// =========================================================
// 2009/09/04 12:07:28
AVCodec flashsv_decoder = {
    "flashsv",
    CODEC_TYPE_VIDEO,
    CODEC_ID_FLASHSV,
    sizeof(FlashSVContext),
    flashsv_decode_init,
    NULL,
    flashsv_decode_end,
    flashsv_decode_frame,
    CODEC_CAP_DR1,
    .pix_fmts = (enum PixelFormat[]){PIX_FMT_BGR24, PIX_FMT_NONE},
    .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video v1"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_flashsv_decoder[] = {PIX_FMT_BGR24, PIX_FMT_NONE};
AVCodec flashsv_decoder = {
    "flashsv",                                         /* const char * name                                */
    CODEC_TYPE_VIDEO,                                  /* enum CodecType type                              */
    CODEC_ID_FLASHSV,                                  /* enum CodecID id                                  */
    sizeof(FlashSVContext),                            /* int priv_data_size                               */
    flashsv_decode_init,                               /* int (*init)(AVCodecContext *)                    */
    NULL,                                              /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    flashsv_decode_end,                                /* int (*close)(AVCodecContext *)                   */
    flashsv_decode_frame,                              /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DR1,                                     /* int capabilities                                 */
    NULL,                                              /* struct AVCodec * next                            */
    NULL,                                              /* void (*flush)(AVCodecContext *)                  */
    NULL,                                              /* const AVRational * supported_framerates          */
    _s_PF_flashsv_decoder,                             /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("Flash Screen Video v1"),     /* const char * long_name                           */
    NULL,                                              /* const int * supported_samplerates                */
    NULL,                                              /* const enum SampleFormat * sample_fmts            */
    NULL                                               /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:09:09
AVCodec flashsv_encoder = {
    "flashsv",
    CODEC_TYPE_VIDEO,
    CODEC_ID_FLASHSV,
    sizeof(FlashSVContext),
    flashsv_encode_init,
    flashsv_encode_frame,
    flashsv_encode_end,
    .pix_fmts = (enum PixelFormat[]){PIX_FMT_BGR24, PIX_FMT_NONE},
    .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_flashsv_encoder[] = {PIX_FMT_BGR24, PIX_FMT_NONE};
AVCodec flashsv_encoder = {
    "flashsv",                                         /* const char * name                                */
    CODEC_TYPE_VIDEO,                                  /* enum CodecType type                              */
    CODEC_ID_FLASHSV,                                  /* enum CodecID id                                  */
    sizeof(FlashSVContext),                            /* int priv_data_size                               */
    flashsv_encode_init,                               /* int (*init)(AVCodecContext *)                    */
    flashsv_encode_frame,                              /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    flashsv_encode_end,                                /* int (*close)(AVCodecContext *)                   */
    NULL,                                              /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                                 /* int capabilities                                 */
    NULL,                                              /* struct AVCodec * next                            */
    NULL,                                              /* void (*flush)(AVCodecContext *)                  */
    NULL,                                              /* const AVRational * supported_framerates          */
    _s_PF_flashsv_encoder,                             /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("Flash Screen Video"),        /* const char * long_name                           */
    NULL,                                              /* const int * supported_samplerates                */
    NULL,                                              /* const enum SampleFormat * sample_fmts            */
    NULL                                               /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:11:02
AVCodec gif_encoder = {
    "gif",
    CODEC_TYPE_VIDEO,
    CODEC_ID_GIF,
    sizeof(GIFContext),
    gif_encode_init,
    gif_encode_frame,
    NULL, //encode_end,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_RGB8, PIX_FMT_BGR8, PIX_FMT_RGB4_BYTE, PIX_FMT_BGR4_BYTE, PIX_FMT_GRAY8, PIX_FMT_PAL8, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("GIF (Graphics Interchange Format)"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_gif_encoder[] = {PIX_FMT_RGB8, PIX_FMT_BGR8, PIX_FMT_RGB4_BYTE, PIX_FMT_BGR4_BYTE, PIX_FMT_GRAY8, PIX_FMT_PAL8, PIX_FMT_NONE};
AVCodec gif_encoder = {
    "gif",                                                   /* const char * name                                */
    CODEC_TYPE_VIDEO,                                        /* enum CodecType type                              */
    CODEC_ID_GIF,                                            /* enum CodecID id                                  */
    sizeof(GIFContext),                                      /* int priv_data_size                               */
    gif_encode_init,                                         /* int (*init)(AVCodecContext *)                    */
    gif_encode_frame,                                        /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    NULL,                                                    /* int (*close)(AVCodecContext *)                   */
    NULL,                                                    /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                                       /* int capabilities                                 */
    NULL,                                                    /* struct AVCodec * next                            */
    NULL,                                                    /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                    /* const AVRational * supported_framerates          */
    _s_PF_gif_encoder,                                       /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("GIF (Graphics Interchange Format)"), /* const char * long_name                           */
    NULL,                                                    /* const int * supported_samplerates                */
    NULL,                                                    /* const enum SampleFormat * sample_fmts            */
    NULL                                                     /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:12:08
AVCodec h261_encoder = {
    "h261",
    CODEC_TYPE_VIDEO,
    CODEC_ID_H261,
    sizeof(H261Context),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("H.261"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_h261_encoder[] = {PIX_FMT_YUV420P, PIX_FMT_NONE};
AVCodec h261_encoder = {
    "h261",                                              /* const char * name                                */
    CODEC_TYPE_VIDEO,                                    /* enum CodecType type                              */
    CODEC_ID_H261,                                       /* enum CodecID id                                  */
    sizeof(H261Context),                                 /* int priv_data_size                               */
    MPV_encode_init,                                     /* int (*init)(AVCodecContext *)                    */
    MPV_encode_picture,                                  /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    MPV_encode_end,                                      /* int (*close)(AVCodecContext *)                   */
    NULL,                                                /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                                   /* int capabilities                                 */
    NULL,                                                /* struct AVCodec * next                            */
    NULL,                                                /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                /* const AVRational * supported_framerates          */
    _s_PF_h261_encoder,                                  /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("H.261"),                       /* const char * long_name                           */
    NULL,                                                /* const int * supported_samplerates                */
    NULL,                                                /* const enum SampleFormat * sample_fmts            */
    NULL                                                 /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:13:27
AVCodec mpeg4_decoder = {
    "mpeg4",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MPEG4,
    sizeof(MpegEncContext),
    ff_h263_decode_init,
    NULL,
    ff_h263_decode_end,
    ff_h263_decode_frame,
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
    .flush= ff_mpeg_flush,
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
    .pix_fmts= ff_hwaccel_pixfmt_list_420,
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec mpeg4_decoder = {
    "mpeg4",                                                 /* const char * name                                */
    CODEC_TYPE_VIDEO,                                        /* enum CodecType type                              */
    CODEC_ID_MPEG4,                                          /* enum CodecID id                                  */
    sizeof(MpegEncContext),                                  /* int priv_data_size                               */
    ff_h263_decode_init,                                     /* int (*init)(AVCodecContext *)                    */
    NULL,                                                    /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    ff_h263_decode_end,                                      /* int (*close)(AVCodecContext *)                   */
    ff_h263_decode_frame,                                    /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, /* int capabilities                                 */
    NULL,                                                    /* struct AVCodec * next                            */
    ff_mpeg_flush,                                           /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                    /* const AVRational * supported_framerates          */
    ff_hwaccel_pixfmt_list_420,                              /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),                   /* const char * long_name                           */
    NULL,                                                    /* const int * supported_samplerates                */
    NULL,                                                    /* const enum SampleFormat * sample_fmts            */
    NULL                                                     /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:14:40
AVCodec h263_decoder = {
    "h263",
    CODEC_TYPE_VIDEO,
    CODEC_ID_H263,
    sizeof(MpegEncContext),
    ff_h263_decode_init,
    NULL,
    ff_h263_decode_end,
    ff_h263_decode_frame,
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
    .flush= ff_mpeg_flush,
    .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
    .pix_fmts= ff_hwaccel_pixfmt_list_420,
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec h263_decoder = {
    "h263",                                                  /* const char * name                                */
    CODEC_TYPE_VIDEO,                                        /* enum CodecType type                              */
    CODEC_ID_H263,                                           /* enum CodecID id                                  */
    sizeof(MpegEncContext),                                  /* int priv_data_size                               */
    ff_h263_decode_init,                                     /* int (*init)(AVCodecContext *)                    */
    NULL,                                                    /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    ff_h263_decode_end,                                      /* int (*close)(AVCodecContext *)                   */
    ff_h263_decode_frame,                                    /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, /* int capabilities                                 */
    NULL,                                                    /* struct AVCodec * next                            */
    ff_mpeg_flush,                                           /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                    /* const AVRational * supported_framerates          */
    ff_hwaccel_pixfmt_list_420,                              /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"), /* const char * long_name                           */
    NULL,                                                    /* const int * supported_samplerates                */
    NULL,                                                    /* const enum SampleFormat * sample_fmts            */
    NULL                                                     /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:15:51
AVCodec msmpeg4v1_decoder = {
    "msmpeg4v1",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MSMPEG4V1,
    sizeof(MpegEncContext),
    ff_h263_decode_init,
    NULL,
    ff_h263_decode_end,
    ff_h263_decode_frame,
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
    .pix_fmts= ff_pixfmt_list_420,
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec msmpeg4v1_decoder = {
    "msmpeg4v1",                                             /* const char * name                                */
    CODEC_TYPE_VIDEO,                                        /* enum CodecType type                              */
    CODEC_ID_MSMPEG4V1,                                      /* enum CodecID id                                  */
    sizeof(MpegEncContext),                                  /* int priv_data_size                               */
    ff_h263_decode_init,                                     /* int (*init)(AVCodecContext *)                    */
    NULL,                                                    /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    ff_h263_decode_end,                                      /* int (*close)(AVCodecContext *)                   */
    ff_h263_decode_frame,                                    /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,               /* int capabilities                                 */
    NULL,                                                    /* struct AVCodec * next                            */
    NULL,                                                    /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                    /* const AVRational * supported_framerates          */
    ff_pixfmt_list_420,                                      /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"), /* const char * long_name                           */
    NULL,                                                    /* const int * supported_samplerates                */
    NULL,                                                    /* const enum SampleFormat * sample_fmts            */
    NULL                                                     /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:16:47
AVCodec msmpeg4v2_decoder = {
    "msmpeg4v2",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MSMPEG4V2,
    sizeof(MpegEncContext),
    ff_h263_decode_init,
    NULL,
    ff_h263_decode_end,
    ff_h263_decode_frame,
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
    .pix_fmts= ff_pixfmt_list_420,
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec msmpeg4v2_decoder = {
    "msmpeg4v2",                                             /* const char * name                                */
    CODEC_TYPE_VIDEO,                                        /* enum CodecType type                              */
    CODEC_ID_MSMPEG4V2,                                      /* enum CodecID id                                  */
    sizeof(MpegEncContext),                                  /* int priv_data_size                               */
    ff_h263_decode_init,                                     /* int (*init)(AVCodecContext *)                    */
    NULL,                                                    /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    ff_h263_decode_end,                                      /* int (*close)(AVCodecContext *)                   */
    ff_h263_decode_frame,                                    /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,               /* int capabilities                                 */
    NULL,                                                    /* struct AVCodec * next                            */
    NULL,                                                    /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                    /* const AVRational * supported_framerates          */
    ff_pixfmt_list_420,                                      /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"), /* const char * long_name                           */
    NULL,                                                    /* const int * supported_samplerates                */
    NULL,                                                    /* const enum SampleFormat * sample_fmts            */
    NULL                                                     /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:17:44
AVCodec msmpeg4v3_decoder = {
    "msmpeg4",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MSMPEG4V3,
    sizeof(MpegEncContext),
    ff_h263_decode_init,
    NULL,
    ff_h263_decode_end,
    ff_h263_decode_frame,
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
    .pix_fmts= ff_pixfmt_list_420,
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec msmpeg4v3_decoder = {
    "msmpeg4",                                               /* const char * name                                */
    CODEC_TYPE_VIDEO,                                        /* enum CodecType type                              */
    CODEC_ID_MSMPEG4V3,                                      /* enum CodecID id                                  */
    sizeof(MpegEncContext),                                  /* int priv_data_size                               */
    ff_h263_decode_init,                                     /* int (*init)(AVCodecContext *)                    */
    NULL,                                                    /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    ff_h263_decode_end,                                      /* int (*close)(AVCodecContext *)                   */
    ff_h263_decode_frame,                                    /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,               /* int capabilities                                 */
    NULL,                                                    /* struct AVCodec * next                            */
    NULL,                                                    /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                    /* const AVRational * supported_framerates          */
    ff_pixfmt_list_420,                                      /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"), /* const char * long_name                           */
    NULL,                                                    /* const int * supported_samplerates                */
    NULL,                                                    /* const enum SampleFormat * sample_fmts            */
    NULL                                                     /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:18:35
AVCodec wmv1_decoder = {
    "wmv1",
    CODEC_TYPE_VIDEO,
    CODEC_ID_WMV1,
    sizeof(MpegEncContext),
    ff_h263_decode_init,
    NULL,
    ff_h263_decode_end,
    ff_h263_decode_frame,
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
    .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
    .pix_fmts= ff_pixfmt_list_420,
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec wmv1_decoder = {
    "wmv1",                                        /* const char * name                                */
    CODEC_TYPE_VIDEO,                              /* enum CodecType type                              */
    CODEC_ID_WMV1,                                 /* enum CodecID id                                  */
    sizeof(MpegEncContext),                        /* int priv_data_size                               */
    ff_h263_decode_init,                           /* int (*init)(AVCodecContext *)                    */
    NULL,                                          /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    ff_h263_decode_end,                            /* int (*close)(AVCodecContext *)                   */
    ff_h263_decode_frame,                          /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,     /* int capabilities                                 */
    NULL,                                          /* struct AVCodec * next                            */
    NULL,                                          /* void (*flush)(AVCodecContext *)                  */
    NULL,                                          /* const AVRational * supported_framerates          */
    ff_pixfmt_list_420,                            /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("Windows Media Video 7"), /* const char * long_name                           */
    NULL,                                          /* const int * supported_samplerates                */
    NULL,                                          /* const enum SampleFormat * sample_fmts            */
    NULL                                           /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:19:33
AVCodec h263i_decoder = {
    "h263i",
    CODEC_TYPE_VIDEO,
    CODEC_ID_H263I,
    sizeof(MpegEncContext),
    ff_h263_decode_init,
    NULL,
    ff_h263_decode_end,
    ff_h263_decode_frame,
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
    .long_name = NULL_IF_CONFIG_SMALL("Intel H.263"),
    .pix_fmts= ff_pixfmt_list_420,
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec h263i_decoder = {
    "h263i",                                   /* const char * name                                */
    CODEC_TYPE_VIDEO,                          /* enum CodecType type                              */
    CODEC_ID_H263I,                            /* enum CodecID id                                  */
    sizeof(MpegEncContext),                    /* int priv_data_size                               */
    ff_h263_decode_init,                       /* int (*init)(AVCodecContext *)                    */
    NULL,                                      /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    ff_h263_decode_end,                        /* int (*close)(AVCodecContext *)                   */
    ff_h263_decode_frame,                      /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, /* int capabilities                                 */
    NULL,                                      /* struct AVCodec * next                            */
    NULL,                                      /* void (*flush)(AVCodecContext *)                  */
    NULL,                                      /* const AVRational * supported_framerates          */
    ff_pixfmt_list_420,                        /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("Intel H.263"),       /* const char * long_name                           */
    NULL,                                      /* const int * supported_samplerates                */
    NULL,                                      /* const enum SampleFormat * sample_fmts            */
    NULL                                       /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:20:24
AVCodec flv_decoder = {
    "flv",
    CODEC_TYPE_VIDEO,
    CODEC_ID_FLV1,
    sizeof(MpegEncContext),
    ff_h263_decode_init,
    NULL,
    ff_h263_decode_end,
    ff_h263_decode_frame,
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
    .long_name= NULL_IF_CONFIG_SMALL("Flash Video (FLV)"),
    .pix_fmts= ff_pixfmt_list_420,
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec flv_decoder = {
    "flv",                                     /* const char * name                                */
    CODEC_TYPE_VIDEO,                          /* enum CodecType type                              */
    CODEC_ID_FLV1,                             /* enum CodecID id                                  */
    sizeof(MpegEncContext),                    /* int priv_data_size                               */
    ff_h263_decode_init,                       /* int (*init)(AVCodecContext *)                    */
    NULL,                                      /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    ff_h263_decode_end,                        /* int (*close)(AVCodecContext *)                   */
    ff_h263_decode_frame,                      /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, /* int capabilities                                 */
    NULL,                                      /* struct AVCodec * next                            */
    NULL,                                      /* void (*flush)(AVCodecContext *)                  */
    NULL,                                      /* const AVRational * supported_framerates          */
    ff_pixfmt_list_420,                        /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("Flash Video (FLV)"), /* const char * long_name                           */
    NULL,                                      /* const int * supported_samplerates                */
    NULL,                                      /* const enum SampleFormat * sample_fmts            */
    NULL                                       /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:21:40
AVCodec h264_decoder = {
    "h264",
    CODEC_TYPE_VIDEO,
    CODEC_ID_H264,
    sizeof(H264Context),
    decode_init,
    NULL,
    decode_end,
    decode_frame,
    /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_DELAY,
    .flush= flush_dpb,
    .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
    .pix_fmts= ff_hwaccel_pixfmt_list_420,
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec h264_decoder = {
    "h264",                                                  /* const char * name                                */
    CODEC_TYPE_VIDEO,                                        /* enum CodecType type                              */
    CODEC_ID_H264,                                           /* enum CodecID id                                  */
    sizeof(H264Context),                                     /* int priv_data_size                               */
    decode_init,                                             /* int (*init)(AVCodecContext *)                    */
    NULL,                                                    /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    decode_end,                                              /* int (*close)(AVCodecContext *)                   */
    decode_frame,                                            /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,                         /* int capabilities                                 */
    NULL,                                                    /* struct AVCodec * next                            */
    flush_dpb,                                               /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                    /* const AVRational * supported_framerates          */
    ff_hwaccel_pixfmt_list_420,                              /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"), /* const char * long_name                           */
    NULL,                                                    /* const int * supported_samplerates                */
    NULL,                                                    /* const enum SampleFormat * sample_fmts            */
    NULL                                                     /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:22:44
AVCodec h264_vdpau_decoder = {
    "h264_vdpau",
    CODEC_TYPE_VIDEO,
    CODEC_ID_H264,
    sizeof(H264Context),
    decode_init,
    NULL,
    decode_end,
    decode_frame,
    CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
    .flush= flush_dpb,
    .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (VDPAU acceleration)"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec h264_vdpau_decoder = {
    "h264_vdpau",                                            /* const char * name                                */
    CODEC_TYPE_VIDEO,                                        /* enum CodecType type                              */
    CODEC_ID_H264,                                           /* enum CodecID id                                  */
    sizeof(H264Context),                                     /* int priv_data_size                               */
    decode_init,                                             /* int (*init)(AVCodecContext *)                    */
    NULL,                                                    /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    decode_end,                                              /* int (*close)(AVCodecContext *)                   */
    decode_frame,                                            /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU, /* int capabilities                                 */
    NULL,                                                    /* struct AVCodec * next                            */
    flush_dpb,                                               /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                    /* const AVRational * supported_framerates          */
    NULL,                                                    /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (VDPAU acceleration)"), /* const char * long_name                           */
    NULL,                                                    /* const int * supported_samplerates                */
    NULL,                                                    /* const enum SampleFormat * sample_fmts            */
    NULL                                                     /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:23:46
AVCodec huffyuv_encoder = {
    "huffyuv",
    CODEC_TYPE_VIDEO,
    CODEC_ID_HUFFYUV,
    sizeof(HYuvContext),
    encode_init,
    encode_frame,
    encode_end,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV422P, PIX_FMT_RGB32, PIX_FMT_NONE},
    .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_huffyuv_encoder[] = {PIX_FMT_YUV422P, PIX_FMT_RGB32, PIX_FMT_NONE};
AVCodec huffyuv_encoder = {
    "huffyuv",                                               /* const char * name                                */
    CODEC_TYPE_VIDEO,                                        /* enum CodecType type                              */
    CODEC_ID_HUFFYUV,                                        /* enum CodecID id                                  */
    sizeof(HYuvContext),                                     /* int priv_data_size                               */
    encode_init,                                             /* int (*init)(AVCodecContext *)                    */
    encode_frame,                                            /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    encode_end,                                              /* int (*close)(AVCodecContext *)                   */
    NULL,                                                    /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                                       /* int capabilities                                 */
    NULL,                                                    /* struct AVCodec * next                            */
    NULL,                                                    /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                    /* const AVRational * supported_framerates          */
    _s_PF_huffyuv_encoder,                                   /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),               /* const char * long_name                           */
    NULL,                                                    /* const int * supported_samplerates                */
    NULL,                                                    /* const enum SampleFormat * sample_fmts            */
    NULL                                                     /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:24:34
AVCodec ffvhuff_encoder = {
    "ffvhuff",
    CODEC_TYPE_VIDEO,
    CODEC_ID_FFVHUFF,
    sizeof(HYuvContext),
    encode_init,
    encode_frame,
    encode_end,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_RGB32, PIX_FMT_NONE},
    .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_ffvhuff_encoder[] = {PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_RGB32, PIX_FMT_NONE};
AVCodec ffvhuff_encoder = {
    "ffvhuff",                                               /* const char * name                                */
    CODEC_TYPE_VIDEO,                                        /* enum CodecType type                              */
    CODEC_ID_FFVHUFF,                                        /* enum CodecID id                                  */
    sizeof(HYuvContext),                                     /* int priv_data_size                               */
    encode_init,                                             /* int (*init)(AVCodecContext *)                    */
    encode_frame,                                            /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    encode_end,                                              /* int (*close)(AVCodecContext *)                   */
    NULL,                                                    /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                                       /* int capabilities                                 */
    NULL,                                                    /* struct AVCodec * next                            */
    NULL,                                                    /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                    /* const AVRational * supported_framerates          */
    _s_PF_ffvhuff_encoder,                                   /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),          /* const char * long_name                           */
    NULL,                                                    /* const int * supported_samplerates                */
    NULL,                                                    /* const enum SampleFormat * sample_fmts            */
    NULL                                                     /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:26:00
AVCodec jpegls_encoder = { //FIXME avoid MPV_* lossless JPEG should not need them
    "jpegls",
    CODEC_TYPE_VIDEO,
    CODEC_ID_JPEGLS,
    sizeof(JpeglsContext),
    encode_init_ls,
    encode_picture_ls,
    NULL,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_BGR24, PIX_FMT_RGB24, PIX_FMT_GRAY8, PIX_FMT_GRAY16, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("JPEG-LS"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_jpegls_encoder[] = {PIX_FMT_BGR24, PIX_FMT_RGB24, PIX_FMT_GRAY8, PIX_FMT_GRAY16, PIX_FMT_NONE};
AVCodec jpegls_encoder = {
    "jpegls",                                                /* const char * name                                */
    CODEC_TYPE_VIDEO,                                        /* enum CodecType type                              */
    CODEC_ID_JPEGLS,                                         /* enum CodecID id                                  */
    sizeof(JpeglsContext),                                   /* int priv_data_size                               */
    encode_init_ls,                                          /* int (*init)(AVCodecContext *)                    */
    encode_picture_ls,                                       /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    NULL,                                                    /* int (*close)(AVCodecContext *)                   */
    NULL,                                                    /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                                       /* int capabilities                                 */
    NULL,                                                    /* struct AVCodec * next                            */
    NULL,                                                    /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                    /* const AVRational * supported_framerates          */
    _s_PF_jpegls_encoder,                                    /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("JPEG-LS"),                         /* const char * long_name                           */
    NULL,                                                    /* const int * supported_samplerates                */
    NULL,                                                    /* const enum SampleFormat * sample_fmts            */
    NULL                                                     /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:42:04
AVCodec libdirac_encoder = {
    "libdirac",
    CODEC_TYPE_VIDEO,
    CODEC_ID_DIRAC,
    sizeof(FfmpegDiracEncoderParams),
    libdirac_encode_init,
    libdirac_encode_frame,
    libdirac_encode_close,
   .capabilities = CODEC_CAP_DELAY,
   .pix_fmts = (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_NONE},
   .long_name = NULL_IF_CONFIG_SMALL("libdirac Dirac 2.2"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_libdirac_encoder[] = {PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_NONE};
AVCodec libdirac_encoder = {
    "libdirac",                                 /* const char * name                                */
    CODEC_TYPE_VIDEO,                           /* enum CodecType type                              */
    CODEC_ID_DIRAC,                             /* enum CodecID id                                  */
    sizeof(FfmpegDiracEncoderParams),           /* int priv_data_size                               */
    libdirac_encode_init,                       /* int (*init)(AVCodecContext *)                    */
    libdirac_encode_frame,                      /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    libdirac_encode_close,                      /* int (*close)(AVCodecContext *)                   */
    NULL,                                       /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DELAY,                            /* int capabilities                                 */
    NULL,                                       /* struct AVCodec * next                            */
    NULL,                                       /* void (*flush)(AVCodecContext *)                  */
    NULL,                                       /* const AVRational * supported_framerates          */
    _s_PF_libdirac_encoder,                     /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("libdirac Dirac 2.2"), /* const char * long_name                           */
    NULL,                                       /* const int * supported_samplerates                */
    NULL,                                       /* const enum SampleFormat * sample_fmts            */
    NULL                                        /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:43:50
AVCodec libschroedinger_encoder = {
    "libschroedinger",
    CODEC_TYPE_VIDEO,
    CODEC_ID_DIRAC,
    sizeof(FfmpegSchroEncoderParams),
    libschroedinger_encode_init,
    libschroedinger_encode_frame,
    libschroedinger_encode_close,
   .capabilities = CODEC_CAP_DELAY,
   .pix_fmts     = (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_NONE},
   .long_name    = NULL_IF_CONFIG_SMALL("libschroedinger Dirac 2.2"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_libschroedinger_encoder[] = {PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_NONE};
AVCodec libschroedinger_encoder = {
    "libschroedinger",                                 /* const char * name                                */
    CODEC_TYPE_VIDEO,                                  /* enum CodecType type                              */
    CODEC_ID_DIRAC,                                    /* enum CodecID id                                  */
    sizeof(FfmpegSchroEncoderParams),                  /* int priv_data_size                               */
    libschroedinger_encode_init,                       /* int (*init)(AVCodecContext *)                    */
    libschroedinger_encode_frame,                      /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    libschroedinger_encode_close,                      /* int (*close)(AVCodecContext *)                   */
    NULL,                                              /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DELAY,                                   /* int capabilities                                 */
    NULL,                                              /* struct AVCodec * next                            */
    NULL,                                              /* void (*flush)(AVCodecContext *)                  */
    NULL,                                              /* const AVRational * supported_framerates          */
    _s_PF_libschroedinger_encoder,                     /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("libschroedinger Dirac 2.2"), /* const char * long_name                           */
    NULL,                                              /* const int * supported_samplerates                */
    NULL,                                              /* const enum SampleFormat * sample_fmts            */
    NULL                                               /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:45:14
AVCodec libtheora_encoder =
{
    .name = "libtheora",
    .type = CODEC_TYPE_VIDEO,
    .id = CODEC_ID_THEORA,
    .priv_data_size = sizeof(TheoraContext),
    .init = encode_init,
    .close = encode_close,
    .encode = encode_frame,
    .pix_fmts = supported_pixel_formats,
    .long_name = NULL_IF_CONFIG_SMALL("libtheora Theora"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec libtheora_encoder ={
    "libtheora",                              /* const char * name                                */
    CODEC_TYPE_VIDEO,                         /* enum CodecType type                              */
    CODEC_ID_THEORA,                          /* enum CodecID id                                  */
    sizeof(TheoraContext),                    /* int priv_data_size                               */
    encode_init,                              /* int (*init)(AVCodecContext *)                    */
    encode_frame,                             /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    encode_close,                             /* int (*close)(AVCodecContext *)                   */
    NULL,                                     /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                        /* int capabilities                                 */
    NULL,                                     /* struct AVCodec * next                            */
    NULL,                                     /* void (*flush)(AVCodecContext *)                  */
    NULL,                                     /* const AVRational * supported_framerates          */
    supported_pixel_formats,                  /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("libtheora Theora"), /* const char * long_name                           */
    NULL,                                     /* const int * supported_samplerates                */
    NULL,                                     /* const enum SampleFormat * sample_fmts            */
    NULL                                      /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:46:35
AVCodec libx264_encoder = {
    .name = "libx264",
    .type = CODEC_TYPE_VIDEO,
    .id = CODEC_ID_H264,
    .priv_data_size = sizeof(X264Context),
    .init = X264_init,
    .encode = X264_frame,
    .close = X264_close,
    .capabilities = CODEC_CAP_DELAY,
    .pix_fmts = (enum PixelFormat[]) { PIX_FMT_YUV420P, PIX_FMT_NONE },
    .long_name = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_libx264_encoder[] = { PIX_FMT_YUV420P, PIX_FMT_NONE };
AVCodec libx264_encoder = {
    "libx264",                                               /* const char * name                                */
    CODEC_TYPE_VIDEO,                                        /* enum CodecType type                              */
    CODEC_ID_H264,                                           /* enum CodecID id                                  */
    sizeof(X264Context),                                     /* int priv_data_size                               */
    X264_init,                                               /* int (*init)(AVCodecContext *)                    */
    X264_frame,                                              /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    X264_close,                                              /* int (*close)(AVCodecContext *)                   */
    NULL,                                                    /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DELAY,                                         /* int capabilities                                 */
    NULL,                                                    /* struct AVCodec * next                            */
    NULL,                                                    /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                    /* const AVRational * supported_framerates          */
    _s_PF_libx264_encoder,                                   /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"), /* const char * long_name                           */
    NULL,                                                    /* const int * supported_samplerates                */
    NULL,                                                    /* const enum SampleFormat * sample_fmts            */
    NULL                                                     /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:47:47
AVCodec libxvid_encoder = {
    "libxvid",
    CODEC_TYPE_VIDEO,
    CODEC_ID_XVID,
    sizeof(struct xvid_context),
    ff_xvid_encode_init,
    ff_xvid_encode_frame,
    ff_xvid_encode_close,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("libxvidcore MPEG-4 part 2"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_libxvid_encoder[] = {PIX_FMT_YUV420P, PIX_FMT_NONE};
AVCodec libxvid_encoder = {
    "libxvid",                                         /* const char * name                                */
    CODEC_TYPE_VIDEO,                                  /* enum CodecType type                              */
    CODEC_ID_XVID,                                     /* enum CodecID id                                  */
    sizeof(struct xvid_context),                       /* int priv_data_size                               */
    ff_xvid_encode_init,                               /* int (*init)(AVCodecContext *)                    */
    ff_xvid_encode_frame,                              /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    ff_xvid_encode_close,                              /* int (*close)(AVCodecContext *)                   */
    NULL,                                              /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                                 /* int capabilities                                 */
    NULL,                                              /* struct AVCodec * next                            */
    NULL,                                              /* void (*flush)(AVCodecContext *)                  */
    NULL,                                              /* const AVRational * supported_framerates          */
    _s_PF_libxvid_encoder,                             /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("libxvidcore MPEG-4 part 2"), /* const char * long_name                           */
    NULL,                                              /* const int * supported_samplerates                */
    NULL,                                              /* const enum SampleFormat * sample_fmts            */
    NULL                                               /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:48:51
AVCodec mjpeg_encoder = {
    "mjpeg",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MJPEG,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_mjpeg_encoder[] = {PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_NONE};
AVCodec mjpeg_encoder = {
    "mjpeg",                                     /* const char * name                                */
    CODEC_TYPE_VIDEO,                            /* enum CodecType type                              */
    CODEC_ID_MJPEG,                              /* enum CodecID id                                  */
    sizeof(MpegEncContext),                      /* int priv_data_size                               */
    MPV_encode_init,                             /* int (*init)(AVCodecContext *)                    */
    MPV_encode_picture,                          /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    MPV_encode_end,                              /* int (*close)(AVCodecContext *)                   */
    NULL,                                        /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                           /* int capabilities                                 */
    NULL,                                        /* struct AVCodec * next                            */
    NULL,                                        /* void (*flush)(AVCodecContext *)                  */
    NULL,                                        /* const AVRational * supported_framerates          */
    _s_PF_mjpeg_encoder,                         /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"), /* const char * long_name                           */
    NULL,                                        /* const int * supported_samplerates                */
    NULL,                                        /* const enum SampleFormat * sample_fmts            */
    NULL                                         /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:49:46
AVCodec mpeg1video_encoder = {
    "mpeg1video",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MPEG1VIDEO,
    sizeof(MpegEncContext),
    encode_init,
    MPV_encode_picture,
    MPV_encode_end,
    .supported_framerates= ff_frame_rate_tab+1,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
    .capabilities= CODEC_CAP_DELAY,
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-1 video"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_mpeg1video_encoder[] = {PIX_FMT_YUV420P, PIX_FMT_NONE};
AVCodec mpeg1video_encoder = {
    "mpeg1video",                         /* const char * name                                */
    CODEC_TYPE_VIDEO,                     /* enum CodecType type                              */
    CODEC_ID_MPEG1VIDEO,                  /* enum CodecID id                                  */
    sizeof(MpegEncContext),               /* int priv_data_size                               */
    encode_init,                          /* int (*init)(AVCodecContext *)                    */
    MPV_encode_picture,                   /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    MPV_encode_end,                       /* int (*close)(AVCodecContext *)                   */
    NULL,                                 /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DELAY,                      /* int capabilities                                 */
    NULL,                                 /* struct AVCodec * next                            */
    NULL,                                 /* void (*flush)(AVCodecContext *)                  */
    ff_frame_rate_tab+1,                  /* const AVRational * supported_framerates          */
    _s_PF_mpeg1video_encoder,             /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("MPEG-1 video"), /* const char * long_name                           */
    NULL,                                 /* const int * supported_samplerates                */
    NULL,                                 /* const enum SampleFormat * sample_fmts            */
    NULL                                  /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:51:19
AVCodec mpeg2video_encoder = {
    "mpeg2video",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MPEG2VIDEO,
    sizeof(MpegEncContext),
    encode_init,
    MPV_encode_picture,
    MPV_encode_end,
    .supported_framerates= ff_frame_rate_tab+1,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE},
    .capabilities= CODEC_CAP_DELAY,
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-2 video"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_mpeg2video_encoder[] = {PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
AVCodec mpeg2video_encoder = {
    "mpeg2video",                         /* const char * name                                */
    CODEC_TYPE_VIDEO,                     /* enum CodecType type                              */
    CODEC_ID_MPEG2VIDEO,                  /* enum CodecID id                                  */
    sizeof(MpegEncContext),               /* int priv_data_size                               */
    encode_init,                          /* int (*init)(AVCodecContext *)                    */
    MPV_encode_picture,                   /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    MPV_encode_end,                       /* int (*close)(AVCodecContext *)                   */
    NULL,                                 /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DELAY,                      /* int capabilities                                 */
    NULL,                                 /* struct AVCodec * next                            */
    NULL,                                 /* void (*flush)(AVCodecContext *)                  */
    ff_frame_rate_tab+1,                  /* const AVRational * supported_framerates          */
    _s_PF_mpeg2video_encoder,             /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("MPEG-2 video"), /* const char * long_name                           */
    NULL,                                 /* const int * supported_samplerates                */
    NULL,                                 /* const enum SampleFormat * sample_fmts            */
    NULL                                  /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:52:32
AVCodec h263_encoder = {
    "h263",
    CODEC_TYPE_VIDEO,
    CODEC_ID_H263,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_h263_encoder[] = {PIX_FMT_YUV420P, PIX_FMT_NONE};
AVCodec h263_encoder = {
    "h263",                                     /* const char * name                                */
    CODEC_TYPE_VIDEO,                           /* enum CodecType type                              */
    CODEC_ID_H263,                              /* enum CodecID id                                  */
    sizeof(MpegEncContext),                     /* int priv_data_size                               */
    MPV_encode_init,                            /* int (*init)(AVCodecContext *)                    */
    MPV_encode_picture,                         /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    MPV_encode_end,                             /* int (*close)(AVCodecContext *)                   */
    NULL,                                       /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                          /* int capabilities                                 */
    NULL,                                       /* struct AVCodec * next                            */
    NULL,                                       /* void (*flush)(AVCodecContext *)                  */
    NULL,                                       /* const AVRational * supported_framerates          */
    _s_PF_h263_encoder,                         /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"), /* const char * long_name                           */
    NULL,                                       /* const int * supported_samplerates                */
    NULL,                                       /* const enum SampleFormat * sample_fmts            */
    NULL                                        /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:53:18
AVCodec h263p_encoder = {
    "h263p",
    CODEC_TYPE_VIDEO,
    CODEC_ID_H263P,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_h263p_encoder[] = {PIX_FMT_YUV420P, PIX_FMT_NONE};
AVCodec h263p_encoder = {
    "h263p",                                                 /* const char * name                                */
    CODEC_TYPE_VIDEO,                                        /* enum CodecType type                              */
    CODEC_ID_H263P,                                          /* enum CodecID id                                  */
    sizeof(MpegEncContext),                                  /* int priv_data_size                               */
    MPV_encode_init,                                         /* int (*init)(AVCodecContext *)                    */
    MPV_encode_picture,                                      /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    MPV_encode_end,                                          /* int (*close)(AVCodecContext *)                   */
    NULL,                                                    /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                                       /* int capabilities                                 */
    NULL,                                                    /* struct AVCodec * next                            */
    NULL,                                                    /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                    /* const AVRational * supported_framerates          */
    _s_PF_h263p_encoder,                                     /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"), /* const char * long_name                           */
    NULL,                                                    /* const int * supported_samplerates                */
    NULL,                                                    /* const enum SampleFormat * sample_fmts            */
    NULL                                                     /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:54:02
AVCodec flv_encoder = {
    "flv",
    CODEC_TYPE_VIDEO,
    CODEC_ID_FLV1,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("Flash Video (FLV)"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_flv_encoder[] = {PIX_FMT_YUV420P, PIX_FMT_NONE};
AVCodec flv_encoder = {
    "flv",                                     /* const char * name                                */
    CODEC_TYPE_VIDEO,                          /* enum CodecType type                              */
    CODEC_ID_FLV1,                             /* enum CodecID id                                  */
    sizeof(MpegEncContext),                    /* int priv_data_size                               */
    MPV_encode_init,                           /* int (*init)(AVCodecContext *)                    */
    MPV_encode_picture,                        /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    MPV_encode_end,                            /* int (*close)(AVCodecContext *)                   */
    NULL,                                      /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                         /* int capabilities                                 */
    NULL,                                      /* struct AVCodec * next                            */
    NULL,                                      /* void (*flush)(AVCodecContext *)                  */
    NULL,                                      /* const AVRational * supported_framerates          */
    _s_PF_flv_encoder,                         /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("Flash Video (FLV)"), /* const char * long_name                           */
    NULL,                                      /* const int * supported_samplerates                */
    NULL,                                      /* const enum SampleFormat * sample_fmts            */
    NULL                                       /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:54:56
AVCodec mpeg4_encoder = {
    "mpeg4",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MPEG4,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
    .capabilities= CODEC_CAP_DELAY,
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_mpeg4_encoder[] = {PIX_FMT_YUV420P, PIX_FMT_NONE};
AVCodec mpeg4_encoder = {
    "mpeg4",                               /* const char * name                                */
    CODEC_TYPE_VIDEO,                      /* enum CodecType type                              */
    CODEC_ID_MPEG4,                        /* enum CodecID id                                  */
    sizeof(MpegEncContext),                /* int priv_data_size                               */
    MPV_encode_init,                       /* int (*init)(AVCodecContext *)                    */
    MPV_encode_picture,                    /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    MPV_encode_end,                        /* int (*close)(AVCodecContext *)                   */
    NULL,                                  /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DELAY,                       /* int capabilities                                 */
    NULL,                                  /* struct AVCodec * next                            */
    NULL,                                  /* void (*flush)(AVCodecContext *)                  */
    NULL,                                  /* const AVRational * supported_framerates          */
    _s_PF_mpeg4_encoder,                   /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("MPEG-4 part 2"), /* const char * long_name                           */
    NULL,                                  /* const int * supported_samplerates                */
    NULL,                                  /* const enum SampleFormat * sample_fmts            */
    NULL                                   /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:55:45
AVCodec msmpeg4v1_encoder = {
    "msmpeg4v1",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MSMPEG4V1,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_msmpeg4v1_encoder[] = {PIX_FMT_YUV420P, PIX_FMT_NONE};
AVCodec msmpeg4v1_encoder = {
    "msmpeg4v1",                                             /* const char * name                                */
    CODEC_TYPE_VIDEO,                                        /* enum CodecType type                              */
    CODEC_ID_MSMPEG4V1,                                      /* enum CodecID id                                  */
    sizeof(MpegEncContext),                                  /* int priv_data_size                               */
    MPV_encode_init,                                         /* int (*init)(AVCodecContext *)                    */
    MPV_encode_picture,                                      /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    MPV_encode_end,                                          /* int (*close)(AVCodecContext *)                   */
    NULL,                                                    /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                                       /* int capabilities                                 */
    NULL,                                                    /* struct AVCodec * next                            */
    NULL,                                                    /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                    /* const AVRational * supported_framerates          */
    _s_PF_msmpeg4v1_encoder,                                 /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"), /* const char * long_name                           */
    NULL,                                                    /* const int * supported_samplerates                */
    NULL,                                                    /* const enum SampleFormat * sample_fmts            */
    NULL                                                     /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:56:28
AVCodec msmpeg4v2_encoder = {
    "msmpeg4v2",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MSMPEG4V2,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_msmpeg4v2_encoder[] = {PIX_FMT_YUV420P, PIX_FMT_NONE};
AVCodec msmpeg4v2_encoder = {
    "msmpeg4v2",                                             /* const char * name                                */
    CODEC_TYPE_VIDEO,                                        /* enum CodecType type                              */
    CODEC_ID_MSMPEG4V2,                                      /* enum CodecID id                                  */
    sizeof(MpegEncContext),                                  /* int priv_data_size                               */
    MPV_encode_init,                                         /* int (*init)(AVCodecContext *)                    */
    MPV_encode_picture,                                      /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    MPV_encode_end,                                          /* int (*close)(AVCodecContext *)                   */
    NULL,                                                    /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                                       /* int capabilities                                 */
    NULL,                                                    /* struct AVCodec * next                            */
    NULL,                                                    /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                    /* const AVRational * supported_framerates          */
    _s_PF_msmpeg4v2_encoder,                                 /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"), /* const char * long_name                           */
    NULL,                                                    /* const int * supported_samplerates                */
    NULL,                                                    /* const enum SampleFormat * sample_fmts            */
    NULL                                                     /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:57:55
AVCodec msmpeg4v3_encoder = {
    "msmpeg4",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MSMPEG4V3,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_msmpeg4v3_encoder[] = {PIX_FMT_YUV420P, PIX_FMT_NONE};
AVCodec msmpeg4v3_encoder = {
    "msmpeg4",                                               /* const char * name                                */
    CODEC_TYPE_VIDEO,                                        /* enum CodecType type                              */
    CODEC_ID_MSMPEG4V3,                                      /* enum CodecID id                                  */
    sizeof(MpegEncContext),                                  /* int priv_data_size                               */
    MPV_encode_init,                                         /* int (*init)(AVCodecContext *)                    */
    MPV_encode_picture,                                      /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    MPV_encode_end,                                          /* int (*close)(AVCodecContext *)                   */
    NULL,                                                    /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                                       /* int capabilities                                 */
    NULL,                                                    /* struct AVCodec * next                            */
    NULL,                                                    /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                    /* const AVRational * supported_framerates          */
    _s_PF_msmpeg4v3_encoder,                                 /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"), /* const char * long_name                           */
    NULL,                                                    /* const int * supported_samplerates                */
    NULL,                                                    /* const enum SampleFormat * sample_fmts            */
    NULL                                                     /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 12:59:46
AVCodec wmv1_encoder = {
    "wmv1",
    CODEC_TYPE_VIDEO,
    CODEC_ID_WMV1,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_wmv1_encoder[] = {PIX_FMT_YUV420P, PIX_FMT_NONE};
AVCodec wmv1_encoder = {
    "wmv1",                                        /* const char * name                                */
    CODEC_TYPE_VIDEO,                              /* enum CodecType type                              */
    CODEC_ID_WMV1,                                 /* enum CodecID id                                  */
    sizeof(MpegEncContext),                        /* int priv_data_size                               */
    MPV_encode_init,                               /* int (*init)(AVCodecContext *)                    */
    MPV_encode_picture,                            /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    MPV_encode_end,                                /* int (*close)(AVCodecContext *)                   */
    NULL,                                          /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                             /* int capabilities                                 */
    NULL,                                          /* struct AVCodec * next                            */
    NULL,                                          /* void (*flush)(AVCodecContext *)                  */
    NULL,                                          /* const AVRational * supported_framerates          */
    _s_PF_wmv1_encoder,                            /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("Windows Media Video 7"), /* const char * long_name                           */
    NULL,                                          /* const int * supported_samplerates                */
    NULL,                                          /* const enum SampleFormat * sample_fmts            */
    NULL                                           /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:01:04
AVCodec pcx_encoder = {
    "pcx",
    CODEC_TYPE_VIDEO,
    CODEC_ID_PCX,
    sizeof(PCXContext),
    pcx_encode_init,
    pcx_encode_frame,
    NULL,
    .pix_fmts = (enum PixelFormat[]){
        PIX_FMT_RGB24,
        PIX_FMT_RGB8, PIX_FMT_BGR8, PIX_FMT_RGB4_BYTE, PIX_FMT_BGR4_BYTE, PIX_FMT_GRAY8, PIX_FMT_PAL8,
        PIX_FMT_MONOBLACK,
        PIX_FMT_NONE},
    .long_name = NULL_IF_CONFIG_SMALL("PC Paintbrush PCX image"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_pcx_encoder[] = { PIX_FMT_RGB24, PIX_FMT_RGB8, PIX_FMT_BGR8, PIX_FMT_RGB4_BYTE, PIX_FMT_BGR4_BYTE, PIX_FMT_GRAY8, PIX_FMT_PAL8, PIX_FMT_MONOBLACK, PIX_FMT_NONE};
AVCodec pcx_encoder = {
    "pcx",                                           /* const char * name                                */
    CODEC_TYPE_VIDEO,                                /* enum CodecType type                              */
    CODEC_ID_PCX,                                    /* enum CodecID id                                  */
    sizeof(PCXContext),                              /* int priv_data_size                               */
    pcx_encode_init,                                 /* int (*init)(AVCodecContext *)                    */
    pcx_encode_frame,                                /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    NULL,                                            /* int (*close)(AVCodecContext *)                   */
    NULL,                                            /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                               /* int capabilities                                 */
    NULL,                                            /* struct AVCodec * next                            */
    NULL,                                            /* void (*flush)(AVCodecContext *)                  */
    NULL,                                            /* const AVRational * supported_framerates          */
    _s_PF_pcx_encoder,                               /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("PC Paintbrush PCX image"), /* const char * long_name                           */
    NULL,                                            /* const int * supported_samplerates                */
    NULL,                                            /* const enum SampleFormat * sample_fmts            */
    NULL                                             /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:02:47
AVCodec png_encoder = {
    "png",
    CODEC_TYPE_VIDEO,
    CODEC_ID_PNG,
    sizeof(PNGEncContext),
    png_enc_init,
    encode_frame,
    NULL, //encode_end,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGB32, PIX_FMT_PAL8, PIX_FMT_GRAY8, PIX_FMT_MONOBLACK, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("PNG image"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_png_encoder[] = {PIX_FMT_RGB24, PIX_FMT_RGB32, PIX_FMT_PAL8, PIX_FMT_GRAY8, PIX_FMT_MONOBLACK, PIX_FMT_NONE};
AVCodec png_encoder = {
    "png",                             /* const char * name                                */
    CODEC_TYPE_VIDEO,                  /* enum CodecType type                              */
    CODEC_ID_PNG,                      /* enum CodecID id                                  */
    sizeof(PNGEncContext),             /* int priv_data_size                               */
    png_enc_init,                      /* int (*init)(AVCodecContext *)                    */
    encode_frame,                      /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    NULL,                              /* int (*close)(AVCodecContext *)                   */
    NULL,                              /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                 /* int capabilities                                 */
    NULL,                              /* struct AVCodec * next                            */
    NULL,                              /* void (*flush)(AVCodecContext *)                  */
    NULL,                              /* const AVRational * supported_framerates          */
    _s_PF_png_encoder,                 /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("PNG image"), /* const char * long_name                           */
    NULL,                              /* const int * supported_samplerates                */
    NULL,                              /* const enum SampleFormat * sample_fmts            */
    NULL                               /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:03:56
AVCodec pgm_decoder = {
    "pgm",
    CODEC_TYPE_VIDEO,
    CODEC_ID_PGM,
    sizeof(PNMContext),
    common_init,
    NULL,
    NULL,
    pnm_decode_frame,
    CODEC_CAP_DR1,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_GRAY8, PIX_FMT_GRAY16BE, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("PGM (Portable GrayMap) image"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_pgm_decoder[] = {PIX_FMT_GRAY8, PIX_FMT_GRAY16BE, PIX_FMT_NONE};
AVCodec pgm_decoder = {
    "pgm",                                                /* const char * name                                */
    CODEC_TYPE_VIDEO,                                     /* enum CodecType type                              */
    CODEC_ID_PGM,                                         /* enum CodecID id                                  */
    sizeof(PNMContext),                                   /* int priv_data_size                               */
    common_init,                                          /* int (*init)(AVCodecContext *)                    */
    NULL,                                                 /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    NULL,                                                 /* int (*close)(AVCodecContext *)                   */
    pnm_decode_frame,                                     /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DR1,                                        /* int capabilities                                 */
    NULL,                                                 /* struct AVCodec * next                            */
    NULL,                                                 /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                 /* const AVRational * supported_framerates          */
    _s_PF_pgm_decoder,                                    /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("PGM (Portable GrayMap) image"), /* const char * long_name                           */
    NULL,                                                 /* const int * supported_samplerates                */
    NULL,                                                 /* const enum SampleFormat * sample_fmts            */
    NULL                                                  /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:04:52
AVCodec pgm_encoder = {
    "pgm",
    CODEC_TYPE_VIDEO,
    CODEC_ID_PGM,
    sizeof(PNMContext),
    common_init,
    pnm_encode_frame,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_GRAY8, PIX_FMT_GRAY16BE, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("PGM (Portable GrayMap) image"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_pgm_encoder[] = {PIX_FMT_GRAY8, PIX_FMT_GRAY16BE, PIX_FMT_NONE};
AVCodec pgm_encoder = {
    "pgm",                                                /* const char * name                                */
    CODEC_TYPE_VIDEO,                                     /* enum CodecType type                              */
    CODEC_ID_PGM,                                         /* enum CodecID id                                  */
    sizeof(PNMContext),                                   /* int priv_data_size                               */
    common_init,                                          /* int (*init)(AVCodecContext *)                    */
    pnm_encode_frame,                                     /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    NULL,                                                 /* int (*close)(AVCodecContext *)                   */
    NULL,                                                 /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                                    /* int capabilities                                 */
    NULL,                                                 /* struct AVCodec * next                            */
    NULL,                                                 /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                 /* const AVRational * supported_framerates          */
    _s_PF_pgm_encoder,                                    /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("PGM (Portable GrayMap) image"), /* const char * long_name                           */
    NULL,                                                 /* const int * supported_samplerates                */
    NULL,                                                 /* const enum SampleFormat * sample_fmts            */
    NULL                                                  /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:05:49
AVCodec pgmyuv_decoder = {
    "pgmyuv",
    CODEC_TYPE_VIDEO,
    CODEC_ID_PGMYUV,
    sizeof(PNMContext),
    common_init,
    NULL,
    NULL,
    pnm_decode_frame,
    CODEC_CAP_DR1,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("PGMYUV (Portable GrayMap YUV) image"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_pgmyuv_decoder[] = {PIX_FMT_YUV420P, PIX_FMT_NONE};
AVCodec pgmyuv_decoder = {
    "pgmyuv",                                                /* const char * name                                */
    CODEC_TYPE_VIDEO,                                        /* enum CodecType type                              */
    CODEC_ID_PGMYUV,                                         /* enum CodecID id                                  */
    sizeof(PNMContext),                                      /* int priv_data_size                               */
    common_init,                                             /* int (*init)(AVCodecContext *)                    */
    NULL,                                                    /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    NULL,                                                    /* int (*close)(AVCodecContext *)                   */
    pnm_decode_frame,                                        /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DR1,                                           /* int capabilities                                 */
    NULL,                                                    /* struct AVCodec * next                            */
    NULL,                                                    /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                    /* const AVRational * supported_framerates          */
    _s_PF_pgmyuv_decoder,                                    /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("PGMYUV (Portable GrayMap YUV) image"), /* const char * long_name                           */
    NULL,                                                    /* const int * supported_samplerates                */
    NULL,                                                    /* const enum SampleFormat * sample_fmts            */
    NULL                                                     /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:06:50
AVCodec pgmyuv_encoder = {
    "pgmyuv",
    CODEC_TYPE_VIDEO,
    CODEC_ID_PGMYUV,
    sizeof(PNMContext),
    common_init,
    pnm_encode_frame,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("PGMYUV (Portable GrayMap YUV) image"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_pgmyuv_encoder[] = {PIX_FMT_YUV420P, PIX_FMT_NONE};
AVCodec pgmyuv_encoder = {
    "pgmyuv",                                                /* const char * name                                */
    CODEC_TYPE_VIDEO,                                        /* enum CodecType type                              */
    CODEC_ID_PGMYUV,                                         /* enum CodecID id                                  */
    sizeof(PNMContext),                                      /* int priv_data_size                               */
    common_init,                                             /* int (*init)(AVCodecContext *)                    */
    pnm_encode_frame,                                        /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    NULL,                                                    /* int (*close)(AVCodecContext *)                   */
    NULL,                                                    /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                                       /* int capabilities                                 */
    NULL,                                                    /* struct AVCodec * next                            */
    NULL,                                                    /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                    /* const AVRational * supported_framerates          */
    _s_PF_pgmyuv_encoder,                                    /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("PGMYUV (Portable GrayMap YUV) image"), /* const char * long_name                           */
    NULL,                                                    /* const int * supported_samplerates                */
    NULL,                                                    /* const enum SampleFormat * sample_fmts            */
    NULL                                                     /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:07:49
AVCodec ppm_decoder = {
    "ppm",
    CODEC_TYPE_VIDEO,
    CODEC_ID_PPM,
    sizeof(PNMContext),
    common_init,
    NULL,
    NULL,
    pnm_decode_frame,
    CODEC_CAP_DR1,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGB48BE, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("PPM (Portable PixelMap) image"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_ppm_decoder[] = {PIX_FMT_RGB24, PIX_FMT_RGB48BE, PIX_FMT_NONE};
AVCodec ppm_decoder = {
    "ppm",                                                 /* const char * name                                */
    CODEC_TYPE_VIDEO,                                      /* enum CodecType type                              */
    CODEC_ID_PPM,                                          /* enum CodecID id                                  */
    sizeof(PNMContext),                                    /* int priv_data_size                               */
    common_init,                                           /* int (*init)(AVCodecContext *)                    */
    NULL,                                                  /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    NULL,                                                  /* int (*close)(AVCodecContext *)                   */
    pnm_decode_frame,                                      /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DR1,                                         /* int capabilities                                 */
    NULL,                                                  /* struct AVCodec * next                            */
    NULL,                                                  /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                  /* const AVRational * supported_framerates          */
    _s_PF_ppm_decoder,                                     /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("PPM (Portable PixelMap) image"), /* const char * long_name                           */
    NULL,                                                  /* const int * supported_samplerates                */
    NULL,                                                  /* const enum SampleFormat * sample_fmts            */
    NULL                                                   /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:08:36
AVCodec ppm_encoder = {
    "ppm",
    CODEC_TYPE_VIDEO,
    CODEC_ID_PPM,
    sizeof(PNMContext),
    common_init,
    pnm_encode_frame,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGB48BE, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("PPM (Portable PixelMap) image"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_ppm_encoder[] = {PIX_FMT_RGB24, PIX_FMT_RGB48BE, PIX_FMT_NONE};
AVCodec ppm_encoder = {
    "ppm",                                                 /* const char * name                                */
    CODEC_TYPE_VIDEO,                                      /* enum CodecType type                              */
    CODEC_ID_PPM,                                          /* enum CodecID id                                  */
    sizeof(PNMContext),                                    /* int priv_data_size                               */
    common_init,                                           /* int (*init)(AVCodecContext *)                    */
    pnm_encode_frame,                                      /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    NULL,                                                  /* int (*close)(AVCodecContext *)                   */
    NULL,                                                  /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                                     /* int capabilities                                 */
    NULL,                                                  /* struct AVCodec * next                            */
    NULL,                                                  /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                  /* const AVRational * supported_framerates          */
    _s_PF_ppm_encoder,                                     /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("PPM (Portable PixelMap) image"), /* const char * long_name                           */
    NULL,                                                  /* const int * supported_samplerates                */
    NULL,                                                  /* const enum SampleFormat * sample_fmts            */
    NULL                                                   /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:09:37
AVCodec pbm_decoder = {
    "pbm",
    CODEC_TYPE_VIDEO,
    CODEC_ID_PBM,
    sizeof(PNMContext),
    common_init,
    NULL,
    NULL,
    pnm_decode_frame,
    CODEC_CAP_DR1,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_MONOWHITE, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("PBM (Portable BitMap) image"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_pbm_decoder[] = {PIX_FMT_MONOWHITE, PIX_FMT_NONE};
AVCodec pbm_decoder = {
    "pbm",                                               /* const char * name                                */
    CODEC_TYPE_VIDEO,                                    /* enum CodecType type                              */
    CODEC_ID_PBM,                                        /* enum CodecID id                                  */
    sizeof(PNMContext),                                  /* int priv_data_size                               */
    common_init,                                         /* int (*init)(AVCodecContext *)                    */
    NULL,                                                /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    NULL,                                                /* int (*close)(AVCodecContext *)                   */
    pnm_decode_frame,                                    /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DR1,                                       /* int capabilities                                 */
    NULL,                                                /* struct AVCodec * next                            */
    NULL,                                                /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                /* const AVRational * supported_framerates          */
    _s_PF_pbm_decoder,                                   /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("PBM (Portable BitMap) image"), /* const char * long_name                           */
    NULL,                                                /* const int * supported_samplerates                */
    NULL,                                                /* const enum SampleFormat * sample_fmts            */
    NULL                                                 /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:10:26
AVCodec pbm_encoder = {
    "pbm",
    CODEC_TYPE_VIDEO,
    CODEC_ID_PBM,
    sizeof(PNMContext),
    common_init,
    pnm_encode_frame,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_MONOWHITE, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("PBM (Portable BitMap) image"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_pbm_encoder[] = {PIX_FMT_MONOWHITE, PIX_FMT_NONE};
AVCodec pbm_encoder = {
    "pbm",                                               /* const char * name                                */
    CODEC_TYPE_VIDEO,                                    /* enum CodecType type                              */
    CODEC_ID_PBM,                                        /* enum CodecID id                                  */
    sizeof(PNMContext),                                  /* int priv_data_size                               */
    common_init,                                         /* int (*init)(AVCodecContext *)                    */
    pnm_encode_frame,                                    /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    NULL,                                                /* int (*close)(AVCodecContext *)                   */
    NULL,                                                /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                                   /* int capabilities                                 */
    NULL,                                                /* struct AVCodec * next                            */
    NULL,                                                /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                /* const AVRational * supported_framerates          */
    _s_PF_pbm_encoder,                                   /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("PBM (Portable BitMap) image"), /* const char * long_name                           */
    NULL,                                                /* const int * supported_samplerates                */
    NULL,                                                /* const enum SampleFormat * sample_fmts            */
    NULL                                                 /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:11:16
AVCodec pam_decoder = {
    "pam",
    CODEC_TYPE_VIDEO,
    CODEC_ID_PAM,
    sizeof(PNMContext),
    common_init,
    NULL,
    NULL,
    pnm_decode_frame,
    CODEC_CAP_DR1,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGB32, PIX_FMT_GRAY8, PIX_FMT_MONOWHITE, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("PAM (Portable AnyMap) image"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_pam_decoder[] = {PIX_FMT_RGB24, PIX_FMT_RGB32, PIX_FMT_GRAY8, PIX_FMT_MONOWHITE, PIX_FMT_NONE};
AVCodec pam_decoder = {
    "pam",                                               /* const char * name                                */
    CODEC_TYPE_VIDEO,                                    /* enum CodecType type                              */
    CODEC_ID_PAM,                                        /* enum CodecID id                                  */
    sizeof(PNMContext),                                  /* int priv_data_size                               */
    common_init,                                         /* int (*init)(AVCodecContext *)                    */
    NULL,                                                /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    NULL,                                                /* int (*close)(AVCodecContext *)                   */
    pnm_decode_frame,                                    /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DR1,                                       /* int capabilities                                 */
    NULL,                                                /* struct AVCodec * next                            */
    NULL,                                                /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                /* const AVRational * supported_framerates          */
    _s_PF_pam_decoder,                                   /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("PAM (Portable AnyMap) image"), /* const char * long_name                           */
    NULL,                                                /* const int * supported_samplerates                */
    NULL,                                                /* const enum SampleFormat * sample_fmts            */
    NULL                                                 /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:12:05
AVCodec pam_encoder = {
    "pam",
    CODEC_TYPE_VIDEO,
    CODEC_ID_PAM,
    sizeof(PNMContext),
    common_init,
    pam_encode_frame,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGB32, PIX_FMT_GRAY8, PIX_FMT_MONOWHITE, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("PAM (Portable AnyMap) image"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_pam_encoder[] = {PIX_FMT_RGB24, PIX_FMT_RGB32, PIX_FMT_GRAY8, PIX_FMT_MONOWHITE, PIX_FMT_NONE};
AVCodec pam_encoder = {
    "pam",                                               /* const char * name                                */
    CODEC_TYPE_VIDEO,                                    /* enum CodecType type                              */
    CODEC_ID_PAM,                                        /* enum CodecID id                                  */
    sizeof(PNMContext),                                  /* int priv_data_size                               */
    common_init,                                         /* int (*init)(AVCodecContext *)                    */
    pam_encode_frame,                                    /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    NULL,                                                /* int (*close)(AVCodecContext *)                   */
    NULL,                                                /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                                   /* int capabilities                                 */
    NULL,                                                /* struct AVCodec * next                            */
    NULL,                                                /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                /* const AVRational * supported_framerates          */
    _s_PF_pam_encoder,                                   /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("PAM (Portable AnyMap) image"), /* const char * long_name                           */
    NULL,                                                /* const int * supported_samplerates                */
    NULL,                                                /* const enum SampleFormat * sample_fmts            */
    NULL                                                 /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:14:08
AVCodec qtrle_encoder = {
    "qtrle",
    CODEC_TYPE_VIDEO,
    CODEC_ID_QTRLE,
    sizeof(QtrleEncContext),
    qtrle_encode_init,
    qtrle_encode_frame,
    qtrle_encode_end,
    .pix_fmts = (enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_ARGB, PIX_FMT_NONE},
    .long_name = NULL_IF_CONFIG_SMALL("QuickTime Animation (RLE) video"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_qtrle_encoder[] = {PIX_FMT_RGB24, PIX_FMT_ARGB, PIX_FMT_NONE};
AVCodec qtrle_encoder = {
    "qtrle",                                                 /* const char * name                                */
    CODEC_TYPE_VIDEO,                                        /* enum CodecType type                              */
    CODEC_ID_QTRLE,                                          /* enum CodecID id                                  */
    sizeof(QtrleEncContext),                                 /* int priv_data_size                               */
    qtrle_encode_init,                                       /* int (*init)(AVCodecContext *)                    */
    qtrle_encode_frame,                                      /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    qtrle_encode_end,                                        /* int (*close)(AVCodecContext *)                   */
    NULL,                                                    /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                                       /* int capabilities                                 */
    NULL,                                                    /* struct AVCodec * next                            */
    NULL,                                                    /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                    /* const AVRational * supported_framerates          */
    _s_PF_qtrle_encoder,                                     /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("QuickTime Animation (RLE) video"), /* const char * long_name                           */
    NULL,                                                    /* const int * supported_samplerates                */
    NULL,                                                    /* const enum SampleFormat * sample_fmts            */
    NULL                                                     /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:15:29
AVCodec roq_encoder =
{
    "roqvideo",
    CODEC_TYPE_VIDEO,
    CODEC_ID_ROQ,
    sizeof(RoqContext),
    roq_encode_init,
    roq_encode_frame,
    roq_encode_end,
    .supported_framerates = (AVRational[]){{30,1}, {0,0}},
    .pix_fmts = (enum PixelFormat[]){PIX_FMT_YUV444P, PIX_FMT_NONE},
    .long_name = NULL_IF_CONFIG_SMALL("id RoQ video"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_roq_encoder[] = {PIX_FMT_YUV444P, PIX_FMT_NONE};
static AVRational _s_AVRational_roq_encoder[] = {{30,1}, {0,0}};
AVCodec roq_encoder ={
    "roqvideo",                           /* const char * name                                */
    CODEC_TYPE_VIDEO,                     /* enum CodecType type                              */
    CODEC_ID_ROQ,                         /* enum CodecID id                                  */
    sizeof(RoqContext),                   /* int priv_data_size                               */
    roq_encode_init,                      /* int (*init)(AVCodecContext *)                    */
    roq_encode_frame,                     /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    roq_encode_end,                       /* int (*close)(AVCodecContext *)                   */
    NULL,                                 /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                    /* int capabilities                                 */
    NULL,                                 /* struct AVCodec * next                            */
    NULL,                                 /* void (*flush)(AVCodecContext *)                  */
    _s_AVRational_roq_encoder,            /* const AVRational * supported_framerates          */
    _s_PF_roq_encoder,                    /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("id RoQ video"), /* const char * long_name                           */
    NULL,                                 /* const int * supported_samplerates                */
    NULL,                                 /* const enum SampleFormat * sample_fmts            */
    NULL                                  /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:16:58
AVCodec rv10_decoder = {
    "rv10",
    CODEC_TYPE_VIDEO,
    CODEC_ID_RV10,
    sizeof(MpegEncContext),
    rv10_decode_init,
    NULL,
    rv10_decode_end,
    rv10_decode_frame,
    CODEC_CAP_DR1,
    .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
    .pix_fmts= ff_pixfmt_list_420,
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec rv10_decoder = {
    "rv10",                                /* const char * name                                */
    CODEC_TYPE_VIDEO,                      /* enum CodecType type                              */
    CODEC_ID_RV10,                         /* enum CodecID id                                  */
    sizeof(MpegEncContext),                /* int priv_data_size                               */
    rv10_decode_init,                      /* int (*init)(AVCodecContext *)                    */
    NULL,                                  /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    rv10_decode_end,                       /* int (*close)(AVCodecContext *)                   */
    rv10_decode_frame,                     /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DR1,                         /* int capabilities                                 */
    NULL,                                  /* struct AVCodec * next                            */
    NULL,                                  /* void (*flush)(AVCodecContext *)                  */
    NULL,                                  /* const AVRational * supported_framerates          */
    ff_pixfmt_list_420,                    /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("RealVideo 1.0"), /* const char * long_name                           */
    NULL,                                  /* const int * supported_samplerates                */
    NULL,                                  /* const enum SampleFormat * sample_fmts            */
    NULL                                   /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:17:51
AVCodec rv20_decoder = {
    "rv20",
    CODEC_TYPE_VIDEO,
    CODEC_ID_RV20,
    sizeof(MpegEncContext),
    rv10_decode_init,
    NULL,
    rv10_decode_end,
    rv10_decode_frame,
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
    .flush= ff_mpeg_flush,
    .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
    .pix_fmts= ff_pixfmt_list_420,
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec rv20_decoder = {
    "rv20",                                /* const char * name                                */
    CODEC_TYPE_VIDEO,                      /* enum CodecType type                              */
    CODEC_ID_RV20,                         /* enum CodecID id                                  */
    sizeof(MpegEncContext),                /* int priv_data_size                               */
    rv10_decode_init,                      /* int (*init)(AVCodecContext *)                    */
    NULL,                                  /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    rv10_decode_end,                       /* int (*close)(AVCodecContext *)                   */
    rv10_decode_frame,                     /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,       /* int capabilities                                 */
    NULL,                                  /* struct AVCodec * next                            */
    ff_mpeg_flush,                         /* void (*flush)(AVCodecContext *)                  */
    NULL,                                  /* const AVRational * supported_framerates          */
    ff_pixfmt_list_420,                    /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("RealVideo 2.0"), /* const char * long_name                           */
    NULL,                                  /* const int * supported_samplerates                */
    NULL,                                  /* const enum SampleFormat * sample_fmts            */
    NULL                                   /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:19:21
AVCodec rv10_encoder = {
    "rv10",
    CODEC_TYPE_VIDEO,
    CODEC_ID_RV10,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_rv10_encoder[] = {PIX_FMT_YUV420P, PIX_FMT_NONE};
AVCodec rv10_encoder = {
    "rv10",                                /* const char * name                                */
    CODEC_TYPE_VIDEO,                      /* enum CodecType type                              */
    CODEC_ID_RV10,                         /* enum CodecID id                                  */
    sizeof(MpegEncContext),                /* int priv_data_size                               */
    MPV_encode_init,                       /* int (*init)(AVCodecContext *)                    */
    MPV_encode_picture,                    /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    MPV_encode_end,                        /* int (*close)(AVCodecContext *)                   */
    NULL,                                  /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                     /* int capabilities                                 */
    NULL,                                  /* struct AVCodec * next                            */
    NULL,                                  /* void (*flush)(AVCodecContext *)                  */
    NULL,                                  /* const AVRational * supported_framerates          */
    _s_PF_rv10_encoder,                    /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("RealVideo 1.0"), /* const char * long_name                           */
    NULL,                                  /* const int * supported_samplerates                */
    NULL,                                  /* const enum SampleFormat * sample_fmts            */
    NULL                                   /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:20:37
AVCodec rv30_decoder = {
    "rv30",
    CODEC_TYPE_VIDEO,
    CODEC_ID_RV30,
    sizeof(RV34DecContext),
    rv30_decode_init,
    NULL,
    ff_rv34_decode_end,
    ff_rv34_decode_frame,
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
    .flush = ff_mpeg_flush,
    .long_name = NULL_IF_CONFIG_SMALL("RealVideo 3.0"),
    .pix_fmts= ff_pixfmt_list_420,
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec rv30_decoder = {
    "rv30",                                /* const char * name                                */
    CODEC_TYPE_VIDEO,                      /* enum CodecType type                              */
    CODEC_ID_RV30,                         /* enum CodecID id                                  */
    sizeof(RV34DecContext),                /* int priv_data_size                               */
    rv30_decode_init,                      /* int (*init)(AVCodecContext *)                    */
    NULL,                                  /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    ff_rv34_decode_end,                    /* int (*close)(AVCodecContext *)                   */
    ff_rv34_decode_frame,                  /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,       /* int capabilities                                 */
    NULL,                                  /* struct AVCodec * next                            */
    ff_mpeg_flush,                         /* void (*flush)(AVCodecContext *)                  */
    NULL,                                  /* const AVRational * supported_framerates          */
    ff_pixfmt_list_420,                    /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("RealVideo 3.0"), /* const char * long_name                           */
    NULL,                                  /* const int * supported_samplerates                */
    NULL,                                  /* const enum SampleFormat * sample_fmts            */
    NULL                                   /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:21:49
AVCodec rv40_decoder = {
    "rv40",
    CODEC_TYPE_VIDEO,
    CODEC_ID_RV40,
    sizeof(RV34DecContext),
    rv40_decode_init,
    NULL,
    ff_rv34_decode_end,
    ff_rv34_decode_frame,
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
    .flush = ff_mpeg_flush,
    .long_name = NULL_IF_CONFIG_SMALL("RealVideo 4.0"),
    .pix_fmts= ff_pixfmt_list_420,
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec rv40_decoder = {
    "rv40",                                /* const char * name                                */
    CODEC_TYPE_VIDEO,                      /* enum CodecType type                              */
    CODEC_ID_RV40,                         /* enum CodecID id                                  */
    sizeof(RV34DecContext),                /* int priv_data_size                               */
    rv40_decode_init,                      /* int (*init)(AVCodecContext *)                    */
    NULL,                                  /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    ff_rv34_decode_end,                    /* int (*close)(AVCodecContext *)                   */
    ff_rv34_decode_frame,                  /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,       /* int capabilities                                 */
    NULL,                                  /* struct AVCodec * next                            */
    ff_mpeg_flush,                         /* void (*flush)(AVCodecContext *)                  */
    NULL,                                  /* const AVRational * supported_framerates          */
    ff_pixfmt_list_420,                    /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("RealVideo 4.0"), /* const char * long_name                           */
    NULL,                                  /* const int * supported_samplerates                */
    NULL,                                  /* const enum SampleFormat * sample_fmts            */
    NULL                                   /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:25:17
AVCodec rv40_decoder = {
    "rv40",
    CODEC_TYPE_VIDEO,
    CODEC_ID_RV40,
    sizeof(RV34DecContext),
    rv40_decode_init,
    NULL,
    ff_rv34_decode_end,
    ff_rv34_decode_frame,
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
    .flush = ff_mpeg_flush,
    .long_name = NULL_IF_CONFIG_SMALL("RealVideo 4.0"),
    .pix_fmts= ff_pixfmt_list_420,
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec rv40_decoder = {
    "rv40",                                /* const char * name                                */
    CODEC_TYPE_VIDEO,                      /* enum CodecType type                              */
    CODEC_ID_RV40,                         /* enum CodecID id                                  */
    sizeof(RV34DecContext),                /* int priv_data_size                               */
    rv40_decode_init,                      /* int (*init)(AVCodecContext *)                    */
    NULL,                                  /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    ff_rv34_decode_end,                    /* int (*close)(AVCodecContext *)                   */
    ff_rv34_decode_frame,                  /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,       /* int capabilities                                 */
    NULL,                                  /* struct AVCodec * next                            */
    ff_mpeg_flush,                         /* void (*flush)(AVCodecContext *)                  */
    NULL,                                  /* const AVRational * supported_framerates          */
    ff_pixfmt_list_420,                    /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("RealVideo 4.0"), /* const char * long_name                           */
    NULL,                                  /* const int * supported_samplerates                */
    NULL,                                  /* const enum SampleFormat * sample_fmts            */
    NULL                                   /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:26:22
AVCodec rv40_decoder = {
    "rv40",
    CODEC_TYPE_VIDEO,
    CODEC_ID_RV40,
    sizeof(RV34DecContext),
    rv40_decode_init,
    NULL,
    ff_rv34_decode_end,
    ff_rv34_decode_frame,
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
    .flush = ff_mpeg_flush,
    .long_name = NULL_IF_CONFIG_SMALL("RealVideo 4.0"),
    .pix_fmts= ff_pixfmt_list_420,
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec rv40_decoder = {
    "rv40",                                /* const char * name                                */
    CODEC_TYPE_VIDEO,                      /* enum CodecType type                              */
    CODEC_ID_RV40,                         /* enum CodecID id                                  */
    sizeof(RV34DecContext),                /* int priv_data_size                               */
    rv40_decode_init,                      /* int (*init)(AVCodecContext *)                    */
    NULL,                                  /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    ff_rv34_decode_end,                    /* int (*close)(AVCodecContext *)                   */
    ff_rv34_decode_frame,                  /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,       /* int capabilities                                 */
    NULL,                                  /* struct AVCodec * next                            */
    ff_mpeg_flush,                         /* void (*flush)(AVCodecContext *)                  */
    NULL,                                  /* const AVRational * supported_framerates          */
    ff_pixfmt_list_420,                    /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("RealVideo 4.0"), /* const char * long_name                           */
    NULL,                                  /* const int * supported_samplerates                */
    NULL,                                  /* const enum SampleFormat * sample_fmts            */
    NULL                                   /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:27:14
AVCodec rv40_decoder = {
    "rv40",
    CODEC_TYPE_VIDEO,
    CODEC_ID_RV40,
    sizeof(RV34DecContext),
    rv40_decode_init,
    NULL,
    ff_rv34_decode_end,
    ff_rv34_decode_frame,
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
    .flush = ff_mpeg_flush,
    .long_name = NULL_IF_CONFIG_SMALL("RealVideo 4.0"),
    .pix_fmts= ff_pixfmt_list_420,
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec rv40_decoder = {
    "rv40",                                /* const char * name                                */
    CODEC_TYPE_VIDEO,                      /* enum CodecType type                              */
    CODEC_ID_RV40,                         /* enum CodecID id                                  */
    sizeof(RV34DecContext),                /* int priv_data_size                               */
    rv40_decode_init,                      /* int (*init)(AVCodecContext *)                    */
    NULL,                                  /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    ff_rv34_decode_end,                    /* int (*close)(AVCodecContext *)                   */
    ff_rv34_decode_frame,                  /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,       /* int capabilities                                 */
    NULL,                                  /* struct AVCodec * next                            */
    ff_mpeg_flush,                         /* void (*flush)(AVCodecContext *)                  */
    NULL,                                  /* const AVRational * supported_framerates          */
    ff_pixfmt_list_420,                    /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("RealVideo 4.0"), /* const char * long_name                           */
    NULL,                                  /* const int * supported_samplerates                */
    NULL,                                  /* const enum SampleFormat * sample_fmts            */
    NULL                                   /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:28:40
AVCodec rv40_decoder = {
    "rv40",
    CODEC_TYPE_VIDEO,
    CODEC_ID_RV40,
    sizeof(RV34DecContext),
    rv40_decode_init,
    NULL,
    ff_rv34_decode_end,
    ff_rv34_decode_frame,
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
    .flush = ff_mpeg_flush,
    .long_name = NULL_IF_CONFIG_SMALL("RealVideo 4.0"),
    .pix_fmts= ff_pixfmt_list_420,
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec rv40_decoder = {
    "rv40",                                /* const char * name                                */
    CODEC_TYPE_VIDEO,                      /* enum CodecType type                              */
    CODEC_ID_RV40,                         /* enum CodecID id                                  */
    sizeof(RV34DecContext),                /* int priv_data_size                               */
    rv40_decode_init,                      /* int (*init)(AVCodecContext *)                    */
    NULL,                                  /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    ff_rv34_decode_end,                    /* int (*close)(AVCodecContext *)                   */
    ff_rv34_decode_frame,                  /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,       /* int capabilities                                 */
    NULL,                                  /* struct AVCodec * next                            */
    ff_mpeg_flush,                         /* void (*flush)(AVCodecContext *)                  */
    NULL,                                  /* const AVRational * supported_framerates          */
    ff_pixfmt_list_420,                    /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("RealVideo 4.0"), /* const char * long_name                           */
    NULL,                                  /* const int * supported_samplerates                */
    NULL,                                  /* const enum SampleFormat * sample_fmts            */
    NULL                                   /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:29:08
AVCodec svq1_encoder = {
    "svq1",
    CODEC_TYPE_VIDEO,
    CODEC_ID_SVQ1,
    sizeof(SVQ1Context),
    svq1_encode_init,
    svq1_encode_frame,
    svq1_encode_end,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_svq1_encoder[] = {PIX_FMT_YUV410P, PIX_FMT_NONE};
AVCodec svq1_encoder = {
    "svq1",                                              /* const char * name                                */
    CODEC_TYPE_VIDEO,                                    /* enum CodecType type                              */
    CODEC_ID_SVQ1,                                       /* enum CodecID id                                  */
    sizeof(SVQ1Context),                                 /* int priv_data_size                               */
    svq1_encode_init,                                    /* int (*init)(AVCodecContext *)                    */
    svq1_encode_frame,                                   /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    svq1_encode_end,                                     /* int (*close)(AVCodecContext *)                   */
    NULL,                                                /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                                   /* int capabilities                                 */
    NULL,                                                /* struct AVCodec * next                            */
    NULL,                                                /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                /* const AVRational * supported_framerates          */
    _s_PF_svq1_encoder,                                  /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1"), /* const char * long_name                           */
    NULL,                                                /* const int * supported_samplerates                */
    NULL,                                                /* const enum SampleFormat * sample_fmts            */
    NULL                                                 /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:30:06
AVCodec svq1_decoder = {
    "svq1",
    CODEC_TYPE_VIDEO,
    CODEC_ID_SVQ1,
    sizeof(MpegEncContext),
    svq1_decode_init,
    NULL,
    svq1_decode_end,
    svq1_decode_frame,
    CODEC_CAP_DR1,
    .flush= ff_mpeg_flush,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_svq1_decoder[] = {PIX_FMT_YUV410P, PIX_FMT_NONE};
AVCodec svq1_decoder = {
    "svq1",                                              /* const char * name                                */
    CODEC_TYPE_VIDEO,                                    /* enum CodecType type                              */
    CODEC_ID_SVQ1,                                       /* enum CodecID id                                  */
    sizeof(MpegEncContext),                              /* int priv_data_size                               */
    svq1_decode_init,                                    /* int (*init)(AVCodecContext *)                    */
    NULL,                                                /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    svq1_decode_end,                                     /* int (*close)(AVCodecContext *)                   */
    svq1_decode_frame,                                   /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DR1,                                       /* int capabilities                                 */
    NULL,                                                /* struct AVCodec * next                            */
    ff_mpeg_flush,                                       /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                /* const AVRational * supported_framerates          */
    _s_PF_svq1_decoder,                                  /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1"), /* const char * long_name                           */
    NULL,                                                /* const int * supported_samplerates                */
    NULL,                                                /* const enum SampleFormat * sample_fmts            */
    NULL                                                 /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:31:03
AVCodec sgi_encoder = {
    "sgi",
    CODEC_TYPE_VIDEO,
    CODEC_ID_SGI,
    sizeof(SgiContext),
    encode_init,
    encode_frame,
    NULL,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGBA, PIX_FMT_GRAY8, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("SGI image"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_sgi_encoder[] = {PIX_FMT_RGB24, PIX_FMT_RGBA, PIX_FMT_GRAY8, PIX_FMT_NONE};
AVCodec sgi_encoder = {
    "sgi",                             /* const char * name                                */
    CODEC_TYPE_VIDEO,                  /* enum CodecType type                              */
    CODEC_ID_SGI,                      /* enum CodecID id                                  */
    sizeof(SgiContext),                /* int priv_data_size                               */
    encode_init,                       /* int (*init)(AVCodecContext *)                    */
    encode_frame,                      /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    NULL,                              /* int (*close)(AVCodecContext *)                   */
    NULL,                              /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                 /* int capabilities                                 */
    NULL,                              /* struct AVCodec * next                            */
    NULL,                              /* void (*flush)(AVCodecContext *)                  */
    NULL,                              /* const AVRational * supported_framerates          */
    _s_PF_sgi_encoder,                 /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("SGI image"), /* const char * long_name                           */
    NULL,                              /* const int * supported_samplerates                */
    NULL,                              /* const enum SampleFormat * sample_fmts            */
    NULL                               /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:32:33
AVCodec targa_encoder = {
    .name = "targa",
    .type = CODEC_TYPE_VIDEO,
    .id = CODEC_ID_TARGA,
    .priv_data_size = sizeof(TargaContext),
    .init = targa_encode_init,
    .encode = targa_encode_frame,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_BGR24, PIX_FMT_RGB555, PIX_FMT_GRAY8, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("Truevision Targa image"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_targa_encoder[] = {PIX_FMT_BGR24, PIX_FMT_RGB555, PIX_FMT_GRAY8, PIX_FMT_NONE};
AVCodec targa_encoder = {
    "targa",                                        /* const char * name                                */
    CODEC_TYPE_VIDEO,                               /* enum CodecType type                              */
    CODEC_ID_TARGA,                                 /* enum CodecID id                                  */
    sizeof(TargaContext),                           /* int priv_data_size                               */
    targa_encode_init,                              /* int (*init)(AVCodecContext *)                    */
    targa_encode_frame,                             /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    NULL,                                           /* int (*close)(AVCodecContext *)                   */
    NULL,                                           /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                              /* int capabilities                                 */
    NULL,                                           /* struct AVCodec * next                            */
    NULL,                                           /* void (*flush)(AVCodecContext *)                  */
    NULL,                                           /* const AVRational * supported_framerates          */
    _s_PF_targa_encoder,                            /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("Truevision Targa image"), /* const char * long_name                           */
    NULL,                                           /* const int * supported_samplerates                */
    NULL,                                           /* const enum SampleFormat * sample_fmts            */
    NULL                                            /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:46:28
AVCodec tiff_encoder = {
    "tiff",
    CODEC_TYPE_VIDEO,
    CODEC_ID_TIFF,
    sizeof(TiffEncoderContext),
    NULL,
    encode_frame,
    NULL,
    NULL,
    0,
    NULL,
    .pix_fmts =
        (enum PixelFormat[]) {PIX_FMT_RGB24, PIX_FMT_PAL8, PIX_FMT_GRAY8,
                              PIX_FMT_MONOBLACK, PIX_FMT_MONOWHITE,
                              PIX_FMT_YUV420P, PIX_FMT_YUV422P,
                              PIX_FMT_YUV444P, PIX_FMT_YUV410P,
                              PIX_FMT_YUV411P,
                              PIX_FMT_NONE},
    .long_name = NULL_IF_CONFIG_SMALL("TIFF image"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_tiff_encoder[] = {PIX_FMT_RGB24, PIX_FMT_PAL8, PIX_FMT_GRAY8, PIX_FMT_MONOBLACK, PIX_FMT_MONOWHITE, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_YUV410P, PIX_FMT_YUV411P, PIX_FMT_NONE};
AVCodec tiff_encoder = {
    "tiff",                             /* const char * name                                */
    CODEC_TYPE_VIDEO,                   /* enum CodecType type                              */
    CODEC_ID_TIFF,                      /* enum CodecID id                                  */
    sizeof(TiffEncoderContext),         /* int priv_data_size                               */
    NULL,                               /* int (*init)(AVCodecContext *)                    */
    encode_frame,                       /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    NULL,                               /* int (*close)(AVCodecContext *)                   */
    NULL,                               /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                  /* int capabilities                                 */
    NULL,                               /* struct AVCodec * next                            */
    NULL,                               /* void (*flush)(AVCodecContext *)                  */
    NULL,                               /* const AVRational * supported_framerates          */
    _s_PF_tiff_encoder,                 /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("TIFF image"), /* const char * long_name                           */
    NULL,                               /* const int * supported_samplerates                */
    NULL,                               /* const enum SampleFormat * sample_fmts            */
    NULL                                /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:53:12
AVCodec tiff_encoder = {
    "tiff",
    CODEC_TYPE_VIDEO,
    CODEC_ID_TIFF,
    sizeof(TiffEncoderContext),
    NULL,
    encode_frame,
    NULL,
    NULL,
    0,
    NULL,
    .pix_fmts =
        (enum PixelFormat[]) {PIX_FMT_RGB24, PIX_FMT_PAL8, PIX_FMT_GRAY8,
                              PIX_FMT_MONOBLACK, PIX_FMT_MONOWHITE,
                              PIX_FMT_YUV420P, PIX_FMT_YUV422P,
                              PIX_FMT_YUV444P, PIX_FMT_YUV410P,
                              PIX_FMT_YUV411P,
                              PIX_FMT_NONE},
    .long_name = NULL_IF_CONFIG_SMALL("TIFF image"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_tiff_encoder[] = {PIX_FMT_RGB24, PIX_FMT_PAL8, PIX_FMT_GRAY8, PIX_FMT_MONOBLACK, PIX_FMT_MONOWHITE, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_YUV410P, PIX_FMT_YUV411P, PIX_FMT_NONE};
AVCodec tiff_encoder = {
    "tiff",                             /* const char * name                                */
    CODEC_TYPE_VIDEO,                   /* enum CodecType type                              */
    CODEC_ID_TIFF,                      /* enum CodecID id                                  */
    sizeof(TiffEncoderContext),         /* int priv_data_size                               */
    NULL,                               /* int (*init)(AVCodecContext *)                    */
    encode_frame,                       /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    NULL,                               /* int (*close)(AVCodecContext *)                   */
    NULL,                               /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                  /* int capabilities                                 */
    NULL,                               /* struct AVCodec * next                            */
    NULL,                               /* void (*flush)(AVCodecContext *)                  */
    NULL,                               /* const AVRational * supported_framerates          */
    _s_PF_tiff_encoder,                 /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("TIFF image"), /* const char * long_name                           */
    NULL,                               /* const int * supported_samplerates                */
    NULL,                               /* const enum SampleFormat * sample_fmts            */
    NULL                                /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:55:09
AVCodec v210_encoder = {
    "v210",
    CODEC_TYPE_VIDEO,
    CODEC_ID_V210,
    0,
    encode_init,
    encode_frame,
    encode_close,
    .pix_fmts = (enum PixelFormat[]){PIX_FMT_YUV422P16, PIX_FMT_NONE},
    .long_name = NULL_IF_CONFIG_SMALL("Uncompressed 4:2:2 10-bit"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_v210_encoder[] = {PIX_FMT_YUV422P16, PIX_FMT_NONE};
AVCodec v210_encoder = {
    "v210",                                            /* const char * name                                */
    CODEC_TYPE_VIDEO,                                  /* enum CodecType type                              */
    CODEC_ID_V210,                                     /* enum CodecID id                                  */
    0,                                                 /* int priv_data_size                               */
    encode_init,                                       /* int (*init)(AVCodecContext *)                    */
    encode_frame,                                      /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    encode_close,                                      /* int (*close)(AVCodecContext *)                   */
    NULL,                                              /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                                 /* int capabilities                                 */
    NULL,                                              /* struct AVCodec * next                            */
    NULL,                                              /* void (*flush)(AVCodecContext *)                  */
    NULL,                                              /* const AVRational * supported_framerates          */
    _s_PF_v210_encoder,                                /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("Uncompressed 4:2:2 10-bit"), /* const char * long_name                           */
    NULL,                                              /* const int * supported_samplerates                */
    NULL,                                              /* const enum SampleFormat * sample_fmts            */
    NULL                                               /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:56:10
AVCodec vc1_decoder = {
    "vc1",
    CODEC_TYPE_VIDEO,
    CODEC_ID_VC1,
    sizeof(VC1Context),
    vc1_decode_init,
    NULL,
    vc1_decode_end,
    vc1_decode_frame,
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
    NULL,
    .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
    .pix_fmts = ff_hwaccel_pixfmt_list_420
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec vc1_decoder = {
    "vc1",                              /* const char * name                                */
    CODEC_TYPE_VIDEO,                   /* enum CodecType type                              */
    CODEC_ID_VC1,                       /* enum CodecID id                                  */
    sizeof(VC1Context),                 /* int priv_data_size                               */
    vc1_decode_init,                    /* int (*init)(AVCodecContext *)                    */
    NULL,                               /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    vc1_decode_end,                     /* int (*close)(AVCodecContext *)                   */
    vc1_decode_frame,                   /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,    /* int capabilities                                 */
    NULL,                               /* struct AVCodec * next                            */
    NULL,                               /* void (*flush)(AVCodecContext *)                  */
    NULL,                               /* const AVRational * supported_framerates          */
    ff_hwaccel_pixfmt_list_420,         /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("SMPTE VC-1"), /* const char * long_name                           */
    NULL,                               /* const int * supported_samplerates                */
    NULL,                               /* const enum SampleFormat * sample_fmts            */
    NULL                                /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:57:02
AVCodec wmv3_decoder = {
    "wmv3",
    CODEC_TYPE_VIDEO,
    CODEC_ID_WMV3,
    sizeof(VC1Context),
    vc1_decode_init,
    NULL,
    vc1_decode_end,
    vc1_decode_frame,
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
    NULL,
    .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
    .pix_fmts = ff_hwaccel_pixfmt_list_420
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec wmv3_decoder = {
    "wmv3",                                        /* const char * name                                */
    CODEC_TYPE_VIDEO,                              /* enum CodecType type                              */
    CODEC_ID_WMV3,                                 /* enum CodecID id                                  */
    sizeof(VC1Context),                            /* int priv_data_size                               */
    vc1_decode_init,                               /* int (*init)(AVCodecContext *)                    */
    NULL,                                          /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    vc1_decode_end,                                /* int (*close)(AVCodecContext *)                   */
    vc1_decode_frame,                              /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,               /* int capabilities                                 */
    NULL,                                          /* struct AVCodec * next                            */
    NULL,                                          /* void (*flush)(AVCodecContext *)                  */
    NULL,                                          /* const AVRational * supported_framerates          */
    ff_hwaccel_pixfmt_list_420,                    /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("Windows Media Video 9"), /* const char * long_name                           */
    NULL,                                          /* const int * supported_samplerates                */
    NULL,                                          /* const enum SampleFormat * sample_fmts            */
    NULL                                           /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:58:00
AVCodec wmv3_vdpau_decoder = {
    "wmv3_vdpau",
    CODEC_TYPE_VIDEO,
    CODEC_ID_WMV3,
    sizeof(VC1Context),
    vc1_decode_init,
    NULL,
    vc1_decode_end,
    vc1_decode_frame,
    CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
    NULL,
    .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
    .pix_fmts = (enum PixelFormat[]){PIX_FMT_VDPAU_WMV3, PIX_FMT_NONE}
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_wmv3_vdpau_decoder[] = {PIX_FMT_VDPAU_WMV3, PIX_FMT_NONE};
AVCodec wmv3_vdpau_decoder = {
    "wmv3_vdpau",                                            /* const char * name                                */
    CODEC_TYPE_VIDEO,                                        /* enum CodecType type                              */
    CODEC_ID_WMV3,                                           /* enum CodecID id                                  */
    sizeof(VC1Context),                                      /* int priv_data_size                               */
    vc1_decode_init,                                         /* int (*init)(AVCodecContext *)                    */
    NULL,                                                    /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    vc1_decode_end,                                          /* int (*close)(AVCodecContext *)                   */
    vc1_decode_frame,                                        /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU, /* int capabilities                                 */
    NULL,                                                    /* struct AVCodec * next                            */
    NULL,                                                    /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                    /* const AVRational * supported_framerates          */
    _s_PF_wmv3_vdpau_decoder,                                /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),     /* const char * long_name                           */
    NULL,                                                    /* const int * supported_samplerates                */
    NULL,                                                    /* const enum SampleFormat * sample_fmts            */
    NULL                                                     /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 13:58:56
AVCodec vc1_vdpau_decoder = {
    "vc1_vdpau",
    CODEC_TYPE_VIDEO,
    CODEC_ID_VC1,
    sizeof(VC1Context),
    vc1_decode_init,
    NULL,
    vc1_decode_end,
    vc1_decode_frame,
    CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
    NULL,
    .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
    .pix_fmts = (enum PixelFormat[]){PIX_FMT_VDPAU_VC1, PIX_FMT_NONE}
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_vc1_vdpau_decoder[] = {PIX_FMT_VDPAU_VC1, PIX_FMT_NONE};
AVCodec vc1_vdpau_decoder = {
    "vc1_vdpau",                                             /* const char * name                                */
    CODEC_TYPE_VIDEO,                                        /* enum CodecType type                              */
    CODEC_ID_VC1,                                            /* enum CodecID id                                  */
    sizeof(VC1Context),                                      /* int priv_data_size                               */
    vc1_decode_init,                                         /* int (*init)(AVCodecContext *)                    */
    NULL,                                                    /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    vc1_decode_end,                                          /* int (*close)(AVCodecContext *)                   */
    vc1_decode_frame,                                        /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU, /* int capabilities                                 */
    NULL,                                                    /* struct AVCodec * next                            */
    NULL,                                                    /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                    /* const AVRational * supported_framerates          */
    _s_PF_vc1_vdpau_decoder,                                 /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),                /* const char * long_name                           */
    NULL,                                                    /* const int * supported_samplerates                */
    NULL,                                                    /* const enum SampleFormat * sample_fmts            */
    NULL                                                     /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 14:00:48
AVCodec wmv2_decoder = {
    "wmv2",
    CODEC_TYPE_VIDEO,
    CODEC_ID_WMV2,
    sizeof(Wmv2Context),
    wmv2_decode_init,
    NULL,
    wmv2_decode_end,
    ff_h263_decode_frame,
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
    .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 8"),
    .pix_fmts= ff_pixfmt_list_420,
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec wmv2_decoder = {
    "wmv2",                                        /* const char * name                                */
    CODEC_TYPE_VIDEO,                              /* enum CodecType type                              */
    CODEC_ID_WMV2,                                 /* enum CodecID id                                  */
    sizeof(Wmv2Context),                           /* int priv_data_size                               */
    wmv2_decode_init,                              /* int (*init)(AVCodecContext *)                    */
    NULL,                                          /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    wmv2_decode_end,                               /* int (*close)(AVCodecContext *)                   */
    ff_h263_decode_frame,                          /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,     /* int capabilities                                 */
    NULL,                                          /* struct AVCodec * next                            */
    NULL,                                          /* void (*flush)(AVCodecContext *)                  */
    NULL,                                          /* const AVRational * supported_framerates          */
    ff_pixfmt_list_420,                            /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("Windows Media Video 8"), /* const char * long_name                           */
    NULL,                                          /* const int * supported_samplerates                */
    NULL,                                          /* const enum SampleFormat * sample_fmts            */
    NULL                                           /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 14:01:45
AVCodec wmv2_encoder = {
    "wmv2",
    CODEC_TYPE_VIDEO,
    CODEC_ID_WMV2,
    sizeof(Wmv2Context),
    wmv2_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
    .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 8"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_wmv2_encoder[] = {PIX_FMT_YUV420P, PIX_FMT_NONE};
AVCodec wmv2_encoder = {
    "wmv2",                                        /* const char * name                                */
    CODEC_TYPE_VIDEO,                              /* enum CodecType type                              */
    CODEC_ID_WMV2,                                 /* enum CodecID id                                  */
    sizeof(Wmv2Context),                           /* int priv_data_size                               */
    wmv2_encode_init,                              /* int (*init)(AVCodecContext *)                    */
    MPV_encode_picture,                            /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    MPV_encode_end,                                /* int (*close)(AVCodecContext *)                   */
    NULL,                                          /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                             /* int capabilities                                 */
    NULL,                                          /* struct AVCodec * next                            */
    NULL,                                          /* void (*flush)(AVCodecContext *)                  */
    NULL,                                          /* const AVRational * supported_framerates          */
    _s_PF_wmv2_encoder,                            /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("Windows Media Video 8"), /* const char * long_name                           */
    NULL,                                          /* const int * supported_samplerates                */
    NULL,                                          /* const enum SampleFormat * sample_fmts            */
    NULL                                           /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 14:02:58
AVCodec zmbv_encoder = {
    "zmbv",
    CODEC_TYPE_VIDEO,
    CODEC_ID_ZMBV,
    sizeof(ZmbvEncContext),
    encode_init,
    encode_frame,
    encode_end,
    .pix_fmts = (enum PixelFormat[]){PIX_FMT_PAL8, PIX_FMT_NONE},
    .long_name = NULL_IF_CONFIG_SMALL("Zip Motion Blocks Video"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_zmbv_encoder[] = {PIX_FMT_PAL8, PIX_FMT_NONE};
AVCodec zmbv_encoder = {
    "zmbv",                                          /* const char * name                                */
    CODEC_TYPE_VIDEO,                                /* enum CodecType type                              */
    CODEC_ID_ZMBV,                                   /* enum CodecID id                                  */
    sizeof(ZmbvEncContext),                          /* int priv_data_size                               */
    encode_init,                                     /* int (*init)(AVCodecContext *)                    */
    encode_frame,                                    /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    encode_end,                                      /* int (*close)(AVCodecContext *)                   */
    NULL,                                            /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                               /* int capabilities                                 */
    NULL,                                            /* struct AVCodec * next                            */
    NULL,                                            /* void (*flush)(AVCodecContext *)                  */
    NULL,                                            /* const AVRational * supported_framerates          */
    _s_PF_zmbv_encoder,                              /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("Zip Motion Blocks Video"), /* const char * long_name                           */
    NULL,                                            /* const int * supported_samplerates                */
    NULL,                                            /* const enum SampleFormat * sample_fmts            */
    NULL                                             /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 16:21:36
AVOutputFormat aiff_muxer = {
    "aiff",
    NULL_IF_CONFIG_SMALL("Audio IFF"),
    "audio/aiff",
    "aif,aiff,afc,aifc",
    sizeof(AIFFOutputContext),
    CODEC_ID_PCM_S16BE,
    CODEC_ID_NONE,
    aiff_write_header,
    aiff_write_packet,
    aiff_write_trailer,
    .codec_tag= (const AVCodecTag* const []){codec_aiff_tags, 0},
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static AVCodecTag _s_AVC_aiff_muxer[] = {codec_aiff_tags, 0};
AVOutputFormat aiff_muxer = {
    "aiff",                            /* const char * name                                */
    NULL_IF_CONFIG_SMALL("Audio IFF"), /* const char * long_name                           */
    "audio/aiff",                      /* const char * mime_type                           */
    "aif,aiff,afc,aifc",               /* const char * extensions                          */
    sizeof(AIFFOutputContext),         /* int priv_data_size                               */
    CODEC_ID_PCM_S16BE,                /* enum CodecID audio_codec                         */
    CODEC_ID_NONE,                     /* enum CodecID video_codec                         */
    aiff_write_header,                 /* int (*write_header)(struct AVFormatContext *)    */
    aiff_write_packet,                 /* int (*write_packet)(struct AVFormatContext *, AVPacket *pkt) */
    aiff_write_trailer,                /* int (*write_trailer)(struct AVFormatContext *)   */
    0,                                 /* int flags                                        */
    NULL,                              /* int (*set_parameters)(struct AVFormatContext *, AVFormatParameters *) */
    NULL,                              /* int (*interleave_packet)(struct AVFormatContext *, AVPacket *out, AVPacket *in, int flush) */
    _s_AVC_aiff_muxer,                 /* const struct AVCodecTag * const * codec_tag      */
    0,                                 /* enum CodecID subtitle_codec                      */
    NULL,                              /* const AVMetadataConv * metadata_conv             */
    NULL                               /* struct AVOutputFormat * next                     */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 17:25:27
AVOutputFormat libnut_muxer = {
    "libnut",
    "nut format",
    "video/x-nut",
    "nut",
    sizeof(NUTContext),
    CODEC_ID_VORBIS,
    CODEC_ID_MPEG4,
    nut_write_header,
    nut_write_packet,
    nut_write_trailer,
    .flags = AVFMT_GLOBALHEADER,
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVOutputFormat libnut_muxer = {
    "libnut",           /* const char * name                                */
    "nut format",       /* const char * long_name                           */
    "video/x-nut",      /* const char * mime_type                           */
    "nut",              /* const char * extensions                          */
    sizeof(NUTContext), /* int priv_data_size                               */
    CODEC_ID_VORBIS,    /* enum CodecID audio_codec                         */
    CODEC_ID_MPEG4,     /* enum CodecID video_codec                         */
    nut_write_header,   /* int (*write_header)(struct AVFormatContext *)    */
    nut_write_packet,   /* int (*write_packet)(struct AVFormatContext *, AVPacket *pkt) */
    nut_write_trailer,  /* int (*write_trailer)(struct AVFormatContext *)   */
    AVFMT_GLOBALHEADER, /* int flags                                        */
    NULL,               /* int (*set_parameters)(struct AVFormatContext *, AVFormatParameters *) */
    NULL,               /* int (*interleave_packet)(struct AVFormatContext *, AVPacket *out, AVPacket *in, int flush) */
    NULL,               /* const struct AVCodecTag * const * codec_tag      */
    CODEC_ID_NONE,      /* enum CodecID subtitle_codec                      */
    NULL,               /* const AVMetadataConv * metadata_conv             */
    NULL                /* struct AVOutputFormat * next                     */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/04 17:29:15
AVOutputFormat nut_muxer = {
    "nut",
    NULL_IF_CONFIG_SMALL("NUT format"),
    "video/x-nut",
    "nut",
    sizeof(NUTContext),
    CODEC_ID_VORBIS,
    CODEC_ID_MPEG4,
    write_header,
    write_packet,
    write_trailer,
    .flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS,
    .codec_tag= (const AVCodecTag* const []){ff_codec_bmp_tags, ff_codec_wav_tags, ff_nut_subtitle_tags, 0},
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static AVCodecTag _s_AVC_nut_muxer[] = {ff_codec_bmp_tags, ff_codec_wav_tags, ff_nut_subtitle_tags, 0};
AVOutputFormat nut_muxer = {
    "nut",                                   /* const char * name                                */
    NULL_IF_CONFIG_SMALL("NUT format"),      /* const char * long_name                           */
    "video/x-nut",                           /* const char * mime_type                           */
    "nut",                                   /* const char * extensions                          */
    sizeof(NUTContext),                      /* int priv_data_size                               */
    CODEC_ID_VORBIS,                         /* enum CodecID audio_codec                         */
    CODEC_ID_MPEG4,                          /* enum CodecID video_codec                         */
    write_header,                            /* int (*write_header)(struct AVFormatContext *)    */
    write_packet,                            /* int (*write_packet)(struct AVFormatContext *, AVPacket *pkt) */
    write_trailer,                           /* int (*write_trailer)(struct AVFormatContext *)   */
    AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS, /* int flags                                        */
    NULL,                                    /* int (*set_parameters)(struct AVFormatContext *, AVFormatParameters *) */
    NULL,                                    /* int (*interleave_packet)(struct AVFormatContext *, AVPacket *out, AVPacket *in, int flush) */
    _s_AVC_nut_muxer,                        /* const struct AVCodecTag * const * codec_tag      */
    CODEC_ID_NONE,                           /* enum CodecID subtitle_codec                      */
    NULL,                                    /* const AVMetadataConv * metadata_conv             */
    NULL                                     /* struct AVOutputFormat * next                     */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/07 17:45:59
AVOutputFormat nut_muxer = {
    "nut",
    NULL_IF_CONFIG_SMALL("NUT format"),
    "video/x-nut",
    "nut",
    sizeof(NUTContext),
    CODEC_ID_VORBIS,
    CODEC_ID_MPEG4,
    write_header,
    write_packet,
    write_trailer,
    .flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS,
    .codec_tag= (const AVCodecTag* const []){ff_codec_bmp_tags, ff_codec_wav_tags, ff_nut_subtitle_tags, 0},
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const AVCodecTag * _s_AVC_nut_muxer[] = {ff_codec_bmp_tags, ff_codec_wav_tags, ff_nut_subtitle_tags, 0};
AVOutputFormat nut_muxer = {
    "nut",                                   /* const char * name                                */
    NULL_IF_CONFIG_SMALL("NUT format"),      /* const char * long_name                           */
    "video/x-nut",                           /* const char * mime_type                           */
    "nut",                                   /* const char * extensions                          */
    sizeof(NUTContext),                      /* int priv_data_size                               */
    CODEC_ID_VORBIS,                         /* enum CodecID audio_codec                         */
    CODEC_ID_MPEG4,                          /* enum CodecID video_codec                         */
    write_header,                            /* int (*write_header)(struct AVFormatContext *)    */
    write_packet,                            /* int (*write_packet)(struct AVFormatContext *, AVPacket *pkt) */
    write_trailer,                           /* int (*write_trailer)(struct AVFormatContext *)   */
    AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS, /* int flags                                        */
    NULL,                                    /* int (*set_parameters)(struct AVFormatContext *, AVFormatParameters *) */
    NULL,                                    /* int (*interleave_packet)(struct AVFormatContext *, AVPacket *out, AVPacket *in, int flush) */
    _s_AVC_nut_muxer,                        /* const struct AVCodecTag * const * codec_tag      */
    CODEC_ID_NONE,                           /* enum CodecID subtitle_codec                      */
    NULL,                                    /* const AVMetadataConv * metadata_conv             */
    NULL                                     /* struct AVOutputFormat * next                     */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/07 17:53:02
AVOutputFormat voc_muxer = {
    "voc",
    NULL_IF_CONFIG_SMALL("Creative Voice file format"),
    "audio/x-voc",
    "voc",
    sizeof(VocEncContext),
    CODEC_ID_PCM_U8,
    CODEC_ID_NONE,
    voc_write_header,
    voc_write_packet,
    voc_write_trailer,
    .codec_tag=(const AVCodecTag* const []){ff_voc_codec_tags, 0},
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const AVCodecTag * _s_AVC_voc_muxer[] = {ff_voc_codec_tags, 0};
AVOutputFormat voc_muxer = {
    "voc",                                              /* const char * name                                */
    NULL_IF_CONFIG_SMALL("Creative Voice file format"), /* const char * long_name                           */
    "audio/x-voc",                                      /* const char * mime_type                           */
    "voc",                                              /* const char * extensions                          */
    sizeof(VocEncContext),                              /* int priv_data_size                               */
    CODEC_ID_PCM_U8,                                    /* enum CodecID audio_codec                         */
    CODEC_ID_NONE,                                      /* enum CodecID video_codec                         */
    voc_write_header,                                   /* int (*write_header)(struct AVFormatContext *)    */
    voc_write_packet,                                   /* int (*write_packet)(struct AVFormatContext *, AVPacket *pkt) */
    voc_write_trailer,                                  /* int (*write_trailer)(struct AVFormatContext *)   */
    0,                                                  /* int flags                                        */
    NULL,                                               /* int (*set_parameters)(struct AVFormatContext *, AVFormatParameters *) */
    NULL,                                               /* int (*interleave_packet)(struct AVFormatContext *, AVPacket *out, AVPacket *in, int flush) */
    _s_AVC_voc_muxer,                                   /* const struct AVCodecTag * const * codec_tag      */
    CODEC_ID_NONE,                                      /* enum CodecID subtitle_codec                      */
    NULL,                                               /* const AVMetadataConv * metadata_conv             */
    NULL                                                /* struct AVOutputFormat * next                     */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/07 17:55:53
AVInputFormat voc_demuxer = {
    "voc",
    NULL_IF_CONFIG_SMALL("Creative Voice file format"),
    sizeof(VocDecContext),
    voc_probe,
    voc_read_header,
    voc_read_packet,
    .codec_tag=(const AVCodecTag* const []){ff_voc_codec_tags, 0},
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const AVCodecTag * _s_AVC_voc_demuxer[] = {ff_voc_codec_tags, 0};
AVInputFormat voc_demuxer = {
    "voc",                                              /* const char * name                                */
    NULL_IF_CONFIG_SMALL("Creative Voice file format"), /* const char * long_name                           */
    sizeof(VocDecContext),                              /* int priv_data_size                               */
    voc_probe,                                          /* int (*read_probe)(AVProbeData *)                 */
    voc_read_header,                                    /* int (*read_header)(struct AVFormatContext *, AVFormatParameters *ap) */
    voc_read_packet,                                    /* int (*read_packet)(struct AVFormatContext *, AVPacket *pkt) */
    NULL,                                               /* int (*read_close)(struct AVFormatContext *)      */
    NULL,                                               /* int (*read_seek)(struct AVFormatContext *, int stream_index, int64_t timestamp, int flags) */
    NULL,                                               /* int64_t (*read_timestamp)(struct AVFormatContext *s, int stream_index, int64_t *pos, int64_t pos_limit) */
    0,                                                  /* int flags                                        */
    NULL,                                               /* const char * extensions                          */
    0,                                                  /* int value                                        */
    NULL,                                               /* int (*read_play)(struct AVFormatContext *)       */
    NULL,                                               /* int (*read_pause)(struct AVFormatContext *)      */
    _s_AVC_voc_demuxer,                                 /* const struct AVCodecTag * const * codec_tag      */
    NULL,                                               /* int (*read_seek2)(struct AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags) */
    NULL,                                               /* const AVMetadataConv * metadata_conv             */
    NULL                                                /* struct AVInputFormat * next                      */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/22 19:15:09

AVCodec vorbis_decoder = {
    "vorbis",
    CODEC_TYPE_AUDIO,
    CODEC_ID_VORBIS,
    sizeof(vorbis_context),
    vorbis_decode_init,
    NULL,
    vorbis_decode_close,
    vorbis_decode_frame,
    .long_name = NULL_IF_CONFIG_SMALL("Vorbis"),
};


#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec vorbis_decoder = {
    "vorbis",                       /* const char * name                                */
    CODEC_TYPE_AUDIO,               /* enum CodecType type                              */
    CODEC_ID_VORBIS,                /* enum CodecID id                                  */
    sizeof(vorbis_context),         /* int priv_data_size                               */
    vorbis_decode_init,             /* int (*init)(AVCodecContext *)                    */
    NULL,                           /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    vorbis_decode_close,            /* int (*close)(AVCodecContext *)                   */
    vorbis_decode_frame,            /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                              /* int capabilities                                 */
    NULL,                           /* struct AVCodec * next                            */
    NULL,                           /* void (*flush)(AVCodecContext *)                  */
    NULL,                           /* const AVRational * supported_framerates          */
    NULL,                           /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("Vorbis"), /* const char * long_name                           */
    NULL,                           /* const int * supported_samplerates                */
    NULL,                           /* const enum SampleFormat * sample_fmts            */
    NULL                            /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/22 19:46:08
AVCodec twinvq_decoder =
{
    "twinvq",
    CODEC_TYPE_AUDIO,
    CODEC_ID_TWINVQ,
    sizeof(TwinContext),
    twin_decode_init,
    NULL,
    twin_decode_close,
    twin_decode_frame,
    .long_name = NULL_IF_CONFIG_SMALL("VQF TwinVQ"),
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
AVCodec twinvq_decoder ={
    "twinvq",                           /* const char * name                                */
    CODEC_TYPE_AUDIO,                   /* enum CodecType type                              */
    CODEC_ID_TWINVQ,                    /* enum CodecID id                                  */
    sizeof(TwinContext),                /* int priv_data_size                               */
    twin_decode_init,                   /* int (*init)(AVCodecContext *)                    */
    NULL,                               /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    twin_decode_close,                  /* int (*close)(AVCodecContext *)                   */
    twin_decode_frame,                  /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    0,                                  /* int capabilities                                 */
    NULL,                               /* struct AVCodec * next                            */
    NULL,                               /* void (*flush)(AVCodecContext *)                  */
    NULL,                               /* const AVRational * supported_framerates          */
    NULL,                               /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("VQF TwinVQ"), /* const char * long_name                           */
    NULL,                               /* const int * supported_samplerates                */
    NULL,                               /* const enum SampleFormat * sample_fmts            */
    NULL                                /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/22 20:07:24
AVCodec svq3_decoder = {
    "svq3",
    CODEC_TYPE_VIDEO,
    CODEC_ID_SVQ3,
    sizeof(H264Context),
    svq3_decode_init,
    NULL,
    decode_end,
    svq3_decode_frame,
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
    .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3"),
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_NONE},
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const enum PixelFormat _s_PF_svq3_decoder[] = {PIX_FMT_YUVJ420P, PIX_FMT_NONE};
AVCodec svq3_decoder = {
    "svq3",                                                  /* const char * name                                */
    CODEC_TYPE_VIDEO,                                        /* enum CodecType type                              */
    CODEC_ID_SVQ3,                                           /* enum CodecID id                                  */
    sizeof(H264Context),                                     /* int priv_data_size                               */
    svq3_decode_init,                                        /* int (*init)(AVCodecContext *)                    */
    NULL,                                                    /* int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data) */
    decode_end,                                              /* int (*close)(AVCodecContext *)                   */
    svq3_decode_frame,                                       /* int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt) */
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY, /* int capabilities                                 */
    NULL,                                                    /* struct AVCodec * next                            */
    NULL,                                                    /* void (*flush)(AVCodecContext *)                  */
    NULL,                                                    /* const AVRational * supported_framerates          */
    _s_PF_svq3_decoder,                                      /* const enum PixelFormat * pix_fmts                */
    NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3"),     /* const char * long_name                           */
    NULL,                                                    /* const int * supported_samplerates                */
    NULL,                                                    /* const enum SampleFormat * sample_fmts            */
    NULL                                                     /* const int64_t * channel_layouts                  */
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/25 18:19:08
static const DVprofile dv_profiles[] = {
    { .dsf = 0,
      .video_stype = 0x0,
      .frame_size = 120000,        /* IEC 61834, SMPTE-314M - 525/60 (NTSC) */
      .difseg_size = 10,
      .n_difchan = 1,
      .time_base = { 1001, 30000 },
      .ltc_divisor = 30,
      .height = 480,
      .width = 720,
      .sar = {{10, 11}, {40, 33}},
      .work_chunks = &work_chunks_dv25ntsc[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV411P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 90,
      .audio_min_samples  = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
      .audio_shuffle = dv_audio_shuffle525,
    },
    { .dsf = 1,
      .video_stype = 0x0,
      .frame_size = 144000,        /* IEC 61834 - 625/50 (PAL) */
      .difseg_size = 12,
      .n_difchan = 1,
      .time_base = { 1, 25 },
      .ltc_divisor = 25,
      .height = 576,
      .width = 720,
      .sar = {{59, 54}, {118, 81}},
      .work_chunks = &work_chunks_dv25pal[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV420P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 108,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    },
    { .dsf = 1,
      .video_stype = 0x0,
      .frame_size = 144000,        /* SMPTE-314M - 625/50 (PAL) */
      .difseg_size = 12,
      .n_difchan = 1,
      .time_base = { 1, 25 },
      .ltc_divisor = 25,
      .height = 576,
      .width = 720,
      .sar = {{59, 54}, {118, 81}},
      .work_chunks = &work_chunks_dv25pal411[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV411P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 108,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    },
    { .dsf = 0,
      .video_stype = 0x4,
      .frame_size = 240000,        /* SMPTE-314M - 525/60 (NTSC) 50 Mbps */
      .difseg_size = 10,           /* also known as "DVCPRO50" */
      .n_difchan = 2,
      .time_base = { 1001, 30000 },
      .ltc_divisor = 30,
      .height = 480,
      .width = 720,
      .sar = {{10, 11}, {40, 33}},
      .work_chunks = &work_chunks_dv50ntsc[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 90,
      .audio_min_samples  = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
      .audio_shuffle = dv_audio_shuffle525,
    },
    { .dsf = 1,
      .video_stype = 0x4,
      .frame_size = 288000,        /* SMPTE-314M - 625/50 (PAL) 50 Mbps */
      .difseg_size = 12,           /* also known as "DVCPRO50" */
      .n_difchan = 2,
      .time_base = { 1, 25 },
      .ltc_divisor = 25,
      .height = 576,
      .width = 720,
      .sar = {{59, 54}, {118, 81}},
      .work_chunks = &work_chunks_dv50pal[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 108,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    },
    { .dsf = 0,
      .video_stype = 0x14,
      .frame_size = 480000,        /* SMPTE-370M - 1080i60 100 Mbps */
      .difseg_size = 10,           /* also known as "DVCPRO HD" */
      .n_difchan = 4,
      .time_base = { 1001, 30000 },
      .ltc_divisor = 30,
      .height = 1080,
      .width = 1280,
      .sar = {{1, 1}, {1, 1}},
      .work_chunks = &work_chunks_dv100ntsci[0],
      .idct_factor = &dv_idct_factor_hd1080[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 8,
      .block_sizes = block_sizes_dv100,
      .audio_stride = 90,
      .audio_min_samples  = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
      .audio_shuffle = dv_audio_shuffle525,
    },
    { .dsf = 1,
      .video_stype = 0x14,
      .frame_size = 576000,        /* SMPTE-370M - 1080i50 100 Mbps */
      .difseg_size = 12,           /* also known as "DVCPRO HD" */
      .n_difchan = 4,
      .time_base = { 1, 25 },
      .ltc_divisor = 25,
      .height = 1080,
      .width = 1440,
      .sar = {{1, 1}, {1, 1}},
      .work_chunks = &work_chunks_dv100pali[0],
      .idct_factor = &dv_idct_factor_hd1080[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 8,
      .block_sizes = block_sizes_dv100,
      .audio_stride = 108,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    },
    { .dsf = 0,
      .video_stype = 0x18,
      .frame_size = 240000,        /* SMPTE-370M - 720p60 100 Mbps */
      .difseg_size = 10,           /* also known as "DVCPRO HD" */
      .n_difchan = 2,
      .time_base = { 1001, 60000 },
      .ltc_divisor = 60,
      .height = 720,
      .width = 960,
      .sar = {{1, 1}, {1, 1}},
      .work_chunks = &work_chunks_dv100ntscp[0],
      .idct_factor = &dv_idct_factor_hd720[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 8,
      .block_sizes = block_sizes_dv100,
      .audio_stride = 90,
      .audio_min_samples  = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
      .audio_shuffle = dv_audio_shuffle525,
    },
    { .dsf = 1,
      .video_stype = 0x18,
      .frame_size = 288000,        /* SMPTE-370M - 720p50 100 Mbps */
      .difseg_size = 12,           /* also known as "DVCPRO HD" */
      .n_difchan = 2,
      .time_base = { 1, 50 },
      .ltc_divisor = 50,
      .height = 720,
      .width = 960,
      .sar = {{1, 1}, {1, 1}},
      .work_chunks = &work_chunks_dv100palp[0],
      .idct_factor = &dv_idct_factor_hd720[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 8,
      .block_sizes = block_sizes_dv100,
      .audio_stride = 90,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    }
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const DVprofile dv_profiles[] = {
   { /* block = 1 */
       0,                     /* int dsf ; int video_stype         */
       120000,                /* int frame_size                    */
       10,                    /* int difseg_size                   */
       1,                     /* int n_difchan                     */
       { 1001,                /* AVRational time_base              */
       0,                     /* int ltc_divisor                   */
       480,                   /* int height                        */
       720,                   /* int width                         */
       {{10,                  /* AVRational sar[2]                 */
       NULL,                  /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV411P,       /* enum PixelFormat pix_fmt          */
       6,                     /* int bpm                           */
       block_sizes_dv2550,    /* const uint8_t * block_sizes       */
       90,                    /* int audio_stride                  */
       { 1580,                /* int audio_min_samples[3]          */
       0,                     /* int audio_samples_dist[5]         */
       0                      /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 2 */   
       0,                     /* int dsf ; int video_stype         */
       144000,                /* int frame_size                    */
       12,                    /* int difseg_size                   */
       1,                     /* int n_difchan                     */
       { 1,                   /* AVRational time_base              */
       0,                     /* int ltc_divisor                   */
       576,                   /* int height                        */
       720,                   /* int width                         */
       {{59,                  /* AVRational sar[2]                 */
       NULL,                  /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV420P,       /* enum PixelFormat pix_fmt          */
       6,                     /* int bpm                           */
       block_sizes_dv2550,    /* const uint8_t * block_sizes       */
       108,                   /* int audio_stride                  */
       { 1896,                /* int audio_min_samples[3]          */
       0,                     /* int audio_samples_dist[5]         */
       0                      /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 3 */   
       0,                     /* int dsf ; int video_stype         */
       144000,                /* int frame_size                    */
       12,                    /* int difseg_size                   */
       1,                     /* int n_difchan                     */
       { 1,                   /* AVRational time_base              */
       0,                     /* int ltc_divisor                   */
       576,                   /* int height                        */
       720,                   /* int width                         */
       {{59,                  /* AVRational sar[2]                 */
       NULL,                  /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV411P,       /* enum PixelFormat pix_fmt          */
       6,                     /* int bpm                           */
       block_sizes_dv2550,    /* const uint8_t * block_sizes       */
       108,                   /* int audio_stride                  */
       { 1896,                /* int audio_min_samples[3]          */
       0,                     /* int audio_samples_dist[5]         */
       0                      /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 4 */   
       0,                     /* int dsf ; int video_stype         */
       240000,                /* int frame_size                    */
       10,                    /* int difseg_size                   */
       2,                     /* int n_difchan                     */
       { 1001,                /* AVRational time_base              */
       0,                     /* int ltc_divisor                   */
       480,                   /* int height                        */
       720,                   /* int width                         */
       {{10,                  /* AVRational sar[2]                 */
       NULL,                  /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,       /* enum PixelFormat pix_fmt          */
       6,                     /* int bpm                           */
       block_sizes_dv2550,    /* const uint8_t * block_sizes       */
       90,                    /* int audio_stride                  */
       { 1580,                /* int audio_min_samples[3]          */
       0,                     /* int audio_samples_dist[5]         */
       0                      /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 5 */   
       0,                     /* int dsf ; int video_stype         */
       288000,                /* int frame_size                    */
       12,                    /* int difseg_size                   */
       2,                     /* int n_difchan                     */
       { 1,                   /* AVRational time_base              */
       0,                     /* int ltc_divisor                   */
       576,                   /* int height                        */
       720,                   /* int width                         */
       {{59,                  /* AVRational sar[2]                 */
       NULL,                  /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,       /* enum PixelFormat pix_fmt          */
       6,                     /* int bpm                           */
       block_sizes_dv2550,    /* const uint8_t * block_sizes       */
       108,                   /* int audio_stride                  */
       { 1896,                /* int audio_min_samples[3]          */
       0,                     /* int audio_samples_dist[5]         */
       0                      /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 6 */   
       0,                         /* int dsf ; int video_stype         */
       480000,                    /* int frame_size                    */
       10,                        /* int difseg_size                   */
       4,                         /* int n_difchan                     */
       { 1001,                    /* AVRational time_base              */
       0,                         /* int ltc_divisor                   */
       1080,                      /* int height                        */
       1280,                      /* int width                         */
       {{1,                       /* AVRational sar[2]                 */
       NULL,                      /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_hd1080[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,           /* enum PixelFormat pix_fmt          */
       8,                         /* int bpm                           */
       block_sizes_dv100,         /* const uint8_t * block_sizes       */
       90,                        /* int audio_stride                  */
       { 1580,                    /* int audio_min_samples[3]          */
       0,                         /* int audio_samples_dist[5]         */
       0                          /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 7 */   
       0,                         /* int dsf ; int video_stype         */
       576000,                    /* int frame_size                    */
       12,                        /* int difseg_size                   */
       4,                         /* int n_difchan                     */
       { 1,                       /* AVRational time_base              */
       0,                         /* int ltc_divisor                   */
       1080,                      /* int height                        */
       1440,                      /* int width                         */
       {{1,                       /* AVRational sar[2]                 */
       NULL,                      /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_hd1080[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,           /* enum PixelFormat pix_fmt          */
       8,                         /* int bpm                           */
       block_sizes_dv100,         /* const uint8_t * block_sizes       */
       108,                       /* int audio_stride                  */
       { 1896,                    /* int audio_min_samples[3]          */
       0,                         /* int audio_samples_dist[5]         */
       0                          /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 8 */   
       0,                        /* int dsf ; int video_stype         */
       240000,                   /* int frame_size                    */
       10,                       /* int difseg_size                   */
       2,                        /* int n_difchan                     */
       { 1001,                   /* AVRational time_base              */
       0,                        /* int ltc_divisor                   */
       720,                      /* int height                        */
       960,                      /* int width                         */
       {{1,                      /* AVRational sar[2]                 */
       NULL,                     /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_hd720[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,          /* enum PixelFormat pix_fmt          */
       8,                        /* int bpm                           */
       block_sizes_dv100,        /* const uint8_t * block_sizes       */
       90,                       /* int audio_stride                  */
       { 1580,                   /* int audio_min_samples[3]          */
       0,                        /* int audio_samples_dist[5]         */
       0                         /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 9 */   
       0,                        /* int dsf ; int video_stype         */
       288000,                   /* int frame_size                    */
       12,                       /* int difseg_size                   */
       2,                        /* int n_difchan                     */
       { 1,                      /* AVRational time_base              */
       0,                        /* int ltc_divisor                   */
       720,                      /* int height                        */
       960,                      /* int width                         */
       {{1,                      /* AVRational sar[2]                 */
       NULL,                     /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_hd720[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,          /* enum PixelFormat pix_fmt          */
       8,                        /* int bpm                           */
       block_sizes_dv100,        /* const uint8_t * block_sizes       */
       90,                       /* int audio_stride                  */
       { 1896,                   /* int audio_min_samples[3]          */
       0,                        /* int audio_samples_dist[5]         */
       0                         /* const uint8_t (*audio_shuffle)[9] */
   }
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/25 18:29:40
static const DVprofile dv_profiles[] = {
    { .dsf = 0,
      .video_stype = 0x0,
      .frame_size = 120000,        /* IEC 61834, SMPTE-314M - 525/60 (NTSC) */
      .difseg_size = 10,
      .n_difchan = 1,
      .time_base = { 1001, 30000 },
      .ltc_divisor = 30,
      .height = 480,
      .width = 720,
      .sar = {{10, 11}, {40, 33}},
      .work_chunks = &work_chunks_dv25ntsc[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV411P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 90,
      .audio_min_samples  = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
      .audio_shuffle = dv_audio_shuffle525,
    },
    { .dsf = 1,
      .video_stype = 0x0,
      .frame_size = 144000,        /* IEC 61834 - 625/50 (PAL) */
      .difseg_size = 12,
      .n_difchan = 1,
      .time_base = { 1, 25 },
      .ltc_divisor = 25,
      .height = 576,
      .width = 720,
      .sar = {{59, 54}, {118, 81}},
      .work_chunks = &work_chunks_dv25pal[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV420P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 108,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    },
    { .dsf = 1,
      .video_stype = 0x0,
      .frame_size = 144000,        /* SMPTE-314M - 625/50 (PAL) */
      .difseg_size = 12,
      .n_difchan = 1,
      .time_base = { 1, 25 },
      .ltc_divisor = 25,
      .height = 576,
      .width = 720,
      .sar = {{59, 54}, {118, 81}},
      .work_chunks = &work_chunks_dv25pal411[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV411P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 108,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    },
    { .dsf = 0,
      .video_stype = 0x4,
      .frame_size = 240000,        /* SMPTE-314M - 525/60 (NTSC) 50 Mbps */
      .difseg_size = 10,           /* also known as "DVCPRO50" */
      .n_difchan = 2,
      .time_base = { 1001, 30000 },
      .ltc_divisor = 30,
      .height = 480,
      .width = 720,
      .sar = {{10, 11}, {40, 33}},
      .work_chunks = &work_chunks_dv50ntsc[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 90,
      .audio_min_samples  = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
      .audio_shuffle = dv_audio_shuffle525,
    },
    { .dsf = 1,
      .video_stype = 0x4,
      .frame_size = 288000,        /* SMPTE-314M - 625/50 (PAL) 50 Mbps */
      .difseg_size = 12,           /* also known as "DVCPRO50" */
      .n_difchan = 2,
      .time_base = { 1, 25 },
      .ltc_divisor = 25,
      .height = 576,
      .width = 720,
      .sar = {{59, 54}, {118, 81}},
      .work_chunks = &work_chunks_dv50pal[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 108,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    },
    { .dsf = 0,
      .video_stype = 0x14,
      .frame_size = 480000,        /* SMPTE-370M - 1080i60 100 Mbps */
      .difseg_size = 10,           /* also known as "DVCPRO HD" */
      .n_difchan = 4,
      .time_base = { 1001, 30000 },
      .ltc_divisor = 30,
      .height = 1080,
      .width = 1280,
      .sar = {{1, 1}, {1, 1}},
      .work_chunks = &work_chunks_dv100ntsci[0],
      .idct_factor = &dv_idct_factor_hd1080[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 8,
      .block_sizes = block_sizes_dv100,
      .audio_stride = 90,
      .audio_min_samples  = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
      .audio_shuffle = dv_audio_shuffle525,
    },
    { .dsf = 1,
      .video_stype = 0x14,
      .frame_size = 576000,        /* SMPTE-370M - 1080i50 100 Mbps */
      .difseg_size = 12,           /* also known as "DVCPRO HD" */
      .n_difchan = 4,
      .time_base = { 1, 25 },
      .ltc_divisor = 25,
      .height = 1080,
      .width = 1440,
      .sar = {{1, 1}, {1, 1}},
      .work_chunks = &work_chunks_dv100pali[0],
      .idct_factor = &dv_idct_factor_hd1080[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 8,
      .block_sizes = block_sizes_dv100,
      .audio_stride = 108,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    },
    { .dsf = 0,
      .video_stype = 0x18,
      .frame_size = 240000,        /* SMPTE-370M - 720p60 100 Mbps */
      .difseg_size = 10,           /* also known as "DVCPRO HD" */
      .n_difchan = 2,
      .time_base = { 1001, 60000 },
      .ltc_divisor = 60,
      .height = 720,
      .width = 960,
      .sar = {{1, 1}, {1, 1}},
      .work_chunks = &work_chunks_dv100ntscp[0],
      .idct_factor = &dv_idct_factor_hd720[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 8,
      .block_sizes = block_sizes_dv100,
      .audio_stride = 90,
      .audio_min_samples  = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
      .audio_shuffle = dv_audio_shuffle525,
    },
    { .dsf = 1,
      .video_stype = 0x18,
      .frame_size = 288000,        /* SMPTE-370M - 720p50 100 Mbps */
      .difseg_size = 12,           /* also known as "DVCPRO HD" */
      .n_difchan = 2,
      .time_base = { 1, 50 },
      .ltc_divisor = 50,
      .height = 720,
      .width = 960,
      .sar = {{1, 1}, {1, 1}},
      .work_chunks = &work_chunks_dv100palp[0],
      .idct_factor = &dv_idct_factor_hd720[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 8,
      .block_sizes = block_sizes_dv100,
      .audio_stride = 90,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    }
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const DVprofile dv_profiles[] = {
   { /* block = 1 */
       0,                     /* int dsf ; int video_stype         */
       120000,                /* int frame_size                    */
       10,                    /* int difseg_size                   */
       1,                     /* int n_difchan                     */
       { 1001,                /* AVRational time_base              */
       0,                     /* int ltc_divisor                   */
       480,                   /* int height                        */
       720,                   /* int width                         */
       {{10,                  /* AVRational sar[2]                 */
       NULL,                  /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV411P,       /* enum PixelFormat pix_fmt          */
       6,                     /* int bpm                           */
       block_sizes_dv2550,    /* const uint8_t * block_sizes       */
       90,                    /* int audio_stride                  */
       { 1580,                /* int audio_min_samples[3]          */
       0,                     /* int audio_samples_dist[5]         */
       0                      /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 2 */   
       0,                     /* int dsf ; int video_stype         */
       144000,                /* int frame_size                    */
       12,                    /* int difseg_size                   */
       1,                     /* int n_difchan                     */
       { 1,                   /* AVRational time_base              */
       0,                     /* int ltc_divisor                   */
       576,                   /* int height                        */
       720,                   /* int width                         */
       {{59,                  /* AVRational sar[2]                 */
       NULL,                  /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV420P,       /* enum PixelFormat pix_fmt          */
       6,                     /* int bpm                           */
       block_sizes_dv2550,    /* const uint8_t * block_sizes       */
       108,                   /* int audio_stride                  */
       { 1896,                /* int audio_min_samples[3]          */
       0,                     /* int audio_samples_dist[5]         */
       0                      /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 3 */   
       0,                     /* int dsf ; int video_stype         */
       144000,                /* int frame_size                    */
       12,                    /* int difseg_size                   */
       1,                     /* int n_difchan                     */
       { 1,                   /* AVRational time_base              */
       0,                     /* int ltc_divisor                   */
       576,                   /* int height                        */
       720,                   /* int width                         */
       {{59,                  /* AVRational sar[2]                 */
       NULL,                  /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV411P,       /* enum PixelFormat pix_fmt          */
       6,                     /* int bpm                           */
       block_sizes_dv2550,    /* const uint8_t * block_sizes       */
       108,                   /* int audio_stride                  */
       { 1896,                /* int audio_min_samples[3]          */
       0,                     /* int audio_samples_dist[5]         */
       0                      /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 4 */   
       0,                     /* int dsf ; int video_stype         */
       240000,                /* int frame_size                    */
       10,                    /* int difseg_size                   */
       2,                     /* int n_difchan                     */
       { 1001,                /* AVRational time_base              */
       0,                     /* int ltc_divisor                   */
       480,                   /* int height                        */
       720,                   /* int width                         */
       {{10,                  /* AVRational sar[2]                 */
       NULL,                  /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,       /* enum PixelFormat pix_fmt          */
       6,                     /* int bpm                           */
       block_sizes_dv2550,    /* const uint8_t * block_sizes       */
       90,                    /* int audio_stride                  */
       { 1580,                /* int audio_min_samples[3]          */
       0,                     /* int audio_samples_dist[5]         */
       0                      /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 5 */   
       0,                     /* int dsf ; int video_stype         */
       288000,                /* int frame_size                    */
       12,                    /* int difseg_size                   */
       2,                     /* int n_difchan                     */
       { 1,                   /* AVRational time_base              */
       0,                     /* int ltc_divisor                   */
       576,                   /* int height                        */
       720,                   /* int width                         */
       {{59,                  /* AVRational sar[2]                 */
       NULL,                  /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,       /* enum PixelFormat pix_fmt          */
       6,                     /* int bpm                           */
       block_sizes_dv2550,    /* const uint8_t * block_sizes       */
       108,                   /* int audio_stride                  */
       { 1896,                /* int audio_min_samples[3]          */
       0,                     /* int audio_samples_dist[5]         */
       0                      /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 6 */   
       0,                         /* int dsf ; int video_stype         */
       480000,                    /* int frame_size                    */
       10,                        /* int difseg_size                   */
       4,                         /* int n_difchan                     */
       { 1001,                    /* AVRational time_base              */
       0,                         /* int ltc_divisor                   */
       1080,                      /* int height                        */
       1280,                      /* int width                         */
       {{1,                       /* AVRational sar[2]                 */
       NULL,                      /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_hd1080[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,           /* enum PixelFormat pix_fmt          */
       8,                         /* int bpm                           */
       block_sizes_dv100,         /* const uint8_t * block_sizes       */
       90,                        /* int audio_stride                  */
       { 1580,                    /* int audio_min_samples[3]          */
       0,                         /* int audio_samples_dist[5]         */
       0                          /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 7 */   
       0,                         /* int dsf ; int video_stype         */
       576000,                    /* int frame_size                    */
       12,                        /* int difseg_size                   */
       4,                         /* int n_difchan                     */
       { 1,                       /* AVRational time_base              */
       0,                         /* int ltc_divisor                   */
       1080,                      /* int height                        */
       1440,                      /* int width                         */
       {{1,                       /* AVRational sar[2]                 */
       NULL,                      /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_hd1080[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,           /* enum PixelFormat pix_fmt          */
       8,                         /* int bpm                           */
       block_sizes_dv100,         /* const uint8_t * block_sizes       */
       108,                       /* int audio_stride                  */
       { 1896,                    /* int audio_min_samples[3]          */
       0,                         /* int audio_samples_dist[5]         */
       0                          /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 8 */   
       0,                        /* int dsf ; int video_stype         */
       240000,                   /* int frame_size                    */
       10,                       /* int difseg_size                   */
       2,                        /* int n_difchan                     */
       { 1001,                   /* AVRational time_base              */
       0,                        /* int ltc_divisor                   */
       720,                      /* int height                        */
       960,                      /* int width                         */
       {{1,                      /* AVRational sar[2]                 */
       NULL,                     /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_hd720[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,          /* enum PixelFormat pix_fmt          */
       8,                        /* int bpm                           */
       block_sizes_dv100,        /* const uint8_t * block_sizes       */
       90,                       /* int audio_stride                  */
       { 1580,                   /* int audio_min_samples[3]          */
       0,                        /* int audio_samples_dist[5]         */
       0                         /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 9 */   
       0,                        /* int dsf ; int video_stype         */
       288000,                   /* int frame_size                    */
       12,                       /* int difseg_size                   */
       2,                        /* int n_difchan                     */
       { 1,                      /* AVRational time_base              */
       0,                        /* int ltc_divisor                   */
       720,                      /* int height                        */
       960,                      /* int width                         */
       {{1,                      /* AVRational sar[2]                 */
       NULL,                     /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_hd720[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,          /* enum PixelFormat pix_fmt          */
       8,                        /* int bpm                           */
       block_sizes_dv100,        /* const uint8_t * block_sizes       */
       90,                       /* int audio_stride                  */
       { 1896,                   /* int audio_min_samples[3]          */
       0,                        /* int audio_samples_dist[5]         */
       0                         /* const uint8_t (*audio_shuffle)[9] */
   }
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/25 18:35:18
static const DVprofile dv_profiles[] = {
    { .dsf = 0,
      .video_stype = 0x0,
      .frame_size = 120000,        /* IEC 61834, SMPTE-314M - 525/60 (NTSC) */
      .difseg_size = 10,
      .n_difchan = 1,
      .time_base = { 1001, 30000 },
      .ltc_divisor = 30,
      .height = 480,
      .width = 720,
      .sar = {{10, 11}, {40, 33}},
      .work_chunks = &work_chunks_dv25ntsc[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV411P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 90,
      .audio_min_samples  = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
      .audio_shuffle = dv_audio_shuffle525,
    },
    { .dsf = 1,
      .video_stype = 0x0,
      .frame_size = 144000,        /* IEC 61834 - 625/50 (PAL) */
      .difseg_size = 12,
      .n_difchan = 1,
      .time_base = { 1, 25 },
      .ltc_divisor = 25,
      .height = 576,
      .width = 720,
      .sar = {{59, 54}, {118, 81}},
      .work_chunks = &work_chunks_dv25pal[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV420P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 108,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    },
    { .dsf = 1,
      .video_stype = 0x0,
      .frame_size = 144000,        /* SMPTE-314M - 625/50 (PAL) */
      .difseg_size = 12,
      .n_difchan = 1,
      .time_base = { 1, 25 },
      .ltc_divisor = 25,
      .height = 576,
      .width = 720,
      .sar = {{59, 54}, {118, 81}},
      .work_chunks = &work_chunks_dv25pal411[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV411P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 108,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    },
    { .dsf = 0,
      .video_stype = 0x4,
      .frame_size = 240000,        /* SMPTE-314M - 525/60 (NTSC) 50 Mbps */
      .difseg_size = 10,           /* also known as "DVCPRO50" */
      .n_difchan = 2,
      .time_base = { 1001, 30000 },
      .ltc_divisor = 30,
      .height = 480,
      .width = 720,
      .sar = {{10, 11}, {40, 33}},
      .work_chunks = &work_chunks_dv50ntsc[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 90,
      .audio_min_samples  = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
      .audio_shuffle = dv_audio_shuffle525,
    },
    { .dsf = 1,
      .video_stype = 0x4,
      .frame_size = 288000,        /* SMPTE-314M - 625/50 (PAL) 50 Mbps */
      .difseg_size = 12,           /* also known as "DVCPRO50" */
      .n_difchan = 2,
      .time_base = { 1, 25 },
      .ltc_divisor = 25,
      .height = 576,
      .width = 720,
      .sar = {{59, 54}, {118, 81}},
      .work_chunks = &work_chunks_dv50pal[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 108,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    },
    { .dsf = 0,
      .video_stype = 0x14,
      .frame_size = 480000,        /* SMPTE-370M - 1080i60 100 Mbps */
      .difseg_size = 10,           /* also known as "DVCPRO HD" */
      .n_difchan = 4,
      .time_base = { 1001, 30000 },
      .ltc_divisor = 30,
      .height = 1080,
      .width = 1280,
      .sar = {{1, 1}, {1, 1}},
      .work_chunks = &work_chunks_dv100ntsci[0],
      .idct_factor = &dv_idct_factor_hd1080[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 8,
      .block_sizes = block_sizes_dv100,
      .audio_stride = 90,
      .audio_min_samples  = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
      .audio_shuffle = dv_audio_shuffle525,
    },
    { .dsf = 1,
      .video_stype = 0x14,
      .frame_size = 576000,        /* SMPTE-370M - 1080i50 100 Mbps */
      .difseg_size = 12,           /* also known as "DVCPRO HD" */
      .n_difchan = 4,
      .time_base = { 1, 25 },
      .ltc_divisor = 25,
      .height = 1080,
      .width = 1440,
      .sar = {{1, 1}, {1, 1}},
      .work_chunks = &work_chunks_dv100pali[0],
      .idct_factor = &dv_idct_factor_hd1080[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 8,
      .block_sizes = block_sizes_dv100,
      .audio_stride = 108,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    },
    { .dsf = 0,
      .video_stype = 0x18,
      .frame_size = 240000,        /* SMPTE-370M - 720p60 100 Mbps */
      .difseg_size = 10,           /* also known as "DVCPRO HD" */
      .n_difchan = 2,
      .time_base = { 1001, 60000 },
      .ltc_divisor = 60,
      .height = 720,
      .width = 960,
      .sar = {{1, 1}, {1, 1}},
      .work_chunks = &work_chunks_dv100ntscp[0],
      .idct_factor = &dv_idct_factor_hd720[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 8,
      .block_sizes = block_sizes_dv100,
      .audio_stride = 90,
      .audio_min_samples  = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
      .audio_shuffle = dv_audio_shuffle525,
    },
    { .dsf = 1,
      .video_stype = 0x18,
      .frame_size = 288000,        /* SMPTE-370M - 720p50 100 Mbps */
      .difseg_size = 12,           /* also known as "DVCPRO HD" */
      .n_difchan = 2,
      .time_base = { 1, 50 },
      .ltc_divisor = 50,
      .height = 720,
      .width = 960,
      .sar = {{1, 1}, {1, 1}},
      .work_chunks = &work_chunks_dv100palp[0],
      .idct_factor = &dv_idct_factor_hd720[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 8,
      .block_sizes = block_sizes_dv100,
      .audio_stride = 90,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    }
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const DVprofile dv_profiles[] = {
   { /* block = 1 */
       0,                     /* int dsf ; int video_stype         */
       120000,                /* int frame_size                    */
       10,                    /* int difseg_size                   */
       1,                     /* int n_difchan                     */
       { 1001,                /* AVRational time_base              */
       0,                     /* int ltc_divisor                   */
       480,                   /* int height                        */
       720,                   /* int width                         */
       {{10,                  /* AVRational sar[2]                 */
       NULL,                  /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV411P,       /* enum PixelFormat pix_fmt          */
       6,                     /* int bpm                           */
       block_sizes_dv2550,    /* const uint8_t * block_sizes       */
       90,                    /* int audio_stride                  */
       { 1580,                /* int audio_min_samples[3]          */
       0,                     /* int audio_samples_dist[5]         */
       0                      /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 2 */   
       0,                     /* int dsf ; int video_stype         */
       144000,                /* int frame_size                    */
       12,                    /* int difseg_size                   */
       1,                     /* int n_difchan                     */
       { 1,                   /* AVRational time_base              */
       0,                     /* int ltc_divisor                   */
       576,                   /* int height                        */
       720,                   /* int width                         */
       {{59,                  /* AVRational sar[2]                 */
       NULL,                  /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV420P,       /* enum PixelFormat pix_fmt          */
       6,                     /* int bpm                           */
       block_sizes_dv2550,    /* const uint8_t * block_sizes       */
       108,                   /* int audio_stride                  */
       { 1896,                /* int audio_min_samples[3]          */
       0,                     /* int audio_samples_dist[5]         */
       0                      /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 3 */   
       0,                     /* int dsf ; int video_stype         */
       144000,                /* int frame_size                    */
       12,                    /* int difseg_size                   */
       1,                     /* int n_difchan                     */
       { 1,                   /* AVRational time_base              */
       0,                     /* int ltc_divisor                   */
       576,                   /* int height                        */
       720,                   /* int width                         */
       {{59,                  /* AVRational sar[2]                 */
       NULL,                  /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV411P,       /* enum PixelFormat pix_fmt          */
       6,                     /* int bpm                           */
       block_sizes_dv2550,    /* const uint8_t * block_sizes       */
       108,                   /* int audio_stride                  */
       { 1896,                /* int audio_min_samples[3]          */
       0,                     /* int audio_samples_dist[5]         */
       0                      /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 4 */   
       0,                     /* int dsf ; int video_stype         */
       240000,                /* int frame_size                    */
       10,                    /* int difseg_size                   */
       2,                     /* int n_difchan                     */
       { 1001,                /* AVRational time_base              */
       0,                     /* int ltc_divisor                   */
       480,                   /* int height                        */
       720,                   /* int width                         */
       {{10,                  /* AVRational sar[2]                 */
       NULL,                  /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,       /* enum PixelFormat pix_fmt          */
       6,                     /* int bpm                           */
       block_sizes_dv2550,    /* const uint8_t * block_sizes       */
       90,                    /* int audio_stride                  */
       { 1580,                /* int audio_min_samples[3]          */
       0,                     /* int audio_samples_dist[5]         */
       0                      /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 5 */   
       0,                     /* int dsf ; int video_stype         */
       288000,                /* int frame_size                    */
       12,                    /* int difseg_size                   */
       2,                     /* int n_difchan                     */
       { 1,                   /* AVRational time_base              */
       0,                     /* int ltc_divisor                   */
       576,                   /* int height                        */
       720,                   /* int width                         */
       {{59,                  /* AVRational sar[2]                 */
       NULL,                  /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,       /* enum PixelFormat pix_fmt          */
       6,                     /* int bpm                           */
       block_sizes_dv2550,    /* const uint8_t * block_sizes       */
       108,                   /* int audio_stride                  */
       { 1896,                /* int audio_min_samples[3]          */
       0,                     /* int audio_samples_dist[5]         */
       0                      /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 6 */   
       0,                         /* int dsf ; int video_stype         */
       480000,                    /* int frame_size                    */
       10,                        /* int difseg_size                   */
       4,                         /* int n_difchan                     */
       { 1001,                    /* AVRational time_base              */
       0,                         /* int ltc_divisor                   */
       1080,                      /* int height                        */
       1280,                      /* int width                         */
       {{1,                       /* AVRational sar[2]                 */
       NULL,                      /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_hd1080[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,           /* enum PixelFormat pix_fmt          */
       8,                         /* int bpm                           */
       block_sizes_dv100,         /* const uint8_t * block_sizes       */
       90,                        /* int audio_stride                  */
       { 1580,                    /* int audio_min_samples[3]          */
       0,                         /* int audio_samples_dist[5]         */
       0                          /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 7 */   
       0,                         /* int dsf ; int video_stype         */
       576000,                    /* int frame_size                    */
       12,                        /* int difseg_size                   */
       4,                         /* int n_difchan                     */
       { 1,                       /* AVRational time_base              */
       0,                         /* int ltc_divisor                   */
       1080,                      /* int height                        */
       1440,                      /* int width                         */
       {{1,                       /* AVRational sar[2]                 */
       NULL,                      /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_hd1080[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,           /* enum PixelFormat pix_fmt          */
       8,                         /* int bpm                           */
       block_sizes_dv100,         /* const uint8_t * block_sizes       */
       108,                       /* int audio_stride                  */
       { 1896,                    /* int audio_min_samples[3]          */
       0,                         /* int audio_samples_dist[5]         */
       0                          /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 8 */   
       0,                        /* int dsf ; int video_stype         */
       240000,                   /* int frame_size                    */
       10,                       /* int difseg_size                   */
       2,                        /* int n_difchan                     */
       { 1001,                   /* AVRational time_base              */
       0,                        /* int ltc_divisor                   */
       720,                      /* int height                        */
       960,                      /* int width                         */
       {{1,                      /* AVRational sar[2]                 */
       NULL,                     /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_hd720[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,          /* enum PixelFormat pix_fmt          */
       8,                        /* int bpm                           */
       block_sizes_dv100,        /* const uint8_t * block_sizes       */
       90,                       /* int audio_stride                  */
       { 1580,                   /* int audio_min_samples[3]          */
       0,                        /* int audio_samples_dist[5]         */
       0                         /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 9 */   
       0,                        /* int dsf ; int video_stype         */
       288000,                   /* int frame_size                    */
       12,                       /* int difseg_size                   */
       2,                        /* int n_difchan                     */
       { 1,                      /* AVRational time_base              */
       0,                        /* int ltc_divisor                   */
       720,                      /* int height                        */
       960,                      /* int width                         */
       {{1,                      /* AVRational sar[2]                 */
       NULL,                     /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_hd720[0], /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,          /* enum PixelFormat pix_fmt          */
       8,                        /* int bpm                           */
       block_sizes_dv100,        /* const uint8_t * block_sizes       */
       90,                       /* int audio_stride                  */
       { 1896,                   /* int audio_min_samples[3]          */
       0,                        /* int audio_samples_dist[5]         */
       0                         /* const uint8_t (*audio_shuffle)[9] */
   }
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/25 19:02:06
static const DVprofile dv_profiles[] = {
    { .dsf = 0,
      .video_stype = 0x0,
      .frame_size = 120000,        /* IEC 61834, SMPTE-314M - 525/60 (NTSC) */
      .difseg_size = 10,
      .n_difchan = 1,
      .time_base = { 1001, 30000 },
      .ltc_divisor = 30,
      .height = 480,
      .width = 720,
      .sar = {{10, 11}, {40, 33}},
      .work_chunks = &work_chunks_dv25ntsc[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV411P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 90,
      .audio_min_samples  = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
      .audio_shuffle = dv_audio_shuffle525,
    },
    { .dsf = 1,
      .video_stype = 0x0,
      .frame_size = 144000,        /* IEC 61834 - 625/50 (PAL) */
      .difseg_size = 12,
      .n_difchan = 1,
      .time_base = { 1, 25 },
      .ltc_divisor = 25,
      .height = 576,
      .width = 720,
      .sar = {{59, 54}, {118, 81}},
      .work_chunks = &work_chunks_dv25pal[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV420P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 108,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    },
    { .dsf = 1,
      .video_stype = 0x0,
      .frame_size = 144000,        /* SMPTE-314M - 625/50 (PAL) */
      .difseg_size = 12,
      .n_difchan = 1,
      .time_base = { 1, 25 },
      .ltc_divisor = 25,
      .height = 576,
      .width = 720,
      .sar = {{59, 54}, {118, 81}},
      .work_chunks = &work_chunks_dv25pal411[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV411P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 108,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    },
    { .dsf = 0,
      .video_stype = 0x4,
      .frame_size = 240000,        /* SMPTE-314M - 525/60 (NTSC) 50 Mbps */
      .difseg_size = 10,           /* also known as "DVCPRO50" */
      .n_difchan = 2,
      .time_base = { 1001, 30000 },
      .ltc_divisor = 30,
      .height = 480,
      .width = 720,
      .sar = {{10, 11}, {40, 33}},
      .work_chunks = &work_chunks_dv50ntsc[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 90,
      .audio_min_samples  = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
      .audio_shuffle = dv_audio_shuffle525,
    },
    { .dsf = 1,
      .video_stype = 0x4,
      .frame_size = 288000,        /* SMPTE-314M - 625/50 (PAL) 50 Mbps */
      .difseg_size = 12,           /* also known as "DVCPRO50" */
      .n_difchan = 2,
      .time_base = { 1, 25 },
      .ltc_divisor = 25,
      .height = 576,
      .width = 720,
      .sar = {{59, 54}, {118, 81}},
      .work_chunks = &work_chunks_dv50pal[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 108,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    },
    { .dsf = 0,
      .video_stype = 0x14,
      .frame_size = 480000,        /* SMPTE-370M - 1080i60 100 Mbps */
      .difseg_size = 10,           /* also known as "DVCPRO HD" */
      .n_difchan = 4,
      .time_base = { 1001, 30000 },
      .ltc_divisor = 30,
      .height = 1080,
      .width = 1280,
      .sar = {{1, 1}, {1, 1}},
      .work_chunks = &work_chunks_dv100ntsci[0],
      .idct_factor = &dv_idct_factor_hd1080[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 8,
      .block_sizes = block_sizes_dv100,
      .audio_stride = 90,
      .audio_min_samples  = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
      .audio_shuffle = dv_audio_shuffle525,
    },
    { .dsf = 1,
      .video_stype = 0x14,
      .frame_size = 576000,        /* SMPTE-370M - 1080i50 100 Mbps */
      .difseg_size = 12,           /* also known as "DVCPRO HD" */
      .n_difchan = 4,
      .time_base = { 1, 25 },
      .ltc_divisor = 25,
      .height = 1080,
      .width = 1440,
      .sar = {{1, 1}, {1, 1}},
      .work_chunks = &work_chunks_dv100pali[0],
      .idct_factor = &dv_idct_factor_hd1080[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 8,
      .block_sizes = block_sizes_dv100,
      .audio_stride = 108,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    },
    { .dsf = 0,
      .video_stype = 0x18,
      .frame_size = 240000,        /* SMPTE-370M - 720p60 100 Mbps */
      .difseg_size = 10,           /* also known as "DVCPRO HD" */
      .n_difchan = 2,
      .time_base = { 1001, 60000 },
      .ltc_divisor = 60,
      .height = 720,
      .width = 960,
      .sar = {{1, 1}, {1, 1}},
      .work_chunks = &work_chunks_dv100ntscp[0],
      .idct_factor = &dv_idct_factor_hd720[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 8,
      .block_sizes = block_sizes_dv100,
      .audio_stride = 90,
      .audio_min_samples  = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
      .audio_shuffle = dv_audio_shuffle525,
    },
    { .dsf = 1,
      .video_stype = 0x18,
      .frame_size = 288000,        /* SMPTE-370M - 720p50 100 Mbps */
      .difseg_size = 12,           /* also known as "DVCPRO HD" */
      .n_difchan = 2,
      .time_base = { 1, 50 },
      .ltc_divisor = 50,
      .height = 720,
      .width = 960,
      .sar = {{1, 1}, {1, 1}},
      .work_chunks = &work_chunks_dv100palp[0],
      .idct_factor = &dv_idct_factor_hd720[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 8,
      .block_sizes = block_sizes_dv100,
      .audio_stride = 90,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    }
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const DVprofile dv_profiles[] = {
   { /* block = 1 */
       0,                                /* int dsf ; int video_stype         */
       120000,                           /* int frame_size                    */
       10,                               /* int difseg_size                   */
       1,                                /* int n_difchan                     */
       { 1001, 30000 },                  /* AVRational time_base              */
       30,                               /* int ltc_divisor                   */
       480,                              /* int height                        */
       720,                              /* int width                         */
       {{10, 11}, {40, 33}},             /* AVRational sar[2]                 */
       &work_chunks_dv25ntsc[0],         /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0],            /* uint32_t * idct_factor            */
       PIX_FMT_YUV411P,                  /* enum PixelFormat pix_fmt          */
       6,                                /* int bpm                           */
       block_sizes_dv2550,               /* const uint8_t * block_sizes       */
       90,                               /* int audio_stride                  */
       { 1580, 1452, 1053 },             /* int audio_min_samples[3]          */
       { 1600, 1602, 1602, 1602, 1602 }, /* int audio_samples_dist[5]         */
       0                                 /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 2 */   
       0,                                /* int dsf ; int video_stype         */
       144000,                           /* int frame_size                    */
       12,                               /* int difseg_size                   */
       1,                                /* int n_difchan                     */
       { 1, 25 },                        /* AVRational time_base              */
       25,                               /* int ltc_divisor                   */
       576,                              /* int height                        */
       720,                              /* int width                         */
       {{59, 54}, {118, 81}},            /* AVRational sar[2]                 */
       &work_chunks_dv25pal[0],          /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0],            /* uint32_t * idct_factor            */
       PIX_FMT_YUV420P,                  /* enum PixelFormat pix_fmt          */
       6,                                /* int bpm                           */
       block_sizes_dv2550,               /* const uint8_t * block_sizes       */
       108,                              /* int audio_stride                  */
       { 1896, 1742, 1264 },             /* int audio_min_samples[3]          */
       { 1920, 1920, 1920, 1920, 1920 }, /* int audio_samples_dist[5]         */
       0                                 /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 3 */   
       0,                                /* int dsf ; int video_stype         */
       144000,                           /* int frame_size                    */
       12,                               /* int difseg_size                   */
       1,                                /* int n_difchan                     */
       { 1, 25 },                        /* AVRational time_base              */
       25,                               /* int ltc_divisor                   */
       576,                              /* int height                        */
       720,                              /* int width                         */
       {{59, 54}, {118, 81}},            /* AVRational sar[2]                 */
       &work_chunks_dv25pal411[0],       /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0],            /* uint32_t * idct_factor            */
       PIX_FMT_YUV411P,                  /* enum PixelFormat pix_fmt          */
       6,                                /* int bpm                           */
       block_sizes_dv2550,               /* const uint8_t * block_sizes       */
       108,                              /* int audio_stride                  */
       { 1896, 1742, 1264 },             /* int audio_min_samples[3]          */
       { 1920, 1920, 1920, 1920, 1920 }, /* int audio_samples_dist[5]         */
       0                                 /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 4 */   
       0,                                /* int dsf ; int video_stype         */
       240000,                           /* int frame_size                    */
       10,                               /* int difseg_size                   */
       2,                                /* int n_difchan                     */
       { 1001, 30000 },                  /* AVRational time_base              */
       30,                               /* int ltc_divisor                   */
       480,                              /* int height                        */
       720,                              /* int width                         */
       {{10, 11}, {40, 33}},             /* AVRational sar[2]                 */
       &work_chunks_dv50ntsc[0],         /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0],            /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,                  /* enum PixelFormat pix_fmt          */
       6,                                /* int bpm                           */
       block_sizes_dv2550,               /* const uint8_t * block_sizes       */
       90,                               /* int audio_stride                  */
       { 1580, 1452, 1053 },             /* int audio_min_samples[3]          */
       { 1600, 1602, 1602, 1602, 1602 }, /* int audio_samples_dist[5]         */
       0                                 /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 5 */   
       0,                                /* int dsf ; int video_stype         */
       288000,                           /* int frame_size                    */
       12,                               /* int difseg_size                   */
       2,                                /* int n_difchan                     */
       { 1, 25 },                        /* AVRational time_base              */
       25,                               /* int ltc_divisor                   */
       576,                              /* int height                        */
       720,                              /* int width                         */
       {{59, 54}, {118, 81}},            /* AVRational sar[2]                 */
       &work_chunks_dv50pal[0],          /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0],            /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,                  /* enum PixelFormat pix_fmt          */
       6,                                /* int bpm                           */
       block_sizes_dv2550,               /* const uint8_t * block_sizes       */
       108,                              /* int audio_stride                  */
       { 1896, 1742, 1264 },             /* int audio_min_samples[3]          */
       { 1920, 1920, 1920, 1920, 1920 }, /* int audio_samples_dist[5]         */
       0                                 /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 6 */   
       0,                                /* int dsf ; int video_stype         */
       480000,                           /* int frame_size                    */
       10,                               /* int difseg_size                   */
       4,                                /* int n_difchan                     */
       { 1001, 30000 },                  /* AVRational time_base              */
       30,                               /* int ltc_divisor                   */
       1080,                             /* int height                        */
       1280,                             /* int width                         */
       {{1, 1}, {1, 1}},                 /* AVRational sar[2]                 */
       &work_chunks_dv100ntsci[0],       /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_hd1080[0],        /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,                  /* enum PixelFormat pix_fmt          */
       8,                                /* int bpm                           */
       block_sizes_dv100,                /* const uint8_t * block_sizes       */
       90,                               /* int audio_stride                  */
       { 1580, 1452, 1053 },             /* int audio_min_samples[3]          */
       { 1600, 1602, 1602, 1602, 1602 }, /* int audio_samples_dist[5]         */
       0                                 /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 7 */   
       0,                                /* int dsf ; int video_stype         */
       576000,                           /* int frame_size                    */
       12,                               /* int difseg_size                   */
       4,                                /* int n_difchan                     */
       { 1, 25 },                        /* AVRational time_base              */
       25,                               /* int ltc_divisor                   */
       1080,                             /* int height                        */
       1440,                             /* int width                         */
       {{1, 1}, {1, 1}},                 /* AVRational sar[2]                 */
       &work_chunks_dv100pali[0],        /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_hd1080[0],        /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,                  /* enum PixelFormat pix_fmt          */
       8,                                /* int bpm                           */
       block_sizes_dv100,                /* const uint8_t * block_sizes       */
       108,                              /* int audio_stride                  */
       { 1896, 1742, 1264 },             /* int audio_min_samples[3]          */
       { 1920, 1920, 1920, 1920, 1920 }, /* int audio_samples_dist[5]         */
       0                                 /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 8 */   
       0,                                /* int dsf ; int video_stype         */
       240000,                           /* int frame_size                    */
       10,                               /* int difseg_size                   */
       2,                                /* int n_difchan                     */
       { 1001, 60000 },                  /* AVRational time_base              */
       60,                               /* int ltc_divisor                   */
       720,                              /* int height                        */
       960,                              /* int width                         */
       {{1, 1}, {1, 1}},                 /* AVRational sar[2]                 */
       &work_chunks_dv100ntscp[0],       /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_hd720[0],         /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,                  /* enum PixelFormat pix_fmt          */
       8,                                /* int bpm                           */
       block_sizes_dv100,                /* const uint8_t * block_sizes       */
       90,                               /* int audio_stride                  */
       { 1580, 1452, 1053 },             /* int audio_min_samples[3]          */
       { 1600, 1602, 1602, 1602, 1602 }, /* int audio_samples_dist[5]         */
       0                                 /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 9 */   
       0,                                /* int dsf ; int video_stype         */
       288000,                           /* int frame_size                    */
       12,                               /* int difseg_size                   */
       2,                                /* int n_difchan                     */
       { 1, 50 },                        /* AVRational time_base              */
       50,                               /* int ltc_divisor                   */
       720,                              /* int height                        */
       960,                              /* int width                         */
       {{1, 1}, {1, 1}},                 /* AVRational sar[2]                 */
       &work_chunks_dv100palp[0],        /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_hd720[0],         /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,                  /* enum PixelFormat pix_fmt          */
       8,                                /* int bpm                           */
       block_sizes_dv100,                /* const uint8_t * block_sizes       */
       90,                               /* int audio_stride                  */
       { 1896, 1742, 1264 },             /* int audio_min_samples[3]          */
       { 1920, 1920, 1920, 1920, 1920 }, /* int audio_samples_dist[5]         */
       0                                 /* const uint8_t (*audio_shuffle)[9] */
   }
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
// =========================================================
// 2009/09/25 19:15:25
static const DVprofile dv_profiles[] = {
    { .dsf = 0,
      .video_stype = 0x0,
      .frame_size = 120000,        /* IEC 61834, SMPTE-314M - 525/60 (NTSC) */
      .difseg_size = 10,
      .n_difchan = 1,
      .time_base = { 1001, 30000 },
      .ltc_divisor = 30,
      .height = 480,
      .width = 720,
      .sar = {{10, 11}, {40, 33}},
      .work_chunks = &work_chunks_dv25ntsc[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV411P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 90,
      .audio_min_samples  = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
      .audio_shuffle = dv_audio_shuffle525,
    },
    { .dsf = 1,
      .video_stype = 0x0,
      .frame_size = 144000,        /* IEC 61834 - 625/50 (PAL) */
      .difseg_size = 12,
      .n_difchan = 1,
      .time_base = { 1, 25 },
      .ltc_divisor = 25,
      .height = 576,
      .width = 720,
      .sar = {{59, 54}, {118, 81}},
      .work_chunks = &work_chunks_dv25pal[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV420P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 108,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    },
    { .dsf = 1,
      .video_stype = 0x0,
      .frame_size = 144000,        /* SMPTE-314M - 625/50 (PAL) */
      .difseg_size = 12,
      .n_difchan = 1,
      .time_base = { 1, 25 },
      .ltc_divisor = 25,
      .height = 576,
      .width = 720,
      .sar = {{59, 54}, {118, 81}},
      .work_chunks = &work_chunks_dv25pal411[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV411P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 108,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    },
    { .dsf = 0,
      .video_stype = 0x4,
      .frame_size = 240000,        /* SMPTE-314M - 525/60 (NTSC) 50 Mbps */
      .difseg_size = 10,           /* also known as "DVCPRO50" */
      .n_difchan = 2,
      .time_base = { 1001, 30000 },
      .ltc_divisor = 30,
      .height = 480,
      .width = 720,
      .sar = {{10, 11}, {40, 33}},
      .work_chunks = &work_chunks_dv50ntsc[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 90,
      .audio_min_samples  = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
      .audio_shuffle = dv_audio_shuffle525,
    },
    { .dsf = 1,
      .video_stype = 0x4,
      .frame_size = 288000,        /* SMPTE-314M - 625/50 (PAL) 50 Mbps */
      .difseg_size = 12,           /* also known as "DVCPRO50" */
      .n_difchan = 2,
      .time_base = { 1, 25 },
      .ltc_divisor = 25,
      .height = 576,
      .width = 720,
      .sar = {{59, 54}, {118, 81}},
      .work_chunks = &work_chunks_dv50pal[0],
      .idct_factor = &dv_idct_factor_sd[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 6,
      .block_sizes = block_sizes_dv2550,
      .audio_stride = 108,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    },
    { .dsf = 0,
      .video_stype = 0x14,
      .frame_size = 480000,        /* SMPTE-370M - 1080i60 100 Mbps */
      .difseg_size = 10,           /* also known as "DVCPRO HD" */
      .n_difchan = 4,
      .time_base = { 1001, 30000 },
      .ltc_divisor = 30,
      .height = 1080,
      .width = 1280,
      .sar = {{1, 1}, {1, 1}},
      .work_chunks = &work_chunks_dv100ntsci[0],
      .idct_factor = &dv_idct_factor_hd1080[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 8,
      .block_sizes = block_sizes_dv100,
      .audio_stride = 90,
      .audio_min_samples  = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
      .audio_shuffle = dv_audio_shuffle525,
    },
    { .dsf = 1,
      .video_stype = 0x14,
      .frame_size = 576000,        /* SMPTE-370M - 1080i50 100 Mbps */
      .difseg_size = 12,           /* also known as "DVCPRO HD" */
      .n_difchan = 4,
      .time_base = { 1, 25 },
      .ltc_divisor = 25,
      .height = 1080,
      .width = 1440,
      .sar = {{1, 1}, {1, 1}},
      .work_chunks = &work_chunks_dv100pali[0],
      .idct_factor = &dv_idct_factor_hd1080[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 8,
      .block_sizes = block_sizes_dv100,
      .audio_stride = 108,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    },
    { .dsf = 0,
      .video_stype = 0x18,
      .frame_size = 240000,        /* SMPTE-370M - 720p60 100 Mbps */
      .difseg_size = 10,           /* also known as "DVCPRO HD" */
      .n_difchan = 2,
      .time_base = { 1001, 60000 },
      .ltc_divisor = 60,
      .height = 720,
      .width = 960,
      .sar = {{1, 1}, {1, 1}},
      .work_chunks = &work_chunks_dv100ntscp[0],
      .idct_factor = &dv_idct_factor_hd720[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 8,
      .block_sizes = block_sizes_dv100,
      .audio_stride = 90,
      .audio_min_samples  = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
      .audio_shuffle = dv_audio_shuffle525,
    },
    { .dsf = 1,
      .video_stype = 0x18,
      .frame_size = 288000,        /* SMPTE-370M - 720p50 100 Mbps */
      .difseg_size = 12,           /* also known as "DVCPRO HD" */
      .n_difchan = 2,
      .time_base = { 1, 50 },
      .ltc_divisor = 50,
      .height = 720,
      .width = 960,
      .sar = {{1, 1}, {1, 1}},
      .work_chunks = &work_chunks_dv100palp[0],
      .idct_factor = &dv_idct_factor_hd720[0],
      .pix_fmt = PIX_FMT_YUV422P,
      .bpm = 8,
      .block_sizes = block_sizes_dv100,
      .audio_stride = 90,
      .audio_min_samples  = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
      .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
      .audio_shuffle = dv_audio_shuffle625,
    }
};

#ifdef _MSC_VER /* until MSVC supports dot(.) aligned members, etc */
static const DVprofile dv_profiles[] = {
   { /* block = 1 */
       0,                                /* int dsf                           */
       0x0,                              /* int video_stype                   */
       120000,                           /* int frame_size                    */
       10,                               /* int difseg_size                   */
       1,                                /* int n_difchan                     */
       { 1001, 30000 },                  /* AVRational time_base              */
       30,                               /* int ltc_divisor                   */
       480,                              /* int height                        */
       720,                              /* int width                         */
       {{10, 11}, {40, 33}},             /* AVRational sar[2]                 */
       &work_chunks_dv25ntsc[0],         /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0],            /* uint32_t * idct_factor            */
       PIX_FMT_YUV411P,                  /* enum PixelFormat pix_fmt          */
       6,                                /* int bpm                           */
       block_sizes_dv2550,               /* const uint8_t * block_sizes       */
       90,                               /* int audio_stride                  */
       { 1580, 1452, 1053 },             /* int audio_min_samples[3]          */
       { 1600, 1602, 1602, 1602, 1602 }, /* int audio_samples_dist[5]         */
       0                                 /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 2 */   
       1,                                /* int dsf                           */
       0x0,                              /* int video_stype                   */
       144000,                           /* int frame_size                    */
       12,                               /* int difseg_size                   */
       1,                                /* int n_difchan                     */
       { 1, 25 },                        /* AVRational time_base              */
       25,                               /* int ltc_divisor                   */
       576,                              /* int height                        */
       720,                              /* int width                         */
       {{59, 54}, {118, 81}},            /* AVRational sar[2]                 */
       &work_chunks_dv25pal[0],          /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0],            /* uint32_t * idct_factor            */
       PIX_FMT_YUV420P,                  /* enum PixelFormat pix_fmt          */
       6,                                /* int bpm                           */
       block_sizes_dv2550,               /* const uint8_t * block_sizes       */
       108,                              /* int audio_stride                  */
       { 1896, 1742, 1264 },             /* int audio_min_samples[3]          */
       { 1920, 1920, 1920, 1920, 1920 }, /* int audio_samples_dist[5]         */
       0                                 /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 3 */   
       1,                                /* int dsf                           */
       0x0,                              /* int video_stype                   */
       144000,                           /* int frame_size                    */
       12,                               /* int difseg_size                   */
       1,                                /* int n_difchan                     */
       { 1, 25 },                        /* AVRational time_base              */
       25,                               /* int ltc_divisor                   */
       576,                              /* int height                        */
       720,                              /* int width                         */
       {{59, 54}, {118, 81}},            /* AVRational sar[2]                 */
       &work_chunks_dv25pal411[0],       /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0],            /* uint32_t * idct_factor            */
       PIX_FMT_YUV411P,                  /* enum PixelFormat pix_fmt          */
       6,                                /* int bpm                           */
       block_sizes_dv2550,               /* const uint8_t * block_sizes       */
       108,                              /* int audio_stride                  */
       { 1896, 1742, 1264 },             /* int audio_min_samples[3]          */
       { 1920, 1920, 1920, 1920, 1920 }, /* int audio_samples_dist[5]         */
       0                                 /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 4 */   
       0,                                /* int dsf                           */
       0x4,                              /* int video_stype                   */
       240000,                           /* int frame_size                    */
       10,                               /* int difseg_size                   */
       2,                                /* int n_difchan                     */
       { 1001, 30000 },                  /* AVRational time_base              */
       30,                               /* int ltc_divisor                   */
       480,                              /* int height                        */
       720,                              /* int width                         */
       {{10, 11}, {40, 33}},             /* AVRational sar[2]                 */
       &work_chunks_dv50ntsc[0],         /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0],            /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,                  /* enum PixelFormat pix_fmt          */
       6,                                /* int bpm                           */
       block_sizes_dv2550,               /* const uint8_t * block_sizes       */
       90,                               /* int audio_stride                  */
       { 1580, 1452, 1053 },             /* int audio_min_samples[3]          */
       { 1600, 1602, 1602, 1602, 1602 }, /* int audio_samples_dist[5]         */
       0                                 /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 5 */   
       1,                                /* int dsf                           */
       0x4,                              /* int video_stype                   */
       288000,                           /* int frame_size                    */
       12,                               /* int difseg_size                   */
       2,                                /* int n_difchan                     */
       { 1, 25 },                        /* AVRational time_base              */
       25,                               /* int ltc_divisor                   */
       576,                              /* int height                        */
       720,                              /* int width                         */
       {{59, 54}, {118, 81}},            /* AVRational sar[2]                 */
       &work_chunks_dv50pal[0],          /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_sd[0],            /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,                  /* enum PixelFormat pix_fmt          */
       6,                                /* int bpm                           */
       block_sizes_dv2550,               /* const uint8_t * block_sizes       */
       108,                              /* int audio_stride                  */
       { 1896, 1742, 1264 },             /* int audio_min_samples[3]          */
       { 1920, 1920, 1920, 1920, 1920 }, /* int audio_samples_dist[5]         */
       0                                 /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 6 */   
       0,                                /* int dsf                           */
       0x14,                             /* int video_stype                   */
       480000,                           /* int frame_size                    */
       10,                               /* int difseg_size                   */
       4,                                /* int n_difchan                     */
       { 1001, 30000 },                  /* AVRational time_base              */
       30,                               /* int ltc_divisor                   */
       1080,                             /* int height                        */
       1280,                             /* int width                         */
       {{1, 1}, {1, 1}},                 /* AVRational sar[2]                 */
       &work_chunks_dv100ntsci[0],       /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_hd1080[0],        /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,                  /* enum PixelFormat pix_fmt          */
       8,                                /* int bpm                           */
       block_sizes_dv100,                /* const uint8_t * block_sizes       */
       90,                               /* int audio_stride                  */
       { 1580, 1452, 1053 },             /* int audio_min_samples[3]          */
       { 1600, 1602, 1602, 1602, 1602 }, /* int audio_samples_dist[5]         */
       0                                 /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 7 */   
       1,                                /* int dsf                           */
       0x14,                             /* int video_stype                   */
       576000,                           /* int frame_size                    */
       12,                               /* int difseg_size                   */
       4,                                /* int n_difchan                     */
       { 1, 25 },                        /* AVRational time_base              */
       25,                               /* int ltc_divisor                   */
       1080,                             /* int height                        */
       1440,                             /* int width                         */
       {{1, 1}, {1, 1}},                 /* AVRational sar[2]                 */
       &work_chunks_dv100pali[0],        /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_hd1080[0],        /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,                  /* enum PixelFormat pix_fmt          */
       8,                                /* int bpm                           */
       block_sizes_dv100,                /* const uint8_t * block_sizes       */
       108,                              /* int audio_stride                  */
       { 1896, 1742, 1264 },             /* int audio_min_samples[3]          */
       { 1920, 1920, 1920, 1920, 1920 }, /* int audio_samples_dist[5]         */
       0                                 /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 8 */   
       0,                                /* int dsf                           */
       0x18,                             /* int video_stype                   */
       240000,                           /* int frame_size                    */
       10,                               /* int difseg_size                   */
       2,                                /* int n_difchan                     */
       { 1001, 60000 },                  /* AVRational time_base              */
       60,                               /* int ltc_divisor                   */
       720,                              /* int height                        */
       960,                              /* int width                         */
       {{1, 1}, {1, 1}},                 /* AVRational sar[2]                 */
       &work_chunks_dv100ntscp[0],       /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_hd720[0],         /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,                  /* enum PixelFormat pix_fmt          */
       8,                                /* int bpm                           */
       block_sizes_dv100,                /* const uint8_t * block_sizes       */
       90,                               /* int audio_stride                  */
       { 1580, 1452, 1053 },             /* int audio_min_samples[3]          */
       { 1600, 1602, 1602, 1602, 1602 }, /* int audio_samples_dist[5]         */
       0                                 /* const uint8_t (*audio_shuffle)[9] */
   },
   { /* block = 9 */   
       1,                                /* int dsf                           */
       0x18,                             /* int video_stype                   */
       288000,                           /* int frame_size                    */
       12,                               /* int difseg_size                   */
       2,                                /* int n_difchan                     */
       { 1, 50 },                        /* AVRational time_base              */
       50,                               /* int ltc_divisor                   */
       720,                              /* int height                        */
       960,                              /* int width                         */
       {{1, 1}, {1, 1}},                 /* AVRational sar[2]                 */
       &work_chunks_dv100palp[0],        /* DVwork_chunk * work_chunks        */
       &dv_idct_factor_hd720[0],         /* uint32_t * idct_factor            */
       PIX_FMT_YUV422P,                  /* enum PixelFormat pix_fmt          */
       8,                                /* int bpm                           */
       block_sizes_dv100,                /* const uint8_t * block_sizes       */
       90,                               /* int audio_stride                  */
       { 1896, 1742, 1264 },             /* int audio_min_samples[3]          */
       { 1920, 1920, 1920, 1920, 1920 }, /* int audio_samples_dist[5]         */
       0                                 /* const uint8_t (*audio_shuffle)[9] */
   }
};
#else /* !_MSC_VER */
#endif /* _MSC_VER y/n */
// =========================================================
