On Wed, Oct 12, 2016 at 03:22:42PM +0200, Matthieu Bouron wrote:
> From: Matthieu Bouron <matthieu.bou...@stupeflix.com>
>
> Adds the following changes:
> * mediacodecdec.{c,h} -> mediacodecdec_common.{c,h}
> * mediacodecdec_h2645.c -> mediacodecdec.c
> ---
> libavcodec/Makefile | 12 +-
> libavcodec/mediacodec.c | 3 +-
> libavcodec/mediacodec_sw_buffer.c | 2 +-
> libavcodec/mediacodec_sw_buffer.h | 2 +-
> libavcodec/mediacodecdec.c | 1064
> +++++++++-----------
> libavcodec/mediacodecdec_common.c | 789 +++++++++++++++
> .../{mediacodecdec.h => mediacodecdec_common.h} | 6 +-
> libavcodec/mediacodecdec_h2645.c | 623 ------------
> 8 files changed, 1251 insertions(+), 1250 deletions(-)
> create mode 100644 libavcodec/mediacodecdec_common.c
> rename libavcodec/{mediacodecdec.h => mediacodecdec_common.h} (95%)
> delete mode 100644 libavcodec/mediacodecdec_h2645.c
>
> diff --git a/libavcodec/Makefile b/libavcodec/Makefile
> index e8b1b00..7b85378 100644
> --- a/libavcodec/Makefile
> +++ b/libavcodec/Makefile
> @@ -94,7 +94,7 @@ OBJS-$(CONFIG_LSP) += lsp.o
> OBJS-$(CONFIG_LZF) += lzf.o
> OBJS-$(CONFIG_MDCT) += mdct_fixed.o mdct_float.o
> mdct_fixed_32.o
> OBJS-$(CONFIG_ME_CMP) += me_cmp.o
> -OBJS-$(CONFIG_MEDIACODEC) += mediacodecdec.o
> mediacodec_surface.o mediacodec_wrapper.o mediacodec_sw_buffer.o
> +OBJS-$(CONFIG_MEDIACODEC) += mediacodecdec_common.o
> mediacodec_surface.o mediacodec_wrapper.o mediacodec_sw_buffer.o
> OBJS-$(CONFIG_MPEG_ER) += mpeg_er.o
> OBJS-$(CONFIG_MPEGAUDIO) += mpegaudio.o mpegaudiodata.o \
> mpegaudiodecheader.o
> @@ -316,7 +316,7 @@ OBJS-$(CONFIG_H264_DECODER) += h264dec.o
> h264_cabac.o h264_cavlc.o \
> h264_slice.o h264data.o
> h264_parse.o \
> h2645_parse.o
> OBJS-$(CONFIG_H264_CUVID_DECODER) += cuvid.o
> -OBJS-$(CONFIG_H264_MEDIACODEC_DECODER) += mediacodecdec_h2645.o
> +OBJS-$(CONFIG_H264_MEDIACODEC_DECODER) += mediacodecdec.o
> OBJS-$(CONFIG_H264_MMAL_DECODER) += mmaldec.o
> OBJS-$(CONFIG_H264_NVENC_ENCODER) += nvenc_h264.o
> OBJS-$(CONFIG_NVENC_ENCODER) += nvenc_h264.o
> @@ -333,7 +333,7 @@ OBJS-$(CONFIG_HEVC_DECODER) += hevc.o
> hevc_mvs.o hevc_ps.o hevc_sei.o
> hevc_cabac.o hevc_refs.o
> hevcpred.o \
> hevcdsp.o hevc_filter.o
> h2645_parse.o hevc_data.o
> OBJS-$(CONFIG_HEVC_CUVID_DECODER) += cuvid.o
> -OBJS-$(CONFIG_HEVC_MEDIACODEC_DECODER) += mediacodecdec_h2645.o hevc_parse.o
> +OBJS-$(CONFIG_HEVC_MEDIACODEC_DECODER) += mediacodecdec.o hevc_parse.o
> OBJS-$(CONFIG_HEVC_NVENC_ENCODER) += nvenc_hevc.o
> OBJS-$(CONFIG_NVENC_HEVC_ENCODER) += nvenc_hevc.o
> OBJS-$(CONFIG_HEVC_QSV_DECODER) += qsvdec_h2645.o
> @@ -413,7 +413,7 @@ OBJS-$(CONFIG_MPEG2_QSV_ENCODER) += qsvenc_mpeg2.o
> OBJS-$(CONFIG_MPEG2VIDEO_DECODER) += mpeg12dec.o mpeg12.o mpeg12data.o
> OBJS-$(CONFIG_MPEG2VIDEO_ENCODER) += mpeg12enc.o mpeg12.o
> OBJS-$(CONFIG_MPEG4_DECODER) += xvididct.o
> -OBJS-$(CONFIG_MPEG4_MEDIACODEC_DECODER) += mediacodecdec_h2645.o
> +OBJS-$(CONFIG_MPEG4_MEDIACODEC_DECODER) += mediacodecdec.o
> OBJS-$(CONFIG_MPEG4_OMX_ENCODER) += omx.o
> OBJS-$(CONFIG_MPL2_DECODER) += mpl2dec.o ass.o
> OBJS-$(CONFIG_MSA1_DECODER) += mss3.o
> @@ -596,11 +596,11 @@ OBJS-$(CONFIG_VP6_DECODER) += vp6.o vp56.o
> vp56data.o \
> OBJS-$(CONFIG_VP7_DECODER) += vp8.o vp56rac.o
> OBJS-$(CONFIG_VP8_DECODER) += vp8.o vp56rac.o
> OBJS-$(CONFIG_VP8_CUVID_DECODER) += cuvid.o
> -OBJS-$(CONFIG_VP8_MEDIACODEC_DECODER) += mediacodecdec_h2645.o
> +OBJS-$(CONFIG_VP8_MEDIACODEC_DECODER) += mediacodecdec.o
> OBJS-$(CONFIG_VP9_DECODER) += vp9.o vp9dsp.o vp56rac.o
> vp9dsp_8bpp.o \
> vp9dsp_10bpp.o vp9dsp_12bpp.o
> OBJS-$(CONFIG_VP9_CUVID_DECODER) += cuvid.o
> -OBJS-$(CONFIG_VP9_MEDIACODEC_DECODER) += mediacodecdec_h2645.o
> +OBJS-$(CONFIG_VP9_MEDIACODEC_DECODER) += mediacodecdec.o
> OBJS-$(CONFIG_VPLAYER_DECODER) += textdec.o ass.o
> OBJS-$(CONFIG_VQA_DECODER) += vqavideo.o
> OBJS-$(CONFIG_WAVPACK_DECODER) += wavpack.o
> diff --git a/libavcodec/mediacodec.c b/libavcodec/mediacodec.c
> index a658f0e..3521c8a 100644
> --- a/libavcodec/mediacodec.c
> +++ b/libavcodec/mediacodec.c
> @@ -34,7 +34,8 @@
>
> #include "ffjni.h"
> #include "mediacodec.h"
> -#include "mediacodecdec.h"
> +#include "mediacodecdec_common.h"
> +#include "version.h"
>
> AVMediaCodecContext *av_mediacodec_alloc_context(void)
> {
> diff --git a/libavcodec/mediacodec_sw_buffer.c
> b/libavcodec/mediacodec_sw_buffer.c
> index 7baf120..92428e8 100644
> --- a/libavcodec/mediacodec_sw_buffer.c
> +++ b/libavcodec/mediacodec_sw_buffer.c
> @@ -27,9 +27,9 @@
> #include "libavutil/mem.h"
>
> #include "avcodec.h"
> -#include "mediacodecdec.h"
> #include "mediacodec_wrapper.h"
> #include "mediacodec_sw_buffer.h"
> +#include "mediacodecdec_common.h"
>
> #define QCOM_TILE_WIDTH 64
> #define QCOM_TILE_HEIGHT 32
> diff --git a/libavcodec/mediacodec_sw_buffer.h
> b/libavcodec/mediacodec_sw_buffer.h
> index c29de08..574fb52 100644
> --- a/libavcodec/mediacodec_sw_buffer.h
> +++ b/libavcodec/mediacodec_sw_buffer.h
> @@ -28,8 +28,8 @@
> #include "libavutil/frame.h"
>
> #include "avcodec.h"
> -#include "mediacodecdec.h"
> #include "mediacodec_wrapper.h"
> +#include "mediacodecdec_common.h"
>
> void ff_mediacodec_sw_buffer_copy_yuv420_planar(AVCodecContext *avctx,
> MediaCodecDecContext *s,
> diff --git a/libavcodec/mediacodecdec.c b/libavcodec/mediacodecdec.c
> index c031de8..e97bc50 100644
> --- a/libavcodec/mediacodecdec.c
> +++ b/libavcodec/mediacodecdec.c
> @@ -1,5 +1,5 @@
> /*
> - * Android MediaCodec decoder
> + * Android MediaCodec H.264 / H.265 / VP8 / VP9 decoders
> *
> * Copyright (c) 2015-2016 Matthieu Bouron <matthieu.bouron stupeflix.com>
> *
> @@ -20,770 +20,604 @@
> * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
> USA
> */
>
> +#include <stdint.h>
> #include <string.h>
> -#include <sys/types.h>
>
> -#include "libavutil/atomic.h"
> +#include "libavutil/avassert.h"
> #include "libavutil/common.h"
> -#include "libavutil/mem.h"
> -#include "libavutil/log.h"
> +#include "libavutil/fifo.h"
> +#include "libavutil/opt.h"
> +#include "libavutil/intreadwrite.h"
> #include "libavutil/pixfmt.h"
> -#include "libavutil/time.h"
> -#include "libavutil/timestamp.h"
> +#include "libavutil/atomic.h"
>
> #include "avcodec.h"
> +#include "h264_parse.h"
> +#include "hevc_parse.h"
> #include "internal.h"
> -
> -#include "mediacodec.h"
> -#include "mediacodec_surface.h"
> -#include "mediacodec_sw_buffer.h"
> #include "mediacodec_wrapper.h"
> -#include "mediacodecdec.h"
> +#include "mediacodecdec_common.h"
>
> -/**
> - * OMX.k3.video.decoder.avc, OMX.NVIDIA.* OMX.SEC.avc.dec and OMX.google
> - * codec workarounds used in various place are taken from the Gstreamer
> - * project.
> - *
> - * Gstreamer references:
> - *
> https://cgit.freedesktop.org/gstreamer/gst-plugins-bad/tree/sys/androidmedia/
> - *
> - * Gstreamer copyright notice:
> - *
> - * Copyright (C) 2012, Collabora Ltd.
> - * Author: Sebastian Dröge <sebastian.dro...@collabora.co.uk>
> - *
> - * Copyright (C) 2012, Rafaël Carré <funman@videolanorg>
> - *
> - * Copyright (C) 2015, Sebastian Dröge <sebast...@centricular.com>
> - *
> - * Copyright (C) 2014-2015, Collabora Ltd.
> - * Author: Matthieu Bouron <matthieu.bou...@gcollabora.com>
> - *
> - * Copyright (C) 2015, Edward Hervey
> - * Author: Edward Hervey <bilb...@gmail.com>
> - *
> - * Copyright (C) 2015, Matthew Waters <matt...@centricular.com>
> - *
> - * This library is free software; you can redistribute it and/or
> - * modify it under the terms of the GNU Lesser General Public
> - * License as published by the Free Software Foundation
> - * version 2.1 of the License.
> - *
> - * This library is distributed in the hope that it will be useful,
> - * but WITHOUT ANY WARRANTY; without even the implied warranty of
> - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> - * Lesser General Public License for more details.
> - *
> - * You should have received a copy of the GNU Lesser General Public
> - * License along with this library; if not, write to the Free Software
> - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
> USA
> - *
> - */
> +typedef struct MediaCodecH264DecContext {
>
> -#define INPUT_DEQUEUE_TIMEOUT_US 8000
> -#define OUTPUT_DEQUEUE_TIMEOUT_US 8000
> -#define OUTPUT_DEQUEUE_BLOCK_TIMEOUT_US 1000000
> -
> -enum {
> - COLOR_FormatYUV420Planar = 0x13,
> - COLOR_FormatYUV420SemiPlanar = 0x15,
> - COLOR_FormatYCbYCr = 0x19,
> - COLOR_FormatAndroidOpaque = 0x7F000789,
> - COLOR_QCOM_FormatYUV420SemiPlanar = 0x7fa30c00,
> - COLOR_QCOM_FormatYUV420SemiPlanar32m = 0x7fa30c04,
> - COLOR_QCOM_FormatYUV420PackedSemiPlanar64x32Tile2m8ka = 0x7fa30c03,
> - COLOR_TI_FormatYUV420PackedSemiPlanar = 0x7f000100,
> - COLOR_TI_FormatYUV420PackedSemiPlanarInterlaced = 0x7f000001,
> -};
> + MediaCodecDecContext *ctx;
>
> -static const struct {
> + AVBSFContext *bsf;
>
> - int color_format;
> - enum AVPixelFormat pix_fmt;
> + AVFifoBuffer *fifo;
>
> -} color_formats[] = {
> + AVPacket filtered_pkt;
>
> - { COLOR_FormatYUV420Planar,
> AV_PIX_FMT_YUV420P },
> - { COLOR_FormatYUV420SemiPlanar, AV_PIX_FMT_NV12
> },
> - { COLOR_QCOM_FormatYUV420SemiPlanar, AV_PIX_FMT_NV12
> },
> - { COLOR_QCOM_FormatYUV420SemiPlanar32m, AV_PIX_FMT_NV12
> },
> - { COLOR_QCOM_FormatYUV420PackedSemiPlanar64x32Tile2m8ka, AV_PIX_FMT_NV12
> },
> - { COLOR_TI_FormatYUV420PackedSemiPlanar, AV_PIX_FMT_NV12
> },
> - { COLOR_TI_FormatYUV420PackedSemiPlanarInterlaced, AV_PIX_FMT_NV12
> },
> - { 0 }
> -};
> +} MediaCodecH264DecContext;
>
> -static enum AVPixelFormat mcdec_map_color_format(AVCodecContext *avctx,
> - MediaCodecDecContext *s,
> - int color_format)
> +static av_cold int mediacodec_decode_close(AVCodecContext *avctx)
> {
> - int i;
> - enum AVPixelFormat ret = AV_PIX_FMT_NONE;
> + MediaCodecH264DecContext *s = avctx->priv_data;
>
> - if (s->surface) {
> - return AV_PIX_FMT_MEDIACODEC;
> - }
> + ff_mediacodec_dec_close(avctx, s->ctx);
> + s->ctx = NULL;
>
> - if (!strcmp(s->codec_name, "OMX.k3.video.decoder.avc") && color_format
> == COLOR_FormatYCbYCr) {
> - s->color_format = color_format =
> COLOR_TI_FormatYUV420PackedSemiPlanar;
> - }
> + av_fifo_free(s->fifo);
>
> - for (i = 0; i < FF_ARRAY_ELEMS(color_formats); i++) {
> - if (color_formats[i].color_format == color_format) {
> - return color_formats[i].pix_fmt;
> - }
> - }
> -
> - av_log(avctx, AV_LOG_ERROR, "Output color format 0x%x (value=%d) is not
> supported\n",
> - color_format, color_format);
> + av_bsf_free(&s->bsf);
> + av_packet_unref(&s->filtered_pkt);
>
> - return ret;
> + return 0;
> }
>
> -static void ff_mediacodec_dec_ref(MediaCodecDecContext *s)
> +#if CONFIG_H264_MEDIACODEC_DECODER || CONFIG_HEVC_MEDIACODEC_DECODER
> +static int h2645_ps_to_nalu(const uint8_t *src, int src_size, uint8_t **out,
> int *out_size)
> {
> - avpriv_atomic_int_add_and_fetch(&s->refcount, 1);
> -}
> + int i;
> + int ret = 0;
> + uint8_t *p = NULL;
> + static const uint8_t nalu_header[] = { 0x00, 0x00, 0x00, 0x01 };
>
> -static void ff_mediacodec_dec_unref(MediaCodecDecContext *s)
> -{
> - if (!s)
> - return;
> + if (!out || !out_size) {
> + return AVERROR(EINVAL);
> + }
>
> - if (!avpriv_atomic_int_add_and_fetch(&s->refcount, -1)) {
> - if (s->codec) {
> - ff_AMediaCodec_delete(s->codec);
> - s->codec = NULL;
> - }
> + p = av_malloc(sizeof(nalu_header) + src_size);
> + if (!p) {
> + return AVERROR(ENOMEM);
> + }
>
> - if (s->format) {
> - ff_AMediaFormat_delete(s->format);
> - s->format = NULL;
> - }
> + *out = p;
> + *out_size = sizeof(nalu_header) + src_size;
>
> - if (s->surface) {
> - ff_mediacodec_surface_unref(s->surface, NULL);
> - s->surface = NULL;
> - }
> + memcpy(p, nalu_header, sizeof(nalu_header));
> + memcpy(p + sizeof(nalu_header), src, src_size);
>
> - av_freep(&s->codec_name);
> - av_freep(&s);
> - }
> -}
> + /* Escape 0x00, 0x00, 0x0{0-3} pattern */
> + for (i = 4; i < *out_size; i++) {
> + if (i < *out_size - 3 &&
> + p[i + 0] == 0 &&
> + p[i + 1] == 0 &&
> + p[i + 2] <= 3) {
> + uint8_t *new;
>
> -static void mediacodec_buffer_release(void *opaque, uint8_t *data)
> -{
> - AVMediaCodecBuffer *buffer = opaque;
> - MediaCodecDecContext *ctx = buffer->ctx;
> - int released = avpriv_atomic_int_get(&buffer->released);
> + *out_size += 1;
> + new = av_realloc(*out, *out_size);
> + if (!new) {
> + ret = AVERROR(ENOMEM);
> + goto done;
> + }
> + *out = p = new;
>
> - if (!released) {
> - ff_AMediaCodec_releaseOutputBuffer(ctx->codec, buffer->index, 0);
> + i = i + 2;
> + memmove(p + i + 1, p + i, *out_size - (i + 1));
> + p[i] = 0x03;
> + }
> + }
> +done:
> + if (ret < 0) {
> + av_freep(out);
> + *out_size = 0;
> }
>
> - ff_mediacodec_dec_unref(ctx);
> - av_freep(&buffer);
> + return ret;
> }
> -
> -static int mediacodec_wrap_hw_buffer(AVCodecContext *avctx,
> - MediaCodecDecContext *s,
> - ssize_t index,
> - FFAMediaCodecBufferInfo *info,
> - AVFrame *frame)
> -{
> - int ret = 0;
> - int status = 0;
> - AVMediaCodecBuffer *buffer = NULL;
> -
> - frame->buf[0] = NULL;
> - frame->width = avctx->width;
> - frame->height = avctx->height;
> - frame->format = avctx->pix_fmt;
> -
> - if (avctx->pkt_timebase.num && avctx->pkt_timebase.den) {
> - frame->pts = av_rescale_q(info->presentationTimeUs,
> - av_make_q(1, 1000000),
> - avctx->pkt_timebase);
> - } else {
> - frame->pts = info->presentationTimeUs;
> - }
> -#if FF_API_PKT_PTS
> -FF_DISABLE_DEPRECATION_WARNINGS
> - frame->pkt_pts = frame->pts;
> -FF_ENABLE_DEPRECATION_WARNINGS
> #endif
> - frame->pkt_dts = AV_NOPTS_VALUE;
>
> - buffer = av_mallocz(sizeof(AVMediaCodecBuffer));
> - if (!buffer) {
> - ret = AVERROR(ENOMEM);
> - goto fail;
> - }
> -
> - buffer->released = 0;
> +#if CONFIG_H264_MEDIACODEC_DECODER
> +static int h264_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
> +{
> + int i;
> + int ret;
>
> - frame->buf[0] = av_buffer_create(NULL,
> - 0,
> - mediacodec_buffer_release,
> - buffer,
> - AV_BUFFER_FLAG_READONLY);
> + H264ParamSets ps;
> + const PPS *pps = NULL;
> + const SPS *sps = NULL;
> + int is_avc = 0;
> + int nal_length_size = 0;
>
> - if (!frame->buf[0]) {
> - ret = AVERROR(ENOMEM);
> - goto fail;
> + memset(&ps, 0, sizeof(ps));
>
> + ret = ff_h264_decode_extradata(avctx->extradata, avctx->extradata_size,
> + &ps, &is_avc, &nal_length_size, 0, avctx);
> + if (ret < 0) {
> + goto done;
> }
>
> - buffer->ctx = s;
> - ff_mediacodec_dec_ref(s);
> -
> - buffer->index = index;
> - buffer->pts = info->presentationTimeUs;
> -
> - frame->data[3] = (uint8_t *)buffer;
> -
> - return 0;
> -fail:
> - av_freep(buffer);
> - av_buffer_unref(&frame->buf[0]);
> - status = ff_AMediaCodec_releaseOutputBuffer(s->codec, index, 0);
> - if (status < 0) {
> - av_log(avctx, AV_LOG_ERROR, "Failed to release output buffer\n");
> - ret = AVERROR_EXTERNAL;
> + for (i = 0; i < MAX_PPS_COUNT; i++) {
> + if (ps.pps_list[i]) {
> + pps = (const PPS*)ps.pps_list[i]->data;
> + break;
> + }
> }
>
> - return ret;
> -}
> -
> -static int mediacodec_wrap_sw_buffer(AVCodecContext *avctx,
> - MediaCodecDecContext *s,
> - uint8_t *data,
> - size_t size,
> - ssize_t index,
> - FFAMediaCodecBufferInfo *info,
> - AVFrame *frame)
> -{
> - int ret = 0;
> - int status = 0;
> + if (pps) {
> + if (ps.sps_list[pps->sps_id]) {
> + sps = (const SPS*)ps.sps_list[pps->sps_id]->data;
> + }
> + }
>
> - frame->width = avctx->width;
> - frame->height = avctx->height;
> - frame->format = avctx->pix_fmt;
> + if (pps && sps) {
> + uint8_t *data = NULL;
> + int data_size = 0;
>
> - /* MediaCodec buffers needs to be copied to our own refcounted buffers
> - * because the flush command invalidates all input and output buffers.
> - */
> - if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
> - av_log(avctx, AV_LOG_ERROR, "Could not allocate buffer\n");
> - goto done;
> - }
> + if ((ret = h2645_ps_to_nalu(sps->data, sps->data_size, &data,
> &data_size)) < 0) {
> + goto done;
> + }
> + ff_AMediaFormat_setBuffer(format, "csd-0", (void*)data, data_size);
> + av_freep(&data);
>
> - /* Override frame->pkt_pts as ff_get_buffer will override its value based
> - * on the last avpacket received which is not in sync with the frame:
> - * * N avpackets can be pushed before 1 frame is actually returned
> - * * 0-sized avpackets are pushed to flush remaining frames at EOS */
> - frame->pts = info->presentationTimeUs;
> -#if FF_API_PKT_PTS
> -FF_DISABLE_DEPRECATION_WARNINGS
> - frame->pkt_pts = info->presentationTimeUs;
> -FF_ENABLE_DEPRECATION_WARNINGS
> -#endif
> - frame->pkt_dts = AV_NOPTS_VALUE;
> -
> - av_log(avctx, AV_LOG_DEBUG,
> - "Frame: width=%d stride=%d height=%d slice-height=%d "
> - "crop-top=%d crop-bottom=%d crop-left=%d crop-right=%d
> encoder=%s\n"
> - "destination linesizes=%d,%d,%d\n" ,
> - avctx->width, s->stride, avctx->height, s->slice_height,
> - s->crop_top, s->crop_bottom, s->crop_left, s->crop_right,
> s->codec_name,
> - frame->linesize[0], frame->linesize[1], frame->linesize[2]);
> -
> - switch (s->color_format) {
> - case COLOR_FormatYUV420Planar:
> - ff_mediacodec_sw_buffer_copy_yuv420_planar(avctx, s, data, size,
> info, frame);
> - break;
> - case COLOR_FormatYUV420SemiPlanar:
> - case COLOR_QCOM_FormatYUV420SemiPlanar:
> - case COLOR_QCOM_FormatYUV420SemiPlanar32m:
> - ff_mediacodec_sw_buffer_copy_yuv420_semi_planar(avctx, s, data,
> size, info, frame);
> - break;
> - case COLOR_TI_FormatYUV420PackedSemiPlanar:
> - case COLOR_TI_FormatYUV420PackedSemiPlanarInterlaced:
> - ff_mediacodec_sw_buffer_copy_yuv420_packed_semi_planar(avctx, s,
> data, size, info, frame);
> - break;
> - case COLOR_QCOM_FormatYUV420PackedSemiPlanar64x32Tile2m8ka:
> -
> ff_mediacodec_sw_buffer_copy_yuv420_packed_semi_planar_64x32Tile2m8ka(avctx,
> s, data, size, info, frame);
> - break;
> - default:
> - av_log(avctx, AV_LOG_ERROR, "Unsupported color format 0x%x
> (value=%d)\n",
> - s->color_format, s->color_format);
> - ret = AVERROR(EINVAL);
> - goto done;
> + if ((ret = h2645_ps_to_nalu(pps->data, pps->data_size, &data,
> &data_size)) < 0) {
> + goto done;
> + }
> + ff_AMediaFormat_setBuffer(format, "csd-1", (void*)data, data_size);
> + av_freep(&data);
> + } else {
> + av_log(avctx, AV_LOG_ERROR, "Could not extract PPS/SPS from
> extradata");
> + ret = AVERROR_INVALIDDATA;
> }
>
> - ret = 0;
> done:
> - status = ff_AMediaCodec_releaseOutputBuffer(s->codec, index, 0);
> - if (status < 0) {
> - av_log(avctx, AV_LOG_ERROR, "Failed to release output buffer\n");
> - ret = AVERROR_EXTERNAL;
> - }
> + ff_h264_ps_uninit(&ps);
>
> return ret;
> }
> +#endif
>
> -static int mediacodec_dec_parse_format(AVCodecContext *avctx,
> MediaCodecDecContext *s)
> +#if CONFIG_HEVC_MEDIACODEC_DECODER
> +static int hevc_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
> {
> - int width = 0;
> - int height = 0;
> - int32_t value = 0;
> - char *format = NULL;
> + int i;
> + int ret;
>
> - if (!s->format) {
> - av_log(avctx, AV_LOG_ERROR, "Output MediaFormat is not set\n");
> - return AVERROR(EINVAL);
> - }
> + HEVCParamSets ps;
>
> - format = ff_AMediaFormat_toString(s->format);
> - if (!format) {
> - return AVERROR_EXTERNAL;
> - }
> - av_log(avctx, AV_LOG_DEBUG, "Parsing MediaFormat %s\n", format);
> - av_freep(&format);
> -
> - /* Mandatory fields */
> - if (!ff_AMediaFormat_getInt32(s->format, "width", &value)) {
> - format = ff_AMediaFormat_toString(s->format);
> - av_log(avctx, AV_LOG_ERROR, "Could not get %s from format %s\n",
> "width", format);
> - av_freep(&format);
> - return AVERROR_EXTERNAL;
> - }
> - s->width = value;
> + const HEVCVPS *vps = NULL;
> + const HEVCPPS *pps = NULL;
> + const HEVCSPS *sps = NULL;
> + int is_nalff = 0;
> + int nal_length_size = 0;
>
> - if (!ff_AMediaFormat_getInt32(s->format, "height", &value)) {
> - format = ff_AMediaFormat_toString(s->format);
> - av_log(avctx, AV_LOG_ERROR, "Could not get %s from format %s\n",
> "height", format);
> - av_freep(&format);
> - return AVERROR_EXTERNAL;
> - }
> - s->height = value;
> + uint8_t *vps_data = NULL;
> + uint8_t *sps_data = NULL;
> + uint8_t *pps_data = NULL;
> + int vps_data_size = 0;
> + int sps_data_size = 0;
> + int pps_data_size = 0;
>
> - if (!ff_AMediaFormat_getInt32(s->format, "stride", &value)) {
> - format = ff_AMediaFormat_toString(s->format);
> - av_log(avctx, AV_LOG_ERROR, "Could not get %s from format %s\n",
> "stride", format);
> - av_freep(&format);
> - return AVERROR_EXTERNAL;
> - }
> - s->stride = value > 0 ? value : s->width;
> + memset(&ps, 0, sizeof(ps));
>
> - if (!ff_AMediaFormat_getInt32(s->format, "slice-height", &value)) {
> - format = ff_AMediaFormat_toString(s->format);
> - av_log(avctx, AV_LOG_ERROR, "Could not get %s from format %s\n",
> "slice-height", format);
> - av_freep(&format);
> - return AVERROR_EXTERNAL;
> + ret = ff_hevc_decode_extradata(avctx->extradata, avctx->extradata_size,
> + &ps, &is_nalff, &nal_length_size, 0, avctx);
> + if (ret < 0) {
> + goto done;
> }
> - s->slice_height = value > 0 ? value : s->height;
>
> - if (strstr(s->codec_name, "OMX.Nvidia.")) {
> - s->slice_height = FFALIGN(s->height, 16);
> - } else if (strstr(s->codec_name, "OMX.SEC.avc.dec")) {
> - s->slice_height = avctx->height;
> - s->stride = avctx->width;
> + for (i = 0; i < MAX_VPS_COUNT; i++) {
> + if (ps.vps_list[i]) {
> + vps = (const HEVCVPS*)ps.vps_list[i]->data;
> + break;
> + }
> }
>
> - if (!ff_AMediaFormat_getInt32(s->format, "color-format", &value)) {
> - format = ff_AMediaFormat_toString(s->format);
> - av_log(avctx, AV_LOG_ERROR, "Could not get %s from format %s\n",
> "color-format", format);
> - av_freep(&format);
> - return AVERROR_EXTERNAL;
> + for (i = 0; i < MAX_PPS_COUNT; i++) {
> + if (ps.pps_list[i]) {
> + pps = (const HEVCPPS*)ps.pps_list[i]->data;
> + break;
> + }
> }
> - s->color_format = value;
>
> - s->pix_fmt = avctx->pix_fmt = mcdec_map_color_format(avctx, s, value);
> - if (avctx->pix_fmt == AV_PIX_FMT_NONE) {
> - av_log(avctx, AV_LOG_ERROR, "Output color format is not
> supported\n");
> - return AVERROR(EINVAL);
> + if (pps) {
> + if (ps.sps_list[pps->sps_id]) {
> + sps = (const HEVCSPS*)ps.sps_list[pps->sps_id]->data;
> + }
> }
>
> - /* Optional fields */
> - if (ff_AMediaFormat_getInt32(s->format, "crop-top", &value))
> - s->crop_top = value;
> + if (vps && pps && sps) {
> + uint8_t *data;
> + int data_size;
>
> - if (ff_AMediaFormat_getInt32(s->format, "crop-bottom", &value))
> - s->crop_bottom = value;
> + if ((ret = h2645_ps_to_nalu(vps->data, vps->data_size, &vps_data,
> &vps_data_size)) < 0 ||
> + (ret = h2645_ps_to_nalu(sps->data, sps->data_size, &sps_data,
> &sps_data_size)) < 0 ||
> + (ret = h2645_ps_to_nalu(pps->data, pps->data_size, &pps_data,
> &pps_data_size)) < 0) {
> + goto done;
> + }
>
> - if (ff_AMediaFormat_getInt32(s->format, "crop-left", &value))
> - s->crop_left = value;
> + data_size = vps_data_size + sps_data_size + pps_data_size;
> + data = av_mallocz(data_size);
> + if (!data) {
> + ret = AVERROR(ENOMEM);
> + goto done;
> + }
>
> - if (ff_AMediaFormat_getInt32(s->format, "crop-right", &value))
> - s->crop_right = value;
> + memcpy(data , vps_data,
> vps_data_size);
> + memcpy(data + vps_data_size , sps_data,
> sps_data_size);
> + memcpy(data + vps_data_size + sps_data_size, pps_data,
> pps_data_size);
>
> - width = s->crop_right + 1 - s->crop_left;
> - height = s->crop_bottom + 1 - s->crop_top;
> + ff_AMediaFormat_setBuffer(format, "csd-0", data, data_size);
>
> - av_log(avctx, AV_LOG_INFO,
> - "Output crop parameters top=%d bottom=%d left=%d right=%d, "
> - "resulting dimensions width=%d height=%d\n",
> - s->crop_top, s->crop_bottom, s->crop_left, s->crop_right,
> - width, height);
> + av_freep(&data);
> + } else {
> + av_log(avctx, AV_LOG_ERROR, "Could not extract VPS/PPS/SPS from
> extradata");
> + ret = AVERROR_INVALIDDATA;
> + }
>
> - return ff_set_dimensions(avctx, width, height);
> -}
> +done:
> + av_freep(&vps_data);
> + av_freep(&sps_data);
> + av_freep(&pps_data);
>
> + return ret;
> +}
> +#endif
>
> -static int mediacodec_dec_flush_codec(AVCodecContext *avctx,
> MediaCodecDecContext *s)
> +#if CONFIG_MPEG4_MEDIACODEC_DECODER
> +static int mpeg4_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
> {
> - FFAMediaCodec *codec = s->codec;
> - int status;
> -
> - s->output_buffer_count = 0;
> -
> - s->draining = 0;
> - s->flushing = 0;
> - s->eos = 0;
> + int ret = 0;
>
> - status = ff_AMediaCodec_flush(codec);
> - if (status < 0) {
> - av_log(avctx, AV_LOG_ERROR, "Failed to flush codec\n");
> - return AVERROR_EXTERNAL;
> + if (avctx->extradata) {
> + ff_AMediaFormat_setBuffer(format, "csd-0", avctx->extradata,
> avctx->extradata_size);
> }
>
> - return 0;
> + return ret;
> }
> +#endif
>
> -int ff_mediacodec_dec_init(AVCodecContext *avctx, MediaCodecDecContext *s,
> - const char *mime, FFAMediaFormat *format)
> +#if CONFIG_VP8_MEDIACODEC_DECODER || CONFIG_VP9_MEDIACODEC_DECODER
> +static int vpx_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
> {
> int ret = 0;
> - int status;
> - int profile;
>
> - enum AVPixelFormat pix_fmt;
> - static const enum AVPixelFormat pix_fmts[] = {
> - AV_PIX_FMT_MEDIACODEC,
> - AV_PIX_FMT_NONE,
> - };
> + if (avctx->extradata) {
> + ff_AMediaFormat_setBuffer(format, "csd-0", avctx->extradata,
> avctx->extradata_size);
> + }
>
> - s->refcount = 1;
> + return ret;
> +}
> +#endif
>
> - pix_fmt = ff_get_format(avctx, pix_fmts);
> - if (pix_fmt == AV_PIX_FMT_MEDIACODEC) {
> - AVMediaCodecContext *user_ctx = avctx->hwaccel_context;
> +static av_cold int mediacodec_decode_init(AVCodecContext *avctx)
> +{
> + int ret;
>
> - if (user_ctx && user_ctx->surface) {
> - s->surface = ff_mediacodec_surface_ref(user_ctx->surface, avctx);
> - av_log(avctx, AV_LOG_INFO, "Using surface %p\n", s->surface);
> - }
> - }
> + const char *codec_mime = NULL;
>
> - profile = ff_AMediaCodecProfile_getProfileFromAVCodecContext(avctx);
> - if (profile < 0) {
> - av_log(avctx, AV_LOG_WARNING, "Unsupported or unknown profile");
> - }
> + const char *bsf_name = NULL;
> + const AVBitStreamFilter *bsf = NULL;
>
> - s->codec_name = ff_AMediaCodecList_getCodecNameByType(mime, profile, 0,
> avctx);
> - if (!s->codec_name) {
> - ret = AVERROR_EXTERNAL;
> - goto fail;
> - }
> + FFAMediaFormat *format = NULL;
> + MediaCodecH264DecContext *s = avctx->priv_data;
>
> - av_log(avctx, AV_LOG_DEBUG, "Found decoder %s\n", s->codec_name);
> - s->codec = ff_AMediaCodec_createCodecByName(s->codec_name);
> - if (!s->codec) {
> - av_log(avctx, AV_LOG_ERROR, "Failed to create media decoder for type
> %s and name %s\n", mime, s->codec_name);
> + format = ff_AMediaFormat_new();
> + if (!format) {
> + av_log(avctx, AV_LOG_ERROR, "Failed to create media format\n");
> ret = AVERROR_EXTERNAL;
> - goto fail;
> + goto done;
> }
>
> - status = ff_AMediaCodec_configure(s->codec, format, s->surface, NULL, 0);
> - if (status < 0) {
> - char *desc = ff_AMediaFormat_toString(format);
> - av_log(avctx, AV_LOG_ERROR,
> - "Failed to configure codec (status = %d) with format %s\n",
> - status, desc);
> - av_freep(&desc);
> + switch (avctx->codec_id) {
> +#if CONFIG_H264_MEDIACODEC_DECODER
> + case AV_CODEC_ID_H264:
> + codec_mime = "video/avc";
> + bsf_name = "h264_mp4toannexb";
>
> - ret = AVERROR_EXTERNAL;
> - goto fail;
> - }
> + ret = h264_set_extradata(avctx, format);
> + if (ret < 0)
> + goto done;
> + break;
> +#endif
> +#if CONFIG_HEVC_MEDIACODEC_DECODER
> + case AV_CODEC_ID_HEVC:
> + codec_mime = "video/hevc";
> + bsf_name = "hevc_mp4toannexb";
> +
> + ret = hevc_set_extradata(avctx, format);
> + if (ret < 0)
> + goto done;
> + break;
> +#endif
> +#if CONFIG_MPEG4_MEDIACODEC_DECODER
> + case AV_CODEC_ID_MPEG4:
> + codec_mime = "video/mp4v-es",
>
> - status = ff_AMediaCodec_start(s->codec);
> - if (status < 0) {
> - char *desc = ff_AMediaFormat_toString(format);
> - av_log(avctx, AV_LOG_ERROR,
> - "Failed to start codec (status = %d) with format %s\n",
> - status, desc);
> - av_freep(&desc);
> - ret = AVERROR_EXTERNAL;
> - goto fail;
> - }
> + ret = mpeg4_set_extradata(avctx, format);
> + if (ret < 0)
> + goto done;
> + break;
> +#endif
> +#if CONFIG_VP8_MEDIACODEC_DECODER
> + case AV_CODEC_ID_VP8:
> + codec_mime = "video/x-vnd.on2.vp8";
>
> - s->format = ff_AMediaCodec_getOutputFormat(s->codec);
> - if (s->format) {
> - if ((ret = mediacodec_dec_parse_format(avctx, s)) < 0) {
> - av_log(avctx, AV_LOG_ERROR,
> - "Failed to configure context\n");
> - goto fail;
> - }
> - }
> + ret = vpx_set_extradata(avctx, format);
> + if (ret < 0)
> + goto done;
> + break;
> +#endif
> +#if CONFIG_VP9_MEDIACODEC_DECODER
> + case AV_CODEC_ID_VP9:
> + codec_mime = "video/x-vnd.on2.vp9";
>
> - av_log(avctx, AV_LOG_DEBUG, "MediaCodec %p started successfully\n",
> s->codec);
> + ret = vpx_set_extradata(avctx, format);
> + if (ret < 0)
> + goto done;
> + break;
> +#endif
> + default:
> + av_assert0(0);
> + }
>
> - return 0;
> + ff_AMediaFormat_setString(format, "mime", codec_mime);
> + ff_AMediaFormat_setInt32(format, "width", avctx->width);
> + ff_AMediaFormat_setInt32(format, "height", avctx->height);
>
> -fail:
> - av_log(avctx, AV_LOG_ERROR, "MediaCodec %p failed to start\n", s->codec);
> - ff_mediacodec_dec_close(avctx, s);
> - return ret;
> -}
> + s->ctx = av_mallocz(sizeof(*s->ctx));
> + if (!s->ctx) {
> + av_log(avctx, AV_LOG_ERROR, "Failed to allocate
> MediaCodecDecContext\n");
> + ret = AVERROR(ENOMEM);
> + goto done;
> + }
>
> -int ff_mediacodec_dec_decode(AVCodecContext *avctx, MediaCodecDecContext *s,
> - AVFrame *frame, int *got_frame,
> - AVPacket *pkt)
> -{
> - int ret;
> - int offset = 0;
> - int need_draining = 0;
> - uint8_t *data;
> - ssize_t index;
> - size_t size;
> - FFAMediaCodec *codec = s->codec;
> - FFAMediaCodecBufferInfo info = { 0 };
> -
> - int status;
> -
> - int64_t input_dequeue_timeout_us = INPUT_DEQUEUE_TIMEOUT_US;
> - int64_t output_dequeue_timeout_us = OUTPUT_DEQUEUE_TIMEOUT_US;
> -
> - if (s->flushing) {
> - av_log(avctx, AV_LOG_ERROR, "Decoder is flushing and cannot accept
> new buffer "
> - "until all output buffers have been
> released\n");
> - return AVERROR_EXTERNAL;
> + if ((ret = ff_mediacodec_dec_init(avctx, s->ctx, codec_mime, format)) <
> 0) {
> + s->ctx = NULL;
> + goto done;
> }
>
> - if (pkt->size == 0) {
> - need_draining = 1;
> + av_log(avctx, AV_LOG_INFO, "MediaCodec started successfully, ret =
> %d\n", ret);
> +
> + s->fifo = av_fifo_alloc(sizeof(AVPacket));
> + if (!s->fifo) {
> + ret = AVERROR(ENOMEM);
> + goto done;
> }
>
> - if (s->draining && s->eos) {
> - return 0;
> + if (bsf_name) {
> + bsf = av_bsf_get_by_name(bsf_name);
> + if(!bsf) {
> + ret = AVERROR_BSF_NOT_FOUND;
> + goto done;
> }
>
> - while (offset < pkt->size || (need_draining && !s->draining)) {
> + if ((ret = av_bsf_alloc(bsf, &s->bsf))) {
> + goto done;
> + }
>
> - index = ff_AMediaCodec_dequeueInputBuffer(codec,
> input_dequeue_timeout_us);
> - if (ff_AMediaCodec_infoTryAgainLater(codec, index)) {
> - break;
> - }
> + if (((ret = avcodec_parameters_from_context(s->bsf->par_in, avctx)) < 0)
> ||
> + ((ret = av_bsf_init(s->bsf)) < 0)) {
> + goto done;
> + }
> + }
>
> - if (index < 0) {
> - av_log(avctx, AV_LOG_ERROR, "Failed to dequeue input buffer
> (status=%zd)\n", index);
> - return AVERROR_EXTERNAL;
> - }
> + av_init_packet(&s->filtered_pkt);
>
> - data = ff_AMediaCodec_getInputBuffer(codec, index, &size);
> - if (!data) {
> - av_log(avctx, AV_LOG_ERROR, "Failed to get input buffer\n");
> - return AVERROR_EXTERNAL;
> - }
> +done:
> + if (format) {
> + ff_AMediaFormat_delete(format);
> + }
>
> - if (need_draining) {
> - int64_t pts = pkt->pts;
> - uint32_t flags = ff_AMediaCodec_getBufferFlagEndOfStream(codec);
> + if (ret < 0) {
> + mediacodec_decode_close(avctx);
> + }
>
> - if (s->surface) {
> - pts = av_rescale_q(pts, avctx->pkt_timebase, av_make_q(1,
> 1000000));
> - }
> + return ret;
> +}
>
> - av_log(avctx, AV_LOG_DEBUG, "Sending End Of Stream signal\n");
>
> - status = ff_AMediaCodec_queueInputBuffer(codec, index, 0, 0,
> pts, flags);
> - if (status < 0) {
> - av_log(avctx, AV_LOG_ERROR, "Failed to queue input empty
> buffer (status = %d)\n", status);
> - return AVERROR_EXTERNAL;
> - }
> +static int mediacodec_process_data(AVCodecContext *avctx, AVFrame *frame,
> + int *got_frame, AVPacket *pkt)
> +{
> + MediaCodecH264DecContext *s = avctx->priv_data;
>
> - s->draining = 1;
> - break;
> - } else {
> - int64_t pts = pkt->pts;
> + return ff_mediacodec_dec_decode(avctx, s->ctx, frame, got_frame, pkt);
> +}
>
> - size = FFMIN(pkt->size - offset, size);
> +static int mediacodec_decode_frame(AVCodecContext *avctx, void *data,
> + int *got_frame, AVPacket *avpkt)
> +{
> + MediaCodecH264DecContext *s = avctx->priv_data;
> + AVFrame *frame = data;
> + int ret;
>
> - memcpy(data, pkt->data + offset, size);
> - offset += size;
> + /* buffer the input packet */
> + if (avpkt->size) {
> + AVPacket input_pkt = { 0 };
>
> - if (s->surface && avctx->pkt_timebase.num &&
> avctx->pkt_timebase.den) {
> - pts = av_rescale_q(pts, avctx->pkt_timebase, av_make_q(1,
> 1000000));
> - }
> + if (av_fifo_space(s->fifo) < sizeof(input_pkt)) {
> + ret = av_fifo_realloc2(s->fifo,
> + av_fifo_size(s->fifo) +
> sizeof(input_pkt));
> + if (ret < 0)
> + return ret;
> + }
>
> - status = ff_AMediaCodec_queueInputBuffer(codec, index, 0, size,
> pts, 0);
> - if (status < 0) {
> - av_log(avctx, AV_LOG_ERROR, "Failed to queue input buffer
> (status = %d)\n", status);
> - return AVERROR_EXTERNAL;
> - }
> + ret = av_packet_ref(&input_pkt, avpkt);
> + if (ret < 0)
> + return ret;
> + av_fifo_generic_write(s->fifo, &input_pkt, sizeof(input_pkt), NULL);
> + }
> +
> + /*
> + * MediaCodec.flush() discards both input and output buffers, thus we
> + * need to delay the call to this function until the user has released or
> + * renderered the frames he retains.
> + *
> + * After we have buffered an input packet, check if the codec is in the
> + * flushing state. If it is, we need to call ff_mediacodec_dec_flush.
> + *
> + * ff_mediacodec_dec_flush returns 0 if the flush cannot be performed on
> + * the codec (because the user retains frames). The codec stays in the
> + * flushing state.
> + *
> + * ff_mediacodec_dec_flush returns 1 if the flush can actually be
> + * performed on the codec. The codec leaves the flushing state and can
> + * process again packets.
> + *
> + * ff_mediacodec_dec_flush returns a negative value if an error has
> + * occurred.
> + *
> + */
> + if (ff_mediacodec_dec_is_flushing(avctx, s->ctx)) {
> + if (!ff_mediacodec_dec_flush(avctx, s->ctx)) {
> + return avpkt->size;
> }
> }
>
> - if (need_draining || s->draining) {
> - /* If the codec is flushing or need to be flushed, block for a fair
> - * amount of time to ensure we got a frame */
> - output_dequeue_timeout_us = OUTPUT_DEQUEUE_BLOCK_TIMEOUT_US;
> - } else if (s->output_buffer_count == 0) {
> - /* If the codec hasn't produced any frames, do not block so we
> - * can push data to it as fast as possible, and get the first
> - * frame */
> - output_dequeue_timeout_us = 0;
> - }
> + /* process buffered data */
> + while (!*got_frame) {
> + /* prepare the input data -- convert to Annex B if needed */
> + if (s->filtered_pkt.size <= 0) {
> + AVPacket input_pkt = { 0 };
>
> - index = ff_AMediaCodec_dequeueOutputBuffer(codec, &info,
> output_dequeue_timeout_us);
> - if (index >= 0) {
> - int ret;
> + av_packet_unref(&s->filtered_pkt);
>
> - av_log(avctx, AV_LOG_DEBUG, "Got output buffer %zd"
> - " offset=%" PRIi32 " size=%" PRIi32 " ts=%" PRIi64
> - " flags=%" PRIu32 "\n", index, info.offset, info.size,
> - info.presentationTimeUs, info.flags);
> + /* no more data */
> + if (av_fifo_size(s->fifo) < sizeof(AVPacket)) {
> + return avpkt->size ? avpkt->size :
> + ff_mediacodec_dec_decode(avctx, s->ctx, frame,
> got_frame, avpkt);
> + }
>
> - if (info.flags & ff_AMediaCodec_getBufferFlagEndOfStream(codec)) {
> - s->eos = 1;
> - }
> + av_fifo_generic_read(s->fifo, &input_pkt, sizeof(input_pkt),
> NULL);
>
> - if (info.size) {
> - if (s->surface) {
> - if ((ret = mediacodec_wrap_hw_buffer(avctx, s, index, &info,
> frame)) < 0) {
> - av_log(avctx, AV_LOG_ERROR, "Failed to wrap MediaCodec
> buffer\n");
> - return ret;
> - }
> - } else {
> - data = ff_AMediaCodec_getOutputBuffer(codec, index, &size);
> - if (!data) {
> - av_log(avctx, AV_LOG_ERROR, "Failed to get output
> buffer\n");
> - return AVERROR_EXTERNAL;
> - }
> -
> - if ((ret = mediacodec_wrap_sw_buffer(avctx, s, data, size,
> index, &info, frame)) < 0) {
> - av_log(avctx, AV_LOG_ERROR, "Failed to wrap MediaCodec
> buffer\n");
> - return ret;
> - }
> + if (s->bsf) {
> + ret = av_bsf_send_packet(s->bsf, &input_pkt);
> + if (ret < 0) {
> + return ret;
> }
>
> - *got_frame = 1;
> - s->output_buffer_count++;
> - } else {
> - status = ff_AMediaCodec_releaseOutputBuffer(codec, index, 0);
> - if (status < 0) {
> - av_log(avctx, AV_LOG_ERROR, "Failed to release output
> buffer\n");
> + ret = av_bsf_receive_packet(s->bsf, &s->filtered_pkt);
> + if (ret == AVERROR(EAGAIN)) {
> + goto done;
> }
> - }
> -
> - } else if (ff_AMediaCodec_infoOutputFormatChanged(codec, index)) {
> - char *format = NULL;
> -
> - if (s->format) {
> - status = ff_AMediaFormat_delete(s->format);
> - if (status < 0) {
> - av_log(avctx, AV_LOG_ERROR, "Failed to delete MediaFormat
> %p\n", s->format);
> + } else {
> + av_packet_move_ref(&s->filtered_pkt, &input_pkt);
> }
> - }
>
> - s->format = ff_AMediaCodec_getOutputFormat(codec);
> - if (!s->format) {
> - av_log(avctx, AV_LOG_ERROR, "Failed to get output format\n");
> - return AVERROR_EXTERNAL;
> - }
> + /* {h264,hevc}_mp4toannexb are used here and do not require
> flushing */
> + av_assert0(ret != AVERROR_EOF);
>
> - format = ff_AMediaFormat_toString(s->format);
> - if (!format) {
> - return AVERROR_EXTERNAL;
> + if (ret < 0) {
> + return ret;
> + }
> }
> - av_log(avctx, AV_LOG_INFO, "Output MediaFormat changed to %s\n",
> format);
> - av_freep(&format);
>
> - if ((ret = mediacodec_dec_parse_format(avctx, s)) < 0) {
> + ret = mediacodec_process_data(avctx, frame, got_frame,
> &s->filtered_pkt);
> + if (ret < 0)
> return ret;
> - }
>
> - } else if (ff_AMediaCodec_infoOutputBuffersChanged(codec, index)) {
> - ff_AMediaCodec_cleanOutputBuffers(codec);
> - } else if (ff_AMediaCodec_infoTryAgainLater(codec, index)) {
> - if (s->draining) {
> - av_log(avctx, AV_LOG_ERROR, "Failed to dequeue output buffer
> within %" PRIi64 "ms "
> - "while draining remaining frames,
> output will probably lack frames\n",
> - output_dequeue_timeout_us / 1000);
> - } else {
> - av_log(avctx, AV_LOG_DEBUG, "No output buffer available, try
> again later\n");
> - }
> - } else {
> - av_log(avctx, AV_LOG_ERROR, "Failed to dequeue output buffer
> (status=%zd)\n", index);
> - return AVERROR_EXTERNAL;
> + s->filtered_pkt.size -= ret;
> + s->filtered_pkt.data += ret;
> }
> -
> - return offset;
> +done:
> + return avpkt->size;
> }
>
> -int ff_mediacodec_dec_flush(AVCodecContext *avctx, MediaCodecDecContext *s)
> +static void mediacodec_decode_flush(AVCodecContext *avctx)
> {
> - if (!s->surface || avpriv_atomic_int_get(&s->refcount) == 1) {
> - int ret;
> -
> - /* No frames (holding a reference to the codec) are retained by the
> - * user, thus we can flush the codec and returns accordingly */
> - if ((ret = mediacodec_dec_flush_codec(avctx, s)) < 0) {
> - return ret;
> - }
> + MediaCodecH264DecContext *s = avctx->priv_data;
>
> - return 1;
> + while (av_fifo_size(s->fifo)) {
> + AVPacket pkt;
> + av_fifo_generic_read(s->fifo, &pkt, sizeof(pkt), NULL);
> + av_packet_unref(&pkt);
> }
> + av_fifo_reset(s->fifo);
>
> - s->flushing = 1;
> - return 0;
> -}
> -
> -int ff_mediacodec_dec_close(AVCodecContext *avctx, MediaCodecDecContext *s)
> -{
> - ff_mediacodec_dec_unref(s);
> -
> - return 0;
> -}
> + av_packet_unref(&s->filtered_pkt);
>
> -int ff_mediacodec_dec_is_flushing(AVCodecContext *avctx,
> MediaCodecDecContext *s)
> -{
> - return s->flushing;
> + ff_mediacodec_dec_flush(avctx, s->ctx);
> }
>
> -AVHWAccel ff_h264_mediacodec_hwaccel = {
> - .name = "mediacodec",
> - .type = AVMEDIA_TYPE_VIDEO,
> - .id = AV_CODEC_ID_H264,
> - .pix_fmt = AV_PIX_FMT_MEDIACODEC,
> +#if CONFIG_H264_MEDIACODEC_DECODER
> +AVCodec ff_h264_mediacodec_decoder = {
> + .name = "h264_mediacodec",
> + .long_name = NULL_IF_CONFIG_SMALL("H.264 Android MediaCodec
> decoder"),
> + .type = AVMEDIA_TYPE_VIDEO,
> + .id = AV_CODEC_ID_H264,
> + .priv_data_size = sizeof(MediaCodecH264DecContext),
> + .init = mediacodec_decode_init,
> + .decode = mediacodec_decode_frame,
> + .flush = mediacodec_decode_flush,
> + .close = mediacodec_decode_close,
> + .capabilities = CODEC_CAP_DELAY,
> + .caps_internal = FF_CODEC_CAP_SETS_PKT_DTS,
> };
> +#endif
>
> -AVHWAccel ff_hevc_mediacodec_hwaccel = {
> - .name = "mediacodec",
> - .type = AVMEDIA_TYPE_VIDEO,
> - .id = AV_CODEC_ID_HEVC,
> - .pix_fmt = AV_PIX_FMT_MEDIACODEC,
> +#if CONFIG_HEVC_MEDIACODEC_DECODER
> +AVCodec ff_hevc_mediacodec_decoder = {
> + .name = "hevc_mediacodec",
> + .long_name = NULL_IF_CONFIG_SMALL("H.265 Android MediaCodec
> decoder"),
> + .type = AVMEDIA_TYPE_VIDEO,
> + .id = AV_CODEC_ID_HEVC,
> + .priv_data_size = sizeof(MediaCodecH264DecContext),
> + .init = mediacodec_decode_init,
> + .decode = mediacodec_decode_frame,
> + .flush = mediacodec_decode_flush,
> + .close = mediacodec_decode_close,
> + .capabilities = CODEC_CAP_DELAY,
> + .caps_internal = FF_CODEC_CAP_SETS_PKT_DTS,
> };
> +#endif
>
> -AVHWAccel ff_mpeg4_mediacodec_hwaccel = {
> - .name = "mediacodec",
> - .type = AVMEDIA_TYPE_VIDEO,
> - .id = AV_CODEC_ID_MPEG4,
> - .pix_fmt = AV_PIX_FMT_MEDIACODEC,
> +#if CONFIG_MPEG4_MEDIACODEC_DECODER
> +AVCodec ff_mpeg4_mediacodec_decoder = {
> + .name = "mpeg4_mediacodec",
> + .long_name = NULL_IF_CONFIG_SMALL("MPEG4 Android MediaCodec
> decoder"),
> + .type = AVMEDIA_TYPE_VIDEO,
> + .id = AV_CODEC_ID_MPEG4,
> + .priv_data_size = sizeof(MediaCodecH264DecContext),
> + .init = mediacodec_decode_init,
> + .decode = mediacodec_decode_frame,
> + .flush = mediacodec_decode_flush,
> + .close = mediacodec_decode_close,
> + .capabilities = CODEC_CAP_DELAY,
> + .caps_internal = FF_CODEC_CAP_SETS_PKT_DTS,
> };
> +#endif
>
> -AVHWAccel ff_vp8_mediacodec_hwaccel = {
> - .name = "mediacodec",
> - .type = AVMEDIA_TYPE_VIDEO,
> - .id = AV_CODEC_ID_VP8,
> - .pix_fmt = AV_PIX_FMT_MEDIACODEC,
> +#if CONFIG_VP8_MEDIACODEC_DECODER
> +AVCodec ff_vp8_mediacodec_decoder = {
> + .name = "vp8_mediacodec",
> + .long_name = NULL_IF_CONFIG_SMALL("VP8 Android MediaCodec decoder"),
> + .type = AVMEDIA_TYPE_VIDEO,
> + .id = AV_CODEC_ID_VP8,
> + .priv_data_size = sizeof(MediaCodecH264DecContext),
> + .init = mediacodec_decode_init,
> + .decode = mediacodec_decode_frame,
> + .flush = mediacodec_decode_flush,
> + .close = mediacodec_decode_close,
> + .capabilities = CODEC_CAP_DELAY,
> + .caps_internal = FF_CODEC_CAP_SETS_PKT_DTS,
> };
> +#endif
>
> -AVHWAccel ff_vp9_mediacodec_hwaccel = {
> - .name = "mediacodec",
> - .type = AVMEDIA_TYPE_VIDEO,
> - .id = AV_CODEC_ID_VP9,
> - .pix_fmt = AV_PIX_FMT_MEDIACODEC,
> +#if CONFIG_VP9_MEDIACODEC_DECODER
> +AVCodec ff_vp9_mediacodec_decoder = {
> + .name = "vp9_mediacodec",
> + .long_name = NULL_IF_CONFIG_SMALL("VP9 Android MediaCodec decoder"),
> + .type = AVMEDIA_TYPE_VIDEO,
> + .id = AV_CODEC_ID_VP9,
> + .priv_data_size = sizeof(MediaCodecH264DecContext),
> + .init = mediacodec_decode_init,
> + .decode = mediacodec_decode_frame,
> + .flush = mediacodec_decode_flush,
> + .close = mediacodec_decode_close,
> + .capabilities = CODEC_CAP_DELAY,
> + .caps_internal = FF_CODEC_CAP_SETS_PKT_DTS,
> };
> +#endif
> diff --git a/libavcodec/mediacodecdec_common.c
> b/libavcodec/mediacodecdec_common.c
> new file mode 100644
> index 0000000..dfc7f55
> --- /dev/null
> +++ b/libavcodec/mediacodecdec_common.c
> @@ -0,0 +1,789 @@
> +/*
> + * Android MediaCodec decoder
> + *
> + * Copyright (c) 2015-2016 Matthieu Bouron <matthieu.bouron stupeflix.com>
> + *
> + * This file is part of FFmpeg.
> + *
> + * FFmpeg 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.
> + *
> + * FFmpeg 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 FFmpeg; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
> USA
> + */
> +
> +#include <string.h>
> +#include <sys/types.h>
> +
> +#include "libavutil/atomic.h"
> +#include "libavutil/common.h"
> +#include "libavutil/mem.h"
> +#include "libavutil/log.h"
> +#include "libavutil/pixfmt.h"
> +#include "libavutil/time.h"
> +#include "libavutil/timestamp.h"
> +
> +#include "avcodec.h"
> +#include "internal.h"
> +
> +#include "mediacodec.h"
> +#include "mediacodec_surface.h"
> +#include "mediacodec_sw_buffer.h"
> +#include "mediacodec_wrapper.h"
> +#include "mediacodecdec_common.h"
> +
> +/**
> + * OMX.k3.video.decoder.avc, OMX.NVIDIA.* OMX.SEC.avc.dec and OMX.google
> + * codec workarounds used in various place are taken from the Gstreamer
> + * project.
> + *
> + * Gstreamer references:
> + *
> https://cgit.freedesktop.org/gstreamer/gst-plugins-bad/tree/sys/androidmedia/
> + *
> + * Gstreamer copyright notice:
> + *
> + * Copyright (C) 2012, Collabora Ltd.
> + * Author: Sebastian Dröge <sebastian.dro...@collabora.co.uk>
> + *
> + * Copyright (C) 2012, Rafaël Carré <funman@videolanorg>
> + *
> + * Copyright (C) 2015, Sebastian Dröge <sebast...@centricular.com>
> + *
> + * Copyright (C) 2014-2015, Collabora Ltd.
> + * Author: Matthieu Bouron <matthieu.bou...@gcollabora.com>
> + *
> + * Copyright (C) 2015, Edward Hervey
> + * Author: Edward Hervey <bilb...@gmail.com>
> + *
> + * Copyright (C) 2015, Matthew Waters <matt...@centricular.com>
> + *
> + * This library is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU Lesser General Public
> + * License as published by the Free Software Foundation
> + * version 2.1 of the License.
> + *
> + * This library is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + * Lesser General Public License for more details.
> + *
> + * You should have received a copy of the GNU Lesser General Public
> + * License along with this library; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
> USA
> + *
> + */
> +
> +#define INPUT_DEQUEUE_TIMEOUT_US 8000
> +#define OUTPUT_DEQUEUE_TIMEOUT_US 8000
> +#define OUTPUT_DEQUEUE_BLOCK_TIMEOUT_US 1000000
> +
> +enum {
> + COLOR_FormatYUV420Planar = 0x13,
> + COLOR_FormatYUV420SemiPlanar = 0x15,
> + COLOR_FormatYCbYCr = 0x19,
> + COLOR_FormatAndroidOpaque = 0x7F000789,
> + COLOR_QCOM_FormatYUV420SemiPlanar = 0x7fa30c00,
> + COLOR_QCOM_FormatYUV420SemiPlanar32m = 0x7fa30c04,
> + COLOR_QCOM_FormatYUV420PackedSemiPlanar64x32Tile2m8ka = 0x7fa30c03,
> + COLOR_TI_FormatYUV420PackedSemiPlanar = 0x7f000100,
> + COLOR_TI_FormatYUV420PackedSemiPlanarInterlaced = 0x7f000001,
> +};
> +
> +static const struct {
> +
> + int color_format;
> + enum AVPixelFormat pix_fmt;
> +
> +} color_formats[] = {
> +
> + { COLOR_FormatYUV420Planar,
> AV_PIX_FMT_YUV420P },
> + { COLOR_FormatYUV420SemiPlanar, AV_PIX_FMT_NV12
> },
> + { COLOR_QCOM_FormatYUV420SemiPlanar, AV_PIX_FMT_NV12
> },
> + { COLOR_QCOM_FormatYUV420SemiPlanar32m, AV_PIX_FMT_NV12
> },
> + { COLOR_QCOM_FormatYUV420PackedSemiPlanar64x32Tile2m8ka, AV_PIX_FMT_NV12
> },
> + { COLOR_TI_FormatYUV420PackedSemiPlanar, AV_PIX_FMT_NV12
> },
> + { COLOR_TI_FormatYUV420PackedSemiPlanarInterlaced, AV_PIX_FMT_NV12
> },
> + { 0 }
> +};
> +
> +static enum AVPixelFormat mcdec_map_color_format(AVCodecContext *avctx,
> + MediaCodecDecContext *s,
> + int color_format)
> +{
> + int i;
> + enum AVPixelFormat ret = AV_PIX_FMT_NONE;
> +
> + if (s->surface) {
> + return AV_PIX_FMT_MEDIACODEC;
> + }
> +
> + if (!strcmp(s->codec_name, "OMX.k3.video.decoder.avc") && color_format
> == COLOR_FormatYCbYCr) {
> + s->color_format = color_format =
> COLOR_TI_FormatYUV420PackedSemiPlanar;
> + }
> +
> + for (i = 0; i < FF_ARRAY_ELEMS(color_formats); i++) {
> + if (color_formats[i].color_format == color_format) {
> + return color_formats[i].pix_fmt;
> + }
> + }
> +
> + av_log(avctx, AV_LOG_ERROR, "Output color format 0x%x (value=%d) is not
> supported\n",
> + color_format, color_format);
> +
> + return ret;
> +}
> +
> +static void ff_mediacodec_dec_ref(MediaCodecDecContext *s)
> +{
> + avpriv_atomic_int_add_and_fetch(&s->refcount, 1);
> +}
> +
> +static void ff_mediacodec_dec_unref(MediaCodecDecContext *s)
> +{
> + if (!s)
> + return;
> +
> + if (!avpriv_atomic_int_add_and_fetch(&s->refcount, -1)) {
> + if (s->codec) {
> + ff_AMediaCodec_delete(s->codec);
> + s->codec = NULL;
> + }
> +
> + if (s->format) {
> + ff_AMediaFormat_delete(s->format);
> + s->format = NULL;
> + }
> +
> + if (s->surface) {
> + ff_mediacodec_surface_unref(s->surface, NULL);
> + s->surface = NULL;
> + }
> +
> + av_freep(&s->codec_name);
> + av_freep(&s);
> + }
> +}
> +
> +static void mediacodec_buffer_release(void *opaque, uint8_t *data)
> +{
> + AVMediaCodecBuffer *buffer = opaque;
> + MediaCodecDecContext *ctx = buffer->ctx;
> + int released = avpriv_atomic_int_get(&buffer->released);
> +
> + if (!released) {
> + ff_AMediaCodec_releaseOutputBuffer(ctx->codec, buffer->index, 0);
> + }
> +
> + ff_mediacodec_dec_unref(ctx);
> + av_freep(&buffer);
> +}
> +
> +static int mediacodec_wrap_hw_buffer(AVCodecContext *avctx,
> + MediaCodecDecContext *s,
> + ssize_t index,
> + FFAMediaCodecBufferInfo *info,
> + AVFrame *frame)
> +{
> + int ret = 0;
> + int status = 0;
> + AVMediaCodecBuffer *buffer = NULL;
> +
> + frame->buf[0] = NULL;
> + frame->width = avctx->width;
> + frame->height = avctx->height;
> + frame->format = avctx->pix_fmt;
> +
> + if (avctx->pkt_timebase.num && avctx->pkt_timebase.den) {
> + frame->pts = av_rescale_q(info->presentationTimeUs,
> + av_make_q(1, 1000000),
> + avctx->pkt_timebase);
> + } else {
> + frame->pts = info->presentationTimeUs;
> + }
> +#if FF_API_PKT_PTS
> +FF_DISABLE_DEPRECATION_WARNINGS
> + frame->pkt_pts = frame->pts;
> +FF_ENABLE_DEPRECATION_WARNINGS
> +#endif
> + frame->pkt_dts = AV_NOPTS_VALUE;
> +
> + buffer = av_mallocz(sizeof(AVMediaCodecBuffer));
> + if (!buffer) {
> + ret = AVERROR(ENOMEM);
> + goto fail;
> + }
> +
> + buffer->released = 0;
> +
> + frame->buf[0] = av_buffer_create(NULL,
> + 0,
> + mediacodec_buffer_release,
> + buffer,
> + AV_BUFFER_FLAG_READONLY);
> +
> + if (!frame->buf[0]) {
> + ret = AVERROR(ENOMEM);
> + goto fail;
> +
> + }
> +
> + buffer->ctx = s;
> + ff_mediacodec_dec_ref(s);
> +
> + buffer->index = index;
> + buffer->pts = info->presentationTimeUs;
> +
> + frame->data[3] = (uint8_t *)buffer;
> +
> + return 0;
> +fail:
> + av_freep(buffer);
> + av_buffer_unref(&frame->buf[0]);
> + status = ff_AMediaCodec_releaseOutputBuffer(s->codec, index, 0);
> + if (status < 0) {
> + av_log(avctx, AV_LOG_ERROR, "Failed to release output buffer\n");
> + ret = AVERROR_EXTERNAL;
> + }
> +
> + return ret;
> +}
> +
> +static int mediacodec_wrap_sw_buffer(AVCodecContext *avctx,
> + MediaCodecDecContext *s,
> + uint8_t *data,
> + size_t size,
> + ssize_t index,
> + FFAMediaCodecBufferInfo *info,
> + AVFrame *frame)
> +{
> + int ret = 0;
> + int status = 0;
> +
> + frame->width = avctx->width;
> + frame->height = avctx->height;
> + frame->format = avctx->pix_fmt;
> +
> + /* MediaCodec buffers needs to be copied to our own refcounted buffers
> + * because the flush command invalidates all input and output buffers.
> + */
> + if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
> + av_log(avctx, AV_LOG_ERROR, "Could not allocate buffer\n");
> + goto done;
> + }
> +
> + /* Override frame->pkt_pts as ff_get_buffer will override its value based
> + * on the last avpacket received which is not in sync with the frame:
> + * * N avpackets can be pushed before 1 frame is actually returned
> + * * 0-sized avpackets are pushed to flush remaining frames at EOS */
> + frame->pts = info->presentationTimeUs;
> +#if FF_API_PKT_PTS
> +FF_DISABLE_DEPRECATION_WARNINGS
> + frame->pkt_pts = info->presentationTimeUs;
> +FF_ENABLE_DEPRECATION_WARNINGS
> +#endif
> + frame->pkt_dts = AV_NOPTS_VALUE;
> +
> + av_log(avctx, AV_LOG_DEBUG,
> + "Frame: width=%d stride=%d height=%d slice-height=%d "
> + "crop-top=%d crop-bottom=%d crop-left=%d crop-right=%d
> encoder=%s\n"
> + "destination linesizes=%d,%d,%d\n" ,
> + avctx->width, s->stride, avctx->height, s->slice_height,
> + s->crop_top, s->crop_bottom, s->crop_left, s->crop_right,
> s->codec_name,
> + frame->linesize[0], frame->linesize[1], frame->linesize[2]);
> +
> + switch (s->color_format) {
> + case COLOR_FormatYUV420Planar:
> + ff_mediacodec_sw_buffer_copy_yuv420_planar(avctx, s, data, size,
> info, frame);
> + break;
> + case COLOR_FormatYUV420SemiPlanar:
> + case COLOR_QCOM_FormatYUV420SemiPlanar:
> + case COLOR_QCOM_FormatYUV420SemiPlanar32m:
> + ff_mediacodec_sw_buffer_copy_yuv420_semi_planar(avctx, s, data,
> size, info, frame);
> + break;
> + case COLOR_TI_FormatYUV420PackedSemiPlanar:
> + case COLOR_TI_FormatYUV420PackedSemiPlanarInterlaced:
> + ff_mediacodec_sw_buffer_copy_yuv420_packed_semi_planar(avctx, s,
> data, size, info, frame);
> + break;
> + case COLOR_QCOM_FormatYUV420PackedSemiPlanar64x32Tile2m8ka:
> +
> ff_mediacodec_sw_buffer_copy_yuv420_packed_semi_planar_64x32Tile2m8ka(avctx,
> s, data, size, info, frame);
> + break;
> + default:
> + av_log(avctx, AV_LOG_ERROR, "Unsupported color format 0x%x
> (value=%d)\n",
> + s->color_format, s->color_format);
> + ret = AVERROR(EINVAL);
> + goto done;
> + }
> +
> + ret = 0;
> +done:
> + status = ff_AMediaCodec_releaseOutputBuffer(s->codec, index, 0);
> + if (status < 0) {
> + av_log(avctx, AV_LOG_ERROR, "Failed to release output buffer\n");
> + ret = AVERROR_EXTERNAL;
> + }
> +
> + return ret;
> +}
> +
> +static int mediacodec_dec_parse_format(AVCodecContext *avctx,
> MediaCodecDecContext *s)
> +{
> + int width = 0;
> + int height = 0;
> + int32_t value = 0;
> + char *format = NULL;
> +
> + if (!s->format) {
> + av_log(avctx, AV_LOG_ERROR, "Output MediaFormat is not set\n");
> + return AVERROR(EINVAL);
> + }
> +
> + format = ff_AMediaFormat_toString(s->format);
> + if (!format) {
> + return AVERROR_EXTERNAL;
> + }
> + av_log(avctx, AV_LOG_DEBUG, "Parsing MediaFormat %s\n", format);
> + av_freep(&format);
> +
> + /* Mandatory fields */
> + if (!ff_AMediaFormat_getInt32(s->format, "width", &value)) {
> + format = ff_AMediaFormat_toString(s->format);
> + av_log(avctx, AV_LOG_ERROR, "Could not get %s from format %s\n",
> "width", format);
> + av_freep(&format);
> + return AVERROR_EXTERNAL;
> + }
> + s->width = value;
> +
> + if (!ff_AMediaFormat_getInt32(s->format, "height", &value)) {
> + format = ff_AMediaFormat_toString(s->format);
> + av_log(avctx, AV_LOG_ERROR, "Could not get %s from format %s\n",
> "height", format);
> + av_freep(&format);
> + return AVERROR_EXTERNAL;
> + }
> + s->height = value;
> +
> + if (!ff_AMediaFormat_getInt32(s->format, "stride", &value)) {
> + format = ff_AMediaFormat_toString(s->format);
> + av_log(avctx, AV_LOG_ERROR, "Could not get %s from format %s\n",
> "stride", format);
> + av_freep(&format);
> + return AVERROR_EXTERNAL;
> + }
> + s->stride = value > 0 ? value : s->width;
> +
> + if (!ff_AMediaFormat_getInt32(s->format, "slice-height", &value)) {
> + format = ff_AMediaFormat_toString(s->format);
> + av_log(avctx, AV_LOG_ERROR, "Could not get %s from format %s\n",
> "slice-height", format);
> + av_freep(&format);
> + return AVERROR_EXTERNAL;
> + }
> + s->slice_height = value > 0 ? value : s->height;
> +
> + if (strstr(s->codec_name, "OMX.Nvidia.")) {
> + s->slice_height = FFALIGN(s->height, 16);
> + } else if (strstr(s->codec_name, "OMX.SEC.avc.dec")) {
> + s->slice_height = avctx->height;
> + s->stride = avctx->width;
> + }
> +
> + if (!ff_AMediaFormat_getInt32(s->format, "color-format", &value)) {
> + format = ff_AMediaFormat_toString(s->format);
> + av_log(avctx, AV_LOG_ERROR, "Could not get %s from format %s\n",
> "color-format", format);
> + av_freep(&format);
> + return AVERROR_EXTERNAL;
> + }
> + s->color_format = value;
> +
> + s->pix_fmt = avctx->pix_fmt = mcdec_map_color_format(avctx, s, value);
> + if (avctx->pix_fmt == AV_PIX_FMT_NONE) {
> + av_log(avctx, AV_LOG_ERROR, "Output color format is not
> supported\n");
> + return AVERROR(EINVAL);
> + }
> +
> + /* Optional fields */
> + if (ff_AMediaFormat_getInt32(s->format, "crop-top", &value))
> + s->crop_top = value;
> +
> + if (ff_AMediaFormat_getInt32(s->format, "crop-bottom", &value))
> + s->crop_bottom = value;
> +
> + if (ff_AMediaFormat_getInt32(s->format, "crop-left", &value))
> + s->crop_left = value;
> +
> + if (ff_AMediaFormat_getInt32(s->format, "crop-right", &value))
> + s->crop_right = value;
> +
> + width = s->crop_right + 1 - s->crop_left;
> + height = s->crop_bottom + 1 - s->crop_top;
> +
> + av_log(avctx, AV_LOG_INFO,
> + "Output crop parameters top=%d bottom=%d left=%d right=%d, "
> + "resulting dimensions width=%d height=%d\n",
> + s->crop_top, s->crop_bottom, s->crop_left, s->crop_right,
> + width, height);
> +
> + return ff_set_dimensions(avctx, width, height);
> +}
> +
> +
> +static int mediacodec_dec_flush_codec(AVCodecContext *avctx,
> MediaCodecDecContext *s)
> +{
> + FFAMediaCodec *codec = s->codec;
> + int status;
> +
> + s->output_buffer_count = 0;
> +
> + s->draining = 0;
> + s->flushing = 0;
> + s->eos = 0;
> +
> + status = ff_AMediaCodec_flush(codec);
> + if (status < 0) {
> + av_log(avctx, AV_LOG_ERROR, "Failed to flush codec\n");
> + return AVERROR_EXTERNAL;
> + }
> +
> + return 0;
> +}
> +
> +int ff_mediacodec_dec_init(AVCodecContext *avctx, MediaCodecDecContext *s,
> + const char *mime, FFAMediaFormat *format)
> +{
> + int ret = 0;
> + int status;
> + int profile;
> +
> + enum AVPixelFormat pix_fmt;
> + static const enum AVPixelFormat pix_fmts[] = {
> + AV_PIX_FMT_MEDIACODEC,
> + AV_PIX_FMT_NONE,
> + };
> +
> + s->refcount = 1;
> +
> + pix_fmt = ff_get_format(avctx, pix_fmts);
> + if (pix_fmt == AV_PIX_FMT_MEDIACODEC) {
> + AVMediaCodecContext *user_ctx = avctx->hwaccel_context;
> +
> + if (user_ctx && user_ctx->surface) {
> + s->surface = ff_mediacodec_surface_ref(user_ctx->surface, avctx);
> + av_log(avctx, AV_LOG_INFO, "Using surface %p\n", s->surface);
> + }
> + }
> +
> + profile = ff_AMediaCodecProfile_getProfileFromAVCodecContext(avctx);
> + if (profile < 0) {
> + av_log(avctx, AV_LOG_WARNING, "Unsupported or unknown profile");
> + }
> +
> + s->codec_name = ff_AMediaCodecList_getCodecNameByType(mime, profile, 0,
> avctx);
> + if (!s->codec_name) {
> + ret = AVERROR_EXTERNAL;
> + goto fail;
> + }
> +
> + av_log(avctx, AV_LOG_DEBUG, "Found decoder %s\n", s->codec_name);
> + s->codec = ff_AMediaCodec_createCodecByName(s->codec_name);
> + if (!s->codec) {
> + av_log(avctx, AV_LOG_ERROR, "Failed to create media decoder for type
> %s and name %s\n", mime, s->codec_name);
> + ret = AVERROR_EXTERNAL;
> + goto fail;
> + }
> +
> + status = ff_AMediaCodec_configure(s->codec, format, s->surface, NULL, 0);
> + if (status < 0) {
> + char *desc = ff_AMediaFormat_toString(format);
> + av_log(avctx, AV_LOG_ERROR,
> + "Failed to configure codec (status = %d) with format %s\n",
> + status, desc);
> + av_freep(&desc);
> +
> + ret = AVERROR_EXTERNAL;
> + goto fail;
> + }
> +
> + status = ff_AMediaCodec_start(s->codec);
> + if (status < 0) {
> + char *desc = ff_AMediaFormat_toString(format);
> + av_log(avctx, AV_LOG_ERROR,
> + "Failed to start codec (status = %d) with format %s\n",
> + status, desc);
> + av_freep(&desc);
> + ret = AVERROR_EXTERNAL;
> + goto fail;
> + }
> +
> + s->format = ff_AMediaCodec_getOutputFormat(s->codec);
> + if (s->format) {
> + if ((ret = mediacodec_dec_parse_format(avctx, s)) < 0) {
> + av_log(avctx, AV_LOG_ERROR,
> + "Failed to configure context\n");
> + goto fail;
> + }
> + }
> +
> + av_log(avctx, AV_LOG_DEBUG, "MediaCodec %p started successfully\n",
> s->codec);
> +
> + return 0;
> +
> +fail:
> + av_log(avctx, AV_LOG_ERROR, "MediaCodec %p failed to start\n", s->codec);
> + ff_mediacodec_dec_close(avctx, s);
> + return ret;
> +}
> +
> +int ff_mediacodec_dec_decode(AVCodecContext *avctx, MediaCodecDecContext *s,
> + AVFrame *frame, int *got_frame,
> + AVPacket *pkt)
> +{
> + int ret;
> + int offset = 0;
> + int need_draining = 0;
> + uint8_t *data;
> + ssize_t index;
> + size_t size;
> + FFAMediaCodec *codec = s->codec;
> + FFAMediaCodecBufferInfo info = { 0 };
> +
> + int status;
> +
> + int64_t input_dequeue_timeout_us = INPUT_DEQUEUE_TIMEOUT_US;
> + int64_t output_dequeue_timeout_us = OUTPUT_DEQUEUE_TIMEOUT_US;
> +
> + if (s->flushing) {
> + av_log(avctx, AV_LOG_ERROR, "Decoder is flushing and cannot accept
> new buffer "
> + "until all output buffers have been
> released\n");
> + return AVERROR_EXTERNAL;
> + }
> +
> + if (pkt->size == 0) {
> + need_draining = 1;
> + }
> +
> + if (s->draining && s->eos) {
> + return 0;
> + }
> +
> + while (offset < pkt->size || (need_draining && !s->draining)) {
> +
> + index = ff_AMediaCodec_dequeueInputBuffer(codec,
> input_dequeue_timeout_us);
> + if (ff_AMediaCodec_infoTryAgainLater(codec, index)) {
> + break;
> + }
> +
> + if (index < 0) {
> + av_log(avctx, AV_LOG_ERROR, "Failed to dequeue input buffer
> (status=%zd)\n", index);
> + return AVERROR_EXTERNAL;
> + }
> +
> + data = ff_AMediaCodec_getInputBuffer(codec, index, &size);
> + if (!data) {
> + av_log(avctx, AV_LOG_ERROR, "Failed to get input buffer\n");
> + return AVERROR_EXTERNAL;
> + }
> +
> + if (need_draining) {
> + int64_t pts = pkt->pts;
> + uint32_t flags = ff_AMediaCodec_getBufferFlagEndOfStream(codec);
> +
> + if (s->surface) {
> + pts = av_rescale_q(pts, avctx->pkt_timebase, av_make_q(1,
> 1000000));
> + }
> +
> + av_log(avctx, AV_LOG_DEBUG, "Sending End Of Stream signal\n");
> +
> + status = ff_AMediaCodec_queueInputBuffer(codec, index, 0, 0,
> pts, flags);
> + if (status < 0) {
> + av_log(avctx, AV_LOG_ERROR, "Failed to queue input empty
> buffer (status = %d)\n", status);
> + return AVERROR_EXTERNAL;
> + }
> +
> + s->draining = 1;
> + break;
> + } else {
> + int64_t pts = pkt->pts;
> +
> + size = FFMIN(pkt->size - offset, size);
> +
> + memcpy(data, pkt->data + offset, size);
> + offset += size;
> +
> + if (s->surface && avctx->pkt_timebase.num &&
> avctx->pkt_timebase.den) {
> + pts = av_rescale_q(pts, avctx->pkt_timebase, av_make_q(1,
> 1000000));
> + }
> +
> + status = ff_AMediaCodec_queueInputBuffer(codec, index, 0, size,
> pts, 0);
> + if (status < 0) {
> + av_log(avctx, AV_LOG_ERROR, "Failed to queue input buffer
> (status = %d)\n", status);
> + return AVERROR_EXTERNAL;
> + }
> + }
> + }
> +
> + if (need_draining || s->draining) {
> + /* If the codec is flushing or need to be flushed, block for a fair
> + * amount of time to ensure we got a frame */
> + output_dequeue_timeout_us = OUTPUT_DEQUEUE_BLOCK_TIMEOUT_US;
> + } else if (s->output_buffer_count == 0) {
> + /* If the codec hasn't produced any frames, do not block so we
> + * can push data to it as fast as possible, and get the first
> + * frame */
> + output_dequeue_timeout_us = 0;
> + }
> +
> + index = ff_AMediaCodec_dequeueOutputBuffer(codec, &info,
> output_dequeue_timeout_us);
> + if (index >= 0) {
> + int ret;
> +
> + av_log(avctx, AV_LOG_DEBUG, "Got output buffer %zd"
> + " offset=%" PRIi32 " size=%" PRIi32 " ts=%" PRIi64
> + " flags=%" PRIu32 "\n", index, info.offset, info.size,
> + info.presentationTimeUs, info.flags);
> +
> + if (info.flags & ff_AMediaCodec_getBufferFlagEndOfStream(codec)) {
> + s->eos = 1;
> + }
> +
> + if (info.size) {
> + if (s->surface) {
> + if ((ret = mediacodec_wrap_hw_buffer(avctx, s, index, &info,
> frame)) < 0) {
> + av_log(avctx, AV_LOG_ERROR, "Failed to wrap MediaCodec
> buffer\n");
> + return ret;
> + }
> + } else {
> + data = ff_AMediaCodec_getOutputBuffer(codec, index, &size);
> + if (!data) {
> + av_log(avctx, AV_LOG_ERROR, "Failed to get output
> buffer\n");
> + return AVERROR_EXTERNAL;
> + }
> +
> + if ((ret = mediacodec_wrap_sw_buffer(avctx, s, data, size,
> index, &info, frame)) < 0) {
> + av_log(avctx, AV_LOG_ERROR, "Failed to wrap MediaCodec
> buffer\n");
> + return ret;
> + }
> + }
> +
> + *got_frame = 1;
> + s->output_buffer_count++;
> + } else {
> + status = ff_AMediaCodec_releaseOutputBuffer(codec, index, 0);
> + if (status < 0) {
> + av_log(avctx, AV_LOG_ERROR, "Failed to release output
> buffer\n");
> + }
> + }
> +
> + } else if (ff_AMediaCodec_infoOutputFormatChanged(codec, index)) {
> + char *format = NULL;
> +
> + if (s->format) {
> + status = ff_AMediaFormat_delete(s->format);
> + if (status < 0) {
> + av_log(avctx, AV_LOG_ERROR, "Failed to delete MediaFormat
> %p\n", s->format);
> + }
> + }
> +
> + s->format = ff_AMediaCodec_getOutputFormat(codec);
> + if (!s->format) {
> + av_log(avctx, AV_LOG_ERROR, "Failed to get output format\n");
> + return AVERROR_EXTERNAL;
> + }
> +
> + format = ff_AMediaFormat_toString(s->format);
> + if (!format) {
> + return AVERROR_EXTERNAL;
> + }
> + av_log(avctx, AV_LOG_INFO, "Output MediaFormat changed to %s\n",
> format);
> + av_freep(&format);
> +
> + if ((ret = mediacodec_dec_parse_format(avctx, s)) < 0) {
> + return ret;
> + }
> +
> + } else if (ff_AMediaCodec_infoOutputBuffersChanged(codec, index)) {
> + ff_AMediaCodec_cleanOutputBuffers(codec);
> + } else if (ff_AMediaCodec_infoTryAgainLater(codec, index)) {
> + if (s->draining) {
> + av_log(avctx, AV_LOG_ERROR, "Failed to dequeue output buffer
> within %" PRIi64 "ms "
> + "while draining remaining frames,
> output will probably lack frames\n",
> + output_dequeue_timeout_us / 1000);
> + } else {
> + av_log(avctx, AV_LOG_DEBUG, "No output buffer available, try
> again later\n");
> + }
> + } else {
> + av_log(avctx, AV_LOG_ERROR, "Failed to dequeue output buffer
> (status=%zd)\n", index);
> + return AVERROR_EXTERNAL;
> + }
> +
> + return offset;
> +}
> +
> +int ff_mediacodec_dec_flush(AVCodecContext *avctx, MediaCodecDecContext *s)
> +{
> + if (!s->surface || avpriv_atomic_int_get(&s->refcount) == 1) {
> + int ret;
> +
> + /* No frames (holding a reference to the codec) are retained by the
> + * user, thus we can flush the codec and returns accordingly */
> + if ((ret = mediacodec_dec_flush_codec(avctx, s)) < 0) {
> + return ret;
> + }
> +
> + return 1;
> + }
> +
> + s->flushing = 1;
> + return 0;
> +}
> +
> +int ff_mediacodec_dec_close(AVCodecContext *avctx, MediaCodecDecContext *s)
> +{
> + ff_mediacodec_dec_unref(s);
> +
> + return 0;
> +}
> +
> +int ff_mediacodec_dec_is_flushing(AVCodecContext *avctx,
> MediaCodecDecContext *s)
> +{
> + return s->flushing;
> +}
> +
> +AVHWAccel ff_h264_mediacodec_hwaccel = {
> + .name = "mediacodec",
> + .type = AVMEDIA_TYPE_VIDEO,
> + .id = AV_CODEC_ID_H264,
> + .pix_fmt = AV_PIX_FMT_MEDIACODEC,
> +};
> +
> +AVHWAccel ff_hevc_mediacodec_hwaccel = {
> + .name = "mediacodec",
> + .type = AVMEDIA_TYPE_VIDEO,
> + .id = AV_CODEC_ID_HEVC,
> + .pix_fmt = AV_PIX_FMT_MEDIACODEC,
> +};
> +
> +AVHWAccel ff_mpeg4_mediacodec_hwaccel = {
> + .name = "mediacodec",
> + .type = AVMEDIA_TYPE_VIDEO,
> + .id = AV_CODEC_ID_MPEG4,
> + .pix_fmt = AV_PIX_FMT_MEDIACODEC,
> +};
> +
> +AVHWAccel ff_vp8_mediacodec_hwaccel = {
> + .name = "mediacodec",
> + .type = AVMEDIA_TYPE_VIDEO,
> + .id = AV_CODEC_ID_VP8,
> + .pix_fmt = AV_PIX_FMT_MEDIACODEC,
> +};
> +
> +AVHWAccel ff_vp9_mediacodec_hwaccel = {
> + .name = "mediacodec",
> + .type = AVMEDIA_TYPE_VIDEO,
> + .id = AV_CODEC_ID_VP9,
> + .pix_fmt = AV_PIX_FMT_MEDIACODEC,
> +};
> diff --git a/libavcodec/mediacodecdec.h b/libavcodec/mediacodecdec_common.h
> similarity index 95%
> rename from libavcodec/mediacodecdec.h
> rename to libavcodec/mediacodecdec_common.h
> index 7b0b7bb..c00c2e8 100644
> --- a/libavcodec/mediacodecdec.h
> +++ b/libavcodec/mediacodecdec_common.h
> @@ -20,8 +20,8 @@
> * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
> USA
> */
>
> -#ifndef AVCODEC_MEDIACODECDEC_H
> -#define AVCODEC_MEDIACODECDEC_H
> +#ifndef AVCODEC_MEDIACODECDEC_COMMON_H
> +#define AVCODEC_MEDIACODECDEC_COMMON_H
>
> #include <stdint.h>
> #include <sys/types.h>
> @@ -92,4 +92,4 @@ typedef struct MediaCodecBuffer {
>
> } MediaCodecBuffer;
>
> -#endif /* AVCODEC_MEDIACODECDEC_H */
> +#endif /* AVCODEC_MEDIACODECDEC_COMMON_H */
> diff --git a/libavcodec/mediacodecdec_h2645.c
> b/libavcodec/mediacodecdec_h2645.c
> deleted file mode 100644
> index 3cc2492..0000000
> --- a/libavcodec/mediacodecdec_h2645.c
> +++ /dev/null
> @@ -1,623 +0,0 @@
> -/*
> - * Android MediaCodec H.264 / H.265 / VP8 / VP9 decoders
> - *
> - * Copyright (c) 2015-2016 Matthieu Bouron <matthieu.bouron stupeflix.com>
> - *
> - * This file is part of FFmpeg.
> - *
> - * FFmpeg 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.
> - *
> - * FFmpeg 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 FFmpeg; if not, write to the Free Software
> - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
> USA
> - */
> -
> -#include <stdint.h>
> -#include <string.h>
> -
> -#include "libavutil/avassert.h"
> -#include "libavutil/common.h"
> -#include "libavutil/fifo.h"
> -#include "libavutil/opt.h"
> -#include "libavutil/intreadwrite.h"
> -#include "libavutil/pixfmt.h"
> -#include "libavutil/atomic.h"
> -
> -#include "avcodec.h"
> -#include "h264_parse.h"
> -#include "hevc_parse.h"
> -#include "internal.h"
> -#include "mediacodecdec.h"
> -#include "mediacodec_wrapper.h"
> -
> -typedef struct MediaCodecH264DecContext {
> -
> - MediaCodecDecContext *ctx;
> -
> - AVBSFContext *bsf;
> -
> - AVFifoBuffer *fifo;
> -
> - AVPacket filtered_pkt;
> -
> -} MediaCodecH264DecContext;
> -
> -static av_cold int mediacodec_decode_close(AVCodecContext *avctx)
> -{
> - MediaCodecH264DecContext *s = avctx->priv_data;
> -
> - ff_mediacodec_dec_close(avctx, s->ctx);
> - s->ctx = NULL;
> -
> - av_fifo_free(s->fifo);
> -
> - av_bsf_free(&s->bsf);
> - av_packet_unref(&s->filtered_pkt);
> -
> - return 0;
> -}
> -
> -#if CONFIG_H264_MEDIACODEC_DECODER || CONFIG_HEVC_MEDIACODEC_DECODER
> -static int h2645_ps_to_nalu(const uint8_t *src, int src_size, uint8_t **out,
> int *out_size)
> -{
> - int i;
> - int ret = 0;
> - uint8_t *p = NULL;
> - static const uint8_t nalu_header[] = { 0x00, 0x00, 0x00, 0x01 };
> -
> - if (!out || !out_size) {
> - return AVERROR(EINVAL);
> - }
> -
> - p = av_malloc(sizeof(nalu_header) + src_size);
> - if (!p) {
> - return AVERROR(ENOMEM);
> - }
> -
> - *out = p;
> - *out_size = sizeof(nalu_header) + src_size;
> -
> - memcpy(p, nalu_header, sizeof(nalu_header));
> - memcpy(p + sizeof(nalu_header), src, src_size);
> -
> - /* Escape 0x00, 0x00, 0x0{0-3} pattern */
> - for (i = 4; i < *out_size; i++) {
> - if (i < *out_size - 3 &&
> - p[i + 0] == 0 &&
> - p[i + 1] == 0 &&
> - p[i + 2] <= 3) {
> - uint8_t *new;
> -
> - *out_size += 1;
> - new = av_realloc(*out, *out_size);
> - if (!new) {
> - ret = AVERROR(ENOMEM);
> - goto done;
> - }
> - *out = p = new;
> -
> - i = i + 2;
> - memmove(p + i + 1, p + i, *out_size - (i + 1));
> - p[i] = 0x03;
> - }
> - }
> -done:
> - if (ret < 0) {
> - av_freep(out);
> - *out_size = 0;
> - }
> -
> - return ret;
> -}
> -#endif
> -
> -#if CONFIG_H264_MEDIACODEC_DECODER
> -static int h264_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
> -{
> - int i;
> - int ret;
> -
> - H264ParamSets ps;
> - const PPS *pps = NULL;
> - const SPS *sps = NULL;
> - int is_avc = 0;
> - int nal_length_size = 0;
> -
> - memset(&ps, 0, sizeof(ps));
> -
> - ret = ff_h264_decode_extradata(avctx->extradata, avctx->extradata_size,
> - &ps, &is_avc, &nal_length_size, 0, avctx);
> - if (ret < 0) {
> - goto done;
> - }
> -
> - for (i = 0; i < MAX_PPS_COUNT; i++) {
> - if (ps.pps_list[i]) {
> - pps = (const PPS*)ps.pps_list[i]->data;
> - break;
> - }
> - }
> -
> - if (pps) {
> - if (ps.sps_list[pps->sps_id]) {
> - sps = (const SPS*)ps.sps_list[pps->sps_id]->data;
> - }
> - }
> -
> - if (pps && sps) {
> - uint8_t *data = NULL;
> - int data_size = 0;
> -
> - if ((ret = h2645_ps_to_nalu(sps->data, sps->data_size, &data,
> &data_size)) < 0) {
> - goto done;
> - }
> - ff_AMediaFormat_setBuffer(format, "csd-0", (void*)data, data_size);
> - av_freep(&data);
> -
> - if ((ret = h2645_ps_to_nalu(pps->data, pps->data_size, &data,
> &data_size)) < 0) {
> - goto done;
> - }
> - ff_AMediaFormat_setBuffer(format, "csd-1", (void*)data, data_size);
> - av_freep(&data);
> - } else {
> - av_log(avctx, AV_LOG_ERROR, "Could not extract PPS/SPS from
> extradata");
> - ret = AVERROR_INVALIDDATA;
> - }
> -
> -done:
> - ff_h264_ps_uninit(&ps);
> -
> - return ret;
> -}
> -#endif
> -
> -#if CONFIG_HEVC_MEDIACODEC_DECODER
> -static int hevc_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
> -{
> - int i;
> - int ret;
> -
> - HEVCParamSets ps;
> -
> - const HEVCVPS *vps = NULL;
> - const HEVCPPS *pps = NULL;
> - const HEVCSPS *sps = NULL;
> - int is_nalff = 0;
> - int nal_length_size = 0;
> -
> - uint8_t *vps_data = NULL;
> - uint8_t *sps_data = NULL;
> - uint8_t *pps_data = NULL;
> - int vps_data_size = 0;
> - int sps_data_size = 0;
> - int pps_data_size = 0;
> -
> - memset(&ps, 0, sizeof(ps));
> -
> - ret = ff_hevc_decode_extradata(avctx->extradata, avctx->extradata_size,
> - &ps, &is_nalff, &nal_length_size, 0, avctx);
> - if (ret < 0) {
> - goto done;
> - }
> -
> - for (i = 0; i < MAX_VPS_COUNT; i++) {
> - if (ps.vps_list[i]) {
> - vps = (const HEVCVPS*)ps.vps_list[i]->data;
> - break;
> - }
> - }
> -
> - for (i = 0; i < MAX_PPS_COUNT; i++) {
> - if (ps.pps_list[i]) {
> - pps = (const HEVCPPS*)ps.pps_list[i]->data;
> - break;
> - }
> - }
> -
> - if (pps) {
> - if (ps.sps_list[pps->sps_id]) {
> - sps = (const HEVCSPS*)ps.sps_list[pps->sps_id]->data;
> - }
> - }
> -
> - if (vps && pps && sps) {
> - uint8_t *data;
> - int data_size;
> -
> - if ((ret = h2645_ps_to_nalu(vps->data, vps->data_size, &vps_data,
> &vps_data_size)) < 0 ||
> - (ret = h2645_ps_to_nalu(sps->data, sps->data_size, &sps_data,
> &sps_data_size)) < 0 ||
> - (ret = h2645_ps_to_nalu(pps->data, pps->data_size, &pps_data,
> &pps_data_size)) < 0) {
> - goto done;
> - }
> -
> - data_size = vps_data_size + sps_data_size + pps_data_size;
> - data = av_mallocz(data_size);
> - if (!data) {
> - ret = AVERROR(ENOMEM);
> - goto done;
> - }
> -
> - memcpy(data , vps_data,
> vps_data_size);
> - memcpy(data + vps_data_size , sps_data,
> sps_data_size);
> - memcpy(data + vps_data_size + sps_data_size, pps_data,
> pps_data_size);
> -
> - ff_AMediaFormat_setBuffer(format, "csd-0", data, data_size);
> -
> - av_freep(&data);
> - } else {
> - av_log(avctx, AV_LOG_ERROR, "Could not extract VPS/PPS/SPS from
> extradata");
> - ret = AVERROR_INVALIDDATA;
> - }
> -
> -done:
> - av_freep(&vps_data);
> - av_freep(&sps_data);
> - av_freep(&pps_data);
> -
> - return ret;
> -}
> -#endif
> -
> -#if CONFIG_MPEG4_MEDIACODEC_DECODER
> -static int mpeg4_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
> -{
> - int ret = 0;
> -
> - if (avctx->extradata) {
> - ff_AMediaFormat_setBuffer(format, "csd-0", avctx->extradata,
> avctx->extradata_size);
> - }
> -
> - return ret;
> -}
> -#endif
> -
> -#if CONFIG_VP8_MEDIACODEC_DECODER || CONFIG_VP9_MEDIACODEC_DECODER
> -static int vpx_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
> -{
> - int ret = 0;
> -
> - if (avctx->extradata) {
> - ff_AMediaFormat_setBuffer(format, "csd-0", avctx->extradata,
> avctx->extradata_size);
> - }
> -
> - return ret;
> -}
> -#endif
> -
> -static av_cold int mediacodec_decode_init(AVCodecContext *avctx)
> -{
> - int ret;
> -
> - const char *codec_mime = NULL;
> -
> - const char *bsf_name = NULL;
> - const AVBitStreamFilter *bsf = NULL;
> -
> - FFAMediaFormat *format = NULL;
> - MediaCodecH264DecContext *s = avctx->priv_data;
> -
> - format = ff_AMediaFormat_new();
> - if (!format) {
> - av_log(avctx, AV_LOG_ERROR, "Failed to create media format\n");
> - ret = AVERROR_EXTERNAL;
> - goto done;
> - }
> -
> - switch (avctx->codec_id) {
> -#if CONFIG_H264_MEDIACODEC_DECODER
> - case AV_CODEC_ID_H264:
> - codec_mime = "video/avc";
> - bsf_name = "h264_mp4toannexb";
> -
> - ret = h264_set_extradata(avctx, format);
> - if (ret < 0)
> - goto done;
> - break;
> -#endif
> -#if CONFIG_HEVC_MEDIACODEC_DECODER
> - case AV_CODEC_ID_HEVC:
> - codec_mime = "video/hevc";
> - bsf_name = "hevc_mp4toannexb";
> -
> - ret = hevc_set_extradata(avctx, format);
> - if (ret < 0)
> - goto done;
> - break;
> -#endif
> -#if CONFIG_MPEG4_MEDIACODEC_DECODER
> - case AV_CODEC_ID_MPEG4:
> - codec_mime = "video/mp4v-es",
> -
> - ret = mpeg4_set_extradata(avctx, format);
> - if (ret < 0)
> - goto done;
> - break;
> -#endif
> -#if CONFIG_VP8_MEDIACODEC_DECODER
> - case AV_CODEC_ID_VP8:
> - codec_mime = "video/x-vnd.on2.vp8";
> -
> - ret = vpx_set_extradata(avctx, format);
> - if (ret < 0)
> - goto done;
> - break;
> -#endif
> -#if CONFIG_VP9_MEDIACODEC_DECODER
> - case AV_CODEC_ID_VP9:
> - codec_mime = "video/x-vnd.on2.vp9";
> -
> - ret = vpx_set_extradata(avctx, format);
> - if (ret < 0)
> - goto done;
> - break;
> -#endif
> - default:
> - av_assert0(0);
> - }
> -
> - ff_AMediaFormat_setString(format, "mime", codec_mime);
> - ff_AMediaFormat_setInt32(format, "width", avctx->width);
> - ff_AMediaFormat_setInt32(format, "height", avctx->height);
> -
> - s->ctx = av_mallocz(sizeof(*s->ctx));
> - if (!s->ctx) {
> - av_log(avctx, AV_LOG_ERROR, "Failed to allocate
> MediaCodecDecContext\n");
> - ret = AVERROR(ENOMEM);
> - goto done;
> - }
> -
> - if ((ret = ff_mediacodec_dec_init(avctx, s->ctx, codec_mime, format)) <
> 0) {
> - s->ctx = NULL;
> - goto done;
> - }
> -
> - av_log(avctx, AV_LOG_INFO, "MediaCodec started successfully, ret =
> %d\n", ret);
> -
> - s->fifo = av_fifo_alloc(sizeof(AVPacket));
> - if (!s->fifo) {
> - ret = AVERROR(ENOMEM);
> - goto done;
> - }
> -
> - if (bsf_name) {
> - bsf = av_bsf_get_by_name(bsf_name);
> - if(!bsf) {
> - ret = AVERROR_BSF_NOT_FOUND;
> - goto done;
> - }
> -
> - if ((ret = av_bsf_alloc(bsf, &s->bsf))) {
> - goto done;
> - }
> -
> - if (((ret = avcodec_parameters_from_context(s->bsf->par_in, avctx)) < 0)
> ||
> - ((ret = av_bsf_init(s->bsf)) < 0)) {
> - goto done;
> - }
> - }
> -
> - av_init_packet(&s->filtered_pkt);
> -
> -done:
> - if (format) {
> - ff_AMediaFormat_delete(format);
> - }
> -
> - if (ret < 0) {
> - mediacodec_decode_close(avctx);
> - }
> -
> - return ret;
> -}
> -
> -
> -static int mediacodec_process_data(AVCodecContext *avctx, AVFrame *frame,
> - int *got_frame, AVPacket *pkt)
> -{
> - MediaCodecH264DecContext *s = avctx->priv_data;
> -
> - return ff_mediacodec_dec_decode(avctx, s->ctx, frame, got_frame, pkt);
> -}
> -
> -static int mediacodec_decode_frame(AVCodecContext *avctx, void *data,
> - int *got_frame, AVPacket *avpkt)
> -{
> - MediaCodecH264DecContext *s = avctx->priv_data;
> - AVFrame *frame = data;
> - int ret;
> -
> - /* buffer the input packet */
> - if (avpkt->size) {
> - AVPacket input_pkt = { 0 };
> -
> - if (av_fifo_space(s->fifo) < sizeof(input_pkt)) {
> - ret = av_fifo_realloc2(s->fifo,
> - av_fifo_size(s->fifo) +
> sizeof(input_pkt));
> - if (ret < 0)
> - return ret;
> - }
> -
> - ret = av_packet_ref(&input_pkt, avpkt);
> - if (ret < 0)
> - return ret;
> - av_fifo_generic_write(s->fifo, &input_pkt, sizeof(input_pkt), NULL);
> - }
> -
> - /*
> - * MediaCodec.flush() discards both input and output buffers, thus we
> - * need to delay the call to this function until the user has released or
> - * renderered the frames he retains.
> - *
> - * After we have buffered an input packet, check if the codec is in the
> - * flushing state. If it is, we need to call ff_mediacodec_dec_flush.
> - *
> - * ff_mediacodec_dec_flush returns 0 if the flush cannot be performed on
> - * the codec (because the user retains frames). The codec stays in the
> - * flushing state.
> - *
> - * ff_mediacodec_dec_flush returns 1 if the flush can actually be
> - * performed on the codec. The codec leaves the flushing state and can
> - * process again packets.
> - *
> - * ff_mediacodec_dec_flush returns a negative value if an error has
> - * occurred.
> - *
> - */
> - if (ff_mediacodec_dec_is_flushing(avctx, s->ctx)) {
> - if (!ff_mediacodec_dec_flush(avctx, s->ctx)) {
> - return avpkt->size;
> - }
> - }
> -
> - /* process buffered data */
> - while (!*got_frame) {
> - /* prepare the input data -- convert to Annex B if needed */
> - if (s->filtered_pkt.size <= 0) {
> - AVPacket input_pkt = { 0 };
> -
> - av_packet_unref(&s->filtered_pkt);
> -
> - /* no more data */
> - if (av_fifo_size(s->fifo) < sizeof(AVPacket)) {
> - return avpkt->size ? avpkt->size :
> - ff_mediacodec_dec_decode(avctx, s->ctx, frame,
> got_frame, avpkt);
> - }
> -
> - av_fifo_generic_read(s->fifo, &input_pkt, sizeof(input_pkt),
> NULL);
> -
> - if (s->bsf) {
> - ret = av_bsf_send_packet(s->bsf, &input_pkt);
> - if (ret < 0) {
> - return ret;
> - }
> -
> - ret = av_bsf_receive_packet(s->bsf, &s->filtered_pkt);
> - if (ret == AVERROR(EAGAIN)) {
> - goto done;
> - }
> - } else {
> - av_packet_move_ref(&s->filtered_pkt, &input_pkt);
> - }
> -
> - /* {h264,hevc}_mp4toannexb are used here and do not require
> flushing */
> - av_assert0(ret != AVERROR_EOF);
> -
> - if (ret < 0) {
> - return ret;
> - }
> - }
> -
> - ret = mediacodec_process_data(avctx, frame, got_frame,
> &s->filtered_pkt);
> - if (ret < 0)
> - return ret;
> -
> - s->filtered_pkt.size -= ret;
> - s->filtered_pkt.data += ret;
> - }
> -done:
> - return avpkt->size;
> -}
> -
> -static void mediacodec_decode_flush(AVCodecContext *avctx)
> -{
> - MediaCodecH264DecContext *s = avctx->priv_data;
> -
> - while (av_fifo_size(s->fifo)) {
> - AVPacket pkt;
> - av_fifo_generic_read(s->fifo, &pkt, sizeof(pkt), NULL);
> - av_packet_unref(&pkt);
> - }
> - av_fifo_reset(s->fifo);
> -
> - av_packet_unref(&s->filtered_pkt);
> -
> - ff_mediacodec_dec_flush(avctx, s->ctx);
> -}
> -
> -#if CONFIG_H264_MEDIACODEC_DECODER
> -AVCodec ff_h264_mediacodec_decoder = {
> - .name = "h264_mediacodec",
> - .long_name = NULL_IF_CONFIG_SMALL("H.264 Android MediaCodec
> decoder"),
> - .type = AVMEDIA_TYPE_VIDEO,
> - .id = AV_CODEC_ID_H264,
> - .priv_data_size = sizeof(MediaCodecH264DecContext),
> - .init = mediacodec_decode_init,
> - .decode = mediacodec_decode_frame,
> - .flush = mediacodec_decode_flush,
> - .close = mediacodec_decode_close,
> - .capabilities = CODEC_CAP_DELAY,
> - .caps_internal = FF_CODEC_CAP_SETS_PKT_DTS,
> -};
> -#endif
> -
> -#if CONFIG_HEVC_MEDIACODEC_DECODER
> -AVCodec ff_hevc_mediacodec_decoder = {
> - .name = "hevc_mediacodec",
> - .long_name = NULL_IF_CONFIG_SMALL("H.265 Android MediaCodec
> decoder"),
> - .type = AVMEDIA_TYPE_VIDEO,
> - .id = AV_CODEC_ID_HEVC,
> - .priv_data_size = sizeof(MediaCodecH264DecContext),
> - .init = mediacodec_decode_init,
> - .decode = mediacodec_decode_frame,
> - .flush = mediacodec_decode_flush,
> - .close = mediacodec_decode_close,
> - .capabilities = CODEC_CAP_DELAY,
> - .caps_internal = FF_CODEC_CAP_SETS_PKT_DTS,
> -};
> -#endif
> -
> -#if CONFIG_MPEG4_MEDIACODEC_DECODER
> -AVCodec ff_mpeg4_mediacodec_decoder = {
> - .name = "mpeg4_mediacodec",
> - .long_name = NULL_IF_CONFIG_SMALL("MPEG4 Android MediaCodec
> decoder"),
> - .type = AVMEDIA_TYPE_VIDEO,
> - .id = AV_CODEC_ID_MPEG4,
> - .priv_data_size = sizeof(MediaCodecH264DecContext),
> - .init = mediacodec_decode_init,
> - .decode = mediacodec_decode_frame,
> - .flush = mediacodec_decode_flush,
> - .close = mediacodec_decode_close,
> - .capabilities = CODEC_CAP_DELAY,
> - .caps_internal = FF_CODEC_CAP_SETS_PKT_DTS,
> -};
> -#endif
> -
> -#if CONFIG_VP8_MEDIACODEC_DECODER
> -AVCodec ff_vp8_mediacodec_decoder = {
> - .name = "vp8_mediacodec",
> - .long_name = NULL_IF_CONFIG_SMALL("VP8 Android MediaCodec decoder"),
> - .type = AVMEDIA_TYPE_VIDEO,
> - .id = AV_CODEC_ID_VP8,
> - .priv_data_size = sizeof(MediaCodecH264DecContext),
> - .init = mediacodec_decode_init,
> - .decode = mediacodec_decode_frame,
> - .flush = mediacodec_decode_flush,
> - .close = mediacodec_decode_close,
> - .capabilities = CODEC_CAP_DELAY,
> - .caps_internal = FF_CODEC_CAP_SETS_PKT_DTS,
> -};
> -#endif
> -
> -#if CONFIG_VP9_MEDIACODEC_DECODER
> -AVCodec ff_vp9_mediacodec_decoder = {
> - .name = "vp9_mediacodec",
> - .long_name = NULL_IF_CONFIG_SMALL("VP9 Android MediaCodec decoder"),
> - .type = AVMEDIA_TYPE_VIDEO,
> - .id = AV_CODEC_ID_VP9,
> - .priv_data_size = sizeof(MediaCodecH264DecContext),
> - .init = mediacodec_decode_init,
> - .decode = mediacodec_decode_frame,
> - .flush = mediacodec_decode_flush,
> - .close = mediacodec_decode_close,
> - .capabilities = CODEC_CAP_DELAY,
> - .caps_internal = FF_CODEC_CAP_SETS_PKT_DTS,
> -};
> -#endif
> --
> 2.10.0
>
If there is no objection, I will push the patchset in one day.
Matthieu
[...]
_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
http://ffmpeg.org/mailman/listinfo/ffmpeg-devel
