1 /* GStreamer

     2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>

     3  * Copyright (C) <2003> David A. Schleef <ds@schleef.org>

     4  * Copyright (C) <2006> Wim Taymans <wim@fluendo.com>

     5  * Copyright (C) <2007> Julien Moutte <julien@fluendo.com>

     6  *

     7  * This library is free software; you can redistribute it and/or

     8  * modify it under the terms of the GNU Library General Public

     9  * License as published by the Free Software Foundation; either

    10  * version 2 of the License, or (at your option) any later version.

    11  *

    12  * This library is distributed in the hope that it will be useful,

    13  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    15  * Library General Public License for more details.

    16  *

    17  * You should have received a copy of the GNU Library General Public

    18  * License along with this library; if not, write to the

    19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

    20  * Boston, MA 02111-1307, USA.

    21  */

    22 

    23 /**

    24  * SECTION:element-qtdemux

    25  *

    26  * Demuxes a .mov file into raw or compressed audio and/or video streams.

    27  *

    28  * This element supports both push and pull-based scheduling, depending on the

    29  * capabilities of the upstream elements.

    30  *

    31  * <refsect2>

    32  * <title>Example launch line</title>

    33  * |[

    34  * gst-launch filesrc location=test.mov ! qtdemux name=demux  demux.audio_00 ! decodebin ! audioconvert ! audioresample ! autoaudiosink   demux.video_00 ! queue ! decodebin ! ffmpegcolorspace ! videoscale ! autovideosink

    35  * ]| Play (parse and decode) a .mov file and try to output it to

    36  * an automatically detected soundcard and videosink. If the MOV file contains

    37  * compressed audio or video data, this will only work if you have the

    38  * right decoder elements/plugins installed.

    39  * </refsect2>

    40  *

    41  * Last reviewed on 2006-12-29 (0.10.5)

    42  */

    43 

    44 #ifdef HAVE_CONFIG_H

    45 #include "config.h"

    46 #endif

    47 

    48 #include "gst/gst-i18n-plugin.h"

    49 

    50 #include <gst/tag/tag.h>

    51 

    52 #include "qtdemux_types.h"

    53 #include "qtdemux_dump.h"

    54 #include "qtdemux_fourcc.h"

    55 #include "qtdemux.h"

    56 #include "qtpalette.h"

    57 

    58 #include <stdlib.h>

    59 #include <string.h>

    60 

    61 #ifdef HAVE_ZLIB

    62 # include <zlib.h>

    63 #endif

    64 

    65 /* max. size considered 'sane' for non-mdat atoms */

    66 #define QTDEMUX_MAX_ATOM_SIZE (25*1024*1024)

    67 

    68 GST_DEBUG_CATEGORY (qtdemux_debug);

    69 

    70 /*typedef struct _QtNode QtNode; */

    71 typedef struct _QtDemuxSegment QtDemuxSegment;

    72 typedef struct _QtDemuxSample QtDemuxSample;

    73 

    74 /*struct _QtNode

    75 {

    76   guint32 type;

    77   guint8 *data;

    78   gint len;

    79 };*/

    80 

    81 struct _QtDemuxSample

    82 {

    83   guint32 size;

    84   guint64 offset;

    85   GstClockTimeDiff pts_offset;  /* Add this value to timestamp to get the pts */

    86   guint64 timestamp;            /* In GstClockTime */

    87   guint64 duration;             /* in GstClockTime */

    88   gboolean keyframe;            /* TRUE when this packet is a keyframe */

    89 };

    90 

    91 /*

    92  * Quicktime has tracks and segments. A track is a continuous piece of

    93  * multimedia content. The track is not always played from start to finish but

    94  * instead, pieces of the track are 'cut out' and played in sequence. This is

    95  * what the segments do.

    96  *

    97  * Inside the track we have keyframes (K) and delta frames. The track has its

    98  * own timing, which starts from 0 and extends to end. The position in the track

    99  * is called the media_time.

   100  *

   101  * The segments now describe the pieces that should be played from this track

   102  * and are basically tupples of media_time/duration/rate entries. We can have

   103  * multiple segments and they are all played after one another. An example:

   104  *

   105  * segment 1: media_time: 1 second, duration: 1 second, rate 1

   106  * segment 2: media_time: 3 second, duration: 2 second, rate 2

   107  *

   108  * To correctly play back this track, one must play: 1 second of media starting

   109  * from media_time 1 followed by 2 seconds of media starting from media_time 3

   110  * at a rate of 2.

   111  *

   112  * Each of the segments will be played at a specific time, the first segment at

   113  * time 0, the second one after the duration of the first one, etc.. Note that

   114  * the time in resulting playback is not identical to the media_time of the

   115  * track anymore.

   116  *

   117  * Visually, assuming the track has 4 second of media_time:

   118  *

   119  *                (a)                   (b)          (c)              (d)

   120  *         .-----------------------------------------------------------.

   121  * track:  | K.....K.........K........K.......K.......K...........K... |

   122  *         '-----------------------------------------------------------'

   123  *         0              1              2              3              4    

   124  *           .------------^              ^   .----------^              ^

   125  *          /              .-------------'  /       .------------------'

   126  *         /              /          .-----'       /

   127  *         .--------------.         .--------------.

   128  *         | segment 1    |         | segment 2    |

   129  *         '--------------'         '--------------'

   130  *       

   131  * The challenge here is to cut out the right pieces of the track for each of

   132  * the playback segments. This fortunatly can easily be done with the SEGMENT

   133  * events of gstreamer.

   134  *

   135  * For playback of segment 1, we need to provide the decoder with the keyframe

   136  * (a), in the above figure, but we must instruct it only to output the decoded

   137  * data between second 1 and 2. We do this with a SEGMENT event for 1 to 2, time

   138  * position set to the time of the segment: 0.

   139  *

   140  * We then proceed to push data from keyframe (a) to frame (b). The decoder

   141  * decodes but clips all before media_time 1.

   142  * 

   143  * After finishing a segment, we push out a new SEGMENT event with the clipping

   144  * boundaries of the new data.

   145  *

   146  * This is a good usecase for the GStreamer accumulated SEGMENT events.

   147  */

   148 

   149 struct _QtDemuxSegment

   150 {

   151   /* global time and duration, all gst time */

   152   guint64 time;

   153   guint64 stop_time;

   154   guint64 duration;

   155   /* media time of trak, all gst time */

   156   guint64 media_start;

   157   guint64 media_stop;

   158   gdouble rate;

   159 };

   160 

   161 struct _QtDemuxStream

   162 {

   163   GstPad *pad;

   164 

   165   /* stream type */

   166   guint32 subtype;

   167   GstCaps *caps;

   168   guint32 fourcc;

   169 

   170   /* duration/scale */

   171   guint64 duration;             /* in timescale */

   172   guint32 timescale;

   173 

   174   /* our samples */

   175   guint32 n_samples;

   176   QtDemuxSample *samples;

   177   gboolean all_keyframe;        /* TRUE when all samples are keyframes (no stss) */

   178   guint32 min_duration;         /* duration in timescale of first sample, used for figuring out

   179                                    the framerate, in timescale units */

   180 

   181   /* if we use chunks or samples */

   182   gboolean sampled;

   183   guint padding;

   184 

   185   /* video info */

   186   gint width;

   187   gint height;

   188   /* aspect ratio */

   189   gint display_width;

   190   gint display_height;

   191   gint par_w;

   192   gint par_h;

   193   /* Numerator/denominator framerate */

   194   gint fps_n;

   195   gint fps_d;

   196   guint16 bits_per_sample;

   197   guint16 color_table_id;

   198 

   199   /* audio info */

   200   gdouble rate;

   201   gint n_channels;

   202   guint samples_per_packet;

   203   guint samples_per_frame;

   204   guint bytes_per_packet;

   205   guint bytes_per_sample;

   206   guint bytes_per_frame;

   207   guint compression;

   208 

   209   /* when a discontinuity is pending */

   210   gboolean discont;

   211 

   212   /* list of buffers to push first */

   213   GSList *buffers;

   214 

   215   /* if we need to clip this buffer. This is only needed for uncompressed

   216    * data */

   217   gboolean need_clip;

   218 

   219   /* current position */

   220   guint32 segment_index;

   221   guint32 sample_index;

   222   guint64 time_position;        /* in gst time */

   223 

   224   /* the Gst segment we are processing out, used for clipping */

   225   GstSegment segment;

   226 

   227   /* last GstFlowReturn */

   228   GstFlowReturn last_ret;

   229 

   230   /* quicktime segments */

   231   guint32 n_segments;

   232   QtDemuxSegment *segments;

   233   guint32 from_sample;

   234   guint32 to_sample;

   235 

   236   gboolean sent_eos;

   237 };

   238 

   239 enum QtDemuxState

   240 {

   241   QTDEMUX_STATE_INITIAL,        /* Initial state (haven't got the header yet) */

   242   QTDEMUX_STATE_HEADER,         /* Parsing the header */

   243   QTDEMUX_STATE_MOVIE,          /* Parsing/Playing the media data */

   244   QTDEMUX_STATE_BUFFER_MDAT     /* Buffering the mdat atom */

   245 };

   246 

   247 static GNode *qtdemux_tree_get_child_by_type (GNode * node, guint32 fourcc);

   248 static GNode *qtdemux_tree_get_sibling_by_type (GNode * node, guint32 fourcc);

   249 

   250 static const GstElementDetails gst_qtdemux_details =

   251 GST_ELEMENT_DETAILS ("QuickTime demuxer",

   252     "Codec/Demuxer",

   253     "Demultiplex a QuickTime file into audio and video streams",

   254     "David Schleef <ds@schleef.org>, Wim Taymans <wim@fluendo.com>");

   255 

   256 static GstStaticPadTemplate gst_qtdemux_sink_template =

   257     GST_STATIC_PAD_TEMPLATE ("sink",

   258     GST_PAD_SINK,

   259     GST_PAD_ALWAYS,

   260     GST_STATIC_CAPS ("video/quicktime; video/mj2; audio/x-m4a; "

   261         "application/x-3gp")

   262     );

   263 

   264 static GstStaticPadTemplate gst_qtdemux_videosrc_template =

   265 GST_STATIC_PAD_TEMPLATE ("video_%02d",

   266     GST_PAD_SRC,

   267     GST_PAD_SOMETIMES,

   268     GST_STATIC_CAPS_ANY);

   269 

   270 static GstStaticPadTemplate gst_qtdemux_audiosrc_template =

   271 GST_STATIC_PAD_TEMPLATE ("audio_%02d",

   272     GST_PAD_SRC,

   273     GST_PAD_SOMETIMES,

   274     GST_STATIC_CAPS_ANY);

   275 

   276 static GstStaticPadTemplate gst_qtdemux_subpsrc_template =

   277 GST_STATIC_PAD_TEMPLATE ("subp_%02d",

   278     GST_PAD_SRC,

   279     GST_PAD_SOMETIMES,

   280     GST_STATIC_CAPS_ANY);

   281 

   282 static GstElementClass *parent_class = NULL;

   283 

   284 static void gst_qtdemux_class_init (GstQTDemuxClass * klass);

   285 static void gst_qtdemux_base_init (GstQTDemuxClass * klass);

   286 static void gst_qtdemux_init (GstQTDemux * quicktime_demux);

   287 static void gst_qtdemux_dispose (GObject * object);

   288 

   289 static GstStateChangeReturn gst_qtdemux_change_state (GstElement * element,

   290     GstStateChange transition);

   291 static gboolean qtdemux_sink_activate (GstPad * sinkpad);

   292 static gboolean qtdemux_sink_activate_pull (GstPad * sinkpad, gboolean active);

   293 static gboolean qtdemux_sink_activate_push (GstPad * sinkpad, gboolean active);

   294 

   295 static void gst_qtdemux_loop (GstPad * pad);

   296 static GstFlowReturn gst_qtdemux_chain (GstPad * sinkpad, GstBuffer * inbuf);

   297 static gboolean gst_qtdemux_handle_sink_event (GstPad * pad, GstEvent * event);

   298 

   299 static gboolean qtdemux_parse_moov (GstQTDemux * qtdemux, const guint8 * buffer,

   300     int length);

   301 static gboolean qtdemux_parse_node (GstQTDemux * qtdemux, GNode * node,

   302     const guint8 * buffer, int length);

   303 static gboolean qtdemux_parse_tree (GstQTDemux * qtdemux);

   304 

   305 static void gst_qtdemux_handle_esds (GstQTDemux * qtdemux,

   306     QtDemuxStream * stream, GNode * esds, GstTagList * list);

   307 static GstCaps *qtdemux_video_caps (GstQTDemux * qtdemux,

   308     QtDemuxStream * stream, guint32 fourcc, const guint8 * stsd_data,

   309     gchar ** codec_name);

   310 static GstCaps *qtdemux_audio_caps (GstQTDemux * qtdemux,

   311     QtDemuxStream * stream, guint32 fourcc, const guint8 * data, int len,

   312     gchar ** codec_name);

   313 static GstCaps *qtdemux_subp_caps (GstQTDemux * qtdemux,

   314     QtDemuxStream * stream, guint32 fourcc, const guint8 * data,

   315     gchar ** codec_name);

   316 

   317 GType

   318 gst_qtdemux_get_type (void)

   319 {

   320   static GType qtdemux_type = 0;

   321 

   322   if (G_UNLIKELY (!qtdemux_type)) {

   323     static const GTypeInfo qtdemux_info = {

   324       sizeof (GstQTDemuxClass),

   325       (GBaseInitFunc) gst_qtdemux_base_init, NULL,

   326       (GClassInitFunc) gst_qtdemux_class_init,

   327       NULL, NULL, sizeof (GstQTDemux), 0,

   328       (GInstanceInitFunc) gst_qtdemux_init,

   329     };

   330 

   331     qtdemux_type =

   332         g_type_register_static (GST_TYPE_ELEMENT, "GstQTDemux", &qtdemux_info,

   333         0);

   334   }

   335   return qtdemux_type;

   336 }

   337 

   338 static void

   339 gst_qtdemux_base_init (GstQTDemuxClass * klass)

   340 {

   341   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);

   342 

   343   gst_element_class_add_pad_template (element_class,

   344       gst_static_pad_template_get (&gst_qtdemux_sink_template));

   345   gst_element_class_add_pad_template (element_class,

   346       gst_static_pad_template_get (&gst_qtdemux_videosrc_template));

   347   gst_element_class_add_pad_template (element_class,

   348       gst_static_pad_template_get (&gst_qtdemux_audiosrc_template));

   349   gst_element_class_set_details (element_class, &gst_qtdemux_details);

   350 

   351   GST_DEBUG_CATEGORY_INIT (qtdemux_debug, "qtdemux", 0, "qtdemux plugin");

   352 }

   353 

   354 static void

   355 gst_qtdemux_class_init (GstQTDemuxClass * klass)

   356 {

   357   GObjectClass *gobject_class;

   358   GstElementClass *gstelement_class;

   359 

   360   gobject_class = (GObjectClass *) klass;

   361   gstelement_class = (GstElementClass *) klass;

   362 

   363   parent_class = g_type_class_peek_parent (klass);

   364 

   365   gobject_class->dispose = gst_qtdemux_dispose;

   366 

   367   gstelement_class->change_state = gst_qtdemux_change_state;

   368 }

   369 

   370 static void

   371 gst_qtdemux_init (GstQTDemux * qtdemux)

   372 {

   373   qtdemux->sinkpad =

   374       gst_pad_new_from_static_template (&gst_qtdemux_sink_template, "sink");

   375   gst_pad_set_activate_function (qtdemux->sinkpad, qtdemux_sink_activate);

   376   gst_pad_set_activatepull_function (qtdemux->sinkpad,

   377       qtdemux_sink_activate_pull);

   378   gst_pad_set_activatepush_function (qtdemux->sinkpad,

   379       qtdemux_sink_activate_push);

   380   gst_pad_set_chain_function (qtdemux->sinkpad, gst_qtdemux_chain);

   381   gst_pad_set_event_function (qtdemux->sinkpad, gst_qtdemux_handle_sink_event);

   382   gst_element_add_pad (GST_ELEMENT_CAST (qtdemux), qtdemux->sinkpad);

   383 

   384   qtdemux->state = QTDEMUX_STATE_INITIAL;

   385   /* FIXME, use segment last_stop for this */

   386   qtdemux->last_ts = GST_CLOCK_TIME_NONE;

   387   qtdemux->pullbased = FALSE;

   388   qtdemux->neededbytes = 16;

   389   qtdemux->todrop = 0;

   390   qtdemux->adapter = gst_adapter_new ();

   391   qtdemux->offset = 0;

   392   qtdemux->mdatoffset = GST_CLOCK_TIME_NONE;

   393   qtdemux->mdatbuffer = NULL;

   394   gst_segment_init (&qtdemux->segment, GST_FORMAT_TIME);

   395 }

   396 

   397 static void

   398 gst_qtdemux_dispose (GObject * object)

   399 {

   400   GstQTDemux *qtdemux = GST_QTDEMUX (object);

   401 

   402   if (qtdemux->adapter) {

   403     g_object_unref (G_OBJECT (qtdemux->adapter));

   404     qtdemux->adapter = NULL;

   405   }

   406 

   407   G_OBJECT_CLASS (parent_class)->dispose (object);

   408 }

   409 

   410 static GstFlowReturn

   411 gst_qtdemux_pull_atom (GstQTDemux * qtdemux, guint64 offset, guint64 size,

   412     GstBuffer ** buf)

   413 {

   414   GstFlowReturn flow;

   415 

   416   /* Sanity check: catch bogus sizes (fuzzed/broken files) */

   417   if (G_UNLIKELY (size > QTDEMUX_MAX_ATOM_SIZE)) {

   418     GST_ELEMENT_ERROR (qtdemux, STREAM, DECODE,

   419         (_("This file is invalid and cannot be played.")),

   420         ("atom has bogus size %" G_GUINT64_FORMAT, size));

   421     return GST_FLOW_ERROR;

   422   }

   423 

   424   flow = gst_pad_pull_range (qtdemux->sinkpad, offset, size, buf);

   425 

   426   if (G_UNLIKELY (flow != GST_FLOW_OK))

   427     return flow;

   428 

   429   /* Catch short reads - we don't want any partial atoms */

   430   if (G_UNLIKELY (GST_BUFFER_SIZE (*buf) < size)) {

   431     GST_WARNING_OBJECT (qtdemux, "short read: %u < %" G_GUINT64_FORMAT,

   432         GST_BUFFER_SIZE (*buf), size);

   433     gst_buffer_unref (*buf);

   434     *buf = NULL;

   435     return GST_FLOW_UNEXPECTED;

   436   }

   437 

   438   return flow;

   439 }

   440 

   441 #if 0

   442 static gboolean

   443 gst_qtdemux_src_convert (GstPad * pad, GstFormat src_format, gint64 src_value,

   444     GstFormat * dest_format, gint64 * dest_value)

   445 {

   446   gboolean res = TRUE;

   447   QtDemuxStream *stream = gst_pad_get_element_private (pad);

   448 

   449   if (stream->subtype == GST_MAKE_FOURCC ('v', 'i', 'd', 'e') &&

   450       (src_format == GST_FORMAT_BYTES || *dest_format == GST_FORMAT_BYTES))

   451     return FALSE;

   452 

   453   switch (src_format) {

   454     case GST_FORMAT_TIME:

   455       switch (*dest_format) {

   456         case GST_FORMAT_BYTES:

   457           *dest_value = src_value * 1;  /* FIXME */

   458           break;

   459         case GST_FORMAT_DEFAULT:

   460           *dest_value = src_value * 1;  /* FIXME */

   461           break;

   462         default:

   463           res = FALSE;

   464           break;

   465       }

   466       break;

   467     case GST_FORMAT_BYTES:

   468       switch (*dest_format) {

   469         case GST_FORMAT_TIME:

   470           *dest_value = src_value * 1;  /* FIXME */

   471           break;

   472         default:

   473           res = FALSE;

   474           break;

   475       }

   476       break;

   477     case GST_FORMAT_DEFAULT:

   478       switch (*dest_format) {

   479         case GST_FORMAT_TIME:

   480           *dest_value = src_value * 1;  /* FIXME */

   481           break;

   482         default:

   483           res = FALSE;

   484           break;

   485       }

   486       break;

   487     default:

   488       res = FALSE;

   489   }

   490 

   491   return res;

   492 }

   493 #endif

   494 

   495 static const GstQueryType *

   496 gst_qtdemux_get_src_query_types (GstPad * pad)

   497 {

   498   static const GstQueryType src_types[] = {

   499     GST_QUERY_POSITION,

   500     GST_QUERY_DURATION,

   501     GST_QUERY_SEEKING,

   502     0

   503   };

   504 

   505   return src_types;

   506 }

   507 

   508 static gboolean

   509 gst_qtdemux_get_duration (GstQTDemux * qtdemux, gint64 * duration)

   510 {

   511   gboolean res = TRUE;

   512 

   513   *duration = GST_CLOCK_TIME_NONE;

   514 

   515   if (qtdemux->duration != 0) {

   516     if (qtdemux->duration != G_MAXINT32 && qtdemux->timescale != 0) {

   517       *duration = gst_util_uint64_scale (qtdemux->duration,

   518           GST_SECOND, qtdemux->timescale);

   519     }

   520   }

   521   return res;

   522 }

   523 

   524 static gboolean

   525 gst_qtdemux_handle_src_query (GstPad * pad, GstQuery * query)

   526 {

   527   gboolean res = FALSE;

   528   GstQTDemux *qtdemux = GST_QTDEMUX (gst_pad_get_parent (pad));

   529 

   530   GST_LOG_OBJECT (pad, "%s query", GST_QUERY_TYPE_NAME (query));

   531 

   532   switch (GST_QUERY_TYPE (query)) {

   533     case GST_QUERY_POSITION:

   534       if (GST_CLOCK_TIME_IS_VALID (qtdemux->segment.last_stop)) {

   535         gst_query_set_position (query, GST_FORMAT_TIME,

   536             qtdemux->segment.last_stop);

   537         res = TRUE;

   538       }

   539       break;

   540     case GST_QUERY_DURATION:{

   541       GstFormat fmt;

   542 

   543       gst_query_parse_duration (query, &fmt, NULL);

   544       if (fmt == GST_FORMAT_TIME) {

   545         gint64 duration = -1;

   546 

   547         gst_qtdemux_get_duration (qtdemux, &duration);

   548         if (duration > 0) {

   549           gst_query_set_duration (query, GST_FORMAT_TIME, duration);

   550           res = TRUE;

   551         }

   552       }

   553       break;

   554     }

   555     case GST_QUERY_SEEKING:{

   556       GstFormat fmt;

   557       gboolean seekable;

   558 

   559       gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL);

   560       if (fmt == GST_FORMAT_TIME) {

   561         gint64 duration = -1;

   562 

   563         gst_qtdemux_get_duration (qtdemux, &duration);

   564         seekable = TRUE;

   565         if (!qtdemux->pullbased) {

   566           GstQuery *q;

   567 

   568           /* we might be able with help from upstream */

   569           seekable = FALSE;

   570           q = gst_query_new_seeking (GST_FORMAT_BYTES);

   571           if (gst_pad_peer_query (qtdemux->sinkpad, q)) {

   572             gst_query_parse_seeking (q, &fmt, &seekable, NULL, NULL);

   573             GST_LOG_OBJECT (qtdemux, "upstream BYTE seekable %d", seekable);

   574           }

   575           gst_query_unref (q);

   576         }

   577         gst_query_set_seeking (query, GST_FORMAT_TIME, seekable, 0, duration);

   578         res = TRUE;

   579       }

   580       break;

   581     }

   582     default:

   583       res = gst_pad_query_default (pad, query);

   584       break;

   585   }

   586 

   587   gst_object_unref (qtdemux);

   588 

   589   return res;

   590 }

   591 

   592 /* push event on all source pads; takes ownership of the event */

   593 static void

   594 gst_qtdemux_push_event (GstQTDemux * qtdemux, GstEvent * event)

   595 {

   596   guint n;

   597 

   598   GST_DEBUG_OBJECT (qtdemux, "pushing %s event on all source pads",

   599       GST_EVENT_TYPE_NAME (event));

   600 

   601   for (n = 0; n < qtdemux->n_streams; n++) {

   602     GstPad *pad;

   603 

   604     if ((pad = qtdemux->streams[n]->pad))

   605       gst_pad_push_event (pad, gst_event_ref (event));

   606   }

   607   gst_event_unref (event);

   608 }

   609 

   610 /* push a pending newsegment event, if any from the streaming thread */

   611 static void

   612 gst_qtdemux_push_pending_newsegment (GstQTDemux * qtdemux)

   613 {

   614   if (qtdemux->pending_newsegment) {

   615     gst_qtdemux_push_event (qtdemux, qtdemux->pending_newsegment);

   616     qtdemux->pending_newsegment = NULL;

   617   }

   618 }

   619 

   620 typedef struct

   621 {

   622   guint64 media_time;

   623 } FindData;

   624 

   625 static gint

   626 find_func (QtDemuxSample * s1, guint64 * media_time, gpointer user_data)

   627 {

   628   if (s1->timestamp > *media_time)

   629     return 1;

   630 

   631   return -1;

   632 }

   633 

   634 /* find the index of the sample that includes the data for @media_time

   635  *

   636  * Returns the index of the sample.

   637  */

   638 static guint32

   639 gst_qtdemux_find_index (GstQTDemux * qtdemux, QtDemuxStream * str,

   640     guint64 media_time)

   641 {

   642   QtDemuxSample *result;

   643   guint32 index;

   644 

   645   result = gst_util_array_binary_search (str->samples, str->n_samples,

   646       sizeof (QtDemuxSample), (GCompareDataFunc) find_func,

   647       GST_SEARCH_MODE_BEFORE, &media_time, NULL);

   648 

   649   if (G_LIKELY (result))

   650     index = result - str->samples;

   651   else

   652     index = 0;

   653 

   654   return index;

   655 }

   656 

   657 /* find the index of the keyframe needed to decode the sample at @index

   658  * of stream @str.

   659  *

   660  * Returns the index of the keyframe.

   661  */

   662 static guint32

   663 gst_qtdemux_find_keyframe (GstQTDemux * qtdemux, QtDemuxStream * str,

   664     guint32 index)

   665 {

   666   guint32 new_index = index;

   667 

   668   if (index >= str->n_samples) {

   669     new_index = str->n_samples;

   670     goto beach;

   671   }

   672 

   673   /* all keyframes, return index */

   674   if (str->all_keyframe) {

   675     new_index = index;

   676     goto beach;

   677   }

   678 

   679   /* else go back until we have a keyframe */

   680   while (TRUE) {

   681     if (str->samples[new_index].keyframe)

   682       break;

   683 

   684     if (new_index == 0)

   685       break;

   686 

   687     new_index--;

   688   }

   689 

   690 beach:

   691   GST_DEBUG_OBJECT (qtdemux, "searching for keyframe index before index %u "

   692       "gave %u", index, new_index);

   693 

   694   return new_index;

   695 }

   696 

   697 /* find the segment for @time_position for @stream

   698  *

   699  * Returns -1 if the segment cannot be found.

   700  */

   701 static guint32

   702 gst_qtdemux_find_segment (GstQTDemux * qtdemux, QtDemuxStream * stream,

   703     guint64 time_position)

   704 {

   705   gint i;

   706   guint32 seg_idx;

   707 

   708   GST_LOG_OBJECT (qtdemux, "finding segment for %" GST_TIME_FORMAT,

   709       GST_TIME_ARGS (time_position));

   710 

   711   /* find segment corresponding to time_position if we are looking

   712    * for a segment. */

   713   seg_idx = -1;

   714   for (i = 0; i < stream->n_segments; i++) {

   715     QtDemuxSegment *segment = &stream->segments[i];

   716 

   717     GST_LOG_OBJECT (qtdemux,

   718         "looking at segment %" GST_TIME_FORMAT "-%" GST_TIME_FORMAT,

   719         GST_TIME_ARGS (segment->time), GST_TIME_ARGS (segment->stop_time));

   720 

   721     /* For the last segment we include stop_time in the last segment */

   722     if (i < stream->n_segments - 1) {

   723       if (segment->time <= time_position && time_position < segment->stop_time) {

   724         GST_LOG_OBJECT (qtdemux, "segment %d matches", i);

   725         seg_idx = i;

   726         break;

   727       }

   728     } else {

   729       if (segment->time <= time_position && time_position <= segment->stop_time) {

   730         GST_LOG_OBJECT (qtdemux, "segment %d matches", i);

   731         seg_idx = i;

   732         break;

   733       }

   734     }

   735   }

   736   return seg_idx;

   737 }

   738 

   739 /* move the stream @str to the sample position @index.

   740  *

   741  * Updates @str->sample_index and marks discontinuity if needed.

   742  */

   743 static void

   744 gst_qtdemux_move_stream (GstQTDemux * qtdemux, QtDemuxStream * str,

   745     guint32 index)

   746 {

   747   /* no change needed */

   748   if (index == str->sample_index)

   749     return;

   750 

   751   GST_DEBUG_OBJECT (qtdemux, "moving to sample %u of %u", index,

   752       str->n_samples);

   753 

   754   /* position changed, we have a discont */

   755   str->sample_index = index;

   756   /* Each time we move in the stream we store the position where we are 

   757    * starting from */

   758   str->from_sample = index;

   759   str->discont = TRUE;

   760 }

   761 

   762 static void

   763 gst_qtdemux_adjust_seek (GstQTDemux * qtdemux, gint64 desired_time,

   764     gint64 * key_time, gint64 * key_offset)

   765 {

   766   guint64 min_offset;

   767   gint64 min_byte_offset = -1;

   768   gint n;

   769 

   770   min_offset = desired_time;

   771 

   772   /* for each stream, find the index of the sample in the segment

   773    * and move back to the previous keyframe. */

   774   for (n = 0; n < qtdemux->n_streams; n++) {

   775     QtDemuxStream *str;

   776     guint32 index, kindex;

   777     guint32 seg_idx;

   778     guint64 media_start;

   779     guint64 media_time;

   780     guint64 seg_time;

   781     QtDemuxSegment *seg;

   782 

   783     str = qtdemux->streams[n];

   784 

   785     seg_idx = gst_qtdemux_find_segment (qtdemux, str, desired_time);

   786     GST_DEBUG_OBJECT (qtdemux, "align segment %d", seg_idx);

   787 

   788     /* segment not found, continue with normal flow */

   789     if (seg_idx == -1)

   790       continue;

   791 

   792     /* get segment and time in the segment */

   793     seg = &str->segments[seg_idx];

   794     seg_time = desired_time - seg->time;

   795 

   796     /* get the media time in the segment */

   797     media_start = seg->media_start + seg_time;

   798 

   799     /* get the index of the sample with media time */

   800     index = gst_qtdemux_find_index (qtdemux, str, media_start);

   801     GST_DEBUG_OBJECT (qtdemux, "sample for %" GST_TIME_FORMAT " at %u",

   802         GST_TIME_ARGS (media_start), index);

   803 

   804     /* find previous keyframe */

   805     kindex = gst_qtdemux_find_keyframe (qtdemux, str, index);

   806 

   807     /* if the keyframe is at a different position, we need to update the

   808      * requested seek time */

   809     if (index != kindex) {

   810       index = kindex;

   811 

   812       /* get timestamp of keyframe */

   813       media_time = str->samples[kindex].timestamp;

   814       GST_DEBUG_OBJECT (qtdemux, "keyframe at %u with time %" GST_TIME_FORMAT,

   815           kindex, GST_TIME_ARGS (media_time));

   816 

   817       /* keyframes in the segment get a chance to change the

   818        * desired_offset. keyframes out of the segment are

   819        * ignored. */

   820       if (media_time >= seg->media_start) {

   821         guint64 seg_time;

   822 

   823         /* this keyframe is inside the segment, convert back to

   824          * segment time */

   825         seg_time = (media_time - seg->media_start) + seg->time;

   826         if (seg_time < min_offset)

   827           min_offset = seg_time;

   828       }

   829     }

   830 

   831     if (min_byte_offset < 0 || str->samples[index].offset < min_byte_offset)

   832       min_byte_offset = str->samples[index].offset;

   833   }

   834 

   835   if (key_time)

   836     *key_time = min_offset;

   837   if (key_offset)

   838     *key_offset = min_byte_offset;

   839 }

   840 

   841 static gboolean

   842 gst_qtdemux_convert_seek (GstPad * pad, GstFormat * format,

   843     GstSeekType cur_type, gint64 * cur, GstSeekType stop_type, gint64 * stop)

   844 {

   845   gboolean res;

   846   GstFormat fmt;

   847 

   848   g_return_val_if_fail (format != NULL, FALSE);

   849   g_return_val_if_fail (cur != NULL, FALSE);

   850   g_return_val_if_fail (stop != NULL, FALSE);

   851 

   852   if (*format == GST_FORMAT_TIME)

   853     return TRUE;

   854 

   855   fmt = GST_FORMAT_TIME;

   856   res = TRUE;

   857   if (cur_type != GST_SEEK_TYPE_NONE)

   858     res = gst_pad_query_convert (pad, *format, *cur, &fmt, cur);

   859   if (res && stop_type != GST_SEEK_TYPE_NONE)

   860     res = gst_pad_query_convert (pad, *format, *stop, &fmt, stop);

   861 

   862   if (res)

   863     *format = GST_FORMAT_TIME;

   864 

   865   return res;

   866 }

   867 

   868 /* perform seek in push based mode:

   869    find BYTE position to move to based on time and delegate to upstream

   870 */

   871 static gboolean

   872 gst_qtdemux_do_push_seek (GstQTDemux * qtdemux, GstPad * pad, GstEvent * event)

   873 {

   874   gdouble rate;

   875   GstFormat format;

   876   GstSeekFlags flags;

   877   GstSeekType cur_type, stop_type;

   878   gint64 cur, stop;

   879   gboolean res;

   880   gint64 byte_cur;

   881 

   882   GST_DEBUG_OBJECT (qtdemux, "doing push-based seek");

   883 

   884   gst_event_parse_seek (event, &rate, &format, &flags,

   885       &cur_type, &cur, &stop_type, &stop);

   886 

   887   if (stop_type != GST_SEEK_TYPE_NONE)

   888     goto unsupported_seek;

   889   stop = -1;

   890 

   891   /* only forward streaming and seeking is possible */

   892   if (rate <= 0)

   893     goto unsupported_seek;

   894 

   895   /* convert to TIME if needed and possible */

   896   if (!gst_qtdemux_convert_seek (pad, &format, cur_type, &cur,

   897           stop_type, &stop))

   898     goto no_format;

   899 

   900   /* find reasonable corresponding BYTE position,

   901    * also try to mind about keyframes, since we can not go back a bit for them

   902    * later on */

   903   gst_qtdemux_adjust_seek (qtdemux, cur, NULL, &byte_cur);

   904 

   905   if (byte_cur == -1)

   906     goto abort_seek;

   907 

   908   GST_DEBUG_OBJECT (qtdemux, "Pushing BYTE seek rate %g, "

   909       "start %" G_GINT64_FORMAT ", stop %" G_GINT64_FORMAT, rate, byte_cur,

   910       stop);

   911   /* BYTE seek event */

   912   event = gst_event_new_seek (rate, GST_FORMAT_BYTES, flags, cur_type, byte_cur,

   913       stop_type, stop);

   914   res = gst_pad_push_event (qtdemux->sinkpad, event);

   915 

   916   return res;

   917 

   918   /* ERRORS */

   919 abort_seek:

   920   {

   921     GST_DEBUG_OBJECT (qtdemux, "could not determine byte position to seek to, "

   922         "seek aborted.");

   923     return FALSE;

   924   }

   925 unsupported_seek:

   926   {

   927     GST_DEBUG_OBJECT (qtdemux, "unsupported seek, seek aborted.");

   928     return FALSE;

   929   }

   930 no_format:

   931   {

   932     GST_DEBUG_OBJECT (qtdemux, "unsupported format given, seek aborted.");

   933     return FALSE;

   934   }

   935 }

   936 

   937 /* perform the seek.

   938  *

   939  * We set all segment_indexes in the streams to unknown and

   940  * adjust the time_position to the desired position. this is enough

   941  * to trigger a segment switch in the streaming thread to start

   942  * streaming from the desired position.

   943  *

   944  * Keyframe seeking is a little more complicated when dealing with

   945  * segments. Ideally we want to move to the previous keyframe in

   946  * the segment but there might not be a keyframe in the segment. In

   947  * fact, none of the segments could contain a keyframe. We take a

   948  * practical approach: seek to the previous keyframe in the segment,

   949  * if there is none, seek to the beginning of the segment.

   950  *

   951  * Called with STREAM_LOCK

   952  */

   953 static gboolean

   954 gst_qtdemux_perform_seek (GstQTDemux * qtdemux, GstSegment * segment)

   955 {

   956   gint64 desired_offset;

   957   gint n;

   958 

   959   desired_offset = segment->last_stop;

   960 

   961   GST_DEBUG_OBJECT (qtdemux, "seeking to %" GST_TIME_FORMAT,

   962       GST_TIME_ARGS (desired_offset));

   963 

   964   if (segment->flags & GST_SEEK_FLAG_KEY_UNIT) {

   965     gint64 min_offset;

   966 

   967     gst_qtdemux_adjust_seek (qtdemux, desired_offset, &min_offset, NULL);

   968     GST_DEBUG_OBJECT (qtdemux, "keyframe seek, align to %"

   969         GST_TIME_FORMAT, GST_TIME_ARGS (min_offset));

   970     desired_offset = min_offset;

   971   }

   972 

   973   /* and set all streams to the final position */

   974   for (n = 0; n < qtdemux->n_streams; n++) {

   975     QtDemuxStream *stream = qtdemux->streams[n];

   976 

   977     stream->time_position = desired_offset;

   978     stream->sample_index = -1;

   979     stream->segment_index = -1;

   980     stream->last_ret = GST_FLOW_OK;

   981     stream->sent_eos = FALSE;

   982   }

   983   segment->last_stop = desired_offset;

   984   segment->time = desired_offset;

   985 

   986   /* we stop at the end */

   987   if (segment->stop == -1)

   988     segment->stop = segment->duration;

   989 

   990   return TRUE;

   991 }

   992 

   993 /* do a seek in pull based mode */

   994 static gboolean

   995 gst_qtdemux_do_seek (GstQTDemux * qtdemux, GstPad * pad, GstEvent * event)

   996 {

   997   gdouble rate;

   998   GstFormat format;

   999   GstSeekFlags flags;

  1000   GstSeekType cur_type, stop_type;

  1001   gint64 cur, stop;

  1002   gboolean flush;

  1003   gboolean update;

  1004   GstSegment seeksegment;

  1005   int i;

  1006 

  1007   if (event) {

  1008     GST_DEBUG_OBJECT (qtdemux, "doing seek with event");

  1009 

  1010     gst_event_parse_seek (event, &rate, &format, &flags,

  1011         &cur_type, &cur, &stop_type, &stop);

  1012 

  1013     /* we have to have a format as the segment format. Try to convert

  1014      * if not. */

  1015     if (!gst_qtdemux_convert_seek (pad, &format, cur_type, &cur,

  1016             stop_type, &stop))

  1017       goto no_format;

  1018 

  1019     GST_DEBUG_OBJECT (qtdemux, "seek format %s", gst_format_get_name (format));

  1020   } else {

  1021     GST_DEBUG_OBJECT (qtdemux, "doing seek without event");

  1022     flags = 0;

  1023   }

  1024 

  1025   flush = flags & GST_SEEK_FLAG_FLUSH;

  1026 

  1027   /* stop streaming, either by flushing or by pausing the task */

  1028   if (flush) {

  1029     /* unlock upstream pull_range */

  1030     gst_pad_push_event (qtdemux->sinkpad, gst_event_new_flush_start ());

  1031     /* make sure out loop function exits */

  1032     gst_qtdemux_push_event (qtdemux, gst_event_new_flush_start ());

  1033   } else {

  1034     /* non flushing seek, pause the task */

  1035     gst_pad_pause_task (qtdemux->sinkpad);

  1036   }

  1037 

  1038   /* wait for streaming to finish */

  1039   GST_PAD_STREAM_LOCK (qtdemux->sinkpad);

  1040 

  1041   /* copy segment, we need this because we still need the old

  1042    * segment when we close the current segment. */

  1043   memcpy (&seeksegment, &qtdemux->segment, sizeof (GstSegment));

  1044 

  1045   if (event) {

  1046     /* configure the segment with the seek variables */

  1047     GST_DEBUG_OBJECT (qtdemux, "configuring seek");

  1048     gst_segment_set_seek (&seeksegment, rate, format, flags,

  1049         cur_type, cur, stop_type, stop, &update);

  1050   }

  1051 

  1052   /* now do the seek, this actually never returns FALSE */

  1053   gst_qtdemux_perform_seek (qtdemux, &seeksegment);

  1054 

  1055   /* prepare for streaming again */

  1056   if (flush) {

  1057     gst_pad_push_event (qtdemux->sinkpad, gst_event_new_flush_stop ());

  1058     gst_qtdemux_push_event (qtdemux, gst_event_new_flush_stop ());

  1059   } else if (qtdemux->segment_running) {

  1060     /* we are running the current segment and doing a non-flushing seek,

  1061      * close the segment first based on the last_stop. */

  1062     GST_DEBUG_OBJECT (qtdemux, "closing running segment %" G_GINT64_FORMAT

  1063         " to %" G_GINT64_FORMAT, qtdemux->segment.start,

  1064         qtdemux->segment.last_stop);

  1065 

  1066     if (qtdemux->segment.rate >= 0) {

  1067       /* FIXME, rate is the product of the global rate and the (quicktime)

  1068        * segment rate. */

  1069       qtdemux->pending_newsegment = gst_event_new_new_segment (TRUE,

  1070           qtdemux->segment.rate, qtdemux->segment.format,

  1071           qtdemux->segment.start, qtdemux->segment.last_stop,

  1072           qtdemux->segment.time);

  1073     } else {                    /* For Reverse Playback */

  1074       guint64 stop;

  1075 

  1076       if ((stop = qtdemux->segment.stop) == -1)

  1077         stop = qtdemux->segment.duration;

  1078       /* for reverse playback, we played from stop to last_stop. */

  1079       qtdemux->pending_newsegment = gst_event_new_new_segment (TRUE,

  1080           qtdemux->segment.rate, qtdemux->segment.format,

  1081           qtdemux->segment.last_stop, stop, qtdemux->segment.last_stop);

  1082     }

  1083   }

  1084 

  1085   /* commit the new segment */

  1086   memcpy (&qtdemux->segment, &seeksegment, sizeof (GstSegment));

  1087 

  1088   if (qtdemux->segment.flags & GST_SEEK_FLAG_SEGMENT) {

  1089     gst_element_post_message (GST_ELEMENT_CAST (qtdemux),

  1090         gst_message_new_segment_start (GST_OBJECT_CAST (qtdemux),

  1091             qtdemux->segment.format, qtdemux->segment.last_stop));

  1092   }

  1093 

  1094   /* restart streaming, NEWSEGMENT will be sent from the streaming

  1095    * thread. */

  1096   qtdemux->segment_running = TRUE;

  1097   for (i = 0; i < qtdemux->n_streams; i++)

  1098     qtdemux->streams[i]->last_ret = GST_FLOW_OK;

  1099 

  1100   gst_pad_start_task (qtdemux->sinkpad, (GstTaskFunction) gst_qtdemux_loop,

  1101       qtdemux->sinkpad);

  1102 

  1103   GST_PAD_STREAM_UNLOCK (qtdemux->sinkpad);

  1104 

  1105   return TRUE;

  1106 

  1107   /* ERRORS */

  1108 no_format:

  1109   {

  1110     GST_DEBUG_OBJECT (qtdemux, "unsupported format given, seek aborted.");

  1111     return FALSE;

  1112   }

  1113 }

  1114 

  1115 static gboolean

  1116 gst_qtdemux_handle_src_event (GstPad * pad, GstEvent * event)

  1117 {

  1118   gboolean res = TRUE;

  1119   GstQTDemux *qtdemux = GST_QTDEMUX (gst_pad_get_parent (pad));

  1120 

  1121   switch (GST_EVENT_TYPE (event)) {

  1122     case GST_EVENT_SEEK:

  1123       if (qtdemux->pullbased) {

  1124         res = gst_qtdemux_do_seek (qtdemux, pad, event);

  1125       } else if (qtdemux->state == QTDEMUX_STATE_MOVIE && qtdemux->n_streams) {

  1126         res = gst_qtdemux_do_push_seek (qtdemux, pad, event);

  1127       } else {

  1128         GST_DEBUG_OBJECT (qtdemux,

  1129             "ignoring seek in push mode in current state");

  1130         res = FALSE;

  1131       }

  1132       gst_event_unref (event);

  1133       break;

  1134     case GST_EVENT_QOS: