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

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

Windows CE

开发平台：

C/C++

ogg.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: ogg.c 543 2006-01-07 22:06:24Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../common/common.h"
  25. #include "vorbis.h"
  26. #include "tremor/ogg.h"
  27. #include "tremor/ivorbiscodec.h"
  29. // OGG and OGM file format
  31. #define PACKET_TYPE_HEADER 0x01
  32. #define PACKET_TYPE_COMMENT 0x03
  33. #define PACKET_TYPE_CODEBOOK 0x05
  34. #define PACKET_TYPE_BITS 0x07
  36. #define PACKET_IS_SYNCPOINT 0x08
  37. #define PACKET_LEN_BITS01 0xc0
  38. #define PACKET_LEN_BITS2 0x02
  40. static const char MT_Video[] = "video";
  41. static const char MT_Audio[] = "audio";
  42. static const char MT_Text[] = "text";
  44. typedef struct oggstream
  45. {
  46. format_stream Stream;
  48. bool_t Invalid; // not vorbis and not ogm
  49. bool_t Vorbis; // sending direct oggpackets (not the merged binary data)
  50. bool_t Native; // speex
  51. int PacketNo;
  53. int64_t MediaTime; // in units
  54. int64_t MediaRateNum; // in units/tick
  55. int64_t MediaRateDen;
  56. int DefaultLen;
  58. bool_t NeedMorePage;
  60. ogg_stream_state* OggStream;
  61. ogg_packet       OggPacket;
  63. vorbis_info      Info;
  64. vorbis_comment   Comment;
  66. } oggstream;
  68. typedef struct ogg
  69. {
  70. format_base Format;
  71. ogg_sync_state* OggSync;
  72. ogg_page        OggPage;
  74. } ogg;
  76. typedef struct ogm_header_video
  77. {
  78. int32_t width;
  79. int32_t height;
  81. } ogm_header_video;
  83. typedef struct ogm_header_audio
  84. {
  85. int16_t channels;
  86. int16_t blockalign;
  87. int32_t avgbytespersec;
  88. } ogm_header_audio;
  90. typedef struct ogm_header
  91. {
  92. char streamtype[8];
  93. char subtype[4];
  95. int32_t size;
  97. int64_t time_unit;
  98. int64_t samples_per_unit;
  99. int32_t default_len;
  101. int32_t buffersize;
  102. int16_t bits_per_sample;
  104. union
  105. {
  106. ogm_header_video video;
  107. ogm_header_audio audio;
  109. } format;
  111. } ogm_header;
  113. extern int _vorbis_unpack_comment(vorbis_comment *vc,oggpack_buffer *opb,int eop);
  115. static void FreeStream(ogg* p,oggstream* Stream)
  116. {
  117. vorbis_comment_clear(&Stream->Comment);
  118. vorbis_info_clear(&Stream->Info);
  120. ogg_packet_release(&Stream->OggPacket);
  121. if (Stream->OggStream)
  122. {
  123. ogg_stream_destroy(Stream->OggStream);
  124. Stream->OggStream = NULL;
  125. }
  126. }
  128. static void Done(ogg* p)
  129. {
  130. ogg_page_release(&p->OggPage);
  131. if (p->OggSync)
  132. {
  133. ogg_sync_destroy(p->OggSync);
  134. p->OggSync = NULL;
  135. }
  136. }
  138. static int AddBuffer(ogg* p,format_buffer* Buffer)
  139. {
  140. if (!Buffer)
  141. return ERR_NEED_MORE_DATA;
  143. if (Buffer->Length)
  144. {
  145. ogg_buffer* Ptr = ogg_sync_bufferinext(p->OggSync);
  146. if (!Ptr)
  147. {
  148. Format_BufferRelease(&p->Format,Buffer);
  149. return ERR_OUT_OF_MEMORY;
  150. }
  152. Ptr->ext = &p->Format;
  153. Ptr->extdata = Buffer;
  154. Ptr->data = Buffer->Block.Ptr;
  155. Ptr->size = Buffer->Length;
  156. ogg_sync_wrote(p->OggSync,Buffer->Length);
  157. }
  158. else
  159. Format_BufferRelease(&p->Format,Buffer);
  161. return ERR_NONE;
  162. }
  164. static int Init(ogg* p)
  165. {
  166. format_reader* Reader = p->Format.Reader;
  167. format_buffer* Buffer;
  168. int i;
  170. memset(&p->OggPage,0,sizeof(ogg_page));
  171. p->OggSync = ogg_sync_create();
  172. p->Format.TimeStamps = 1;
  173. if (!p->OggSync)
  174. return ERR_OUT_OF_MEMORY;
  176. Format_ReadBuffer(Reader,0);
  177. Buffer = Format_BufferRemove(Reader);
  178. if (!Buffer)
  179. return ERR_INVALID_DATA;
  181. // search for 'OggS' pattern
  182. for (i=3;i<Buffer->Length;++i)
  183. if (Buffer->Block.Ptr[i-3]=='O' &&
  184. Buffer->Block.Ptr[i-2]=='g' &&
  185. Buffer->Block.Ptr[i-1]=='g' &&
  186. Buffer->Block.Ptr[i-0]=='S')
  187. break;
  189. if (i==Buffer->Length)
  190. {
  191. Format_BufferRelease(&p->Format,Buffer);
  192. return ERR_INVALID_DATA;
  193. }
  195. return AddBuffer(p,Buffer);
  196. }
  198. static void AfterSeek(ogg* p)
  199. {
  200. ogg_sync_reset(p->OggSync);
  201. }
  203. static void ReleaseStream(ogg* p,oggstream* Stream)
  204. {
  205. ogg_stream_reset_serialno(Stream->OggStream,Stream->Stream.Id);
  206. Stream->NeedMorePage = 1;
  207. Stream->MediaTime = Stream->Stream.Reader->FilePos>0 && Stream->PacketNo>3 ? -1:0;
  208. }
  210. extern void oggext_release(void* ext,void* ext2)
  211. {
  212. if (ext && ext2)
  213. Format_BufferRelease((format_base*)ext,(format_buffer*)ext2);
  214. }
  216. static int ReadPacketTime( ogg* p, format_reader* Reader, format_packet* Packet )
  217. {
  218. // only called by CalcDuration
  220. format_buffer* Buffer;
  221. int Bytes;
  222. ogg_buffer* Ptr;
  223. ogg_sync_state* Sync = ogg_sync_create();
  224. ogg_page Page;
  226. if (!Sync)
  227. return ERR_OUT_OF_MEMORY;
  229. while ((Buffer = Format_BufferRemove(Reader))!=NULL)
  230. {
  231. Ptr = ogg_sync_bufferinext(Sync);
  232. if (Ptr)
  233. {
  234. Ptr->ext = &p->Format;
  235. Ptr->extdata = Buffer;
  236. Ptr->data = Buffer->Block.Ptr;
  237. Ptr->size = Buffer->Length;
  238. ogg_sync_wrote(Sync,Buffer->Length);
  239. }
  240. else
  241. Format_BufferRelease(&p->Format,Buffer);
  242. }
  244. memset(&Page,0,sizeof(Page));
  246. while ((Bytes = ogg_sync_pageseek(Sync,&Page)) != 0)
  247. {
  248. if (Bytes > 0)
  249. {
  250. int64_t MediaTime = ogg_page_granulepos(&Page);
  251. int Id = ogg_page_serialno(&Page);
  252. int i;
  254. if (MediaTime != -1)
  255. for (i=0;i<p->Format.StreamCount;++i)
  256. if (p->Format.Streams[i]->Id == Id)
  257. {
  258. oggstream* s = (oggstream*) p->Format.Streams[i];
  260. if (s->MediaRateNum)
  261. {
  262. tick_t RefTime = (tick_t)((MediaTime * s->MediaRateDen) / s->MediaRateNum);
  264. if (RefTime > Packet->RefTime)
  265. {
  266. Packet->Stream = &s->Stream;
  267. Packet->RefTime = RefTime;
  268. }
  269. }
  270. break;
  271. }
  272. }
  273. }
  275. ogg_page_release(&Page);
  276. ogg_sync_destroy(Sync);
  278. return ERR_NONE;
  279. }
  281. static void FrameRate( fraction* f, int64_t Num, int64_t Den )
  282. {
  283. while (Num > MAX_INT || Den > MAX_INT)
  284. {
  285. Num >>= 1;
  286. Den >>= 1;
  287. }
  288. f->Num = (int)Num;
  289. f->Den = (int)Den;
  290. }
  292. static bool_t SpeexHeader(ogg* p, oggstream* s, const char* Data, int Length )
  293. {
  294. if (Length<80 && strncmp(Data,"Speex   ",8)!=0)
  295. return 0;
  297. PacketFormatClear(&s->Stream.Format);
  298. s->Stream.Format.Type = PACKET_AUDIO;
  299. s->Stream.Format.Format.Audio.Format = AUDIOFMT_SPEEX;
  300. s->Stream.Format.Format.Audio.Channels = INT32LE(*(int32_t*)(Data+48));
  301. s->Stream.Format.ByteRate = INT32LE(*(int32_t*)(Data+52))/8;
  302. s->Stream.Format.Format.Audio.SampleRate = INT32LE(*(int32_t*)(Data+36));
  304. s->MediaRateDen = TICKSPERSEC;
  305. s->MediaRateNum = s->Stream.Format.Format.Audio.SampleRate;
  306. s->Native = 1;
  308. if (PacketFormatExtra(&s->Stream.Format,Length))
  309. memcpy(s->Stream.Format.Extra,Data,s->Stream.Format.ExtraLength);
  311. return 1;
  312. }
  314. static bool_t OGMHeader(ogg* p, oggstream* s, const char* Data, int Length )
  315. {
  316. int i;
  317. if (Length<40 || (*Data & PACKET_TYPE_BITS) != PACKET_TYPE_HEADER)
  318. return 0;
  320. if (strncmp(Data+1, "Direct Show Samples embedded in Ogg", 35) == 0)
  321. {
  322. // old header
  324. if (INT32LE(*(int32_t*)(Data+96)) == 0x05589F80)
  325. {
  326. PacketFormatClear(&s->Stream.Format);
  327. s->Stream.Format.Type = PACKET_VIDEO;
  328. s->Stream.Format.Format.Video.Width = INT32LE(*(int32_t*)(Data+176));
  329. s->Stream.Format.Format.Video.Height = INT32LE(*(int32_t*)(Data+180));
  330. s->Stream.Format.Format.Video.Pixel.FourCC = INT32LE(*(int32_t*)(Data+68));
  331. s->Stream.Format.Format.Video.Pixel.BitCount = INT16LE(*(int16_t*)(Data+182));
  333. i = INT16LE(*(int16_t*)(Data+136)); // extrasize
  334. if (i && PacketFormatExtra(&s->Stream.Format,i))
  335. memcpy(s->Stream.Format.Extra,Data+142,s->Stream.Format.ExtraLength);
  337. s->MediaRateDen = INT64LE(*(int32_t*)(Data+164))*TICKSPERSEC;
  338. s->MediaRateNum = 10000000;
  339. s->DefaultLen = 1;
  341. FrameRate(&s->Stream.Format.PacketRate,s->MediaRateNum,s->MediaRateDen/TICKSPERSEC);
  342. return 1;
  343. }
  345. if (INT32LE(*(int32_t*)(Data+96)) == 0x05589F81)
  346. {
  347. PacketFormatClear(&s->Stream.Format);
  348. s->Stream.Format.Type = PACKET_AUDIO;
  349. s->Stream.Format.Format.Audio.Format = INT16LE(*(int16_t*)(Data+124));
  350. s->Stream.Format.Format.Audio.Channels = INT16LE(*(int16_t*)(Data+126));
  351. s->Stream.Format.Format.Audio.BlockAlign = INT16LE(*(int16_t*)(Data+136));
  352. s->Stream.Format.Format.Audio.Bits = INT16LE(*(int16_t*)(Data+138));
  353. s->Stream.Format.Format.Audio.SampleRate = INT32LE(*(int32_t*)(Data+128));
  354. s->Stream.Format.ByteRate = INT32LE(*(int32_t*)(p+132));
  356. i = INT16LE(*(int16_t*)(Data+136)); // extrasize
  357. if (i && PacketFormatExtra(&s->Stream.Format,i))
  358. memcpy(s->Stream.Format.Extra,Data+142,s->Stream.Format.ExtraLength);
  360. s->MediaRateDen = TICKSPERSEC;
  361. s->MediaRateNum = INT32LE(*(int32_t*)(Data+128));
  362. s->DefaultLen = 1;
  363. return 1;
  364. }
  365. }
  366. else
  367. if (Length >= sizeof(ogm_header)+1)
  368. {
  369. ogm_header Head;
  370. memcpy(&Head,Data+1,sizeof(Head));
  372. // new header
  373. if (strncmp(Head.streamtype, MT_Video, strlen(MT_Video)) == 0)
  374. {
  375. PacketFormatClear(&s->Stream.Format);
  376. s->Stream.Format.Type = PACKET_VIDEO;
  377. s->Stream.Format.Format.Video.Width = INT32LE(Head.format.video.width);
  378. s->Stream.Format.Format.Video.Height = INT32LE(Head.format.video.height);
  379. s->Stream.Format.Format.Video.Pixel.FourCC = INT32LE(*(int32_t*)Head.subtype);
  380. s->Stream.Format.Format.Video.Pixel.BitCount = INT16LE(Head.bits_per_sample);
  382. s->MediaRateDen = INT64LE(Head.time_unit)*TICKSPERSEC;
  383. s->MediaRateNum = INT64LE(Head.samples_per_unit) * 10000000;
  384. s->DefaultLen = INT32LE(Head.default_len);
  386. FrameRate(&s->Stream.Format.PacketRate,s->MediaRateNum,s->MediaRateDen/TICKSPERSEC);
  387. i = Length - (sizeof(ogm_header)+1);
  388. if (i && PacketFormatExtra(&s->Stream.Format,i))
  389. memcpy(s->Stream.Format.Extra,Data+1+sizeof(ogm_header),s->Stream.Format.ExtraLength);
  390. return 1;
  391. }
  393. if (strncmp(Head.streamtype, MT_Audio, strlen(MT_Audio)) == 0)
  394. {
  395. PacketFormatClear(&s->Stream.Format);
  396. s->Stream.Format.Type = PACKET_AUDIO;
  397. s->Stream.Format.Format.Audio.Format = 0;
  398. for (i=0;i<4;++i)
  399. if (Head.subtype[i])
  400. s->Stream.Format.Format.Audio.Format = s->Stream.Format.Format.Audio.Format*16+Hex(Head.subtype[i]);
  401. s->Stream.Format.Format.Audio.Channels = INT16LE(Head.format.audio.channels);
  402. s->Stream.Format.Format.Audio.Bits = INT16LE(Head.bits_per_sample);
  403. s->Stream.Format.Format.Audio.BlockAlign = INT16LE(Head.format.audio.blockalign);
  404. s->Stream.Format.ByteRate = INT32LE(Head.format.audio.avgbytespersec);
  405. s->Stream.Format.Format.Audio.SampleRate = (int)INT64LE(Head.samples_per_unit);
  407. s->MediaRateDen = INT64LE(Head.time_unit)*TICKSPERSEC;
  408. s->MediaRateNum = INT64LE(Head.samples_per_unit) * 10000000;
  409. s->DefaultLen = INT32LE(Head.default_len);
  411. i = Length - (sizeof(ogm_header)+1);
  412. if (i && PacketFormatExtra(&s->Stream.Format,i))
  413. memcpy(s->Stream.Format.Extra,Data+1+sizeof(ogm_header),s->Stream.Format.ExtraLength);
  414. return 1;
  415. }
  417. if (strncmp(Data+1, MT_Text,  strlen(MT_Text)) == 0)
  418. {
  419. PacketFormatClear(&s->Stream.Format);
  420. s->Stream.Format.Type = PACKET_SUBTITLE;
  421. s->Stream.Format.Format.Subtitle.FourCC = SUBTITLE_OEM; //???
  423. s->MediaRateDen = INT64LE(Head.time_unit)*TICKSPERSEC;
  424. s->MediaRateNum = INT64LE(Head.samples_per_unit) * 10000000;
  425. s->DefaultLen = INT32LE(Head.default_len);
  427. i = Length - (sizeof(ogm_header)+1);
  428. if (i && PacketFormatExtra(&s->Stream.Format,i))
  429. memcpy(s->Stream.Format.Extra,Data+1+sizeof(ogm_header),s->Stream.Format.ExtraLength);
  430. return 1;
  431. }
  432. }
  434. return 0;
  435. }
  437. static void SendComments(oggstream* Stream)
  438. {
  439. tchar_t s[256];
  440. if (Stream->Stream.Comment.Node)
  441. {
  442. int No;
  443. for (No=0;No<Stream->Comment.comments;++No)
  444. {
  445. UTF8ToTcs(s,TSIZEOF(s),Stream->Comment.user_comments[No]);
  446. Stream->Stream.Comment.Node->Set(Stream->Stream.Comment.Node,Stream->Stream.Comment.No,s,sizeof(s));
  447. }
  448. }
  449. }
  451. static bool_t VorbisHeader(ogg* p,oggstream* s)
  452. {
  453. tchar_t URL[MAXPATH];
  455. if (vorbis_synthesis_headerin(&s->Info,&s->Comment,&s->OggPacket)<0)
  456. return 0;
  458. PacketFormatClear(&s->Stream.Format);
  459. s->Stream.Format.Type = PACKET_AUDIO;
  460. s->Stream.Format.Format.Audio.Channels = s->Info.channels;
  461. s->Stream.Format.Format.Audio.SampleRate = s->Info.rate;
  462. s->Stream.Format.ByteRate = s->Info.bitrate_nominal >> 3;
  464. if (p->Format.Reader->Input->Get(p->Format.Reader->Input,STREAM_URL,URL,sizeof(URL))==ERR_NONE &&
  465. CheckExts(URL,T("ogg:A")) != 0)
  466. s->Stream.Format.Format.Audio.Format = AUDIOFMT_VORBIS_INTERNAL_AUDIO;
  467. else
  468. s->Stream.Format.Format.Audio.Format = AUDIOFMT_VORBIS_INTERNAL_VIDEO;
  470. s->Vorbis = 1;
  471. s->MediaRateDen = TICKSPERSEC;
  472. s->MediaRateNum = s->Info.rate;
  473. return 1;
  474. }
  476. static int FillQueue(ogg* p,format_reader* Reader)
  477. {
  478. for (;;)
  479. {
  480. int Bytes = ogg_sync_pageseek(p->OggSync,&p->OggPage);
  482. if (Bytes == 0) // need more data
  483. {
  484. int Result;
  485. format_buffer* Buffer;
  487. if (!Reader->BufferAvailable && (!p->Format.SyncMode || p->Format.SyncRead<=0))
  488. return ERR_NEED_MORE_DATA;
  490. Buffer = Format_BufferRemove(Reader);
  491. if (!Buffer && p->Format.SyncMode && p->Format.SyncRead>0 && Format_ReadBuffer(Reader,0))
  492. Buffer = Format_BufferRemove(Reader);
  494. Result = AddBuffer(p,Buffer);
  495. if (Result != ERR_NONE)
  496. return Result;
  497. }
  498. else
  499. if (Bytes < 0)
  500. Reader->FilePos -= Bytes;
  501. else
  502. if (Bytes > 0)
  503. {
  504. int StreamNo;
  505. oggstream* s;
  506. int Id;
  508. Reader->FilePos += Bytes;
  510. Id = ogg_page_serialno(&p->OggPage);
  512. DEBUG_MSG4(DEBUG_FORMAT,T("OGG Page id:%d size:%d gran:%d filepos:%d"),Id,p->OggPage.body_len,(int)ogg_page_granulepos(&p->OggPage),Reader->FilePos - Bytes);
  514. for (StreamNo=0;StreamNo<p->Format.StreamCount;++StreamNo)
  515. if (p->Format.Streams[StreamNo]->Id == Id)
  516. break;
  518. if (StreamNo==p->Format.StreamCount)
  519. {
  520. // check for restarted audio http streaming (comments changed)
  521. if (p->Format.StreamCount==1 && 
  522. p->Format.Streams[0]->Format.Type == PACKET_AUDIO &&
  523. p->Format.Streams[0]->LastTime>0)
  524. {
  525. StreamNo = 0;
  526. s = (oggstream*) p->Format.Streams[0];
  527. if (s->Vorbis)
  528. {
  529. // vorbis decoder have to release s->Info
  530. s->Stream.Format.Extra = NULL;
  531. s->Stream.Format.ExtraLength = 0;
  532. ConnectionUpdate((node*)&p->Format,FORMAT_STREAM+0,s->Stream.Pin.Node,s->Stream.Pin.No);
  533. }
  534. FreeStream(p,s);
  535. }
  536. else
  537. {
  538. s = (oggstream*) Format_AddStream(&p->Format,sizeof(oggstream));
  539. if (!s) continue;
  540. }
  542. // init stream
  543. s->Stream.Id = Id;
  544. s->OggStream = ogg_stream_create(Id);
  545. s->NeedMorePage = 1;
  546. s->MediaTime = 0;
  547. s->Invalid = 0;
  548. s->Vorbis = 0;
  549. s->Native = 0;
  550. s->PacketNo = 0;
  552. vorbis_info_init(&s->Info);
  553. vorbis_comment_init(&s->Comment);
  554. }
  556. s = (oggstream*) p->Format.Streams[StreamNo];
  558. if (s->Invalid) // drop invalid streams
  559. continue;
  561. if (s->PacketNo>=3)
  562. {
  563. if (!s->Stream.Pin.Node) // drop unused streams
  564. continue;
  566. if (p->Format.InSeek)
  567. {
  568. // reftime needed for SeekByPacket
  569. if ((s->MediaTime = ogg_page_granulepos(&p->OggPage)) != -1)
  570. {
  571. // no need for GlobalOffset here
  572. s->Stream.LastTime = (tick_t)(s->MediaTime * s->MediaRateDen / s->MediaRateNum);
  573. if (s->Stream.Format.Type == PACKET_AUDIO)
  574. {
  575. s->Stream.LastTime += p->Format.AVOffset;
  576. if (s->Stream.LastTime < 0)
  577. s->Stream.LastTime = 0;
  578. }
  579. }
  580. }
  581. }
  583. // add page to stream
  584. if (ogg_stream_pagein(s->OggStream,&p->OggPage) >= 0)
  585. {
  586. if (s->PacketNo<3) // header packet needed?
  587. {
  588. int i = ogg_stream_packetout(s->OggStream,&s->OggPacket);
  589. if (i == 0) // stream needs more pages
  590. continue;
  592. if (++s->PacketNo==1) // first packet?
  593. {
  594. ogg_reference* Ref;
  595. const void* Data;
  596. int Length;
  598. if (i < 0)
  599. {
  600. // first header packet is a must have
  601. s->Invalid = 1;
  602. continue;
  603. }
  605. if (p->Format.UseBufferBlock)
  606. {
  607. for (Length=0,Ref=s->OggPacket.packet;Ref;Ref=Ref->next)
  608. Length += Ref->length;
  610. if (s->Stream.BufferBlockLength<Length && !Format_AllocBufferBlock(&p->Format,&s->Stream,Length))
  611. {
  612. Length = 0;
  613. Data = NULL;
  614. }
  615. else
  616. {
  617. for (Length=0,Ref=s->OggPacket.packet;Ref;Ref=Ref->next)
  618. {
  619. WriteBlock(&s->Stream.BufferBlock,Length,Ref->buffer->data + Ref->begin,Ref->length);
  620. Length += Ref->length;
  621. }
  622. Data = s->Stream.BufferBlock.Ptr;
  623. }
  624. }
  625. else
  626. {
  627. BufferDrop(&s->Stream.BufferMem);
  628. for (Ref=s->OggPacket.packet;Ref;Ref=Ref->next)
  629. BufferWrite(&s->Stream.BufferMem,Ref->buffer->data + Ref->begin, Ref->length, 16384);
  630. Data = s->Stream.BufferMem.Data;
  631. Length = s->Stream.BufferMem.WritePos;
  632. }
  634. if (OGMHeader(p,s,(char*)Data,Length) || SpeexHeader(p,s,(char*)Data,Length))
  635. {
  636. PacketFormatDefault(&s->Stream.Format);
  637. s->PacketNo = 3; // no more headers
  638. }
  639. else
  640. if (!VorbisHeader(p,s))
  641. {
  642. s->Invalid = 1;
  643. continue;
  644. }
  646. while (s->MediaRateNum > (1<<30))
  647. {
  648. s->MediaRateDen >>= 1;
  649. s->MediaRateNum >>= 1;
  650. }
  652. Format_PrepairStream(&p->Format,&s->Stream);
  653. continue;
  654. }
  655. else
  656. {
  657. assert(s->Vorbis);
  659. // error in second or third header packet will not cause fatal error
  660. vorbis_synthesis_headerin(&s->Info,&s->Comment,&s->OggPacket); 
  662. if (s->PacketNo == 3)
  663. {
  664. // got the three header packets: reinit codec with vorbis_info
  665. s->Stream.Format.Extra = &s->Info;
  666. s->Stream.Format.ExtraLength = -1;
  667. ConnectionUpdate((node*)&p->Format,FORMAT_STREAM+StreamNo,s->Stream.Pin.Node,s->Stream.Pin.No);
  668. SendComments(s);
  669. }
  670. continue;
  671. }
  672. }
  674. s->NeedMorePage = 0;
  675. break;
  676. }
  677. }
  678. }
  679. return ERR_NONE;
  680. }
  682. static int Process(ogg* p,oggstream* Stream)
  683. {
  684. int Result;
  685. int No;
  686. int Burst = 1;
  688. if (Stream->Invalid)
  689. return ERR_NONE;
  691. if (Stream->Stream.Pending)
  692. {
  693. Result = Format_Send(&p->Format,&Stream->Stream);
  695. if (Result == ERR_BUFFER_FULL || Result == ERR_SYNCED)
  696. return Result;
  697. }
  699. // process a limited number of packets at once (other streams need cpu time too)
  701. Result = ERR_NONE;
  702. Burst = Stream->Stream.PacketBurst;
  704. for (No=0;No<Burst;++No)
  705. {
  706. while (Stream->NeedMorePage)
  707. {
  708. Result = FillQueue(p,Stream->Stream.Reader);
  710. if (Result == ERR_NEED_MORE_DATA && Stream->Stream.Reader->NoMoreInput)
  711. Result = Format_CheckEof(&p->Format,&Stream->Stream);
  713. if (Result != ERR_NONE || (p->Format.Bench && Stream->NeedMorePage))
  714. return Result;
  715. }
  717. // sync: only SyncStream is processed
  718. if (p->Format.SyncMode && Stream != (oggstream*)p->Format.SyncStream)
  719. return ERR_NEED_MORE_DATA;
  721. Result = ogg_stream_packetout(Stream->OggStream,&Stream->OggPacket);
  722. if (Result == 0)
  723. {
  724. // stream needs more pages
  725. Stream->NeedMorePage = 1;
  726. if (p->Format.Bench) break; // benchmark mode: no additional pages are added in this loop
  727. --No;
  728. continue;
  729. }
  730. if (Result < 0) // packet hole or span
  731. continue;
  733. DEBUG_MSG3(DEBUG_FORMAT,T("OGG Packet id:%d size:%d gran:%d"),Stream->Stream.Id,Stream->OggPacket.bytes,(int)Stream->OggPacket.granulepos);
  735. if (!Stream->Vorbis && Stream->PacketNo==3)
  736. {
  737. // non vorbis: second packet can be a comment (after first header)
  738. ++Stream->PacketNo;
  740. if (Stream->Native)
  741. {
  742. oggpack_buffer opb;
  743.     oggpack_readinit(&opb,Stream->OggPacket.packet);
  744. if (_vorbis_unpack_comment(&Stream->Comment,&opb,0)>=0)
  745. SendComments(Stream);
  746. continue; // always assume comment packet
  747. }
  748. else
  749. {
  750. Stream->Info.rate=1;
  751. if (vorbis_synthesis_headerin(&Stream->Info,&Stream->Comment,&Stream->OggPacket) >= 0)
  752. {
  753. SendComments(Stream);
  754. continue;
  755. }
  756. }
  757. }
  759. // build output packet
  761. if (Stream->OggPacket.granulepos >= 0)
  762. Stream->MediaTime = Stream->OggPacket.granulepos;
  764. if (Stream->MediaTime >= 0)
  765. {
  766. tick_t t = (tick_t)((Stream->MediaTime * Stream->MediaRateDen) / Stream->MediaRateNum);
  767. t += p->Format.GlobalOffset;
  768. if (Stream->Stream.Format.Type == PACKET_AUDIO)
  769. {
  770. t += p->Format.AVOffset;
  771. if (t<0) t=0;
  772. }
  773. if (Stream->Stream.LastTime>t && t-p->Format.GlobalOffset<TICKSPERSEC)
  774. Format_TimeStampRestarted(&p->Format,&Stream->Stream,&t);
  775. Stream->Stream.LastTime = Stream->Stream.Packet.RefTime = t;
  776. }
  777. else
  778. {
  779. if (Stream->Stream.LastTime < 0)
  780. continue;
  781. Stream->Stream.Packet.RefTime = TIME_UNKNOWN;
  782. }
  784. if (!Stream->Vorbis)
  785. {
  786. ogg_reference* Ref;
  787. const uint8_t* Data;
  788. int Length;
  789. int Len;
  790. int PacketTime;
  792. // merge buffers
  794. if (p->Format.UseBufferBlock)
  795. {
  796. for (Length=0,Ref=Stream->OggPacket.packet;Ref;Ref=Ref->next)
  797. Length += Ref->length;
  799. if (Stream->Stream.BufferBlockLength<Length && !Format_AllocBufferBlock(&p->Format,&Stream->Stream,Length))
  800. {
  801. Length = 0;
  802. Data = NULL;
  803. }
  804. else
  805. {
  806. for (Length=0,Ref=Stream->OggPacket.packet;Ref;Ref=Ref->next)
  807. {
  808. WriteBlock(&Stream->Stream.BufferBlock,Length,Ref->buffer->data + Ref->begin,Ref->length);
  809. Length += Ref->length;
  810. }
  811. Data = Stream->Stream.BufferBlock.Ptr;
  812. }
  813. }
  814. else
  815. {
  816. BufferDrop(&Stream->Stream.BufferMem);
  817. for (Ref=Stream->OggPacket.packet;Ref;Ref=Ref->next)
  818. BufferWrite(&Stream->Stream.BufferMem,Ref->buffer->data + Ref->begin, Ref->length, 16384);
  819. Data = (const uint8_t*)Stream->Stream.BufferMem.Data;
  820. Length = Stream->Stream.BufferMem.WritePos;
  821. }
  823. if (Stream->Native)
  824. {
  825. Stream->Stream.Packet.Data[0] = Data;
  826. Stream->Stream.Packet.Length = Length;
  827. Stream->MediaTime = -1;
  828. }
  829. else
  830. {
  831. // process OGM information
  832. if (*Data & PACKET_TYPE_HEADER)
  833. continue; // not data packet
  835. Len = (*Data & PACKET_LEN_BITS01) >> 6;
  836. Len |= (*Data & PACKET_LEN_BITS2) << 1;
  838. Stream->Stream.Packet.Key = (*Data & PACKET_IS_SYNCPOINT) != 0;
  839. Stream->Stream.Packet.Data[0] = Data + 1 + Len;
  840. Stream->Stream.Packet.Length = Length - 1 - Len;
  842. if (!Len)
  843. PacketTime = Stream->DefaultLen;
  844. else
  845. for (PacketTime=0;Len;--Len)
  846. {
  847. PacketTime <<= 8;
  848. PacketTime |= Data[Len];
  849. }
  851. Stream->MediaTime += PacketTime;
  852. }
  853. }
  854. else
  855. {
  856. // send oggpacket directly 
  857. if (!Stream->OggPacket.packet)
  858. continue;
  860. Stream->Stream.Packet.Data[0] = &Stream->OggPacket;
  861. Stream->Stream.Packet.Length = sizeof(Stream->OggPacket);
  862. Stream->MediaTime = -1;
  863. }
  864. Stream->Stream.Pending = 1;
  866. Result = Format_Send(&p->Format,&Stream->Stream);
  868. if (Result == ERR_BUFFER_FULL || Result == ERR_SYNCED)
  869. break;
  871. if (Stream->Stream.State.DropLevel==2)
  872. Burst = Stream->Stream.PacketBurst*2; // try to catch up
  873. }
  875. // buffer full: there was possibly some processing so don't allow sleeping
  876. // need data: burst count exceeded, but it doesn't mean there is no data left in buffers
  877. if (Result == ERR_BUFFER_FULL || Result == ERR_NEED_MORE_DATA)
  878. Result = ERR_NONE;
  880. return Result;
  881. }
  883. static int Create(ogg* p)
  884. {
  885. p->Format.Init = (fmtfunc)Init;
  886. p->Format.Done = (fmtvoid)Done;
  887. p->Format.Seek = (fmtseek)Format_SeekByPacket;
  888. p->Format.FillQueue = (fmtfill)FillQueue;
  889. p->Format.ReadPacket = (fmtreadpacket)ReadPacketTime;
  890. p->Format.ReleaseStream = (fmtstream)ReleaseStream;
  891. p->Format.AfterSeek = (fmtvoid)AfterSeek;
  892. p->Format.FreeStream = (fmtstream)FreeStream;
  893. p->Format.Process = (fmtstreamprocess)Process;
  894. p->Format.DisableReader = 1;
  895. p->Format.Sended = NULL;
  896. return ERR_NONE;
  897. }
  899. static const nodedef OGG = 
  900. {
  901. sizeof(ogg),
  902. OGG_ID,
  903. FORMATBASE_CLASS,
  904. PRI_DEFAULT,
  905. (nodecreate)Create,
  906. };
  908. void OGG_Init()
  909. {
  910. NodeRegisterClass(&OGG);
  911. }
  913. void OGG_Done()
  914. {
  915. NodeUnRegisterClass(OGG_ID);
  916. }