@@ -11,6 +11,7 @@ version <next>:

 - bench and abench filters

 - ciescope filter

 - protocol blacklisting API

+- MediaCodec H264 decoding

 version 3.0:

@@ -308,6 +308,7 @@ Codecs:

 Hardware acceleration:

   crystalhd.c                           Philip Langdale

   dxva2*                                Hendrik Leppkes, Laurent Aimar

+  mediacodec*                           Matthieu Bouron

   vaapi*                                Gwenole Beauchesne

   vda*                                  Sebastien Zwickert

   vdpau*                                Philip Langdale, Carl Eugen Hoyos

@@ -276,6 +276,7 @@ External library support:

   --enable-libzvbi         enable teletext support via libzvbi [no]

   --disable-lzma           disable lzma [autodetect]

   --enable-decklink        enable Blackmagic DeckLink I/O support [no]

+  --enable-mediacodec      enable Android MediaCodec support [no]

   --enable-mmal            enable decoding via MMAL [no]

   --enable-netcdf          enable NetCDF, needed for sofalizer filter [no]

   --enable-nvenc           enable NVIDIA NVENC support [no]

@@ -1501,6 +1502,7 @@ EXTERNAL_LIBRARY_LIST="

     libzmq

     libzvbi

     lzma

+    mediacodec

     mmal

     netcdf

     nvenc

@@ -2505,6 +2507,8 @@ h264_d3d11va_hwaccel_deps="d3d11va"

 h264_d3d11va_hwaccel_select="h264_decoder"

 h264_dxva2_hwaccel_deps="dxva2"

 h264_dxva2_hwaccel_select="h264_decoder"

+h264_mediacodec_decoder_deps="mediacodec"

+h264_mediacodec_decoder_select="h264_mp4toannexb_bsf h264_parser"

 h264_mmal_decoder_deps="mmal"

 h264_mmal_decoder_select="mmal"

 h264_mmal_hwaccel_deps="mmal"

@@ -5672,6 +5676,7 @@ enabled libzmq            && require_pkg_config libzmq zmq.h zmq_ctx_new

 enabled libzvbi           && require libzvbi libzvbi.h vbi_decoder_new -lzvbi &&

                              { check_cpp_condition libzvbi.h "VBI_VERSION_MAJOR > 0 || VBI_VERSION_MINOR > 2 || VBI_VERSION_MINOR == 2 && VBI_VERSION_MICRO >= 28" ||

                                enabled gpl || die "ERROR: libzvbi requires version 0.2.28 or --enable-gpl."; }

