293 lines
6.6 KiB
C
Executable File
293 lines
6.6 KiB
C
Executable File
/*****************************************************************************
|
|
*
|
|
* 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: mpg.c 607 2006-01-22 20:58:29Z picard $
|
|
*
|
|
* The Core Pocket Media Player
|
|
* Copyright (c) 2004-2005 Gabor Kovacs
|
|
*
|
|
****************************************************************************/
|
|
|
|
#include "../common/common.h"
|
|
#include "mpg.h"
|
|
|
|
typedef struct mpeg
|
|
{
|
|
format_base Format;
|
|
bool_t ErrorShowed;
|
|
|
|
} mpeg;
|
|
|
|
static int Init(mpeg* p)
|
|
{
|
|
p->Format.TimeStamps = 1;
|
|
p->Format.StartTime = 0;
|
|
p->ErrorShowed = 0;
|
|
return ERR_NONE;
|
|
}
|
|
|
|
static int findcode(format_reader* p)
|
|
{
|
|
int n;
|
|
int32_t code = -1;
|
|
for (n=0;n<0x4000;++n)
|
|
{
|
|
int v = p->Read8(p);
|
|
if (v<0)
|
|
break;
|
|
code = (code<<8)|v;
|
|
if ((code >> 8)==1)
|
|
return code;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static int64_t readtime(format_reader* p,int i)
|
|
{
|
|
int64_t t;
|
|
t = (int64_t)((i >> 1) & 0x07) << 30;
|
|
t |= (p->ReadBE16(p) >> 1) << 15;
|
|
t |= (p->ReadBE16(p) >> 1);
|
|
return t;
|
|
}
|
|
|
|
static int ReadPacket(mpeg* p, format_reader* Reader, format_packet* Packet)
|
|
{
|
|
format_stream* s;
|
|
int PCM = 0;
|
|
int code = findcode(Reader);
|
|
int i;
|
|
int64_t time;
|
|
filepos_t end;
|
|
|
|
if (code == 0x1BE || code == 0x1BF)
|
|
{
|
|
i = Reader->ReadBE16(Reader);
|
|
Reader->Skip(Reader,i);
|
|
return ERR_NONE;
|
|
}
|
|
|
|
if (code != 0x1BD && (code<0x1C0 || code>=0x1F0))
|
|
return ERR_NONE;
|
|
|
|
end = Reader->ReadBE16(Reader);
|
|
end += Reader->FilePos;
|
|
time = -1;
|
|
|
|
while ((i = Reader->Read8(Reader))==255)
|
|
if (Reader->FilePos >= end)
|
|
return ERR_NONE;
|
|
|
|
if ((i>>6)==1)
|
|
{
|
|
Reader->Read8(Reader);
|
|
i = Reader->Read8(Reader);
|
|
}
|
|
|
|
if ((i>>5)==1)
|
|
{
|
|
time = readtime(Reader,i);
|
|
if (i&16)
|
|
time = readtime(Reader,Reader->Read8(Reader));
|
|
}
|
|
else
|
|
if ((i>>6)==2)
|
|
{
|
|
filepos_t end2;
|
|
|
|
if ((i>>4)!=8)
|
|
{
|
|
if (!p->ErrorShowed)
|
|
{
|
|
p->ErrorShowed = 1;
|
|
ShowError(p->Format.Format.Class,MPG_ID,MPG_ENCRYPTED);
|
|
}
|
|
return ERR_END_OF_FILE;
|
|
}
|
|
|
|
i = Reader->Read8(Reader);
|
|
end2 = Reader->Read8(Reader);
|
|
end2 += Reader->FilePos;
|
|
|
|
if (end2 > end)
|
|
return ERR_NONE;
|
|
|
|
if (i&128)
|
|
{
|
|
time = readtime(Reader,Reader->Read8(Reader));
|
|
if (i&64)
|
|
time = readtime(Reader,Reader->Read8(Reader));
|
|
}
|
|
|
|
Reader->Skip(Reader,end2-Reader->FilePos);
|
|
}
|
|
|
|
if (code == 0x1BD)
|
|
{
|
|
code = Reader->Read8(Reader);
|
|
if (code >= 0x80 && code <= 0xBF)
|
|
Reader->Skip(Reader,3);
|
|
if (code >= 0xA0 && code <= 0xBF)
|
|
{
|
|
Reader->Skip(Reader,1);
|
|
PCM = Reader->Read8(Reader);
|
|
Reader->Skip(Reader,1);
|
|
}
|
|
}
|
|
|
|
if (time>=0)
|
|
{
|
|
Packet->RefTime = (tick_t)((time * TICKSPERSEC) / 90000) - p->Format.StartTime;
|
|
if (Packet->RefTime < 0)
|
|
Packet->RefTime = 0;
|
|
}
|
|
else
|
|
Packet->RefTime = TIME_UNKNOWN;
|
|
|
|
s = NULL;
|
|
for (i=0;i<p->Format.StreamCount;++i)
|
|
if (p->Format.Streams[i]->Id == code)
|
|
{
|
|
s = p->Format.Streams[i];
|
|
break;
|
|
}
|
|
|
|
if (!s)
|
|
{
|
|
if (Packet->RefTime < 0) //skip
|
|
return ERR_NONE;
|
|
|
|
if (!p->Format.StartTime)
|
|
{
|
|
p->Format.StartTime = Packet->RefTime;
|
|
Packet->RefTime = 0;
|
|
}
|
|
|
|
switch (code>>4)
|
|
{
|
|
case 8:
|
|
case 9:
|
|
s = Format_AddStream(&p->Format,sizeof(format_stream));
|
|
if (s)
|
|
{
|
|
s->Id = code;
|
|
PacketFormatClear(&s->Format);
|
|
s->Format.Type = PACKET_AUDIO;
|
|
s->Format.Format.Audio.Format = AUDIOFMT_A52;
|
|
Format_PrepairStream(&p->Format,s);
|
|
}
|
|
break;
|
|
case 10:
|
|
case 11:
|
|
s = Format_AddStream(&p->Format,sizeof(format_stream));
|
|
if (s)
|
|
{
|
|
static const int Freq[4] = { 48000, 96000, 44100, 32000 };
|
|
s->Id = code;
|
|
PacketFormatClear(&s->Format);
|
|
s->Format.Type = PACKET_AUDIO;
|
|
s->Format.Format.Audio.Format = AUDIOFMT_PCM;
|
|
s->Format.Format.Audio.SampleRate = Freq[(PCM >> 4) & 3];
|
|
s->Format.Format.Audio.Channels = 1 + (PCM & 7);
|
|
s->Format.Format.Audio.Bits = 16;
|
|
s->Format.Format.Audio.FracBits = 15;
|
|
s->Format.ByteRate = s->Format.Format.Audio.SampleRate * s->Format.Format.Audio.Channels * 2;
|
|
Format_PrepairStream(&p->Format,s);
|
|
}
|
|
break;
|
|
case 28:
|
|
case 29:
|
|
s = Format_AddStream(&p->Format,sizeof(format_stream));
|
|
if (s)
|
|
{
|
|
s->Id = code;
|
|
PacketFormatClear(&s->Format);
|
|
s->Format.Type = PACKET_AUDIO;
|
|
s->Format.Format.Audio.Format = AUDIOFMT_MP2;
|
|
Format_PrepairStream(&p->Format,s);
|
|
}
|
|
break;
|
|
case 30:
|
|
s = Format_AddStream(&p->Format,sizeof(format_stream));
|
|
if (s)
|
|
{
|
|
// minimal mpeg4 detection
|
|
int32_t code1 = 0;
|
|
int32_t code2 = 0;
|
|
filepos_t pos = Reader->FilePos;
|
|
if (end >= pos+8)
|
|
{
|
|
code1 = Reader->ReadBE32(Reader);
|
|
if (code1 == 0x100)
|
|
code2 = Reader->ReadBE32(Reader);
|
|
Reader->Seek(Reader,pos,SEEK_SET);
|
|
}
|
|
|
|
s->Id = code;
|
|
PacketFormatClear(&s->Format);
|
|
s->Format.Type = PACKET_VIDEO;
|
|
s->Format.Format.Video.Pixel.Flags = PF_FOURCC | PF_FRAGMENTED;
|
|
if ((code1 == 0x100 && code2 == 0x120) || code1 == 0x120)
|
|
s->Format.Format.Video.Pixel.FourCC = FOURCC('M','P','4','V');
|
|
else
|
|
s->Format.Format.Video.Pixel.FourCC = FOURCC('M','P','E','G');
|
|
Format_PrepairStream(&p->Format,s);
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (!s)
|
|
{
|
|
Reader->Skip(Reader,end - Reader->FilePos);
|
|
return ERR_NONE;
|
|
}
|
|
}
|
|
|
|
Packet->Stream = s;
|
|
Packet->Data = Reader->ReadAsRef(Reader,end - Reader->FilePos);
|
|
return ERR_NONE;
|
|
}
|
|
|
|
static int Create(mpeg* p)
|
|
{
|
|
p->Format.Init = (fmtfunc)Init;
|
|
p->Format.Seek = (fmtseek)Format_SeekByPacket;
|
|
p->Format.ReadPacket = (fmtreadpacket)ReadPacket;
|
|
p->Format.MinHeaderLoad = MINBUFFER/2;
|
|
return ERR_NONE;
|
|
}
|
|
|
|
static const nodedef MPG =
|
|
{
|
|
sizeof(mpeg),
|
|
MPG_ID,
|
|
FORMATBASE_CLASS,
|
|
PRI_DEFAULT-10, // lower priority so others can override
|
|
(nodecreate)Create,
|
|
NULL,
|
|
};
|
|
|
|
void MPG_Init()
|
|
{
|
|
NodeRegisterClass(&MPG);
|
|
}
|
|
|
|
void MPG_Done()
|
|
{
|
|
NodeUnRegisterClass(MPG_ID);
|
|
}
|
|
|