falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
95500 Commits
32 Branches
293MB
Tree: a581bb66ea
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a581bb66ea'
${ noResults }
FFmpeg/libavformat/avienc.c

1020 lines
36KB
Raw Blame History 

  1. /*

  2.  * AVI muxer

  3.  * Copyright (c) 2000 Fabrice Bellard

  4.  *

  5.  * This file is part of FFmpeg.

  6.  *

  7.  * FFmpeg is free software; you can redistribute it and/or

  8.  * modify it under the terms of the GNU Lesser General Public

  9.  * License as published by the Free Software Foundation; either

  10.  * version 2.1 of the License, or (at your option) any later version.

  11.  *

  12.  * FFmpeg is distributed in the hope that it will be useful,

  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  15.  * Lesser General Public License for more details.

  16.  *

  17.  * You should have received a copy of the GNU Lesser General Public

  18.  * License along with FFmpeg; if not, write to the Free Software

  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  20.  */

  21. 

  22. #include <math.h>

  23. 

  24. #include "avformat.h"

  25. #include "internal.h"

  26. #include "avi.h"

  27. #include "avio_internal.h"

  28. #include "riff.h"

  29. #include "mpegts.h"

  30. #include "libavformat/avlanguage.h"

  31. #include "libavutil/avstring.h"

  32. #include "libavutil/avutil.h"

  33. #include "libavutil/internal.h"

  34. #include "libavutil/intreadwrite.h"

  35. #include "libavutil/dict.h"

  36. #include "libavutil/avassert.h"

  37. #include "libavutil/timestamp.h"

  38. #include "libavutil/opt.h"

  39. #include "libavutil/pixdesc.h"

  40. #include "libavcodec/raw.h"

  41. 

  42. /*

  43.  * TODO:

  44.  *  - fill all fields if non streamed (nb_frames for example)

  45.  */

  46. 

  47. typedef struct AVIIentry {

  48.     char tag[4];

  49.     unsigned int flags;

  50.     unsigned int pos;

  51.     unsigned int len;

  52. } AVIIentry;

  53. 

  54. #define AVI_INDEX_CLUSTER_SIZE 16384

  55. #define AVI_MASTER_INDEX_PREFIX_SIZE    (8+2+1+1+4+8+4+4)

  56. #define AVI_MASTER_INDEX_ENTRY_SIZE     16  /* bytes per entry */

  57. #define AVI_MASTER_INDEX_SIZE_DEFAULT   256 /* number of entries */

  58. 

  59. typedef struct AVIIndex {

  60.     int64_t     indx_start;

  61.     int64_t     audio_strm_offset;

  62.     int         entry;

  63.     int         ents_allocated;

  64.     int         master_odml_riff_id_base;

  65.     AVIIentry** cluster;

  66. } AVIIndex;

  67. 

  68. typedef struct AVIContext {

  69.     const AVClass *class;

  70.     int64_t riff_start, movi_list, odml_list;

  71.     int64_t frames_hdr_all;

  72.     int riff_id;

  73.     int reserve_index_space;

  74.     int master_index_max_size;

  75.     int write_channel_mask;

  76. } AVIContext;

  77. 

  78. typedef struct AVIStream {

  79.     int64_t frames_hdr_strm;

  80.     int64_t audio_strm_length;

  81.     int packet_count;

  82.     int entry;

  83.     int max_size;

  84.     int sample_requested;

  85. 

  86.     int64_t last_dts;

  87. 

  88.     AVIIndex indexes;

  89. 

  90.     int64_t strh_flags_offset;

  91. 

  92.     uint32_t palette[AVPALETTE_COUNT];

  93.     uint32_t old_palette[AVPALETTE_COUNT];

  94.     int64_t pal_offset;

  95. } AVIStream;

  96. 

  97. static int avi_write_packet_internal(AVFormatContext *s, AVPacket *pkt);

  98. 

  99. static inline AVIIentry *avi_get_ientry(const AVIIndex *idx, int ent_id)

  100. {

  101.     int cl = ent_id / AVI_INDEX_CLUSTER_SIZE;

  102.     int id = ent_id % AVI_INDEX_CLUSTER_SIZE;

  103.     return &idx->cluster[cl][id];

  104. }

  105. 

  106. static int avi_add_ientry(AVFormatContext *s, int stream_index, char *tag,

  107.                           unsigned int flags, unsigned int size)

  108. {

  109.     AVIContext *avi  = s->priv_data;

  110.     AVIOContext *pb  = s->pb;

  111.     AVIStream *avist = s->streams[stream_index]->priv_data;

  112.     AVIIndex *idx    = &avist->indexes;

  113.     int cl           = idx->entry / AVI_INDEX_CLUSTER_SIZE;

  114.     int id           = idx->entry % AVI_INDEX_CLUSTER_SIZE;

  115. 

  116.     if (idx->ents_allocated <= idx->entry) {

  117.         idx->cluster = av_realloc_f(idx->cluster, sizeof(void*), cl+1);

  118.         if (!idx->cluster) {

  119.             idx->ents_allocated = 0;

  120.             idx->entry          = 0;

  121.             return AVERROR(ENOMEM);

  122.         }

  123.         idx->cluster[cl] =

  124.             av_malloc(AVI_INDEX_CLUSTER_SIZE * sizeof(AVIIentry));

  125.         if (!idx->cluster[cl])

  126.             return AVERROR(ENOMEM);

  127.         idx->ents_allocated += AVI_INDEX_CLUSTER_SIZE;

  128.     }

  129. 

  130.     if (tag)

  131.         memcpy(idx->cluster[cl][id].tag, tag, 4);

  132.     else

  133.         memset(idx->cluster[cl][id].tag, 0, 4);

  134.     idx->cluster[cl][id].flags = flags;

  135.     idx->cluster[cl][id].pos   = avio_tell(pb) - avi->movi_list;

  136.     idx->cluster[cl][id].len   = size;

  137.     avist->max_size = FFMAX(avist->max_size, size);

  138.     idx->entry++;

  139. 

  140.     return 0;

  141. }

  142. 

  143. static av_cold int avi_init(struct AVFormatContext *s)

  144. {

  145.     AVIContext *avi = s->priv_data;

  146. 

  147.     if (avi->reserve_index_space > 0) {

  148.         avi->master_index_max_size = (avi->reserve_index_space - AVI_MASTER_INDEX_PREFIX_SIZE) / AVI_MASTER_INDEX_ENTRY_SIZE;

  149.         avi->master_index_max_size = FFMAX(avi->master_index_max_size, 16);

  150.     } else

  151.         avi->master_index_max_size = AVI_MASTER_INDEX_SIZE_DEFAULT;

  152.     av_log(s, AV_LOG_DEBUG, "reserve_index_space:%d master_index_max_size:%d\n",

  153.            avi->reserve_index_space, avi->master_index_max_size);

  154. 

  155.     return 1; /* stream initialization continues in avi_write_header */

  156. }

  157. 

  158. static int64_t avi_start_new_riff(AVFormatContext *s, AVIOContext *pb,

  159.                                   const char *riff_tag, const char *list_tag)

  160. {

  161.     AVIContext *avi = s->priv_data;

  162.     int64_t loff;

  163.     int i;

  164. 

  165.     avi->riff_id++;

  166.     for (i = 0; i < s->nb_streams; i++) {

  167.         AVIStream *avist = s->streams[i]->priv_data;

  168.         avist->indexes.audio_strm_offset = avist->audio_strm_length;

  169.         avist->indexes.entry = 0;

  170.     }

  171. 

  172.     avi->riff_start = ff_start_tag(pb, "RIFF");

  173.     ffio_wfourcc(pb, riff_tag);

  174.     loff = ff_start_tag(pb, "LIST");

  175.     ffio_wfourcc(pb, list_tag);

  176.     return loff;

  177. }

  178. 

  179. static char *avi_stream2fourcc(char *tag, int index, enum AVMediaType type)

  180. {

  181.     tag[0] = '0' + index / 10;

  182.     tag[1] = '0' + index % 10;

  183.     if (type == AVMEDIA_TYPE_VIDEO) {

  184.         tag[2] = 'd';

  185.         tag[3] = 'c';

  186.     } else if (type == AVMEDIA_TYPE_SUBTITLE) {

  187.         // note: this is not an official code

  188.         tag[2] = 's';

  189.         tag[3] = 'b';

  190.     } else {

  191.         tag[2] = 'w';

  192.         tag[3] = 'b';

  193.     }

  194.     tag[4] = '\0';

  195.     return tag;

  196. }

  197. 

  198. static int avi_write_counters(AVFormatContext *s, int riff_id)

  199. {

  200.     AVIOContext *pb = s->pb;

  201.     AVIContext *avi = s->priv_data;

  202.     int n, au_byterate, au_ssize, au_scale, nb_frames = 0;

  203.     int64_t file_size;

  204.     AVCodecParameters *par;

  205. 

  206.     file_size = avio_tell(pb);

  207.     for (n = 0; n < s->nb_streams; n++) {

  208.         AVIStream *avist = s->streams[n]->priv_data;

  209. 

  210.         av_assert0(avist->frames_hdr_strm);

  211.         par = s->streams[n]->codecpar;

  212.         avio_seek(pb, avist->frames_hdr_strm, SEEK_SET);

  213.         ff_parse_specific_params(s->streams[n], &au_byterate, &au_ssize, &au_scale);

  214.         if (au_ssize == 0)

  215.             avio_wl32(pb, avist->packet_count);

  216.         else

  217.             avio_wl32(pb, avist->audio_strm_length / au_ssize);

  218.         if (par->codec_type == AVMEDIA_TYPE_VIDEO)

  219.             nb_frames = FFMAX(nb_frames, avist->packet_count);

  220.     }

  221.     if (riff_id == 1) {

  222.         av_assert0(avi->frames_hdr_all);

  223.         avio_seek(pb, avi->frames_hdr_all, SEEK_SET);

  224.         avio_wl32(pb, nb_frames);

  225.     }

  226.     avio_seek(pb, file_size, SEEK_SET);

  227. 

  228.     return 0;

  229. }

  230. 

  231. static void write_odml_master(AVFormatContext *s, int stream_index)

  232. {

  233.     AVIOContext *pb = s->pb;

  234.     AVIContext *avi = s->priv_data;

  235.     AVStream *st = s->streams[stream_index];

  236.     AVCodecParameters *par = st->codecpar;

  237.     AVIStream *avist = st->priv_data;

  238.     unsigned char tag[5];

  239.     int j;

  240. 

  241.     /* Starting to lay out AVI OpenDML master index.

  242.         * We want to make it JUNK entry for now, since we'd

  243.         * like to get away without making AVI an OpenDML one

  244.         * for compatibility reasons. */

  245.     avist->indexes.indx_start = ff_start_tag(pb, "JUNK");

  246.     avio_wl16(pb, 4);   /* wLongsPerEntry */

  247.     avio_w8(pb, 0);     /* bIndexSubType (0 == frame index) */

  248.     avio_w8(pb, 0);     /* bIndexType (0 == AVI_INDEX_OF_INDEXES) */

  249.     avio_wl32(pb, 0);   /* nEntriesInUse (will fill out later on) */

  250.     ffio_wfourcc(pb, avi_stream2fourcc(tag, stream_index, par->codec_type));

  251.                         /* dwChunkId */

  252.     avio_wl64(pb, 0);   /* dwReserved[3] */

  253.     avio_wl32(pb, 0);   /* Must be 0.    */

  254.     for (j = 0; j < avi->master_index_max_size * 2; j++)

  255.         avio_wl64(pb, 0);

  256.     ff_end_tag(pb, avist->indexes.indx_start);

  257. }

  258. 

  259. static int avi_write_header(AVFormatContext *s)

  260. {

  261.     AVIContext *avi = s->priv_data;

  262.     AVIOContext *pb = s->pb;

  263.     int bitrate, n, i, nb_frames, au_byterate, au_ssize, au_scale;

  264.     int64_t max_stream_duration = 0;

  265.     AVCodecParameters *video_par;

  266.     AVStream *video_st = NULL;

  267.     int64_t list1, list2, strh, strf;

  268.     AVDictionaryEntry *t = NULL;

  269.     int padding;

  270. 

  271.     if (s->nb_streams > AVI_MAX_STREAM_COUNT) {

  272.         av_log(s, AV_LOG_ERROR, "AVI does not support >%d streams\n",

  273.                AVI_MAX_STREAM_COUNT);

  274.         return AVERROR(EINVAL);

  275.     }

  276. 

  277.     for (n = 0; n < s->nb_streams; n++) {

  278.         s->streams[n]->priv_data = av_mallocz(sizeof(AVIStream));

  279.         if (!s->streams[n]->priv_data)

  280.             return AVERROR(ENOMEM);

  281.     }

  282. 

  283.     /* header list */

  284.     avi->riff_id = 0;

  285.     list1 = avi_start_new_riff(s, pb, "AVI ", "hdrl");

  286. 

  287.     /* avi header */

  288.     ffio_wfourcc(pb, "avih");

  289.     avio_wl32(pb, 14 * 4);

  290.     bitrate = 0;

  291. 

  292.     video_par = NULL;

  293.     for (n = 0; n < s->nb_streams; n++) {

  294.         AVCodecParameters *par = s->streams[n]->codecpar;

  295.         AVStream *st = s->streams[n];

  296.         bitrate = FFMIN(bitrate + par->bit_rate, INT32_MAX);

  297.         if (st->duration > 0) {

  298.             int64_t stream_duration = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);

  299.             max_stream_duration = FFMAX(stream_duration, max_stream_duration);

  300.         }

  301.         if (par->codec_type == AVMEDIA_TYPE_VIDEO) {

  302.             video_par = par;

  303.             video_st = st;

  304.         }

  305.     }

  306. 

  307.     /* guess master index size based on bitrate and duration */

  308.     if (!avi->reserve_index_space) {

  309.         double duration_est, filesize_est;

  310.         if (s->duration > 0)

  311.             duration_est = (double)s->duration / AV_TIME_BASE;

  312.         else if (max_stream_duration > 0)

  313.             duration_est = (double)max_stream_duration / AV_TIME_BASE;

  314.         else

  315.             duration_est = 10 * 60 * 60; /* default to 10 hours */

  316.         filesize_est = duration_est * (bitrate / 8) * 1.10; /* add 10% safety margin for muxer+bitrate */

  317.         avi->master_index_max_size = FFMAX((int)ceil(filesize_est / AVI_MAX_RIFF_SIZE) + 1,

  318.                                            avi->master_index_max_size);

  319.         av_log(s, AV_LOG_DEBUG, "duration_est:%0.3f, filesize_est:%0.1fGiB, master_index_max_size:%d\n",

  320.                duration_est, filesize_est / (1024*1024*1024), avi->master_index_max_size);

  321.     }

  322. 

  323.     nb_frames = 0;

  324. 

  325.     // TODO: should be avg_frame_rate

  326.     if (video_st)

  327.         avio_wl32(pb, (uint32_t) (INT64_C(1000000) * video_st->time_base.num /

  328.                                   video_st->time_base.den));

  329.     else

  330.         avio_wl32(pb, 0);

  331.     avio_wl32(pb, bitrate / 8); /* XXX: not quite exact */

  332.     avio_wl32(pb, 0); /* padding */

  333.     if (!(pb->seekable & AVIO_SEEKABLE_NORMAL))

  334.         avio_wl32(pb, AVIF_TRUSTCKTYPE | AVIF_ISINTERLEAVED);  /* flags */

  335.     else

  336.         avio_wl32(pb, AVIF_TRUSTCKTYPE | AVIF_HASINDEX | AVIF_ISINTERLEAVED);  /* flags */

  337.     avi->frames_hdr_all = avio_tell(pb); /* remember this offset to fill later */

  338.     avio_wl32(pb, nb_frames); /* nb frames, filled later */

  339.     avio_wl32(pb, 0); /* initial frame */

  340.     avio_wl32(pb, s->nb_streams); /* nb streams */

  341.     avio_wl32(pb, 1024 * 1024); /* suggested buffer size */

  342.     if (video_par) {

  343.         avio_wl32(pb, video_par->width);

  344.         avio_wl32(pb, video_par->height);

  345.     } else {

  346.         avio_wl32(pb, 0);

  347.         avio_wl32(pb, 0);

  348.     }

  349.     avio_wl32(pb, 0); /* reserved */

  350.     avio_wl32(pb, 0); /* reserved */

  351.     avio_wl32(pb, 0); /* reserved */

  352.     avio_wl32(pb, 0); /* reserved */

  353. 

  354.     /* stream list */

  355.     for (i = 0; i < n; i++) {

  356.         AVStream *st = s->streams[i];

  357.         AVCodecParameters *par = st->codecpar;

  358.         AVIStream *avist = st->priv_data;

  359.         list2 = ff_start_tag(pb, "LIST");

  360.         ffio_wfourcc(pb, "strl");

  361. 

  362.         /* stream generic header */

  363.         strh = ff_start_tag(pb, "strh");

  364.         switch (par->codec_type) {

  365.         case AVMEDIA_TYPE_SUBTITLE:

  366.             // XSUB subtitles behave like video tracks, other subtitles

  367.             // are not (yet) supported.

  368.             if (par->codec_id != AV_CODEC_ID_XSUB) {

  369.                 avpriv_report_missing_feature(s, "Subtitle streams other than DivX XSUB");

  370.                 return AVERROR_PATCHWELCOME;

  371.             }

  372.         case AVMEDIA_TYPE_VIDEO:

  373.             ffio_wfourcc(pb, "vids");

  374.             break;

  375.         case AVMEDIA_TYPE_AUDIO:

  376.             ffio_wfourcc(pb, "auds");

  377.             break;

  378. //      case AVMEDIA_TYPE_TEXT:

  379. //          ffio_wfourcc(pb, "txts");

  380. //          break;

  381.         case AVMEDIA_TYPE_DATA:

  382.             ffio_wfourcc(pb, "dats");

  383.             break;

  384.         }

  385.         if (par->codec_type == AVMEDIA_TYPE_VIDEO ||

  386.             par->codec_id == AV_CODEC_ID_XSUB)

  387.             avio_wl32(pb, par->codec_tag);

  388.         else

  389.             avio_wl32(pb, 1);

  390.         avist->strh_flags_offset = avio_tell(pb);

  391.         avio_wl32(pb, 0); /* flags */

  392.         avio_wl16(pb, 0); /* priority */

  393.         avio_wl16(pb, 0); /* language */

  394.         avio_wl32(pb, 0); /* initial frame */

  395. 

  396.         ff_parse_specific_params(st, &au_byterate, &au_ssize, &au_scale);

  397. 

  398.         if (   par->codec_type == AVMEDIA_TYPE_VIDEO

  399.             && par->codec_id != AV_CODEC_ID_XSUB

  400.             && au_byterate > 1000LL*au_scale) {

  401.             au_byterate = 600;

  402.             au_scale    = 1;

  403.         }

  404.         avpriv_set_pts_info(st, 64, au_scale, au_byterate);

  405.         if (par->codec_id == AV_CODEC_ID_XSUB)

  406.             au_scale = au_byterate = 0;

  407. 

  408.         avio_wl32(pb, au_scale); /* scale */

  409.         avio_wl32(pb, au_byterate); /* rate */

  410. 

  411.         avio_wl32(pb, 0); /* start */

  412.         /* remember this offset to fill later */

  413.         avist->frames_hdr_strm = avio_tell(pb);

  414.         if (!(pb->seekable & AVIO_SEEKABLE_NORMAL))

  415.             /* FIXME: this may be broken, but who cares */

  416.             avio_wl32(pb, AVI_MAX_RIFF_SIZE);

  417.         else

  418.             avio_wl32(pb, 0);  /* length, XXX: filled later */

  419. 

  420.         /* suggested buffer size, is set to largest chunk size in avi_write_trailer */

  421.         if (par->codec_type == AVMEDIA_TYPE_VIDEO)

  422.             avio_wl32(pb, 1024 * 1024);

  423.         else if (par->codec_type == AVMEDIA_TYPE_AUDIO)

  424.             avio_wl32(pb, 12 * 1024);

  425.         else

  426.             avio_wl32(pb, 0);

  427.         avio_wl32(pb, -1); /* quality */

  428.         avio_wl32(pb, au_ssize); /* sample size */

  429.         avio_wl32(pb, 0);

  430.         avio_wl16(pb, par->width);

  431.         avio_wl16(pb, par->height);

  432.         ff_end_tag(pb, strh);

  433. 

  434.         if (par->codec_type != AVMEDIA_TYPE_DATA) {

  435.             int ret, flags;

  436.             enum AVPixelFormat pix_fmt;

  437. 

  438.             strf = ff_start_tag(pb, "strf");

  439.             switch (par->codec_type) {

  440.             case AVMEDIA_TYPE_SUBTITLE:

  441.                 /* XSUB subtitles behave like video tracks, other subtitles

  442.                  * are not (yet) supported. */

  443.                 if (par->codec_id != AV_CODEC_ID_XSUB)

  444.                     break;

  445.             case AVMEDIA_TYPE_VIDEO:

  446.                 /* WMP expects RGB 5:5:5 rawvideo in avi to have bpp set to 16. */

  447.                 if (  !par->codec_tag

  448.                     && par->codec_id == AV_CODEC_ID_RAWVIDEO

  449.                     && par->format == AV_PIX_FMT_RGB555LE

  450.                     && par->bits_per_coded_sample == 15)

  451.                     par->bits_per_coded_sample = 16;

  452.                 avist->pal_offset = avio_tell(pb) + 40;

  453.                 ff_put_bmp_header(pb, par, 0, 0);

  454.                 pix_fmt = avpriv_find_pix_fmt(avpriv_pix_fmt_bps_avi,

  455.                                               par->bits_per_coded_sample);

  456.                 if (   !par->codec_tag

  457.                     && par->codec_id == AV_CODEC_ID_RAWVIDEO

  458.                     && par->format != pix_fmt

  459.                     && par->format != AV_PIX_FMT_NONE)

  460.                     av_log(s, AV_LOG_ERROR, "%s rawvideo cannot be written to avi, output file will be unreadable\n",

  461.                           av_get_pix_fmt_name(par->format));

  462.                 break;

  463.             case AVMEDIA_TYPE_AUDIO:

  464.                 flags = (avi->write_channel_mask == 0) ? FF_PUT_WAV_HEADER_SKIP_CHANNELMASK : 0;

  465.                 if ((ret = ff_put_wav_header(s, pb, par, flags)) < 0)

  466.                     return ret;

  467.                 break;

  468.             default:

  469.                 av_log(s, AV_LOG_ERROR,

  470.                     "Invalid or not supported codec type '%s' found in the input\n",

  471.                     (char *)av_x_if_null(av_get_media_type_string(par->codec_type), "?"));

  472.                 return AVERROR(EINVAL);

  473.             }

  474.             ff_end_tag(pb, strf);

  475.             if ((t = av_dict_get(st->metadata, "title", NULL, 0))) {

  476.                 ff_riff_write_info_tag(s->pb, "strn", t->value);

  477.                 t = NULL;

  478.             }

  479.             if (par->codec_id == AV_CODEC_ID_XSUB

  480.             && (t = av_dict_get(s->streams[i]->metadata, "language", NULL, 0))) {

  481.                 const char* langstr = ff_convert_lang_to(t->value, AV_LANG_ISO639_1);

  482.                 t = NULL;

  483.                 if (langstr) {

  484.                     char* str = av_asprintf("Subtitle - %s-xx;02", langstr);

  485.                     if (!str)

  486.                         return AVERROR(ENOMEM);

  487.                     ff_riff_write_info_tag(s->pb, "strn", str);

  488.                     av_free(str);

  489.                 }

  490.             }

  491.         }

  492. 

  493.         if (pb->seekable & AVIO_SEEKABLE_NORMAL) {

  494.             write_odml_master(s, i);

  495.         }

  496. 

  497.         if (par->codec_type == AVMEDIA_TYPE_VIDEO   &&

  498.             st->sample_aspect_ratio.num > 0 &&

  499.             st->sample_aspect_ratio.den > 0) {

  500.             int vprp       = ff_start_tag(pb, "vprp");

  501.             AVRational dar = av_mul_q(st->sample_aspect_ratio,

  502.                                       (AVRational) { par->width,

  503.                                                      par->height });

  504.             int num, den, fields, i;

  505.             av_reduce(&num, &den, dar.num, dar.den, 0xFFFF);

  506.             if (par->field_order == AV_FIELD_TT || par->field_order == AV_FIELD_BB ||

  507.                 par->field_order == AV_FIELD_TB || par->field_order == AV_FIELD_BT) {

  508.                 fields = 2; // interlaced

  509.             } else {

  510.                 fields = 1; // progressive

  511.             }

  512. 

  513.             avio_wl32(pb, 0); // video format   = unknown

  514.             avio_wl32(pb, 0); // video standard = unknown

  515.             // TODO: should be avg_frame_rate

  516.             avio_wl32(pb, (2LL*st->time_base.den + st->time_base.num - 1) / (2LL * st->time_base.num));

  517.             avio_wl32(pb, par->width);

  518.             avio_wl32(pb, par->height);

  519.             avio_wl16(pb, den);

  520.             avio_wl16(pb, num);

  521.             avio_wl32(pb, par->width);

  522.             avio_wl32(pb, par->height);

  523.             avio_wl32(pb, fields); // fields per frame

  524. 

  525.             for (i = 0; i < fields; i++) {

  526.                 int start_line;

  527.                 // OpenDML v1.02 is not very specific on what value to use for

  528.                 // start_line when frame data is not coming from a capturing device,

  529.                 // so just use 0/1 depending on the field order for interlaced frames

  530.                 if (par->field_order == AV_FIELD_TT || par->field_order == AV_FIELD_TB) {

  531.                     start_line = (i == 0) ? 0 : 1;

  532.                 } else if (par->field_order == AV_FIELD_BB || par->field_order == AV_FIELD_BT) {

  533.                     start_line = (i == 0) ? 1 : 0;

  534.                 } else {

  535.                     start_line = 0;

  536.                 }

  537. 

  538.                 avio_wl32(pb, par->height / fields); // compressed bitmap height

  539.                 avio_wl32(pb, par->width);           // compressed bitmap width

  540.                 avio_wl32(pb, par->height / fields); // valid bitmap height

  541.                 avio_wl32(pb, par->width);           // valid bitmap width

  542.                 avio_wl32(pb, 0);                    // valid bitmap X offset

  543.                 avio_wl32(pb, 0);                    // valid bitmap Y offset

  544.                 avio_wl32(pb, 0);                    // valid X offset in T

  545.                 avio_wl32(pb, start_line);           // valid Y start line

  546.             }

  547.             ff_end_tag(pb, vprp);

  548.         }

  549. 

  550.         ff_end_tag(pb, list2);

  551.     }

  552. 

  553.     if (pb->seekable & AVIO_SEEKABLE_NORMAL) {

  554.         /* AVI could become an OpenDML one, if it grows beyond 2Gb range */

  555.         avi->odml_list = ff_start_tag(pb, "JUNK");

  556.         ffio_wfourcc(pb, "odml");

  557.         ffio_wfourcc(pb, "dmlh");

  558.         avio_wl32(pb, 248);

  559.         for (i = 0; i < 248; i += 4)

  560.             avio_wl32(pb, 0);

  561.         ff_end_tag(pb, avi->odml_list);

  562.     }

  563. 

  564.     ff_end_tag(pb, list1);

  565. 

  566.     ff_riff_write_info(s);

  567. 

  568. 

  569.     padding = s->metadata_header_padding;

  570.     if (padding < 0)

  571.         padding = 1016;

  572. 

  573.     /* some padding for easier tag editing */

  574.     if (padding) {

  575.         list2 = ff_start_tag(pb, "JUNK");

  576.         for (i = padding; i > 0; i -= 4)

  577.             avio_wl32(pb, 0);

  578.         ff_end_tag(pb, list2);

  579.     }

  580. 

  581.     avi->movi_list = ff_start_tag(pb, "LIST");

  582.     ffio_wfourcc(pb, "movi");

  583. 

  584.     avio_flush(pb);

  585. 

  586.     return 0;

  587. }

  588. 

  589. static void update_odml_entry(AVFormatContext *s, int stream_index, int64_t ix, int size)

  590. {

  591.     AVIOContext *pb = s->pb;

  592.     AVIContext *avi = s->priv_data;

  593.     AVIStream *avist = s->streams[stream_index]->priv_data;

  594.     int64_t pos;

  595.     int au_byterate, au_ssize, au_scale;

  596. 

  597.     avio_flush(pb);

  598.     pos = avio_tell(pb);

  599. 

  600.     /* Updating one entry in the AVI OpenDML master index */

  601.     avio_seek(pb, avist->indexes.indx_start - 8, SEEK_SET);

  602.     ffio_wfourcc(pb, "indx");             /* enabling this entry */

  603.     avio_skip(pb, 8);

  604.     avio_wl32(pb, avi->riff_id - avist->indexes.master_odml_riff_id_base);          /* nEntriesInUse */

  605.     avio_skip(pb, 16 * (avi->riff_id - avist->indexes.master_odml_riff_id_base));

  606.     avio_wl64(pb, ix);                    /* qwOffset */

  607.     avio_wl32(pb, size);                  /* dwSize */

  608.     ff_parse_specific_params(s->streams[stream_index], &au_byterate, &au_ssize, &au_scale);

  609.     if (s->streams[stream_index]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && au_ssize > 0) {

  610.         uint32_t audio_segm_size = (avist->audio_strm_length - avist->indexes.audio_strm_offset);

  611.         if ((audio_segm_size % au_ssize > 0) && !avist->sample_requested) {

  612.             avpriv_request_sample(s, "OpenDML index duration for audio packets with partial frames");

  613.             avist->sample_requested = 1;

  614.         }

  615.         avio_wl32(pb, audio_segm_size / au_ssize);  /* dwDuration (sample count) */

  616.     } else

  617.         avio_wl32(pb, avist->indexes.entry);  /* dwDuration (packet count) */

  618. 

  619.     avio_seek(pb, pos, SEEK_SET);

  620. }

  621. 

  622. static int avi_write_ix(AVFormatContext *s)

  623. {

  624.     AVIOContext *pb = s->pb;

  625.     AVIContext *avi = s->priv_data;

  626.     char tag[5];

  627.     char ix_tag[] = "ix00";

  628.     int i, j;

  629. 

  630.     av_assert0(pb->seekable & AVIO_SEEKABLE_NORMAL);

  631. 

  632.     for (i = 0; i < s->nb_streams; i++) {

  633.         AVIStream *avist = s->streams[i]->priv_data;

  634.         if (avi->riff_id - avist->indexes.master_odml_riff_id_base == avi->master_index_max_size) {

  635.             int64_t pos;

  636.             int size = AVI_MASTER_INDEX_PREFIX_SIZE + AVI_MASTER_INDEX_ENTRY_SIZE * avi->master_index_max_size;

  637. 

  638.             pos = avio_tell(pb);

  639.             update_odml_entry(s, i, pos, size);

  640.             write_odml_master(s, i);

  641.             av_assert1(avio_tell(pb) - pos == size);

  642.             avist->indexes.master_odml_riff_id_base = avi->riff_id - 1;

  643.         }

  644.         av_assert0(avi->riff_id - avist->indexes.master_odml_riff_id_base < avi->master_index_max_size);

  645.     }

  646. 

  647.     for (i = 0; i < s->nb_streams; i++) {

  648.         AVIStream *avist = s->streams[i]->priv_data;

  649.         int64_t ix;

  650. 

  651.         avi_stream2fourcc(tag, i, s->streams[i]->codecpar->codec_type);

  652.         ix_tag[3] = '0' + i;

  653. 

  654.         /* Writing AVI OpenDML leaf index chunk */

  655.         ix = avio_tell(pb);

  656.         ffio_wfourcc(pb, ix_tag);      /* ix?? */

  657.         avio_wl32(pb, avist->indexes.entry * 8 + 24);

  658.         /* chunk size */

  659.         avio_wl16(pb, 2);           /* wLongsPerEntry */

  660.         avio_w8(pb, 0);             /* bIndexSubType (0 == frame index) */

  661.         avio_w8(pb, 1);             /* bIndexType (1 == AVI_INDEX_OF_CHUNKS) */

  662.         avio_wl32(pb, avist->indexes.entry);

  663.         /* nEntriesInUse */

  664.         ffio_wfourcc(pb, tag);         /* dwChunkId */

  665.         avio_wl64(pb, avi->movi_list); /* qwBaseOffset */

  666.         avio_wl32(pb, 0);              /* dwReserved_3 (must be 0) */

  667. 

  668.         for (j = 0; j < avist->indexes.entry; j++) {

  669.             AVIIentry *ie = avi_get_ientry(&avist->indexes, j);

  670.             avio_wl32(pb, ie->pos + 8);

  671.             avio_wl32(pb, ((uint32_t) ie->len & ~0x80000000) |

  672.                           (ie->flags & 0x10 ? 0 : 0x80000000));

  673.         }

  674. 

  675.         update_odml_entry(s, i, ix, avio_tell(pb) - ix);

  676.     }

  677.     return 0;

  678. }

  679. 

  680. static int avi_write_idx1(AVFormatContext *s)

  681. {

  682.     AVIOContext *pb = s->pb;

  683.     AVIContext *avi = s->priv_data;

  684.     int64_t idx_chunk;

  685.     int i;

  686.     char tag[5];

  687. 

  688.     if (pb->seekable & AVIO_SEEKABLE_NORMAL) {

  689.         AVIStream *avist;

  690.         AVIIentry *ie = 0, *tie;

  691.         int empty, stream_id = -1;

  692. 

  693.         idx_chunk = ff_start_tag(pb, "idx1");

  694.         for (i = 0; i < s->nb_streams; i++) {

  695.             avist        = s->streams[i]->priv_data;

  696.             avist->entry = 0;

  697.         }

  698. 

  699.         do {

  700.             empty = 1;

  701.             for (i = 0; i < s->nb_streams; i++) {

  702.                 avist = s->streams[i]->priv_data;

  703.                 if (avist->indexes.entry <= avist->entry)

  704.                     continue;

  705. 

  706.                 tie = avi_get_ientry(&avist->indexes, avist->entry);

  707.                 if (empty || tie->pos < ie->pos) {

  708.                     ie        = tie;

  709.                     stream_id = i;

  710.                 }

  711.                 empty = 0;

  712.             }

  713.             if (!empty) {

  714.                 avist = s->streams[stream_id]->priv_data;

  715.                 if (*ie->tag)

  716.                     ffio_wfourcc(pb, ie->tag);

  717.                 else {

  718.                     avi_stream2fourcc(tag, stream_id,

  719.                                   s->streams[stream_id]->codecpar->codec_type);

  720.                     ffio_wfourcc(pb, tag);

  721.                 }

  722.                 avio_wl32(pb, ie->flags);

  723.                 avio_wl32(pb, ie->pos);

  724.                 avio_wl32(pb, ie->len);

  725.                 avist->entry++;

  726.             }

  727.         } while (!empty);

  728.         ff_end_tag(pb, idx_chunk);

  729. 

  730.         avi_write_counters(s, avi->riff_id);

  731.     }

  732.     return 0;

  733. }

  734. 

  735. static int write_skip_frames(AVFormatContext *s, int stream_index, int64_t dts)

  736. {

  737.     AVIStream *avist    = s->streams[stream_index]->priv_data;

  738.     AVCodecParameters *par = s->streams[stream_index]->codecpar;

  739. 

  740.     ff_dlog(s, "dts:%s packet_count:%d stream_index:%d\n", av_ts2str(dts), avist->packet_count, stream_index);

  741.     while (par->block_align == 0 && dts != AV_NOPTS_VALUE &&

  742.            dts > avist->packet_count && par->codec_id != AV_CODEC_ID_XSUB && avist->packet_count) {

  743.         AVPacket empty_packet;

  744. 

  745.         if (dts - avist->packet_count > 60000) {

  746.             av_log(s, AV_LOG_ERROR, "Too large number of skipped frames %"PRId64" > 60000\n", dts - avist->packet_count);

  747.             return AVERROR(EINVAL);

  748.         }

  749. 

  750.         av_init_packet(&empty_packet);

  751.         empty_packet.size         = 0;

  752.         empty_packet.data         = NULL;

  753.         empty_packet.stream_index = stream_index;

  754.         avi_write_packet_internal(s, &empty_packet);

  755.         ff_dlog(s, "dup dts:%s packet_count:%d\n", av_ts2str(dts), avist->packet_count);

  756.     }

  757. 

  758.     return 0;

  759. }

  760. 

  761. static int avi_write_packet(AVFormatContext *s, AVPacket *pkt)

  762. {

  763.     const int stream_index = pkt->stream_index;

  764.     AVCodecParameters *par = s->streams[stream_index]->codecpar;

  765.     int ret;

  766. 

  767.     if (par->codec_id == AV_CODEC_ID_H264 && par->codec_tag == MKTAG('H','2','6','4') && pkt->size) {

  768.         ret = ff_check_h264_startcode(s, s->streams[stream_index], pkt);

  769.         if (ret < 0)

  770.             return ret;

  771.     }

  772. 

  773.     if ((ret = write_skip_frames(s, stream_index, pkt->dts)) < 0)

  774.         return ret;

  775. 

  776.     if (!pkt->size)

  777.         return avi_write_packet_internal(s, pkt); /* Passthrough */

  778. 

  779.     if (par->codec_type == AVMEDIA_TYPE_VIDEO) {

  780.         AVIStream *avist = s->streams[stream_index]->priv_data;

  781.         AVIOContext *pb  = s->pb;

  782.         AVPacket *opkt   = pkt;

  783.         int reshuffle_ret;

  784.         if (par->codec_id == AV_CODEC_ID_RAWVIDEO && par->codec_tag == 0) {

  785.             int64_t bpc = par->bits_per_coded_sample != 15 ? par->bits_per_coded_sample : 16;

  786.             int expected_stride = ((par->width * bpc + 31) >> 5)*4;

  787.             reshuffle_ret = ff_reshuffle_raw_rgb(s, &pkt, par, expected_stride);

  788.             if (reshuffle_ret < 0)

  789.                 return reshuffle_ret;

  790.         } else

  791.             reshuffle_ret = 0;

  792.         if (par->format == AV_PIX_FMT_PAL8) {

  793.             ret = ff_get_packet_palette(s, opkt, reshuffle_ret, avist->palette);

  794.             if (ret < 0)

  795.                 goto fail;

  796.             if (ret) {

  797.                 int pal_size = 1 << par->bits_per_coded_sample;

  798.                 int pc_tag, i;

  799. 

  800.                 av_assert0(par->bits_per_coded_sample >= 0 && par->bits_per_coded_sample <= 8);

  801. 

  802.                 if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && avist->pal_offset) {

  803.                     int64_t cur_offset = avio_tell(pb);

  804.                     avio_seek(pb, avist->pal_offset, SEEK_SET);

  805.                     for (i = 0; i < pal_size; i++) {

  806.                         uint32_t v = avist->palette[i];

  807.                         avio_wl32(pb, v & 0xffffff);

  808.                     }

  809.                     avio_seek(pb, cur_offset, SEEK_SET);

  810.                     memcpy(avist->old_palette, avist->palette, pal_size * 4);

  811.                     avist->pal_offset = 0;

  812.                 }

  813.                 if (memcmp(avist->palette, avist->old_palette, pal_size * 4)) {

  814.                     unsigned char tag[5];

  815.                     avi_stream2fourcc(tag, stream_index, par->codec_type);

  816.                     tag[2] = 'p'; tag[3] = 'c';

  817.                     if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {

  818.                         if (avist->strh_flags_offset) {

  819.                             int64_t cur_offset = avio_tell(pb);

  820.                             avio_seek(pb, avist->strh_flags_offset, SEEK_SET);

  821.                             avio_wl32(pb, AVISF_VIDEO_PALCHANGES);

  822.                             avio_seek(pb, cur_offset, SEEK_SET);

  823.                             avist->strh_flags_offset = 0;

  824.                         }

  825.                         ret = avi_add_ientry(s, stream_index, tag, AVIIF_NO_TIME,

  826.                                        pal_size * 4 + 4);

  827.                         if (ret < 0)

  828.                             goto fail;

  829.                     }

  830.                     pc_tag = ff_start_tag(pb, tag);

  831.                     avio_w8(pb, 0);

  832.                     avio_w8(pb, pal_size & 0xFF);

  833.                     avio_wl16(pb, 0); // reserved

  834.                     for (i = 0; i < pal_size; i++) {

  835.                         uint32_t v = avist->palette[i];

  836.                         avio_wb32(pb, v<<8);

  837.                     }

  838.                     ff_end_tag(pb, pc_tag);

  839.                     memcpy(avist->old_palette, avist->palette, pal_size * 4);

  840.                 }

  841.             }

  842.         }

  843.         if (reshuffle_ret) {

  844.             ret = avi_write_packet_internal(s, pkt);

  845. 

  846. fail:

  847.             if (reshuffle_ret)

  848.                 av_packet_free(&pkt);

  849.             return ret;

  850.         }

  851.     }

  852. 

  853.     return avi_write_packet_internal(s, pkt);

  854. }

  855. 

  856. static int avi_write_packet_internal(AVFormatContext *s, AVPacket *pkt)

  857. {

  858.     unsigned char tag[5];

  859.     unsigned int flags = 0;

  860.     const int stream_index = pkt->stream_index;

  861.     int size               = pkt->size;

  862.     AVIContext *avi     = s->priv_data;

  863.     AVIOContext *pb     = s->pb;

  864.     AVIStream *avist    = s->streams[stream_index]->priv_data;

  865.     AVCodecParameters *par = s->streams[stream_index]->codecpar;

  866. 

  867.     if (pkt->dts != AV_NOPTS_VALUE)

  868.         avist->last_dts = pkt->dts + pkt->duration;

  869. 

  870.     avist->packet_count++;

  871. 

  872.     // Make sure to put an OpenDML chunk when the file size exceeds the limits

  873.     if ((pb->seekable & AVIO_SEEKABLE_NORMAL) &&

  874.         (avio_tell(pb) - avi->riff_start > AVI_MAX_RIFF_SIZE)) {

  875.         avi_write_ix(s);

  876.         ff_end_tag(pb, avi->movi_list);

  877. 

  878.         if (avi->riff_id == 1)

  879.             avi_write_idx1(s);

  880. 

  881.         ff_end_tag(pb, avi->riff_start);

  882.         avi->movi_list = avi_start_new_riff(s, pb, "AVIX", "movi");

  883.     }

  884. 

  885.     avi_stream2fourcc(tag, stream_index, par->codec_type);

  886.     if (pkt->flags & AV_PKT_FLAG_KEY)

  887.         flags = 0x10;

  888.     if (par->codec_type == AVMEDIA_TYPE_AUDIO)

  889.         avist->audio_strm_length += size;

  890. 

  891.     if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {

  892.         int ret;

  893.         ret = avi_add_ientry(s, stream_index, NULL, flags, size);

  894.         if (ret < 0)

  895.             return ret;

  896.     }

  897. 

  898.     avio_write(pb, tag, 4);

  899.     avio_wl32(pb, size);

  900.     avio_write(pb, pkt->data, size);

  901.     if (size & 1)

  902.         avio_w8(pb, 0);

  903. 

  904.     return 0;

  905. }

  906. 

  907. static int avi_write_trailer(AVFormatContext *s)

  908. {

  909.     AVIContext *avi = s->priv_data;

  910.     AVIOContext *pb = s->pb;

  911.     int res = 0;

  912.     int i, n, nb_frames;

  913.     int64_t file_size;

  914. 

  915.     for (i = 0; i < s->nb_streams; i++) {

  916.         AVIStream *avist = s->streams[i]->priv_data;

  917.         write_skip_frames(s, i, avist->last_dts);

  918.     }

  919. 

  920.     if (pb->seekable & AVIO_SEEKABLE_NORMAL) {

  921.         if (avi->riff_id == 1) {

  922.             ff_end_tag(pb, avi->movi_list);

  923.             res = avi_write_idx1(s);

  924.             ff_end_tag(pb, avi->riff_start);

  925.         } else {

  926.             avi_write_ix(s);

  927.             ff_end_tag(pb, avi->movi_list);

  928.             ff_end_tag(pb, avi->riff_start);

  929. 

  930.             file_size = avio_tell(pb);

  931.             avio_seek(pb, avi->odml_list - 8, SEEK_SET);

  932.             ffio_wfourcc(pb, "LIST"); /* Making this AVI OpenDML one */

  933.             avio_skip(pb, 16);

  934. 

  935.             for (n = nb_frames = 0; n < s->nb_streams; n++) {

  936.                 AVCodecParameters *par = s->streams[n]->codecpar;

  937.                 AVIStream *avist       = s->streams[n]->priv_data;

  938. 

  939.                 if (par->codec_type == AVMEDIA_TYPE_VIDEO) {

  940.                     if (nb_frames < avist->packet_count)

  941.                         nb_frames = avist->packet_count;

  942.                 } else {

  943.                     if (par->codec_id == AV_CODEC_ID_MP2 ||

  944.                         par->codec_id == AV_CODEC_ID_MP3)

  945.                         nb_frames += avist->packet_count;

  946.                 }

  947.             }

  948.             avio_wl32(pb, nb_frames);

  949.             avio_seek(pb, file_size, SEEK_SET);

  950. 

  951.             avi_write_counters(s, avi->riff_id);

  952.         }

  953.     }

  954. 

  955.     if (avi->riff_id >= avi->master_index_max_size) {

  956.         int index_space = AVI_MASTER_INDEX_PREFIX_SIZE +

  957.                           AVI_MASTER_INDEX_ENTRY_SIZE * avi->riff_id;

  958.         av_log(s, AV_LOG_WARNING, "Output file not strictly OpenDML compliant, "

  959.                "consider re-muxing with 'reserve_index_space' option value >= %d\n",

  960.                index_space);

  961.     }

  962. 

  963.     for (i = 0; i < s->nb_streams; i++) {

  964.         AVIStream *avist = s->streams[i]->priv_data;

  965.         if (pb->seekable & AVIO_SEEKABLE_NORMAL) {

  966.             avio_seek(pb, avist->frames_hdr_strm + 4, SEEK_SET);

  967.             avio_wl32(pb, avist->max_size);

  968.         }

  969.     }

  970. 

  971.     return res;

  972. }

  973. 

  974. static void avi_deinit(AVFormatContext *s)

  975. {

  976.     for (int i = 0; i < s->nb_streams; i++) {

  977.         AVIStream *avist = s->streams[i]->priv_data;

  978.         if (!avist)

  979.             continue;

  980.         for (int j = 0; j < avist->indexes.ents_allocated / AVI_INDEX_CLUSTER_SIZE; j++)

  981.             av_freep(&avist->indexes.cluster[j]);

  982.         av_freep(&avist->indexes.cluster);

  983.         avist->indexes.ents_allocated = avist->indexes.entry = 0;

  984.     }

  985. }

  986. 

  987. #define OFFSET(x) offsetof(AVIContext, x)

  988. #define ENC AV_OPT_FLAG_ENCODING_PARAM

  989. static const AVOption options[] = {

  990.     { "reserve_index_space", "reserve space (in bytes) at the beginning of the file for each stream index", OFFSET(reserve_index_space), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, ENC },

  991.     { "write_channel_mask", "write channel mask into wave format header", OFFSET(write_channel_mask), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, ENC },

  992.     { NULL },

  993. };

  994. 

  995. static const AVClass avi_muxer_class = {

  996.     .class_name = "AVI muxer",

  997.     .item_name  = av_default_item_name,

  998.     .option     = options,

  999.     .version    = LIBAVUTIL_VERSION_INT,

  1000. };

  1001. 

  1002. AVOutputFormat ff_avi_muxer = {

  1003.     .name           = "avi",

  1004.     .long_name      = NULL_IF_CONFIG_SMALL("AVI (Audio Video Interleaved)"),

  1005.     .mime_type      = "video/x-msvideo",

  1006.     .extensions     = "avi",

  1007.     .priv_data_size = sizeof(AVIContext),

  1008.     .audio_codec    = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_AC3,

  1009.     .video_codec    = AV_CODEC_ID_MPEG4,

  1010.     .init           = avi_init,

  1011.     .deinit         = avi_deinit,

  1012.     .write_header   = avi_write_header,

  1013.     .write_packet   = avi_write_packet,

  1014.     .write_trailer  = avi_write_trailer,

  1015.     .codec_tag      = (const AVCodecTag * const []) {

  1016.         ff_codec_bmp_tags, ff_codec_wav_tags, 0

  1017.     },

  1018.     .priv_class     = &avi_muxer_class,

  1019. };