Go to the documentation of this file.
23 #include "config_components.h"
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)
82 static const uint8_t nalu_header[] = { 0x00, 0x00, 0x00, 0x01 };
88 p =
av_malloc(
sizeof(nalu_header) + src_size);
94 *
out_size =
sizeof(nalu_header) + src_size;
96 memcpy(p, nalu_header,
sizeof(nalu_header));
97 memcpy(p +
sizeof(nalu_header),
src, src_size);
130 #if CONFIG_H264_MEDIACODEC_DECODER
140 int nal_length_size = 0;
142 memset(&ps, 0,
sizeof(ps));
145 &ps, &is_avc, &nal_length_size, 0, avctx);
170 if ((
ret = h2645_ps_to_nalu(
sps->data,
sps->data_size, &
data, &data_size)) < 0) {
176 if ((
ret = h2645_ps_to_nalu(
pps->data,
pps->data_size, &
data, &data_size)) < 0) {
182 const int warn = is_avc && (avctx->
codec_tag ==
MKTAG(
'a',
'v',
'c',
'1') ||
185 "Could not extract PPS/SPS from extradata\n");
196 #if CONFIG_HEVC_MEDIACODEC_DECODER
209 int nal_length_size = 0;
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;
218 memset(&ps, 0,
sizeof(ps));
219 memset(&
sei, 0,
sizeof(
sei));
222 &ps, &
sei, &is_nalff, &nal_length_size, 0, 1, avctx);
251 avctx->
profile =
sps->ptl.general_ptl.profile_idc;
252 avctx->
level =
sps->ptl.general_ptl.level_idc;
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) {
260 data_size = vps_data_size + sps_data_size + pps_data_size;
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);
275 const int warn = is_nalff && avctx->
codec_tag ==
MKTAG(
'h',
'v',
'c',
'1');
277 "Could not extract VPS/PPS/SPS from extradata\n");
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
318 const char *codec_mime =
NULL;
323 if (
s->use_ndk_codec < 0)
334 #if CONFIG_AV1_MEDIACODEC_DECODER
336 codec_mime =
"video/av01";
338 ret = common_set_extradata(avctx,
format);
343 #if CONFIG_H264_MEDIACODEC_DECODER
345 codec_mime =
"video/avc";
352 #if CONFIG_HEVC_MEDIACODEC_DECODER
354 codec_mime =
"video/hevc";
361 #if CONFIG_MPEG2_MEDIACODEC_DECODER
363 codec_mime =
"video/mpeg2";
365 ret = common_set_extradata(avctx,
format);
370 #if CONFIG_MPEG4_MEDIACODEC_DECODER
372 codec_mime =
"video/mp4v-es",
374 ret = common_set_extradata(avctx,
format);
379 #if CONFIG_VP8_MEDIACODEC_DECODER
381 codec_mime =
"video/x-vnd.on2.vp8";
383 ret = common_set_extradata(avctx,
format);
388 #if CONFIG_VP9_MEDIACODEC_DECODER
390 codec_mime =
"video/x-vnd.on2.vp9";
392 ret = common_set_extradata(avctx,
format);
397 #if CONFIG_AAC_MEDIACODEC_DECODER
399 codec_mime =
"audio/mp4a-latm";
401 ret = common_set_extradata(avctx,
format);
406 #if CONFIG_AMRNB_MEDIACODEC_DECODER
408 codec_mime =
"audio/3gpp";
410 ret = common_set_extradata(avctx,
format);
415 #if CONFIG_AMRWB_MEDIACODEC_DECODER
417 codec_mime =
"audio/amr-wb";
419 ret = common_set_extradata(avctx,
format);
424 #if CONFIG_MP3_MEDIACODEC_DECODER
426 codec_mime =
"audio/mpeg";
428 ret = common_set_extradata(avctx,
format);
446 if (
s->operating_rate > 0)
456 s->ctx->delay_flush =
s->delay_flush;
457 s->ctx->use_ndk_codec =
s->use_ndk_codec;
465 "MediaCodec started successfully: codec = %s, ret = %d\n",
466 s->ctx->codec_name,
ret);
475 if (sdk_int > 0 && sdk_int <= 23 &&
476 strcmp(
s->ctx->codec_name,
"OMX.amlogic.mpeg2.decoder.awesome") == 0) {
478 s->ctx->codec_name, sdk_int);
479 s->amlogic_mpeg2_api23_workaround = 1;
515 if (
s->ctx->current_input_buffer < 0 && !
s->ctx->draining) {
531 s->ctx->current_input_buffer =
index;
535 if (
s->buffered_pkt.size > 0) {
538 s->buffered_pkt.size -=
ret;
539 s->buffered_pkt.data +=
ret;
540 if (
s->buffered_pkt.size <= 0) {
544 "could not send entire packet in single input buffer (%d < %d)\n",
545 ret,
s->buffered_pkt.size+
ret);
551 if (
s->amlogic_mpeg2_api23_workaround &&
s->buffered_pkt.size <= 0) {
567 }
else if (
ret ==
AVERROR(EAGAIN) &&
s->ctx->current_input_buffer < 0) {
569 }
else if (
ret < 0) {
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",
604 {
"ndk_codec",
"Use MediaCodec from NDK",
606 {
"operating_rate",
"The desired operating rate that the codec will need to operate at, zero for unspecified",
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, \
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, \
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, \
635 .hw_configs = mediacodec_hw_configs, \
636 .p.wrapper_name = "mediacodec", \
639 #if CONFIG_H264_MEDIACODEC_DECODER
643 #if CONFIG_HEVC_MEDIACODEC_DECODER
647 #if CONFIG_MPEG2_MEDIACODEC_DECODER
651 #if CONFIG_MPEG4_MEDIACODEC_DECODER
655 #if CONFIG_VP8_MEDIACODEC_DECODER
659 #if CONFIG_VP9_MEDIACODEC_DECODER
663 #if CONFIG_AV1_MEDIACODEC_DECODER
667 #define AD AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM
669 {
"ndk_codec",
"Use MediaCodec from NDK",
671 {
"operating_rate",
"The desired operating rate that the codec will need to operate at, zero for unspecified",
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, \
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, \
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, \
700 .p.wrapper_name = "mediacodec", \
703 #if CONFIG_AAC_MEDIACODEC_DECODER
707 #if CONFIG_AMRNB_MEDIACODEC_DECODER
711 #if CONFIG_AMRWB_MEDIACODEC_DECODER
715 #if CONFIG_MP3_MEDIACODEC_DECODER
const SPS * sps_list[MAX_SPS_COUNT]
RefStruct references.
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)
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Called by decoders to get the next packet for decoding.
#define AV_LOG_WARNING
Something somehow does not look correct.
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
void ff_h264_ps_uninit(H264ParamSets *ps)
Uninit H264 param sets structure.
int sample_rate
samples per second
const HEVCPPS * pps_list[HEVC_MAX_PPS_COUNT]
RefStruct references.
#define AVERROR_EOF
End of file.
const PPS * pps_list[MAX_PPS_COUNT]
RefStruct references.
This structure describes decoded (raw) audio or video data.
@ AV_HWDEVICE_TYPE_MEDIACODEC
int nb_channels
Number of channels in this layout.
AVChannelLayout ch_layout
Audio channel layout.
int amlogic_mpeg2_api23_workaround
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
const HEVCSPS * sps_list[HEVC_MAX_SPS_COUNT]
RefStruct references.
@ AV_CODEC_HW_CONFIG_METHOD_AD_HOC
The codec supports this format by some ad-hoc method.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
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
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)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
enum AVPixelFormat pix_fmt
For decoders, a hardware pixel format which that decoder may be able to decode to if suitable hardwar...
@ AV_PIX_FMT_MEDIACODEC
hardware decoding through MediaCodec
Describe the class of an AVClass context structure.
static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H265RawVPS *current)
@ AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX
The codec supports this format via the hw_device_ctx interface.
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
int level
Encoding level descriptor.
#define AVERROR_EXTERNAL
Generic error in an external library.
#define AV_LOG_INFO
Standard information.
void ff_hevc_ps_uninit(HEVCParamSets *ps)
#define i(width, name, range_min, range_max)
uint8_t * extradata
Out-of-band global headers that may be used by some codecs.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
void * av_jni_get_java_vm(void *log_ctx)
int ff_h264_get_profile(const SPS *sps)
Compute profile from profile_idc and constraint_set?_flags.
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
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
main external API structure.
@ AV_OPT_TYPE_INT
Underlying C type is int.
MediaCodecDecContext * ctx
enum AVMediaType codec_type
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
This structure stores compressed data.
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
const HEVCVPS * vps_list[HEVC_MAX_VPS_COUNT]
RefStruct references.
int width
picture width / height.
#define MKTAG(a, b, c, d)
AVCodecHWConfig public
This is the structure which will be returned to the user by avcodec_get_hw_config().
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.