diff mbox

[FFmpeg-devel] lavc: add new API for iterating codecs and codec parsers

Message ID 20171223132753.732a865b17e50f3f67c5306d@itanimul.li
State Superseded
Headers show

Commit Message

Josh Dekker Dec. 23, 2017, 1:27 p.m. UTC 
This is the first patch to add the new API for iterating items within the libraries to lavc, this completes lavc's support for this API (BSFs were already using it).

I'm currently working on a similar patch for lavfi, lavf and lavd. Note that I'm not entirely sure how to properly deprecate stuff so if that's incorrect some advice would be appreciated.

Comments

wm4 Dec. 23, 2017, 3:50 p.m. UTC | #1 
On Sat, 23 Dec 2017 13:27:53 +0000
Josh de Kock <josh@itanimul.li> wrote:

> From 1d84641556eea563b82b17a6ffe54226e0e31c4e Mon Sep 17 00:00:00 2001
> From: Josh de Kock <josh@itanimul.li>
> Date: Fri, 22 Dec 2017 22:17:00 +0000
> Subject: [PATCH] lavc: add new API for iterating codecs and codec parsers
> 
> Also replace linked list with an array.
> ---

I generally agree with this patch.

>  configure              |   14 +-
>  libavcodec/allcodecs.c | 1472 ++++++++++++++++++++++++++++--------------------
>  libavcodec/avcodec.h   |   25 +
>  libavcodec/parser.c    |   86 ++-
>  libavcodec/utils.c     |  105 ----
>  5 files changed, 962 insertions(+), 740 deletions(-)
> 
> diff --git a/configure b/configure
> index d09eec4..681fe10 100755
> --- a/configure
> +++ b/configure
> @@ -3517,9 +3517,6 @@ find_things(){
>      sed -n "s/^[^#]*$pattern.*([^,]*, *\([^,]*\)\(,.*\)*).*/\1_$thing/p" "$file"
>  }
>  
> -ENCODER_LIST=$(find_things  encoder  ENC      libavcodec/allcodecs.c)
> -DECODER_LIST=$(find_things  decoder  DEC      libavcodec/allcodecs.c)
> -PARSER_LIST=$(find_things   parser   PARSER   libavcodec/allcodecs.c)
>  MUXER_LIST=$(find_things    muxer    _MUX     libavformat/allformats.c)
>  DEMUXER_LIST=$(find_things  demuxer  DEMUX    libavformat/allformats.c)
>  OUTDEV_LIST=$(find_things   outdev   OUTDEV   libavdevice/alldevices.c)
> @@ -3533,6 +3530,13 @@ find_things_extern(){
>      sed -n "s/^[^#]*extern.*$pattern *ff_\([^ ]*\)_$thing;/\1_$thing/p" "$file"
>  }
>  
> +ENCODER_LIST=$(find_things_extern encoder AVCodec libavcodec/allcodecs.c)
> +DECODER_LIST=$(find_things_extern decoder AVCodec libavcodec/allcodecs.c)
> +CODEC_LIST="
> +    $ENCODER_LIST
> +    $DECODER_LIST
> +"
> +PARSER_LIST=$(find_things_extern parser AVCodecParser libavcodec/parser.c)
>  BSF_LIST=$(find_things_extern bsf AVBitStreamFilter libavcodec/bitstream_filters.c)
>  HWACCEL_LIST=$(find_things_extern hwaccel AVHWAccel libavcodec/hwaccels.h)
>  PROTOCOL_LIST=$(find_things_extern protocol URLProtocol libavformat/protocols.c)
> @@ -7020,6 +7024,10 @@ print_enabled_components(){
>      cp_if_changed $TMPH $file
>  }
>  
> +print_enabled_components libavcodec/codec_list.c AVCodec codec_list $CODEC_LIST
> +#print_enabled_components libavcodec/encoder_list.c AVCodec encoder_list $ENCODER_LIST
> +#print_enabled_components libavcodec/decoder_list.c AVCodec decoder_list $DECODER_LIST

Commented leftover crap?

