开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
RealMediaSplitter.h
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：9k
源码类别：

多媒体编程

开发平台：

Visual C++

RealMediaSplitter.h：源码内容
  1. /* 
  2.  * Copyright (C) 2003-2005 Gabest
  3.  * http://www.gabest.org
  4.  *
  5.  *  This Program is free software; you can redistribute it and/or modify
  6.  *  it under the terms of the GNU General Public License as published by
  7.  *  the Free Software Foundation; either version 2, or (at your option)
  8.  *  any later version.
  9.  *   
  10.  *  This Program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13.  *  GNU General Public License for more details.
  14.  *   
  15.  *  You should have received a copy of the GNU General Public License
  16.  *  along with GNU Make; see the file COPYING.  If not, write to
  17.  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 
  18.  *  http://www.gnu.org/copyleft/gpl.html
  19.  *
  20.  */
  22. #pragma once
  24. #include <atlbase.h>
  25. #include <atlcoll.h>
  26. #include <afxtempl.h>
  27. #include "..BaseSplitterBaseSplitter.h"
  28. #include "....transformBaseVideoFilterBaseVideoFilter.h"
  30. #pragma pack(push, 1)
  32. namespace RMFF
  33. {
  34. typedef struct {union {char id[4]; UINT32 object_id;}; UINT32 size; UINT16 object_version;} ChunkHdr;
  35. typedef struct {UINT32 version, nHeaders;} FileHdr;
  36. typedef struct 
  37. {
  38. UINT32 maxBitRate, avgBitRate;
  39. UINT32 maxPacketSize, avgPacketSize, nPackets;
  40. UINT32 tDuration, tPreroll;
  41. UINT32 ptrIndex, ptrData;
  42. UINT16 nStreams;
  43. enum flags_t {PN_SAVE_ENABLED=1, PN_PERFECT_PLAY_ENABLED=2, PN_LIVE_BROADCAST=4} flags; 
  44. } Properies;
  45. typedef struct 
  46. {
  47. UINT16 stream;
  48. UINT32 maxBitRate, avgBitRate;
  49. UINT32 maxPacketSize, avgPacketSize;
  50. UINT32 tStart, tPreroll, tDuration;
  51. CStringA name, mime;
  52. CArray<BYTE> typeSpecData;
  53. UINT32 width, height;
  54. bool interlaced, top_field_first;
  55. } MediaProperies;
  56. typedef struct {CStringA title, author, copyright, comment;} ContentDesc;
  57. typedef struct {UINT64 pos; UINT32 nPackets, ptrNext;} DataChunk;
  58. typedef struct 
  59. {
  60. UINT16 len, stream;
  61. UINT32 tStart;
  62. UINT8 reserved;
  63. enum flag_t {PN_RELIABLE_FLAG=1, PN_KEYFRAME_FLAG=2} flags; // UINT8
  64. CArray<BYTE> pData;
  65. } MediaPacketHeader;
  66. typedef struct {UINT32 nIndices; UINT16 stream; UINT32 ptrNext;} IndexChunkHeader;
  67. typedef struct {UINT32 tStart, ptrFilePos, packet;} IndexRecord;
  68. }
  70. struct rvinfo
  71. {
  72. DWORD dwSize, fcc1, fcc2; 
  73. WORD w, h, bpp; 
  74. DWORD unk1, fps, type1, type2;
  75. BYTE morewh[14];
  76. void bswap();
  77. };
  79. struct rainfo
  80. {
  81. DWORD fourcc1;             // '.', 'r', 'a', 0xfd
  82. WORD version1;            // 4 or 5
  83. WORD unknown1;            // 00 000
  84. DWORD fourcc2;             // .ra4 or .ra5
  85. DWORD unknown2;            // ???
  86. WORD version2;            // 4 or 5
  87. DWORD header_size;         // == 0x4e
  88. WORD flavor;              // codec flavor id
  89. DWORD coded_frame_size;    // coded frame size
  90. DWORD unknown3;            // big number
  91. DWORD unknown4;            // bigger number
  92. DWORD unknown5;            // yet another number
  93. WORD sub_packet_h;
  94. WORD frame_size;
  95. WORD sub_packet_size;
  96. WORD unknown6;            // 00 00
  97. void bswap();
  98. };
  100. struct rainfo4 : rainfo
  101. {
  102. WORD sample_rate;
  103. WORD unknown8;            // 0
  104. WORD sample_size;
  105. WORD channels;
  106. void bswap();
  107. };
  109. struct rainfo5 : rainfo
  110. {
  111. BYTE unknown7[6];          // 0, srate, 0
  112. WORD sample_rate;
  113. WORD unknown8;            // 0
  114. WORD sample_size;
  115. WORD channels;
  116. DWORD genr;                // "genr"
  117. DWORD fourcc3;             // fourcc
  118. void bswap();
  119. };
  121. #pragma pack(pop)
  123. class CRMFile : public CBaseSplitterFile
  124. {
  125. using CBaseSplitterFile::Read;
  127. HRESULT Init();
  128. void GetDimensions();
  130. public:
  131. CRMFile(IAsyncReader* pAsyncReader, HRESULT& hr);
  133. template<typename T> HRESULT Read(T& var);
  134. HRESULT Read(RMFF::ChunkHdr& hdr);
  135. HRESULT Read(RMFF::MediaPacketHeader& mph, bool fFull = true);
  137. RMFF::FileHdr m_fh;
  138. RMFF::ContentDesc m_cd;
  139. RMFF::Properies m_p;
  140. CAutoPtrList<RMFF::MediaProperies> m_mps;
  141. CAutoPtrList<RMFF::DataChunk> m_dcs;
  142. CAutoPtrList<RMFF::IndexRecord> m_irs;
  144. typedef struct {CStringA name, data;} subtitle;
  145. CList<subtitle> m_subs;
  147. int GetMasterStream();
  148. };
  150. class CRealMediaSplitterOutputPin : public CBaseSplitterOutputPin
  151. {
  152. private:
  153. typedef struct {CArray<BYTE> data; DWORD offset;} segment;
  155. class CSegments : public CAutoPtrList<segment>, public CCritSec
  156. {
  157. public:
  158. REFERENCE_TIME rtStart; 
  159. bool fDiscontinuity, fSyncPoint, fMerged;
  160. void Clear()
  161. {
  162. CAutoLock cAutoLock(this);
  163. rtStart = 0;
  164. fDiscontinuity = fSyncPoint = fMerged = false;
  165. RemoveAll();
  166. }
  167. } m_segments;
  169. CCritSec m_csQueue;
  171. HRESULT DeliverSegments();
  173. protected:
  174. HRESULT DeliverPacket(CAutoPtr<Packet> p);
  176. public:
  177. CRealMediaSplitterOutputPin(CArray<CMediaType>& mts, LPCWSTR pName, CBaseFilter* pFilter, CCritSec* pLock, HRESULT* phr);
  178. virtual ~CRealMediaSplitterOutputPin();
  180. HRESULT DeliverEndFlush();
  181. };
  183. [uuid("E21BE468-5C18-43EB-B0CC-DB93A847D769")]
  184. class CRealMediaSplitterFilter : public CBaseSplitterFilter
  185. {
  186. protected:
  187. CAutoPtr<CRMFile> m_pFile;
  188. HRESULT CreateOutputs(IAsyncReader* pAsyncReader);
  190. bool DemuxInit();
  191. void DemuxSeek(REFERENCE_TIME rt);
  192. bool DemuxLoop();
  194. POSITION m_seekpos;
  195. UINT32 m_seekpacket;
  196. UINT64 m_seekfilepos;
  198. public:
  199. CRealMediaSplitterFilter(LPUNKNOWN pUnk, HRESULT* phr);
  200. virtual ~CRealMediaSplitterFilter();
  202. // IKeyFrameInfo
  204. STDMETHODIMP_(HRESULT) GetKeyFrameCount(UINT& nKFs);
  205. STDMETHODIMP_(HRESULT) GetKeyFrames(const GUID* pFormat, REFERENCE_TIME* pKFs, UINT& nKFs);
  206. };
  208. [uuid("765035B3-5944-4A94-806B-20EE3415F26F")]
  209. class CRealMediaSourceFilter : public CRealMediaSplitterFilter
  210. {
  211. public:
  212. CRealMediaSourceFilter(LPUNKNOWN pUnk, HRESULT* phr);
  213. };
  215. ////////////
  217. [uuid("238D0F23-5DC9-45A6-9BE2-666160C324DD")]
  218. class CRealVideoDecoder : public CBaseVideoFilter
  219. {
  220. typedef HRESULT (WINAPI *PRVCustomMessage)(void*, DWORD);
  221. typedef HRESULT (WINAPI *PRVFree)(DWORD);
  222. typedef HRESULT (WINAPI *PRVHiveMessage)(void*, DWORD);
  223. typedef HRESULT (WINAPI *PRVInit)(void*, DWORD* dwCookie);
  224. typedef HRESULT (WINAPI *PRVTransform)(BYTE*, BYTE*, void*, void*, DWORD);
  226. PRVCustomMessage RVCustomMessage;
  227. PRVFree RVFree;
  228. PRVHiveMessage RVHiveMessage;
  229. PRVInit RVInit;
  230. PRVTransform RVTransform;
  232. HMODULE m_hDrvDll;
  233. DWORD m_dwCookie;
  235. HRESULT InitRV(const CMediaType* pmt);
  236. void FreeRV();
  238. REFERENCE_TIME m_tStart;
  240. void Resize(BYTE* pIn, DWORD wi, DWORD hi, BYTE* pOut, DWORD wo, DWORD ho);
  241. void ResizeWidth(BYTE* pIn, DWORD wi, DWORD hi, BYTE* pOut, DWORD wo, DWORD ho);
  242. void ResizeHeight(BYTE* pIn, DWORD wi, DWORD hi, BYTE* pOut, DWORD wo, DWORD ho);
  243. void ResizeRow(BYTE* pIn, DWORD wi, DWORD dpi, BYTE* pOut, DWORD wo, DWORD dpo);
  245. CAutoVectorPtr<BYTE> m_pI420, m_pI420Tmp;
  247. public:
  248. CRealVideoDecoder(LPUNKNOWN lpunk, HRESULT* phr);
  249. virtual ~CRealVideoDecoder();
  251. HRESULT Transform(IMediaSample* pIn);
  252. HRESULT CheckInputType(const CMediaType* mtIn);
  253. HRESULT CheckTransform(const CMediaType* mtIn, const CMediaType* mtOut);
  255. HRESULT StartStreaming();
  256. HRESULT StopStreaming();
  258. HRESULT NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate);
  260. DWORD m_timestamp;
  261. bool m_fDropFrames;
  262. HRESULT AlterQuality(Quality q);
  263. };
  265. [uuid("941A4793-A705-4312-8DFC-C11CA05F397E")]
  266. class CRealAudioDecoder : public CTransformFilter
  267. {
  268. typedef HRESULT (WINAPI *PCloseCodec)(DWORD);
  269. typedef HRESULT (WINAPI *PDecode)(DWORD,BYTE*,long,BYTE*,long*,long);
  270. typedef HRESULT (WINAPI *PFlush)(DWORD,DWORD,DWORD);
  271. typedef HRESULT (WINAPI *PFreeDecoder)(DWORD);
  272. typedef void* (WINAPI *PGetFlavorProperty)(void*,DWORD,DWORD,int*);
  273. typedef HRESULT (WINAPI *PInitDecoder)(DWORD, void*);
  274. typedef HRESULT (WINAPI *POpenCodec)(void*);
  275. typedef HRESULT (WINAPI *POpenCodec2)(void*, const char*);
  276. typedef HRESULT (WINAPI *PSetFlavor)(DWORD, WORD);
  277. typedef void (WINAPI *PSetDLLAccessPath)(const char*);
  278. typedef void (WINAPI *PSetPwd)(DWORD, const char*);
  280. PCloseCodec RACloseCodec;
  281. PDecode RADecode;
  282. PFlush RAFlush;
  283. PFreeDecoder RAFreeDecoder;
  284. PGetFlavorProperty RAGetFlavorProperty;
  285. PInitDecoder RAInitDecoder;
  286. POpenCodec RAOpenCodec;
  287. POpenCodec2 RAOpenCodec2;
  288. PSetFlavor RASetFlavor;
  289. PSetDLLAccessPath RASetDLLAccessPath;
  290. PSetPwd RASetPwd;
  292. CStringA m_dllpath;
  293. HMODULE m_hDrvDll;
  294. DWORD m_dwCookie;
  296. HRESULT InitRA(const CMediaType* pmt);
  297. void FreeRA();
  299. REFERENCE_TIME m_tStart;
  301. rainfo m_rai;
  302. CAutoVectorPtr<BYTE> m_buff;
  303. int m_bufflen;
  304. REFERENCE_TIME m_rtBuffStart;
  305. bool m_fBuffDiscontinuity;
  307. public:
  308. CRealAudioDecoder(LPUNKNOWN lpunk, HRESULT* phr);
  309. virtual ~CRealAudioDecoder();
  311. HRESULT Receive(IMediaSample* pIn);
  312. HRESULT CheckInputType(const CMediaType* mtIn);
  313. HRESULT CheckTransform(const CMediaType* mtIn, const CMediaType* mtOut);
  314. HRESULT DecideBufferSize(IMemAllocator* pAllocator, ALLOCATOR_PROPERTIES* pProperties);
  315. HRESULT GetMediaType(int iPosition, CMediaType* pMediaType);
  317. HRESULT StartStreaming();
  318. HRESULT StopStreaming();
  320.     HRESULT EndOfStream();
  321.     HRESULT BeginFlush();
  322.     HRESULT EndFlush();
  323.     HRESULT NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate);
  324. };