FFmpeg
mediacodecdec.c
Go to the documentation of this file.
1 /*
2  * Android MediaCodec MPEG-2 / H.264 / H.265 / MPEG-4 / VP8 / VP9 decoders
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 "config_components.h"
24 
25 #include <stdint.h>
26 #include <string.h>
27 
28 #include "libavutil/avassert.h"
29 #include "libavutil/common.h"
30 #include "libavutil/mem.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/intreadwrite.h"
33 #include "libavutil/pixfmt.h"
34 #include "libavutil/internal.h"
35 
36 #include "avcodec.h"
37 #include "codec_internal.h"
38 #include "decode.h"
39 #include "h264_parse.h"
40 #include "h264_ps.h"
41 #include "hevc/parse.h"
42 #include "hwconfig.h"
43 #include "internal.h"
44 #include "jni.h"
45 #include "mediacodec_wrapper.h"
46 #include "mediacodecdec_common.h"
47 
48 typedef struct MediaCodecH264DecContext {
49 
51 
53 
55 
58 
60  // Ref. MediaFormat KEY_OPERATING_RATE
63 
65 {
67 
68  ff_mediacodec_dec_close(avctx, s->ctx);
69  s->ctx = NULL;
70 
71  av_packet_unref(&s->buffered_pkt);
72 
73  return 0;
74 }
75 
76 #if CONFIG_H264_MEDIACODEC_DECODER || CONFIG_HEVC_MEDIACODEC_DECODER
77 static int h2645_ps_to_nalu(const uint8_t *src, int src_size, uint8_t **out, int *out_size)
78 {
79  int i;
80  int ret = 0;
81  uint8_t *p = NULL;
82  static const uint8_t nalu_header[] = { 0x00, 0x00, 0x00, 0x01 };
83 
84  if (!out || !out_size) {
85  return AVERROR(EINVAL);
86  }
87 
88  p = av_malloc(sizeof(nalu_header) + src_size);
89  if (!p) {
90  return AVERROR(ENOMEM);
91  }
92 
93  *out = p;
94  *out_size = sizeof(nalu_header) + src_size;
95 
96  memcpy(p, nalu_header, sizeof(nalu_header));
97  memcpy(p + sizeof(nalu_header), src, src_size);
98 
99  /* Escape 0x00, 0x00, 0x0{0-3} pattern */
100  for (i = 4; i < *out_size; i++) {
101  if (i < *out_size - 3 &&
102  p[i + 0] == 0 &&
103  p[i + 1] == 0 &&
104  p[i + 2] <= 3) {
105  uint8_t *new;
106 
107  *out_size += 1;
108  new = av_realloc(*out, *out_size);
109  if (!new) {
110  ret = AVERROR(ENOMEM);
111  goto done;
112  }
113  *out = p = new;
114 
115  i = i + 2;
116  memmove(p + i + 1, p + i, *out_size - (i + 1));
117  p[i] = 0x03;
118  }
119  }
120 done:
121  if (ret < 0) {
122  av_freep(out);
123  *out_size = 0;
124  }
125 
126  return ret;
127 }
128 #endif
129 
130 #if CONFIG_H264_MEDIACODEC_DECODER
131 static int h264_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
132 {
133  int i;
134  int ret;
135 
136  H264ParamSets ps;
137  const PPS *pps = NULL;
138  const SPS *sps = NULL;
139  int is_avc = 0;
140  int nal_length_size = 0;
141 
142  memset(&ps, 0, sizeof(ps));
143 
145  &ps, &is_avc, &nal_length_size, 0, avctx);
146  if (ret < 0) {
147  goto done;
148  }
149 
150  for (i = 0; i < MAX_PPS_COUNT; i++) {
151  if (ps.pps_list[i]) {
152  pps = ps.pps_list[i];
153  break;
154  }
155  }
156 
157  if (pps) {
158  if (ps.sps_list[pps->sps_id]) {
159  sps = ps.sps_list[pps->sps_id];
160  }
161  }
162 
163  if (pps && sps) {
164  uint8_t *data = NULL;
165  int data_size = 0;
166 
167  avctx->profile = ff_h264_get_profile(sps);
168  avctx->level = sps->level_idc;
169 
170  if ((ret = h2645_ps_to_nalu(sps->data, sps->data_size, &data, &data_size)) < 0) {
171  goto done;
172  }
173  ff_AMediaFormat_setBuffer(format, "csd-0", (void*)data, data_size);
174  av_freep(&data);
175 
176  if ((ret = h2645_ps_to_nalu(pps->data, pps->data_size, &data, &data_size)) < 0) {
177  goto done;
178  }
179  ff_AMediaFormat_setBuffer(format, "csd-1", (void*)data, data_size);
180  av_freep(&data);
181  } else {
182  const int warn = is_avc && (avctx->codec_tag == MKTAG('a','v','c','1') ||
183  avctx->codec_tag == MKTAG('a','v','c','2'));
184  av_log(avctx, warn ? AV_LOG_WARNING : AV_LOG_DEBUG,
185  "Could not extract PPS/SPS from extradata\n");
186  ret = 0;
187  }
188 
189 done:
190  ff_h264_ps_uninit(&ps);
191 
192  return ret;
193 }
194 #endif
195 
196 #if CONFIG_HEVC_MEDIACODEC_DECODER
197 static int hevc_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
198 {
199  int i;
200  int ret;
201 
202  HEVCParamSets ps;
203  HEVCSEI sei;
204 
205  const HEVCVPS *vps = NULL;
206  const HEVCPPS *pps = NULL;
207  const HEVCSPS *sps = NULL;
208  int is_nalff = 0;
209  int nal_length_size = 0;
210 
211  uint8_t *vps_data = NULL;
212  uint8_t *sps_data = NULL;
213  uint8_t *pps_data = NULL;
214  int vps_data_size = 0;
215  int sps_data_size = 0;
216  int pps_data_size = 0;
217 
218  memset(&ps, 0, sizeof(ps));
219  memset(&sei, 0, sizeof(sei));
220 
222  &ps, &sei, &is_nalff, &nal_length_size, 0, 1, avctx);
223  if (ret < 0) {
224  goto done;
225  }
226 
227  for (i = 0; i < HEVC_MAX_VPS_COUNT; i++) {
228  if (ps.vps_list[i]) {
229  vps = ps.vps_list[i];
230  break;
231  }
232  }
233 
234  for (i = 0; i < HEVC_MAX_PPS_COUNT; i++) {
235  if (ps.pps_list[i]) {
236  pps = ps.pps_list[i];
237  break;
238  }
239  }
240 
241  if (pps) {
242  if (ps.sps_list[pps->sps_id]) {
243  sps = ps.sps_list[pps->sps_id];
244  }
245  }
246 
247  if (vps && pps && sps) {
248  uint8_t *data;
249  int data_size;
250 
251  avctx->profile = sps->ptl.general_ptl.profile_idc;
252  avctx->level = sps->ptl.general_ptl.level_idc;
253 
254  if ((ret = h2645_ps_to_nalu(vps->data, vps->data_size, &vps_data, &vps_data_size)) < 0 ||
255  (ret = h2645_ps_to_nalu(sps->data, sps->data_size, &sps_data, &sps_data_size)) < 0 ||
256  (ret = h2645_ps_to_nalu(pps->data, pps->data_size, &pps_data, &pps_data_size)) < 0) {
257  goto done;
258  }
259 
260  data_size = vps_data_size + sps_data_size + pps_data_size;
261  data = av_mallocz(data_size);
262  if (!data) {
263  ret = AVERROR(ENOMEM);
264  goto done;
265  }
266 
267  memcpy(data , vps_data, vps_data_size);
268  memcpy(data + vps_data_size , sps_data, sps_data_size);
269  memcpy(data + vps_data_size + sps_data_size, pps_data, pps_data_size);
270 
271  ff_AMediaFormat_setBuffer(format, "csd-0", data, data_size);
272 
273  av_freep(&data);
274  } else {
275  const int warn = is_nalff && avctx->codec_tag == MKTAG('h','v','c','1');
276  av_log(avctx, warn ? AV_LOG_WARNING : AV_LOG_DEBUG,
277  "Could not extract VPS/PPS/SPS from extradata\n");
278  ret = 0;
279  }
280 
281 done:
282  ff_hevc_ps_uninit(&ps);
283 
284  av_freep(&vps_data);
285  av_freep(&sps_data);
286  av_freep(&pps_data);
287 
288  return ret;
289 }
290 #endif
291 
292 #if CONFIG_MPEG2_MEDIACODEC_DECODER || \
293  CONFIG_MPEG4_MEDIACODEC_DECODER || \
294  CONFIG_VP8_MEDIACODEC_DECODER || \
295  CONFIG_VP9_MEDIACODEC_DECODER || \
296  CONFIG_AV1_MEDIACODEC_DECODER || \
297  CONFIG_AAC_MEDIACODEC_DECODER || \
298  CONFIG_AMRNB_MEDIACODEC_DECODER || \
299  CONFIG_AMRWB_MEDIACODEC_DECODER || \
300  CONFIG_MP3_MEDIACODEC_DECODER
301 static int common_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
302 {
303  int ret = 0;
304 
305  if (avctx->extradata) {
306  ff_AMediaFormat_setBuffer(format, "csd-0", avctx->extradata, avctx->extradata_size);
307  }
308 
309  return ret;
310 }
311 #endif
312 
314 {
315  int ret;
316  int sdk_int;
317 
318  const char *codec_mime = NULL;
319 
322 
323  if (s->use_ndk_codec < 0)
324  s->use_ndk_codec = !av_jni_get_java_vm(avctx);
325 
326  format = ff_AMediaFormat_new(s->use_ndk_codec);
327  if (!format) {
328  av_log(avctx, AV_LOG_ERROR, "Failed to create media format\n");
330  goto done;
331  }
332 
333  switch (avctx->codec_id) {
334 #if CONFIG_AV1_MEDIACODEC_DECODER
335  case AV_CODEC_ID_AV1:
336  codec_mime = "video/av01";
337 
338  ret = common_set_extradata(avctx, format);
339  if (ret < 0)
340  goto done;
341  break;
342 #endif
343 #if CONFIG_H264_MEDIACODEC_DECODER
344  case AV_CODEC_ID_H264:
345  codec_mime = "video/avc";
346 
347  ret = h264_set_extradata(avctx, format);
348  if (ret < 0)
349  goto done;
350  break;
351 #endif
352 #if CONFIG_HEVC_MEDIACODEC_DECODER
353  case AV_CODEC_ID_HEVC:
354  codec_mime = "video/hevc";
355 
356  ret = hevc_set_extradata(avctx, format);
357  if (ret < 0)
358  goto done;
359  break;
360 #endif
361 #if CONFIG_MPEG2_MEDIACODEC_DECODER
363  codec_mime = "video/mpeg2";
364 
365  ret = common_set_extradata(avctx, format);
366  if (ret < 0)
367  goto done;
368  break;
369 #endif
370 #if CONFIG_MPEG4_MEDIACODEC_DECODER
371  case AV_CODEC_ID_MPEG4:
372  codec_mime = "video/mp4v-es",
373 
374  ret = common_set_extradata(avctx, format);
375  if (ret < 0)
376  goto done;
377  break;
378 #endif
379 #if CONFIG_VP8_MEDIACODEC_DECODER
380  case AV_CODEC_ID_VP8:
381  codec_mime = "video/x-vnd.on2.vp8";
382 
383  ret = common_set_extradata(avctx, format);
384  if (ret < 0)
385  goto done;
386  break;
387 #endif
388 #if CONFIG_VP9_MEDIACODEC_DECODER
389  case AV_CODEC_ID_VP9:
390  codec_mime = "video/x-vnd.on2.vp9";
391 
392  ret = common_set_extradata(avctx, format);
393  if (ret < 0)
394  goto done;
395  break;
396 #endif
397 #if CONFIG_AAC_MEDIACODEC_DECODER
398  case AV_CODEC_ID_AAC:
399  codec_mime = "audio/mp4a-latm";
400 
401  ret = common_set_extradata(avctx, format);
402  if (ret < 0)
403  goto done;
404  break;
405 #endif
406 #if CONFIG_AMRNB_MEDIACODEC_DECODER
407  case AV_CODEC_ID_AMR_NB:
408  codec_mime = "audio/3gpp";
409 
410  ret = common_set_extradata(avctx, format);
411  if (ret < 0)
412  goto done;
413  break;
414 #endif
415 #if CONFIG_AMRWB_MEDIACODEC_DECODER
416  case AV_CODEC_ID_AMR_WB:
417  codec_mime = "audio/amr-wb";
418 
419  ret = common_set_extradata(avctx, format);
420  if (ret < 0)
421  goto done;
422  break;
423 #endif
424 #if CONFIG_MP3_MEDIACODEC_DECODER
425  case AV_CODEC_ID_MP3:
426  codec_mime = "audio/mpeg";
427 
428  ret = common_set_extradata(avctx, format);
429  if (ret < 0)
430  goto done;
431  break;
432 #endif
433  default:
434  av_assert0(0);
435  }
436 
437  ff_AMediaFormat_setString(format, "mime", codec_mime);
438 
439  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
440  ff_AMediaFormat_setInt32(format, "width", avctx->width);
441  ff_AMediaFormat_setInt32(format, "height", avctx->height);
442  } else {
443  ff_AMediaFormat_setInt32(format, "channel-count", avctx->ch_layout.nb_channels);
444  ff_AMediaFormat_setInt32(format, "sample-rate", avctx->sample_rate);
445  }
446  if (s->operating_rate > 0)
447  ff_AMediaFormat_setInt32(format, "operating-rate", s->operating_rate);
448 
449  s->ctx = av_mallocz(sizeof(*s->ctx));
450  if (!s->ctx) {
451  av_log(avctx, AV_LOG_ERROR, "Failed to allocate MediaCodecDecContext\n");
452  ret = AVERROR(ENOMEM);
453  goto done;
454  }
455 
456  s->ctx->delay_flush = s->delay_flush;
457  s->ctx->use_ndk_codec = s->use_ndk_codec;
458 
459  if ((ret = ff_mediacodec_dec_init(avctx, s->ctx, codec_mime, format)) < 0) {
460  s->ctx = NULL;
461  goto done;
462  }
463 
464  av_log(avctx, AV_LOG_INFO,
465  "MediaCodec started successfully: codec = %s, ret = %d\n",
466  s->ctx->codec_name, ret);
467 
468  sdk_int = ff_Build_SDK_INT(avctx);
469  /* ff_Build_SDK_INT can fail when target API < 24 and JVM isn't available.
470  * If we don't check sdk_int > 0, the workaround might be enabled by
471  * mistake.
472  * JVM is required to make the workaround works reliably. On the other hand,
473  * missing a workaround should not be a serious issue, we do as best we can.
474  */
475  if (sdk_int > 0 && sdk_int <= 23 &&
476  strcmp(s->ctx->codec_name, "OMX.amlogic.mpeg2.decoder.awesome") == 0) {
477  av_log(avctx, AV_LOG_INFO, "Enabling workaround for %s on API=%d\n",
478  s->ctx->codec_name, sdk_int);
479  s->amlogic_mpeg2_api23_workaround = 1;
480  }
481 
482 done:
483  if (format) {
485  }
486 
487  if (ret < 0) {
489  }
490 
491  return ret;
492 }
493 
495 {
497  int ret;
498  ssize_t index;
499 
500  /* In delay_flush mode, wait until the user has released or rendered
501  all retained frames. */
502  if (s->delay_flush && ff_mediacodec_dec_is_flushing(avctx, s->ctx)) {
503  if (!ff_mediacodec_dec_flush(avctx, s->ctx)) {
504  return AVERROR(EAGAIN);
505  }
506  }
507 
508  /* poll for new frame */
509  ret = ff_mediacodec_dec_receive(avctx, s->ctx, frame, false);
510  if (ret != AVERROR(EAGAIN))
511  return ret;
512 
513  /* feed decoder */
514  while (1) {
515  if (s->ctx->current_input_buffer < 0 && !s->ctx->draining) {
516  /* poll for input space */
517  index = ff_AMediaCodec_dequeueInputBuffer(s->ctx->codec, 0);
518  if (index < 0) {
519  /* no space, block for an output frame to appear */
520  ret = ff_mediacodec_dec_receive(avctx, s->ctx, frame, true);
521  /* Try again if both input port and output port return EAGAIN.
522  * If no data is consumed and no frame in output, it can make
523  * both avcodec_send_packet() and avcodec_receive_frame()
524  * return EAGAIN, which violate the design.
525  */
526  if (ff_AMediaCodec_infoTryAgainLater(s->ctx->codec, index) &&
527  ret == AVERROR(EAGAIN))
528  continue;
529  return ret;
530  }
531  s->ctx->current_input_buffer = index;
532  }
533 
534  /* try to flush any buffered packet data */
535  if (s->buffered_pkt.size > 0) {
536  ret = ff_mediacodec_dec_send(avctx, s->ctx, &s->buffered_pkt, false);
537  if (ret >= 0) {
538  s->buffered_pkt.size -= ret;
539  s->buffered_pkt.data += ret;
540  if (s->buffered_pkt.size <= 0) {
541  av_packet_unref(&s->buffered_pkt);
542  } else {
543  av_log(avctx, AV_LOG_WARNING,
544  "could not send entire packet in single input buffer (%d < %d)\n",
545  ret, s->buffered_pkt.size+ret);
546  }
547  } else if (ret < 0 && ret != AVERROR(EAGAIN)) {
548  return ret;
549  }
550 
551  if (s->amlogic_mpeg2_api23_workaround && s->buffered_pkt.size <= 0) {
552  /* fallthrough to fetch next packet regardless of input buffer space */
553  } else {
554  /* poll for space again */
555  continue;
556  }
557  }
558 
559  /* fetch new packet or eof */
560  ret = ff_decode_get_packet(avctx, &s->buffered_pkt);
561  if (ret == AVERROR_EOF) {
562  AVPacket null_pkt = { 0 };
563  ret = ff_mediacodec_dec_send(avctx, s->ctx, &null_pkt, true);
564  if (ret < 0)
565  return ret;
566  return ff_mediacodec_dec_receive(avctx, s->ctx, frame, true);
567  } else if (ret == AVERROR(EAGAIN) && s->ctx->current_input_buffer < 0) {
568  return ff_mediacodec_dec_receive(avctx, s->ctx, frame, true);
569  } else if (ret < 0) {
570  return ret;
571  }
572  }
573 
574  return AVERROR(EAGAIN);
575 }
576 
578 {
580 
581  av_packet_unref(&s->buffered_pkt);
582 
583  ff_mediacodec_dec_flush(avctx, s->ctx);
584 }
585 
587  &(const AVCodecHWConfigInternal) {
588  .public = {
592  .device_type = AV_HWDEVICE_TYPE_MEDIACODEC,
593  },
594  .hwaccel = NULL,
595  },
596  NULL
597 };
598 
599 #define OFFSET(x) offsetof(MediaCodecH264DecContext, x)
600 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
602  { "delay_flush", "Delay flush until hw output buffers are returned to the decoder",
603  OFFSET(delay_flush), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, VD },
604  { "ndk_codec", "Use MediaCodec from NDK",
605  OFFSET(use_ndk_codec), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VD },
606  { "operating_rate", "The desired operating rate that the codec will need to operate at, zero for unspecified",
607  OFFSET(operating_rate), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, VD },
608  { NULL }
609 };
610 
611 #define DECLARE_MEDIACODEC_VCLASS(short_name) \
612 static const AVClass ff_##short_name##_mediacodec_dec_class = { \
613  .class_name = #short_name "_mediacodec", \
614  .item_name = av_default_item_name, \
615  .option = ff_mediacodec_vdec_options, \
616  .version = LIBAVUTIL_VERSION_INT, \
617 };
618 
619 #define DECLARE_MEDIACODEC_VDEC(short_name, full_name, codec_id, bsf) \
620 DECLARE_MEDIACODEC_VCLASS(short_name) \
621 const FFCodec ff_ ## short_name ## _mediacodec_decoder = { \
622  .p.name = #short_name "_mediacodec", \
623  CODEC_LONG_NAME(full_name " Android MediaCodec decoder"), \
624  .p.type = AVMEDIA_TYPE_VIDEO, \
625  .p.id = codec_id, \
626  .p.priv_class = &ff_##short_name##_mediacodec_dec_class, \
627  .priv_data_size = sizeof(MediaCodecH264DecContext), \
628  .init = mediacodec_decode_init, \
629  FF_CODEC_RECEIVE_FRAME_CB(mediacodec_receive_frame), \
630  .flush = mediacodec_decode_flush, \
631  .close = mediacodec_decode_close, \
632  .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_HARDWARE, \
633  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE, \
634  .bsfs = bsf, \
635  .hw_configs = mediacodec_hw_configs, \
636  .p.wrapper_name = "mediacodec", \
637 }; \
638 
639 #if CONFIG_H264_MEDIACODEC_DECODER
640 DECLARE_MEDIACODEC_VDEC(h264, "H.264", AV_CODEC_ID_H264, "h264_mp4toannexb")
641 #endif
642 
643 #if CONFIG_HEVC_MEDIACODEC_DECODER
644 DECLARE_MEDIACODEC_VDEC(hevc, "H.265", AV_CODEC_ID_HEVC, "hevc_mp4toannexb")
645 #endif
646 
647 #if CONFIG_MPEG2_MEDIACODEC_DECODER
649 #endif
650 
651 #if CONFIG_MPEG4_MEDIACODEC_DECODER
653 #endif
654 
655 #if CONFIG_VP8_MEDIACODEC_DECODER
657 #endif
658 
659 #if CONFIG_VP9_MEDIACODEC_DECODER
661 #endif
662 
663 #if CONFIG_AV1_MEDIACODEC_DECODER
665 #endif
666 
667 #define AD AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM
669  { "ndk_codec", "Use MediaCodec from NDK",
670  OFFSET(use_ndk_codec), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, AD },
671  { "operating_rate", "The desired operating rate that the codec will need to operate at, zero for unspecified",
672  OFFSET(operating_rate), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AD },
673  { NULL }
674 };
675 
676 #define DECLARE_MEDIACODEC_ACLASS(short_name) \
677 static const AVClass ff_##short_name##_mediacodec_dec_class = { \
678  .class_name = #short_name "_mediacodec", \
679  .item_name = av_default_item_name, \
680  .option = ff_mediacodec_adec_options, \
681  .version = LIBAVUTIL_VERSION_INT, \
682 };
683 
684 #define DECLARE_MEDIACODEC_ADEC(short_name, full_name, codec_id, bsf) \
685 DECLARE_MEDIACODEC_VCLASS(short_name) \
686 const FFCodec ff_ ## short_name ## _mediacodec_decoder = { \
687  .p.name = #short_name "_mediacodec", \
688  CODEC_LONG_NAME(full_name " Android MediaCodec decoder"), \
689  .p.type = AVMEDIA_TYPE_AUDIO, \
690  .p.id = codec_id, \
691  .p.priv_class = &ff_##short_name##_mediacodec_dec_class, \
692  .priv_data_size = sizeof(MediaCodecH264DecContext), \
693  .init = mediacodec_decode_init, \
694  FF_CODEC_RECEIVE_FRAME_CB(mediacodec_receive_frame), \
695  .flush = mediacodec_decode_flush, \
696  .close = mediacodec_decode_close, \
697  .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HARDWARE, \
698  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE, \
699  .bsfs = bsf, \
700  .p.wrapper_name = "mediacodec", \
701 }; \
702 
703 #if CONFIG_AAC_MEDIACODEC_DECODER
704 DECLARE_MEDIACODEC_ADEC(aac, "AAC", AV_CODEC_ID_AAC, "aac_adtstoasc")
705 #endif
706 
707 #if CONFIG_AMRNB_MEDIACODEC_DECODER
709 #endif
710 
711 #if CONFIG_AMRWB_MEDIACODEC_DECODER
713 #endif
714 
715 #if CONFIG_MP3_MEDIACODEC_DECODER
717 #endif
H264ParamSets::sps_list
const SPS * sps_list[MAX_SPS_COUNT]
RefStruct references.
Definition: h264_ps.h:145
ff_hevc_decode_extradata
int ff_hevc_decode_extradata(const uint8_t *data, int size, HEVCParamSets *ps, HEVCSEI *sei, int *is_nalff, int *nal_length_size, int err_recognition, int apply_defdispwin, void *logctx)
Definition: parse.c:79
hwconfig.h
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:429
ff_AMediaFormat_delete
static int ff_AMediaFormat_delete(FFAMediaFormat *format)
Definition: mediacodec_wrapper.h:92
MediaCodecDecContext
Definition: mediacodecdec_common.h:37
ff_decode_get_packet
int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Called by decoders to get the next packet for decoding.
Definition: decode.c:248
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
ff_h264_ps_uninit
void ff_h264_ps_uninit(H264ParamSets *ps)
Uninit H264 param sets structure.
Definition: h264_ps.c:270
mediacodec_receive_frame
static int mediacodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: mediacodecdec.c:494
out
FILE * out
Definition: movenc.c:55
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1056
HEVCParamSets::pps_list
const HEVCPPS * pps_list[HEVC_MAX_PPS_COUNT]
RefStruct references.
Definition: ps.h:511
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
mediacodec_decode_init
static av_cold int mediacodec_decode_init(AVCodecContext *avctx)
Definition: mediacodecdec.c:313
AD
#define AD
Definition: mediacodecdec.c:667
ff_mediacodec_dec_close
int ff_mediacodec_dec_close(AVCodecContext *avctx, MediaCodecDecContext *s)
Definition: mediacodecdec_common.c:1121
out_size
int out_size
Definition: movenc.c:56
H264ParamSets::pps_list
const PPS * pps_list[MAX_PPS_COUNT]
RefStruct references.
Definition: h264_ps.h:146
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
MediaCodecH264DecContext::buffered_pkt
AVPacket buffered_pkt
Definition: mediacodecdec.c:54
h264_parse.h
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
ff_mediacodec_dec_receive
int ff_mediacodec_dec_receive(AVCodecContext *avctx, MediaCodecDecContext *s, AVFrame *frame, bool wait)
Definition: mediacodecdec_common.c:978
internal.h
ff_AMediaFormat_setString
static void ff_AMediaFormat_setString(FFAMediaFormat *format, const char *name, const char *value)
Definition: mediacodec_wrapper.h:150
AVOption
AVOption.
Definition: opt.h:429
data
const char data[16]
Definition: mxf.c:149
AV_HWDEVICE_TYPE_MEDIACODEC
@ AV_HWDEVICE_TYPE_MEDIACODEC
Definition: hwcontext.h:38
AV_CODEC_ID_AMR_NB
@ AV_CODEC_ID_AMR_NB
Definition: codec_id.h:427
ff_mediacodec_dec_is_flushing
int ff_mediacodec_dec_is_flushing(AVCodecContext *avctx, MediaCodecDecContext *s)
Definition: mediacodecdec_common.c:1140
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:327
ff_AMediaFormat_setInt32
static void ff_AMediaFormat_setInt32(FFAMediaFormat *format, const char *name, int32_t value)
Definition: mediacodec_wrapper.h:135
AV_CODEC_ID_AMR_WB
@ AV_CODEC_ID_AMR_WB
Definition: codec_id.h:428
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1071
MediaCodecH264DecContext::amlogic_mpeg2_api23_workaround
int amlogic_mpeg2_api23_workaround
Definition: mediacodecdec.c:57
ff_mediacodec_dec_flush
int ff_mediacodec_dec_flush(AVCodecContext *avctx, MediaCodecDecContext *s)
Definition: mediacodecdec_common.c:1103
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:447
HEVCParamSets::sps_list
const HEVCSPS * sps_list[HEVC_MAX_SPS_COUNT]
RefStruct references.
Definition: ps.h:510
ff_AMediaFormat_new
FFAMediaFormat * ff_AMediaFormat_new(int ndk)
Definition: mediacodec_wrapper.c:2531
mediacodecdec_common.h
AV_CODEC_HW_CONFIG_METHOD_AD_HOC
@ AV_CODEC_HW_CONFIG_METHOD_AD_HOC
The codec supports this format by some ad-hoc method.
Definition: codec.h:342
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
av_cold
#define av_cold
Definition: attributes.h:90
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:530
ff_Build_SDK_INT
int ff_Build_SDK_INT(AVCodecContext *avctx)
Definition: mediacodec_wrapper.c:2559
ff_AMediaFormat_setBuffer
static void ff_AMediaFormat_setBuffer(FFAMediaFormat *format, const char *name, void *data, size_t size)
Definition: mediacodec_wrapper.h:155
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
MediaCodecH264DecContext::operating_rate
int operating_rate
Definition: mediacodecdec.c:61
format
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
ff_h264_decode_extradata
int ff_h264_decode_extradata(const uint8_t *data, int size, H264ParamSets *ps, int *is_avc, int *nal_length_size, int err_recognition, void *logctx)
Definition: h264_parse.c:466
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:222
HEVCSEI
Definition: sei.h:98
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
decode.h
AVCodecHWConfig::pix_fmt
enum AVPixelFormat pix_fmt
For decoders, a hardware pixel format which that decoder may be able to decode to if suitable hardwar...
Definition: codec.h:354
OFFSET
#define OFFSET(x)
Definition: mediacodecdec.c:599
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:461
AV_PIX_FMT_MEDIACODEC
@ AV_PIX_FMT_MEDIACODEC
hardware decoding through MediaCodec
Definition: pixfmt.h:316
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
NULL
#define NULL
Definition: coverity.c:32
parse.h
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:284
SPS
Sequence parameter set.
Definition: h264_ps.h:44
PPS
Picture parameter set.
Definition: h264_ps.h:110
MAX_PPS_COUNT
#define MAX_PPS_COUNT
Definition: h264_ps.h:38
vps
static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H265RawVPS *current)
Definition: cbs_h265_syntax_template.c:423
AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX
@ AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX
The codec supports this format via the hw_device_ctx interface.
Definition: codec.h:313
sei
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
Definition: cbs_h264_syntax_template.c:858
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1794
h264_ps.h
index
int index
Definition: gxfenc.c:90
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:448
MediaCodecH264DecContext::use_ndk_codec
int use_ndk_codec
Definition: mediacodecdec.c:59
codec_internal.h
ff_mediacodec_adec_options
static const AVOption ff_mediacodec_adec_options[]
Definition: mediacodecdec.c:668
VD
#define VD
Definition: mediacodecdec.c:600
MediaCodecH264DecContext
Definition: mediacodecdec.c:48
AVCodecHWConfigInternal
Definition: hwconfig.h:25
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:220
ff_hevc_ps_uninit
void ff_hevc_ps_uninit(HEVCParamSets *ps)
Definition: ps.c:2384
mediacodec_decode_flush
static void mediacodec_decode_flush(AVCodecContext *avctx)
Definition: mediacodecdec.c:577
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
mediacodec_wrapper.h
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:529
internal.h
common.h
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:228
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:256
AVCodecContext::height
int height
Definition: avcodec.h:624
av_jni_get_java_vm
void * av_jni_get_java_vm(void *log_ctx)
Definition: jni.c:75
MediaCodecH264DecContext::avclass
AVClass * avclass
Definition: mediacodecdec.c:50
ff_AMediaCodec_dequeueInputBuffer
static ssize_t ff_AMediaCodec_dequeueInputBuffer(FFAMediaCodec *codec, int64_t timeoutUs)
Definition: mediacodec_wrapper.h:292
avcodec.h
HEVC_MAX_VPS_COUNT
@ HEVC_MAX_VPS_COUNT
Definition: hevc.h:113
ret
ret
Definition: filter_design.txt:187
pixfmt.h
ff_h264_get_profile
int ff_h264_get_profile(const SPS *sps)
Compute profile from profile_idc and constraint_set?_flags.
Definition: h264_parse.c:533
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
MediaCodecH264DecContext::delay_flush
int delay_flush
Definition: mediacodecdec.c:56
DECLARE_MEDIACODEC_VDEC
#define DECLARE_MEDIACODEC_VDEC(short_name, full_name, codec_id, bsf)
Definition: mediacodecdec.c:619
AVCodecContext
main external API structure.
Definition: avcodec.h:451
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1650
H264ParamSets
Definition: h264_ps.h:144
pps
uint64_t pps
Definition: dovi_rpuenc.c:35
ff_mediacodec_vdec_options
static const AVOption ff_mediacodec_vdec_options[]
Definition: mediacodecdec.c:601
HEVC_MAX_PPS_COUNT
@ HEVC_MAX_PPS_COUNT
Definition: hevc.h:117
DECLARE_MEDIACODEC_ADEC
#define DECLARE_MEDIACODEC_ADEC(short_name, full_name, codec_id, bsf)
Definition: mediacodecdec.c:684
MediaCodecH264DecContext::ctx
MediaCodecDecContext * ctx
Definition: mediacodecdec.c:52
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:459
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
HEVCVPS
Definition: ps.h:171
HEVCSPS
Definition: ps.h:252
HEVCPPS
Definition: ps.h:371
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:476
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
AVPacket
This structure stores compressed data.
Definition: packet.h:516
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
HEVCParamSets::vps_list
const HEVCVPS * vps_list[HEVC_MAX_VPS_COUNT]
RefStruct references.
Definition: ps.h:509
ff_AMediaCodec_infoTryAgainLater
static int ff_AMediaCodec_infoTryAgainLater(FFAMediaCodec *codec, ssize_t idx)
Definition: mediacodec_wrapper.h:322
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:624
ff_mediacodec_dec_send
int ff_mediacodec_dec_send(AVCodecContext *avctx, MediaCodecDecContext *s, AVPacket *pkt, bool wait)
Definition: mediacodecdec_common.c:884
AV_CODEC_ID_VP8
@ AV_CODEC_ID_VP8
Definition: codec_id.h:192
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
mediacodec_hw_configs
static const AVCodecHWConfigInternal *const mediacodec_hw_configs[]
Definition: mediacodecdec.c:586
jni.h
AVCodecHWConfigInternal::public
AVCodecHWConfig public
This is the structure which will be returned to the user by avcodec_get_hw_config().
Definition: hwconfig.h:30
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:54
FFAMediaFormat
Definition: mediacodec_wrapper.h:63
mediacodec_decode_close
static av_cold int mediacodec_decode_close(AVCodecContext *avctx)
Definition: mediacodecdec.c:64
src
#define src
Definition: vp8dsp.c:248
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:155
ff_mediacodec_dec_init
int ff_mediacodec_dec_init(AVCodecContext *avctx, MediaCodecDecContext *s, const char *mime, FFAMediaFormat *format)
Definition: mediacodecdec_common.c:819
HEVCParamSets
Definition: ps.h:508