gst/realmedia/rmdemux.c

   1 /* GStreamer RealMedia demuxer
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   3  * Copyright (C) <2003> David A. Schleef <ds@schleef.org>
   4  * Copyright (C) <2004> Stephane Loeuillet <gstreamer@leroutier.net>
   5  * Copyright (C) <2005> Owen Fraser-Green <owen@discobabe.net>
   6  * Copyright (C) <2005> Michael Smith <fluendo.com>
   7  * Copyright (C) <2006> Wim Taymans <wim@fluendo.com>
   8  * Copyright (C) <2006> Tim-Philipp Müller <tim centricular net>
   9  * Copyright (C) <2007> Wim Taymans <wim.taymans@gmail.com>
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Library General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Library General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Library General Public
  22  * License along with this library; if not, write to the
  23  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  24  * Boston, MA 02110-1301, USA.
  25  */
  26
  27 #ifdef HAVE_CONFIG_H
  28 #  include "config.h"
  29 #endif
  30
  31 #include "rmdemux.h"
  32 #include "rmutils.h"
  33
  34 #include <string.h>
  35 #include <ctype.h>
  36
  37 #define RMDEMUX_GUINT32_GET(a)  GST_READ_UINT32_BE(a)
  38 #define RMDEMUX_GUINT16_GET(a)  GST_READ_UINT16_BE(a)
  39 #define RMDEMUX_FOURCC_GET(a)   GST_READ_UINT32_LE(a)
  40 #define HEADER_SIZE 10
  41 #define DATA_SIZE 8
  42
  43 #define MAX_FRAGS 256
  44
  45 static const guint8 sipr_subpk_size[4] = { 29, 19, 37, 20 };
  46
  47 typedef struct _GstRMDemuxIndex GstRMDemuxIndex;
  48
  49 struct _GstRMDemuxStream
  50 {
  51   guint32 subtype;
  52   guint32 fourcc;
  53   guint32 subformat;
  54   guint32 format;
  55
  56   int id;
  57   GstPad *pad;
  58   gboolean discont;
  59   int timescale;
  60
  61   int sample_index;
  62   GstRMDemuxIndex *index;
  63   int index_length;
  64   gint framerate_numerator;
  65   gint framerate_denominator;
  66   guint32 seek_offset;
  67
  68   guint16 width;
  69   guint16 height;
  70   guint16 flavor;
  71   guint16 rate;                 /* samplerate         */
  72   guint16 n_channels;           /* channels           */
  73   guint16 sample_width;         /* bits_per_sample    */
  74   guint16 leaf_size;            /* subpacket_size     */
  75   guint32 packet_size;          /* coded_frame_size   */
  76   guint16 version;
  77   guint32 extra_data_size;      /* codec_data_length  */
  78   guint8 *extra_data;           /* extras             */
  79   guint32 bitrate;
  80
  81   gboolean needs_descrambling;
  82   guint subpackets_needed;      /* subpackets needed for descrambling    */
  83   GPtrArray *subpackets;        /* array containing subpacket GstBuffers */
  84
  85   /* Variables needed for fixing timestamps. */
  86   GstClockTime next_ts, last_ts;
  87   guint16 next_seq, last_seq;
  88
  89   gint frag_seqnum;
  90   gint frag_subseq;
  91   guint frag_length;
  92   guint frag_current;
  93   guint frag_count;
  94   guint frag_offset[MAX_FRAGS];
  95   GstAdapter *adapter;
  96
  97   GstTagList *pending_tags;
  98 };
  99
 100 struct _GstRMDemuxIndex
 101 {
 102   guint32 offset;
 103   GstClockTime timestamp;
 104 };
 105
 106 static GstStaticPadTemplate gst_rmdemux_sink_template =
 107 GST_STATIC_PAD_TEMPLATE ("sink",
 108     GST_PAD_SINK,
 109     GST_PAD_ALWAYS,
 110     GST_STATIC_CAPS ("application/vnd.rn-realmedia")
 111     );
 112
 113 static GstStaticPadTemplate gst_rmdemux_videosrc_template =
 114 GST_STATIC_PAD_TEMPLATE ("video_%u",
 115     GST_PAD_SRC,
 116     GST_PAD_SOMETIMES,
 117     GST_STATIC_CAPS_ANY);
 118
 119 static GstStaticPadTemplate gst_rmdemux_audiosrc_template =
 120 GST_STATIC_PAD_TEMPLATE ("audio_%u",
 121     GST_PAD_SRC,
 122     GST_PAD_SOMETIMES,
 123     GST_STATIC_CAPS_ANY);
 124
 125 GST_DEBUG_CATEGORY_STATIC (rmdemux_debug);
 126 #define GST_CAT_DEFAULT rmdemux_debug
 127
 128 static GstElementClass *parent_class = NULL;
 129
 130 static void gst_rmdemux_class_init (GstRMDemuxClass * klass);
 131 static void gst_rmdemux_base_init (GstRMDemuxClass * klass);
 132 static void gst_rmdemux_init (GstRMDemux * rmdemux);
 133 static void gst_rmdemux_finalize (GObject * object);
 134 static GstStateChangeReturn gst_rmdemux_change_state (GstElement * element,
 135     GstStateChange transition);
 136 static GstFlowReturn gst_rmdemux_chain (GstPad * pad, GstObject * parent,
 137     GstBuffer * buffer);
 138 static void gst_rmdemux_loop (GstPad * pad);
 139 static gboolean gst_rmdemux_sink_activate (GstPad * sinkpad,
 140     GstObject * parent);
 141 static gboolean gst_rmdemux_sink_activate_mode (GstPad * sinkpad,
 142     GstObject * parent, GstPadMode mode, gboolean active);
 143 static gboolean gst_rmdemux_sink_event (GstPad * pad, GstObject * parent,
 144     GstEvent * event);
 145 static gboolean gst_rmdemux_src_event (GstPad * pad, GstObject * parent,
 146     GstEvent * event);
 147 static void gst_rmdemux_send_event (GstRMDemux * rmdemux, GstEvent * event);
 148 static gboolean gst_rmdemux_src_query (GstPad * pad, GstObject * parent,
 149     GstQuery * query);
 150 static gboolean gst_rmdemux_perform_seek (GstRMDemux * rmdemux,
 151     GstEvent * event);
 152
 153 static void gst_rmdemux_parse__rmf (GstRMDemux * rmdemux, const guint8 * data,
 154     int length);
 155 static void gst_rmdemux_parse_prop (GstRMDemux * rmdemux, const guint8 * data,
 156     int length);
 157 static void gst_rmdemux_parse_mdpr (GstRMDemux * rmdemux,
 158     const guint8 * data, int length);
 159 static guint gst_rmdemux_parse_indx (GstRMDemux * rmdemux, const guint8 * data,
 160     int length);
 161 static void gst_rmdemux_parse_data (GstRMDemux * rmdemux, const guint8 * data,
 162     int length);
 163 static void gst_rmdemux_parse_cont (GstRMDemux * rmdemux, const guint8 * data,
 164     int length);
 165 static GstFlowReturn gst_rmdemux_parse_packet (GstRMDemux * rmdemux,
 166     GstBuffer * in, guint16 version);
 167 static void gst_rmdemux_parse_indx_data (GstRMDemux * rmdemux,
 168     const guint8 * data, int length);
 169 static void gst_rmdemux_stream_clear_cached_subpackets (GstRMDemux * rmdemux,
 170     GstRMDemuxStream * stream);
 171 static GstRMDemuxStream *gst_rmdemux_get_stream_by_id (GstRMDemux * rmdemux,
 172     int id);
 173
 174 static GType
 175 gst_rmdemux_get_type (void)
 176 {
 177   static GType rmdemux_type = 0;
 178
 179   if (!rmdemux_type) {
 180     static const GTypeInfo rmdemux_info = {
 181       sizeof (GstRMDemuxClass),
 182       (GBaseInitFunc) gst_rmdemux_base_init, NULL,
 183       (GClassInitFunc) gst_rmdemux_class_init,
 184       NULL, NULL, sizeof (GstRMDemux), 0,
 185       (GInstanceInitFunc) gst_rmdemux_init,
 186     };
 187
 188     rmdemux_type =
 189         g_type_register_static (GST_TYPE_ELEMENT, "GstRMDemux", &rmdemux_info,
 190         0);
 191   }
 192   return rmdemux_type;
 193 }
 194
 195 static void
 196 gst_rmdemux_base_init (GstRMDemuxClass * klass)
 197 {
 198   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
 199
 200   gst_element_class_add_pad_template (element_class,
 201       gst_static_pad_template_get (&gst_rmdemux_sink_template));
 202   gst_element_class_add_pad_template (element_class,
 203       gst_static_pad_template_get (&gst_rmdemux_videosrc_template));
 204   gst_element_class_add_pad_template (element_class,
 205       gst_static_pad_template_get (&gst_rmdemux_audiosrc_template));
 206   gst_element_class_set_static_metadata (element_class, "RealMedia Demuxer",
 207       "Codec/Demuxer",
 208       "Demultiplex a RealMedia file into audio and video streams",
 209       "David Schleef <ds@schleef.org>");
 210 }
 211
 212 static void
 213 gst_rmdemux_class_init (GstRMDemuxClass * klass)
 214 {
 215   GObjectClass *gobject_class;
 216   GstElementClass *gstelement_class;
 217
 218   gobject_class = (GObjectClass *) klass;
 219   gstelement_class = (GstElementClass *) klass;
 220
 221   parent_class = g_type_class_peek_parent (klass);
 222
 223   gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_rmdemux_change_state);
 224
 225   GST_DEBUG_CATEGORY_INIT (rmdemux_debug, "rmdemux",
 226       0, "Demuxer for Realmedia streams");
 227
 228   gobject_class->finalize = gst_rmdemux_finalize;
 229 }
 230
 231 static void
 232 gst_rmdemux_finalize (GObject * object)
 233 {
 234   GstRMDemux *rmdemux = GST_RMDEMUX (object);
 235
 236   if (rmdemux->adapter) {
 237     g_object_unref (rmdemux->adapter);
 238     rmdemux->adapter = NULL;
 239   }
 240   if (rmdemux->flowcombiner) {
 241     gst_flow_combiner_free (rmdemux->flowcombiner);
 242     rmdemux->flowcombiner = NULL;
 243   }
 244
 245   GST_CALL_PARENT (G_OBJECT_CLASS, finalize, (object));
 246 }
 247
 248 static void
 249 gst_rmdemux_init (GstRMDemux * rmdemux)
 250 {
 251   rmdemux->sinkpad =
 252       gst_pad_new_from_static_template (&gst_rmdemux_sink_template, "sink");
 253   gst_pad_set_event_function (rmdemux->sinkpad,
 254       GST_DEBUG_FUNCPTR (gst_rmdemux_sink_event));
 255   gst_pad_set_chain_function (rmdemux->sinkpad,
 256       GST_DEBUG_FUNCPTR (gst_rmdemux_chain));
 257   gst_pad_set_activate_function (rmdemux->sinkpad,
 258       GST_DEBUG_FUNCPTR (gst_rmdemux_sink_activate));
 259   gst_pad_set_activatemode_function (rmdemux->sinkpad,
 260       GST_DEBUG_FUNCPTR (gst_rmdemux_sink_activate_mode));
 261
 262   gst_element_add_pad (GST_ELEMENT (rmdemux), rmdemux->sinkpad);
 263
 264   rmdemux->adapter = gst_adapter_new ();
 265   rmdemux->first_ts = GST_CLOCK_TIME_NONE;
 266   rmdemux->base_ts = GST_CLOCK_TIME_NONE;
 267   rmdemux->need_newsegment = TRUE;
 268   rmdemux->have_group_id = FALSE;
 269   rmdemux->group_id = G_MAXUINT;
 270   rmdemux->flowcombiner = gst_flow_combiner_new ();
 271
 272   gst_rm_utils_run_tests ();
 273 }
 274
 275 static gboolean
 276 gst_rmdemux_sink_event (GstPad * pad, GstObject * parent, GstEvent * event)
 277 {
 278   gboolean ret;
 279
 280   switch (GST_EVENT_TYPE (event)) {
 281     case GST_EVENT_SEGMENT:
 282       gst_event_unref (event);
 283       ret = TRUE;
 284       break;
 285     default:
 286       ret = gst_pad_event_default (pad, parent, event);
 287       break;
 288   }
 289   return ret;
 290 }
 291
 292 static gboolean
 293 gst_rmdemux_src_event (GstPad * pad, GstObject * parent, GstEvent * event)
 294 {
 295   gboolean ret = TRUE;
 296
 297   GstRMDemux *rmdemux = GST_RMDEMUX (parent);
 298
 299   GST_LOG_OBJECT (rmdemux, "handling src event");
 300
 301   switch (GST_EVENT_TYPE (event)) {
 302     case GST_EVENT_SEEK:
 303     {
 304       gboolean running;
 305
 306       GST_LOG_OBJECT (rmdemux, "Event on src: SEEK");
 307       /* can't seek if we are not seekable, FIXME could pass the
 308        * seek query upstream after converting it to bytes using
 309        * the average bitrate of the stream. */
 310       if (!rmdemux->seekable) {
 311         ret = FALSE;
 312         GST_DEBUG ("seek on non seekable stream");
 313         goto done_unref;
 314       }
 315
 316       GST_OBJECT_LOCK (rmdemux);
 317       /* check if we can do the seek now */
 318       running = rmdemux->running;
 319       GST_OBJECT_UNLOCK (rmdemux);
 320
 321       /* now do the seek */
 322       if (running) {
 323         ret = gst_rmdemux_perform_seek (rmdemux, event);
 324       } else
 325         ret = TRUE;
 326
 327       gst_event_unref (event);
 328       break;
 329     }
 330     default:
 331       GST_LOG_OBJECT (rmdemux, "Event on src: type=%d", GST_EVENT_TYPE (event));
 332       ret = gst_pad_event_default (pad, parent, event);
 333       break;
 334   }
 335
 336   return ret;
 337
 338 done_unref:
 339   GST_DEBUG ("error handling event");
 340   gst_event_unref (event);
 341   return ret;
 342 }
 343
 344 /* Validate that this looks like a reasonable point to seek to */
 345 static gboolean
 346 gst_rmdemux_validate_offset (GstRMDemux * rmdemux)
 347 {
 348   GstBuffer *buffer;
 349   GstFlowReturn flowret;
 350   guint16 version, length;
 351   gboolean ret = TRUE;
 352   GstMapInfo map;
 353
 354   buffer = NULL;
 355   flowret = gst_pad_pull_range (rmdemux->sinkpad, rmdemux->offset, 4, &buffer);
 356
 357   if (flowret != GST_FLOW_OK) {
 358     GST_DEBUG_OBJECT (rmdemux, "Failed to pull data at offset %d",
 359         rmdemux->offset);
 360     return FALSE;
 361   }
 362   /* TODO: Can we also be seeking to a 'DATA' chunk header? Check this.
 363    * Also, for the case we currently handle, can we check any more? It's pretty
 364    * sucky to not be validating a little more heavily than this... */
 365   /* This should now be the start of a data packet header. That begins with
 366    * a 2-byte 'version' field, which has to be 0 or 1, then a length. I'm not
 367    * certain what values are valid for length, but it must always be at least
 368    * 4 bytes, and we can check that it won't take us past our known total size
 369    */
 370
 371   gst_buffer_map (buffer, &map, GST_MAP_READ);
 372   version = RMDEMUX_GUINT16_GET (map.data);
 373   if (version != 0 && version != 1) {
 374     GST_DEBUG_OBJECT (rmdemux, "Expected version 0 or 1, got %d",
 375         (int) version);
 376     ret = FALSE;
 377   }
 378
 379   length = RMDEMUX_GUINT16_GET (map.data + 2);
 380   /* TODO: Also check against total stream length */
 381   if (length < 4) {
 382     GST_DEBUG_OBJECT (rmdemux, "Expected length >= 4, got %d", (int) length);
 383     ret = FALSE;
 384   }
 385   gst_buffer_unmap (buffer, &map);
 386
 387   if (ret) {
 388     rmdemux->offset += 4;
 389     gst_adapter_clear (rmdemux->adapter);
 390     gst_adapter_push (rmdemux->adapter, buffer);
 391   } else {
 392     GST_WARNING_OBJECT (rmdemux, "Failed to validate seek offset at %d",
 393         rmdemux->offset);
 394     gst_buffer_unref (buffer);
 395   }
 396
 397   return ret;
 398 }
 399
 400 static gboolean
 401 find_seek_offset_bytes (GstRMDemux * rmdemux, guint target)
 402 {
 403   int i;
 404   GSList *cur;
 405   gboolean ret = FALSE;
 406
 407   for (cur = rmdemux->streams; cur; cur = cur->next) {
 408     GstRMDemuxStream *stream = cur->data;
 409
 410     /* Search backwards through this stream's index until we find the first
 411      * timestamp before our target time */
 412     for (i = stream->index_length - 1; i >= 0; i--) {
 413       if (stream->index[i].offset <= target) {
 414         /* Set the seek_offset for the stream so we don't bother parsing it
 415          * until we've passed that point */
 416         stream->seek_offset = stream->index[i].offset;
 417         rmdemux->offset = stream->index[i].offset;
 418         ret = TRUE;
 419         break;
 420       }
 421     }
 422   }
 423   return ret;
 424 }
 425
 426 static gboolean
 427 find_seek_offset_time (GstRMDemux * rmdemux, GstClockTime time)
 428 {
 429   int i, n_stream;
 430   gboolean ret = FALSE;
 431   GSList *cur;
 432   GstClockTime earliest = GST_CLOCK_TIME_NONE;
 433
 434   n_stream = 0;
 435   for (cur = rmdemux->streams; cur; cur = cur->next, n_stream++) {
 436     GstRMDemuxStream *stream = cur->data;
 437
 438     /* Search backwards through this stream's index until we find the first
 439      * timestamp before our target time */
 440     for (i = stream->index_length - 1; i >= 0; i--) {
 441       if (stream->index[i].timestamp <= time) {
 442         /* Set the seek_offset for the stream so we don't bother parsing it
 443          * until we've passed that point */
 444         stream->seek_offset = stream->index[i].offset;
 445
 446         /* If it's also the earliest timestamp we've seen of all streams, then
 447          * that's our target!
 448          */
 449         if (earliest == GST_CLOCK_TIME_NONE ||
 450             stream->index[i].timestamp < earliest) {
 451           earliest = stream->index[i].timestamp;
 452           rmdemux->offset = stream->index[i].offset;
 453           GST_DEBUG_OBJECT (rmdemux,
 454               "We're looking for %" GST_TIME_FORMAT
 455               " and we found that stream %d has the latest index at %"
 456               GST_TIME_FORMAT, GST_TIME_ARGS (rmdemux->segment.start), n_stream,
 457               GST_TIME_ARGS (earliest));
 458         }
 459
 460         ret = TRUE;
 461
 462         break;
 463       }
 464     }
 465     stream->discont = TRUE;
 466   }
 467   return ret;
 468 }
 469
 470 static gboolean
 471 gst_rmdemux_perform_seek (GstRMDemux * rmdemux, GstEvent * event)
 472 {
 473   gboolean validated;
 474   gboolean ret = TRUE;
 475   gboolean flush;
 476   GstFormat format;
 477   gdouble rate;
 478   GstSeekFlags flags;
 479   GstSeekType cur_type, stop_type;
 480   gint64 cur, stop;
 481   gboolean update;
 482
 483   if (event) {
 484     GST_DEBUG_OBJECT (rmdemux, "seek with event");
 485
 486     gst_event_parse_seek (event, &rate, &format, &flags,
 487         &cur_type, &cur, &stop_type, &stop);
 488
 489     /* we can only seek on time */
 490     if (format != GST_FORMAT_TIME) {
 491       GST_DEBUG_OBJECT (rmdemux, "can only seek on TIME");
 492       goto error;
 493     }
 494     /* cannot yet do backwards playback */
 495     if (rate <= 0.0) {
 496       GST_DEBUG_OBJECT (rmdemux, "can only seek with positive rate, not %lf",
 497           rate);
 498       goto error;
 499     }
 500   } else {
 501     GST_DEBUG_OBJECT (rmdemux, "seek without event");
 502
 503     flags = 0;
 504     rate = 1.0;
 505   }
 506
 507   GST_DEBUG_OBJECT (rmdemux, "seek, rate %g", rate);
 508
 509   flush = flags & GST_SEEK_FLAG_FLUSH;
 510
 511   /* first step is to unlock the streaming thread if it is
 512    * blocked in a chain call, we do this by starting the flush. */
 513   if (flush) {
 514     gst_pad_push_event (rmdemux->sinkpad, gst_event_new_flush_start ());
 515     gst_rmdemux_send_event (rmdemux, gst_event_new_flush_start ());
 516   } else {
 517     gst_pad_pause_task (rmdemux->sinkpad);
 518   }
 519
 520   GST_LOG_OBJECT (rmdemux, "Done starting flushes");
 521
 522   /* now grab the stream lock so that streaming cannot continue, for
 523    * non flushing seeks when the element is in PAUSED this could block
 524    * forever. */
 525   GST_PAD_STREAM_LOCK (rmdemux->sinkpad);
 526
 527   GST_LOG_OBJECT (rmdemux, "Took streamlock");
 528
 529   if (event) {
 530     gst_segment_do_seek (&rmdemux->segment, rate, format, flags,
 531         cur_type, cur, stop_type, stop, &update);
 532   }
 533
 534   GST_DEBUG_OBJECT (rmdemux, "segment positions set to %" GST_TIME_FORMAT "-%"
 535       GST_TIME_FORMAT, GST_TIME_ARGS (rmdemux->segment.start),
 536       GST_TIME_ARGS (rmdemux->segment.stop));
 537
 538   /* we need to stop flushing on the sinkpad as we're going to use it
 539    * next. We can do this as we have the STREAM lock now. */
 540   gst_pad_push_event (rmdemux->sinkpad, gst_event_new_flush_stop (TRUE));
 541
 542   GST_LOG_OBJECT (rmdemux, "Pushed FLUSH_STOP event");
 543
 544   /* For each stream, find the first index offset equal to or before our seek
 545    * target. Of these, find the smallest offset. That's where we seek to.
 546    *
 547    * Then we pull 4 bytes from that offset, and validate that we've seeked to a
 548    * what looks like a plausible packet.
 549    * If that fails, restart, with the seek target set to one less than the
 550    * offset we just tried. If we run out of places to try, treat that as a fatal
 551    * error.
 552    */
 553   if (!find_seek_offset_time (rmdemux, rmdemux->segment.position)) {
 554     GST_LOG_OBJECT (rmdemux, "Failed to find seek offset by time");
 555     ret = FALSE;
 556     goto done;
 557   }
 558
 559   GST_LOG_OBJECT (rmdemux, "Validating offset %u", rmdemux->offset);
 560   validated = gst_rmdemux_validate_offset (rmdemux);
 561   while (!validated) {
 562     GST_INFO_OBJECT (rmdemux, "Failed to validate offset at %u",
 563         rmdemux->offset);
 564     if (!find_seek_offset_bytes (rmdemux, rmdemux->offset - 1)) {
 565       ret = FALSE;
 566       goto done;
 567     }
 568     validated = gst_rmdemux_validate_offset (rmdemux);
 569   }
 570
 571   GST_LOG_OBJECT (rmdemux, "Found final offset. Excellent!");
 572
 573   /* now we have a new position, prepare for streaming again */
 574   {
 575     /* Reset the demuxer state */
 576     rmdemux->state = RMDEMUX_STATE_DATA_PACKET;
 577
 578     if (flush)
 579       gst_rmdemux_send_event (rmdemux, gst_event_new_flush_stop (TRUE));
 580
 581     /* must send newsegment event from streaming thread, so just set flag */
 582     rmdemux->need_newsegment = TRUE;
 583
 584     /* notify start of new segment */
 585     if (rmdemux->segment.flags & GST_SEEK_FLAG_SEGMENT) {
 586       gst_element_post_message (GST_ELEMENT_CAST (rmdemux),
 587           gst_message_new_segment_start (GST_OBJECT_CAST (rmdemux),
 588               GST_FORMAT_TIME, rmdemux->segment.position));
 589     }
 590
 591     /* restart our task since it might have been stopped when we did the
 592      * flush. */
 593     gst_pad_start_task (rmdemux->sinkpad, (GstTaskFunction) gst_rmdemux_loop,
 594         rmdemux->sinkpad, NULL);
 595   }
 596
 597 done:
 598   /* streaming can continue now */
 599   GST_PAD_STREAM_UNLOCK (rmdemux->sinkpad);
 600
 601   return ret;
 602
 603 error:
 604   {
 605     GST_DEBUG_OBJECT (rmdemux, "seek failed");
 606     return FALSE;
 607   }
 608 }
 609
 610
 611 static gboolean
 612 gst_rmdemux_src_query (GstPad * pad, GstObject * parent, GstQuery * query)
 613 {
 614   gboolean res = FALSE;
 615   GstRMDemux *rmdemux;
 616
 617   rmdemux = GST_RMDEMUX (parent);
 618
 619   switch (GST_QUERY_TYPE (query)) {
 620     case GST_QUERY_POSITION:
 621       GST_DEBUG_OBJECT (rmdemux, "Position query: no idea from demuxer!");
 622       break;
 623     case GST_QUERY_DURATION:{
 624       GstFormat fmt;
 625
 626       gst_query_parse_duration (query, &fmt, NULL);
 627       if (fmt == GST_FORMAT_TIME) {
 628         GST_OBJECT_LOCK (rmdemux);
 629         if (G_LIKELY (rmdemux->running)) {
 630           gst_query_set_duration (query, GST_FORMAT_TIME, rmdemux->duration);
 631           GST_DEBUG_OBJECT (rmdemux, "duration set to %" GST_TIME_FORMAT,
 632               GST_TIME_ARGS (rmdemux->duration));
 633           res = TRUE;
 634         }
 635         GST_OBJECT_UNLOCK (rmdemux);
 636       }
 637       break;
 638     }
 639     case GST_QUERY_SEEKING:{
 640       GstFormat fmt;
 641
 642       gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL);
 643       if (fmt == GST_FORMAT_TIME) {
 644         GST_OBJECT_LOCK (rmdemux);
 645         if (G_LIKELY (rmdemux->running)) {
 646           gst_query_set_seeking (query, GST_FORMAT_TIME, rmdemux->seekable,
 647               0, rmdemux->duration);
 648           res = TRUE;
 649         }
 650         GST_OBJECT_UNLOCK (rmdemux);
 651       }
 652       break;
 653     }
 654     case GST_QUERY_SEGMENT:
 655     {
 656       GstFormat format;
 657       gint64 start, stop;
 658
 659       format = rmdemux->segment.format;
 660
 661       start =
 662           gst_segment_to_stream_time (&rmdemux->segment, format,
 663           rmdemux->segment.start);
 664       if ((stop = rmdemux->segment.stop) == -1)
 665         stop = rmdemux->segment.duration;
 666       else
 667         stop = gst_segment_to_stream_time (&rmdemux->segment, format, stop);
 668
 669       gst_query_set_segment (query, rmdemux->segment.rate, format, start, stop);
 670       res = TRUE;
 671       break;
 672     }
 673     default:
 674       res = gst_pad_query_default (pad, parent, query);
 675       break;
 676   }
 677
 678   return res;
 679 }
 680
 681 static void
 682 gst_rmdemux_reset (GstRMDemux * rmdemux)
 683 {
 684   GSList *cur;
 685
 686   GST_OBJECT_LOCK (rmdemux);
 687   rmdemux->running = FALSE;
 688   GST_OBJECT_UNLOCK (rmdemux);
 689
 690   for (cur = rmdemux->streams; cur; cur = cur->next) {
 691     GstRMDemuxStream *stream = cur->data;
 692
 693     g_object_unref (stream->adapter);
 694     gst_rmdemux_stream_clear_cached_subpackets (rmdemux, stream);
 695     gst_flow_combiner_remove_pad (rmdemux->flowcombiner, stream->pad);
 696     gst_element_remove_pad (GST_ELEMENT (rmdemux), stream->pad);
 697     if (stream->pending_tags)
 698       gst_tag_list_unref (stream->pending_tags);
 699     if (stream->subpackets)
 700       g_ptr_array_free (stream->subpackets, TRUE);
 701     g_free (stream->index);
 702     g_free (stream);
 703   }
 704   g_slist_free (rmdemux->streams);
 705   rmdemux->streams = NULL;
 706   rmdemux->n_audio_streams = 0;
 707   rmdemux->n_video_streams = 0;
 708
 709   if (rmdemux->pending_tags != NULL) {
 710     gst_tag_list_unref (rmdemux->pending_tags);
 711     rmdemux->pending_tags = NULL;
 712   }
 713
 714   gst_adapter_clear (rmdemux->adapter);
 715   rmdemux->state = RMDEMUX_STATE_HEADER;
 716   rmdemux->have_pads = FALSE;
 717
 718   gst_segment_init (&rmdemux->segment, GST_FORMAT_UNDEFINED);
 719   rmdemux->first_ts = GST_CLOCK_TIME_NONE;
 720   rmdemux->base_ts = GST_CLOCK_TIME_NONE;
 721   rmdemux->need_newsegment = TRUE;
 722
 723   rmdemux->have_group_id = FALSE;
 724   rmdemux->group_id = G_MAXUINT;
 725 }
 726
 727 static GstStateChangeReturn
 728 gst_rmdemux_change_state (GstElement * element, GstStateChange transition)
 729 {
 730   GstRMDemux *rmdemux = GST_RMDEMUX (element);
 731   GstStateChangeReturn res;
 732
 733   switch (transition) {
 734     case GST_STATE_CHANGE_NULL_TO_READY:
 735       break;
 736     case GST_STATE_CHANGE_READY_TO_PAUSED:
 737       rmdemux->state = RMDEMUX_STATE_HEADER;
 738       rmdemux->have_pads = FALSE;
 739       gst_segment_init (&rmdemux->segment, GST_FORMAT_TIME);
 740       rmdemux->running = FALSE;
 741       break;
 742     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
 743       break;
 744     default:
 745       break;
 746   }
 747
 748   res = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 749
 750   switch (transition) {
 751     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
 752       break;
 753     case GST_STATE_CHANGE_PAUSED_TO_READY:{
 754       gst_rmdemux_reset (rmdemux);
 755       break;
 756     }
 757     case GST_STATE_CHANGE_READY_TO_NULL:
 758       break;
 759     default:
 760       break;
 761   }
 762
 763   return res;
 764 }
 765
 766 /* this function is called when the pad is activated and should start
 767  * processing data.
 768  *
 769  * We check if we can do random access to decide if we work push or
 770  * pull based.
 771  */
 772 static gboolean
 773 gst_rmdemux_sink_activate (GstPad * sinkpad, GstObject * parent)
 774 {
 775   GstQuery *query;
 776   gboolean pull_mode;
 777
 778   query = gst_query_new_scheduling ();
 779
 780   if (!gst_pad_peer_query (sinkpad, query)) {
 781     gst_query_unref (query);
 782     goto activate_push;
 783   }
 784
 785   pull_mode = gst_query_has_scheduling_mode_with_flags (query,
 786       GST_PAD_MODE_PULL, GST_SCHEDULING_FLAG_SEEKABLE);
 787   gst_query_unref (query);
 788
 789   if (!pull_mode)
 790     goto activate_push;
 791
 792   GST_DEBUG_OBJECT (sinkpad, "activating pull");
 793   return gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PULL, TRUE);
 794
 795 activate_push:
 796   {
 797     GST_DEBUG_OBJECT (sinkpad, "activating push");
 798     return gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PUSH, TRUE);
 799   }
 800 }
 801
 802 static gboolean
 803 gst_rmdemux_sink_activate_mode (GstPad * sinkpad, GstObject * parent,
 804     GstPadMode mode, gboolean active)
 805 {
 806   gboolean res;
 807   GstRMDemux *demux;
 808
 809   demux = GST_RMDEMUX (parent);
 810
 811   switch (mode) {
 812     case GST_PAD_MODE_PUSH:
 813       demux->seekable = FALSE;
 814       demux->running = active;
 815       res = TRUE;
 816       break;
 817     case GST_PAD_MODE_PULL:
 818       if (active) {
 819         demux->seekable = TRUE;
 820         demux->offset = 0;
 821         demux->loop_state = RMDEMUX_LOOP_STATE_HEADER;
 822         demux->data_offset = G_MAXUINT;
 823         res =
 824             gst_pad_start_task (sinkpad, (GstTaskFunction) gst_rmdemux_loop,
 825             sinkpad, NULL);
 826       } else {
 827         res = gst_pad_stop_task (sinkpad);
 828       }
 829       break;
 830     default:
 831       res = FALSE;
 832       break;
 833   }
 834   return res;
 835 }
 836
 837
 838 /* random access mode - just pass over to our chain function */
 839 static void
 840 gst_rmdemux_loop (GstPad * pad)
 841 {
 842   GstRMDemux *rmdemux;
 843   GstBuffer *buffer;
 844   GstFlowReturn ret = GST_FLOW_OK;
 845   guint size;
 846
 847   rmdemux = GST_RMDEMUX (GST_PAD_PARENT (pad));
 848
 849   GST_LOG_OBJECT (rmdemux, "loop with state=%d and offset=0x%x",
 850       rmdemux->loop_state, rmdemux->offset);
 851
 852   switch (rmdemux->state) {
 853     case RMDEMUX_STATE_HEADER:
 854       size = HEADER_SIZE;
 855       break;
 856     case RMDEMUX_STATE_HEADER_DATA:
 857       size = DATA_SIZE;
 858       break;
 859     case RMDEMUX_STATE_DATA_PACKET:
 860       size = rmdemux->avg_packet_size;
 861       break;
 862     case RMDEMUX_STATE_EOS:
 863       GST_LOG_OBJECT (rmdemux, "At EOS, pausing task");
 864       ret = GST_FLOW_EOS;
 865       goto need_pause;
 866     default:
 867       GST_LOG_OBJECT (rmdemux, "Default: requires %d bytes (state is %d)",
 868           (int) rmdemux->size, rmdemux->state);
 869       size = rmdemux->size;
 870   }
 871
 872   buffer = NULL;
 873   ret = gst_pad_pull_range (pad, rmdemux->offset, size, &buffer);
 874   if (ret != GST_FLOW_OK) {
 875     if (rmdemux->offset == rmdemux->index_offset) {
 876       /* The index isn't available so forget about it */
 877       rmdemux->loop_state = RMDEMUX_LOOP_STATE_DATA;
 878       rmdemux->offset = rmdemux->data_offset;
 879       GST_OBJECT_LOCK (rmdemux);
 880       rmdemux->running = TRUE;
 881       rmdemux->seekable = FALSE;
 882       GST_OBJECT_UNLOCK (rmdemux);
 883       return;
 884     } else {
 885       GST_DEBUG_OBJECT (rmdemux, "Unable to pull %d bytes at offset 0x%08x "
 886           "(pull_range returned flow %s, state is %d)", (gint) size,
 887           rmdemux->offset, gst_flow_get_name (ret), GST_STATE (rmdemux));
 888       goto need_pause;
 889     }
 890   }
 891
 892   size = gst_buffer_get_size (buffer);
 893
 894   /* Defer to the chain function */
 895   ret = gst_rmdemux_chain (pad, GST_OBJECT_CAST (rmdemux), buffer);
 896   if (ret != GST_FLOW_OK) {
 897     GST_DEBUG_OBJECT (rmdemux, "Chain flow failed at offset 0x%08x",
 898         rmdemux->offset);
 899     goto need_pause;
 900   }
 901
 902   rmdemux->offset += size;
 903
 904   switch (rmdemux->loop_state) {
 905     case RMDEMUX_LOOP_STATE_HEADER:
 906       if (rmdemux->offset >= rmdemux->data_offset) {
 907         /* It's the end of the header */
 908         rmdemux->loop_state = RMDEMUX_LOOP_STATE_INDEX;
 909         rmdemux->offset = rmdemux->index_offset;
 910       }
 911       break;
 912     case RMDEMUX_LOOP_STATE_INDEX:
 913       if (rmdemux->state == RMDEMUX_STATE_HEADER) {
 914         if (rmdemux->index_offset == 0) {
 915           /* We've read the last index */
 916           rmdemux->loop_state = RMDEMUX_LOOP_STATE_DATA;
 917           rmdemux->offset = rmdemux->data_offset;
 918           GST_OBJECT_LOCK (rmdemux);
 919           rmdemux->running = TRUE;
 920           GST_OBJECT_UNLOCK (rmdemux);
 921         } else {
 922           /* Get the next index */
 923           rmdemux->offset = rmdemux->index_offset;
 924         }
 925       }
 926       break;
 927     case RMDEMUX_LOOP_STATE_DATA:
 928       break;
 929   }
 930
 931   return;
 932
 933   /* ERRORS */
 934 need_pause:
 935   {
 936     const gchar *reason = gst_flow_get_name (ret);
 937
 938     GST_LOG_OBJECT (rmdemux, "pausing task, reason %s", reason);
 939     rmdemux->segment_running = FALSE;
 940     gst_pad_pause_task (rmdemux->sinkpad);
 941
 942     if (ret == GST_FLOW_EOS) {
 943       /* perform EOS logic */
 944       if (rmdemux->segment.flags & GST_SEEK_FLAG_SEGMENT) {
 945         gint64 stop;
 946
 947         /* for segment playback we need to post when (in stream time)
 948          * we stopped, this is either stop (when set) or the duration. */
 949         if ((stop = rmdemux->segment.stop) == -1)
 950           stop = rmdemux->segment.duration;
 951
 952         GST_LOG_OBJECT (rmdemux, "Sending segment done, at end of segment");
 953         gst_element_post_message (GST_ELEMENT (rmdemux),
 954             gst_message_new_segment_done (GST_OBJECT (rmdemux),
 955                 GST_FORMAT_TIME, stop));
 956         gst_rmdemux_send_event (rmdemux,
 957             gst_event_new_segment_done (GST_FORMAT_TIME, stop));
 958       } else {
 959         /* normal playback, send EOS to all linked pads */
 960         GST_LOG_OBJECT (rmdemux, "Sending EOS, at end of stream");
 961         gst_rmdemux_send_event (rmdemux, gst_event_new_eos ());
 962       }
 963     } else if (ret == GST_FLOW_NOT_LINKED || ret < GST_FLOW_EOS) {
 964       GST_ELEMENT_ERROR (rmdemux, STREAM, FAILED,
 965           (NULL), ("stream stopped, reason %s", reason));
 966       gst_rmdemux_send_event (rmdemux, gst_event_new_eos ());
 967     }
 968     return;
 969   }
 970 }
 971
 972 static gboolean
 973 gst_rmdemux_fourcc_isplausible (guint32 fourcc)
 974 {
 975   int i;
 976
 977   for (i = 0; i < 4; i++) {
 978     if (!isprint ((int) ((unsigned char *) (&fourcc))[i])) {
 979       return FALSE;
 980     }
 981   }
 982   return TRUE;
 983 }
 984
 985 static GstFlowReturn
 986 gst_rmdemux_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
 987 {
 988   GstFlowReturn ret = GST_FLOW_OK;
 989   const guint8 *data;
 990   guint16 version;
 991   guint avail;
 992
 993   GstRMDemux *rmdemux = GST_RMDEMUX (parent);
 994
 995   if (rmdemux->base_ts == -1) {
 996     if (GST_BUFFER_DTS_IS_VALID (buffer))
 997       rmdemux->base_ts = GST_BUFFER_DTS (buffer);
 998     else
 999       rmdemux->base_ts = GST_BUFFER_PTS (buffer);
1000
1001     GST_LOG_OBJECT (rmdemux, "base_ts %" GST_TIME_FORMAT,
1002         GST_TIME_ARGS (rmdemux->base_ts));
1003   }
1004
1005   gst_adapter_push (rmdemux->adapter, buffer);
1006
1007   GST_LOG_OBJECT (rmdemux, "Chaining buffer of size %" G_GSIZE_FORMAT,
1008       gst_buffer_get_size (buffer));
1009
1010   while (TRUE) {
1011     avail = gst_adapter_available (rmdemux->adapter);
1012
1013     GST_LOG_OBJECT (rmdemux, "looping in chain, avail %u", avail);
1014     switch (rmdemux->state) {
1015       case RMDEMUX_STATE_HEADER:
1016       {
1017         if (gst_adapter_available (rmdemux->adapter) < HEADER_SIZE)
1018           goto unlock;
1019
1020         data = gst_adapter_map (rmdemux->adapter, HEADER_SIZE);
1021
1022         rmdemux->object_id = RMDEMUX_FOURCC_GET (data + 0);
1023         rmdemux->size = RMDEMUX_GUINT32_GET (data + 4) - HEADER_SIZE;
1024         rmdemux->object_version = RMDEMUX_GUINT16_GET (data + 8);
1025
1026         /* Sanity-check. We assume that the FOURCC is printable ASCII */
1027         if (!gst_rmdemux_fourcc_isplausible (rmdemux->object_id)) {
1028           /* Failed. Remain in HEADER state, try again... We flush only
1029            * the actual FOURCC, not the entire header, because we could
1030            * need to resync anywhere at all... really, this should never
1031            * happen. */
1032           GST_WARNING_OBJECT (rmdemux, "Bogus looking header, unprintable "
1033               "FOURCC");
1034           gst_adapter_unmap (rmdemux->adapter);
1035           gst_adapter_flush (rmdemux->adapter, 4);
1036
1037           break;
1038         }
1039
1040         GST_LOG_OBJECT (rmdemux, "header found with object_id=%"
1041             GST_FOURCC_FORMAT
1042             " size=%08x object_version=%d",
1043             GST_FOURCC_ARGS (rmdemux->object_id), rmdemux->size,
1044             rmdemux->object_version);
1045
1046         gst_adapter_unmap (rmdemux->adapter);
1047         gst_adapter_flush (rmdemux->adapter, HEADER_SIZE);
1048
1049         switch (rmdemux->object_id) {
1050           case GST_MAKE_FOURCC ('.', 'R', 'M', 'F'):
1051             rmdemux->state = RMDEMUX_STATE_HEADER_RMF;
1052             break;
1053           case GST_MAKE_FOURCC ('P', 'R', 'O', 'P'):
1054             rmdemux->state = RMDEMUX_STATE_HEADER_PROP;
1055             break;
1056           case GST_MAKE_FOURCC ('M', 'D', 'P', 'R'):
1057             rmdemux->state = RMDEMUX_STATE_HEADER_MDPR;
1058             break;
1059           case GST_MAKE_FOURCC ('I', 'N', 'D', 'X'):
1060             rmdemux->state = RMDEMUX_STATE_HEADER_INDX;
1061             break;
1062           case GST_MAKE_FOURCC ('D', 'A', 'T', 'A'):
1063             rmdemux->state = RMDEMUX_STATE_HEADER_DATA;
1064             break;
1065           case GST_MAKE_FOURCC ('C', 'O', 'N', 'T'):
1066             rmdemux->state = RMDEMUX_STATE_HEADER_CONT;
1067             break;
1068           default:
1069             rmdemux->state = RMDEMUX_STATE_HEADER_UNKNOWN;
1070             break;
1071         }
1072         break;
1073       }
1074       case RMDEMUX_STATE_HEADER_UNKNOWN:
1075       {
1076         if (gst_adapter_available (rmdemux->adapter) < rmdemux->size)
1077           goto unlock;
1078
1079         GST_WARNING_OBJECT (rmdemux, "Unknown object_id %" GST_FOURCC_FORMAT,
1080             GST_FOURCC_ARGS (rmdemux->object_id));
1081
1082         gst_adapter_flush (rmdemux->adapter, rmdemux->size);
1083         rmdemux->state = RMDEMUX_STATE_HEADER;
1084         break;
1085       }
1086       case RMDEMUX_STATE_HEADER_RMF:
1087       {
1088         if (gst_adapter_available (rmdemux->adapter) < rmdemux->size)
1089           goto unlock;
1090
1091         if ((rmdemux->object_version == 0) || (rmdemux->object_version == 1)) {
1092           data = gst_adapter_map (rmdemux->adapter, rmdemux->size);
1093           gst_rmdemux_parse__rmf (rmdemux, data, rmdemux->size);
1094           gst_adapter_unmap (rmdemux->adapter);
1095           gst_adapter_flush (rmdemux->adapter, rmdemux->size);
1096         } else {
1097           gst_adapter_flush (rmdemux->adapter, rmdemux->size);
1098         }
1099         rmdemux->state = RMDEMUX_STATE_HEADER;
1100         break;
1101       }
1102       case RMDEMUX_STATE_HEADER_PROP:
1103       {
1104         if (gst_adapter_available (rmdemux->adapter) < rmdemux->size)
1105           goto unlock;
1106
1107         data = gst_adapter_map (rmdemux->adapter, rmdemux->size);
1108         gst_rmdemux_parse_prop (rmdemux, data, rmdemux->size);
1109         gst_adapter_unmap (rmdemux->adapter);
1110         gst_adapter_flush (rmdemux->adapter, rmdemux->size);
1111
1112         rmdemux->state = RMDEMUX_STATE_HEADER;
1113         break;
1114       }
1115       case RMDEMUX_STATE_HEADER_MDPR:
1116       {
1117         if (gst_adapter_available (rmdemux->adapter) < rmdemux->size)
1118           goto unlock;
1119
1120         data = gst_adapter_map (rmdemux->adapter, rmdemux->size);
1121         gst_rmdemux_parse_mdpr (rmdemux, data, rmdemux->size);
1122         gst_adapter_unmap (rmdemux->adapter);
1123         gst_adapter_flush (rmdemux->adapter, rmdemux->size);
1124
1125         rmdemux->state = RMDEMUX_STATE_HEADER;
1126         break;
1127       }
1128       case RMDEMUX_STATE_HEADER_CONT:
1129       {
1130         if (gst_adapter_available (rmdemux->adapter) < rmdemux->size)
1131           goto unlock;
1132
1133         data = gst_adapter_map (rmdemux->adapter, rmdemux->size);
1134         gst_rmdemux_parse_cont (rmdemux, data, rmdemux->size);
1135         gst_adapter_unmap (rmdemux->adapter);
1136         gst_adapter_flush (rmdemux->adapter, rmdemux->size);
1137
1138         rmdemux->state = RMDEMUX_STATE_HEADER;
1139         break;
1140       }
1141       case RMDEMUX_STATE_HEADER_DATA:
1142       {
1143         /* If we haven't already done so then signal there are no more pads */
1144         if (!rmdemux->have_pads) {
1145           GST_LOG_OBJECT (rmdemux, "no more pads");
1146           gst_element_no_more_pads (GST_ELEMENT (rmdemux));
1147           rmdemux->have_pads = TRUE;
1148         }
1149
1150         /* The actual header is only 8 bytes */
1151         rmdemux->size = DATA_SIZE;
1152         GST_LOG_OBJECT (rmdemux, "data available %" G_GSIZE_FORMAT,
1153             gst_adapter_available (rmdemux->adapter));
1154         if (gst_adapter_available (rmdemux->adapter) < rmdemux->size)
1155           goto unlock;
1156
1157         data = gst_adapter_map (rmdemux->adapter, rmdemux->size);
1158         gst_rmdemux_parse_data (rmdemux, data, rmdemux->size);
1159         gst_adapter_unmap (rmdemux->adapter);
1160         gst_adapter_flush (rmdemux->adapter, rmdemux->size);
1161
1162         rmdemux->state = RMDEMUX_STATE_DATA_PACKET;
1163         break;
1164       }
1165       case RMDEMUX_STATE_HEADER_INDX:
1166       {
1167         if (gst_adapter_available (rmdemux->adapter) < rmdemux->size)
1168           goto unlock;
1169
1170         data = gst_adapter_map (rmdemux->adapter, rmdemux->size);
1171         rmdemux->size = gst_rmdemux_parse_indx (rmdemux, data, rmdemux->size);
1172         /* Only flush the header */
1173         gst_adapter_unmap (rmdemux->adapter);
1174         gst_adapter_flush (rmdemux->adapter, HEADER_SIZE);
1175
1176         rmdemux->state = RMDEMUX_STATE_INDX_DATA;
1177         break;
1178       }
1179       case RMDEMUX_STATE_INDX_DATA:
1180       {
1181         /* There's not always an data to get... */
1182         if (rmdemux->size > 0) {
1183           if (gst_adapter_available (rmdemux->adapter) < rmdemux->size)
1184             goto unlock;
1185
1186           data = gst_adapter_map (rmdemux->adapter, rmdemux->size);
1187           gst_rmdemux_parse_indx_data (rmdemux, data, rmdemux->size);
1188           gst_adapter_unmap (rmdemux->adapter);
1189           gst_adapter_flush (rmdemux->adapter, rmdemux->size);
1190         }
1191
1192         rmdemux->state = RMDEMUX_STATE_HEADER;
1193         break;
1194       }
1195       case RMDEMUX_STATE_DATA_PACKET:
1196       {
1197         guint8 header[4];
1198
1199         if (gst_adapter_available (rmdemux->adapter) < 2)
1200           goto unlock;
1201
1202         gst_adapter_copy (rmdemux->adapter, header, 0, 2);
1203         version = RMDEMUX_GUINT16_GET (header);
1204         GST_LOG_OBJECT (rmdemux, "Data packet with version=%d", version);
1205
1206         if (version == 0 || version == 1) {
1207           guint16 length;
1208
1209           if (gst_adapter_available (rmdemux->adapter) < 4)
1210             goto unlock;
1211
1212           gst_adapter_copy (rmdemux->adapter, header, 0, 4);
1213
1214           length = RMDEMUX_GUINT16_GET (header + 2);
1215           GST_LOG_OBJECT (rmdemux, "Got length %d", length);
1216
1217           if (length < 4) {
1218             GST_LOG_OBJECT (rmdemux, "length too small, dropping");
1219             /* Invalid, just drop it */
1220             gst_adapter_flush (rmdemux->adapter, 4);
1221           } else {
1222             GstBuffer *buffer;
1223
1224             avail = gst_adapter_available (rmdemux->adapter);
1225             if (avail < length)
1226               goto unlock;
1227
1228             GST_LOG_OBJECT (rmdemux, "we have %u available and we needed %d",
1229                 avail, length);
1230
1231             /* flush version and length */
1232             gst_adapter_flush (rmdemux->adapter, 4);
1233             length -= 4;
1234
1235             buffer = gst_adapter_take_buffer (rmdemux->adapter, length);
1236
1237             ret = gst_rmdemux_parse_packet (rmdemux, buffer, version);
1238             rmdemux->chunk_index++;
1239           }
1240
1241           if (rmdemux->chunk_index == rmdemux->n_chunks || length == 0)
1242             rmdemux->state = RMDEMUX_STATE_HEADER;
1243         } else {
1244           /* Stream done */
1245           gst_adapter_flush (rmdemux->adapter, 2);
1246
1247           if (rmdemux->data_offset == 0) {
1248             GST_LOG_OBJECT (rmdemux,
1249                 "No further data, internal demux state EOS");
1250             rmdemux->state = RMDEMUX_STATE_EOS;
1251           } else
1252             rmdemux->state = RMDEMUX_STATE_HEADER;
1253         }
1254         break;
1255       }
1256       case RMDEMUX_STATE_EOS:
1257         gst_rmdemux_send_event (rmdemux, gst_event_new_eos ());
1258         goto unlock;
1259       default:
1260         GST_WARNING_OBJECT (rmdemux, "Unhandled state %d", rmdemux->state);
1261         goto unlock;
1262     }
1263   }
1264
1265 unlock:
1266   return ret;
1267 }
1268
1269 static GstRMDemuxStream *
1270 gst_rmdemux_get_stream_by_id (GstRMDemux * rmdemux, int id)
1271 {
1272   GSList *cur;
1273
1274   for (cur = rmdemux->streams; cur; cur = cur->next) {
1275     GstRMDemuxStream *stream = cur->data;
1276
1277     if (stream->id == id) {
1278       return stream;
1279     }
1280   }
1281
1282   return NULL;
1283 }
1284
1285 static void
1286 gst_rmdemux_send_event (GstRMDemux * rmdemux, GstEvent * event)
1287 {
1288   GSList *cur;
1289
1290   for (cur = rmdemux->streams; cur; cur = cur->next) {
1291     GstRMDemuxStream *stream = cur->data;
1292
1293     GST_DEBUG_OBJECT (rmdemux, "Pushing %s event on pad %s",
1294         GST_EVENT_TYPE_NAME (event), GST_PAD_NAME (stream->pad));
1295
1296     switch (GST_EVENT_TYPE (event)) {
1297       case GST_EVENT_FLUSH_STOP:
1298         stream->last_ts = -1;
1299         stream->next_ts = -1;
1300         stream->last_seq = -1;
1301         stream->next_seq = -1;
1302         break;
1303       default:
1304         break;
1305     }
1306     gst_event_ref (event);
1307     gst_pad_push_event (stream->pad, event);
1308   }
1309   gst_event_unref (event);
1310 }
1311
1312 static void
1313 gst_rmdemux_add_stream (GstRMDemux * rmdemux, GstRMDemuxStream * stream)
1314 {
1315   GstCaps *stream_caps = NULL;
1316   const gchar *codec_tag = NULL;
1317   gchar *codec_name = NULL;
1318   gchar *stream_id;
1319   int version = 0;
1320
1321   if (stream->subtype == GST_RMDEMUX_STREAM_VIDEO) {
1322     char *name = g_strdup_printf ("video_%u", rmdemux->n_video_streams);
1323
1324     stream->pad =
1325         gst_pad_new_from_static_template (&gst_rmdemux_videosrc_template, name);
1326     g_free (name);
1327
1328     codec_tag = GST_TAG_VIDEO_CODEC;
1329
1330     switch (stream->fourcc) {
1331       case GST_RM_VDO_RV10:
1332         version = 1;
1333         break;
1334       case GST_RM_VDO_RV20:
1335         version = 2;
1336         break;
1337       case GST_RM_VDO_RV30:
1338         version = 3;
1339         break;
1340       case GST_RM_VDO_RV40:
1341         version = 4;
1342         break;
1343       default:
1344         stream_caps = gst_caps_new_simple ("video/x-unknown-fourcc",
1345             "fourcc", G_TYPE_UINT, stream->fourcc, NULL);
1346         GST_WARNING_OBJECT (rmdemux,
1347             "Unknown video FOURCC code \"%" GST_FOURCC_FORMAT "\" (%08x)",
1348             GST_FOURCC_ARGS (stream->fourcc), stream->fourcc);
1349     }
1350
1351     if (version) {
1352       stream_caps =
1353           gst_caps_new_simple ("video/x-pn-realvideo", "rmversion", G_TYPE_INT,
1354           (int) version,
1355           "format", G_TYPE_INT,
1356           (int) stream->format,
1357           "subformat", G_TYPE_INT, (int) stream->subformat, NULL);
1358     }
1359
1360     if (stream_caps) {
1361       gst_caps_set_simple (stream_caps,
1362           "width", G_TYPE_INT, stream->width,
1363           "height", G_TYPE_INT, stream->height,
1364           "framerate", GST_TYPE_FRACTION, stream->framerate_numerator,
1365           stream->framerate_denominator, NULL);
1366     }
1367     rmdemux->n_video_streams++;
1368
1369   } else if (stream->subtype == GST_RMDEMUX_STREAM_AUDIO) {
1370     char *name = g_strdup_printf ("audio_%u", rmdemux->n_audio_streams);
1371
1372     stream->pad =
1373         gst_pad_new_from_static_template (&gst_rmdemux_audiosrc_template, name);
1374     GST_LOG_OBJECT (rmdemux, "Created audio pad \"%s\"", name);
1375     g_free (name);
1376
1377     codec_tag = GST_TAG_AUDIO_CODEC;
1378
1379     switch (stream->fourcc) {
1380         /* Older RealAudio Codecs */
1381       case GST_RM_AUD_14_4:
1382         version = 1;
1383         break;
1384
1385       case GST_RM_AUD_28_8:
1386         version = 2;
1387         break;
1388
1389         /* DolbyNet (Dolby AC3, low bitrate) */
1390       case GST_RM_AUD_DNET:
1391         stream_caps =
1392             gst_caps_new_simple ("audio/x-ac3", "rate", G_TYPE_INT,
1393             (int) stream->rate, NULL);
1394         stream->needs_descrambling = TRUE;
1395         stream->subpackets_needed = 1;
1396         stream->subpackets = NULL;
1397         break;
1398
1399         /* MPEG-4 based */
1400       case GST_RM_AUD_RAAC:
1401       case GST_RM_AUD_RACP:
1402         stream_caps =
1403             gst_caps_new_simple ("audio/mpeg", "mpegversion", G_TYPE_INT,
1404             (int) 4, "framed", G_TYPE_BOOLEAN, TRUE, NULL);
1405         if (stream->extra_data_size > 0) {
1406           /* strip off an unknown byte in the extra data */
1407           stream->extra_data_size--;
1408           stream->extra_data++;
1409         }
1410         stream->needs_descrambling = TRUE;
1411         stream->subpackets_needed = 1;
1412         stream->subpackets = NULL;
1413         break;
1414
1415         /* Sony ATRAC3 */
1416       case GST_RM_AUD_ATRC:
1417         stream_caps = gst_caps_new_empty_simple ("audio/x-vnd.sony.atrac3");
1418         stream->needs_descrambling = TRUE;
1419         stream->subpackets_needed = stream->height;
1420         stream->subpackets = NULL;
1421         break;
1422
1423         /* RealAudio G2 audio */
1424       case GST_RM_AUD_COOK:
1425         version = 8;
1426         stream->needs_descrambling = TRUE;
1427         stream->subpackets_needed = stream->height;
1428         stream->subpackets = NULL;
1429         break;
1430
1431         /* RALF is lossless */
1432       case GST_RM_AUD_RALF:
1433         GST_DEBUG_OBJECT (rmdemux, "RALF");
1434         stream_caps = gst_caps_new_empty_simple ("audio/x-ralf-mpeg4-generic");
1435         break;
1436
1437       case GST_RM_AUD_SIPR:
1438
1439         if (stream->flavor > 3) {
1440           GST_WARNING_OBJECT (rmdemux, "bad SIPR flavor %d, freeing it",
1441               stream->flavor);
1442           g_free (stream);
1443           goto beach;
1444         }
1445
1446         GST_DEBUG_OBJECT (rmdemux, "SIPR");
1447         stream_caps = gst_caps_new_empty_simple ("audio/x-sipro");
1448         stream->needs_descrambling = TRUE;
1449         stream->subpackets_needed = stream->height;
1450         stream->subpackets = NULL;
1451         stream->leaf_size = sipr_subpk_size[stream->flavor];
1452
1453         break;
1454
1455       default:
1456         stream_caps = gst_caps_new_simple ("video/x-unknown-fourcc",
1457             "fourcc", G_TYPE_UINT, stream->fourcc, NULL);
1458         GST_WARNING_OBJECT (rmdemux,
1459             "Unknown audio FOURCC code \"%" GST_FOURCC_FORMAT "\" (%08x)",
1460             GST_FOURCC_ARGS (stream->fourcc), stream->fourcc);
1461         break;
1462     }
1463
1464     if (version) {
1465       stream_caps =
1466           gst_caps_new_simple ("audio/x-pn-realaudio", "raversion", G_TYPE_INT,
1467           (int) version, NULL);
1468     }
1469
1470     if (stream_caps) {
1471       gst_caps_set_simple (stream_caps,
1472           "flavor", G_TYPE_INT, (int) stream->flavor,
1473           "rate", G_TYPE_INT, (int) stream->rate,
1474           "channels", G_TYPE_INT, (int) stream->n_channels,
1475           "width", G_TYPE_INT, (int) stream->sample_width,
1476           "leaf_size", G_TYPE_INT, (int) stream->leaf_size,
1477           "packet_size", G_TYPE_INT, (int) stream->packet_size,
1478           "bitrate", G_TYPE_INT, (int) stream->bitrate,
1479           "height", G_TYPE_INT, (int) stream->height, NULL);
1480     }
1481     rmdemux->n_audio_streams++;
1482   } else {
1483     GST_WARNING_OBJECT (rmdemux, "not adding stream of type %d, freeing it",
1484         stream->subtype);
1485     g_free (stream);
1486     goto beach;
1487   }
1488
1489   GST_PAD_ELEMENT_PRIVATE (stream->pad) = stream;
1490   rmdemux->streams = g_slist_append (rmdemux->streams, stream);
1491   GST_LOG_OBJECT (rmdemux, "n_streams is now %d",
1492       g_slist_length (rmdemux->streams));
1493
1494   GST_LOG ("stream->pad = %p, stream_caps = %" GST_PTR_FORMAT, stream->pad,
1495       stream_caps);
1496
1497   if (stream->pad && stream_caps) {
1498     GstEvent *event;
1499
1500     GST_LOG_OBJECT (rmdemux, "%d bytes of extra data for stream %s",
1501         stream->extra_data_size, GST_PAD_NAME (stream->pad));
1502
1503     /* add codec_data if there is any */
1504     if (stream->extra_data_size > 0) {
1505       GstBuffer *buffer;
1506
1507       buffer = gst_buffer_new_and_alloc (stream->extra_data_size);
1508       gst_buffer_fill (buffer, 0, stream->extra_data, stream->extra_data_size);
1509
1510       gst_caps_set_simple (stream_caps, "codec_data", GST_TYPE_BUFFER,
1511           buffer, NULL);
1512
1513       gst_buffer_unref (buffer);
1514     }
1515
1516     gst_pad_use_fixed_caps (stream->pad);
1517
1518     gst_pad_set_event_function (stream->pad,
1519         GST_DEBUG_FUNCPTR (gst_rmdemux_src_event));
1520     gst_pad_set_query_function (stream->pad,
1521         GST_DEBUG_FUNCPTR (gst_rmdemux_src_query));
1522
1523     GST_DEBUG_OBJECT (rmdemux, "adding pad %s with caps %" GST_PTR_FORMAT
1524         ", stream_id=%d", GST_PAD_NAME (stream->pad), stream_caps, stream->id);
1525     gst_pad_set_active (stream->pad, TRUE);
1526
1527     stream_id =
1528         gst_pad_create_stream_id_printf (stream->pad,
1529         GST_ELEMENT_CAST (rmdemux), "%03u", stream->id);
1530
1531     event =
1532         gst_pad_get_sticky_event (rmdemux->sinkpad, GST_EVENT_STREAM_START, 0);
1533     if (event) {
1534       if (gst_event_parse_group_id (event, &rmdemux->group_id))
1535         rmdemux->have_group_id = TRUE;
1536       else
1537         rmdemux->have_group_id = FALSE;
1538       gst_event_unref (event);
1539     } else if (!rmdemux->have_group_id) {
1540       rmdemux->have_group_id = TRUE;
1541       rmdemux->group_id = gst_util_group_id_next ();
1542     }
1543
1544     event = gst_event_new_stream_start (stream_id);
1545     if (rmdemux->have_group_id)
1546       gst_event_set_group_id (event, rmdemux->group_id);
1547
1548     gst_pad_push_event (stream->pad, event);
1549     g_free (stream_id);
1550
1551     gst_pad_set_caps (stream->pad, stream_caps);
1552
1553     codec_name = gst_pb_utils_get_codec_description (stream_caps);
1554
1555     /* save for later, we must send the tags after the newsegment event */
1556     if (codec_tag != NULL && codec_name != NULL) {
1557       if (stream->pending_tags == NULL)
1558         stream->pending_tags = gst_tag_list_new_empty ();
1559       gst_tag_list_add (stream->pending_tags, GST_TAG_MERGE_KEEP,
1560           codec_tag, codec_name, NULL);
1561       g_free (codec_name);
1562     }
1563     gst_element_add_pad (GST_ELEMENT_CAST (rmdemux), stream->pad);
1564     gst_flow_combiner_add_pad (rmdemux->flowcombiner, stream->pad);
1565   }
1566
1567 beach:
1568
1569   if (stream_caps)
1570     gst_caps_unref (stream_caps);
1571 }
1572
1573 static int
1574 re_skip_pascal_string (const guint8 * ptr)
1575 {
1576   int length;
1577
1578   length = ptr[0];
1579
1580   return length + 1;
1581 }
1582
1583 static void
1584 gst_rmdemux_parse__rmf (GstRMDemux * rmdemux, const guint8 * data, int length)
1585 {
1586   GST_LOG_OBJECT (rmdemux, "file_version: %d", RMDEMUX_GUINT32_GET (data));
1587   GST_LOG_OBJECT (rmdemux, "num_headers: %d", RMDEMUX_GUINT32_GET (data + 4));
1588 }
1589
1590 static void
1591 gst_rmdemux_parse_prop (GstRMDemux * rmdemux, const guint8 * data, int length)
1592 {
1593   GST_LOG_OBJECT (rmdemux, "max bitrate: %d", RMDEMUX_GUINT32_GET (data));
1594   GST_LOG_OBJECT (rmdemux, "avg bitrate: %d", RMDEMUX_GUINT32_GET (data + 4));
1595   GST_LOG_OBJECT (rmdemux, "max packet size: %d",
1596       RMDEMUX_GUINT32_GET (data + 8));
1597   rmdemux->avg_packet_size = RMDEMUX_GUINT32_GET (data + 12);
1598   GST_LOG_OBJECT (rmdemux, "avg packet size: %d", rmdemux->avg_packet_size);
1599   rmdemux->num_packets = RMDEMUX_GUINT32_GET (data + 16);
1600   GST_LOG_OBJECT (rmdemux, "number of packets: %d", rmdemux->num_packets);
1601
1602   GST_LOG_OBJECT (rmdemux, "duration: %d", RMDEMUX_GUINT32_GET (data + 20));
1603   rmdemux->duration = RMDEMUX_GUINT32_GET (data + 20) * GST_MSECOND;
1604
1605   GST_LOG_OBJECT (rmdemux, "preroll: %d", RMDEMUX_GUINT32_GET (data + 24));
1606   rmdemux->index_offset = RMDEMUX_GUINT32_GET (data + 28);
1607   GST_LOG_OBJECT (rmdemux, "offset of INDX section: 0x%08x",
1608       rmdemux->index_offset);
1609   rmdemux->data_offset = RMDEMUX_GUINT32_GET (data + 32);
1610   GST_LOG_OBJECT (rmdemux, "offset of DATA section: 0x%08x",
1611       rmdemux->data_offset);
1612   GST_LOG_OBJECT (rmdemux, "n streams: %d", RMDEMUX_GUINT16_GET (data + 36));
1613   GST_LOG_OBJECT (rmdemux, "flags: 0x%04x", RMDEMUX_GUINT16_GET (data + 38));
1614 }
1615
1616 static void
1617 gst_rmdemux_parse_mdpr (GstRMDemux * rmdemux, const guint8 * data, int length)
1618 {
1619   GstRMDemuxStream *stream;
1620   char *stream1_type_string;
1621   char *stream2_type_string;
1622   guint str_len = 0;
1623   int stream_type;
1624   int offset;
1625   guint32 max_bitrate;
1626   guint32 avg_bitrate;
1627
1628   stream = g_new0 (GstRMDemuxStream, 1);
1629
1630   stream->id = RMDEMUX_GUINT16_GET (data);
1631   stream->index = NULL;
1632   stream->seek_offset = 0;
1633   stream->last_ts = -1;
1634   stream->next_ts = -1;
1635   stream->discont = TRUE;
1636   stream->adapter = gst_adapter_new ();
1637   GST_LOG_OBJECT (rmdemux, "stream_number=%d", stream->id);
1638
1639   /* parse the bitrates */
1640   max_bitrate = RMDEMUX_GUINT32_GET (data + 2);
1641   avg_bitrate = RMDEMUX_GUINT32_GET (data + 6);
1642   stream->bitrate = avg_bitrate;
1643   GST_LOG_OBJECT (rmdemux, "Stream max bitrate=%u", max_bitrate);
1644   GST_LOG_OBJECT (rmdemux, "Stream avg bitrate=%u", avg_bitrate);
1645   if (max_bitrate != 0) {
1646     if (stream->pending_tags == NULL)
1647       stream->pending_tags = gst_tag_list_new_empty ();
1648     gst_tag_list_add (stream->pending_tags, GST_TAG_MERGE_REPLACE,
1649         GST_TAG_MAXIMUM_BITRATE, max_bitrate, NULL);
1650   }
1651   if (avg_bitrate != 0) {
1652     if (stream->pending_tags == NULL)
1653       stream->pending_tags = gst_tag_list_new_empty ();
1654     gst_tag_list_add (stream->pending_tags, GST_TAG_MERGE_REPLACE,
1655         GST_TAG_BITRATE, avg_bitrate, NULL);
1656   }
1657
1658   offset = 30;
1659   stream1_type_string = gst_rm_utils_read_string8 (data + offset,
1660       length - offset, &str_len);
1661   offset += str_len;
1662   stream2_type_string = gst_rm_utils_read_string8 (data + offset,
1663       length - offset, &str_len);
1664   offset += str_len;
1665
1666   /* stream1_type_string for audio and video stream is a "put_whatever_you_want" field :
1667    * observed values :
1668    * - "[The ]Video/Audio Stream" (File produced by an official Real encoder)
1669    * - "RealVideoPremierePlugIn-VIDEO/AUDIO" (File produced by Abobe Premiere)
1670    *
1671    * so, we should not rely on it to know which stream type it is
1672    */
1673
1674   GST_LOG_OBJECT (rmdemux, "stream type: %s", stream1_type_string);
1675   GST_LOG_OBJECT (rmdemux, "MIME type=%s", stream2_type_string);
1676
1677   if (strcmp (stream2_type_string, "video/x-pn-realvideo") == 0) {
1678     stream_type = GST_RMDEMUX_STREAM_VIDEO;
1679   } else if (strcmp (stream2_type_string,
1680           "video/x-pn-multirate-realvideo") == 0) {
1681     stream_type = GST_RMDEMUX_STREAM_VIDEO;
1682   } else if (strcmp (stream2_type_string, "audio/x-pn-realaudio") == 0) {
1683     stream_type = GST_RMDEMUX_STREAM_AUDIO;
1684   } else if (strcmp (stream2_type_string,
1685           "audio/x-pn-multirate-realaudio") == 0) {
1686     stream_type = GST_RMDEMUX_STREAM_AUDIO;
1687   } else if (strcmp (stream2_type_string,
1688           "audio/x-pn-multirate-realaudio-live") == 0) {
1689     stream_type = GST_RMDEMUX_STREAM_AUDIO;
1690   } else if (strcmp (stream2_type_string, "audio/x-ralf-mpeg4-generic") == 0) {
1691     /* Another audio type found in the real testsuite */
1692     stream_type = GST_RMDEMUX_STREAM_AUDIO;
1693   } else if (strcmp (stream1_type_string, "") == 0 &&
1694       strcmp (stream2_type_string, "logical-fileinfo") == 0) {
1695     stream_type = GST_RMDEMUX_STREAM_FILEINFO;
1696   } else {
1697     stream_type = GST_RMDEMUX_STREAM_UNKNOWN;
1698     GST_WARNING_OBJECT (rmdemux, "unknown stream type \"%s\",\"%s\"",
1699         stream1_type_string, stream2_type_string);
1700   }
1701   g_free (stream1_type_string);
1702   g_free (stream2_type_string);
1703
1704   offset += 4;
1705
1706   stream->subtype = stream_type;
1707   switch (stream_type) {
1708
1709     case GST_RMDEMUX_STREAM_VIDEO:
1710       /* RV10/RV20/RV30/RV40 => video/x-pn-realvideo, version=1,2,3,4 */
1711       stream->fourcc = RMDEMUX_FOURCC_GET (data + offset + 8);
1712       stream->width = RMDEMUX_GUINT16_GET (data + offset + 12);
1713       stream->height = RMDEMUX_GUINT16_GET (data + offset + 14);
1714       stream->rate = RMDEMUX_GUINT16_GET (data + offset + 16);
1715       stream->subformat = RMDEMUX_GUINT32_GET (data + offset + 26);
1716       stream->format = RMDEMUX_GUINT32_GET (data + offset + 30);
1717       stream->extra_data_size = length - (offset + 26);
1718       stream->extra_data = (guint8 *) data + offset + 26;
1719       /* Natural way to represent framerates here requires unsigned 32 bit
1720        * numerator, which we don't have. For the nasty case, approximate...
1721        */
1722       {
1723         guint32 numerator = RMDEMUX_GUINT16_GET (data + offset + 22) * 65536 +
1724             RMDEMUX_GUINT16_GET (data + offset + 24);
1725         if (numerator > G_MAXINT) {
1726           stream->framerate_numerator = (gint) (numerator >> 1);
1727           stream->framerate_denominator = 32768;
1728         } else {
1729           stream->framerate_numerator = (gint) numerator;
1730           stream->framerate_denominator = 65536;
1731         }
1732       }
1733
1734       GST_DEBUG_OBJECT (rmdemux,
1735           "Video stream with fourcc=%" GST_FOURCC_FORMAT
1736           " width=%d height=%d rate=%d framerate=%d/%d subformat=%x format=%x extra_data_size=%d",
1737           GST_FOURCC_ARGS (stream->fourcc), stream->width, stream->height,
1738           stream->rate, stream->framerate_numerator,
1739           stream->framerate_denominator, stream->subformat, stream->format,
1740           stream->extra_data_size);
1741       break;
1742     case GST_RMDEMUX_STREAM_AUDIO:{
1743       stream->version = RMDEMUX_GUINT16_GET (data + offset + 4);
1744       GST_INFO ("stream version = %u", stream->version);
1745       switch (stream->version) {
1746         case 3:
1747           stream->fourcc = GST_RM_AUD_14_4;
1748           stream->packet_size = 20;
1749           stream->rate = 8000;
1750           stream->n_channels = 1;
1751           stream->sample_width = 16;
1752           stream->flavor = 1;
1753           stream->leaf_size = 0;
1754           stream->height = 0;
1755           break;
1756         case 4:
1757           stream->flavor = RMDEMUX_GUINT16_GET (data + offset + 22);
1758           stream->packet_size = RMDEMUX_GUINT32_GET (data + offset + 24);
1759           /* stream->frame_size = RMDEMUX_GUINT32_GET (data + offset + 42); */
1760           stream->leaf_size = RMDEMUX_GUINT16_GET (data + offset + 44);
1761           stream->height = RMDEMUX_GUINT16_GET (data + offset + 40);
1762           stream->rate = RMDEMUX_GUINT16_GET (data + offset + 48);
1763           stream->sample_width = RMDEMUX_GUINT16_GET (data + offset + 52);
1764           stream->n_channels = RMDEMUX_GUINT16_GET (data + offset + 54);
1765           stream->fourcc = RMDEMUX_FOURCC_GET (data + offset + 62);
1766           stream->extra_data_size = RMDEMUX_GUINT32_GET (data + offset + 69);
1767           GST_DEBUG_OBJECT (rmdemux, "%u bytes of extra codec data",
1768               stream->extra_data_size);
1769           if (length - (offset + 73) >= stream->extra_data_size) {
1770             stream->extra_data = (guint8 *) data + offset + 73;
1771           } else {
1772             GST_WARNING_OBJECT (rmdemux, "codec data runs beyond MDPR chunk");
1773             stream->extra_data_size = 0;
1774           }
1775           break;
1776         case 5:
1777           stream->flavor = RMDEMUX_GUINT16_GET (data + offset + 22);
1778           stream->packet_size = RMDEMUX_GUINT32_GET (data + offset + 24);
1779           /* stream->frame_size = RMDEMUX_GUINT32_GET (data + offset + 42); */
1780           stream->leaf_size = RMDEMUX_GUINT16_GET (data + offset + 44);
1781           stream->height = RMDEMUX_GUINT16_GET (data + offset + 40);
1782           stream->rate = RMDEMUX_GUINT16_GET (data + offset + 54);
1783           stream->sample_width = RMDEMUX_GUINT16_GET (data + offset + 58);
1784           stream->n_channels = RMDEMUX_GUINT16_GET (data + offset + 60);
1785           stream->fourcc = RMDEMUX_FOURCC_GET (data + offset + 66);
1786           stream->extra_data_size = RMDEMUX_GUINT32_GET (data + offset + 74);
1787           GST_DEBUG_OBJECT (rmdemux, "%u bytes of extra codec data",
1788               stream->extra_data_size);
1789           if (length - (offset + 78) >= stream->extra_data_size) {
1790             stream->extra_data = (guint8 *) data + offset + 78;
1791           } else {
1792             GST_WARNING_OBJECT (rmdemux, "codec data runs beyond MDPR chunk");
1793             stream->extra_data_size = 0;
1794           }
1795           break;
1796         default:{
1797           GST_WARNING_OBJECT (rmdemux, "Unhandled audio stream version %d",
1798               stream->version);
1799           break;
1800         }
1801       }
1802       /*  14_4, 28_8, cook, dnet, sipr, raac, racp, ralf, atrc */
1803       GST_DEBUG_OBJECT (rmdemux,
1804           "Audio stream with rate=%d sample_width=%d n_channels=%d",
1805           stream->rate, stream->sample_width, stream->n_channels);
1806
1807       break;
1808     }
1809     case GST_RMDEMUX_STREAM_FILEINFO:
1810     {
1811       int element_nb;
1812
1813       /* Length of this section */
1814       GST_DEBUG_OBJECT (rmdemux, "length2: 0x%08x",
1815           RMDEMUX_GUINT32_GET (data + offset));
1816       offset += 4;
1817
1818       /* Unknown : 00 00 00 00 */
1819       offset += 4;
1820
1821       /* Number of variables that would follow (loop iterations) */
1822       element_nb = RMDEMUX_GUINT32_GET (data + offset);
1823       offset += 4;
1824
1825       while (element_nb) {
1826         /* Category Id : 00 00 00 XX 00 00 */
1827         offset += 6;
1828
1829         /* Variable Name */
1830         offset += re_skip_pascal_string (data + offset);
1831
1832         /* Variable Value Type */
1833         /*   00 00 00 00 00 => integer/boolean, preceded by length */
1834         /*   00 00 00 02 00 => pascal string, preceded by length, no trailing \0 */
1835         offset += 5;
1836
1837         /* Variable Value */
1838         offset += re_skip_pascal_string (data + offset);
1839
1840         element_nb--;
1841       }
1842     }
1843       break;
1844     case GST_RMDEMUX_STREAM_UNKNOWN:
1845     default:
1846       break;
1847   }
1848
1849   gst_rmdemux_add_stream (rmdemux, stream);
1850 }
1851
1852 static guint
1853 gst_rmdemux_parse_indx (GstRMDemux * rmdemux, const guint8 * data, int length)
1854 {
1855   int n;
1856   int id;
1857
1858   n = RMDEMUX_GUINT32_GET (data);
1859   id = RMDEMUX_GUINT16_GET (data + 4);
1860   rmdemux->index_offset = RMDEMUX_GUINT32_GET (data + 6);
1861
1862   GST_DEBUG_OBJECT (rmdemux, "Number of indices=%d Stream ID=%d length=%d", n,
1863       id, length);
1864
1865   /* Point to the next index_stream */
1866   rmdemux->index_stream = gst_rmdemux_get_stream_by_id (rmdemux, id);
1867
1868   /* Return the length of the index */
1869   return 14 * n;
1870 }
1871
1872 static void
1873 gst_rmdemux_parse_indx_data (GstRMDemux * rmdemux, const guint8 * data,
1874     int length)
1875 {
1876   int i;
1877   int n;
1878   GstRMDemuxIndex *index;
1879
1880   /* The number of index records */
1881   n = length / 14;
1882
1883   if (rmdemux->index_stream == NULL)
1884     return;
1885
1886   /* don't parse the index a second time when operating pull-based and
1887    * reaching the end of the file */
1888   if (rmdemux->index_stream->index_length > 0) {
1889     GST_DEBUG_OBJECT (rmdemux, "Already have an index for this stream");
1890     return;
1891   }
1892
1893   index = g_malloc (sizeof (GstRMDemuxIndex) * n);
1894   rmdemux->index_stream->index = index;
1895   rmdemux->index_stream->index_length = n;
1896
1897   for (i = 0; i < n; i++) {
1898     index[i].timestamp = RMDEMUX_GUINT32_GET (data + 2) * GST_MSECOND;
1899     index[i].offset = RMDEMUX_GUINT32_GET (data + 6);
1900
1901     GST_DEBUG_OBJECT (rmdemux, "Index found for timestamp=%f (at offset=%x)",
1902         gst_guint64_to_gdouble (index[i].timestamp) / GST_SECOND,
1903         index[i].offset);
1904     data += 14;
1905   }
1906 }
1907
1908 static void
1909 gst_rmdemux_parse_data (GstRMDemux * rmdemux, const guint8 * data, int length)
1910 {
1911   rmdemux->n_chunks = RMDEMUX_GUINT32_GET (data);
1912   rmdemux->data_offset = RMDEMUX_GUINT32_GET (data + 4);
1913   rmdemux->chunk_index = 0;
1914   GST_DEBUG_OBJECT (rmdemux, "Data chunk found with %d packets "
1915       "(next data at 0x%08x)", rmdemux->n_chunks, rmdemux->data_offset);
1916 }
1917
1918 static void
1919 gst_rmdemux_parse_cont (GstRMDemux * rmdemux, const guint8 * data, int length)
1920 {
1921   GstTagList *tags;
1922
1923   tags = gst_rm_utils_read_tags (data, length, gst_rm_utils_read_string16);
1924
1925   GST_LOG_OBJECT (rmdemux, "tags: %" GST_PTR_FORMAT, tags);
1926
1927   rmdemux->pending_tags =
1928       gst_tag_list_merge (rmdemux->pending_tags, tags, GST_TAG_MERGE_APPEND);
1929   gst_tag_list_unref (tags);
1930 }
1931
1932 static void
1933 gst_rmdemux_stream_clear_cached_subpackets (GstRMDemux * rmdemux,
1934     GstRMDemuxStream * stream)
1935 {
1936   if (stream->subpackets == NULL || stream->subpackets->len == 0)
1937     return;
1938
1939   GST_DEBUG_OBJECT (rmdemux, "discarding %u previously collected subpackets",
1940       stream->subpackets->len);
1941   g_ptr_array_foreach (stream->subpackets, (GFunc) gst_mini_object_unref, NULL);
1942   g_ptr_array_set_size (stream->subpackets, 0);
1943 }
1944
1945 static GstFlowReturn
1946 gst_rmdemux_descramble_audio (GstRMDemux * rmdemux, GstRMDemuxStream * stream)
1947 {
1948   GstFlowReturn ret = GST_FLOW_ERROR;
1949   GstBuffer *outbuf;
1950   GstMapInfo outmap;
1951   guint packet_size = stream->packet_size;
1952   guint height = stream->subpackets->len;
1953   guint leaf_size = stream->leaf_size;
1954   guint p, x;
1955
1956   g_assert (stream->height == height);
1957
1958   GST_LOG ("packet_size = %u, leaf_size = %u, height= %u", packet_size,
1959       leaf_size, height);
1960
1961   outbuf = gst_buffer_new_and_alloc (height * packet_size);
1962   gst_buffer_map (outbuf, &outmap, GST_MAP_WRITE);
1963
1964   for (p = 0; p < height; ++p) {
1965     GstBuffer *b = g_ptr_array_index (stream->subpackets, p);
1966     GstMapInfo map;
1967
1968     gst_buffer_map (b, &map, GST_MAP_READ);
1969
1970     if (p == 0) {
1971       GST_BUFFER_PTS (outbuf) = GST_BUFFER_PTS (b);
1972       GST_BUFFER_DTS (outbuf) = GST_BUFFER_DTS (b);
1973     }
1974
1975     for (x = 0; x < packet_size / leaf_size; ++x) {
1976       guint idx;
1977
1978       idx = height * x + ((height + 1) / 2) * (p % 2) + (p / 2);
1979
1980       /* GST_LOG ("%3u => %3u", (height * p) + x, idx); */
1981       memcpy (outmap.data + leaf_size * idx, map.data + leaf_size * x,
1982           leaf_size);
1983     }
1984     gst_buffer_unmap (b, &map);
1985   }
1986   gst_buffer_unmap (outbuf, &outmap);
1987
1988   /* some decoders, such as realaudiodec, need to be fed in packet units */
1989   for (p = 0; p < height; ++p) {
1990     GstBuffer *subbuf;
1991
1992     subbuf =
1993         gst_buffer_copy_region (outbuf, GST_BUFFER_COPY_ALL, p * packet_size,
1994         packet_size);
1995
1996     GST_LOG_OBJECT (rmdemux, "pushing buffer dts %" GST_TIME_FORMAT ", pts %"
1997         GST_TIME_FORMAT, GST_TIME_ARGS (GST_BUFFER_DTS (subbuf)),
1998         GST_TIME_ARGS (GST_BUFFER_PTS (subbuf)));
1999
2000     if (stream->discont) {
2001       GST_BUFFER_FLAG_SET (subbuf, GST_BUFFER_FLAG_DISCONT);
2002       stream->discont = FALSE;
2003     }
2004
2005     ret = gst_pad_push (stream->pad, subbuf);
2006     if (ret != GST_FLOW_OK)
2007       break;
2008   }
2009
2010   gst_buffer_unref (outbuf);
2011
2012   gst_rmdemux_stream_clear_cached_subpackets (rmdemux, stream);
2013
2014   return ret;
2015 }
2016
2017 static GstFlowReturn
2018 gst_rmdemux_descramble_dnet_audio (GstRMDemux * rmdemux,
2019     GstRMDemuxStream * stream)
2020 {
2021   GstBuffer *buf;
2022
2023   buf = g_ptr_array_index (stream->subpackets, 0);
2024   g_ptr_array_index (stream->subpackets, 0) = NULL;
2025   g_ptr_array_set_size (stream->subpackets, 0);
2026
2027   buf = gst_rm_utils_descramble_dnet_buffer (buf);
2028
2029   if (stream->discont) {
2030     GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
2031     stream->discont = FALSE;
2032   }
2033   return gst_pad_push (stream->pad, buf);
2034 }
2035
2036 static GstFlowReturn
2037 gst_rmdemux_descramble_mp4a_audio (GstRMDemux * rmdemux,
2038     GstRMDemuxStream * stream)
2039 {
2040   GstFlowReturn res;
2041   GstBuffer *buf, *outbuf;
2042   guint frames, index, i;
2043   GstMapInfo map;
2044   GstClockTime timestamp;
2045
2046   res = GST_FLOW_OK;
2047
2048   buf = g_ptr_array_index (stream->subpackets, 0);
2049   g_ptr_array_index (stream->subpackets, 0) = NULL;
2050   g_ptr_array_set_size (stream->subpackets, 0);
2051
2052   gst_buffer_map (buf, &map, GST_MAP_READ);
2053   timestamp = GST_BUFFER_PTS (buf);
2054
2055   frames = (map.data[1] & 0xf0) >> 4;
2056   index = 2 * frames + 2;
2057
2058   for (i = 0; i < frames; i++) {
2059     guint len = (map.data[i * 2 + 2] << 8) | map.data[i * 2 + 3];
2060
2061     outbuf = gst_buffer_copy_region (buf, GST_BUFFER_COPY_ALL, index, len);
2062     if (i == 0) {
2063       GST_BUFFER_PTS (outbuf) = timestamp;
2064       GST_BUFFER_DTS (outbuf) = timestamp;
2065     }
2066
2067     index += len;
2068
2069     if (stream->discont) {
2070       GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
2071       stream->discont = FALSE;
2072     }
2073     res = gst_pad_push (stream->pad, outbuf);
2074     if (res != GST_FLOW_OK)
2075       break;
2076   }
2077   gst_buffer_unmap (buf, &map);
2078   gst_buffer_unref (buf);
2079   return res;
2080 }
2081
2082 static GstFlowReturn
2083 gst_rmdemux_descramble_sipr_audio (GstRMDemux * rmdemux,
2084     GstRMDemuxStream * stream)
2085 {
2086   GstFlowReturn ret;
2087   GstBuffer *outbuf;
2088   GstMapInfo outmap;
2089   guint packet_size = stream->packet_size;
2090   guint height = stream->subpackets->len;
2091   guint p;
2092
2093   g_assert (stream->height == height);
2094
2095   GST_LOG ("packet_size = %u, leaf_size = %u, height= %u", packet_size,
2096       stream->leaf_size, height);
2097
2098   outbuf = gst_buffer_new_and_alloc (height * packet_size);
2099   gst_buffer_map (outbuf, &outmap, GST_MAP_WRITE);
2100
2101   for (p = 0; p < height; ++p) {
2102     GstBuffer *b = g_ptr_array_index (stream->subpackets, p);
2103
2104     if (p == 0) {
2105       GST_BUFFER_DTS (outbuf) = GST_BUFFER_DTS (b);
2106       GST_BUFFER_PTS (outbuf) = GST_BUFFER_PTS (b);
2107     }
2108
2109     gst_buffer_extract (b, 0, outmap.data + packet_size * p, packet_size);
2110   }
2111   gst_buffer_unmap (outbuf, &outmap);
2112
2113   GST_LOG_OBJECT (rmdemux, "pushing buffer dts %" GST_TIME_FORMAT ", pts %"
2114       GST_TIME_FORMAT, GST_TIME_ARGS (GST_BUFFER_DTS (outbuf)),
2115       GST_TIME_ARGS (GST_BUFFER_PTS (outbuf)));
2116
2117   if (stream->discont) {
2118     GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT);
2119     stream->discont = FALSE;
2120   }
2121
2122   outbuf = gst_rm_utils_descramble_sipr_buffer (outbuf);
2123
2124   ret = gst_pad_push (stream->pad, outbuf);
2125
2126   gst_rmdemux_stream_clear_cached_subpackets (rmdemux, stream);
2127
2128   return ret;
2129 }
2130
2131 static GstFlowReturn
2132 gst_rmdemux_handle_scrambled_packet (GstRMDemux * rmdemux,
2133     GstRMDemuxStream * stream, GstBuffer * buf, gboolean keyframe)
2134 {
2135   GstFlowReturn ret;
2136
2137   if (stream->subpackets == NULL)
2138     stream->subpackets = g_ptr_array_sized_new (stream->subpackets_needed);
2139
2140   GST_LOG ("Got subpacket %u/%u, len=%" G_GSIZE_FORMAT ", key=%d",
2141       stream->subpackets->len + 1, stream->subpackets_needed,
2142       gst_buffer_get_size (buf), keyframe);
2143
2144   if (keyframe && stream->subpackets->len > 0) {
2145     gst_rmdemux_stream_clear_cached_subpackets (rmdemux, stream);
2146   }
2147
2148   g_ptr_array_add (stream->subpackets, buf);
2149
2150   if (stream->subpackets->len < stream->subpackets_needed)
2151     return GST_FLOW_OK;
2152
2153   g_assert (stream->subpackets->len >= 1);
2154
2155   switch (stream->fourcc) {
2156     case GST_RM_AUD_DNET:
2157       ret = gst_rmdemux_descramble_dnet_audio (rmdemux, stream);
2158       break;
2159     case GST_RM_AUD_COOK:
2160     case GST_RM_AUD_ATRC:
2161       ret = gst_rmdemux_descramble_audio (rmdemux, stream);
2162       break;
2163     case GST_RM_AUD_RAAC:
2164     case GST_RM_AUD_RACP:
2165       ret = gst_rmdemux_descramble_mp4a_audio (rmdemux, stream);
2166       break;
2167     case GST_RM_AUD_SIPR:
2168       ret = gst_rmdemux_descramble_sipr_audio (rmdemux, stream);
2169       break;
2170     default:
2171       ret = GST_FLOW_ERROR;
2172       g_assert_not_reached ();
2173   }
2174
2175   return ret;
2176 }
2177
2178 #define PARSE_NUMBER(data, size, number, label) \
2179 G_STMT_START {                                  \
2180   if (size < 2)                                 \
2181     goto label;                                 \
2182   number = GST_READ_UINT16_BE (data);           \
2183   if (!(number & 0xc000)) {                     \
2184     if (size < 4)                               \
2185       goto label;                               \
2186     number = GST_READ_UINT32_BE (data);         \
2187     data += 4;                                  \
2188     size -= 4;                                  \
2189   } else {                                      \
2190     number &= 0x3fff;                           \
2191     data += 2;                                  \
2192     size -= 2;                                  \
2193   }                                             \
2194 } G_STMT_END
2195
2196 static GstFlowReturn
2197 gst_rmdemux_parse_video_packet (GstRMDemux * rmdemux, GstRMDemuxStream * stream,
2198     GstBuffer * in, guint offset, guint16 version,
2199     GstClockTime timestamp, gboolean key)
2200 {
2201   GstFlowReturn ret;
2202   GstMapInfo map;
2203   const guint8 *data;
2204   gsize size;
2205
2206   gst_buffer_map (in, &map, GST_MAP_READ);
2207
2208   data = map.data + offset;
2209   size = map.size - offset;
2210
2211   /* if size <= 2, we want this method to return the same GstFlowReturn as it
2212    * was previously for that given stream. */
2213   ret = GST_PAD_LAST_FLOW_RETURN (stream->pad);
2214
2215   while (size > 2) {
2216     guint8 pkg_header;
2217     guint pkg_offset;
2218     guint pkg_length;
2219     guint pkg_subseq = 0, pkg_seqnum = G_MAXUINT;
2220     guint fragment_size;
2221     GstBuffer *fragment;
2222
2223     pkg_header = *data++;
2224     size--;
2225
2226     /* packet header
2227      * bit 7: 1=last block in block chain
2228      * bit 6: 1=short header (only one block?)
2229      */
2230     if ((pkg_header & 0xc0) == 0x40) {
2231       /* skip unknown byte */
2232       data++;
2233       size--;
2234       pkg_offset = 0;
2235       pkg_length = size;
2236     } else {
2237       if ((pkg_header & 0x40) == 0) {
2238         pkg_subseq = (*data++) & 0x7f;
2239         size--;
2240       } else {
2241         pkg_subseq = 0;
2242       }
2243
2244       /* length */
2245       PARSE_NUMBER (data, size, pkg_length, not_enough_data);
2246
2247       /* offset */
2248       PARSE_NUMBER (data, size, pkg_offset, not_enough_data);
2249
2250       /* seqnum */
2251       if (size < 1)
2252         goto not_enough_data;
2253
2254       pkg_seqnum = *data++;
2255       size--;
2256     }
2257
2258     GST_DEBUG_OBJECT (rmdemux,
2259         "seq %d, subseq %d, offset %d, length %d, size %" G_GSIZE_FORMAT
2260         ", header %02x", pkg_seqnum, pkg_subseq, pkg_offset, pkg_length, size,
2261         pkg_header);
2262
2263     /* calc size of fragment */
2264     if ((pkg_header & 0xc0) == 0x80) {
2265       fragment_size = pkg_offset;
2266     } else {
2267       if ((pkg_header & 0xc0) == 0)
2268         fragment_size = size;
2269       else
2270         fragment_size = pkg_length;
2271     }
2272     GST_DEBUG_OBJECT (rmdemux, "fragment size %d", fragment_size);
2273
2274     /* get the fragment */
2275     fragment =
2276         gst_buffer_copy_region (in, GST_BUFFER_COPY_ALL, data - map.data,
2277         fragment_size);
2278
2279     if (pkg_subseq == 1) {
2280       GST_DEBUG_OBJECT (rmdemux, "start new fragment");
2281       gst_adapter_clear (stream->adapter);
2282       stream->frag_current = 0;
2283       stream->frag_count = 0;
2284       stream->frag_length = pkg_length;
2285     } else if (pkg_subseq == 0) {
2286       GST_DEBUG_OBJECT (rmdemux, "non fragmented packet");
2287       stream->frag_current = 0;
2288       stream->frag_count = 0;
2289       stream->frag_length = fragment_size;
2290     }
2291
2292     /* put fragment in adapter */
2293     gst_adapter_push (stream->adapter, fragment);
2294     stream->frag_offset[stream->frag_count] = stream->frag_current;
2295     stream->frag_current += fragment_size;
2296     stream->frag_count++;
2297
2298     if (stream->frag_count > MAX_FRAGS)
2299       goto too_many_fragments;
2300
2301     GST_DEBUG_OBJECT (rmdemux, "stored fragment in adapter %d/%d",
2302         stream->frag_current, stream->frag_length);
2303
2304     /* flush fragment when complete */
2305     if (stream->frag_current >= stream->frag_length) {
2306       GstBuffer *out;
2307       GstMapInfo outmap;
2308       guint8 *outdata;
2309       guint header_size;
2310       gint i, avail;
2311
2312       /* calculate header size, which is:
2313        * 1 byte for the number of fragments - 1
2314        * for each fragment:
2315        *   4 bytes 0x00000001 little endian
2316        *   4 bytes fragment offset
2317        *
2318        * This is also the matroska header for realvideo, the decoder needs the
2319        * fragment offsets, both in ffmpeg and real .so, so we just give it that
2320        * in front of the data.
2321        */
2322       header_size = 1 + (8 * (stream->frag_count));
2323
2324       GST_DEBUG_OBJECT (rmdemux,
2325           "fragmented completed. count %d, header_size %u", stream->frag_count,
2326           header_size);
2327
2328       avail = gst_adapter_available (stream->adapter);
2329
2330       out = gst_buffer_new_and_alloc (header_size + avail);
2331       gst_buffer_map (out, &outmap, GST_MAP_WRITE);
2332       outdata = outmap.data;
2333
2334       /* create header */
2335       *outdata++ = stream->frag_count - 1;
2336       for (i = 0; i < stream->frag_count; i++) {
2337         GST_WRITE_UINT32_LE (outdata, 0x00000001);
2338         outdata += 4;
2339         GST_WRITE_UINT32_LE (outdata, stream->frag_offset[i]);
2340         outdata += 4;
2341       }
2342
2343       /* copy packet data after the header now */
2344       gst_adapter_copy (stream->adapter, outdata, 0, avail);
2345       gst_adapter_flush (stream->adapter, avail);
2346
2347       stream->frag_current = 0;
2348       stream->frag_count = 0;
2349       stream->frag_length = 0;
2350
2351       if (timestamp != -1) {
2352         if (rmdemux->first_ts != -1 && timestamp > rmdemux->first_ts)
2353           timestamp -= rmdemux->first_ts;
2354         else
2355           timestamp = 0;
2356
2357         if (rmdemux->base_ts != -1)
2358           timestamp += rmdemux->base_ts;
2359       }
2360       gst_buffer_unmap (out, &outmap);
2361
2362       /* video has DTS */
2363       GST_BUFFER_DTS (out) = timestamp;
2364       GST_BUFFER_PTS (out) = GST_CLOCK_TIME_NONE;
2365
2366       GST_LOG_OBJECT (rmdemux, "pushing timestamp %" GST_TIME_FORMAT,
2367           GST_TIME_ARGS (timestamp));
2368
2369       if (stream->discont) {
2370         GST_BUFFER_FLAG_SET (out, GST_BUFFER_FLAG_DISCONT);
2371         stream->discont = FALSE;
2372       }
2373
2374       if (!key) {
2375         GST_BUFFER_FLAG_SET (out, GST_BUFFER_FLAG_DELTA_UNIT);
2376       }
2377
2378       ret = gst_pad_push (stream->pad, out);
2379       ret = gst_flow_combiner_update_flow (rmdemux->flowcombiner, ret);
2380       if (ret != GST_FLOW_OK)
2381         break;
2382
2383       timestamp = GST_CLOCK_TIME_NONE;
2384     }
2385     data += fragment_size;
2386     size -= fragment_size;
2387   }
2388   GST_DEBUG_OBJECT (rmdemux, "%" G_GSIZE_FORMAT " bytes left", size);
2389
2390 done:
2391   gst_buffer_unmap (in, &map);
2392   gst_buffer_unref (in);
2393
2394   return ret;
2395
2396   /* ERRORS */
2397 not_enough_data:
2398   {
2399     GST_ELEMENT_WARNING (rmdemux, STREAM, DECODE, ("Skipping bad packet."),
2400         (NULL));
2401     ret = GST_FLOW_OK;
2402     goto done;
2403   }
2404 too_many_fragments:
2405   {
2406     GST_ELEMENT_ERROR (rmdemux, STREAM, DECODE,
2407         ("Got more fragments (%u) than can be handled (%u)",
2408             stream->frag_count, MAX_FRAGS), (NULL));
2409     ret = GST_FLOW_ERROR;
2410     goto done;
2411   }
2412 }
2413
2414 static GstFlowReturn
2415 gst_rmdemux_parse_audio_packet (GstRMDemux * rmdemux, GstRMDemuxStream * stream,
2416     GstBuffer * in, guint offset, guint16 version,
2417     GstClockTime timestamp, gboolean key)
2418 {
2419   GstFlowReturn ret;
2420   GstBuffer *buffer;
2421
2422   buffer = gst_buffer_copy_region (in, GST_BUFFER_COPY_MEMORY, offset, -1);
2423
2424   if (rmdemux->first_ts != -1 && timestamp > rmdemux->first_ts)
2425     timestamp -= rmdemux->first_ts;
2426   else
2427     timestamp = 0;
2428
2429   if (rmdemux->base_ts != -1)
2430     timestamp += rmdemux->base_ts;
2431
2432   GST_BUFFER_PTS (buffer) = timestamp;
2433   GST_BUFFER_DTS (buffer) = timestamp;
2434
2435   if (stream->needs_descrambling) {
2436     GST_LOG_OBJECT (rmdemux, "descramble timestamp %" GST_TIME_FORMAT,
2437         GST_TIME_ARGS (timestamp));
2438     ret = gst_rmdemux_handle_scrambled_packet (rmdemux, stream, buffer, key);
2439   } else {
2440     GST_LOG_OBJECT (rmdemux,
2441         "Pushing buffer of size %" G_GSIZE_FORMAT ", timestamp %"
2442         GST_TIME_FORMAT "to pad %s", gst_buffer_get_size (buffer),
2443         GST_TIME_ARGS (timestamp), GST_PAD_NAME (stream->pad));
2444
2445     if (stream->discont) {
2446       GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT);
2447       stream->discont = FALSE;
2448     }
2449     ret = gst_pad_push (stream->pad, buffer);
2450   }
2451
2452   gst_buffer_unref (in);
2453
2454   return ret;
2455 }
2456
2457 static GstFlowReturn
2458 gst_rmdemux_parse_packet (GstRMDemux * rmdemux, GstBuffer * in, guint16 version)
2459 {
2460   guint16 id;
2461   GstRMDemuxStream *stream;
2462   gsize size, offset;
2463   GstFlowReturn cret, ret;
2464   GstClockTime timestamp;
2465   gboolean key;
2466   GstMapInfo map;
2467   guint8 *data;
2468   guint8 flags;
2469   guint32 ts;
2470
2471   gst_buffer_map (in, &map, GST_MAP_READ);
2472   data = map.data;
2473   size = map.size;
2474
2475   /* stream number */
2476   id = RMDEMUX_GUINT16_GET (data);
2477
2478   stream = gst_rmdemux_get_stream_by_id (rmdemux, id);
2479   if (!stream || !stream->pad)
2480     goto unknown_stream;
2481
2482   /* timestamp in Msec */
2483   ts = RMDEMUX_GUINT32_GET (data + 2);
2484   timestamp = ts * GST_MSECOND;
2485
2486   rmdemux->segment.position = timestamp;
2487
2488   GST_LOG_OBJECT (rmdemux, "Parsing a packet for stream=%d, timestamp=%"
2489       GST_TIME_FORMAT ", size %" G_GSIZE_FORMAT ", version=%d, ts=%u", id,
2490       GST_TIME_ARGS (timestamp), size, version, ts);
2491
2492   if (rmdemux->first_ts == GST_CLOCK_TIME_NONE) {
2493     GST_DEBUG_OBJECT (rmdemux, "First timestamp: %" GST_TIME_FORMAT,
2494         GST_TIME_ARGS (timestamp));
2495     rmdemux->first_ts = timestamp;
2496   }
2497
2498   /* skip stream_id and timestamp */
2499   data += (2 + 4);
2500   size -= (2 + 4);
2501
2502   /* get flags */
2503   flags = GST_READ_UINT8 (data + 1);
2504
2505   data += 2;
2506   size -= 2;
2507
2508   /* version 1 has an extra byte */
2509   if (version == 1) {
2510     data += 1;
2511     size -= 1;
2512   }
2513   offset = data - map.data;
2514   gst_buffer_unmap (in, &map);
2515
2516   key = (flags & 0x02) != 0;
2517   GST_DEBUG_OBJECT (rmdemux, "flags %d, Keyframe %d", flags, key);
2518
2519   if (rmdemux->need_newsegment) {
2520     GstEvent *event;
2521
2522     event = gst_event_new_segment (&rmdemux->segment);
2523
2524     GST_DEBUG_OBJECT (rmdemux, "sending NEWSEGMENT event, segment.start= %"
2525         GST_TIME_FORMAT, GST_TIME_ARGS (rmdemux->segment.start));
2526
2527     gst_rmdemux_send_event (rmdemux, event);
2528     rmdemux->need_newsegment = FALSE;
2529
2530     if (rmdemux->pending_tags != NULL) {
2531       gst_rmdemux_send_event (rmdemux,
2532           gst_event_new_tag (rmdemux->pending_tags));
2533       rmdemux->pending_tags = NULL;
2534     }
2535   }
2536
2537   if (stream->pending_tags != NULL) {
2538     GST_LOG_OBJECT (stream->pad, "tags %" GST_PTR_FORMAT, stream->pending_tags);
2539     gst_pad_push_event (stream->pad, gst_event_new_tag (stream->pending_tags));
2540     stream->pending_tags = NULL;
2541   }
2542
2543   if ((rmdemux->offset + size) <= stream->seek_offset) {
2544     GST_DEBUG_OBJECT (rmdemux,
2545         "Stream %d is skipping: seek_offset=%d, offset=%d, size=%"
2546         G_GSIZE_FORMAT, stream->id, stream->seek_offset, rmdemux->offset, size);
2547     cret = GST_FLOW_OK;
2548     gst_buffer_unref (in);
2549     goto beach;
2550   }
2551
2552   /* do special headers */
2553   if (stream->subtype == GST_RMDEMUX_STREAM_VIDEO) {
2554     ret =
2555         gst_rmdemux_parse_video_packet (rmdemux, stream, in, offset,
2556         version, timestamp, key);
2557   } else if (stream->subtype == GST_RMDEMUX_STREAM_AUDIO) {
2558     ret =
2559         gst_rmdemux_parse_audio_packet (rmdemux, stream, in, offset,
2560         version, timestamp, key);
2561   } else {
2562     gst_buffer_unref (in);
2563     ret = GST_FLOW_OK;
2564   }
2565
2566   cret = gst_flow_combiner_update_pad_flow (rmdemux->flowcombiner, stream->pad,
2567       ret);
2568
2569 beach:
2570   return cret;
2571
2572   /* ERRORS */
2573 unknown_stream:
2574   {
2575     GST_WARNING_OBJECT (rmdemux, "No stream for stream id %d in parsing "
2576         "data packet", id);
2577     gst_buffer_unmap (in, &map);
2578     gst_buffer_unref (in);
2579     return GST_FLOW_OK;
2580   }
2581 }
2582
2583 gboolean
2584 gst_rmdemux_plugin_init (GstPlugin * plugin)
2585 {
2586   return gst_element_register (plugin, "rmdemux",
2587       GST_RANK_PRIMARY, GST_TYPE_RMDEMUX);
2588 }