return 0;
}
-AVCodec fourxm_decoder = {
+AVCodec ff_fourxm_decoder = {
"4xm",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_4XM,
-AVCodec eightbps_decoder = {
+AVCodec ff_eightbps_decoder = {
"8bps",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_8BPS,
return 0;
}
-AVCodec eightsvx_fib_decoder = {
+AVCodec ff_eightsvx_fib_decoder = {
.name = "8svx_fib",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_8SVX_FIB,
.long_name = NULL_IF_CONFIG_SMALL("8SVX fibonacci"),
};
-AVCodec eightsvx_exp_decoder = {
+AVCodec ff_eightsvx_exp_decoder = {
.name = "8svx_exp",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_8SVX_EXP,
return 0;
}
-AVCodec a64multi_encoder = {
+AVCodec ff_a64multi_encoder = {
.name = "a64multi",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_A64_MULTI,
.capabilities = CODEC_CAP_DELAY,
};
-AVCodec a64multi5_encoder = {
+AVCodec ff_a64multi5_encoder = {
.name = "a64multi5",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_A64_MULTI5,
return 0;
}
-AVBitStreamFilter aac_adtstoasc_bsf = {
+AVBitStreamFilter ff_aac_adtstoasc_bsf = {
"aac_adtstoasc",
sizeof(AACBSFContext),
aac_adtstoasc_filter,
}
-AVCodecParser aac_parser = {
+AVCodecParser ff_aac_parser = {
{ CODEC_ID_AAC },
sizeof(AACAC3ParseContext),
aac_parse_init,
}
-AVCodec aac_decoder = {
+AVCodec ff_aac_decoder = {
"aac",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_AAC,
in MPEG transport streams which only contain one program.
To do a more complex LATM demuxing a separate LATM demuxer should be used.
*/
-AVCodec aac_latm_decoder = {
+AVCodec ff_aac_latm_decoder = {
.name = "aac_latm",
.type = CODEC_TYPE_AUDIO,
.id = CODEC_ID_AAC_LATM,
return 0;
}
-AVCodec aac_encoder = {
+AVCodec ff_aac_encoder = {
"aac",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_AAC,
return 0;
}
-AVCodec aasc_decoder = {
+AVCodec ff_aasc_decoder = {
"aasc",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_AASC,
}
-AVCodecParser ac3_parser = {
+AVCodecParser ff_ac3_parser = {
{ CODEC_ID_AC3, CODEC_ID_EAC3 },
sizeof(AACAC3ParseContext),
ac3_parse_init,
return 0;
}
-AVCodec ac3_decoder = {
+AVCodec ff_ac3_decoder = {
.name = "ac3",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_AC3,
};
#if CONFIG_EAC3_DECODER
-AVCodec eac3_decoder = {
+AVCodec ff_eac3_decoder = {
.name = "eac3",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_EAC3,
#endif /* TEST */
-AVCodec ac3_fixed_encoder = {
+AVCodec ff_ac3_fixed_encoder = {
"ac3_fixed",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_AC3,
}
-AVCodec ac3_encoder = {
+AVCodec ff_ac3_encoder = {
"ac3",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_AC3,
#if CONFIG_ENCODERS
#define ADPCM_ENCODER(id,name,long_name_) \
-AVCodec name ## _encoder = { \
+AVCodec ff_ ## name ## _encoder = { \
#name, \
AVMEDIA_TYPE_AUDIO, \
id, \
#if CONFIG_DECODERS
#define ADPCM_DECODER(id,name,long_name_) \
-AVCodec name ## _decoder = { \
+AVCodec ff_ ## name ## _decoder = { \
#name, \
AVMEDIA_TYPE_AUDIO, \
id, \
return buf-buf0;
}
-AVCodec adpcm_adx_decoder = {
+AVCodec ff_adpcm_adx_decoder = {
"adpcm_adx",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_ADPCM_ADX,
return dst-frame;
}
-AVCodec adpcm_adx_encoder = {
+AVCodec ff_adpcm_adx_encoder = {
"adpcm_adx",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_ADPCM_ADX,
return 0;
}
-AVCodec alac_decoder = {
+AVCodec ff_alac_decoder = {
"alac",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_ALAC,
return 0;
}
-AVCodec alac_encoder = {
+AVCodec ff_alac_encoder = {
"alac",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_ALAC,
#include "avcodec.h"
#define REGISTER_HWACCEL(X,x) { \
- extern AVHWAccel x##_hwaccel; \
- if(CONFIG_##X##_HWACCEL) av_register_hwaccel(&x##_hwaccel); }
+ extern AVHWAccel ff_##x##_hwaccel; \
+ if(CONFIG_##X##_HWACCEL) av_register_hwaccel(&ff_##x##_hwaccel); }
#define REGISTER_ENCODER(X,x) { \
- extern AVCodec x##_encoder; \
- if(CONFIG_##X##_ENCODER) avcodec_register(&x##_encoder); }
+ extern AVCodec ff_##x##_encoder; \
+ if(CONFIG_##X##_ENCODER) avcodec_register(&ff_##x##_encoder); }
#define REGISTER_DECODER(X,x) { \
- extern AVCodec x##_decoder; \
- if(CONFIG_##X##_DECODER) avcodec_register(&x##_decoder); }
+ extern AVCodec ff_##x##_decoder; \
+ if(CONFIG_##X##_DECODER) avcodec_register(&ff_##x##_decoder); }
#define REGISTER_ENCDEC(X,x) REGISTER_ENCODER(X,x); REGISTER_DECODER(X,x)
#define REGISTER_PARSER(X,x) { \
- extern AVCodecParser x##_parser; \
- if(CONFIG_##X##_PARSER) av_register_codec_parser(&x##_parser); }
+ extern AVCodecParser ff_##x##_parser; \
+ if(CONFIG_##X##_PARSER) av_register_codec_parser(&ff_##x##_parser); }
#define REGISTER_BSF(X,x) { \
- extern AVBitStreamFilter x##_bsf; \
- if(CONFIG_##X##_BSF) av_register_bitstream_filter(&x##_bsf); }
+ extern AVBitStreamFilter ff_##x##_bsf; \
+ if(CONFIG_##X##_BSF) av_register_bitstream_filter(&ff_##x##_bsf); }
void avcodec_register_all(void)
{
}
-AVCodec als_decoder = {
+AVCodec ff_als_decoder = {
"als",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_MP4ALS,
}
-AVCodec amrnb_decoder = {
+AVCodec ff_amrnb_decoder = {
.name = "amrnb",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_AMR_NB,
return expected_fr_size;
}
-AVCodec amrwb_decoder = {
+AVCodec ff_amrwb_decoder = {
.name = "amrwb",
.type = CODEC_TYPE_AUDIO,
.id = CODEC_ID_AMR_WB,
return 0;
}
-AVCodec anm_decoder = {
+AVCodec ff_anm_decoder = {
"anm",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_ANM,
return 0;
}
-AVCodec ansi_decoder = {
+AVCodec ff_ansi_decoder = {
.name = "ansi",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_ANSI,
s->samples= 0;
}
-AVCodec ape_decoder = {
+AVCodec ff_ape_decoder = {
"ape",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_APE,
return avpkt->size;
}
-AVCodec ass_decoder = {
+AVCodec ff_ass_decoder = {
.name = "ass",
.long_name = NULL_IF_CONFIG_SMALL("Advanced SubStation Alpha subtitle"),
.type = AVMEDIA_TYPE_SUBTITLE,
return total_len;
}
-AVCodec ass_encoder = {
+AVCodec ff_ass_encoder = {
.name = "ass",
.long_name = NULL_IF_CONFIG_SMALL("Advanced SubStation Alpha subtitle"),
.type = AVMEDIA_TYPE_SUBTITLE,
return 0;
}
-AVCodec asv1_decoder = {
+AVCodec ff_asv1_decoder = {
"asv1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_ASV1,
.long_name= NULL_IF_CONFIG_SMALL("ASUS V1"),
};
-AVCodec asv2_decoder = {
+AVCodec ff_asv2_decoder = {
"asv2",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_ASV2,
};
#if CONFIG_ASV1_ENCODER
-AVCodec asv1_encoder = {
+AVCodec ff_asv1_encoder = {
"asv1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_ASV1,
#endif
#if CONFIG_ASV2_ENCODER
-AVCodec asv2_encoder = {
+AVCodec ff_asv2_encoder = {
"asv2",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_ASV2,
}
-AVCodec atrac1_decoder = {
+AVCodec ff_atrac1_decoder = {
.name = "atrac1",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_ATRAC1,
}
-AVCodec atrac3_decoder =
+AVCodec ff_atrac3_decoder =
{
.name = "atrac3",
.type = AVMEDIA_TYPE_AUDIO,
return 0;
}
-AVCodec aura2_decoder = {
+AVCodec ff_aura2_decoder = {
"aura2",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_AURA2,
return 0;
}
-AVCodec avs_decoder = {
+AVCodec ff_avs_decoder = {
"avs",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_AVS,
return 0;
}
-AVCodec bethsoftvid_decoder = {
+AVCodec ff_bethsoftvid_decoder = {
.name = "bethsoftvid",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_BETHSOFTVID,
return 0;
}
-AVCodec bfi_decoder = {
+AVCodec ff_bfi_decoder = {
.name = "bfi",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_BFI,
return 0;
}
-AVCodec bink_decoder = {
+AVCodec ff_bink_decoder = {
"binkvideo",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_BINKVIDEO,
return buf_size;
}
-AVCodec binkaudio_rdft_decoder = {
+AVCodec ff_binkaudio_rdft_decoder = {
"binkaudio_rdft",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_BINKAUDIO_RDFT,
.long_name = NULL_IF_CONFIG_SMALL("Bink Audio (RDFT)")
};
-AVCodec binkaudio_dct_decoder = {
+AVCodec ff_binkaudio_dct_decoder = {
"binkaudio_dct",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_BINKAUDIO_DCT,
return 0;
}
-AVCodec bmp_decoder = {
+AVCodec ff_bmp_decoder = {
"bmp",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_BMP,
return n_bytes;
}
-AVCodec bmp_encoder = {
+AVCodec ff_bmp_encoder = {
"bmp",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_BMP,
return buf_size;
}
-AVCodec c93_decoder = {
+AVCodec ff_c93_decoder = {
"c93",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_C93,
return next;
}
-AVCodecParser cavsvideo_parser = {
+AVCodecParser ff_cavsvideo_parser = {
{ CODEC_ID_CAVS },
sizeof(ParseContext1),
NULL,
}
}
-AVCodec cavs_decoder = {
+AVCodec ff_cavs_decoder = {
"cavs",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_CAVS,
return 0;
}
-AVCodec cdgraphics_decoder = {
+AVCodec ff_cdgraphics_decoder = {
"cdgraphics",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_CDGRAPHICS,
/**
* This filter removes a string of NULL bytes from the end of a packet.
*/
-AVBitStreamFilter chomp_bsf = {
+AVBitStreamFilter ff_chomp_bsf = {
"chomp",
0,
chomp_filter,
return 0;
}
-AVCodec cinepak_decoder = {
+AVCodec ff_cinepak_decoder = {
"cinepak",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_CINEPAK,
}
#endif
-AVCodec cljr_decoder = {
+AVCodec ff_cljr_decoder = {
"cljr",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_CLJR,
};
#if CONFIG_CLJR_ENCODER
-AVCodec cljr_encoder = {
+AVCodec ff_cljr_encoder = {
"cljr",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_CLJR,
}
-AVCodec cook_decoder =
+AVCodec ff_cook_decoder =
{
.name = "cook",
.type = AVMEDIA_TYPE_AUDIO,
return 0;
}
-AVCodec cscd_decoder = {
+AVCodec ff_cscd_decoder = {
"camstudio",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_CSCD,
}
#if CONFIG_AURA_DECODER
-AVCodec aura_decoder = {
+AVCodec ff_aura_decoder = {
"aura",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_AURA,
#endif
#if CONFIG_CYUV_DECODER
-AVCodec cyuv_decoder = {
+AVCodec ff_cyuv_decoder = {
"cyuv",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_CYUV,
{ FF_PROFILE_UNKNOWN },
};
-AVCodec dca_decoder = {
+AVCodec ff_dca_decoder = {
.name = "dca",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_DTS,
return next;
}
-AVCodecParser dca_parser = {
+AVCodecParser ff_dca_parser = {
{CODEC_ID_DTS},
sizeof(DCAParseContext),
dca_parse_init,
av_free(pc->buffer);
}
-AVCodecParser dirac_parser = {
+AVCodecParser ff_dirac_parser = {
{ CODEC_ID_DIRAC },
sizeof(DiracParseContext),
NULL,
return next;
}
-AVCodecParser dnxhd_parser = {
+AVCodecParser ff_dnxhd_parser = {
{ CODEC_ID_DNXHD },
sizeof(ParseContext),
NULL,
return 0;
}
-AVCodec dnxhd_decoder = {
+AVCodec ff_dnxhd_decoder = {
"dnxhd",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DNXHD,
return 0;
}
-AVCodec dnxhd_encoder = {
+AVCodec ff_dnxhd_encoder = {
"dnxhd",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DNXHD,
}
#define DPCM_DECODER(id, name, long_name_) \
-AVCodec name ## _decoder = { \
+AVCodec ff_ ## name ## _decoder = { \
#name, \
AVMEDIA_TYPE_AUDIO, \
id, \
return 0;
}
-AVCodec dpx_decoder = {
+AVCodec ff_dpx_decoder = {
"dpx",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DPX,
}
-AVCodec dsicinvideo_decoder = {
+AVCodec ff_dsicinvideo_decoder = {
"dsicinvideo",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DSICINVIDEO,
.long_name = NULL_IF_CONFIG_SMALL("Delphine Software International CIN video"),
};
-AVCodec dsicinaudio_decoder = {
+AVCodec ff_dsicinaudio_decoder = {
"dsicinaudio",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_DSICINAUDIO,
return 0;
}
-AVBitStreamFilter dump_extradata_bsf={
+AVBitStreamFilter ff_dump_extradata_bsf={
"dump_extra",
0,
dump_extradata,
#if CONFIG_DVVIDEO_ENCODER
-AVCodec dvvideo_encoder = {
+AVCodec ff_dvvideo_encoder = {
"dvvideo",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DVVIDEO,
#endif // CONFIG_DVVIDEO_ENCODER
#if CONFIG_DVVIDEO_DECODER
-AVCodec dvvideo_decoder = {
+AVCodec ff_dvvideo_decoder = {
"dvvideo",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DVVIDEO,
return ret;
}
-AVCodec dvbsub_encoder = {
+AVCodec ff_dvbsub_encoder = {
"dvbsub",
AVMEDIA_TYPE_SUBTITLE,
CODEC_ID_DVB_SUBTITLE,
av_freep(&pc->packet_buf);
}
-AVCodecParser dvbsub_parser = {
+AVCodecParser ff_dvbsub_parser = {
{ CODEC_ID_DVB_SUBTITLE },
sizeof(DVBSubParseContext),
dvbsub_parse_init,
}
-AVCodec dvbsub_decoder = {
+AVCodec ff_dvbsub_decoder = {
"dvbsub",
AVMEDIA_TYPE_SUBTITLE,
CODEC_ID_DVB_SUBTITLE,
av_freep(&pc->packet);
}
-AVCodecParser dvdsub_parser = {
+AVCodecParser ff_dvdsub_parser = {
{ CODEC_ID_DVD_SUBTITLE },
sizeof(DVDSubParseContext),
dvdsub_parse_init,
return buf_size;
}
-AVCodec dvdsub_decoder = {
+AVCodec ff_dvdsub_decoder = {
"dvdsub",
AVMEDIA_TYPE_SUBTITLE,
CODEC_ID_DVD_SUBTITLE,
return ret;
}
-AVCodec dvdsub_encoder = {
+AVCodec ff_dvdsub_encoder = {
"dvdsub",
AVMEDIA_TYPE_SUBTITLE,
CODEC_ID_DVD_SUBTITLE,
return 0;
}
-AVCodec dxa_decoder = {
+AVCodec ff_dxa_decoder = {
"dxa",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DXA,
return 0;
}
-AVCodec eacmv_decoder = {
+AVCodec ff_eacmv_decoder = {
"eacmv",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_CMV,
return 0;
}
-AVCodec eamad_decoder = {
+AVCodec ff_eamad_decoder = {
"eamad",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MAD,
return 0;
}
-AVCodec eatgq_decoder = {
+AVCodec ff_eatgq_decoder = {
"eatgq",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_TGQ,
return 0;
}
-AVCodec eatgv_decoder = {
+AVCodec ff_eatgv_decoder = {
"eatgv",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_TGV,
return 0;
}
-AVCodec eatqi_decoder = {
+AVCodec ff_eatqi_decoder = {
"eatqi",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_TQI,
}
-AVCodec escape124_decoder = {
+AVCodec ff_escape124_decoder = {
"escape124",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_ESCAPE124,
return buf_size;
}
-AVCodec ffv1_decoder = {
+AVCodec ff_ffv1_decoder = {
"ffv1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_FFV1,
};
#if CONFIG_FFV1_ENCODER
-AVCodec ffv1_encoder = {
+AVCodec ff_ffv1_encoder = {
"ffv1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_FFV1,
av_free(fpc->wrap_buf);
}
-AVCodecParser flac_parser = {
+AVCodecParser ff_flac_parser = {
{ CODEC_ID_FLAC },
sizeof(FLACParseContext),
flac_parse_init,
return 0;
}
-AVCodec flac_decoder = {
+AVCodec ff_flac_decoder = {
"flac",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_FLAC,
}
-AVCodec flac_encoder = {
+AVCodec ff_flac_encoder = {
"flac",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_FLAC,
}
-AVCodec flashsv_decoder = {
+AVCodec ff_flashsv_decoder = {
"flashsv",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_FLASHSV,
return 0;
}
-AVCodec flashsv_encoder = {
+AVCodec ff_flashsv_encoder = {
"flashsv",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_FLASHSV,
return 0;
}
-AVCodec flic_decoder = {
+AVCodec ff_flic_decoder = {
"flic",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_FLIC,
return 0;
}
-AVCodec flv_decoder = {
+AVCodec ff_flv_decoder = {
"flv",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_FLV1,
}
}
-AVCodec flv_encoder = {
+AVCodec ff_flv_encoder = {
"flv",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_FLV1,
}
-AVCodec fraps_decoder = {
+AVCodec ff_fraps_decoder = {
"fraps",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_FRAPS,
return 0;
}
-AVCodec frwu_decoder = {
+AVCodec ff_frwu_decoder = {
"FRWU",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_FRWU,
return avpkt->size;
}
-AVCodec adpcm_g722_decoder = {
+AVCodec ff_adpcm_g722_decoder = {
.name = "g722",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_ADPCM_G722,
return i;
}
-AVCodec adpcm_g722_encoder = {
+AVCodec ff_adpcm_g722_encoder = {
.name = "g722",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_ADPCM_G722,
}
#if CONFIG_ADPCM_G726_ENCODER
-AVCodec adpcm_g726_encoder = {
+AVCodec ff_adpcm_g726_encoder = {
"g726",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_ADPCM_G726,
};
#endif
-AVCodec adpcm_g726_decoder = {
+AVCodec ff_adpcm_g726_decoder = {
"g726",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_ADPCM_G726,
return buf_size;
}
-AVCodec g729_decoder =
+AVCodec ff_g729_decoder =
{
"g729",
AVMEDIA_TYPE_AUDIO,
return 0;
}
-AVCodec gif_encoder = {
+AVCodec ff_gif_encoder = {
"gif",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_GIF,
return 0;
}
-AVCodec gif_decoder = {
+AVCodec ff_gif_decoder = {
"gif",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_GIF,
return avctx->block_align;
}
-AVCodec gsm_decoder = {
+AVCodec ff_gsm_decoder = {
"gsm",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_GSM,
.long_name = NULL_IF_CONFIG_SMALL("GSM"),
};
-AVCodec gsm_ms_decoder = {
+AVCodec ff_gsm_ms_decoder = {
"gsm_ms",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_GSM_MS,
return next;
}
-AVCodecParser h261_parser = {
+AVCodecParser ff_h261_parser = {
{ CODEC_ID_H261 },
sizeof(ParseContext),
NULL,
return 0;
}
-AVCodec h261_decoder = {
+AVCodec ff_h261_decoder = {
"h261",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_H261,
}
}
-AVCodec h261_encoder = {
+AVCodec ff_h261_encoder = {
"h261",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_H261,
return next;
}
-AVCodecParser h263_parser = {
+AVCodecParser ff_h263_parser = {
{ CODEC_ID_H263 },
sizeof(ParseContext),
NULL,
return get_consumed_bytes(s, buf_size);
}
-AVCodec h263_decoder = {
+AVCodec ff_h263_decoder = {
"h263",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_H263,
}
-AVCodec h264_decoder = {
+AVCodec ff_h264_decoder = {
"h264",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_H264,
};
#if CONFIG_H264_VDPAU_DECODER
-AVCodec h264_vdpau_decoder = {
+AVCodec ff_h264_vdpau_decoder = {
"h264_vdpau",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_H264,
return AVERROR(EINVAL);
}
-AVBitStreamFilter h264_mp4toannexb_bsf = {
+AVBitStreamFilter ff_h264_mp4toannexb_bsf = {
"h264_mp4toannexb",
sizeof(H264BSFContext),
h264_mp4toannexb_filter,
return 0;
}
-AVCodecParser h264_parser = {
+AVCodecParser ff_h264_parser = {
{ CODEC_ID_H264 },
sizeof(H264Context),
init,
#endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
#if CONFIG_HUFFYUV_DECODER
-AVCodec huffyuv_decoder = {
+AVCodec ff_huffyuv_decoder = {
"huffyuv",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_HUFFYUV,
#endif
#if CONFIG_FFVHUFF_DECODER
-AVCodec ffvhuff_decoder = {
+AVCodec ff_ffvhuff_decoder = {
"ffvhuff",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_FFVHUFF,
#endif
#if CONFIG_HUFFYUV_ENCODER
-AVCodec huffyuv_encoder = {
+AVCodec ff_huffyuv_encoder = {
"huffyuv",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_HUFFYUV,
#endif
#if CONFIG_FFVHUFF_ENCODER
-AVCodec ffvhuff_encoder = {
+AVCodec ff_ffvhuff_encoder = {
"ffvhuff",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_FFVHUFF,
return 0;
}
-AVCodec idcin_decoder = {
+AVCodec ff_idcin_decoder = {
"idcinvideo",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_IDCIN,
return 0;
}
-AVCodec iff_ilbm_decoder = {
+AVCodec ff_iff_ilbm_decoder = {
"iff_ilbm",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_IFF_ILBM,
.long_name = NULL_IF_CONFIG_SMALL("IFF ILBM"),
};
-AVCodec iff_byterun1_decoder = {
+AVCodec ff_iff_byterun1_decoder = {
"iff_byterun1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_IFF_BYTERUN1,
}
-AVCodec imc_decoder = {
+AVCodec ff_imc_decoder = {
.name = "imc",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_IMC,
return 1;
}
-AVBitStreamFilter imx_dump_header_bsf = {
+AVBitStreamFilter ff_imx_dump_header_bsf = {
"imxdump",
0,
imx_dump_header,
return 0;
}
-AVCodec indeo2_decoder = {
+AVCodec ff_indeo2_decoder = {
"indeo2",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_INDEO2,
return 0;
}
-AVCodec indeo3_decoder = {
+AVCodec ff_indeo3_decoder = {
"indeo3",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_INDEO3,
}
-AVCodec indeo5_decoder = {
+AVCodec ff_indeo5_decoder = {
.name = "indeo5",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_INDEO5,
return 0;
}
-AVCodec h263i_decoder = {
+AVCodec ff_h263i_decoder = {
"h263i",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_H263I,
return 0;
}
-AVCodec interplay_video_decoder = {
+AVCodec ff_interplay_video_decoder = {
"interplayvideo",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_INTERPLAY_VIDEO,
}
-AVCodec jpegls_decoder = {
+AVCodec ff_jpegls_decoder = {
"jpegls",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_JPEGLS,
return 0;
}
-AVCodec jpegls_encoder = { //FIXME avoid MPV_* lossless JPEG should not need them
+AVCodec ff_jpegls_encoder = { //FIXME avoid MPV_* lossless JPEG should not need them
"jpegls",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_JPEGLS,
return 0;
}
-AVCodec kgv1_decoder = {
+AVCodec ff_kgv1_decoder = {
"kgv1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_KGV1,
return 0;
}
-AVCodec kmvc_decoder = {
+AVCodec ff_kmvc_decoder = {
"kmvc",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_KMVC,
return 0;
}
-AVCodec lagarith_decoder = {
+AVCodec ff_lagarith_decoder = {
"lagarith",
CODEC_TYPE_VIDEO,
CODEC_ID_LAGARITH,
return next;
}
-AVCodecParser aac_latm_parser = {
+AVCodecParser ff_aac_latm_parser = {
{ CODEC_ID_AAC_LATM },
sizeof(LATMParseContext),
NULL,
}
#if CONFIG_MSZH_DECODER
-AVCodec mszh_decoder = {
+AVCodec ff_mszh_decoder = {
"mszh",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MSZH,
#endif
#if CONFIG_ZLIB_DECODER
-AVCodec zlib_decoder = {
+AVCodec ff_zlib_decoder = {
"zlib",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_ZLIB,
return 0;
}
-AVCodec zlib_encoder = {
+AVCodec ff_zlib_encoder = {
"zlib",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_ZLIB,
-AVCodec libdirac_decoder = {
+AVCodec ff_libdirac_decoder = {
"libdirac",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DIRAC,
}
-AVCodec libdirac_encoder = {
+AVCodec ff_libdirac_encoder = {
"libdirac",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DIRAC,
{ FF_PROFILE_UNKNOWN },
};
-AVCodec libfaac_encoder = {
+AVCodec ff_libfaac_encoder = {
"libfaac",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_AAC,
}
-AVCodec libgsm_encoder = {
+AVCodec ff_libgsm_encoder = {
"libgsm",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_GSM,
.long_name = NULL_IF_CONFIG_SMALL("libgsm GSM"),
};
-AVCodec libgsm_ms_encoder = {
+AVCodec ff_libgsm_ms_encoder = {
"libgsm_ms",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_GSM_MS,
return avctx->block_align;
}
-AVCodec libgsm_decoder = {
+AVCodec ff_libgsm_decoder = {
"libgsm",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_GSM,
.long_name = NULL_IF_CONFIG_SMALL("libgsm GSM"),
};
-AVCodec libgsm_ms_decoder = {
+AVCodec ff_libgsm_ms_decoder = {
"libgsm_ms",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_GSM_MS,
}
-AVCodec libmp3lame_encoder = {
+AVCodec ff_libmp3lame_encoder = {
"libmp3lame",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_MP3,
return packet_size;
}
-AVCodec libopencore_amrnb_decoder = {
+AVCodec ff_libopencore_amrnb_decoder = {
"libopencore_amrnb",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_AMR_NB,
return written;
}
-AVCodec libopencore_amrnb_encoder = {
+AVCodec ff_libopencore_amrnb_encoder = {
"libopencore_amrnb",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_AMR_NB,
return 0;
}
-AVCodec libopencore_amrwb_decoder = {
+AVCodec ff_libopencore_amrwb_decoder = {
"libopencore_amrwb",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_AMR_WB,
}
-AVCodec libopenjpeg_decoder = {
+AVCodec ff_libopenjpeg_decoder = {
"libopenjpeg",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_JPEG2000,
p_schro_params->eos_signalled = 0;
}
-AVCodec libschroedinger_decoder = {
+AVCodec ff_libschroedinger_decoder = {
"libschroedinger",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DIRAC,
}
-AVCodec libschroedinger_encoder = {
+AVCodec ff_libschroedinger_encoder = {
"libschroedinger",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DIRAC,
return 0;
}
-AVCodec libspeex_decoder = {
+AVCodec ff_libspeex_decoder = {
"libspeex",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_SPEEX,
}
/** AVCodec struct exposed to libavcodec */
-AVCodec libtheora_encoder = {
+AVCodec ff_libtheora_encoder = {
.name = "libtheora",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_THEORA,
}
-AVCodec libvorbis_encoder = {
+AVCodec ff_libvorbis_encoder = {
"libvorbis",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_VORBIS,
return 0;
}
-AVCodec libvpx_decoder = {
+AVCodec ff_libvpx_decoder = {
"libvpx",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_VP8,
return coded_size;
}
-AVCodec libvpx_encoder = {
+AVCodec ff_libvpx_encoder = {
"libvpx",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_VP8,
return 0;
}
-AVCodec libx264_encoder = {
+AVCodec ff_libx264_encoder = {
.name = "libx264",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_H264,
return 0;
}
-AVCodec libxavs_encoder = {
+AVCodec ff_libxavs_encoder = {
.name = "libxavs",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_CAVS,
/**
* Xvid codec definition for libavcodec.
*/
-AVCodec libxvid_encoder = {
+AVCodec ff_libxvid_encoder = {
"libxvid",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG4,
}
-AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless JPEG should not need them
+AVCodec ff_ljpeg_encoder = { //FIXME avoid MPV_* lossless JPEG should not need them
"ljpeg",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_LJPEG,
return 0;
}
-AVCodec loco_decoder = {
+AVCodec ff_loco_decoder = {
"loco",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_LOCO,
return buf_size;
}
-AVCodec mace3_decoder = {
+AVCodec ff_mace3_decoder = {
"mace3",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_MACE3,
.long_name = NULL_IF_CONFIG_SMALL("MACE (Macintosh Audio Compression/Expansion) 3:1"),
};
-AVCodec mace6_decoder = {
+AVCodec ff_mace6_decoder = {
"mace6",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_MACE6,
return 0;
}
-AVCodec mdec_decoder = {
+AVCodec ff_mdec_decoder = {
"mdec",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MDEC,
return 0;
}
-AVCodec mimic_decoder = {
+AVCodec ff_mimic_decoder = {
"mimic",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MIMIC,
return 1;
}
-AVBitStreamFilter mjpeg2jpeg_bsf = {
+AVBitStreamFilter ff_mjpeg2jpeg_bsf = {
.name = "mjpeg2jpeg",
.priv_data_size = 0,
.filter = mjpeg2jpeg_filter,
}
-AVCodecParser mjpeg_parser = {
+AVCodecParser ff_mjpeg_parser = {
{ CODEC_ID_MJPEG },
sizeof(ParseContext),
NULL,
return 0;
}
-AVBitStreamFilter mjpega_dump_header_bsf = {
+AVBitStreamFilter ff_mjpega_dump_header_bsf = {
"mjpegadump",
0,
mjpega_dump_header,
return buf_ptr - buf;
}
-AVCodec mjpegb_decoder = {
+AVCodec ff_mjpegb_decoder = {
"mjpegb",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MJPEGB,
return 0;
}
-AVCodec mjpeg_decoder = {
+AVCodec ff_mjpeg_decoder = {
"mjpeg",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MJPEG,
.long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
};
-AVCodec thp_decoder = {
+AVCodec ff_thp_decoder = {
"thp",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_THP,
s->i_tex_bits += get_bits_diff(s);
}
-AVCodec mjpeg_encoder = {
+AVCodec ff_mjpeg_encoder = {
"mjpeg",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MJPEG,
return 1;
}
-AVCodecParser mlp_parser = {
+AVCodecParser ff_mlp_parser = {
{ CODEC_ID_MLP, CODEC_ID_TRUEHD },
sizeof(MLPParseContext),
mlp_init,
return -1;
}
-AVCodec mlp_decoder = {
+AVCodec ff_mlp_decoder = {
"mlp",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_MLP,
};
#if CONFIG_TRUEHD_DECODER
-AVCodec truehd_decoder = {
+AVCodec ff_truehd_decoder = {
"truehd",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_TRUEHD,
return 0;
}
-AVCodec mmvideo_decoder = {
+AVCodec ff_mmvideo_decoder = {
"mmvideo",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MMVIDEO,
return 0;
}
-AVCodec motionpixels_decoder = {
+AVCodec ff_motionpixels_decoder = {
"motionpixels",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MOTIONPIXELS,
return 1;
}
-AVBitStreamFilter text2movsub_bsf={
+AVBitStreamFilter ff_text2movsub_bsf={
"text2movsub",
0,
text2movsub,
return 1;
}
-AVBitStreamFilter mov2textsub_bsf={
+AVBitStreamFilter ff_mov2textsub_bsf={
"mov2textsub",
0,
mov2textsub,
return 1;
}
-AVBitStreamFilter mp3_header_compress_bsf={
+AVBitStreamFilter ff_mp3_header_compress_bsf={
"mp3comp",
0,
mp3_header_compress,
return 1;
}
-AVBitStreamFilter mp3_header_decompress_bsf={
+AVBitStreamFilter ff_mp3_header_decompress_bsf={
"mp3decomp",
0,
mp3_header_decompress,
c->frames_to_skip = 32;
}
-AVCodec mpc7_decoder = {
+AVCodec ff_mpc7_decoder = {
"mpc7",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_MUSEPACK7,
return c->cur_frame ? c->last_bits_used >> 3 : buf_size;
}
-AVCodec mpc8_decoder = {
+AVCodec ff_mpc8_decoder = {
"mpc8",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_MUSEPACK8,
return 0;
}
-AVCodec mpeg1video_decoder = {
+AVCodec ff_mpeg1video_decoder = {
"mpeg1video",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG1VIDEO,
.long_name= NULL_IF_CONFIG_SMALL("MPEG-1 video"),
};
-AVCodec mpeg2video_decoder = {
+AVCodec ff_mpeg2video_decoder = {
"mpeg2video",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG2VIDEO,
};
//legacy decoder
-AVCodec mpegvideo_decoder = {
+AVCodec ff_mpegvideo_decoder = {
"mpegvideo",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG2VIDEO,
return 0;
}
-AVCodec mpeg_xvmc_decoder = {
+AVCodec ff_mpeg_xvmc_decoder = {
"mpegvideo_xvmc",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG2VIDEO_XVMC,
#endif
#if CONFIG_MPEG_VDPAU_DECODER
-AVCodec mpeg_vdpau_decoder = {
+AVCodec ff_mpeg_vdpau_decoder = {
"mpegvideo_vdpau",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG2VIDEO,
#endif
#if CONFIG_MPEG1_VDPAU_DECODER
-AVCodec mpeg1_vdpau_decoder = {
+AVCodec ff_mpeg1_vdpau_decoder = {
"mpeg1video_vdpau",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG1VIDEO,
put_bits(&s->pb, table_vlc[112][1], table_vlc[112][0]);
}
-AVCodec mpeg1video_encoder = {
+AVCodec ff_mpeg1video_encoder = {
"mpeg1video",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG1VIDEO,
.long_name= NULL_IF_CONFIG_SMALL("MPEG-1 video"),
};
-AVCodec mpeg2video_encoder = {
+AVCodec ff_mpeg2video_encoder = {
"mpeg2video",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG2VIDEO,
}
-AVCodecParser mpeg4video_parser = {
+AVCodecParser ff_mpeg4video_parser = {
{ CODEC_ID_MPEG4 },
sizeof(ParseContext1),
mpeg4video_parse_init,
return 0;
}
-AVCodec mpeg4_decoder = {
+AVCodec ff_mpeg4_decoder = {
"mpeg4",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG4,
#if CONFIG_MPEG4_VDPAU_DECODER
-AVCodec mpeg4_vdpau_decoder = {
+AVCodec ff_mpeg4_vdpau_decoder = {
"mpeg4_vdpau",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG4,
put_bits(&s->pb, 1, 0); /* no HEC */
}
-AVCodec mpeg4_encoder = {
+AVCodec ff_mpeg4_encoder = {
"mpeg4",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG4,
}
-AVCodecParser mpegaudio_parser = {
+AVCodecParser ff_mpegaudio_parser = {
{ CODEC_ID_MP1, CODEC_ID_MP2, CODEC_ID_MP3 },
sizeof(MpegAudioParseContext),
NULL,
#if !CONFIG_FLOAT
#if CONFIG_MP1_DECODER
-AVCodec mp1_decoder =
+AVCodec ff_mp1_decoder =
{
"mp1",
AVMEDIA_TYPE_AUDIO,
};
#endif
#if CONFIG_MP2_DECODER
-AVCodec mp2_decoder =
+AVCodec ff_mp2_decoder =
{
"mp2",
AVMEDIA_TYPE_AUDIO,
};
#endif
#if CONFIG_MP3_DECODER
-AVCodec mp3_decoder =
+AVCodec ff_mp3_decoder =
{
"mp3",
AVMEDIA_TYPE_AUDIO,
};
#endif
#if CONFIG_MP3ADU_DECODER
-AVCodec mp3adu_decoder =
+AVCodec ff_mp3adu_decoder =
{
"mp3adu",
AVMEDIA_TYPE_AUDIO,
};
#endif
#if CONFIG_MP3ON4_DECODER
-AVCodec mp3on4_decoder =
+AVCodec ff_mp3on4_decoder =
{
"mp3on4",
AVMEDIA_TYPE_AUDIO,
}
#if CONFIG_MP1FLOAT_DECODER
-AVCodec mp1float_decoder =
+AVCodec ff_mp1float_decoder =
{
"mp1float",
AVMEDIA_TYPE_AUDIO,
};
#endif
#if CONFIG_MP2FLOAT_DECODER
-AVCodec mp2float_decoder =
+AVCodec ff_mp2float_decoder =
{
"mp2float",
AVMEDIA_TYPE_AUDIO,
};
#endif
#if CONFIG_MP3FLOAT_DECODER
-AVCodec mp3float_decoder =
+AVCodec ff_mp3float_decoder =
{
"mp3float",
AVMEDIA_TYPE_AUDIO,
};
#endif
#if CONFIG_MP3ADUFLOAT_DECODER
-AVCodec mp3adufloat_decoder =
+AVCodec ff_mp3adufloat_decoder =
{
"mp3adufloat",
AVMEDIA_TYPE_AUDIO,
};
#endif
#if CONFIG_MP3ON4FLOAT_DECODER
-AVCodec mp3on4float_decoder =
+AVCodec ff_mp3on4float_decoder =
{
"mp3on4float",
AVMEDIA_TYPE_AUDIO,
return 0;
}
-AVCodec mp2_encoder = {
+AVCodec ff_mp2_encoder = {
"mp2",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_MP2,
return last_non_zero;
}
-AVCodec h263_encoder = {
+AVCodec ff_h263_encoder = {
"h263",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_H263,
.long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
};
-AVCodec h263p_encoder = {
+AVCodec ff_h263p_encoder = {
"h263p",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_H263P,
.long_name= NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
};
-AVCodec msmpeg4v1_encoder = {
+AVCodec ff_msmpeg4v1_encoder = {
"msmpeg4v1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MSMPEG4V1,
.long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
};
-AVCodec msmpeg4v2_encoder = {
+AVCodec ff_msmpeg4v2_encoder = {
"msmpeg4v2",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MSMPEG4V2,
.long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
};
-AVCodec msmpeg4v3_encoder = {
+AVCodec ff_msmpeg4v3_encoder = {
"msmpeg4",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MSMPEG4V3,
.long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
};
-AVCodec wmv1_encoder = {
+AVCodec ff_wmv1_encoder = {
"wmv1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_WMV1,
return 0;
}
-AVCodecParser mpegvideo_parser = {
+AVCodecParser ff_mpegvideo_parser = {
{ CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
sizeof(ParseContext1),
NULL,
return 0;
}
-AVCodec msmpeg4v1_decoder = {
+AVCodec ff_msmpeg4v1_decoder = {
"msmpeg4v1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MSMPEG4V1,
.pix_fmts= ff_pixfmt_list_420,
};
-AVCodec msmpeg4v2_decoder = {
+AVCodec ff_msmpeg4v2_decoder = {
"msmpeg4v2",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MSMPEG4V2,
.pix_fmts= ff_pixfmt_list_420,
};
-AVCodec msmpeg4v3_decoder = {
+AVCodec ff_msmpeg4v3_decoder = {
"msmpeg4",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MSMPEG4V3,
.pix_fmts= ff_pixfmt_list_420,
};
-AVCodec wmv1_decoder = {
+AVCodec ff_wmv1_decoder = {
"wmv1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_WMV1,
return 0;
}
-AVCodec msrle_decoder = {
+AVCodec ff_msrle_decoder = {
"msrle",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MSRLE,
return 0;
}
-AVCodec msvideo1_decoder = {
+AVCodec ff_msvideo1_decoder = {
"msvideo1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MSVIDEO1,
return 0;
}
-AVCodec nellymoser_decoder = {
+AVCodec ff_nellymoser_decoder = {
"nellymoser",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_NELLYMOSER,
return 0;
}
-AVCodec nellymoser_encoder = {
+AVCodec ff_nellymoser_encoder = {
.name = "nellymoser",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_NELLYMOSER,
return 1;
}
-AVBitStreamFilter noise_bsf={
+AVBitStreamFilter ff_noise_bsf={
"noise",
sizeof(int),
noise,
return 0;
}
-AVCodec nuv_decoder = {
+AVCodec ff_nuv_decoder = {
"nuv",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_NUV,
}
-AVCodec pam_encoder = {
+AVCodec ff_pam_encoder = {
"pam",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_PAM,
return retval;
}
-AVCodec pcm_bluray_decoder = {
+AVCodec ff_pcm_bluray_decoder = {
"pcm_bluray",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_PCM_BLURAY,
#if CONFIG_ENCODERS
#define PCM_ENCODER(id_,sample_fmt_,name_,long_name_) \
-AVCodec name_ ## _encoder = { \
+AVCodec ff_ ## name_ ## _encoder = { \
.name = #name_, \
.type = AVMEDIA_TYPE_AUDIO, \
.id = id_, \
#if CONFIG_DECODERS
#define PCM_DECODER(id_,sample_fmt_,name_,long_name_) \
-AVCodec name_ ## _decoder = { \
+AVCodec ff_ ## name_ ## _decoder = { \
.name = #name_, \
.type = AVMEDIA_TYPE_AUDIO, \
.id = id_, \
return 0;
}
-AVCodec pcx_decoder = {
+AVCodec ff_pcx_decoder = {
"pcx",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_PCX,
return buf - buf_start;
}
-AVCodec pcx_encoder = {
+AVCodec ff_pcx_encoder = {
"pcx",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_PCX,
return buf_size;
}
-AVCodec pgssub_decoder = {
+AVCodec ff_pgssub_decoder = {
"pgssub",
AVMEDIA_TYPE_SUBTITLE,
CODEC_ID_HDMV_PGS_SUBTITLE,
return 0;
}
-AVCodec pictor_decoder = {
+AVCodec ff_pictor_decoder = {
"pictor",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_PICTOR,
return 0;
}
-AVCodec png_decoder = {
+AVCodec ff_png_decoder = {
"png",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_PNG,
return 0;
}
-AVCodec png_encoder = {
+AVCodec ff_png_encoder = {
"png",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_PNG,
return next;
}
-AVCodecParser pnm_parser = {
+AVCodecParser ff_pnm_parser = {
{ CODEC_ID_PGM, CODEC_ID_PGMYUV, CODEC_ID_PPM, CODEC_ID_PBM, CODEC_ID_PAM},
sizeof(ParseContext),
NULL,
#if CONFIG_PGM_DECODER
-AVCodec pgm_decoder = {
+AVCodec ff_pgm_decoder = {
"pgm",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_PGM,
#endif
#if CONFIG_PGMYUV_DECODER
-AVCodec pgmyuv_decoder = {
+AVCodec ff_pgmyuv_decoder = {
"pgmyuv",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_PGMYUV,
#endif
#if CONFIG_PPM_DECODER
-AVCodec ppm_decoder = {
+AVCodec ff_ppm_decoder = {
"ppm",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_PPM,
#endif
#if CONFIG_PBM_DECODER
-AVCodec pbm_decoder = {
+AVCodec ff_pbm_decoder = {
"pbm",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_PBM,
#endif
#if CONFIG_PAM_DECODER
-AVCodec pam_decoder = {
+AVCodec ff_pam_decoder = {
"pam",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_PAM,
#if CONFIG_PGM_ENCODER
-AVCodec pgm_encoder = {
+AVCodec ff_pgm_encoder = {
"pgm",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_PGM,
#endif
#if CONFIG_PGMYUV_ENCODER
-AVCodec pgmyuv_encoder = {
+AVCodec ff_pgmyuv_encoder = {
"pgmyuv",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_PGMYUV,
#endif
#if CONFIG_PPM_ENCODER
-AVCodec ppm_encoder = {
+AVCodec ff_ppm_encoder = {
"ppm",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_PPM,
#endif
#if CONFIG_PBM_ENCODER
-AVCodec pbm_encoder = {
+AVCodec ff_pbm_encoder = {
"pbm",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_PBM,
return 0;
}
-AVCodec ptx_decoder = {
+AVCodec ff_ptx_decoder = {
"ptx",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_PTX,
return *data_size;
}
-AVCodec qcelp_decoder =
+AVCodec ff_qcelp_decoder =
{
.name = "qcelp",
.type = AVMEDIA_TYPE_AUDIO,
return s->checksum_size;
}
-AVCodec qdm2_decoder =
+AVCodec ff_qdm2_decoder =
{
.name = "qdm2",
.type = AVMEDIA_TYPE_AUDIO,
return 0;
}
-AVCodec qdraw_decoder = {
+AVCodec ff_qdraw_decoder = {
"qdraw",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_QDRAW,
return 0;
}
-AVCodec qpeg_decoder = {
+AVCodec ff_qpeg_decoder = {
"qpeg",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_QPEG,
return 0;
}
-AVCodec qtrle_decoder = {
+AVCodec ff_qtrle_decoder = {
"qtrle",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_QTRLE,
return 0;
}
-AVCodec qtrle_encoder = {
+AVCodec ff_qtrle_encoder = {
"qtrle",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_QTRLE,
}
#if CONFIG_R210_DECODER
-AVCodec r210_decoder = {
+AVCodec ff_r210_decoder = {
"r210",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_R210,
};
#endif
#if CONFIG_R10K_DECODER
-AVCodec r10k_decoder = {
+AVCodec ff_r10k_decoder = {
"r10k",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_R10K,
return 20;
}
-AVCodec ra_144_decoder =
+AVCodec ff_ra_144_decoder =
{
"real_144",
AVMEDIA_TYPE_AUDIO,
}
-AVCodec ra_144_encoder =
+AVCodec ff_ra_144_encoder =
{
"real_144",
AVMEDIA_TYPE_AUDIO,
return avctx->block_align;
}
-AVCodec ra_288_decoder =
+AVCodec ff_ra_288_decoder =
{
"real_288",
AVMEDIA_TYPE_AUDIO,
return 0;
}
-AVCodec rawvideo_decoder = {
+AVCodec ff_rawvideo_decoder = {
"rawvideo",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_RAWVIDEO,
return ret;
}
-AVCodec rawvideo_encoder = {
+AVCodec ff_rawvideo_encoder = {
"rawvideo",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_RAWVIDEO,
return 0;
}
-AVBitStreamFilter remove_extradata_bsf={
+AVBitStreamFilter ff_remove_extradata_bsf={
"remove_extra",
0,
remove_extradata,
}
-AVCodec rl2_decoder = {
+AVCodec ff_rl2_decoder = {
"rl2",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_RL2,
return 0;
}
-AVCodec roq_dpcm_encoder = {
+AVCodec ff_roq_dpcm_encoder = {
"roq_dpcm",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_ROQ_DPCM,
return 0;
}
-AVCodec roq_decoder = {
+AVCodec ff_roq_decoder = {
"roqvideo",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_ROQ,
return 0;
}
-AVCodec roq_encoder =
+AVCodec ff_roq_encoder =
{
"roqvideo",
AVMEDIA_TYPE_VIDEO,
return 0;
}
-AVCodec rpza_decoder = {
+AVCodec ff_rpza_decoder = {
"rpza",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_RPZA,
return buf_size;
}
-AVCodec rv10_decoder = {
+AVCodec ff_rv10_decoder = {
"rv10",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_RV10,
.pix_fmts= ff_pixfmt_list_420,
};
-AVCodec rv20_decoder = {
+AVCodec ff_rv20_decoder = {
"rv20",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_RV20,
put_bits(&s->pb, 3, 0); /* ignored */
}
-AVCodec rv10_encoder = {
+AVCodec ff_rv10_encoder = {
"rv10",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_RV10,
}
}
-AVCodec rv20_encoder = {
+AVCodec ff_rv20_encoder = {
"rv20",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_RV20,
return 0;
}
-AVCodec rv30_decoder = {
+AVCodec ff_rv30_decoder = {
"rv30",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_RV30,
return 0;
}
-AVCodec rv40_decoder = {
+AVCodec ff_rv40_decoder = {
"rv40",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_RV40,
return 0;
}
-AVCodec sgi_decoder = {
+AVCodec ff_sgi_decoder = {
"sgi",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_SGI,
return buf - orig_buf;
}
-AVCodec sgi_encoder = {
+AVCodec ff_sgi_encoder = {
"sgi",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_SGI,
s->bitstream_index= 0;
}
-AVCodec shorten_decoder = {
+AVCodec ff_shorten_decoder = {
"shorten",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_SHORTEN,
return mode_par->bits_per_frame >> 3;
}
-AVCodec sipr_decoder = {
+AVCodec ff_sipr_decoder = {
"sipr",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_SIPR,
return buf_size;
}
-AVCodec smacker_decoder = {
+AVCodec ff_smacker_decoder = {
"smackvid",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_SMACKVIDEO,
.long_name = NULL_IF_CONFIG_SMALL("Smacker video"),
};
-AVCodec smackaud_decoder = {
+AVCodec ff_smackaud_decoder = {
"smackaud",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_SMACKAUDIO,
return 0;
}
-AVCodec smc_decoder = {
+AVCodec ff_smc_decoder = {
"smc",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_SMC,
return 0;
}
-AVCodec snow_decoder = {
+AVCodec ff_snow_decoder = {
"snow",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_SNOW,
return 0;
}
-AVCodec snow_encoder = {
+AVCodec ff_snow_encoder = {
"snow",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_SNOW,
return (get_bits_count(&gb)+7)/8;
}
-AVCodec sonic_decoder = {
+AVCodec ff_sonic_decoder = {
"sonic",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_SONIC,
#endif /* CONFIG_SONIC_DECODER */
#if CONFIG_SONIC_ENCODER
-AVCodec sonic_encoder = {
+AVCodec ff_sonic_encoder = {
"sonic",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_SONIC,
#endif
#if CONFIG_SONIC_LS_ENCODER
-AVCodec sonic_ls_encoder = {
+AVCodec ff_sonic_ls_encoder = {
"sonicls",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_SONIC_LS,
return i;
}
-AVCodec sp5x_decoder = {
+AVCodec ff_sp5x_decoder = {
"sp5x",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_SP5X,
.long_name = NULL_IF_CONFIG_SMALL("Sunplus JPEG (SP5X)"),
};
-AVCodec amv_decoder = {
+AVCodec ff_amv_decoder = {
"amv",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_AMV,
return avpkt->size;
}
-AVCodec srt_decoder = {
+AVCodec ff_srt_decoder = {
.name = "srt",
.long_name = NULL_IF_CONFIG_SMALL("SubRip subtitle"),
.type = AVMEDIA_TYPE_SUBTITLE,
return 0;
}
-AVCodec sunrast_decoder = {
+AVCodec ff_sunrast_decoder = {
"sunrast",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_SUNRAST,
}
-AVCodec svq1_decoder = {
+AVCodec ff_svq1_decoder = {
"svq1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_SVQ1,
}
-AVCodec svq1_encoder = {
+AVCodec ff_svq1_encoder = {
"svq1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_SVQ1,
}
-AVCodec svq3_decoder = {
+AVCodec ff_svq3_decoder = {
"svq3",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_SVQ3,
return 0;
}
-AVCodec targa_decoder = {
+AVCodec ff_targa_decoder = {
"targa",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_TARGA,
return 0;
}
-AVCodec targa_encoder = {
+AVCodec ff_targa_encoder = {
.name = "targa",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_TARGA,
return 0;
}
-AVCodec tiertexseqvideo_decoder = {
+AVCodec ff_tiertexseqvideo_decoder = {
"tiertexseqvideo",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_TIERTEXSEQVIDEO,
return 0;
}
-AVCodec tiff_decoder = {
+AVCodec ff_tiff_decoder = {
"tiff",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_TIFF,
return ret;
}
-AVCodec tiff_encoder = {
+AVCodec ff_tiff_encoder = {
"tiff",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_TIFF,
return 0;
}
-AVCodec tmv_decoder = {
+AVCodec ff_tmv_decoder = {
.name = "tmv",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_TMV,
return 0;
}
-AVCodec truemotion1_decoder = {
+AVCodec ff_truemotion1_decoder = {
"truemotion1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_TRUEMOTION1,
return 0;
}
-AVCodec truemotion2_decoder = {
+AVCodec ff_truemotion2_decoder = {
"truemotion2",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_TRUEMOTION2,
return consumed;
}
-AVCodec truespeech_decoder = {
+AVCodec ff_truespeech_decoder = {
"truespeech",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_TRUESPEECH,
return 0;
}
-AVCodec tscc_decoder = {
+AVCodec ff_tscc_decoder = {
"camtasia",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_TSCC,
return 0;
}
-AVCodec tta_decoder = {
+AVCodec ff_tta_decoder = {
"tta",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_TTA,
return 0;
}
-AVCodec twinvq_decoder =
+AVCodec ff_twinvq_decoder =
{
"twinvq",
AVMEDIA_TYPE_AUDIO,
return 0;
}
-AVCodec txd_decoder = {
+AVCodec ff_txd_decoder = {
"txd",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_TXD,
return buf_size;
}
-AVCodec ulti_decoder = {
+AVCodec ff_ulti_decoder = {
"ultimotion",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_ULTI,
return 0;
}
-AVCodec v210_decoder = {
+AVCodec ff_v210_decoder = {
"v210",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_V210,
return 0;
}
-AVCodec v210_encoder = {
+AVCodec ff_v210_encoder = {
"v210",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_V210,
return 0;
}
-AVCodec v210x_decoder = {
+AVCodec ff_v210x_decoder = {
"v210x",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_V210X,
return 0;
}
-AVCodec vb_decoder = {
+AVCodec ff_vb_decoder = {
"vb",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_VB,
return 0;
}
-AVCodecParser vc1_parser = {
+AVCodecParser ff_vc1_parser = {
{ CODEC_ID_VC1 },
sizeof(VC1ParseContext),
NULL,
}
-AVCodec vc1_decoder = {
+AVCodec ff_vc1_decoder = {
"vc1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_VC1,
};
#if CONFIG_WMV3_DECODER
-AVCodec wmv3_decoder = {
+AVCodec ff_wmv3_decoder = {
"wmv3",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_WMV3,
#endif
#if CONFIG_WMV3_VDPAU_DECODER
-AVCodec wmv3_vdpau_decoder = {
+AVCodec ff_wmv3_vdpau_decoder = {
"wmv3_vdpau",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_WMV3,
#endif
#if CONFIG_VC1_VDPAU_DECODER
-AVCodec vc1_vdpau_decoder = {
+AVCodec ff_vc1_vdpau_decoder = {
"vc1_vdpau",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_VC1,
}
#endif
-AVCodec vcr1_decoder = {
+AVCodec ff_vcr1_decoder = {
"vcr1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_VCR1,
};
#if CONFIG_VCR1_ENCODER
-AVCodec vcr1_encoder = {
+AVCodec ff_vcr1_encoder = {
"vcr1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_VCR1,
* Public Data Structures
*/
-AVCodec vmdvideo_decoder = {
+AVCodec ff_vmdvideo_decoder = {
"vmdvideo",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_VMDVIDEO,
.long_name = NULL_IF_CONFIG_SMALL("Sierra VMD video"),
};
-AVCodec vmdaudio_decoder = {
+AVCodec ff_vmdaudio_decoder = {
"vmdaudio",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_VMDAUDIO,
return 0;
}
-AVCodec vmnc_decoder = {
+AVCodec ff_vmnc_decoder = {
"vmnc",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_VMNC,
return 0 ;
}
-AVCodec vorbis_decoder = {
+AVCodec ff_vorbis_decoder = {
"vorbis",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_VORBIS,
return 0 ;
}
-AVCodec vorbis_encoder = {
+AVCodec ff_vorbis_encoder = {
"vorbis",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_VORBIS,
return vp3_decode_init(avctx);
}
-AVCodec theora_decoder = {
+AVCodec ff_theora_decoder = {
"theora",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_THEORA,
};
#endif
-AVCodec vp3_decoder = {
+AVCodec ff_vp3_decoder = {
"vp3",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_VP3,
return buf_size;
}
-AVCodecParser vp3_parser = {
+AVCodecParser ff_vp3_parser = {
{ CODEC_ID_THEORA, CODEC_ID_VP3,
CODEC_ID_VP6, CODEC_ID_VP6F, CODEC_ID_VP6A },
0,
return 0;
}
-AVCodec vp5_decoder = {
+AVCodec ff_vp5_decoder = {
"vp5",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_VP5,
return 0;
}
-AVCodec vp6_decoder = {
+AVCodec ff_vp6_decoder = {
"vp6",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_VP6,
};
/* flash version, not flipped upside-down */
-AVCodec vp6f_decoder = {
+AVCodec ff_vp6f_decoder = {
"vp6f",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_VP6F,
};
/* flash version, not flipped upside-down, with alpha channel */
-AVCodec vp6a_decoder = {
+AVCodec ff_vp6a_decoder = {
"vp6a",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_VP6A,
return 0;
}
-AVCodec vp8_decoder = {
+AVCodec ff_vp8_decoder = {
"vp8",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_VP8,
return buf_size;
}
-AVCodecParser vp8_parser = {
+AVCodecParser ff_vp8_parser = {
{ CODEC_ID_VP8 },
0,
NULL,
return 0;
}
-AVCodec vqa_decoder = {
+AVCodec ff_vqa_decoder = {
"vqavideo",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_WS_VQA,
return s->samples_left > 0 ? 0 : avpkt->size;
}
-AVCodec wavpack_decoder = {
+AVCodec ff_wavpack_decoder = {
"wavpack",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_WAVPACK,
s->last_superframe_len= 0;
}
-AVCodec wmav1_decoder =
+AVCodec ff_wmav1_decoder =
{
"wmav1",
AVMEDIA_TYPE_AUDIO,
.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
};
-AVCodec wmav2_decoder =
+AVCodec ff_wmav2_decoder =
{
"wmav2",
AVMEDIA_TYPE_AUDIO,
return put_bits_ptr(&s->pb) - s->pb.buf;
}
-AVCodec wmav1_encoder =
+AVCodec ff_wmav1_encoder =
{
"wmav1",
AVMEDIA_TYPE_AUDIO,
.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
};
-AVCodec wmav2_encoder =
+AVCodec ff_wmav2_encoder =
{
"wmav2",
AVMEDIA_TYPE_AUDIO,
/**
*@brief wmapro decoder
*/
-AVCodec wmapro_decoder = {
+AVCodec ff_wmapro_decoder = {
"wmapro",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_WMAPRO,
}
}
-AVCodec wmavoice_decoder = {
+AVCodec ff_wmavoice_decoder = {
"wmavoice",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_WMAVOICE,
return ff_h263_decode_end(avctx);
}
-AVCodec wmv2_decoder = {
+AVCodec ff_wmv2_decoder = {
"wmv2",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_WMV2,
}
}
-AVCodec wmv2_encoder = {
+AVCodec ff_wmv2_encoder = {
"wmv2",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_WMV2,
return 0;
}
-AVCodec wnv1_decoder = {
+AVCodec ff_wnv1_decoder = {
"wnv1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_WNV1,
return buf_size;
}
-AVCodec ws_snd1_decoder = {
+AVCodec ff_ws_snd1_decoder = {
"ws_snd1",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_WESTWOOD_SND1,
return 0;
}
-AVCodec xan_wc3_decoder = {
+AVCodec ff_xan_wc3_decoder = {
"xan_wc3",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_XAN_WC3,
};
/*
-AVCodec xan_wc4_decoder = {
+AVCodec ff_xan_wc4_decoder = {
"xan_wc4",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_XAN_WC4,
return 0;
}
-AVCodec xl_decoder = {
+AVCodec ff_xl_decoder = {
"xl",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_VIXL,
return buf_size;
}
-AVCodec xsub_decoder = {
+AVCodec ff_xsub_decoder = {
"xsub",
AVMEDIA_TYPE_SUBTITLE,
CODEC_ID_XSUB,
return 0;
}
-AVCodec xsub_encoder = {
+AVCodec ff_xsub_encoder = {
"xsub",
AVMEDIA_TYPE_SUBTITLE,
CODEC_ID_XSUB,
return avpkt->size;
}
-AVCodec yop_decoder = {
+AVCodec ff_yop_decoder = {
"yop",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_YOP,
return 0;
}
-AVCodec zmbv_decoder = {
+AVCodec ff_zmbv_decoder = {
"zmbv",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_ZMBV,
return 0;
}
-AVCodec zmbv_encoder = {
+AVCodec ff_zmbv_encoder = {
"zmbv",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_ZMBV,
projects / platform / upstream / libav.git / commitdiff