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

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

Windows CE

开发平台：

C/C++

format_base.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: format_base.c 611 2006-01-25 22:01:51Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "common.h"
  26. #define DROP_SHOW 8
  28. #define ENDCHUNKS (128*1024/BLOCKSIZE)
  29. #define SKIPDISTANCE 64*1024
  31. #define SYNCREAD 6
  33. #define SEEKTRIES 4
  34. #define SEEKMAXREAD 256*1024
  36. #define PROCESSMINAUDIO BLOCKSIZE
  37. #define PROCESSMINVIDEO 128*1024
  39. #define READER_BONUS 256*1024
  41. int FormatBaseEnum(format_base* p,int* No,datadef* Param)
  42. {
  43. if (FormatEnum(p,No,Param) == ERR_NONE)
  44. return ERR_NONE;
  46. if (*No < p->TotalCount)
  47. {
  48. memset(Param,0,sizeof(datadef));
  49. Param->Class = FORMAT_CLASS;
  50. Param->Size = sizeof(pin);
  51. Param->No = FORMAT_STREAM + *No;
  52. Param->Type = TYPE_PACKET;
  53. Param->Flags = DF_OUTPUT;
  54. *No = 0;
  55. return ERR_NONE;
  56. }
  57. *No -= p->TotalCount;
  59. if (*No < p->TotalCount)
  60. {
  61. memset(Param,0,sizeof(datadef));
  62. Param->Class = FORMAT_CLASS;
  63. Param->Size = sizeof(pin);
  64. Param->No = FORMAT_COMMENT + *No;
  65. Param->Type = TYPE_COMMENT;
  66. Param->Flags = DF_OUTPUT;
  67. *No = 0;
  68. return ERR_NONE;
  69. }
  70. *No -= p->TotalCount;
  72. return ERR_INVALID_PARAM;
  73. }
  75. static INLINE void Format_BufferInsert(format_reader* p,format_buffer* Buffer)
  76. {
  77. Buffer->Next = NULL;
  78. if (p->BufferLast)
  79. p->BufferLast->Next = Buffer;
  80. else
  81. p->BufferFirst = Buffer;
  82. p->BufferLast = Buffer;
  83. p->BufferAvailable += Buffer->Length;
  84. }
  86. format_buffer* Format_BufferAlloc(format_base*,int Mode); //0:optional 1:drop 2:new alloc
  87. format_packet* Format_PacketAlloc(format_base*);
  88. void Format_PacketRelease(format_base*, format_packet*);
  89. bool_t Format_ReadBuffer(format_reader*, bool_t ToRead);
  91. int Format_Seek(format_base* p,filepos_t Pos,int Origin)
  92. {
  93. int Result = p->Reader->Seek(p->Reader,Pos,Origin);
  94. if (Result == ERR_NONE)
  95. Format_AfterSeek(p);
  96. return Result;
  97. }
  99. int Format_SeekForce(format_base* p,filepos_t Pos,int Origin)
  100. {
  101. int Result;
  102. filepos_t Save = p->Reader[0].FilePos;
  103. p->Reader[0].FilePos = -1;
  104. Result = Format_Seek(p,Pos,Origin);
  105. if (Result != ERR_NONE)
  106. p->Reader[0].FilePos = Save;
  107. return Result;
  108. }
  110. int Format_SeekByPacket(format_base* p,tick_t Time,filepos_t FilePos,bool_t PrevKey)
  111. {
  112. int Try;
  113. int LastTime;
  114. int LastPos;
  115. format_stream* Stream = NULL;
  117. if (FilePos < 0)
  118. {
  119. Time -= SHOWAHEAD; // we should go a little earlier
  120. if (Time > 0)
  121. {
  122. if (p->FileSize<0 || p->Duration<0)
  123. return ERR_NOT_SUPPORTED;
  125. FilePos = Scale(p->FileSize,Time,p->Duration);
  126. }
  127. else
  128. FilePos = 0;
  129. }
  131. if (Time>0)
  132. Stream = Format_DefSyncStream(p,p->Reader);
  134. p->GlobalOffset = 0;
  135. p->InSeek = 1;
  137. LastPos = -1;
  138. LastTime = -1;
  140. for (Try=0;Try<SEEKTRIES;++Try) // maximum iterations
  141. {
  142. if (FilePos < p->SeekByPacket_DataStart)
  143. FilePos = p->SeekByPacket_DataStart;
  144. if (p->SeekByPacket_BlockAlign > 1)
  145. FilePos -= (FilePos - p->SeekByPacket_DataStart) % p->SeekByPacket_BlockAlign;
  147. if (Format_Seek(p,FilePos,SEEK_SET) != ERR_NONE)
  148. {
  149. p->InSeek = 0;
  150. return ERR_NOT_SUPPORTED;
  151. }
  153. if (Stream)
  154. {
  155. // check if really seeked to the right time (and adjust if needed)
  157. format_reader* Reader = p->Reader;
  158. int SeekRead = FilePos + SEEKMAXREAD;
  160. while (Reader->FilePos<SeekRead)
  161. {
  162. Format_ReadBuffer(Reader,0); // simulate input thread
  164. if (p->FillQueue(p,Reader) == ERR_END_OF_FILE)
  165. break;
  167. if (Stream->LastTime >= 0)
  168. {
  169. DEBUG_MSG3(DEBUG_FORMAT,T("SeekByPacket to:%d current:%d filepos:%d"),Time,Stream->LastTime,FilePos);
  171. if (!p->TimeStamps)
  172. {
  173. // adjust GlobalOffset
  174. p->GlobalOffset = Time - Stream->LastTime;
  175. if (p->GlobalOffset>0)
  176. {
  177. // need to adjust all stream packets
  178. int No;
  179. for (No=0;No<p->StreamCount;++No)
  180. {
  181. format_packet* i;
  182. format_stream* s = p->Streams[No];
  183. if (s->LastTime >= 0)
  184. s->LastTime += p->GlobalOffset;
  185. for (i=s->PacketFirst;i;i=i->Next)
  186. if (i->RefTime >= 0)
  187. i->RefTime += p->GlobalOffset;
  188. }
  189. }
  190. else
  191. p->GlobalOffset=0; // can't be negative
  192. SeekRead = -1; // accept
  193. break;
  194. }
  196. if (Time>=Stream->LastTime && (Time-Stream->LastTime) <= (TICKSPERSEC/2))
  197. FilePos = -1; // accept
  198. else
  199. {
  200. int Move;
  202. if (LastPos >= 0)
  203.   Move = Scale(FilePos-LastPos,Time-Stream->LastTime,Stream->LastTime-LastTime);
  204. else
  205.   Move = Scale(p->FileSize,Time-Stream->LastTime,p->Duration);
  207. if (Move < 0)
  208. Move = (Move*9)/8;
  209. else
  210. Move = (Move*15)/16;
  212. if (Move > 64*1024 || Move < -64*1024)
  213. {
  214. LastTime = Stream->LastTime;
  215. LastPos = FilePos;
  216. }
  217. else
  218. LastPos = -1;
  220. FilePos += Move;
  221. }
  223. if (FilePos < 0 || FilePos >= p->FileSize)
  224. SeekRead = -1; // accept
  225. break;
  226. }
  228. if (!Reader->BufferAvailable && !Reader->ReadBuffer && Reader->NoMoreInput)
  229. break; // end of file
  230. }
  232. if (Reader->FilePos<SeekRead)
  233. continue; // try again
  234. }
  235. break;
  236. }
  238. p->InSeek = 0;
  240. return ERR_NONE;
  241. }
  243. format_buffer* Format_BufferRemoveLast(format_reader* Reader)
  244. {
  245. format_buffer *Buffer,*Tail;
  246. LockEnter(Reader->Format->BufferLock);
  247. Buffer = Reader->BufferLast;
  248. if (Buffer)
  249. {
  250. Tail = Reader->BufferFirst;
  251. if (Tail == Buffer)
  252. Reader->BufferFirst = Tail = NULL;
  253. else
  254. {
  255. while (Tail && Tail->Next != Buffer)
  256. Tail = Tail->Next;
  257. if (Tail)
  258. Tail->Next = NULL;
  259. }
  260. Reader->BufferLast = Tail;
  261. Reader->BufferAvailable -= Buffer->Length;
  262. assert(Reader->BufferAvailable >= 0);
  263. }
  264. LockLeave(Reader->Format->BufferLock);
  265. return Buffer;
  266. }
  268. int Format_Hibernate(format_base* p, int Mode)
  269. {
  270. bool_t Changed = 0;
  272. if (p->InputLock)
  273. {
  274. int No;
  275. format_buffer *Buffer;
  277. LockEnter(p->InputLock);
  278. LockEnter(p->BufferLock);
  280. #ifndef TARGET_PALMOS
  282. if (Mode == HIBERNATE_HARD)
  283. {
  284. format_reader *Reader = p->Reader;
  285. filepos_t Seek = 0;
  287. if (Reader->InputBuffer)
  288. Seek += Reader->InputBuffer->Length;
  290. for (Buffer = Reader->BufferFirst;Buffer;Buffer = Buffer->Next)
  291. Seek += Buffer->Length;
  293. if (Seek && Reader->Input && Reader->Input->Seek(Reader->Input,-Seek,SEEK_CUR)>=0)
  294. {
  295. Reader->NoMoreInput = 0;
  297. if (Reader->InputBuffer)
  298. {
  299. Format_BufferRelease(p,Reader->InputBuffer);
  300. Reader->InputBuffer = NULL;
  301. }
  303. while ((Buffer = Format_BufferRemoveLast(Reader)) != NULL)
  304. Format_BufferRelease(p,Buffer);
  305. }
  306. }
  307. #endif
  309. while (p->FreeBuffers)
  310. {
  311. Buffer = p->FreeBuffers;
  312. p->FreeBuffers = Buffer->Next;
  313. FreeBlock(&Buffer->Block);
  314. free(Buffer);
  315. Changed = 1;
  316. }
  318. if (!Changed)
  319. for (No=0;No<MAXREADER;++No)
  320. for (Buffer = p->Reader[No].BufferFirst;Buffer;Buffer = Buffer->Next)
  321. if (SetHeapBlock(BLOCKSIZE,&Buffer->Block,HEAP_STORAGE))
  322. Changed = 1;
  324. LockLeave(p->BufferLock);
  325. LockLeave(p->InputLock);
  326. }
  328. return Changed ? ERR_NONE : ERR_OUT_OF_MEMORY;
  329. }
  331. static bool_t DropBuffer(format_base* p)
  332. {
  333. bool_t Dropped = 0;
  334. int No=0;
  336. for (No=0;No<p->StreamCount;++No)
  337. {
  338. format_stream* Stream = p->Streams[No];
  339. if (Stream->PacketFirst)
  340. {
  341. format_packet* Packet = Stream->PacketFirst;
  342. Stream->PacketFirst = Packet->Next;
  343. if (Stream->PacketLast == Packet)
  344. Stream->PacketLast = NULL;
  346. Format_PacketRelease(p,Packet);
  348. Stream->Pending = 0;
  349. Stream->State.DropLevel = 2;
  350. Stream->DropCount = DROP_SHOW;
  351. Dropped = 1;
  352. }
  353. }
  355. return Dropped;
  356. }
  358. format_buffer* Format_BufferAlloc(format_base* p,int Mode)
  359. {
  360. format_buffer* Buffer;
  362. retry:
  363. Buffer = p->FreeBuffers;
  364. if (!Buffer)
  365. {
  366. if (p->BufferUsed < p->BufferSize || Mode==2)
  367. {
  368. block Block;
  369. if (AllocBlock(BLOCKSIZE,&Block,Mode!=2,HEAP_ANY))
  370. {
  371. Buffer = (format_buffer*) malloc(sizeof(format_buffer));
  372. if (Buffer)
  373. Buffer->Block = Block;
  374. else
  375. FreeBlock(&Block);
  376. }
  377. }
  378. else
  379. if (Mode==0)
  380. return NULL;
  382. if (!Buffer)
  383. {
  384. if (Mode==1 && DropBuffer(p))
  385. goto retry;
  386. return NULL;
  387. }
  388. }
  389. else
  390. {
  391. assert(Buffer->RefCount==0);
  392. p->FreeBuffers = Buffer->Next;
  393. }
  395. Buffer->Length = 0;
  396. Buffer->Id = p->BufferId++;
  397. Buffer->RefCount = 1;
  398. Buffer->Next = NULL;
  399. ++p->BufferUsed;
  401. return Buffer;
  402. }
  404. static int SumByteRate(format_base* p)
  405. {
  406. // try to sum stream byterates
  407. int No;
  408. int ByteRate = 0;
  410. for (No=0;No<p->StreamCount;++No)
  411. {
  412. packetformat Format;
  413. p->Format.Get(p,(FORMAT_STREAM|PIN_FORMAT)+No,&Format,sizeof(Format));
  414. if (Format.ByteRate<=0)
  415. {
  416. if (p->Streams[No]->Pin.Node && p->ProcessTime == TIME_SYNC)
  417. {
  418. p->ProcessTime = 0;
  419. p->Process(p,p->Streams[No]); // try processing
  420. p->ProcessTime = TIME_SYNC;
  421. }
  422. p->Format.Get(p,(FORMAT_STREAM|PIN_FORMAT)+No,&Format,sizeof(Format));
  423. if (Format.ByteRate<=0)
  424. return p->SumByteRate; // failed
  425. }
  426. ByteRate += Format.ByteRate;
  427. }
  429. return ByteRate;
  430. }
  432. static bool_t IsVideo(format_base* p)
  433. {
  434. int No;
  435. for (No=0;No<p->StreamCount;++No)
  436. if (p->Streams[No]->Format.Type == PACKET_VIDEO)
  437. return 1;
  438. return 0;
  439. }
  441. static void FindCoverArt(format_base* p);
  443. static void CalcDuration(format_base* p)
  444. {
  445. if (p->Duration<0 && p->FileSize>=0)
  446. {
  447. if (p->TimeStamps)
  448. {
  449. // try to read the last packets and figure out Duration
  450. filepos_t SavePos;
  451. format_reader* Reader = p->Reader;
  453. LockEnter(p->InputLock);
  454. LockEnter(p->BufferLock);
  456. SavePos = Reader->Input->Seek(Reader->Input,0,SEEK_CUR);
  457. if (SavePos >= 0)
  458. {
  459. format_buffer* Buffer[ENDCHUNKS];
  460. int No,i;
  461. int Total = 0;
  462. tick_t Max=-1;
  463. format_reader Backup = *Reader;
  465. memset(Buffer,0,sizeof(Buffer));
  467. Reader->NoMoreInput = 1; //disable reading during ReadPacket
  469. for (No=0;No<ENDCHUNKS;++No)
  470. {
  471. filepos_t Pos = p->FileSize - (No+1)*BLOCKSIZE;
  472. if (Pos<0)
  473. {
  474. if (No)
  475. break;
  476. Pos = 0;
  477. }
  479. Buffer[No] = Format_BufferAlloc(p,2);
  480. if (!Buffer[No])
  481. break;
  483. if (Reader->Input->Seek(Reader->Input,Pos,SEEK_SET)<0)
  484. break;
  486. Buffer[No]->Length = Reader->Input->ReadBlock(Reader->Input,&Buffer[No]->Block,0,BLOCKSIZE);
  487. if (Buffer[No]->Length < 0)
  488. break;
  490. Total += Buffer[No]->Length;
  491. if (No)
  492. Buffer[No]->Next = Buffer[No-1];
  494. // setup temporary buffer
  495. Reader->InputBuffer = NULL;
  496. Reader->BufferAvailable = Total;
  497. Reader->BufferLast = Buffer[0];
  498. Reader->BufferFirst = Buffer[No];
  499. Reader->ReadPos = 0;
  500. Reader->ReadBuffer = NULL;
  501. Reader->FilePos = Pos;
  502. for (i=0;i<=No;++i)
  503. Buffer[i]->RefCount++;
  505. if (p->SeekByPacket_BlockAlign > 1)
  506. {
  507. int Rem = (Pos - p->SeekByPacket_DataStart) % p->SeekByPacket_BlockAlign;
  508. if (Rem)
  509. Reader->Skip(Reader,p->SeekByPacket_BlockAlign - Rem);
  510. }
  511. if (p->BackupPacketState)
  512. p->BackupPacketState(p,1);
  514. while (Reader->BufferLast || Reader->ReadBuffer)
  515. {
  516. int Result;
  517. format_packet* Packet = Format_PacketAlloc(p);
  518. if (!Packet)
  519. break;
  521. Result = p->ReadPacket(p,Reader,Packet);
  523. if (Result != ERR_NONE && Result != ERR_DATA_NOT_FOUND)
  524. {
  525. Reader->BufferLast = NULL;
  526. Reader->ReadBuffer = NULL;
  527. }
  528. else
  529. if (Result == ERR_NONE && Packet->Stream && Packet->RefTime>Max)
  530. Max = Packet->RefTime;
  532. Format_PacketRelease(p,Packet);
  533. }
  535. if (p->BackupPacketState)
  536. p->BackupPacketState(p,0);
  538. for (i=0;i<=No;++i)
  539. Buffer[i]->RefCount=1; // ugly
  541. if (Max >= 0)
  542. {
  543. p->Duration = Max;
  544. break;
  545. }
  546. }
  548. for (No=0;No<ENDCHUNKS;++No)
  549. if (Buffer[No])
  550. Format_BufferRelease(p,Buffer[No]);
  552. Reader->Input->Seek(Reader->Input,SavePos,SEEK_SET);
  553. *Reader = Backup;
  554. }
  556. LockLeave(p->BufferLock);
  557. LockLeave(p->InputLock);
  558. }
  560. if (p->StreamCount)
  561. {
  562. int ByteRate = SumByteRate(p);
  563. if (ByteRate>0)
  564. {
  565. tick_t Duration = Scale(p->FileSize,TICKSPERSEC,ByteRate);
  566. if (p->Duration<0 || p->Duration+3*TICKSPERSEC<Duration)
  567. {
  568. p->Duration = Duration;
  569. p->TimeStamps = 0;
  570. }
  571. }
  572. }
  573. }
  575. #if !defined(MULTITHREAD)
  576. if (IsVideo(p))
  577. p->AutoReadSize = 1; // force auto readsize
  578. #endif
  580. if (p->StreamCount && p->ProcessMinBuffer)
  581. {
  582. int ByteRate = SumByteRate(p);
  583. if (ByteRate<=0 && p->Duration>0)
  584. {
  585. int FileSize = p->FileSize;
  586. if (FileSize < 0 && p->Reader->Input)
  587. {
  588. LockEnter(p->InputLock);
  589. p->Reader->Input->Get(p->Reader->Input,STREAM_LENGTH,&FileSize,sizeof(FileSize));
  590. LockLeave(p->InputLock);
  591. }
  592. ByteRate = Scale(FileSize,TICKSPERSEC,p->Duration);
  593. }
  595. if (ByteRate>0)
  596. {
  597. while (ByteRate>p->ProcessMinBuffer*2 && p->ProcessMinBuffer < p->BufferSize*BLOCKSIZE/4)
  598. p->ProcessMinBuffer += BLOCKSIZE;
  600. if (p->AutoReadSize)
  601. {
  602. int No;
  603. int Rate = ByteRate / 16;
  605. // find video framerate
  606. for (No=0;No<p->StreamCount;++No)
  607. {
  608. packetformat Format;
  609. p->Format.Get(p,(FORMAT_STREAM|PIN_FORMAT)+No,&Format,sizeof(Format));
  610. if (Format.Type == PACKET_VIDEO && Format.PacketRate.Num>0)
  611. {
  612. Rate = Scale(ByteRate,Format.PacketRate.Den,Format.PacketRate.Num);
  613. break;
  614. }
  615. }
  617. p->ReadSize = 16384;
  618. while (p->ReadSize>1024 && Rate<5000)
  619. {
  620. Rate <<= 1;
  621. p->ReadSize >>= 1;
  622. }
  623. }
  624. }
  625. }
  627. #if defined(TARGET_SYMBIAN)
  628. if (p->ReadSize > 4096) // large reads interfere with audio (until multithreaded is not added...)
  629. p->ReadSize = 4096;
  630. #endif
  632. FindCoverArt(p);
  633. }
  635. void Format_BufferRelease(format_base* p, format_buffer* Buffer)
  636. {
  637. //DEBUG_MSG4(DEBUG_FORMAT,"Buffer:%d release %d->%d (%d)",Buffer->Id,Buffer->RefCount,Buffer->RefCount-1,p->BufferUsed);
  639. LockEnter(p->BufferLock);
  641. assert(Buffer->RefCount>0 && Buffer->RefCount<1000);
  643. if (--Buffer->RefCount <= 0)
  644. {
  645. assert(Buffer->RefCount==0);
  646. --p->BufferUsed;
  647. if (p->BufferUsed <= p->BufferSize)
  648. {
  649. Buffer->Next = p->FreeBuffers;
  650. p->FreeBuffers = Buffer;
  651. }
  652. else
  653. {
  654. FreeBlock(&Buffer->Block);
  655. free(Buffer);
  656. }
  657. }
  659. LockLeave(p->BufferLock);
  660. }
  662. format_buffer* Format_BufferRemove(format_reader* Reader)
  663. {
  664. format_buffer* Buffer;
  665. LockEnter(Reader->Format->BufferLock);
  666. Buffer = Reader->BufferFirst;
  667. if (Buffer)
  668. {
  669. Reader->BufferFirst = Buffer->Next;
  670. if (Reader->BufferLast == Buffer)
  671. Reader->BufferLast = NULL;
  672. Reader->BufferAvailable -= Buffer->Length;
  673. assert(Reader->BufferAvailable >= 0);
  674. }
  675. LockLeave(Reader->Format->BufferLock);
  676. return Buffer;
  677. }
  679. void Format_SingleRefRelease(format_base* p, format_ref* Ref)
  680. {
  681. if (Ref->Buffer)
  682. Format_BufferRelease(p,Ref->Buffer);
  683. Ref->Next = p->FreeRefs;
  684. p->FreeRefs = Ref;
  685. }
  687. void Format_ReleaseRef(format_base* p, format_ref* Ref)
  688. {
  689. while (Ref)
  690. {
  691. format_ref* Next = Ref->Next;
  692. Format_SingleRefRelease(p,Ref);
  693. Ref = Next;
  694. }
  695. }
  697. void Format_PacketRelease(format_base* p, format_packet* Packet)
  698. {
  699. Format_ReleaseRef(p,Packet->Data);
  700. Packet->Data = NULL;
  701. Packet->Next = p->FreePackets;
  702. p->FreePackets = Packet;
  703. }
  705. static NOINLINE void ReleaseStream(format_base* p,format_stream* Stream)
  706. {
  707. format_packet* Packet;
  709. Stream->State.DropLevel = 0;
  710. Stream->DropCount = 0;
  711. Stream->Pending = 0;
  712. Stream->LastTime = TIME_SYNC;
  714. while (Stream->PacketFirst)
  715. {
  716. Packet = Stream->PacketFirst;
  717. Stream->PacketFirst = Packet->Next;
  718. if (Stream->PacketLast == Packet)
  719. Stream->PacketLast = NULL;
  721. Format_PacketRelease(p,Packet);
  722. }
  724. if (p->ReleaseStream && Stream != p->SubTitle && Stream != p->CoverArt)
  725. p->ReleaseStream(p,Stream);
  726. }
  728. static int UpdateStreamPin(format_base* p,format_stream* Stream)
  729. {
  730. if (!Stream->Pin.Node)
  731. ReleaseStream(p,Stream);
  732. return ERR_NONE;
  733. }
  735. void Format_AfterSeek(format_base* p)
  736. {
  737. int No;
  739. // release stream packets
  740. for (No=0;No<p->StreamCount;++No)
  741. ReleaseStream(p,p->Streams[No]);
  743. if (p->SubTitle)
  744. ReleaseStream(p,p->SubTitle);
  746. p->LastRead = NULL;
  747. if (p->AfterSeek)
  748. p->AfterSeek(p);
  749. }
  751. void Format_ReleaseBuffers(format_reader* Reader)
  752. {
  753. format_buffer* Buffer;
  755. // release read buffers
  756. Reader->NoMoreInput = 0;
  758. Reader->ReadPos = 0;
  759. if (Reader->ReadBuffer)
  760. {
  761. Format_BufferRelease(Reader->Format,Reader->ReadBuffer);
  762. Reader->ReadBuffer = NULL;
  763. }
  765. if (Reader->InputBuffer)
  766. {
  767. Format_BufferRelease(Reader->Format,Reader->InputBuffer);
  768. Reader->InputBuffer = NULL;
  769. }
  771. while ((Buffer = Format_BufferRemove(Reader))!=NULL)
  772. Format_BufferRelease(Reader->Format,Buffer);
  773. }
  775. format_reader* Format_FindReader(format_base* p,filepos_t Min,filepos_t Max)
  776. {
  777. int No;
  778. filepos_t LimitMax;
  780. if (Max < Min+16)
  781. Max = Min+16;
  783. LimitMax = p->BufferSize*BLOCKSIZE/2;
  784. if (p->Duration>0)
  785. {
  786. // example a 55Mb/sec mjpeg with pcm audio can have large differences at end of file
  787. LimitMax = Scale(Max-Min,3*TICKSPERSEC,p->Duration);
  788. if (LimitMax < 512*1024)
  789. LimitMax = 512*1024;
  790. }
  792. for (No=0;No<MAXREADER;++No)
  793. {
  794. format_reader* Reader = p->Reader+No;
  795. filepos_t Limit = (Reader->OffsetMax - Reader->OffsetMin)/4;
  796. if (Limit<128*1024)
  797. Limit=128*1024;
  798. if (Limit>LimitMax)
  799. Limit=LimitMax;
  801. if (!Reader->OffsetMax ||
  802. (Reader->OffsetMin < Max && Reader->OffsetMax > Min && 
  803.  abs(Reader->OffsetMin-Min)<Limit && abs(Reader->OffsetMax-Max)<Limit))
  804. {
  805. stream* Orig = p->Reader[0].Input;
  807. if (Reader->OffsetMin > Min)
  808. Reader->OffsetMin = Min;
  809. if (Reader->OffsetMax < Max)
  810. Reader->OffsetMax = Max;
  812. Reader->Ratio = Scale(MAX_INT,1,Reader->OffsetMax - Reader->OffsetMin);
  814. if (!Reader->Input && Orig)
  815. {
  816. bool_t Silent = 1;
  817. tchar_t URL[MAXPATH];
  818. stream* Input;
  820. if (Orig->Get(Orig,STREAM_URL,URL,sizeof(URL)) != ERR_NONE)
  821. break;
  823. Input = (stream*)NodeCreate(Orig->Class);
  824. if (!Input)
  825. break;
  827. Input->Set(Input,STREAM_SILENT,&Silent,sizeof(bool_t));
  829. if (Input->Set(Input,STREAM_URL,URL,sizeof(URL))!=ERR_NONE)
  830. {
  831. NodeDelete((node*)Input);
  832. break;
  833. }
  835. Reader->ReadPos = 0;
  836. Reader->FilePos = 0;
  837. Reader->Input = Input;
  838. }
  840. return Reader;
  841. }
  842. }
  844. return NULL;
  845. }
  847. static NOINLINE void Format_FreeStream(format_base* p,format_stream* Stream)
  848. {
  849. PacketFormatClear(&Stream->Format);
  850. BufferClear(&Stream->BufferMem);
  851. FreeBlock(&Stream->BufferBlock);
  852. free(Stream);
  853. }
  855. int Format_Reset(format_base* p)
  856. {
  857. int Result = ERR_NONE;
  858. format_packet* Packet;
  859. format_buffer* Buffer;
  860. format_reader* Reader;
  861. format_ref* Ref;
  862. int No;
  864. if (p->BufferLock) // only if it was inited
  865. {
  866. Format_AfterSeek(p);
  867. for (No=0;No<MAXREADER;++No)
  868. Format_ReleaseBuffers(p->Reader+No);
  869. }
  871. if (p->ReleaseStreams.Func)
  872. p->ReleaseStreams.Func(p->ReleaseStreams.This,0,0);
  874. if (p->Done)
  875. p->Done(p);
  877. while (p->StreamCount)
  878. Format_RemoveStream(p);
  880. while (p->FreePackets)
  881. {
  882. Packet = p->FreePackets;
  883. p->FreePackets = Packet->Next;
  884. free(Packet);
  885. }
  887. while (p->FreeBuffers)
  888. {
  889. Buffer = p->FreeBuffers;
  890. p->FreeBuffers = Buffer->Next;
  891. FreeBlock(&Buffer->Block);
  892. free(Buffer);
  893. }
  895. while (p->FreeRefs)
  896. {
  897. Ref = p->FreeRefs;
  898. p->FreeRefs = Ref->Next;
  899. free(Ref);
  900. }
  902. if (p->SubTitle)
  903. {
  904. Format_FreeSubTitle(p,p->SubTitle);
  905. p->SubTitle = NULL;
  906. }
  908. if (p->CoverArt)
  909. {
  910. Format_FreeStream(p,p->CoverArt);
  911. p->CoverArt = NULL;
  912. }
  914. p->TotalCount = 0;
  915. p->StreamCount = 0;
  916. p->ActiveStreams = 0;
  918. LockDelete(p->BufferLock);
  919. LockDelete(p->InputLock);
  920. p->BufferLock = NULL;
  921. p->InputLock = NULL;
  922. p->LastRead = NULL;
  924. for (No=0;No<MAXREADER;++No)
  925. {
  926. Reader = p->Reader+No;
  927. if (No>0 && Reader->Input)
  928. {
  929. Reader->Input->Set(Reader->Input,STREAM_URL,NULL,0);
  930. NodeDelete((node*)Reader->Input);
  931. Reader->Input = NULL;
  932. }
  933. Reader->Ratio = -1;
  934. Reader->OffsetMin = MAX_INT;
  935. Reader->OffsetMax = 0;
  936. Reader->Current = NULL;
  937. Reader->OutOfSync = 0;
  938. }
  940. Reader = p->Reader;
  941. if (Reader->Input)
  942. {
  943. if (!NodeIsClass(Reader->Input->Class,STREAM_CLASS) &&
  944. !NodeIsClass(Reader->Input->Class,STREAMPROCESS_CLASS))
  945. return ERR_INVALID_PARAM;
  947. if (Reader->Input->Get(Reader->Input,STREAM_LENGTH,&p->FileSize,sizeof(p->FileSize)) != ERR_NONE)
  948. p->FileSize = -1;
  950. p->InputLock = LockCreate();
  951. p->BufferLock = LockCreate();
  952. p->Duration = TIME_UNKNOWN;
  953. p->FirstSync = 1;
  954. p->SyncMode = 1; // start with syncmode
  955. p->SyncTime = TIME_SYNC;
  956. p->SyncStream = NULL;
  957. p->HeaderLoaded = 0;
  958. p->ProcessMinBuffer = PROCESSMINVIDEO;
  959. p->ReadSize = 16384;
  960. p->GlobalOffset = 0;
  961. p->SumByteRate = 0;
  963. Reader->FilePos = 0;
  964. Reader->NoMoreInput = 0;
  966. p->SeekByPacket_DataStart = 0;
  967. p->SeekByPacket_BlockAlign = 1;
  969. if (p->Init)
  970. {
  971. Result = p->Init(p);
  972. if (Result != ERR_NONE)
  973. {
  974. Reader->Input = NULL;
  975. Format_Reset(p);
  976. }
  977. else
  978. p->SyncRead = SYNCREAD;
  979. }
  980. }
  981. return Result;
  982. }
  984. int FormatBaseGet(format_base* p,int No,void* Data,int Size)
  985. {
  986. int Result = ERR_INVALID_PARAM;
  987. if (No >= FORMAT_COMMENT && No < FORMAT_COMMENT+p->TotalCount)  
  988. GETVALUE(p->Streams[No-FORMAT_COMMENT]->Comment,pin)
  989. else
  990. if (No >= FORMAT_STREAM && No < FORMAT_STREAM+p->TotalCount)
  991. GETVALUE(p->Streams[No-FORMAT_STREAM]->Pin,pin)
  992. else
  993. if (No >= FORMAT_STREAM_PRIORITY && No < FORMAT_STREAM_PRIORITY+p->TotalCount)
  994. GETVALUE(p->Streams[No-FORMAT_STREAM_PRIORITY]->Priority,int)
  995. else
  996. if (No >= (FORMAT_STREAM|PIN_PROCESS) && No < (FORMAT_STREAM|PIN_PROCESS)+p->TotalCount)
  997. GETVALUE(p->Streams[No-(FORMAT_STREAM|PIN_PROCESS)]->Process,packetprocess)
  998. else
  999. if (No >= (FORMAT_STREAM|PIN_FORMAT) && No < (FORMAT_STREAM|PIN_FORMAT)+p->TotalCount)
  1000. {
  1001. packetformat CodecFormat;
  1002. format_stream* s = p->Streams[No-(FORMAT_STREAM|PIN_FORMAT)];
  1003. assert(Size == sizeof(packetformat));
  1004. if (s->Pin.Node && s->Pin.Node->Get(s->Pin.Node,s->Pin.No|PIN_FORMAT,&CodecFormat,sizeof(CodecFormat))==ERR_NONE)
  1005. PacketFormatCombine(&s->Format,&CodecFormat);
  1006. *(packetformat*)Data = s->Format;
  1007. Result = ERR_NONE;
  1008. }
  1009. else
  1010. switch (No)
  1011. {
  1012. case FORMAT_BUFFERSIZE: GETVALUE(p->BufferSize,int); break;
  1013. case FORMAT_INPUT: GETVALUE(p->Reader[0].Input,stream*); break;
  1014. case FORMAT_DURATION: GETVALUECOND(p->Duration,tick_t,p->Duration>=0); break;
  1015. case FORMAT_FILEPOS: GETVALUECOND(p->Reader[0].FilePos,int,p->Timing && p->Reader[0].FilePos>=0); break;
  1016. case FORMAT_FILEALIGN: GETVALUE(p->FileAlign,int); break;
  1017. case FORMAT_STREAM_COUNT: GETVALUE(p->TotalCount,int); break;
  1018. case FORMAT_FILESIZE: GETVALUECOND(p->FileSize/1024,int,p->FileSize>=0); break;
  1019. case FORMAT_FIND_SUBTITLES: GETVALUE(p->NeedSubtitles,bool_t); break;
  1020. case FORMAT_GLOBAL_COMMENT: GETVALUE(p->Comment,pin); break;
  1021. case FORMAT_AUTO_READSIZE: GETVALUE(p->AutoReadSize,bool_t); break;
  1022. case FORMAT_TIMING: GETVALUE(p->Timing,bool_t); break;
  1023. case FORMAT_COVERART: GETVALUECOND(p->StreamCount+(p->SubTitle!=NULL),int,p->CoverArt!=NULL); break;
  1024. case FORMAT_MIN_BUFFER: GETVALUE(p->ProcessMinBuffer/BLOCKSIZE,int); break;
  1025. }
  1026. return Result;
  1027. }
  1029. int FormatBaseSet(format_base* p,int No,const void* Data,int Size)
  1030. {
  1031. node* Advanced;
  1032. uint8_t* Ptr;
  1033. int Result = ERR_INVALID_PARAM;
  1035. if (No >= FORMAT_COMMENT && No < FORMAT_COMMENT+p->TotalCount)
  1036. SETVALUE(p->Streams[No-FORMAT_COMMENT]->Comment,pin,ERR_NONE)
  1037. else
  1038. if (No >= FORMAT_STREAM && No < FORMAT_STREAM+p->TotalCount)
  1039. {
  1040. format_stream* s = p->Streams[No-FORMAT_STREAM];
  1041. if (s->Pin.Node && No-FORMAT_STREAM<p->StreamCount) p->ActiveStreams--;
  1042. SETVALUE(s->Pin,pin,UpdateStreamPin(p,s));
  1043. if (s->Pin.Node && No-FORMAT_STREAM<p->StreamCount) p->ActiveStreams++;
  1044. }
  1045. else
  1046. if (No >= (FORMAT_STREAM|PIN_PROCESS) && No < (FORMAT_STREAM|PIN_PROCESS)+p->TotalCount)
  1047. SETVALUE(p->Streams[No-(FORMAT_STREAM|PIN_PROCESS)]->Process,packetprocess,ERR_NONE)
  1048. else
  1049. switch (No)
  1050. {
  1051. case FORMAT_INPUT: SETVALUENULL(p->Reader[0].Input,stream*,Format_Reset(p),p->Reader[0].Input=NULL); break;
  1052. case FORMAT_UPDATESTREAMS: SETVALUE(p->UpdateStreams,notify,ERR_NONE); break;
  1053. case FORMAT_RELEASESTREAMS: SETVALUE(p->ReleaseStreams,notify,ERR_NONE); break;
  1054. case FORMAT_FIND_SUBTITLES: SETVALUE(p->NeedSubtitles,bool_t,ERR_NONE); break;
  1055. case FORMAT_GLOBAL_COMMENT: SETVALUE(p->Comment,pin,ERR_NONE); break;
  1056. case FORMAT_FILEALIGN: SETVALUE(p->FileAlign,int,ERR_NONE); break;
  1057. case FORMAT_AUTO_READSIZE: SETVALUE(p->AutoReadSize,bool_t,ERR_NONE); break;
  1059. case NODE_HIBERNATE:
  1060. assert(Size == sizeof(int));
  1061. Result = Format_Hibernate(p,*(int*)Data);
  1062. break;
  1064. case NODE_SETTINGSCHANGED:
  1065. Advanced = Context()->Advanced;
  1066. if (Advanced)
  1067. {
  1068. Advanced->Get(Advanced,ADVANCED_DROPTOL,&p->DropTolerance,sizeof(tick_t));
  1069. Advanced->Get(Advanced,ADVANCED_SKIPTOL,&p->SkipTolerance,sizeof(tick_t));
  1070. Advanced->Get(Advanced,ADVANCED_AVOFFSET,&p->AVOffset,sizeof(tick_t));
  1071. }
  1072. break;
  1074. case FORMAT_DATAFEED:
  1076. Ptr = (uint8_t*) Data;
  1077. while (Size)
  1078. {
  1079. format_buffer* Buffer;
  1081. Buffer = Format_BufferAlloc(p,2);
  1082. if (Buffer)
  1083. {
  1084. Buffer->Length = Size;
  1085. if (Buffer->Length > BLOCKSIZE)
  1086. Buffer->Length = BLOCKSIZE;
  1088. WriteBlock(&Buffer->Block,0,Ptr,Buffer->Length);
  1090. Ptr += Buffer->Length;
  1091. Size -= Buffer->Length;
  1093. Format_BufferInsert(p->Reader,Buffer);
  1094. }
  1095. }
  1097. break;
  1099. case FORMAT_BUFFERSIZE: SETVALUE(p->BufferSize,int,ERR_NONE); break;
  1100. }
  1101. return Result;
  1102. }
  1104. format_packet* Format_PacketAlloc(format_base* p)
  1105. {
  1106. format_packet* Packet = p->FreePackets;
  1108. if (!Packet)
  1109. {
  1110. Packet = (format_packet*) malloc(sizeof(format_packet));
  1111. if (!Packet)
  1112. return NULL;
  1113. }
  1114. else
  1115. p->FreePackets = Packet->Next;
  1117. Packet->Data = NULL;
  1118. Packet->RefTime = TIME_UNKNOWN;
  1119. Packet->EndRefTime = TIME_UNKNOWN;
  1120. Packet->Stream = NULL;
  1121. Packet->Next = NULL;
  1122. Packet->Key = 1;
  1124. return Packet;
  1125. }
  1127. static int Format_Sync(format_base* p,tick_t Time,int FilePos,bool_t PrevKey)
  1128. {
  1129. if (!p->Seek || !p->Reader[0].Input)
  1130. return ERR_NOT_SUPPORTED;
  1132. if (!p->HeaderLoaded)
  1133. return ERR_LOADING_HEADER;
  1135. p->SyncMode = 1;
  1136. p->SyncRead = SYNCREAD;
  1137. p->SyncTime = TIME_SYNC; // set before p->Seek
  1138. p->SyncStream = NULL;
  1140. if (Time>=0 || FilePos>=0)
  1141. {
  1142. int Result = p->Seek(p,Time,FilePos,PrevKey);
  1143. if (Result != ERR_NONE)
  1144. {
  1145. p->SyncMode = 0;
  1146. return Result;
  1147. }
  1148. }
  1150. return ERR_NONE;
  1151. }
  1153. int Format_CheckEof(format_base* p,format_stream* Stream)
  1154. {
  1155. int Result;
  1157. if (!p->Timing && p->ProcessTime>=0 && p->ProcessTime<5*TICKSPERSEC)
  1158. return ERR_BUFFER_FULL;
  1160. Stream->State.CurrTime = p->ProcessTime;
  1161. Stream->State.DropLevel = 0;
  1163. Result = Stream->Process(Stream->Pin.Node,NULL,&Stream->State);
  1164. if (Result != ERR_BUFFER_FULL)
  1165. Result = ERR_END_OF_FILE;
  1167. return Result;
  1168. }
  1170. static NOINLINE int Synced(format_base* p,format_stream* Stream)
  1171. {
  1172. p->SyncMode = 0;
  1174. if (p->SyncTime == TIME_SYNC)
  1175. {
  1176. p->SyncTime = Stream->Packet.RefTime;
  1177. if (p->SyncTime < 0)
  1178. p->SyncTime = Stream->LastTime;
  1179. }
  1181. if (p->FirstSync)
  1182. {
  1183. // some codecs may need the first few packets as headers
  1184. int No;
  1185. p->ProcessTime = 0;
  1186. for (No=0;No<p->StreamCount;++No)
  1187. if (p->Streams[No]->Pin.Node && p->Streams[No]->PacketFirst)
  1188. p->Process(p,p->Streams[No]); // try processing
  1189. p->ProcessTime = TIME_SYNC;
  1190. }
  1192. return ERR_SYNCED;
  1193. }
  1195. int Format_Send(format_base* p,format_stream* Stream)
  1196. {
  1197. int Result;
  1198. tick_t CurrTime = p->ProcessTime;
  1200. Stream->State.CurrTime = CurrTime;
  1202. if (Stream->Packet.RefTime >= 0 && !Stream->DisableDrop)
  1203. {
  1204. Stream->State.DropLevel = 0;
  1206. if (CurrTime >= 0)
  1207. {
  1208. tick_t Diff = CurrTime - Stream->Packet.RefTime;
  1210. if (Diff < -TICKSPERSEC/2 && Stream->Format.Type == PACKET_VIDEO)
  1211. {
  1212. // make sure buffers and pending packets are processed
  1213. Stream->Process(Stream->Pin.Node,NULL,&Stream->State);
  1214. return ERR_BUFFER_FULL;
  1215. }
  1217. if (Diff > p->DropTolerance)
  1218. {
  1219. if (Diff > p->SkipTolerance + p->DropTolerance)
  1220. {
  1221. Stream->State.DropLevel = 2;
  1222. Stream->DropCount = DROP_SHOW;
  1223. }
  1224. else
  1225. {
  1226. if (!Stream->State.DropLevel)
  1227. Stream->DropCount = 0;
  1229. if (Stream->DropCount >= DROP_SHOW)
  1230. {
  1231. Stream->State.DropLevel = 0; // show one packet
  1232. Stream->DropCount = 0;
  1233. }
  1234. else
  1235. {
  1236. Stream->State.DropLevel = 1;
  1237. ++Stream->DropCount;
  1238. }
  1239. }
  1240. }
  1241. }
  1242. }
  1244. DEBUG_MSG5(DEBUG_FORMAT,T("Send stream:%d size:%d time:%d curr:%d drop:%d"),Stream->No,Stream->Packet.Length,Stream->Packet.RefTime,CurrTime,Stream->State.DropLevel);
  1246. Result = Stream->Process(Stream->Pin.Node,&Stream->Packet,&Stream->State);
  1248. // packet not processed?
  1249. if (Result == ERR_BUFFER_FULL)
  1250. {
  1251. DEBUG_MSG1(DEBUG_FORMAT,T("Send stream:%d BufferFull"),Stream->No);
  1252. return Result;
  1253. }
  1255. if (p->Sended)
  1256. p->Sended(p,Stream);
  1258. Stream->Pending = 0;
  1260. // sync: found a valid frame?
  1261. if (p->SyncMode && (Result == ERR_NONE || Result == ERR_NOT_SUPPORTED))
  1262. Result = Synced(p,Stream);
  1264. return Result;
  1265. }
  1267. void Format_TimeStampRestarted(format_base* p,format_stream* Stream,tick_t* RefTime)
  1268. {
  1269. if (!p->InSeek)
  1270. {
  1271. format_packet* i;
  1272. *RefTime -= p->GlobalOffset;
  1274. p->GlobalOffset = Stream->LastTime; // last processed time
  1275. for (i=Stream->PacketFirst;i;i=i->Next)
  1276. if (i->RefTime>=0)
  1277. p->GlobalOffset = i->RefTime; // last packet time
  1279. *RefTime += p->GlobalOffset;
  1280. p->TimeStamps = 0;
  1281. }
  1282. }
  1284. int Format_FillQueue(format_base* p,format_reader* Reader)
  1285. {
  1286. int Result;
  1287. format_packet* Packet;
  1289. if (!Reader->BufferAvailable && !Reader->ReadBuffer && p->ProcessMinBuffer!=0 &&
  1290. (!p->SyncMode || p->SyncRead<=0 || Reader->NoMoreInput))
  1291. return ERR_NEED_MORE_DATA;
  1293. Packet = Format_PacketAlloc(p);
  1294. if (!Packet)
  1295. return ERR_OUT_OF_MEMORY;
  1297. Result = p->ReadPacket(p,Reader,Packet);
  1299. if (Result == ERR_NONE && Packet->Stream && Packet->Stream->Pin.Node)
  1300. {
  1301. format_stream* s = Packet->Stream;
  1303. if (Packet->RefTime>=0)
  1304. {
  1305. Packet->RefTime += p->GlobalOffset;
  1307. if (s->Format.Type == PACKET_AUDIO)
  1308. {
  1309. Packet->RefTime += p->AVOffset;
  1310. if (Packet->RefTime < 0)
  1311. Packet->RefTime = 0;
  1312. }
  1314. if (s->LastTime<0)
  1315. s->LastTime = Packet->RefTime; // found reftime
  1316. else
  1317. if (s->LastTime > Packet->RefTime+TICKSPERSEC  && Packet->RefTime-p->GlobalOffset<TICKSPERSEC)
  1318. Format_TimeStampRestarted(p,s,&Packet->RefTime);
  1319. }
  1321. if (s->LastTime >= TIME_UNKNOWN)
  1322. {
  1323. // add packet to stream
  1324. if (!s->PacketFirst)
  1325. s->PacketFirst = Packet;
  1326. else
  1327. s->PacketLast->Next = Packet;
  1328. s->PacketLast = Packet;
  1330. if (Packet->EndRefTime>=0 && s->Format.Type == PACKET_SUBTITLE)
  1331. {
  1332. // add empty packet
  1333. format_packet* Tail = Format_PacketAlloc(p);
  1334. if (Tail)
  1335. {
  1336. Tail->Stream = Packet->Stream;
  1337. Tail->RefTime = Packet->EndRefTime;
  1339. if (!s->PacketFirst)
  1340. s->PacketFirst = Tail;
  1341. else
  1342. s->PacketLast->Next = Tail;
  1343. s->PacketLast = Tail;
  1344. }
  1345. }
  1346. }
  1347. else
  1348. Format_PacketRelease(p,Packet);
  1349. }
  1350. else
  1351. Format_PacketRelease(p,Packet);
  1353. return Result;
  1354. }
  1356. NOINLINE bool_t Format_AllocBufferBlock(format_base* p,format_stream* Stream,int Size)
  1357. {
  1358. FreeBlock(&Stream->BufferBlock);
  1359. if (Size>0)
  1360. {
  1361. Size = (Size + SAFETAIL + 0x7FFF) & ~0x7FFF;
  1362. if (AllocBlock(Size,&Stream->BufferBlock,0,HEAP_STORAGE))
  1363. Size -= SAFETAIL;
  1364. else
  1365. Size = 0;
  1366. }
  1367. Stream->BufferBlockLength = Size;
  1368. return Size>0;
  1369. }
  1371. /*
  1372. static bool_t ReleasePacket(format_base* p)
  1373. {
  1374. int No;
  1375. format_stream* Min = NULL;
  1376. tick_t MinTime = MAX_TICK;
  1378. for (No=0;No<p->StreamCount;++No)
  1379. {
  1380. format_stream* Stream = p->Streams[No];
  1381. if (Stream->PacketFirst && Stream->PacketFirst->RefTime < MinTime)
  1382. {
  1383. Min = Stream;
  1384. MinTime = Stream->PacketFirst->RefTime;
  1385. }
  1386. }
  1388. if (Min)
  1389. {
  1390. format_packet* Packet = Min->PacketFirst;
  1392. Min->PacketFirst = Packet->Next;
  1393. if (Min->PacketLast == Packet)
  1394. Min->PacketLast = NULL;
  1396. Format_PacketRelease(p,Packet);
  1397. return 1;
  1398. }
  1400. return 0;
  1401. }
  1402. */
  1404. static int Format_ProcessStream(format_base* p,format_stream* Stream)
  1405. {
  1406. format_packet* Packet;
  1407. format_ref* Ref;
  1408. int Result = ERR_NONE;
  1409. int No;
  1410. int Burst;
  1412. if (Stream->Pending)
  1413. {
  1414. Result = Format_Send(p,Stream);
  1416. if (Result == ERR_BUFFER_FULL || Result == ERR_SYNCED)
  1417. {
  1418. if (p->SyncMode && Stream == p->SyncStream) // can happen when sync without seek 
  1419. Result = Synced(p,Stream);
  1420. return Result;
  1421. }
  1422. }
  1424. // process a limited number of packets at once (other streams need cpu time too)
  1426. Burst = Stream->PacketBurst;
  1428. for (No=0;No<Burst;++No)
  1429. {
  1430. while (!Stream->PacketFirst)
  1431. {
  1432. format_reader* Reader = Stream->Reader;
  1434. /*
  1435. if (p->BufferUsed >= p->BufferSize && p->SyncMode && Stream == p->SyncStream)
  1436. {
  1437. // try dropping other stream packets to make buffer for sync stream
  1438. while (p->BufferUsed >= p->BufferSize)
  1439. if (!ReleasePacket(p))
  1440. break;
  1441. }
  1442. */
  1444. // prevent audio from going too much ahead
  1445. if (Reader->BufferAvailable < p->ProcessMinBuffer && !Reader->NoMoreInput && 
  1446. (!p->SyncMode || p->SyncRead<=0 || Stream != p->SyncStream))
  1447. return ERR_NEED_MORE_DATA;
  1449. Result = Format_FillQueue(p,Reader);
  1451. if (Reader->NoMoreInput && (Result == ERR_END_OF_FILE || Result == ERR_NEED_MORE_DATA))
  1452. Result = Format_CheckEof(p,Stream);
  1454. if (Result != ERR_NONE || (p->Bench && (No || !Stream->PacketFirst)))
  1455. return Result;
  1456. }
  1458. Packet = Stream->PacketFirst;
  1460. // sync: all non SyncStream packets are stored (or dropped)
  1461. if (p->SyncMode && Stream != p->SyncStream && p->SyncStream)
  1462. {
  1463. // catch up to syncstream (drop packets)
  1464. tick_t LastTime = p->SyncStream->LastTime;
  1465. if (p->SyncStream->Fragmented)
  1466. LastTime -= TICKSPERSEC/2; // LastTime may not be the correct sync time
  1468. while (Packet && Packet->RefTime < LastTime)
  1469. {
  1470. Stream->PacketFirst = Packet->Next;
  1471. if (Stream->PacketLast == Packet)
  1472. Stream->PacketLast = NULL;
  1474. Format_PacketRelease(p,Packet);
  1476. Packet = Stream->PacketFirst;
  1477. }
  1478. return ERR_NEED_MORE_DATA; // allow SyncStream to need more data
  1479. }
  1481. //DEBUG_MSG3(DEBUG_FORMAT,T("Packet stream:%d time:%d pos:%d"),Stream->No,Packet->RefTime,Packet->FilePos);
  1483. // build output packet
  1485. if (Packet->RefTime >= 0)
  1486. Stream->LastTime = Packet->RefTime;
  1488. Stream->Packet.RefTime = Packet->RefTime;
  1489. Stream->Packet.Key = Packet->Key;
  1490. Ref = Packet->Data;
  1492. if (!Ref)
  1493. {
  1494. Stream->Packet.Data[0] = NULL;
  1495. Stream->Packet.Length = 0;
  1496. Stream->Pending = 1;
  1497. }
  1498. else
  1499. if (!Stream->Fragmented)
  1500. {
  1501. if (Ref->Next || (Ref->Length + Ref->Begin + SAFETAIL > BLOCKSIZE) || Stream->ForceMerge)
  1502. {
  1503. // merge references
  1504. if (p->UseBufferBlock)
  1505. {
  1506. int Total = 0;
  1507. format_ref* i;
  1508. for (Total=0,i=Ref;i;i=i->Next)
  1509. Total += i->Length;
  1511. if (Stream->BufferBlockLength < Total && !Format_AllocBufferBlock(p,Stream,Total))
  1512. Ref = NULL;
  1514. for (Total=0,i=Ref;i;i=i->Next)
  1515. {
  1516. WriteBlock(&Stream->BufferBlock,Total,i->Buffer->Block.Ptr + i->Begin,i->Length);
  1517. Total += i->Length;
  1518. }
  1520. Stream->Packet.Data[0] = Stream->BufferBlock.Ptr;
  1521. Stream->Packet.Length = Total;
  1522. }
  1523. else
  1524. {
  1525. BufferDrop(&Stream->BufferMem);
  1526. for (;Ref;Ref=Ref->Next)
  1527. BufferWrite(&Stream->BufferMem,Ref->Buffer->Block.Ptr + Ref->Begin, Ref->Length,16384);
  1529. Stream->Packet.Data[0] = Stream->BufferMem.Data;
  1530. Stream->Packet.Length = Stream->BufferMem.WritePos;
  1531. }
  1532. }
  1533. else
  1534. {
  1535. // single reference
  1536. Stream->Packet.Data[0] = Ref->Buffer->Block.Ptr + Ref->Begin;
  1537. Stream->Packet.Length = Ref->Length;
  1538. }
  1539. Stream->Pending = 1;
  1540. }
  1541. else
  1542. {
  1543. // send first reference (doesn't matter how long)
  1544. Stream->Packet.Data[0] = Ref->Buffer->Block.Ptr + Ref->Begin;
  1545. Stream->Packet.Length = Ref->Length;
  1546. Stream->Pending = 2; // indicate parital sending
  1547. }
  1549. Result = Format_Send(p,Stream);
  1551. if (Result == ERR_BUFFER_FULL || Result == ERR_SYNCED)
  1552. break;
  1554. if (Stream->State.DropLevel==2 && Stream->PacketFirst && Burst<10 && No==Burst-1)
  1555. ++Burst; // try to catch up
  1556. }
  1558. // buffer full: there was possibly some processing so don't allow sleeping
  1559. // need data: burst count exceeded, but it doesn't mean there is no data left in buffers
  1560. if (Result == ERR_BUFFER_FULL || Result == ERR_NEED_MORE_DATA)
  1561. Result = ERR_NONE;
  1563. return Result;
  1564. }
  1566. static void Format_Sended(format_base* p, format_stream* Stream)
  1567. {
  1568. format_packet* Packet = Stream->PacketFirst;
  1569. if (Packet)
  1570. {
  1571. if (Stream->Pending == 2 && Packet->Data)
  1572. {
  1573. // release sended references
  1574. format_ref* Ref = Packet->Data;
  1575. Packet->Data = Ref->Next;
  1576. Format_SingleRefRelease(p,Ref);
  1578. if (Packet->Data)
  1579. {
  1580. // packet still not finished
  1581. Packet->RefTime = TIME_UNKNOWN;
  1582. return;
  1583. }
  1584. }
  1586. // full packet is released
  1587. Stream->PacketFirst = Packet->Next;
  1588. if (Stream->PacketLast == Packet)
  1589. Stream->PacketLast = NULL;
  1591. Format_PacketRelease(p,Packet);
  1592. }
  1593. }
  1595. NOINLINE format_stream* Format_DefSyncStream(format_base* p, format_reader* Reader)
  1596. {
  1597. format_stream* Found = NULL;
  1598. format_stream* Stream;
  1599. int No;
  1601. // prefer video streams
  1602. for (No=0;No<p->StreamCount;++No)
  1603. {
  1604. Stream = p->Streams[No];
  1605. if (Stream->Pin.Node && (!Reader || Stream->Reader==Reader))
  1606. {
  1607. if (Stream->Format.Type == PACKET_VIDEO)
  1608. return Stream;
  1610. if (!Found)
  1611. Found = Stream;
  1612. }
  1613. }
  1615. return Found;
  1616. }
  1618. static bool_t TryReSend(node* p)
  1619. {
  1620. if (p)
  1621. {
  1622. bool_t Buffered;
  1623. if (p->Get(p,FLOW_BUFFERED,&Buffered,sizeof(Buffered))==ERR_NONE && Buffered)
  1624. return p->Set(p,FLOW_RESEND,NULL,0) == ERR_NONE;
  1626. if (!NodeIsClass(p->Class,OUT_CLASS))
  1627. {
  1628. pin Pin;
  1629. node* Node;
  1630. datadef DataDef;
  1631. int No;
  1633. for (No=0;NodeEnum(p,No,&DataDef)==ERR_NONE;++No)
  1634. if (DataDef.Flags & DF_OUTPUT)
  1635. {
  1636. switch (DataDef.Type)
  1637. {
  1638. case TYPE_NODE:
  1639. if (p->Get(p,DataDef.No,&Node,sizeof(Node))==ERR_NONE && TryReSend(Node))
  1640. return 1;
  1641. break;
  1643. case TYPE_PACKET:
  1644. if (p->Get(p,DataDef.No,&Pin,sizeof(Pin))==ERR_NONE && TryReSend(Pin.Node))
  1645. return 1;
  1646. break;
  1647. }
  1648. }
  1649. }
  1650. }
  1651. return 0;
  1652. }
  1654. static int DummyError(void* This,int Param,int Param2)
  1655. {
  1656. return ERR_NONE;
  1657. }
  1659. static NOINLINE int ProcessCoverArt(format_base* p,format_stream* Stream)
  1660. {
  1661. int Result;
  1662. notify Error;
  1663. context* c = Context();
  1664. node* Node = Stream->Pin.Node;
  1665. if (!Node)
  1666. return ERR_NONE;
  1668. if (TryReSend(Node))
  1669. return ERR_NONE;
  1671. // suppress covert art decoding error messages
  1672. Error = c->Error;
  1673. c->Error.Func = DummyError;
  1675. Stream->State.CurrTime = TIME_SYNC;
  1676. Stream->State.DropLevel = 0;
  1677. Result = Stream->Process(Node,&Stream->Packet,&Stream->State);
  1679. c->Error = Error;
  1680. return Result;
  1681. }
  1683. static int Format_Process(format_base* p,processstate* State)
  1684. {
  1685. int No;
  1686. int Result;
  1687. int AllNeedMoreData = 1;
  1688. int AllEndOfFile = 1;
  1690. assert(State->Time>=0 || State->Time == TIME_BENCH);
  1692. State->BufferUsedBefore = p->BufferUsed;
  1693. p->ProcessTime = State->Time;
  1694. p->Bench = p->ProcessTime < 0;
  1696. if (!p->HeaderLoaded)
  1697. {
  1698. // load format begining to find streams
  1699. format_reader* Reader = p->Reader;
  1701. Result = p->FillQueue(p,Reader);
  1703. if (Reader->FilePos > HEADERLOAD || (p->StreamCount && Reader->FilePos > p->MinHeaderLoad) || Reader->Eof(Reader))
  1704. p->HeaderLoaded = 1;
  1706. State->BufferUsedAfter = p->BufferUsed;
  1707. return Result;
  1708. }
  1710. if (p->SyncMode)
  1711. {
  1712. p->ProcessTime = TIME_SYNC;
  1713. // we need to choose one stream (to find a non dropped frame)
  1714. if (!p->SyncStream)
  1715. {
  1716. p->SyncStream = Format_DefSyncStream(p,NULL);
  1717. if (!p->SyncStream)
  1718. {
  1719. // no sync needed
  1720. p->SyncMode = 0;
  1722. // try to calc duration once (after first sync)
  1723. if (p->FirstSync)
  1724. {
  1725. p->FirstSync = 0;
  1726. CalcDuration(p);
  1727. }
  1729. if (p->CoverArt)
  1730. ProcessCoverArt(p,p->CoverArt);
  1732. // leave time as it is
  1733. State->BufferUsedAfter = p->BufferUsed;
  1734. return ERR_SYNCED;
  1735. }
  1736. }
  1737. }
  1739. // if all streams are full: caller can go to sleep
  1740. Result = ERR_BUFFER_FULL;
  1742. if (p->SubTitle)
  1743. Format_ProcessSubTitle(p,p->SubTitle);
  1745. for (No=0;No<p->StreamCount;++No)
  1746. {
  1747. format_stream* Stream = p->Streams[No];
  1748. if (Stream->Pin.Node)
  1749. {
  1750. int i = p->Process(p,Stream);
  1752. if (!p->SyncMode || p->SyncStream == Stream)
  1753. {
  1754. if (i == ERR_NEED_MORE_DATA)
  1755. {
  1756. if (!Stream->Reader->NoMoreInput && Stream->Format.Type != PACKET_SUBTITLE)
  1757. {
  1758. // if less then 1/8 sec is left and stream needs data -> force need more data mode
  1759. tick_t LastTime = Stream->LastTime;
  1760. if (State->Fill || (LastTime >= 0 && p->ProcessTime >= 0 && LastTime < p->ProcessTime + TICKSPERSEC/8))
  1761. Result = ERR_NEED_MORE_DATA;
  1762. }
  1763. }
  1764. else
  1765. AllNeedMoreData = 0;
  1767. if (i != ERR_END_OF_FILE)
  1768. AllEndOfFile = 0;
  1769. }
  1771. if (i == ERR_SYNCED)
  1772. {
  1773. // try to calc duration once (after first sync)
  1774. if (p->FirstSync)
  1775. {
  1776. p->FirstSync = 0;
  1777. CalcDuration(p);
  1778. }
  1780. if (p->CoverArt)
  1781. ProcessCoverArt(p,p->CoverArt);
  1783. State->Time = p->SyncTime;
  1784. State->BufferUsedAfter = p->BufferUsed;
  1785. return i;
  1786. }
  1788. if (Result == ERR_BUFFER_FULL &&
  1789. i != ERR_BUFFER_FULL && 
  1790. i != ERR_END_OF_FILE && 
  1791. i != ERR_NEED_MORE_DATA)
  1792. Result = ERR_NONE; // no sleep
  1794. if (Result == ERR_NONE && Stream->State.DropLevel)
  1795. Result = ERR_DROPPING;
  1796. }
  1797. }
  1799. if (!p->ActiveStreams)
  1800. {
  1801. // release buffers
  1802. Result = ERR_END_OF_FILE;
  1804. for (No=0;No<MAXREADER;++No)
  1805. {
  1806. format_buffer* Buffer;
  1807. format_reader* Reader = p->Reader+No;
  1808. if (!Reader->Input)
  1809. break;
  1810. while ((Buffer = Format_BufferRemove(Reader))!=NULL)
  1811. {
  1812. Reader->FilePos += Buffer->Length;
  1813. Format_BufferRelease(p,Buffer);
  1814. }
  1815. if (!Reader->NoMoreInput)
  1816. Result = ERR_BUFFER_FULL; // return buffer full so fill mode doesn't go though file
  1817. }
  1819. State->Time = TIME_UNKNOWN; // player should use file position
  1820. }
  1821. else
  1822. {
  1823. if (AllEndOfFile) // all end of file?
  1824. Result = ERR_END_OF_FILE;
  1825. else
  1826. if (AllNeedMoreData) // all need data?
  1827. {
  1828. Result = ERR_END_OF_FILE;
  1829. for (No=0;No<MAXREADER;++No)
  1830. {
  1831. if (!p->Reader[No].Input)
  1832. break;
  1833. if (!p->Reader[No].NoMoreInput)
  1834. {
  1835. Result = ERR_NEED_MORE_DATA;
  1836. break;
  1837. }
  1838. }
  1839. }
  1840. else
  1841. if (Result == ERR_BUFFER_FULL && State->Fill)
  1842. {
  1843. // don't allow exiting fill mode if buffer is less than ProcessMinBuffer+BLOCKSIZE
  1844. // we might fallback to loadmode right after starting playback
  1845. if (p->Reader->BufferAvailable < p->ProcessMinBuffer+BLOCKSIZE && !p->Reader->NoMoreInput)
  1846. Result = ERR_NEED_MORE_DATA; 
  1847. }
  1848. }
  1850. if (p->SyncMode && Result == ERR_END_OF_FILE)
  1851. {
  1852. p->SyncMode = 0;
  1853. if (p->Duration<0 && p->SyncStream)
  1854. State->Time = p->SyncStream->LastTime;
  1855. else
  1856. State->Time = p->Duration;
  1857. Result = ERR_SYNCED;
  1858. }
  1860. State->BufferUsedAfter = p->BufferUsed;
  1861. return Result;
  1862. }
  1864. format_ref* Format_RefAlloc(format_base* p, format_buffer* To, int Begin, int Length)
  1865. {
  1866. format_ref* Ref = p->FreeRefs;
  1868. if (!Ref)
  1869. {
  1870. Ref = (format_ref*) malloc(sizeof(format_ref));
  1871. if (!Ref)
  1872. return NULL;
  1873. }
  1874. else
  1875. p->FreeRefs = Ref->Next;
  1877. LockEnter(p->BufferLock);
  1879. //DEBUG_MSG3(DEBUG_FORMAT,"Buffer:%d addref %d->%d",To->Id,To->RefCount,To->RefCount+1);
  1880. ++To->RefCount;
  1882. LockLeave(p->BufferLock);
  1884. Ref->Length = Length;
  1885. Ref->Begin = Begin;
  1886. Ref->Buffer = To;
  1887. Ref->Next = NULL;
  1888. return Ref;
  1889. }
  1891. bool_t Format_ReadBuffer(format_reader* Reader, bool_t ToRead)
  1892. {
  1893. bool_t Result;
  1895. LockEnter(Reader->Format->InputLock);
  1896. LockEnter(Reader->Format->BufferLock);
  1898. if (!Reader->BufferFirst && !Reader->NoMoreInput)
  1899. {
  1900. format_buffer* Buffer = Reader->InputBuffer;
  1902. if (!Buffer)
  1903. Buffer = Format_BufferAlloc(Reader->Format,1);
  1905. if (Buffer)
  1906. {
  1907. // use partial buffer loading after sync for a few times (SYNCREAD)
  1908. // but later have to use full buffer (matroska seeking example can run out of buffer...)
  1909. int TargetLength = (ToRead && Reader->Format->SyncRead>0)? Reader->Format->ReadSize:BLOCKSIZE;
  1910. if (Buffer->Length >= TargetLength)
  1911. {
  1912. Format_BufferInsert(Reader,Buffer);
  1913. Reader->InputBuffer = NULL;
  1914. }
  1915. else
  1916. {
  1917. int Length = Reader->Input->ReadBlock(Reader->Input,&Buffer->Block,Buffer->Length,TargetLength - Buffer->Length);
  1918. if (Length < 0)
  1919. {
  1920. // failed
  1921. if (!Reader->InputBuffer)
  1922. Format_BufferRelease(Reader->Format,Buffer);
  1923. }
  1924. else
  1925. {
  1926. Buffer->Length += Length;
  1927. Reader->NoMoreInput = Length == 0;
  1929. if (!Length && !Reader->InputBuffer)
  1930. Format_BufferRelease(Reader->Format,Buffer);
  1931. else
  1932. {
  1933. Format_BufferInsert(Reader,Buffer);
  1934. Reader->InputBuffer = NULL;
  1935. }
  1936. }
  1937. }
  1938. }
  1940. if (Reader->Format->SyncRead>0)
  1941. Reader->Format->SyncRead--;
  1942. }
  1944. Result = Reader->BufferFirst != NULL;
  1946. if (Result && ToRead)
  1947. {
  1948. Reader->ReadBuffer = Format_BufferRemove(Reader);
  1949. if (Reader->ReadBuffer)
  1950. Reader->ReadLen = Reader->ReadBuffer->Length;
  1951. }
  1953. LockLeave(Reader->Format->BufferLock);
  1954. LockLeave(Reader->Format->InputLock);
  1956. return Result;
  1957. }
  1959. format_ref* Format_DupRef(format_base* p, format_ref* Chain, int Offset, int Length)
  1960. {
  1961. format_ref* Head = NULL;
  1962. format_ref** Ptr = &Head;
  1964. while (Chain && Offset >= Chain->Length)
  1965. {
  1966. Chain = Chain->Next;
  1967. Offset -= Chain->Length;
  1968. }
  1970. while (Chain && Length > 0)
  1971. {
  1972. int Len = Chain->Length - Offset;
  1973. if (Len > Length)
  1974. Len = Length;
  1976. *Ptr = Format_RefAlloc(p,Chain->Buffer,Chain->Begin+Offset,Len);
  1977. if (!*Ptr)
  1978. break;
  1980. Chain = Chain->Next;
  1981. Length -= Len;
  1982. Offset = 0;
  1984. Ptr = &(*Ptr)->Next;
  1985. }
  1987. return Head;
  1988. }
  1990. //---------------------------------------------------------------------------------------------
  1992. static bool_t Reader_GetReadBuffer(format_reader* Reader)
  1993. {
  1994. if (!Reader->Input) // external reader
  1995. {
  1996. Reader->ReadBuffer = NULL;
  1997. return 0;
  1998. }
  2000. // release old buffer
  2001. if (Reader->ReadBuffer)
  2002. {
  2003. Reader->ReadPos -= Reader->ReadBuffer->Length;
  2004. Format_BufferRelease(Reader->Format,Reader->ReadBuffer);
  2005. }
  2007. // get new buffer from BufferFirst..BufferLast chain
  2008. Reader->ReadBuffer = Format_BufferRemove(Reader);
  2009. if (Reader->ReadBuffer)
  2010. {
  2011. Reader->ReadLen = Reader->ReadBuffer->Length;
  2012. return 1;
  2013. }
  2015. // load input now (can't wait for input thread)
  2016. return Format_ReadBuffer(Reader,1);
  2017. }
  2019. format_ref* Reader_ReadAsRef(format_reader* p, int Length)
  2020. {
  2021. int n;
  2022. format_ref* Ref;
  2023. format_ref** RefPtr;
  2025. Ref = NULL;
  2026. RefPtr = &Ref;
  2028. if (Length < 0) // read as much as possible from one buffer
  2029. {
  2030. while (!p->ReadBuffer || p->ReadPos >= p->ReadLen)
  2031. if (!p->GetReadBuffer(p))
  2032. return NULL;
  2034. n = p->ReadLen - p->ReadPos;
  2035. if (n > -Length)
  2036. n = -Length;
  2037. Length = n;
  2038. }
  2040. while (Length > 0)
  2041. {
  2042. while (!p->ReadBuffer || p->ReadPos >= p->ReadLen)
  2043. if (!p->GetReadBuffer(p))
  2044. return Ref;
  2046. n = p->ReadLen - p->ReadPos;
  2047. if (n > Length)
  2048. n = Length;
  2050. *RefPtr = Format_RefAlloc(p->Format,p->ReadBuffer,p->ReadPos,n);
  2051. if (!*RefPtr)
  2052. break;
  2054. RefPtr = &(*RefPtr)->Next;
  2056. Length -= n;
  2057. p->FilePos += n;
  2058. p->ReadPos += n;
  2059. }
  2060. return Ref;
  2061. }
  2063. static void Reader_Skip(format_reader* p,int n)
  2064. {
  2065. if (n > 0)
  2066. {
  2067. assert(n < 0x10000000);
  2068. p->FilePos += n;
  2069. p->ReadPos += n;
  2070. }
  2071. }
  2073. static int Reader_Seek(format_reader* Reader,filepos_t Pos,int Origin)
  2074. {
  2075. int Adjust = 0;
  2077. if (Reader->FilePos >= 0 && !Reader->Format->DisableReader)
  2078. {
  2079. filepos_t RelPos = Pos;
  2080. if (Origin == SEEK_SET)
  2081. RelPos -= Reader->FilePos;
  2082. if (Origin != SEEK_END)
  2083. {
  2084. // check if we can use Format_Skip
  2085. if (RelPos >= 0 && RelPos < Reader->BufferAvailable + SKIPDISTANCE)
  2086. {
  2087. Reader_Skip(Reader,RelPos);
  2088. return ERR_NONE;
  2089. }
  2091. // check if we are in the same ReadBuffer
  2092. if (RelPos < 0 && Reader->ReadBuffer && Reader->ReadPos + RelPos >= 0)
  2093. {
  2094. Reader->FilePos += RelPos;
  2095. Reader->ReadPos += RelPos;
  2096. return ERR_NONE;
  2097. }
  2098. }
  2099. }
  2101. if (!Reader->Input)
  2102. return ERR_NOT_SUPPORTED;
  2104. if (Origin == SEEK_CUR)
  2105. {
  2106. // input is at a different position already, using SEEK_SET
  2107. Origin = SEEK_SET;
  2108. Pos += Reader->FilePos;
  2109. }
  2111. if (Origin == SEEK_SET)
  2112. {
  2113. // align reading for local files
  2114. Adjust = Pos & (Reader->Format->FileAlign-1);
  2115. Pos &= ~(Reader->Format->FileAlign-1);
  2116. }
  2118. LockEnter(Reader->Format->InputLock);
  2119. Pos = Reader->Input->Seek(Reader->Input,Pos,Origin);
  2120. if (Pos < 0)
  2121. {
  2122. LockLeave(Reader->Format->InputLock);
  2123. return ERR_NOT_SUPPORTED;
  2124. }
  2126. // query again file size, because http could have reopened connection
  2127. if (Reader->Input->Get(Reader->Input,STREAM_LENGTH,&Reader->Format->FileSize,sizeof(Reader->Format->FileSize)) != ERR_NONE)
  2128. Reader->Format->FileSize = -1;
  2130. Format_ReleaseBuffers(Reader);
  2132. Reader->FilePos = Pos + Adjust;
  2133. Reader->ReadPos += Adjust;
  2135. LockLeave(Reader->Format->InputLock);
  2137. return ERR_NONE;
  2138. }
  2140. static bool_t Reader_Eof(format_reader* p)
  2141. {
  2142. return !p->BufferAvailable && !p->ReadBuffer && p->NoMoreInput;
  2143. }
  2145. static int Reader_Read(format_reader* p, void* Data, int Length0)
  2146. {
  2147. uint8_t* Ptr = (uint8_t*)Data;
  2148. int Length = Length0;
  2149. int n;
  2150. while (Length > 0)
  2151. {
  2152. while (!p->ReadBuffer || p->ReadPos >= p->ReadLen)
  2153. if (!p->GetReadBuffer(p))
  2154. return Length0 - Length;
  2156. n = p->ReadLen - p->ReadPos;
  2157. if (n > Length)
  2158. n = Length;
  2160. memcpy(Ptr,p->ReadBuffer->Block.Ptr+p->ReadPos,n);
  2161. Ptr += n;
  2162. Length -= n;
  2163. p->FilePos += n;
  2164. p->ReadPos += n;
  2165. }
  2167. return Length0;
  2168. }
  2170. static int Reader_Read8(format_reader* p)
  2171. {
  2172. while (!p->ReadBuffer || p->ReadPos >= p->ReadLen)
  2173. if (!p->GetReadBuffer(p))
  2174. return -1;
  2176. p->FilePos++;
  2177. return p->ReadBuffer->Block.Ptr[p->ReadPos++];
  2178. }
  2180. static int Reader_ReadBE16(format_reader* p)
  2181. {
  2182. int v = Reader_Read8(p) << 8;
  2183. v |= Reader_Read8(p);
  2184. return v;
  2185. }
  2187. static int Reader_ReadLE16(format_reader* p)
  2188. {
  2189. int v = Reader_Read8(p);
  2190. v |= Reader_Read8(p) << 8;
  2191. return v;
  2192. }
  2194. static int Reader_ReadBE32(format_reader* p)
  2195. {
  2196. int v = Reader_Read8(p) << 24;
  2197. v |= Reader_Read8(p) << 16;
  2198. v |= Reader_Read8(p) << 8;
  2199. v |= Reader_Read8(p);
  2200. return v;
  2201. }
  2203. static int Reader_ReadLE32(format_reader* p)
  2204. {
  2205. int v = Reader_Read8(p);
  2206. v |= Reader_Read8(p) << 8;
  2207. v |= Reader_Read8(p) << 16;
  2208. v |= Reader_Read8(p) << 24;
  2209. return v;
  2210. }
  2212. static int64_t Reader_ReadBE64(format_reader* p)
  2213. {
  2214. int64_t v = (int64_t)Reader_ReadBE32(p) << 32;
  2215. v |= (uint32_t)Reader_ReadBE32(p);
  2216. return v;
  2217. }
  2219. static int64_t Reader_ReadLE64(format_reader* p)
  2220. {
  2221. int64_t v = (uint32_t)Reader_ReadLE32(p);
  2222. v |= (int64_t)Reader_ReadLE32(p) << 32;
  2223. return v;
  2224. }
  2226. static NOINLINE int GetRate(format_reader* p,format_reader* Last)
  2227. {
  2228. int64_t Rate;
  2230. if (p->NoMoreInput)
  2231. return MAX_INT;
  2233. if (p->BufferAvailable <= PROCESSMINVIDEO)
  2234. return -MAX_INT;
  2236. Rate = (int64_t)p->Ratio * (p->BufferAvailable - (p==Last?READER_BONUS:0));
  2237. if (Rate > MAX_INT)
  2238. return MAX_INT;
  2239. return (int)Rate;
  2240. }
  2242. static int Format_ReadInput(format_base* p,int BufferMax,int* BufferUsed)
  2243. {
  2244. int No;
  2245. int Left,Length;
  2246. int Result = ERR_NONE;
  2247. format_buffer* Buffer;
  2248. format_reader* Reader;
  2249. int Used = p->BufferUsed;
  2251. // simple estimate test without locking BufferUsed
  2252. if (Used >= BufferMax)
  2253. {
  2254. *BufferUsed = Used;
  2255. return ERR_BUFFER_FULL;
  2256. }
  2258. LockEnter(p->InputLock);
  2259. LockEnter(p->BufferLock);
  2261. // select which reader to use
  2262. Reader = p->Reader;
  2263. if (p->Reader[1].Input)
  2264. {
  2265. int Lowest = GetRate(Reader,p->LastRead);
  2266. for (No=1;No<MAXREADER;++No)
  2267. {
  2268. format_reader* r = p->Reader+No;
  2269. if (r->Ratio > 0)
  2270. {
  2271. int Rate = GetRate(r,p->LastRead);
  2272. if (Lowest > Rate)
  2273. {
  2274. Lowest = Rate;
  2275. Reader = r;
  2276. }
  2277. }
  2278. }
  2280. p->LastRead = Reader;
  2281. }
  2283. Buffer = Reader->InputBuffer;
  2284. if (!Buffer)
  2285. {
  2286. // allocate input buffer
  2287. if (p->BufferUsed < BufferMax) // check again (BufferUsed is locked)
  2288. {
  2289. Buffer = Format_BufferAlloc(p,0);
  2290. if (p->BufferUsed >= BufferMax)
  2291. Result = ERR_BUFFER_FULL;
  2292. }
  2294. if (!Buffer)
  2295. {
  2296. *BufferUsed = p->BufferUsed;
  2297. LockLeave(p->BufferLock);
  2298. LockLeave(p->InputLock);
  2299. return ERR_BUFFER_FULL;
  2300. }
  2302. #ifndef NDEBUG
  2303. Buffer->FilePos = Reader->Input->Seek(Reader->Input,0,SEEK_CUR);
  2304. #endif
  2305. }
  2307. *BufferUsed = p->BufferUsed;
  2308. LockLeave(p->BufferLock);
  2310. Left = BLOCKSIZE - Buffer->Length;
  2311. if (Left > p->ReadSize)
  2312. Left = p->ReadSize;
  2314. if (Reader->Input->DataAvailable)
  2315. {
  2316. int Available = Reader->Input->DataAvailable(Reader->Input);
  2317. if (Available>=0)
  2318. {
  2319. if (!Available)
  2320. {
  2321. if (!Reader->InputBuffer)
  2322. Format_BufferRelease(Reader->Format,Buffer);
  2323. LockLeave(p->InputLock);
  2324. return ERR_NEED_MORE_DATA;
  2325. }
  2327. if (Left > Available)
  2328. Left = Available;
  2329. }
  2330. }
  2332. Length = Reader->Input->ReadBlock(Reader->Input,&Buffer->Block,Buffer->Length,Left);
  2334. if (Length < 0)
  2335. {
  2336. // failed
  2337. if (!Reader->InputBuffer)
  2338. Format_BufferRelease(Reader->Format,Buffer);
  2339. Result = ERR_DEVICE_ERROR;
  2340. }
  2341. else
  2342. {
  2343. Buffer->Length += Length;
  2344. Reader->NoMoreInput = Length == 0;
  2346. if (!Length)
  2347. {
  2348. // only return end of file if all readers are at the end
  2349. Result = ERR_END_OF_FILE;
  2350. for (No=0;No<MAXREADER;++No)
  2351. {
  2352. if (!p->Reader[No].Input)
  2353. break;
  2354. if (!p->Reader[No].NoMoreInput)
  2355. {
  2356. Result = ERR_NONE;
  2357. break;
  2358. }
  2359. }
  2360. }
  2362. if (!Length && !Reader->InputBuffer)
  2363. Format_BufferRelease(Reader->Format,Buffer);
  2364. else
  2365. {
  2366. if (!Length || Buffer->Length == BLOCKSIZE || p->ProcessMinBuffer==0)
  2367. {
  2368. LockEnter(p->BufferLock);
  2369. Format_BufferInsert(Reader,Buffer);
  2370. LockLeave(p->BufferLock);
  2371. Buffer = NULL;
  2372. }
  2373. Reader->InputBuffer = Buffer;
  2374. }
  2375. }
  2377. LockLeave(p->InputLock);
  2378. return Result;
  2379. }
  2381. static NOINLINE void UpdateTotalCount(format_base* p)
  2382. {
  2383. p->TotalCount = p->StreamCount;
  2384. if (p->SubTitle)
  2385. p->Streams[p->TotalCount++] = p->SubTitle;
  2386. if (p->CoverArt)
  2387. p->Streams[p->TotalCount++] = p->CoverArt;
  2388. }
  2390. static NOINLINE void ReadCoverArt(format_base* p,stream* Input,filepos_t Pos,int Len,const tchar_t* ContentType,const tchar_t* URL)
  2391. {
  2392. uint8_t Probe[512];
  2393. int ProbeLen;
  2395. Input->Seek(Input,Pos,SEEK_SET);
  2396. ProbeLen = Input->Read(Input,Probe,min(Len,sizeof(Probe)));
  2397. if (ProbeLen>0)
  2398. {
  2399. int *i;
  2400. array List;
  2401. NodeEnumClassEx(&List,RAWIMAGE_CLASS,ContentType,URL,Probe,ProbeLen);
  2402. for (i=ARRAYBEGIN(List,int);i!=ARRAYEND(List,int);++i)
  2403. {
  2404. const tchar_t* Format = LangStr(*i,RAWIMAGE_FORMAT);
  2405. if (tcsnicmp(Format,T("vcodec/"),7)==0)
  2406. {
  2407. format_stream* s = (format_stream*) malloc(sizeof(format_stream));
  2408. if (!s)
  2409. return;
  2411. memset(s,0,sizeof(format_stream));
  2412. s->Format.Type = PACKET_VIDEO;
  2413. s->Format.Format.Video.Pixel.Flags = PF_FOURCC|PF_NOPREROTATE;
  2414. s->Format.Format.Video.Pixel.FourCC = StringToFourCC(Format+7,1);
  2416. if (Format_AllocBufferBlock(p,s,Len))
  2417. {
  2418. WriteBlock(&s->BufferBlock,0,Probe,ProbeLen);
  2419. s->Packet.Length = ProbeLen;
  2421. if (Len>ProbeLen)
  2422. s->Packet.Length += Input->ReadBlock(Input,&s->BufferBlock,ProbeLen,Len-ProbeLen);
  2423. }
  2425. if (s->Packet.Length>0)
  2426. {
  2427. s->Packet.Data[0] = s->BufferBlock.Ptr;
  2428. s->Packet.Key = 1;
  2429. s->Packet.RefTime = 0;
  2431. p->CoverArt = s;
  2432. UpdateTotalCount(p);
  2433. Format_PrepairStream(p,s);
  2434. }
  2435. else
  2436. Format_FreeStream(p,s);
  2437. break;
  2438. }
  2439. }
  2440. ArrayClear(&List);
  2441. }
  2442. }
  2444. static NOINLINE bool_t GetNonStreamingURL(format_base* p,tchar_t* URL,int URLLen,bool_t Local)
  2445. {
  2446. bool_t HasHost;
  2447. int Length;
  2448. stream* Input = p->Reader->Input;
  2450. if (!Input)
  2451. return 0;
  2453. LockEnter(p->InputLock);
  2454. if (Input->Get(Input,STREAM_URL,URL,URLLen*sizeof(tchar_t)) != ERR_NONE)
  2455. URL[0] = 0;
  2456. if (Input->Get(Input,STREAM_LENGTH,&Length,sizeof(Length)) != ERR_NONE)
  2457. Length = -1;
  2458. LockLeave(p->InputLock);
  2460. if (!URL[0])
  2461. return 0; //no URL?
  2463. GetMime(URL,NULL,0,&HasHost);
  2464. if (HasHost && (Local || Length<0))
  2465. return 0; //non local or streaming
  2466. return 1;
  2467. }
  2469. static NOINLINE bool_t OpenCoverAtr(format_base* p, const tchar_t* Base, const tchar_t* Name)
  2470. {
  2471. tchar_t Path[MAXPATH];
  2472. int Length;
  2473. stream* Input;
  2475. AbsPath(Path,TSIZEOF(Path),Name,Base);
  2476. if (FileExits(Path) && (Input = GetStream(Path,1))!=NULL)
  2477. {
  2478. //todo: cache global cover art...
  2480. if (Input->Set(Input,STREAM_URL,Path,sizeof(tchar_t)*(tcslen(Path)+1)) == ERR_NONE &&
  2481. Input->Get(Input,STREAM_LENGTH,&Length,sizeof(Length)) == ERR_NONE)
  2482. ReadCoverArt(p,Input,0,Length,NULL,Path);
  2484. Input->Set(Input,STREAM_URL,NULL,0);
  2485. NodeDelete((node*)Input);
  2486. }
  2487. return p->CoverArt != NULL;
  2488. }
  2490. static NOINLINE void FindCoverArt(format_base* p)
  2491. {
  2492. tchar_t Value[MAXPATH];
  2494. if (p->Comment.Node && NodeIsClass(p->Comment.Node->Class,PLAYER_ID) &&
  2495. ((player*)p->Comment.Node)->CommentByName(p->Comment.Node,-1,PlayerComment(COMMENT_COVER),Value,TSIZEOF(Value)))
  2496. {
  2497. tchar_t* SPos = tcschr(Value,':');
  2498. tchar_t* SLen = SPos?tcschr(SPos+1,':'):NULL;
  2499. tchar_t* ContentType = SLen?tcschr(SLen+1,':'):NULL;
  2500. int Pos = SPos ? StringToInt(SPos+1,0):0;
  2501. int Len = SLen ? StringToInt(SLen+1,0):0;
  2503. if (ContentType && Len>0)
  2504. {
  2505. stream* Input = p->Reader->Input;
  2506. filepos_t SavePos;
  2507. LockEnter(p->InputLock);
  2509. SavePos = Input->Seek(Input,0,SEEK_CUR);
  2510. if (SavePos >= 0)
  2511. {
  2512. if (*(++ContentType)==0)
  2513. ContentType = NULL;
  2515. ReadCoverArt(p,Input,Pos,Len,ContentType,NULL);
  2516. Input->Seek(Input,SavePos,SEEK_SET);
  2517. }
  2518. LockLeave(p->InputLock);
  2519. }
  2520. }
  2521. else if (NodeIsClass(p->Format.Class,RAWAUDIO_CLASS) && GetNonStreamingURL(p,Value,TSIZEOF(Value),1))
  2522. {
  2523. tchar_t Base[MAXPATH];
  2524. SplitURL(Value,Base,TSIZEOF(Base),Base,TSIZEOF(Base),NULL,0,NULL,0);
  2526. if (!OpenCoverAtr(p,Base,T("cover.jpg")) &&
  2527. !OpenCoverAtr(p,Base,T("folder.jpg")) &&
  2528. !OpenCoverAtr(p,Base,T("front.jpg")) &&
  2529. !OpenCoverAtr(p,Base,T("coverart.jpg")));
  2530. }
  2531. }
  2533. static void FindSubtitles(format_base* p)
  2534. {
  2535. /*
  2536. //!SUBTITLE
  2537. tchar_t* SubExt[] = { T("sub"),T("str"),T("smi"), NULL };
  2538. tchar_t** s;
  2540. tchar_t URL[MAXPATH];
  2541. if (!GetNonStreamingURL(p,URL,TSIZEOF(URL),0))
  2542. return;
  2544. for (s=SubExt;*s && !p->SubTitle;++s)
  2545. if (SetFileExt(URL,TSIZEOF(URL),*s))
  2546. {
  2547. stream* Input = GetStream(URL,1);
  2548. if (Input)
  2549. {
  2550. bool_t Silent = 1;
  2551. Input->Set(Input,STREAM_SILENT,&Silent,sizeof(Silent));
  2553. if (Input->Set(Input,STREAM_URL,URL,sizeof(tchar_t)*(tcslen(URL)+1)) == ERR_NONE)
  2554. {
  2555. p->SubTitle = Format_LoadSubTitle(p,Input);
  2556. if (p->SubTitle)
  2557. {
  2558. UpdateTotalCount(p);
  2559. Format_PrepairStream(p,(format_stream*)p->SubTitle);
  2560. }
  2561. }
  2562. Input->Delete(Input);
  2563. }
  2564. }
  2565. */
  2566. }
  2568. void Format_PrepairStream(format_base* p,format_stream* Stream)
  2569. {
  2570. switch (Stream->Format.Type)
  2571. {
  2572. case PACKET_VIDEO: Stream->PacketBurst = VIDEO_BURST; break;
  2573. case PACKET_AUDIO: Stream->PacketBurst = AUDIO_BURST; break;
  2574. case PACKET_SUBTITLE: Stream->PacketBurst = 1; break;
  2575. }
  2577. if (p->ProcessMinBuffer)
  2578. p->ProcessMinBuffer = IsVideo(p) ? PROCESSMINVIDEO:PROCESSMINAUDIO;
  2580. if (Stream->Format.Type == PACKET_AUDIO && Stream->Format.Format.Audio.Format == AUDIOFMT_PCM)
  2581. {
  2582. // there could be alignement problems (with memory and with audio.BlockSize)
  2583. Stream->Fragmented = 0;
  2584. Stream->ForceMerge = 1;
  2585. }
  2587. if (p->UpdateStreams.Func)
  2588. p->UpdateStreams.Func(p->UpdateStreams.This,0,0);
  2590. if (Stream->Format.Type == PACKET_VIDEO && p->NeedSubtitles)
  2591. {
  2592. p->NeedSubtitles = 0;
  2593. FindSubtitles(p);
  2594. }
  2595. }
  2597. static NOINLINE void DefaultPalette(packetformat* p)
  2598. {
  2599. if (p->Format.Video.Pixel.BitCount >= 1 &&
  2600. p->Format.Video.Pixel.BitCount <= 8 &&
  2601. p->ExtraLength >= (4 << p->Format.Video.Pixel.BitCount))
  2602. p->Format.Video.Pixel.Palette = p->Extra;
  2603. }
  2605. int Format_BitmapInfoMem(format_stream* s,void* Data,int Length)
  2606. {
  2607. if (Length>=4)
  2608. {
  2609. char* p = (char*)Data;
  2610. int Size = INT32LE(*(int32_t*)p);
  2611. if (Length >= Size)
  2612. {
  2613. PacketFormatClear(&s->Format);
  2614. s->Format.Type = PACKET_VIDEO;
  2615. s->Format.Format.Video.Width = INT32LE(*(int32_t*)(p+4));
  2616. s->Format.Format.Video.Height = INT32LE(*(int32_t*)(p+8));
  2617. s->Format.Format.Video.Pixel.BitCount = INT16LE(*(int16_t*)(p+14));
  2618. s->Format.Format.Video.Pixel.FourCC = INT32LE(*(int32_t*)(p+16));
  2619. s->Format.Format.Video.Aspect = ASPECT_ONE; //todo
  2621. if (PacketFormatExtra(&s->Format,Size-40))
  2622. {
  2623. memcpy(s->Format.Extra,p+40,s->Format.ExtraLength);
  2624. DefaultPalette(&s->Format);
  2625. }
  2627. PacketFormatDefault(&s->Format);
  2628. }
  2629. else
  2630. Size = 4;
  2631. Length -= Size;
  2632. }
  2633. return Length;
  2634. }
  2636. void Format_BitmapInfo(format_reader* p,format_stream* s,int Length)
  2637. {
  2638. if (Length>=4)
  2639. {
  2640. int Size = p->ReadLE32(p); //size
  2641. if (Length >= Size)
  2642. {
  2643. PacketFormatClear(&s->Format);
  2644. s->Format.Type = PACKET_VIDEO;
  2645. s->Format.Format.Video.Width = p->ReadLE32(p); 
  2646. s->Format.Format.Video.Height = p->ReadLE32(p); 
  2647. p->ReadLE16(p); //planes
  2648. s->Format.Format.Video.Pixel.BitCount = p->ReadLE16(p);
  2649. s->Format.Format.Video.Pixel.FourCC = p->ReadLE32(p);
  2650. s->Format.Format.Video.Aspect = ASPECT_ONE; //todo
  2651. p->Skip(p,20); //SizeImage,XPelsPerMeter,YPelsPerMeter,ClrUsed,ClrImportant
  2653. if (PacketFormatExtra(&s->Format,Size-40))
  2654. {
  2655. p->Read(p,s->Format.Extra,s->Format.ExtraLength);
  2656. DefaultPalette(&s->Format);
  2657. }
  2659. PacketFormatDefault(&s->Format);
  2660. }
  2661. else
  2662. Size = 4;
  2664. Length -= Size;
  2665. }
  2666. p->Skip(p,Length);
  2667. }
  2669. int Format_WaveFormatMem(format_stream* s,void* Data,int Length)
  2670. {
  2671. if (Length >= 16)
  2672. {
  2673. char* p = (char*)Data;
  2675. PacketFormatClear(&s->Format);
  2676. s->Format.Type = PACKET_AUDIO;
  2677. s->Format.Format.Audio.Format = INT16LE(*(int16_t*)(p+0));
  2678. s->Format.Format.Audio.Channels =INT16LE(*(int16_t*)(p+2));
  2679. s->Format.Format.Audio.SampleRate = INT32LE(*(int32_t*)(p+4));
  2680. s->Format.ByteRate = INT32LE(*(int32_t*)(p+8));
  2681. s->Format.Format.Audio.BlockAlign = INT16LE(*(int16_t*)(p+12));
  2682. s->Format.Format.Audio.Bits = INT16LE(*(int16_t*)(p+14));
  2683. Length -= 16;
  2685. if (Length >= 2)
  2686. {
  2687. int Extra = INT16LE(*(int16_t*)(p+16));
  2688. Length -= 2;
  2689. if (Extra > 0 && Length >= Extra)
  2690. {
  2691. if (PacketFormatExtra(&s->Format,Extra))
  2692. memcpy(s->Format.Extra,p+18,s->Format.ExtraLength);
  2693. Length -= Extra;
  2694. }
  2695. }
  2697. PacketFormatDefault(&s->Format);
  2698. }
  2699. return Length;
  2700. }
  2702. void Format_WaveFormat(format_reader* p,format_stream* s,int Length)
  2703. {
  2704. if (Length >= 16)
  2705. {
  2706. PacketFormatClear(&s->Format);
  2707. s->Format.Type = PACKET_AUDIO;
  2708. s->Format.Format.Audio.Format = p->ReadLE16(p);
  2709. s->Format.Format.Audio.Channels = p->ReadLE16(p);
  2710. s->Format.Format.Audio.SampleRate = p->ReadLE32(p);
  2711. s->Format.ByteRate = p->ReadLE32(p);
  2712. s->Format.Format.Audio.BlockAlign = p->ReadLE16(p);
  2713. s->Format.Format.Audio.Bits = p->ReadLE16(p);
  2714. Length -= 16;
  2716. if (Length >= 2)
  2717. {
  2718. int Extra = p->ReadLE16(p);
  2719. Length -= 2;
  2720. if (Extra > 0 && Length >= Extra)
  2721. {
  2722. if (PacketFormatExtra(&s->Format,Extra))
  2723. p->Read(p,s->Format.Extra,s->Format.ExtraLength);
  2724. Length -= Extra;
  2725. }
  2726. }
  2728. PacketFormatDefault(&s->Format);
  2729. }
  2730. p->Skip(p,Length);
  2731. }
  2733. void Format_RemoveStream(format_base* p)
  2734. {
  2735. if (p->StreamCount)
  2736. {
  2737. format_stream* Stream = p->Streams[--p->StreamCount];
  2738. UpdateTotalCount(p);
  2739. if (p->FreeStream)
  2740. p->FreeStream(p,Stream);
  2741. Format_FreeStream(p,Stream);
  2742. }
  2743. }
  2745. format_stream* Format_AddStream(format_base* p, int Length)
  2746. {
  2747. format_stream* s;
  2749. if (p->StreamCount >= MAXSTREAM-1-1) //subtitle,coverart
  2750. return NULL;
  2752. s = (format_stream*) malloc(Length);
  2753. if (!s)
  2754. return NULL;
  2756. memset(s,0,Length);
  2757. s->Reader = p->Reader; // default
  2758. s->No = p->StreamCount;
  2759. s->LastTime = TIME_SYNC;
  2760. p->Streams[p->StreamCount++] = s;
  2761. UpdateTotalCount(p);
  2762. return s;
  2763. }
  2765. static int Create(format_base* p)
  2766. {
  2767. int No;
  2768. format_reader* Reader = p->Reader;
  2769. for (No=0;No<MAXREADER;++No,++Reader)
  2770. {
  2771. Reader->Format = p;
  2772. Reader->Seek = Reader_Seek;
  2773. Reader->Eof = Reader_Eof;
  2774. Reader->Skip = Reader_Skip;
  2775. Reader->Read = Reader_Read;
  2776. Reader->Read8 = Reader_Read8;
  2777. Reader->ReadLE16 = Reader_ReadLE16;
  2778. Reader->ReadBE16 = Reader_ReadBE16;
  2779. Reader->ReadLE32 = Reader_ReadLE32;
  2780. Reader->ReadBE32 = Reader_ReadBE32;
  2781. Reader->ReadLE64 = Reader_ReadLE64;
  2782. Reader->ReadBE64 = Reader_ReadBE64;
  2783. Reader->ReadAsRef = Reader_ReadAsRef;
  2784. Reader->GetReadBuffer = Reader_GetReadBuffer;
  2785. }
  2787. p->Format.Enum = (nodeenum)FormatBaseEnum;
  2788. p->Format.Get = (nodeget)FormatBaseGet;
  2789. p->Format.Set = (nodeset)FormatBaseSet;
  2791. p->Format.Sync = (fmtsync)Format_Sync;
  2792. p->Format.Read = (fmtread)Format_ReadInput;
  2793. p->Format.Process = (fmtprocess)Format_Process;
  2794. p->FillQueue = (fmtfill)Format_FillQueue;
  2795. p->Process = (fmtstreamprocess)Format_ProcessStream;
  2796. p->Sended = (fmtstream)Format_Sended;
  2797. p->FileAlign = 1;
  2798. p->Timing = 1;
  2799. p->MinHeaderLoad = BLOCKSIZE;
  2801. #ifdef TARGET_PALMOS
  2802. p->UseBufferBlock = Context()->LowMemory;
  2803. #endif
  2805. return ERR_NONE;
  2806. }
  2808. static const nodedef FormatBase =
  2809. {
  2810. sizeof(format_base)|CF_ABSTRACT,
  2811. FORMATBASE_CLASS,
  2812. FORMAT_CLASS,
  2813. PRI_DEFAULT,
  2814. (nodecreate)Create,
  2815. };
  2817. void FormatBase_Init()
  2818. {
  2819. NodeRegisterClass(&FormatBase);
  2820. }
  2822. void FormatBase_Done()
  2823. {
  2824. NodeUnRegisterClass(FORMATBASE_CLASS);
  2825. }