Go to the documentation of this file.
23 #include "config_components.h"
74 #if CONFIG_H264_MEDIACODEC_DECODER || CONFIG_HEVC_MEDIACODEC_DECODER
75 static int h2645_ps_to_nalu(
const uint8_t *
src,
int src_size, uint8_t **
out,
int *
out_size)
80 static const uint8_t nalu_header[] = { 0x00, 0x00, 0x00, 0x01 };
86 p =
av_malloc(
sizeof(nalu_header) + src_size);
92 *
out_size =
sizeof(nalu_header) + src_size;
94 memcpy(p, nalu_header,
sizeof(nalu_header));
95 memcpy(p +
sizeof(nalu_header),
src, src_size);
128 #if CONFIG_H264_MEDIACODEC_DECODER
138 int nal_length_size = 0;
140 memset(&ps, 0,
sizeof(ps));
143 &ps, &is_avc, &nal_length_size, 0, avctx);
168 if ((
ret = h2645_ps_to_nalu(
sps->data,
sps->data_size, &
data, &data_size)) < 0) {
174 if ((
ret = h2645_ps_to_nalu(
pps->data,
pps->data_size, &
data, &data_size)) < 0) {
180 const int warn = is_avc && (avctx->
codec_tag ==
MKTAG(
'a',
'v',
'c',
'1') ||
183 "Could not extract PPS/SPS from extradata\n");
194 #if CONFIG_HEVC_MEDIACODEC_DECODER
207 int nal_length_size = 0;
209 uint8_t *vps_data =
NULL;
210 uint8_t *sps_data =
NULL;
211 uint8_t *pps_data =
NULL;
212 int vps_data_size = 0;
213 int sps_data_size = 0;
214 int pps_data_size = 0;
216 memset(&ps, 0,
sizeof(ps));
217 memset(&
sei, 0,
sizeof(
sei));
220 &ps, &
sei, &is_nalff, &nal_length_size, 0, 1, avctx);
249 avctx->
profile =
sps->ptl.general_ptl.profile_idc;
250 avctx->
level =
sps->ptl.general_ptl.level_idc;
252 if ((
ret = h2645_ps_to_nalu(
vps->data,
vps->data_size, &vps_data, &vps_data_size)) < 0 ||
253 (
ret = h2645_ps_to_nalu(
sps->data,
sps->data_size, &sps_data, &sps_data_size)) < 0 ||
254 (
ret = h2645_ps_to_nalu(
pps->data,
pps->data_size, &pps_data, &pps_data_size)) < 0) {
258 data_size = vps_data_size + sps_data_size + pps_data_size;
265 memcpy(
data , vps_data, vps_data_size);
266 memcpy(
data + vps_data_size , sps_data, sps_data_size);
267 memcpy(
data + vps_data_size + sps_data_size, pps_data, pps_data_size);
273 const int warn = is_nalff && avctx->
codec_tag ==
MKTAG(
'h',
'v',
'c',
'1');
275 "Could not extract VPS/PPS/SPS from extradata\n");
290 #if CONFIG_MPEG2_MEDIACODEC_DECODER || \
291 CONFIG_MPEG4_MEDIACODEC_DECODER || \
292 CONFIG_VP8_MEDIACODEC_DECODER || \
293 CONFIG_VP9_MEDIACODEC_DECODER || \
294 CONFIG_AV1_MEDIACODEC_DECODER
312 const char *codec_mime =
NULL;
317 if (
s->use_ndk_codec < 0)
328 #if CONFIG_AV1_MEDIACODEC_DECODER
330 codec_mime =
"video/av01";
332 ret = common_set_extradata(avctx,
format);
337 #if CONFIG_H264_MEDIACODEC_DECODER
339 codec_mime =
"video/avc";
346 #if CONFIG_HEVC_MEDIACODEC_DECODER
348 codec_mime =
"video/hevc";
355 #if CONFIG_MPEG2_MEDIACODEC_DECODER
357 codec_mime =
"video/mpeg2";
359 ret = common_set_extradata(avctx,
format);
364 #if CONFIG_MPEG4_MEDIACODEC_DECODER
366 codec_mime =
"video/mp4v-es",
368 ret = common_set_extradata(avctx,
format);
373 #if CONFIG_VP8_MEDIACODEC_DECODER
375 codec_mime =
"video/x-vnd.on2.vp8";
377 ret = common_set_extradata(avctx,
format);
382 #if CONFIG_VP9_MEDIACODEC_DECODER
384 codec_mime =
"video/x-vnd.on2.vp9";
386 ret = common_set_extradata(avctx,
format);
406 s->ctx->delay_flush =
s->delay_flush;
407 s->ctx->use_ndk_codec =
s->use_ndk_codec;
415 "MediaCodec started successfully: codec = %s, ret = %d\n",
416 s->ctx->codec_name,
ret);
425 if (sdk_int > 0 && sdk_int <= 23 &&
426 strcmp(
s->ctx->codec_name,
"OMX.amlogic.mpeg2.decoder.awesome") == 0) {
428 s->ctx->codec_name, sdk_int);
429 s->amlogic_mpeg2_api23_workaround = 1;
465 if (
s->ctx->current_input_buffer < 0) {
481 s->ctx->current_input_buffer =
index;
485 if (
s->buffered_pkt.size > 0) {
488 s->buffered_pkt.size -=
ret;
489 s->buffered_pkt.data +=
ret;
490 if (
s->buffered_pkt.size <= 0) {
494 "could not send entire packet in single input buffer (%d < %d)\n",
495 ret,
s->buffered_pkt.size+
ret);
501 if (
s->amlogic_mpeg2_api23_workaround &&
s->buffered_pkt.size <= 0) {
517 }
else if (
ret ==
AVERROR(EAGAIN) &&
s->ctx->current_input_buffer < 0) {
519 }
else if (
ret < 0) {
549 #define OFFSET(x) offsetof(MediaCodecH264DecContext, x)
550 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
552 {
"delay_flush",
"Delay flush until hw output buffers are returned to the decoder",
554 {
"ndk_codec",
"Use MediaCodec from NDK",
559 #define DECLARE_MEDIACODEC_VCLASS(short_name) \
560 static const AVClass ff_##short_name##_mediacodec_dec_class = { \
561 .class_name = #short_name "_mediacodec", \
562 .item_name = av_default_item_name, \
563 .option = ff_mediacodec_vdec_options, \
564 .version = LIBAVUTIL_VERSION_INT, \
567 #define DECLARE_MEDIACODEC_VDEC(short_name, full_name, codec_id, bsf) \
568 DECLARE_MEDIACODEC_VCLASS(short_name) \
569 const FFCodec ff_ ## short_name ## _mediacodec_decoder = { \
570 .p.name = #short_name "_mediacodec", \
571 CODEC_LONG_NAME(full_name " Android MediaCodec decoder"), \
572 .p.type = AVMEDIA_TYPE_VIDEO, \
574 .p.priv_class = &ff_##short_name##_mediacodec_dec_class, \
575 .priv_data_size = sizeof(MediaCodecH264DecContext), \
576 .init = mediacodec_decode_init, \
577 FF_CODEC_RECEIVE_FRAME_CB(mediacodec_receive_frame), \
578 .flush = mediacodec_decode_flush, \
579 .close = mediacodec_decode_close, \
580 .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_HARDWARE, \
581 .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE, \
583 .hw_configs = mediacodec_hw_configs, \
584 .p.wrapper_name = "mediacodec", \
587 #if CONFIG_H264_MEDIACODEC_DECODER
591 #if CONFIG_HEVC_MEDIACODEC_DECODER
595 #if CONFIG_MPEG2_MEDIACODEC_DECODER
599 #if CONFIG_MPEG4_MEDIACODEC_DECODER
603 #if CONFIG_VP8_MEDIACODEC_DECODER
607 #if CONFIG_VP9_MEDIACODEC_DECODER
611 #if CONFIG_AV1_MEDIACODEC_DECODER
const SPS * sps_list[MAX_SPS_COUNT]
RefStruct references.
@ AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX
The codec supports this format via the hw_device_ctx interface.
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.
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_CODEC_HW_CONFIG_METHOD_AD_HOC
The codec supports this format by some ad-hoc method.
@ AV_HWDEVICE_TYPE_MEDIACODEC
int amlogic_mpeg2_api23_workaround
const HEVCSPS * sps_list[HEVC_MAX_SPS_COUNT]
RefStruct references.
#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.
void ff_hevc_ps_uninit(HEVCParamSets *ps)
static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H265RawVPS *current)
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)
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.
#define i(width, name, range_min, range_max)
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
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.
MediaCodecDecContext * ctx
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
This structure stores compressed data.
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.