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 <stdint.h>
24 #include <string.h>
25 
26 #include "libavutil/avassert.h"
27 #include "libavutil/common.h"
28 #include "libavutil/opt.h"
29 #include "libavutil/intreadwrite.h"
30 #include "libavutil/pixfmt.h"
31 #include "libavutil/internal.h"
32 
33 #include "avcodec.h"
34 #include "decode.h"
35 #include "h264_parse.h"
36 #include "hevc_parse.h"
37 #include "hwconfig.h"
38 #include "internal.h"
39 #include "mediacodec_wrapper.h"
40 #include "mediacodecdec_common.h"
41 
42 typedef struct MediaCodecH264DecContext {
43 
45 
47 
49 
52 
54 
56 {
58 
59  ff_mediacodec_dec_close(avctx, s->ctx);
60  s->ctx = NULL;
61 
62  av_packet_unref(&s->buffered_pkt);
63 
64  return 0;
65 }
66 
67 #if CONFIG_H264_MEDIACODEC_DECODER || CONFIG_HEVC_MEDIACODEC_DECODER
68 static int h2645_ps_to_nalu(const uint8_t *src, int src_size, uint8_t **out, int *out_size)
69 {
70  int i;
71  int ret = 0;
72  uint8_t *p = NULL;
73  static const uint8_t nalu_header[] = { 0x00, 0x00, 0x00, 0x01 };
74 
75  if (!out || !out_size) {
76  return AVERROR(EINVAL);
77  }
78 
79  p = av_malloc(sizeof(nalu_header) + src_size);
80  if (!p) {
81  return AVERROR(ENOMEM);
82  }
83 
84  *out = p;
85  *out_size = sizeof(nalu_header) + src_size;
86 
87  memcpy(p, nalu_header, sizeof(nalu_header));
88  memcpy(p + sizeof(nalu_header), src, src_size);
89 
90  /* Escape 0x00, 0x00, 0x0{0-3} pattern */
91  for (i = 4; i < *out_size; i++) {
92  if (i < *out_size - 3 &&
93  p[i + 0] == 0 &&
94  p[i + 1] == 0 &&
95  p[i + 2] <= 3) {
96  uint8_t *new;
97 
98  *out_size += 1;
99  new = av_realloc(*out, *out_size);
100  if (!new) {
101  ret = AVERROR(ENOMEM);
102  goto done;
103  }
104  *out = p = new;
105 
106  i = i + 2;
107  memmove(p + i + 1, p + i, *out_size - (i + 1));
108  p[i] = 0x03;
109  }
110  }
111 done:
112  if (ret < 0) {
113  av_freep(out);
114  *out_size = 0;
115  }
116 
117  return ret;
118 }
119 #endif
120 
121 #if CONFIG_H264_MEDIACODEC_DECODER
122 static int h264_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
123 {
124  int i;
125  int ret;
126 
127  H264ParamSets ps;
128  const PPS *pps = NULL;
129  const SPS *sps = NULL;
130  int is_avc = 0;
131  int nal_length_size = 0;
132 
133  memset(&ps, 0, sizeof(ps));
134 
136  &ps, &is_avc, &nal_length_size, 0, avctx);
137  if (ret < 0) {
138  goto done;
139  }
140 
141  for (i = 0; i < MAX_PPS_COUNT; i++) {
142  if (ps.pps_list[i]) {
143  pps = (const PPS*)ps.pps_list[i]->data;
144  break;
145  }
146  }
147 
148  if (pps) {
149  if (ps.sps_list[pps->sps_id]) {
150  sps = (const SPS*)ps.sps_list[pps->sps_id]->data;
151  }
152  }
153 
154  if (pps && sps) {
155  uint8_t *data = NULL;
156  int data_size = 0;
157 
158  if ((ret = h2645_ps_to_nalu(sps->data, sps->data_size, &data, &data_size)) < 0) {
159  goto done;
160  }
161  ff_AMediaFormat_setBuffer(format, "csd-0", (void*)data, data_size);
162  av_freep(&data);
163 
164  if ((ret = h2645_ps_to_nalu(pps->data, pps->data_size, &data, &data_size)) < 0) {
165  goto done;
166  }
167  ff_AMediaFormat_setBuffer(format, "csd-1", (void*)data, data_size);
168  av_freep(&data);
169  } else {
170  av_log(avctx, AV_LOG_ERROR, "Could not extract PPS/SPS from extradata");
172  }
173 
174 done:
175  ff_h264_ps_uninit(&ps);
176 
177  return ret;
178 }
179 #endif
180 
181 #if CONFIG_HEVC_MEDIACODEC_DECODER
182 static int hevc_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
183 {
184  int i;
185  int ret;
186 
187  HEVCParamSets ps;
188  HEVCSEI sei;
189 
190  const HEVCVPS *vps = NULL;
191  const HEVCPPS *pps = NULL;
192  const HEVCSPS *sps = NULL;
193  int is_nalff = 0;
194  int nal_length_size = 0;
195 
196  uint8_t *vps_data = NULL;
197  uint8_t *sps_data = NULL;
198  uint8_t *pps_data = NULL;
199  int vps_data_size = 0;
200  int sps_data_size = 0;
201  int pps_data_size = 0;
202 
203  memset(&ps, 0, sizeof(ps));
204  memset(&sei, 0, sizeof(sei));
205 
207  &ps, &sei, &is_nalff, &nal_length_size, 0, 1, avctx);
208  if (ret < 0) {
209  goto done;
210  }
211 
212  for (i = 0; i < HEVC_MAX_VPS_COUNT; i++) {
213  if (ps.vps_list[i]) {
214  vps = (const HEVCVPS*)ps.vps_list[i]->data;
215  break;
216  }
217  }
218 
219  for (i = 0; i < HEVC_MAX_PPS_COUNT; i++) {
220  if (ps.pps_list[i]) {
221  pps = (const HEVCPPS*)ps.pps_list[i]->data;
222  break;
223  }
224  }
225 
226  if (pps) {
227  if (ps.sps_list[pps->sps_id]) {
228  sps = (const HEVCSPS*)ps.sps_list[pps->sps_id]->data;
229  }
230  }
231 
232  if (vps && pps && sps) {
233  uint8_t *data;
234  int data_size;
235 
236  if ((ret = h2645_ps_to_nalu(vps->data, vps->data_size, &vps_data, &vps_data_size)) < 0 ||
237  (ret = h2645_ps_to_nalu(sps->data, sps->data_size, &sps_data, &sps_data_size)) < 0 ||
238  (ret = h2645_ps_to_nalu(pps->data, pps->data_size, &pps_data, &pps_data_size)) < 0) {
239  goto done;
240  }
241 
242  data_size = vps_data_size + sps_data_size + pps_data_size;
243  data = av_mallocz(data_size);
244  if (!data) {
245  ret = AVERROR(ENOMEM);
246  goto done;
247  }
248 
249  memcpy(data , vps_data, vps_data_size);
250  memcpy(data + vps_data_size , sps_data, sps_data_size);
251  memcpy(data + vps_data_size + sps_data_size, pps_data, pps_data_size);
252 
253  ff_AMediaFormat_setBuffer(format, "csd-0", data, data_size);
254 
255  av_freep(&data);
256  } else {
257  av_log(avctx, AV_LOG_ERROR, "Could not extract VPS/PPS/SPS from extradata");
259  }
260 
261 done:
262  ff_hevc_ps_uninit(&ps);
263 
264  av_freep(&vps_data);
265  av_freep(&sps_data);
266  av_freep(&pps_data);
267 
268  return ret;
269 }
270 #endif
271 
272 #if CONFIG_MPEG2_MEDIACODEC_DECODER || \
273  CONFIG_MPEG4_MEDIACODEC_DECODER || \
274  CONFIG_VP8_MEDIACODEC_DECODER || \
275  CONFIG_VP9_MEDIACODEC_DECODER
276 static int common_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
277 {
278  int ret = 0;
279 
280  if (avctx->extradata) {
281  ff_AMediaFormat_setBuffer(format, "csd-0", avctx->extradata, avctx->extradata_size);
282  }
283 
284  return ret;
285 }
286 #endif
287 
289 {
290  int ret;
291  int sdk_int;
292 
293  const char *codec_mime = NULL;
294 
297 
299  if (!format) {
300  av_log(avctx, AV_LOG_ERROR, "Failed to create media format\n");
302  goto done;
303  }
304 
305  switch (avctx->codec_id) {
306 #if CONFIG_H264_MEDIACODEC_DECODER
307  case AV_CODEC_ID_H264:
308  codec_mime = "video/avc";
309 
310  ret = h264_set_extradata(avctx, format);
311  if (ret < 0)
312  goto done;
313  break;
314 #endif
315 #if CONFIG_HEVC_MEDIACODEC_DECODER
316  case AV_CODEC_ID_HEVC:
317  codec_mime = "video/hevc";
318 
319  ret = hevc_set_extradata(avctx, format);
320  if (ret < 0)
321  goto done;
322  break;
323 #endif
324 #if CONFIG_MPEG2_MEDIACODEC_DECODER
326  codec_mime = "video/mpeg2";
327 
328  ret = common_set_extradata(avctx, format);
329  if (ret < 0)
330  goto done;
331  break;
332 #endif
333 #if CONFIG_MPEG4_MEDIACODEC_DECODER
334  case AV_CODEC_ID_MPEG4:
335  codec_mime = "video/mp4v-es",
336 
337  ret = common_set_extradata(avctx, format);
338  if (ret < 0)
339  goto done;
340  break;
341 #endif
342 #if CONFIG_VP8_MEDIACODEC_DECODER
343  case AV_CODEC_ID_VP8:
344  codec_mime = "video/x-vnd.on2.vp8";
345 
346  ret = common_set_extradata(avctx, format);
347  if (ret < 0)
348  goto done;
349  break;
350 #endif
351 #if CONFIG_VP9_MEDIACODEC_DECODER
352  case AV_CODEC_ID_VP9:
353  codec_mime = "video/x-vnd.on2.vp9";
354 
355  ret = common_set_extradata(avctx, format);
356  if (ret < 0)
357  goto done;
358  break;
359 #endif
360  default:
361  av_assert0(0);
362  }
363 
364  ff_AMediaFormat_setString(format, "mime", codec_mime);
365  ff_AMediaFormat_setInt32(format, "width", avctx->width);
366  ff_AMediaFormat_setInt32(format, "height", avctx->height);
367 
368  s->ctx = av_mallocz(sizeof(*s->ctx));
369  if (!s->ctx) {
370  av_log(avctx, AV_LOG_ERROR, "Failed to allocate MediaCodecDecContext\n");
371  ret = AVERROR(ENOMEM);
372  goto done;
373  }
374 
375  s->ctx->delay_flush = s->delay_flush;
376 
377  if ((ret = ff_mediacodec_dec_init(avctx, s->ctx, codec_mime, format)) < 0) {
378  s->ctx = NULL;
379  goto done;
380  }
381 
382  av_log(avctx, AV_LOG_INFO,
383  "MediaCodec started successfully: codec = %s, ret = %d\n",
384  s->ctx->codec_name, ret);
385 
386  sdk_int = ff_Build_SDK_INT(avctx);
387  if (sdk_int <= 23 &&
388  strcmp(s->ctx->codec_name, "OMX.amlogic.mpeg2.decoder.awesome") == 0) {
389  av_log(avctx, AV_LOG_INFO, "Enabling workaround for %s on API=%d\n",
390  s->ctx->codec_name, sdk_int);
391  s->amlogic_mpeg2_api23_workaround = 1;
392  }
393 
394 done:
395  if (format) {
397  }
398 
399  if (ret < 0) {
401  }
402 
403  return ret;
404 }
405 
407 {
409  int ret;
410  ssize_t index;
411 
412  /* In delay_flush mode, wait until the user has released or rendered
413  all retained frames. */
414  if (s->delay_flush && ff_mediacodec_dec_is_flushing(avctx, s->ctx)) {
415  if (!ff_mediacodec_dec_flush(avctx, s->ctx)) {
416  return AVERROR(EAGAIN);
417  }
418  }
419 
420  /* poll for new frame */
421  ret = ff_mediacodec_dec_receive(avctx, s->ctx, frame, false);
422  if (ret != AVERROR(EAGAIN))
423  return ret;
424 
425  /* feed decoder */
426  while (1) {
427  if (s->ctx->current_input_buffer < 0) {
428  /* poll for input space */
429  index = ff_AMediaCodec_dequeueInputBuffer(s->ctx->codec, 0);
430  if (index < 0) {
431  /* no space, block for an output frame to appear */
432  return ff_mediacodec_dec_receive(avctx, s->ctx, frame, true);
433  }
434  s->ctx->current_input_buffer = index;
435  }
436 
437  /* try to flush any buffered packet data */
438  if (s->buffered_pkt.size > 0) {
439  ret = ff_mediacodec_dec_send(avctx, s->ctx, &s->buffered_pkt, false);
440  if (ret >= 0) {
441  s->buffered_pkt.size -= ret;
442  s->buffered_pkt.data += ret;
443  if (s->buffered_pkt.size <= 0) {
444  av_packet_unref(&s->buffered_pkt);
445  } else {
446  av_log(avctx, AV_LOG_WARNING,
447  "could not send entire packet in single input buffer (%d < %d)\n",
448  ret, s->buffered_pkt.size+ret);
449  }
450  } else if (ret < 0 && ret != AVERROR(EAGAIN)) {
451  return ret;
452  }
453 
454  if (s->amlogic_mpeg2_api23_workaround && s->buffered_pkt.size <= 0) {
455  /* fallthrough to fetch next packet regardless of input buffer space */
456  } else {
457  /* poll for space again */
458  continue;
459  }
460  }
461 
462  /* fetch new packet or eof */
463  ret = ff_decode_get_packet(avctx, &s->buffered_pkt);
464  if (ret == AVERROR_EOF) {
465  AVPacket null_pkt = { 0 };
466  ret = ff_mediacodec_dec_send(avctx, s->ctx, &null_pkt, true);
467  if (ret < 0)
468  return ret;
469  return ff_mediacodec_dec_receive(avctx, s->ctx, frame, true);
470  } else if (ret == AVERROR(EAGAIN) && s->ctx->current_input_buffer < 0) {
471  return ff_mediacodec_dec_receive(avctx, s->ctx, frame, true);
472  } else if (ret < 0) {
473  return ret;
474  }
475  }
476 
477  return AVERROR(EAGAIN);
478 }
479 
481 {
483 
484  av_packet_unref(&s->buffered_pkt);
485 
486  ff_mediacodec_dec_flush(avctx, s->ctx);
487 }
488 
490  &(const AVCodecHWConfigInternal) {
491  .public = {
495  .device_type = AV_HWDEVICE_TYPE_MEDIACODEC,
496  },
497  .hwaccel = NULL,
498  },
499  NULL
500 };
501 
502 #define OFFSET(x) offsetof(MediaCodecH264DecContext, x)
503 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
505  { "delay_flush", "Delay flush until hw output buffers are returned to the decoder",
506  OFFSET(delay_flush), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, VD },
507  { NULL }
508 };
509 
510 #define DECLARE_MEDIACODEC_VCLASS(short_name) \
511 static const AVClass ff_##short_name##_mediacodec_dec_class = { \
512  .class_name = #short_name "_mediacodec", \
513  .item_name = av_default_item_name, \
514  .option = ff_mediacodec_vdec_options, \
515  .version = LIBAVUTIL_VERSION_INT, \
516 };
517 
518 #define DECLARE_MEDIACODEC_VDEC(short_name, full_name, codec_id, bsf) \
519 DECLARE_MEDIACODEC_VCLASS(short_name) \
520 AVCodec ff_##short_name##_mediacodec_decoder = { \
521  .name = #short_name "_mediacodec", \
522  .long_name = NULL_IF_CONFIG_SMALL(full_name " Android MediaCodec decoder"), \
523  .type = AVMEDIA_TYPE_VIDEO, \
524  .id = codec_id, \
525  .priv_class = &ff_##short_name##_mediacodec_dec_class, \
526  .priv_data_size = sizeof(MediaCodecH264DecContext), \
527  .init = mediacodec_decode_init, \
528  .receive_frame = mediacodec_receive_frame, \
529  .flush = mediacodec_decode_flush, \
530  .close = mediacodec_decode_close, \
531  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_HARDWARE, \
532  .caps_internal = FF_CODEC_CAP_SETS_PKT_DTS, \
533  .bsfs = bsf, \
534  .hw_configs = mediacodec_hw_configs, \
535  .wrapper_name = "mediacodec", \
536 }; \
537 
538 #if CONFIG_H264_MEDIACODEC_DECODER
539 DECLARE_MEDIACODEC_VDEC(h264, "H.264", AV_CODEC_ID_H264, "h264_mp4toannexb")
540 #endif
541 
542 #if CONFIG_HEVC_MEDIACODEC_DECODER
543 DECLARE_MEDIACODEC_VDEC(hevc, "H.265", AV_CODEC_ID_HEVC, "hevc_mp4toannexb")
544 #endif
545 
546 #if CONFIG_MPEG2_MEDIACODEC_DECODER
548 #endif
549 
550 #if CONFIG_MPEG4_MEDIACODEC_DECODER
552 #endif
553 
554 #if CONFIG_VP8_MEDIACODEC_DECODER
556 #endif
557 
558 #if CONFIG_VP9_MEDIACODEC_DECODER
560 #endif
hwconfig.h
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:605
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:238
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
mediacodec_hw_configs
static const AVCodecHWConfigInternal * mediacodec_hw_configs[]
Definition: mediacodecdec.c:489
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:317
mediacodec_receive_frame
static int mediacodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: mediacodecdec.c:406
out
FILE * out
Definition: movenc.c:54
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:89
mediacodec_decode_init
static av_cold int mediacodec_decode_init(AVCodecContext *avctx)
Definition: mediacodecdec.c:288
ff_mediacodec_dec_close
int ff_mediacodec_dec_close(AVCodecContext *avctx, MediaCodecDecContext *s)
Definition: mediacodecdec_common.c:901
out_size
int out_size
Definition: movenc.c:55
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:61
MediaCodecH264DecContext::buffered_pkt
AVPacket buffered_pkt
Definition: mediacodecdec.c:48
h264_parse.h
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
ff_mediacodec_dec_receive
int ff_mediacodec_dec_receive(AVCodecContext *avctx, MediaCodecDecContext *s, AVFrame *frame, bool wait)
Definition: mediacodecdec_common.c:760
internal.h
AVOption
AVOption.
Definition: opt.h:246
data
const char data[16]
Definition: mxf.c:91
HEVC_MAX_VPS_COUNT
@ HEVC_MAX_VPS_COUNT
Definition: hevc.h:110
AV_HWDEVICE_TYPE_MEDIACODEC
@ AV_HWDEVICE_TYPE_MEDIACODEC
Definition: hwcontext.h:38
ff_mediacodec_dec_is_flushing
int ff_mediacodec_dec_is_flushing(AVCodecContext *avctx, MediaCodecDecContext *s)
Definition: mediacodecdec_common.c:908
ff_AMediaFormat_setBuffer
void ff_AMediaFormat_setBuffer(FFAMediaFormat *format, const char *name, void *data, size_t size)
Definition: mediacodec_wrapper.c:1074
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
ff_AMediaFormat_new
FFAMediaFormat * ff_AMediaFormat_new(void)
Definition: mediacodec_wrapper.c:612
MediaCodecH264DecContext::amlogic_mpeg2_api23_workaround
int amlogic_mpeg2_api23_workaround
Definition: mediacodecdec.c:51
HEVC_MAX_PPS_COUNT
@ HEVC_MAX_PPS_COUNT
Definition: hevc.h:114
ff_mediacodec_dec_flush
int ff_mediacodec_dec_flush(AVCodecContext *avctx, MediaCodecDecContext *s)
Definition: mediacodecdec_common.c:883
mediacodecdec_common.h
hevc_parse.h
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_cold
#define av_cold
Definition: attributes.h:90
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:628
ff_Build_SDK_INT
int ff_Build_SDK_INT(AVCodecContext *avctx)
Definition: mediacodec_wrapper.c:1696
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
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:462
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:217
HEVCSEI
Definition: hevc_sei.h:113
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
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:434
H264ParamSets::sps_list
AVBufferRef * sps_list[MAX_SPS_COUNT]
Definition: h264_ps.h:144
OFFSET
#define OFFSET(x)
Definition: mediacodecdec.c:502
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:76
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:536
AV_PIX_FMT_MEDIACODEC
@ AV_PIX_FMT_MEDIACODEC
hardware decoding through MediaCodec
Definition: pixfmt.h:293
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
NULL
#define NULL
Definition: coverity.c:32
ff_hevc_ps_uninit
void ff_hevc_ps_uninit(HEVCParamSets *ps)
Definition: hevc_ps.c:1747
SPS
Sequence parameter set.
Definition: h264_ps.h:44
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:393
src
#define src
Definition: vp8dsp.c:254
PPS
Picture parameter set.
Definition: h264_ps.h:111
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:420
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: hevc_parse.c:80
sei
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
Definition: cbs_h264_syntax_template.c:924
index
int index
Definition: gxfenc.c:89
pps
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
Definition: cbs_h264_syntax_template.c:404
ff_AMediaFormat_setInt32
void ff_AMediaFormat_setInt32(FFAMediaFormat *format, const char *name, int32_t value)
Definition: mediacodec_wrapper.c:964
VD
#define VD
Definition: mediacodecdec.c:503
MediaCodecH264DecContext
Definition: mediacodecdec.c:42
AVCodecHWConfigInternal
Definition: hwconfig.h:29
HEVCParamSets::pps_list
AVBufferRef * pps_list[HEVC_MAX_PPS_COUNT]
Definition: hevc_ps.h:330
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:57
ff_AMediaCodec_dequeueInputBuffer
ssize_t ff_AMediaCodec_dequeueInputBuffer(FFAMediaCodec *codec, int64_t timeoutUs)
Definition: mediacodec_wrapper.c:1450
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
ff_AMediaFormat_setString
void ff_AMediaFormat_setString(FFAMediaFormat *format, const char *name, const char *value)
Definition: mediacodec_wrapper.c:1039
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:134
mediacodec_decode_flush
static void mediacodec_decode_flush(AVCodecContext *avctx)
Definition: mediacodecdec.c:480
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
mediacodec_wrapper.h
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:627
internal.h
common.h
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:223
uint8_t
uint8_t
Definition: audio_convert.c:194
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:237
AVCodecContext::height
int height
Definition: avcodec.h:699
MediaCodecH264DecContext::avclass
AVClass * avclass
Definition: mediacodecdec.c:44
avcodec.h
ret
ret
Definition: filter_design.txt:187
pixfmt.h
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:50
DECLARE_MEDIACODEC_VDEC
#define DECLARE_MEDIACODEC_VDEC(short_name, full_name, codec_id, bsf)
Definition: mediacodecdec.c:518
AVCodecContext
main external API structure.
Definition: avcodec.h:526
H264ParamSets::pps_list
AVBufferRef * pps_list[MAX_PPS_COUNT]
Definition: h264_ps.h:145
ff_AMediaFormat_delete
int ff_AMediaFormat_delete(FFAMediaFormat *format)
Definition: mediacodec_wrapper.c:692
H264ParamSets
Definition: h264_ps.h:143
HEVCParamSets::sps_list
AVBufferRef * sps_list[HEVC_MAX_SPS_COUNT]
Definition: hevc_ps.h:329
ff_mediacodec_vdec_options
static const AVOption ff_mediacodec_vdec_options[]
Definition: mediacodecdec.c:504
MediaCodecH264DecContext::ctx
MediaCodecDecContext * ctx
Definition: mediacodecdec.c:46
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:422
HEVCVPS
Definition: hevc_ps.h:123
HEVCSPS
Definition: hevc_ps.h:153
HEVCPPS
Definition: hevc_ps.h:249
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:553
AVPacket
This structure stores compressed data.
Definition: packet.h:332
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:240
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:699
ff_mediacodec_dec_send
int ff_mediacodec_dec_send(AVCodecContext *avctx, MediaCodecDecContext *s, AVPacket *pkt, bool wait)
Definition: mediacodecdec_common.c:666
AV_CODEC_ID_VP8
@ AV_CODEC_ID_VP8
Definition: codec_id.h:189
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
AVCodecHWConfigInternal::public
AVCodecHWConfig public
This is the structure which will be returned to the user by avcodec_get_hw_config().
Definition: hwconfig.h:34
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
FFAMediaFormat
Definition: mediacodec_wrapper.c:162
mediacodec_decode_close
static av_cold int mediacodec_decode_close(AVCodecContext *avctx)
Definition: mediacodecdec.c:55
HEVCParamSets::vps_list
AVBufferRef * vps_list[HEVC_MAX_VPS_COUNT]
Definition: hevc_ps.h:328
ff_mediacodec_dec_init
int ff_mediacodec_dec_init(AVCodecContext *avctx, MediaCodecDecContext *s, const char *mime, FFAMediaFormat *format)
Definition: mediacodecdec_common.c:565
HEVCParamSets
Definition: hevc_ps.h:327