backup
/
gps
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
gps/GPSResources/tcpmpVerOld/vorbislq/ogg.c

917 lines
24 KiB
C
Executable File
Raw Blame History

/*****************************************************************************
*
* This program is free software ; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* $Id: ogg.c 543 2006-01-07 22:06:24Z picard $
*
* The Core Pocket Media Player
* Copyright (c) 2004-2005 Gabor Kovacs
*
****************************************************************************/
#include "../common/common.h"
#include "vorbis.h"
#include "tremor/ogg.h"
#include "tremor/ivorbiscodec.h"
// OGG and OGM file format
#define PACKET_TYPE_HEADER 0x01
#define PACKET_TYPE_COMMENT 0x03
#define PACKET_TYPE_CODEBOOK 0x05
#define PACKET_TYPE_BITS 0x07
#define PACKET_IS_SYNCPOINT 0x08
#define PACKET_LEN_BITS01 0xc0
#define PACKET_LEN_BITS2 0x02
static const char MT_Video[] = "video";
static const char MT_Audio[] = "audio";
static const char MT_Text[] = "text";
typedef struct oggstream
{
format_stream Stream;
bool_t Invalid; // not vorbis and not ogm
bool_t Vorbis; // sending direct oggpackets (not the merged binary data)
bool_t Native; // speex
int PacketNo;
int64_t MediaTime; // in units
int64_t MediaRateNum; // in units/tick
int64_t MediaRateDen;
int DefaultLen;
bool_t NeedMorePage;
ogg_stream_state* OggStream;
ogg_packet OggPacket;
vorbis_info Info;
vorbis_comment Comment;
} oggstream;
typedef struct ogg
{
format_base Format;
ogg_sync_state* OggSync;
ogg_page OggPage;
} ogg;
typedef struct ogm_header_video
{
int32_t width;
int32_t height;
} ogm_header_video;
typedef struct ogm_header_audio
{
int16_t channels;
int16_t blockalign;
int32_t avgbytespersec;
} ogm_header_audio;
typedef struct ogm_header
{
char streamtype[8];
char subtype[4];
int32_t size;
int64_t time_unit;
int64_t samples_per_unit;
int32_t default_len;
int32_t buffersize;
int16_t bits_per_sample;
union
{
ogm_header_video video;
ogm_header_audio audio;
} format;
} ogm_header;
extern int _vorbis_unpack_comment(vorbis_comment *vc,oggpack_buffer *opb,int eop);
static void FreeStream(ogg* p,oggstream* Stream)
{
vorbis_comment_clear(&Stream->Comment);
vorbis_info_clear(&Stream->Info);
ogg_packet_release(&Stream->OggPacket);
if (Stream->OggStream)
{
ogg_stream_destroy(Stream->OggStream);
Stream->OggStream = NULL;
}
}
static void Done(ogg* p)
{
ogg_page_release(&p->OggPage);
if (p->OggSync)
{
ogg_sync_destroy(p->OggSync);
p->OggSync = NULL;
}
}
static int AddBuffer(ogg* p,format_buffer* Buffer)
{
if (!Buffer)
return ERR_NEED_MORE_DATA;
if (Buffer->Length)
{
ogg_buffer* Ptr = ogg_sync_bufferinext(p->OggSync);
if (!Ptr)
{
Format_BufferRelease(&p->Format,Buffer);
return ERR_OUT_OF_MEMORY;
}
Ptr->ext = &p->Format;
Ptr->extdata = Buffer;
Ptr->data = Buffer->Block.Ptr;
Ptr->size = Buffer->Length;
ogg_sync_wrote(p->OggSync,Buffer->Length);
}
else
Format_BufferRelease(&p->Format,Buffer);
return ERR_NONE;
}
static int Init(ogg* p)
{
format_reader* Reader = p->Format.Reader;
format_buffer* Buffer;
int i;
memset(&p->OggPage,0,sizeof(ogg_page));
p->OggSync = ogg_sync_create();
p->Format.TimeStamps = 1;
if (!p->OggSync)
return ERR_OUT_OF_MEMORY;
Format_ReadBuffer(Reader,0);
Buffer = Format_BufferRemove(Reader);
if (!Buffer)
return ERR_INVALID_DATA;
// search for 'OggS' pattern
for (i=3;i<Buffer->Length;++i)
if (Buffer->Block.Ptr[i-3]=='O' &&
Buffer->Block.Ptr[i-2]=='g' &&
Buffer->Block.Ptr[i-1]=='g' &&
Buffer->Block.Ptr[i-0]=='S')
break;
if (i==Buffer->Length)
{
Format_BufferRelease(&p->Format,Buffer);
return ERR_INVALID_DATA;
}
return AddBuffer(p,Buffer);
}
static void AfterSeek(ogg* p)
{
ogg_sync_reset(p->OggSync);
}
static void ReleaseStream(ogg* p,oggstream* Stream)
{
ogg_stream_reset_serialno(Stream->OggStream,Stream->Stream.Id);
Stream->NeedMorePage = 1;
Stream->MediaTime = Stream->Stream.Reader->FilePos>0 && Stream->PacketNo>3 ? -1:0;
}
extern void oggext_release(void* ext,void* ext2)
{
if (ext && ext2)
Format_BufferRelease((format_base*)ext,(format_buffer*)ext2);
}
static int ReadPacketTime( ogg* p, format_reader* Reader, format_packet* Packet )
{
// only called by CalcDuration
format_buffer* Buffer;
int Bytes;
ogg_buffer* Ptr;
ogg_sync_state* Sync = ogg_sync_create();
ogg_page Page;
if (!Sync)
return ERR_OUT_OF_MEMORY;
while ((Buffer = Format_BufferRemove(Reader))!=NULL)
{
Ptr = ogg_sync_bufferinext(Sync);
if (Ptr)
{
Ptr->ext = &p->Format;
Ptr->extdata = Buffer;
Ptr->data = Buffer->Block.Ptr;
Ptr->size = Buffer->Length;
ogg_sync_wrote(Sync,Buffer->Length);
}
else
Format_BufferRelease(&p->Format,Buffer);
}
memset(&Page,0,sizeof(Page));
while ((Bytes = ogg_sync_pageseek(Sync,&Page)) != 0)
{
if (Bytes > 0)
{
int64_t MediaTime = ogg_page_granulepos(&Page);
int Id = ogg_page_serialno(&Page);
int i;
if (MediaTime != -1)
for (i=0;i<p->Format.StreamCount;++i)
if (p->Format.Streams[i]->Id == Id)
{
oggstream* s = (oggstream*) p->Format.Streams[i];
if (s->MediaRateNum)
{
tick_t RefTime = (tick_t)((MediaTime * s->MediaRateDen) / s->MediaRateNum);
if (RefTime > Packet->RefTime)
{
Packet->Stream = &s->Stream;
Packet->RefTime = RefTime;
}
}
break;
}
}
}
ogg_page_release(&Page);
ogg_sync_destroy(Sync);
return ERR_NONE;
}
static void FrameRate( fraction* f, int64_t Num, int64_t Den )
{
while (Num > MAX_INT || Den > MAX_INT)
{
Num >>= 1;
Den >>= 1;
}
f->Num = (int)Num;
f->Den = (int)Den;
}
static bool_t SpeexHeader(ogg* p, oggstream* s, const char* Data, int Length )
{
if (Length<80 && strncmp(Data,"Speex ",8)!=0)
return 0;
PacketFormatClear(&s->Stream.Format);
s->Stream.Format.Type = PACKET_AUDIO;
s->Stream.Format.Format.Audio.Format = AUDIOFMT_SPEEX;
s->Stream.Format.Format.Audio.Channels = INT32LE(*(int32_t*)(Data+48));
s->Stream.Format.ByteRate = INT32LE(*(int32_t*)(Data+52))/8;
s->Stream.Format.Format.Audio.SampleRate = INT32LE(*(int32_t*)(Data+36));
s->MediaRateDen = TICKSPERSEC;
s->MediaRateNum = s->Stream.Format.Format.Audio.SampleRate;
s->Native = 1;
if (PacketFormatExtra(&s->Stream.Format,Length))
memcpy(s->Stream.Format.Extra,Data,s->Stream.Format.ExtraLength);
return 1;
}
static bool_t OGMHeader(ogg* p, oggstream* s, const char* Data, int Length )
{
int i;
if (Length<40 || (*Data & PACKET_TYPE_BITS) != PACKET_TYPE_HEADER)
return 0;
if (strncmp(Data+1, "Direct Show Samples embedded in Ogg", 35) == 0)
{
// old header
if (INT32LE(*(int32_t*)(Data+96)) == 0x05589F80)
{
PacketFormatClear(&s->Stream.Format);
s->Stream.Format.Type = PACKET_VIDEO;
s->Stream.Format.Format.Video.Width = INT32LE(*(int32_t*)(Data+176));
s->Stream.Format.Format.Video.Height = INT32LE(*(int32_t*)(Data+180));
s->Stream.Format.Format.Video.Pixel.FourCC = INT32LE(*(int32_t*)(Data+68));
s->Stream.Format.Format.Video.Pixel.BitCount = INT16LE(*(int16_t*)(Data+182));
i = INT16LE(*(int16_t*)(Data+136)); // extrasize
if (i && PacketFormatExtra(&s->Stream.Format,i))
memcpy(s->Stream.Format.Extra,Data+142,s->Stream.Format.ExtraLength);
s->MediaRateDen = INT64LE(*(int32_t*)(Data+164))*TICKSPERSEC;
s->MediaRateNum = 10000000;
s->DefaultLen = 1;
FrameRate(&s->Stream.Format.PacketRate,s->MediaRateNum,s->MediaRateDen/TICKSPERSEC);
return 1;
}
if (INT32LE(*(int32_t*)(Data+96)) == 0x05589F81)
{
PacketFormatClear(&s->Stream.Format);
s->Stream.Format.Type = PACKET_AUDIO;
s->Stream.Format.Format.Audio.Format = INT16LE(*(int16_t*)(Data+124));
s->Stream.Format.Format.Audio.Channels = INT16LE(*(int16_t*)(Data+126));
s->Stream.Format.Format.Audio.BlockAlign = INT16LE(*(int16_t*)(Data+136));
s->Stream.Format.Format.Audio.Bits = INT16LE(*(int16_t*)(Data+138));
s->Stream.Format.Format.Audio.SampleRate = INT32LE(*(int32_t*)(Data+128));
s->Stream.Format.ByteRate = INT32LE(*(int32_t*)(p+132));
i = INT16LE(*(int16_t*)(Data+136)); // extrasize
if (i && PacketFormatExtra(&s->Stream.Format,i))
memcpy(s->Stream.Format.Extra,Data+142,s->Stream.Format.ExtraLength);
s->MediaRateDen = TICKSPERSEC;
s->MediaRateNum = INT32LE(*(int32_t*)(Data+128));
s->DefaultLen = 1;
return 1;
}
}
else
if (Length >= sizeof(ogm_header)+1)
{
ogm_header Head;
memcpy(&Head,Data+1,sizeof(Head));
// new header
if (strncmp(Head.streamtype, MT_Video, strlen(MT_Video)) == 0)
{
PacketFormatClear(&s->Stream.Format);
s->Stream.Format.Type = PACKET_VIDEO;
s->Stream.Format.Format.Video.Width = INT32LE(Head.format.video.width);
s->Stream.Format.Format.Video.Height = INT32LE(Head.format.video.height);
s->Stream.Format.Format.Video.Pixel.FourCC = INT32LE(*(int32_t*)Head.subtype);
s->Stream.Format.Format.Video.Pixel.BitCount = INT16LE(Head.bits_per_sample);
s->MediaRateDen = INT64LE(Head.time_unit)*TICKSPERSEC;
s->MediaRateNum = INT64LE(Head.samples_per_unit) * 10000000;
s->DefaultLen = INT32LE(Head.default_len);
FrameRate(&s->Stream.Format.PacketRate,s->MediaRateNum,s->MediaRateDen/TICKSPERSEC);
i = Length - (sizeof(ogm_header)+1);
if (i && PacketFormatExtra(&s->Stream.Format,i))
memcpy(s->Stream.Format.Extra,Data+1+sizeof(ogm_header),s->Stream.Format.ExtraLength);
return 1;
}
if (strncmp(Head.streamtype, MT_Audio, strlen(MT_Audio)) == 0)
{
PacketFormatClear(&s->Stream.Format);
s->Stream.Format.Type = PACKET_AUDIO;
s->Stream.Format.Format.Audio.Format = 0;
for (i=0;i<4;++i)
if (Head.subtype[i])
s->Stream.Format.Format.Audio.Format = s->Stream.Format.Format.Audio.Format*16+Hex(Head.subtype[i]);
s->Stream.Format.Format.Audio.Channels = INT16LE(Head.format.audio.channels);
s->Stream.Format.Format.Audio.Bits = INT16LE(Head.bits_per_sample);
s->Stream.Format.Format.Audio.BlockAlign = INT16LE(Head.format.audio.blockalign);
s->Stream.Format.ByteRate = INT32LE(Head.format.audio.avgbytespersec);
s->Stream.Format.Format.Audio.SampleRate = (int)INT64LE(Head.samples_per_unit);
s->MediaRateDen = INT64LE(Head.time_unit)*TICKSPERSEC;
s->MediaRateNum = INT64LE(Head.samples_per_unit) * 10000000;
s->DefaultLen = INT32LE(Head.default_len);
i = Length - (sizeof(ogm_header)+1);
if (i && PacketFormatExtra(&s->Stream.Format,i))
memcpy(s->Stream.Format.Extra,Data+1+sizeof(ogm_header),s->Stream.Format.ExtraLength);
return 1;
}
if (strncmp(Data+1, MT_Text, strlen(MT_Text)) == 0)
{
PacketFormatClear(&s->Stream.Format);
s->Stream.Format.Type = PACKET_SUBTITLE;
s->Stream.Format.Format.Subtitle.FourCC = SUBTITLE_OEM; //???
s->MediaRateDen = INT64LE(Head.time_unit)*TICKSPERSEC;
s->MediaRateNum = INT64LE(Head.samples_per_unit) * 10000000;
s->DefaultLen = INT32LE(Head.default_len);
i = Length - (sizeof(ogm_header)+1);
if (i && PacketFormatExtra(&s->Stream.Format,i))
memcpy(s->Stream.Format.Extra,Data+1+sizeof(ogm_header),s->Stream.Format.ExtraLength);
return 1;
}
}
return 0;
}
static void SendComments(oggstream* Stream)
{
tchar_t s[256];
if (Stream->Stream.Comment.Node)
{
int No;
for (No=0;No<Stream->Comment.comments;++No)
{
UTF8ToTcs(s,TSIZEOF(s),Stream->Comment.user_comments[No]);
Stream->Stream.Comment.Node->Set(Stream->Stream.Comment.Node,Stream->Stream.Comment.No,s,sizeof(s));
}
}
}
static bool_t VorbisHeader(ogg* p,oggstream* s)
{
tchar_t URL[MAXPATH];
if (vorbis_synthesis_headerin(&s->Info,&s->Comment,&s->OggPacket)<0)
return 0;
PacketFormatClear(&s->Stream.Format);
s->Stream.Format.Type = PACKET_AUDIO;
s->Stream.Format.Format.Audio.Channels = s->Info.channels;
s->Stream.Format.Format.Audio.SampleRate = s->Info.rate;
s->Stream.Format.ByteRate = s->Info.bitrate_nominal >> 3;
if (p->Format.Reader->Input->Get(p->Format.Reader->Input,STREAM_URL,URL,sizeof(URL))==ERR_NONE &&
CheckExts(URL,T("ogg:A")) != 0)
s->Stream.Format.Format.Audio.Format = AUDIOFMT_VORBIS_INTERNAL_AUDIO;
else
s->Stream.Format.Format.Audio.Format = AUDIOFMT_VORBIS_INTERNAL_VIDEO;
s->Vorbis = 1;
s->MediaRateDen = TICKSPERSEC;
s->MediaRateNum = s->Info.rate;
return 1;
}
static int FillQueue(ogg* p,format_reader* Reader)
{
for (;;)
{
int Bytes = ogg_sync_pageseek(p->OggSync,&p->OggPage);
if (Bytes == 0) // need more data
{
int Result;
format_buffer* Buffer;
if (!Reader->BufferAvailable && (!p->Format.SyncMode || p->Format.SyncRead<=0))
return ERR_NEED_MORE_DATA;
Buffer = Format_BufferRemove(Reader);
if (!Buffer && p->Format.SyncMode && p->Format.SyncRead>0 && Format_ReadBuffer(Reader,0))
Buffer = Format_BufferRemove(Reader);
Result = AddBuffer(p,Buffer);
if (Result != ERR_NONE)
return Result;
}
else
if (Bytes < 0)
Reader->FilePos -= Bytes;
else
if (Bytes > 0)
{
int StreamNo;
oggstream* s;
int Id;
Reader->FilePos += Bytes;
Id = ogg_page_serialno(&p->OggPage);
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);
for (StreamNo=0;StreamNo<p->Format.StreamCount;++StreamNo)
if (p->Format.Streams[StreamNo]->Id == Id)
break;
if (StreamNo==p->Format.StreamCount)
{
// check for restarted audio http streaming (comments changed)
if (p->Format.StreamCount==1 &&
p->Format.Streams[0]->Format.Type == PACKET_AUDIO &&
p->Format.Streams[0]->LastTime>0)
{
StreamNo = 0;
s = (oggstream*) p->Format.Streams[0];
if (s->Vorbis)
{
// vorbis decoder have to release s->Info
s->Stream.Format.Extra = NULL;
s->Stream.Format.ExtraLength = 0;
ConnectionUpdate((node*)&p->Format,FORMAT_STREAM+0,s->Stream.Pin.Node,s->Stream.Pin.No);
}
FreeStream(p,s);
}
else
{
s = (oggstream*) Format_AddStream(&p->Format,sizeof(oggstream));
if (!s) continue;
}
// init stream
s->Stream.Id = Id;
s->OggStream = ogg_stream_create(Id);
s->NeedMorePage = 1;
s->MediaTime = 0;
s->Invalid = 0;
s->Vorbis = 0;
s->Native = 0;
s->PacketNo = 0;
vorbis_info_init(&s->Info);
vorbis_comment_init(&s->Comment);
}
s = (oggstream*) p->Format.Streams[StreamNo];
if (s->Invalid) // drop invalid streams
continue;
if (s->PacketNo>=3)
{
if (!s->Stream.Pin.Node) // drop unused streams
continue;
if (p->Format.InSeek)
{
// reftime needed for SeekByPacket
if ((s->MediaTime = ogg_page_granulepos(&p->OggPage)) != -1)
{
// no need for GlobalOffset here
s->Stream.LastTime = (tick_t)(s->MediaTime * s->MediaRateDen / s->MediaRateNum);
if (s->Stream.Format.Type == PACKET_AUDIO)
{
s->Stream.LastTime += p->Format.AVOffset;
if (s->Stream.LastTime < 0)
s->Stream.LastTime = 0;
}
}
}
}
// add page to stream
if (ogg_stream_pagein(s->OggStream,&p->OggPage) >= 0)
{
if (s->PacketNo<3) // header packet needed?
{
int i = ogg_stream_packetout(s->OggStream,&s->OggPacket);
if (i == 0) // stream needs more pages
continue;
if (++s->PacketNo==1) // first packet?
{
ogg_reference* Ref;
const void* Data;
int Length;
if (i < 0)
{
// first header packet is a must have
s->Invalid = 1;
continue;
}
if (p->Format.UseBufferBlock)
{
for (Length=0,Ref=s->OggPacket.packet;Ref;Ref=Ref->next)
Length += Ref->length;
if (s->Stream.BufferBlockLength<Length && !Format_AllocBufferBlock(&p->Format,&s->Stream,Length))
{
Length = 0;
Data = NULL;
}
else
{
for (Length=0,Ref=s->OggPacket.packet;Ref;Ref=Ref->next)
{
WriteBlock(&s->Stream.BufferBlock,Length,Ref->buffer->data + Ref->begin,Ref->length);
Length += Ref->length;
}
Data = s->Stream.BufferBlock.Ptr;
}
}
else
{
BufferDrop(&s->Stream.BufferMem);
for (Ref=s->OggPacket.packet;Ref;Ref=Ref->next)
BufferWrite(&s->Stream.BufferMem,Ref->buffer->data + Ref->begin, Ref->length, 16384);
Data = s->Stream.BufferMem.Data;
Length = s->Stream.BufferMem.WritePos;
}
if (OGMHeader(p,s,(char*)Data,Length) || SpeexHeader(p,s,(char*)Data,Length))
{
PacketFormatDefault(&s->Stream.Format);
s->PacketNo = 3; // no more headers
}
else
if (!VorbisHeader(p,s))
{
s->Invalid = 1;
continue;
}
while (s->MediaRateNum > (1<<30))
{
s->MediaRateDen >>= 1;
s->MediaRateNum >>= 1;
}
Format_PrepairStream(&p->Format,&s->Stream);
continue;
}
else
{
assert(s->Vorbis);
// error in second or third header packet will not cause fatal error
vorbis_synthesis_headerin(&s->Info,&s->Comment,&s->OggPacket);
if (s->PacketNo == 3)
{
// got the three header packets: reinit codec with vorbis_info
s->Stream.Format.Extra = &s->Info;
s->Stream.Format.ExtraLength = -1;
ConnectionUpdate((node*)&p->Format,FORMAT_STREAM+StreamNo,s->Stream.Pin.Node,s->Stream.Pin.No);
SendComments(s);
}
continue;
}
}
s->NeedMorePage = 0;
break;
}
}
}
return ERR_NONE;
}
static int Process(ogg* p,oggstream* Stream)
{
int Result;
int No;
int Burst = 1;
if (Stream->Invalid)
return ERR_NONE;
if (Stream->Stream.Pending)
{
Result = Format_Send(&p->Format,&Stream->Stream);
if (Result == ERR_BUFFER_FULL || Result == ERR_SYNCED)
return Result;
}
// process a limited number of packets at once (other streams need cpu time too)
Result = ERR_NONE;
Burst = Stream->Stream.PacketBurst;
for (No=0;No<Burst;++No)
{
while (Stream->NeedMorePage)
{
Result = FillQueue(p,Stream->Stream.Reader);
if (Result == ERR_NEED_MORE_DATA && Stream->Stream.Reader->NoMoreInput)
Result = Format_CheckEof(&p->Format,&Stream->Stream);
if (Result != ERR_NONE || (p->Format.Bench && Stream->NeedMorePage))
return Result;
}
// sync: only SyncStream is processed
if (p->Format.SyncMode && Stream != (oggstream*)p->Format.SyncStream)
return ERR_NEED_MORE_DATA;
Result = ogg_stream_packetout(Stream->OggStream,&Stream->OggPacket);
if (Result == 0)
{
// stream needs more pages
Stream->NeedMorePage = 1;
if (p->Format.Bench) break; // benchmark mode: no additional pages are added in this loop
--No;
continue;
}
if (Result < 0) // packet hole or span
continue;
DEBUG_MSG3(DEBUG_FORMAT,T("OGG Packet id:%d size:%d gran:%d"),Stream->Stream.Id,Stream->OggPacket.bytes,(int)Stream->OggPacket.granulepos);
if (!Stream->Vorbis && Stream->PacketNo==3)
{
// non vorbis: second packet can be a comment (after first header)
++Stream->PacketNo;
if (Stream->Native)
{
oggpack_buffer opb;
oggpack_readinit(&opb,Stream->OggPacket.packet);
if (_vorbis_unpack_comment(&Stream->Comment,&opb,0)>=0)
SendComments(Stream);
continue; // always assume comment packet
}
else
{
Stream->Info.rate=1;
if (vorbis_synthesis_headerin(&Stream->Info,&Stream->Comment,&Stream->OggPacket) >= 0)
{
SendComments(Stream);
continue;
}
}
}
// build output packet
if (Stream->OggPacket.granulepos >= 0)
Stream->MediaTime = Stream->OggPacket.granulepos;
if (Stream->MediaTime >= 0)
{
tick_t t = (tick_t)((Stream->MediaTime * Stream->MediaRateDen) / Stream->MediaRateNum);
t += p->Format.GlobalOffset;
if (Stream->Stream.Format.Type == PACKET_AUDIO)
{
t += p->Format.AVOffset;
if (t<0) t=0;
}
if (Stream->Stream.LastTime>t && t-p->Format.GlobalOffset<TICKSPERSEC)
Format_TimeStampRestarted(&p->Format,&Stream->Stream,&t);
Stream->Stream.LastTime = Stream->Stream.Packet.RefTime = t;
}
else
{
if (Stream->Stream.LastTime < 0)
continue;
Stream->Stream.Packet.RefTime = TIME_UNKNOWN;
}
if (!Stream->Vorbis)
{
ogg_reference* Ref;
const uint8_t* Data;
int Length;
int Len;
int PacketTime;
// merge buffers
if (p->Format.UseBufferBlock)
{
for (Length=0,Ref=Stream->OggPacket.packet;Ref;Ref=Ref->next)
Length += Ref->length;
if (Stream->Stream.BufferBlockLength<Length && !Format_AllocBufferBlock(&p->Format,&Stream->Stream,Length))
{
Length = 0;
Data = NULL;
}
else
{
for (Length=0,Ref=Stream->OggPacket.packet;Ref;Ref=Ref->next)
{
WriteBlock(&Stream->Stream.BufferBlock,Length,Ref->buffer->data + Ref->begin,Ref->length);
Length += Ref->length;
}
Data = Stream->Stream.BufferBlock.Ptr;
}
}
else
{
BufferDrop(&Stream->Stream.BufferMem);
for (Ref=Stream->OggPacket.packet;Ref;Ref=Ref->next)
BufferWrite(&Stream->Stream.BufferMem,Ref->buffer->data + Ref->begin, Ref->length, 16384);
Data = (const uint8_t*)Stream->Stream.BufferMem.Data;
Length = Stream->Stream.BufferMem.WritePos;
}
if (Stream->Native)
{
Stream->Stream.Packet.Data[0] = Data;
Stream->Stream.Packet.Length = Length;
Stream->MediaTime = -1;
}
else
{
// process OGM information
if (*Data & PACKET_TYPE_HEADER)
continue; // not data packet
Len = (*Data & PACKET_LEN_BITS01) >> 6;
Len |= (*Data & PACKET_LEN_BITS2) << 1;
Stream->Stream.Packet.Key = (*Data & PACKET_IS_SYNCPOINT) != 0;
Stream->Stream.Packet.Data[0] = Data + 1 + Len;
Stream->Stream.Packet.Length = Length - 1 - Len;
if (!Len)
PacketTime = Stream->DefaultLen;
else
for (PacketTime=0;Len;--Len)
{
PacketTime <<= 8;
PacketTime |= Data[Len];
}
Stream->MediaTime += PacketTime;
}
}
else
{
// send oggpacket directly
if (!Stream->OggPacket.packet)
continue;
Stream->Stream.Packet.Data[0] = &Stream->OggPacket;
Stream->Stream.Packet.Length = sizeof(Stream->OggPacket);
Stream->MediaTime = -1;
}
Stream->Stream.Pending = 1;
Result = Format_Send(&p->Format,&Stream->Stream);
if (Result == ERR_BUFFER_FULL || Result == ERR_SYNCED)
break;
if (Stream->Stream.State.DropLevel==2)
Burst = Stream->Stream.PacketBurst*2; // try to catch up
}
// buffer full: there was possibly some processing so don't allow sleeping
// need data: burst count exceeded, but it doesn't mean there is no data left in buffers
if (Result == ERR_BUFFER_FULL || Result == ERR_NEED_MORE_DATA)
Result = ERR_NONE;
return Result;
}
static int Create(ogg* p)
{
p->Format.Init = (fmtfunc)Init;
p->Format.Done = (fmtvoid)Done;
p->Format.Seek = (fmtseek)Format_SeekByPacket;
p->Format.FillQueue = (fmtfill)FillQueue;
p->Format.ReadPacket = (fmtreadpacket)ReadPacketTime;
p->Format.ReleaseStream = (fmtstream)ReleaseStream;
p->Format.AfterSeek = (fmtvoid)AfterSeek;
p->Format.FreeStream = (fmtstream)FreeStream;
p->Format.Process = (fmtstreamprocess)Process;
p->Format.DisableReader = 1;
p->Format.Sended = NULL;
return ERR_NONE;
}
static const nodedef OGG =
{
sizeof(ogg),
OGG_ID,
FORMATBASE_CLASS,
PRI_DEFAULT,
(nodecreate)Create,
};
void OGG_Init()
{
NodeRegisterClass(&OGG);
}
void OGG_Done()
{
NodeUnRegisterClass(OGG_ID);
}
Reference in New Issue View Git Blame Copy Permalink