mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-07-11 09:06:05 +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)
{
GstQTDemux *demux = GST_QTDEMUX (GST_PAD_PARENT (sinkpad));
gboolean res = FALSE;
gboolean res;
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_NEWSEGMENT:
/* We need to convert it to a GST_FORMAT_TIME new segment */
gst_event_unref (event);
res = TRUE;
break;
default:
gst_pad_event_default (demux->sinkpad, event);
return TRUE;
res = gst_pad_event_default (demux->sinkpad, event);
break;
}
gst_event_unref (event);
return res;
}
@ -1596,7 +1598,7 @@ next_entry_size (GstQTDemux * demux)
QtDemuxStream *stream;
int i;
int smallidx = -1;
guint64 smalloffs = -1;
guint64 smalloffs = (guint64) - 1;
GST_LOG_OBJECT (demux, "Finding entry at offset %lld", demux->offset);
@ -2057,7 +2059,7 @@ qtdemux_zfree (void *opaque, void *addr)
static void *
qtdemux_inflate (void *z_buffer, int z_length, int length)
{
void *buffer;
guint8 *buffer;
z_stream *z;
int ret;
@ -2069,12 +2071,12 @@ qtdemux_inflate (void *z_buffer, int z_length, int length)
z->next_in = z_buffer;
z->avail_in = z_length;
buffer = g_malloc (length);
buffer = (guint8 *) g_malloc (length);
ret = inflateInit (z);
while (z->avail_in > 0) {
if (z->avail_out == 0) {
length += 1024;
buffer = realloc (buffer, length);
buffer = (guint8 *) g_realloc (buffer, length);
z->next_out = buffer + z->total_out;
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);
cmvd = qtdemux_tree_get_child_by_type (cmov, FOURCC_cmvd);
if (QTDEMUX_FOURCC_GET (dcom->data + 8) == GST_MAKE_FOURCC ('z', 'l', 'i',
'b')) {
if (QTDEMUX_FOURCC_GET ((guint8 *) dcom->data + 8) == GST_MAKE_FOURCC ('z',
'l', 'i', 'b')) {
int uncompressed_length;
int compressed_length;
guint8 *buf;
uncompressed_length = QTDEMUX_GUINT32_GET (cmvd->data + 8);
compressed_length = QTDEMUX_GUINT32_GET (cmvd->data + 4) - 12;
uncompressed_length = QTDEMUX_GUINT32_GET ((guint8 *) cmvd->data + 8);
compressed_length = QTDEMUX_GUINT32_GET ((guint8 *) cmvd->data + 4) - 12;
GST_LOG ("length = %d", uncompressed_length);
buf = (guint8 *) qtdemux_inflate (cmvd->data + 12, compressed_length,
uncompressed_length);
buf =
(guint8 *) qtdemux_inflate ((guint8 *) cmvd->data + 12,
compressed_length, uncompressed_length);
qtdemux->moov_node_compressed = qtdemux->moov_node;
qtdemux->moov_node = g_node_new (buf);
@ -3136,8 +3139,8 @@ qtdemux_parse_tree (GstQTDemux * qtdemux)
return;
}
qtdemux->timescale = QTDEMUX_GUINT32_GET (mvhd->data + 20);
qtdemux->duration = QTDEMUX_GUINT32_GET (mvhd->data + 24);
qtdemux->timescale = QTDEMUX_GUINT32_GET ((guint8 *) mvhd->data + 20);
qtdemux->duration = QTDEMUX_GUINT32_GET ((guint8 *) mvhd->data + 24);
GST_INFO_OBJECT (qtdemux, "timescale: %d", qtdemux->timescale);
GST_INFO_OBJECT (qtdemux, "duration: %d", qtdemux->duration);
@ -3211,12 +3214,13 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
int sample_index;
GstTagList *list = 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);
g_return_if_fail (tkhd);
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);
g_assert (mdia);
@ -3232,8 +3236,8 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
stream->sample_index = 0;
stream->last_ret = GST_FLOW_OK;
stream->timescale = QTDEMUX_GUINT32_GET (mdhd->data + 20);
stream->duration = QTDEMUX_GUINT32_GET (mdhd->data + 24);
stream->timescale = QTDEMUX_GUINT32_GET ((guint8 *) mdhd->data + 20);
stream->duration = QTDEMUX_GUINT32_GET ((guint8 *) mdhd->data + 24);
GST_LOG ("track timescale: %d", stream->timescale);
GST_LOG ("track duration: %d", stream->duration);
@ -3263,9 +3267,9 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
g_assert (hdlr);
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_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);
g_assert (stsd);
stsd_data = (const guint8 *) stsd->data;
if (stream->subtype == FOURCC_vide) {
guint32 fourcc;
@ -3284,24 +3289,24 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
stream->sampled = TRUE;
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));
stream->width = QTDEMUX_GUINT16_GET (stsd->data + offset + 32);
stream->height = QTDEMUX_GUINT16_GET (stsd->data + offset + 34);
stream->width = QTDEMUX_GUINT16_GET (stsd_data + offset + 32);
stream->height = QTDEMUX_GUINT16_GET (stsd_data + offset + 34);
stream->fps_n = 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->color_table_id = QTDEMUX_GUINT16_GET (stsd->data + offset + 84);
stream->bits_per_sample = QTDEMUX_GUINT16_GET (stsd_data + offset + 82);
stream->color_table_id = QTDEMUX_GUINT16_GET (stsd_data + offset + 84);
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'))
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) {
list = gst_tag_list_new ();
gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
@ -3316,69 +3321,69 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
if (esds) {
gst_qtdemux_handle_esds (qtdemux, stream, esds, list);
} 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')) {
gint len = QTDEMUX_GUINT32_GET (stsd->data) - 0x66;
guint8 *stsddata = stsd->data + 0x66;
gint len = QTDEMUX_GUINT32_GET (stsd_data) - 0x66;
const guint8 *avc_data = stsd_data + 0x66;
/* find avcC */
while (len >= 0x8 &&
QTDEMUX_FOURCC_GET (stsddata + 0x4) !=
QTDEMUX_FOURCC_GET (avc_data + 0x4) !=
GST_MAKE_FOURCC ('a', 'v', 'c', 'C') &&
QTDEMUX_GUINT32_GET (stsddata) < len) {
len -= QTDEMUX_GUINT32_GET (stsddata);
stsddata += QTDEMUX_GUINT32_GET (stsddata);
QTDEMUX_GUINT32_GET (avc_data) < len) {
len -= QTDEMUX_GUINT32_GET (avc_data);
avc_data += QTDEMUX_GUINT32_GET (avc_data);
}
/* parse, if found */
if (len > 0x8 &&
QTDEMUX_FOURCC_GET (stsddata + 0x4) ==
QTDEMUX_FOURCC_GET (avc_data + 0x4) ==
GST_MAKE_FOURCC ('a', 'v', 'c', 'C')) {
GstBuffer *buf;
gint size;
if (QTDEMUX_GUINT32_GET (stsddata) < len)
size = QTDEMUX_GUINT32_GET (stsddata) - 0x8;
if (QTDEMUX_GUINT32_GET (avc_data) < len)
size = QTDEMUX_GUINT32_GET (avc_data) - 0x8;
else
size = len - 0x8;
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,
"codec_data", GST_TYPE_BUFFER, buf, NULL);
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')) {
GstBuffer *buf;
gint len = QTDEMUX_GUINT32_GET (stsd->data);
gint len = QTDEMUX_GUINT32_GET (stsd_data);
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,
"codec_data", GST_TYPE_BUFFER, buf, NULL);
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')) {
GstBuffer *buf;
gint len = QTDEMUX_GUINT32_GET (stsd->data);
gint len = QTDEMUX_GUINT32_GET (stsd_data);
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,
"codec_data", GST_TYPE_BUFFER, buf, NULL);
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_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);
}
}
GST_INFO_OBJECT (qtdemux,
"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);
} else if (stream->subtype == FOURCC_soun) {
int version, samplesize;
@ -3386,29 +3391,29 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
int len;
guint16 compression_id;
len = QTDEMUX_GUINT32_GET (stsd->data + 16);
len = QTDEMUX_GUINT32_GET (stsd_data + 16);
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_FOURCC_ARGS (stream->fourcc));
offset = 32;
version = QTDEMUX_GUINT32_GET (stsd->data + offset);
stream->n_channels = QTDEMUX_GUINT16_GET (stsd->data + offset + 8);
samplesize = QTDEMUX_GUINT16_GET (stsd->data + offset + 10);
compression_id = QTDEMUX_GUINT16_GET (stsd->data + offset + 12);
stream->rate = QTDEMUX_FP32_GET (stsd->data + offset + 16);
version = QTDEMUX_GUINT32_GET (stsd_data + offset);
stream->n_channels = QTDEMUX_GUINT16_GET (stsd_data + offset + 8);
samplesize = QTDEMUX_GUINT16_GET (stsd_data + offset + 10);
compression_id = QTDEMUX_GUINT16_GET (stsd_data + offset + 12);
stream->rate = QTDEMUX_FP32_GET (stsd_data + offset + 16);
GST_LOG ("version/rev: %08x", version);
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 ("sample_size: %d", samplesize);
GST_LOG ("compression_id: %d", compression_id);
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);
if (compression_id == 0xfffe)
@ -3453,10 +3458,10 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
stream->samples_per_frame = 1 * stream->n_channels;
}
} else if (version == 0x00010000) {
stream->samples_per_packet = QTDEMUX_GUINT32_GET (stsd->data + offset);
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_sample = QTDEMUX_GUINT32_GET (stsd->data + offset + 12);
stream->samples_per_packet = QTDEMUX_GUINT32_GET (stsd_data + offset);
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_sample = QTDEMUX_GUINT32_GET (stsd_data + offset + 12);
GST_LOG ("samples/packet: %d", stream->samples_per_packet);
GST_LOG ("bytes/packet: %d", stream->bytes_per_packet);
@ -3480,10 +3485,10 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
guint64 val;
} qtfp;
stream->samples_per_packet = QTDEMUX_GUINT32_GET (stsd->data + offset);
qtfp.val = QTDEMUX_GUINT64_GET (stsd->data + offset + 4);
stream->samples_per_packet = QTDEMUX_GUINT32_GET (stsd_data + offset);
qtfp.val = QTDEMUX_GUINT64_GET (stsd_data + offset + 4);
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 ("sample rate: %g", stream->rate);
@ -3520,30 +3525,28 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
if (esds) {
gst_qtdemux_handle_esds (qtdemux, stream, esds, list);
} else {
if (QTDEMUX_FOURCC_GET (stsd->data + 16 + 4) ==
if (QTDEMUX_FOURCC_GET (stsd_data + 16 + 4) ==
GST_MAKE_FOURCC ('Q', 'D', 'M', '2')) {
gint len = QTDEMUX_GUINT32_GET (stsd->data);
gint len = QTDEMUX_GUINT32_GET (stsd_data);
if (len > 0x4C) {
GstBuffer *buf = gst_buffer_new_and_alloc (len - 0x4C);
memcpy (GST_BUFFER_DATA (buf),
(guint8 *) stsd->data + 0x4C, len - 0x4C);
memcpy (GST_BUFFER_DATA (buf), stsd_data + 0x4C, len - 0x4C);
gst_caps_set_simple (stream->caps,
"codec_data", GST_TYPE_BUFFER, buf, NULL);
gst_buffer_unref (buf);
}
gst_caps_set_simple (stream->caps,
"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')) {
gint len = QTDEMUX_GUINT32_GET (stsd->data);
gint len = QTDEMUX_GUINT32_GET (stsd_data);
if (len > 0x34) {
GstBuffer *buf = gst_buffer_new_and_alloc (len - 0x34);
memcpy (GST_BUFFER_DATA (buf),
(guint8 *) stsd->data + 0x34, len - 0x34);
memcpy (GST_BUFFER_DATA (buf), stsd_data + 0x34, len - 0x34);
gst_caps_set_simple (stream->caps,
"codec_data", GST_TYPE_BUFFER, buf, NULL);
gst_buffer_unref (buf);
@ -3554,12 +3557,12 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
}
GST_INFO_OBJECT (qtdemux,
"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);
} else if (stream->subtype == FOURCC_strm) {
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_FOURCC_ARGS (fourcc));
@ -3590,22 +3593,25 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
/* sample to chunk */
stsc = qtdemux_tree_get_child_by_type (stbl, FOURCC_stsc);
g_assert (stsc);
stsc_data = (const guint8 *) stsc->data;
/* sample size */
stsz = qtdemux_tree_get_child_by_type (stbl, FOURCC_stsz);
g_assert (stsz);
stsz_data = (const guint8 *) stsz->data;
/* chunk offsets */
stco = qtdemux_tree_get_child_by_type (stbl, FOURCC_stco);
co64 = qtdemux_tree_get_child_by_type (stbl, FOURCC_co64);
g_assert (stco || co64);
stco_data = (const guint8 *) stco->data;
/* sample time */
stts = qtdemux_tree_get_child_by_type (stbl, FOURCC_stts);
g_assert (stts);
/* sample sync, can be NULL */
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) {
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",
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++) {
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
samples[i].size = sample_size;
@ -3622,28 +3628,29 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
/* init other fields to defaults for this sample */
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;
offset = 16;
for (i = 0; i < n_samples_per_chunk; i++) {
guint32 first_chunk, last_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) {
last_chunk = G_MAXUINT32;
} 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++) {
guint64 chunk_offset;
if (stco) {
chunk_offset = QTDEMUX_GUINT32_GET (stco->data + 16 + j * 4);
chunk_offset = QTDEMUX_GUINT32_GET (stco_data + 16 + j * 4);
} 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++) {
GST_LOG_OBJECT (qtdemux, "Creating entry %d with offset %lld",
@ -3659,7 +3666,7 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
}
done:
n_sample_times = QTDEMUX_GUINT32_GET (stts->data + 12);
n_sample_times = QTDEMUX_GUINT32_GET ((guint8 *) stts->data + 12);
timestamp = 0;
stream->min_duration = 0;
time = 0;
@ -3668,8 +3675,8 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
guint32 n;
guint32 duration;
n = QTDEMUX_GUINT32_GET (stts->data + 16 + 8 * i);
duration = QTDEMUX_GUINT32_GET (stts->data + 16 + 8 * i + 4);
n = QTDEMUX_GUINT32_GET ((guint8 *) stts->data + 16 + 8 * i);
duration = QTDEMUX_GUINT32_GET ((guint8 *) stts->data + 16 + 8 * i + 4);
for (j = 0; j < n; j++) {
GST_INFO_OBJECT (qtdemux, "sample %d: timestamp %" GST_TIME_FORMAT,
index, GST_TIME_ARGS (timestamp));
@ -3691,14 +3698,14 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
/* mark keyframes */
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) {
stream->all_keyframe = TRUE;
} else {
offset = 16;
for (i = 0; i < n_sample_syncs; i++) {
/* 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;
offset += 4;
}
@ -3713,16 +3720,16 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
/* treat chunks as samples */
if (stco) {
n_samples = QTDEMUX_GUINT32_GET (stco->data + 12);
n_samples = QTDEMUX_GUINT32_GET (stco_data + 12);
} else {
n_samples = QTDEMUX_GUINT32_GET (co64->data + 12);
n_samples = QTDEMUX_GUINT32_GET ((guint8 *) co64->data + 12);
}
stream->n_samples = n_samples;
GST_DEBUG_OBJECT (qtdemux, "allocating n_samples %d", n_samples);
samples = g_new0 (QtDemuxSample, n_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);
offset = 16;
sample_index = 0;
@ -3731,16 +3738,16 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
guint32 first_chunk, last_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
* of the next entry; except if there is no next, where we fake it with
* INT_MAX */
if (i == n_samples_per_chunk - 1) {
last_chunk = G_MAXUINT32;
} 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,
"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)
goto done2;
if (stco) {
chunk_offset = QTDEMUX_GUINT32_GET (stco->data + 16 + j * 4);
chunk_offset = QTDEMUX_GUINT32_GET (stco_data + 16 + j * 4);
} 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,
"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);
if (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) {
s = g_strndup ((char *) data->data + 16, len - 16);
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);
if (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) {
n1 = GST_READ_UINT16_BE (data->data + 18);
n2 = GST_READ_UINT16_BE (data->data + 20);
n1 = GST_READ_UINT16_BE ((guint8 *) data->data + 18);
n2 = GST_READ_UINT16_BE ((guint8 *) data->data + 20);
GST_DEBUG_OBJECT (qtdemux, "adding tag %d/%d", n1, n2);
gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_REPLACE,
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);
if (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) {
guint y, m = 1, d = 1;
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);
if (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) {
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 *)) {
GST_DEBUG_OBJECT (qtdemux, "adding %d [%s]", n, genres[n]);
gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_REPLACE,