> +print_enabled_components libavcodec/parser_list.c AVCodecParser parser_list $PARSER_LIST
>  print_enabled_components libavcodec/bsf_list.c AVBitStreamFilter bitstream_filters $BSF_LIST
>  print_enabled_components libavformat/protocol_list.c URLProtocol url_protocols $PROTOCOL_LIST
>  
> diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c
> index ed1e7ab..cea2bf3 100644
> --- a/libavcodec/allcodecs.c
> +++ b/libavcodec/allcodecs.c
> @@ -29,641 +29,865 @@
>  #include "avcodec.h"
>  #include "version.h"
>  
> -#define REGISTER_ENCODER(X, x)                                          \
> -    {                                                                   \
> -        extern AVCodec ff_##x##_encoder;                                \
> -        if (CONFIG_##X##_ENCODER)                                       \
> -            avcodec_register(&ff_##x##_encoder);                        \
> +extern AVCodec ff_a64multi_encoder;
> [...] 
>
> +#include "codec_list.c"
> +
> +#if CONFIG_ME_CMP
> +#include "me_cmp.h"
> +pthread_once_t ff_me_cmp_static_init = PTHREAD_ONCE_INIT;
> +#endif
> +
> +pthread_once_t av_codec_next_init = PTHREAD_ONCE_INIT;
> +
> +const AVCodec *av_codec_iterate(void **opaque)
> +{
> +    uintptr_t i = (uintptr_t)*opaque;
> +    const AVCodec *c = codec_list[i];
> +
> +    if (c)
> +        *opaque = (void*)(i + 1);
> +
> +    return c;
> +}
> +
> +static void av_codec_init_next(void)
> +{
> +    AVCodec *prev = NULL, *p;
> +    void *i = 0;
> +    while ((p = (AVCodec*)av_codec_iterate(&i))) {
> +        if (prev)
> +            prev->next = p;
> +        prev = p;
>      }
> +    prev->next = NULL;
> +}
>  
> -#define REGISTER_DECODER(X, x)                                          \
> -    {                                                                   \
> -        extern AVCodec ff_##x##_decoder;                                \
> -        if (CONFIG_##X##_DECODER)                                       \
> -            avcodec_register(&ff_##x##_decoder);                        \
> +av_cold void avcodec_register(AVCodec *codec)
> +{

This function, together with av_codec_next(), should be deprecated.
Just adding attribute_deprecated isn't enough. You also need to add
that FF_API_ ifdeffery soup (unfortunately).

> +#if CONFIG_ME_CMP
> +    pthread_once(&ff_me_cmp_static_init, ff_me_cmp_init_static);
> +#endif
> +
> +    pthread_once(&av_codec_next_init, av_codec_init_next);
> +    
> +    if (codec->init_static_data)
> +        codec->init_static_data(codec);
> +}

As I stated below, this stuff should go away. The me_cmp thing can
probably be (very carefully) be moved to codecs which need it. The
init_static_data thing will have to stay for a while, because wrappers
like libx264 modify a public field of AVCodec in it.

> +
> +AVCodec *av_codec_next(const AVCodec *c)
> +{
> +    pthread_once(&av_codec_next_init, av_codec_init_next);
> +
> +    if (c)
> +        return c->next;
> +    else
> +        return (AVCodec*)codec_list[0];
> +}
> +
> +static enum AVCodecID remap_deprecated_codec_id(enum AVCodecID id)
> +{
> +    switch(id){
> +        //This is for future deprecatec codec ids, its empty since
> +        //last major bump but will fill up again over time, please don't remove it
> +        default                                         : return id;
>      }
> +}
> +
> +static AVCodec *find_codec(enum AVCodecID id, int (*x)(const AVCodec *))
> +{
> +    const AVCodec *p, *experimental = NULL;
> +    void *i = 0;
>  
> -#define REGISTER_ENCDEC(X, x) REGISTER_ENCODER(X, x); REGISTER_DECODER(X, x)
> +    id = remap_deprecated_codec_id(id);
>  
> -#define REGISTER_PARSER(X, x)                                           \
> -    {                                                                   \
> -        extern AVCodecParser ff_##x##_parser;                           \
> -        if (CONFIG_##X##_PARSER)                                        \
> -            av_register_codec_parser(&ff_##x##_parser);                 \
> +    while ((p = av_codec_iterate(&i))) {
> +        if (!x(p))
> +            continue;
> +        if (p->id == id) {
> +            if (p->capabilities & AV_CODEC_CAP_EXPERIMENTAL && !experimental) {
> +                experimental = p;
> +            } else
> +                return (AVCodec*)p;
> +        }
>      }
>  
> -static void register_all(void)
> +    return (AVCodec*)experimental;
> +}
> +
> +AVCodec *avcodec_find_encoder(enum AVCodecID id)
>  {
> -    /* video codecs */
> -    REGISTER_ENCODER(A64MULTI,          a64multi);
> [...]
> +    return find_codec(id, av_codec_is_encoder);
> +}
> +
> +AVCodec *avcodec_find_decoder(enum AVCodecID id)
> +{
> +    return find_codec(id, av_codec_is_decoder);
> +}
> +
> +static AVCodec *find_codec_by_name(const char *name, int (*x)(const AVCodec *))
> +{
> +    void *i = 0;
> +    const AVCodec *p;
> +
> +    if (!name)
> +        return NULL;
> +
> +    while ((p = av_codec_iterate(&i))) {
> +        if (!x(p))
> +            continue;
> +        if (strcmp(name, p->name) == 0)
> +            return (AVCodec*)p;
> +    }
> +
> +    return NULL;
> +}
> +
> +AVCodec *avcodec_find_encoder_by_name(const char *name)
> +{
> +    return find_codec_by_name(name, av_codec_is_encoder);
> +}
> +
> +AVCodec *avcodec_find_decoder_by_name(const char *name)
> +{
> +    return find_codec_by_name(name, av_codec_is_decoder);
>  }
>  
>  void avcodec_register_all(void)
>  {
> -    static AVOnce control = AV_ONCE_INIT;
> +	const AVCodec *codec;
> +    void *i = 0;
>  
> -    ff_thread_once(&control, register_all);
> +#if CONFIG_ME_CMP
> +    pthread_once(&ff_me_cmp_static_init, ff_me_cmp_init_static);
> +#endif
> +
> +    pthread_once(&av_codec_next_init, av_codec_init_next);
> +
> +    while ((codec = av_codec_iterate(&i))) {
> +        if (codec->init_static_data)
> +        	codec->init_static_data((AVCodec*)codec);
> +    }
>  }

I think this function should be deprecated, and not be required to be
called. This requires init_static_data and the me_cmp thing to be moved
somewhere else. Also, init_static_data should somehow be synchronized
too.

> diff --git a/libavcodec/avcodec.h b/libavcodec/avcodec.h
> index ce089b7..2300974 100644
> --- a/libavcodec/avcodec.h
> +++ b/libavcodec/avcodec.h
> @@ -3979,10 +3979,22 @@ typedef struct AVCodecParameters {
>  } AVCodecParameters;
>  
>  /**
> + * Iterate over all registered codecs.
> + *
> + * @param opaque a pointer where libavcodec will store the iteration state. Must
> + *               point to NULL to start the iteration.
> + *
> + * @return the next registered codec or NULL when the iteration is
> + *         finished
> + */
> +const AVCodec *av_codec_iterate(void **opaque);
> +
> +/**
>   * If c is NULL, returns the first registered codec,
>   * if c is non-NULL, returns the next registered codec after c,
>   * or NULL if c is the last one.
>   */
> +attribute_deprecated
>  AVCodec *av_codec_next(const AVCodec *c);
>  
>  /**
> @@ -5120,8 +5132,21 @@ typedef struct AVCodecParser {
>      struct AVCodecParser *next;
>  } AVCodecParser;
>  
> +/**
> + * Iterate over all registered codec parsers.
> + *
> + * @param opaque a pointer where libavcodec will store the iteration state. Must
> + *               point to NULL to start the iteration.
> + *
> + * @return the next registered codec parser or NULL when the iteration is
> + *         finished
> + */
> +const AVCodecParser *av_parser_iterate(void **opaque);

Such additions need doc/APIchanges entries. Deprecations receive an
entry in that file too.

> +
> +attribute_deprecated
>  AVCodecParser *av_parser_next(const AVCodecParser *c);
>  
> +attribute_deprecated
>  void av_register_codec_parser(AVCodecParser *parser);
>  AVCodecParserContext *av_parser_init(int codec_id);
>  
> diff --git a/libavcodec/parser.c b/libavcodec/parser.c
> index 670680e..4e4c22d 100644
> --- a/libavcodec/parser.c
> +++ b/libavcodec/parser.c
> @@ -32,33 +32,103 @@
>  #include "internal.h"
>  #include "parser.h"
>  
> -static AVCodecParser *av_first_parser = NULL;
> +#include "pthread.h"
> +
> +/* Parsers */
> +extern AVCodecParser ff_aac_parser;
> +extern AVCodecParser ff_aac_latm_parser;
> +extern AVCodecParser ff_ac3_parser;
> +extern AVCodecParser ff_adx_parser;
> +extern AVCodecParser ff_bmp_parser;
> +extern AVCodecParser ff_cavsvideo_parser;
> +extern AVCodecParser ff_cook_parser;
> +extern AVCodecParser ff_dca_parser;
> +extern AVCodecParser ff_dirac_parser;
> +extern AVCodecParser ff_dnxhd_parser;
> +extern AVCodecParser ff_dpx_parser;
> +extern AVCodecParser ff_dvaudio_parser;
> +extern AVCodecParser ff_dvbsub_parser;
> +extern AVCodecParser ff_dvdsub_parser;
> +extern AVCodecParser ff_dvd_nav_parser;
> +extern AVCodecParser ff_flac_parser;
> +extern AVCodecParser ff_g729_parser;
> +extern AVCodecParser ff_gsm_parser;
> +extern AVCodecParser ff_h261_parser;
> +extern AVCodecParser ff_h263_parser;
> +extern AVCodecParser ff_h264_parser;
> +extern AVCodecParser ff_hevc_parser;
> +extern AVCodecParser ff_mjpeg_parser;
> +extern AVCodecParser ff_mlp_parser;
> +extern AVCodecParser ff_mpeg4video_parser;
> +extern AVCodecParser ff_mpegaudio_parser;
> +extern AVCodecParser ff_mpegvideo_parser;
> +extern AVCodecParser ff_opus_parser;
> +extern AVCodecParser ff_png_parser;
> +extern AVCodecParser ff_pnm_parser;
> +extern AVCodecParser ff_rv30_parser;
> +extern AVCodecParser ff_rv40_parser;
> +extern AVCodecParser ff_sipr_parser;
> +extern AVCodecParser ff_tak_parser;
> +extern AVCodecParser ff_vc1_parser;
> +extern AVCodecParser ff_vorbis_parser;
> +extern AVCodecParser ff_vp3_parser;
> +extern AVCodecParser ff_vp8_parser;
> +extern AVCodecParser ff_vp9_parser;
> +extern AVCodecParser ff_xma_parser;
> +
> +#include "parser_list.c"
> +
> +pthread_once_t av_parser_next_init = PTHREAD_ONCE_INIT;
> +
> +static void av_parser_init_next(void)
> +{
> +    AVCodecParser *prev = NULL, *p;
> +    int i = 0;
> +    while ((p = (AVCodecParser*)parser_list[i++])) {
> +        if (prev)
> +            prev->next = p;
> +        prev = p;
> +    }
> +    prev->next = NULL;
> +}
>  
>  AVCodecParser *av_parser_next(const AVCodecParser *p)
>  {
> +    pthread_once(&av_parser_next_init, av_parser_init_next);
> +
>      if (p)
>          return p->next;
>      else
> -        return av_first_parser;
> +        return (AVCodecParser*)parser_list[0];
> +}
> +
> +const AVCodecParser *av_parser_iterate(void **opaque)
> +{
> +    uintptr_t i = (uintptr_t)*opaque;
> +    const AVCodecParser *p = parser_list[i];
> +
> +    if (p)
> +        *opaque = (void*)(i + 1);
> +
> +    return p;
>  }
>  
>  void av_register_codec_parser(AVCodecParser *parser)
>  {
> -    do {
> -        parser->next = av_first_parser;
> -    } while (parser->next != avpriv_atomic_ptr_cas((void * volatile *)&av_first_parser, parser->next, parser));
> +    pthread_once(&av_parser_next_init, av_parser_init_next);
>  }
>  
>  AVCodecParserContext *av_parser_init(int codec_id)
>  {
>      AVCodecParserContext *s = NULL;
> -    AVCodecParser *parser;
> +    const AVCodecParser *parser;
> +    void *i = 0;
>      int ret;
>  
>      if (codec_id == AV_CODEC_ID_NONE)
>          return NULL;
>  
> -    for (parser = av_first_parser; parser; parser = parser->next) {
> +    while ((parser = av_parser_iterate(&i))) {
>          if (parser->codec_ids[0] == codec_id ||
>              parser->codec_ids[1] == codec_id ||
>              parser->codec_ids[2] == codec_id ||
> @@ -72,7 +142,7 @@ found:
>      s = av_mallocz(sizeof(AVCodecParserContext));
>      if (!s)
>          goto err_out;
> -    s->parser = parser;
> +    s->parser = (AVCodecParser*)parser;
>      s->priv_data = av_mallocz(parser->priv_data_size);
>      if (!s->priv_data)
>          goto err_out;
> diff --git a/libavcodec/utils.c b/libavcodec/utils.c
> index 873f39f..ff1422e 100644
> --- a/libavcodec/utils.c
> +++ b/libavcodec/utils.c
> @@ -47,7 +47,6 @@
>  #include "decode.h"
>  #include "hwaccel.h"
>  #include "libavutil/opt.h"
> -#include "me_cmp.h"
>  #include "mpegvideo.h"
>  #include "thread.h"
>  #include "frame_thread_encoder.h"
> @@ -144,30 +143,6 @@ void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size)
>          memset(*p, 0, min_size + AV_INPUT_BUFFER_PADDING_SIZE);
>  }
>  
> -/* encoder management */
> -static AVCodec *first_avcodec = NULL;
> -static AVCodec **last_avcodec = &first_avcodec;
> -
> -AVCodec *av_codec_next(const AVCodec *c)
> -{
> -    if (c)
> -        return c->next;
> -    else
> -        return first_avcodec;
> -}
> -
> -static av_cold void avcodec_init(void)
> -{
> -    static int initialized = 0;
> -
> -    if (initialized != 0)
> -        return;
> -    initialized = 1;
> -
> -    if (CONFIG_ME_CMP)
> -        ff_me_cmp_init_static();
> -}
> -
>  int av_codec_is_encoder(const AVCodec *codec)
>  {
>      return codec && (codec->encode_sub || codec->encode2 ||codec->send_frame);
> @@ -178,21 +153,6 @@ int av_codec_is_decoder(const AVCodec *codec)
>      return codec && (codec->decode || codec->receive_frame);
>  }
>  
> -av_cold void avcodec_register(AVCodec *codec)
> -{
> -    AVCodec **p;
> -    avcodec_init();
> -    p = last_avcodec;
> -    codec->next = NULL;
> -
> -    while(*p || avpriv_atomic_ptr_cas((void * volatile *)p, NULL, codec))
> -        p = &(*p)->next;
> -    last_avcodec = &codec->next;
> -
> -    if (codec->init_static_data)
> -        codec->init_static_data(codec);
> -}
> -
>  int ff_set_dimensions(AVCodecContext *s, int width, int height)
>  {
>      int ret = av_image_check_size2(width, height, s->max_pixels, AV_PIX_FMT_NONE, 0, s);
> @@ -1202,71 +1162,6 @@ FF_ENABLE_DEPRECATION_WARNINGS
>      return 0;
>  }
>  
> -static enum AVCodecID remap_deprecated_codec_id(enum AVCodecID id)
> -{
> -    switch(id){
> -        //This is for future deprecatec codec ids, its empty since
> -        //last major bump but will fill up again over time, please don't remove it
> -        default                                         : return id;
> -    }
> -}
> -
> -static AVCodec *find_encdec(enum AVCodecID id, int encoder)
> -{
> -    AVCodec *p, *experimental = NULL;
> -    p = first_avcodec;
> -    id= remap_deprecated_codec_id(id);
> -    while (p) {
> -        if ((encoder ? av_codec_is_encoder(p) : av_codec_is_decoder(p)) &&
> -            p->id == id) {
> -            if (p->capabilities & AV_CODEC_CAP_EXPERIMENTAL && !experimental) {
> -                experimental = p;
> -            } else
> -                return p;
> -        }
> -        p = p->next;
> -    }
> -    return experimental;
> -}
> -
> -AVCodec *avcodec_find_encoder(enum AVCodecID id)
> -{
> -    return find_encdec(id, 1);
> -}
> -
> -AVCodec *avcodec_find_encoder_by_name(const char *name)
> -{
> -    AVCodec *p;
> -    if (!name)
> -        return NULL;
> -    p = first_avcodec;
> -    while (p) {
> -        if (av_codec_is_encoder(p) && strcmp(name, p->name) == 0)
> -            return p;
> -        p = p->next;
> -    }
> -    return NULL;
> -}
> -
> -AVCodec *avcodec_find_decoder(enum AVCodecID id)
> -{
> -    return find_encdec(id, 0);
> -}
> -
> -AVCodec *avcodec_find_decoder_by_name(const char *name)
> -{
> -    AVCodec *p;
> -    if (!name)
> -        return NULL;
> -    p = first_avcodec;
> -    while (p) {
> -        if (av_codec_is_decoder(p) && strcmp(name, p->name) == 0)
> -            return p;
> -        p = p->next;
> -    }
> -    return NULL;
> -}
> -
>  const char *avcodec_get_name(enum AVCodecID id)
>  {
>      const AVCodecDescriptor *cd;

I think it'd be slightly more readable if you did the move in a
separate patch before this one, but I'm not insisting on it.
Michael Niedermayer Dec. 24, 2017, 1:06 a.m. UTC | #2 
On Sat, Dec 23, 2017 at 01:27:53PM +0000, Josh de Kock wrote:
> This is the first patch to add the new API for iterating items within the libraries to lavc, this completes lavc's support for this API (BSFs were already using it).
> 
> I'm currently working on a similar patch for lavfi, lavf and lavd. Note that I'm not entirely sure how to properly deprecate stuff so if that's incorrect some advice would be appreciated.
> 
> -- 
> Josh de Kock <josh@itanimul.li>

>  configure              |   14 
>  libavcodec/allcodecs.c | 1472 ++++++++++++++++++++++++++++---------------------
>  libavcodec/avcodec.h   |   25 
>  libavcodec/parser.c    |   86 ++
>  libavcodec/utils.c     |  105 ---
>  5 files changed, 962 insertions(+), 740 deletions(-)
> 1d29484b82a8f3aaa4689f316f20819ebe3ff8a6  0001-lavc-add-new-API-for-iterating-codecs-and-codec-pars.patch
> From 1d84641556eea563b82b17a6ffe54226e0e31c4e Mon Sep 17 00:00:00 2001
> From: Josh de Kock <josh@itanimul.li>
> Date: Fri, 22 Dec 2017 22:17:00 +0000
> Subject: [PATCH] lavc: add new API for iterating codecs and codec parsers
> 
> Also replace linked list with an array.
> ---
>  configure              |   14 +-
>  libavcodec/allcodecs.c | 1472 ++++++++++++++++++++++++++++--------------------
>  libavcodec/avcodec.h   |   25 +
>  libavcodec/parser.c    |   86 ++-
>  libavcodec/utils.c     |  105 ----
>  5 files changed, 962 insertions(+), 740 deletions(-)
[...]

> +static void av_codec_init_next(void)
> +{
> +    AVCodec *prev = NULL, *p;
> +    void *i = 0;
> +    while ((p = (AVCodec*)av_codec_iterate(&i))) {
> +        if (prev)
> +            prev->next = p;
> +        prev = p;
>      }
> +    prev->next = NULL;
> +}
>  
> -#define REGISTER_DECODER(X, x)                                          \
> -    {                                                                   \
> -        extern AVCodec ff_##x##_decoder;                                \
> -        if (CONFIG_##X##_DECODER)                                       \
> -            avcodec_register(&ff_##x##_decoder);                        \

> +av_cold void avcodec_register(AVCodec *codec)
> +{
> +#if CONFIG_ME_CMP
> +    pthread_once(&ff_me_cmp_static_init, ff_me_cmp_init_static);
> +#endif
> +
> +    pthread_once(&av_codec_next_init, av_codec_init_next);
> +    
> +    if (codec->init_static_data)
> +        codec->init_static_data(codec);
> +}
> +

This would not register the provided codec. You have to still register it
in case its a AVCodec provided by the user (app).

The commit message does not say that registering user provided codecs is
removed. This is unacceptable. You cannot silently remove this.

If you mean to lock libavcodec down so that registration of codecs is no
longer possible, this has to be made clear in the commit message.

I do in fact not agree to remove this as i belive its moving us away from
the spirit of open source. But in case im in the minority at least what is
done must be clearly stated in the commit message.
Its untrue that this is just adding a new API

Now changing the linked list to an array (which your patch does half of) is
probably a good idea.
If you and others agree we can also easily maintain support for user apps
to register codecs. The only thing needed is to make the array bigger and
add codecs which arent ours in there as long as there is space.
doing this would be very easy, a atomic integer pointing to the begin of
the free space which is atomically increased for each register is all that
is needed


> +AVCodec *av_codec_next(const AVCodec *c)
> +{
> +    pthread_once(&av_codec_next_init, av_codec_init_next);
> +
> +    if (c)
> +        return c->next;

AVCodec->next should be removed as it makes the structs non constant

Thanks

[...]
wm4 Dec. 24, 2017, 1:31 a.m. UTC | #3 
On Sun, 24 Dec 2017 02:06:40 +0100
Michael Niedermayer <michael@niedermayer.cc> wrote:

> If you and others agree we can also easily maintain support for user apps
> to register codecs. The only thing needed is to make the array bigger and
> add codecs which arent ours in there as long as there is space.
> doing this would be very easy, a atomic integer pointing to the begin of
> the free space which is atomically increased for each register is all that
> is needed

Not sure how often I repeated this (specifically for you), but:

- users can't provide AVCodec, because it would require accessing
  internal API and private ABI unstable fields
- if we provide the ability to add user codecs (which I'm not
  fundamentally against), then it should not modify global state.
  Having named user codecs in a process wide list would definitely lead
  to name clashes or other conflicts
- also, we would have to provide stable/public API for implementing
  codecs in the first place (all AVCodec callback fields are private),
  and we're nowhere near the state of adding it
- dropping avcodec_register() is definitely not the worst blocker for
  user codecs - it's very, very far from it, because once we have
  fixed the things above, we can just add a new public API for
  registering (which would have to have a different function signature
  to avoid global mutable lists). So I don't know why you complain.
- these points are technical, not ideological

Can you point out any user application which registers its own codecs
(and this violates the API)?

> > +AVCodec *av_codec_next(const AVCodec *c)
> > +{
> > +    pthread_once(&av_codec_next_init, av_codec_init_next);
> > +
> > +    if (c)
> > +        return c->next;  
> 
> AVCodec->next should be removed as it makes the structs non constant

That has to happen after a deprecation phase, unless you have an idea
how to make av_codec_next() not O(n^2) without this.
Michael Niedermayer Dec. 24, 2017, 11:43 a.m. UTC | #4 
On Sun, Dec 24, 2017 at 02:31:16AM +0100, wm4 wrote:
> On Sun, 24 Dec 2017 02:06:40 +0100
> Michael Niedermayer <michael@niedermayer.cc> wrote:
> 
> > If you and others agree we can also easily maintain support for user apps
> > to register codecs. The only thing needed is to make the array bigger and
> > add codecs which arent ours in there as long as there is space.
> > doing this would be very easy, a atomic integer pointing to the begin of
> > the free space which is atomically increased for each register is all that
> > is needed
> 
> Not sure how often I repeated this (specifically for you), but:

why are you so upset ? We have different oppinions here or we misunderstand
each other.


> 
> - users can't provide AVCodec, because it would require accessing
>   internal API and private ABI unstable fields

That is expected without there being an effort to design a public API
for external codecs.

Point being, this doesnt matter.
One can still maintain an external codec register it and use it.
It would need to be rebuild for each libavcodec version and would
occasionally need to be changed like any internal codec.
But it would not be harder than maintaining a codec inside ffmpeg.

Especially if one targets a release like 3.4.x it would be close to 0
work to have a external codec that is registered compared to having it
internal


> - if we provide the ability to add user codecs (which I'm not
>   fundamentally against), then it should not modify global state.
>   Having named user codecs in a process wide list would definitely lead
>   to name clashes or other conflicts

I dont see how you could do this without modifying global state.
You would need some kind of context for all codec "lookup" functions

Such context could be added and iam not against this at all, but i feel
this is fixing a problem noone has ever had. registering codecs was
supported since forever and ive never heared of a conflict like you describe


> - also, we would have to provide stable/public API for implementing
>   codecs in the first place (all AVCodec callback fields are private),
>   and we're nowhere near the state of adding it

I would love to see such a API and i would certainly contribute but
as explained above, we dont have it and we dont really need it for
registering user codec to be usefull in practice IMO


> - dropping avcodec_register() is definitely not the worst blocker for
>   user codecs - it's very, very far from it, because once we have
>   fixed the things above, we can just add a new public API for
>   registering (which would have to have a different function signature
>   to avoid global mutable lists). So I don't know why you complain.

Like elaborated above, it is the main problem.
Currently external codecs are possible for all i know. And i have
seen it used a few years ago, so it did work at some point in real
applications.


> - these points are technical, not ideological
> 
> Can you point out any user application which registers its own codecs
> (and this violates the API)?

I do not remember which application it was but i did a few years ago review
all user apps using libavcodec / libavformat for things we could merge.
I do remember seeing some that added codecs.
It was some code that was very specific to the app or platform IIRC

There are more usecases. For example codec optimizations for niche
codecs where rejected on ffmpeg-devel.
I find it unfriendly from us if we reject improvments because they
arent in a area most of us care and then also drop the possibility
for externally maintaining and registering code without doing a
full fork (which is much more work to maintain)

> 
> > > +AVCodec *av_codec_next(const AVCodec *c)
> > > +{
> > > +    pthread_once(&av_codec_next_init, av_codec_init_next);
> > > +
> > > +    if (c)
> > > +        return c->next;  
> > 
> > AVCodec->next should be removed as it makes the structs non constant
> 
> That has to happen after a deprecation phase, unless you have an idea
> how to make av_codec_next() not O(n^2) without this.

That can be done and there are many ways. Not saying we want to do it
first possibility, one can add a int "constant" to each AVCodec.
configure would have to choose these or there would be holes in the array.
a hashtable with a mutex is an option too but that seems not worth the
complexity / work
the 3rd obvious option is to make "next" a pointer to a int which is
initialized in each codec to some static int. Which can then be set
to the array index, the main struct can then remain in read only memory
iam pretty sure there are many more options

PS: merry Xmas!

[...]
Rostislav Pehlivanov Dec. 24, 2017, 12:39 p.m. UTC | #5 
On 24 December 2017 at 11:43, Michael Niedermayer <michael@niedermayer.cc>
wrote:

> On Sun, Dec 24, 2017 at 02:31:16AM +0100, wm4 wrote:
> > On Sun, 24 Dec 2017 02:06:40 +0100
> > Michael Niedermayer <michael@niedermayer.cc> wrote:
> >
> > > If you and others agree we can also easily maintain support for user
> apps
> > > to register codecs. The only thing needed is to make the array bigger
> and
> > > add codecs which arent ours in there as long as there is space.
> > > doing this would be very easy, a atomic integer pointing to the begin
> of
> > > the free space which is atomically increased for each register is all
> that
> > > is needed
> >
> > Not sure how often I repeated this (specifically for you), but:
>
> why are you so upset ? We have different oppinions here or we misunderstand
> each other.
>
>
> >
> > - users can't provide AVCodec, because it would require accessing
> >   internal API and private ABI unstable fields
>
> That is expected without there being an effort to design a public API
> for external codecs.
>
> Point being, this doesnt matter.
> One can still maintain an external codec register it and use it.
> It would need to be rebuild for each libavcodec version and would
> occasionally need to be changed like any internal codec.
> But it would not be harder than maintaining a codec inside ffmpeg.
>
> Especially if one targets a release like 3.4.x it would be close to 0
> work to have a external codec that is registered compared to having it
> internal
>
>

Stop derailing the thread, both of you. We're not going to support external
codecs now,
nor in the future. This has been discussed before. Much of the work that
would be done on
supporting external codecs is better spent with a disassembler on some
binary of a yet
another H264/HEVC copy.
Muhammad Faiz Dec. 24, 2017, 1:59 p.m. UTC | #6 
On Sat, Dec 23, 2017 at 8:27 PM, Josh de Kock <josh@itanimul.li> wrote:
> This is the first patch to add the new API for iterating items within the libraries to lavc, this completes lavc's support for this API (BSFs were already using it).
>
> I'm currently working on a similar patch for lavfi, lavf and lavd. Note that I'm not entirely sure how to properly deprecate stuff so if that's incorrect some advice would be appreciated.
>
> --
> Josh de Kock <josh@itanimul.li>

>+
>+#include "codec_list.c"
>+

Building outside ffmpeg tree, I got
CC      libavcodec/allcodecs.o
CC      libavcodec/alsdec.o
src/libavcodec/allcodecs.c:756:24: fatal error: codec_list.c: No such
file or directory
compilation terminated.

Also, the patch contains tabs and trailing whitespace.
James Almer Dec. 24, 2017, 2:56 p.m. UTC | #7 
On 12/24/2017 8:43 AM, Michael Niedermayer wrote:
> On Sun, Dec 24, 2017 at 02:31:16AM +0100, wm4 wrote:
>> On Sun, 24 Dec 2017 02:06:40 +0100
>> Michael Niedermayer <michael@niedermayer.cc> wrote:
>>
>>> If you and others agree we can also easily maintain support for user apps
>>> to register codecs. The only thing needed is to make the array bigger and
>>> add codecs which arent ours in there as long as there is space.
>>> doing this would be very easy, a atomic integer pointing to the begin of
>>> the free space which is atomically increased for each register is all that
>>> is needed
>>
>> Not sure how often I repeated this (specifically for you), but:
> 
> why are you so upset ? We have different oppinions here or we misunderstand
> each other.
> 
> 
>>
>> - users can't provide AVCodec, because it would require accessing
>>   internal API and private ABI unstable fields
> 
> That is expected without there being an effort to design a public API
> for external codecs.
> 
> Point being, this doesnt matter.
> One can still maintain an external codec register it and use it.
> It would need to be rebuild for each libavcodec version and would
> occasionally need to be changed like any internal codec.
> But it would not be harder than maintaining a codec inside ffmpeg.

Every project that requires some custom addition to what ffmpeg offers
will and should implement them into their own public fork of ffmpeg as
lgpl expects them to, and right now that includes custom modules like
codecs, muxers and such. Said changes can then be upstreamed if
needed/useful.

The API does not allow them to register their own codecs. We could right
now move all the "private" AVCodec fields into an internal opaque struct
while keeping the codec register API untouched and it wouldn't be an API
break of any kind, yet it would prevent people from abusing it and
registering their own Frankencodecs.
So yes, it's literally a side effect of us putting internal fields in
public headers, an awful practice that no one else does, probably
because of reasons like the one we're discussing.

Furthermore, we did what this patch is doing with hwaccels a month or so
ago, and it wasn't an issue. Same with bsfs like a year ago. This is
simply the next step.

> 
> Especially if one targets a release like 3.4.x it would be close to 0
> work to have a external codec that is registered compared to having it
> internal
> 
> 
>> - if we provide the ability to add user codecs (which I'm not
>>   fundamentally against), then it should not modify global state.
>>   Having named user codecs in a process wide list would definitely lead
>>   to name clashes or other conflicts
> 
> I dont see how you could do this without modifying global state.
> You would need some kind of context for all codec "lookup" functions
> 
> Such context could be added and iam not against this at all, but i feel
> this is fixing a problem noone has ever had. registering codecs was
> supported since forever and ive never heared of a conflict like you describe
> 
> 
>> - also, we would have to provide stable/public API for implementing
>>   codecs in the first place (all AVCodec callback fields are private),
>>   and we're nowhere near the state of adding it
> 
> I would love to see such a API and i would certainly contribute but
> as explained above, we dont have it and we dont really need it for
> registering user codec to be usefull in practice IMO
> 
> 
>> - dropping avcodec_register() is definitely not the worst blocker for
>>   user codecs - it's very, very far from it, because once we have
>>   fixed the things above, we can just add a new public API for
>>   registering (which would have to have a different function signature
>>   to avoid global mutable lists). So I don't know why you complain.
> 
> Like elaborated above, it is the main problem.
> Currently external codecs are possible for all i know. And i have
> seen it used a few years ago, so it did work at some point in real
> applications.
> 
> 
>> - these points are technical, not ideological
>>
>> Can you point out any user application which registers its own codecs
>> (and this violates the API)?
> 
> I do not remember which application it was but i did a few years ago review
> all user apps using libavcodec / libavformat for things we could merge.
> I do remember seeing some that added codecs.
> It was some code that was very specific to the app or platform IIRC

"People in the past misused the API. What if they still do?" is not a
good reason to prevent development and improvements to our codebase.
People will always misuse the API when they can, and it should never be
a reason to condition development. Just look at how things were with
mplayer for the longest time.

> 
> There are more usecases. For example codec optimizations for niche
> codecs where rejected on ffmpeg-devel.
> I find it unfriendly from us if we reject improvments because they
> arent in a area most of us care and then also drop the possibility
> for externally maintaining and registering code without doing a
> full fork (which is much more work to maintain)

No, it's not easier to maintain than in a fork. They are still forced to
ship their own libavcodec instead of using the system one since they are
using private, non fixed ABI fields to register their codecs, they still
need to adapt to any non offset related changes to said callback fields,
etc.

If we eventually add the possibility to register user codecs, then it
should be one similar to AVIO, where the callback functions are provided
by the user at the moment of allocating an AVCodec before it can be
registered. But right now, registering user codecs is so fragile that
it's a matter of making the private AVCodec fields truly private for it
to stop being possible.

> 
>>
>>>> +AVCodec *av_codec_next(const AVCodec *c)
>>>> +{
>>>> +    pthread_once(&av_codec_next_init, av_codec_init_next);
>>>> +
>>>> +    if (c)
>>>> +        return c->next;  
>>>
>>> AVCodec->next should be removed as it makes the structs non constant
>>
>> That has to happen after a deprecation phase, unless you have an idea
>> how to make av_codec_next() not O(n^2) without this.
> 
> That can be done and there are many ways. Not saying we want to do it
> first possibility, one can add a int "constant" to each AVCodec.
> configure would have to choose these or there would be holes in the array.
> a hashtable with a mutex is an option too but that seems not worth the
> complexity / work
> the 3rd obvious option is to make "next" a pointer to a int which is
> initialized in each codec to some static int. Which can then be set
> to the array index, the main struct can then remain in read only memory
> iam pretty sure there are many more options
> 
> PS: merry Xmas!

Merry Christmas :)

> 
> [...]
> 
> 
> 
> _______________________________________________
> ffmpeg-devel mailing list
> ffmpeg-devel@ffmpeg.org
> http://ffmpeg.org/mailman/listinfo/ffmpeg-devel
>
Nicolas George Dec. 24, 2017, 3:54 p.m. UTC | #8 
I fully agree with the point you are making, but there is an argument
you are invoking that I do not agree with at all.

James Almer (2017-12-24):
> So yes, it's literally a side effect of us putting internal fields in
> public headers, an awful practice that no one else does

No one else, except glibc, OpenBSD, Gtk+ (until the Gnome guys took
over), which are just the examples that come to mind immediately.

the need for having internal fields in public headers is a consequence
of the design of the C language. There are other languages that offer
better options, but they all have also drawbacks in other area, and I am
pretty sure the vast majority here would rightly be against
reimplementing FFmpeg as a C++ or Rust project.

There are also other options within the C language, but they all have
huge drawbacks.

So when you are saying that it is an awful practice, it is the same as
with Churchill's quote about democracy being the worst form of
government: it is an awful practice, but all other practices to achieve
the same result are even more awful.

There may be a better solution that we have not thought of yet. But if
you propose something, please stay open about the drawbacks that you may
not have seen or may not affect your work flow.

> People will always misuse the API when they can, and it should never be
> a reason to condition development.

I fully agree with that, but beware, I will keep you to it.

It relates directly to the point above: if people are not able to read
"this field is private, do not touch it", that does not mean we should
make it public. But it does not mean that we should make complex efforts
to hide them.

> Merry Christmas :)

I wonder what I should be merrier about: twenty centuries of dogmatic
brainwashing, or the unbounded consumer society leading to a global
ecologic catastrophe.

Happy days-getting-longer to you all!

Regards,
wm4 Dec. 24, 2017, 4:50 p.m. UTC | #9 
On Sun, 24 Dec 2017 12:43:27 +0100
Michael Niedermayer <michael@niedermayer.cc> wrote:

> On Sun, Dec 24, 2017 at 02:31:16AM +0100, wm4 wrote:
> > On Sun, 24 Dec 2017 02:06:40 +0100
> > Michael Niedermayer <michael@niedermayer.cc> wrote:
> >   
> > > If you and others agree we can also easily maintain support for user apps
> > > to register codecs. The only thing needed is to make the array bigger and
> > > add codecs which arent ours in there as long as there is space.
> > > doing this would be very easy, a atomic integer pointing to the begin of
> > > the free space which is atomically increased for each register is all that
> > > is needed  
> > 
> > Not sure how often I repeated this (specifically for you), but:  
> 
> why are you so upset ? We have different oppinions here or we misunderstand
> each other.

Not necessarily upset, but this is tiring. Every time you bring this
up, I have to repeat the arguments I made, and next time you seem to
have forgotten about it. And then it always degenerates in a flame war.
I don't need this.

On the other hand, you seem to be upset about the removal of codec
registering. I don't know why. As I've said, it didn't work anyway,
unless you've used internal API/ABI. You seem to be raising a bit of
a stink about it.

In summary:

- before this commit: you could not register user codecs, unless you've
  used unstable internal API and used ABI unstable internal fields,
  effectively binding to one FFmpeg version
- after this commit: you can not register user codecs, even if you're
  willing to violate the API

Not a big loss I think. Also you could still pass customs AVCodec to
the codec context creation.

> > 
> > - users can't provide AVCodec, because it would require accessing
> >   internal API and private ABI unstable fields  
> 
> That is expected without there being an effort to design a public API
> for external codecs.
> 
> Point being, this doesnt matter.
> One can still maintain an external codec register it and use it.
> It would need to be rebuild for each libavcodec version and would
> occasionally need to be changed like any internal codec.
> But it would not be harder than maintaining a codec inside ffmpeg.

You're just as well off by patching the libavcodec to add your
non-upstreamed codec. (Before this patch, you obviously had to have
control over the libavcodec used, and now you can use your control over
it to patch it in.)

> Especially if one targets a release like 3.4.x it would be close to 0
> work to have a external codec that is registered compared to having it
> internal
> 
> 
> > - if we provide the ability to add user codecs (which I'm not
> >   fundamentally against), then it should not modify global state.
> >   Having named user codecs in a process wide list would definitely lead
> >   to name clashes or other conflicts  
> 
> I dont see how you could do this without modifying global state.
> You would need some kind of context for all codec "lookup" functions
> 
> Such context could be added and iam not against this at all, but i feel

Yes. And this would require new API. Actually, I think you would just
not register the codec at all, but pass it directly to AVCodecContext
initialization (and for other components, anything that actually needs
to access such lists).

In fact you can still do this after this patch. avcodec_alloc_context3()
takes a AVCodec pointer. You can pass a custom struct if you're willing
to violate the public API.

> this is fixing a problem noone has ever had. registering codecs was
> supported since forever and ive never heared of a conflict like you describe

I've never heard of any API user using custom registration. When I
inquired about this in my previous mail, you couldn't name verifiable
examples either.

I know a bunch of programs that broke because libavformat removed
custom protocol registration (and forced you to use a custom AVIO
context instead), but apparently that hasn't been a problem for FFmpeg.

> 
> > - also, we would have to provide stable/public API for implementing
> >   codecs in the first place (all AVCodec callback fields are private),
> >   and we're nowhere near the state of adding it  
> 
> I would love to see such a API and i would certainly contribute but

> as explained above, we dont have it and we dont really need it for
> registering user codec to be usefull in practice IMO

Are you seriously arguing for API users to access internal API?

And I bet some time later you could argue for avoiding internal API
changes because some API users rely on it... This is not how it works.
You're just setting us up for a maintenance nightmare. The whole point
of separation FFmpeg into public and private API is to set a boundary
so we can do anything at all without immediately breaking API users.

> 
> > - dropping avcodec_register() is definitely not the worst blocker for
> >   user codecs - it's very, very far from it, because once we have
> >   fixed the things above, we can just add a new public API for
> >   registering (which would have to have a different function signature
> >   to avoid global mutable lists). So I don't know why you complain.  
> 
> Like elaborated above, it is the main problem.
> Currently external codecs are possible for all i know. And i have
> seen it used a few years ago, so it did work at some point in real
> applications.
> 
> 
> > - these points are technical, not ideological
> > 
> > Can you point out any user application which registers its own codecs
> > (and this violates the API)?  
> 
> I do not remember which application it was but i did a few years ago review
> all user apps using libavcodec / libavformat for things we could merge.
> I do remember seeing some that added codecs.
> It was some code that was very specific to the app or platform IIRC

These sound like they're fine with patching ffmpeg, or using the
method I described above.

Besides, "someone might have done something that violated the API a
decade ago" isn't a very good argument to consider and respect
hypothetical invalid API use now. If the code you mentioned still
exists, we've probably broken it a dozen times by now.

> There are more usecases. For example codec optimizations for niche
> codecs where rejected on ffmpeg-devel.
> I find it unfriendly from us if we reject improvments because they
> arent in a area most of us care and then also drop the possibility
> for externally maintaining and registering code without doing a
> full fork (which is much more work to maintain)

What? We accept tons of obscure features and optimizations.

The only thing I remember that got consistently rejected were the HEVC
optimizations - not because we didn't want them, but because they used
intrinsics in x86 (instead of external asm), which we reject on
principle. We (apparently) had bad experiences with them in the past,
compiler support tends to be flaky, and performance of the generated
code can depend much on used compiler and is not very predictable. You
know very well that we have a policy to reject intrinsics and that we
follow it for good reasons.

I'm not sure why you feel the need to distort the facts that much just
to make some sort of passive aggressive sounding point about general
dev/project practices.

> >   
> > > > +AVCodec *av_codec_next(const AVCodec *c)
> > > > +{
> > > > +    pthread_once(&av_codec_next_init, av_codec_init_next);
> > > > +
> > > > +    if (c)
> > > > +        return c->next;    
> > > 
> > > AVCodec->next should be removed as it makes the structs non constant  
> > 
> > That has to happen after a deprecation phase, unless you have an idea
> > how to make av_codec_next() not O(n^2) without this.  
> 
> That can be done and there are many ways. Not saying we want to do it
> first possibility, one can add a int "constant" to each AVCodec.
> configure would have to choose these or there would be holes in the array.

That sounds complicated, how would configure modify each AVCodec struct
(which are spread into hundreds of source files)?

> a hashtable with a mutex is an option too but that seems not worth the
> complexity / work
> the 3rd obvious option is to make "next" a pointer to a int which is
> initialized in each codec to some static int. Which can then be set
> to the array index, the main struct can then remain in read only memory
> iam pretty sure there are many more options

Not sure how these are better than just initializing the next pointer
for now, until deprecation removes it.

> PS: merry Xmas!

Same.
Lou Logan Dec. 24, 2017, 7:24 p.m. UTC | #10 
On Sun, Dec 24, 2017, at 6:54 AM, Nicolas George wrote:
>
> ...or the unbounded consumer society leading to a global ecologic catastrophe.

As I work in the multimedia field I am therefore too poor to participate in the consumer society.

> Happy days-getting-longer to you all!

What about the other half of the planet?
Michael Niedermayer Dec. 25, 2017, 3:02 a.m. UTC | #11 
On Sun, Dec 24, 2017 at 05:50:29PM +0100, wm4 wrote:
> On Sun, 24 Dec 2017 12:43:27 +0100
> Michael Niedermayer <michael@niedermayer.cc> wrote:
> 
> > On Sun, Dec 24, 2017 at 02:31:16AM +0100, wm4 wrote:
> > > On Sun, 24 Dec 2017 02:06:40 +0100
> > > Michael Niedermayer <michael@niedermayer.cc> wrote:
[...]
> > 
> > > - also, we would have to provide stable/public API for implementing
> > >   codecs in the first place (all AVCodec callback fields are private),
> > >   and we're nowhere near the state of adding it  
> > 
> > I would love to see such a API and i would certainly contribute but
> 
> > as explained above, we dont have it and we dont really need it for
> > registering user codec to be usefull in practice IMO
> 
> Are you seriously arguing for API users to access internal API?

no. iam not arguing that anyone who has the choice should use internal
API. 


[...]

> 
> > There are more usecases. For example codec optimizations for niche
> > codecs where rejected on ffmpeg-devel.
> > I find it unfriendly from us if we reject improvments because they
> > arent in a area most of us care and then also drop the possibility
> > for externally maintaining and registering code without doing a
> > full fork (which is much more work to maintain)
> 
> What? We accept tons of obscure features and optimizations.
> 
> The only thing I remember that got consistently rejected were the HEVC
> optimizations - not because we didn't want them, but because they used
> intrinsics in x86 (instead of external asm), which we reject on
> principle. We (apparently) had bad experiences with them in the past,
> compiler support tends to be flaky, and performance of the generated
> code can depend much on used compiler and is not very predictable. You
> know very well that we have a policy to reject intrinsics and that we
> follow it for good reasons.
> 
> I'm not sure why you feel the need to distort the facts that much just
> to make some sort of passive aggressive sounding point about general
> dev/project practices.

What is distorted ?

The case i was thinking of and refered to should be this thread:
"[FFmpeg-devel] [PATCH] Cinepak: speed up decoding several-fold, depending on the scenario, by supporting multiple output pixel formats."
The patch was as i said rejected
It was about a niche codec (cinepak)
It was an optimization as stated.
The rest of my statment was just what i find unfriendly, that is just
my oppinon.

Maybe that sounds "passive aggressive" i dont know, but then any self critique
could likely sound "passive aggressive" to someone


> 
> > >   
> > > > > +AVCodec *av_codec_next(const AVCodec *c)
> > > > > +{
> > > > > +    pthread_once(&av_codec_next_init, av_codec_init_next);
> > > > > +
> > > > > +    if (c)
> > > > > +        return c->next;    
> > > > 
> > > > AVCodec->next should be removed as it makes the structs non constant  
> > > 
> > > That has to happen after a deprecation phase, unless you have an idea
> > > how to make av_codec_next() not O(n^2) without this.  
> > 
> > That can be done and there are many ways. Not saying we want to do it
> > first possibility, one can add a int "constant" to each AVCodec.
> > configure would have to choose these or there would be holes in the array.
> 
> That sounds complicated, how would configure modify each AVCodec struct
> (which are spread into hundreds of source files)?

It would generate a header with a list, enum or #define
the named identifers of that list would be used in the individual files


> 
> > a hashtable with a mutex is an option too but that seems not worth the
> > complexity / work
> > the 3rd obvious option is to make "next" a pointer to a int which is
> > initialized in each codec to some static int. Which can then be set
> > to the array index, the main struct can then remain in read only memory
> > iam pretty sure there are many more options
> 
> Not sure how these are better than just initializing the next pointer
> for now, until deprecation removes it.

It would allow the AVCodec to be in read only memory, not a major thing
at all, but thats one of the main advantages of removing the next pointer

[...]
diff mbox

Patch

From 1d84641556eea563b82b17a6ffe54226e0e31c4e Mon Sep 17 00:00:00 2001
From: Josh de Kock <josh@itanimul.li>
Date: Fri, 22 Dec 2017 22:17:00 +0000
Subject: [PATCH] lavc: add new API for iterating codecs and codec parsers

Also replace linked list with an array.
---
 configure              |   14 +-
 libavcodec/allcodecs.c | 1472 ++++++++++++++++++++++++++++--------------------
 libavcodec/avcodec.h   |   25 +
 libavcodec/parser.c    |   86 ++-
 libavcodec/utils.c     |  105 ----
 5 files changed, 962 insertions(+), 740 deletions(-)

diff --git a/configure b/configure
index d09eec4..681fe10 100755
--- a/configure
+++ b/configure
@@ -3517,9 +3517,6 @@  find_things(){
     sed -n "s/^[^#]*$pattern.*([^,]*, *\([^,]*\)\(,.*\)*).*/\1_$thing/p" "$file"
 }
 
-ENCODER_LIST=$(find_things  encoder  ENC      libavcodec/allcodecs.c)
-DECODER_LIST=$(find_things  decoder  DEC      libavcodec/allcodecs.c)
-PARSER_LIST=$(find_things   parser   PARSER   libavcodec/allcodecs.c)
 MUXER_LIST=$(find_things    muxer    _MUX     libavformat/allformats.c)
 DEMUXER_LIST=$(find_things  demuxer  DEMUX    libavformat/allformats.c)
 OUTDEV_LIST=$(find_things   outdev   OUTDEV   libavdevice/alldevices.c)
@@ -3533,6 +3530,13 @@  find_things_extern(){
     sed -n "s/^[^#]*extern.*$pattern *ff_\([^ ]*\)_$thing;/\1_$thing/p" "$file"
 }
 
+ENCODER_LIST=$(find_things_extern encoder AVCodec libavcodec/allcodecs.c)
+DECODER_LIST=$(find_things_extern decoder AVCodec libavcodec/allcodecs.c)
+CODEC_LIST="
+    $ENCODER_LIST
+    $DECODER_LIST
+"
+PARSER_LIST=$(find_things_extern parser AVCodecParser libavcodec/parser.c)
 BSF_LIST=$(find_things_extern bsf AVBitStreamFilter libavcodec/bitstream_filters.c)
 HWACCEL_LIST=$(find_things_extern hwaccel AVHWAccel libavcodec/hwaccels.h)
 PROTOCOL_LIST=$(find_things_extern protocol URLProtocol libavformat/protocols.c)
@@ -7020,6 +7024,10 @@  print_enabled_components(){
     cp_if_changed $TMPH $file
 }
 
+print_enabled_components libavcodec/codec_list.c AVCodec codec_list $CODEC_LIST
+#print_enabled_components libavcodec/encoder_list.c AVCodec encoder_list $ENCODER_LIST
+#print_enabled_components libavcodec/decoder_list.c AVCodec decoder_list $DECODER_LIST
+print_enabled_components libavcodec/parser_list.c AVCodecParser parser_list $PARSER_LIST
 print_enabled_components libavcodec/bsf_list.c AVBitStreamFilter bitstream_filters $BSF_LIST
 print_enabled_components libavformat/protocol_list.c URLProtocol url_protocols $PROTOCOL_LIST
 
diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c
index ed1e7ab..cea2bf3 100644
--- a/libavcodec/allcodecs.c
+++ b/libavcodec/allcodecs.c
@@ -29,641 +29,865 @@ 
 #include "avcodec.h"
 #include "version.h"
 
-#define REGISTER_ENCODER(X, x)                                          \
-    {                                                                   \
-        extern AVCodec ff_##x##_encoder;                                \
-        if (CONFIG_##X##_ENCODER)                                       \
-            avcodec_register(&ff_##x##_encoder);                        \
+extern AVCodec ff_a64multi_encoder;
+extern AVCodec ff_a64multi5_encoder;
+extern AVCodec ff_aasc_decoder;
+extern AVCodec ff_aic_decoder;
+extern AVCodec ff_alias_pix_encoder;
+extern AVCodec ff_alias_pix_decoder;
+extern AVCodec ff_amv_encoder;
+extern AVCodec ff_amv_decoder;
+extern AVCodec ff_anm_decoder;
+extern AVCodec ff_ansi_decoder;
+extern AVCodec ff_apng_encoder;
+extern AVCodec ff_apng_decoder;
+extern AVCodec ff_asv1_encoder;
+extern AVCodec ff_asv1_decoder;
+extern AVCodec ff_asv2_encoder;
+extern AVCodec ff_asv2_decoder;
+extern AVCodec ff_aura_decoder;
+extern AVCodec ff_aura2_decoder;
+extern AVCodec ff_avrp_encoder;
+extern AVCodec ff_avrp_decoder;
+extern AVCodec ff_avrn_decoder;
+extern AVCodec ff_avs_decoder;
+extern AVCodec ff_avui_encoder;
+extern AVCodec ff_avui_decoder;
+extern AVCodec ff_ayuv_encoder;
+extern AVCodec ff_ayuv_decoder;
+extern AVCodec ff_bethsoftvid_decoder;
+extern AVCodec ff_bfi_decoder;
+extern AVCodec ff_bink_decoder;
+extern AVCodec ff_bmp_encoder;
+extern AVCodec ff_bmp_decoder;
+extern AVCodec ff_bmv_video_decoder;
+extern AVCodec ff_brender_pix_decoder;
+extern AVCodec ff_c93_decoder;
+extern AVCodec ff_cavs_decoder;
+extern AVCodec ff_cdgraphics_decoder;
+extern AVCodec ff_cdxl_decoder;
+extern AVCodec ff_cfhd_decoder;
+extern AVCodec ff_cinepak_encoder;
+extern AVCodec ff_cinepak_decoder;
+extern AVCodec ff_clearvideo_decoder;
+extern AVCodec ff_cljr_encoder;
+extern AVCodec ff_cljr_decoder;
+extern AVCodec ff_cllc_decoder;
+extern AVCodec ff_comfortnoise_encoder;
+extern AVCodec ff_comfortnoise_decoder;
+extern AVCodec ff_cpia_decoder;
+extern AVCodec ff_cscd_decoder;
+extern AVCodec ff_cyuv_decoder;
+extern AVCodec ff_dds_decoder;
+extern AVCodec ff_dfa_decoder;
+extern AVCodec ff_dirac_decoder;
+extern AVCodec ff_dnxhd_encoder;
+extern AVCodec ff_dnxhd_decoder;
+extern AVCodec ff_dpx_encoder;
+extern AVCodec ff_dpx_decoder;
+extern AVCodec ff_dsicinvideo_decoder;
+extern AVCodec ff_dvaudio_decoder;
+extern AVCodec ff_dvvideo_encoder;
+extern AVCodec ff_dvvideo_decoder;
+extern AVCodec ff_dxa_decoder;
+extern AVCodec ff_dxtory_decoder;
+extern AVCodec ff_dxv_decoder;
+extern AVCodec ff_eacmv_decoder;
+extern AVCodec ff_eamad_decoder;
+extern AVCodec ff_eatgq_decoder;
+extern AVCodec ff_eatgv_decoder;
+extern AVCodec ff_eatqi_decoder;
+extern AVCodec ff_eightbps_decoder;
+extern AVCodec ff_eightsvx_exp_decoder;
+extern AVCodec ff_eightsvx_fib_decoder;
+extern AVCodec ff_escape124_decoder;
+extern AVCodec ff_escape130_decoder;
+extern AVCodec ff_exr_decoder;
+extern AVCodec ff_ffv1_encoder;
+extern AVCodec ff_ffv1_decoder;
+extern AVCodec ff_ffvhuff_encoder;
+extern AVCodec ff_ffvhuff_decoder;
+extern AVCodec ff_fic_decoder;
+extern AVCodec ff_fits_encoder;
+extern AVCodec ff_fits_decoder;
+extern AVCodec ff_flashsv_encoder;
+extern AVCodec ff_flashsv_decoder;
+extern AVCodec ff_flashsv2_encoder;
+extern AVCodec ff_flashsv2_decoder;
+extern AVCodec ff_flic_decoder;
+extern AVCodec ff_flv_encoder;
+extern AVCodec ff_flv_decoder;
+extern AVCodec ff_fmvc_decoder;
+extern AVCodec ff_fourxm_decoder;
+extern AVCodec ff_fraps_decoder;
+extern AVCodec ff_frwu_decoder;
+extern AVCodec ff_g2m_decoder;
+extern AVCodec ff_gdv_decoder;
+extern AVCodec ff_gif_encoder;
+extern AVCodec ff_gif_decoder;
+extern AVCodec ff_h261_encoder;
+extern AVCodec ff_h261_decoder;
+extern AVCodec ff_h263_encoder;
+extern AVCodec ff_h263_decoder;
+extern AVCodec ff_h263i_decoder;
+extern AVCodec ff_h263p_encoder;
+extern AVCodec ff_h263p_decoder;
+extern AVCodec ff_h263_v4l2m2m_decoder;
+extern AVCodec ff_h264_decoder;
+extern AVCodec ff_h264_crystalhd_decoder;
+extern AVCodec ff_h264_v4l2m2m_decoder;
+extern AVCodec ff_h264_mediacodec_decoder;
+extern AVCodec ff_h264_mmal_decoder;
+extern AVCodec ff_h264_qsv_decoder;
+extern AVCodec ff_h264_rkmpp_decoder;
+extern AVCodec ff_hap_encoder;
+extern AVCodec ff_hap_decoder;
+extern AVCodec ff_hevc_decoder;
+extern AVCodec ff_hevc_qsv_decoder;
+extern AVCodec ff_hevc_rkmpp_decoder;
+extern AVCodec ff_hevc_v4l2m2m_decoder;
+extern AVCodec ff_hnm4_video_decoder;
+extern AVCodec ff_hq_hqa_decoder;
+extern AVCodec ff_hqx_decoder;
+extern AVCodec ff_huffyuv_encoder;
+extern AVCodec ff_huffyuv_decoder;
+extern AVCodec ff_idcin_decoder;
+extern AVCodec ff_iff_ilbm_decoder;
+extern AVCodec ff_indeo2_decoder;
+extern AVCodec ff_indeo3_decoder;
+extern AVCodec ff_indeo4_decoder;
+extern AVCodec ff_indeo5_decoder;
+extern AVCodec ff_interplay_video_decoder;
+extern AVCodec ff_jpeg2000_encoder;
+extern AVCodec ff_jpeg2000_decoder;
+extern AVCodec ff_jpegls_encoder;
+extern AVCodec ff_jpegls_decoder;
+extern AVCodec ff_jv_decoder;
+extern AVCodec ff_kgv1_decoder;
+extern AVCodec ff_kmvc_decoder;
+extern AVCodec ff_lagarith_decoder;
+extern AVCodec ff_ljpeg_encoder;
+extern AVCodec ff_loco_decoder;
+extern AVCodec ff_m101_decoder;
+extern AVCodec ff_magicyuv_encoder;
+extern AVCodec ff_magicyuv_decoder;
+extern AVCodec ff_mdec_decoder;
+extern AVCodec ff_mimic_decoder;
+extern AVCodec ff_mjpeg_encoder;
+extern AVCodec ff_mjpeg_decoder;
+extern AVCodec ff_mjpegb_decoder;
+extern AVCodec ff_mmvideo_decoder;
+extern AVCodec ff_motionpixels_decoder;
+extern AVCodec ff_mpeg1video_encoder;
+extern AVCodec ff_mpeg1video_decoder;
+extern AVCodec ff_mpeg2video_encoder;
+extern AVCodec ff_mpeg2video_decoder;
+extern AVCodec ff_mpeg4_encoder;
+extern AVCodec ff_mpeg4_decoder;
+extern AVCodec ff_mpeg4_crystalhd_decoder;
+extern AVCodec ff_mpeg4_v4l2m2m_decoder;
+extern AVCodec ff_mpeg4_mmal_decoder;
+extern AVCodec ff_mpegvideo_decoder;
+extern AVCodec ff_mpeg1_v4l2m2m_decoder;
+extern AVCodec ff_mpeg2_mmal_decoder;
+extern AVCodec ff_mpeg2_crystalhd_decoder;
+extern AVCodec ff_mpeg2_v4l2m2m_decoder;
+extern AVCodec ff_mpeg2_qsv_decoder;
+extern AVCodec ff_mpeg2_mediacodec_decoder;
+extern AVCodec ff_msa1_decoder;
+extern AVCodec ff_mscc_decoder;
+extern AVCodec ff_msmpeg4v1_decoder;
+extern AVCodec ff_msmpeg4v2_encoder;
+extern AVCodec ff_msmpeg4v2_decoder;
+extern AVCodec ff_msmpeg4v3_encoder;
+extern AVCodec ff_msmpeg4v3_decoder;
+extern AVCodec ff_msmpeg4_crystalhd_decoder;
+extern AVCodec ff_msrle_decoder;
+extern AVCodec ff_mss1_decoder;
+extern AVCodec ff_mss2_decoder;
+extern AVCodec ff_msvideo1_encoder;
+extern AVCodec ff_msvideo1_decoder;
+extern AVCodec ff_mszh_decoder;
+extern AVCodec ff_mts2_decoder;
+extern AVCodec ff_mvc1_decoder;
+extern AVCodec ff_mvc2_decoder;
+extern AVCodec ff_mxpeg_decoder;
+extern AVCodec ff_nuv_decoder;
+extern AVCodec ff_paf_video_decoder;
+extern AVCodec ff_pam_encoder;
+extern AVCodec ff_pam_decoder;
+extern AVCodec ff_pbm_encoder;
+extern AVCodec ff_pbm_decoder;
+extern AVCodec ff_pcx_encoder;
+extern AVCodec ff_pcx_decoder;
+extern AVCodec ff_pgm_encoder;
+extern AVCodec ff_pgm_decoder;
+extern AVCodec ff_pgmyuv_encoder;
+extern AVCodec ff_pgmyuv_decoder;
+extern AVCodec ff_pictor_decoder;
+extern AVCodec ff_pixlet_decoder;
+extern AVCodec ff_png_encoder;
+extern AVCodec ff_png_decoder;
+extern AVCodec ff_ppm_encoder;
+extern AVCodec ff_ppm_decoder;
+extern AVCodec ff_prores_encoder;
+extern AVCodec ff_prores_decoder;
+extern AVCodec ff_prores_aw_encoder;
+extern AVCodec ff_prores_ks_encoder;
+extern AVCodec ff_prores_lgpl_decoder;
+extern AVCodec ff_psd_decoder;
+extern AVCodec ff_ptx_decoder;
+extern AVCodec ff_qdraw_decoder;
+extern AVCodec ff_qpeg_decoder;
+extern AVCodec ff_qtrle_encoder;
+extern AVCodec ff_qtrle_decoder;
+extern AVCodec ff_r10k_encoder;
+extern AVCodec ff_r10k_decoder;
+extern AVCodec ff_r210_encoder;
+extern AVCodec ff_r210_decoder;
+extern AVCodec ff_rawvideo_encoder;
+extern AVCodec ff_rawvideo_decoder;
+extern AVCodec ff_rl2_decoder;
+extern AVCodec ff_roq_encoder;
+extern AVCodec ff_roq_decoder;
+extern AVCodec ff_rpza_decoder;
+extern AVCodec ff_rscc_decoder;
+extern AVCodec ff_rv10_encoder;
+extern AVCodec ff_rv10_decoder;
+extern AVCodec ff_rv20_encoder;
+extern AVCodec ff_rv20_decoder;
+extern AVCodec ff_rv30_decoder;
+extern AVCodec ff_rv40_decoder;
+extern AVCodec ff_s302m_encoder;
+extern AVCodec ff_s302m_decoder;
+extern AVCodec ff_sanm_decoder;
+extern AVCodec ff_scpr_decoder;
+extern AVCodec ff_screenpresso_decoder;
+extern AVCodec ff_sdx2_dpcm_decoder;
+extern AVCodec ff_sgi_encoder;
+extern AVCodec ff_sgi_decoder;
+extern AVCodec ff_sgirle_decoder;
+extern AVCodec ff_sheervideo_decoder;
+extern AVCodec ff_smacker_decoder;
+extern AVCodec ff_smc_decoder;
+extern AVCodec ff_smvjpeg_decoder;
+extern AVCodec ff_snow_encoder;
+extern AVCodec ff_snow_decoder;
+extern AVCodec ff_sp5x_decoder;
+extern AVCodec ff_speedhq_decoder;
+extern AVCodec ff_srgc_decoder;
+extern AVCodec ff_sunrast_encoder;
+extern AVCodec ff_sunrast_decoder;
+extern AVCodec ff_svq1_encoder;
+extern AVCodec ff_svq1_decoder;
+extern AVCodec ff_svq3_decoder;
+extern AVCodec ff_targa_encoder;
+extern AVCodec ff_targa_decoder;
+extern AVCodec ff_targa_y216_decoder;
+extern AVCodec ff_tdsc_decoder;
+extern AVCodec ff_theora_decoder;
+extern AVCodec ff_thp_decoder;
+extern AVCodec ff_tiertexseqvideo_decoder;
+extern AVCodec ff_tiff_encoder;
+extern AVCodec ff_tiff_decoder;
+extern AVCodec ff_tmv_decoder;
+extern AVCodec ff_truemotion1_decoder;
+extern AVCodec ff_truemotion2_decoder;
+extern AVCodec ff_truemotion2rt_decoder;
+extern AVCodec ff_tscc_decoder;
+extern AVCodec ff_tscc2_decoder;
+extern AVCodec ff_txd_decoder;
+extern AVCodec ff_ulti_decoder;
+extern AVCodec ff_utvideo_encoder;
+extern AVCodec ff_utvideo_decoder;
+extern AVCodec ff_v210_encoder;
+extern AVCodec ff_v210_decoder;
+extern AVCodec ff_v210x_decoder;
+extern AVCodec ff_v308_encoder;
+extern AVCodec ff_v308_decoder;
+extern AVCodec ff_v408_encoder;
+extern AVCodec ff_v408_decoder;
+extern AVCodec ff_v410_encoder;
+extern AVCodec ff_v410_decoder;
+extern AVCodec ff_vb_decoder;
+extern AVCodec ff_vble_decoder;
+extern AVCodec ff_vc1_decoder;
+extern AVCodec ff_vc1_crystalhd_decoder;
+extern AVCodec ff_vc1image_decoder;
+extern AVCodec ff_vc1_mmal_decoder;
+extern AVCodec ff_vc1_qsv_decoder;
+extern AVCodec ff_vc1_v4l2m2m_decoder;
+extern AVCodec ff_vc2_encoder;
+extern AVCodec ff_vcr1_decoder;
+extern AVCodec ff_vmdvideo_decoder;
+extern AVCodec ff_vmnc_decoder;
+extern AVCodec ff_vp3_decoder;
+extern AVCodec ff_vp5_decoder;
+extern AVCodec ff_vp6_decoder;
+extern AVCodec ff_vp6a_decoder;
+extern AVCodec ff_vp6f_decoder;
+extern AVCodec ff_vp7_decoder;
+extern AVCodec ff_vp8_decoder;
+extern AVCodec ff_vp8_rkmpp_decoder;
+extern AVCodec ff_vp8_v4l2m2m_decoder;
+extern AVCodec ff_vp9_decoder;
+extern AVCodec ff_vp9_rkmpp_decoder;
+extern AVCodec ff_vp9_v4l2m2m_decoder;
+extern AVCodec ff_vqa_decoder;
+extern AVCodec ff_bitpacked_decoder;
+extern AVCodec ff_webp_decoder;
+extern AVCodec ff_wrapped_avframe_encoder;
+extern AVCodec ff_wrapped_avframe_decoder;
+extern AVCodec ff_wmv1_encoder;
+extern AVCodec ff_wmv1_decoder;
+extern AVCodec ff_wmv2_encoder;
+extern AVCodec ff_wmv2_decoder;
+extern AVCodec ff_wmv3_decoder;
+extern AVCodec ff_wmv3_crystalhd_decoder;
+extern AVCodec ff_wmv3image_decoder;
+extern AVCodec ff_wnv1_decoder;
+extern AVCodec ff_xan_wc3_decoder;
+extern AVCodec ff_xan_wc4_decoder;
+extern AVCodec ff_xbm_encoder;
+extern AVCodec ff_xbm_decoder;
+extern AVCodec ff_xface_encoder;
+extern AVCodec ff_xface_decoder;
+extern AVCodec ff_xl_decoder;
+extern AVCodec ff_xpm_decoder;
+extern AVCodec ff_xwd_encoder;
+extern AVCodec ff_xwd_decoder;
+extern AVCodec ff_y41p_encoder;
+extern AVCodec ff_y41p_decoder;
+extern AVCodec ff_ylc_decoder;
+extern AVCodec ff_yop_decoder;
+extern AVCodec ff_yuv4_encoder;
+extern AVCodec ff_yuv4_decoder;
+extern AVCodec ff_zero12v_decoder;
+extern AVCodec ff_zerocodec_decoder;
+extern AVCodec ff_zlib_encoder;
+extern AVCodec ff_zlib_decoder;
+extern AVCodec ff_zmbv_encoder;
+extern AVCodec ff_zmbv_decoder;
+
+/* audio codecs */
+extern AVCodec ff_aac_encoder;
+extern AVCodec ff_aac_decoder;
+extern AVCodec ff_aac_fixed_decoder;
+extern AVCodec ff_aac_latm_decoder;
+extern AVCodec ff_ac3_encoder;
+extern AVCodec ff_ac3_decoder;
+extern AVCodec ff_ac3_fixed_encoder;
+extern AVCodec ff_ac3_fixed_decoder;
+extern AVCodec ff_alac_encoder;
+extern AVCodec ff_alac_decoder;
+extern AVCodec ff_als_decoder;
+extern AVCodec ff_amrnb_decoder;
+extern AVCodec ff_amrwb_decoder;
+extern AVCodec ff_ape_decoder;
+extern AVCodec ff_aptx_encoder;
+extern AVCodec ff_aptx_decoder;
+extern AVCodec ff_atrac1_decoder;
+extern AVCodec ff_atrac3_decoder;
+extern AVCodec ff_atrac3al_decoder;
+extern AVCodec ff_atrac3p_decoder;
+extern AVCodec ff_atrac3pal_decoder;
+extern AVCodec ff_binkaudio_dct_decoder;
+extern AVCodec ff_binkaudio_rdft_decoder;
+extern AVCodec ff_bmv_audio_decoder;
+extern AVCodec ff_cook_decoder;
+extern AVCodec ff_dca_encoder;
+extern AVCodec ff_dca_decoder;
+extern AVCodec ff_dolby_e_decoder;
+extern AVCodec ff_dsd_lsbf_decoder;
+extern AVCodec ff_dsd_msbf_decoder;
+extern AVCodec ff_dsd_lsbf_planar_decoder;
+extern AVCodec ff_dsd_msbf_planar_decoder;
+extern AVCodec ff_dsicinaudio_decoder;
+extern AVCodec ff_dss_sp_decoder;
+extern AVCodec ff_dst_decoder;
+extern AVCodec ff_eac3_encoder;
+extern AVCodec ff_eac3_decoder;
+extern AVCodec ff_evrc_decoder;
+extern AVCodec ff_ffwavesynth_decoder;
+extern AVCodec ff_flac_encoder;
+extern AVCodec ff_flac_decoder;
+extern AVCodec ff_g723_1_encoder;
+extern AVCodec ff_g723_1_decoder;
+extern AVCodec ff_g729_decoder;
+extern AVCodec ff_gsm_decoder;
+extern AVCodec ff_gsm_ms_decoder;
+extern AVCodec ff_iac_decoder;
+extern AVCodec ff_imc_decoder;
+extern AVCodec ff_interplay_acm_decoder;
+extern AVCodec ff_mace3_decoder;
+extern AVCodec ff_mace6_decoder;
+extern AVCodec ff_metasound_decoder;
+extern AVCodec ff_mlp_encoder;
+extern AVCodec ff_mlp_decoder;
+extern AVCodec ff_mp1_decoder;
+extern AVCodec ff_mp1float_decoder;
+extern AVCodec ff_mp2_encoder;
+extern AVCodec ff_mp2_decoder;
+extern AVCodec ff_mp2float_decoder;
+extern AVCodec ff_mp2fixed_encoder;
+extern AVCodec ff_mp3_decoder;
+extern AVCodec ff_mp3float_decoder;
+extern AVCodec ff_mp3adu_decoder;
+extern AVCodec ff_mp3adufloat_decoder;
+extern AVCodec ff_mp3on4_decoder;
+extern AVCodec ff_mp3on4float_decoder;
+extern AVCodec ff_mpc7_decoder;
+extern AVCodec ff_mpc8_decoder;
+extern AVCodec ff_nellymoser_encoder;
+extern AVCodec ff_nellymoser_decoder;
+extern AVCodec ff_on2avc_decoder;
+extern AVCodec ff_opus_encoder;
+extern AVCodec ff_opus_decoder;
+extern AVCodec ff_paf_audio_decoder;
+extern AVCodec ff_qcelp_decoder;
+extern AVCodec ff_qdm2_decoder;
+extern AVCodec ff_qdmc_decoder;
+extern AVCodec ff_ra_144_encoder;
+extern AVCodec ff_ra_144_decoder;
+extern AVCodec ff_ra_288_decoder;
+extern AVCodec ff_ralf_decoder;
+extern AVCodec ff_shorten_decoder;
+extern AVCodec ff_sipr_decoder;
+extern AVCodec ff_smackaud_decoder;
+extern AVCodec ff_sonic_encoder;
+extern AVCodec ff_sonic_decoder;
+extern AVCodec ff_sonic_ls_encoder;
+extern AVCodec ff_tak_decoder;
+extern AVCodec ff_truehd_encoder;
+extern AVCodec ff_truehd_decoder;
+extern AVCodec ff_truespeech_decoder;
+extern AVCodec ff_tta_encoder;
+extern AVCodec ff_tta_decoder;
+extern AVCodec ff_twinvq_decoder;
+extern AVCodec ff_vmdaudio_decoder;
+extern AVCodec ff_vorbis_encoder;
+extern AVCodec ff_vorbis_decoder;
+extern AVCodec ff_wavpack_encoder;
+extern AVCodec ff_wavpack_decoder;
+extern AVCodec ff_wmalossless_decoder;
+extern AVCodec ff_wmapro_decoder;
+extern AVCodec ff_wmav1_encoder;
+extern AVCodec ff_wmav1_decoder;
+extern AVCodec ff_wmav2_encoder;
+extern AVCodec ff_wmav2_decoder;
+extern AVCodec ff_wmavoice_decoder;
+extern AVCodec ff_ws_snd1_decoder;
+extern AVCodec ff_xma1_decoder;
+extern AVCodec ff_xma2_decoder;
+
+/* PCM codecs */
+extern AVCodec ff_pcm_alaw_encoder;
+extern AVCodec ff_pcm_alaw_decoder;
+extern AVCodec ff_pcm_bluray_decoder;
+extern AVCodec ff_pcm_dvd_decoder;
+extern AVCodec ff_pcm_f16le_decoder;
+extern AVCodec ff_pcm_f24le_decoder;
+extern AVCodec ff_pcm_f32be_encoder;
+extern AVCodec ff_pcm_f32be_decoder;
+extern AVCodec ff_pcm_f32le_encoder;
+extern AVCodec ff_pcm_f32le_decoder;
+extern AVCodec ff_pcm_f64be_encoder;
+extern AVCodec ff_pcm_f64be_decoder;
+extern AVCodec ff_pcm_f64le_encoder;
+extern AVCodec ff_pcm_f64le_decoder;
+extern AVCodec ff_pcm_lxf_decoder;
+extern AVCodec ff_pcm_mulaw_encoder;
+extern AVCodec ff_pcm_mulaw_decoder;
+extern AVCodec ff_pcm_s8_encoder;
+extern AVCodec ff_pcm_s8_decoder;
+extern AVCodec ff_pcm_s8_planar_encoder;
+extern AVCodec ff_pcm_s8_planar_decoder;
+extern AVCodec ff_pcm_s16be_encoder;
+extern AVCodec ff_pcm_s16be_decoder;
+extern AVCodec ff_pcm_s16be_planar_encoder;
+extern AVCodec ff_pcm_s16be_planar_decoder;
+extern AVCodec ff_pcm_s16le_encoder;
+extern AVCodec ff_pcm_s16le_decoder;
+extern AVCodec ff_pcm_s16le_planar_encoder;
+extern AVCodec ff_pcm_s16le_planar_decoder;
+extern AVCodec ff_pcm_s24be_encoder;
+extern AVCodec ff_pcm_s24be_decoder;
+extern AVCodec ff_pcm_s24daud_encoder;
+extern AVCodec ff_pcm_s24daud_decoder;
+extern AVCodec ff_pcm_s24le_encoder;
+extern AVCodec ff_pcm_s24le_decoder;
+extern AVCodec ff_pcm_s24le_planar_encoder;
+extern AVCodec ff_pcm_s24le_planar_decoder;
+extern AVCodec ff_pcm_s32be_encoder;
+extern AVCodec ff_pcm_s32be_decoder;
+extern AVCodec ff_pcm_s32le_encoder;
+extern AVCodec ff_pcm_s32le_decoder;
+extern AVCodec ff_pcm_s32le_planar_encoder;
+extern AVCodec ff_pcm_s32le_planar_decoder;
+extern AVCodec ff_pcm_s64be_encoder;
+extern AVCodec ff_pcm_s64be_decoder;
+extern AVCodec ff_pcm_s64le_encoder;
+extern AVCodec ff_pcm_s64le_decoder;
+extern AVCodec ff_pcm_u8_encoder;
+extern AVCodec ff_pcm_u8_decoder;
+extern AVCodec ff_pcm_u16be_encoder;
+extern AVCodec ff_pcm_u16be_decoder;
+extern AVCodec ff_pcm_u16le_encoder;
+extern AVCodec ff_pcm_u16le_decoder;
+extern AVCodec ff_pcm_u24be_encoder;
+extern AVCodec ff_pcm_u24be_decoder;
+extern AVCodec ff_pcm_u24le_encoder;
+extern AVCodec ff_pcm_u24le_decoder;
+extern AVCodec ff_pcm_u32be_encoder;
+extern AVCodec ff_pcm_u32be_decoder;
+extern AVCodec ff_pcm_u32le_encoder;
+extern AVCodec ff_pcm_u32le_decoder;
+extern AVCodec ff_pcm_zork_decoder;
+
+/* DPCM codecs */
+extern AVCodec ff_gremlin_dpcm_decoder;
+extern AVCodec ff_interplay_dpcm_decoder;
+extern AVCodec ff_roq_dpcm_encoder;
+extern AVCodec ff_roq_dpcm_decoder;
+extern AVCodec ff_sol_dpcm_decoder;
+extern AVCodec ff_xan_dpcm_decoder;
+
+/* ADPCM codecs */
+extern AVCodec ff_adpcm_4xm_decoder;
+extern AVCodec ff_adpcm_adx_encoder;
+extern AVCodec ff_adpcm_adx_decoder;
+extern AVCodec ff_adpcm_afc_decoder;
+extern AVCodec ff_adpcm_aica_decoder;
+extern AVCodec ff_adpcm_ct_decoder;
+extern AVCodec ff_adpcm_dtk_decoder;
+extern AVCodec ff_adpcm_ea_decoder;
+extern AVCodec ff_adpcm_ea_maxis_xa_decoder;
+extern AVCodec ff_adpcm_ea_r1_decoder;
+extern AVCodec ff_adpcm_ea_r2_decoder;
+extern AVCodec ff_adpcm_ea_r3_decoder;
+extern AVCodec ff_adpcm_ea_xas_decoder;
+extern AVCodec ff_adpcm_g722_encoder;
+extern AVCodec ff_adpcm_g722_decoder;
+extern AVCodec ff_adpcm_g726_encoder;
+extern AVCodec ff_adpcm_g726_decoder;
+extern AVCodec ff_adpcm_g726le_encoder;
+extern AVCodec ff_adpcm_g726le_decoder;
+extern AVCodec ff_adpcm_ima_amv_decoder;
+extern AVCodec ff_adpcm_ima_apc_decoder;
+extern AVCodec ff_adpcm_ima_dat4_decoder;
+extern AVCodec ff_adpcm_ima_dk3_decoder;
+extern AVCodec ff_adpcm_ima_dk4_decoder;
+extern AVCodec ff_adpcm_ima_ea_eacs_decoder;
+extern AVCodec ff_adpcm_ima_ea_sead_decoder;
+extern AVCodec ff_adpcm_ima_iss_decoder;
+extern AVCodec ff_adpcm_ima_oki_decoder;
+extern AVCodec ff_adpcm_ima_qt_encoder;
+extern AVCodec ff_adpcm_ima_qt_decoder;
+extern AVCodec ff_adpcm_ima_rad_decoder;
+extern AVCodec ff_adpcm_ima_smjpeg_decoder;
+extern AVCodec ff_adpcm_ima_wav_encoder;
+extern AVCodec ff_adpcm_ima_wav_decoder;
+extern AVCodec ff_adpcm_ima_ws_decoder;
+extern AVCodec ff_adpcm_ms_encoder;
+extern AVCodec ff_adpcm_ms_decoder;
+extern AVCodec ff_adpcm_mtaf_decoder;
+extern AVCodec ff_adpcm_psx_decoder;
+extern AVCodec ff_adpcm_sbpro_2_decoder;
+extern AVCodec ff_adpcm_sbpro_3_decoder;
+extern AVCodec ff_adpcm_sbpro_4_decoder;
+extern AVCodec ff_adpcm_swf_encoder;
+extern AVCodec ff_adpcm_swf_decoder;
+extern AVCodec ff_adpcm_thp_decoder;
+extern AVCodec ff_adpcm_thp_le_decoder;
+extern AVCodec ff_adpcm_vima_decoder;
+extern AVCodec ff_adpcm_xa_decoder;
+extern AVCodec ff_adpcm_yamaha_encoder;
+extern AVCodec ff_adpcm_yamaha_decoder;
+
+/* subtitles */
+extern AVCodec ff_ssa_encoder;
+extern AVCodec ff_ssa_decoder;
+extern AVCodec ff_ass_encoder;
+extern AVCodec ff_ass_decoder;
+extern AVCodec ff_ccaption_decoder;
+extern AVCodec ff_dvbsub_encoder;
+extern AVCodec ff_dvbsub_decoder;
+extern AVCodec ff_dvdsub_encoder;
+extern AVCodec ff_dvdsub_decoder;
+extern AVCodec ff_jacosub_decoder;
+extern AVCodec ff_microdvd_decoder;
+extern AVCodec ff_movtext_encoder;
+extern AVCodec ff_movtext_decoder;
+extern AVCodec ff_mpl2_decoder;
+extern AVCodec ff_pgssub_decoder;
+extern AVCodec ff_pjs_decoder;
+extern AVCodec ff_realtext_decoder;
+extern AVCodec ff_sami_decoder;
+extern AVCodec ff_srt_encoder;
+extern AVCodec ff_srt_decoder;
+extern AVCodec ff_stl_decoder;
+extern AVCodec ff_subrip_encoder;
+extern AVCodec ff_subrip_decoder;
+extern AVCodec ff_subviewer_decoder;
+extern AVCodec ff_subviewer1_decoder;
+extern AVCodec ff_text_encoder;
+extern AVCodec ff_text_decoder;
+extern AVCodec ff_vplayer_decoder;
+extern AVCodec ff_webvtt_encoder;
+extern AVCodec ff_webvtt_decoder;
+extern AVCodec ff_xsub_encoder;
+extern AVCodec ff_xsub_decoder;
+
+/* external libraries */
+extern AVCodec ff_aac_at_encoder;
+extern AVCodec ff_aac_at_decoder;
+extern AVCodec ff_ac3_at_decoder;
+extern AVCodec ff_adpcm_ima_qt_at_decoder;
+extern AVCodec ff_alac_at_encoder;
+extern AVCodec ff_alac_at_decoder;
+extern AVCodec ff_amr_nb_at_decoder;
+extern AVCodec ff_eac3_at_decoder;
+extern AVCodec ff_gsm_ms_at_decoder;
+extern AVCodec ff_ilbc_at_encoder;
+extern AVCodec ff_ilbc_at_decoder;
+extern AVCodec ff_mp1_at_decoder;
+extern AVCodec ff_mp2_at_decoder;
+extern AVCodec ff_mp3_at_decoder;
+extern AVCodec ff_pcm_alaw_at_encoder;
+extern AVCodec ff_pcm_alaw_at_decoder;
+extern AVCodec ff_pcm_mulaw_at_encoder;
+extern AVCodec ff_pcm_mulaw_at_decoder;
+extern AVCodec ff_qdmc_at_decoder;
+extern AVCodec ff_qdm2_at_decoder;
+extern AVCodec ff_libcelt_decoder;
+extern AVCodec ff_libfdk_aac_encoder;
+extern AVCodec ff_libfdk_aac_decoder;
+extern AVCodec ff_libgsm_encoder;
+extern AVCodec ff_libgsm_decoder;
+extern AVCodec ff_libgsm_ms_encoder;
+extern AVCodec ff_libgsm_ms_decoder;
+extern AVCodec ff_libilbc_encoder;
+extern AVCodec ff_libilbc_decoder;
+extern AVCodec ff_libmp3lame_encoder;
+extern AVCodec ff_libopencore_amrnb_encoder;
+extern AVCodec ff_libopencore_amrnb_decoder;
+extern AVCodec ff_libopencore_amrwb_decoder;
+extern AVCodec ff_libopenjpeg_encoder;
+extern AVCodec ff_libopenjpeg_decoder;
+extern AVCodec ff_libopus_encoder;
+extern AVCodec ff_libopus_decoder;
+extern AVCodec ff_librsvg_decoder;
+extern AVCodec ff_libshine_encoder;
+extern AVCodec ff_libspeex_encoder;
+extern AVCodec ff_libspeex_decoder;
+extern AVCodec ff_libtheora_encoder;
+extern AVCodec ff_libtwolame_encoder;
+extern AVCodec ff_libvo_amrwbenc_encoder;
+extern AVCodec ff_libvorbis_encoder;
+extern AVCodec ff_libvorbis_decoder;
+extern AVCodec ff_libvpx_vp8_encoder;
+extern AVCodec ff_libvpx_vp8_decoder;
+extern AVCodec ff_libvpx_vp9_encoder;
+extern AVCodec ff_libvpx_vp9_decoder;
+extern AVCodec ff_libwavpack_encoder;
+/* preferred over libwebp */
+extern AVCodec ff_libwebp_anim_encoder;
+extern AVCodec ff_libwebp_encoder;
+extern AVCodec ff_libx262_encoder;
+extern AVCodec ff_libx264_encoder;
+extern AVCodec ff_libx264rgb_encoder;
+extern AVCodec ff_libx265_encoder;
+extern AVCodec ff_libxavs_encoder;
+extern AVCodec ff_libxvid_encoder;
+extern AVCodec ff_libzvbi_teletext_decoder;
+
+/* text */
+extern AVCodec ff_bintext_decoder;
+extern AVCodec ff_xbin_decoder;
+extern AVCodec ff_idf_decoder;
+
+/* external libraries, that shouldn't be used by default if one of the
+ * above is available */
+extern AVCodec ff_h263_v4l2m2m_encoder;
+extern AVCodec ff_libopenh264_encoder;
+extern AVCodec ff_libopenh264_decoder;
+extern AVCodec ff_h264_amf_encoder;
+extern AVCodec ff_h264_cuvid_decoder;
+extern AVCodec ff_h264_nvenc_encoder;
+extern AVCodec ff_h264_omx_encoder;
+extern AVCodec ff_h264_qsv_encoder;
+extern AVCodec ff_h264_v4l2m2m_encoder;
+extern AVCodec ff_h264_vaapi_encoder;
+extern AVCodec ff_h264_videotoolbox_encoder;
+#if FF_API_NVENC_OLD_NAME
+extern AVCodec ff_nvenc_encoder;
+extern AVCodec ff_nvenc_h264_encoder;
+extern AVCodec ff_nvenc_hevc_encoder;
+#endif
+extern AVCodec ff_hevc_amf_encoder;
+extern AVCodec ff_hevc_cuvid_decoder;
+extern AVCodec ff_hevc_mediacodec_decoder;
+extern AVCodec ff_hevc_nvenc_encoder;
+extern AVCodec ff_hevc_qsv_encoder;
+extern AVCodec ff_hevc_v4l2m2m_encoder;
+extern AVCodec ff_hevc_vaapi_encoder;
+extern AVCodec ff_hevc_videotoolbox_encoder;
+extern AVCodec ff_libkvazaar_encoder;
+extern AVCodec ff_mjpeg_cuvid_decoder;
+extern AVCodec ff_mjpeg_qsv_encoder;
+extern AVCodec ff_mjpeg_vaapi_encoder;
+extern AVCodec ff_mpeg1_cuvid_decoder;
+extern AVCodec ff_mpeg2_cuvid_decoder;
+extern AVCodec ff_mpeg2_qsv_encoder;
+extern AVCodec ff_mpeg2_vaapi_encoder;
+extern AVCodec ff_mpeg4_cuvid_decoder;
+extern AVCodec ff_mpeg4_mediacodec_decoder;
+extern AVCodec ff_mpeg4_v4l2m2m_encoder;
+extern AVCodec ff_vc1_cuvid_decoder;
+extern AVCodec ff_vp8_cuvid_decoder;
+extern AVCodec ff_vp8_mediacodec_decoder;
+extern AVCodec ff_vp8_qsv_decoder;
+extern AVCodec ff_vp8_v4l2m2m_encoder;
+extern AVCodec ff_vp8_vaapi_encoder;
+extern AVCodec ff_vp9_cuvid_decoder;
+extern AVCodec ff_vp9_mediacodec_decoder;
+extern AVCodec ff_vp9_vaapi_encoder;
+
+#include "codec_list.c"
+
+#if CONFIG_ME_CMP
+#include "me_cmp.h"
+pthread_once_t ff_me_cmp_static_init = PTHREAD_ONCE_INIT;
+#endif
+
+pthread_once_t av_codec_next_init = PTHREAD_ONCE_INIT;
+
+const AVCodec *av_codec_iterate(void **opaque)
+{
+    uintptr_t i = (uintptr_t)*opaque;
+    const AVCodec *c = codec_list[i];
+
+    if (c)
+        *opaque = (void*)(i + 1);
+
+    return c;
+}
+
+static void av_codec_init_next(void)
+{
+    AVCodec *prev = NULL, *p;
+    void *i = 0;
+    while ((p = (AVCodec*)av_codec_iterate(&i))) {
+        if (prev)
+            prev->next = p;
+        prev = p;
     }
+    prev->next = NULL;
+}
 
-#define REGISTER_DECODER(X, x)                                          \
-    {                                                                   \
-        extern AVCodec ff_##x##_decoder;                                \
-        if (CONFIG_##X##_DECODER)                                       \
-            avcodec_register(&ff_##x##_decoder);                        \
+av_cold void avcodec_register(AVCodec *codec)
+{
+#if CONFIG_ME_CMP
+    pthread_once(&ff_me_cmp_static_init, ff_me_cmp_init_static);
+#endif
+
+    pthread_once(&av_codec_next_init, av_codec_init_next);
+    
+    if (codec->init_static_data)
+        codec->init_static_data(codec);
+}
+
+AVCodec *av_codec_next(const AVCodec *c)
+{
+    pthread_once(&av_codec_next_init, av_codec_init_next);
+
+    if (c)
+        return c->next;
+    else
+        return (AVCodec*)codec_list[0];
+}
+
+static enum AVCodecID remap_deprecated_codec_id(enum AVCodecID id)
+{
+    switch(id){
+        //This is for future deprecatec codec ids, its empty since
+        //last major bump but will fill up again over time, please don't remove it
+        default                                         : return id;
     }
+}
+
+static AVCodec *find_codec(enum AVCodecID id, int (*x)(const AVCodec *))
+{
+    const AVCodec *p, *experimental = NULL;
+    void *i = 0;
 
-#define REGISTER_ENCDEC(X, x) REGISTER_ENCODER(X, x); REGISTER_DECODER(X, x)
+    id = remap_deprecated_codec_id(id);
 
-#define REGISTER_PARSER(X, x)                                           \
-    {                                                                   \
-        extern AVCodecParser ff_##x##_parser;                           \
-        if (CONFIG_##X##_PARSER)                                        \
-            av_register_codec_parser(&ff_##x##_parser);                 \
+    while ((p = av_codec_iterate(&i))) {
+        if (!x(p))
+            continue;
+        if (p->id == id) {
+            if (p->capabilities & AV_CODEC_CAP_EXPERIMENTAL && !experimental) {
+                experimental = p;
+            } else
+                return (AVCodec*)p;
+        }
     }
 
-static void register_all(void)
+    return (AVCodec*)experimental;
+}
+
+AVCodec *avcodec_find_encoder(enum AVCodecID id)
 {
-    /* video codecs */
-    REGISTER_ENCODER(A64MULTI,          a64multi);
-    REGISTER_ENCODER(A64MULTI5,         a64multi5);
-    REGISTER_DECODER(AASC,              aasc);
-    REGISTER_DECODER(AIC,               aic);
-    REGISTER_ENCDEC (ALIAS_PIX,         alias_pix);
-    REGISTER_ENCDEC (AMV,               amv);
-    REGISTER_DECODER(ANM,               anm);
-    REGISTER_DECODER(ANSI,              ansi);
-    REGISTER_ENCDEC (APNG,              apng);
-    REGISTER_ENCDEC (ASV1,              asv1);
-    REGISTER_ENCDEC (ASV2,              asv2);
-    REGISTER_DECODER(AURA,              aura);
-    REGISTER_DECODER(AURA2,             aura2);
-    REGISTER_ENCDEC (AVRP,              avrp);
-    REGISTER_DECODER(AVRN,              avrn);
-    REGISTER_DECODER(AVS,               avs);
-    REGISTER_ENCDEC (AVUI,              avui);
-    REGISTER_ENCDEC (AYUV,              ayuv);
-    REGISTER_DECODER(BETHSOFTVID,       bethsoftvid);
-    REGISTER_DECODER(BFI,               bfi);
-    REGISTER_DECODER(BINK,              bink);
-    REGISTER_ENCDEC (BMP,               bmp);
-    REGISTER_DECODER(BMV_VIDEO,         bmv_video);
-    REGISTER_DECODER(BRENDER_PIX,       brender_pix);
-    REGISTER_DECODER(C93,               c93);
-    REGISTER_DECODER(CAVS,              cavs);
-    REGISTER_DECODER(CDGRAPHICS,        cdgraphics);
-    REGISTER_DECODER(CDXL,              cdxl);
-    REGISTER_DECODER(CFHD,              cfhd);
-    REGISTER_ENCDEC (CINEPAK,           cinepak);
-    REGISTER_DECODER(CLEARVIDEO,        clearvideo);
-    REGISTER_ENCDEC (CLJR,              cljr);
-    REGISTER_DECODER(CLLC,              cllc);
-    REGISTER_ENCDEC (COMFORTNOISE,      comfortnoise);
-    REGISTER_DECODER(CPIA,              cpia);
-    REGISTER_DECODER(CSCD,              cscd);
-    REGISTER_DECODER(CYUV,              cyuv);
-    REGISTER_DECODER(DDS,               dds);
-    REGISTER_DECODER(DFA,               dfa);
-    REGISTER_DECODER(DIRAC,             dirac);
-    REGISTER_ENCDEC (DNXHD,             dnxhd);
-    REGISTER_ENCDEC (DPX,               dpx);
-    REGISTER_DECODER(DSICINVIDEO,       dsicinvideo);
-    REGISTER_DECODER(DVAUDIO,           dvaudio);
-    REGISTER_ENCDEC (DVVIDEO,           dvvideo);
-    REGISTER_DECODER(DXA,               dxa);
-    REGISTER_DECODER(DXTORY,            dxtory);
-    REGISTER_DECODER(DXV,               dxv);
-    REGISTER_DECODER(EACMV,             eacmv);
-    REGISTER_DECODER(EAMAD,             eamad);
-    REGISTER_DECODER(EATGQ,             eatgq);
-    REGISTER_DECODER(EATGV,             eatgv);
-    REGISTER_DECODER(EATQI,             eatqi);
-    REGISTER_DECODER(EIGHTBPS,          eightbps);
-    REGISTER_DECODER(EIGHTSVX_EXP,      eightsvx_exp);
-    REGISTER_DECODER(EIGHTSVX_FIB,      eightsvx_fib);
-    REGISTER_DECODER(ESCAPE124,         escape124);
-    REGISTER_DECODER(ESCAPE130,         escape130);
-    REGISTER_DECODER(EXR,               exr);
-    REGISTER_ENCDEC (FFV1,              ffv1);
-    REGISTER_ENCDEC (FFVHUFF,           ffvhuff);
-    REGISTER_DECODER(FIC,               fic);
-    REGISTER_ENCDEC (FITS,              fits);
-    REGISTER_ENCDEC (FLASHSV,           flashsv);
-    REGISTER_ENCDEC (FLASHSV2,          flashsv2);
-    REGISTER_DECODER(FLIC,              flic);
-    REGISTER_ENCDEC (FLV,               flv);
-    REGISTER_DECODER(FMVC,              fmvc);
-    REGISTER_DECODER(FOURXM,            fourxm);
-    REGISTER_DECODER(FRAPS,             fraps);
-    REGISTER_DECODER(FRWU,              frwu);
-    REGISTER_DECODER(G2M,               g2m);
-    REGISTER_DECODER(GDV,               gdv);
-    REGISTER_ENCDEC (GIF,               gif);
-    REGISTER_ENCDEC (H261,              h261);
-    REGISTER_ENCDEC (H263,              h263);
-    REGISTER_DECODER(H263I,             h263i);
-    REGISTER_ENCDEC (H263P,             h263p);
-    REGISTER_DECODER(H263_V4L2M2M,      h263_v4l2m2m);
-    REGISTER_DECODER(H264,              h264);
-    REGISTER_DECODER(H264_CRYSTALHD,    h264_crystalhd);
-    REGISTER_DECODER(H264_V4L2M2M,      h264_v4l2m2m);
-    REGISTER_DECODER(H264_MEDIACODEC,   h264_mediacodec);
-    REGISTER_DECODER(H264_MMAL,         h264_mmal);
-    REGISTER_DECODER(H264_QSV,          h264_qsv);
-    REGISTER_DECODER(H264_RKMPP,        h264_rkmpp);
-    REGISTER_ENCDEC (HAP,               hap);
-    REGISTER_DECODER(HEVC,              hevc);
-    REGISTER_DECODER(HEVC_QSV,          hevc_qsv);
-    REGISTER_DECODER(HEVC_RKMPP,        hevc_rkmpp);
-    REGISTER_DECODER(HEVC_V4L2M2M,      hevc_v4l2m2m);
-    REGISTER_DECODER(HNM4_VIDEO,        hnm4_video);
-    REGISTER_DECODER(HQ_HQA,            hq_hqa);
-    REGISTER_DECODER(HQX,               hqx);
-    REGISTER_ENCDEC (HUFFYUV,           huffyuv);
-    REGISTER_DECODER(IDCIN,             idcin);
-    REGISTER_DECODER(IFF_ILBM,          iff_ilbm);
-    REGISTER_DECODER(INDEO2,            indeo2);
-    REGISTER_DECODER(INDEO3,            indeo3);
-    REGISTER_DECODER(INDEO4,            indeo4);
-    REGISTER_DECODER(INDEO5,            indeo5);
-    REGISTER_DECODER(INTERPLAY_VIDEO,   interplay_video);
-    REGISTER_ENCDEC (JPEG2000,          jpeg2000);
-    REGISTER_ENCDEC (JPEGLS,            jpegls);
-    REGISTER_DECODER(JV,                jv);
-    REGISTER_DECODER(KGV1,              kgv1);
-    REGISTER_DECODER(KMVC,              kmvc);
-    REGISTER_DECODER(LAGARITH,          lagarith);
-    REGISTER_ENCODER(LJPEG,             ljpeg);
-    REGISTER_DECODER(LOCO,              loco);
-    REGISTER_DECODER(M101,              m101);
-    REGISTER_ENCDEC (MAGICYUV,          magicyuv);
-    REGISTER_DECODER(MDEC,              mdec);
-    REGISTER_DECODER(MIMIC,             mimic);
-    REGISTER_ENCDEC (MJPEG,             mjpeg);
-    REGISTER_DECODER(MJPEGB,            mjpegb);
-    REGISTER_DECODER(MMVIDEO,           mmvideo);
-    REGISTER_DECODER(MOTIONPIXELS,      motionpixels);
-    REGISTER_ENCDEC (MPEG1VIDEO,        mpeg1video);
-    REGISTER_ENCDEC (MPEG2VIDEO,        mpeg2video);
-    REGISTER_ENCDEC (MPEG4,             mpeg4);
-    REGISTER_DECODER(MPEG4_CRYSTALHD,   mpeg4_crystalhd);
-    REGISTER_DECODER(MPEG4_V4L2M2M,     mpeg4_v4l2m2m);
-    REGISTER_DECODER(MPEG4_MMAL,        mpeg4_mmal);
-    REGISTER_DECODER(MPEGVIDEO,         mpegvideo);
-    REGISTER_DECODER(MPEG1_V4L2M2M,     mpeg1_v4l2m2m);
-    REGISTER_DECODER(MPEG2_MMAL,        mpeg2_mmal);
-    REGISTER_DECODER(MPEG2_CRYSTALHD,   mpeg2_crystalhd);
-    REGISTER_DECODER(MPEG2_V4L2M2M,     mpeg2_v4l2m2m);
-    REGISTER_DECODER(MPEG2_QSV,         mpeg2_qsv);
-    REGISTER_DECODER(MPEG2_MEDIACODEC,  mpeg2_mediacodec);
-    REGISTER_DECODER(MSA1,              msa1);
-    REGISTER_DECODER(MSCC,              mscc);
-    REGISTER_DECODER(MSMPEG4V1,         msmpeg4v1);
-    REGISTER_ENCDEC (MSMPEG4V2,         msmpeg4v2);
-    REGISTER_ENCDEC (MSMPEG4V3,         msmpeg4v3);
-    REGISTER_DECODER(MSMPEG4_CRYSTALHD, msmpeg4_crystalhd);
-    REGISTER_DECODER(MSRLE,             msrle);
-    REGISTER_DECODER(MSS1,              mss1);
-    REGISTER_DECODER(MSS2,              mss2);
-    REGISTER_ENCDEC (MSVIDEO1,          msvideo1);
-    REGISTER_DECODER(MSZH,              mszh);
-    REGISTER_DECODER(MTS2,              mts2);
-    REGISTER_DECODER(MVC1,              mvc1);
-    REGISTER_DECODER(MVC2,              mvc2);
-    REGISTER_DECODER(MXPEG,             mxpeg);
-    REGISTER_DECODER(NUV,               nuv);
-    REGISTER_DECODER(PAF_VIDEO,         paf_video);
-    REGISTER_ENCDEC (PAM,               pam);
-    REGISTER_ENCDEC (PBM,               pbm);
-    REGISTER_ENCDEC (PCX,               pcx);
-    REGISTER_ENCDEC (PGM,               pgm);
-    REGISTER_ENCDEC (PGMYUV,            pgmyuv);
-    REGISTER_DECODER(PICTOR,            pictor);
-    REGISTER_DECODER(PIXLET,            pixlet);
-    REGISTER_ENCDEC (PNG,               png);
-    REGISTER_ENCDEC (PPM,               ppm);
-    REGISTER_ENCDEC (PRORES,            prores);
-    REGISTER_ENCODER(PRORES_AW,         prores_aw);
-    REGISTER_ENCODER(PRORES_KS,         prores_ks);
-    REGISTER_DECODER(PRORES_LGPL,       prores_lgpl);
-    REGISTER_DECODER(PSD,               psd);
-    REGISTER_DECODER(PTX,               ptx);
-    REGISTER_DECODER(QDRAW,             qdraw);
-    REGISTER_DECODER(QPEG,              qpeg);
-    REGISTER_ENCDEC (QTRLE,             qtrle);
-    REGISTER_ENCDEC (R10K,              r10k);
-    REGISTER_ENCDEC (R210,              r210);
-    REGISTER_ENCDEC (RAWVIDEO,          rawvideo);
-    REGISTER_DECODER(RL2,               rl2);
-    REGISTER_ENCDEC (ROQ,               roq);
-    REGISTER_DECODER(RPZA,              rpza);
-    REGISTER_DECODER(RSCC,              rscc);
-    REGISTER_ENCDEC (RV10,              rv10);
-    REGISTER_ENCDEC (RV20,              rv20);
-    REGISTER_DECODER(RV30,              rv30);
-    REGISTER_DECODER(RV40,              rv40);
-    REGISTER_ENCDEC (S302M,             s302m);
-    REGISTER_DECODER(SANM,              sanm);
-    REGISTER_DECODER(SCPR,              scpr);
-    REGISTER_DECODER(SCREENPRESSO,      screenpresso);
-    REGISTER_DECODER(SDX2_DPCM,         sdx2_dpcm);
-    REGISTER_ENCDEC (SGI,               sgi);
-    REGISTER_DECODER(SGIRLE,            sgirle);
-    REGISTER_DECODER(SHEERVIDEO,        sheervideo);
-    REGISTER_DECODER(SMACKER,           smacker);
-    REGISTER_DECODER(SMC,               smc);
-    REGISTER_DECODER(SMVJPEG,           smvjpeg);
-    REGISTER_ENCDEC (SNOW,              snow);
-    REGISTER_DECODER(SP5X,              sp5x);
-    REGISTER_DECODER(SPEEDHQ,           speedhq);
-    REGISTER_DECODER(SRGC,              srgc);
-    REGISTER_ENCDEC (SUNRAST,           sunrast);
-    REGISTER_ENCDEC (SVQ1,              svq1);
-    REGISTER_DECODER(SVQ3,              svq3);
-    REGISTER_ENCDEC (TARGA,             targa);
-    REGISTER_DECODER(TARGA_Y216,        targa_y216);
-    REGISTER_DECODER(TDSC,              tdsc);
-    REGISTER_DECODER(THEORA,            theora);
-    REGISTER_DECODER(THP,               thp);
-    REGISTER_DECODER(TIERTEXSEQVIDEO,   tiertexseqvideo);
-    REGISTER_ENCDEC (TIFF,              tiff);
-    REGISTER_DECODER(TMV,               tmv);
-    REGISTER_DECODER(TRUEMOTION1,       truemotion1);
-    REGISTER_DECODER(TRUEMOTION2,       truemotion2);
-    REGISTER_DECODER(TRUEMOTION2RT,     truemotion2rt);
-    REGISTER_DECODER(TSCC,              tscc);
-    REGISTER_DECODER(TSCC2,             tscc2);
-    REGISTER_DECODER(TXD,               txd);
-    REGISTER_DECODER(ULTI,              ulti);
-    REGISTER_ENCDEC (UTVIDEO,           utvideo);
-    REGISTER_ENCDEC (V210,              v210);
-    REGISTER_DECODER(V210X,             v210x);
-    REGISTER_ENCDEC (V308,              v308);
-    REGISTER_ENCDEC (V408,              v408);
-    REGISTER_ENCDEC (V410,              v410);
-    REGISTER_DECODER(VB,                vb);
-    REGISTER_DECODER(VBLE,              vble);
-    REGISTER_DECODER(VC1,               vc1);
-    REGISTER_DECODER(VC1_CRYSTALHD,     vc1_crystalhd);
-    REGISTER_DECODER(VC1IMAGE,          vc1image);
-    REGISTER_DECODER(VC1_MMAL,          vc1_mmal);
-    REGISTER_DECODER(VC1_QSV,           vc1_qsv);
-    REGISTER_DECODER(VC1_V4L2M2M,       vc1_v4l2m2m);
-    REGISTER_ENCODER(VC2,               vc2);
-    REGISTER_DECODER(VCR1,              vcr1);
-    REGISTER_DECODER(VMDVIDEO,          vmdvideo);
-    REGISTER_DECODER(VMNC,              vmnc);
-    REGISTER_DECODER(VP3,               vp3);
-    REGISTER_DECODER(VP5,               vp5);
-    REGISTER_DECODER(VP6,               vp6);
-    REGISTER_DECODER(VP6A,              vp6a);
-    REGISTER_DECODER(VP6F,              vp6f);
-    REGISTER_DECODER(VP7,               vp7);
-    REGISTER_DECODER(VP8,               vp8);
-    REGISTER_DECODER(VP8_RKMPP,         vp8_rkmpp);
-    REGISTER_DECODER(VP8_V4L2M2M,       vp8_v4l2m2m);
-    REGISTER_DECODER(VP9,               vp9);
-    REGISTER_DECODER(VP9_RKMPP,         vp9_rkmpp);
-    REGISTER_DECODER(VP9_V4L2M2M,       vp9_v4l2m2m);
-    REGISTER_DECODER(VQA,               vqa);
-    REGISTER_DECODER(BITPACKED,         bitpacked);
-    REGISTER_DECODER(WEBP,              webp);
-    REGISTER_ENCDEC (WRAPPED_AVFRAME,   wrapped_avframe);
-    REGISTER_ENCDEC (WMV1,              wmv1);
-    REGISTER_ENCDEC (WMV2,              wmv2);
-    REGISTER_DECODER(WMV3,              wmv3);
-    REGISTER_DECODER(WMV3_CRYSTALHD,    wmv3_crystalhd);
-    REGISTER_DECODER(WMV3IMAGE,         wmv3image);
-    REGISTER_DECODER(WNV1,              wnv1);
-    REGISTER_DECODER(XAN_WC3,           xan_wc3);
-    REGISTER_DECODER(XAN_WC4,           xan_wc4);
-    REGISTER_ENCDEC (XBM,               xbm);
-    REGISTER_ENCDEC (XFACE,             xface);
-    REGISTER_DECODER(XL,                xl);
-    REGISTER_DECODER(XPM,               xpm);
-    REGISTER_ENCDEC (XWD,               xwd);
-    REGISTER_ENCDEC (Y41P,              y41p);
-    REGISTER_DECODER(YLC,               ylc);
-    REGISTER_DECODER(YOP,               yop);
-    REGISTER_ENCDEC (YUV4,              yuv4);
-    REGISTER_DECODER(ZERO12V,           zero12v);
-    REGISTER_DECODER(ZEROCODEC,         zerocodec);
-    REGISTER_ENCDEC (ZLIB,              zlib);
-    REGISTER_ENCDEC (ZMBV,              zmbv);
-
-    /* audio codecs */
-    REGISTER_ENCDEC (AAC,               aac);
-    REGISTER_DECODER(AAC_FIXED,         aac_fixed);
-    REGISTER_DECODER(AAC_LATM,          aac_latm);
-    REGISTER_ENCDEC (AC3,               ac3);
-    REGISTER_ENCDEC (AC3_FIXED,         ac3_fixed);
-    REGISTER_ENCDEC (ALAC,              alac);
-    REGISTER_DECODER(ALS,               als);
-    REGISTER_DECODER(AMRNB,             amrnb);
-    REGISTER_DECODER(AMRWB,             amrwb);
-    REGISTER_DECODER(APE,               ape);
-    REGISTER_ENCDEC (APTX,              aptx);
-    REGISTER_DECODER(ATRAC1,            atrac1);
-    REGISTER_DECODER(ATRAC3,            atrac3);
-    REGISTER_DECODER(ATRAC3AL,          atrac3al);
-    REGISTER_DECODER(ATRAC3P,           atrac3p);
-    REGISTER_DECODER(ATRAC3PAL,         atrac3pal);
-    REGISTER_DECODER(BINKAUDIO_DCT,     binkaudio_dct);
-    REGISTER_DECODER(BINKAUDIO_RDFT,    binkaudio_rdft);
-    REGISTER_DECODER(BMV_AUDIO,         bmv_audio);
-    REGISTER_DECODER(COOK,              cook);
-    REGISTER_ENCDEC (DCA,               dca);
-    REGISTER_DECODER(DOLBY_E,           dolby_e);
-    REGISTER_DECODER(DSD_LSBF,          dsd_lsbf);
-    REGISTER_DECODER(DSD_MSBF,          dsd_msbf);
-    REGISTER_DECODER(DSD_LSBF_PLANAR,   dsd_lsbf_planar);
-    REGISTER_DECODER(DSD_MSBF_PLANAR,   dsd_msbf_planar);
-    REGISTER_DECODER(DSICINAUDIO,       dsicinaudio);
-    REGISTER_DECODER(DSS_SP,            dss_sp);
-    REGISTER_DECODER(DST,               dst);
-    REGISTER_ENCDEC (EAC3,              eac3);
-    REGISTER_DECODER(EVRC,              evrc);
-    REGISTER_DECODER(FFWAVESYNTH,       ffwavesynth);
-    REGISTER_ENCDEC (FLAC,              flac);
-    REGISTER_ENCDEC (G723_1,            g723_1);
-    REGISTER_DECODER(G729,              g729);
-    REGISTER_DECODER(GSM,               gsm);
-    REGISTER_DECODER(GSM_MS,            gsm_ms);
-    REGISTER_DECODER(IAC,               iac);
-    REGISTER_DECODER(IMC,               imc);
-    REGISTER_DECODER(INTERPLAY_ACM,     interplay_acm);
-    REGISTER_DECODER(MACE3,             mace3);
-    REGISTER_DECODER(MACE6,             mace6);
-    REGISTER_DECODER(METASOUND,         metasound);
-    REGISTER_ENCDEC (MLP,               mlp);
-    REGISTER_DECODER(MP1,               mp1);
-    REGISTER_DECODER(MP1FLOAT,          mp1float);
-    REGISTER_ENCDEC (MP2,               mp2);
-    REGISTER_DECODER(MP2FLOAT,          mp2float);
-    REGISTER_ENCODER(MP2FIXED,          mp2fixed);
-    REGISTER_DECODER(MP3,               mp3);
-    REGISTER_DECODER(MP3FLOAT,          mp3float);
-    REGISTER_DECODER(MP3ADU,            mp3adu);
-    REGISTER_DECODER(MP3ADUFLOAT,       mp3adufloat);
-    REGISTER_DECODER(MP3ON4,            mp3on4);
-    REGISTER_DECODER(MP3ON4FLOAT,       mp3on4float);
-    REGISTER_DECODER(MPC7,              mpc7);
-    REGISTER_DECODER(MPC8,              mpc8);
-    REGISTER_ENCDEC (NELLYMOSER,        nellymoser);
-    REGISTER_DECODER(ON2AVC,            on2avc);
-    REGISTER_ENCDEC (OPUS,              opus);
-    REGISTER_DECODER(PAF_AUDIO,         paf_audio);
-    REGISTER_DECODER(QCELP,             qcelp);
-    REGISTER_DECODER(QDM2,              qdm2);
-    REGISTER_DECODER(QDMC,              qdmc);
-    REGISTER_ENCDEC (RA_144,            ra_144);
-    REGISTER_DECODER(RA_288,            ra_288);
-    REGISTER_DECODER(RALF,              ralf);
-    REGISTER_DECODER(SHORTEN,           shorten);
-    REGISTER_DECODER(SIPR,              sipr);
-    REGISTER_DECODER(SMACKAUD,          smackaud);
-    REGISTER_ENCDEC (SONIC,             sonic);
-    REGISTER_ENCODER(SONIC_LS,          sonic_ls);
-    REGISTER_DECODER(TAK,               tak);
-    REGISTER_ENCDEC (TRUEHD,            truehd);
-    REGISTER_DECODER(TRUESPEECH,        truespeech);
-    REGISTER_ENCDEC (TTA,               tta);
-    REGISTER_DECODER(TWINVQ,            twinvq);
-    REGISTER_DECODER(VMDAUDIO,          vmdaudio);
-    REGISTER_ENCDEC (VORBIS,            vorbis);
-    REGISTER_ENCDEC (WAVPACK,           wavpack);
-    REGISTER_DECODER(WMALOSSLESS,       wmalossless);
-    REGISTER_DECODER(WMAPRO,            wmapro);
-    REGISTER_ENCDEC (WMAV1,             wmav1);
-    REGISTER_ENCDEC (WMAV2,             wmav2);
-    REGISTER_DECODER(WMAVOICE,          wmavoice);
-    REGISTER_DECODER(WS_SND1,           ws_snd1);
-    REGISTER_DECODER(XMA1,              xma1);
-    REGISTER_DECODER(XMA2,              xma2);
-
-    /* PCM codecs */
-    REGISTER_ENCDEC (PCM_ALAW,          pcm_alaw);
-    REGISTER_DECODER(PCM_BLURAY,        pcm_bluray);
-    REGISTER_DECODER(PCM_DVD,           pcm_dvd);
-    REGISTER_DECODER(PCM_F16LE,         pcm_f16le);
-    REGISTER_DECODER(PCM_F24LE,         pcm_f24le);
-    REGISTER_ENCDEC (PCM_F32BE,         pcm_f32be);
-    REGISTER_ENCDEC (PCM_F32LE,         pcm_f32le);
-    REGISTER_ENCDEC (PCM_F64BE,         pcm_f64be);
-    REGISTER_ENCDEC (PCM_F64LE,         pcm_f64le);
-    REGISTER_DECODER(PCM_LXF,           pcm_lxf);
-    REGISTER_ENCDEC (PCM_MULAW,         pcm_mulaw);
-    REGISTER_ENCDEC (PCM_S8,            pcm_s8);
-    REGISTER_ENCDEC (PCM_S8_PLANAR,     pcm_s8_planar);
-    REGISTER_ENCDEC (PCM_S16BE,         pcm_s16be);
-    REGISTER_ENCDEC (PCM_S16BE_PLANAR,  pcm_s16be_planar);
-    REGISTER_ENCDEC (PCM_S16LE,         pcm_s16le);
-    REGISTER_ENCDEC (PCM_S16LE_PLANAR,  pcm_s16le_planar);
-    REGISTER_ENCDEC (PCM_S24BE,         pcm_s24be);
-    REGISTER_ENCDEC (PCM_S24DAUD,       pcm_s24daud);
-    REGISTER_ENCDEC (PCM_S24LE,         pcm_s24le);
-    REGISTER_ENCDEC (PCM_S24LE_PLANAR,  pcm_s24le_planar);
-    REGISTER_ENCDEC (PCM_S32BE,         pcm_s32be);
-    REGISTER_ENCDEC (PCM_S32LE,         pcm_s32le);
-    REGISTER_ENCDEC (PCM_S32LE_PLANAR,  pcm_s32le_planar);
-    REGISTER_ENCDEC (PCM_S64BE,         pcm_s64be);
-    REGISTER_ENCDEC (PCM_S64LE,         pcm_s64le);
-    REGISTER_ENCDEC (PCM_U8,            pcm_u8);
-    REGISTER_ENCDEC (PCM_U16BE,         pcm_u16be);
-    REGISTER_ENCDEC (PCM_U16LE,         pcm_u16le);
-    REGISTER_ENCDEC (PCM_U24BE,         pcm_u24be);
-    REGISTER_ENCDEC (PCM_U24LE,         pcm_u24le);
-    REGISTER_ENCDEC (PCM_U32BE,         pcm_u32be);
-    REGISTER_ENCDEC (PCM_U32LE,         pcm_u32le);
-    REGISTER_DECODER(PCM_ZORK,          pcm_zork);
-
-    /* DPCM codecs */
-    REGISTER_DECODER(GREMLIN_DPCM,      gremlin_dpcm);
-    REGISTER_DECODER(INTERPLAY_DPCM,    interplay_dpcm);
-    REGISTER_ENCDEC (ROQ_DPCM,          roq_dpcm);
-    REGISTER_DECODER(SOL_DPCM,          sol_dpcm);
-    REGISTER_DECODER(XAN_DPCM,          xan_dpcm);
-
-    /* ADPCM codecs */
-    REGISTER_DECODER(ADPCM_4XM,         adpcm_4xm);
-    REGISTER_ENCDEC (ADPCM_ADX,         adpcm_adx);
-    REGISTER_DECODER(ADPCM_AFC,         adpcm_afc);
-    REGISTER_DECODER(ADPCM_AICA,        adpcm_aica);
-    REGISTER_DECODER(ADPCM_CT,          adpcm_ct);
-    REGISTER_DECODER(ADPCM_DTK,         adpcm_dtk);
-    REGISTER_DECODER(ADPCM_EA,          adpcm_ea);
-    REGISTER_DECODER(ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa);
-    REGISTER_DECODER(ADPCM_EA_R1,       adpcm_ea_r1);
-    REGISTER_DECODER(ADPCM_EA_R2,       adpcm_ea_r2);
-    REGISTER_DECODER(ADPCM_EA_R3,       adpcm_ea_r3);
-    REGISTER_DECODER(ADPCM_EA_XAS,      adpcm_ea_xas);
-    REGISTER_ENCDEC (ADPCM_G722,        adpcm_g722);
-    REGISTER_ENCDEC (ADPCM_G726,        adpcm_g726);
-    REGISTER_ENCDEC (ADPCM_G726LE,      adpcm_g726le);
-    REGISTER_DECODER(ADPCM_IMA_AMV,     adpcm_ima_amv);
-    REGISTER_DECODER(ADPCM_IMA_APC,     adpcm_ima_apc);
-    REGISTER_DECODER(ADPCM_IMA_DAT4,    adpcm_ima_dat4);
-    REGISTER_DECODER(ADPCM_IMA_DK3,     adpcm_ima_dk3);
-    REGISTER_DECODER(ADPCM_IMA_DK4,     adpcm_ima_dk4);
-    REGISTER_DECODER(ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs);
-    REGISTER_DECODER(ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead);
-    REGISTER_DECODER(ADPCM_IMA_ISS,     adpcm_ima_iss);
-    REGISTER_DECODER(ADPCM_IMA_OKI,     adpcm_ima_oki);
-    REGISTER_ENCDEC (ADPCM_IMA_QT,      adpcm_ima_qt);
-    REGISTER_DECODER(ADPCM_IMA_RAD,     adpcm_ima_rad);
-    REGISTER_DECODER(ADPCM_IMA_SMJPEG,  adpcm_ima_smjpeg);
-    REGISTER_ENCDEC (ADPCM_IMA_WAV,     adpcm_ima_wav);
-    REGISTER_DECODER(ADPCM_IMA_WS,      adpcm_ima_ws);
-    REGISTER_ENCDEC (ADPCM_MS,          adpcm_ms);
-    REGISTER_DECODER(ADPCM_MTAF,        adpcm_mtaf);
-    REGISTER_DECODER(ADPCM_PSX,         adpcm_psx);
-    REGISTER_DECODER(ADPCM_SBPRO_2,     adpcm_sbpro_2);
-    REGISTER_DECODER(ADPCM_SBPRO_3,     adpcm_sbpro_3);
-    REGISTER_DECODER(ADPCM_SBPRO_4,     adpcm_sbpro_4);
-    REGISTER_ENCDEC (ADPCM_SWF,         adpcm_swf);
-    REGISTER_DECODER(ADPCM_THP,         adpcm_thp);
-    REGISTER_DECODER(ADPCM_THP_LE,      adpcm_thp_le);
-    REGISTER_DECODER(ADPCM_VIMA,        adpcm_vima);
-    REGISTER_DECODER(ADPCM_XA,          adpcm_xa);
-    REGISTER_ENCDEC (ADPCM_YAMAHA,      adpcm_yamaha);
-
-    /* subtitles */
-    REGISTER_ENCDEC (SSA,               ssa);
-    REGISTER_ENCDEC (ASS,               ass);
-    REGISTER_DECODER(CCAPTION,          ccaption);
-    REGISTER_ENCDEC (DVBSUB,            dvbsub);
-    REGISTER_ENCDEC (DVDSUB,            dvdsub);
-    REGISTER_DECODER(JACOSUB,           jacosub);
-    REGISTER_DECODER(MICRODVD,          microdvd);
-    REGISTER_ENCDEC (MOVTEXT,           movtext);
-    REGISTER_DECODER(MPL2,              mpl2);
-    REGISTER_DECODER(PGSSUB,            pgssub);
-    REGISTER_DECODER(PJS,               pjs);
-    REGISTER_DECODER(REALTEXT,          realtext);
-    REGISTER_DECODER(SAMI,              sami);
-    REGISTER_ENCDEC (SRT,               srt);
-    REGISTER_DECODER(STL,               stl);
-    REGISTER_ENCDEC (SUBRIP,            subrip);
-    REGISTER_DECODER(SUBVIEWER,         subviewer);
-    REGISTER_DECODER(SUBVIEWER1,        subviewer1);
-    REGISTER_ENCDEC (TEXT,              text);
-    REGISTER_DECODER(VPLAYER,           vplayer);
-    REGISTER_ENCDEC (WEBVTT,            webvtt);
-    REGISTER_ENCDEC (XSUB,              xsub);
-
-    /* external libraries */
-    REGISTER_ENCDEC (AAC_AT,            aac_at);
-    REGISTER_DECODER(AC3_AT,            ac3_at);
-    REGISTER_DECODER(ADPCM_IMA_QT_AT,   adpcm_ima_qt_at);
-    REGISTER_ENCDEC (ALAC_AT,           alac_at);
-    REGISTER_DECODER(AMR_NB_AT,         amr_nb_at);
-    REGISTER_DECODER(EAC3_AT,           eac3_at);
-    REGISTER_DECODER(GSM_MS_AT,         gsm_ms_at);
-    REGISTER_ENCDEC (ILBC_AT,           ilbc_at);
-    REGISTER_DECODER(MP1_AT,            mp1_at);
-    REGISTER_DECODER(MP2_AT,            mp2_at);
-    REGISTER_DECODER(MP3_AT,            mp3_at);
-    REGISTER_ENCDEC (PCM_ALAW_AT,       pcm_alaw_at);
-    REGISTER_ENCDEC (PCM_MULAW_AT,      pcm_mulaw_at);
-    REGISTER_DECODER(QDMC_AT,           qdmc_at);
-    REGISTER_DECODER(QDM2_AT,           qdm2_at);
-    REGISTER_DECODER(LIBCELT,           libcelt);
-    REGISTER_ENCDEC (LIBFDK_AAC,        libfdk_aac);
-    REGISTER_ENCDEC (LIBGSM,            libgsm);
-    REGISTER_ENCDEC (LIBGSM_MS,         libgsm_ms);
-    REGISTER_ENCDEC (LIBILBC,           libilbc);
-    REGISTER_ENCODER(LIBMP3LAME,        libmp3lame);
-    REGISTER_ENCDEC (LIBOPENCORE_AMRNB, libopencore_amrnb);
-    REGISTER_DECODER(LIBOPENCORE_AMRWB, libopencore_amrwb);
-    REGISTER_ENCDEC (LIBOPENJPEG,       libopenjpeg);
-    REGISTER_ENCDEC (LIBOPUS,           libopus);
-    REGISTER_DECODER(LIBRSVG,           librsvg);
-    REGISTER_ENCODER(LIBSHINE,          libshine);
-    REGISTER_ENCDEC (LIBSPEEX,          libspeex);
-    REGISTER_ENCODER(LIBTHEORA,         libtheora);
-    REGISTER_ENCODER(LIBTWOLAME,        libtwolame);
-    REGISTER_ENCODER(LIBVO_AMRWBENC,    libvo_amrwbenc);
-    REGISTER_ENCDEC (LIBVORBIS,         libvorbis);
-    REGISTER_ENCDEC (LIBVPX_VP8,        libvpx_vp8);
-    REGISTER_ENCDEC (LIBVPX_VP9,        libvpx_vp9);
-    REGISTER_ENCODER(LIBWAVPACK,        libwavpack);
-    REGISTER_ENCODER(LIBWEBP_ANIM,      libwebp_anim);  /* preferred over libwebp */
-    REGISTER_ENCODER(LIBWEBP,           libwebp);
-    REGISTER_ENCODER(LIBX262,           libx262);
-    REGISTER_ENCODER(LIBX264,           libx264);
-    REGISTER_ENCODER(LIBX264RGB,        libx264rgb);
-    REGISTER_ENCODER(LIBX265,           libx265);
-    REGISTER_ENCODER(LIBXAVS,           libxavs);
-    REGISTER_ENCODER(LIBXVID,           libxvid);
-    REGISTER_DECODER(LIBZVBI_TELETEXT,  libzvbi_teletext);
-
-    /* text */
-    REGISTER_DECODER(BINTEXT,           bintext);
-    REGISTER_DECODER(XBIN,              xbin);
-    REGISTER_DECODER(IDF,               idf);
-
-    /* external libraries, that shouldn't be used by default if one of the
-     * above is available */
-    REGISTER_ENCODER(H263_V4L2M2M,      h263_v4l2m2m);
-    REGISTER_ENCDEC (LIBOPENH264,       libopenh264);
-    REGISTER_ENCODER(H264_AMF,          h264_amf);
-    REGISTER_DECODER(H264_CUVID,        h264_cuvid);
-    REGISTER_ENCODER(H264_NVENC,        h264_nvenc);
-    REGISTER_ENCODER(H264_OMX,          h264_omx);
-    REGISTER_ENCODER(H264_QSV,          h264_qsv);
-    REGISTER_ENCODER(H264_V4L2M2M,      h264_v4l2m2m);
-    REGISTER_ENCODER(H264_VAAPI,        h264_vaapi);
-    REGISTER_ENCODER(H264_VIDEOTOOLBOX, h264_videotoolbox);
-#if FF_API_NVENC_OLD_NAME
-    REGISTER_ENCODER(NVENC,             nvenc);
-    REGISTER_ENCODER(NVENC_H264,        nvenc_h264);
-    REGISTER_ENCODER(NVENC_HEVC,        nvenc_hevc);
-#endif
-    REGISTER_ENCODER(HEVC_AMF,          hevc_amf);
-    REGISTER_DECODER(HEVC_CUVID,        hevc_cuvid);
-    REGISTER_DECODER(HEVC_MEDIACODEC,   hevc_mediacodec);
-    REGISTER_ENCODER(HEVC_NVENC,        hevc_nvenc);
-    REGISTER_ENCODER(HEVC_QSV,          hevc_qsv);
-    REGISTER_ENCODER(HEVC_V4L2M2M,      hevc_v4l2m2m);
-    REGISTER_ENCODER(HEVC_VAAPI,        hevc_vaapi);
-    REGISTER_ENCODER(HEVC_VIDEOTOOLBOX, hevc_videotoolbox);
-    REGISTER_ENCODER(LIBKVAZAAR,        libkvazaar);
-    REGISTER_DECODER(MJPEG_CUVID,       mjpeg_cuvid);
-    REGISTER_ENCODER(MJPEG_QSV,         mjpeg_qsv);
-    REGISTER_ENCODER(MJPEG_VAAPI,       mjpeg_vaapi);
-    REGISTER_DECODER(MPEG1_CUVID,       mpeg1_cuvid);
-    REGISTER_DECODER(MPEG2_CUVID,       mpeg2_cuvid);
-    REGISTER_ENCODER(MPEG2_QSV,         mpeg2_qsv);
-    REGISTER_ENCODER(MPEG2_VAAPI,       mpeg2_vaapi);
-    REGISTER_DECODER(MPEG4_CUVID,       mpeg4_cuvid);
-    REGISTER_DECODER(MPEG4_MEDIACODEC,  mpeg4_mediacodec);
-    REGISTER_ENCODER(MPEG4_V4L2M2M,     mpeg4_v4l2m2m);
-    REGISTER_DECODER(VC1_CUVID,         vc1_cuvid);
-    REGISTER_DECODER(VP8_CUVID,         vp8_cuvid);
-    REGISTER_DECODER(VP8_MEDIACODEC,    vp8_mediacodec);
-    REGISTER_DECODER(VP8_QSV,           vp8_qsv);
-    REGISTER_ENCODER(VP8_V4L2M2M,       vp8_v4l2m2m);
-    REGISTER_ENCODER(VP8_VAAPI,         vp8_vaapi);
-    REGISTER_DECODER(VP9_CUVID,         vp9_cuvid);
-    REGISTER_DECODER(VP9_MEDIACODEC,    vp9_mediacodec);
-    REGISTER_ENCODER(VP9_VAAPI,         vp9_vaapi);
-
-    /* parsers */
-    REGISTER_PARSER(AAC,                aac);
-    REGISTER_PARSER(AAC_LATM,           aac_latm);
-    REGISTER_PARSER(AC3,                ac3);
-    REGISTER_PARSER(ADX,                adx);
-    REGISTER_PARSER(BMP,                bmp);
-    REGISTER_PARSER(CAVSVIDEO,          cavsvideo);
-    REGISTER_PARSER(COOK,               cook);
-    REGISTER_PARSER(DCA,                dca);
-    REGISTER_PARSER(DIRAC,              dirac);
-    REGISTER_PARSER(DNXHD,              dnxhd);
-    REGISTER_PARSER(DPX,                dpx);
-    REGISTER_PARSER(DVAUDIO,            dvaudio);
-    REGISTER_PARSER(DVBSUB,             dvbsub);
-    REGISTER_PARSER(DVDSUB,             dvdsub);
-    REGISTER_PARSER(DVD_NAV,            dvd_nav);
-    REGISTER_PARSER(FLAC,               flac);
-    REGISTER_PARSER(G729,               g729);
-    REGISTER_PARSER(GSM,                gsm);
-    REGISTER_PARSER(H261,               h261);
-    REGISTER_PARSER(H263,               h263);
-    REGISTER_PARSER(H264,               h264);
-    REGISTER_PARSER(HEVC,               hevc);
-    REGISTER_PARSER(MJPEG,              mjpeg);
-    REGISTER_PARSER(MLP,                mlp);
-    REGISTER_PARSER(MPEG4VIDEO,         mpeg4video);
-    REGISTER_PARSER(MPEGAUDIO,          mpegaudio);
-    REGISTER_PARSER(MPEGVIDEO,          mpegvideo);
-    REGISTER_PARSER(OPUS,               opus);
-    REGISTER_PARSER(PNG,                png);
-    REGISTER_PARSER(PNM,                pnm);
-    REGISTER_PARSER(RV30,               rv30);
-    REGISTER_PARSER(RV40,               rv40);
-    REGISTER_PARSER(SIPR,               sipr);
-    REGISTER_PARSER(TAK,                tak);
-    REGISTER_PARSER(VC1,                vc1);
-    REGISTER_PARSER(VORBIS,             vorbis);
-    REGISTER_PARSER(VP3,                vp3);
-    REGISTER_PARSER(VP8,                vp8);
-    REGISTER_PARSER(VP9,                vp9);
-    REGISTER_PARSER(XMA,                xma);
+    return find_codec(id, av_codec_is_encoder);
+}
+
+AVCodec *avcodec_find_decoder(enum AVCodecID id)
+{
+    return find_codec(id, av_codec_is_decoder);
+}
+
+static AVCodec *find_codec_by_name(const char *name, int (*x)(const AVCodec *))
+{
+    void *i = 0;
+    const AVCodec *p;
+
+    if (!name)
+        return NULL;
+
+    while ((p = av_codec_iterate(&i))) {
+        if (!x(p))
+            continue;
+        if (strcmp(name, p->name) == 0)
+            return (AVCodec*)p;
+    }
+
+    return NULL;
+}
+
+AVCodec *avcodec_find_encoder_by_name(const char *name)
+{
+    return find_codec_by_name(name, av_codec_is_encoder);
+}
+
+AVCodec *avcodec_find_decoder_by_name(const char *name)
+{
+    return find_codec_by_name(name, av_codec_is_decoder);
 }
 
 void avcodec_register_all(void)
 {
-    static AVOnce control = AV_ONCE_INIT;
+	const AVCodec *codec;
+    void *i = 0;
 
-    ff_thread_once(&control, register_all);
+#if CONFIG_ME_CMP
+    pthread_once(&ff_me_cmp_static_init, ff_me_cmp_init_static);
+#endif
+
+    pthread_once(&av_codec_next_init, av_codec_init_next);
+
+    while ((codec = av_codec_iterate(&i))) {
+        if (codec->init_static_data)
+        	codec->init_static_data((AVCodec*)codec);
+    }
 }
diff --git a/libavcodec/avcodec.h b/libavcodec/avcodec.h
index ce089b7..2300974 100644
--- a/libavcodec/avcodec.h
+++ b/libavcodec/avcodec.h
@@ -3979,10 +3979,22 @@  typedef struct AVCodecParameters {
 } AVCodecParameters;
 
 /**
+ * Iterate over all registered codecs.
+ *
+ * @param opaque a pointer where libavcodec will store the iteration state. Must
+ *               point to NULL to start the iteration.
+ *
+ * @return the next registered codec or NULL when the iteration is
+ *         finished
+ */
+const AVCodec *av_codec_iterate(void **opaque);
+
+/**
  * If c is NULL, returns the first registered codec,
  * if c is non-NULL, returns the next registered codec after c,
  * or NULL if c is the last one.
  */
+attribute_deprecated
 AVCodec *av_codec_next(const AVCodec *c);
 
 /**
@@ -5120,8 +5132,21 @@  typedef struct AVCodecParser {
     struct AVCodecParser *next;
 } AVCodecParser;
 
+/**
+ * Iterate over all registered codec parsers.
+ *
+ * @param opaque a pointer where libavcodec will store the iteration state. Must
+ *               point to NULL to start the iteration.
+ *
+ * @return the next registered codec parser or NULL when the iteration is
+ *         finished
+ */
+const AVCodecParser *av_parser_iterate(void **opaque);
+
+attribute_deprecated
 AVCodecParser *av_parser_next(const AVCodecParser *c);
 
+attribute_deprecated
 void av_register_codec_parser(AVCodecParser *parser);
 AVCodecParserContext *av_parser_init(int codec_id);
 
diff --git a/libavcodec/parser.c b/libavcodec/parser.c
index 670680e..4e4c22d 100644
--- a/libavcodec/parser.c
+++ b/libavcodec/parser.c
@@ -32,33 +32,103 @@ 
 #include "internal.h"
 #include "parser.h"
 
-static AVCodecParser *av_first_parser = NULL;
+#include "pthread.h"
+
+/* Parsers */
+extern AVCodecParser ff_aac_parser;
+extern AVCodecParser ff_aac_latm_parser;
+extern AVCodecParser ff_ac3_parser;
+extern AVCodecParser ff_adx_parser;
+extern AVCodecParser ff_bmp_parser;
+extern AVCodecParser ff_cavsvideo_parser;
+extern AVCodecParser ff_cook_parser;
+extern AVCodecParser ff_dca_parser;
+extern AVCodecParser ff_dirac_parser;
+extern AVCodecParser ff_dnxhd_parser;
+extern AVCodecParser ff_dpx_parser;
+extern AVCodecParser ff_dvaudio_parser;
+extern AVCodecParser ff_dvbsub_parser;
+extern AVCodecParser ff_dvdsub_parser;
+extern AVCodecParser ff_dvd_nav_parser;
+extern AVCodecParser ff_flac_parser;
+extern AVCodecParser ff_g729_parser;
+extern AVCodecParser ff_gsm_parser;
+extern AVCodecParser ff_h261_parser;
+extern AVCodecParser ff_h263_parser;
+extern AVCodecParser ff_h264_parser;
+extern AVCodecParser ff_hevc_parser;
+extern AVCodecParser ff_mjpeg_parser;
+extern AVCodecParser ff_mlp_parser;
+extern AVCodecParser ff_mpeg4video_parser;
+extern AVCodecParser ff_mpegaudio_parser;
+extern AVCodecParser ff_mpegvideo_parser;
+extern AVCodecParser ff_opus_parser;
+extern AVCodecParser ff_png_parser;
+extern AVCodecParser ff_pnm_parser;
+extern AVCodecParser ff_rv30_parser;
+extern AVCodecParser ff_rv40_parser;
+extern AVCodecParser ff_sipr_parser;
+extern AVCodecParser ff_tak_parser;
+extern AVCodecParser ff_vc1_parser;
+extern AVCodecParser ff_vorbis_parser;
+extern AVCodecParser ff_vp3_parser;
+extern AVCodecParser ff_vp8_parser;
+extern AVCodecParser ff_vp9_parser;
+extern AVCodecParser ff_xma_parser;
+
+#include "parser_list.c"
+
+pthread_once_t av_parser_next_init = PTHREAD_ONCE_INIT;
+
+static void av_parser_init_next(void)
+{
+    AVCodecParser *prev = NULL, *p;
+    int i = 0;
+    while ((p = (AVCodecParser*)parser_list[i++])) {
+        if (prev)
+            prev->next = p;
+        prev = p;
+    }
+    prev->next = NULL;
+}
 
 AVCodecParser *av_parser_next(const AVCodecParser *p)
 {
+    pthread_once(&av_parser_next_init, av_parser_init_next);
+
     if (p)
         return p->next;
     else
-        return av_first_parser;
+        return (AVCodecParser*)parser_list[0];
+}
+
+const AVCodecParser *av_parser_iterate(void **opaque)
+{
+    uintptr_t i = (uintptr_t)*opaque;
+    const AVCodecParser *p = parser_list[i];
+
+    if (p)
+        *opaque = (void*)(i + 1);
+
+    return p;
 }
 
 void av_register_codec_parser(AVCodecParser *parser)
 {
-    do {
-        parser->next = av_first_parser;
-    } while (parser->next != avpriv_atomic_ptr_cas((void * volatile *)&av_first_parser, parser->next, parser));
+    pthread_once(&av_parser_next_init, av_parser_init_next);
 }
 
 AVCodecParserContext *av_parser_init(int codec_id)
 {
     AVCodecParserContext *s = NULL;
-    AVCodecParser *parser;
+    const AVCodecParser *parser;
+    void *i = 0;
     int ret;
 
     if (codec_id == AV_CODEC_ID_NONE)
         return NULL;
 
-    for (parser = av_first_parser; parser; parser = parser->next) {
+    while ((parser = av_parser_iterate(&i))) {
         if (parser->codec_ids[0] == codec_id ||
             parser->codec_ids[1] == codec_id ||
             parser->codec_ids[2] == codec_id ||
@@ -72,7 +142,7 @@  found:
     s = av_mallocz(sizeof(AVCodecParserContext));
     if (!s)
         goto err_out;
-    s->parser = parser;
+    s->parser = (AVCodecParser*)parser;
     s->priv_data = av_mallocz(parser->priv_data_size);
     if (!s->priv_data)
         goto err_out;
diff --git a/libavcodec/utils.c b/libavcodec/utils.c
index 873f39f..ff1422e 100644
--- a/libavcodec/utils.c
+++ b/libavcodec/utils.c
@@ -47,7 +47,6 @@ 
 #include "decode.h"
 #include "hwaccel.h"
 #include "libavutil/opt.h"
-#include "me_cmp.h"
 #include "mpegvideo.h"
 #include "thread.h"
 #include "frame_thread_encoder.h"
@@ -144,30 +143,6 @@  void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size)
         memset(*p, 0, min_size + AV_INPUT_BUFFER_PADDING_SIZE);
 }
 
-/* encoder management */
-static AVCodec *first_avcodec = NULL;
-static AVCodec **last_avcodec = &first_avcodec;
-
-AVCodec *av_codec_next(const AVCodec *c)
-{
-    if (c)
-        return c->next;
-    else
-        return first_avcodec;
-}
-
-static av_cold void avcodec_init(void)
-{
-    static int initialized = 0;
-
-    if (initialized != 0)
-        return;
-    initialized = 1;
-
-    if (CONFIG_ME_CMP)
-        ff_me_cmp_init_static();
-}
-
 int av_codec_is_encoder(const AVCodec *codec)
 {
     return codec && (codec->encode_sub || codec->encode2 ||codec->send_frame);
@@ -178,21 +153,6 @@  int av_codec_is_decoder(const AVCodec *codec)
     return codec && (codec->decode || codec->receive_frame);
 }
 
-av_cold void avcodec_register(AVCodec *codec)
-{
-    AVCodec **p;
-    avcodec_init();
-    p = last_avcodec;
-    codec->next = NULL;
-
-    while(*p || avpriv_atomic_ptr_cas((void * volatile *)p, NULL, codec))
-        p = &(*p)->next;
-    last_avcodec = &codec->next;
-
-    if (codec->init_static_data)
-        codec->init_static_data(codec);
-}
-
 int ff_set_dimensions(AVCodecContext *s, int width, int height)
 {
     int ret = av_image_check_size2(width, height, s->max_pixels, AV_PIX_FMT_NONE, 0, s);
@@ -1202,71 +1162,6 @@  FF_ENABLE_DEPRECATION_WARNINGS
     return 0;
 }
 
-static enum AVCodecID remap_deprecated_codec_id(enum AVCodecID id)
-{
-    switch(id){
-        //This is for future deprecatec codec ids, its empty since
-        //last major bump but will fill up again over time, please don't remove it
-        default                                         : return id;
-    }
-}
-
-static AVCodec *find_encdec(enum AVCodecID id, int encoder)
-{
-    AVCodec *p, *experimental = NULL;
-    p = first_avcodec;
-    id= remap_deprecated_codec_id(id);
-    while (p) {
-        if ((encoder ? av_codec_is_encoder(p) : av_codec_is_decoder(p)) &&
-            p->id == id) {
-            if (p->capabilities & AV_CODEC_CAP_EXPERIMENTAL && !experimental) {
-                experimental = p;
-            } else
-                return p;
-        }
-        p = p->next;
-    }
-    return experimental;
-}
-
-AVCodec *avcodec_find_encoder(enum AVCodecID id)
-{
-    return find_encdec(id, 1);
-}
-
-AVCodec *avcodec_find_encoder_by_name(const char *name)
-{
-    AVCodec *p;
-    if (!name)
-        return NULL;
-    p = first_avcodec;
-    while (p) {
-        if (av_codec_is_encoder(p) && strcmp(name, p->name) == 0)
-            return p;
-        p = p->next;
-    }
-    return NULL;
-}
-
-AVCodec *avcodec_find_decoder(enum AVCodecID id)
-{
-    return find_encdec(id, 0);
-}
-
-AVCodec *avcodec_find_decoder_by_name(const char *name)
-{
-    AVCodec *p;
-    if (!name)
-        return NULL;
-    p = first_avcodec;
-    while (p) {
-        if (av_codec_is_decoder(p) && strcmp(name, p->name) == 0)
-            return p;
-        p = p->next;
-    }
-    return NULL;
-}
-
 const char *avcodec_get_name(enum AVCodecID id)
 {
     const AVCodecDescriptor *cd;
-- 
2.7.4