Author: fejj
Date: 2008-01-14 16:25:27 -0500 (Mon, 14 Jan 2008)
New Revision: 92904
Modified:
trunk/moon/src/ChangeLog
trunk/moon/src/pipeline.cpp
trunk/moon/src/pipeline.h
Log:
2008-01-14 Jeffrey Stedfast <[EMAIL PROTECTED]>
* pipeline.cpp: Partially implemented an mp3 demuxer.
Modified: trunk/moon/src/ChangeLog
===================================================================
--- trunk/moon/src/ChangeLog 2008-01-14 21:11:18 UTC (rev 92903)
+++ trunk/moon/src/ChangeLog 2008-01-14 21:25:27 UTC (rev 92904)
@@ -1,3 +1,7 @@
+2008-01-14 Jeffrey Stedfast <[EMAIL PROTECTED]>
+
+ * pipeline.cpp: Partially implemented an mp3 demuxer.
+
2008-01-14 Rolf Bjarne Kvinge <[EMAIL PROTECTED]>
* media.cpp, media.h, mplayer2.cpp, pipeline.cpp, pipeline.h: Make
markers
Modified: trunk/moon/src/pipeline.cpp
===================================================================
--- trunk/moon/src/pipeline.cpp 2008-01-14 21:11:18 UTC (rev 92903)
+++ trunk/moon/src/pipeline.cpp 2008-01-14 21:25:27 UTC (rev 92904)
@@ -119,6 +119,7 @@
Media::Initialize ()
{
// register stuff
+ //Media::RegisterDemuxer (new Mp3DemuxerInfo ());
Media::RegisterDemuxer (new ASFDemuxerInfo ());
#ifdef INCLUDE_FFMPEG
register_ffmpeg ();
@@ -147,16 +148,13 @@
}
registered_demuxers = NULL;
-
current = registered_converters;
while (current != NULL) {
next = current->next;
delete current;
current = next;
}
- registered_converters = NULL;
-
-
+ registered_converters = NULL;
}
void
@@ -247,35 +245,25 @@
MediaResult
Media::Open (IMediaSource* source)
{
+ MediaResult result;
+
printf ("Media::Open ().\n");
- MediaResult result = MEDIA_FAIL; // We return success if at least 1
stream could be opened correctly (has decoder and, if applicable, converter)
-
- if (source == NULL) {
+ if (source == NULL)
return MEDIA_INVALID_ARGUMENT;
- }
// Select a demuxer
- uint8_t buffer [16];
- if (!source->Peek (&buffer [0], 16)) {
- return MEDIA_FAIL;
- }
+ DemuxerInfo *demuxerInfo = registered_demuxers;
+ while (demuxerInfo != NULL && !demuxerInfo->Supports (source))
+ demuxerInfo = (DemuxerInfo *) demuxerInfo->next;
- DemuxerInfo* current_demuxer = registered_demuxers;
- while (current_demuxer != NULL && !current_demuxer->Supports (&buffer
[0], 16)) {
- printf ("Checking registered demuxer '%s' if it supports the
media file '%s': no.\n", current_demuxer->GetName (), file_or_url);
- current_demuxer = (DemuxerInfo*) current_demuxer->next;
- }
-
- if (current_demuxer == NULL) {
+ if (demuxerInfo == NULL) {
AddMessage (MEDIA_UNKNOWN_MEDIA_TYPE, g_strdup_printf ("No
demuxers registered to handle the media file '%s'.", file_or_url));
return MEDIA_UNKNOWN_MEDIA_TYPE;
- } else {
- printf ("Checking registered demuxer '%s' if it supports the
media file '%s': yes.\n", current_demuxer->GetName (), file_or_url);
- demuxer = current_demuxer->Create (this);
}
// Found a demuxer
+ demuxer = demuxerInfo->Create (this);
result = demuxer->ReadHeader ();
if (!MEDIA_SUCCEEDED (result)) {
@@ -323,8 +311,8 @@
if (decoder != NULL) {
// Select converter for this stream
if (stream->GetType () == MediaTypeVideo &&
decoder->pixel_format != MoonPixelFormatRGB32) {
- VideoStream* vs = (VideoStream*) stream;
- IImageConverter* converter;
+ VideoStream *vs = (VideoStream *) stream;
+ IImageConverter *converter = NULL;
ConverterInfo* current_conv =
registered_converters;
while (current_conv != NULL &&
!current_conv->Supports (decoder->pixel_format, MoonPixelFormatRGB32)) {
@@ -533,32 +521,33 @@
* ASFDemuxer
*/
-ASFDemuxer::ASFDemuxer (Media* media) : IMediaDemuxer (media),
- parser (NULL), reader (NULL)
+ASFDemuxer::ASFDemuxer (Media* media) : IMediaDemuxer (media)
{
+ stream_to_asf_index = NULL;
+ reader = NULL;
+ parser = NULL;
}
ASFDemuxer::~ASFDemuxer ()
{
- delete reader;
- reader = NULL;
+ g_free (stream_to_asf_index);
- delete parser;
- parser = NULL;
+ if (reader)
+ delete reader;
- g_free (stream_to_asf_index);
- stream_to_asf_index = NULL;
+ if (parser)
+ delete parser;
}
MediaResult
ASFDemuxer::Seek (guint64 pts)
{
- if (reader == NULL) {
+ if (reader == NULL)
reader = new ASFFrameReader (parser);
- }
if (reader->Seek (0, pts))
return MEDIA_SUCCESS;
+
return MEDIA_FAIL;
}
@@ -827,9 +816,8 @@
{
//printf ("ASFDemuxer::ReadFrame (%p).\n", frame);
- if (reader == NULL) {
+ if (reader == NULL)
reader = new ASFFrameReader (parser);
- }
//printf ("ASFDemuxer::ReadFrame (%p) frame = ", frame);
//frame->printf ();
@@ -876,25 +864,336 @@
*/
bool
-ASFDemuxerInfo::Supports (uint8_t* buffer, uint32_t length)
+ASFDemuxerInfo::Supports (IMediaSource *source)
{
- if (length < 16)
+ uint8_t buffer[16];
+
+ if (!source->Peek (buffer, 16))
return false;
-
- bool result = asf_guid_compare (&asf_guids_header, (asf_guid*) buffer);
-
- printf ("ASFDemuxerInfo::Supports (%p, %u): probing result: %s\n",
buffer, length, result ? "true" : "false");
+ bool result = asf_guid_compare (&asf_guids_header, (asf_guid *) buffer);
+
+ printf ("ASFDemuxerInfo::Supports (%p): probing result: %s\n", source,
+ result ? "true" : "false");
+
return result;
}
-IMediaDemuxer*
+IMediaDemuxer *
ASFDemuxerInfo::Create (Media* media)
{
return new ASFDemuxer (media);
-}
+}
+
/*
+ * Mp3Demuxer
+ */
+
+Mp3Demuxer::Mp3Demuxer (Media *media) : IMediaDemuxer (media)
+{
+ //reader = NULL;
+}
+
+Mp3Demuxer::~Mp3Demuxer ()
+{
+ //if (reader)
+ // delete reader;
+}
+
+MediaResult
+Mp3Demuxer::Seek (guint64 pts)
+{
+ //if (reader == NULL)
+ // reader = new Mp3FrameReader (parser);
+
+ //if (reader->Seek (0, pts))
+ // return MEDIA_SUCCESS;
+
+ return MEDIA_FAIL;
+}
+
+
+struct MpegFrameHeader {
+ uint8_t version;
+ uint8_t layer;
+
+ uint8_t padded;
+ uint8_t prot;
+
+ int bit_rate;
+ int sample_rate;
+ int8_t channels;
+};
+
+static int mpeg1_bitrates[3][15] = {
+ /* version 1, layer 1 */
+ { 0, 32, 48, 56, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448
},
+ /* version 1, layer 2 */
+ { 0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384 },
+ /* version 1, layer 3 */
+ { 0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320 },
+};
+
+static int mpeg2_bitrates[3][15] = {
+ /* version 2, layer 1 */
+ { 0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256 },
+ /* version 2, layer 2 */
+ { 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160 },
+ /* version 2, layer 3 */
+ { 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160 }
+};
+
+static int
+mpeg_bitrate (MpegFrameHeader *mpeg, uint8_t bits)
+{
+ int i = (bits & 0xf0) >> 4;
+
+ if (i > 14)
+ return -1;
+
+ if (mpeg->version == 1)
+ mpeg->bit_rate = mpeg1_bitrates[mpeg->layer - 1][i];
+ else
+ mpeg->bit_rate = mpeg2_bitrates[mpeg->layer - 1][i];
+
+ return 0;
+}
+
+static int mpeg_samplerates[2][3] = {
+ { 44100, 48000, 32000 },
+ { 22050, 24000, 16000 }
+};
+
+static int
+mpeg_samplerate (MpegFrameHeader *mpeg, uint8_t bits)
+{
+ int i = bits & 0x0c;
+
+ if (i > 2)
+ return -1;
+
+ mpeg->sample_rate = mpeg_samplerates[mpeg->version - 1][i];
+
+ return 0;
+}
+
+static int
+mpeg_channels (MpegFrameHeader *mpeg, uint8_t bits)
+{
+ int mode = (bits >> 6) & 0x3;
+
+ switch (mode) {
+ case 0: /* stereo */
+ mpeg->channels = 2;
+ break;
+ case 1: /* joint stereo */
+ mpeg->channels = 2;
+ break;
+ case 2: /* dual channel (2 mono channels) */
+ mpeg->channels = 2;
+ break;
+ case 3: /* mono */
+ mpeg->channels = 1;
+ break;
+ }
+
+ return 0;
+}
+
+static int
+mpeg_parse_header (const uint8_t *buffer, MpegFrameHeader *mpeg)
+{
+ /* check that this is a valid MPEG sync header */
+ if (buffer[0] != 0xff || ((buffer[1] & 0xfa) != 0xfa))
+ return -1;
+
+ // extract the MPEG version
+ if (buffer[1] & 0x08)
+ mpeg->version = 1;
+ else
+ mpeg->version = 2;
+
+ // extract the MPEG layer
+ switch (buffer[1] & 0x06) {
+ case 0x02:
+ mpeg->layer = 3;
+ break;
+ case 0x04:
+ mpeg->layer = 2;
+ break;
+ case 0x06:
+ mpeg->layer = 1;
+ break;
+ default: /* 0x00 reserved */
+ return -1;
+ }
+
+ // protection (via 16bit crc) bit
+ mpeg->prot = (buffer[1] & 0x01) == 0 ? 1 : 0;
+
+ // extract the bit rate
+ if (mpeg_bitrate (mpeg, buffer[2]) == -1)
+ return -1;
+
+ // extract the sample rate
+ if (mpeg_samplerate (mpeg, buffer[2]) == -1)
+ return -1;
+
+ // check if the frame is padded
+ mpeg->padded = (buffer[2] & 0x2) ? 1 : 0;
+
+ // extract the channel mode */
+ if (mpeg_channels (mpeg, buffer[3]) == -1)
+ return -1;
+
+ return 0;
+}
+
+MediaResult
+Mp3Demuxer::ReadHeader ()
+{
+ IMediaSource *source = GetMedia ()->GetSource ();
+ IMediaStream **streams = NULL;
+ IMediaStream *stream;
+ MpegFrameHeader mpeg;
+ AudioStream *audio;
+ uint8_t buffer[10];
+ uint32_t size = 0;
+ int stream_count;
+ int i;
+
+ printf ("Mp3Demuxer::ReadHeader ().\n");
+
+ if (!source->Read (buffer, 10))
+ return MEDIA_INVALID_MEDIA;
+
+ // Check for a leading ID3 tag
+ if (!strncmp ((const char *) buffer, "ID3", 3)) {
+ for (i = 0; i < 4; i++) {
+ if (buffer[6 + i] & 0x80)
+ return false;
+
+ size = (size << 7) | buffer[6 + i];
+ }
+
+ if ((buffer[5] & (1 << 4))) {
+ // add additional 10 bytes for footer
+ size += 20;
+ } else
+ size += 10;
+
+ // skip over the ID3 tag
+ if (!source->Seek ((int64_t) size, SEEK_SET))
+ return MEDIA_INVALID_MEDIA;
+
+ if (!source->Read (buffer, 4))
+ return MEDIA_INVALID_MEDIA;
+
+ stream_start = (int64_t) size;
+ } else {
+ stream_start = 0;
+ }
+
+ if (!source->Seek (stream_start, SEEK_SET))
+ return MEDIA_INVALID_MEDIA;
+
+ memset ((void *) &mpeg, 0, sizeof (mpeg));
+ if (mpeg_parse_header (buffer, &mpeg) == -1)
+ return MEDIA_INVALID_MEDIA;
+
+ stream = audio = new AudioStream (GetMedia ());
+ audio->codec_id = CODEC_MP3;
+ audio->codec = "mp3";
+
+ audio->bit_rate = mpeg.bit_rate;
+ audio->channels = mpeg.channels;
+ audio->sample_rate = mpeg.sample_rate;
+ audio->block_align = 0;
+ audio->bits_per_sample = 0;
+ audio->extra_data = NULL;
+ audio->extra_data_size = 0;
+
+ stream->start_time = 0;
+
+ streams = g_new (IMediaStream *, 2);
+ streams[0] = stream;
+ streams[1] = NULL;
+ stream_count = 1;
+
+ SetStreams (streams, stream_count);
+
+ return MEDIA_SUCCESS;
+}
+
+MediaResult
+Mp3Demuxer::ReadFrame (MediaFrame *frame)
+{
+ // FIXME: implement me
+ return MEDIA_SUCCESS;
+}
+
+
+/*
+ * Mp3DemuxerInfo
+ */
+
+bool
+Mp3DemuxerInfo::Supports (IMediaSource *source)
+{
+ uint8_t buffer[10];
+ uint32_t size = 0;
+ int i;
+
+ // peek at the first 10 bytes which is enough to contain
+ // either the mp3 frame header or an ID3 tag header
+ if (!source->Peek (buffer, 10))
+ return false;
+
+ // Check for a leading ID3 tag
+ if (!strncmp ((const char *) buffer, "ID3", 3)) {
+ for (i = 0; i < 4; i++) {
+ if (buffer[6 + i] & 0x80)
+ return false;
+
+ size = (size << 7) | buffer[6 + i];
+ }
+
+ if ((buffer[5] & (1 << 4))) {
+ // add additional 10 bytes for footer
+ size += 20;
+ } else
+ size += 10;
+
+ // skip over the ID3 tag
+ if (!source->Seek (size, SEEK_SET))
+ return false;
+
+ // peek at the mp3 frame header
+ if (!source->Read (buffer, 4))
+ return false;
+
+ if (!source->Seek (0, SEEK_SET))
+ return false;
+ }
+
+ /* validate that this is an MPEG-1 Audio Layer 3 stream by
+ * checking that the 32bit header matches the pattern:
+ *
+ * 1111 1111 1111 101* **** **** **** ****
+ */
+
+ return (buffer[0] == 0xff) && ((buffer[1] & 0xfa) == 0xfa);
+}
+
+IMediaDemuxer *
+Mp3DemuxerInfo::Create (Media *media)
+{
+ return new Mp3Demuxer (media);
+}
+
+
+/*
* FileSource
*/
@@ -936,12 +1235,9 @@
}
// Open the file if it hasn't been opened.
- if (!fd) {
- fd = fopen (filename, "rb");
- if (!fd) {
- media->AddMessage (MEDIA_FILE_ERROR, g_strdup_printf
("Could not open the file '%s': %s.\n", filename, strerror (errno)));
- return false;
- }
+ if (!fd && !(fd = fopen (filename, "rb"))) {
+ media->AddMessage (MEDIA_FILE_ERROR, g_strdup_printf ("Could
not open the file '%s': %s.\n", filename, strerror (errno)));
+ return false;
}
// Read
@@ -1037,7 +1333,7 @@
*/
IMediaStream::IMediaStream (Media* media) :
- extra_data (NULL), extra_data_size (NULL), codec_id (0), start_time (0),
+ extra_data (NULL), extra_data_size (0), codec_id (0), start_time (0),
msec_per_frame (0), duration (0), decoder (NULL), codec (NULL),
min_padding (0),
index (-1), context (NULL)
{
Modified: trunk/moon/src/pipeline.h
===================================================================
--- trunk/moon/src/pipeline.h 2008-01-14 21:11:18 UTC (rev 92903)
+++ trunk/moon/src/pipeline.h 2008-01-14 21:25:27 UTC (rev 92904)
@@ -182,8 +182,8 @@
public:
// <buffer> points to the first <length> bytes of a file.
// <length> is guaranteed to be at least 16 bytes.
- virtual bool Supports (uint8_t* buffer, uint32_t length) = 0;
- virtual IMediaDemuxer* Create (Media* media) = 0;
+ virtual bool Supports (IMediaSource *source) = 0;
+ virtual IMediaDemuxer *Create (Media *media) = 0;
};
class ConverterInfo : public MediaInfo {
@@ -387,14 +387,14 @@
void* GetContext () { return context; }
void SetContext (void* context) { this->context = context; }
- void* extra_data;
+ void *extra_data;
int extra_data_size;
int codec_id;
guint64 start_time;
gint32 msec_per_frame;
guint64 duration;
- IMediaDecoder* decoder;
- const char* codec;
+ IMediaDecoder *decoder;
+ const char *codec;
// The minimum amount of padding any other part of the pipeline needs
for frames from this stream.
// Used by the demuxer when reading frames, ensures that there are at
least min_padding extra bytes
// at the end of the frame data (all initialized to 0).
@@ -405,7 +405,7 @@
private:
bool enabled;
- void* context;
+ void *context;
};
@@ -430,25 +430,24 @@
};
class IMediaDemuxer : public IMediaObject {
+ IMediaStream **streams;
+ int stream_count;
+
public:
- IMediaDemuxer (Media* media) : IMediaObject (media) {}
+ IMediaDemuxer (Media *media) : IMediaObject (media) {}
virtual ~IMediaDemuxer ();
virtual MediaResult ReadHeader () = 0;
// Fills the uncompressed_data field in the frame with data.
- virtual MediaResult ReadFrame (MediaFrame* frame) = 0;
+ virtual MediaResult ReadFrame (MediaFrame *frame) = 0;
virtual MediaResult Seek (guint64 pts) = 0;
int GetStreamCount () { return stream_count; }
- IMediaStream* GetStream (int index)
+ IMediaStream *GetStream (int index)
{
return (index < 0 || index >= stream_count) ? NULL : streams
[index];
}
protected:
- void SetStreams (IMediaStream** streams, int count);
-
-private:
- int stream_count;
- IMediaStream** streams;
+ void SetStreams (IMediaStream **streams, int count);
};
class IMediaDecoder {
@@ -547,7 +546,7 @@
class AudioStream : public IMediaStream {
public:
- AudioStream (Media* media) : IMediaStream (media) {}
+ AudioStream (Media *media) : IMediaStream (media) {}
virtual MoonMediaType GetType () { return MediaTypeAudio; }
@@ -562,28 +561,28 @@
* ASF related implementations
*/
class ASFDemuxer : public IMediaDemuxer {
+ gint32 *stream_to_asf_index;
+ ASFFrameReader *reader;
+ ASFParser *parser;
+
+ void ReadMarkers ();
+
public:
- ASFDemuxer (Media* media);
+ ASFDemuxer (Media *media);
~ASFDemuxer ();
virtual MediaResult ReadHeader ();
- virtual MediaResult ReadFrame (MediaFrame* frame);
+ virtual MediaResult ReadFrame (MediaFrame *frame);
virtual MediaResult Seek (guint64 pts);
- ASFParser* GetParser () { return parser; }
-private:
- void ReadMarkers ();
-
- ASFParser* parser;
- ASFFrameReader* reader;
- gint32* stream_to_asf_index;
+ ASFParser *GetParser () { return parser; }
};
class ASFDemuxerInfo : public DemuxerInfo {
public:
- virtual bool Supports (uint8_t* buffer, uint32_t length);
- virtual IMediaDemuxer* Create (Media* media);
- virtual const char* GetName () { return "ASFDemuxer"; }
+ virtual bool Supports (IMediaSource *source);
+ virtual IMediaDemuxer *Create (Media *media);
+ virtual const char *GetName () { return "ASFDemuxer"; }
};
class MarkerStream : public IMediaStream {
@@ -608,13 +607,43 @@
/*
* Mp3 related implementations
*/
-
+
+class Mp3Demuxer : public IMediaDemuxer {
+ //Mp3FrameReader *reader;
+ int64_t stream_start;
+ int version;
+ int layer;
+
+public:
+ Mp3Demuxer (Media *media);
+ ~Mp3Demuxer ();
+
+ virtual MediaResult ReadHeader ();
+ virtual MediaResult ReadFrame (MediaFrame *frame);
+ virtual MediaResult Seek (guint64 pts);
+};
+
+class Mp3DemuxerInfo : public DemuxerInfo {
+public:
+ virtual bool Supports (IMediaSource *source);
+ virtual IMediaDemuxer *Create (Media *media);
+ virtual const char *GetName () { return "Mp3Demuxer"; }
+};
+
+#if 0
+class Mp3MarkerStream : public IMediaStream {
+public:
+ Mp3MarkerStream (Media *media) : IMediaStream (media) {}
+ virtual MoonMediaType GetType () { return MediaTypeMarker; }
+};
+#endif
+
class Mp3Decoder : public IMediaDecoder {
public:
- Mp3Decoder (Media* media, IMediaStream* stream);
+ Mp3Decoder (Media *media, IMediaStream *stream);
virtual ~Mp3Decoder ();
- virtual MediaResult DecodeFrame (MediaFrame* frame);
+ virtual MediaResult DecodeFrame (MediaFrame *frame);
virtual MediaResult Open ();
};
_______________________________________________
Mono-patches maillist - [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches