git.sesse.net Git - ffmpeg/blob - libavcodec/omx.c

   1 /*
   2  * OMX Video encoder
   3  * Copyright (C) 2011 Martin Storsjo
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "config.h"
  23
  24 #if CONFIG_OMX_RPI
  25 #define OMX_SKIP64BIT
  26 #endif
  27
  28 #include <dlfcn.h>
  29 #include <OMX_Core.h>
  30 #include <OMX_Component.h>
  31 #include <pthread.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <sys/time.h>
  35
  36 #include "libavutil/avstring.h"
  37 #include "libavutil/avutil.h"
  38 #include "libavutil/common.h"
  39 #include "libavutil/imgutils.h"
  40 #include "libavutil/log.h"
  41 #include "libavutil/opt.h"
  42
  43 #include "avcodec.h"
  44 #include "h264.h"
  45 #include "internal.h"
  46
  47 #ifdef OMX_SKIP64BIT
  48 static OMX_TICKS to_omx_ticks(int64_t value)
  49 {
  50     OMX_TICKS s;
  51     s.nLowPart  = value & 0xffffffff;
  52     s.nHighPart = value >> 32;
  53     return s;
  54 }
  55 static int64_t from_omx_ticks(OMX_TICKS value)
  56 {
  57     return (((int64_t)value.nHighPart) << 32) | value.nLowPart;
  58 }
  59 #else
  60 #define to_omx_ticks(x) (x)
  61 #define from_omx_ticks(x) (x)
  62 #endif
  63
  64 #define INIT_STRUCT(x) do {                                               \
  65         x.nSize = sizeof(x);                                              \
  66         x.nVersion = s->version;                                          \
  67     } while (0)
  68 #define CHECK(x) do {                                                     \
  69         if (x != OMX_ErrorNone) {                                         \
  70             av_log(avctx, AV_LOG_ERROR,                                   \
  71                    "err %x (%d) on line %d\n", x, x, __LINE__);           \
  72             return AVERROR_UNKNOWN;                                       \
  73         }                                                                 \
  74     } while (0)
  75
  76 typedef struct OMXContext {
  77     void *lib;
  78     void *lib2;
  79     OMX_ERRORTYPE (*ptr_Init)(void);
  80     OMX_ERRORTYPE (*ptr_Deinit)(void);
  81     OMX_ERRORTYPE (*ptr_ComponentNameEnum)(OMX_STRING, OMX_U32, OMX_U32);
  82     OMX_ERRORTYPE (*ptr_GetHandle)(OMX_HANDLETYPE*, OMX_STRING, OMX_PTR, OMX_CALLBACKTYPE*);
  83     OMX_ERRORTYPE (*ptr_FreeHandle)(OMX_HANDLETYPE);
  84     OMX_ERRORTYPE (*ptr_GetComponentsOfRole)(OMX_STRING, OMX_U32*, OMX_U8**);
  85     OMX_ERRORTYPE (*ptr_GetRolesOfComponent)(OMX_STRING, OMX_U32*, OMX_U8**);
  86     void (*host_init)(void);
  87 } OMXContext;
  88
  89 static av_cold void *dlsym_prefixed(void *handle, const char *symbol, const char *prefix)
  90 {
  91     char buf[50];
  92     snprintf(buf, sizeof(buf), "%s%s", prefix ? prefix : "", symbol);
  93     return dlsym(handle, buf);
  94 }
  95
  96 static av_cold int omx_try_load(OMXContext *s, void *logctx,
  97                                 const char *libname, const char *prefix,
  98                                 const char *libname2)
  99 {
 100     if (libname2) {
 101         s->lib2 = dlopen(libname2, RTLD_NOW | RTLD_GLOBAL);
 102         if (!s->lib2) {
 103             av_log(logctx, AV_LOG_WARNING, "%s not found\n", libname2);
 104             return AVERROR_ENCODER_NOT_FOUND;
 105         }
 106         s->host_init = dlsym(s->lib2, "bcm_host_init");
 107         if (!s->host_init) {
 108             av_log(logctx, AV_LOG_WARNING, "bcm_host_init not found\n");
 109             dlclose(s->lib2);
 110             s->lib2 = NULL;
 111             return AVERROR_ENCODER_NOT_FOUND;
 112         }
 113     }
 114     s->lib = dlopen(libname, RTLD_NOW | RTLD_GLOBAL);
 115     if (!s->lib) {
 116         av_log(logctx, AV_LOG_WARNING, "%s not found\n", libname);
 117         return AVERROR_ENCODER_NOT_FOUND;
 118     }
 119     s->ptr_Init                = dlsym_prefixed(s->lib, "OMX_Init", prefix);
 120     s->ptr_Deinit              = dlsym_prefixed(s->lib, "OMX_Deinit", prefix);
 121     s->ptr_ComponentNameEnum   = dlsym_prefixed(s->lib, "OMX_ComponentNameEnum", prefix);
 122     s->ptr_GetHandle           = dlsym_prefixed(s->lib, "OMX_GetHandle", prefix);
 123     s->ptr_FreeHandle          = dlsym_prefixed(s->lib, "OMX_FreeHandle", prefix);
 124     s->ptr_GetComponentsOfRole = dlsym_prefixed(s->lib, "OMX_GetComponentsOfRole", prefix);
 125     s->ptr_GetRolesOfComponent = dlsym_prefixed(s->lib, "OMX_GetRolesOfComponent", prefix);
 126     if (!s->ptr_Init || !s->ptr_Deinit || !s->ptr_ComponentNameEnum ||
 127         !s->ptr_GetHandle || !s->ptr_FreeHandle ||
 128         !s->ptr_GetComponentsOfRole || !s->ptr_GetRolesOfComponent) {
 129         av_log(logctx, AV_LOG_WARNING, "Not all functions found in %s\n", libname);
 130         dlclose(s->lib);
 131         s->lib = NULL;
 132         if (s->lib2)
 133             dlclose(s->lib2);
 134         s->lib2 = NULL;
 135         return AVERROR_ENCODER_NOT_FOUND;
 136     }
 137     return 0;
 138 }
 139
 140 static av_cold OMXContext *omx_init(void *logctx, const char *libname, const char *prefix)
 141 {
 142     static const char * const libnames[] = {
 143 #if CONFIG_OMX_RPI
 144         "/opt/vc/lib/libopenmaxil.so", "/opt/vc/lib/libbcm_host.so",
 145 #else
 146         "libOMX_Core.so", NULL,
 147         "libOmxCore.so", NULL,
 148 #endif
 149         NULL
 150     };
 151     const char* const* nameptr;
 152     int ret = AVERROR_ENCODER_NOT_FOUND;
 153     OMXContext *omx_context;
 154
 155     omx_context = av_mallocz(sizeof(*omx_context));
 156     if (!omx_context)
 157         return NULL;
 158     if (libname) {
 159         ret = omx_try_load(omx_context, logctx, libname, prefix, NULL);
 160         if (ret < 0) {
 161             av_free(omx_context);
 162             return NULL;
 163         }
 164     } else {
 165         for (nameptr = libnames; *nameptr; nameptr += 2)
 166             if (!(ret = omx_try_load(omx_context, logctx, nameptr[0], prefix, nameptr[1])))
 167                 break;
 168         if (!*nameptr) {
 169             av_free(omx_context);
 170             return NULL;
 171         }
 172     }
 173
 174     if (omx_context->host_init)
 175         omx_context->host_init();
 176     omx_context->ptr_Init();
 177     return omx_context;
 178 }
 179
 180 static av_cold void omx_deinit(OMXContext *omx_context)
 181 {
 182     if (!omx_context)
 183         return;
 184     omx_context->ptr_Deinit();
 185     dlclose(omx_context->lib);
 186     av_free(omx_context);
 187 }
 188
 189 typedef struct OMXCodecContext {
 190     const AVClass *class;
 191     char *libname;
 192     char *libprefix;
 193     OMXContext *omx_context;
 194
 195     AVCodecContext *avctx;
 196
 197     char component_name[OMX_MAX_STRINGNAME_SIZE];
 198     OMX_VERSIONTYPE version;
 199     OMX_HANDLETYPE handle;
 200     int in_port, out_port;
 201     OMX_COLOR_FORMATTYPE color_format;
 202     int stride, plane_size;
 203
 204     int num_in_buffers, num_out_buffers;
 205     OMX_BUFFERHEADERTYPE **in_buffer_headers;
 206     OMX_BUFFERHEADERTYPE **out_buffer_headers;
 207     int num_free_in_buffers;
 208     OMX_BUFFERHEADERTYPE **free_in_buffers;
 209     int num_done_out_buffers;
 210     OMX_BUFFERHEADERTYPE **done_out_buffers;
 211     pthread_mutex_t input_mutex;
 212     pthread_cond_t input_cond;
 213     pthread_mutex_t output_mutex;
 214     pthread_cond_t output_cond;
 215
 216     pthread_mutex_t state_mutex;
 217     pthread_cond_t state_cond;
 218     OMX_STATETYPE state;
 219     OMX_ERRORTYPE error;
 220
 221     int mutex_cond_inited;
 222
 223     int eos_sent, got_eos;
 224
 225     uint8_t *output_buf;
 226     int output_buf_size;
 227
 228     int input_zerocopy;
 229     int profile;
 230 } OMXCodecContext;
 231
 232 static void append_buffer(pthread_mutex_t *mutex, pthread_cond_t *cond,
 233                           int* array_size, OMX_BUFFERHEADERTYPE **array,
 234                           OMX_BUFFERHEADERTYPE *buffer)
 235 {
 236     pthread_mutex_lock(mutex);
 237     array[(*array_size)++] = buffer;
 238     pthread_cond_broadcast(cond);
 239     pthread_mutex_unlock(mutex);
 240 }
 241
 242 static OMX_BUFFERHEADERTYPE *get_buffer(pthread_mutex_t *mutex, pthread_cond_t *cond,
 243                                         int* array_size, OMX_BUFFERHEADERTYPE **array,
 244                                         int wait)
 245 {
 246     OMX_BUFFERHEADERTYPE *buffer;
 247     pthread_mutex_lock(mutex);
 248     if (wait) {
 249         while (!*array_size)
 250            pthread_cond_wait(cond, mutex);
 251     }
 252     if (*array_size > 0) {
 253         buffer = array[0];
 254         (*array_size)--;
 255         memmove(&array[0], &array[1], (*array_size) * sizeof(OMX_BUFFERHEADERTYPE*));
 256     } else {
 257         buffer = NULL;
 258     }
 259     pthread_mutex_unlock(mutex);
 260     return buffer;
 261 }
 262
 263 static OMX_ERRORTYPE event_handler(OMX_HANDLETYPE component, OMX_PTR app_data, OMX_EVENTTYPE event,
 264                                    OMX_U32 data1, OMX_U32 data2, OMX_PTR event_data)
 265 {
 266     OMXCodecContext *s = app_data;
 267     // This uses casts in the printfs, since OMX_U32 actually is a typedef for
 268     // unsigned long in official header versions (but there are also modified
 269     // versions where it is something else).
 270     switch (event) {
 271     case OMX_EventError:
 272         pthread_mutex_lock(&s->state_mutex);
 273         av_log(s->avctx, AV_LOG_ERROR, "OMX error %"PRIx32"\n", (uint32_t) data1);
 274         s->error = data1;
 275         pthread_cond_broadcast(&s->state_cond);
 276         pthread_mutex_unlock(&s->state_mutex);
 277         break;
 278     case OMX_EventCmdComplete:
 279         if (data1 == OMX_CommandStateSet) {
 280             pthread_mutex_lock(&s->state_mutex);
 281             s->state = data2;
 282             av_log(s->avctx, AV_LOG_VERBOSE, "OMX state changed to %"PRIu32"\n", (uint32_t) data2);
 283             pthread_cond_broadcast(&s->state_cond);
 284             pthread_mutex_unlock(&s->state_mutex);
 285         } else if (data1 == OMX_CommandPortDisable) {
 286             av_log(s->avctx, AV_LOG_VERBOSE, "OMX port %"PRIu32" disabled\n", (uint32_t) data2);
 287         } else if (data1 == OMX_CommandPortEnable) {
 288             av_log(s->avctx, AV_LOG_VERBOSE, "OMX port %"PRIu32" enabled\n", (uint32_t) data2);
 289         } else {
 290             av_log(s->avctx, AV_LOG_VERBOSE, "OMX command complete, command %"PRIu32", value %"PRIu32"\n",
 291                                              (uint32_t) data1, (uint32_t) data2);
 292         }
 293         break;
 294     case OMX_EventPortSettingsChanged:
 295         av_log(s->avctx, AV_LOG_VERBOSE, "OMX port %"PRIu32" settings changed\n", (uint32_t) data1);
 296         break;
 297     default:
 298         av_log(s->avctx, AV_LOG_VERBOSE, "OMX event %d %"PRIx32" %"PRIx32"\n",
 299                                          event, (uint32_t) data1, (uint32_t) data2);
 300         break;
 301     }
 302     return OMX_ErrorNone;
 303 }
 304
 305 static OMX_ERRORTYPE empty_buffer_done(OMX_HANDLETYPE component, OMX_PTR app_data,
 306                                        OMX_BUFFERHEADERTYPE *buffer)
 307 {
 308     OMXCodecContext *s = app_data;
 309     if (s->input_zerocopy) {
 310         if (buffer->pAppPrivate) {
 311             if (buffer->pOutputPortPrivate)
 312                 av_free(buffer->pAppPrivate);
 313             else
 314                 av_frame_free((AVFrame**)&buffer->pAppPrivate);
 315             buffer->pAppPrivate = NULL;
 316         }
 317     }
 318     append_buffer(&s->input_mutex, &s->input_cond,
 319                   &s->num_free_in_buffers, s->free_in_buffers, buffer);
 320     return OMX_ErrorNone;
 321 }
 322
 323 static OMX_ERRORTYPE fill_buffer_done(OMX_HANDLETYPE component, OMX_PTR app_data,
 324                                       OMX_BUFFERHEADERTYPE *buffer)
 325 {
 326     OMXCodecContext *s = app_data;
 327     append_buffer(&s->output_mutex, &s->output_cond,
 328                   &s->num_done_out_buffers, s->done_out_buffers, buffer);
 329     return OMX_ErrorNone;
 330 }
 331
 332 static const OMX_CALLBACKTYPE callbacks = {
 333     event_handler,
 334     empty_buffer_done,
 335     fill_buffer_done
 336 };
 337
 338 static av_cold int find_component(OMXContext *omx_context, void *logctx,
 339                                   const char *role, char *str, int str_size)
 340 {
 341     OMX_U32 i, num = 0;
 342     char **components;
 343     int ret = 0;
 344
 345 #if CONFIG_OMX_RPI
 346     if (av_strstart(role, "video_encoder.", NULL)) {
 347         av_strlcpy(str, "OMX.broadcom.video_encode", str_size);
 348         return 0;
 349     }
 350 #endif
 351     omx_context->ptr_GetComponentsOfRole((OMX_STRING) role, &num, NULL);
 352     if (!num) {
 353         av_log(logctx, AV_LOG_WARNING, "No component for role %s found\n", role);
 354         return AVERROR_ENCODER_NOT_FOUND;
 355     }
 356     components = av_mallocz_array(num, sizeof(*components));
 357     if (!components)
 358         return AVERROR(ENOMEM);
 359     for (i = 0; i < num; i++) {
 360         components[i] = av_mallocz(OMX_MAX_STRINGNAME_SIZE);
 361         if (!components[i]) {
 362             ret = AVERROR(ENOMEM);
 363             goto end;
 364         }
 365     }
 366     omx_context->ptr_GetComponentsOfRole((OMX_STRING) role, &num, (OMX_U8**) components);
 367     av_strlcpy(str, components[0], str_size);
 368 end:
 369     for (i = 0; i < num; i++)
 370         av_free(components[i]);
 371     av_free(components);
 372     return ret;
 373 }
 374
 375 static av_cold int wait_for_state(OMXCodecContext *s, OMX_STATETYPE state)
 376 {
 377     int ret = 0;
 378     pthread_mutex_lock(&s->state_mutex);
 379     while (s->state != state && s->error == OMX_ErrorNone)
 380         pthread_cond_wait(&s->state_cond, &s->state_mutex);
 381     if (s->error != OMX_ErrorNone)
 382         ret = AVERROR_ENCODER_NOT_FOUND;
 383     pthread_mutex_unlock(&s->state_mutex);
 384     return ret;
 385 }
 386
 387 static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
 388 {
 389     OMXCodecContext *s = avctx->priv_data;
 390     OMX_PARAM_COMPONENTROLETYPE role_params = { 0 };
 391     OMX_PORT_PARAM_TYPE video_port_params = { 0 };
 392     OMX_PARAM_PORTDEFINITIONTYPE in_port_params = { 0 }, out_port_params = { 0 };
 393     OMX_VIDEO_PARAM_PORTFORMATTYPE video_port_format = { 0 };
 394     OMX_VIDEO_PARAM_BITRATETYPE vid_param_bitrate = { 0 };
 395     OMX_ERRORTYPE err;
 396     int i;
 397
 398     s->version.s.nVersionMajor = 1;
 399     s->version.s.nVersionMinor = 1;
 400     s->version.s.nRevision     = 2;
 401
 402     err = s->omx_context->ptr_GetHandle(&s->handle, s->component_name, s, (OMX_CALLBACKTYPE*) &callbacks);
 403     if (err != OMX_ErrorNone) {
 404         av_log(avctx, AV_LOG_ERROR, "OMX_GetHandle(%s) failed: %x\n", s->component_name, err);
 405         return AVERROR_UNKNOWN;
 406     }
 407
 408     // This one crashes the mediaserver on qcom, if used over IOMX
 409     INIT_STRUCT(role_params);
 410     av_strlcpy(role_params.cRole, role, sizeof(role_params.cRole));
 411     // Intentionally ignore errors on this one
 412     OMX_SetParameter(s->handle, OMX_IndexParamStandardComponentRole, &role_params);
 413
 414     INIT_STRUCT(video_port_params);
 415     err = OMX_GetParameter(s->handle, OMX_IndexParamVideoInit, &video_port_params);
 416     CHECK(err);
 417
 418     s->in_port = s->out_port = -1;
 419     for (i = 0; i < video_port_params.nPorts; i++) {
 420         int port = video_port_params.nStartPortNumber + i;
 421         OMX_PARAM_PORTDEFINITIONTYPE port_params = { 0 };
 422         INIT_STRUCT(port_params);
 423         port_params.nPortIndex = port;
 424         err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &port_params);
 425         if (err != OMX_ErrorNone) {
 426             av_log(avctx, AV_LOG_WARNING, "port %d error %x\n", port, err);
 427             break;
 428         }
 429         if (port_params.eDir == OMX_DirInput && s->in_port < 0) {
 430             in_port_params = port_params;
 431             s->in_port = port;
 432         } else if (port_params.eDir == OMX_DirOutput && s->out_port < 0) {
 433             out_port_params = port_params;
 434             s->out_port = port;
 435         }
 436     }
 437     if (s->in_port < 0 || s->out_port < 0) {
 438         av_log(avctx, AV_LOG_ERROR, "No in or out port found (in %d out %d)\n", s->in_port, s->out_port);
 439         return AVERROR_UNKNOWN;
 440     }
 441
 442     s->color_format = 0;
 443     for (i = 0; ; i++) {
 444         INIT_STRUCT(video_port_format);
 445         video_port_format.nIndex = i;
 446         video_port_format.nPortIndex = s->in_port;
 447         if (OMX_GetParameter(s->handle, OMX_IndexParamVideoPortFormat, &video_port_format) != OMX_ErrorNone)
 448             break;
 449         if (video_port_format.eColorFormat == OMX_COLOR_FormatYUV420Planar ||
 450             video_port_format.eColorFormat == OMX_COLOR_FormatYUV420PackedPlanar) {
 451             s->color_format = video_port_format.eColorFormat;
 452             break;
 453         }
 454     }
 455     if (s->color_format == 0) {
 456         av_log(avctx, AV_LOG_ERROR, "No supported pixel formats (%d formats available)\n", i);
 457         return AVERROR_UNKNOWN;
 458     }
 459
 460     in_port_params.bEnabled   = OMX_TRUE;
 461     in_port_params.bPopulated = OMX_FALSE;
 462     in_port_params.eDomain    = OMX_PortDomainVideo;
 463
 464     in_port_params.format.video.pNativeRender         = NULL;
 465     in_port_params.format.video.bFlagErrorConcealment = OMX_FALSE;
 466     in_port_params.format.video.eColorFormat          = s->color_format;
 467     s->stride     = avctx->width;
 468     s->plane_size = avctx->height;
 469     // If specific codecs need to manually override the stride/plane_size,
 470     // that can be done here.
 471     in_port_params.format.video.nStride      = s->stride;
 472     in_port_params.format.video.nSliceHeight = s->plane_size;
 473     in_port_params.format.video.nFrameWidth  = avctx->width;
 474     in_port_params.format.video.nFrameHeight = avctx->height;
 475     if (avctx->framerate.den > 0 && avctx->framerate.num > 0)
 476         in_port_params.format.video.xFramerate = (1 << 16) * avctx->framerate.num / avctx->framerate.den;
 477     else
 478         in_port_params.format.video.xFramerate = (1 << 16) * avctx->time_base.den / avctx->time_base.num;
 479
 480     err = OMX_SetParameter(s->handle, OMX_IndexParamPortDefinition, &in_port_params);
 481     CHECK(err);
 482     err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &in_port_params);
 483     CHECK(err);
 484     s->stride         = in_port_params.format.video.nStride;
 485     s->plane_size     = in_port_params.format.video.nSliceHeight;
 486     s->num_in_buffers = in_port_params.nBufferCountActual;
 487
 488     err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &out_port_params);
 489     out_port_params.bEnabled   = OMX_TRUE;
 490     out_port_params.bPopulated = OMX_FALSE;
 491     out_port_params.eDomain    = OMX_PortDomainVideo;
 492     out_port_params.format.video.pNativeRender = NULL;
 493     out_port_params.format.video.nFrameWidth   = avctx->width;
 494     out_port_params.format.video.nFrameHeight  = avctx->height;
 495     out_port_params.format.video.nStride       = 0;
 496     out_port_params.format.video.nSliceHeight  = 0;
 497     out_port_params.format.video.nBitrate      = avctx->bit_rate;
 498     out_port_params.format.video.xFramerate    = in_port_params.format.video.xFramerate;
 499     out_port_params.format.video.bFlagErrorConcealment  = OMX_FALSE;
 500     if (avctx->codec->id == AV_CODEC_ID_MPEG4)
 501         out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
 502     else if (avctx->codec->id == AV_CODEC_ID_H264)
 503         out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
 504
 505     err = OMX_SetParameter(s->handle, OMX_IndexParamPortDefinition, &out_port_params);
 506     CHECK(err);
 507     err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &out_port_params);
 508     CHECK(err);
 509     s->num_out_buffers = out_port_params.nBufferCountActual;
 510
 511     INIT_STRUCT(vid_param_bitrate);
 512     vid_param_bitrate.nPortIndex     = s->out_port;
 513     vid_param_bitrate.eControlRate   = OMX_Video_ControlRateVariable;
 514     vid_param_bitrate.nTargetBitrate = avctx->bit_rate;
 515     err = OMX_SetParameter(s->handle, OMX_IndexParamVideoBitrate, &vid_param_bitrate);
 516     if (err != OMX_ErrorNone)
 517         av_log(avctx, AV_LOG_WARNING, "Unable to set video bitrate parameter\n");
 518
 519     if (avctx->codec->id == AV_CODEC_ID_H264) {
 520         OMX_VIDEO_PARAM_AVCTYPE avc = { 0 };
 521         INIT_STRUCT(avc);
 522         avc.nPortIndex = s->out_port;
 523         err = OMX_GetParameter(s->handle, OMX_IndexParamVideoAvc, &avc);
 524         CHECK(err);
 525         avc.nBFrames = 0;
 526         avc.nPFrames = avctx->gop_size - 1;
 527         switch (s->profile == FF_PROFILE_UNKNOWN ? avctx->profile : s->profile) {
 528         case FF_PROFILE_H264_BASELINE:
 529             avc.eProfile = OMX_VIDEO_AVCProfileBaseline;
 530             break;
 531         case FF_PROFILE_H264_MAIN:
 532             avc.eProfile = OMX_VIDEO_AVCProfileMain;
 533             break;
 534         case FF_PROFILE_H264_HIGH:
 535             avc.eProfile = OMX_VIDEO_AVCProfileHigh;
 536             break;
 537         default:
 538             break;
 539         }
 540         err = OMX_SetParameter(s->handle, OMX_IndexParamVideoAvc, &avc);
 541         CHECK(err);
 542     }
 543
 544     err = OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateIdle, NULL);
 545     CHECK(err);
 546
 547     s->in_buffer_headers  = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_in_buffers);
 548     s->free_in_buffers    = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_in_buffers);
 549     s->out_buffer_headers = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_out_buffers);
 550     s->done_out_buffers   = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_out_buffers);
 551     if (!s->in_buffer_headers || !s->free_in_buffers || !s->out_buffer_headers || !s->done_out_buffers)
 552         return AVERROR(ENOMEM);
 553     for (i = 0; i < s->num_in_buffers && err == OMX_ErrorNone; i++) {
 554         if (s->input_zerocopy)
 555             err = OMX_UseBuffer(s->handle, &s->in_buffer_headers[i], s->in_port, s, in_port_params.nBufferSize, NULL);
 556         else
 557             err = OMX_AllocateBuffer(s->handle, &s->in_buffer_headers[i],  s->in_port,  s, in_port_params.nBufferSize);
 558         if (err == OMX_ErrorNone)
 559             s->in_buffer_headers[i]->pAppPrivate = s->in_buffer_headers[i]->pOutputPortPrivate = NULL;
 560     }
 561     CHECK(err);
 562     s->num_in_buffers = i;
 563     for (i = 0; i < s->num_out_buffers && err == OMX_ErrorNone; i++)
 564         err = OMX_AllocateBuffer(s->handle, &s->out_buffer_headers[i], s->out_port, s, out_port_params.nBufferSize);
 565     CHECK(err);
 566     s->num_out_buffers = i;
 567
 568     if (wait_for_state(s, OMX_StateIdle) < 0) {
 569         av_log(avctx, AV_LOG_ERROR, "Didn't get OMX_StateIdle\n");
 570         return AVERROR_UNKNOWN;
 571     }
 572     err = OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
 573     CHECK(err);
 574     if (wait_for_state(s, OMX_StateExecuting) < 0) {
 575         av_log(avctx, AV_LOG_ERROR, "Didn't get OMX_StateExecuting\n");
 576         return AVERROR_UNKNOWN;
 577     }
 578
 579     for (i = 0; i < s->num_out_buffers && err == OMX_ErrorNone; i++)
 580         err = OMX_FillThisBuffer(s->handle, s->out_buffer_headers[i]);
 581     if (err != OMX_ErrorNone) {
 582         for (; i < s->num_out_buffers; i++)
 583             s->done_out_buffers[s->num_done_out_buffers++] = s->out_buffer_headers[i];
 584     }
 585     for (i = 0; i < s->num_in_buffers; i++)
 586         s->free_in_buffers[s->num_free_in_buffers++] = s->in_buffer_headers[i];
 587     return err != OMX_ErrorNone ? AVERROR_UNKNOWN : 0;
 588 }
 589
 590 static av_cold void cleanup(OMXCodecContext *s)
 591 {
 592     int i, executing;
 593
 594     pthread_mutex_lock(&s->state_mutex);
 595     executing = s->state == OMX_StateExecuting;
 596     pthread_mutex_unlock(&s->state_mutex);
 597
 598     if (executing) {
 599         OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateIdle, NULL);
 600         wait_for_state(s, OMX_StateIdle);
 601         OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
 602         for (i = 0; i < s->num_in_buffers; i++) {
 603             OMX_BUFFERHEADERTYPE *buffer = get_buffer(&s->input_mutex, &s->input_cond,
 604                                                       &s->num_free_in_buffers, s->free_in_buffers, 1);
 605             if (s->input_zerocopy)
 606                 buffer->pBuffer = NULL;
 607             OMX_FreeBuffer(s->handle, s->in_port, buffer);
 608         }
 609         for (i = 0; i < s->num_out_buffers; i++) {
 610             OMX_BUFFERHEADERTYPE *buffer = get_buffer(&s->output_mutex, &s->output_cond,
 611                                                       &s->num_done_out_buffers, s->done_out_buffers, 1);
 612             OMX_FreeBuffer(s->handle, s->out_port, buffer);
 613         }
 614         wait_for_state(s, OMX_StateLoaded);
 615     }
 616     if (s->handle) {
 617         s->omx_context->ptr_FreeHandle(s->handle);
 618         s->handle = NULL;
 619     }
 620
 621     omx_deinit(s->omx_context);
 622     s->omx_context = NULL;
 623     if (s->mutex_cond_inited) {
 624         pthread_cond_destroy(&s->state_cond);
 625         pthread_mutex_destroy(&s->state_mutex);
 626         pthread_cond_destroy(&s->input_cond);
 627         pthread_mutex_destroy(&s->input_mutex);
 628         pthread_cond_destroy(&s->output_cond);
 629         pthread_mutex_destroy(&s->output_mutex);
 630         s->mutex_cond_inited = 0;
 631     }
 632     av_freep(&s->in_buffer_headers);
 633     av_freep(&s->out_buffer_headers);
 634     av_freep(&s->free_in_buffers);
 635     av_freep(&s->done_out_buffers);
 636     av_freep(&s->output_buf);
 637 }
 638
 639 static av_cold int omx_encode_init(AVCodecContext *avctx)
 640 {
 641     OMXCodecContext *s = avctx->priv_data;
 642     int ret = AVERROR_ENCODER_NOT_FOUND;
 643     const char *role;
 644     OMX_BUFFERHEADERTYPE *buffer;
 645     OMX_ERRORTYPE err;
 646
 647     s->omx_context = omx_init(avctx, s->libname, s->libprefix);
 648     if (!s->omx_context)
 649         return AVERROR_ENCODER_NOT_FOUND;
 650
 651     pthread_mutex_init(&s->state_mutex, NULL);
 652     pthread_cond_init(&s->state_cond, NULL);
 653     pthread_mutex_init(&s->input_mutex, NULL);
 654     pthread_cond_init(&s->input_cond, NULL);
 655     pthread_mutex_init(&s->output_mutex, NULL);
 656     pthread_cond_init(&s->output_cond, NULL);
 657     s->mutex_cond_inited = 1;
 658     s->avctx = avctx;
 659     s->state = OMX_StateLoaded;
 660     s->error = OMX_ErrorNone;
 661
 662     switch (avctx->codec->id) {
 663     case AV_CODEC_ID_MPEG4:
 664         role = "video_encoder.mpeg4";
 665         break;
 666     case AV_CODEC_ID_H264:
 667         role = "video_encoder.avc";
 668         break;
 669     default:
 670         return AVERROR(ENOSYS);
 671     }
 672
 673     if ((ret = find_component(s->omx_context, avctx, role, s->component_name, sizeof(s->component_name))) < 0)
 674         goto fail;
 675
 676     av_log(avctx, AV_LOG_INFO, "Using %s\n", s->component_name);
 677
 678     if ((ret = omx_component_init(avctx, role)) < 0)
 679         goto fail;
 680
 681     if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
 682         while (1) {
 683             buffer = get_buffer(&s->output_mutex, &s->output_cond,
 684                                 &s->num_done_out_buffers, s->done_out_buffers, 1);
 685             if (buffer->nFlags & OMX_BUFFERFLAG_CODECCONFIG) {
 686                 if ((ret = av_reallocp(&avctx->extradata, avctx->extradata_size + buffer->nFilledLen + AV_INPUT_BUFFER_PADDING_SIZE)) < 0) {
 687                     avctx->extradata_size = 0;
 688                     goto fail;
 689                 }
 690                 memcpy(avctx->extradata + avctx->extradata_size, buffer->pBuffer + buffer->nOffset, buffer->nFilledLen);
 691                 avctx->extradata_size += buffer->nFilledLen;
 692                 memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
 693             }
 694             err = OMX_FillThisBuffer(s->handle, buffer);
 695             if (err != OMX_ErrorNone) {
 696                 append_buffer(&s->output_mutex, &s->output_cond,
 697                               &s->num_done_out_buffers, s->done_out_buffers, buffer);
 698                 av_log(avctx, AV_LOG_ERROR, "OMX_FillThisBuffer failed: %x\n", err);
 699                 ret = AVERROR_UNKNOWN;
 700                 goto fail;
 701             }
 702             if (avctx->codec->id == AV_CODEC_ID_H264) {
 703                 // For H.264, the extradata can be returned in two separate buffers
 704                 // (the videocore encoder on raspberry pi does this);
 705                 // therefore check that we have got both SPS and PPS before continuing.
 706                 int nals[32] = { 0 };
 707                 int i;
 708                 for (i = 0; i + 4 < avctx->extradata_size; i++) {
 709                      if (!avctx->extradata[i + 0] &&
 710                          !avctx->extradata[i + 1] &&
 711                          !avctx->extradata[i + 2] &&
 712                          avctx->extradata[i + 3] == 1) {
 713                          nals[avctx->extradata[i + 4] & 0x1f]++;
 714                      }
 715                 }
 716                 if (nals[H264_NAL_SPS] && nals[H264_NAL_PPS])
 717                     break;
 718             } else {
 719                 if (avctx->extradata_size > 0)
 720                     break;
 721             }
 722         }
 723     }
 724
 725     return 0;
 726 fail:
 727     return ret;
 728 }
 729
 730
 731 static int omx_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
 732                             const AVFrame *frame, int *got_packet)
 733 {
 734     OMXCodecContext *s = avctx->priv_data;
 735     int ret = 0;
 736     OMX_BUFFERHEADERTYPE* buffer;
 737     OMX_ERRORTYPE err;
 738
 739     if (frame) {
 740         uint8_t *dst[4];
 741         int linesize[4];
 742         int need_copy;
 743         buffer = get_buffer(&s->input_mutex, &s->input_cond,
 744                             &s->num_free_in_buffers, s->free_in_buffers, 1);
 745
 746         buffer->nFilledLen = av_image_fill_arrays(dst, linesize, buffer->pBuffer, avctx->pix_fmt, s->stride, s->plane_size, 1);
 747
 748         if (s->input_zerocopy) {
 749             uint8_t *src[4] = { NULL };
 750             int src_linesize[4];
 751             av_image_fill_arrays(src, src_linesize, frame->data[0], avctx->pix_fmt, s->stride, s->plane_size, 1);
 752             if (frame->linesize[0] == src_linesize[0] &&
 753                 frame->linesize[1] == src_linesize[1] &&
 754                 frame->linesize[2] == src_linesize[2] &&
 755                 frame->data[1] == src[1] &&
 756                 frame->data[2] == src[2]) {
 757                 // If the input frame happens to have all planes stored contiguously,
 758                 // with the right strides, just clone the frame and set the OMX
 759                 // buffer header to point to it
 760                 AVFrame *local = av_frame_clone(frame);
 761                 if (!local) {
 762                     // Return the buffer to the queue so it's not lost
 763                     append_buffer(&s->input_mutex, &s->input_cond, &s->num_free_in_buffers, s->free_in_buffers, buffer);
 764                     return AVERROR(ENOMEM);
 765                 } else {
 766                     buffer->pAppPrivate = local;
 767                     buffer->pOutputPortPrivate = NULL;
 768                     buffer->pBuffer = local->data[0];
 769                     need_copy = 0;
 770                 }
 771             } else {
 772                 // If not, we need to allocate a new buffer with the right
 773                 // size and copy the input frame into it.
 774                 uint8_t *buf = NULL;
 775                 int image_buffer_size = av_image_get_buffer_size(avctx->pix_fmt, s->stride, s->plane_size, 1);
 776                 if (image_buffer_size >= 0)
 777                     buf = av_malloc(image_buffer_size);
 778                 if (!buf) {
 779                     // Return the buffer to the queue so it's not lost
 780                     append_buffer(&s->input_mutex, &s->input_cond, &s->num_free_in_buffers, s->free_in_buffers, buffer);
 781                     return AVERROR(ENOMEM);
 782                 } else {
 783                     buffer->pAppPrivate = buf;
 784                     // Mark that pAppPrivate is an av_malloc'ed buffer, not an AVFrame
 785                     buffer->pOutputPortPrivate = (void*) 1;
 786                     buffer->pBuffer = buf;
 787                     need_copy = 1;
 788                     buffer->nFilledLen = av_image_fill_arrays(dst, linesize, buffer->pBuffer, avctx->pix_fmt, s->stride, s->plane_size, 1);
 789                 }
 790             }
 791         } else {
 792             need_copy = 1;
 793         }
 794         if (need_copy)
 795             av_image_copy(dst, linesize, (const uint8_t**) frame->data, frame->linesize, avctx->pix_fmt, avctx->width, avctx->height);
 796         buffer->nFlags = OMX_BUFFERFLAG_ENDOFFRAME;
 797         buffer->nOffset = 0;
 798         // Convert the timestamps to microseconds; some encoders can ignore
 799         // the framerate and do VFR bit allocation based on timestamps.
 800         buffer->nTimeStamp = to_omx_ticks(av_rescale_q(frame->pts, avctx->time_base, AV_TIME_BASE_Q));
 801         if (frame->pict_type == AV_PICTURE_TYPE_I) {
 802 #if CONFIG_OMX_RPI
 803             OMX_CONFIG_BOOLEANTYPE config = {0, };
 804             INIT_STRUCT(config);
 805             config.bEnabled = OMX_TRUE;
 806             err = OMX_SetConfig(s->handle, OMX_IndexConfigBrcmVideoRequestIFrame, &config);
 807             if (err != OMX_ErrorNone) {
 808                 av_log(avctx, AV_LOG_ERROR, "OMX_SetConfig(RequestIFrame) failed: %x\n", err);
 809             }
 810 #else
 811             OMX_CONFIG_INTRAREFRESHVOPTYPE config = {0, };
 812             INIT_STRUCT(config);
 813             config.nPortIndex = s->out_port;
 814             config.IntraRefreshVOP = OMX_TRUE;
 815             err = OMX_SetConfig(s->handle, OMX_IndexConfigVideoIntraVOPRefresh, &config);
 816             if (err != OMX_ErrorNone) {
 817                 av_log(avctx, AV_LOG_ERROR, "OMX_SetConfig(IntraVOPRefresh) failed: %x\n", err);
 818             }
 819 #endif
 820         }
 821         err = OMX_EmptyThisBuffer(s->handle, buffer);
 822         if (err != OMX_ErrorNone) {
 823             append_buffer(&s->input_mutex, &s->input_cond, &s->num_free_in_buffers, s->free_in_buffers, buffer);
 824             av_log(avctx, AV_LOG_ERROR, "OMX_EmptyThisBuffer failed: %x\n", err);
 825             return AVERROR_UNKNOWN;
 826         }
 827     } else if (!s->eos_sent) {
 828         buffer = get_buffer(&s->input_mutex, &s->input_cond,
 829                             &s->num_free_in_buffers, s->free_in_buffers, 1);
 830
 831         buffer->nFilledLen = 0;
 832         buffer->nFlags = OMX_BUFFERFLAG_EOS;
 833         buffer->pAppPrivate = buffer->pOutputPortPrivate = NULL;
 834         err = OMX_EmptyThisBuffer(s->handle, buffer);
 835         if (err != OMX_ErrorNone) {
 836             append_buffer(&s->input_mutex, &s->input_cond, &s->num_free_in_buffers, s->free_in_buffers, buffer);
 837             av_log(avctx, AV_LOG_ERROR, "OMX_EmptyThisBuffer failed: %x\n", err);
 838             return AVERROR_UNKNOWN;
 839         }
 840         s->eos_sent = 1;
 841     }
 842
 843     while (!*got_packet && ret == 0 && !s->got_eos) {
 844         // If not flushing, just poll the queue if there's finished packets.
 845         // If flushing, do a blocking wait until we either get a completed
 846         // packet, or get EOS.
 847         buffer = get_buffer(&s->output_mutex, &s->output_cond,
 848                             &s->num_done_out_buffers, s->done_out_buffers,
 849                             !frame);
 850         if (!buffer)
 851             break;
 852
 853         if (buffer->nFlags & OMX_BUFFERFLAG_EOS)
 854             s->got_eos = 1;
 855
 856         if (buffer->nFlags & OMX_BUFFERFLAG_CODECCONFIG && avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
 857             if ((ret = av_reallocp(&avctx->extradata, avctx->extradata_size + buffer->nFilledLen + AV_INPUT_BUFFER_PADDING_SIZE)) < 0) {
 858                 avctx->extradata_size = 0;
 859                 goto end;
 860             }
 861             memcpy(avctx->extradata + avctx->extradata_size, buffer->pBuffer + buffer->nOffset, buffer->nFilledLen);
 862             avctx->extradata_size += buffer->nFilledLen;
 863             memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
 864         } else {
 865             if (!(buffer->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) || !pkt->data) {
 866                 // If the output packet isn't preallocated, just concatenate everything in our
 867                 // own buffer
 868                 int newsize = s->output_buf_size + buffer->nFilledLen + AV_INPUT_BUFFER_PADDING_SIZE;
 869                 if ((ret = av_reallocp(&s->output_buf, newsize)) < 0) {
 870                     s->output_buf_size = 0;
 871                     goto end;
 872                 }
 873                 memcpy(s->output_buf + s->output_buf_size, buffer->pBuffer + buffer->nOffset, buffer->nFilledLen);
 874                 s->output_buf_size += buffer->nFilledLen;
 875                 if (buffer->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) {
 876                     if ((ret = av_packet_from_data(pkt, s->output_buf, s->output_buf_size)) < 0) {
 877                         av_freep(&s->output_buf);
 878                         s->output_buf_size = 0;
 879                         goto end;
 880                     }
 881                     s->output_buf = NULL;
 882                     s->output_buf_size = 0;
 883                 }
 884             } else {
 885                 // End of frame, and the caller provided a preallocated frame
 886                 if ((ret = ff_alloc_packet2(avctx, pkt, s->output_buf_size + buffer->nFilledLen, 0)) < 0) {
 887                     av_log(avctx, AV_LOG_ERROR, "Error getting output packet of size %d.\n",
 888                            (int)(s->output_buf_size + buffer->nFilledLen));
 889                     goto end;
 890                 }
 891                 memcpy(pkt->data, s->output_buf, s->output_buf_size);
 892                 memcpy(pkt->data + s->output_buf_size, buffer->pBuffer + buffer->nOffset, buffer->nFilledLen);
 893                 av_freep(&s->output_buf);
 894                 s->output_buf_size = 0;
 895             }
 896             if (buffer->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) {
 897                 pkt->pts = av_rescale_q(from_omx_ticks(buffer->nTimeStamp), AV_TIME_BASE_Q, avctx->time_base);
 898                 // We don't currently enable B-frames for the encoders, so set
 899                 // pkt->dts = pkt->pts. (The calling code behaves worse if the encoder
 900                 // doesn't set the dts).
 901                 pkt->dts = pkt->pts;
 902                 if (buffer->nFlags & OMX_BUFFERFLAG_SYNCFRAME)
 903                     pkt->flags |= AV_PKT_FLAG_KEY;
 904                 *got_packet = 1;
 905             }
 906         }
 907 end:
 908         err = OMX_FillThisBuffer(s->handle, buffer);
 909         if (err != OMX_ErrorNone) {
 910             append_buffer(&s->output_mutex, &s->output_cond, &s->num_done_out_buffers, s->done_out_buffers, buffer);
 911             av_log(avctx, AV_LOG_ERROR, "OMX_FillThisBuffer failed: %x\n", err);
 912             ret = AVERROR_UNKNOWN;
 913         }
 914     }
 915     return ret;
 916 }
 917
 918 static av_cold int omx_encode_end(AVCodecContext *avctx)
 919 {
 920     OMXCodecContext *s = avctx->priv_data;
 921
 922     cleanup(s);
 923     return 0;
 924 }
 925
 926 #define OFFSET(x) offsetof(OMXCodecContext, x)
 927 #define VDE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 928 #define VE  AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 929 static const AVOption options[] = {
 930     { "omx_libname", "OpenMAX library name", OFFSET(libname), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
 931     { "omx_libprefix", "OpenMAX library prefix", OFFSET(libprefix), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
 932     { "zerocopy", "Try to avoid copying input frames if possible", OFFSET(input_zerocopy), AV_OPT_TYPE_INT, { .i64 = CONFIG_OMX_RPI }, 0, 1, VE },
 933     { "profile",  "Set the encoding profile", OFFSET(profile), AV_OPT_TYPE_INT,   { .i64 = FF_PROFILE_UNKNOWN },       FF_PROFILE_UNKNOWN, FF_PROFILE_H264_HIGH, VE, "profile" },
 934     { "baseline", "",                         0,               AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_BASELINE }, 0, 0, VE, "profile" },
 935     { "main",     "",                         0,               AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_MAIN },     0, 0, VE, "profile" },
 936     { "high",     "",                         0,               AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_HIGH },     0, 0, VE, "profile" },
 937     { NULL }
 938 };
 939
 940 static const enum AVPixelFormat omx_encoder_pix_fmts[] = {
 941     AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
 942 };
 943
 944 static const AVClass omx_mpeg4enc_class = {
 945     .class_name = "mpeg4_omx",
 946     .item_name  = av_default_item_name,
 947     .option     = options,
 948     .version    = LIBAVUTIL_VERSION_INT,
 949 };
 950 AVCodec ff_mpeg4_omx_encoder = {
 951     .name             = "mpeg4_omx",
 952     .long_name        = NULL_IF_CONFIG_SMALL("OpenMAX IL MPEG-4 video encoder"),
 953     .type             = AVMEDIA_TYPE_VIDEO,
 954     .id               = AV_CODEC_ID_MPEG4,
 955     .priv_data_size   = sizeof(OMXCodecContext),
 956     .init             = omx_encode_init,
 957     .encode2          = omx_encode_frame,
 958     .close            = omx_encode_end,
 959     .pix_fmts         = omx_encoder_pix_fmts,
 960     .capabilities     = AV_CODEC_CAP_DELAY,
 961     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
 962     .priv_class       = &omx_mpeg4enc_class,
 963 };
 964
 965 static const AVClass omx_h264enc_class = {
 966     .class_name = "h264_omx",
 967     .item_name  = av_default_item_name,
 968     .option     = options,
 969     .version    = LIBAVUTIL_VERSION_INT,
 970 };
 971 AVCodec ff_h264_omx_encoder = {
 972     .name             = "h264_omx",
 973     .long_name        = NULL_IF_CONFIG_SMALL("OpenMAX IL H.264 video encoder"),
 974     .type             = AVMEDIA_TYPE_VIDEO,
 975     .id               = AV_CODEC_ID_H264,
 976     .priv_data_size   = sizeof(OMXCodecContext),
 977     .init             = omx_encode_init,
 978     .encode2          = omx_encode_frame,
 979     .close            = omx_encode_end,
 980     .pix_fmts         = omx_encoder_pix_fmts,
 981     .capabilities     = AV_CODEC_CAP_DELAY,
 982     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
 983     .priv_class       = &omx_h264enc_class,
 984 };