+++ /dev/null
-/* GStreamer
- * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
- * Copyright (C) <2003> David A. Schleef <ds@schleef.org>
- * Copyright (C) <2006> Wim Taymans <wim@fluendo.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- */
-
-/**
- * SECTION:element-qtdemux
- *
- * <refsect2>
- * <para>
- * Demuxes a .mov file into raw or compressed audio and/or video streams.
- * </para>
- * <para>
- * This element supports both push and pull-based scheduling, depending on the
- * capabilities of the upstream elements.
- * </para>
- * <title>Example launch line</title>
- * <para>
- * <programlisting>
- * gst-launch filesrc location=test.mov ! qtdemux name=demux demux.audio_00 ! decodebin ! audioconvert ! audioresample ! autoaudiosink demux.video_00 ! queue ! decodebin ! ffmpegcolorspace ! videoscale ! autovideosink
- * </programlisting>
- * Play (parse and decode) a .mov file and try to output it to
- * an automatically detected soundcard and videosink. If the MOV file contains
- * compressed audio or video data, this will only work if you have the
- * right decoder elements/plugins installed.
- * </para>
- * </refsect2>
- *
- * Last reviewed on 2006-12-29 (0.10.5)
- */
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include "gst/gst-i18n-plugin.h"
-
-#include "qtdemux_types.h"
-#include "qtdemux_dump.h"
-#include "qtdemux_fourcc.h"
-#include "qtdemux.h"
-#include "qtpalette.h"
-
-#include <stdlib.h>
-#include <string.h>
-
-#ifdef HAVE_ZLIB
-# include <zlib.h>
-#endif
-
-GST_DEBUG_CATEGORY (qtdemux_debug);
-
-#if 0
-#define qtdemux_dump_mem(a,b) gst_util_dump_mem(a,b)
-#else
-#define qtdemux_dump_mem(a,b) /* */
-#endif
-
-typedef struct _QtNode QtNode;
-typedef struct _QtDemuxSegment QtDemuxSegment;
-typedef struct _QtDemuxSample QtDemuxSample;
-
-struct _QtNode
-{
- guint32 type;
- guint8 *data;
- gint len;
-};
-
-struct _QtDemuxSample
-{
- guint32 chunk;
- guint32 size;
- guint64 offset;
- GstClockTimeDiff pts_offset; /* Add this value to timestamp to get the pts */
- guint64 timestamp; /* In GstClockTime */
- guint64 duration; /* in GstClockTime */
- gboolean keyframe; /* TRUE when this packet is a keyframe */
-};
-
-struct _QtDemuxSegment
-{
- /* global time and duration, all gst time */
- guint64 time;
- guint64 stop_time;
- guint64 duration;
- /* media time of trak, all gst time */
- guint64 media_start;
- guint64 media_stop;
- gdouble rate;
-};
-
-struct _QtDemuxStream
-{
- GstPad *pad;
-
- /* stream type */
- guint32 subtype;
- GstCaps *caps;
- guint32 fourcc;
-
- /* duration/scale */
- guint64 duration; /* in timescale */
- guint32 timescale;
-
- /* our samples */
- guint32 n_samples;
- QtDemuxSample *samples;
- gboolean all_keyframe; /* TRUE when all samples are keyframes (no stss) */
- guint32 min_duration; /* duration in timescale of first sample, used for figuring out
- the framerate, in timescale units */
-
- /* if we use chunks or samples */
- gboolean sampled;
-
- /* video info */
- gint width;
- gint height;
- /* Numerator/denominator framerate */
- gint fps_n;
- gint fps_d;
- guint16 bits_per_sample;
- guint16 color_table_id;
-
- /* audio info */
- gdouble rate;
- gint n_channels;
- guint samples_per_packet;
- guint samples_per_frame;
- guint bytes_per_packet;
- guint bytes_per_sample;
- guint bytes_per_frame;
- guint compression;
-
- /* when a discontinuity is pending */
- gboolean discont;
-
- /* current position */
- guint32 segment_index;
- guint32 sample_index;
- guint64 time_position; /* in gst time */
-
- /* last GstFlowReturn */
- GstFlowReturn last_ret;
-
- /* quicktime segments */
- guint32 n_segments;
- QtDemuxSegment *segments;
- gboolean segment_pending;
-};
-
-enum QtDemuxState
-{
- QTDEMUX_STATE_INITIAL, /* Initial state (haven't got the header yet) */
- QTDEMUX_STATE_HEADER, /* Parsing the header */
- QTDEMUX_STATE_MOVIE, /* Parsing/Playing the media data */
- QTDEMUX_STATE_BUFFER_MDAT /* Buffering the mdat atom */
-};
-
-static GNode *qtdemux_tree_get_child_by_type (GNode * node, guint32 fourcc);
-static GNode *qtdemux_tree_get_sibling_by_type (GNode * node, guint32 fourcc);
-
-static const GstElementDetails gst_qtdemux_details =
-GST_ELEMENT_DETAILS ("QuickTime demuxer",
- "Codec/Demuxer",
- "Demultiplex a QuickTime file into audio and video streams",
- "David Schleef <ds@schleef.org>, Wim Taymans <wim@fluendo.com>");
-
-static GstStaticPadTemplate gst_qtdemux_sink_template =
- GST_STATIC_PAD_TEMPLATE ("sink",
- GST_PAD_SINK,
- GST_PAD_ALWAYS,
- GST_STATIC_CAPS ("video/quicktime; audio/x-m4a; application/x-3gp")
- );
-
-static GstStaticPadTemplate gst_qtdemux_videosrc_template =
-GST_STATIC_PAD_TEMPLATE ("audio_%02d",
- GST_PAD_SRC,
- GST_PAD_SOMETIMES,
- GST_STATIC_CAPS_ANY);
-
-static GstStaticPadTemplate gst_qtdemux_audiosrc_template =
-GST_STATIC_PAD_TEMPLATE ("video_%02d",
- GST_PAD_SRC,
- GST_PAD_SOMETIMES,
- GST_STATIC_CAPS_ANY);
-
-static GstElementClass *parent_class = NULL;
-
-static void gst_qtdemux_class_init (GstQTDemuxClass * klass);
-static void gst_qtdemux_base_init (GstQTDemuxClass * klass);
-static void gst_qtdemux_init (GstQTDemux * quicktime_demux);
-static void gst_qtdemux_dispose (GObject * object);
-
-static GstStateChangeReturn gst_qtdemux_change_state (GstElement * element,
- GstStateChange transition);
-static gboolean qtdemux_sink_activate (GstPad * sinkpad);
-static gboolean qtdemux_sink_activate_pull (GstPad * sinkpad, gboolean active);
-static gboolean qtdemux_sink_activate_push (GstPad * sinkpad, gboolean active);
-
-static void gst_qtdemux_loop (GstPad * pad);
-static GstFlowReturn gst_qtdemux_chain (GstPad * sinkpad, GstBuffer * inbuf);
-static gboolean gst_qtdemux_handle_sink_event (GstPad * pad, GstEvent * event);
-
-static gboolean qtdemux_parse_moov (GstQTDemux * qtdemux, guint8 * buffer,
- int length);
-static gboolean qtdemux_parse_node (GstQTDemux * qtdemux, GNode * node,
- guint8 * buffer, int length);
-static gboolean qtdemux_parse_tree (GstQTDemux * qtdemux);
-
-static void gst_qtdemux_handle_esds (GstQTDemux * qtdemux,
- QtDemuxStream * stream, GNode * esds, GstTagList * list);
-static GstCaps *qtdemux_video_caps (GstQTDemux * qtdemux, guint32 fourcc,
- const guint8 * stsd_data, const gchar ** codec_name);
-static GstCaps *qtdemux_audio_caps (GstQTDemux * qtdemux,
- QtDemuxStream * stream, guint32 fourcc, const guint8 * data, int len,
- const gchar ** codec_name);
-
-GType
-gst_qtdemux_get_type (void)
-{
- static GType qtdemux_type = 0;
-
- if (!qtdemux_type) {
- static const GTypeInfo qtdemux_info = {
- sizeof (GstQTDemuxClass),
- (GBaseInitFunc) gst_qtdemux_base_init, NULL,
- (GClassInitFunc) gst_qtdemux_class_init,
- NULL, NULL, sizeof (GstQTDemux), 0,
- (GInstanceInitFunc) gst_qtdemux_init,
- };
-
- qtdemux_type =
- g_type_register_static (GST_TYPE_ELEMENT, "GstQTDemux", &qtdemux_info,
- 0);
- }
- return qtdemux_type;
-}
-
-static void
-gst_qtdemux_base_init (GstQTDemuxClass * klass)
-{
- GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
-
- gst_element_class_add_pad_template (element_class,
- gst_static_pad_template_get (&gst_qtdemux_sink_template));
- gst_element_class_add_pad_template (element_class,
- gst_static_pad_template_get (&gst_qtdemux_videosrc_template));
- gst_element_class_add_pad_template (element_class,
- gst_static_pad_template_get (&gst_qtdemux_audiosrc_template));
- gst_element_class_set_details (element_class, &gst_qtdemux_details);
-
- GST_DEBUG_CATEGORY_INIT (qtdemux_debug, "qtdemux", 0, "qtdemux plugin");
-}
-
-static void
-gst_qtdemux_class_init (GstQTDemuxClass * klass)
-{
- GObjectClass *gobject_class;
- GstElementClass *gstelement_class;
-
- gobject_class = (GObjectClass *) klass;
- gstelement_class = (GstElementClass *) klass;
-
- parent_class = g_type_class_peek_parent (klass);
-
- gobject_class->dispose = gst_qtdemux_dispose;
-
- gstelement_class->change_state = gst_qtdemux_change_state;
-}
-
-static void
-gst_qtdemux_init (GstQTDemux * qtdemux)
-{
- qtdemux->sinkpad =
- gst_pad_new_from_static_template (&gst_qtdemux_sink_template, "sink");
- gst_pad_set_activate_function (qtdemux->sinkpad, qtdemux_sink_activate);
- gst_pad_set_activatepull_function (qtdemux->sinkpad,
- qtdemux_sink_activate_pull);
- gst_pad_set_activatepush_function (qtdemux->sinkpad,
- qtdemux_sink_activate_push);
- gst_pad_set_chain_function (qtdemux->sinkpad, gst_qtdemux_chain);
- gst_pad_set_event_function (qtdemux->sinkpad, gst_qtdemux_handle_sink_event);
- gst_element_add_pad (GST_ELEMENT_CAST (qtdemux), qtdemux->sinkpad);
-
- qtdemux->state = QTDEMUX_STATE_INITIAL;
- /* FIXME, use segment last_stop for this */
- qtdemux->last_ts = GST_CLOCK_TIME_NONE;
- qtdemux->pullbased = FALSE;
- qtdemux->neededbytes = 16;
- qtdemux->todrop = 0;
- qtdemux->adapter = gst_adapter_new ();
- qtdemux->offset = 0;
- qtdemux->mdatoffset = GST_CLOCK_TIME_NONE;
- qtdemux->mdatbuffer = NULL;
- gst_segment_init (&qtdemux->segment, GST_FORMAT_TIME);
-}
-
-static void
-gst_qtdemux_dispose (GObject * object)
-{
- GstQTDemux *qtdemux = GST_QTDEMUX (object);
-
- if (qtdemux->adapter) {
- g_object_unref (G_OBJECT (qtdemux->adapter));
- qtdemux->adapter = NULL;
- }
-
- G_OBJECT_CLASS (parent_class)->dispose (object);
-}
-
-#if 0
-static gboolean
-gst_qtdemux_src_convert (GstPad * pad, GstFormat src_format, gint64 src_value,
- GstFormat * dest_format, gint64 * dest_value)
-{
- gboolean res = TRUE;
- QtDemuxStream *stream = gst_pad_get_element_private (pad);
-
- if (stream->subtype == GST_MAKE_FOURCC ('v', 'i', 'd', 'e') &&
- (src_format == GST_FORMAT_BYTES || *dest_format == GST_FORMAT_BYTES))
- return FALSE;
-
- switch (src_format) {
- case GST_FORMAT_TIME:
- switch (*dest_format) {
- case GST_FORMAT_BYTES:
- *dest_value = src_value * 1; /* FIXME */
- break;
- case GST_FORMAT_DEFAULT:
- *dest_value = src_value * 1; /* FIXME */
- break;
- default:
- res = FALSE;
- break;
- }
- break;
- case GST_FORMAT_BYTES:
- switch (*dest_format) {
- case GST_FORMAT_TIME:
- *dest_value = src_value * 1; /* FIXME */
- break;
- default:
- res = FALSE;
- break;
- }
- break;
- case GST_FORMAT_DEFAULT:
- switch (*dest_format) {
- case GST_FORMAT_TIME:
- *dest_value = src_value * 1; /* FIXME */
- break;
- default:
- res = FALSE;
- break;
- }
- break;
- default:
- res = FALSE;
- }
-
- return res;
-}
-#endif
-
-static const GstQueryType *
-gst_qtdemux_get_src_query_types (GstPad * pad)
-{
- static const GstQueryType src_types[] = {
- GST_QUERY_POSITION,
- GST_QUERY_DURATION,
- GST_QUERY_SEEKING,
- 0
- };
-
- return src_types;
-}
-
-static gboolean
-gst_qtdemux_get_duration (GstQTDemux * qtdemux, gint64 * duration)
-{
- gboolean res = TRUE;
-
- *duration = GST_CLOCK_TIME_NONE;
-
- if (qtdemux->duration != 0) {
- if (qtdemux->duration != G_MAXINT32 && qtdemux->timescale != 0) {
- *duration = gst_util_uint64_scale (qtdemux->duration,
- GST_SECOND, qtdemux->timescale);
- }
- }
- return res;
-}
-
-static gboolean
-gst_qtdemux_handle_src_query (GstPad * pad, GstQuery * query)
-{
- gboolean res = FALSE;
- GstQTDemux *qtdemux = GST_QTDEMUX (gst_pad_get_parent (pad));
-
- switch (GST_QUERY_TYPE (query)) {
- case GST_QUERY_POSITION:
- if (GST_CLOCK_TIME_IS_VALID (qtdemux->segment.last_stop)) {
- gst_query_set_position (query, GST_FORMAT_TIME,
- qtdemux->segment.last_stop);
- res = TRUE;
- }
- break;
- case GST_QUERY_DURATION:{
- GstFormat fmt;
-
- gst_query_parse_duration (query, &fmt, NULL);
- if (fmt == GST_FORMAT_TIME) {
- gint64 duration = -1;
-
- gst_qtdemux_get_duration (qtdemux, &duration);
- if (duration > 0) {
- gst_query_set_duration (query, GST_FORMAT_TIME, duration);
- res = TRUE;
- }
- }
- break;
- }
- case GST_QUERY_SEEKING:{
- GstFormat fmt;
-
- gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL);
- if (fmt == GST_FORMAT_TIME) {
- gint64 duration = -1;
-
- gst_qtdemux_get_duration (qtdemux, &duration);
- gst_query_set_seeking (query, GST_FORMAT_TIME, qtdemux->pullbased,
- 0, duration);
- res = TRUE;
- }
- break;
- }
- default:
- res = gst_pad_query_default (pad, query);
- break;
- }
-
- gst_object_unref (qtdemux);
-
- return res;
-}
-
-/* push event on all source pads; takes ownership of the event */
-static void
-gst_qtdemux_push_event (GstQTDemux * qtdemux, GstEvent * event)
-{
- guint n;
-
- GST_DEBUG_OBJECT (qtdemux, "pushing %s event on all source pads",
- GST_EVENT_TYPE_NAME (event));
-
- for (n = 0; n < qtdemux->n_streams; n++) {
- GstPad *pad;
-
- if ((pad = qtdemux->streams[n]->pad))
- gst_pad_push_event (pad, gst_event_ref (event));
- }
- gst_event_unref (event);
-}
-
-/* find the index of the sample that includes the data for @media_time
- *
- * Returns the index of the sample or n_samples when the sample was not
- * found.
- */
-/* FIXME, binary search would be nice here */
-static guint32
-gst_qtdemux_find_index (GstQTDemux * qtdemux, QtDemuxStream * str,
- guint64 media_time)
-{
- guint32 i;
-
- if (str->n_samples == 0)
- return 0;
-
- for (i = 0; i < str->n_samples; i++) {
- if (str->samples[i].timestamp > media_time) {
- /* first sample after media_time, we need the previous one */
- return (i == 0 ? 0 : i - 1);
- }
- }
- return str->n_samples - 1;
-}
-
-/* find the index of the keyframe needed to decode the sample at @index
- * of stream @str.
- *
- * Returns the index of the keyframe.
- */
-static guint32
-gst_qtdemux_find_keyframe (GstQTDemux * qtdemux, QtDemuxStream * str,
- guint32 index)
-{
- if (index >= str->n_samples)
- return str->n_samples;
-
- /* all keyframes, return index */
- if (str->all_keyframe)
- return index;
-
- /* else go back until we have a keyframe */
- while (TRUE) {
- if (str->samples[index].keyframe)
- break;
-
- if (index == 0)
- break;
-
- index--;
- }
- return index;
-}
-
-/* find the segment for @time_position for @stream
- *
- * Returns -1 if the segment cannot be found.
- */
-static guint32
-gst_qtdemux_find_segment (GstQTDemux * qtdemux, QtDemuxStream * stream,
- guint64 time_position)
-{
- gint i;
- guint32 seg_idx;
-
- /* find segment corresponding to time_position if we are looking
- * for a segment. */
- seg_idx = -1;
- for (i = 0; i < stream->n_segments; i++) {
- QtDemuxSegment *segment = &stream->segments[i];
-
- if (segment->time <= time_position && time_position < segment->stop_time) {
- seg_idx = i;
- break;
- }
- }
- return seg_idx;
-}
-
-/* move the stream @str to the sample position @index.
- *
- * Updates @str->sample_index and marks discontinuity if needed.
- */
-static void
-gst_qtdemux_move_stream (GstQTDemux * qtdemux, QtDemuxStream * str,
- guint32 index)
-{
- /* no change needed */
- if (index == str->sample_index)
- return;
-
- GST_DEBUG_OBJECT (qtdemux, "moving to sample %u of %u", index,
- str->n_samples);
-
- /* position changed, we have a discont */
- str->sample_index = index;
- str->discont = TRUE;
-}
-
-/* perform the seek.
- *
- * We set all segment_indexes in the streams to unknown and
- * adjust the time_position to the desired position. this is enough
- * to trigger a segment switch in the streaming thread to start
- * streaming from the desired position.
- *
- * Keyframe seeking is a little more complicated when dealing with
- * segments. Ideally we want to move to the previous keyframe in
- * the segment but there might not be a keyframe in the segment. In
- * fact, none of the segments could contain a keyframe. We take a
- * practical approach: seek to the previous keyframe in the segment,
- * if there is none, seek to the beginning of the segment.
- *
- * Called with STREAM_LOCK
- */
-static gboolean
-gst_qtdemux_perform_seek (GstQTDemux * qtdemux, GstSegment * segment)
-{
- gint64 desired_offset;
- gint n;
-
- desired_offset = segment->last_stop;
-
- GST_DEBUG_OBJECT (qtdemux, "seeking to %" GST_TIME_FORMAT,
- GST_TIME_ARGS (desired_offset));
-
- if (segment->flags & GST_SEEK_FLAG_KEY_UNIT) {
- guint64 min_offset;
-
- min_offset = desired_offset;
-
- /* for each stream, find the index of the sample in the segment
- * and move back to the previous keyframe. */
- for (n = 0; n < qtdemux->n_streams; n++) {
- QtDemuxStream *str;
- guint32 index, kindex;
- guint32 seg_idx;
- guint64 media_start;
- guint64 media_time;
- guint64 seg_time;
- QtDemuxSegment *seg;
-
- str = qtdemux->streams[n];
-
- seg_idx = gst_qtdemux_find_segment (qtdemux, str, desired_offset);
- GST_DEBUG_OBJECT (qtdemux, "align segment %d", seg_idx);
-
- /* segment not found, continue with normal flow */
- if (seg_idx == -1)
- continue;
-
- /* get segment and time in the segment */
- seg = &str->segments[seg_idx];
- seg_time = desired_offset - seg->time;
-
- /* get the media time in the segment */
- media_start = seg->media_start + seg_time;
-
- /* get the index of the sample with media time */
- index = gst_qtdemux_find_index (qtdemux, str, media_start);
- GST_DEBUG_OBJECT (qtdemux, "sample for %" GST_TIME_FORMAT " at %u",
- GST_TIME_ARGS (media_start), index);
-
- /* find previous keyframe */
- kindex = gst_qtdemux_find_keyframe (qtdemux, str, index);
-
- GST_DEBUG_OBJECT (qtdemux, "keyframe at %u", kindex);
-
- /* if the keyframe is at a different position, we need to update the
- * requiested seek time */
- if (index != kindex) {
- index = kindex;
-
- /* get timestamp of keyframe */
- media_time = str->samples[kindex].timestamp;
- GST_DEBUG_OBJECT (qtdemux, "keyframe at %u with time %" GST_TIME_FORMAT,
- kindex, GST_TIME_ARGS (media_time));
-
- /* keyframes in the segment get a chance to change the
- * desired_offset. keyframes out of the segment are
- * ignored. */
- if (media_time >= seg->media_start) {
- guint64 seg_time;
-
- /* this keyframe is inside the segment, convert back to
- * segment time */
- seg_time = (media_time - seg->media_start) + seg->time;
- if (seg_time < min_offset)
- min_offset = seg_time;
- }
- }
- }
- GST_DEBUG_OBJECT (qtdemux, "keyframe seek, align to %"
- GST_TIME_FORMAT, GST_TIME_ARGS (desired_offset));
- desired_offset = min_offset;
- }
-
- /* and set all streams to the final position */
- for (n = 0; n < qtdemux->n_streams; n++) {
- QtDemuxStream *stream = qtdemux->streams[n];
-
- stream->time_position = desired_offset;
- stream->sample_index = 0;
- stream->segment_index = -1;
- stream->last_ret = GST_FLOW_OK;
- }
- segment->last_stop = desired_offset;
- segment->time = desired_offset;
-
- /* we stop at the end */
- if (segment->stop == -1)
- segment->stop = segment->duration;
-
- return TRUE;
-}
-
-/* do a seek in pull based mode */
-static gboolean
-gst_qtdemux_do_seek (GstQTDemux * qtdemux, GstPad * pad, GstEvent * event)
-{
- gdouble rate;
- GstFormat format;
- GstSeekFlags flags;
- GstSeekType cur_type, stop_type;
- gint64 cur, stop;
- gboolean flush;
- gboolean res;
- gboolean update;
- GstSegment seeksegment;
- int i;
-
- if (event) {
- GST_DEBUG_OBJECT (qtdemux, "doing seek with event");
-
- gst_event_parse_seek (event, &rate, &format, &flags,
- &cur_type, &cur, &stop_type, &stop);
-
- /* we have to have a format as the segment format. Try to convert
- * if not. */
- if (format != GST_FORMAT_TIME) {
- GstFormat fmt;
-
- fmt = GST_FORMAT_TIME;
- res = TRUE;
- if (cur_type != GST_SEEK_TYPE_NONE)
- res = gst_pad_query_convert (pad, format, cur, &fmt, &cur);
- if (res && stop_type != GST_SEEK_TYPE_NONE)
- res = gst_pad_query_convert (pad, format, stop, &fmt, &stop);
- if (!res)
- goto no_format;
-
- format = fmt;
- }
- } else {
- GST_DEBUG_OBJECT (qtdemux, "doing seek without event");
- flags = 0;
- }
-
- flush = flags & GST_SEEK_FLAG_FLUSH;
-
- GST_DEBUG_OBJECT (qtdemux, "seek format %d", format);
-
- /* stop streaming, either by flushing or by pausing the task */
- if (flush) {
- /* unlock upstream pull_range */
- gst_pad_push_event (qtdemux->sinkpad, gst_event_new_flush_start ());
- /* make sure out loop function exits */
- gst_qtdemux_push_event (qtdemux, gst_event_new_flush_start ());
- } else {
- /* non flushing seek, pause the task */
- gst_pad_pause_task (qtdemux->sinkpad);
- }
-
- /* wait for streaming to finish */
- GST_PAD_STREAM_LOCK (qtdemux->sinkpad);
-
- /* copy segment, we need this because we still need the old
- * segment when we close the current segment. */
- memcpy (&seeksegment, &qtdemux->segment, sizeof (GstSegment));
-
- if (event) {
- /* configure the segment with the seek variables */
- GST_DEBUG_OBJECT (qtdemux, "configuring seek");
- gst_segment_set_seek (&seeksegment, rate, format, flags,
- cur_type, cur, stop_type, stop, &update);
- }
-
- /* now do the seek, this actually never returns FALSE */
- res = gst_qtdemux_perform_seek (qtdemux, &seeksegment);
-
- /* prepare for streaming again */
- if (flush) {
- gst_pad_push_event (qtdemux->sinkpad, gst_event_new_flush_stop ());
- gst_qtdemux_push_event (qtdemux, gst_event_new_flush_stop ());
- } else if (qtdemux->segment_running) {
- /* we are running the current segment and doing a non-flushing seek,
- * close the segment first based on the last_stop. */
- GST_DEBUG_OBJECT (qtdemux, "closing running segment %" G_GINT64_FORMAT
- " to %" G_GINT64_FORMAT, qtdemux->segment.start,
- qtdemux->segment.last_stop);
-
- /* FIXME, needs to be done from the streaming thread. Also, the rate is the
- * product of the global rate and the (quicktime) segment rate. */
- gst_qtdemux_push_event (qtdemux,
- gst_event_new_new_segment (TRUE,
- qtdemux->segment.rate, qtdemux->segment.format,
- qtdemux->segment.start, qtdemux->segment.last_stop,
- qtdemux->segment.time));
- }
-
- /* commit the new segment */
- memcpy (&qtdemux->segment, &seeksegment, sizeof (GstSegment));
-
- if (qtdemux->segment.flags & GST_SEEK_FLAG_SEGMENT) {
- gst_element_post_message (GST_ELEMENT_CAST (qtdemux),
- gst_message_new_segment_start (GST_OBJECT_CAST (qtdemux),
- qtdemux->segment.format, qtdemux->segment.last_stop));
- }
-
- /* restart streaming, NEWSEGMENT will be sent from the streaming
- * thread. */
- qtdemux->segment_running = TRUE;
- for (i = 0; i < qtdemux->n_streams; i++)
- qtdemux->streams[i]->last_ret = GST_FLOW_OK;
-
- gst_pad_start_task (qtdemux->sinkpad, (GstTaskFunction) gst_qtdemux_loop,
- qtdemux->sinkpad);
-
- GST_PAD_STREAM_UNLOCK (qtdemux->sinkpad);
-
- return TRUE;
-
- /* ERRORS */
-no_format:
- {
- GST_DEBUG_OBJECT (qtdemux, "unsupported format given, seek aborted.");
- return FALSE;
- }
-}
-
-static gboolean
-gst_qtdemux_handle_src_event (GstPad * pad, GstEvent * event)
-{
- gboolean res = TRUE;
- GstQTDemux *qtdemux = GST_QTDEMUX (gst_pad_get_parent (pad));
-
- switch (GST_EVENT_TYPE (event)) {
- case GST_EVENT_SEEK:
- if (qtdemux->pullbased) {
- res = gst_qtdemux_do_seek (qtdemux, pad, event);
- } else {
- GST_DEBUG_OBJECT (qtdemux, "cannot seek in streaming mode");
- res = FALSE;
- }
- break;
- default:
- res = FALSE;
- break;
- }
-
- gst_object_unref (qtdemux);
-
- gst_event_unref (event);
-
- return res;
-}
-
-static gboolean
-gst_qtdemux_handle_sink_event (GstPad * sinkpad, GstEvent * event)
-{
- GstQTDemux *demux = GST_QTDEMUX (GST_PAD_PARENT (sinkpad));
- 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:
- res = gst_pad_event_default (demux->sinkpad, event);
- break;
- }
-
- return res;
-}
-
-static GstStateChangeReturn
-gst_qtdemux_change_state (GstElement * element, GstStateChange transition)
-{
- GstQTDemux *qtdemux = GST_QTDEMUX (element);
- GstStateChangeReturn result = GST_STATE_CHANGE_FAILURE;
-
- switch (transition) {
- case GST_STATE_CHANGE_PAUSED_TO_READY:
- break;
- default:
- break;
- }
-
- result = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
-
- switch (transition) {
- case GST_STATE_CHANGE_PAUSED_TO_READY:{
- gint n;
-
- qtdemux->state = QTDEMUX_STATE_INITIAL;
- qtdemux->last_ts = GST_CLOCK_TIME_NONE;
- qtdemux->neededbytes = 16;
- qtdemux->todrop = 0;
- qtdemux->pullbased = FALSE;
- qtdemux->offset = 0;
- qtdemux->mdatoffset = GST_CLOCK_TIME_NONE;
- if (qtdemux->mdatbuffer)
- gst_buffer_unref (qtdemux->mdatbuffer);
- qtdemux->mdatbuffer = NULL;
- gst_adapter_clear (qtdemux->adapter);
- for (n = 0; n < qtdemux->n_streams; n++) {
- QtDemuxStream *stream = qtdemux->streams[n];
-
- if (stream->pad)
- gst_element_remove_pad (element, stream->pad);
- g_free (stream->samples);
- if (stream->caps)
- gst_caps_unref (stream->caps);
- g_free (stream->segments);
- g_free (stream);
- }
- qtdemux->n_streams = 0;
- qtdemux->n_video_streams = 0;
- qtdemux->n_audio_streams = 0;
- gst_segment_init (&qtdemux->segment, GST_FORMAT_TIME);
- break;
- }
- default:
- break;
- }
-
- return result;
-}
-
-static void
-extract_initial_length_and_fourcc (guint8 * data, guint64 * plength,
- guint32 * pfourcc)
-{
- guint64 length;
- guint32 fourcc;
-
- length = QT_UINT32 (data);
- GST_DEBUG ("length %08" G_GINT64_MODIFIER "x", length);
- fourcc = QT_FOURCC (data + 4);
- GST_DEBUG ("atom type %" GST_FOURCC_FORMAT, GST_FOURCC_ARGS (fourcc));
-
- if (length == 0) {
- length = G_MAXUINT32;
- } else if (length == 1) {
- /* this means we have an extended size, which is the 64 bit value of
- * the next 8 bytes */
- length = QT_UINT64 (data + 8);
- GST_DEBUG ("length %08llx", length);
- }
-
- if (plength)
- *plength = length;
- if (pfourcc)
- *pfourcc = fourcc;
-}
-
-static GstFlowReturn
-gst_qtdemux_loop_state_header (GstQTDemux * qtdemux)
-{
- guint64 length;
- guint32 fourcc;
- GstBuffer *buf = NULL;
- GstFlowReturn ret = GST_FLOW_OK;
- guint64 cur_offset = qtdemux->offset;
-
- ret = gst_pad_pull_range (qtdemux->sinkpad, cur_offset, 16, &buf);
- if (ret != GST_FLOW_OK)
- goto beach;
- extract_initial_length_and_fourcc (GST_BUFFER_DATA (buf), &length, &fourcc);
- gst_buffer_unref (buf);
-
- switch (fourcc) {
- case FOURCC_mdat:
- case FOURCC_free:
- case FOURCC_wide:
- case FOURCC_PICT:
- case FOURCC_pnot:
- {
- GST_LOG_OBJECT (qtdemux,
- "skipping atom '%" GST_FOURCC_FORMAT "' at %" G_GUINT64_FORMAT,
- GST_FOURCC_ARGS (fourcc), cur_offset);
- cur_offset += length;
- qtdemux->offset += length;
- break;
- }
- case FOURCC_moov:
- {
- GstBuffer *moov;
-
- ret = gst_pad_pull_range (qtdemux->sinkpad, cur_offset, length, &moov);
- if (ret != GST_FLOW_OK)
- goto beach;
- if (length != GST_BUFFER_SIZE (moov)) {
- GST_ELEMENT_ERROR (qtdemux, STREAM, DECODE,
- (_("This file is incomplete and cannot be played.")),
- ("We got less than expected (received %u, wanted %u)",
- GST_BUFFER_SIZE (moov), (guint) length));
- ret = GST_FLOW_ERROR;
- goto beach;
- }
- cur_offset += length;
- qtdemux->offset += length;
-
- qtdemux_parse_moov (qtdemux, GST_BUFFER_DATA (moov), length);
- qtdemux_node_dump (qtdemux, qtdemux->moov_node);
-
- qtdemux_parse_tree (qtdemux);
- g_node_destroy (qtdemux->moov_node);
- gst_buffer_unref (moov);
- qtdemux->moov_node = NULL;
- qtdemux->state = QTDEMUX_STATE_MOVIE;
- GST_DEBUG_OBJECT (qtdemux, "switching state to STATE_MOVIE (%d)",
- qtdemux->state);
- break;
- }
- default:
- {
- GST_LOG_OBJECT (qtdemux,
- "unknown %08x '%" GST_FOURCC_FORMAT "' at %" G_GUINT64_FORMAT, fourcc,
- GST_FOURCC_ARGS (fourcc), cur_offset);
- cur_offset += length;
- qtdemux->offset += length;
- break;
- }
- }
-
-beach:
- return ret;
-}
-
-/* activate the given segment number @seg_idx of @stream at time @offset.
- * @offset is an absolute global position over all the segments.
- *
- * This will push out a NEWSEGMENT event with the right values and
- * position the stream index to the first decodable sample before
- * @offset.
- */
-static gboolean
-gst_qtdemux_activate_segment (GstQTDemux * qtdemux, QtDemuxStream * stream,
- guint32 seg_idx, guint64 offset)
-{
- GstEvent *event;
- QtDemuxSegment *segment;
- guint32 index, kf_index;
- guint64 seg_time;
- guint64 start, stop;
- gdouble rate;
-
- /* update the current segment */
- stream->segment_index = seg_idx;
-
- /* get the segment */
- segment = &stream->segments[seg_idx];
-
- if (offset < segment->time)
- return FALSE;
-
- /* get time in this segment */
- seg_time = offset - segment->time;
-
- if (seg_time >= segment->duration)
- return FALSE;
-
- /* calc media start/stop */
- if (qtdemux->segment.stop == -1)
- stop = segment->media_stop;
- else
- stop = MIN (segment->media_stop, qtdemux->segment.stop);
- start = MIN (segment->media_start + seg_time, stop);
-
- GST_DEBUG_OBJECT (qtdemux, "newsegment %d from %" GST_TIME_FORMAT
- " to %" GST_TIME_FORMAT ", time %" GST_TIME_FORMAT, seg_idx,
- GST_TIME_ARGS (start), GST_TIME_ARGS (stop), GST_TIME_ARGS (offset));
-
- /* combine global rate with that of the segment */
- rate = segment->rate * qtdemux->segment.rate;
- event = gst_event_new_new_segment (FALSE, rate, GST_FORMAT_TIME,
- start, stop, offset);
-
- if (stream->pad)
- gst_pad_push_event (stream->pad, event);
-
- /* and move to the keyframe before the indicated media time of the
- * segment */
- index = gst_qtdemux_find_index (qtdemux, stream, start);
-
- GST_DEBUG_OBJECT (qtdemux, "moving data pointer to %" GST_TIME_FORMAT
- ", index: %u", GST_TIME_ARGS (start), index);
-
- /* we're at the right spot */
- if (index == stream->sample_index)
- return TRUE;
-
- /* find keyframe of the target index */
- kf_index = gst_qtdemux_find_keyframe (qtdemux, stream, index);
-
- /* if we move forwards, we don't have to go back to the previous
- * keyframe since we already sent that. We can also just jump to
- * the keyframe right before the target index if there is one. */
- if (index > stream->sample_index) {
- /* moving forwards check if we move past a keyframe */
- if (kf_index > stream->sample_index) {
- GST_DEBUG_OBJECT (qtdemux, "moving forwards to keyframe at %u", kf_index);
- gst_qtdemux_move_stream (qtdemux, stream, kf_index);
- } else {
- GST_DEBUG_OBJECT (qtdemux, "moving forwards, keyframe at %u already sent",
- kf_index);
- }
- } else {
- GST_DEBUG_OBJECT (qtdemux, "moving backwards to keyframe at %u", kf_index);
- gst_qtdemux_move_stream (qtdemux, stream, kf_index);
- }
-
- return TRUE;
-}
-
-/* prepare to get the current sample of @stream, getting essential values.
- *
- * This function will also prepare and send the segment when needed.
- *
- * Return FALSE if the stream is EOS.
- */
-static gboolean
-gst_qtdemux_prepare_current_sample (GstQTDemux * qtdemux,
- QtDemuxStream * stream, guint64 * offset, guint * size, guint64 * timestamp,
- guint64 * duration, gboolean * keyframe)
-{
- QtDemuxSample *sample;
- guint64 time_position;
- guint32 seg_idx;
-
- g_return_val_if_fail (stream != NULL, FALSE);
-
- time_position = stream->time_position;
- if (time_position == -1)
- goto eos;
-
- seg_idx = stream->segment_index;
- if (seg_idx == -1) {
- /* find segment corresponding to time_position if we are looking
- * for a segment. */
- seg_idx = gst_qtdemux_find_segment (qtdemux, stream, time_position);
-
- /* nothing found, we're really eos */
- if (seg_idx == -1)
- goto eos;
- }
-
- /* different segment, activate it, sample_index will be set. */
- if (stream->segment_index != seg_idx)
- gst_qtdemux_activate_segment (qtdemux, stream, seg_idx, time_position);
-
- GST_LOG_OBJECT (qtdemux, "segment active, index = %u of %u",
- stream->sample_index, stream->n_samples);
-
- if (stream->sample_index >= stream->n_samples)
- goto eos;
-
- /* now get the info for the sample we're at */
- sample = &stream->samples[stream->sample_index];
-
- *timestamp = sample->timestamp + sample->pts_offset;
- *offset = sample->offset;
- *size = sample->size;
- *duration = sample->duration;
- *keyframe = stream->all_keyframe || sample->keyframe;
-
- return TRUE;
-
- /* special cases */
-eos:
- {
- stream->time_position = -1;
- return FALSE;
- }
-}
-
-/* move to the next sample in @stream.
- *
- * Moves to the next segment when needed.
- */
-static void
-gst_qtdemux_advance_sample (GstQTDemux * qtdemux, QtDemuxStream * stream)
-{
- QtDemuxSample *sample;
- QtDemuxSegment *segment;
-
- /* move to next sample */
- stream->sample_index++;
-
- /* get current segment */
- segment = &stream->segments[stream->segment_index];
-
- /* reached the last sample, we need the next segment */
- if (stream->sample_index >= stream->n_samples)
- goto next_segment;
-
- /* get next sample */
- sample = &stream->samples[stream->sample_index];
-
- /* see if we are past the segment */
- if (sample->timestamp >= segment->media_stop)
- goto next_segment;
-
- if (sample->timestamp >= segment->media_start) {
- /* inside the segment, update time_position, looks very familiar to
- * GStreamer segments, doesn't it? */
- stream->time_position =
- (sample->timestamp - segment->media_start) + segment->time;
- } else {
- /* not yet in segment, time does not yet increment. This means
- * that we are still prerolling keyframes to the decoder so it can
- * decode the first sample of the segment. */
- stream->time_position = segment->time;
- }
- return;
-
- /* move to the next segment */
-next_segment:
- {
- GST_DEBUG_OBJECT (qtdemux, "segment %d ended ", stream->segment_index);
-
- if (stream->segment_index == stream->n_segments - 1) {
- /* are we at the end of the last segment, we're EOS */
- stream->time_position = -1;
- } else {
- /* else we're only at the end of the current segment */
- stream->time_position = segment->stop_time;
- }
- /* make sure we select a new segment */
- stream->segment_index = -1;
- }
-}
-
-static GstFlowReturn
-gst_qtdemux_combine_flows (GstQTDemux * demux, QtDemuxStream * stream,
- GstFlowReturn ret)
-{
- gint i;
-
- /* store the value */
- stream->last_ret = ret;
-
- /* any other error that is not-linked can be returned right
- * away */
- if (ret != GST_FLOW_NOT_LINKED)
- goto done;
-
- /* only return NOT_LINKED if all other pads returned NOT_LINKED */
- for (i = 0; i < demux->n_streams; i++) {
- QtDemuxStream *ostream = demux->streams[i];
-
- ret = ostream->last_ret;
- /* some other return value (must be SUCCESS but we can return
- * other values as well) */
- if (ret != GST_FLOW_NOT_LINKED)
- goto done;
- }
- /* if we get here, all other pads were unlinked and we return
- * NOT_LINKED then */
-done:
- GST_LOG_OBJECT (demux, "combined flow return: %s", gst_flow_get_name (ret));
- return ret;
-}
-
-static GstFlowReturn
-gst_qtdemux_loop_state_movie (GstQTDemux * qtdemux)
-{
- GstFlowReturn ret = GST_FLOW_OK;
- GstBuffer *buf = NULL;
- QtDemuxStream *stream;
- guint64 min_time;
- guint64 offset;
- guint64 timestamp;
- guint64 duration;
- gboolean keyframe;
- guint size;
- gint index;
- gint i;
-
- /* Figure out the next stream sample to output, min_time is expressed in
- * global time and runs over the edit list segments. */
- min_time = G_MAXUINT64;
- index = -1;
- for (i = 0; i < qtdemux->n_streams; i++) {
- guint64 position;
-
- stream = qtdemux->streams[i];
- position = stream->time_position;
-
- /* position of -1 is EOS */
- if (position != -1 && position < min_time) {
- min_time = position;
- index = i;
- }
- }
- /* all are EOS */
- if (index == -1)
- goto eos;
-
- /* check for segment end */
- if (qtdemux->segment.stop != -1 && qtdemux->segment.stop < min_time)
- goto eos;
-
- stream = qtdemux->streams[index];
-
- /* fetch info for the current sample of this stream */
- if (!gst_qtdemux_prepare_current_sample (qtdemux, stream, &offset, &size,
- ×tamp, &duration, &keyframe))
- goto eos;
-
- GST_LOG_OBJECT (qtdemux,
- "pushing from stream %d, offset=%" G_GUINT64_FORMAT
- ",size=%d timestamp=%" GST_TIME_FORMAT,
- index, offset, size, GST_TIME_ARGS (timestamp));
-
- /* hmm, empty sample, skip and move to next sample */
- if (G_UNLIKELY (size <= 0))
- goto next;
-
- GST_LOG_OBJECT (qtdemux, "reading %d bytes @ %" G_GUINT64_FORMAT, size,
- offset);
-
- ret = gst_pad_pull_range (qtdemux->sinkpad, offset, size, &buf);
- if (ret != GST_FLOW_OK)
- goto beach;
-
- if (stream->fourcc == FOURCC_rtsp) {
- GstMessage *m;
- gchar *url;
-
- url = g_strndup ((gchar *) GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
-
- /* we have RTSP redirect now */
- m = gst_message_new_element (GST_OBJECT_CAST (qtdemux),
- gst_structure_new ("redirect",
- "new-location", G_TYPE_STRING, url, NULL));
- g_free (url);
-
- gst_element_post_message (GST_ELEMENT_CAST (qtdemux), m);
- }
-
- qtdemux->last_ts = min_time;
- gst_segment_set_last_stop (&qtdemux->segment, GST_FORMAT_TIME, min_time);
-
- if (stream->pad) {
- /* we're going to modify the metadata */
- buf = gst_buffer_make_metadata_writable (buf);
-
- if (stream->discont) {
- GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
- stream->discont = FALSE;
- }
-
- GST_BUFFER_TIMESTAMP (buf) = timestamp;
- GST_BUFFER_DURATION (buf) = duration;
-
- if (!keyframe)
- GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
-
- gst_buffer_set_caps (buf, stream->caps);
-
- GST_LOG_OBJECT (qtdemux,
- "Pushing buffer with time %" GST_TIME_FORMAT ", duration %"
- GST_TIME_FORMAT " on pad %s",
- GST_TIME_ARGS (timestamp), GST_TIME_ARGS (duration),
- GST_PAD_NAME (stream->pad));
- ret = gst_pad_push (stream->pad, buf);
- } else {
- ret = GST_FLOW_OK;
- }
-
- /* combine flows */
- ret = gst_qtdemux_combine_flows (qtdemux, stream, ret);
-
-next:
- gst_qtdemux_advance_sample (qtdemux, stream);
-
-beach:
- return ret;
-
- /* special cases */
-eos:
- {
- GST_DEBUG_OBJECT (qtdemux, "No samples left for any streams - EOS");
- ret = GST_FLOW_UNEXPECTED;
- goto beach;
- }
-}
-
-static void
-gst_qtdemux_loop (GstPad * pad)
-{
- GstQTDemux *qtdemux;
- guint64 cur_offset;
- GstFlowReturn ret;
-
- qtdemux = GST_QTDEMUX (gst_pad_get_parent (pad));
-
- cur_offset = qtdemux->offset;
- GST_LOG_OBJECT (qtdemux, "loop at position %" G_GUINT64_FORMAT ", state %d",
- cur_offset, qtdemux->state);
-
- switch (qtdemux->state) {
- case QTDEMUX_STATE_INITIAL:
- case QTDEMUX_STATE_HEADER:
- ret = gst_qtdemux_loop_state_header (qtdemux);
- break;
- case QTDEMUX_STATE_MOVIE:
- ret = gst_qtdemux_loop_state_movie (qtdemux);
- break;
- default:
- /* ouch */
- goto invalid_state;
- }
-
- /* if something went wrong, pause */
- if (ret != GST_FLOW_OK)
- goto pause;
-
-done:
- gst_object_unref (qtdemux);
- return;
-
- /* ERRORS */
-invalid_state:
- {
- GST_ELEMENT_ERROR (qtdemux, STREAM, FAILED,
- (NULL), ("streaming stopped, invalid state"));
- qtdemux->segment_running = FALSE;
- gst_pad_pause_task (pad);
- gst_qtdemux_push_event (qtdemux, gst_event_new_eos ());
- goto done;
- }
-pause:
- {
- const gchar *reason = gst_flow_get_name (ret);
-
- GST_LOG_OBJECT (qtdemux, "pausing task, reason %s", reason);
-
- qtdemux->segment_running = FALSE;
- gst_pad_pause_task (pad);
-
- /* fatal errors need special actions */
- if (GST_FLOW_IS_FATAL (ret) || ret == GST_FLOW_NOT_LINKED) {
- /* check EOS */
- if (ret == GST_FLOW_UNEXPECTED) {
- if (qtdemux->n_streams == 0) {
- /* we have no streams, post an error */
- GST_ELEMENT_ERROR (qtdemux, STREAM, DECODE,
- (_("This file contains no playable streams.")),
- ("no known streams found"));
- }
- if (qtdemux->segment.flags & GST_SEEK_FLAG_SEGMENT) {
- gint64 stop;
-
- if ((stop = qtdemux->segment.stop) == -1)
- stop = qtdemux->segment.duration;
-
- GST_LOG_OBJECT (qtdemux, "Sending segment done, at end of segment");
- gst_element_post_message (GST_ELEMENT_CAST (qtdemux),
- gst_message_new_segment_done (GST_OBJECT_CAST (qtdemux),
- GST_FORMAT_TIME, stop));
- } else {
- GST_LOG_OBJECT (qtdemux, "Sending EOS at end of segment");
- gst_qtdemux_push_event (qtdemux, gst_event_new_eos ());
- }
- } else {
- GST_ELEMENT_ERROR (qtdemux, STREAM, FAILED,
- (NULL), ("streaming stopped, reason %s", reason));
- gst_qtdemux_push_event (qtdemux, gst_event_new_eos ());
- }
- }
- goto done;
- }
-}
-
-/*
- * next_entry_size
- *
- * Returns the size of the first entry at the current offset.
- * If -1, there are none (which means EOS or empty file).
- */
-static guint64
-next_entry_size (GstQTDemux * demux)
-{
- QtDemuxStream *stream;
- int i;
- int smallidx = -1;
- guint64 smalloffs = (guint64) - 1;
-
- GST_LOG_OBJECT (demux, "Finding entry at offset %lld", demux->offset);
-
- for (i = 0; i < demux->n_streams; i++) {
- stream = demux->streams[i];
-
- GST_LOG_OBJECT (demux,
- "Checking Stream %d (sample_index:%d / offset:%lld / size:%d / chunk:%d)",
- i, stream->sample_index, stream->samples[stream->sample_index].offset,
- stream->samples[stream->sample_index].size,
- stream->samples[stream->sample_index].chunk);
-
- if (((smalloffs == -1)
- || (stream->samples[stream->sample_index].offset < smalloffs))
- && (stream->samples[stream->sample_index].size)) {
- smallidx = i;
- smalloffs = stream->samples[stream->sample_index].offset;
- }
- }
-
- GST_LOG_OBJECT (demux, "stream %d offset %lld demux->offset :%lld",
- smallidx, smalloffs, demux->offset);
-
- if (smallidx == -1)
- return -1;
- stream = demux->streams[smallidx];
-
- if (stream->samples[stream->sample_index].offset >= demux->offset) {
- demux->todrop =
- stream->samples[stream->sample_index].offset - demux->offset;
- return stream->samples[stream->sample_index].size + demux->todrop;
- }
-
- GST_DEBUG_OBJECT (demux, "There wasn't any entry at offset %lld",
- demux->offset);
- return -1;
-}
-
-static void
-gst_qtdemux_post_progress (GstQTDemux * demux, gint num, gint denom)
-{
- gint perc = (gint) ((gdouble) num * 100.0 / (gdouble) denom);
-
- gst_element_post_message (GST_ELEMENT_CAST (demux),
- gst_message_new_element (GST_OBJECT_CAST (demux),
- gst_structure_new ("progress", "percent", G_TYPE_INT, perc, NULL)));
-}
-
-/* FIXME, unverified after edit list updates */
-static GstFlowReturn
-gst_qtdemux_chain (GstPad * sinkpad, GstBuffer * inbuf)
-{
- GstQTDemux *demux;
- GstFlowReturn ret = GST_FLOW_OK;
-
- demux = GST_QTDEMUX (gst_pad_get_parent (sinkpad));
-
- gst_adapter_push (demux->adapter, inbuf);
-
- GST_DEBUG_OBJECT (demux, "pushing in inbuf %p, neededbytes:%u, available:%u",
- inbuf, demux->neededbytes, gst_adapter_available (demux->adapter));
-
- while (((gst_adapter_available (demux->adapter)) >= demux->neededbytes) &&
- (ret == GST_FLOW_OK)) {
-
- GST_DEBUG_OBJECT (demux,
- "state:%d , demux->neededbytes:%d, demux->offset:%lld", demux->state,
- demux->neededbytes, demux->offset);
-
- switch (demux->state) {
- case QTDEMUX_STATE_INITIAL:{
- const guint8 *data;
- guint32 fourcc;
- guint64 size;
-
- data = gst_adapter_peek (demux->adapter, demux->neededbytes);
-
- /* get fourcc/length, set neededbytes */
- extract_initial_length_and_fourcc ((guint8 *) data, &size, &fourcc);
- GST_DEBUG_OBJECT (demux,
- "Peeking found [%" GST_FOURCC_FORMAT "] size: %u",
- GST_FOURCC_ARGS (fourcc), (guint) size);
- if (fourcc == FOURCC_mdat) {
- if (demux->n_streams > 0) {
- demux->state = QTDEMUX_STATE_MOVIE;
- demux->neededbytes = next_entry_size (demux);
- } else {
- demux->state = QTDEMUX_STATE_BUFFER_MDAT;
- demux->neededbytes = size;
- demux->mdatoffset = demux->offset;
- }
- } else {
- demux->neededbytes = size;
- demux->state = QTDEMUX_STATE_HEADER;
- }
- break;
- }
- case QTDEMUX_STATE_HEADER:{
- guint8 *data;
- guint32 fourcc;
-
- GST_DEBUG_OBJECT (demux, "In header");
-
- data = gst_adapter_take (demux->adapter, demux->neededbytes);
-
- /* parse the header */
- extract_initial_length_and_fourcc (data, NULL, &fourcc);
- if (fourcc == FOURCC_moov) {
- GST_DEBUG_OBJECT (demux, "Parsing [moov]");
-
- qtdemux_parse_moov (demux, data, demux->neededbytes);
- qtdemux_node_dump (demux, demux->moov_node);
- qtdemux_parse_tree (demux);
-
- g_node_destroy (demux->moov_node);
- g_free (data);
- demux->moov_node = NULL;
- } else {
- GST_WARNING_OBJECT (demux,
- "Unknown fourcc while parsing header : %" GST_FOURCC_FORMAT,
- GST_FOURCC_ARGS (fourcc));
- /* Let's jump that one and go back to initial state */
- }
-
- GST_DEBUG_OBJECT (demux, "Finished parsing the header");
- if (demux->mdatbuffer && demux->n_streams) {
- /* the mdat was before the header */
- GST_DEBUG_OBJECT (demux, "We have n_streams:%d and mdatbuffer:%p",
- demux->n_streams, demux->mdatbuffer);
- gst_adapter_clear (demux->adapter);
- GST_DEBUG_OBJECT (demux, "mdatbuffer starts with %" GST_FOURCC_FORMAT,
- GST_FOURCC_ARGS (QT_UINT32 (demux->mdatbuffer)));
- gst_adapter_push (demux->adapter, demux->mdatbuffer);
- demux->mdatbuffer = NULL;
- demux->offset = demux->mdatoffset;
- demux->neededbytes = next_entry_size (demux);
- demux->state = QTDEMUX_STATE_MOVIE;
- } else {
- GST_DEBUG_OBJECT (demux, "Carrying on normally");
- demux->offset += demux->neededbytes;
- demux->neededbytes = 16;
- demux->state = QTDEMUX_STATE_INITIAL;
- }
-
- break;
- }
- case QTDEMUX_STATE_BUFFER_MDAT:{
- GST_DEBUG_OBJECT (demux, "Got our buffer at offset %lld",
- demux->mdatoffset);
- if (demux->mdatbuffer)
- gst_buffer_unref (demux->mdatbuffer);
- demux->mdatbuffer = gst_buffer_new ();
- gst_buffer_set_data (demux->mdatbuffer,
- gst_adapter_take (demux->adapter, demux->neededbytes),
- demux->neededbytes);
- GST_DEBUG_OBJECT (demux, "mdatbuffer starts with %" GST_FOURCC_FORMAT,
- GST_FOURCC_ARGS (QT_UINT32 (demux->mdatbuffer)));
- demux->offset += demux->neededbytes;
- demux->neededbytes = 16;
- demux->state = QTDEMUX_STATE_INITIAL;
- gst_qtdemux_post_progress (demux, 1, 1);
-
- break;
- }
- case QTDEMUX_STATE_MOVIE:{
- guint8 *data;
- GstBuffer *outbuf;
- QtDemuxStream *stream = NULL;
- int i = -1;
-
- GST_DEBUG_OBJECT (demux, "BEGIN // in MOVIE for offset %lld",
- demux->offset);
-
- if (demux->todrop) {
- gst_adapter_flush (demux->adapter, demux->todrop);
- demux->neededbytes -= demux->todrop;
- demux->offset += demux->todrop;
- }
-
- /* Figure out which stream this is packet belongs to */
- for (i = 0; i < demux->n_streams; i++) {
- stream = demux->streams[i];
- GST_LOG_OBJECT (demux,
- "Checking stream %d (sample_index:%d / offset:%lld / size:%d / chunk:%d)",
- i, stream->sample_index,
- stream->samples[stream->sample_index].offset,
- stream->samples[stream->sample_index].size,
- stream->samples[stream->sample_index].chunk);
-
- if (stream->samples[stream->sample_index].offset == demux->offset)
- break;
- }
-
- if (stream == NULL)
- goto unknown_stream;
-
- /* first buffer? */
- /* FIXME : this should be handled in sink_event */
- if (demux->last_ts == GST_CLOCK_TIME_NONE) {
- gst_qtdemux_push_event (demux,
- gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_TIME,
- 0, GST_CLOCK_TIME_NONE, 0));
- }
-
- /* get data */
- data = gst_adapter_take (demux->adapter, demux->neededbytes);
-
- /* Put data in a buffer, set timestamps, caps, ... */
- outbuf = gst_buffer_new ();
- gst_buffer_set_data (outbuf, data, demux->neededbytes);
- GST_DEBUG_OBJECT (demux, "stream : %" GST_FOURCC_FORMAT,
- GST_FOURCC_ARGS (stream->fourcc));
-
- if (stream->samples[stream->sample_index].pts_offset) {
- demux->last_ts = stream->samples[stream->sample_index].timestamp;
- GST_BUFFER_TIMESTAMP (outbuf) = demux->last_ts +
- stream->samples[stream->sample_index].pts_offset;
- } else {
- GST_BUFFER_TIMESTAMP (outbuf) =
- stream->samples[stream->sample_index].timestamp;
- demux->last_ts = GST_BUFFER_TIMESTAMP (outbuf);
- }
- GST_BUFFER_DURATION (outbuf) =
- stream->samples[stream->sample_index].duration;
-
- /* send buffer */
- if (stream->pad) {
- GST_LOG_OBJECT (demux,
- "Pushing buffer with time %" GST_TIME_FORMAT " on pad %p",
- GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)), stream->pad);
- gst_buffer_set_caps (outbuf, stream->caps);
- ret = gst_pad_push (stream->pad, outbuf);
- } else {
- gst_buffer_unref (outbuf);
- ret = GST_FLOW_OK;
- }
-
- /* combine flows */
- ret = gst_qtdemux_combine_flows (demux, stream, ret);
-
- stream->sample_index++;
-
- /* update current offset and figure out size of next buffer */
- GST_LOG_OBJECT (demux, "increasing offset %" G_GUINT64_FORMAT " by %u",
- demux->offset, demux->neededbytes);
- demux->offset += demux->neededbytes;
- GST_LOG_OBJECT (demux, "offset is now %lld", demux->offset);
-
- if ((demux->neededbytes = next_entry_size (demux)) == -1)
- goto eos;
- break;
- }
- default:
- goto invalid_state;
- }
- }
-
- /* when buffering movie data, at least show user something is happening */
- if (ret == GST_FLOW_OK && demux->state == QTDEMUX_STATE_BUFFER_MDAT &&
- gst_adapter_available (demux->adapter) <= demux->neededbytes) {
- gst_qtdemux_post_progress (demux, gst_adapter_available (demux->adapter),
- demux->neededbytes);
- }
-done:
- gst_object_unref (demux);
-
- return ret;
-
- /* ERRORS */
-unknown_stream:
- {
- GST_ELEMENT_ERROR (demux, STREAM, FAILED, (NULL), ("unknown stream found"));
- ret = GST_FLOW_ERROR;
- goto done;
- }
-eos:
- {
- GST_DEBUG_OBJECT (demux, "no next entry, EOS");
- ret = GST_FLOW_UNEXPECTED;
- goto done;
- }
-invalid_state:
- {
- GST_ELEMENT_ERROR (demux, STREAM, FAILED,
- (NULL), ("qtdemuxer invalid state %d", demux->state));
- ret = GST_FLOW_ERROR;
- goto done;
- }
-}
-
-static gboolean
-qtdemux_sink_activate (GstPad * sinkpad)
-{
- if (gst_pad_check_pull_range (sinkpad))
- return gst_pad_activate_pull (sinkpad, TRUE);
- else
- return gst_pad_activate_push (sinkpad, TRUE);
-}
-
-static gboolean
-qtdemux_sink_activate_pull (GstPad * sinkpad, gboolean active)
-{
- GstQTDemux *demux = GST_QTDEMUX (GST_PAD_PARENT (sinkpad));
-
- if (active) {
- demux->pullbased = TRUE;
- demux->segment_running = TRUE;
- gst_pad_start_task (sinkpad, (GstTaskFunction) gst_qtdemux_loop, sinkpad);
- } else {
- demux->segment_running = FALSE;
- gst_pad_stop_task (sinkpad);
- }
-
- return TRUE;
-}
-
-static gboolean
-qtdemux_sink_activate_push (GstPad * sinkpad, gboolean active)
-{
- GstQTDemux *demux = GST_QTDEMUX (GST_PAD_PARENT (sinkpad));
-
- demux->pullbased = FALSE;
-
- return TRUE;
-}
-
-#ifdef HAVE_ZLIB
-static void *
-qtdemux_zalloc (void *opaque, unsigned int items, unsigned int size)
-{
- return g_malloc (items * size);
-}
-
-static void
-qtdemux_zfree (void *opaque, void *addr)
-{
- g_free (addr);
-}
-
-static void *
-qtdemux_inflate (void *z_buffer, int z_length, int length)
-{
- guint8 *buffer;
- z_stream *z;
- int ret;
-
- z = g_new0 (z_stream, 1);
- z->zalloc = qtdemux_zalloc;
- z->zfree = qtdemux_zfree;
- z->opaque = NULL;
-
- z->next_in = z_buffer;
- z->avail_in = z_length;
-
- buffer = (guint8 *) g_malloc (length);
- ret = inflateInit (z);
- while (z->avail_in > 0) {
- if (z->avail_out == 0) {
- length += 1024;
- buffer = (guint8 *) g_realloc (buffer, length);
- z->next_out = buffer + z->total_out;
- z->avail_out = 1024;
- }
- ret = inflate (z, Z_SYNC_FLUSH);
- if (ret != Z_OK)
- break;
- }
- if (ret != Z_STREAM_END) {
- g_warning ("inflate() returned %d", ret);
- }
-
- g_free (z);
- return buffer;
-}
-#endif /* HAVE_ZLIB */
-
-static gboolean
-qtdemux_parse_moov (GstQTDemux * qtdemux, guint8 * buffer, int length)
-{
- GNode *cmov;
-
- qtdemux->moov_node = g_node_new (buffer);
-
- GST_DEBUG_OBJECT (qtdemux, "parsing 'moov' atom");
- qtdemux_parse_node (qtdemux, qtdemux->moov_node, buffer, length);
-
- cmov = qtdemux_tree_get_child_by_type (qtdemux->moov_node, FOURCC_cmov);
- if (cmov) {
- guint32 method;
- GNode *dcom;
- GNode *cmvd;
-
- dcom = qtdemux_tree_get_child_by_type (cmov, FOURCC_dcom);
- cmvd = qtdemux_tree_get_child_by_type (cmov, FOURCC_cmvd);
- if (dcom == NULL || cmvd == NULL)
- goto invalid_compression;
-
- method = QT_FOURCC ((guint8 *) dcom->data + 8);
- switch (method) {
-#ifdef HAVE_ZLIB
- case GST_MAKE_FOURCC ('z', 'l', 'i', 'b'):{
- int uncompressed_length;
- int compressed_length;
- guint8 *buf;
-
- uncompressed_length = QT_UINT32 ((guint8 *) cmvd->data + 8);
- compressed_length = QT_UINT32 ((guint8 *) cmvd->data + 4) - 12;
- GST_LOG ("length = %d", 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);
-
- qtdemux_parse_node (qtdemux, qtdemux->moov_node, buf,
- uncompressed_length);
- break;
- }
-#endif /* HAVE_ZLIB */
- default:
- GST_WARNING_OBJECT (qtdemux, "unknown or unhandled header compression "
- "type %" GST_FOURCC_FORMAT, GST_FOURCC_ARGS (method));
- break;
- }
- }
- return TRUE;
-
- /* ERRORS */
-invalid_compression:
- {
- GST_ERROR_OBJECT (qtdemux, "invalid compressed header");
- return FALSE;
- }
-}
-
-static gboolean
-qtdemux_parse_container (GstQTDemux * qtdemux, GNode * node, guint8 * buf,
- guint8 * end)
-{
- while (buf < end) {
- GNode *child;
- guint32 len;
-
- if (buf + 4 > end) {
- GST_LOG_OBJECT (qtdemux, "buffer overrun");
- break;
- }
- len = QT_UINT32 (buf);
- if (len == 0) {
- GST_LOG_OBJECT (qtdemux, "empty container");
- break;
- }
- if (len < 8) {
- GST_WARNING_OBJECT (qtdemux, "length too short (%d < 8)", len);
- break;
- }
- if (len > (end - buf)) {
- GST_WARNING_OBJECT (qtdemux, "length too long (%d > %d)", len, end - buf);
- break;
- }
-
- child = g_node_new (buf);
- g_node_append (node, child);
- qtdemux_parse_node (qtdemux, child, buf, len);
-
- buf += len;
- }
- return TRUE;
-}
-
-static gboolean
-qtdemux_parse_node (GstQTDemux * qtdemux, GNode * node, guint8 * buffer,
- int length)
-{
- guint32 fourcc;
- guint32 node_length;
- const QtNodeType *type;
- guint8 *end;
-
- GST_LOG_OBJECT (qtdemux, "qtdemux_parse buffer %p length %d", buffer, length);
-
- node_length = QT_UINT32 (buffer);
- fourcc = QT_FOURCC (buffer + 4);
-
- type = qtdemux_type_get (fourcc);
-
- /* ignore empty nodes */
- if (fourcc == 0 || node_length == 8)
- return TRUE;
-
- end = buffer + length;
-
- GST_LOG_OBJECT (qtdemux,
- "parsing '%" GST_FOURCC_FORMAT "', length=%d, name '%s'",
- GST_FOURCC_ARGS (fourcc), node_length, type->name);
-
- if (type->flags & QT_FLAG_CONTAINER) {
- qtdemux_parse_container (qtdemux, node, buffer + 8, end);
- } else {
- switch (fourcc) {
- case FOURCC_stsd:
- {
- if (node_length < 20) {
- GST_LOG_OBJECT (qtdemux, "skipping small stsd box");
- break;
- }
- GST_DEBUG_OBJECT (qtdemux,
- "parsing stsd (sample table, sample description) atom");
- qtdemux_parse_container (qtdemux, node, buffer + 16, end);
- break;
- }
- case FOURCC_mp4a:
- {
- guint32 version;
- guint32 offset;
-
- if (length < 20) {
- GST_LOG_OBJECT (qtdemux, "skipping small mp4a box");
- break;
- }
- version = QT_UINT32 (buffer + 16);
-
- GST_WARNING_OBJECT (qtdemux, "mp4a version 0x%08x", version);
-
- /* parse any esds descriptors */
- switch (version) {
- case 0x00000000:
- case 0x00010000:
- offset = 0x24;
- break;
- case 0x00020000:
- offset = 0x48;
- break;
- default:
- GST_WARNING_OBJECT (qtdemux, "unhandled mp4a version 0x%08x",
- version);
- offset = 0;
- break;
- }
- if (offset)
- qtdemux_parse_container (qtdemux, node, buffer + offset, end);
- break;
- }
- case FOURCC_mp4v:
- {
- guint8 *buf;
- guint32 version;
- int tlen;
-
- GST_DEBUG_OBJECT (qtdemux, "parsing in mp4v");
- version = QT_UINT32 (buffer + 16);
- GST_DEBUG_OBJECT (qtdemux, "version %08x", version);
- if (1 || version == 0x00000000) {
- buf = buffer + 0x32;
-
- /* FIXME Quicktime uses PASCAL string while
- * the iso format uses C strings. Check the file
- * type before attempting to parse the string here. */
- tlen = QT_UINT8 (buf);
- GST_DEBUG_OBJECT (qtdemux, "tlen = %d", tlen);
- buf++;
- GST_DEBUG_OBJECT (qtdemux, "string = %.*s", tlen, (char *) buf);
- /* the string has a reserved space of 32 bytes so skip
- * the remaining 31 */
- buf += 31;
- buf += 4; /* and 4 bytes reserved */
-
- qtdemux_dump_mem (buf, end - buf);
-
- qtdemux_parse_container (qtdemux, node, buf, end);
- }
- break;
- }
- case FOURCC_meta:
- {
- GST_DEBUG_OBJECT (qtdemux, "parsing meta atom");
- qtdemux_parse_container (qtdemux, node, buffer + 12, end);
- break;
- }
- default:
- break;
- }
- }
- GST_LOG_OBJECT (qtdemux, "parsed '%" GST_FOURCC_FORMAT,
- GST_FOURCC_ARGS (fourcc));
- return TRUE;
-}
-
-static GNode *
-qtdemux_tree_get_child_by_type (GNode * node, guint32 fourcc)
-{
- GNode *child;
- guint8 *buffer;
- guint32 child_fourcc;
-
- for (child = g_node_first_child (node); child;
- child = g_node_next_sibling (child)) {
- buffer = (guint8 *) child->data;
-
- child_fourcc = QT_FOURCC (buffer + 4);
-
- if (child_fourcc == fourcc) {
- return child;
- }
- }
- return NULL;
-}
-
-static GNode *
-qtdemux_tree_get_sibling_by_type (GNode * node, guint32 fourcc)
-{
- GNode *child;
- guint8 *buffer;
- guint32 child_fourcc;
-
- for (child = g_node_next_sibling (node); child;
- child = g_node_next_sibling (child)) {
- buffer = (guint8 *) child->data;
-
- child_fourcc = QT_FOURCC (buffer + 4);
-
- if (child_fourcc == fourcc) {
- return child;
- }
- }
- return NULL;
-}
-
-static gboolean
-gst_qtdemux_add_stream (GstQTDemux * qtdemux,
- QtDemuxStream * stream, GstTagList * list)
-{
- if (qtdemux->n_streams >= GST_QTDEMUX_MAX_STREAMS)
- goto too_many_streams;
-
- if (stream->subtype == FOURCC_vide) {
- gchar *name = g_strdup_printf ("video_%02d", qtdemux->n_video_streams);
-
- stream->pad =
- gst_pad_new_from_static_template (&gst_qtdemux_videosrc_template, name);
- g_free (name);
-
- /* fps is calculated base on the duration of the first frames since
- * qt does not have a fixed framerate. */
- if ((stream->n_samples == 1) && (stream->min_duration == 0)) {
- /* still frame */
- stream->fps_n = 0;
- stream->fps_d = 1;
- } else {
- stream->fps_n = stream->timescale;
- if (stream->min_duration == 0)
- stream->fps_d = 1;
- else
- stream->fps_d = stream->min_duration;
- }
-
- if (stream->caps) {
- gboolean gray;
- gint depth, palette_count;
- const guint32 *palette_data = NULL;
-
- gst_caps_set_simple (stream->caps,
- "width", G_TYPE_INT, stream->width,
- "height", G_TYPE_INT, stream->height,
- "framerate", GST_TYPE_FRACTION, stream->fps_n, stream->fps_d, NULL);
-
- depth = stream->bits_per_sample;
-
- /* more than 32 bits means grayscale */
- gray = (depth > 32);
- /* low 32 bits specify the depth */
- depth &= 0x1F;
-
- /* different number of palette entries is determined by depth. */
- palette_count = 0;
- if ((depth == 1) || (depth == 2) || (depth == 4) || (depth == 8))
- palette_count = (1 << depth);
-
- switch (palette_count) {
- case 0:
- break;
- case 2:
- palette_data = ff_qt_default_palette_2;
- break;
- case 4:
- palette_data = ff_qt_default_palette_4;
- break;
- case 16:
- if (gray)
- palette_data = ff_qt_grayscale_palette_16;
- else
- palette_data = ff_qt_default_palette_16;
- break;
- case 256:
- if (gray)
- palette_data = ff_qt_grayscale_palette_256;
- else
- palette_data = ff_qt_default_palette_256;
- break;
- default:
- GST_ELEMENT_WARNING (qtdemux, STREAM, DECODE,
- (_("The video in this file might not play correctly.")),
- ("unsupported palette depth %d", depth));
- break;
- }
- if (palette_data) {
- GstBuffer *palette;
-
- /* make sure it's not writable. We leave MALLOCDATA to NULL so that we
- * don't free any of the buffer data. */
- palette = gst_buffer_new ();
- GST_BUFFER_FLAG_SET (palette, GST_BUFFER_FLAG_READONLY);
- GST_BUFFER_DATA (palette) = (guint8 *) palette_data;
- GST_BUFFER_SIZE (palette) = sizeof (guint32) * palette_count;
-
- gst_caps_set_simple (stream->caps, "palette_data",
- GST_TYPE_BUFFER, palette, NULL);
- gst_buffer_unref (palette);
- } else if (palette_count != 0) {
- GST_ELEMENT_WARNING (qtdemux, STREAM, NOT_IMPLEMENTED,
- (NULL), ("Unsupported palette depth %d. Ignoring stream.", depth));
-
- gst_object_unref (stream->pad);
- stream->pad = NULL;
- }
- }
- qtdemux->n_video_streams++;
- } else if (stream->subtype == FOURCC_soun) {
- gchar *name = g_strdup_printf ("audio_%02d", qtdemux->n_audio_streams);
-
- stream->pad =
- gst_pad_new_from_static_template (&gst_qtdemux_audiosrc_template, name);
- g_free (name);
- if (stream->caps) {
- gst_caps_set_simple (stream->caps,
- "rate", G_TYPE_INT, (int) stream->rate,
- "channels", G_TYPE_INT, stream->n_channels, NULL);
- }
- qtdemux->n_audio_streams++;
- } else if (stream->subtype == FOURCC_strm) {
- GST_DEBUG_OBJECT (qtdemux, "stream type, not creating pad");
- } else {
- GST_DEBUG_OBJECT (qtdemux, "unknown stream type");
- goto done;
- }
-
- qtdemux->streams[qtdemux->n_streams] = stream;
- qtdemux->n_streams++;
- GST_DEBUG_OBJECT (qtdemux, "n_streams is now %d", qtdemux->n_streams);
-
- if (stream->pad) {
- GST_PAD_ELEMENT_PRIVATE (stream->pad) = stream;
-
- gst_pad_use_fixed_caps (stream->pad);
- gst_pad_set_event_function (stream->pad, gst_qtdemux_handle_src_event);
- gst_pad_set_query_type_function (stream->pad,
- gst_qtdemux_get_src_query_types);
- gst_pad_set_query_function (stream->pad, gst_qtdemux_handle_src_query);
-
- GST_DEBUG_OBJECT (qtdemux, "setting caps %" GST_PTR_FORMAT, stream->caps);
- gst_pad_set_caps (stream->pad, stream->caps);
-
- GST_DEBUG_OBJECT (qtdemux, "adding pad %s %p to qtdemux %p",
- GST_OBJECT_NAME (stream->pad), stream->pad, qtdemux);
- gst_pad_set_active (stream->pad, TRUE);
- gst_element_add_pad (GST_ELEMENT_CAST (qtdemux), stream->pad);
- if (list)
- gst_element_found_tags_for_pad (GST_ELEMENT_CAST (qtdemux), stream->pad,
- list);
- }
-done:
- return TRUE;
-
-too_many_streams:
- {
- GST_ELEMENT_WARNING (qtdemux, STREAM, DECODE,
- (_("This file contains too many streams. Only playing first %d"),
- GST_QTDEMUX_MAX_STREAMS), (NULL));
- return TRUE;
- }
-}
-
-/* collect all samples for @stream by reading the info from @stbl
- */
-static gboolean
-qtdemux_parse_samples (GstQTDemux * qtdemux, QtDemuxStream * stream,
- GNode * stbl)
-{
- int offset;
- GNode *stsc;
- GNode *stsz;
- GNode *stco;
- GNode *co64;
- GNode *stts;
- GNode *stss;
- GNode *ctts;
- const guint8 *stsc_data, *stsz_data, *stco_data;
- int sample_size;
- int sample_index;
- int n_samples;
- int n_samples_per_chunk;
- int n_sample_times;
- QtDemuxSample *samples;
- gint i, j, k;
- int index;
- guint64 timestamp, time;
-
- /* sample to chunk */
- if (!(stsc = qtdemux_tree_get_child_by_type (stbl, FOURCC_stsc)))
- goto corrupt_file;
- stsc_data = (const guint8 *) stsc->data;
- /* sample size */
- if (!(stsz = qtdemux_tree_get_child_by_type (stbl, FOURCC_stsz)))
- goto corrupt_file;
- 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);
- if (stco) {
- stco_data = (const guint8 *) stco->data;
- } else {
- stco_data = NULL;
- if (co64 == NULL)
- goto corrupt_file;
- }
- /* sample time */
- if (!(stts = qtdemux_tree_get_child_by_type (stbl, FOURCC_stts)))
- goto corrupt_file;
-
- /* sample sync, can be NULL */
- stss = qtdemux_tree_get_child_by_type (stbl, FOURCC_stss);
-
- sample_size = QT_UINT32 (stsz_data + 12);
- if (sample_size == 0 || stream->sampled) {
- n_samples = QT_UINT32 (stsz_data + 16);
- GST_DEBUG_OBJECT (qtdemux, "stsz sample_size 0, allocating n_samples %d",
- n_samples);
- stream->n_samples = n_samples;
- samples = g_new0 (QtDemuxSample, n_samples);
- stream->samples = samples;
-
- for (i = 0; i < n_samples; i++) {
- if (sample_size == 0)
- samples[i].size = QT_UINT32 (stsz_data + i * 4 + 20);
- else
- samples[i].size = sample_size;
-
- GST_LOG_OBJECT (qtdemux, "sample %d has size %d", i, samples[i].size);
- /* init other fields to defaults for this sample */
- samples[i].keyframe = FALSE;
- }
- n_samples_per_chunk = QT_UINT32 (stsc_data + 12);
- index = 0;
- for (i = 0; i < n_samples_per_chunk; i++) {
- guint32 first_chunk, last_chunk;
- guint32 samples_per_chunk;
-
- first_chunk = QT_UINT32 (stsc_data + 16 + i * 12 + 0) - 1;
- if (i == n_samples_per_chunk - 1) {
- last_chunk = G_MAXUINT32;
- } else {
- last_chunk = QT_UINT32 (stsc_data + 16 + i * 12 + 12) - 1;
- }
- samples_per_chunk = QT_UINT32 (stsc_data + 16 + i * 12 + 4);
-
- for (j = first_chunk; j < last_chunk; j++) {
- guint64 chunk_offset;
-
- if (stco) {
- chunk_offset = QT_UINT32 (stco_data + 16 + j * 4);
- } else {
- chunk_offset = QT_UINT64 ((guint8 *) co64->data + 16 + j * 8);
- }
- for (k = 0; k < samples_per_chunk; k++) {
- GST_LOG_OBJECT (qtdemux, "Creating entry %d with offset %lld",
- index, chunk_offset);
- samples[index].chunk = j;
- samples[index].offset = chunk_offset;
- chunk_offset += samples[index].size;
- index++;
- if (index >= n_samples)
- goto done2;
- }
- }
- }
- done2:
-
- n_sample_times = QT_UINT32 ((guint8 *) stts->data + 12);
- timestamp = 0;
- stream->min_duration = 0;
- time = 0;
- index = 0;
- for (i = 0; i < n_sample_times; i++) {
- guint32 n;
- guint32 duration;
-
- n = QT_UINT32 ((guint8 *) stts->data + 16 + 8 * i);
- duration = QT_UINT32 ((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));
-
- samples[index].timestamp = timestamp;
- /* take first duration for fps */
- if (stream->min_duration == 0)
- stream->min_duration = duration;
- /* add non-scaled values to avoid rounding errors */
- time += duration;
- timestamp = gst_util_uint64_scale (time, GST_SECOND, stream->timescale);
- samples[index].duration = timestamp - samples[index].timestamp;
-
- index++;
- }
- }
- if (stss) {
- /* mark keyframes */
- guint32 n_sample_syncs;
-
- n_sample_syncs = QT_UINT32 ((guint8 *) stss->data + 12);
- if (n_sample_syncs == 0) {
- stream->all_keyframe = TRUE;
- } else {
- offset = 16;
- for (i = 0; i < n_sample_syncs; i++) {
- /* note that the first sample is index 1, not 0 */
- index = QT_UINT32 ((guint8 *) stss->data + offset);
- samples[index - 1].keyframe = TRUE;
- offset += 4;
- }
- }
- } else {
- /* no stss, all samples are keyframes */
- stream->all_keyframe = TRUE;
- }
- } else {
- GST_DEBUG_OBJECT (qtdemux,
- "stsz sample_size %d != 0, treating chunks as samples", sample_size);
-
- /* treat chunks as samples */
- if (stco) {
- n_samples = QT_UINT32 (stco_data + 12);
- } else {
- n_samples = QT_UINT32 ((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 = QT_UINT32 (stsc_data + 12);
- GST_DEBUG_OBJECT (qtdemux, "n_samples_per_chunk %d", n_samples_per_chunk);
- sample_index = 0;
- timestamp = 0;
- for (i = 0; i < n_samples_per_chunk; i++) {
- guint32 first_chunk, last_chunk;
- guint32 samples_per_chunk;
-
- first_chunk = QT_UINT32 (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 = QT_UINT32 (stsc_data + 16 + i * 12 + 12) - 1;
- }
- samples_per_chunk = QT_UINT32 (stsc_data + 16 + i * 12 + 4);
-
- GST_LOG_OBJECT (qtdemux,
- "entry %d has first_chunk %d, last_chunk %d, samples_per_chunk %d", i,
- first_chunk, last_chunk, samples_per_chunk);
-
- for (j = first_chunk; j < last_chunk; j++) {
- guint64 chunk_offset;
-
- if (j >= n_samples)
- goto done;
-
- if (stco) {
- chunk_offset = QT_UINT32 (stco_data + 16 + j * 4);
- } else {
- chunk_offset = QT_UINT64 ((guint8 *) co64->data + 16 + j * 8);
- }
- GST_LOG_OBJECT (qtdemux,
- "Creating entry %d with offset %" G_GUINT64_FORMAT, j,
- chunk_offset);
-
- samples[j].chunk = j;
- samples[j].offset = chunk_offset;
-
- if (stream->samples_per_frame * stream->bytes_per_frame) {
- samples[j].size = (samples_per_chunk * stream->n_channels) /
- stream->samples_per_frame * stream->bytes_per_frame;
- } else {
- samples[j].size = samples_per_chunk;
- }
-
- GST_INFO_OBJECT (qtdemux, "sample %d: timestamp %" GST_TIME_FORMAT
- ", size %u", j, GST_TIME_ARGS (timestamp), samples[j].size);
-
- samples[j].timestamp = timestamp;
- sample_index += samples_per_chunk;
-
- timestamp = gst_util_uint64_scale (sample_index,
- GST_SECOND, stream->timescale);
- samples[j].duration = timestamp - samples[j].timestamp;
-
- samples[j].keyframe = TRUE;
- }
- }
- }
-
- /* composition time to sample */
- if ((ctts = qtdemux_tree_get_child_by_type (stbl, FOURCC_ctts))) {
- const guint8 *ctts_data = (const guint8 *) ctts->data;
- guint32 n_entries = QT_UINT32 (ctts_data + 12);
- guint32 count;
- gint32 soffset;
-
- /* Fill in the pts_offsets */
- for (i = 0, j = 0; (j < stream->n_samples) && (i < n_entries); i++) {
- count = QT_UINT32 (ctts_data + 16 + i * 8);
- soffset = QT_UINT32 (ctts_data + 20 + i * 8);
- for (k = 0; k < count; k++, j++) {
- /* we operate with very small soffset values here, it shouldn't overflow */
- samples[j].pts_offset = soffset * GST_SECOND / stream->timescale;
- }
- }
- }
-done:
- return TRUE;
-
-/* ERRORS */
-corrupt_file:
- {
- GST_ELEMENT_ERROR (qtdemux, STREAM, DECODE,
- (_("This file is corrupt and cannot be played.")), (NULL));
- return FALSE;
- }
-}
-
-/* collect all segment info for @stream.
- */
-static gboolean
-qtdemux_parse_segments (GstQTDemux * qtdemux, QtDemuxStream * stream,
- GNode * trak)
-{
- GNode *edts;
-
- /* parse and prepare segment info from the edit list */
- GST_DEBUG_OBJECT (qtdemux, "looking for edit list container");
- stream->n_segments = 0;
- stream->segments = NULL;
- if ((edts = qtdemux_tree_get_child_by_type (trak, FOURCC_edts))) {
- GNode *elst;
- gint n_segments;
- gint i, count;
- guint64 time, stime;
- guint8 *buffer;
-
- GST_DEBUG_OBJECT (qtdemux, "looking for edit list");
- if (!(elst = qtdemux_tree_get_child_by_type (edts, FOURCC_elst)))
- goto done;
-
- buffer = elst->data;
-
- n_segments = QT_UINT32 (buffer + 12);
-
- /* we might allocate a bit too much, at least allocate 1 segment */
- stream->segments = g_new (QtDemuxSegment, MAX (n_segments, 1));
-
- /* segments always start from 0 */
- time = 0;
- stime = 0;
- count = 0;
- for (i = 0; i < n_segments; i++) {
- guint64 duration;
- guint64 media_time;
- QtDemuxSegment *segment;
-
- media_time = QT_UINT32 (buffer + 20 + i * 12);
-
- /* -1 media time is an empty segment, just ignore it */
- if (media_time == G_MAXUINT32)
- continue;
-
- duration = QT_UINT32 (buffer + 16 + i * 12);
-
- segment = &stream->segments[count++];
-
- /* time and duration expressed in global timescale */
- segment->time = stime;
- /* add non scaled values so we don't cause roundoff errors */
- time += duration;
- stime = gst_util_uint64_scale (time, GST_SECOND, qtdemux->timescale);
- segment->stop_time = stime;
- segment->duration = stime - segment->time;
- /* media_time expressed in stream timescale */
- segment->media_start =
- gst_util_uint64_scale (media_time, GST_SECOND, stream->timescale);
- segment->media_stop = segment->media_start + segment->duration;
- segment->rate = QT_FP32 (buffer + 24 + i * 12);
-
- GST_DEBUG_OBJECT (qtdemux, "created segment %d time %" GST_TIME_FORMAT
- ", duration %" GST_TIME_FORMAT ", media_time %" GST_TIME_FORMAT
- ", rate %g", i, GST_TIME_ARGS (segment->time),
- GST_TIME_ARGS (segment->duration),
- GST_TIME_ARGS (segment->media_start), segment->rate);
- }
- GST_DEBUG_OBJECT (qtdemux, "found %d non-empty segments", count);
- stream->n_segments = count;
- }
-done:
-
- /* no segments, create one to play the complete trak */
- if (stream->n_segments == 0) {
- if (stream->segments == NULL)
- stream->segments = g_new (QtDemuxSegment, 1);
-
- stream->segments[0].time = 0;
- stream->segments[0].stop_time = qtdemux->segment.duration;
- stream->segments[0].duration = qtdemux->segment.duration;
- stream->segments[0].media_start = 0;
- stream->segments[0].media_stop = qtdemux->segment.duration;
- stream->segments[0].rate = 1.0;
-
- GST_DEBUG_OBJECT (qtdemux, "created dummy segment");
- stream->n_segments = 1;
- }
- GST_DEBUG_OBJECT (qtdemux, "using %d segments", stream->n_segments);
-
- return TRUE;
-}
-
-/* parse the traks.
- * With each track we associate a new QtDemuxStream that contains all the info
- * about the trak.
- * traks that do not decode to something (like strm traks) will not have a pad.
- */
-static gboolean
-qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak)
-{
- int offset;
- GNode *tkhd;
- GNode *mdia;
- GNode *mdhd;
- GNode *hdlr;
- GNode *minf;
- GNode *stbl;
- GNode *stsd;
- GNode *mp4a;
- GNode *mp4v;
- GNode *wave;
- GNode *esds;
- QtDemuxStream *stream;
- GstTagList *list = NULL;
- const gchar *codec = NULL;
- const guint8 *stsd_data;
- guint32 version;
-
- /* new streams always need a discont */
- stream = g_new0 (QtDemuxStream, 1);
- stream->discont = TRUE;
- stream->segment_index = -1;
- stream->time_position = 0;
- stream->sample_index = 0;
- stream->last_ret = GST_FLOW_OK;
-
- if (!(tkhd = qtdemux_tree_get_child_by_type (trak, FOURCC_tkhd)))
- goto corrupt_file;
-
- GST_LOG_OBJECT (qtdemux, "track[tkhd] version/flags: 0x%08x",
- QT_UINT32 ((guint8 *) tkhd->data + 8));
-
- if (!(mdia = qtdemux_tree_get_child_by_type (trak, FOURCC_mdia)))
- goto corrupt_file;
-
- if (!(mdhd = qtdemux_tree_get_child_by_type (mdia, FOURCC_mdhd)))
- goto corrupt_file;
-
- version = QT_UINT32 ((guint8 *) mdhd->data + 8);
- GST_LOG_OBJECT (qtdemux, "track version/flags: %08x", version);
- if (version == 0x01000000) {
- stream->timescale = QT_UINT32 ((guint8 *) mdhd->data + 28);
- stream->duration = QT_UINT64 ((guint8 *) mdhd->data + 32);
- } else {
- stream->timescale = QT_UINT32 ((guint8 *) mdhd->data + 20);
- stream->duration = QT_UINT32 ((guint8 *) mdhd->data + 24);
- }
-
- GST_LOG_OBJECT (qtdemux, "track timescale: %" G_GUINT32_FORMAT,
- stream->timescale);
- GST_LOG_OBJECT (qtdemux, "track duration: %" G_GUINT64_FORMAT,
- stream->duration);
-
- if (qtdemux->duration != G_MAXINT32 && stream->duration != G_MAXINT32) {
- guint64 tdur1, tdur2;
-
- /* don't overflow */
- tdur1 = stream->timescale * (guint64) qtdemux->duration;
- tdur2 = qtdemux->timescale * (guint64) stream->duration;
-
- /* HACK:
- * some of those trailers, nowadays, have prologue images that are
- * themselves vide tracks as well. I haven't really found a way to
- * identify those yet, except for just looking at their duration. */
- if (tdur1 != 0 && (tdur2 * 10 / tdur1) < 2) {
- GST_WARNING_OBJECT (qtdemux,
- "Track shorter than 20%% (%" G_GUINT64_FORMAT "/%" G_GUINT32_FORMAT
- " vs. %" G_GUINT32_FORMAT "/%" G_GUINT32_FORMAT ") of the stream "
- "found, assuming preview image or something; skipping track",
- stream->duration, stream->timescale, qtdemux->duration,
- qtdemux->timescale);
- g_free (stream);
- return TRUE;
- }
- }
-
- if (!(hdlr = qtdemux_tree_get_child_by_type (mdia, FOURCC_hdlr)))
- goto corrupt_file;
-
- GST_LOG_OBJECT (qtdemux, "track type: %" GST_FOURCC_FORMAT,
- GST_FOURCC_ARGS (QT_FOURCC ((guint8 *) hdlr->data + 12)));
-
- stream->subtype = QT_FOURCC ((guint8 *) hdlr->data + 16);
- GST_LOG_OBJECT (qtdemux, "track subtype: %" GST_FOURCC_FORMAT,
- GST_FOURCC_ARGS (stream->subtype));
-
- if (!(minf = qtdemux_tree_get_child_by_type (mdia, FOURCC_minf)))
- goto corrupt_file;
-
- if (!(stbl = qtdemux_tree_get_child_by_type (minf, FOURCC_stbl)))
- goto corrupt_file;
-
- /* parse stsd */
- if (!(stsd = qtdemux_tree_get_child_by_type (stbl, FOURCC_stsd)))
- goto corrupt_file;
- stsd_data = (const guint8 *) stsd->data;
-
- if (stream->subtype == FOURCC_vide) {
- guint32 fourcc;
-
- stream->sampled = TRUE;
-
- offset = 16;
- stream->fourcc = fourcc = QT_FOURCC (stsd_data + offset + 4);
- GST_LOG_OBJECT (qtdemux, "st type: %" GST_FOURCC_FORMAT,
- GST_FOURCC_ARGS (fourcc));
-
- stream->width = QT_UINT16 (stsd_data + offset + 32);
- stream->height = QT_UINT16 (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 = QT_UINT16 (stsd_data + offset + 82);
- stream->color_table_id = QT_UINT16 (stsd_data + offset + 84);
-
- GST_LOG_OBJECT (qtdemux, "frame count: %u",
- QT_UINT16 (stsd_data + offset + 48));
-
- if (fourcc == FOURCC_drms)
- goto error_encrypted;
-
- 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,
- GST_TAG_VIDEO_CODEC, codec, NULL);
- }
-
- esds = NULL;
- mp4v = qtdemux_tree_get_child_by_type (stsd, FOURCC_mp4v);
- if (mp4v)
- esds = qtdemux_tree_get_child_by_type (mp4v, FOURCC_esds);
-
- if (esds) {
- gst_qtdemux_handle_esds (qtdemux, stream, esds, list);
- } else {
- switch (fourcc) {
- case FOURCC_avc1:
- {
- gint len = QT_UINT32 (stsd_data) - 0x66;
- const guint8 *avc_data = stsd_data + 0x66;
-
- /* find avcC */
- while (len >= 0x8 &&
- QT_FOURCC (avc_data + 0x4) != FOURCC_avcC &&
- QT_UINT32 (avc_data) < len) {
- len -= QT_UINT32 (avc_data);
- avc_data += QT_UINT32 (avc_data);
- }
-
- /* parse, if found */
- if (len > 0x8 && QT_FOURCC (avc_data + 0x4) == FOURCC_avcC) {
- GstBuffer *buf;
- gint size;
-
- if (QT_UINT32 (avc_data) < len)
- size = QT_UINT32 (avc_data) - 0x8;
- else
- size = len - 0x8;
-
- GST_DEBUG_OBJECT (qtdemux, "found avcC codec_data in stsd");
-
- buf = gst_buffer_new_and_alloc (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);
- }
- break;
- }
- case FOURCC_SVQ3:
- case FOURCC_VP31:
- {
- GstBuffer *buf;
- gint len = QT_UINT32 (stsd_data);
-
- GST_DEBUG_OBJECT (qtdemux, "found codec_data in stsd");
-
- buf = gst_buffer_new_and_alloc (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);
- break;
- }
- case FOURCC_rle_:
- {
- gst_caps_set_simple (stream->caps,
- "depth", G_TYPE_INT, QT_UINT16 (stsd_data + offset + 82), NULL);
- break;
- }
- default:
- break;
- }
- }
-
- GST_INFO_OBJECT (qtdemux,
- "type %" GST_FOURCC_FORMAT " caps %" GST_PTR_FORMAT,
- GST_FOURCC_ARGS (fourcc), stream->caps);
-
- } else if (stream->subtype == FOURCC_soun) {
- int version, samplesize;
- guint32 fourcc;
- int len;
- guint16 compression_id;
-
- len = QT_UINT32 (stsd_data + 16);
- GST_LOG_OBJECT (qtdemux, "stsd len: %d", len);
-
- stream->fourcc = fourcc = QT_FOURCC (stsd_data + 16 + 4);
- GST_LOG_OBJECT (qtdemux, "stsd type: %" GST_FOURCC_FORMAT,
- GST_FOURCC_ARGS (stream->fourcc));
-
- offset = 32;
-
- version = QT_UINT32 (stsd_data + offset);
- stream->n_channels = QT_UINT16 (stsd_data + offset + 8);
- samplesize = QT_UINT16 (stsd_data + offset + 10);
- compression_id = QT_UINT16 (stsd_data + offset + 12);
- stream->rate = QT_FP32 (stsd_data + offset + 16);
-
- GST_LOG_OBJECT (qtdemux, "version/rev: %08x", version);
- GST_LOG_OBJECT (qtdemux, "vendor: %08x",
- QT_UINT32 (stsd_data + offset + 4));
- GST_LOG_OBJECT (qtdemux, "n_channels: %d", stream->n_channels);
- GST_LOG_OBJECT (qtdemux, "sample_size: %d", samplesize);
- GST_LOG_OBJECT (qtdemux, "compression_id: %d", compression_id);
- GST_LOG_OBJECT (qtdemux, "packet size: %d",
- QT_UINT16 (stsd_data + offset + 14));
- GST_LOG_OBJECT (qtdemux, "sample rate: %g", stream->rate);
-
- if (compression_id == 0xfffe)
- stream->sampled = TRUE;
-
- /* first assume uncompressed audio */
- stream->bytes_per_sample = samplesize / 8;
- stream->samples_per_frame = stream->n_channels;
- stream->bytes_per_frame = stream->n_channels * stream->bytes_per_sample;
- stream->samples_per_packet = stream->samples_per_frame;
- stream->bytes_per_packet = stream->bytes_per_sample;
-
- offset = 52;
- switch (fourcc) {
- /* Yes, these have to be hard-coded */
- case FOURCC_MAC6:
- {
- stream->samples_per_packet = 6;
- stream->bytes_per_packet = 1;
- stream->bytes_per_frame = 1 * stream->n_channels;
- stream->bytes_per_sample = 1;
- stream->samples_per_frame = 6 * stream->n_channels;
- break;
- }
- case FOURCC_MAC3:
- {
- stream->samples_per_packet = 3;
- stream->bytes_per_packet = 1;
- stream->bytes_per_frame = 1 * stream->n_channels;
- stream->bytes_per_sample = 1;
- stream->samples_per_frame = 3 * stream->n_channels;
- break;
- }
- case FOURCC_ima4:
- {
- stream->samples_per_packet = 64;
- stream->bytes_per_packet = 34;
- stream->bytes_per_frame = 34 * stream->n_channels;
- stream->bytes_per_sample = 2;
- stream->samples_per_frame = 64 * stream->n_channels;
- break;
- }
- case FOURCC_ulaw:
- case FOURCC_alaw:
- {
- stream->samples_per_packet = 1;
- stream->bytes_per_packet = 1;
- stream->bytes_per_frame = 1 * stream->n_channels;
- stream->bytes_per_sample = 1;
- stream->samples_per_frame = 1 * stream->n_channels;
- break;
- }
- default:
- break;
- }
- if (version == 0x00010000) {
- switch (fourcc) {
- case FOURCC_twos:
- case FOURCC_sowt:
- case FOURCC_raw_:
- break;
- default:
- {
- /* only parse extra decoding config for non-pcm audio */
- stream->samples_per_packet = QT_UINT32 (stsd_data + offset);
- stream->bytes_per_packet = QT_UINT32 (stsd_data + offset + 4);
- stream->bytes_per_frame = QT_UINT32 (stsd_data + offset + 8);
- stream->bytes_per_sample = QT_UINT32 (stsd_data + offset + 12);
-
- GST_LOG_OBJECT (qtdemux, "samples/packet: %d",
- stream->samples_per_packet);
- GST_LOG_OBJECT (qtdemux, "bytes/packet: %d",
- stream->bytes_per_packet);
- GST_LOG_OBJECT (qtdemux, "bytes/frame: %d",
- stream->bytes_per_frame);
- GST_LOG_OBJECT (qtdemux, "bytes/sample: %d",
- stream->bytes_per_sample);
-
- if (!stream->sampled && stream->bytes_per_packet) {
- stream->samples_per_frame = (stream->bytes_per_frame /
- stream->bytes_per_packet) * stream->samples_per_packet;
- GST_LOG_OBJECT (qtdemux, "samples/frame: %d",
- stream->samples_per_frame);
- }
- break;
- }
- }
- offset = 68;
- } else if (version == 0x00020000) {
- union
- {
- gdouble fp;
- guint64 val;
- } qtfp;
-
- stream->samples_per_packet = QT_UINT32 (stsd_data + offset);
- qtfp.val = QT_UINT64 (stsd_data + offset + 4);
- stream->rate = qtfp.fp;
- stream->n_channels = QT_UINT32 (stsd_data + offset + 12);
-
- GST_LOG_OBJECT (qtdemux, "samples/packet: %d",
- stream->samples_per_packet);
- GST_LOG_OBJECT (qtdemux, "sample rate: %g", stream->rate);
- GST_LOG_OBJECT (qtdemux, "n_channels: %d", stream->n_channels);
-
- offset = 68;
- } else {
- GST_WARNING_OBJECT (qtdemux, "unknown version %08x", version);
- }
-
- if (fourcc == FOURCC_drms)
- goto error_encrypted;
-
- stream->caps = qtdemux_audio_caps (qtdemux, stream, fourcc, NULL, 0,
- &codec);
-
- if (codec) {
- list = gst_tag_list_new ();
- gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
- GST_TAG_AUDIO_CODEC, codec, NULL);
- }
-
- mp4a = qtdemux_tree_get_child_by_type (stsd, FOURCC_mp4a);
- wave = NULL;
- esds = NULL;
- if (mp4a) {
- wave = qtdemux_tree_get_child_by_type (mp4a, FOURCC_wave);
- if (wave)
- esds = qtdemux_tree_get_child_by_type (wave, FOURCC_esds);
- if (!esds)
- esds = qtdemux_tree_get_child_by_type (mp4a, FOURCC_esds);
- }
-
- if (esds) {
- gst_qtdemux_handle_esds (qtdemux, stream, esds, list);
- } else {
- switch (fourcc) {
- case FOURCC_QDM2:
- {
- gint len = QT_UINT32 (stsd_data);
-
- if (len > 0x4C) {
- GstBuffer *buf = gst_buffer_new_and_alloc (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);
- break;
- }
- case FOURCC_alac:
- {
- gint len = QT_UINT32 (stsd_data);
-
- if (len > 0x34) {
- GstBuffer *buf = gst_buffer_new_and_alloc (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);
- }
- gst_caps_set_simple (stream->caps,
- "samplesize", G_TYPE_INT, samplesize, NULL);
- break;
- }
- default:
- break;
- }
- }
- GST_INFO_OBJECT (qtdemux,
- "type %" GST_FOURCC_FORMAT " caps %" GST_PTR_FORMAT,
- GST_FOURCC_ARGS (fourcc), stream->caps);
-
- } else if (stream->subtype == FOURCC_strm) {
- guint32 fourcc;
-
- stream->fourcc = fourcc = QT_FOURCC (stsd_data + 16 + 4);
- GST_LOG_OBJECT (qtdemux, "stsd type: %" GST_FOURCC_FORMAT,
- GST_FOURCC_ARGS (fourcc));
-
- if (fourcc != FOURCC_rtsp) {
- GST_INFO_OBJECT (qtdemux, "unhandled stream type %" GST_FOURCC_FORMAT,
- GST_FOURCC_ARGS (fourcc));
- goto unknown_stream;
- }
- stream->sampled = TRUE;
- } else {
- goto unknown_stream;
- }
-
- /* promote to sampled format */
- if (stream->fourcc == FOURCC_samr) {
- /* force mono 8000 Hz for AMR */
- stream->sampled = TRUE;
- stream->n_channels = 1;
- stream->rate = 8000;
- } else if (stream->fourcc == FOURCC_sawb) {
- /* force mono 16000 Hz for AMR-WB */
- stream->sampled = TRUE;
- stream->n_channels = 1;
- stream->rate = 16000;
- } else if (stream->fourcc == FOURCC_mp4a) {
- stream->sampled = TRUE;
- }
-
- /* collect sample information */
- if (!qtdemux_parse_samples (qtdemux, stream, stbl))
- goto samples_failed;
-
- /* configure segments */
- if (!qtdemux_parse_segments (qtdemux, stream, trak))
- goto segments_failed;
-
- /* now we are ready to add the stream */
- gst_qtdemux_add_stream (qtdemux, stream, list);
-
- return TRUE;
-
-/* ERRORS */
-corrupt_file:
- {
- GST_ELEMENT_ERROR (qtdemux, STREAM, DECODE,
- (_("This file is corrupt and cannot be played.")), (NULL));
- g_free (stream);
- return FALSE;
- }
-error_encrypted:
- {
- GST_ELEMENT_ERROR (qtdemux, STREAM, DECODE,
- (_("This file is encrypted and cannot be played.")), (NULL));
- g_free (stream);
- return FALSE;
- }
-samples_failed:
- {
- /* we posted an error already */
- g_free (stream);
- return FALSE;
- }
-segments_failed:
- {
- /* we posted an error already */
- g_free (stream);
- return FALSE;
- }
-unknown_stream:
- {
- GST_INFO_OBJECT (qtdemux, "unknown subtype %" GST_FOURCC_FORMAT,
- GST_FOURCC_ARGS (stream->subtype));
- g_free (stream);
- return TRUE;
- }
-}
-
-static void
-qtdemux_tag_add_str (GstQTDemux * qtdemux, const char *tag, GNode * node)
-{
- GNode *data;
- char *s;
- int len;
- int type;
-
- data = qtdemux_tree_get_child_by_type (node, FOURCC_data);
- if (data) {
- len = QT_UINT32 (data->data);
- type = QT_UINT32 ((guint8 *) data->data + 8);
- if (type == 0x00000001) {
- s = g_strndup ((char *) data->data + 16, len - 16);
- GST_DEBUG_OBJECT (qtdemux, "adding tag %s", s);
- gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_REPLACE, tag, s, NULL);
- g_free (s);
- }
- }
-}
-
-static void
-qtdemux_tag_add_num (GstQTDemux * qtdemux, const char *tag1,
- const char *tag2, GNode * node)
-{
- GNode *data;
- int len;
- int type;
- int n1, n2;
-
- data = qtdemux_tree_get_child_by_type (node, FOURCC_data);
- if (data) {
- len = QT_UINT32 (data->data);
- type = QT_UINT32 ((guint8 *) data->data + 8);
- if (type == 0x00000000 && len >= 22) {
- n1 = QT_UINT16 ((guint8 *) data->data + 18);
- n2 = QT_UINT16 ((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);
- }
- }
-}
-
-static void
-qtdemux_tag_add_date (GstQTDemux * qtdemux, const char *tag, GNode * node)
-{
- GNode *data;
- char *s;
- int len;
- int type;
-
- data = qtdemux_tree_get_child_by_type (node, FOURCC_data);
- if (data) {
- len = QT_UINT32 (data->data);
- type = QT_UINT32 ((guint8 *) data->data + 8);
- if (type == 0x00000001) {
- guint y, m = 1, d = 1;
- gint ret;
-
- s = g_strndup ((char *) data->data + 16, len - 16);
- GST_DEBUG_OBJECT (qtdemux, "adding date '%s'", s);
- ret = sscanf (s, "%u-%u-%u", &y, &m, &d);
- if (ret >= 1 && y > 1500 && y < 3000) {
- GDate *date;
-
- date = g_date_new_dmy (d, m, y);
- gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_REPLACE, tag,
- date, NULL);
- g_date_free (date);
- } else {
- GST_DEBUG_OBJECT (qtdemux, "could not parse date string '%s'", s);
- }
- g_free (s);
- }
- }
-}
-
-static void
-qtdemux_tag_add_gnre (GstQTDemux * qtdemux, const char *tag, GNode * node)
-{
- static const gchar *genres[] = {
- "N/A", "Blues", "Classic Rock", "Country", "Dance", "Disco",
- "Funk", "Grunge", "Hip-Hop", "Jazz", "Metal", "New Age", "Oldies",
- "Other", "Pop", "R&B", "Rap", "Reggae", "Rock", "Techno",
- "Industrial", "Alternative", "Ska", "Death Metal", "Pranks",
- "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop", "Vocal",
- "Jazz+Funk", "Fusion", "Trance", "Classical", "Instrumental",
- "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise",
- "AlternRock", "Bass", "Soul", "Punk", "Space", "Meditative",
- "Instrumental Pop", "Instrumental Rock", "Ethnic", "Gothic",
- "Darkwave", "Techno-Industrial", "Electronic", "Pop-Folk",
- "Eurodance", "Dream", "Southern Rock", "Comedy", "Cult", "Gangsta",
- "Top 40", "Christian Rap", "Pop/Funk", "Jungle", "Native American",
- "Cabaret", "New Wave", "Psychadelic", "Rave", "Showtunes",
- "Trailer", "Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz", "Polka",
- "Retro", "Musical", "Rock & Roll", "Hard Rock", "Folk",
- "Folk/Rock", "National Folk", "Swing", "Fast-Fusion", "Bebob",
- "Latin", "Revival", "Celtic", "Bluegrass", "Avantgarde",
- "Gothic Rock", "Progressive Rock", "Psychedelic Rock",
- "Symphonic Rock", "Slow Rock", "Big Band", "Chorus",
- "Easy Listening", "Acoustic", "Humour", "Speech", "Chanson",
- "Opera", "Chamber Music", "Sonata", "Symphony", "Booty Bass",
- "Primus", "Porn Groove", "Satire", "Slow Jam", "Club", "Tango",
- "Samba", "Folklore", "Ballad", "Power Ballad", "Rhythmic Soul",
- "Freestyle", "Duet", "Punk Rock", "Drum Solo", "A capella",
- "Euro-House", "Dance Hall", "Goa", "Drum & Bass", "Club House",
- "Hardcore", "Terror", "Indie", "BritPop", "NegerPunk",
- "Polsk Punk", "Beat", "Christian Gangsta", "Heavy Metal",
- "Black Metal", "Crossover", "Contemporary C", "Christian Rock",
- "Merengue", "Salsa", "Thrash Metal", "Anime", "JPop", "SynthPop"
- };
- GNode *data;
- int len;
- int type;
- int n;
-
- data = qtdemux_tree_get_child_by_type (node, FOURCC_data);
- if (data) {
- len = QT_UINT32 (data->data);
- type = QT_UINT32 ((guint8 *) data->data + 8);
- if (type == 0x00000000 && len >= 18) {
- n = QT_UINT16 ((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,
- tag, genres[n], NULL);
- }
- }
- }
-}
-
-static void
-qtdemux_parse_udta (GstQTDemux * qtdemux, GNode * udta)
-{
- GNode *meta;
- GNode *ilst;
- GNode *node;
-
- meta = qtdemux_tree_get_child_by_type (udta, FOURCC_meta);
- if (meta == NULL) {
- GST_LOG_OBJECT (qtdemux, "no meta");
- return;
- }
-
- ilst = qtdemux_tree_get_child_by_type (meta, FOURCC_ilst);
- if (ilst == NULL) {
- GST_LOG_OBJECT (qtdemux, "no ilst");
- return;
- }
-
- GST_DEBUG_OBJECT (qtdemux, "new tag list");
- qtdemux->tag_list = gst_tag_list_new ();
-
- node = qtdemux_tree_get_child_by_type (ilst, FOURCC__nam);
- if (node) {
- qtdemux_tag_add_str (qtdemux, GST_TAG_TITLE, node);
- }
-
- node = qtdemux_tree_get_child_by_type (ilst, FOURCC__ART);
- if (node) {
- qtdemux_tag_add_str (qtdemux, GST_TAG_ARTIST, node);
- } else {
- node = qtdemux_tree_get_child_by_type (ilst, FOURCC__wrt);
- if (node) {
- qtdemux_tag_add_str (qtdemux, GST_TAG_ARTIST, node);
- } else {
- node = qtdemux_tree_get_child_by_type (ilst, FOURCC__grp);
- if (node) {
- qtdemux_tag_add_str (qtdemux, GST_TAG_ARTIST, node);
- }
- }
- }
-
- node = qtdemux_tree_get_child_by_type (ilst, FOURCC__alb);
- if (node) {
- qtdemux_tag_add_str (qtdemux, GST_TAG_ALBUM, node);
- }
-
- node = qtdemux_tree_get_child_by_type (ilst, FOURCC__day);
- if (node) {
- qtdemux_tag_add_date (qtdemux, GST_TAG_DATE, node);
- }
-
- node = qtdemux_tree_get_child_by_type (ilst, FOURCC__too);
- if (node) {
- qtdemux_tag_add_str (qtdemux, GST_TAG_COMMENT, node);
- }
-
- node = qtdemux_tree_get_child_by_type (ilst, FOURCC_trkn);
- if (node) {
- qtdemux_tag_add_num (qtdemux, GST_TAG_TRACK_NUMBER,
- GST_TAG_TRACK_COUNT, node);
- }
-
- node = qtdemux_tree_get_child_by_type (ilst, FOURCC_disc);
- if (node) {
- qtdemux_tag_add_num (qtdemux, GST_TAG_ALBUM_VOLUME_NUMBER,
- GST_TAG_ALBUM_VOLUME_COUNT, node);
- } else {
- node = qtdemux_tree_get_child_by_type (ilst, FOURCC_disk);
- if (node) {
- qtdemux_tag_add_num (qtdemux, GST_TAG_ALBUM_VOLUME_NUMBER,
- GST_TAG_ALBUM_VOLUME_COUNT, node);
- }
- }
-
- node = qtdemux_tree_get_child_by_type (ilst, FOURCC_gnre);
- if (node) {
- qtdemux_tag_add_gnre (qtdemux, GST_TAG_GENRE, node);
- } else {
- node = qtdemux_tree_get_child_by_type (ilst, FOURCC__gen);
- if (node) {
- qtdemux_tag_add_str (qtdemux, GST_TAG_GENRE, node);
- }
- }
-}
-
-typedef struct
-{
- GstStructure *structure; /* helper for sort function */
- gchar *location;
- guint min_req_bitrate;
- guint min_req_qt_version;
-} GstQtReference;
-
-static gint
-qtdemux_redirects_sort_func (gconstpointer a, gconstpointer b)
-{
- GstQtReference *ref_a = (GstQtReference *) a;
- GstQtReference *ref_b = (GstQtReference *) b;
-
- if (ref_b->min_req_qt_version != ref_a->min_req_qt_version)
- return ref_b->min_req_qt_version - ref_a->min_req_qt_version;
-
- /* known bitrates go before unknown; higher bitrates go first */
- return ref_b->min_req_bitrate - ref_a->min_req_bitrate;
-}
-
-/* sort the redirects and post a message for the application.
- */
-static void
-qtdemux_process_redirects (GstQTDemux * qtdemux, GList * references)
-{
- GstQtReference *best;
- GstStructure *s;
- GstMessage *msg;
- GValue list_val = { 0, };
- GList *l;
-
- g_assert (references != NULL);
-
- references = g_list_sort (references, qtdemux_redirects_sort_func);
-
- best = (GstQtReference *) references->data;
-
- g_value_init (&list_val, GST_TYPE_LIST);
-
- for (l = references; l != NULL; l = l->next) {
- GstQtReference *ref = (GstQtReference *) l->data;
- GValue struct_val = { 0, };
-
- ref->structure = gst_structure_new ("redirect",
- "new-location", G_TYPE_STRING, ref->location, NULL);
-
- if (ref->min_req_bitrate > 0) {
- gst_structure_set (ref->structure, "minimum-bitrate", G_TYPE_INT,
- ref->min_req_bitrate, NULL);
- }
-
- g_value_init (&struct_val, GST_TYPE_STRUCTURE);
- g_value_set_boxed (&struct_val, ref->structure);
- gst_value_list_append_value (&list_val, &struct_val);
- g_value_unset (&struct_val);
- /* don't free anything here yet, since we need best->structure below */
- }
-
- g_assert (best != NULL);
- s = gst_structure_copy (best->structure);
-
- if (g_list_length (references) > 1) {
- gst_structure_set_value (s, "locations", &list_val);
- }
-
- g_value_unset (&list_val);
-
- for (l = references; l != NULL; l = l->next) {
- GstQtReference *ref = (GstQtReference *) l->data;
-
- gst_structure_free (ref->structure);
- g_free (ref->location);
- g_free (ref);
- }
- g_list_free (references);
-
- GST_INFO_OBJECT (qtdemux, "posting redirect message: %" GST_PTR_FORMAT, s);
- msg = gst_message_new_element (GST_OBJECT_CAST (qtdemux), s);
- gst_element_post_message (GST_ELEMENT_CAST (qtdemux), msg);
-}
-
-/* look for redirect nodes, collect all redirect information and
- * process it.
- */
-static gboolean
-qtdemux_parse_redirects (GstQTDemux * qtdemux)
-{
- GNode *rmra, *rmda, *rdrf;
-
- rmra = qtdemux_tree_get_child_by_type (qtdemux->moov_node, FOURCC_rmra);
- if (rmra) {
- GList *redirects = NULL;
-
- rmda = qtdemux_tree_get_child_by_type (rmra, FOURCC_rmda);
- while (rmda) {
- GstQtReference ref = { NULL, NULL, 0, 0 };
- GNode *rmdr, *rmvc;
-
- if ((rmdr = qtdemux_tree_get_child_by_type (rmda, FOURCC_rmdr))) {
- ref.min_req_bitrate = QT_UINT32 ((guint8 *) rmdr->data + 12);
- GST_LOG_OBJECT (qtdemux, "data rate atom, required bitrate = %u",
- ref.min_req_bitrate);
- }
-
- if ((rmvc = qtdemux_tree_get_child_by_type (rmda, FOURCC_rmvc))) {
- guint32 package = QT_FOURCC ((guint8 *) rmvc->data + 12);
- guint version = QT_UINT32 ((guint8 *) rmvc->data + 16);
-
-#ifndef GST_DISABLE_GST_DEBUG
- guint bitmask = QT_UINT32 ((guint8 *) rmvc->data + 20);
-#endif
- guint check_type = QT_UINT16 ((guint8 *) rmvc->data + 24);
-
- GST_LOG_OBJECT (qtdemux,
- "version check atom [%" GST_FOURCC_FORMAT "], version=0x%08x"
- ", mask=%08x, check_type=%u", GST_FOURCC_ARGS (package), version,
- bitmask, check_type);
- if (package == FOURCC_qtim && check_type == 0) {
- ref.min_req_qt_version = version;
- }
- }
-
- rdrf = qtdemux_tree_get_child_by_type (rmda, FOURCC_rdrf);
- if (rdrf) {
- guint32 ref_type;
- guint8 *ref_data;
-
- ref_type = QT_FOURCC ((guint8 *) rdrf->data + 12);
- ref_data = (guint8 *) rdrf->data + 20;
- if (ref_type == FOURCC_alis) {
- guint record_len, record_version, fn_len;
-
- /* MacOSX alias record, google for alias-layout.txt */
- record_len = QT_UINT16 (ref_data + 4);
- record_version = QT_UINT16 (ref_data + 4 + 2);
- fn_len = QT_UINT8 (ref_data + 50);
- if (record_len > 50 && record_version == 2 && fn_len > 0) {
- ref.location = g_strndup ((gchar *) ref_data + 51, fn_len);
- }
- } else if (ref_type == FOURCC_url_) {
- ref.location = g_strdup ((gchar *) ref_data);
- } else {
- GST_DEBUG_OBJECT (qtdemux,
- "unknown rdrf reference type %" GST_FOURCC_FORMAT,
- GST_FOURCC_ARGS (ref_type));
- }
- if (ref.location != NULL) {
- GST_INFO_OBJECT (qtdemux, "New location: %s", ref.location);
- redirects = g_list_prepend (redirects, g_memdup (&ref, sizeof (ref)));
- } else {
- GST_WARNING_OBJECT (qtdemux,
- "Failed to extract redirect location from rdrf atom");
- }
- }
-
- /* look for others */
- rmda = qtdemux_tree_get_sibling_by_type (rmda, FOURCC_rmda);
- }
-
- if (redirects != NULL) {
- qtdemux_process_redirects (qtdemux, redirects);
- }
- }
- return TRUE;
-}
-
-/* we have read th complete moov node now.
- * This function parses all of the relevant info, creates the traks and
- * prepares all data structures for playback
- */
-static gboolean
-qtdemux_parse_tree (GstQTDemux * qtdemux)
-{
- GNode *mvhd;
- GNode *trak;
- GNode *udta;
- gint64 duration;
-
- mvhd = qtdemux_tree_get_child_by_type (qtdemux->moov_node, FOURCC_mvhd);
- if (mvhd == NULL) {
- GST_LOG_OBJECT (qtdemux, "No mvhd node found, looking for redirects.");
- return qtdemux_parse_redirects (qtdemux);
- }
-
- qtdemux->timescale = QT_UINT32 ((guint8 *) mvhd->data + 20);
- qtdemux->duration = QT_UINT32 ((guint8 *) mvhd->data + 24);
-
- GST_INFO_OBJECT (qtdemux, "timescale: %u", qtdemux->timescale);
- GST_INFO_OBJECT (qtdemux, "duration: %u", qtdemux->duration);
-
- /* set duration in the segment info */
- gst_qtdemux_get_duration (qtdemux, &duration);
- gst_segment_set_duration (&qtdemux->segment, GST_FORMAT_TIME, duration);
-
- /* parse all traks */
- trak = qtdemux_tree_get_child_by_type (qtdemux->moov_node, FOURCC_trak);
- while (trak) {
- qtdemux_parse_trak (qtdemux, trak);
- /* iterate all siblings */
- trak = qtdemux_tree_get_sibling_by_type (trak, FOURCC_trak);
- }
- gst_element_no_more_pads (GST_ELEMENT_CAST (qtdemux));
-
- /* find and push tags, we do this after adding the pads so we can push the
- * tags downstream as well. */
- udta = qtdemux_tree_get_child_by_type (qtdemux->moov_node, FOURCC_udta);
- if (udta) {
- qtdemux_parse_udta (qtdemux, udta);
-
- if (qtdemux->tag_list) {
- GST_DEBUG_OBJECT (qtdemux,
- "calling gst_element_found_tags with %" GST_PTR_FORMAT,
- qtdemux->tag_list);
- gst_element_found_tags (GST_ELEMENT_CAST (qtdemux), qtdemux->tag_list);
- qtdemux->tag_list = NULL;
- }
- } else {
- GST_LOG_OBJECT (qtdemux, "No udta node found.");
- }
- return TRUE;
-}
-
-/* taken from ffmpeg */
-static unsigned int
-get_size (guint8 * ptr, guint8 ** end)
-{
- int count = 4;
- int len = 0;
-
- while (count--) {
- int c = *ptr;
-
- ptr++;
- len = (len << 7) | (c & 0x7f);
- if (!(c & 0x80))
- break;
- }
- if (end)
- *end = ptr;
- return len;
-}
-
-/* this can change the codec originally present in @list */
-static void
-gst_qtdemux_handle_esds (GstQTDemux * qtdemux, QtDemuxStream * stream,
- GNode * esds, GstTagList * list)
-{
- int len = QT_UINT32 (esds->data);
- guint8 *ptr = esds->data;
- guint8 *end = ptr + len;
- int tag;
- guint8 *data_ptr = NULL;
- int data_len = 0;
- guint8 object_type_id = 0;
-
- qtdemux_dump_mem (ptr, len);
- ptr += 8;
- GST_DEBUG_OBJECT (qtdemux, "version/flags = %08x", QT_UINT32 (ptr));
- ptr += 4;
- while (ptr < end) {
- tag = QT_UINT8 (ptr);
- GST_DEBUG_OBJECT (qtdemux, "tag = %02x", tag);
- ptr++;
- len = get_size (ptr, &ptr);
- GST_DEBUG_OBJECT (qtdemux, "len = %d", len);
-
- switch (tag) {
- case 0x03:
- GST_DEBUG_OBJECT (qtdemux, "ID %04x", QT_UINT16 (ptr));
- GST_DEBUG_OBJECT (qtdemux, "priority %04x", QT_UINT8 (ptr + 2));
- ptr += 3;
- break;
- case 0x04:
- object_type_id = QT_UINT8 (ptr);
- GST_DEBUG_OBJECT (qtdemux, "object_type_id %02x", object_type_id);
- GST_DEBUG_OBJECT (qtdemux, "stream_type %02x", QT_UINT8 (ptr + 1));
- GST_DEBUG_OBJECT (qtdemux, "buffer_size_db %02x", QT_UINT24 (ptr + 2));
- GST_DEBUG_OBJECT (qtdemux, "max bitrate %d", QT_UINT32 (ptr + 5));
- GST_DEBUG_OBJECT (qtdemux, "avg bitrate %d", QT_UINT32 (ptr + 9));
- ptr += 13;
- break;
- case 0x05:
- GST_DEBUG_OBJECT (qtdemux, "data:");
- qtdemux_dump_mem (ptr, len);
- data_ptr = ptr;
- data_len = len;
- ptr += len;
- break;
- case 0x06:
- GST_DEBUG_OBJECT (qtdemux, "data %02x", QT_UINT8 (ptr));
- ptr += 1;
- break;
- default:
- GST_ERROR_OBJECT (qtdemux, "parse error");
- }
- }
-
- if (data_ptr) {
- GstBuffer *buffer;
-
- buffer = gst_buffer_new_and_alloc (data_len);
- memcpy (GST_BUFFER_DATA (buffer), data_ptr, data_len);
- qtdemux_dump_mem (GST_BUFFER_DATA (buffer), data_len);
-
- GST_DEBUG_OBJECT (qtdemux, "setting codec_data from esds");
-
- gst_caps_set_simple (stream->caps, "codec_data", GST_TYPE_BUFFER,
- buffer, NULL);
- gst_buffer_unref (buffer);
- }
- /* object_type_id in the stsd atom in mp4a tells us about AAC or plain
- * MPEG audio and other formats */
- switch (object_type_id) {
- case 107:
- /* change to mpeg1 layer 3 audio */
- gst_caps_set_simple (stream->caps, "layer", G_TYPE_INT, 3,
- "mpegversion", G_TYPE_INT, 1, NULL);
- if (list)
- gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
- GST_TAG_AUDIO_CODEC, "MPEG-1 layer 3", NULL);
- break;
- case 0xE1:
- {
- GstStructure *structure;
-
- /* QCELP, the codec_data is a riff tag (little endian) with
- * more info (http://ftp.3gpp2.org/TSGC/Working/2003/2003-05-SanDiego/TSG-C-2003-05-San%20Diego/WG1/SWG12/C12-20030512-006%20=%20C12-20030217-015_Draft_Baseline%20Text%20of%20FFMS_R2.doc). */
- structure = gst_caps_get_structure (stream->caps, 0);
- gst_structure_set_name (structure, "audio/qcelp");
- gst_structure_remove_fields (structure, "mpegversion", "framed", NULL);
-
- if (list)
- gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
- GST_TAG_AUDIO_CODEC, "QCELP", NULL);
- break;
- }
- default:
- break;
- }
-}
-
-#define _codec(name) \
- do { \
- if (codec_name) { \
- *codec_name = name; \
- } \
- } while (0)
-
-static GstCaps *
-qtdemux_video_caps (GstQTDemux * qtdemux, guint32 fourcc,
- const guint8 * stsd_data, const gchar ** codec_name)
-{
- switch (fourcc) {
- case GST_MAKE_FOURCC ('p', 'n', 'g', ' '):
- _codec ("PNG still images");
- return gst_caps_from_string ("image/png");
- case GST_MAKE_FOURCC ('j', 'p', 'e', 'g'):
- _codec ("JPEG still images");
- return gst_caps_from_string ("image/jpeg");
- case GST_MAKE_FOURCC ('m', 'j', 'p', 'a'):
- case GST_MAKE_FOURCC ('A', 'V', 'D', 'J'):
- _codec ("Motion-JPEG");
- return gst_caps_from_string ("image/jpeg");
- case GST_MAKE_FOURCC ('m', 'j', 'p', 'b'):
- _codec ("Motion-JPEG format B");
- return gst_caps_from_string ("video/x-mjpeg-b");
- case GST_MAKE_FOURCC ('S', 'V', 'Q', '3'):
- _codec ("Sorensen video v.3");
- return gst_caps_from_string ("video/x-svq, " "svqversion = (int) 3");
- case GST_MAKE_FOURCC ('s', 'v', 'q', 'i'):
- case GST_MAKE_FOURCC ('S', 'V', 'Q', '1'):
- _codec ("Sorensen video v.1");
- return gst_caps_from_string ("video/x-svq, " "svqversion = (int) 1");
- case GST_MAKE_FOURCC ('r', 'a', 'w', ' '):
- {
- guint16 bps;
- GstCaps *caps;
-
- _codec ("Raw RGB video");
- bps = QT_UINT16 (stsd_data + 98);
- /* set common stuff */
- caps = gst_caps_new_simple ("video/x-raw-rgb",
- "endianness", G_TYPE_INT, G_BYTE_ORDER, "depth", G_TYPE_INT, bps,
- NULL);
-
- switch (bps) {
- case 15:
- gst_caps_set_simple (caps,
- "bpp", G_TYPE_INT, 16,
- "endianness", G_TYPE_INT, G_BIG_ENDIAN,
- "red_mask", G_TYPE_INT, 0x7c00,
- "green_mask", G_TYPE_INT, 0x03e0,
- "blue_mask", G_TYPE_INT, 0x001f, NULL);
- break;
- case 16:
- gst_caps_set_simple (caps,
- "bpp", G_TYPE_INT, 16,
- "endianness", G_TYPE_INT, G_BIG_ENDIAN,
- "red_mask", G_TYPE_INT, 0xf800,
- "green_mask", G_TYPE_INT, 0x07e0,
- "blue_mask", G_TYPE_INT, 0x001f, NULL);
- break;
- case 24:
- gst_caps_set_simple (caps,
- "bpp", G_TYPE_INT, 24,
- "endianness", G_TYPE_INT, G_BIG_ENDIAN,
- "red_mask", G_TYPE_INT, 0xff0000,
- "green_mask", G_TYPE_INT, 0x00ff00,
- "blue_mask", G_TYPE_INT, 0x0000ff, NULL);
- break;
- case 32:
- gst_caps_set_simple (caps,
- "bpp", G_TYPE_INT, 32,
- "endianness", G_TYPE_INT, G_BIG_ENDIAN,
- "alpha_mask", G_TYPE_INT, 0xff000000,
- "red_mask", G_TYPE_INT, 0x00ff0000,
- "green_mask", G_TYPE_INT, 0x0000ff00,
- "blue_mask", G_TYPE_INT, 0x000000ff, NULL);
- break;
- default:
- /* unknown */
- break;
- }
- return caps;
- }
- case GST_MAKE_FOURCC ('y', 'v', '1', '2'):
- _codec ("Raw planar YUV 4:2:0");
- return gst_caps_from_string ("video/x-raw-yuv, "
- "format = (fourcc) I420");
- case GST_MAKE_FOURCC ('y', 'u', 'v', '2'):
- case GST_MAKE_FOURCC ('Y', 'u', 'v', '2'):
- _codec ("Raw packed YUV 4:2:2");
- return gst_caps_from_string ("video/x-raw-yuv, "
- "format = (fourcc) YUY2");
- case GST_MAKE_FOURCC ('m', 'p', 'e', 'g'):
- _codec ("MPEG-1 video");
- return gst_caps_from_string ("video/mpeg, "
- "systemstream = (boolean) false, " "mpegversion = (int) 1");
- case GST_MAKE_FOURCC ('g', 'i', 'f', ' '):
- _codec ("GIF still images");
- return gst_caps_from_string ("image/gif");
- case GST_MAKE_FOURCC ('h', '2', '6', '3'):
- case GST_MAKE_FOURCC ('H', '2', '6', '3'):
- case GST_MAKE_FOURCC ('s', '2', '6', '3'):
- case GST_MAKE_FOURCC ('U', '2', '6', '3'):
- _codec ("H.263");
- /* ffmpeg uses the height/width props, don't know why */
- return gst_caps_from_string ("video/x-h263");
- case GST_MAKE_FOURCC ('m', 'p', '4', 'v'):
- _codec ("MPEG-4 video");
- return gst_caps_from_string ("video/mpeg, "
- "mpegversion = (int) 4, " "systemstream = (boolean) false");
- case GST_MAKE_FOURCC ('3', 'i', 'v', 'd'):
- case GST_MAKE_FOURCC ('3', 'I', 'V', 'D'):
- _codec ("Microsoft MPEG-4 4.3"); /* FIXME? */
- return gst_caps_from_string ("video/x-msmpeg, msmpegversion = (int) 43");
- case GST_MAKE_FOURCC ('3', 'I', 'V', '1'):
- case GST_MAKE_FOURCC ('3', 'I', 'V', '2'):
- _codec ("3ivX video");
- return gst_caps_from_string ("video/x-3ivx");
- case GST_MAKE_FOURCC ('D', 'I', 'V', '3'):
- _codec ("DivX 3");
- return gst_caps_from_string ("video/x-divx," "divxversion= (int) 3");
- case GST_MAKE_FOURCC ('D', 'I', 'V', 'X'):
- _codec ("DivX 4");
- return gst_caps_from_string ("video/x-divx," "divxversion= (int) 4");
-
- case GST_MAKE_FOURCC ('D', 'X', '5', '0'):
- _codec ("DivX 5");
- return gst_caps_from_string ("video/x-divx," "divxversion= (int) 5");
- case GST_MAKE_FOURCC ('c', 'v', 'i', 'd'):
- _codec ("Cinepak");
- return gst_caps_from_string ("video/x-cinepak");
- case GST_MAKE_FOURCC ('q', 'd', 'r', 'w'):
- _codec ("Apple QuickDraw");
- return gst_caps_from_string ("video/x-qdrw");
- case GST_MAKE_FOURCC ('r', 'p', 'z', 'a'):
- _codec ("Apple video");
- return gst_caps_from_string ("video/x-apple-video");
- case GST_MAKE_FOURCC ('a', 'v', 'c', '1'):
- _codec ("H.264 / AVC");
- return gst_caps_from_string ("video/x-h264");
- case GST_MAKE_FOURCC ('r', 'l', 'e', ' '):
- _codec ("Run-length encoding");
- return gst_caps_from_string ("video/x-rle, layout=(string)quicktime");
- case GST_MAKE_FOURCC ('i', 'v', '3', '2'):
- _codec ("Indeo Video 3");
- return gst_caps_from_string ("video/x-indeo, indeoversion=(int)3");
- case GST_MAKE_FOURCC ('I', 'V', '4', '1'):
- case GST_MAKE_FOURCC ('i', 'v', '4', '1'):
- _codec ("Intel Video 4");
- return gst_caps_from_string ("video/x-indeo, indeoversion=(int)4");
- case GST_MAKE_FOURCC ('d', 'v', 'c', 'p'):
- case GST_MAKE_FOURCC ('d', 'v', 'c', ' '):
- case GST_MAKE_FOURCC ('d', 'v', 's', 'd'):
- case GST_MAKE_FOURCC ('D', 'V', 'S', 'D'):
- case GST_MAKE_FOURCC ('d', 'v', 'c', 's'):
- case GST_MAKE_FOURCC ('D', 'V', 'C', 'S'):
- case GST_MAKE_FOURCC ('d', 'v', '2', '5'):
- case GST_MAKE_FOURCC ('d', 'v', 'p', 'p'):
- _codec ("DV Video");
- return gst_caps_from_string ("video/x-dv, systemstream=(boolean)false");
- case GST_MAKE_FOURCC ('s', 'm', 'c', ' '):
- _codec ("Apple Graphics (SMC)");
- return gst_caps_from_string ("video/x-smc");
- case GST_MAKE_FOURCC ('V', 'P', '3', '1'):
- _codec ("VP3");
- return gst_caps_from_string ("video/x-vp3");
- case GST_MAKE_FOURCC ('k', 'p', 'c', 'd'):
- default:
- {
- char *s;
-
- s = g_strdup_printf ("video/x-gst-fourcc-%" GST_FOURCC_FORMAT,
- GST_FOURCC_ARGS (fourcc));
- return gst_caps_new_simple (s, NULL);
- }
- }
-}
-
-static GstCaps *
-qtdemux_audio_caps (GstQTDemux * qtdemux, QtDemuxStream * stream,
- guint32 fourcc, const guint8 * data, int len, const gchar ** codec_name)
-{
- switch (fourcc) {
- case GST_MAKE_FOURCC ('N', 'O', 'N', 'E'):
- case GST_MAKE_FOURCC ('r', 'a', 'w', ' '):
- _codec ("Raw 8-bit PCM audio");
- /* FIXME */
- return gst_caps_from_string ("audio/x-raw-int, "
- "width = (int) 8, " "depth = (int) 8, " "signed = (boolean) false");
- case GST_MAKE_FOURCC ('t', 'w', 'o', 's'):
- if (stream->bytes_per_frame == 1) {
- _codec ("Raw 8-bit PCM audio");
- return gst_caps_from_string ("audio/x-raw-int, "
- "width = (int) 8, " "depth = (int) 8, " "signed = (boolean) true");
- } else {
- _codec ("Raw 16-bit PCM audio");
- /* FIXME */
- return gst_caps_from_string ("audio/x-raw-int, "
- "width = (int) 16, "
- "depth = (int) 16, "
- "endianness = (int) BIG_ENDIAN, " "signed = (boolean) true");
- }
- case GST_MAKE_FOURCC ('s', 'o', 'w', 't'):
- if (stream->bytes_per_frame == 1) {
- _codec ("Raw 8-bit PCM audio");
- return gst_caps_from_string ("audio/x-raw-int, "
- "width = (int) 8, " "depth = (int) 8, " "signed = (boolean) true");
- } else {
- _codec ("Raw 16-bit PCM audio");
- /* FIXME */
- return gst_caps_from_string ("audio/x-raw-int, "
- "width = (int) 16, "
- "depth = (int) 16, "
- "endianness = (int) LITTLE_ENDIAN, " "signed = (boolean) true");
- }
- case GST_MAKE_FOURCC ('f', 'l', '6', '4'):
- _codec ("Raw 64-bit floating-point audio");
- return gst_caps_from_string ("audio/x-raw-float, "
- "width = (int) 64, " "endianness = (int) BIG_ENDIAN");
- case GST_MAKE_FOURCC ('f', 'l', '3', '2'):
- _codec ("Raw 32-bit floating-point audio");
- return gst_caps_from_string ("audio/x-raw-float, "
- "width = (int) 32, " "endianness = (int) BIG_ENDIAN");
- case GST_MAKE_FOURCC ('i', 'n', '2', '4'):
- _codec ("Raw 24-bit PCM audio");
- /* FIXME */
- return gst_caps_from_string ("audio/x-raw-int, "
- "width = (int) 24, "
- "depth = (int) 24, "
- "endianness = (int) BIG_ENDIAN, " "signed = (boolean) true");
- case GST_MAKE_FOURCC ('i', 'n', '3', '2'):
- _codec ("Raw 32-bit PCM audio");
- /* FIXME */
- return gst_caps_from_string ("audio/x-raw-int, "
- "width = (int) 32, "
- "depth = (int) 32, "
- "endianness = (int) BIG_ENDIAN, " "signed = (boolean) true");
- case GST_MAKE_FOURCC ('u', 'l', 'a', 'w'):
- _codec ("Mu-law audio");
- /* FIXME */
- return gst_caps_from_string ("audio/x-mulaw");
- case GST_MAKE_FOURCC ('a', 'l', 'a', 'w'):
- _codec ("A-law audio");
- /* FIXME */
- return gst_caps_from_string ("audio/x-alaw");
- case 0x6d730002:
- _codec ("Microsoft ADPCM");
- /* Microsoft ADPCM-ACM code 2 */
- return gst_caps_from_string ("audio/x-adpcm, "
- "layout = (string) microsoft");
- case 0x6d730011:
- case 0x6d730017:
- _codec ("DVI/Intel IMA ADPCM");
- /* FIXME DVI/Intel IMA ADPCM/ACM code 17 */
- return gst_caps_from_string ("audio/x-adpcm, "
- "layout = (string) quicktime");
- case 0x6d730055:
- /* MPEG layer 3, CBR only (pre QT4.1) */
- case 0x5500736d:
- case GST_MAKE_FOURCC ('.', 'm', 'p', '3'):
- _codec ("MPEG-1 layer 3");
- /* MPEG layer 3, CBR & VBR (QT4.1 and later) */
- return gst_caps_from_string ("audio/mpeg, "
- "layer = (int) 3, " "mpegversion = (int) 1");
- case GST_MAKE_FOURCC ('M', 'A', 'C', '3'):
- _codec ("MACE-3");
- return gst_caps_from_string ("audio/x-mace, " "maceversion = (int) 3");
- case GST_MAKE_FOURCC ('M', 'A', 'C', '6'):
- _codec ("MACE-6");
- return gst_caps_from_string ("audio/x-mace, " "maceversion = (int) 6");
- case GST_MAKE_FOURCC ('O', 'g', 'g', 'V'):
- /* ogg/vorbis */
- return gst_caps_from_string ("application/ogg");
- case GST_MAKE_FOURCC ('d', 'v', 'c', 'a'):
- _codec ("DV audio");
- return gst_caps_from_string ("audio/x-dv");
- case GST_MAKE_FOURCC ('m', 'p', '4', 'a'):
- _codec ("MPEG-4 AAC audio");
- return gst_caps_new_simple ("audio/mpeg",
- "mpegversion", G_TYPE_INT, 4, "framed", G_TYPE_BOOLEAN, TRUE, NULL);
- case GST_MAKE_FOURCC ('Q', 'D', 'M', '2'):
- _codec ("QDesign Music v.2");
- /* FIXME: QDesign music version 2 (no constant) */
- if (data) {
- return gst_caps_new_simple ("audio/x-qdm2",
- "framesize", G_TYPE_INT, QT_UINT32 (data + 52),
- "bitrate", G_TYPE_INT, QT_UINT32 (data + 40),
- "blocksize", G_TYPE_INT, QT_UINT32 (data + 44), NULL);
- } else {
- return gst_caps_new_simple ("audio/x-qdm2", NULL);
- }
- case GST_MAKE_FOURCC ('a', 'g', 's', 'm'):
- _codec ("GSM audio");
- return gst_caps_new_simple ("audio/x-gsm", NULL);
- case GST_MAKE_FOURCC ('s', 'a', 'm', 'r'):
- _codec ("AMR audio");
- return gst_caps_new_simple ("audio/AMR", NULL);
- case GST_MAKE_FOURCC ('s', 'a', 'w', 'b'):
- _codec ("AMR-WB audio");
- return gst_caps_new_simple ("audio/AMR-WB", NULL);
- case GST_MAKE_FOURCC ('i', 'm', 'a', '4'):
- _codec ("Quicktime IMA ADPCM");
- return gst_caps_new_simple ("audio/x-adpcm",
- "layout", G_TYPE_STRING, "quicktime", NULL);
- case GST_MAKE_FOURCC ('a', 'l', 'a', 'c'):
- _codec ("Apple lossless audio");
- return gst_caps_new_simple ("audio/x-alac", NULL);
- case GST_MAKE_FOURCC ('q', 't', 'v', 'r'):
- /* ? */
- case GST_MAKE_FOURCC ('Q', 'D', 'M', 'C'):
- /* QDesign music */
- case GST_MAKE_FOURCC ('Q', 'c', 'l', 'p'):
- /* QUALCOMM PureVoice */
- default:
- {
- char *s;
-
- s = g_strdup_printf ("audio/x-gst-fourcc-%" GST_FOURCC_FORMAT,
- GST_FOURCC_ARGS (fourcc));
- return gst_caps_new_simple (s, NULL);
- }
- }
-}
projects / platform / upstream / gstreamer.git / commitdiff