205dca17fa5db24ae89bdd507e2e81c76a2ba770
[glsdk/gst-plugin-ducati.git] / src / gstducatividdec.c
1 /*
2  * GStreamer
3  * Copyright (c) 2010, Texas Instruments Incorporated
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation
8  * version 2.1 of the License.
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  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
18  */
20 #ifdef HAVE_CONFIG_H
21 #  include <config.h>
22 #endif
24 #include "gstducatividdec.h"
25 #include "gstducatibufferpriv.h"
27 GST_BOILERPLATE (GstDucatiVidDec, gst_ducati_viddec, GstElement,
28     GST_TYPE_ELEMENT);
30 static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",
31     GST_PAD_SRC,
32     GST_PAD_ALWAYS,
33     GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV_STRIDED ("NV12", "[ 0, max ]"))
34     );
36 enum
37 {
38   PROP_0,
39   PROP_VERSION,
40 };
42 /* helper functions */
44 static void
45 engine_close (GstDucatiVidDec * self)
46 {
47   if (self->engine) {
48     Engine_close (self->engine);
49     self->engine = NULL;
50   }
52   if (self->params) {
53     dce_free (self->params);
54     self->params = NULL;
55   }
57   if (self->dynParams) {
58     dce_free (self->dynParams);
59     self->dynParams = NULL;
60   }
62   if (self->status) {
63     dce_free (self->status);
64     self->status = NULL;
65   }
67   if (self->inBufs) {
68     dce_free (self->inBufs);
69     self->inBufs = NULL;
70   }
72   if (self->outBufs) {
73     dce_free (self->outBufs);
74     self->outBufs = NULL;
75   }
77   if (self->inArgs) {
78     dce_free (self->inArgs);
79     self->inArgs = NULL;
80   }
82   if (self->outArgs) {
83     dce_free (self->outArgs);
84     self->outArgs = NULL;
85   }
87   if (self->device) {
88     dce_deinit (self->device);
89     self->device = NULL;
90   }
91 }
93 static gboolean
94 engine_open (GstDucatiVidDec * self)
95 {
96   gboolean ret;
97   int ec;
99   if (G_UNLIKELY (self->engine)) {
100     return TRUE;
101   }
103   if (self->device == NULL) {
104     self->device = dce_init ();
105     if (self->device == NULL) {
106       GST_ERROR_OBJECT (self, "dce_init() failed");
107       return FALSE;
108     }
109   }
111   GST_DEBUG_OBJECT (self, "opening engine");
113   self->engine = Engine_open ((String) "ivahd_vidsvr", NULL, &ec);
114   if (G_UNLIKELY (!self->engine)) {
115     GST_ERROR_OBJECT (self, "could not create engine");
116     return FALSE;
117   }
119   ret = GST_DUCATIVIDDEC_GET_CLASS (self)->allocate_params (self,
120       sizeof (IVIDDEC3_Params), sizeof (IVIDDEC3_DynamicParams),
121       sizeof (IVIDDEC3_Status), sizeof (IVIDDEC3_InArgs),
122       sizeof (IVIDDEC3_OutArgs));
124   return ret;
127 static void
128 codec_delete (GstDucatiVidDec * self)
130   if (self->pool) {
131     gst_drm_buffer_pool_destroy (self->pool);
132     self->pool = NULL;
133   }
135   if (self->codec) {
136     VIDDEC3_delete (self->codec);
137     self->codec = NULL;
138   }
140   if (self->input_bo) {
141     omap_bo_del (self->input_bo);
142     self->input_bo = NULL;
143   }
146 static gboolean
147 codec_create (GstDucatiVidDec * self)
149   gint err;
150   const gchar *codec_name;
152   codec_delete (self);
154   if (G_UNLIKELY (!self->engine)) {
155     GST_ERROR_OBJECT (self, "no engine");
156     return FALSE;
157   }
159   /* these need to be set before VIDDEC3_create */
160   self->params->maxWidth = self->width;
161   self->params->maxHeight = self->height;
163   codec_name = GST_DUCATIVIDDEC_GET_CLASS (self)->codec_name;
165   /* create codec: */
166   GST_DEBUG_OBJECT (self, "creating codec: %s", codec_name);
167   self->codec =
168       VIDDEC3_create (self->engine, (String) codec_name, self->params);
170   if (!self->codec) {
171     return FALSE;
172   }
174   err =
175       VIDDEC3_control (self->codec, XDM_SETPARAMS, self->dynParams,
176       self->status);
177   if (err) {
178     GST_ERROR_OBJECT (self, "failed XDM_SETPARAMS");
179     return FALSE;
180   }
182   self->first_in_buffer = TRUE;
183   self->first_out_buffer = TRUE;
185   /* allocate input buffer and initialize inBufs: */
186   self->input_bo = omap_bo_new (self->device,
187       self->width * self->height, OMAP_BO_WC);
188   self->input = omap_bo_map (self->input_bo);
189   self->inBufs->numBufs = 1;
190   self->inBufs->descs[0].buf = (XDAS_Int8 *) omap_bo_handle (self->input_bo);
192   return TRUE;
195 static inline GstBuffer *
196 codec_buffer_pool_get (GstDucatiVidDec * self, GstBuffer * buf)
198   if (G_UNLIKELY (!self->pool)) {
199     guint size = gst_video_format_get_size (GST_VIDEO_FORMAT_NV12,
200         self->padded_width, self->padded_height);
202     GST_DEBUG_OBJECT (self, "creating bufferpool");
203     self->pool = gst_drm_buffer_pool_new (GST_ELEMENT (self),
204         dce_get_fd (), GST_PAD_CAPS (self->srcpad), size);
205   }
206   return GST_BUFFER (gst_drm_buffer_pool_get (self->pool, FALSE));
209 static GstDucatiBufferPriv *
210 get_buffer_priv (GstDucatiVidDec * self, GstBuffer * buf)
212   GstDucatiBufferPriv *priv = gst_ducati_buffer_priv_get (buf);
213   if (!priv) {
214     GstVideoFormat format = GST_VIDEO_FORMAT_NV12;
215     GstDmaBuf *dmabuf = gst_buffer_get_dma_buf (buf);
217     /* if it isn't a dmabuf buffer that we can import, then there
218      * is nothing we can do with it:
219      */
220     if (!dmabuf) {
221       GST_DEBUG_OBJECT (self, "not importing non dmabuf buffer");
222       return NULL;
223     }
225     priv = gst_ducati_buffer_priv_new ();
227     priv->bo = omap_bo_from_dmabuf (self->device, gst_dma_buf_get_fd (dmabuf));
229     priv->uv_offset = gst_video_format_get_component_offset (format,
230         1, self->stride, self->padded_height);
231     priv->size = gst_video_format_get_size (format,
232         self->stride, self->padded_height);
234     gst_ducati_buffer_priv_set (buf, priv);
235     gst_mini_object_unref (GST_MINI_OBJECT (priv));
236   }
237   return priv;
240 static XDAS_Int32
241 codec_prepare_outbuf (GstDucatiVidDec * self, GstBuffer ** buf,
242     gboolean force_internal)
244   GstDucatiBufferPriv *priv = NULL;
246   if (!force_internal)
247     priv = get_buffer_priv (self, *buf);
249   if (!priv) {
250     GstBuffer *orig = *buf;
252     GST_DEBUG_OBJECT (self, "internal bufferpool forced");
253     *buf = codec_buffer_pool_get (self, NULL);
254     GST_BUFFER_TIMESTAMP (*buf) = GST_BUFFER_TIMESTAMP (orig);
255     GST_BUFFER_DURATION (*buf) = GST_BUFFER_DURATION (orig);
256     gst_buffer_unref (orig);
257     return codec_prepare_outbuf (self, buf, FALSE);
258   }
260   self->outBufs->numBufs = 2;
261   self->outBufs->descs[0].memType = XDM_MEMTYPE_BO;
262   self->outBufs->descs[0].buf = (XDAS_Int8 *) omap_bo_handle (priv->bo);
263   self->outBufs->descs[0].bufSize.bytes = priv->uv_offset;
264   self->outBufs->descs[1].memType = XDM_MEMTYPE_BO_OFFSET;
265   self->outBufs->descs[1].buf = (XDAS_Int8 *) priv->uv_offset;
266   self->outBufs->descs[1].bufSize.bytes = priv->size - priv->uv_offset;
268   return (XDAS_Int32) * buf;    // XXX use lookup table
271 static GstBuffer *
272 codec_get_outbuf (GstDucatiVidDec * self, XDAS_Int32 id)
274   GstBuffer *buf = (GstBuffer *) id;    // XXX use lookup table
275   if (buf) {
276     gst_buffer_ref (buf);
277   }
278   return buf;
281 static void
282 codec_unlock_outbuf (GstDucatiVidDec * self, XDAS_Int32 id)
284   GstBuffer *buf = (GstBuffer *) id;    // XXX use lookup table
285   if (buf) {
286     GST_DEBUG_OBJECT (self, "free buffer: %d %p", id, buf);
287     gst_buffer_unref (buf);
288   }
291 static gint
292 codec_process (GstDucatiVidDec * self, gboolean send, gboolean flush,
293     GstFlowReturn * flow_ret)
295   gint err;
296   GstClockTime t;
297   GstBuffer *outbuf = NULL;
298   gint i;
299   GstDucatiVidDecClass *klass = GST_DUCATIVIDDEC_GET_CLASS (self);
300   GstFlowReturn ret = GST_FLOW_OK;
301   if (flow_ret)
302     /* never leave flow_ret uninitialized */
303     *flow_ret = GST_FLOW_OK;
305   memset (&self->outArgs->outputID, 0, sizeof (self->outArgs->outputID));
306   memset (&self->outArgs->freeBufID, 0, sizeof (self->outArgs->freeBufID));
308   t = gst_util_get_timestamp ();
309   err = VIDDEC3_process (self->codec,
310       self->inBufs, self->outBufs, self->inArgs, self->outArgs);
311   GST_DEBUG_OBJECT (self, "%10dns", (gint) (gst_util_get_timestamp () - t));
313   if (err) {
314     GST_WARNING_OBJECT (self, "err=%d, extendedError=%08x",
315         err, self->outArgs->extendedError);
316     gst_ducati_log_extended_error_info (self->outArgs->extendedError);
318     err = VIDDEC3_control (self->codec, XDM_GETSTATUS,
319         self->dynParams, self->status);
320     if (err) {
321       GST_WARNING_OBJECT (self, "XDM_GETSTATUS: err=%d, extendedError=%08x",
322           err, self->status->extendedError);
323       gst_ducati_log_extended_error_info (self->status->extendedError);
324     }
326     if (flush)
327       err = XDM_EFAIL;
328     else
329       err = klass->handle_error (self, err,
330           self->outArgs->extendedError, self->status->extendedError);
331   }
333   /* we now let the codec decide */
334   self->dynParams->newFrameFlag = XDAS_FALSE;
336   if (err == XDM_EFAIL || self->outArgs->outBufsInUseFlag)
337     goto skip_outbuf_processing;
339   for (i = 0; i < IVIDEO2_MAX_IO_BUFFERS && self->outArgs->outputID[i]; i++) {
340     gboolean interlaced;
342     outbuf = codec_get_outbuf (self, self->outArgs->outputID[i]);
344     interlaced =
345         self->outArgs->decodedBufs.contentType ==
346         IVIDEO_PROGRESSIVE ? FALSE : TRUE;
348     /* if send is FALSE, don't try to renegotiate as we could be flushing during
349      * a PAUSED->READY state change
350      */
351     if (send && interlaced != self->interlaced) {
352       GstCaps *caps;
354       GST_WARNING_OBJECT (self, "upstream set interlaced=%d but codec "
355           "thinks interlaced=%d... trusting codec", self->interlaced,
356           interlaced);
358       self->interlaced = interlaced;
360       caps =
361           gst_caps_make_writable (gst_pad_get_negotiated_caps (self->srcpad));
362       GST_INFO_OBJECT (self, "changing interlace field in caps");
363       gst_caps_set_simple (caps, "interlaced", G_TYPE_BOOLEAN, interlaced,
364           NULL);
365       gst_drm_buffer_pool_set_caps (self->pool, caps);
366       if (!gst_pad_set_caps (self->srcpad, caps)) {
367         GST_ERROR_OBJECT (self,
368             "downstream didn't want to change interlace mode");
369         err = XDM_EFAIL;
370       }
371       gst_caps_unref (caps);
373       /* this buffer still has the old caps so we skip it */
374       send = FALSE;
375     }
377     if (G_UNLIKELY (self->send_crop_event) && send) {
378       gint crop_width, crop_height;
379       GstDucatiVidDecClass *klass = GST_DUCATIVIDDEC_GET_CLASS (self);
381       /* send region of interest to sink on first buffer: */
382       XDM_Rect *r = &(self->outArgs->displayBufs.bufDesc[0].activeFrameRegion);
384       crop_width = r->bottomRight.x - r->topLeft.x;
385       crop_height = r->bottomRight.y - r->topLeft.y;
387       if (crop_width > self->input_width)
388         crop_width = self->input_width;
389       if (crop_height > self->input_height)
390         crop_height = self->input_height;
392       if (self->interlaced && !strcmp (klass->codec_name, "ivahd_mpeg2vdec"))
393         crop_height = crop_height / 2;
395       GST_INFO_OBJECT (self, "active frame region %d, %d, %d, %d, crop %dx%d",
396           r->topLeft.x, r->topLeft.y, r->bottomRight.x, r->bottomRight.y,
397           crop_width, crop_height);
399       gst_pad_push_event (self->srcpad,
400           gst_event_new_crop (r->topLeft.y, r->topLeft.x,
401               crop_width, crop_height));
403       if (self->crop)
404         gst_video_crop_unref (self->crop);
406       self->crop = gst_video_crop_new (r->topLeft.y, r->topLeft.x,
407           crop_width, crop_height);
409       self->send_crop_event = FALSE;
410     }
412     if (G_UNLIKELY (self->first_out_buffer) && send && !self->outArgs->outBufsInUseFlag) {
413       GstDRMBufferPool *pool;
414       self->first_out_buffer = FALSE;
416       /* Destroy the pool so the buffers we used so far are eventually released.
417        * The pool will be recreated if needed.
418        */
419       pool = self->pool;
420       self->pool = NULL;
421       gst_drm_buffer_pool_destroy (pool);
422     }
424     if (send && !self->outArgs->outBufsInUseFlag) {
425       GstClockTime ts;
427       ts = GST_BUFFER_TIMESTAMP (outbuf);
429       GST_DEBUG_OBJECT (self, "got buffer: %d %p (%" GST_TIME_FORMAT ")",
430           i, outbuf, GST_TIME_ARGS (ts));
432       if (self->ts_may_be_pts) {
433         if ((self->last_pts != GST_CLOCK_TIME_NONE) && (self->last_pts > ts)) {
434           GST_DEBUG_OBJECT (self, "detected PTS going backwards, "
435               "enabling ts_is_pts");
436           self->ts_is_pts = TRUE;
437         }
438       }
440       self->last_pts = ts;
442       if (self->dts_ridx != self->dts_widx) {
443         ts = self->dts_queue[self->dts_ridx++ % NDTS];
444       }
446       if (self->ts_is_pts) {
447         /* if we have a queued DTS from demuxer, use that instead: */
448         GST_BUFFER_TIMESTAMP (outbuf) = ts;
449         GST_DEBUG_OBJECT (self, "fixed ts: %d %p (%" GST_TIME_FORMAT ")",
450             i, outbuf, GST_TIME_ARGS (ts));
451       }
453       if (GST_BUFFER_CAPS (outbuf) &&
454           !gst_caps_is_equal (GST_BUFFER_CAPS (outbuf),
455               GST_PAD_CAPS (self->srcpad))) {
456         /* this looks a bit scary but it's really just to change the interlace=
457          * field in caps when we start as !interlaced and the codec detects
458          * otherwise */
459         GST_WARNING_OBJECT (self, "overriding buffer caps to fix "
460             "interlace mismatch");
461         outbuf = gst_buffer_make_metadata_writable (outbuf);
462         gst_buffer_set_caps (outbuf, GST_PAD_CAPS (self->srcpad));
463       }
465       if (self->crop)
466         gst_buffer_set_video_crop (outbuf, self->crop);
468       ret = gst_pad_push (self->srcpad, outbuf);
469       if (flow_ret)
470         *flow_ret = ret;
471       if (ret != GST_FLOW_OK) {
472         GST_WARNING_OBJECT (self, "push failed %s", gst_flow_get_name (ret));
473         /* just unref the remaining buffers (if any) */
474         send = FALSE;
475       }
476     } else {
477       GST_DEBUG_OBJECT (self, "free buffer: %d %p", i, outbuf);
478       gst_buffer_unref (outbuf);
479     }
480   }
482 skip_outbuf_processing:
483   for (i = 0; i < IVIDEO2_MAX_IO_BUFFERS && self->outArgs->freeBufID[i]; i++) {
484     codec_unlock_outbuf (self, self->outArgs->freeBufID[i]);
485   }
487   return err;
490 /** call control(FLUSH), and then process() to pop out all buffers */
491 gboolean
492 gst_ducati_viddec_codec_flush (GstDucatiVidDec * self, gboolean eos)
494   gint err = FALSE;
496   GST_DEBUG_OBJECT (self, "flush: eos=%d", eos);
498   /* note: flush is synchronized against _chain() to avoid calling
499    * the codec from multiple threads
500    */
501   GST_PAD_STREAM_LOCK (self->sinkpad);
503   self->dts_ridx = self->dts_widx = 0;
504   self->last_dts = self->last_pts = GST_CLOCK_TIME_NONE;
505   self->ts_may_be_pts = TRUE;
506   self->ts_is_pts = FALSE;
507   self->wait_keyframe = TRUE;
508   self->in_size = 0;
509   self->needs_flushing = FALSE;
510   self->need_out_buf = TRUE;
512   if (G_UNLIKELY (self->first_in_buffer)) {
513     goto out;
514   }
516   if (G_UNLIKELY (!self->codec)) {
517     GST_WARNING_OBJECT (self, "no codec");
518     goto out;
519   }
521   err = VIDDEC3_control (self->codec, XDM_FLUSH, self->dynParams, self->status);
522   if (err) {
523     GST_ERROR_OBJECT (self, "failed XDM_FLUSH");
524     goto out;
525   }
527   self->inBufs->descs[0].bufSize.bytes = 0;
528   self->inArgs->numBytes = 0;
529   self->inArgs->inputID = 0;
531   do {
532     err = codec_process (self, eos, TRUE, NULL);
533   } while (err != XDM_EFAIL);
535   /* reset outArgs in case we're flushing in codec_process trying to do error
536    * recovery */
537   memset (&self->outArgs->outputID, 0, sizeof (self->outArgs->outputID));
538   memset (&self->outArgs->freeBufID, 0, sizeof (self->outArgs->freeBufID));
540   self->dynParams->newFrameFlag = XDAS_TRUE;
542   /* on a flush, it is normal (and not an error) for the last _process() call
543    * to return an error..
544    */
545   err = XDM_EOK;
547 out:
548   GST_PAD_STREAM_UNLOCK (self->sinkpad);
549   GST_DEBUG_OBJECT (self, "done");
551   return !err;
554 /* GstDucatiVidDec vmethod default implementations */
556 static gboolean
557 gst_ducati_viddec_parse_caps (GstDucatiVidDec * self, GstStructure * s)
559   const GValue *codec_data;
560   gint w, h;
562   if (gst_structure_get_int (s, "width", &self->input_width) &&
563       gst_structure_get_int (s, "height", &self->input_height)) {
565     h = ALIGN2 (self->input_height, 4); /* round up to MB */
566     w = ALIGN2 (self->input_width, 4);  /* round up to MB */
568     /* if we've already created codec, but the resolution has changed, we
569      * need to re-create the codec:
570      */
571     if (G_UNLIKELY (self->codec)) {
572       if ((h != self->height) || (w != self->width)) {
573         codec_delete (self);
574       }
575     }
577     self->width = w;
578     self->height = h;
580     codec_data = gst_structure_get_value (s, "codec_data");
582     if (codec_data) {
583       GstBuffer *buffer = gst_value_get_buffer (codec_data);
584       GST_DEBUG_OBJECT (self, "codec_data: %" GST_PTR_FORMAT, buffer);
585       self->codec_data = gst_buffer_ref (buffer);
586     }
588     return TRUE;
589   }
591   return FALSE;
594 static gboolean
595 gst_ducati_viddec_allocate_params (GstDucatiVidDec * self, gint params_sz,
596     gint dynparams_sz, gint status_sz, gint inargs_sz, gint outargs_sz)
599   /* allocate params: */
600   self->params = dce_alloc (params_sz);
601   if (G_UNLIKELY (!self->params)) {
602     return FALSE;
603   }
604   self->params->size = params_sz;
605   self->params->maxFrameRate = 30000;
606   self->params->maxBitRate = 10000000;
608   self->params->dataEndianness = XDM_BYTE;
609   self->params->forceChromaFormat = XDM_YUV_420SP;
610   self->params->operatingMode = IVIDEO_DECODE_ONLY;
612   self->params->displayBufsMode = IVIDDEC3_DISPLAYBUFS_EMBEDDED;
613   self->params->inputDataMode = IVIDEO_ENTIREFRAME;
614   self->params->outputDataMode = IVIDEO_ENTIREFRAME;
615   self->params->numInputDataUnits = 0;
616   self->params->numOutputDataUnits = 0;
618   self->params->metadataType[0] = IVIDEO_METADATAPLANE_NONE;
619   self->params->metadataType[1] = IVIDEO_METADATAPLANE_NONE;
620   self->params->metadataType[2] = IVIDEO_METADATAPLANE_NONE;
621   self->params->errorInfoMode = IVIDEO_ERRORINFO_OFF;
623   /* allocate dynParams: */
624   self->dynParams = dce_alloc (dynparams_sz);
625   if (G_UNLIKELY (!self->dynParams)) {
626     return FALSE;
627   }
628   self->dynParams->size = dynparams_sz;
629   self->dynParams->decodeHeader = XDM_DECODE_AU;
630   self->dynParams->displayWidth = 0;
631   self->dynParams->frameSkipMode = IVIDEO_NO_SKIP;
632   self->dynParams->newFrameFlag = XDAS_TRUE;
634   /* allocate status: */
635   self->status = dce_alloc (status_sz);
636   if (G_UNLIKELY (!self->status)) {
637     return FALSE;
638   }
639   self->status->size = status_sz;
641   /* allocate inBufs/outBufs: */
642   self->inBufs = dce_alloc (sizeof (XDM2_BufDesc));
643   self->outBufs = dce_alloc (sizeof (XDM2_BufDesc));
644   if (G_UNLIKELY (!self->inBufs) || G_UNLIKELY (!self->outBufs)) {
645     return FALSE;
646   }
648   /* allocate inArgs/outArgs: */
649   self->inArgs = dce_alloc (inargs_sz);
650   self->outArgs = dce_alloc (outargs_sz);
651   if (G_UNLIKELY (!self->inArgs) || G_UNLIKELY (!self->outArgs)) {
652     return FALSE;
653   }
654   self->inArgs->size = inargs_sz;
655   self->outArgs->size = outargs_sz;
657   return TRUE;
660 static GstBuffer *
661 gst_ducati_viddec_push_input (GstDucatiVidDec * self, GstBuffer * buf)
663   if (G_UNLIKELY (self->first_in_buffer) && self->codec_data) {
664     push_input (self, GST_BUFFER_DATA (self->codec_data),
665         GST_BUFFER_SIZE (self->codec_data));
666   }
668   /* just copy entire buffer */
669   push_input (self, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
670   gst_buffer_unref (buf);
672   return NULL;
675 static gint
676 gst_ducati_viddec_handle_error (GstDucatiVidDec * self, gint ret,
677     gint extended_error, gint status_extended_error)
679   if (XDM_ISFATALERROR (extended_error))
680     ret = XDM_EFAIL;
681   else
682     ret = XDM_EOK;
684   return ret;
687 /* GstElement vmethod implementations */
689 static gboolean
690 gst_ducati_viddec_sink_setcaps (GstPad * pad, GstCaps * caps)
692   gboolean ret = TRUE;
693   GstDucatiVidDec *self = GST_DUCATIVIDDEC (gst_pad_get_parent (pad));
694   GstDucatiVidDecClass *klass = GST_DUCATIVIDDEC_GET_CLASS (self);
695   GstStructure *s;
696   GstCaps *outcaps = NULL;
697   GstStructure *out_s;
698   gint par_width, par_height;
699   gboolean par_present;
701   GST_INFO_OBJECT (self, "setcaps (sink): %" GST_PTR_FORMAT, caps);
703   s = gst_caps_get_structure (caps, 0);
704   if (!klass->parse_caps (self, s)) {
705     GST_WARNING_OBJECT (self, "missing required fields");
706     ret = FALSE;
707     goto out;
708   }
710   /* update output/padded sizes */
711   klass->update_buffer_size (self);
713   if (!gst_structure_get_fraction (s, "framerate", &self->fps_n, &self->fps_d)) {
714     self->fps_n = 0;
715     self->fps_d = 1;
716   }
717   gst_structure_get_boolean (s, "interlaced", &self->interlaced);
718   par_present = gst_structure_get_fraction (s, "pixel-aspect-ratio",
719       &par_width, &par_height);
721   outcaps = gst_pad_get_allowed_caps (self->srcpad);
722   if (outcaps) {
723     outcaps = gst_caps_make_writable (outcaps);
724     gst_caps_truncate (outcaps);
725     if (gst_caps_is_empty (outcaps)) {
726       gst_caps_unref (outcaps);
727       outcaps = NULL;
728     }
729   }
731   if (!outcaps) {
732     /* note: default to non-strided for better compatibility with
733      * other gst elements that don't understand stride:
734      */
735     outcaps = gst_caps_new_simple ("video/x-raw-yuv",
736         "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('N', 'V', '1', '2'), NULL);
737   }
739   out_s = gst_caps_get_structure (outcaps, 0);
740   gst_structure_set (out_s,
741       "width", G_TYPE_INT, self->padded_width,
742       "height", G_TYPE_INT, self->padded_height,
743       "framerate", GST_TYPE_FRACTION, self->fps_n, self->fps_d, NULL);
744   if (par_present)
745     gst_structure_set (out_s, "pixel-aspect-ratio", GST_TYPE_FRACTION,
746         par_width, par_height, NULL);
748   if (self->interlaced)
749     gst_structure_set (out_s, "interlaced", G_TYPE_BOOLEAN, TRUE, NULL);
751   if (!strcmp (gst_structure_get_name (out_s), "video/x-raw-yuv-strided")) {
752     if (!gst_structure_get_int (out_s, "rowstride", &self->stride)) {
753       self->stride = 4096;
754       gst_structure_set (out_s, "rowstride", G_TYPE_INT, self->stride, NULL);
755     }
756   } else {
757     self->stride = gst_video_format_get_row_stride (GST_VIDEO_FORMAT_NV12,
758         0, self->padded_width);
759   }
761   self->outsize = gst_video_format_get_size (GST_VIDEO_FORMAT_NV12,
762       self->stride, self->padded_height);
764   GST_INFO_OBJECT (self, "outsize %d stride %d outcaps: %" GST_PTR_FORMAT,
765       self->outsize, self->stride, outcaps);
767   if (!self->first_in_buffer) {
768     /* Caps changed mid stream. We flush the codec to unlock all the potentially
769      * locked buffers. This is needed for downstream sinks that provide a
770      * buffer pool and need to destroy all the outstanding buffers before they
771      * can negotiate new caps (hello v4l2sink).
772      */
773     gst_ducati_viddec_codec_flush (self, FALSE);
774   }
776   /* (re)send a crop event when caps change */
777   self->send_crop_event = TRUE;
779   ret = gst_pad_set_caps (self->srcpad, outcaps);
781   GST_INFO_OBJECT (self, "set caps done %d, %" GST_PTR_FORMAT, ret, outcaps);
783 out:
784   if (outcaps)
785     gst_caps_unref (outcaps);
786   gst_object_unref (self);
788   return ret;
791 static GstCaps *
792 gst_ducati_viddec_src_getcaps (GstPad * pad)
794   GstCaps *caps = NULL;
795   GstCaps *outcaps = NULL;
796   int i;
798   caps = GST_PAD_CAPS (pad);
799   if (caps == NULL) {
800     outcaps = gst_caps_copy (gst_pad_get_pad_template_caps (pad));
801     return outcaps;
802   }
804   outcaps = gst_caps_new_empty ();
806   /* allow -rowstrided and regular yuv */
807   for (i = 0; i < gst_caps_get_size (caps); i++) {
808     GstStructure *structure;
809     GstStructure *modified_structure;
810     GValue value = { 0 };
812     structure = gst_caps_get_structure (caps, i);
813     gst_caps_append_structure (outcaps, gst_structure_copy (structure));
814     modified_structure = gst_structure_copy (structure);
816     if (gst_structure_has_name (structure, "video/x-raw-yuv")) {
817       gst_structure_set_name (modified_structure, "video/x-raw-yuv-strided");
818       g_value_init (&value, GST_TYPE_INT_RANGE);
819       gst_value_set_int_range (&value, 0, G_MAXINT);
820       gst_structure_set_value (modified_structure, "rowstride", &value);
821       gst_caps_append_structure (outcaps, modified_structure);
822       g_value_unset (&value);
823     } else {
824       gst_structure_set_name (modified_structure, "video/x-raw-yuv");
825       gst_structure_remove_field (modified_structure, "rowstride");
826       gst_caps_append_structure (outcaps, modified_structure);
827     }
828   }
829   return outcaps;
832 static gboolean
833 gst_ducati_viddec_query (GstDucatiVidDec * self, GstPad * pad,
834     GstQuery * query, gboolean * forward)
836   gboolean res = TRUE;
838   switch (GST_QUERY_TYPE (query)) {
839     case GST_QUERY_BUFFERS:
840       GST_DEBUG_OBJECT (self, "min buffers: %d", self->min_buffers);
841       gst_query_set_buffers_count (query, self->min_buffers);
843       GST_DEBUG_OBJECT (self, "min dimensions: %dx%d",
844           self->padded_width, self->padded_height);
845       gst_query_set_buffers_dimensions (query,
846           self->padded_width, self->padded_height);
847       *forward = FALSE;
848       break;
849     default:
850       break;
851   }
854   return res;
857 static gboolean
858 gst_ducati_viddec_src_query (GstPad * pad, GstQuery * query)
860   gboolean res = TRUE, forward = TRUE;
861   GstDucatiVidDec *self = GST_DUCATIVIDDEC (GST_OBJECT_PARENT (pad));
862   GstDucatiVidDecClass *klass = GST_DUCATIVIDDEC_GET_CLASS (self);
864   GST_DEBUG_OBJECT (self, "query: %" GST_PTR_FORMAT, query);
865   res = klass->query (self, pad, query, &forward);
866   if (res && forward)
867     res = gst_pad_query_default (pad, query);
869   return res;
872 static gboolean
873 gst_ducati_viddec_do_qos (GstDucatiVidDec * self, GstBuffer * buf)
875   GstClockTime timestamp, qostime;
876   GstDucatiVidDecClass *klass = GST_DUCATIVIDDEC_GET_CLASS (self);
877   gint64 diff;
879   if (self->wait_keyframe) {
880     if (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT)) {
881       GST_INFO_OBJECT (self, "skipping until the next keyframe");
882       return FALSE;
883     }
885     self->wait_keyframe = FALSE;
886   }
888   timestamp = GST_BUFFER_TIMESTAMP (buf);
889   if (self->segment.format != GST_FORMAT_TIME ||
890       self->qos_earliest_time == GST_CLOCK_TIME_NONE)
891     goto no_qos;
893   if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (timestamp)))
894     goto no_qos;
896   qostime = gst_segment_to_running_time (&self->segment,
897       GST_FORMAT_TIME, timestamp);
898   if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (qostime)))
899     /* out of segment */
900     goto no_qos;
902   /* see how our next timestamp relates to the latest qos timestamp. negative
903    * values mean we are early, positive values mean we are too late. */
904   diff = GST_CLOCK_DIFF (qostime, self->qos_earliest_time);
906   GST_DEBUG_OBJECT (self, "QOS: qostime %" GST_TIME_FORMAT
907       ", earliest %" GST_TIME_FORMAT " diff %" G_GINT64_FORMAT " proportion %f",
908       GST_TIME_ARGS (qostime), GST_TIME_ARGS (self->qos_earliest_time), diff,
909       self->qos_proportion);
911   if (klass->drop_frame (self, buf, diff)) {
912     GST_INFO_OBJECT (self, "dropping frame");
913     return FALSE;
914   }
916 no_qos:
917   return TRUE;
920 static gboolean
921 gst_ducati_viddec_drop_frame (GstDucatiVidDec * self, GstBuffer * buf,
922     gint64 diff)
924   gboolean is_keyframe = !GST_BUFFER_FLAG_IS_SET (buf,
925       GST_BUFFER_FLAG_DELTA_UNIT);
927   if (diff >= 0 && !is_keyframe)
928     return TRUE;
930   return FALSE;
933 static GstFlowReturn
934 gst_ducati_viddec_chain (GstPad * pad, GstBuffer * buf)
936   GstDucatiVidDec *self = GST_DUCATIVIDDEC (GST_OBJECT_PARENT (pad));
937   GstClockTime ts = GST_BUFFER_TIMESTAMP (buf);
938   GstFlowReturn ret = GST_FLOW_OK;
939   Int32 err;
940   GstBuffer *outbuf = NULL;
941   GstCaps *outcaps = NULL;
942   gboolean decode;
944   if (G_UNLIKELY (!self->engine)) {
945     GST_ERROR_OBJECT (self, "no engine");
946     gst_buffer_unref (buf);
947     return GST_FLOW_ERROR;
948   }
950   GST_DEBUG_OBJECT (self, "chain: %" GST_TIME_FORMAT " (%d bytes, flags %d)",
951       GST_TIME_ARGS (ts), GST_BUFFER_SIZE (buf), GST_BUFFER_FLAGS (buf));
953   decode = gst_ducati_viddec_do_qos (self, buf);
954   if (!decode) {
955     gst_buffer_unref (buf);
956     return GST_FLOW_OK;
957   }
959   if (!self->need_out_buf)
960     goto have_out_buf;
962   /* do this before creating codec to ensure reverse caps negotiation
963    * happens first:
964    */
965 allocate_buffer:
966   ret = gst_pad_alloc_buffer (self->srcpad, 0, self->outsize,
967       GST_PAD_CAPS (self->srcpad), &outbuf);
968   if (ret != GST_FLOW_OK) {
969     GST_WARNING_OBJECT (self, "alloc_buffer failed %s",
970         gst_flow_get_name (ret));
971     gst_buffer_unref (buf);
972     return ret;
973   }
975   outcaps = GST_BUFFER_CAPS (outbuf);
976   if (outcaps && !gst_caps_is_equal (outcaps, GST_PAD_CAPS (self->srcpad))) {
977     GstStructure *s;
979     GST_INFO_OBJECT (self, "doing upstream negotiation bufsize %d",
980         GST_BUFFER_SIZE (outbuf));
982     s = gst_caps_get_structure (outcaps, 0);
983     gst_structure_get_int (s, "rowstride", &self->stride);
984     self->outsize = gst_video_format_get_size (GST_VIDEO_FORMAT_NV12,
985         self->stride, self->padded_height);
987     GST_INFO_OBJECT (self, "outsize %d stride %d outcaps: %" GST_PTR_FORMAT,
988         self->outsize, self->stride, outcaps);
990     gst_pad_set_caps (self->srcpad, outcaps);
992     if (GST_BUFFER_SIZE (outbuf) != self->outsize) {
993       GST_INFO_OBJECT (self, "dropping buffer (bufsize %d != outsize %d)",
994           GST_BUFFER_SIZE (outbuf), self->outsize);
995       gst_buffer_unref (outbuf);
996       goto allocate_buffer;
997     }
998   }
1000   if (G_UNLIKELY (!self->codec)) {
1001     if (!codec_create (self)) {
1002       GST_ERROR_OBJECT (self, "could not create codec");
1003       gst_buffer_unref (buf);
1004       gst_buffer_unref (outbuf);
1005       return GST_FLOW_ERROR;
1006     }
1007   }
1009   GST_BUFFER_TIMESTAMP (outbuf) = GST_BUFFER_TIMESTAMP (buf);
1010   GST_BUFFER_DURATION (outbuf) = GST_BUFFER_DURATION (buf);
1012   /* Pass new output buffer to the decoder to decode into. Use buffers from the
1013    * internal pool while self->first_out_buffer == TRUE in order to simplify
1014    * things in case we need to renegotiate */
1015   self->inArgs->inputID =
1016       codec_prepare_outbuf (self, &outbuf, self->first_out_buffer);
1017   if (!self->inArgs->inputID) {
1018     GST_ERROR_OBJECT (self, "could not prepare output buffer");
1019     gst_buffer_unref (buf);
1020     return GST_FLOW_ERROR;
1021   }
1023 have_out_buf:
1024   buf = GST_DUCATIVIDDEC_GET_CLASS (self)->push_input (self, buf);
1026   if (ts != GST_CLOCK_TIME_NONE) {
1027     self->dts_queue[self->dts_widx++ % NDTS] = ts;
1028     /* if next buffer has earlier ts than previous, then the ts
1029      * we are getting are definitely decode order (DTS):
1030      */
1031     if ((self->last_dts != GST_CLOCK_TIME_NONE) && (self->last_dts > ts)) {
1032       GST_DEBUG_OBJECT (self, "input timestamp definitely DTS");
1033       self->ts_may_be_pts = FALSE;
1034     }
1035     self->last_dts = ts;
1036   }
1038   if (self->in_size == 0 && outbuf) {
1039     GST_DEBUG_OBJECT (self, "no input, skipping process");
1040     gst_buffer_unref (outbuf);
1041     return GST_FLOW_OK;
1042   }
1044   self->inArgs->numBytes = self->in_size;
1045   self->inBufs->descs[0].bufSize.bytes = self->in_size;
1046   self->inBufs->descs[0].memType = XDM_MEMTYPE_BO;
1048   err = codec_process (self, TRUE, FALSE, &ret);
1049   if (err) {
1050     GST_ELEMENT_ERROR (self, STREAM, DECODE, (NULL),
1051         ("process returned error: %d %08x", err, self->outArgs->extendedError));
1052     gst_ducati_log_extended_error_info (self->outArgs->extendedError);
1053     return GST_FLOW_ERROR;
1054   }
1055   if (ret != GST_FLOW_OK) {
1056     GST_WARNING_OBJECT (self, "push from codec_process failed %s",
1057         gst_flow_get_name (ret));
1058     return ret;
1059   }
1061   self->first_in_buffer = FALSE;
1063   /* The copy could be avoided by playing with the buffer pointer,
1064      but it seems to be rare and for not many bytes */
1065   GST_DEBUG_OBJECT (self, "Consumed %d/%d (%d) bytes, %d left",
1066       self->outArgs->bytesConsumed, self->in_size,
1067       self->inArgs->numBytes,
1068       self->in_size - self->outArgs->bytesConsumed);
1069   if (self->outArgs->bytesConsumed > 0) {
1070     if (self->outArgs->bytesConsumed > self->in_size) {
1071       GST_WARNING_OBJECT (self, "Codec claims to have used more bytes than supplied");
1072       self->in_size = 0;
1073     } else {
1074       if (self->outArgs->bytesConsumed < self->in_size) {
1075         GST_DEBUG_OBJECT (self, "First 16 were:");
1076         gst_util_dump_mem (self->input, 16);
1077         memmove (self->input, self->input + self->outArgs->bytesConsumed,
1078             self->in_size - self->outArgs->bytesConsumed);
1079       }
1080       self->in_size -= self->outArgs->bytesConsumed;
1081     }
1082   }
1084   if (self->outArgs->outBufsInUseFlag) {
1085     GST_DEBUG_OBJECT (self, "outBufsInUseFlag set");
1086     self->need_out_buf = FALSE;
1087   } else {
1088     self->need_out_buf = TRUE;
1089   }
1091   if (buf) {
1092     GST_DEBUG_OBJECT (self, "found remaining data: %d bytes",
1093         GST_BUFFER_SIZE (buf));
1094     ts = GST_BUFFER_TIMESTAMP (buf);
1095     goto allocate_buffer;
1096   }
1098   if (self->needs_flushing)
1099     gst_ducati_viddec_codec_flush (self, FALSE);
1101   return GST_FLOW_OK;
1104 static gboolean
1105 gst_ducati_viddec_event (GstPad * pad, GstEvent * event)
1107   GstDucatiVidDec *self = GST_DUCATIVIDDEC (GST_OBJECT_PARENT (pad));
1108   gboolean ret = TRUE;
1110   GST_DEBUG_OBJECT (self, "begin: event=%s", GST_EVENT_TYPE_NAME (event));
1112   switch (GST_EVENT_TYPE (event)) {
1113     case GST_EVENT_NEWSEGMENT:
1114     {
1115       gboolean update;
1116       GstFormat fmt;
1117       gint64 start, stop, time;
1118       gdouble rate, arate;
1120       gst_event_parse_new_segment_full (event, &update, &rate, &arate, &fmt,
1121           &start, &stop, &time);
1122       gst_segment_set_newsegment_full (&self->segment, update,
1123           rate, arate, fmt, start, stop, time);
1124       break;
1125     }
1126     case GST_EVENT_EOS:
1127       if (!gst_ducati_viddec_codec_flush (self, TRUE)) {
1128         GST_ERROR_OBJECT (self, "could not flush on eos");
1129         ret = FALSE;
1130       }
1131       break;
1132     case GST_EVENT_FLUSH_STOP:
1133       if (!gst_ducati_viddec_codec_flush (self, FALSE)) {
1134         GST_ERROR_OBJECT (self, "could not flush");
1135         gst_event_unref (event);
1136         ret = FALSE;
1137       }
1138       gst_segment_init (&self->segment, GST_FORMAT_UNDEFINED);
1139       self->qos_earliest_time = GST_CLOCK_TIME_NONE;
1140       self->qos_proportion = 1;
1141       self->need_out_buf = TRUE;
1142       break;
1143     default:
1144       break;
1145   }
1147   if (ret)
1148     ret = gst_pad_push_event (self->srcpad, event);
1149   GST_LOG_OBJECT (self, "end");
1151   return ret;
1154 static gboolean
1155 gst_ducati_viddec_src_event (GstPad * pad, GstEvent * event)
1157   GstDucatiVidDec *self = GST_DUCATIVIDDEC (GST_OBJECT_PARENT (pad));
1158   gboolean ret = TRUE;
1160   GST_LOG_OBJECT (self, "begin: event=%s", GST_EVENT_TYPE_NAME (event));
1162   switch (GST_EVENT_TYPE (event)) {
1163     case GST_EVENT_QOS:
1164     {
1165       gdouble proportion;
1166       GstClockTimeDiff diff;
1167       GstClockTime timestamp;
1169       gst_event_parse_qos (event, &proportion, &diff, &timestamp);
1171       GST_OBJECT_LOCK (self);
1172       self->qos_proportion = proportion;
1173       self->qos_earliest_time = timestamp + 2 * diff;
1174       GST_OBJECT_UNLOCK (self);
1176       GST_DEBUG_OBJECT (self,
1177           "got QoS proportion %f %" GST_TIME_FORMAT ", %" G_GINT64_FORMAT,
1178           proportion, GST_TIME_ARGS (timestamp), diff);
1180       ret = gst_pad_push_event (self->sinkpad, event);
1181       break;
1182     }
1183     default:
1184       ret = gst_pad_push_event (self->sinkpad, event);
1185       break;
1186   }
1188   GST_LOG_OBJECT (self, "end");
1190   return ret;
1193 static GstStateChangeReturn
1194 gst_ducati_viddec_change_state (GstElement * element, GstStateChange transition)
1196   GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
1197   GstDucatiVidDec *self = GST_DUCATIVIDDEC (element);
1198   gboolean supported;
1200   GST_DEBUG_OBJECT (self, "begin: changing state %s -> %s",
1201       gst_element_state_get_name (GST_STATE_TRANSITION_CURRENT (transition)),
1202       gst_element_state_get_name (GST_STATE_TRANSITION_NEXT (transition)));
1204   switch (transition) {
1205     case GST_STATE_CHANGE_NULL_TO_READY:
1206       if (!engine_open (self)) {
1207         GST_ERROR_OBJECT (self, "could not open");
1208         return GST_STATE_CHANGE_FAILURE;
1209       }
1210       /* try to create/destroy the codec here, it may not be supported */
1211       supported = codec_create (self);
1212       codec_delete (self);
1213       self->codec = NULL;
1214       if (!supported) {
1215         GST_ERROR_OBJECT (element, "Failed to create codec %s, not supported",
1216             GST_DUCATIVIDDEC_GET_CLASS (self)->codec_name);
1217         engine_close (self);
1218         return GST_STATE_CHANGE_FAILURE;
1219       }
1220       break;
1221     default:
1222       break;
1223   }
1225   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
1227   if (ret == GST_STATE_CHANGE_FAILURE)
1228     goto leave;
1230   switch (transition) {
1231     case GST_STATE_CHANGE_PAUSED_TO_READY:
1232       self->interlaced = FALSE;
1233       self->send_crop_event = TRUE;
1234       gst_ducati_viddec_codec_flush (self, FALSE);
1235       break;
1236     case GST_STATE_CHANGE_READY_TO_NULL:
1237       codec_delete (self);
1238       engine_close (self);
1239       break;
1240     default:
1241       break;
1242   }
1244 leave:
1245   GST_LOG_OBJECT (self, "end");
1247   return ret;
1250 /* GObject vmethod implementations */
1252 #define VERSION_LENGTH 256
1254 static void
1255 gst_ducati_viddec_get_property (GObject * obj,
1256     guint prop_id, GValue * value, GParamSpec * pspec)
1258   GstDucatiVidDec *self = GST_DUCATIVIDDEC (obj);
1261   switch (prop_id) {
1262     case PROP_VERSION:{
1263       int err;
1264       char *version = NULL;
1266       if (!self->engine)
1267         engine_open (self);
1269       if (!self->codec)
1270         codec_create (self);
1272       if (self->codec) {
1273         version = dce_alloc (VERSION_LENGTH);
1274         self->status->data.buf = (XDAS_Int8 *) version;
1275         self->status->data.bufSize = VERSION_LENGTH;
1277         err = VIDDEC3_control (self->codec, XDM_GETVERSION,
1278             self->dynParams, self->status);
1279         if (err) {
1280           GST_ERROR_OBJECT (self, "failed XDM_GETVERSION");
1281         }
1283         self->status->data.buf = NULL;
1284         self->status->data.bufSize = 0;
1285       }
1287       g_value_set_string (value, version);
1288       if (version)
1289         dce_free (version);
1291       break;
1292     }
1293     default:{
1294       G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
1295       break;
1296     }
1297   }
1300 static void
1301 gst_ducati_viddec_finalize (GObject * obj)
1303   GstDucatiVidDec *self = GST_DUCATIVIDDEC (obj);
1305   codec_delete (self);
1306   engine_close (self);
1308   if (self->codec_data) {
1309     gst_buffer_unref (self->codec_data);
1310     self->codec_data = NULL;
1311   }
1313   G_OBJECT_CLASS (parent_class)->finalize (obj);
1316 static void
1317 gst_ducati_viddec_base_init (gpointer gclass)
1319   GstElementClass *element_class = GST_ELEMENT_CLASS (gclass);
1321   gst_element_class_add_pad_template (element_class,
1322       gst_static_pad_template_get (&src_factory));
1325 static void
1326 gst_ducati_viddec_class_init (GstDucatiVidDecClass * klass)
1328   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
1329   GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
1331   gobject_class->get_property =
1332       GST_DEBUG_FUNCPTR (gst_ducati_viddec_get_property);
1333   gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_ducati_viddec_finalize);
1334   gstelement_class->change_state =
1335       GST_DEBUG_FUNCPTR (gst_ducati_viddec_change_state);
1337   klass->parse_caps = GST_DEBUG_FUNCPTR (gst_ducati_viddec_parse_caps);
1338   klass->allocate_params =
1339       GST_DEBUG_FUNCPTR (gst_ducati_viddec_allocate_params);
1340   klass->push_input = GST_DEBUG_FUNCPTR (gst_ducati_viddec_push_input);
1341   klass->handle_error = GST_DEBUG_FUNCPTR (gst_ducati_viddec_handle_error);
1342   klass->drop_frame = GST_DEBUG_FUNCPTR (gst_ducati_viddec_drop_frame);
1343   klass->query = GST_DEBUG_FUNCPTR (gst_ducati_viddec_query);
1345   g_object_class_install_property (gobject_class, PROP_VERSION,
1346       g_param_spec_string ("version", "Version",
1347           "The codec version string", "",
1348           G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
1351 static void
1352 gst_ducati_viddec_init (GstDucatiVidDec * self, GstDucatiVidDecClass * klass)
1354   GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
1356   self->sinkpad =
1357       gst_pad_new_from_template (gst_element_class_get_pad_template
1358       (gstelement_class, "sink"), "sink");
1359   gst_pad_set_setcaps_function (self->sinkpad,
1360       GST_DEBUG_FUNCPTR (gst_ducati_viddec_sink_setcaps));
1361   gst_pad_set_chain_function (self->sinkpad,
1362       GST_DEBUG_FUNCPTR (gst_ducati_viddec_chain));
1363   gst_pad_set_event_function (self->sinkpad,
1364       GST_DEBUG_FUNCPTR (gst_ducati_viddec_event));
1366   self->srcpad = gst_pad_new_from_static_template (&src_factory, "src");
1367   gst_pad_set_event_function (self->srcpad,
1368       GST_DEBUG_FUNCPTR (gst_ducati_viddec_src_event));
1369   gst_pad_set_query_function (self->srcpad,
1370       GST_DEBUG_FUNCPTR (gst_ducati_viddec_src_query));
1371   gst_pad_set_getcaps_function (self->srcpad,
1372       GST_DEBUG_FUNCPTR (gst_ducati_viddec_src_getcaps));
1374   gst_element_add_pad (GST_ELEMENT (self), self->sinkpad);
1375   gst_element_add_pad (GST_ELEMENT (self), self->srcpad);
1377   self->input_width = 0;
1378   self->input_height = 0;
1379   /* sane defaults in case we need to create codec without caps negotiation
1380    * (for example, to get 'version' property)
1381    */
1382   self->width = 128;
1383   self->height = 128;
1384   self->fps_n = -1;
1385   self->fps_d = -1;
1387   self->first_in_buffer = TRUE;
1388   self->first_out_buffer = TRUE;
1389   self->interlaced = FALSE;
1390   self->send_crop_event = TRUE;
1392   self->dts_ridx = self->dts_widx = 0;
1393   self->last_dts = self->last_pts = GST_CLOCK_TIME_NONE;
1394   self->ts_may_be_pts = TRUE;
1395   self->ts_is_pts = FALSE;
1397   self->pageMemType = XDM_MEMTYPE_TILEDPAGE;
1399   gst_segment_init (&self->segment, GST_FORMAT_UNDEFINED);
1401   self->qos_proportion = 1;
1402   self->qos_earliest_time = GST_CLOCK_TIME_NONE;
1403   self->wait_keyframe = TRUE;
1405   self->need_out_buf = TRUE;
1406   self->device = NULL;
1407   self->input_bo = NULL;