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

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

Windows CE

开发平台：

C/C++

avi.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: avi.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 "avi.h"
  27. #define INDEXSTEP 512
  29. #define AVI_INDEX_OF_INDEXES 0x00
  30. #define AVI_INDEX_OF_CHUNKS 0x01
  31. #define AVI_INDEX_KEY 0x80000000
  33. typedef struct aviindex
  34. {
  35. int32_t Id;
  36. int8_t Flags[4];
  37. int32_t Pos;
  38. int32_t Length;
  39. } aviindex;
  41. typedef struct avisuperindex
  42. {
  43. int Offset;
  44. int Size;
  45. int StartTime;
  46. int EndTime;
  47. int LastData;
  49. } avisuperindex;
  51. typedef struct avistdindex
  52. {
  53. uint32_t FourCC;
  54. int Size;
  55. int16_t LongsPerEntry;
  56. int8_t IndexSubType;
  57. int8_t IndexType;
  58. int Count;
  59. int ChunkId;
  60. int OffsetLow;
  61. int OffsetHigh;
  62. int Reserved;
  64. } avistdindex;
  66. typedef struct avistream
  67. {
  68. format_stream Stream;
  70. int* Index; // mediatime
  71. bool_t ByteRate;
  72. int RefStart;
  73. int MediaTime;
  74. int NewMediaTime; // after seek (if seek successed)
  75. fraction64 MediaRate; // byterate or packetrate
  76. int SampleSize;
  77. int MaxPacket;
  78. int Length;
  79. int SuperIndexCount;
  80. avisuperindex* SuperIndex; //opendml index
  81. int PrevKey;
  82. int PrevMediaTime;
  83. int PrevKeyBuffer;
  85. filepos_t OffsetMin;
  86. filepos_t OffsetMax;
  87. int* ZeroChunkPos;
  88. array ZeroChunk;
  89. int LastPos;
  91. } avistream;
  93. typedef struct avi
  94. {
  95. format_base Format;
  97. int FramePeriod;
  98. int ByteRate;
  99. bool_t ErrorIndex;
  100. bool_t UnLimited;
  101. bool_t CheckForZero;
  102. bool_t FoundStdIndex;
  104. int DataPos;
  105. int DataEnd;
  107. // stream header and format loading
  108. int HeadType;
  109. avistream* LastStream;
  111. int VideoHandler;
  112. int VideoFrames;
  113. fraction VideoFPS;
  114. int VideoStart;
  116. fraction AudioRate;
  117. int AudioLength;
  118. int AudioStart;
  119. int AudioSampleSize;
  121. int IndexAdjustPos;
  122. int IndexCount;
  123. int IndexPos;
  124. int IndexReaded;
  125. int IndexBufferNo;
  126. block IndexBuffer;
  128. char NameChar[256];
  130. int FoundTotal;
  131. int FoundAtEnd[8];
  132. int FoundLastPos[8];
  134. } avi;
  136. #define ALIGN2(x) (((x)+1)&~1)
  137. #define ISDIGIT(x) ((x)>='0' && (x)<='9')
  138. #define STREAMNO(x) ((((x) & 255)-'0')*10 + ((((x) >> 8) & 255)-'0'))
  139. #define ISDATA(x) (ISDIGIT((x) & 255) && ISDIGIT(((x) >> 8) & 255))
  140. #define ISIDX(x) (ISDIGIT(((x) >> 16) & 255) && ISDIGIT(((x) >> 24) & 255) && ((x) & 255)=='i' && (((x) >> 8) & 255)=='x')
  141. #define IDXNO(x) (((((x) >> 16) & 255)-'0')*10 + ((((x) >> 24) & 255)-'0'))
  143. static void Done(avi* p)
  144. {
  145. FreeBlock(&p->IndexBuffer);
  146. }
  148. #define CHECKINDEX 16384
  150. static NOINLINE int Load32LE(const uint8_t* i) { return LOAD32LE(i); }
  152. static void PreCheckIndexODML(avi* p,avistream* Stream)
  153. {
  154. int k;
  155. array Array = {NULL};
  156. avistdindex StdIndex;
  157. stream* Input = p->Format.Reader->Input;
  158. filepos_t Save = Input->Seek(Input,0,SEEK_CUR);
  159. if (Save>=0 && Input->Seek(Input,Stream->SuperIndex[0].Offset,SEEK_SET)>=0)
  160. {
  161. if (Input->Read(Input,&StdIndex,sizeof(StdIndex)) == sizeof(StdIndex) &&
  162. StdIndex.IndexType == AVI_INDEX_OF_CHUNKS &&
  163. StdIndex.LongsPerEntry == 2)
  164. {
  165. if (StdIndex.Count > 1024)
  166. StdIndex.Count = 1024;
  168. if (ArrayAppend(&Array,NULL,8*StdIndex.Count,1024))
  169. {
  170. if (Input->Read(Input,ARRAYBEGIN(Array,int32_t),8*StdIndex.Count) == 8*StdIndex.Count)
  171. {
  172. for (k=0;k<StdIndex.Count;++k)
  173. if ((ARRAYBEGIN(Array,int32_t)[k*2+1] & ~AVI_INDEX_KEY)==0)
  174. {
  175. p->CheckForZero = 1;
  176. break;
  177. }
  178. }
  179. ArrayClear(&Array);
  180. }
  181. }
  182. Input->Seek(Input,Save,SEEK_SET);
  183. }
  184. }
  186. static void PreCheckIndex(avi* p)
  187. {
  188. block Buffer;
  189. if (AllocBlock(CHECKINDEX,&Buffer,0,HEAP_ANY))
  190. {
  191. format_reader* Reader = p->Format.Reader;
  192. filepos_t Save = Reader->Input->Seek(Reader->Input,0,SEEK_CUR);
  193. if (Save>=0 && Reader->Input->Seek(Reader->Input,-CHECKINDEX,SEEK_END)>=0)
  194. {
  195. if (Reader->Input->ReadBlock(Reader->Input,&Buffer,0,CHECKINDEX)==CHECKINDEX)
  196. {
  197. int Type = 0;
  198. int LastNo;
  199. int No = 24;
  200. const uint8_t* i = Buffer.Ptr+CHECKINDEX-12;
  202. while (--i>=Buffer.Ptr+16)
  203. {
  204. if (p->NameChar[*i])
  205. {
  206. Type |= *i << No;
  207. No -= 8;
  208. if (No<0)
  209. {
  210. if (Type == FOURCCLE('J','U','N','K') && ISDATA(Load32LE(i-16)))
  211. {
  212. i -= 16;
  213. p->FoundStdIndex = 1;
  214. break;
  215. }
  216. if (ISDATA(Type) && (Load32LE(i+4) & ~0x10)==0)
  217. {
  218. p->FoundStdIndex = 1;
  219. break;
  220. }
  221. Type <<= 8;
  222. No += 8;
  223. }
  224. }
  225. else
  226. {
  227. Type = 0;
  228. No = 24;
  229. }
  230. }
  232. LastNo = -1;
  233. for (;i>=Buffer.Ptr+16;i-=16)
  234. {
  235. if (Load32LE(i-8) == FOURCCLE('i','d','x','1'))
  236. break;
  238. Type = Load32LE(i);
  239. if (ISDATA(Type))
  240. {
  241. int Pos = Load32LE(i+8);
  242. int No = STREAMNO(Type);
  243. if (No >= 0 && No < 8)
  244. {
  245. if (No != LastNo)
  246. {
  247. if (LastNo>=0)
  248. ++p->FoundAtEnd[LastNo];
  249. LastNo = No;
  250. }
  252. if (p->FoundLastPos[No] == Pos)
  253. p->CheckForZero = 1;
  255. p->FoundLastPos[No] = Pos;
  256. ++p->FoundTotal;
  257. }
  259. if (Load32LE(i+12)==0 && Pos==Load32LE(i-16+8))
  260. {
  261. p->CheckForZero = 1;
  262. break;
  263. }
  264. }
  265. }
  267. if (LastNo>=0)
  268. ++p->FoundAtEnd[LastNo];
  269. }
  270. Reader->Input->Seek(Reader->Input,Save,SEEK_SET);
  271. }
  273. FreeBlock(&Buffer);
  274. }
  275. }
  277. static int Init(avi* p)
  278. {
  279. int DataLength;
  280. int Type;
  281. format_reader* Reader = p->Format.Reader;
  283. if (!AllocBlock(sizeof(aviindex)*INDEXSTEP,&p->IndexBuffer,0,HEAP_ANY))
  284. return ERR_OUT_OF_MEMORY;
  286. memset(p->FoundAtEnd,0,sizeof(p->FoundAtEnd));
  287. memset(p->FoundLastPos,0,sizeof(p->FoundLastPos));
  288. p->LastStream = NULL;
  289. p->FoundTotal = 0;
  290. p->FoundStdIndex = 0;
  291. p->CheckForZero = 0;
  292. p->UnLimited = 1;
  293. p->IndexAdjustPos = 4;
  294. p->IndexPos = -1;
  295. p->IndexCount = 0;
  296. p->IndexReaded = 0;
  297. p->IndexBufferNo = -1;
  298. p->DataPos = -1;
  299. p->DataEnd = -1;
  300. p->ErrorIndex = 0;
  301. p->AudioLength = 0;
  303. memset(p->NameChar,0,sizeof(p->NameChar));
  304. memset(p->NameChar+'a',1,'z'-'a');
  305. memset(p->NameChar+'A',1,'Z'-'A');
  306. memset(p->NameChar+'0',1,'9'-'0');
  307. p->NameChar['_']=1;
  308. p->NameChar[' ']=1;
  310. Type = Reader->ReadLE32(Reader);
  311. DataLength = Reader->ReadLE32(Reader);
  313. if (Type != FOURCCLE('R','I','F','F'))
  314. return ERR_INVALID_DATA;
  316. if (DataLength > 256 && (p->Format.FileSize < 0 || p->Format.FileSize > DataLength + 8))
  317. p->Format.FileSize = DataLength + 8;
  319. Reader->ReadLE32(Reader); // 'AVI ' or 'AVIX'
  321. PreCheckIndex(p);
  322. return ERR_NONE;
  323. }
  325. static INLINE int ChunkTime(avistream* Stream, int DataLength)
  326. {
  327. if (Stream->ByteRate)
  328. return DataLength; //byterate
  330. // packetrate
  331. if (DataLength > Stream->MaxPacket) 
  332. return (DataLength + Stream->MaxPacket - 1) / Stream->MaxPacket;
  333. return 1;
  334. }
  336. static void UpdateAviFrameRate(avi* p)
  337. {
  338. if (QueryAdvanced(ADVANCED_AVIFRAMERATE) && p->AudioLength && p->VideoFrames)
  339. {
  340. int i;
  341. for (i=0;i<p->Format.StreamCount;++i)
  342. {
  343. avistream* Stream = (avistream*) p->Format.Streams[i];
  344. if (Stream->Stream.Format.Type == PACKET_VIDEO && Stream->Length)
  345. {
  346. Stream->MediaRate.Num = Scale64(p->AudioLength,(int64_t)p->AudioRate.Den*TICKSPERSEC,p->AudioRate.Num);
  347. Stream->MediaRate.Den = p->VideoFrames;
  348. }
  349. }
  350. }
  351. }
  353. static bool_t SubtitleTiming(format_packet* Packet,format_reader* Reader,int Length)
  354. {
  355. int Hour0,Hour1,Min0,Min1,Sec0,Sec1,MSec0,MSec1;
  356. int i;
  357. tchar_t s[64];
  358. for (i=0;i<63 && Length>0;++i)
  359. {
  360. int ch = Reader->Read8(Reader);
  361. --Length;
  362. if (ch<0 || ch==']') break;
  363. s[i] = (tchar_t)ch;
  364. }
  365. s[i] = 0;
  367. if (stscanf(s,T("[%d:%d:%d.%d-%d:%d:%d.%d"),&Hour0,&Min0,&Sec0,&MSec0,&Hour1,&Min1,&Sec1,&MSec1)!=8)
  368. {
  369. Reader->Skip(Reader,Length);
  370. return 0;
  371. }
  372. Packet->RefTime = Scale(((Hour0*60+Min0)*60+Sec0)*1000+MSec0,TICKSPERSEC,1000);
  373. Packet->EndRefTime = Scale(((Hour1*60+Min1)*60+Sec1)*1000+MSec1,TICKSPERSEC,1000);
  374. Packet->Data = Reader->ReadAsRef(Reader,Length);
  375. return 1;
  376. }
  378. static void SetMediaTime(avistream* p,int Time)
  379. {
  380. p->MediaTime = Time;
  381. p->ZeroChunkPos = ARRAYBEGIN(p->ZeroChunk,int);
  382. if (p->ZeroChunkPos)
  383. while (*p->ZeroChunkPos < Time)
  384. ++p->ZeroChunkPos;
  385. }
  387. static void ReadMeta(avi* p, format_reader* Reader, int* DataLength)
  388. {
  389. pin* Comment = &p->LastStream->Stream.Comment;
  390. tchar_t Meta[512];
  391. char UTF8[512];
  392. int Len = *DataLength;
  393. if (Len>=512) Len=511;
  394. Len = Reader->Read(Reader,UTF8,Len);
  395. if (Len>0)
  396. {
  397. *DataLength -= Len;
  398. UTF8[Len] = 0;
  399. tcscpy_s(Meta,TSIZEOF(Meta),T("LANGUAGE="));
  400. UTF8ToTcs(Meta+tcslen(Meta),TSIZEOF(Meta)-tcslen(Meta),UTF8);
  401. if (Comment->Node)
  402. Comment->Node->Set(Comment->Node,Comment->No,Meta,sizeof(Meta));
  403. }
  404. }
  406. static void CheckIndex(avi* p, format_reader* Reader);
  408. static int ReadPacket(avi* p, format_reader* Reader, format_packet* Packet)
  409. {
  410. avistream* Stream;
  411. int No,Ch,StartPos;
  412. int SubType,Type,DataLength;
  413. tick_t Duration;
  414. int LongsPerEntry;
  415. int IndexType;
  416. int Count;
  417. int BaseOffset;
  419. // find a valid chunk header first
  421. //DEBUG_MSG1(DEBUG_FORMAT,T("AVI Packet %08x"),Reader->FilePos);
  423. StartPos = Reader->FilePos;
  425. if (!p->UnLimited && p->DataEnd >= 0 && Reader->FilePos >= p->DataEnd)
  426. return ERR_END_OF_FILE;
  428. do
  429. {
  430. bool_t PossibleAlign = Reader->FilePos & 1;
  431. Type = 0;
  432. No = 0;
  433. while (No<32)
  434. {
  435. Ch = Reader->Read8(Reader);
  437. if (Ch>=0 && p->NameChar[Ch])
  438. {
  439. Type |= Ch << No;
  440. No += 8;
  442. if (No==32 && PossibleAlign)
  443. {
  444. int Stream = STREAMNO(Type);
  445. if (!ISDATA(Type) || ISDIGIT((Type>>16) & 255) || ISDIGIT((Type>>24) & 255) || 
  446. Stream <0 || Stream>=p->Format.StreamCount)
  447. {
  448. No -= 8;
  449. Type >>= 8;
  450. }
  451. }
  452. }
  453. else
  454. {
  455. if (!PossibleAlign)
  456. {
  457. Reader->OutOfSync = 1;
  458. if ((Reader->FilePos-StartPos)>=16384)
  459. return ERR_DATA_NOT_FOUND; // this will force the process loop to stop, so input thread can be woken up
  460. if (Reader->Eof(Reader))
  461. return ERR_END_OF_FILE;
  462. }
  463. No = 0;
  464. Type = 0;
  465. PossibleAlign = 0;
  466. }
  467. }
  469. if (!p->UnLimited && p->DataEnd >= 0 && Reader->FilePos >= p->DataEnd)
  470. return ERR_END_OF_FILE;
  472. DataLength = Reader->ReadLE32(Reader);
  474. if (DataLength<0 || (Reader->FilePos+DataLength<0) || (p->DataPos>=0 && p->Format.FileSize>=0 && Reader->FilePos+DataLength>p->Format.FileSize))
  475. {
  476. DataLength = -1;
  477. Reader->OutOfSync = 1;
  478. continue;
  479. }
  481. if (ISDATA(Type))
  482. {
  483. No = STREAMNO(Type);
  484. if (No >= 0 && No < p->Format.StreamCount)
  485. {
  486. //DEBUG_MSG3(-1,"AVI Packet stream:%d pos:%08x length:%d",No,Reader->FilePos,DataLength);
  488. Stream = (avistream*) p->Format.Streams[No];
  489. if (Stream->Stream.Reader != Reader)
  490. break;
  492. if (Reader->OutOfSync)
  493. {
  494. if (p->Format.ProcessTime >= 0)
  495. {
  496. int i;
  497. tick_t RefTime;
  499. // this won't solve the out of sync problem
  500. // but at least the streams won't be dropped
  502. for (i=0;i<p->Format.StreamCount;++i)
  503. {
  504. avistream* s = (avistream*) p->Format.Streams[i];
  505. if (s->Stream.Reader == Reader)
  506. {
  507. RefTime = s->RefStart+Scale64(s->MediaTime,s->MediaRate.Num,s->MediaRate.Den);
  508. if (RefTime < p->Format.ProcessTime - TICKSPERSEC)
  509. SetMediaTime(s,Scale64(p->Format.ProcessTime-s->RefStart,s->MediaRate.Den,s->MediaRate.Num));
  510. }
  511. }
  512. }
  513. Reader->OutOfSync = 0;
  514. }
  516. Packet->Stream = &Stream->Stream;
  518. if (Stream->ZeroChunkPos)
  519. while (*Stream->ZeroChunkPos == Stream->MediaTime)
  520. {
  521. Stream->MediaTime += ChunkTime(Stream,0);
  522. ++Stream->ZeroChunkPos;
  523. }
  525. if (Stream->Stream.Format.Type == PACKET_SUBTITLE)
  526. {
  527. if (!SubtitleTiming(Packet,Reader,DataLength))
  528. continue;
  529. }
  530. else
  531. {
  532. Packet->Data = Reader->ReadAsRef(Reader,DataLength);
  533. Packet->RefTime = Stream->RefStart+Scale64(Stream->MediaTime,Stream->MediaRate.Num,Stream->MediaRate.Den);
  534. }
  536. DEBUG_MSG5(DEBUG_FORMAT,T("AVI stream:%d time:%d mediatime:%d pos:%08x length:%08x"),No,Packet->RefTime,Stream->MediaTime,Reader->FilePos,DataLength);
  538. Stream->MediaTime += ChunkTime(Stream,DataLength);
  539. return ERR_NONE;
  540. }
  541. }
  543. if (ISIDX(Type))
  544. {
  545. No = IDXNO(Type);
  546. if (No >= 0 && No < p->Format.StreamCount)
  547. break; // opendml index
  548. }
  550. switch (Type)
  551. {
  552. case FOURCCLE('R','I','F','F'):
  553. Reader->ReadLE32(Reader); // 'AVI ' or 'AVIX'
  554. return ERR_NONE;
  556. case FOURCCLE('a','v','i','h'):
  557. if (p->Format.HeaderLoaded) break;
  558. p->FramePeriod = Reader->ReadLE32(Reader);
  559. p->ByteRate = Reader->ReadLE32(Reader);
  560. DataLength -= 8;
  561. break;
  563. case FOURCCLE('i','n','d','x'):
  564. if (p->Format.HeaderLoaded) break;
  565. // opendml index
  567. LongsPerEntry = Reader->ReadLE16(Reader);
  568. Reader->Read8(Reader); //subtype
  569. IndexType = Reader->Read8(Reader);
  570. Count = Reader->ReadLE32(Reader);
  571. Type = Reader->ReadLE32(Reader);
  572. BaseOffset = (int)Reader->ReadLE64(Reader);
  573. Reader->Skip(Reader,4);
  574. DataLength -= 6*4;
  576. if (ISDATA(Type))
  577. {
  578. No = STREAMNO(Type);
  579. if (No >= 0 && No < p->Format.StreamCount && Count)
  580. {
  581. avisuperindex* s;
  583. Stream = (avistream*) p->Format.Streams[No];
  585. if (IndexType == AVI_INDEX_OF_CHUNKS && LongsPerEntry==2)
  586. {
  587. p->UnLimited = 1;
  588. p->Format.FileSize = -1;
  590. // create fake index of indexes
  592. Stream->SuperIndexCount = 1;
  593. Stream->SuperIndex = s = (avisuperindex*) malloc(sizeof(avisuperindex));
  595. s->Offset = Reader->FilePos - 6*4 - 8;
  596. s->Size = DataLength + 6*4 + 8;
  597. s->StartTime = 0;
  598. s->EndTime = 0;
  599. s->LastData = 0;
  601. for (No=0;No<Count;++No)
  602. {
  603. int Data = BaseOffset + Reader->ReadLE32(Reader) - 8;
  604. int Size = Reader->ReadLE32(Reader) & ~AVI_INDEX_KEY;
  606. if (s->LastData < Data)
  607. s->LastData = Data;
  609. s->EndTime += ChunkTime(Stream,Size);
  610. }
  611. }
  612. if (IndexType == AVI_INDEX_OF_INDEXES && LongsPerEntry==4)
  613. {
  614. int Time;
  616. p->UnLimited = 1;
  617. p->Format.FileSize = -1;
  619. // load index of indexes
  621. Stream->SuperIndexCount = Count;
  622. Stream->SuperIndex = s = (avisuperindex*) malloc(sizeof(avisuperindex)*Count);
  624. Time = 0;
  625. for (No=0;No<Count;++No,++s)
  626. {
  627. s->Offset = (int)Reader->ReadLE64(Reader);
  628. s->Size = Reader->ReadLE32(Reader);
  629. s->StartTime = Time;
  630. Time += Reader->ReadLE32(Reader) * Stream->SampleSize;
  631.    s->EndTime = Time;
  632. s->LastData = -1;
  633. DataLength -= 16;
  634. }
  636. if (Count && !p->FoundStdIndex && !p->CheckForZero && Stream->Stream.Format.Type == PACKET_VIDEO)
  637. {
  638. LockEnter(p->Format.InputLock);
  639. PreCheckIndexODML(p,Stream);
  640. LockLeave(p->Format.InputLock);
  641. }
  642. }
  643. }
  644. }
  646. break;
  648. case FOURCCLE('s','t','r','h'):
  649. if (p->Format.HeaderLoaded) break;
  651. p->HeadType = Reader->ReadLE32(Reader);
  652. DataLength -= 4;
  654. if (p->HeadType == FOURCCLE('v','i','d','s'))
  655. {
  656. p->VideoHandler = Reader->ReadLE32(Reader);
  658. Reader->ReadLE32(Reader); // flags
  659. Reader->ReadLE16(Reader); // priority
  660. Reader->ReadLE16(Reader); // language
  661. Reader->ReadLE32(Reader); 
  663. p->VideoFPS.Den = Reader->ReadLE32(Reader); 
  664. p->VideoFPS.Num = Reader->ReadLE32(Reader); 
  666. if (!p->VideoFPS.Den || !p->VideoFPS.Num)
  667. {
  668. p->VideoFPS.Den = 1;
  669. p->VideoFPS.Num = 25;
  670. }
  671. if (p->VideoFPS.Den==1 && p->VideoFPS.Num >= 12000) //not important
  672. p->VideoFPS.Den = 1000;
  674. p->VideoStart = Reader->ReadLE32(Reader);
  675. p->VideoFrames = Reader->ReadLE32(Reader);
  677. DataLength -= 32;
  678. }
  679. else
  680. if (p->HeadType == FOURCCLE('a','u','d','s'))
  681. {
  682. Reader->ReadLE32(Reader); // format
  683. Reader->ReadLE32(Reader); // flags
  684. Reader->ReadLE16(Reader); // priority
  685. Reader->ReadLE16(Reader); // language
  686. Reader->ReadLE32(Reader); 
  687. p->AudioRate.Den = Reader->ReadLE32(Reader); 
  688. p->AudioRate.Num = Reader->ReadLE32(Reader); 
  689. p->AudioStart = Reader->ReadLE32(Reader);
  690. p->AudioLength = Reader->ReadLE32(Reader);
  692. Reader->ReadLE32(Reader); // initialframes
  693. Reader->ReadLE32(Reader); // suggested buffersize
  695. p->AudioSampleSize = Reader->ReadLE32(Reader);
  697. DataLength -= 44;
  698. }
  699. break;
  701. case FOURCCLE('s','t','r','n'):
  702. if (p->Format.HeaderLoaded) break;
  703. if (p->LastStream && DataLength)
  704. ReadMeta(p,Reader,&DataLength);
  705. break;
  707. case FOURCCLE('s','t','r','f'):
  708. if (p->Format.HeaderLoaded) break;
  709. if (p->HeadType == FOURCCLE('v','i','d','s'))
  710. {
  711. p->LastStream = Stream = (avistream*) Format_AddStream(&p->Format,sizeof(avistream));
  712. if (Stream)
  713. {
  714. Stream->Index = NULL;
  715. Stream->SuperIndex = NULL;
  716. Stream->ByteRate = 0;
  717. Stream->Stream.Fragmented = 0;
  718. Stream->SampleSize = 1;
  719. Stream->MaxPacket = MAX_INT;
  720. Format_BitmapInfo(Reader,&Stream->Stream,DataLength);
  722. if (Stream->Stream.Format.Format.Video.Pixel.FourCC == FOURCC('D','X','S','B'))
  723. {
  724. PacketFormatClear(&Stream->Stream.Format);
  725. Stream->Stream.Format.Type = PACKET_SUBTITLE;
  726. Stream->Stream.Format.Format.Subtitle.FourCC = FOURCC('D','X','S','B');
  727. }
  728. else
  729. {
  730. if (Stream->Stream.Format.Format.Video.Pixel.FourCC == 4)
  731. Stream->Stream.Format.Format.Video.Pixel.FourCC = UpperFourCC(p->VideoHandler);
  733. Stream->MediaRate.Den = p->VideoFPS.Num;
  734. Stream->MediaRate.Num = (int64_t)p->VideoFPS.Den * TICKSPERSEC;
  735. Stream->RefStart = Scale64(p->VideoStart,Stream->MediaRate.Num,Stream->MediaRate.Den);
  736. Stream->Length = p->VideoFrames;
  737. Stream->Stream.Format.PacketRate = p->VideoFPS;
  739. if (p->VideoFrames)
  740. {
  741. Duration = Scale64(p->VideoFrames,Stream->MediaRate.Num,Stream->MediaRate.Den);
  742. if (p->Format.Duration < Duration)
  743. p->Format.Duration = Duration;
  744. }
  746. UpdateAviFrameRate(p);
  747. }
  748. Format_PrepairStream(&p->Format,&Stream->Stream);
  749. }
  750. else
  751. Reader->Skip(Reader,DataLength);
  753. return ERR_NONE;
  754. }
  755. else
  756. if (p->HeadType == FOURCCLE('a','u','d','s'))
  757. {
  758. p->LastStream = Stream = (avistream*) Format_AddStream(&p->Format,sizeof(avistream));
  759. if (Stream)
  760. {
  761. Format_WaveFormat(Reader,&Stream->Stream,DataLength);
  763. // some encoders doesn't set AudioSampleSize, but still using CBR mode
  764. // detect it by insane packet rate
  765. if (!p->AudioSampleSize && p->AudioRate.Den*1000<=p->AudioRate.Num)
  766. p->AudioSampleSize = Stream->Stream.Format.Format.Audio.BlockAlign;
  768. Stream->Index = NULL;
  769. Stream->SuperIndex = NULL;
  770. Stream->ByteRate = p->AudioSampleSize != 0;
  771. Stream->Stream.Fragmented = Stream->ByteRate && p->AudioSampleSize <= 4;
  773. if (!Stream->ByteRate)
  774. {
  775. // VBR (packetrate)
  776. Stream->MediaRate.Den = p->AudioRate.Num;
  777. Stream->MediaRate.Num = (int64_t)p->AudioRate.Den * TICKSPERSEC;
  778. if (p->AudioRate.Num == Stream->Stream.Format.Format.Audio.SampleRate)
  779. Stream->MaxPacket = p->AudioRate.Den;
  780. else
  781. Stream->MaxPacket = MAX_INT;
  782. Stream->SampleSize = 1;
  783. }
  784. else
  785. {
  786. // CBR (byterate)
  788. // some digital cameras don't fill AudioSampleSize correctly only BlockAlign (with ADPCM)
  789. if (p->AudioSampleSize < Stream->Stream.Format.Format.Audio.BlockAlign)
  790. p->AudioSampleSize = Stream->Stream.Format.Format.Audio.BlockAlign;
  792. if (Stream->Stream.Format.Format.Audio.Format == 0x55 /*MP3*/ && 
  793. p->AudioRate.Num == 4977)
  794. {
  795. Stream->MediaRate.Den = (p->AudioRate.Num*16-7)*p->AudioSampleSize;
  796. Stream->MediaRate.Num = (int64_t)p->AudioRate.Den*TICKSPERSEC*16;
  797. }
  798. else
  799. {
  800. Stream->MediaRate.Den = p->AudioRate.Num*p->AudioSampleSize;
  801. Stream->MediaRate.Num = (int64_t)p->AudioRate.Den*TICKSPERSEC;
  802. }
  804. Stream->SampleSize = p->AudioSampleSize;
  805. }
  807. Stream->RefStart = Scale64(p->AudioStart,(int64_t)p->AudioRate.Den*TICKSPERSEC,p->AudioRate.Num);
  808. Stream->Length = p->AudioLength;
  810. if (p->AudioLength)
  811. {
  812. Duration = Scale64(p->AudioLength,(int64_t)p->AudioRate.Den*TICKSPERSEC,p->AudioRate.Num);
  813. if (Duration>0 && p->Format.Duration < Duration)
  814. p->Format.Duration = Duration;
  815. }
  817. UpdateAviFrameRate(p);
  818. Format_PrepairStream(&p->Format,&Stream->Stream);
  819. }
  820. else
  821. Reader->Skip(Reader,DataLength);
  822. return ERR_NONE;
  823. }
  824. else
  825. p->LastStream = NULL;
  826. break;
  828. case FOURCCLE('L','I','S','T'):
  829. SubType = Reader->ReadLE32(Reader);
  830. DataLength -= 4;
  832. switch (SubType)
  833. {
  834. case FOURCCLE('s','t','r','l'):
  835. return ERR_NONE;
  837. case FOURCCLE('h','d','r','l'):
  838. return ERR_NONE;
  840. case FOURCCLE('m','o','v','i'):
  841. if (p->Format.HeaderLoaded) return ERR_NONE;
  842. p->DataPos = Reader->FilePos;
  843. p->DataEnd = DataLength + Reader->FilePos;
  844. p->Format.HeaderLoaded = 1;
  846. if (p->FoundTotal >= 256 && p->Format.StreamCount>1)
  847. {
  848. for (No=0;No<p->Format.StreamCount && No<8;++No)
  849. if (p->FoundAtEnd[No] < 2)
  850. p->CheckForZero = 1; // possibly non interleaved streams
  851. }
  853. if (p->CheckForZero)
  854. {
  855. LockEnter(p->Format.InputLock);
  856. CheckIndex(p,Reader);
  857. LockLeave(p->Format.InputLock);
  858. }
  860. for (No=0;No<p->Format.StreamCount;++No)
  861. SetMediaTime((avistream*)p->Format.Streams[No],0);
  863. return ERR_NONE;
  865. case FOURCCLE('o','d','m','l'):
  866. break;
  868. default:
  869. return ERR_NONE;
  870. }
  871. break;
  873. case FOURCCLE('J','U','N','K'):
  874. case FOURCCLE('i','d','x','1'):
  875. break;
  877. default: 
  878. if (Reader->OutOfSync || DataLength > 256*1024) // unknown
  879. DataLength = -1;
  880. }
  881. }
  882. while (DataLength<0);
  884. Reader->Skip(Reader,DataLength);
  886. return ERR_NONE;
  887. }
  889. static int ErrorIndex(avi* p,stream* Input,filepos_t OldFilePos)
  890. {
  891. if (OldFilePos>=0)
  892. {
  893. if (Input)
  894. Input->Seek(Input,OldFilePos,SEEK_SET);
  896. if (!p->ErrorIndex)
  897. {
  898. p->ErrorIndex = 1;
  899. ShowError(p->Format.Format.Class,AVI_ID,AVI_NO_INDEX);
  900. }
  901. }
  902. return ERR_NOT_SUPPORTED;
  903. }
  905. static INLINE const aviindex* IndexBuffer(avi* p,int n)
  906. {
  907. return ((const aviindex*)p->IndexBuffer.Ptr)+n;
  908. }
  910. static int LoadIndexBuffer(avi* p,stream* Input,int No,filepos_t OldFilePos)
  911. {
  912. if (p->IndexBufferNo != No)
  913. {
  914. int Bytes = (p->IndexCount - No*INDEXSTEP)*sizeof(aviindex);
  915. if (Bytes > INDEXSTEP*sizeof(aviindex))
  916. Bytes = INDEXSTEP*sizeof(aviindex);
  918. if (Input->Seek(Input,p->IndexPos+No*INDEXSTEP*sizeof(aviindex),SEEK_SET)<0)
  919. return ErrorIndex(p,Input,OldFilePos);
  921. if (Input->ReadBlock(Input,&p->IndexBuffer,0,Bytes) != Bytes)
  922. return ErrorIndex(p,Input,OldFilePos);
  924. p->IndexBufferNo = No;
  926. if (No == 0)
  927. {
  928. if (INT32LE(IndexBuffer(p,0)->Pos) == p->DataPos)
  929. p->IndexAdjustPos = p->DataPos;
  930. else
  931. p->IndexAdjustPos = 4;
  932. }
  933. }
  934. return ERR_NONE;
  935. }
  937. static int ReadIndex(stream* Input,avistream* Stream,avisuperindex* Index,int MediaTime,int DstPos,bool_t PrevKey)
  938. {
  939. bool_t NeedKey = Stream->Stream.Format.Type == PACKET_VIDEO;
  940. avistdindex StdIndex;
  941. int No;
  942. int FoundPos = -1;
  943. int32_t* i; 
  944. int LookBack = 0;
  946. if (!NeedKey)
  947. PrevKey = 0;
  949. if (PrevKey)
  950. LookBack = 300;
  952. if (DstPos>=0 && Index->LastData>=0 && DstPos > Index->LastData)
  953. return -1;
  955. if (MediaTime>=0 && Index->EndTime + LookBack <= MediaTime)
  956. return -1;
  958. if (Input->Seek(Input,Index->Offset,SEEK_SET) < 0)
  959. return -2;
  961. if (Input->Read(Input,&StdIndex,sizeof(StdIndex)) != sizeof(StdIndex))
  962. return -1;
  964. if (StdIndex.IndexType != AVI_INDEX_OF_CHUNKS ||
  965. StdIndex.LongsPerEntry != 2)
  966. return -1;
  968. i = (int32_t*) malloc(8*StdIndex.Count);
  969. if (!i)
  970. return -1;
  972. if (Input->Read(Input,i,8*StdIndex.Count) != 8*StdIndex.Count)
  973. {
  974. free(i);
  975. return -1;
  976. }
  978. if (Index->LastData<0)
  979. {
  980. Index->LastData = 0;
  981. for (No=0;No<StdIndex.Count;++No)
  982. {
  983. int Data = StdIndex.OffsetLow + i[No*2] - 8;
  984. int Size = i[No*2+1] & ~AVI_INDEX_KEY;
  985. if (Size && Index->LastData < Data)
  986. Index->LastData = Data;
  987. }
  988. }
  990. Stream->NewMediaTime = Index->StartTime;
  992. for (No=0;No<StdIndex.Count;++No)
  993. {
  994. int Data = StdIndex.OffsetLow + i[No*2] - 8;
  995. int Size = i[No*2+1];
  997. if (MediaTime>=0)
  998. {
  999. if (Stream->NewMediaTime >= MediaTime && (!NeedKey || !(Size & AVI_INDEX_KEY))) 
  1000. {
  1001. if (PrevKey && Stream->NewMediaTime != MediaTime && Stream->PrevKey>=0)
  1002. {
  1003. Stream->NewMediaTime = Stream->PrevMediaTime;
  1004. FoundPos = Stream->PrevKey; // use previous key
  1005. }
  1006. else
  1007. FoundPos = Data; // found sample after mediatime
  1008. break;
  1009. }
  1011. if (PrevKey && !(Size & AVI_INDEX_KEY))
  1012. {
  1013. Stream->PrevMediaTime = Stream->NewMediaTime;
  1014. Stream->PrevKey = Data;
  1015. }
  1016. }
  1018. if (DstPos>=0 && Data >= DstPos) 
  1019. {
  1020. FoundPos = Data; // found a sample after the destination position
  1021. break; 
  1022. }
  1024. Stream->NewMediaTime = Stream->NewMediaTime + ChunkTime(Stream,Size & ~AVI_INDEX_KEY);
  1025. }
  1027. free(i);
  1028. return FoundPos;
  1029. }
  1031. static int RestorePrevKey(avi* p,avistream* Stream,int No,int OldFilePos,int* Pos)
  1032. {
  1033. int i,j;
  1034. avistream* s;
  1036. if (Stream->PrevKeyBuffer != No)
  1037. {
  1038. int Result = LoadIndexBuffer(p,Stream->Stream.Reader->Input,Stream->PrevKeyBuffer,OldFilePos);
  1039. if (Result != ERR_NONE)
  1040. return Result;
  1042. No = Stream->PrevKeyBuffer;
  1043. }
  1045. // restart this block and recalc NewMediaTime
  1046. for (j=0;j<p->Format.StreamCount;++j)
  1047. {
  1048. s = (avistream*) p->Format.Streams[j];
  1049. s->NewMediaTime = s->Index[No];
  1050. }
  1052. for (i=0;i<Stream->PrevKey;++i)
  1053. {
  1054. j = STREAMNO(IndexBuffer(p,i)->Id);
  1055. if (j>=0 && j<p->Format.StreamCount)
  1056. {
  1057. s = (avistream*) p->Format.Streams[j];
  1058. s->NewMediaTime += ChunkTime(s,IndexBuffer(p,i)->Length);
  1059. }
  1060. }
  1062. *Pos = INT32LE(IndexBuffer(p,i)->Pos) - p->IndexAdjustPos;
  1063. return ERR_NONE;
  1064. }
  1066. static int FindIndexPos(avi* p,stream* Input)
  1067. {
  1068. int OldFilePos = Input->Seek(Input,0,SEEK_CUR);
  1069. int Pos = p->DataEnd;
  1070. // try to find index block
  1072. if (Input->Seek(Input,Pos,SEEK_SET) < 0)
  1073. return ERR_NOT_SUPPORTED;
  1075. for (;;)
  1076. {
  1077. int32_t Head[2];
  1079. if (Pos & 1)
  1080. {
  1081. if (Input->Read(Input,Head,sizeof(Head)) != sizeof(Head))
  1082. return ErrorIndex(p,Input,OldFilePos);
  1084. Pos += sizeof(Head);
  1086. if (Head[0] != FOURCC('i','d','x','1'))
  1087. {
  1088. memmove((char*)Head,(char*)Head+1,sizeof(Head)-1);
  1089. if (Input->Read(Input,(char*)Head+sizeof(Head)-1,1) != 1)
  1090. return ErrorIndex(p,Input,OldFilePos);
  1091. ++Pos;
  1092. }
  1093. }
  1094. else
  1095. {
  1096. if (Input->Read(Input,Head,sizeof(Head)) != sizeof(Head))
  1097. return ErrorIndex(p,Input,OldFilePos);
  1098. Pos += sizeof(Head);
  1099. }
  1101. if (Head[0] == FOURCC('i','d','x','1'))
  1102. {
  1103. int i,No;
  1105. p->IndexCount = Head[1] / sizeof(aviindex);
  1107. i = ((p->IndexCount + INDEXSTEP - 1) / INDEXSTEP) + 1;
  1109. for (No=0;No<p->Format.StreamCount;++No)
  1110. {
  1111. avistream* s = (avistream*) p->Format.Streams[No];
  1112. s->Index = (int*) malloc(sizeof(int)*i);
  1113. if (!s->Index)
  1114. return ERR_OUT_OF_MEMORY;
  1116. s->Index[0] = 0;
  1117. }
  1119. p->IndexPos = Pos;
  1120. p->IndexReaded = 0;
  1121. break;
  1122. }
  1124. if (Head[1]<0 || (Pos+Head[1]<0))
  1125. return ErrorIndex(p,Input,OldFilePos);
  1127. Pos += Head[1];
  1129. if (Input->Seek(Input,Pos,SEEK_SET) != Pos)
  1130. return ErrorIndex(p,Input,OldFilePos);
  1131. }
  1132. return ERR_NONE;
  1133. }
  1135. static NOINLINE int CheckIndexBuffer(avi* p,stream* Input,int No,filepos_t OldFilePos,int IndexCount)
  1136. {
  1137. // load page and calc sum mediatime
  1138. if (p->IndexReaded <= No)
  1139. {
  1140. int i,j;
  1141. int Result = LoadIndexBuffer(p,Input,No,OldFilePos);
  1142. if (Result != ERR_NONE)
  1143. return Result;
  1145. for (j=0;j<p->Format.StreamCount;++j)
  1146. {
  1147. avistream* s = (avistream*) p->Format.Streams[j];
  1148. s->Index[No+1] = s->Index[No];
  1149. }
  1151. for (i=0;i<IndexCount;++i)
  1152. {
  1153. j = STREAMNO(IndexBuffer(p,i)->Id);
  1154. if (j>=0 && j<p->Format.StreamCount)
  1155. {
  1156. avistream* s = (avistream*) p->Format.Streams[j];
  1157. s->Index[No+1] += ChunkTime(s,INT32LE(IndexBuffer(p,i)->Length));
  1158. }
  1159. }
  1161. p->IndexReaded = No+1;
  1162. }
  1163. return ERR_NONE;
  1164. }
  1166. static int Seek(avi* p, tick_t Time, filepos_t FilePos, bool_t PrevKey)
  1167. {
  1168. int Result = ERR_NONE;
  1169. int RNo;
  1170. if (p->DataPos < 0)
  1171. {
  1172. // no avi header yet, only seek to the beginning supported
  1174. if (Time>0 || FilePos>0)
  1175. return ERR_NOT_SUPPORTED;
  1177. p->Format.Reader[0].OutOfSync = 0;
  1178. return Format_Seek(&p->Format,0,SEEK_SET);
  1179. }
  1181. for (RNo=0;RNo<MAXREADER;++RNo)
  1182. {
  1183. filepos_t Pos = -1;
  1184. avistream* Stream;
  1185. avistream* s;
  1186. int i,j,No;
  1187. format_reader* Reader = &p->Format.Reader[RNo];
  1188. stream* Input = Reader->Input;
  1189. filepos_t OldReaderPos = Reader->FilePos;
  1190. filepos_t OldFilePos;
  1192. if (!Input)
  1193. break;
  1195. OldFilePos = Input->Seek(Input,0,SEEK_CUR);
  1197. if (Time <= 0 && FilePos <= 0)
  1198. {
  1199. // seek to the beginning (no index needed for that)
  1201. Pos = Reader->OffsetMin<MAX_INT?Reader->OffsetMin:p->DataPos;
  1203. for (j=0;j<p->Format.StreamCount;++j)
  1204. if (p->Format.Streams[j]->Reader == Reader)
  1205. ((avistream*)p->Format.Streams[j])->NewMediaTime = 0;
  1206. }
  1207. else
  1208. {
  1209. Stream = (avistream*) Format_DefSyncStream(&p->Format,Reader);
  1210. if (Stream)
  1211. {
  1212. bool_t NeedKey = Stream->Stream.Format.Type == PACKET_VIDEO;
  1213. int MediaTime = Scale64(Time,Stream->MediaRate.Den,Stream->MediaRate.Num);
  1215. Stream->PrevKey = -1;
  1217. if (PrevKey)
  1218. ++MediaTime; // seek to same position even if there is rounding error
  1220. if (Stream->SuperIndex)
  1221. {
  1222. // using OpenDML index
  1223. if (MediaTime >= Stream->SuperIndex[Stream->SuperIndexCount-1].EndTime)
  1224. MediaTime = Stream->SuperIndex[Stream->SuperIndexCount-1].EndTime-1;
  1226. // find position by MediaTime
  1227. for (No=0;No<Stream->SuperIndexCount;++No)
  1228. {
  1229. Pos = ReadIndex(Input,Stream,Stream->SuperIndex+No,MediaTime,-1,PrevKey);
  1230. if (Pos == -2)
  1231. return ERR_NOT_SUPPORTED;
  1233. if (Pos >= 0)
  1234. break;
  1235. }
  1237. if (Pos<0)
  1238. {
  1239. if (PrevKey && Stream->PrevKey>=0)
  1240. {
  1241. Stream->NewMediaTime = Stream->PrevMediaTime;
  1242. Pos = Stream->PrevKey;
  1243. }
  1244. else
  1245. {
  1246. Stream->NewMediaTime = Stream->SuperIndex[Stream->SuperIndexCount-1].EndTime;
  1247. Pos = Stream->SuperIndex[Stream->SuperIndexCount-1].LastData;
  1249. if (Pos<0)
  1250. return ErrorIndex(p,Input,OldFilePos);
  1251. }
  1252. }
  1254. // calculate NewMediaTime for all other streams
  1255. for (j=0;j<p->Format.StreamCount;++j)
  1256. {
  1257. s = (avistream*) p->Format.Streams[j];
  1258. if (s->Stream.Reader==Reader && s != Stream)
  1259. {
  1260. // find position by Pos
  1261. for (No=0;No<s->SuperIndexCount;++No)
  1262. if (ReadIndex(Input,s,s->SuperIndex+No,-1,Pos,0) >= 0)
  1263. break;
  1265. if (No==s->SuperIndexCount)
  1266. s->NewMediaTime = s->SuperIndex[s->SuperIndexCount-1].EndTime;
  1267. }
  1268. }
  1269. }
  1270. else
  1271. {
  1272. int Next;
  1273. int IndexCount,IndexLeft;
  1274. tick_t LookBack = 0;
  1276. // do we have the index block?
  1277. if (p->IndexPos < 0)
  1278. {
  1279. Result = FindIndexPos(p,Input);
  1280. if (Result!=ERR_NONE)
  1281. return Result;
  1282. }
  1284. IndexLeft = p->IndexCount;
  1286. if (!NeedKey)
  1287. PrevKey = 0;
  1289. if (PrevKey)
  1290. LookBack = 300;
  1292. // find the index page
  1294. for (No=0;IndexLeft>0;++No,IndexLeft-=INDEXSTEP)
  1295. {
  1296. IndexCount = IndexLeft;
  1297. if (IndexCount > INDEXSTEP)
  1298. IndexCount = INDEXSTEP;
  1300. Result = CheckIndexBuffer(p,Input,No,OldFilePos,IndexCount);
  1301. if (Result != ERR_NONE)
  1302. return Result;
  1304. //DEBUG_MSG4(DEBUG_FORMAT,"AVI IndexBlock no:%d start:%d end:%d (target:%d)",No,Stream->Index[No],Stream->Index[No+1],MediaTime);
  1306. if (Stream->Index[No]!=Stream->Index[No+1] &&
  1307. (Stream->Index[No+1]+LookBack > MediaTime || IndexLeft<2*INDEXSTEP))
  1308. {
  1309. Result = LoadIndexBuffer(p,Input,No,OldFilePos);
  1310. if (Result != ERR_NONE)
  1311. return Result;
  1313. for (j=0;j<p->Format.StreamCount;++j)
  1314. {
  1315. s = (avistream*) p->Format.Streams[j];
  1316. if (s->Stream.Reader == Reader)
  1317. s->NewMediaTime = s->Index[No];
  1318. }
  1320. // find sub page position
  1322. for (i=0;i<IndexCount;++i)
  1323. {
  1324. j = STREAMNO(IndexBuffer(p,i)->Id);
  1325. if (j>=0 && j<p->Format.StreamCount && p->Format.Streams[j]->Reader==Reader)
  1326. {
  1327. s = (avistream*) p->Format.Streams[j];
  1328. Next = s->NewMediaTime + ChunkTime(s,IndexBuffer(p,i)->Length);
  1330. //DEBUG_MSG3(DEBUG_FORMAT,"AVI Index stream:%d pos:%d flag:%d",j,INT32LE(IndexBuffer(p,i)->Pos),IndexBuffer(p,i)->Flags[0]);
  1332. if (s==Stream)
  1333. {
  1334. Pos = INT32LE(IndexBuffer(p,i)->Pos) - p->IndexAdjustPos;
  1336. if (s->NewMediaTime >= MediaTime)
  1337. {
  1338. // only accept keyframes with valid position
  1339. if (Pos >= 0 && Pos < p->DataEnd - p->DataPos &&
  1340. (!NeedKey || (IndexBuffer(p,i)->Flags[0] & 0x10)))
  1341. {
  1342. if (PrevKey && s->NewMediaTime != MediaTime && Stream->PrevKey>=0)
  1343. {
  1344. Result = RestorePrevKey(p,Stream,No,OldFilePos,&Pos);
  1345. if (Result != ERR_NONE)
  1346. return Result;
  1347. }
  1348. break;
  1349. }
  1350. }
  1352. if (Pos >= 0 && Pos < p->DataEnd - p->DataPos &&
  1353. (IndexBuffer(p,i)->Flags[0] & 0x10))
  1354. {
  1355. Stream->PrevKey = i;
  1356. Stream->PrevKeyBuffer = No;
  1357. }
  1358. }
  1360. s->NewMediaTime = Next;
  1361. }
  1362. }
  1364. // found? 
  1365. if (i<IndexCount)
  1366. break;
  1367. }
  1368. }
  1370. if (IndexLeft <= 0)
  1371. {
  1372. if (Stream->PrevKey>=0)
  1373. {
  1374. Result = RestorePrevKey(p,Stream,No,OldFilePos,&Pos);
  1375. if (Result != ERR_NONE)
  1376. return Result;
  1377. }
  1378. else
  1379. {
  1380. // go to end
  1381. for (j=0;j<p->Format.StreamCount;++j)
  1382. {
  1383. s = (avistream*) p->Format.Streams[j];
  1384. s->NewMediaTime = s->Index[p->IndexReaded];
  1385. }
  1387. Pos = p->DataEnd - p->DataPos;
  1388. }
  1389. }
  1391. Pos += p->DataPos;
  1392. }
  1394. if (NeedKey && Stream->NewMediaTime >= 0) // use updated time with other Readers
  1395. Time = Scale64(Stream->NewMediaTime,Stream->MediaRate.Num,Stream->MediaRate.Den);
  1396. }
  1397. }
  1399. if (Pos>=0)
  1400. {
  1401. Reader->FilePos = -1; // force seek, because Input changed
  1402. if (Reader->Seek(Reader,Pos,SEEK_SET) != ERR_NONE)
  1403. {
  1404. Reader->FilePos = OldReaderPos;
  1405. // restore old input position
  1406. Input->Seek(Input,OldFilePos,SEEK_SET);
  1407. return ERR_NOT_SUPPORTED;
  1408. }
  1410. // set new positions
  1411. for (j=0;j<p->Format.StreamCount;++j)
  1412. if (p->Format.Streams[j]->Reader == Reader)
  1413. {
  1414. s = (avistream*) p->Format.Streams[j];
  1415. SetMediaTime(s,s->NewMediaTime);
  1416. }
  1418. Reader->OutOfSync = 0;
  1419. }
  1420. }
  1422. Format_AfterSeek(&p->Format);
  1423. return ERR_NONE;
  1424. }
  1426. static NOINLINE void AddZeroChunk(avistream* Stream)
  1427. {
  1428. ArrayAppend(&Stream->ZeroChunk,&Stream->NewMediaTime,sizeof(Stream->NewMediaTime),512);
  1429. }
  1431. static void CheckIndex(avi* p, format_reader* Reader)
  1432. {
  1433. bool_t FlushBuffers = 0;
  1434. avistream* Stream;
  1435. int i,j,k;
  1436. bool_t OpenDML = 0;
  1437. array Array = {NULL};
  1438. stream* Input = Reader->Input;
  1439. filepos_t OldFilePos = Input->Seek(Input,0,SEEK_CUR);
  1440. filepos_t OldReaderPos = Reader->FilePos;
  1442. if (OldFilePos<0)
  1443. return;
  1445. for (i=0;i<p->Format.StreamCount;++i)
  1446. {
  1447. Stream = (avistream*)p->Format.Streams[i];
  1448. Stream->NewMediaTime = 0;
  1449. Stream->OffsetMin = MAX_INT;
  1450. Stream->OffsetMax = 0;
  1451. Stream->LastPos = 0;
  1453. if (Stream->SuperIndex) // we need non video streams as well for offsetmin/max
  1454. {
  1455. OpenDML = 1;
  1457. for (j=0;j<Stream->SuperIndexCount;++j)
  1458. {
  1459. avistdindex StdIndex;
  1461. if (Input->Seek(Input,Stream->SuperIndex[j].Offset,SEEK_SET) < 0)
  1462. break;
  1464. if (Input->Read(Input,&StdIndex,sizeof(StdIndex)) != sizeof(StdIndex))
  1465. break;
  1467. if (StdIndex.IndexType != AVI_INDEX_OF_CHUNKS ||
  1468. StdIndex.LongsPerEntry != 2)
  1469. break;
  1471. ArrayDrop(&Array);
  1472. if (!ArrayAppend(&Array,NULL,8*StdIndex.Count,1024))
  1473. break;
  1475. if (Input->Read(Input,ARRAYBEGIN(Array,int32_t),8*StdIndex.Count) != 8*StdIndex.Count)
  1476. break;
  1478. for (k=0;k<StdIndex.Count;++k)
  1479. {
  1480. int Pos = StdIndex.OffsetLow + ARRAYBEGIN(Array,int32_t)[k*2] - 8;
  1481. int Size = ARRAYBEGIN(Array,int32_t)[k*2+1] & ~AVI_INDEX_KEY;
  1482. if (!Size)
  1483. AddZeroChunk(Stream);
  1484. else
  1485. {
  1486. if (Stream->OffsetMin>Pos)
  1487. Stream->OffsetMin=Pos;
  1488. if (Stream->OffsetMax<Pos)
  1489. Stream->OffsetMax=Pos;
  1490. }
  1491. Stream->NewMediaTime = Stream->NewMediaTime + ChunkTime(Stream,Size);
  1492. }
  1493. }
  1494. }
  1495. }
  1497. if (!OpenDML && (p->IndexPos>=0 || FindIndexPos(p,Input)==ERR_NONE))
  1498. {
  1499. int IndexLeft = p->IndexCount;
  1500. int IndexCount;
  1501. int LastPos = 0;
  1503. for (i=0;IndexLeft>0;++i,IndexLeft-=INDEXSTEP)
  1504. {
  1505. IndexCount = IndexLeft;
  1506. if (IndexCount > INDEXSTEP)
  1507. IndexCount = INDEXSTEP;
  1509. if (CheckIndexBuffer(p,Input,i,-1,IndexCount)==ERR_NONE && 
  1510. LoadIndexBuffer(p,Input,i,-1)==ERR_NONE)
  1511. {
  1512. for (k=0;k<IndexCount;++k)
  1513. {
  1514. j = STREAMNO(IndexBuffer(p,k)->Id);
  1515. if (j>=0 && j<p->Format.StreamCount)
  1516. {
  1517. int Pos = IndexBuffer(p,k)->Pos - p->IndexAdjustPos + p->DataPos;
  1518. int Size = IndexBuffer(p,k)->Length;
  1519. Stream = (avistream*) p->Format.Streams[j];
  1520. if ((Size==0 && Pos==LastPos) || (Pos==Stream->LastPos))
  1521. AddZeroChunk(Stream);
  1522. if (Size)
  1523. {
  1524. if (Stream->OffsetMin>Pos)
  1525. Stream->OffsetMin=Pos;
  1526. if (Stream->OffsetMax<Pos)
  1527. Stream->OffsetMax=Pos;
  1528. }
  1529. LastPos = Pos;
  1530. Stream->LastPos=Pos;
  1531. Stream->NewMediaTime = Stream->NewMediaTime + ChunkTime(Stream,Size);
  1532. }
  1533. }
  1534. }
  1535. }
  1536. }
  1538. for (i=0;i<p->Format.StreamCount;++i)
  1539. {
  1540. Stream = (avistream*)p->Format.Streams[i];
  1541. if (!ARRAYEMPTY(Stream->ZeroChunk))
  1542. {
  1543. Stream->NewMediaTime = MAX_INT;
  1544. AddZeroChunk(Stream);
  1545. }
  1546. if (Stream->OffsetMax)
  1547. {
  1548. format_reader* Reader = Format_FindReader(&p->Format,Stream->OffsetMin,Stream->OffsetMax);
  1549. if (Reader)
  1550. Stream->Stream.Reader = Reader;
  1551. }
  1552. }
  1554. ArrayClear(&Array);
  1556. for (i=0;i<MAXREADER;++i)
  1557. {
  1558. format_reader* v = &p->Format.Reader[i];
  1559. if (v->Input && v->OffsetMax>0)
  1560. {
  1561. v->Seek(v,v->OffsetMin,SEEK_SET);
  1562. FlushBuffers = 1;
  1563. if (Reader == v)
  1564. OldReaderPos = v->OffsetMin;
  1565. }
  1566. }
  1568. if (!FlushBuffers)
  1569. Input->Seek(Input,OldFilePos,SEEK_SET);
  1570. else
  1571. {
  1572. // probably first reader already allocated all the buffers
  1573. Reader->FilePos = -1;
  1574. Reader->Seek(Reader,OldReaderPos,SEEK_SET);
  1575. }
  1576. }
  1578. static int Set(avi* p,int No,const void* Data,int Size)
  1579. {
  1580. if (No == NODE_SETTINGSCHANGED)
  1581. UpdateAviFrameRate(p);
  1583. return FormatBaseSet(&p->Format,No,Data,Size);
  1584. }
  1586. static void FreeStream(avi* p, avistream* Stream)
  1587. {
  1588. free(Stream->Index);
  1589. free(Stream->SuperIndex);
  1590. ArrayClear(&Stream->ZeroChunk);
  1591. }
  1593. static int Create(avi* p)
  1594. {
  1595. p->Format.Format.Set = (nodeset)Set;
  1596. p->Format.Init = (fmtfunc)Init;
  1597. p->Format.Done = (fmtvoid)Done;
  1598. p->Format.Seek = (fmtseek)Seek;
  1599. p->Format.ReadPacket = (fmtreadpacket)ReadPacket;
  1600. p->Format.FreeStream = (fmtstream)FreeStream;
  1601. p->Format.MinHeaderLoad = MAX_INT; //manualy setting HeaderLoaded
  1602. return ERR_NONE;
  1603. }
  1605. static const nodedef AVI = 
  1606. {
  1607. sizeof(avi),
  1608. AVI_ID,
  1609. FORMATBASE_CLASS,
  1610. PRI_DEFAULT,
  1611. (nodecreate)Create,
  1612. };
  1614. void AVI_Init()
  1615. {
  1616. NodeRegisterClass(&AVI);
  1617. }
  1619. void AVI_Done()
  1620. {
  1621. NodeUnRegisterClass(AVI_ID);
  1622. }