virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-23 12:43:46 +02:00
Code Issues Releases Activity

Use explicit struct initializers for AVCodec declarations.

Browse Source
This commit is contained in:
Diego Biurrun 2011-09-23 21:11:15 +02:00
parent 30b4ee7901
commit 8671488799
16 changed files with 252 additions and 303 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
libavcodec/adpcm.c
View File

@ -1086,17 +1086,15 @@ static int adpcm_decode_frame(AVCodecContext *avctx,
} }
#define ADPCM_DECODER(id,name,long_name_) \ #define ADPCM_DECODER(id_, name_, long_name_) \
AVCodec ff_ ## name ## _decoder = { \ AVCodec ff_ ## name_ ## _decoder = { \
#name, \ .name = #name_, \
AVMEDIA_TYPE_AUDIO, \ .type = AVMEDIA_TYPE_AUDIO, \
id, \ .id = id_, \
sizeof(ADPCMDecodeContext), \ .priv_data_size = sizeof(ADPCMDecodeContext), \
adpcm_decode_init, \ .init = adpcm_decode_init, \
NULL, \ .decode = adpcm_decode_frame, \
NULL, \ .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
adpcm_decode_frame, \
.long_name = NULL_IF_CONFIG_SMALL(long_name_), \
} }
/* Note: Do not forget to add new entries to the Makefile as well. */ /* Note: Do not forget to add new entries to the Makefile as well. */

23
libavcodec/adpcmenc.c
View File

@ -667,18 +667,17 @@ static int adpcm_encode_frame(AVCodecContext *avctx,
} }
#define ADPCM_ENCODER(id,name,long_name_) \ #define ADPCM_ENCODER(id_, name_, long_name_) \
AVCodec ff_ ## name ## _encoder = { \ AVCodec ff_ ## name_ ## _encoder = { \
#name, \ .name = #name_, \
AVMEDIA_TYPE_AUDIO, \ .type = AVMEDIA_TYPE_AUDIO, \
id, \ .id = id_, \
sizeof(ADPCMEncodeContext), \ .priv_data_size = sizeof(ADPCMEncodeContext), \
adpcm_encode_init, \ .init = adpcm_encode_init, \
adpcm_encode_frame, \ .encode = adpcm_encode_frame, \
adpcm_encode_close, \ .close = adpcm_encode_close, \
NULL, \ .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, \
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, \ .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
.long_name = NULL_IF_CONFIG_SMALL(long_name_), \
} }
ADPCM_ENCODER(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt, "ADPCM IMA QuickTime"); ADPCM_ENCODER(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt, "ADPCM IMA QuickTime");

20
libavcodec/dpcm.c
View File

@ -298,17 +298,15 @@ static int dpcm_decode_frame(AVCodecContext *avctx,
return buf_size; return buf_size;
} }
#define DPCM_DECODER(id, name, long_name_) \ #define DPCM_DECODER(id_, name_, long_name_) \
AVCodec ff_ ## name ## _decoder = { \ AVCodec ff_ ## name_ ## _decoder = { \
#name, \ .name = #name_, \
AVMEDIA_TYPE_AUDIO, \ .type = AVMEDIA_TYPE_AUDIO, \
id, \ .id = id_, \
sizeof(DPCMContext), \ .priv_data_size = sizeof(DPCMContext), \
dpcm_decode_init, \ .init = dpcm_decode_init, \
NULL, \ .decode = dpcm_decode_frame, \
NULL, \ .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
dpcm_decode_frame, \
.long_name = NULL_IF_CONFIG_SMALL(long_name_), \
} }
DPCM_DECODER(CODEC_ID_INTERPLAY_DPCM, interplay_dpcm, "DPCM Interplay"); DPCM_DECODER(CODEC_ID_INTERPLAY_DPCM, interplay_dpcm, "DPCM Interplay");

17
libavcodec/jpeglsenc.c
View File

@ -383,13 +383,12 @@ static av_cold int encode_init_ls(AVCodecContext *ctx) {
} }
AVCodec ff_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", .name = "jpegls",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_JPEGLS, .id = CODEC_ID_JPEGLS,
sizeof(JpeglsContext), .priv_data_size = sizeof(JpeglsContext),
encode_init_ls, .init = encode_init_ls,
encode_picture_ls, .encode = encode_picture_ls,
NULL, .pix_fmts = (const enum PixelFormat[]){PIX_FMT_BGR24, PIX_FMT_RGB24, PIX_FMT_GRAY8, PIX_FMT_GRAY16, PIX_FMT_NONE},
.pix_fmts= (const enum PixelFormat[]){PIX_FMT_BGR24, PIX_FMT_RGB24, PIX_FMT_GRAY8, PIX_FMT_GRAY16, PIX_FMT_NONE}, .long_name = NULL_IF_CONFIG_SMALL("JPEG-LS"),
.long_name= NULL_IF_CONFIG_SMALL("JPEG-LS"),
}; };

23
libavcodec/libopenjpeg.c
View File

@ -185,15 +185,14 @@ static av_cold int libopenjpeg_decode_close(AVCodecContext *avctx)
AVCodec ff_libopenjpeg_decoder = { AVCodec ff_libopenjpeg_decoder = {
"libopenjpeg", .name = "libopenjpeg",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_JPEG2000, .id = CODEC_ID_JPEG2000,
sizeof(LibOpenJPEGContext), .priv_data_size = sizeof(LibOpenJPEGContext),
libopenjpeg_decode_init, .init = libopenjpeg_decode_init,
NULL, .close = libopenjpeg_decode_close,
libopenjpeg_decode_close, .decode = libopenjpeg_decode_frame,
libopenjpeg_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1, .max_lowres = 5,
.max_lowres = 5, .long_name = NULL_IF_CONFIG_SMALL("OpenJPEG based JPEG 2000 decoder"),
.long_name = NULL_IF_CONFIG_SMALL("OpenJPEG based JPEG 2000 decoder"), };
} ;

24
libavcodec/libvorbis.c
View File

@ -245,15 +245,15 @@ static av_cold int oggvorbis_encode_close(AVCodecContext *avccontext) {
AVCodec ff_libvorbis_encoder = { AVCodec ff_libvorbis_encoder = {
"libvorbis", .name = "libvorbis",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_VORBIS, .id = CODEC_ID_VORBIS,
sizeof(OggVorbisContext), .priv_data_size = sizeof(OggVorbisContext),
oggvorbis_encode_init, .init = oggvorbis_encode_init,
oggvorbis_encode_frame, .encode = oggvorbis_encode_frame,
oggvorbis_encode_close, .close = oggvorbis_encode_close,
.capabilities= CODEC_CAP_DELAY, .capabilities = CODEC_CAP_DELAY,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.long_name= NULL_IF_CONFIG_SMALL("libvorbis Vorbis"), .long_name = NULL_IF_CONFIG_SMALL("libvorbis Vorbis"),
.priv_class= &class, .priv_class = &class,
} ; };

16
libavcodec/ljpegenc.c
View File

@ -187,12 +187,12 @@ static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, in
AVCodec ff_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", .name = "ljpeg",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_LJPEG, .id = CODEC_ID_LJPEG,
sizeof(MpegEncContext), .priv_data_size = sizeof(MpegEncContext),
MPV_encode_init, .init = MPV_encode_init,
encode_picture_lossless, .encode = encode_picture_lossless,
MPV_encode_end, .close = MPV_encode_end,
.long_name = NULL_IF_CONFIG_SMALL("Lossless JPEG"), .long_name = NULL_IF_CONFIG_SMALL("Lossless JPEG"),
}; };

114
libavcodec/mpegaudiodec.c
View File

@ -2051,82 +2051,68 @@ static int decode_frame_mp3on4(AVCodecContext * avctx,
#if !CONFIG_FLOAT #if !CONFIG_FLOAT
#if CONFIG_MP1_DECODER #if CONFIG_MP1_DECODER
AVCodec ff_mp1_decoder = AVCodec ff_mp1_decoder = {
{ .name = "mp1",
"mp1", .type = AVMEDIA_TYPE_AUDIO,
AVMEDIA_TYPE_AUDIO, .id = CODEC_ID_MP1,
CODEC_ID_MP1, .priv_data_size = sizeof(MPADecodeContext),
sizeof(MPADecodeContext), .init = decode_init,
decode_init, .decode = decode_frame,
NULL, .capabilities = CODEC_CAP_PARSE_ONLY,
NULL, .flush = flush,
decode_frame, .long_name = NULL_IF_CONFIG_SMALL("MP1 (MPEG audio layer 1)"),
CODEC_CAP_PARSE_ONLY,
.flush= flush,
.long_name= NULL_IF_CONFIG_SMALL("MP1 (MPEG audio layer 1)"),
}; };
#endif #endif
#if CONFIG_MP2_DECODER #if CONFIG_MP2_DECODER
AVCodec ff_mp2_decoder = AVCodec ff_mp2_decoder = {
{ .name = "mp2",
"mp2", .type = AVMEDIA_TYPE_AUDIO,
AVMEDIA_TYPE_AUDIO, .id = CODEC_ID_MP2,
CODEC_ID_MP2, .priv_data_size = sizeof(MPADecodeContext),
sizeof(MPADecodeContext), .init = decode_init,
decode_init, .decode = decode_frame,
NULL, .capabilities = CODEC_CAP_PARSE_ONLY,
NULL, .flush = flush,
decode_frame, .long_name = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
CODEC_CAP_PARSE_ONLY,
.flush= flush,
.long_name= NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
}; };
#endif #endif
#if CONFIG_MP3_DECODER #if CONFIG_MP3_DECODER
AVCodec ff_mp3_decoder = AVCodec ff_mp3_decoder = {
{ .name = "mp3",
"mp3", .type = AVMEDIA_TYPE_AUDIO,
AVMEDIA_TYPE_AUDIO, .id = CODEC_ID_MP3,
CODEC_ID_MP3, .priv_data_size = sizeof(MPADecodeContext),
sizeof(MPADecodeContext), .init = decode_init,
decode_init, .decode = decode_frame,
NULL, .capabilities = CODEC_CAP_PARSE_ONLY,
NULL, .flush = flush,
decode_frame, .long_name = NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
CODEC_CAP_PARSE_ONLY,
.flush= flush,
.long_name= NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
}; };
#endif #endif
#if CONFIG_MP3ADU_DECODER #if CONFIG_MP3ADU_DECODER
AVCodec ff_mp3adu_decoder = AVCodec ff_mp3adu_decoder = {
{ .name = "mp3adu",
"mp3adu", .type = AVMEDIA_TYPE_AUDIO,
AVMEDIA_TYPE_AUDIO, .id = CODEC_ID_MP3ADU,
CODEC_ID_MP3ADU, .priv_data_size = sizeof(MPADecodeContext),
sizeof(MPADecodeContext), .init = decode_init,
decode_init, .decode = decode_frame_adu,
NULL, .capabilities = CODEC_CAP_PARSE_ONLY,
NULL, .flush = flush,
decode_frame_adu, .long_name = NULL_IF_CONFIG_SMALL("ADU (Application Data Unit) MP3 (MPEG audio layer 3)"),
CODEC_CAP_PARSE_ONLY,
.flush= flush,
.long_name= NULL_IF_CONFIG_SMALL("ADU (Application Data Unit) MP3 (MPEG audio layer 3)"),
}; };
#endif #endif
#if CONFIG_MP3ON4_DECODER #if CONFIG_MP3ON4_DECODER
AVCodec ff_mp3on4_decoder = AVCodec ff_mp3on4_decoder = {
{ .name = "mp3on4",
"mp3on4", .type = AVMEDIA_TYPE_AUDIO,
AVMEDIA_TYPE_AUDIO, .id = CODEC_ID_MP3ON4,
CODEC_ID_MP3ON4, .priv_data_size = sizeof(MP3On4DecodeContext),
sizeof(MP3On4DecodeContext), .init = decode_init_mp3on4,
decode_init_mp3on4, .close = decode_close_mp3on4,
NULL, .decode = decode_frame_mp3on4,
decode_close_mp3on4, .flush = flush,
decode_frame_mp3on4, .long_name = NULL_IF_CONFIG_SMALL("MP3onMP4"),
.flush= flush,
.long_name= NULL_IF_CONFIG_SMALL("MP3onMP4"),
}; };
#endif #endif
#endif #endif

114
libavcodec/mpegaudiodec_float.c
View File

@ -23,81 +23,67 @@
#include "mpegaudiodec.c" #include "mpegaudiodec.c"
#if CONFIG_MP1FLOAT_DECODER #if CONFIG_MP1FLOAT_DECODER
AVCodec ff_mp1float_decoder = AVCodec ff_mp1float_decoder = {
{ .name = "mp1float",
"mp1float", .type = AVMEDIA_TYPE_AUDIO,
AVMEDIA_TYPE_AUDIO, .id = CODEC_ID_MP1,
CODEC_ID_MP1, .priv_data_size = sizeof(MPADecodeContext),
sizeof(MPADecodeContext), .init = decode_init,
decode_init, .decode = decode_frame,
NULL, .capabilities = CODEC_CAP_PARSE_ONLY,
.close = NULL, .flush = flush,
decode_frame, .long_name = NULL_IF_CONFIG_SMALL("MP1 (MPEG audio layer 1)"),
CODEC_CAP_PARSE_ONLY,
.flush= flush,
.long_name= NULL_IF_CONFIG_SMALL("MP1 (MPEG audio layer 1)"),
}; };
#endif #endif
#if CONFIG_MP2FLOAT_DECODER #if CONFIG_MP2FLOAT_DECODER
AVCodec ff_mp2float_decoder = AVCodec ff_mp2float_decoder = {
{ .name = "mp2float",
"mp2float", .type = AVMEDIA_TYPE_AUDIO,
AVMEDIA_TYPE_AUDIO, .id = CODEC_ID_MP2,
CODEC_ID_MP2, .priv_data_size = sizeof(MPADecodeContext),
sizeof(MPADecodeContext), .init = decode_init,
decode_init, .decode = decode_frame,
NULL, .capabilities = CODEC_CAP_PARSE_ONLY,
.close = NULL, .flush = flush,
decode_frame, .long_name = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
CODEC_CAP_PARSE_ONLY,
.flush= flush,
.long_name= NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
}; };
#endif #endif
#if CONFIG_MP3FLOAT_DECODER #if CONFIG_MP3FLOAT_DECODER
AVCodec ff_mp3float_decoder = AVCodec ff_mp3float_decoder = {
{ .name = "mp3float",
"mp3float", .type = AVMEDIA_TYPE_AUDIO,
AVMEDIA_TYPE_AUDIO, .id = CODEC_ID_MP3,
CODEC_ID_MP3, .priv_data_size = sizeof(MPADecodeContext),
sizeof(MPADecodeContext), .init = decode_init,
decode_init, .decode = decode_frame,
NULL, .capabilities = CODEC_CAP_PARSE_ONLY,
.close = NULL, .flush = flush,
decode_frame, .long_name = NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
CODEC_CAP_PARSE_ONLY,
.flush= flush,
.long_name= NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
}; };
#endif #endif
#if CONFIG_MP3ADUFLOAT_DECODER #if CONFIG_MP3ADUFLOAT_DECODER
AVCodec ff_mp3adufloat_decoder = AVCodec ff_mp3adufloat_decoder = {
{ .name = "mp3adufloat",
"mp3adufloat", .type = AVMEDIA_TYPE_AUDIO,
AVMEDIA_TYPE_AUDIO, .id = CODEC_ID_MP3ADU,
CODEC_ID_MP3ADU, .priv_data_size = sizeof(MPADecodeContext),
sizeof(MPADecodeContext), .init = decode_init,
decode_init, .decode = decode_frame_adu,
NULL, .capabilities = CODEC_CAP_PARSE_ONLY,
.close = NULL, .flush = flush,
decode_frame_adu, .long_name = NULL_IF_CONFIG_SMALL("ADU (Application Data Unit) MP3 (MPEG audio layer 3)"),
CODEC_CAP_PARSE_ONLY,
.flush= flush,
.long_name= NULL_IF_CONFIG_SMALL("ADU (Application Data Unit) MP3 (MPEG audio layer 3)"),
}; };
#endif #endif
#if CONFIG_MP3ON4FLOAT_DECODER #if CONFIG_MP3ON4FLOAT_DECODER
AVCodec ff_mp3on4float_decoder = AVCodec ff_mp3on4float_decoder = {
{ .name = "mp3on4float",
"mp3on4float", .type = AVMEDIA_TYPE_AUDIO,
AVMEDIA_TYPE_AUDIO, .id = CODEC_ID_MP3ON4,
CODEC_ID_MP3ON4, .priv_data_size = sizeof(MP3On4DecodeContext),
sizeof(MP3On4DecodeContext), .init = decode_init_mp3on4,
decode_init_mp3on4, .close = decode_close_mp3on4,
NULL, .decode = decode_frame_mp3on4,
decode_close_mp3on4, .flush = flush,
decode_frame_mp3on4, .long_name = NULL_IF_CONFIG_SMALL("MP3onMP4"),
.flush= flush,
.long_name= NULL_IF_CONFIG_SMALL("MP3onMP4"),
}; };
#endif #endif

19
libavcodec/ra144dec.c
View File

@ -114,15 +114,12 @@ static int ra144_decode_frame(AVCodecContext * avctx, void *vdata,
return 20; return 20;
} }
AVCodec ff_ra_144_decoder = AVCodec ff_ra_144_decoder = {
{ .name = "real_144",
"real_144", .type = AVMEDIA_TYPE_AUDIO,
AVMEDIA_TYPE_AUDIO, .id = CODEC_ID_RA_144,
CODEC_ID_RA_144, .priv_data_size = sizeof(RA144Context),
sizeof(RA144Context), .init = ra144_decode_init,
ra144_decode_init, .decode = ra144_decode_frame,
NULL, .long_name = NULL_IF_CONFIG_SMALL("RealAudio 1.0 (14.4K)"),
NULL,
ra144_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("RealAudio 1.0 (14.4K)"),
}; };

19
libavcodec/ra144enc.c
View File

@ -508,14 +508,13 @@ static int ra144_encode_frame(AVCodecContext *avctx, uint8_t *frame,
} }
AVCodec ff_ra_144_encoder = AVCodec ff_ra_144_encoder = {
{ .name = "real_144",
"real_144", .type = AVMEDIA_TYPE_AUDIO,
AVMEDIA_TYPE_AUDIO, .id = CODEC_ID_RA_144,
CODEC_ID_RA_144, .priv_data_size = sizeof(RA144Context),
sizeof(RA144Context), .init = ra144_encode_init,
ra144_encode_init, .encode = ra144_encode_frame,
ra144_encode_frame, .close = ra144_encode_close,
ra144_encode_close, .long_name = NULL_IF_CONFIG_SMALL("RealAudio 1.0 (14.4K) encoder"),
.long_name = NULL_IF_CONFIG_SMALL("RealAudio 1.0 (14.4K) encoder"),
}; };

19
libavcodec/ra288.c
View File

@ -203,15 +203,12 @@ static int ra288_decode_frame(AVCodecContext * avctx, void *data,
return avctx->block_align; return avctx->block_align;
} }
AVCodec ff_ra_288_decoder = AVCodec ff_ra_288_decoder = {
{ .name = "real_288",
"real_288", .type = AVMEDIA_TYPE_AUDIO,
AVMEDIA_TYPE_AUDIO, .id = CODEC_ID_RA_288,
CODEC_ID_RA_288, .priv_data_size = sizeof(RA288Context),
sizeof(RA288Context), .init = ra288_decode_init,
ra288_decode_init, .decode = ra288_decode_frame,
NULL, .long_name = NULL_IF_CONFIG_SMALL("RealAudio 2.0 (28.8K)"),
NULL,
ra288_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("RealAudio 2.0 (28.8K)"),
}; };

21
libavcodec/roqvideoenc.c
View File

@ -1065,16 +1065,15 @@ static int roq_encode_end(AVCodecContext *avctx)
return 0; return 0;
} }
AVCodec ff_roq_encoder = AVCodec ff_roq_encoder = {
{ .name = "roqvideo",
"roqvideo", .type = AVMEDIA_TYPE_VIDEO,
AVMEDIA_TYPE_VIDEO, .id = CODEC_ID_ROQ,
CODEC_ID_ROQ, .priv_data_size = sizeof(RoqContext),
sizeof(RoqContext), .init = roq_encode_init,
roq_encode_init, .encode = roq_encode_frame,
roq_encode_frame, .close = roq_encode_end,
roq_encode_end,
.supported_framerates = (const AVRational[]){{30,1}, {0,0}}, .supported_framerates = (const AVRational[]){{30,1}, {0,0}},
.pix_fmts = (const enum PixelFormat[]){PIX_FMT_YUV444P, PIX_FMT_NONE}, .pix_fmts = (const enum PixelFormat[]){PIX_FMT_YUV444P, PIX_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("id RoQ video"), .long_name = NULL_IF_CONFIG_SMALL("id RoQ video"),
}; };

20
libavcodec/twinvq.c
View File

@ -1120,15 +1120,13 @@ static av_cold int twin_decode_close(AVCodecContext *avctx)
return 0; return 0;
} }
AVCodec ff_twinvq_decoder = AVCodec ff_twinvq_decoder = {
{ .name = "twinvq",
"twinvq", .type = AVMEDIA_TYPE_AUDIO,
AVMEDIA_TYPE_AUDIO, .id = CODEC_ID_TWINVQ,
CODEC_ID_TWINVQ, .priv_data_size = sizeof(TwinContext),
sizeof(TwinContext), .init = twin_decode_init,
twin_decode_init, .close = twin_decode_close,
NULL, .decode = twin_decode_frame,
twin_decode_close, .long_name = NULL_IF_CONFIG_SMALL("VQF TwinVQ"),
twin_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("VQF TwinVQ"),
}; };

