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

1684 lines
50KB
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. } JNIAMediaCodecListFields;

  66. 

  67. static const struct FFJniField jni_amediacodeclist_mapping[] = {

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

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

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

  71. 

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

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

  74. 

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

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

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

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

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

  80. 

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

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

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

  84. 

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

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

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

  88. 

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

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

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

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

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

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

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

  96. 

  97.     { NULL }

  98. };

  99. 

  100. struct JNIAMediaFormatFields {

  101. 

  102.     jclass mediaformat_class;

  103. 

  104.     jmethodID init_id;

  105. 

  106.     jmethodID get_integer_id;

  107.     jmethodID get_long_id;

  108.     jmethodID get_float_id;

  109.     jmethodID get_bytebuffer_id;

  110.     jmethodID get_string_id;

  111. 

  112.     jmethodID set_integer_id;

  113.     jmethodID set_long_id;

  114.     jmethodID set_float_id;

  115.     jmethodID set_bytebuffer_id;

  116.     jmethodID set_string_id;

  117. 

  118.     jmethodID to_string_id;

  119. 

  120. } JNIAMediaFormatFields;

  121. 

  122. static const struct FFJniField jni_amediaformat_mapping[] = {

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

  124. 

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

  126. 

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

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

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

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

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

  132. 

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

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

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

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

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

  138. 

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

  140. 

  141.     { NULL }

  142. };

  143. 

  144. static const AVClass amediaformat_class = {

  145.     .class_name = "amediaformat",

  146.     .item_name  = av_default_item_name,

  147.     .version    = LIBAVCODEC_VERSION_INT,

  148. };

  149. 

  150. struct FFAMediaFormat {

  151. 

  152.     const AVClass *class;

  153.     struct JNIAMediaFormatFields jfields;

  154.     jobject object;

  155. };

  156. 

  157. struct JNIAMediaCodecFields {

  158. 

  159.     jclass mediacodec_class;

  160. 

  161.     jfieldID info_try_again_later_id;

  162.     jfieldID info_output_buffers_changed_id;

  163.     jfieldID info_output_format_changed_id;

  164. 

  165.     jfieldID buffer_flag_codec_config_id;

  166.     jfieldID buffer_flag_end_of_stream_id;

  167.     jfieldID buffer_flag_key_frame_id;

  168. 

  169.     jfieldID configure_flag_encode_id;

  170. 

  171.     jmethodID create_by_codec_name_id;

  172.     jmethodID create_decoder_by_type_id;

  173.     jmethodID create_encoder_by_type_id;

  174. 

  175.     jmethodID get_name_id;

  176. 

  177.     jmethodID configure_id;

  178.     jmethodID start_id;

  179.     jmethodID flush_id;

  180.     jmethodID stop_id;

  181.     jmethodID release_id;

  182. 

  183.     jmethodID get_output_format_id;

  184. 

  185.     jmethodID dequeue_input_buffer_id;

  186.     jmethodID queue_input_buffer_id;

  187.     jmethodID get_input_buffer_id;

  188.     jmethodID get_input_buffers_id;

  189. 

  190.     jmethodID dequeue_output_buffer_id;

  191.     jmethodID get_output_buffer_id;

  192.     jmethodID get_output_buffers_id;

  193.     jmethodID release_output_buffer_id;

  194.     jmethodID release_output_buffer_at_time_id;

  195. 

  196.     jclass mediainfo_class;

  197. 

  198.     jmethodID init_id;

  199. 

  200.     jfieldID flags_id;

  201.     jfieldID offset_id;

  202.     jfieldID presentation_time_us_id;

  203.     jfieldID size_id;

  204. 

  205. } JNIAMediaCodecFields;

  206. 

  207. static const struct FFJniField jni_amediacodec_mapping[] = {

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

  209. 

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

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

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

  213. 

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

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

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

  217. 

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

  219. 

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

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

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

  223. 

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

  225. 

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

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

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

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

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

  231. 

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

  233. 

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

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

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

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

  238. 

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

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

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

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

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

  244. 

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

  246. 

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

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

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

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

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

  252. 

  253.     { NULL }

  254. };

  255. 

  256. static const AVClass amediacodec_class = {

  257.     .class_name = "amediacodec",

  258.     .item_name  = av_default_item_name,

  259.     .version    = LIBAVCODEC_VERSION_INT,

  260. };

  261. 

  262. struct FFAMediaCodec {

  263. 

  264.     const AVClass *class;

  265. 

  266.     struct JNIAMediaCodecFields jfields;

  267. 

  268.     jobject object;

  269. 

  270.     jobject input_buffers;

  271.     jobject output_buffers;

  272. 

  273.     int INFO_TRY_AGAIN_LATER;

  274.     int INFO_OUTPUT_BUFFERS_CHANGED;

  275.     int INFO_OUTPUT_FORMAT_CHANGED;

  276. 

  277.     int BUFFER_FLAG_CODEC_CONFIG;

  278.     int BUFFER_FLAG_END_OF_STREAM;

  279.     int BUFFER_FLAG_KEY_FRAME;

  280. 

  281.     int CONFIGURE_FLAG_ENCODE;

  282. 

  283.     int has_get_i_o_buffer;

  284. };

  285. 

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

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

  288.     if (!(env)) {                                                  \

  289.         return ret;                                                \

  290.     }                                                              \

  291. } while (0)

  292. 

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

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

  295.     if (!(env)) {                                                  \

  296.         return;                                                    \

  297.     }                                                              \

  298. } while (0)

  299. 

  300. int ff_AMediaCodecProfile_getProfileFromAVCodecContext(AVCodecContext *avctx)

  301. {

  302.     int ret = -1;

  303. 

  304.     JNIEnv *env = NULL;

  305.     struct JNIAMediaCodecListFields jfields = { 0 };

  306. 

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

  308. 

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

  310.         goto done;

  311.     }

  312. 

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

  314.         jfieldID field_id = 0;

  315. 

  316.         switch(avctx->profile) {

  317.         case FF_PROFILE_H264_BASELINE:

  318.         case FF_PROFILE_H264_CONSTRAINED_BASELINE:

  319.             field_id = jfields.avc_profile_baseline_id;

  320.             break;

  321.         case FF_PROFILE_H264_MAIN:

  322.             field_id = jfields.avc_profile_main_id;

  323.             break;

  324.         case FF_PROFILE_H264_EXTENDED:

  325.             field_id = jfields.avc_profile_extended_id;

  326.             break;

  327.         case FF_PROFILE_H264_HIGH:

  328.             field_id = jfields.avc_profile_high_id;

  329.             break;

  330.         case FF_PROFILE_H264_HIGH_10:

  331.         case FF_PROFILE_H264_HIGH_10_INTRA:

  332.             field_id = jfields.avc_profile_high10_id;

  333.             break;

  334.         case FF_PROFILE_H264_HIGH_422:

  335.         case FF_PROFILE_H264_HIGH_422_INTRA:

  336.             field_id = jfields.avc_profile_high422_id;

  337.             break;

  338.         case FF_PROFILE_H264_HIGH_444:

  339.         case FF_PROFILE_H264_HIGH_444_INTRA:

  340.         case FF_PROFILE_H264_HIGH_444_PREDICTIVE:

  341.             field_id = jfields.avc_profile_high444_id;

  342.             break;

  343.         }

  344. 

  345.         if (field_id) {

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

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

  348.                 ret = -1;

  349.                 goto done;

  350.             }

  351.         }

  352.     }

  353. 

  354. done:

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

  356. 

  357.     return ret;

  358. }

  359. 

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

  361. {

  362.     int ret;

  363.     int i;

  364.     int codec_count;

  365.     int found_codec = 0;

  366.     char *name = NULL;

  367.     char *supported_type = NULL;

  368. 

  369.     JNIEnv *env = NULL;

  370.     struct JNIAMediaCodecListFields jfields = { 0 };

  371.     struct JNIAMediaFormatFields mediaformat_jfields = { 0 };

  372. 

  373.     jobject format = NULL;

  374.     jobject codec = NULL;

  375.     jobject codec_name = NULL;

  376. 

  377.     jobject info = NULL;

  378.     jobject type = NULL;

  379.     jobjectArray types = NULL;

  380. 

  381.     jobject capabilities = NULL;

  382.     jobject profile_level = NULL;

  383.     jobjectArray profile_levels = NULL;

  384. 

  385.     JNI_GET_ENV_OR_RETURN(env, log_ctx, NULL);

  386. 

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

  388.         goto done;

  389.     }

  390. 

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

  392.         goto done;

  393.     }

  394. 

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

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

  397.         goto done;

  398.     }

  399. 

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

  401.         int j;

  402.         int type_count;

  403.         int is_encoder;

  404. 

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

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

  407.             goto done;

  408.         }

  409. 

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

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

  412.             goto done;

  413.         }

  414. 

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

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

  417.             goto done;

  418.         }

  419. 

  420.         if (is_encoder != encoder) {

  421.             goto done_with_info;

  422.         }

  423. 

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

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

  426.             int k;

  427.             int profile_count;

  428. 

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

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

  431.                 goto done;

  432.             }

  433. 

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

  435.             if (!supported_type) {

  436.                 goto done;

  437.             }

  438. 

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

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

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

  442.                     goto done;

  443.                 }

  444. 

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

  446.                 if (!name) {

  447.                     goto done;

  448.                 }

  449. 

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

  451.                     av_freep(&name);

  452.                     goto done_with_type;

  453.                 }

  454. 

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

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

  457.                     goto done;

  458.                 }

  459. 

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

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

  462.                     goto done;

  463.                 }

  464. 

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

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

  467.                     int supported_profile = 0;

  468. 

  469.                     if (profile < 0) {

  470.                         found_codec = 1;

  471.                         break;

  472.                     }

  473. 

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

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

  476.                         goto done;

  477.                     }

  478. 

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

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

  481.                         goto done;

  482.                     }

  483. 

  484.                     found_codec = profile == supported_profile;

  485. 

  486.                     if (profile_level) {

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

  488.                         profile_level = NULL;

  489.                     }

  490. 

  491.                     if (found_codec) {

  492.                         break;

  493.                     }

  494.                 }

  495.             }

  496. 

  497. done_with_type:

  498.             if (profile_levels) {

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

  500.                 profile_levels = NULL;

  501.             }

  502. 

  503.             if (capabilities) {

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

  505.                 capabilities = NULL;

  506.             }

  507. 

  508.             if (type) {

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

  510.                 type = NULL;

  511.             }

  512. 

  513.             av_freep(&supported_type);

  514. 

  515.             if (found_codec) {

  516.                 break;

  517.             }

  518. 

  519.             av_freep(&name);

  520.         }

  521. 

  522. done_with_info:

  523.         if (info) {

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

  525.             info = NULL;

  526.         }

  527. 

  528.         if (types) {

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

  530.             types = NULL;

  531.         }

  532. 

  533.         if (found_codec) {

  534.             break;

  535.         }

  536.     }

  537. 

  538. done:

  539.     if (format) {

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

  541.     }

  542. 

  543.     if (codec) {

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

  545.     }

  546. 

  547.     if (codec_name) {

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

  549.     }

  550. 

  551.     if (info) {

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

  553.     }

  554. 

  555.     if (type) {

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

  557.     }

  558. 

  559.     if (types) {

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

  561.     }

  562. 

  563.     if (capabilities) {

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

  565.     }

  566. 

  567.     if (profile_level) {

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

  569.     }

  570. 

  571.     if (profile_levels) {

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

  573.     }

  574. 

  575.     av_freep(&supported_type);

  576. 

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

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

  579. 

  580.     if (!found_codec) {

  581.         av_freep(&name);

  582.     }

  583. 

  584.     return name;

  585. }

  586. 

  587. FFAMediaFormat *ff_AMediaFormat_new(void)

  588. {

  589.     JNIEnv *env = NULL;

  590.     FFAMediaFormat *format = NULL;

  591. 

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

  593.     if (!format) {

  594.         return NULL;

  595.     }

  596.     format->class = &amediaformat_class;

  597. 

  598.     env = ff_jni_get_env(format);

  599.     if (!env) {

  600.         av_freep(&format);

  601.         return NULL;

  602.     }

  603. 

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

  605.         goto fail;

  606.     }

  607. 

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

  609.     if (!format->object) {

  610.         goto fail;

  611.     }

  612. 

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

  614.     if (!format->object) {

  615.         goto fail;

  616.     }

  617. 

  618.     return format;

  619. fail:

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

  621. 

  622.     av_freep(&format);

  623. 

  624.     return NULL;

  625. }

  626. 

  627. static FFAMediaFormat *ff_AMediaFormat_newFromObject(void *object)

  628. {

  629.     JNIEnv *env = NULL;

  630.     FFAMediaFormat *format = 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.     format->object = (*env)->NewGlobalRef(env, object);

  649.     if (!format->object) {

  650.         goto fail;

  651.     }

  652. 

  653.     return format;

  654. fail:

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

  656. 

  657.     av_freep(&format);

  658. 

  659.     return NULL;

  660. }

  661. 

  662. int ff_AMediaFormat_delete(FFAMediaFormat* format)

  663. {

  664.     int ret = 0;

  665. 

  666.     JNIEnv *env = NULL;

  667. 

  668.     if (!format) {

  669.         return 0;

  670.     }

  671. 

  672.     JNI_GET_ENV_OR_RETURN(env, format, AVERROR_EXTERNAL);

  673. 

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

  675.     format->object = NULL;

  676. 

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

  678. 

  679.     av_freep(&format);

  680. 

  681.     return ret;

  682. }

  683. 

  684. char* ff_AMediaFormat_toString(FFAMediaFormat* format)

  685. {

  686.     char *ret = NULL;

  687. 

  688.     JNIEnv *env = NULL;

  689.     jstring description = NULL;

  690. 

  691.     av_assert0(format != NULL);

  692. 

  693.     JNI_GET_ENV_OR_RETURN(env, format, NULL);

  694. 

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

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

  697.         goto fail;

  698.     }

  699. 

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

  701. fail:

  702.     if (description) {

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

  704.     }

  705. 

  706.     return ret;

  707. }

  708. 

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

  710. {

  711.     int ret = 1;

  712. 

  713.     JNIEnv *env = NULL;

  714.     jstring key = NULL;

  715. 

  716.     av_assert0(format != NULL);

  717. 

  718.     JNI_GET_ENV_OR_RETURN(env, format, 0);

  719. 

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

  721.     if (!key) {

  722.         ret = 0;

  723.         goto fail;

  724.     }

  725. 

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

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

  728.         ret = 0;

  729.         goto fail;

  730.     }

  731. 

  732.     ret = 1;

  733. fail:

  734.     if (key) {

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

  736.     }

  737. 

  738.     return ret;

  739. }

  740. 

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

  742. {

  743.     int ret = 1;

  744. 

  745.     JNIEnv *env = NULL;

  746.     jstring key = NULL;

  747. 

  748.     av_assert0(format != NULL);

  749. 

  750.     JNI_GET_ENV_OR_RETURN(env, format, 0);

  751. 

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

  753.     if (!key) {

  754.         ret = 0;

  755.         goto fail;

  756.     }

  757. 

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

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

  760.         ret = 0;

  761.         goto fail;

  762.     }

  763. 

  764.     ret = 1;

  765. fail:

  766.     if (key) {

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

  768.     }

  769. 

  770.     return ret;

  771. }

  772. 

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

  774. {

  775.     int ret = 1;

  776. 

  777.     JNIEnv *env = NULL;

  778.     jstring key = NULL;

  779. 

  780.     av_assert0(format != NULL);

  781. 

  782.     JNI_GET_ENV_OR_RETURN(env, format, 0);

  783. 

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

  785.     if (!key) {

  786.         ret = 0;

  787.         goto fail;

  788.     }

  789. 

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

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

  792.         ret = 0;

  793.         goto fail;

  794.     }

  795. 

  796.     ret = 1;

  797. fail:

  798.     if (key) {

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

  800.     }

  801. 

  802.     return ret;

  803. }

  804. 

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

  806. {

  807.     int ret = 1;

  808. 

  809.     JNIEnv *env = NULL;

  810.     jstring key = NULL;

  811.     jobject result = NULL;

  812. 

  813.     av_assert0(format != NULL);

  814. 

  815.     JNI_GET_ENV_OR_RETURN(env, format, 0);

  816. 

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

  818.     if (!key) {

  819.         ret = 0;

  820.         goto fail;

  821.     }

  822. 

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

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

  825.         ret = 0;

  826.         goto fail;

  827.     }

  828. 

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

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

  831. 

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

  833.         void *src = *data;

  834.         *data = av_malloc(*size);

  835.         if (!*data) {

  836.             ret = 0;

  837.             goto fail;

  838.         }

  839. 

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

  841.     }

  842. 

  843.     ret = 1;

  844. fail:

  845.     if (key) {

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

  847.     }

  848. 

  849.     if (result) {

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

  851.     }

  852. 

  853.     return ret;

  854. }

  855. 

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

  857. {

  858.     int ret = 1;

  859. 

  860.     JNIEnv *env = NULL;

  861.     jstring key = NULL;

  862.     jstring result = NULL;

  863. 

  864.     av_assert0(format != NULL);

  865. 

  866.     JNI_GET_ENV_OR_RETURN(env, format, 0);

  867. 

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

  869.     if (!key) {

  870.         ret = 0;

  871.         goto fail;

  872.     }

  873. 

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

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

  876.         ret = 0;

  877.         goto fail;

  878.     }

  879. 

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

  881.     if (!*out) {

  882.         ret = 0;

  883.         goto fail;

  884.     }

  885. 

  886.     ret = 1;

  887. fail:

  888.     if (key) {

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

  890.     }

  891. 

  892.     if (result) {

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

  894.     }

  895. 

  896.     return ret;

  897. }

  898. 

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

  900. {

  901.     JNIEnv *env = NULL;

  902.     jstring key = NULL;

  903. 

  904.     av_assert0(format != NULL);

  905. 

  906.     JNI_GET_ENV_OR_RETURN_VOID(env, format);

  907. 

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

  909.     if (!key) {

  910.         goto fail;

  911.     }

  912. 

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

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

  915.         goto fail;

  916.     }

  917. 

  918. fail:

  919.     if (key) {

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

  921.     }

  922. }

  923. 

  924. void ff_AMediaFormat_setInt64(FFAMediaFormat* format, const char* name, int64_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_long_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_setFloat(FFAMediaFormat* format, const char* name, float 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_float_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_setString(FFAMediaFormat* format, const char* name, const char* value)

  975. {

  976.     JNIEnv *env = NULL;

  977.     jstring key = NULL;

  978.     jstring string = NULL;

  979. 

  980.     av_assert0(format != NULL);

  981. 

  982.     JNI_GET_ENV_OR_RETURN_VOID(env, format);

  983. 

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

  985.     if (!key) {

  986.         goto fail;

  987.     }

  988. 

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

  990.     if (!string) {

  991.         goto fail;

  992.     }

  993. 

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

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

  996.         goto fail;

  997.     }

  998. 

  999. fail:

  1000.     if (key) {

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

  1002.     }

  1003. 

  1004.     if (string) {

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

  1006.     }

  1007. }

  1008. 

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

  1010. {

  1011.     JNIEnv *env = NULL;

  1012.     jstring key = NULL;

  1013.     jobject buffer = NULL;

  1014.     void *buffer_data = NULL;

  1015. 

  1016.     av_assert0(format != NULL);

  1017. 

  1018.     JNI_GET_ENV_OR_RETURN_VOID(env, format);

  1019. 

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

  1021.     if (!key) {

  1022.         goto fail;

  1023.     }

  1024. 

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

  1026.         goto fail;

  1027.     }

  1028. 

  1029.     buffer_data = av_malloc(size);

  1030.     if (!buffer_data) {

  1031.         goto fail;

  1032.     }

  1033. 

  1034.     memcpy(buffer_data, data, size);

  1035. 

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

  1037.     if (!buffer) {

  1038.         goto fail;

  1039.     }

  1040. 

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

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

  1043.         goto fail;

  1044.     }

  1045. 

  1046. fail:

  1047.     if (key) {

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

  1049.     }

  1050. 

  1051.     if (buffer) {

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

  1053.     }

  1054. }

  1055. 

  1056. static int codec_init_static_fields(FFAMediaCodec *codec)

  1057. {

  1058.     int ret = 0;

  1059.     JNIEnv *env = NULL;

  1060. 

  1061.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1062. 

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

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

  1065.         goto fail;

  1066.     }

  1067. 

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

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

  1070.         goto fail;

  1071.     }

  1072. 

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

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

  1075.         goto fail;

  1076.     }

  1077. 

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

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

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

  1081.             goto fail;

  1082.         }

  1083.     }

  1084. 

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

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

  1087.         goto fail;

  1088.     }

  1089. 

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

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

  1092.         goto fail;

  1093.     }

  1094. 

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

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

  1097.         goto fail;

  1098.     }

  1099. 

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

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

  1102.         goto fail;

  1103.     }

  1104. 

  1105. fail:

  1106. 

  1107.     return ret;

  1108. }

  1109. 

  1110. FFAMediaCodec* ff_AMediaCodec_createCodecByName(const char *name)

  1111. {

  1112.     JNIEnv *env = NULL;

  1113.     FFAMediaCodec *codec = NULL;

  1114.     jstring codec_name = NULL;

  1115. 

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

  1117.     if (!codec) {

  1118.         return NULL;

  1119.     }

  1120.     codec->class = &amediacodec_class;

  1121. 

  1122.     env = ff_jni_get_env(codec);

  1123.     if (!env) {

  1124.         av_freep(&codec);

  1125.         return NULL;

  1126.     }

  1127. 

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

  1129.         goto fail;

  1130.     }

  1131. 

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

  1133.     if (!codec_name) {

  1134.         goto fail;

  1135.     }

  1136. 

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

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

  1139.         goto fail;

  1140.     }

  1141. 

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

  1143.     if (!codec->object) {

  1144.         goto fail;

  1145.     }

  1146. 

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

  1148.         goto fail;

  1149.     }

  1150. 

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

  1152.         codec->has_get_i_o_buffer = 1;

  1153.     }

  1154. 

  1155.     return codec;

  1156. fail:

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

  1158. 

  1159.     if (codec_name) {

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

  1161.     }

  1162. 

  1163.     av_freep(&codec);

  1164. 

  1165.     return NULL;

  1166. }

  1167. 

  1168. FFAMediaCodec* ff_AMediaCodec_createDecoderByType(const char *mime)

  1169. {

  1170.     JNIEnv *env = NULL;

  1171.     FFAMediaCodec *codec = NULL;

  1172.     jstring mime_type = NULL;

  1173. 

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

  1175.     if (!codec) {

  1176.         return NULL;

  1177.     }

  1178.     codec->class = &amediacodec_class;

  1179. 

  1180.     env = ff_jni_get_env(codec);

  1181.     if (!env) {

  1182.         av_freep(&codec);

  1183.         return NULL;

  1184.     }

  1185. 

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

  1187.         goto fail;

  1188.     }

  1189. 

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

  1191.     if (!mime_type) {

  1192.         goto fail;

  1193.     }

  1194. 

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

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

  1197.         goto fail;

  1198.     }

  1199. 

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

  1201.     if (!codec->object) {

  1202.         goto fail;

  1203.     }

  1204. 

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

  1206.         goto fail;

  1207.     }

  1208. 

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

  1210.         codec->has_get_i_o_buffer = 1;

  1211.     }

  1212. 

  1213.     return codec;

  1214. fail:

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

  1216. 

  1217.     if (mime_type) {

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

  1219.     }

  1220. 

  1221.     av_freep(&codec);

  1222. 

  1223.     return NULL;

  1224. }

  1225. 

  1226. FFAMediaCodec* ff_AMediaCodec_createEncoderByType(const char *mime)

  1227. {

  1228.     JNIEnv *env = NULL;

  1229.     FFAMediaCodec *codec = NULL;

  1230.     jstring mime_type = NULL;

  1231. 

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

  1233.     if (!codec) {

  1234.         return NULL;

  1235.     }

  1236.     codec->class = &amediacodec_class;

  1237. 

  1238.     env = ff_jni_get_env(codec);

  1239.     if (!env) {

  1240.         av_freep(&codec);

  1241.         return NULL;

  1242.     }

  1243. 

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

  1245.         goto fail;

  1246.     }

  1247. 

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

  1249.     if (!mime_type) {

  1250.         goto fail;

  1251.     }

  1252. 

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

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

  1255.         goto fail;

  1256.     }

  1257. 

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

  1259.     if (!codec->object) {

  1260.         goto fail;

  1261.     }

  1262. 

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

  1264.         goto fail;

  1265.     }

  1266. 

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

  1268.         codec->has_get_i_o_buffer = 1;

  1269.     }

  1270. 

  1271.     return codec;

  1272. fail:

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

  1274. 

  1275.     if (mime_type) {

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

  1277.     }

  1278. 

  1279.     av_freep(&codec);

  1280. 

  1281.     return NULL;

  1282. }

  1283. 

  1284. int ff_AMediaCodec_delete(FFAMediaCodec* codec)

  1285. {

  1286.     int ret = 0;

  1287. 

  1288.     JNIEnv *env = NULL;

  1289. 

  1290.     if (!codec) {

  1291.         return 0;

  1292.     }

  1293. 

  1294.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1295. 

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

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

  1298.         ret = AVERROR_EXTERNAL;

  1299.     }

  1300. 

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

  1302.     codec->object = NULL;

  1303. 

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

  1305. 

  1306.     av_freep(&codec);

  1307. 

  1308.     return ret;

  1309. }

  1310. 

  1311. char *ff_AMediaCodec_getName(FFAMediaCodec *codec)

  1312. {

  1313.     char *ret = NULL;

  1314.     JNIEnv *env = NULL;

  1315.     jobject *name = NULL;

  1316. 

  1317.     JNI_GET_ENV_OR_RETURN(env, codec, NULL);

  1318. 

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

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

  1321.         goto fail;

  1322.     }

  1323. 

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

  1325. 

  1326. fail:

  1327.     return ret;

  1328. }

  1329. 

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

  1331. {

  1332.     int ret = 0;

  1333.     JNIEnv *env = NULL;

  1334. 

  1335.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1336. 

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

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

  1339.         ret = AVERROR_EXTERNAL;

  1340.         goto fail;

  1341.     }

  1342. 

  1343. fail:

  1344.     return ret;

  1345. }

  1346. 

  1347. int ff_AMediaCodec_start(FFAMediaCodec* codec)

  1348. {

  1349.     int ret = 0;

  1350.     JNIEnv *env = NULL;

  1351. 

  1352.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1353. 

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

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

  1356.         ret = AVERROR_EXTERNAL;

  1357.         goto fail;

  1358.     }

  1359. 

  1360. fail:

  1361.     return ret;

  1362. }

  1363. 

  1364. int ff_AMediaCodec_stop(FFAMediaCodec* codec)

  1365. {

  1366.     int ret = 0;

  1367.     JNIEnv *env = NULL;

  1368. 

  1369.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1370. 

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

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

  1373.         ret = AVERROR_EXTERNAL;

  1374.         goto fail;

  1375.     }

  1376. 

  1377. fail:

  1378.     return ret;

  1379. }

  1380. 

  1381. int ff_AMediaCodec_flush(FFAMediaCodec* codec)

  1382. {

  1383.     int ret = 0;

  1384.     JNIEnv *env = NULL;

  1385. 

  1386.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1387. 

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

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

  1390.         ret = AVERROR_EXTERNAL;

  1391.         goto fail;

  1392.     }

  1393. 

  1394. fail:

  1395.     return ret;

  1396. }

  1397. 

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

  1399. {

  1400.     int ret = 0;

  1401.     JNIEnv *env = NULL;

  1402. 

  1403.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1404. 

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

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

  1407.         ret = AVERROR_EXTERNAL;

  1408.         goto fail;

  1409.     }

  1410. 

  1411. fail:

  1412.     return ret;

  1413. }

  1414. 

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

  1416. {

  1417.     int ret = 0;

  1418.     JNIEnv *env = NULL;

  1419. 

  1420.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1421. 

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

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

  1424.         ret = AVERROR_EXTERNAL;

  1425.         goto fail;

  1426.     }

  1427. 

  1428. fail:

  1429.     return ret;

  1430. }

  1431. 

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

  1433. {

  1434.     int ret = 0;

  1435.     JNIEnv *env = NULL;

  1436. 

  1437.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1438. 

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

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

  1441.         ret = AVERROR_EXTERNAL;

  1442.         goto fail;

  1443.     }

  1444. 

  1445. fail:

  1446.     return ret;

  1447. }

  1448. 

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

  1450. {

  1451.     int ret = 0;

  1452.     JNIEnv *env = NULL;

  1453. 

  1454.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1455. 

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

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

  1458.         ret = AVERROR_EXTERNAL;

  1459.         goto fail;

  1460.     }

  1461. 

  1462. fail:

  1463.     return ret;

  1464. }

  1465. 

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

  1467. {

  1468.     int ret = 0;

  1469.     JNIEnv *env = NULL;

  1470. 

  1471.     jobject mediainfo = NULL;

  1472. 

  1473.     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);

  1474. 

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

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

  1477.         ret = AVERROR_EXTERNAL;

  1478.         goto fail;

  1479.     }

  1480. 

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

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

  1483.         ret = AVERROR_EXTERNAL;

  1484.         goto fail;

  1485.     }

  1486. 

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

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

  1489.         ret = AVERROR_EXTERNAL;

  1490.         goto fail;

  1491.     }

  1492. 

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

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

  1495.         ret = AVERROR_EXTERNAL;

  1496.         goto fail;

  1497.     }

  1498. 

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

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

  1501.         ret = AVERROR_EXTERNAL;

  1502.         goto fail;

  1503.     }

  1504. 

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

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

  1507.         ret = AVERROR_EXTERNAL;

  1508.         goto fail;

  1509.     }

  1510. fail:

  1511.     if (mediainfo) {

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

  1513.     }

  1514. 

  1515.     return ret;

  1516. }

  1517. 

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

  1519. {

  1520.     uint8_t *ret = NULL;

  1521.     JNIEnv *env = NULL;

  1522. 

  1523.     jobject buffer = NULL;

  1524. 

  1525.     JNI_GET_ENV_OR_RETURN(env, codec, NULL);

  1526. 

  1527.     if (codec->has_get_i_o_buffer) {

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

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

  1530.             goto fail;

  1531.         }

  1532.     } else {

  1533.         if (!codec->input_buffers) {

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

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

  1536.                 goto fail;

  1537.             }

  1538. 

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

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

  1541.                 goto fail;

  1542.             }

  1543.         }

  1544. 

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

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

  1547.             goto fail;

  1548.         }

  1549.     }

  1550. 

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

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

  1553. fail:

  1554.     if (buffer) {

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

  1556.     }

  1557. 

  1558.     return ret;

  1559. }

  1560. 

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

  1562. {

  1563.     uint8_t *ret = NULL;

  1564.     JNIEnv *env = NULL;

  1565. 

  1566.     jobject buffer = NULL;

  1567. 

  1568.     JNI_GET_ENV_OR_RETURN(env, codec, NULL);

  1569. 

  1570.     if (codec->has_get_i_o_buffer) {

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

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

  1573.             goto fail;

  1574.         }

  1575.     } else {

  1576.         if (!codec->output_buffers) {

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

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

  1579.                 goto fail;

  1580.             }

  1581. 

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

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

  1584.                 goto fail;

  1585.             }

  1586.         }

  1587. 

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

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

  1590.             goto fail;

  1591.         }

  1592.     }

  1593. 

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

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

  1596. fail:

  1597.     if (buffer) {

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

  1599.     }

  1600. 

  1601.     return ret;

  1602. }

  1603. 

  1604. FFAMediaFormat* ff_AMediaCodec_getOutputFormat(FFAMediaCodec* codec)

  1605. {

  1606.     FFAMediaFormat *ret = NULL;

  1607.     JNIEnv *env = NULL;

  1608. 

  1609.     jobject mediaformat = NULL;

  1610. 

  1611.     JNI_GET_ENV_OR_RETURN(env, codec, NULL);

  1612. 

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

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

  1615.         goto fail;

  1616.     }

  1617. 

  1618.     ret = ff_AMediaFormat_newFromObject(mediaformat);

  1619. fail:

  1620.     if (mediaformat) {

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

  1622.     }

  1623. 

  1624.     return ret;

  1625. }

  1626. 

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

  1628. {

  1629.     return idx == codec->INFO_TRY_AGAIN_LATER;

  1630. }

  1631. 

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

  1633. {

  1634.     return idx == codec->INFO_OUTPUT_BUFFERS_CHANGED;

  1635. }

  1636. 

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

  1638. {

  1639.     return idx == codec->INFO_OUTPUT_FORMAT_CHANGED;

  1640. }

  1641. 

  1642. int ff_AMediaCodec_getBufferFlagCodecConfig(FFAMediaCodec *codec)

  1643. {

  1644.     return codec->BUFFER_FLAG_CODEC_CONFIG;

  1645. }

  1646. 

  1647. int ff_AMediaCodec_getBufferFlagEndOfStream(FFAMediaCodec *codec)

  1648. {

  1649.     return codec->BUFFER_FLAG_END_OF_STREAM;

  1650. }

  1651. 

  1652. int ff_AMediaCodec_getBufferFlagKeyFrame(FFAMediaCodec *codec)

  1653. {

  1654.     return codec->BUFFER_FLAG_KEY_FRAME;

  1655. }

  1656. 

  1657. int ff_AMediaCodec_getConfigureFlagEncode(FFAMediaCodec *codec)

  1658. {

  1659.     return codec->CONFIGURE_FLAG_ENCODE;

  1660. }

  1661. 

  1662. int ff_AMediaCodec_cleanOutputBuffers(FFAMediaCodec *codec)

  1663. {

  1664.     int ret = 0;

  1665. 

  1666.     if (!codec->has_get_i_o_buffer) {

  1667.         if (codec->output_buffers) {

  1668.             JNIEnv *env = NULL;

  1669. 

  1670.             env = ff_jni_get_env(codec);

  1671.             if (!env) {

  1672.                 ret = AVERROR_EXTERNAL;

  1673.                 goto fail;

  1674.             }

  1675. 

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

  1677.             codec->output_buffers = NULL;

  1678.         }

  1679.     }

  1680. 

  1681. fail:

  1682.     return ret;

  1683. }