omx/gstomxvideoenc.c

   1 /*
   2  * Copyright (C) 2011, Hewlett-Packard Development Company, L.P.
   3  *   Author: Sebastian Dröge <sebastian.droege@collabora.co.uk>, Collabora Ltd.
   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  *
  19  */
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include "config.h"
  23 #endif
  24
  25 #include <gst/gst.h>
  26 #include <gst/video/gstvideometa.h>
  27 #include <gst/allocators/gstdmabuf.h>
  28
  29 #include <string.h>
  30
  31 #include "gstomxbufferpool.h"
  32 #include "gstomxvideo.h"
  33 #include "gstomxvideoenc.h"
  34
  35 #ifdef USE_OMX_TARGET_RPI
  36 #include <OMX_Broadcom.h>
  37 #include <OMX_Index.h>
  38 #endif
  39
  40 GST_DEBUG_CATEGORY_STATIC (gst_omx_video_enc_debug_category);
  41 #define GST_CAT_DEFAULT gst_omx_video_enc_debug_category
  42
  43 #define GST_TYPE_OMX_VIDEO_ENC_CONTROL_RATE (gst_omx_video_enc_control_rate_get_type ())
  44 static GType
  45 gst_omx_video_enc_control_rate_get_type (void)
  46 {
  47   static GType qtype = 0;
  48
  49   if (qtype == 0) {
  50     static const GEnumValue values[] = {
  51       {OMX_Video_ControlRateDisable, "Disable", "disable"},
  52       {OMX_Video_ControlRateVariable, "Variable", "variable"},
  53       {OMX_Video_ControlRateConstant, "Constant", "constant"},
  54       {OMX_Video_ControlRateVariableSkipFrames, "Variable Skip Frames",
  55           "variable-skip-frames"},
  56       {OMX_Video_ControlRateConstantSkipFrames, "Constant Skip Frames",
  57           "constant-skip-frames"},
  58 #ifdef USE_OMX_TARGET_ZYNQ_USCALE_PLUS
  59       {OMX_ALG_Video_ControlRateLowLatency, "Low Latency", "low-latency"},
  60 #endif
  61       {0xffffffff, "Component Default", "default"},
  62       {0, NULL, NULL}
  63     };
  64
  65     qtype = g_enum_register_static ("GstOMXVideoEncControlRate", values);
  66   }
  67   return qtype;
  68 }
  69
  70 #ifdef USE_OMX_TARGET_ZYNQ_USCALE_PLUS
  71 #define GST_TYPE_OMX_VIDEO_ENC_QP_MODE (gst_omx_video_enc_qp_mode_get_type ())
  72 static GType
  73 gst_omx_video_enc_qp_mode_get_type (void)
  74 {
  75   static GType qtype = 0;
  76
  77   if (qtype == 0) {
  78     static const GEnumValue values[] = {
  79       {OMX_ALG_UNIFORM_QP, "Use the same QP for all coding units of the frame",
  80           "uniform"},
  81       {OMX_ALG_AUTO_QP,
  82             "Let the VCU encoder change the QP for each coding unit according to its content",
  83           "auto"},
  84       {OMX_ALG_ROI_QP,
  85             "Adjust QP according to the regions of interest defined on each frame. Must be set to handle ROI metadata.",
  86           "roi"},
  87       {0xffffffff, "Component Default", "default"},
  88       {0, NULL, NULL}
  89     };
  90
  91     qtype = g_enum_register_static ("GstOMXVideoEncQpMode", values);
  92   }
  93   return qtype;
  94 }
  95
  96 #define GST_TYPE_OMX_VIDEO_ENC_GOP_MODE (gst_omx_video_enc_gop_mode_get_type ())
  97 static GType
  98 gst_omx_video_enc_gop_mode_get_type (void)
  99 {
 100   static GType qtype = 0;
 101
 102   if (qtype == 0) {
 103     static const GEnumValue values[] = {
 104       {OMX_ALG_GOP_MODE_DEFAULT, "Basic GOP settings", "basic"},
 105       {OMX_ALG_GOP_MODE_PYRAMIDAL,
 106           "Advanced GOP pattern with hierarchical B-frames", "pyramidal"},
 107       {OMX_ALG_GOP_MODE_LOW_DELAY_P, "Single I-frame followed by P-frames only",
 108           "low-delay-p"},
 109       {OMX_ALG_GOP_MODE_LOW_DELAY_B, "Single I-frame followed by B-frames only",
 110           "low-delay-b"},
 111       {OMX_ALG_GOP_MODE_ADAPTIVE, "Advanced GOP pattern with adaptive B-frames",
 112           "adaptive"},
 113       {0, NULL, NULL}
 114     };
 115
 116     qtype = g_enum_register_static ("GstOMXVideoEncGopMode", values);
 117   }
 118   return qtype;
 119 }
 120
 121 #define GST_TYPE_OMX_VIDEO_ENC_GDR_MODE (gst_omx_video_enc_gdr_mode_get_type ())
 122 static GType
 123 gst_omx_video_enc_gdr_mode_get_type (void)
 124 {
 125   static GType qtype = 0;
 126
 127   if (qtype == 0) {
 128     static const GEnumValue values[] = {
 129       {OMX_ALG_GDR_OFF, "No GDR", "disabled"},
 130       {OMX_ALG_GDR_VERTICAL,
 131             "Gradual refresh using a vertical bar moving from left to right",
 132           "vertical"},
 133       {OMX_ALG_GDR_HORIZONTAL,
 134             "Gradual refresh using a horizontal bar moving from top to bottom",
 135           "horizontal"},
 136       {0, NULL, NULL}
 137     };
 138
 139     qtype = g_enum_register_static ("GstOMXVideoEncGdrMode", values);
 140   }
 141   return qtype;
 142 }
 143
 144 #define GST_TYPE_OMX_VIDEO_ENC_SCALING_LIST (gst_omx_video_enc_scaling_list_get_type ())
 145 static GType
 146 gst_omx_video_enc_scaling_list_get_type (void)
 147 {
 148   static GType qtype = 0;
 149
 150   if (qtype == 0) {
 151     static const GEnumValue values[] = {
 152       {OMX_ALG_SCL_DEFAULT, "Default scaling list mode", "default"},
 153       {OMX_ALG_SCL_FLAT, "Flat scaling list mode", "flat"},
 154       {0, NULL, NULL}
 155     };
 156
 157     qtype = g_enum_register_static ("GstOMXVideoEncScalingList", values);
 158   }
 159   return qtype;
 160 }
 161
 162 #define GST_TYPE_OMX_VIDEO_ENC_ASPECT_RATIO (gst_omx_video_enc_aspect_ratio_get_type ())
 163 static GType
 164 gst_omx_video_enc_aspect_ratio_get_type (void)
 165 {
 166   static GType qtype = 0;
 167
 168   if (qtype == 0) {
 169     static const GEnumValue values[] = {
 170       {OMX_ALG_ASPECT_RATIO_AUTO,
 171             "4:3 for SD video,16:9 for HD video,unspecified for unknown format",
 172           "auto"},
 173       {OMX_ALG_ASPECT_RATIO_4_3, "4:3 aspect ratio", "4-3"},
 174       {OMX_ALG_ASPECT_RATIO_16_9, "16:9 aspect ratio", "16-9"},
 175       {OMX_ALG_ASPECT_RATIO_NONE,
 176           "Aspect ratio information is not present in the stream", "none"},
 177       {0, NULL, NULL}
 178     };
 179
 180     qtype = g_enum_register_static ("GstOMXVideoEncAspectRatio", values);
 181   }
 182   return qtype;
 183 }
 184
 185 #define GST_TYPE_OMX_VIDEO_ENC_ROI_QUALITY (gst_omx_video_enc_roi_quality_type ())
 186 static GType
 187 gst_omx_video_enc_roi_quality_type (void)
 188 {
 189   static GType qtype = 0;
 190
 191   if (qtype == 0) {
 192     static const GEnumValue values[] = {
 193       {OMX_ALG_ROI_QUALITY_HIGH, "Delta QP of -5", "high"},
 194       {OMX_ALG_ROI_QUALITY_MEDIUM, "Delta QP of 0", "medium"},
 195       {OMX_ALG_ROI_QUALITY_LOW, "Delta QP of +5", "low"},
 196       {OMX_ALG_ROI_QUALITY_DONT_CARE, "Maximum delta QP value", "dont-care"},
 197       {0, NULL, NULL}
 198     };
 199
 200     qtype = g_enum_register_static ("GstOMXVideoEncRoiQuality", values);
 201   }
 202   return qtype;
 203 }
 204 #endif
 205
 206 /* prototypes */
 207 static void gst_omx_video_enc_finalize (GObject * object);
 208 static void gst_omx_video_enc_set_property (GObject * object, guint prop_id,
 209     const GValue * value, GParamSpec * pspec);
 210 static void gst_omx_video_enc_get_property (GObject * object, guint prop_id,
 211     GValue * value, GParamSpec * pspec);
 212
 213
 214 static GstStateChangeReturn
 215 gst_omx_video_enc_change_state (GstElement * element,
 216     GstStateChange transition);
 217
 218 static gboolean gst_omx_video_enc_open (GstVideoEncoder * encoder);
 219 static gboolean gst_omx_video_enc_close (GstVideoEncoder * encoder);
 220 static gboolean gst_omx_video_enc_start (GstVideoEncoder * encoder);
 221 static gboolean gst_omx_video_enc_stop (GstVideoEncoder * encoder);
 222 static gboolean gst_omx_video_enc_set_format (GstVideoEncoder * encoder,
 223     GstVideoCodecState * state);
 224 static gboolean gst_omx_video_enc_flush (GstVideoEncoder * encoder);
 225 static GstFlowReturn gst_omx_video_enc_handle_frame (GstVideoEncoder * encoder,
 226     GstVideoCodecFrame * frame);
 227 static gboolean gst_omx_video_enc_finish (GstVideoEncoder * encoder);
 228 static gboolean gst_omx_video_enc_propose_allocation (GstVideoEncoder * encoder,
 229     GstQuery * query);
 230 static GstCaps *gst_omx_video_enc_getcaps (GstVideoEncoder * encoder,
 231     GstCaps * filter);
 232 static gboolean gst_omx_video_enc_decide_allocation (GstVideoEncoder * encoder,
 233     GstQuery * query);
 234 static gboolean gst_omx_video_enc_sink_query (GstVideoEncoder * encoder,
 235     GstQuery * query);
 236
 237 static GstFlowReturn gst_omx_video_enc_drain (GstOMXVideoEnc * self);
 238
 239 static GstFlowReturn gst_omx_video_enc_handle_output_frame (GstOMXVideoEnc *
 240     self, GstOMXPort * port, GstOMXBuffer * buf, GstVideoCodecFrame * frame);
 241
 242 enum
 243 {
 244   PROP_0,
 245   PROP_CONTROL_RATE,
 246   PROP_TARGET_BITRATE,
 247   PROP_QUANT_I_FRAMES,
 248   PROP_QUANT_P_FRAMES,
 249   PROP_QUANT_B_FRAMES,
 250   PROP_QP_MODE,
 251   PROP_MIN_QP,
 252   PROP_MAX_QP,
 253   PROP_GOP_MODE,
 254   PROP_GDR_MODE,
 255   PROP_INITIAL_DELAY,
 256   PROP_CPB_SIZE,
 257   PROP_SCALING_LIST,
 258   PROP_LOW_BANDWIDTH,
 259   PROP_MAX_BITRATE,
 260   PROP_ASPECT_RATIO,
 261   PROP_FILLER_DATA,
 262   PROP_NUM_SLICES,
 263   PROP_SLICE_SIZE,
 264   PROP_DEPENDENT_SLICE,
 265   PROP_DEFAULT_ROI_QUALITY,
 266 };
 267
 268 /* FIXME: Better defaults */
 269 #define GST_OMX_VIDEO_ENC_CONTROL_RATE_DEFAULT (0xffffffff)
 270 #define GST_OMX_VIDEO_ENC_TARGET_BITRATE_DEFAULT (0xffffffff)
 271 #define GST_OMX_VIDEO_ENC_QUANT_I_FRAMES_DEFAULT (0xffffffff)
 272 #define GST_OMX_VIDEO_ENC_QUANT_P_FRAMES_DEFAULT (0xffffffff)
 273 #define GST_OMX_VIDEO_ENC_QUANT_B_FRAMES_DEFAULT (0xffffffff)
 274 #define GST_OMX_VIDEO_ENC_QP_MODE_DEFAULT (0xffffffff)
 275 #define GST_OMX_VIDEO_ENC_MIN_QP_DEFAULT (10)
 276 #define GST_OMX_VIDEO_ENC_MAX_QP_DEFAULT (51)
 277 #define GST_OMX_VIDEO_ENC_GOP_MODE_DEFAULT (OMX_ALG_GOP_MODE_DEFAULT)
 278 #define GST_OMX_VIDEO_ENC_GDR_MODE_DEFAULT (OMX_ALG_GDR_OFF)
 279 #define GST_OMX_VIDEO_ENC_INITIAL_DELAY_DEFAULT (1500)
 280 #define GST_OMX_VIDEO_ENC_CPB_SIZE_DEFAULT (3000)
 281 #define GST_OMX_VIDEO_ENC_SCALING_LIST_DEFAULT (OMX_ALG_SCL_DEFAULT)
 282 #define GST_OMX_VIDEO_ENC_LOW_BANDWIDTH_DEFAULT (FALSE)
 283 #define GST_OMX_VIDEO_ENC_MAX_BITRATE_DEFAULT (0xffffffff)
 284 #define GST_OMX_VIDEO_ENC_ASPECT_RATIO_DEFAULT (OMX_ALG_ASPECT_RATIO_AUTO)
 285 #define GST_OMX_VIDEO_ENC_FILLER_DATA_DEFAULT (TRUE)
 286 #define GST_OMX_VIDEO_ENC_NUM_SLICES_DEFAULT (0xffffffff)
 287 #define GST_OMX_VIDEO_ENC_SLICE_SIZE_DEFAULT (0)
 288 #define GST_OMX_VIDEO_ENC_DEPENDENT_SLICE_DEFAULT (FALSE)
 289 #define GST_OMX_VIDEO_ENC_DEFAULT_ROI_QUALITY OMX_ALG_ROI_QUALITY_HIGH
 290
 291 /* class initialization */
 292 #define do_init \
 293 { \
 294   GST_DEBUG_CATEGORY_INIT (gst_omx_video_enc_debug_category, "omxvideoenc", 0, \
 295       "debug category for gst-omx video encoder base class"); \
 296   G_IMPLEMENT_INTERFACE (GST_TYPE_PRESET, NULL); \
 297 }
 298
 299 G_DEFINE_ABSTRACT_TYPE_WITH_CODE (GstOMXVideoEnc, gst_omx_video_enc,
 300     GST_TYPE_VIDEO_ENCODER, do_init);
 301
 302 static void
 303 gst_omx_video_enc_class_init (GstOMXVideoEncClass * klass)
 304 {
 305   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 306   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
 307   GstVideoEncoderClass *video_encoder_class = GST_VIDEO_ENCODER_CLASS (klass);
 308
 309
 310   gobject_class->finalize = gst_omx_video_enc_finalize;
 311   gobject_class->set_property = gst_omx_video_enc_set_property;
 312   gobject_class->get_property = gst_omx_video_enc_get_property;
 313
 314   g_object_class_install_property (gobject_class, PROP_CONTROL_RATE,
 315       g_param_spec_enum ("control-rate", "Control Rate",
 316           "Bitrate control method",
 317           GST_TYPE_OMX_VIDEO_ENC_CONTROL_RATE,
 318           GST_OMX_VIDEO_ENC_CONTROL_RATE_DEFAULT,
 319           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
 320           GST_PARAM_MUTABLE_READY));
 321
 322   g_object_class_install_property (gobject_class, PROP_TARGET_BITRATE,
 323       g_param_spec_uint ("target-bitrate", "Target Bitrate",
 324           "Target bitrate in bits per second (0xffffffff=component default)",
 325           0, G_MAXUINT, GST_OMX_VIDEO_ENC_TARGET_BITRATE_DEFAULT,
 326           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
 327           GST_PARAM_MUTABLE_PLAYING));
 328
 329   g_object_class_install_property (gobject_class, PROP_QUANT_I_FRAMES,
 330       g_param_spec_uint ("quant-i-frames", "I-Frame Quantization",
 331           "Quantization parameter for I-frames (0xffffffff=component default)",
 332           0, G_MAXUINT, GST_OMX_VIDEO_ENC_QUANT_I_FRAMES_DEFAULT,
 333           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
 334           GST_PARAM_MUTABLE_READY));
 335
 336   g_object_class_install_property (gobject_class, PROP_QUANT_P_FRAMES,
 337       g_param_spec_uint ("quant-p-frames", "P-Frame Quantization",
 338           "Quantization parameter for P-frames (0xffffffff=component default)",
 339           0, G_MAXUINT, GST_OMX_VIDEO_ENC_QUANT_P_FRAMES_DEFAULT,
 340           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
 341           GST_PARAM_MUTABLE_READY));
 342
 343   g_object_class_install_property (gobject_class, PROP_QUANT_B_FRAMES,
 344       g_param_spec_uint ("quant-b-frames", "B-Frame Quantization",
 345           "Quantization parameter for B-frames (0xffffffff=component default)",
 346           0, G_MAXUINT, GST_OMX_VIDEO_ENC_QUANT_B_FRAMES_DEFAULT,
 347           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
 348           GST_PARAM_MUTABLE_READY));
 349
 350 #ifdef USE_OMX_TARGET_ZYNQ_USCALE_PLUS
 351   g_object_class_install_property (gobject_class, PROP_QP_MODE,
 352       g_param_spec_enum ("qp-mode", "QP mode",
 353           "QP control mode used by the VCU encoder",
 354           GST_TYPE_OMX_VIDEO_ENC_QP_MODE,
 355           GST_OMX_VIDEO_ENC_QP_MODE_DEFAULT,
 356           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
 357           GST_PARAM_MUTABLE_READY));
 358
 359   g_object_class_install_property (gobject_class, PROP_MIN_QP,
 360       g_param_spec_uint ("min-qp", "min Quantization value",
 361           "Minimum QP value allowed for the rate control",
 362           0, 51, GST_OMX_VIDEO_ENC_MIN_QP_DEFAULT,
 363           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
 364           GST_PARAM_MUTABLE_READY));
 365
 366   g_object_class_install_property (gobject_class, PROP_MAX_QP,
 367       g_param_spec_uint ("max-qp", "max Quantization value",
 368           "Maximum QP value allowed for the rate control",
 369           0, 51, GST_OMX_VIDEO_ENC_MAX_QP_DEFAULT,
 370           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
 371           GST_PARAM_MUTABLE_READY));
 372
 373   g_object_class_install_property (gobject_class, PROP_GOP_MODE,
 374       g_param_spec_enum ("gop-mode", "GOP mode",
 375           "Group Of Pictures mode",
 376           GST_TYPE_OMX_VIDEO_ENC_GOP_MODE,
 377           GST_OMX_VIDEO_ENC_GOP_MODE_DEFAULT,
 378           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
 379           GST_PARAM_MUTABLE_READY));
 380
 381   g_object_class_install_property (gobject_class, PROP_GDR_MODE,
 382       g_param_spec_enum ("gdr-mode", "GDR mode",
 383           "Gradual Decoder Refresh scheme mode. Only used if gop-mode=low-delay-p",
 384           GST_TYPE_OMX_VIDEO_ENC_GDR_MODE,
 385           GST_OMX_VIDEO_ENC_GDR_MODE_DEFAULT,
 386           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
 387           GST_PARAM_MUTABLE_READY));
 388
 389   g_object_class_install_property (gobject_class, PROP_INITIAL_DELAY,
 390       g_param_spec_uint ("initial-delay", "Initial Delay",
 391           "The initial removal delay as specified in the HRD model in msec. "
 392           "Not used when control-rate=disable",
 393           0, G_MAXUINT, GST_OMX_VIDEO_ENC_INITIAL_DELAY_DEFAULT,
 394           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
 395           GST_PARAM_MUTABLE_READY));
 396
 397   g_object_class_install_property (gobject_class, PROP_CPB_SIZE,
 398       g_param_spec_uint ("cpb-size", "CPB size",
 399           "Coded Picture Buffer as specified in the HRD model in msec. "
 400           "Not used when control-rate=disable",
 401           0, G_MAXUINT, GST_OMX_VIDEO_ENC_CPB_SIZE_DEFAULT,
 402           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
 403           GST_PARAM_MUTABLE_READY));
 404
 405   g_object_class_install_property (gobject_class, PROP_SCALING_LIST,
 406       g_param_spec_enum ("scaling-list", "Scaling List",
 407           "Scaling list mode",
 408           GST_TYPE_OMX_VIDEO_ENC_SCALING_LIST,
 409           GST_OMX_VIDEO_ENC_SCALING_LIST_DEFAULT,
 410           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
 411           GST_PARAM_MUTABLE_READY));
 412
 413   g_object_class_install_property (gobject_class, PROP_LOW_BANDWIDTH,
 414       g_param_spec_boolean ("low-bandwidth", "Low bandwidth mode",
 415           "If enabled, decrease the vertical search range "
 416           "used for P-frame motion estimation to reduce the bandwidth",
 417           GST_OMX_VIDEO_ENC_LOW_BANDWIDTH_DEFAULT,
 418           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
 419           GST_PARAM_MUTABLE_READY));
 420
 421   g_object_class_install_property (gobject_class, PROP_MAX_BITRATE,
 422       g_param_spec_uint ("max-bitrate", "Max Bitrate",
 423           "Max bitrate in bits per second, only used if control-rate=variable (0xffffffff=component default)",
 424           0, G_MAXUINT, GST_OMX_VIDEO_ENC_MAX_BITRATE_DEFAULT,
 425           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
 426           GST_PARAM_MUTABLE_READY));
 427
 428   g_object_class_install_property (gobject_class, PROP_ASPECT_RATIO,
 429       g_param_spec_enum ("aspect-ratio", "Aspect ratio",
 430           "Display aspect ratio of the video sequence to be written in SPS/VUI",
 431           GST_TYPE_OMX_VIDEO_ENC_ASPECT_RATIO,
 432           GST_OMX_VIDEO_ENC_ASPECT_RATIO_DEFAULT,
 433           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
 434           GST_PARAM_MUTABLE_READY));
 435
 436   g_object_class_install_property (gobject_class, PROP_FILLER_DATA,
 437       g_param_spec_boolean ("filler-data", "Filler Data",
 438           "Enable/Disable Filler Data NAL units for CBR rate control",
 439           GST_OMX_VIDEO_ENC_FILLER_DATA_DEFAULT,
 440           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
 441           GST_PARAM_MUTABLE_READY));
 442
 443   g_object_class_install_property (gobject_class, PROP_NUM_SLICES,
 444       g_param_spec_uint ("num-slices", "Number of slices",
 445           "Number of slices produced for each frame. Each slice contains one or more complete macroblock/CTU row(s). "
 446           "Slices are distributed over the frame as regularly as possible. If slice-size is defined as well more slices "
 447           "may be produced to fit the slice-size requirement (0xffffffff=component default)",
 448           1, G_MAXUINT, GST_OMX_VIDEO_ENC_NUM_SLICES_DEFAULT,
 449           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
 450           GST_PARAM_MUTABLE_READY));
 451
 452   g_object_class_install_property (gobject_class, PROP_SLICE_SIZE,
 453       g_param_spec_uint ("slice-size", "Target slice size",
 454           "Target slice size (in bytes) that the encoder uses to "
 455           "automatically split the bitstream into approximately equally-sized slices",
 456           0, 65535, GST_OMX_VIDEO_ENC_SLICE_SIZE_DEFAULT,
 457           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
 458           GST_PARAM_MUTABLE_READY));
 459
 460   g_object_class_install_property (gobject_class, PROP_DEPENDENT_SLICE,
 461       g_param_spec_boolean ("dependent-slice", "Dependent slice",
 462           "If encoding with multiple slices, specify whether the additional slices are "
 463           "dependent slice segments or regular slices",
 464           GST_OMX_VIDEO_ENC_DEPENDENT_SLICE_DEFAULT,
 465           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 466
 467   g_object_class_install_property (gobject_class, PROP_DEFAULT_ROI_QUALITY,
 468       g_param_spec_enum ("default-roi-quality", "Default ROI Qualtiy",
 469           "The default quality level to apply to each Region of Interest",
 470           GST_TYPE_OMX_VIDEO_ENC_ROI_QUALITY,
 471           GST_OMX_VIDEO_ENC_DEFAULT_ROI_QUALITY,
 472           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 473 #endif
 474
 475   element_class->change_state =
 476       GST_DEBUG_FUNCPTR (gst_omx_video_enc_change_state);
 477
 478   video_encoder_class->open = GST_DEBUG_FUNCPTR (gst_omx_video_enc_open);
 479   video_encoder_class->close = GST_DEBUG_FUNCPTR (gst_omx_video_enc_close);
 480   video_encoder_class->start = GST_DEBUG_FUNCPTR (gst_omx_video_enc_start);
 481   video_encoder_class->stop = GST_DEBUG_FUNCPTR (gst_omx_video_enc_stop);
 482   video_encoder_class->flush = GST_DEBUG_FUNCPTR (gst_omx_video_enc_flush);
 483   video_encoder_class->set_format =
 484       GST_DEBUG_FUNCPTR (gst_omx_video_enc_set_format);
 485   video_encoder_class->handle_frame =
 486       GST_DEBUG_FUNCPTR (gst_omx_video_enc_handle_frame);
 487   video_encoder_class->finish = GST_DEBUG_FUNCPTR (gst_omx_video_enc_finish);
 488   video_encoder_class->propose_allocation =
 489       GST_DEBUG_FUNCPTR (gst_omx_video_enc_propose_allocation);
 490   video_encoder_class->getcaps = GST_DEBUG_FUNCPTR (gst_omx_video_enc_getcaps);
 491   video_encoder_class->decide_allocation =
 492       GST_DEBUG_FUNCPTR (gst_omx_video_enc_decide_allocation);
 493   video_encoder_class->sink_query =
 494       GST_DEBUG_FUNCPTR (gst_omx_video_enc_sink_query);
 495
 496   klass->cdata.type = GST_OMX_COMPONENT_TYPE_FILTER;
 497   klass->cdata.default_sink_template_caps =
 498       GST_VIDEO_CAPS_MAKE (GST_OMX_VIDEO_SUPPORTED_FORMATS);
 499
 500   klass->handle_output_frame =
 501       GST_DEBUG_FUNCPTR (gst_omx_video_enc_handle_output_frame);
 502 }
 503
 504 static void
 505 gst_omx_video_enc_init (GstOMXVideoEnc * self)
 506 {
 507   self->control_rate = GST_OMX_VIDEO_ENC_CONTROL_RATE_DEFAULT;
 508   self->target_bitrate = GST_OMX_VIDEO_ENC_TARGET_BITRATE_DEFAULT;
 509   self->quant_i_frames = GST_OMX_VIDEO_ENC_QUANT_I_FRAMES_DEFAULT;
 510   self->quant_p_frames = GST_OMX_VIDEO_ENC_QUANT_P_FRAMES_DEFAULT;
 511   self->quant_b_frames = GST_OMX_VIDEO_ENC_QUANT_B_FRAMES_DEFAULT;
 512 #ifdef USE_OMX_TARGET_ZYNQ_USCALE_PLUS
 513   self->qp_mode = GST_OMX_VIDEO_ENC_QP_MODE_DEFAULT;
 514   self->min_qp = GST_OMX_VIDEO_ENC_MIN_QP_DEFAULT;
 515   self->max_qp = GST_OMX_VIDEO_ENC_MAX_QP_DEFAULT;
 516   self->gop_mode = GST_OMX_VIDEO_ENC_GOP_MODE_DEFAULT;
 517   self->gdr_mode = GST_OMX_VIDEO_ENC_GDR_MODE_DEFAULT;
 518   self->initial_delay = GST_OMX_VIDEO_ENC_INITIAL_DELAY_DEFAULT;
 519   self->cpb_size = GST_OMX_VIDEO_ENC_CPB_SIZE_DEFAULT;
 520   self->scaling_list = GST_OMX_VIDEO_ENC_SCALING_LIST_DEFAULT;
 521   self->low_bandwidth = GST_OMX_VIDEO_ENC_LOW_BANDWIDTH_DEFAULT;
 522   self->max_bitrate = GST_OMX_VIDEO_ENC_MAX_BITRATE_DEFAULT;
 523   self->aspect_ratio = GST_OMX_VIDEO_ENC_ASPECT_RATIO_DEFAULT;
 524   self->filler_data = GST_OMX_VIDEO_ENC_FILLER_DATA_DEFAULT;
 525   self->num_slices = GST_OMX_VIDEO_ENC_NUM_SLICES_DEFAULT;
 526   self->slice_size = GST_OMX_VIDEO_ENC_SLICE_SIZE_DEFAULT;
 527   self->dependent_slice = GST_OMX_VIDEO_ENC_DEPENDENT_SLICE_DEFAULT;
 528   self->default_roi_quality = GST_OMX_VIDEO_ENC_DEFAULT_ROI_QUALITY;
 529 #endif
 530
 531   self->default_target_bitrate = GST_OMX_PROP_OMX_DEFAULT;
 532
 533   g_mutex_init (&self->drain_lock);
 534   g_cond_init (&self->drain_cond);
 535
 536 #ifdef USE_OMX_TARGET_ZYNQ_USCALE_PLUS
 537   self->alg_roi_quality_enum_class =
 538       g_type_class_ref (GST_TYPE_OMX_VIDEO_ENC_ROI_QUALITY);
 539 #endif
 540 }
 541
 542 #ifdef USE_OMX_TARGET_ZYNQ_USCALE_PLUS
 543
 544 #define CHECK_ERR(setting) \
 545   if (err == OMX_ErrorUnsupportedIndex || err == OMX_ErrorUnsupportedSetting) { \
 546     GST_WARNING_OBJECT (self, \
 547         "Setting " setting " parameters not supported by the component"); \
 548   } else if (err != OMX_ErrorNone) { \
 549     GST_ERROR_OBJECT (self, \
 550         "Failed to set " setting " parameters: %s (0x%08x)", \
 551         gst_omx_error_to_string (err), err); \
 552     return FALSE; \
 553   }
 554
 555 static gboolean
 556 set_zynqultrascaleplus_props (GstOMXVideoEnc * self)
 557 {
 558   OMX_ERRORTYPE err;
 559
 560   if (self->qp_mode != GST_OMX_VIDEO_ENC_QP_MODE_DEFAULT) {
 561     OMX_ALG_VIDEO_PARAM_QUANTIZATION_CONTROL quant;
 562
 563     GST_OMX_INIT_STRUCT (&quant);
 564     quant.nPortIndex = self->enc_out_port->index;
 565     quant.eQpControlMode = self->qp_mode;
 566
 567     GST_DEBUG_OBJECT (self, "setting QP mode to %d", self->qp_mode);
 568
 569     err =
 570         gst_omx_component_set_parameter (self->enc,
 571         (OMX_INDEXTYPE) OMX_ALG_IndexParamVideoQuantizationControl, &quant);
 572     CHECK_ERR ("quantization");
 573   }
 574
 575   {
 576     OMX_ALG_VIDEO_PARAM_QUANTIZATION_EXTENSION qp_values;
 577
 578     GST_OMX_INIT_STRUCT (&qp_values);
 579     qp_values.nPortIndex = self->enc_out_port->index;
 580     qp_values.nQpMin = self->min_qp;
 581     qp_values.nQpMax = self->max_qp;
 582
 583     GST_DEBUG_OBJECT (self, "setting min QP as %d and max QP as %d",
 584         self->min_qp, self->max_qp);
 585
 586     err =
 587         gst_omx_component_set_parameter (self->enc,
 588         (OMX_INDEXTYPE) OMX_ALG_IndexParamVideoQuantizationExtension,
 589         &qp_values);
 590     CHECK_ERR ("min-qp and max-qp");
 591   }
 592
 593   {
 594     OMX_ALG_VIDEO_PARAM_GOP_CONTROL gop_mode;
 595
 596     if (self->gdr_mode != OMX_ALG_GDR_OFF &&
 597         self->gop_mode != OMX_ALG_GOP_MODE_LOW_DELAY_P) {
 598       GST_ERROR_OBJECT (self,
 599           "gdr-mode mode only can be set if gop-mode=low-delay-p");
 600       return FALSE;
 601     }
 602
 603     GST_OMX_INIT_STRUCT (&gop_mode);
 604     gop_mode.nPortIndex = self->enc_out_port->index;
 605     gop_mode.eGopControlMode = self->gop_mode;
 606     gop_mode.eGdrMode = self->gdr_mode;
 607
 608     GST_DEBUG_OBJECT (self, "setting GOP mode to %d and GDR mode to %d",
 609         self->gop_mode, self->gdr_mode);
 610
 611     err =
 612         gst_omx_component_set_parameter (self->enc,
 613         (OMX_INDEXTYPE) OMX_ALG_IndexParamVideoGopControl, &gop_mode);
 614     CHECK_ERR ("GOP & GDR");
 615   }
 616
 617   if (self->control_rate != OMX_Video_ControlRateDisable) {
 618     if (self->cpb_size < self->initial_delay) {
 619       GST_ERROR_OBJECT (self,
 620           "cpb-size (%d) cannot be smaller than initial-delay (%d)",
 621           self->cpb_size, self->initial_delay);
 622       g_critical ("cpb-size (%d) cannot be smaller than initial-delay (%d)",
 623           self->cpb_size, self->initial_delay);
 624     } else {
 625       OMX_ALG_VIDEO_PARAM_CODED_PICTURE_BUFFER cpb;
 626
 627       GST_OMX_INIT_STRUCT (&cpb);
 628       cpb.nPortIndex = self->enc_out_port->index;
 629       cpb.nCodedPictureBufferSize = self->cpb_size;
 630       cpb.nInitialRemovalDelay = self->initial_delay;
 631
 632       GST_DEBUG_OBJECT (self, "setting cpb size to %d and initial delay to %d",
 633           self->cpb_size, self->initial_delay);
 634
 635       err =
 636           gst_omx_component_set_parameter (self->enc,
 637           (OMX_INDEXTYPE) OMX_ALG_IndexParamVideoCodedPictureBuffer, &cpb);
 638       CHECK_ERR ("cpb size & initial delay");
 639     }
 640   }
 641
 642   {
 643     OMX_ALG_VIDEO_PARAM_SCALING_LIST scaling_list;
 644
 645     GST_OMX_INIT_STRUCT (&scaling_list);
 646     scaling_list.nPortIndex = self->enc_out_port->index;
 647     scaling_list.eScalingListMode = self->scaling_list;
 648
 649     GST_DEBUG_OBJECT (self, "setting scaling list mode as %d",
 650         self->scaling_list);
 651
 652     err =
 653         gst_omx_component_set_parameter (self->enc,
 654         (OMX_INDEXTYPE) OMX_ALG_IndexParamVideoScalingList, &scaling_list);
 655     CHECK_ERR ("scaling-list");
 656   }
 657
 658   {
 659     OMX_ALG_VIDEO_PARAM_LOW_BANDWIDTH low_bw;
 660
 661     GST_OMX_INIT_STRUCT (&low_bw);
 662     low_bw.nPortIndex = self->enc_out_port->index;
 663     low_bw.bEnableLowBandwidth = self->low_bandwidth;
 664
 665     GST_DEBUG_OBJECT (self, "%s low bandwith moded",
 666         self->low_bandwidth ? "Enable" : "Disable");
 667
 668     err =
 669         gst_omx_component_set_parameter (self->enc,
 670         (OMX_INDEXTYPE) OMX_ALG_IndexParamVideoLowBandwidth, &low_bw);
 671     CHECK_ERR ("low-bandwidth");
 672   }
 673
 674   if (self->max_bitrate != GST_OMX_VIDEO_ENC_MAX_BITRATE_DEFAULT) {
 675     OMX_ALG_VIDEO_PARAM_MAX_BITRATE max_bitrate;
 676
 677     GST_OMX_INIT_STRUCT (&max_bitrate);
 678     max_bitrate.nPortIndex = self->enc_out_port->index;
 679     /* nMaxBitrate is in kbps while max-bitrate is in bps */
 680     max_bitrate.nMaxBitrate = self->max_bitrate / 1000;
 681
 682     GST_DEBUG_OBJECT (self, "setting max bitrate to %d", self->max_bitrate);
 683
 684     err =
 685         gst_omx_component_set_parameter (self->enc,
 686         (OMX_INDEXTYPE) OMX_ALG_IndexParamVideoMaxBitrate, &max_bitrate);
 687     CHECK_ERR ("max-bitrate");
 688   }
 689
 690   {
 691     OMX_ALG_VIDEO_PARAM_ASPECT_RATIO aspect_ratio;
 692
 693     GST_OMX_INIT_STRUCT (&aspect_ratio);
 694     aspect_ratio.nPortIndex = self->enc_out_port->index;
 695     aspect_ratio.eAspectRatio = self->aspect_ratio;
 696
 697     GST_DEBUG_OBJECT (self, "setting aspect ratio to %d", self->aspect_ratio);
 698
 699     err =
 700         gst_omx_component_set_parameter (self->enc,
 701         (OMX_INDEXTYPE) OMX_ALG_IndexParamVideoAspectRatio, &aspect_ratio);
 702     CHECK_ERR ("aspect-ratio");
 703   }
 704
 705   {
 706     OMX_ALG_VIDEO_PARAM_FILLER_DATA filler_data;
 707
 708     GST_OMX_INIT_STRUCT (&filler_data);
 709     filler_data.nPortIndex = self->enc_out_port->index;
 710     filler_data.bDisableFillerData = !(self->filler_data);
 711
 712     GST_DEBUG_OBJECT (self, "%s filler data",
 713         self->filler_data ? "Enable" : "Disable");
 714
 715     err =
 716         gst_omx_component_set_parameter (self->enc,
 717         (OMX_INDEXTYPE) OMX_ALG_IndexParamVideoFillerData, &filler_data);
 718     CHECK_ERR ("filler-data");
 719   }
 720
 721   if (self->num_slices != GST_OMX_VIDEO_ENC_NUM_SLICES_DEFAULT ||
 722       self->slice_size != GST_OMX_VIDEO_ENC_SLICE_SIZE_DEFAULT) {
 723     OMX_ALG_VIDEO_PARAM_SLICES slices;
 724
 725     GST_OMX_INIT_STRUCT (&slices);
 726     slices.nPortIndex = self->enc_out_port->index;
 727
 728     err = gst_omx_component_get_parameter (self->enc,
 729         (OMX_INDEXTYPE) OMX_ALG_IndexParamVideoSlices, &slices);
 730     if (err != OMX_ErrorNone) {
 731       GST_WARNING_OBJECT (self, "Error getting slice parameters: %s (0x%08x)",
 732           gst_omx_error_to_string (err), err);
 733       return FALSE;
 734     }
 735
 736     if (self->num_slices != GST_OMX_VIDEO_ENC_NUM_SLICES_DEFAULT) {
 737       slices.nNumSlices = self->num_slices;
 738       GST_DEBUG_OBJECT (self,
 739           "setting number of slices to %d (dependent slices: %d)",
 740           self->num_slices, self->dependent_slice);
 741     }
 742
 743     if (self->slice_size != GST_OMX_VIDEO_ENC_SLICE_SIZE_DEFAULT) {
 744       slices.nSlicesSize = self->slice_size;
 745       GST_DEBUG_OBJECT (self, "setting slice size to %d (dependent slices: %d)",
 746           self->slice_size, self->dependent_slice);
 747     }
 748
 749     slices.bDependentSlices = self->dependent_slice;
 750
 751     err =
 752         gst_omx_component_set_parameter (self->enc,
 753         (OMX_INDEXTYPE) OMX_ALG_IndexParamVideoSlices, &slices);
 754     CHECK_ERR ("slices");
 755   }
 756
 757   return TRUE;
 758 }
 759 #endif
 760
 761 static gboolean
 762 gst_omx_video_enc_set_bitrate (GstOMXVideoEnc * self)
 763 {
 764   OMX_ERRORTYPE err;
 765   OMX_VIDEO_PARAM_BITRATETYPE bitrate_param;
 766   gboolean result = TRUE;
 767
 768   GST_OBJECT_LOCK (self);
 769
 770   GST_OMX_INIT_STRUCT (&bitrate_param);
 771   bitrate_param.nPortIndex = self->enc_out_port->index;
 772
 773   err = gst_omx_component_get_parameter (self->enc,
 774       OMX_IndexParamVideoBitrate, &bitrate_param);
 775
 776   if (err == OMX_ErrorNone) {
 777 #ifdef USE_OMX_TARGET_RPI
 778     /* FIXME: Workaround for RPi returning garbage for this parameter */
 779     if (bitrate_param.nVersion.nVersion == 0) {
 780       GST_OMX_INIT_STRUCT (&bitrate_param);
 781       bitrate_param.nPortIndex = self->enc_out_port->index;
 782     }
 783 #endif
 784     if (self->default_target_bitrate == GST_OMX_PROP_OMX_DEFAULT)
 785       /* Save the actual OMX default so we can restore it if needed */
 786       self->default_target_bitrate = bitrate_param.nTargetBitrate;
 787
 788     if (self->control_rate != 0xffffffff)
 789       bitrate_param.eControlRate = self->control_rate;
 790     if (self->target_bitrate != 0xffffffff)
 791       bitrate_param.nTargetBitrate = self->target_bitrate;
 792     else
 793       bitrate_param.nTargetBitrate = self->default_target_bitrate;
 794
 795     err =
 796         gst_omx_component_set_parameter (self->enc,
 797         OMX_IndexParamVideoBitrate, &bitrate_param);
 798     if (err == OMX_ErrorUnsupportedIndex) {
 799       GST_WARNING_OBJECT (self,
 800           "Setting a bitrate not supported by the component");
 801     } else if (err == OMX_ErrorUnsupportedSetting) {
 802       GST_WARNING_OBJECT (self,
 803           "Setting bitrate settings %u %u not supported by the component",
 804           self->control_rate, self->target_bitrate);
 805     } else if (err != OMX_ErrorNone) {
 806       GST_ERROR_OBJECT (self,
 807           "Failed to set bitrate parameters: %s (0x%08x)",
 808           gst_omx_error_to_string (err), err);
 809       result = FALSE;
 810     }
 811   } else {
 812     GST_ERROR_OBJECT (self, "Failed to get bitrate parameters: %s (0x%08x)",
 813         gst_omx_error_to_string (err), err);
 814   }
 815
 816   GST_OBJECT_UNLOCK (self);
 817   return result;
 818 }
 819
 820 static gboolean
 821 gst_omx_video_enc_open (GstVideoEncoder * encoder)
 822 {
 823   GstOMXVideoEnc *self = GST_OMX_VIDEO_ENC (encoder);
 824   GstOMXVideoEncClass *klass = GST_OMX_VIDEO_ENC_GET_CLASS (self);
 825   gint in_port_index, out_port_index;
 826
 827   self->enc =
 828       gst_omx_component_new (GST_OBJECT_CAST (self), klass->cdata.core_name,
 829       klass->cdata.component_name, klass->cdata.component_role,
 830       klass->cdata.hacks);
 831   self->started = FALSE;
 832
 833   if (!self->enc)
 834     return FALSE;
 835
 836   if (gst_omx_component_get_state (self->enc,
 837           GST_CLOCK_TIME_NONE) != OMX_StateLoaded)
 838     return FALSE;
 839
 840   in_port_index = klass->cdata.in_port_index;
 841   out_port_index = klass->cdata.out_port_index;
 842
 843   if (in_port_index == -1 || out_port_index == -1) {
 844     OMX_PORT_PARAM_TYPE param;
 845     OMX_ERRORTYPE err;
 846
 847     GST_OMX_INIT_STRUCT (&param);
 848
 849     err =
 850         gst_omx_component_get_parameter (self->enc, OMX_IndexParamVideoInit,
 851         &param);
 852     if (err != OMX_ErrorNone) {
 853       GST_WARNING_OBJECT (self, "Couldn't get port information: %s (0x%08x)",
 854           gst_omx_error_to_string (err), err);
 855       /* Fallback */
 856       in_port_index = 0;
 857       out_port_index = 1;
 858     } else {
 859       GST_DEBUG_OBJECT (self, "Detected %u ports, starting at %u",
 860           (guint) param.nPorts, (guint) param.nStartPortNumber);
 861       in_port_index = param.nStartPortNumber + 0;
 862       out_port_index = param.nStartPortNumber + 1;
 863     }
 864   }
 865
 866   self->enc_in_port = gst_omx_component_add_port (self->enc, in_port_index);
 867   self->enc_out_port = gst_omx_component_add_port (self->enc, out_port_index);
 868
 869   if (!self->enc_in_port || !self->enc_out_port)
 870     return FALSE;
 871
 872   /* Set properties */
 873   {
 874     OMX_ERRORTYPE err;
 875
 876     if (!gst_omx_video_enc_set_bitrate (self))
 877       return FALSE;
 878
 879     if (self->quant_i_frames != 0xffffffff ||
 880         self->quant_p_frames != 0xffffffff ||
 881         self->quant_b_frames != 0xffffffff) {
 882       OMX_VIDEO_PARAM_QUANTIZATIONTYPE quant_param;
 883
 884       GST_OMX_INIT_STRUCT (&quant_param);
 885       quant_param.nPortIndex = self->enc_out_port->index;
 886
 887       err = gst_omx_component_get_parameter (self->enc,
 888           OMX_IndexParamVideoQuantization, &quant_param);
 889
 890       if (err == OMX_ErrorNone) {
 891
 892         if (self->quant_i_frames != 0xffffffff)
 893           quant_param.nQpI = self->quant_i_frames;
 894         if (self->quant_p_frames != 0xffffffff)
 895           quant_param.nQpP = self->quant_p_frames;
 896         if (self->quant_b_frames != 0xffffffff)
 897           quant_param.nQpB = self->quant_b_frames;
 898
 899         err =
 900             gst_omx_component_set_parameter (self->enc,
 901             OMX_IndexParamVideoQuantization, &quant_param);
 902         if (err == OMX_ErrorUnsupportedIndex) {
 903           GST_WARNING_OBJECT (self,
 904               "Setting quantization parameters not supported by the component");
 905         } else if (err == OMX_ErrorUnsupportedSetting) {
 906           GST_WARNING_OBJECT (self,
 907               "Setting quantization parameters %u %u %u not supported by the component",
 908               self->quant_i_frames, self->quant_p_frames, self->quant_b_frames);
 909         } else if (err != OMX_ErrorNone) {
 910           GST_ERROR_OBJECT (self,
 911               "Failed to set quantization parameters: %s (0x%08x)",
 912               gst_omx_error_to_string (err), err);
 913           return FALSE;
 914         }
 915       } else {
 916         GST_ERROR_OBJECT (self,
 917             "Failed to get quantization parameters: %s (0x%08x)",
 918             gst_omx_error_to_string (err), err);
 919
 920       }
 921     }
 922   }
 923 #ifdef USE_OMX_TARGET_ZYNQ_USCALE_PLUS
 924   if (!set_zynqultrascaleplus_props (self))
 925     return FALSE;
 926 #endif
 927
 928   return TRUE;
 929 }
 930
 931 static gboolean
 932 gst_omx_video_enc_deallocate_in_buffers (GstOMXVideoEnc * self)
 933 {
 934   /* Pool will take care of deallocating buffers when deactivated upstream */
 935   if (!self->in_pool_used
 936       && gst_omx_port_deallocate_buffers (self->enc_in_port) != OMX_ErrorNone)
 937     return FALSE;
 938
 939   return TRUE;
 940 }
 941
 942 static gboolean
 943 gst_omx_video_enc_shutdown (GstOMXVideoEnc * self)
 944 {
 945   OMX_STATETYPE state;
 946
 947   GST_DEBUG_OBJECT (self, "Shutting down encoder");
 948
 949   state = gst_omx_component_get_state (self->enc, 0);
 950   if (state > OMX_StateLoaded || state == OMX_StateInvalid) {
 951     if (state > OMX_StateIdle) {
 952       gst_omx_component_set_state (self->enc, OMX_StateIdle);
 953       gst_omx_component_get_state (self->enc, 5 * GST_SECOND);
 954     }
 955     gst_omx_component_set_state (self->enc, OMX_StateLoaded);
 956     gst_omx_video_enc_deallocate_in_buffers (self);
 957     gst_omx_port_deallocate_buffers (self->enc_out_port);
 958     if (state > OMX_StateLoaded)
 959       gst_omx_component_get_state (self->enc, 5 * GST_SECOND);
 960   }
 961
 962   return TRUE;
 963 }
 964
 965 static gboolean
 966 gst_omx_video_enc_close (GstVideoEncoder * encoder)
 967 {
 968   GstOMXVideoEnc *self = GST_OMX_VIDEO_ENC (encoder);
 969
 970   GST_DEBUG_OBJECT (self, "Closing encoder");
 971
 972   if (!gst_omx_video_enc_shutdown (self))
 973     return FALSE;
 974
 975   self->enc_in_port = NULL;
 976   self->enc_out_port = NULL;
 977   if (self->enc)
 978     gst_omx_component_unref (self->enc);
 979   self->enc = NULL;
 980
 981   self->started = FALSE;
 982
 983   return TRUE;
 984 }
 985
 986 static void
 987 gst_omx_video_enc_finalize (GObject * object)
 988 {
 989   GstOMXVideoEnc *self = GST_OMX_VIDEO_ENC (object);
 990
 991   g_mutex_clear (&self->drain_lock);
 992   g_cond_clear (&self->drain_cond);
 993
 994 #ifdef USE_OMX_TARGET_ZYNQ_USCALE_PLUS
 995   g_clear_pointer (&self->alg_roi_quality_enum_class, g_type_class_unref);
 996 #endif
 997
 998   G_OBJECT_CLASS (gst_omx_video_enc_parent_class)->finalize (object);
 999 }
1000
1001 static void
1002 gst_omx_video_enc_set_property (GObject * object, guint prop_id,
1003     const GValue * value, GParamSpec * pspec)
1004 {
1005   GstOMXVideoEnc *self = GST_OMX_VIDEO_ENC (object);
1006
1007   switch (prop_id) {
1008     case PROP_CONTROL_RATE:
1009       self->control_rate = g_value_get_enum (value);
1010       break;
1011     case PROP_TARGET_BITRATE:
1012       GST_OBJECT_LOCK (self);
1013       self->target_bitrate = g_value_get_uint (value);
1014       if (self->enc) {
1015         OMX_VIDEO_CONFIG_BITRATETYPE config;
1016         OMX_ERRORTYPE err;
1017
1018         GST_OMX_INIT_STRUCT (&config);
1019         config.nPortIndex = self->enc_out_port->index;
1020         config.nEncodeBitrate = self->target_bitrate;
1021         err =
1022             gst_omx_component_set_config (self->enc,
1023             OMX_IndexConfigVideoBitrate, &config);
1024         if (err != OMX_ErrorNone)
1025           GST_ERROR_OBJECT (self,
1026               "Failed to set bitrate parameter: %s (0x%08x)",
1027               gst_omx_error_to_string (err), err);
1028       }
1029       GST_OBJECT_UNLOCK (self);
1030       break;
1031     case PROP_QUANT_I_FRAMES:
1032       self->quant_i_frames = g_value_get_uint (value);
1033       break;
1034     case PROP_QUANT_P_FRAMES:
1035       self->quant_p_frames = g_value_get_uint (value);
1036       break;
1037     case PROP_QUANT_B_FRAMES:
1038       self->quant_b_frames = g_value_get_uint (value);
1039       break;
1040 #ifdef USE_OMX_TARGET_ZYNQ_USCALE_PLUS
1041     case PROP_QP_MODE:
1042       self->qp_mode = g_value_get_enum (value);
1043       break;
1044     case PROP_MIN_QP:
1045       self->min_qp = g_value_get_uint (value);
1046       break;
1047     case PROP_MAX_QP:
1048       self->max_qp = g_value_get_uint (value);
1049       break;
1050     case PROP_GOP_MODE:
1051       self->gop_mode = g_value_get_enum (value);
1052       break;
1053     case PROP_GDR_MODE:
1054       self->gdr_mode = g_value_get_enum (value);
1055       break;
1056     case PROP_INITIAL_DELAY:
1057       self->initial_delay = g_value_get_uint (value);
1058       break;
1059     case PROP_CPB_SIZE:
1060       self->cpb_size = g_value_get_uint (value);
1061       break;
1062     case PROP_SCALING_LIST:
1063       self->scaling_list = g_value_get_enum (value);
1064       break;
1065     case PROP_LOW_BANDWIDTH:
1066       self->low_bandwidth = g_value_get_boolean (value);
1067       break;
1068     case PROP_MAX_BITRATE:
1069       self->max_bitrate = g_value_get_uint (value);
1070       break;
1071     case PROP_ASPECT_RATIO:
1072       self->aspect_ratio = g_value_get_enum (value);
1073       break;
1074     case PROP_FILLER_DATA:
1075       self->filler_data = g_value_get_boolean (value);
1076       break;
1077     case PROP_NUM_SLICES:
1078       self->num_slices = g_value_get_uint (value);
1079       break;
1080     case PROP_SLICE_SIZE:
1081       self->slice_size = g_value_get_uint (value);
1082       break;
1083     case PROP_DEPENDENT_SLICE:
1084       self->dependent_slice = g_value_get_boolean (value);
1085       break;
1086     case PROP_DEFAULT_ROI_QUALITY:
1087       self->default_roi_quality = g_value_get_enum (value);
1088       break;
1089 #endif
1090     default:
1091       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1092       break;
1093   }
1094 }
1095
1096 static void
1097 gst_omx_video_enc_get_property (GObject * object, guint prop_id, GValue * value,
1098     GParamSpec * pspec)
1099 {
1100   GstOMXVideoEnc *self = GST_OMX_VIDEO_ENC (object);
1101
1102   switch (prop_id) {
1103     case PROP_CONTROL_RATE:
1104       g_value_set_enum (value, self->control_rate);
1105       break;
1106     case PROP_TARGET_BITRATE:
1107       GST_OBJECT_LOCK (self);
1108       g_value_set_uint (value, self->target_bitrate);
1109       GST_OBJECT_UNLOCK (self);
1110       break;
1111     case PROP_QUANT_I_FRAMES:
1112       g_value_set_uint (value, self->quant_i_frames);
1113       break;
1114     case PROP_QUANT_P_FRAMES:
1115       g_value_set_uint (value, self->quant_p_frames);
1116       break;
1117     case PROP_QUANT_B_FRAMES:
1118       g_value_set_uint (value, self->quant_b_frames);
1119       break;
1120 #ifdef USE_OMX_TARGET_ZYNQ_USCALE_PLUS
1121     case PROP_QP_MODE:
1122       g_value_set_enum (value, self->qp_mode);
1123       break;
1124     case PROP_MIN_QP:
1125       g_value_set_uint (value, self->min_qp);
1126       break;
1127     case PROP_MAX_QP:
1128       g_value_set_uint (value, self->max_qp);
1129       break;
1130     case PROP_GOP_MODE:
1131       g_value_set_enum (value, self->gop_mode);
1132       break;
1133     case PROP_GDR_MODE:
1134       g_value_set_enum (value, self->gdr_mode);
1135       break;
1136     case PROP_INITIAL_DELAY:
1137       g_value_set_uint (value, self->initial_delay);
1138       break;
1139     case PROP_CPB_SIZE:
1140       g_value_set_uint (value, self->cpb_size);
1141       break;
1142     case PROP_SCALING_LIST:
1143       g_value_set_enum (value, self->scaling_list);
1144       break;
1145     case PROP_LOW_BANDWIDTH:
1146       g_value_set_boolean (value, self->low_bandwidth);
1147       break;
1148     case PROP_MAX_BITRATE:
1149       g_value_set_uint (value, self->max_bitrate);
1150       break;
1151     case PROP_ASPECT_RATIO:
1152       g_value_set_enum (value, self->aspect_ratio);
1153       break;
1154     case PROP_FILLER_DATA:
1155       g_value_set_boolean (value, self->filler_data);
1156       break;
1157     case PROP_NUM_SLICES:
1158       g_value_set_uint (value, self->num_slices);
1159       break;
1160     case PROP_SLICE_SIZE:
1161       g_value_set_uint (value, self->slice_size);
1162       break;
1163     case PROP_DEPENDENT_SLICE:
1164       g_value_set_boolean (value, self->dependent_slice);
1165       break;
1166     case PROP_DEFAULT_ROI_QUALITY:
1167       g_value_set_enum (value, self->default_roi_quality);
1168       break;
1169 #endif
1170     default:
1171       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1172       break;
1173   }
1174 }
1175
1176 static GstStateChangeReturn
1177 gst_omx_video_enc_change_state (GstElement * element, GstStateChange transition)
1178 {
1179   GstOMXVideoEnc *self;
1180   GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
1181
1182   g_return_val_if_fail (GST_IS_OMX_VIDEO_ENC (element),
1183       GST_STATE_CHANGE_FAILURE);
1184   self = GST_OMX_VIDEO_ENC (element);
1185
1186   switch (transition) {
1187     case GST_STATE_CHANGE_NULL_TO_READY:
1188       break;
1189     case GST_STATE_CHANGE_READY_TO_PAUSED:
1190       self->downstream_flow_ret = GST_FLOW_OK;
1191
1192       self->draining = FALSE;
1193       self->started = FALSE;
1194       break;
1195     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
1196       break;
1197     case GST_STATE_CHANGE_PAUSED_TO_READY:
1198       if (self->enc_in_port)
1199         gst_omx_port_set_flushing (self->enc_in_port, 5 * GST_SECOND, TRUE);
1200       if (self->enc_out_port)
1201         gst_omx_port_set_flushing (self->enc_out_port, 5 * GST_SECOND, TRUE);
1202
1203       g_mutex_lock (&self->drain_lock);
1204       self->draining = FALSE;
1205       g_cond_broadcast (&self->drain_cond);
1206       g_mutex_unlock (&self->drain_lock);
1207       break;
1208     default:
1209       break;
1210   }
1211
1212   if (ret == GST_STATE_CHANGE_FAILURE)
1213     return ret;
1214
1215   ret =
1216       GST_ELEMENT_CLASS (gst_omx_video_enc_parent_class)->change_state (element,
1217       transition);
1218
1219   if (ret == GST_STATE_CHANGE_FAILURE)
1220     return ret;
1221
1222   switch (transition) {
1223     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
1224       break;
1225     case GST_STATE_CHANGE_PAUSED_TO_READY:
1226       self->downstream_flow_ret = GST_FLOW_FLUSHING;
1227       self->started = FALSE;
1228       break;
1229     case GST_STATE_CHANGE_READY_TO_NULL:
1230       break;
1231     default:
1232       break;
1233   }
1234
1235   return ret;
1236 }
1237
1238 static gboolean
1239 get_chroma_info_from_input (GstOMXVideoEnc * self, const gchar ** chroma_format,
1240     guint * bit_depth_luma, guint * bit_depth_chroma)
1241 {
1242   switch (self->input_state->info.finfo->format) {
1243     case GST_VIDEO_FORMAT_GRAY8:
1244       *chroma_format = "4:0:0";
1245       *bit_depth_luma = 8;
1246       *bit_depth_chroma = 0;
1247       break;
1248     case GST_VIDEO_FORMAT_I420:
1249     case GST_VIDEO_FORMAT_NV12:
1250       *chroma_format = "4:2:0";
1251       *bit_depth_luma = *bit_depth_chroma = 8;
1252       break;
1253     case GST_VIDEO_FORMAT_NV16:
1254     case GST_VIDEO_FORMAT_YUY2:
1255     case GST_VIDEO_FORMAT_YVYU:
1256     case GST_VIDEO_FORMAT_UYVY:
1257       *chroma_format = "4:2:2";
1258       *bit_depth_luma = *bit_depth_chroma = 8;
1259       break;
1260     case GST_VIDEO_FORMAT_GRAY10_LE32:
1261       *chroma_format = "4:0:0";
1262       *bit_depth_luma = 10;
1263       *bit_depth_chroma = 0;
1264       break;
1265     case GST_VIDEO_FORMAT_NV12_10LE32:
1266       *chroma_format = "4:2:0";
1267       *bit_depth_luma = *bit_depth_chroma = 10;
1268       break;
1269     case GST_VIDEO_FORMAT_NV16_10LE32:
1270       *chroma_format = "4:2:2";
1271       *bit_depth_luma = *bit_depth_chroma = 10;
1272       break;
1273     default:
1274       return FALSE;
1275   }
1276
1277   return TRUE;
1278 }
1279
1280 static GstCaps *
1281 get_output_caps (GstOMXVideoEnc * self)
1282 {
1283   GstOMXVideoEncClass *klass = GST_OMX_VIDEO_ENC_GET_CLASS (self);
1284   GstCaps *caps;
1285   const gchar *chroma_format;
1286   guint bit_depth_luma, bit_depth_chroma;
1287
1288   caps = klass->get_caps (self, self->enc_out_port, self->input_state);
1289
1290   /* Add chroma info about the encoded stream inferred from the format of the input */
1291   if (get_chroma_info_from_input (self, &chroma_format, &bit_depth_luma,
1292           &bit_depth_chroma)) {
1293     GST_DEBUG_OBJECT (self,
1294         "adding chroma info to output caps: %s (luma %d bits) (chroma %d bits)",
1295         chroma_format, bit_depth_luma, bit_depth_chroma);
1296
1297     gst_caps_set_simple (caps, "chroma-format", G_TYPE_STRING, chroma_format,
1298         "bit-depth-luma", G_TYPE_UINT, bit_depth_luma,
1299         "bit-depth-chroma", G_TYPE_UINT, bit_depth_chroma, NULL);
1300   }
1301
1302   return caps;
1303 }
1304
1305 static GstFlowReturn
1306 gst_omx_video_enc_handle_output_frame (GstOMXVideoEnc * self, GstOMXPort * port,
1307     GstOMXBuffer * buf, GstVideoCodecFrame * frame)
1308 {
1309   GstOMXVideoEncClass *klass = GST_OMX_VIDEO_ENC_GET_CLASS (self);
1310   GstFlowReturn flow_ret = GST_FLOW_OK;
1311
1312   if ((buf->omx_buf->nFlags & OMX_BUFFERFLAG_CODECCONFIG)
1313       && buf->omx_buf->nFilledLen > 0) {
1314     GstVideoCodecState *state;
1315     GstBuffer *codec_data;
1316     GstMapInfo map = GST_MAP_INFO_INIT;
1317     GstCaps *caps;
1318
1319     GST_DEBUG_OBJECT (self, "Handling codec data");
1320
1321     caps = get_output_caps (self);
1322     codec_data = gst_buffer_new_and_alloc (buf->omx_buf->nFilledLen);
1323
1324     gst_buffer_map (codec_data, &map, GST_MAP_WRITE);
1325     memcpy (map.data,
1326         buf->omx_buf->pBuffer + buf->omx_buf->nOffset,
1327         buf->omx_buf->nFilledLen);
1328     gst_buffer_unmap (codec_data, &map);
1329     state =
1330         gst_video_encoder_set_output_state (GST_VIDEO_ENCODER (self), caps,
1331         self->input_state);
1332     state->codec_data = codec_data;
1333     gst_video_codec_state_unref (state);
1334     if (!gst_video_encoder_negotiate (GST_VIDEO_ENCODER (self))) {
1335       gst_video_codec_frame_unref (frame);
1336       GST_ERROR_OBJECT (self,
1337           "Downstream element refused to negotiate codec_data in the caps");
1338       return GST_FLOW_NOT_NEGOTIATED;
1339     }
1340     gst_video_codec_frame_unref (frame);
1341     flow_ret = GST_FLOW_OK;
1342   } else if (buf->omx_buf->nFilledLen > 0) {
1343     GstBuffer *outbuf;
1344     GstMapInfo map = GST_MAP_INFO_INIT;
1345
1346     GST_DEBUG_OBJECT (self, "Handling output data");
1347
1348     outbuf = gst_buffer_new_and_alloc (buf->omx_buf->nFilledLen);
1349
1350     gst_buffer_map (outbuf, &map, GST_MAP_WRITE);
1351     memcpy (map.data,
1352         buf->omx_buf->pBuffer + buf->omx_buf->nOffset,
1353         buf->omx_buf->nFilledLen);
1354     gst_buffer_unmap (outbuf, &map);
1355
1356     GST_BUFFER_TIMESTAMP (outbuf) =
1357         gst_util_uint64_scale (GST_OMX_GET_TICKS (buf->omx_buf->nTimeStamp),
1358         GST_SECOND, OMX_TICKS_PER_SECOND);
1359     if (buf->omx_buf->nTickCount != 0)
1360       GST_BUFFER_DURATION (outbuf) =
1361           gst_util_uint64_scale (buf->omx_buf->nTickCount, GST_SECOND,
1362           OMX_TICKS_PER_SECOND);
1363
1364     if ((klass->cdata.hacks & GST_OMX_HACK_SYNCFRAME_FLAG_NOT_USED)
1365         || (buf->omx_buf->nFlags & OMX_BUFFERFLAG_SYNCFRAME)) {
1366       if (frame)
1367         GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (frame);
1368       else
1369         GST_BUFFER_FLAG_UNSET (outbuf, GST_BUFFER_FLAG_DELTA_UNIT);
1370     } else {
1371       if (frame)
1372         GST_VIDEO_CODEC_FRAME_UNSET_SYNC_POINT (frame);
1373       else
1374         GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DELTA_UNIT);
1375     }
1376
1377     if (frame) {
1378       frame->output_buffer = outbuf;
1379       flow_ret =
1380           gst_video_encoder_finish_frame (GST_VIDEO_ENCODER (self), frame);
1381     } else {
1382       GST_ERROR_OBJECT (self, "No corresponding frame found");
1383       flow_ret = gst_pad_push (GST_VIDEO_ENCODER_SRC_PAD (self), outbuf);
1384     }
1385   } else if (frame != NULL) {
1386     /* Just ignore empty buffers, don't drop a frame for that */
1387     flow_ret = GST_FLOW_OK;
1388     gst_video_codec_frame_unref (frame);
1389   }
1390
1391   return flow_ret;
1392 }
1393
1394 static gboolean
1395 gst_omx_video_enc_ensure_nb_out_buffers (GstOMXVideoEnc * self)
1396 {
1397   GstOMXVideoEncClass *klass = GST_OMX_VIDEO_ENC_GET_CLASS (self);
1398   guint extra = 0;
1399
1400   if (!(klass->cdata.hacks & GST_OMX_HACK_ENSURE_BUFFER_COUNT_ACTUAL))
1401     return TRUE;
1402
1403   /* If dowstream tell us how many buffers it needs allocate as many extra buffers so we won't starve
1404    * if it keeps them downstream (like when using dynamic mode). */
1405   if (self->nb_downstream_buffers)
1406     extra = self->nb_downstream_buffers;
1407
1408   if (!gst_omx_port_ensure_buffer_count_actual (self->enc_out_port, extra))
1409     return FALSE;
1410
1411   return TRUE;
1412 }
1413
1414 static void
1415 gst_omx_video_enc_pause_loop (GstOMXVideoEnc * self, GstFlowReturn flow_ret)
1416 {
1417   g_mutex_lock (&self->drain_lock);
1418   if (self->draining) {
1419     self->draining = FALSE;
1420     g_cond_broadcast (&self->drain_cond);
1421   }
1422   gst_pad_pause_task (GST_VIDEO_ENCODER_SRC_PAD (self));
1423   self->downstream_flow_ret = flow_ret;
1424   self->started = FALSE;
1425   g_mutex_unlock (&self->drain_lock);
1426 }
1427
1428 static void
1429 gst_omx_video_enc_loop (GstOMXVideoEnc * self)
1430 {
1431   GstOMXVideoEncClass *klass;
1432   GstOMXPort *port = self->enc_out_port;
1433   GstOMXBuffer *buf = NULL;
1434   GstVideoCodecFrame *frame;
1435   GstFlowReturn flow_ret = GST_FLOW_OK;
1436   GstOMXAcquireBufferReturn acq_return;
1437   OMX_ERRORTYPE err;
1438
1439   klass = GST_OMX_VIDEO_ENC_GET_CLASS (self);
1440
1441   acq_return = gst_omx_port_acquire_buffer (port, &buf, GST_OMX_WAIT);
1442   if (acq_return == GST_OMX_ACQUIRE_BUFFER_ERROR) {
1443     goto component_error;
1444   } else if (acq_return == GST_OMX_ACQUIRE_BUFFER_FLUSHING) {
1445     goto flushing;
1446   } else if (acq_return == GST_OMX_ACQUIRE_BUFFER_EOS) {
1447     goto eos;
1448   }
1449
1450   if (!gst_pad_has_current_caps (GST_VIDEO_ENCODER_SRC_PAD (self))
1451       || acq_return == GST_OMX_ACQUIRE_BUFFER_RECONFIGURE) {
1452     GstCaps *caps;
1453     GstVideoCodecState *state;
1454
1455     GST_DEBUG_OBJECT (self, "Port settings have changed, updating caps");
1456
1457     if (acq_return == GST_OMX_ACQUIRE_BUFFER_RECONFIGURE
1458         && gst_omx_port_is_enabled (port)) {
1459       /* Reallocate all buffers */
1460       err = gst_omx_port_set_enabled (port, FALSE);
1461       if (err != OMX_ErrorNone)
1462         goto reconfigure_error;
1463
1464       err = gst_omx_port_wait_buffers_released (port, 5 * GST_SECOND);
1465       if (err != OMX_ErrorNone)
1466         goto reconfigure_error;
1467
1468       err = gst_omx_port_deallocate_buffers (port);
1469       if (err != OMX_ErrorNone)
1470         goto reconfigure_error;
1471
1472       err = gst_omx_port_wait_enabled (port, 1 * GST_SECOND);
1473       if (err != OMX_ErrorNone)
1474         goto reconfigure_error;
1475     }
1476
1477     GST_VIDEO_ENCODER_STREAM_LOCK (self);
1478
1479     caps = get_output_caps (self);
1480     if (!caps) {
1481       if (buf)
1482         gst_omx_port_release_buffer (self->enc_out_port, buf);
1483       GST_VIDEO_ENCODER_STREAM_UNLOCK (self);
1484       goto caps_failed;
1485     }
1486
1487     GST_DEBUG_OBJECT (self, "Setting output state: %" GST_PTR_FORMAT, caps);
1488
1489     state =
1490         gst_video_encoder_set_output_state (GST_VIDEO_ENCODER (self), caps,
1491         self->input_state);
1492     gst_video_codec_state_unref (state);
1493
1494     if (!gst_video_encoder_negotiate (GST_VIDEO_ENCODER (self))) {
1495       if (buf)
1496         gst_omx_port_release_buffer (self->enc_out_port, buf);
1497       GST_VIDEO_ENCODER_STREAM_UNLOCK (self);
1498       goto caps_failed;
1499     }
1500
1501     GST_VIDEO_ENCODER_STREAM_UNLOCK (self);
1502
1503     if (acq_return == GST_OMX_ACQUIRE_BUFFER_RECONFIGURE) {
1504       if (!gst_omx_video_enc_ensure_nb_out_buffers (self))
1505         goto reconfigure_error;
1506
1507       err = gst_omx_port_set_enabled (port, TRUE);
1508       if (err != OMX_ErrorNone)
1509         goto reconfigure_error;
1510
1511       err = gst_omx_port_allocate_buffers (port);
1512       if (err != OMX_ErrorNone)
1513         goto reconfigure_error;
1514
1515       err = gst_omx_port_wait_enabled (port, 5 * GST_SECOND);
1516       if (err != OMX_ErrorNone)
1517         goto reconfigure_error;
1518
1519       err = gst_omx_port_populate (port);
1520       if (err != OMX_ErrorNone)
1521         goto reconfigure_error;
1522
1523       err = gst_omx_port_mark_reconfigured (port);
1524       if (err != OMX_ErrorNone)
1525         goto reconfigure_error;
1526     }
1527
1528     /* Now get a buffer */
1529     if (acq_return != GST_OMX_ACQUIRE_BUFFER_OK) {
1530       return;
1531     }
1532   }
1533
1534   g_assert (acq_return == GST_OMX_ACQUIRE_BUFFER_OK);
1535
1536   /* This prevents a deadlock between the srcpad stream
1537    * lock and the videocodec stream lock, if ::flush()
1538    * is called at the wrong time
1539    */
1540   if (gst_omx_port_is_flushing (self->enc_out_port)) {
1541     GST_DEBUG_OBJECT (self, "Flushing");
1542     gst_omx_port_release_buffer (self->enc_out_port, buf);
1543     goto flushing;
1544   }
1545
1546   GST_DEBUG_OBJECT (self, "Handling buffer: 0x%08x (%s) %" G_GUINT64_FORMAT,
1547       (guint) buf->omx_buf->nFlags,
1548       gst_omx_buffer_flags_to_string (buf->omx_buf->nFlags),
1549       (guint64) GST_OMX_GET_TICKS (buf->omx_buf->nTimeStamp));
1550
1551   frame = gst_omx_video_find_nearest_frame (GST_ELEMENT_CAST (self), buf,
1552       gst_video_encoder_get_frames (GST_VIDEO_ENCODER (self)));
1553
1554   g_assert (klass->handle_output_frame);
1555   flow_ret = klass->handle_output_frame (self, self->enc_out_port, buf, frame);
1556
1557   GST_DEBUG_OBJECT (self, "Finished frame: %s", gst_flow_get_name (flow_ret));
1558
1559   err = gst_omx_port_release_buffer (port, buf);
1560   if (err != OMX_ErrorNone)
1561     goto release_error;
1562
1563   GST_VIDEO_ENCODER_STREAM_LOCK (self);
1564   self->downstream_flow_ret = flow_ret;
1565   GST_VIDEO_ENCODER_STREAM_UNLOCK (self);
1566
1567   GST_DEBUG_OBJECT (self, "Read frame from component");
1568
1569   if (flow_ret != GST_FLOW_OK)
1570     goto flow_error;
1571
1572   return;
1573
1574 component_error:
1575   {
1576     GST_ELEMENT_ERROR (self, LIBRARY, FAILED, (NULL),
1577         ("OpenMAX component in error state %s (0x%08x)",
1578             gst_omx_component_get_last_error_string (self->enc),
1579             gst_omx_component_get_last_error (self->enc)));
1580     gst_pad_push_event (GST_VIDEO_ENCODER_SRC_PAD (self), gst_event_new_eos ());
1581     gst_omx_video_enc_pause_loop (self, GST_FLOW_ERROR);
1582     return;
1583   }
1584 flushing:
1585   {
1586     GST_DEBUG_OBJECT (self, "Flushing -- stopping task");
1587     gst_omx_video_enc_pause_loop (self, GST_FLOW_FLUSHING);
1588     return;
1589   }
1590
1591 eos:
1592   {
1593     g_mutex_lock (&self->drain_lock);
1594     if (self->draining) {
1595       GST_DEBUG_OBJECT (self, "Drained");
1596       self->draining = FALSE;
1597       g_cond_broadcast (&self->drain_cond);
1598       flow_ret = GST_FLOW_OK;
1599       gst_pad_pause_task (GST_VIDEO_ENCODER_SRC_PAD (self));
1600     } else {
1601       GST_DEBUG_OBJECT (self, "Component signalled EOS");
1602       flow_ret = GST_FLOW_EOS;
1603     }
1604     g_mutex_unlock (&self->drain_lock);
1605
1606     GST_VIDEO_ENCODER_STREAM_LOCK (self);
1607     self->downstream_flow_ret = flow_ret;
1608     GST_VIDEO_ENCODER_STREAM_UNLOCK (self);
1609
1610     /* Here we fallback and pause the task for the EOS case */
1611     if (flow_ret != GST_FLOW_OK)
1612       goto flow_error;
1613
1614     return;
1615   }
1616 flow_error:
1617   {
1618     if (flow_ret == GST_FLOW_EOS) {
1619       GST_DEBUG_OBJECT (self, "EOS");
1620
1621       gst_pad_push_event (GST_VIDEO_ENCODER_SRC_PAD (self),
1622           gst_event_new_eos ());
1623     } else if (flow_ret < GST_FLOW_EOS) {
1624       GST_ELEMENT_ERROR (self, STREAM, FAILED, ("Internal data stream error."),
1625           ("stream stopped, reason %s", gst_flow_get_name (flow_ret)));
1626
1627       gst_pad_push_event (GST_VIDEO_ENCODER_SRC_PAD (self),
1628           gst_event_new_eos ());
1629     } else if (flow_ret == GST_FLOW_FLUSHING) {
1630       GST_DEBUG_OBJECT (self, "Flushing -- stopping task");
1631     }
1632     gst_omx_video_enc_pause_loop (self, flow_ret);
1633     return;
1634   }
1635 reconfigure_error:
1636   {
1637     GST_ELEMENT_ERROR (self, LIBRARY, SETTINGS, (NULL),
1638         ("Unable to reconfigure output port"));
1639     gst_pad_push_event (GST_VIDEO_ENCODER_SRC_PAD (self), gst_event_new_eos ());
1640     gst_omx_video_enc_pause_loop (self, GST_FLOW_NOT_NEGOTIATED);
1641     return;
1642   }
1643 caps_failed:
1644   {
1645     GST_ELEMENT_ERROR (self, LIBRARY, SETTINGS, (NULL), ("Failed to set caps"));
1646     gst_pad_push_event (GST_VIDEO_ENCODER_SRC_PAD (self), gst_event_new_eos ());
1647     gst_omx_video_enc_pause_loop (self, GST_FLOW_NOT_NEGOTIATED);
1648     return;
1649   }
1650 release_error:
1651   {
1652     GST_ELEMENT_ERROR (self, LIBRARY, SETTINGS, (NULL),
1653         ("Failed to relase output buffer to component: %s (0x%08x)",
1654             gst_omx_error_to_string (err), err));
1655     gst_pad_push_event (GST_VIDEO_ENCODER_SRC_PAD (self), gst_event_new_eos ());
1656     gst_omx_video_enc_pause_loop (self, GST_FLOW_ERROR);
1657     return;
1658   }
1659 }
1660
1661 static gboolean
1662 gst_omx_video_enc_start (GstVideoEncoder * encoder)
1663 {
1664   GstOMXVideoEnc *self;
1665
1666   self = GST_OMX_VIDEO_ENC (encoder);
1667
1668   self->last_upstream_ts = 0;
1669   self->downstream_flow_ret = GST_FLOW_OK;
1670   self->nb_downstream_buffers = 0;
1671   self->in_pool_used = FALSE;
1672
1673   return TRUE;
1674 }
1675
1676 static gboolean
1677 gst_omx_video_enc_stop (GstVideoEncoder * encoder)
1678 {
1679   GstOMXVideoEnc *self;
1680
1681   self = GST_OMX_VIDEO_ENC (encoder);
1682
1683   GST_DEBUG_OBJECT (self, "Stopping encoder");
1684
1685   gst_omx_port_set_flushing (self->enc_in_port, 5 * GST_SECOND, TRUE);
1686   gst_omx_port_set_flushing (self->enc_out_port, 5 * GST_SECOND, TRUE);
1687
1688   gst_pad_stop_task (GST_VIDEO_ENCODER_SRC_PAD (encoder));
1689
1690   if (gst_omx_component_get_state (self->enc, 0) > OMX_StateIdle)
1691     gst_omx_component_set_state (self->enc, OMX_StateIdle);
1692
1693   self->downstream_flow_ret = GST_FLOW_FLUSHING;
1694   self->started = FALSE;
1695
1696   if (self->input_state)
1697     gst_video_codec_state_unref (self->input_state);
1698   self->input_state = NULL;
1699
1700   g_mutex_lock (&self->drain_lock);
1701   self->draining = FALSE;
1702   g_cond_broadcast (&self->drain_cond);
1703   g_mutex_unlock (&self->drain_lock);
1704
1705   self->default_target_bitrate = GST_OMX_PROP_OMX_DEFAULT;
1706
1707   gst_omx_component_get_state (self->enc, 5 * GST_SECOND);
1708
1709   return TRUE;
1710 }
1711
1712 #ifdef USE_OMX_TARGET_ZYNQ_USCALE_PLUS
1713 static void
1714 gst_omx_video_enc_set_latency (GstOMXVideoEnc * self)
1715 {
1716   GstClockTime latency;
1717   OMX_ALG_PARAM_REPORTED_LATENCY param;
1718   OMX_ERRORTYPE err;
1719
1720   GST_OMX_INIT_STRUCT (&param);
1721   err =
1722       gst_omx_component_get_parameter (self->enc,
1723       (OMX_INDEXTYPE) OMX_ALG_IndexParamReportedLatency, &param);
1724
1725   if (err != OMX_ErrorNone) {
1726     GST_WARNING_OBJECT (self, "Couldn't retrieve latency: %s (0x%08x)",
1727         gst_omx_error_to_string (err), err);
1728     return;
1729   }
1730
1731   GST_DEBUG_OBJECT (self, "retrieved latency of %d ms",
1732       (guint32) param.nLatency);
1733
1734   /* Convert to ns */
1735   latency = param.nLatency * GST_MSECOND;
1736
1737   gst_video_encoder_set_latency (GST_VIDEO_ENCODER (self), latency, latency);
1738 }
1739 #endif
1740
1741 static gboolean
1742 gst_omx_video_enc_disable (GstOMXVideoEnc * self)
1743 {
1744   GstOMXVideoEncClass *klass;
1745
1746   klass = GST_OMX_VIDEO_ENC_GET_CLASS (self);
1747
1748   GST_DEBUG_OBJECT (self, "Need to disable and drain encoder");
1749   gst_omx_video_enc_drain (self);
1750   gst_omx_port_set_flushing (self->enc_out_port, 5 * GST_SECOND, TRUE);
1751
1752   /* Wait until the srcpad loop is finished,
1753    * unlock GST_VIDEO_ENCODER_STREAM_LOCK to prevent deadlocks
1754    * caused by using this lock from inside the loop function */
1755   GST_VIDEO_ENCODER_STREAM_UNLOCK (self);
1756   gst_pad_stop_task (GST_VIDEO_ENCODER_SRC_PAD (self));
1757   GST_VIDEO_ENCODER_STREAM_LOCK (self);
1758
1759   if (klass->cdata.hacks & GST_OMX_HACK_NO_COMPONENT_RECONFIGURE) {
1760     GST_VIDEO_ENCODER_STREAM_UNLOCK (self);
1761     gst_omx_video_enc_stop (GST_VIDEO_ENCODER (self));
1762     gst_omx_video_enc_close (GST_VIDEO_ENCODER (self));
1763     GST_VIDEO_ENCODER_STREAM_LOCK (self);
1764
1765     if (!gst_omx_video_enc_open (GST_VIDEO_ENCODER (self)))
1766       return FALSE;
1767
1768     /* The decoder is returned to initial state */
1769     self->disabled = FALSE;
1770   } else {
1771     /* Disabling at the same time input port and output port is only
1772      * required when a buffer is shared between the ports. This cannot
1773      * be the case for a encoder because its input and output buffers
1774      * are of different nature. So let's disable ports sequencially.
1775      * Starting from IL 1.2.0, this point has been clarified.
1776      * OMX_SendCommand will return an error if the IL client attempts to
1777      * call it when there is already an on-going command being processed.
1778      * The exception is for buffer sharing above and the event
1779      * OMX_EventPortNeedsDisable will be sent to request disabling the
1780      * other port at the same time. */
1781     if (gst_omx_port_set_enabled (self->enc_in_port, FALSE) != OMX_ErrorNone)
1782       return FALSE;
1783     if (gst_omx_port_wait_buffers_released (self->enc_in_port,
1784             5 * GST_SECOND) != OMX_ErrorNone)
1785       return FALSE;
1786     if (!gst_omx_video_enc_deallocate_in_buffers (self))
1787       return FALSE;
1788     if (gst_omx_port_wait_enabled (self->enc_in_port,
1789             1 * GST_SECOND) != OMX_ErrorNone)
1790       return FALSE;
1791
1792     if (gst_omx_port_set_enabled (self->enc_out_port, FALSE) != OMX_ErrorNone)
1793       return FALSE;
1794     if (gst_omx_port_wait_buffers_released (self->enc_out_port,
1795             1 * GST_SECOND) != OMX_ErrorNone)
1796       return FALSE;
1797     if (gst_omx_port_deallocate_buffers (self->enc_out_port) != OMX_ErrorNone)
1798       return FALSE;
1799     if (gst_omx_port_wait_enabled (self->enc_out_port,
1800             1 * GST_SECOND) != OMX_ErrorNone)
1801       return FALSE;
1802
1803     self->disabled = TRUE;
1804   }
1805
1806   GST_DEBUG_OBJECT (self, "Encoder drained and disabled");
1807   return TRUE;
1808 }
1809
1810 static gboolean
1811 gst_omx_video_enc_configure_input_buffer (GstOMXVideoEnc * self,
1812     GstBuffer * input)
1813 {
1814   GstOMXVideoEncClass *klass = GST_OMX_VIDEO_ENC_GET_CLASS (self);
1815   GstVideoInfo *info = &self->input_state->info;
1816   OMX_PARAM_PORTDEFINITIONTYPE port_def;
1817   GstVideoMeta *meta;
1818   guint stride, slice_height;
1819
1820   gst_omx_port_get_port_definition (self->enc_in_port, &port_def);
1821
1822   meta = gst_buffer_get_video_meta (input);
1823   if (meta) {
1824     /* Use the stride and slice height of the first plane */
1825     stride = meta->stride[0];
1826     g_assert (stride != 0);
1827     slice_height = (meta->offset[1] - meta->offset[0]) / stride;
1828
1829     GST_DEBUG_OBJECT (self,
1830         "adjusting stride (%d) and slice-height (%d) using input buffer meta",
1831         stride, slice_height);
1832   } else {
1833     GST_WARNING_OBJECT (self,
1834         "input buffer doesn't provide video meta, can't adjust stride and slice height");
1835
1836     stride = info->stride[0];
1837     slice_height = info->height;
1838   }
1839
1840   if (port_def.nBufferAlignment)
1841     port_def.format.video.nStride =
1842         GST_ROUND_UP_N (stride, port_def.nBufferAlignment);
1843   else
1844     port_def.format.video.nStride = GST_ROUND_UP_4 (stride);    /* safe (?) default */
1845
1846   if (klass->cdata.hacks & GST_OMX_HACK_HEIGHT_MULTIPLE_16)
1847     port_def.format.video.nSliceHeight = GST_ROUND_UP_16 (slice_height);
1848   else
1849     port_def.format.video.nSliceHeight = slice_height;
1850
1851   switch (port_def.format.video.eColorFormat) {
1852     case OMX_COLOR_FormatYUV420Planar:
1853     case OMX_COLOR_FormatYUV420PackedPlanar:
1854 #ifdef USE_OMX_TARGET_ZYNQ_USCALE_PLUS
1855       /* Formats defined in extensions have their own enum so disable to -Wswitch warning */
1856 #pragma GCC diagnostic push
1857 #pragma GCC diagnostic ignored "-Wswitch"
1858     case OMX_ALG_COLOR_FormatYUV420SemiPlanar10bitPacked:
1859 #pragma GCC diagnostic pop
1860 #endif
1861       port_def.nBufferSize =
1862           (port_def.format.video.nStride * port_def.format.video.nFrameHeight) +
1863           2 * ((port_def.format.video.nStride / 2) *
1864           ((port_def.format.video.nFrameHeight + 1) / 2));
1865       break;
1866
1867     case OMX_COLOR_FormatYUV420PackedSemiPlanar:
1868     case OMX_COLOR_FormatYUV420SemiPlanar:
1869       port_def.nBufferSize =
1870           (port_def.format.video.nStride * port_def.format.video.nFrameHeight) +
1871           (port_def.format.video.nStride *
1872           ((port_def.format.video.nFrameHeight + 1) / 2));
1873       break;
1874
1875     case OMX_COLOR_FormatYUV422SemiPlanar:
1876 #ifdef USE_OMX_TARGET_ZYNQ_USCALE_PLUS
1877       /* Formats defined in extensions have their own enum so disable to -Wswitch warning */
1878 #pragma GCC diagnostic push
1879 #pragma GCC diagnostic ignored "-Wswitch"
1880     case OMX_ALG_COLOR_FormatYUV422SemiPlanar10bitPacked:
1881 #pragma GCC diagnostic pop
1882 #endif
1883       port_def.nBufferSize =
1884           (port_def.format.video.nStride * port_def.format.video.nFrameHeight) +
1885           2 * (port_def.format.video.nStride *
1886           ((port_def.format.video.nFrameHeight + 1) / 2));
1887       break;
1888
1889     default:
1890       GST_ERROR_OBJECT (self, "Unsupported port format %x",
1891           port_def.format.video.eColorFormat);
1892       g_assert_not_reached ();
1893   }
1894
1895   GST_DEBUG_OBJECT (self,
1896       "setting input nStride=%d nSliceHeight=%d nBufferSize=%d (nBufferAlignment=%d)",
1897       (guint) port_def.format.video.nStride,
1898       (guint) port_def.format.video.nSliceHeight,
1899       (guint) port_def.nBufferSize, (guint) port_def.nBufferAlignment);
1900
1901   if (gst_omx_port_update_port_definition (self->enc_in_port,
1902           &port_def) != OMX_ErrorNone)
1903     return FALSE;
1904
1905   return TRUE;
1906 }
1907
1908 static gboolean
1909 gst_omx_video_enc_ensure_nb_in_buffers (GstOMXVideoEnc * self)
1910 {
1911   GstOMXVideoEncClass *klass = GST_OMX_VIDEO_ENC_GET_CLASS (self);
1912
1913   if ((klass->cdata.hacks & GST_OMX_HACK_ENSURE_BUFFER_COUNT_ACTUAL)) {
1914     if (!gst_omx_port_ensure_buffer_count_actual (self->enc_in_port, 0))
1915       return FALSE;
1916   }
1917
1918   return TRUE;
1919 }
1920
1921 static gboolean
1922 gst_omx_video_enc_allocate_in_buffers (GstOMXVideoEnc * self)
1923 {
1924   switch (self->input_allocation) {
1925     case GST_OMX_BUFFER_ALLOCATION_ALLOCATE_BUFFER:
1926       if (gst_omx_port_allocate_buffers (self->enc_in_port) != OMX_ErrorNone)
1927         return FALSE;
1928       break;
1929     case GST_OMX_BUFFER_ALLOCATION_USE_BUFFER_DYNAMIC:
1930       if (gst_omx_port_use_dynamic_buffers (self->enc_in_port) != OMX_ErrorNone)
1931         return FALSE;
1932       break;
1933     case GST_OMX_BUFFER_ALLOCATION_USE_BUFFER:
1934     default:
1935       /* Not supported */
1936       g_return_val_if_reached (FALSE);
1937   }
1938
1939   return TRUE;
1940 }
1941
1942 static gboolean
1943 check_input_alignment (GstOMXVideoEnc * self, GstMapInfo * map)
1944 {
1945   OMX_PARAM_PORTDEFINITIONTYPE *port_def = &self->enc_in_port->port_def;
1946
1947   if (map->size != port_def->nBufferSize) {
1948     GST_DEBUG_OBJECT (self,
1949         "input buffer has wrong size/stride (%" G_GSIZE_FORMAT
1950         " expected: %u), can't use dynamic allocation",
1951         map->size, (guint32) port_def->nBufferSize);
1952     return FALSE;
1953   }
1954
1955   if (port_def->nBufferAlignment &&
1956       (GPOINTER_TO_UINT (map->data) & (port_def->nBufferAlignment - 1)) != 0) {
1957     GST_DEBUG_OBJECT (self,
1958         "input buffer is not properly aligned (address: %p alignment: %u bytes), can't use dynamic allocation",
1959         map->data, (guint32) port_def->nBufferAlignment);
1960     return FALSE;
1961   }
1962
1963   return TRUE;
1964 }
1965
1966 /* Check if @inbuf's alignment and stride matches the requirements to use the
1967  * dynamic buffer mode. */
1968 static gboolean
1969 can_use_dynamic_buffer_mode (GstOMXVideoEnc * self, GstBuffer * inbuf)
1970 {
1971   GstMapInfo map;
1972   gboolean result = FALSE;
1973
1974   if (gst_buffer_n_memory (inbuf) > 1) {
1975     GST_DEBUG_OBJECT (self,
1976         "input buffer contains more than one memory, can't use dynamic allocation");
1977     return FALSE;
1978   }
1979
1980   if (!gst_buffer_map (inbuf, &map, GST_MAP_READ)) {
1981     GST_ELEMENT_ERROR (self, STREAM, FORMAT, (NULL),
1982         ("failed to map input buffer"));
1983     return FALSE;
1984   }
1985
1986   result = check_input_alignment (self, &map);
1987
1988   gst_buffer_unmap (inbuf, &map);
1989   return result;
1990 }
1991
1992 /* Choose the allocation mode for input buffers depending of what's supported by
1993  * the component and the size/alignment of the input buffer. */
1994 static GstOMXBufferAllocation
1995 gst_omx_video_enc_pick_input_allocation_mode (GstOMXVideoEnc * self,
1996     GstBuffer * inbuf)
1997 {
1998   if (!gst_omx_is_dynamic_allocation_supported ())
1999     return GST_OMX_BUFFER_ALLOCATION_ALLOCATE_BUFFER;
2000
2001   if (can_use_dynamic_buffer_mode (self, inbuf)) {
2002     GST_DEBUG_OBJECT (self,
2003         "input buffer is properly aligned, use dynamic allocation");
2004     return GST_OMX_BUFFER_ALLOCATION_USE_BUFFER_DYNAMIC;
2005   }
2006
2007   GST_DEBUG_OBJECT (self, "let input buffer allocate its buffers");
2008   return GST_OMX_BUFFER_ALLOCATION_ALLOCATE_BUFFER;
2009 }
2010
2011 static gboolean
2012 gst_omx_video_enc_set_to_idle (GstOMXVideoEnc * self)
2013 {
2014   GstOMXVideoEncClass *klass = GST_OMX_VIDEO_ENC_GET_CLASS (self);
2015   gboolean no_disable_outport;
2016
2017   no_disable_outport = klass->cdata.hacks & GST_OMX_HACK_NO_DISABLE_OUTPORT;
2018
2019   if (!no_disable_outport) {
2020     /* Disable output port */
2021     if (gst_omx_port_set_enabled (self->enc_out_port, FALSE) != OMX_ErrorNone)
2022       return FALSE;
2023
2024     if (gst_omx_port_wait_enabled (self->enc_out_port,
2025             1 * GST_SECOND) != OMX_ErrorNone)
2026       return FALSE;
2027   }
2028
2029   if (gst_omx_component_set_state (self->enc, OMX_StateIdle) != OMX_ErrorNone)
2030     return FALSE;
2031
2032   /* Need to allocate buffers to reach Idle state */
2033   if (!gst_omx_video_enc_allocate_in_buffers (self))
2034     return FALSE;
2035
2036   if (no_disable_outport) {
2037     if (gst_omx_port_allocate_buffers (self->enc_out_port) != OMX_ErrorNone)
2038       return FALSE;
2039   }
2040
2041   if (gst_omx_component_get_state (self->enc,
2042           GST_CLOCK_TIME_NONE) != OMX_StateIdle)
2043     return FALSE;
2044
2045   return TRUE;
2046 }
2047
2048 static GstOMXBuffer *
2049 get_omx_buf (GstBuffer * buffer)
2050 {
2051   GstMemory *mem;
2052
2053   mem = gst_buffer_peek_memory (buffer, 0);
2054   return gst_omx_memory_get_omx_buf (mem);
2055 }
2056
2057 static gboolean
2058 buffer_is_from_input_pool (GstOMXVideoEnc * self, GstBuffer * buffer)
2059 {
2060   /* Buffer from our input pool will already have a GstOMXBuffer associated
2061    * with our input port. */
2062   GstOMXBuffer *buf;
2063
2064   buf = get_omx_buf (buffer);
2065   if (!buf)
2066     return FALSE;
2067
2068   return buf->port == self->enc_in_port;
2069 }
2070
2071 static gboolean
2072 gst_omx_video_enc_enable (GstOMXVideoEnc * self, GstBuffer * input)
2073 {
2074   GstOMXVideoEncClass *klass;
2075
2076   klass = GST_OMX_VIDEO_ENC_GET_CLASS (self);
2077
2078   /* Is downstream using our buffer pool? */
2079   if (buffer_is_from_input_pool (self, input)) {
2080     self->in_pool_used = TRUE;
2081   }
2082
2083   if (!self->in_pool_used) {
2084     if (!gst_omx_video_enc_configure_input_buffer (self, input))
2085       return FALSE;
2086
2087     self->input_allocation = gst_omx_video_enc_pick_input_allocation_mode (self,
2088         input);
2089     self->input_dmabuf = FALSE;
2090
2091 #ifdef USE_OMX_TARGET_ZYNQ_USCALE_PLUS
2092     if (gst_is_dmabuf_memory (gst_buffer_peek_memory (input, 0))) {
2093       if (self->input_allocation ==
2094           GST_OMX_BUFFER_ALLOCATION_USE_BUFFER_DYNAMIC) {
2095         GST_DEBUG_OBJECT (self, "Configure encoder input to import dmabuf");
2096         gst_omx_port_set_dmabuf (self->enc_in_port, TRUE);
2097       } else {
2098         GST_DEBUG_OBJECT (self,
2099             "Wrong input allocation mode (%d); dynamic buffers are required to use dmabuf import",
2100             self->input_allocation);
2101       }
2102
2103       self->input_dmabuf = TRUE;
2104     }
2105 #endif
2106   }
2107
2108   GST_DEBUG_OBJECT (self, "Enabling component");
2109
2110   if (!self->in_pool_used) {
2111     if (!gst_omx_video_enc_ensure_nb_in_buffers (self))
2112       return FALSE;
2113     if (!gst_omx_video_enc_ensure_nb_out_buffers (self))
2114       return FALSE;
2115   }
2116
2117   if (self->disabled) {
2118     if (gst_omx_port_set_enabled (self->enc_in_port, TRUE) != OMX_ErrorNone)
2119       return FALSE;
2120     if (!gst_omx_video_enc_allocate_in_buffers (self))
2121       return FALSE;
2122
2123     if ((klass->cdata.hacks & GST_OMX_HACK_NO_DISABLE_OUTPORT)) {
2124       if (gst_omx_port_set_enabled (self->enc_out_port, TRUE) != OMX_ErrorNone)
2125         return FALSE;
2126       if (gst_omx_port_allocate_buffers (self->enc_out_port) != OMX_ErrorNone)
2127         return FALSE;
2128
2129       if (gst_omx_port_wait_enabled (self->enc_out_port,
2130               5 * GST_SECOND) != OMX_ErrorNone)
2131         return FALSE;
2132     }
2133
2134     if (gst_omx_port_wait_enabled (self->enc_in_port,
2135             5 * GST_SECOND) != OMX_ErrorNone)
2136       return FALSE;
2137     if (gst_omx_port_mark_reconfigured (self->enc_in_port) != OMX_ErrorNone)
2138       return FALSE;
2139   } else {
2140     /* If the input pool is active we already allocated buffers and set the component to Idle. */
2141     if (!self->in_pool_used) {
2142       if (!gst_omx_video_enc_set_to_idle (self))
2143         return FALSE;
2144     }
2145
2146     if (gst_omx_component_set_state (self->enc,
2147             OMX_StateExecuting) != OMX_ErrorNone)
2148       return FALSE;
2149
2150     if (gst_omx_component_get_state (self->enc,
2151             GST_CLOCK_TIME_NONE) != OMX_StateExecuting)
2152       return FALSE;
2153   }
2154
2155   /* Unset flushing to allow ports to accept data again */
2156   gst_omx_port_set_flushing (self->enc_in_port, 5 * GST_SECOND, FALSE);
2157   gst_omx_port_set_flushing (self->enc_out_port, 5 * GST_SECOND, FALSE);
2158
2159   if (gst_omx_component_get_last_error (self->enc) != OMX_ErrorNone) {
2160     GST_ERROR_OBJECT (self, "Component in error state: %s (0x%08x)",
2161         gst_omx_component_get_last_error_string (self->enc),
2162         gst_omx_component_get_last_error (self->enc));
2163     return FALSE;
2164   }
2165
2166   self->disabled = FALSE;
2167
2168   return TRUE;
2169 }
2170
2171 /* returns TRUE if only the framerate changed and that framerate could be
2172  * updated using OMX_IndexConfigVideoFramerate */
2173 static gboolean
2174 gst_omx_video_enc_framerate_changed (GstOMXVideoEnc * self,
2175     GstVideoCodecState * state)
2176 {
2177   GstVideoInfo prev_info = self->input_state->info;
2178   GstVideoInfo *info = &state->info;
2179   GstOMXVideoEncClass *klass;
2180
2181   klass = GST_OMX_VIDEO_ENC_GET_CLASS (self);
2182
2183   prev_info.fps_n = info->fps_n;
2184   prev_info.fps_d = info->fps_d;
2185
2186   /* if only the framerate changed, try and set the framerate parameter */
2187   if (gst_video_info_is_equal (info, &prev_info)) {
2188     OMX_CONFIG_FRAMERATETYPE config;
2189     OMX_ERRORTYPE err;
2190
2191     GST_DEBUG_OBJECT (self, "Framerate change detected: %d/%d -> %d/%d",
2192         self->input_state->info.fps_n, self->input_state->info.fps_d,
2193         info->fps_n, info->fps_d);
2194
2195     GST_OMX_INIT_STRUCT (&config);
2196     config.nPortIndex = self->enc_in_port->index;
2197     if (klass->cdata.hacks & GST_OMX_HACK_VIDEO_FRAMERATE_INTEGER)
2198       config.xEncodeFramerate = info->fps_n ? (info->fps_n) / (info->fps_d) : 0;
2199     else
2200       config.xEncodeFramerate = gst_omx_video_calculate_framerate_q16 (info);
2201
2202     err = gst_omx_component_set_config (self->enc,
2203         OMX_IndexConfigVideoFramerate, &config);
2204     if (err == OMX_ErrorNone) {
2205       gst_video_codec_state_unref (self->input_state);
2206       self->input_state = gst_video_codec_state_ref (state);
2207       return TRUE;
2208     } else {
2209       GST_WARNING_OBJECT (self,
2210           "Failed to set framerate configuration: %s (0x%08x)",
2211           gst_omx_error_to_string (err), err);
2212       /* if changing the rate dynamically didn't work, keep going with a full
2213        * encoder reset */
2214     }
2215   }
2216
2217   return FALSE;
2218 }
2219
2220 static gboolean
2221 gst_omx_video_enc_set_format (GstVideoEncoder * encoder,
2222     GstVideoCodecState * state)
2223 {
2224   GstOMXVideoEnc *self;
2225   GstOMXVideoEncClass *klass;
2226   gboolean needs_disable = FALSE;
2227   OMX_PARAM_PORTDEFINITIONTYPE port_def;
2228   GstVideoInfo *info = &state->info;
2229   GList *negotiation_map = NULL, *l;
2230   GstCaps *caps;
2231
2232   self = GST_OMX_VIDEO_ENC (encoder);
2233   klass = GST_OMX_VIDEO_ENC_GET_CLASS (encoder);
2234
2235   caps = gst_video_info_to_caps (info);
2236   GST_DEBUG_OBJECT (self, "Setting new input format: %" GST_PTR_FORMAT, caps);
2237   gst_caps_unref (caps);
2238
2239   gst_omx_port_get_port_definition (self->enc_in_port, &port_def);
2240
2241   needs_disable =
2242       gst_omx_component_get_state (self->enc,
2243       GST_CLOCK_TIME_NONE) != OMX_StateLoaded;
2244   /* If the component is not in Loaded state and a real format change happens
2245    * we have to disable the port and re-allocate all buffers. If no real
2246    * format change happened we can just exit here.
2247    */
2248   if (needs_disable) {
2249     if (gst_omx_video_enc_framerate_changed (self, state))
2250       return TRUE;
2251
2252     if (!gst_omx_video_enc_disable (self))
2253       return FALSE;
2254
2255     if (!self->disabled) {
2256       /* The local port_def is now obsolete so get it again. */
2257       gst_omx_port_get_port_definition (self->enc_in_port, &port_def);
2258     }
2259   }
2260
2261   negotiation_map =
2262       gst_omx_video_get_supported_colorformats (self->enc_in_port,
2263       self->input_state);
2264   if (!negotiation_map) {
2265     /* Fallback */
2266     switch (info->finfo->format) {
2267       case GST_VIDEO_FORMAT_I420:
2268         port_def.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
2269         break;
2270       case GST_VIDEO_FORMAT_NV12:
2271         port_def.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
2272         break;
2273       case GST_VIDEO_FORMAT_NV16:
2274         port_def.format.video.eColorFormat = OMX_COLOR_FormatYUV422SemiPlanar;
2275         break;
2276       case GST_VIDEO_FORMAT_ABGR:
2277         port_def.format.video.eColorFormat = OMX_COLOR_Format32bitARGB8888;
2278         break;
2279       case GST_VIDEO_FORMAT_ARGB:
2280         port_def.format.video.eColorFormat = OMX_COLOR_Format32bitBGRA8888;
2281         break;
2282       default:
2283         GST_ERROR_OBJECT (self, "Unsupported format %s",
2284             gst_video_format_to_string (info->finfo->format));
2285         return FALSE;
2286         break;
2287     }
2288   } else {
2289     for (l = negotiation_map; l; l = l->next) {
2290       GstOMXVideoNegotiationMap *m = l->data;
2291
2292       if (m->format == info->finfo->format) {
2293         port_def.format.video.eColorFormat = m->type;
2294         break;
2295       }
2296     }
2297     g_list_free_full (negotiation_map,
2298         (GDestroyNotify) gst_omx_video_negotiation_map_free);
2299   }
2300
2301   port_def.format.video.nFrameWidth = info->width;
2302   port_def.format.video.nFrameHeight = info->height;
2303
2304   if (G_UNLIKELY (klass->cdata.hacks & GST_OMX_HACK_VIDEO_FRAMERATE_INTEGER))
2305     port_def.format.video.xFramerate =
2306         info->fps_n ? (info->fps_n) / (info->fps_d) : 0;
2307   else
2308     port_def.format.video.xFramerate =
2309         gst_omx_video_calculate_framerate_q16 (info);
2310
2311   GST_DEBUG_OBJECT (self, "Setting inport port definition");
2312   if (gst_omx_port_update_port_definition (self->enc_in_port,
2313           &port_def) != OMX_ErrorNone)
2314     return FALSE;
2315
2316 #ifdef USE_OMX_TARGET_RPI
2317   /* aspect ratio */
2318   {
2319     OMX_ERRORTYPE err;
2320     OMX_CONFIG_POINTTYPE aspect_ratio_param;
2321
2322     GST_OMX_INIT_STRUCT (&aspect_ratio_param);
2323     aspect_ratio_param.nPortIndex = self->enc_out_port->index;
2324
2325     err = gst_omx_component_get_parameter (self->enc,
2326         OMX_IndexParamBrcmPixelAspectRatio, &aspect_ratio_param);
2327
2328     if (err == OMX_ErrorNone) {
2329
2330       aspect_ratio_param.nX = info->par_n;
2331       aspect_ratio_param.nY = info->par_d;
2332
2333       err =
2334           gst_omx_component_set_parameter (self->enc,
2335           OMX_IndexParamBrcmPixelAspectRatio, &aspect_ratio_param);
2336
2337       if (err == OMX_ErrorUnsupportedIndex) {
2338         GST_WARNING_OBJECT (self,
2339             "Setting aspect ratio parameters not supported by the component");
2340       } else if (err == OMX_ErrorUnsupportedSetting) {
2341         GST_WARNING_OBJECT (self,
2342             "Setting aspect ratio %u %u not supported by the component",
2343             aspect_ratio_param.nX, aspect_ratio_param.nY);
2344       } else if (err != OMX_ErrorNone) {
2345         GST_ERROR_OBJECT (self,
2346             "Failed to set aspect ratio: %s (0x%08x)",
2347             gst_omx_error_to_string (err), err);
2348         return FALSE;
2349       }
2350     }
2351   }
2352 #endif // USE_OMX_TARGET_RPI
2353
2354   if (klass->set_format) {
2355     if (!klass->set_format (self, self->enc_in_port, state)) {
2356       GST_ERROR_OBJECT (self, "Subclass failed to set the new format");
2357       return FALSE;
2358     }
2359   }
2360
2361   GST_DEBUG_OBJECT (self, "Updating ports definition");
2362   if (gst_omx_port_update_port_definition (self->enc_out_port,
2363           NULL) != OMX_ErrorNone)
2364     return FALSE;
2365   if (gst_omx_port_update_port_definition (self->enc_in_port,
2366           NULL) != OMX_ErrorNone)
2367     return FALSE;
2368
2369   /* Some OMX implementations reset the bitrate after setting the compression
2370    * format, see bgo#698049, so re-set it */
2371   gst_omx_video_enc_set_bitrate (self);
2372
2373   if (self->input_state)
2374     gst_video_codec_state_unref (self->input_state);
2375   self->input_state = gst_video_codec_state_ref (state);
2376
2377 #ifdef USE_OMX_TARGET_ZYNQ_USCALE_PLUS
2378   gst_omx_video_enc_set_latency (self);
2379 #endif
2380
2381   self->downstream_flow_ret = GST_FLOW_OK;
2382   return TRUE;
2383 }
2384
2385 static gboolean
2386 gst_omx_video_enc_flush (GstVideoEncoder * encoder)
2387 {
2388   GstOMXVideoEnc *self;
2389
2390   self = GST_OMX_VIDEO_ENC (encoder);
2391
2392   GST_DEBUG_OBJECT (self, "Flushing encoder");
2393
2394   if (gst_omx_component_get_state (self->enc, 0) == OMX_StateLoaded)
2395     return TRUE;
2396
2397   /* 0) Pause the components */
2398   if (gst_omx_component_get_state (self->enc, 0) == OMX_StateExecuting) {
2399     gst_omx_component_set_state (self->enc, OMX_StatePause);
2400     gst_omx_component_get_state (self->enc, GST_CLOCK_TIME_NONE);
2401   }
2402
2403   /* 1) Flush the ports */
2404   GST_DEBUG_OBJECT (self, "flushing ports");
2405   gst_omx_port_set_flushing (self->enc_in_port, 5 * GST_SECOND, TRUE);
2406   gst_omx_port_set_flushing (self->enc_out_port, 5 * GST_SECOND, TRUE);
2407
2408   /* Wait until the srcpad loop is finished,
2409    * unlock GST_VIDEO_ENCODER_STREAM_LOCK to prevent deadlocks
2410    * caused by using this lock from inside the loop function */
2411   GST_VIDEO_ENCODER_STREAM_UNLOCK (self);
2412   GST_PAD_STREAM_LOCK (GST_VIDEO_ENCODER_SRC_PAD (self));
2413   GST_PAD_STREAM_UNLOCK (GST_VIDEO_ENCODER_SRC_PAD (self));
2414   GST_VIDEO_ENCODER_STREAM_LOCK (self);
2415
2416   /* 3) Resume components */
2417   gst_omx_component_set_state (self->enc, OMX_StateExecuting);
2418   gst_omx_component_get_state (self->enc, GST_CLOCK_TIME_NONE);
2419
2420   /* 4) Unset flushing to allow ports to accept data again */
2421   gst_omx_port_set_flushing (self->enc_in_port, 5 * GST_SECOND, FALSE);
2422   gst_omx_port_set_flushing (self->enc_out_port, 5 * GST_SECOND, FALSE);
2423   gst_omx_port_populate (self->enc_out_port);
2424
2425   /* Start the srcpad loop again */
2426   self->last_upstream_ts = 0;
2427   self->downstream_flow_ret = GST_FLOW_OK;
2428   self->started = FALSE;
2429   GST_DEBUG_OBJECT (self, "Flush finished");
2430
2431   return TRUE;
2432 }
2433
2434 static gboolean
2435 gst_omx_video_enc_semi_planar_manual_copy (GstOMXVideoEnc * self,
2436     GstBuffer * inbuf, GstOMXBuffer * outbuf, const GstVideoFormatInfo * finfo)
2437 {
2438   GstVideoInfo *info = &self->input_state->info;
2439   OMX_PARAM_PORTDEFINITIONTYPE *port_def = &self->enc_in_port->port_def;
2440   GstVideoFrame frame;
2441   gint i, j, height, width;
2442   guint8 *src, *dest;
2443   gint src_stride, dest_stride;
2444
2445   outbuf->omx_buf->nFilledLen = 0;
2446
2447   if (!gst_video_frame_map (&frame, info, inbuf, GST_MAP_READ)) {
2448     GST_ERROR_OBJECT (self, "Invalid input buffer size");
2449     return FALSE;
2450   }
2451   dest_stride = port_def->format.video.nStride;
2452
2453   for (i = 0; i < 2; i++) {
2454     src_stride = GST_VIDEO_FRAME_COMP_STRIDE (&frame, i);
2455     /* XXX: Try this if no stride was set */
2456     if (dest_stride == 0)
2457       dest_stride = src_stride;
2458
2459     dest = outbuf->omx_buf->pBuffer + outbuf->omx_buf->nOffset;
2460     if (i == 1)
2461       dest +=
2462           port_def->format.video.nSliceHeight * port_def->format.video.nStride;
2463
2464     src = GST_VIDEO_FRAME_COMP_DATA (&frame, i);
2465     height = GST_VIDEO_FRAME_COMP_HEIGHT (&frame, i);
2466     width = GST_VIDEO_FRAME_COMP_WIDTH (&frame, i) * (i == 0 ? 1 : 2);
2467
2468     if (GST_VIDEO_FORMAT_INFO_BITS (finfo) == 10)
2469       /* Need ((width + 2) / 3) 32-bits words */
2470       width = (width + 2) / 3 * 4;
2471
2472     if (dest + dest_stride * height >
2473         outbuf->omx_buf->pBuffer + outbuf->omx_buf->nAllocLen) {
2474       GST_ERROR_OBJECT (self, "Invalid output buffer size");
2475       gst_video_frame_unmap (&frame);
2476       return FALSE;
2477     }
2478
2479     for (j = 0; j < height; j++) {
2480       memcpy (dest, src, width);
2481       src += src_stride;
2482       dest += dest_stride;
2483     }
2484
2485     /* nFilledLen should include the vertical padding in each slice (spec 3.1.3.7.1) */
2486     outbuf->omx_buf->nFilledLen +=
2487         GST_VIDEO_FORMAT_INFO_SCALE_HEIGHT (finfo, i,
2488         port_def->format.video.nSliceHeight) * port_def->format.video.nStride;
2489   }
2490
2491   gst_video_frame_unmap (&frame);
2492   return TRUE;
2493 }
2494
2495 static gboolean
2496 gst_omx_video_enc_fill_buffer (GstOMXVideoEnc * self, GstBuffer * inbuf,
2497     GstOMXBuffer * outbuf)
2498 {
2499   GstVideoCodecState *state = gst_video_codec_state_ref (self->input_state);
2500   GstVideoInfo *info = &state->info;
2501   OMX_PARAM_PORTDEFINITIONTYPE *port_def = &self->enc_in_port->port_def;
2502   gboolean ret = FALSE;
2503   GstVideoFrame frame;
2504
2505   if (info->width != port_def->format.video.nFrameWidth ||
2506       info->height != port_def->format.video.nFrameHeight) {
2507     GST_ERROR_OBJECT (self, "Width or height do not match");
2508     goto done;
2509   }
2510
2511   if (self->enc_in_port->allocation ==
2512       GST_OMX_BUFFER_ALLOCATION_USE_BUFFER_DYNAMIC) {
2513     if (gst_buffer_n_memory (inbuf) > 1) {
2514       GST_ELEMENT_ERROR (self, STREAM, FORMAT, (NULL),
2515           ("input buffer now has more than one memory, can't use dynamic allocation any more"));
2516       return FALSE;
2517     }
2518
2519     if (!self->input_dmabuf) {
2520       /* Map and keep a ref on the buffer while it's being processed
2521        * by the OMX component. */
2522       if (!gst_omx_buffer_map_frame (outbuf, inbuf, info)) {
2523         GST_ELEMENT_ERROR (self, STREAM, FORMAT, (NULL),
2524             ("failed to map input buffer"));
2525         return FALSE;
2526       }
2527
2528       if (!check_input_alignment (self, &outbuf->input_frame.map[0])) {
2529         GST_ELEMENT_ERROR (self, STREAM, FORMAT, (NULL),
2530             ("input buffer now has wrong alignment/stride, can't use dynamic allocation any more"));
2531         return FALSE;
2532       }
2533
2534       GST_LOG_OBJECT (self, "Transfer buffer of %" G_GSIZE_FORMAT " bytes",
2535           gst_buffer_get_size (inbuf));
2536     } else {
2537       /* dmabuf input */
2538       if (!gst_omx_buffer_import_fd (outbuf, inbuf)) {
2539         GST_ELEMENT_ERROR (self, STREAM, FORMAT, (NULL),
2540             ("failed to import dmabuf"));
2541         return FALSE;
2542       }
2543
2544       GST_LOG_OBJECT (self, "Import dmabuf of %" G_GSIZE_FORMAT " bytes",
2545           gst_buffer_get_size (inbuf));
2546     }
2547
2548     ret = TRUE;
2549     goto done;
2550   }
2551
2552   /* Same strides and everything */
2553   if (gst_buffer_get_size (inbuf) ==
2554       outbuf->omx_buf->nAllocLen - outbuf->omx_buf->nOffset) {
2555     outbuf->omx_buf->nFilledLen = gst_buffer_get_size (inbuf);
2556
2557     GST_LOG_OBJECT (self, "Matched strides - direct copy %u bytes",
2558         (guint) outbuf->omx_buf->nFilledLen);
2559
2560     gst_buffer_extract (inbuf, 0,
2561         outbuf->omx_buf->pBuffer + outbuf->omx_buf->nOffset,
2562         outbuf->omx_buf->nFilledLen);
2563     ret = TRUE;
2564     goto done;
2565   }
2566
2567   /* Different strides */
2568   GST_LOG_OBJECT (self, "Mismatched strides - copying line-by-line");
2569
2570   switch (info->finfo->format) {
2571     case GST_VIDEO_FORMAT_I420:{
2572       gint i, j, height, width;
2573       guint8 *src, *dest;
2574       gint src_stride, dest_stride;
2575
2576       outbuf->omx_buf->nFilledLen = 0;
2577
2578       if (!gst_video_frame_map (&frame, info, inbuf, GST_MAP_READ)) {
2579         GST_ERROR_OBJECT (self, "Invalid input buffer size");
2580         ret = FALSE;
2581         goto done;
2582       }
2583
2584       for (i = 0; i < 3; i++) {
2585         if (i == 0) {
2586           dest_stride = port_def->format.video.nStride;
2587         } else {
2588           dest_stride = port_def->format.video.nStride / 2;
2589         }
2590
2591         src_stride = GST_VIDEO_FRAME_COMP_STRIDE (&frame, i);
2592         /* XXX: Try this if no stride was set */
2593         if (dest_stride == 0)
2594           dest_stride = src_stride;
2595
2596         dest = outbuf->omx_buf->pBuffer + outbuf->omx_buf->nOffset;
2597         if (i > 0)
2598           dest +=
2599               port_def->format.video.nSliceHeight *
2600               port_def->format.video.nStride;
2601         if (i == 2)
2602           dest +=
2603               (port_def->format.video.nSliceHeight / 2) *
2604               (port_def->format.video.nStride / 2);
2605
2606         src = GST_VIDEO_FRAME_COMP_DATA (&frame, i);
2607         height = GST_VIDEO_FRAME_COMP_HEIGHT (&frame, i);
2608         width = GST_VIDEO_FRAME_COMP_WIDTH (&frame, i);
2609
2610         if (dest + dest_stride * height >
2611             outbuf->omx_buf->pBuffer + outbuf->omx_buf->nAllocLen) {
2612           gst_video_frame_unmap (&frame);
2613           GST_ERROR_OBJECT (self, "Invalid output buffer size");
2614           ret = FALSE;
2615           goto done;
2616         }
2617
2618         for (j = 0; j < height; j++) {
2619           memcpy (dest, src, width);
2620           src += src_stride;
2621           dest += dest_stride;
2622         }
2623
2624         /* nFilledLen should include the vertical padding in each slice (spec 3.1.3.7.1) */
2625         if (i == 0)
2626           outbuf->omx_buf->nFilledLen +=
2627               port_def->format.video.nSliceHeight *
2628               port_def->format.video.nStride;
2629         else
2630           outbuf->omx_buf->nFilledLen +=
2631               (port_def->format.video.nSliceHeight / 2) *
2632               (port_def->format.video.nStride / 2);
2633       }
2634       gst_video_frame_unmap (&frame);
2635       ret = TRUE;
2636       break;
2637     }
2638     case GST_VIDEO_FORMAT_NV12:
2639     case GST_VIDEO_FORMAT_NV16:
2640     case GST_VIDEO_FORMAT_NV12_10LE32:
2641     case GST_VIDEO_FORMAT_NV16_10LE32:
2642       ret =
2643           gst_omx_video_enc_semi_planar_manual_copy (self, inbuf, outbuf,
2644           info->finfo);
2645       break;
2646     default:
2647       GST_ERROR_OBJECT (self, "Unsupported format");
2648       goto done;
2649       break;
2650   }
2651
2652 done:
2653
2654   gst_video_codec_state_unref (state);
2655
2656   return ret;
2657 }
2658
2659 #ifdef USE_OMX_TARGET_ZYNQ_USCALE_PLUS
2660 static void
2661 handle_roi_metadata (GstOMXVideoEnc * self, GstBuffer * input)
2662 {
2663   GstMeta *meta;
2664   gpointer state = NULL;
2665
2666   while ((meta =
2667           gst_buffer_iterate_meta_filtered (input, &state,
2668               GST_VIDEO_REGION_OF_INTEREST_META_API_TYPE))) {
2669     GstVideoRegionOfInterestMeta *roi = (GstVideoRegionOfInterestMeta *) meta;
2670     OMX_ALG_VIDEO_CONFIG_REGION_OF_INTEREST roi_param;
2671     GstStructure *s;
2672
2673     GST_LOG_OBJECT (self, "Input buffer ROI: type=%s id=%d (%d, %d) %dx%d",
2674         g_quark_to_string (roi->roi_type), roi->id, roi->x, roi->y, roi->w,
2675         roi->h);
2676
2677     if (self->qp_mode != OMX_ALG_ROI_QP) {
2678       GST_WARNING_OBJECT (self,
2679           "Need qp-mode=roi to handle ROI metadata (current: %d); ignoring",
2680           self->qp_mode);
2681       continue;
2682     }
2683
2684     GST_OMX_INIT_STRUCT (&roi_param);
2685     roi_param.nPortIndex = self->enc_in_port->index;
2686     roi_param.nLeft = roi->x;
2687     roi_param.nTop = roi->y;
2688     roi_param.nWidth = roi->w;
2689     roi_param.nHeight = roi->h;
2690
2691     s = gst_video_region_of_interest_meta_get_param (roi, "roi/omx-alg");
2692     if (s) {
2693       const gchar *quality;
2694       GEnumValue *evalue;
2695
2696       quality = gst_structure_get_string (s, "quality");
2697
2698       evalue =
2699           g_enum_get_value_by_nick (self->alg_roi_quality_enum_class, quality);
2700       if (!evalue) {
2701         roi_param.eQuality = self->default_roi_quality;
2702
2703         GST_WARNING_OBJECT (self,
2704             "Unknown ROI encoding quality '%s', use default (%d)",
2705             quality, self->default_roi_quality);
2706       } else {
2707         roi_param.eQuality = evalue->value;
2708
2709         GST_LOG_OBJECT (self, "Use encoding quality '%s' from upstream",
2710             quality);
2711       }
2712     } else {
2713       roi_param.eQuality = self->default_roi_quality;
2714
2715       GST_LOG_OBJECT (self, "No quality specified upstream, use default (%d)",
2716           self->default_roi_quality);
2717     }
2718
2719     gst_omx_component_set_config (self->enc,
2720         (OMX_INDEXTYPE) OMX_ALG_IndexConfigVideoRegionOfInterest, &roi_param);
2721   }
2722 }
2723 #endif
2724
2725 static GstFlowReturn
2726 gst_omx_video_enc_handle_frame (GstVideoEncoder * encoder,
2727     GstVideoCodecFrame * frame)
2728 {
2729   GstOMXAcquireBufferReturn acq_ret = GST_OMX_ACQUIRE_BUFFER_ERROR;
2730   GstOMXVideoEnc *self;
2731   GstOMXPort *port;
2732   GstOMXBuffer *buf;
2733   OMX_ERRORTYPE err;
2734   GstClockTimeDiff deadline;
2735
2736   self = GST_OMX_VIDEO_ENC (encoder);
2737
2738   GST_DEBUG_OBJECT (self, "Handling frame");
2739
2740   if (self->downstream_flow_ret != GST_FLOW_OK) {
2741     gst_video_codec_frame_unref (frame);
2742     return self->downstream_flow_ret;
2743   }
2744
2745   deadline = gst_video_encoder_get_max_encode_time (encoder, frame);
2746   if (deadline < 0) {
2747     GST_WARNING_OBJECT (self,
2748         "Input frame is too late, dropping (deadline %" GST_TIME_FORMAT ")",
2749         GST_TIME_ARGS (-deadline));
2750
2751     /* Calling finish_frame with frame->output_buffer == NULL will drop it */
2752     return gst_video_encoder_finish_frame (GST_VIDEO_ENCODER (self), frame);
2753   }
2754
2755   if (!self->started) {
2756     if (gst_omx_port_is_flushing (self->enc_out_port)) {
2757       if (!gst_omx_video_enc_enable (self, frame->input_buffer))
2758         goto enable_error;
2759     }
2760
2761     GST_DEBUG_OBJECT (self, "Starting task");
2762     gst_pad_start_task (GST_VIDEO_ENCODER_SRC_PAD (self),
2763         (GstTaskFunction) gst_omx_video_enc_loop, self, NULL);
2764   }
2765
2766   port = self->enc_in_port;
2767
2768   while (acq_ret != GST_OMX_ACQUIRE_BUFFER_OK) {
2769     GstClockTime timestamp, duration;
2770     gboolean fill_buffer = TRUE;
2771
2772     /* Make sure to release the base class stream lock, otherwise
2773      * _loop() can't call _finish_frame() and we might block forever
2774      * because no input buffers are released */
2775     GST_VIDEO_ENCODER_STREAM_UNLOCK (self);
2776
2777     if (buffer_is_from_input_pool (self, frame->input_buffer)) {
2778       /* Receiving a buffer from our input pool */
2779       buf = get_omx_buf (frame->input_buffer);
2780
2781       GST_LOG_OBJECT (self,
2782           "Input buffer %p already has a OMX buffer associated: %p",
2783           frame->input_buffer, buf);
2784
2785       g_assert (!buf->input_buffer);
2786       /* Prevent the buffer to be released to the pool while it's being
2787        * processed by OMX. The reference will be dropped in EmptyBufferDone() */
2788       buf->input_buffer = gst_buffer_ref (frame->input_buffer);
2789
2790       acq_ret = GST_OMX_ACQUIRE_BUFFER_OK;
2791       fill_buffer = FALSE;
2792       buf->omx_buf->nFilledLen = gst_buffer_get_size (frame->input_buffer);
2793     } else {
2794       acq_ret = gst_omx_port_acquire_buffer (port, &buf, GST_OMX_WAIT);
2795     }
2796
2797     if (acq_ret == GST_OMX_ACQUIRE_BUFFER_ERROR) {
2798       GST_VIDEO_ENCODER_STREAM_LOCK (self);
2799       goto component_error;
2800     } else if (acq_ret == GST_OMX_ACQUIRE_BUFFER_FLUSHING) {
2801       GST_VIDEO_ENCODER_STREAM_LOCK (self);
2802       goto flushing;
2803     } else if (acq_ret == GST_OMX_ACQUIRE_BUFFER_RECONFIGURE) {
2804       /* Reallocate all buffers */
2805       err = gst_omx_port_set_enabled (port, FALSE);
2806       if (err != OMX_ErrorNone) {
2807         GST_VIDEO_ENCODER_STREAM_LOCK (self);
2808         goto reconfigure_error;
2809       }
2810
2811       err = gst_omx_port_wait_buffers_released (port, 5 * GST_SECOND);
2812       if (err != OMX_ErrorNone) {
2813         GST_VIDEO_ENCODER_STREAM_LOCK (self);
2814         goto reconfigure_error;
2815       }
2816
2817       err = gst_omx_port_deallocate_buffers (port);
2818       if (err != OMX_ErrorNone) {
2819         GST_VIDEO_ENCODER_STREAM_LOCK (self);
2820         goto reconfigure_error;
2821       }
2822
2823       err = gst_omx_port_wait_enabled (port, 1 * GST_SECOND);
2824       if (err != OMX_ErrorNone) {
2825         GST_VIDEO_ENCODER_STREAM_LOCK (self);
2826         goto reconfigure_error;
2827       }
2828
2829       if (!gst_omx_video_enc_ensure_nb_in_buffers (self)) {
2830         GST_VIDEO_ENCODER_STREAM_LOCK (self);
2831         goto reconfigure_error;
2832       }
2833
2834       err = gst_omx_port_set_enabled (port, TRUE);
2835       if (err != OMX_ErrorNone) {
2836         GST_VIDEO_ENCODER_STREAM_LOCK (self);
2837         goto reconfigure_error;
2838       }
2839
2840       if (!gst_omx_video_enc_allocate_in_buffers (self)) {
2841         GST_VIDEO_ENCODER_STREAM_LOCK (self);
2842         goto reconfigure_error;
2843       }
2844
2845       err = gst_omx_port_wait_enabled (port, 5 * GST_SECOND);
2846       if (err != OMX_ErrorNone) {
2847         GST_VIDEO_ENCODER_STREAM_LOCK (self);
2848         goto reconfigure_error;
2849       }
2850
2851       err = gst_omx_port_mark_reconfigured (port);
2852       if (err != OMX_ErrorNone) {
2853         GST_VIDEO_ENCODER_STREAM_LOCK (self);
2854         goto reconfigure_error;
2855       }
2856
2857       /* Now get a new buffer and fill it */
2858       GST_VIDEO_ENCODER_STREAM_LOCK (self);
2859       continue;
2860     }
2861     GST_VIDEO_ENCODER_STREAM_LOCK (self);
2862
2863     g_assert (acq_ret == GST_OMX_ACQUIRE_BUFFER_OK && buf != NULL);
2864
2865     if (buf->omx_buf->nAllocLen - buf->omx_buf->nOffset <= 0) {
2866       gst_omx_port_release_buffer (port, buf);
2867       goto full_buffer;
2868     }
2869
2870     if (self->downstream_flow_ret != GST_FLOW_OK) {
2871       gst_omx_port_release_buffer (port, buf);
2872       goto flow_error;
2873     }
2874
2875     /* Now handle the frame */
2876
2877     if (GST_VIDEO_CODEC_FRAME_IS_FORCE_KEYFRAME (frame)) {
2878 #ifdef USE_OMX_TARGET_RPI
2879       OMX_CONFIG_BOOLEANTYPE config;
2880
2881       GST_OMX_INIT_STRUCT (&config);
2882       config.bEnabled = OMX_TRUE;
2883
2884       GST_DEBUG_OBJECT (self, "Forcing a keyframe (iframe on the RPi)");
2885
2886       err =
2887           gst_omx_component_set_config (self->enc,
2888           OMX_IndexConfigBrcmVideoRequestIFrame, &config);
2889 #elif defined(USE_OMX_TARGET_ZYNQ_USCALE_PLUS)
2890       OMX_ALG_VIDEO_CONFIG_INSERT config;
2891
2892       GST_OMX_INIT_STRUCT (&config);
2893       config.nPortIndex = self->enc_out_port->index;
2894
2895       GST_DEBUG_OBJECT (self, "Forcing a keyframe");
2896       err = gst_omx_component_set_config (self->enc, (OMX_INDEXTYPE)
2897           OMX_ALG_IndexConfigVideoInsertInstantaneousDecodingRefresh, &config);
2898 #else
2899       OMX_CONFIG_INTRAREFRESHVOPTYPE config;
2900
2901       GST_OMX_INIT_STRUCT (&config);
2902       config.nPortIndex = port->index;
2903       config.IntraRefreshVOP = OMX_TRUE;
2904
2905       GST_DEBUG_OBJECT (self, "Forcing a keyframe");
2906       err =
2907           gst_omx_component_set_config (self->enc,
2908           OMX_IndexConfigVideoIntraVOPRefresh, &config);
2909 #endif
2910       if (err != OMX_ErrorNone)
2911         GST_ERROR_OBJECT (self, "Failed to force a keyframe: %s (0x%08x)",
2912             gst_omx_error_to_string (err), err);
2913     }
2914 #ifdef USE_OMX_TARGET_ZYNQ_USCALE_PLUS
2915     handle_roi_metadata (self, frame->input_buffer);
2916 #endif
2917
2918     /* Copy the buffer content in chunks of size as requested
2919      * by the port */
2920     if (fill_buffer
2921         && !gst_omx_video_enc_fill_buffer (self, frame->input_buffer, buf)) {
2922       gst_omx_port_release_buffer (port, buf);
2923       goto buffer_fill_error;
2924     }
2925
2926     timestamp = frame->pts;
2927     if (timestamp != GST_CLOCK_TIME_NONE) {
2928       GST_OMX_SET_TICKS (buf->omx_buf->nTimeStamp,
2929           gst_util_uint64_scale (timestamp, OMX_TICKS_PER_SECOND, GST_SECOND));
2930       self->last_upstream_ts = timestamp;
2931     }
2932
2933     duration = frame->duration;
2934     if (duration != GST_CLOCK_TIME_NONE) {
2935       buf->omx_buf->nTickCount =
2936           gst_util_uint64_scale (duration, OMX_TICKS_PER_SECOND, GST_SECOND);
2937       self->last_upstream_ts += duration;
2938     } else {
2939       buf->omx_buf->nTickCount = 0;
2940     }
2941
2942     self->started = TRUE;
2943     err = gst_omx_port_release_buffer (port, buf);
2944     if (err != OMX_ErrorNone)
2945       goto release_error;
2946
2947     GST_DEBUG_OBJECT (self, "Passed frame to component");
2948   }
2949
2950   gst_video_codec_frame_unref (frame);
2951
2952   return self->downstream_flow_ret;
2953
2954 full_buffer:
2955   {
2956     GST_ELEMENT_ERROR (self, LIBRARY, FAILED, (NULL),
2957         ("Got OpenMAX buffer with no free space (%p, %u/%u)", buf,
2958             (guint) buf->omx_buf->nOffset, (guint) buf->omx_buf->nAllocLen));
2959     gst_video_codec_frame_unref (frame);
2960     return GST_FLOW_ERROR;
2961   }
2962
2963 flow_error:
2964   {
2965     gst_video_codec_frame_unref (frame);
2966     return self->downstream_flow_ret;
2967   }
2968
2969 enable_error:
2970   {
2971     /* Report the OMX error, if any */
2972     if (gst_omx_component_get_last_error (self->enc) != OMX_ErrorNone)
2973       GST_ELEMENT_ERROR (self, LIBRARY, FAILED, (NULL),
2974           ("Failed to enable OMX encoder: %s (0x%08x)",
2975               gst_omx_component_get_last_error_string (self->enc),
2976               gst_omx_component_get_last_error (self->enc)));
2977     else
2978       GST_ELEMENT_ERROR (self, LIBRARY, FAILED, (NULL),
2979           ("Failed to enable OMX encoder"));
2980     gst_video_codec_frame_unref (frame);
2981     return GST_FLOW_ERROR;
2982   }
2983
2984 component_error:
2985   {
2986     GST_ELEMENT_ERROR (self, LIBRARY, FAILED, (NULL),
2987         ("OpenMAX component in error state %s (0x%08x)",
2988             gst_omx_component_get_last_error_string (self->enc),
2989             gst_omx_component_get_last_error (self->enc)));
2990     gst_video_codec_frame_unref (frame);
2991     return GST_FLOW_ERROR;
2992   }
2993
2994 flushing:
2995   {
2996     GST_DEBUG_OBJECT (self, "Flushing -- returning FLUSHING");
2997     gst_video_codec_frame_unref (frame);
2998     return GST_FLOW_FLUSHING;
2999   }
3000 reconfigure_error:
3001   {
3002     GST_ELEMENT_ERROR (self, LIBRARY, SETTINGS, (NULL),
3003         ("Unable to reconfigure input port"));
3004     gst_video_codec_frame_unref (frame);
3005     return GST_FLOW_ERROR;
3006   }
3007 buffer_fill_error:
3008   {
3009     GST_ELEMENT_ERROR (self, RESOURCE, WRITE, (NULL),
3010         ("Failed to write input into the OpenMAX buffer"));
3011     gst_video_codec_frame_unref (frame);
3012     return GST_FLOW_ERROR;
3013   }
3014 release_error:
3015   {
3016     gst_video_codec_frame_unref (frame);
3017     GST_ELEMENT_ERROR (self, LIBRARY, SETTINGS, (NULL),
3018         ("Failed to relase input buffer to component: %s (0x%08x)",
3019             gst_omx_error_to_string (err), err));
3020     return GST_FLOW_ERROR;
3021   }
3022 }
3023
3024 static GstFlowReturn
3025 gst_omx_video_enc_finish (GstVideoEncoder * encoder)
3026 {
3027   GstOMXVideoEnc *self;
3028
3029   self = GST_OMX_VIDEO_ENC (encoder);
3030
3031   return gst_omx_video_enc_drain (self);
3032 }
3033
3034 static GstFlowReturn
3035 gst_omx_video_enc_drain (GstOMXVideoEnc * self)
3036 {
3037   GstOMXVideoEncClass *klass;
3038   GstOMXBuffer *buf;
3039   GstOMXAcquireBufferReturn acq_ret;
3040   OMX_ERRORTYPE err;
3041
3042   GST_DEBUG_OBJECT (self, "Draining component");
3043
3044   klass = GST_OMX_VIDEO_ENC_GET_CLASS (self);
3045
3046   if (!self->started) {
3047     GST_DEBUG_OBJECT (self, "Component not started yet");
3048     return GST_FLOW_OK;
3049   }
3050   self->started = FALSE;
3051
3052   if ((klass->cdata.hacks & GST_OMX_HACK_NO_EMPTY_EOS_BUFFER)) {
3053     GST_WARNING_OBJECT (self, "Component does not support empty EOS buffers");
3054     return GST_FLOW_OK;
3055   }
3056
3057   /* Make sure to release the base class stream lock, otherwise
3058    * _loop() can't call _finish_frame() and we might block forever
3059    * because no input buffers are released */
3060   GST_VIDEO_ENCODER_STREAM_UNLOCK (self);
3061
3062   /* Send an EOS buffer to the component and let the base
3063    * class drop the EOS event. We will send it later when
3064    * the EOS buffer arrives on the output port. */
3065   acq_ret = gst_omx_port_acquire_buffer (self->enc_in_port, &buf, GST_OMX_WAIT);
3066   if (acq_ret != GST_OMX_ACQUIRE_BUFFER_OK) {
3067     GST_VIDEO_ENCODER_STREAM_LOCK (self);
3068     GST_ERROR_OBJECT (self, "Failed to acquire buffer for draining: %d",
3069         acq_ret);
3070     return GST_FLOW_ERROR;
3071   }
3072
3073   g_mutex_lock (&self->drain_lock);
3074   self->draining = TRUE;
3075   buf->omx_buf->nFilledLen = 0;
3076   GST_OMX_SET_TICKS (buf->omx_buf->nTimeStamp,
3077       gst_util_uint64_scale (self->last_upstream_ts, OMX_TICKS_PER_SECOND,
3078           GST_SECOND));
3079   buf->omx_buf->nTickCount = 0;
3080   buf->omx_buf->nFlags |= OMX_BUFFERFLAG_EOS;
3081   err = gst_omx_port_release_buffer (self->enc_in_port, buf);
3082   if (err != OMX_ErrorNone) {
3083     GST_ERROR_OBJECT (self, "Failed to drain component: %s (0x%08x)",
3084         gst_omx_error_to_string (err), err);
3085     g_mutex_unlock (&self->drain_lock);
3086     GST_VIDEO_ENCODER_STREAM_LOCK (self);
3087     return GST_FLOW_ERROR;
3088   }
3089   GST_DEBUG_OBJECT (self, "Waiting until component is drained");
3090   g_cond_wait (&self->drain_cond, &self->drain_lock);
3091   GST_DEBUG_OBJECT (self, "Drained component");
3092   g_mutex_unlock (&self->drain_lock);
3093   GST_VIDEO_ENCODER_STREAM_LOCK (self);
3094
3095   self->started = FALSE;
3096
3097   return GST_FLOW_OK;
3098 }
3099
3100 #ifdef USE_OMX_TARGET_ZYNQ_USCALE_PLUS
3101 static gboolean
3102 pool_request_allocate_cb (GstBufferPool * pool, GstOMXVideoEnc * self)
3103 {
3104   GstStructure *config;
3105   guint min;
3106
3107   gst_omx_port_set_dmabuf (self->enc_in_port, TRUE);
3108
3109   config = gst_buffer_pool_get_config (pool);
3110
3111   if (!gst_buffer_pool_config_get_params (config, NULL, NULL, &min, NULL)) {
3112     gst_structure_free (config);
3113     return FALSE;
3114   }
3115   gst_structure_free (config);
3116
3117   GST_DEBUG_OBJECT (self,
3118       "input pool configured for %d buffers, adjust nBufferCountActual", min);
3119
3120   if (!gst_omx_port_update_buffer_count_actual (self->enc_in_port, min))
3121     return FALSE;
3122
3123   if (!gst_omx_video_enc_set_to_idle (self))
3124     return FALSE;
3125
3126   self->input_allocation = GST_OMX_BUFFER_ALLOCATION_ALLOCATE_BUFFER;
3127   self->input_dmabuf = TRUE;
3128
3129   /* gst_omx_port_acquire_buffer() will fail if the input port is stil flushing
3130    * which will prevent upstream from acquiring buffers. */
3131   gst_omx_port_set_flushing (self->enc_in_port, 5 * GST_SECOND, FALSE);
3132
3133   return TRUE;
3134 }
3135
3136 static GstBufferPool *
3137 create_input_pool (GstOMXVideoEnc * self, GstCaps * caps, guint num_buffers)
3138 {
3139   GstBufferPool *pool;
3140   GstStructure *config;
3141
3142   pool =
3143       gst_omx_buffer_pool_new (GST_ELEMENT_CAST (self), self->enc,
3144       self->enc_in_port, GST_OMX_BUFFER_MODE_DMABUF);
3145
3146   g_signal_connect_object (pool, "allocate",
3147       G_CALLBACK (pool_request_allocate_cb), self, 0);
3148
3149   config = gst_buffer_pool_get_config (pool);
3150
3151   gst_buffer_pool_config_set_params (config, caps,
3152       self->enc_in_port->port_def.nBufferSize, num_buffers, 0);
3153
3154   if (!gst_buffer_pool_set_config (pool, config)) {
3155     GST_INFO_OBJECT (self, "Failed to set config on input pool");
3156     gst_object_unref (pool);
3157     return NULL;
3158   }
3159
3160   return pool;
3161 }
3162 #endif
3163
3164 static gboolean
3165 gst_omx_video_enc_propose_allocation (GstVideoEncoder * encoder,
3166     GstQuery * query)
3167 {
3168   GstOMXVideoEnc *self = GST_OMX_VIDEO_ENC (encoder);
3169   guint num_buffers;
3170   GstCaps *caps;
3171   GstVideoInfo info;
3172   GstBufferPool *pool = NULL;
3173
3174   gst_query_parse_allocation (query, &caps, NULL);
3175
3176   if (!caps) {
3177     GST_WARNING_OBJECT (self, "allocation query does not contain caps");
3178     return FALSE;
3179   }
3180
3181   if (!gst_video_info_from_caps (&info, caps)) {
3182     GST_WARNING_OBJECT (self, "Failed to parse caps %" GST_PTR_FORMAT, caps);
3183     return FALSE;
3184   }
3185
3186   gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL);
3187
3188   num_buffers = self->enc_in_port->port_def.nBufferCountMin + 1;
3189
3190 #ifdef USE_OMX_TARGET_ZYNQ_USCALE_PLUS
3191   /* dmabuf export is currently only supported on Zynqultrascaleplus */
3192   pool = create_input_pool (self, caps, num_buffers);
3193   if (!pool) {
3194     GST_WARNING_OBJECT (self, "Failed to create and configure pool");
3195     return FALSE;
3196   }
3197 #endif
3198
3199   GST_DEBUG_OBJECT (self,
3200       "request at least %d buffers of size %" G_GSIZE_FORMAT, num_buffers,
3201       info.size);
3202   gst_query_add_allocation_pool (query, pool,
3203       self->enc_in_port->port_def.nBufferSize, num_buffers, 0);
3204
3205   self->in_pool_used = FALSE;
3206
3207   g_clear_object (&pool);
3208
3209   return
3210       GST_VIDEO_ENCODER_CLASS
3211       (gst_omx_video_enc_parent_class)->propose_allocation (encoder, query);
3212 }
3213
3214 static GList *
3215 filter_supported_formats (GList * negotiation_map)
3216 {
3217   GList *cur;
3218
3219   for (cur = negotiation_map; cur != NULL;) {
3220     GstOMXVideoNegotiationMap *nmap = (GstOMXVideoNegotiationMap *) (cur->data);
3221     GList *next;
3222
3223     switch (nmap->format) {
3224       case GST_VIDEO_FORMAT_I420:
3225       case GST_VIDEO_FORMAT_NV12:
3226       case GST_VIDEO_FORMAT_NV12_10LE32:
3227       case GST_VIDEO_FORMAT_NV16:
3228       case GST_VIDEO_FORMAT_NV16_10LE32:
3229         //case GST_VIDEO_FORMAT_ABGR:
3230         //case GST_VIDEO_FORMAT_ARGB:
3231         cur = g_list_next (cur);
3232         continue;
3233       default:
3234         gst_omx_video_negotiation_map_free (nmap);
3235         next = g_list_next (cur);
3236         negotiation_map = g_list_delete_link (negotiation_map, cur);
3237         cur = next;
3238     }
3239   }
3240
3241   return negotiation_map;
3242 }
3243
3244 static GstCaps *
3245 gst_omx_video_enc_getcaps (GstVideoEncoder * encoder, GstCaps * filter)
3246 {
3247   GstOMXVideoEnc *self = GST_OMX_VIDEO_ENC (encoder);
3248   GList *negotiation_map = NULL;
3249   GstCaps *comp_supported_caps;
3250   GstCaps *ret;
3251
3252   if (!self->enc)
3253     return gst_video_encoder_proxy_getcaps (encoder, NULL, filter);
3254
3255   negotiation_map =
3256       gst_omx_video_get_supported_colorformats (self->enc_in_port,
3257       self->input_state);
3258   negotiation_map = filter_supported_formats (negotiation_map);
3259
3260   comp_supported_caps = gst_omx_video_get_caps_for_map (negotiation_map);
3261   g_list_free_full (negotiation_map,
3262       (GDestroyNotify) gst_omx_video_negotiation_map_free);
3263
3264   if (!gst_caps_is_empty (comp_supported_caps)) {
3265     ret =
3266         gst_video_encoder_proxy_getcaps (encoder, comp_supported_caps, filter);
3267     gst_caps_unref (comp_supported_caps);
3268   } else {
3269     gst_caps_unref (comp_supported_caps);
3270     ret = gst_video_encoder_proxy_getcaps (encoder, NULL, filter);
3271   }
3272
3273   GST_LOG_OBJECT (encoder, "Supported caps %" GST_PTR_FORMAT, ret);
3274
3275   return ret;
3276 }
3277
3278 static gboolean
3279 gst_omx_video_enc_decide_allocation (GstVideoEncoder * encoder,
3280     GstQuery * query)
3281 {
3282   GstOMXVideoEnc *self = GST_OMX_VIDEO_ENC (encoder);
3283   guint min = 1;
3284
3285   if (!GST_VIDEO_ENCODER_CLASS
3286       (gst_omx_video_enc_parent_class)->decide_allocation (encoder, query))
3287     return FALSE;
3288
3289   if (gst_query_get_n_allocation_pools (query)) {
3290     gst_query_parse_nth_allocation_pool (query, 0, NULL, NULL, &min, NULL);
3291     GST_DEBUG_OBJECT (self,
3292         "Downstream requested %d buffers, adjust number of output buffers accordingly",
3293         min);
3294   } else {
3295     GST_DEBUG_OBJECT (self, "Downstream didn't set any allocation pool info");
3296   }
3297
3298   self->nb_downstream_buffers = min;
3299
3300   return TRUE;
3301 }
3302
3303 static gboolean
3304 gst_omx_video_enc_sink_query (GstVideoEncoder * encoder, GstQuery * query)
3305 {
3306   GstOMXVideoEnc *self = GST_OMX_VIDEO_ENC (encoder);
3307
3308   switch (GST_QUERY_TYPE (query)) {
3309     case GST_QUERY_ALLOCATION:
3310     case GST_QUERY_DRAIN:
3311     {
3312       GST_DEBUG_OBJECT (encoder, "%s query: drain encoder",
3313           GST_QUERY_TYPE_NAME (query));
3314
3315       gst_omx_video_enc_drain (self);
3316       return TRUE;
3317     }
3318     default:
3319       break;
3320   }
3321
3322   return
3323       GST_VIDEO_ENCODER_CLASS (gst_omx_video_enc_parent_class)->sink_query
3324       (encoder, query);
3325 }