/ - Diff - PeerStreamer - Redmine

         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,

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,

         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,

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,

         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",
 ,
         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,

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,

         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",
 ,
         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,

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,

+    }
     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,

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,

         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,

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,

         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,

PeerStreamer

Revision d36beb3f