+enabled mediacodec        && { enabled jni || die "ERROR: mediacodec requires --enable-jni"; }

 enabled mmal              && { check_lib interface/mmal/mmal.h mmal_port_connect -lmmal_core -lmmal_util -lmmal_vc_client -lbcm_host ||

                                 { ! enabled cross_compile && {

                                     add_cflags -isystem/opt/vc/include/ -isystem/opt/vc/include/interface/vmcs_host/linux -isystem/opt/vc/include/interface/vcos/pthreads -fgnu89-inline ;

@@ -91,6 +91,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_wrapper.o mediacodec_sw_buffer.o

 OBJS-$(CONFIG_MPEG_ER)                 += mpeg_er.o

 OBJS-$(CONFIG_MPEGAUDIO)               += mpegaudio.o mpegaudiodata.o   \

                                           mpegaudiodecheader.o

@@ -306,6 +307,7 @@ OBJS-$(CONFIG_H264_DECODER)            += h264.o h264_cabac.o h264_cavlc.o \

                                           h264_direct.o h264_loopfilter.o  \

                                           h264_mb.o h264_picture.o h264_ps.o \

                                           h264_refs.o h264_sei.o h264_slice.o

+OBJS-$(CONFIG_H264_MEDIACODEC_DECODER) += mediacodecdec_h264.o

 OBJS-$(CONFIG_H264_MMAL_DECODER)       += mmaldec.o

 OBJS-$(CONFIG_H264_VDA_DECODER)        += vda_h264_dec.o

 OBJS-$(CONFIG_H264_QSV_DECODER)        += qsvdec_h2645.o

@@ -944,6 +946,7 @@ SKIPHEADERS-$(CONFIG_LIBSCHROEDINGER)  += libschroedinger.h

 SKIPHEADERS-$(CONFIG_LIBUTVIDEO)       += libutvideo.h

 SKIPHEADERS-$(CONFIG_LIBVPX)           += libvpx.h

 SKIPHEADERS-$(CONFIG_LIBWEBP_ENCODER)  += libwebpenc_common.h

+SKIPHEADERS-$(CONFIG_MEDIACODEC)       += mediacodecdec.h mediacodec_wrapper.h mediacodec_sw_buffer.h

 SKIPHEADERS-$(CONFIG_QSV)              += qsv.h qsv_internal.h

 SKIPHEADERS-$(CONFIG_QSVDEC)           += qsvdec.h

 SKIPHEADERS-$(CONFIG_QSVENC)           += qsvenc.h

@@ -196,6 +196,7 @@ void avcodec_register_all(void)

     REGISTER_ENCDEC (H263P,             h263p);

     REGISTER_DECODER(H264,              h264);

     REGISTER_DECODER(H264_CRYSTALHD,    h264_crystalhd);

+    REGISTER_DECODER(H264_MEDIACODEC,   h264_mediacodec);

     REGISTER_DECODER(H264_MMAL,         h264_mmal);

     REGISTER_DECODER(H264_QSV,          h264_qsv);

     REGISTER_DECODER(H264_VDA,          h264_vda);

new file mode 100644

@@ -0,0 +1,339 @@

+/*

+ * Android MediaCodec software buffer copy functions

+ *

+ * 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/frame.h"

+#include "libavutil/mem.h"

+

+#include "avcodec.h"

+#include "mediacodecdec.h"

+#include "mediacodec_wrapper.h"

+#include "mediacodec_sw_buffer.h"

+

+#define QCOM_TILE_WIDTH 64

+#define QCOM_TILE_HEIGHT 32

+#define QCOM_TILE_SIZE (QCOM_TILE_WIDTH * QCOM_TILE_HEIGHT)

+#define QCOM_TILE_GROUP_SIZE (4 * QCOM_TILE_SIZE)

+

+/**

+ * The code handling the the various YUV color formats is taken from the

+ * GStreamer project.

+ *

+ * Gstreamer reference:

+ * https://cgit.freedesktop.org/gstreamer/gst-plugins-bad/tree/sys/androidmedia/

+ *

+ * Copyright (C) 2012, Collabora Ltd.

+ *   Author: Sebastian Dröge <sebastian.droege@collabora.co.uk>

+ *

+ * Copyright (C) 2012, Rafaël Carré <funman@videolanorg>

+ *

+ * Copyright (C) 2015, Sebastian Dröge <sebastian@centricular.com>

+ *

+ * Copyright (C) 2014-2015, Collabora Ltd.

+ *   Author: Matthieu Bouron <matthieu.bouron@gcollabora.com>

+ *

+ * Copyright (C) 2015, Edward Hervey

+ *   Author: Edward Hervey <bilboed@gmail.com>

+ *

+ * Copyright (C) 2015, Matthew Waters <matthew@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

+ *

+ */

+void ff_mediacodec_sw_buffer_copy_yuv420_planar(AVCodecContext *avctx,

+                                                MediaCodecDecContext *s,

+                                                uint8_t *data,

+                                                size_t size,

+                                                FFAMediaCodecBufferInfo *info,

+                                                AVFrame *frame)

+{

+    int i;

+    uint8_t *src = NULL;

+

+    for (i = 0; i < 3; i++) {

+        int stride = s->stride;

+        int height;

+

+        src = data + info->offset;

+        if (i == 0) {

+            height = avctx->height;

+

+            src += s->crop_top * s->stride;

+            src += s->crop_left;

+        } else {

+            height = avctx->height / 2;

+            stride = (s->stride + 1) / 2;

+

+            src += s->slice_height * s->stride;

+

+            if (i == 2) {

+                src += ((s->slice_height + 1) / 2) * stride;

+            }

+

+            src += s->crop_top * stride;

+            src += (s->crop_left / 2);

+        }

+

+        if (frame->linesize[i] == stride) {

+            memcpy(frame->data[i], src, height * stride);

+        } else {

+            int j, width;

+            uint8_t *dst = frame->data[i];

+

+            if (i == 0) {

+                width = avctx->width;

+            } else if (i == 1) {

+                width = FFMIN(frame->linesize[i], FFALIGN(avctx->width, 2));

+            }

+

+            for (j = 0; j < height; j++) {

+                memcpy(dst, src, width);

+                src += stride;

+                dst += frame->linesize[i];

+            }

+        }

+    }

+}

+

+void ff_mediacodec_sw_buffer_copy_yuv420_semi_planar(AVCodecContext *avctx,

+                                                     MediaCodecDecContext *s,

+                                                     uint8_t *data,

+                                                     size_t size,

+                                                     FFAMediaCodecBufferInfo *info,

+                                                     AVFrame *frame)

+{

+    int i;

+    uint8_t *src = NULL;

+

+    for (i = 0; i < 2; i++) {

+        int height;

+

+        src = data + info->offset;

+        if (i == 0) {

+            height = avctx->height;

+

+            src += s->crop_top * s->stride;

+            src += s->crop_left;

+        } else if (i == 1) {

+            height = avctx->height / 2;

+

+            src += s->slice_height * s->stride;

+            src += s->crop_top * s->stride;

+            src += s->crop_left;

+        }

+

+        if (frame->linesize[i] == s->stride) {

+            memcpy(frame->data[i], src, height * s->stride);

+        } else {

+            int j, width;

+            uint8_t *dst = frame->data[i];

+

+            if (i == 0) {

+                width = avctx->width;

+            } else if (i == 1) {

+                width = FFMIN(frame->linesize[i], FFALIGN(avctx->width, 2));

+            }

+

+            for (j = 0; j < height; j++) {

+                memcpy(dst, src, width);

+                src += s->stride;

+                dst += frame->linesize[i];

+            }

+        }

+    }

+}

+

+

+

+void ff_mediacodec_sw_buffer_copy_yuv420_packed_semi_planar(AVCodecContext *avctx,

+                                                            MediaCodecDecContext *s,

+                                                            uint8_t *data,

+                                                            size_t size,

+                                                            FFAMediaCodecBufferInfo *info,

+                                                            AVFrame *frame)

+{

+    int i;

+    uint8_t *src = NULL;

+

+    for (i = 0; i < 2; i++) {

+        int height;

+

+        src = data + info->offset;

+        if (i == 0) {

+            height = avctx->height;

+        } else if (i == 1) {

+            height = avctx->height / 2;

+

+            src += (s->slice_height - s->crop_top / 2) * s->stride;

+

+            src += s->crop_top * s->stride;

+            src += s->crop_left;

+        }

+

+        if (frame->linesize[i] == s->stride) {

+            memcpy(frame->data[i], src, height * s->stride);

+        } else {

+            int j, width;

+            uint8_t *dst = frame->data[i];

+

+            if (i == 0) {

+                width = avctx->width;

+            } else if (i == 1) {

+                width = FFMIN(frame->linesize[i], FFALIGN(avctx->width, 2));

+            }

+

+            for (j = 0; j < height; j++) {

+                memcpy(dst, src, width);

+                src += s->stride;

+                dst += frame->linesize[i];

+            }

+        }

+    }

+}

+

+/**

+ * The code handling the QCOM_FormatYUV420PackedSemiPlanar64x32Tile2m8ka

+ * color format is taken from the VLC project.

+ *

+ * VLC reference:

+ * http://git.videolan.org/?p=vlc.git;a=blob;f=modules/codec/omxil/qcom.c;hb=HEAD

+ *

+ * VLC copyright notice:

+ *

+ *****************************************************************************

+ * qcom.c : pixel format translation for Qualcomm tiled nv12

+ *****************************************************************************

+ * Copyright © 2012 Rafaël Carré

+ *

+ * Authors: Rafaël Carré <funman@videolanorg>

+ *

+ * This program 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.

+ *

+ * This program 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 program; if not, write to the Free Software Foundation,

+ * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.

+ *

+ */

+

+static size_t qcom_tile_pos(size_t x, size_t y, size_t w, size_t h)

+{

+  size_t flim = x + (y & ~1) * w;

+

+  if (y & 1) {

+    flim += (x & ~3) + 2;

+  } else if ((h & 1) == 0 || y != (h - 1)) {

+    flim += (x + 2) & ~3;

+  }

+

+  return flim;

+}

+

+void ff_mediacodec_sw_buffer_copy_yuv420_packed_semi_planar_64x32Tile2m8ka(AVCodecContext *avctx,

+                                                                           MediaCodecDecContext *s,

+                                                                           uint8_t *data,

+                                                                           size_t size,

+                                                                           FFAMediaCodecBufferInfo *info,

+                                                                           AVFrame *frame)

+{

+    size_t width = frame->width;

+    size_t linesize = frame->linesize[0];

+    size_t height = frame->height;

+

+    const size_t tile_w = (width - 1) / QCOM_TILE_WIDTH + 1;

+    const size_t tile_w_align = (tile_w + 1) & ~1;

+    const size_t tile_h_luma = (height - 1) / QCOM_TILE_HEIGHT + 1;

+    const size_t tile_h_chroma = (height / 2 - 1) / QCOM_TILE_HEIGHT + 1;

+

+    size_t luma_size = tile_w_align * tile_h_luma * QCOM_TILE_SIZE;

+    if((luma_size % QCOM_TILE_GROUP_SIZE) != 0)

+        luma_size = (((luma_size - 1) / QCOM_TILE_GROUP_SIZE) + 1) * QCOM_TILE_GROUP_SIZE;

+

+    for(size_t y = 0; y < tile_h_luma; y++) {

+        size_t row_width = width;

+        for(size_t x = 0; x < tile_w; x++) {

+            size_t tile_width = row_width;

+            size_t tile_height = height;

+            /* dest luma memory index for this tile */

+            size_t luma_idx = y * QCOM_TILE_HEIGHT * linesize + x * QCOM_TILE_WIDTH;

+            /* dest chroma memory index for this tile */

+            /* XXX: remove divisions */

+            size_t chroma_idx = (luma_idx / linesize) * linesize / 2 + (luma_idx % linesize);

+

+            /* luma source pointer for this tile */

+            const uint8_t *src_luma  = data

+                + qcom_tile_pos(x, y,tile_w_align, tile_h_luma) * QCOM_TILE_SIZE;

+

+            /* chroma source pointer for this tile */

+            const uint8_t *src_chroma = data + luma_size

+                + qcom_tile_pos(x, y/2, tile_w_align, tile_h_chroma) * QCOM_TILE_SIZE;

+            if (y & 1)

+                src_chroma += QCOM_TILE_SIZE/2;

+

+            /* account for right columns */

+            if (tile_width > QCOM_TILE_WIDTH)

+                tile_width = QCOM_TILE_WIDTH;

+

+            /* account for bottom rows */

+            if (tile_height > QCOM_TILE_HEIGHT)

+                tile_height = QCOM_TILE_HEIGHT;

+

+            tile_height /= 2;

+            while (tile_height--) {

+                memcpy(frame->data[0] + luma_idx, src_luma, tile_width);

+                src_luma += QCOM_TILE_WIDTH;

+                luma_idx += linesize;

+

+                memcpy(frame->data[0] + luma_idx, src_luma, tile_width);

+                src_luma += QCOM_TILE_WIDTH;

+                luma_idx += linesize;

+

+                memcpy(frame->data[1] + chroma_idx, src_chroma, tile_width);

+                src_chroma += QCOM_TILE_WIDTH;

+                chroma_idx += linesize;

+            }

+            row_width -= QCOM_TILE_WIDTH;

+        }

+        height -= QCOM_TILE_HEIGHT;

+    }

+}

new file mode 100644

@@ -0,0 +1,62 @@

+/*

+ * Android MediaCodec software buffer copy functions

+ *

+ * 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

+ */

+

+#ifndef AVCODEC_MEDIACODEC_SW_BUFFER_H

+#define AVCODEC_MEDIACODEC_SW_BUFFER_H

+

+#include <sys/types.h>

+

+#include "libavutil/frame.h"

+

+#include "avcodec.h"

+#include "mediacodecdec.h"

+#include "mediacodec_wrapper.h"

+

+void ff_mediacodec_sw_buffer_copy_yuv420_planar(AVCodecContext *avctx,

+                                                MediaCodecDecContext *s,

+                                                uint8_t *data,

+                                                size_t size,

+                                                FFAMediaCodecBufferInfo *info,

+                                                AVFrame *frame);

+

+void ff_mediacodec_sw_buffer_copy_yuv420_semi_planar(AVCodecContext *avctx,

+                                                     MediaCodecDecContext *s,

+                                                     uint8_t *data,

+                                                     size_t size,

+                                                     FFAMediaCodecBufferInfo *info,

+                                                     AVFrame *frame);

+

+void ff_mediacodec_sw_buffer_copy_yuv420_packed_semi_planar(AVCodecContext *avctx,

+                                                     MediaCodecDecContext *s,

+                                                     uint8_t *data,

+                                                     size_t size,

+                                                     FFAMediaCodecBufferInfo *info,

+                                                     AVFrame *frame);

+

+void ff_mediacodec_sw_buffer_copy_yuv420_packed_semi_planar_64x32Tile2m8ka(AVCodecContext *avctx,

+                                                     MediaCodecDecContext *s,

+                                                     uint8_t *data,

+                                                     size_t size,

+                                                     FFAMediaCodecBufferInfo *info,

+                                                     AVFrame *frame);

+

+#endif /* AVCODEC_MEDIACODEC_SW_BUFFER_H */

new file mode 100644

@@ -0,0 +1,1705 @@

+/*

+ * Android MediaCodec Wrapper

+ *

+ * 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 <jni.h>

+

+#include "libavutil/avassert.h"

+#include "libavutil/mem.h"

+#include "libavutil/avstring.h"

+

+#include "ffjni.h"

+#include "version.h"

+#include "mediacodec_wrapper.h"

+

+struct JNIAMediaCodecListFields {

+

+    jclass mediaformat_class;

+    jmethodID create_video_format_id;

+

+    jclass mediacodec_list_class;

+    jmethodID init_id;

+    jmethodID find_decoder_for_format_id;

+

+    jmethodID get_codec_count_id;

+    jmethodID get_codec_info_at_id;

+

+    jclass mediacodec_info_class;

+    jmethodID get_name_id;

+    jmethodID get_supported_types_id;

+    jmethodID is_encoder_id;

+

+} JNIAMediaCodecListFields;

+

+static const struct FFJniField jfields_mapping[] = {

+    { "android/media/MediaFormat", NULL, NULL, FF_JNI_CLASS, offsetof(struct JNIAMediaCodecListFields, mediaformat_class), 1 },

+        { "android/media/MediaFormat", "createVideoFormat", "(Ljava/lang/String;II)Landroid/media/MediaFormat;", FF_JNI_STATIC_METHOD, offsetof(struct JNIAMediaCodecListFields, create_video_format_id), 1 },

+

+    { "android/media/MediaCodecList", NULL, NULL, FF_JNI_CLASS, offsetof(struct JNIAMediaCodecListFields, mediacodec_list_class), 1 },

+        { "android/media/MediaCodecList", "<init>", "(I)V", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecListFields, init_id), 0 },

+        { "android/media/MediaCodecList", "findDecoderForFormat", "(Landroid/media/MediaFormat;)Ljava/lang/String;", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecListFields, find_decoder_for_format_id), 0 },

+

+        { "android/media/MediaCodecList", "getCodecCount", "()I", FF_JNI_STATIC_METHOD, offsetof(struct JNIAMediaCodecListFields, get_codec_count_id), 1 },

+        { "android/media/MediaCodecList", "getCodecInfoAt", "(I)Landroid/media/MediaCodecInfo;", FF_JNI_STATIC_METHOD, offsetof(struct JNIAMediaCodecListFields, get_codec_info_at_id), 1 },

+

+    { "android/media/MediaCodecInfo", NULL, NULL, FF_JNI_CLASS, offsetof(struct JNIAMediaCodecListFields, mediacodec_info_class), 1 },

+        { "android/media/MediaCodecInfo", "getName", "()Ljava/lang/String;", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecListFields, get_name_id), 1 },

+        { "android/media/MediaCodecInfo", "getSupportedTypes", "()[Ljava/lang/String;", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecListFields, get_supported_types_id), 1 },

+        { "android/media/MediaCodecInfo", "isEncoder", "()Z", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecListFields, is_encoder_id), 1 },

+

+    { NULL }

+};

+

+#define JNI_ATTACH_ENV_OR_RETURN(env, attached, log_ctx, ret) do { \

+    (env) = ff_jni_attach_env(attached, log_ctx);                  \

+    if (!(env)) {                                                  \

+        return ret;                                                \

+    }                                                              \

+} while (0)

+

+#define JNI_ATTACH_ENV_OR_RETURN_VOID(env, attached, log_ctx) do { \

+    (env) = ff_jni_attach_env(attached, log_ctx);              \

+    if (!(env)) {                                                  \

+        return;                                                    \

+    }                                                              \

+} while (0)

+

+#define JNI_DETACH_ENV(attached, log_ctx) do { \

+    if (attached)                              \

+        ff_jni_detach_env(log_ctx);            \

+} while (0)

+

+char *ff_AMediaCodecList_getCodecNameByType(const char *mime, int width, int height, void *log_ctx)

+{

+    int ret;

+    char *name = NULL;

+    char *supported_type = NULL;

+

+    int attached = 0;

+    JNIEnv *env = NULL;

+    struct JNIAMediaCodecListFields jfields = { 0 };

+

+    jobject format = NULL;

+    jobject codec = NULL;

+    jstring tmp = NULL;

+

+    jobject info = NULL;

+    jobject type = NULL;

+    jobjectArray types = NULL;

+

+    JNI_ATTACH_ENV_OR_RETURN(env, &attached, log_ctx, NULL);

+

+    if ((ret = ff_jni_init_jfields(env, &jfields, jfields_mapping, 0, log_ctx)) < 0) {

+        goto done;

+    }

+

+    if (jfields.init_id && jfields.find_decoder_for_format_id) {

+        tmp = ff_jni_utf_chars_to_jstring(env, mime, log_ctx);

+        if (!tmp) {

+            goto done;

+        }

+

+        format = (*env)->CallStaticObjectMethod(env, jfields.mediaformat_class, jfields.create_video_format_id, tmp, width, height);

+        if (ff_jni_exception_check(env, 1, log_ctx) < 0) {

+            goto done;

+        }

+        (*env)->DeleteLocalRef(env, tmp);

+

+        codec = (*env)->NewObject(env, jfields.mediacodec_list_class, jfields.init_id, 0);

+        if (ff_jni_exception_check(env, 1, log_ctx) < 0) {

+            goto done;

+        }

+

+        tmp = (*env)->CallObjectMethod(env, codec, jfields.find_decoder_for_format_id, format);

+        if (ff_jni_exception_check(env, 1, log_ctx) < 0) {

+            goto done;

+        }

+        if (!tmp) {

+            av_log(NULL, AV_LOG_ERROR, "Could not find decoder in media codec list "

+                                       "for format { mime=%s width=%d height=%d }\n", mime, width, height);

+            goto done;

+        }

+

+        name = ff_jni_jstring_to_utf_chars(env, tmp, log_ctx);

+        if (!name) {

+            goto done;

+        }

+

+    } else {

+        int i;

+        int codec_count;

+

+        codec_count = (*env)->CallStaticIntMethod(env, jfields.mediacodec_list_class, jfields.get_codec_count_id);

+        if (ff_jni_exception_check(env, 1, log_ctx) < 0) {

+            goto done;

+        }

+

+        for(i = 0; i < codec_count; i++) {

+            int j;

+            int type_count;

+            int is_encoder;

+

+            info = (*env)->CallStaticObjectMethod(env, jfields.mediacodec_list_class, jfields.get_codec_info_at_id, i);

+            if (ff_jni_exception_check(env, 1, log_ctx) < 0) {

+                goto done;

+            }

+

+            types = (*env)->CallObjectMethod(env, info, jfields.get_supported_types_id);

+            if (ff_jni_exception_check(env, 1, log_ctx) < 0) {

+                goto done;

+            }

+

+            is_encoder = (*env)->CallBooleanMethod(env, info, jfields.is_encoder_id);

+            if (ff_jni_exception_check(env, 1, log_ctx) < 0) {

+                goto done;

+            }

+

+            if (is_encoder) {

+                continue;

+            }

+

+            type_count = (*env)->GetArrayLength(env, types);

+            for (j = 0; j < type_count; j++) {

+

+                type = (*env)->GetObjectArrayElement(env, types, j);

+                if (ff_jni_exception_check(env, 1, log_ctx) < 0) {

+                    goto done;

+                }

+

+                supported_type = ff_jni_jstring_to_utf_chars(env, type, log_ctx);

+                if (!supported_type) {

+                    goto done;

+                }

+

+                if (!av_strcasecmp(supported_type, mime)) {

+                    jobject codec_name;

+

+                    codec_name = (*env)->CallObjectMethod(env, info, jfields.get_name_id);

+                    if (ff_jni_exception_check(env, 1, log_ctx) < 0) {

+                        goto done;

+                    }

+

+                    name = ff_jni_jstring_to_utf_chars(env, codec_name, log_ctx);

+                    if (!name) {

+                        goto done;

+                    }

+

+                    if (strstr(name, "OMX.google")) {

+                        av_freep(&name);

+                        continue;

+                    }

+                }

+

+                av_freep(&supported_type);

+            }

+

+            (*env)->DeleteLocalRef(env, info);

+            info = NULL;

+

+            (*env)->DeleteLocalRef(env, types);

+            types = NULL;

+

+            if (name)

+                break;

+        }

+    }

+

+done:

+    if (format) {

+        (*env)->DeleteLocalRef(env, format);

+    }

+

+    if (codec) {

+        (*env)->DeleteLocalRef(env, codec);

+    }

+

+    if (tmp) {

+        (*env)->DeleteLocalRef(env, tmp);

+    }

+

+    if (info) {

+        (*env)->DeleteLocalRef(env, info);

+    }

+

+    if (type) {

+        (*env)->DeleteLocalRef(env, type);

+    }

+

+    if (types) {

+        (*env)->DeleteLocalRef(env, types);

+    }

+

+    av_freep(&supported_type);

+

+    ff_jni_reset_jfields(env, &jfields, jfields_mapping, 0, log_ctx);

+

+    JNI_DETACH_ENV(attached, log_ctx);

+

+    return name;

+}

+

+struct JNIAMediaFormatFields {

+

+    jclass clazz;

+

+    jmethodID init_id;

+

+    jmethodID get_integer_id;

+    jmethodID get_long_id;

+    jmethodID get_float_id;

+    jmethodID get_bytebuffer_id;

+    jmethodID get_string_id;

+

+    jmethodID set_integer_id;

+    jmethodID set_long_id;

+    jmethodID set_float_id;

+    jmethodID set_bytebuffer_id;

+    jmethodID set_string_id;

+

+    jmethodID to_string_id;

+

+} JNIAMediaFormatFields;

+

+static const struct FFJniField jni_amediaformat_mapping[] = {

+    { "android/media/MediaFormat", NULL, NULL, FF_JNI_CLASS, offsetof(struct JNIAMediaFormatFields, clazz), 1 },

+

+        { "android/media/MediaFormat", "<init>", "()V", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, init_id), 1 },

+

+        { "android/media/MediaFormat", "getInteger", "(Ljava/lang/String;)I", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, get_integer_id), 1 },

+        { "android/media/MediaFormat", "getLong", "(Ljava/lang/String;)J", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, get_long_id), 1 },

+        { "android/media/MediaFormat", "getFloat", "(Ljava/lang/String;)F", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, get_float_id), 1 },

+        { "android/media/MediaFormat", "getByteBuffer", "(Ljava/lang/String;)Ljava/nio/ByteBuffer;", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, get_bytebuffer_id), 1 },

+        { "android/media/MediaFormat", "getString", "(Ljava/lang/String;)Ljava/lang/String;", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, get_string_id), 1 },

+

+        { "android/media/MediaFormat", "setInteger", "(Ljava/lang/String;I)V", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, set_integer_id), 1 },

+        { "android/media/MediaFormat", "setLong", "(Ljava/lang/String;J)V", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, set_long_id), 1 },

+        { "android/media/MediaFormat", "setFloat", "(Ljava/lang/String;F)V", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, set_float_id), 1 },

+        { "android/media/MediaFormat", "setByteBuffer", "(Ljava/lang/String;Ljava/nio/ByteBuffer;)V", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, set_bytebuffer_id), 1 },

+        { "android/media/MediaFormat", "setString", "(Ljava/lang/String;Ljava/lang/String;)V", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, set_string_id), 1 },

+

+        { "android/media/MediaFormat", "toString", "()Ljava/lang/String;", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, to_string_id), 1 },

+

+    { NULL }

+};

+

+static const AVClass amediaformat_class = {

+    .class_name = "amediaformat",

+    .item_name  = av_default_item_name,

+    .version    = LIBAVCODEC_VERSION_INT,

+};

+

+struct FFAMediaFormat {

+

+    const AVClass *class;

+    struct JNIAMediaFormatFields jfields;

+    jobject object;

+};

+

+FFAMediaFormat *ff_AMediaFormat_new(void)

+{

+    int attached = 0;

+    JNIEnv *env = NULL;

+    FFAMediaFormat *format = NULL;

+

+    format = av_mallocz(sizeof(FFAMediaFormat));

+    if (!format) {

+        return NULL;

+    }

+    format->class = &amediaformat_class;

+

+    env = ff_jni_attach_env(&attached, format);

+    if (!env) {

+        av_freep(&format);

+        return NULL;

+    }

+

+    if (ff_jni_init_jfields(env, &format->jfields, jni_amediaformat_mapping, 1, format) < 0) {

+        goto fail;

+    }

+

+    format->object = (*env)->NewObject(env, format->jfields.clazz, format->jfields.init_id);

+    if (!format->object) {

+        goto fail;

+    }

+

+    format->object = (*env)->NewGlobalRef(env, format->object);

+    if (!format->object) {

+        goto fail;

+    }

+

+    JNI_DETACH_ENV(attached, format);

+

+    return format;

+fail:

+    ff_jni_reset_jfields(env, &format->jfields, jni_amediaformat_mapping, 1, format);

+

+    JNI_DETACH_ENV(attached, format);

+

+    av_freep(&format);

+

+    return NULL;

+}

+

+static FFAMediaFormat *ff_AMediaFormat_newFromObject(void *object)

+{

+    int attached = 0;

+    JNIEnv *env = NULL;

+    FFAMediaFormat *format = NULL;

+

+    format = av_mallocz(sizeof(FFAMediaFormat));

+    if (!format) {

+        return NULL;

+    }

+    format->class = &amediaformat_class;

+

+    env = ff_jni_attach_env(&attached, format);

+    if (!env) {

+        av_freep(&format);

+        return NULL;

+    }

+

+    if (ff_jni_init_jfields(env, &format->jfields, jni_amediaformat_mapping, 1, format) < 0) {

+        goto fail;

+    }

+

+    format->object = (*env)->NewGlobalRef(env, object);

+    if (!format->object) {

+        goto fail;