backup
/
gps
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
gps/GPSResources/tcpmp/common/format_base.c

2826 lines
66 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: format_base.c 611 2006-01-25 22:01:51Z picard $
*
* The Core Pocket Media Player
* Copyright (c) 2004-2005 Gabor Kovacs
*
****************************************************************************/
#include "common.h"
#define DROP_SHOW 8
#define ENDCHUNKS (128*1024/BLOCKSIZE)
#define SKIPDISTANCE 64*1024
#define SYNCREAD 6
#define SEEKTRIES 4
#define SEEKMAXREAD 256*1024
#define PROCESSMINAUDIO BLOCKSIZE
#define PROCESSMINVIDEO 128*1024
#define READER_BONUS 256*1024
int FormatBaseEnum(format_base* p,int* No,datadef* Param)
{
if (FormatEnum(p,No,Param) == ERR_NONE)
return ERR_NONE;
if (*No < p->TotalCount)
{
memset(Param,0,sizeof(datadef));
Param->Class = FORMAT_CLASS;
Param->Size = sizeof(pin);
Param->No = FORMAT_STREAM + *No;
Param->Type = TYPE_PACKET;
Param->Flags = DF_OUTPUT;
*No = 0;
return ERR_NONE;
}
*No -= p->TotalCount;
if (*No < p->TotalCount)
{
memset(Param,0,sizeof(datadef));
Param->Class = FORMAT_CLASS;
Param->Size = sizeof(pin);
Param->No = FORMAT_COMMENT + *No;
Param->Type = TYPE_COMMENT;
Param->Flags = DF_OUTPUT;
*No = 0;
return ERR_NONE;
}
*No -= p->TotalCount;
return ERR_INVALID_PARAM;
}
static INLINE void Format_BufferInsert(format_reader* p,format_buffer* Buffer)
{
Buffer->Next = NULL;
if (p->BufferLast)
p->BufferLast->Next = Buffer;
else
p->BufferFirst = Buffer;
p->BufferLast = Buffer;
p->BufferAvailable += Buffer->Length;
}
format_buffer* Format_BufferAlloc(format_base*,int Mode); //0:optional 1:drop 2:new alloc
format_packet* Format_PacketAlloc(format_base*);
void Format_PacketRelease(format_base*, format_packet*);
bool_t Format_ReadBuffer(format_reader*, bool_t ToRead);
int Format_Seek(format_base* p,filepos_t Pos,int Origin)
{
int Result = p->Reader->Seek(p->Reader,Pos,Origin);
if (Result == ERR_NONE)
Format_AfterSeek(p);
return Result;
}
int Format_SeekForce(format_base* p,filepos_t Pos,int Origin)
{
int Result;
filepos_t Save = p->Reader[0].FilePos;
p->Reader[0].FilePos = -1;
Result = Format_Seek(p,Pos,Origin);
if (Result != ERR_NONE)
p->Reader[0].FilePos = Save;
return Result;
}
int Format_SeekByPacket(format_base* p,tick_t Time,filepos_t FilePos,bool_t PrevKey)
{
int Try;
int LastTime;
int LastPos;
format_stream* Stream = NULL;
if (FilePos < 0)
{
Time -= SHOWAHEAD; // we should go a little earlier
if (Time > 0)
{
if (p->FileSize<0 || p->Duration<0)
return ERR_NOT_SUPPORTED;
FilePos = Scale(p->FileSize,Time,p->Duration);
}
else
FilePos = 0;
}
if (Time>0)
Stream = Format_DefSyncStream(p,p->Reader);
p->GlobalOffset = 0;
p->InSeek = 1;
LastPos = -1;
LastTime = -1;
for (Try=0;Try<SEEKTRIES;++Try) // maximum iterations
{
if (FilePos < p->SeekByPacket_DataStart)
FilePos = p->SeekByPacket_DataStart;
if (p->SeekByPacket_BlockAlign > 1)
FilePos -= (FilePos - p->SeekByPacket_DataStart) % p->SeekByPacket_BlockAlign;
if (Format_Seek(p,FilePos,SEEK_SET) != ERR_NONE)
{
p->InSeek = 0;
return ERR_NOT_SUPPORTED;
}
if (Stream)
{
// check if really seeked to the right time (and adjust if needed)
format_reader* Reader = p->Reader;
int SeekRead = FilePos + SEEKMAXREAD;
while (Reader->FilePos<SeekRead)
{
Format_ReadBuffer(Reader,0); // simulate input thread
if (p->FillQueue(p,Reader) == ERR_END_OF_FILE)
break;
if (Stream->LastTime >= 0)
{
DEBUG_MSG3(DEBUG_FORMAT,T("SeekByPacket to:%d current:%d filepos:%d"),Time,Stream->LastTime,FilePos);
if (!p->TimeStamps)
{
// adjust GlobalOffset
p->GlobalOffset = Time - Stream->LastTime;
if (p->GlobalOffset>0)
{
// need to adjust all stream packets
int No;
for (No=0;No<p->StreamCount;++No)
{
format_packet* i;
format_stream* s = p->Streams[No];
if (s->LastTime >= 0)
s->LastTime += p->GlobalOffset;
for (i=s->PacketFirst;i;i=i->Next)
if (i->RefTime >= 0)
i->RefTime += p->GlobalOffset;
}
}
else
p->GlobalOffset=0; // can't be negative
SeekRead = -1; // accept
break;
}
if (Time>=Stream->LastTime && (Time-Stream->LastTime) <= (TICKSPERSEC/2))
FilePos = -1; // accept
else
{
int Move;
if (LastPos >= 0)
Move = Scale(FilePos-LastPos,Time-Stream->LastTime,Stream->LastTime-LastTime);
else
Move = Scale(p->FileSize,Time-Stream->LastTime,p->Duration);
if (Move < 0)
Move = (Move*9)/8;
else
Move = (Move*15)/16;
if (Move > 64*1024 || Move < -64*1024)
{
LastTime = Stream->LastTime;
LastPos = FilePos;
}
else
LastPos = -1;
FilePos += Move;
}
if (FilePos < 0 || FilePos >= p->FileSize)
SeekRead = -1; // accept
break;
}
if (!Reader->BufferAvailable && !Reader->ReadBuffer && Reader->NoMoreInput)
break; // end of file
}
if (Reader->FilePos<SeekRead)
continue; // try again
}
break;
}
p->InSeek = 0;
return ERR_NONE;
}
format_buffer* Format_BufferRemoveLast(format_reader* Reader)
{
format_buffer *Buffer,*Tail;
LockEnter(Reader->Format->BufferLock);
Buffer = Reader->BufferLast;
if (Buffer)
{
Tail = Reader->BufferFirst;
if (Tail == Buffer)
Reader->BufferFirst = Tail = NULL;
else
{
while (Tail && Tail->Next != Buffer)
Tail = Tail->Next;
if (Tail)
Tail->Next = NULL;
}
Reader->BufferLast = Tail;
Reader->BufferAvailable -= Buffer->Length;
assert(Reader->BufferAvailable >= 0);
}
LockLeave(Reader->Format->BufferLock);
return Buffer;
}
int Format_Hibernate(format_base* p, int Mode)
{
bool_t Changed = 0;
if (p->InputLock)
{
int No;
format_buffer *Buffer;
LockEnter(p->InputLock);
LockEnter(p->BufferLock);
#ifndef TARGET_PALMOS
if (Mode == HIBERNATE_HARD)
{
format_reader *Reader = p->Reader;
filepos_t Seek = 0;
if (Reader->InputBuffer)
Seek += Reader->InputBuffer->Length;
for (Buffer = Reader->BufferFirst;Buffer;Buffer = Buffer->Next)
Seek += Buffer->Length;
if (Seek && Reader->Input && Reader->Input->Seek(Reader->Input,-Seek,SEEK_CUR)>=0)
{
Reader->NoMoreInput = 0;
if (Reader->InputBuffer)
{
Format_BufferRelease(p,Reader->InputBuffer);
Reader->InputBuffer = NULL;
}
while ((Buffer = Format_BufferRemoveLast(Reader)) != NULL)
Format_BufferRelease(p,Buffer);
}
}
#endif
while (p->FreeBuffers)
{
Buffer = p->FreeBuffers;
p->FreeBuffers = Buffer->Next;
FreeBlock(&Buffer->Block);
free(Buffer);
Changed = 1;
}
if (!Changed)
for (No=0;No<MAXREADER;++No)
for (Buffer = p->Reader[No].BufferFirst;Buffer;Buffer = Buffer->Next)
if (SetHeapBlock(BLOCKSIZE,&Buffer->Block,HEAP_STORAGE))
Changed = 1;
LockLeave(p->BufferLock);
LockLeave(p->InputLock);
}
return Changed ? ERR_NONE : ERR_OUT_OF_MEMORY;
}
static bool_t DropBuffer(format_base* p)
{
bool_t Dropped = 0;
int No=0;
for (No=0;No<p->StreamCount;++No)
{
format_stream* Stream = p->Streams[No];
if (Stream->PacketFirst)
{
format_packet* Packet = Stream->PacketFirst;
Stream->PacketFirst = Packet->Next;
if (Stream->PacketLast == Packet)
Stream->PacketLast = NULL;
Format_PacketRelease(p,Packet);
Stream->Pending = 0;
Stream->State.DropLevel = 2;
Stream->DropCount = DROP_SHOW;
Dropped = 1;
}
}
return Dropped;
}
format_buffer* Format_BufferAlloc(format_base* p,int Mode)
{
format_buffer* Buffer;
retry:
Buffer = p->FreeBuffers;
if (!Buffer)
{
if (p->BufferUsed < p->BufferSize || Mode==2)
{
block Block;
if (AllocBlock(BLOCKSIZE,&Block,Mode!=2,HEAP_ANY))
{
Buffer = (format_buffer*) malloc(sizeof(format_buffer));
if (Buffer)
Buffer->Block = Block;
else
FreeBlock(&Block);
}
}
else
if (Mode==0)
return NULL;
if (!Buffer)
{
if (Mode==1 && DropBuffer(p))
goto retry;
return NULL;
}
}
else
{
assert(Buffer->RefCount==0);
p->FreeBuffers = Buffer->Next;
}
Buffer->Length = 0;
Buffer->Id = p->BufferId++;
Buffer->RefCount = 1;
Buffer->Next = NULL;
++p->BufferUsed;
return Buffer;
}
static int SumByteRate(format_base* p)
{
// try to sum stream byterates
int No;
int ByteRate = 0;
for (No=0;No<p->StreamCount;++No)
{
packetformat Format;
p->Format.Get(p,(FORMAT_STREAM|PIN_FORMAT)+No,&Format,sizeof(Format));
if (Format.ByteRate<=0)
{
if (p->Streams[No]->Pin.Node && p->ProcessTime == TIME_SYNC)
{
p->ProcessTime = 0;
p->Process(p,p->Streams[No]); // try processing
p->ProcessTime = TIME_SYNC;
}
p->Format.Get(p,(FORMAT_STREAM|PIN_FORMAT)+No,&Format,sizeof(Format));
if (Format.ByteRate<=0)
return p->SumByteRate; // failed
}
ByteRate += Format.ByteRate;
}
return ByteRate;
}
static bool_t IsVideo(format_base* p)
{
int No;
for (No=0;No<p->StreamCount;++No)
if (p->Streams[No]->Format.Type == PACKET_VIDEO)
return 1;
return 0;
}
static void FindCoverArt(format_base* p);
static void CalcDuration(format_base* p)
{
if (p->Duration<0 && p->FileSize>=0)
{
if (p->TimeStamps)
{
// try to read the last packets and figure out Duration
filepos_t SavePos;
format_reader* Reader = p->Reader;
LockEnter(p->InputLock);
LockEnter(p->BufferLock);
SavePos = Reader->Input->Seek(Reader->Input,0,SEEK_CUR);
if (SavePos >= 0)
{
format_buffer* Buffer[ENDCHUNKS];
int No,i;
int Total = 0;
tick_t Max=-1;
format_reader Backup = *Reader;
memset(Buffer,0,sizeof(Buffer));
Reader->NoMoreInput = 1; //disable reading during ReadPacket
for (No=0;No<ENDCHUNKS;++No)
{
filepos_t Pos = p->FileSize - (No+1)*BLOCKSIZE;
if (Pos<0)
{
if (No)
break;
Pos = 0;
}
Buffer[No] = Format_BufferAlloc(p,2);
if (!Buffer[No])
break;
if (Reader->Input->Seek(Reader->Input,Pos,SEEK_SET)<0)
break;
Buffer[No]->Length = Reader->Input->ReadBlock(Reader->Input,&Buffer[No]->Block,0,BLOCKSIZE);
if (Buffer[No]->Length < 0)
break;
Total += Buffer[No]->Length;
if (No)
Buffer[No]->Next = Buffer[No-1];
// setup temporary buffer
Reader->InputBuffer = NULL;
Reader->BufferAvailable = Total;
Reader->BufferLast = Buffer[0];
Reader->BufferFirst = Buffer[No];
Reader->ReadPos = 0;
Reader->ReadBuffer = NULL;
Reader->FilePos = Pos;
for (i=0;i<=No;++i)
Buffer[i]->RefCount++;
if (p->SeekByPacket_BlockAlign > 1)
{
int Rem = (Pos - p->SeekByPacket_DataStart) % p->SeekByPacket_BlockAlign;
if (Rem)
Reader->Skip(Reader,p->SeekByPacket_BlockAlign - Rem);
}
if (p->BackupPacketState)
p->BackupPacketState(p,1);
while (Reader->BufferLast || Reader->ReadBuffer)
{
int Result;
format_packet* Packet = Format_PacketAlloc(p);
if (!Packet)
break;
Result = p->ReadPacket(p,Reader,Packet);
if (Result != ERR_NONE && Result != ERR_DATA_NOT_FOUND)
{
Reader->BufferLast = NULL;
Reader->ReadBuffer = NULL;
}
else
if (Result == ERR_NONE && Packet->Stream && Packet->RefTime>Max)
Max = Packet->RefTime;
Format_PacketRelease(p,Packet);
}
if (p->BackupPacketState)
p->BackupPacketState(p,0);
for (i=0;i<=No;++i)
Buffer[i]->RefCount=1; // ugly
if (Max >= 0)
{
p->Duration = Max;
break;
}
}
for (No=0;No<ENDCHUNKS;++No)
if (Buffer[No])
Format_BufferRelease(p,Buffer[No]);
Reader->Input->Seek(Reader->Input,SavePos,SEEK_SET);
*Reader = Backup;
}
LockLeave(p->BufferLock);
LockLeave(p->InputLock);
}
if (p->StreamCount)
{
int ByteRate = SumByteRate(p);
if (ByteRate>0)
{
tick_t Duration = Scale(p->FileSize,TICKSPERSEC,ByteRate);
if (p->Duration<0 || p->Duration+3*TICKSPERSEC<Duration)
{
p->Duration = Duration;
p->TimeStamps = 0;
}
}
}
}
#if !defined(MULTITHREAD)
if (IsVideo(p))
p->AutoReadSize = 1; // force auto readsize
#endif
if (p->StreamCount && p->ProcessMinBuffer)
{
int ByteRate = SumByteRate(p);
if (ByteRate<=0 && p->Duration>0)
{
int FileSize = p->FileSize;
if (FileSize < 0 && p->Reader->Input)
{
LockEnter(p->InputLock);
p->Reader->Input->Get(p->Reader->Input,STREAM_LENGTH,&FileSize,sizeof(FileSize));
LockLeave(p->InputLock);
}
ByteRate = Scale(FileSize,TICKSPERSEC,p->Duration);
}
if (ByteRate>0)
{
while (ByteRate>p->ProcessMinBuffer*2 && p->ProcessMinBuffer < p->BufferSize*BLOCKSIZE/4)
p->ProcessMinBuffer += BLOCKSIZE;
if (p->AutoReadSize)
{
int No;
int Rate = ByteRate / 16;
// find video framerate
for (No=0;No<p->StreamCount;++No)
{
packetformat Format;
p->Format.Get(p,(FORMAT_STREAM|PIN_FORMAT)+No,&Format,sizeof(Format));
if (Format.Type == PACKET_VIDEO && Format.PacketRate.Num>0)
{
Rate = Scale(ByteRate,Format.PacketRate.Den,Format.PacketRate.Num);
break;
}
}
p->ReadSize = 16384;
while (p->ReadSize>1024 && Rate<5000)
{
Rate <<= 1;
p->ReadSize >>= 1;
}
}
}
}
#if defined(TARGET_SYMBIAN)
if (p->ReadSize > 4096) // large reads interfere with audio (until multithreaded is not added...)
p->ReadSize = 4096;
#endif
FindCoverArt(p);
}
void Format_BufferRelease(format_base* p, format_buffer* Buffer)
{
//DEBUG_MSG4(DEBUG_FORMAT,"Buffer:%d release %d->%d (%d)",Buffer->Id,Buffer->RefCount,Buffer->RefCount-1,p->BufferUsed);
LockEnter(p->BufferLock);
assert(Buffer->RefCount>0 && Buffer->RefCount<1000);
if (--Buffer->RefCount <= 0)
{
assert(Buffer->RefCount==0);
--p->BufferUsed;
if (p->BufferUsed <= p->BufferSize)
{
Buffer->Next = p->FreeBuffers;
p->FreeBuffers = Buffer;
}
else
{
FreeBlock(&Buffer->Block);
free(Buffer);
}
}
LockLeave(p->BufferLock);
}
format_buffer* Format_BufferRemove(format_reader* Reader)
{
format_buffer* Buffer;
LockEnter(Reader->Format->BufferLock);
Buffer = Reader->BufferFirst;
if (Buffer)
{
Reader->BufferFirst = Buffer->Next;
if (Reader->BufferLast == Buffer)
Reader->BufferLast = NULL;
Reader->BufferAvailable -= Buffer->Length;
assert(Reader->BufferAvailable >= 0);
}
LockLeave(Reader->Format->BufferLock);
return Buffer;
}
void Format_SingleRefRelease(format_base* p, format_ref* Ref)
{
if (Ref->Buffer)
Format_BufferRelease(p,Ref->Buffer);
Ref->Next = p->FreeRefs;
p->FreeRefs = Ref;
}
void Format_ReleaseRef(format_base* p, format_ref* Ref)
{
while (Ref)
{
format_ref* Next = Ref->Next;
Format_SingleRefRelease(p,Ref);
Ref = Next;
}
}
void Format_PacketRelease(format_base* p, format_packet* Packet)
{
Format_ReleaseRef(p,Packet->Data);
Packet->Data = NULL;
Packet->Next = p->FreePackets;
p->FreePackets = Packet;
}
static NOINLINE void ReleaseStream(format_base* p,format_stream* Stream)
{
format_packet* Packet;
Stream->State.DropLevel = 0;
Stream->DropCount = 0;
Stream->Pending = 0;
Stream->LastTime = TIME_SYNC;
while (Stream->PacketFirst)
{
Packet = Stream->PacketFirst;
Stream->PacketFirst = Packet->Next;
if (Stream->PacketLast == Packet)
Stream->PacketLast = NULL;
Format_PacketRelease(p,Packet);
}
if (p->ReleaseStream && Stream != p->SubTitle && Stream != p->CoverArt)
p->ReleaseStream(p,Stream);
}
static int UpdateStreamPin(format_base* p,format_stream* Stream)
{
if (!Stream->Pin.Node)
ReleaseStream(p,Stream);
return ERR_NONE;
}
void Format_AfterSeek(format_base* p)
{
int No;
// release stream packets
for (No=0;No<p->StreamCount;++No)
ReleaseStream(p,p->Streams[No]);
if (p->SubTitle)
ReleaseStream(p,p->SubTitle);
p->LastRead = NULL;
if (p->AfterSeek)
p->AfterSeek(p);
}
void Format_ReleaseBuffers(format_reader* Reader)
{
format_buffer* Buffer;
// release read buffers
Reader->NoMoreInput = 0;
Reader->ReadPos = 0;
if (Reader->ReadBuffer)
{
Format_BufferRelease(Reader->Format,Reader->ReadBuffer);
Reader->ReadBuffer = NULL;
}
if (Reader->InputBuffer)
{
Format_BufferRelease(Reader->Format,Reader->InputBuffer);
Reader->InputBuffer = NULL;
}
while ((Buffer = Format_BufferRemove(Reader))!=NULL)
Format_BufferRelease(Reader->Format,Buffer);
}
format_reader* Format_FindReader(format_base* p,filepos_t Min,filepos_t Max)
{
int No;
filepos_t LimitMax;
if (Max < Min+16)
Max = Min+16;
LimitMax = p->BufferSize*BLOCKSIZE/2;
if (p->Duration>0)
{
// example a 55Mb/sec mjpeg with pcm audio can have large differences at end of file
LimitMax = Scale(Max-Min,3*TICKSPERSEC,p->Duration);
if (LimitMax < 512*1024)
LimitMax = 512*1024;
}
for (No=0;No<MAXREADER;++No)
{
format_reader* Reader = p->Reader+No;
filepos_t Limit = (Reader->OffsetMax - Reader->OffsetMin)/4;
if (Limit<128*1024)
Limit=128*1024;
if (Limit>LimitMax)
Limit=LimitMax;
if (!Reader->OffsetMax ||
(Reader->OffsetMin < Max && Reader->OffsetMax > Min &&
abs(Reader->OffsetMin-Min)<Limit && abs(Reader->OffsetMax-Max)<Limit))
{
stream* Orig = p->Reader[0].Input;
if (Reader->OffsetMin > Min)
Reader->OffsetMin = Min;
if (Reader->OffsetMax < Max)
Reader->OffsetMax = Max;
Reader->Ratio = Scale(MAX_INT,1,Reader->OffsetMax - Reader->OffsetMin);
if (!Reader->Input && Orig)
{
bool_t Silent = 1;
tchar_t URL[MAXPATH];
stream* Input;
if (Orig->Get(Orig,STREAM_URL,URL,sizeof(URL)) != ERR_NONE)
break;
Input = (stream*)NodeCreate(Orig->Class);
if (!Input)
break;
Input->Set(Input,STREAM_SILENT,&Silent,sizeof(bool_t));
if (Input->Set(Input,STREAM_URL,URL,sizeof(URL))!=ERR_NONE)
{
NodeDelete((node*)Input);
break;
}
Reader->ReadPos = 0;
Reader->FilePos = 0;
Reader->Input = Input;
}
return Reader;
}
}
return NULL;
}
static NOINLINE void Format_FreeStream(format_base* p,format_stream* Stream)
{
PacketFormatClear(&Stream->Format);
BufferClear(&Stream->BufferMem);
FreeBlock(&Stream->BufferBlock);
free(Stream);
}
int Format_Reset(format_base* p)
{
int Result = ERR_NONE;
format_packet* Packet;
format_buffer* Buffer;
format_reader* Reader;
format_ref* Ref;
int No;
if (p->BufferLock) // only if it was inited
{
Format_AfterSeek(p);
for (No=0;No<MAXREADER;++No)
Format_ReleaseBuffers(p->Reader+No);
}
if (p->ReleaseStreams.Func)
p->ReleaseStreams.Func(p->ReleaseStreams.This,0,0);
if (p->Done)
p->Done(p);
while (p->StreamCount)
Format_RemoveStream(p);
while (p->FreePackets)
{
Packet = p->FreePackets;
p->FreePackets = Packet->Next;
free(Packet);
}
while (p->FreeBuffers)
{
Buffer = p->FreeBuffers;
p->FreeBuffers = Buffer->Next;
FreeBlock(&Buffer->Block);
free(Buffer);
}
while (p->FreeRefs)
{
Ref = p->FreeRefs;
p->FreeRefs = Ref->Next;
free(Ref);
}
if (p->SubTitle)
{
Format_FreeSubTitle(p,p->SubTitle);
p->SubTitle = NULL;
}
if (p->CoverArt)
{
Format_FreeStream(p,p->CoverArt);
p->CoverArt = NULL;
}
p->TotalCount = 0;
p->StreamCount = 0;
p->ActiveStreams = 0;
LockDelete(p->BufferLock);
LockDelete(p->InputLock);
p->BufferLock = NULL;
p->InputLock = NULL;
p->LastRead = NULL;
for (No=0;No<MAXREADER;++No)
{
Reader = p->Reader+No;
if (No>0 && Reader->Input)
{
Reader->Input->Set(Reader->Input,STREAM_URL,NULL,0);
NodeDelete((node*)Reader->Input);
Reader->Input = NULL;
}
Reader->Ratio = -1;
Reader->OffsetMin = MAX_INT;
Reader->OffsetMax = 0;
Reader->Current = NULL;
Reader->OutOfSync = 0;
}
Reader = p->Reader;
if (Reader->Input)
{
if (!NodeIsClass(Reader->Input->Class,STREAM_CLASS) &&
!NodeIsClass(Reader->Input->Class,STREAMPROCESS_CLASS))
return ERR_INVALID_PARAM;
if (Reader->Input->Get(Reader->Input,STREAM_LENGTH,&p->FileSize,sizeof(p->FileSize)) != ERR_NONE)
p->FileSize = -1;
p->InputLock = LockCreate();
p->BufferLock = LockCreate();
p->Duration = TIME_UNKNOWN;
p->FirstSync = 1;
p->SyncMode = 1; // start with syncmode
p->SyncTime = TIME_SYNC;
p->SyncStream = NULL;
p->HeaderLoaded = 0;
p->ProcessMinBuffer = PROCESSMINVIDEO;
p->ReadSize = 16384;
p->GlobalOffset = 0;
p->SumByteRate = 0;
Reader->FilePos = 0;
Reader->NoMoreInput = 0;
p->SeekByPacket_DataStart = 0;
p->SeekByPacket_BlockAlign = 1;
if (p->Init)
{
Result = p->Init(p);
if (Result != ERR_NONE)
{
Reader->Input = NULL;
Format_Reset(p);
}
else
p->SyncRead = SYNCREAD;
}
}
return Result;
}
int FormatBaseGet(format_base* p,int No,void* Data,int Size)
{
int Result = ERR_INVALID_PARAM;
if (No >= FORMAT_COMMENT && No < FORMAT_COMMENT+p->TotalCount)
GETVALUE(p->Streams[No-FORMAT_COMMENT]->Comment,pin)
else
if (No >= FORMAT_STREAM && No < FORMAT_STREAM+p->TotalCount)
GETVALUE(p->Streams[No-FORMAT_STREAM]->Pin,pin)
else
if (No >= FORMAT_STREAM_PRIORITY && No < FORMAT_STREAM_PRIORITY+p->TotalCount)
GETVALUE(p->Streams[No-FORMAT_STREAM_PRIORITY]->Priority,int)
else
if (No >= (FORMAT_STREAM|PIN_PROCESS) && No < (FORMAT_STREAM|PIN_PROCESS)+p->TotalCount)
GETVALUE(p->Streams[No-(FORMAT_STREAM|PIN_PROCESS)]->Process,packetprocess)
else
if (No >= (FORMAT_STREAM|PIN_FORMAT) && No < (FORMAT_STREAM|PIN_FORMAT)+p->TotalCount)
{
packetformat CodecFormat;
format_stream* s = p->Streams[No-(FORMAT_STREAM|PIN_FORMAT)];
assert(Size == sizeof(packetformat));
if (s->Pin.Node && s->Pin.Node->Get(s->Pin.Node,s->Pin.No|PIN_FORMAT,&CodecFormat,sizeof(CodecFormat))==ERR_NONE)
PacketFormatCombine(&s->Format,&CodecFormat);
*(packetformat*)Data = s->Format;
Result = ERR_NONE;
}
else
switch (No)
{
case FORMAT_BUFFERSIZE: GETVALUE(p->BufferSize,int); break;
case FORMAT_INPUT: GETVALUE(p->Reader[0].Input,stream*); break;
case FORMAT_DURATION: GETVALUECOND(p->Duration,tick_t,p->Duration>=0); break;
case FORMAT_FILEPOS: GETVALUECOND(p->Reader[0].FilePos,int,p->Timing && p->Reader[0].FilePos>=0); break;
case FORMAT_FILEALIGN: GETVALUE(p->FileAlign,int); break;
case FORMAT_STREAM_COUNT: GETVALUE(p->TotalCount,int); break;
case FORMAT_FILESIZE: GETVALUECOND(p->FileSize/1024,int,p->FileSize>=0); break;
case FORMAT_FIND_SUBTITLES: GETVALUE(p->NeedSubtitles,bool_t); break;
case FORMAT_GLOBAL_COMMENT: GETVALUE(p->Comment,pin); break;
case FORMAT_AUTO_READSIZE: GETVALUE(p->AutoReadSize,bool_t); break;
case FORMAT_TIMING: GETVALUE(p->Timing,bool_t); break;
case FORMAT_COVERART: GETVALUECOND(p->StreamCount+(p->SubTitle!=NULL),int,p->CoverArt!=NULL); break;
case FORMAT_MIN_BUFFER: GETVALUE(p->ProcessMinBuffer/BLOCKSIZE,int); break;
}
return Result;
}
int FormatBaseSet(format_base* p,int No,const void* Data,int Size)
{
node* Advanced;
uint8_t* Ptr;
int Result = ERR_INVALID_PARAM;
if (No >= FORMAT_COMMENT && No < FORMAT_COMMENT+p->TotalCount)
SETVALUE(p->Streams[No-FORMAT_COMMENT]->Comment,pin,ERR_NONE)
else
if (No >= FORMAT_STREAM && No < FORMAT_STREAM+p->TotalCount)
{
format_stream* s = p->Streams[No-FORMAT_STREAM];
if (s->Pin.Node && No-FORMAT_STREAM<p->StreamCount) p->ActiveStreams--;
SETVALUE(s->Pin,pin,UpdateStreamPin(p,s));
if (s->Pin.Node && No-FORMAT_STREAM<p->StreamCount) p->ActiveStreams++;
}
else
if (No >= (FORMAT_STREAM|PIN_PROCESS) && No < (FORMAT_STREAM|PIN_PROCESS)+p->TotalCount)
SETVALUE(p->Streams[No-(FORMAT_STREAM|PIN_PROCESS)]->Process,packetprocess,ERR_NONE)
else
switch (No)
{
case FORMAT_INPUT: SETVALUENULL(p->Reader[0].Input,stream*,Format_Reset(p),p->Reader[0].Input=NULL); break;
case FORMAT_UPDATESTREAMS: SETVALUE(p->UpdateStreams,notify,ERR_NONE); break;
case FORMAT_RELEASESTREAMS: SETVALUE(p->ReleaseStreams,notify,ERR_NONE); break;
case FORMAT_FIND_SUBTITLES: SETVALUE(p->NeedSubtitles,bool_t,ERR_NONE); break;
case FORMAT_GLOBAL_COMMENT: SETVALUE(p->Comment,pin,ERR_NONE); break;
case FORMAT_FILEALIGN: SETVALUE(p->FileAlign,int,ERR_NONE); break;
case FORMAT_AUTO_READSIZE: SETVALUE(p->AutoReadSize,bool_t,ERR_NONE); break;
case NODE_HIBERNATE:
assert(Size == sizeof(int));
Result = Format_Hibernate(p,*(int*)Data);
break;
case NODE_SETTINGSCHANGED:
Advanced = Context()->Advanced;
if (Advanced)
{
Advanced->Get(Advanced,ADVANCED_DROPTOL,&p->DropTolerance,sizeof(tick_t));
Advanced->Get(Advanced,ADVANCED_SKIPTOL,&p->SkipTolerance,sizeof(tick_t));
Advanced->Get(Advanced,ADVANCED_AVOFFSET,&p->AVOffset,sizeof(tick_t));
}
break;
case FORMAT_DATAFEED:
Ptr = (uint8_t*) Data;
while (Size)
{
format_buffer* Buffer;
Buffer = Format_BufferAlloc(p,2);
if (Buffer)
{
Buffer->Length = Size;
if (Buffer->Length > BLOCKSIZE)
Buffer->Length = BLOCKSIZE;
WriteBlock(&Buffer->Block,0,Ptr,Buffer->Length);
Ptr += Buffer->Length;
Size -= Buffer->Length;
Format_BufferInsert(p->Reader,Buffer);
}
}
break;
case FORMAT_BUFFERSIZE: SETVALUE(p->BufferSize,int,ERR_NONE); break;
}
return Result;
}
format_packet* Format_PacketAlloc(format_base* p)
{
format_packet* Packet = p->FreePackets;
if (!Packet)
{
Packet = (format_packet*) malloc(sizeof(format_packet));
if (!Packet)
return NULL;
}
else
p->FreePackets = Packet->Next;
Packet->Data = NULL;
Packet->RefTime = TIME_UNKNOWN;
Packet->EndRefTime = TIME_UNKNOWN;
Packet->Stream = NULL;
Packet->Next = NULL;
Packet->Key = 1;
return Packet;
}
static int Format_Sync(format_base* p,tick_t Time,int FilePos,bool_t PrevKey)
{
if (!p->Seek || !p->Reader[0].Input)
return ERR_NOT_SUPPORTED;
if (!p->HeaderLoaded)
return ERR_LOADING_HEADER;
p->SyncMode = 1;
p->SyncRead = SYNCREAD;
p->SyncTime = TIME_SYNC; // set before p->Seek
p->SyncStream = NULL;
if (Time>=0 || FilePos>=0)
{
int Result = p->Seek(p,Time,FilePos,PrevKey);
if (Result != ERR_NONE)
{
p->SyncMode = 0;
return Result;
}
}
return ERR_NONE;
}
int Format_CheckEof(format_base* p,format_stream* Stream)
{
int Result;
if (!p->Timing && p->ProcessTime>=0 && p->ProcessTime<5*TICKSPERSEC)
return ERR_BUFFER_FULL;
Stream->State.CurrTime = p->ProcessTime;
Stream->State.DropLevel = 0;
Result = Stream->Process(Stream->Pin.Node,NULL,&Stream->State);
if (Result != ERR_BUFFER_FULL)
Result = ERR_END_OF_FILE;
return Result;
}
static NOINLINE int Synced(format_base* p,format_stream* Stream)
{
p->SyncMode = 0;
if (p->SyncTime == TIME_SYNC)
{
p->SyncTime = Stream->Packet.RefTime;
if (p->SyncTime < 0)
p->SyncTime = Stream->LastTime;
}
if (p->FirstSync)
{
// some codecs may need the first few packets as headers
int No;
p->ProcessTime = 0;
for (No=0;No<p->StreamCount;++No)
if (p->Streams[No]->Pin.Node && p->Streams[No]->PacketFirst)
p->Process(p,p->Streams[No]); // try processing
p->ProcessTime = TIME_SYNC;
}
return ERR_SYNCED;
}
int Format_Send(format_base* p,format_stream* Stream)
{
int Result;
tick_t CurrTime = p->ProcessTime;
Stream->State.CurrTime = CurrTime;
if (Stream->Packet.RefTime >= 0 && !Stream->DisableDrop)
{
Stream->State.DropLevel = 0;
if (CurrTime >= 0)
{
tick_t Diff = CurrTime - Stream->Packet.RefTime;
if (Diff < -TICKSPERSEC/2 && Stream->Format.Type == PACKET_VIDEO)
{
// make sure buffers and pending packets are processed
Stream->Process(Stream->Pin.Node,NULL,&Stream->State);
return ERR_BUFFER_FULL;
}
if (Diff > p->DropTolerance)
{
if (Diff > p->SkipTolerance + p->DropTolerance)
{
Stream->State.DropLevel = 2;
Stream->DropCount = DROP_SHOW;
}
else
{
if (!Stream->State.DropLevel)
Stream->DropCount = 0;
if (Stream->DropCount >= DROP_SHOW)
{
Stream->State.DropLevel = 0; // show one packet
Stream->DropCount = 0;
}
else
{
Stream->State.DropLevel = 1;
++Stream->DropCount;
}
}
}
}
}
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);
Result = Stream->Process(Stream->Pin.Node,&Stream->Packet,&Stream->State);
// packet not processed?
if (Result == ERR_BUFFER_FULL)
{
DEBUG_MSG1(DEBUG_FORMAT,T("Send stream:%d BufferFull"),Stream->No);
return Result;
}
if (p->Sended)
p->Sended(p,Stream);
Stream->Pending = 0;
// sync: found a valid frame?
if (p->SyncMode && (Result == ERR_NONE || Result == ERR_NOT_SUPPORTED))
Result = Synced(p,Stream);
return Result;
}
void Format_TimeStampRestarted(format_base* p,format_stream* Stream,tick_t* RefTime)
{
if (!p->InSeek)
{
format_packet* i;
*RefTime -= p->GlobalOffset;
p->GlobalOffset = Stream->LastTime; // last processed time
for (i=Stream->PacketFirst;i;i=i->Next)
if (i->RefTime>=0)
p->GlobalOffset = i->RefTime; // last packet time
*RefTime += p->GlobalOffset;
p->TimeStamps = 0;
}
}
int Format_FillQueue(format_base* p,format_reader* Reader)
{
int Result;
format_packet* Packet;
if (!Reader->BufferAvailable && !Reader->ReadBuffer && p->ProcessMinBuffer!=0 &&
(!p->SyncMode || p->SyncRead<=0 || Reader->NoMoreInput))
return ERR_NEED_MORE_DATA;
Packet = Format_PacketAlloc(p);
if (!Packet)
return ERR_OUT_OF_MEMORY;
Result = p->ReadPacket(p,Reader,Packet);
if (Result == ERR_NONE && Packet->Stream && Packet->Stream->Pin.Node)
{
format_stream* s = Packet->Stream;
if (Packet->RefTime>=0)
{
Packet->RefTime += p->GlobalOffset;
if (s->Format.Type == PACKET_AUDIO)
{
Packet->RefTime += p->AVOffset;
if (Packet->RefTime < 0)
Packet->RefTime = 0;
}
if (s->LastTime<0)
s->LastTime = Packet->RefTime; // found reftime
else
if (s->LastTime > Packet->RefTime+TICKSPERSEC && Packet->RefTime-p->GlobalOffset<TICKSPERSEC)
Format_TimeStampRestarted(p,s,&Packet->RefTime);
}
if (s->LastTime >= TIME_UNKNOWN)
{
// add packet to stream
if (!s->PacketFirst)
s->PacketFirst = Packet;
else
s->PacketLast->Next = Packet;
s->PacketLast = Packet;
if (Packet->EndRefTime>=0 && s->Format.Type == PACKET_SUBTITLE)
{
// add empty packet
format_packet* Tail = Format_PacketAlloc(p);
if (Tail)
{
Tail->Stream = Packet->Stream;
Tail->RefTime = Packet->EndRefTime;
if (!s->PacketFirst)
s->PacketFirst = Tail;
else
s->PacketLast->Next = Tail;
s->PacketLast = Tail;
}
}
}
else
Format_PacketRelease(p,Packet);
}
else
Format_PacketRelease(p,Packet);
return Result;
}
NOINLINE bool_t Format_AllocBufferBlock(format_base* p,format_stream* Stream,int Size)
{
FreeBlock(&Stream->BufferBlock);
if (Size>0)
{
Size = (Size + SAFETAIL + 0x7FFF) & ~0x7FFF;
if (AllocBlock(Size,&Stream->BufferBlock,0,HEAP_STORAGE))
Size -= SAFETAIL;
else
Size = 0;
}
Stream->BufferBlockLength = Size;
return Size>0;
}
/*
static bool_t ReleasePacket(format_base* p)
{
int No;
format_stream* Min = NULL;
tick_t MinTime = MAX_TICK;
for (No=0;No<p->StreamCount;++No)
{
format_stream* Stream = p->Streams[No];
if (Stream->PacketFirst && Stream->PacketFirst->RefTime < MinTime)
{
Min = Stream;
MinTime = Stream->PacketFirst->RefTime;
}
}
if (Min)
{
format_packet* Packet = Min->PacketFirst;
Min->PacketFirst = Packet->Next;
if (Min->PacketLast == Packet)
Min->PacketLast = NULL;
Format_PacketRelease(p,Packet);
return 1;
}
return 0;
}
*/
static int Format_ProcessStream(format_base* p,format_stream* Stream)
{
format_packet* Packet;
format_ref* Ref;
int Result = ERR_NONE;
int No;
int Burst;
if (Stream->Pending)
{
Result = Format_Send(p,Stream);
if (Result == ERR_BUFFER_FULL || Result == ERR_SYNCED)
{
if (p->SyncMode && Stream == p->SyncStream) // can happen when sync without seek
Result = Synced(p,Stream);
return Result;
}
}
// process a limited number of packets at once (other streams need cpu time too)
Burst = Stream->PacketBurst;
for (No=0;No<Burst;++No)
{
while (!Stream->PacketFirst)
{
format_reader* Reader = Stream->Reader;
/*
if (p->BufferUsed >= p->BufferSize && p->SyncMode && Stream == p->SyncStream)
{
// try dropping other stream packets to make buffer for sync stream
while (p->BufferUsed >= p->BufferSize)
if (!ReleasePacket(p))
break;
}
*/
// prevent audio from going too much ahead
if (Reader->BufferAvailable < p->ProcessMinBuffer && !Reader->NoMoreInput &&
(!p->SyncMode || p->SyncRead<=0 || Stream != p->SyncStream))
return ERR_NEED_MORE_DATA;
Result = Format_FillQueue(p,Reader);
if (Reader->NoMoreInput && (Result == ERR_END_OF_FILE || Result == ERR_NEED_MORE_DATA))
Result = Format_CheckEof(p,Stream);
if (Result != ERR_NONE || (p->Bench && (No || !Stream->PacketFirst)))
return Result;
}
Packet = Stream->PacketFirst;
// sync: all non SyncStream packets are stored (or dropped)
if (p->SyncMode && Stream != p->SyncStream && p->SyncStream)
{
// catch up to syncstream (drop packets)
tick_t LastTime = p->SyncStream->LastTime;
if (p->SyncStream->Fragmented)
LastTime -= TICKSPERSEC/2; // LastTime may not be the correct sync time
while (Packet && Packet->RefTime < LastTime)
{
Stream->PacketFirst = Packet->Next;
if (Stream->PacketLast == Packet)
Stream->PacketLast = NULL;
Format_PacketRelease(p,Packet);
Packet = Stream->PacketFirst;
}
return ERR_NEED_MORE_DATA; // allow SyncStream to need more data
}
//DEBUG_MSG3(DEBUG_FORMAT,T("Packet stream:%d time:%d pos:%d"),Stream->No,Packet->RefTime,Packet->FilePos);
// build output packet
if (Packet->RefTime >= 0)
Stream->LastTime = Packet->RefTime;
Stream->Packet.RefTime = Packet->RefTime;
Stream->Packet.Key = Packet->Key;
Ref = Packet->Data;
if (!Ref)
{
Stream->Packet.Data[0] = NULL;
Stream->Packet.Length = 0;
Stream->Pending = 1;
}
else
if (!Stream->Fragmented)
{
if (Ref->Next || (Ref->Length + Ref->Begin + SAFETAIL > BLOCKSIZE) || Stream->ForceMerge)
{
// merge references
if (p->UseBufferBlock)
{
int Total = 0;
format_ref* i;
for (Total=0,i=Ref;i;i=i->Next)
Total += i->Length;
if (Stream->BufferBlockLength < Total && !Format_AllocBufferBlock(p,Stream,Total))
Ref = NULL;
for (Total=0,i=Ref;i;i=i->Next)
{
WriteBlock(&Stream->BufferBlock,Total,i->Buffer->Block.Ptr + i->Begin,i->Length);
Total += i->Length;
}
Stream->Packet.Data[0] = Stream->BufferBlock.Ptr;
Stream->Packet.Length = Total;
}
else
{
BufferDrop(&Stream->BufferMem);
for (;Ref;Ref=Ref->Next)
BufferWrite(&Stream->BufferMem,Ref->Buffer->Block.Ptr + Ref->Begin, Ref->Length,16384);
Stream->Packet.Data[0] = Stream->BufferMem.Data;
Stream->Packet.Length = Stream->BufferMem.WritePos;
}
}
else
{
// single reference
Stream->Packet.Data[0] = Ref->Buffer->Block.Ptr + Ref->Begin;
Stream->Packet.Length = Ref->Length;
}
Stream->Pending = 1;
}
else
{
// send first reference (doesn't matter how long)
Stream->Packet.Data[0] = Ref->Buffer->Block.Ptr + Ref->Begin;
Stream->Packet.Length = Ref->Length;
Stream->Pending = 2; // indicate parital sending
}
Result = Format_Send(p,Stream);
if (Result == ERR_BUFFER_FULL || Result == ERR_SYNCED)
break;
if (Stream->State.DropLevel==2 && Stream->PacketFirst && Burst<10 && No==Burst-1)
++Burst; // 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 void Format_Sended(format_base* p, format_stream* Stream)
{
format_packet* Packet = Stream->PacketFirst;
if (Packet)
{
if (Stream->Pending == 2 && Packet->Data)
{
// release sended references
format_ref* Ref = Packet->Data;
Packet->Data = Ref->Next;
Format_SingleRefRelease(p,Ref);
if (Packet->Data)
{
// packet still not finished
Packet->RefTime = TIME_UNKNOWN;
return;
}
}
// full packet is released
Stream->PacketFirst = Packet->Next;
if (Stream->PacketLast == Packet)
Stream->PacketLast = NULL;
Format_PacketRelease(p,Packet);
}
}
NOINLINE format_stream* Format_DefSyncStream(format_base* p, format_reader* Reader)
{
format_stream* Found = NULL;
format_stream* Stream;
int No;
// prefer video streams
for (No=0;No<p->StreamCount;++No)
{
Stream = p->Streams[No];
if (Stream->Pin.Node && (!Reader || Stream->Reader==Reader))
{
if (Stream->Format.Type == PACKET_VIDEO)
return Stream;
if (!Found)
Found = Stream;
}
}
return Found;
}
static bool_t TryReSend(node* p)
{
if (p)
{
bool_t Buffered;
if (p->Get(p,FLOW_BUFFERED,&Buffered,sizeof(Buffered))==ERR_NONE && Buffered)
return p->Set(p,FLOW_RESEND,NULL,0) == ERR_NONE;
if (!NodeIsClass(p->Class,OUT_CLASS))
{
pin Pin;
node* Node;
datadef DataDef;
int No;
for (No=0;NodeEnum(p,No,&DataDef)==ERR_NONE;++No)
if (DataDef.Flags & DF_OUTPUT)
{
switch (DataDef.Type)
{
case TYPE_NODE:
if (p->Get(p,DataDef.No,&Node,sizeof(Node))==ERR_NONE && TryReSend(Node))
return 1;
break;
case TYPE_PACKET:
if (p->Get(p,DataDef.No,&Pin,sizeof(Pin))==ERR_NONE && TryReSend(Pin.Node))
return 1;
break;
}
}
}
}
return 0;
}
static int DummyError(void* This,int Param,int Param2)
{
return ERR_NONE;
}
static NOINLINE int ProcessCoverArt(format_base* p,format_stream* Stream)
{
int Result;
notify Error;
context* c = Context();
node* Node = Stream->Pin.Node;
if (!Node)
return ERR_NONE;
if (TryReSend(Node))
return ERR_NONE;
// suppress covert art decoding error messages
Error = c->Error;
c->Error.Func = DummyError;
Stream->State.CurrTime = TIME_SYNC;
Stream->State.DropLevel = 0;
Result = Stream->Process(Node,&Stream->Packet,&Stream->State);
c->Error = Error;
return Result;
}
static int Format_Process(format_base* p,processstate* State)
{
int No;
int Result;
int AllNeedMoreData = 1;
int AllEndOfFile = 1;
assert(State->Time>=0 || State->Time == TIME_BENCH);
State->BufferUsedBefore = p->BufferUsed;
p->ProcessTime = State->Time;
p->Bench = p->ProcessTime < 0;
if (!p->HeaderLoaded)
{
// load format begining to find streams
format_reader* Reader = p->Reader;
Result = p->FillQueue(p,Reader);
if (Reader->FilePos > HEADERLOAD || (p->StreamCount && Reader->FilePos > p->MinHeaderLoad) || Reader->Eof(Reader))
p->HeaderLoaded = 1;
State->BufferUsedAfter = p->BufferUsed;
return Result;
}
if (p->SyncMode)
{
p->ProcessTime = TIME_SYNC;
// we need to choose one stream (to find a non dropped frame)
if (!p->SyncStream)
{
p->SyncStream = Format_DefSyncStream(p,NULL);
if (!p->SyncStream)
{
// no sync needed
p->SyncMode = 0;
// try to calc duration once (after first sync)
if (p->FirstSync)
{
p->FirstSync = 0;
CalcDuration(p);
}
if (p->CoverArt)
ProcessCoverArt(p,p->CoverArt);
// leave time as it is
State->BufferUsedAfter = p->BufferUsed;
return ERR_SYNCED;
}
}
}
// if all streams are full: caller can go to sleep
Result = ERR_BUFFER_FULL;
if (p->SubTitle)
Format_ProcessSubTitle(p,p->SubTitle);
for (No=0;No<p->StreamCount;++No)
{
format_stream* Stream = p->Streams[No];
if (Stream->Pin.Node)
{
int i = p->Process(p,Stream);
if (!p->SyncMode || p->SyncStream == Stream)
{
if (i == ERR_NEED_MORE_DATA)
{
if (!Stream->Reader->NoMoreInput && Stream->Format.Type != PACKET_SUBTITLE)
{
// if less then 1/8 sec is left and stream needs data -> force need more data mode
tick_t LastTime = Stream->LastTime;
if (State->Fill || (LastTime >= 0 && p->ProcessTime >= 0 && LastTime < p->ProcessTime + TICKSPERSEC/8))
Result = ERR_NEED_MORE_DATA;
}
}
else
AllNeedMoreData = 0;
if (i != ERR_END_OF_FILE)
AllEndOfFile = 0;
}
if (i == ERR_SYNCED)
{
// try to calc duration once (after first sync)
if (p->FirstSync)
{
p->FirstSync = 0;
CalcDuration(p);
}
if (p->CoverArt)
ProcessCoverArt(p,p->CoverArt);
State->Time = p->SyncTime;
State->BufferUsedAfter = p->BufferUsed;
return i;
}
if (Result == ERR_BUFFER_FULL &&
i != ERR_BUFFER_FULL &&
i != ERR_END_OF_FILE &&
i != ERR_NEED_MORE_DATA)
Result = ERR_NONE; // no sleep
if (Result == ERR_NONE && Stream->State.DropLevel)
Result = ERR_DROPPING;
}
}
if (!p->ActiveStreams)
{
// release buffers
Result = ERR_END_OF_FILE;
for (No=0;No<MAXREADER;++No)
{
format_buffer* Buffer;
format_reader* Reader = p->Reader+No;
if (!Reader->Input)
break;
while ((Buffer = Format_BufferRemove(Reader))!=NULL)
{
Reader->FilePos += Buffer->Length;
Format_BufferRelease(p,Buffer);
}
if (!Reader->NoMoreInput)
Result = ERR_BUFFER_FULL; // return buffer full so fill mode doesn't go though file
}
State->Time = TIME_UNKNOWN; // player should use file position
}
else
{
if (AllEndOfFile) // all end of file?
Result = ERR_END_OF_FILE;
else
if (AllNeedMoreData) // all need data?
{
Result = ERR_END_OF_FILE;
for (No=0;No<MAXREADER;++No)
{
if (!p->Reader[No].Input)
break;
if (!p->Reader[No].NoMoreInput)
{
Result = ERR_NEED_MORE_DATA;
break;
}
}
}
else
if (Result == ERR_BUFFER_FULL && State->Fill)
{
// don't allow exiting fill mode if buffer is less than ProcessMinBuffer+BLOCKSIZE
// we might fallback to loadmode right after starting playback
if (p->Reader->BufferAvailable < p->ProcessMinBuffer+BLOCKSIZE && !p->Reader->NoMoreInput)
Result = ERR_NEED_MORE_DATA;
}
}
if (p->SyncMode && Result == ERR_END_OF_FILE)
{
p->SyncMode = 0;
if (p->Duration<0 && p->SyncStream)
State->Time = p->SyncStream->LastTime;
else
State->Time = p->Duration;
Result = ERR_SYNCED;
}
State->BufferUsedAfter = p->BufferUsed;
return Result;
}
format_ref* Format_RefAlloc(format_base* p, format_buffer* To, int Begin, int Length)
{
format_ref* Ref = p->FreeRefs;
if (!Ref)
{
Ref = (format_ref*) malloc(sizeof(format_ref));
if (!Ref)
return NULL;
}
else
p->FreeRefs = Ref->Next;
LockEnter(p->BufferLock);
//DEBUG_MSG3(DEBUG_FORMAT,"Buffer:%d addref %d->%d",To->Id,To->RefCount,To->RefCount+1);
++To->RefCount;
LockLeave(p->BufferLock);
Ref->Length = Length;
Ref->Begin = Begin;
Ref->Buffer = To;
Ref->Next = NULL;
return Ref;
}
bool_t Format_ReadBuffer(format_reader* Reader, bool_t ToRead)
{
bool_t Result;
LockEnter(Reader->Format->InputLock);
LockEnter(Reader->Format->BufferLock);
if (!Reader->BufferFirst && !Reader->NoMoreInput)
{
format_buffer* Buffer = Reader->InputBuffer;
if (!Buffer)
Buffer = Format_BufferAlloc(Reader->Format,1);
if (Buffer)
{
// use partial buffer loading after sync for a few times (SYNCREAD)
// but later have to use full buffer (matroska seeking example can run out of buffer...)
int TargetLength = (ToRead && Reader->Format->SyncRead>0)? Reader->Format->ReadSize:BLOCKSIZE;
if (Buffer->Length >= TargetLength)
{
Format_BufferInsert(Reader,Buffer);
Reader->InputBuffer = NULL;
}
else
{
int Length = Reader->Input->ReadBlock(Reader->Input,&Buffer->Block,Buffer->Length,TargetLength - Buffer->Length);
if (Length < 0)
{
// failed
if (!Reader->InputBuffer)
Format_BufferRelease(Reader->Format,Buffer);
}
else
{
Buffer->Length += Length;
Reader->NoMoreInput = Length == 0;
if (!Length && !Reader->InputBuffer)
Format_BufferRelease(Reader->Format,Buffer);
else
{
Format_BufferInsert(Reader,Buffer);
Reader->InputBuffer = NULL;
}
}
}
}
if (Reader->Format->SyncRead>0)
Reader->Format->SyncRead--;
}
Result = Reader->BufferFirst != NULL;
if (Result && ToRead)
{
Reader->ReadBuffer = Format_BufferRemove(Reader);
if (Reader->ReadBuffer)
Reader->ReadLen = Reader->ReadBuffer->Length;
}
LockLeave(Reader->Format->BufferLock);
LockLeave(Reader->Format->InputLock);
return Result;
}
format_ref* Format_DupRef(format_base* p, format_ref* Chain, int Offset, int Length)
{
format_ref* Head = NULL;
format_ref** Ptr = &Head;
while (Chain && Offset >= Chain->Length)
{
Chain = Chain->Next;
Offset -= Chain->Length;
}
while (Chain && Length > 0)
{
int Len = Chain->Length - Offset;
if (Len > Length)
Len = Length;
*Ptr = Format_RefAlloc(p,Chain->Buffer,Chain->Begin+Offset,Len);
if (!*Ptr)
break;
Chain = Chain->Next;
Length -= Len;
Offset = 0;
Ptr = &(*Ptr)->Next;
}
return Head;
}
//---------------------------------------------------------------------------------------------
static bool_t Reader_GetReadBuffer(format_reader* Reader)
{
if (!Reader->Input) // external reader
{
Reader->ReadBuffer = NULL;
return 0;
}
// release old buffer
if (Reader->ReadBuffer)
{
Reader->ReadPos -= Reader->ReadBuffer->Length;
Format_BufferRelease(Reader->Format,Reader->ReadBuffer);
}
// get new buffer from BufferFirst..BufferLast chain
Reader->ReadBuffer = Format_BufferRemove(Reader);
if (Reader->ReadBuffer)
{
Reader->ReadLen = Reader->ReadBuffer->Length;
return 1;
}
// load input now (can't wait for input thread)
return Format_ReadBuffer(Reader,1);
}
format_ref* Reader_ReadAsRef(format_reader* p, int Length)
{
int n;
format_ref* Ref;
format_ref** RefPtr;
Ref = NULL;
RefPtr = &Ref;
if (Length < 0) // read as much as possible from one buffer
{
while (!p->ReadBuffer || p->ReadPos >= p->ReadLen)
if (!p->GetReadBuffer(p))
return NULL;
n = p->ReadLen - p->ReadPos;
if (n > -Length)
n = -Length;
Length = n;
}
while (Length > 0)
{
while (!p->ReadBuffer || p->ReadPos >= p->ReadLen)
if (!p->GetReadBuffer(p))
return Ref;
n = p->ReadLen - p->ReadPos;
if (n > Length)
n = Length;
*RefPtr = Format_RefAlloc(p->Format,p->ReadBuffer,p->ReadPos,n);
if (!*RefPtr)
break;
RefPtr = &(*RefPtr)->Next;
Length -= n;
p->FilePos += n;
p->ReadPos += n;
}
return Ref;
}
static void Reader_Skip(format_reader* p,int n)
{
if (n > 0)
{
assert(n < 0x10000000);
p->FilePos += n;
p->ReadPos += n;
}
}
static int Reader_Seek(format_reader* Reader,filepos_t Pos,int Origin)
{
int Adjust = 0;
if (Reader->FilePos >= 0 && !Reader->Format->DisableReader)
{
filepos_t RelPos = Pos;
if (Origin == SEEK_SET)
RelPos -= Reader->FilePos;
if (Origin != SEEK_END)
{
// check if we can use Format_Skip
if (RelPos >= 0 && RelPos < Reader->BufferAvailable + SKIPDISTANCE)
{
Reader_Skip(Reader,RelPos);
return ERR_NONE;
}
// check if we are in the same ReadBuffer
if (RelPos < 0 && Reader->ReadBuffer && Reader->ReadPos + RelPos >= 0)
{
Reader->FilePos += RelPos;
Reader->ReadPos += RelPos;
return ERR_NONE;
}
}
}
if (!Reader->Input)
return ERR_NOT_SUPPORTED;
if (Origin == SEEK_CUR)
{
// input is at a different position already, using SEEK_SET
Origin = SEEK_SET;
Pos += Reader->FilePos;
}
if (Origin == SEEK_SET)
{
// align reading for local files
Adjust = Pos & (Reader->Format->FileAlign-1);
Pos &= ~(Reader->Format->FileAlign-1);
}
LockEnter(Reader->Format->InputLock);
Pos = Reader->Input->Seek(Reader->Input,Pos,Origin);
if (Pos < 0)
{
LockLeave(Reader->Format->InputLock);
return ERR_NOT_SUPPORTED;
}
// query again file size, because http could have reopened connection
if (Reader->Input->Get(Reader->Input,STREAM_LENGTH,&Reader->Format->FileSize,sizeof(Reader->Format->FileSize)) != ERR_NONE)
Reader->Format->FileSize = -1;
Format_ReleaseBuffers(Reader);
Reader->FilePos = Pos + Adjust;
Reader->ReadPos += Adjust;
LockLeave(Reader->Format->InputLock);
return ERR_NONE;
}
static bool_t Reader_Eof(format_reader* p)
{
return !p->BufferAvailable && !p->ReadBuffer && p->NoMoreInput;
}
static int Reader_Read(format_reader* p, void* Data, int Length0)
{
uint8_t* Ptr = (uint8_t*)Data;
int Length = Length0;
int n;
while (Length > 0)
{
while (!p->ReadBuffer || p->ReadPos >= p->ReadLen)
if (!p->GetReadBuffer(p))
return Length0 - Length;
n = p->ReadLen - p->ReadPos;
if (n > Length)
n = Length;
memcpy(Ptr,p->ReadBuffer->Block.Ptr+p->ReadPos,n);
Ptr += n;
Length -= n;
p->FilePos += n;
p->ReadPos += n;
}
return Length0;
}
static int Reader_Read8(format_reader* p)
{
while (!p->ReadBuffer || p->ReadPos >= p->ReadLen)
if (!p->GetReadBuffer(p))
return -1;
p->FilePos++;
return p->ReadBuffer->Block.Ptr[p->ReadPos++];
}
static int Reader_ReadBE16(format_reader* p)
{
int v = Reader_Read8(p) << 8;
v |= Reader_Read8(p);
return v;
}
static int Reader_ReadLE16(format_reader* p)
{
int v = Reader_Read8(p);
v |= Reader_Read8(p) << 8;
return v;
}
static int Reader_ReadBE32(format_reader* p)
{
int v = Reader_Read8(p) << 24;
v |= Reader_Read8(p) << 16;
v |= Reader_Read8(p) << 8;
v |= Reader_Read8(p);
return v;
}
static int Reader_ReadLE32(format_reader* p)
{
int v = Reader_Read8(p);
v |= Reader_Read8(p) << 8;
v |= Reader_Read8(p) << 16;
v |= Reader_Read8(p) << 24;
return v;
}
static int64_t Reader_ReadBE64(format_reader* p)
{
int64_t v = (int64_t)Reader_ReadBE32(p) << 32;
v |= (uint32_t)Reader_ReadBE32(p);
return v;
}
static int64_t Reader_ReadLE64(format_reader* p)
{
int64_t v = (uint32_t)Reader_ReadLE32(p);
v |= (int64_t)Reader_ReadLE32(p) << 32;
return v;
}
static NOINLINE int GetRate(format_reader* p,format_reader* Last)
{
int64_t Rate;
if (p->NoMoreInput)
return MAX_INT;
if (p->BufferAvailable <= PROCESSMINVIDEO)
return -MAX_INT;
Rate = (int64_t)p->Ratio * (p->BufferAvailable - (p==Last?READER_BONUS:0));
if (Rate > MAX_INT)
return MAX_INT;
return (int)Rate;
}
static int Format_ReadInput(format_base* p,int BufferMax,int* BufferUsed)
{
int No;
int Left,Length;
int Result = ERR_NONE;
format_buffer* Buffer;
format_reader* Reader;
int Used = p->BufferUsed;
// simple estimate test without locking BufferUsed
if (Used >= BufferMax)
{
*BufferUsed = Used;
return ERR_BUFFER_FULL;
}
LockEnter(p->InputLock);
LockEnter(p->BufferLock);
// select which reader to use
Reader = p->Reader;
if (p->Reader[1].Input)
{
int Lowest = GetRate(Reader,p->LastRead);
for (No=1;No<MAXREADER;++No)
{
format_reader* r = p->Reader+No;
if (r->Ratio > 0)
{
int Rate = GetRate(r,p->LastRead);
if (Lowest > Rate)
{
Lowest = Rate;
Reader = r;
}
}
}
p->LastRead = Reader;
}
Buffer = Reader->InputBuffer;
if (!Buffer)
{
// allocate input buffer
if (p->BufferUsed < BufferMax) // check again (BufferUsed is locked)
{
Buffer = Format_BufferAlloc(p,0);
if (p->BufferUsed >= BufferMax)
Result = ERR_BUFFER_FULL;
}
if (!Buffer)
{
*BufferUsed = p->BufferUsed;
LockLeave(p->BufferLock);
LockLeave(p->InputLock);
return ERR_BUFFER_FULL;
}
#ifndef NDEBUG
Buffer->FilePos = Reader->Input->Seek(Reader->Input,0,SEEK_CUR);
#endif
}
*BufferUsed = p->BufferUsed;
LockLeave(p->BufferLock);
Left = BLOCKSIZE - Buffer->Length;
if (Left > p->ReadSize)
Left = p->ReadSize;
if (Reader->Input->DataAvailable)
{
int Available = Reader->Input->DataAvailable(Reader->Input);
if (Available>=0)
{
if (!Available)
{
if (!Reader->InputBuffer)
Format_BufferRelease(Reader->Format,Buffer);
LockLeave(p->InputLock);
return ERR_NEED_MORE_DATA;
}
if (Left > Available)
Left = Available;
}
}
Length = Reader->Input->ReadBlock(Reader->Input,&Buffer->Block,Buffer->Length,Left);
if (Length < 0)
{
// failed
if (!Reader->InputBuffer)
Format_BufferRelease(Reader->Format,Buffer);
Result = ERR_DEVICE_ERROR;
}
else
{
Buffer->Length += Length;
Reader->NoMoreInput = Length == 0;
if (!Length)
{
// only return end of file if all readers are at the end
Result = ERR_END_OF_FILE;
for (No=0;No<MAXREADER;++No)
{
if (!p->Reader[No].Input)
break;
if (!p->Reader[No].NoMoreInput)
{
Result = ERR_NONE;
break;
}
}
}
if (!Length && !Reader->InputBuffer)
Format_BufferRelease(Reader->Format,Buffer);
else
{
if (!Length || Buffer->Length == BLOCKSIZE || p->ProcessMinBuffer==0)
{
LockEnter(p->BufferLock);
Format_BufferInsert(Reader,Buffer);
LockLeave(p->BufferLock);
Buffer = NULL;
}
Reader->InputBuffer = Buffer;
}
}
LockLeave(p->InputLock);
return Result;
}
static NOINLINE void UpdateTotalCount(format_base* p)
{
p->TotalCount = p->StreamCount;
if (p->SubTitle)
p->Streams[p->TotalCount++] = p->SubTitle;
if (p->CoverArt)
p->Streams[p->TotalCount++] = p->CoverArt;
}
static NOINLINE void ReadCoverArt(format_base* p,stream* Input,filepos_t Pos,int Len,const tchar_t* ContentType,const tchar_t* URL)
{
uint8_t Probe[512];
int ProbeLen;
Input->Seek(Input,Pos,SEEK_SET);
ProbeLen = Input->Read(Input,Probe,min(Len,sizeof(Probe)));
if (ProbeLen>0)
{
int *i;
array List;
NodeEnumClassEx(&List,RAWIMAGE_CLASS,ContentType,URL,Probe,ProbeLen);
for (i=ARRAYBEGIN(List,int);i!=ARRAYEND(List,int);++i)
{
const tchar_t* Format = LangStr(*i,RAWIMAGE_FORMAT);
if (tcsnicmp(Format,T("vcodec/"),7)==0)
{
format_stream* s = (format_stream*) malloc(sizeof(format_stream));
if (!s)
return;
memset(s,0,sizeof(format_stream));
s->Format.Type = PACKET_VIDEO;
s->Format.Format.Video.Pixel.Flags = PF_FOURCC|PF_NOPREROTATE;
s->Format.Format.Video.Pixel.FourCC = StringToFourCC(Format+7,1);
if (Format_AllocBufferBlock(p,s,Len))
{
WriteBlock(&s->BufferBlock,0,Probe,ProbeLen);
s->Packet.Length = ProbeLen;
if (Len>ProbeLen)
s->Packet.Length += Input->ReadBlock(Input,&s->BufferBlock,ProbeLen,Len-ProbeLen);
}
if (s->Packet.Length>0)
{
s->Packet.Data[0] = s->BufferBlock.Ptr;
s->Packet.Key = 1;
s->Packet.RefTime = 0;
p->CoverArt = s;
UpdateTotalCount(p);
Format_PrepairStream(p,s);
}
else
Format_FreeStream(p,s);
break;
}
}
ArrayClear(&List);
}
}
static NOINLINE bool_t GetNonStreamingURL(format_base* p,tchar_t* URL,int URLLen,bool_t Local)
{
bool_t HasHost;
int Length;
stream* Input = p->Reader->Input;
if (!Input)
return 0;
LockEnter(p->InputLock);
if (Input->Get(Input,STREAM_URL,URL,URLLen*sizeof(tchar_t)) != ERR_NONE)
URL[0] = 0;
if (Input->Get(Input,STREAM_LENGTH,&Length,sizeof(Length)) != ERR_NONE)
Length = -1;
LockLeave(p->InputLock);
if (!URL[0])
return 0; //no URL?
GetMime(URL,NULL,0,&HasHost);
if (HasHost && (Local || Length<0))
return 0; //non local or streaming
return 1;
}
static NOINLINE bool_t OpenCoverAtr(format_base* p, const tchar_t* Base, const tchar_t* Name)
{
tchar_t Path[MAXPATH];
int Length;
stream* Input;
AbsPath(Path,TSIZEOF(Path),Name,Base);
if (FileExits(Path) && (Input = GetStream(Path,1))!=NULL)
{
//todo: cache global cover art...
if (Input->Set(Input,STREAM_URL,Path,sizeof(tchar_t)*(tcslen(Path)+1)) == ERR_NONE &&
Input->Get(Input,STREAM_LENGTH,&Length,sizeof(Length)) == ERR_NONE)
ReadCoverArt(p,Input,0,Length,NULL,Path);
Input->Set(Input,STREAM_URL,NULL,0);
NodeDelete((node*)Input);
}
return p->CoverArt != NULL;
}
static NOINLINE void FindCoverArt(format_base* p)
{
tchar_t Value[MAXPATH];
if (p->Comment.Node && NodeIsClass(p->Comment.Node->Class,PLAYER_ID) &&
((player*)p->Comment.Node)->CommentByName(p->Comment.Node,-1,PlayerComment(COMMENT_COVER),Value,TSIZEOF(Value)))
{
tchar_t* SPos = tcschr(Value,':');
tchar_t* SLen = SPos?tcschr(SPos+1,':'):NULL;
tchar_t* ContentType = SLen?tcschr(SLen+1,':'):NULL;
int Pos = SPos ? StringToInt(SPos+1,0):0;
int Len = SLen ? StringToInt(SLen+1,0):0;
if (ContentType && Len>0)
{
stream* Input = p->Reader->Input;
filepos_t SavePos;
LockEnter(p->InputLock);
SavePos = Input->Seek(Input,0,SEEK_CUR);
if (SavePos >= 0)
{
if (*(++ContentType)==0)
ContentType = NULL;
ReadCoverArt(p,Input,Pos,Len,ContentType,NULL);
Input->Seek(Input,SavePos,SEEK_SET);
}
LockLeave(p->InputLock);
}
}
else if (NodeIsClass(p->Format.Class,RAWAUDIO_CLASS) && GetNonStreamingURL(p,Value,TSIZEOF(Value),1))
{
tchar_t Base[MAXPATH];
SplitURL(Value,Base,TSIZEOF(Base),Base,TSIZEOF(Base),NULL,0,NULL,0);
if (!OpenCoverAtr(p,Base,T("cover.jpg")) &&
!OpenCoverAtr(p,Base,T("folder.jpg")) &&
!OpenCoverAtr(p,Base,T("front.jpg")) &&
!OpenCoverAtr(p,Base,T("coverart.jpg")));
}
}
static void FindSubtitles(format_base* p)
{
/*
//!SUBTITLE
tchar_t* SubExt[] = { T("sub"),T("str"),T("smi"), NULL };
tchar_t** s;
tchar_t URL[MAXPATH];
if (!GetNonStreamingURL(p,URL,TSIZEOF(URL),0))
return;
for (s=SubExt;*s && !p->SubTitle;++s)
if (SetFileExt(URL,TSIZEOF(URL),*s))
{
stream* Input = GetStream(URL,1);
if (Input)
{
bool_t Silent = 1;
Input->Set(Input,STREAM_SILENT,&Silent,sizeof(Silent));
if (Input->Set(Input,STREAM_URL,URL,sizeof(tchar_t)*(tcslen(URL)+1)) == ERR_NONE)
{
p->SubTitle = Format_LoadSubTitle(p,Input);
if (p->SubTitle)
{
UpdateTotalCount(p);
Format_PrepairStream(p,(format_stream*)p->SubTitle);
}
}
Input->Delete(Input);
}
}
*/
}
void Format_PrepairStream(format_base* p,format_stream* Stream)
{
switch (Stream->Format.Type)
{
case PACKET_VIDEO: Stream->PacketBurst = VIDEO_BURST; break;
case PACKET_AUDIO: Stream->PacketBurst = AUDIO_BURST; break;
case PACKET_SUBTITLE: Stream->PacketBurst = 1; break;
}
if (p->ProcessMinBuffer)
p->ProcessMinBuffer = IsVideo(p) ? PROCESSMINVIDEO:PROCESSMINAUDIO;
if (Stream->Format.Type == PACKET_AUDIO && Stream->Format.Format.Audio.Format == AUDIOFMT_PCM)
{
// there could be alignement problems (with memory and with audio.BlockSize)
Stream->Fragmented = 0;
Stream->ForceMerge = 1;
}
if (p->UpdateStreams.Func)
p->UpdateStreams.Func(p->UpdateStreams.This,0,0);
if (Stream->Format.Type == PACKET_VIDEO && p->NeedSubtitles)
{
p->NeedSubtitles = 0;
FindSubtitles(p);
}
}
static NOINLINE void DefaultPalette(packetformat* p)
{
if (p->Format.Video.Pixel.BitCount >= 1 &&
p->Format.Video.Pixel.BitCount <= 8 &&
p->ExtraLength >= (4 << p->Format.Video.Pixel.BitCount))
p->Format.Video.Pixel.Palette = p->Extra;
}
int Format_BitmapInfoMem(format_stream* s,void* Data,int Length)
{
if (Length>=4)
{
char* p = (char*)Data;
int Size = INT32LE(*(int32_t*)p);
if (Length >= Size)
{
PacketFormatClear(&s->Format);
s->Format.Type = PACKET_VIDEO;
s->Format.Format.Video.Width = INT32LE(*(int32_t*)(p+4));
s->Format.Format.Video.Height = INT32LE(*(int32_t*)(p+8));
s->Format.Format.Video.Pixel.BitCount = INT16LE(*(int16_t*)(p+14));
s->Format.Format.Video.Pixel.FourCC = INT32LE(*(int32_t*)(p+16));
s->Format.Format.Video.Aspect = ASPECT_ONE; //todo
if (PacketFormatExtra(&s->Format,Size-40))
{
memcpy(s->Format.Extra,p+40,s->Format.ExtraLength);
DefaultPalette(&s->Format);
}
PacketFormatDefault(&s->Format);
}
else
Size = 4;
Length -= Size;
}
return Length;
}
void Format_BitmapInfo(format_reader* p,format_stream* s,int Length)
{
if (Length>=4)
{
int Size = p->ReadLE32(p); //size
if (Length >= Size)
{
PacketFormatClear(&s->Format);
s->Format.Type = PACKET_VIDEO;
s->Format.Format.Video.Width = p->ReadLE32(p);
s->Format.Format.Video.Height = p->ReadLE32(p);
p->ReadLE16(p); //planes
s->Format.Format.Video.Pixel.BitCount = p->ReadLE16(p);
s->Format.Format.Video.Pixel.FourCC = p->ReadLE32(p);
s->Format.Format.Video.Aspect = ASPECT_ONE; //todo
p->Skip(p,20); //SizeImage,XPelsPerMeter,YPelsPerMeter,ClrUsed,ClrImportant
if (PacketFormatExtra(&s->Format,Size-40))
{
p->Read(p,s->Format.Extra,s->Format.ExtraLength);
DefaultPalette(&s->Format);
}
PacketFormatDefault(&s->Format);
}
else
Size = 4;
Length -= Size;
}
p->Skip(p,Length);
}
int Format_WaveFormatMem(format_stream* s,void* Data,int Length)
{
if (Length >= 16)
{
char* p = (char*)Data;
PacketFormatClear(&s->Format);
s->Format.Type = PACKET_AUDIO;
s->Format.Format.Audio.Format = INT16LE(*(int16_t*)(p+0));
s->Format.Format.Audio.Channels =INT16LE(*(int16_t*)(p+2));
s->Format.Format.Audio.SampleRate = INT32LE(*(int32_t*)(p+4));
s->Format.ByteRate = INT32LE(*(int32_t*)(p+8));
s->Format.Format.Audio.BlockAlign = INT16LE(*(int16_t*)(p+12));
s->Format.Format.Audio.Bits = INT16LE(*(int16_t*)(p+14));
Length -= 16;
if (Length >= 2)
{
int Extra = INT16LE(*(int16_t*)(p+16));
Length -= 2;
if (Extra > 0 && Length >= Extra)
{
if (PacketFormatExtra(&s->Format,Extra))
memcpy(s->Format.Extra,p+18,s->Format.ExtraLength);
Length -= Extra;
}
}
PacketFormatDefault(&s->Format);
}
return Length;
}
void Format_WaveFormat(format_reader* p,format_stream* s,int Length)
{
if (Length >= 16)
{
PacketFormatClear(&s->Format);
s->Format.Type = PACKET_AUDIO;
s->Format.Format.Audio.Format = p->ReadLE16(p);
s->Format.Format.Audio.Channels = p->ReadLE16(p);
s->Format.Format.Audio.SampleRate = p->ReadLE32(p);
s->Format.ByteRate = p->ReadLE32(p);
s->Format.Format.Audio.BlockAlign = p->ReadLE16(p);
s->Format.Format.Audio.Bits = p->ReadLE16(p);
Length -= 16;
if (Length >= 2)
{
int Extra = p->ReadLE16(p);
Length -= 2;
if (Extra > 0 && Length >= Extra)
{
if (PacketFormatExtra(&s->Format,Extra))
p->Read(p,s->Format.Extra,s->Format.ExtraLength);
Length -= Extra;
}
}
PacketFormatDefault(&s->Format);
}
p->Skip(p,Length);
}
void Format_RemoveStream(format_base* p)
{
if (p->StreamCount)
{
format_stream* Stream = p->Streams[--p->StreamCount];
UpdateTotalCount(p);
if (p->FreeStream)
p->FreeStream(p,Stream);
Format_FreeStream(p,Stream);
}
}
format_stream* Format_AddStream(format_base* p, int Length)
{
format_stream* s;
if (p->StreamCount >= MAXSTREAM-1-1) //subtitle,coverart
return NULL;
s = (format_stream*) malloc(Length);
if (!s)
return NULL;
memset(s,0,Length);
s->Reader = p->Reader; // default
s->No = p->StreamCount;
s->LastTime = TIME_SYNC;
p->Streams[p->StreamCount++] = s;
UpdateTotalCount(p);
return s;
}
static int Create(format_base* p)
{
int No;
format_reader* Reader = p->Reader;
for (No=0;No<MAXREADER;++No,++Reader)
{
Reader->Format = p;
Reader->Seek = Reader_Seek;
Reader->Eof = Reader_Eof;
Reader->Skip = Reader_Skip;
Reader->Read = Reader_Read;
Reader->Read8 = Reader_Read8;
Reader->ReadLE16 = Reader_ReadLE16;
Reader->ReadBE16 = Reader_ReadBE16;
Reader->ReadLE32 = Reader_ReadLE32;
Reader->ReadBE32 = Reader_ReadBE32;
Reader->ReadLE64 = Reader_ReadLE64;
Reader->ReadBE64 = Reader_ReadBE64;
Reader->ReadAsRef = Reader_ReadAsRef;
Reader->GetReadBuffer = Reader_GetReadBuffer;
}
p->Format.Enum = (nodeenum)FormatBaseEnum;
p->Format.Get = (nodeget)FormatBaseGet;
p->Format.Set = (nodeset)FormatBaseSet;
p->Format.Sync = (fmtsync)Format_Sync;
p->Format.Read = (fmtread)Format_ReadInput;
p->Format.Process = (fmtprocess)Format_Process;
p->FillQueue = (fmtfill)Format_FillQueue;
p->Process = (fmtstreamprocess)Format_ProcessStream;
p->Sended = (fmtstream)Format_Sended;
p->FileAlign = 1;
p->Timing = 1;
p->MinHeaderLoad = BLOCKSIZE;
#ifdef TARGET_PALMOS
p->UseBufferBlock = Context()->LowMemory;
#endif
return ERR_NONE;
}
static const nodedef FormatBase =
{
sizeof(format_base)|CF_ABSTRACT,
FORMATBASE_CLASS,
FORMAT_CLASS,
PRI_DEFAULT,
(nodecreate)Create,
};
void FormatBase_Init()
{
NodeRegisterClass(&FormatBase);
}
void FormatBase_Done()
{
NodeUnRegisterClass(FORMATBASE_CLASS);
}
Reference in New Issue View Git Blame Copy Permalink