mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-25 01:30:38 +00:00
Code Issues 1 Projects Releases Wiki Activity

gst/asfdemux/: lot's of fixes to make data extraction simpler and get the code architecture and compiler independant....

Browse source 
Original commit message from CVS:
2004-01-27  Benjamin Otte  <in7y118@public.uni-hamburg.de>

* gst/asfdemux/asfheaders.h:
* gst/asfdemux/gstasfdemux.c:
* gst/asfdemux/gstasfmux.c: (gst_asfmux_put_guid),
(gst_asfmux_put_string), (gst_asfmux_put_wav_header),
(gst_asfmux_put_vid_header), (gst_asfmux_put_bmp_header):
lot's of fixes to make data extraction simpler and get the code
architecture and compiler independant. Add debugging category
* gst/goom/gstgoom.c: (gst_goom_change_state):
reset channel count on PAUSED=>READY, not READY=>PAUSED
This commit is contained in:
Benjamin Otte 2004-01-27 01:27:04 +00:00
parent 3221a980b3
commit 9964e04d4d
5 changed files with 324 additions and 310 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
ChangeLog
View file

@ -1,3 +1,15 @@
2004-01-27 Benjamin Otte <in7y118@public.uni-hamburg.de>
* gst/asfdemux/asfheaders.h:
* gst/asfdemux/gstasfdemux.c:
* gst/asfdemux/gstasfmux.c: (gst_asfmux_put_guid),
(gst_asfmux_put_string), (gst_asfmux_put_wav_header),
(gst_asfmux_put_vid_header), (gst_asfmux_put_bmp_header):
lot's of fixes to make data extraction simpler and get the code
architecture and compiler independant. Add debugging category
* gst/goom/gstgoom.c: (gst_goom_change_state):
reset channel count on PAUSED=>READY, not READY=>PAUSED
2004-01-26 Colin Walters <walters@verbum.org> 2004-01-26 Colin Walters <walters@verbum.org>
* ext/gnomevfs/gstgnomevfssrc.c (gst_gnomevfssrc_get): Remove ugly * ext/gnomevfs/gstgnomevfssrc.c (gst_gnomevfssrc_get): Remove ugly

1
ext/mad/gstid3tag.c
View file

@ -923,6 +923,7 @@ gst_id3_tag_chain (GstPad *pad, GstData *data)
} }
} }
/* caps nego and typefinding */ /* caps nego and typefinding */
GST_LOG_OBJECT (tag, "removing first %ld bytes, because they're the ID3v2 tag", tag->v2tag_size);
buffer = gst_buffer_create_sub (tag->buffer, tag->v2tag_size, buffer = gst_buffer_create_sub (tag->buffer, tag->v2tag_size,
GST_BUFFER_SIZE (tag->buffer) - tag->v2tag_size); GST_BUFFER_SIZE (tag->buffer) - tag->v2tag_size);
gst_data_unref (GST_DATA (tag->buffer)); gst_data_unref (GST_DATA (tag->buffer));

7
gst/asfdemux/asfheaders.h
View file

