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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
matroska.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：15k
源码类别：

Windows CE

开发平台：

C/C++

matroska.c：源码内容
  1. /*****************************************************************************
  2.  *
  3.  * This program is free software ; you can redistribute it and/or modify
  4.  * it under the terms of the GNU General Public License as published by
  5.  * the Free Software Foundation; either version 2 of the License, or
  6.  * (at your option) any later version.
  7.  *
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11.  * GNU General Public License for more details.
  12.  *
  13.  * You should have received a copy of the GNU General Public License
  14.  * along with this program; if not, write to the Free Software
  15.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16.  *
  17.  * $Id: matroska.c 548 2006-01-08 22:41:57Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../common/common.h"
  25. #include "matroska.h"
  26. #include "MatroskaParser/MatroskaParser.h"
  28. typedef struct matroska
  29. {
  30. format_base Format;
  31. InputStream IO;
  32. MatroskaFile* File;
  34. } matroska;
  36. #define MK(p) ((matroska*)((char*)(p)-OFS(matroska,IO)))
  38. static void AudioTrackMS(format_stream* s,TrackInfo* Info)
  39. {
  40. s->Fragmented = 1;
  41. Format_WaveFormatMem(s,Info->CodecPrivate,Info->CodecPrivateSize);
  42. }
  44. static void AudioTrack(format_stream* s,TrackInfo* Info,int Format,bool_t PacketBased)
  45. {
  46. PacketFormatClear(&s->Format);
  47. s->Format.Type = PACKET_AUDIO;
  48. s->Format.Format.Audio.Format = Format;
  49. s->Format.Format.Audio.Channels = Info->Audio.Channels;
  50. s->Format.Format.Audio.SampleRate = mkv_TruncFloat(Info->Audio.SamplingFreq);
  51. s->Format.Format.Audio.Bits = Info->Audio.BitDepth;
  52. s->Fragmented = !PacketBased;
  53. if (PacketBased)
  54. s->Format.Format.Audio.Flags |= PCM_PACKET_BASED;
  55. PacketFormatDefault(&s->Format);
  56. }
  58. static void SetPacketRate(format_stream* s,TrackInfo* Info)
  59. {
  60. if (Info->DefaultDuration)
  61. {
  62. longlong v = Info->DefaultDuration;
  63. s->Format.PacketRate.Num = 1000000000;
  64. while (v > MAX_INT)
  65. {
  66. v >>= 1;
  67. s->Format.PacketRate.Num >>= 1;
  68. }
  69. s->Format.PacketRate.Den = (int)v;
  70.    }
  71. }
  73. static NOINLINE void VideoAspect(format_stream* s,TrackInfo* Info)
  74. {
  75. if (Info->Video.PixelWidth>0 && Info->Video.PixelHeight>0 &&
  76. Info->Video.DisplayWidth>0 && Info->Video.DisplayHeight>0)
  77. s->Format.Format.Video.Aspect = (int)((ASPECT_ONE*(int64_t)Info->Video.DisplayWidth*(int64_t)Info->Video.PixelHeight)/
  78. ((int64_t)Info->Video.PixelWidth*(int64_t)Info->Video.DisplayHeight));
  79. }
  81. static NOINLINE void VideoTrackMS(format_stream* s,TrackInfo* Info)
  82. {
  83. Format_BitmapInfoMem(s,Info->CodecPrivate,Info->CodecPrivateSize);
  84. VideoAspect(s,Info);
  85. SetPacketRate(s,Info);
  86. }
  88. static NOINLINE void SubtitleTrack(format_stream* s,int FourCC)
  89. {
  90. PacketFormatClear(&s->Format);
  91. s->Format.Type = PACKET_SUBTITLE;
  92. s->Format.Format.Subtitle.FourCC = FourCC;
  93. }
  95. static NOINLINE void VideoTrack(format_stream* s,TrackInfo* Info,int FourCC)
  96. {
  97. PacketFormatClear(&s->Format);
  98. s->Format.Type = PACKET_VIDEO;
  99. s->Format.Format.Video.Pixel.Flags = PF_FOURCC;
  100. s->Format.Format.Video.Pixel.FourCC = FourCC;
  101. s->Format.Format.Video.Width = Info->Video.PixelWidth;
  102. s->Format.Format.Video.Height = Info->Video.PixelHeight;
  103. s->Format.Format.Video.Aspect = ASPECT_ONE;
  104. VideoAspect(s,Info);
  105. SetPacketRate(s,Info);
  106. }
  108. static NOINLINE void AddChapter(pin* Comment,ulonglong Start,struct ChapterDisplay* p,int No)
  109. {
  110. tchar_t s[256];
  112. stprintf_s(s,TSIZEOF(s),T("CHAPTER%02dNAME="),No);
  113. UTF8ToTcs(s+tcslen(s),TSIZEOF(s)-tcslen(s),p->String);
  114. Comment->Node->Set(Comment->Node,Comment->No,s,sizeof(s));
  116. BuildChapter(s,TSIZEOF(s),No,Start,1000000);
  117. Comment->Node->Set(Comment->Node,Comment->No,s,sizeof(s));
  118. }
  120. static NOINLINE void AddAttachment(pin* Comment,Attachment *At) 
  121. {
  122. tchar_t MimeType[32];
  123. StrToTcs(MimeType,TSIZEOF(MimeType),At->MimeType);
  125. if (tcsnicmp(MimeType,T("image"),5)==0)
  126. {
  127. tchar_t s[256];
  128. stprintf_s(s,TSIZEOF(s),T("%s=:%d:%d:%s"),PlayerComment(COMMENT_COVER),(int)At->Position,(int)At->Length,MimeType);
  129. Comment->Node->Set(Comment->Node,Comment->No,s,sizeof(s));
  130. }
  131. }
  133. static int AddChapters(pin* Comment,Chapter *Ch,int No) 
  134. {
  135. uint32_t i,j;
  137. if (Ch)
  138. for (i=0;i<Ch->nChildren;++i) 
  139. {
  140. for (j=0;j<Ch->Children[i].nDisplay;++i)
  141. if (Ch->Children[i].Display[j].String)
  142. {
  143. AddChapter(Comment,Ch->Children[i].Start,
  144. &Ch->Children[i].Display[j],No++);
  145. break;
  146. }
  148. No = AddChapters(Comment,&Ch->Children[i],No);
  149. }
  151. return No;
  152. }
  154. static void AddComment(pin* Comment,tchar_t* Name,char* Value) 
  155. {
  156. if (Comment->Node && Value)
  157. {
  158. tchar_t s[256];
  159. tcscpy_s(s,TSIZEOF(s),Name);
  160. tcscat_s(s,TSIZEOF(s),T("="));
  161. UTF8ToTcs(s+tcslen(s),TSIZEOF(s)-tcslen(s),Value);
  162. Comment->Node->Set(Comment->Node,Comment->No,s,sizeof(s));
  163. }
  164. }
  166. static void BuildConfig(format_stream* s,const char* CodecID,int OutputFreq)
  167. {
  168. static const int Rates[12] = {96000,88200,64000,48000,44100,32000,24000,22050,16000,12000,11025,8000};
  169. int Rate;
  170. int Profile;
  171. uint8_t* Config;
  172. int Len = 2;
  173. bool_t SBR = 0;
  175. if (OutputFreq > s->Format.Format.Audio.SampleRate)
  176. {
  177. if (OutputFreq > 24000)
  178. OutputFreq >>= 1;
  179. s->Format.Format.Audio.SampleRate = OutputFreq;
  180. SBR = 1;
  181. }
  183. for (Rate=0;Rate<11;++Rate)
  184. if (s->Format.Format.Audio.SampleRate >= Rates[Rate])
  185. break;
  187. if (strcmp(CodecID+12, "MAIN")==0)
  188. Profile = 1;
  189. else if (strcmp(CodecID+12, "SSR")==0)
  190. Profile = 3;
  191. else if (strcmp(CodecID+12, "LTP")==0)
  192. Profile = 4;
  193. else if (strcmp(CodecID+12, "SBR")==0)
  194. Profile = 5;
  195. else if (strcmp(CodecID+12, "LC/SBR")==0 || SBR)
  196. {
  197. Profile = 2;
  198. Len = 5;
  199. }
  200. else
  201. Profile = 2; //assuming LC
  203. if (PacketFormatExtra(&s->Format,Len))
  204. {
  205. Config = (uint8_t*)s->Format.Extra;
  206.     Config[0] = (uint8_t)(Profile << 3);
  207.     Config[0] |= (uint8_t)(Rate >> 1);
  208.     Config[1] = (uint8_t)(Rate << 7);
  209.     Config[1] |= (uint8_t)(s->Format.Format.Audio.Channels << 3);
  211. if (Len>2)
  212. {
  213. if (s->Format.Format.Audio.SampleRate <= 24000)
  214. s->Format.Format.Audio.SampleRate <<= 1;
  216. for (Rate=0;Rate<11;++Rate)
  217. if (s->Format.Format.Audio.SampleRate >= Rates[Rate])
  218. break;
  220. Config[2] = 0x56;
  221. Config[3] = 0xE5;
  222. Config[4] = 0x80;
  223. Config[4] |= (uint8_t)(Rate << 3);
  224. }
  225. }
  226. }
  228. static int Init(matroska* p)
  229. {
  230. unsigned n,Count;
  231. SegmentInfo* Info;
  233. p->File = mkv_Open(&p->IO,NULL,0);
  234. if (!p->File)
  235. return ERR_INVALID_DATA;
  237. Info = mkv_GetFileInfo(p->File);
  238. if (Info)
  239. p->Format.Duration = (tick_t)((Info->Duration * TICKSPERSEC) / 1000000000);
  241. Count = mkv_GetNumTracks(p->File);
  242. for (n=0;n<Count;++n)
  243. {
  244. format_stream* s = Format_AddStream(&p->Format,sizeof(format_stream));
  245. if (s)
  246. {
  247. TrackInfo *Info = mkv_GetTrackInfo(p->File,n);
  248. if (Info)
  249. {
  250. int CodecPrivateSize = Info->CodecPrivateSize;
  252. if (strcmp(Info->CodecID, "V_MS/VFW/FOURCC")==0)
  253. {
  254. VideoTrackMS(s,Info);
  255. CodecPrivateSize = 0;
  256. }
  257. else if (strncmp(Info->CodecID, "V_REAL/RV", 9)==0)
  258. VideoTrack(s,Info,LOAD32LE(Info->CodecID+7));
  259. else if (strncmp(Info->CodecID, "V_MPEG4/ISO/AVC", 14)==0)
  260. {
  261. VideoTrack(s,Info,FOURCC('A','V','C','1'));
  262. s->Format.Format.Video.Pixel.Flags |= PF_PTS;
  263. }
  264. else if (strncmp(Info->CodecID, "V_MPEG4/ISO", 11)==0)
  265. VideoTrack(s,Info,FOURCC('M','P','4','V'));
  266. else if (strcmp(Info->CodecID, "V_MPEG4/MS/V3")==0)
  267. VideoTrack(s,Info,FOURCC('M','P','4','3'));
  268. else if (strcmp(Info->CodecID, "V_MPEG1")==0 || strcmp(Info->CodecID, "V_MPEG2")==0)
  269. VideoTrack(s,Info,FOURCC('M','P','E','G'));
  270. else if (strcmp(Info->CodecID, "V_MJPEG")==0)
  271. VideoTrack(s,Info,FOURCC('M','J','P','G'));
  272. else if (strcmp(Info->CodecID, "A_MPEG/L3")==0)
  273. AudioTrack(s,Info,AUDIOFMT_MP3,0);
  274. else if (strcmp(Info->CodecID, "A_MPEG/L2")==0 || strcmp(Info->CodecID, "A_MPEG/L1")==0)
  275. AudioTrack(s,Info,AUDIOFMT_MP2,0);
  276. else if (strcmp(Info->CodecID, "A_PCM/INT/LIT")==0)
  277. AudioTrack(s,Info,AUDIOFMT_PCM,0);
  278. else if (strstr(Info->CodecID, "A_AC3")!=NULL || strcmp(Info->CodecID, "A_DTS")==0)
  279. AudioTrack(s,Info,AUDIOFMT_A52,0);
  280. else if (strstr(Info->CodecID, "A_AAC")!=NULL)
  281. {
  282. AudioTrack(s,Info,AUDIOFMT_AAC,1);
  283. if (!CodecPrivateSize)
  284. BuildConfig(s,Info->CodecID,mkv_TruncFloat(Info->Audio.OutputSamplingFreq));
  285. }
  286. else if (strcmp(Info->CodecID, "A_VORBIS")==0)
  287. AudioTrack(s,Info,AUDIOFMT_VORBIS_PACKET,1);
  288. else if (strcmp(Info->CodecID, "A_QUICKTIME/QDM2")==0)
  289. AudioTrack(s,Info,AUDIOFMT_QDESIGN2,1);
  290. else if (strcmp(Info->CodecID, "A_TTA1")==0)
  291. AudioTrack(s,Info,AUDIOFMT_TTA,1);
  292. else if (strcmp(Info->CodecID, "A_MS/ACM")==0)
  293. {
  294. AudioTrackMS(s,Info);
  295. CodecPrivateSize = 0;
  296. }
  297. else if (strcmp(Info->CodecID, "S_TEXT/UTF8")==0)
  298. SubtitleTrack(s,SUBTITLE_UTF8);
  299. else if (strcmp(Info->CodecID, "S_TEXT/SSA")==0)
  300. SubtitleTrack(s,SUBTITLE_SSA);
  301. else if (strcmp(Info->CodecID, "S_TEXT/ASS")==0)
  302. SubtitleTrack(s,SUBTITLE_ASS);
  303. else if (strcmp(Info->CodecID, "S_TEXT/USF")==0)
  304. SubtitleTrack(s,SUBTITLE_USF);
  306. if (CodecPrivateSize && PacketFormatExtra(&s->Format,CodecPrivateSize))
  307. memcpy(s->Format.Extra,Info->CodecPrivate,s->Format.ExtraLength);
  308. }
  309. Format_PrepairStream(&p->Format,s);
  311. AddComment(&s->Comment,T("TITLE"),Info->Name);
  312. AddComment(&s->Comment,T("LANGUAGE"),Info->Language);
  313. }
  314. }
  316. if (p->Format.StreamCount)
  317. {
  318. pin* Comment = &p->Format.Streams[0]->Comment;
  319. Tag* Tags;
  320. Chapter* Ch;
  321. Attachment* At;
  323. mkv_GetTags(p->File,&Tags,&Count);
  325. if (Tags && Comment->Node)
  326. for (n=0;n<Count;++n,++Tags)
  327. {
  328. uint32_t i;
  329. for (i=0;i<Tags->nSimpleTags;++i)
  330. {
  331. tchar_t s[256];
  332. UTF8ToTcs(s,TSIZEOF(s),Tags->SimpleTags[i].Name);
  333. tcscat_s(s,TSIZEOF(s),T("="));
  334. UTF8ToTcs(s+tcslen(s),TSIZEOF(s)-tcslen(s),Tags->SimpleTags[i].Value);
  335. Comment->Node->Set(Comment->Node,Comment->No,s,sizeof(s));
  336. }
  337. }
  339. mkv_GetAttachments(p->File,&At,&Count);
  340. if (Count>0)
  341. for (n=0;n<Count;++n)
  342. AddAttachment(Comment,At+n);
  344. mkv_GetChapters(p->File,&Ch,&Count);
  345. if (Count>0 && Info)
  346. AddChapters(Comment,Ch,1);
  347. }
  349. mkv_SetTrackMask(p->File,0);
  351. p->Format.HeaderLoaded = 1;
  352. return ERR_NONE;
  353. }
  355. static void Done(matroska* p)
  356. {
  357. if (p->File)
  358. {
  359. mkv_Close(p->File);
  360. p->File = NULL;
  361. }
  362. }
  364. static int ReadPacket(matroska* p, format_reader* Reader, format_packet* Packet)
  365. {
  366. ulonglong Start,End;
  367. void* Ref;
  368. ulonglong Pos;
  369. unsigned int Flags,Track,Size;
  370. int Result = mkv_ReadFrame(p->File,0,&Track,&Start,&End,&Pos,&Size,&Ref,&Flags);
  372. if (Result == EOF)
  373. return ERR_END_OF_FILE;
  375. if (Result != 0)
  376. return ERR_INVALID_DATA;
  378. Packet->Data = (format_ref*)Ref;
  379. Packet->Key = (Flags & FRAME_KF) != 0;
  380. Packet->Stream = p->Format.Streams[Track];
  382. if (!(Flags & FRAME_UNKNOWN_START))
  383. {
  384. Packet->RefTime = (tick_t)((Start * TICKSPERSEC) / 1000000000);
  385. if (Packet->Stream->Format.Type == PACKET_SUBTITLE && !(Flags & FRAME_UNKNOWN_END))
  386. Packet->EndRefTime = (tick_t)((End * TICKSPERSEC) / 1000000000);
  387. }
  389. return ERR_NONE;
  390. }
  392. static int Seek(matroska* p, tick_t Time, filepos_t FilePos,bool_t PrevKey)
  393. {
  394. if (Time < 0 && FilePos >= 0 && p->Format.Duration > 0 && p->Format.FileSize > 0)
  395. Time = Scale(FilePos, p->Format.Duration, p->Format.FileSize);
  397. if (Time >= 0)
  398. {
  399. p->Format.SyncRead = 0; // don't use partial buffers
  400. mkv_Seek(p->File,((ulonglong)Time * 1000000000 + (TICKSPERSEC/2))/TICKSPERSEC,PrevKey?MKVF_SEEK_TO_PREV_KEYFRAME:0);
  402. Format_AfterSeek(&p->Format);
  403. return ERR_NONE;
  404. }
  405. return ERR_NOT_SUPPORTED;
  406. }
  408. static int Read(struct InputStream *cc,ulonglong pos,void *buffer,int count)
  409. {
  410. format_reader* Reader = &MK(cc)->Format.Reader[0];
  412. if (Reader->FilePos != pos && Reader->Seek(Reader,(filepos_t)pos,SEEK_SET) != ERR_NONE)
  413. return -1;
  415. return Reader->Read(Reader,buffer,count);
  416. }
  418. static longlong Scan(struct InputStream *cc,ulonglong start,unsigned signature)
  419. {
  420. format_reader* Reader = &MK(cc)->Format.Reader[0];
  421. unsigned v = ~signature;
  422. int ch;
  424. if (Reader->FilePos != start && Reader->Seek(Reader,(filepos_t)start,SEEK_SET) != ERR_NONE)
  425. return -1;
  427. while ((ch = Reader->Read8(Reader)) >= 0)
  428. {
  429. v = ((v << 8) | ch) & 0xFFFFFFFF;
  430. if (v == signature)
  431. return Reader->FilePos - 4;
  432. }
  434. return -1;
  435. }
  437. static unsigned GetSize(struct InputStream *cc)
  438. {
  439. return MK(cc)->Format.Reader->BufferAvailable;
  440. }
  442. static const char* GetError(struct InputStream *cc)
  443. {
  444. return "";
  445. }
  447. static void* MemAlloc(struct InputStream *cc,size_t size)
  448. {
  449. return malloc(size);
  450. }
  452. static void* MemReAlloc(struct InputStream *cc,void *mem,size_t newsize)
  453. {
  454. return realloc(mem,newsize);
  455. }
  457. static void MemFree(struct InputStream *cc,void *mem)
  458. {
  459. free(mem);
  460. }
  462. static int Progress(struct InputStream *cc,ulonglong cur,ulonglong max)
  463. {
  464. return 1;
  465. }
  467. static int IOReadCh(struct InputStream *IO)
  468. {
  469. return MK(IO)->Format.Reader->Read8(MK(IO)->Format.Reader);
  470. }
  472. static int IORead(struct InputStream *IO,void *buffer,int count)
  473. {
  474. return MK(IO)->Format.Reader->Read(MK(IO)->Format.Reader,buffer,count);
  475. }
  477. static void IOSeek(struct InputStream *IO,longlong where,int how)
  478. {
  479.     MK(IO)->Format.Reader->Seek(MK(IO)->Format.Reader,(filepos_t)where,how);
  480. }
  482. static longlong IOTell(struct InputStream *IO)
  483. {
  484. return MK(IO)->Format.Reader->FilePos;
  485. }
  487. static void* IOMakeRef(struct InputStream *IO,int count)
  488. {
  489. return MK(IO)->Format.Reader->ReadAsRef(MK(IO)->Format.Reader,count);
  490. }
  492. static void IOReleaseRef(struct InputStream *IO,void* ref)
  493. {
  494. Format_ReleaseRef(&MK(IO)->Format,(format_ref*)ref);
  495. }
  497. static int Create(matroska* p)
  498. {
  499. p->Format.Init = (fmtfunc)Init;
  500. p->Format.Done = (fmtvoid)Done;
  501. p->Format.Seek = (fmtseek)Seek;
  502. p->Format.ReadPacket = (fmtreadpacket) ReadPacket;
  503.    p->IO.read = Read;
  504. p->IO.scan = Scan;
  505. p->IO.getsize = GetSize;
  506. p->IO.geterror = GetError;
  507. p->IO.memalloc = MemAlloc;
  508. p->IO.memrealloc = MemReAlloc;
  509. p->IO.memfree = MemFree;
  510. p->IO.progress = Progress;
  511. p->IO.ioread = IORead;
  512. p->IO.ioreadch = IOReadCh;
  513. p->IO.ioseek = IOSeek;
  514. p->IO.iotell = IOTell;
  515. p->IO.makeref = IOMakeRef;
  516. p->IO.releaseref = IOReleaseRef;
  517. return ERR_NONE;
  518. }
  520. static const nodedef Matroska = 
  521. {
  522. sizeof(matroska),
  523. MATROSKA_ID,
  524. FORMATBASE_CLASS,
  525. PRI_DEFAULT,
  526. (nodecreate)Create,
  527. };
  529. void Matroska_Init()
  530. {
  531. NodeRegisterClass(&Matroska);
  532. }
  534. void Matroska_Done()
  535. {
  536. NodeUnRegisterClass(MATROSKA_ID);
  537. }