Index: Makefile
===================================================================
--- Makefile (nonexistent)
+++ Makefile (revision 377)
@@ -0,0 +1,1313 @@
+NAME = avcodec
+DESC = FFmpeg codec library
+
+HEADERS = ac3_parser.h \
+ adts_parser.h \
+ avcodec.h \
+ avdct.h \
+ avfft.h \
+ bsf.h \
+ codec.h \
+ codec_desc.h \
+ codec_id.h \
+ codec_par.h \
+ d3d11va.h \
+ dirac.h \
+ dv_profile.h \
+ dxva2.h \
+ jni.h \
+ mediacodec.h \
+ packet.h \
+ qsv.h \
+ vaapi.h \
+ vdpau.h \
+ version.h \
+ videotoolbox.h \
+ vorbis_parser.h \
+ xvmc.h \
+
+OBJS = ac3_parser.o \
+ adts_parser.o \
+ allcodecs.o \
+ avcodec.o \
+ avdct.o \
+ avpacket.o \
+ avpicture.o \
+ bitstream.o \
+ bitstream_filter.o \
+ bitstream_filters.o \
+ bsf.o \
+ codec_desc.o \
+ codec_par.o \
+ d3d11va.o \
+ decode.o \
+ dirac.o \
+ dv_profile.o \
+ encode.o \
+ imgconvert.o \
+ jni.o \
+ mathtables.o \
+ mediacodec.o \
+ mpeg12framerate.o \
+ options.o \
+ parser.o \
+ parsers.o \
+ profiles.o \
+ qsv_api.o \
+ raw.o \
+ utils.o \
+ vorbis_parser.o \
+ xiph.o \
+
+# subsystems
+OBJS-$(CONFIG_AANDCTTABLES) += aandcttab.o
+OBJS-$(CONFIG_AC3DSP) += ac3dsp.o ac3.o ac3tab.o
+OBJS-$(CONFIG_ADTS_HEADER) += adts_header.o mpeg4audio.o
+OBJS-$(CONFIG_AMF) += amfenc.o
+OBJS-$(CONFIG_AUDIO_FRAME_QUEUE) += audio_frame_queue.o
+OBJS-$(CONFIG_ATSC_A53) += atsc_a53.o
+OBJS-$(CONFIG_AUDIODSP) += audiodsp.o
+OBJS-$(CONFIG_BLOCKDSP) += blockdsp.o
+OBJS-$(CONFIG_BSWAPDSP) += bswapdsp.o
+OBJS-$(CONFIG_CABAC) += cabac.o
+OBJS-$(CONFIG_CBS) += cbs.o cbs_bsf.o
+OBJS-$(CONFIG_CBS_AV1) += cbs_av1.o
+OBJS-$(CONFIG_CBS_H264) += cbs_h2645.o cbs_sei.o h2645_parse.o
+OBJS-$(CONFIG_CBS_H265) += cbs_h2645.o cbs_sei.o h2645_parse.o
+OBJS-$(CONFIG_CBS_JPEG) += cbs_jpeg.o
+OBJS-$(CONFIG_CBS_MPEG2) += cbs_mpeg2.o
+OBJS-$(CONFIG_CBS_VP9) += cbs_vp9.o
+OBJS-$(CONFIG_CRYSTALHD) += crystalhd.o
+OBJS-$(CONFIG_DCT) += dct.o dct32_fixed.o dct32_float.o
+OBJS-$(CONFIG_ERROR_RESILIENCE) += error_resilience.o
+OBJS-$(CONFIG_EXIF) += exif.o tiff_common.o
+OBJS-$(CONFIG_FAANDCT) += faandct.o
+OBJS-$(CONFIG_FAANIDCT) += faanidct.o
+OBJS-$(CONFIG_FDCTDSP) += fdctdsp.o jfdctfst.o jfdctint.o
+FFT-OBJS-$(CONFIG_HARDCODED_TABLES) += cos_tables.o
+OBJS-$(CONFIG_FFT) += avfft.o fft_float.o fft_fixed_32.o \
+ fft_init_table.o $(FFT-OBJS-yes)
+OBJS-$(CONFIG_FLACDSP) += flacdsp.o
+OBJS-$(CONFIG_FMTCONVERT) += fmtconvert.o
+OBJS-$(CONFIG_GOLOMB) += golomb.o
+OBJS-$(CONFIG_H263DSP) += h263dsp.o
+OBJS-$(CONFIG_H264CHROMA) += h264chroma.o
+OBJS-$(CONFIG_H264DSP) += h264dsp.o h264idct.o
+OBJS-$(CONFIG_H264PARSE) += h264_parse.o h2645_parse.o h264_ps.o
+OBJS-$(CONFIG_H264PRED) += h264pred.o
+OBJS-$(CONFIG_H264QPEL) += h264qpel.o
+OBJS-$(CONFIG_HEVCPARSE) += hevc_parse.o h2645_parse.o hevc_ps.o hevc_sei.o hevc_data.o \
+ dynamic_hdr10_plus.o
+OBJS-$(CONFIG_HPELDSP) += hpeldsp.o
+OBJS-$(CONFIG_HUFFMAN) += huffman.o
+OBJS-$(CONFIG_HUFFYUVDSP) += huffyuvdsp.o
+OBJS-$(CONFIG_HUFFYUVENCDSP) += huffyuvencdsp.o
+OBJS-$(CONFIG_IDCTDSP) += idctdsp.o simple_idct.o jrevdct.o
+OBJS-$(CONFIG_IIRFILTER) += iirfilter.o
+OBJS-$(CONFIG_MDCT15) += mdct15.o
+OBJS-$(CONFIG_INTRAX8) += intrax8.o intrax8dsp.o msmpeg4data.o
+OBJS-$(CONFIG_IVIDSP) += ivi_dsp.o
+OBJS-$(CONFIG_JNI) += ffjni.o jni.o
+OBJS-$(CONFIG_JPEGTABLES) += jpegtables.o
+OBJS-$(CONFIG_LLAUDDSP) += lossless_audiodsp.o
+OBJS-$(CONFIG_LLVIDDSP) += lossless_videodsp.o
+OBJS-$(CONFIG_LLVIDENCDSP) += lossless_videoencdsp.o
+OBJS-$(CONFIG_LPC) += lpc.o
+OBJS-$(CONFIG_LSP) += lsp.o
+OBJS-$(CONFIG_LZF) += lzf.o
+OBJS-$(CONFIG_MDCT) += mdct_float.o mdct_fixed_32.o
+OBJS-$(CONFIG_ME_CMP) += me_cmp.o
+OBJS-$(CONFIG_MEDIACODEC) += mediacodecdec_common.o mediacodec_surface.o mediacodec_wrapper.o mediacodec_sw_buffer.o
+OBJS-$(CONFIG_MPEG_ER) += mpeg_er.o
+OBJS-$(CONFIG_MPEGAUDIO) += mpegaudio.o mpegaudiodec_common.o
+OBJS-$(CONFIG_MPEGAUDIODSP) += mpegaudiodsp.o \
+ mpegaudiodsp_data.o \
+ mpegaudiodsp_fixed.o \
+ mpegaudiodsp_float.o
+OBJS-$(CONFIG_MPEGAUDIOHEADER) += mpegaudiodecheader.o mpegaudiodata.o
+OBJS-$(CONFIG_MPEGVIDEO) += mpegvideo.o mpegvideodsp.o rl.o \
+ mpegvideo_motion.o mpegutils.o \
+ mpegvideodata.o mpegpicture.o
+OBJS-$(CONFIG_MPEGVIDEOENC) += mpegvideo_enc.o mpeg12data.o \
+ motion_est.o ratecontrol.o \
+ mpegvideoencdsp.o
+OBJS-$(CONFIG_MSS34DSP) += mss34dsp.o
+OBJS-$(CONFIG_PIXBLOCKDSP) += pixblockdsp.o
+OBJS-$(CONFIG_QPELDSP) += qpeldsp.o
+OBJS-$(CONFIG_QSV) += qsv.o
+OBJS-$(CONFIG_QSVDEC) += qsvdec.o
+OBJS-$(CONFIG_QSVENC) += qsvenc.o
+OBJS-$(CONFIG_RANGECODER) += rangecoder.o
+OBJS-$(CONFIG_RDFT) += rdft.o
+OBJS-$(CONFIG_RV34DSP) += rv34dsp.o
+OBJS-$(CONFIG_SHARED) += log2_tab.o reverse.o
+OBJS-$(CONFIG_SINEWIN) += sinewin.o
+OBJS-$(CONFIG_SNAPPY) += snappy.o
+OBJS-$(CONFIG_STARTCODE) += startcode.o
+OBJS-$(CONFIG_TEXTUREDSP) += texturedsp.o
+OBJS-$(CONFIG_TEXTUREDSPENC) += texturedspenc.o
+OBJS-$(CONFIG_TPELDSP) += tpeldsp.o
+OBJS-$(CONFIG_VAAPI_ENCODE) += vaapi_encode.o
+OBJS-$(CONFIG_VC1DSP) += vc1dsp.o
+OBJS-$(CONFIG_VIDEODSP) += videodsp.o
+OBJS-$(CONFIG_VP3DSP) += vp3dsp.o
+OBJS-$(CONFIG_VP56DSP) += vp56dsp.o
+OBJS-$(CONFIG_VP8DSP) += vp8dsp.o
+OBJS-$(CONFIG_V4L2_M2M) += v4l2_m2m.o v4l2_context.o v4l2_buffers.o v4l2_fmt.o
+OBJS-$(CONFIG_WMA_FREQS) += wma_freqs.o
+OBJS-$(CONFIG_WMV2DSP) += wmv2dsp.o
+
+# decoders/encoders
+OBJS-$(CONFIG_ZERO12V_DECODER) += 012v.o
+OBJS-$(CONFIG_A64MULTI_ENCODER) += a64multienc.o elbg.o
+OBJS-$(CONFIG_A64MULTI5_ENCODER) += a64multienc.o elbg.o
+OBJS-$(CONFIG_AAC_DECODER) += aacdec.o aactab.o aacsbr.o aacps_common.o aacps_float.o \
+ mpeg4audio.o kbdwin.o \
+ sbrdsp.o aacpsdsp_float.o cbrt_data.o
+OBJS-$(CONFIG_AAC_FIXED_DECODER) += aacdec_fixed.o aactab.o aacsbr_fixed.o aacps_common.o aacps_fixed.o \
+ mpeg4audio.o kbdwin.o \
+ sbrdsp_fixed.o aacpsdsp_fixed.o cbrt_data_fixed.o
+OBJS-$(CONFIG_AAC_ENCODER) += aacenc.o aaccoder.o aacenctab.o \
+ aacpsy.o aactab.o \
+ aacenc_is.o \
+ aacenc_tns.o \
+ aacenc_ltp.o \
+ aacenc_pred.o \
+ psymodel.o mpeg4audio.o kbdwin.o
+OBJS-$(CONFIG_AAC_MF_ENCODER) += mfenc.o mf_utils.o
+OBJS-$(CONFIG_AASC_DECODER) += aasc.o msrledec.o
+OBJS-$(CONFIG_AC3_DECODER) += ac3dec_float.o ac3dec_data.o ac3.o kbdwin.o ac3tab.o
+OBJS-$(CONFIG_AC3_FIXED_DECODER) += ac3dec_fixed.o ac3dec_data.o ac3.o kbdwin.o ac3tab.o
+OBJS-$(CONFIG_AC3_ENCODER) += ac3enc_float.o ac3enc.o ac3tab.o \
+ ac3.o kbdwin.o
+OBJS-$(CONFIG_AC3_FIXED_ENCODER) += ac3enc_fixed.o ac3enc.o ac3tab.o ac3.o kbdwin.o
+OBJS-$(CONFIG_AC3_MF_ENCODER) += mfenc.o mf_utils.o
+OBJS-$(CONFIG_ACELP_KELVIN_DECODER) += g729dec.o lsp.o celp_math.o celp_filters.o acelp_filters.o acelp_pitch_delay.o acelp_vectors.o g729postfilter.o
+OBJS-$(CONFIG_AGM_DECODER) += agm.o
+OBJS-$(CONFIG_AIC_DECODER) += aic.o
+OBJS-$(CONFIG_ALAC_DECODER) += alac.o alac_data.o alacdsp.o
+OBJS-$(CONFIG_ALAC_ENCODER) += alacenc.o alac_data.o
+OBJS-$(CONFIG_ALIAS_PIX_DECODER) += aliaspixdec.o
+OBJS-$(CONFIG_ALIAS_PIX_ENCODER) += aliaspixenc.o
+OBJS-$(CONFIG_ALS_DECODER) += alsdec.o bgmc.o mlz.o mpeg4audio.o
+OBJS-$(CONFIG_AMRNB_DECODER) += amrnbdec.o celp_filters.o \
+ celp_math.o acelp_filters.o \
+ acelp_vectors.o \
+ acelp_pitch_delay.o
+OBJS-$(CONFIG_AMRWB_DECODER) += amrwbdec.o celp_filters.o \
+ celp_math.o acelp_filters.o \
+ acelp_vectors.o \
+ acelp_pitch_delay.o
+OBJS-$(CONFIG_AMV_ENCODER) += mjpegenc.o mjpegenc_common.o \
+ mjpegenc_huffman.o
+OBJS-$(CONFIG_ANM_DECODER) += anm.o
+OBJS-$(CONFIG_ANSI_DECODER) += ansi.o cga_data.o
+OBJS-$(CONFIG_APE_DECODER) += apedec.o
+OBJS-$(CONFIG_APTX_DECODER) += aptxdec.o aptx.o
+OBJS-$(CONFIG_APTX_ENCODER) += aptxenc.o aptx.o
+OBJS-$(CONFIG_APTX_HD_DECODER) += aptxdec.o aptx.o
+OBJS-$(CONFIG_APTX_HD_ENCODER) += aptxenc.o aptx.o
+OBJS-$(CONFIG_APNG_DECODER) += png.o pngdec.o pngdsp.o
+OBJS-$(CONFIG_APNG_ENCODER) += png.o pngenc.o
+OBJS-$(CONFIG_ARBC_DECODER) += arbc.o
+OBJS-$(CONFIG_ARGO_DECODER) += argo.o
+OBJS-$(CONFIG_SSA_DECODER) += assdec.o ass.o
+OBJS-$(CONFIG_SSA_ENCODER) += assenc.o ass.o
+OBJS-$(CONFIG_ASS_DECODER) += assdec.o ass.o
+OBJS-$(CONFIG_ASS_ENCODER) += assenc.o ass.o
+OBJS-$(CONFIG_ASV1_DECODER) += asvdec.o asv.o mpeg12data.o
+OBJS-$(CONFIG_ASV1_ENCODER) += asvenc.o asv.o mpeg12data.o
+OBJS-$(CONFIG_ASV2_DECODER) += asvdec.o asv.o mpeg12data.o
+OBJS-$(CONFIG_ASV2_ENCODER) += asvenc.o asv.o mpeg12data.o
+OBJS-$(CONFIG_ATRAC1_DECODER) += atrac1.o atrac.o
+OBJS-$(CONFIG_ATRAC3_DECODER) += atrac3.o atrac.o
+OBJS-$(CONFIG_ATRAC3AL_DECODER) += atrac3.o atrac.o
+OBJS-$(CONFIG_ATRAC3P_DECODER) += atrac3plusdec.o atrac3plus.o \
+ atrac3plusdsp.o atrac.o
+OBJS-$(CONFIG_ATRAC3PAL_DECODER) += atrac3plusdec.o atrac3plus.o \
+ atrac3plusdsp.o atrac.o
+OBJS-$(CONFIG_ATRAC9_DECODER) += atrac9dec.o
+OBJS-$(CONFIG_AURA_DECODER) += cyuv.o
+OBJS-$(CONFIG_AURA2_DECODER) += aura.o
+OBJS-$(CONFIG_AV1_DECODER) += av1dec.o
+OBJS-$(CONFIG_AV1_CUVID_DECODER) += cuviddec.o
+OBJS-$(CONFIG_AVRN_DECODER) += avrndec.o
+OBJS-$(CONFIG_AVRP_DECODER) += r210dec.o
+OBJS-$(CONFIG_AVRP_ENCODER) += r210enc.o
+OBJS-$(CONFIG_AVS_DECODER) += avs.o
+OBJS-$(CONFIG_AVS_OMX_DECODER) += omxdec.o
+OBJS-$(CONFIG_AVUI_DECODER) += avuidec.o
+OBJS-$(CONFIG_AVUI_ENCODER) += avuienc.o
+OBJS-$(CONFIG_AYUV_DECODER) += v408dec.o
+OBJS-$(CONFIG_AYUV_ENCODER) += v408enc.o
+OBJS-$(CONFIG_BETHSOFTVID_DECODER) += bethsoftvideo.o
+OBJS-$(CONFIG_BFI_DECODER) += bfi.o
+OBJS-$(CONFIG_BINK_DECODER) += bink.o binkdsp.o
+OBJS-$(CONFIG_BINKAUDIO_DCT_DECODER) += binkaudio.o
+OBJS-$(CONFIG_BINKAUDIO_RDFT_DECODER) += binkaudio.o
+OBJS-$(CONFIG_BINTEXT_DECODER) += bintext.o cga_data.o
+OBJS-$(CONFIG_BITPACKED_DECODER) += bitpacked.o
+OBJS-$(CONFIG_BMP_DECODER) += bmp.o msrledec.o
+OBJS-$(CONFIG_BMP_ENCODER) += bmpenc.o
+OBJS-$(CONFIG_BMV_AUDIO_DECODER) += bmvaudio.o
+OBJS-$(CONFIG_BMV_VIDEO_DECODER) += bmvvideo.o
+OBJS-$(CONFIG_BRENDER_PIX_DECODER) += brenderpix.o
+OBJS-$(CONFIG_C93_DECODER) += c93.o
+OBJS-$(CONFIG_CAVS_DECODER) += cavs.o cavsdec.o cavsdsp.o \
+ cavsdata.o
+OBJS-$(CONFIG_CCAPTION_DECODER) += ccaption_dec.o ass.o
+OBJS-$(CONFIG_CDGRAPHICS_DECODER) += cdgraphics.o
+OBJS-$(CONFIG_CDTOONS_DECODER) += cdtoons.o
+OBJS-$(CONFIG_CDXL_DECODER) += cdxl.o
+OBJS-$(CONFIG_CFHD_DECODER) += cfhd.o cfhddata.o cfhddsp.o
+OBJS-$(CONFIG_CFHD_ENCODER) += cfhdenc.o cfhddata.o cfhdencdsp.o
+OBJS-$(CONFIG_CINEPAK_DECODER) += cinepak.o
+OBJS-$(CONFIG_CINEPAK_ENCODER) += cinepakenc.o elbg.o
+OBJS-$(CONFIG_CLEARVIDEO_DECODER) += clearvideo.o
+OBJS-$(CONFIG_CLJR_DECODER) += cljrdec.o
+OBJS-$(CONFIG_CLJR_ENCODER) += cljrenc.o
+OBJS-$(CONFIG_CLLC_DECODER) += cllc.o canopus.o
+OBJS-$(CONFIG_COMFORTNOISE_DECODER) += cngdec.o celp_filters.o
+OBJS-$(CONFIG_COMFORTNOISE_ENCODER) += cngenc.o
+OBJS-$(CONFIG_COOK_DECODER) += cook.o
+OBJS-$(CONFIG_CPIA_DECODER) += cpia.o
+OBJS-$(CONFIG_CRI_DECODER) += cri.o
+OBJS-$(CONFIG_CSCD_DECODER) += cscd.o
+OBJS-$(CONFIG_CYUV_DECODER) += cyuv.o
+OBJS-$(CONFIG_DCA_DECODER) += dcadec.o dca.o dcadata.o dcahuff.o \
+ dca_core.o dca_exss.o dca_xll.o dca_lbr.o \
+ dcadsp.o dcadct.o synth_filter.o
+OBJS-$(CONFIG_DCA_ENCODER) += dcaenc.o dcadata.o dcahuff.o \
+ dcaadpcm.o
+OBJS-$(CONFIG_DDS_DECODER) += dds.o
+OBJS-$(CONFIG_DERF_DPCM_DECODER) += dpcm.o
+OBJS-$(CONFIG_DIRAC_DECODER) += diracdec.o dirac.o diracdsp.o diractab.o \
+ dirac_arith.o dirac_dwt.o dirac_vlc.o
+OBJS-$(CONFIG_DFA_DECODER) += dfa.o
+OBJS-$(CONFIG_DNXHD_DECODER) += dnxhddec.o dnxhddata.o
+OBJS-$(CONFIG_DNXHD_ENCODER) += dnxhdenc.o dnxhddata.o
+OBJS-$(CONFIG_DOLBY_E_DECODER) += dolby_e.o dolby_e_parse.o kbdwin.o
+OBJS-$(CONFIG_DPX_DECODER) += dpx.o
+OBJS-$(CONFIG_DPX_ENCODER) += dpxenc.o
+OBJS-$(CONFIG_DSD_LSBF_DECODER) += dsddec.o dsd.o
+OBJS-$(CONFIG_DSD_MSBF_DECODER) += dsddec.o dsd.o
+OBJS-$(CONFIG_DSD_LSBF_PLANAR_DECODER) += dsddec.o dsd.o
+OBJS-$(CONFIG_DSD_MSBF_PLANAR_DECODER) += dsddec.o dsd.o
+OBJS-$(CONFIG_DSICINAUDIO_DECODER) += dsicinaudio.o
+OBJS-$(CONFIG_DSICINVIDEO_DECODER) += dsicinvideo.o
+OBJS-$(CONFIG_DSS_SP_DECODER) += dss_sp.o
+OBJS-$(CONFIG_DST_DECODER) += dstdec.o dsd.o
+OBJS-$(CONFIG_DVBSUB_DECODER) += dvbsubdec.o
+OBJS-$(CONFIG_DVBSUB_ENCODER) += dvbsubenc.o
+OBJS-$(CONFIG_DVDSUB_DECODER) += dvdsubdec.o dvdsub.o
+OBJS-$(CONFIG_DVDSUB_ENCODER) += dvdsubenc.o dvdsub.o
+OBJS-$(CONFIG_DVAUDIO_DECODER) += dvaudiodec.o
+OBJS-$(CONFIG_DVVIDEO_DECODER) += dvdec.o dv.o dvdata.o
+OBJS-$(CONFIG_DVVIDEO_ENCODER) += dvenc.o dv.o dvdata.o
+OBJS-$(CONFIG_DXA_DECODER) += dxa.o
+OBJS-$(CONFIG_DXTORY_DECODER) += dxtory.o
+OBJS-$(CONFIG_DXV_DECODER) += dxv.o
+OBJS-$(CONFIG_EAC3_DECODER) += eac3_data.o
+OBJS-$(CONFIG_EAC3_ENCODER) += eac3enc.o eac3_data.o
+OBJS-$(CONFIG_EACMV_DECODER) += eacmv.o
+OBJS-$(CONFIG_EAMAD_DECODER) += eamad.o eaidct.o mpeg12.o \
+ mpeg12data.o
+OBJS-$(CONFIG_EATGQ_DECODER) += eatgq.o eaidct.o
+OBJS-$(CONFIG_EATGV_DECODER) += eatgv.o
+OBJS-$(CONFIG_EATQI_DECODER) += eatqi.o eaidct.o mpeg12.o mpeg12data.o mpegvideodata.o rl.o
+OBJS-$(CONFIG_EIGHTBPS_DECODER) += 8bps.o
+OBJS-$(CONFIG_EIGHTSVX_EXP_DECODER) += 8svx.o
+OBJS-$(CONFIG_EIGHTSVX_FIB_DECODER) += 8svx.o
+OBJS-$(CONFIG_ESCAPE124_DECODER) += escape124.o
+OBJS-$(CONFIG_ESCAPE130_DECODER) += escape130.o
+OBJS-$(CONFIG_EVRC_DECODER) += evrcdec.o acelp_vectors.o lsp.o
+OBJS-$(CONFIG_EXR_DECODER) += exr.o exrdsp.o
+OBJS-$(CONFIG_EXR_ENCODER) += exrenc.o
+OBJS-$(CONFIG_FASTAUDIO_DECODER) += fastaudio.o
+OBJS-$(CONFIG_FFV1_DECODER) += ffv1dec.o ffv1.o
+OBJS-$(CONFIG_FFV1_ENCODER) += ffv1enc.o ffv1.o
+OBJS-$(CONFIG_FFWAVESYNTH_DECODER) += ffwavesynth.o
+OBJS-$(CONFIG_FIC_DECODER) += fic.o
+OBJS-$(CONFIG_FITS_DECODER) += fitsdec.o fits.o
+OBJS-$(CONFIG_FITS_ENCODER) += fitsenc.o
+OBJS-$(CONFIG_FLAC_DECODER) += flacdec.o flacdata.o flac.o
+OBJS-$(CONFIG_FLAC_ENCODER) += flacenc.o flacdata.o flac.o
+OBJS-$(CONFIG_FLASHSV_DECODER) += flashsv.o
+OBJS-$(CONFIG_FLASHSV_ENCODER) += flashsvenc.o
+OBJS-$(CONFIG_FLASHSV2_ENCODER) += flashsv2enc.o
+OBJS-$(CONFIG_FLASHSV2_DECODER) += flashsv.o
+OBJS-$(CONFIG_FLIC_DECODER) += flicvideo.o
+OBJS-$(CONFIG_FLV_DECODER) += flvdec.o
+OBJS-$(CONFIG_FLV_ENCODER) += flvenc.o
+OBJS-$(CONFIG_FMVC_DECODER) += fmvc.o
+OBJS-$(CONFIG_FOURXM_DECODER) += 4xm.o
+OBJS-$(CONFIG_FRAPS_DECODER) += fraps.o
+OBJS-$(CONFIG_FRWU_DECODER) += frwu.o
+OBJS-$(CONFIG_G2M_DECODER) += g2meet.o elsdec.o mjpegdec_common.o
+OBJS-$(CONFIG_G723_1_DECODER) += g723_1dec.o g723_1.o \
+ acelp_vectors.o celp_filters.o celp_math.o
+OBJS-$(CONFIG_G723_1_ENCODER) += g723_1enc.o g723_1.o \
+ acelp_vectors.o celp_filters.o celp_math.o
+OBJS-$(CONFIG_G729_DECODER) += g729dec.o lsp.o celp_math.o celp_filters.o acelp_filters.o acelp_pitch_delay.o acelp_vectors.o g729postfilter.o
+OBJS-$(CONFIG_GDV_DECODER) += gdv.o
+OBJS-$(CONFIG_GIF_DECODER) += gifdec.o lzw.o
+OBJS-$(CONFIG_GIF_ENCODER) += gif.o lzwenc.o
+OBJS-$(CONFIG_GREMLIN_DPCM_DECODER) += dpcm.o
+OBJS-$(CONFIG_GSM_DECODER) += gsmdec.o gsmdec_data.o msgsmdec.o
+OBJS-$(CONFIG_GSM_MS_DECODER) += gsmdec.o gsmdec_data.o msgsmdec.o
+OBJS-$(CONFIG_H261_DECODER) += h261dec.o h261data.o h261.o
+OBJS-$(CONFIG_H261_ENCODER) += h261enc.o h261data.o h261.o
+OBJS-$(CONFIG_H263_DECODER) += h263dec.o h263.o ituh263dec.o \
+ mpeg4video.o mpeg4videodec.o \
+ h263data.o
+OBJS-$(CONFIG_H263I_DECODER) += intelh263dec.o
+OBJS-$(CONFIG_H263_ENCODER) += mpeg4video.o \
+ h263.o ituh263enc.o h263data.o
+OBJS-$(CONFIG_H263_OMX_DECODER) += omxdec.o
+OBJS-$(CONFIG_H263_V4L2M2M_DECODER) += v4l2_m2m_dec.o
+OBJS-$(CONFIG_H263_V4L2M2M_ENCODER) += v4l2_m2m_enc.o
+OBJS-$(CONFIG_H264_DECODER) += h264dec.o h264_cabac.o h264_cavlc.o \
+ h264_direct.o h264_loopfilter.o \
+ h264_mb.o h264_picture.o \
+ h264_refs.o h264_sei.o \
+ h264_slice.o h264data.o
+OBJS-$(CONFIG_H264_AMF_ENCODER) += amfenc_h264.o
+OBJS-$(CONFIG_H264_CUVID_DECODER) += cuviddec.o
+OBJS-$(CONFIG_H264_MEDIACODEC_DECODER) += mediacodecdec.o
+OBJS-$(CONFIG_H264_MF_ENCODER) += mfenc.o mf_utils.o
+OBJS-$(CONFIG_H264_MMAL_DECODER) += mmaldec.o
+OBJS-$(CONFIG_H264_NVENC_ENCODER) += nvenc.o nvenc_h264.o
+OBJS-$(CONFIG_NVENC_ENCODER) += nvenc.o nvenc_h264.o
+OBJS-$(CONFIG_NVENC_H264_ENCODER) += nvenc.o nvenc_h264.o
+OBJS-$(CONFIG_H264_OMX_DECODER) += omxdec.o
+OBJS-$(CONFIG_H264_OMX_ENCODER) += omxenc.o
+OBJS-$(CONFIG_H264_QSV_DECODER) += qsvdec.o
+OBJS-$(CONFIG_H264_QSV_ENCODER) += qsvenc_h264.o
+OBJS-$(CONFIG_H264_RKMPP_DECODER) += rkmppdec.o
+OBJS-$(CONFIG_H264_VAAPI_ENCODER) += vaapi_encode_h264.o h264_levels.o
+OBJS-$(CONFIG_H264_VIDEOTOOLBOX_ENCODER) += videotoolboxenc.o
+OBJS-$(CONFIG_H264_V4L2M2M_DECODER) += v4l2_m2m_dec.o
+OBJS-$(CONFIG_H264_V4L2M2M_ENCODER) += v4l2_m2m_enc.o
+OBJS-$(CONFIG_HAP_DECODER) += hapdec.o hap.o
+OBJS-$(CONFIG_HAP_ENCODER) += hapenc.o hap.o
+OBJS-$(CONFIG_HCA_DECODER) += hcadec.o
+OBJS-$(CONFIG_HCOM_DECODER) += hcom.o
+OBJS-$(CONFIG_HEVC_DECODER) += hevcdec.o hevc_mvs.o \
+ hevc_cabac.o hevc_refs.o hevcpred.o \
+ hevcdsp.o hevc_filter.o hevc_data.o
+OBJS-$(CONFIG_HEVC_AMF_ENCODER) += amfenc_hevc.o
+OBJS-$(CONFIG_HEVC_CUVID_DECODER) += cuviddec.o
+OBJS-$(CONFIG_HEVC_MEDIACODEC_DECODER) += mediacodecdec.o
+OBJS-$(CONFIG_HEVC_MF_ENCODER) += mfenc.o mf_utils.o
+OBJS-$(CONFIG_HEVC_NVENC_ENCODER) += nvenc.o nvenc_hevc.o
+OBJS-$(CONFIG_NVENC_HEVC_ENCODER) += nvenc.o nvenc_hevc.o
+OBJS-$(CONFIG_HEVC_OMX_DECODER) += omxdec.o
+OBJS-$(CONFIG_HEVC_QSV_DECODER) += qsvdec.o
+OBJS-$(CONFIG_HEVC_QSV_ENCODER) += qsvenc_hevc.o hevc_ps_enc.o \
+ hevc_data.o
+OBJS-$(CONFIG_HEVC_RKMPP_DECODER) += rkmppdec.o
+OBJS-$(CONFIG_HEVC_VAAPI_ENCODER) += vaapi_encode_h265.o h265_profile_level.o
+OBJS-$(CONFIG_HEVC_V4L2M2M_DECODER) += v4l2_m2m_dec.o
+OBJS-$(CONFIG_HEVC_V4L2M2M_ENCODER) += v4l2_m2m_enc.o
+OBJS-$(CONFIG_HNM4_VIDEO_DECODER) += hnm4video.o
+OBJS-$(CONFIG_HQ_HQA_DECODER) += hq_hqa.o hq_hqadata.o hq_hqadsp.o \
+ canopus.o
+OBJS-$(CONFIG_HQX_DECODER) += hqx.o hqxvlc.o hqxdsp.o canopus.o
+OBJS-$(CONFIG_HUFFYUV_DECODER) += huffyuv.o huffyuvdec.o
+OBJS-$(CONFIG_HUFFYUV_ENCODER) += huffyuv.o huffyuvenc.o
+OBJS-$(CONFIG_HYMT_DECODER) += huffyuv.o huffyuvdec.o
+OBJS-$(CONFIG_IDCIN_DECODER) += idcinvideo.o
+OBJS-$(CONFIG_IDF_DECODER) += bintext.o cga_data.o
+OBJS-$(CONFIG_IFF_ILBM_DECODER) += iff.o
+OBJS-$(CONFIG_ILBC_DECODER) += ilbcdec.o
+OBJS-$(CONFIG_IMC_DECODER) += imc.o
+OBJS-$(CONFIG_IMM4_DECODER) += imm4.o
+OBJS-$(CONFIG_IMM5_DECODER) += imm5.o
+OBJS-$(CONFIG_INDEO2_DECODER) += indeo2.o
+OBJS-$(CONFIG_INDEO3_DECODER) += indeo3.o
+OBJS-$(CONFIG_INDEO4_DECODER) += indeo4.o ivi.o
+OBJS-$(CONFIG_INDEO5_DECODER) += indeo5.o ivi.o
+OBJS-$(CONFIG_INTERPLAY_ACM_DECODER) += interplayacm.o
+OBJS-$(CONFIG_INTERPLAY_DPCM_DECODER) += dpcm.o
+OBJS-$(CONFIG_INTERPLAY_VIDEO_DECODER) += interplayvideo.o
+OBJS-$(CONFIG_IPU_DECODER) += mpeg12dec.o mpeg12.o mpeg12data.o
+OBJS-$(CONFIG_JACOSUB_DECODER) += jacosubdec.o ass.o
+OBJS-$(CONFIG_JPEG2000_ENCODER) += j2kenc.o mqcenc.o mqc.o jpeg2000.o \
+ jpeg2000dwt.o
+OBJS-$(CONFIG_JPEG2000_DECODER) += jpeg2000dec.o jpeg2000.o jpeg2000dsp.o \
+ jpeg2000dwt.o mqcdec.o mqc.o
+OBJS-$(CONFIG_JPEGLS_DECODER) += jpeglsdec.o jpegls.o
+OBJS-$(CONFIG_JPEGLS_ENCODER) += jpeglsenc.o jpegls.o
+OBJS-$(CONFIG_JV_DECODER) += jvdec.o
+OBJS-$(CONFIG_KGV1_DECODER) += kgv1dec.o
+OBJS-$(CONFIG_KMVC_DECODER) += kmvc.o
+OBJS-$(CONFIG_LAGARITH_DECODER) += lagarith.o lagarithrac.o
+OBJS-$(CONFIG_LJPEG_ENCODER) += ljpegenc.o mjpegenc_common.o
+OBJS-$(CONFIG_LOCO_DECODER) += loco.o
+OBJS-$(CONFIG_LSCR_DECODER) += lscrdec.o png.o pngdec.o pngdsp.o
+OBJS-$(CONFIG_M101_DECODER) += m101.o
+OBJS-$(CONFIG_MACE3_DECODER) += mace.o
+OBJS-$(CONFIG_MACE6_DECODER) += mace.o
+OBJS-$(CONFIG_MAGICYUV_DECODER) += magicyuv.o
+OBJS-$(CONFIG_MAGICYUV_ENCODER) += magicyuvenc.o
+OBJS-$(CONFIG_MDEC_DECODER) += mdec.o mpeg12.o mpeg12data.o
+OBJS-$(CONFIG_METASOUND_DECODER) += metasound.o metasound_data.o \
+ twinvq.o
+OBJS-$(CONFIG_MICRODVD_DECODER) += microdvddec.o ass.o
+OBJS-$(CONFIG_MIMIC_DECODER) += mimic.o
+OBJS-$(CONFIG_MJPEG_DECODER) += mjpegdec.o mjpegdec_common.o
+OBJS-$(CONFIG_MJPEG_QSV_DECODER) += qsvdec.o
+OBJS-$(CONFIG_MJPEG_ENCODER) += mjpegenc.o mjpegenc_common.o \
+ mjpegenc_huffman.o
+OBJS-$(CONFIG_MJPEGB_DECODER) += mjpegbdec.o
+OBJS-$(CONFIG_MJPEG_CUVID_DECODER) += cuviddec.o
+OBJS-$(CONFIG_MJPEG_OMX_DECODER) += omxdec.o
+OBJS-$(CONFIG_MJPEG_QSV_ENCODER) += qsvenc_jpeg.o
+OBJS-$(CONFIG_MJPEG_VAAPI_ENCODER) += vaapi_encode_mjpeg.o
+OBJS-$(CONFIG_MLP_DECODER) += mlpdec.o mlpdsp.o
+OBJS-$(CONFIG_MLP_ENCODER) += mlpenc.o mlp.o
+OBJS-$(CONFIG_MMVIDEO_DECODER) += mmvideo.o
+OBJS-$(CONFIG_MOBICLIP_DECODER) += mobiclip.o
+OBJS-$(CONFIG_MOTIONPIXELS_DECODER) += motionpixels.o
+OBJS-$(CONFIG_MOVTEXT_DECODER) += movtextdec.o ass.o
+OBJS-$(CONFIG_MOVTEXT_ENCODER) += movtextenc.o ass_split.o
+OBJS-$(CONFIG_MP1_DECODER) += mpegaudiodec_fixed.o
+OBJS-$(CONFIG_MP1FLOAT_DECODER) += mpegaudiodec_float.o
+OBJS-$(CONFIG_MP2_DECODER) += mpegaudiodec_fixed.o
+OBJS-$(CONFIG_MP2_ENCODER) += mpegaudioenc_float.o mpegaudio.o \
+ mpegaudiodata.o mpegaudiodsp_data.o
+OBJS-$(CONFIG_MP2FIXED_ENCODER) += mpegaudioenc_fixed.o mpegaudio.o \
+ mpegaudiodata.o mpegaudiodsp_data.o
+OBJS-$(CONFIG_MP2FLOAT_DECODER) += mpegaudiodec_float.o
+OBJS-$(CONFIG_MP3_DECODER) += mpegaudiodec_fixed.o
+OBJS-$(CONFIG_MP3_MF_ENCODER) += mfenc.o mf_utils.o
+OBJS-$(CONFIG_MP3ADU_DECODER) += mpegaudiodec_fixed.o
+OBJS-$(CONFIG_MP3ADUFLOAT_DECODER) += mpegaudiodec_float.o
+OBJS-$(CONFIG_MP3FLOAT_DECODER) += mpegaudiodec_float.o
+OBJS-$(CONFIG_MP3ON4_DECODER) += mpegaudiodec_fixed.o mpeg4audio.o
+OBJS-$(CONFIG_MP3ON4FLOAT_DECODER) += mpegaudiodec_float.o mpeg4audio.o
+OBJS-$(CONFIG_MPC7_DECODER) += mpc7.o mpc.o
+OBJS-$(CONFIG_MPC8_DECODER) += mpc8.o mpc.o
+OBJS-$(CONFIG_MPEGVIDEO_DECODER) += mpeg12dec.o mpeg12.o mpeg12data.o
+OBJS-$(CONFIG_MPEG1VIDEO_DECODER) += mpeg12dec.o mpeg12.o mpeg12data.o
+OBJS-$(CONFIG_MPEG1VIDEO_ENCODER) += mpeg12enc.o mpeg12.o
+OBJS-$(CONFIG_MPEG1_CUVID_DECODER) += cuviddec.o
+OBJS-$(CONFIG_MPEG1_V4L2M2M_DECODER) += v4l2_m2m_dec.o
+OBJS-$(CONFIG_MPEG2_MMAL_DECODER) += mmaldec.o
+OBJS-$(CONFIG_MPEG2_QSV_DECODER) += qsvdec.o
+OBJS-$(CONFIG_MPEG2_QSV_ENCODER) += qsvenc_mpeg2.o
+OBJS-$(CONFIG_MPEG2VIDEO_DECODER) += mpeg12dec.o mpeg12.o mpeg12data.o
+OBJS-$(CONFIG_MPEG2VIDEO_ENCODER) += mpeg12enc.o mpeg12.o
+OBJS-$(CONFIG_MPEG2_CUVID_DECODER) += cuviddec.o
+OBJS-$(CONFIG_MPEG2_MEDIACODEC_DECODER) += mediacodecdec.o
+OBJS-$(CONFIG_MPEG2_OMX_DECODER) += omxdec.o
+OBJS-$(CONFIG_MPEG2_VAAPI_ENCODER) += vaapi_encode_mpeg2.o
+OBJS-$(CONFIG_MPEG2_V4L2M2M_DECODER) += v4l2_m2m_dec.o
+OBJS-$(CONFIG_MPEG4_DECODER) += xvididct.o
+OBJS-$(CONFIG_MPEG4_ENCODER) += mpeg4videoenc.o
+OBJS-$(CONFIG_MPEG4_CUVID_DECODER) += cuviddec.o
+OBJS-$(CONFIG_MPEG4_MEDIACODEC_DECODER) += mediacodecdec.o
+OBJS-$(CONFIG_MPEG4_OMX_DECODER) += omxdec.o
+OBJS-$(CONFIG_MPEG4_OMX_ENCODER) += omxenc.o
+OBJS-$(CONFIG_MPEG4_V4L2M2M_DECODER) += v4l2_m2m_dec.o
+OBJS-$(CONFIG_MPEG4_V4L2M2M_ENCODER) += v4l2_m2m_enc.o
+OBJS-$(CONFIG_MPL2_DECODER) += mpl2dec.o ass.o
+OBJS-$(CONFIG_MSA1_DECODER) += mss3.o
+OBJS-$(CONFIG_MSCC_DECODER) += mscc.o
+OBJS-$(CONFIG_MSMPEG4V1_DECODER) += msmpeg4dec.o msmpeg4.o msmpeg4data.o
+OBJS-$(CONFIG_MSMPEG4V2_DECODER) += msmpeg4dec.o msmpeg4.o msmpeg4data.o
+OBJS-$(CONFIG_MSMPEG4V2_ENCODER) += msmpeg4enc.o msmpeg4.o msmpeg4data.o
+OBJS-$(CONFIG_MSMPEG4V3_DECODER) += msmpeg4dec.o msmpeg4.o msmpeg4data.o
+OBJS-$(CONFIG_MSMPEG4V3_ENCODER) += msmpeg4enc.o msmpeg4.o msmpeg4data.o
+OBJS-$(CONFIG_MSP2_DECODER) += msp2dec.o
+OBJS-$(CONFIG_MSRLE_DECODER) += msrle.o msrledec.o
+OBJS-$(CONFIG_MSS1_DECODER) += mss1.o mss12.o
+OBJS-$(CONFIG_MSS2_DECODER) += mss2.o mss12.o mss2dsp.o wmv2data.o
+OBJS-$(CONFIG_MSVIDEO1_DECODER) += msvideo1.o
+OBJS-$(CONFIG_MSVIDEO1_ENCODER) += msvideo1enc.o elbg.o
+OBJS-$(CONFIG_MSZH_DECODER) += lcldec.o
+OBJS-$(CONFIG_MTS2_DECODER) += mss4.o
+OBJS-$(CONFIG_MV30_DECODER) += mv30.o
+OBJS-$(CONFIG_MVC1_DECODER) += mvcdec.o
+OBJS-$(CONFIG_MVC2_DECODER) += mvcdec.o
+OBJS-$(CONFIG_MVDV_DECODER) += midivid.o
+OBJS-$(CONFIG_MVHA_DECODER) += mvha.o
+OBJS-$(CONFIG_MWSC_DECODER) += mwsc.o
+OBJS-$(CONFIG_MXPEG_DECODER) += mxpegdec.o
+OBJS-$(CONFIG_NELLYMOSER_DECODER) += nellymoserdec.o nellymoser.o
+OBJS-$(CONFIG_NELLYMOSER_ENCODER) += nellymoserenc.o nellymoser.o
+OBJS-$(CONFIG_NOTCHLC_DECODER) += notchlc.o
+OBJS-$(CONFIG_NUV_DECODER) += nuv.o rtjpeg.o
+OBJS-$(CONFIG_ON2AVC_DECODER) += on2avc.o on2avcdata.o
+OBJS-$(CONFIG_OPUS_DECODER) += opusdec.o opus.o opus_celt.o opus_rc.o \
+ opus_pvq.o opus_silk.o opustab.o vorbis_data.o \
+ opusdsp.o
+OBJS-$(CONFIG_OPUS_ENCODER) += opusenc.o opus.o opus_rc.o opustab.o opus_pvq.o \
+ opusenc_psy.o vorbis_data.o
+OBJS-$(CONFIG_PAF_AUDIO_DECODER) += pafaudio.o
+OBJS-$(CONFIG_PAF_VIDEO_DECODER) += pafvideo.o
+OBJS-$(CONFIG_PAM_DECODER) += pnmdec.o pnm.o
+OBJS-$(CONFIG_PAM_ENCODER) += pamenc.o
+OBJS-$(CONFIG_PBM_DECODER) += pnmdec.o pnm.o
+OBJS-$(CONFIG_PBM_ENCODER) += pnmenc.o
+OBJS-$(CONFIG_PCX_DECODER) += pcx.o
+OBJS-$(CONFIG_PCX_ENCODER) += pcxenc.o
+OBJS-$(CONFIG_PFM_DECODER) += pnmdec.o pnm.o
+OBJS-$(CONFIG_PFM_ENCODER) += pnmenc.o
+OBJS-$(CONFIG_PGM_DECODER) += pnmdec.o pnm.o
+OBJS-$(CONFIG_PGM_ENCODER) += pnmenc.o
+OBJS-$(CONFIG_PGMYUV_DECODER) += pnmdec.o pnm.o
+OBJS-$(CONFIG_PGMYUV_ENCODER) += pnmenc.o
+OBJS-$(CONFIG_PGSSUB_DECODER) += pgssubdec.o
+OBJS-$(CONFIG_PGX_DECODER) += pgxdec.o
+OBJS-$(CONFIG_PHOTOCD_DECODER) += photocd.o
+OBJS-$(CONFIG_PICTOR_DECODER) += pictordec.o cga_data.o
+OBJS-$(CONFIG_PIXLET_DECODER) += pixlet.o
+OBJS-$(CONFIG_PJS_DECODER) += textdec.o ass.o
+OBJS-$(CONFIG_PNG_DECODER) += png.o pngdec.o pngdsp.o
+OBJS-$(CONFIG_PNG_ENCODER) += png.o pngenc.o
+OBJS-$(CONFIG_PPM_DECODER) += pnmdec.o pnm.o
+OBJS-$(CONFIG_PPM_ENCODER) += pnmenc.o
+OBJS-$(CONFIG_PRORES_DECODER) += proresdec2.o proresdsp.o proresdata.o
+OBJS-$(CONFIG_PRORES_ENCODER) += proresenc_anatoliy.o proresdata.o
+OBJS-$(CONFIG_PRORES_AW_ENCODER) += proresenc_anatoliy.o proresdata.o
+OBJS-$(CONFIG_PRORES_KS_ENCODER) += proresenc_kostya.o proresdata.o
+OBJS-$(CONFIG_PROSUMER_DECODER) += prosumer.o
+OBJS-$(CONFIG_PSD_DECODER) += psd.o
+OBJS-$(CONFIG_PTX_DECODER) += ptx.o
+OBJS-$(CONFIG_QCELP_DECODER) += qcelpdec.o \
+ celp_filters.o acelp_vectors.o \
+ acelp_filters.o
+OBJS-$(CONFIG_QDM2_DECODER) += qdm2.o
+OBJS-$(CONFIG_QDMC_DECODER) += qdmc.o
+OBJS-$(CONFIG_QDRAW_DECODER) += qdrw.o
+OBJS-$(CONFIG_QPEG_DECODER) += qpeg.o
+OBJS-$(CONFIG_QTRLE_DECODER) += qtrle.o
+OBJS-$(CONFIG_QTRLE_ENCODER) += qtrleenc.o
+OBJS-$(CONFIG_R10K_DECODER) += r210dec.o
+OBJS-$(CONFIG_R10K_ENCODER) += r210enc.o
+OBJS-$(CONFIG_R210_DECODER) += r210dec.o
+OBJS-$(CONFIG_R210_ENCODER) += r210enc.o
+OBJS-$(CONFIG_RA_144_DECODER) += ra144dec.o ra144.o celp_filters.o
+OBJS-$(CONFIG_RA_144_ENCODER) += ra144enc.o ra144.o celp_filters.o
+OBJS-$(CONFIG_RA_288_DECODER) += ra288.o celp_filters.o
+OBJS-$(CONFIG_RALF_DECODER) += ralf.o
+OBJS-$(CONFIG_RASC_DECODER) += rasc.o
+OBJS-$(CONFIG_RAWVIDEO_DECODER) += rawdec.o
+OBJS-$(CONFIG_RAWVIDEO_ENCODER) += rawenc.o
+OBJS-$(CONFIG_REALTEXT_DECODER) += realtextdec.o ass.o
+OBJS-$(CONFIG_RL2_DECODER) += rl2.o
+OBJS-$(CONFIG_ROQ_DECODER) += roqvideodec.o roqvideo.o
+OBJS-$(CONFIG_ROQ_ENCODER) += roqvideoenc.o roqvideo.o elbg.o
+OBJS-$(CONFIG_ROQ_DPCM_DECODER) += dpcm.o
+OBJS-$(CONFIG_ROQ_DPCM_ENCODER) += roqaudioenc.o
+OBJS-$(CONFIG_RPZA_DECODER) += rpza.o
+OBJS-$(CONFIG_RPZA_ENCODER) += rpzaenc.o
+OBJS-$(CONFIG_RSCC_DECODER) += rscc.o
+OBJS-$(CONFIG_RV10_DECODER) += rv10.o
+OBJS-$(CONFIG_RV10_ENCODER) += rv10enc.o
+OBJS-$(CONFIG_RV20_DECODER) += rv10.o
+OBJS-$(CONFIG_RV20_ENCODER) += rv20enc.o
+OBJS-$(CONFIG_RV30_DECODER) += rv30.o rv34.o rv30dsp.o
+OBJS-$(CONFIG_RV30_OMX_DECODER) += omxdec.o
+OBJS-$(CONFIG_RV40_DECODER) += rv40.o rv34.o rv40dsp.o
+OBJS-$(CONFIG_RV40_OMX_DECODER) += omxdec.o
+OBJS-$(CONFIG_SAMI_DECODER) += samidec.o ass.o htmlsubtitles.o
+OBJS-$(CONFIG_S302M_DECODER) += s302m.o
+OBJS-$(CONFIG_S302M_ENCODER) += s302menc.o
+OBJS-$(CONFIG_SANM_DECODER) += sanm.o
+OBJS-$(CONFIG_SCPR_DECODER) += scpr.o
+OBJS-$(CONFIG_SCREENPRESSO_DECODER) += screenpresso.o
+OBJS-$(CONFIG_SDX2_DPCM_DECODER) += dpcm.o
+OBJS-$(CONFIG_SGA_DECODER) += sga.o
+OBJS-$(CONFIG_SGI_DECODER) += sgidec.o
+OBJS-$(CONFIG_SGI_ENCODER) += sgienc.o rle.o
+OBJS-$(CONFIG_SGIRLE_DECODER) += sgirledec.o
+OBJS-$(CONFIG_SHEERVIDEO_DECODER) += sheervideo.o
+OBJS-$(CONFIG_SHORTEN_DECODER) += shorten.o
+OBJS-$(CONFIG_SIPR_DECODER) += sipr.o acelp_pitch_delay.o \
+ celp_math.o acelp_vectors.o \
+ acelp_filters.o celp_filters.o \
+ sipr16k.o
+OBJS-$(CONFIG_SIREN_DECODER) += siren.o
+OBJS-$(CONFIG_SIMBIOSIS_IMX_DECODER) += imx.o
+OBJS-$(CONFIG_SMACKAUD_DECODER) += smacker.o
+OBJS-$(CONFIG_SMACKER_DECODER) += smacker.o
+OBJS-$(CONFIG_SMC_DECODER) += smc.o
+OBJS-$(CONFIG_SNOW_DECODER) += snowdec.o snow.o snow_dwt.o
+OBJS-$(CONFIG_SNOW_ENCODER) += snowenc.o snow.o snow_dwt.o \
+ h263.o h263data.o ituh263enc.o
+OBJS-$(CONFIG_SOL_DPCM_DECODER) += dpcm.o
+OBJS-$(CONFIG_SONIC_DECODER) += sonic.o
+OBJS-$(CONFIG_SONIC_ENCODER) += sonic.o
+OBJS-$(CONFIG_SONIC_LS_ENCODER) += sonic.o
+OBJS-$(CONFIG_SPEEDHQ_DECODER) += speedhq.o mpeg12.o mpeg12data.o simple_idct.o
+OBJS-$(CONFIG_SPEEDHQ_ENCODER) += speedhq.o mpeg12data.o mpeg12enc.o speedhqenc.o
+OBJS-$(CONFIG_SP5X_DECODER) += sp5xdec.o
+OBJS-$(CONFIG_SRGC_DECODER) += mscc.o
+OBJS-$(CONFIG_SRT_DECODER) += srtdec.o ass.o htmlsubtitles.o
+OBJS-$(CONFIG_SRT_ENCODER) += srtenc.o ass_split.o
+OBJS-$(CONFIG_STL_DECODER) += textdec.o ass.o
+OBJS-$(CONFIG_SUBRIP_DECODER) += srtdec.o ass.o htmlsubtitles.o
+OBJS-$(CONFIG_SUBRIP_ENCODER) += srtenc.o ass_split.o
+OBJS-$(CONFIG_SUBVIEWER1_DECODER) += textdec.o ass.o
+OBJS-$(CONFIG_SUBVIEWER_DECODER) += subviewerdec.o ass.o
+OBJS-$(CONFIG_SUNRAST_DECODER) += sunrast.o
+OBJS-$(CONFIG_SUNRAST_ENCODER) += sunrastenc.o
+OBJS-$(CONFIG_LIBRSVG_DECODER) += librsvgdec.o
+OBJS-$(CONFIG_SBC_DECODER) += sbcdec.o sbcdec_data.o sbc.o
+OBJS-$(CONFIG_SBC_ENCODER) += sbcenc.o sbc.o sbcdsp.o sbcdsp_data.o
+OBJS-$(CONFIG_SORENSON_OMX_DECODER) += omxdec.o
+OBJS-$(CONFIG_SVQ1_DECODER) += svq1dec.o svq1.o h263data.o
+OBJS-$(CONFIG_SVQ1_ENCODER) += svq1enc.o svq1.o h263data.o \
+ h263.o ituh263enc.o
+OBJS-$(CONFIG_SVQ3_DECODER) += svq3.o mpegutils.o h264data.o
+OBJS-$(CONFIG_TEXT_DECODER) += textdec.o ass.o
+OBJS-$(CONFIG_TEXT_ENCODER) += srtenc.o ass_split.o
+OBJS-$(CONFIG_TAK_DECODER) += takdec.o tak.o takdsp.o
+OBJS-$(CONFIG_TARGA_DECODER) += targa.o
+OBJS-$(CONFIG_TARGA_ENCODER) += targaenc.o rle.o
+OBJS-$(CONFIG_TARGA_Y216_DECODER) += targa_y216dec.o
+OBJS-$(CONFIG_TDSC_DECODER) += tdsc.o
+OBJS-$(CONFIG_TIERTEXSEQVIDEO_DECODER) += tiertexseqv.o
+OBJS-$(CONFIG_TIFF_DECODER) += tiff.o lzw.o faxcompr.o tiff_common.o
+OBJS-$(CONFIG_TIFF_ENCODER) += tiffenc.o rle.o lzwenc.o
+OBJS-$(CONFIG_TMV_DECODER) += tmv.o cga_data.o
+OBJS-$(CONFIG_TRUEHD_DECODER) += mlpdec.o mlpdsp.o
+OBJS-$(CONFIG_TRUEHD_ENCODER) += mlpenc.o mlp.o
+OBJS-$(CONFIG_TRUEMOTION1_DECODER) += truemotion1.o
+OBJS-$(CONFIG_TRUEMOTION2_DECODER) += truemotion2.o
+OBJS-$(CONFIG_TRUEMOTION2RT_DECODER) += truemotion2rt.o
+OBJS-$(CONFIG_TRUESPEECH_DECODER) += truespeech.o
+OBJS-$(CONFIG_TSCC_DECODER) += tscc.o msrledec.o
+OBJS-$(CONFIG_TSCC2_DECODER) += tscc2.o
+OBJS-$(CONFIG_TTA_DECODER) += tta.o ttadata.o ttadsp.o
+OBJS-$(CONFIG_TTA_ENCODER) += ttaenc.o ttaencdsp.o ttadata.o
+OBJS-$(CONFIG_TTML_ENCODER) += ttmlenc.o ass_split.o
+OBJS-$(CONFIG_TWINVQ_DECODER) += twinvqdec.o twinvq.o metasound_data.o
+OBJS-$(CONFIG_TXD_DECODER) += txd.o
+OBJS-$(CONFIG_ULTI_DECODER) += ulti.o
+OBJS-$(CONFIG_UTVIDEO_DECODER) += utvideodec.o utvideodsp.o
+OBJS-$(CONFIG_UTVIDEO_ENCODER) += utvideoenc.o
+OBJS-$(CONFIG_V210_DECODER) += v210dec.o
+OBJS-$(CONFIG_V210_ENCODER) += v210enc.o
+OBJS-$(CONFIG_V210X_DECODER) += v210x.o
+OBJS-$(CONFIG_V308_DECODER) += v308dec.o
+OBJS-$(CONFIG_V308_ENCODER) += v308enc.o
+OBJS-$(CONFIG_V408_DECODER) += v408dec.o
+OBJS-$(CONFIG_V408_ENCODER) += v408enc.o
+OBJS-$(CONFIG_V410_DECODER) += v410dec.o
+OBJS-$(CONFIG_V410_ENCODER) += v410enc.o
+OBJS-$(CONFIG_VB_DECODER) += vb.o
+OBJS-$(CONFIG_VBLE_DECODER) += vble.o
+OBJS-$(CONFIG_VC1_DECODER) += vc1dec.o vc1_block.o vc1_loopfilter.o \
+ vc1_mc.o vc1_pred.o vc1.o vc1data.o \
+ msmpeg4dec.o msmpeg4.o msmpeg4data.o \
+ wmv2dsp.o wmv2data.o
+OBJS-$(CONFIG_VC1_CUVID_DECODER) += cuviddec.o
+OBJS-$(CONFIG_VC1_MMAL_DECODER) += mmaldec.o
+OBJS-$(CONFIG_VC1_OMX_DECODER) += omxdec.o
+OBJS-$(CONFIG_VC1_QSV_DECODER) += qsvdec.o
+OBJS-$(CONFIG_VC1_V4L2M2M_DECODER) += v4l2_m2m_dec.o
+OBJS-$(CONFIG_VC2_ENCODER) += vc2enc.o vc2enc_dwt.o diractab.o
+OBJS-$(CONFIG_VCR1_DECODER) += vcr1.o
+OBJS-$(CONFIG_VMDAUDIO_DECODER) += vmdaudio.o
+OBJS-$(CONFIG_VMDVIDEO_DECODER) += vmdvideo.o
+OBJS-$(CONFIG_VMNC_DECODER) += vmnc.o
+OBJS-$(CONFIG_VORBIS_DECODER) += vorbisdec.o vorbisdsp.o vorbis.o \
+ vorbis_data.o
+OBJS-$(CONFIG_VORBIS_ENCODER) += vorbisenc.o vorbis.o \
+ vorbis_data.o
+OBJS-$(CONFIG_VP3_DECODER) += vp3.o
+OBJS-$(CONFIG_VP5_DECODER) += vp5.o vp56.o vp56data.o vp56rac.o
+OBJS-$(CONFIG_VP6_DECODER) += vp6.o vp56.o vp56data.o \
+ vp6dsp.o vp56rac.o
+OBJS-$(CONFIG_VP6_OMX_DECODER) += omxdec.o
+OBJS-$(CONFIG_VP7_DECODER) += vp8.o vp56rac.o
+OBJS-$(CONFIG_VP8_DECODER) += vp8.o vp56rac.o
+OBJS-$(CONFIG_VP8_CUVID_DECODER) += cuviddec.o
+OBJS-$(CONFIG_VP8_MEDIACODEC_DECODER) += mediacodecdec.o
+OBJS-$(CONFIG_VP8_OMX_DECODER) += omxdec.o
+OBJS-$(CONFIG_VP8_QSV_DECODER) += qsvdec.o
+OBJS-$(CONFIG_VP8_RKMPP_DECODER) += rkmppdec.o
+OBJS-$(CONFIG_VP8_VAAPI_ENCODER) += vaapi_encode_vp8.o
+OBJS-$(CONFIG_VP8_V4L2M2M_DECODER) += v4l2_m2m_dec.o
+OBJS-$(CONFIG_VP8_V4L2M2M_ENCODER) += v4l2_m2m_enc.o
+OBJS-$(CONFIG_VP9_DECODER) += vp9.o vp9data.o vp9dsp.o vp9lpf.o vp9recon.o \
+ vp9block.o vp9prob.o vp9mvs.o vp56rac.o \
+ vp9dsp_8bpp.o vp9dsp_10bpp.o vp9dsp_12bpp.o
+OBJS-$(CONFIG_VP9_CUVID_DECODER) += cuviddec.o
+OBJS-$(CONFIG_VP9_MEDIACODEC_DECODER) += mediacodecdec.o
+OBJS-$(CONFIG_VP9_RKMPP_DECODER) += rkmppdec.o
+OBJS-$(CONFIG_VP9_VAAPI_ENCODER) += vaapi_encode_vp9.o
+OBJS-$(CONFIG_VP9_QSV_ENCODER) += qsvenc_vp9.o
+OBJS-$(CONFIG_VPLAYER_DECODER) += textdec.o ass.o
+OBJS-$(CONFIG_VP9_V4L2M2M_DECODER) += v4l2_m2m_dec.o
+OBJS-$(CONFIG_VQA_DECODER) += vqavideo.o
+OBJS-$(CONFIG_WAVPACK_DECODER) += wavpack.o wavpackdata.o dsd.o
+OBJS-$(CONFIG_WAVPACK_ENCODER) += wavpackdata.o wavpackenc.o
+OBJS-$(CONFIG_WCMV_DECODER) += wcmv.o
+OBJS-$(CONFIG_WEBP_DECODER) += webp.o
+OBJS-$(CONFIG_WEBVTT_DECODER) += webvttdec.o ass.o
+OBJS-$(CONFIG_WEBVTT_ENCODER) += webvttenc.o ass_split.o
+OBJS-$(CONFIG_WMALOSSLESS_DECODER) += wmalosslessdec.o wma_common.o
+OBJS-$(CONFIG_WMAPRO_DECODER) += wmaprodec.o wma.o wma_common.o
+OBJS-$(CONFIG_WMAV1_DECODER) += wmadec.o wma.o wma_common.o aactab.o
+OBJS-$(CONFIG_WMAV1_ENCODER) += wmaenc.o wma.o wma_common.o aactab.o
+OBJS-$(CONFIG_WMAV2_DECODER) += wmadec.o wma.o wma_common.o aactab.o
+OBJS-$(CONFIG_WMAV2_ENCODER) += wmaenc.o wma.o wma_common.o aactab.o
+OBJS-$(CONFIG_WMAVOICE_DECODER) += wmavoice.o \
+ celp_filters.o \
+ acelp_vectors.o acelp_filters.o
+OBJS-$(CONFIG_WMV1_DECODER) += msmpeg4dec.o msmpeg4.o msmpeg4data.o
+OBJS-$(CONFIG_WMV1_ENCODER) += msmpeg4enc.o msmpeg4.o msmpeg4data.o
+OBJS-$(CONFIG_WMV2_DECODER) += wmv2dec.o wmv2.o wmv2data.o \
+ msmpeg4dec.o msmpeg4.o msmpeg4data.o
+OBJS-$(CONFIG_WMV2_ENCODER) += wmv2enc.o wmv2.o wmv2data.o \
+ msmpeg4.o msmpeg4enc.o msmpeg4data.o
+OBJS-$(CONFIG_WMV3_OMX_DECODER) += omxdec.o
+OBJS-$(CONFIG_WNV1_DECODER) += wnv1.o
+OBJS-$(CONFIG_WRAPPED_AVFRAME_DECODER) += wrapped_avframe.o
+OBJS-$(CONFIG_WRAPPED_AVFRAME_ENCODER) += wrapped_avframe.o
+OBJS-$(CONFIG_WS_SND1_DECODER) += ws-snd1.o
+OBJS-$(CONFIG_XAN_DPCM_DECODER) += dpcm.o
+OBJS-$(CONFIG_XAN_WC3_DECODER) += xan.o
+OBJS-$(CONFIG_XAN_WC4_DECODER) += xxan.o
+OBJS-$(CONFIG_XBIN_DECODER) += bintext.o cga_data.o
+OBJS-$(CONFIG_XBM_DECODER) += xbmdec.o
+OBJS-$(CONFIG_XBM_ENCODER) += xbmenc.o
+OBJS-$(CONFIG_XFACE_DECODER) += xfacedec.o xface.o
+OBJS-$(CONFIG_XFACE_ENCODER) += xfaceenc.o xface.o
+OBJS-$(CONFIG_XL_DECODER) += xl.o
+OBJS-$(CONFIG_XMA1_DECODER) += wmaprodec.o wma.o wma_common.o
+OBJS-$(CONFIG_XMA2_DECODER) += wmaprodec.o wma.o wma_common.o
+OBJS-$(CONFIG_XPM_DECODER) += xpmdec.o
+OBJS-$(CONFIG_XSUB_DECODER) += xsubdec.o
+OBJS-$(CONFIG_XSUB_ENCODER) += xsubenc.o
+OBJS-$(CONFIG_XWD_DECODER) += xwddec.o
+OBJS-$(CONFIG_XWD_ENCODER) += xwdenc.o
+OBJS-$(CONFIG_Y41P_DECODER) += y41pdec.o
+OBJS-$(CONFIG_Y41P_ENCODER) += y41penc.o
+OBJS-$(CONFIG_YLC_DECODER) += ylc.o
+OBJS-$(CONFIG_YOP_DECODER) += yop.o
+OBJS-$(CONFIG_YUV4_DECODER) += yuv4dec.o
+OBJS-$(CONFIG_YUV4_ENCODER) += yuv4enc.o
+OBJS-$(CONFIG_ZEROCODEC_DECODER) += zerocodec.o
+OBJS-$(CONFIG_ZLIB_DECODER) += lcldec.o
+OBJS-$(CONFIG_ZLIB_ENCODER) += lclenc.o
+OBJS-$(CONFIG_ZMBV_DECODER) += zmbv.o
+OBJS-$(CONFIG_ZMBV_ENCODER) += zmbvenc.o
+
+# (AD)PCM decoders/encoders
+OBJS-$(CONFIG_PCM_ALAW_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_ALAW_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_BLURAY_DECODER) += pcm-bluray.o
+OBJS-$(CONFIG_PCM_DVD_DECODER) += pcm-dvd.o
+OBJS-$(CONFIG_PCM_DVD_ENCODER) += pcm-dvdenc.o
+OBJS-$(CONFIG_PCM_F16LE_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_F24LE_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_F32BE_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_F32BE_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_F32LE_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_F32LE_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_F64BE_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_F64BE_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_F64LE_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_F64LE_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_LXF_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_MULAW_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_MULAW_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_S8_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_S8_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_S8_PLANAR_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_S8_PLANAR_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_S16BE_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_S16BE_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_S16BE_PLANAR_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_S16BE_PLANAR_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_S16LE_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_S16LE_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_S16LE_PLANAR_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_S16LE_PLANAR_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_S24BE_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_S24BE_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_S24DAUD_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_S24DAUD_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_S24LE_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_S24LE_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_S24LE_PLANAR_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_S24LE_PLANAR_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_S32BE_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_S32BE_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_S32LE_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_S32LE_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_S32LE_PLANAR_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_S32LE_PLANAR_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_S64BE_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_S64BE_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_S64LE_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_S64LE_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_SGA_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_U8_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_U8_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_U16BE_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_U16BE_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_U16LE_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_U16LE_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_U24BE_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_U24BE_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_U24LE_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_U24LE_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_U32BE_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_U32BE_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_U32LE_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_U32LE_ENCODER) += pcm.o
+OBJS-$(CONFIG_PCM_VIDC_DECODER) += pcm.o
+OBJS-$(CONFIG_PCM_VIDC_ENCODER) += pcm.o
+
+OBJS-$(CONFIG_ADPCM_4XM_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_ADX_DECODER) += adxdec.o adx.o
+OBJS-$(CONFIG_ADPCM_ADX_ENCODER) += adxenc.o adx.o
+OBJS-$(CONFIG_ADPCM_AFC_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_AGM_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_AICA_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_ARGO_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_ARGO_ENCODER) += adpcm.o adpcmenc.o
+OBJS-$(CONFIG_ADPCM_CT_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_DTK_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_EA_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_EA_MAXIS_XA_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_EA_R1_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_EA_R2_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_EA_R3_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_EA_XAS_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_G722_DECODER) += g722.o g722dsp.o g722dec.o
+OBJS-$(CONFIG_ADPCM_G722_ENCODER) += g722.o g722dsp.o g722enc.o
+OBJS-$(CONFIG_ADPCM_G726_DECODER) += g726.o
+OBJS-$(CONFIG_ADPCM_G726_ENCODER) += g726.o
+OBJS-$(CONFIG_ADPCM_G726LE_DECODER) += g726.o
+OBJS-$(CONFIG_ADPCM_G726LE_ENCODER) += g726.o
+OBJS-$(CONFIG_ADPCM_IMA_AMV_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_AMV_ENCODER) += adpcmenc.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_ALP_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_ALP_ENCODER) += adpcmenc.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_APC_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_APM_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_APM_ENCODER) += adpcmenc.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_CUNNING_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_DAT4_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_DK3_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_DK4_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_EA_EACS_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_EA_SEAD_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_ISS_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_MOFLEX_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_MTF_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_OKI_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_QT_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_QT_ENCODER) += adpcmenc.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_RAD_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_SSI_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_SSI_ENCODER) += adpcmenc.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_SMJPEG_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_WAV_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_WAV_ENCODER) += adpcmenc.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_IMA_WS_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_MS_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_MS_ENCODER) += adpcmenc.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_MTAF_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_PSX_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_SBPRO_2_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_SBPRO_3_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_SBPRO_4_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_SWF_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_SWF_ENCODER) += adpcmenc.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_THP_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_THP_LE_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_VIMA_DECODER) += vima.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_XA_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_YAMAHA_DECODER) += adpcm.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_YAMAHA_ENCODER) += adpcmenc.o adpcm_data.o
+OBJS-$(CONFIG_ADPCM_ZORK_DECODER) += adpcm.o adpcm_data.o
+
+# hardware accelerators
+OBJS-$(CONFIG_D3D11VA) += dxva2.o
+OBJS-$(CONFIG_DXVA2) += dxva2.o
+OBJS-$(CONFIG_NVDEC) += nvdec.o
+OBJS-$(CONFIG_VAAPI) += vaapi_decode.o
+OBJS-$(CONFIG_VIDEOTOOLBOX) += videotoolbox.o
+OBJS-$(CONFIG_VDPAU) += vdpau.o
+
+OBJS-$(CONFIG_AV1_D3D11VA_HWACCEL) += dxva2_av1.o
+OBJS-$(CONFIG_AV1_DXVA2_HWACCEL) += dxva2_av1.o
+OBJS-$(CONFIG_AV1_NVDEC_HWACCEL) += nvdec_av1.o
+OBJS-$(CONFIG_AV1_VAAPI_HWACCEL) += vaapi_av1.o
+OBJS-$(CONFIG_H263_VAAPI_HWACCEL) += vaapi_mpeg4.o
+OBJS-$(CONFIG_H263_VIDEOTOOLBOX_HWACCEL) += videotoolbox.o
+OBJS-$(CONFIG_H264_D3D11VA_HWACCEL) += dxva2_h264.o
+OBJS-$(CONFIG_H264_DXVA2_HWACCEL) += dxva2_h264.o
+OBJS-$(CONFIG_H264_NVDEC_HWACCEL) += nvdec_h264.o
+OBJS-$(CONFIG_H264_QSV_HWACCEL) += qsvdec.o
+OBJS-$(CONFIG_H264_VAAPI_HWACCEL) += vaapi_h264.o
+OBJS-$(CONFIG_H264_VDPAU_HWACCEL) += vdpau_h264.o
+OBJS-$(CONFIG_H264_VIDEOTOOLBOX_HWACCEL) += videotoolbox.o
+OBJS-$(CONFIG_HEVC_D3D11VA_HWACCEL) += dxva2_hevc.o
+OBJS-$(CONFIG_HEVC_DXVA2_HWACCEL) += dxva2_hevc.o
+OBJS-$(CONFIG_HEVC_NVDEC_HWACCEL) += nvdec_hevc.o
+OBJS-$(CONFIG_HEVC_QSV_HWACCEL) += qsvdec.o
+OBJS-$(CONFIG_HEVC_VAAPI_HWACCEL) += vaapi_hevc.o h265_profile_level.o
+OBJS-$(CONFIG_HEVC_VDPAU_HWACCEL) += vdpau_hevc.o h265_profile_level.o
+OBJS-$(CONFIG_MJPEG_NVDEC_HWACCEL) += nvdec_mjpeg.o
+OBJS-$(CONFIG_MJPEG_VAAPI_HWACCEL) += vaapi_mjpeg.o
+OBJS-$(CONFIG_MPEG1_NVDEC_HWACCEL) += nvdec_mpeg12.o
+OBJS-$(CONFIG_MPEG1_VDPAU_HWACCEL) += vdpau_mpeg12.o
+OBJS-$(CONFIG_MPEG1_VIDEOTOOLBOX_HWACCEL) += videotoolbox.o
+OBJS-$(CONFIG_MPEG1_XVMC_HWACCEL) += mpegvideo_xvmc.o
+OBJS-$(CONFIG_MPEG2_D3D11VA_HWACCEL) += dxva2_mpeg2.o
+OBJS-$(CONFIG_MPEG2_DXVA2_HWACCEL) += dxva2_mpeg2.o
+OBJS-$(CONFIG_MPEG2_NVDEC_HWACCEL) += nvdec_mpeg12.o
+OBJS-$(CONFIG_MPEG2_QSV_HWACCEL) += qsvdec.o
+OBJS-$(CONFIG_MPEG2_VAAPI_HWACCEL) += vaapi_mpeg2.o
+OBJS-$(CONFIG_MPEG2_VDPAU_HWACCEL) += vdpau_mpeg12.o
+OBJS-$(CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL) += videotoolbox.o
+OBJS-$(CONFIG_MPEG2_XVMC_HWACCEL) += mpegvideo_xvmc.o
+OBJS-$(CONFIG_MPEG4_NVDEC_HWACCEL) += nvdec_mpeg4.o
+OBJS-$(CONFIG_MPEG4_VAAPI_HWACCEL) += vaapi_mpeg4.o
+OBJS-$(CONFIG_MPEG4_VDPAU_HWACCEL) += vdpau_mpeg4.o
+OBJS-$(CONFIG_MPEG4_VIDEOTOOLBOX_HWACCEL) += videotoolbox.o
+OBJS-$(CONFIG_VC1_D3D11VA_HWACCEL) += dxva2_vc1.o
+OBJS-$(CONFIG_VC1_DXVA2_HWACCEL) += dxva2_vc1.o
+OBJS-$(CONFIG_VC1_NVDEC_HWACCEL) += nvdec_vc1.o
+OBJS-$(CONFIG_VC1_QSV_HWACCEL) += qsvdec.o
+OBJS-$(CONFIG_VC1_VAAPI_HWACCEL) += vaapi_vc1.o
+OBJS-$(CONFIG_VC1_VDPAU_HWACCEL) += vdpau_vc1.o
+OBJS-$(CONFIG_VP8_NVDEC_HWACCEL) += nvdec_vp8.o
+OBJS-$(CONFIG_VP8_VAAPI_HWACCEL) += vaapi_vp8.o
+OBJS-$(CONFIG_VP9_D3D11VA_HWACCEL) += dxva2_vp9.o
+OBJS-$(CONFIG_VP9_DXVA2_HWACCEL) += dxva2_vp9.o
+OBJS-$(CONFIG_VP9_NVDEC_HWACCEL) += nvdec_vp9.o
+OBJS-$(CONFIG_VP9_VAAPI_HWACCEL) += vaapi_vp9.o
+OBJS-$(CONFIG_VP9_VDPAU_HWACCEL) += vdpau_vp9.o
+OBJS-$(CONFIG_VP8_QSV_HWACCEL) += qsvdec.o
+
+# libavformat dependencies
+OBJS-$(CONFIG_ISO_MEDIA) += mpeg4audio.o mpegaudiodata.o
+
+OBJS-$(CONFIG_ADTS_MUXER) += mpeg4audio.o
+OBJS-$(CONFIG_CODEC2_DEMUXER) += codec2utils.o
+OBJS-$(CONFIG_CODEC2_MUXER) += codec2utils.o
+OBJS-$(CONFIG_CODEC2RAW_DEMUXER) += codec2utils.o
+OBJS-$(CONFIG_DNXHD_DEMUXER) += dnxhddata.o
+OBJS-$(CONFIG_FITS_DEMUXER) += fits.o
+OBJS-$(CONFIG_LATM_MUXER) += mpeg4audio.o
+OBJS-$(CONFIG_MATROSKA_AUDIO_MUXER) += mpeg4audio.o
+OBJS-$(CONFIG_MATROSKA_MUXER) += mpeg4audio.o
+OBJS-$(CONFIG_MOV_DEMUXER) += ac3tab.o
+OBJS-$(CONFIG_MATROSKA_DEMUXER) += mpeg4audio.o
+OBJS-$(CONFIG_MXF_MUXER) += dnxhddata.o
+OBJS-$(CONFIG_NUT_MUXER) += mpegaudiodata.o
+OBJS-$(CONFIG_RTP_MUXER) += mpeg4audio.o
+OBJS-$(CONFIG_SPDIF_MUXER) += dca.o
+OBJS-$(CONFIG_TAK_DEMUXER) += tak.o
+OBJS-$(CONFIG_WEBM_MUXER) += mpeg4audio.o
+
+# libavfilter dependencies
+OBJS-$(CONFIG_ELBG_FILTER) += elbg.o
+
+# external codec libraries
+OBJS-$(CONFIG_AAC_AT_DECODER) += audiotoolboxdec.o
+OBJS-$(CONFIG_AC3_AT_DECODER) += audiotoolboxdec.o
+OBJS-$(CONFIG_ADPCM_IMA_QT_AT_DECODER) += audiotoolboxdec.o
+OBJS-$(CONFIG_ALAC_AT_DECODER) += audiotoolboxdec.o
+OBJS-$(CONFIG_AMR_NB_AT_DECODER) += audiotoolboxdec.o
+OBJS-$(CONFIG_EAC3_AT_DECODER) += audiotoolboxdec.o
+OBJS-$(CONFIG_GSM_MS_AT_DECODER) += audiotoolboxdec.o
+OBJS-$(CONFIG_ILBC_AT_DECODER) += audiotoolboxdec.o
+OBJS-$(CONFIG_MP1_AT_DECODER) += audiotoolboxdec.o
+OBJS-$(CONFIG_MP2_AT_DECODER) += audiotoolboxdec.o
+OBJS-$(CONFIG_MP3_AT_DECODER) += audiotoolboxdec.o
+OBJS-$(CONFIG_PCM_MULAW_AT_DECODER) += audiotoolboxdec.o
+OBJS-$(CONFIG_PCM_ALAW_AT_DECODER) += audiotoolboxdec.o
+OBJS-$(CONFIG_QDMC_AT_DECODER) += audiotoolboxdec.o
+OBJS-$(CONFIG_QDM2_AT_DECODER) += audiotoolboxdec.o
+OBJS-$(CONFIG_AAC_AT_ENCODER) += audiotoolboxenc.o
+OBJS-$(CONFIG_ALAC_AT_ENCODER) += audiotoolboxenc.o
+OBJS-$(CONFIG_ILBC_AT_ENCODER) += audiotoolboxenc.o
+OBJS-$(CONFIG_PCM_ALAW_AT_ENCODER) += audiotoolboxenc.o
+OBJS-$(CONFIG_PCM_MULAW_AT_ENCODER) += audiotoolboxenc.o
+OBJS-$(CONFIG_LIBAOM_AV1_DECODER) += libaomdec.o
+OBJS-$(CONFIG_LIBAOM_AV1_ENCODER) += libaomenc.o
+OBJS-$(CONFIG_LIBARIBB24_DECODER) += libaribb24.o ass.o
+OBJS-$(CONFIG_LIBCELT_DECODER) += libcelt_dec.o
+OBJS-$(CONFIG_LIBCODEC2_DECODER) += libcodec2.o codec2utils.o
+OBJS-$(CONFIG_LIBCODEC2_ENCODER) += libcodec2.o codec2utils.o
+OBJS-$(CONFIG_LIBDAV1D_DECODER) += libdav1d.o
+OBJS-$(CONFIG_LIBDAVS2_DECODER) += libdavs2.o
+OBJS-$(CONFIG_LIBFDK_AAC_DECODER) += libfdk-aacdec.o
+OBJS-$(CONFIG_LIBFDK_AAC_ENCODER) += libfdk-aacenc.o
+OBJS-$(CONFIG_LIBGSM_DECODER) += libgsmdec.o
+OBJS-$(CONFIG_LIBGSM_ENCODER) += libgsmenc.o
+OBJS-$(CONFIG_LIBGSM_MS_DECODER) += libgsmdec.o
+OBJS-$(CONFIG_LIBGSM_MS_ENCODER) += libgsmenc.o
+OBJS-$(CONFIG_LIBILBC_DECODER) += libilbc.o
+OBJS-$(CONFIG_LIBILBC_ENCODER) += libilbc.o
+OBJS-$(CONFIG_LIBKVAZAAR_ENCODER) += libkvazaar.o
+OBJS-$(CONFIG_LIBMP3LAME_ENCODER) += libmp3lame.o
+OBJS-$(CONFIG_LIBOPENCORE_AMRNB_DECODER) += libopencore-amr.o
+OBJS-$(CONFIG_LIBOPENCORE_AMRNB_ENCODER) += libopencore-amr.o
+OBJS-$(CONFIG_LIBOPENCORE_AMRWB_DECODER) += libopencore-amr.o
+OBJS-$(CONFIG_LIBOPENH264_DECODER) += libopenh264dec.o libopenh264.o
+OBJS-$(CONFIG_LIBOPENH264_ENCODER) += libopenh264enc.o libopenh264.o
+OBJS-$(CONFIG_LIBOPENJPEG_DECODER) += libopenjpegdec.o
+OBJS-$(CONFIG_LIBOPENJPEG_ENCODER) += libopenjpegenc.o
+OBJS-$(CONFIG_LIBOPUS_DECODER) += libopusdec.o libopus.o \
+ vorbis_data.o
+OBJS-$(CONFIG_LIBOPUS_ENCODER) += libopusenc.o libopus.o \
+ vorbis_data.o
+OBJS-$(CONFIG_LIBRAV1E_ENCODER) += librav1e.o
+OBJS-$(CONFIG_LIBSHINE_ENCODER) += libshine.o
+OBJS-$(CONFIG_LIBSPEEX_DECODER) += libspeexdec.o
+OBJS-$(CONFIG_LIBSPEEX_ENCODER) += libspeexenc.o
+OBJS-$(CONFIG_LIBSVTAV1_ENCODER) += libsvtav1.o
+OBJS-$(CONFIG_LIBTHEORA_ENCODER) += libtheoraenc.o
+OBJS-$(CONFIG_LIBTWOLAME_ENCODER) += libtwolame.o
+OBJS-$(CONFIG_LIBUAVS3D_DECODER) += libuavs3d.o
+OBJS-$(CONFIG_LIBVO_AMRWBENC_ENCODER) += libvo-amrwbenc.o
+OBJS-$(CONFIG_LIBVORBIS_DECODER) += libvorbisdec.o
+OBJS-$(CONFIG_LIBVORBIS_ENCODER) += libvorbisenc.o \
+ vorbis_data.o
+OBJS-$(CONFIG_LIBVPX_VP8_DECODER) += libvpxdec.o
+OBJS-$(CONFIG_LIBVPX_VP8_ENCODER) += libvpxenc.o
+OBJS-$(CONFIG_LIBVPX_VP9_DECODER) += libvpxdec.o libvpx.o
+OBJS-$(CONFIG_LIBVPX_VP9_ENCODER) += libvpxenc.o libvpx.o
+OBJS-$(CONFIG_LIBWEBP_ENCODER) += libwebpenc_common.o libwebpenc.o
+OBJS-$(CONFIG_LIBWEBP_ANIM_ENCODER) += libwebpenc_common.o libwebpenc_animencoder.o
+OBJS-$(CONFIG_LIBX262_ENCODER) += libx264.o
+OBJS-$(CONFIG_LIBX264_ENCODER) += libx264.o
+OBJS-$(CONFIG_LIBX265_ENCODER) += libx265.o
+OBJS-$(CONFIG_LIBXAVS_ENCODER) += libxavs.o
+OBJS-$(CONFIG_LIBXAVS2_ENCODER) += libxavs2.o
+OBJS-$(CONFIG_LIBXVID_ENCODER) += libxvid.o
+OBJS-$(CONFIG_LIBZVBI_TELETEXT_DECODER) += libzvbi-teletextdec.o ass.o
+
+# parsers
+OBJS-$(CONFIG_AAC_LATM_PARSER) += latm_parser.o
+OBJS-$(CONFIG_AAC_PARSER) += aac_parser.o aac_ac3_parser.o \
+ mpeg4audio.o
+OBJS-$(CONFIG_AC3_PARSER) += ac3tab.o aac_ac3_parser.o
+OBJS-$(CONFIG_ADX_PARSER) += adx_parser.o adx.o
+OBJS-$(CONFIG_AV1_PARSER) += av1_parser.o av1_parse.o
+OBJS-$(CONFIG_AVS2_PARSER) += avs2_parser.o
+OBJS-$(CONFIG_AVS3_PARSER) += avs3_parser.o
+OBJS-$(CONFIG_BMP_PARSER) += bmp_parser.o
+OBJS-$(CONFIG_CAVSVIDEO_PARSER) += cavs_parser.o
+OBJS-$(CONFIG_COOK_PARSER) += cook_parser.o
+OBJS-$(CONFIG_CRI_PARSER) += cri_parser.o
+OBJS-$(CONFIG_DCA_PARSER) += dca_parser.o dca_exss.o dca.o
+OBJS-$(CONFIG_DIRAC_PARSER) += dirac_parser.o
+OBJS-$(CONFIG_DNXHD_PARSER) += dnxhd_parser.o dnxhddata.o
+OBJS-$(CONFIG_DOLBY_E_PARSER) += dolby_e_parser.o dolby_e_parse.o
+OBJS-$(CONFIG_DPX_PARSER) += dpx_parser.o
+OBJS-$(CONFIG_DVAUDIO_PARSER) += dvaudio_parser.o
+OBJS-$(CONFIG_DVBSUB_PARSER) += dvbsub_parser.o
+OBJS-$(CONFIG_DVD_NAV_PARSER) += dvd_nav_parser.o
+OBJS-$(CONFIG_DVDSUB_PARSER) += dvdsub_parser.o
+OBJS-$(CONFIG_FLAC_PARSER) += flac_parser.o flacdata.o flac.o
+OBJS-$(CONFIG_G723_1_PARSER) += g723_1_parser.o
+OBJS-$(CONFIG_G729_PARSER) += g729_parser.o
+OBJS-$(CONFIG_GIF_PARSER) += gif_parser.o
+OBJS-$(CONFIG_GSM_PARSER) += gsm_parser.o
+OBJS-$(CONFIG_H261_PARSER) += h261_parser.o
+OBJS-$(CONFIG_H263_PARSER) += h263_parser.o
+OBJS-$(CONFIG_H264_PARSER) += h264_parser.o h264_sei.o h264data.o
+OBJS-$(CONFIG_HEVC_PARSER) += hevc_parser.o hevc_data.o
+OBJS-$(CONFIG_IPU_PARSER) += ipu_parser.o
+OBJS-$(CONFIG_JPEG2000_PARSER) += jpeg2000_parser.o
+OBJS-$(CONFIG_MJPEG_PARSER) += mjpeg_parser.o
+OBJS-$(CONFIG_MLP_PARSER) += mlp_parse.o mlp_parser.o mlp.o
+OBJS-$(CONFIG_MPEG4VIDEO_PARSER) += mpeg4video_parser.o h263.o \
+ mpeg4videodec.o mpeg4video.o \
+ ituh263dec.o h263dec.o h263data.o
+OBJS-$(CONFIG_MPEGAUDIO_PARSER) += mpegaudio_parser.o
+OBJS-$(CONFIG_MPEGVIDEO_PARSER) += mpegvideo_parser.o \
+ mpeg12.o mpeg12data.o
+OBJS-$(CONFIG_OPUS_PARSER) += opus_parser.o opus.o opustab.o \
+ opus_rc.o vorbis_data.o
+OBJS-$(CONFIG_PNG_PARSER) += png_parser.o
+OBJS-$(CONFIG_PNM_PARSER) += pnm_parser.o pnm.o
+OBJS-$(CONFIG_RV30_PARSER) += rv34_parser.o
+OBJS-$(CONFIG_RV40_PARSER) += rv34_parser.o
+OBJS-$(CONFIG_SBC_PARSER) += sbc_parser.o
+OBJS-$(CONFIG_SIPR_PARSER) += sipr_parser.o
+OBJS-$(CONFIG_TAK_PARSER) += tak_parser.o tak.o
+OBJS-$(CONFIG_VC1_PARSER) += vc1_parser.o vc1.o vc1data.o \
+ simple_idct.o wmv2data.o
+OBJS-$(CONFIG_VP3_PARSER) += vp3_parser.o
+OBJS-$(CONFIG_VP8_PARSER) += vp8_parser.o
+OBJS-$(CONFIG_VP9_PARSER) += vp9_parser.o
+OBJS-$(CONFIG_WEBP_PARSER) += webp_parser.o
+OBJS-$(CONFIG_XBM_PARSER) += xbm_parser.o
+OBJS-$(CONFIG_XMA_PARSER) += xma_parser.o
+
+# bitstream filters
+OBJS-$(CONFIG_AAC_ADTSTOASC_BSF) += aac_adtstoasc_bsf.o mpeg4audio.o
+OBJS-$(CONFIG_AV1_METADATA_BSF) += av1_metadata_bsf.o
+OBJS-$(CONFIG_AV1_FRAME_MERGE_BSF) += av1_frame_merge_bsf.o
+OBJS-$(CONFIG_AV1_FRAME_SPLIT_BSF) += av1_frame_split_bsf.o
+OBJS-$(CONFIG_CHOMP_BSF) += chomp_bsf.o
+OBJS-$(CONFIG_DUMP_EXTRADATA_BSF) += dump_extradata_bsf.o
+OBJS-$(CONFIG_DCA_CORE_BSF) += dca_core_bsf.o
+OBJS-$(CONFIG_EAC3_CORE_BSF) += eac3_core_bsf.o
+OBJS-$(CONFIG_EXTRACT_EXTRADATA_BSF) += extract_extradata_bsf.o \
+ av1_parse.o h2645_parse.o
+OBJS-$(CONFIG_FILTER_UNITS_BSF) += filter_units_bsf.o
+OBJS-$(CONFIG_H264_METADATA_BSF) += h264_metadata_bsf.o h264_levels.o
+OBJS-$(CONFIG_H264_MP4TOANNEXB_BSF) += h264_mp4toannexb_bsf.o
+OBJS-$(CONFIG_H264_REDUNDANT_PPS_BSF) += h264_redundant_pps_bsf.o
+OBJS-$(CONFIG_HAPQA_EXTRACT_BSF) += hapqa_extract_bsf.o hap.o
+OBJS-$(CONFIG_HEVC_METADATA_BSF) += h265_metadata_bsf.o h265_profile_level.o
+OBJS-$(CONFIG_HEVC_MP4TOANNEXB_BSF) += hevc_mp4toannexb_bsf.o
+OBJS-$(CONFIG_IMX_DUMP_HEADER_BSF) += imx_dump_header_bsf.o
+OBJS-$(CONFIG_MJPEG2JPEG_BSF) += mjpeg2jpeg_bsf.o
+OBJS-$(CONFIG_MJPEGA_DUMP_HEADER_BSF) += mjpega_dump_header_bsf.o
+OBJS-$(CONFIG_MPEG4_UNPACK_BFRAMES_BSF) += mpeg4_unpack_bframes_bsf.o
+OBJS-$(CONFIG_MOV2TEXTSUB_BSF) += movsub_bsf.o
+OBJS-$(CONFIG_MP3_HEADER_DECOMPRESS_BSF) += mp3_header_decompress_bsf.o \
+ mpegaudiodata.o
+OBJS-$(CONFIG_MPEG2_METADATA_BSF) += mpeg2_metadata_bsf.o
+OBJS-$(CONFIG_NOISE_BSF) += noise_bsf.o
+OBJS-$(CONFIG_NULL_BSF) += null_bsf.o
+OBJS-$(CONFIG_OPUS_METADATA_BSF) += opus_metadata_bsf.o
+OBJS-$(CONFIG_PCM_RECHUNK_BSF) += pcm_rechunk_bsf.o
+OBJS-$(CONFIG_PRORES_METADATA_BSF) += prores_metadata_bsf.o
+OBJS-$(CONFIG_REMOVE_EXTRADATA_BSF) += remove_extradata_bsf.o
+OBJS-$(CONFIG_SETTS_BSF) += setts_bsf.o
+OBJS-$(CONFIG_TEXT2MOVSUB_BSF) += movsub_bsf.o
+OBJS-$(CONFIG_TRACE_HEADERS_BSF) += trace_headers_bsf.o
+OBJS-$(CONFIG_TRUEHD_CORE_BSF) += truehd_core_bsf.o mlp_parse.o mlp.o
+OBJS-$(CONFIG_VP9_METADATA_BSF) += vp9_metadata_bsf.o
+OBJS-$(CONFIG_VP9_RAW_REORDER_BSF) += vp9_raw_reorder_bsf.o
+OBJS-$(CONFIG_VP9_SUPERFRAME_BSF) += vp9_superframe_bsf.o
+OBJS-$(CONFIG_VP9_SUPERFRAME_SPLIT_BSF) += vp9_superframe_split_bsf.o
+
+# thread libraries
+OBJS-$(HAVE_LIBC_MSVCRT) += file_open.o
+OBJS-$(HAVE_THREADS) += pthread.o pthread_slice.o pthread_frame.o
+
+OBJS-$(CONFIG_FRAME_THREAD_ENCODER) += frame_thread_encoder.o
+
+# Windows resource file
+SLIBOBJS-$(HAVE_GNU_WINDRES) += avcodecres.o
+
+SKIPHEADERS += %_tablegen.h \
+ %_tables.h \
+ fft-internal.h \
+ tableprint.h \
+ tableprint_vlc.h \
+ aaccoder_twoloop.h \
+ aaccoder_trellis.h \
+ aacenc_quantization.h \
+ aacenc_quantization_misc.h \
+ $(ARCH)/vp56_arith.h \
+
+SKIPHEADERS-$(CONFIG_AMF) += amfenc.h
+SKIPHEADERS-$(CONFIG_D3D11VA) += d3d11va.h dxva2_internal.h
+SKIPHEADERS-$(CONFIG_DXVA2) += dxva2.h dxva2_internal.h
+SKIPHEADERS-$(CONFIG_JNI) += ffjni.h
+SKIPHEADERS-$(CONFIG_LIBVPX) += libvpx.h
+SKIPHEADERS-$(CONFIG_LIBWEBP_ENCODER) += libwebpenc_common.h
+SKIPHEADERS-$(CONFIG_MEDIACODEC) += mediacodecdec_common.h mediacodec_surface.h mediacodec_wrapper.h mediacodec_sw_buffer.h
+SKIPHEADERS-$(CONFIG_MEDIAFOUNDATION) += mf_utils.h
+SKIPHEADERS-$(CONFIG_NVDEC) += nvdec.h
+SKIPHEADERS-$(CONFIG_NVENC) += nvenc.h
+SKIPHEADERS-$(CONFIG_QSV) += qsv.h qsv_internal.h
+SKIPHEADERS-$(CONFIG_QSVENC) += qsvenc.h
+SKIPHEADERS-$(CONFIG_XVMC) += xvmc.h
+SKIPHEADERS-$(CONFIG_VAAPI) += vaapi_decode.h vaapi_hevc.h vaapi_encode.h
+SKIPHEADERS-$(CONFIG_VDPAU) += vdpau.h vdpau_internal.h
+SKIPHEADERS-$(CONFIG_VIDEOTOOLBOX) += videotoolbox.h vt_internal.h
+SKIPHEADERS-$(CONFIG_V4L2_M2M) += v4l2_buffers.h v4l2_context.h v4l2_m2m.h
+
+TESTPROGS = avpacket \
+ celp_math \
+ codec_desc \
+ htmlsubtitles \
+ imgconvert \
+ jpeg2000dwt \
+ mathops \
+ utils \
+
+TESTPROGS-$(CONFIG_CABAC) += cabac
+TESTPROGS-$(CONFIG_DCT) += avfft
+TESTPROGS-$(CONFIG_FFT) += fft fft-fixed32
+TESTPROGS-$(CONFIG_GOLOMB) += golomb
+TESTPROGS-$(CONFIG_IDCTDSP) += dct
+TESTPROGS-$(CONFIG_IIRFILTER) += iirfilter
+TESTPROGS-$(CONFIG_MJPEG_ENCODER) += mjpegenc_huffman
+TESTPROGS-$(HAVE_MMX) += motion
+TESTPROGS-$(CONFIG_MPEGVIDEO) += mpeg12framerate
+TESTPROGS-$(CONFIG_H264_METADATA_BSF) += h264_levels
+TESTPROGS-$(CONFIG_HEVC_METADATA_BSF) += h265_levels
+TESTPROGS-$(CONFIG_RANGECODER) += rangecoder
+TESTPROGS-$(CONFIG_SNOW_ENCODER) += snowenc
+
+TESTOBJS = dctref.o
+
+TOOLS = fourcc2pixfmt
+
+HOSTPROGS = aacps_tablegen \
+ aacps_fixed_tablegen \
+ cbrt_tablegen \
+ cbrt_fixed_tablegen \
+ cos_tablegen \
+ dv_tablegen \
+ motionpixels_tablegen \
+ mpegaudio_tablegen \
+ mpegaudiodec_common_tablegen \
+ pcm_tablegen \
+ qdm2_tablegen \
+ sinewin_tablegen \
+ sinewin_fixed_tablegen \
+
+CLEANFILES = *_tables.c *_tables.h *_tablegen$(HOSTEXESUF)
+
+$(SUBDIR)tests/dct$(EXESUF): $(SUBDIR)dctref.o $(SUBDIR)aandcttab.o
+$(SUBDIR)dv_tablegen$(HOSTEXESUF): $(SUBDIR)dvdata_host.o
+
+TRIG_TABLES = cos cos_fixed sin
+TRIG_TABLES := $(TRIG_TABLES:%=$(SUBDIR)%_tables.c)
+
+$(TRIG_TABLES): $(SUBDIR)%_tables.c: $(SUBDIR)cos_tablegen$(HOSTEXESUF)
+ $(M)./$< $* > $@
+
+ifdef CONFIG_SMALL
+$(SUBDIR)%_tablegen$(HOSTEXESUF): HOSTCFLAGS += -DCONFIG_SMALL=1
+else
+$(SUBDIR)%_tablegen$(HOSTEXESUF): HOSTCFLAGS += -DCONFIG_SMALL=0
+endif
+
+GEN_HEADERS = cbrt_tables.h cbrt_fixed_tables.h aacps_tables.h aacps_fixed_tables.h \
+ dv_tables.h \
+ sinewin_tables.h sinewin_fixed_tables.h mpegaudio_tables.h \
+ mpegaudiodec_common_tables.h motionpixels_tables.h \
+ pcm_tables.h qdm2_tables.h
+GEN_HEADERS := $(addprefix $(SUBDIR), $(GEN_HEADERS))
+
+$(GEN_HEADERS): $(SUBDIR)%_tables.h: $(SUBDIR)%_tablegen$(HOSTEXESUF)
+ $(M)./$< > $@
+
+ifdef CONFIG_HARDCODED_TABLES
+$(SUBDIR)cbrt_data.o: $(SUBDIR)cbrt_tables.h
+$(SUBDIR)cbrt_data_fixed.o: $(SUBDIR)cbrt_fixed_tables.h
+$(SUBDIR)aacdec_fixed.o: $(SUBDIR)sinewin_fixed_tables.h
+$(SUBDIR)aacps_float.o: $(SUBDIR)aacps_tables.h
+$(SUBDIR)aacps_fixed.o: $(SUBDIR)aacps_fixed_tables.h
+$(SUBDIR)dvenc.o: $(SUBDIR)dv_tables.h
+$(SUBDIR)motionpixels.o: $(SUBDIR)motionpixels_tables.h
+$(SUBDIR)mpegaudiodec_common.o: $(SUBDIR)mpegaudiodec_common_tables.h
+$(SUBDIR)mpegaudiodec_fixed.o: $(SUBDIR)mpegaudio_tables.h
+$(SUBDIR)mpegaudiodec_float.o: $(SUBDIR)mpegaudio_tables.h
+$(SUBDIR)pcm.o: $(SUBDIR)pcm_tables.h
+$(SUBDIR)qdm2.o: $(SUBDIR)qdm2_tables.h
+$(SUBDIR)sinewin.o: $(SUBDIR)sinewin_tables.h
+endif
Index: allcodecs.c
===================================================================
--- allcodecs.c (nonexistent)
+++ allcodecs.c (revision 377)
@@ -0,0 +1,993 @@
+/*
+ * Provide registration of all codecs, parsers and bitstream filters for libavcodec.
+ * Copyright (c) 2002 Fabrice Bellard
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/**
+ * @file
+ * Provide registration of all codecs, parsers and bitstream filters for libavcodec.
+ */
+
+#include "config.h"
+#include "libavutil/thread.h"
+#include "avcodec.h"
+#include "version.h"
+
+extern AVCodec ff_a64multi_encoder;
+extern AVCodec ff_a64multi5_encoder;
+extern AVCodec ff_aasc_decoder;
+extern AVCodec ff_aic_decoder;
+extern AVCodec ff_alias_pix_encoder;
+extern AVCodec ff_alias_pix_decoder;
+extern AVCodec ff_agm_decoder;
+extern AVCodec ff_amv_encoder;
+extern AVCodec ff_amv_decoder;
+extern AVCodec ff_anm_decoder;
+extern AVCodec ff_ansi_decoder;
+extern AVCodec ff_apng_encoder;
+extern AVCodec ff_apng_decoder;
+extern AVCodec ff_arbc_decoder;
+extern AVCodec ff_argo_decoder;
+extern AVCodec ff_asv1_encoder;
+extern AVCodec ff_asv1_decoder;
+extern AVCodec ff_asv2_encoder;
+extern AVCodec ff_asv2_decoder;
+extern AVCodec ff_aura_decoder;
+extern AVCodec ff_aura2_decoder;
+extern AVCodec ff_avrp_encoder;
+extern AVCodec ff_avrp_decoder;
+extern AVCodec ff_avrn_decoder;
+extern AVCodec ff_avs_omx_decoder;
+extern AVCodec ff_avs_decoder;
+extern AVCodec ff_avui_encoder;
+extern AVCodec ff_avui_decoder;
+extern AVCodec ff_ayuv_encoder;
+extern AVCodec ff_ayuv_decoder;
+extern AVCodec ff_bethsoftvid_decoder;
+extern AVCodec ff_bfi_decoder;
+extern AVCodec ff_bink_decoder;
+extern AVCodec ff_bitpacked_decoder;
+extern AVCodec ff_bmp_encoder;
+extern AVCodec ff_bmp_decoder;
+extern AVCodec ff_bmv_video_decoder;
+extern AVCodec ff_brender_pix_decoder;
+extern AVCodec ff_c93_decoder;
+extern AVCodec ff_cavs_decoder;
+extern AVCodec ff_cdgraphics_decoder;
+extern AVCodec ff_cdtoons_decoder;
+extern AVCodec ff_cdxl_decoder;
+extern AVCodec ff_cfhd_encoder;
+extern AVCodec ff_cfhd_decoder;
+extern AVCodec ff_cinepak_encoder;
+extern AVCodec ff_cinepak_decoder;
+extern AVCodec ff_clearvideo_decoder;
+extern AVCodec ff_cljr_encoder;
+extern AVCodec ff_cljr_decoder;
+extern AVCodec ff_cllc_decoder;
+extern AVCodec ff_comfortnoise_encoder;
+extern AVCodec ff_comfortnoise_decoder;
+extern AVCodec ff_cpia_decoder;
+extern AVCodec ff_cri_decoder;
+extern AVCodec ff_cscd_decoder;
+extern AVCodec ff_cyuv_decoder;
+extern AVCodec ff_dds_decoder;
+extern AVCodec ff_dfa_decoder;
+extern AVCodec ff_dirac_decoder;
+extern AVCodec ff_dnxhd_encoder;
+extern AVCodec ff_dnxhd_decoder;
+extern AVCodec ff_dpx_encoder;
+extern AVCodec ff_dpx_decoder;
+extern AVCodec ff_dsicinvideo_decoder;
+extern AVCodec ff_dvaudio_decoder;
+extern AVCodec ff_dvvideo_encoder;
+extern AVCodec ff_dvvideo_decoder;
+extern AVCodec ff_dxa_decoder;
+extern AVCodec ff_dxtory_decoder;
+extern AVCodec ff_dxv_decoder;
+extern AVCodec ff_eacmv_decoder;
+extern AVCodec ff_eamad_decoder;
+extern AVCodec ff_eatgq_decoder;
+extern AVCodec ff_eatgv_decoder;
+extern AVCodec ff_eatqi_decoder;
+extern AVCodec ff_eightbps_decoder;
+extern AVCodec ff_eightsvx_exp_decoder;
+extern AVCodec ff_eightsvx_fib_decoder;
+extern AVCodec ff_escape124_decoder;
+extern AVCodec ff_escape130_decoder;
+extern AVCodec ff_exr_encoder;
+extern AVCodec ff_exr_decoder;
+extern AVCodec ff_ffv1_encoder;
+extern AVCodec ff_ffv1_decoder;
+extern AVCodec ff_ffvhuff_encoder;
+extern AVCodec ff_ffvhuff_decoder;
+extern AVCodec ff_fic_decoder;
+extern AVCodec ff_fits_encoder;
+extern AVCodec ff_fits_decoder;
+extern AVCodec ff_flashsv_encoder;
+extern AVCodec ff_flashsv_decoder;
+extern AVCodec ff_flashsv2_encoder;
+extern AVCodec ff_flashsv2_decoder;
+extern AVCodec ff_flic_decoder;
+extern AVCodec ff_flv_encoder;
+extern AVCodec ff_sorenson_omx_decoder;
+extern AVCodec ff_flv_decoder;
+extern AVCodec ff_fmvc_decoder;
+extern AVCodec ff_fourxm_decoder;
+extern AVCodec ff_fraps_decoder;
+extern AVCodec ff_frwu_decoder;
+extern AVCodec ff_g2m_decoder;
+extern AVCodec ff_gdv_decoder;
+extern AVCodec ff_gif_encoder;
+extern AVCodec ff_gif_decoder;
+extern AVCodec ff_h261_encoder;
+extern AVCodec ff_h261_decoder;
+extern AVCodec ff_h263_encoder;
+extern AVCodec ff_h263_omx_decoder;
+extern AVCodec ff_h263_decoder;
+extern AVCodec ff_h263i_decoder;
+extern AVCodec ff_h263p_encoder;
+extern AVCodec ff_h263p_decoder;
+extern AVCodec ff_h263_v4l2m2m_decoder;
+extern AVCodec ff_h264_omx_decoder;
+extern AVCodec ff_h264_decoder;
+extern AVCodec ff_h264_crystalhd_decoder;
+extern AVCodec ff_h264_v4l2m2m_decoder;
+extern AVCodec ff_h264_mediacodec_decoder;
+extern AVCodec ff_h264_mmal_decoder;
+extern AVCodec ff_h264_qsv_decoder;
+extern AVCodec ff_h264_rkmpp_decoder;
+extern AVCodec ff_hap_encoder;
+extern AVCodec ff_hap_decoder;
+extern AVCodec ff_hevc_omx_decoder;
+extern AVCodec ff_hevc_decoder;
+extern AVCodec ff_hevc_qsv_decoder;
+extern AVCodec ff_hevc_rkmpp_decoder;
+extern AVCodec ff_hevc_v4l2m2m_decoder;
+extern AVCodec ff_hnm4_video_decoder;
+extern AVCodec ff_hq_hqa_decoder;
+extern AVCodec ff_hqx_decoder;
+extern AVCodec ff_huffyuv_encoder;
+extern AVCodec ff_huffyuv_decoder;
+extern AVCodec ff_hymt_decoder;
+extern AVCodec ff_idcin_decoder;
+extern AVCodec ff_iff_ilbm_decoder;
+extern AVCodec ff_imm4_decoder;
+extern AVCodec ff_imm5_decoder;
+extern AVCodec ff_indeo2_decoder;
+extern AVCodec ff_indeo3_decoder;
+extern AVCodec ff_indeo4_decoder;
+extern AVCodec ff_indeo5_decoder;
+extern AVCodec ff_interplay_video_decoder;
+extern AVCodec ff_ipu_decoder;
+extern AVCodec ff_jpeg2000_encoder;
+extern AVCodec ff_jpeg2000_decoder;
+extern AVCodec ff_jpegls_encoder;
+extern AVCodec ff_jpegls_decoder;
+extern AVCodec ff_jv_decoder;
+extern AVCodec ff_kgv1_decoder;
+extern AVCodec ff_kmvc_decoder;
+extern AVCodec ff_lagarith_decoder;
+extern AVCodec ff_ljpeg_encoder;
+extern AVCodec ff_loco_decoder;
+extern AVCodec ff_lscr_decoder;
+extern AVCodec ff_m101_decoder;
+extern AVCodec ff_magicyuv_encoder;
+extern AVCodec ff_magicyuv_decoder;
+extern AVCodec ff_mdec_decoder;
+extern AVCodec ff_mimic_decoder;
+extern AVCodec ff_mjpeg_encoder;
+extern AVCodec ff_mjpeg_decoder;
+extern AVCodec ff_mjpeg_omx_decoder;
+extern AVCodec ff_mjpegb_decoder;
+extern AVCodec ff_mmvideo_decoder;
+extern AVCodec ff_mobiclip_decoder;
+extern AVCodec ff_motionpixels_decoder;
+extern AVCodec ff_mpeg1video_encoder;
+extern AVCodec ff_mpeg1video_decoder;
+extern AVCodec ff_mpeg2video_encoder;
+extern AVCodec ff_mpeg2video_decoder;
+extern AVCodec ff_mpeg2_omx_decoder;
+extern AVCodec ff_mpeg4_encoder;
+extern AVCodec ff_mpeg4_decoder;
+extern AVCodec ff_mpeg4_omx_decoder;
+extern AVCodec ff_mpeg4_crystalhd_decoder;
+extern AVCodec ff_mpeg4_v4l2m2m_decoder;
+extern AVCodec ff_mpeg4_mmal_decoder;
+extern AVCodec ff_mpegvideo_decoder;
+extern AVCodec ff_mpeg1_v4l2m2m_decoder;
+extern AVCodec ff_mpeg2_mmal_decoder;
+extern AVCodec ff_mpeg2_crystalhd_decoder;
+extern AVCodec ff_mpeg2_v4l2m2m_decoder;
+extern AVCodec ff_mpeg2_qsv_decoder;
+extern AVCodec ff_mpeg2_mediacodec_decoder;
+extern AVCodec ff_msa1_decoder;
+extern AVCodec ff_mscc_decoder;
+extern AVCodec ff_msmpeg4v1_decoder;
+extern AVCodec ff_msmpeg4v2_encoder;
+extern AVCodec ff_msmpeg4v2_decoder;
+extern AVCodec ff_msmpeg4v3_encoder;
+extern AVCodec ff_msmpeg4v3_decoder;
+extern AVCodec ff_msmpeg4_crystalhd_decoder;
+extern AVCodec ff_msp2_decoder;
+extern AVCodec ff_msrle_decoder;
+extern AVCodec ff_mss1_decoder;
+extern AVCodec ff_mss2_decoder;
+extern AVCodec ff_msvideo1_encoder;
+extern AVCodec ff_msvideo1_decoder;
+extern AVCodec ff_mszh_decoder;
+extern AVCodec ff_mts2_decoder;
+extern AVCodec ff_mv30_decoder;
+extern AVCodec ff_mvc1_decoder;
+extern AVCodec ff_mvc2_decoder;
+extern AVCodec ff_mvdv_decoder;
+extern AVCodec ff_mvha_decoder;
+extern AVCodec ff_mwsc_decoder;
+extern AVCodec ff_mxpeg_decoder;
+extern AVCodec ff_notchlc_decoder;
+extern AVCodec ff_nuv_decoder;
+extern AVCodec ff_paf_video_decoder;
+extern AVCodec ff_pam_encoder;
+extern AVCodec ff_pam_decoder;
+extern AVCodec ff_pbm_encoder;
+extern AVCodec ff_pbm_decoder;
+extern AVCodec ff_pcx_encoder;
+extern AVCodec ff_pcx_decoder;
+extern AVCodec ff_pfm_encoder;
+extern AVCodec ff_pfm_decoder;
+extern AVCodec ff_pgm_encoder;
+extern AVCodec ff_pgm_decoder;
+extern AVCodec ff_pgmyuv_encoder;
+extern AVCodec ff_pgmyuv_decoder;
+extern AVCodec ff_pgx_decoder;
+extern AVCodec ff_photocd_decoder;
+extern AVCodec ff_pictor_decoder;
+extern AVCodec ff_pixlet_decoder;
+extern AVCodec ff_png_encoder;
+extern AVCodec ff_png_decoder;
+extern AVCodec ff_ppm_encoder;
+extern AVCodec ff_ppm_decoder;
+extern AVCodec ff_prores_encoder;
+extern AVCodec ff_prores_decoder;
+extern AVCodec ff_prores_aw_encoder;
+extern AVCodec ff_prores_ks_encoder;
+extern AVCodec ff_prosumer_decoder;
+extern AVCodec ff_psd_decoder;
+extern AVCodec ff_ptx_decoder;
+extern AVCodec ff_qdraw_decoder;
+extern AVCodec ff_qpeg_decoder;
+extern AVCodec ff_qtrle_encoder;
+extern AVCodec ff_qtrle_decoder;
+extern AVCodec ff_r10k_encoder;
+extern AVCodec ff_r10k_decoder;
+extern AVCodec ff_r210_encoder;
+extern AVCodec ff_r210_decoder;
+extern AVCodec ff_rasc_decoder;
+extern AVCodec ff_rawvideo_encoder;
+extern AVCodec ff_rawvideo_decoder;
+extern AVCodec ff_rl2_decoder;
+extern AVCodec ff_roq_encoder;
+extern AVCodec ff_roq_decoder;
+extern AVCodec ff_rpza_encoder;
+extern AVCodec ff_rpza_decoder;
+extern AVCodec ff_rscc_decoder;
+extern AVCodec ff_rv10_encoder;
+extern AVCodec ff_rv10_decoder;
+extern AVCodec ff_rv20_encoder;
+extern AVCodec ff_rv20_decoder;
+extern AVCodec ff_rv30_decoder;
+extern AVCodec ff_rv30_omx_decoder;
+extern AVCodec ff_rv40_decoder;
+extern AVCodec ff_rv40_omx_decoder;
+extern AVCodec ff_s302m_encoder;
+extern AVCodec ff_s302m_decoder;
+extern AVCodec ff_sanm_decoder;
+extern AVCodec ff_scpr_decoder;
+extern AVCodec ff_screenpresso_decoder;
+extern AVCodec ff_sga_decoder;
+extern AVCodec ff_sgi_encoder;
+extern AVCodec ff_sgi_decoder;
+extern AVCodec ff_sgirle_decoder;
+extern AVCodec ff_sheervideo_decoder;
+extern AVCodec ff_simbiosis_imx_decoder;
+extern AVCodec ff_smacker_decoder;
+extern AVCodec ff_smc_decoder;
+extern AVCodec ff_smvjpeg_decoder;
+extern AVCodec ff_snow_encoder;
+extern AVCodec ff_snow_decoder;
+extern AVCodec ff_sp5x_decoder;
+extern AVCodec ff_speedhq_decoder;
+extern AVCodec ff_speedhq_encoder;
+extern AVCodec ff_srgc_decoder;
+extern AVCodec ff_sunrast_encoder;
+extern AVCodec ff_sunrast_decoder;
+extern AVCodec ff_svq1_encoder;
+extern AVCodec ff_svq1_decoder;
+extern AVCodec ff_svq3_decoder;
+extern AVCodec ff_targa_encoder;
+extern AVCodec ff_targa_decoder;
+extern AVCodec ff_targa_y216_decoder;
+extern AVCodec ff_tdsc_decoder;
+extern AVCodec ff_theora_decoder;
+extern AVCodec ff_thp_decoder;
+extern AVCodec ff_tiertexseqvideo_decoder;
+extern AVCodec ff_tiff_encoder;
+extern AVCodec ff_tiff_decoder;
+extern AVCodec ff_tmv_decoder;
+extern AVCodec ff_truemotion1_decoder;
+extern AVCodec ff_truemotion2_decoder;
+extern AVCodec ff_truemotion2rt_decoder;
+extern AVCodec ff_tscc_decoder;
+extern AVCodec ff_tscc2_decoder;
+extern AVCodec ff_txd_decoder;
+extern AVCodec ff_ulti_decoder;
+extern AVCodec ff_utvideo_encoder;
+extern AVCodec ff_utvideo_decoder;
+extern AVCodec ff_v210_encoder;
+extern AVCodec ff_v210_decoder;
+extern AVCodec ff_v210x_decoder;
+extern AVCodec ff_v308_encoder;
+extern AVCodec ff_v308_decoder;
+extern AVCodec ff_v408_encoder;
+extern AVCodec ff_v408_decoder;
+extern AVCodec ff_v410_encoder;
+extern AVCodec ff_v410_decoder;
+extern AVCodec ff_vb_decoder;
+extern AVCodec ff_vble_decoder;
+extern AVCodec ff_vc1_omx_decoder;
+extern AVCodec ff_vc1_decoder;
+extern AVCodec ff_vc1_crystalhd_decoder;
+extern AVCodec ff_vc1image_decoder;
+extern AVCodec ff_vc1_mmal_decoder;
+extern AVCodec ff_vc1_qsv_decoder;
+extern AVCodec ff_vc1_v4l2m2m_decoder;
+extern AVCodec ff_vc2_encoder;
+extern AVCodec ff_vcr1_decoder;
+extern AVCodec ff_vmdvideo_decoder;
+extern AVCodec ff_vmnc_decoder;
+extern AVCodec ff_vp3_decoder;
+extern AVCodec ff_vp4_decoder;
+extern AVCodec ff_vp5_decoder;
+extern AVCodec ff_vp6_omx_decoder;
+extern AVCodec ff_vp6_decoder;
+extern AVCodec ff_vp6a_omx_decoder;
+extern AVCodec ff_vp6a_decoder;
+extern AVCodec ff_vp6f_omx_decoder;
+extern AVCodec ff_vp6f_decoder;
+extern AVCodec ff_vp7_decoder;
+extern AVCodec ff_vp8_omx_decoder;
+extern AVCodec ff_vp8_decoder;
+extern AVCodec ff_vp8_rkmpp_decoder;
+extern AVCodec ff_vp8_v4l2m2m_decoder;
+extern AVCodec ff_vp9_decoder;
+extern AVCodec ff_vp9_rkmpp_decoder;
+extern AVCodec ff_vp9_v4l2m2m_decoder;
+extern AVCodec ff_vqa_decoder;
+extern AVCodec ff_webp_decoder;
+extern AVCodec ff_wcmv_decoder;
+extern AVCodec ff_wrapped_avframe_encoder;
+extern AVCodec ff_wrapped_avframe_decoder;
+extern AVCodec ff_wmv1_encoder;
+extern AVCodec ff_wmv1_decoder;
+extern AVCodec ff_wmv2_encoder;
+extern AVCodec ff_wmv2_decoder;
+extern AVCodec ff_wmv3_omx_decoder;
+extern AVCodec ff_wmv3_decoder;
+extern AVCodec ff_wmv3_crystalhd_decoder;
+extern AVCodec ff_wmv3image_decoder;
+extern AVCodec ff_wnv1_decoder;
+extern AVCodec ff_xan_wc3_decoder;
+extern AVCodec ff_xan_wc4_decoder;
+extern AVCodec ff_xbm_encoder;
+extern AVCodec ff_xbm_decoder;
+extern AVCodec ff_xface_encoder;
+extern AVCodec ff_xface_decoder;
+extern AVCodec ff_xl_decoder;
+extern AVCodec ff_xpm_decoder;
+extern AVCodec ff_xwd_encoder;
+extern AVCodec ff_xwd_decoder;
+extern AVCodec ff_y41p_encoder;
+extern AVCodec ff_y41p_decoder;
+extern AVCodec ff_ylc_decoder;
+extern AVCodec ff_yop_decoder;
+extern AVCodec ff_yuv4_encoder;
+extern AVCodec ff_yuv4_decoder;
+extern AVCodec ff_zero12v_decoder;
+extern AVCodec ff_zerocodec_decoder;
+extern AVCodec ff_zlib_encoder;
+extern AVCodec ff_zlib_decoder;
+extern AVCodec ff_zmbv_encoder;
+extern AVCodec ff_zmbv_decoder;
+
+/* audio codecs */
+extern AVCodec ff_aac_encoder;
+extern AVCodec ff_aac_decoder;
+extern AVCodec ff_aac_fixed_decoder;
+extern AVCodec ff_aac_latm_decoder;
+extern AVCodec ff_ac3_encoder;
+extern AVCodec ff_ac3_decoder;
+extern AVCodec ff_ac3_fixed_encoder;
+extern AVCodec ff_ac3_fixed_decoder;
+extern AVCodec ff_acelp_kelvin_decoder;
+extern AVCodec ff_alac_encoder;
+extern AVCodec ff_alac_decoder;
+extern AVCodec ff_als_decoder;
+extern AVCodec ff_amrnb_decoder;
+extern AVCodec ff_amrwb_decoder;
+extern AVCodec ff_ape_decoder;
+extern AVCodec ff_aptx_encoder;
+extern AVCodec ff_aptx_decoder;
+extern AVCodec ff_aptx_hd_encoder;
+extern AVCodec ff_aptx_hd_decoder;
+extern AVCodec ff_atrac1_decoder;
+extern AVCodec ff_atrac3_decoder;
+extern AVCodec ff_atrac3al_decoder;
+extern AVCodec ff_atrac3p_decoder;
+extern AVCodec ff_atrac3pal_decoder;
+extern AVCodec ff_atrac9_decoder;
+extern AVCodec ff_binkaudio_dct_decoder;
+extern AVCodec ff_binkaudio_rdft_decoder;
+extern AVCodec ff_bmv_audio_decoder;
+extern AVCodec ff_cook_decoder;
+extern AVCodec ff_dca_encoder;
+extern AVCodec ff_dca_decoder;
+extern AVCodec ff_dolby_e_decoder;
+extern AVCodec ff_dsd_lsbf_decoder;
+extern AVCodec ff_dsd_msbf_decoder;
+extern AVCodec ff_dsd_lsbf_planar_decoder;
+extern AVCodec ff_dsd_msbf_planar_decoder;
+extern AVCodec ff_dsicinaudio_decoder;
+extern AVCodec ff_dss_sp_decoder;
+extern AVCodec ff_dst_decoder;
+extern AVCodec ff_eac3_encoder;
+extern AVCodec ff_eac3_decoder;
+extern AVCodec ff_evrc_decoder;
+extern AVCodec ff_fastaudio_decoder;
+extern AVCodec ff_ffwavesynth_decoder;
+extern AVCodec ff_flac_encoder;
+extern AVCodec ff_flac_decoder;
+extern AVCodec ff_g723_1_encoder;
+extern AVCodec ff_g723_1_decoder;
+extern AVCodec ff_g729_decoder;
+extern AVCodec ff_gsm_decoder;
+extern AVCodec ff_gsm_ms_decoder;
+extern AVCodec ff_hca_decoder;
+extern AVCodec ff_hcom_decoder;
+extern AVCodec ff_iac_decoder;
+extern AVCodec ff_ilbc_decoder;
+extern AVCodec ff_imc_decoder;
+extern AVCodec ff_interplay_acm_decoder;
+extern AVCodec ff_mace3_decoder;
+extern AVCodec ff_mace6_decoder;
+extern AVCodec ff_metasound_decoder;
+extern AVCodec ff_mlp_encoder;
+extern AVCodec ff_mlp_decoder;
+extern AVCodec ff_mp1_decoder;
+extern AVCodec ff_mp1float_decoder;
+extern AVCodec ff_mp2_encoder;
+extern AVCodec ff_mp2_decoder;
+extern AVCodec ff_mp2float_decoder;
+extern AVCodec ff_mp2fixed_encoder;
+extern AVCodec ff_mp3float_decoder;
+extern AVCodec ff_mp3_decoder;
+extern AVCodec ff_mp3adufloat_decoder;
+extern AVCodec ff_mp3adu_decoder;
+extern AVCodec ff_mp3on4float_decoder;
+extern AVCodec ff_mp3on4_decoder;
+extern AVCodec ff_mpc7_decoder;
+extern AVCodec ff_mpc8_decoder;
+extern AVCodec ff_nellymoser_encoder;
+extern AVCodec ff_nellymoser_decoder;
+extern AVCodec ff_on2avc_decoder;
+extern AVCodec ff_opus_encoder;
+extern AVCodec ff_opus_decoder;
+extern AVCodec ff_paf_audio_decoder;
+extern AVCodec ff_qcelp_decoder;
+extern AVCodec ff_qdm2_decoder;
+extern AVCodec ff_qdmc_decoder;
+extern AVCodec ff_ra_144_encoder;
+extern AVCodec ff_ra_144_decoder;
+extern AVCodec ff_ra_288_decoder;
+extern AVCodec ff_ralf_decoder;
+extern AVCodec ff_sbc_encoder;
+extern AVCodec ff_sbc_decoder;
+extern AVCodec ff_shorten_decoder;
+extern AVCodec ff_sipr_decoder;
+extern AVCodec ff_siren_decoder;
+extern AVCodec ff_smackaud_decoder;
+extern AVCodec ff_sonic_encoder;
+extern AVCodec ff_sonic_decoder;
+extern AVCodec ff_sonic_ls_encoder;
+extern AVCodec ff_tak_decoder;
+extern AVCodec ff_truehd_encoder;
+extern AVCodec ff_truehd_decoder;
+extern AVCodec ff_truespeech_decoder;
+extern AVCodec ff_tta_encoder;
+extern AVCodec ff_tta_decoder;
+extern AVCodec ff_twinvq_decoder;
+extern AVCodec ff_vmdaudio_decoder;
+extern AVCodec ff_vorbis_encoder;
+extern AVCodec ff_vorbis_decoder;
+extern AVCodec ff_wavpack_encoder;
+extern AVCodec ff_wavpack_decoder;
+extern AVCodec ff_wmalossless_decoder;
+extern AVCodec ff_wmapro_decoder;
+extern AVCodec ff_wmav1_encoder;
+extern AVCodec ff_wmav1_decoder;
+extern AVCodec ff_wmav2_encoder;
+extern AVCodec ff_wmav2_decoder;
+extern AVCodec ff_wmavoice_decoder;
+extern AVCodec ff_ws_snd1_decoder;
+extern AVCodec ff_xma1_decoder;
+extern AVCodec ff_xma2_decoder;
+
+/* PCM codecs */
+extern AVCodec ff_pcm_alaw_encoder;
+extern AVCodec ff_pcm_alaw_decoder;
+extern AVCodec ff_pcm_bluray_decoder;
+extern AVCodec ff_pcm_dvd_encoder;
+extern AVCodec ff_pcm_dvd_decoder;
+extern AVCodec ff_pcm_f16le_decoder;
+extern AVCodec ff_pcm_f24le_decoder;
+extern AVCodec ff_pcm_f32be_encoder;
+extern AVCodec ff_pcm_f32be_decoder;
+extern AVCodec ff_pcm_f32le_encoder;
+extern AVCodec ff_pcm_f32le_decoder;
+extern AVCodec ff_pcm_f64be_encoder;
+extern AVCodec ff_pcm_f64be_decoder;
+extern AVCodec ff_pcm_f64le_encoder;
+extern AVCodec ff_pcm_f64le_decoder;
+extern AVCodec ff_pcm_lxf_decoder;
+extern AVCodec ff_pcm_mulaw_encoder;
+extern AVCodec ff_pcm_mulaw_decoder;
+extern AVCodec ff_pcm_s8_encoder;
+extern AVCodec ff_pcm_s8_decoder;
+extern AVCodec ff_pcm_s8_planar_encoder;
+extern AVCodec ff_pcm_s8_planar_decoder;
+extern AVCodec ff_pcm_s16be_encoder;
+extern AVCodec ff_pcm_s16be_decoder;
+extern AVCodec ff_pcm_s16be_planar_encoder;
+extern AVCodec ff_pcm_s16be_planar_decoder;
+extern AVCodec ff_pcm_s16le_encoder;
+extern AVCodec ff_pcm_s16le_decoder;
+extern AVCodec ff_pcm_s16le_planar_encoder;
+extern AVCodec ff_pcm_s16le_planar_decoder;
+extern AVCodec ff_pcm_s24be_encoder;
+extern AVCodec ff_pcm_s24be_decoder;
+extern AVCodec ff_pcm_s24daud_encoder;
+extern AVCodec ff_pcm_s24daud_decoder;
+extern AVCodec ff_pcm_s24le_encoder;
+extern AVCodec ff_pcm_s24le_decoder;
+extern AVCodec ff_pcm_s24le_planar_encoder;
+extern AVCodec ff_pcm_s24le_planar_decoder;
+extern AVCodec ff_pcm_s32be_encoder;
+extern AVCodec ff_pcm_s32be_decoder;
+extern AVCodec ff_pcm_s32le_encoder;
+extern AVCodec ff_pcm_s32le_decoder;
+extern AVCodec ff_pcm_s32le_planar_encoder;
+extern AVCodec ff_pcm_s32le_planar_decoder;
+extern AVCodec ff_pcm_s64be_encoder;
+extern AVCodec ff_pcm_s64be_decoder;
+extern AVCodec ff_pcm_s64le_encoder;
+extern AVCodec ff_pcm_s64le_decoder;
+extern AVCodec ff_pcm_sga_decoder;
+extern AVCodec ff_pcm_u8_encoder;
+extern AVCodec ff_pcm_u8_decoder;
+extern AVCodec ff_pcm_u16be_encoder;
+extern AVCodec ff_pcm_u16be_decoder;
+extern AVCodec ff_pcm_u16le_encoder;
+extern AVCodec ff_pcm_u16le_decoder;
+extern AVCodec ff_pcm_u24be_encoder;
+extern AVCodec ff_pcm_u24be_decoder;
+extern AVCodec ff_pcm_u24le_encoder;
+extern AVCodec ff_pcm_u24le_decoder;
+extern AVCodec ff_pcm_u32be_encoder;
+extern AVCodec ff_pcm_u32be_decoder;
+extern AVCodec ff_pcm_u32le_encoder;
+extern AVCodec ff_pcm_u32le_decoder;
+extern AVCodec ff_pcm_vidc_encoder;
+extern AVCodec ff_pcm_vidc_decoder;
+
+/* DPCM codecs */
+extern AVCodec ff_derf_dpcm_decoder;
+extern AVCodec ff_gremlin_dpcm_decoder;
+extern AVCodec ff_interplay_dpcm_decoder;
+extern AVCodec ff_roq_dpcm_encoder;
+extern AVCodec ff_roq_dpcm_decoder;
+extern AVCodec ff_sdx2_dpcm_decoder;
+extern AVCodec ff_sol_dpcm_decoder;
+extern AVCodec ff_xan_dpcm_decoder;
+
+/* ADPCM codecs */
+extern AVCodec ff_adpcm_4xm_decoder;
+extern AVCodec ff_adpcm_adx_encoder;
+extern AVCodec ff_adpcm_adx_decoder;
+extern AVCodec ff_adpcm_afc_decoder;
+extern AVCodec ff_adpcm_agm_decoder;
+extern AVCodec ff_adpcm_aica_decoder;
+extern AVCodec ff_adpcm_argo_decoder;
+extern AVCodec ff_adpcm_argo_encoder;
+extern AVCodec ff_adpcm_ct_decoder;
+extern AVCodec ff_adpcm_dtk_decoder;
+extern AVCodec ff_adpcm_ea_decoder;
+extern AVCodec ff_adpcm_ea_maxis_xa_decoder;
+extern AVCodec ff_adpcm_ea_r1_decoder;
+extern AVCodec ff_adpcm_ea_r2_decoder;
+extern AVCodec ff_adpcm_ea_r3_decoder;
+extern AVCodec ff_adpcm_ea_xas_decoder;
+extern AVCodec ff_adpcm_g722_encoder;
+extern AVCodec ff_adpcm_g722_decoder;
+extern AVCodec ff_adpcm_g726_encoder;
+extern AVCodec ff_adpcm_g726_decoder;
+extern AVCodec ff_adpcm_g726le_encoder;
+extern AVCodec ff_adpcm_g726le_decoder;
+extern AVCodec ff_adpcm_ima_amv_decoder;
+extern AVCodec ff_adpcm_ima_amv_encoder;
+extern AVCodec ff_adpcm_ima_alp_decoder;
+extern AVCodec ff_adpcm_ima_alp_encoder;
+extern AVCodec ff_adpcm_ima_apc_decoder;
+extern AVCodec ff_adpcm_ima_apm_decoder;
+extern AVCodec ff_adpcm_ima_apm_encoder;
+extern AVCodec ff_adpcm_ima_cunning_decoder;
+extern AVCodec ff_adpcm_ima_dat4_decoder;
+extern AVCodec ff_adpcm_ima_dk3_decoder;
+extern AVCodec ff_adpcm_ima_dk4_decoder;
+extern AVCodec ff_adpcm_ima_ea_eacs_decoder;
+extern AVCodec ff_adpcm_ima_ea_sead_decoder;
+extern AVCodec ff_adpcm_ima_iss_decoder;
+extern AVCodec ff_adpcm_ima_moflex_decoder;
+extern AVCodec ff_adpcm_ima_mtf_decoder;
+extern AVCodec ff_adpcm_ima_oki_decoder;
+extern AVCodec ff_adpcm_ima_qt_encoder;
+extern AVCodec ff_adpcm_ima_qt_decoder;
+extern AVCodec ff_adpcm_ima_rad_decoder;
+extern AVCodec ff_adpcm_ima_ssi_decoder;
+extern AVCodec ff_adpcm_ima_ssi_encoder;
+extern AVCodec ff_adpcm_ima_smjpeg_decoder;
+extern AVCodec ff_adpcm_ima_wav_encoder;
+extern AVCodec ff_adpcm_ima_wav_decoder;
+extern AVCodec ff_adpcm_ima_ws_decoder;
+extern AVCodec ff_adpcm_ms_encoder;
+extern AVCodec ff_adpcm_ms_decoder;
+extern AVCodec ff_adpcm_mtaf_decoder;
+extern AVCodec ff_adpcm_psx_decoder;
+extern AVCodec ff_adpcm_sbpro_2_decoder;
+extern AVCodec ff_adpcm_sbpro_3_decoder;
+extern AVCodec ff_adpcm_sbpro_4_decoder;
+extern AVCodec ff_adpcm_swf_encoder;
+extern AVCodec ff_adpcm_swf_decoder;
+extern AVCodec ff_adpcm_thp_decoder;
+extern AVCodec ff_adpcm_thp_le_decoder;
+extern AVCodec ff_adpcm_vima_decoder;
+extern AVCodec ff_adpcm_xa_decoder;
+extern AVCodec ff_adpcm_yamaha_encoder;
+extern AVCodec ff_adpcm_yamaha_decoder;
+extern AVCodec ff_adpcm_zork_decoder;
+
+/* subtitles */
+extern AVCodec ff_ssa_encoder;
+extern AVCodec ff_ssa_decoder;
+extern AVCodec ff_ass_encoder;
+extern AVCodec ff_ass_decoder;
+extern AVCodec ff_ccaption_decoder;
+extern AVCodec ff_dvbsub_encoder;
+extern AVCodec ff_dvbsub_decoder;
+extern AVCodec ff_dvdsub_encoder;
+extern AVCodec ff_dvdsub_decoder;
+extern AVCodec ff_jacosub_decoder;
+extern AVCodec ff_microdvd_decoder;
+extern AVCodec ff_movtext_encoder;
+extern AVCodec ff_movtext_decoder;
+extern AVCodec ff_mpl2_decoder;
+extern AVCodec ff_pgssub_decoder;
+extern AVCodec ff_pjs_decoder;
+extern AVCodec ff_realtext_decoder;
+extern AVCodec ff_sami_decoder;
+extern AVCodec ff_srt_encoder;
+extern AVCodec ff_srt_decoder;
+extern AVCodec ff_stl_decoder;
+extern AVCodec ff_subrip_encoder;
+extern AVCodec ff_subrip_decoder;
+extern AVCodec ff_subviewer_decoder;
+extern AVCodec ff_subviewer1_decoder;
+extern AVCodec ff_text_encoder;
+extern AVCodec ff_text_decoder;
+extern AVCodec ff_ttml_encoder;
+extern AVCodec ff_vplayer_decoder;
+extern AVCodec ff_webvtt_encoder;
+extern AVCodec ff_webvtt_decoder;
+extern AVCodec ff_xsub_encoder;
+extern AVCodec ff_xsub_decoder;
+
+/* external libraries */
+extern AVCodec ff_aac_at_encoder;
+extern AVCodec ff_aac_at_decoder;
+extern AVCodec ff_ac3_at_decoder;
+extern AVCodec ff_adpcm_ima_qt_at_decoder;
+extern AVCodec ff_alac_at_encoder;
+extern AVCodec ff_alac_at_decoder;
+extern AVCodec ff_amr_nb_at_decoder;
+extern AVCodec ff_eac3_at_decoder;
+extern AVCodec ff_gsm_ms_at_decoder;
+extern AVCodec ff_ilbc_at_encoder;
+extern AVCodec ff_ilbc_at_decoder;
+extern AVCodec ff_mp1_at_decoder;
+extern AVCodec ff_mp2_at_decoder;
+extern AVCodec ff_mp3_at_decoder;
+extern AVCodec ff_pcm_alaw_at_encoder;
+extern AVCodec ff_pcm_alaw_at_decoder;
+extern AVCodec ff_pcm_mulaw_at_encoder;
+extern AVCodec ff_pcm_mulaw_at_decoder;
+extern AVCodec ff_qdmc_at_decoder;
+extern AVCodec ff_qdm2_at_decoder;
+extern AVCodec ff_libaom_av1_encoder;
+extern AVCodec ff_libaribb24_decoder;
+extern AVCodec ff_libcelt_decoder;
+extern AVCodec ff_libcodec2_encoder;
+extern AVCodec ff_libcodec2_decoder;
+extern AVCodec ff_libdav1d_decoder;
+extern AVCodec ff_libdavs2_decoder;
+extern AVCodec ff_libfdk_aac_encoder;
+extern AVCodec ff_libfdk_aac_decoder;
+extern AVCodec ff_libgsm_encoder;
+extern AVCodec ff_libgsm_decoder;
+extern AVCodec ff_libgsm_ms_encoder;
+extern AVCodec ff_libgsm_ms_decoder;
+extern AVCodec ff_libilbc_encoder;
+extern AVCodec ff_libilbc_decoder;
+extern AVCodec ff_libmp3lame_encoder;
+extern AVCodec ff_libopencore_amrnb_encoder;
+extern AVCodec ff_libopencore_amrnb_decoder;
+extern AVCodec ff_libopencore_amrwb_decoder;
+extern AVCodec ff_libopenjpeg_encoder;
+extern AVCodec ff_libopenjpeg_decoder;
+extern AVCodec ff_libopus_encoder;
+extern AVCodec ff_libopus_decoder;
+extern AVCodec ff_librav1e_encoder;
+extern AVCodec ff_librsvg_decoder;
+extern AVCodec ff_libshine_encoder;
+extern AVCodec ff_libspeex_encoder;
+extern AVCodec ff_libspeex_decoder;
+extern AVCodec ff_libsvtav1_encoder;
+extern AVCodec ff_libtheora_encoder;
+extern AVCodec ff_libtwolame_encoder;
+extern AVCodec ff_libuavs3d_decoder;
+extern AVCodec ff_libvo_amrwbenc_encoder;
+extern AVCodec ff_libvorbis_encoder;
+extern AVCodec ff_libvorbis_decoder;
+extern AVCodec ff_libvpx_vp8_encoder;
+extern AVCodec ff_libvpx_vp8_decoder;
+extern AVCodec ff_libvpx_vp9_encoder;
+extern AVCodec ff_libvpx_vp9_decoder;
+/* preferred over libwebp */
+extern AVCodec ff_libwebp_anim_encoder;
+extern AVCodec ff_libwebp_encoder;
+extern AVCodec ff_libx262_encoder;
+extern AVCodec ff_libx264_encoder;
+extern AVCodec ff_libx264rgb_encoder;
+extern AVCodec ff_libx265_encoder;
+extern AVCodec ff_libxavs_encoder;
+extern AVCodec ff_libxavs2_encoder;
+extern AVCodec ff_libxvid_encoder;
+extern AVCodec ff_libzvbi_teletext_decoder;
+
+/* text */
+extern AVCodec ff_bintext_decoder;
+extern AVCodec ff_xbin_decoder;
+extern AVCodec ff_idf_decoder;
+
+/* external libraries, that shouldn't be used by default if one of the
+ * above is available */
+extern AVCodec ff_aac_mf_encoder;
+extern AVCodec ff_ac3_mf_encoder;
+extern AVCodec ff_h263_v4l2m2m_encoder;
+extern AVCodec ff_libaom_av1_decoder;
+/* hwaccel hooks only, so prefer external decoders */
+extern AVCodec ff_av1_decoder;
+extern AVCodec ff_av1_cuvid_decoder;
+extern AVCodec ff_av1_qsv_decoder;
+extern AVCodec ff_libopenh264_encoder;
+extern AVCodec ff_libopenh264_decoder;
+extern AVCodec ff_h264_amf_encoder;
+extern AVCodec ff_h264_cuvid_decoder;
+extern AVCodec ff_h264_mf_encoder;
+extern AVCodec ff_h264_nvenc_encoder;
+extern AVCodec ff_h264_omx_encoder;
+extern AVCodec ff_h264_qsv_encoder;
+extern AVCodec ff_h264_v4l2m2m_encoder;
+extern AVCodec ff_h264_vaapi_encoder;
+extern AVCodec ff_h264_videotoolbox_encoder;
+#if FF_API_NVENC_OLD_NAME
+extern AVCodec ff_nvenc_encoder;
+extern AVCodec ff_nvenc_h264_encoder;
+extern AVCodec ff_nvenc_hevc_encoder;
+#endif
+extern AVCodec ff_hevc_amf_encoder;
+extern AVCodec ff_hevc_cuvid_decoder;
+extern AVCodec ff_hevc_mediacodec_decoder;
+extern AVCodec ff_hevc_mf_encoder;
+extern AVCodec ff_hevc_nvenc_encoder;
+extern AVCodec ff_hevc_qsv_encoder;
+extern AVCodec ff_hevc_v4l2m2m_encoder;
+extern AVCodec ff_hevc_vaapi_encoder;
+extern AVCodec ff_hevc_videotoolbox_encoder;
+extern AVCodec ff_libkvazaar_encoder;
+extern AVCodec ff_mjpeg_cuvid_decoder;
+extern AVCodec ff_mjpeg_qsv_encoder;
+extern AVCodec ff_mjpeg_qsv_decoder;
+extern AVCodec ff_mjpeg_vaapi_encoder;
+extern AVCodec ff_mp3_mf_encoder;
+extern AVCodec ff_mpeg1_cuvid_decoder;
+extern AVCodec ff_mpeg2_cuvid_decoder;
+extern AVCodec ff_mpeg2_qsv_encoder;
+extern AVCodec ff_mpeg2_vaapi_encoder;
+extern AVCodec ff_mpeg4_cuvid_decoder;
+extern AVCodec ff_mpeg4_mediacodec_decoder;
+extern AVCodec ff_mpeg4_omx_encoder;
+extern AVCodec ff_mpeg4_v4l2m2m_encoder;
+extern AVCodec ff_vc1_cuvid_decoder;
+extern AVCodec ff_vp8_cuvid_decoder;
+extern AVCodec ff_vp8_mediacodec_decoder;
+extern AVCodec ff_vp8_qsv_decoder;
+extern AVCodec ff_vp8_v4l2m2m_encoder;
+extern AVCodec ff_vp8_vaapi_encoder;
+extern AVCodec ff_vp9_cuvid_decoder;
+extern AVCodec ff_vp9_mediacodec_decoder;
+extern AVCodec ff_vp9_qsv_decoder;
+extern AVCodec ff_vp9_vaapi_encoder;
+extern AVCodec ff_vp9_qsv_encoder;
+
+// The iterate API is not usable with ossfuzz due to the excessive size of binaries created
+#if CONFIG_OSSFUZZ
+AVCodec * codec_list[] = {
+ NULL,
+ NULL,
+ NULL
+};
+#else
+#include "libavcodec/codec_list.c"
+#endif
+
+static AVOnce av_codec_static_init = AV_ONCE_INIT;
+static void av_codec_init_static(void)
+{
+ for (int i = 0; codec_list[i]; i++) {
+ if (codec_list[i]->init_static_data)
+ codec_list[i]->init_static_data((AVCodec*)codec_list[i]);
+ }
+}
+
+const AVCodec *av_codec_iterate(void **opaque)
+{
+ uintptr_t i = (uintptr_t)*opaque;
+ const AVCodec *c = codec_list[i];
+
+ ff_thread_once(&av_codec_static_init, av_codec_init_static);
+
+ if (c)
+ *opaque = (void*)(i + 1);
+
+ return c;
+}
+
+#if FF_API_NEXT
+FF_DISABLE_DEPRECATION_WARNINGS
+static AVOnce av_codec_next_init = AV_ONCE_INIT;
+
+static void av_codec_init_next(void)
+{
+ AVCodec *prev = NULL, *p;
+ void *i = 0;
+ while ((p = (AVCodec*)av_codec_iterate(&i))) {
+ if (prev)
+ prev->next = p;
+ prev = p;
+ }
+}
+
+
+
+av_cold void avcodec_register(AVCodec *codec)
+{
+ ff_thread_once(&av_codec_next_init, av_codec_init_next);
+}
+
+AVCodec *av_codec_next(const AVCodec *c)
+{
+ ff_thread_once(&av_codec_next_init, av_codec_init_next);
+
+ if (c)
+ return c->next;
+ else
+ return (AVCodec*)codec_list[0];
+}
+
+void avcodec_register_all(void)
+{
+ ff_thread_once(&av_codec_next_init, av_codec_init_next);
+}
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
+
+static enum AVCodecID remap_deprecated_codec_id(enum AVCodecID id)
+{
+ switch(id){
+ //This is for future deprecatec codec ids, its empty since
+ //last major bump but will fill up again over time, please don't remove it
+ default : return id;
+ }
+}
+
+static AVCodec *find_codec(enum AVCodecID id, int (*x)(const AVCodec *))
+{
+ const AVCodec *p, *experimental = NULL;
+ void *i = 0;
+
+ id = remap_deprecated_codec_id(id);
+
+ while ((p = av_codec_iterate(&i))) {
+ if (!x(p))
+ continue;
+ if (p->id == id) {
+ if (p->capabilities & AV_CODEC_CAP_EXPERIMENTAL && !experimental) {
+ experimental = p;
+ } else
+ return (AVCodec*)p;
+ }
+ }
+
+ return (AVCodec*)experimental;
+}
+
+AVCodec *avcodec_find_encoder(enum AVCodecID id)
+{
+ return find_codec(id, av_codec_is_encoder);
+}
+
+AVCodec *avcodec_find_decoder(enum AVCodecID id)
+{
+ return find_codec(id, av_codec_is_decoder);
+}
+
+static AVCodec *find_codec_by_name(const char *name, int (*x)(const AVCodec *))
+{
+ void *i = 0;
+ const AVCodec *p;
+
+ if (!name)
+ return NULL;
+
+ while ((p = av_codec_iterate(&i))) {
+ if (!x(p))
+ continue;
+ if (strcmp(name, p->name) == 0)
+ return (AVCodec*)p;
+ }
+
+ return NULL;
+}
+
+AVCodec *avcodec_find_encoder_by_name(const char *name)
+{
+ return find_codec_by_name(name, av_codec_is_encoder);
+}
+
+AVCodec *avcodec_find_decoder_by_name(const char *name)
+{
+ return find_codec_by_name(name, av_codec_is_decoder);
+}
Index: omxdec.c
===================================================================
--- omxdec.c (nonexistent)
+++ omxdec.c (revision 377)
@@ -0,0 +1,1796 @@
+/*
+ * OMX Video decoder
+ *
+ * Copyright (C) 2022 Baikal Electronics, JSC
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <pthread.h>
+#include <dlfcn.h>
+#include <time.h>
+
+#include <stdatomic.h>
+
+#include "libavutil/avstring.h"
+#include "libavutil/imgutils.h"
+#include "libavutil/opt.h"
+#include "libavutil/log.h"
+#if CONFIG_OMX_IMG
+#include "libswscale/swscale.h"
+#endif /* CONFIG_OMX_IMG */
+
+#include "avcodec.h"
+#include "h264.h"
+#include "internal.h"
+
+#include <OMX_Core.h>
+#include <OMX_Component.h>
+#include <OMX_RoleNames.h>
+#include <OMX_IndexExt.h>
+#include <OMX_VideoExt.h>
+
+#define OMX_DECODER_VERSION_MAJOR (1)
+#define OMX_DECODER_VERSION_MINOR (2)
+#define OMX_DECODER_VERSION_REVISION (0)
+#define OMX_DECODER_VERSION_STEP (0)
+
+#define OMX_STATE_TIMEOUT 5
+#define OMX_OUTPUT_TIMEOUT 1
+#define OMX_INPUT_QUEUE_THRESHOLD 4
+
+static const char * const omx_core_libraries[] = {
+#if CONFIG_OMX_IMG
+ "libomx_vxd.so",
+#else
+ "libOMX_Core.so",
+ "libOmxCore.so",
+#endif /* CONFIG_OMX_IMG */
+ NULL
+};
+
+#ifdef OMX_SKIP64BIT
+static OMX_TICKS to_omx_ticks(int64_t value)
+{
+ OMX_TICKS res;
+ s.nLowPart = value & 0xffffffff;
+ s.nHighPart = value >> 32;
+ return res;
+}
+static int64_t from_omx_ticks(OMX_TICKS value)
+{
+ return (((int64_t)value.nHighPart) << 32) | value.nLowPart;
+}
+#else
+#define to_omx_ticks(value) (value)
+#define from_omx_ticks(value) (value)
+#endif
+
+#define OMX_INIT_STRUCT(p) do { \
+ memset ((p), 0, sizeof (*(p))); \
+ (p)->nSize = sizeof (*(p)); \
+ (p)->nVersion.s.nVersionMajor = OMX_DECODER_VERSION_MAJOR; \
+ (p)->nVersion.s.nVersionMinor = OMX_DECODER_VERSION_MINOR; \
+ (p)->nVersion.s.nRevision = OMX_DECODER_VERSION_REVISION; \
+ (p)->nVersion.s.nStep = OMX_DECODER_VERSION_STEP; \
+} while (0)
+
+typedef struct _OMXCore OMXCore;
+typedef struct _OMXCodecContext OMXCodecContext;
+typedef struct _OMXCodecPort OMXCodecPort;
+typedef struct _OMXInputBuffer OMXInputBuffer;
+typedef struct _OMXBufferHeader OMXBufferHeader;
+
+struct _OMXCore {
+ void *handle;
+ OMX_ERRORTYPE (*pInit)(void);
+ OMX_ERRORTYPE (*pDeinit)(void);
+ OMX_ERRORTYPE (*pComponentNameEnum)(OMX_STRING, OMX_U32, OMX_U32);
+ OMX_ERRORTYPE (*pGetHandle)(OMX_HANDLETYPE*, OMX_STRING, OMX_PTR,
+ OMX_CALLBACKTYPE*);
+ OMX_ERRORTYPE (*pFreeHandle)(OMX_HANDLETYPE);
+#if CONFIG_OMX_IMG
+ OMX_ERRORTYPE (*pComponentOfRoleEnum)(OMX_STRING, OMX_STRING, OMX_U32);
+#else
+ OMX_ERRORTYPE (*pGetComponentsOfRole)(OMX_STRING, OMX_U32*, OMX_U8**);
+#endif /* CONFIG_OMX_IMG */
+};
+
+struct _OMXInputBuffer {
+ AVBufferRef *ref;
+ void *data;
+ size_t size;
+ int64_t pts;
+ OMX_U32 flags;
+ OMXInputBuffer *next;
+};
+
+struct _OMXBufferHeader {
+ OMX_BUFFERHEADERTYPE *header;
+ OMXCodecPort *port;
+ int decoding;
+ void *priv;
+ OMXBufferHeader *next;
+};
+
+struct _OMXCodecPort {
+ int index;
+ OMX_PARAM_PORTDEFINITIONTYPE port_def;
+ // number of port buffers
+ int num_buffers;
+ // buffer headers pool
+ OMXBufferHeader *headers;
+ // number of headers in pool
+ atomic_int num_headers;
+ // headers pool lock
+ pthread_mutex_t mutex;
+ OMXCodecContext *ctx;
+};
+
+struct _OMXCodecContext {
+ const AVClass *class;
+
+ AVCodecContext *avctx;
+
+ char *libname;
+ OMXCore *core;
+
+ char component_name[OMX_MAX_STRINGNAME_SIZE];
+ OMX_HANDLETYPE handle;
+
+ int stride, plane_size;
+
+ OMXCodecPort in;
+ // lock free (accessed by omx_decode only)
+ OMXInputBuffer *in_queue_head, *in_queue_tail;
+ int in_queue_size;
+
+ OMXCodecPort out;
+ OMXBufferHeader *out_queue_head, *out_queue_tail;
+ int out_queue_size;
+ pthread_mutex_t out_queue_mutex;
+ pthread_cond_t out_queue_cond;
+#if !CONFIG_OMX_IMG
+ uint8_t *output_buf;
+ int output_buf_size;
+#endif /* !CONFIG_OMX_IMG */
+ int settings_changed;
+#if CONFIG_OMX_IMG
+ struct SwsContext *sws_ctx;
+ enum AVPixelFormat decoder_pix_fmt;
+#endif /* CONFIG_OMX_IMG */
+
+ int flushing;
+
+ pthread_mutex_t state_mutex;
+ pthread_cond_t state_cond;
+ OMX_STATETYPE state;
+ OMX_ERRORTYPE error;
+
+ int eos_sent, eos_received;
+ int extradata_sent;
+};
+
+static av_cold int omx_core_load(OMXCore *core, void *logctx,
+ const char *libname)
+{
+ core->handle = dlopen(libname, RTLD_LOCAL | RTLD_NOW);
+ if (!core->handle) {
+ av_log(logctx, AV_LOG_WARNING, "%s not found\n", libname);
+ return -1;
+ }
+ core->pInit = dlsym(core->handle, "OMX_Init");
+ core->pDeinit = dlsym(core->handle, "OMX_Deinit");
+ core->pGetHandle = dlsym(core->handle, "OMX_GetHandle");
+ core->pFreeHandle = dlsym(core->handle, "OMX_FreeHandle");
+#if CONFIG_OMX_IMG
+ core->pComponentOfRoleEnum = dlsym(core->handle, "OMX_ComponentOfRoleEnum");
+#else
+ core->pGetComponentsOfRole = dlsym(core->handle, "OMX_GetComponentsOfRole");
+#endif /* CONFIG_OMX_IMG */
+ if (!core->pInit || !core->pDeinit || !core->pGetHandle ||
+ !core->pFreeHandle ||
+#if CONFIG_OMX_IMG
+ !core->pComponentOfRoleEnum
+#else
+ !core->pGetComponentsOfRole
+#endif /* CONFIG_OMX_IMG */
+ ) {
+ av_log(logctx, AV_LOG_WARNING, "Not all functions found in %s\n",
+ libname);
+ dlclose(core->handle);
+ core->handle = NULL;
+ return -1;
+ }
+ return 0;
+}
+
+static const char *omx_error_string(OMX_ERRORTYPE err)
+{
+ switch (err) {
+ case OMX_ErrorNone:
+ return "None";
+ case OMX_ErrorInsufficientResources:
+ return "Insufficient resources";
+ case OMX_ErrorUndefined:
+ return "Undefined";
+ case OMX_ErrorInvalidComponentName:
+ return "Invalid component name";
+ case OMX_ErrorComponentNotFound:
+ return "Component not found";
+ case OMX_ErrorInvalidComponent:
+ return "Invalid component";
+ case OMX_ErrorBadParameter:
+ return "Bad parameter";
+ case OMX_ErrorNotImplemented:
+ return "Not implemented";
+ case OMX_ErrorUnderflow:
+ return "Underflow";
+ case OMX_ErrorOverflow:
+ return "Overflow";
+ case OMX_ErrorHardware:
+ return "Hardware";
+ case OMX_ErrorInvalidState:
+ return "Invalid state";
+ case OMX_ErrorStreamCorrupt:
+ return "Stream corrupt";
+ case OMX_ErrorPortsNotCompatible:
+ return "Ports not compatible";
+ case OMX_ErrorResourcesLost:
+ return "Resources lost";
+ case OMX_ErrorNoMore:
+ return "No more";
+ case OMX_ErrorVersionMismatch:
+ return "Version mismatch";
+ case OMX_ErrorNotReady:
+ return "Not ready";
+ case OMX_ErrorTimeout:
+ return "Timeout";
+ case OMX_ErrorSameState:
+ return "Same state";
+ case OMX_ErrorResourcesPreempted:
+ return "Resources preempted";
+ case OMX_ErrorPortUnresponsiveDuringAllocation:
+ return "Port unresponsive during allocation";
+ case OMX_ErrorPortUnresponsiveDuringDeallocation:
+ return "Port unresponsive during deallocation";
+ case OMX_ErrorPortUnresponsiveDuringStop:
+ return "Port unresponsive during stop";
+ case OMX_ErrorIncorrectStateTransition:
+ return "Incorrect state transition";
+ case OMX_ErrorIncorrectStateOperation:
+ return "Incorrect state operation";
+ case OMX_ErrorUnsupportedSetting:
+ return "Unsupported setting";
+ case OMX_ErrorUnsupportedIndex:
+ return "Unsupported index";
+ case OMX_ErrorBadPortIndex:
+ return "Bad port index";
+ case OMX_ErrorPortUnpopulated:
+ return "Port unpopulated";
+ case OMX_ErrorComponentSuspended:
+ return "Component suspended";
+ case OMX_ErrorDynamicResourcesUnavailable:
+ return "Dynamic resources unavailable";
+ case OMX_ErrorMbErrorsInFrame:
+ return "Macroblock errors in frame";
+ case OMX_ErrorFormatNotDetected:
+ return "Format not detected";
+ case OMX_ErrorContentPipeOpenFailed:
+ return "Content pipe open failed";
+ case OMX_ErrorContentPipeCreationFailed:
+ return "Content pipe creation failed";
+ case OMX_ErrorSeperateTablesUsed:
+ return "Separate tables used";
+ case OMX_ErrorTunnelingUnsupported:
+ return "Tunneling unsupported";
+ default:
+ if (err >= OMX_ErrorKhronosExtensions &&
+ err < OMX_ErrorVendorStartUnused)
+ return "Khronos extension error";
+ else if (err >= OMX_ErrorVendorStartUnused &&
+ err < OMX_ErrorMax)
+ return "Vendor specific error";
+ else
+ return "Unknown error";
+ }
+}
+
+static av_cold OMXCore *omx_core_init(void *logctx, const char *libname)
+{
+ OMXCore *core;
+ int loaded = 0;
+ OMX_ERRORTYPE err;
+
+ core = av_mallocz(sizeof(*core));
+ if (!core) {
+ av_log(logctx, AV_LOG_ERROR,
+ "Core initialization error: Not enough memory\n");
+ return NULL;
+ }
+
+ if (libname)
+ loaded = (omx_core_load(core, logctx, libname) == 0);
+ else {
+ int i;
+
+ for (i = 0; omx_core_libraries[i] && !loaded; i++)
+ loaded = (omx_core_load(core, logctx, omx_core_libraries[i]) == 0);
+ }
+ if (!loaded) {
+ av_log(logctx, AV_LOG_ERROR,
+ "Core initialization error: Core library not found\n");
+ av_free(core);
+ return NULL;
+ }
+
+ err = core->pInit();
+ if (err != OMX_ErrorNone) {
+ av_log(logctx, AV_LOG_ERROR,
+ "Core initialization error: %s\n", omx_error_string(err));
+ dlclose(core->handle);
+ av_free(core);
+ return NULL;
+ }
+
+ return core;
+}
+
+static av_cold void omx_core_destroy(OMXCore *core)
+{
+ if (core) {
+ core->pDeinit();
+ dlclose(core->handle);
+ av_free(core);
+ }
+}
+
+#if !CONFIG_OMX_IMG
+static av_cold int omx_component_find(OMXCodecContext *ctx,
+ const char *role, char *str, int str_size)
+{
+ AVCodecContext *avctx = ctx->avctx;
+ int ret = 0;
+ OMX_U32 i, num = 0;
+ char **components;
+
+ ctx->core->pGetComponentsOfRole((OMX_STRING) role, &num, NULL);
+ if (!num) {
+ av_log(avctx, AV_LOG_ERROR, "No component for role %s found\n", role);
+ return -1;
+ }
+ components = av_mallocz_array(num, sizeof(*components));
+ if (!components) {
+ av_log(avctx, AV_LOG_ERROR,
+ "Component search error: Not enough memory\n");
+ return -1;
+ }
+ for (i = 0; i < num; i++) {
+ components[i] = av_mallocz(OMX_MAX_STRINGNAME_SIZE);
+ if (!components[i]) {
+ av_log(avctx, AV_LOG_ERROR,
+ "Component search error: Not enough memory\n");
+ ret = -1;
+ goto end;
+ }
+ }
+ ctx->core->pGetComponentsOfRole((OMX_STRING) role, &num,
+ (OMX_U8**) components);
+ av_strlcpy(str, components[0], str_size);
+end:
+ for (i = 0; i < num; i++)
+ av_free(components[i]);
+ av_free(components);
+ return ret;
+}
+#endif /* !CONFIG_OMX_IMG */
+
+static OMX_ERRORTYPE omx_event_handler(OMX_HANDLETYPE component,
+ OMX_PTR app_data, OMX_EVENTTYPE event,
+ OMX_U32 data1, OMX_U32 data2,
+ OMX_PTR event_data)
+{
+ OMXCodecContext *ctx = app_data;
+
+ /* This uses casts in the printfs, since OMX_U32 actually is a typedef for
+ unsigned long in official header versions (but there are also modified
+ versions where it is something else). */
+ switch (event) {
+ case OMX_EventError:
+ pthread_mutex_lock(&ctx->state_mutex);
+ av_log(ctx->avctx, AV_LOG_ERROR, "OMX error %"PRIx32"\n",
+ (uint32_t) data1);
+ ctx->error = data1;
+ pthread_cond_broadcast(&ctx->state_cond);
+ pthread_mutex_unlock(&ctx->state_mutex);
+ break;
+ case OMX_EventCmdComplete:
+ if (data1 == OMX_CommandStateSet) {
+ pthread_mutex_lock(&ctx->state_mutex);
+ ctx->state = data2;
+ av_log(ctx->avctx, AV_LOG_VERBOSE,
+ "OMX state changed to %"PRIu32"\n", (uint32_t) data2);
+ pthread_cond_broadcast(&ctx->state_cond);
+ pthread_mutex_unlock(&ctx->state_mutex);
+ } else if (data1 == OMX_CommandPortDisable) {
+ av_log(ctx->avctx, AV_LOG_VERBOSE,
+ "OMX port %"PRIu32" disabled\n", (uint32_t) data2);
+ pthread_mutex_lock(&ctx->state_mutex);
+ pthread_cond_broadcast(&ctx->state_cond);
+ pthread_mutex_unlock(&ctx->state_mutex);
+ } else if (data1 == OMX_CommandPortEnable) {
+ av_log(ctx->avctx, AV_LOG_VERBOSE,
+ "OMX port %"PRIu32" enabled\n", (uint32_t) data2);
+ pthread_mutex_lock(&ctx->state_mutex);
+ pthread_cond_broadcast(&ctx->state_cond);
+ pthread_mutex_unlock(&ctx->state_mutex);
+ } else if (data1 == OMX_CommandFlush) {
+ av_log(ctx->avctx, AV_LOG_VERBOSE,
+ "OMX port %"PRIu32" flushed\n", (uint32_t) data2);
+ pthread_mutex_lock(&ctx->state_mutex);
+ ctx->flushing = 0;
+ pthread_cond_broadcast(&ctx->state_cond);
+ pthread_mutex_unlock(&ctx->state_mutex);
+ } else {
+ av_log(ctx->avctx, AV_LOG_VERBOSE,
+ "OMX command complete, command %"PRIu32", value %"PRIu32"\n",
+ (uint32_t) data1, (uint32_t) data2);
+ }
+ break;
+ case OMX_EventPortSettingsChanged:
+ av_log(ctx->avctx, AV_LOG_VERBOSE,
+ "OMX port %"PRIu32" settings changed\n", (uint32_t) data1);
+ /* Probably we are waiting for output data now. Wake up waiting task
+ to apply new output port settings. */
+ pthread_mutex_lock(&ctx->out_queue_mutex);
+ ctx->settings_changed = 1;
+ pthread_cond_broadcast(&ctx->out_queue_cond);
+ pthread_mutex_unlock(&ctx->out_queue_mutex);
+ break;
+ case OMX_EventBufferFlag:
+ av_log(ctx->avctx, AV_LOG_VERBOSE,
+ "OMX port %"PRIu32" EOS received (%"PRIx32")\n",
+ (uint32_t) data1, (uint32_t) data2);
+ break;
+ default:
+ av_log(ctx->avctx, AV_LOG_VERBOSE, "OMX event %d %"PRIx32" %"PRIx32"\n",
+ event, (uint32_t) data1, (uint32_t) data2);
+ break;
+ }
+ return OMX_ErrorNone;
+}
+
+/* Must be called with pool locked */
+static void omx_buffer_release(OMXBufferHeader *h)
+{
+ OMXCodecPort *port = h->port;
+ OMXCodecContext *ctx = h->port->ctx;
+
+ if (h->decoding) {
+ h->decoding = 0;
+ if (port->port_def.eDir == OMX_DirInput) {
+ OMXInputBuffer *buffer = h->priv;
+
+ h->header->pBuffer = NULL;
+ av_buffer_unref(&buffer->ref);
+ av_free(buffer);
+ }
+ h->next = port->headers;
+ port->headers = h;
+ atomic_fetch_add(&port->num_headers, 1);
+ }
+ else
+ av_log(ctx->avctx, AV_LOG_VERBOSE,
+ "Port %d release unused buffer %p - ignore\n", port->index, h);
+}
+
+static OMX_ERRORTYPE omx_empty_buffer_done(OMX_HANDLETYPE component,
+ OMX_PTR app_data,
+ OMX_BUFFERHEADERTYPE *header)
+{
+ OMXBufferHeader *h = header->pAppPrivate;
+ OMXCodecPort *port = h->port;
+
+ pthread_mutex_lock(&port->mutex);
+ omx_buffer_release(h);
+ pthread_mutex_unlock(&port->mutex);
+ /* Probably we are waiting for output data now, but decoder has not enough
+ input data yet. Wake up waiting task to send new data to the decoder. */
+ pthread_mutex_lock(&port->ctx->out_queue_mutex);
+ pthread_cond_broadcast(&port->ctx->out_queue_cond);
+ pthread_mutex_unlock(&port->ctx->out_queue_mutex);
+
+ return OMX_ErrorNone;
+}
+
+static OMX_ERRORTYPE omx_fill_buffer_done(OMX_HANDLETYPE component,
+ OMX_PTR app_data,
+ OMX_BUFFERHEADERTYPE *header)
+{
+ OMXCodecContext *ctx = app_data;
+ OMXBufferHeader *h = header->pAppPrivate;
+ OMXCodecPort *port = h->port;
+
+ pthread_mutex_lock(&port->mutex);
+ if (h->decoding) {
+ h->decoding = 0;
+ // add buffer to output queue
+ pthread_mutex_lock(&ctx->out_queue_mutex);
+ h->next = NULL;
+ if (!ctx->out_queue_head)
+ ctx->out_queue_head = h;
+ if (ctx->out_queue_tail)
+ ctx->out_queue_tail->next = h;
+ ctx->out_queue_tail = h;
+ ctx->out_queue_size++;
+ pthread_cond_broadcast(&ctx->out_queue_cond);
+ pthread_mutex_unlock(&ctx->out_queue_mutex);
+ }
+ else
+ av_log(ctx->avctx, AV_LOG_VERBOSE,
+ "Fill buffer done called for unused buffer\n");
+ pthread_mutex_unlock(&port->mutex);
+
+ return OMX_ErrorNone;
+}
+
+static const OMX_CALLBACKTYPE omx_callbacks = {
+ omx_event_handler,
+ omx_empty_buffer_done,
+ omx_fill_buffer_done
+};
+
+static enum AVPixelFormat omx_to_av_pix_fmt(OMX_COLOR_FORMATTYPE color_format)
+{
+ switch (color_format) {
+ case OMX_COLOR_FormatL8:
+ return AV_PIX_FMT_GRAY8;
+ case OMX_COLOR_FormatYUV420Planar:
+ case OMX_COLOR_FormatYUV420PackedPlanar:
+ return AV_PIX_FMT_YUV420P;
+ case OMX_COLOR_FormatYUV420SemiPlanar:
+ case OMX_COLOR_FormatYUV420PackedSemiPlanar:
+ return AV_PIX_FMT_NV12;
+ case OMX_COLOR_FormatYUV422SemiPlanar:
+ return AV_PIX_FMT_NV16;
+ case OMX_COLOR_FormatYCbYCr:
+ return AV_PIX_FMT_YUYV422;
+ case OMX_COLOR_FormatYCrYCb:
+ return AV_PIX_FMT_YVYU422;
+ case OMX_COLOR_FormatCbYCrY:
+ return AV_PIX_FMT_UYVY422;
+ case OMX_COLOR_Format32bitARGB8888:
+ /* There is a mismatch in omxil specification 4.2.1 between
+ OMX_COLOR_Format32bitARGB8888 and its description
+ Follow the description */
+ return AV_PIX_FMT_ABGR;
+ case OMX_COLOR_Format32bitBGRA8888:
+ /* Same issue as OMX_COLOR_Format32bitARGB8888 */
+ return AV_PIX_FMT_ARGB;
+ case OMX_COLOR_Format16bitRGB565:
+ return AV_PIX_FMT_RGB565;
+ case OMX_COLOR_Format16bitBGR565:
+ return AV_PIX_FMT_BGR565;
+ }
+
+ return AV_PIX_FMT_NONE;
+}
+
+static OMX_COLOR_FORMATTYPE omx_codec_select_color_format(OMXCodecContext *ctx)
+{
+ AVCodecContext *avctx = ctx->avctx;
+ OMX_COLOR_FORMATTYPE color_format = OMX_COLOR_FormatUnused;
+
+ if (avctx->pix_fmt != AV_PIX_FMT_NONE) {
+ OMX_VIDEO_PARAM_PORTFORMATTYPE video_port_format = { 0 };
+ OMX_ERRORTYPE err;
+ int i;
+
+ for (i = 0; ; i++) {
+ OMX_INIT_STRUCT(&video_port_format);
+ video_port_format.nIndex = i;
+ video_port_format.nPortIndex = ctx->out.index;
+ if (OMX_GetParameter(ctx->handle, OMX_IndexParamVideoPortFormat,
+ &video_port_format) != OMX_ErrorNone)
+ break;
+ if (omx_to_av_pix_fmt(video_port_format.eColorFormat) ==
+ avctx->pix_fmt) {
+ color_format = video_port_format.eColorFormat;
+ break;
+ }
+ }
+ if (color_format != OMX_COLOR_FormatUnused) {
+ OMX_INIT_STRUCT(&video_port_format);
+ video_port_format.nPortIndex = ctx->out.index;
+ video_port_format.eColorFormat = color_format;
+ err = OMX_SetParameter(ctx->handle, OMX_IndexParamVideoPortFormat,
+ &video_port_format);
+ if (err != OMX_ErrorNone)
+ av_log(avctx, AV_LOG_WARNING,
+ "Can not set port %d color format: %s\n",
+ ctx->out.index, omx_error_string(err));
+ }
+ }
+ return color_format;
+}
+
+static av_cold void omx_port_init(OMXCodecContext *ctx, OMXCodecPort *port)
+{
+ port->index = -1;
+ pthread_mutex_init(&port->mutex, NULL);
+ port->ctx = ctx;
+}
+
+static OMX_ERRORTYPE omx_update_port_definition(OMXCodecPort *port,
+ OMX_PARAM_PORTDEFINITIONTYPE *port_def)
+{
+ OMXCodecContext *ctx = port->ctx;
+ OMX_ERRORTYPE err;
+
+ if (port_def) {
+ err = OMX_SetParameter(ctx->handle, OMX_IndexParamPortDefinition,
+ port_def);
+ if (err != OMX_ErrorNone)
+ av_log(ctx->avctx, AV_LOG_WARNING,
+ "Can not set port %d definition: %s\n", port->index,
+ omx_error_string(err));
+ }
+ OMX_GetParameter(ctx->handle, OMX_IndexParamPortDefinition,
+ &port->port_def);
+
+ return err;
+}
+
+static av_cold OMX_VIDEO_CODINGTYPE omx_id_to_coding_type(enum AVCodecID id)
+{
+ switch (id) {
+ case AV_CODEC_ID_H264:
+ return OMX_VIDEO_CodingAVC;
+ case AV_CODEC_ID_HEVC:
+ return OMX_VIDEO_CodingHEVC;
+ case AV_CODEC_ID_MPEG4:
+ return OMX_VIDEO_CodingMPEG4;
+ case AV_CODEC_ID_H263:
+ return OMX_VIDEO_CodingH263;
+ case AV_CODEC_ID_MPEG2VIDEO:
+ return OMX_VIDEO_CodingMPEG2;
+ case AV_CODEC_ID_MJPEG:
+ return OMX_VIDEO_CodingMJPEG;
+ case AV_CODEC_ID_VP8:
+ return OMX_VIDEO_CodingVP8;
+ case AV_CODEC_ID_WMV3:
+ return OMX_VIDEO_CodingWMV;
+ case AV_CODEC_ID_RV30:
+ case AV_CODEC_ID_RV40:
+ return OMX_VIDEO_CodingRV;
+#if CONFIG_OMX_IMG
+ case AV_CODEC_ID_VC1:
+ return OMX_VIDEO_CodingVC1;
+ case AV_CODEC_ID_FLV1:
+ return OMX_VIDEO_CodingSorensonSpark;
+ case AV_CODEC_ID_VP6:
+ case AV_CODEC_ID_VP6F:
+ case AV_CODEC_ID_VP6A:
+ return OMX_VIDEO_CodingVP6;
+ case AV_CODEC_ID_AVS:
+ return OMX_VIDEO_CodingAVS;
+#endif /* CONFIG_OMX_IMG */
+ }
+ return OMX_VIDEO_CodingUnused;
+}
+
+static void omx_codec_set_output_format(OMXCodecContext *ctx)
+{
+ AVCodecContext *avctx = ctx->avctx;
+
+#if CONFIG_OMX_IMG
+ if (avctx->pix_fmt == AV_PIX_FMT_NONE)
+ avctx->pix_fmt = AV_PIX_FMT_YUV420P;
+
+ ctx->decoder_pix_fmt =
+ omx_to_av_pix_fmt(ctx->out.port_def.format.video.eColorFormat);
+ if (ctx->decoder_pix_fmt != AV_PIX_FMT_NONE) {
+ if (ctx->decoder_pix_fmt != avctx->pix_fmt) {
+ /* prepare pixel formats converter, if decoder and requested
+ output formats are not the same */
+ ctx->sws_ctx = sws_getCachedContext(ctx->sws_ctx,
+ avctx->width, avctx->height, ctx->decoder_pix_fmt,
+ avctx->width, avctx->height, avctx->pix_fmt,
+ 0, NULL, NULL, NULL);
+ if (!ctx->sws_ctx)
+ av_log(avctx, AV_LOG_ERROR,
+ "Can not create pixel formats converter\n");
+ }
+ }
+#else
+ avctx->pix_fmt =
+ omx_to_av_pix_fmt(ctx->out.port_def.format.video.eColorFormat);
+#endif /* CONFIG_OMX_IMG */
+}
+
+static av_cold int omx_port_config(OMXCodecPort *port)
+{
+ OMXCodecContext *ctx = port->ctx;
+ AVCodecContext *avctx = ctx->avctx;
+
+ port->port_def.bEnabled = OMX_TRUE;
+ port->port_def.bPopulated = OMX_FALSE;
+ port->port_def.eDomain = OMX_PortDomainVideo;
+ port->port_def.format.video.pNativeRender = NULL;
+ port->port_def.format.video.bFlagErrorConcealment = OMX_FALSE;
+ port->port_def.format.video.nFrameWidth = avctx->width;
+ port->port_def.format.video.nFrameHeight = avctx->height;
+ if (avctx->framerate.den > 0 && avctx->framerate.num > 0)
+ port->port_def.format.video.xFramerate =
+ (1LL << 16) * avctx->framerate.num / avctx->framerate.den;
+ else if (avctx->pkt_timebase.den > 0 && avctx->pkt_timebase.num > 0)
+ port->port_def.format.video.xFramerate =
+ (1LL << 16) * avctx->pkt_timebase.den / avctx->pkt_timebase.num;
+ else
+ port->port_def.format.video.xFramerate = 0;
+
+ if (port->port_def.eDir == OMX_DirInput) {
+ port->port_def.format.video.nStride = 0;
+ port->port_def.format.video.nSliceHeight = 0;
+ port->port_def.format.video.eCompressionFormat =
+ omx_id_to_coding_type(avctx->codec_id);
+ }
+ else {
+ port->port_def.format.video.nStride = ctx->stride;
+ port->port_def.format.video.nSliceHeight = ctx->plane_size;
+ }
+
+ if (omx_update_port_definition(port, &port->port_def) != OMX_ErrorNone)
+ return -1;
+ port->num_buffers = port->port_def.nBufferCountActual;
+ if (port->port_def.eDir == OMX_DirOutput) {
+ ctx->stride = port->port_def.format.video.nStride;
+ ctx->plane_size = port->port_def.format.video.nSliceHeight;
+ omx_codec_set_output_format(ctx);
+ }
+
+ return 0;
+}
+
+static av_cold int omx_component_init(OMXCodecContext *ctx, const char *role)
+{
+ AVCodecContext *avctx = ctx->avctx;
+ OMX_PARAM_COMPONENTROLETYPE role_params = { 0 };
+ OMX_PORT_PARAM_TYPE video_port_params = { 0 };
+ OMX_ERRORTYPE err;
+ int i;
+
+ err = ctx->core->pGetHandle(&ctx->handle, ctx->component_name, ctx,
+ (OMX_CALLBACKTYPE*) &omx_callbacks);
+ if (err != OMX_ErrorNone) {
+ av_log(avctx, AV_LOG_ERROR, "Can not get component handle: %s\n",
+ omx_error_string(err));
+ return -1;
+ }
+
+ OMX_INIT_STRUCT(&role_params);
+ av_strlcpy(role_params.cRole, role, sizeof(role_params.cRole));
+ OMX_SetParameter(ctx->handle, OMX_IndexParamStandardComponentRole,
+ &role_params);
+
+ OMX_INIT_STRUCT(&video_port_params);
+ err = OMX_GetParameter(ctx->handle, OMX_IndexParamVideoInit,
+ &video_port_params);
+ if (err != OMX_ErrorNone) {
+ av_log(avctx, AV_LOG_ERROR, "Can not get component ports: %s\n",
+ omx_error_string(err));
+ return -1;
+ }
+
+ for (i = 0; i < video_port_params.nPorts; i++) {
+ int port = video_port_params.nStartPortNumber + i;
+ OMX_PARAM_PORTDEFINITIONTYPE port_def = { 0 };
+
+ OMX_INIT_STRUCT(&port_def);
+ port_def.nPortIndex = port;
+ err = OMX_GetParameter(ctx->handle, OMX_IndexParamPortDefinition,
+ &port_def);
+ if (err != OMX_ErrorNone) {
+ av_log(avctx, AV_LOG_WARNING,
+ "Can not get port %d definition: %s\n", port,
+ omx_error_string(err));
+ continue;
+ }
+ if (port_def.eDir == OMX_DirInput && ctx->in.index < 0) {
+ ctx->in.index = port;
+ ctx->in.port_def = port_def;
+ } else if (port_def.eDir == OMX_DirOutput && ctx->out.index < 0) {
+ ctx->out.index = port;
+ ctx->out.port_def = port_def;
+ }
+ }
+ if (ctx->in.index < 0 || ctx->out.index < 0) {
+ av_log(avctx, AV_LOG_ERROR, "No in or out port found (in %d out %d)\n",
+ ctx->in.index, ctx->out.index);
+ return -1;
+ }
+
+ // try to set output port default color format to avctx->pix_fmt
+ omx_codec_select_color_format(ctx);
+
+#if CONFIG_OMX_IMG
+ /* The following piece of code is to pass the information to OMX AVC or
+ HEVC component that the CodecConfig data and Picture Data is NAL Size
+ Delimited and will not contain NAL start codes(SCP- 0x00000001) */
+ if (avctx->codec_id == AV_CODEC_ID_H264 ||
+ avctx->codec_id == AV_CODEC_ID_HEVC) {
+ OMX_SetConfig(ctx->handle, OMX_IndexImgDataIsNALSizeDelimited,
+ NULL);
+ }
+#endif /* CONFIG_OMX_IMG */
+
+ if (omx_port_config(&ctx->in) < 0)
+ return -1;
+ if (omx_port_config(&ctx->out) < 0)
+ return -1;
+
+ return 0;
+}
+
+static int omx_port_buffers_alloc(OMXCodecPort *port)
+{
+ OMXCodecContext *ctx = port->ctx;
+ AVCodecContext *avctx = ctx->avctx;
+ int i, err = OMX_ErrorNone;
+
+ for (i = 0; i < port->num_buffers && err == OMX_ErrorNone; i++) {
+ OMXBufferHeader *h;
+
+ h = av_mallocz(sizeof(*h));
+ if (!h) {
+ av_log(avctx, AV_LOG_ERROR,
+ "Port %d buffer allocation error: Not enough memory\n",
+ port->index);
+ return -1;
+ }
+ if (port->port_def.eDir == OMX_DirInput) {
+#if CONFIG_OMX_IMG
+ /* hack: IMG implementation of OMX_UseBuffer returns error
+ if pBuffer is NULL */
+ err = OMX_UseBuffer(ctx->handle, &h->header, port->index,
+ h, port->port_def.nBufferSize, (OMX_U8 *) 1);
+ if (h->header)
+ h->header->pBuffer = NULL;
+#else
+ err = OMX_UseBuffer(ctx->handle, &h->header, port->index,
+ h, port->port_def.nBufferSize, NULL);
+#endif /* CONFIG_OMX_IMG */
+ }
+ else
+ err = OMX_AllocateBuffer(ctx->handle, &h->header, port->index,
+ h, port->port_def.nBufferSize);
+ if (err != OMX_ErrorNone) {
+ av_log(avctx, AV_LOG_ERROR, "Port %d buffer allocation error: %s\n",
+ port->index, omx_error_string(err));
+ av_free(h);
+ return -1;
+ }
+ h->port = port;
+ h->next = port->headers;
+ port->headers = h;
+ atomic_fetch_add(&port->num_headers, 1);
+ }
+
+ return 0;
+}
+
+static av_cold int omx_wait_for_state(OMXCodecContext *ctx, OMX_STATETYPE state)
+{
+ struct timespec ts;
+ int ret = 0;
+
+ pthread_mutex_lock(&ctx->state_mutex);
+ ctx->error = OMX_ErrorNone;
+ clock_gettime(CLOCK_REALTIME, &ts);
+ ts.tv_sec += OMX_STATE_TIMEOUT;
+ while (ctx->state != state && ctx->error == OMX_ErrorNone && ret == 0)
+ ret = pthread_cond_timedwait(&ctx->state_cond, &ctx->state_mutex, &ts);
+ if (ctx->error != OMX_ErrorNone || ret != 0)
+ ret = -1;
+ pthread_mutex_unlock(&ctx->state_mutex);
+ return ret;
+}
+
+static av_cold const char *omx_id_to_role(enum AVCodecID id)
+{
+ switch (id) {
+ case AV_CODEC_ID_H264:
+ return OMX_ROLE_VIDEO_DECODER_AVC;
+ case AV_CODEC_ID_HEVC:
+ return OMX_ROLE_VIDEO_DECODER_HEVC;
+ case AV_CODEC_ID_MPEG4:
+ return OMX_ROLE_VIDEO_DECODER_MPEG4;
+ case AV_CODEC_ID_H263:
+ return OMX_ROLE_VIDEO_DECODER_H263;
+ case AV_CODEC_ID_MPEG2VIDEO:
+ return OMX_ROLE_VIDEO_DECODER_MPEG2;
+ case AV_CODEC_ID_MJPEG:
+ return "video_decoder.mjpeg";
+ case AV_CODEC_ID_VP8:
+ return OMX_ROLE_VIDEO_DECODER_VP8;
+ case AV_CODEC_ID_WMV3:
+ return OMX_ROLE_VIDEO_DECODER_WMV;
+ case AV_CODEC_ID_RV30:
+ case AV_CODEC_ID_RV40:
+ return OMX_ROLE_VIDEO_DECODER_RV;
+#if CONFIG_OMX_IMG
+ case AV_CODEC_ID_VC1:
+ return OMX_ROLE_VIDEO_DECODER_VC1;
+ case AV_CODEC_ID_FLV1:
+ return OMX_ROLE_VIDEO_DECODER_SORENSON;
+ case AV_CODEC_ID_VP6:
+ case AV_CODEC_ID_VP6F:
+ case AV_CODEC_ID_VP6A:
+ return OMX_ROLE_VIDEO_DECODER_VP6;
+ case AV_CODEC_ID_AVS:
+ return "video_decoder.avs";
+#endif /* CONFIG_OMX_IMG */
+ }
+ return NULL;
+}
+
+static av_cold int omx_decode_init(AVCodecContext *avctx)
+{
+ OMXCodecContext *ctx = avctx->priv_data;
+ const char *role;
+ OMX_ERRORTYPE err;
+
+ role = omx_id_to_role(avctx->codec_id);
+ if (!role) {
+ av_log(avctx, AV_LOG_ERROR, "Unsupported codec id %d\n",
+ avctx->codec_id);
+ return AVERROR_DECODER_NOT_FOUND;
+ }
+
+ ctx->core = omx_core_init(avctx, ctx->libname);
+ if (!ctx->core)
+ return AVERROR_DECODER_NOT_FOUND;
+
+ ctx->avctx = avctx;
+
+ omx_port_init(ctx, &ctx->in);
+ omx_port_init(ctx, &ctx->out);
+ pthread_mutex_init(&ctx->out_queue_mutex, NULL);
+ pthread_cond_init(&ctx->out_queue_cond, NULL);
+
+ pthread_mutex_init(&ctx->state_mutex, NULL);
+ pthread_cond_init(&ctx->state_cond, NULL);
+
+ ctx->state = OMX_StateLoaded;
+ ctx->error = OMX_ErrorNone;
+
+#if CONFIG_OMX_IMG
+ err = ctx->core->pComponentOfRoleEnum((OMX_STRING) ctx->component_name,
+ (OMX_STRING) role, 0);
+ if (err != OMX_ErrorNone) {
+ av_log(avctx, AV_LOG_ERROR, "No component for role %s found: %s\n",
+ role, omx_error_string(err));
+ return AVERROR_DECODER_NOT_FOUND;
+ }
+#else
+ if (omx_component_find(ctx, role,
+ ctx->component_name,
+ sizeof(ctx->component_name)) < 0)
+ return AVERROR_DECODER_NOT_FOUND;
+#endif /* CONFIG_OMX_IMG */
+
+ av_log(avctx, AV_LOG_INFO, "Using %s\n", ctx->component_name);
+
+ if (omx_component_init(ctx, role) < 0)
+ return AVERROR_DECODER_NOT_FOUND;
+
+ err = OMX_SendCommand(ctx->handle, OMX_CommandStateSet, OMX_StateIdle,
+ NULL);
+ if (err != OMX_ErrorNone) {
+ av_log(ctx->avctx, AV_LOG_ERROR, "Set StateIdle error: %s\n",
+ omx_error_string(err));
+ return AVERROR_UNKNOWN;
+ }
+ if (omx_port_buffers_alloc(&ctx->in) < 0)
+ return AVERROR_UNKNOWN;
+ if (omx_port_buffers_alloc(&ctx->out) < 0)
+ return AVERROR_UNKNOWN;
+ if (omx_wait_for_state(ctx, OMX_StateIdle) < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Did not get StateIdle\n");
+ return AVERROR_UNKNOWN;
+ }
+ err = OMX_SendCommand(ctx->handle, OMX_CommandStateSet, OMX_StateExecuting,
+ NULL);
+ if (err != OMX_ErrorNone) {
+ av_log(ctx->avctx, AV_LOG_ERROR, "Set StateExecuting error: %s\n",
+ omx_error_string(err));
+ return AVERROR_UNKNOWN;
+ }
+ if (omx_wait_for_state(ctx, OMX_StateExecuting) < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Did not get StateExecuting\n");
+ return AVERROR_UNKNOWN;
+ }
+
+ return 0;
+}
+
+static inline int64_t from_pts(AVRational timebase, int64_t value)
+{
+ if (value != AV_NOPTS_VALUE) {
+ if (timebase.num > 0 && timebase.den > 0)
+ return av_rescale_q(value, timebase, AV_TIME_BASE_Q);
+ else
+ return value;
+ }
+ return 0;
+}
+
+static inline int64_t to_pts(AVRational timebase, int64_t value)
+{
+ if (timebase.num > 0 && timebase.den > 0)
+ return av_rescale_q(value, AV_TIME_BASE_Q, timebase);
+ return value;
+}
+
+static int omx_add_packet(OMXCodecContext *ctx, AVPacket *avpkt,
+ int is_extradata)
+{
+ AVCodecContext *avctx = ctx->avctx;
+ AVBufferRef *buf = NULL;
+ int size = 0;
+ uint8_t *data = NULL;
+ int ret = 0;
+
+ if (avpkt->size) {
+ if (avpkt->buf) {
+ buf = av_buffer_ref(avpkt->buf);
+ size = avpkt->size;
+ data = avpkt->data;
+ } else {
+ buf = av_buffer_alloc(avpkt->size);
+ if (buf) {
+ memcpy(buf->data, avpkt->data, buf->size);
+ size = buf->size;
+ data = buf->data;
+ }
+ }
+ if (!buf) {
+ av_log(avctx, AV_LOG_ERROR,
+ "Input queue add package error: Not enough memory\n");
+ ret = AVERROR(ENOMEM);
+ goto done;
+ }
+ }
+ else if (ctx->eos_sent)
+ goto done;
+
+ do {
+ OMXInputBuffer *buffer;
+
+ buffer = av_mallocz(sizeof(*buffer));
+ if (!buffer) {
+ av_log(avctx, AV_LOG_ERROR,
+ "Input queue add package error: Not enough memory\n");
+ ret = AVERROR(ENOMEM);
+ goto done;
+ }
+
+ buffer->data = data;
+ buffer->size = FFMIN(size, ctx->in.port_def.nBufferSize);
+ buffer->pts = avpkt->pts;
+
+ if (is_extradata)
+ buffer->flags |= OMX_BUFFERFLAG_CODECCONFIG;
+
+ data += buffer->size;
+ size -= buffer->size;
+
+ if (!size)
+ buffer->flags |= OMX_BUFFERFLAG_ENDOFFRAME;
+
+ if (!buffer->size) {
+ buffer->flags |= OMX_BUFFERFLAG_EOS;
+ ctx->eos_sent = 1;
+ }
+
+ if (buf) {
+ buffer->ref = av_buffer_ref(buf);
+ if (!buffer->ref) {
+ av_log(avctx, AV_LOG_ERROR,
+ "Input queue add package error: Not enough memory\n");
+ av_free(buffer);
+ ret = AVERROR(ENOMEM);
+ goto done;
+ }
+ }
+
+ // add buffer to input queue
+ if (!ctx->in_queue_head)
+ ctx->in_queue_head = buffer;
+ if (ctx->in_queue_tail)
+ ctx->in_queue_tail->next = buffer;
+ ctx->in_queue_tail = buffer;
+ ctx->in_queue_size++;
+ } while (size);
+
+done:
+ av_buffer_unref(&buf);
+ return ret;
+}
+
+static int omx_fill_output_port(OMXCodecContext *ctx)
+{
+ OMXCodecPort *port = &ctx->out;
+ OMXBufferHeader *h;
+ int ret = 0;
+
+ if (ctx->settings_changed)
+ return 0;
+
+ pthread_mutex_lock(&port->mutex);
+ while ((h = port->headers)) {
+ OMX_ERRORTYPE err;
+
+ // prepare buffer header
+ h->decoding = 1;
+ // remove buffer header from pool
+ port->headers = h->next;
+ atomic_fetch_add(&port->num_headers, -1);
+ /* deadlock could happens if FillThisBuffer called locked
+ when FillBufferDone is waiting for lock */
+ pthread_mutex_unlock(&port->mutex);
+ err = OMX_FillThisBuffer(ctx->handle, h->header);
+ pthread_mutex_lock(&port->mutex);
+ if (err != OMX_ErrorNone) {
+ omx_buffer_release(h);
+ ret = AVERROR_UNKNOWN;
+ av_log(ctx->avctx, AV_LOG_ERROR, "FillThisBuffer error: %s\n",
+ omx_error_string(err));
+ break;
+ }
+ }
+ pthread_mutex_unlock(&port->mutex);
+ return ret;
+}
+
+static int omx_fill_input_port(OMXCodecContext *ctx)
+{
+ AVCodecContext *avctx = ctx->avctx;
+ OMXCodecPort *port = &ctx->in;
+ OMXInputBuffer *buffer;
+
+ if (ctx->settings_changed)
+ return 0;
+
+ while ((buffer = ctx->in_queue_head)) {
+ OMXBufferHeader *h;
+ OMX_ERRORTYPE err;
+
+ pthread_mutex_lock(&port->mutex);
+ h = port->headers;
+ if (!h) {
+ pthread_mutex_unlock(&port->mutex);
+ return 0;
+ }
+ // prepare buffer header
+ h->priv = buffer;
+ h->header->pBuffer = buffer->data;
+ h->header->nOffset = 0;
+ h->header->nFilledLen = buffer->size;
+ h->header->nTimeStamp = to_omx_ticks(from_pts(avctx->pkt_timebase,
+ buffer->pts));
+ h->header->nFlags = buffer->flags;
+ h->decoding = 1;
+ // remove buffer header from pool
+ port->headers = h->next;
+ atomic_fetch_add(&port->num_headers, -1);
+ // remove buffer from input queue
+ ctx->in_queue_head = buffer->next;
+ if (ctx->in_queue_tail == buffer)
+ ctx->in_queue_tail = NULL;
+ ctx->in_queue_size--;
+ /* deadlock could happens if EmptyThisBuffer called locked
+ when EmptyBufferDone is waiting for lock */
+ pthread_mutex_unlock(&port->mutex);
+ err = OMX_EmptyThisBuffer(ctx->handle, h->header);
+ if (err != OMX_ErrorNone) {
+ pthread_mutex_lock(&port->mutex);
+ omx_buffer_release(h);
+ pthread_mutex_unlock(&port->mutex);
+ av_log(avctx, AV_LOG_ERROR, "EmptyThisBuffer error: %s\n",
+ omx_error_string(err));
+ return AVERROR_UNKNOWN;
+ }
+ }
+ return 0;
+}
+
+static OMXBufferHeader *omx_get_output(OMXCodecContext *ctx, int wait)
+{
+ OMXBufferHeader *h = NULL;
+ int ret = 0;
+
+ pthread_mutex_lock(&ctx->out_queue_mutex);
+ if (wait) {
+ struct timespec ts;
+
+ clock_gettime(CLOCK_REALTIME, &ts);
+ ts.tv_sec += OMX_OUTPUT_TIMEOUT;
+ /* Waiting until output buffer available or output port settings changed
+ or input port buffer available or timeout occured */
+ while (!ctx->out_queue_head && !ctx->settings_changed &&
+ atomic_load(&ctx->in.num_headers) == 0 && ret == 0)
+ ret = pthread_cond_timedwait(&ctx->out_queue_cond,
+ &ctx->out_queue_mutex, &ts);
+ }
+ if (ret == 0 && !ctx->settings_changed && (h = ctx->out_queue_head)) {
+ ctx->out_queue_head = h->next;
+ if (ctx->out_queue_tail == h)
+ ctx->out_queue_tail = NULL;
+ ctx->out_queue_size--;
+ }
+ pthread_mutex_unlock(&ctx->out_queue_mutex);
+
+ return h;
+}
+
+static int omx_read_frame(OMXCodecContext *ctx, AVFrame *frame, int *got_frame)
+{
+ AVCodecContext *avctx = ctx->avctx;
+ OMXCodecPort *port = &ctx->out;
+ int ret = 0;
+
+ while (!*got_frame && ret == 0 && !ctx->eos_received) {
+ OMXBufferHeader *h;
+ int wait = ctx->eos_sent ||
+ ctx->in_queue_size >= OMX_INPUT_QUEUE_THRESHOLD;
+ int eof;
+
+ // if flushing or input queue exceeded, try blocking wait
+ h = omx_get_output(ctx, wait);
+ if (!h) {
+ if (wait && !ctx->settings_changed &&
+ atomic_load(&ctx->in.num_headers) == 0) {
+ av_log(avctx, AV_LOG_VERBOSE, "Output data timeout\n");
+ ret = AVERROR_UNKNOWN;
+ }
+ break;
+ }
+
+#if CONFIG_OMX_IMG
+ eof = 1;
+#else
+ eof = h->header->nFlags & OMX_BUFFERFLAG_ENDOFFRAME;
+#endif /* CONFIG_OMX_IMG */
+
+ if (h->header->nFlags & OMX_BUFFERFLAG_EOS) {
+ ctx->eos_received = 1;
+ }
+
+#if !CONFIG_OMX_IMG
+ if (h->header->nFilledLen > 0 && (ctx->output_buf || !eof)) {
+ if ((ret = av_reallocp(&ctx->output_buf,
+ ctx->output_buf_size +
+ h->header->nFilledLen)) < 0) {
+ ctx->output_buf_size = 0;
+ av_log(avctx, AV_LOG_ERROR,
+ "Output buffer allocation error: %d\n", ret);
+ goto end;
+ }
+ memcpy(ctx->output_buf + ctx->output_buf_size,
+ h->header->pBuffer + h->header->nOffset,
+ h->header->nFilledLen);
+ ctx->output_buf_size += h->header->nFilledLen;
+ }
+#endif /* !CONFIG_OMX_IMG */
+
+ if (eof) {
+ uint8_t *buf = NULL;
+ int len = 0;
+ uint8_t *src[4];
+ int linesize[4];
+
+#if !CONFIG_OMX_IMG
+ if (ctx->output_buf) {
+ buf = ctx->output_buf;
+ len = ctx->output_buf_size;
+ }
+ else
+#endif /* !CONFIG_OMX_IMG */
+ if (h->header->nFilledLen > 0) {
+ buf = h->header->pBuffer + h->header->nOffset;
+ len = h->header->nFilledLen;
+ }
+
+ if (!buf || len == 0) {
+ goto end;
+ }
+
+ if ((ret = ff_get_buffer(avctx, frame, 0)) == 0) {
+ av_image_fill_arrays(src, linesize, buf,
+#if CONFIG_OMX_IMG
+ ctx->decoder_pix_fmt,
+#else
+ avctx->pix_fmt,
+#endif /* CONFIG_OMX_IMG */
+ ctx->stride, ctx->plane_size, 1);
+#if CONFIG_OMX_IMG
+ if (ctx->sws_ctx)
+ sws_scale(ctx->sws_ctx, (const uint8_t **) src, linesize,
+ 0, avctx->height, frame->data, frame->linesize);
+ else
+#endif /* CONFIG_OMX_IMG */
+ av_image_copy(frame->data, frame->linesize,
+ (const uint8_t **) src, linesize,
+ avctx->pix_fmt, avctx->width, avctx->height);
+
+ frame->pts = to_pts(avctx->pkt_timebase,
+ from_omx_ticks(h->header->nTimeStamp));
+#if FF_API_PKT_PTS
+FF_DISABLE_DEPRECATION_WARNINGS
+ frame->pkt_pts = frame->pts;
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
+ frame->pkt_dts = AV_NOPTS_VALUE;
+
+ *got_frame = 1;
+ }
+ else
+ av_log(avctx, AV_LOG_ERROR,
+ "Frame buffer allocation error: %d\n", ret);
+#if !CONFIG_OMX_IMG
+ av_freep(&ctx->output_buf);
+ ctx->output_buf_size = 0;
+#endif /* !CONFIG_OMX_IMG */
+ }
+end:
+ pthread_mutex_lock(&port->mutex);
+ h->next = port->headers;
+ port->headers = h;
+ atomic_fetch_add(&port->num_headers, 1);
+ pthread_mutex_unlock(&port->mutex);
+ }
+
+ return ret;
+}
+
+static void omx_port_free(OMXCodecPort *port)
+{
+ OMXBufferHeader *h;
+
+ while ((h = port->headers)) {
+ port->headers = h->next;
+ atomic_fetch_add(&port->num_headers, -1);
+ port->num_buffers--;
+ OMX_FreeBuffer(port->ctx->handle, port->index, h->header);
+ av_free(h);
+ }
+}
+
+static av_cold int omx_wait_port_state(OMXCodecPort *port, int enabled)
+{
+ OMXCodecContext *ctx = port->ctx;
+ struct timespec ts;
+ int ret = 0;
+
+ pthread_mutex_lock(&ctx->state_mutex);
+ ctx->error = OMX_ErrorNone;
+ clock_gettime(CLOCK_REALTIME, &ts);
+ ts.tv_sec += OMX_STATE_TIMEOUT;
+ omx_update_port_definition(port, NULL);
+ while (!!port->port_def.bEnabled != !!enabled &&
+ ctx->error == OMX_ErrorNone && ret == 0) {
+ ret = pthread_cond_timedwait(&ctx->state_cond, &ctx->state_mutex, &ts);
+ omx_update_port_definition(port, NULL);
+ }
+ if (ctx->error != OMX_ErrorNone || ret != 0)
+ ret = -1;
+ pthread_mutex_unlock(&ctx->state_mutex);
+ return ret;
+}
+
+static int omx_change_settings(OMXCodecContext *ctx)
+{
+ AVCodecContext *avctx = ctx->avctx;
+ OMXCodecPort *port = &ctx->out;
+ int width, height;
+#if CONFIG_OMX_IMG
+ OMX_CONFIG_RECTTYPE crop_rect;
+#endif /* CONFIG_OMX_IMG */
+ OMX_ERRORTYPE err;
+
+ /* For decoder we dealing with output port settings only */
+
+ // disable port
+ omx_update_port_definition(port, NULL);
+ if (port->port_def.bEnabled) {
+ err = OMX_SendCommand(ctx->handle, OMX_CommandPortDisable, port->index,
+ NULL);
+ if (err != OMX_ErrorNone) {
+ av_log(avctx, AV_LOG_ERROR, "Port %d disable error: %s\n",
+ port->index, omx_error_string(err));
+ return AVERROR_UNKNOWN;
+ }
+ }
+ // deallocate port buffers
+ pthread_mutex_lock(&port->mutex);
+ omx_port_free(port);
+ pthread_mutex_unlock(&port->mutex);
+ while (port->num_buffers > 0) {
+ OMXBufferHeader *h;
+
+ h = omx_get_output(ctx, 1);
+ if (!h) {
+ av_log(avctx, AV_LOG_VERBOSE, "Output data timeout\n");
+ break;
+ }
+ port->num_buffers--;
+ OMX_FreeBuffer(ctx->handle, port->index, h->header);
+ av_free(h);
+ }
+ // wait for port disabled
+ if (omx_wait_port_state(port, 0) < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Port %d not disabled\n", port->index);
+ return AVERROR_UNKNOWN;
+ }
+ // update port config
+ omx_codec_select_color_format(ctx);
+ if (omx_update_port_definition(port, &port->port_def) != OMX_ErrorNone)
+ return AVERROR_UNKNOWN;
+ port->num_buffers = port->port_def.nBufferCountActual;
+ ctx->stride = port->port_def.format.video.nStride;
+ ctx->plane_size = port->port_def.format.video.nSliceHeight;
+ width = port->port_def.format.video.nFrameWidth;
+ height = port->port_def.format.video.nFrameHeight;
+#if CONFIG_OMX_IMG
+ OMX_INIT_STRUCT(&crop_rect);
+ err = OMX_GetConfig(ctx->handle, OMX_IndexConfigCommonOutputCrop,
+ &crop_rect);
+ if (err == OMX_ErrorNone) {
+ width = crop_rect.nWidth;
+ height = crop_rect.nHeight;
+ }
+ else
+ av_log(avctx, AV_LOG_WARNING,
+ "Can not get output port crop rectangle: %s\n",
+ omx_error_string(err));
+#endif /* CONFIG_OMX_IMG */
+ if (ff_set_dimensions(avctx, width, height) < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Can not set frame dimensions\n");
+ return AVERROR_UNKNOWN;
+ }
+ omx_codec_set_output_format(ctx);
+ if (avctx->pix_fmt == AV_PIX_FMT_NONE) {
+ av_log(avctx, AV_LOG_ERROR, "Undefined output pixel format\n");
+ return -1;
+ }
+ // enable port
+ if (!port->port_def.bEnabled) {
+ err = OMX_SendCommand(ctx->handle, OMX_CommandPortEnable, port->index,
+ NULL);
+ if (err != OMX_ErrorNone) {
+ av_log(avctx, AV_LOG_ERROR, "Port %d enable error: %s\n",
+ port->index, omx_error_string(err));
+ return AVERROR_UNKNOWN;
+ }
+ }
+ // allocate port buffers
+ if (omx_port_buffers_alloc(port) < 0)
+ return AVERROR_UNKNOWN;
+ // wait for port enabled
+ if (omx_wait_port_state(port, 1) < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Port %d not enabled\n", port->index);
+ return AVERROR_UNKNOWN;
+ }
+ return 0;
+}
+
+static int omx_decode(AVCodecContext *avctx, void *data, int *got_frame,
+ AVPacket *avpkt)
+{
+ OMXCodecContext *ctx = avctx->priv_data;
+ AVFrame *frame = data;
+ int ret = 0;
+
+ if (avctx->extradata_size && !ctx->extradata_sent) {
+ AVPacket pkt = {0};
+
+ av_init_packet(&pkt);
+ pkt.data = avctx->extradata;
+ pkt.size = avctx->extradata_size;
+ ctx->extradata_sent = 1;
+ if ((ret = omx_add_packet(ctx, &pkt, 1)) < 0)
+ return ret;
+ }
+
+ if ((ret = omx_add_packet(ctx, avpkt, 0)) < 0)
+ return ret;
+
+ if ((ret = omx_fill_output_port(ctx)) < 0)
+ return ret;
+
+ if ((ret = omx_fill_input_port(ctx)) < 0)
+ return ret;
+
+ if ((ret = omx_read_frame(ctx, frame, got_frame)) < 0)
+ return ret;
+
+ if (ctx->settings_changed) {
+ ctx->settings_changed = 0;
+ if ((ret = omx_change_settings(ctx)) < 0)
+ return ret;
+ }
+
+ if ((ret = omx_fill_output_port(ctx)) < 0)
+ return ret;
+
+ if ((ret = omx_fill_input_port(ctx)) < 0)
+ return ret;
+
+ return 0;
+}
+
+static int omx_wait_flushed(OMXCodecContext *ctx)
+{
+ struct timespec ts;
+ int ret = 0;
+
+ pthread_mutex_lock(&ctx->state_mutex);
+ ctx->error = OMX_ErrorNone;
+ clock_gettime(CLOCK_REALTIME, &ts);
+ ts.tv_sec += OMX_STATE_TIMEOUT;
+ while (ctx->flushing && ctx->error == OMX_ErrorNone && ret == 0) {
+ ret = pthread_cond_timedwait(&ctx->state_cond, &ctx->state_mutex, &ts);
+ }
+ if (ctx->error != OMX_ErrorNone || ret != 0)
+ ret = -1;
+ pthread_mutex_unlock(&ctx->state_mutex);
+ return ret;
+}
+
+static void omx_input_queue_free(OMXCodecContext *ctx)
+{
+ OMXInputBuffer *buffer;
+
+ while ((buffer = ctx->in_queue_head)) {
+ ctx->in_queue_head = buffer->next;
+ if (ctx->in_queue_tail == buffer)
+ ctx->in_queue_tail = NULL;
+ ctx->in_queue_size--;
+ av_buffer_unref(&buffer->ref);
+ av_free(buffer);
+ }
+}
+
+static void omx_flush(AVCodecContext *avctx)
+{
+ OMXCodecContext *ctx = avctx->priv_data;
+ OMXBufferHeader *h;
+ OMX_STATETYPE state;
+ OMX_ERRORTYPE err;
+
+ pthread_mutex_lock(&ctx->state_mutex);
+ state = ctx->state;
+ pthread_mutex_unlock(&ctx->state_mutex);
+
+ // pause component
+ if (state == OMX_StateExecuting) {
+ err = OMX_SendCommand(ctx->handle, OMX_CommandStateSet,
+ OMX_StatePause, NULL);
+ if (err != OMX_ErrorNone)
+ av_log(ctx->avctx, AV_LOG_ERROR, "Set StatePause error: %s\n",
+ omx_error_string(err));
+ }
+ // input queue free
+ omx_input_queue_free(ctx);
+ ctx->in_queue_head = ctx->in_queue_tail = NULL;
+ ctx->in_queue_size = 0;
+ // flush input port
+ ctx->flushing = 1;
+ err = OMX_SendCommand(ctx->handle, OMX_CommandFlush, ctx->in.index, NULL);
+ if (err != OMX_ErrorNone) {
+ av_log(avctx, AV_LOG_ERROR, "Input port flush error: %s\n",
+ omx_error_string(err));
+ ctx->flushing = 0;
+ }
+ if (omx_wait_flushed(ctx) < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Input port not flushed\n");
+ ctx->flushing = 0;
+ }
+ // flush output port
+ ctx->flushing = 1;
+ err = OMX_SendCommand(ctx->handle, OMX_CommandFlush, ctx->out.index, NULL);
+ if (err != OMX_ErrorNone) {
+ av_log(avctx, AV_LOG_ERROR, "Output port flush error: %s\n",
+ omx_error_string(err));
+ ctx->flushing = 0;
+ }
+ if (omx_wait_flushed(ctx) < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Output port not flushed\n");
+ ctx->flushing = 0;
+ }
+ // output queue free
+ pthread_mutex_lock(&ctx->out.mutex);
+ pthread_mutex_lock(&ctx->out_queue_mutex);
+ while ((h = ctx->out_queue_head)) {
+ ctx->out_queue_head = h->next;
+ if (ctx->out_queue_tail == h)
+ ctx->out_queue_tail = NULL;
+ ctx->out_queue_size--;
+ h->next = ctx->out.headers;
+ ctx->out.headers = h;
+ atomic_fetch_add(&ctx->out.num_headers, 1);
+ }
+ ctx->out_queue_head = ctx->out_queue_tail = NULL;
+ ctx->out_queue_size = 0;
+ pthread_mutex_unlock(&ctx->out_queue_mutex);
+ pthread_mutex_unlock(&ctx->out.mutex);
+ // resume component
+ err = OMX_SendCommand(ctx->handle, OMX_CommandStateSet, OMX_StateExecuting,
+ NULL);
+ if (err != OMX_ErrorNone)
+ av_log(ctx->avctx, AV_LOG_ERROR, "Set StateExecuting error: %s\n",
+ omx_error_string(err));
+ // reset EOS flag
+ ctx->eos_sent = ctx->eos_received = 0;
+ // fill output port
+ omx_fill_output_port(ctx);
+}
+
+static av_cold void omx_port_destroy(OMXCodecPort *port)
+{
+ pthread_mutex_destroy(&port->mutex);
+ port->num_buffers = 0;
+ atomic_store(&port->num_headers, 0);
+ port->headers = NULL;
+}
+
+static av_cold void omx_output_queue_free(OMXCodecContext *ctx)
+{
+ OMXBufferHeader *h;
+
+ while ((h = ctx->out_queue_head)) {
+ ctx->out_queue_head = h->next;
+ if (ctx->out_queue_tail == h)
+ ctx->out_queue_tail = NULL;
+ ctx->out_queue_size--;
+ ctx->out.num_buffers--;
+ OMX_FreeBuffer(ctx->handle, ctx->out.index, h->header);
+ av_free(h);
+ }
+}
+
+static av_cold void omx_decode_stop(OMXCodecContext *ctx)
+{
+ omx_port_free(&ctx->in);
+ omx_input_queue_free(ctx);
+ omx_port_free(&ctx->out);
+ omx_output_queue_free(ctx);
+}
+
+static av_cold int omx_decode_close(AVCodecContext *avctx)
+{
+ OMXCodecContext *ctx = avctx->priv_data;
+ OMX_STATETYPE state;
+
+ pthread_mutex_lock(&ctx->state_mutex);
+ state = ctx->state;
+ pthread_mutex_unlock(&ctx->state_mutex);
+
+ if (state > OMX_StateLoaded || state == OMX_StateInvalid) {
+ OMX_ERRORTYPE err;
+
+ if (state > OMX_StateIdle) {
+ err = OMX_SendCommand(ctx->handle, OMX_CommandStateSet,
+ OMX_StateIdle, NULL);
+ if (err != OMX_ErrorNone)
+ av_log(ctx->avctx, AV_LOG_ERROR, "Set StateIdle error: %s\n",
+ omx_error_string(err));
+ if (omx_wait_for_state(ctx, OMX_StateIdle) < 0)
+ av_log(avctx, AV_LOG_ERROR, "Did not get StateIdle\n");
+ }
+ err = OMX_SendCommand(ctx->handle, OMX_CommandStateSet, OMX_StateLoaded,
+ NULL);
+ if (err != OMX_ErrorNone)
+ av_log(ctx->avctx, AV_LOG_ERROR, "Set StateLoaded error: %s\n",
+ omx_error_string(err));
+ omx_decode_stop(ctx);
+ if (omx_wait_for_state(ctx, OMX_StateLoaded) < 0)
+ av_log(avctx, AV_LOG_ERROR, "Did not get StateLoaded\n");
+ }
+
+ if (ctx->handle) {
+ ctx->core->pFreeHandle(ctx->handle);
+ ctx->handle = NULL;
+ }
+
+ omx_core_destroy(ctx->core);
+ ctx->core = NULL;
+
+ pthread_cond_destroy(&ctx->state_cond);
+ pthread_mutex_destroy(&ctx->state_mutex);
+
+ ctx->in_queue_head = ctx->in_queue_tail = NULL;
+ ctx->in_queue_size = 0;
+
+ ctx->out_queue_head = ctx->out_queue_tail = NULL;
+ ctx->out_queue_size = 0;
+ pthread_cond_destroy(&ctx->out_queue_cond);
+ pthread_mutex_destroy(&ctx->out_queue_mutex);
+#if !CONFIG_OMX_IMG
+ av_freep(&ctx->output_buf);
+ ctx->output_buf_size = 0;
+#endif /* !CONFIG_OMX_IMG */
+ ctx->settings_changed = 0;
+#if CONFIG_OMX_IMG
+ sws_freeContext(ctx->sws_ctx);
+ ctx->sws_ctx = NULL;
+ ctx->decoder_pix_fmt = AV_PIX_FMT_NONE;
+#endif /* CONFIG_OMX_IMG */
+
+ omx_port_destroy(&ctx->in);
+ omx_port_destroy(&ctx->out);
+
+ ctx->eos_sent = ctx->eos_received = ctx->extradata_sent = 0;
+
+ return 0;
+}
+
+#define OFFSET(x) offsetof(OMXCodecContext, x)
+#define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
+static const AVOption options[] = {
+ { "omx_libname", "OpenMAX library name", OFFSET(libname),
+ AV_OPT_TYPE_STRING, { 0 }, 0, 0, FLAGS },
+ { NULL }
+};
+
+static const enum AVPixelFormat omx_decoder_pix_fmts[] = {
+ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
+};
+
+#define OMXDEC_CLASS(NAME) \
+ static const AVClass omx_ ## NAME ## _dec_class = { \
+ .class_name = #NAME "_omx_decoder", \
+ .item_name = av_default_item_name, \
+ .option = options, \
+ .version = LIBAVUTIL_VERSION_INT, \
+ };
+
+#define OMXDEC(NAME, LONGNAME, ID) \
+ OMXDEC_CLASS(NAME) \
+ AVCodec ff_ ## NAME ## _omx_decoder = { \
+ .name = #NAME "_omx" , \
+ .long_name = NULL_IF_CONFIG_SMALL("OpenMAX " LONGNAME " decoder"),\
+ .type = AVMEDIA_TYPE_VIDEO, \
+ .id = ID , \
+ .priv_data_size = sizeof(OMXCodecContext), \
+ .init = omx_decode_init, \
+ .decode = omx_decode, \
+ .flush = omx_flush, \
+ .close = omx_decode_close, \
+ .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HARDWARE, \
+ .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | \
+ FF_CODEC_CAP_INIT_CLEANUP, \
+ .pix_fmts = omx_decoder_pix_fmts, \
+ .wrapper_name = "omx", \
+ }
+
+OMXDEC(h264, "H.264", AV_CODEC_ID_H264);
+OMXDEC(hevc, "H.265", AV_CODEC_ID_HEVC);
+OMXDEC(mpeg4, "MPEG4", AV_CODEC_ID_MPEG4);
+OMXDEC(h263, "H.263", AV_CODEC_ID_H263);
+OMXDEC(mpeg2, "MPEG2", AV_CODEC_ID_MPEG2VIDEO);
+OMXDEC(mjpeg, "MJPEG", AV_CODEC_ID_MJPEG);
+OMXDEC(vp8, "VP8", AV_CODEC_ID_VP8);
+OMXDEC(wmv3, "WMV3", AV_CODEC_ID_WMV3);
+OMXDEC(rv30, "RealVideo 3.0", AV_CODEC_ID_RV30);
+OMXDEC(rv40, "RealVideo 4.0", AV_CODEC_ID_RV40);
+#if CONFIG_OMX_IMG
+OMXDEC(vc1, "VC1", AV_CODEC_ID_VC1);
+OMXDEC(sorenson, "Sorenson", AV_CODEC_ID_FLV1);
+OMXDEC(vp6, "VP6", AV_CODEC_ID_VP6);
+OMXDEC(vp6f, "VP6F", AV_CODEC_ID_VP6F);
+OMXDEC(vp6a, "VP6A", AV_CODEC_ID_VP6A);
+OMXDEC(avs, "AVS", AV_CODEC_ID_AVS);
+#endif /* CONFIG_OMX_IMG */
Index: omxenc.c
===================================================================
--- omxenc.c (nonexistent)
+++ omxenc.c (revision 377)
@@ -0,0 +1,988 @@
+/*
+ * OMX Video encoder
+ * Copyright (C) 2011 Martin Storsjo
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "config.h"
+
+#if CONFIG_OMX_RPI
+#define OMX_SKIP64BIT
+#endif
+
+#include <dlfcn.h>
+#include <OMX_Core.h>
+#include <OMX_Component.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+
+#include "libavutil/avstring.h"
+#include "libavutil/avutil.h"
+#include "libavutil/common.h"
+#include "libavutil/imgutils.h"
+#include "libavutil/log.h"
+#include "libavutil/opt.h"
+
+#include "avcodec.h"
+#include "h264.h"
+#include "internal.h"
+
+#ifdef OMX_SKIP64BIT
+static OMX_TICKS to_omx_ticks(int64_t value)
+{
+ OMX_TICKS s;
+ s.nLowPart = value & 0xffffffff;
+ s.nHighPart = value >> 32;
+ return s;
+}
+static int64_t from_omx_ticks(OMX_TICKS value)
+{
+ return (((int64_t)value.nHighPart) << 32) | value.nLowPart;
+}
+#else
+#define to_omx_ticks(x) (x)
+#define from_omx_ticks(x) (x)
+#endif
+
+#define INIT_STRUCT(x) do { \
+ x.nSize = sizeof(x); \
+ x.nVersion = s->version; \
+ } while (0)
+#define CHECK(x) do { \
+ if (x != OMX_ErrorNone) { \
+ av_log(avctx, AV_LOG_ERROR, \
+ "err %x (%d) on line %d\n", x, x, __LINE__); \
+ return AVERROR_UNKNOWN; \
+ } \
+ } while (0)
+
+typedef struct OMXContext {
+ void *lib;
+ void *lib2;
+ OMX_ERRORTYPE (*ptr_Init)(void);
+ OMX_ERRORTYPE (*ptr_Deinit)(void);
+ OMX_ERRORTYPE (*ptr_ComponentNameEnum)(OMX_STRING, OMX_U32, OMX_U32);
+ OMX_ERRORTYPE (*ptr_GetHandle)(OMX_HANDLETYPE*, OMX_STRING, OMX_PTR, OMX_CALLBACKTYPE*);
+ OMX_ERRORTYPE (*ptr_FreeHandle)(OMX_HANDLETYPE);
+ OMX_ERRORTYPE (*ptr_GetComponentsOfRole)(OMX_STRING, OMX_U32*, OMX_U8**);
+ OMX_ERRORTYPE (*ptr_GetRolesOfComponent)(OMX_STRING, OMX_U32*, OMX_U8**);
+ void (*host_init)(void);
+} OMXContext;
+
+static av_cold void *dlsym_prefixed(void *handle, const char *symbol, const char *prefix)
+{
+ char buf[50];
+ snprintf(buf, sizeof(buf), "%s%s", prefix ? prefix : "", symbol);
+ return dlsym(handle, buf);
+}
+
+static av_cold int omx_try_load(OMXContext *s, void *logctx,
+ const char *libname, const char *prefix,
+ const char *libname2)
+{
+ if (libname2) {
+ s->lib2 = dlopen(libname2, RTLD_NOW | RTLD_GLOBAL);
+ if (!s->lib2) {
+ av_log(logctx, AV_LOG_WARNING, "%s not found\n", libname2);
+ return AVERROR_ENCODER_NOT_FOUND;
+ }
+ s->host_init = dlsym(s->lib2, "bcm_host_init");
+ if (!s->host_init) {
+ av_log(logctx, AV_LOG_WARNING, "bcm_host_init not found\n");
+ dlclose(s->lib2);
+ s->lib2 = NULL;
+ return AVERROR_ENCODER_NOT_FOUND;
+ }
+ }
+ s->lib = dlopen(libname, RTLD_NOW | RTLD_GLOBAL);
+ if (!s->lib) {
+ av_log(logctx, AV_LOG_WARNING, "%s not found\n", libname);
+ return AVERROR_ENCODER_NOT_FOUND;
+ }
+ s->ptr_Init = dlsym_prefixed(s->lib, "OMX_Init", prefix);
+ s->ptr_Deinit = dlsym_prefixed(s->lib, "OMX_Deinit", prefix);
+ s->ptr_ComponentNameEnum = dlsym_prefixed(s->lib, "OMX_ComponentNameEnum", prefix);
+ s->ptr_GetHandle = dlsym_prefixed(s->lib, "OMX_GetHandle", prefix);
+ s->ptr_FreeHandle = dlsym_prefixed(s->lib, "OMX_FreeHandle", prefix);
+ s->ptr_GetComponentsOfRole = dlsym_prefixed(s->lib, "OMX_GetComponentsOfRole", prefix);
+ s->ptr_GetRolesOfComponent = dlsym_prefixed(s->lib, "OMX_GetRolesOfComponent", prefix);
+ if (!s->ptr_Init || !s->ptr_Deinit || !s->ptr_ComponentNameEnum ||
+ !s->ptr_GetHandle || !s->ptr_FreeHandle ||
+ !s->ptr_GetComponentsOfRole || !s->ptr_GetRolesOfComponent) {
+ av_log(logctx, AV_LOG_WARNING, "Not all functions found in %s\n", libname);
+ dlclose(s->lib);
+ s->lib = NULL;
+ if (s->lib2)
+ dlclose(s->lib2);
+ s->lib2 = NULL;
+ return AVERROR_ENCODER_NOT_FOUND;
+ }
+ return 0;
+}
+
+static av_cold OMXContext *omx_init(void *logctx, const char *libname, const char *prefix)
+{
+ static const char * const libnames[] = {
+#if CONFIG_OMX_RPI
+ "/opt/vc/lib/libopenmaxil.so", "/opt/vc/lib/libbcm_host.so",
+#else
+ "libOMX_Core.so", NULL,
+ "libOmxCore.so", NULL,
+#endif
+ NULL
+ };
+ const char* const* nameptr;
+ int ret = AVERROR_ENCODER_NOT_FOUND;
+ OMXContext *omx_context;
+
+ omx_context = av_mallocz(sizeof(*omx_context));
+ if (!omx_context)
+ return NULL;
+ if (libname) {
+ ret = omx_try_load(omx_context, logctx, libname, prefix, NULL);
+ if (ret < 0) {
+ av_free(omx_context);
+ return NULL;
+ }
+ } else {
+ for (nameptr = libnames; *nameptr; nameptr += 2)
+ if (!(ret = omx_try_load(omx_context, logctx, nameptr[0], prefix, nameptr[1])))
+ break;
+ if (!*nameptr) {
+ av_free(omx_context);
+ return NULL;
+ }
+ }
+
+ if (omx_context->host_init)
+ omx_context->host_init();
+ omx_context->ptr_Init();
+ return omx_context;
+}
+
+static av_cold void omx_deinit(OMXContext *omx_context)
+{
+ if (!omx_context)
+ return;
+ omx_context->ptr_Deinit();
+ dlclose(omx_context->lib);
+ av_free(omx_context);
+}
+
+typedef struct OMXCodecContext {
+ const AVClass *class;
+ char *libname;
+ char *libprefix;
+ OMXContext *omx_context;
+
+ AVCodecContext *avctx;
+
+ char component_name[OMX_MAX_STRINGNAME_SIZE];
+ OMX_VERSIONTYPE version;
+ OMX_HANDLETYPE handle;
+ int in_port, out_port;
+ OMX_COLOR_FORMATTYPE color_format;
+ int stride, plane_size;
+
+ int num_in_buffers, num_out_buffers;
+ OMX_BUFFERHEADERTYPE **in_buffer_headers;
+ OMX_BUFFERHEADERTYPE **out_buffer_headers;
+ int num_free_in_buffers;
+ OMX_BUFFERHEADERTYPE **free_in_buffers;
+ int num_done_out_buffers;
+ OMX_BUFFERHEADERTYPE **done_out_buffers;
+ pthread_mutex_t input_mutex;
+ pthread_cond_t input_cond;
+ pthread_mutex_t output_mutex;
+ pthread_cond_t output_cond;
+
+ pthread_mutex_t state_mutex;
+ pthread_cond_t state_cond;
+ OMX_STATETYPE state;
+ OMX_ERRORTYPE error;
+
+ int mutex_cond_inited;
+
+ int eos_sent, got_eos;
+
+ uint8_t *output_buf;
+ int output_buf_size;
+
+ int input_zerocopy;
+ int profile;
+} OMXCodecContext;
+
+static void append_buffer(pthread_mutex_t *mutex, pthread_cond_t *cond,
+ int* array_size, OMX_BUFFERHEADERTYPE **array,
+ OMX_BUFFERHEADERTYPE *buffer)
+{
+ pthread_mutex_lock(mutex);
+ array[(*array_size)++] = buffer;
+ pthread_cond_broadcast(cond);
+ pthread_mutex_unlock(mutex);
+}
+
+static OMX_BUFFERHEADERTYPE *get_buffer(pthread_mutex_t *mutex, pthread_cond_t *cond,
+ int* array_size, OMX_BUFFERHEADERTYPE **array,
+ int wait)
+{
+ OMX_BUFFERHEADERTYPE *buffer;
+ pthread_mutex_lock(mutex);
+ if (wait) {
+ while (!*array_size)
+ pthread_cond_wait(cond, mutex);
+ }
+ if (*array_size > 0) {
+ buffer = array[0];
+ (*array_size)--;
+ memmove(&array[0], &array[1], (*array_size) * sizeof(OMX_BUFFERHEADERTYPE*));
+ } else {
+ buffer = NULL;
+ }
+ pthread_mutex_unlock(mutex);
+ return buffer;
+}
+
+static OMX_ERRORTYPE event_handler(OMX_HANDLETYPE component, OMX_PTR app_data, OMX_EVENTTYPE event,
+ OMX_U32 data1, OMX_U32 data2, OMX_PTR event_data)
+{
+ OMXCodecContext *s = app_data;
+ // This uses casts in the printfs, since OMX_U32 actually is a typedef for
+ // unsigned long in official header versions (but there are also modified
+ // versions where it is something else).
+ switch (event) {
+ case OMX_EventError:
+ pthread_mutex_lock(&s->state_mutex);
+ av_log(s->avctx, AV_LOG_ERROR, "OMX error %"PRIx32"\n", (uint32_t) data1);
+ s->error = data1;
+ pthread_cond_broadcast(&s->state_cond);
+ pthread_mutex_unlock(&s->state_mutex);
+ break;
+ case OMX_EventCmdComplete:
+ if (data1 == OMX_CommandStateSet) {
+ pthread_mutex_lock(&s->state_mutex);
+ s->state = data2;
+ av_log(s->avctx, AV_LOG_VERBOSE, "OMX state changed to %"PRIu32"\n", (uint32_t) data2);
+ pthread_cond_broadcast(&s->state_cond);
+ pthread_mutex_unlock(&s->state_mutex);
+ } else if (data1 == OMX_CommandPortDisable) {
+ av_log(s->avctx, AV_LOG_VERBOSE, "OMX port %"PRIu32" disabled\n", (uint32_t) data2);
+ } else if (data1 == OMX_CommandPortEnable) {
+ av_log(s->avctx, AV_LOG_VERBOSE, "OMX port %"PRIu32" enabled\n", (uint32_t) data2);
+ } else {
+ av_log(s->avctx, AV_LOG_VERBOSE, "OMX command complete, command %"PRIu32", value %"PRIu32"\n",
+ (uint32_t) data1, (uint32_t) data2);
+ }
+ break;
+ case OMX_EventPortSettingsChanged:
+ av_log(s->avctx, AV_LOG_VERBOSE, "OMX port %"PRIu32" settings changed\n", (uint32_t) data1);
+ break;
+ default:
+ av_log(s->avctx, AV_LOG_VERBOSE, "OMX event %d %"PRIx32" %"PRIx32"\n",
+ event, (uint32_t) data1, (uint32_t) data2);
+ break;
+ }
+ return OMX_ErrorNone;
+}
+
+static OMX_ERRORTYPE empty_buffer_done(OMX_HANDLETYPE component, OMX_PTR app_data,
+ OMX_BUFFERHEADERTYPE *buffer)
+{
+ OMXCodecContext *s = app_data;
+ if (s->input_zerocopy) {
+ if (buffer->pAppPrivate) {
+ if (buffer->pOutputPortPrivate)
+ av_free(buffer->pAppPrivate);
+ else
+ av_frame_free((AVFrame**)&buffer->pAppPrivate);
+ buffer->pAppPrivate = NULL;
+ }
+ }
+ append_buffer(&s->input_mutex, &s->input_cond,
+ &s->num_free_in_buffers, s->free_in_buffers, buffer);
+ return OMX_ErrorNone;
+}
+
+static OMX_ERRORTYPE fill_buffer_done(OMX_HANDLETYPE component, OMX_PTR app_data,
+ OMX_BUFFERHEADERTYPE *buffer)
+{
+ OMXCodecContext *s = app_data;
+ append_buffer(&s->output_mutex, &s->output_cond,
+ &s->num_done_out_buffers, s->done_out_buffers, buffer);
+ return OMX_ErrorNone;
+}
+
+static const OMX_CALLBACKTYPE callbacks = {
+ event_handler,
+ empty_buffer_done,
+ fill_buffer_done
+};
+
+static av_cold int find_component(OMXContext *omx_context, void *logctx,
+ const char *role, char *str, int str_size)
+{
+ OMX_U32 i, num = 0;
+ char **components;
+ int ret = 0;
+
+#if CONFIG_OMX_RPI
+ if (av_strstart(role, "video_encoder.", NULL)) {
+ av_strlcpy(str, "OMX.broadcom.video_encode", str_size);
+ return 0;
+ }
+#endif
+ omx_context->ptr_GetComponentsOfRole((OMX_STRING) role, &num, NULL);
+ if (!num) {
+ av_log(logctx, AV_LOG_WARNING, "No component for role %s found\n", role);
+ return AVERROR_ENCODER_NOT_FOUND;
+ }
+ components = av_mallocz_array(num, sizeof(*components));
+ if (!components)
+ return AVERROR(ENOMEM);
+ for (i = 0; i < num; i++) {
+ components[i] = av_mallocz(OMX_MAX_STRINGNAME_SIZE);
+ if (!components[i]) {
+ ret = AVERROR(ENOMEM);
+ goto end;
+ }
+ }
+ omx_context->ptr_GetComponentsOfRole((OMX_STRING) role, &num, (OMX_U8**) components);
+ av_strlcpy(str, components[0], str_size);
+end:
+ for (i = 0; i < num; i++)
+ av_free(components[i]);
+ av_free(components);
+ return ret;
+}
+
+static av_cold int wait_for_state(OMXCodecContext *s, OMX_STATETYPE state)
+{
+ int ret = 0;
+ pthread_mutex_lock(&s->state_mutex);
+ while (s->state != state && s->error == OMX_ErrorNone)
+ pthread_cond_wait(&s->state_cond, &s->state_mutex);
+ if (s->error != OMX_ErrorNone)
+ ret = AVERROR_ENCODER_NOT_FOUND;
+ pthread_mutex_unlock(&s->state_mutex);
+ return ret;
+}
+
+static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+{
+ OMXCodecContext *s = avctx->priv_data;
+ OMX_PARAM_COMPONENTROLETYPE role_params = { 0 };
+ OMX_PORT_PARAM_TYPE video_port_params = { 0 };
+ OMX_PARAM_PORTDEFINITIONTYPE in_port_params = { 0 }, out_port_params = { 0 };
+ OMX_VIDEO_PARAM_PORTFORMATTYPE video_port_format = { 0 };
+ OMX_VIDEO_PARAM_BITRATETYPE vid_param_bitrate = { 0 };
+ OMX_ERRORTYPE err;
+ int i;
+
+ s->version.s.nVersionMajor = 1;
+ s->version.s.nVersionMinor = 1;
+ s->version.s.nRevision = 2;
+
+ err = s->omx_context->ptr_GetHandle(&s->handle, s->component_name, s, (OMX_CALLBACKTYPE*) &callbacks);
+ if (err != OMX_ErrorNone) {
+ av_log(avctx, AV_LOG_ERROR, "OMX_GetHandle(%s) failed: %x\n", s->component_name, err);
+ return AVERROR_UNKNOWN;
+ }
+
+ // This one crashes the mediaserver on qcom, if used over IOMX
+ INIT_STRUCT(role_params);
+ av_strlcpy(role_params.cRole, role, sizeof(role_params.cRole));
+ // Intentionally ignore errors on this one
+ OMX_SetParameter(s->handle, OMX_IndexParamStandardComponentRole, &role_params);
+
+ INIT_STRUCT(video_port_params);
+ err = OMX_GetParameter(s->handle, OMX_IndexParamVideoInit, &video_port_params);
+ CHECK(err);
+
+ s->in_port = s->out_port = -1;
+ for (i = 0; i < video_port_params.nPorts; i++) {
+ int port = video_port_params.nStartPortNumber + i;
+ OMX_PARAM_PORTDEFINITIONTYPE port_params = { 0 };
+ INIT_STRUCT(port_params);
+ port_params.nPortIndex = port;
+ err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &port_params);
+ if (err != OMX_ErrorNone) {
+ av_log(avctx, AV_LOG_WARNING, "port %d error %x\n", port, err);
+ break;
+ }
+ if (port_params.eDir == OMX_DirInput && s->in_port < 0) {
+ in_port_params = port_params;
+ s->in_port = port;
+ } else if (port_params.eDir == OMX_DirOutput && s->out_port < 0) {
+ out_port_params = port_params;
+ s->out_port = port;
+ }
+ }
+ if (s->in_port < 0 || s->out_port < 0) {
+ av_log(avctx, AV_LOG_ERROR, "No in or out port found (in %d out %d)\n", s->in_port, s->out_port);
+ return AVERROR_UNKNOWN;
+ }
+
+ s->color_format = 0;
+ for (i = 0; ; i++) {
+ INIT_STRUCT(video_port_format);
+ video_port_format.nIndex = i;
+ video_port_format.nPortIndex = s->in_port;
+ if (OMX_GetParameter(s->handle, OMX_IndexParamVideoPortFormat, &video_port_format) != OMX_ErrorNone)
+ break;
+ if (video_port_format.eColorFormat == OMX_COLOR_FormatYUV420Planar ||
+ video_port_format.eColorFormat == OMX_COLOR_FormatYUV420PackedPlanar) {
+ s->color_format = video_port_format.eColorFormat;
+ break;
+ }
+ }
+ if (s->color_format == 0) {
+ av_log(avctx, AV_LOG_ERROR, "No supported pixel formats (%d formats available)\n", i);
+ return AVERROR_UNKNOWN;
+ }
+
+ in_port_params.bEnabled = OMX_TRUE;
+ in_port_params.bPopulated = OMX_FALSE;
+ in_port_params.eDomain = OMX_PortDomainVideo;
+
+ in_port_params.format.video.pNativeRender = NULL;
+ in_port_params.format.video.bFlagErrorConcealment = OMX_FALSE;
+ in_port_params.format.video.eColorFormat = s->color_format;
+ s->stride = avctx->width;
+ s->plane_size = avctx->height;
+ // If specific codecs need to manually override the stride/plane_size,
+ // that can be done here.
+ in_port_params.format.video.nStride = s->stride;
+ in_port_params.format.video.nSliceHeight = s->plane_size;
+ in_port_params.format.video.nFrameWidth = avctx->width;
+ in_port_params.format.video.nFrameHeight = avctx->height;
+ if (avctx->framerate.den > 0 && avctx->framerate.num > 0)
+ in_port_params.format.video.xFramerate = (1LL << 16) * avctx->framerate.num / avctx->framerate.den;
+ else
+ in_port_params.format.video.xFramerate = (1LL << 16) * avctx->time_base.den / avctx->time_base.num;
+
+ err = OMX_SetParameter(s->handle, OMX_IndexParamPortDefinition, &in_port_params);
+ CHECK(err);
+ err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &in_port_params);
+ CHECK(err);
+ s->stride = in_port_params.format.video.nStride;
+ s->plane_size = in_port_params.format.video.nSliceHeight;
+ s->num_in_buffers = in_port_params.nBufferCountActual;
+
+ err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &out_port_params);
+ out_port_params.bEnabled = OMX_TRUE;
+ out_port_params.bPopulated = OMX_FALSE;
+ out_port_params.eDomain = OMX_PortDomainVideo;
+ out_port_params.format.video.pNativeRender = NULL;
+ out_port_params.format.video.nFrameWidth = avctx->width;
+ out_port_params.format.video.nFrameHeight = avctx->height;
+ out_port_params.format.video.nStride = 0;
+ out_port_params.format.video.nSliceHeight = 0;
+ out_port_params.format.video.nBitrate = avctx->bit_rate;
+ out_port_params.format.video.xFramerate = in_port_params.format.video.xFramerate;
+ out_port_params.format.video.bFlagErrorConcealment = OMX_FALSE;
+ if (avctx->codec->id == AV_CODEC_ID_MPEG4)
+ out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
+ else if (avctx->codec->id == AV_CODEC_ID_H264)
+ out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
+
+ err = OMX_SetParameter(s->handle, OMX_IndexParamPortDefinition, &out_port_params);
+ CHECK(err);
+ err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &out_port_params);
+ CHECK(err);
+ s->num_out_buffers = out_port_params.nBufferCountActual;
+
+ INIT_STRUCT(vid_param_bitrate);
+ vid_param_bitrate.nPortIndex = s->out_port;
+ vid_param_bitrate.eControlRate = OMX_Video_ControlRateVariable;
+ vid_param_bitrate.nTargetBitrate = avctx->bit_rate;
+ err = OMX_SetParameter(s->handle, OMX_IndexParamVideoBitrate, &vid_param_bitrate);
+ if (err != OMX_ErrorNone)
+ av_log(avctx, AV_LOG_WARNING, "Unable to set video bitrate parameter\n");
+
+ if (avctx->codec->id == AV_CODEC_ID_H264) {
+ OMX_VIDEO_PARAM_AVCTYPE avc = { 0 };
+ INIT_STRUCT(avc);
+ avc.nPortIndex = s->out_port;
+ err = OMX_GetParameter(s->handle, OMX_IndexParamVideoAvc, &avc);
+ CHECK(err);
+ avc.nBFrames = 0;
+ avc.nPFrames = avctx->gop_size - 1;
+ switch (s->profile == FF_PROFILE_UNKNOWN ? avctx->profile : s->profile) {
+ case FF_PROFILE_H264_BASELINE:
+ avc.eProfile = OMX_VIDEO_AVCProfileBaseline;
+ break;
+ case FF_PROFILE_H264_MAIN:
+ avc.eProfile = OMX_VIDEO_AVCProfileMain;
+ break;
+ case FF_PROFILE_H264_HIGH:
+ avc.eProfile = OMX_VIDEO_AVCProfileHigh;
+ break;
+ default:
+ break;
+ }
+ err = OMX_SetParameter(s->handle, OMX_IndexParamVideoAvc, &avc);
+ CHECK(err);
+ }
+
+ err = OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateIdle, NULL);
+ CHECK(err);
+
+ s->in_buffer_headers = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_in_buffers);
+ s->free_in_buffers = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_in_buffers);
+ s->out_buffer_headers = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_out_buffers);
+ s->done_out_buffers = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_out_buffers);
+ if (!s->in_buffer_headers || !s->free_in_buffers || !s->out_buffer_headers || !s->done_out_buffers)
+ return AVERROR(ENOMEM);
+ for (i = 0; i < s->num_in_buffers && err == OMX_ErrorNone; i++) {
+ if (s->input_zerocopy)
+ err = OMX_UseBuffer(s->handle, &s->in_buffer_headers[i], s->in_port, s, in_port_params.nBufferSize, NULL);
+ else
+ err = OMX_AllocateBuffer(s->handle, &s->in_buffer_headers[i], s->in_port, s, in_port_params.nBufferSize);
+ if (err == OMX_ErrorNone)
+ s->in_buffer_headers[i]->pAppPrivate = s->in_buffer_headers[i]->pOutputPortPrivate = NULL;
+ }
+ CHECK(err);
+ s->num_in_buffers = i;
+ for (i = 0; i < s->num_out_buffers && err == OMX_ErrorNone; i++)
+ err = OMX_AllocateBuffer(s->handle, &s->out_buffer_headers[i], s->out_port, s, out_port_params.nBufferSize);
+ CHECK(err);
+ s->num_out_buffers = i;
+
+ if (wait_for_state(s, OMX_StateIdle) < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Didn't get OMX_StateIdle\n");
+ return AVERROR_UNKNOWN;
+ }
+ err = OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
+ CHECK(err);
+ if (wait_for_state(s, OMX_StateExecuting) < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Didn't get OMX_StateExecuting\n");
+ return AVERROR_UNKNOWN;
+ }
+
+ for (i = 0; i < s->num_out_buffers && err == OMX_ErrorNone; i++)
+ err = OMX_FillThisBuffer(s->handle, s->out_buffer_headers[i]);
+ if (err != OMX_ErrorNone) {
+ for (; i < s->num_out_buffers; i++)
+ s->done_out_buffers[s->num_done_out_buffers++] = s->out_buffer_headers[i];
+ }
+ for (i = 0; i < s->num_in_buffers; i++)
+ s->free_in_buffers[s->num_free_in_buffers++] = s->in_buffer_headers[i];
+ return err != OMX_ErrorNone ? AVERROR_UNKNOWN : 0;
+}
+
+static av_cold void cleanup(OMXCodecContext *s)
+{
+ int i, executing;
+
+ pthread_mutex_lock(&s->state_mutex);
+ executing = s->state == OMX_StateExecuting;
+ pthread_mutex_unlock(&s->state_mutex);
+
+ if (executing) {
+ OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateIdle, NULL);
+ wait_for_state(s, OMX_StateIdle);
+ OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
+ for (i = 0; i < s->num_in_buffers; i++) {
+ OMX_BUFFERHEADERTYPE *buffer = get_buffer(&s->input_mutex, &s->input_cond,
+ &s->num_free_in_buffers, s->free_in_buffers, 1);
+ if (s->input_zerocopy)
+ buffer->pBuffer = NULL;
+ OMX_FreeBuffer(s->handle, s->in_port, buffer);
+ }
+ for (i = 0; i < s->num_out_buffers; i++) {
+ OMX_BUFFERHEADERTYPE *buffer = get_buffer(&s->output_mutex, &s->output_cond,
+ &s->num_done_out_buffers, s->done_out_buffers, 1);
+ OMX_FreeBuffer(s->handle, s->out_port, buffer);
+ }
+ wait_for_state(s, OMX_StateLoaded);
+ }
+ if (s->handle) {
+ s->omx_context->ptr_FreeHandle(s->handle);
+ s->handle = NULL;
+ }
+
+ omx_deinit(s->omx_context);
+ s->omx_context = NULL;
+ if (s->mutex_cond_inited) {
+ pthread_cond_destroy(&s->state_cond);
+ pthread_mutex_destroy(&s->state_mutex);
+ pthread_cond_destroy(&s->input_cond);
+ pthread_mutex_destroy(&s->input_mutex);
+ pthread_cond_destroy(&s->output_cond);
+ pthread_mutex_destroy(&s->output_mutex);
+ s->mutex_cond_inited = 0;
+ }
+ av_freep(&s->in_buffer_headers);
+ av_freep(&s->out_buffer_headers);
+ av_freep(&s->free_in_buffers);
+ av_freep(&s->done_out_buffers);
+ av_freep(&s->output_buf);
+}
+
+static av_cold int omx_encode_init(AVCodecContext *avctx)
+{
+ OMXCodecContext *s = avctx->priv_data;
+ int ret = AVERROR_ENCODER_NOT_FOUND;
+ const char *role;
+ OMX_BUFFERHEADERTYPE *buffer;
+ OMX_ERRORTYPE err;
+
+ s->omx_context = omx_init(avctx, s->libname, s->libprefix);
+ if (!s->omx_context)
+ return AVERROR_ENCODER_NOT_FOUND;
+
+ pthread_mutex_init(&s->state_mutex, NULL);
+ pthread_cond_init(&s->state_cond, NULL);
+ pthread_mutex_init(&s->input_mutex, NULL);
+ pthread_cond_init(&s->input_cond, NULL);
+ pthread_mutex_init(&s->output_mutex, NULL);
+ pthread_cond_init(&s->output_cond, NULL);
+ s->mutex_cond_inited = 1;
+ s->avctx = avctx;
+ s->state = OMX_StateLoaded;
+ s->error = OMX_ErrorNone;
+
+ switch (avctx->codec->id) {
+ case AV_CODEC_ID_MPEG4:
+ role = "video_encoder.mpeg4";
+ break;
+ case AV_CODEC_ID_H264:
+ role = "video_encoder.avc";
+ break;
+ default:
+ return AVERROR(ENOSYS);
+ }
+
+ if ((ret = find_component(s->omx_context, avctx, role, s->component_name, sizeof(s->component_name))) < 0)
+ goto fail;
+
+ av_log(avctx, AV_LOG_INFO, "Using %s\n", s->component_name);
+
+ if ((ret = omx_component_init(avctx, role)) < 0)
+ goto fail;
+
+ if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
+ while (1) {
+ buffer = get_buffer(&s->output_mutex, &s->output_cond,
+ &s->num_done_out_buffers, s->done_out_buffers, 1);
+ if (buffer->nFlags & OMX_BUFFERFLAG_CODECCONFIG) {
+ if ((ret = av_reallocp(&avctx->extradata, avctx->extradata_size + buffer->nFilledLen + AV_INPUT_BUFFER_PADDING_SIZE)) < 0) {
+ avctx->extradata_size = 0;
+ goto fail;
+ }
+ memcpy(avctx->extradata + avctx->extradata_size, buffer->pBuffer + buffer->nOffset, buffer->nFilledLen);
+ avctx->extradata_size += buffer->nFilledLen;
+ memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
+ }
+ err = OMX_FillThisBuffer(s->handle, buffer);
+ if (err != OMX_ErrorNone) {
+ append_buffer(&s->output_mutex, &s->output_cond,
+ &s->num_done_out_buffers, s->done_out_buffers, buffer);
+ av_log(avctx, AV_LOG_ERROR, "OMX_FillThisBuffer failed: %x\n", err);
+ ret = AVERROR_UNKNOWN;
+ goto fail;
+ }
+ if (avctx->codec->id == AV_CODEC_ID_H264) {
+ // For H.264, the extradata can be returned in two separate buffers
+ // (the videocore encoder on raspberry pi does this);
+ // therefore check that we have got both SPS and PPS before continuing.
+ int nals[32] = { 0 };
+ int i;
+ for (i = 0; i + 4 < avctx->extradata_size; i++) {
+ if (!avctx->extradata[i + 0] &&
+ !avctx->extradata[i + 1] &&
+ !avctx->extradata[i + 2] &&
+ avctx->extradata[i + 3] == 1) {
+ nals[avctx->extradata[i + 4] & 0x1f]++;
+ }
+ }
+ if (nals[H264_NAL_SPS] && nals[H264_NAL_PPS])
+ break;
+ } else {
+ if (avctx->extradata_size > 0)
+ break;
+ }
+ }
+ }
+
+ return 0;
+fail:
+ return ret;
+}
+
+
+static int omx_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
+ const AVFrame *frame, int *got_packet)
+{
+ OMXCodecContext *s = avctx->priv_data;
+ int ret = 0;
+ OMX_BUFFERHEADERTYPE* buffer;
+ OMX_ERRORTYPE err;
+ int had_partial = 0;
+
+ if (frame) {
+ uint8_t *dst[4];
+ int linesize[4];
+ int need_copy;
+ buffer = get_buffer(&s->input_mutex, &s->input_cond,
+ &s->num_free_in_buffers, s->free_in_buffers, 1);
+
+ buffer->nFilledLen = av_image_fill_arrays(dst, linesize, buffer->pBuffer, avctx->pix_fmt, s->stride, s->plane_size, 1);
+
+ if (s->input_zerocopy) {
+ uint8_t *src[4] = { NULL };
+ int src_linesize[4];
+ av_image_fill_arrays(src, src_linesize, frame->data[0], avctx->pix_fmt, s->stride, s->plane_size, 1);
+ if (frame->linesize[0] == src_linesize[0] &&
+ frame->linesize[1] == src_linesize[1] &&
+ frame->linesize[2] == src_linesize[2] &&
+ frame->data[1] == src[1] &&
+ frame->data[2] == src[2]) {
+ // If the input frame happens to have all planes stored contiguously,
+ // with the right strides, just clone the frame and set the OMX
+ // buffer header to point to it
+ AVFrame *local = av_frame_clone(frame);
+ if (!local) {
+ // Return the buffer to the queue so it's not lost
+ append_buffer(&s->input_mutex, &s->input_cond, &s->num_free_in_buffers, s->free_in_buffers, buffer);
+ return AVERROR(ENOMEM);
+ } else {
+ buffer->pAppPrivate = local;
+ buffer->pOutputPortPrivate = NULL;
+ buffer->pBuffer = local->data[0];
+ need_copy = 0;
+ }
+ } else {
+ // If not, we need to allocate a new buffer with the right
+ // size and copy the input frame into it.
+ uint8_t *buf = NULL;
+ int image_buffer_size = av_image_get_buffer_size(avctx->pix_fmt, s->stride, s->plane_size, 1);
+ if (image_buffer_size >= 0)
+ buf = av_malloc(image_buffer_size);
+ if (!buf) {
+ // Return the buffer to the queue so it's not lost
+ append_buffer(&s->input_mutex, &s->input_cond, &s->num_free_in_buffers, s->free_in_buffers, buffer);
+ return AVERROR(ENOMEM);
+ } else {
+ buffer->pAppPrivate = buf;
+ // Mark that pAppPrivate is an av_malloc'ed buffer, not an AVFrame
+ buffer->pOutputPortPrivate = (void*) 1;
+ buffer->pBuffer = buf;
+ need_copy = 1;
+ buffer->nFilledLen = av_image_fill_arrays(dst, linesize, buffer->pBuffer, avctx->pix_fmt, s->stride, s->plane_size, 1);
+ }
+ }
+ } else {
+ need_copy = 1;
+ }
+ if (need_copy)
+ av_image_copy(dst, linesize, (const uint8_t**) frame->data, frame->linesize, avctx->pix_fmt, avctx->width, avctx->height);
+ buffer->nFlags = OMX_BUFFERFLAG_ENDOFFRAME;
+ buffer->nOffset = 0;
+ // Convert the timestamps to microseconds; some encoders can ignore
+ // the framerate and do VFR bit allocation based on timestamps.
+ buffer->nTimeStamp = to_omx_ticks(av_rescale_q(frame->pts, avctx->time_base, AV_TIME_BASE_Q));
+ if (frame->pict_type == AV_PICTURE_TYPE_I) {
+#if CONFIG_OMX_RPI
+ OMX_CONFIG_BOOLEANTYPE config = {0, };
+ INIT_STRUCT(config);
+ config.bEnabled = OMX_TRUE;
+ err = OMX_SetConfig(s->handle, OMX_IndexConfigBrcmVideoRequestIFrame, &config);
+ if (err != OMX_ErrorNone) {
+ av_log(avctx, AV_LOG_ERROR, "OMX_SetConfig(RequestIFrame) failed: %x\n", err);
+ }
+#else
+ OMX_CONFIG_INTRAREFRESHVOPTYPE config = {0, };
+ INIT_STRUCT(config);
+ config.nPortIndex = s->out_port;
+ config.IntraRefreshVOP = OMX_TRUE;
+ err = OMX_SetConfig(s->handle, OMX_IndexConfigVideoIntraVOPRefresh, &config);
+ if (err != OMX_ErrorNone) {
+ av_log(avctx, AV_LOG_ERROR, "OMX_SetConfig(IntraVOPRefresh) failed: %x\n", err);
+ }
+#endif
+ }
+ err = OMX_EmptyThisBuffer(s->handle, buffer);
+ if (err != OMX_ErrorNone) {
+ append_buffer(&s->input_mutex, &s->input_cond, &s->num_free_in_buffers, s->free_in_buffers, buffer);
+ av_log(avctx, AV_LOG_ERROR, "OMX_EmptyThisBuffer failed: %x\n", err);
+ return AVERROR_UNKNOWN;
+ }
+ } else if (!s->eos_sent) {
+ buffer = get_buffer(&s->input_mutex, &s->input_cond,
+ &s->num_free_in_buffers, s->free_in_buffers, 1);
+
+ buffer->nFilledLen = 0;
+ buffer->nFlags = OMX_BUFFERFLAG_EOS;
+ buffer->pAppPrivate = buffer->pOutputPortPrivate = NULL;
+ err = OMX_EmptyThisBuffer(s->handle, buffer);
+ if (err != OMX_ErrorNone) {
+ append_buffer(&s->input_mutex, &s->input_cond, &s->num_free_in_buffers, s->free_in_buffers, buffer);
+ av_log(avctx, AV_LOG_ERROR, "OMX_EmptyThisBuffer failed: %x\n", err);
+ return AVERROR_UNKNOWN;
+ }
+ s->eos_sent = 1;
+ }
+
+ while (!*got_packet && ret == 0 && !s->got_eos) {
+ // If not flushing, just poll the queue if there's finished packets.
+ // If flushing, do a blocking wait until we either get a completed
+ // packet, or get EOS.
+ buffer = get_buffer(&s->output_mutex, &s->output_cond,
+ &s->num_done_out_buffers, s->done_out_buffers,
+ !frame || had_partial);
+ if (!buffer)
+ break;
+
+ if (buffer->nFlags & OMX_BUFFERFLAG_EOS)
+ s->got_eos = 1;
+
+ if (buffer->nFlags & OMX_BUFFERFLAG_CODECCONFIG && avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
+ if ((ret = av_reallocp(&avctx->extradata, avctx->extradata_size + buffer->nFilledLen + AV_INPUT_BUFFER_PADDING_SIZE)) < 0) {
+ avctx->extradata_size = 0;
+ goto end;
+ }
+ memcpy(avctx->extradata + avctx->extradata_size, buffer->pBuffer + buffer->nOffset, buffer->nFilledLen);
+ avctx->extradata_size += buffer->nFilledLen;
+ memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
+ } else {
+ if (!(buffer->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) || !pkt->data) {
+ // If the output packet isn't preallocated, just concatenate everything in our
+ // own buffer
+ int newsize = s->output_buf_size + buffer->nFilledLen + AV_INPUT_BUFFER_PADDING_SIZE;
+ if ((ret = av_reallocp(&s->output_buf, newsize)) < 0) {
+ s->output_buf_size = 0;
+ goto end;
+ }
+ memcpy(s->output_buf + s->output_buf_size, buffer->pBuffer + buffer->nOffset, buffer->nFilledLen);
+ s->output_buf_size += buffer->nFilledLen;
+ if (buffer->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) {
+ if ((ret = av_packet_from_data(pkt, s->output_buf, s->output_buf_size)) < 0) {
+ av_freep(&s->output_buf);
+ s->output_buf_size = 0;
+ goto end;
+ }
+ s->output_buf = NULL;
+ s->output_buf_size = 0;
+ }
+#if CONFIG_OMX_RPI
+ had_partial = 1;
+#endif
+ } else {
+ // End of frame, and the caller provided a preallocated frame
+ if ((ret = ff_alloc_packet2(avctx, pkt, s->output_buf_size + buffer->nFilledLen, 0)) < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Error getting output packet of size %d.\n",
+ (int)(s->output_buf_size + buffer->nFilledLen));
+ goto end;
+ }
+ memcpy(pkt->data, s->output_buf, s->output_buf_size);
+ memcpy(pkt->data + s->output_buf_size, buffer->pBuffer + buffer->nOffset, buffer->nFilledLen);
+ av_freep(&s->output_buf);
+ s->output_buf_size = 0;
+ }
+ if (buffer->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) {
+ pkt->pts = av_rescale_q(from_omx_ticks(buffer->nTimeStamp), AV_TIME_BASE_Q, avctx->time_base);
+ // We don't currently enable B-frames for the encoders, so set
+ // pkt->dts = pkt->pts. (The calling code behaves worse if the encoder
+ // doesn't set the dts).
+ pkt->dts = pkt->pts;
+ if (buffer->nFlags & OMX_BUFFERFLAG_SYNCFRAME)
+ pkt->flags |= AV_PKT_FLAG_KEY;
+ *got_packet = 1;
+ }
+ }
+end:
+ err = OMX_FillThisBuffer(s->handle, buffer);
+ if (err != OMX_ErrorNone) {
+ append_buffer(&s->output_mutex, &s->output_cond, &s->num_done_out_buffers, s->done_out_buffers, buffer);
+ av_log(avctx, AV_LOG_ERROR, "OMX_FillThisBuffer failed: %x\n", err);
+ ret = AVERROR_UNKNOWN;
+ }
+ }
+ return ret;
+}
+
+static av_cold int omx_encode_end(AVCodecContext *avctx)
+{
+ OMXCodecContext *s = avctx->priv_data;
+
+ cleanup(s);
+ return 0;
+}
+
+#define OFFSET(x) offsetof(OMXCodecContext, x)
+#define VDE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM
+#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
+static const AVOption options[] = {
+ { "omx_libname", "OpenMAX library name", OFFSET(libname), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
+ { "omx_libprefix", "OpenMAX library prefix", OFFSET(libprefix), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
+ { "zerocopy", "Try to avoid copying input frames if possible", OFFSET(input_zerocopy), AV_OPT_TYPE_INT, { .i64 = CONFIG_OMX_RPI }, 0, 1, VE },
+ { "profile", "Set the encoding profile", OFFSET(profile), AV_OPT_TYPE_INT, { .i64 = FF_PROFILE_UNKNOWN }, FF_PROFILE_UNKNOWN, FF_PROFILE_H264_HIGH, VE, "profile" },
+ { "baseline", "", 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_BASELINE }, 0, 0, VE, "profile" },
+ { "main", "", 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_MAIN }, 0, 0, VE, "profile" },
+ { "high", "", 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_HIGH }, 0, 0, VE, "profile" },
+ { NULL }
+};
+
+static const enum AVPixelFormat omx_encoder_pix_fmts[] = {
+ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
+};
+
+static const AVClass omx_mpeg4enc_class = {
+ .class_name = "mpeg4_omx",
+ .item_name = av_default_item_name,
+ .option = options,
+ .version = LIBAVUTIL_VERSION_INT,
+};
+AVCodec ff_mpeg4_omx_encoder = {
+ .name = "mpeg4_omx",
+ .long_name = NULL_IF_CONFIG_SMALL("OpenMAX IL MPEG-4 video encoder"),
+ .type = AVMEDIA_TYPE_VIDEO,
+ .id = AV_CODEC_ID_MPEG4,
+ .priv_data_size = sizeof(OMXCodecContext),
+ .init = omx_encode_init,
+ .encode2 = omx_encode_frame,
+ .close = omx_encode_end,
+ .pix_fmts = omx_encoder_pix_fmts,
+ .capabilities = AV_CODEC_CAP_DELAY,
+ .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
+ .priv_class = &omx_mpeg4enc_class,
+};
+
+static const AVClass omx_h264enc_class = {
+ .class_name = "h264_omx",
+ .item_name = av_default_item_name,
+ .option = options,
+ .version = LIBAVUTIL_VERSION_INT,
+};
+AVCodec ff_h264_omx_encoder = {
+ .name = "h264_omx",
+ .long_name = NULL_IF_CONFIG_SMALL("OpenMAX IL H.264 video encoder"),
+ .type = AVMEDIA_TYPE_VIDEO,
+ .id = AV_CODEC_ID_H264,
+ .priv_data_size = sizeof(OMXCodecContext),
+ .init = omx_encode_init,
+ .encode2 = omx_encode_frame,
+ .close = omx_encode_end,
+ .pix_fmts = omx_encoder_pix_fmts,
+ .capabilities = AV_CODEC_CAP_DELAY,
+ .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
+ .priv_class = &omx_h264enc_class,
+};
Radix cross Linux
The main Radix cross Linux repository contains the build scripts of packages, which have the most complete and common functionality for desktop machines
452 Commits
2 Branches
1 Tag