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.
101453 Commits
32 Branches
844MB
Tree: a7425f712a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a7425f712a'
${ noResults }
FFmpeg/libavcodec/mediacodec_wrapper.c

1724 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.     jmethodID is_software_only_id;

  49. 

  50.     jclass codec_capabilities_class;

  51.     jfieldID color_formats_id;

  52.     jfieldID profile_levels_id;

  53. 

  54.     jclass codec_profile_level_class;

  55.     jfieldID profile_id;

  56.     jfieldID level_id;

  57. 

  58.     jfieldID avc_profile_baseline_id;

  59.     jfieldID avc_profile_main_id;

  60.     jfieldID avc_profile_extended_id;

  61.     jfieldID avc_profile_high_id;

  62.     jfieldID avc_profile_high10_id;

  63.     jfieldID avc_profile_high422_id;

  64.     jfieldID avc_profile_high444_id;

  65. 

  66.     jfieldID hevc_profile_main_id;

  67.     jfieldID hevc_profile_main10_id;

  68.     jfieldID hevc_profile_main10_hdr10_id;

  69. 

  70. };

  71. 

  72. static const struct FFJniField jni_amediacodeclist_mapping[] = {

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

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

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

  76. 

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

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

  79. 

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

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

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

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

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

  85.         { "android/media/MediaCodecInfo", "isSoftwareOnly", "()Z", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecListFields, is_software_only_id), 0 },

  86. 

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

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

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

  90. 

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

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

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

  94. 

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

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

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

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

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

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

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

  102. 

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

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

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

  106. 

  107.     { NULL }

  108. };

  109. 

  110. struct JNIAMediaFormatFields {

  111. 

  112.     jclass mediaformat_class;

  113. 

  114.     jmethodID init_id;

  115. 

  116.     jmethodID contains_key_id;

  117. 

  118.     jmethodID get_integer_id;

  119.     jmethodID get_long_id;

  120.     jmethodID get_float_id;

  121.     jmethodID get_bytebuffer_id;

  122.     jmethodID get_string_id;

  123. 

  124.     jmethodID set_integer_id;

  125.     jmethodID set_long_id;

  126.     jmethodID set_float_id;

  127.     jmethodID set_bytebuffer_id;

  128.     jmethodID set_string_id;

  129. 

  130.     jmethodID to_string_id;

  131. 

  132. };

  133. 

  134. static const struct FFJniField jni_amediaformat_mapping[] = {

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

  136. 

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

  138. 

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

  140. 

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

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

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

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

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

  146. 

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

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

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

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

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

  152. 

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

  154. 

  155.     { NULL }

  156. };

  157. 

  158. static const AVClass amediaformat_class = {

  159.     .class_name = "amediaformat",

  160.     .item_name  = av_default_item_name,

  161.     .version    = LIBAVUTIL_VERSION_INT,

  162. };

  163. 

  164. struct FFAMediaFormat {

  165. 

  166.     const AVClass *class;

  167.     struct JNIAMediaFormatFields jfields;

  168.     jobject object;

  169. };

  170. 

  171. struct JNIAMediaCodecFields {

  172. 

  173.     jclass mediacodec_class;

  174. 

  175.     jfieldID info_try_again_later_id;

  176.     jfieldID info_output_buffers_changed_id;

  177.     jfieldID info_output_format_changed_id;

  178. 

  179.     jfieldID buffer_flag_codec_config_id;

  180.     jfieldID buffer_flag_end_of_stream_id;

  181.     jfieldID buffer_flag_key_frame_id;

  182. 

  183.     jfieldID configure_flag_encode_id;

  184. 

  185.     jmethodID create_by_codec_name_id;

  186.     jmethodID create_decoder_by_type_id;

  187.     jmethodID create_encoder_by_type_id;

  188. 

  189.     jmethodID get_name_id;

  190. 

  191.     jmethodID configure_id;

  192.     jmethodID start_id;

  193.     jmethodID flush_id;

  194.     jmethodID stop_id;

  195.     jmethodID release_id;

  196. 

  197.     jmethodID get_output_format_id;

  198. 

  199.     jmethodID dequeue_input_buffer_id;

  200.     jmethodID queue_input_buffer_id;

  201.     jmethodID get_input_buffer_id;

  202.     jmethodID get_input_buffers_id;

  203. 

  204.     jmethodID dequeue_output_buffer_id;

  205.     jmethodID get_output_buffer_id;

  206.     jmethodID get_output_buffers_id;

  207.     jmethodID release_output_buffer_id;

  208.     jmethodID release_output_buffer_at_time_id;

  209. 

  210.     jclass mediainfo_class;

  211. 

  212.     jmethodID init_id;

  213. 

  214.     jfieldID flags_id;

  215.     jfieldID offset_id;

  216.     jfieldID presentation_time_us_id;

  217.     jfieldID size_id;

  218. 

  219. };

  220. 

  221. static const struct FFJniField jni_amediacodec_mapping[] = {

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

  223. 

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

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

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

  227. 

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

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

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

  231. 

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

  233. 

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

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

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

  237. 

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

  239. 

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

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

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

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

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

  245. 

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

  247. 

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

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

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

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

  252. 

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

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

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

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

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

  258. 

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

  260. 

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

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

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

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

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

  266. 

  267.     { NULL }

  268. };

  269. 

  270. static const AVClass amediacodec_class = {

  271.     .class_name = "amediacodec",

  272.     .item_name  = av_default_item_name,

  273.     .version    = LIBAVUTIL_VERSION_INT,

  274. };

  275. 

  276. struct FFAMediaCodec {

  277. 

  278.     const AVClass *class;

  279. 

  280.     struct JNIAMediaCodecFields jfields;

  281. 

  282.     jobject object;

  283.     jobject buffer_info;

  284. 

  285.     jobject input_buffers;

  286.     jobject output_buffers;

  287. 

  288.     int INFO_TRY_AGAIN_LATER;

  289.     int INFO_OUTPUT_BUFFERS_CHANGED;

  290.     int INFO_OUTPUT_FORMAT_CHANGED;

  291. 

  292.     int BUFFER_FLAG_CODEC_CONFIG;

  293.     int BUFFER_FLAG_END_OF_STREAM;

  294.     int BUFFER_FLAG_KEY_FRAME;

  295. 

  296.     int CONFIGURE_FLAG_ENCODE;

  297. 

  298.     int has_get_i_o_buffer;

  299. };

  300. 

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

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

  303.     if (!(env)) {                                                  \

  304.         return ret;                                                \

  305.     }                                                              \

  306. } while (0)

  307. 

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

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

  310.     if (!(env)) {                                                  \

  311.         return;                                                    \

  312.     }                                                              \

  313. } while (0)

  314. 

  315. int ff_AMediaCodecProfile_getProfileFromAVCodecContext(AVCodecContext *avctx)

  316. {

  317.     int ret = -1;

  318. 

  319.     JNIEnv *env = NULL;

  320.     struct JNIAMediaCodecListFields jfields = { 0 };

  321.     jfieldID field_id = 0;

  322. 

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

  324. 

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

  326.         goto done;

  327.     }

  328. 

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

  330.         switch(avctx->profile) {

  331.         case FF_PROFILE_H264_BASELINE:

  332.         case FF_PROFILE_H264_CONSTRAINED_BASELINE:

  333.             field_id = jfields.avc_profile_baseline_id;

  334.             break;

  335.         case FF_PROFILE_H264_MAIN:

  336.             field_id = jfields.avc_profile_main_id;

  337.             break;

  338.         case FF_PROFILE_H264_EXTENDED:

  339.             field_id = jfields.avc_profile_extended_id;

  340.             break;

  341.         case FF_PROFILE_H264_HIGH:

  342.             field_id = jfields.avc_profile_high_id;

  343.             break;

  344.         case FF_PROFILE_H264_HIGH_10:

  345.         case FF_PROFILE_H264_HIGH_10_INTRA:

  346.             field_id = jfields.avc_profile_high10_id;

  347.             break;

  348.         case FF_PROFILE_H264_HIGH_422:

  349.         case FF_PROFILE_H264_HIGH_422_INTRA:

  350.             field_id = jfields.avc_profile_high422_id;

  351.             break;

  352.         case FF_PROFILE_H264_HIGH_444:

  353.         case FF_PROFILE_H264_HIGH_444_INTRA:

  354.         case FF_PROFILE_H264_HIGH_444_PREDICTIVE:

  355.             field_id = jfields.avc_profile_high444_id;

  356.             break;

  357.         }

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

  359.         switch (avctx->profile) {

  360.         case FF_PROFILE_HEVC_MAIN:

  361.         case FF_PROFILE_HEVC_MAIN_STILL_PICTURE:

  362.             field_id = jfields.hevc_profile_main_id;

  363.             break;

  364.         case FF_PROFILE_HEVC_MAIN_10:

  365.             field_id = jfields.hevc_profile_main10_id;

  366.             break;

  367.         }

  368.     }

  369. 

  370.         if (field_id) {

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

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

  373.                 ret = -1;

  374.                 goto done;

  375.             }

  376.         }

  377. 

  378. done:

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

  380. 

  381.     return ret;

  382. }

  383. 

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

  385. {

  386.     int ret;

  387.     int i;

  388.     int codec_count;

  389.     int found_codec = 0;

  390.     char *name = NULL;

  391.     char *supported_type = NULL;

  392. 

  393.     JNIEnv *env = NULL;

  394.     struct JNIAMediaCodecListFields jfields = { 0 };

  395.     struct JNIAMediaFormatFields mediaformat_jfields = { 0 };

  396. 

  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.         if (jfields.is_software_only_id) {

  447.             int is_software_only = (*env)->CallBooleanMethod(env, info, jfields.is_software_only_id);

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

  449.                 goto done;

  450.             }

  451. 

  452.             if (is_software_only) {

  453.                 goto done_with_info;

  454.             }

  455.         }

  456. 

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

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

  459.             goto done;

  460.         }

  461. 

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

  463.         if (!name) {

  464.             goto done;

  465.         }

  466. 

  467.         if (codec_name) {

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

  469.             codec_name = NULL;

  470.         }

  471. 

  472.         /* Skip software decoders */

  473.         if (

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

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

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

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

  478.             goto done_with_info;

  479.         }

  480. 

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

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

  483.             int k;

  484.             int profile_count;

  485. 

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

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

  488.                 goto done;

  489.             }

  490. 

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

  492.             if (!supported_type) {

  493.                 goto done;

  494.             }

  495. 

  496.             if (av_strcasecmp(supported_type, mime)) {

  497.                 goto done_with_type;

  498.             }

  499. 

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

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

  502.                 goto done;

  503.             }

  504. 

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

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

  507.                 goto done;

  508.             }

  509. 

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

  511.             if (!profile_count) {

  512.                 found_codec = 1;

  513.             }

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

  515.                 int supported_profile = 0;

  516. 

  517.                 if (profile < 0) {

  518.                     found_codec = 1;

  519.                     break;

  520.                 }

  521. 

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

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

  524.                     goto done;

  525.                 }

  526. 

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

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

  529.                     goto done;

  530.                 }

  531. 

  532.                 found_codec = profile == supported_profile;

  533. 

  534.                 if (profile_level) {

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

  536.                     profile_level = NULL;

  537.                 }

  538. 

  539.                 if (found_codec) {

  540.                     break;

  541.                 }

  542.             }

  543. 

  544. done_with_type:

  545.             if (profile_levels) {

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

  547.                 profile_levels = NULL;

  548.             }

  549. 

  550.             if (capabilities) {

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

  552.                 capabilities = NULL;

  553.             }

  554. 

  555.             if (type) {

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

  557.                 type = NULL;

  558.             }

  559. 

  560.             av_freep(&supported_type);

  561. 

  562.             if (found_codec) {

  563.                 break;

  564.             }

  565.         }

  566. 

  567. done_with_info:

  568.         if (info) {

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

  570.             info = NULL;

  571.         }

  572. 

  573.         if (types) {

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

  575.             types = NULL;

  576.         }

  577. 

  578.         if (found_codec) {

  579.             break;

  580.         }

  581. 

  582.         av_freep(&name);

  583.     }

  584. 

  585. done:

  586.     if (codec_name) {

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

  588.     }

  589. 

  590.     if (info) {

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

  592.     }

  593. 

  594.     if (type) {

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

  596.     }

  597. 

  598.     if (types) {

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

  600.     }

  601. 

  602.     if (capabilities) {

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

  604.     }

  605. 

  606.     if (profile_level) {

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

  608.     }

  609. 

  610.     if (profile_levels) {

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

  612.     }

  613. 

  614.     av_freep(&supported_type);

  615. 

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

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

  618. 

  619.     if (!found_codec) {

  620.         av_freep(&name);

  621.     }

  622. 

  623.     return name;

  624. }

  625. 

  626. FFAMediaFormat *ff_AMediaFormat_new(void)

  627. {

  628.     JNIEnv *env = NULL;

  629.     FFAMediaFormat *format = NULL;

  630.     jobject object = NULL;

  631. 

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

  633.     if (!format) {

  634.         return NULL;

  635.     }

  636.     format->class = &amediaformat_class;

  637. 

  638.     env = ff_jni_get_env(format);

  639.     if (!env) {

  640.         av_freep(&format);

  641.         return NULL;

  642.     }

  643. 

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

  645.         goto fail;

  646.     }

  647. 

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

  649.     if (!object) {

  650.         goto fail;

  651.     }

  652. 

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

  654.     if (!format->object) {

  655.         goto fail;

  656.     }

  657. 

  658. fail:

  659.     if (object) {

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

  661.     }

  662. 

  663.     if (!format->object) {

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

  665.         av_freep(&format);

  666.     }

  667. 

  668.     return format;

  669. }

  670. 

  671. static FFAMediaFormat *ff_AMediaFormat_newFromObject(void *object)

  672. {

  673.     JNIEnv *env = NULL;

  674.     FFAMediaFormat *format = NULL;

  675. 

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

  677.     if (!format) {

  678.         return NULL;

  679.     }

  680.     format->class = &amediaformat_class;

  681. 

  682.     env = ff_jni_get_env(format);

  683.     if (!env) {

  684.         av_freep(&format);

  685.         return NULL;

  686.     }

  687. 

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

  689.         goto fail;

  690.     }

  691. 

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

  693.     if (!format->object) {

  694.         goto fail;

  695.     }

  696. 

  697.     return format;

  698. fail:

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

  700. 

  701.     av_freep(&format);

  702. 

  703.     return NULL;

  704. }

  705. 

  706. int ff_AMediaFormat_delete(FFAMediaFormat* format)

  707. {

  708.     int ret = 0;

  709. 

  710.     JNIEnv *env = NULL;

  711. 

  712.     if (!format) {

  713.         return 0;

  714.     }

  715. 

  716.     JNI_GET_ENV_OR_RETURN(env, format, AVERROR_EXTERNAL);

  717. 

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

  719.     format->object = NULL;

  720. 

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

  722. 

  723.     av_freep(&format);

  724. 

  725.     return ret;

  726. }

  727. 

  728. char* ff_AMediaFormat_toString(FFAMediaFormat* format)

  729. {

  730.     char *ret = NULL;

  731. 

  732.     JNIEnv *env = NULL;

  733.     jstring description = NULL;

  734. 

  735.     av_assert0(format != NULL);

  736. 

  737.     JNI_GET_ENV_OR_RETURN(env, format, NULL);

  738. 

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

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

  741.         goto fail;

  742.     }

  743. 

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

  745. fail:

  746.     if (description) {

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

  748.     }

  749. 

  750.     return ret;

  751. }

  752. 

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

  754. {

  755.     int ret = 1;

  756. 

  757.     JNIEnv *env = NULL;

  758.     jstring key = NULL;

  759.     jboolean contains_key;

  760. 

  761.     av_assert0(format != NULL);

  762. 

  763.     JNI_GET_ENV_OR_RETURN(env, format, 0);

  764. 

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

  766.     if (!key) {

  767.         ret = 0;

  768.         goto fail;

  769.     }

  770. 

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

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

  773.         ret = 0;

  774.         goto fail;

  775.     }

  776. 

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

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

  779.         ret = 0;

  780.         goto fail;

  781.     }

  782. 

  783.     ret = 1;

  784. fail:

  785.     if (key) {

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

  787.     }

  788. 

  789.     return ret;

  790. }

  791. 

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

  793. {

  794.     int ret = 1;

  795. 

  796.     JNIEnv *env = NULL;

  797.     jstring key = NULL;

  798.     jboolean contains_key;

  799. 

  800.     av_assert0(format != NULL);

  801. 

  802.     JNI_GET_ENV_OR_RETURN(env, format, 0);

  803. 

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

  805.     if (!key) {

  806.         ret = 0;

  807.         goto fail;

  808.     }

  809. 

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

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

  812.         ret = 0;

  813.         goto fail;

  814.     }

  815. 

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

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

  818.         ret = 0;

  819.         goto fail;

  820.     }

  821. 

  822.     ret = 1;

  823. fail:

  824.     if (key) {

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

  826.     }

  827. 

  828.     return ret;

  829. }

  830. 

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

  832. {

  833.     int ret = 1;

  834. 

  835.     JNIEnv *env = NULL;

  836.     jstring key = NULL;

  837.     jboolean contains_key;

  838. 

  839.     av_assert0(format != NULL);

  840. 

  841.     JNI_GET_ENV_OR_RETURN(env, format, 0);

  842. 

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

  844.     if (!key) {

  845.         ret = 0;

  846.         goto fail;

  847.     }

  848. 

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

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

  851.         ret = 0;

  852.         goto fail;

  853.     }

  854. 

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

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

  857.         ret = 0;

  858.         goto fail;

  859.     }

  860. 

  861.     ret = 1;

  862. fail:

  863.     if (key) {

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

  865.     }

  866. 

  867.     return ret;

  868. }

  869. 

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

  871. {

  872.     int ret = 1;

  873. 

  874.     JNIEnv *env = NULL;

  875.     jstring key = NULL;

  876.     jboolean contains_key;

  877.     jobject result = NULL;

  878. 

  879.     av_assert0(format != NULL);

  880. 

  881.     JNI_GET_ENV_OR_RETURN(env, format, 0);

  882. 

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

  884.     if (!key) {

  885.         ret = 0;

  886.         goto fail;

  887.     }

  888. 

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

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

  891.         ret = 0;

  892.         goto fail;

  893.     }

  894. 

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

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

  897.         ret = 0;

  898.         goto fail;

  899.     }

  900. 

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

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

  903. 

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

  905.         void *src = *data;

  906.         *data = av_malloc(*size);

  907.         if (!*data) {

  908.             ret = 0;

  909.             goto fail;

  910.         }

  911. 

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

  913.     }

  914. 

  915.     ret = 1;

  916. fail:

  917.     if (key) {

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

  919.     }

  920. 

  921.     if (result) {

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

  923.     }

  924. 

  925.     return ret;

  926. }

  927. 

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

  929. {

  930.     int ret = 1;

  931. 

  932.     JNIEnv *env = NULL;

  933.     jstring key = NULL;

  934.     jboolean contains_key;

  935.     jstring result = NULL;

  936. 

  937.     av_assert0(format != NULL);

  938. 

  939.     JNI_GET_ENV_OR_RETURN(env, format, 0);

  940. 

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

  942.     if (!key) {

  943.         ret = 0;

  944.         goto fail;

  945.     }

  946. 

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

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

  949.         ret = 0;

  950.         goto fail;

  951.     }

  952. 

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

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

  955.         ret = 0;

  956.         goto fail;

  957.     }

  958. 

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

  960.     if (!*out) {

  961.         ret = 0;

  962.         goto fail;

  963.     }

  964. 

  965.     ret = 1;

  966. fail:

  967.     if (key) {

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

  969.     }

  970. 

  971.     if (result) {

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

  973.     }

  974. 

  975.     return ret;

  976. }

  977. 

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

  979. {

  980.     JNIEnv *env = NULL;

  981.     jstring key = NULL;

  982. 

  983.     av_assert0(format != NULL);

  984. 

  985.     JNI_GET_ENV_OR_RETURN_VOID(env, format);

  986. 

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

  988.     if (!key) {

  989.         goto fail;

  990.     }

  991. 

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

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

  994.         goto fail;

  995.     }

  996. 

  997. fail:

  998.     if (key) {

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

  1000.     }

  1001. }

  1002. 

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

  1004. {

  1005.     JNIEnv *env = NULL;

  1006.     jstring key = NULL;

  1007. 

  1008.     av_assert0(format != NULL);

  1009. 

  1010.     JNI_GET_ENV_OR_RETURN_VOID(env, format);

  1011. 

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

  1013.     if (!key) {

  1014.         goto fail;

  1015.     }

  1016. 

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

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

  1019.         goto fail;

  1020.     }

  1021. 

  1022. fail:

  1023.     if (key) {

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

  1025.     }

  1026. }

  1027. 

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

  1029. {

  1030.     JNIEnv *env = NULL;

  1031.     jstring key = NULL;

  1032. 

  1033.     av_assert0(format != NULL);

  1034. 

  1035.     JNI_GET_ENV_OR_RETURN_VOID(env, format);

  1036. 

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

  1038.     if (!key) {

  1039.         goto fail;

  1040.     }

  1041. 

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

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

  1044.         goto fail;

  1045.     }

  1046. 

  1047. fail:

  1048.     if (key) {

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

  1050.     }

  1051. }

  1052. 

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

  1054. {

  1055.     JNIEnv *env = NULL;

  1056.     jstring key = NULL;

  1057.     jstring string = NULL;

  1058. 

  1059.     av_assert0(format != NULL);

  1060. 

  1061.     JNI_GET_ENV_OR_RETURN_VOID(env, format);

  1062. 

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

  1064.     if (!key) {

  1065.         goto fail;

  1066.     }

  1067. 

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

  1069.     if (!string) {

  1070.         goto fail;

  1071.     }

  1072. 

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

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

  1075.         goto fail;

  1076.     }

  1077. 

  1078. fail:

  1079.     if (key) {

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

  1081.     }

  1082. 

  1083.     if (string) {

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

  1085.     }

  1086. }

  1087. 

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

  1089. {

  1090.     JNIEnv *env = NULL;

  1091.     jstring key = NULL;

  1092.     jobject buffer = NULL;

  1093.     void *buffer_data = NULL;

  1094. 

  1095.     av_assert0(format != NULL);

  1096. 

  1097.     JNI_GET_ENV_OR_RETURN_VOID(env, format);

  1098. 

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

  1100.     if (!key) {

  1101.         goto fail;

  1102.     }

  1103. 

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

  1105.         goto fail;

  1106.     }

  1107. 

  1108.     buffer_data = av_malloc(size);

  1109.     if (!buffer_data) {

  1110.         goto fail;

  1111.     }

  1112. 

  1113.     memcpy(buffer_data, data, size);

  1114. 

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

  1116.     if (!buffer) {

  1117.         goto fail;

  1118.     }

  1119. 

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

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

  1122.         goto fail;

  1123.     }

  1124. 

  1125. fail:

  1126.     if (key) {

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

  1128.     }

  1129. 

  1130.     if (buffer) {

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

  1132.     }

  1133. }

  1134. 

  1135. static int codec_init_static_fields(FFAMediaCodec *codec)

  1136. {

  1137.     int ret = 0;

  1138.     JNIEnv *env = NULL;

  1139. 

  1140.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1141. 

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

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

  1144.         goto fail;

  1145.     }

  1146. 

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

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

  1149.         goto fail;

  1150.     }

  1151. 

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

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

  1154.         goto fail;

  1155.     }

  1156. 

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

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

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

  1160.             goto fail;

  1161.         }

  1162.     }

  1163. 

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

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

  1166.         goto fail;

  1167.     }

  1168. 

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

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

  1171.         goto fail;

  1172.     }

  1173. 

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

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

  1176.         goto fail;

  1177.     }

  1178. 

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

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

  1181.         goto fail;

  1182.     }

  1183. 

  1184. fail:

  1185. 

  1186.     return ret;

  1187. }

  1188. 

  1189. #define CREATE_CODEC_BY_NAME   0

  1190. #define CREATE_DECODER_BY_TYPE 1

  1191. #define CREATE_ENCODER_BY_TYPE 2

  1192. 

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

  1194. {

  1195.     int ret = -1;

  1196.     JNIEnv *env = NULL;

  1197.     FFAMediaCodec *codec = NULL;

  1198.     jstring jarg = NULL;

  1199.     jobject object = NULL;

  1200.     jobject buffer_info = NULL;

  1201.     jmethodID create_id = NULL;

  1202. 

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

  1204.     if (!codec) {

  1205.         return NULL;

  1206.     }

  1207.     codec->class = &amediacodec_class;

  1208. 

  1209.     env = ff_jni_get_env(codec);

  1210.     if (!env) {

  1211.         av_freep(&codec);

  1212.         return NULL;

  1213.     }

  1214. 

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

  1216.         goto fail;

  1217.     }

  1218. 

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

  1220.     if (!jarg) {

  1221.         goto fail;

  1222.     }

  1223. 

  1224.     switch (method) {

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

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

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

  1228.     default:

  1229.         av_assert0(0);

  1230.     }

  1231. 

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

  1233.                                             codec->jfields.mediacodec_class,

  1234.                                             create_id,

  1235.                                             jarg);

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

  1237.         goto fail;

  1238.     }

  1239. 

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

  1241.     if (!codec->object) {

  1242.         goto fail;

  1243.     }

  1244. 

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

  1246.         goto fail;

  1247.     }

  1248. 

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

  1250.         codec->has_get_i_o_buffer = 1;

  1251.     }

  1252. 

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

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

  1255.         goto fail;

  1256.     }

  1257. 

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

  1259.     if (!codec->buffer_info) {

  1260.         goto fail;

  1261.     }

  1262. 

  1263.     ret = 0;

  1264. fail:

  1265.     if (jarg) {

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

  1267.     }

  1268. 

  1269.     if (object) {

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

  1271.     }

  1272. 

  1273.     if (buffer_info) {

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

  1275.     }

  1276. 

  1277.     if (ret < 0) {

  1278.         if (codec->object) {

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

  1280.         }

  1281. 

  1282.         if (codec->buffer_info) {

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

  1284.         }

  1285. 

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

  1287.         av_freep(&codec);

  1288.     }

  1289. 

  1290.     return codec;

  1291. }

  1292. 

  1293. #define DECLARE_FF_AMEDIACODEC_CREATE_FUNC(name, method) \

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

  1295. {                                                        \

  1296.     return codec_create(method, arg);                    \

  1297. }                                                        \

  1298. 

  1299. DECLARE_FF_AMEDIACODEC_CREATE_FUNC(createCodecByName,   CREATE_CODEC_BY_NAME)

  1300. DECLARE_FF_AMEDIACODEC_CREATE_FUNC(createDecoderByType, CREATE_DECODER_BY_TYPE)

  1301. DECLARE_FF_AMEDIACODEC_CREATE_FUNC(createEncoderByType, CREATE_ENCODER_BY_TYPE)

  1302. 

  1303. int ff_AMediaCodec_delete(FFAMediaCodec* codec)

  1304. {

  1305.     int ret = 0;

  1306. 

  1307.     JNIEnv *env = NULL;

  1308. 

  1309.     if (!codec) {

  1310.         return 0;

  1311.     }

  1312. 

  1313.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1314. 

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

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

  1317.         ret = AVERROR_EXTERNAL;

  1318.     }

  1319. 

  1320.     (*env)->DeleteGlobalRef(env, codec->input_buffers);

  1321.     codec->input_buffers = NULL;

  1322. 

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

  1324.     codec->output_buffers = NULL;

  1325. 

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

  1327.     codec->object = NULL;

  1328. 

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

  1330.     codec->buffer_info = NULL;

  1331. 

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

  1333. 

  1334.     av_freep(&codec);

  1335. 

  1336.     return ret;

  1337. }

  1338. 

  1339. char *ff_AMediaCodec_getName(FFAMediaCodec *codec)

  1340. {

  1341.     char *ret = NULL;

  1342.     JNIEnv *env = NULL;

  1343.     jobject *name = NULL;

  1344. 

  1345.     JNI_GET_ENV_OR_RETURN(env, codec, NULL);

  1346. 

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

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

  1349.         goto fail;

  1350.     }

  1351. 

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

  1353. 

  1354. fail:

  1355.     if (name) {

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

  1357.     }

  1358. 

  1359.     return ret;

  1360. }

  1361. 

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

  1363. {

  1364.     int ret = 0;

  1365.     JNIEnv *env = NULL;

  1366. 

  1367.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1368. 

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

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

  1371.         ret = AVERROR_EXTERNAL;

  1372.         goto fail;

  1373.     }

  1374. 

  1375. fail:

  1376.     return ret;

  1377. }

  1378. 

  1379. int ff_AMediaCodec_start(FFAMediaCodec* codec)

  1380. {

  1381.     int ret = 0;

  1382.     JNIEnv *env = NULL;

  1383. 

  1384.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1385. 

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

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

  1388.         ret = AVERROR_EXTERNAL;

  1389.         goto fail;

  1390.     }

  1391. 

  1392. fail:

  1393.     return ret;

  1394. }

  1395. 

  1396. int ff_AMediaCodec_stop(FFAMediaCodec* codec)

  1397. {

  1398.     int ret = 0;

  1399.     JNIEnv *env = NULL;

  1400. 

  1401.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1402. 

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

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

  1405.         ret = AVERROR_EXTERNAL;

  1406.         goto fail;

  1407.     }

  1408. 

  1409. fail:

  1410.     return ret;

  1411. }

  1412. 

  1413. int ff_AMediaCodec_flush(FFAMediaCodec* codec)

  1414. {

  1415.     int ret = 0;

  1416.     JNIEnv *env = NULL;

  1417. 

  1418.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1419. 

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

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

  1422.         ret = AVERROR_EXTERNAL;

  1423.         goto fail;

  1424.     }

  1425. 

  1426. fail:

  1427.     return ret;

  1428. }

  1429. 

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

  1431. {

  1432.     int ret = 0;

  1433.     JNIEnv *env = NULL;

  1434. 

  1435.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1436. 

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

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

  1439.         ret = AVERROR_EXTERNAL;

  1440.         goto fail;

  1441.     }

  1442. 

  1443. fail:

  1444.     return ret;

  1445. }

  1446. 

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

  1448. {

  1449.     int ret = 0;

  1450.     JNIEnv *env = NULL;

  1451. 

  1452.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1453. 

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

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

  1456.         ret = AVERROR_EXTERNAL;

  1457.         goto fail;

  1458.     }

  1459. 

  1460. fail:

  1461.     return ret;

  1462. }

  1463. 

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

  1465. {

  1466.     int ret = 0;

  1467.     JNIEnv *env = NULL;

  1468. 

  1469.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1470. 

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

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

  1473.         ret = AVERROR_EXTERNAL;

  1474.         goto fail;

  1475.     }

  1476. 

  1477. fail:

  1478.     return ret;

  1479. }

  1480. 

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

  1482. {

  1483.     int ret = 0;

  1484.     JNIEnv *env = NULL;

  1485. 

  1486.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1487. 

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

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

  1490.         ret = AVERROR_EXTERNAL;

  1491.         goto fail;

  1492.     }

  1493. 

  1494. fail:

  1495.     return ret;

  1496. }

  1497. 

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

  1499. {

  1500.     int ret = 0;

  1501.     JNIEnv *env = NULL;

  1502. 

  1503.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1504. 

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

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

  1507.         return AVERROR_EXTERNAL;

  1508.     }

  1509. 

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

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

  1512.         return AVERROR_EXTERNAL;

  1513.     }

  1514. 

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

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

  1517.         return AVERROR_EXTERNAL;

  1518.     }

  1519. 

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

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

  1522.         return AVERROR_EXTERNAL;

  1523.     }

  1524. 

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

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

  1527.         return AVERROR_EXTERNAL;

  1528.     }

  1529. 

  1530.     return ret;

  1531. }

  1532. 

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

  1534. {

  1535.     uint8_t *ret = NULL;

  1536.     JNIEnv *env = NULL;

  1537. 

  1538.     jobject buffer = NULL;

  1539.     jobject input_buffers = NULL;

  1540. 

  1541.     JNI_GET_ENV_OR_RETURN(env, codec, NULL);

  1542. 

  1543.     if (codec->has_get_i_o_buffer) {

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

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

  1546.             goto fail;

  1547.         }

  1548.     } else {

  1549.         if (!codec->input_buffers) {

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

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

  1552.                 goto fail;

  1553.             }

  1554. 

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

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

  1557.                 goto fail;

  1558.             }

  1559.         }

  1560. 

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

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

  1563.             goto fail;

  1564.         }

  1565.     }

  1566. 

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

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

  1569. fail:

  1570.     if (buffer) {

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

  1572.     }

  1573. 

  1574.     if (input_buffers) {

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

  1576.     }

  1577. 

  1578.     return ret;

  1579. }

  1580. 

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

  1582. {

  1583.     uint8_t *ret = NULL;

  1584.     JNIEnv *env = NULL;

  1585. 

  1586.     jobject buffer = NULL;

  1587.     jobject output_buffers = NULL;

  1588. 

  1589.     JNI_GET_ENV_OR_RETURN(env, codec, NULL);

  1590. 

  1591.     if (codec->has_get_i_o_buffer) {

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

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

  1594.             goto fail;

  1595.         }

  1596.     } else {

  1597.         if (!codec->output_buffers) {

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

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

  1600.                 goto fail;

  1601.             }

  1602. 

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

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

  1605.                 goto fail;

  1606.             }

  1607.         }

  1608. 

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

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

  1611.             goto fail;

  1612.         }

  1613.     }

  1614. 

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

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

  1617. fail:

  1618.     if (buffer) {

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

  1620.     }

  1621. 

  1622.     if (output_buffers) {

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

  1624.     }

  1625. 

  1626.     return ret;

  1627. }

  1628. 

  1629. FFAMediaFormat* ff_AMediaCodec_getOutputFormat(FFAMediaCodec* codec)

  1630. {

  1631.     FFAMediaFormat *ret = NULL;

  1632.     JNIEnv *env = NULL;

  1633. 

  1634.     jobject mediaformat = NULL;

  1635. 

  1636.     JNI_GET_ENV_OR_RETURN(env, codec, NULL);

  1637. 

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

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

  1640.         goto fail;

  1641.     }

  1642. 

  1643.     ret = ff_AMediaFormat_newFromObject(mediaformat);

  1644. fail:

  1645.     if (mediaformat) {

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

  1647.     }

  1648. 

  1649.     return ret;

  1650. }

  1651. 

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

  1653. {

  1654.     return idx == codec->INFO_TRY_AGAIN_LATER;

  1655. }

  1656. 

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

  1658. {

  1659.     return idx == codec->INFO_OUTPUT_BUFFERS_CHANGED;

  1660. }

  1661. 

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

  1663. {

  1664.     return idx == codec->INFO_OUTPUT_FORMAT_CHANGED;

  1665. }

  1666. 

  1667. int ff_AMediaCodec_getBufferFlagCodecConfig(FFAMediaCodec *codec)

  1668. {

  1669.     return codec->BUFFER_FLAG_CODEC_CONFIG;

  1670. }

  1671. 

  1672. int ff_AMediaCodec_getBufferFlagEndOfStream(FFAMediaCodec *codec)

  1673. {

  1674.     return codec->BUFFER_FLAG_END_OF_STREAM;

  1675. }

  1676. 

  1677. int ff_AMediaCodec_getBufferFlagKeyFrame(FFAMediaCodec *codec)

  1678. {

  1679.     return codec->BUFFER_FLAG_KEY_FRAME;

  1680. }

  1681. 

  1682. int ff_AMediaCodec_getConfigureFlagEncode(FFAMediaCodec *codec)

  1683. {

  1684.     return codec->CONFIGURE_FLAG_ENCODE;

  1685. }

  1686. 

  1687. int ff_AMediaCodec_cleanOutputBuffers(FFAMediaCodec *codec)

  1688. {

  1689.     int ret = 0;

  1690. 

  1691.     if (!codec->has_get_i_o_buffer) {

  1692.         if (codec->output_buffers) {

  1693.             JNIEnv *env = NULL;

  1694. 

  1695.             env = ff_jni_get_env(codec);

  1696.             if (!env) {

  1697.                 ret = AVERROR_EXTERNAL;

  1698.                 goto fail;

  1699.             }

  1700. 

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

  1702.             codec->output_buffers = NULL;

  1703.         }

  1704.     }

  1705. 

  1706. fail:

  1707.     return ret;

  1708. }

  1709. 

  1710. int ff_Build_SDK_INT(AVCodecContext *avctx)

  1711. {

  1712.     int ret = -1;

  1713.     JNIEnv *env = NULL;

  1714.     jclass versionClass;

  1715.     jfieldID sdkIntFieldID;

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

  1717. 

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

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

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

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

  1722.     return ret;

  1723. }