omx/gstomx_base_filter.c

   1 /*
   2  * Copyright (C) 2007-2009 Nokia Corporation.
   3  *
   4  * Author: Felipe Contreras <felipe.contreras@nokia.com>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation
   9  * version 2.1 of the License.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  */
  21
  22 #include "gstomx_base_filter.h"
  23 #include "gstomx.h"
  24 #include "gstomx_interface.h"
  25
  26 #include <string.h>             /* for memcpy */
  27
  28 /* MODIFICATION: for state-tuning */
  29 static void output_loop (gpointer data);
  30
  31 enum
  32 {
  33   ARG_USE_TIMESTAMPS = GSTOMX_NUM_COMMON_PROP,
  34   ARG_NUM_INPUT_BUFFERS,
  35   ARG_NUM_OUTPUT_BUFFERS,
  36 };
  37
  38 static void init_interfaces (GType type);
  39 GSTOMX_BOILERPLATE_FULL (GstOmxBaseFilter, gst_omx_base_filter, GstElement,
  40     GST_TYPE_ELEMENT, init_interfaces);
  41
  42 static inline void
  43 log_buffer (GstOmxBaseFilter * self, OMX_BUFFERHEADERTYPE * omx_buffer, const gchar *name)
  44 {
  45   GST_DEBUG_OBJECT (self, "%s: omx_buffer: "
  46       "size=%lu, "
  47       "len=%lu, "
  48       "flags=%lu, "
  49       "offset=%lu, "
  50       "timestamp=%lld",
  51       name, omx_buffer->nAllocLen, omx_buffer->nFilledLen, omx_buffer->nFlags,
  52       omx_buffer->nOffset, omx_buffer->nTimeStamp);
  53 }
  54
  55 /* Add_code_for_extended_color_format */
  56 static gboolean
  57 is_extended_color_format(GstOmxBaseFilter * self, GOmxPort * port)
  58 {
  59   OMX_PARAM_PORTDEFINITIONTYPE param;
  60   OMX_HANDLETYPE omx_handle = self->gomx->omx_handle;
  61
  62   if (G_UNLIKELY (!omx_handle)) {
  63     GST_WARNING_OBJECT (self, "no component");
  64     return FALSE;
  65   }
  66
  67   G_OMX_INIT_PARAM (param);
  68
  69   param.nPortIndex = port->port_index;
  70   OMX_GetParameter (omx_handle, OMX_IndexParamPortDefinition, &param);
  71
  72   switch ((guint)param.format.video.eColorFormat) {
  73     case OMX_EXT_COLOR_FormatNV12TPhysicalAddress:
  74     case OMX_EXT_COLOR_FormatNV12LPhysicalAddress:
  75     case OMX_EXT_COLOR_FormatNV12Tiled:
  76     case OMX_EXT_COLOR_FormatNV12TFdValue:
  77     case OMX_EXT_COLOR_FormatNV12LFdValue:
  78       return TRUE;
  79     default:
  80       return FALSE;
  81   }
  82 }
  83
  84 static void
  85 setup_ports (GstOmxBaseFilter * self)
  86 {
  87   /* Input port configuration. */
  88   g_omx_port_setup (self->in_port);
  89   gst_pad_set_element_private (self->sinkpad, self->in_port);
  90
  91   /* Output port configuration. */
  92   g_omx_port_setup (self->out_port);
  93   gst_pad_set_element_private (self->srcpad, self->out_port);
  94
  95   /* @todo: read from config file: */
  96   if (g_getenv ("OMX_ALLOCATE_ON")) {
  97     GST_DEBUG_OBJECT (self, "OMX_ALLOCATE_ON");
  98     self->in_port->omx_allocate = TRUE;
  99     self->out_port->omx_allocate = TRUE;
 100     self->in_port->shared_buffer = FALSE;
 101     self->out_port->shared_buffer = FALSE;
 102   } else if (g_getenv ("OMX_SHARE_HACK_ON")) {
 103     GST_DEBUG_OBJECT (self, "OMX_SHARE_HACK_ON");
 104     self->in_port->shared_buffer = TRUE;
 105     self->out_port->shared_buffer = TRUE;
 106   } else if (g_getenv ("OMX_SHARE_HACK_OFF")) {
 107     GST_DEBUG_OBJECT (self, "OMX_SHARE_HACK_OFF");
 108     self->in_port->shared_buffer = FALSE;
 109     self->out_port->shared_buffer = FALSE;
 110   /* MODIFICATION: Add extended_color_format */
 111   } else if (self->gomx->component_vendor == GOMX_VENDOR_SLSI) {
 112     self->in_port->shared_buffer = (is_extended_color_format(self, self->in_port))
 113         ? FALSE : TRUE;
 114     self->out_port->shared_buffer = (is_extended_color_format(self, self->out_port))
 115         ? FALSE : TRUE;
 116   } else if (self->gomx->component_vendor == GOMX_VENDOR_QCT) {
 117     GST_DEBUG_OBJECT (self, "GOMX_VENDOR_QCT");
 118     self->in_port->omx_allocate = TRUE;
 119     self->out_port->omx_allocate = TRUE;
 120     self->in_port->shared_buffer = FALSE;
 121     self->out_port->shared_buffer = FALSE;
 122   } else {
 123     GST_DEBUG_OBJECT (self, "default sharing and allocation");
 124   }
 125
 126   GST_DEBUG_OBJECT (self, "omx_allocate: in: %d, out: %d",
 127       self->in_port->omx_allocate, self->out_port->omx_allocate);
 128   GST_DEBUG_OBJECT (self, "share_buffer: in: %d, out: %d",
 129       self->in_port->shared_buffer, self->out_port->shared_buffer);
 130 }
 131
 132 static GstFlowReturn
 133 omx_change_state(GstOmxBaseFilter * self,GstOmxChangeState transition, GOmxPort *in_port, GstBuffer * buf)
 134 {
 135   GOmxCore *gomx;
 136   GstFlowReturn ret = GST_FLOW_OK;
 137
 138   gomx = self->gomx;
 139
 140   switch (transition) {
 141   case GstOmx_LodedToIdle:
 142     {
 143       g_mutex_lock (self->ready_lock);
 144
 145       GST_INFO_OBJECT (self, "omx: prepare");
 146
 147       /** @todo this should probably go after doing preparations. */
 148       if (self->omx_setup) {
 149         self->omx_setup (self);
 150       }
 151
 152       setup_ports (self);
 153
 154       g_omx_core_prepare (self->gomx);
 155
 156       if (gomx->omx_state == OMX_StateIdle) {
 157         self->ready = TRUE;
 158         gst_pad_start_task (self->srcpad, output_loop, self->srcpad);
 159       }
 160
 161       g_mutex_unlock (self->ready_lock);
 162
 163       if (gomx->omx_state != OMX_StateIdle)
 164         goto out_flushing;
 165     }
 166     break;
 167
 168   case GstOmx_IdleToExcuting:
 169     {
 170       GST_INFO_OBJECT (self, "omx: play");
 171       g_omx_core_start (gomx);
 172
 173       if (gomx->omx_state != OMX_StateExecuting)
 174         goto out_flushing;
 175
 176       /* send buffer with codec data flag */
 177       /** @todo move to util */
 178       if (self->codec_data) {
 179         OMX_BUFFERHEADERTYPE *omx_buffer;
 180
 181         GST_LOG_OBJECT (self, "request buffer");
 182         omx_buffer = g_omx_port_request_buffer (in_port);
 183
 184         if (G_LIKELY (omx_buffer)) {
 185           omx_buffer->nFlags |= OMX_BUFFERFLAG_CODECCONFIG;
 186
 187           omx_buffer->nFilledLen = GST_BUFFER_SIZE (self->codec_data);
 188           memcpy (omx_buffer->pBuffer + omx_buffer->nOffset,
 189           GST_BUFFER_DATA (self->codec_data), omx_buffer->nFilledLen);
 190
 191           GST_LOG_OBJECT (self, "release_buffer");
 192           g_omx_port_release_buffer (in_port, omx_buffer);
 193         }
 194       }
 195     }
 196     break;
 197
 198   default:
 199     break;
 200   }
 201
 202 leave:
 203
 204   GST_LOG_OBJECT (self, "end");
 205   return ret;
 206
 207   /* special conditions */
 208 out_flushing:
 209   {
 210     const gchar *error_msg = NULL;
 211
 212     if (gomx->omx_error) {
 213       error_msg = "Error from OpenMAX component";
 214     } else if (gomx->omx_state != OMX_StateExecuting &&
 215         gomx->omx_state != OMX_StatePause) {
 216       error_msg = "OpenMAX component in wrong state";
 217     }
 218
 219     if (error_msg) {
 220       GST_ELEMENT_ERROR (self, STREAM, FAILED, (NULL), ("%s", error_msg));
 221       ret = GST_FLOW_ERROR;
 222     }
 223
 224     if (buf)
 225       gst_buffer_unref (buf);
 226     goto leave;
 227   }
 228 }
 229
 230 static GstStateChangeReturn
 231 change_state (GstElement * element, GstStateChange transition)
 232 {
 233   GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
 234   GstOmxBaseFilter *self;
 235   GOmxCore *core;
 236
 237   self = GST_OMX_BASE_FILTER (element);
 238   core = self->gomx;
 239
 240   GST_LOG_OBJECT (self, "begin");
 241
 242   GST_INFO_OBJECT (self, "changing state %s - %s",
 243       gst_element_state_get_name (GST_STATE_TRANSITION_CURRENT (transition)),
 244       gst_element_state_get_name (GST_STATE_TRANSITION_NEXT (transition)));
 245
 246   switch (transition) {
 247     case GST_STATE_CHANGE_NULL_TO_READY:
 248       GST_INFO_OBJECT (self, "GST_STATE_CHANGE_NULL_TO_READY");
 249       if (core->omx_state != OMX_StateLoaded) {
 250         ret = GST_STATE_CHANGE_FAILURE;
 251         goto leave;
 252       }
 253
 254       if (self->adapter_size > 0) {
 255         GST_LOG_OBJECT (self, "gst_adapter_new. size: %d", self->adapter_size);
 256         self->adapter = gst_adapter_new();
 257         if (self->adapter == NULL)
 258           GST_ERROR_OBJECT (self, "Failed to create adapter!!");
 259       }
 260       break;
 261
 262     case GST_STATE_CHANGE_READY_TO_PAUSED:
 263       GST_INFO_OBJECT (self, "GST_STATE_CHANGE_READY_TO_PAUSED");
 264       /* MODIFICATION: state tuning */
 265       if (self->use_state_tuning) {
 266         GST_INFO_OBJECT (self, "use state-tuning feature");
 267         /* to handle abnormal state change. */
 268         if (self->gomx != self->in_port->core) {
 269           GST_ERROR_OBJECT(self, "self->gomx != self->in_port->core. start new in_port");
 270           self->in_port = g_omx_core_new_port (self->gomx, 0);
 271         }
 272         if (self->gomx != self->out_port->core) {
 273           GST_ERROR_OBJECT(self, "self->gomx != self->out_port->core. start new out_port");
 274           self->out_port = g_omx_core_new_port (self->gomx, 1);
 275         }
 276
 277         omx_change_state(self, GstOmx_LodedToIdle, NULL, NULL);
 278
 279         if (core->omx_state != OMX_StateIdle) {
 280           GST_ERROR_OBJECT(self, "fail to move from OMX state Loaded to Idle");
 281           g_omx_port_finish(self->in_port);
 282           g_omx_port_finish(self->out_port);
 283           g_omx_core_stop(core);
 284           g_omx_core_unload(core);
 285           ret = GST_STATE_CHANGE_FAILURE;
 286           goto leave;
 287         }
 288       }
 289       break;
 290
 291     default:
 292       break;
 293   }
 294
 295   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 296
 297   if (ret == GST_STATE_CHANGE_FAILURE)
 298     goto leave;
 299
 300   switch (transition) {
 301     case GST_STATE_CHANGE_PAUSED_TO_READY:
 302       GST_INFO_OBJECT (self, "GST_STATE_CHANGE_PAUSED_TO_READY");
 303       g_mutex_lock (self->ready_lock);
 304       if (self->ready) {
 305         g_omx_port_finish (self->in_port);
 306         g_omx_port_finish (self->out_port);
 307
 308         g_omx_core_stop (core);
 309         g_omx_core_unload (core);
 310         self->ready = FALSE;
 311       }
 312       g_mutex_unlock (self->ready_lock);
 313       if (core->omx_state != OMX_StateLoaded &&
 314           core->omx_state != OMX_StateInvalid) {
 315         ret = GST_STATE_CHANGE_FAILURE;
 316         goto leave;
 317       }
 318       break;
 319
 320     case GST_STATE_CHANGE_READY_TO_NULL:
 321       GST_INFO_OBJECT (self, "GST_STATE_CHANGE_READY_TO_NULL");
 322       if (self->adapter) {
 323         gst_adapter_clear(self->adapter);
 324         g_object_unref(self->adapter);
 325         self->adapter = NULL;
 326       }
 327       break;
 328
 329     default:
 330       break;
 331   }
 332
 333 leave:
 334   GST_LOG_OBJECT (self, "end");
 335
 336   return ret;
 337 }
 338
 339 static void
 340 finalize (GObject * obj)
 341 {
 342   GstOmxBaseFilter *self;
 343
 344   self = GST_OMX_BASE_FILTER (obj);
 345
 346   if (self->adapter) {
 347     gst_adapter_clear(self->adapter);
 348     g_object_unref(self->adapter);
 349     self->adapter = NULL;
 350   }
 351
 352   if (self->codec_data) {
 353     gst_buffer_unref (self->codec_data);
 354     self->codec_data = NULL;
 355   }
 356
 357   g_omx_core_free (self->gomx);
 358
 359   g_mutex_free (self->ready_lock);
 360
 361   G_OBJECT_CLASS (parent_class)->finalize (obj);
 362 }
 363
 364 static void
 365 set_property (GObject * obj,
 366     guint prop_id, const GValue * value, GParamSpec * pspec)
 367 {
 368   GstOmxBaseFilter *self;
 369
 370   self = GST_OMX_BASE_FILTER (obj);
 371
 372   switch (prop_id) {
 373     case ARG_USE_TIMESTAMPS:
 374       self->use_timestamps = g_value_get_boolean (value);
 375       break;
 376     case ARG_NUM_INPUT_BUFFERS:
 377     case ARG_NUM_OUTPUT_BUFFERS:
 378     {
 379       OMX_PARAM_PORTDEFINITIONTYPE param;
 380       OMX_HANDLETYPE omx_handle = self->gomx->omx_handle;
 381       OMX_U32 nBufferCountActual;
 382       GOmxPort *port = (prop_id == ARG_NUM_INPUT_BUFFERS) ?
 383           self->in_port : self->out_port;
 384
 385       if (G_UNLIKELY (!omx_handle)) {
 386         GST_WARNING_OBJECT (self, "no component");
 387         break;
 388       }
 389
 390       nBufferCountActual = g_value_get_uint (value);
 391
 392       G_OMX_INIT_PARAM (param);
 393
 394       param.nPortIndex = port->port_index;
 395       OMX_GetParameter (omx_handle, OMX_IndexParamPortDefinition, &param);
 396
 397       if (nBufferCountActual < param.nBufferCountMin) {
 398         GST_ERROR_OBJECT (self, "buffer count %lu is less than minimum %lu",
 399             nBufferCountActual, param.nBufferCountMin);
 400         return;
 401       }
 402
 403       param.nBufferCountActual = nBufferCountActual;
 404
 405       OMX_SetParameter (omx_handle, OMX_IndexParamPortDefinition, &param);
 406     }
 407       break;
 408     default:
 409       G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
 410       break;
 411   }
 412 }
 413
 414 static void
 415 get_property (GObject * obj, guint prop_id, GValue * value, GParamSpec * pspec)
 416 {
 417   GstOmxBaseFilter *self;
 418
 419   self = GST_OMX_BASE_FILTER (obj);
 420
 421   if (gstomx_get_property_helper (self->gomx, prop_id, value))
 422     return;
 423
 424   switch (prop_id) {
 425     case ARG_USE_TIMESTAMPS:
 426       g_value_set_boolean (value, self->use_timestamps);
 427       break;
 428     case ARG_NUM_INPUT_BUFFERS:
 429     case ARG_NUM_OUTPUT_BUFFERS:
 430     {
 431       OMX_PARAM_PORTDEFINITIONTYPE param;
 432       OMX_HANDLETYPE omx_handle = self->gomx->omx_handle;
 433       GOmxPort *port = (prop_id == ARG_NUM_INPUT_BUFFERS) ?
 434           self->in_port : self->out_port;
 435
 436       if (G_UNLIKELY (!omx_handle)) {
 437         GST_WARNING_OBJECT (self, "no component");
 438         g_value_set_uint (value, 0);
 439         break;
 440       }
 441
 442       G_OMX_INIT_PARAM (param);
 443
 444       param.nPortIndex = port->port_index;
 445       OMX_GetParameter (omx_handle, OMX_IndexParamPortDefinition, &param);
 446
 447       g_value_set_uint (value, param.nBufferCountActual);
 448     }
 449       break;
 450     default:
 451       G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
 452       break;
 453   }
 454 }
 455
 456 static void
 457 type_base_init (gpointer g_class)
 458 {
 459 }
 460
 461 static void
 462 type_class_init (gpointer g_class, gpointer class_data)
 463 {
 464   GObjectClass *gobject_class;
 465   GstElementClass *gstelement_class;
 466
 467   gobject_class = G_OBJECT_CLASS (g_class);
 468   gstelement_class = GST_ELEMENT_CLASS (g_class);
 469
 470   gobject_class->finalize = finalize;
 471   gstelement_class->change_state = change_state;
 472
 473   /* Properties stuff */
 474   {
 475     gobject_class->set_property = set_property;
 476     gobject_class->get_property = get_property;
 477
 478     gstomx_install_property_helper (gobject_class);
 479
 480     g_object_class_install_property (gobject_class, ARG_USE_TIMESTAMPS,
 481         g_param_spec_boolean ("use-timestamps", "Use timestamps",
 482             "Whether or not to use timestamps",
 483             TRUE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 484
 485     g_object_class_install_property (gobject_class, ARG_NUM_INPUT_BUFFERS,
 486         g_param_spec_uint ("input-buffers", "Input buffers",
 487             "The number of OMX input buffers",
 488             1, 10, 4, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 489     g_object_class_install_property (gobject_class, ARG_NUM_OUTPUT_BUFFERS,
 490         g_param_spec_uint ("output-buffers", "Output buffers",
 491             "The number of OMX output buffers",
 492             1, 10, 4, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 493
 494   }
 495 }
 496
 497 static inline GstFlowReturn
 498 push_buffer (GstOmxBaseFilter * self, GstBuffer * buf, OMX_BUFFERHEADERTYPE * omx_buffer)
 499 {
 500   GstFlowReturn ret = GST_FLOW_OK;
 501   GstOmxBaseFilterClass *basefilter_class;
 502
 503   basefilter_class = GST_OMX_BASE_FILTER_GET_CLASS (self);
 504   /* process output gst buffer before gst_pad_push */
 505   if (basefilter_class->process_output_buf) {
 506     GstOmxReturn ret = GSTOMX_RETURN_OK;
 507     ret = basefilter_class->process_output_buf(self, &buf, omx_buffer);
 508     if (ret == GSTOMX_RETURN_SKIP) {
 509       gst_buffer_unref (buf);
 510       goto leave;
 511     }
 512   }
 513
 514   GST_LOG_OBJECT (self, "OUT_BUFFER: timestamp = %" GST_TIME_FORMAT " size = %lu",
 515       GST_TIME_ARGS(GST_BUFFER_TIMESTAMP (buf)), GST_BUFFER_SIZE (buf));
 516   ret = gst_pad_push (self->srcpad, buf);
 517   GST_LOG_OBJECT (self, "gst_pad_push end. ret = %d", ret);
 518
 519 leave:
 520   return ret;
 521 }
 522
 523 static void
 524 output_loop (gpointer data)
 525 {
 526   GstPad *pad;
 527   GOmxCore *gomx;
 528   GOmxPort *out_port;
 529   GstOmxBaseFilter *self;
 530   GstFlowReturn ret = GST_FLOW_OK;
 531
 532   pad = data;
 533   self = GST_OMX_BASE_FILTER (gst_pad_get_parent (pad));
 534   gomx = self->gomx;
 535
 536   GST_LOG_OBJECT (self, "begin");
 537
 538   /* do not bother if we have been setup to bail out */
 539   if ((ret = g_atomic_int_get (&self->last_pad_push_return)) != GST_FLOW_OK)
 540     goto leave;
 541
 542   if (!self->ready) {
 543     g_error ("not ready");
 544     return;
 545   }
 546
 547   out_port = self->out_port;
 548
 549   if (G_LIKELY (out_port->enabled)) {
 550     OMX_BUFFERHEADERTYPE *omx_buffer = NULL;
 551
 552     GST_LOG_OBJECT (self, "request buffer");
 553     omx_buffer = g_omx_port_request_buffer (out_port);
 554
 555     GST_LOG_OBJECT (self, "omx_buffer: %p", omx_buffer);
 556
 557     if (G_UNLIKELY (!omx_buffer)) {
 558       GST_WARNING_OBJECT (self, "null buffer: leaving");
 559       ret = GST_FLOW_WRONG_STATE;
 560       goto leave;
 561     }
 562
 563     log_buffer (self, omx_buffer, "output_loop");
 564
 565     if (G_LIKELY (omx_buffer->nFilledLen > 0)) {
 566       GstBuffer *buf;
 567
 568 #if 1
 569             /** @todo remove this check */
 570       if (G_LIKELY (self->in_port->enabled)) {
 571         GstCaps *caps = NULL;
 572
 573         caps = gst_pad_get_negotiated_caps (self->srcpad);
 574
 575         if (!caps) {
 576                     /** @todo We shouldn't be doing this. */
 577           GST_WARNING_OBJECT (self, "faking settings changed notification");
 578           if (gomx->settings_changed_cb)
 579             gomx->settings_changed_cb (gomx);
 580         } else {
 581           GST_LOG_OBJECT (self, "caps already fixed: %" GST_PTR_FORMAT, caps);
 582           gst_caps_unref (caps);
 583         }
 584       }
 585 #endif
 586
 587       /* buf is always null when the output buffer pointer isn't shared. */
 588       buf = omx_buffer->pAppPrivate;
 589
 590             /** @todo we need to move all the caps handling to one single
 591              * place, in the output loop probably. */
 592       if (G_UNLIKELY (omx_buffer->nFlags & OMX_BUFFERFLAG_CODECCONFIG)) {
 593         /* modification: to handle both byte-stream and packetized codec_data */
 594         GstOmxBaseFilterClass *basefilter_class;
 595
 596         basefilter_class = GST_OMX_BASE_FILTER_GET_CLASS (self);
 597         if (basefilter_class->process_output_caps) {
 598           basefilter_class->process_output_caps(self, omx_buffer);
 599         }
 600         /* MODIFICATION: to handle output ST12 HW addr (dec) */
 601       } else if (is_extended_color_format(self, self->out_port)) {
 602         GstCaps *caps = NULL;
 603         GstStructure *structure;
 604         gint width = 0, height = 0;
 605         SCMN_IMGB *outbuf = NULL;
 606
 607         if (G_UNLIKELY (omx_buffer->nFlags & OMX_BUFFERFLAG_DECODEONLY)) {
 608           GST_INFO_OBJECT (self, "Decodeonly flag was set from component");
 609           g_omx_port_release_buffer (out_port, omx_buffer);
 610           goto leave;
 611         }
 612
 613         caps = gst_pad_get_negotiated_caps(self->srcpad);
 614         structure = gst_caps_get_structure(caps, 0);
 615
 616         gst_structure_get_int(structure, "width", &width);
 617         gst_structure_get_int(structure, "height", &height);
 618
 619         if (G_LIKELY((width > 0) && (height > 0))) {
 620           buf = gst_buffer_new_and_alloc(width * height * 3 / 2);
 621         } else {
 622           GST_ERROR_OBJECT (self, "invalid buffer size");
 623           ret = GST_FLOW_UNEXPECTED;
 624           goto leave;
 625         }
 626
 627         outbuf = (SCMN_IMGB*)(omx_buffer->pBuffer);
 628         if (outbuf->buf_share_method == 1) {
 629           GST_LOG_OBJECT (self, "dec output buf: fd[0]:%d  fd[1]:%d fd[2]:%d  w[0]:%d h[0]:%d  buf_share_method:%d",
 630               outbuf->fd[0], outbuf->fd[1], outbuf->fd[2], outbuf->w[0], outbuf->h[0], outbuf->buf_share_method);
 631         } else if (outbuf->buf_share_method == 0) {
 632           GST_LOG_OBJECT (self, "dec output uses hw addr");
 633         } else {
 634           GST_WARNING_OBJECT (self, "dec output buf has wrong buf_share_method");
 635         }
 636         memcpy (GST_BUFFER_MALLOCDATA(buf), omx_buffer->pBuffer, omx_buffer->nFilledLen);
 637
 638         if (self->use_timestamps) {
 639           GST_BUFFER_TIMESTAMP (buf) =
 640               gst_util_uint64_scale_int (omx_buffer->nTimeStamp, GST_SECOND,
 641               OMX_TICKS_PER_SECOND);
 642         }
 643         gst_buffer_set_caps(buf, GST_PAD_CAPS(self->srcpad));
 644         gst_caps_unref (caps);
 645
 646         ret = push_buffer (self, buf, omx_buffer);
 647       } else if (buf && !(omx_buffer->nFlags & OMX_BUFFERFLAG_EOS)) {
 648         GST_BUFFER_SIZE (buf) = omx_buffer->nFilledLen;
 649         if (self->use_timestamps) {
 650           GST_BUFFER_TIMESTAMP (buf) =
 651               gst_util_uint64_scale_int (omx_buffer->nTimeStamp, GST_SECOND,
 652               OMX_TICKS_PER_SECOND);
 653         }
 654
 655         omx_buffer->pAppPrivate = NULL;
 656         omx_buffer->pBuffer = NULL;
 657
 658         ret = push_buffer (self, buf, omx_buffer);
 659
 660       } else {
 661         /* This is only meant for the first OpenMAX buffers,
 662          * which need to be pre-allocated. */
 663         /* Also for the very last one. */
 664         ret = gst_pad_alloc_buffer_and_set_caps (self->srcpad,
 665             GST_BUFFER_OFFSET_NONE,
 666             omx_buffer->nFilledLen, GST_PAD_CAPS (self->srcpad), &buf);
 667
 668         if (G_LIKELY (buf)) {
 669           memcpy (GST_BUFFER_DATA (buf),
 670               omx_buffer->pBuffer + omx_buffer->nOffset,
 671               omx_buffer->nFilledLen);
 672           if (self->use_timestamps) {
 673             GST_BUFFER_TIMESTAMP (buf) =
 674                 gst_util_uint64_scale_int (omx_buffer->nTimeStamp, GST_SECOND,
 675                 OMX_TICKS_PER_SECOND);
 676           }
 677
 678           if (self->out_port->shared_buffer) {
 679             GST_WARNING_OBJECT (self, "couldn't zero-copy");
 680             /* If pAppPrivate is NULL, it means it was a dummy
 681              * allocation, free it. */
 682             if (!omx_buffer->pAppPrivate) {
 683               g_free (omx_buffer->pBuffer);
 684               omx_buffer->pBuffer = NULL;
 685             }
 686           }
 687
 688           ret = push_buffer (self, buf, omx_buffer);
 689         } else {
 690           GST_WARNING_OBJECT (self, "couldn't allocate buffer of size %lu",
 691               omx_buffer->nFilledLen);
 692         }
 693       }
 694     } else {
 695       GST_WARNING_OBJECT (self, "empty buffer");
 696     }
 697
 698     if (self->out_port->shared_buffer &&
 699         !omx_buffer->pBuffer && omx_buffer->nOffset == 0) {
 700       GstBuffer *buf;
 701       GstFlowReturn result;
 702
 703       GST_LOG_OBJECT (self, "allocate buffer");
 704       result = gst_pad_alloc_buffer_and_set_caps (self->srcpad,
 705           GST_BUFFER_OFFSET_NONE,
 706           omx_buffer->nAllocLen, GST_PAD_CAPS (self->srcpad), &buf);
 707
 708       if (G_LIKELY (result == GST_FLOW_OK)) {
 709         omx_buffer->pAppPrivate = buf;
 710
 711         omx_buffer->pBuffer = GST_BUFFER_DATA (buf);
 712         omx_buffer->nAllocLen = GST_BUFFER_SIZE (buf);
 713       } else {
 714         GST_WARNING_OBJECT (self,
 715             "could not pad allocate buffer, using malloc");
 716         omx_buffer->pBuffer = g_malloc (omx_buffer->nAllocLen);
 717       }
 718     }
 719
 720     if (self->out_port->shared_buffer && !omx_buffer->pBuffer) {
 721       GST_ERROR_OBJECT (self, "no input buffer to share");
 722     }
 723
 724     if (G_UNLIKELY (omx_buffer->nFlags & OMX_BUFFERFLAG_EOS)) {
 725       GST_DEBUG_OBJECT (self, "got eos");
 726       gst_pad_push_event (self->srcpad, gst_event_new_eos ());
 727       omx_buffer->nFlags &= ~OMX_BUFFERFLAG_EOS;
 728       ret = GST_FLOW_UNEXPECTED;
 729     }
 730
 731     omx_buffer->nFilledLen = 0;
 732     GST_LOG_OBJECT (self, "release_buffer");
 733     g_omx_port_release_buffer (out_port, omx_buffer);
 734   }
 735
 736 leave:
 737
 738   self->last_pad_push_return = ret;
 739
 740   if (gomx->omx_error != OMX_ErrorNone)
 741     ret = GST_FLOW_ERROR;
 742
 743   if (ret != GST_FLOW_OK) {
 744     GST_INFO_OBJECT (self, "pause task, reason:  %s", gst_flow_get_name (ret));
 745     gst_pad_pause_task (self->srcpad);
 746   }
 747
 748   GST_LOG_OBJECT (self, "end");
 749
 750   gst_object_unref (self);
 751 }
 752
 753 static GstFlowReturn
 754 pad_chain (GstPad * pad, GstBuffer * buf)
 755 {
 756   GOmxCore *gomx;
 757   GOmxPort *in_port;
 758   GstOmxBaseFilter *self;
 759   GstOmxBaseFilterClass *basefilter_class;
 760   GstFlowReturn ret = GST_FLOW_OK;
 761   GstBuffer *adapter_buf = NULL;
 762
 763   self = GST_OMX_BASE_FILTER (GST_OBJECT_PARENT (pad));
 764
 765   gomx = self->gomx;
 766
 767   GST_LOG_OBJECT (self, "IN_BUFFER: timestamp = %" GST_TIME_FORMAT " size = %lu, state:%d",
 768       GST_TIME_ARGS(GST_BUFFER_TIMESTAMP (buf)), GST_BUFFER_SIZE (buf), gomx->omx_state);
 769
 770   /* STATE_TUNING */
 771   if (!self->use_state_tuning) {
 772     if (G_UNLIKELY (gomx->omx_state == OMX_StateLoaded))
 773       omx_change_state(self, GstOmx_LodedToIdle, NULL, NULL);
 774   }
 775
 776   in_port = self->in_port;
 777
 778   if (G_LIKELY (in_port->enabled)) {
 779     guint buffer_offset = 0;
 780     guint8 *src_data = NULL;
 781     guint src_size = 0;
 782     GstClockTime src_timestamp = 0;
 783     GstClockTime src_duration = 0;
 784
 785     if (G_UNLIKELY (gomx->omx_state == OMX_StateIdle))
 786       omx_change_state(self, GstOmx_IdleToExcuting,in_port, buf);
 787
 788     if (G_UNLIKELY (gomx->omx_state != OMX_StateExecuting)) {
 789       GST_ERROR_OBJECT (self, "Whoa! very wrong");
 790     }
 791
 792     basefilter_class = GST_OMX_BASE_FILTER_GET_CLASS (self);
 793     /* process input gst buffer before OMX_EmptyThisBuffer */
 794     if (basefilter_class->process_input_buf)
 795     {
 796       GstOmxReturn ret = GSTOMX_RETURN_OK;
 797       ret = basefilter_class->process_input_buf(self,&buf);
 798       if (ret == GSTOMX_RETURN_SKIP) {
 799         gst_buffer_unref(buf);
 800         goto leave;
 801       }
 802     }
 803
 804     if (self->adapter_size > 0) {
 805       if (!self->adapter) {
 806         GST_WARNING_OBJECT (self, "adapter is NULL. retry gst_adapter_new");
 807         self->adapter = gst_adapter_new();
 808       }
 809
 810       if (GST_BUFFER_IS_DISCONT(buf))
 811       {
 812         GST_INFO_OBJECT (self, "got GST_BUFFER_IS_DISCONT.");
 813         gst_adapter_clear(self->adapter);
 814       }
 815
 816       gst_adapter_push(self->adapter, buf);
 817
 818       src_size = gst_adapter_available(self->adapter);
 819       if (src_size < self->adapter_size) {
 820         GST_LOG_OBJECT (self, "Not enough data in adapter to feed to decoder.");
 821         goto leave;
 822       }
 823
 824       if (src_size > self->adapter_size) {
 825         src_size = src_size - GST_BUFFER_SIZE(buf);
 826         GST_LOG_OBJECT (self, "take buffer from adapter. size=%d", src_size);
 827       }
 828
 829       src_timestamp = gst_adapter_prev_timestamp(self->adapter, NULL);
 830       adapter_buf = gst_adapter_take_buffer(self->adapter, src_size);
 831       src_data = GST_BUFFER_DATA(adapter_buf);
 832       src_duration = GST_BUFFER_TIMESTAMP (buf) - src_timestamp;
 833     } else {
 834       src_data = GST_BUFFER_DATA (buf);
 835       src_size = GST_BUFFER_SIZE (buf);
 836       src_timestamp = GST_BUFFER_TIMESTAMP (buf);
 837       src_duration = GST_BUFFER_DURATION (buf);
 838     }
 839
 840     while (G_LIKELY (buffer_offset < src_size)) {
 841       OMX_BUFFERHEADERTYPE *omx_buffer;
 842
 843       if (self->last_pad_push_return != GST_FLOW_OK ||
 844           !(gomx->omx_state == OMX_StateExecuting ||
 845               gomx->omx_state == OMX_StatePause)) {
 846         goto out_flushing;
 847       }
 848
 849       GST_LOG_OBJECT (self, "request buffer");
 850       omx_buffer = g_omx_port_request_buffer (in_port);
 851
 852       GST_LOG_OBJECT (self, "omx_buffer: %p", omx_buffer);
 853
 854       if (G_LIKELY (omx_buffer)) {
 855         log_buffer (self, omx_buffer, "pad_chain");
 856
 857         /* MODIFICATION: to handle input SN12 HW addr. (enc) */
 858         if (is_extended_color_format(self, self->in_port)) {
 859           SCMN_IMGB *inbuf = NULL;
 860
 861           if (!GST_BUFFER_MALLOCDATA(buf)) {
 862               GST_WARNING_OBJECT (self, "null MALLOCDATA in hw color format. skip this.");
 863               goto out_flushing;
 864           }
 865
 866           inbuf = (SCMN_IMGB*)(GST_BUFFER_MALLOCDATA(buf));
 867           if (inbuf != NULL && inbuf->buf_share_method == 1) {
 868             GST_LOG_OBJECT (self, "enc. fd[0]:%d  fd[1]:%d  fd[2]:%d  w[0]:%d  h[0]:%d   buf_share_method:%d",
 869                 inbuf->fd[0], inbuf->fd[1], inbuf->fd[2], inbuf->w[0], inbuf->h[0], inbuf->buf_share_method);
 870           } else if (inbuf != NULL && inbuf->buf_share_method == 0) {
 871             GST_LOG_OBJECT (self, "enc input buf uses hw addr");
 872           } else {
 873             GST_WARNING_OBJECT (self, "enc input buf has wrong buf_share_method");
 874           }
 875
 876           memcpy (omx_buffer->pBuffer, GST_BUFFER_MALLOCDATA(buf), sizeof(SCMN_IMGB));
 877           omx_buffer->nAllocLen = sizeof(SCMN_IMGB);
 878           omx_buffer->nFilledLen = sizeof(SCMN_IMGB);
 879         } else if (omx_buffer->nOffset == 0 && self->in_port->shared_buffer) {
 880           {
 881             GstBuffer *old_buf;
 882             old_buf = omx_buffer->pAppPrivate;
 883
 884             if (old_buf) {
 885               gst_buffer_unref ((GstBuffer *)old_buf);
 886             } else if (omx_buffer->pBuffer) {
 887               g_free (omx_buffer->pBuffer);
 888               omx_buffer->pBuffer = NULL;
 889             }
 890           }
 891
 892           omx_buffer->pBuffer = src_data;
 893           omx_buffer->nAllocLen = src_size;
 894           omx_buffer->nFilledLen = src_size;
 895           omx_buffer->pAppPrivate = (self->adapter_size > 0) ? (OMX_PTR)adapter_buf : (OMX_PTR)buf;
 896         } else {
 897           omx_buffer->nFilledLen = MIN (src_size - buffer_offset,
 898               omx_buffer->nAllocLen - omx_buffer->nOffset);
 899           memcpy (omx_buffer->pBuffer + omx_buffer->nOffset,
 900               src_data + buffer_offset, omx_buffer->nFilledLen);
 901         }
 902
 903         if (self->use_timestamps) {
 904           GstClockTime timestamp_offset = 0;
 905
 906           if (buffer_offset && src_duration != GST_CLOCK_TIME_NONE) {
 907             timestamp_offset = gst_util_uint64_scale_int (buffer_offset,
 908                 src_duration, src_size);
 909           }
 910
 911           omx_buffer->nTimeStamp =
 912               gst_util_uint64_scale_int (src_timestamp +
 913               timestamp_offset, OMX_TICKS_PER_SECOND, GST_SECOND);
 914         }
 915
 916         /* MODIFICATION: hw addr */
 917         if (is_extended_color_format(self, self->in_port)) {
 918           buffer_offset = GST_BUFFER_SIZE (buf);
 919         } else {
 920           buffer_offset += omx_buffer->nFilledLen;
 921         }
 922
 923         GST_LOG_OBJECT (self, "release_buffer");
 924                 /** @todo untaint buffer */
 925         g_omx_port_release_buffer (in_port, omx_buffer);
 926       } else {
 927         GST_WARNING_OBJECT (self, "null buffer");
 928         ret = GST_FLOW_WRONG_STATE;
 929         goto out_flushing;
 930       }
 931     }
 932   } else {
 933     GST_WARNING_OBJECT (self, "done");
 934     ret = GST_FLOW_UNEXPECTED;
 935   }
 936
 937   if (!self->in_port->shared_buffer) {
 938     if (self->adapter_size > 0 && adapter_buf) {
 939       gst_buffer_unref (adapter_buf);
 940       adapter_buf = NULL;
 941     } else {
 942       gst_buffer_unref (buf);
 943     }
 944   }
 945
 946 leave:
 947
 948   GST_LOG_OBJECT (self, "end");
 949
 950   return ret;
 951
 952   /* special conditions */
 953 out_flushing:
 954   {
 955     const gchar *error_msg = NULL;
 956
 957     GST_LOG_OBJECT(self, "out_flushing");
 958
 959     if (gomx->omx_error) {
 960       error_msg = "Error from OpenMAX component";
 961     } else if (gomx->omx_state != OMX_StateExecuting &&
 962         gomx->omx_state != OMX_StatePause) {
 963       error_msg = "OpenMAX component in wrong state";
 964     }
 965
 966     if (error_msg) {
 967       GST_ELEMENT_ERROR (self, STREAM, FAILED, (NULL), ("%s", error_msg));
 968       ret = GST_FLOW_ERROR;
 969     }
 970
 971     if (self->adapter_size > 0 && adapter_buf) {
 972       gst_buffer_unref (adapter_buf);
 973       adapter_buf = NULL;
 974     } else {
 975       gst_buffer_unref (buf);
 976     }
 977
 978     goto leave;
 979   }
 980 }
 981
 982 static gboolean
 983 pad_event (GstPad * pad, GstEvent * event)
 984 {
 985   GstOmxBaseFilter *self;
 986   GOmxCore *gomx;
 987   GOmxPort *in_port;
 988   gboolean ret = TRUE;
 989
 990   self = GST_OMX_BASE_FILTER (GST_OBJECT_PARENT (pad));
 991   gomx = self->gomx;
 992   in_port = self->in_port;
 993
 994   GST_LOG_OBJECT (self, "begin");
 995
 996   GST_INFO_OBJECT (self, "event: %s", GST_EVENT_TYPE_NAME (event));
 997
 998   if (self->pad_event) {
 999     if (!self->pad_event(pad, event))
1000       return TRUE;
1001   }
1002
1003   switch (GST_EVENT_TYPE (event)) {
1004     case GST_EVENT_EOS:
1005       /* if we are init'ed, and there is a running loop; then
1006        * if we get a buffer to inform it of EOS, let it handle the rest
1007        * in any other case, we send EOS */
1008       if (self->ready && self->last_pad_push_return == GST_FLOW_OK) {
1009         /* send buffer with eos flag */
1010                 /** @todo move to util */
1011         {
1012           OMX_BUFFERHEADERTYPE *omx_buffer;
1013
1014           GST_LOG_OBJECT (self, "request buffer");
1015           omx_buffer = g_omx_port_request_buffer (in_port);
1016
1017           if (G_LIKELY (omx_buffer)) {
1018
1019             if (self->adapter_size > 0 && self->adapter) {
1020               guint src_len = 0;
1021               GstBuffer *adapter_buf = NULL;
1022
1023               src_len = gst_adapter_available(self->adapter);
1024               if (src_len > 0 && src_len < self->adapter_size) {
1025                 omx_buffer->nTimeStamp = gst_util_uint64_scale_int(
1026                    gst_adapter_prev_timestamp(self->adapter, NULL),
1027                    OMX_TICKS_PER_SECOND, GST_SECOND);
1028                 adapter_buf = gst_adapter_take_buffer(self->adapter, src_len);
1029                 omx_buffer->pBuffer = GST_BUFFER_DATA(adapter_buf);
1030                 omx_buffer->nAllocLen = src_len;
1031                 omx_buffer->nFilledLen = src_len;
1032                 omx_buffer->pAppPrivate = adapter_buf;
1033               }
1034               gst_adapter_clear(self->adapter);
1035             }
1036             omx_buffer->nFlags |= OMX_BUFFERFLAG_EOS;
1037
1038             GST_LOG_OBJECT (self, "release_buffer in EOS. size=%d", omx_buffer->nFilledLen);
1039             /* foo_buffer_untaint (omx_buffer); */
1040             g_omx_port_release_buffer (in_port, omx_buffer);
1041             /* loop handles EOS, eat it here */
1042             gst_event_unref (event);
1043             break;
1044           }
1045         }
1046       }
1047
1048       /* we tried, but it's up to us here */
1049       ret = gst_pad_push_event (self->srcpad, event);
1050       break;
1051
1052     case GST_EVENT_FLUSH_START:
1053       if (gomx->omx_state == OMX_StatePause || gomx->omx_state == OMX_StateExecuting) {
1054         gst_pad_push_event (self->srcpad, event);
1055         self->last_pad_push_return = GST_FLOW_WRONG_STATE;
1056
1057         g_omx_core_flush_start (gomx);
1058
1059         gst_pad_pause_task (self->srcpad);
1060
1061         ret = TRUE;
1062       } else {
1063         GST_ERROR_OBJECT (self, "flush start in wrong omx state");
1064         ret = FALSE;
1065       }
1066       break;
1067
1068     case GST_EVENT_FLUSH_STOP:
1069       if (gomx->omx_state == OMX_StatePause || gomx->omx_state == OMX_StateExecuting) {
1070         gst_pad_push_event (self->srcpad, event);
1071         self->last_pad_push_return = GST_FLOW_OK;
1072
1073         g_omx_core_flush_stop (gomx);
1074
1075         if (self->adapter_size > 0 && self->adapter) {
1076           gst_adapter_clear(self->adapter);
1077         }
1078
1079         if (self->ready)
1080           gst_pad_start_task (self->srcpad, output_loop, self->srcpad);
1081
1082         ret = TRUE;
1083       } else {
1084         GST_ERROR_OBJECT (self, "flush start in wrong omx state");
1085         ret = FALSE;
1086       }
1087       break;
1088
1089     case GST_EVENT_NEWSEGMENT:
1090       ret = gst_pad_push_event (self->srcpad, event);
1091       break;
1092
1093     default:
1094       ret = gst_pad_push_event (self->srcpad, event);
1095       break;
1096   }
1097
1098   GST_LOG_OBJECT (self, "end");
1099
1100   return ret;
1101 }
1102
1103 static gboolean
1104 activate_push (GstPad * pad, gboolean active)
1105 {
1106   gboolean result = TRUE;
1107   GstOmxBaseFilter *self;
1108
1109   self = GST_OMX_BASE_FILTER (gst_pad_get_parent (pad));
1110
1111   if (active) {
1112     GST_DEBUG_OBJECT (self, "activate");
1113     /* task may carry on */
1114     g_atomic_int_set (&self->last_pad_push_return, GST_FLOW_OK);
1115
1116     /* we do not start the task yet if the pad is not connected */
1117     if (gst_pad_is_linked (pad)) {
1118       if (self->ready) {
1119                 /** @todo link callback function also needed */
1120         g_omx_port_resume (self->in_port);
1121         g_omx_port_resume (self->out_port);
1122
1123         result = gst_pad_start_task (pad, output_loop, pad);
1124       }
1125     }
1126   } else {
1127     GST_DEBUG_OBJECT (self, "deactivate");
1128
1129     /* persuade task to bail out */
1130     g_atomic_int_set (&self->last_pad_push_return, GST_FLOW_WRONG_STATE);
1131
1132     if (self->ready) {
1133             /** @todo disable this until we properly reinitialize the buffers. */
1134 #if 0
1135       /* flush all buffers */
1136       OMX_SendCommand (self->gomx->omx_handle, OMX_CommandFlush, OMX_ALL, NULL);
1137 #endif
1138
1139       /* unlock loops */
1140       g_omx_port_pause (self->in_port);
1141       g_omx_port_pause (self->out_port);
1142     }
1143
1144     /* make sure streaming finishes */
1145     result = gst_pad_stop_task (pad);
1146   }
1147
1148   gst_object_unref (self);
1149
1150   return result;
1151 }
1152
1153 static void
1154 type_instance_init (GTypeInstance * instance, gpointer g_class)
1155 {
1156   GstOmxBaseFilter *self;
1157   GstElementClass *element_class;
1158
1159   element_class = GST_ELEMENT_CLASS (g_class);
1160
1161   self = GST_OMX_BASE_FILTER (instance);
1162
1163   GST_LOG_OBJECT (self, "begin");
1164
1165   self->use_timestamps = TRUE;
1166   self->use_state_tuning = FALSE;
1167   self->adapter_size = 0;
1168   self->adapter = NULL;
1169
1170   self->gomx = gstomx_core_new (self, G_TYPE_FROM_CLASS (g_class));
1171   self->in_port = g_omx_core_new_port (self->gomx, 0);
1172   self->out_port = g_omx_core_new_port (self->gomx, 1);
1173
1174   self->ready_lock = g_mutex_new ();
1175
1176   self->sinkpad =
1177       gst_pad_new_from_template (gst_element_class_get_pad_template
1178       (element_class, "sink"), "sink");
1179
1180   gst_pad_set_chain_function (self->sinkpad, pad_chain);
1181   gst_pad_set_event_function (self->sinkpad, pad_event);
1182
1183   self->srcpad =
1184       gst_pad_new_from_template (gst_element_class_get_pad_template
1185       (element_class, "src"), "src");
1186
1187   gst_pad_set_activatepush_function (self->srcpad, activate_push);
1188
1189   gst_pad_use_fixed_caps (self->srcpad);
1190
1191   gst_element_add_pad (GST_ELEMENT (self), self->sinkpad);
1192   gst_element_add_pad (GST_ELEMENT (self), self->srcpad);
1193
1194   GST_LOG_OBJECT (self, "end");
1195 }
1196
1197 static void
1198 omx_interface_init (GstImplementsInterfaceClass * klass)
1199 {
1200 }
1201
1202 static gboolean
1203 interface_supported (GstImplementsInterface * iface, GType type)
1204 {
1205   g_assert (type == GST_TYPE_OMX);
1206   return TRUE;
1207 }
1208
1209 static void
1210 interface_init (GstImplementsInterfaceClass * klass)
1211 {
1212   klass->supported = interface_supported;
1213 }
1214
1215 static void
1216 init_interfaces (GType type)
1217 {
1218   GInterfaceInfo *iface_info;
1219   GInterfaceInfo *omx_info;
1220
1221
1222   iface_info = g_new0 (GInterfaceInfo, 1);
1223   iface_info->interface_init = (GInterfaceInitFunc) interface_init;
1224
1225   g_type_add_interface_static (type, GST_TYPE_IMPLEMENTS_INTERFACE, iface_info);
1226   g_free (iface_info);
1227
1228   omx_info = g_new0 (GInterfaceInfo, 1);
1229   omx_info->interface_init = (GInterfaceInitFunc) omx_interface_init;
1230
1231   g_type_add_interface_static (type, GST_TYPE_OMX, omx_info);
1232   g_free (omx_info);
1233 }