Revision d36beb3f

View differences:

libavcodec/4xm.c
865 865
    return 0;
866 866
}
867 867

  
868
AVCodec fourxm_decoder = {
868
AVCodec ff_fourxm_decoder = {
869 869
    "4xm",
870 870
    AVMEDIA_TYPE_VIDEO,
871 871
    CODEC_ID_4XM,
libavcodec/8bps.c
219 219

  
220 220

  
221 221

  
222
AVCodec eightbps_decoder = {
222
AVCodec ff_eightbps_decoder = {
223 223
        "8bps",
224 224
        AVMEDIA_TYPE_VIDEO,
225 225
        CODEC_ID_8BPS,
libavcodec/8svx.c
92 92
    return 0;
93 93
}
94 94

  
95
AVCodec eightsvx_fib_decoder = {
95
AVCodec ff_eightsvx_fib_decoder = {
96 96
  .name           = "8svx_fib",
97 97
  .type           = AVMEDIA_TYPE_AUDIO,
98 98
  .id             = CODEC_ID_8SVX_FIB,
......
102 102
  .long_name      = NULL_IF_CONFIG_SMALL("8SVX fibonacci"),
103 103
};
104 104

  
105
AVCodec eightsvx_exp_decoder = {
105
AVCodec ff_eightsvx_exp_decoder = {
106 106
  .name           = "8svx_exp",
107 107
  .type           = AVMEDIA_TYPE_AUDIO,
108 108
  .id             = CODEC_ID_8SVX_EXP,
libavcodec/a64multienc.c
362 362
    return 0;
363 363
}
364 364

  
365
AVCodec a64multi_encoder = {
365
AVCodec ff_a64multi_encoder = {
366 366
    .name           = "a64multi",
367 367
    .type           = AVMEDIA_TYPE_VIDEO,
368 368
    .id             = CODEC_ID_A64_MULTI,
......
375 375
    .capabilities   = CODEC_CAP_DELAY,
376 376
};
377 377

  
378
AVCodec a64multi5_encoder = {
378
AVCodec ff_a64multi5_encoder = {
379 379
    .name           = "a64multi5",
380 380
    .type           = AVMEDIA_TYPE_VIDEO,
381 381
    .id             = CODEC_ID_A64_MULTI5,
libavcodec/aac_adtstoasc_bsf.c
107 107
    return 0;
108 108
}
109 109

  
110
AVBitStreamFilter aac_adtstoasc_bsf = {
110
AVBitStreamFilter ff_aac_adtstoasc_bsf = {
111 111
    "aac_adtstoasc",
112 112
    sizeof(AACBSFContext),
113 113
    aac_adtstoasc_filter,
libavcodec/aac_parser.c
60 60
}
61 61

  
62 62

  
63
AVCodecParser aac_parser = {
63
AVCodecParser ff_aac_parser = {
64 64
    { CODEC_ID_AAC },
65 65
    sizeof(AACAC3ParseContext),
66 66
    aac_parse_init,
libavcodec/aacdec.c
2351 2351
}
2352 2352

  
2353 2353

  
2354
AVCodec aac_decoder = {
2354
AVCodec ff_aac_decoder = {
2355 2355
    "aac",
2356 2356
    AVMEDIA_TYPE_AUDIO,
2357 2357
    CODEC_ID_AAC,
......
2372 2372
    in MPEG transport streams which only contain one program.
2373 2373
    To do a more complex LATM demuxing a separate LATM demuxer should be used.
2374 2374
*/
2375
AVCodec aac_latm_decoder = {
2375
AVCodec ff_aac_latm_decoder = {
2376 2376
    .name = "aac_latm",
2377 2377
    .type = CODEC_TYPE_AUDIO,
2378 2378
    .id   = CODEC_ID_AAC_LATM,
libavcodec/aacenc.c
641 641
    return 0;
642 642
}
643 643

  
644
AVCodec aac_encoder = {
644
AVCodec ff_aac_encoder = {
645 645
    "aac",
646 646
    AVMEDIA_TYPE_AUDIO,
647 647
    CODEC_ID_AAC,
libavcodec/aasc.c
109 109
    return 0;
110 110
}
111 111

  
112
AVCodec aasc_decoder = {
112
AVCodec ff_aasc_decoder = {
113 113
    "aasc",
114 114
    AVMEDIA_TYPE_VIDEO,
115 115
    CODEC_ID_AASC,
libavcodec/ac3_parser.c
169 169
}
170 170

  
171 171

  
172
AVCodecParser ac3_parser = {
172
AVCodecParser ff_ac3_parser = {
173 173
    { CODEC_ID_AC3, CODEC_ID_EAC3 },
174 174
    sizeof(AACAC3ParseContext),
175 175
    ac3_parse_init,
libavcodec/ac3dec.c
1437 1437
    return 0;
1438 1438
}
1439 1439

  
1440
AVCodec ac3_decoder = {
1440
AVCodec ff_ac3_decoder = {
1441 1441
    .name = "ac3",
1442 1442
    .type = AVMEDIA_TYPE_AUDIO,
1443 1443
    .id = CODEC_ID_AC3,
......
1449 1449
};
1450 1450

  
1451 1451
#if CONFIG_EAC3_DECODER
1452
AVCodec eac3_decoder = {
1452
AVCodec ff_eac3_decoder = {
1453 1453
    .name = "eac3",
1454 1454
    .type = AVMEDIA_TYPE_AUDIO,
1455 1455
    .id = CODEC_ID_EAC3,
libavcodec/ac3enc_fixed.c
425 425
#endif /* TEST */
426 426

  
427 427

  
428
AVCodec ac3_fixed_encoder = {
428
AVCodec ff_ac3_fixed_encoder = {
429 429
    "ac3_fixed",
430 430
    AVMEDIA_TYPE_AUDIO,
431 431
    CODEC_ID_AC3,
libavcodec/ac3enc_float.c
109 109
}
110 110

  
111 111

  
112
AVCodec ac3_encoder = {
112
AVCodec ff_ac3_encoder = {
113 113
    "ac3",
114 114
    AVMEDIA_TYPE_AUDIO,
115 115
    CODEC_ID_AC3,
libavcodec/adpcm.c
1708 1708

  
1709 1709
#if CONFIG_ENCODERS
1710 1710
#define ADPCM_ENCODER(id,name,long_name_)       \
1711
AVCodec name ## _encoder = {                    \
1711
AVCodec ff_ ## name ## _encoder = {             \
1712 1712
    #name,                                      \
1713 1713
    AVMEDIA_TYPE_AUDIO,                         \
1714 1714
    id,                                         \
......
1726 1726

  
1727 1727
#if CONFIG_DECODERS
1728 1728
#define ADPCM_DECODER(id,name,long_name_)       \
1729
AVCodec name ## _decoder = {                    \
1729
AVCodec ff_ ## name ## _decoder = {             \
1730 1730
    #name,                                      \
1731 1731
    AVMEDIA_TYPE_AUDIO,                         \
1732 1732
    id,                                         \
libavcodec/adxdec.c
166 166
    return buf-buf0;
167 167
}
168 168

  
169
AVCodec adpcm_adx_decoder = {
169
AVCodec ff_adpcm_adx_decoder = {
170 170
    "adpcm_adx",
171 171
    AVMEDIA_TYPE_AUDIO,
172 172
    CODEC_ID_ADPCM_ADX,
libavcodec/adxenc.c
183 183
    return dst-frame;
184 184
}
185 185

  
186
AVCodec adpcm_adx_encoder = {
186
AVCodec ff_adpcm_adx_encoder = {
187 187
    "adpcm_adx",
188 188
    AVMEDIA_TYPE_AUDIO,
189 189
    CODEC_ID_ADPCM_ADX,
libavcodec/alac.c
691 691
    return 0;
692 692
}
693 693

  
694
AVCodec alac_decoder = {
694
AVCodec ff_alac_decoder = {
695 695
    "alac",
696 696
    AVMEDIA_TYPE_AUDIO,
697 697
    CODEC_ID_ALAC,
libavcodec/alacenc.c
523 523
    return 0;
524 524
}
525 525

  
526
AVCodec alac_encoder = {
526
AVCodec ff_alac_encoder = {
527 527
    "alac",
528 528
    AVMEDIA_TYPE_AUDIO,
529 529
    CODEC_ID_ALAC,
libavcodec/allcodecs.c
27 27
#include "avcodec.h"
28 28

  
29 29
#define REGISTER_HWACCEL(X,x) { \
30
          extern AVHWAccel x##_hwaccel; \
31
          if(CONFIG_##X##_HWACCEL) av_register_hwaccel(&x##_hwaccel); }
30
          extern AVHWAccel ff_##x##_hwaccel; \
31
          if(CONFIG_##X##_HWACCEL) av_register_hwaccel(&ff_##x##_hwaccel); }
32 32

  
33 33
#define REGISTER_ENCODER(X,x) { \
34
          extern AVCodec x##_encoder; \
35
          if(CONFIG_##X##_ENCODER)  avcodec_register(&x##_encoder); }
34
          extern AVCodec ff_##x##_encoder; \
35
          if(CONFIG_##X##_ENCODER)  avcodec_register(&ff_##x##_encoder); }
36 36
#define REGISTER_DECODER(X,x) { \
37
          extern AVCodec x##_decoder; \
38
          if(CONFIG_##X##_DECODER)  avcodec_register(&x##_decoder); }
37
          extern AVCodec ff_##x##_decoder; \
38
          if(CONFIG_##X##_DECODER)  avcodec_register(&ff_##x##_decoder); }
39 39
#define REGISTER_ENCDEC(X,x)  REGISTER_ENCODER(X,x); REGISTER_DECODER(X,x)
40 40

  
41 41
#define REGISTER_PARSER(X,x) { \
42
          extern AVCodecParser x##_parser; \
43
          if(CONFIG_##X##_PARSER)  av_register_codec_parser(&x##_parser); }
42
          extern AVCodecParser ff_##x##_parser; \
43
          if(CONFIG_##X##_PARSER)  av_register_codec_parser(&ff_##x##_parser); }
44 44
#define REGISTER_BSF(X,x) { \
45
          extern AVBitStreamFilter x##_bsf; \
46
          if(CONFIG_##X##_BSF)     av_register_bitstream_filter(&x##_bsf); }
45
          extern AVBitStreamFilter ff_##x##_bsf; \
46
          if(CONFIG_##X##_BSF)     av_register_bitstream_filter(&ff_##x##_bsf); }
47 47

  
48 48
void avcodec_register_all(void)
49 49
{
libavcodec/alsdec.c
1737 1737
}
1738 1738

  
1739 1739

  
1740
AVCodec als_decoder = {
1740
AVCodec ff_als_decoder = {
1741 1741
    "als",
1742 1742
    AVMEDIA_TYPE_AUDIO,
1743 1743
    CODEC_ID_MP4ALS,
libavcodec/amrnbdec.c
1036 1036
}
1037 1037

  
1038 1038

  
1039
AVCodec amrnb_decoder = {
1039
AVCodec ff_amrnb_decoder = {
1040 1040
    .name           = "amrnb",
1041 1041
    .type           = AVMEDIA_TYPE_AUDIO,
1042 1042
    .id             = CODEC_ID_AMR_NB,
libavcodec/amrwbdec.c
1225 1225
    return expected_fr_size;
1226 1226
}
1227 1227

  
1228
AVCodec amrwb_decoder = {
1228
AVCodec ff_amrwb_decoder = {
1229 1229
    .name           = "amrwb",
1230 1230
    .type           = CODEC_TYPE_AUDIO,
1231 1231
    .id             = CODEC_ID_AMR_WB,
libavcodec/anm.c
183 183
    return 0;
184 184
}
185 185

  
186
AVCodec anm_decoder = {
186
AVCodec ff_anm_decoder = {
187 187
    "anm",
188 188
    AVMEDIA_TYPE_VIDEO,
189 189
    CODEC_ID_ANM,
libavcodec/ansi.c
422 422
    return 0;
423 423
}
424 424

  
425
AVCodec ansi_decoder = {
425
AVCodec ff_ansi_decoder = {
426 426
    .name           = "ansi",
427 427
    .type           = AVMEDIA_TYPE_VIDEO,
428 428
    .id             = CODEC_ID_ANSI,
libavcodec/apedec.c
883 883
    s->samples= 0;
884 884
}
885 885

  
886
AVCodec ape_decoder = {
886
AVCodec ff_ape_decoder = {
887 887
    "ape",
888 888
    AVMEDIA_TYPE_AUDIO,
889 889
    CODEC_ID_APE,
libavcodec/assdec.c
52 52
    return avpkt->size;
53 53
}
54 54

  
55
AVCodec ass_decoder = {
55
AVCodec ff_ass_decoder = {
56 56
    .name         = "ass",
57 57
    .long_name    = NULL_IF_CONFIG_SMALL("Advanced SubStation Alpha subtitle"),
58 58
    .type         = AVMEDIA_TYPE_SUBTITLE,
libavcodec/assenc.c
57 57
    return total_len;
58 58
}
59 59

  
60
AVCodec ass_encoder = {
60
AVCodec ff_ass_encoder = {
61 61
    .name         = "ass",
62 62
    .long_name    = NULL_IF_CONFIG_SMALL("Advanced SubStation Alpha subtitle"),
63 63
    .type         = AVMEDIA_TYPE_SUBTITLE,
libavcodec/asv1.c
613 613
    return 0;
614 614
}
615 615

  
616
AVCodec asv1_decoder = {
616
AVCodec ff_asv1_decoder = {
617 617
    "asv1",
618 618
    AVMEDIA_TYPE_VIDEO,
619 619
    CODEC_ID_ASV1,
......
626 626
    .long_name= NULL_IF_CONFIG_SMALL("ASUS V1"),
627 627
};
628 628

  
629
AVCodec asv2_decoder = {
629
AVCodec ff_asv2_decoder = {
630 630
    "asv2",
631 631
    AVMEDIA_TYPE_VIDEO,
632 632
    CODEC_ID_ASV2,
......
640 640
};
641 641

  
642 642
#if CONFIG_ASV1_ENCODER
643
AVCodec asv1_encoder = {
643
AVCodec ff_asv1_encoder = {
644 644
    "asv1",
645 645
    AVMEDIA_TYPE_VIDEO,
646 646
    CODEC_ID_ASV1,
......
654 654
#endif
655 655

  
656 656
#if CONFIG_ASV2_ENCODER
657
AVCodec asv2_encoder = {
657
AVCodec ff_asv2_encoder = {
658 658
    "asv2",
659 659
    AVMEDIA_TYPE_VIDEO,
660 660
    CODEC_ID_ASV2,
libavcodec/atrac1.c
365 365
}
366 366

  
367 367

  
368
AVCodec atrac1_decoder = {
368
AVCodec ff_atrac1_decoder = {
369 369
    .name = "atrac1",
370 370
    .type = AVMEDIA_TYPE_AUDIO,
371 371
    .id = CODEC_ID_ATRAC1,
libavcodec/atrac3.c
1019 1019
}
1020 1020

  
1021 1021

  
1022
AVCodec atrac3_decoder =
1022
AVCodec ff_atrac3_decoder =
1023 1023
{
1024 1024
    .name = "atrac3",
1025 1025
    .type = AVMEDIA_TYPE_AUDIO,
libavcodec/aura.c
122 122
    return 0;
123 123
}
124 124

  
125
AVCodec aura2_decoder = {
125
AVCodec ff_aura2_decoder = {
126 126
    "aura2",
127 127
    AVMEDIA_TYPE_VIDEO,
128 128
    CODEC_ID_AURA2,
libavcodec/avs.c
150 150
    return 0;
151 151
}
152 152

  
153
AVCodec avs_decoder = {
153
AVCodec ff_avs_decoder = {
154 154
    "avs",
155 155
    AVMEDIA_TYPE_VIDEO,
156 156
    CODEC_ID_AVS,
libavcodec/bethsoftvideo.c
130 130
    return 0;
131 131
}
132 132

  
133
AVCodec bethsoftvid_decoder = {
133
AVCodec ff_bethsoftvid_decoder = {
134 134
    .name = "bethsoftvid",
135 135
    .type = AVMEDIA_TYPE_VIDEO,
136 136
    .id = CODEC_ID_BETHSOFTVID,
libavcodec/bfi.c
180 180
    return 0;
181 181
}
182 182

  
183
AVCodec bfi_decoder = {
183
AVCodec ff_bfi_decoder = {
184 184
    .name = "bfi",
185 185
    .type = AVMEDIA_TYPE_VIDEO,
186 186
    .id = CODEC_ID_BFI,
libavcodec/bink.c
1000 1000
    return 0;
1001 1001
}
1002 1002

  
1003
AVCodec bink_decoder = {
1003
AVCodec ff_bink_decoder = {
1004 1004
    "binkvideo",
1005 1005
    AVMEDIA_TYPE_VIDEO,
1006 1006
    CODEC_ID_BINKVIDEO,
libavcodec/binkaudio.c
286 286
    return buf_size;
287 287
}
288 288

  
289
AVCodec binkaudio_rdft_decoder = {
289
AVCodec ff_binkaudio_rdft_decoder = {
290 290
    "binkaudio_rdft",
291 291
    AVMEDIA_TYPE_AUDIO,
292 292
    CODEC_ID_BINKAUDIO_RDFT,
......
298 298
    .long_name = NULL_IF_CONFIG_SMALL("Bink Audio (RDFT)")
299 299
};
300 300

  
301
AVCodec binkaudio_dct_decoder = {
301
AVCodec ff_binkaudio_dct_decoder = {
302 302
    "binkaudio_dct",
303 303
    AVMEDIA_TYPE_AUDIO,
304 304
    CODEC_ID_BINKAUDIO_DCT,
libavcodec/bmp.c
335 335
    return 0;
336 336
}
337 337

  
338
AVCodec bmp_decoder = {
338
AVCodec ff_bmp_decoder = {
339 339
    "bmp",
340 340
    AVMEDIA_TYPE_VIDEO,
341 341
    CODEC_ID_BMP,
libavcodec/bmpenc.c
149 149
    return n_bytes;
150 150
}
151 151

  
152
AVCodec bmp_encoder = {
152
AVCodec ff_bmp_encoder = {
153 153
    "bmp",
154 154
    AVMEDIA_TYPE_VIDEO,
155 155
    CODEC_ID_BMP,
libavcodec/c93.c
242 242
    return buf_size;
243 243
}
244 244

  
245
AVCodec c93_decoder = {
245
AVCodec ff_c93_decoder = {
246 246
    "c93",
247 247
    AVMEDIA_TYPE_VIDEO,
248 248
    CODEC_ID_C93,
libavcodec/cavs_parser.c
97 97
    return next;
98 98
}
99 99

  
100
AVCodecParser cavsvideo_parser = {
100
AVCodecParser ff_cavsvideo_parser = {
101 101
    { CODEC_ID_CAVS },
102 102
    sizeof(ParseContext1),
103 103
    NULL,
libavcodec/cavsdec.c
709 709
    }
710 710
}
711 711

  
712
AVCodec cavs_decoder = {
712
AVCodec ff_cavs_decoder = {
713 713
    "cavs",
714 714
    AVMEDIA_TYPE_VIDEO,
715 715
    CODEC_ID_CAVS,
libavcodec/cdgraphics.c
367 367
    return 0;
368 368
}
369 369

  
370
AVCodec cdgraphics_decoder = {
370
AVCodec ff_cdgraphics_decoder = {
371 371
    "cdgraphics",
372 372
    AVMEDIA_TYPE_VIDEO,
373 373
    CODEC_ID_CDGRAPHICS,
libavcodec/chomp_bsf.c
40 40
/**
41 41
 * This filter removes a string of NULL bytes from the end of a packet.
42 42
 */
43
AVBitStreamFilter chomp_bsf = {
43
AVBitStreamFilter ff_chomp_bsf = {
44 44
    "chomp",
45 45
    0,
46 46
    chomp_filter,
libavcodec/cinepak.c
455 455
    return 0;
456 456
}
457 457

  
458
AVCodec cinepak_decoder = {
458
AVCodec ff_cinepak_decoder = {
459 459
    "cinepak",
460 460
    AVMEDIA_TYPE_VIDEO,
461 461
    CODEC_ID_CINEPAK,
libavcodec/cljr.c
140 140
}
141 141
#endif
142 142

  
143
AVCodec cljr_decoder = {
143
AVCodec ff_cljr_decoder = {
144 144
    "cljr",
145 145
    AVMEDIA_TYPE_VIDEO,
146 146
    CODEC_ID_CLJR,
......
154 154
};
155 155

  
156 156
#if CONFIG_CLJR_ENCODER
157
AVCodec cljr_encoder = {
157
AVCodec ff_cljr_encoder = {
158 158
    "cljr",
159 159
    AVMEDIA_TYPE_VIDEO,
160 160
    CODEC_ID_CLJR,
libavcodec/cook.c
1283 1283
}
1284 1284

  
1285 1285

  
1286
AVCodec cook_decoder =
1286
AVCodec ff_cook_decoder =
1287 1287
{
1288 1288
    .name = "cook",
1289 1289
    .type = AVMEDIA_TYPE_AUDIO,
libavcodec/cscd.c
254 254
    return 0;
255 255
}
256 256

  
257
AVCodec cscd_decoder = {
257
AVCodec ff_cscd_decoder = {
258 258
    "camstudio",
259 259
    AVMEDIA_TYPE_VIDEO,
260 260
    CODEC_ID_CSCD,
libavcodec/cyuv.c
178 178
}
179 179

  
180 180
#if CONFIG_AURA_DECODER
181
AVCodec aura_decoder = {
181
AVCodec ff_aura_decoder = {
182 182
    "aura",
183 183
    AVMEDIA_TYPE_VIDEO,
184 184
    CODEC_ID_AURA,
......
194 194
#endif
195 195

  
196 196
#if CONFIG_CYUV_DECODER
197
AVCodec cyuv_decoder = {
197
AVCodec ff_cyuv_decoder = {
198 198
    "cyuv",
199 199
    AVMEDIA_TYPE_VIDEO,
200 200
    CODEC_ID_CYUV,
libavcodec/dca.c
1875 1875
    { FF_PROFILE_UNKNOWN },
1876 1876
};
1877 1877

  
1878
AVCodec dca_decoder = {
1878
AVCodec ff_dca_decoder = {
1879 1879
    .name = "dca",
1880 1880
    .type = AVMEDIA_TYPE_AUDIO,
1881 1881
    .id = CODEC_ID_DTS,
libavcodec/dca_parser.c
125 125
    return next;
126 126
}
127 127

  
128
AVCodecParser dca_parser = {
128
AVCodecParser ff_dca_parser = {
129 129
    {CODEC_ID_DTS},
130 130
    sizeof(DCAParseContext),
131 131
    dca_parse_init,
libavcodec/dirac_parser.c
247 247
        av_free(pc->buffer);
248 248
}
249 249

  
250
AVCodecParser dirac_parser = {
250
AVCodecParser ff_dirac_parser = {
251 251
    { CODEC_ID_DIRAC },
252 252
    sizeof(DiracParseContext),
253 253
    NULL,
libavcodec/dnxhd_parser.c
86 86
    return next;
87 87
}
88 88

  
89
AVCodecParser dnxhd_parser = {
89
AVCodecParser ff_dnxhd_parser = {
90 90
    { CODEC_ID_DNXHD },
91 91
    sizeof(ParseContext),
92 92
    NULL,
libavcodec/dnxhddec.c
346 346
    return 0;
347 347
}
348 348

  
349
AVCodec dnxhd_decoder = {
349
AVCodec ff_dnxhd_decoder = {
350 350
    "dnxhd",
351 351
    AVMEDIA_TYPE_VIDEO,
352 352
    CODEC_ID_DNXHD,
libavcodec/dnxhdenc.c
848 848
    return 0;
849 849
}
850 850

  
851
AVCodec dnxhd_encoder = {
851
AVCodec ff_dnxhd_encoder = {
852 852
    "dnxhd",
853 853
    AVMEDIA_TYPE_VIDEO,
854 854
    CODEC_ID_DNXHD,
libavcodec/dpcm.c
299 299
}
300 300

  
301 301
#define DPCM_DECODER(id, name, long_name_)      \
302
AVCodec name ## _decoder = {                    \
302
AVCodec ff_ ## name ## _decoder = {             \
303 303
    #name,                                      \
304 304
    AVMEDIA_TYPE_AUDIO,                         \
305 305
    id,                                         \
libavcodec/dpx.c
220 220
    return 0;
221 221
}
222 222

  
223
AVCodec dpx_decoder = {
223
AVCodec ff_dpx_decoder = {
224 224
    "dpx",
225 225
    AVMEDIA_TYPE_VIDEO,
226 226
    CODEC_ID_DPX,
libavcodec/dsicinav.c
343 343
}
344 344

  
345 345

  
346
AVCodec dsicinvideo_decoder = {
346
AVCodec ff_dsicinvideo_decoder = {
347 347
    "dsicinvideo",
348 348
    AVMEDIA_TYPE_VIDEO,
349 349
    CODEC_ID_DSICINVIDEO,
......
356 356
    .long_name = NULL_IF_CONFIG_SMALL("Delphine Software International CIN video"),
357 357
};
358 358

  
359
AVCodec dsicinaudio_decoder = {
359
AVCodec ff_dsicinaudio_decoder = {
360 360
    "dsicinaudio",
361 361
    AVMEDIA_TYPE_AUDIO,
362 362
    CODEC_ID_DSICINAUDIO,
libavcodec/dump_extradata_bsf.c
43 43
    return 0;
44 44
}
45 45

  
46
AVBitStreamFilter dump_extradata_bsf={
46
AVBitStreamFilter ff_dump_extradata_bsf={
47 47
    "dump_extra",
48 48
    0,
49 49
    dump_extradata,
libavcodec/dv.c
1290 1290

  
1291 1291

  
1292 1292
#if CONFIG_DVVIDEO_ENCODER
1293
AVCodec dvvideo_encoder = {
1293
AVCodec ff_dvvideo_encoder = {
1294 1294
    "dvvideo",
1295 1295
    AVMEDIA_TYPE_VIDEO,
1296 1296
    CODEC_ID_DVVIDEO,
......
1303 1303
#endif // CONFIG_DVVIDEO_ENCODER
1304 1304

  
1305 1305
#if CONFIG_DVVIDEO_DECODER
1306
AVCodec dvvideo_decoder = {
1306
AVCodec ff_dvvideo_decoder = {
1307 1307
    "dvvideo",
1308 1308
    AVMEDIA_TYPE_VIDEO,
1309 1309
    CODEC_ID_DVVIDEO,
libavcodec/dvbsub.c
402 402
    return ret;
403 403
}
404 404

  
405
AVCodec dvbsub_encoder = {
405
AVCodec ff_dvbsub_encoder = {
406 406
    "dvbsub",
407 407
    AVMEDIA_TYPE_SUBTITLE,
408 408
    CODEC_ID_DVB_SUBTITLE,
libavcodec/dvbsub_parser.c
179 179
    av_freep(&pc->packet_buf);
180 180
}
181 181

  
182
AVCodecParser dvbsub_parser = {
182
AVCodecParser ff_dvbsub_parser = {
183 183
    { CODEC_ID_DVB_SUBTITLE },
184 184
    sizeof(DVBSubParseContext),
185 185
    dvbsub_parse_init,
libavcodec/dvbsubdec.c
1479 1479
}
1480 1480

  
1481 1481

  
1482
AVCodec dvbsub_decoder = {
1482
AVCodec ff_dvbsub_decoder = {
1483 1483
    "dvbsub",
1484 1484
    AVMEDIA_TYPE_SUBTITLE,
1485 1485
    CODEC_ID_DVB_SUBTITLE,
libavcodec/dvdsub_parser.c
76 76
    av_freep(&pc->packet);
77 77
}
78 78

  
79
AVCodecParser dvdsub_parser = {
79
AVCodecParser ff_dvdsub_parser = {
80 80
    { CODEC_ID_DVD_SUBTITLE },
81 81
    sizeof(DVDSubParseContext),
82 82
    dvdsub_parse_init,
libavcodec/dvdsubdec.c
486 486
    return buf_size;
487 487
}
488 488

  
489
AVCodec dvdsub_decoder = {
489
AVCodec ff_dvdsub_decoder = {
490 490
    "dvdsub",
491 491
    AVMEDIA_TYPE_SUBTITLE,
492 492
    CODEC_ID_DVD_SUBTITLE,
libavcodec/dvdsubenc.c
215 215
    return ret;
216 216
}
217 217

  
218
AVCodec dvdsub_encoder = {
218
AVCodec ff_dvdsub_encoder = {
219 219
    "dvdsub",
220 220
    AVMEDIA_TYPE_SUBTITLE,
221 221
    CODEC_ID_DVD_SUBTITLE,
libavcodec/dxa.c
317 317
    return 0;
318 318
}
319 319

  
320
AVCodec dxa_decoder = {
320
AVCodec ff_dxa_decoder = {
321 321
    "dxa",
322 322
    AVMEDIA_TYPE_VIDEO,
323 323
    CODEC_ID_DXA,
libavcodec/eacmv.c
205 205
    return 0;
206 206
}
207 207

  
208
AVCodec eacmv_decoder = {
208
AVCodec ff_eacmv_decoder = {
209 209
    "eacmv",
210 210
    AVMEDIA_TYPE_VIDEO,
211 211
    CODEC_ID_CMV,
libavcodec/eamad.c
306 306
    return 0;
307 307
}
308 308

  
309
AVCodec eamad_decoder = {
309
AVCodec ff_eamad_decoder = {
310 310
    "eamad",
311 311
    AVMEDIA_TYPE_VIDEO,
312 312
    CODEC_ID_MAD,
libavcodec/eatgq.c
243 243
    return 0;
244 244
}
245 245

  
246
AVCodec eatgq_decoder = {
246
AVCodec ff_eatgq_decoder = {
247 247
    "eatgq",
248 248
    AVMEDIA_TYPE_VIDEO,
249 249
    CODEC_ID_TGQ,
libavcodec/eatgv.c
334 334
    return 0;
335 335
}
336 336

  
337
AVCodec eatgv_decoder = {
337
AVCodec ff_eatgv_decoder = {
338 338
    "eatgv",
339 339
    AVMEDIA_TYPE_VIDEO,
340 340
    CODEC_ID_TGV,
libavcodec/eatqi.c
154 154
    return 0;
155 155
}
156 156

  
157
AVCodec eatqi_decoder = {
157
AVCodec ff_eatqi_decoder = {
158 158
    "eatqi",
159 159
    AVMEDIA_TYPE_VIDEO,
160 160
    CODEC_ID_TQI,
libavcodec/escape124.c
363 363
}
364 364

  
365 365

  
366
AVCodec escape124_decoder = {
366
AVCodec ff_escape124_decoder = {
367 367
    "escape124",
368 368
    AVMEDIA_TYPE_VIDEO,
369 369
    CODEC_ID_ESCAPE124,
libavcodec/ffv1.c
1786 1786
    return buf_size;
1787 1787
}
1788 1788

  
1789
AVCodec ffv1_decoder = {
1789
AVCodec ff_ffv1_decoder = {
1790 1790
    "ffv1",
1791 1791
    AVMEDIA_TYPE_VIDEO,
1792 1792
    CODEC_ID_FFV1,
......
1801 1801
};
1802 1802

  
1803 1803
#if CONFIG_FFV1_ENCODER
1804
AVCodec ffv1_encoder = {
1804
AVCodec ff_ffv1_encoder = {
1805 1805
    "ffv1",
1806 1806
    AVMEDIA_TYPE_VIDEO,
1807 1807
    CODEC_ID_FFV1,
libavcodec/flac_parser.c
673 673
    av_free(fpc->wrap_buf);
674 674
}
675 675

  
676
AVCodecParser flac_parser = {
676
AVCodecParser ff_flac_parser = {
677 677
    { CODEC_ID_FLAC },
678 678
    sizeof(FLACParseContext),
679 679
    flac_parse_init,
libavcodec/flacdec.c
653 653
    return 0;
654 654
}
655 655

  
656
AVCodec flac_decoder = {
656
AVCodec ff_flac_decoder = {
657 657
    "flac",
658 658
    AVMEDIA_TYPE_AUDIO,
659 659
    CODEC_ID_FLAC,
libavcodec/flacenc.c
1326 1326
}
1327 1327

  
1328 1328

  
1329
AVCodec flac_encoder = {
1329
AVCodec ff_flac_encoder = {
1330 1330
    "flac",
1331 1331
    AVMEDIA_TYPE_AUDIO,
1332 1332
    CODEC_ID_FLAC,
libavcodec/flashsv.c
250 250
}
251 251

  
252 252

  
253
AVCodec flashsv_decoder = {
253
AVCodec ff_flashsv_decoder = {
254 254
    "flashsv",
255 255
    AVMEDIA_TYPE_VIDEO,
256 256
    CODEC_ID_FLASHSV,
libavcodec/flashsvenc.c
280 280
    return 0;
281 281
}
282 282

  
283
AVCodec flashsv_encoder = {
283
AVCodec ff_flashsv_encoder = {
284 284
    "flashsv",
285 285
    AVMEDIA_TYPE_VIDEO,
286 286
    CODEC_ID_FLASHSV,
libavcodec/flicvideo.c
742 742
    return 0;
743 743
}
744 744

  
745
AVCodec flic_decoder = {
745
AVCodec ff_flic_decoder = {
746 746
    "flic",
747 747
    AVMEDIA_TYPE_VIDEO,
748 748
    CODEC_ID_FLIC,
libavcodec/flvdec.c
118 118
    return 0;
119 119
}
120 120

  
121
AVCodec flv_decoder = {
121
AVCodec ff_flv_decoder = {
122 122
    "flv",
123 123
    AVMEDIA_TYPE_VIDEO,
124 124
    CODEC_ID_FLV1,
libavcodec/flvenc.c
84 84
    }
85 85
}
86 86

  
87
AVCodec flv_encoder = {
87
AVCodec ff_flv_encoder = {
88 88
    "flv",
89 89
    AVMEDIA_TYPE_VIDEO,
90 90
    CODEC_ID_FLV1,
libavcodec/fraps.c
355 355
}
356 356

  
357 357

  
358
AVCodec fraps_decoder = {
358
AVCodec ff_fraps_decoder = {
359 359
    "fraps",
360 360
    AVMEDIA_TYPE_VIDEO,
361 361
    CODEC_ID_FRAPS,
libavcodec/frwu.c
109 109
    return 0;
110 110
}
111 111

  
112
AVCodec frwu_decoder = {
112
AVCodec ff_frwu_decoder = {
113 113
    "FRWU",
114 114
    AVMEDIA_TYPE_VIDEO,
115 115
    CODEC_ID_FRWU,
libavcodec/g722.c
328 328
    return avpkt->size;
329 329
}
330 330

  
331
AVCodec adpcm_g722_decoder = {
331
AVCodec ff_adpcm_g722_decoder = {
332 332
    .name           = "g722",
333 333
    .type           = AVMEDIA_TYPE_AUDIO,
334 334
    .id             = CODEC_ID_ADPCM_G722,
......
568 568
    return i;
569 569
}
570 570

  
571
AVCodec adpcm_g722_encoder = {
571
AVCodec ff_adpcm_g722_encoder = {
572 572
    .name           = "g722",
573 573
    .type           = AVMEDIA_TYPE_AUDIO,
574 574
    .id             = CODEC_ID_ADPCM_G722,
libavcodec/g726.c
391 391
}
392 392

  
393 393
#if CONFIG_ADPCM_G726_ENCODER
394
AVCodec adpcm_g726_encoder = {
394
AVCodec ff_adpcm_g726_encoder = {
395 395
    "g726",
396 396
    AVMEDIA_TYPE_AUDIO,
397 397
    CODEC_ID_ADPCM_G726,
......
406 406
};
407 407
#endif
408 408

  
409
AVCodec adpcm_g726_decoder = {
409
AVCodec ff_adpcm_g726_decoder = {
410 410
    "g726",
411 411
    AVMEDIA_TYPE_AUDIO,
412 412
    CODEC_ID_ADPCM_G726,
libavcodec/g729dec.c
312 312
    return buf_size;
313 313
}
314 314

  
315
AVCodec g729_decoder =
315
AVCodec ff_g729_decoder =
316 316
{
317 317
    "g729",
318 318
    AVMEDIA_TYPE_AUDIO,
libavcodec/gif.c
166 166
    return 0;
167 167
}
168 168

  
169
AVCodec gif_encoder = {
169
AVCodec ff_gif_encoder = {
170 170
    "gif",
171 171
    AVMEDIA_TYPE_VIDEO,
172 172
    CODEC_ID_GIF,
libavcodec/gifdec.c
325 325
    return 0;
326 326
}
327 327

  
328
AVCodec gif_decoder = {
328
AVCodec ff_gif_decoder = {
329 329
    "gif",
330 330
    AVMEDIA_TYPE_VIDEO,
331 331
    CODEC_ID_GIF,
libavcodec/gsmdec.c
84 84
    return avctx->block_align;
85 85
}
86 86

  
87
AVCodec gsm_decoder = {
87
AVCodec ff_gsm_decoder = {
88 88
    "gsm",
89 89
    AVMEDIA_TYPE_AUDIO,
90 90
    CODEC_ID_GSM,
......
96 96
    .long_name = NULL_IF_CONFIG_SMALL("GSM"),
97 97
};
98 98

  
99
AVCodec gsm_ms_decoder = {
99
AVCodec ff_gsm_ms_decoder = {
100 100
    "gsm_ms",
101 101
    AVMEDIA_TYPE_AUDIO,
102 102
    CODEC_ID_GSM_MS,
libavcodec/h261_parser.c
81 81
    return next;
82 82
}
83 83

  
84
AVCodecParser h261_parser = {
84
AVCodecParser ff_h261_parser = {
85 85
    { CODEC_ID_H261 },
86 86
    sizeof(ParseContext),
87 87
    NULL,
libavcodec/h261dec.c
641 641
    return 0;
642 642
}
643 643

  
644
AVCodec h261_decoder = {
644
AVCodec ff_h261_decoder = {
645 645
    "h261",
646 646
    AVMEDIA_TYPE_VIDEO,
647 647
    CODEC_ID_H261,
libavcodec/h261enc.c
321 321
    }
322 322
}
323 323

  
324
AVCodec h261_encoder = {
324
AVCodec ff_h261_encoder = {
325 325
    "h261",
326 326
    AVMEDIA_TYPE_VIDEO,
327 327
    CODEC_ID_H261,
libavcodec/h263_parser.c
83 83
    return next;
84 84
}
85 85

  
86
AVCodecParser h263_parser = {
86
AVCodecParser ff_h263_parser = {
87 87
    { CODEC_ID_H263 },
88 88
    sizeof(ParseContext),
89 89
    NULL,
libavcodec/h263dec.c
735 735
    return get_consumed_bytes(s, buf_size);
736 736
}
737 737

  
738
AVCodec h263_decoder = {
738
AVCodec ff_h263_decoder = {
739 739
    "h263",
740 740
    AVMEDIA_TYPE_VIDEO,
741 741
    CODEC_ID_H263,
libavcodec/h264.c
3360 3360
}
3361 3361

  
3362 3362

  
3363
AVCodec h264_decoder = {
3363
AVCodec ff_h264_decoder = {
3364 3364
    "h264",
3365 3365
    AVMEDIA_TYPE_VIDEO,
3366 3366
    CODEC_ID_H264,
......
3375 3375
};
3376 3376

  
3377 3377
#if CONFIG_H264_VDPAU_DECODER
3378
AVCodec h264_vdpau_decoder = {
3378
AVCodec ff_h264_vdpau_decoder = {
3379 3379
    "h264_vdpau",
3380 3380
    AVMEDIA_TYPE_VIDEO,
3381 3381
    CODEC_ID_H264,
libavcodec/h264_mp4toannexb_bsf.c
169 169
    return AVERROR(EINVAL);
170 170
}
171 171

  
172
AVBitStreamFilter h264_mp4toannexb_bsf = {
172
AVBitStreamFilter ff_h264_mp4toannexb_bsf = {
173 173
    "h264_mp4toannexb",
174 174
    sizeof(H264BSFContext),
175 175
    h264_mp4toannexb_filter,
libavcodec/h264_parser.c
332 332
    return 0;
333 333
}
334 334

  
335
AVCodecParser h264_parser = {
335
AVCodecParser ff_h264_parser = {
336 336
    { CODEC_ID_H264 },
337 337
    sizeof(H264Context),
338 338
    init,
libavcodec/huffyuv.c
1416 1416
#endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
1417 1417

  
1418 1418
#if CONFIG_HUFFYUV_DECODER
1419
AVCodec huffyuv_decoder = {
1419
AVCodec ff_huffyuv_decoder = {
1420 1420
    "huffyuv",
1421 1421
    AVMEDIA_TYPE_VIDEO,
1422 1422
    CODEC_ID_HUFFYUV,
......
1432 1432
#endif
1433 1433

  
1434 1434
#if CONFIG_FFVHUFF_DECODER
1435
AVCodec ffvhuff_decoder = {
1435
AVCodec ff_ffvhuff_decoder = {
1436 1436
    "ffvhuff",
1437 1437
    AVMEDIA_TYPE_VIDEO,
1438 1438
    CODEC_ID_FFVHUFF,
......
1448 1448
#endif
1449 1449

  
1450 1450
#if CONFIG_HUFFYUV_ENCODER
1451
AVCodec huffyuv_encoder = {
1451
AVCodec ff_huffyuv_encoder = {
1452 1452
    "huffyuv",
1453 1453
    AVMEDIA_TYPE_VIDEO,
1454 1454
    CODEC_ID_HUFFYUV,
......
1462 1462
#endif
1463 1463

  
1464 1464
#if CONFIG_FFVHUFF_ENCODER
1465
AVCodec ffvhuff_encoder = {
1465
AVCodec ff_ffvhuff_encoder = {
1466 1466
    "ffvhuff",
1467 1467
    AVMEDIA_TYPE_VIDEO,
1468 1468
    CODEC_ID_FFVHUFF,
... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff