ext/theora/gsttheoraparse.c

   1 /* GStreamer
   2  * Copyright (C) <2004> Thomas Vander Stichele <thomas at apestaart dot org>
   3  * Copyright (C) 2006 Andy Wingo <wingo@pobox.com>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 /**
  22  * SECTION:element-theoraparse
  23  * @see_also: theoradec, oggdemux, vorbisparse
  24  *
  25  * The theoraparse element will parse the header packets of the Theora
  26  * stream and put them as the streamheader in the caps. This is used in the
  27  * multifdsink case where you want to stream live theora streams to multiple
  28  * clients, each client has to receive the streamheaders first before they can
  29  * consume the theora packets.
  30  *
  31  * This element also makes sure that the buffers that it pushes out are properly
  32  * timestamped and that their offset and offset_end are set. The buffers that
  33  * theoraparse outputs have all of the metadata that oggmux expects to receive,
  34  * which allows you to (for example) remux an ogg/theora file.
  35  *
  36  * In addition, this element allows you to fix badly synchronized streams. You
  37  * pass in an array of (granule time, buffer time) synchronization points via
  38  * the synchronization-points GValueArray property, and this element will adjust
  39  * the granulepos values that it outputs. The adjustment will be made by
  40  * offsetting all buffers that it outputs by a specified amount, and updating
  41  * that offset from the value array whenever a keyframe is processed.
  42  *
  43  * <refsect2>
  44  * <title>Example pipelines</title>
  45  * |[
  46  * gst-launch -v filesrc location=video.ogg ! oggdemux ! theoraparse ! fakesink
  47  * ]| This pipeline shows that the streamheader is set in the caps, and that each
  48  * buffer has the timestamp, duration, offset, and offset_end set.
  49  * |[
  50  * gst-launch filesrc location=video.ogg ! oggdemux ! theoraparse \
  51  *            ! oggmux ! filesink location=video-remuxed.ogg
  52  * ]| This pipeline shows remuxing. video-remuxed.ogg might not be exactly the same
  53  * as video.ogg, but they should produce exactly the same decoded data.
  54  * </refsect2>
  55  *
  56  * Last reviewed on 2008-05-28 (0.10.20)
  57  */
  58
  59 /* FIXME 0.11: suppress warnings for deprecated API such as GValueArray
  60  * with newer GLib versions (>= 2.31.0) */
  61 #define GLIB_DISABLE_DEPRECATION_WARNINGS
  62
  63 #ifdef HAVE_CONFIG_H
  64 #  include "config.h"
  65 #endif
  66
  67 #include "gsttheoraparse.h"
  68
  69 #define GST_CAT_DEFAULT theoraparse_debug
  70 GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
  71
  72 static GstStaticPadTemplate theora_parse_sink_factory =
  73 GST_STATIC_PAD_TEMPLATE ("sink",
  74     GST_PAD_SINK,
  75     GST_PAD_ALWAYS,
  76     GST_STATIC_CAPS ("video/x-theora")
  77     );
  78
  79 static GstStaticPadTemplate theora_parse_src_factory =
  80 GST_STATIC_PAD_TEMPLATE ("src",
  81     GST_PAD_SRC,
  82     GST_PAD_ALWAYS,
  83     GST_STATIC_CAPS ("video/x-theora")
  84     );
  85
  86 enum
  87 {
  88   PROP_0,
  89   PROP_SYNCHRONIZATION_POINTS
  90 };
  91
  92 #define gst_theora_parse_parent_class parent_class
  93 G_DEFINE_TYPE (GstTheoraParse, gst_theora_parse, GST_TYPE_ELEMENT);
  94
  95 static void theora_parse_dispose (GObject * object);
  96
  97 #if 0
  98 static void theora_parse_get_property (GObject * object, guint prop_id,
  99     GValue * value, GParamSpec * pspec);
 100 static void theora_parse_set_property (GObject * object, guint prop_id,
 101     const GValue * value, GParamSpec * pspec);
 102 #endif
 103
 104 static GstFlowReturn theora_parse_chain (GstPad * pad, GstObject * parent,
 105     GstBuffer * buffer);
 106 static GstStateChangeReturn theora_parse_change_state (GstElement * element,
 107     GstStateChange transition);
 108 static gboolean theora_parse_sink_event (GstPad * pad, GstObject * parent,
 109     GstEvent * event);
 110 static gboolean theora_parse_src_query (GstPad * pad, GstObject * parent,
 111     GstQuery * query);
 112
 113 static void
 114 gst_theora_parse_class_init (GstTheoraParseClass * klass)
 115 {
 116   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 117   GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
 118
 119   gobject_class->dispose = theora_parse_dispose;
 120
 121 #if 0
 122   gobject_class->get_property = theora_parse_get_property;
 123   gobject_class->set_property = theora_parse_set_property;
 124
 125   /**
 126    * GstTheoraParse:sychronization-points
 127    *
 128    * An array of (granuletime, buffertime) pairs
 129    *
 130    * Since: 0.10.10
 131    */
 132   g_object_class_install_property (gobject_class, PROP_SYNCHRONIZATION_POINTS,
 133       g_param_spec_value_array ("synchronization-points",
 134           "Synchronization points",
 135           "An array of (granuletime, buffertime) pairs",
 136           g_param_spec_uint64 ("time", "Time",
 137               "Time (either granuletime or buffertime)", 0, G_MAXUINT64, 0,
 138               G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS),
 139           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 140 #endif
 141
 142   gst_element_class_add_pad_template (gstelement_class,
 143       gst_static_pad_template_get (&theora_parse_src_factory));
 144   gst_element_class_add_pad_template (gstelement_class,
 145       gst_static_pad_template_get (&theora_parse_sink_factory));
 146   gst_element_class_set_details_simple (gstelement_class,
 147       "Theora video parser", "Codec/Parser/Video",
 148       "parse raw theora streams", "Andy Wingo <wingo@pobox.com>");
 149
 150   gstelement_class->change_state = theora_parse_change_state;
 151
 152   GST_DEBUG_CATEGORY_INIT (theoraparse_debug, "theoraparse", 0,
 153       "Theora parser");
 154 }
 155
 156 static void
 157 gst_theora_parse_init (GstTheoraParse * parse)
 158 {
 159   parse->sinkpad =
 160       gst_pad_new_from_static_template (&theora_parse_sink_factory, "sink");
 161   gst_pad_set_chain_function (parse->sinkpad, theora_parse_chain);
 162   gst_pad_set_event_function (parse->sinkpad, theora_parse_sink_event);
 163   gst_element_add_pad (GST_ELEMENT (parse), parse->sinkpad);
 164
 165   parse->srcpad =
 166       gst_pad_new_from_static_template (&theora_parse_src_factory, "src");
 167   gst_pad_set_query_function (parse->srcpad, theora_parse_src_query);
 168   gst_element_add_pad (GST_ELEMENT (parse), parse->srcpad);
 169 }
 170
 171 static void
 172 theora_parse_dispose (GObject * object)
 173 {
 174   GstTheoraParse *parse = GST_THEORA_PARSE (object);
 175
 176   g_free (parse->times);
 177   parse->times = NULL;
 178
 179   G_OBJECT_CLASS (parent_class)->dispose (object);
 180 }
 181
 182 #if 0
 183 static void
 184 theora_parse_set_property (GObject * object, guint prop_id,
 185     const GValue * value, GParamSpec * pspec)
 186 {
 187   GstTheoraParse *parse = GST_THEORA_PARSE (object);
 188
 189   switch (prop_id) {
 190     case PROP_SYNCHRONIZATION_POINTS:
 191     {
 192       GValueArray *array;
 193       guint i;
 194
 195       array = g_value_get_boxed (value);
 196
 197       if (array) {
 198         if (array->n_values % 2)
 199           goto odd_values;
 200
 201         g_free (parse->times);
 202         parse->times = g_new (GstClockTime, array->n_values);
 203         parse->npairs = array->n_values / 2;
 204         for (i = 0; i < array->n_values; i++)
 205           parse->times[i] = g_value_get_uint64 (&array->values[i]);
 206       } else {
 207         g_free (parse->times);
 208         parse->npairs = 0;
 209       }
 210     }
 211       break;
 212     default:
 213       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 214       break;
 215   }
 216
 217   return;
 218
 219 odd_values:
 220   {
 221     g_critical ("expected an even number of time values for "
 222         "synchronization-points");
 223     return;
 224   }
 225 }
 226
 227 static void
 228 theora_parse_get_property (GObject * object, guint prop_id,
 229     GValue * value, GParamSpec * pspec)
 230 {
 231   GstTheoraParse *parse = GST_THEORA_PARSE (object);
 232
 233   switch (prop_id) {
 234     case PROP_SYNCHRONIZATION_POINTS:
 235     {
 236       GValueArray *array = NULL;
 237       guint i;
 238
 239       array = g_value_array_new (parse->npairs * 2);
 240
 241       for (i = 0; i < parse->npairs; i++) {
 242         GValue v = { 0, };
 243
 244         g_value_init (&v, G_TYPE_UINT64);
 245         g_value_set_uint64 (&v, parse->times[i * 2]);
 246         g_value_array_append (array, &v);
 247         g_value_set_uint64 (&v, parse->times[i * 2 + 1]);
 248         g_value_array_append (array, &v);
 249         g_value_unset (&v);
 250       }
 251
 252       g_value_take_boxed (value, array);
 253     }
 254       break;
 255     default:
 256       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 257       break;
 258   }
 259 }
 260 #endif
 261
 262 static void
 263 theora_parse_set_header_on_caps (GstTheoraParse * parse, GstCaps * caps)
 264 {
 265   GstBuffer **bufs;
 266   GstStructure *structure;
 267   gint i;
 268   GValue array = { 0 };
 269   GValue value = { 0 };
 270
 271   bufs = parse->streamheader;
 272   structure = gst_caps_get_structure (caps, 0);
 273   g_value_init (&array, GST_TYPE_ARRAY);
 274
 275   for (i = 0; i < 3; i++) {
 276     if (bufs[i] == NULL)
 277       continue;
 278
 279     bufs[i] = gst_buffer_make_writable (bufs[i]);
 280     GST_BUFFER_FLAG_SET (bufs[i], GST_BUFFER_FLAG_HEADER);
 281
 282     g_value_init (&value, GST_TYPE_BUFFER);
 283     gst_value_set_buffer (&value, bufs[i]);
 284     gst_value_array_append_value (&array, &value);
 285     g_value_unset (&value);
 286   }
 287
 288   gst_structure_set_value (structure, "streamheader", &array);
 289   g_value_unset (&array);
 290 }
 291
 292 /* two tasks to do here: set the streamheader on the caps, and use libtheora to
 293    parse the headers */
 294 static void
 295 theora_parse_set_streamheader (GstTheoraParse * parse)
 296 {
 297   GstCaps *caps;
 298   gint i;
 299   guint32 bitstream_version;
 300   th_setup_info *setup = NULL;
 301
 302   g_assert (!parse->streamheader_received);
 303
 304   caps = gst_caps_make_writable (gst_pad_query_caps (parse->srcpad, NULL));
 305   theora_parse_set_header_on_caps (parse, caps);
 306   GST_DEBUG_OBJECT (parse, "here are the caps: %" GST_PTR_FORMAT, caps);
 307   gst_pad_set_caps (parse->srcpad, caps);
 308   gst_caps_unref (caps);
 309
 310   for (i = 0; i < 3; i++) {
 311     ogg_packet packet;
 312     GstBuffer *buf;
 313     int ret;
 314     GstMapInfo map;
 315
 316     buf = parse->streamheader[i];
 317     if (buf == NULL)
 318       continue;
 319
 320     gst_buffer_map (buf, &map, GST_MAP_READ);
 321     packet.packet = map.data;
 322     packet.bytes = map.size;
 323     packet.granulepos = GST_BUFFER_OFFSET_END (buf);
 324     packet.packetno = i + 1;
 325     packet.e_o_s = 0;
 326     packet.b_o_s = (i == 0);
 327     ret = th_decode_headerin (&parse->info, &parse->comment, &setup, &packet);
 328     gst_buffer_unmap (buf, &map);
 329     if (ret < 0) {
 330       GST_WARNING_OBJECT (parse, "Failed to decode Theora header %d: %d\n",
 331           i + 1, ret);
 332     }
 333   }
 334   if (setup) {
 335     th_setup_free (setup);
 336   }
 337
 338   parse->fps_n = parse->info.fps_numerator;
 339   parse->fps_d = parse->info.fps_denominator;
 340   parse->shift = parse->info.keyframe_granule_shift;
 341
 342   /* With libtheora-1.0beta1 the granulepos scheme was changed:
 343    * where earlier the granulepos referred to the index/beginning
 344    * of a frame, it now refers to the end, which matches the use
 345    * in vorbis/speex. We check the bitstream version from the header so
 346    * we know which way to interpret the incoming granuepos
 347    */
 348   bitstream_version = (parse->info.version_major << 16) |
 349       (parse->info.version_minor << 8) | parse->info.version_subminor;
 350   parse->is_old_bitstream = (bitstream_version <= 0x00030200);
 351
 352   parse->streamheader_received = TRUE;
 353 }
 354
 355 static void
 356 theora_parse_drain_event_queue (GstTheoraParse * parse)
 357 {
 358   while (parse->event_queue->length) {
 359     GstEvent *event;
 360
 361     event = GST_EVENT_CAST (g_queue_pop_head (parse->event_queue));
 362     gst_pad_event_default (parse->sinkpad, GST_OBJECT_CAST (parse), event);
 363   }
 364 }
 365
 366 static void
 367 theora_parse_push_headers (GstTheoraParse * parse)
 368 {
 369   gint i;
 370
 371   theora_parse_drain_event_queue (parse);
 372
 373   if (!parse->streamheader_received)
 374     theora_parse_set_streamheader (parse);
 375
 376   /* ignore return values, we pass along the result of pushing data packets only
 377    */
 378   for (i = 0; i < 3; i++) {
 379     GstBuffer *buf;
 380
 381     if ((buf = parse->streamheader[i])) {
 382       gst_pad_push (parse->srcpad, buf);
 383       parse->streamheader[i] = NULL;
 384     }
 385   }
 386 }
 387
 388 static void
 389 theora_parse_clear_queue (GstTheoraParse * parse)
 390 {
 391   while (parse->buffer_queue->length) {
 392     GstBuffer *buf;
 393
 394     buf = GST_BUFFER_CAST (g_queue_pop_head (parse->buffer_queue));
 395     gst_buffer_unref (buf);
 396   }
 397   while (parse->event_queue->length) {
 398     GstEvent *event;
 399
 400     event = GST_EVENT_CAST (g_queue_pop_head (parse->event_queue));
 401     gst_event_unref (event);
 402   }
 403 }
 404
 405 static gint64
 406 make_granulepos (GstTheoraParse * parse, gint64 keyframe, gint64 frame)
 407 {
 408   gint64 iframe;
 409
 410   if (keyframe == -1)
 411     keyframe = 0;
 412   /* If using newer theora, offset the granulepos by +1, see comment in
 413    * theora_parse_set_streamheader.
 414    *
 415    * We don't increment keyframe directly, as internally we always index frames
 416    * starting from 0 and we do some sanity checking below. */
 417   if (!parse->is_old_bitstream)
 418     iframe = keyframe + 1;
 419   else
 420     iframe = keyframe;
 421
 422   g_return_val_if_fail (frame >= keyframe, -1);
 423   g_return_val_if_fail (frame - keyframe < 1 << parse->shift, -1);
 424
 425   return (iframe << parse->shift) + (frame - keyframe);
 426 }
 427
 428 static void
 429 parse_granulepos (GstTheoraParse * parse, gint64 granulepos,
 430     gint64 * keyframe, gint64 * frame)
 431 {
 432   gint64 kf;
 433
 434   kf = granulepos >> parse->shift;
 435   /* If using newer theora, offset the granulepos by -1, see comment
 436    * in theora_parse_set_streamheader */
 437   if (!parse->is_old_bitstream)
 438     kf -= 1;
 439   if (keyframe)
 440     *keyframe = kf;
 441   if (frame)
 442     *frame = kf + (granulepos & ((1 << parse->shift) - 1));
 443 }
 444
 445 static gboolean
 446 is_keyframe (GstBuffer * buf)
 447 {
 448   gsize size;
 449   guint8 data[1];
 450
 451   size = gst_buffer_get_size (buf);
 452   if (size == 0)
 453     return FALSE;
 454
 455   gst_buffer_extract (buf, 0, data, 1);
 456
 457   return ((data[0] & 0x40) == 0);
 458 }
 459
 460 static void
 461 theora_parse_munge_granulepos (GstTheoraParse * parse, GstBuffer * buf,
 462     gint64 keyframe, gint64 frame)
 463 {
 464   gint64 frames_diff;
 465   GstClockTimeDiff time_diff;
 466
 467   if (keyframe == frame) {
 468     gint i;
 469
 470     /* update granule_offset */
 471     for (i = 0; i < parse->npairs; i++) {
 472       if (parse->times[i * 2] >= GST_BUFFER_OFFSET (buf))
 473         break;
 474     }
 475     if (i > 0) {
 476       /* time_diff gets reset below */
 477       time_diff = parse->times[i * 2 - 1] - parse->times[i * 2 - 2];
 478       parse->granule_offset = gst_util_uint64_scale (time_diff,
 479           parse->fps_n, parse->fps_d * GST_SECOND);
 480       parse->granule_offset <<= parse->shift;
 481     }
 482   }
 483
 484   frames_diff = parse->granule_offset >> parse->shift;
 485   time_diff = gst_util_uint64_scale_int (GST_SECOND * frames_diff,
 486       parse->fps_d, parse->fps_n);
 487
 488   GST_DEBUG_OBJECT (parse, "offsetting theora stream by %" G_GINT64_FORMAT
 489       " frames (%" GST_TIME_FORMAT ")", frames_diff, GST_TIME_ARGS (time_diff));
 490
 491   GST_BUFFER_OFFSET_END (buf) += parse->granule_offset;
 492   GST_BUFFER_OFFSET (buf) += time_diff;
 493   GST_BUFFER_TIMESTAMP (buf) += time_diff;
 494 }
 495
 496 static GstFlowReturn
 497 theora_parse_push_buffer (GstTheoraParse * parse, GstBuffer * buf,
 498     gint64 keyframe, gint64 frame)
 499 {
 500
 501   GstClockTime this_time, next_time;
 502
 503   this_time = gst_util_uint64_scale_int (GST_SECOND * frame,
 504       parse->fps_d, parse->fps_n);
 505
 506   next_time = gst_util_uint64_scale_int (GST_SECOND * (frame + 1),
 507       parse->fps_d, parse->fps_n);
 508
 509   GST_BUFFER_OFFSET_END (buf) = make_granulepos (parse, keyframe, frame);
 510   GST_BUFFER_OFFSET (buf) = this_time;
 511   GST_BUFFER_TIMESTAMP (buf) = this_time;
 512   GST_BUFFER_DURATION (buf) = next_time - this_time;
 513
 514   if (parse->times)
 515     theora_parse_munge_granulepos (parse, buf, keyframe, frame);
 516
 517   GST_DEBUG_OBJECT (parse, "pushing buffer with granulepos %" G_GINT64_FORMAT
 518       "|%" G_GINT64_FORMAT, keyframe, frame - keyframe);
 519
 520   return gst_pad_push (parse->srcpad, buf);
 521 }
 522
 523 static GstFlowReturn
 524 theora_parse_drain_queue_prematurely (GstTheoraParse * parse)
 525 {
 526   GstFlowReturn ret = GST_FLOW_OK;
 527
 528   /* got an EOS event, make sure to push out any buffers that were in the queue
 529    * -- won't normally be the case, but this catches the
 530    * didn't-get-a-granulepos-on-the-last-packet case. Assuming a continuous
 531    * stream. */
 532
 533   GST_DEBUG_OBJECT (parse, "got EOS, draining queue");
 534
 535   /* if we get an eos before pushing the streamheaders, drain our events before
 536    * eos */
 537   theora_parse_drain_event_queue (parse);
 538
 539   while (!g_queue_is_empty (parse->buffer_queue)) {
 540     GstBuffer *buf;
 541
 542     buf = GST_BUFFER_CAST (g_queue_pop_head (parse->buffer_queue));
 543
 544     parse->prev_frame++;
 545
 546     if (is_keyframe (buf))
 547       /* we have a keyframe */
 548       parse->prev_keyframe = parse->prev_frame;
 549     else
 550       GST_BUFFER_FLAGS (buf) |= GST_BUFFER_FLAG_DELTA_UNIT;
 551
 552     if (parse->prev_keyframe < 0) {
 553       if (GST_BUFFER_OFFSET_END_IS_VALID (buf)) {
 554         parse_granulepos (parse, GST_BUFFER_OFFSET_END (buf),
 555             &parse->prev_keyframe, NULL);
 556       } else {
 557         /* No previous keyframe known; can't extract one from this frame. That
 558          * means we can't do any valid output for this frame, just continue to
 559          * the next frame.
 560          */
 561         gst_buffer_unref (buf);
 562         continue;
 563       }
 564     }
 565
 566     ret = theora_parse_push_buffer (parse, buf, parse->prev_keyframe,
 567         parse->prev_frame);
 568
 569     if (ret != GST_FLOW_OK)
 570       goto done;
 571   }
 572
 573 done:
 574   return ret;
 575 }
 576
 577 static GstFlowReturn
 578 theora_parse_drain_queue (GstTheoraParse * parse, gint64 granulepos)
 579 {
 580   GstFlowReturn ret = GST_FLOW_OK;
 581   gint64 keyframe, prev_frame, frame;
 582
 583   parse_granulepos (parse, granulepos, &keyframe, &frame);
 584
 585   GST_DEBUG ("draining queue of length %d",
 586       g_queue_get_length (parse->buffer_queue));
 587
 588   GST_LOG_OBJECT (parse, "gp %" G_GINT64_FORMAT ", kf %" G_GINT64_FORMAT
 589       ", frame %" G_GINT64_FORMAT, granulepos, keyframe, frame);
 590
 591   prev_frame = frame - g_queue_get_length (parse->buffer_queue);
 592
 593   GST_LOG_OBJECT (parse,
 594       "new prev %" G_GINT64_FORMAT ", prev %" G_GINT64_FORMAT, prev_frame,
 595       parse->prev_frame);
 596
 597   if (prev_frame < parse->prev_frame) {
 598     GST_WARNING ("jumped %" G_GINT64_FORMAT
 599         " frames backwards! not sure what to do here",
 600         parse->prev_frame - prev_frame);
 601     parse->prev_frame = prev_frame;
 602   } else if (prev_frame > parse->prev_frame) {
 603     GST_INFO ("discontinuity detected (%" G_GINT64_FORMAT
 604         " frames)", prev_frame - parse->prev_frame);
 605     if (keyframe <= prev_frame && keyframe > parse->prev_keyframe)
 606       parse->prev_keyframe = keyframe;
 607     parse->prev_frame = prev_frame;
 608   }
 609
 610   while (!g_queue_is_empty (parse->buffer_queue)) {
 611     GstBuffer *buf;
 612
 613     parse->prev_frame++;
 614     g_assert (parse->prev_frame >= 0);
 615
 616     buf = GST_BUFFER_CAST (g_queue_pop_head (parse->buffer_queue));
 617
 618     if (is_keyframe (buf))
 619       /* we have a keyframe */
 620       parse->prev_keyframe = parse->prev_frame;
 621     else
 622       GST_BUFFER_FLAGS (buf) |= GST_BUFFER_FLAG_DELTA_UNIT;
 623
 624     ret = theora_parse_push_buffer (parse, buf, parse->prev_keyframe,
 625         parse->prev_frame);
 626
 627     if (ret != GST_FLOW_OK)
 628       goto done;
 629   }
 630
 631 done:
 632   return ret;
 633 }
 634
 635 static GstFlowReturn
 636 theora_parse_queue_buffer (GstTheoraParse * parse, GstBuffer * buf)
 637 {
 638   GstFlowReturn ret = GST_FLOW_OK;
 639
 640   buf = gst_buffer_make_writable (buf);
 641
 642   g_queue_push_tail (parse->buffer_queue, buf);
 643
 644   if (GST_BUFFER_OFFSET_END_IS_VALID (buf)) {
 645     if (parse->prev_keyframe < 0) {
 646       parse_granulepos (parse, GST_BUFFER_OFFSET_END (buf),
 647           &parse->prev_keyframe, NULL);
 648     }
 649     ret = theora_parse_drain_queue (parse, GST_BUFFER_OFFSET_END (buf));
 650   }
 651
 652   return ret;
 653 }
 654
 655 static GstFlowReturn
 656 theora_parse_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
 657 {
 658   GstFlowReturn ret;
 659   GstTheoraParse *parse;
 660   GstMapInfo map;
 661   guint8 header;
 662   gboolean have_header;
 663
 664   parse = GST_THEORA_PARSE (parent);
 665
 666   have_header = FALSE;
 667
 668   gst_buffer_map (buffer, &map, GST_MAP_READ);
 669   header = map.data[0];
 670   gst_buffer_unmap (buffer, &map);
 671
 672   if (map.size >= 1) {
 673     if (header & 0x80)
 674       have_header = TRUE;
 675   }
 676
 677   if (have_header) {
 678     if (parse->send_streamheader) {
 679       /* we need to collect the headers still */
 680       /* so put it on the streamheader list and return */
 681       if (header >= 0x80 && header <= 0x82)
 682         parse->streamheader[header - 0x80] = buffer;
 683     }
 684     ret = GST_FLOW_OK;
 685   } else {
 686     /* data packet, push the headers we collected before */
 687     if (parse->send_streamheader) {
 688       theora_parse_push_headers (parse);
 689       parse->send_streamheader = FALSE;
 690     }
 691
 692     ret = theora_parse_queue_buffer (parse, buffer);
 693   }
 694
 695   return ret;
 696 }
 697
 698 static gboolean
 699 theora_parse_queue_event (GstTheoraParse * parse, GstEvent * event)
 700 {
 701   g_queue_push_tail (parse->event_queue, event);
 702   return TRUE;
 703 }
 704
 705 static gboolean
 706 theora_parse_sink_event (GstPad * pad, GstObject * parent, GstEvent * event)
 707 {
 708   gboolean ret;
 709   GstTheoraParse *parse;
 710
 711   parse = GST_THEORA_PARSE (parent);
 712
 713   switch (GST_EVENT_TYPE (event)) {
 714     case GST_EVENT_FLUSH_STOP:
 715       theora_parse_clear_queue (parse);
 716       parse->prev_keyframe = -1;
 717       parse->prev_frame = -1;
 718       ret = gst_pad_event_default (pad, parent, event);
 719       break;
 720     case GST_EVENT_EOS:
 721       theora_parse_drain_queue_prematurely (parse);
 722       ret = gst_pad_event_default (pad, parent, event);
 723       break;
 724     default:
 725       if (parse->send_streamheader && GST_EVENT_IS_SERIALIZED (event))
 726         ret = theora_parse_queue_event (parse, event);
 727       else
 728         ret = gst_pad_event_default (pad, parent, event);
 729       break;
 730   }
 731
 732   return ret;
 733 }
 734
 735 static gboolean
 736 theora_parse_src_convert (GstPad * pad,
 737     GstFormat src_format, gint64 src_value,
 738     GstFormat * dest_format, gint64 * dest_value)
 739 {
 740   gboolean res = TRUE;
 741   GstTheoraParse *parse;
 742   guint64 scale = 1;
 743
 744   if (src_format == *dest_format) {
 745     *dest_value = src_value;
 746     return TRUE;
 747   }
 748
 749   parse = GST_THEORA_PARSE (gst_pad_get_parent (pad));
 750
 751   /* we need the info part before we can done something */
 752   if (!parse->streamheader_received)
 753     goto no_header;
 754
 755   switch (src_format) {
 756     case GST_FORMAT_BYTES:
 757       switch (*dest_format) {
 758         case GST_FORMAT_DEFAULT:
 759           *dest_value = gst_util_uint64_scale_int (src_value, 2,
 760               parse->info.pic_height * parse->info.pic_width * 3);
 761           break;
 762         case GST_FORMAT_TIME:
 763           /* seems like a rather silly conversion, implement me if you like */
 764         default:
 765           res = FALSE;
 766       }
 767       break;
 768     case GST_FORMAT_TIME:
 769       switch (*dest_format) {
 770         case GST_FORMAT_BYTES:
 771           scale = 3 * (parse->info.pic_width * parse->info.pic_height) / 2;
 772         case GST_FORMAT_DEFAULT:
 773           *dest_value = scale * gst_util_uint64_scale (src_value,
 774               parse->info.fps_numerator,
 775               parse->info.fps_denominator * GST_SECOND);
 776           break;
 777         default:
 778           GST_DEBUG_OBJECT (parse, "cannot convert to format %s",
 779               gst_format_get_name (*dest_format));
 780           res = FALSE;
 781       }
 782       break;
 783     case GST_FORMAT_DEFAULT:
 784       switch (*dest_format) {
 785         case GST_FORMAT_TIME:
 786           *dest_value = gst_util_uint64_scale (src_value,
 787               GST_SECOND * parse->info.fps_denominator,
 788               parse->info.fps_numerator);
 789           break;
 790         case GST_FORMAT_BYTES:
 791           *dest_value = gst_util_uint64_scale_int (src_value,
 792               3 * parse->info.pic_width * parse->info.pic_height, 2);
 793           break;
 794         default:
 795           res = FALSE;
 796       }
 797       break;
 798     default:
 799       res = FALSE;
 800   }
 801 done:
 802   gst_object_unref (parse);
 803   return res;
 804
 805   /* ERRORS */
 806 no_header:
 807   {
 808     GST_DEBUG_OBJECT (parse, "no header yet, cannot convert");
 809     res = FALSE;
 810     goto done;
 811   }
 812 }
 813
 814 static gboolean
 815 theora_parse_src_query (GstPad * pad, GstObject * parent, GstQuery * query)
 816 {
 817   GstTheoraParse *parse;
 818   gboolean res = FALSE;
 819
 820   parse = GST_THEORA_PARSE (parent);
 821
 822   switch (GST_QUERY_TYPE (query)) {
 823     case GST_QUERY_POSITION:
 824     {
 825       gint64 frame, value;
 826       GstFormat my_format, format;
 827       gint64 time;
 828
 829       frame = parse->prev_frame;
 830
 831       GST_LOG_OBJECT (parse,
 832           "query %p: we have current frame: %" G_GINT64_FORMAT, query, frame);
 833
 834       /* parse format */
 835       gst_query_parse_position (query, &format, NULL);
 836
 837       /* and convert to the final format in two steps with time as the
 838        * intermediate step */
 839       my_format = GST_FORMAT_TIME;
 840       if (!(res =
 841               theora_parse_src_convert (parse->sinkpad, GST_FORMAT_DEFAULT,
 842                   frame, &my_format, &time)))
 843         goto error;
 844
 845       /* fixme: handle segments
 846          time = (time - parse->segment.start) + parse->segment.time;
 847        */
 848
 849       GST_LOG_OBJECT (parse,
 850           "query %p: our time: %" GST_TIME_FORMAT " (conv to %s)",
 851           query, GST_TIME_ARGS (time), gst_format_get_name (format));
 852
 853       if (!(res =
 854               theora_parse_src_convert (pad, my_format, time, &format, &value)))
 855         goto error;
 856
 857       gst_query_set_position (query, format, value);
 858
 859       GST_LOG_OBJECT (parse,
 860           "query %p: we return %" G_GINT64_FORMAT " (format %u)", query, value,
 861           format);
 862
 863       break;
 864     }
 865     case GST_QUERY_DURATION:
 866       /* forward to peer for total */
 867       if (!(res = gst_pad_query (GST_PAD_PEER (parse->sinkpad), query)))
 868         goto error;
 869       break;
 870     case GST_QUERY_CONVERT:
 871     {
 872       GstFormat src_fmt, dest_fmt;
 873       gint64 src_val, dest_val;
 874
 875       gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
 876       if (!(res =
 877               theora_parse_src_convert (pad, src_fmt, src_val, &dest_fmt,
 878                   &dest_val)))
 879         goto error;
 880
 881       gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
 882       break;
 883     }
 884     default:
 885       res = gst_pad_query_default (pad, parent, query);
 886       break;
 887   }
 888 done:
 889
 890   return res;
 891
 892   /* ERRORS */
 893 error:
 894   {
 895     GST_DEBUG_OBJECT (parse, "query failed");
 896     goto done;
 897   }
 898 }
 899
 900 static GstStateChangeReturn
 901 theora_parse_change_state (GstElement * element, GstStateChange transition)
 902 {
 903   GstTheoraParse *parse = GST_THEORA_PARSE (element);
 904   GstStateChangeReturn ret;
 905   gint i;
 906
 907   switch (transition) {
 908     case GST_STATE_CHANGE_READY_TO_PAUSED:
 909       th_info_init (&parse->info);
 910       th_comment_init (&parse->comment);
 911       parse->send_streamheader = TRUE;
 912       parse->buffer_queue = g_queue_new ();
 913       parse->event_queue = g_queue_new ();
 914       parse->prev_keyframe = -1;
 915       parse->prev_frame = -1;
 916       parse->granule_offset = 0;
 917       break;
 918     default:
 919       break;
 920   }
 921
 922   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 923
 924   switch (transition) {
 925     case GST_STATE_CHANGE_PAUSED_TO_READY:
 926       th_info_clear (&parse->info);
 927       th_comment_clear (&parse->comment);
 928       theora_parse_clear_queue (parse);
 929       g_queue_free (parse->buffer_queue);
 930       g_queue_free (parse->event_queue);
 931       parse->buffer_queue = NULL;
 932       for (i = 0; i < 3; i++) {
 933         if (parse->streamheader[i]) {
 934           gst_buffer_unref (parse->streamheader[i]);
 935           parse->streamheader[i] = NULL;
 936         }
 937       }
 938       parse->streamheader_received = FALSE;
 939       break;
 940     default:
 941       break;
 942   }
 943
 944   return ret;
 945 }