From 2343decb3c7b80f087c66117baacff861487b3e8 Mon Sep 17 00:00:00 2001 From: =?utf8?q?Sebastian=20Dr=C3=B6ge?= Date: Wed, 20 Jul 2011 08:34:33 +0200 Subject: [PATCH] omxvideoenc: Add video encoder base class and MPEG4 video encoder Unfortunately requires lots of hacks again to work properly with Bellagio. --- omx/Makefile.am | 4 + omx/gstomx.c | 8 +- omx/gstomx.conf | 8 + omx/gstomx.h | 11 +- omx/gstomxmpeg4videoenc.c | 125 +++++++ omx/gstomxmpeg4videoenc.h | 60 +++ omx/gstomxvideoenc.c | 914 ++++++++++++++++++++++++++++++++++++++++++++++ omx/gstomxvideoenc.h | 85 +++++ 8 files changed, 1213 insertions(+), 2 deletions(-) create mode 100644 omx/gstomxmpeg4videoenc.c create mode 100644 omx/gstomxmpeg4videoenc.h create mode 100644 omx/gstomxvideoenc.c create mode 100644 omx/gstomxvideoenc.h diff --git a/omx/Makefile.am b/omx/Makefile.am index 5e8ca6d..ecf81c9 100644 --- a/omx/Makefile.am +++ b/omx/Makefile.am @@ -3,8 +3,10 @@ plugin_LTLIBRARIES = libgstomx.la libgstomx_la_SOURCES = \ gstomx.c \ gstomxvideodec.c \ + gstomxvideoenc.c \ gstomxmpeg4videodec.c \ gstomxh264dec.c \ + gstomxmpeg4videoenc.c \ gstbasevideocodec.c \ gstbasevideodecoder.c \ gstbasevideoencoder.c \ @@ -13,8 +15,10 @@ libgstomx_la_SOURCES = \ noinst_HEADERS = \ gstomx.h \ gstomxvideodec.h \ + gstomxvideoenc.h \ gstomxmpeg4videodec.h \ gstomxh264dec.h \ + gstomxmpeg4videoenc.h \ gstbasevideocodec.h \ gstbasevideodecoder.h \ gstbasevideoencoder.h \ diff --git a/omx/gstomx.c b/omx/gstomx.c index 27c55e7..a82e90c 100644 --- a/omx/gstomx.c +++ b/omx/gstomx.c @@ -28,6 +28,7 @@ #include "gstomx.h" #include "gstomxmpeg4videodec.h" #include "gstomxh264dec.h" +#include "gstomxmpeg4videoenc.h" GST_DEBUG_CATEGORY (gstomx_debug); #define GST_CAT_DEFAULT gstomx_debug @@ -1625,7 +1626,8 @@ done: GQuark gst_omx_element_name_quark = 0; static GType (*types[]) (void) = { -gst_omx_mpeg4_video_dec_get_type, gst_omx_h264_dec_get_type}; +gst_omx_mpeg4_video_dec_get_type, gst_omx_h264_dec_get_type, + gst_omx_mpeg4_video_enc_get_type}; static GKeyFile *config = NULL; GKeyFile * @@ -1742,6 +1744,10 @@ gst_omx_parse_hacks (gchar ** hacks) GST_OMX_HACK_EVENT_PORT_SETTINGS_CHANGED_NDATA_PARAMETER_SWAP; else if (g_str_equal (*hacks, "event-port-settings-changed-port-0-to-1")) hacks_flags |= GST_OMX_HACK_EVENT_PORT_SETTINGS_CHANGED_PORT_0_TO_1; + else if (g_str_equal (*hacks, "video-framerate-integer")) + hacks_flags |= GST_OMX_HACK_VIDEO_FRAMERATE_INTEGER; + else if (g_str_equal (*hacks, "syncframe-flag-not-used")) + hacks_flags |= GST_OMX_HACK_SYNCFRAME_FLAG_NOT_USED; else GST_WARNING ("Unknown hack: %s", *hacks); hacks++; diff --git a/omx/gstomx.conf b/omx/gstomx.conf index e5c22e3..944fe17 100644 --- a/omx/gstomx.conf +++ b/omx/gstomx.conf @@ -16,3 +16,11 @@ in-port-index=0 out-port-index=1 hacks=event-port-settings-changed-ndata-parameter-swap;event-port-settings-changed-port-0-to-1 +[omxmpeg4videoenc] +type-name=GstOMXMPEG4VideoEnc +core-name=/usr/local/lib/libomxil-bellagio.so.0 +component-name=OMX.st.video_encoder.mpeg4 +rank=0 +in-port-index=0 +out-port-index=1 +hacks=event-port-settings-changed-ndata-parameter-swap;video-framerate-integer;syncframe-flag-not-used diff --git a/omx/gstomx.h b/omx/gstomx.h index 943c92e..aef7745 100644 --- a/omx/gstomx.h +++ b/omx/gstomx.h @@ -37,7 +37,16 @@ G_BEGIN_DECLS /* In the EventSettingsChanged callback assume that port index 0 really * means port index 1. Happens with the Bellagio ffmpegdist video decoder. */ -#define GST_OMX_HACK_EVENT_PORT_SETTINGS_CHANGED_PORT_0_TO_1 G_GUINT64_CONSTANT (0x0000000000000002) +#define GST_OMX_HACK_EVENT_PORT_SETTINGS_CHANGED_PORT_0_TO_1 G_GUINT64_CONSTANT (0x0000000000000002) +/* If the video framerate is not specified as fraction (Q.16) but as + * integer number. Happens with the Bellagio ffmpegdist video encoder. + */ +#define GST_OMX_HACK_VIDEO_FRAMERATE_INTEGER G_GUINT64_CONSTANT (0x0000000000000004) +/* If the SYNCFRAME flag on encoder output buffers is not used and we + * have to assume that all frames are sync frames. + * Happens with the Bellagio ffmpegdist video encoder. + */ +#define GST_OMX_HACK_SYNCFRAME_FLAG_NOT_USED G_GUINT64_CONSTANT (0x0000000000000008) typedef struct _GstOMXCore GstOMXCore; typedef struct _GstOMXPort GstOMXPort; diff --git a/omx/gstomxmpeg4videoenc.c b/omx/gstomxmpeg4videoenc.c new file mode 100644 index 0000000..70829a1 --- /dev/null +++ b/omx/gstomxmpeg4videoenc.c @@ -0,0 +1,125 @@ +/* + * Copyright (C) 2011, Hewlett-Packard Development Company, L.P. + * Author: Sebastian Dröge , Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include + +#include "gstomxmpeg4videoenc.h" + +GST_DEBUG_CATEGORY_STATIC (gst_omx_mpeg4_video_enc_debug_category); +#define GST_CAT_DEFAULT gst_omx_mpeg4_video_enc_debug_category + +/* prototypes */ +static void gst_omx_mpeg4_video_enc_finalize (GObject * object); +static gboolean gst_omx_mpeg4_video_enc_set_format (GstOMXVideoEnc * enc, + GstOMXPort * port, GstVideoState * state); +static GstCaps *gst_omx_mpeg4_video_enc_get_caps (GstOMXVideoEnc * enc, + GstOMXPort * port, GstVideoState * state); + +enum +{ + PROP_0 +}; + +/* class initialization */ + +#define DEBUG_INIT(bla) \ + GST_DEBUG_CATEGORY_INIT (gst_omx_mpeg4_video_enc_debug_category, "omxmpeg4videoenc", 0, \ + "debug category for gst-omx video encoder base class"); + +GST_BOILERPLATE_FULL (GstOMXMPEG4VideoEnc, gst_omx_mpeg4_video_enc, + GstOMXVideoEnc, GST_TYPE_OMX_VIDEO_ENC, DEBUG_INIT); + +static void +gst_omx_mpeg4_video_enc_base_init (gpointer g_class) +{ + GstElementClass *element_class = GST_ELEMENT_CLASS (g_class); + + gst_element_class_set_details_simple (element_class, + "OpenMAX MPEG4 Video Encoder", + "Codec/Encoder/Video", + "Encode MPEG4 video streams", + "Sebastian Dröge "); +} + +static void +gst_omx_mpeg4_video_enc_class_init (GstOMXMPEG4VideoEncClass * klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + GstOMXVideoEncClass *videoenc_class = GST_OMX_VIDEO_ENC_CLASS (klass); + + gobject_class->finalize = gst_omx_mpeg4_video_enc_finalize; + + videoenc_class->set_format = + GST_DEBUG_FUNCPTR (gst_omx_mpeg4_video_enc_set_format); + videoenc_class->get_caps = + GST_DEBUG_FUNCPTR (gst_omx_mpeg4_video_enc_get_caps); + + videoenc_class->default_src_template_caps = "video/mpeg, " + "mpegversion=(int) 4, " + "systemstream=(boolean) false, " + "width=(int) [ 16, 4096 ], " "height=(int) [ 16, 4096 ]"; + videoenc_class->default_sink_template_caps = GST_VIDEO_CAPS_YUV ("I420"); +} + +static void +gst_omx_mpeg4_video_enc_init (GstOMXMPEG4VideoEnc * self, + GstOMXMPEG4VideoEncClass * klass) +{ +} + +static void +gst_omx_mpeg4_video_enc_finalize (GObject * object) +{ + /* GstOMXMPEG4VideoEnc *self = GST_OMX_MPEG4_VIDEO_ENC (object); */ + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static gboolean +gst_omx_mpeg4_video_enc_set_format (GstOMXVideoEnc * enc, GstOMXPort * port, + GstVideoState * state) +{ + return TRUE; +} + +static GstCaps * +gst_omx_mpeg4_video_enc_get_caps (GstOMXVideoEnc * enc, GstOMXPort * port, + GstVideoState * state) +{ + GstCaps *caps; + + caps = + gst_caps_new_simple ("video/mpeg", "mpegversion", G_TYPE_INT, 4, + "systemstream", G_TYPE_BOOLEAN, FALSE, "width", G_TYPE_INT, state->width, + "height", G_TYPE_INT, state->height, NULL); + + if (state->fps_n != 0) + gst_caps_set_simple (caps, "framerate", GST_TYPE_FRACTION, state->fps_n, + state->fps_d, NULL); + if (state->par_n != 1 || state->par_d != 1) + gst_caps_set_simple (caps, "pixel-aspect-ratio", GST_TYPE_FRACTION, + state->par_n, state->par_d, NULL); + + return caps; +} diff --git a/omx/gstomxmpeg4videoenc.h b/omx/gstomxmpeg4videoenc.h new file mode 100644 index 0000000..01d6698 --- /dev/null +++ b/omx/gstomxmpeg4videoenc.h @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2011, Hewlett-Packard Development Company, L.P. + * Author: Sebastian Dröge , Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifndef __GST_OMX_MPEG4_VIDEO_ENC_H__ +#define __GST_OMX_MPEG4_VIDEO_ENC_H__ + +#include +#include "gstomxvideoenc.h" + +G_BEGIN_DECLS + +#define GST_TYPE_OMX_MPEG4_VIDEO_ENC \ + (gst_omx_mpeg4_video_enc_get_type()) +#define GST_OMX_MPEG4_VIDEO_ENC(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_OMX_MPEG4_VIDEO_ENC,GstOMXMPEG4VideoEnc)) +#define GST_OMX_MPEG4_VIDEO_ENC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_OMX_MPEG4_VIDEO_ENC,GstOMXMPEG4VideoEncClass)) +#define GST_OMX_MPEG4_VIDEO_ENC_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj),GST_TYPE_OMX_MPEG4_VIDEO_ENC,GstOMXMPEG4VideoEncClass)) +#define GST_IS_OMX_MPEG4_VIDEO_ENC(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_OMX_MPEG4_VIDEO_ENC)) +#define GST_IS_OMX_MPEG4_VIDEO_ENC_CLASS(obj) \ + (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_OMX_MPEG4_VIDEO_ENC)) + +typedef struct _GstOMXMPEG4VideoEnc GstOMXMPEG4VideoEnc; +typedef struct _GstOMXMPEG4VideoEncClass GstOMXMPEG4VideoEncClass; + +struct _GstOMXMPEG4VideoEnc +{ + GstOMXVideoEnc parent; +}; + +struct _GstOMXMPEG4VideoEncClass +{ + GstOMXVideoEncClass parent_class; +}; + +GType gst_omx_mpeg4_video_enc_get_type (void); + +G_END_DECLS + +#endif /* __GST_OMX_MPEG4_VIDEO_ENC_H__ */ + diff --git a/omx/gstomxvideoenc.c b/omx/gstomxvideoenc.c new file mode 100644 index 0000000..7e01365 --- /dev/null +++ b/omx/gstomxvideoenc.c @@ -0,0 +1,914 @@ +/* + * Copyright (C) 2011, Hewlett-Packard Development Company, L.P. + * Author: Sebastian Dröge , Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include + +#include "gstomxvideoenc.h" + +GST_DEBUG_CATEGORY_STATIC (gst_omx_video_enc_debug_category); +#define GST_CAT_DEFAULT gst_omx_video_enc_debug_category + +typedef struct _BufferIdentification BufferIdentification; +struct _BufferIdentification +{ + guint64 timestamp; +}; + +static void +buffer_identification_free (BufferIdentification * id) +{ + g_slice_free (BufferIdentification, id); +} + +/* prototypes */ +static void gst_omx_video_enc_finalize (GObject * object); + +static GstStateChangeReturn +gst_omx_video_enc_change_state (GstElement * element, + GstStateChange transition); + +static gboolean gst_omx_video_enc_start (GstBaseVideoEncoder * encoder); +static gboolean gst_omx_video_enc_stop (GstBaseVideoEncoder * encoder); +static gboolean gst_omx_video_enc_set_format (GstBaseVideoEncoder * encoder, + GstVideoState * state); +static gboolean gst_omx_video_enc_reset (GstBaseVideoEncoder * encoder); +static GstFlowReturn gst_omx_video_enc_handle_frame (GstBaseVideoEncoder * + encoder, GstVideoFrame * frame); +static gboolean gst_omx_video_enc_finish (GstBaseVideoEncoder * encoder); + +enum +{ + PROP_0 +}; + +/* class initialization */ + +#define DEBUG_INIT(bla) \ + GST_DEBUG_CATEGORY_INIT (gst_omx_video_enc_debug_category, "omxvideoenc", 0, \ + "debug category for gst-omx video encoder base class"); + +GST_BOILERPLATE_FULL (GstOMXVideoEnc, gst_omx_video_enc, GstBaseVideoEncoder, + GST_TYPE_BASE_VIDEO_ENCODER, DEBUG_INIT); + +static void +gst_omx_video_enc_base_init (gpointer g_class) +{ + GstElementClass *element_class = GST_ELEMENT_CLASS (g_class); + GstOMXVideoEncClass *videoenc_class = GST_OMX_VIDEO_ENC_CLASS (g_class); + GKeyFile *config; + const gchar *element_name; + GError *err; + gchar *core_name, *component_name, *component_role; + gint in_port_index, out_port_index; + gchar *template_caps; + GstPadTemplate *templ; + GstCaps *caps; + gchar **hacks; + + element_name = + g_type_get_qdata (G_TYPE_FROM_CLASS (g_class), + gst_omx_element_name_quark); + /* This happens for the base class and abstract subclasses */ + if (!element_name) + return; + + config = gst_omx_get_configuration (); + + /* This will always succeed, see check in plugin_init */ + core_name = g_key_file_get_string (config, element_name, "core-name", NULL); + g_assert (core_name != NULL); + videoenc_class->core_name = core_name; + component_name = + g_key_file_get_string (config, element_name, "component-name", NULL); + g_assert (component_name != NULL); + videoenc_class->component_name = component_name; + + /* If this fails we simply don't set a role */ + if ((component_role = + g_key_file_get_string (config, element_name, "component-role", + NULL))) { + GST_DEBUG ("Using component-role '%s' for element '%s'", component_role, + element_name); + videoenc_class->component_role = component_role; + } + + + /* Now set the inport/outport indizes and assume sane defaults */ + err = NULL; + in_port_index = + g_key_file_get_integer (config, element_name, "in-port-index", &err); + if (err != NULL) { + GST_DEBUG ("No 'in-port-index' set for element '%s', assuming 0: %s", + element_name, err->message); + in_port_index = 0; + g_error_free (err); + } + videoenc_class->in_port_index = in_port_index; + + err = NULL; + out_port_index = + g_key_file_get_integer (config, element_name, "out-port-index", &err); + if (err != NULL) { + GST_DEBUG ("No 'out-port-index' set for element '%s', assuming 1: %s", + element_name, err->message); + out_port_index = 1; + g_error_free (err); + } + videoenc_class->out_port_index = out_port_index; + + /* Add pad templates */ + err = NULL; + if (!(template_caps = + g_key_file_get_string (config, element_name, "sink-template-caps", + &err))) { + GST_DEBUG + ("No sink template caps specified for element '%s', using default '%s'", + element_name, videoenc_class->default_sink_template_caps); + caps = gst_caps_from_string (videoenc_class->default_sink_template_caps); + g_assert (caps != NULL); + g_error_free (err); + } else { + caps = gst_caps_from_string (template_caps); + if (!caps) { + GST_DEBUG + ("Could not parse sink template caps '%s' for element '%s', using default '%s'", + template_caps, element_name, + videoenc_class->default_sink_template_caps); + caps = gst_caps_from_string (videoenc_class->default_sink_template_caps); + g_assert (caps != NULL); + } + } + templ = gst_pad_template_new ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, caps); + g_free (template_caps); + gst_element_class_add_pad_template (element_class, templ); + gst_object_unref (templ); + + err = NULL; + if (!(template_caps = + g_key_file_get_string (config, element_name, "src-template-caps", + &err))) { + GST_DEBUG + ("No src template caps specified for element '%s', using default '%s'", + element_name, videoenc_class->default_src_template_caps); + caps = gst_caps_from_string (videoenc_class->default_src_template_caps); + g_assert (caps != NULL); + g_error_free (err); + } else { + caps = gst_caps_from_string (template_caps); + if (!caps) { + GST_DEBUG + ("Could not parse src template caps '%s' for element '%s', using default '%s'", + template_caps, element_name, + videoenc_class->default_src_template_caps); + caps = gst_caps_from_string (videoenc_class->default_src_template_caps); + g_assert (caps != NULL); + } + } + templ = gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS, caps); + g_free (template_caps); + gst_element_class_add_pad_template (element_class, templ); + gst_object_unref (templ); + + if ((hacks = + g_key_file_get_string_list (config, element_name, "hacks", NULL, + NULL))) { +#ifndef GST_DISABLE_GST_DEBUG + gchar **walk = hacks; + + while (*walk) { + GST_DEBUG ("Using hack: %s", *walk); + walk++; + } +#endif + + videoenc_class->hacks = gst_omx_parse_hacks (hacks); + } +} + +static void +gst_omx_video_enc_class_init (GstOMXVideoEncClass * klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + GstElementClass *element_class = GST_ELEMENT_CLASS (klass); + GstBaseVideoEncoderClass *base_video_encoder_class = + GST_BASE_VIDEO_ENCODER_CLASS (klass); + + gobject_class->finalize = gst_omx_video_enc_finalize; + + element_class->change_state = + GST_DEBUG_FUNCPTR (gst_omx_video_enc_change_state); + + base_video_encoder_class->start = GST_DEBUG_FUNCPTR (gst_omx_video_enc_start); + base_video_encoder_class->stop = GST_DEBUG_FUNCPTR (gst_omx_video_enc_stop); + base_video_encoder_class->reset = GST_DEBUG_FUNCPTR (gst_omx_video_enc_reset); + base_video_encoder_class->set_format = + GST_DEBUG_FUNCPTR (gst_omx_video_enc_set_format); + base_video_encoder_class->handle_frame = + GST_DEBUG_FUNCPTR (gst_omx_video_enc_handle_frame); + base_video_encoder_class->finish = + GST_DEBUG_FUNCPTR (gst_omx_video_enc_finish); +} + +static void +gst_omx_video_enc_init (GstOMXVideoEnc * self, GstOMXVideoEncClass * klass) +{ +} + +static gboolean +gst_omx_video_enc_open (GstOMXVideoEnc * self) +{ + GstOMXVideoEncClass *klass = GST_OMX_VIDEO_ENC_GET_CLASS (self); + + self->component = + gst_omx_component_new (GST_OBJECT_CAST (self), klass->core_name, + klass->component_name, klass->component_role, klass->hacks); + self->started = FALSE; + + if (!self->component) + return FALSE; + + if (gst_omx_component_get_state (self->component, + GST_CLOCK_TIME_NONE) != OMX_StateLoaded) + return FALSE; + + self->in_port = + gst_omx_component_add_port (self->component, klass->in_port_index); + self->out_port = + gst_omx_component_add_port (self->component, klass->out_port_index); + + if (!self->in_port || !self->out_port) + return FALSE; + + return TRUE; +} + +static gboolean +gst_omx_video_enc_close (GstOMXVideoEnc * self) +{ + if (gst_omx_component_get_state (self->component, 0) > OMX_StateLoaded) { + gst_omx_component_set_state (self->component, OMX_StateLoaded); + gst_omx_port_deallocate_buffers (self->in_port); + gst_omx_port_deallocate_buffers (self->out_port); + gst_omx_component_get_state (self->component, 5 * GST_SECOND); + } + + self->in_port = NULL; + self->out_port = NULL; + if (self->component) + gst_omx_component_free (self->component); + self->component = NULL; + + return TRUE; +} + +static void +gst_omx_video_enc_finalize (GObject * object) +{ + /* GstOMXVideoEnc *self = GST_OMX_VIDEO_ENC (object); */ + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static GstStateChangeReturn +gst_omx_video_enc_change_state (GstElement * element, GstStateChange transition) +{ + GstOMXVideoEnc *self; + GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS; + + g_return_val_if_fail (GST_IS_OMX_VIDEO_ENC (element), + GST_STATE_CHANGE_FAILURE); + self = GST_OMX_VIDEO_ENC (element); + + switch (transition) { + case GST_STATE_CHANGE_NULL_TO_READY: + if (!gst_omx_video_enc_open (self)) + ret = GST_STATE_CHANGE_FAILURE; + break; + case GST_STATE_CHANGE_READY_TO_PAUSED: + gst_omx_port_set_flushing (self->out_port, FALSE); + gst_omx_port_set_flushing (self->in_port, FALSE); + break; + case GST_STATE_CHANGE_PAUSED_TO_PLAYING: + break; + case GST_STATE_CHANGE_PAUSED_TO_READY: + gst_omx_port_set_flushing (self->out_port, TRUE); + gst_omx_port_set_flushing (self->in_port, TRUE); + break; + default: + break; + } + + if (ret == GST_STATE_CHANGE_FAILURE) + return ret; + + ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); + + if (ret == GST_STATE_CHANGE_FAILURE) + return ret; + + switch (transition) { + case GST_STATE_CHANGE_PLAYING_TO_PAUSED: + break; + case GST_STATE_CHANGE_PAUSED_TO_READY: + break; + case GST_STATE_CHANGE_READY_TO_NULL: + if (!gst_omx_video_enc_close (self)) + ret = GST_STATE_CHANGE_FAILURE; + break; + default: + break; + } + + return ret; +} + +#define MAX_FRAME_DIST_TICKS (5 * OMX_TICKS_PER_SECOND) +#define MAX_FRAME_DIST_FRAMES (100) + +static GstVideoFrame * +_find_nearest_frame (GstOMXVideoEnc * self, GstOMXBuffer * buf) +{ + GList *l, *best_l = NULL; + GList *finish_frames = NULL; + GstVideoFrame *best = NULL; + guint64 best_timestamp = 0; + guint64 best_diff = G_MAXUINT64; + BufferIdentification *best_id = NULL; + + GST_OBJECT_LOCK (self); + for (l = GST_BASE_VIDEO_CODEC (self)->frames; l; l = l->next) { + GstVideoFrame *tmp = l->data; + BufferIdentification *id = tmp->coder_hook; + guint64 timestamp, diff; + + /* This happens for frames that were just added but + * which were not passed to the component yet. Ignore + * them here! + */ + if (!id) + continue; + + timestamp = id->timestamp; + + if (timestamp > buf->omx_buf->nTimeStamp) + diff = timestamp - buf->omx_buf->nTimeStamp; + else + diff = buf->omx_buf->nTimeStamp - timestamp; + + if (best == NULL || diff < best_diff) { + best = tmp; + best_timestamp = timestamp; + best_diff = diff; + best_l = l; + best_id = id; + + /* For frames without timestamp we simply take the first frame */ + if ((buf->omx_buf->nTimeStamp == 0 && timestamp == 0) || diff == 0) + break; + } + } + + if (best_id) { + for (l = GST_BASE_VIDEO_CODEC (self)->frames; l && l != best_l; l = l->next) { + GstVideoFrame *tmp = l->data; + BufferIdentification *id = tmp->coder_hook; + guint64 diff_ticks, diff_frames; + + if (id->timestamp > best_timestamp) + break; + + if (id->timestamp == 0 || best_timestamp == 0) + diff_ticks = 0; + else + diff_ticks = best_timestamp - id->timestamp; + diff_frames = best->system_frame_number - tmp->system_frame_number; + + if (diff_ticks > MAX_FRAME_DIST_TICKS + || diff_frames > MAX_FRAME_DIST_FRAMES) { + finish_frames = g_list_prepend (finish_frames, tmp); + } + } + } + + GST_OBJECT_UNLOCK (self); + + if (finish_frames) { + g_warning ("Too old frames, bug in encoder -- please file a bug"); + for (l = finish_frames; l; l = l->next) { + gst_base_video_encoder_finish_frame (GST_BASE_VIDEO_ENCODER (self), + l->data); + } + } + + return best; +} + +static void +gst_omx_video_enc_loop (GstOMXVideoEnc * self) +{ + GstOMXVideoEncClass *klass; + GstOMXPort *port = self->out_port; + GstOMXBuffer *buf = NULL; + GstVideoFrame *frame; + GstFlowReturn flow_ret = GST_FLOW_OK; + GstOMXAcquireBufferReturn acq_return; + + klass = GST_OMX_VIDEO_ENC_GET_CLASS (self); + + acq_return = gst_omx_port_acquire_buffer (port, &buf); + if (acq_return == GST_OMX_ACQUIRE_BUFFER_ERROR) { + goto component_error; + } else if (acq_return == GST_OMX_ACQUIRE_BUFFER_FLUSHING) { + goto flushing; + } else if (acq_return == GST_OMX_ACQUIRE_BUFFER_RECONFIGURE) { + if (gst_omx_port_reconfigure (self->out_port) != OMX_ErrorNone) + goto reconfigure_error; + /* And restart the loop */ + return; + } + + if (!GST_PAD_CAPS (GST_BASE_VIDEO_CODEC_SRC_PAD (self)) + || acq_return == GST_OMX_ACQUIRE_BUFFER_RECONFIGURED) { + GstVideoState *state = &GST_BASE_VIDEO_CODEC (self)->state; + GstCaps *caps; + + GST_DEBUG_OBJECT (self, "Port settings have changed, updating caps"); + + caps = klass->get_caps (self, self->out_port, state); + if (!caps) { + if (buf) + gst_omx_port_release_buffer (self->out_port, buf); + goto caps_failed; + } + + if (!gst_pad_set_caps (GST_BASE_VIDEO_CODEC_SRC_PAD (self), caps)) { + gst_caps_unref (caps); + if (buf) + gst_omx_port_release_buffer (self->out_port, buf); + goto caps_failed; + } + gst_caps_unref (caps); + + /* Now get a buffer */ + if (acq_return != GST_OMX_ACQUIRE_BUFFER_OK) + return; + } + + g_assert (acq_return == GST_OMX_ACQUIRE_BUFFER_OK && buf != NULL); + + GST_DEBUG_OBJECT (self, "Handling buffer: 0x%08x %lu", buf->omx_buf->nFlags, + buf->omx_buf->nTimeStamp); + + frame = _find_nearest_frame (self, buf); + if (buf->omx_buf->nFilledLen > 0) { + GstBuffer *outbuf; + + outbuf = gst_buffer_new_and_alloc (buf->omx_buf->nFilledLen); + gst_buffer_set_caps (outbuf, + GST_PAD_CAPS (GST_BASE_VIDEO_CODEC_SRC_PAD (self))); + + memcpy (GST_BUFFER_DATA (outbuf), + buf->omx_buf->pBuffer + buf->omx_buf->nOffset, + buf->omx_buf->nFilledLen); + GST_BUFFER_TIMESTAMP (outbuf) = + gst_util_uint64_scale (buf->omx_buf->nTimeStamp, GST_SECOND, + OMX_TICKS_PER_SECOND); + if (buf->omx_buf->nTickCount != 0) + GST_BUFFER_DURATION (outbuf) = + gst_util_uint64_scale (buf->omx_buf->nTickCount, GST_SECOND, + OMX_TICKS_PER_SECOND); + + if ((klass->hacks & GST_OMX_HACK_SYNCFRAME_FLAG_NOT_USED) + || (buf->omx_buf->nFlags & OMX_BUFFERFLAG_SYNCFRAME)) { + if (frame) + frame->is_sync_point = TRUE; + else + GST_BUFFER_FLAG_UNSET (outbuf, GST_BUFFER_FLAG_DELTA_UNIT); + } else { + if (frame) + frame->is_sync_point = FALSE; + else + GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DELTA_UNIT); + } + /* TODO: OMX_BUFFERFLAG_SYNCFRAME -> not delta frame */ + + if (frame) { + frame->src_buffer = outbuf; + flow_ret = + gst_base_video_encoder_finish_frame (GST_BASE_VIDEO_ENCODER (self), + frame); + } else { + GST_ERROR_OBJECT (self, "No corresponding frame found"); + flow_ret = gst_pad_push (GST_BASE_VIDEO_CODEC_SRC_PAD (self), outbuf); + } + } else if (frame != NULL) { + /*flow_ret = + gst_base_video_encoder_finish_frame (GST_BASE_VIDEO_ENCODER (self), + frame); */ + } + + if (flow_ret == GST_FLOW_OK && (buf->omx_buf->nFlags & OMX_BUFFERFLAG_EOS)) + flow_ret = GST_FLOW_UNEXPECTED; + + gst_omx_port_release_buffer (port, buf); + + if (flow_ret != GST_FLOW_OK) + goto flow_error; + + return; + +component_error: + { + GST_ELEMENT_ERROR (self, LIBRARY, FAILED, (NULL), + ("OpenMAX component in error state %s (0x%08x)", + gst_omx_component_get_last_error_string (self->component), + gst_omx_component_get_last_error (self->component))); + gst_pad_push_event (GST_BASE_VIDEO_CODEC_SRC_PAD (self), + gst_event_new_eos ()); + gst_pad_pause_task (GST_BASE_VIDEO_CODEC_SRC_PAD (self)); + return; + } +flushing: + { + GST_DEBUG_OBJECT (self, "Flushing -- stopping task"); + gst_pad_pause_task (GST_BASE_VIDEO_CODEC_SRC_PAD (self)); + return; + } +flow_error: + { + if (flow_ret == GST_FLOW_UNEXPECTED) { + GST_DEBUG_OBJECT (self, "EOS"); + + gst_pad_push_event (GST_BASE_VIDEO_CODEC_SRC_PAD (self), + gst_event_new_eos ()); + gst_pad_pause_task (GST_BASE_VIDEO_CODEC_SRC_PAD (self)); + } else if (flow_ret == GST_FLOW_NOT_LINKED + || flow_ret < GST_FLOW_UNEXPECTED) { + GST_ELEMENT_ERROR (self, STREAM, FAILED, ("Internal data stream error."), + ("stream stopped, reason %s", gst_flow_get_name (flow_ret))); + + gst_pad_push_event (GST_BASE_VIDEO_CODEC_SRC_PAD (self), + gst_event_new_eos ()); + gst_pad_pause_task (GST_BASE_VIDEO_CODEC_SRC_PAD (self)); + } + return; + } +reconfigure_error: + { + GST_ELEMENT_ERROR (self, LIBRARY, SETTINGS, (NULL), + ("Unable to reconfigure output port")); + gst_pad_push_event (GST_BASE_VIDEO_CODEC_SRC_PAD (self), + gst_event_new_eos ()); + gst_pad_pause_task (GST_BASE_VIDEO_CODEC_SRC_PAD (self)); + return; + } +caps_failed: + { + GST_ELEMENT_ERROR (self, LIBRARY, SETTINGS, (NULL), ("Failed to set caps")); + gst_pad_push_event (GST_BASE_VIDEO_CODEC_SRC_PAD (self), + gst_event_new_eos ()); + gst_pad_pause_task (GST_BASE_VIDEO_CODEC_SRC_PAD (self)); + return; + } +} + +static gboolean +gst_omx_video_enc_start (GstBaseVideoEncoder * encoder) +{ + GstOMXVideoEnc *self; + gboolean ret; + + self = GST_OMX_VIDEO_ENC (encoder); + + ret = + gst_pad_start_task (GST_BASE_VIDEO_CODEC_SRC_PAD (self), + (GstTaskFunction) gst_omx_video_enc_loop, self); + + return ret; +} + +static gboolean +gst_omx_video_enc_stop (GstBaseVideoEncoder * encoder) +{ + GstOMXVideoEnc *self; + + self = GST_OMX_VIDEO_ENC (encoder); + + gst_pad_stop_task (GST_BASE_VIDEO_CODEC_SRC_PAD (encoder)); + + if (gst_omx_component_get_state (self->component, 0) > OMX_StateIdle) + gst_omx_component_set_state (self->component, OMX_StateIdle); + + gst_omx_port_set_flushing (self->in_port, TRUE); + gst_omx_port_set_flushing (self->out_port, TRUE); + + gst_omx_component_get_state (self->component, 5 * GST_SECOND); + + return TRUE; +} + +static gboolean +gst_omx_video_enc_set_format (GstBaseVideoEncoder * encoder, + GstVideoState * state) +{ + GstOMXVideoEnc *self; + GstOMXVideoEncClass *klass; + gboolean needs_disable = FALSE; + OMX_PARAM_PORTDEFINITIONTYPE port_def; + + self = GST_OMX_VIDEO_ENC (encoder); + klass = GST_OMX_VIDEO_ENC_GET_CLASS (encoder); + + GST_DEBUG_OBJECT (self, "Setting new caps %" GST_PTR_FORMAT, state->caps); + + gst_omx_port_get_port_definition (self->in_port, &port_def); + + needs_disable = + gst_omx_component_get_state (self->component, + GST_CLOCK_TIME_NONE) != OMX_StateLoaded; + /* If the component is not in Loaded state and a real format change happens + * we have to disable the port and re-allocate all buffers. If no real + * format change happened we can just exit here. + */ + if (needs_disable) { + if (gst_omx_port_manual_reconfigure (self->in_port, TRUE) != OMX_ErrorNone) + return FALSE; + if (gst_omx_port_set_enabled (self->in_port, FALSE) != OMX_ErrorNone) + return FALSE; + } + + switch (state->format) { + case GST_VIDEO_FORMAT_I420: + port_def.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar; + break; + case GST_VIDEO_FORMAT_NV12: + port_def.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar; + break; + default: + GST_ERROR_OBJECT (self, "Unsupported caps %" GST_PTR_FORMAT, state->caps); + return FALSE; + break; + } + port_def.format.video.nFrameWidth = state->width; + port_def.format.video.nFrameHeight = state->height; + if (state->fps_n == 0) { + port_def.format.video.xFramerate = 0; + } else { + if (!(klass->hacks & GST_OMX_HACK_VIDEO_FRAMERATE_INTEGER)) + port_def.format.video.xFramerate = (state->fps_n << 16) / (state->fps_d); + else + port_def.format.video.xFramerate = (state->fps_n) / (state->fps_d); + } + + if (!gst_omx_port_update_port_definition (self->in_port, &port_def)) + return FALSE; + if (!gst_omx_port_update_port_definition (self->out_port, NULL)) + return FALSE; + + if (klass->set_format) { + if (!klass->set_format (self, self->in_port, state)) { + GST_ERROR_OBJECT (self, "Subclass failed to set the new format"); + return FALSE; + } + } + + if (needs_disable) { + if (gst_omx_port_set_enabled (self->in_port, TRUE) != OMX_ErrorNone) + return FALSE; + if (gst_omx_port_manual_reconfigure (self->in_port, FALSE) != OMX_ErrorNone) + return FALSE; + } else { + if (gst_omx_component_set_state (self->component, + OMX_StateIdle) != OMX_ErrorNone) + return FALSE; + + /* Need to allocate buffers to reach Idle state */ + if (gst_omx_port_allocate_buffers (self->in_port) != OMX_ErrorNone) + return FALSE; + if (gst_omx_port_allocate_buffers (self->out_port) != OMX_ErrorNone) + return FALSE; + + if (gst_omx_component_get_state (self->component, + GST_CLOCK_TIME_NONE) != OMX_StateIdle) + return FALSE; + + if (gst_omx_component_set_state (self->component, + OMX_StateExecuting) != OMX_ErrorNone) + return FALSE; + } + + /* Unset flushing to allow ports to accept data again */ + gst_omx_port_set_flushing (self->in_port, FALSE); + gst_omx_port_set_flushing (self->out_port, FALSE); + + if (gst_omx_component_get_last_error (self->component) != OMX_ErrorNone) { + GST_ERROR_OBJECT (self, "Component in error state: %s (0x%08x)", + gst_omx_component_get_last_error_string (self->component), + gst_omx_component_get_last_error (self->component)); + return FALSE; + } + + /* Start the srcpad loop again */ + gst_pad_start_task (GST_BASE_VIDEO_CODEC_SRC_PAD (self), + (GstTaskFunction) gst_omx_video_enc_loop, encoder); + + return (gst_omx_component_get_state (self->component, + GST_CLOCK_TIME_NONE) == OMX_StateExecuting); +} + +static gboolean +gst_omx_video_enc_reset (GstBaseVideoEncoder * encoder) +{ + GstOMXVideoEnc *self; + + self = GST_OMX_VIDEO_ENC (encoder); + + GST_DEBUG_OBJECT (self, "Resetting encoder"); + + /* FIXME: Workaround for + * https://bugzilla.gnome.org/show_bug.cgi?id=654529 + */ + GST_OBJECT_LOCK (self); + g_list_foreach (GST_BASE_VIDEO_CODEC (self)->frames, + (GFunc) gst_base_video_codec_free_frame, NULL); + g_list_free (GST_BASE_VIDEO_CODEC (self)->frames); + GST_BASE_VIDEO_CODEC (self)->frames = NULL; + GST_OBJECT_UNLOCK (self); + + if (self->started) { + gst_omx_port_set_flushing (self->in_port, TRUE); + gst_omx_port_set_flushing (self->out_port, TRUE); + + /* Wait until the srcpad loop is finished */ + GST_PAD_STREAM_LOCK (GST_BASE_VIDEO_CODEC_SRC_PAD (self)); + GST_PAD_STREAM_UNLOCK (GST_BASE_VIDEO_CODEC_SRC_PAD (self)); + + gst_omx_port_set_flushing (self->in_port, FALSE); + gst_omx_port_set_flushing (self->out_port, FALSE); + } + + /* Start the srcpad loop again */ + gst_pad_start_task (GST_BASE_VIDEO_CODEC_SRC_PAD (self), + (GstTaskFunction) gst_omx_video_enc_loop, encoder); + + return TRUE; +} + +static GstFlowReturn +gst_omx_video_enc_handle_frame (GstBaseVideoEncoder * encoder, + GstVideoFrame * frame) +{ + GstOMXAcquireBufferReturn acq_ret = GST_OMX_ACQUIRE_BUFFER_ERROR; + GstOMXVideoEnc *self; + GstOMXBuffer *buf; + guint offset = 0; + GstClockTime timestamp, duration, timestamp_offset = 0; + + self = GST_OMX_VIDEO_ENC (encoder); + + GST_DEBUG_OBJECT (self, "Handling frame"); + + timestamp = frame->presentation_timestamp; + duration = frame->presentation_duration; + + while (offset < GST_BUFFER_SIZE (frame->sink_buffer)) { + acq_ret = gst_omx_port_acquire_buffer (self->in_port, &buf); + + if (acq_ret == GST_OMX_ACQUIRE_BUFFER_ERROR) { + goto component_error; + } else if (acq_ret == GST_OMX_ACQUIRE_BUFFER_FLUSHING) { + goto flushing; + } else if (acq_ret == GST_OMX_ACQUIRE_BUFFER_RECONFIGURE) { + if (gst_omx_port_reconfigure (self->in_port) != OMX_ErrorNone) + goto reconfigure_error; + /* Now get a new buffer and fill it */ + continue; + } else if (acq_ret == GST_OMX_ACQUIRE_BUFFER_RECONFIGURED) { + /* TODO: Anything to do here? Don't think so */ + continue; + } + + g_assert (acq_ret == GST_OMX_ACQUIRE_BUFFER_OK && buf != NULL); + + /* Now handle the frame */ + + /* Copy the buffer content in chunks of size as requested + * by the port */ + buf->omx_buf->nFilledLen = + MIN (GST_BUFFER_SIZE (frame->sink_buffer) - offset, + buf->omx_buf->nAllocLen - buf->omx_buf->nOffset); + memcpy (buf->omx_buf->pBuffer + buf->omx_buf->nOffset, + GST_BUFFER_DATA (frame->sink_buffer) + offset, + buf->omx_buf->nFilledLen); + + /* Interpolate timestamps if we're passing the buffer + * in multiple chunks */ + if (offset != 0 && duration != GST_CLOCK_TIME_NONE) { + timestamp_offset = + gst_util_uint64_scale (offset, duration, + GST_BUFFER_SIZE (frame->sink_buffer)); + } + + if (timestamp != GST_CLOCK_TIME_NONE) { + buf->omx_buf->nTimeStamp = + gst_util_uint64_scale (timestamp + timestamp_offset, + OMX_TICKS_PER_SECOND, GST_SECOND); + } + if (duration != GST_CLOCK_TIME_NONE) { + buf->omx_buf->nTickCount = + gst_util_uint64_scale (buf->omx_buf->nFilledLen, duration, + GST_BUFFER_SIZE (frame->sink_buffer)); + } + + if (offset == 0) { + BufferIdentification *id = g_slice_new0 (BufferIdentification); + + if (!GST_BUFFER_FLAG_IS_SET (frame->sink_buffer, + GST_BUFFER_FLAG_DELTA_UNIT)) + buf->omx_buf->nFlags |= OMX_BUFFERFLAG_SYNCFRAME; + + id->timestamp = buf->omx_buf->nTimeStamp; + frame->coder_hook = id; + frame->coder_hook_destroy_notify = + (GDestroyNotify) buffer_identification_free; + } + + /* TODO: Set flags + * - OMX_BUFFERFLAG_ENCODEONLY for buffers that are outside + * the segment + * - OMX_BUFFERFLAG_ENDOFFRAME for parsed input + */ + + offset += buf->omx_buf->nFilledLen; + self->started = TRUE; + gst_omx_port_release_buffer (self->in_port, buf); + } + + return GST_FLOW_OK; + +component_error: + { + GST_ELEMENT_ERROR (self, LIBRARY, FAILED, (NULL), + ("OpenMAX component in error state %s (0x%08x)", + gst_omx_component_get_last_error_string (self->component), + gst_omx_component_get_last_error (self->component))); + return GST_FLOW_ERROR; + } + +flushing: + { + GST_DEBUG_OBJECT (self, "Flushing -- returning WRONG_STATE"); + return GST_FLOW_WRONG_STATE; + } +reconfigure_error: + { + GST_ELEMENT_ERROR (self, LIBRARY, SETTINGS, (NULL), + ("Unable to reconfigure input port")); + return GST_FLOW_ERROR; + } +} + +static gboolean +gst_omx_video_enc_finish (GstBaseVideoEncoder * encoder) +{ + GstOMXVideoEnc *self; + GstOMXBuffer *buf; + GstOMXAcquireBufferReturn acq_ret; + + self = GST_OMX_VIDEO_ENC (encoder); + + GST_DEBUG_OBJECT (self, "Sending EOS to the component"); + + /* Send an EOS buffer to the component and let the base + * class drop the EOS event. We will send it later when + * the EOS buffer arrives on the output port. */ + acq_ret = gst_omx_port_acquire_buffer (self->in_port, &buf); + if (acq_ret == GST_OMX_ACQUIRE_BUFFER_OK) { + buf->omx_buf->nFlags |= OMX_BUFFERFLAG_EOS; + gst_omx_port_release_buffer (self->in_port, buf); + } + + return TRUE; +} diff --git a/omx/gstomxvideoenc.h b/omx/gstomxvideoenc.h new file mode 100644 index 0000000..98619b2 --- /dev/null +++ b/omx/gstomxvideoenc.h @@ -0,0 +1,85 @@ +/* + * Copyright (C) 2011, Hewlett-Packard Development Company, L.P. + * Author: Sebastian Dröge , Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifndef __GST_OMX_VIDEO_ENC_H__ +#define __GST_OMX_VIDEO_ENC_H__ + +#include +#include "gstbasevideoencoder.h" + +#include "gstomx.h" + +G_BEGIN_DECLS + +#define GST_TYPE_OMX_VIDEO_ENC \ + (gst_omx_video_enc_get_type()) +#define GST_OMX_VIDEO_ENC(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_OMX_VIDEO_ENC,GstOMXVideoEnc)) +#define GST_OMX_VIDEO_ENC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_OMX_VIDEO_ENC,GstOMXVideoEncClass)) +#define GST_OMX_VIDEO_ENC_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj),GST_TYPE_OMX_VIDEO_ENC,GstOMXVideoEncClass)) +#define GST_IS_OMX_VIDEO_ENC(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_OMX_VIDEO_ENC)) +#define GST_IS_OMX_VIDEO_ENC_CLASS(obj) \ + (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_OMX_VIDEO_ENC)) + +typedef struct _GstOMXVideoEnc GstOMXVideoEnc; +typedef struct _GstOMXVideoEncClass GstOMXVideoEncClass; + +struct _GstOMXVideoEnc +{ + GstBaseVideoEncoder parent; + + /* < protected > */ + GstOMXCore *core; + GstOMXComponent *component; + GstOMXPort *in_port, *out_port; + + /* < private > */ + /* TRUE if the component is configured and saw + * the first buffer */ + gboolean started; +}; + +struct _GstOMXVideoEncClass +{ + GstBaseVideoEncoderClass parent_class; + + const gchar *core_name; + const gchar *component_name; + const gchar *component_role; + + const gchar *default_src_template_caps; + const gchar *default_sink_template_caps; + + guint32 in_port_index, out_port_index; + + guint64 hacks; + + gboolean (*set_format) (GstOMXVideoEnc * self, GstOMXPort * port, GstVideoState * state); + GstCaps *(*get_caps) (GstOMXVideoEnc * self, GstOMXPort * port, GstVideoState * state); +}; + +GType gst_omx_video_enc_get_type (void); + +G_END_DECLS + +#endif /* __GST_OMX_VIDEO_ENC_H__ */ -- 2.7.4