subprojects/gst-libav/ext/libav/gstavdemux.c

   1 /* GStreamer
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>,
   3  *               <2006> Edward Hervey <bilboed@bilboed.com>
   4  *               <2006> Wim Taymans <wim@fluendo.com>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25
  26 #include <string.h>
  27
  28 #include <libavformat/avformat.h>
  29 #include <libavutil/imgutils.h>
  30 /* #include <ffmpeg/avi.h> */
  31 #include <gst/gst.h>
  32 #include <gst/base/gstflowcombiner.h>
  33
  34 #include "gstav.h"
  35 #include "gstavcodecmap.h"
  36 #include "gstavutils.h"
  37 #include "gstavprotocol.h"
  38
  39 #define MAX_STREAMS 20
  40
  41 typedef struct _GstFFMpegDemux GstFFMpegDemux;
  42 typedef struct _GstFFStream GstFFStream;
  43
  44 struct _GstFFStream
  45 {
  46   GstPad *pad;
  47
  48   AVStream *avstream;
  49
  50   gboolean unknown;
  51   GstClockTime last_ts;
  52   gboolean discont;
  53   gboolean eos;
  54
  55   GstTagList *tags;             /* stream tags */
  56 };
  57
  58 struct _GstFFMpegDemux
  59 {
  60   GstElement element;
  61
  62   /* We need to keep track of our pads, so we do so here. */
  63   GstPad *sinkpad;
  64
  65   gboolean have_group_id;
  66   guint group_id;
  67
  68   AVFormatContext *context;
  69   gboolean opened;
  70
  71   GstFFStream *streams[MAX_STREAMS];
  72
  73   GstFlowCombiner *flowcombiner;
  74
  75   gint videopads, audiopads;
  76
  77   GstClockTime start_time;
  78   GstClockTime duration;
  79
  80   /* TRUE if working in pull-mode */
  81   gboolean seekable;
  82
  83   /* TRUE if the avformat demuxer can reliably handle streaming mode */
  84   gboolean can_push;
  85
  86   gboolean flushing;
  87
  88   /* segment stuff */
  89   GstSegment segment;
  90
  91   /* cached seek in READY */
  92   GstEvent *seek_event;
  93
  94   /* cached upstream events */
  95   GList *cached_events;
  96
  97   /* push mode data */
  98   GstFFMpegPipe ffpipe;
  99   GstTask *task;
 100   GRecMutex task_lock;
 101 };
 102
 103 typedef struct _GstFFMpegDemuxClass GstFFMpegDemuxClass;
 104
 105 struct _GstFFMpegDemuxClass
 106 {
 107   GstElementClass parent_class;
 108
 109   AVInputFormat *in_plugin;
 110   GstPadTemplate *sinktempl;
 111   GstPadTemplate *videosrctempl;
 112   GstPadTemplate *audiosrctempl;
 113 };
 114
 115 /* A number of function prototypes are given so we can refer to them later. */
 116 static void gst_ffmpegdemux_class_init (GstFFMpegDemuxClass * klass);
 117 static void gst_ffmpegdemux_base_init (GstFFMpegDemuxClass * klass);
 118 static void gst_ffmpegdemux_init (GstFFMpegDemux * demux);
 119 static void gst_ffmpegdemux_finalize (GObject * object);
 120
 121 static gboolean gst_ffmpegdemux_sink_event (GstPad * sinkpad,
 122     GstObject * parent, GstEvent * event);
 123 static GstFlowReturn gst_ffmpegdemux_chain (GstPad * sinkpad,
 124     GstObject * parent, GstBuffer * buf);
 125
 126 static void gst_ffmpegdemux_loop (GstFFMpegDemux * demux);
 127 static gboolean gst_ffmpegdemux_sink_activate (GstPad * sinkpad,
 128     GstObject * parent);
 129 static gboolean gst_ffmpegdemux_sink_activate_mode (GstPad * sinkpad,
 130     GstObject * parent, GstPadMode mode, gboolean active);
 131 static GstTagList *gst_ffmpeg_metadata_to_tag_list (AVDictionary * metadata);
 132
 133 #if 0
 134 static gboolean
 135 gst_ffmpegdemux_src_convert (GstPad * pad,
 136     GstFormat src_fmt,
 137     gint64 src_value, GstFormat * dest_fmt, gint64 * dest_value);
 138 #endif
 139 static gboolean
 140 gst_ffmpegdemux_send_event (GstElement * element, GstEvent * event);
 141 static GstStateChangeReturn
 142 gst_ffmpegdemux_change_state (GstElement * element, GstStateChange transition);
 143
 144 #define GST_FFDEMUX_PARAMS_QDATA g_quark_from_static_string("avdemux-params")
 145
 146 static GstElementClass *parent_class = NULL;
 147
 148 static const gchar *
 149 gst_ffmpegdemux_averror (gint av_errno)
 150 {
 151   const gchar *message = NULL;
 152
 153   switch (av_errno) {
 154     case AVERROR (EINVAL):
 155       message = "Unknown error";
 156       break;
 157     case AVERROR (EIO):
 158       message = "Input/output error";
 159       break;
 160     case AVERROR (EDOM):
 161       message = "Number syntax expected in filename";
 162       break;
 163     case AVERROR (ENOMEM):
 164       message = "Not enough memory";
 165       break;
 166     case AVERROR (EILSEQ):
 167       message = "Unknown format";
 168       break;
 169     case AVERROR (ENOSYS):
 170       message = "Operation not supported";
 171       break;
 172     default:
 173       message = "Unhandled error code received";
 174       break;
 175   }
 176
 177   return message;
 178 }
 179
 180 static void
 181 gst_ffmpegdemux_base_init (GstFFMpegDemuxClass * klass)
 182 {
 183   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
 184   AVInputFormat *in_plugin;
 185   GstCaps *sinkcaps;
 186   GstPadTemplate *sinktempl, *audiosrctempl, *videosrctempl;
 187   gchar *longname, *description, *name;
 188
 189   in_plugin = (AVInputFormat *)
 190       g_type_get_qdata (G_OBJECT_CLASS_TYPE (klass), GST_FFDEMUX_PARAMS_QDATA);
 191   g_assert (in_plugin != NULL);
 192
 193   name = g_strdup (in_plugin->name);
 194   g_strdelimit (name, ".,|-<> ", '_');
 195
 196   /* construct the element details struct */
 197   longname = g_strdup_printf ("libav %s demuxer", in_plugin->long_name);
 198   description = g_strdup_printf ("libav %s demuxer", in_plugin->long_name);
 199   gst_element_class_set_metadata (element_class, longname,
 200       "Codec/Demuxer", description,
 201       "Wim Taymans <wim@fluendo.com>, "
 202       "Ronald Bultje <rbultje@ronald.bitfreak.net>, "
 203       "Edward Hervey <bilboed@bilboed.com>");
 204   g_free (longname);
 205   g_free (description);
 206
 207   /* pad templates */
 208   sinkcaps = gst_ffmpeg_formatid_to_caps (name);
 209   sinktempl = gst_pad_template_new ("sink",
 210       GST_PAD_SINK, GST_PAD_ALWAYS, sinkcaps);
 211   g_free (name);
 212   videosrctempl = gst_pad_template_new ("video_%u",
 213       GST_PAD_SRC, GST_PAD_SOMETIMES, GST_CAPS_ANY);
 214   audiosrctempl = gst_pad_template_new ("audio_%u",
 215       GST_PAD_SRC, GST_PAD_SOMETIMES, GST_CAPS_ANY);
 216
 217   gst_element_class_add_pad_template (element_class, videosrctempl);
 218   gst_element_class_add_pad_template (element_class, audiosrctempl);
 219   gst_element_class_add_pad_template (element_class, sinktempl);
 220
 221   gst_caps_unref (sinkcaps);
 222
 223   klass->in_plugin = in_plugin;
 224   klass->videosrctempl = videosrctempl;
 225   klass->audiosrctempl = audiosrctempl;
 226   klass->sinktempl = sinktempl;
 227 }
 228
 229 static void
 230 gst_ffmpegdemux_class_init (GstFFMpegDemuxClass * klass)
 231 {
 232   GObjectClass *gobject_class;
 233   GstElementClass *gstelement_class;
 234
 235   gobject_class = (GObjectClass *) klass;
 236   gstelement_class = (GstElementClass *) klass;
 237
 238   parent_class = g_type_class_peek_parent (klass);
 239
 240   gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_ffmpegdemux_finalize);
 241
 242   gstelement_class->change_state = gst_ffmpegdemux_change_state;
 243   gstelement_class->send_event = gst_ffmpegdemux_send_event;
 244 }
 245
 246 static void
 247 gst_ffmpegdemux_init (GstFFMpegDemux * demux)
 248 {
 249   GstFFMpegDemuxClass *oclass =
 250       (GstFFMpegDemuxClass *) (G_OBJECT_GET_CLASS (demux));
 251   gint n;
 252
 253   demux->sinkpad = gst_pad_new_from_template (oclass->sinktempl, "sink");
 254   gst_pad_set_activate_function (demux->sinkpad,
 255       GST_DEBUG_FUNCPTR (gst_ffmpegdemux_sink_activate));
 256   gst_pad_set_activatemode_function (demux->sinkpad,
 257       GST_DEBUG_FUNCPTR (gst_ffmpegdemux_sink_activate_mode));
 258   gst_element_add_pad (GST_ELEMENT (demux), demux->sinkpad);
 259
 260   /* push based setup */
 261   /* the following are not used in pull-based mode, so safe to set anyway */
 262   gst_pad_set_event_function (demux->sinkpad,
 263       GST_DEBUG_FUNCPTR (gst_ffmpegdemux_sink_event));
 264   gst_pad_set_chain_function (demux->sinkpad,
 265       GST_DEBUG_FUNCPTR (gst_ffmpegdemux_chain));
 266   /* task for driving ffmpeg in loop function */
 267   demux->task =
 268       gst_task_new ((GstTaskFunction) gst_ffmpegdemux_loop, demux, NULL);
 269   g_rec_mutex_init (&demux->task_lock);
 270   gst_task_set_lock (demux->task, &demux->task_lock);
 271
 272   demux->have_group_id = FALSE;
 273   demux->group_id = G_MAXUINT;
 274
 275   demux->opened = FALSE;
 276   demux->context = NULL;
 277
 278   for (n = 0; n < MAX_STREAMS; n++) {
 279     demux->streams[n] = NULL;
 280   }
 281   demux->videopads = 0;
 282   demux->audiopads = 0;
 283
 284   demux->seek_event = NULL;
 285   gst_segment_init (&demux->segment, GST_FORMAT_TIME);
 286
 287   demux->flowcombiner = gst_flow_combiner_new ();
 288
 289   /* push based data */
 290   g_mutex_init (&demux->ffpipe.tlock);
 291   g_cond_init (&demux->ffpipe.cond);
 292   demux->ffpipe.adapter = gst_adapter_new ();
 293
 294   /* blacklist unreliable push-based demuxers */
 295   if (strcmp (oclass->in_plugin->name, "ape"))
 296     demux->can_push = TRUE;
 297   else
 298     demux->can_push = FALSE;
 299 }
 300
 301 static void
 302 gst_ffmpegdemux_finalize (GObject * object)
 303 {
 304   GstFFMpegDemux *demux;
 305
 306   demux = (GstFFMpegDemux *) object;
 307
 308   gst_flow_combiner_free (demux->flowcombiner);
 309
 310   g_mutex_clear (&demux->ffpipe.tlock);
 311   g_cond_clear (&demux->ffpipe.cond);
 312   gst_object_unref (demux->ffpipe.adapter);
 313
 314   gst_object_unref (demux->task);
 315   g_rec_mutex_clear (&demux->task_lock);
 316
 317   G_OBJECT_CLASS (parent_class)->finalize (object);
 318 }
 319
 320 static void
 321 gst_ffmpegdemux_close (GstFFMpegDemux * demux)
 322 {
 323   gint n;
 324   GstEvent **event_p;
 325
 326   if (!demux->opened)
 327     return;
 328
 329   /* remove pads from ourselves */
 330   for (n = 0; n < MAX_STREAMS; n++) {
 331     GstFFStream *stream;
 332
 333     stream = demux->streams[n];
 334     if (stream) {
 335       if (stream->pad) {
 336         gst_flow_combiner_remove_pad (demux->flowcombiner, stream->pad);
 337         gst_element_remove_pad (GST_ELEMENT (demux), stream->pad);
 338       }
 339       if (stream->tags)
 340         gst_tag_list_unref (stream->tags);
 341       g_free (stream);
 342     }
 343     demux->streams[n] = NULL;
 344   }
 345   demux->videopads = 0;
 346   demux->audiopads = 0;
 347
 348   /* close demuxer context from ffmpeg */
 349   if (demux->seekable)
 350     gst_ffmpegdata_close (demux->context->pb);
 351   else
 352     gst_ffmpeg_pipe_close (demux->context->pb);
 353   demux->context->pb = NULL;
 354   avformat_close_input (&demux->context);
 355   if (demux->context)
 356     avformat_free_context (demux->context);
 357   demux->context = NULL;
 358
 359   GST_OBJECT_LOCK (demux);
 360   demux->opened = FALSE;
 361   event_p = &demux->seek_event;
 362   gst_event_replace (event_p, NULL);
 363   GST_OBJECT_UNLOCK (demux);
 364
 365   gst_segment_init (&demux->segment, GST_FORMAT_TIME);
 366 }
 367
 368 /* send an event to all the source pads .
 369  * Takes ownership of the event.
 370  *
 371  * Returns FALSE if none of the source pads handled the event.
 372  */
 373 static gboolean
 374 gst_ffmpegdemux_push_event (GstFFMpegDemux * demux, GstEvent * event)
 375 {
 376   gboolean res;
 377   gint n;
 378
 379   res = TRUE;
 380
 381   for (n = 0; n < MAX_STREAMS; n++) {
 382     GstFFStream *s = demux->streams[n];
 383
 384     if (s && s->pad) {
 385       gst_event_ref (event);
 386       res &= gst_pad_push_event (s->pad, event);
 387     }
 388   }
 389   gst_event_unref (event);
 390
 391   return res;
 392 }
 393
 394 /* set flags on all streams */
 395 static void
 396 gst_ffmpegdemux_set_flags (GstFFMpegDemux * demux, gboolean discont,
 397     gboolean eos)
 398 {
 399   GstFFStream *s;
 400   gint n;
 401
 402   for (n = 0; n < MAX_STREAMS; n++) {
 403     if ((s = demux->streams[n])) {
 404       s->discont = discont;
 405       s->eos = eos;
 406     }
 407   }
 408 }
 409
 410 /* check if all streams are eos */
 411 static gboolean
 412 gst_ffmpegdemux_is_eos (GstFFMpegDemux * demux)
 413 {
 414   GstFFStream *s;
 415   gint n;
 416
 417   for (n = 0; n < MAX_STREAMS; n++) {
 418     if ((s = demux->streams[n])) {
 419       GST_DEBUG ("stream %d %p eos:%d", n, s, s->eos);
 420       if (!s->eos)
 421         return FALSE;
 422     }
 423   }
 424   return TRUE;
 425 }
 426
 427 /* Returns True if we at least outputted one buffer */
 428 static gboolean
 429 gst_ffmpegdemux_has_outputted (GstFFMpegDemux * demux)
 430 {
 431   GstFFStream *s;
 432   gint n;
 433
 434   for (n = 0; n < MAX_STREAMS; n++) {
 435     if ((s = demux->streams[n])) {
 436       if (GST_CLOCK_TIME_IS_VALID (s->last_ts))
 437         return TRUE;
 438     }
 439   }
 440   return FALSE;
 441 }
 442
 443 static gboolean
 444 gst_ffmpegdemux_do_seek (GstFFMpegDemux * demux, GstSegment * segment)
 445 {
 446   gboolean ret;
 447   gint seekret;
 448   gint64 target;
 449   gint64 fftarget;
 450   AVStream *stream;
 451   gint index;
 452
 453   /* find default index and fail if none is present */
 454   index = av_find_default_stream_index (demux->context);
 455   GST_LOG_OBJECT (demux, "default stream index %d", index);
 456   if (index < 0)
 457     return FALSE;
 458
 459   ret = TRUE;
 460
 461   /* get the stream for seeking */
 462   stream = demux->context->streams[index];
 463   /* initial seek position */
 464   target = segment->position + demux->start_time;
 465   /* convert target to ffmpeg time */
 466   fftarget = gst_ffmpeg_time_gst_to_ff (target, stream->time_base);
 467
 468   GST_LOG_OBJECT (demux, "do seek to time %" GST_TIME_FORMAT,
 469       GST_TIME_ARGS (target));
 470
 471   /* if we need to land on a keyframe, try to do so, we don't try to do a
 472    * keyframe seek if we are not absolutely sure we have an index.*/
 473   if (segment->flags & GST_SEEK_FLAG_KEY_UNIT) {
 474     gint keyframeidx;
 475
 476     GST_LOG_OBJECT (demux, "looking for keyframe in ffmpeg for time %"
 477         GST_TIME_FORMAT, GST_TIME_ARGS (target));
 478
 479     /* search in the index for the previous keyframe */
 480     keyframeidx =
 481         av_index_search_timestamp (stream, fftarget, AVSEEK_FLAG_BACKWARD);
 482
 483     GST_LOG_OBJECT (demux, "keyframeidx: %d", keyframeidx);
 484
 485     if (keyframeidx >= 0) {
 486 #if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(58,78,0)
 487       fftarget = avformat_index_get_entry (stream, keyframeidx)->timestamp;
 488 #else
 489       fftarget = stream->index_entries[keyframeidx].timestamp;
 490 #endif
 491       target = gst_ffmpeg_time_ff_to_gst (fftarget, stream->time_base);
 492
 493       GST_LOG_OBJECT (demux,
 494           "Found a keyframe at ffmpeg idx: %d timestamp :%" GST_TIME_FORMAT,
 495           keyframeidx, GST_TIME_ARGS (target));
 496     }
 497   }
 498
 499   GST_DEBUG_OBJECT (demux,
 500       "About to call av_seek_frame (context, %d, %" G_GINT64_FORMAT
 501       ", 0) for time %" GST_TIME_FORMAT, index, fftarget,
 502       GST_TIME_ARGS (target));
 503
 504   if ((seekret =
 505           av_seek_frame (demux->context, index, fftarget,
 506               AVSEEK_FLAG_BACKWARD)) < 0)
 507     goto seek_failed;
 508
 509   GST_DEBUG_OBJECT (demux, "seek success, returned %d", seekret);
 510
 511   if (target > demux->start_time)
 512     target -= demux->start_time;
 513   else
 514     target = 0;
 515
 516   segment->position = target;
 517   segment->time = target;
 518   segment->start = target;
 519
 520   return ret;
 521
 522   /* ERRORS */
 523 seek_failed:
 524   {
 525     GST_WARNING_OBJECT (demux, "Call to av_seek_frame failed : %d", seekret);
 526     return FALSE;
 527   }
 528 }
 529
 530 static gboolean
 531 gst_ffmpegdemux_perform_seek (GstFFMpegDemux * demux, GstEvent * event)
 532 {
 533   gboolean res;
 534   gdouble rate;
 535   GstFormat format;
 536   GstSeekFlags flags;
 537   GstSeekType cur_type, stop_type;
 538   gint64 cur, stop;
 539   gboolean flush;
 540   gboolean update;
 541   GstSegment seeksegment;
 542
 543   if (!demux->seekable) {
 544     GST_DEBUG_OBJECT (demux, "in push mode; ignoring seek");
 545     return FALSE;
 546   }
 547
 548   GST_DEBUG_OBJECT (demux, "starting seek");
 549
 550   if (event) {
 551     gst_event_parse_seek (event, &rate, &format, &flags,
 552         &cur_type, &cur, &stop_type, &stop);
 553
 554     /* we have to have a format as the segment format. Try to convert
 555      * if not. */
 556     if (demux->segment.format != format) {
 557       GstFormat fmt;
 558
 559       fmt = demux->segment.format;
 560       res = TRUE;
 561       /* FIXME, use source pad */
 562       if (cur_type != GST_SEEK_TYPE_NONE && cur != -1)
 563         res = gst_pad_query_convert (demux->sinkpad, format, cur, fmt, &cur);
 564       if (res && stop_type != GST_SEEK_TYPE_NONE && stop != -1)
 565         res = gst_pad_query_convert (demux->sinkpad, format, stop, fmt, &stop);
 566       if (!res)
 567         goto no_format;
 568
 569       format = fmt;
 570     }
 571   } else {
 572     flags = 0;
 573   }
 574
 575   flush = flags & GST_SEEK_FLAG_FLUSH;
 576
 577   /* send flush start */
 578   if (flush) {
 579     /* mark flushing so that the streaming thread can react on it */
 580     GST_OBJECT_LOCK (demux);
 581     demux->flushing = TRUE;
 582     GST_OBJECT_UNLOCK (demux);
 583     gst_pad_push_event (demux->sinkpad, gst_event_new_flush_start ());
 584     gst_ffmpegdemux_push_event (demux, gst_event_new_flush_start ());
 585   } else {
 586     gst_pad_pause_task (demux->sinkpad);
 587   }
 588
 589   /* grab streaming lock, this should eventually be possible, either
 590    * because the task is paused or our streaming thread stopped
 591    * because our peer is flushing. */
 592   GST_PAD_STREAM_LOCK (demux->sinkpad);
 593
 594   /* make copy into temp structure, we can only update the main one
 595    * when we actually could do the seek. */
 596   memcpy (&seeksegment, &demux->segment, sizeof (GstSegment));
 597
 598   /* now configure the seek segment */
 599   if (event) {
 600     gst_segment_do_seek (&seeksegment, rate, format, flags,
 601         cur_type, cur, stop_type, stop, &update);
 602   }
 603
 604   GST_DEBUG_OBJECT (demux, "segment configured from %" G_GINT64_FORMAT
 605       " to %" G_GINT64_FORMAT ", position %" G_GINT64_FORMAT,
 606       seeksegment.start, seeksegment.stop, seeksegment.position);
 607
 608   /* make the sinkpad available for data passing since we might need
 609    * it when doing the seek */
 610   if (flush) {
 611     GST_OBJECT_LOCK (demux);
 612     demux->flushing = FALSE;
 613     GST_OBJECT_UNLOCK (demux);
 614     gst_pad_push_event (demux->sinkpad, gst_event_new_flush_stop (TRUE));
 615   }
 616
 617   /* do the seek, segment.position contains new position. */
 618   res = gst_ffmpegdemux_do_seek (demux, &seeksegment);
 619
 620   /* and prepare to continue streaming */
 621   if (flush) {
 622     /* send flush stop, peer will accept data and events again. We
 623      * are not yet providing data as we still have the STREAM_LOCK. */
 624     gst_ffmpegdemux_push_event (demux, gst_event_new_flush_stop (TRUE));
 625   }
 626   /* if successfull seek, we update our real segment and push
 627    * out the new segment. */
 628   if (res) {
 629     memcpy (&demux->segment, &seeksegment, sizeof (GstSegment));
 630
 631     if (demux->segment.flags & GST_SEEK_FLAG_SEGMENT) {
 632       gst_element_post_message (GST_ELEMENT (demux),
 633           gst_message_new_segment_start (GST_OBJECT (demux),
 634               demux->segment.format, demux->segment.position));
 635     }
 636
 637     /* now send the newsegment, FIXME, do this from the streaming thread */
 638     GST_DEBUG_OBJECT (demux, "Sending newsegment %" GST_SEGMENT_FORMAT,
 639         &demux->segment);
 640
 641     gst_ffmpegdemux_push_event (demux, gst_event_new_segment (&demux->segment));
 642   }
 643
 644   /* Mark discont on all srcpads and remove eos */
 645   gst_ffmpegdemux_set_flags (demux, TRUE, FALSE);
 646   gst_flow_combiner_reset (demux->flowcombiner);
 647
 648   /* and restart the task in case it got paused explicitely or by
 649    * the FLUSH_START event we pushed out. */
 650   gst_pad_start_task (demux->sinkpad, (GstTaskFunction) gst_ffmpegdemux_loop,
 651       demux->sinkpad, NULL);
 652
 653   /* and release the lock again so we can continue streaming */
 654   GST_PAD_STREAM_UNLOCK (demux->sinkpad);
 655
 656   return res;
 657
 658   /* ERROR */
 659 no_format:
 660   {
 661     GST_DEBUG_OBJECT (demux, "undefined format given, seek aborted.");
 662     return FALSE;
 663   }
 664 }
 665
 666 static gboolean
 667 gst_ffmpegdemux_src_event (GstPad * pad, GstObject * parent, GstEvent * event)
 668 {
 669   GstFFMpegDemux *demux;
 670   gboolean res = TRUE;
 671
 672   demux = (GstFFMpegDemux *) parent;
 673
 674   switch (GST_EVENT_TYPE (event)) {
 675     case GST_EVENT_SEEK:
 676       res = gst_ffmpegdemux_perform_seek (demux, event);
 677       gst_event_unref (event);
 678       break;
 679     case GST_EVENT_LATENCY:
 680       res = gst_pad_push_event (demux->sinkpad, event);
 681       break;
 682     case GST_EVENT_NAVIGATION:
 683     case GST_EVENT_QOS:
 684     default:
 685       res = FALSE;
 686       gst_event_unref (event);
 687       break;
 688   }
 689
 690   return res;
 691 }
 692
 693 static gboolean
 694 gst_ffmpegdemux_send_event (GstElement * element, GstEvent * event)
 695 {
 696   GstFFMpegDemux *demux = (GstFFMpegDemux *) (element);
 697   gboolean res;
 698
 699   switch (GST_EVENT_TYPE (event)) {
 700     case GST_EVENT_SEEK:
 701       GST_OBJECT_LOCK (demux);
 702       if (!demux->opened) {
 703         GstEvent **event_p;
 704
 705         GST_DEBUG_OBJECT (demux, "caching seek event");
 706         event_p = &demux->seek_event;
 707         gst_event_replace (event_p, event);
 708         GST_OBJECT_UNLOCK (demux);
 709
 710         res = TRUE;
 711       } else {
 712         GST_OBJECT_UNLOCK (demux);
 713         res = gst_ffmpegdemux_perform_seek (demux, event);
 714         gst_event_unref (event);
 715       }
 716       break;
 717     default:
 718       res = FALSE;
 719       break;
 720   }
 721
 722   return res;
 723 }
 724
 725 static gboolean
 726 gst_ffmpegdemux_src_query (GstPad * pad, GstObject * parent, GstQuery * query)
 727 {
 728   GstFFMpegDemux *demux;
 729   GstFFStream *stream;
 730   AVStream *avstream;
 731   gboolean res = FALSE;
 732
 733   if (!(stream = gst_pad_get_element_private (pad)))
 734     return FALSE;
 735
 736   avstream = stream->avstream;
 737
 738   demux = (GstFFMpegDemux *) parent;
 739
 740   switch (GST_QUERY_TYPE (query)) {
 741     case GST_QUERY_POSITION:
 742     {
 743       GstFormat format;
 744       gint64 timeposition;
 745
 746       gst_query_parse_position (query, &format, NULL);
 747
 748       timeposition = stream->last_ts;
 749       if (!(GST_CLOCK_TIME_IS_VALID (timeposition)))
 750         break;
 751
 752       switch (format) {
 753         case GST_FORMAT_TIME:
 754           gst_query_set_position (query, GST_FORMAT_TIME, timeposition);
 755           res = TRUE;
 756           break;
 757         case GST_FORMAT_DEFAULT:
 758           gst_query_set_position (query, GST_FORMAT_DEFAULT,
 759               gst_util_uint64_scale (timeposition, avstream->avg_frame_rate.num,
 760                   GST_SECOND * avstream->avg_frame_rate.den));
 761           res = TRUE;
 762           break;
 763         case GST_FORMAT_BYTES:
 764           if (demux->videopads + demux->audiopads == 1 &&
 765               GST_PAD_PEER (demux->sinkpad) != NULL)
 766             res = gst_pad_query_default (pad, parent, query);
 767           break;
 768         default:
 769           break;
 770       }
 771     }
 772       break;
 773     case GST_QUERY_DURATION:
 774     {
 775       GstFormat format;
 776       gint64 timeduration;
 777
 778       gst_query_parse_duration (query, &format, NULL);
 779
 780       timeduration =
 781           gst_ffmpeg_time_ff_to_gst (avstream->duration, avstream->time_base);
 782       if (!(GST_CLOCK_TIME_IS_VALID (timeduration))) {
 783         /* use duration of complete file if the stream duration is not known */
 784         timeduration = demux->duration;
 785         if (!(GST_CLOCK_TIME_IS_VALID (timeduration)))
 786           break;
 787       }
 788
 789       switch (format) {
 790         case GST_FORMAT_TIME:
 791           gst_query_set_duration (query, GST_FORMAT_TIME, timeduration);
 792           res = TRUE;
 793           break;
 794         case GST_FORMAT_DEFAULT:
 795           gst_query_set_duration (query, GST_FORMAT_DEFAULT,
 796               gst_util_uint64_scale (timeduration, avstream->avg_frame_rate.num,
 797                   GST_SECOND * avstream->avg_frame_rate.den));
 798           res = TRUE;
 799           break;
 800         case GST_FORMAT_BYTES:
 801           if (demux->videopads + demux->audiopads == 1 &&
 802               GST_PAD_PEER (demux->sinkpad) != NULL)
 803             res = gst_pad_query_default (pad, parent, query);
 804           break;
 805         default:
 806           break;
 807       }
 808     }
 809       break;
 810     case GST_QUERY_SEEKING:{
 811       GstFormat format;
 812       gboolean seekable;
 813       gint64 dur = -1;
 814
 815       gst_query_parse_seeking (query, &format, NULL, NULL, NULL);
 816       seekable = demux->seekable;
 817       if (!gst_pad_query_duration (pad, format, &dur)) {
 818         /* unlikely that we don't know duration but can seek */
 819         seekable = FALSE;
 820         dur = -1;
 821       }
 822       gst_query_set_seeking (query, format, seekable, 0, dur);
 823       res = TRUE;
 824       break;
 825     }
 826     case GST_QUERY_SEGMENT:{
 827       GstFormat format;
 828       gint64 start, stop;
 829
 830       format = demux->segment.format;
 831
 832       start =
 833           gst_segment_to_stream_time (&demux->segment, format,
 834           demux->segment.start);
 835       if ((stop = demux->segment.stop) == -1)
 836         stop = demux->segment.duration;
 837       else
 838         stop = gst_segment_to_stream_time (&demux->segment, format, stop);
 839
 840       gst_query_set_segment (query, demux->segment.rate, format, start, stop);
 841       res = TRUE;
 842       break;
 843     }
 844     default:
 845       /* FIXME : ADD GST_QUERY_CONVERT */
 846       res = gst_pad_query_default (pad, parent, query);
 847       break;
 848   }
 849
 850   return res;
 851 }
 852
 853 #if 0
 854 /* FIXME, reenable me */
 855 static gboolean
 856 gst_ffmpegdemux_src_convert (GstPad * pad,
 857     GstFormat src_fmt,
 858     gint64 src_value, GstFormat * dest_fmt, gint64 * dest_value)
 859 {
 860   GstFFStream *stream;
 861   gboolean res = TRUE;
 862   AVStream *avstream;
 863
 864   if (!(stream = gst_pad_get_element_private (pad)))
 865     return FALSE;
 866
 867   avstream = stream->avstream;
 868   if (avstream->codec->codec_type != AVMEDIA_TYPE_VIDEO)
 869     return FALSE;
 870
 871   switch (src_fmt) {
 872     case GST_FORMAT_TIME:
 873       switch (*dest_fmt) {
 874         case GST_FORMAT_DEFAULT:
 875           *dest_value = gst_util_uint64_scale (src_value,
 876               avstream->avg_frame_rate.num,
 877               GST_SECOND * avstream->avg_frame_rate.den);
 878           break;
 879         default:
 880           res = FALSE;
 881           break;
 882       }
 883       break;
 884     case GST_FORMAT_DEFAULT:
 885       switch (*dest_fmt) {
 886         case GST_FORMAT_TIME:
 887           *dest_value = gst_util_uint64_scale (src_value,
 888               GST_SECOND * avstream->avg_frame_rate.num,
 889               avstream->avg_frame_rate.den);
 890           break;
 891         default:
 892           res = FALSE;
 893           break;
 894       }
 895       break;
 896     default:
 897       res = FALSE;
 898       break;
 899   }
 900
 901   return res;
 902 }
 903 #endif
 904
 905 static gchar *
 906 gst_ffmpegdemux_create_padname (const gchar * templ, gint n)
 907 {
 908   GString *string;
 909
 910   /* FIXME, we just want to printf the number according to the template but
 911    * then the format string is not a literal and we can't check arguments and
 912    * this generates a compiler error */
 913   string = g_string_new (templ);
 914   g_string_truncate (string, string->len - 2);
 915   g_string_append_printf (string, "%u", n);
 916
 917   return g_string_free (string, FALSE);
 918 }
 919
 920 static GstFFStream *
 921 gst_ffmpegdemux_get_stream (GstFFMpegDemux * demux, AVStream * avstream)
 922 {
 923   GstFFMpegDemuxClass *oclass;
 924   GstPadTemplate *templ = NULL;
 925   GstPad *pad;
 926   GstCaps *caps;
 927   gint num;
 928   gchar *padname;
 929   const gchar *codec;
 930   AVCodecContext *ctx = NULL;
 931   GstFFStream *stream;
 932   GstEvent *event;
 933   gchar *stream_id;
 934
 935   oclass = (GstFFMpegDemuxClass *) G_OBJECT_GET_CLASS (demux);
 936
 937   if (demux->streams[avstream->index] != NULL)
 938     goto exists;
 939
 940   ctx = avcodec_alloc_context3 (NULL);
 941   avcodec_parameters_to_context (ctx, avstream->codecpar);
 942
 943   /* create new stream */
 944   stream = g_new0 (GstFFStream, 1);
 945   demux->streams[avstream->index] = stream;
 946
 947   /* mark stream as unknown */
 948   stream->unknown = TRUE;
 949   stream->discont = TRUE;
 950   stream->avstream = avstream;
 951   stream->last_ts = GST_CLOCK_TIME_NONE;
 952   stream->tags = NULL;
 953
 954   switch (ctx->codec_type) {
 955     case AVMEDIA_TYPE_VIDEO:
 956       templ = oclass->videosrctempl;
 957       num = demux->videopads++;
 958       /* These are not part of the codec parameters we built the
 959        * context from */
 960       ctx->framerate.num = avstream->r_frame_rate.num;
 961       ctx->framerate.den = avstream->r_frame_rate.den;
 962       break;
 963     case AVMEDIA_TYPE_AUDIO:
 964       templ = oclass->audiosrctempl;
 965       num = demux->audiopads++;
 966       break;
 967     default:
 968       goto unknown_type;
 969   }
 970
 971   /* get caps that belongs to this stream */
 972   caps = gst_ffmpeg_codecid_to_caps (ctx->codec_id, ctx, TRUE);
 973   if (caps == NULL)
 974     goto unknown_caps;
 975
 976   /* stream is known now */
 977   stream->unknown = FALSE;
 978
 979   /* create new pad for this stream */
 980   padname =
 981       gst_ffmpegdemux_create_padname (GST_PAD_TEMPLATE_NAME_TEMPLATE (templ),
 982       num);
 983   pad = gst_pad_new_from_template (templ, padname);
 984   g_free (padname);
 985
 986   gst_pad_use_fixed_caps (pad);
 987   gst_pad_set_active (pad, TRUE);
 988
 989   gst_pad_set_query_function (pad, gst_ffmpegdemux_src_query);
 990   gst_pad_set_event_function (pad, gst_ffmpegdemux_src_event);
 991
 992   /* store pad internally */
 993   stream->pad = pad;
 994   gst_pad_set_element_private (pad, stream);
 995
 996   /* transform some useful info to GstClockTime and remember */
 997   {
 998     GstClockTime tmp;
 999
1000     /* FIXME, actually use the start_time in some way */
1001     tmp = gst_ffmpeg_time_ff_to_gst (avstream->start_time, avstream->time_base);
1002     GST_DEBUG_OBJECT (demux, "stream %d: start time: %" GST_TIME_FORMAT,
1003         avstream->index, GST_TIME_ARGS (tmp));
1004
1005     tmp = gst_ffmpeg_time_ff_to_gst (avstream->duration, avstream->time_base);
1006     GST_DEBUG_OBJECT (demux, "stream %d: duration: %" GST_TIME_FORMAT,
1007         avstream->index, GST_TIME_ARGS (tmp));
1008   }
1009
1010   demux->streams[avstream->index] = stream;
1011
1012
1013   stream_id =
1014       gst_pad_create_stream_id_printf (pad, GST_ELEMENT_CAST (demux), "%03u",
1015       avstream->index);
1016
1017   event = gst_pad_get_sticky_event (demux->sinkpad, GST_EVENT_STREAM_START, 0);
1018   if (event) {
1019     if (gst_event_parse_group_id (event, &demux->group_id))
1020       demux->have_group_id = TRUE;
1021     else
1022       demux->have_group_id = FALSE;
1023     gst_event_unref (event);
1024   } else if (!demux->have_group_id) {
1025     demux->have_group_id = TRUE;
1026     demux->group_id = gst_util_group_id_next ();
1027   }
1028   event = gst_event_new_stream_start (stream_id);
1029   if (demux->have_group_id)
1030     gst_event_set_group_id (event, demux->group_id);
1031
1032   gst_pad_push_event (pad, event);
1033   g_free (stream_id);
1034
1035   GST_INFO_OBJECT (pad, "adding pad with caps %" GST_PTR_FORMAT, caps);
1036   gst_pad_set_caps (pad, caps);
1037   gst_caps_unref (caps);
1038
1039   /* activate and add */
1040   gst_element_add_pad (GST_ELEMENT (demux), pad);
1041   gst_flow_combiner_add_pad (demux->flowcombiner, pad);
1042
1043   /* metadata */
1044   if ((codec = gst_ffmpeg_get_codecid_longname (ctx->codec_id))) {
1045     stream->tags = gst_ffmpeg_metadata_to_tag_list (avstream->metadata);
1046
1047     if (stream->tags == NULL)
1048       stream->tags = gst_tag_list_new_empty ();
1049
1050     gst_tag_list_add (stream->tags, GST_TAG_MERGE_REPLACE,
1051         (ctx->codec_type == AVMEDIA_TYPE_VIDEO) ?
1052         GST_TAG_VIDEO_CODEC : GST_TAG_AUDIO_CODEC, codec, NULL);
1053   }
1054
1055 done:
1056   if (ctx)
1057     avcodec_free_context (&ctx);
1058   return stream;
1059
1060   /* ERRORS */
1061 exists:
1062   {
1063     GST_DEBUG_OBJECT (demux, "Pad existed (stream %d)", avstream->index);
1064     stream = demux->streams[avstream->index];
1065     goto done;
1066   }
1067 unknown_type:
1068   {
1069     GST_WARNING_OBJECT (demux, "Unknown pad type %d", ctx->codec_type);
1070     goto done;
1071   }
1072 unknown_caps:
1073   {
1074     GST_WARNING_OBJECT (demux, "Unknown caps for codec %d", ctx->codec_id);
1075     goto done;
1076   }
1077 }
1078
1079 static gchar *
1080 safe_utf8_copy (gchar * input)
1081 {
1082   gchar *output;
1083
1084   if (!(g_utf8_validate (input, -1, NULL))) {
1085     output = g_convert (input, strlen (input),
1086         "UTF-8", "ISO-8859-1", NULL, NULL, NULL);
1087   } else {
1088     output = g_strdup (input);
1089   }
1090
1091   return output;
1092 }
1093
1094 /* This is a list of standard tag keys taken from the avformat.h
1095  * header, without handling any variants. */
1096 static const struct
1097 {
1098   const gchar *ffmpeg_tag_name;
1099   const gchar *gst_tag_name;
1100 } tagmapping[] = {
1101   {
1102   "album", GST_TAG_ALBUM}, {
1103   "album_artist", GST_TAG_ALBUM_ARTIST}, {
1104   "artist", GST_TAG_ARTIST}, {
1105   "comment", GST_TAG_COMMENT}, {
1106   "composer", GST_TAG_COMPOSER}, {
1107   "copyright", GST_TAG_COPYRIGHT},
1108       /* Need to convert ISO 8601 to GstDateTime: */
1109   {
1110   "creation_time", GST_TAG_DATE_TIME},
1111       /* Need to convert ISO 8601 to GDateTime: */
1112   {
1113   "date", GST_TAG_DATE_TIME}, {
1114   "disc", GST_TAG_ALBUM_VOLUME_NUMBER}, {
1115   "encoder", GST_TAG_ENCODER}, {
1116   "encoded_by", GST_TAG_ENCODED_BY}, {
1117   "genre", GST_TAG_GENRE}, {
1118   "language", GST_TAG_LANGUAGE_CODE}, {
1119   "performer", GST_TAG_PERFORMER}, {
1120   "publisher", GST_TAG_PUBLISHER}, {
1121   "title", GST_TAG_TITLE}, {
1122   "track", GST_TAG_TRACK_NUMBER}
1123 };
1124
1125 static const gchar *
1126 match_tag_name (gchar * ffmpeg_tag_name)
1127 {
1128   gint i;
1129   for (i = 0; i < G_N_ELEMENTS (tagmapping); i++) {
1130     if (!g_strcmp0 (tagmapping[i].ffmpeg_tag_name, ffmpeg_tag_name))
1131       return tagmapping[i].gst_tag_name;
1132   }
1133   return NULL;
1134 }
1135
1136 static GstTagList *
1137 gst_ffmpeg_metadata_to_tag_list (AVDictionary * metadata)
1138 {
1139   AVDictionaryEntry *tag = NULL;
1140   GstTagList *list;
1141   list = gst_tag_list_new_empty ();
1142
1143   while ((tag = av_dict_get (metadata, "", tag, AV_DICT_IGNORE_SUFFIX))) {
1144     const gchar *gsttag = match_tag_name (tag->key);
1145     GType t;
1146     GST_LOG ("mapping tag %s=%s\n", tag->key, tag->value);
1147     if (gsttag == NULL) {
1148       GST_LOG ("Ignoring unknown metadata tag %s", tag->key);
1149       continue;
1150     }
1151     /* Special case, track and disc numbers may be x/n in libav, split
1152      * them */
1153     if (g_str_equal (gsttag, GST_TAG_TRACK_NUMBER)) {
1154       guint track, trackcount;
1155       if (sscanf (tag->value, "%u/%u", &track, &trackcount) == 2) {
1156         gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
1157             gsttag, track, GST_TAG_TRACK_COUNT, trackcount, NULL);
1158         continue;
1159       }
1160       /* Fall through and handle as a single uint below */
1161     } else if (g_str_equal (gsttag, GST_TAG_ALBUM_VOLUME_NUMBER)) {
1162       guint disc, disc_count;
1163       if (sscanf (tag->value, "%u/%u", &disc, &disc_count) == 2) {
1164         gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
1165             gsttag, disc, GST_TAG_ALBUM_VOLUME_COUNT, disc_count, NULL);
1166         continue;
1167       }
1168       /* Fall through and handle as a single uint below */
1169     }
1170
1171     t = gst_tag_get_type (gsttag);
1172     if (t == G_TYPE_STRING) {
1173       gchar *s = safe_utf8_copy (tag->value);
1174       gst_tag_list_add (list, GST_TAG_MERGE_REPLACE, gsttag, s, NULL);
1175       g_free (s);
1176     } else if (t == G_TYPE_UINT || t == G_TYPE_INT) {
1177       gchar *end;
1178       gint v = strtol (tag->value, &end, 10);
1179       if (end == tag->value)
1180         continue;               /* Failed to parse */
1181       gst_tag_list_add (list, GST_TAG_MERGE_REPLACE, gsttag, v, NULL);
1182     } else if (t == G_TYPE_DATE) {
1183       guint year, month, day;
1184       GDate *date = NULL;
1185       if (sscanf (tag->value, "%04u-%02u-%02u", &year, &month, &day) == 3) {
1186         date = g_date_new_dmy (day, month, year);
1187       } else {
1188         /* Try interpreting just as a year */
1189         gchar *end;
1190
1191         year = strtol (tag->value, &end, 10);
1192         if (end != tag->value)
1193           date = g_date_new_dmy (1, 1, year);
1194       }
1195       if (date) {
1196         gst_tag_list_add (list, GST_TAG_MERGE_REPLACE, gsttag, date, NULL);
1197         g_date_free (date);
1198       }
1199     } else if (t == GST_TYPE_DATE_TIME) {
1200       gchar *s = safe_utf8_copy (tag->value);
1201       GstDateTime *d = gst_date_time_new_from_iso8601_string (s);
1202
1203       g_free (s);
1204       if (d) {
1205         gst_tag_list_add (list, GST_TAG_MERGE_REPLACE, gsttag, d, NULL);
1206         gst_date_time_unref (d);
1207       }
1208     } else {
1209       GST_FIXME ("Unhandled tag %s", gsttag);
1210     }
1211   }
1212
1213   if (gst_tag_list_is_empty (list)) {
1214     gst_tag_list_unref (list);
1215     return NULL;
1216   }
1217
1218   return list;
1219 }
1220
1221 static gboolean
1222 gst_ffmpegdemux_open (GstFFMpegDemux * demux)
1223 {
1224   AVIOContext *iocontext = NULL;
1225   GstFFMpegDemuxClass *oclass =
1226       (GstFFMpegDemuxClass *) G_OBJECT_GET_CLASS (demux);
1227   gint res, n_streams, i;
1228   GstTagList *tags;
1229   GstEvent *event;
1230   GList *cached_events;
1231   GstQuery *query;
1232   gchar *uri = NULL;
1233
1234   /* to be sure... */
1235   gst_ffmpegdemux_close (demux);
1236
1237   /* open via our input protocol hack */
1238   if (demux->seekable)
1239     res = gst_ffmpegdata_open (demux->sinkpad, AVIO_FLAG_READ, &iocontext);
1240   else
1241     res = gst_ffmpeg_pipe_open (&demux->ffpipe, AVIO_FLAG_READ, &iocontext);
1242
1243   if (res < 0)
1244     goto beach;
1245
1246   query = gst_query_new_uri ();
1247   if (gst_pad_peer_query (demux->sinkpad, query)) {
1248     gchar *query_uri, *redirect_uri;
1249     gboolean permanent;
1250
1251     gst_query_parse_uri (query, &query_uri);
1252     gst_query_parse_uri_redirection (query, &redirect_uri);
1253     gst_query_parse_uri_redirection_permanent (query, &permanent);
1254
1255     if (permanent && redirect_uri) {
1256       uri = redirect_uri;
1257       g_free (query_uri);
1258     } else {
1259       uri = query_uri;
1260       g_free (redirect_uri);
1261     }
1262   }
1263   gst_query_unref (query);
1264
1265   GST_DEBUG_OBJECT (demux, "Opening context with URI %s", GST_STR_NULL (uri));
1266
1267   demux->context = avformat_alloc_context ();
1268   demux->context->pb = iocontext;
1269   res = avformat_open_input (&demux->context, uri, oclass->in_plugin, NULL);
1270
1271   g_free (uri);
1272
1273   GST_DEBUG_OBJECT (demux, "av_open_input returned %d", res);
1274   if (res < 0)
1275     goto beach;
1276
1277   res = gst_ffmpeg_av_find_stream_info (demux->context);
1278   GST_DEBUG_OBJECT (demux, "av_find_stream_info returned %d", res);
1279   if (res < 0)
1280     goto beach;
1281
1282   n_streams = demux->context->nb_streams;
1283   GST_DEBUG_OBJECT (demux, "we have %d streams", n_streams);
1284
1285   /* open_input_file() automatically reads the header. We can now map each
1286    * created AVStream to a GstPad to make GStreamer handle it. */
1287   for (i = 0; i < n_streams; i++) {
1288     gst_ffmpegdemux_get_stream (demux, demux->context->streams[i]);
1289   }
1290
1291   gst_element_no_more_pads (GST_ELEMENT (demux));
1292
1293   /* transform some useful info to GstClockTime and remember */
1294   demux->start_time = gst_util_uint64_scale_int (demux->context->start_time,
1295       GST_SECOND, AV_TIME_BASE);
1296   GST_DEBUG_OBJECT (demux, "start time: %" GST_TIME_FORMAT,
1297       GST_TIME_ARGS (demux->start_time));
1298   if (demux->context->duration > 0)
1299     demux->duration = gst_util_uint64_scale_int (demux->context->duration,
1300         GST_SECOND, AV_TIME_BASE);
1301   else
1302     demux->duration = GST_CLOCK_TIME_NONE;
1303
1304   GST_DEBUG_OBJECT (demux, "duration: %" GST_TIME_FORMAT,
1305       GST_TIME_ARGS (demux->duration));
1306
1307   /* store duration in the segment as well */
1308   demux->segment.duration = demux->duration;
1309
1310   GST_OBJECT_LOCK (demux);
1311   demux->opened = TRUE;
1312   event = demux->seek_event;
1313   demux->seek_event = NULL;
1314   cached_events = demux->cached_events;
1315   demux->cached_events = NULL;
1316   GST_OBJECT_UNLOCK (demux);
1317
1318   if (event) {
1319     gst_ffmpegdemux_perform_seek (demux, event);
1320     gst_event_unref (event);
1321   } else {
1322     GST_DEBUG_OBJECT (demux, "Sending segment %" GST_SEGMENT_FORMAT,
1323         &demux->segment);
1324     gst_ffmpegdemux_push_event (demux, gst_event_new_segment (&demux->segment));
1325   }
1326
1327   while (cached_events) {
1328     event = cached_events->data;
1329     GST_INFO_OBJECT (demux, "pushing cached event: %" GST_PTR_FORMAT, event);
1330     gst_ffmpegdemux_push_event (demux, event);
1331     cached_events = g_list_delete_link (cached_events, cached_events);
1332   }
1333
1334   /* grab the global tags */
1335   tags = gst_ffmpeg_metadata_to_tag_list (demux->context->metadata);
1336   if (tags) {
1337     GST_INFO_OBJECT (demux, "global tags: %" GST_PTR_FORMAT, tags);
1338   }
1339
1340   /* now handle the stream tags */
1341   for (i = 0; i < n_streams; i++) {
1342     GstFFStream *stream;
1343
1344     stream = gst_ffmpegdemux_get_stream (demux, demux->context->streams[i]);
1345     if (stream->pad != NULL) {
1346
1347       /* Global tags */
1348       if (tags)
1349         gst_pad_push_event (stream->pad,
1350             gst_event_new_tag (gst_tag_list_ref (tags)));
1351
1352       /* Per-stream tags */
1353       if (stream->tags != NULL) {
1354         GST_INFO_OBJECT (stream->pad, "stream tags: %" GST_PTR_FORMAT,
1355             stream->tags);
1356         gst_pad_push_event (stream->pad,
1357             gst_event_new_tag (gst_tag_list_ref (stream->tags)));
1358       }
1359     }
1360   }
1361   if (tags)
1362     gst_tag_list_unref (tags);
1363   return TRUE;
1364
1365   /* ERRORS */
1366 beach:
1367   {
1368     GST_ELEMENT_ERROR (demux, LIBRARY, FAILED, (NULL),
1369         ("%s", gst_ffmpegdemux_averror (res)));
1370     return FALSE;
1371   }
1372 }
1373
1374 #define GST_FFMPEG_TYPE_FIND_SIZE 4096
1375 #define GST_FFMPEG_TYPE_FIND_MIN_SIZE 256
1376
1377 static void
1378 gst_ffmpegdemux_type_find (GstTypeFind * tf, gpointer priv)
1379 {
1380   const guint8 *data;
1381   AVInputFormat *in_plugin = (AVInputFormat *) priv;
1382   gint res = 0;
1383   guint64 length;
1384   GstCaps *sinkcaps;
1385
1386   /* We want GST_FFMPEG_TYPE_FIND_SIZE bytes, but if the file is shorter than
1387    * that we'll give it a try... */
1388   length = gst_type_find_get_length (tf);
1389   if (length == 0 || length > GST_FFMPEG_TYPE_FIND_SIZE)
1390     length = GST_FFMPEG_TYPE_FIND_SIZE;
1391
1392   /* The ffmpeg typefinders assume there's a certain minimum amount of data
1393    * and will happily do invalid memory access if there isn't, so let's just
1394    * skip the ffmpeg typefinders if the data available is too short
1395    * (in which case it's unlikely to be a media file anyway) */
1396   if (length < GST_FFMPEG_TYPE_FIND_MIN_SIZE) {
1397     GST_LOG ("not typefinding %" G_GUINT64_FORMAT " bytes, too short", length);
1398     return;
1399   }
1400
1401   GST_LOG ("typefinding %" G_GUINT64_FORMAT " bytes", length);
1402   if (in_plugin->read_probe &&
1403       (data = gst_type_find_peek (tf, 0, length)) != NULL) {
1404     AVProbeData probe_data;
1405
1406     probe_data.filename = "";
1407     probe_data.buf = (guint8 *) data;
1408     probe_data.buf_size = length;
1409
1410     res = in_plugin->read_probe (&probe_data);
1411     if (res > 0) {
1412       res = MAX (1, res * GST_TYPE_FIND_MAXIMUM / AVPROBE_SCORE_MAX);
1413       /* Restrict the probability for MPEG-TS streams, because there is
1414        * probably a better version in plugins-base, if the user has a recent
1415        * plugins-base (in fact we shouldn't even get here for ffmpeg mpegts or
1416        * mpegtsraw typefinders, since we blacklist them) */
1417       if (g_str_has_prefix (in_plugin->name, "mpegts"))
1418         res = MIN (res, GST_TYPE_FIND_POSSIBLE);
1419
1420       sinkcaps = gst_ffmpeg_formatid_to_caps (in_plugin->name);
1421
1422       GST_LOG ("libav typefinder '%s' suggests %" GST_PTR_FORMAT ", p=%u%%",
1423           in_plugin->name, sinkcaps, res);
1424
1425       gst_type_find_suggest (tf, res, sinkcaps);
1426       gst_caps_unref (sinkcaps);
1427     }
1428   }
1429 }
1430
1431 /* Task */
1432 static void
1433 gst_ffmpegdemux_loop (GstFFMpegDemux * demux)
1434 {
1435   GstFlowReturn ret;
1436   gint res = -1;
1437   AVPacket pkt;
1438   GstPad *srcpad;
1439   GstFFStream *stream;
1440   AVStream *avstream;
1441   GstBuffer *outbuf = NULL;
1442   GstClockTime timestamp, duration;
1443   gint outsize;
1444   gboolean rawvideo;
1445   GstFlowReturn stream_last_flow;
1446   gint64 pts;
1447
1448   /* open file if we didn't so already */
1449   if (!demux->opened)
1450     if (!gst_ffmpegdemux_open (demux))
1451       goto open_failed;
1452
1453   GST_DEBUG_OBJECT (demux, "about to read a frame");
1454
1455   /* read a frame */
1456   res = av_read_frame (demux->context, &pkt);
1457   if (res < 0)
1458     goto read_failed;
1459
1460   /* get the stream */
1461   stream =
1462       gst_ffmpegdemux_get_stream (demux,
1463       demux->context->streams[pkt.stream_index]);
1464
1465   /* check if we know the stream */
1466   if (stream->unknown)
1467     goto done;
1468
1469   /* get more stuff belonging to this stream */
1470   avstream = stream->avstream;
1471
1472   /* do timestamps, we do this first so that we can know when we
1473    * stepped over the segment stop position. */
1474   pts = pkt.pts;
1475   if (G_UNLIKELY (pts < 0)) {
1476     /* some streams have pts such this:
1477      * 0
1478      * -2
1479      * -1
1480      * 1
1481      *
1482      * we reset pts to 0 since for us timestamp are unsigned
1483      */
1484     GST_WARNING_OBJECT (demux,
1485         "negative pts detected: %" G_GINT64_FORMAT " resetting to 0", pts);
1486     pts = 0;
1487   }
1488   timestamp = gst_ffmpeg_time_ff_to_gst (pts, avstream->time_base);
1489   if (GST_CLOCK_TIME_IS_VALID (timestamp)) {
1490     stream->last_ts = timestamp;
1491   }
1492   duration = gst_ffmpeg_time_ff_to_gst (pkt.duration, avstream->time_base);
1493   if (G_UNLIKELY (!duration)) {
1494     GST_WARNING_OBJECT (demux, "invalid buffer duration, setting to NONE");
1495     duration = GST_CLOCK_TIME_NONE;
1496   }
1497
1498
1499   GST_DEBUG_OBJECT (demux,
1500       "pkt pts:%" GST_TIME_FORMAT
1501       " / size:%d / stream_index:%d / flags:%d / duration:%" GST_TIME_FORMAT
1502       " / pos:%" G_GINT64_FORMAT, GST_TIME_ARGS (timestamp), pkt.size,
1503       pkt.stream_index, pkt.flags, GST_TIME_ARGS (duration), (gint64) pkt.pos);
1504
1505   /* check start_time */
1506 #if 0
1507   if (demux->start_time != -1 && demux->start_time > timestamp)
1508     goto drop;
1509 #endif
1510
1511   if (GST_CLOCK_TIME_IS_VALID (timestamp)) {
1512     /* start_time should be the ts of the first frame but it may actually be
1513      * higher because of rounding when converting to gst ts. */
1514     if (demux->start_time >= timestamp)
1515       timestamp = 0;
1516     else
1517       timestamp -= demux->start_time;
1518   }
1519
1520   /* check if we ran outside of the segment */
1521   if (demux->segment.stop != -1 && timestamp > demux->segment.stop)
1522     goto drop;
1523
1524   /* prepare to push packet to peer */
1525   srcpad = stream->pad;
1526
1527   rawvideo = (avstream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1528       avstream->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO);
1529
1530   if (rawvideo)
1531     outsize = gst_ffmpeg_avpicture_get_size (avstream->codecpar->format,
1532         avstream->codecpar->width, avstream->codecpar->height);
1533   else
1534     outsize = pkt.size;
1535
1536   outbuf = gst_buffer_new_and_alloc (outsize);
1537
1538   /* copy the data from packet into the target buffer
1539    * and do conversions for raw video packets */
1540   if (rawvideo) {
1541     AVFrame src, dst;
1542     const gchar *plugin_name =
1543         ((GstFFMpegDemuxClass *) (G_OBJECT_GET_CLASS (demux)))->in_plugin->name;
1544     GstMapInfo map;
1545
1546     GST_WARNING ("Unknown demuxer %s, no idea what to do", plugin_name);
1547     gst_ffmpeg_avpicture_fill (&src, pkt.data,
1548         avstream->codecpar->format, avstream->codecpar->width,
1549         avstream->codecpar->height);
1550
1551     gst_buffer_map (outbuf, &map, GST_MAP_WRITE);
1552     gst_ffmpeg_avpicture_fill (&dst, map.data,
1553         avstream->codecpar->format, avstream->codecpar->width,
1554         avstream->codecpar->height);
1555
1556     av_image_copy (dst.data, dst.linesize, (const uint8_t **) src.data,
1557         src.linesize, avstream->codecpar->format, avstream->codecpar->width,
1558         avstream->codecpar->height);
1559     gst_buffer_unmap (outbuf, &map);
1560   } else {
1561     gst_buffer_fill (outbuf, 0, pkt.data, outsize);
1562   }
1563
1564   GST_BUFFER_TIMESTAMP (outbuf) = timestamp;
1565   GST_BUFFER_DURATION (outbuf) = duration;
1566
1567   /* mark keyframes */
1568   if (!(pkt.flags & AV_PKT_FLAG_KEY)) {
1569     GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DELTA_UNIT);
1570   }
1571
1572   /* Mark discont */
1573   if (stream->discont) {
1574     GST_DEBUG_OBJECT (demux, "marking DISCONT");
1575     GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT);
1576     stream->discont = FALSE;
1577   }
1578
1579   GST_DEBUG_OBJECT (demux,
1580       "Sending out buffer time:%" GST_TIME_FORMAT " size:%" G_GSIZE_FORMAT,
1581       GST_TIME_ARGS (timestamp), gst_buffer_get_size (outbuf));
1582
1583   ret = stream_last_flow = gst_pad_push (srcpad, outbuf);
1584
1585   /* if a pad is in e.g. WRONG_STATE, we want to pause to unlock the STREAM_LOCK */
1586   if (((ret = gst_flow_combiner_update_flow (demux->flowcombiner,
1587                   ret)) != GST_FLOW_OK)) {
1588     GST_WARNING_OBJECT (demux, "stream_movi flow: %s / %s",
1589         gst_flow_get_name (stream_last_flow), gst_flow_get_name (ret));
1590     goto pause;
1591   }
1592
1593 done:
1594   /* can destroy the packet now */
1595   if (res == 0) {
1596     av_packet_unref (&pkt);
1597   }
1598
1599   return;
1600
1601   /* ERRORS */
1602 pause:
1603   {
1604     GST_LOG_OBJECT (demux, "pausing task, reason %d (%s)", ret,
1605         gst_flow_get_name (ret));
1606     if (demux->seekable)
1607       gst_pad_pause_task (demux->sinkpad);
1608     else {
1609       GstFFMpegPipe *ffpipe = &demux->ffpipe;
1610
1611       GST_FFMPEG_PIPE_MUTEX_LOCK (ffpipe);
1612       /* pause task and make sure loop stops */
1613       gst_task_pause (demux->task);
1614       g_rec_mutex_lock (&demux->task_lock);
1615       g_rec_mutex_unlock (&demux->task_lock);
1616       demux->ffpipe.srcresult = ret;
1617       GST_FFMPEG_PIPE_MUTEX_UNLOCK (ffpipe);
1618     }
1619
1620     if (ret == GST_FLOW_EOS) {
1621       if (demux->segment.flags & GST_SEEK_FLAG_SEGMENT) {
1622         gint64 stop;
1623
1624         if ((stop = demux->segment.stop) == -1)
1625           stop = demux->segment.duration;
1626
1627         GST_LOG_OBJECT (demux, "posting segment done");
1628         gst_element_post_message (GST_ELEMENT (demux),
1629             gst_message_new_segment_done (GST_OBJECT (demux),
1630                 demux->segment.format, stop));
1631         gst_ffmpegdemux_push_event (demux,
1632             gst_event_new_segment_done (demux->segment.format, stop));
1633       } else {
1634         GST_LOG_OBJECT (demux, "pushing eos");
1635         gst_ffmpegdemux_push_event (demux, gst_event_new_eos ());
1636       }
1637     } else if (ret == GST_FLOW_NOT_LINKED || ret < GST_FLOW_EOS) {
1638       GST_ELEMENT_FLOW_ERROR (demux, ret);
1639       gst_ffmpegdemux_push_event (demux, gst_event_new_eos ());
1640     }
1641     goto done;
1642   }
1643 open_failed:
1644   {
1645     ret = GST_FLOW_ERROR;
1646     goto pause;
1647   }
1648 read_failed:
1649   {
1650     /* something went wrong... */
1651     GST_WARNING_OBJECT (demux, "av_read_frame returned %d", res);
1652
1653     GST_OBJECT_LOCK (demux);
1654     /* pause appropriatly based on if we are flushing or not */
1655     if (demux->flushing)
1656       ret = GST_FLOW_FLUSHING;
1657     else if (gst_ffmpegdemux_has_outputted (demux)
1658         || gst_ffmpegdemux_is_eos (demux)) {
1659       GST_DEBUG_OBJECT (demux, "We are EOS");
1660       ret = GST_FLOW_EOS;
1661     } else
1662       ret = GST_FLOW_ERROR;
1663     GST_OBJECT_UNLOCK (demux);
1664
1665     goto pause;
1666   }
1667 drop:
1668   {
1669     GST_DEBUG_OBJECT (demux, "dropping buffer out of segment, stream eos");
1670     stream->eos = TRUE;
1671     if (gst_ffmpegdemux_is_eos (demux)) {
1672       av_packet_unref (&pkt);
1673       GST_DEBUG_OBJECT (demux, "we are eos");
1674       ret = GST_FLOW_EOS;
1675       goto pause;
1676     } else {
1677       GST_DEBUG_OBJECT (demux, "some streams are not yet eos");
1678       goto done;
1679     }
1680   }
1681 }
1682
1683
1684 static gboolean
1685 gst_ffmpegdemux_sink_event (GstPad * sinkpad, GstObject * parent,
1686     GstEvent * event)
1687 {
1688   GstFFMpegDemux *demux;
1689   GstFFMpegPipe *ffpipe;
1690   gboolean result = TRUE;
1691
1692   demux = (GstFFMpegDemux *) parent;
1693   ffpipe = &(demux->ffpipe);
1694
1695   GST_LOG_OBJECT (demux, "event: %" GST_PTR_FORMAT, event);
1696
1697   switch (GST_EVENT_TYPE (event)) {
1698     case GST_EVENT_FLUSH_START:
1699       /* forward event */
1700       gst_pad_event_default (sinkpad, parent, event);
1701
1702       /* now unblock the chain function */
1703       GST_FFMPEG_PIPE_MUTEX_LOCK (ffpipe);
1704       ffpipe->srcresult = GST_FLOW_FLUSHING;
1705       GST_FFMPEG_PIPE_SIGNAL (ffpipe);
1706       GST_FFMPEG_PIPE_MUTEX_UNLOCK (ffpipe);
1707
1708       /* loop might run into WRONG_STATE and end itself,
1709        * but may also be waiting in a ffmpeg read
1710        * trying to break that would make ffmpeg believe eos,
1711        * so no harm to have the loop 'pausing' there ... */
1712       goto done;
1713     case GST_EVENT_FLUSH_STOP:
1714       /* forward event */
1715       gst_pad_event_default (sinkpad, parent, event);
1716
1717       GST_OBJECT_LOCK (demux);
1718       g_list_foreach (demux->cached_events, (GFunc) gst_mini_object_unref,
1719           NULL);
1720       g_list_free (demux->cached_events);
1721       GST_OBJECT_UNLOCK (demux);
1722       GST_FFMPEG_PIPE_MUTEX_LOCK (ffpipe);
1723       gst_adapter_clear (ffpipe->adapter);
1724       ffpipe->srcresult = GST_FLOW_OK;
1725       /* loop may have decided to end itself as a result of flush WRONG_STATE */
1726       gst_task_start (demux->task);
1727       demux->flushing = FALSE;
1728       GST_LOG_OBJECT (demux, "loop started");
1729       GST_FFMPEG_PIPE_MUTEX_UNLOCK (ffpipe);
1730       goto done;
1731     case GST_EVENT_EOS:
1732       /* inform the src task that it can stop now */
1733       GST_FFMPEG_PIPE_MUTEX_LOCK (ffpipe);
1734       ffpipe->eos = TRUE;
1735       GST_FFMPEG_PIPE_SIGNAL (ffpipe);
1736       GST_FFMPEG_PIPE_MUTEX_UNLOCK (ffpipe);
1737
1738       /* eat this event for now, task will send eos when finished */
1739       gst_event_unref (event);
1740       goto done;
1741     case GST_EVENT_STREAM_START:
1742     case GST_EVENT_CAPS:
1743     case GST_EVENT_SEGMENT:
1744       GST_LOG_OBJECT (demux, "dropping %s event", GST_EVENT_TYPE_NAME (event));
1745       gst_event_unref (event);
1746       goto done;
1747     default:
1748       /* for a serialized event, wait until an earlier data is gone,
1749        * though this is no guarantee as to when task is done with it.
1750        *
1751        * If the demuxer isn't opened, push straight away, since we'll
1752        * be waiting against a cond that will never be signalled. */
1753       if (GST_EVENT_IS_SERIALIZED (event)) {
1754         if (demux->opened) {
1755           GST_FFMPEG_PIPE_MUTEX_LOCK (ffpipe);
1756           while (!ffpipe->needed)
1757             GST_FFMPEG_PIPE_WAIT (ffpipe);
1758           GST_FFMPEG_PIPE_MUTEX_UNLOCK (ffpipe);
1759         } else {
1760           /* queue events and send them later (esp. tag events) */
1761           GST_OBJECT_LOCK (demux);
1762           demux->cached_events = g_list_append (demux->cached_events, event);
1763           GST_OBJECT_UNLOCK (demux);
1764           goto done;
1765         }
1766       }
1767       break;
1768   }
1769
1770   result = gst_pad_event_default (sinkpad, parent, event);
1771
1772 done:
1773
1774   return result;
1775 }
1776
1777 static GstFlowReturn
1778 gst_ffmpegdemux_chain (GstPad * sinkpad, GstObject * parent, GstBuffer * buffer)
1779 {
1780   GstFFMpegDemux *demux;
1781   GstFFMpegPipe *ffpipe;
1782
1783   demux = (GstFFMpegDemux *) parent;
1784   ffpipe = &demux->ffpipe;
1785
1786   GST_FFMPEG_PIPE_MUTEX_LOCK (ffpipe);
1787
1788   if (G_UNLIKELY (ffpipe->eos))
1789     goto eos;
1790
1791   if (G_UNLIKELY (ffpipe->srcresult != GST_FLOW_OK))
1792     goto ignore;
1793
1794   GST_DEBUG ("Giving a buffer of %" G_GSIZE_FORMAT " bytes",
1795       gst_buffer_get_size (buffer));
1796   gst_adapter_push (ffpipe->adapter, buffer);
1797   buffer = NULL;
1798   while (gst_adapter_available (ffpipe->adapter) >= ffpipe->needed) {
1799     GST_DEBUG ("Adapter has more that requested (ffpipe->needed:%d)",
1800         ffpipe->needed);
1801     GST_FFMPEG_PIPE_SIGNAL (ffpipe);
1802     GST_FFMPEG_PIPE_WAIT (ffpipe);
1803     /* may have become flushing */
1804     if (G_UNLIKELY (ffpipe->srcresult != GST_FLOW_OK))
1805       goto ignore;
1806   }
1807
1808   GST_FFMPEG_PIPE_MUTEX_UNLOCK (ffpipe);
1809
1810   return GST_FLOW_OK;
1811
1812 /* special cases */
1813 eos:
1814   {
1815     GST_DEBUG_OBJECT (demux, "ignoring buffer at end-of-stream");
1816     GST_FFMPEG_PIPE_MUTEX_UNLOCK (ffpipe);
1817
1818     gst_buffer_unref (buffer);
1819     return GST_FLOW_EOS;
1820   }
1821 ignore:
1822   {
1823     GST_DEBUG_OBJECT (demux, "ignoring buffer because src task encountered %s",
1824         gst_flow_get_name (ffpipe->srcresult));
1825     GST_FFMPEG_PIPE_MUTEX_UNLOCK (ffpipe);
1826
1827     if (buffer)
1828       gst_buffer_unref (buffer);
1829     return GST_FLOW_FLUSHING;
1830   }
1831 }
1832
1833 static gboolean
1834 gst_ffmpegdemux_sink_activate (GstPad * sinkpad, GstObject * parent)
1835 {
1836   GstQuery *query;
1837   gboolean pull_mode;
1838   GstSchedulingFlags flags;
1839
1840   query = gst_query_new_scheduling ();
1841
1842   if (!gst_pad_peer_query (sinkpad, query)) {
1843     gst_query_unref (query);
1844     goto activate_push;
1845   }
1846
1847   pull_mode = gst_query_has_scheduling_mode_with_flags (query,
1848       GST_PAD_MODE_PULL, GST_SCHEDULING_FLAG_SEEKABLE);
1849
1850   gst_query_parse_scheduling (query, &flags, NULL, NULL, NULL);
1851   if (flags & GST_SCHEDULING_FLAG_SEQUENTIAL)
1852     pull_mode = FALSE;
1853
1854   gst_query_unref (query);
1855
1856   if (!pull_mode)
1857     goto activate_push;
1858
1859   GST_DEBUG_OBJECT (sinkpad, "activating pull");
1860   return gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PULL, TRUE);
1861
1862 activate_push:
1863   {
1864     GST_DEBUG_OBJECT (sinkpad, "activating push");
1865     return gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PUSH, TRUE);
1866   }
1867 }
1868
1869 /* push mode:
1870  * - not seekable
1871  * - use gstpipe protocol, like ffmpeg's pipe protocol
1872  * - (independently managed) task driving ffmpeg
1873  */
1874 static gboolean
1875 gst_ffmpegdemux_sink_activate_push (GstPad * sinkpad, GstObject * parent,
1876     gboolean active)
1877 {
1878   GstFFMpegDemux *demux;
1879   gboolean res = FALSE;
1880
1881   demux = (GstFFMpegDemux *) (parent);
1882
1883   if (active) {
1884     if (demux->can_push == FALSE) {
1885       GST_WARNING_OBJECT (demux, "Demuxer can't reliably operate in push-mode");
1886       goto beach;
1887     }
1888     demux->ffpipe.eos = FALSE;
1889     demux->ffpipe.srcresult = GST_FLOW_OK;
1890     demux->ffpipe.needed = 0;
1891     demux->seekable = FALSE;
1892     res = gst_task_start (demux->task);
1893   } else {
1894     GstFFMpegPipe *ffpipe = &demux->ffpipe;
1895
1896     /* release chain and loop */
1897     GST_FFMPEG_PIPE_MUTEX_LOCK (ffpipe);
1898     demux->ffpipe.srcresult = GST_FLOW_FLUSHING;
1899     /* end streaming by making ffmpeg believe eos */
1900     demux->ffpipe.eos = TRUE;
1901     GST_FFMPEG_PIPE_SIGNAL (ffpipe);
1902     GST_FFMPEG_PIPE_MUTEX_UNLOCK (ffpipe);
1903
1904     /* make sure streaming ends */
1905     gst_task_stop (demux->task);
1906     g_rec_mutex_lock (&demux->task_lock);
1907     g_rec_mutex_unlock (&demux->task_lock);
1908     res = gst_task_join (demux->task);
1909     demux->seekable = FALSE;
1910   }
1911
1912 beach:
1913   return res;
1914 }
1915
1916 /* pull mode:
1917  * - seekable
1918  * - use gstreamer protocol, like ffmpeg's file protocol
1919  * - task driving ffmpeg based on sink pad
1920  */
1921 static gboolean
1922 gst_ffmpegdemux_sink_activate_pull (GstPad * sinkpad, GstObject * parent,
1923     gboolean active)
1924 {
1925   GstFFMpegDemux *demux;
1926   gboolean res;
1927
1928   demux = (GstFFMpegDemux *) parent;
1929
1930   if (active) {
1931     demux->seekable = TRUE;
1932     res = gst_pad_start_task (sinkpad, (GstTaskFunction) gst_ffmpegdemux_loop,
1933         demux, NULL);
1934   } else {
1935     res = gst_pad_stop_task (sinkpad);
1936     demux->seekable = FALSE;
1937   }
1938
1939   return res;
1940 }
1941
1942 static gboolean
1943 gst_ffmpegdemux_sink_activate_mode (GstPad * sinkpad, GstObject * parent,
1944     GstPadMode mode, gboolean active)
1945 {
1946   gboolean res;
1947
1948   switch (mode) {
1949     case GST_PAD_MODE_PUSH:
1950       res = gst_ffmpegdemux_sink_activate_push (sinkpad, parent, active);
1951       break;
1952     case GST_PAD_MODE_PULL:
1953       res = gst_ffmpegdemux_sink_activate_pull (sinkpad, parent, active);
1954       break;
1955     default:
1956       res = FALSE;
1957       break;
1958   }
1959   return res;
1960 }
1961
1962 static GstStateChangeReturn
1963 gst_ffmpegdemux_change_state (GstElement * element, GstStateChange transition)
1964 {
1965   GstFFMpegDemux *demux = (GstFFMpegDemux *) (element);
1966   GstStateChangeReturn ret;
1967
1968   switch (transition) {
1969     case GST_STATE_CHANGE_READY_TO_PAUSED:
1970 #if 0
1971       /* test seek in READY here */
1972       gst_element_send_event (element, gst_event_new_seek (1.0,
1973               GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,
1974               GST_SEEK_TYPE_SET, 10 * GST_SECOND,
1975               GST_SEEK_TYPE_SET, 13 * GST_SECOND));
1976 #endif
1977       break;
1978     default:
1979       break;
1980   }
1981
1982   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
1983
1984   switch (transition) {
1985     case GST_STATE_CHANGE_PAUSED_TO_READY:
1986       gst_ffmpegdemux_close (demux);
1987       gst_adapter_clear (demux->ffpipe.adapter);
1988       g_list_foreach (demux->cached_events, (GFunc) gst_mini_object_unref,
1989           NULL);
1990       g_list_free (demux->cached_events);
1991       demux->cached_events = NULL;
1992       demux->have_group_id = FALSE;
1993       demux->group_id = G_MAXUINT;
1994       break;
1995     default:
1996       break;
1997   }
1998
1999   return ret;
2000 }
2001
2002 gboolean
2003 gst_ffmpegdemux_register (GstPlugin * plugin)
2004 {
2005   GType type;
2006   const AVInputFormat *in_plugin;
2007   gchar *extensions;
2008   GTypeInfo typeinfo = {
2009     sizeof (GstFFMpegDemuxClass),
2010     (GBaseInitFunc) gst_ffmpegdemux_base_init,
2011     NULL,
2012     (GClassInitFunc) gst_ffmpegdemux_class_init,
2013     NULL,
2014     NULL,
2015     sizeof (GstFFMpegDemux),
2016     0,
2017     (GInstanceInitFunc) gst_ffmpegdemux_init,
2018   };
2019
2020   void *i = 0;
2021
2022   GST_LOG ("Registering demuxers");
2023
2024   while ((in_plugin = av_demuxer_iterate (&i))) {
2025     gchar *type_name, *typefind_name;
2026     gint rank;
2027     gboolean register_typefind_func = TRUE;
2028
2029     GST_LOG ("Attempting to handle libav demuxer plugin %s [%s]",
2030         in_plugin->name, in_plugin->long_name);
2031
2032     /* no emulators */
2033     if (in_plugin->long_name != NULL) {
2034       if (!strncmp (in_plugin->long_name, "raw ", 4) ||
2035           !strncmp (in_plugin->long_name, "pcm ", 4)
2036           )
2037         continue;
2038     }
2039
2040     if (!strcmp (in_plugin->name, "audio_device") ||
2041         !strncmp (in_plugin->name, "image", 5) ||
2042         !strcmp (in_plugin->name, "mpegvideo") ||
2043         !strcmp (in_plugin->name, "mjpeg") ||
2044         !strcmp (in_plugin->name, "redir") ||
2045         !strncmp (in_plugin->name, "u8", 2) ||
2046         !strncmp (in_plugin->name, "u16", 3) ||
2047         !strncmp (in_plugin->name, "u24", 3) ||
2048         !strncmp (in_plugin->name, "u32", 3) ||
2049         !strncmp (in_plugin->name, "s8", 2) ||
2050         !strncmp (in_plugin->name, "s16", 3) ||
2051         !strncmp (in_plugin->name, "s24", 3) ||
2052         !strncmp (in_plugin->name, "s32", 3) ||
2053         !strncmp (in_plugin->name, "f32", 3) ||
2054         !strncmp (in_plugin->name, "f64", 3) ||
2055         !strcmp (in_plugin->name, "mulaw") || !strcmp (in_plugin->name, "alaw")
2056         )
2057       continue;
2058
2059     /* no network demuxers */
2060     if (!strcmp (in_plugin->name, "sdp") ||
2061         !strcmp (in_plugin->name, "rtsp") ||
2062         !strcmp (in_plugin->name, "applehttp")
2063         )
2064       continue;
2065
2066     /* these don't do what one would expect or
2067      * are only partially functional/useful */
2068     if (!strcmp (in_plugin->name, "aac") ||
2069         !strcmp (in_plugin->name, "wv") ||
2070         !strcmp (in_plugin->name, "ass") ||
2071         !strcmp (in_plugin->name, "ffmetadata"))
2072       continue;
2073
2074     /* Don't use the typefind functions of formats for which we already have
2075      * better typefind functions */
2076     if (!strcmp (in_plugin->name, "mov,mp4,m4a,3gp,3g2,mj2") ||
2077         !strcmp (in_plugin->name, "ass") ||
2078         !strcmp (in_plugin->name, "avi") ||
2079         !strcmp (in_plugin->name, "asf") ||
2080         !strcmp (in_plugin->name, "mpegvideo") ||
2081         !strcmp (in_plugin->name, "mp3") ||
2082         !strcmp (in_plugin->name, "matroska") ||
2083         !strcmp (in_plugin->name, "matroska_webm") ||
2084         !strcmp (in_plugin->name, "matroska,webm") ||
2085         !strcmp (in_plugin->name, "mpeg") ||
2086         !strcmp (in_plugin->name, "wav") ||
2087         !strcmp (in_plugin->name, "au") ||
2088         !strcmp (in_plugin->name, "tta") ||
2089         !strcmp (in_plugin->name, "rm") ||
2090         !strcmp (in_plugin->name, "amr") ||
2091         !strcmp (in_plugin->name, "ogg") ||
2092         !strcmp (in_plugin->name, "aiff") ||
2093         !strcmp (in_plugin->name, "ape") ||
2094         !strcmp (in_plugin->name, "dv") ||
2095         !strcmp (in_plugin->name, "flv") ||
2096         !strcmp (in_plugin->name, "mpc") ||
2097         !strcmp (in_plugin->name, "mpc8") ||
2098         !strcmp (in_plugin->name, "mpegts") ||
2099         !strcmp (in_plugin->name, "mpegtsraw") ||
2100         !strcmp (in_plugin->name, "mxf") ||
2101         !strcmp (in_plugin->name, "nuv") ||
2102         !strcmp (in_plugin->name, "swf") ||
2103         !strcmp (in_plugin->name, "voc") ||
2104         !strcmp (in_plugin->name, "pva") ||
2105         !strcmp (in_plugin->name, "gif") ||
2106         !strcmp (in_plugin->name, "vc1test") ||
2107         !strcmp (in_plugin->name, "ivf"))
2108       register_typefind_func = FALSE;
2109
2110     /* Set the rank of demuxers known to work to MARGINAL.
2111      * Set demuxers for which we already have another implementation to NONE
2112      * Set All others to NONE*/
2113     /**
2114      * element-avdemux_xwma
2115      *
2116      * Since: 1.20
2117      */
2118     if (!strcmp (in_plugin->name, "wsvqa") ||
2119         !strcmp (in_plugin->name, "wsaud") ||
2120         !strcmp (in_plugin->name, "wc3movie") ||
2121         !strcmp (in_plugin->name, "voc") ||
2122         !strcmp (in_plugin->name, "tta") ||
2123         !strcmp (in_plugin->name, "sol") ||
2124         !strcmp (in_plugin->name, "smk") ||
2125         !strcmp (in_plugin->name, "vmd") ||
2126         !strcmp (in_plugin->name, "film_cpk") ||
2127         !strcmp (in_plugin->name, "ingenient") ||
2128         !strcmp (in_plugin->name, "psxstr") ||
2129         !strcmp (in_plugin->name, "nuv") ||
2130         !strcmp (in_plugin->name, "nut") ||
2131         !strcmp (in_plugin->name, "nsv") ||
2132         !strcmp (in_plugin->name, "mxf") ||
2133         !strcmp (in_plugin->name, "mmf") ||
2134         !strcmp (in_plugin->name, "mm") ||
2135         !strcmp (in_plugin->name, "ipmovie") ||
2136         !strcmp (in_plugin->name, "ape") ||
2137         !strcmp (in_plugin->name, "RoQ") ||
2138         !strcmp (in_plugin->name, "idcin") ||
2139         !strcmp (in_plugin->name, "gxf") ||
2140         !strcmp (in_plugin->name, "ffm") ||
2141         !strcmp (in_plugin->name, "ea") ||
2142         !strcmp (in_plugin->name, "daud") ||
2143         !strcmp (in_plugin->name, "avs") ||
2144         !strcmp (in_plugin->name, "aiff") ||
2145         !strcmp (in_plugin->name, "xwma") ||
2146         !strcmp (in_plugin->name, "4xm") ||
2147         !strcmp (in_plugin->name, "yuv4mpegpipe") ||
2148         !strcmp (in_plugin->name, "pva") ||
2149         !strcmp (in_plugin->name, "mpc") ||
2150         !strcmp (in_plugin->name, "mpc8") ||
2151         !strcmp (in_plugin->name, "ivf") ||
2152         !strcmp (in_plugin->name, "brstm") ||
2153         !strcmp (in_plugin->name, "bfstm") ||
2154         !strcmp (in_plugin->name, "gif") ||
2155         !strcmp (in_plugin->name, "dsf") || !strcmp (in_plugin->name, "iff"))
2156       rank = GST_RANK_MARGINAL;
2157     else {
2158       GST_DEBUG ("ignoring %s", in_plugin->name);
2159       rank = GST_RANK_NONE;
2160       continue;
2161     }
2162
2163     /* construct the type */
2164     type_name = g_strdup_printf ("avdemux_%s", in_plugin->name);
2165     g_strdelimit (type_name, ".,|-<> ", '_');
2166
2167     /* if it's already registered, drop it */
2168     if (g_type_from_name (type_name)) {
2169       g_free (type_name);
2170       continue;
2171     }
2172
2173     typefind_name = g_strdup_printf ("avtype_%s", in_plugin->name);
2174     g_strdelimit (typefind_name, ".,|-<> ", '_');
2175
2176     /* create the type now */
2177     type = g_type_register_static (GST_TYPE_ELEMENT, type_name, &typeinfo, 0);
2178     g_type_set_qdata (type, GST_FFDEMUX_PARAMS_QDATA, (gpointer) in_plugin);
2179
2180     if (in_plugin->extensions)
2181       extensions = g_strdelimit (g_strdup (in_plugin->extensions), " ", ',');
2182     else
2183       extensions = NULL;
2184
2185     if (!gst_element_register (plugin, type_name, rank, type) ||
2186         (register_typefind_func == TRUE &&
2187             !gst_type_find_register (plugin, typefind_name, rank,
2188                 gst_ffmpegdemux_type_find, extensions, NULL,
2189                 (gpointer) in_plugin, NULL))) {
2190       g_warning ("Registration of type %s failed", type_name);
2191       g_free (type_name);
2192       g_free (typefind_name);
2193       g_free (extensions);
2194       return FALSE;
2195     }
2196
2197     g_free (type_name);
2198     g_free (typefind_name);
2199     g_free (extensions);
2200   }
2201
2202   GST_LOG ("Finished registering demuxers");
2203
2204   return TRUE;
2205 }