44
libavcodec/wmadec.c
View File

@ -916,30 +916,26 @@ static av_cold void flush(AVCodecContext *avctx)
s->last_superframe_len= 0; s->last_superframe_len= 0;
} }
AVCodec ff_wmav1_decoder = AVCodec ff_wmav1_decoder = {
{ .name = "wmav1",
"wmav1", .type = AVMEDIA_TYPE_AUDIO,
AVMEDIA_TYPE_AUDIO, .id = CODEC_ID_WMAV1,
CODEC_ID_WMAV1, .priv_data_size = sizeof(WMACodecContext),
sizeof(WMACodecContext), .init = wma_decode_init,
wma_decode_init, .close = ff_wma_end,
NULL, .decode = wma_decode_superframe,
ff_wma_end, .flush = flush,
wma_decode_superframe, .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
.flush=flush,
.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
}; };
AVCodec ff_wmav2_decoder = AVCodec ff_wmav2_decoder = {
{ .name = "wmav2",
"wmav2", .type = AVMEDIA_TYPE_AUDIO,
AVMEDIA_TYPE_AUDIO, .id = CODEC_ID_WMAV2,
CODEC_ID_WMAV2, .priv_data_size = sizeof(WMACodecContext),
sizeof(WMACodecContext), .init = wma_decode_init,
wma_decode_init, .close = ff_wma_end,
NULL, .decode = wma_decode_superframe,
ff_wma_end, .flush = flush,
wma_decode_superframe, .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),
.flush=flush,
.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),
}; };

42
libavcodec/wmaenc.c
View File

@ -390,28 +390,26 @@ static int encode_superframe(AVCodecContext *avctx,
return put_bits_ptr(&s->pb) - s->pb.buf; return put_bits_ptr(&s->pb) - s->pb.buf;
} }
AVCodec ff_wmav1_encoder = AVCodec ff_wmav1_encoder = {
{ .name = "wmav1",
"wmav1", .type = AVMEDIA_TYPE_AUDIO,
AVMEDIA_TYPE_AUDIO, .id = CODEC_ID_WMAV1,
CODEC_ID_WMAV1, .priv_data_size = sizeof(WMACodecContext),
sizeof(WMACodecContext), .init = encode_init,
encode_init, .encode = encode_superframe,
encode_superframe, .close = ff_wma_end,
ff_wma_end, .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
}; };
AVCodec ff_wmav2_encoder = AVCodec ff_wmav2_encoder = {
{ .name = "wmav2",
"wmav2", .type = AVMEDIA_TYPE_AUDIO,
AVMEDIA_TYPE_AUDIO, .id = CODEC_ID_WMAV2,
CODEC_ID_WMAV2, .priv_data_size = sizeof(WMACodecContext),
sizeof(WMACodecContext), .init = encode_init,
encode_init, .encode = encode_superframe,
encode_superframe, .close = ff_wma_end,
ff_wma_end, .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),
.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),
}; };