@ -137,6 +137,7 @@ struct _asf_stream_audio {
typedef struct _asf_stream_audio asf_stream_audio; typedef struct _asf_stream_audio asf_stream_audio;
struct _asf_stream_correction { struct _asf_stream_correction {
guint8 span;
guint16 packet_size; guint16 packet_size;
guint16 chunk_size; guint16 chunk_size;
guint16 data_size; guint16 data_size;
@ -150,9 +151,7 @@ struct _asf_stream_video {
guint32 height; guint32 height;
guint8 unknown; guint8 unknown;
guint16 size; guint16 size;
} __attribute__ ((__packed__)); };
/* the packed attribute is needed to prevent this thing
* from expanding 'unknown' to 16 bits */
typedef struct _asf_stream_video asf_stream_video; typedef struct _asf_stream_video asf_stream_video;
@ -176,7 +175,7 @@ struct _asf_obj_data {
ASFGuid file_id; ASFGuid file_id;
guint64 packets; guint64 packets;
guint8 unknown1; guint8 unknown1;
guint8 unknown2; /* guint8 unknown2; FIXME: this object is supposed to be 26 bytes?! */
guint8 correction; guint8 correction;
}; };

589
gst/asfdemux/gstasfdemux.c
View file

@ -42,6 +42,9 @@ GST_STATIC_PAD_TEMPLATE (
GST_STATIC_CAPS("video/x-ms-asf") GST_STATIC_CAPS("video/x-ms-asf")
); );
GST_DEBUG_CATEGORY_STATIC (asf_debug);
#define GST_CAT_DEFAULT asf_debug
static void gst_asf_demux_base_init (gpointer g_class); static void gst_asf_demux_base_init (gpointer g_class);
static void gst_asf_demux_class_init (GstASFDemuxClass *klass); static void gst_asf_demux_class_init (GstASFDemuxClass *klass);
static void gst_asf_demux_init (GstASFDemux *asf_demux); static void gst_asf_demux_init (GstASFDemux *asf_demux);
@ -259,7 +262,7 @@ gst_asf_demux_loop (GstElement *element)
gst_asf_demux_process_object (asf_demux); gst_asf_demux_process_object (asf_demux);
} }
static guint32 gst_asf_demux_read_var_length (GstASFDemux *asf_demux, guint8 type, guint32 *rsize) static guint32 _read_var_length (GstASFDemux *asf_demux, guint8 type, guint32 *rsize)
{ {
guint32 got_bytes; guint32 got_bytes;
guint8 *var; guint8 *var;
@ -303,40 +306,196 @@ static guint32 gst_asf_demux_read_var_length (GstASFDemux *asf_demux, guint8 typ
return ret; return ret;
} }
static void gst_asf_demux_read_object_header_rest (GstASFDemux *asf_demux, guint8 **buf, guint32 size) { #define READ_UINT_BITS_FUNCTION(bits) \
guint32 got_bytes; static gboolean \
GstByteStream *bs = asf_demux->bs; _read_uint ## bits (GstASFDemux *asf_demux, guint ## bits *ret) \
gboolean ret; { \
GstEvent *event; GstEvent *event; \
guint32 remaining; guint32 remaining; \
guint8* data; \
\
g_return_val_if_fail (ret != NULL, FALSE); \
\
do { \
if (gst_bytestream_peek_bytes (asf_demux->bs, &data, bits / 8) == bits / 8) { \
*ret = GUINT ## bits ## _FROM_LE (*((guint ## bits *) data)); \
gst_bytestream_flush (asf_demux->bs, bits / 8); \
return TRUE; \
} \
gst_bytestream_get_status (asf_demux->bs, &remaining, &event); \
} while (gst_asf_demux_handle_sink_event (asf_demux, event, remaining)); \
\
return FALSE; \
}
do { #ifndef GUINT8_FROM_LE
got_bytes = gst_bytestream_peek_bytes (bs, buf, size); # define GUINT8_FROM_LE(x) (x)
if (got_bytes == size) { #endif
gst_bytestream_flush (bs, size); READ_UINT_BITS_FUNCTION (8)
return; READ_UINT_BITS_FUNCTION (16)
READ_UINT_BITS_FUNCTION (32)
READ_UINT_BITS_FUNCTION (64)
#define GET_UINT(a,b)
static gboolean
_read_guid (GstASFDemux *asf_demux, ASFGuid *guid)
{
return (_read_uint32 (asf_demux, &guid->v1) &&
_read_uint32 (asf_demux, &guid->v2) &&
_read_uint32 (asf_demux, &guid->v3) &&
_read_uint32 (asf_demux, &guid->v4));
} }
gst_bytestream_get_status (bs, &remaining, &event);
ret = gst_asf_demux_handle_sink_event (asf_demux, event, remaining); static gboolean
} while (ret); _read_obj_file (GstASFDemux *asf_demux, asf_obj_file *object)
{
return (_read_guid (asf_demux, &object->file_id) &&
_read_uint64 (asf_demux, &object->file_size) &&
_read_uint64 (asf_demux, &object->creation_time) &&
_read_uint64 (asf_demux, &object->packets_count) &&
_read_uint64 (asf_demux, &object->play_time) &&
_read_uint64 (asf_demux, &object->send_time) &&
_read_uint64 (asf_demux, &object->preroll) &&
_read_uint32 (asf_demux, &object->flags) &&
_read_uint32 (asf_demux, &object->min_pktsize) &&
_read_uint32 (asf_demux, &object->max_pktsize) &&
_read_uint32 (asf_demux, &object->min_bitrate));
} }
static gboolean
_read_bitrate_record (GstASFDemux *asf_demux, asf_bitrate_record *record)
{
return (_read_uint16 (asf_demux, &record->stream_id) &&
_read_uint32 (asf_demux, &record->bitrate));
}
static gboolean
_read_obj_comment (GstASFDemux *asf_demux, asf_obj_comment *comment)
{
return (_read_uint16 (asf_demux, &comment->title_length) &&
_read_uint16 (asf_demux, &comment->author_length) &&
_read_uint16 (asf_demux, &comment->copyright_length) &&
_read_uint16 (asf_demux, &comment->description_length) &&
_read_uint16 (asf_demux, &comment->rating_length));
}
static gboolean
_read_obj_header (GstASFDemux *asf_demux, asf_obj_header *header)
{
return (_read_uint32 (asf_demux, &header->num_objects) &&
_read_uint8 (asf_demux, &header->unknown1) &&
_read_uint8 (asf_demux, &header->unknown2));
}
static gboolean
_read_obj_stream (GstASFDemux *asf_demux, asf_obj_stream *stream)
{
return (_read_guid (asf_demux, &stream->type) &&
_read_guid (asf_demux, &stream->correction) &&
_read_uint64 (asf_demux, &stream->unknown1) &&
_read_uint32 (asf_demux, &stream->type_specific_size) &&
_read_uint32 (asf_demux, &stream->stream_specific_size) &&
_read_uint16 (asf_demux, &stream->id) &&
_read_uint32 (asf_demux, &stream->unknown2));
}
static gboolean
_read_replicated_data (GstASFDemux *asf_demux, asf_replicated_data *rep)
{
return (_read_uint32 (asf_demux, &rep->object_size) &&
_read_uint32 (asf_demux, &rep->frag_timestamp));
}
static gboolean
_read_obj_data (GstASFDemux *asf_demux, asf_obj_data *object)
{
return (_read_guid (asf_demux, &object->file_id) &&
_read_uint64 (asf_demux, &object->packets) &&
_read_uint8 (asf_demux, &object->unknown1) &&
/*_read_uint8 (asf_demux, &object->unknown2) && */
_read_uint8 (asf_demux, &object->correction));
}
static gboolean
_read_obj_data_correction (GstASFDemux *asf_demux, asf_obj_data_correction *object)
{
return (_read_uint8 (asf_demux, &object->type) &&
_read_uint8 (asf_demux, &object->cycle));
}
static gboolean
_read_obj_data_packet (GstASFDemux *asf_demux, asf_obj_data_packet *object)
{
return (_read_uint8 (asf_demux, &object->flags) &&
_read_uint8 (asf_demux, &object->property));
}
static gboolean
_read_stream_audio (GstASFDemux *asf_demux, asf_stream_audio *audio)
{
return (_read_uint16 (asf_demux, &audio->codec_tag) &&
_read_uint16 (asf_demux, &audio->channels) &&
_read_uint32 (asf_demux, &audio->sample_rate) &&
_read_uint32 (asf_demux, &audio->byte_rate) &&
_read_uint16 (asf_demux, &audio->block_align) &&
_read_uint16 (asf_demux, &audio->word_size) &&
_read_uint16 (asf_demux, &audio->size));
}
static gboolean
_read_stream_correction (GstASFDemux *asf_demux, asf_stream_correction *object)
{
return (_read_uint8 (asf_demux, &object->span) &&
_read_uint16 (asf_demux, &object->packet_size) &&
_read_uint16 (asf_demux, &object->chunk_size) &&
_read_uint16 (asf_demux, &object->data_size) &&
_read_uint8 (asf_demux, &object->silence_data));
}
static gboolean
_read_stream_video (GstASFDemux *asf_demux, asf_stream_video *video)
{
return (_read_uint32 (asf_demux, &video->width) &&
_read_uint32 (asf_demux, &video->height) &&
_read_uint8 (asf_demux, &video->unknown) &&
_read_uint16 (asf_demux, &video->size));
}
static gboolean
_read_stream_video_format (GstASFDemux *asf_demux, asf_stream_video_format *fmt)
{
return (_read_uint32 (asf_demux, &fmt->size) &&
_read_uint32 (asf_demux, &fmt->width) &&
_read_uint32 (asf_demux, &fmt->height) &&
_read_uint16 (asf_demux, &fmt->planes) &&
_read_uint16 (asf_demux, &fmt->depth) &&
_read_uint32 (asf_demux, &fmt->tag) &&
_read_uint32 (asf_demux, &fmt->image_size) &&
_read_uint32 (asf_demux, &fmt->xpels_meter) &&
_read_uint32 (asf_demux, &fmt->ypels_meter) &&
_read_uint32 (asf_demux, &fmt->num_colors) &&
_read_uint32 (asf_demux, &fmt->imp_colors));
}
static gboolean static gboolean
gst_asf_demux_process_file (GstASFDemux *asf_demux, guint64 *obj_size) gst_asf_demux_process_file (GstASFDemux *asf_demux, guint64 *obj_size)
{ {
asf_obj_file *object; asf_obj_file object;
guint8 *ptr;
guint64 packets;
/* Get the rest of the header's header */ /* Get the rest of the header's header */
gst_asf_demux_read_object_header_rest (asf_demux, &ptr, 80); _read_obj_file (asf_demux, &object);
object = (asf_obj_file *)ptr; asf_demux->packet_size = object.max_pktsize;
packets = GUINT64_FROM_LE (object->packets_count); asf_demux->play_time = (guint32) object.play_time / 10;
asf_demux->packet_size = GUINT32_FROM_LE (object->max_pktsize); asf_demux->preroll = object.preroll;
asf_demux->play_time = (guint32) GUINT64_FROM_LE (object->play_time) / 10;
asf_demux->preroll = GUINT64_FROM_LE (object->preroll);
GST_INFO ( "Object is a file with %" G_GUINT64_FORMAT " data packets", packets); GST_INFO ( "Object is a file with %" G_GUINT64_FORMAT " data packets", object.packets_count);
return TRUE; return TRUE;
} }
@ -344,24 +503,20 @@ gst_asf_demux_process_file (GstASFDemux *asf_demux, guint64 *obj_size)
static gboolean static gboolean
gst_asf_demux_process_bitrate_props_object (GstASFDemux *asf_demux, guint64 *obj_size) gst_asf_demux_process_bitrate_props_object (GstASFDemux *asf_demux, guint64 *obj_size)
{ {
guint32 got_bytes;
GstBuffer *buf;
guint16 num_streams; guint16 num_streams;
guint8 stream_id; guint8 stream_id;
guint16 i; guint16 i;
guint8 *ptr; asf_bitrate_record bitrate_record;
asf_bitrate_record *bitrate_record;
got_bytes = gst_bytestream_read (asf_demux->bs, &buf, 2); if (!_read_uint16 (asf_demux, &num_streams))
num_streams = GUINT16_FROM_LE (*GST_BUFFER_DATA (buf)); return FALSE;
GST_INFO ( "Object is a bitrate properties object with %u streams.", num_streams); GST_INFO ( "Object is a bitrate properties object with %u streams.", num_streams);
for (i = 0; i < num_streams; i++) { for (i = 0; i < num_streams; i++) {
gst_asf_demux_read_object_header_rest (asf_demux, &ptr, 6); _read_bitrate_record (asf_demux, &bitrate_record);
bitrate_record = (asf_bitrate_record *)ptr; stream_id = bitrate_record.stream_id & 0x7f;
stream_id = GUINT16_FROM_LE (bitrate_record->stream_id) & 0x7f; asf_demux->bitrate[stream_id] = bitrate_record.bitrate;
asf_demux->bitrate[stream_id] = GUINT32_FROM_LE (bitrate_record->bitrate);
} }
return TRUE; return TRUE;
@ -370,33 +525,22 @@ gst_asf_demux_process_bitrate_props_object (GstASFDemux *asf_demux, guint64 *obj
static gboolean static gboolean
gst_asf_demux_process_comment (GstASFDemux *asf_demux, guint64 *obj_size) gst_asf_demux_process_comment (GstASFDemux *asf_demux, guint64 *obj_size)
{ {
asf_obj_comment *object; asf_obj_comment object;
guint16 title_length;
guint16 author_length;
guint16 copyright_length;
guint16 description_length;
guint16 rating_length;
guint8 *ptr;
GstByteStream *bs = asf_demux->bs; GstByteStream *bs = asf_demux->bs;
GST_INFO ( "Object is a comment."); GST_INFO ( "Object is a comment.");
/* Get the rest of the comment's header */ /* Get the rest of the comment's header */
gst_asf_demux_read_object_header_rest (asf_demux, &ptr, 10); _read_obj_comment (asf_demux, &object);
object = (asf_obj_comment *)ptr; GST_DEBUG ("Comment lengths: title=%d author=%d copyright=%d description=%d rating=%d",
title_length = GUINT16_FROM_LE (object->title_length); object.title_length, object.author_length, object.copyright_length, object.description_length, object.rating_length);
author_length = GUINT16_FROM_LE (object->author_length);
copyright_length = GUINT16_FROM_LE (object->copyright_length);
description_length = GUINT16_FROM_LE (object->description_length);
rating_length = GUINT16_FROM_LE (object->rating_length);
GST_DEBUG ("Comment lengths: title=%d author=%d copyright=%d description=%d rating=%d", title_length, author_length, copyright_length, description_length, rating_length);
/* We don't do anything with them at the moment so just skip them */ /* We don't do anything with them at the moment so just skip them */
gst_bytestream_flush (bs, title_length); gst_bytestream_flush (bs, object.title_length);
gst_bytestream_flush (bs, author_length); gst_bytestream_flush (bs, object.author_length);
gst_bytestream_flush (bs, copyright_length); gst_bytestream_flush (bs, object.copyright_length);
gst_bytestream_flush (bs, description_length); gst_bytestream_flush (bs, object.description_length);
gst_bytestream_flush (bs, rating_length); gst_bytestream_flush (bs, object.rating_length);
return TRUE; return TRUE;
} }
@ -405,20 +549,16 @@ gst_asf_demux_process_comment (GstASFDemux *asf_demux, guint64 *obj_size)
static gboolean static gboolean
gst_asf_demux_process_header (GstASFDemux *asf_demux, guint64 *obj_size) gst_asf_demux_process_header (GstASFDemux *asf_demux, guint64 *obj_size)
{ {
guint32 num_objects; asf_obj_header object;
asf_obj_header *object;
guint32 i; guint32 i;
guint8 *ptr;
/* Get the rest of the header's header */ /* Get the rest of the header's header */
gst_asf_demux_read_object_header_rest (asf_demux, &ptr, 6); _read_obj_header (asf_demux, &object);
object = (asf_obj_header *)ptr;
num_objects = GUINT32_FROM_LE (object->num_objects);
GST_INFO ( "Object is a header with %u parts", num_objects); GST_INFO ( "Object is a header with %u parts", object.num_objects);
/* Loop through the header's objects, processing those */ /* Loop through the header's objects, processing those */
for (i = 0; i < num_objects; i++) { for (i = 0; i < object.num_objects; i++) {
if (!gst_asf_demux_process_object (asf_demux)) { if (!gst_asf_demux_process_object (asf_demux)) {
return FALSE; return FALSE;
} }
@ -431,7 +571,7 @@ static gboolean
gst_asf_demux_process_segment (GstASFDemux *asf_demux, gst_asf_demux_process_segment (GstASFDemux *asf_demux,
asf_packet_info *packet_info) asf_packet_info *packet_info)
{ {
guint8 *byte; guint8 byte;
gboolean key_frame; gboolean key_frame;
guint32 replic_size; guint32 replic_size;
guint8 time_delta; guint8 time_delta;
@ -440,20 +580,18 @@ gst_asf_demux_process_segment (GstASFDemux *asf_demux,
guint32 rsize; guint32 rsize;
asf_segment_info segment_info; asf_segment_info segment_info;
gst_asf_demux_read_object_header_rest (asf_demux, (guint8**)&byte, 1); rsize = 1; _read_uint8 (asf_demux, &byte); rsize = 1;
segment_info.stream_number = *byte & 0x7f; segment_info.stream_number = byte & 0x7f;
key_frame = (*byte & 0x80) >> 7; key_frame = (byte & 0x80) >> 7;
GST_INFO ( "Processing segment for stream %u", segment_info.stream_number); GST_INFO ( "Processing segment for stream %u", segment_info.stream_number);
segment_info.sequence = gst_asf_demux_read_var_length (asf_demux, packet_info->seqtype, &rsize); segment_info.sequence = _read_var_length (asf_demux, packet_info->seqtype, &rsize);
segment_info.frag_offset = gst_asf_demux_read_var_length (asf_demux, packet_info->fragoffsettype, &rsize); segment_info.frag_offset = _read_var_length (asf_demux, packet_info->fragoffsettype, &rsize);
replic_size = gst_asf_demux_read_var_length (asf_demux, packet_info->replicsizetype, &rsize); replic_size = _read_var_length (asf_demux, packet_info->replicsizetype, &rsize);
GST_DEBUG ("sequence = %x, frag_offset = %x, replic_size = %x", segment_info.sequence, segment_info.frag_offset, replic_size); GST_DEBUG ("sequence = %x, frag_offset = %x, replic_size = %x", segment_info.sequence, segment_info.frag_offset, replic_size);
if (replic_size > 1) { if (replic_size > 1) {
asf_replicated_data *replicated_data_header; asf_replicated_data replicated_data_header;
guint8 *replicated_data = NULL;
guint8 *ptr;
segment_info.compressed = FALSE; segment_info.compressed = FALSE;
@ -462,13 +600,12 @@ gst_asf_demux_process_segment (GstASFDemux *asf_demux,
gst_element_error (asf_demux, STREAM, DEMUX, NULL, ("The payload has replicated data but the size is less than 8")); gst_element_error (asf_demux, STREAM, DEMUX, NULL, ("The payload has replicated data but the size is less than 8"));
return FALSE; return FALSE;
} }
gst_asf_demux_read_object_header_rest (asf_demux, &ptr, 8); _read_replicated_data (asf_demux, &replicated_data_header);
replicated_data_header = (asf_replicated_data *)ptr; segment_info.frag_timestamp = replicated_data_header.frag_timestamp;
segment_info.frag_timestamp = GUINT32_FROM_LE (replicated_data_header->frag_timestamp); segment_info.segment_size = replicated_data_header.object_size;
segment_info.segment_size = GUINT32_FROM_LE (replicated_data_header->object_size);
if (replic_size > 8) { if (replic_size > 8) {
gst_asf_demux_read_object_header_rest (asf_demux, &replicated_data, replic_size - 8); gst_bytestream_flush (asf_demux->bs, replic_size - 8);
} }
rsize += replic_size; rsize += replic_size;
@ -476,8 +613,7 @@ gst_asf_demux_process_segment (GstASFDemux *asf_demux,
if (replic_size == 1) { if (replic_size == 1) {
/* It's compressed */ /* It's compressed */
segment_info.compressed = TRUE; segment_info.compressed = TRUE;
gst_asf_demux_read_object_header_rest (asf_demux, (guint8**)&byte, 1); rsize++; _read_uint8 (asf_demux, &time_delta); rsize++;
time_delta = *byte;
GST_DEBUG ("time_delta %u", time_delta); GST_DEBUG ("time_delta %u", time_delta);
} else { } else {
segment_info.compressed = FALSE; segment_info.compressed = FALSE;
@ -491,7 +627,7 @@ gst_asf_demux_process_segment (GstASFDemux *asf_demux,
GST_DEBUG ("multiple = %u compressed = %u", packet_info->multiple, segment_info.compressed); GST_DEBUG ("multiple = %u compressed = %u", packet_info->multiple, segment_info.compressed);
if (packet_info->multiple) { if (packet_info->multiple) {
frag_size = gst_asf_demux_read_var_length (asf_demux, packet_info->segsizetype, &rsize); frag_size = _read_var_length (asf_demux, packet_info->segsizetype, &rsize);
} else { } else {
frag_size = packet_info->size_left - rsize; frag_size = packet_info->size_left - rsize;
} }
@ -502,9 +638,9 @@ gst_asf_demux_process_segment (GstASFDemux *asf_demux,
if (segment_info.compressed) { if (segment_info.compressed) {
while (frag_size > 0) { while (frag_size > 0) {
gst_asf_demux_read_object_header_rest (asf_demux, (guint8**)&byte, 1); _read_uint8 (asf_demux, &byte);
packet_info->size_left--; packet_info->size_left--;
segment_info.chunk_size = *byte; segment_info.chunk_size = byte;
segment_info.segment_size = segment_info.chunk_size; segment_info.segment_size = segment_info.chunk_size;
if (segment_info.chunk_size > packet_info->size_left) { if (segment_info.chunk_size > packet_info->size_left) {
@ -527,58 +663,52 @@ gst_asf_demux_process_segment (GstASFDemux *asf_demux,
static gboolean static gboolean
gst_asf_demux_process_data (GstASFDemux *asf_demux, guint64 *obj_size) gst_asf_demux_process_data (GstASFDemux *asf_demux, guint64 *obj_size)
{ {
asf_obj_data *object; asf_obj_data object;
asf_obj_data_packet *packet_properties_object; asf_obj_data_packet packet_properties_object;
gboolean correction; gboolean correction;
guint64 packets; guint64 packets;
guint64 packet; guint64 packet;
guint8 *buf; guint8 buf;
guint32 sequence; guint32 sequence;
guint32 packet_length; guint32 packet_length;
guint32 *timestamp; guint16 duration;
guint16 *duration;
guint8 segment; guint8 segment;
guint8 segments; guint8 segments;
guint8 flags; guint8 flags;
guint8 property; guint8 property;
asf_packet_info packet_info; asf_packet_info packet_info;
guint32 rsize; guint32 rsize;
guint8 *ptr;
/* Get the rest of the header */ /* Get the rest of the header */
gst_asf_demux_read_object_header_rest (asf_demux, &ptr, 26); _read_obj_data (asf_demux, &object);
object = (asf_obj_data *)ptr; packets = object.packets;
packets = GUINT64_FROM_LE (object->packets);
GST_INFO ( "Object is data with %" G_GUINT64_FORMAT " packets", packets); GST_INFO ( "Object is data with %" G_GUINT64_FORMAT " packets", packets);
for (packet = 0; packet < packets; packet++) { for (packet = 0; packet < packets; packet++) {
GST_INFO ( "\n\nProcess packet %" G_GUINT64_FORMAT, packet); GST_INFO ( "\n\nProcess packet %" G_GUINT64_FORMAT, packet);
gst_asf_demux_read_object_header_rest (asf_demux, (guint8**)&buf, 1); rsize=1; _read_uint8 (asf_demux, &buf); rsize=1;
if (*buf & 0x80) { if (buf & 0x80) {
asf_obj_data_correction *correction_object; asf_obj_data_correction correction_object;
guint8 *ptr;
/* Uses error correction */ /* Uses error correction */
correction = TRUE; correction = TRUE;
GST_DEBUG ("Data has error correction (%x)", *buf); GST_DEBUG ("Data has error correction (%x)", buf);
gst_asf_demux_read_object_header_rest (asf_demux, &ptr, 2); rsize += 2; _read_obj_data_correction (asf_demux, &correction_object); rsize += 2;
correction_object = (asf_obj_data_correction *)ptr;
} }
/* Read the packet flags */ /* Read the packet flags */
gst_asf_demux_read_object_header_rest (asf_demux, &ptr, 2); rsize += 2; _read_obj_data_packet (asf_demux, &packet_properties_object); rsize += 2;
packet_properties_object = (asf_obj_data_packet *)ptr; flags = packet_properties_object.flags;
flags = packet_properties_object->flags; property = packet_properties_object.property;
property = packet_properties_object->property;
packet_info.multiple = flags & 0x01; packet_info.multiple = flags & 0x01;
sequence = gst_asf_demux_read_var_length (asf_demux, (flags >> 1) & 0x03, &rsize); sequence = _read_var_length (asf_demux, (flags >> 1) & 0x03, &rsize);
packet_info.padsize = packet_info.padsize =
gst_asf_demux_read_var_length (asf_demux, (flags >> 3) & 0x03, &rsize); _read_var_length (asf_demux, (flags >> 3) & 0x03, &rsize);
packet_length = packet_length =
gst_asf_demux_read_var_length (asf_demux, (flags >> 5) & 0x03, &rsize); _read_var_length (asf_demux, (flags >> 5) & 0x03, &rsize);
if (packet_length == 0) if (packet_length == 0)
packet_length = asf_demux->packet_size; packet_length = asf_demux->packet_size;
@ -589,22 +719,19 @@ gst_asf_demux_process_data (GstASFDemux *asf_demux, guint64 *obj_size)
packet_info.fragoffsettype = (property >> 2) & 0x03; packet_info.fragoffsettype = (property >> 2) & 0x03;
packet_info.seqtype = (property >> 4) & 0x03; packet_info.seqtype = (property >> 4) & 0x03;
gst_asf_demux_read_object_header_rest (asf_demux, &ptr, 4); _read_uint32 (asf_demux, &asf_demux->timestamp);
timestamp = (guint32 *)ptr; _read_uint16 (asf_demux, &duration);
asf_demux->timestamp = *timestamp;
gst_asf_demux_read_object_header_rest (asf_demux, &ptr, 2);
duration = (guint16 *)ptr;
rsize += 6; rsize += 6;
GST_DEBUG ("Timestamp = %x, Duration = %x", asf_demux->timestamp, *duration); GST_DEBUG ("Timestamp = %x, Duration = %x", asf_demux->timestamp, duration);
if (packet_info.multiple) { if (packet_info.multiple) {
/* There are multiple payloads */ /* There are multiple payloads */
gst_asf_demux_read_object_header_rest (asf_demux, (guint8**)&buf, 1); _read_uint8 (asf_demux, &buf);
rsize++; rsize++;
packet_info.segsizetype = (*buf >> 6) & 0x03; packet_info.segsizetype = (buf >> 6) & 0x03;
segments = *buf & 0x3f; segments = buf & 0x3f;
} else { } else {
packet_info.segsizetype = 2; packet_info.segsizetype = 2;
segments = 1; segments = 1;
@ -636,69 +763,64 @@ gst_asf_demux_process_data (GstASFDemux *asf_demux, guint64 *obj_size)
static gboolean static gboolean
gst_asf_demux_process_stream (GstASFDemux *asf_demux, guint64 *obj_size) gst_asf_demux_process_stream (GstASFDemux *asf_demux, guint64 *obj_size)
{ {
asf_obj_stream *object; asf_obj_stream object;
guint32 stream_id; guint32 stream_id;
guint32 correction; guint32 correction;
asf_stream_audio *audio_object; asf_stream_audio audio_object;
asf_stream_correction *correction_object; asf_stream_correction correction_object;
asf_stream_video *video_object; asf_stream_video video_object;
asf_stream_video_format *video_format_object; asf_stream_video_format video_format_object;
guint16 size; guint16 size;
GstBuffer *buf; GstBuffer *buf;
guint32 got_bytes; guint32 got_bytes;
guint16 id; guint16 id;
guint8 *ptr;
/* Get the rest of the header's header */ /* Get the rest of the header's header */
gst_asf_demux_read_object_header_rest (asf_demux, &ptr, 54); _read_obj_stream (asf_demux, &object);
object = (asf_obj_stream *)ptr;
/* Identify the stream type */ /* Identify the stream type */
stream_id = gst_asf_demux_identify_guid (asf_demux, asf_stream_guids, &(object->type)); stream_id = gst_asf_demux_identify_guid (asf_demux, asf_stream_guids, &(object.type));
correction = gst_asf_demux_identify_guid (asf_demux, asf_correction_guids, &(object->correction)); correction = gst_asf_demux_identify_guid (asf_demux, asf_correction_guids, &(object.correction));
id = GUINT16_FROM_LE (object->id); id = object.id;
switch (stream_id) { switch (stream_id) {
case ASF_STREAM_AUDIO: case ASF_STREAM_AUDIO:
gst_asf_demux_read_object_header_rest (asf_demux, &ptr, 18); _read_stream_audio (asf_demux, &audio_object);
audio_object = (asf_stream_audio *)ptr; size = audio_object.size;
size = GUINT16_FROM_LE (audio_object->size);
GST_INFO ("Object is an audio stream with %u bytes of additional data.", size); GST_INFO ("Object is an audio stream with %u bytes of additional data.", size);
if (!gst_asf_demux_add_audio_stream (asf_demux, audio_object, id)) if (!gst_asf_demux_add_audio_stream (asf_demux, &audio_object, id))
return FALSE; return FALSE;
switch (correction) { switch (correction) {
case ASF_CORRECTION_ON: case ASF_CORRECTION_ON:
GST_INFO ( "Using error correction"); GST_INFO ( "Using error correction");
/* Have to read the first byte seperately to avoid endian problems */ _read_stream_correction (asf_demux, &correction_object);
got_bytes = gst_bytestream_read (asf_demux->bs, &buf, 1); asf_demux->span = correction_object.span;
asf_demux->span = *GST_BUFFER_DATA (buf);
gst_asf_demux_read_object_header_rest (asf_demux, &ptr, 7); GST_DEBUG ("Descrambling: ps:%d cs:%d ds:%d s:%d sd:%d", correction_object.packet_size, correction_object.chunk_size,
correction_object = (asf_stream_correction *)ptr; correction_object.data_size, (guint) correction_object.span, (guint) correction_object.silence_data);
GST_DEBUG ("Descrambling: ps:%d cs:%d ds:%d s:%d sd:%d", GUINT16_FROM_LE(correction_object->packet_size), GUINT16_FROM_LE(correction_object->chunk_size), GUINT16_FROM_LE(correction_object->data_size), asf_demux->span, correction_object->silence_data);
if (asf_demux->span > 1) { if (asf_demux->span > 1) {
if (!correction_object->chunk_size || ((correction_object->packet_size / correction_object->chunk_size) <= 1)) if (!correction_object.chunk_size || ((correction_object.packet_size / correction_object.chunk_size) <= 1))
/* Disable descrambling */ /* Disable descrambling */
asf_demux->span = 0; asf_demux->span = 0;
} else { } else {
/* Descambling is enabled */ /* Descambling is enabled */
asf_demux->ds_packet_size = correction_object->packet_size; asf_demux->ds_packet_size = correction_object.packet_size;
asf_demux->ds_chunk_size = correction_object->chunk_size; asf_demux->ds_chunk_size = correction_object.chunk_size;
} }
/* Now skip the rest of the silence data */ /* Now skip the rest of the silence data */
if (correction_object->data_size > 1) if (correction_object.data_size > 1)
gst_bytestream_flush (asf_demux->bs, correction_object->data_size - 1); gst_bytestream_flush (asf_demux->bs, correction_object.data_size - 1);
break; break;
case ASF_CORRECTION_OFF: case ASF_CORRECTION_OFF:
GST_INFO ( "Error correction off"); GST_INFO ( "Error correction off");
gst_bytestream_flush (asf_demux->bs, object->stream_specific_size); gst_bytestream_flush (asf_demux->bs, object.stream_specific_size);
break; break;
default: default:
gst_element_error (asf_demux, STREAM, DEMUX, NULL, ("Audio stream using unknown error correction")); gst_element_error (asf_demux, STREAM, DEMUX, NULL, ("Audio stream using unknown error correction"));
@ -707,16 +829,12 @@ gst_asf_demux_process_stream (GstASFDemux *asf_demux, guint64 *obj_size)
break; break;
case ASF_STREAM_VIDEO: case ASF_STREAM_VIDEO:
gst_asf_demux_read_object_header_rest (asf_demux, &ptr, 11); _read_stream_video (asf_demux, &video_object);
video_object = (asf_stream_video *)ptr; size = video_object.size - 40; /* Byte order gets offset by single byte */
size = GUINT16_FROM_LE(video_object->size) - 40; /* Byte order gets
* offset by single
* byte */
GST_INFO ( "Object is a video stream with %u bytes of additional data.", size); GST_INFO ( "Object is a video stream with %u bytes of additional data.", size);
gst_asf_demux_read_object_header_rest (asf_demux, &ptr, 40); _read_stream_video_format (asf_demux, &video_format_object);
video_format_object = (asf_stream_video_format *)ptr;
if (!gst_asf_demux_add_video_stream (asf_demux, video_format_object, id)) if (!gst_asf_demux_add_video_stream (asf_demux, &video_format_object, id))
return FALSE; return FALSE;
/* Read any additional information */ /* Read any additional information */
@ -755,31 +873,21 @@ gst_asf_demux_skip_object (GstASFDemux *asf_demux, guint64 *obj_size)
} }
static inline gboolean static inline gboolean
gst_asf_demux_read_object_header (GstASFDemux *asf_demux, guint32 *obj_id, guint64 *obj_size) _read_object_header (GstASFDemux *asf_demux, guint32 *obj_id, guint64 *obj_size)
{ {
guint32 got_bytes; ASFGuid guid;
ASFGuid *guid;
GstByteStream *bs = asf_demux->bs;
guint8 *ptr;
/* First get the GUID */ /* First get the GUID */
if ((got_bytes = gst_bytestream_peek_bytes (bs, &ptr, if (!_read_guid (asf_demux, &guid))
sizeof(ASFGuid))) < sizeof(ASFGuid))
return FALSE; return FALSE;
guid = (ASFGuid *) ptr; *obj_id = gst_asf_demux_identify_guid (asf_demux, asf_object_guids, &guid);
*obj_id = gst_asf_demux_identify_guid (asf_demux, asf_object_guids, guid);
gst_bytestream_flush (bs, sizeof (ASFGuid));
if ((got_bytes = gst_bytestream_peek_bytes (bs, &ptr, if (!_read_uint64 (asf_demux, obj_size))
sizeof(guint64))) < sizeof(guint64))
return FALSE; return FALSE;
*obj_size = GUINT64_FROM_LE(* (guint64 *) ptr);
gst_bytestream_flush (bs, sizeof (guint64));
if (*obj_id == ASF_OBJ_UNDEFINED) { if (*obj_id == ASF_OBJ_UNDEFINED) {
GST_WARNING_OBJECT (asf_demux, "Could not identify object (0x%08x/0x%08x/0x%08x/0x%08x) with size=%llu", GST_WARNING_OBJECT (asf_demux, "Could not identify object (0x%08x/0x%08x/0x%08x/0x%08x) with size=%llu",
guid->v1, guid->v2, guid->v3, guid->v4, *obj_size); guid.v1, guid.v2, guid.v3, guid.v4, *obj_size);
return TRUE; return TRUE;
} }
@ -792,7 +900,7 @@ gst_asf_demux_process_object (GstASFDemux *asf_demux) {
guint32 obj_id; guint32 obj_id;
guint64 obj_size; guint64 obj_size;
if (!gst_asf_demux_read_object_header (asf_demux, &obj_id, &obj_size)) { if (!_read_object_header (asf_demux, &obj_id, &obj_size)) {
GST_DEBUG (" ***** Error reading object at filepos %" G_GUINT64_FORMAT " (EOS?)\n", /**filepos*/ gst_bytestream_tell (asf_demux->bs)); GST_DEBUG (" ***** Error reading object at filepos %" G_GUINT64_FORMAT " (EOS?)\n", /**filepos*/ gst_bytestream_tell (asf_demux->bs));
gst_asf_demux_handle_sink_event (asf_demux, gst_event_new (GST_EVENT_EOS), 0); gst_asf_demux_handle_sink_event (asf_demux, gst_event_new (GST_EVENT_EOS), 0);
return FALSE; return FALSE;
@ -1177,24 +1285,16 @@ gst_asf_demux_change_state (GstElement *element)
static guint32 static guint32
gst_asf_demux_identify_guid (GstASFDemux *asf_demux, gst_asf_demux_identify_guid (GstASFDemux *asf_demux,
ASFGuidHash *guids, ASFGuidHash *guids,
ASFGuid *guid_raw) ASFGuid *guid)
{ {
guint32 i; guint32 i;
ASFGuid guid;
/* guid_raw is passed in 'as-is' from the file
* so we must convert it's endianess */
guid.v1 = GUINT32_FROM_LE (guid_raw->v1);
guid.v2 = GUINT32_FROM_LE (guid_raw->v2);
guid.v3 = GUINT32_FROM_LE (guid_raw->v3);
guid.v4 = GUINT32_FROM_LE (guid_raw->v4);
i = 0; i = 0;
while (guids[i].obj_id != ASF_OBJ_UNDEFINED) { while (guids[i].obj_id != ASF_OBJ_UNDEFINED) {
if (guids[i].guid.v1 == guid.v1 && if (guids[i].guid.v1 == guid->v1 &&
guids[i].guid.v2 == guid.v2 && guids[i].guid.v2 == guid->v2 &&
guids[i].guid.v3 == guid.v3 && guids[i].guid.v3 == guid->v3 &&
guids[i].guid.v4 == guid.v4) { guids[i].guid.v4 == guid->v4) {
return guids[i].obj_id; return guids[i].obj_id;
} }
i++; i++;
@ -1205,47 +1305,6 @@ gst_asf_demux_identify_guid (GstASFDemux *asf_demux,
} }
/*
* Stream and pad setup code
*/
#ifdef G_HAVE_ISO_VARARGS
#define GST_ASF_AUD_CAPS_NEW(name, mimetype, ...) \
(audio != NULL) ? \
GST_CAPS_NEW (name, \
mimetype, \
"rate", GST_PROPS_INT ( \
GUINT32_FROM_LE (audio->sample_rate)), \
"channels", GST_PROPS_INT ( \
GUINT16_FROM_LE (audio->channels)), \
__VA_ARGS__) \
: \
GST_CAPS_NEW (name, \
mimetype, \
"rate", GST_PROPS_INT_RANGE (8000, 96000), \
"channels", GST_PROPS_INT_RANGE (1, 2), \
__VA_ARGS__)
#elif defined(G_HAVE_GNUC_VARARGS)
#define GST_ASF_AUD_CAPS_NEW(name, mimetype, props...) \
(audio != NULL) ? \
GST_CAPS_NEW (name, \
mimetype, \
"rate", GST_PROPS_INT ( \
GUINT32_FROM_LE (audio->sample_rate)), \
"channels", GST_PROPS_INT ( \
GUINT16_FROM_LE (audio->channels)), \
##props) \
: \
GST_CAPS_NEW (name, \
mimetype, \
"rate", GST_PROPS_INT_RANGE (8000, 96000), \
"channels", GST_PROPS_INT_RANGE (1, 2), \
##props)
#endif
static GstCaps * static GstCaps *
gst_asf_demux_audio_caps (guint16 codec_id, gst_asf_demux_audio_caps (guint16 codec_id,
asf_stream_audio *audio, guint8 *extradata) asf_stream_audio *audio, guint8 *extradata)
@ -1275,9 +1334,9 @@ gst_asf_demux_audio_caps (guint16 codec_id,
"depth = (int) { 8, 16 }"); "depth = (int) { 8, 16 }");
if (audio != NULL) { if (audio != NULL) {
gint ba = GUINT16_FROM_LE (audio->block_align); gint ba = audio->block_align;
gint ch = GUINT16_FROM_LE (audio->channels); gint ch = audio->channels;
gint ws = GUINT16_FROM_LE (audio->word_size); gint ws = audio->word_size;
gst_caps_set_simple (caps, gst_caps_set_simple (caps,
"width", G_TYPE_INT, (int)(ba * 8 / ch), "width", G_TYPE_INT, (int)(ba * 8 / ch),
@ -1360,8 +1419,8 @@ gst_asf_demux_audio_caps (guint16 codec_id,
if (audio != NULL) { if (audio != NULL) {
gst_caps_set_simple (caps, gst_caps_set_simple (caps,
"rate", G_TYPE_INT, GUINT32_FROM_LE (audio->sample_rate), "rate", G_TYPE_INT, audio->sample_rate,
"channels", G_TYPE_INT, GUINT16_FROM_LE (audio->channels), "channels", G_TYPE_INT, audio->channels,
NULL); NULL);
}else{ }else{
gst_caps_set_simple (caps, gst_caps_set_simple (caps,
@ -1382,9 +1441,8 @@ gst_asf_demux_add_audio_stream (GstASFDemux *asf_demux,
GstCaps *caps; GstCaps *caps;
gchar *name = NULL; gchar *name = NULL;
guint16 size_left = 0; guint16 size_left = 0;
guint8 *extradata=NULL;
size_left = GUINT16_FROM_LE(audio->size); size_left = audio->size;
/* Create the audio pad */ /* Create the audio pad */
name = g_strdup_printf ("audio_%02d", asf_demux->num_audio_streams); name = g_strdup_printf ("audio_%02d", asf_demux->num_audio_streams);
@ -1394,64 +1452,28 @@ gst_asf_demux_add_audio_stream (GstASFDemux *asf_demux,
gst_pad_use_explicit_caps (src_pad); gst_pad_use_explicit_caps (src_pad);
/* Swallow up any left over data */ /* Swallow up any left over data and set up the standard propertis from the header info */
if (size_left) { if (size_left) {
GST_WARNING_OBJECT (asf_demux, "asfdemux: Audio header contains %d bytes of surplus data", size_left); guint8 *extradata;
gst_asf_demux_read_object_header_rest (asf_demux, &extradata, size_left);
// gst_bytestream_flush (asf_demux->bs, size_left);
}
/* Now set up the standard propertis from the header info */ GST_WARNING_OBJECT (asf_demux, "asfdemux: Audio header contains %d bytes of surplus data", size_left);
caps = gst_asf_demux_audio_caps (GUINT16_FROM_LE(audio->codec_tag), gst_bytestream_peek_bytes (asf_demux->bs, &extradata, size_left);
audio, extradata); caps = gst_asf_demux_audio_caps (audio->codec_tag, audio, extradata);
gst_bytestream_flush (asf_demux->bs, size_left);
} else {
caps = gst_asf_demux_audio_caps (audio->codec_tag, audio, NULL);
}
GST_INFO ("Adding audio stream %u codec %u (0x%x)", GST_INFO ("Adding audio stream %u codec %u (0x%x)",
asf_demux->num_video_streams, asf_demux->num_video_streams,
GUINT16_FROM_LE(audio->codec_tag), audio->codec_tag,
GUINT16_FROM_LE(audio->codec_tag)); audio->codec_tag);
asf_demux->num_audio_streams++; asf_demux->num_audio_streams++;
return gst_asf_demux_setup_pad (asf_demux, src_pad, caps, id); return gst_asf_demux_setup_pad (asf_demux, src_pad, caps, id);
} }
#ifdef G_HAVE_ISO_VARARGS
#define GST_ASF_VID_CAPS_NEW(name, mimetype, ...) \
(video != NULL) ? \
GST_CAPS_NEW (name, \
mimetype, \
"width", GST_PROPS_INT (width), \
"height", GST_PROPS_INT (height), \
"framerate", GST_PROPS_FLOAT (0),/* FIXME */ \
__VA_ARGS__) \
: \
GST_CAPS_NEW (name, \
mimetype, \
"width", GST_PROPS_INT_RANGE (16, 4096), \
"height", GST_PROPS_INT_RANGE (16, 4096), \
"framerate", GST_PROPS_FLOAT_RANGE (0, G_MAXFLOAT), \
__VA_ARGS__)
#elif defined(G_HAVE_GNUC_VARARGS)
#define GST_ASF_VID_CAPS_NEW(name, mimetype, props...) \
(video != NULL) ? \
GST_CAPS_NEW (name, \
mimetype, \
"width", GST_PROPS_INT (width), \
"height", GST_PROPS_INT (height), \
"framerate", GST_PROPS_FLOAT (0),/* FIXME */ \
##props) \
: \
GST_CAPS_NEW (name, \
mimetype, \
"width", GST_PROPS_INT_RANGE (16, 4096), \
"height", GST_PROPS_INT_RANGE (16, 4096), \
"framerate", GST_PROPS_FLOAT_RANGE (0, G_MAXFLOAT), \
##props)
#endif
static GstCaps * static GstCaps *
gst_asf_demux_video_caps (guint32 codec_fcc, gst_asf_demux_video_caps (guint32 codec_fcc,
asf_stream_video_format *video) asf_stream_video_format *video)
@ -1460,8 +1482,8 @@ gst_asf_demux_video_caps (guint32 codec_fcc,
gint width = 0, height = 0; gint width = 0, height = 0;
if (video != NULL) { if (video != NULL) {
width = GUINT32_FROM_LE (video->width); width = video->width;
height = GUINT32_FROM_LE (video->height); height = video->height;
} }
switch (codec_fcc) { switch (codec_fcc) {
@ -1532,8 +1554,8 @@ gst_asf_demux_video_caps (guint32 codec_fcc,
if (video != NULL) { if (video != NULL) {
gst_caps_set_simple (caps, gst_caps_set_simple (caps,
"width", G_TYPE_INT, GUINT32_FROM_LE (video->width), "width", G_TYPE_INT, video->width,
"height", G_TYPE_INT, GUINT32_FROM_LE (video->height), "height", G_TYPE_INT, video->height,
"framerate", G_TYPE_DOUBLE, (double) 0, NULL); "framerate", G_TYPE_DOUBLE, (double) 0, NULL);
} else { } else {
gst_caps_set_simple (caps, gst_caps_set_simple (caps,
@ -1560,13 +1582,12 @@ gst_asf_demux_add_video_stream (GstASFDemux *asf_demux,
g_free (name); g_free (name);
/* Now try some gstreamer formatted MIME types (from gst_avi_demux_strf_vids) */ /* Now try some gstreamer formatted MIME types (from gst_avi_demux_strf_vids) */
caps = gst_asf_demux_video_caps (GUINT32_FROM_LE(video->tag), caps = gst_asf_demux_video_caps (video->tag, video);
video);
GST_INFO ("Adding video stream %u codec " GST_FOURCC_FORMAT " (0x%08x)", GST_INFO ("Adding video stream %u codec " GST_FOURCC_FORMAT " (0x%08x)",
asf_demux->num_video_streams, asf_demux->num_video_streams,
GST_FOURCC_ARGS(GUINT32_FROM_LE(video->tag)), GST_FOURCC_ARGS(video->tag),
GUINT32_FROM_LE(video->tag)); video->tag);
asf_demux->num_video_streams++; asf_demux->num_video_streams++;
@ -1620,6 +1641,8 @@ plugin_init (GstPlugin *plugin)
!gst_element_register (plugin, "asfmux", GST_RANK_NONE, GST_TYPE_ASFMUX)) !gst_element_register (plugin, "asfmux", GST_RANK_NONE, GST_TYPE_ASFMUX))
return FALSE; return FALSE;
GST_DEBUG_CATEGORY_INIT (asf_debug, "asfdemux", 0, "asf demuxer element");
return TRUE; return TRUE;
} }

21
gst/asfdemux/gstasfmux.c
View file

@ -770,14 +770,10 @@ gst_asfmux_put_guid (GstBuffer *packet,
} }
guid = &hash[n].guid; guid = &hash[n].guid;
#if (G_BYTE_ORDER == G_BIG_ENDIAN)
gst_asfmux_put_le32 (packet, guid->v1); gst_asfmux_put_le32 (packet, guid->v1);
gst_asfmux_put_le32 (packet, guid->v2); gst_asfmux_put_le32 (packet, guid->v2);
gst_asfmux_put_le32 (packet, guid->v3); gst_asfmux_put_le32 (packet, guid->v3);
gst_asfmux_put_le32 (packet, guid->v4); gst_asfmux_put_le32 (packet, guid->v4);
#else
gst_asfmux_put_buffer (packet, (guint8 *) guid, 16);
#endif
} }
static void static void
@ -785,16 +781,12 @@ gst_asfmux_put_string (GstBuffer *packet,
const gchar *str) const gchar *str)
{ {
gunichar2 *utf16_str = g_utf8_to_utf16 (str, strlen (str), NULL, NULL, NULL); gunichar2 *utf16_str = g_utf8_to_utf16 (str, strlen (str), NULL, NULL, NULL);
#if (G_BYTE_ORDER == G_BIG_ENDIAN)
gint i, len = strlen (str); gint i, len = strlen (str);
/* this is not an off-by-one-bug, we need the terminating /0 too */ /* this is not an off-by-one-bug, we need the terminating /0 too */
for (i = 0; i <= len; i++) { for (i = 0; i <= len; i++) {
gst_asfmux_put_le16 (packet, utf16_str[i]); gst_asfmux_put_le16 (packet, utf16_str[i]);
} }
#else
gst_asfmux_put_buffer (packet, (guint8 *) utf16_str, (strlen (str) + 1) * 2);
#endif
g_free (utf16_str); g_free (utf16_str);
} }
@ -825,7 +817,6 @@ static void
gst_asfmux_put_wav_header (GstBuffer *packet, gst_asfmux_put_wav_header (GstBuffer *packet,
asf_stream_audio *hdr) asf_stream_audio *hdr)
{ {
#if (G_BYTE_ORDER == G_BIG_ENDIAN)
gst_asfmux_put_le16 (packet, hdr->codec_tag); gst_asfmux_put_le16 (packet, hdr->codec_tag);
gst_asfmux_put_le16 (packet, hdr->channels); gst_asfmux_put_le16 (packet, hdr->channels);
gst_asfmux_put_le32 (packet, hdr->sample_rate); gst_asfmux_put_le32 (packet, hdr->sample_rate);
@ -833,31 +824,22 @@ gst_asfmux_put_wav_header (GstBuffer *packet,
gst_asfmux_put_le16 (packet, hdr->block_align); gst_asfmux_put_le16 (packet, hdr->block_align);
gst_asfmux_put_le16 (packet, hdr->word_size); gst_asfmux_put_le16 (packet, hdr->word_size);
gst_asfmux_put_le16 (packet, hdr->size); gst_asfmux_put_le16 (packet, hdr->size);
#else
gst_asfmux_put_buffer (packet, (guint8 *) hdr, 18);
#endif
} }
static void static void
gst_asfmux_put_vid_header (GstBuffer *packet, gst_asfmux_put_vid_header (GstBuffer *packet,
asf_stream_video *hdr) asf_stream_video *hdr)
{ {
/* why does it write hdr->size incorrectly? */
#if (G_BYTE_ORDER == G_BIG_ENDIAN)
gst_asfmux_put_le32 (packet, hdr->width); gst_asfmux_put_le32 (packet, hdr->width);
gst_asfmux_put_le32 (packet, hdr->height); gst_asfmux_put_le32 (packet, hdr->height);
gst_asfmux_put_byte (packet, hdr->unknown); gst_asfmux_put_byte (packet, hdr->unknown);
gst_asfmux_put_le16 (packet, hdr->size); gst_asfmux_put_le16 (packet, hdr->size);
#else
gst_asfmux_put_buffer (packet, (guint8 *) hdr, 11);
#endif
} }
static void static void
gst_asfmux_put_bmp_header (GstBuffer *packet, gst_asfmux_put_bmp_header (GstBuffer *packet,
asf_stream_video_format *hdr) asf_stream_video_format *hdr)
{ {
#if (G_BYTE_ORDER == G_BIG_ENDIAN)
gst_asfmux_put_le32 (packet, hdr->size); gst_asfmux_put_le32 (packet, hdr->size);
gst_asfmux_put_le32 (packet, hdr->width); gst_asfmux_put_le32 (packet, hdr->width);
gst_asfmux_put_le32 (packet, hdr->height); gst_asfmux_put_le32 (packet, hdr->height);
@ -869,9 +851,6 @@ gst_asfmux_put_bmp_header (GstBuffer *packet,
gst_asfmux_put_le32 (packet, hdr->ypels_meter); gst_asfmux_put_le32 (packet, hdr->ypels_meter);
gst_asfmux_put_le32 (packet, hdr->num_colors); gst_asfmux_put_le32 (packet, hdr->num_colors);
gst_asfmux_put_le32 (packet, hdr->imp_colors); gst_asfmux_put_le32 (packet, hdr->imp_colors);
#else
gst_asfmux_put_buffer (packet, (guint8 *) hdr, 40);
#endif
} }
/* init header */ /* init header */