mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-09-08 21:28:45 +00:00
Code Issues 1 Projects Releases Wiki Activity

gst/qtdemux/qtdemux.c: Make compile with Forte compiler, mostly don't do pointer arithmetic with void pointers (#3626...

Browse source 
Original commit message from CVS:
Patch by: Josep Torra Valles  <josep at fluendo com>
* gst/qtdemux/qtdemux.c: (gst_qtdemux_handle_sink_event),
(next_entry_size), (qtdemux_inflate), (qtdemux_parse_moov),
(qtdemux_parse_tree), (qtdemux_parse_trak), (qtdemux_tag_add_str),
(qtdemux_tag_add_num), (qtdemux_tag_add_date),
(qtdemux_tag_add_gnre):
Make compile with Forte compiler, mostly don't do pointer arithmetic
with void pointers (#362626).
This commit is contained in:
Josep Torra Valles 2006-10-17 14:57:17 +00:00 committed by Tim-Philipp Müller
parent bad39277cf
commit 9d73ae1136
1 changed files with 111 additions and 103 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

214
gst/qtdemux/qtdemux.c
View file

@ -975,17 +975,19 @@ static gboolean
gst_qtdemux_handle_sink_event (GstPad * sinkpad, GstEvent * event) gst_qtdemux_handle_sink_event (GstPad * sinkpad, GstEvent * event)
{ {
GstQTDemux *demux = GST_QTDEMUX (GST_PAD_PARENT (sinkpad)); GstQTDemux *demux = GST_QTDEMUX (GST_PAD_PARENT (sinkpad));
gboolean res = FALSE; gboolean res;
switch (GST_EVENT_TYPE (event)) { switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_NEWSEGMENT: case GST_EVENT_NEWSEGMENT:
/* We need to convert it to a GST_FORMAT_TIME new segment */ /* We need to convert it to a GST_FORMAT_TIME new segment */
gst_event_unref (event);
res = TRUE;
break;
default: default:
gst_pad_event_default (demux->sinkpad, event); res = gst_pad_event_default (demux->sinkpad, event);
return TRUE; break;
} }
gst_event_unref (event);
return res; return res;
} }
@ -1596,7 +1598,7 @@ next_entry_size (GstQTDemux * demux)
QtDemuxStream *stream; QtDemuxStream *stream;
int i; int i;
int smallidx = -1; int smallidx = -1;
guint64 smalloffs = -1; guint64 smalloffs = (guint64) - 1;
GST_LOG_OBJECT (demux, "Finding entry at offset %lld", demux->offset); GST_LOG_OBJECT (demux, "Finding entry at offset %lld", demux->offset);
@ -2057,7 +2059,7 @@ qtdemux_zfree (void *opaque, void *addr)
static void * static void *
qtdemux_inflate (void *z_buffer, int z_length, int length) qtdemux_inflate (void *z_buffer, int z_length, int length)
{ {
void *buffer; guint8 *buffer;
z_stream *z; z_stream *z;
int ret; int ret;
@ -2069,12 +2071,12 @@ qtdemux_inflate (void *z_buffer, int z_length, int length)
z->next_in = z_buffer; z->next_in = z_buffer;
z->avail_in = z_length; z->avail_in = z_length;
buffer = g_malloc (length); buffer = (guint8 *) g_malloc (length);
ret = inflateInit (z); ret = inflateInit (z);
while (z->avail_in > 0) { while (z->avail_in > 0) {
if (z->avail_out == 0) { if (z->avail_out == 0) {
length += 1024; length += 1024;
buffer = realloc (buffer, length); buffer = (guint8 *) g_realloc (buffer, length);
z->next_out = buffer + z->total_out; z->next_out = buffer + z->total_out;
z->avail_out = 1024; z->avail_out = 1024;
} }
@ -2108,18 +2110,19 @@ qtdemux_parse_moov (GstQTDemux * qtdemux, guint8 * buffer, int length)
dcom = qtdemux_tree_get_child_by_type (cmov, FOURCC_dcom); dcom = qtdemux_tree_get_child_by_type (cmov, FOURCC_dcom);
cmvd = qtdemux_tree_get_child_by_type (cmov, FOURCC_cmvd); cmvd = qtdemux_tree_get_child_by_type (cmov, FOURCC_cmvd);
if (QTDEMUX_FOURCC_GET (dcom->data + 8) == GST_MAKE_FOURCC ('z', 'l', 'i', if (QTDEMUX_FOURCC_GET ((guint8 *) dcom->data + 8) == GST_MAKE_FOURCC ('z',
'b')) { 'l', 'i', 'b')) {
int uncompressed_length; int uncompressed_length;
int compressed_length; int compressed_length;
guint8 *buf; guint8 *buf;
uncompressed_length = QTDEMUX_GUINT32_GET (cmvd->data + 8); uncompressed_length = QTDEMUX_GUINT32_GET ((guint8 *) cmvd->data + 8);
compressed_length = QTDEMUX_GUINT32_GET (cmvd->data + 4) - 12; compressed_length = QTDEMUX_GUINT32_GET ((guint8 *) cmvd->data + 4) - 12;
GST_LOG ("length = %d", uncompressed_length); GST_LOG ("length = %d", uncompressed_length);
buf = (guint8 *) qtdemux_inflate (cmvd->data + 12, compressed_length, buf =
uncompressed_length); (guint8 *) qtdemux_inflate ((guint8 *) cmvd->data + 12,
compressed_length, uncompressed_length);
qtdemux->moov_node_compressed = qtdemux->moov_node; qtdemux->moov_node_compressed = qtdemux->moov_node;
qtdemux->moov_node = g_node_new (buf); qtdemux->moov_node = g_node_new (buf);
@ -3136,8 +3139,8 @@ qtdemux_parse_tree (GstQTDemux * qtdemux)
return; return;
} }
qtdemux->timescale = QTDEMUX_GUINT32_GET (mvhd->data + 20); qtdemux->timescale = QTDEMUX_GUINT32_GET ((guint8 *) mvhd->data + 20);
qtdemux->duration = QTDEMUX_GUINT32_GET (mvhd->data + 24); qtdemux->duration = QTDEMUX_GUINT32_GET ((guint8 *) mvhd->data + 24);
GST_INFO_OBJECT (qtdemux, "timescale: %d", qtdemux->timescale); GST_INFO_OBJECT (qtdemux, "timescale: %d", qtdemux->timescale);
GST_INFO_OBJECT (qtdemux, "duration: %d", qtdemux->duration); GST_INFO_OBJECT (qtdemux, "duration: %d", qtdemux->duration);
@ -3211,12 +3214,13 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
int sample_index; int sample_index;
GstTagList *list = NULL; GstTagList *list = NULL;
const gchar *codec = NULL; const gchar *codec = NULL;
const guint8 *stsd_data, *stsc_data, *stsz_data, *stco_data;
tkhd = qtdemux_tree_get_child_by_type (trak, FOURCC_tkhd); tkhd = qtdemux_tree_get_child_by_type (trak, FOURCC_tkhd);
g_return_if_fail (tkhd); g_return_if_fail (tkhd);
GST_LOG ("track[tkhd] version/flags: 0x%08x", GST_LOG ("track[tkhd] version/flags: 0x%08x",
QTDEMUX_GUINT32_GET (tkhd->data + 8)); QTDEMUX_GUINT32_GET ((guint8 *) tkhd->data + 8));
mdia = qtdemux_tree_get_child_by_type (trak, FOURCC_mdia); mdia = qtdemux_tree_get_child_by_type (trak, FOURCC_mdia);
g_assert (mdia); g_assert (mdia);
@ -3232,8 +3236,8 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
stream->sample_index = 0; stream->sample_index = 0;
stream->last_ret = GST_FLOW_OK; stream->last_ret = GST_FLOW_OK;
stream->timescale = QTDEMUX_GUINT32_GET (mdhd->data + 20); stream->timescale = QTDEMUX_GUINT32_GET ((guint8 *) mdhd->data + 20);
stream->duration = QTDEMUX_GUINT32_GET (mdhd->data + 24); stream->duration = QTDEMUX_GUINT32_GET ((guint8 *) mdhd->data + 24);
GST_LOG ("track timescale: %d", stream->timescale); GST_LOG ("track timescale: %d", stream->timescale);
GST_LOG ("track duration: %d", stream->duration); GST_LOG ("track duration: %d", stream->duration);
@ -3263,9 +3267,9 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
g_assert (hdlr); g_assert (hdlr);
GST_LOG ("track type: %" GST_FOURCC_FORMAT, GST_LOG ("track type: %" GST_FOURCC_FORMAT,
GST_FOURCC_ARGS (QTDEMUX_FOURCC_GET (hdlr->data + 12))); GST_FOURCC_ARGS (QTDEMUX_FOURCC_GET ((guint8 *) hdlr->data + 12)));
stream->subtype = QTDEMUX_FOURCC_GET (hdlr->data + 16); stream->subtype = QTDEMUX_FOURCC_GET ((guint8 *) hdlr->data + 16);
GST_LOG ("track subtype: %" GST_FOURCC_FORMAT, GST_LOG ("track subtype: %" GST_FOURCC_FORMAT,
GST_FOURCC_ARGS (stream->subtype)); GST_FOURCC_ARGS (stream->subtype));
@ -3277,6 +3281,7 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
stsd = qtdemux_tree_get_child_by_type (stbl, FOURCC_stsd); stsd = qtdemux_tree_get_child_by_type (stbl, FOURCC_stsd);
g_assert (stsd); g_assert (stsd);
stsd_data = (const guint8 *) stsd->data;
if (stream->subtype == FOURCC_vide) { if (stream->subtype == FOURCC_vide) {
guint32 fourcc; guint32 fourcc;
@ -3284,24 +3289,24 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
stream->sampled = TRUE; stream->sampled = TRUE;
offset = 16; offset = 16;
stream->fourcc = fourcc = QTDEMUX_FOURCC_GET (stsd->data + offset + 4); stream->fourcc = fourcc = QTDEMUX_FOURCC_GET (stsd_data + offset + 4);
GST_LOG ("st type: %" GST_FOURCC_FORMAT, GST_FOURCC_ARGS (fourcc)); GST_LOG ("st type: %" GST_FOURCC_FORMAT, GST_FOURCC_ARGS (fourcc));
stream->width = QTDEMUX_GUINT16_GET (stsd->data + offset + 32); stream->width = QTDEMUX_GUINT16_GET (stsd_data + offset + 32);
stream->height = QTDEMUX_GUINT16_GET (stsd->data + offset + 34); stream->height = QTDEMUX_GUINT16_GET (stsd_data + offset + 34);
stream->fps_n = 0; /* this is filled in later */ stream->fps_n = 0; /* this is filled in later */
stream->fps_d = 0; /* this is filled in later */ stream->fps_d = 0; /* this is filled in later */
stream->bits_per_sample = QTDEMUX_GUINT16_GET (stsd->data + offset + 82); stream->bits_per_sample = QTDEMUX_GUINT16_GET (stsd_data + offset + 82);
stream->color_table_id = QTDEMUX_GUINT16_GET (stsd->data + offset + 84); stream->color_table_id = QTDEMUX_GUINT16_GET (stsd_data + offset + 84);
GST_LOG ("frame count: %u", GST_LOG ("frame count: %u",
QTDEMUX_GUINT16_GET (stsd->data + offset + 48)); QTDEMUX_GUINT16_GET (stsd_data + offset + 48));
if (fourcc == GST_MAKE_FOURCC ('d', 'r', 'm', 's')) if (fourcc == GST_MAKE_FOURCC ('d', 'r', 'm', 's'))
goto error_encrypted; goto error_encrypted;
stream->caps = qtdemux_video_caps (qtdemux, fourcc, stsd->data, &codec); stream->caps = qtdemux_video_caps (qtdemux, fourcc, stsd_data, &codec);
if (codec) { if (codec) {
list = gst_tag_list_new (); list = gst_tag_list_new ();
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE, gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
@ -3316,69 +3321,69 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
if (esds) { if (esds) {
gst_qtdemux_handle_esds (qtdemux, stream, esds, list); gst_qtdemux_handle_esds (qtdemux, stream, esds, list);
} else { } else {
if (QTDEMUX_FOURCC_GET ((char *) stsd->data + 16 + 4) == if (QTDEMUX_FOURCC_GET (stsd_data + 16 + 4) ==
GST_MAKE_FOURCC ('a', 'v', 'c', '1')) { GST_MAKE_FOURCC ('a', 'v', 'c', '1')) {
gint len = QTDEMUX_GUINT32_GET (stsd->data) - 0x66; gint len = QTDEMUX_GUINT32_GET (stsd_data) - 0x66;
guint8 *stsddata = stsd->data + 0x66; const guint8 *avc_data = stsd_data + 0x66;
/* find avcC */ /* find avcC */
while (len >= 0x8 && while (len >= 0x8 &&
QTDEMUX_FOURCC_GET (stsddata + 0x4) != QTDEMUX_FOURCC_GET (avc_data + 0x4) !=
GST_MAKE_FOURCC ('a', 'v', 'c', 'C') && GST_MAKE_FOURCC ('a', 'v', 'c', 'C') &&
QTDEMUX_GUINT32_GET (stsddata) < len) { QTDEMUX_GUINT32_GET (avc_data) < len) {
len -= QTDEMUX_GUINT32_GET (stsddata); len -= QTDEMUX_GUINT32_GET (avc_data);
stsddata += QTDEMUX_GUINT32_GET (stsddata); avc_data += QTDEMUX_GUINT32_GET (avc_data);
} }
/* parse, if found */ /* parse, if found */
if (len > 0x8 && if (len > 0x8 &&
QTDEMUX_FOURCC_GET (stsddata + 0x4) == QTDEMUX_FOURCC_GET (avc_data + 0x4) ==
GST_MAKE_FOURCC ('a', 'v', 'c', 'C')) { GST_MAKE_FOURCC ('a', 'v', 'c', 'C')) {
GstBuffer *buf; GstBuffer *buf;
gint size; gint size;
if (QTDEMUX_GUINT32_GET (stsddata) < len) if (QTDEMUX_GUINT32_GET (avc_data) < len)
size = QTDEMUX_GUINT32_GET (stsddata) - 0x8; size = QTDEMUX_GUINT32_GET (avc_data) - 0x8;
else else
size = len - 0x8; size = len - 0x8;
buf = gst_buffer_new_and_alloc (size); buf = gst_buffer_new_and_alloc (size);
memcpy (GST_BUFFER_DATA (buf), stsddata + 0x8, size); memcpy (GST_BUFFER_DATA (buf), avc_data + 0x8, size);
gst_caps_set_simple (stream->caps, gst_caps_set_simple (stream->caps,
"codec_data", GST_TYPE_BUFFER, buf, NULL); "codec_data", GST_TYPE_BUFFER, buf, NULL);
gst_buffer_unref (buf); gst_buffer_unref (buf);
} }
} else if (QTDEMUX_FOURCC_GET (stsd->data + 16 + 4) == } else if (QTDEMUX_FOURCC_GET (stsd_data + 16 + 4) ==
GST_MAKE_FOURCC ('S', 'V', 'Q', '3')) { GST_MAKE_FOURCC ('S', 'V', 'Q', '3')) {
GstBuffer *buf; GstBuffer *buf;
gint len = QTDEMUX_GUINT32_GET (stsd->data); gint len = QTDEMUX_GUINT32_GET (stsd_data);
buf = gst_buffer_new_and_alloc (len); buf = gst_buffer_new_and_alloc (len);
memcpy (GST_BUFFER_DATA (buf), stsd->data, len); memcpy (GST_BUFFER_DATA (buf), stsd_data, len);
gst_caps_set_simple (stream->caps, gst_caps_set_simple (stream->caps,
"codec_data", GST_TYPE_BUFFER, buf, NULL); "codec_data", GST_TYPE_BUFFER, buf, NULL);
gst_buffer_unref (buf); gst_buffer_unref (buf);
} else if (QTDEMUX_FOURCC_GET (stsd->data + 16 + 4) == } else if (QTDEMUX_FOURCC_GET (stsd_data + 16 + 4) ==
GST_MAKE_FOURCC ('V', 'P', '3', '1')) { GST_MAKE_FOURCC ('V', 'P', '3', '1')) {
GstBuffer *buf; GstBuffer *buf;
gint len = QTDEMUX_GUINT32_GET (stsd->data); gint len = QTDEMUX_GUINT32_GET (stsd_data);
buf = gst_buffer_new_and_alloc (len); buf = gst_buffer_new_and_alloc (len);
memcpy (GST_BUFFER_DATA (buf), stsd->data, len); memcpy (GST_BUFFER_DATA (buf), stsd_data, len);
gst_caps_set_simple (stream->caps, gst_caps_set_simple (stream->caps,
"codec_data", GST_TYPE_BUFFER, buf, NULL); "codec_data", GST_TYPE_BUFFER, buf, NULL);
gst_buffer_unref (buf); gst_buffer_unref (buf);
} else if (QTDEMUX_FOURCC_GET (stsd->data + 16 + 4) == } else if (QTDEMUX_FOURCC_GET (stsd_data + 16 + 4) ==
GST_MAKE_FOURCC ('r', 'l', 'e', ' ')) { GST_MAKE_FOURCC ('r', 'l', 'e', ' ')) {
gst_caps_set_simple (stream->caps, gst_caps_set_simple (stream->caps,
"depth", G_TYPE_INT, QTDEMUX_GUINT16_GET (stsd->data + offset + 82), "depth", G_TYPE_INT, QTDEMUX_GUINT16_GET (stsd_data + offset + 82),
NULL); NULL);
} }
} }
GST_INFO_OBJECT (qtdemux, GST_INFO_OBJECT (qtdemux,
"type %" GST_FOURCC_FORMAT " caps %" GST_PTR_FORMAT, "type %" GST_FOURCC_FORMAT " caps %" GST_PTR_FORMAT,
GST_FOURCC_ARGS (QTDEMUX_FOURCC_GET (stsd->data + offset + 4)), GST_FOURCC_ARGS (QTDEMUX_FOURCC_GET (stsd_data + offset + 4)),
stream->caps); stream->caps);
} else if (stream->subtype == FOURCC_soun) { } else if (stream->subtype == FOURCC_soun) {
int version, samplesize; int version, samplesize;
@ -3386,29 +3391,29 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
int len; int len;
guint16 compression_id; guint16 compression_id;
len = QTDEMUX_GUINT32_GET (stsd->data + 16); len = QTDEMUX_GUINT32_GET (stsd_data + 16);
GST_LOG ("stsd len: %d", len); GST_LOG ("stsd len: %d", len);
stream->fourcc = fourcc = QTDEMUX_FOURCC_GET (stsd->data + 16 + 4); stream->fourcc = fourcc = QTDEMUX_FOURCC_GET (stsd_data + 16 + 4);
GST_LOG ("stsd type: %" GST_FOURCC_FORMAT, GST_LOG ("stsd type: %" GST_FOURCC_FORMAT,
GST_FOURCC_ARGS (stream->fourcc)); GST_FOURCC_ARGS (stream->fourcc));
offset = 32; offset = 32;
version = QTDEMUX_GUINT32_GET (stsd->data + offset); version = QTDEMUX_GUINT32_GET (stsd_data + offset);
stream->n_channels = QTDEMUX_GUINT16_GET (stsd->data + offset + 8); stream->n_channels = QTDEMUX_GUINT16_GET (stsd_data + offset + 8);
samplesize = QTDEMUX_GUINT16_GET (stsd->data + offset + 10); samplesize = QTDEMUX_GUINT16_GET (stsd_data + offset + 10);
compression_id = QTDEMUX_GUINT16_GET (stsd->data + offset + 12); compression_id = QTDEMUX_GUINT16_GET (stsd_data + offset + 12);
stream->rate = QTDEMUX_FP32_GET (stsd->data + offset + 16); stream->rate = QTDEMUX_FP32_GET (stsd_data + offset + 16);
GST_LOG ("version/rev: %08x", version); GST_LOG ("version/rev: %08x", version);
GST_LOG ("vendor: %08x", GST_LOG ("vendor: %08x",
QTDEMUX_GUINT32_GET (stsd->data + offset + 4)); QTDEMUX_GUINT32_GET (stsd_data + offset + 4));
GST_LOG ("n_channels: %d", stream->n_channels); GST_LOG ("n_channels: %d", stream->n_channels);
GST_LOG ("sample_size: %d", samplesize); GST_LOG ("sample_size: %d", samplesize);
GST_LOG ("compression_id: %d", compression_id); GST_LOG ("compression_id: %d", compression_id);
GST_LOG ("packet size: %d", GST_LOG ("packet size: %d",
QTDEMUX_GUINT16_GET (stsd->data + offset + 14)); QTDEMUX_GUINT16_GET (stsd_data + offset + 14));
GST_LOG ("sample rate: %g", stream->rate); GST_LOG ("sample rate: %g", stream->rate);
if (compression_id == 0xfffe) if (compression_id == 0xfffe)
@ -3453,10 +3458,10 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
stream->samples_per_frame = 1 * stream->n_channels; stream->samples_per_frame = 1 * stream->n_channels;
} }
} else if (version == 0x00010000) { } else if (version == 0x00010000) {
stream->samples_per_packet = QTDEMUX_GUINT32_GET (stsd->data + offset); stream->samples_per_packet = QTDEMUX_GUINT32_GET (stsd_data + offset);
stream->bytes_per_packet = QTDEMUX_GUINT32_GET (stsd->data + offset + 4); stream->bytes_per_packet = QTDEMUX_GUINT32_GET (stsd_data + offset + 4);
stream->bytes_per_frame = QTDEMUX_GUINT32_GET (stsd->data + offset + 8); stream->bytes_per_frame = QTDEMUX_GUINT32_GET (stsd_data + offset + 8);
stream->bytes_per_sample = QTDEMUX_GUINT32_GET (stsd->data + offset + 12); stream->bytes_per_sample = QTDEMUX_GUINT32_GET (stsd_data + offset + 12);
GST_LOG ("samples/packet: %d", stream->samples_per_packet); GST_LOG ("samples/packet: %d", stream->samples_per_packet);
GST_LOG ("bytes/packet: %d", stream->bytes_per_packet); GST_LOG ("bytes/packet: %d", stream->bytes_per_packet);
@ -3480,10 +3485,10 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
guint64 val; guint64 val;
} qtfp; } qtfp;
stream->samples_per_packet = QTDEMUX_GUINT32_GET (stsd->data + offset); stream->samples_per_packet = QTDEMUX_GUINT32_GET (stsd_data + offset);
qtfp.val = QTDEMUX_GUINT64_GET (stsd->data + offset + 4); qtfp.val = QTDEMUX_GUINT64_GET (stsd_data + offset + 4);
stream->rate = qtfp.fp; stream->rate = qtfp.fp;
stream->n_channels = QTDEMUX_GUINT32_GET (stsd->data + offset + 12); stream->n_channels = QTDEMUX_GUINT32_GET (stsd_data + offset + 12);
GST_LOG ("samples/packet: %d", stream->samples_per_packet); GST_LOG ("samples/packet: %d", stream->samples_per_packet);
GST_LOG ("sample rate: %g", stream->rate); GST_LOG ("sample rate: %g", stream->rate);
@ -3520,30 +3525,28 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
if (esds) { if (esds) {
gst_qtdemux_handle_esds (qtdemux, stream, esds, list); gst_qtdemux_handle_esds (qtdemux, stream, esds, list);
} else { } else {
if (QTDEMUX_FOURCC_GET (stsd->data + 16 + 4) == if (QTDEMUX_FOURCC_GET (stsd_data + 16 + 4) ==
GST_MAKE_FOURCC ('Q', 'D', 'M', '2')) { GST_MAKE_FOURCC ('Q', 'D', 'M', '2')) {
gint len = QTDEMUX_GUINT32_GET (stsd->data); gint len = QTDEMUX_GUINT32_GET (stsd_data);
if (len > 0x4C) { if (len > 0x4C) {
GstBuffer *buf = gst_buffer_new_and_alloc (len - 0x4C); GstBuffer *buf = gst_buffer_new_and_alloc (len - 0x4C);
memcpy (GST_BUFFER_DATA (buf), memcpy (GST_BUFFER_DATA (buf), stsd_data + 0x4C, len - 0x4C);
(guint8 *) stsd->data + 0x4C, len - 0x4C);
gst_caps_set_simple (stream->caps, gst_caps_set_simple (stream->caps,
"codec_data", GST_TYPE_BUFFER, buf, NULL); "codec_data", GST_TYPE_BUFFER, buf, NULL);
gst_buffer_unref (buf); gst_buffer_unref (buf);
} }
gst_caps_set_simple (stream->caps, gst_caps_set_simple (stream->caps,
"samplesize", G_TYPE_INT, samplesize, NULL); "samplesize", G_TYPE_INT, samplesize, NULL);
} else if (QTDEMUX_FOURCC_GET (stsd->data + 16 + 4) == } else if (QTDEMUX_FOURCC_GET (stsd_data + 16 + 4) ==
GST_MAKE_FOURCC ('a', 'l', 'a', 'c')) { GST_MAKE_FOURCC ('a', 'l', 'a', 'c')) {
gint len = QTDEMUX_GUINT32_GET (stsd->data); gint len = QTDEMUX_GUINT32_GET (stsd_data);
if (len > 0x34) { if (len > 0x34) {
GstBuffer *buf = gst_buffer_new_and_alloc (len - 0x34); GstBuffer *buf = gst_buffer_new_and_alloc (len - 0x34);
memcpy (GST_BUFFER_DATA (buf), memcpy (GST_BUFFER_DATA (buf), stsd_data + 0x34, len - 0x34);
(guint8 *) stsd->data + 0x34, len - 0x34);
gst_caps_set_simple (stream->caps, gst_caps_set_simple (stream->caps,
"codec_data", GST_TYPE_BUFFER, buf, NULL); "codec_data", GST_TYPE_BUFFER, buf, NULL);
gst_buffer_unref (buf); gst_buffer_unref (buf);
@ -3554,12 +3557,12 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
} }
GST_INFO_OBJECT (qtdemux, GST_INFO_OBJECT (qtdemux,
"type %" GST_FOURCC_FORMAT " caps %" GST_PTR_FORMAT, "type %" GST_FOURCC_FORMAT " caps %" GST_PTR_FORMAT,
GST_FOURCC_ARGS (QTDEMUX_FOURCC_GET (stsd->data + 16 + 4)), GST_FOURCC_ARGS (QTDEMUX_FOURCC_GET (stsd_data + 16 + 4)),
stream->caps); stream->caps);
} else if (stream->subtype == FOURCC_strm) { } else if (stream->subtype == FOURCC_strm) {
guint32 fourcc; guint32 fourcc;
stream->fourcc = fourcc = QTDEMUX_FOURCC_GET (stsd->data + 16 + 4); stream->fourcc = fourcc = QTDEMUX_FOURCC_GET (stsd_data + 16 + 4);
GST_LOG_OBJECT (qtdemux, "stsd type: %" GST_FOURCC_FORMAT, GST_LOG_OBJECT (qtdemux, "stsd type: %" GST_FOURCC_FORMAT,
GST_FOURCC_ARGS (fourcc)); GST_FOURCC_ARGS (fourcc));
@ -3590,22 +3593,25 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
/* sample to chunk */ /* sample to chunk */
stsc = qtdemux_tree_get_child_by_type (stbl, FOURCC_stsc); stsc = qtdemux_tree_get_child_by_type (stbl, FOURCC_stsc);
g_assert (stsc); g_assert (stsc);
stsc_data = (const guint8 *) stsc->data;
/* sample size */ /* sample size */
stsz = qtdemux_tree_get_child_by_type (stbl, FOURCC_stsz); stsz = qtdemux_tree_get_child_by_type (stbl, FOURCC_stsz);
g_assert (stsz); g_assert (stsz);
stsz_data = (const guint8 *) stsz->data;
/* chunk offsets */ /* chunk offsets */
stco = qtdemux_tree_get_child_by_type (stbl, FOURCC_stco); stco = qtdemux_tree_get_child_by_type (stbl, FOURCC_stco);
co64 = qtdemux_tree_get_child_by_type (stbl, FOURCC_co64); co64 = qtdemux_tree_get_child_by_type (stbl, FOURCC_co64);
g_assert (stco || co64); g_assert (stco || co64);
stco_data = (const guint8 *) stco->data;
/* sample time */ /* sample time */
stts = qtdemux_tree_get_child_by_type (stbl, FOURCC_stts); stts = qtdemux_tree_get_child_by_type (stbl, FOURCC_stts);
g_assert (stts); g_assert (stts);
/* sample sync, can be NULL */ /* sample sync, can be NULL */
stss = qtdemux_tree_get_child_by_type (stbl, FOURCC_stss); stss = qtdemux_tree_get_child_by_type (stbl, FOURCC_stss);
sample_size = QTDEMUX_GUINT32_GET (stsz->data + 12); sample_size = QTDEMUX_GUINT32_GET (stsz_data + 12);
if (sample_size == 0 || stream->sampled) { if (sample_size == 0 || stream->sampled) {
n_samples = QTDEMUX_GUINT32_GET (stsz->data + 16); n_samples = QTDEMUX_GUINT32_GET (stsz_data + 16);
GST_DEBUG_OBJECT (qtdemux, "stsz sample_size 0, allocating n_samples %d", GST_DEBUG_OBJECT (qtdemux, "stsz sample_size 0, allocating n_samples %d",
n_samples); n_samples);
stream->n_samples = n_samples; stream->n_samples = n_samples;
@ -3614,7 +3620,7 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
for (i = 0; i < n_samples; i++) { for (i = 0; i < n_samples; i++) {
if (sample_size == 0) if (sample_size == 0)
samples[i].size = QTDEMUX_GUINT32_GET (stsz->data + i * 4 + 20); samples[i].size = QTDEMUX_GUINT32_GET (stsz_data + i * 4 + 20);
else else
samples[i].size = sample_size; samples[i].size = sample_size;
@ -3622,28 +3628,29 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
/* init other fields to defaults for this sample */ /* init other fields to defaults for this sample */
samples[i].keyframe = FALSE; samples[i].keyframe = FALSE;
} }
n_samples_per_chunk = QTDEMUX_GUINT32_GET (stsc->data + 12); n_samples_per_chunk = QTDEMUX_GUINT32_GET (stsc_data + 12);
index = 0; index = 0;
offset = 16; offset = 16;
for (i = 0; i < n_samples_per_chunk; i++) { for (i = 0; i < n_samples_per_chunk; i++) {
guint32 first_chunk, last_chunk; guint32 first_chunk, last_chunk;
guint32 samples_per_chunk; guint32 samples_per_chunk;
first_chunk = QTDEMUX_GUINT32_GET (stsc->data + 16 + i * 12 + 0) - 1; first_chunk = QTDEMUX_GUINT32_GET (stsc_data + 16 + i * 12 + 0) - 1;
if (i == n_samples_per_chunk - 1) { if (i == n_samples_per_chunk - 1) {
last_chunk = G_MAXUINT32; last_chunk = G_MAXUINT32;
} else { } else {
last_chunk = QTDEMUX_GUINT32_GET (stsc->data + 16 + i * 12 + 12) - 1; last_chunk = QTDEMUX_GUINT32_GET (stsc_data + 16 + i * 12 + 12) - 1;
} }
samples_per_chunk = QTDEMUX_GUINT32_GET (stsc->data + 16 + i * 12 + 4); samples_per_chunk = QTDEMUX_GUINT32_GET (stsc_data + 16 + i * 12 + 4);
for (j = first_chunk; j < last_chunk; j++) { for (j = first_chunk; j < last_chunk; j++) {
guint64 chunk_offset; guint64 chunk_offset;
if (stco) { if (stco) {
chunk_offset = QTDEMUX_GUINT32_GET (stco->data + 16 + j * 4); chunk_offset = QTDEMUX_GUINT32_GET (stco_data + 16 + j * 4);
} else { } else {
chunk_offset = QTDEMUX_GUINT64_GET (co64->data + 16 + j * 8); chunk_offset =
QTDEMUX_GUINT64_GET ((guint8 *) co64->data + 16 + j * 8);
} }
for (k = 0; k < samples_per_chunk; k++) { for (k = 0; k < samples_per_chunk; k++) {
GST_LOG_OBJECT (qtdemux, "Creating entry %d with offset %lld", GST_LOG_OBJECT (qtdemux, "Creating entry %d with offset %lld",
@ -3659,7 +3666,7 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
} }
done: done:
n_sample_times = QTDEMUX_GUINT32_GET (stts->data + 12); n_sample_times = QTDEMUX_GUINT32_GET ((guint8 *) stts->data + 12);
timestamp = 0; timestamp = 0;
stream->min_duration = 0; stream->min_duration = 0;
time = 0; time = 0;
@ -3668,8 +3675,8 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
guint32 n; guint32 n;
guint32 duration; guint32 duration;
n = QTDEMUX_GUINT32_GET (stts->data + 16 + 8 * i); n = QTDEMUX_GUINT32_GET ((guint8 *) stts->data + 16 + 8 * i);
duration = QTDEMUX_GUINT32_GET (stts->data + 16 + 8 * i + 4); duration = QTDEMUX_GUINT32_GET ((guint8 *) stts->data + 16 + 8 * i + 4);
for (j = 0; j < n; j++) { for (j = 0; j < n; j++) {
GST_INFO_OBJECT (qtdemux, "sample %d: timestamp %" GST_TIME_FORMAT, GST_INFO_OBJECT (qtdemux, "sample %d: timestamp %" GST_TIME_FORMAT,
index, GST_TIME_ARGS (timestamp)); index, GST_TIME_ARGS (timestamp));
@ -3691,14 +3698,14 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
/* mark keyframes */ /* mark keyframes */
guint32 n_sample_syncs; guint32 n_sample_syncs;
n_sample_syncs = QTDEMUX_GUINT32_GET (stss->data + 12); n_sample_syncs = QTDEMUX_GUINT32_GET ((guint8 *) stss->data + 12);
if (n_sample_syncs == 0) { if (n_sample_syncs == 0) {
stream->all_keyframe = TRUE; stream->all_keyframe = TRUE;
} else { } else {
offset = 16; offset = 16;
for (i = 0; i < n_sample_syncs; i++) { for (i = 0; i < n_sample_syncs; i++) {
/* not that the first sample is index 1, not 0 */ /* not that the first sample is index 1, not 0 */
index = QTDEMUX_GUINT32_GET (stss->data + offset); index = QTDEMUX_GUINT32_GET ((guint8 *) stss->data + offset);
samples[index - 1].keyframe = TRUE; samples[index - 1].keyframe = TRUE;
offset += 4; offset += 4;
} }
@ -3713,16 +3720,16 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
/* treat chunks as samples */ /* treat chunks as samples */
if (stco) { if (stco) {
n_samples = QTDEMUX_GUINT32_GET (stco->data + 12); n_samples = QTDEMUX_GUINT32_GET (stco_data + 12);
} else { } else {
n_samples = QTDEMUX_GUINT32_GET (co64->data + 12); n_samples = QTDEMUX_GUINT32_GET ((guint8 *) co64->data + 12);
} }
stream->n_samples = n_samples; stream->n_samples = n_samples;
GST_DEBUG_OBJECT (qtdemux, "allocating n_samples %d", n_samples); GST_DEBUG_OBJECT (qtdemux, "allocating n_samples %d", n_samples);
samples = g_new0 (QtDemuxSample, n_samples); samples = g_new0 (QtDemuxSample, n_samples);
stream->samples = samples; stream->samples = samples;
n_samples_per_chunk = QTDEMUX_GUINT32_GET (stsc->data + 12); n_samples_per_chunk = QTDEMUX_GUINT32_GET (stsc_data + 12);
GST_DEBUG_OBJECT (qtdemux, "n_samples_per_chunk %d", n_samples_per_chunk); GST_DEBUG_OBJECT (qtdemux, "n_samples_per_chunk %d", n_samples_per_chunk);
offset = 16; offset = 16;
sample_index = 0; sample_index = 0;
@ -3731,16 +3738,16 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
guint32 first_chunk, last_chunk; guint32 first_chunk, last_chunk;
guint32 samples_per_chunk; guint32 samples_per_chunk;
first_chunk = QTDEMUX_GUINT32_GET (stsc->data + 16 + i * 12 + 0) - 1; first_chunk = QTDEMUX_GUINT32_GET (stsc_data + 16 + i * 12 + 0) - 1;
/* the last chunk of each entry is calculated by taking the first chunk /* the last chunk of each entry is calculated by taking the first chunk
* of the next entry; except if there is no next, where we fake it with * of the next entry; except if there is no next, where we fake it with
* INT_MAX */ * INT_MAX */
if (i == n_samples_per_chunk - 1) { if (i == n_samples_per_chunk - 1) {
last_chunk = G_MAXUINT32; last_chunk = G_MAXUINT32;
} else { } else {
last_chunk = QTDEMUX_GUINT32_GET (stsc->data + 16 + i * 12 + 12) - 1; last_chunk = QTDEMUX_GUINT32_GET (stsc_data + 16 + i * 12 + 12) - 1;
} }
samples_per_chunk = QTDEMUX_GUINT32_GET (stsc->data + 16 + i * 12 + 4); samples_per_chunk = QTDEMUX_GUINT32_GET (stsc_data + 16 + i * 12 + 4);
GST_LOG_OBJECT (qtdemux, GST_LOG_OBJECT (qtdemux,
"entry %d has first_chunk %d, last_chunk %d, samples_per_chunk %d", i, "entry %d has first_chunk %d, last_chunk %d, samples_per_chunk %d", i,
@ -3752,9 +3759,10 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
if (j >= n_samples) if (j >= n_samples)
goto done2; goto done2;
if (stco) { if (stco) {
chunk_offset = QTDEMUX_GUINT32_GET (stco->data + 16 + j * 4); chunk_offset = QTDEMUX_GUINT32_GET (stco_data + 16 + j * 4);
} else { } else {
chunk_offset = QTDEMUX_GUINT64_GET (co64->data + 16 + j * 8); chunk_offset =
QTDEMUX_GUINT64_GET ((guint8 *) co64->data + 16 + j * 8);
} }
GST_LOG_OBJECT (qtdemux, GST_LOG_OBJECT (qtdemux,
"Creating entry %d with offset %" G_GUINT64_FORMAT, j, "Creating entry %d with offset %" G_GUINT64_FORMAT, j,
@ -3977,7 +3985,7 @@ qtdemux_tag_add_str (GstQTDemux * qtdemux, const char *tag, GNode * node)
data = qtdemux_tree_get_child_by_type (node, FOURCC_data); data = qtdemux_tree_get_child_by_type (node, FOURCC_data);
if (data) { if (data) {
len = QTDEMUX_GUINT32_GET (data->data); len = QTDEMUX_GUINT32_GET (data->data);
type = QTDEMUX_GUINT32_GET (data->data + 8); type = QTDEMUX_GUINT32_GET ((guint8 *) data->data + 8);
if (type == 0x00000001) { if (type == 0x00000001) {
s = g_strndup ((char *) data->data + 16, len - 16); s = g_strndup ((char *) data->data + 16, len - 16);
GST_DEBUG_OBJECT (qtdemux, "adding tag %s", s); GST_DEBUG_OBJECT (qtdemux, "adding tag %s", s);
@ -3999,10 +4007,10 @@ qtdemux_tag_add_num (GstQTDemux * qtdemux, const char *tag1,
data = qtdemux_tree_get_child_by_type (node, FOURCC_data); data = qtdemux_tree_get_child_by_type (node, FOURCC_data);
if (data) { if (data) {
len = QTDEMUX_GUINT32_GET (data->data); len = QTDEMUX_GUINT32_GET (data->data);
type = QTDEMUX_GUINT32_GET (data->data + 8); type = QTDEMUX_GUINT32_GET ((guint8 *) data->data + 8);
if (type == 0x00000000 && len >= 22) { if (type == 0x00000000 && len >= 22) {
n1 = GST_READ_UINT16_BE (data->data + 18); n1 = GST_READ_UINT16_BE ((guint8 *) data->data + 18);
n2 = GST_READ_UINT16_BE (data->data + 20); n2 = GST_READ_UINT16_BE ((guint8 *) data->data + 20);
GST_DEBUG_OBJECT (qtdemux, "adding tag %d/%d", n1, n2); GST_DEBUG_OBJECT (qtdemux, "adding tag %d/%d", n1, n2);
gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_REPLACE, gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_REPLACE,
tag1, n1, tag2, n2, NULL); tag1, n1, tag2, n2, NULL);
@ -4021,7 +4029,7 @@ qtdemux_tag_add_date (GstQTDemux * qtdemux, const char *tag, GNode * node)
data = qtdemux_tree_get_child_by_type (node, FOURCC_data); data = qtdemux_tree_get_child_by_type (node, FOURCC_data);
if (data) { if (data) {
len = QTDEMUX_GUINT32_GET (data->data); len = QTDEMUX_GUINT32_GET (data->data);
type = QTDEMUX_GUINT32_GET (data->data + 8); type = QTDEMUX_GUINT32_GET ((guint8 *) data->data + 8);
if (type == 0x00000001) { if (type == 0x00000001) {
guint y, m = 1, d = 1; guint y, m = 1, d = 1;
gint ret; gint ret;
@ -4086,9 +4094,9 @@ qtdemux_tag_add_gnre (GstQTDemux * qtdemux, const char *tag, GNode * node)
data = qtdemux_tree_get_child_by_type (node, FOURCC_data); data = qtdemux_tree_get_child_by_type (node, FOURCC_data);
if (data) { if (data) {
len = QTDEMUX_GUINT32_GET (data->data); len = QTDEMUX_GUINT32_GET (data->data);
type = QTDEMUX_GUINT32_GET (data->data + 8); type = QTDEMUX_GUINT32_GET ((guint8 *) data->data + 8);
if (type == 0x00000000 && len >= 18) { if (type == 0x00000000 && len >= 18) {
n = GST_READ_UINT16_BE (data->data + 16); n = GST_READ_UINT16_BE ((guint8 *) data->data + 16);
if (n > 0 && n < sizeof (genres) / sizeof (char *)) { if (n > 0 && n < sizeof (genres) / sizeof (char *)) {
GST_DEBUG_OBJECT (qtdemux, "adding %d [%s]", n, genres[n]); GST_DEBUG_OBJECT (qtdemux, "adding %d [%s]", n, genres[n]);
gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_REPLACE, gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_REPLACE,