FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
mediacodec_wrapper.c
Go to the documentation of this file.
1 /*
2  * Android MediaCodec Wrapper
3  *
4  * Copyright (c) 2015-2016 Matthieu Bouron <matthieu.bouron stupeflix.com>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include <jni.h>
24 
25 #include "libavutil/avassert.h"
26 #include "libavutil/mem.h"
27 #include "libavutil/avstring.h"
28 
29 #include "avcodec.h"
30 #include "ffjni.h"
31 #include "version.h"
32 #include "mediacodec_wrapper.h"
33 
34 struct JNIAMediaCodecListFields {
35 
36  jclass mediacodec_list_class;
37  jmethodID init_id;
38  jmethodID find_decoder_for_format_id;
39 
40  jmethodID get_codec_count_id;
41  jmethodID get_codec_info_at_id;
42 
43  jclass mediacodec_info_class;
44  jmethodID get_name_id;
45  jmethodID get_codec_capabilities_id;
46  jmethodID get_supported_types_id;
47  jmethodID is_encoder_id;
48 
49  jclass codec_capabilities_class;
50  jfieldID color_formats_id;
51  jfieldID profile_levels_id;
52 
53  jclass codec_profile_level_class;
54  jfieldID profile_id;
55  jfieldID level_id;
56 
57  jfieldID avc_profile_baseline_id;
58  jfieldID avc_profile_main_id;
59  jfieldID avc_profile_extended_id;
60  jfieldID avc_profile_high_id;
61  jfieldID avc_profile_high10_id;
62  jfieldID avc_profile_high422_id;
63  jfieldID avc_profile_high444_id;
64 
65  jfieldID hevc_profile_main_id;
66  jfieldID hevc_profile_main10_id;
67  jfieldID hevc_profile_main10_hdr10_id;
68 
69 };
70 
71 static const struct FFJniField jni_amediacodeclist_mapping[] = {
72  { "android/media/MediaCodecList", NULL, NULL, FF_JNI_CLASS, offsetof(struct JNIAMediaCodecListFields, mediacodec_list_class), 1 },
73  { "android/media/MediaCodecList", "<init>", "(I)V", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecListFields, init_id), 0 },
74  { "android/media/MediaCodecList", "findDecoderForFormat", "(Landroid/media/MediaFormat;)Ljava/lang/String;", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecListFields, find_decoder_for_format_id), 0 },
75 
76  { "android/media/MediaCodecList", "getCodecCount", "()I", FF_JNI_STATIC_METHOD, offsetof(struct JNIAMediaCodecListFields, get_codec_count_id), 1 },
77  { "android/media/MediaCodecList", "getCodecInfoAt", "(I)Landroid/media/MediaCodecInfo;", FF_JNI_STATIC_METHOD, offsetof(struct JNIAMediaCodecListFields, get_codec_info_at_id), 1 },
78 
79  { "android/media/MediaCodecInfo", NULL, NULL, FF_JNI_CLASS, offsetof(struct JNIAMediaCodecListFields, mediacodec_info_class), 1 },
80  { "android/media/MediaCodecInfo", "getName", "()Ljava/lang/String;", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecListFields, get_name_id), 1 },
81  { "android/media/MediaCodecInfo", "getCapabilitiesForType", "(Ljava/lang/String;)Landroid/media/MediaCodecInfo$CodecCapabilities;", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecListFields, get_codec_capabilities_id), 1 },
82  { "android/media/MediaCodecInfo", "getSupportedTypes", "()[Ljava/lang/String;", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecListFields, get_supported_types_id), 1 },
83  { "android/media/MediaCodecInfo", "isEncoder", "()Z", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecListFields, is_encoder_id), 1 },
84 
85  { "android/media/MediaCodecInfo$CodecCapabilities", NULL, NULL, FF_JNI_CLASS, offsetof(struct JNIAMediaCodecListFields, codec_capabilities_class), 1 },
86  { "android/media/MediaCodecInfo$CodecCapabilities", "colorFormats", "[I", FF_JNI_FIELD, offsetof(struct JNIAMediaCodecListFields, color_formats_id), 1 },
87  { "android/media/MediaCodecInfo$CodecCapabilities", "profileLevels", "[Landroid/media/MediaCodecInfo$CodecProfileLevel;", FF_JNI_FIELD, offsetof(struct JNIAMediaCodecListFields, profile_levels_id), 1 },
88 
89  { "android/media/MediaCodecInfo$CodecProfileLevel", NULL, NULL, FF_JNI_CLASS, offsetof(struct JNIAMediaCodecListFields, codec_profile_level_class), 1 },
90  { "android/media/MediaCodecInfo$CodecProfileLevel", "profile", "I", FF_JNI_FIELD, offsetof(struct JNIAMediaCodecListFields, profile_id), 1 },
91  { "android/media/MediaCodecInfo$CodecProfileLevel", "level", "I", FF_JNI_FIELD, offsetof(struct JNIAMediaCodecListFields, level_id), 1 },
92 
93  { "android/media/MediaCodecInfo$CodecProfileLevel", "AVCProfileBaseline", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecListFields, avc_profile_baseline_id), 1 },
94  { "android/media/MediaCodecInfo$CodecProfileLevel", "AVCProfileMain", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecListFields, avc_profile_main_id), 1 },
95  { "android/media/MediaCodecInfo$CodecProfileLevel", "AVCProfileExtended", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecListFields, avc_profile_extended_id), 1 },
96  { "android/media/MediaCodecInfo$CodecProfileLevel", "AVCProfileHigh", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecListFields, avc_profile_high_id), 1 },
97  { "android/media/MediaCodecInfo$CodecProfileLevel", "AVCProfileHigh10", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecListFields, avc_profile_high10_id), 1 },
98  { "android/media/MediaCodecInfo$CodecProfileLevel", "AVCProfileHigh422", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecListFields, avc_profile_high422_id), 1 },
99  { "android/media/MediaCodecInfo$CodecProfileLevel", "AVCProfileHigh444", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecListFields, avc_profile_high444_id), 1 },
100 
101  { "android/media/MediaCodecInfo$CodecProfileLevel", "HEVCProfileMain", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecListFields, hevc_profile_main_id), 0 },
102  { "android/media/MediaCodecInfo$CodecProfileLevel", "HEVCProfileMain10", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecListFields, hevc_profile_main10_id), 0 },
103  { "android/media/MediaCodecInfo$CodecProfileLevel", "HEVCProfileMain10HDR10", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecListFields, hevc_profile_main10_hdr10_id), 0 },
104 
105  { NULL }
106 };
107 
108 struct JNIAMediaFormatFields {
109 
110  jclass mediaformat_class;
111 
112  jmethodID init_id;
113 
114  jmethodID contains_key_id;
115 
116  jmethodID get_integer_id;
117  jmethodID get_long_id;
118  jmethodID get_float_id;
119  jmethodID get_bytebuffer_id;
120  jmethodID get_string_id;
121 
122  jmethodID set_integer_id;
123  jmethodID set_long_id;
124  jmethodID set_float_id;
125  jmethodID set_bytebuffer_id;
126  jmethodID set_string_id;
127 
128  jmethodID to_string_id;
129 
130 };
131 
132 static const struct FFJniField jni_amediaformat_mapping[] = {
133  { "android/media/MediaFormat", NULL, NULL, FF_JNI_CLASS, offsetof(struct JNIAMediaFormatFields, mediaformat_class), 1 },
134 
135  { "android/media/MediaFormat", "<init>", "()V", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, init_id), 1 },
136 
137  { "android/media/MediaFormat", "containsKey", "(Ljava/lang/String;)Z", FF_JNI_METHOD,offsetof(struct JNIAMediaFormatFields, contains_key_id), 1 },
138 
139  { "android/media/MediaFormat", "getInteger", "(Ljava/lang/String;)I", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, get_integer_id), 1 },
140  { "android/media/MediaFormat", "getLong", "(Ljava/lang/String;)J", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, get_long_id), 1 },
141  { "android/media/MediaFormat", "getFloat", "(Ljava/lang/String;)F", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, get_float_id), 1 },
142  { "android/media/MediaFormat", "getByteBuffer", "(Ljava/lang/String;)Ljava/nio/ByteBuffer;", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, get_bytebuffer_id), 1 },
143  { "android/media/MediaFormat", "getString", "(Ljava/lang/String;)Ljava/lang/String;", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, get_string_id), 1 },
144 
145  { "android/media/MediaFormat", "setInteger", "(Ljava/lang/String;I)V", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, set_integer_id), 1 },
146  { "android/media/MediaFormat", "setLong", "(Ljava/lang/String;J)V", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, set_long_id), 1 },
147  { "android/media/MediaFormat", "setFloat", "(Ljava/lang/String;F)V", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, set_float_id), 1 },
148  { "android/media/MediaFormat", "setByteBuffer", "(Ljava/lang/String;Ljava/nio/ByteBuffer;)V", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, set_bytebuffer_id), 1 },
149  { "android/media/MediaFormat", "setString", "(Ljava/lang/String;Ljava/lang/String;)V", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, set_string_id), 1 },
150 
151  { "android/media/MediaFormat", "toString", "()Ljava/lang/String;", FF_JNI_METHOD, offsetof(struct JNIAMediaFormatFields, to_string_id), 1 },
152 
153  { NULL }
154 };
155 
156 static const AVClass amediaformat_class = {
157  .class_name = "amediaformat",
158  .item_name = av_default_item_name,
159  .version = LIBAVUTIL_VERSION_INT,
160 };
161 
162 struct FFAMediaFormat {
163 
164  const AVClass *class;
165  struct JNIAMediaFormatFields jfields;
166  jobject object;
167 };
168 
169 struct JNIAMediaCodecFields {
170 
171  jclass mediacodec_class;
172 
173  jfieldID info_try_again_later_id;
174  jfieldID info_output_buffers_changed_id;
175  jfieldID info_output_format_changed_id;
176 
177  jfieldID buffer_flag_codec_config_id;
178  jfieldID buffer_flag_end_of_stream_id;
179  jfieldID buffer_flag_key_frame_id;
180 
181  jfieldID configure_flag_encode_id;
182 
183  jmethodID create_by_codec_name_id;
184  jmethodID create_decoder_by_type_id;
185  jmethodID create_encoder_by_type_id;
186 
187  jmethodID get_name_id;
188 
189  jmethodID configure_id;
190  jmethodID start_id;
191  jmethodID flush_id;
192  jmethodID stop_id;
193  jmethodID release_id;
194 
195  jmethodID get_output_format_id;
196 
197  jmethodID dequeue_input_buffer_id;
198  jmethodID queue_input_buffer_id;
199  jmethodID get_input_buffer_id;
200  jmethodID get_input_buffers_id;
201 
202  jmethodID dequeue_output_buffer_id;
203  jmethodID get_output_buffer_id;
204  jmethodID get_output_buffers_id;
205  jmethodID release_output_buffer_id;
206  jmethodID release_output_buffer_at_time_id;
207 
208  jclass mediainfo_class;
209 
210  jmethodID init_id;
211 
212  jfieldID flags_id;
213  jfieldID offset_id;
214  jfieldID presentation_time_us_id;
215  jfieldID size_id;
216 
217 };
218 
219 static const struct FFJniField jni_amediacodec_mapping[] = {
220  { "android/media/MediaCodec", NULL, NULL, FF_JNI_CLASS, offsetof(struct JNIAMediaCodecFields, mediacodec_class), 1 },
221 
222  { "android/media/MediaCodec", "INFO_TRY_AGAIN_LATER", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecFields, info_try_again_later_id), 1 },
223  { "android/media/MediaCodec", "INFO_OUTPUT_BUFFERS_CHANGED", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecFields, info_output_buffers_changed_id), 1 },
224  { "android/media/MediaCodec", "INFO_OUTPUT_FORMAT_CHANGED", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecFields, info_output_format_changed_id), 1 },
225 
226  { "android/media/MediaCodec", "BUFFER_FLAG_CODEC_CONFIG", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecFields, buffer_flag_codec_config_id), 1 },
227  { "android/media/MediaCodec", "BUFFER_FLAG_END_OF_STREAM", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecFields, buffer_flag_end_of_stream_id), 1 },
228  { "android/media/MediaCodec", "BUFFER_FLAG_KEY_FRAME", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecFields, buffer_flag_key_frame_id), 0 },
229 
230  { "android/media/MediaCodec", "CONFIGURE_FLAG_ENCODE", "I", FF_JNI_STATIC_FIELD, offsetof(struct JNIAMediaCodecFields, configure_flag_encode_id), 1 },
231 
232  { "android/media/MediaCodec", "createByCodecName", "(Ljava/lang/String;)Landroid/media/MediaCodec;", FF_JNI_STATIC_METHOD, offsetof(struct JNIAMediaCodecFields, create_by_codec_name_id), 1 },
233  { "android/media/MediaCodec", "createDecoderByType", "(Ljava/lang/String;)Landroid/media/MediaCodec;", FF_JNI_STATIC_METHOD, offsetof(struct JNIAMediaCodecFields, create_decoder_by_type_id), 1 },
234  { "android/media/MediaCodec", "createEncoderByType", "(Ljava/lang/String;)Landroid/media/MediaCodec;", FF_JNI_STATIC_METHOD, offsetof(struct JNIAMediaCodecFields, create_encoder_by_type_id), 1 },
235 
236  { "android/media/MediaCodec", "getName", "()Ljava/lang/String;", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, get_name_id), 1 },
237 
238  { "android/media/MediaCodec", "configure", "(Landroid/media/MediaFormat;Landroid/view/Surface;Landroid/media/MediaCrypto;I)V", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, configure_id), 1 },
239  { "android/media/MediaCodec", "start", "()V", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, start_id), 1 },
240  { "android/media/MediaCodec", "flush", "()V", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, flush_id), 1 },
241  { "android/media/MediaCodec", "stop", "()V", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, stop_id), 1 },
242  { "android/media/MediaCodec", "release", "()V", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, release_id), 1 },
243 
244  { "android/media/MediaCodec", "getOutputFormat", "()Landroid/media/MediaFormat;", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, get_output_format_id), 1 },
245 
246  { "android/media/MediaCodec", "dequeueInputBuffer", "(J)I", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, dequeue_input_buffer_id), 1 },
247  { "android/media/MediaCodec", "queueInputBuffer", "(IIIJI)V", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, queue_input_buffer_id), 1 },
248  { "android/media/MediaCodec", "getInputBuffer", "(I)Ljava/nio/ByteBuffer;", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, get_input_buffer_id), 0 },
249  { "android/media/MediaCodec", "getInputBuffers", "()[Ljava/nio/ByteBuffer;", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, get_input_buffers_id), 1 },
250 
251  { "android/media/MediaCodec", "dequeueOutputBuffer", "(Landroid/media/MediaCodec$BufferInfo;J)I", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, dequeue_output_buffer_id), 1 },
252  { "android/media/MediaCodec", "getOutputBuffer", "(I)Ljava/nio/ByteBuffer;", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, get_output_buffer_id), 0 },
253  { "android/media/MediaCodec", "getOutputBuffers", "()[Ljava/nio/ByteBuffer;", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, get_output_buffers_id), 1 },
254  { "android/media/MediaCodec", "releaseOutputBuffer", "(IZ)V", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, release_output_buffer_id), 1 },
255  { "android/media/MediaCodec", "releaseOutputBuffer", "(IJ)V", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, release_output_buffer_at_time_id), 0 },
256 
257  { "android/media/MediaCodec$BufferInfo", NULL, NULL, FF_JNI_CLASS, offsetof(struct JNIAMediaCodecFields, mediainfo_class), 1 },
258 
259  { "android/media/MediaCodec.BufferInfo", "<init>", "()V", FF_JNI_METHOD, offsetof(struct JNIAMediaCodecFields, init_id), 1 },
260  { "android/media/MediaCodec.BufferInfo", "flags", "I", FF_JNI_FIELD, offsetof(struct JNIAMediaCodecFields, flags_id), 1 },
261  { "android/media/MediaCodec.BufferInfo", "offset", "I", FF_JNI_FIELD, offsetof(struct JNIAMediaCodecFields, offset_id), 1 },
262  { "android/media/MediaCodec.BufferInfo", "presentationTimeUs", "J", FF_JNI_FIELD, offsetof(struct JNIAMediaCodecFields, presentation_time_us_id), 1 },
263  { "android/media/MediaCodec.BufferInfo", "size", "I", FF_JNI_FIELD, offsetof(struct JNIAMediaCodecFields, size_id), 1 },
264 
265  { NULL }
266 };
267 
268 static const AVClass amediacodec_class = {
269  .class_name = "amediacodec",
270  .item_name = av_default_item_name,
271  .version = LIBAVUTIL_VERSION_INT,
272 };
273 
274 struct FFAMediaCodec {
275 
276  const AVClass *class;
277 
278  struct JNIAMediaCodecFields jfields;
279 
280  jobject object;
281  jobject buffer_info;
282 
283  jobject input_buffers;
284  jobject output_buffers;
285 
286  int INFO_TRY_AGAIN_LATER;
287  int INFO_OUTPUT_BUFFERS_CHANGED;
288  int INFO_OUTPUT_FORMAT_CHANGED;
289 
290  int BUFFER_FLAG_CODEC_CONFIG;
291  int BUFFER_FLAG_END_OF_STREAM;
292  int BUFFER_FLAG_KEY_FRAME;
293 
294  int CONFIGURE_FLAG_ENCODE;
295 
296  int has_get_i_o_buffer;
297 };
298 
299 #define JNI_GET_ENV_OR_RETURN(env, log_ctx, ret) do { \
300  (env) = ff_jni_get_env(log_ctx); \
301  if (!(env)) { \
302  return ret; \
303  } \
304 } while (0)
305 
306 #define JNI_GET_ENV_OR_RETURN_VOID(env, log_ctx) do { \
307  (env) = ff_jni_get_env(log_ctx); \
308  if (!(env)) { \
309  return; \
310  } \
311 } while (0)
312 
313 int ff_AMediaCodecProfile_getProfileFromAVCodecContext(AVCodecContext *avctx)
314 {
315  int ret = -1;
316 
317  JNIEnv *env = NULL;
318  struct JNIAMediaCodecListFields jfields = { 0 };
319  jfieldID field_id = 0;
320 
321  JNI_GET_ENV_OR_RETURN(env, avctx, -1);
322 
323  if (ff_jni_init_jfields(env, &jfields, jni_amediacodeclist_mapping, 0, avctx) < 0) {
324  goto done;
325  }
326 
327  if (avctx->codec_id == AV_CODEC_ID_H264) {
328  switch(avctx->profile) {
329  case FF_PROFILE_H264_BASELINE:
330  case FF_PROFILE_H264_CONSTRAINED_BASELINE:
331  field_id = jfields.avc_profile_baseline_id;
332  break;
333  case FF_PROFILE_H264_MAIN:
334  field_id = jfields.avc_profile_main_id;
335  break;
336  case FF_PROFILE_H264_EXTENDED:
337  field_id = jfields.avc_profile_extended_id;
338  break;
339  case FF_PROFILE_H264_HIGH:
340  field_id = jfields.avc_profile_high_id;
341  break;
342  case FF_PROFILE_H264_HIGH_10:
343  case FF_PROFILE_H264_HIGH_10_INTRA:
344  field_id = jfields.avc_profile_high10_id;
345  break;
346  case FF_PROFILE_H264_HIGH_422:
347  case FF_PROFILE_H264_HIGH_422_INTRA:
348  field_id = jfields.avc_profile_high422_id;
349  break;
350  case FF_PROFILE_H264_HIGH_444:
351  case FF_PROFILE_H264_HIGH_444_INTRA:
352  case FF_PROFILE_H264_HIGH_444_PREDICTIVE:
353  field_id = jfields.avc_profile_high444_id;
354  break;
355  }
356  } else if (avctx->codec_id == AV_CODEC_ID_HEVC) {
357  switch (avctx->profile) {
358  case FF_PROFILE_HEVC_MAIN:
359  case FF_PROFILE_HEVC_MAIN_STILL_PICTURE:
360  field_id = jfields.hevc_profile_main_id;
361  break;
362  case FF_PROFILE_HEVC_MAIN_10:
363  field_id = jfields.hevc_profile_main10_id;
364  break;
365  }
366  }
367 
368  if (field_id) {
369  ret = (*env)->GetStaticIntField(env, jfields.codec_profile_level_class, field_id);
370  if (ff_jni_exception_check(env, 1, avctx) < 0) {
371  ret = -1;
372  goto done;
373  }
374  }
375 
376 done:
377  ff_jni_reset_jfields(env, &jfields, jni_amediacodeclist_mapping, 0, avctx);
378 
379  return ret;
380 }
381 
382 char *ff_AMediaCodecList_getCodecNameByType(const char *mime, int profile, int encoder, void *log_ctx)
383 {
384  int ret;
385  int i;
386  int codec_count;
387  int found_codec = 0;
388  char *name = NULL;
389  char *supported_type = NULL;
390 
391  JNIEnv *env = NULL;
392  struct JNIAMediaCodecListFields jfields = { 0 };
393  struct JNIAMediaFormatFields mediaformat_jfields = { 0 };
394 
395  jobject format = NULL;
396  jobject codec = NULL;
397  jobject codec_name = NULL;
398 
399  jobject info = NULL;
400  jobject type = NULL;
401  jobjectArray types = NULL;
402 
403  jobject capabilities = NULL;
404  jobject profile_level = NULL;
405  jobjectArray profile_levels = NULL;
406 
407  JNI_GET_ENV_OR_RETURN(env, log_ctx, NULL);
408 
409  if ((ret = ff_jni_init_jfields(env, &jfields, jni_amediacodeclist_mapping, 0, log_ctx)) < 0) {
410  goto done;
411  }
412 
413  if ((ret = ff_jni_init_jfields(env, &mediaformat_jfields, jni_amediaformat_mapping, 0, log_ctx)) < 0) {
414  goto done;
415  }
416 
417  codec_count = (*env)->CallStaticIntMethod(env, jfields.mediacodec_list_class, jfields.get_codec_count_id);
418  if (ff_jni_exception_check(env, 1, log_ctx) < 0) {
419  goto done;
420  }
421 
422  for(i = 0; i < codec_count; i++) {
423  int j;
424  int type_count;
425  int is_encoder;
426 
427  info = (*env)->CallStaticObjectMethod(env, jfields.mediacodec_list_class, jfields.get_codec_info_at_id, i);
428  if (ff_jni_exception_check(env, 1, log_ctx) < 0) {
429  goto done;
430  }
431 
432  types = (*env)->CallObjectMethod(env, info, jfields.get_supported_types_id);
433  if (ff_jni_exception_check(env, 1, log_ctx) < 0) {
434  goto done;
435  }
436 
437  is_encoder = (*env)->CallBooleanMethod(env, info, jfields.is_encoder_id);
438  if (ff_jni_exception_check(env, 1, log_ctx) < 0) {
439  goto done;
440  }
441 
442  if (is_encoder != encoder) {
443  goto done_with_info;
444  }
445 
446  type_count = (*env)->GetArrayLength(env, types);
447  for (j = 0; j < type_count; j++) {
448  int k;
449  int profile_count;
450 
451  type = (*env)->GetObjectArrayElement(env, types, j);
452  if (ff_jni_exception_check(env, 1, log_ctx) < 0) {
453  goto done;
454  }
455 
456  supported_type = ff_jni_jstring_to_utf_chars(env, type, log_ctx);
457  if (!supported_type) {
458  goto done;
459  }
460 
461  if (!av_strcasecmp(supported_type, mime)) {
462  codec_name = (*env)->CallObjectMethod(env, info, jfields.get_name_id);
463  if (ff_jni_exception_check(env, 1, log_ctx) < 0) {
464  goto done;
465  }
466 
467  name = ff_jni_jstring_to_utf_chars(env, codec_name, log_ctx);
468  if (!name) {
469  goto done;
470  }
471 
472  /* Skip software decoders */
473  if (
474  strstr(name, "OMX.google") ||
475  strstr(name, "OMX.ffmpeg") ||
476  (strstr(name, "OMX.SEC") && strstr(name, ".sw.")) ||
477  !strcmp(name, "OMX.qcom.video.decoder.hevcswvdec")) {
478  av_freep(&name);
479  goto done_with_type;
480  }
481 
482  capabilities = (*env)->CallObjectMethod(env, info, jfields.get_codec_capabilities_id, type);
483  if (ff_jni_exception_check(env, 1, log_ctx) < 0) {
484  goto done;
485  }
486 
487  profile_levels = (*env)->GetObjectField(env, capabilities, jfields.profile_levels_id);
488  if (ff_jni_exception_check(env, 1, log_ctx) < 0) {
489  goto done;
490  }
491 
492  profile_count = (*env)->GetArrayLength(env, profile_levels);
493  if (!profile_count) {
494  found_codec = 1;
495  }
496  for (k = 0; k < profile_count; k++) {
497  int supported_profile = 0;
498 
499  if (profile < 0) {
500  found_codec = 1;
501  break;
502  }
503 
504  profile_level = (*env)->GetObjectArrayElement(env, profile_levels, k);
505  if (ff_jni_exception_check(env, 1, log_ctx) < 0) {
506  goto done;
507  }
508 
509  supported_profile = (*env)->GetIntField(env, profile_level, jfields.profile_id);
510  if (ff_jni_exception_check(env, 1, log_ctx) < 0) {
511  goto done;
512  }
513 
514  found_codec = profile == supported_profile;
515 
516  if (profile_level) {
517  (*env)->DeleteLocalRef(env, profile_level);
518  profile_level = NULL;
519  }
520 
521  if (found_codec) {
522  break;
523  }
524  }
525  }
526 
527 done_with_type:
528  if (profile_levels) {
529  (*env)->DeleteLocalRef(env, profile_levels);
530  profile_levels = NULL;
531  }
532 
533  if (capabilities) {
534  (*env)->DeleteLocalRef(env, capabilities);
535  capabilities = NULL;
536  }
537 
538  if (type) {
539  (*env)->DeleteLocalRef(env, type);
540  type = NULL;
541  }
542 
543  av_freep(&supported_type);
544 
545  if (found_codec) {
546  break;
547  }
548 
549  av_freep(&name);
550  }
551 
552 done_with_info:
553  if (info) {
554  (*env)->DeleteLocalRef(env, info);
555  info = NULL;
556  }
557 
558  if (types) {
559  (*env)->DeleteLocalRef(env, types);
560  types = NULL;
561  }
562 
563  if (found_codec) {
564  break;
565  }
566  }
567 
568 done:
569  if (format) {
570  (*env)->DeleteLocalRef(env, format);
571  }
572 
573  if (codec) {
574  (*env)->DeleteLocalRef(env, codec);
575  }
576 
577  if (codec_name) {
578  (*env)->DeleteLocalRef(env, codec_name);
579  }
580 
581  if (info) {
582  (*env)->DeleteLocalRef(env, info);
583  }
584 
585  if (type) {
586  (*env)->DeleteLocalRef(env, type);
587  }
588 
589  if (types) {
590  (*env)->DeleteLocalRef(env, types);
591  }
592 
593  if (capabilities) {
594  (*env)->DeleteLocalRef(env, capabilities);
595  }
596 
597  if (profile_level) {
598  (*env)->DeleteLocalRef(env, profile_level);
599  }
600 
601  if (profile_levels) {
602  (*env)->DeleteLocalRef(env, profile_levels);
603  }
604 
605  av_freep(&supported_type);
606 
607  ff_jni_reset_jfields(env, &jfields, jni_amediacodeclist_mapping, 0, log_ctx);
608  ff_jni_reset_jfields(env, &mediaformat_jfields, jni_amediaformat_mapping, 0, log_ctx);
609 
610  if (!found_codec) {
611  av_freep(&name);
612  }
613 
614  return name;
615 }
616 
617 FFAMediaFormat *ff_AMediaFormat_new(void)
618 {
619  JNIEnv *env = NULL;
620  FFAMediaFormat *format = NULL;
621  jobject object = NULL;
622 
623  format = av_mallocz(sizeof(FFAMediaFormat));
624  if (!format) {
625  return NULL;
626  }
627  format->class = &amediaformat_class;
628 
629  env = ff_jni_get_env(format);
630  if (!env) {
631  av_freep(&format);
632  return NULL;
633  }
634 
635  if (ff_jni_init_jfields(env, &format->jfields, jni_amediaformat_mapping, 1, format) < 0) {
636  goto fail;
637  }
638 
639  object = (*env)->NewObject(env, format->jfields.mediaformat_class, format->jfields.init_id);
640  if (!object) {
641  goto fail;
642  }
643 
644  format->object = (*env)->NewGlobalRef(env, object);
645  if (!format->object) {
646  goto fail;
647  }
648 
649 fail:
650  if (object) {
651  (*env)->DeleteLocalRef(env, object);
652  }
653 
654  if (!format->object) {
655  ff_jni_reset_jfields(env, &format->jfields, jni_amediaformat_mapping, 1, format);
656  av_freep(&format);
657  }
658 
659  return format;
660 }
661 
662 static FFAMediaFormat *ff_AMediaFormat_newFromObject(void *object)
663 {
664  JNIEnv *env = NULL;
665  FFAMediaFormat *format = NULL;
666 
667  format = av_mallocz(sizeof(FFAMediaFormat));
668  if (!format) {
669  return NULL;
670  }
671  format->class = &amediaformat_class;
672 
673  env = ff_jni_get_env(format);
674  if (!env) {
675  av_freep(&format);
676  return NULL;
677  }
678 
679  if (ff_jni_init_jfields(env, &format->jfields, jni_amediaformat_mapping, 1, format) < 0) {
680  goto fail;
681  }
682 
683  format->object = (*env)->NewGlobalRef(env, object);
684  if (!format->object) {
685  goto fail;
686  }
687 
688  return format;
689 fail:
690  ff_jni_reset_jfields(env, &format->jfields, jni_amediaformat_mapping, 1, format);
691 
692  av_freep(&format);
693 
694  return NULL;
695 }
696 
697 int ff_AMediaFormat_delete(FFAMediaFormat* format)
698 {
699  int ret = 0;
700 
701  JNIEnv *env = NULL;
702 
703  if (!format) {
704  return 0;
705  }
706 
707  JNI_GET_ENV_OR_RETURN(env, format, AVERROR_EXTERNAL);
708 
709  (*env)->DeleteGlobalRef(env, format->object);
710  format->object = NULL;
711 
712  ff_jni_reset_jfields(env, &format->jfields, jni_amediaformat_mapping, 1, format);
713 
714  av_freep(&format);
715 
716  return ret;
717 }
718 
719 char* ff_AMediaFormat_toString(FFAMediaFormat* format)
720 {
721  char *ret = NULL;
722 
723  JNIEnv *env = NULL;
724  jstring description = NULL;
725 
726  av_assert0(format != NULL);
727 
728  JNI_GET_ENV_OR_RETURN(env, format, NULL);
729 
730  description = (*env)->CallObjectMethod(env, format->object, format->jfields.to_string_id);
731  if (ff_jni_exception_check(env, 1, NULL) < 0) {
732  goto fail;
733  }
734 
735  ret = ff_jni_jstring_to_utf_chars(env, description, format);
736 fail:
737  if (description) {
738  (*env)->DeleteLocalRef(env, description);
739  }
740 
741  return ret;
742 }
743 
744 int ff_AMediaFormat_getInt32(FFAMediaFormat* format, const char *name, int32_t *out)
745 {
746  int ret = 1;
747 
748  JNIEnv *env = NULL;
749  jstring key = NULL;
750  jboolean contains_key;
751 
752  av_assert0(format != NULL);
753 
754  JNI_GET_ENV_OR_RETURN(env, format, 0);
755 
756  key = ff_jni_utf_chars_to_jstring(env, name, format);
757  if (!key) {
758  ret = 0;
759  goto fail;
760  }
761 
762  contains_key = (*env)->CallBooleanMethod(env, format->object, format->jfields.contains_key_id, key);
763  if (!contains_key || (ret = ff_jni_exception_check(env, 1, format)) < 0) {
764  ret = 0;
765  goto fail;
766  }
767 
768  *out = (*env)->CallIntMethod(env, format->object, format->jfields.get_integer_id, key);
769  if ((ret = ff_jni_exception_check(env, 1, format)) < 0) {
770  ret = 0;
771  goto fail;
772  }
773 
774  ret = 1;
775 fail:
776  if (key) {
777  (*env)->DeleteLocalRef(env, key);
778  }
779 
780  return ret;
781 }
782 
783 int ff_AMediaFormat_getInt64(FFAMediaFormat* format, const char *name, int64_t *out)
784 {
785  int ret = 1;
786 
787  JNIEnv *env = NULL;
788  jstring key = NULL;
789  jboolean contains_key;
790 
791  av_assert0(format != NULL);
792 
793  JNI_GET_ENV_OR_RETURN(env, format, 0);
794 
795  key = ff_jni_utf_chars_to_jstring(env, name, format);
796  if (!key) {
797  ret = 0;
798  goto fail;
799  }
800 
801  contains_key = (*env)->CallBooleanMethod(env, format->object, format->jfields.contains_key_id, key);
802  if (!contains_key || (ret = ff_jni_exception_check(env, 1, format)) < 0) {
803  ret = 0;
804  goto fail;
805  }
806 
807  *out = (*env)->CallLongMethod(env, format->object, format->jfields.get_long_id, key);
808  if ((ret = ff_jni_exception_check(env, 1, format)) < 0) {
809  ret = 0;
810  goto fail;
811  }
812 
813  ret = 1;
814 fail:
815  if (key) {
816  (*env)->DeleteLocalRef(env, key);
817  }
818 
819  return ret;
820 }
821 
822 int ff_AMediaFormat_getFloat(FFAMediaFormat* format, const char *name, float *out)
823 {
824  int ret = 1;
825 
826  JNIEnv *env = NULL;
827  jstring key = NULL;
828  jboolean contains_key;
829 
830  av_assert0(format != NULL);
831 
832  JNI_GET_ENV_OR_RETURN(env, format, 0);
833 
834  key = ff_jni_utf_chars_to_jstring(env, name, format);
835  if (!key) {
836  ret = 0;
837  goto fail;
838  }
839 
840  contains_key = (*env)->CallBooleanMethod(env, format->object, format->jfields.contains_key_id, key);
841  if (!contains_key || (ret = ff_jni_exception_check(env, 1, format)) < 0) {
842  ret = 0;
843  goto fail;
844  }
845 
846  *out = (*env)->CallFloatMethod(env, format->object, format->jfields.get_float_id, key);
847  if ((ret = ff_jni_exception_check(env, 1, format)) < 0) {
848  ret = 0;
849  goto fail;
850  }
851 
852  ret = 1;
853 fail:
854  if (key) {
855  (*env)->DeleteLocalRef(env, key);
856  }
857 
858  return ret;
859 }
860 
861 int ff_AMediaFormat_getBuffer(FFAMediaFormat* format, const char *name, void** data, size_t *size)
862 {
863  int ret = 1;
864 
865  JNIEnv *env = NULL;
866  jstring key = NULL;
867  jboolean contains_key;
868  jobject result = NULL;
869 
870  av_assert0(format != NULL);
871 
872  JNI_GET_ENV_OR_RETURN(env, format, 0);
873 
874  key = ff_jni_utf_chars_to_jstring(env, name, format);
875  if (!key) {
876  ret = 0;
877  goto fail;
878  }
879 
880  contains_key = (*env)->CallBooleanMethod(env, format->object, format->jfields.contains_key_id, key);
881  if (!contains_key || (ret = ff_jni_exception_check(env, 1, format)) < 0) {
882  ret = 0;
883  goto fail;
884  }
885 
886  result = (*env)->CallObjectMethod(env, format->object, format->jfields.get_bytebuffer_id, key);
887  if ((ret = ff_jni_exception_check(env, 1, format)) < 0) {
888  ret = 0;
889  goto fail;
890  }
891 
892  *data = (*env)->GetDirectBufferAddress(env, result);
893  *size = (*env)->GetDirectBufferCapacity(env, result);
894 
895  if (*data && *size) {
896  void *src = *data;
897  *data = av_malloc(*size);
898  if (!*data) {
899  ret = 0;
900  goto fail;
901  }
902 
903  memcpy(*data, src, *size);
904  }
905 
906  ret = 1;
907 fail:
908  if (key) {
909  (*env)->DeleteLocalRef(env, key);
910  }
911 
912  if (result) {
913  (*env)->DeleteLocalRef(env, result);
914  }
915 
916  return ret;
917 }
918 
919 int ff_AMediaFormat_getString(FFAMediaFormat* format, const char *name, const char **out)
920 {
921  int ret = 1;
922 
923  JNIEnv *env = NULL;
924  jstring key = NULL;
925  jboolean contains_key;
926  jstring result = NULL;
927 
928  av_assert0(format != NULL);
929 
930  JNI_GET_ENV_OR_RETURN(env, format, 0);
931 
932  key = ff_jni_utf_chars_to_jstring(env, name, format);
933  if (!key) {
934  ret = 0;
935  goto fail;
936  }
937 
938  contains_key = (*env)->CallBooleanMethod(env, format->object, format->jfields.contains_key_id, key);
939  if (!contains_key || (ret = ff_jni_exception_check(env, 1, format)) < 0) {
940  ret = 0;
941  goto fail;
942  }
943 
944  result = (*env)->CallObjectMethod(env, format->object, format->jfields.get_string_id, key);
945  if ((ret = ff_jni_exception_check(env, 1, format)) < 0) {
946  ret = 0;
947  goto fail;
948  }
949 
950  *out = ff_jni_jstring_to_utf_chars(env, result, format);
951  if (!*out) {
952  ret = 0;
953  goto fail;
954  }
955 
956  ret = 1;
957 fail:
958  if (key) {
959  (*env)->DeleteLocalRef(env, key);
960  }
961 
962  if (result) {
963  (*env)->DeleteLocalRef(env, result);
964  }
965 
966  return ret;
967 }
968 
969 void ff_AMediaFormat_setInt32(FFAMediaFormat* format, const char* name, int32_t value)
970 {
971  JNIEnv *env = NULL;
972  jstring key = NULL;
973 
974  av_assert0(format != NULL);
975 
976  JNI_GET_ENV_OR_RETURN_VOID(env, format);
977 
978  key = ff_jni_utf_chars_to_jstring(env, name, format);
979  if (!key) {
980  goto fail;
981  }
982 
983  (*env)->CallVoidMethod(env, format->object, format->jfields.set_integer_id, key, value);
984  if (ff_jni_exception_check(env, 1, format) < 0) {
985  goto fail;
986  }
987 
988 fail:
989  if (key) {
990  (*env)->DeleteLocalRef(env, key);
991  }
992 }
993 
994 void ff_AMediaFormat_setInt64(FFAMediaFormat* format, const char* name, int64_t value)
995 {
996  JNIEnv *env = NULL;
997  jstring key = NULL;
998 
999  av_assert0(format != NULL);
1000 
1001  JNI_GET_ENV_OR_RETURN_VOID(env, format);
1002 
1003  key = ff_jni_utf_chars_to_jstring(env, name, format);
1004  if (!key) {
1005  goto fail;
1006  }
1007 
1008  (*env)->CallVoidMethod(env, format->object, format->jfields.set_long_id, key, value);
1009  if (ff_jni_exception_check(env, 1, format) < 0) {
1010  goto fail;
1011  }
1012 
1013 fail:
1014  if (key) {
1015  (*env)->DeleteLocalRef(env, key);
1016  }
1017 }
1018 
1019 void ff_AMediaFormat_setFloat(FFAMediaFormat* format, const char* name, float value)
1020 {
1021  JNIEnv *env = NULL;
1022  jstring key = NULL;
1023 
1024  av_assert0(format != NULL);
1025 
1026  JNI_GET_ENV_OR_RETURN_VOID(env, format);
1027 
1028  key = ff_jni_utf_chars_to_jstring(env, name, format);
1029  if (!key) {
1030  goto fail;
1031  }
1032 
1033  (*env)->CallVoidMethod(env, format->object, format->jfields.set_float_id, key, value);
1034  if (ff_jni_exception_check(env, 1, format) < 0) {
1035  goto fail;
1036  }
1037 
1038 fail:
1039  if (key) {
1040  (*env)->DeleteLocalRef(env, key);
1041  }
1042 }
1043 
1044 void ff_AMediaFormat_setString(FFAMediaFormat* format, const char* name, const char* value)
1045 {
1046  JNIEnv *env = NULL;
1047  jstring key = NULL;
1048  jstring string = NULL;
1049 
1050  av_assert0(format != NULL);
1051 
1052  JNI_GET_ENV_OR_RETURN_VOID(env, format);
1053 
1054  key = ff_jni_utf_chars_to_jstring(env, name, format);
1055  if (!key) {
1056  goto fail;
1057  }
1058 
1059  string = ff_jni_utf_chars_to_jstring(env, value, format);
1060  if (!string) {
1061  goto fail;
1062  }
1063 
1064  (*env)->CallVoidMethod(env, format->object, format->jfields.set_string_id, key, string);
1065  if (ff_jni_exception_check(env, 1, format) < 0) {
1066  goto fail;
1067  }
1068 
1069 fail:
1070  if (key) {
1071  (*env)->DeleteLocalRef(env, key);
1072  }
1073 
1074  if (string) {
1075  (*env)->DeleteLocalRef(env, string);
1076  }
1077 }
1078 
1079 void ff_AMediaFormat_setBuffer(FFAMediaFormat* format, const char* name, void* data, size_t size)
1080 {
1081  JNIEnv *env = NULL;
1082  jstring key = NULL;
1083  jobject buffer = NULL;
1084  void *buffer_data = NULL;
1085 
1086  av_assert0(format != NULL);
1087 
1088  JNI_GET_ENV_OR_RETURN_VOID(env, format);
1089 
1090  key = ff_jni_utf_chars_to_jstring(env, name, format);
1091  if (!key) {
1092  goto fail;
1093  }
1094 
1095  if (!data || !size) {
1096  goto fail;
1097  }
1098 
1099  buffer_data = av_malloc(size);
1100  if (!buffer_data) {
1101  goto fail;
1102  }
1103 
1104  memcpy(buffer_data, data, size);
1105 
1106  buffer = (*env)->NewDirectByteBuffer(env, buffer_data, size);
1107  if (!buffer) {
1108  goto fail;
1109  }
1110 
1111  (*env)->CallVoidMethod(env, format->object, format->jfields.set_bytebuffer_id, key, buffer);
1112  if (ff_jni_exception_check(env, 1, format) < 0) {
1113  goto fail;
1114  }
1115 
1116 fail:
1117  if (key) {
1118  (*env)->DeleteLocalRef(env, key);
1119  }
1120 
1121  if (buffer) {
1122  (*env)->DeleteLocalRef(env, buffer);
1123  }
1124 }
1125 
1126 static int codec_init_static_fields(FFAMediaCodec *codec)
1127 {
1128  int ret = 0;
1129  JNIEnv *env = NULL;
1130 
1131  JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);
1132 
1133  codec->INFO_TRY_AGAIN_LATER = (*env)->GetStaticIntField(env, codec->jfields.mediacodec_class, codec->jfields.info_try_again_later_id);
1134  if ((ret = ff_jni_exception_check(env, 1, codec)) < 0) {
1135  goto fail;
1136  }
1137 
1138  codec->BUFFER_FLAG_CODEC_CONFIG = (*env)->GetStaticIntField(env, codec->jfields.mediacodec_class, codec->jfields.buffer_flag_codec_config_id);
1139  if ((ret = ff_jni_exception_check(env, 1, codec)) < 0) {
1140  goto fail;
1141  }
1142 
1143  codec->BUFFER_FLAG_END_OF_STREAM = (*env)->GetStaticIntField(env, codec->jfields.mediacodec_class, codec->jfields.buffer_flag_end_of_stream_id);
1144  if ((ret = ff_jni_exception_check(env, 1, codec)) < 0) {
1145  goto fail;
1146  }
1147 
1148  if (codec->jfields.buffer_flag_key_frame_id) {
1149  codec->BUFFER_FLAG_KEY_FRAME = (*env)->GetStaticIntField(env, codec->jfields.mediacodec_class, codec->jfields.buffer_flag_key_frame_id);
1150  if ((ret = ff_jni_exception_check(env, 1, codec)) < 0) {
1151  goto fail;
1152  }
1153  }
1154 
1155  codec->CONFIGURE_FLAG_ENCODE = (*env)->GetStaticIntField(env, codec->jfields.mediacodec_class, codec->jfields.configure_flag_encode_id);
1156  if ((ret = ff_jni_exception_check(env, 1, codec)) < 0) {
1157  goto fail;
1158  }
1159 
1160  codec->INFO_TRY_AGAIN_LATER = (*env)->GetStaticIntField(env, codec->jfields.mediacodec_class, codec->jfields.info_try_again_later_id);
1161  if ((ret = ff_jni_exception_check(env, 1, codec)) < 0) {
1162  goto fail;
1163  }
1164 
1165  codec->INFO_OUTPUT_BUFFERS_CHANGED = (*env)->GetStaticIntField(env, codec->jfields.mediacodec_class, codec->jfields.info_output_buffers_changed_id);
1166  if ((ret = ff_jni_exception_check(env, 1, codec)) < 0) {
1167  goto fail;
1168  }
1169 
1170  codec->INFO_OUTPUT_FORMAT_CHANGED = (*env)->GetStaticIntField(env, codec->jfields.mediacodec_class, codec->jfields.info_output_format_changed_id);
1171  if ((ret = ff_jni_exception_check(env, 1, codec)) < 0) {
1172  goto fail;
1173  }
1174 
1175 fail:
1176 
1177  return ret;
1178 }
1179 
1180 #define CREATE_CODEC_BY_NAME 0
1181 #define CREATE_DECODER_BY_TYPE 1
1182 #define CREATE_ENCODER_BY_TYPE 2
1183 
1184 static inline FFAMediaCodec *codec_create(int method, const char *arg)
1185 {
1186  int ret = -1;
1187  JNIEnv *env = NULL;
1188  FFAMediaCodec *codec = NULL;
1189  jstring jarg = NULL;
1190  jobject object = NULL;
1191  jobject buffer_info = NULL;
1192  jmethodID create_id = NULL;
1193 
1194  codec = av_mallocz(sizeof(FFAMediaCodec));
1195  if (!codec) {
1196  return NULL;
1197  }
1198  codec->class = &amediacodec_class;
1199 
1200  env = ff_jni_get_env(codec);
1201  if (!env) {
1202  av_freep(&codec);
1203  return NULL;
1204  }
1205 
1206  if (ff_jni_init_jfields(env, &codec->jfields, jni_amediacodec_mapping, 1, codec) < 0) {
1207  goto fail;
1208  }
1209 
1210  jarg = ff_jni_utf_chars_to_jstring(env, arg, codec);
1211  if (!jarg) {
1212  goto fail;
1213  }
1214 
1215  switch (method) {
1216  case CREATE_CODEC_BY_NAME: create_id = codec->jfields.create_by_codec_name_id; break;
1217  case CREATE_DECODER_BY_TYPE: create_id = codec->jfields.create_decoder_by_type_id; break;
1218  case CREATE_ENCODER_BY_TYPE: create_id = codec->jfields.create_encoder_by_type_id; break;
1219  default:
1220  av_assert0(0);
1221  }
1222 
1223  object = (*env)->CallStaticObjectMethod(env,
1224  codec->jfields.mediacodec_class,
1225  create_id,
1226  jarg);
1227  if (ff_jni_exception_check(env, 1, codec) < 0) {
1228  goto fail;
1229  }
1230 
1231  codec->object = (*env)->NewGlobalRef(env, object);
1232  if (!codec->object) {
1233  goto fail;
1234  }
1235 
1236  if (codec_init_static_fields(codec) < 0) {
1237  goto fail;
1238  }
1239 
1240  if (codec->jfields.get_input_buffer_id && codec->jfields.get_output_buffer_id) {
1241  codec->has_get_i_o_buffer = 1;
1242  }
1243 
1244  buffer_info = (*env)->NewObject(env, codec->jfields.mediainfo_class, codec->jfields.init_id);
1245  if (ff_jni_exception_check(env, 1, codec) < 0) {
1246  goto fail;
1247  }
1248 
1249  codec->buffer_info = (*env)->NewGlobalRef(env, buffer_info);
1250  if (!codec->buffer_info) {
1251  goto fail;
1252  }
1253 
1254  ret = 0;
1255 fail:
1256  if (jarg) {
1257  (*env)->DeleteLocalRef(env, jarg);
1258  }
1259 
1260  if (object) {
1261  (*env)->DeleteLocalRef(env, object);
1262  }
1263 
1264  if (buffer_info) {
1265  (*env)->DeleteLocalRef(env, buffer_info);
1266  }
1267 
1268  if (ret < 0) {
1269  if (codec->object) {
1270  (*env)->DeleteGlobalRef(env, codec->object);
1271  }
1272 
1273  if (codec->buffer_info) {
1274  (*env)->DeleteGlobalRef(env, codec->buffer_info);
1275  }
1276 
1277  ff_jni_reset_jfields(env, &codec->jfields, jni_amediacodec_mapping, 1, codec);
1278  av_freep(&codec);
1279  }
1280 
1281  return codec;
1282 }
1283 
1284 #define DECLARE_FF_AMEDIACODEC_CREATE_FUNC(name, method) \
1285 FFAMediaCodec *ff_AMediaCodec_##name(const char *arg) \
1286 { \
1287  return codec_create(method, arg); \
1288 } \
1289 
1290 DECLARE_FF_AMEDIACODEC_CREATE_FUNC(createCodecByName, CREATE_CODEC_BY_NAME)
1291 DECLARE_FF_AMEDIACODEC_CREATE_FUNC(createDecoderByType, CREATE_DECODER_BY_TYPE)
1292 DECLARE_FF_AMEDIACODEC_CREATE_FUNC(createEncoderByType, CREATE_ENCODER_BY_TYPE)
1293 
1294 int ff_AMediaCodec_delete(FFAMediaCodec* codec)
1295 {
1296  int ret = 0;
1297 
1298  JNIEnv *env = NULL;
1299 
1300  if (!codec) {
1301  return 0;
1302  }
1303 
1304  JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);
1305 
1306  (*env)->CallVoidMethod(env, codec->object, codec->jfields.release_id);
1307  if (ff_jni_exception_check(env, 1, codec) < 0) {
1308  ret = AVERROR_EXTERNAL;
1309  }
1310 
1311  (*env)->DeleteGlobalRef(env, codec->object);
1312  codec->object = NULL;
1313 
1314  (*env)->DeleteGlobalRef(env, codec->buffer_info);
1315  codec->buffer_info = NULL;
1316 
1317  ff_jni_reset_jfields(env, &codec->jfields, jni_amediacodec_mapping, 1, codec);
1318 
1319  av_freep(&codec);
1320 
1321  return ret;
1322 }
1323 
1324 char *ff_AMediaCodec_getName(FFAMediaCodec *codec)
1325 {
1326  char *ret = NULL;
1327  JNIEnv *env = NULL;
1328  jobject *name = NULL;
1329 
1330  JNI_GET_ENV_OR_RETURN(env, codec, NULL);
1331 
1332  name = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_name_id);
1333  if (ff_jni_exception_check(env, 1, codec) < 0) {
1334  goto fail;
1335  }
1336 
1337  ret = ff_jni_jstring_to_utf_chars(env, name, codec);
1338 
1339 fail:
1340  return ret;
1341 }
1342 
1343 int ff_AMediaCodec_configure(FFAMediaCodec* codec, const FFAMediaFormat* format, void* surface, void *crypto, uint32_t flags)
1344 {
1345  int ret = 0;
1346  JNIEnv *env = NULL;
1347 
1348  JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);
1349 
1350  (*env)->CallVoidMethod(env, codec->object, codec->jfields.configure_id, format->object, surface, NULL, flags);
1351  if (ff_jni_exception_check(env, 1, codec) < 0) {
1352  ret = AVERROR_EXTERNAL;
1353  goto fail;
1354  }
1355 
1356 fail:
1357  return ret;
1358 }
1359 
1360 int ff_AMediaCodec_start(FFAMediaCodec* codec)
1361 {
1362  int ret = 0;
1363  JNIEnv *env = NULL;
1364 
1365  JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);
1366 
1367  (*env)->CallVoidMethod(env, codec->object, codec->jfields.start_id);
1368  if (ff_jni_exception_check(env, 1, codec) < 0) {
1369  ret = AVERROR_EXTERNAL;
1370  goto fail;
1371  }
1372 
1373 fail:
1374  return ret;
1375 }
1376 
1377 int ff_AMediaCodec_stop(FFAMediaCodec* codec)
1378 {
1379  int ret = 0;
1380  JNIEnv *env = NULL;
1381 
1382  JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);
1383 
1384  (*env)->CallVoidMethod(env, codec->object, codec->jfields.stop_id);
1385  if (ff_jni_exception_check(env, 1, codec) < 0) {
1386  ret = AVERROR_EXTERNAL;
1387  goto fail;
1388  }
1389 
1390 fail:
1391  return ret;
1392 }
1393 
1394 int ff_AMediaCodec_flush(FFAMediaCodec* codec)
1395 {
1396  int ret = 0;
1397  JNIEnv *env = NULL;
1398 
1399  JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);
1400 
1401  (*env)->CallVoidMethod(env, codec->object, codec->jfields.flush_id);
1402  if (ff_jni_exception_check(env, 1, codec) < 0) {
1403  ret = AVERROR_EXTERNAL;
1404  goto fail;
1405  }
1406 
1407 fail:
1408  return ret;
1409 }
1410 
1411 int ff_AMediaCodec_releaseOutputBuffer(FFAMediaCodec* codec, size_t idx, int render)
1412 {
1413  int ret = 0;
1414  JNIEnv *env = NULL;
1415 
1416  JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);
1417 
1418  (*env)->CallVoidMethod(env, codec->object, codec->jfields.release_output_buffer_id, (jint)idx, (jboolean)render);
1419  if (ff_jni_exception_check(env, 1, codec) < 0) {
1420  ret = AVERROR_EXTERNAL;
1421  goto fail;
1422  }
1423 
1424 fail:
1425  return ret;
1426 }
1427 
1428 int ff_AMediaCodec_releaseOutputBufferAtTime(FFAMediaCodec *codec, size_t idx, int64_t timestampNs)
1429 {
1430  int ret = 0;
1431  JNIEnv *env = NULL;
1432 
1433  JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);
1434 
1435  (*env)->CallVoidMethod(env, codec->object, codec->jfields.release_output_buffer_at_time_id, (jint)idx, (jlong)timestampNs);
1436  if (ff_jni_exception_check(env, 1, codec) < 0) {
1437  ret = AVERROR_EXTERNAL;
1438  goto fail;
1439  }
1440 
1441 fail:
1442  return ret;
1443 }
1444 
1445 ssize_t ff_AMediaCodec_dequeueInputBuffer(FFAMediaCodec* codec, int64_t timeoutUs)
1446 {
1447  int ret = 0;
1448  JNIEnv *env = NULL;
1449 
1450  JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);
1451 
1452  ret = (*env)->CallIntMethod(env, codec->object, codec->jfields.dequeue_input_buffer_id, timeoutUs);
1453  if (ff_jni_exception_check(env, 1, codec) < 0) {
1454  ret = AVERROR_EXTERNAL;
1455  goto fail;
1456  }
1457 
1458 fail:
1459  return ret;
1460 }
1461 
1462 int ff_AMediaCodec_queueInputBuffer(FFAMediaCodec* codec, size_t idx, off_t offset, size_t size, uint64_t time, uint32_t flags)
1463 {
1464  int ret = 0;
1465  JNIEnv *env = NULL;
1466 
1467  JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);
1468 
1469  (*env)->CallVoidMethod(env, codec->object, codec->jfields.queue_input_buffer_id, (jint)idx, (jint)offset, (jint)size, time, flags);
1470  if ((ret = ff_jni_exception_check(env, 1, codec)) < 0) {
1471  ret = AVERROR_EXTERNAL;
1472  goto fail;
1473  }
1474 
1475 fail:
1476  return ret;
1477 }
1478 
1479 ssize_t ff_AMediaCodec_dequeueOutputBuffer(FFAMediaCodec* codec, FFAMediaCodecBufferInfo *info, int64_t timeoutUs)
1480 {
1481  int ret = 0;
1482  JNIEnv *env = NULL;
1483 
1484  JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);
1485 
1486  ret = (*env)->CallIntMethod(env, codec->object, codec->jfields.dequeue_output_buffer_id, codec->buffer_info, timeoutUs);
1487  if (ff_jni_exception_check(env, 1, codec) < 0) {
1488  return AVERROR_EXTERNAL;
1489  }
1490 
1491  info->flags = (*env)->GetIntField(env, codec->buffer_info, codec->jfields.flags_id);
1492  if (ff_jni_exception_check(env, 1, codec) < 0) {
1493  return AVERROR_EXTERNAL;
1494  }
1495 
1496  info->offset = (*env)->GetIntField(env, codec->buffer_info, codec->jfields.offset_id);
1497  if (ff_jni_exception_check(env, 1, codec) < 0) {
1498  return AVERROR_EXTERNAL;
1499  }
1500 
1501  info->presentationTimeUs = (*env)->GetLongField(env, codec->buffer_info, codec->jfields.presentation_time_us_id);
1502  if (ff_jni_exception_check(env, 1, codec) < 0) {
1503  return AVERROR_EXTERNAL;
1504  }
1505 
1506  info->size = (*env)->GetIntField(env, codec->buffer_info, codec->jfields.size_id);
1507  if (ff_jni_exception_check(env, 1, codec) < 0) {
1508  return AVERROR_EXTERNAL;
1509  }
1510 
1511  return ret;
1512 }
1513 
1514 uint8_t* ff_AMediaCodec_getInputBuffer(FFAMediaCodec* codec, size_t idx, size_t *out_size)
1515 {
1516  uint8_t *ret = NULL;
1517  JNIEnv *env = NULL;
1518 
1519  jobject buffer = NULL;
1520  jobject input_buffers = NULL;
1521 
1522  JNI_GET_ENV_OR_RETURN(env, codec, NULL);
1523 
1524  if (codec->has_get_i_o_buffer) {
1525  buffer = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_input_buffer_id, (jint)idx);
1526  if (ff_jni_exception_check(env, 1, codec) < 0) {
1527  goto fail;
1528  }
1529  } else {
1530  if (!codec->input_buffers) {
1531  input_buffers = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_input_buffers_id);
1532  if (ff_jni_exception_check(env, 1, codec) < 0) {
1533  goto fail;
1534  }
1535 
1536  codec->input_buffers = (*env)->NewGlobalRef(env, input_buffers);
1537  if (ff_jni_exception_check(env, 1, codec) < 0) {
1538  goto fail;
1539  }
1540  }
1541 
1542  buffer = (*env)->GetObjectArrayElement(env, codec->input_buffers, idx);
1543  if (ff_jni_exception_check(env, 1, codec) < 0) {
1544  goto fail;
1545  }
1546  }
1547 
1548  ret = (*env)->GetDirectBufferAddress(env, buffer);
1549  *out_size = (*env)->GetDirectBufferCapacity(env, buffer);
1550 fail:
1551  if (buffer) {
1552  (*env)->DeleteLocalRef(env, buffer);
1553  }
1554 
1555  if (input_buffers) {
1556  (*env)->DeleteLocalRef(env, input_buffers);
1557  }
1558 
1559  return ret;
1560 }
1561 
1562 uint8_t* ff_AMediaCodec_getOutputBuffer(FFAMediaCodec* codec, size_t idx, size_t *out_size)
1563 {
1564  uint8_t *ret = NULL;
1565  JNIEnv *env = NULL;
1566 
1567  jobject buffer = NULL;
1568  jobject output_buffers = NULL;
1569 
1570  JNI_GET_ENV_OR_RETURN(env, codec, NULL);
1571 
1572  if (codec->has_get_i_o_buffer) {
1573  buffer = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_output_buffer_id, (jint)idx);
1574  if (ff_jni_exception_check(env, 1, codec) < 0) {
1575  goto fail;
1576  }
1577  } else {
1578  if (!codec->output_buffers) {
1579  output_buffers = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_output_buffers_id);
1580  if (ff_jni_exception_check(env, 1, codec) < 0) {
1581  goto fail;
1582  }
1583 
1584  codec->output_buffers = (*env)->NewGlobalRef(env, output_buffers);
1585  if (ff_jni_exception_check(env, 1, codec) < 0) {
1586  goto fail;
1587  }
1588  }
1589 
1590  buffer = (*env)->GetObjectArrayElement(env, codec->output_buffers, idx);
1591  if (ff_jni_exception_check(env, 1, codec) < 0) {
1592  goto fail;
1593  }
1594  }
1595 
1596  ret = (*env)->GetDirectBufferAddress(env, buffer);
1597  *out_size = (*env)->GetDirectBufferCapacity(env, buffer);
1598 fail:
1599  if (buffer) {
1600  (*env)->DeleteLocalRef(env, buffer);
1601  }
1602 
1603  if (output_buffers) {
1604  (*env)->DeleteLocalRef(env, output_buffers);
1605  }
1606 
1607  return ret;
1608 }
1609 
1610 FFAMediaFormat* ff_AMediaCodec_getOutputFormat(FFAMediaCodec* codec)
1611 {
1612  FFAMediaFormat *ret = NULL;
1613  JNIEnv *env = NULL;
1614 
1615  jobject mediaformat = NULL;
1616 
1617  JNI_GET_ENV_OR_RETURN(env, codec, NULL);
1618 
1619  mediaformat = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_output_format_id);
1620  if (ff_jni_exception_check(env, 1, codec) < 0) {
1621  goto fail;
1622  }
1623 
1624  ret = ff_AMediaFormat_newFromObject(mediaformat);
1625 fail:
1626  if (mediaformat) {
1627  (*env)->DeleteLocalRef(env, mediaformat);
1628  }
1629 
1630  return ret;
1631 }
1632 
1633 int ff_AMediaCodec_infoTryAgainLater(FFAMediaCodec *codec, ssize_t idx)
1634 {
1635  return idx == codec->INFO_TRY_AGAIN_LATER;
1636 }
1637 
1638 int ff_AMediaCodec_infoOutputBuffersChanged(FFAMediaCodec *codec, ssize_t idx)
1639 {
1640  return idx == codec->INFO_OUTPUT_BUFFERS_CHANGED;
1641 }
1642 
1643 int ff_AMediaCodec_infoOutputFormatChanged(FFAMediaCodec *codec, ssize_t idx)
1644 {
1645  return idx == codec->INFO_OUTPUT_FORMAT_CHANGED;
1646 }
1647 
1648 int ff_AMediaCodec_getBufferFlagCodecConfig(FFAMediaCodec *codec)
1649 {
1650  return codec->BUFFER_FLAG_CODEC_CONFIG;
1651 }
1652 
1653 int ff_AMediaCodec_getBufferFlagEndOfStream(FFAMediaCodec *codec)
1654 {
1655  return codec->BUFFER_FLAG_END_OF_STREAM;
1656 }
1657 
1658 int ff_AMediaCodec_getBufferFlagKeyFrame(FFAMediaCodec *codec)
1659 {
1660  return codec->BUFFER_FLAG_KEY_FRAME;
1661 }
1662 
1663 int ff_AMediaCodec_getConfigureFlagEncode(FFAMediaCodec *codec)
1664 {
1665  return codec->CONFIGURE_FLAG_ENCODE;
1666 }
1667 
1668 int ff_AMediaCodec_cleanOutputBuffers(FFAMediaCodec *codec)
1669 {
1670  int ret = 0;
1671 
1672  if (!codec->has_get_i_o_buffer) {
1673  if (codec->output_buffers) {
1674  JNIEnv *env = NULL;
1675 
1676  env = ff_jni_get_env(codec);
1677  if (!env) {
1678  ret = AVERROR_EXTERNAL;
1679  goto fail;
1680  }
1681 
1682  (*env)->DeleteGlobalRef(env, codec->output_buffers);
1683  codec->output_buffers = NULL;
1684  }
1685  }
1686 
1687 fail:
1688  return ret;
1689 }
1690 
1691 int ff_Build_SDK_INT(AVCodecContext *avctx)
1692 {
1693  int ret = -1;
1694  JNIEnv *env = NULL;
1695  jclass versionClass;
1696  jfieldID sdkIntFieldID;
1697  JNI_GET_ENV_OR_RETURN(env, avctx, -1);
1698 
1699  versionClass = (*env)->FindClass(env, "android/os/Build$VERSION");
1700  sdkIntFieldID = (*env)->GetStaticFieldID(env, versionClass, "SDK_INT", "I");
1701  ret = (*env)->GetStaticIntField(env, versionClass, sdkIntFieldID);
1702  (*env)->DeleteLocalRef(env, versionClass);
1703  return ret;
1704 }
FF_PROFILE_H264_MAIN
#define FF_PROFILE_H264_MAIN
Definition: avcodec.h:2900
mediacodec_wrapper.h
NULL
#define NULL
Definition: coverity.c:32
FFAMediaCodec::class
const AVClass * class
Definition: mediacodec_wrapper.c:276
ff_AMediaFormat_getBuffer
int ff_AMediaFormat_getBuffer(FFAMediaFormat *format, const char *name, void **data, size_t *size)
Definition: mediacodec_wrapper.c:861
format
static const char * format[]
Definition: af_aiir.c:330
data
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
ff_jni_reset_jfields
int ff_jni_reset_jfields(JNIEnv *env, void *jfields, const struct FFJniField *jfields_mapping, int global, void *log_ctx)
Definition: ffjni.c:374
ff_AMediaCodecList_getCodecNameByType
char * ff_AMediaCodecList_getCodecNameByType(const char *mime, int profile, int encoder, void *log_ctx)
Definition: mediacodec_wrapper.c:382
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
mem.h
Memory handling functions.
ff_AMediaFormat_setBuffer
void ff_AMediaFormat_setBuffer(FFAMediaFormat *format, const char *name, void *data, size_t size)
Definition: mediacodec_wrapper.c:1079
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
ff_AMediaFormat_newFromObject
static FFAMediaFormat * ff_AMediaFormat_newFromObject(void *object)
Definition: mediacodec_wrapper.c:662
FFAMediaFormat::jfields
struct JNIAMediaFormatFields jfields
Definition: mediacodec_wrapper.c:165
out_size
int out_size
Definition: movenc.c:55
ff_jni_utf_chars_to_jstring
jstring ff_jni_utf_chars_to_jstring(JNIEnv *env, const char *utf_chars, void *log_ctx)
Definition: ffjni.c:127
key
const char * key
Definition: hwcontext_opencl.c:168
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
jni_amediacodeclist_mapping
static const struct FFJniField jni_amediacodeclist_mapping[]
Definition: mediacodec_wrapper.c:71
src
#define src
Definition: vp8dsp.c:254
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:2859
AV_CODEC_ID_H264
Definition: avcodec.h:245
jni_amediacodec_mapping
static const struct FFJniField jni_amediacodec_mapping[]
Definition: mediacodec_wrapper.c:219
amediacodec_class
static const AVClass amediacodec_class
Definition: mediacodec_wrapper.c:268
FF_PROFILE_H264_HIGH_444_PREDICTIVE
#define FF_PROFILE_H264_HIGH_444_PREDICTIVE
Definition: avcodec.h:2910
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
CREATE_CODEC_BY_NAME
#define CREATE_CODEC_BY_NAME
Definition: mediacodec_wrapper.c:1180
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
ff_AMediaCodec_flush
int ff_AMediaCodec_flush(FFAMediaCodec *codec)
Definition: mediacodec_wrapper.c:1394
FF_PROFILE_H264_BASELINE
#define FF_PROFILE_H264_BASELINE
Definition: avcodec.h:2898
ff_AMediaCodec_releaseOutputBuffer
int ff_AMediaCodec_releaseOutputBuffer(FFAMediaCodec *codec, size_t idx, int render)
Definition: mediacodec_wrapper.c:1411
uint8_t
uint8_t
Definition: audio_convert.c:194
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
ff_AMediaFormat_new
FFAMediaFormat * ff_AMediaFormat_new(void)
Definition: mediacodec_wrapper.c:617
ff_AMediaCodec_infoOutputBuffersChanged
int ff_AMediaCodec_infoOutputBuffersChanged(FFAMediaCodec *codec, ssize_t idx)
Definition: mediacodec_wrapper.c:1638
FF_PROFILE_HEVC_MAIN
#define FF_PROFILE_HEVC_MAIN
Definition: avcodec.h:2947
ff_Build_SDK_INT
int ff_Build_SDK_INT(AVCodecContext *avctx)
Definition: mediacodec_wrapper.c:1691
ff_AMediaCodec_infoOutputFormatChanged
int ff_AMediaCodec_infoOutputFormatChanged(FFAMediaCodec *codec, ssize_t idx)
Definition: mediacodec_wrapper.c:1643
FF_PROFILE_H264_EXTENDED
#define FF_PROFILE_H264_EXTENDED
Definition: avcodec.h:2901
ff_AMediaFormat_toString
char * ff_AMediaFormat_toString(FFAMediaFormat *format)
Definition: mediacodec_wrapper.c:719
size
ptrdiff_t size
Definition: opengl_enc.c:101
FF_PROFILE_HEVC_MAIN_10
#define FF_PROFILE_HEVC_MAIN_10
Definition: avcodec.h:2948
ff_AMediaFormat_getFloat
int ff_AMediaFormat_getFloat(FFAMediaFormat *format, const char *name, float *out)
Definition: mediacodec_wrapper.c:822
version.h
Libavcodec version macros.
jni_amediaformat_mapping
static const struct FFJniField jni_amediaformat_mapping[]
Definition: mediacodec_wrapper.c:132
ff_AMediaCodec_getName
char * ff_AMediaCodec_getName(FFAMediaCodec *codec)
Definition: mediacodec_wrapper.c:1324
JNIAMediaCodecFields::info_output_format_changed_id
jfieldID info_output_format_changed_id
Definition: mediacodec_wrapper.c:175
ff_AMediaCodec_getInputBuffer
uint8_t * ff_AMediaCodec_getInputBuffer(FFAMediaCodec *codec, size_t idx, size_t *out_size)
Definition: mediacodec_wrapper.c:1514
arg
const char * arg
Definition: jacosubdec.c:66
FF_PROFILE_H264_HIGH_422
#define FF_PROFILE_H264_HIGH_422
Definition: avcodec.h:2906
FF_PROFILE_H264_HIGH
#define FF_PROFILE_H264_HIGH
Definition: avcodec.h:2902
JNI_GET_ENV_OR_RETURN_VOID
#define JNI_GET_ENV_OR_RETURN_VOID(env, log_ctx)
Definition: mediacodec_wrapper.c:306
avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().
offset
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
fail
#define fail()
Definition: checkasm.h:117
DECLARE_FF_AMEDIACODEC_CREATE_FUNC
#define DECLARE_FF_AMEDIACODEC_CREATE_FUNC(name, method)
Definition: mediacodec_wrapper.c:1284
ff_AMediaCodec_queueInputBuffer
int ff_AMediaCodec_queueInputBuffer(FFAMediaCodec *codec, size_t idx, off_t offset, size_t size, uint64_t time, uint32_t flags)
Definition: mediacodec_wrapper.c:1462
ff_AMediaCodec_dequeueOutputBuffer
ssize_t ff_AMediaCodec_dequeueOutputBuffer(FFAMediaCodec *codec, FFAMediaCodecBufferInfo *info, int64_t timeoutUs)
Definition: mediacodec_wrapper.c:1479
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:213
ff_AMediaFormat_setInt32
void ff_AMediaFormat_setInt32(FFAMediaFormat *format, const char *name, int32_t value)
Definition: mediacodec_wrapper.c:969
ff_jni_jstring_to_utf_chars
char * ff_jni_jstring_to_utf_chars(JNIEnv *env, jstring string, void *log_ctx)
Definition: ffjni.c:97
ff_AMediaCodec_delete
int ff_AMediaCodec_delete(FFAMediaCodec *codec)
Definition: mediacodec_wrapper.c:1294
ff_AMediaFormat_getString
int ff_AMediaFormat_getString(FFAMediaFormat *format, const char *name, const char **out)
Definition: mediacodec_wrapper.c:919
value
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:109
FF_PROFILE_HEVC_MAIN_STILL_PICTURE
#define FF_PROFILE_HEVC_MAIN_STILL_PICTURE
Definition: avcodec.h:2949
int32_t
int32_t
Definition: audio_convert.c:194
ff_AMediaFormat_setInt64
void ff_AMediaFormat_setInt64(FFAMediaFormat *format, const char *name, int64_t value)
Definition: mediacodec_wrapper.c:994
ff_AMediaCodec_getBufferFlagEndOfStream
int ff_AMediaCodec_getBufferFlagEndOfStream(FFAMediaCodec *codec)
Definition: mediacodec_wrapper.c:1653
ff_jni_init_jfields
int ff_jni_init_jfields(JNIEnv *env, void *jfields, const struct FFJniField *jfields_mapping, int global, void *log_ctx)
Definition: ffjni.c:285
ff_AMediaFormat_setFloat
void ff_AMediaFormat_setFloat(FFAMediaFormat *format, const char *name, float value)
Definition: mediacodec_wrapper.c:1019
ff_jni_exception_check
int ff_jni_exception_check(JNIEnv *env, int log, void *log_ctx)
Definition: ffjni.c:252
ff_AMediaCodec_getBufferFlagKeyFrame
int ff_AMediaCodec_getBufferFlagKeyFrame(FFAMediaCodec *codec)
Definition: mediacodec_wrapper.c:1658
ff_AMediaFormat_setString
void ff_AMediaFormat_setString(FFAMediaFormat *format, const char *name, const char *value)
Definition: mediacodec_wrapper.c:1044
ff_AMediaCodec_dequeueInputBuffer
ssize_t ff_AMediaCodec_dequeueInputBuffer(FFAMediaCodec *codec, int64_t timeoutUs)
Definition: mediacodec_wrapper.c:1445
CREATE_DECODER_BY_TYPE
#define CREATE_DECODER_BY_TYPE
Definition: mediacodec_wrapper.c:1181
ff_AMediaFormat_getInt32
int ff_AMediaFormat_getInt32(FFAMediaFormat *format, const char *name, int32_t *out)
Definition: mediacodec_wrapper.c:744
FFAMediaCodec::jfields
struct JNIAMediaCodecFields jfields
Definition: mediacodec_wrapper.c:278
ff_AMediaCodec_cleanOutputBuffers
int ff_AMediaCodec_cleanOutputBuffers(FFAMediaCodec *codec)
Definition: mediacodec_wrapper.c:1668
ff_AMediaCodec_start
int ff_AMediaCodec_start(FFAMediaCodec *codec)
Definition: mediacodec_wrapper.c:1360
avcodec.h
Libavcodec external API header.
ff_AMediaCodec_getBufferFlagCodecConfig
int ff_AMediaCodec_getBufferFlagCodecConfig(FFAMediaCodec *codec)
Definition: mediacodec_wrapper.c:1648
FF_PROFILE_H264_HIGH_422_INTRA
#define FF_PROFILE_H264_HIGH_422_INTRA
Definition: avcodec.h:2907
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:1543
CREATE_ENCODER_BY_TYPE
#define CREATE_ENCODER_BY_TYPE
Definition: mediacodec_wrapper.c:1182
AVCodecContext
main external API structure.
Definition: avcodec.h:1533
ff_AMediaCodecProfile_getProfileFromAVCodecContext
int ff_AMediaCodecProfile_getProfileFromAVCodecContext(AVCodecContext *avctx)
The following API around MediaCodec and MediaFormat is based on the NDK one provided by Google since ...
Definition: mediacodec_wrapper.c:313
type
GLint GLenum type
Definition: opengl_enc.c:105
FF_PROFILE_H264_HIGH_10_INTRA
#define FF_PROFILE_H264_HIGH_10_INTRA
Definition: avcodec.h:2904
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
FF_PROFILE_H264_HIGH_444
#define FF_PROFILE_H264_HIGH_444
Definition: avcodec.h:2909
JNIAMediaCodecFields::info_output_buffers_changed_id
jfieldID info_output_buffers_changed_id
Definition: mediacodec_wrapper.c:174
ff_AMediaCodec_stop
int ff_AMediaCodec_stop(FFAMediaCodec *codec)
Definition: mediacodec_wrapper.c:1377
ff_AMediaCodec_infoTryAgainLater
int ff_AMediaCodec_infoTryAgainLater(FFAMediaCodec *codec, ssize_t idx)
Definition: mediacodec_wrapper.c:1633
ff_AMediaFormat_delete
int ff_AMediaFormat_delete(FFAMediaFormat *format)
Definition: mediacodec_wrapper.c:697
AV_CODEC_ID_HEVC
Definition: avcodec.h:392
profile
mfxU16 profile
Definition: qsvenc.c:44
JNIAMediaCodecFields::release_output_buffer_at_time_id
jmethodID release_output_buffer_at_time_id
Definition: mediacodec_wrapper.c:206
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:596
ff_AMediaCodec_getOutputBuffer
uint8_t * ff_AMediaCodec_getOutputBuffer(FFAMediaCodec *codec, size_t idx, size_t *out_size)
Definition: mediacodec_wrapper.c:1562
ff_AMediaCodec_configure
int ff_AMediaCodec_configure(FFAMediaCodec *codec, const FFAMediaFormat *format, void *surface, void *crypto, uint32_t flags)
Definition: mediacodec_wrapper.c:1343
ff_jni_get_env
JNIEnv * ff_jni_get_env(void *log_ctx)
Definition: ffjni.c:51
amediaformat_class
static const AVClass amediaformat_class
Definition: mediacodec_wrapper.c:156
FFAMediaFormat::class
const AVClass * class
Definition: mediacodec_wrapper.c:164
JNI_GET_ENV_OR_RETURN
#define JNI_GET_ENV_OR_RETURN(env, log_ctx, ret)
Definition: mediacodec_wrapper.c:299
ff_AMediaCodec_getConfigureFlagEncode
int ff_AMediaCodec_getConfigureFlagEncode(FFAMediaCodec *codec)
Definition: mediacodec_wrapper.c:1663
codec_init_static_fields
static int codec_init_static_fields(FFAMediaCodec *codec)
Definition: mediacodec_wrapper.c:1126
ff_AMediaCodec_getOutputFormat
FFAMediaFormat * ff_AMediaCodec_getOutputFormat(FFAMediaCodec *codec)
Definition: mediacodec_wrapper.c:1610
FF_PROFILE_H264_HIGH_444_INTRA
#define FF_PROFILE_H264_HIGH_444_INTRA
Definition: avcodec.h:2911
out
FILE * out
Definition: movenc.c:54
ff_AMediaFormat_getInt64
int ff_AMediaFormat_getInt64(FFAMediaFormat *format, const char *name, int64_t *out)
Definition: mediacodec_wrapper.c:783
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
codec_create
static FFAMediaCodec * codec_create(int method, const char *arg)
Definition: mediacodec_wrapper.c:1184
FF_PROFILE_H264_CONSTRAINED_BASELINE
#define FF_PROFILE_H264_CONSTRAINED_BASELINE
Definition: avcodec.h:2899
buffer_data
Definition: avio_reading.c:37
FF_PROFILE_H264_HIGH_10
#define FF_PROFILE_H264_HIGH_10
Definition: avcodec.h:2903
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:57
ff_AMediaCodec_releaseOutputBufferAtTime
int ff_AMediaCodec_releaseOutputBufferAtTime(FFAMediaCodec *codec, size_t idx, int64_t timestampNs)
Definition: mediacodec_wrapper.c:1428
buffer
GLuint buffer
Definition: opengl_enc.c:102
name
const char * name
Definition: opengl_enc.c:103
Generated on Tue Nov 6 2018 18:11:08 for FFmpeg by   doxygen 1.8.6