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 = (1LL << 16) * avctx->framerate.num / avctx->framerate.den;
 477     else
 478         in_port_params.format.video.xFramerate = (1LL << 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     int had_partial = 0;
 739
 740     if (frame) {
 741         uint8_t *dst[4];
 742         int linesize[4];
 743         int need_copy;
 744         buffer = get_buffer(&s->input_mutex, &s->input_cond,
 745                             &s->num_free_in_buffers, s->free_in_buffers, 1);
 746
 747         buffer->nFilledLen = av_image_fill_arrays(dst, linesize, buffer->pBuffer, avctx->pix_fmt, s->stride, s->plane_size, 1);
 748
 749         if (s->input_zerocopy) {
 750             uint8_t *src[4] = { NULL };
 751             int src_linesize[4];
 752             av_image_fill_arrays(src, src_linesize, frame->data[0], avctx->pix_fmt, s->stride, s->plane_size, 1);
 753             if (frame->linesize[0] == src_linesize[0] &&
 754                 frame->linesize[1] == src_linesize[1] &&
 755                 frame->linesize[2] == src_linesize[2] &&
 756                 frame->data[1] == src[1] &&
 757                 frame->data[2] == src[2]) {
 758                 // If the input frame happens to have all planes stored contiguously,
 759                 // with the right strides, just clone the frame and set the OMX
 760                 // buffer header to point to it
 761                 AVFrame *local = av_frame_clone(frame);
 762                 if (!local) {
 763                     // Return the buffer to the queue so it's not lost
 764                     append_buffer(&s->input_mutex, &s->input_cond, &s->num_free_in_buffers, s->free_in_buffers, buffer);
 765                     return AVERROR(ENOMEM);
 766                 } else {
 767                     buffer->pAppPrivate = local;
 768                     buffer->pOutputPortPrivate = NULL;
 769                     buffer->pBuffer = local->data[0];
 770                     need_copy = 0;
 771                 }
 772             } else {
 773                 // If not, we need to allocate a new buffer with the right
 774                 // size and copy the input frame into it.
 775                 uint8_t *buf = NULL;
 776                 int image_buffer_size = av_image_get_buffer_size(avctx->pix_fmt, s->stride, s->plane_size, 1);
 777                 if (image_buffer_size >= 0)
 778                     buf = av_malloc(image_buffer_size);
 779                 if (!buf) {
 780                     // Return the buffer to the queue so it's not lost
 781                     append_buffer(&s->input_mutex, &s->input_cond, &s->num_free_in_buffers, s->free_in_buffers, buffer);
 782                     return AVERROR(ENOMEM);
 783                 } else {
 784                     buffer->pAppPrivate = buf;
 785                     // Mark that pAppPrivate is an av_malloc'ed buffer, not an AVFrame
 786                     buffer->pOutputPortPrivate = (void*) 1;
 787                     buffer->pBuffer = buf;
 788                     need_copy = 1;
 789                     buffer->nFilledLen = av_image_fill_arrays(dst, linesize, buffer->pBuffer, avctx->pix_fmt, s->stride, s->plane_size, 1);
 790                 }
 791             }
 792         } else {
 793             need_copy = 1;
 794         }
 795         if (need_copy)
 796             av_image_copy(dst, linesize, (const uint8_t**) frame->data, frame->linesize, avctx->pix_fmt, avctx->width, avctx->height);
 797         buffer->nFlags = OMX_BUFFERFLAG_ENDOFFRAME;
 798         buffer->nOffset = 0;
 799         // Convert the timestamps to microseconds; some encoders can ignore
 800         // the framerate and do VFR bit allocation based on timestamps.
 801         buffer->nTimeStamp = to_omx_ticks(av_rescale_q(frame->pts, avctx->time_base, AV_TIME_BASE_Q));
 802         if (frame->pict_type == AV_PICTURE_TYPE_I) {
 803 #if CONFIG_OMX_RPI
 804             OMX_CONFIG_BOOLEANTYPE config = {0, };
 805             INIT_STRUCT(config);
 806             config.bEnabled = OMX_TRUE;
 807             err = OMX_SetConfig(s->handle, OMX_IndexConfigBrcmVideoRequestIFrame, &config);
 808             if (err != OMX_ErrorNone) {
 809                 av_log(avctx, AV_LOG_ERROR, "OMX_SetConfig(RequestIFrame) failed: %x\n", err);
 810             }
 811 #else
 812             OMX_CONFIG_INTRAREFRESHVOPTYPE config = {0, };
 813             INIT_STRUCT(config);
 814             config.nPortIndex = s->out_port;
 815             config.IntraRefreshVOP = OMX_TRUE;
 816             err = OMX_SetConfig(s->handle, OMX_IndexConfigVideoIntraVOPRefresh, &config);
 817             if (err != OMX_ErrorNone) {
 818                 av_log(avctx, AV_LOG_ERROR, "OMX_SetConfig(IntraVOPRefresh) failed: %x\n", err);
 819             }
 820 #endif
 821         }
 822         err = OMX_EmptyThisBuffer(s->handle, buffer);
 823         if (err != OMX_ErrorNone) {
 824             append_buffer(&s->input_mutex, &s->input_cond, &s->num_free_in_buffers, s->free_in_buffers, buffer);
 825             av_log(avctx, AV_LOG_ERROR, "OMX_EmptyThisBuffer failed: %x\n", err);
 826             return AVERROR_UNKNOWN;
 827         }
 828     } else if (!s->eos_sent) {
 829         buffer = get_buffer(&s->input_mutex, &s->input_cond,
 830                             &s->num_free_in_buffers, s->free_in_buffers, 1);
 831
 832         buffer->nFilledLen = 0;
 833         buffer->nFlags = OMX_BUFFERFLAG_EOS;
 834         buffer->pAppPrivate = buffer->pOutputPortPrivate = NULL;
 835         err = OMX_EmptyThisBuffer(s->handle, buffer);
 836         if (err != OMX_ErrorNone) {
 837             append_buffer(&s->input_mutex, &s->input_cond, &s->num_free_in_buffers, s->free_in_buffers, buffer);
 838             av_log(avctx, AV_LOG_ERROR, "OMX_EmptyThisBuffer failed: %x\n", err);
 839             return AVERROR_UNKNOWN;
 840         }
 841         s->eos_sent = 1;
 842     }
 843
 844     while (!*got_packet && ret == 0 && !s->got_eos) {
 845         // If not flushing, just poll the queue if there's finished packets.
 846         // If flushing, do a blocking wait until we either get a completed
 847         // packet, or get EOS.
 848         buffer = get_buffer(&s->output_mutex, &s->output_cond,
 849                             &s->num_done_out_buffers, s->done_out_buffers,
 850                             !frame || had_partial);
 851         if (!buffer)
 852             break;
 853
 854         if (buffer->nFlags & OMX_BUFFERFLAG_EOS)
 855             s->got_eos = 1;
 856
 857         if (buffer->nFlags & OMX_BUFFERFLAG_CODECCONFIG && avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
 858             if ((ret = av_reallocp(&avctx->extradata, avctx->extradata_size + buffer->nFilledLen + AV_INPUT_BUFFER_PADDING_SIZE)) < 0) {
 859                 avctx->extradata_size = 0;
 860                 goto end;
 861             }
 862             memcpy(avctx->extradata + avctx->extradata_size, buffer->pBuffer + buffer->nOffset, buffer->nFilledLen);
 863             avctx->extradata_size += buffer->nFilledLen;
 864             memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
 865         } else {
 866             if (!(buffer->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) || !pkt->data) {
 867                 // If the output packet isn't preallocated, just concatenate everything in our
 868                 // own buffer
 869                 int newsize = s->output_buf_size + buffer->nFilledLen + AV_INPUT_BUFFER_PADDING_SIZE;
 870                 if ((ret = av_reallocp(&s->output_buf, newsize)) < 0) {
 871                     s->output_buf_size = 0;
 872                     goto end;
 873                 }
 874                 memcpy(s->output_buf + s->output_buf_size, buffer->pBuffer + buffer->nOffset, buffer->nFilledLen);
 875                 s->output_buf_size += buffer->nFilledLen;
 876                 if (buffer->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) {
 877                     if ((ret = av_packet_from_data(pkt, s->output_buf, s->output_buf_size)) < 0) {
 878                         av_freep(&s->output_buf);
 879                         s->output_buf_size = 0;
 880                         goto end;
 881                     }
 882                     s->output_buf = NULL;
 883                     s->output_buf_size = 0;
 884                 }
 885 #if CONFIG_OMX_RPI
 886                 had_partial = 1;
 887 #endif
 888             } else {
 889                 // End of frame, and the caller provided a preallocated frame
 890                 if ((ret = ff_alloc_packet2(avctx, pkt, s->output_buf_size + buffer->nFilledLen, 0)) < 0) {
 891                     av_log(avctx, AV_LOG_ERROR, "Error getting output packet of size %d.\n",
 892                            (int)(s->output_buf_size + buffer->nFilledLen));
 893                     goto end;
 894                 }
 895                 memcpy(pkt->data, s->output_buf, s->output_buf_size);
 896                 memcpy(pkt->data + s->output_buf_size, buffer->pBuffer + buffer->nOffset, buffer->nFilledLen);
 897                 av_freep(&s->output_buf);
 898                 s->output_buf_size = 0;
 899             }
 900             if (buffer->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) {
 901                 pkt->pts = av_rescale_q(from_omx_ticks(buffer->nTimeStamp), AV_TIME_BASE_Q, avctx->time_base);
 902                 // We don't currently enable B-frames for the encoders, so set
 903                 // pkt->dts = pkt->pts. (The calling code behaves worse if the encoder
 904                 // doesn't set the dts).
 905                 pkt->dts = pkt->pts;
 906                 if (buffer->nFlags & OMX_BUFFERFLAG_SYNCFRAME)
 907                     pkt->flags |= AV_PKT_FLAG_KEY;
 908                 *got_packet = 1;
 909             }
 910         }
 911 end:
 912         err = OMX_FillThisBuffer(s->handle, buffer);
 913         if (err != OMX_ErrorNone) {
 914             append_buffer(&s->output_mutex, &s->output_cond, &s->num_done_out_buffers, s->done_out_buffers, buffer);
 915             av_log(avctx, AV_LOG_ERROR, "OMX_FillThisBuffer failed: %x\n", err);
 916             ret = AVERROR_UNKNOWN;
 917         }
 918     }
 919     return ret;
 920 }
 921
 922 static av_cold int omx_encode_end(AVCodecContext *avctx)
 923 {
 924     OMXCodecContext *s = avctx->priv_data;
 925
 926     cleanup(s);
 927     return 0;
 928 }
 929
 930 #define OFFSET(x) offsetof(OMXCodecContext, x)
 931 #define VDE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 932 #define VE  AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 933 static const AVOption options[] = {
 934     { "omx_libname", "OpenMAX library name", OFFSET(libname), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
 935     { "omx_libprefix", "OpenMAX library prefix", OFFSET(libprefix), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
 936     { "zerocopy", "Try to avoid copying input frames if possible", OFFSET(input_zerocopy), AV_OPT_TYPE_INT, { .i64 = CONFIG_OMX_RPI }, 0, 1, VE },
 937     { "profile",  "Set the encoding profile", OFFSET(profile), AV_OPT_TYPE_INT,   { .i64 = FF_PROFILE_UNKNOWN },       FF_PROFILE_UNKNOWN, FF_PROFILE_H264_HIGH, VE, "profile" },
 938     { "baseline", "",                         0,               AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_BASELINE }, 0, 0, VE, "profile" },
 939     { "main",     "",                         0,               AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_MAIN },     0, 0, VE, "profile" },
 940     { "high",     "",                         0,               AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_HIGH },     0, 0, VE, "profile" },
 941     { NULL }
 942 };
 943
 944 static const enum AVPixelFormat omx_encoder_pix_fmts[] = {
 945     AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
 946 };
 947
 948 static const AVClass omx_mpeg4enc_class = {
 949     .class_name = "mpeg4_omx",
 950     .item_name  = av_default_item_name,
 951     .option     = options,
 952     .version    = LIBAVUTIL_VERSION_INT,
 953 };
 954 const AVCodec ff_mpeg4_omx_encoder = {
 955     .name             = "mpeg4_omx",
 956     .long_name        = NULL_IF_CONFIG_SMALL("OpenMAX IL MPEG-4 video encoder"),
 957     .type             = AVMEDIA_TYPE_VIDEO,
 958     .id               = AV_CODEC_ID_MPEG4,
 959     .priv_data_size   = sizeof(OMXCodecContext),
 960     .init             = omx_encode_init,
 961     .encode2          = omx_encode_frame,
 962     .close            = omx_encode_end,
 963     .pix_fmts         = omx_encoder_pix_fmts,
 964     .capabilities     = AV_CODEC_CAP_DELAY,
 965     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
 966     .priv_class       = &omx_mpeg4enc_class,
 967 };
 968
 969 static const AVClass omx_h264enc_class = {
 970     .class_name = "h264_omx",
 971     .item_name  = av_default_item_name,
 972     .option     = options,
 973     .version    = LIBAVUTIL_VERSION_INT,
 974 };
 975 const AVCodec ff_h264_omx_encoder = {
 976     .name             = "h264_omx",
 977     .long_name        = NULL_IF_CONFIG_SMALL("OpenMAX IL H.264 video encoder"),
 978     .type             = AVMEDIA_TYPE_VIDEO,
 979     .id               = AV_CODEC_ID_H264,
 980     .priv_data_size   = sizeof(OMXCodecContext),
 981     .init             = omx_encode_init,
 982     .encode2          = omx_encode_frame,
 983     .close            = omx_encode_end,
 984     .pix_fmts         = omx_encoder_pix_fmts,
 985     .capabilities     = AV_CODEC_CAP_DELAY,
 986     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
 987     .priv_class       = &omx_h264enc_class,
 988 };