FFmpeg
Loading...
Searching...
No Matches
mediacodecdec_common.c
Go to the documentation of this file.
1/*
2 * Android MediaCodec decoder
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 <string.h>
24#include <sys/types.h>
25
26#include "libavutil/avassert.h"
27#include "libavutil/common.h"
29#include "libavutil/mem.h"
30#include "libavutil/log.h"
31#include "libavutil/pixfmt.h"
32#include "libavutil/time.h"
33#include "libavutil/timestamp.h"
35
36#include "avcodec.h"
37#include "decode.h"
38
39#include "mediacodec.h"
40#include "mediacodec_surface.h"
42#include "mediacodec_wrapper.h"
44
45/**
46 * OMX.k3.video.decoder.avc, OMX.NVIDIA.* OMX.SEC.avc.dec and OMX.google
47 * codec workarounds used in various place are taken from the Gstreamer
48 * project.
49 *
50 * Gstreamer references:
51 * https://cgit.freedesktop.org/gstreamer/gst-plugins-bad/tree/sys/androidmedia/
52 *
53 * Gstreamer copyright notice:
54 *
55 * Copyright (C) 2012, Collabora Ltd.
56 * Author: Sebastian Dröge <sebastian.droege@collabora.co.uk>
57 *
58 * Copyright (C) 2012, Rafaël Carré <funman@videolanorg>
59 *
60 * Copyright (C) 2015, Sebastian Dröge <sebastian@centricular.com>
61 *
62 * Copyright (C) 2014-2015, Collabora Ltd.
63 * Author: Matthieu Bouron <matthieu.bouron@gcollabora.com>
64 *
65 * Copyright (C) 2015, Edward Hervey
66 * Author: Edward Hervey <bilboed@gmail.com>
67 *
68 * Copyright (C) 2015, Matthew Waters <matthew@centricular.com>
69 *
70 * This library is free software; you can redistribute it and/or
71 * modify it under the terms of the GNU Lesser General Public
72 * License as published by the Free Software Foundation
73 * version 2.1 of the License.
74 *
75 * This library is distributed in the hope that it will be useful,
76 * but WITHOUT ANY WARRANTY; without even the implied warranty of
77 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
78 * Lesser General Public License for more details.
79 *
80 * You should have received a copy of the GNU Lesser General Public
81 * License along with this library; if not, write to the Free Software
82 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
83 *
84 */
85
86#define INPUT_DEQUEUE_TIMEOUT_US 8000
87#define OUTPUT_DEQUEUE_TIMEOUT_US 8000
88#define OUTPUT_DEQUEUE_BLOCK_TIMEOUT_US 1000000
89
90enum {
91 ENCODING_PCM_16BIT = 0x00000002,
92 ENCODING_PCM_8BIT = 0x00000003,
93 ENCODING_PCM_FLOAT = 0x00000004,
95 ENCODING_PCM_32BIT = 0x00000016,
96};
97
98static const struct {
99
102
103} sample_formats[] = {
104
109 { 0 }
111
114 int pcm_format)
115{
117
118 for (int i = 0; i < FF_ARRAY_ELEMS(sample_formats); i++) {
120 return sample_formats[i].sample_format;
121 }
122 }
123
124 av_log(avctx, AV_LOG_ERROR, "Output sample format 0x%x (value=%d) is not supported\n",
126
127 return ret;
128}
129
130enum
131{
150};
151
152static const struct {
153
154 int mask;
155 uint64_t layout;
156
157} channel_masks[] = {
177
179 int channel_mask)
180{
181 uint64_t channel_layout = 0;
182
183 for (int i = 0; i < FF_ARRAY_ELEMS(channel_masks); i++) {
184 if (channel_mask & channel_masks[i].mask)
185 channel_layout |= channel_masks[i].layout;
186 }
187
188 return channel_layout;
189}
190
191enum {
201};
202
203static const struct {
204
207
208} color_formats[] = {
209
217 { 0 }
219
222 int color_format)
223{
224 int i;
226
227 if (s->surface) {
229 }
230
231 if (!strcmp(s->codec_name, "OMX.k3.video.decoder.avc") && color_format == COLOR_FormatYCbYCr) {
233 }
234
235 for (i = 0; i < FF_ARRAY_ELEMS(color_formats); i++) {
237 return color_formats[i].pix_fmt;
238 }
239 }
240
241 av_log(avctx, AV_LOG_ERROR, "Output color format 0x%x (value=%d) is not supported\n",
243
244 return ret;
245}
246
248{
249 atomic_fetch_add(&s->refcount, 1);
250}
251
253{
254 if (!s)
255 return;
256
257 if (atomic_fetch_sub(&s->refcount, 1) == 1) {
258 if (s->codec) {
259 ff_AMediaCodec_delete(s->codec);
260 s->codec = NULL;
261 }
262
263 if (s->format) {
264 ff_AMediaFormat_delete(s->format);
265 s->format = NULL;
266 }
267
268 if (s->surface) {
270 s->surface = NULL;
271 }
272
273 av_freep(&s->codec_name);
274 av_freep(&s);
275 }
276}
277
278static void mediacodec_buffer_release(void *opaque, uint8_t *data)
279{
280 AVMediaCodecBuffer *buffer = opaque;
282 int released = atomic_load(&buffer->released);
283
284 if (!released && (ctx->delay_flush || buffer->serial == atomic_load(&ctx->serial))) {
285 atomic_fetch_sub(&ctx->hw_buffer_count, 1);
286 av_log(ctx->avctx, AV_LOG_DEBUG,
287 "Releasing output buffer %zd (%p) ts=%"PRId64" on free() [%d pending]\n",
288 buffer->index, buffer, buffer->pts, atomic_load(&ctx->hw_buffer_count));
290 }
291
294}
295
298 ssize_t index,
300 AVFrame *frame)
301{
302 int ret = 0;
303 int status = 0;
304 AVMediaCodecBuffer *buffer = NULL;
305
306 frame->buf[0] = NULL;
307 frame->width = avctx->width;
308 frame->height = avctx->height;
309 frame->format = avctx->pix_fmt;
310 frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
311
312 if (avctx->pkt_timebase.num && avctx->pkt_timebase.den) {
315 avctx->pkt_timebase);
316 } else {
317 frame->pts = info->presentationTimeUs;
318 }
319 frame->pkt_dts = AV_NOPTS_VALUE;
320 frame->color_range = avctx->color_range;
321 frame->color_primaries = avctx->color_primaries;
322 frame->color_trc = avctx->color_trc;
323 frame->colorspace = avctx->colorspace;
324
325 buffer = av_mallocz(sizeof(AVMediaCodecBuffer));
326 if (!buffer) {
327 ret = AVERROR(ENOMEM);
328 goto fail;
329 }
330
331 atomic_init(&buffer->released, 0);
332
333 frame->buf[0] = av_buffer_create(NULL,
334 0,
336 buffer,
338
339 if (!frame->buf[0]) {
340 ret = AVERROR(ENOMEM);
341 goto fail;
342
343 }
344
345 buffer->ctx = s;
346 buffer->serial = atomic_load(&s->serial);
348
349 buffer->index = index;
350 buffer->pts = info->presentationTimeUs;
351
352 frame->data[3] = (uint8_t *)buffer;
353
354 atomic_fetch_add(&s->hw_buffer_count, 1);
355 av_log(avctx, AV_LOG_DEBUG,
356 "Wrapping output buffer %zd (%p) ts=%"PRId64" [%d pending]\n",
357 buffer->index, buffer, buffer->pts, atomic_load(&s->hw_buffer_count));
358
359 return 0;
360fail:
362 status = ff_AMediaCodec_releaseOutputBuffer(s->codec, index, 0);
363 if (status < 0) {
364 av_log(avctx, AV_LOG_ERROR, "Failed to release output buffer\n");
366 }
367
368 return ret;
369}
370
373 uint8_t *data,
374 size_t size,
375 ssize_t index,
377 AVFrame *frame)
378{
379 int ret = 0;
380 int status = 0;
381 const int sample_size = av_get_bytes_per_sample(avctx->sample_fmt);
382 if (!sample_size) {
383 av_log(avctx, AV_LOG_ERROR, "Could not get bytes per sample\n");
384 ret = AVERROR(ENOSYS);
385 goto done;
386 }
387
388 if (info->size % (sample_size * avctx->ch_layout.nb_channels)) {
389 av_log(avctx, AV_LOG_ERROR, "input is not a multiple of channels * sample_size\n");
390 ret = AVERROR(EINVAL);
391 goto done;
392 }
393
394 frame->format = avctx->sample_fmt;
395 frame->sample_rate = avctx->sample_rate;
396 frame->nb_samples = info->size / (sample_size * avctx->ch_layout.nb_channels);
397
398 ret = av_channel_layout_copy(&frame->ch_layout, &avctx->ch_layout);
399 if (ret < 0) {
400 av_log(avctx, AV_LOG_ERROR, "Could not copy channel layout\n");
401 goto done;
402 }
403
404 /* MediaCodec buffers needs to be copied to our own refcounted buffers
405 * because the flush command invalidates all input and output buffers.
406 */
407 ret = ff_get_buffer(avctx, frame, 0);
408 if (ret < 0) {
409 av_log(avctx, AV_LOG_ERROR, "Could not allocate buffer\n");
410 goto done;
411 }
412
413 /* Override frame->pts as ff_get_buffer will override its value based
414 * on the last avpacket received which is not in sync with the frame:
415 * * N avpackets can be pushed before 1 frame is actually returned
416 * * 0-sized avpackets are pushed to flush remaining frames at EOS */
417 if (avctx->pkt_timebase.num && avctx->pkt_timebase.den) {
420 avctx->pkt_timebase);
421 } else {
422 frame->pts = info->presentationTimeUs;
423 }
424 frame->pkt_dts = AV_NOPTS_VALUE;
425 frame->flags |= AV_FRAME_FLAG_KEY;
426
427 av_log(avctx, AV_LOG_TRACE,
428 "Frame: format=%d channels=%d sample_rate=%d nb_samples=%d",
429 avctx->sample_fmt, avctx->ch_layout.nb_channels, avctx->sample_rate, frame->nb_samples);
430
431 memcpy(frame->data[0], data, info->size);
432
433 ret = 0;
434done:
435 status = ff_AMediaCodec_releaseOutputBuffer(s->codec, index, 0);
436 if (status < 0) {
437 av_log(avctx, AV_LOG_ERROR, "Failed to release output buffer\n");
439 }
440
441 return ret;
442}
443
446 uint8_t *data,
447 size_t size,
448 ssize_t index,
450 AVFrame *frame)
451{
452 int ret = 0;
453 int status = 0;
454
455 frame->width = avctx->width;
456 frame->height = avctx->height;
457 frame->format = avctx->pix_fmt;
458
459 /* MediaCodec buffers needs to be copied to our own refcounted buffers
460 * because the flush command invalidates all input and output buffers.
461 */
462 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
463 av_log(avctx, AV_LOG_ERROR, "Could not allocate buffer\n");
464 goto done;
465 }
466
467 /* Override frame->pkt_pts as ff_get_buffer will override its value based
468 * on the last avpacket received which is not in sync with the frame:
469 * * N avpackets can be pushed before 1 frame is actually returned
470 * * 0-sized avpackets are pushed to flush remaining frames at EOS */
471 if (avctx->pkt_timebase.num && avctx->pkt_timebase.den) {
474 avctx->pkt_timebase);
475 } else {
476 frame->pts = info->presentationTimeUs;
477 }
478 frame->pkt_dts = AV_NOPTS_VALUE;
479
480 av_log(avctx, AV_LOG_TRACE,
481 "Frame: width=%d stride=%d height=%d slice-height=%d "
482 "crop-top=%d crop-bottom=%d crop-left=%d crop-right=%d encoder=%s "
483 "destination linesizes=%d,%d,%d\n" ,
484 avctx->width, s->stride, avctx->height, s->slice_height,
485 s->crop_top, s->crop_bottom, s->crop_left, s->crop_right, s->codec_name,
486 frame->linesize[0], frame->linesize[1], frame->linesize[2]);
487
488 switch (s->color_format) {
491 break;
496 break;
500 break;
503 break;
504 default:
505 av_log(avctx, AV_LOG_ERROR, "Unsupported color format 0x%x (value=%d)\n",
506 s->color_format, s->color_format);
507 ret = AVERROR(EINVAL);
508 goto done;
509 }
510
511 ret = 0;
512done:
513 status = ff_AMediaCodec_releaseOutputBuffer(s->codec, index, 0);
514 if (status < 0) {
515 av_log(avctx, AV_LOG_ERROR, "Failed to release output buffer\n");
517 }
518
519 return ret;
520}
521
524 uint8_t *data,
525 size_t size,
526 ssize_t index,
528 AVFrame *frame)
529{
530 if (avctx->codec_type == AVMEDIA_TYPE_AUDIO)
531 return mediacodec_wrap_sw_audio_buffer(avctx, s, data, size, index, info, frame);
532 else if (avctx->codec_type == AVMEDIA_TYPE_VIDEO)
533 return mediacodec_wrap_sw_video_buffer(avctx, s, data, size, index, info, frame);
534 else
535 av_assert0(0);
536}
537
538#define AMEDIAFORMAT_GET_INT32(name, key, mandatory) do { \
539 int32_t value = 0; \
540 if (ff_AMediaFormat_getInt32(s->format, key, &value)) { \
541 (name) = value; \
542 } else if (mandatory) { \
543 av_log(avctx, AV_LOG_ERROR, "Could not get %s from format %s\n", key, format); \
544 ret = AVERROR_EXTERNAL; \
545 goto fail; \
546 } else { \
547 (name) = 0; \
548 } \
549} while (0) \
550
552{
553 int ret = 0;
554 int width = 0;
555 int height = 0;
556 int color_range = 0;
557 int color_standard = 0;
558 int color_transfer = 0;
559 char *format = NULL;
560
561 if (!s->format) {
562 av_log(avctx, AV_LOG_ERROR, "Output MediaFormat is not set\n");
563 return AVERROR(EINVAL);
564 }
565
567 if (!format) {
568 return AVERROR_EXTERNAL;
569 }
570 av_log(avctx, AV_LOG_DEBUG, "Parsing MediaFormat %s\n", format);
571
572 /* Mandatory fields */
573 AMEDIAFORMAT_GET_INT32(s->width, "width", 1);
574 AMEDIAFORMAT_GET_INT32(s->height, "height", 1);
575
576 AMEDIAFORMAT_GET_INT32(s->stride, "stride", 0);
577 s->stride = s->stride > 0 ? s->stride : s->width;
578
579 AMEDIAFORMAT_GET_INT32(s->slice_height, "slice-height", 0);
580
581 if (strstr(s->codec_name, "OMX.Nvidia.") && s->slice_height == 0) {
582 s->slice_height = FFALIGN(s->height, 16);
583 } else if (strstr(s->codec_name, "OMX.SEC.avc.dec")) {
584 s->slice_height = avctx->height;
585 s->stride = avctx->width;
586 } else if (strstr(s->codec_name, "OMX.MTK.VIDEO.DECODER.MPEG2")) {
587 s->slice_height = s->height;
588 } else if (s->slice_height == 0) {
589 s->slice_height = s->height;
590 }
591
592 AMEDIAFORMAT_GET_INT32(s->color_format, "color-format", 1);
593 avctx->pix_fmt = mcdec_map_color_format(avctx, s, s->color_format);
594 if (avctx->pix_fmt == AV_PIX_FMT_NONE) {
595 av_log(avctx, AV_LOG_ERROR, "Output color format is not supported\n");
596 ret = AVERROR(EINVAL);
597 goto fail;
598 }
599
600 /* Until the codec signals a format change, the output format is the one
601 * set up by configure(), before the codec has seen any input. Its crop
602 * rectangle, display size and color description do not describe the
603 * stream, so keep the values set by the caller. The fields above
604 * describe the configured output buffers and always apply.
605 */
606 if (!s->has_output_format) {
608 return 0;
609 }
610
611 /* Optional fields */
612 AMEDIAFORMAT_GET_INT32(s->crop_top, "crop-top", 0);
613 AMEDIAFORMAT_GET_INT32(s->crop_bottom, "crop-bottom", 0);
614 AMEDIAFORMAT_GET_INT32(s->crop_left, "crop-left", 0);
615 AMEDIAFORMAT_GET_INT32(s->crop_right, "crop-right", 0);
616
617 // Try "crop" for NDK
618 if (!(s->crop_right && s->crop_bottom) && s->use_ndk_codec)
619 ff_AMediaFormat_getRect(s->format, "crop", &s->crop_left, &s->crop_top, &s->crop_right, &s->crop_bottom);
620
621 if (s->crop_right && s->crop_bottom) {
622 width = s->crop_right + 1 - s->crop_left;
623 height = s->crop_bottom + 1 - s->crop_top;
624 } else {
625 /* TODO: NDK MediaFormat should try getRect() first.
626 * Try crop-width/crop-height, it works on NVIDIA Shield.
627 */
628 AMEDIAFORMAT_GET_INT32(width, "crop-width", 0);
629 AMEDIAFORMAT_GET_INT32(height, "crop-height", 0);
630 }
631 if (!width || !height) {
632 width = s->width;
633 height = s->height;
634 }
635
636 AMEDIAFORMAT_GET_INT32(s->display_width, "display-width", 0);
637 AMEDIAFORMAT_GET_INT32(s->display_height, "display-height", 0);
638
639 if (s->display_width && s->display_height) {
640 AVRational sar = av_div_q(
641 (AVRational){ s->display_width, s->display_height },
642 (AVRational){ width, height });
643 ff_set_sar(avctx, sar);
644 }
645
646 AMEDIAFORMAT_GET_INT32(color_range, "color-range", 0);
647 if (color_range)
649
650 AMEDIAFORMAT_GET_INT32(color_standard, "color-standard", 0);
651 if (color_standard) {
654 }
655
656 AMEDIAFORMAT_GET_INT32(color_transfer, "color-transfer", 0);
657 if (color_transfer)
659
660 av_log(avctx, AV_LOG_INFO,
661 "Output crop parameters top=%d bottom=%d left=%d right=%d, "
662 "resulting dimensions width=%d height=%d\n",
663 s->crop_top, s->crop_bottom, s->crop_left, s->crop_right,
664 width, height);
665
667 return ff_set_dimensions(avctx, width, height);
668fail:
670 return ret;
671}
672
674{
675 int ret = 0;
676 int sample_rate = 0;
677 int channel_count = 0;
678 int channel_mask = 0;
679 int pcm_encoding = 0;
680 char *format = NULL;
681
682 if (!s->format) {
683 av_log(avctx, AV_LOG_ERROR, "Output MediaFormat is not set\n");
684 return AVERROR(EINVAL);
685 }
686
688 if (!format) {
689 return AVERROR_EXTERNAL;
690 }
691 av_log(avctx, AV_LOG_DEBUG, "Parsing MediaFormat %s\n", format);
692
693 /* Mandatory fields */
694 AMEDIAFORMAT_GET_INT32(channel_count, "channel-count", 1);
695 AMEDIAFORMAT_GET_INT32(sample_rate, "sample-rate", 1);
696
697 AMEDIAFORMAT_GET_INT32(pcm_encoding, "pcm-encoding", 0);
698 if (pcm_encoding)
699 avctx->sample_fmt = mcdec_map_pcm_format(avctx, s, pcm_encoding);
700 else
702
703 avctx->sample_rate = sample_rate;
704
705 AMEDIAFORMAT_GET_INT32(channel_mask, "channel-mask", 0);
706 if (channel_mask)
707 av_channel_layout_from_mask(&avctx->ch_layout, mcdec_map_channel_mask(avctx, channel_mask));
708 else
709 av_channel_layout_default(&avctx->ch_layout, channel_count);
710
711 av_log(avctx, AV_LOG_INFO,
712 "Output parameters channel-count=%d channel-layout=%x sample-rate=%d\n",
713 channel_count, channel_mask, sample_rate);
714
715fail:
717 return ret;
718}
719
721{
722 if (avctx->codec_type == AVMEDIA_TYPE_AUDIO)
724 else if (avctx->codec_type == AVMEDIA_TYPE_VIDEO)
726 else
727 av_assert0(0);
728}
729
731{
732 FFAMediaCodec *codec = s->codec;
733 int status;
734
735 s->output_buffer_count = 0;
736
737 s->draining = 0;
738 s->flushing = 0;
739 s->eos = 0;
740 atomic_fetch_add(&s->serial, 1);
741 atomic_init(&s->hw_buffer_count, 0);
742 s->current_input_buffer = -1;
743
744 status = ff_AMediaCodec_flush(codec);
745 if (status < 0) {
746 av_log(avctx, AV_LOG_ERROR, "Failed to flush codec\n");
747 return AVERROR_EXTERNAL;
748 }
749
750 return 0;
751}
752
754 const char *mime, FFAMediaFormat *format)
755{
756 int profile;
757
759 static const enum AVPixelFormat pix_fmts[] = {
762 };
763
766 AVMediaCodecContext *user_ctx = avctx->hwaccel_context;
767
768 if (avctx->hw_device_ctx) {
769 AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)(avctx->hw_device_ctx->data);
770 if (device_ctx->type == AV_HWDEVICE_TYPE_MEDIACODEC) {
771 if (device_ctx->hwctx) {
772 AVMediaCodecDeviceContext *mediacodec_ctx = (AVMediaCodecDeviceContext *)device_ctx->hwctx;
773 s->surface = ff_mediacodec_surface_ref(mediacodec_ctx->surface, mediacodec_ctx->native_window, avctx);
774 av_log(avctx, AV_LOG_INFO, "Using surface %p\n", s->surface);
775 }
776 }
777 }
778
779 if (!s->surface && user_ctx && user_ctx->surface) {
780 s->surface = ff_mediacodec_surface_ref(user_ctx->surface, NULL, avctx);
781 av_log(avctx, AV_LOG_INFO, "Using surface %p\n", s->surface);
782 }
783 }
784
786 if (profile < 0) {
787 av_log(avctx, AV_LOG_WARNING, "Unsupported or unknown profile\n");
788 }
789
790 s->codec_name = ff_AMediaCodecList_getCodecNameByType(mime, profile, 0, avctx);
791 if (!s->codec_name && (avctx->hwaccel_flags & AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH)) {
792 profile = -1;
793 s->codec_name = ff_AMediaCodecList_getCodecNameByType(mime, profile, 0, avctx);
794 }
795 if (!s->codec_name) {
796 av_log(avctx, AV_LOG_INFO, "Failed to getCodecNameByType(%s, %d)\n", mime, profile);
797 // getCodecNameByType() can fail due to missing JVM, while NDK
798 // mediacodec can be used without JVM.
799 if (!s->use_ndk_codec) {
800 return AVERROR_EXTERNAL;
801 }
802 } else {
803 av_log(avctx, AV_LOG_DEBUG, "Found decoder %s\n", s->codec_name);
804 }
805
806 if (s->codec_name)
807 s->codec = ff_AMediaCodec_createCodecByName(s->codec_name, s->use_ndk_codec);
808 else {
809 s->codec = ff_AMediaCodec_createDecoderByType(mime, s->use_ndk_codec);
810 if (s->codec) {
811 s->codec_name = ff_AMediaCodec_getName(s->codec);
812 if (!s->codec_name)
813 s->codec_name = av_strdup(mime);
814 }
815 }
816 if (!s->codec) {
817 av_log(avctx, AV_LOG_ERROR, "Failed to create media decoder for type %s and name %s\n", mime, s->codec_name);
818 return AVERROR_EXTERNAL;
819 }
820
821 return 0;
822}
823
825 const char *mime, FFAMediaFormat *format)
826{
827 s->codec = ff_AMediaCodec_createDecoderByType(mime, s->use_ndk_codec);
828 if (!s->codec) {
829 av_log(avctx, AV_LOG_ERROR, "Failed to create media decoder for mime %s\n", mime);
830 return AVERROR_EXTERNAL;
831 }
832
833 s->codec_name = ff_AMediaCodec_getName(s->codec);
834 if (!s->codec_name) {
835 s->codec_name = av_strdup(mime);
836 if (!s->codec_name)
837 return AVERROR(ENOMEM);
838 }
839
840 return 0;
841}
842
844 const char *mime, FFAMediaFormat *format)
845{
846 int ret;
847 int status;
848
849 s->avctx = avctx;
850 atomic_init(&s->refcount, 1);
851 atomic_init(&s->hw_buffer_count, 0);
852 atomic_init(&s->serial, 1);
853 s->current_input_buffer = -1;
854
855 if (avctx->codec_type == AVMEDIA_TYPE_AUDIO)
857 else if (avctx->codec_type == AVMEDIA_TYPE_VIDEO)
859 else
860 av_assert0(0);
861 if (ret < 0)
862 goto fail;
863
864 status = ff_AMediaCodec_configure(s->codec, format, s->surface, NULL, 0);
865 if (status < 0) {
867 av_log(avctx, AV_LOG_ERROR,
868 "Failed to configure codec %s (status = %d) with format %s\n",
869 s->codec_name, status, desc);
870 av_freep(&desc);
871
873 goto fail;
874 }
875
876 status = ff_AMediaCodec_start(s->codec);
877 if (status < 0) {
879 av_log(avctx, AV_LOG_ERROR,
880 "Failed to start codec %s (status = %d) with format %s\n",
881 s->codec_name, status, desc);
882 av_freep(&desc);
884 goto fail;
885 }
886
887 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
888 s->format = ff_AMediaCodec_getOutputFormat(s->codec);
889 if (s->format) {
890 if ((ret = mediacodec_dec_parse_format(avctx, s)) < 0) {
891 av_log(avctx, AV_LOG_ERROR,
892 "Failed to configure context\n");
893 goto fail;
894 }
895 }
896 }
897
898 av_log(avctx, AV_LOG_DEBUG, "MediaCodec %p started successfully\n", s->codec);
899
900 return 0;
901
902fail:
903 av_log(avctx, AV_LOG_ERROR, "MediaCodec %p failed to start\n", s->codec);
905 return ret;
906}
907
909 AVPacket *pkt, bool wait)
910{
911 int offset = 0;
912 int need_draining = 0;
913 uint8_t *data;
914 size_t size;
915 FFAMediaCodec *codec = s->codec;
916 int status;
917 int64_t input_dequeue_timeout_us = wait ? INPUT_DEQUEUE_TIMEOUT_US : 0;
918 int64_t pts;
919
920 if (s->flushing) {
921 av_log(avctx, AV_LOG_ERROR, "Decoder is flushing and cannot accept new buffer "
922 "until all output buffers have been released\n");
923 return AVERROR_EXTERNAL;
924 }
925
926 if (pkt->size == 0) {
927 need_draining = 1;
928 }
929
930 if (s->draining && s->eos) {
931 return AVERROR_EOF;
932 }
933
934 while (offset < pkt->size || (need_draining && !s->draining)) {
935 ssize_t index = s->current_input_buffer;
936 if (index < 0) {
937 index = ff_AMediaCodec_dequeueInputBuffer(codec, input_dequeue_timeout_us);
939 av_log(avctx, AV_LOG_TRACE, "No input buffer available, try again later\n");
940 break;
941 }
942
943 if (index < 0) {
944 av_log(avctx, AV_LOG_ERROR, "Failed to dequeue input buffer (status=%zd)\n", index);
945 return AVERROR_EXTERNAL;
946 }
947 }
948 s->current_input_buffer = -1;
949
951 if (!data) {
952 av_log(avctx, AV_LOG_ERROR, "Failed to get input buffer\n");
953 return AVERROR_EXTERNAL;
954 }
955
956 pts = pkt->pts;
957 if (pts == AV_NOPTS_VALUE) {
958 av_log(avctx, AV_LOG_WARNING, "Input packet is missing PTS\n");
959 pts = 0;
960 }
961 if (pts && avctx->pkt_timebase.num && avctx->pkt_timebase.den) {
963 }
964
965 if (need_draining) {
967
968 av_log(avctx, AV_LOG_DEBUG, "Sending End Of Stream signal\n");
969
970 status = ff_AMediaCodec_queueInputBuffer(codec, index, 0, 0, pts, flags);
971 if (status < 0) {
972 av_log(avctx, AV_LOG_ERROR, "Failed to queue input empty buffer (status = %d)\n", status);
973 return AVERROR_EXTERNAL;
974 }
975
976 av_log(avctx, AV_LOG_TRACE,
977 "Queued empty EOS input buffer %zd with flags=%d\n", index, flags);
978
979 s->draining = 1;
980 return 0;
981 }
982
983 size = FFMIN(pkt->size - offset, size);
984 memcpy(data, pkt->data + offset, size);
985 offset += size;
986
987 status = ff_AMediaCodec_queueInputBuffer(codec, index, 0, size, pts, 0);
988 if (status < 0) {
989 av_log(avctx, AV_LOG_ERROR, "Failed to queue input buffer (status = %d)\n", status);
990 return AVERROR_EXTERNAL;
991 }
992
993 av_log(avctx, AV_LOG_TRACE,
994 "Queued input buffer %zd size=%zd ts=%"PRIi64"\n", index, size, pts);
995 }
996
997 if (offset == 0)
998 return AVERROR(EAGAIN);
999 return offset;
1000}
1001
1003 AVFrame *frame, bool wait)
1004{
1005 int ret;
1006 uint8_t *data;
1007 ssize_t index;
1008 size_t size;
1009 FFAMediaCodec *codec = s->codec;
1010 FFAMediaCodecBufferInfo info = { 0 };
1011 int status;
1012 int64_t output_dequeue_timeout_us = OUTPUT_DEQUEUE_TIMEOUT_US;
1013
1014 if (s->draining && s->eos) {
1015 return AVERROR_EOF;
1016 }
1017
1018 if (s->draining) {
1019 /* If the codec is flushing or need to be flushed, block for a fair
1020 * amount of time to ensure we got a frame */
1021 output_dequeue_timeout_us = OUTPUT_DEQUEUE_BLOCK_TIMEOUT_US;
1022 } else if (s->output_buffer_count == 0 || !wait) {
1023 /* If the codec hasn't produced any frames, do not block so we
1024 * can push data to it as fast as possible, and get the first
1025 * frame */
1026 output_dequeue_timeout_us = 0;
1027 }
1028
1029 index = ff_AMediaCodec_dequeueOutputBuffer(codec, &info, output_dequeue_timeout_us);
1030 if (index >= 0) {
1031 av_log(avctx, AV_LOG_TRACE, "Got output buffer %zd"
1032 " offset=%" PRIi32 " size=%" PRIi32 " ts=%" PRIi64
1033 " flags=%" PRIu32 "\n", index, info.offset, info.size,
1034 info.presentationTimeUs, info.flags);
1035
1037 s->eos = 1;
1038 }
1039
1040 if (info.size) {
1041 if (s->format && !s->has_output_format) {
1042 /* No format change preceded the first output buffer, so the
1043 * initial output format describes the decoded frames. Only
1044 * video fetches that format at init.
1045 */
1046 s->has_output_format = true;
1047 if ((ret = mediacodec_dec_parse_format(avctx, s)) < 0) {
1048 av_log(avctx, AV_LOG_ERROR, "Failed to parse output format\n");
1050 return ret;
1051 }
1052 }
1053
1054 if (s->surface) {
1055 if ((ret = mediacodec_wrap_hw_buffer(avctx, s, index, &info, frame)) < 0) {
1056 av_log(avctx, AV_LOG_ERROR, "Failed to wrap MediaCodec buffer\n");
1057 return ret;
1058 }
1059 } else {
1061 if (!data) {
1062 av_log(avctx, AV_LOG_ERROR, "Failed to get output buffer\n");
1063 return AVERROR_EXTERNAL;
1064 }
1065
1066 if ((ret = mediacodec_wrap_sw_buffer(avctx, s, data, size, index, &info, frame)) < 0) {
1067 av_log(avctx, AV_LOG_ERROR, "Failed to wrap MediaCodec buffer\n");
1068 return ret;
1069 }
1070 }
1071
1072 s->output_buffer_count++;
1073 return 0;
1074 } else {
1075 status = ff_AMediaCodec_releaseOutputBuffer(codec, index, 0);
1076 if (status < 0) {
1077 av_log(avctx, AV_LOG_ERROR, "Failed to release output buffer\n");
1078 }
1079 }
1080
1081 } else if (ff_AMediaCodec_infoOutputFormatChanged(codec, index)) {
1082 char *format = NULL;
1083
1084 if (s->format) {
1085 status = ff_AMediaFormat_delete(s->format);
1086 if (status < 0) {
1087 av_log(avctx, AV_LOG_ERROR, "Failed to delete MediaFormat %p\n", s->format);
1088 }
1089 }
1090
1091 s->format = ff_AMediaCodec_getOutputFormat(codec);
1092 s->has_output_format = true;
1093 if (!s->format) {
1094 av_log(avctx, AV_LOG_ERROR, "Failed to get output format\n");
1095 return AVERROR_EXTERNAL;
1096 }
1097
1099 if (!format) {
1100 return AVERROR_EXTERNAL;
1101 }
1102 av_log(avctx, AV_LOG_INFO, "Output MediaFormat changed to %s\n", format);
1103 av_freep(&format);
1104
1105 if ((ret = mediacodec_dec_parse_format(avctx, s)) < 0) {
1106 return ret;
1107 }
1108
1111 } else if (ff_AMediaCodec_infoTryAgainLater(codec, index)) {
1112 if (s->draining) {
1113 av_log(avctx, AV_LOG_ERROR, "Failed to dequeue output buffer within %" PRIi64 "ms "
1114 "while draining remaining frames, output will probably lack frames\n",
1115 output_dequeue_timeout_us / 1000);
1116 } else {
1117 av_log(avctx, AV_LOG_TRACE, "No output buffer available, try again later\n");
1118 }
1119 } else {
1120 av_log(avctx, AV_LOG_ERROR, "Failed to dequeue output buffer (status=%zd)\n", index);
1121 return AVERROR_EXTERNAL;
1122 }
1123
1124 if (s->draining && s->eos)
1125 return AVERROR_EOF;
1126 return AVERROR(EAGAIN);
1127}
1128
1129/*
1130* ff_mediacodec_dec_flush returns 0 if the flush cannot be performed on
1131* the codec (because the user retains frames). The codec stays in the
1132* flushing state.
1133*
1134* ff_mediacodec_dec_flush returns 1 if the flush can actually be
1135* performed on the codec. The codec leaves the flushing state and can
1136* process again packets.
1137*
1138* ff_mediacodec_dec_flush returns a negative value if an error has
1139* occurred.
1140*/
1142{
1143 if (!s->surface || !s->delay_flush || atomic_load(&s->refcount) == 1) {
1144 int ret;
1145
1146 /* No frames (holding a reference to the codec) are retained by the
1147 * user, thus we can flush the codec and returns accordingly */
1148 if ((ret = mediacodec_dec_flush_codec(avctx, s)) < 0) {
1149 return ret;
1150 }
1151
1152 return 1;
1153 }
1154
1155 s->flushing = 1;
1156 return 0;
1157}
1158
1160{
1161 if (!s)
1162 return 0;
1163
1164 if (s->codec) {
1165 if (atomic_load(&s->hw_buffer_count) == 0) {
1166 ff_AMediaCodec_stop(s->codec);
1167 av_log(avctx, AV_LOG_DEBUG, "MediaCodec %p stopped\n", s->codec);
1168 } else {
1169 av_log(avctx, AV_LOG_DEBUG, "Not stopping MediaCodec (there are buffers pending)\n");
1170 }
1171 }
1172
1174
1175 return 0;
1176}
1177
1179{
1180 return s->flushing;
1181}
static const char *const format[]
Definition af_aiir.c:445
static AVFormatContext * ctx
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition avassert.h:42
Libavcodec external API header.
#define flags(name, subs,...)
Definition cbs_h264.c:74
#define i(width, name, range_min, range_max)
Definition cbs_h264.c:63
#define s(width, name)
Definition cbs_vp9.c:198
Public libavutil channel layout APIs header.
common internal and external API header
#define NULL
Definition coverity.c:32
long long int64_t
Definition coverity.c:34
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition decode.c:1814
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition decode.c:1248
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
Check that the provided sample aspect ratio is valid and set it on the codec context.
Definition utils.c:106
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Definition utils.c:91
static AVPacket * pkt
static enum AVPixelFormat pix_fmt
static AVFrame * frame
int ret
Definition ffplay.c:391
SDL_atomic_t done
Definition ffplay.c:392
#define fail
Definition test.h:479
#define AV_CH_SIDE_LEFT
#define AV_CH_TOP_FRONT_LEFT
#define AV_CH_FRONT_RIGHT
#define AV_CH_TOP_BACK_CENTER
#define AV_CH_FRONT_RIGHT_OF_CENTER
#define AV_CH_BACK_CENTER
#define AV_CH_TOP_FRONT_CENTER
#define AV_CH_FRONT_LEFT_OF_CENTER
#define AV_CH_BACK_RIGHT
#define AV_CH_FRONT_CENTER
#define AV_CH_TOP_BACK_RIGHT
#define AV_CH_TOP_CENTER
#define AV_CH_SIDE_RIGHT
#define AV_CH_BACK_LEFT
#define AV_CH_TOP_BACK_LEFT
#define AV_CH_LOW_FREQUENCY
#define AV_CH_TOP_FRONT_RIGHT
#define AV_CH_FRONT_LEFT
#define AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH
Hardware acceleration should still be attempted for decoding when the codec profile does not match th...
Definition avcodec.h:2038
void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels)
Get the default channel layout for a given number of channels.
int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask)
Initialize a native channel layout from a bitmask indicating which channels are present.
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
#define AV_BUFFER_FLAG_READONLY
Always treat the buffer as read-only, even when it has only one reference.
Definition buffer.h:114
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition buffer.c:56
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition error.h:59
#define AVERROR_EOF
End of file.
Definition error.h:57
#define AVERROR(e)
Definition error.h:45
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition frame.h:694
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition log.h:236
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition log.h:231
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition log.h:216
#define AV_LOG_INFO
Standard information.
Definition log.h:221
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition log.h:210
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition rational.c:88
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
@ AVMEDIA_TYPE_AUDIO
Definition avutil.h:201
@ AVMEDIA_TYPE_VIDEO
Definition avutil.h:200
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition samplefmt.c:109
AVSampleFormat
Audio sample formats.
Definition samplefmt.h:55
@ AV_SAMPLE_FMT_FLT
float
Definition samplefmt.h:60
@ AV_SAMPLE_FMT_S32
signed 32 bits
Definition samplefmt.h:59
@ AV_SAMPLE_FMT_NONE
Definition samplefmt.h:56
@ AV_SAMPLE_FMT_U8
unsigned 8 bits
Definition samplefmt.h:57
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition samplefmt.h:58
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition avutil.h:247
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition avutil.h:263
int index
Definition gxfenc.c:90
@ AV_HWDEVICE_TYPE_MEDIACODEC
Definition hwcontext.h:38
unsigned offset
Definition libaomenc.c:763
static enum AVPixelFormat pix_fmts[]
Definition libkvazaar.c:296
const char * desc
Definition libsvtav1.c:83
static const uint16_t mask[17]
Definition lzw.c:38
#define FFMIN(a, b)
Definition macros.h:49
#define FFALIGN(x, a)
Definition macros.h:78
FFANativeWindow * ff_mediacodec_surface_ref(void *surface, void *native_window, void *log_ctx)
int ff_mediacodec_surface_unref(FFANativeWindow *window, void *log_ctx)
void ff_mediacodec_sw_buffer_copy_yuv420_packed_semi_planar_64x32Tile2m8ka(AVCodecContext *avctx, MediaCodecDecContext *s, uint8_t *data, size_t size, FFAMediaCodecBufferInfo *info, AVFrame *frame)
void ff_mediacodec_sw_buffer_copy_yuv420_semi_planar(AVCodecContext *avctx, MediaCodecDecContext *s, uint8_t *data, size_t size, FFAMediaCodecBufferInfo *info, AVFrame *frame)
void ff_mediacodec_sw_buffer_copy_yuv420_planar(AVCodecContext *avctx, MediaCodecDecContext *s, uint8_t *data, size_t size, FFAMediaCodecBufferInfo *info, AVFrame *frame)
The code handling the various YUV color formats is taken from the GStreamer project.
void ff_mediacodec_sw_buffer_copy_yuv420_packed_semi_planar(AVCodecContext *avctx, MediaCodecDecContext *s, uint8_t *data, size_t size, FFAMediaCodecBufferInfo *info, AVFrame *frame)
FFAMediaCodec * ff_AMediaCodec_createDecoderByType(const char *mime_type, int ndk)
FFAMediaCodec * ff_AMediaCodec_createCodecByName(const char *name, int ndk)
char * ff_AMediaCodecList_getCodecNameByType(const char *mime, int profile, int encoder, void *log_ctx)
enum AVColorPrimaries ff_AMediaFormatColorStandard_to_AVColorPrimaries(int color_standard)
Map MediaFormat color standard to AVColorPrimaries.
int ff_AMediaCodecProfile_getProfileFromAVCodecContext(AVCodecContext *avctx)
The following API around MediaCodec and MediaFormat is based on the NDK one provided by Google since ...
enum AVColorRange ff_AMediaFormatColorRange_to_AVColorRange(int color_range)
Map MediaFormat color range to AVColorRange.
enum AVColorTransferCharacteristic ff_AMediaFormatColorTransfer_to_AVColorTransfer(int color_transfer)
Map MediaFormat color transfer to AVColorTransferCharacteristic.
enum AVColorSpace ff_AMediaFormatColorStandard_to_AVColorSpace(int color_standard)
Map MediaFormat color standard to AVColorSpace.
static char * ff_AMediaFormat_toString(FFAMediaFormat *format)
static int ff_AMediaCodec_releaseOutputBuffer(FFAMediaCodec *codec, size_t idx, int render)
static FFAMediaFormat * ff_AMediaCodec_getOutputFormat(FFAMediaCodec *codec)
static int ff_AMediaCodec_flush(FFAMediaCodec *codec)
static int ff_AMediaFormat_getRect(FFAMediaFormat *format, const char *name, int32_t *left, int32_t *top, int32_t *right, int32_t *bottom)
static int ff_AMediaCodec_infoOutputBuffersChanged(FFAMediaCodec *codec, ssize_t idx)
static int ff_AMediaCodec_queueInputBuffer(FFAMediaCodec *codec, size_t idx, off_t offset, size_t size, uint64_t time, uint32_t flags)
static char * ff_AMediaCodec_getName(FFAMediaCodec *codec)
static int ff_AMediaCodec_getBufferFlagEndOfStream(FFAMediaCodec *codec)
static int ff_AMediaCodec_cleanOutputBuffers(FFAMediaCodec *codec)
static int ff_AMediaFormat_delete(FFAMediaFormat *format)
static int ff_AMediaCodec_configure(FFAMediaCodec *codec, const FFAMediaFormat *format, FFANativeWindow *surface, void *crypto, uint32_t flags)
static int ff_AMediaCodec_start(FFAMediaCodec *codec)
static uint8_t * ff_AMediaCodec_getOutputBuffer(FFAMediaCodec *codec, size_t idx, size_t *out_size)
static ssize_t ff_AMediaCodec_dequeueInputBuffer(FFAMediaCodec *codec, int64_t timeoutUs)
static int ff_AMediaCodec_infoOutputFormatChanged(FFAMediaCodec *codec, ssize_t idx)
static uint8_t * ff_AMediaCodec_getInputBuffer(FFAMediaCodec *codec, size_t idx, size_t *out_size)
static int ff_AMediaCodec_delete(FFAMediaCodec *codec)
static int ff_AMediaCodec_stop(FFAMediaCodec *codec)
static ssize_t ff_AMediaCodec_dequeueOutputBuffer(FFAMediaCodec *codec, FFAMediaCodecBufferInfo *info, int64_t timeoutUs)
static int ff_AMediaCodec_infoTryAgainLater(FFAMediaCodec *codec, ssize_t idx)
@ COLOR_TI_FormatYUV420PackedSemiPlanar
@ COLOR_QCOM_FormatYUV420SemiPlanar32m
@ COLOR_TI_FormatYUV420PackedSemiPlanarInterlaced
@ COLOR_FormatYCbYCr
@ COLOR_FormatYUV420Planar
@ COLOR_QCOM_FormatYUV420PackedSemiPlanar64x32Tile2m8ka
@ COLOR_FormatAndroidOpaque
@ COLOR_QCOM_FormatYUV420SemiPlanar
@ COLOR_FormatYUV420SemiPlanar
int ff_mediacodec_dec_send(AVCodecContext *avctx, MediaCodecDecContext *s, AVPacket *pkt, bool wait)
@ ENCODING_PCM_8BIT
@ ENCODING_PCM_24BIT_PACKED
@ ENCODING_PCM_32BIT
@ ENCODING_PCM_FLOAT
@ ENCODING_PCM_16BIT
static int mediacodec_wrap_sw_video_buffer(AVCodecContext *avctx, MediaCodecDecContext *s, uint8_t *data, size_t size, ssize_t index, FFAMediaCodecBufferInfo *info, AVFrame *frame)
static int mediacodec_wrap_hw_buffer(AVCodecContext *avctx, MediaCodecDecContext *s, ssize_t index, FFAMediaCodecBufferInfo *info, AVFrame *frame)
int ff_mediacodec_dec_flush(AVCodecContext *avctx, MediaCodecDecContext *s)
int ff_mediacodec_dec_receive(AVCodecContext *avctx, MediaCodecDecContext *s, AVFrame *frame, bool wait)
uint64_t layout
#define OUTPUT_DEQUEUE_TIMEOUT_US
static int mediacodec_dec_flush_codec(AVCodecContext *avctx, MediaCodecDecContext *s)
static int mediacodec_wrap_sw_buffer(AVCodecContext *avctx, MediaCodecDecContext *s, uint8_t *data, size_t size, ssize_t index, FFAMediaCodecBufferInfo *info, AVFrame *frame)
static int mediacodec_dec_parse_format(AVCodecContext *avctx, MediaCodecDecContext *s)
int ff_mediacodec_dec_close(AVCodecContext *avctx, MediaCodecDecContext *s)
static int mediacodec_wrap_sw_audio_buffer(AVCodecContext *avctx, MediaCodecDecContext *s, uint8_t *data, size_t size, ssize_t index, FFAMediaCodecBufferInfo *info, AVFrame *frame)
#define INPUT_DEQUEUE_TIMEOUT_US
OMX.k3.video.decoder.avc, OMX.NVIDIA.
int pcm_format
static const struct @363176277014013144023233335312337360113163011307 channel_masks[]
static int mediacodec_dec_parse_audio_format(AVCodecContext *avctx, MediaCodecDecContext *s)
static const struct @000316305124326106314053112007167062251150035262 color_formats[]
static const struct @161106304217160064156176027033213377304043230355 sample_formats[]
#define OUTPUT_DEQUEUE_BLOCK_TIMEOUT_US
static int mediacodec_dec_get_video_codec(AVCodecContext *avctx, MediaCodecDecContext *s, const char *mime, FFAMediaFormat *format)
int ff_mediacodec_dec_init(AVCodecContext *avctx, MediaCodecDecContext *s, const char *mime, FFAMediaFormat *format)
static void ff_mediacodec_dec_ref(MediaCodecDecContext *s)
@ CHANNEL_OUT_LOW_FREQUENCY
@ CHANNEL_OUT_TOP_BACK_LEFT
@ CHANNEL_OUT_TOP_FRONT_LEFT
@ CHANNEL_OUT_TOP_FRONT_RIGHT
@ CHANNEL_OUT_TOP_FRONT_CENTER
@ CHANNEL_OUT_FRONT_CENTER
@ CHANNEL_OUT_TOP_BACK_CENTER
@ CHANNEL_OUT_FRONT_RIGHT_OF_CENTER
@ CHANNEL_OUT_SIDE_RIGHT
@ CHANNEL_OUT_FRONT_RIGHT
@ CHANNEL_OUT_FRONT_LEFT
@ CHANNEL_OUT_SIDE_LEFT
@ CHANNEL_OUT_TOP_BACK_RIGHT
@ CHANNEL_OUT_BACK_CENTER
@ CHANNEL_OUT_TOP_CENTER
@ CHANNEL_OUT_BACK_LEFT
@ CHANNEL_OUT_BACK_RIGHT
@ CHANNEL_OUT_FRONT_LEFT_OF_CENTER
int ff_mediacodec_dec_is_flushing(AVCodecContext *avctx, MediaCodecDecContext *s)
enum AVSampleFormat sample_format
int color_format
static enum AVSampleFormat mcdec_map_pcm_format(AVCodecContext *avctx, MediaCodecDecContext *s, int pcm_format)
static uint64_t mcdec_map_channel_mask(AVCodecContext *avctx, int channel_mask)
static void ff_mediacodec_dec_unref(MediaCodecDecContext *s)
static int mediacodec_dec_get_audio_codec(AVCodecContext *avctx, MediaCodecDecContext *s, const char *mime, FFAMediaFormat *format)
static int mediacodec_dec_parse_video_format(AVCodecContext *avctx, MediaCodecDecContext *s)
#define AMEDIAFORMAT_GET_INT32(name, key, mandatory)
static enum AVPixelFormat mcdec_map_color_format(AVCodecContext *avctx, MediaCodecDecContext *s, int color_format)
static void mediacodec_buffer_release(void *opaque, uint8_t *data)
Memory handling functions.
const char data[16]
Definition mxf.c:155
int profile
Definition mxfenc.c:2338
#define av_strdup(s)
Definition ops_static.c:55
pixel format definitions
AVPixelFormat
Pixel format.
Definition pixfmt.h:71
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition pixfmt.h:96
@ AV_PIX_FMT_NONE
Definition pixfmt.h:72
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition pixfmt.h:73
@ AV_PIX_FMT_MEDIACODEC
hardware decoding through MediaCodec
Definition pixfmt.h:316
#define FF_ARRAY_ELEMS(a)
#define atomic_fetch_sub(object, operand)
Definition stdatomic.h:315
#define atomic_load(object)
Definition stdatomic.h:250
#define atomic_fetch_add(object, operand)
Definition stdatomic.h:312
#define atomic_init(obj, value)
Definition stdatomic.h:119
uint8_t * data
The data buffer.
Definition buffer.h:90
int nb_channels
Number of channels in this layout.
main external API structure.
Definition avcodec.h:443
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition avcodec.h:644
int hwaccel_flags
Bit set of AV_HWACCEL_FLAG_* flags, which affect hardware accelerated decoding (if active).
Definition avcodec.h:1508
int width
picture width / height.
Definition avcodec.h:605
AVChannelLayout ch_layout
Audio channel layout.
Definition avcodec.h:1059
enum AVSampleFormat sample_fmt
audio sample format
Definition avcodec.h:1051
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition avcodec.h:685
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are expressed.
Definition avcodec.h:554
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition avcodec.h:658
enum AVMediaType codec_type
Definition avcodec.h:451
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
Definition avcodec.h:629
enum AVColorSpace colorspace
YUV colorspace type.
Definition avcodec.h:672
int sample_rate
samples per second
Definition avcodec.h:1044
void * hwaccel_context
Legacy hardware accelerator context.
Definition avcodec.h:1453
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition avcodec.h:665
AVBufferRef * hw_device_ctx
A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...
Definition avcodec.h:1499
This structure describes decoded (raw) audio or video data.
Definition frame.h:479
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition hwcontext.h:63
void * hwctx
The format-specific data, allocated and freed by libavutil along with this context.
Definition hwcontext.h:88
enum AVHWDeviceType type
This field identifies the underlying API used for hardware access.
Definition hwcontext.h:75
This structure holds a reference to a android/view/Surface object that will be used as output by the ...
Definition mediacodec.h:33
void * surface
android/view/Surface object reference.
Definition mediacodec.h:38
void * native_window
Pointer to ANativeWindow.
void * surface
android/view/Surface handle, to be filled by the user.
This structure stores compressed data.
Definition packet.h:587
Rational number (pair of numerator and denominator).
Definition rational.h:58
int num
Numerator.
Definition rational.h:59
int den
Denominator.
Definition rational.h:60
#define av_mallocz(s)
#define av_freep(p)
#define av_log(a,...)
static char buffer[20]
Definition seek.c:33
#define height
Definition dsp.h:99
#define width
Definition dsp.h:99
timestamp utils, mostly useful for debugging/logging purposes
static int64_t pts
int size
color_range