falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
94377 Commits
32 Branches
687MB
Tree: 3abec7f397
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3abec7f397'
${ noResults }
FFmpeg/libavcodec/mediacodec_wrapper.c

1714 lines
53KB
Raw Blame History 

  1. /*

  2.  * Android MediaCodec Wrapper

  3.  *

  4.  * Copyright (c) 2015-2016 Matthieu Bouron <matthieu.bouron stupeflix.com>

  5.  *

  6.  * This file is part of FFmpeg.

  7.  *

  8.  * FFmpeg is free software; you can redistribute it and/or

  9.  * modify it under the terms of the GNU Lesser General Public

  10.  * License as published by the Free Software Foundation; either

  11.  * version 2.1 of the License, or (at your option) any later version.

  12.  *

  13.  * FFmpeg is distributed in the hope that it will be useful,

  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  16.  * Lesser General Public License for more details.

  17.  *

  18.  * You should have received a copy of the GNU Lesser General Public

  19.  * License along with FFmpeg; if not, write to the Free Software

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

  21.  */

  22. 

  23. #include <jni.h>

  24. 

  25. #include "libavutil/avassert.h"

  26. #include "libavutil/mem.h"

  27. #include "libavutil/avstring.h"

  28. 

  29. #include "avcodec.h"

  30. #include "ffjni.h"

  31. #include "version.h"

  32. #include "mediacodec_wrapper.h"

  33. 

  34. struct JNIAMediaCodecListFields {

  35. 

  36.     jclass mediacodec_list_class;

  37.     jmethodID init_id;

  38.     jmethodID find_decoder_for_format_id;

  39. 

  40.     jmethodID get_codec_count_id;

  41.     jmethodID get_codec_info_at_id;

  42. 

  43.     jclass mediacodec_info_class;

  44.     jmethodID get_name_id;

  45.     jmethodID get_codec_capabilities_id;

  46.     jmethodID get_supported_types_id;

  47.     jmethodID is_encoder_id;

  48. 

  49.     jclass codec_capabilities_class;

  50.     jfieldID color_formats_id;

  51.     jfieldID profile_levels_id;

  52. 

  53.     jclass codec_profile_level_class;

  54.     jfieldID profile_id;

  55.     jfieldID level_id;

  56. 

  57.     jfieldID avc_profile_baseline_id;

  58.     jfieldID avc_profile_main_id;

  59.     jfieldID avc_profile_extended_id;

  60.     jfieldID avc_profile_high_id;

  61.     jfieldID avc_profile_high10_id;

  62.     jfieldID avc_profile_high422_id;

  63.     jfieldID avc_profile_high444_id;

  64. 

  65.     jfieldID hevc_profile_main_id;

  66.     jfieldID hevc_profile_main10_id;

  67.     jfieldID hevc_profile_main10_hdr10_id;

  68. 

  69. };

  70. 

  71. static const struct FFJniField jni_amediacodeclist_mapping[] = {

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

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

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

  75. 

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

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

  78. 

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

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

  81.         { "android/media/MediaCodecInfo", "getCapabilitiesForType", "(Ljava/lang/String;)Landroid/media/MediaCodecInfo$CodecCapabilities;", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecListFields, get_codec_capabilities_id), 1 },

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

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

  84. 

  85.     { "android/media/MediaCodecInfo$CodecCapabilities", NULL, NULL, FF_JNI_CLASS, offsetof(struct JNIAMediaCodecListFields, codec_capabilities_class), 1 },

  86.         { "android/media/MediaCodecInfo$CodecCapabilities", "colorFormats", "[I", FF_JNI_FIELD, offsetof(struct JNIAMediaCodecListFields, color_formats_id), 1 },

  87.         { "android/media/MediaCodecInfo$CodecCapabilities", "profileLevels", "[Landroid/media/MediaCodecInfo$CodecProfileLevel;", FF_JNI_FIELD, offsetof(struct JNIAMediaCodecListFields, profile_levels_id), 1 },

  88. 

  89.     { "android/media/MediaCodecInfo$CodecProfileLevel", NULL, NULL, FF_JNI_CLASS, offsetof(struct JNIAMediaCodecListFields, codec_profile_level_class), 1 },

  90.         { "android/media/MediaCodecInfo$CodecProfileLevel", "profile", "I", FF_JNI_FIELD, offsetof(struct JNIAMediaCodecListFields, profile_id), 1 },

  91.         { "android/media/MediaCodecInfo$CodecProfileLevel", "level", "I", FF_JNI_FIELD, offsetof(struct JNIAMediaCodecListFields, level_id), 1 },

  92. 

  93.         { "android/media/MediaCodecInfo$CodecProfileLevel", "AVCProfileBaseline", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecListFields, avc_profile_baseline_id), 1 },

  94.         { "android/media/MediaCodecInfo$CodecProfileLevel", "AVCProfileMain", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecListFields, avc_profile_main_id), 1 },

  95.         { "android/media/MediaCodecInfo$CodecProfileLevel", "AVCProfileExtended", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecListFields, avc_profile_extended_id), 1 },

  96.         { "android/media/MediaCodecInfo$CodecProfileLevel", "AVCProfileHigh", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecListFields, avc_profile_high_id), 1 },

  97.         { "android/media/MediaCodecInfo$CodecProfileLevel", "AVCProfileHigh10", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecListFields, avc_profile_high10_id), 1 },

  98.         { "android/media/MediaCodecInfo$CodecProfileLevel", "AVCProfileHigh422", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecListFields, avc_profile_high422_id), 1 },

  99.         { "android/media/MediaCodecInfo$CodecProfileLevel", "AVCProfileHigh444", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecListFields, avc_profile_high444_id), 1 },

  100. 

  101.         { "android/media/MediaCodecInfo$CodecProfileLevel", "HEVCProfileMain", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecListFields, hevc_profile_main_id), 0 },

  102.         { "android/media/MediaCodecInfo$CodecProfileLevel", "HEVCProfileMain10", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecListFields, hevc_profile_main10_id), 0 },

  103.         { "android/media/MediaCodecInfo$CodecProfileLevel", "HEVCProfileMain10HDR10", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecListFields, hevc_profile_main10_hdr10_id), 0 },

  104. 

  105.     { NULL }

  106. };

  107. 

  108. struct JNIAMediaFormatFields {

  109. 

  110.     jclass mediaformat_class;

  111. 

  112.     jmethodID init_id;

  113. 

  114.     jmethodID contains_key_id;

  115. 

  116.     jmethodID get_integer_id;

  117.     jmethodID get_long_id;

  118.     jmethodID get_float_id;

  119.     jmethodID get_bytebuffer_id;

  120.     jmethodID get_string_id;

  121. 

  122.     jmethodID set_integer_id;

  123.     jmethodID set_long_id;

  124.     jmethodID set_float_id;

  125.     jmethodID set_bytebuffer_id;

  126.     jmethodID set_string_id;

  127. 

  128.     jmethodID to_string_id;

  129. 

  130. };

  131. 

  132. static const struct FFJniField jni_amediaformat_mapping[] = {

  133.     { "android/media/MediaFormat", NULL, NULL, FF_JNI_CLASS, offsetof(struct JNIAMediaFormatFields, mediaformat_class), 1 },

  134. 

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

  136. 

  137.         { "android/media/MediaFormat", "containsKey", "(Ljava/lang/String;)Z", FF_JNI_METHOD,offsetof(struct JNIAMediaFormatFields, contains_key_id), 1 },

  138. 

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

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

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

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

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

  144. 

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

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

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

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

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

  150. 

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

  152. 

  153.     { NULL }

  154. };

  155. 

  156. static const AVClass amediaformat_class = {

  157.     .class_name = "amediaformat",

  158.     .item_name  = av_default_item_name,

  159.     .version    = LIBAVUTIL_VERSION_INT,

  160. };

  161. 

  162. struct FFAMediaFormat {

  163. 

  164.     const AVClass *class;

  165.     struct JNIAMediaFormatFields jfields;

  166.     jobject object;

  167. };

  168. 

  169. struct JNIAMediaCodecFields {

  170. 

  171.     jclass mediacodec_class;

  172. 

  173.     jfieldID info_try_again_later_id;

  174.     jfieldID info_output_buffers_changed_id;

  175.     jfieldID info_output_format_changed_id;

  176. 

  177.     jfieldID buffer_flag_codec_config_id;

  178.     jfieldID buffer_flag_end_of_stream_id;

  179.     jfieldID buffer_flag_key_frame_id;

  180. 

  181.     jfieldID configure_flag_encode_id;

  182. 

  183.     jmethodID create_by_codec_name_id;

  184.     jmethodID create_decoder_by_type_id;

  185.     jmethodID create_encoder_by_type_id;

  186. 

  187.     jmethodID get_name_id;

  188. 

  189.     jmethodID configure_id;

  190.     jmethodID start_id;

  191.     jmethodID flush_id;

  192.     jmethodID stop_id;

  193.     jmethodID release_id;

  194. 

  195.     jmethodID get_output_format_id;

  196. 

  197.     jmethodID dequeue_input_buffer_id;

  198.     jmethodID queue_input_buffer_id;

  199.     jmethodID get_input_buffer_id;

  200.     jmethodID get_input_buffers_id;

  201. 

  202.     jmethodID dequeue_output_buffer_id;

  203.     jmethodID get_output_buffer_id;

  204.     jmethodID get_output_buffers_id;

  205.     jmethodID release_output_buffer_id;

  206.     jmethodID release_output_buffer_at_time_id;

  207. 

  208.     jclass mediainfo_class;

  209. 

  210.     jmethodID init_id;

  211. 

  212.     jfieldID flags_id;

  213.     jfieldID offset_id;

  214.     jfieldID presentation_time_us_id;

  215.     jfieldID size_id;

  216. 

  217. };

  218. 

  219. static const struct FFJniField jni_amediacodec_mapping[] = {

  220.     { "android/media/MediaCodec", NULL, NULL, FF_JNI_CLASS, offsetof(struct JNIAMediaCodecFields, mediacodec_class), 1 },

  221. 

  222.         { "android/media/MediaCodec", "INFO_TRY_AGAIN_LATER", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecFields, info_try_again_later_id), 1 },

  223.         { "android/media/MediaCodec", "INFO_OUTPUT_BUFFERS_CHANGED", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecFields, info_output_buffers_changed_id), 1 },

  224.         { "android/media/MediaCodec", "INFO_OUTPUT_FORMAT_CHANGED", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecFields, info_output_format_changed_id), 1 },

  225. 

  226.         { "android/media/MediaCodec", "BUFFER_FLAG_CODEC_CONFIG", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecFields, buffer_flag_codec_config_id), 1 },

  227.         { "android/media/MediaCodec", "BUFFER_FLAG_END_OF_STREAM", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecFields, buffer_flag_end_of_stream_id), 1 },

  228.         { "android/media/MediaCodec", "BUFFER_FLAG_KEY_FRAME", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecFields, buffer_flag_key_frame_id), 0 },

  229. 

  230.         { "android/media/MediaCodec", "CONFIGURE_FLAG_ENCODE", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecFields, configure_flag_encode_id), 1 },

  231. 

  232.         { "android/media/MediaCodec", "createByCodecName", "(Ljava/lang/String;)Landroid/media/MediaCodec;", FF_JNI_STATIC_METHOD, offsetof(struct JNIAMediaCodecFields, create_by_codec_name_id), 1 },

  233.         { "android/media/MediaCodec", "createDecoderByType", "(Ljava/lang/String;)Landroid/media/MediaCodec;", FF_JNI_STATIC_METHOD, offsetof(struct JNIAMediaCodecFields, create_decoder_by_type_id), 1 },

  234.         { "android/media/MediaCodec", "createEncoderByType", "(Ljava/lang/String;)Landroid/media/MediaCodec;", FF_JNI_STATIC_METHOD, offsetof(struct JNIAMediaCodecFields, create_encoder_by_type_id), 1 },

  235. 

  236.         { "android/media/MediaCodec", "getName", "()Ljava/lang/String;", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, get_name_id), 1 },

  237. 

  238.         { "android/media/MediaCodec", "configure", "(Landroid/media/MediaFormat;Landroid/view/Surface;Landroid/media/MediaCrypto;I)V", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, configure_id), 1 },

  239.         { "android/media/MediaCodec", "start", "()V", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, start_id), 1 },

  240.         { "android/media/MediaCodec", "flush", "()V", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, flush_id), 1 },

  241.         { "android/media/MediaCodec", "stop", "()V", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, stop_id), 1 },

  242.         { "android/media/MediaCodec", "release", "()V", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, release_id), 1 },

  243. 

  244.         { "android/media/MediaCodec", "getOutputFormat", "()Landroid/media/MediaFormat;", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, get_output_format_id), 1 },

  245. 

  246.         { "android/media/MediaCodec", "dequeueInputBuffer", "(J)I", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, dequeue_input_buffer_id), 1 },

  247.         { "android/media/MediaCodec", "queueInputBuffer", "(IIIJI)V", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, queue_input_buffer_id), 1 },

  248.         { "android/media/MediaCodec", "getInputBuffer", "(I)Ljava/nio/ByteBuffer;", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, get_input_buffer_id), 0 },

  249.         { "android/media/MediaCodec", "getInputBuffers", "()[Ljava/nio/ByteBuffer;", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, get_input_buffers_id), 1 },

  250. 

  251.         { "android/media/MediaCodec", "dequeueOutputBuffer", "(Landroid/media/MediaCodec$BufferInfo;J)I", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, dequeue_output_buffer_id), 1 },

  252.         { "android/media/MediaCodec", "getOutputBuffer", "(I)Ljava/nio/ByteBuffer;", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, get_output_buffer_id), 0 },

  253.         { "android/media/MediaCodec", "getOutputBuffers", "()[Ljava/nio/ByteBuffer;", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, get_output_buffers_id), 1 },

  254.         { "android/media/MediaCodec", "releaseOutputBuffer", "(IZ)V", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, release_output_buffer_id), 1 },

  255.         { "android/media/MediaCodec", "releaseOutputBuffer", "(IJ)V", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, release_output_buffer_at_time_id), 0 },

  256. 

  257.     { "android/media/MediaCodec$BufferInfo", NULL, NULL, FF_JNI_CLASS, offsetof(struct JNIAMediaCodecFields, mediainfo_class), 1 },

  258. 

  259.         { "android/media/MediaCodec.BufferInfo", "<init>", "()V", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, init_id), 1 },

  260.         { "android/media/MediaCodec.BufferInfo", "flags", "I", FF_JNI_FIELD, offsetof(struct JNIAMediaCodecFields, flags_id), 1 },

  261.         { "android/media/MediaCodec.BufferInfo", "offset", "I", FF_JNI_FIELD, offsetof(struct JNIAMediaCodecFields, offset_id), 1 },

  262.         { "android/media/MediaCodec.BufferInfo", "presentationTimeUs", "J", FF_JNI_FIELD, offsetof(struct JNIAMediaCodecFields, presentation_time_us_id), 1 },

  263.         { "android/media/MediaCodec.BufferInfo", "size", "I", FF_JNI_FIELD, offsetof(struct JNIAMediaCodecFields, size_id), 1 },

  264. 

  265.     { NULL }

  266. };

  267. 

  268. static const AVClass amediacodec_class = {

  269.     .class_name = "amediacodec",

  270.     .item_name  = av_default_item_name,

  271.     .version    = LIBAVUTIL_VERSION_INT,

  272. };

  273. 

  274. struct FFAMediaCodec {

  275. 

  276.     const AVClass *class;

  277. 

  278.     struct JNIAMediaCodecFields jfields;

  279. 

  280.     jobject object;

  281.     jobject buffer_info;

  282. 

  283.     jobject input_buffers;

  284.     jobject output_buffers;

  285. 

  286.     int INFO_TRY_AGAIN_LATER;

  287.     int INFO_OUTPUT_BUFFERS_CHANGED;

  288.     int INFO_OUTPUT_FORMAT_CHANGED;

  289. 

  290.     int BUFFER_FLAG_CODEC_CONFIG;

  291.     int BUFFER_FLAG_END_OF_STREAM;

  292.     int BUFFER_FLAG_KEY_FRAME;

  293. 

  294.     int CONFIGURE_FLAG_ENCODE;

  295. 

  296.     int has_get_i_o_buffer;

  297. };

  298. 

  299. #define JNI_GET_ENV_OR_RETURN(env, log_ctx, ret) do {              \

  300.     (env) = ff_jni_get_env(log_ctx);                               \

  301.     if (!(env)) {                                                  \

  302.         return ret;                                                \

  303.     }                                                              \

  304. } while (0)

  305. 

  306. #define JNI_GET_ENV_OR_RETURN_VOID(env, log_ctx) do {              \

  307.     (env) = ff_jni_get_env(log_ctx);                               \

  308.     if (!(env)) {                                                  \

  309.         return;                                                    \

  310.     }                                                              \

  311. } while (0)

  312. 

  313. int ff_AMediaCodecProfile_getProfileFromAVCodecContext(AVCodecContext *avctx)

  314. {

  315.     int ret = -1;

  316. 

  317.     JNIEnv *env = NULL;

  318.     struct JNIAMediaCodecListFields jfields = { 0 };

  319.     jfieldID field_id = 0;

  320. 

  321.     JNI_GET_ENV_OR_RETURN(env, avctx, -1);

  322. 

  323.     if (ff_jni_init_jfields(env, &jfields, jni_amediacodeclist_mapping, 0, avctx) < 0) {

  324.         goto done;

  325.     }

  326. 

  327.     if (avctx->codec_id == AV_CODEC_ID_H264) {

  328.         switch(avctx->profile) {

  329.         case FF_PROFILE_H264_BASELINE:

  330.         case FF_PROFILE_H264_CONSTRAINED_BASELINE:

  331.             field_id = jfields.avc_profile_baseline_id;

  332.             break;

  333.         case FF_PROFILE_H264_MAIN:

  334.             field_id = jfields.avc_profile_main_id;

  335.             break;

  336.         case FF_PROFILE_H264_EXTENDED:

  337.             field_id = jfields.avc_profile_extended_id;

  338.             break;

  339.         case FF_PROFILE_H264_HIGH:

  340.             field_id = jfields.avc_profile_high_id;

  341.             break;

  342.         case FF_PROFILE_H264_HIGH_10:

  343.         case FF_PROFILE_H264_HIGH_10_INTRA:

  344.             field_id = jfields.avc_profile_high10_id;

  345.             break;

  346.         case FF_PROFILE_H264_HIGH_422:

  347.         case FF_PROFILE_H264_HIGH_422_INTRA:

  348.             field_id = jfields.avc_profile_high422_id;

  349.             break;

  350.         case FF_PROFILE_H264_HIGH_444:

  351.         case FF_PROFILE_H264_HIGH_444_INTRA:

  352.         case FF_PROFILE_H264_HIGH_444_PREDICTIVE:

  353.             field_id = jfields.avc_profile_high444_id;

  354.             break;

  355.         }

  356.     } else if (avctx->codec_id == AV_CODEC_ID_HEVC) {

  357.         switch (avctx->profile) {

  358.         case FF_PROFILE_HEVC_MAIN:

  359.         case FF_PROFILE_HEVC_MAIN_STILL_PICTURE:

  360.             field_id = jfields.hevc_profile_main_id;

  361.             break;

  362.         case FF_PROFILE_HEVC_MAIN_10:

  363.             field_id = jfields.hevc_profile_main10_id;

  364.             break;

  365.         }

  366.     }

  367. 

  368.         if (field_id) {

  369.             ret = (*env)->GetStaticIntField(env, jfields.codec_profile_level_class, field_id);

  370.             if (ff_jni_exception_check(env, 1, avctx) < 0) {

  371.                 ret = -1;

  372.                 goto done;

  373.             }

  374.         }

  375. 

  376. done:

  377.     ff_jni_reset_jfields(env, &jfields, jni_amediacodeclist_mapping, 0, avctx);

  378. 

  379.     return ret;

  380. }

  381. 

  382. char *ff_AMediaCodecList_getCodecNameByType(const char *mime, int profile, int encoder, void *log_ctx)

  383. {

  384.     int ret;

  385.     int i;

  386.     int codec_count;

  387.     int found_codec = 0;

  388.     char *name = NULL;

  389.     char *supported_type = NULL;

  390. 

  391.     JNIEnv *env = NULL;

  392.     struct JNIAMediaCodecListFields jfields = { 0 };

  393.     struct JNIAMediaFormatFields mediaformat_jfields = { 0 };

  394. 

  395.     jobject format = NULL;

  396.     jobject codec = NULL;

  397.     jobject codec_name = NULL;

  398. 

  399.     jobject info = NULL;

  400.     jobject type = NULL;

  401.     jobjectArray types = NULL;

  402. 

  403.     jobject capabilities = NULL;

  404.     jobject profile_level = NULL;

  405.     jobjectArray profile_levels = NULL;

  406. 

  407.     JNI_GET_ENV_OR_RETURN(env, log_ctx, NULL);

  408. 

  409.     if ((ret = ff_jni_init_jfields(env, &jfields, jni_amediacodeclist_mapping, 0, log_ctx)) < 0) {

  410.         goto done;

  411.     }

  412. 

  413.     if ((ret = ff_jni_init_jfields(env, &mediaformat_jfields, jni_amediaformat_mapping, 0, log_ctx)) < 0) {

  414.         goto done;

  415.     }

  416. 

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

  418.     if (ff_jni_exception_check(env, 1, log_ctx) < 0) {

  419.         goto done;

  420.     }

  421. 

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

  423.         int j;

  424.         int type_count;

  425.         int is_encoder;

  426. 

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

  428.         if (ff_jni_exception_check(env, 1, log_ctx) < 0) {

  429.             goto done;

  430.         }

  431. 

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

  433.         if (ff_jni_exception_check(env, 1, log_ctx) < 0) {

  434.             goto done;

  435.         }

  436. 

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

  438.         if (ff_jni_exception_check(env, 1, log_ctx) < 0) {

  439.             goto done;

  440.         }

  441. 

  442.         if (is_encoder != encoder) {

  443.             goto done_with_info;

  444.         }

  445. 

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

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

  448.             int k;

  449.             int profile_count;

  450. 

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

  452.             if (ff_jni_exception_check(env, 1, log_ctx) < 0) {

  453.                 goto done;

  454.             }

  455. 

  456.             supported_type = ff_jni_jstring_to_utf_chars(env, type, log_ctx);

  457.             if (!supported_type) {

  458.                 goto done;

  459.             }

  460. 

  461.             if (!av_strcasecmp(supported_type, mime)) {

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

  463.                 if (ff_jni_exception_check(env, 1, log_ctx) < 0) {

  464.                     goto done;

  465.                 }

  466. 

  467.                 name = ff_jni_jstring_to_utf_chars(env, codec_name, log_ctx);

  468.                 if (!name) {

  469.                     goto done;

  470.                 }

  471. 

  472.                 if (codec_name) {

  473.                     (*env)->DeleteLocalRef(env, codec_name);

  474.                     codec_name = NULL;

  475.                 }

  476. 

  477.                 /* Skip software decoders */

  478.                 if (

  479.                     strstr(name, "OMX.google") ||

  480.                     strstr(name, "OMX.ffmpeg") ||

  481.                     (strstr(name, "OMX.SEC") && strstr(name, ".sw.")) ||

  482.                     !strcmp(name, "OMX.qcom.video.decoder.hevcswvdec")) {

  483.                     av_freep(&name);

  484.                     goto done_with_type;

  485.                 }

  486. 

  487.                 capabilities = (*env)->CallObjectMethod(env, info, jfields.get_codec_capabilities_id, type);

  488.                 if (ff_jni_exception_check(env, 1, log_ctx) < 0) {

  489.                     goto done;

  490.                 }

  491. 

  492.                 profile_levels = (*env)->GetObjectField(env, capabilities, jfields.profile_levels_id);

  493.                 if (ff_jni_exception_check(env, 1, log_ctx) < 0) {

  494.                     goto done;

  495.                 }

  496. 

  497.                 profile_count = (*env)->GetArrayLength(env, profile_levels);

  498.                 if (!profile_count) {

  499.                     found_codec = 1;

  500.                 }

  501.                 for (k = 0; k < profile_count; k++) {

  502.                     int supported_profile = 0;

  503. 

  504.                     if (profile < 0) {

  505.                         found_codec = 1;

  506.                         break;

  507.                     }

  508. 

  509.                     profile_level = (*env)->GetObjectArrayElement(env, profile_levels, k);

  510.                     if (ff_jni_exception_check(env, 1, log_ctx) < 0) {

  511.                         goto done;

  512.                     }

  513. 

  514.                     supported_profile = (*env)->GetIntField(env, profile_level, jfields.profile_id);

  515.                     if (ff_jni_exception_check(env, 1, log_ctx) < 0) {

  516.                         goto done;

  517.                     }

  518. 

  519.                     found_codec = profile == supported_profile;

  520. 

  521.                     if (profile_level) {

  522.                         (*env)->DeleteLocalRef(env, profile_level);

  523.                         profile_level = NULL;

  524.                     }

  525. 

  526.                     if (found_codec) {

  527.                         break;

  528.                     }

  529.                 }

  530.             }

  531. 

  532. done_with_type:

  533.             if (profile_levels) {

  534.                 (*env)->DeleteLocalRef(env, profile_levels);

  535.                 profile_levels = NULL;

  536.             }

  537. 

  538.             if (capabilities) {

  539.                 (*env)->DeleteLocalRef(env, capabilities);

  540.                 capabilities = NULL;

  541.             }

  542. 

  543.             if (type) {

  544.                 (*env)->DeleteLocalRef(env, type);

  545.                 type = NULL;

  546.             }

  547. 

  548.             av_freep(&supported_type);

  549. 

  550.             if (found_codec) {

  551.                 break;

  552.             }

  553. 

  554.             av_freep(&name);

  555.         }

  556. 

  557. done_with_info:

  558.         if (info) {

  559.             (*env)->DeleteLocalRef(env, info);

  560.             info = NULL;

  561.         }

  562. 

  563.         if (types) {

  564.             (*env)->DeleteLocalRef(env, types);

  565.             types = NULL;

  566.         }

  567. 

  568.         if (found_codec) {

  569.             break;

  570.         }

  571.     }

  572. 

  573. done:

  574.     if (format) {

  575.         (*env)->DeleteLocalRef(env, format);

  576.     }

  577. 

  578.     if (codec) {

  579.         (*env)->DeleteLocalRef(env, codec);

  580.     }

  581. 

  582.     if (codec_name) {

  583.         (*env)->DeleteLocalRef(env, codec_name);

  584.     }

  585. 

  586.     if (info) {

  587.         (*env)->DeleteLocalRef(env, info);

  588.     }

  589. 

  590.     if (type) {

  591.         (*env)->DeleteLocalRef(env, type);

  592.     }

  593. 

  594.     if (types) {

  595.         (*env)->DeleteLocalRef(env, types);

  596.     }

  597. 

  598.     if (capabilities) {

  599.         (*env)->DeleteLocalRef(env, capabilities);

  600.     }

  601. 

  602.     if (profile_level) {

  603.         (*env)->DeleteLocalRef(env, profile_level);

  604.     }

  605. 

  606.     if (profile_levels) {

  607.         (*env)->DeleteLocalRef(env, profile_levels);

  608.     }

  609. 

  610.     av_freep(&supported_type);

  611. 

  612.     ff_jni_reset_jfields(env, &jfields, jni_amediacodeclist_mapping, 0, log_ctx);

  613.     ff_jni_reset_jfields(env, &mediaformat_jfields, jni_amediaformat_mapping, 0, log_ctx);

  614. 

  615.     if (!found_codec) {

  616.         av_freep(&name);

  617.     }

  618. 

  619.     return name;

  620. }

  621. 

  622. FFAMediaFormat *ff_AMediaFormat_new(void)

  623. {

  624.     JNIEnv *env = NULL;

  625.     FFAMediaFormat *format = NULL;

  626.     jobject object = NULL;

  627. 

  628.     format = av_mallocz(sizeof(FFAMediaFormat));

  629.     if (!format) {

  630.         return NULL;

  631.     }

  632.     format->class = &amediaformat_class;

  633. 

  634.     env = ff_jni_get_env(format);

  635.     if (!env) {

  636.         av_freep(&format);

  637.         return NULL;

  638.     }

  639. 

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

  641.         goto fail;

  642.     }

  643. 

  644.     object = (*env)->NewObject(env, format->jfields.mediaformat_class, format->jfields.init_id);

  645.     if (!object) {

  646.         goto fail;

  647.     }

  648. 

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

  650.     if (!format->object) {

  651.         goto fail;

  652.     }

  653. 

  654. fail:

  655.     if (object) {

  656.         (*env)->DeleteLocalRef(env, object);

  657.     }

  658. 

  659.     if (!format->object) {

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

  661.         av_freep(&format);

  662.     }

  663. 

  664.     return format;

  665. }

  666. 

  667. static FFAMediaFormat *ff_AMediaFormat_newFromObject(void *object)

  668. {

  669.     JNIEnv *env = NULL;

  670.     FFAMediaFormat *format = NULL;

  671. 

  672.     format = av_mallocz(sizeof(FFAMediaFormat));

  673.     if (!format) {

  674.         return NULL;

  675.     }

  676.     format->class = &amediaformat_class;

  677. 

  678.     env = ff_jni_get_env(format);

  679.     if (!env) {

  680.         av_freep(&format);

  681.         return NULL;

  682.     }

  683. 

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

  685.         goto fail;

  686.     }

  687. 

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

  689.     if (!format->object) {

  690.         goto fail;

  691.     }

  692. 

  693.     return format;

  694. fail:

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

  696. 

  697.     av_freep(&format);

  698. 

  699.     return NULL;

  700. }

  701. 

  702. int ff_AMediaFormat_delete(FFAMediaFormat* format)

  703. {

  704.     int ret = 0;

  705. 

  706.     JNIEnv *env = NULL;

  707. 

  708.     if (!format) {

  709.         return 0;

  710.     }

  711. 

  712.     JNI_GET_ENV_OR_RETURN(env, format, AVERROR_EXTERNAL);

  713. 

  714.     (*env)->DeleteGlobalRef(env, format->object);

  715.     format->object = NULL;

  716. 

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

  718. 

  719.     av_freep(&format);

  720. 

  721.     return ret;

  722. }

  723. 

  724. char* ff_AMediaFormat_toString(FFAMediaFormat* format)

  725. {

  726.     char *ret = NULL;

  727. 

  728.     JNIEnv *env = NULL;

  729.     jstring description = NULL;

  730. 

  731.     av_assert0(format != NULL);

  732. 

  733.     JNI_GET_ENV_OR_RETURN(env, format, NULL);

  734. 

  735.     description = (*env)->CallObjectMethod(env, format->object, format->jfields.to_string_id);

  736.     if (ff_jni_exception_check(env, 1, NULL) < 0) {

  737.         goto fail;

  738.     }

  739. 

  740.     ret = ff_jni_jstring_to_utf_chars(env, description, format);

  741. fail:

  742.     if (description) {

  743.         (*env)->DeleteLocalRef(env, description);

  744.     }

  745. 

  746.     return ret;

  747. }

  748. 

  749. int ff_AMediaFormat_getInt32(FFAMediaFormat* format, const char *name, int32_t *out)

  750. {

  751.     int ret = 1;

  752. 

  753.     JNIEnv *env = NULL;

  754.     jstring key = NULL;

  755.     jboolean contains_key;

  756. 

  757.     av_assert0(format != NULL);

  758. 

  759.     JNI_GET_ENV_OR_RETURN(env, format, 0);

  760. 

  761.     key = ff_jni_utf_chars_to_jstring(env, name, format);

  762.     if (!key) {

  763.         ret = 0;

  764.         goto fail;

  765.     }

  766. 

  767.     contains_key = (*env)->CallBooleanMethod(env, format->object, format->jfields.contains_key_id, key);

  768.     if (!contains_key || (ret = ff_jni_exception_check(env, 1, format)) < 0) {

  769.         ret = 0;

  770.         goto fail;

  771.     }

  772. 

  773.     *out = (*env)->CallIntMethod(env, format->object, format->jfields.get_integer_id, key);

  774.     if ((ret = ff_jni_exception_check(env, 1, format)) < 0) {

  775.         ret = 0;

  776.         goto fail;

  777.     }

  778. 

  779.     ret = 1;

  780. fail:

  781.     if (key) {

  782.         (*env)->DeleteLocalRef(env, key);

  783.     }

  784. 

  785.     return ret;

  786. }

  787. 

  788. int ff_AMediaFormat_getInt64(FFAMediaFormat* format, const char *name, int64_t *out)

  789. {

  790.     int ret = 1;

  791. 

  792.     JNIEnv *env = NULL;

  793.     jstring key = NULL;

  794.     jboolean contains_key;

  795. 

  796.     av_assert0(format != NULL);

  797. 

  798.     JNI_GET_ENV_OR_RETURN(env, format, 0);

  799. 

  800.     key = ff_jni_utf_chars_to_jstring(env, name, format);

  801.     if (!key) {

  802.         ret = 0;

  803.         goto fail;

  804.     }

  805. 

  806.     contains_key = (*env)->CallBooleanMethod(env, format->object, format->jfields.contains_key_id, key);

  807.     if (!contains_key || (ret = ff_jni_exception_check(env, 1, format)) < 0) {

  808.         ret = 0;

  809.         goto fail;

  810.     }

  811. 

  812.     *out = (*env)->CallLongMethod(env, format->object, format->jfields.get_long_id, key);

  813.     if ((ret = ff_jni_exception_check(env, 1, format)) < 0) {

  814.         ret = 0;

  815.         goto fail;

  816.     }

  817. 

  818.     ret = 1;

  819. fail:

  820.     if (key) {

  821.         (*env)->DeleteLocalRef(env, key);

  822.     }

  823. 

  824.     return ret;

  825. }

  826. 

  827. int ff_AMediaFormat_getFloat(FFAMediaFormat* format, const char *name, float *out)

  828. {

  829.     int ret = 1;

  830. 

  831.     JNIEnv *env = NULL;

  832.     jstring key = NULL;

  833.     jboolean contains_key;

  834. 

  835.     av_assert0(format != NULL);

  836. 

  837.     JNI_GET_ENV_OR_RETURN(env, format, 0);

  838. 

  839.     key = ff_jni_utf_chars_to_jstring(env, name, format);

  840.     if (!key) {

  841.         ret = 0;

  842.         goto fail;

  843.     }

  844. 

  845.     contains_key = (*env)->CallBooleanMethod(env, format->object, format->jfields.contains_key_id, key);

  846.     if (!contains_key || (ret = ff_jni_exception_check(env, 1, format)) < 0) {

  847.         ret = 0;

  848.         goto fail;

  849.     }

  850. 

  851.     *out = (*env)->CallFloatMethod(env, format->object, format->jfields.get_float_id, key);

  852.     if ((ret = ff_jni_exception_check(env, 1, format)) < 0) {

  853.         ret = 0;

  854.         goto fail;

  855.     }

  856. 

  857.     ret = 1;

  858. fail:

  859.     if (key) {

  860.         (*env)->DeleteLocalRef(env, key);

  861.     }

  862. 

  863.     return ret;

  864. }

  865. 

  866. int ff_AMediaFormat_getBuffer(FFAMediaFormat* format, const char *name, void** data, size_t *size)

  867. {

  868.     int ret = 1;

  869. 

  870.     JNIEnv *env = NULL;

  871.     jstring key = NULL;

  872.     jboolean contains_key;

  873.     jobject result = NULL;

  874. 

  875.     av_assert0(format != NULL);

  876. 

  877.     JNI_GET_ENV_OR_RETURN(env, format, 0);

  878. 

  879.     key = ff_jni_utf_chars_to_jstring(env, name, format);

  880.     if (!key) {

  881.         ret = 0;

  882.         goto fail;

  883.     }

  884. 

  885.     contains_key = (*env)->CallBooleanMethod(env, format->object, format->jfields.contains_key_id, key);

  886.     if (!contains_key || (ret = ff_jni_exception_check(env, 1, format)) < 0) {

  887.         ret = 0;

  888.         goto fail;

  889.     }

  890. 

  891.     result = (*env)->CallObjectMethod(env, format->object, format->jfields.get_bytebuffer_id, key);

  892.     if ((ret = ff_jni_exception_check(env, 1, format)) < 0) {

  893.         ret = 0;

  894.         goto fail;

  895.     }

  896. 

  897.     *data = (*env)->GetDirectBufferAddress(env, result);

  898.     *size = (*env)->GetDirectBufferCapacity(env, result);

  899. 

  900.     if (*data && *size) {

  901.         void *src = *data;

  902.         *data = av_malloc(*size);

  903.         if (!*data) {

  904.             ret = 0;

  905.             goto fail;

  906.         }

  907. 

  908.         memcpy(*data, src, *size);

  909.     }

  910. 

  911.     ret = 1;

  912. fail:

  913.     if (key) {

  914.         (*env)->DeleteLocalRef(env, key);

  915.     }

  916. 

  917.     if (result) {

  918.         (*env)->DeleteLocalRef(env, result);

  919.     }

  920. 

  921.     return ret;

  922. }

  923. 

  924. int ff_AMediaFormat_getString(FFAMediaFormat* format, const char *name, const char **out)

  925. {

  926.     int ret = 1;

  927. 

  928.     JNIEnv *env = NULL;

  929.     jstring key = NULL;

  930.     jboolean contains_key;

  931.     jstring result = NULL;

  932. 

  933.     av_assert0(format != NULL);

  934. 

  935.     JNI_GET_ENV_OR_RETURN(env, format, 0);

  936. 

  937.     key = ff_jni_utf_chars_to_jstring(env, name, format);

  938.     if (!key) {

  939.         ret = 0;

  940.         goto fail;

  941.     }

  942. 

  943.     contains_key = (*env)->CallBooleanMethod(env, format->object, format->jfields.contains_key_id, key);

  944.     if (!contains_key || (ret = ff_jni_exception_check(env, 1, format)) < 0) {

  945.         ret = 0;

  946.         goto fail;

  947.     }

  948. 

  949.     result = (*env)->CallObjectMethod(env, format->object, format->jfields.get_string_id, key);

  950.     if ((ret = ff_jni_exception_check(env, 1, format)) < 0) {

  951.         ret = 0;

  952.         goto fail;

  953.     }

  954. 

  955.     *out = ff_jni_jstring_to_utf_chars(env, result, format);

  956.     if (!*out) {

  957.         ret = 0;

  958.         goto fail;

  959.     }

  960. 

  961.     ret = 1;

  962. fail:

  963.     if (key) {

  964.         (*env)->DeleteLocalRef(env, key);

  965.     }

  966. 

  967.     if (result) {

  968.         (*env)->DeleteLocalRef(env, result);

  969.     }

  970. 

  971.     return ret;

  972. }

  973. 

  974. void ff_AMediaFormat_setInt32(FFAMediaFormat* format, const char* name, int32_t value)

  975. {

  976.     JNIEnv *env = NULL;

  977.     jstring key = NULL;

  978. 

  979.     av_assert0(format != NULL);

  980. 

  981.     JNI_GET_ENV_OR_RETURN_VOID(env, format);

  982. 

  983.     key = ff_jni_utf_chars_to_jstring(env, name, format);

  984.     if (!key) {

  985.         goto fail;

  986.     }

  987. 

  988.     (*env)->CallVoidMethod(env, format->object, format->jfields.set_integer_id, key, value);

  989.     if (ff_jni_exception_check(env, 1, format) < 0) {

  990.         goto fail;

  991.     }

  992. 

  993. fail:

  994.     if (key) {

  995.         (*env)->DeleteLocalRef(env, key);

  996.     }

  997. }

  998. 

  999. void ff_AMediaFormat_setInt64(FFAMediaFormat* format, const char* name, int64_t value)

  1000. {

  1001.     JNIEnv *env = NULL;

  1002.     jstring key = NULL;

  1003. 

  1004.     av_assert0(format != NULL);

  1005. 

  1006.     JNI_GET_ENV_OR_RETURN_VOID(env, format);

  1007. 

  1008.     key = ff_jni_utf_chars_to_jstring(env, name, format);

  1009.     if (!key) {

  1010.         goto fail;

  1011.     }

  1012. 

  1013.     (*env)->CallVoidMethod(env, format->object, format->jfields.set_long_id, key, value);

  1014.     if (ff_jni_exception_check(env, 1, format) < 0) {

  1015.         goto fail;

  1016.     }

  1017. 

  1018. fail:

  1019.     if (key) {

  1020.         (*env)->DeleteLocalRef(env, key);

  1021.     }

  1022. }

  1023. 

  1024. void ff_AMediaFormat_setFloat(FFAMediaFormat* format, const char* name, float value)

  1025. {

  1026.     JNIEnv *env = NULL;

  1027.     jstring key = NULL;

  1028. 

  1029.     av_assert0(format != NULL);

  1030. 

  1031.     JNI_GET_ENV_OR_RETURN_VOID(env, format);

  1032. 

  1033.     key = ff_jni_utf_chars_to_jstring(env, name, format);

  1034.     if (!key) {

  1035.         goto fail;

  1036.     }

  1037. 

  1038.     (*env)->CallVoidMethod(env, format->object, format->jfields.set_float_id, key, value);

  1039.     if (ff_jni_exception_check(env, 1, format) < 0) {

  1040.         goto fail;

  1041.     }

  1042. 

  1043. fail:

  1044.     if (key) {

  1045.         (*env)->DeleteLocalRef(env, key);

  1046.     }

  1047. }

  1048. 

  1049. void ff_AMediaFormat_setString(FFAMediaFormat* format, const char* name, const char* value)

  1050. {

  1051.     JNIEnv *env = NULL;

  1052.     jstring key = NULL;

  1053.     jstring string = NULL;

  1054. 

  1055.     av_assert0(format != NULL);

  1056. 

  1057.     JNI_GET_ENV_OR_RETURN_VOID(env, format);

  1058. 

  1059.     key = ff_jni_utf_chars_to_jstring(env, name, format);

  1060.     if (!key) {

  1061.         goto fail;

  1062.     }

  1063. 

  1064.     string = ff_jni_utf_chars_to_jstring(env, value, format);

  1065.     if (!string) {

  1066.         goto fail;

  1067.     }

  1068. 

  1069.     (*env)->CallVoidMethod(env, format->object, format->jfields.set_string_id, key, string);

  1070.     if (ff_jni_exception_check(env, 1, format) < 0) {

  1071.         goto fail;

  1072.     }

  1073. 

  1074. fail:

  1075.     if (key) {

  1076.         (*env)->DeleteLocalRef(env, key);

  1077.     }

  1078. 

  1079.     if (string) {

  1080.         (*env)->DeleteLocalRef(env, string);

  1081.     }

  1082. }

  1083. 

  1084. void ff_AMediaFormat_setBuffer(FFAMediaFormat* format, const char* name, void* data, size_t size)

  1085. {

  1086.     JNIEnv *env = NULL;

  1087.     jstring key = NULL;

  1088.     jobject buffer = NULL;

  1089.     void *buffer_data = NULL;

  1090. 

  1091.     av_assert0(format != NULL);

  1092. 

  1093.     JNI_GET_ENV_OR_RETURN_VOID(env, format);

  1094. 

  1095.     key = ff_jni_utf_chars_to_jstring(env, name, format);

  1096.     if (!key) {

  1097.         goto fail;

  1098.     }

  1099. 

  1100.     if (!data || !size) {

  1101.         goto fail;

  1102.     }

  1103. 

  1104.     buffer_data = av_malloc(size);

  1105.     if (!buffer_data) {

  1106.         goto fail;

  1107.     }

  1108. 

  1109.     memcpy(buffer_data, data, size);

  1110. 

  1111.     buffer = (*env)->NewDirectByteBuffer(env, buffer_data, size);

  1112.     if (!buffer) {

  1113.         goto fail;

  1114.     }

  1115. 

  1116.     (*env)->CallVoidMethod(env, format->object, format->jfields.set_bytebuffer_id, key, buffer);

  1117.     if (ff_jni_exception_check(env, 1, format) < 0) {

  1118.         goto fail;

  1119.     }

  1120. 

  1121. fail:

  1122.     if (key) {

  1123.         (*env)->DeleteLocalRef(env, key);

  1124.     }

  1125. 

  1126.     if (buffer) {

  1127.         (*env)->DeleteLocalRef(env, buffer);

  1128.     }

  1129. }

  1130. 

  1131. static int codec_init_static_fields(FFAMediaCodec *codec)

  1132. {

  1133.     int ret = 0;

  1134.     JNIEnv *env = NULL;

  1135. 

  1136.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1137. 

  1138.     codec->INFO_TRY_AGAIN_LATER = (*env)->GetStaticIntField(env, codec->jfields.mediacodec_class, codec->jfields.info_try_again_later_id);

  1139.     if ((ret = ff_jni_exception_check(env, 1, codec)) < 0) {

  1140.         goto fail;

  1141.     }

  1142. 

  1143.     codec->BUFFER_FLAG_CODEC_CONFIG = (*env)->GetStaticIntField(env, codec->jfields.mediacodec_class, codec->jfields.buffer_flag_codec_config_id);

  1144.     if ((ret = ff_jni_exception_check(env, 1, codec)) < 0) {

  1145.         goto fail;

  1146.     }

  1147. 

  1148.     codec->BUFFER_FLAG_END_OF_STREAM = (*env)->GetStaticIntField(env, codec->jfields.mediacodec_class, codec->jfields.buffer_flag_end_of_stream_id);

  1149.     if ((ret = ff_jni_exception_check(env, 1, codec)) < 0) {

  1150.         goto fail;

  1151.     }

  1152. 

  1153.     if (codec->jfields.buffer_flag_key_frame_id) {

  1154.         codec->BUFFER_FLAG_KEY_FRAME = (*env)->GetStaticIntField(env, codec->jfields.mediacodec_class, codec->jfields.buffer_flag_key_frame_id);

  1155.         if ((ret = ff_jni_exception_check(env, 1, codec)) < 0) {

  1156.             goto fail;

  1157.         }

  1158.     }

  1159. 

  1160.     codec->CONFIGURE_FLAG_ENCODE = (*env)->GetStaticIntField(env, codec->jfields.mediacodec_class, codec->jfields.configure_flag_encode_id);

  1161.     if ((ret = ff_jni_exception_check(env, 1, codec)) < 0) {

  1162.         goto fail;

  1163.     }

  1164. 

  1165.     codec->INFO_TRY_AGAIN_LATER = (*env)->GetStaticIntField(env, codec->jfields.mediacodec_class, codec->jfields.info_try_again_later_id);

  1166.     if ((ret = ff_jni_exception_check(env, 1, codec)) < 0) {

  1167.         goto fail;

  1168.     }

  1169. 

  1170.     codec->INFO_OUTPUT_BUFFERS_CHANGED = (*env)->GetStaticIntField(env, codec->jfields.mediacodec_class, codec->jfields.info_output_buffers_changed_id);

  1171.     if ((ret = ff_jni_exception_check(env, 1, codec)) < 0) {

  1172.         goto fail;

  1173.     }

  1174. 

  1175.     codec->INFO_OUTPUT_FORMAT_CHANGED = (*env)->GetStaticIntField(env, codec->jfields.mediacodec_class, codec->jfields.info_output_format_changed_id);

  1176.     if ((ret = ff_jni_exception_check(env, 1, codec)) < 0) {

  1177.         goto fail;

  1178.     }

  1179. 

  1180. fail:

  1181. 

  1182.     return ret;

  1183. }

  1184. 

  1185. #define CREATE_CODEC_BY_NAME   0

  1186. #define CREATE_DECODER_BY_TYPE 1

  1187. #define CREATE_ENCODER_BY_TYPE 2

  1188. 

  1189. static inline FFAMediaCodec *codec_create(int method, const char *arg)

  1190. {

  1191.     int ret = -1;

  1192.     JNIEnv *env = NULL;

  1193.     FFAMediaCodec *codec = NULL;

  1194.     jstring jarg = NULL;

  1195.     jobject object = NULL;

  1196.     jobject buffer_info = NULL;

  1197.     jmethodID create_id = NULL;

  1198. 

  1199.     codec = av_mallocz(sizeof(FFAMediaCodec));

  1200.     if (!codec) {

  1201.         return NULL;

  1202.     }

  1203.     codec->class = &amediacodec_class;

  1204. 

  1205.     env = ff_jni_get_env(codec);

  1206.     if (!env) {

  1207.         av_freep(&codec);

  1208.         return NULL;

  1209.     }

  1210. 

  1211.     if (ff_jni_init_jfields(env, &codec->jfields, jni_amediacodec_mapping, 1, codec) < 0) {

  1212.         goto fail;

  1213.     }

  1214. 

  1215.     jarg = ff_jni_utf_chars_to_jstring(env, arg, codec);

  1216.     if (!jarg) {

  1217.         goto fail;

  1218.     }

  1219. 

  1220.     switch (method) {

  1221.     case CREATE_CODEC_BY_NAME:   create_id = codec->jfields.create_by_codec_name_id;   break;

  1222.     case CREATE_DECODER_BY_TYPE: create_id = codec->jfields.create_decoder_by_type_id; break;

  1223.     case CREATE_ENCODER_BY_TYPE: create_id = codec->jfields.create_encoder_by_type_id; break;

  1224.     default:

  1225.         av_assert0(0);

  1226.     }

  1227. 

  1228.     object = (*env)->CallStaticObjectMethod(env,

  1229.                                             codec->jfields.mediacodec_class,

  1230.                                             create_id,

  1231.                                             jarg);

  1232.     if (ff_jni_exception_check(env, 1, codec) < 0) {

  1233.         goto fail;

  1234.     }

  1235. 

  1236.     codec->object = (*env)->NewGlobalRef(env, object);

  1237.     if (!codec->object) {

  1238.         goto fail;

  1239.     }

  1240. 

  1241.     if (codec_init_static_fields(codec) < 0) {

  1242.         goto fail;

  1243.     }

  1244. 

  1245.     if (codec->jfields.get_input_buffer_id && codec->jfields.get_output_buffer_id) {

  1246.         codec->has_get_i_o_buffer = 1;

  1247.     }

  1248. 

  1249.     buffer_info = (*env)->NewObject(env, codec->jfields.mediainfo_class, codec->jfields.init_id);

  1250.     if (ff_jni_exception_check(env, 1, codec) < 0) {

  1251.         goto fail;

  1252.     }

  1253. 

  1254.     codec->buffer_info = (*env)->NewGlobalRef(env, buffer_info);

  1255.     if (!codec->buffer_info) {

  1256.         goto fail;

  1257.     }

  1258. 

  1259.     ret = 0;

  1260. fail:

  1261.     if (jarg) {

  1262.         (*env)->DeleteLocalRef(env, jarg);

  1263.     }

  1264. 

  1265.     if (object) {

  1266.         (*env)->DeleteLocalRef(env, object);

  1267.     }

  1268. 

  1269.     if (buffer_info) {

  1270.         (*env)->DeleteLocalRef(env, buffer_info);

  1271.     }

  1272. 

  1273.     if (ret < 0) {

  1274.         if (codec->object) {

  1275.             (*env)->DeleteGlobalRef(env, codec->object);

  1276.         }

  1277. 

  1278.         if (codec->buffer_info) {

  1279.             (*env)->DeleteGlobalRef(env, codec->buffer_info);

  1280.         }

  1281. 

  1282.         ff_jni_reset_jfields(env, &codec->jfields, jni_amediacodec_mapping, 1, codec);

  1283.         av_freep(&codec);

  1284.     }

  1285. 

  1286.     return codec;

  1287. }

  1288. 

  1289. #define DECLARE_FF_AMEDIACODEC_CREATE_FUNC(name, method) \

  1290. FFAMediaCodec *ff_AMediaCodec_##name(const char *arg)    \

  1291. {                                                        \

  1292.     return codec_create(method, arg);                    \

  1293. }                                                        \

  1294. 

  1295. DECLARE_FF_AMEDIACODEC_CREATE_FUNC(createCodecByName,   CREATE_CODEC_BY_NAME)

  1296. DECLARE_FF_AMEDIACODEC_CREATE_FUNC(createDecoderByType, CREATE_DECODER_BY_TYPE)

  1297. DECLARE_FF_AMEDIACODEC_CREATE_FUNC(createEncoderByType, CREATE_ENCODER_BY_TYPE)

  1298. 

  1299. int ff_AMediaCodec_delete(FFAMediaCodec* codec)

  1300. {

  1301.     int ret = 0;

  1302. 

  1303.     JNIEnv *env = NULL;

  1304. 

  1305.     if (!codec) {

  1306.         return 0;

  1307.     }

  1308. 

  1309.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1310. 

  1311.     (*env)->CallVoidMethod(env, codec->object, codec->jfields.release_id);

  1312.     if (ff_jni_exception_check(env, 1, codec) < 0) {

  1313.         ret = AVERROR_EXTERNAL;

  1314.     }

  1315. 

  1316.     (*env)->DeleteGlobalRef(env, codec->object);

  1317.     codec->object = NULL;

  1318. 

  1319.     (*env)->DeleteGlobalRef(env, codec->buffer_info);

  1320.     codec->buffer_info = NULL;

  1321. 

  1322.     ff_jni_reset_jfields(env, &codec->jfields, jni_amediacodec_mapping, 1, codec);

  1323. 

  1324.     av_freep(&codec);

  1325. 

  1326.     return ret;

  1327. }

  1328. 

  1329. char *ff_AMediaCodec_getName(FFAMediaCodec *codec)

  1330. {

  1331.     char *ret = NULL;

  1332.     JNIEnv *env = NULL;

  1333.     jobject *name = NULL;

  1334. 

  1335.     JNI_GET_ENV_OR_RETURN(env, codec, NULL);

  1336. 

  1337.     name = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_name_id);

  1338.     if (ff_jni_exception_check(env, 1, codec) < 0) {

  1339.         goto fail;

  1340.     }

  1341. 

  1342.     ret = ff_jni_jstring_to_utf_chars(env, name, codec);

  1343. 

  1344. fail:

  1345.     if (name) {

  1346.         (*env)->DeleteLocalRef(env, name);

  1347.     }

  1348. 

  1349.     return ret;

  1350. }

  1351. 

  1352. int ff_AMediaCodec_configure(FFAMediaCodec* codec, const FFAMediaFormat* format, void* surface, void *crypto, uint32_t flags)

  1353. {

  1354.     int ret = 0;

  1355.     JNIEnv *env = NULL;

  1356. 

  1357.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1358. 

  1359.     (*env)->CallVoidMethod(env, codec->object, codec->jfields.configure_id, format->object, surface, NULL, flags);

  1360.     if (ff_jni_exception_check(env, 1, codec) < 0) {

  1361.         ret = AVERROR_EXTERNAL;

  1362.         goto fail;

  1363.     }

  1364. 

  1365. fail:

  1366.     return ret;

  1367. }

  1368. 

  1369. int ff_AMediaCodec_start(FFAMediaCodec* codec)

  1370. {

  1371.     int ret = 0;

  1372.     JNIEnv *env = NULL;

  1373. 

  1374.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1375. 

  1376.     (*env)->CallVoidMethod(env, codec->object, codec->jfields.start_id);

  1377.     if (ff_jni_exception_check(env, 1, codec) < 0) {

  1378.         ret = AVERROR_EXTERNAL;

  1379.         goto fail;

  1380.     }

  1381. 

  1382. fail:

  1383.     return ret;

  1384. }

  1385. 

  1386. int ff_AMediaCodec_stop(FFAMediaCodec* codec)

  1387. {

  1388.     int ret = 0;

  1389.     JNIEnv *env = NULL;

  1390. 

  1391.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1392. 

  1393.     (*env)->CallVoidMethod(env, codec->object, codec->jfields.stop_id);

  1394.     if (ff_jni_exception_check(env, 1, codec) < 0) {

  1395.         ret = AVERROR_EXTERNAL;

  1396.         goto fail;

  1397.     }

  1398. 

  1399. fail:

  1400.     return ret;

  1401. }

  1402. 

  1403. int ff_AMediaCodec_flush(FFAMediaCodec* codec)

  1404. {

  1405.     int ret = 0;

  1406.     JNIEnv *env = NULL;

  1407. 

  1408.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1409. 

  1410.     (*env)->CallVoidMethod(env, codec->object, codec->jfields.flush_id);

  1411.     if (ff_jni_exception_check(env, 1, codec) < 0) {

  1412.         ret = AVERROR_EXTERNAL;

  1413.         goto fail;

  1414.     }

  1415. 

  1416. fail:

  1417.     return ret;

  1418. }

  1419. 

  1420. int ff_AMediaCodec_releaseOutputBuffer(FFAMediaCodec* codec, size_t idx, int render)

  1421. {

  1422.     int ret = 0;

  1423.     JNIEnv *env = NULL;

  1424. 

  1425.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1426. 

  1427.     (*env)->CallVoidMethod(env, codec->object, codec->jfields.release_output_buffer_id, (jint)idx, (jboolean)render);

  1428.     if (ff_jni_exception_check(env, 1, codec) < 0) {

  1429.         ret = AVERROR_EXTERNAL;

  1430.         goto fail;

  1431.     }

  1432. 

  1433. fail:

  1434.     return ret;

  1435. }

  1436. 

  1437. int ff_AMediaCodec_releaseOutputBufferAtTime(FFAMediaCodec *codec, size_t idx, int64_t timestampNs)

  1438. {

  1439.     int ret = 0;

  1440.     JNIEnv *env = NULL;

  1441. 

  1442.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1443. 

  1444.     (*env)->CallVoidMethod(env, codec->object, codec->jfields.release_output_buffer_at_time_id, (jint)idx, (jlong)timestampNs);

  1445.     if (ff_jni_exception_check(env, 1, codec) < 0) {

  1446.         ret = AVERROR_EXTERNAL;

  1447.         goto fail;

  1448.     }

  1449. 

  1450. fail:

  1451.     return ret;

  1452. }

  1453. 

  1454. ssize_t ff_AMediaCodec_dequeueInputBuffer(FFAMediaCodec* codec, int64_t timeoutUs)

  1455. {

  1456.     int ret = 0;

  1457.     JNIEnv *env = NULL;

  1458. 

  1459.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1460. 

  1461.     ret = (*env)->CallIntMethod(env, codec->object, codec->jfields.dequeue_input_buffer_id, timeoutUs);

  1462.     if (ff_jni_exception_check(env, 1, codec) < 0) {

  1463.         ret = AVERROR_EXTERNAL;

  1464.         goto fail;

  1465.     }

  1466. 

  1467. fail:

  1468.     return ret;

  1469. }

  1470. 

  1471. int ff_AMediaCodec_queueInputBuffer(FFAMediaCodec* codec, size_t idx, off_t offset, size_t size, uint64_t time, uint32_t flags)

  1472. {

  1473.     int ret = 0;

  1474.     JNIEnv *env = NULL;

  1475. 

  1476.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1477. 

  1478.     (*env)->CallVoidMethod(env, codec->object, codec->jfields.queue_input_buffer_id, (jint)idx, (jint)offset, (jint)size, time, flags);

  1479.     if ((ret = ff_jni_exception_check(env, 1, codec)) < 0) {

  1480.         ret = AVERROR_EXTERNAL;

  1481.         goto fail;

  1482.     }

  1483. 

  1484. fail:

  1485.     return ret;

  1486. }

  1487. 

  1488. ssize_t ff_AMediaCodec_dequeueOutputBuffer(FFAMediaCodec* codec, FFAMediaCodecBufferInfo *info, int64_t timeoutUs)

  1489. {

  1490.     int ret = 0;

  1491.     JNIEnv *env = NULL;

  1492. 

  1493.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1494. 

  1495.     ret = (*env)->CallIntMethod(env, codec->object, codec->jfields.dequeue_output_buffer_id, codec->buffer_info, timeoutUs);

  1496.     if (ff_jni_exception_check(env, 1, codec) < 0) {

  1497.         return AVERROR_EXTERNAL;

  1498.     }

  1499. 

  1500.     info->flags = (*env)->GetIntField(env, codec->buffer_info, codec->jfields.flags_id);

  1501.     if (ff_jni_exception_check(env, 1, codec) < 0) {

  1502.         return AVERROR_EXTERNAL;

  1503.     }

  1504. 

  1505.     info->offset = (*env)->GetIntField(env, codec->buffer_info, codec->jfields.offset_id);

  1506.     if (ff_jni_exception_check(env, 1, codec) < 0) {

  1507.         return AVERROR_EXTERNAL;

  1508.     }

  1509. 

  1510.     info->presentationTimeUs = (*env)->GetLongField(env, codec->buffer_info, codec->jfields.presentation_time_us_id);

  1511.     if (ff_jni_exception_check(env, 1, codec) < 0) {

  1512.         return AVERROR_EXTERNAL;

  1513.     }

  1514. 

  1515.     info->size = (*env)->GetIntField(env, codec->buffer_info, codec->jfields.size_id);

  1516.     if (ff_jni_exception_check(env, 1, codec) < 0) {

  1517.         return AVERROR_EXTERNAL;

  1518.     }

  1519. 

  1520.     return ret;

  1521. }

  1522. 

  1523. uint8_t* ff_AMediaCodec_getInputBuffer(FFAMediaCodec* codec, size_t idx, size_t *out_size)

  1524. {

  1525.     uint8_t *ret = NULL;

  1526.     JNIEnv *env = NULL;

  1527. 

  1528.     jobject buffer = NULL;

  1529.     jobject input_buffers = NULL;

  1530. 

  1531.     JNI_GET_ENV_OR_RETURN(env, codec, NULL);

  1532. 

  1533.     if (codec->has_get_i_o_buffer) {

  1534.         buffer = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_input_buffer_id, (jint)idx);

  1535.         if (ff_jni_exception_check(env, 1, codec) < 0) {

  1536.             goto fail;

  1537.         }

  1538.     } else {

  1539.         if (!codec->input_buffers) {

  1540.             input_buffers = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_input_buffers_id);

  1541.             if (ff_jni_exception_check(env, 1, codec) < 0) {

  1542.                 goto fail;

  1543.             }

  1544. 

  1545.             codec->input_buffers = (*env)->NewGlobalRef(env, input_buffers);

  1546.             if (ff_jni_exception_check(env, 1, codec) < 0) {

  1547.                 goto fail;

  1548.             }

  1549.         }

  1550. 

  1551.         buffer = (*env)->GetObjectArrayElement(env, codec->input_buffers, idx);

  1552.         if (ff_jni_exception_check(env, 1, codec) < 0) {

  1553.             goto fail;

  1554.         }

  1555.     }

  1556. 

  1557.     ret = (*env)->GetDirectBufferAddress(env, buffer);

  1558.     *out_size = (*env)->GetDirectBufferCapacity(env, buffer);

  1559. fail:

  1560.     if (buffer) {

  1561.         (*env)->DeleteLocalRef(env, buffer);

  1562.     }

  1563. 

  1564.     if (input_buffers) {

  1565.         (*env)->DeleteLocalRef(env, input_buffers);

  1566.     }

  1567. 

  1568.     return ret;

  1569. }

  1570. 

  1571. uint8_t* ff_AMediaCodec_getOutputBuffer(FFAMediaCodec* codec, size_t idx, size_t *out_size)

  1572. {

  1573.     uint8_t *ret = NULL;

  1574.     JNIEnv *env = NULL;

  1575. 

  1576.     jobject buffer = NULL;

  1577.     jobject output_buffers = NULL;

  1578. 

  1579.     JNI_GET_ENV_OR_RETURN(env, codec, NULL);

  1580. 

  1581.     if (codec->has_get_i_o_buffer) {

  1582.         buffer = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_output_buffer_id, (jint)idx);

  1583.         if (ff_jni_exception_check(env, 1, codec) < 0) {

  1584.             goto fail;

  1585.         }

  1586.     } else {

  1587.         if (!codec->output_buffers) {

  1588.             output_buffers = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_output_buffers_id);

  1589.             if (ff_jni_exception_check(env, 1, codec) < 0) {

  1590.                 goto fail;

  1591.             }

  1592. 

  1593.             codec->output_buffers = (*env)->NewGlobalRef(env, output_buffers);

  1594.             if (ff_jni_exception_check(env, 1, codec) < 0) {

  1595.                 goto fail;

  1596.             }

  1597.         }

  1598. 

  1599.         buffer = (*env)->GetObjectArrayElement(env, codec->output_buffers, idx);

  1600.         if (ff_jni_exception_check(env, 1, codec) < 0) {

  1601.             goto fail;

  1602.         }

  1603.     }

  1604. 

  1605.     ret = (*env)->GetDirectBufferAddress(env, buffer);

  1606.     *out_size = (*env)->GetDirectBufferCapacity(env, buffer);

  1607. fail:

  1608.     if (buffer) {

  1609.         (*env)->DeleteLocalRef(env, buffer);

  1610.     }

  1611. 

  1612.     if (output_buffers) {

  1613.         (*env)->DeleteLocalRef(env, output_buffers);

  1614.     }

  1615. 

  1616.     return ret;

  1617. }

  1618. 

  1619. FFAMediaFormat* ff_AMediaCodec_getOutputFormat(FFAMediaCodec* codec)

  1620. {

  1621.     FFAMediaFormat *ret = NULL;

  1622.     JNIEnv *env = NULL;

  1623. 

  1624.     jobject mediaformat = NULL;

  1625. 

  1626.     JNI_GET_ENV_OR_RETURN(env, codec, NULL);

  1627. 

  1628.     mediaformat = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_output_format_id);

  1629.     if (ff_jni_exception_check(env, 1, codec) < 0) {

  1630.         goto fail;

  1631.     }

  1632. 

  1633.     ret = ff_AMediaFormat_newFromObject(mediaformat);

  1634. fail:

  1635.     if (mediaformat) {

  1636.         (*env)->DeleteLocalRef(env, mediaformat);

  1637.     }

  1638. 

  1639.     return ret;

  1640. }

  1641. 

  1642. int ff_AMediaCodec_infoTryAgainLater(FFAMediaCodec *codec, ssize_t idx)

  1643. {

  1644.     return idx == codec->INFO_TRY_AGAIN_LATER;

  1645. }

  1646. 

  1647. int ff_AMediaCodec_infoOutputBuffersChanged(FFAMediaCodec *codec, ssize_t idx)

  1648. {

  1649.     return idx == codec->INFO_OUTPUT_BUFFERS_CHANGED;

  1650. }

  1651. 

  1652. int ff_AMediaCodec_infoOutputFormatChanged(FFAMediaCodec *codec, ssize_t idx)

  1653. {

  1654.     return idx == codec->INFO_OUTPUT_FORMAT_CHANGED;

  1655. }

  1656. 

  1657. int ff_AMediaCodec_getBufferFlagCodecConfig(FFAMediaCodec *codec)

  1658. {

  1659.     return codec->BUFFER_FLAG_CODEC_CONFIG;

  1660. }

  1661. 

  1662. int ff_AMediaCodec_getBufferFlagEndOfStream(FFAMediaCodec *codec)

  1663. {

  1664.     return codec->BUFFER_FLAG_END_OF_STREAM;

  1665. }

  1666. 

  1667. int ff_AMediaCodec_getBufferFlagKeyFrame(FFAMediaCodec *codec)

  1668. {

  1669.     return codec->BUFFER_FLAG_KEY_FRAME;

  1670. }

  1671. 

  1672. int ff_AMediaCodec_getConfigureFlagEncode(FFAMediaCodec *codec)

  1673. {

  1674.     return codec->CONFIGURE_FLAG_ENCODE;

  1675. }

  1676. 

  1677. int ff_AMediaCodec_cleanOutputBuffers(FFAMediaCodec *codec)

  1678. {

  1679.     int ret = 0;

  1680. 

  1681.     if (!codec->has_get_i_o_buffer) {

  1682.         if (codec->output_buffers) {

  1683.             JNIEnv *env = NULL;

  1684. 

  1685.             env = ff_jni_get_env(codec);

  1686.             if (!env) {

  1687.                 ret = AVERROR_EXTERNAL;

  1688.                 goto fail;

  1689.             }

  1690. 

  1691.             (*env)->DeleteGlobalRef(env, codec->output_buffers);

  1692.             codec->output_buffers = NULL;

  1693.         }

  1694.     }

  1695. 

  1696. fail:

  1697.     return ret;

  1698. }

  1699. 

  1700. int ff_Build_SDK_INT(AVCodecContext *avctx)

  1701. {

  1702.     int ret = -1;

  1703.     JNIEnv *env = NULL;

  1704.     jclass versionClass;

  1705.     jfieldID sdkIntFieldID;

  1706.     JNI_GET_ENV_OR_RETURN(env, avctx, -1);

  1707. 

  1708.     versionClass = (*env)->FindClass(env, "android/os/Build$VERSION");

  1709.     sdkIntFieldID = (*env)->GetStaticFieldID(env, versionClass, "SDK_INT", "I");

  1710.     ret = (*env)->GetStaticIntField(env, versionClass, sdkIntFieldID);

  1711.     (*env)->DeleteLocalRef(env, versionClass);

  1712.     return ret;

  1713. }