diff options
| -rw-r--r-- | Changelog | 1 | ||||
| -rwxr-xr-x | configure | 7 | ||||
| -rw-r--r-- | libavcodec/Makefile | 2 | ||||
| -rw-r--r-- | libavcodec/allcodecs.c | 2 | ||||
| -rw-r--r-- | libavcodec/omx.c | 823 | ||||
| -rw-r--r-- | libavcodec/version.h | 2 |
6 files changed, 836 insertions, 1 deletions
@@ -54,6 +54,7 @@ version <next>: - VAAPI-accelerated format conversion and scaling - libnpp/CUDA-accelerated format conversion and scaling - VAAPI-accelerate H.264/HEVC/MJPEG encoding +- Generic OpenMAX IL encoder version 11: @@ -144,6 +144,7 @@ Hardware-accelerated decoding/encoding: --enable-libmfx enable HW acceleration through libmfx --enable-mmal enable decoding via MMAL [no] --enable-nvenc enable encoding via NVENC [no] + --enable-omx enable encoding via OpenMAX IL [no] Individual component options: --disable-everything disable all components listed below @@ -1272,6 +1273,7 @@ HW_CODECS_LIST=" libmfx mmal nvenc + omx " HWACCEL_LIST=" @@ -2106,6 +2108,7 @@ h264_mmal_decoder_deps="mmal" h264_mmal_hwaccel_deps="mmal" h264_mmal_decoder_select="h264_decoder" h264_mmal_encoder_deps="mmal" +h264_omx_encoder_deps="omx" h264_qsv_hwaccel_deps="libmfx" h264_vaapi_hwaccel_deps="vaapi" h264_vaapi_hwaccel_select="h264_decoder" @@ -2133,6 +2136,7 @@ mpeg2_vaapi_hwaccel_deps="vaapi" mpeg2_vaapi_hwaccel_select="mpeg2video_decoder" mpeg2_vdpau_hwaccel_deps="vdpau" mpeg2_vdpau_hwaccel_select="mpeg2video_decoder" +mpeg4_omx_encoder_deps="omx" mpeg4_vaapi_hwaccel_deps="vaapi" mpeg4_vaapi_hwaccel_select="mpeg4_decoder" mpeg4_vdpau_hwaccel_deps="vdpau" @@ -2153,6 +2157,8 @@ wmv3_vdpau_hwaccel_select="vc1_vdpau_hwaccel" # hardware-accelerated codecs nvenc_deps_any="dlopen LoadLibrary" nvenc_extralibs='$ldl' +omx_deps="dlopen pthreads" +omx_extralibs='$ldl' qsvdec_select="qsv" qsvenc_select="qsv" vaapi_encode_deps="vaapi" @@ -4615,6 +4621,7 @@ enabled mmal && { check_lib interface/mmal/mmal.h mmal_port_connect check_lib interface/mmal/mmal.h mmal_port_connect ; } check_lib interface/mmal/mmal.h mmal_port_connect ; } || die "ERROR: mmal not found"; } +enabled omx && { check_header OMX_Core.h || die "ERROR: OpenMAX IL headers not found"; } enabled openssl && { check_pkg_config openssl openssl/ssl.h SSL_library_init && { add_cflags $openssl_cflags && add_extralibs $openssl_libs; }|| check_lib openssl/ssl.h SSL_library_init -lssl -lcrypto || diff --git a/libavcodec/Makefile b/libavcodec/Makefile index fbe9998da7..d9f614de8b 100644 --- a/libavcodec/Makefile +++ b/libavcodec/Makefile @@ -621,6 +621,7 @@ OBJS-$(CONFIG_QSVENC) += qsvenc.o OBJS-$(CONFIG_H264_MMAL_DECODER) += mmaldec.o OBJS-$(CONFIG_H264_NVENC_ENCODER) += nvenc_h264.o +OBJS-$(CONFIG_H264_OMX_ENCODER) += omx.o OBJS-$(CONFIG_H264_QSV_DECODER) += qsvdec_h2645.o OBJS-$(CONFIG_H264_QSV_ENCODER) += qsvenc_h264.o OBJS-$(CONFIG_H264_VAAPI_ENCODER) += vaapi_encode_h264.o vaapi_encode_h26x.o @@ -630,6 +631,7 @@ OBJS-$(CONFIG_HEVC_QSV_ENCODER) += qsvenc_hevc.o hevc_ps_enc.o h2645_p OBJS-$(CONFIG_HEVC_VAAPI_ENCODER) += vaapi_encode_h265.o vaapi_encode_h26x.o OBJS-$(CONFIG_MPEG2_QSV_DECODER) += qsvdec_mpeg2.o OBJS-$(CONFIG_MPEG2_QSV_ENCODER) += qsvenc_mpeg2.o +OBJS-$(CONFIG_MPEG4_OMX_ENCODER) += omx.o # libavformat dependencies OBJS-$(CONFIG_ISO_MEDIA) += mpeg4audio.o mpegaudiodata.o diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c index 5446ec3efb..16e9cd647c 100644 --- a/libavcodec/allcodecs.c +++ b/libavcodec/allcodecs.c @@ -487,11 +487,13 @@ void avcodec_register_all(void) * above is available */ REGISTER_ENCODER(LIBOPENH264, libopenh264); REGISTER_ENCODER(H264_NVENC, h264_nvenc); + REGISTER_ENCODER(H264_OMX, h264_omx); REGISTER_ENCODER(H264_QSV, h264_qsv); REGISTER_ENCODER(LIBKVAZAAR, libkvazaar); REGISTER_ENCODER(HEVC_NVENC, hevc_nvenc); REGISTER_ENCODER(HEVC_QSV, hevc_qsv); REGISTER_ENCODER(MPEG2_QSV, mpeg2_qsv); + REGISTER_ENCODER(MPEG4_OMX, mpeg4_omx); #if FF_API_NVENC_OLD_NAME REGISTER_ENCODER(NVENC_H264, nvenc_h264); REGISTER_ENCODER(NVENC_HEVC, nvenc_hevc); diff --git a/libavcodec/omx.c b/libavcodec/omx.c new file mode 100644 index 0000000000..6a4a5a1de5 --- /dev/null +++ b/libavcodec/omx.c @@ -0,0 +1,823 @@ +/* + * OMX Video encoder + * Copyright (C) 2011 Martin Storsjo + * + * This file is part of Libav. + * + * Libav is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * Libav is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Libav; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <dlfcn.h> +#include <OMX_Core.h> +#include <OMX_Component.h> +#include <pthread.h> +#include <stdio.h> +#include <stdlib.h> +#include <sys/time.h> + +#include "libavutil/avstring.h" +#include "libavutil/avutil.h" +#include "libavutil/common.h" +#include "libavutil/imgutils.h" +#include "libavutil/log.h" +#include "libavutil/opt.h" + +#include "avcodec.h" +#include "h264.h" +#include "internal.h" + +#ifdef OMX_SKIP64BIT +static OMX_TICKS to_omx_ticks(int64_t value) +{ + OMX_TICKS s; + s.nLowPart = value & 0xffffffff; + s.nHighPart = value >> 32; + return s; +} +static int64_t from_omx_ticks(OMX_TICKS value) +{ + return (((int64_t)value.nHighPart) << 32) | value.nLowPart; +} +#else +#define to_omx_ticks(x) (x) +#define from_omx_ticks(x) (x) +#endif + +#define INIT_STRUCT(x) do { \ + x.nSize = sizeof(x); \ + x.nVersion = s->version; \ + } while (0) +#define CHECK(x) do { \ + if (x != OMX_ErrorNone) { \ + av_log(avctx, AV_LOG_ERROR, \ + "err %x (%d) on line %d\n", x, x, __LINE__); \ + return AVERROR_UNKNOWN; \ + } \ + } while (0) + +typedef struct OMXContext { + void *lib; + OMX_ERRORTYPE (*ptr_Init)(void); + OMX_ERRORTYPE (*ptr_Deinit)(void); + OMX_ERRORTYPE (*ptr_ComponentNameEnum)(OMX_STRING, OMX_U32, OMX_U32); + OMX_ERRORTYPE (*ptr_GetHandle)(OMX_HANDLETYPE*, OMX_STRING, OMX_PTR, OMX_CALLBACKTYPE*); + OMX_ERRORTYPE (*ptr_FreeHandle)(OMX_HANDLETYPE); + OMX_ERRORTYPE (*ptr_GetComponentsOfRole)(OMX_STRING, OMX_U32*, OMX_U8**); + OMX_ERRORTYPE (*ptr_GetRolesOfComponent)(OMX_STRING, OMX_U32*, OMX_U8**); +} OMXContext; + +static av_cold void *dlsym_prefixed(void *handle, const char *symbol, const char *prefix) +{ + char buf[50]; + snprintf(buf, sizeof(buf), "%s%s", prefix ? prefix : "", symbol); + return dlsym(handle, buf); +} + +static av_cold int omx_try_load(OMXContext *s, void *logctx, + const char *libname, const char *prefix) +{ + s->lib = dlopen(libname, RTLD_NOW | RTLD_GLOBAL); + if (!s->lib) { + av_log(logctx, AV_LOG_WARNING, "%s not found\n", libname); + return AVERROR_ENCODER_NOT_FOUND; + } + s->ptr_Init = dlsym_prefixed(s->lib, "OMX_Init", prefix); + s->ptr_Deinit = dlsym_prefixed(s->lib, "OMX_Deinit", prefix); + s->ptr_ComponentNameEnum = dlsym_prefixed(s->lib, "OMX_ComponentNameEnum", prefix); + s->ptr_GetHandle = dlsym_prefixed(s->lib, "OMX_GetHandle", prefix); + s->ptr_FreeHandle = dlsym_prefixed(s->lib, "OMX_FreeHandle", prefix); + s->ptr_GetComponentsOfRole = dlsym_prefixed(s->lib, "OMX_GetComponentsOfRole", prefix); + s->ptr_GetRolesOfComponent = dlsym_prefixed(s->lib, "OMX_GetRolesOfComponent", prefix); + if (!s->ptr_Init || !s->ptr_Deinit || !s->ptr_ComponentNameEnum || + !s->ptr_GetHandle || !s->ptr_FreeHandle || + !s->ptr_GetComponentsOfRole || !s->ptr_GetRolesOfComponent) { + av_log(logctx, AV_LOG_WARNING, "Not all functions found in %s\n", libname); + dlclose(s->lib); + s->lib = NULL; + return AVERROR_ENCODER_NOT_FOUND; + } + return 0; +} + +static av_cold OMXContext *omx_init(void *logctx, const char *libname, const char *prefix) +{ + static const char * const libnames[] = { + "libOMX_Core.so", + "libOmxCore.so", + NULL + }; + const char* const* nameptr; + int ret = AVERROR_ENCODER_NOT_FOUND; + OMXContext *omx_context; + + omx_context = av_mallocz(sizeof(*omx_context)); + if (!omx_context) + return NULL; + if (libname) { + ret = omx_try_load(omx_context, logctx, libname, prefix); + if (ret < 0) { + av_free(omx_context); + return NULL; + } + } else { + for (nameptr = libnames; *nameptr; nameptr++) + if (!(ret = omx_try_load(omx_context, logctx, *nameptr, prefix))) + break; + if (!*nameptr) { + av_free(omx_context); + return NULL; + } + } + + omx_context->ptr_Init(); + return omx_context; +} + +static av_cold void omx_deinit(OMXContext *omx_context) +{ + if (!omx_context) + return; + omx_context->ptr_Deinit(); + dlclose(omx_context->lib); + av_free(omx_context); +} + +typedef struct OMXCodecContext { + const AVClass *class; + char *libname; + char *libprefix; + OMXContext *omx_context; + + AVCodecContext *avctx; + + char component_name[OMX_MAX_STRINGNAME_SIZE]; + OMX_VERSIONTYPE version; + OMX_HANDLETYPE handle; + int in_port, out_port; + OMX_COLOR_FORMATTYPE color_format; + int stride, plane_size; + + int num_in_buffers, num_out_buffers; + OMX_BUFFERHEADERTYPE **in_buffer_headers; + OMX_BUFFERHEADERTYPE **out_buffer_headers; + int num_free_in_buffers; + OMX_BUFFERHEADERTYPE **free_in_buffers; + int num_done_out_buffers; + OMX_BUFFERHEADERTYPE **done_out_buffers; + pthread_mutex_t input_mutex; + pthread_cond_t input_cond; + pthread_mutex_t output_mutex; + pthread_cond_t output_cond; + + pthread_mutex_t state_mutex; + pthread_cond_t state_cond; + OMX_STATETYPE state; + OMX_ERRORTYPE error; + + int mutex_cond_inited; + + int num_in_frames, num_out_frames; + + uint8_t *output_buf; + int output_buf_size; +} OMXCodecContext; + +static void append_buffer(pthread_mutex_t *mutex, pthread_cond_t *cond, + int* array_size, OMX_BUFFERHEADERTYPE **array, + OMX_BUFFERHEADERTYPE *buffer) +{ + pthread_mutex_lock(mutex); + array[(*array_size)++] = buffer; + pthread_cond_broadcast(cond); + pthread_mutex_unlock(mutex); +} + +static OMX_BUFFERHEADERTYPE *get_buffer(pthread_mutex_t *mutex, pthread_cond_t *cond, + int* array_size, OMX_BUFFERHEADERTYPE **array, + int wait) +{ + OMX_BUFFERHEADERTYPE *buffer; + pthread_mutex_lock(mutex); + if (wait) { + while (!*array_size) + pthread_cond_wait(cond, mutex); + } + if (*array_size > 0) { + buffer = array[0]; + (*array_size)--; + memmove(&array[0], &array[1], (*array_size) * sizeof(OMX_BUFFERHEADERTYPE*)); + } else { + buffer = NULL; + } + pthread_mutex_unlock(mutex); + return buffer; +} + +static OMX_ERRORTYPE event_handler(OMX_HANDLETYPE component, OMX_PTR app_data, OMX_EVENTTYPE event, + OMX_U32 data1, OMX_U32 data2, OMX_PTR event_data) +{ + OMXCodecContext *s = app_data; + // This uses casts in the printfs, since OMX_U32 actually is a typedef for + // unsigned long in official header versions (but there are also modified + // versions where it is something else). + switch (event) { + case OMX_EventError: + pthread_mutex_lock(&s->state_mutex); + av_log(s->avctx, AV_LOG_ERROR, "OMX error %"PRIx32"\n", (uint32_t) data1); + s->error = data1; + pthread_cond_broadcast(&s->state_cond); + pthread_mutex_unlock(&s->state_mutex); + break; + case OMX_EventCmdComplete: + if (data1 == OMX_CommandStateSet) { + pthread_mutex_lock(&s->state_mutex); + s->state = data2; + av_log(s->avctx, AV_LOG_VERBOSE, "OMX state changed to %"PRIu32"\n", (uint32_t) data2); + pthread_cond_broadcast(&s->state_cond); + pthread_mutex_unlock(&s->state_mutex); + } else if (data1 == OMX_CommandPortDisable) { + av_log(s->avctx, AV_LOG_VERBOSE, "OMX port %"PRIu32" disabled\n", (uint32_t) data2); + } else if (data1 == OMX_CommandPortEnable) { + av_log(s->avctx, AV_LOG_VERBOSE, "OMX port %"PRIu32" enabled\n", (uint32_t) data2); + } else { + av_log(s->avctx, AV_LOG_VERBOSE, "OMX command complete, command %"PRIu32", value %"PRIu32"\n", + (uint32_t) data1, (uint32_t) data2); + } + break; + case OMX_EventPortSettingsChanged: + av_log(s->avctx, AV_LOG_VERBOSE, "OMX port %"PRIu32" settings changed\n", (uint32_t) data1); + break; + default: + av_log(s->avctx, AV_LOG_VERBOSE, "OMX event %d %"PRIx32" %"PRIx32"\n", + event, (uint32_t) data1, (uint32_t) data2); + break; + } + return OMX_ErrorNone; +} + +static OMX_ERRORTYPE empty_buffer_done(OMX_HANDLETYPE component, OMX_PTR app_data, + OMX_BUFFERHEADERTYPE *buffer) +{ + OMXCodecContext *s = app_data; + append_buffer(&s->input_mutex, &s->input_cond, + &s->num_free_in_buffers, s->free_in_buffers, buffer); + return OMX_ErrorNone; +} + +static OMX_ERRORTYPE fill_buffer_done(OMX_HANDLETYPE component, OMX_PTR app_data, + OMX_BUFFERHEADERTYPE *buffer) +{ + OMXCodecContext *s = app_data; + append_buffer(&s->output_mutex, &s->output_cond, + &s->num_done_out_buffers, s->done_out_buffers, buffer); + return OMX_ErrorNone; +} + +static const OMX_CALLBACKTYPE callbacks = { + event_handler, + empty_buffer_done, + fill_buffer_done +}; + +static av_cold int find_component(OMXContext *omx_context, void *logctx, + const char *role, char *str, int str_size) +{ + OMX_U32 i, num = 0; + char **components; + int ret = 0; + + omx_context->ptr_GetComponentsOfRole((OMX_STRING) role, &num, NULL); + if (!num) { + av_log(logctx, AV_LOG_WARNING, "No component for role %s found\n", role); + return AVERROR_ENCODER_NOT_FOUND; + } + components = av_mallocz(sizeof(char*) * num); + if (!components) + return AVERROR(ENOMEM); + for (i = 0; i < num; i++) { + components[i] = av_mallocz(OMX_MAX_STRINGNAME_SIZE); + if (!components) { + ret = AVERROR(ENOMEM); + goto end; + } + } + omx_context->ptr_GetComponentsOfRole((OMX_STRING) role, &num, (OMX_U8**) components); + av_strlcpy(str, components[0], str_size); +end: + for (i = 0; i < num; i++) + av_free(components[i]); + av_free(components); + return ret; +} + +static av_cold int wait_for_state(OMXCodecContext *s, OMX_STATETYPE state) +{ + int ret = 0; + pthread_mutex_lock(&s->state_mutex); + while (s->state != state && s->error == OMX_ErrorNone) + pthread_cond_wait(&s->state_cond, &s->state_mutex); + if (s->error != OMX_ErrorNone) + ret = AVERROR_ENCODER_NOT_FOUND; + pthread_mutex_unlock(&s->state_mutex); + return ret; +} + +static av_cold int omx_component_init(AVCodecContext *avctx, const char *role) +{ + OMXCodecContext *s = avctx->priv_data; + OMX_PARAM_COMPONENTROLETYPE role_params = { 0 }; + OMX_PORT_PARAM_TYPE video_port_params = { 0 }; + OMX_PARAM_PORTDEFINITIONTYPE in_port_params = { 0 }, out_port_params = { 0 }; + OMX_VIDEO_PARAM_PORTFORMATTYPE video_port_format = { 0 }; + OMX_VIDEO_PARAM_BITRATETYPE vid_param_bitrate = { 0 }; + OMX_ERRORTYPE err; + int i; + + s->version.s.nVersionMajor = 1; + s->version.s.nVersionMinor = 1; + s->version.s.nRevision = 2; + + err = s->omx_context->ptr_GetHandle(&s->handle, s->component_name, s, (OMX_CALLBACKTYPE*) &callbacks); + if (err != OMX_ErrorNone) { + av_log(avctx, AV_LOG_ERROR, "OMX_GetHandle(%s) failed: %x\n", s->component_name, err); + return AVERROR_UNKNOWN; + } + + // This one crashes the mediaserver on qcom, if used over IOMX + INIT_STRUCT(role_params); + av_strlcpy(role_params.cRole, role, sizeof(role_params.cRole)); + // Intentionally ignore errors on this one + OMX_SetParameter(s->handle, OMX_IndexParamStandardComponentRole, &role_params); + + INIT_STRUCT(video_port_params); + err = OMX_GetParameter(s->handle, OMX_IndexParamVideoInit, &video_port_params); + CHECK(err); + + s->in_port = s->out_port = -1; + for (i = 0; i < video_port_params.nPorts; i++) { + int port = video_port_params.nStartPortNumber + i; + OMX_PARAM_PORTDEFINITIONTYPE port_params = { 0 }; + INIT_STRUCT(port_params); + port_params.nPortIndex = port; + err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &port_params); + if (err != OMX_ErrorNone) { + av_log(avctx, AV_LOG_WARNING, "port %d error %x\n", port, err); + break; + } + if (port_params.eDir == OMX_DirInput && s->in_port < 0) { + in_port_params = port_params; + s->in_port = port; + } else if (port_params.eDir == OMX_DirOutput && s->out_port < 0) { + out_port_params = port_params; + s->out_port = port; + } + } + if (s->in_port < 0 || s->out_port < 0) { + av_log(avctx, AV_LOG_ERROR, "No in or out port found (in %d out %d)\n", s->in_port, s->out_port); + return AVERROR_UNKNOWN; + } + + s->color_format = 0; + for (i = 0; ; i++) { + INIT_STRUCT(video_port_format); + video_port_format.nIndex = i; + video_port_format.nPortIndex = s->in_port; + if (OMX_GetParameter(s->handle, OMX_IndexParamVideoPortFormat, &video_port_format) != OMX_ErrorNone) + break; + if (video_port_format.eColorFormat == OMX_COLOR_FormatYUV420Planar || + video_port_format.eColorFormat == OMX_COLOR_FormatYUV420PackedPlanar) { + s->color_format = video_port_format.eColorFormat; + break; + } + } + if (s->color_format == 0) { + av_log(avctx, AV_LOG_ERROR, "No supported pixel formats (%d formats available)\n", i); + return AVERROR_UNKNOWN; + } + + in_port_params.bEnabled = OMX_TRUE; + in_port_params.bPopulated = OMX_FALSE; + in_port_params.eDomain = OMX_PortDomainVideo; + + in_port_params.format.video.pNativeRender = NULL; + in_port_params.format.video.bFlagErrorConcealment = OMX_FALSE; + in_port_params.format.video.eColorFormat = s->color_format; + s->stride = avctx->width; + s->plane_size = avctx->height; + // If specific codecs need to manually override the stride/plane_size, + // that can be done here. + in_port_params.format.video.nStride = s->stride; + in_port_params.format.video.nSliceHeight = s->plane_size; + in_port_params.format.video.nFrameWidth = avctx->width; + in_port_params.format.video.nFrameHeight = avctx->height; + if (avctx->framerate.den > 0 && avctx->framerate.num > 0) + in_port_params.format.video.xFramerate = (1 << 16) * avctx->framerate.num / avctx->framerate.den; + else + in_port_params.format.video.xFramerate = (1 << 16) * avctx->time_base.den / avctx->time_base.num; + + err = OMX_SetParameter(s->handle, OMX_IndexParamPortDefinition, &in_port_params); + CHECK(err); + err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &in_port_params); + CHECK(err); + s->stride = in_port_params.format.video.nStride; + s->plane_size = in_port_params.format.video.nSliceHeight; + s->num_in_buffers = in_port_params.nBufferCountActual; + + err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &out_port_params); + out_port_params.bEnabled = OMX_TRUE; + out_port_params.bPopulated = OMX_FALSE; + out_port_params.eDomain = OMX_PortDomainVideo; + out_port_params.format.video.pNativeRender = NULL; + out_port_params.format.video.nFrameWidth = avctx->width; + out_port_params.format.video.nFrameHeight = avctx->height; + out_port_params.format.video.nStride = 0; + out_port_params.format.video.nSliceHeight = 0; + out_port_params.format.video.nBitrate = avctx->bit_rate; + out_port_params.format.video.xFramerate = in_port_params.format.video.xFramerate; + out_port_params.format.video.bFlagErrorConcealment = OMX_FALSE; + if (avctx->codec->id == AV_CODEC_ID_MPEG4) + out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4; + else if (avctx->codec->id == AV_CODEC_ID_H264) + out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC; + + err = OMX_SetParameter(s->handle, OMX_IndexParamPortDefinition, &out_port_params); + CHECK(err); + err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &out_port_params); + CHECK(err); + s->num_out_buffers = out_port_params.nBufferCountActual; + + INIT_STRUCT(vid_param_bitrate); + vid_param_bitrate.nPortIndex = s->out_port; + vid_param_bitrate.eControlRate = OMX_Video_ControlRateVariable; + vid_param_bitrate.nTargetBitrate = avctx->bit_rate; + err = OMX_SetParameter(s->handle, OMX_IndexParamVideoBitrate, &vid_param_bitrate); + if (err != OMX_ErrorNone) + av_log(avctx, AV_LOG_WARNING, "Unable to set video bitrate parameter\n"); + + if (avctx->codec->id == AV_CODEC_ID_H264) { + OMX_VIDEO_PARAM_AVCTYPE avc = { 0 }; + INIT_STRUCT(avc); + avc.nPortIndex = s->out_port; + err = OMX_GetParameter(s->handle, OMX_IndexParamVideoAvc, &avc); + CHECK(err); + avc.nBFrames = 0; + avc.nPFrames = avctx->gop_size - 1; + err = OMX_SetParameter(s->handle, OMX_IndexParamVideoAvc, &avc); + CHECK(err); + } + + err = OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateIdle, NULL); + CHECK(err); + + s->in_buffer_headers = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_in_buffers); + s->free_in_buffers = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_in_buffers); + s->out_buffer_headers = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_out_buffers); + s->done_out_buffers = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_out_buffers); + if (!s->in_buffer_headers || !s->free_in_buffers || !s->out_buffer_headers || !s->done_out_buffers) + return AVERROR(ENOMEM); + for (i = 0; i < s->num_in_buffers && err == OMX_ErrorNone; i++) + err = OMX_AllocateBuffer(s->handle, &s->in_buffer_headers[i], s->in_port, s, in_port_params.nBufferSize); + CHECK(err); + s->num_in_buffers = i; + for (i = 0; i < s->num_out_buffers && err == OMX_ErrorNone; i++) + err = OMX_AllocateBuffer(s->handle, &s->out_buffer_headers[i], s->out_port, s, out_port_params.nBufferSize); + CHECK(err); + s->num_out_buffers = i; + + if (wait_for_state(s, OMX_StateIdle) < 0) { + av_log(avctx, AV_LOG_ERROR, "Didn't get OMX_StateIdle\n"); + return AVERROR_UNKNOWN; + } + err = OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateExecuting, NULL); + CHECK(err); + if (wait_for_state(s, OMX_StateExecuting) < 0) { + av_log(avctx, AV_LOG_ERROR, "Didn't get OMX_StateExecuting\n"); + return AVERROR_UNKNOWN; + } + + for (i = 0; i < s->num_out_buffers && err == OMX_ErrorNone; i++) + err = OMX_FillThisBuffer(s->handle, s->out_buffer_headers[i]); + if (err != OMX_ErrorNone) { + for (; i < s->num_out_buffers; i++) + s->done_out_buffers[s->num_done_out_buffers++] = s->out_buffer_headers[i]; + } + for (i = 0; i < s->num_in_buffers; i++) + s->free_in_buffers[s->num_free_in_buffers++] = s->in_buffer_headers[i]; + return err != OMX_ErrorNone ? AVERROR_UNKNOWN : 0; +} + +static av_cold void cleanup(OMXCodecContext *s) +{ + int i, executing; + + pthread_mutex_lock(&s->state_mutex); + executing = s->state == OMX_StateExecuting; + pthread_mutex_unlock(&s->state_mutex); + + if (executing) { + OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateIdle, NULL); + wait_for_state(s, OMX_StateIdle); + OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateLoaded, NULL); + for (i = 0; i < s->num_in_buffers; i++) { + OMX_BUFFERHEADERTYPE *buffer = get_buffer(&s->input_mutex, &s->input_cond, + &s->num_free_in_buffers, s->free_in_buffers, 1); + OMX_FreeBuffer(s->handle, s->in_port, buffer); + } + for (i = 0; i < s->num_out_buffers; i++) { + OMX_BUFFERHEADERTYPE *buffer = get_buffer(&s->output_mutex, &s->output_cond, + &s->num_done_out_buffers, s->done_out_buffers, 1); + OMX_FreeBuffer(s->handle, s->out_port, buffer); + } + wait_for_state(s, OMX_StateLoaded); + } + if (s->handle) { + s->omx_context->ptr_FreeHandle(s->handle); + s->handle = NULL; + } + + omx_deinit(s->omx_context); + s->omx_context = NULL; + if (s->mutex_cond_inited) { + pthread_cond_destroy(&s->state_cond); + pthread_mutex_destroy(&s->state_mutex); + pthread_cond_destroy(&s->input_cond); + pthread_mutex_destroy(&s->input_mutex); + pthread_cond_destroy(&s->output_cond); + pthread_mutex_destroy(&s->output_mutex); + s->mutex_cond_inited = 0; + } + av_freep(&s->in_buffer_headers); + av_freep(&s->out_buffer_headers); + av_freep(&s->free_in_buffers); + av_freep(&s->done_out_buffers); + av_freep(&s->output_buf); +} + +static av_cold int omx_encode_init(AVCodecContext *avctx) +{ + OMXCodecContext *s = avctx->priv_data; + int ret = AVERROR_ENCODER_NOT_FOUND; + const char *role; + OMX_BUFFERHEADERTYPE *buffer; + OMX_ERRORTYPE err; + + s->omx_context = omx_init(avctx, s->libname, s->libprefix); + if (!s->omx_context) + return AVERROR_ENCODER_NOT_FOUND; + + pthread_mutex_init(&s->state_mutex, NULL); + pthread_cond_init(&s->state_cond, NULL); + pthread_mutex_init(&s->input_mutex, NULL); + pthread_cond_init(&s->input_cond, NULL); + pthread_mutex_init(&s->output_mutex, NULL); + pthread_cond_init(&s->output_cond, NULL); + s->mutex_cond_inited = 1; + s->avctx = avctx; + s->state = OMX_StateLoaded; + s->error = OMX_ErrorNone; + + switch (avctx->codec->id) { + case AV_CODEC_ID_MPEG4: + role = "video_encoder.mpeg4"; + break; + case AV_CODEC_ID_H264: + role = "video_encoder.avc"; + break; + default: + return AVERROR(ENOSYS); + } + + if ((ret = find_component(s->omx_context, avctx, role, s->component_name, sizeof(s->component_name))) < 0) + goto fail; + + av_log(avctx, AV_LOG_INFO, "Using %s\n", s->component_name); + + if ((ret = omx_component_init(avctx, role)) < 0) + goto fail; + + if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) { + while (1) { + buffer = get_buffer(&s->output_mutex, &s->output_cond, + &s->num_done_out_buffers, s->done_out_buffers, 1); + if (buffer->nFlags & OMX_BUFFERFLAG_CODECCONFIG) { + if ((ret = av_reallocp(&avctx->extradata, avctx->extradata_size + buffer->nFilledLen + AV_INPUT_BUFFER_PADDING_SIZE)) < 0) { + avctx->extradata_size = 0; + goto fail; + } + memcpy(avctx->extradata + avctx->extradata_size, buffer->pBuffer + buffer->nOffset, buffer->nFilledLen); + avctx->extradata_size += buffer->nFilledLen; + memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE); + } + err = OMX_FillThisBuffer(s->handle, buffer); + if (err != OMX_ErrorNone) { + append_buffer(&s->output_mutex, &s->output_cond, + &s->num_done_out_buffers, s->done_out_buffers, buffer); + av_log(avctx, AV_LOG_ERROR, "OMX_FillThisBuffer failed: %x\n", err); + ret = AVERROR_UNKNOWN; + goto fail; + } + if (avctx->codec->id == AV_CODEC_ID_H264) { + // For H264, the extradata can be returned in two separate buffers + // (the videocore encoder on raspberry pi does this); + // therefore check that we have got both SPS and PPS before continuing. + int nals[32] = { 0 }; + int i; + for (i = 0; i + 4 < avctx->extradata_size; i++) { + if (!avctx->extradata[i + 0] && + !avctx->extradata[i + 1] && + !avctx->extradata[i + 2] && + avctx->extradata[i + 3] == 1) { + nals[avctx->extradata[i + 4] & 0x1f]++; + } + } + if (nals[NAL_SPS] && nals[NAL_PPS]) + break; + } else { + if (avctx->extradata_size > 0) + break; + } + } + } + + return 0; +fail: + return ret; +} + + +static int omx_encode_frame(AVCodecContext *avctx, AVPacket *pkt, + const AVFrame *frame, int *got_packet) +{ + OMXCodecContext *s = avctx->priv_data; + int ret = 0; + OMX_BUFFERHEADERTYPE* buffer; + OMX_ERRORTYPE err; + + if (frame) { + uint8_t *dst[4]; + int linesize[4]; + buffer = get_buffer(&s->input_mutex, &s->input_cond, + &s->num_free_in_buffers, s->free_in_buffers, 1); + + buffer->nFilledLen = av_image_fill_arrays(dst, linesize, buffer->pBuffer, avctx->pix_fmt, s->stride, s->plane_size, 1); + av_image_copy(dst, linesize, (const uint8_t**) frame->data, frame->linesize, avctx->pix_fmt, avctx->width, avctx->height); + buffer->nFlags = OMX_BUFFERFLAG_ENDOFFRAME; + buffer->nOffset = 0; + // Convert the timestamps to microseconds; some encoders can ignore + // the framerate and do VFR bit allocation based on timestamps. + buffer->nTimeStamp = to_omx_ticks(av_rescale_q(frame->pts, avctx->time_base, AV_TIME_BASE_Q)); + err = OMX_EmptyThisBuffer(s->handle, buffer); + if (err != OMX_ErrorNone) { + append_buffer(&s->input_mutex, &s->input_cond, &s->num_free_in_buffers, s->free_in_buffers, buffer); + av_log(avctx, AV_LOG_ERROR, "OMX_EmptyThisBuffer failed: %x\n", err); + return AVERROR_UNKNOWN; + } + s->num_in_frames++; + } + + while (!*got_packet && ret == 0) { + // Only wait for output if flushing and not all frames have been output + buffer = get_buffer(&s->output_mutex, &s->output_cond, + &s->num_done_out_buffers, s->done_out_buffers, + !frame && s->num_out_frames < s->num_in_frames); + if (!buffer) + break; + + if (buffer->nFlags & OMX_BUFFERFLAG_CODECCONFIG && avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) { + if ((ret = av_reallocp(&avctx->extradata, avctx->extradata_size + buffer->nFilledLen + AV_INPUT_BUFFER_PADDING_SIZE)) < 0) { + avctx->extradata_size = 0; + goto end; + } + memcpy(avctx->extradata + avctx->extradata_size, buffer->pBuffer + buffer->nOffset, buffer->nFilledLen); + avctx->extradata_size += buffer->nFilledLen; + memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE); + } else { + if (buffer->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) + s->num_out_frames++; + if (!(buffer->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) || !pkt->data) { + // If the output packet isn't preallocated, just concatenate everything in our + // own buffer + int newsize = s->output_buf_size + buffer->nFilledLen + AV_INPUT_BUFFER_PADDING_SIZE; + if ((ret = av_reallocp(&s->output_buf, newsize)) < 0) { + s->output_buf_size = 0; + goto end; + } + memcpy(s->output_buf + s->output_buf_size, buffer->pBuffer + buffer->nOffset, buffer->nFilledLen); + s->output_buf_size += buffer->nFilledLen; + if (buffer->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) { + if ((ret = av_packet_from_data(pkt, s->output_buf, s->output_buf_size)) < 0) { + av_freep(&s->output_buf); + s->output_buf_size = 0; + goto end; + } + s->output_buf = NULL; + s->output_buf_size = 0; + } + } else { + // End of frame, and the caller provided a preallocated frame + if ((ret = ff_alloc_packet(pkt, s->output_buf_size + buffer->nFilledLen)) < 0) { + av_log(avctx, AV_LOG_ERROR, "Error getting output packet of size %d.\n", + (int)(s->output_buf_size + buffer->nFilledLen)); + goto end; + } + memcpy(pkt->data, s->output_buf, s->output_buf_size); + memcpy(pkt->data + s->output_buf_size, buffer->pBuffer + buffer->nOffset, buffer->nFilledLen); + av_freep(&s->output_buf); + s->output_buf_size = 0; + } + if (buffer->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) { + ret = pkt->size; + pkt->pts = av_rescale_q(from_omx_ticks(buffer->nTimeStamp), AV_TIME_BASE_Q, avctx->time_base); + // We don't currently enable b-frames for the encoders, so set + // pkt->dts = pkt->pts. (The calling code behaves worse if the encoder + // doesn't set the dts). + pkt->dts = pkt->pts; + if (buffer->nFlags & OMX_BUFFERFLAG_SYNCFRAME) + pkt->flags |= AV_PKT_FLAG_KEY; + *got_packet = 1; + } + } +end: + err = OMX_FillThisBuffer(s->handle, buffer); + if (err != OMX_ErrorNone) { + append_buffer(&s->output_mutex, &s->output_cond, &s->num_done_out_buffers, s->done_out_buffers, buffer); + av_log(avctx, AV_LOG_ERROR, "OMX_FillThisBuffer failed: %x\n", err); + ret = AVERROR_UNKNOWN; + } + } + return ret; +} + +static av_cold int omx_encode_end(AVCodecContext *avctx) +{ + OMXCodecContext *s = avctx->priv_data; + + cleanup(s); + return 0; +} + +#define OFFSET(x) offsetof(OMXCodecContext, x) +#define VDE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM +static const AVOption options[] = { + { "omx_libname", "OpenMAX library name", OFFSET(libname), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE }, + { "omx_libprefix", "OpenMAX library prefix", OFFSET(libprefix), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE }, + { NULL } +}; + +static const enum AVPixelFormat omx_encoder_pix_fmts[] = { + AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE +}; + +static const AVClass omx_mpeg4enc_class = { + .class_name = "mpeg4_omx", + .item_name = av_default_item_name, + .option = options, + .version = LIBAVUTIL_VERSION_INT, +}; +AVCodec ff_mpeg4_omx_encoder = { + .name = "mpeg4_omx", + .long_name = NULL_IF_CONFIG_SMALL("OpenMAX IL MPEG4 video encoder"), + .type = AVMEDIA_TYPE_VIDEO, + .id = AV_CODEC_ID_MPEG4, + .priv_data_size = sizeof(OMXCodecContext), + .init = omx_encode_init, + .encode2 = omx_encode_frame, + .close = omx_encode_end, + .pix_fmts = omx_encoder_pix_fmts, + .capabilities = AV_CODEC_CAP_DELAY, + .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP, + .priv_class = &omx_mpeg4enc_class, +}; + +static const AVClass omx_h264enc_class = { + .class_name = "h264_omx", + .item_name = av_default_item_name, + .option = options, + .version = LIBAVUTIL_VERSION_INT, +}; +AVCodec ff_h264_omx_encoder = { + .name = "h264_omx", + .long_name = NULL_IF_CONFIG_SMALL("OpenMAX IL H264 video encoder"), + .type = AVMEDIA_TYPE_VIDEO, + .id = AV_CODEC_ID_H264, + .priv_data_size = sizeof(OMXCodecContext), + .init = omx_encode_init, + .encode2 = omx_encode_frame, + .close = omx_encode_end, + .pix_fmts = omx_encoder_pix_fmts, + .capabilities = AV_CODEC_CAP_DELAY, + .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP, + .priv_class = &omx_h264enc_class, +}; diff --git a/libavcodec/version.h b/libavcodec/version.h index c7a5193b5b..a84cdeda98 100644 --- a/libavcodec/version.h +++ b/libavcodec/version.h @@ -28,7 +28,7 @@ #include "libavutil/version.h" #define LIBAVCODEC_VERSION_MAJOR 57 -#define LIBAVCODEC_VERSION_MINOR 17 +#define LIBAVCODEC_VERSION_MINOR 18 #define LIBAVCODEC_VERSION_MICRO 0 #define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \ |