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

1740 lines
52KB
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 get_integer_id;

  115.     jmethodID get_long_id;

  116.     jmethodID get_float_id;

  117.     jmethodID get_bytebuffer_id;

  118.     jmethodID get_string_id;

  119. 

  120.     jmethodID set_integer_id;

  121.     jmethodID set_long_id;

  122.     jmethodID set_float_id;

  123.     jmethodID set_bytebuffer_id;

  124.     jmethodID set_string_id;

  125. 

  126.     jmethodID to_string_id;

  127. 

  128. };

  129. 

  130. static const struct FFJniField jni_amediaformat_mapping[] = {

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

  132. 

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

  134. 

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

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

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

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

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

  140. 

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

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

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

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

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

  146. 

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

  148. 

  149.     { NULL }

  150. };

  151. 

  152. static const AVClass amediaformat_class = {

  153.     .class_name = "amediaformat",

  154.     .item_name  = av_default_item_name,

  155.     .version    = LIBAVCODEC_VERSION_INT,

  156. };

  157. 

  158. struct FFAMediaFormat {

  159. 

  160.     const AVClass *class;

  161.     struct JNIAMediaFormatFields jfields;

  162.     jobject object;

  163. };

  164. 

  165. struct JNIAMediaCodecFields {

  166. 

  167.     jclass mediacodec_class;

  168. 

  169.     jfieldID info_try_again_later_id;

  170.     jfieldID info_output_buffers_changed_id;

  171.     jfieldID info_output_format_changed_id;

  172. 

  173.     jfieldID buffer_flag_codec_config_id;

  174.     jfieldID buffer_flag_end_of_stream_id;

  175.     jfieldID buffer_flag_key_frame_id;

  176. 

  177.     jfieldID configure_flag_encode_id;

  178. 

  179.     jmethodID create_by_codec_name_id;

  180.     jmethodID create_decoder_by_type_id;

  181.     jmethodID create_encoder_by_type_id;

  182. 

  183.     jmethodID get_name_id;

  184. 

  185.     jmethodID configure_id;

  186.     jmethodID start_id;

  187.     jmethodID flush_id;

  188.     jmethodID stop_id;

  189.     jmethodID release_id;

  190. 

  191.     jmethodID get_output_format_id;

  192. 

  193.     jmethodID dequeue_input_buffer_id;

  194.     jmethodID queue_input_buffer_id;

  195.     jmethodID get_input_buffer_id;

  196.     jmethodID get_input_buffers_id;

  197. 

  198.     jmethodID dequeue_output_buffer_id;

  199.     jmethodID get_output_buffer_id;

  200.     jmethodID get_output_buffers_id;

  201.     jmethodID release_output_buffer_id;

  202.     jmethodID release_output_buffer_at_time_id;

  203. 

  204.     jclass mediainfo_class;

  205. 

  206.     jmethodID init_id;

  207. 

  208.     jfieldID flags_id;

  209.     jfieldID offset_id;

  210.     jfieldID presentation_time_us_id;

  211.     jfieldID size_id;

  212. 

  213. };

  214. 

  215. static const struct FFJniField jni_amediacodec_mapping[] = {

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

  217. 

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

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

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

  221. 

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

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

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

  225. 

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

  227. 

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

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

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

  231. 

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

  233. 

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

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

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

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

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

  239. 

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

  241. 

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

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

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

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

  246. 

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

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

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

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

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

  252. 

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

  254. 

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

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

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

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

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

  260. 

  261.     { NULL }

  262. };

  263. 

  264. static const AVClass amediacodec_class = {

  265.     .class_name = "amediacodec",

  266.     .item_name  = av_default_item_name,

  267.     .version    = LIBAVCODEC_VERSION_INT,

  268. };

  269. 

  270. struct FFAMediaCodec {

  271. 

  272.     const AVClass *class;

  273. 

  274.     struct JNIAMediaCodecFields jfields;

  275. 

  276.     jobject object;

  277. 

  278.     jobject input_buffers;

  279.     jobject output_buffers;

  280. 

  281.     int INFO_TRY_AGAIN_LATER;

  282.     int INFO_OUTPUT_BUFFERS_CHANGED;

  283.     int INFO_OUTPUT_FORMAT_CHANGED;

  284. 

  285.     int BUFFER_FLAG_CODEC_CONFIG;

  286.     int BUFFER_FLAG_END_OF_STREAM;

  287.     int BUFFER_FLAG_KEY_FRAME;

  288. 

  289.     int CONFIGURE_FLAG_ENCODE;

  290. 

  291.     int has_get_i_o_buffer;

  292. };

  293. 

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

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

  296.     if (!(env)) {                                                  \

  297.         return ret;                                                \

  298.     }                                                              \

  299. } while (0)

  300. 

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

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

  303.     if (!(env)) {                                                  \

  304.         return;                                                    \

  305.     }                                                              \

  306. } while (0)

  307. 

  308. int ff_AMediaCodecProfile_getProfileFromAVCodecContext(AVCodecContext *avctx)

  309. {

  310.     int ret = -1;

  311. 

  312.     JNIEnv *env = NULL;

  313.     struct JNIAMediaCodecListFields jfields = { 0 };

  314.     jfieldID field_id = 0;

  315. 

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

  317. 

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

  319.         goto done;

  320.     }

  321. 

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

  323.         switch(avctx->profile) {

  324.         case FF_PROFILE_H264_BASELINE:

  325.         case FF_PROFILE_H264_CONSTRAINED_BASELINE:

  326.             field_id = jfields.avc_profile_baseline_id;

  327.             break;

  328.         case FF_PROFILE_H264_MAIN:

  329.             field_id = jfields.avc_profile_main_id;

  330.             break;

  331.         case FF_PROFILE_H264_EXTENDED:

  332.             field_id = jfields.avc_profile_extended_id;

  333.             break;

  334.         case FF_PROFILE_H264_HIGH:

  335.             field_id = jfields.avc_profile_high_id;

  336.             break;

  337.         case FF_PROFILE_H264_HIGH_10:

  338.         case FF_PROFILE_H264_HIGH_10_INTRA:

  339.             field_id = jfields.avc_profile_high10_id;

  340.             break;

  341.         case FF_PROFILE_H264_HIGH_422:

  342.         case FF_PROFILE_H264_HIGH_422_INTRA:

  343.             field_id = jfields.avc_profile_high422_id;

  344.             break;

  345.         case FF_PROFILE_H264_HIGH_444:

  346.         case FF_PROFILE_H264_HIGH_444_INTRA:

  347.         case FF_PROFILE_H264_HIGH_444_PREDICTIVE:

  348.             field_id = jfields.avc_profile_high444_id;

  349.             break;

  350.         }

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

  352.         switch (avctx->profile) {

  353.         case FF_PROFILE_HEVC_MAIN:

  354.         case FF_PROFILE_HEVC_MAIN_STILL_PICTURE:

  355.             field_id = jfields.hevc_profile_main_id;

  356.             break;

  357.         case FF_PROFILE_HEVC_MAIN_10:

  358.             field_id = jfields.hevc_profile_main10_id;

  359.             break;

  360.         }

  361.     }

  362. 

  363.         if (field_id) {

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

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

  366.                 ret = -1;

  367.                 goto done;

  368.             }

  369.         }

  370. 

  371. done:

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

  373. 

  374.     return ret;

  375. }

  376. 

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

  378. {

  379.     int ret;

  380.     int i;

  381.     int codec_count;

  382.     int found_codec = 0;

  383.     char *name = NULL;

  384.     char *supported_type = NULL;

  385. 

  386.     JNIEnv *env = NULL;

  387.     struct JNIAMediaCodecListFields jfields = { 0 };

  388.     struct JNIAMediaFormatFields mediaformat_jfields = { 0 };

  389. 

  390.     jobject format = NULL;

  391.     jobject codec = NULL;

  392.     jobject codec_name = NULL;

  393. 

  394.     jobject info = NULL;

  395.     jobject type = NULL;

  396.     jobjectArray types = NULL;

  397. 

  398.     jobject capabilities = NULL;

  399.     jobject profile_level = NULL;

  400.     jobjectArray profile_levels = NULL;

  401. 

  402.     JNI_GET_ENV_OR_RETURN(env, log_ctx, NULL);

  403. 

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

  405.         goto done;

  406.     }

  407. 

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

  409.         goto done;

  410.     }

  411. 

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

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

  414.         goto done;

  415.     }

  416. 

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

  418.         int j;

  419.         int type_count;

  420.         int is_encoder;

  421. 

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

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

  424.             goto done;

  425.         }

  426. 

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

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

  429.             goto done;

  430.         }

  431. 

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

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

  434.             goto done;

  435.         }

  436. 

  437.         if (is_encoder != encoder) {

  438.             goto done_with_info;

  439.         }

  440. 

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

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

  443.             int k;

  444.             int profile_count;

  445. 

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

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

  448.                 goto done;

  449.             }

  450. 

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

  452.             if (!supported_type) {

  453.                 goto done;

  454.             }

  455. 

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

  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 (strstr(name, "OMX.google")) {

  468.                     av_freep(&name);

  469.                     goto done_with_type;

  470.                 }

  471. 

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

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

  474.                     goto done;

  475.                 }

  476. 

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

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

  479.                     goto done;

  480.                 }

  481. 

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

  483.                 if (!profile_count) {

  484.                     found_codec = 1;

  485.                 }

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

  487.                     int supported_profile = 0;

  488. 

  489.                     if (profile < 0) {

  490.                         found_codec = 1;

  491.                         break;

  492.                     }

  493. 

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

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

  496.                         goto done;

  497.                     }

  498. 

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

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

  501.                         goto done;

  502.                     }

  503. 

  504.                     found_codec = profile == supported_profile;

  505. 

  506.                     if (profile_level) {

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

  508.                         profile_level = NULL;

  509.                     }

  510. 

  511.                     if (found_codec) {

  512.                         break;

  513.                     }

  514.                 }

  515.             }

  516. 

  517. done_with_type:

  518.             if (profile_levels) {

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

  520.                 profile_levels = NULL;

  521.             }

  522. 

  523.             if (capabilities) {

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

  525.                 capabilities = NULL;

  526.             }

  527. 

  528.             if (type) {

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

  530.                 type = NULL;

  531.             }

  532. 

  533.             av_freep(&supported_type);

  534. 

  535.             if (found_codec) {

  536.                 break;

  537.             }

  538. 

  539.             av_freep(&name);

  540.         }

  541. 

  542. done_with_info:

  543.         if (info) {

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

  545.             info = NULL;

  546.         }

  547. 

  548.         if (types) {

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

  550.             types = NULL;

  551.         }

  552. 

  553.         if (found_codec) {

  554.             break;

  555.         }

  556.     }

  557. 

  558. done:

  559.     if (format) {

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

  561.     }

  562. 

  563.     if (codec) {

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

  565.     }

  566. 

  567.     if (codec_name) {

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

  569.     }

  570. 

  571.     if (info) {

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

  573.     }

  574. 

  575.     if (type) {

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

  577.     }

  578. 

  579.     if (types) {

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

  581.     }

  582. 

  583.     if (capabilities) {

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

  585.     }

  586. 

  587.     if (profile_level) {

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

  589.     }

  590. 

  591.     if (profile_levels) {

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

  593.     }

  594. 

  595.     av_freep(&supported_type);

  596. 

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

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

  599. 

  600.     if (!found_codec) {

  601.         av_freep(&name);

  602.     }

  603. 

  604.     return name;

  605. }

  606. 

  607. FFAMediaFormat *ff_AMediaFormat_new(void)

  608. {

  609.     JNIEnv *env = NULL;

  610.     FFAMediaFormat *format = NULL;

  611.     jobject object = NULL;

  612. 

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

  614.     if (!format) {

  615.         return NULL;

  616.     }

  617.     format->class = &amediaformat_class;

  618. 

  619.     env = ff_jni_get_env(format);

  620.     if (!env) {

  621.         av_freep(&format);

  622.         return NULL;

  623.     }

  624. 

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

  626.         goto fail;

  627.     }

  628. 

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

  630.     if (!object) {

  631.         goto fail;

  632.     }

  633. 

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

  635.     if (!format->object) {

  636.         goto fail;

  637.     }

  638. 

  639. fail:

  640.     if (object) {

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

  642.     }

  643. 

  644.     if (!format->object) {

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

  646.         av_freep(&format);

  647.     }

  648. 

  649.     return format;

  650. }

  651. 

  652. static FFAMediaFormat *ff_AMediaFormat_newFromObject(void *object)

  653. {

  654.     JNIEnv *env = NULL;

  655.     FFAMediaFormat *format = NULL;

  656. 

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

  658.     if (!format) {

  659.         return NULL;

  660.     }

  661.     format->class = &amediaformat_class;

  662. 

  663.     env = ff_jni_get_env(format);

  664.     if (!env) {

  665.         av_freep(&format);

  666.         return NULL;

  667.     }

  668. 

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

  670.         goto fail;

  671.     }

  672. 

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

  674.     if (!format->object) {

  675.         goto fail;

  676.     }

  677. 

  678.     return format;

  679. fail:

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

  681. 

  682.     av_freep(&format);

  683. 

  684.     return NULL;

  685. }

  686. 

  687. int ff_AMediaFormat_delete(FFAMediaFormat* format)

  688. {

  689.     int ret = 0;

  690. 

  691.     JNIEnv *env = NULL;

  692. 

  693.     if (!format) {

  694.         return 0;

  695.     }

  696. 

  697.     JNI_GET_ENV_OR_RETURN(env, format, AVERROR_EXTERNAL);

  698. 

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

  700.     format->object = NULL;

  701. 

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

  703. 

  704.     av_freep(&format);

  705. 

  706.     return ret;

  707. }

  708. 

  709. char* ff_AMediaFormat_toString(FFAMediaFormat* format)

  710. {

  711.     char *ret = NULL;

  712. 

  713.     JNIEnv *env = NULL;

  714.     jstring description = NULL;

  715. 

  716.     av_assert0(format != NULL);

  717. 

  718.     JNI_GET_ENV_OR_RETURN(env, format, NULL);

  719. 

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

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

  722.         goto fail;

  723.     }

  724. 

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

  726. fail:

  727.     if (description) {

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

  729.     }

  730. 

  731.     return ret;

  732. }

  733. 

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

  735. {

  736.     int ret = 1;

  737. 

  738.     JNIEnv *env = NULL;

  739.     jstring key = NULL;

  740. 

  741.     av_assert0(format != NULL);

  742. 

  743.     JNI_GET_ENV_OR_RETURN(env, format, 0);

  744. 

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

  746.     if (!key) {

  747.         ret = 0;

  748.         goto fail;

  749.     }

  750. 

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

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

  753.         ret = 0;

  754.         goto fail;

  755.     }

  756. 

  757.     ret = 1;

  758. fail:

  759.     if (key) {

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

  761.     }

  762. 

  763.     return ret;

  764. }

  765. 

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

  767. {

  768.     int ret = 1;

  769. 

  770.     JNIEnv *env = NULL;

  771.     jstring key = NULL;

  772. 

  773.     av_assert0(format != NULL);

  774. 

  775.     JNI_GET_ENV_OR_RETURN(env, format, 0);

  776. 

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

  778.     if (!key) {

  779.         ret = 0;

  780.         goto fail;

  781.     }

  782. 

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

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

  785.         ret = 0;

  786.         goto fail;

  787.     }

  788. 

  789.     ret = 1;

  790. fail:

  791.     if (key) {

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

  793.     }

  794. 

  795.     return ret;

  796. }

  797. 

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

  799. {

  800.     int ret = 1;

  801. 

  802.     JNIEnv *env = NULL;

  803.     jstring key = NULL;

  804. 

  805.     av_assert0(format != NULL);

  806. 

  807.     JNI_GET_ENV_OR_RETURN(env, format, 0);

  808. 

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

  810.     if (!key) {

  811.         ret = 0;

  812.         goto fail;

  813.     }

  814. 

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

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

  817.         ret = 0;

  818.         goto fail;

  819.     }

  820. 

  821.     ret = 1;

  822. fail:

  823.     if (key) {

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

  825.     }

  826. 

  827.     return ret;

  828. }

  829. 

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

  831. {

  832.     int ret = 1;

  833. 

  834.     JNIEnv *env = NULL;

  835.     jstring key = NULL;

  836.     jobject result = NULL;

  837. 

  838.     av_assert0(format != NULL);

  839. 

  840.     JNI_GET_ENV_OR_RETURN(env, format, 0);

  841. 

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

  843.     if (!key) {

  844.         ret = 0;

  845.         goto fail;

  846.     }

  847. 

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

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

  850.         ret = 0;

  851.         goto fail;

  852.     }

  853. 

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

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

  856. 

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

  858.         void *src = *data;

  859.         *data = av_malloc(*size);

  860.         if (!*data) {

  861.             ret = 0;

  862.             goto fail;

  863.         }

  864. 

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

  866.     }

  867. 

  868.     ret = 1;

  869. fail:

  870.     if (key) {

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

  872.     }

  873. 

  874.     if (result) {

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

  876.     }

  877. 

  878.     return ret;

  879. }

  880. 

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

  882. {

  883.     int ret = 1;

  884. 

  885.     JNIEnv *env = NULL;

  886.     jstring key = NULL;

  887.     jstring result = NULL;

  888. 

  889.     av_assert0(format != NULL);

  890. 

  891.     JNI_GET_ENV_OR_RETURN(env, format, 0);

  892. 

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

  894.     if (!key) {

  895.         ret = 0;

  896.         goto fail;

  897.     }

  898. 

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

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

  901.         ret = 0;

  902.         goto fail;

  903.     }

  904. 

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

  906.     if (!*out) {

  907.         ret = 0;

  908.         goto fail;

  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. void ff_AMediaFormat_setInt32(FFAMediaFormat* format, const char* name, int32_t value)

  925. {

  926.     JNIEnv *env = NULL;

  927.     jstring key = NULL;

  928. 

  929.     av_assert0(format != NULL);

  930. 

  931.     JNI_GET_ENV_OR_RETURN_VOID(env, format);

  932. 

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

  934.     if (!key) {

  935.         goto fail;

  936.     }

  937. 

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

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

  940.         goto fail;

  941.     }

  942. 

  943. fail:

  944.     if (key) {

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

  946.     }

  947. }

  948. 

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

  950. {

  951.     JNIEnv *env = NULL;

  952.     jstring key = NULL;

  953. 

  954.     av_assert0(format != NULL);

  955. 

  956.     JNI_GET_ENV_OR_RETURN_VOID(env, format);

  957. 

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

  959.     if (!key) {

  960.         goto fail;

  961.     }

  962. 

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

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

  965.         goto fail;

  966.     }

  967. 

  968. fail:

  969.     if (key) {

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

  971.     }

  972. }

  973. 

  974. void ff_AMediaFormat_setFloat(FFAMediaFormat* format, const char* name, float 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_float_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_setString(FFAMediaFormat* format, const char* name, const char* value)

  1000. {

  1001.     JNIEnv *env = NULL;

  1002.     jstring key = NULL;

  1003.     jstring string = NULL;

  1004. 

  1005.     av_assert0(format != NULL);

  1006. 

  1007.     JNI_GET_ENV_OR_RETURN_VOID(env, format);

  1008. 

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

  1010.     if (!key) {

  1011.         goto fail;

  1012.     }

  1013. 

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

  1015.     if (!string) {

  1016.         goto fail;

  1017.     }

  1018. 

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

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

  1021.         goto fail;

  1022.     }

  1023. 

  1024. fail:

  1025.     if (key) {

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

  1027.     }

  1028. 

  1029.     if (string) {

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

  1031.     }

  1032. }

  1033. 

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

  1035. {

  1036.     JNIEnv *env = NULL;

  1037.     jstring key = NULL;

  1038.     jobject buffer = NULL;

  1039.     void *buffer_data = NULL;

  1040. 

  1041.     av_assert0(format != NULL);

  1042. 

  1043.     JNI_GET_ENV_OR_RETURN_VOID(env, format);

  1044. 

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

  1046.     if (!key) {

  1047.         goto fail;

  1048.     }

  1049. 

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

  1051.         goto fail;

  1052.     }

  1053. 

  1054.     buffer_data = av_malloc(size);

  1055.     if (!buffer_data) {

  1056.         goto fail;

  1057.     }

  1058. 

  1059.     memcpy(buffer_data, data, size);

  1060. 

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

  1062.     if (!buffer) {

  1063.         goto fail;

  1064.     }

  1065. 

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

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

  1068.         goto fail;

  1069.     }

  1070. 

  1071. fail:

  1072.     if (key) {

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

  1074.     }

  1075. 

  1076.     if (buffer) {

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

  1078.     }

  1079. }

  1080. 

  1081. static int codec_init_static_fields(FFAMediaCodec *codec)

  1082. {

  1083.     int ret = 0;

  1084.     JNIEnv *env = NULL;

  1085. 

  1086.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1087. 

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

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

  1090.         goto fail;

  1091.     }

  1092. 

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

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

  1095.         goto fail;

  1096.     }

  1097. 

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

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

  1100.         goto fail;

  1101.     }

  1102. 

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

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

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

  1106.             goto fail;

  1107.         }

  1108.     }

  1109. 

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

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

  1112.         goto fail;

  1113.     }

  1114. 

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

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

  1117.         goto fail;

  1118.     }

  1119. 

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

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

  1122.         goto fail;

  1123.     }

  1124. 

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

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

  1127.         goto fail;

  1128.     }

  1129. 

  1130. fail:

  1131. 

  1132.     return ret;

  1133. }

  1134. 

  1135. FFAMediaCodec* ff_AMediaCodec_createCodecByName(const char *name)

  1136. {

  1137.     int ret = -1;

  1138.     JNIEnv *env = NULL;

  1139.     FFAMediaCodec *codec = NULL;

  1140.     jstring codec_name = NULL;

  1141.     jobject object = NULL;

  1142. 

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

  1144.     if (!codec) {

  1145.         return NULL;

  1146.     }

  1147.     codec->class = &amediacodec_class;

  1148. 

  1149.     env = ff_jni_get_env(codec);

  1150.     if (!env) {

  1151.         av_freep(&codec);

  1152.         return NULL;

  1153.     }

  1154. 

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

  1156.         goto fail;

  1157.     }

  1158. 

  1159.     codec_name = ff_jni_utf_chars_to_jstring(env, name, codec);

  1160.     if (!codec_name) {

  1161.         goto fail;

  1162.     }

  1163. 

  1164.     object = (*env)->CallStaticObjectMethod(env, codec->jfields.mediacodec_class, codec->jfields.create_by_codec_name_id, codec_name);

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

  1166.         goto fail;

  1167.     }

  1168. 

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

  1170.     if (!codec->object) {

  1171.         goto fail;

  1172.     }

  1173. 

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

  1175.         goto fail;

  1176.     }

  1177. 

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

  1179.         codec->has_get_i_o_buffer = 1;

  1180.     }

  1181. 

  1182.     ret = 0;

  1183. fail:

  1184.     if (codec_name) {

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

  1186.     }

  1187. 

  1188.     if (object) {

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

  1190.     }

  1191. 

  1192.     if (ret < 0) {

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

  1194.         av_freep(&codec);

  1195.     }

  1196. 

  1197.     return codec;

  1198. }

  1199. 

  1200. FFAMediaCodec* ff_AMediaCodec_createDecoderByType(const char *mime)

  1201. {

  1202.     int ret = -1;

  1203.     JNIEnv *env = NULL;

  1204.     FFAMediaCodec *codec = NULL;

  1205.     jstring mime_type = NULL;

  1206.     jobject object = NULL;

  1207. 

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

  1209.     if (!codec) {

  1210.         return NULL;

  1211.     }

  1212.     codec->class = &amediacodec_class;

  1213. 

  1214.     env = ff_jni_get_env(codec);

  1215.     if (!env) {

  1216.         av_freep(&codec);

  1217.         return NULL;

  1218.     }

  1219. 

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

  1221.         goto fail;

  1222.     }

  1223. 

  1224.     mime_type = ff_jni_utf_chars_to_jstring(env, mime, codec);

  1225.     if (!mime_type) {

  1226.         goto fail;

  1227.     }

  1228. 

  1229.     object = (*env)->CallStaticObjectMethod(env, codec->jfields.mediacodec_class, codec->jfields.create_decoder_by_type_id, mime_type);

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

  1231.         goto fail;

  1232.     }

  1233. 

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

  1235.     if (!codec->object) {

  1236.         goto fail;

  1237.     }

  1238. 

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

  1240.         goto fail;

  1241.     }

  1242. 

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

  1244.         codec->has_get_i_o_buffer = 1;

  1245.     }

  1246. 

  1247.     ret = 0;

  1248. fail:

  1249.     if (mime_type) {

  1250.         (*env)->DeleteLocalRef(env, mime_type);

  1251.     }

  1252. 

  1253.     if (object) {

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

  1255.     }

  1256. 

  1257.     if (ret < 0) {

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

  1259.         av_freep(&codec);

  1260.     }

  1261. 

  1262.     return codec;

  1263. }

  1264. 

  1265. FFAMediaCodec* ff_AMediaCodec_createEncoderByType(const char *mime)

  1266. {

  1267.     int ret = -1;

  1268.     JNIEnv *env = NULL;

  1269.     FFAMediaCodec *codec = NULL;

  1270.     jstring mime_type = NULL;

  1271.     jobject object = NULL;

  1272. 

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

  1274.     if (!codec) {

  1275.         return NULL;

  1276.     }

  1277.     codec->class = &amediacodec_class;

  1278. 

  1279.     env = ff_jni_get_env(codec);

  1280.     if (!env) {

  1281.         av_freep(&codec);

  1282.         return NULL;

  1283.     }

  1284. 

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

  1286.         goto fail;

  1287.     }

  1288. 

  1289.     mime_type = ff_jni_utf_chars_to_jstring(env, mime, codec);

  1290.     if (!mime_type) {

  1291.         goto fail;

  1292.     }

  1293. 

  1294.     object = (*env)->CallStaticObjectMethod(env, codec->jfields.mediacodec_class, codec->jfields.create_encoder_by_type_id, mime_type);

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

  1296.         goto fail;

  1297.     }

  1298. 

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

  1300.     if (!codec->object) {

  1301.         goto fail;

  1302.     }

  1303. 

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

  1305.         goto fail;

  1306.     }

  1307. 

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

  1309.         codec->has_get_i_o_buffer = 1;

  1310.     }

  1311. 

  1312.     ret = 0;

  1313. fail:

  1314.     if (mime_type) {

  1315.         (*env)->DeleteLocalRef(env, mime_type);

  1316.     }

  1317. 

  1318.     if (object) {

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

  1320.     }

  1321. 

  1322.     if  (ret < 0) {

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

  1324.         av_freep(&codec);

  1325.     }

  1326. 

  1327.     return codec;

  1328. }

  1329. 

  1330. int ff_AMediaCodec_delete(FFAMediaCodec* codec)

  1331. {

  1332.     int ret = 0;

  1333. 

  1334.     JNIEnv *env = NULL;

  1335. 

  1336.     if (!codec) {

  1337.         return 0;

  1338.     }

  1339. 

  1340.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1341. 

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

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

  1344.         ret = AVERROR_EXTERNAL;

  1345.     }

  1346. 

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

  1348.     codec->object = NULL;

  1349. 

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

  1351. 

  1352.     av_freep(&codec);

  1353. 

  1354.     return ret;

  1355. }

  1356. 

  1357. char *ff_AMediaCodec_getName(FFAMediaCodec *codec)

  1358. {

  1359.     char *ret = NULL;

  1360.     JNIEnv *env = NULL;

  1361.     jobject *name = NULL;

  1362. 

  1363.     JNI_GET_ENV_OR_RETURN(env, codec, NULL);

  1364. 

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

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

  1367.         goto fail;

  1368.     }

  1369. 

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

  1371. 

  1372. fail:

  1373.     return ret;

  1374. }

  1375. 

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

  1377. {

  1378.     int ret = 0;

  1379.     JNIEnv *env = NULL;

  1380. 

  1381.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1382. 

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

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

  1385.         ret = AVERROR_EXTERNAL;

  1386.         goto fail;

  1387.     }

  1388. 

  1389. fail:

  1390.     return ret;

  1391. }

  1392. 

  1393. int ff_AMediaCodec_start(FFAMediaCodec* codec)

  1394. {

  1395.     int ret = 0;

  1396.     JNIEnv *env = NULL;

  1397. 

  1398.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1399. 

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

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

  1402.         ret = AVERROR_EXTERNAL;

  1403.         goto fail;

  1404.     }

  1405. 

  1406. fail:

  1407.     return ret;

  1408. }

  1409. 

  1410. int ff_AMediaCodec_stop(FFAMediaCodec* codec)

  1411. {

  1412.     int ret = 0;

  1413.     JNIEnv *env = NULL;

  1414. 

  1415.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1416. 

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

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

  1419.         ret = AVERROR_EXTERNAL;

  1420.         goto fail;

  1421.     }

  1422. 

  1423. fail:

  1424.     return ret;

  1425. }

  1426. 

  1427. int ff_AMediaCodec_flush(FFAMediaCodec* codec)

  1428. {

  1429.     int ret = 0;

  1430.     JNIEnv *env = NULL;

  1431. 

  1432.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1433. 

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

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

  1436.         ret = AVERROR_EXTERNAL;

  1437.         goto fail;

  1438.     }

  1439. 

  1440. fail:

  1441.     return ret;

  1442. }

  1443. 

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

  1445. {

  1446.     int ret = 0;

  1447.     JNIEnv *env = NULL;

  1448. 

  1449.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1450. 

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

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

  1453.         ret = AVERROR_EXTERNAL;

  1454.         goto fail;

  1455.     }

  1456. 

  1457. fail:

  1458.     return ret;

  1459. }

  1460. 

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

  1462. {

  1463.     int ret = 0;

  1464.     JNIEnv *env = NULL;

  1465. 

  1466.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1467. 

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

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

  1470.         ret = AVERROR_EXTERNAL;

  1471.         goto fail;

  1472.     }

  1473. 

  1474. fail:

  1475.     return ret;

  1476. }

  1477. 

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

  1479. {

  1480.     int ret = 0;

  1481.     JNIEnv *env = NULL;

  1482. 

  1483.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1484. 

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

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

  1487.         ret = AVERROR_EXTERNAL;

  1488.         goto fail;

  1489.     }

  1490. 

  1491. fail:

  1492.     return ret;

  1493. }

  1494. 

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

  1496. {

  1497.     int ret = 0;

  1498.     JNIEnv *env = NULL;

  1499. 

  1500.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1501. 

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

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

  1504.         ret = AVERROR_EXTERNAL;

  1505.         goto fail;

  1506.     }

  1507. 

  1508. fail:

  1509.     return ret;

  1510. }

  1511. 

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

  1513. {

  1514.     int ret = 0;

  1515.     JNIEnv *env = NULL;

  1516. 

  1517.     jobject mediainfo = NULL;

  1518. 

  1519.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1520. 

  1521.     mediainfo = (*env)->NewObject(env, codec->jfields.mediainfo_class, codec->jfields.init_id);

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

  1523.         ret = AVERROR_EXTERNAL;

  1524.         goto fail;

  1525.     }

  1526. 

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

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

  1529.         ret = AVERROR_EXTERNAL;

  1530.         goto fail;

  1531.     }

  1532. 

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

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

  1535.         ret = AVERROR_EXTERNAL;

  1536.         goto fail;

  1537.     }

  1538. 

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

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

  1541.         ret = AVERROR_EXTERNAL;

  1542.         goto fail;

  1543.     }

  1544. 

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

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

  1547.         ret = AVERROR_EXTERNAL;

  1548.         goto fail;

  1549.     }

  1550. 

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

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

  1553.         ret = AVERROR_EXTERNAL;

  1554.         goto fail;

  1555.     }

  1556. fail:

  1557.     if (mediainfo) {

  1558.         (*env)->DeleteLocalRef(env, mediainfo);

  1559.     }

  1560. 

  1561.     return ret;

  1562. }

  1563. 

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

  1565. {

  1566.     uint8_t *ret = NULL;

  1567.     JNIEnv *env = NULL;

  1568. 

  1569.     jobject buffer = NULL;

  1570.     jobject input_buffers = NULL;

  1571. 

  1572.     JNI_GET_ENV_OR_RETURN(env, codec, NULL);

  1573. 

  1574.     if (codec->has_get_i_o_buffer) {

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

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

  1577.             goto fail;

  1578.         }

  1579.     } else {

  1580.         if (!codec->input_buffers) {

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

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

  1583.                 goto fail;

  1584.             }

  1585. 

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

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

  1588.                 goto fail;

  1589.             }

  1590.         }

  1591. 

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

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

  1594.             goto fail;

  1595.         }

  1596.     }

  1597. 

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

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

  1600. fail:

  1601.     if (buffer) {

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

  1603.     }

  1604. 

  1605.     if (input_buffers) {

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

  1607.     }

  1608. 

  1609.     return ret;

  1610. }

  1611. 

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

  1613. {

  1614.     uint8_t *ret = NULL;

  1615.     JNIEnv *env = NULL;

  1616. 

  1617.     jobject buffer = NULL;

  1618.     jobject output_buffers = NULL;

  1619. 

  1620.     JNI_GET_ENV_OR_RETURN(env, codec, NULL);

  1621. 

  1622.     if (codec->has_get_i_o_buffer) {

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

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

  1625.             goto fail;

  1626.         }

  1627.     } else {

  1628.         if (!codec->output_buffers) {

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

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

  1631.                 goto fail;

  1632.             }

  1633. 

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

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

  1636.                 goto fail;

  1637.             }

  1638.         }

  1639. 

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

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

  1642.             goto fail;

  1643.         }

  1644.     }

  1645. 

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

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

  1648. fail:

  1649.     if (buffer) {

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

  1651.     }

  1652. 

  1653.     if (output_buffers) {

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

  1655.     }

  1656. 

  1657.     return ret;

  1658. }

  1659. 

  1660. FFAMediaFormat* ff_AMediaCodec_getOutputFormat(FFAMediaCodec* codec)

  1661. {

  1662.     FFAMediaFormat *ret = NULL;

  1663.     JNIEnv *env = NULL;

  1664. 

  1665.     jobject mediaformat = NULL;

  1666. 

  1667.     JNI_GET_ENV_OR_RETURN(env, codec, NULL);

  1668. 

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

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

  1671.         goto fail;

  1672.     }

  1673. 

  1674.     ret = ff_AMediaFormat_newFromObject(mediaformat);

  1675. fail:

  1676.     if (mediaformat) {

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

  1678.     }

  1679. 

  1680.     return ret;

  1681. }

  1682. 

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

  1684. {

  1685.     return idx == codec->INFO_TRY_AGAIN_LATER;

  1686. }

  1687. 

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

  1689. {

  1690.     return idx == codec->INFO_OUTPUT_BUFFERS_CHANGED;

  1691. }

  1692. 

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

  1694. {

  1695.     return idx == codec->INFO_OUTPUT_FORMAT_CHANGED;

  1696. }

  1697. 

  1698. int ff_AMediaCodec_getBufferFlagCodecConfig(FFAMediaCodec *codec)

  1699. {

  1700.     return codec->BUFFER_FLAG_CODEC_CONFIG;

  1701. }

  1702. 

  1703. int ff_AMediaCodec_getBufferFlagEndOfStream(FFAMediaCodec *codec)

  1704. {

  1705.     return codec->BUFFER_FLAG_END_OF_STREAM;

  1706. }

  1707. 

  1708. int ff_AMediaCodec_getBufferFlagKeyFrame(FFAMediaCodec *codec)

  1709. {

  1710.     return codec->BUFFER_FLAG_KEY_FRAME;

  1711. }

  1712. 

  1713. int ff_AMediaCodec_getConfigureFlagEncode(FFAMediaCodec *codec)

  1714. {

  1715.     return codec->CONFIGURE_FLAG_ENCODE;

  1716. }

  1717. 

  1718. int ff_AMediaCodec_cleanOutputBuffers(FFAMediaCodec *codec)

  1719. {

  1720.     int ret = 0;

  1721. 

  1722.     if (!codec->has_get_i_o_buffer) {

  1723.         if (codec->output_buffers) {

  1724.             JNIEnv *env = NULL;

  1725. 

  1726.             env = ff_jni_get_env(codec);

  1727.             if (!env) {

  1728.                 ret = AVERROR_EXTERNAL;

  1729.                 goto fail;

  1730.             }

  1731. 

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

  1733.             codec->output_buffers = NULL;

  1734.         }

  1735.     }

  1736. 

  1737. fail:

  1738.     return ret;

  1739. }