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

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

Windows CE

开发平台：

C/C++

mov.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: mov.c 607 2006-01-22 20:58:29Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../common/common.h"
  25. #include "../common/zlib/zlib.h"
  26. #include "mov.h"
  27. #include "movpal.h"
  29. #define MP4_INVALID_AUDIO_TYPE          0x00
  30. #define MP4_MPEG1_AUDIO_TYPE            0x6B
  31. #define MP4_MPEG2_AUDIO_TYPE            0x69
  32. #define MP4_MPEG2_AAC_MAIN_AUDIO_TYPE   0x66
  33. #define MP4_MPEG2_AAC_LC_AUDIO_TYPE     0x67
  34. #define MP4_MPEG2_AAC_SSR_AUDIO_TYPE    0x68
  35. #define MP4_MPEG4_AUDIO_TYPE            0x40
  36. #define MP4_PRIVATE_AUDIO_TYPE          0xE0
  38. #define MP4_INVALID_VIDEO_TYPE          0x00
  39. #define MP4_MPEG1_VIDEO_TYPE            0x6A
  40. #define MP4_MPEG2_SIMPLE_VIDEO_TYPE     0x60
  41. #define MP4_MPEG2_MAIN_VIDEO_TYPE       0x61
  42. #define MP4_MPEG2_SNR_VIDEO_TYPE        0x62
  43. #define MP4_MPEG2_SPATIAL_VIDEO_TYPE    0x63
  44. #define MP4_MPEG2_HIGH_VIDEO_TYPE       0x64
  45. #define MP4_MPEG2_442_VIDEO_TYPE        0x65
  46. #define MP4_MPEG4_VIDEO_TYPE            0x20
  47. #define MP4_JPEG_VIDEO_TYPE             0x6C
  49. typedef struct mp4stsc
  50. {
  51. int FirstChunk;
  52. int Samples;
  54. } mp4stsc;
  56. typedef struct mp4stts
  57. {
  58. int Count;
  59. int Delta;
  61. } mp4stts;
  63. typedef struct mp4streampos
  64. {
  65. int CurrentTime;
  66. int SampleNo;
  67. int SamplesLeft;
  69. int STSSDelta;
  70. int STSSValue;
  71. int STSZDelta;
  72. int STSZValue;
  73. int STTSLeft;
  75. const uint8_t* STSSPos;
  76. const uint8_t* STSSEnd;
  77. const mp4stts* STTSPos;
  78. const mp4stsc* STSCPos;
  79. const uint8_t* STSZPos;
  80. const uint8_t* STSZEnd;
  81. const int* STCOPos;
  83. } mp4streampos;
  85. typedef struct mp4stream
  86. {
  87. format_stream Stream;
  89. tick_t Duration;
  90. int TimeScale;
  91. int SamplesPerPacket;
  92. int BytesPerPacket;
  93. bool_t AllKey;
  95. filepos_t OffsetMin;
  96. filepos_t OffsetMax;
  97. int StartTime;
  99. mp4streampos Pos;
  101. int STSZDef; //default sample size
  102. array STSS; //key samples (compressed)
  103. array STSZ; //sample size (compressed)
  104. array STTS; //sample duration (mp4stts) + delimiter
  105. array STSC; //sample per chunk (mp4stsc) + delimiter
  106. array STCO; //chunk offset (int) + delimiter
  108. } mp4stream;
  110. typedef struct mp4
  111. {
  112. format_base Format;
  114. uint32_t Type;
  115. uint32_t CompressType;
  116. boolmem_t ErrorShowed;
  117. boolmem_t MOOVFound;
  118. boolmem_t RMRAFound;
  119. int TimeScale;
  121. mp4stream* Track;
  122. tchar_t Meta[32];
  124. } mp4;
  126. typedef void (*mp4atomfunc)(mp4* p, filepos_t EndOfAtom);
  128. typedef struct mp4atomtable
  129. {
  130. uint32_t Atom;
  131. mp4atomfunc Func;
  133. } mp4atomtable;
  135. typedef struct mp4atom
  136. {
  137. uint32_t Atom;
  138. filepos_t EndOfAtom;
  140. } mp4atom;
  143. static int ReadVersion(format_reader* Reader)
  144. {
  145. int Ver = Reader->Read8(Reader);
  146. Reader->Skip(Reader,3); //flags;
  147. return Ver;
  148. }
  150. static bool_t ReadAtom(format_reader* Reader, mp4atom* Atom)
  151. {
  152. filepos_t Size;
  153. Atom->Atom = 0;
  154. Atom->EndOfAtom = Reader->FilePos;
  155. Size = Reader->ReadBE32(Reader);
  156. Reader->Read(Reader,&Atom->Atom,sizeof(Atom->Atom));
  157. if (Size == 1)
  158. Size = (filepos_t)Reader->ReadBE64(Reader);
  159. Atom->EndOfAtom += Size;
  160. return Size >= 8;
  161. }
  163. static void ReadSubAtoms(mp4* p,filepos_t EndOfAtom);
  164. static INLINE format_reader* Reader(mp4* p) { return p->Format.Reader; }
  166. static void ReadFTYP(mp4* p, filepos_t EndOfAtom)
  167. {
  168. p->Type = 0;
  169. Reader(p)->Read(Reader(p),&p->Type,sizeof(p->Type));
  170. }
  172. static void ReadRMRA(mp4* p, filepos_t EndOfAtom)
  173. {
  174. p->RMRAFound = 1;
  175. ReadSubAtoms(p,EndOfAtom);
  176. p->RMRAFound = 0;
  177. }
  179. static void ReadMOOV(mp4* p, filepos_t EndOfAtom)
  180. {
  181. p->MOOVFound = 1;
  182. ReadSubAtoms(p,EndOfAtom);
  183. }
  185. static INLINE const uint8_t* ReadValue(const uint8_t* p,const uint8_t* pe,int* Delta,int* Value,bool_t Alternate)
  186. {
  187. if (p>=pe)
  188. *Value = 0;
  189. else
  190. {
  191. int i = *(int8_t*)(p++);
  192. while (!(i & 1))
  193. i = (i<<7) | *(p++);
  194. i >>= 1;
  195. if (Alternate) *Delta = -*Delta;
  196. *Delta += i;
  197. *Value += *Delta;
  198. }
  199. return p;
  200. }
  202. static void WriteValue(array* Array,int* Delta,int* Value,int i,bool_t Alternate)
  203. {
  204. uint8_t Data[8];
  205. int n,Flag = 1;
  207. i -= *Value;
  208. *Value += i;
  209. if (Alternate) *Delta = -*Delta;
  210. i -= *Delta;
  211. *Delta += i;
  213. for (n=7;i>=64||i<-64;i>>=7,--n)
  214. {
  215. Data[n] = (uint8_t)(((i & 127) << 1)|Flag);
  216. Flag = 0;
  217. }
  218. Data[n] = (uint8_t)((i << 1)|Flag);
  219. ArrayAppend(Array,Data+n,8-n,1024);
  220. }
  222. static NOINLINE void NextKey(mp4streampos* Pos)
  223. {
  224. if (!Pos->STSSPos)
  225. ++Pos->STSSValue;
  226. else
  227. Pos->STSSPos = ReadValue(Pos->STSSPos,Pos->STSSEnd,&Pos->STSSDelta,&Pos->STSSValue,0);
  228. }
  230. static int NextSample(mp4stream* Stream,mp4streampos* Pos)
  231. {
  232. if (Stream->Stream.Fragmented || Stream->Stream.ForceMerge)
  233. {
  234. int n,i;
  235. for (n=Pos->SamplesLeft;n>0;n-=i)
  236. {
  237. if (!Pos->STTSLeft)
  238. Pos->STTSLeft = (++Pos->STTSPos)->Count;
  239. i = min(Pos->STTSLeft,n);
  240. Pos->STTSLeft -= i;
  241. Pos->CurrentTime += i*Pos->STTSPos->Delta;
  242. }
  244. n = Pos->SamplesLeft;
  245. Pos->SampleNo += n;
  246. Pos->SamplesLeft = 0;
  248. if (Stream->STSZDef==1 && Stream->SamplesPerPacket && Stream->BytesPerPacket)
  249. return Scale(n,Stream->BytesPerPacket,Stream->SamplesPerPacket);
  251. return Stream->STSZDef*n;
  252. }
  253. else
  254. {
  255. if (!Pos->STTSLeft)
  256. Pos->STTSLeft = (++Pos->STTSPos)->Count;
  257. --Pos->STTSLeft;
  258. ++Pos->SampleNo;
  259. --Pos->SamplesLeft;
  260. Pos->CurrentTime += Pos->STTSPos->Delta;
  261. if (!Stream->STSZDef)
  262. Pos->STSZPos = ReadValue(Pos->STSZPos,Pos->STSZEnd,&Pos->STSZDelta,&Pos->STSZValue,1);
  264. return Pos->STSZValue;
  265. }
  266. }
  268. static void NextChunk(mp4stream* Stream,mp4streampos* Pos)
  269. {
  270. // return sample count in chunk and step to next chunk
  271. do
  272. {
  273. int Chunk = Pos->STCOPos - ARRAYBEGIN(Stream->STCO,int);
  274. while (Pos->STSCPos[1].FirstChunk <= Chunk)
  275. ++Pos->STSCPos;
  276. ++Pos->STCOPos;
  277. Pos->SamplesLeft = Pos->STSCPos->Samples;
  279. } while (Pos->SamplesLeft <= 0);
  280. }
  282. static void Head(mp4stream* Stream,mp4streampos* Pos)
  283. {
  284. Pos->SampleNo = 0;
  285. Pos->CurrentTime = Stream->StartTime;
  286. Pos->SamplesLeft = 0;
  287. Pos->STTSLeft = 0;
  288. Pos->STSSDelta = 0;
  289. Pos->STSSValue = 0;
  290. Pos->STSZDelta = 0;
  291. Pos->STSZValue = 0;
  292. Pos->STSSPos = ARRAYBEGIN(Stream->STSS,uint8_t);
  293. Pos->STSSEnd = ARRAYEND(Stream->STSS,uint8_t);
  294. Pos->STTSPos = ARRAYBEGIN(Stream->STTS,mp4stts);
  295. Pos->STSCPos = ARRAYBEGIN(Stream->STSC,mp4stsc);
  296. Pos->STSZPos = ARRAYBEGIN(Stream->STSZ,uint8_t);
  297. Pos->STSZEnd = ARRAYEND(Stream->STSZ,uint8_t);
  298. Pos->STCOPos = ARRAYBEGIN(Stream->STCO,int);
  300. if (Pos->STTSPos)
  301. Pos->STTSLeft = Pos->STTSPos->Count;
  303. if (Stream->STSZDef)
  304. Pos->STSZValue = Stream->STSZDef;
  306. if (Pos->STSSPos)
  307. NextKey(Pos);
  308. else
  309. if (Stream->AllKey)
  310. Pos->STSSValue = 0;
  311. else
  312. Pos->STSSValue = -1;
  313. }
  315. static int GetFrames(mp4stream* Stream)
  316. {
  317. const mp4stsc* i;
  318. int Frames = 0;
  319. int Chunks = ARRAYCOUNT(Stream->STCO,int)-1; //minus delimier
  320. for (i=ARRAYBEGIN(Stream->STSC,mp4stsc);i!=ARRAYEND(Stream->STSC,mp4stsc)-1;++i)
  321. {
  322. int Next = min(Chunks,i[1].FirstChunk);
  323. if (Next > i->FirstChunk)
  324. Frames += i->Samples * (Next - i->FirstChunk);
  325. }
  326. return Frames;
  327. }
  329. static void ReadTRAK(mp4* p,filepos_t EndOfAtom)
  330. {
  331. mp4stream* Stream;
  332. p->Track = (mp4stream*) Format_AddStream(&p->Format,sizeof(mp4stream));
  333. p->Track->OffsetMin = MAX_INT;
  334. p->Track->OffsetMax = 0;
  336. ReadSubAtoms(p,EndOfAtom);
  338. Stream = p->Track;
  339. if (Stream)
  340. {
  341. if (ARRAYEMPTY(Stream->STCO) || ARRAYEMPTY(Stream->STTS) || ARRAYEMPTY(Stream->STSC))
  342. Format_RemoveStream(&p->Format);
  343. else
  344. {
  345. if (Stream->Stream.Format.Type == PACKET_VIDEO && Stream->Duration>0)
  346. {
  347. // calc FPS
  348. Stream->Stream.Format.PacketRate.Num = Scale(GetFrames(Stream),TICKSPERSEC*1000,Stream->Duration);
  349. Stream->Stream.Format.PacketRate.Den = 1000;
  351. if (Stream->Stream.Format.PacketRate.Num < 1000) // slideshow or podcast?
  352. Stream->Stream.Format.Format.Video.Pixel.Flags |= PF_NOPREROTATE;
  353. }
  355. //todo: calc ByteRate
  357. Head(Stream,&Stream->Pos);
  358. Format_PrepairStream(&p->Format,&Stream->Stream);
  359. }
  360. p->Track = NULL;
  361. }
  362. }
  364. static void ReadMETA(mp4* p,filepos_t EndOfAtom)
  365. {
  366. ReadVersion(Reader(p));
  367. ReadSubAtoms(p,EndOfAtom);
  368. }
  370. static void ReadSTSS(mp4* p,filepos_t EndOfAtom)
  371. {
  372. mp4stream* Stream = p->Track;
  373. int Count;
  374. int Delta,Value;
  376. if (!Stream || Stream->Stream.Fragmented) return;
  377. ReadVersion(Reader(p));
  379. Count = Reader(p)->ReadBE32(Reader(p));
  381. if (Count <= 1 && Stream->Stream.Format.Type == PACKET_VIDEO &&
  382. Stream->Stream.Format.Format.Video.Pixel.FourCC == FOURCC('S','2','6','3'))
  383. {
  384. // assume all frames as keyframes
  385. Stream->AllKey = 1;
  386. return;
  387. }
  389. ArrayClear(&Stream->STSS);
  390. ArrayAlloc(&Stream->STSS,Count+128,1024);
  392. Delta = Value = 0;
  393. while (Count-->0)
  394. WriteValue(&Stream->STSS,&Delta,&Value,Reader(p)->ReadBE32(Reader(p))-1,0);
  396. ArrayLock(&Stream->STSS);
  397. }
  399. static void ReadSTSC(mp4* p,filepos_t EndOfAtom)
  400. {
  401. mp4stream* Stream = p->Track;
  402. int Count;
  404. if (!Stream) return;
  405. ReadVersion(Reader(p));
  407. Count = Reader(p)->ReadBE32(Reader(p));
  409. ArrayClear(&Stream->STSC);
  410. if (ArrayAppend(&Stream->STSC,NULL,sizeof(mp4stsc)*(Count+1),1))
  411. {
  412. mp4stsc* se = ARRAYEND(Stream->STSC,mp4stsc)-1;
  413. mp4stsc* s;
  414. for (s=ARRAYBEGIN(Stream->STSC,mp4stsc);s!=se;++s)
  415. {
  416. s->FirstChunk = Reader(p)->ReadBE32(Reader(p))-1; 
  417. s->Samples = Reader(p)->ReadBE32(Reader(p));
  418. Reader(p)->ReadBE32(Reader(p)); // desc
  419. }
  420. s->FirstChunk = MAX_INT; // delimiter
  421. s->Samples = 0;
  423. ArrayLock(&Stream->STSC);
  424. }
  425. }
  427. static void ReadSTCO(mp4* p,filepos_t EndOfAtom)
  428. {
  429. mp4stream* Stream = p->Track;
  430. int Count;
  432. if (!Stream) return;
  433. ReadVersion(Reader(p));
  435. Count = Reader(p)->ReadBE32(Reader(p));
  437. ArrayClear(&Stream->STCO);
  438. if (ArrayAppend(&Stream->STCO,NULL,sizeof(int)*(Count+1),1))
  439. {
  440. int* ce = ARRAYEND(Stream->STCO,int)-1;
  441. int* c;
  442. for (c=ARRAYBEGIN(Stream->STCO,int);c!=ce;++c)
  443. {
  444. *c = Reader(p)->ReadBE32(Reader(p));
  445. // skip first and last chunks (some crappy encoders make bad interleaving, but leaving the last chunk at file end)
  446. if (Count<3 || (c!=ARRAYBEGIN(Stream->STCO,int) && c!=ce-1))
  447. {
  448. if (Stream->OffsetMin > *c)
  449. Stream->OffsetMin = *c;
  450. if (Stream->OffsetMax < *c)
  451. Stream->OffsetMax = *c;
  452. }
  453. }
  454. *c = MAX_INT;
  456. ArrayLock(&Stream->STCO);
  457. }
  458. }
  460. static void ReadCTTS(mp4* p,filepos_t EndOfAtom)
  461. {
  462. // presentation time offset (TCPMP only handles decoding time at the moment)
  464. mp4stream* Stream = p->Track;
  465. int Count;
  467. if (!Stream) return;
  468. ReadVersion(Reader(p));
  470. Count = Reader(p)->ReadBE32(Reader(p));
  472. if (Count>0)
  473. {
  474. int Offset;
  475. int Min = MAX_INT;
  477. while (Count-->0)
  478. {
  479. Reader(p)->ReadBE32(Reader(p)); // samples
  480. Offset = Reader(p)->ReadBE32(Reader(p));
  481. if (Min > Offset)
  482. Min = Offset;
  483. }
  485. if (Min>0 && Min<Stream->TimeScale)
  486. Stream->StartTime = Min;
  487. }
  488. }
  490. static void ReadSTSZ(mp4* p,filepos_t EndOfAtom)
  491. {
  492. mp4stream* Stream = p->Track;
  493. int Count;
  495. if (!Stream) return;
  496. ReadVersion(Reader(p));
  498. Stream->STSZDef = Reader(p)->ReadBE32(Reader(p));
  499. Count = Reader(p)->ReadBE32(Reader(p));
  501. if (!Stream->STSZDef)
  502. {
  503. int Delta,Value;
  505. Stream->Stream.Fragmented = 0;
  507. ArrayClear(&Stream->STSZ);
  508. ArrayAlloc(&Stream->STSZ,(Stream->Stream.Format.Type==PACKET_VIDEO?2*Count:Count)+1024,1024);
  510. Delta = Value = 0;
  511. while (Count-->0)
  512. WriteValue(&Stream->STSZ,&Delta,&Value,Reader(p)->ReadBE32(Reader(p)),1);
  514. ArrayLock(&Stream->STSZ);
  515. }
  516. else
  517. if (Stream->STSZDef==1)
  518. Stream->Stream.Fragmented = 1;
  519. }
  521. static void ReadSTTS(mp4* p,filepos_t EndOfAtom)
  522. {
  523. mp4stream* Stream = p->Track;
  524. int Count;
  526. if (!Stream) return;
  527. ReadVersion(Reader(p));
  529. Count = Reader(p)->ReadBE32(Reader(p));
  531. ArrayClear(&Stream->STTS);
  532. if (ArrayAppend(&Stream->STTS,NULL,sizeof(mp4stts)*(Count+1),1))
  533. {
  534. mp4stts* se = ARRAYEND(Stream->STTS,mp4stts)-1;
  535. mp4stts* s;
  536. for (s=ARRAYBEGIN(Stream->STTS,mp4stts);s!=se;++s)
  537. {
  538. s->Count = Reader(p)->ReadBE32(Reader(p)); 
  539. s->Delta = Reader(p)->ReadBE32(Reader(p));
  540. }
  541. s->Count = MAX_INT;
  542. s->Delta = 0;
  544. ArrayLock(&Stream->STTS);
  545. }
  546. }
  548. static void ReadExtra(mp4* p,filepos_t EndOfAtom)
  549. {
  550. filepos_t Len = EndOfAtom - Reader(p)->FilePos;
  551. packetformat* Format;
  553. if (!p->Track || Len<=0) return;
  555. Format = &p->Track->Stream.Format;
  556. if (PacketFormatExtra(Format,Len))
  557. Reader(p)->Read(Reader(p),Format->Extra,Format->ExtraLength);
  558. }
  560. static int DescLen(mp4* p)
  561. {
  562. int Len = 0;
  563. int i;
  564. for (i=0;i<4;++i)
  565. {
  566. int v = Reader(p)->Read8(Reader(p));
  567. Len = (Len << 7) | (v & 0x7F);
  568. if (!(v & 0x80))
  569. break;
  570. }
  571. return Len;
  572. }
  574. static void ReadESDS(mp4* p,filepos_t EndOfAtom)
  575. {
  576. int Tag,Len;
  577. mp4stream* Stream = p->Track;
  579. if (!Stream) return;
  581. ReadVersion(Reader(p));
  583. Tag = Reader(p)->Read8(Reader(p));
  584. Len = DescLen(p);
  586. Reader(p)->Skip(Reader(p),2); //ID
  587. if (Tag == 3)
  588. Reader(p)->Skip(Reader(p),1); //priority
  590. Tag = Reader(p)->Read8(Reader(p));
  591. Len = DescLen(p);
  593. if (Tag == 4) //config descr
  594. {
  595. int ObjTypeId = Reader(p)->Read8(Reader(p));
  597. Reader(p)->Skip(Reader(p),12); //stream_type,buffer_size,max_bitrate,min_bitrate
  599. Tag = Reader(p)->Read8(Reader(p));
  600. Len = DescLen(p);
  602. if (Tag == 5 && PacketFormatExtra(&Stream->Stream.Format,Len))
  603. Reader(p)->Read(Reader(p),Stream->Stream.Format.Extra,Stream->Stream.Format.ExtraLength);
  605. //override fourcc or format if neccessary
  607. if (Stream->Stream.Format.Type == PACKET_VIDEO)
  608. {
  609. switch (ObjTypeId)
  610. {
  611. case MP4_MPEG1_VIDEO_TYPE:
  612. case MP4_MPEG2_SIMPLE_VIDEO_TYPE:
  613. case MP4_MPEG2_MAIN_VIDEO_TYPE:
  614. case MP4_MPEG2_SNR_VIDEO_TYPE:
  615. case MP4_MPEG2_SPATIAL_VIDEO_TYPE:
  616. case MP4_MPEG2_HIGH_VIDEO_TYPE:
  617. case MP4_MPEG2_442_VIDEO_TYPE:
  618. Stream->Stream.Format.Format.Video.Pixel.FourCC = FOURCC('m','p','e','g');
  619. break;
  621. case MP4_MPEG4_VIDEO_TYPE:
  622. Stream->Stream.Format.Format.Video.Pixel.FourCC = FOURCC('m','p','4','v');
  623. break;
  625. case MP4_JPEG_VIDEO_TYPE:
  626. Stream->Stream.Format.Format.Video.Pixel.FourCC = FOURCC('j','p','e','g');
  627. Stream->AllKey = 1;
  628. break;
  629. }
  630. }
  632. if (Stream->Stream.Format.Type == PACKET_AUDIO)
  633. {
  634. switch (ObjTypeId)
  635. {
  636. case MP4_MPEG1_AUDIO_TYPE:
  637. case MP4_MPEG2_AUDIO_TYPE:
  638. Stream->Stream.Format.Format.Audio.Format = AUDIOFMT_MP3;
  639. break;
  641. case MP4_MPEG2_AAC_MAIN_AUDIO_TYPE:
  642. case MP4_MPEG2_AAC_LC_AUDIO_TYPE:
  643. case MP4_MPEG2_AAC_SSR_AUDIO_TYPE:
  644. case MP4_MPEG4_AUDIO_TYPE:
  645. Stream->Stream.Format.Format.Audio.Format = AUDIOFMT_AAC;
  646. break;
  648. case MP4_PRIVATE_AUDIO_TYPE+1:
  649. if (Stream->Stream.Format.ExtraLength>4 && 
  650. *(uint32_t*)Stream->Stream.Format.Extra == FOURCC('Q','L','C','M'))
  651. Stream->Stream.Format.Format.Audio.Format = AUDIOFMT_QCELP;
  652. break;
  653. }
  654. }
  655. }
  656. }
  658. static void SetText(mp4* p,uint32_t FourCC)
  659. {
  660. packetformat* Format = &p->Track->Stream.Format;
  661. PacketFormatClear(Format);
  662. Format->Type = PACKET_SUBTITLE;
  663. Format->Format.Subtitle.FourCC = FourCC;
  664. PacketFormatDefault(Format);
  665. }
  667. static void SetAudio(mp4* p,int AudioFormat,int SampleRate,int Bits,int Channels)
  668. {
  669. packetformat* Format = &p->Track->Stream.Format;
  670. PacketFormatClear(Format);
  671. Format->Type = PACKET_AUDIO;
  672. Format->Format.Audio.Format = AudioFormat;
  673. Format->Format.Audio.Flags = PCM_PACKET_BASED;
  674. Format->Format.Audio.SampleRate = SampleRate;
  675. Format->Format.Audio.Bits = Bits;
  676. Format->Format.Audio.Channels = Channels;
  677. PacketFormatDefault(Format);
  678. }
  680. static void ReadAudio(mp4* p,int AudioFormat,int Atom,filepos_t EndOfAtom,int FixedBits)
  681. {
  682. packetformat* Format = &p->Track->Stream.Format;
  683. PacketFormatClear(Format);
  684. Format->Type = PACKET_AUDIO;
  685. Format->Format.Audio.Format = AudioFormat;
  686. Format->Format.Audio.Channels = 1;
  687. Format->Format.Audio.Flags = PCM_PACKET_BASED;
  689. #ifdef IS_BIG_ENDIAN
  690. if (Atom == FOURCC('s','o','w','t'))
  691. Format->Format.Audio.Flags |= PCM_SWAPEDBYTES;
  692. #else
  693. if (Atom == FOURCC('t','w','o','s'))
  694. Format->Format.Audio.Flags |= PCM_SWAPEDBYTES;
  695. #endif
  697. if (Atom == FOURCC('r','a','w',' ') || Atom == FOURCC('N','O','N','E'))
  698. {
  699. #ifndef IS_BIG_ENDIAN
  700. Format->Format.Audio.Flags |= PCM_SWAPEDBYTES; // some digital cameras use 'raw ' with 16bit big endian
  701. #endif
  702. Format->Format.Audio.Bits = 8;
  703. }
  704. else
  705. Format->Format.Audio.Bits = 16;
  707. if (EndOfAtom - Reader(p)->FilePos >= 20)
  708. {
  709. int Ver = Reader(p)->ReadBE16(Reader(p));
  710. Reader(p)->Skip(Reader(p),2+4); // revision, vendor
  712. Format->Format.Audio.Channels = Reader(p)->ReadBE16(Reader(p)); // channel count
  713. Format->Format.Audio.Bits = Reader(p)->ReadBE16(Reader(p)); // sample size
  715. Reader(p)->Skip(Reader(p),2+2); // compression_id,packet_size
  717. Format->Format.Audio.SampleRate = Reader(p)->ReadBE16(Reader(p)); // sample rate
  718. Reader(p)->Skip(Reader(p),2); // reserved (part of 32bit sample rate?)
  720. if (FixedBits < 0)
  721. FixedBits = Format->Format.Audio.Bits; 
  723. if (Ver == 1)
  724. {
  725. p->Track->SamplesPerPacket = Reader(p)->ReadBE32(Reader(p));
  726. Reader(p)->ReadBE32(Reader(p));
  727. p->Track->BytesPerPacket = Reader(p)->ReadBE32(Reader(p));
  728. Reader(p)->ReadBE32(Reader(p));
  730. if (AudioFormat == AUDIOFMT_ADPCM_MS || AudioFormat == AUDIOFMT_ADPCM_IMA)
  731. Format->Format.Audio.BlockAlign = p->Track->BytesPerPacket;
  732. }
  733. else
  734. if (FixedBits)
  735. {
  736. p->Track->SamplesPerPacket = 1;
  737. p->Track->BytesPerPacket = (FixedBits * Format->Format.Audio.Channels) >> 3;
  738. }
  740. ReadSubAtoms(p,EndOfAtom);
  741. }
  743. PacketFormatDefault(Format);
  744. }
  746. static void ReadVideo(mp4* p,int FourCC,filepos_t EndOfAtom)
  747. {
  748. int ColTable,BitCount,ColCount;
  749. bool_t ColGray;
  750. packetformat* Format = &p->Track->Stream.Format;
  751. PacketFormatClear(Format);
  752. Format->Type = PACKET_VIDEO;
  754. Reader(p)->Skip(Reader(p),16); // reserved
  756. Format->Format.Video.Pixel.FourCC = FourCC;
  757. Format->Format.Video.Width = Reader(p)->ReadBE16(Reader(p));
  758. Format->Format.Video.Height = Reader(p)->ReadBE16(Reader(p)); 
  759. Format->Format.Video.Aspect = ASPECT_ONE; //todo: fix
  761. if (FourCC == FOURCC('m','p','4','v'))
  762. {
  763. // use mpeg4 vol information instead 
  764. Format->Format.Video.Width = 0;
  765. Format->Format.Video.Height = 0;
  766. }
  768. Reader(p)->Skip(Reader(p),14+32); // reserved,compressor
  770. BitCount = Reader(p)->ReadBE16(Reader(p));
  771. ColGray = (BitCount & 32)!=0;
  772. BitCount &= 31;
  773. ColCount = 1<<BitCount;
  774. Format->Format.Video.Pixel.BitCount = BitCount;
  776. ColTable = Reader(p)->ReadBE16(Reader(p));
  778.     if ((BitCount==2 || BitCount==4 || BitCount==8) &&
  779. PacketFormatExtra(Format,sizeof(rgb)*ColCount)) 
  780. {
  781. rgb* Pal = Format->Format.Video.Pixel.Palette = (rgb*)Format->Extra;
  782. if (ColGray)
  783. {
  784. int i;
  785. for (i=0;i<ColCount;++i)
  786. {
  787. int v = 255 - (i*255)/(ColCount-1);
  788. Pal[i].c.r = (uint8_t)v;
  789. Pal[i].c.g = (uint8_t)v;
  790. Pal[i].c.b = (uint8_t)v;
  791. Pal[i].c.a = 0;
  792. }
  793. }
  794. else
  795. if (ColTable & 8)
  796. {
  797. // default palette
  798. int i;
  799. const rgbval_t* v = MovPal;
  800. if (BitCount>2) v += 1<<2;
  801. if (BitCount>4) v += 1<<4;
  802. for (i=0;i<ColCount;++i)
  803. Pal[i].v = v[i];
  804. }
  805. else
  806. {
  807. int Start,End;
  808. Start = Reader(p)->ReadBE32(Reader(p));
  809. Reader(p)->Skip(Reader(p),2); // count
  810. End = Reader(p)->ReadBE16(Reader(p))+1;
  811. if (End > ColCount)
  812. End = ColCount;
  814. for (;Start<End;++Start)
  815. {
  816. uint8_t v[4][2];
  817. Reader(p)->Read(Reader(p),v,sizeof(v)); // 16bit a,r,g,b 
  818. Pal[Start].c.r = v[1][0];
  819. Pal[Start].c.g = v[2][0];
  820. Pal[Start].c.b = v[3][0];
  821. Pal[Start].c.a = 0;
  822. }
  823. }
  824. }
  826. ReadSubAtoms(p,EndOfAtom);
  827. PacketFormatDefault(Format);
  828. }
  830. static void ReadSTSD(mp4* p,filepos_t EndOfAtom)
  831. {
  832. mp4stream* Stream = p->Track;
  833. int DescCount;
  834. mp4atom Atom;
  836. if (!Stream) return;
  838. ReadVersion(Reader(p));
  840. DescCount = Reader(p)->ReadBE32(Reader(p));
  841. if (DescCount && ReadAtom(Reader(p),&Atom))
  842. {
  843. uint32_t FirstAtom = Atom.Atom;
  844. Reader(p)->Skip(Reader(p),6+2); // reserved,reference index
  846. Stream->Stream.Fragmented = 0;
  848. // fourcc codes from libavformat
  850. if (Atom.Atom == FOURCC('A','V','D','J'))
  851. Atom.Atom = FOURCC('j','p','e','g');
  853. switch (Atom.Atom)
  854. {
  855. case FOURCC('p','n','g',' '):
  856. Atom.Atom = FOURCC('P','N','G','_');
  857. case FOURCC('t','i','f','f'):
  858. case FOURCC('j','p','e','g'):
  859. case FOURCC('m','j','p','a'):
  860. case FOURCC('m','j','p','b'):
  861. Stream->AllKey = 1;
  862. // no break;
  863. case FOURCC('3','I','V','2'):
  864. case FOURCC('3','I','V','1'):
  865. case FOURCC('a','v','c','1'):
  866. case FOURCC('S','V','Q','1'):
  867. case FOURCC('S','V','Q','3'):
  868. case FOURCC('m','p','4','v'):
  869. case FOURCC('D','I','V','X'):
  870. case FOURCC('V','P','3','1'):
  871. case FOURCC('h','2','6','3'):
  872. case FOURCC('s','2','6','3'):
  873. case FOURCC('c','v','i','d'):
  874. ReadVideo(p,Atom.Atom,Atom.EndOfAtom);
  875. break;
  877. // case FOURCC('O','g','g','V'):
  878. // Stream->Stream.Fragmented = 1;
  879. // ReadAudio(p,AUDIOFMT_VORBIS_MODE1,Atom.Atom,Atom.EndOfAtom,-1);
  880. // break;
  882. case FOURCC('s','o','w','t'):
  883. case FOURCC('t','w','o','s'):
  884. case FOURCC('r','a','w',' '):
  885. case FOURCC('N','O','N','E'):
  886. Stream->Stream.Fragmented = 1;
  887. ReadAudio(p,AUDIOFMT_PCM,Atom.Atom,Atom.EndOfAtom,-1);
  888. break;
  890. case FOURCC('u','l','a','w'):
  891. Stream->Stream.Fragmented = 1;
  892. ReadAudio(p,AUDIOFMT_MULAW,Atom.Atom,Atom.EndOfAtom,8);
  893. break;
  895. case FOURCC('a','l','a','w'):
  896. Stream->Stream.Fragmented = 1;
  897. ReadAudio(p,AUDIOFMT_ALAW,Atom.Atom,Atom.EndOfAtom,8);
  898. break;
  900. case FOURCC('Q','D','M','2'):
  901. Stream->Stream.Fragmented = 1;
  902. ReadAudio(p,AUDIOFMT_QDESIGN2,Atom.Atom,Atom.EndOfAtom,0);
  903. break;
  905. case FOURCC('.','m','p','3'):
  906. case 0x6D730055:
  907. case 0x5500736D:
  908. Stream->Stream.Fragmented = 1;
  909. ReadAudio(p,AUDIOFMT_MP3,Atom.Atom,Atom.EndOfAtom,0);
  910. break;
  912. case 0x6D730002:
  913. case 0x0200736D:
  914. Stream->Stream.Fragmented = 1;
  915. ReadAudio(p,AUDIOFMT_ADPCM_MS,Atom.Atom,Atom.EndOfAtom,0);
  916. break;
  918. case 0x6D730011:
  919. case 0x1100736D:
  920. Stream->Stream.Fragmented = 1;
  921. ReadAudio(p,AUDIOFMT_ADPCM_IMA,Atom.Atom,Atom.EndOfAtom,0);
  922. break;
  924. case FOURCC('i','m','a','4'):
  925. Stream->Stream.Fragmented = 1;
  926. ReadAudio(p,AUDIOFMT_ADPCM_IMA_QT,Atom.Atom,Atom.EndOfAtom,0);
  928. Stream->SamplesPerPacket = 64;
  929. Stream->BytesPerPacket = 34*Stream->Stream.Format.Format.Audio.Channels;
  930. break;
  932. case FOURCC('m','p','4','a'):
  933. ReadAudio(p,AUDIOFMT_AAC,Atom.Atom,Atom.EndOfAtom,0);
  934. break;
  936. case FOURCC('s','a','m','r'):
  937. SetAudio(p,AUDIOFMT_AMR_NB,8000,16,1);
  938. break;
  940. case FOURCC('s','a','w','b'):
  941. SetAudio(p,AUDIOFMT_AMR_WB,16000,16,1);
  942. break;
  944. case FOURCC('t','e','x','t'):
  945. SetText(p,UpperFourCC(Atom.Atom));
  946. break;
  948. case FOURCC('t','x','3','g'):
  949. SetText(p,UpperFourCC(Atom.Atom));
  950. break;
  951. }
  953. while (--DescCount>0)
  954. {
  955. Reader(p)->Seek(Reader(p),Atom.EndOfAtom,SEEK_SET);
  956. ReadAtom(Reader(p),&Atom);
  957. if (Atom.Atom != FirstAtom)
  958. {
  959. if (!p->ErrorShowed)
  960. {
  961. p->ErrorShowed = 1;
  962. ShowError(p->Format.Format.Class,MP4_ID,MP4_MULTIPLE_FORMAT);
  963. }
  964. Stream->Stream.Format.Type = PACKET_NONE;
  965. break;
  966. }
  967. }
  968. }
  970. if (Stream->Stream.Format.Type == PACKET_NONE)
  971. {
  972. Format_RemoveStream(&p->Format);
  973. p->Track = NULL;
  974. }
  975. }
  977. static void ReadMVHD(mp4* p,filepos_t EndOfAtom)
  978. {
  979. int Duration;
  981. ReadVersion(Reader(p));
  982. Reader(p)->ReadBE32(Reader(p)); // creation time
  983. Reader(p)->ReadBE32(Reader(p)); // modification time
  985. p->TimeScale = Reader(p)->ReadBE32(Reader(p)); // timescale
  986. Duration = Reader(p)->ReadBE32(Reader(p)); // duration
  988. if (Duration>0)
  989. p->Format.Duration = Scale(Duration,TICKSPERSEC,p->TimeScale);
  990. }
  992. static void ReadMDHD(mp4* p,filepos_t EndOfAtom)
  993. {
  994. int Duration = -1;
  996. if (!p->Track) return;
  998. switch (ReadVersion(Reader(p)))
  999. {
  1000. case 0:
  1001. Reader(p)->ReadBE32(Reader(p)); // creation time
  1002. Reader(p)->ReadBE32(Reader(p)); // modification time
  1003. p->Track->TimeScale = Reader(p)->ReadBE32(Reader(p)); // timescale
  1004. Duration = Reader(p)->ReadBE32(Reader(p)); // duration
  1005. break;
  1007. case 1:
  1008. Reader(p)->ReadBE64(Reader(p)); // creation time
  1009. Reader(p)->ReadBE64(Reader(p)); // modification time
  1010. p->Track->TimeScale = Reader(p)->ReadBE32(Reader(p)); // timescale
  1011. Duration = (int)Reader(p)->ReadBE64(Reader(p)); // duration
  1012. break;
  1013. }
  1015. if (Duration>0)
  1016. {
  1017. Duration = Scale(Duration,TICKSPERSEC,p->Track->TimeScale);
  1018. if (p->Format.Duration < Duration)
  1019. p->Format.Duration = Duration;
  1020. }
  1022. p->Track->Duration = Duration;
  1023. }
  1025. static void ReadCMOV(mp4* p,filepos_t EndOfAtom)
  1026. {
  1027. ReadSubAtoms(p,EndOfAtom);
  1028. p->CompressType = 0;
  1029. }
  1031. static void ReadDCOM(mp4* p,filepos_t EndOfAtom)
  1032. {
  1033. p->CompressType = 0;
  1034. Reader(p)->Read(Reader(p),&p->CompressType,sizeof(p->CompressType));
  1035. }
  1037. static void ReadCMVD(mp4* p,filepos_t EndOfAtom)
  1038. {
  1039. if (p->CompressType == FOURCC('z','l','i','b'))
  1040. {
  1041. uint32_t DstLen = Reader(p)->ReadBE32(Reader(p));
  1042. int SrcLen = EndOfAtom - Reader(p)->FilePos;
  1044. uint8_t* Src = (uint8_t*)malloc(SrcLen);
  1045. uint8_t* Dst = (uint8_t*)malloc(DstLen);
  1047. if (Src && Dst && Reader(p)->Read(Reader(p),Src,SrcLen)==SrcLen && 
  1048. uncompress(Dst,&DstLen,Src,SrcLen)==Z_OK)
  1049. {
  1050. format_buffer Buffer;
  1051. format_reader* Reader = p->Format.Reader;
  1052. format_reader Backup = *Reader;
  1054. Buffer.Block.Id = 0;
  1055. Buffer.Block.Ptr = Dst;
  1056. Buffer.Length = DstLen;
  1058. Reader->BufferFirst = NULL;
  1059. Reader->BufferLast = NULL;
  1060. Reader->NoMoreInput = 1;
  1061. Reader->ReadPos = 0;
  1062. Reader->ReadLen = DstLen;
  1063. Reader->FilePos = 0;
  1064. Reader->Input = NULL;
  1065. Reader->InputBuffer = NULL;
  1066. Reader->ReadBuffer = &Buffer;
  1067. Reader->Format = &p->Format;
  1068. Reader->BufferAvailable = 0;
  1070. ReadSubAtoms(p,DstLen);
  1072. *Reader = Backup;
  1073. }
  1074. free(Src);
  1075. free(Dst);
  1076. }
  1077. }
  1079. static void AddMeta(mp4* p,const tchar_t* Meta,int Size)
  1080. {
  1081. pin* Comment = &p->Format.Comment;
  1082. format_stream* Stream = (format_stream*)p->Track;
  1083. if (Stream)
  1084. Comment = &Stream->Comment;
  1085. if (Comment->Node)
  1086. Comment->Node->Set(Comment->Node,Comment->No,Meta,Size);
  1087. }
  1089. static void ReadMetaString(mp4* p,filepos_t EndOfAtom)
  1090. {
  1091. tchar_t Meta[512];
  1092. char UTF8[512];
  1093. int Len = EndOfAtom - Reader(p)->FilePos;
  1094. if (Len>=512) Len=511;
  1095. Len = Reader(p)->Read(Reader(p),UTF8,Len);
  1096. if (Len>0)
  1097. {
  1098. UTF8[Len] = 0;
  1099. tcscpy_s(Meta,TSIZEOF(Meta),p->Meta);
  1100. UTF8ToTcs(Meta+tcslen(p->Meta),TSIZEOF(Meta)-tcslen(p->Meta),UTF8);
  1101. AddMeta(p,Meta,sizeof(Meta));
  1102. }
  1103. }
  1105. static void ReadRDRF(mp4* p,filepos_t EndOfAtom)
  1106. {
  1107. if (p->RMRAFound)
  1108. {
  1109. //redirect
  1110. if (Reader(p)->ReadBE32(Reader(p))==0)
  1111. {
  1112. int Size;
  1113. uint32_t Type = 0;
  1114. Reader(p)->Read(Reader(p),&Type,sizeof(Type));
  1115. Size = Reader(p)->ReadBE32(Reader(p));
  1116. if (Type == FOURCC('u','r','l',' '))
  1117. {
  1118. tcscpy_s(p->Meta,TSIZEOF(p->Meta),T("REDIRECT="));
  1119. ReadMetaString(p,min(EndOfAtom,Reader(p)->FilePos + Size));
  1120. p->Meta[0] = 0;
  1121. }
  1122. }
  1123. }
  1124. }
  1126. static void ReadDATA(mp4* p,filepos_t EndOfAtom)
  1127. {
  1128. ReadVersion(Reader(p));
  1129. Reader(p)->Skip(Reader(p),4); //reserved;
  1130. if (tcscmp(p->Meta,T("COVER="))==0)
  1131. {
  1132. tchar_t Meta[256];
  1133. stprintf_s(Meta,TSIZEOF(Meta),T("%s:%d:%d:"),p->Meta,Reader(p)->FilePos,EndOfAtom-Reader(p)->FilePos);
  1134. AddMeta(p,Meta,sizeof(Meta));
  1135. }
  1136. else
  1137. if (tcscmp(p->Meta,T("GENRE="))==0)
  1138. {
  1139. tchar_t Meta[256];
  1140. tcscpy_s(Meta,TSIZEOF(Meta),p->Meta);
  1141. if (ID3v1_Genre(Reader(p)->ReadBE16(Reader(p))-1,Meta+tcslen(Meta),256-tcslen(Meta)))
  1142. AddMeta(p,Meta,sizeof(Meta));
  1143. }
  1144. else
  1145. if (p->Meta[0])
  1146. ReadMetaString(p,EndOfAtom);
  1147. }
  1149. static void ReadNeroChapter(mp4* p,filepos_t EndOfAtom)
  1150. {
  1151. int Count,i,Len;
  1153. Reader(p)->Read8(Reader(p)); // version?
  1154. Reader(p)->Skip(Reader(p),4); // ???
  1155. Count = Reader(p)->ReadBE32(Reader(p));
  1156. for (i=0;i<Count;++i)
  1157. {
  1158. int64_t Time = Reader(p)->ReadBE64(Reader(p));
  1160. stprintf_s(p->Meta,TSIZEOF(p->Meta),T("CHAPTER%02dNAME="),i+1);
  1161. Len = Reader(p)->Read8(Reader(p));
  1162. ReadMetaString(p,Reader(p)->FilePos + Len);
  1164. BuildChapter(p->Meta,TSIZEOF(p->Meta),i+1,Time,10000);
  1165. AddMeta(p,p->Meta,sizeof(p->Meta));
  1166. }
  1167. }
  1169. static void ReadNAME(mp4* p,filepos_t EndOfAtom)
  1170. {
  1171. ReadVersion(Reader(p));
  1172. if (p->Meta[0])
  1173. ReadMetaString(p,EndOfAtom);
  1174. else
  1175. {
  1176. char UTF8[512];
  1177. int Len = EndOfAtom - Reader(p)->FilePos;
  1178. if (Len>510) Len=510;
  1179. Len = Reader(p)->Read(Reader(p),UTF8,Len);
  1180. if (Len>0)
  1181. {
  1182. UTF8[Len] = '=';
  1183. UTF8[Len+1] = 0;
  1184. UTF8ToTcs(p->Meta,TSIZEOF(p->Meta),UTF8);
  1185. }
  1186. }
  1187. }
  1189. static void ReadMeta(mp4* p,filepos_t EndOfAtom, const tchar_t* Meta)
  1190. {
  1191. mp4atom Atom;
  1192. int Pos = Reader(p)->FilePos;
  1193. tcscpy_s(p->Meta,TSIZEOF(p->Meta),Meta);
  1194. ReadAtom(Reader(p),&Atom);
  1195. Reader(p)->Seek(Reader(p),Pos,SEEK_SET);
  1196. if (Atom.EndOfAtom > EndOfAtom)
  1197. ReadNAME(p,EndOfAtom);
  1198. else
  1199. ReadSubAtoms(p,EndOfAtom);
  1200. p->Meta[0] = 0;
  1201. }
  1203. static void ReadMetaCover(mp4* p,filepos_t EndOfAtom) { ReadMeta(p,EndOfAtom,T("COVER=")); }
  1204. static void ReadMetaName(mp4* p,filepos_t EndOfAtom) { ReadMeta(p,EndOfAtom,T("TITLE=")); }
  1205. static void ReadMetaArtist(mp4* p,filepos_t EndOfAtom) { ReadMeta(p,EndOfAtom,T("ARTIST=")); }
  1206. static void ReadMetaWriter(mp4* p,filepos_t EndOfAtom) { ReadMeta(p,EndOfAtom,T("WRITER=")); }
  1207. static void ReadMetaAlbum(mp4* p,filepos_t EndOfAtom) { ReadMeta(p,EndOfAtom,T("ALBUM=")); }
  1208. static void ReadMetaDate(mp4* p,filepos_t EndOfAtom) { ReadMeta(p,EndOfAtom,T("DATE=")); }
  1209. static void ReadMetaTool(mp4* p,filepos_t EndOfAtom) { ReadMeta(p,EndOfAtom,T("TOOL=")); }
  1210. static void ReadMetaComment(mp4* p,filepos_t EndOfAtom) { ReadMeta(p,EndOfAtom,T("COMMENT=")); }
  1211. static void ReadMetaGenre(mp4* p,filepos_t EndOfAtom) { ReadMeta(p,EndOfAtom,T("GENRE=")); }
  1213. static const mp4atomtable AtomTable[] =
  1214. {
  1215. { FOURCC('f','t','y','p'), ReadFTYP },
  1216. { FOURCC('m','o','o','v'), ReadMOOV },
  1217. { FOURCC('t','r','a','k'), ReadTRAK },
  1218. { FOURCC('m','v','h','d'), ReadMVHD },
  1219. { FOURCC('m','d','h','d'), ReadMDHD },
  1220. { FOURCC('s','t','b','l'), ReadSubAtoms },
  1221. { FOURCC('m','i','n','f'), ReadSubAtoms },
  1222. { FOURCC('e','d','t','s'), ReadSubAtoms },
  1223. { FOURCC('m','d','i','a'), ReadSubAtoms },
  1224. { FOURCC('u','d','t','a'), ReadSubAtoms },
  1225. { FOURCC('i','l','s','t'), ReadSubAtoms },
  1226. { FOURCC('w','a','v','e'), ReadSubAtoms },
  1227. { FOURCC('-','-','-','-'), ReadSubAtoms },
  1228. { FOURCC('r','m','d','a'), ReadSubAtoms },
  1229. { FOURCC('r','m','r','a'), ReadRMRA },
  1230. { FOURCC('r','d','r','f'), ReadRDRF },
  1231. { FOURCC('m','e','t','a'), ReadMETA },
  1232. { FOURCC('s','t','s','d'), ReadSTSD },
  1233. { FOURCC('s','t','s','s'), ReadSTSS },
  1234. { FOURCC('s','t','s','c'), ReadSTSC },
  1235. { FOURCC('s','t','c','o'), ReadSTCO },
  1236. { FOURCC('c','t','t','s'), ReadCTTS },
  1237. { FOURCC('s','t','s','z'), ReadSTSZ },
  1238. { FOURCC('s','t','t','s'), ReadSTTS },
  1239. { FOURCC('c','m','o','v'), ReadCMOV },
  1240. { FOURCC('d','c','o','m'), ReadDCOM },
  1241. { FOURCC('c','m','v','d'), ReadCMVD },
  1242. { FOURCC('e','s','d','s'), ReadESDS },
  1243. { FOURCC('S','M','I',' '), ReadExtra },
  1244. { FOURCC('a','v','c','C'), ReadExtra },
  1245. { FOURCC('d','a','t','a'), ReadDATA },
  1246. { FOURCC('n','a','m','e'), ReadNAME },
  1247. { FOURCC('c','h','p','l'), ReadNeroChapter },
  1248. { FOURCC('251','n','a','m'), ReadMetaName },
  1249. { FOURCC('251','A','R','T'), ReadMetaArtist },
  1250. { FOURCC('251','w','r','t'), ReadMetaWriter },
  1251. { FOURCC('251','a','l','b'), ReadMetaAlbum },
  1252. { FOURCC('251','d','a','y'), ReadMetaDate },
  1253. { FOURCC('251','t','o','o'), ReadMetaTool },
  1254. { FOURCC('251','c','m','t'), ReadMetaComment },
  1255. { FOURCC('251','g','e','n'), ReadMetaGenre },
  1256. { FOURCC('c','o','v','r'), ReadMetaCover },
  1257. { FOURCC('g','n','r','e'), ReadMetaGenre },
  1259. { 0, NULL }
  1260. };
  1262. static void ReadSubAtoms(mp4* p,filepos_t EndOfAtom)
  1263. {
  1264. mp4atom Atom;
  1265. const mp4atomtable* i;
  1267. while (Reader(p)->FilePos < EndOfAtom - 8)
  1268. {
  1269. if (!ReadAtom(Reader(p),&Atom))
  1270. break;
  1272. if (p->MOOVFound && Atom.Atom == FOURCC('m','d','a','t'))
  1273. break;
  1275. for (i=AtomTable;i->Atom;++i)
  1276. if (i->Atom == Atom.Atom)
  1277. {
  1278. i->Func(p,Atom.EndOfAtom);
  1279. break;
  1280. }
  1282. Reader(p)->Seek(Reader(p),Atom.EndOfAtom,SEEK_SET);
  1283. }
  1285. p->Meta[0] = 0;
  1286. }
  1288. static mp4stream* FindNextChunk(mp4* p, format_reader* Reader)
  1289. {
  1290. mp4stream* Stream = NULL;
  1291. int Min = MAX_INT;
  1292. int No;
  1293. for (No=0;No<p->Format.StreamCount;++No)
  1294. {
  1295. mp4stream* s = (mp4stream*)p->Format.Streams[No];
  1296. if (s->Stream.Pin.Node && s->Stream.Reader == Reader && Min > *s->Pos.STCOPos)
  1297. {
  1298. Min = *s->Pos.STCOPos;
  1299. Stream = s;
  1300. }
  1301. }
  1303. if (Stream)
  1304. {
  1305. if (Reader->Seek(Reader,Min,SEEK_SET) == ERR_NONE)
  1306. {
  1307. Reader->Current = &Stream->Stream;
  1308. NextChunk(Stream,&Stream->Pos);
  1309. }
  1310. else
  1311. Stream = NULL;
  1312. }
  1313. return Stream;
  1314. }
  1316. static void AddTextChapters(mp4* p,mp4stream* s)
  1317. {
  1318. format_reader* Reader = p->Format.Reader;
  1319. mp4streampos Pos;
  1320. int No = 1;
  1322. Head(s,&Pos);
  1323. for (;;)
  1324. {
  1325. filepos_t FilePos = *Pos.STCOPos;
  1326. if (FilePos == MAX_INT)
  1327. break;
  1329. NextChunk(s,&Pos);
  1330. while (Pos.SamplesLeft)
  1331. {
  1332. if (Reader->Seek(Reader,FilePos,SEEK_SET) == ERR_NONE)
  1333. {
  1334. int Len = Reader->ReadBE16(Reader);
  1335. if (Len)
  1336. {
  1337. stprintf_s(p->Meta,TSIZEOF(p->Meta),T("CHAPTER%02dNAME="),No);
  1338. ReadMetaString(p,Reader->FilePos+Len);
  1339. BuildChapter(p->Meta,TSIZEOF(p->Meta),No,(int64_t)Pos.CurrentTime*1000,s->TimeScale);
  1340. AddMeta(p,p->Meta,sizeof(p->Meta));
  1341. ++No;
  1342. }
  1343. }
  1344. FilePos += NextSample(s,&Pos);
  1345. }
  1346. }
  1347. }
  1349. static int Init(mp4* p)
  1350. {
  1351. int No;
  1353. p->MOOVFound = 0;
  1354. p->Type = FOURCC('m','o','o','v'); //quicktime .mov
  1355. p->TimeScale = 0;
  1356. p->ErrorShowed = 0;
  1357. p->Format.HeaderLoaded = 1;
  1358. p->Meta[0] = 0;
  1360. ReadSubAtoms(p,MAX_INT);
  1362. if (!p->MOOVFound)
  1363. return ERR_INVALID_DATA;
  1365. if (p->Format.Comment.Node)
  1366. for (No=0;No<p->Format.StreamCount;++No)
  1367. {
  1368. mp4stream* s = (mp4stream*)p->Format.Streams[No];
  1369. if (s->Stream.Format.Type == PACKET_SUBTITLE && 
  1370. s->Stream.Format.Format.Subtitle.FourCC == FOURCC('T','E','X','T') && GetFrames(s)<100)
  1371. AddTextChapters(p,s);
  1372. }
  1374. for (No=0;No<p->Format.StreamCount;++No)
  1375. {
  1376. mp4stream* s = (mp4stream*)p->Format.Streams[No];
  1377. format_reader* Reader = Format_FindReader(&p->Format,s->OffsetMin,s->OffsetMax);
  1378. if (!Reader)
  1379. break;
  1380. s->Stream.Reader = Reader;
  1381. }
  1383. for (No=0;No<MAXREADER;++No)
  1384. FindNextChunk(p,p->Format.Reader+No);
  1386. return ERR_NONE;
  1387. }
  1389. static int ReadPacket(mp4* p, format_reader* Reader, format_packet* Packet)
  1390. {
  1391. mp4stream* Stream = (mp4stream*) Reader->Current;
  1392. if (!Stream)
  1393. {
  1394. Stream = FindNextChunk(p,Reader);
  1395. if (!Stream)
  1396. return ERR_END_OF_FILE;
  1397. }
  1399. Packet->Stream = &Stream->Stream;
  1400. Packet->RefTime = Scale(Stream->Pos.CurrentTime,TICKSPERSEC,Stream->TimeScale);
  1401. if (Stream->Pos.STSSValue >= 0)
  1402. {
  1403. Packet->Key = Stream->Pos.SampleNo == Stream->Pos.STSSValue;
  1404. if (Packet->Key)
  1405. NextKey(&Stream->Pos);
  1406. }
  1407. Packet->Data = Reader->ReadAsRef(Reader,NextSample(Stream,&Stream->Pos));
  1408. if (Stream->Pos.SamplesLeft==0)
  1409. Reader->Current = NULL;
  1410. return ERR_NONE;
  1411. }
  1413. static bool_t GetNeedKey(mp4stream* Stream)
  1414. {
  1415. return (!ARRAYEMPTY(Stream->STSS) || Stream->AllKey) && Stream->Stream.Format.Type == PACKET_VIDEO;
  1416. }
  1418. static int SeekReader(mp4* p, format_reader* Reader, tick_t* DstTime, filepos_t DstPos, bool_t PrevKey)
  1419. {
  1420. mp4stream* Stream = (mp4stream*) Format_DefSyncStream(&p->Format,Reader);
  1421. if (Stream && Reader->Input)
  1422. {
  1423. mp4streampos Last;
  1424. mp4streampos Pos;
  1425. bool_t NeedKey;
  1426. tick_t SyncTime;
  1427. int DstMediaTime,No;
  1428. filepos_t FilePos;
  1429. filepos_t LastFilePos = -1;
  1431. DstMediaTime = -1;
  1432. if (*DstTime >= 0)
  1433. DstMediaTime = Scale(*DstTime,Stream->TimeScale,TICKSPERSEC);
  1435. NeedKey = GetNeedKey(Stream);
  1436. if (!NeedKey)
  1437. PrevKey = 0;
  1438. else
  1439. if (Stream->AllKey) // SyncTime will be independent anyway. we always need current chapter image
  1440. PrevKey = 1;
  1442. if (PrevKey && DstMediaTime >= 0)
  1443. DstMediaTime += 1+Stream->TimeScale/256; // seek to same position even if there is rounding error
  1445. Head(Stream,&Last);
  1446. Head(Stream,&Pos);
  1448. for (;;)
  1449. {
  1450. FilePos = *Pos.STCOPos;
  1451. if (FilePos == MAX_INT)
  1452. break;
  1454. NextChunk(Stream,&Pos);
  1456. while (Pos.SamplesLeft)
  1457. {
  1458. bool_t Key = Pos.SampleNo == Pos.STSSValue;
  1460. if (DstMediaTime >= 0 && Pos.CurrentTime >= DstMediaTime && (!NeedKey || Key))
  1461. {
  1462. if (PrevKey && Pos.CurrentTime != DstMediaTime && LastFilePos>=0)
  1463. {
  1464. FilePos = LastFilePos;
  1465. Pos = Last;
  1466. }
  1467. goto found;
  1468. }
  1470. if (DstPos >= 0 && FilePos >= DstPos)
  1471. goto found;
  1473. if (Key || Pos.STSSValue<0)
  1474. {
  1475. LastFilePos = FilePos;
  1476. Last = Pos;
  1477. }
  1479. if (Key) NextKey(&Pos);
  1480. FilePos += NextSample(Stream,&Pos);
  1481. }
  1482. }
  1484. if (LastFilePos>=0)
  1485. {
  1486. FilePos = LastFilePos;
  1487. Pos = Last;
  1488. }
  1489. found:
  1491. if (FilePos==MAX_INT || Reader->Seek(Reader,FilePos,SEEK_SET) != ERR_NONE)
  1492. return ERR_NOT_SUPPORTED;
  1494. Stream->Stream.Reader->Current = Pos.SamplesLeft ? &Stream->Stream:NULL;
  1495. Stream->Pos = Pos;
  1497. SyncTime = Scale(Pos.CurrentTime,TICKSPERSEC,Stream->TimeScale);
  1498. if (*DstTime >= 0 && (!Stream->AllKey || (abs(*DstTime-SyncTime)<TICKSPERSEC/16))) // use updated time with other Readers
  1499. *DstTime = SyncTime;
  1501. // set current positions for other streams
  1502. for (No=0;No<p->Format.StreamCount;++No)
  1503. {
  1504. mp4stream* s = (mp4stream*) p->Format.Streams[No];
  1505. if (s->Stream.Reader==Reader && s != Stream)
  1506. {
  1507. Head(s,&s->Pos);
  1508. for (;;)
  1509. {
  1510. if (*s->Pos.STCOPos >= FilePos)
  1511. break;
  1513. NextChunk(s,&s->Pos);
  1514. while (s->Pos.SamplesLeft)
  1515. {
  1516. if (s->Pos.SampleNo == s->Pos.STSSValue) 
  1517. NextKey(&s->Pos);
  1518. NextSample(s,&s->Pos);
  1519. }
  1520. }
  1521. }
  1522. }
  1523. }
  1525. return ERR_NONE;
  1526. }
  1528. static int Seek(mp4* p, tick_t DstTime, filepos_t DstPos, bool_t PrevKey)
  1529. {
  1530. int Result;
  1531. int Skip = -1;
  1532. int No;
  1534. for (No=0;No<MAXREADER;++No)
  1535. {
  1536. mp4stream* Stream = (mp4stream*) Format_DefSyncStream(&p->Format,&p->Format.Reader[No]);
  1537. if (Stream && GetNeedKey(Stream))
  1538. {
  1539. Skip = No;
  1540. Result = SeekReader(p,&p->Format.Reader[No],&DstTime,DstPos,PrevKey);
  1541. if (Result != ERR_NONE)
  1542. return Result;
  1543. if (Stream->AllKey && DstTime >= 0)
  1544. p->Format.SyncTime = DstTime;
  1545. break;
  1546. }
  1547. }
  1549. if (Skip<0)
  1550. PrevKey = 0;
  1552. for (No=0;No<MAXREADER;++No)
  1553. if (No != Skip)
  1554. {
  1555. Result = SeekReader(p,&p->Format.Reader[No],&DstTime,DstPos,PrevKey);
  1556. if (Result != ERR_NONE)
  1557. return Result;
  1558. }
  1560. Format_AfterSeek(&p->Format);
  1561. return ERR_NONE;
  1562. }
  1564. static void FreeStream(mp4* p, mp4stream* Stream)
  1565. {
  1566. ArrayClear(&Stream->STSS);
  1567. ArrayClear(&Stream->STSZ);
  1568. ArrayClear(&Stream->STTS);
  1569. ArrayClear(&Stream->STSC);
  1570. ArrayClear(&Stream->STCO);
  1571. }
  1573. static int Create(mp4* p)
  1574. {
  1575. p->Format.Init = (fmtfunc)Init;
  1576. p->Format.Seek = (fmtseek)Seek;
  1577. p->Format.ReadPacket = (fmtreadpacket)ReadPacket;
  1578. p->Format.FreeStream = (fmtstream)FreeStream;
  1579. return ERR_NONE;
  1580. }
  1582. static const nodedef MP4 =
  1583. {
  1584. sizeof(mp4),
  1585. MP4_ID,
  1586. FORMATBASE_CLASS,
  1587. PRI_DEFAULT,
  1588. (nodecreate)Create,
  1589. };
  1591. void MP4_Init()
  1592. {
  1593. NodeRegisterClass(&MP4);
  1594. }
  1596. void MP4_Done()
  1597. {
  1598. NodeUnRegisterClass(MP4_ID);
  1599. }