ext/dv/gstdvdemux.c

   1 /* GStreamer
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   3  *               <2005> Wim Taymans <wim@fluendo.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 #ifdef HAVE_CONFIG_H
  22 #include "config.h"
  23 #endif
  24
  25 #include <string.h>
  26 #include <math.h>
  27
  28 #include <gst/audio/audio.h>
  29 #include "gstdvdemux.h"
  30 #include "gstsmptetimecode.h"
  31
  32 /**
  33  * SECTION:element-dvdemux
  34  *
  35  * dvdemux splits raw DV into its audio and video components. The audio will be
  36  * decoded raw samples and the video will be encoded DV video.
  37  *
  38  * This element can operate in both push and pull mode depending on the
  39  * capabilities of the upstream peer.
  40  *
  41  * <refsect2>
  42  * <title>Example launch line</title>
  43  * |[
  44  * gst-launch filesrc location=test.dv ! dvdemux name=demux ! queue ! audioconvert ! alsasink demux. ! queue ! dvdec ! xvimagesink
  45  * ]| This pipeline decodes and renders the raw DV stream to an audio and a videosink.
  46  * </refsect2>
  47  *
  48  * Last reviewed on 2006-02-27 (0.10.3)
  49  */
  50
  51 /* DV output has two modes, normal and wide. The resolution is the same in both
  52  * cases: 720 pixels wide by 576 pixels tall in PAL format, and 720x480 for
  53  * NTSC.
  54  *
  55  * Each of the modes has its own pixel aspect ratio, which is fixed in practice
  56  * by ITU-R BT.601 (also known as "CCIR-601" or "Rec.601"). Or so claims a
  57  * reference that I culled from the reliable "internet",
  58  * http://www.mir.com/DMG/aspect.html. Normal PAL is 59/54 and normal NTSC is
  59  * 10/11. Because the pixel resolution is the same for both cases, we can get
  60  * the pixel aspect ratio for wide recordings by multiplying by the ratio of
  61  * display aspect ratios, 16/9 (for wide) divided by 4/3 (for normal):
  62  *
  63  * Wide NTSC: 10/11 * (16/9)/(4/3) = 40/33
  64  * Wide PAL: 59/54 * (16/9)/(4/3) = 118/81
  65  *
  66  * However, the pixel resolution coming out of a DV source does not combine with
  67  * the standard pixel aspect ratios to give a proper display aspect ratio. An
  68  * image 480 pixels tall, with a 4:3 display aspect ratio, will be 768 pixels
  69  * wide. But, if we take the normal PAL aspect ratio of 59/54, and multiply it
  70  * with the width of the DV image (720 pixels), we get 786.666..., which is
  71  * nonintegral and too wide. The camera is not outputting a 4:3 image.
  72  *
  73  * If the video sink for this stream has fixed dimensions (such as for
  74  * fullscreen playback, or for a java applet in a web page), you then have two
  75  * choices. Either you show the whole image, but pad the image with black
  76  * borders on the top and bottom (like watching a widescreen video on a 4:3
  77  * device), or you crop the video to the proper ratio. Apparently the latter is
  78  * the standard practice.
  79  *
  80  * For its part, GStreamer is concerned with accuracy and preservation of
  81  * information. This element outputs the 720x576 or 720x480 video that it
  82  * recieves, noting the proper aspect ratio. This should not be a problem for
  83  * windowed applications, which can change size to fit the video. Applications
  84  * with fixed size requirements should decide whether to crop or pad which
  85  * an element such as videobox can do.
  86  */
  87
  88 #define NTSC_HEIGHT 480
  89 #define NTSC_BUFFER 120000
  90 #define NTSC_FRAMERATE_NUMERATOR 30000
  91 #define NTSC_FRAMERATE_DENOMINATOR 1001
  92
  93 #define PAL_HEIGHT 576
  94 #define PAL_BUFFER 144000
  95 #define PAL_FRAMERATE_NUMERATOR 25
  96 #define PAL_FRAMERATE_DENOMINATOR 1
  97
  98 #define PAL_NORMAL_PAR_X        59
  99 #define PAL_NORMAL_PAR_Y        54
 100 #define PAL_WIDE_PAR_X          118
 101 #define PAL_WIDE_PAR_Y          81
 102
 103 #define NTSC_NORMAL_PAR_X       10
 104 #define NTSC_NORMAL_PAR_Y       11
 105 #define NTSC_WIDE_PAR_X         40
 106 #define NTSC_WIDE_PAR_Y         33
 107
 108 GST_DEBUG_CATEGORY_STATIC (dvdemux_debug);
 109 #define GST_CAT_DEFAULT dvdemux_debug
 110
 111 static GstStaticPadTemplate sink_temp = GST_STATIC_PAD_TEMPLATE ("sink",
 112     GST_PAD_SINK,
 113     GST_PAD_ALWAYS,
 114     GST_STATIC_CAPS ("video/x-dv, systemstream = (boolean) true")
 115     );
 116
 117 static GstStaticPadTemplate video_src_temp = GST_STATIC_PAD_TEMPLATE ("video",
 118     GST_PAD_SRC,
 119     GST_PAD_SOMETIMES,
 120     GST_STATIC_CAPS ("video/x-dv, systemstream = (boolean) false")
 121     );
 122
 123 static GstStaticPadTemplate audio_src_temp = GST_STATIC_PAD_TEMPLATE ("audio",
 124     GST_PAD_SRC,
 125     GST_PAD_SOMETIMES,
 126     GST_STATIC_CAPS ("audio/x-raw, "
 127         "format = (string) " GST_AUDIO_NE (S16) ", "
 128         "layout = (string) interleaved, "
 129         "rate = (int) { 32000, 44100, 48000 }, " "channels = (int) {2, 4}")
 130     );
 131
 132
 133 #define gst_dvdemux_parent_class parent_class
 134 G_DEFINE_TYPE (GstDVDemux, gst_dvdemux, GST_TYPE_ELEMENT);
 135
 136 static void gst_dvdemux_finalize (GObject * object);
 137
 138 /* query functions */
 139 static gboolean gst_dvdemux_src_query (GstPad * pad, GstObject * parent,
 140     GstQuery * query);
 141 static gboolean gst_dvdemux_sink_query (GstPad * pad, GstObject * parent,
 142     GstQuery * query);
 143
 144 /* convert functions */
 145 static gboolean gst_dvdemux_sink_convert (GstDVDemux * demux,
 146     GstFormat src_format, gint64 src_value, GstFormat * dest_format,
 147     gint64 * dest_value);
 148 static gboolean gst_dvdemux_src_convert (GstDVDemux * demux, GstPad * pad,
 149     GstFormat src_format, gint64 src_value, GstFormat * dest_format,
 150     gint64 * dest_value);
 151
 152 /* event functions */
 153 static gboolean gst_dvdemux_send_event (GstElement * element, GstEvent * event);
 154 static gboolean gst_dvdemux_handle_src_event (GstPad * pad, GstObject * parent,
 155     GstEvent * event);
 156 static gboolean gst_dvdemux_handle_sink_event (GstPad * pad, GstObject * parent,
 157     GstEvent * event);
 158
 159 /* scheduling functions */
 160 static void gst_dvdemux_loop (GstPad * pad);
 161 static GstFlowReturn gst_dvdemux_flush (GstDVDemux * dvdemux);
 162 static GstFlowReturn gst_dvdemux_chain (GstPad * pad, GstObject * parent,
 163     GstBuffer * buffer);
 164
 165 /* state change functions */
 166 static gboolean gst_dvdemux_sink_activate (GstPad * sinkpad,
 167     GstObject * parent);
 168 static gboolean gst_dvdemux_sink_activate_mode (GstPad * sinkpad,
 169     GstObject * parent, GstPadMode mode, gboolean active);
 170 static GstStateChangeReturn gst_dvdemux_change_state (GstElement * element,
 171     GstStateChange transition);
 172
 173 static void
 174 gst_dvdemux_class_init (GstDVDemuxClass * klass)
 175 {
 176   GObjectClass *gobject_class;
 177   GstElementClass *gstelement_class;
 178
 179   gobject_class = (GObjectClass *) klass;
 180   gstelement_class = (GstElementClass *) klass;
 181
 182   gobject_class->finalize = gst_dvdemux_finalize;
 183
 184   gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_dvdemux_change_state);
 185   gstelement_class->send_event = GST_DEBUG_FUNCPTR (gst_dvdemux_send_event);
 186
 187   gst_element_class_add_pad_template (gstelement_class,
 188       gst_static_pad_template_get (&sink_temp));
 189   gst_element_class_add_pad_template (gstelement_class,
 190       gst_static_pad_template_get (&video_src_temp));
 191   gst_element_class_add_pad_template (gstelement_class,
 192       gst_static_pad_template_get (&audio_src_temp));
 193
 194   gst_element_class_set_static_metadata (gstelement_class,
 195       "DV system stream demuxer", "Codec/Demuxer",
 196       "Uses libdv to separate DV audio from DV video (libdv.sourceforge.net)",
 197       "Erik Walthinsen <omega@cse.ogi.edu>, Wim Taymans <wim@fluendo.com>");
 198
 199   GST_DEBUG_CATEGORY_INIT (dvdemux_debug, "dvdemux", 0, "DV demuxer element");
 200 }
 201
 202 static void
 203 gst_dvdemux_init (GstDVDemux * dvdemux)
 204 {
 205   gint i;
 206
 207   dvdemux->sinkpad = gst_pad_new_from_static_template (&sink_temp, "sink");
 208   /* we can operate in pull and push mode so we install
 209    * a custom activate function */
 210   gst_pad_set_activate_function (dvdemux->sinkpad,
 211       GST_DEBUG_FUNCPTR (gst_dvdemux_sink_activate));
 212   /* the function to activate in push mode */
 213   gst_pad_set_activatemode_function (dvdemux->sinkpad,
 214       GST_DEBUG_FUNCPTR (gst_dvdemux_sink_activate_mode));
 215   /* for push mode, this is the chain function */
 216   gst_pad_set_chain_function (dvdemux->sinkpad,
 217       GST_DEBUG_FUNCPTR (gst_dvdemux_chain));
 218   /* handling events (in push mode only) */
 219   gst_pad_set_event_function (dvdemux->sinkpad,
 220       GST_DEBUG_FUNCPTR (gst_dvdemux_handle_sink_event));
 221   /* query functions */
 222   gst_pad_set_query_function (dvdemux->sinkpad,
 223       GST_DEBUG_FUNCPTR (gst_dvdemux_sink_query));
 224
 225   /* now add the pad */
 226   gst_element_add_pad (GST_ELEMENT (dvdemux), dvdemux->sinkpad);
 227
 228   dvdemux->adapter = gst_adapter_new ();
 229
 230   /* we need 4 temp buffers for audio decoding which are of a static
 231    * size and which we can allocate here */
 232   for (i = 0; i < 4; i++) {
 233     dvdemux->audio_buffers[i] =
 234         (gint16 *) g_malloc (DV_AUDIO_MAX_SAMPLES * sizeof (gint16));
 235   }
 236 }
 237
 238 static void
 239 gst_dvdemux_finalize (GObject * object)
 240 {
 241   GstDVDemux *dvdemux;
 242   gint i;
 243
 244   dvdemux = GST_DVDEMUX (object);
 245
 246   g_object_unref (dvdemux->adapter);
 247
 248   /* clean up temp audio buffers */
 249   for (i = 0; i < 4; i++) {
 250     g_free (dvdemux->audio_buffers[i]);
 251   }
 252
 253   G_OBJECT_CLASS (parent_class)->finalize (object);
 254 }
 255
 256 /* reset to default values before starting streaming */
 257 static void
 258 gst_dvdemux_reset (GstDVDemux * dvdemux)
 259 {
 260   dvdemux->frame_offset = 0;
 261   dvdemux->audio_offset = 0;
 262   dvdemux->video_offset = 0;
 263   dvdemux->framecount = 0;
 264   g_atomic_int_set (&dvdemux->found_header, 0);
 265   dvdemux->frame_len = -1;
 266   dvdemux->need_segment = FALSE;
 267   dvdemux->new_media = FALSE;
 268   dvdemux->framerate_numerator = 0;
 269   dvdemux->framerate_denominator = 0;
 270   dvdemux->height = 0;
 271   dvdemux->frequency = 0;
 272   dvdemux->channels = 0;
 273   dvdemux->wide = FALSE;
 274   gst_segment_init (&dvdemux->byte_segment, GST_FORMAT_BYTES);
 275   gst_segment_init (&dvdemux->time_segment, GST_FORMAT_TIME);
 276 }
 277
 278 static GstPad *
 279 gst_dvdemux_add_pad (GstDVDemux * dvdemux, GstStaticPadTemplate * template)
 280 {
 281   gboolean no_more_pads;
 282   GstPad *pad;
 283
 284   pad = gst_pad_new_from_static_template (template, template->name_template);
 285
 286   gst_pad_set_query_function (pad, GST_DEBUG_FUNCPTR (gst_dvdemux_src_query));
 287
 288   gst_pad_set_event_function (pad,
 289       GST_DEBUG_FUNCPTR (gst_dvdemux_handle_src_event));
 290   gst_pad_use_fixed_caps (pad);
 291   gst_pad_set_active (pad, TRUE);
 292   gst_element_add_pad (GST_ELEMENT (dvdemux), pad);
 293
 294   no_more_pads =
 295       (dvdemux->videosrcpad != NULL && template == &audio_src_temp) ||
 296       (dvdemux->audiosrcpad != NULL && template == &video_src_temp);
 297
 298   if (no_more_pads)
 299     gst_element_no_more_pads (GST_ELEMENT (dvdemux));
 300
 301   gst_pad_push_event (pad, gst_event_new_segment (&dvdemux->time_segment));
 302
 303   if (no_more_pads) {
 304     gst_pad_push_event (pad,
 305         gst_event_new_tag ("GstDemuxer",
 306             gst_tag_list_new (GST_TAG_CONTAINER_FORMAT, "DV", NULL)));
 307   }
 308
 309   return pad;
 310 }
 311
 312 static void
 313 gst_dvdemux_remove_pads (GstDVDemux * dvdemux)
 314 {
 315   if (dvdemux->videosrcpad) {
 316     gst_element_remove_pad (GST_ELEMENT (dvdemux), dvdemux->videosrcpad);
 317     dvdemux->videosrcpad = NULL;
 318   }
 319   if (dvdemux->audiosrcpad) {
 320     gst_element_remove_pad (GST_ELEMENT (dvdemux), dvdemux->audiosrcpad);
 321     dvdemux->audiosrcpad = NULL;
 322   }
 323 }
 324
 325 static gboolean
 326 gst_dvdemux_src_convert (GstDVDemux * dvdemux, GstPad * pad,
 327     GstFormat src_format, gint64 src_value, GstFormat * dest_format,
 328     gint64 * dest_value)
 329 {
 330   gboolean res = TRUE;
 331
 332   if (*dest_format == src_format || src_value == -1) {
 333     *dest_value = src_value;
 334     goto done;
 335   }
 336
 337   if (dvdemux->frame_len <= 0)
 338     goto error;
 339
 340   if (dvdemux->decoder == NULL)
 341     goto error;
 342
 343   GST_INFO_OBJECT (pad,
 344       "src_value:%" G_GINT64_FORMAT ", src_format:%d, dest_format:%d",
 345       src_value, src_format, *dest_format);
 346
 347   switch (src_format) {
 348     case GST_FORMAT_BYTES:
 349       switch (*dest_format) {
 350         case GST_FORMAT_DEFAULT:
 351           if (pad == dvdemux->videosrcpad)
 352             *dest_value = src_value / dvdemux->frame_len;
 353           else if (pad == dvdemux->audiosrcpad)
 354             *dest_value = src_value / (2 * dvdemux->channels);
 355           break;
 356         case GST_FORMAT_TIME:
 357           *dest_format = GST_FORMAT_TIME;
 358           if (pad == dvdemux->videosrcpad)
 359             *dest_value = gst_util_uint64_scale (src_value,
 360                 GST_SECOND * dvdemux->framerate_denominator,
 361                 dvdemux->frame_len * dvdemux->framerate_numerator);
 362           else if (pad == dvdemux->audiosrcpad)
 363             *dest_value = gst_util_uint64_scale_int (src_value, GST_SECOND,
 364                 2 * dvdemux->frequency * dvdemux->channels);
 365           break;
 366         default:
 367           res = FALSE;
 368       }
 369       break;
 370     case GST_FORMAT_TIME:
 371       switch (*dest_format) {
 372         case GST_FORMAT_BYTES:
 373           if (pad == dvdemux->videosrcpad)
 374             *dest_value = gst_util_uint64_scale (src_value,
 375                 dvdemux->frame_len * dvdemux->framerate_numerator,
 376                 dvdemux->framerate_denominator * GST_SECOND);
 377           else if (pad == dvdemux->audiosrcpad)
 378             *dest_value = gst_util_uint64_scale_int (src_value,
 379                 2 * dvdemux->frequency * dvdemux->channels, GST_SECOND);
 380           break;
 381         case GST_FORMAT_DEFAULT:
 382           if (pad == dvdemux->videosrcpad) {
 383             if (src_value)
 384               *dest_value = gst_util_uint64_scale (src_value,
 385                   dvdemux->framerate_numerator,
 386                   dvdemux->framerate_denominator * GST_SECOND);
 387             else
 388               *dest_value = 0;
 389           } else if (pad == dvdemux->audiosrcpad) {
 390             *dest_value = gst_util_uint64_scale (src_value,
 391                 dvdemux->frequency, GST_SECOND);
 392           }
 393           break;
 394         default:
 395           res = FALSE;
 396       }
 397       break;
 398     case GST_FORMAT_DEFAULT:
 399       switch (*dest_format) {
 400         case GST_FORMAT_TIME:
 401           if (pad == dvdemux->videosrcpad) {
 402             *dest_value = gst_util_uint64_scale (src_value,
 403                 GST_SECOND * dvdemux->framerate_denominator,
 404                 dvdemux->framerate_numerator);
 405           } else if (pad == dvdemux->audiosrcpad) {
 406             if (src_value)
 407               *dest_value = gst_util_uint64_scale (src_value,
 408                   GST_SECOND, dvdemux->frequency);
 409             else
 410               *dest_value = 0;
 411           }
 412           break;
 413         case GST_FORMAT_BYTES:
 414           if (pad == dvdemux->videosrcpad) {
 415             *dest_value = src_value * dvdemux->frame_len;
 416           } else if (pad == dvdemux->audiosrcpad) {
 417             *dest_value = src_value * 2 * dvdemux->channels;
 418           }
 419           break;
 420         default:
 421           res = FALSE;
 422       }
 423       break;
 424     default:
 425       res = FALSE;
 426   }
 427
 428 done:
 429   GST_INFO_OBJECT (pad,
 430       "Result : dest_format:%d, dest_value:%" G_GINT64_FORMAT ", res:%d",
 431       *dest_format, *dest_value, res);
 432   return res;
 433
 434   /* ERRORS */
 435 error:
 436   {
 437     GST_INFO ("source conversion failed");
 438     return FALSE;
 439   }
 440 }
 441
 442 static gboolean
 443 gst_dvdemux_sink_convert (GstDVDemux * dvdemux, GstFormat src_format,
 444     gint64 src_value, GstFormat * dest_format, gint64 * dest_value)
 445 {
 446   gboolean res = TRUE;
 447
 448   GST_DEBUG_OBJECT (dvdemux, "%d -> %d", src_format, *dest_format);
 449   GST_INFO_OBJECT (dvdemux,
 450       "src_value:%" G_GINT64_FORMAT ", src_format:%d, dest_format:%d",
 451       src_value, src_format, *dest_format);
 452
 453   if (*dest_format == GST_FORMAT_DEFAULT)
 454     *dest_format = GST_FORMAT_TIME;
 455
 456   if (*dest_format == src_format || src_value == -1) {
 457     *dest_value = src_value;
 458     goto done;
 459   }
 460
 461   if (dvdemux->frame_len <= 0)
 462     goto error;
 463
 464   switch (src_format) {
 465     case GST_FORMAT_BYTES:
 466       switch (*dest_format) {
 467         case GST_FORMAT_TIME:
 468         {
 469           guint64 frame;
 470
 471           /* get frame number, rounds down so don't combine this
 472            * line and the next line. */
 473           frame = src_value / dvdemux->frame_len;
 474
 475           *dest_value = gst_util_uint64_scale (frame,
 476               GST_SECOND * dvdemux->framerate_denominator,
 477               dvdemux->framerate_numerator);
 478           break;
 479         }
 480         default:
 481           res = FALSE;
 482       }
 483       break;
 484     case GST_FORMAT_TIME:
 485       switch (*dest_format) {
 486         case GST_FORMAT_BYTES:
 487         {
 488           guint64 frame;
 489
 490           /* calculate the frame */
 491           frame =
 492               gst_util_uint64_scale (src_value, dvdemux->framerate_numerator,
 493               dvdemux->framerate_denominator * GST_SECOND);
 494
 495           /* calculate the offset from the rounded frame */
 496           *dest_value = frame * dvdemux->frame_len;
 497           break;
 498         }
 499         default:
 500           res = FALSE;
 501       }
 502       break;
 503     default:
 504       res = FALSE;
 505   }
 506   GST_INFO_OBJECT (dvdemux,
 507       "Result : dest_format:%d, dest_value:%" G_GINT64_FORMAT ", res:%d",
 508       *dest_format, *dest_value, res);
 509
 510 done:
 511   return res;
 512
 513 error:
 514   {
 515     GST_INFO_OBJECT (dvdemux, "sink conversion failed");
 516     return FALSE;
 517   }
 518 }
 519
 520 static gboolean
 521 gst_dvdemux_src_query (GstPad * pad, GstObject * parent, GstQuery * query)
 522 {
 523   gboolean res = TRUE;
 524   GstDVDemux *dvdemux;
 525
 526   dvdemux = GST_DVDEMUX (parent);
 527
 528   switch (GST_QUERY_TYPE (query)) {
 529     case GST_QUERY_POSITION:
 530     {
 531       GstFormat format;
 532       gint64 cur;
 533
 534       /* get target format */
 535       gst_query_parse_position (query, &format, NULL);
 536
 537       /* bring the position to the requested format. */
 538       if (!(res = gst_dvdemux_src_convert (dvdemux, pad,
 539                   GST_FORMAT_TIME, dvdemux->time_segment.position,
 540                   &format, &cur)))
 541         goto error;
 542       gst_query_set_position (query, format, cur);
 543       break;
 544     }
 545     case GST_QUERY_DURATION:
 546     {
 547       GstFormat format;
 548       GstFormat format2;
 549       gint64 end;
 550
 551       /* First ask the peer in the original format */
 552       if (!gst_pad_peer_query (dvdemux->sinkpad, query)) {
 553         /* get target format */
 554         gst_query_parse_duration (query, &format, NULL);
 555
 556         /* change query to bytes to perform on peer */
 557         gst_query_set_duration (query, GST_FORMAT_BYTES, -1);
 558
 559         /* Now ask the peer in BYTES format and try to convert */
 560         if (!gst_pad_peer_query (dvdemux->sinkpad, query)) {
 561           goto error;
 562         }
 563
 564         /* get peer total length */
 565         gst_query_parse_duration (query, NULL, &end);
 566
 567         /* convert end to requested format */
 568         if (end != -1) {
 569           format2 = format;
 570           if (!(res = gst_dvdemux_sink_convert (dvdemux,
 571                       GST_FORMAT_BYTES, end, &format2, &end))) {
 572             goto error;
 573           }
 574           gst_query_set_duration (query, format, end);
 575         }
 576       }
 577       break;
 578     }
 579     case GST_QUERY_CONVERT:
 580     {
 581       GstFormat src_fmt, dest_fmt;
 582       gint64 src_val, dest_val;
 583
 584       gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
 585       if (!(res =
 586               gst_dvdemux_src_convert (dvdemux, pad, src_fmt, src_val,
 587                   &dest_fmt, &dest_val)))
 588         goto error;
 589       gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
 590       break;
 591     }
 592     default:
 593       res = gst_pad_query_default (pad, parent, query);
 594       break;
 595   }
 596
 597   return res;
 598
 599   /* ERRORS */
 600 error:
 601   {
 602     GST_DEBUG ("error source query");
 603     return FALSE;
 604   }
 605 }
 606
 607 static gboolean
 608 gst_dvdemux_sink_query (GstPad * pad, GstObject * parent, GstQuery * query)
 609 {
 610   gboolean res = TRUE;
 611   GstDVDemux *dvdemux;
 612
 613   dvdemux = GST_DVDEMUX (parent);
 614
 615   switch (GST_QUERY_TYPE (query)) {
 616     case GST_QUERY_CONVERT:
 617     {
 618       GstFormat src_fmt, dest_fmt;
 619       gint64 src_val, dest_val;
 620
 621       gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
 622       if (!(res =
 623               gst_dvdemux_sink_convert (dvdemux, src_fmt, src_val, &dest_fmt,
 624                   &dest_val)))
 625         goto error;
 626       gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
 627       break;
 628     }
 629     default:
 630       res = gst_pad_query_default (pad, parent, query);
 631       break;
 632   }
 633
 634   return res;
 635
 636   /* ERRORS */
 637 error:
 638   {
 639     GST_DEBUG ("error handling sink query");
 640     return FALSE;
 641   }
 642 }
 643
 644 /* takes ownership of the event */
 645 static gboolean
 646 gst_dvdemux_push_event (GstDVDemux * dvdemux, GstEvent * event)
 647 {
 648   gboolean res = FALSE;
 649
 650   if (dvdemux->videosrcpad) {
 651     gst_event_ref (event);
 652     res |= gst_pad_push_event (dvdemux->videosrcpad, event);
 653   }
 654
 655   if (dvdemux->audiosrcpad)
 656     res |= gst_pad_push_event (dvdemux->audiosrcpad, event);
 657   else
 658     gst_event_unref (event);
 659
 660   return res;
 661 }
 662
 663 static gboolean
 664 gst_dvdemux_handle_sink_event (GstPad * pad, GstObject * parent,
 665     GstEvent * event)
 666 {
 667   GstDVDemux *dvdemux = GST_DVDEMUX (parent);
 668   gboolean res = TRUE;
 669
 670   switch (GST_EVENT_TYPE (event)) {
 671     case GST_EVENT_FLUSH_START:
 672       /* we are not blocking on anything exect the push() calls
 673        * to the peer which will be unblocked by forwarding the
 674        * event.*/
 675       res = gst_dvdemux_push_event (dvdemux, event);
 676       break;
 677     case GST_EVENT_FLUSH_STOP:
 678       gst_adapter_clear (dvdemux->adapter);
 679       GST_DEBUG ("cleared adapter");
 680       gst_segment_init (&dvdemux->byte_segment, GST_FORMAT_BYTES);
 681       gst_segment_init (&dvdemux->time_segment, GST_FORMAT_TIME);
 682       res = gst_dvdemux_push_event (dvdemux, event);
 683       break;
 684     case GST_EVENT_SEGMENT:
 685     {
 686       const GstSegment *segment;
 687
 688       gst_event_parse_segment (event, &segment);
 689       switch (segment->format) {
 690         case GST_FORMAT_BYTES:
 691           gst_segment_copy_into (segment, &dvdemux->byte_segment);
 692
 693 #if 0
 694           /* FIXME ?? no longer such subtle distinction in 0.11 */
 695           /* the update can always be sent */
 696           if (update) {
 697             GstEvent *update;
 698
 699             update = gst_event_new_new_segment (TRUE,
 700                 dvdemux->time_segment.rate, dvdemux->time_segment.format,
 701                 dvdemux->time_segment.start, dvdemux->time_segment.position,
 702                 dvdemux->time_segment.time);
 703
 704             gst_dvdemux_push_event (dvdemux, update);
 705           } else {
 706             /* and queue a SEGMENT before sending the next set of buffers, we
 707              * cannot convert to time yet as we might not know the size of the
 708              * frames, etc.. */
 709             dvdemux->need_segment = TRUE;
 710           }
 711 #endif
 712           dvdemux->need_segment = TRUE;
 713           gst_event_unref (event);
 714           break;
 715         case GST_FORMAT_TIME:
 716           gst_segment_copy_into (segment, &dvdemux->time_segment);
 717
 718           /* and we can just forward this time event */
 719           res = gst_dvdemux_push_event (dvdemux, event);
 720           break;
 721         default:
 722           gst_event_unref (event);
 723           /* cannot accept this format */
 724           res = FALSE;
 725           break;
 726       }
 727       break;
 728     }
 729     case GST_EVENT_EOS:
 730       /* flush any pending data, should be nothing left. */
 731       gst_dvdemux_flush (dvdemux);
 732       /* forward event */
 733       res = gst_dvdemux_push_event (dvdemux, event);
 734       /* and clear the adapter */
 735       gst_adapter_clear (dvdemux->adapter);
 736       break;
 737     case GST_EVENT_CAPS:
 738       gst_event_unref (event);
 739       break;
 740     default:
 741       res = gst_dvdemux_push_event (dvdemux, event);
 742       break;
 743   }
 744
 745   return res;
 746 }
 747
 748 /* convert a pair of values on the given srcpad */
 749 static gboolean
 750 gst_dvdemux_convert_src_pair (GstDVDemux * dvdemux, GstPad * pad,
 751     GstFormat src_format, gint64 src_start, gint64 src_stop,
 752     GstFormat dst_format, gint64 * dst_start, gint64 * dst_stop)
 753 {
 754   gboolean res;
 755
 756   GST_INFO ("starting conversion of start");
 757   /* bring the format to time on srcpad. */
 758   if (!(res = gst_dvdemux_src_convert (dvdemux, pad,
 759               src_format, src_start, &dst_format, dst_start))) {
 760     goto done;
 761   }
 762   GST_INFO ("Finished conversion of start: %" G_GINT64_FORMAT, *dst_start);
 763
 764   GST_INFO ("starting conversion of stop");
 765   /* bring the format to time on srcpad. */
 766   if (!(res = gst_dvdemux_src_convert (dvdemux, pad,
 767               src_format, src_stop, &dst_format, dst_stop))) {
 768     /* could not convert seek format to time offset */
 769     goto done;
 770   }
 771   GST_INFO ("Finished conversion of stop: %" G_GINT64_FORMAT, *dst_stop);
 772 done:
 773   return res;
 774 }
 775
 776 /* convert a pair of values on the sinkpad */
 777 static gboolean
 778 gst_dvdemux_convert_sink_pair (GstDVDemux * dvdemux,
 779     GstFormat src_format, gint64 src_start, gint64 src_stop,
 780     GstFormat dst_format, gint64 * dst_start, gint64 * dst_stop)
 781 {
 782   gboolean res;
 783
 784   GST_INFO ("starting conversion of start");
 785   /* bring the format to time on srcpad. */
 786   if (!(res = gst_dvdemux_sink_convert (dvdemux,
 787               src_format, src_start, &dst_format, dst_start))) {
 788     goto done;
 789   }
 790   GST_INFO ("Finished conversion of start: %" G_GINT64_FORMAT, *dst_start);
 791
 792   GST_INFO ("starting conversion of stop");
 793   /* bring the format to time on srcpad. */
 794   if (!(res = gst_dvdemux_sink_convert (dvdemux,
 795               src_format, src_stop, &dst_format, dst_stop))) {
 796     /* could not convert seek format to time offset */
 797     goto done;
 798   }
 799   GST_INFO ("Finished conversion of stop: %" G_GINT64_FORMAT, *dst_stop);
 800 done:
 801   return res;
 802 }
 803
 804 /* convert a pair of values on the srcpad to a pair of
 805  * values on the sinkpad
 806  */
 807 static gboolean
 808 gst_dvdemux_convert_src_to_sink (GstDVDemux * dvdemux, GstPad * pad,
 809     GstFormat src_format, gint64 src_start, gint64 src_stop,
 810     GstFormat dst_format, gint64 * dst_start, gint64 * dst_stop)
 811 {
 812   GstFormat conv;
 813   gboolean res;
 814
 815   conv = GST_FORMAT_TIME;
 816   /* convert to TIME intermediate format */
 817   if (!(res = gst_dvdemux_convert_src_pair (dvdemux, pad,
 818               src_format, src_start, src_stop, conv, dst_start, dst_stop))) {
 819     /* could not convert format to time offset */
 820     goto done;
 821   }
 822   /* convert to dst format on sinkpad */
 823   if (!(res = gst_dvdemux_convert_sink_pair (dvdemux,
 824               conv, *dst_start, *dst_stop, dst_format, dst_start, dst_stop))) {
 825     /* could not convert format to time offset */
 826     goto done;
 827   }
 828 done:
 829   return res;
 830 }
 831
 832 #if 0
 833 static gboolean
 834 gst_dvdemux_convert_segment (GstDVDemux * dvdemux, GstSegment * src,
 835     GstSegment * dest)
 836 {
 837   dest->rate = src->rate;
 838   dest->abs_rate = src->abs_rate;
 839   dest->flags = src->flags;
 840
 841   return TRUE;
 842 }
 843 #endif
 844
 845 /* handle seek in push base mode.
 846  *
 847  * Convert the time seek to a bytes seek and send it
 848  * upstream
 849  * Does not take ownership of the event.
 850  */
 851 static gboolean
 852 gst_dvdemux_handle_push_seek (GstDVDemux * dvdemux, GstPad * pad,
 853     GstEvent * event)
 854 {
 855   gboolean res = FALSE;
 856   gdouble rate;
 857   GstSeekFlags flags;
 858   GstFormat format;
 859   GstSeekType cur_type, stop_type;
 860   gint64 cur, stop;
 861   gint64 start_position, end_position;
 862   GstEvent *newevent;
 863
 864   gst_event_parse_seek (event, &rate, &format, &flags,
 865       &cur_type, &cur, &stop_type, &stop);
 866
 867   /* First try if upstream can handle time based seeks */
 868   if (format == GST_FORMAT_TIME)
 869     res = gst_pad_push_event (dvdemux->sinkpad, gst_event_ref (event));
 870
 871   if (!res) {
 872     /* we convert the start/stop on the srcpad to the byte format
 873      * on the sinkpad and forward the event */
 874     res = gst_dvdemux_convert_src_to_sink (dvdemux, pad,
 875         format, cur, stop, GST_FORMAT_BYTES, &start_position, &end_position);
 876     if (!res)
 877       goto done;
 878
 879     /* now this is the updated seek event on bytes */
 880     newevent = gst_event_new_seek (rate, GST_FORMAT_BYTES, flags,
 881         cur_type, start_position, stop_type, end_position);
 882
 883     res = gst_pad_push_event (dvdemux->sinkpad, newevent);
 884   }
 885 done:
 886   return res;
 887 }
 888
 889 /* position ourselves to the configured segment, used in pull mode.
 890  * The input segment is in TIME format. We convert the time values
 891  * to bytes values into our byte_segment which we use to pull data from
 892  * the sinkpad peer.
 893  */
 894 static gboolean
 895 gst_dvdemux_do_seek (GstDVDemux * demux, GstSegment * segment)
 896 {
 897   gboolean res;
 898   GstFormat format;
 899
 900   /* position to value configured is last_stop, this will round down
 901    * to the byte position where the frame containing the given
 902    * timestamp can be found. */
 903   format = GST_FORMAT_BYTES;
 904   res = gst_dvdemux_sink_convert (demux,
 905       segment->format, segment->position,
 906       &format, (gint64 *) & demux->byte_segment.position);
 907   if (!res)
 908     goto done;
 909
 910   /* update byte segment start */
 911   gst_dvdemux_sink_convert (demux,
 912       segment->format, segment->start, &format,
 913       (gint64 *) & demux->byte_segment.start);
 914
 915   /* update byte segment stop */
 916   gst_dvdemux_sink_convert (demux,
 917       segment->format, segment->stop, &format,
 918       (gint64 *) & demux->byte_segment.stop);
 919
 920   /* update byte segment time */
 921   gst_dvdemux_sink_convert (demux,
 922       segment->format, segment->time, &format,
 923       (gint64 *) & demux->byte_segment.time);
 924
 925   /* calculate current frame number */
 926   format = GST_FORMAT_DEFAULT;
 927   gst_dvdemux_src_convert (demux, demux->videosrcpad,
 928       segment->format, segment->start, &format, &demux->video_offset);
 929
 930   /* calculate current audio number */
 931   format = GST_FORMAT_DEFAULT;
 932   gst_dvdemux_src_convert (demux, demux->audiosrcpad,
 933       segment->format, segment->start, &format, &demux->audio_offset);
 934
 935   /* every DV frame corresponts with one video frame */
 936   demux->frame_offset = demux->video_offset;
 937
 938 done:
 939   return res;
 940 }
 941
 942 /* handle seek in pull base mode.
 943  *
 944  * Does not take ownership of the event.
 945  */
 946 static gboolean
 947 gst_dvdemux_handle_pull_seek (GstDVDemux * demux, GstPad * pad,
 948     GstEvent * event)
 949 {
 950   gboolean res;
 951   gdouble rate;
 952   GstFormat format;
 953   GstSeekFlags flags;
 954   GstSeekType cur_type, stop_type;
 955   gint64 cur, stop;
 956   gboolean flush;
 957   gboolean update;
 958   GstSegment seeksegment;
 959
 960   GST_DEBUG_OBJECT (demux, "doing seek");
 961
 962   /* first bring the event format to TIME, our native format
 963    * to perform the seek on */
 964   if (event) {
 965     GstFormat conv;
 966
 967     gst_event_parse_seek (event, &rate, &format, &flags,
 968         &cur_type, &cur, &stop_type, &stop);
 969
 970     /* can't seek backwards yet */
 971     if (rate <= 0.0)
 972       goto wrong_rate;
 973
 974     /* convert input format to TIME */
 975     conv = GST_FORMAT_TIME;
 976     if (!(gst_dvdemux_convert_src_pair (demux, pad,
 977                 format, cur, stop, conv, &cur, &stop)))
 978       goto no_format;
 979
 980     format = GST_FORMAT_TIME;
 981   } else {
 982     flags = 0;
 983   }
 984
 985   flush = flags & GST_SEEK_FLAG_FLUSH;
 986
 987   /* send flush start */
 988   if (flush)
 989     gst_dvdemux_push_event (demux, gst_event_new_flush_start ());
 990   else
 991     gst_pad_pause_task (demux->sinkpad);
 992
 993   /* grab streaming lock, this should eventually be possible, either
 994    * because the task is paused or our streaming thread stopped
 995    * because our peer is flushing. */
 996   GST_PAD_STREAM_LOCK (demux->sinkpad);
 997
 998   /* make copy into temp structure, we can only update the main one
 999    * when the subclass actually could to the seek. */
1000   memcpy (&seeksegment, &demux->time_segment, sizeof (GstSegment));
1001
1002   /* now configure the seek segment */
1003   if (event) {
1004     gst_segment_do_seek (&seeksegment, rate, format, flags,
1005         cur_type, cur, stop_type, stop, &update);
1006   }
1007
1008   GST_DEBUG_OBJECT (demux, "segment configured from %" G_GINT64_FORMAT
1009       " to %" G_GINT64_FORMAT ", position %" G_GINT64_FORMAT,
1010       seeksegment.start, seeksegment.stop, seeksegment.position);
1011
1012   /* do the seek, segment.position contains new position. */
1013   res = gst_dvdemux_do_seek (demux, &seeksegment);
1014
1015   /* and prepare to continue streaming */
1016   if (flush) {
1017     /* send flush stop, peer will accept data and events again. We
1018      * are not yet providing data as we still have the STREAM_LOCK. */
1019     gst_dvdemux_push_event (demux, gst_event_new_flush_stop (TRUE));
1020   }
1021
1022   /* if successfull seek, we update our real segment and push
1023    * out the new segment. */
1024   if (res) {
1025     memcpy (&demux->time_segment, &seeksegment, sizeof (GstSegment));
1026
1027     if (demux->time_segment.flags & GST_SEEK_FLAG_SEGMENT) {
1028       gst_element_post_message (GST_ELEMENT_CAST (demux),
1029           gst_message_new_segment_start (GST_OBJECT_CAST (demux),
1030               demux->time_segment.format, demux->time_segment.position));
1031     }
1032     if ((stop = demux->time_segment.stop) == -1)
1033       stop = demux->time_segment.duration;
1034
1035     GST_INFO_OBJECT (demux,
1036         "Saving newsegment event to be sent in streaming thread");
1037
1038     if (demux->pending_segment)
1039       gst_event_unref (demux->pending_segment);
1040
1041     demux->pending_segment = gst_event_new_segment (&demux->time_segment);
1042
1043     demux->need_segment = FALSE;
1044   }
1045
1046   /* and restart the task in case it got paused explicitely or by
1047    * the FLUSH_START event we pushed out. */
1048   gst_pad_start_task (demux->sinkpad, (GstTaskFunction) gst_dvdemux_loop,
1049       demux->sinkpad, NULL);
1050
1051   /* and release the lock again so we can continue streaming */
1052   GST_PAD_STREAM_UNLOCK (demux->sinkpad);
1053
1054   return TRUE;
1055
1056   /* ERRORS */
1057 wrong_rate:
1058   {
1059     GST_DEBUG_OBJECT (demux, "negative playback rate %lf not supported.", rate);
1060     return FALSE;
1061   }
1062 no_format:
1063   {
1064     GST_DEBUG_OBJECT (demux, "cannot convert to TIME format, seek aborted.");
1065     return FALSE;
1066   }
1067 }
1068
1069 static gboolean
1070 gst_dvdemux_send_event (GstElement * element, GstEvent * event)
1071 {
1072   GstDVDemux *dvdemux = GST_DVDEMUX (element);
1073   gboolean res = FALSE;
1074
1075   switch (GST_EVENT_TYPE (event)) {
1076     case GST_EVENT_SEEK:
1077     {
1078       /* checking header and configuring the seek must be atomic */
1079       GST_OBJECT_LOCK (dvdemux);
1080       if (g_atomic_int_get (&dvdemux->found_header) == 0) {
1081         GstEvent **event_p;
1082
1083         event_p = &dvdemux->seek_event;
1084
1085         /* We don't have pads yet. Keep the event. */
1086         GST_INFO_OBJECT (dvdemux, "Keeping the seek event for later");
1087
1088         gst_event_replace (event_p, event);
1089         GST_OBJECT_UNLOCK (dvdemux);
1090
1091         res = TRUE;
1092       } else {
1093         GST_OBJECT_UNLOCK (dvdemux);
1094
1095         if (dvdemux->seek_handler) {
1096           res = dvdemux->seek_handler (dvdemux, dvdemux->videosrcpad, event);
1097           gst_event_unref (event);
1098         }
1099       }
1100       break;
1101     }
1102     default:
1103       res = GST_ELEMENT_CLASS (parent_class)->send_event (element, event);
1104       break;
1105   }
1106
1107   return res;
1108 }
1109
1110 /* handle an event on the source pad, it's most likely a seek */
1111 static gboolean
1112 gst_dvdemux_handle_src_event (GstPad * pad, GstObject * parent,
1113     GstEvent * event)
1114 {
1115   gboolean res = TRUE;
1116   GstDVDemux *dvdemux;
1117
1118   dvdemux = GST_DVDEMUX (parent);
1119
1120   switch (GST_EVENT_TYPE (event)) {
1121     case GST_EVENT_SEEK:
1122       /* seek handler is installed based on scheduling mode */
1123       if (dvdemux->seek_handler)
1124         res = dvdemux->seek_handler (dvdemux, pad, event);
1125       else
1126         res = FALSE;
1127       break;
1128     case GST_EVENT_QOS:
1129       /* we can't really (yet) do QoS */
1130       res = FALSE;
1131       break;
1132     case GST_EVENT_NAVIGATION:
1133     case GST_EVENT_CAPS:
1134       /* no navigation or caps either... */
1135       res = FALSE;
1136       break;
1137     default:
1138       res = gst_pad_push_event (dvdemux->sinkpad, event);
1139       event = NULL;
1140       break;
1141   }
1142   if (event)
1143     gst_event_unref (event);
1144
1145   return res;
1146 }
1147
1148 /* does not take ownership of buffer */
1149 static GstFlowReturn
1150 gst_dvdemux_demux_audio (GstDVDemux * dvdemux, GstBuffer * buffer,
1151     guint64 duration)
1152 {
1153   gint num_samples;
1154   GstFlowReturn ret;
1155   GstMapInfo map;
1156
1157   gst_buffer_map (buffer, &map, GST_MAP_READ);
1158   dv_decode_full_audio (dvdemux->decoder, map.data, dvdemux->audio_buffers);
1159   gst_buffer_unmap (buffer, &map);
1160
1161   if (G_LIKELY ((num_samples = dv_get_num_samples (dvdemux->decoder)) > 0)) {
1162     gint16 *a_ptr;
1163     gint i, j;
1164     GstBuffer *outbuf;
1165     gint frequency, channels;
1166
1167     if (G_UNLIKELY (dvdemux->audiosrcpad == NULL))
1168       dvdemux->audiosrcpad = gst_dvdemux_add_pad (dvdemux, &audio_src_temp);
1169
1170     /* get initial format or check if format changed */
1171     frequency = dv_get_frequency (dvdemux->decoder);
1172     channels = dv_get_num_channels (dvdemux->decoder);
1173
1174     if (G_UNLIKELY ((frequency != dvdemux->frequency)
1175             || (channels != dvdemux->channels))) {
1176       GstCaps *caps;
1177       GstAudioInfo info;
1178
1179       dvdemux->frequency = frequency;
1180       dvdemux->channels = channels;
1181
1182       gst_audio_info_init (&info);
1183       gst_audio_info_set_format (&info, GST_AUDIO_FORMAT_S16LE,
1184           frequency, channels, NULL);
1185       caps = gst_audio_info_to_caps (&info);
1186       gst_pad_push_event (dvdemux->audiosrcpad, gst_event_new_stream_start ());
1187       gst_pad_set_caps (dvdemux->audiosrcpad, caps);
1188       gst_caps_unref (caps);
1189     }
1190
1191     outbuf = gst_buffer_new_and_alloc (num_samples *
1192         sizeof (gint16) * dvdemux->channels);
1193
1194     gst_buffer_map (outbuf, &map, GST_MAP_WRITE);
1195     a_ptr = (gint16 *) map.data;
1196
1197     for (i = 0; i < num_samples; i++) {
1198       for (j = 0; j < dvdemux->channels; j++) {
1199         *(a_ptr++) = dvdemux->audio_buffers[j][i];
1200       }
1201     }
1202     gst_buffer_unmap (outbuf, &map);
1203
1204     GST_DEBUG ("pushing audio %" GST_TIME_FORMAT,
1205         GST_TIME_ARGS (dvdemux->time_segment.position));
1206
1207     GST_BUFFER_TIMESTAMP (outbuf) = dvdemux->time_segment.position;
1208     GST_BUFFER_DURATION (outbuf) = duration;
1209     GST_BUFFER_OFFSET (outbuf) = dvdemux->audio_offset;
1210     dvdemux->audio_offset += num_samples;
1211     GST_BUFFER_OFFSET_END (outbuf) = dvdemux->audio_offset;
1212
1213     if (dvdemux->new_media)
1214       GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT);
1215
1216     ret = gst_pad_push (dvdemux->audiosrcpad, outbuf);
1217   } else {
1218     /* no samples */
1219     ret = GST_FLOW_OK;
1220   }
1221
1222   return ret;
1223 }
1224
1225 /* takes ownership of buffer */
1226 static GstFlowReturn
1227 gst_dvdemux_demux_video (GstDVDemux * dvdemux, GstBuffer * buffer,
1228     guint64 duration)
1229 {
1230   GstBuffer *outbuf;
1231   gint height;
1232   gboolean wide;
1233   GstFlowReturn ret = GST_FLOW_OK;
1234
1235   if (G_UNLIKELY (dvdemux->videosrcpad == NULL))
1236     dvdemux->videosrcpad = gst_dvdemux_add_pad (dvdemux, &video_src_temp);
1237
1238   /* get params */
1239   /* framerate is already up-to-date */
1240   height = dvdemux->decoder->height;
1241   wide = dv_format_wide (dvdemux->decoder);
1242
1243   /* see if anything changed */
1244   if (G_UNLIKELY ((dvdemux->height != height) || dvdemux->wide != wide)) {
1245     GstCaps *caps;
1246     gint par_x, par_y;
1247
1248     dvdemux->height = height;
1249     dvdemux->wide = wide;
1250
1251     if (dvdemux->decoder->system == e_dv_system_625_50) {
1252       if (wide) {
1253         par_x = PAL_WIDE_PAR_X;
1254         par_y = PAL_WIDE_PAR_Y;
1255       } else {
1256         par_x = PAL_NORMAL_PAR_X;
1257         par_y = PAL_NORMAL_PAR_Y;
1258       }
1259     } else {
1260       if (wide) {
1261         par_x = NTSC_WIDE_PAR_X;
1262         par_y = NTSC_WIDE_PAR_Y;
1263       } else {
1264         par_x = NTSC_NORMAL_PAR_X;
1265         par_y = NTSC_NORMAL_PAR_Y;
1266       }
1267     }
1268
1269     caps = gst_caps_new_simple ("video/x-dv",
1270         "systemstream", G_TYPE_BOOLEAN, FALSE,
1271         "width", G_TYPE_INT, 720,
1272         "height", G_TYPE_INT, height,
1273         "framerate", GST_TYPE_FRACTION, dvdemux->framerate_numerator,
1274         dvdemux->framerate_denominator,
1275         "pixel-aspect-ratio", GST_TYPE_FRACTION, par_x, par_y, NULL);
1276     gst_pad_push_event (dvdemux->videosrcpad, gst_event_new_stream_start ());
1277     gst_pad_set_caps (dvdemux->videosrcpad, caps);
1278     gst_caps_unref (caps);
1279   }
1280
1281   /* takes ownership of buffer here, we just need to modify
1282    * the metadata. */
1283   outbuf = gst_buffer_make_writable (buffer);
1284
1285   GST_BUFFER_TIMESTAMP (outbuf) = dvdemux->time_segment.position;
1286   GST_BUFFER_OFFSET (outbuf) = dvdemux->video_offset;
1287   GST_BUFFER_OFFSET_END (outbuf) = dvdemux->video_offset + 1;
1288   GST_BUFFER_DURATION (outbuf) = duration;
1289
1290   if (dvdemux->new_media)
1291     GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT);
1292
1293   GST_DEBUG ("pushing video %" GST_TIME_FORMAT,
1294       GST_TIME_ARGS (dvdemux->time_segment.position));
1295
1296   ret = gst_pad_push (dvdemux->videosrcpad, outbuf);
1297
1298   dvdemux->video_offset++;
1299
1300   return ret;
1301 }
1302
1303 static int
1304 get_ssyb_offset (int dif, int ssyb)
1305 {
1306   int offset;
1307
1308   offset = dif * 12000;         /* to dif */
1309   offset += 80 * (1 + (ssyb / 6));      /* to subcode pack */
1310   offset += 3;                  /* past header */
1311   offset += 8 * (ssyb % 6);     /* to ssyb */
1312
1313   return offset;
1314 }
1315
1316 static gboolean
1317 gst_dvdemux_get_timecode (GstDVDemux * dvdemux, GstBuffer * buffer,
1318     GstSMPTETimeCode * timecode)
1319 {
1320   guint8 *data;
1321   GstMapInfo map;
1322   int offset;
1323   int dif;
1324   int n_difs = dvdemux->decoder->num_dif_seqs;
1325
1326   gst_buffer_map (buffer, &map, GST_MAP_READ);
1327   data = map.data;
1328   for (dif = 0; dif < n_difs; dif++) {
1329     offset = get_ssyb_offset (dif, 3);
1330     if (data[offset + 3] == 0x13) {
1331       timecode->frames = ((data[offset + 4] >> 4) & 0x3) * 10 +
1332           (data[offset + 4] & 0xf);
1333       timecode->seconds = ((data[offset + 5] >> 4) & 0x3) * 10 +
1334           (data[offset + 5] & 0xf);
1335       timecode->minutes = ((data[offset + 6] >> 4) & 0x3) * 10 +
1336           (data[offset + 6] & 0xf);
1337       timecode->hours = ((data[offset + 7] >> 4) & 0x3) * 10 +
1338           (data[offset + 7] & 0xf);
1339       GST_DEBUG ("got timecode %" GST_SMPTE_TIME_CODE_FORMAT,
1340           GST_SMPTE_TIME_CODE_ARGS (timecode));
1341       gst_buffer_unmap (buffer, &map);
1342       return TRUE;
1343     }
1344   }
1345
1346   gst_buffer_unmap (buffer, &map);
1347   return FALSE;
1348 }
1349
1350 static gboolean
1351 gst_dvdemux_is_new_media (GstDVDemux * dvdemux, GstBuffer * buffer)
1352 {
1353   guint8 *data;
1354   GstMapInfo map;
1355   int aaux_offset;
1356   int dif;
1357   int n_difs;
1358
1359   n_difs = dvdemux->decoder->num_dif_seqs;
1360
1361   gst_buffer_map (buffer, &map, GST_MAP_READ);
1362   data = map.data;
1363   for (dif = 0; dif < n_difs; dif++) {
1364     if (dif & 1) {
1365       aaux_offset = (dif * 12000) + (6 + 16 * 1) * 80 + 3;
1366     } else {
1367       aaux_offset = (dif * 12000) + (6 + 16 * 4) * 80 + 3;
1368     }
1369     if (data[aaux_offset + 0] == 0x51) {
1370       if ((data[aaux_offset + 2] & 0x80) == 0) {
1371         gst_buffer_unmap (buffer, &map);
1372         return TRUE;
1373       }
1374     }
1375   }
1376
1377   gst_buffer_unmap (buffer, &map);
1378   return FALSE;
1379 }
1380
1381 /* takes ownership of buffer */
1382 static GstFlowReturn
1383 gst_dvdemux_demux_frame (GstDVDemux * dvdemux, GstBuffer * buffer)
1384 {
1385   GstClockTime next_ts;
1386   GstFlowReturn aret, vret, ret;
1387   GstMapInfo map;
1388   guint64 duration;
1389   GstSMPTETimeCode timecode;
1390   int frame_number;
1391
1392   if (G_UNLIKELY (dvdemux->need_segment)) {
1393     GstFormat format;
1394
1395     /* convert to time and store as start/end_timestamp */
1396     format = GST_FORMAT_TIME;
1397     if (!(gst_dvdemux_convert_sink_pair (dvdemux,
1398                 GST_FORMAT_BYTES, dvdemux->byte_segment.start,
1399                 dvdemux->byte_segment.stop, format,
1400                 (gint64 *) & dvdemux->time_segment.start,
1401                 (gint64 *) & dvdemux->time_segment.stop)))
1402       goto segment_error;
1403
1404     dvdemux->time_segment.rate = dvdemux->byte_segment.rate;
1405     dvdemux->time_segment.position = dvdemux->time_segment.start;
1406
1407     /* calculate current frame number */
1408     format = GST_FORMAT_DEFAULT;
1409     if (!(gst_dvdemux_src_convert (dvdemux, dvdemux->videosrcpad,
1410                 GST_FORMAT_TIME, dvdemux->time_segment.start,
1411                 &format, &dvdemux->frame_offset)))
1412       goto segment_error;
1413
1414     GST_DEBUG_OBJECT (dvdemux, "sending segment start: %" GST_TIME_FORMAT
1415         ", stop: %" GST_TIME_FORMAT ", time: %" GST_TIME_FORMAT,
1416         GST_TIME_ARGS (dvdemux->time_segment.start),
1417         GST_TIME_ARGS (dvdemux->time_segment.stop),
1418         GST_TIME_ARGS (dvdemux->time_segment.start));
1419
1420     gst_dvdemux_push_event (dvdemux,
1421         gst_event_new_segment (&dvdemux->time_segment));
1422
1423     dvdemux->need_segment = FALSE;
1424   }
1425
1426   gst_dvdemux_get_timecode (dvdemux, buffer, &timecode);
1427   gst_smpte_time_code_get_frame_number (
1428       (dvdemux->decoder->system == e_dv_system_625_50) ?
1429       GST_SMPTE_TIME_CODE_SYSTEM_25 : GST_SMPTE_TIME_CODE_SYSTEM_30,
1430       &frame_number, &timecode);
1431
1432   next_ts = gst_util_uint64_scale_int (
1433       (dvdemux->frame_offset + 1) * GST_SECOND,
1434       dvdemux->framerate_denominator, dvdemux->framerate_numerator);
1435   duration = next_ts - dvdemux->time_segment.position;
1436
1437   gst_buffer_map (buffer, &map, GST_MAP_READ);
1438   dv_parse_packs (dvdemux->decoder, map.data);
1439   gst_buffer_unmap (buffer, &map);
1440   dvdemux->new_media = FALSE;
1441   if (gst_dvdemux_is_new_media (dvdemux, buffer) &&
1442       dvdemux->frames_since_new_media > 2) {
1443     dvdemux->new_media = TRUE;
1444     dvdemux->frames_since_new_media = 0;
1445   }
1446   dvdemux->frames_since_new_media++;
1447
1448   /* does not take ownership of buffer */
1449   aret = ret = gst_dvdemux_demux_audio (dvdemux, buffer, duration);
1450   if (G_UNLIKELY (ret != GST_FLOW_OK && ret != GST_FLOW_NOT_LINKED)) {
1451     gst_buffer_unref (buffer);
1452     goto done;
1453   }
1454
1455   /* takes ownership of buffer */
1456   vret = ret = gst_dvdemux_demux_video (dvdemux, buffer, duration);
1457   if (G_UNLIKELY (ret != GST_FLOW_OK && ret != GST_FLOW_NOT_LINKED))
1458     goto done;
1459
1460   /* if both are not linked, we stop */
1461   if (G_UNLIKELY (aret == GST_FLOW_NOT_LINKED && vret == GST_FLOW_NOT_LINKED)) {
1462     ret = GST_FLOW_NOT_LINKED;
1463     goto done;
1464   }
1465
1466   dvdemux->time_segment.position = next_ts;
1467   dvdemux->frame_offset++;
1468
1469   /* check for the end of the segment */
1470   if (dvdemux->time_segment.stop != -1 && next_ts > dvdemux->time_segment.stop)
1471     ret = GST_FLOW_EOS;
1472   else
1473     ret = GST_FLOW_OK;
1474
1475 done:
1476   return ret;
1477
1478   /* ERRORS */
1479 segment_error:
1480   {
1481     GST_DEBUG ("error generating new_segment event");
1482     gst_buffer_unref (buffer);
1483     return GST_FLOW_ERROR;
1484   }
1485 }
1486
1487 /* flush any remaining data in the adapter, used in chain based scheduling mode */
1488 static GstFlowReturn
1489 gst_dvdemux_flush (GstDVDemux * dvdemux)
1490 {
1491   GstFlowReturn ret = GST_FLOW_OK;
1492
1493   while (gst_adapter_available (dvdemux->adapter) >= dvdemux->frame_len) {
1494     const guint8 *data;
1495     gint length;
1496
1497     /* get the accumulated bytes */
1498     data = gst_adapter_map (dvdemux->adapter, dvdemux->frame_len);
1499
1500     /* parse header to know the length and other params */
1501     if (G_UNLIKELY (dv_parse_header (dvdemux->decoder, data) < 0)) {
1502       gst_adapter_unmap (dvdemux->adapter);
1503       goto parse_header_error;
1504     }
1505     gst_adapter_unmap (dvdemux->adapter);
1506
1507     /* after parsing the header we know the length of the data */
1508     length = dvdemux->frame_len = dvdemux->decoder->frame_size;
1509     if (dvdemux->decoder->system == e_dv_system_625_50) {
1510       dvdemux->framerate_numerator = PAL_FRAMERATE_NUMERATOR;
1511       dvdemux->framerate_denominator = PAL_FRAMERATE_DENOMINATOR;
1512     } else {
1513       dvdemux->framerate_numerator = NTSC_FRAMERATE_NUMERATOR;
1514       dvdemux->framerate_denominator = NTSC_FRAMERATE_DENOMINATOR;
1515     }
1516     g_atomic_int_set (&dvdemux->found_header, 1);
1517
1518     /* let demux_video set the height, it needs to detect when things change so
1519      * it can reset caps */
1520
1521     /* if we still have enough for a frame, start decoding */
1522     if (G_LIKELY (gst_adapter_available (dvdemux->adapter) >= length)) {
1523       GstBuffer *buffer;
1524
1525       buffer = gst_adapter_take_buffer (dvdemux->adapter, length);
1526
1527       /* and decode the buffer, takes ownership */
1528       ret = gst_dvdemux_demux_frame (dvdemux, buffer);
1529       if (G_UNLIKELY (ret != GST_FLOW_OK))
1530         goto done;
1531     }
1532   }
1533 done:
1534   return ret;
1535
1536   /* ERRORS */
1537 parse_header_error:
1538   {
1539     GST_ELEMENT_ERROR (dvdemux, STREAM, DECODE,
1540         (NULL), ("Error parsing DV header"));
1541     return GST_FLOW_ERROR;
1542   }
1543 }
1544
1545 /* streaming operation:
1546  *
1547  * accumulate data until we have a frame, then decode.
1548  */
1549 static GstFlowReturn
1550 gst_dvdemux_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
1551 {
1552   GstDVDemux *dvdemux;
1553   GstFlowReturn ret;
1554   GstClockTime timestamp;
1555
1556   dvdemux = GST_DVDEMUX (parent);
1557
1558   /* a discontinuity in the stream, we need to get rid of
1559    * accumulated data in the adapter and assume a new frame
1560    * starts after the discontinuity */
1561   if (G_UNLIKELY (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT)))
1562     gst_adapter_clear (dvdemux->adapter);
1563
1564   /* a timestamp always should be respected */
1565   timestamp = GST_BUFFER_TIMESTAMP (buffer);
1566   if (GST_CLOCK_TIME_IS_VALID (timestamp)) {
1567     dvdemux->time_segment.position = timestamp;
1568     /* FIXME, adjust frame_offset and other counters */
1569   }
1570
1571   gst_adapter_push (dvdemux->adapter, buffer);
1572
1573   /* Apparently dv_parse_header can read from the body of the frame
1574    * too, so it needs more than header_size bytes. Wacky!
1575    */
1576   if (G_UNLIKELY (dvdemux->frame_len == -1)) {
1577     /* if we don't know the length of a frame, we assume it is
1578      * the NTSC_BUFFER length, as this is enough to figure out
1579      * if this is PAL or NTSC */
1580     dvdemux->frame_len = NTSC_BUFFER;
1581   }
1582
1583   /* and try to flush pending frames */
1584   ret = gst_dvdemux_flush (dvdemux);
1585
1586   return ret;
1587 }
1588
1589 /* pull based operation.
1590  *
1591  * Read header first to figure out the frame size. Then read
1592  * and decode full frames.
1593  */
1594 static void
1595 gst_dvdemux_loop (GstPad * pad)
1596 {
1597   GstFlowReturn ret;
1598   GstDVDemux *dvdemux;
1599   GstBuffer *buffer = NULL;
1600   GstMapInfo map;
1601
1602   dvdemux = GST_DVDEMUX (gst_pad_get_parent (pad));
1603
1604   if (G_UNLIKELY (g_atomic_int_get (&dvdemux->found_header) == 0)) {
1605     GST_DEBUG_OBJECT (dvdemux, "pulling first buffer");
1606     /* pull in NTSC sized buffer to figure out the frame
1607      * length */
1608     ret = gst_pad_pull_range (dvdemux->sinkpad,
1609         dvdemux->byte_segment.position, NTSC_BUFFER, &buffer);
1610     if (G_UNLIKELY (ret != GST_FLOW_OK))
1611       goto pause;
1612
1613     /* check buffer size, don't want to read small buffers */
1614     if (G_UNLIKELY (gst_buffer_get_size (buffer) < NTSC_BUFFER))
1615       goto small_buffer;
1616
1617     gst_buffer_map (buffer, &map, GST_MAP_READ);
1618     /* parse header to know the length and other params */
1619     if (G_UNLIKELY (dv_parse_header (dvdemux->decoder, map.data) < 0)) {
1620       gst_buffer_unmap (buffer, &map);
1621       goto parse_header_error;
1622     }
1623     gst_buffer_unmap (buffer, &map);
1624
1625     /* after parsing the header we know the length of the data */
1626     dvdemux->frame_len = dvdemux->decoder->frame_size;
1627     if (dvdemux->decoder->system == e_dv_system_625_50) {
1628       dvdemux->framerate_numerator = PAL_FRAMERATE_NUMERATOR;
1629       dvdemux->framerate_denominator = PAL_FRAMERATE_DENOMINATOR;
1630     } else {
1631       dvdemux->framerate_numerator = NTSC_FRAMERATE_NUMERATOR;
1632       dvdemux->framerate_denominator = NTSC_FRAMERATE_DENOMINATOR;
1633     }
1634     dvdemux->need_segment = TRUE;
1635
1636     /* see if we need to read a larger part */
1637     if (dvdemux->frame_len != NTSC_BUFFER) {
1638       gst_buffer_unref (buffer);
1639       buffer = NULL;
1640     }
1641
1642     {
1643       GstEvent *event;
1644
1645       /* setting header and prrforming the seek must be atomic */
1646       GST_OBJECT_LOCK (dvdemux);
1647       /* got header now */
1648       g_atomic_int_set (&dvdemux->found_header, 1);
1649
1650       /* now perform pending seek if any. */
1651       event = dvdemux->seek_event;
1652       if (event)
1653         gst_event_ref (event);
1654       GST_OBJECT_UNLOCK (dvdemux);
1655
1656       if (event) {
1657         if (!gst_dvdemux_handle_pull_seek (dvdemux, dvdemux->videosrcpad,
1658                 event)) {
1659           GST_ELEMENT_WARNING (dvdemux, STREAM, DECODE, (NULL),
1660               ("Error perfoming initial seek"));
1661         }
1662         gst_event_unref (event);
1663
1664         /* and we need to pull a new buffer in all cases. */
1665         if (buffer) {
1666           gst_buffer_unref (buffer);
1667           buffer = NULL;
1668         }
1669       }
1670     }
1671   }
1672
1673
1674   if (G_UNLIKELY (dvdemux->pending_segment)) {
1675
1676     /* now send the newsegment */
1677     GST_DEBUG_OBJECT (dvdemux, "Sending newsegment from");
1678
1679     gst_dvdemux_push_event (dvdemux, dvdemux->pending_segment);
1680     dvdemux->pending_segment = NULL;
1681   }
1682
1683   if (G_LIKELY (buffer == NULL)) {
1684     GST_DEBUG_OBJECT (dvdemux, "pulling buffer at offset %" G_GINT64_FORMAT,
1685         dvdemux->byte_segment.position);
1686
1687     ret = gst_pad_pull_range (dvdemux->sinkpad,
1688         dvdemux->byte_segment.position, dvdemux->frame_len, &buffer);
1689     if (ret != GST_FLOW_OK)
1690       goto pause;
1691
1692     /* check buffer size, don't want to read small buffers */
1693     if (gst_buffer_get_size (buffer) < dvdemux->frame_len)
1694       goto small_buffer;
1695   }
1696   /* and decode the buffer */
1697   ret = gst_dvdemux_demux_frame (dvdemux, buffer);
1698   if (G_UNLIKELY (ret != GST_FLOW_OK))
1699     goto pause;
1700
1701   /* and position ourselves for the next buffer */
1702   dvdemux->byte_segment.position += dvdemux->frame_len;
1703
1704 done:
1705   gst_object_unref (dvdemux);
1706
1707   return;
1708
1709   /* ERRORS */
1710 parse_header_error:
1711   {
1712     GST_ELEMENT_ERROR (dvdemux, STREAM, DECODE,
1713         (NULL), ("Error parsing DV header"));
1714     gst_buffer_unref (buffer);
1715     gst_pad_pause_task (dvdemux->sinkpad);
1716     gst_dvdemux_push_event (dvdemux, gst_event_new_eos ());
1717     goto done;
1718   }
1719 small_buffer:
1720   {
1721     GST_ELEMENT_ERROR (dvdemux, STREAM, DECODE,
1722         (NULL), ("Error reading buffer"));
1723     gst_buffer_unref (buffer);
1724     gst_pad_pause_task (dvdemux->sinkpad);
1725     gst_dvdemux_push_event (dvdemux, gst_event_new_eos ());
1726     goto done;
1727   }
1728 pause:
1729   {
1730     GST_INFO_OBJECT (dvdemux, "pausing task, %s", gst_flow_get_name (ret));
1731     gst_pad_pause_task (dvdemux->sinkpad);
1732     if (ret == GST_FLOW_EOS) {
1733       GST_LOG_OBJECT (dvdemux, "got eos");
1734       /* so align our position with the end of it, if there is one
1735        * this ensures a subsequent will arrive at correct base/acc time */
1736       if (dvdemux->time_segment.rate > 0.0 &&
1737           GST_CLOCK_TIME_IS_VALID (dvdemux->time_segment.stop))
1738         dvdemux->time_segment.position = dvdemux->time_segment.stop;
1739       else if (dvdemux->time_segment.rate < 0.0)
1740         dvdemux->time_segment.position = dvdemux->time_segment.start;
1741       /* perform EOS logic */
1742       if (dvdemux->time_segment.flags & GST_SEEK_FLAG_SEGMENT) {
1743         gst_element_post_message (GST_ELEMENT (dvdemux),
1744             gst_message_new_segment_done (GST_OBJECT_CAST (dvdemux),
1745                 dvdemux->time_segment.format, dvdemux->time_segment.position));
1746         gst_dvdemux_push_event (dvdemux,
1747             gst_event_new_segment_done (dvdemux->time_segment.format,
1748                 dvdemux->time_segment.position));
1749       } else {
1750         gst_dvdemux_push_event (dvdemux, gst_event_new_eos ());
1751       }
1752     } else if (ret == GST_FLOW_NOT_LINKED || ret < GST_FLOW_EOS) {
1753       /* for fatal errors or not-linked we post an error message */
1754       GST_ELEMENT_ERROR (dvdemux, STREAM, FAILED,
1755           (NULL), ("streaming stopped, reason %s", gst_flow_get_name (ret)));
1756       gst_dvdemux_push_event (dvdemux, gst_event_new_eos ());
1757     }
1758     goto done;
1759   }
1760 }
1761
1762 static gboolean
1763 gst_dvdemux_sink_activate_mode (GstPad * sinkpad, GstObject * parent,
1764     GstPadMode mode, gboolean active)
1765 {
1766   gboolean res;
1767   GstDVDemux *demux = GST_DVDEMUX (parent);
1768
1769   switch (mode) {
1770     case GST_PAD_MODE_PULL:
1771       if (active) {
1772         demux->seek_handler = gst_dvdemux_handle_pull_seek;
1773         res = gst_pad_start_task (sinkpad,
1774             (GstTaskFunction) gst_dvdemux_loop, sinkpad, NULL);
1775       } else {
1776         demux->seek_handler = NULL;
1777         res = gst_pad_stop_task (sinkpad);
1778       }
1779       break;
1780     case GST_PAD_MODE_PUSH:
1781       if (active) {
1782         GST_DEBUG_OBJECT (demux, "activating push/chain function");
1783         demux->seek_handler = gst_dvdemux_handle_push_seek;
1784       } else {
1785         GST_DEBUG_OBJECT (demux, "deactivating push/chain function");
1786         demux->seek_handler = NULL;
1787       }
1788       res = TRUE;
1789       break;
1790     default:
1791       res = FALSE;
1792       break;
1793   }
1794   return res;
1795 }
1796
1797 /* decide on push or pull based scheduling */
1798 static gboolean
1799 gst_dvdemux_sink_activate (GstPad * sinkpad, GstObject * parent)
1800 {
1801   GstQuery *query;
1802   gboolean pull_mode;
1803
1804   query = gst_query_new_scheduling ();
1805
1806   if (!gst_pad_peer_query (sinkpad, query)) {
1807     gst_query_unref (query);
1808     goto activate_push;
1809   }
1810
1811   pull_mode = gst_query_has_scheduling_mode (query, GST_PAD_MODE_PULL);
1812   gst_query_unref (query);
1813
1814   if (!pull_mode)
1815     goto activate_push;
1816
1817   GST_DEBUG_OBJECT (sinkpad, "activating pull");
1818   return gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PULL, TRUE);
1819
1820 activate_push:
1821   {
1822     GST_DEBUG_OBJECT (sinkpad, "activating push");
1823     return gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PUSH, TRUE);
1824   }
1825 }
1826
1827 static GstStateChangeReturn
1828 gst_dvdemux_change_state (GstElement * element, GstStateChange transition)
1829 {
1830   GstDVDemux *dvdemux = GST_DVDEMUX (element);
1831   GstStateChangeReturn ret;
1832
1833   switch (transition) {
1834     case GST_STATE_CHANGE_NULL_TO_READY:
1835       break;
1836     case GST_STATE_CHANGE_READY_TO_PAUSED:
1837       dvdemux->decoder = dv_decoder_new (0, FALSE, FALSE);
1838       dv_set_error_log (dvdemux->decoder, NULL);
1839       gst_dvdemux_reset (dvdemux);
1840       break;
1841     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
1842       break;
1843     default:
1844       break;
1845   }
1846
1847   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
1848
1849   switch (transition) {
1850     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
1851       break;
1852     case GST_STATE_CHANGE_PAUSED_TO_READY:
1853       gst_adapter_clear (dvdemux->adapter);
1854       dv_decoder_free (dvdemux->decoder);
1855       dvdemux->decoder = NULL;
1856
1857       gst_dvdemux_remove_pads (dvdemux);
1858       break;
1859     case GST_STATE_CHANGE_READY_TO_NULL:
1860     {
1861       GstEvent **event_p;
1862
1863       event_p = &dvdemux->seek_event;
1864       gst_event_replace (event_p, NULL);
1865       if (dvdemux->pending_segment)
1866         gst_event_unref (dvdemux->pending_segment);
1867       dvdemux->pending_segment = NULL;
1868       break;
1869     }
1870     default:
1871       break;
1872   }
1873   return ret;
1874 }