git.sesse.net Git - ffmpeg/blob - libavformat/avienc.c

   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 //#define DEBUG
  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/internal.h"
  33 #include "libavutil/intreadwrite.h"
  34 #include "libavutil/dict.h"
  35 #include "libavutil/avassert.h"
  36 #include "libavutil/timestamp.h"
  37 #include "libavutil/pixdesc.h"
  38 #include "libavcodec/raw.h"
  39
  40 /*
  41  * TODO:
  42  *  - fill all fields if non streamed (nb_frames for example)
  43  */
  44
  45 typedef struct AVIIentry {
  46     unsigned int flags, pos, len;
  47 } AVIIentry;
  48
  49 #define AVI_INDEX_CLUSTER_SIZE 16384
  50
  51 typedef struct AVIIndex {
  52     int64_t     indx_start;
  53     int64_t     audio_strm_offset;
  54     int         entry;
  55     int         ents_allocated;
  56     int         master_odml_riff_id_base;
  57     AVIIentry** cluster;
  58 } AVIIndex;
  59
  60 typedef struct AVIContext {
  61     int64_t riff_start, movi_list, odml_list;
  62     int64_t frames_hdr_all;
  63     int riff_id;
  64 } AVIContext;
  65
  66 typedef struct AVIStream {
  67     int64_t frames_hdr_strm;
  68     int64_t audio_strm_length;
  69     int packet_count;
  70     int entry;
  71     int max_size;
  72     int sample_requested;
  73
  74     int64_t last_dts;
  75
  76     AVIIndex indexes;
  77 } AVIStream;
  78
  79 static int avi_write_packet(AVFormatContext *s, AVPacket *pkt);
  80
  81 static inline AVIIentry *avi_get_ientry(const AVIIndex *idx, int ent_id)
  82 {
  83     int cl = ent_id / AVI_INDEX_CLUSTER_SIZE;
  84     int id = ent_id % AVI_INDEX_CLUSTER_SIZE;
  85     return &idx->cluster[cl][id];
  86 }
  87
  88 static int64_t avi_start_new_riff(AVFormatContext *s, AVIOContext *pb,
  89                                   const char *riff_tag, const char *list_tag)
  90 {
  91     AVIContext *avi = s->priv_data;
  92     int64_t loff;
  93     int i;
  94
  95     avi->riff_id++;
  96     for (i = 0; i < s->nb_streams; i++) {
  97         AVIStream *avist = s->streams[i]->priv_data;
  98         avist->indexes.audio_strm_offset = avist->audio_strm_length;
  99         avist->indexes.entry = 0;
 100     }
 101
 102     avi->riff_start = ff_start_tag(pb, "RIFF");
 103     ffio_wfourcc(pb, riff_tag);
 104     loff = ff_start_tag(pb, "LIST");
 105     ffio_wfourcc(pb, list_tag);
 106     return loff;
 107 }
 108
 109 static char *avi_stream2fourcc(char *tag, int index, enum AVMediaType type)
 110 {
 111     tag[0] = '0' + index / 10;
 112     tag[1] = '0' + index % 10;
 113     if (type == AVMEDIA_TYPE_VIDEO) {
 114         tag[2] = 'd';
 115         tag[3] = 'c';
 116     } else if (type == AVMEDIA_TYPE_SUBTITLE) {
 117         // note: this is not an official code
 118         tag[2] = 's';
 119         tag[3] = 'b';
 120     } else {
 121         tag[2] = 'w';
 122         tag[3] = 'b';
 123     }
 124     tag[4] = '\0';
 125     return tag;
 126 }
 127
 128 static int avi_write_counters(AVFormatContext *s, int riff_id)
 129 {
 130     AVIOContext *pb = s->pb;
 131     AVIContext *avi = s->priv_data;
 132     int n, au_byterate, au_ssize, au_scale, nb_frames = 0;
 133     int64_t file_size;
 134     AVCodecContext *stream;
 135
 136     file_size = avio_tell(pb);
 137     for (n = 0; n < s->nb_streams; n++) {
 138         AVIStream *avist = s->streams[n]->priv_data;
 139
 140         av_assert0(avist->frames_hdr_strm);
 141         stream = s->streams[n]->codec;
 142         avio_seek(pb, avist->frames_hdr_strm, SEEK_SET);
 143         ff_parse_specific_params(s->streams[n], &au_byterate, &au_ssize, &au_scale);
 144         if (au_ssize == 0)
 145             avio_wl32(pb, avist->packet_count);
 146         else
 147             avio_wl32(pb, avist->audio_strm_length / au_ssize);
 148         if (stream->codec_type == AVMEDIA_TYPE_VIDEO)
 149             nb_frames = FFMAX(nb_frames, avist->packet_count);
 150     }
 151     if (riff_id == 1) {
 152         av_assert0(avi->frames_hdr_all);
 153         avio_seek(pb, avi->frames_hdr_all, SEEK_SET);
 154         avio_wl32(pb, nb_frames);
 155     }
 156     avio_seek(pb, file_size, SEEK_SET);
 157
 158     return 0;
 159 }
 160
 161 static void write_odml_master(AVFormatContext *s, int stream_index)
 162 {
 163     AVIOContext *pb = s->pb;
 164     AVStream *st = s->streams[stream_index];
 165     AVCodecContext *enc = st->codec;
 166     AVIStream *avist = st->priv_data;
 167     unsigned char tag[5];
 168     int j;
 169
 170     /* Starting to lay out AVI OpenDML master index.
 171         * We want to make it JUNK entry for now, since we'd
 172         * like to get away without making AVI an OpenDML one
 173         * for compatibility reasons. */
 174     avist->indexes.indx_start = ff_start_tag(pb, "JUNK");
 175     avio_wl16(pb, 4);   /* wLongsPerEntry */
 176     avio_w8(pb, 0);     /* bIndexSubType (0 == frame index) */
 177     avio_w8(pb, 0);     /* bIndexType (0 == AVI_INDEX_OF_INDEXES) */
 178     avio_wl32(pb, 0);   /* nEntriesInUse (will fill out later on) */
 179     ffio_wfourcc(pb, avi_stream2fourcc(tag, stream_index, enc->codec_type));
 180                         /* dwChunkId */
 181     avio_wl64(pb, 0);   /* dwReserved[3] */
 182     avio_wl32(pb, 0);   /* Must be 0.    */
 183     for (j = 0; j < AVI_MASTER_INDEX_SIZE * 2; j++)
 184         avio_wl64(pb, 0);
 185     ff_end_tag(pb, avist->indexes.indx_start);
 186 }
 187
 188 static int avi_write_header(AVFormatContext *s)
 189 {
 190     AVIContext *avi = s->priv_data;
 191     AVIOContext *pb = s->pb;
 192     int bitrate, n, i, nb_frames, au_byterate, au_ssize, au_scale;
 193     AVCodecContext *video_enc;
 194     AVStream *video_st = NULL;
 195     int64_t list1, list2, strh, strf;
 196     AVDictionaryEntry *t = NULL;
 197     int padding;
 198
 199     if (s->nb_streams > AVI_MAX_STREAM_COUNT) {
 200         av_log(s, AV_LOG_ERROR, "AVI does not support >%d streams\n",
 201                AVI_MAX_STREAM_COUNT);
 202         return AVERROR(EINVAL);
 203     }
 204
 205     for (n = 0; n < s->nb_streams; n++) {
 206         s->streams[n]->priv_data = av_mallocz(sizeof(AVIStream));
 207         if (!s->streams[n]->priv_data)
 208             return AVERROR(ENOMEM);
 209     }
 210
 211     /* header list */
 212     avi->riff_id = 0;
 213     list1 = avi_start_new_riff(s, pb, "AVI ", "hdrl");
 214
 215     /* avi header */
 216     ffio_wfourcc(pb, "avih");
 217     avio_wl32(pb, 14 * 4);
 218     bitrate = 0;
 219
 220     video_enc = NULL;
 221     for (n = 0; n < s->nb_streams; n++) {
 222         AVCodecContext *codec = s->streams[n]->codec;
 223         bitrate += codec->bit_rate;
 224         if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
 225             video_enc = codec;
 226             video_st = s->streams[n];
 227         }
 228     }
 229
 230     nb_frames = 0;
 231
 232     // TODO: should be avg_frame_rate
 233     if (video_st)
 234         avio_wl32(pb, (uint32_t) (INT64_C(1000000) * video_st->time_base.num /
 235                                   video_st->time_base.den));
 236     else
 237         avio_wl32(pb, 0);
 238     avio_wl32(pb, bitrate / 8); /* XXX: not quite exact */
 239     avio_wl32(pb, 0); /* padding */
 240     if (!pb->seekable)
 241         avio_wl32(pb, AVIF_TRUSTCKTYPE | AVIF_ISINTERLEAVED);  /* flags */
 242     else
 243         avio_wl32(pb, AVIF_TRUSTCKTYPE | AVIF_HASINDEX | AVIF_ISINTERLEAVED);  /* flags */
 244     avi->frames_hdr_all = avio_tell(pb); /* remember this offset to fill later */
 245     avio_wl32(pb, nb_frames); /* nb frames, filled later */
 246     avio_wl32(pb, 0); /* initial frame */
 247     avio_wl32(pb, s->nb_streams); /* nb streams */
 248     avio_wl32(pb, 1024 * 1024); /* suggested buffer size */
 249     if (video_enc) {
 250         avio_wl32(pb, video_enc->width);
 251         avio_wl32(pb, video_enc->height);
 252     } else {
 253         avio_wl32(pb, 0);
 254         avio_wl32(pb, 0);
 255     }
 256     avio_wl32(pb, 0); /* reserved */
 257     avio_wl32(pb, 0); /* reserved */
 258     avio_wl32(pb, 0); /* reserved */
 259     avio_wl32(pb, 0); /* reserved */
 260
 261     /* stream list */
 262     for (i = 0; i < n; i++) {
 263         AVStream *st = s->streams[i];
 264         AVCodecContext *enc = st->codec;
 265         AVIStream *avist = st->priv_data;
 266         list2 = ff_start_tag(pb, "LIST");
 267         ffio_wfourcc(pb, "strl");
 268
 269         /* stream generic header */
 270         strh = ff_start_tag(pb, "strh");
 271         switch (enc->codec_type) {
 272         case AVMEDIA_TYPE_SUBTITLE:
 273             // XSUB subtitles behave like video tracks, other subtitles
 274             // are not (yet) supported.
 275             if (enc->codec_id != AV_CODEC_ID_XSUB) {
 276                 av_log(s, AV_LOG_ERROR,
 277                        "Subtitle streams other than DivX XSUB are not supported by the AVI muxer.\n");
 278                 return AVERROR_PATCHWELCOME;
 279             }
 280         case AVMEDIA_TYPE_VIDEO:
 281             ffio_wfourcc(pb, "vids");
 282             break;
 283         case AVMEDIA_TYPE_AUDIO:
 284             ffio_wfourcc(pb, "auds");
 285             break;
 286 //      case AVMEDIA_TYPE_TEXT:
 287 //          ffio_wfourcc(pb, "txts");
 288 //          break;
 289         case AVMEDIA_TYPE_DATA:
 290             ffio_wfourcc(pb, "dats");
 291             break;
 292         }
 293         if (enc->codec_type == AVMEDIA_TYPE_VIDEO ||
 294             enc->codec_id == AV_CODEC_ID_XSUB)
 295             avio_wl32(pb, enc->codec_tag);
 296         else
 297             avio_wl32(pb, 1);
 298         avio_wl32(pb, 0); /* flags */
 299         avio_wl16(pb, 0); /* priority */
 300         avio_wl16(pb, 0); /* language */
 301         avio_wl32(pb, 0); /* initial frame */
 302
 303         ff_parse_specific_params(st, &au_byterate, &au_ssize, &au_scale);
 304
 305         if (   enc->codec_type == AVMEDIA_TYPE_VIDEO
 306             && enc->codec_id != AV_CODEC_ID_XSUB
 307             && au_byterate > 1000LL*au_scale) {
 308             au_byterate = 600;
 309             au_scale    = 1;
 310         }
 311         avpriv_set_pts_info(st, 64, au_scale, au_byterate);
 312         if (enc->codec_id == AV_CODEC_ID_XSUB)
 313             au_scale = au_byterate = 0;
 314
 315         avio_wl32(pb, au_scale); /* scale */
 316         avio_wl32(pb, au_byterate); /* rate */
 317
 318         avio_wl32(pb, 0); /* start */
 319         /* remember this offset to fill later */
 320         avist->frames_hdr_strm = avio_tell(pb);
 321         if (!pb->seekable)
 322             /* FIXME: this may be broken, but who cares */
 323             avio_wl32(pb, AVI_MAX_RIFF_SIZE);
 324         else
 325             avio_wl32(pb, 0);  /* length, XXX: filled later */
 326
 327         /* suggested buffer size, is set to largest chunk size in avi_write_trailer */
 328         if (enc->codec_type == AVMEDIA_TYPE_VIDEO)
 329             avio_wl32(pb, 1024 * 1024);
 330         else if (enc->codec_type == AVMEDIA_TYPE_AUDIO)
 331             avio_wl32(pb, 12 * 1024);
 332         else
 333             avio_wl32(pb, 0);
 334         avio_wl32(pb, -1); /* quality */
 335         avio_wl32(pb, au_ssize); /* sample size */
 336         avio_wl32(pb, 0);
 337         avio_wl16(pb, enc->width);
 338         avio_wl16(pb, enc->height);
 339         ff_end_tag(pb, strh);
 340
 341         if (enc->codec_type != AVMEDIA_TYPE_DATA) {
 342             int ret;
 343             enum AVPixelFormat pix_fmt;
 344
 345             strf = ff_start_tag(pb, "strf");
 346             switch (enc->codec_type) {
 347             case AVMEDIA_TYPE_SUBTITLE:
 348                 /* XSUB subtitles behave like video tracks, other subtitles
 349                  * are not (yet) supported. */
 350                 if (enc->codec_id != AV_CODEC_ID_XSUB)
 351                     break;
 352             case AVMEDIA_TYPE_VIDEO:
 353                 /* WMP expects RGB 5:5:5 rawvideo in avi to have bpp set to 16. */
 354                 if (  !enc->codec_tag
 355                     && enc->codec_id == AV_CODEC_ID_RAWVIDEO
 356                     && enc->pix_fmt == AV_PIX_FMT_RGB555LE
 357                     && enc->bits_per_coded_sample == 15)
 358                     enc->bits_per_coded_sample = 16;
 359                 ff_put_bmp_header(pb, enc, ff_codec_bmp_tags, 0, 0);
 360                 pix_fmt = avpriv_find_pix_fmt(avpriv_pix_fmt_bps_avi,
 361                                               enc->bits_per_coded_sample);
 362                 if (   !enc->codec_tag
 363                     && enc->codec_id == AV_CODEC_ID_RAWVIDEO
 364                     && enc->pix_fmt != pix_fmt
 365                     && enc->pix_fmt != AV_PIX_FMT_NONE)
 366                     av_log(s, AV_LOG_ERROR, "%s rawvideo cannot be written to avi, output file will be unreadable\n",
 367                           av_get_pix_fmt_name(enc->pix_fmt));
 368                 break;
 369             case AVMEDIA_TYPE_AUDIO:
 370                 if ((ret = ff_put_wav_header(pb, enc, 0)) < 0)
 371                     return ret;
 372                 break;
 373             default:
 374                 av_log(s, AV_LOG_ERROR,
 375                     "Invalid or not supported codec type '%s' found in the input\n",
 376                     (char *)av_x_if_null(av_get_media_type_string(enc->codec_type), "?"));
 377                 return AVERROR(EINVAL);
 378             }
 379             ff_end_tag(pb, strf);
 380             if ((t = av_dict_get(st->metadata, "title", NULL, 0))) {
 381                 ff_riff_write_info_tag(s->pb, "strn", t->value);
 382                 t = NULL;
 383             }
 384             if (enc->codec_id == AV_CODEC_ID_XSUB
 385             && (t = av_dict_get(s->streams[i]->metadata, "language", NULL, 0))) {
 386                 const char* langstr = av_convert_lang_to(t->value, AV_LANG_ISO639_1);
 387                 t = NULL;
 388                 if (langstr) {
 389                     char* str = av_asprintf("Subtitle - %s-xx;02", langstr);
 390                     if (!str)
 391                         return AVERROR(ENOMEM);
 392                     ff_riff_write_info_tag(s->pb, "strn", str);
 393                     av_free(str);
 394                 }
 395             }
 396         }
 397
 398         if (pb->seekable) {
 399             write_odml_master(s, i);
 400         }
 401
 402         if (enc->codec_type == AVMEDIA_TYPE_VIDEO   &&
 403             st->sample_aspect_ratio.num > 0 &&
 404             st->sample_aspect_ratio.den > 0) {
 405             int vprp       = ff_start_tag(pb, "vprp");
 406             AVRational dar = av_mul_q(st->sample_aspect_ratio,
 407                                       (AVRational) { enc->width,
 408                                                      enc->height });
 409             int num, den;
 410             av_reduce(&num, &den, dar.num, dar.den, 0xFFFF);
 411
 412             avio_wl32(pb, 0); // video format   = unknown
 413             avio_wl32(pb, 0); // video standard = unknown
 414             // TODO: should be avg_frame_rate
 415             avio_wl32(pb, (2LL*st->time_base.den + st->time_base.num - 1) / (2LL * st->time_base.num));
 416             avio_wl32(pb, enc->width);
 417             avio_wl32(pb, enc->height);
 418             avio_wl16(pb, den);
 419             avio_wl16(pb, num);
 420             avio_wl32(pb, enc->width);
 421             avio_wl32(pb, enc->height);
 422             avio_wl32(pb, 1); // progressive FIXME
 423
 424             avio_wl32(pb, enc->height);
 425             avio_wl32(pb, enc->width);
 426             avio_wl32(pb, enc->height);
 427             avio_wl32(pb, enc->width);
 428             avio_wl32(pb, 0);
 429             avio_wl32(pb, 0);
 430
 431             avio_wl32(pb, 0);
 432             avio_wl32(pb, 0);
 433             ff_end_tag(pb, vprp);
 434         }
 435
 436         ff_end_tag(pb, list2);
 437     }
 438
 439     if (pb->seekable) {
 440         /* AVI could become an OpenDML one, if it grows beyond 2Gb range */
 441         avi->odml_list = ff_start_tag(pb, "JUNK");
 442         ffio_wfourcc(pb, "odml");
 443         ffio_wfourcc(pb, "dmlh");
 444         avio_wl32(pb, 248);
 445         for (i = 0; i < 248; i += 4)
 446             avio_wl32(pb, 0);
 447         ff_end_tag(pb, avi->odml_list);
 448     }
 449
 450     ff_end_tag(pb, list1);
 451
 452     ff_riff_write_info(s);
 453
 454
 455     padding = s->metadata_header_padding;
 456     if (padding < 0)
 457         padding = 1016;
 458
 459     /* some padding for easier tag editing */
 460     if (padding) {
 461         list2 = ff_start_tag(pb, "JUNK");
 462         for (i = padding; i > 0; i -= 4)
 463             avio_wl32(pb, 0);
 464         ff_end_tag(pb, list2);
 465     }
 466
 467     avi->movi_list = ff_start_tag(pb, "LIST");
 468     ffio_wfourcc(pb, "movi");
 469
 470     avio_flush(pb);
 471
 472     return 0;
 473 }
 474
 475 static void update_odml_entry(AVFormatContext *s, int stream_index, int64_t ix, int size)
 476 {
 477     AVIOContext *pb = s->pb;
 478     AVIContext *avi = s->priv_data;
 479     AVIStream *avist = s->streams[stream_index]->priv_data;
 480     int64_t pos;
 481     int au_byterate, au_ssize, au_scale;
 482
 483     avio_flush(pb);
 484     pos = avio_tell(pb);
 485
 486     /* Updating one entry in the AVI OpenDML master index */
 487     avio_seek(pb, avist->indexes.indx_start - 8, SEEK_SET);
 488     ffio_wfourcc(pb, "indx");             /* enabling this entry */
 489     avio_skip(pb, 8);
 490     avio_wl32(pb, avi->riff_id - avist->indexes.master_odml_riff_id_base);          /* nEntriesInUse */
 491     avio_skip(pb, 16 * (avi->riff_id - avist->indexes.master_odml_riff_id_base));
 492     avio_wl64(pb, ix);                    /* qwOffset */
 493     avio_wl32(pb, size);                  /* dwSize */
 494     ff_parse_specific_params(s->streams[stream_index], &au_byterate, &au_ssize, &au_scale);
 495     if (s->streams[stream_index]->codec->codec_type == AVMEDIA_TYPE_AUDIO && au_ssize > 0) {
 496         uint32_t audio_segm_size = (avist->audio_strm_length - avist->indexes.audio_strm_offset);
 497         if ((audio_segm_size % au_ssize > 0) && !avist->sample_requested) {
 498             avpriv_request_sample(s, "OpenDML index duration for audio packets with partial frames");
 499             avist->sample_requested = 1;
 500         }
 501         avio_wl32(pb, audio_segm_size / au_ssize);  /* dwDuration (sample count) */
 502     } else
 503         avio_wl32(pb, avist->indexes.entry);  /* dwDuration (packet count) */
 504
 505     avio_seek(pb, pos, SEEK_SET);
 506 }
 507
 508 static int avi_write_ix(AVFormatContext *s)
 509 {
 510     AVIOContext *pb = s->pb;
 511     AVIContext *avi = s->priv_data;
 512     char tag[5];
 513     char ix_tag[] = "ix00";
 514     int i, j;
 515
 516     av_assert0(pb->seekable);
 517
 518     for (i = 0; i < s->nb_streams; i++) {
 519         AVIStream *avist = s->streams[i]->priv_data;
 520         if (avi->riff_id - avist->indexes.master_odml_riff_id_base == AVI_MASTER_INDEX_SIZE) {
 521             int64_t pos;
 522             int size = 8+2+1+1+4+8+4+4+16*AVI_MASTER_INDEX_SIZE;
 523
 524             pos = avio_tell(pb);
 525             update_odml_entry(s, i, pos, size);
 526             write_odml_master(s, i);
 527             av_assert1(avio_tell(pb) - pos == size);
 528             avist->indexes.master_odml_riff_id_base = avi->riff_id - 1;
 529         }
 530         av_assert0(avi->riff_id - avist->indexes.master_odml_riff_id_base < AVI_MASTER_INDEX_SIZE);
 531     }
 532
 533     for (i = 0; i < s->nb_streams; i++) {
 534         AVIStream *avist = s->streams[i]->priv_data;
 535         int64_t ix;
 536
 537         avi_stream2fourcc(tag, i, s->streams[i]->codec->codec_type);
 538         ix_tag[3] = '0' + i;
 539
 540         /* Writing AVI OpenDML leaf index chunk */
 541         ix = avio_tell(pb);
 542         ffio_wfourcc(pb, ix_tag);      /* ix?? */
 543         avio_wl32(pb, avist->indexes.entry * 8 + 24);
 544         /* chunk size */
 545         avio_wl16(pb, 2);           /* wLongsPerEntry */
 546         avio_w8(pb, 0);             /* bIndexSubType (0 == frame index) */
 547         avio_w8(pb, 1);             /* bIndexType (1 == AVI_INDEX_OF_CHUNKS) */
 548         avio_wl32(pb, avist->indexes.entry);
 549         /* nEntriesInUse */
 550         ffio_wfourcc(pb, tag);         /* dwChunkId */
 551         avio_wl64(pb, avi->movi_list); /* qwBaseOffset */
 552         avio_wl32(pb, 0);              /* dwReserved_3 (must be 0) */
 553
 554         for (j = 0; j < avist->indexes.entry; j++) {
 555             AVIIentry *ie = avi_get_ientry(&avist->indexes, j);
 556             avio_wl32(pb, ie->pos + 8);
 557             avio_wl32(pb, ((uint32_t) ie->len & ~0x80000000) |
 558                           (ie->flags & 0x10 ? 0 : 0x80000000));
 559         }
 560
 561         update_odml_entry(s, i, ix, avio_tell(pb) - ix);
 562     }
 563     return 0;
 564 }
 565
 566 static int avi_write_idx1(AVFormatContext *s)
 567 {
 568     AVIOContext *pb = s->pb;
 569     AVIContext *avi = s->priv_data;
 570     int64_t idx_chunk;
 571     int i;
 572     char tag[5];
 573
 574     if (pb->seekable) {
 575         AVIStream *avist;
 576         AVIIentry *ie = 0, *tie;
 577         int empty, stream_id = -1;
 578
 579         idx_chunk = ff_start_tag(pb, "idx1");
 580         for (i = 0; i < s->nb_streams; i++) {
 581             avist        = s->streams[i]->priv_data;
 582             avist->entry = 0;
 583         }
 584
 585         do {
 586             empty = 1;
 587             for (i = 0; i < s->nb_streams; i++) {
 588                 avist = s->streams[i]->priv_data;
 589                 if (avist->indexes.entry <= avist->entry)
 590                     continue;
 591
 592                 tie = avi_get_ientry(&avist->indexes, avist->entry);
 593                 if (empty || tie->pos < ie->pos) {
 594                     ie        = tie;
 595                     stream_id = i;
 596                 }
 597                 empty = 0;
 598             }
 599             if (!empty) {
 600                 avist = s->streams[stream_id]->priv_data;
 601                 avi_stream2fourcc(tag, stream_id,
 602                                   s->streams[stream_id]->codec->codec_type);
 603                 ffio_wfourcc(pb, tag);
 604                 avio_wl32(pb, ie->flags);
 605                 avio_wl32(pb, ie->pos);
 606                 avio_wl32(pb, ie->len);
 607                 avist->entry++;
 608             }
 609         } while (!empty);
 610         ff_end_tag(pb, idx_chunk);
 611
 612         avi_write_counters(s, avi->riff_id);
 613     }
 614     return 0;
 615 }
 616
 617 static int write_skip_frames(AVFormatContext *s, int stream_index, int64_t dts)
 618 {
 619     AVIStream *avist    = s->streams[stream_index]->priv_data;
 620     AVCodecContext *enc = s->streams[stream_index]->codec;
 621
 622     ff_dlog(s, "dts:%s packet_count:%d stream_index:%d\n", av_ts2str(dts), avist->packet_count, stream_index);
 623     while (enc->block_align == 0 && dts != AV_NOPTS_VALUE &&
 624            dts > avist->packet_count && enc->codec_id != AV_CODEC_ID_XSUB && avist->packet_count) {
 625         AVPacket empty_packet;
 626
 627         if (dts - avist->packet_count > 60000) {
 628             av_log(s, AV_LOG_ERROR, "Too large number of skipped frames %"PRId64" > 60000\n", dts - avist->packet_count);
 629             return AVERROR(EINVAL);
 630         }
 631
 632         av_init_packet(&empty_packet);
 633         empty_packet.size         = 0;
 634         empty_packet.data         = NULL;
 635         empty_packet.stream_index = stream_index;
 636         avi_write_packet(s, &empty_packet);
 637         ff_dlog(s, "dup dts:%s packet_count:%d\n", av_ts2str(dts), avist->packet_count);
 638     }
 639
 640     return 0;
 641 }
 642
 643 static int avi_write_packet(AVFormatContext *s, AVPacket *pkt)
 644 {
 645     unsigned char tag[5];
 646     unsigned int flags = 0;
 647     const int stream_index = pkt->stream_index;
 648     int size               = pkt->size;
 649     AVIContext *avi     = s->priv_data;
 650     AVIOContext *pb     = s->pb;
 651     AVIStream *avist    = s->streams[stream_index]->priv_data;
 652     AVCodecContext *enc = s->streams[stream_index]->codec;
 653     int ret;
 654
 655     if (enc->codec_id == AV_CODEC_ID_H264 && enc->codec_tag == MKTAG('H','2','6','4') && pkt->size) {
 656         ret = ff_check_h264_startcode(s, s->streams[stream_index], pkt);
 657         if (ret < 0)
 658             return ret;
 659     }
 660
 661     if ((ret = write_skip_frames(s, stream_index, pkt->dts)) < 0)
 662         return ret;
 663
 664     if (pkt->dts != AV_NOPTS_VALUE)
 665         avist->last_dts = pkt->dts + pkt->duration;
 666
 667     avist->packet_count++;
 668
 669     // Make sure to put an OpenDML chunk when the file size exceeds the limits
 670     if (pb->seekable &&
 671         (avio_tell(pb) - avi->riff_start > AVI_MAX_RIFF_SIZE)) {
 672         avi_write_ix(s);
 673         ff_end_tag(pb, avi->movi_list);
 674
 675         if (avi->riff_id == 1)
 676             avi_write_idx1(s);
 677
 678         ff_end_tag(pb, avi->riff_start);
 679         avi->movi_list = avi_start_new_riff(s, pb, "AVIX", "movi");
 680     }
 681
 682     avi_stream2fourcc(tag, stream_index, enc->codec_type);
 683     if (pkt->flags & AV_PKT_FLAG_KEY)
 684         flags = 0x10;
 685     if (enc->codec_type == AVMEDIA_TYPE_AUDIO)
 686         avist->audio_strm_length += size;
 687
 688     if (s->pb->seekable) {
 689         AVIIndex *idx = &avist->indexes;
 690         int cl = idx->entry / AVI_INDEX_CLUSTER_SIZE;
 691         int id = idx->entry % AVI_INDEX_CLUSTER_SIZE;
 692         if (idx->ents_allocated <= idx->entry) {
 693             idx->cluster = av_realloc_f(idx->cluster, sizeof(void*), cl+1);
 694             if (!idx->cluster) {
 695                 idx->ents_allocated = 0;
 696                 idx->entry          = 0;
 697                 return AVERROR(ENOMEM);
 698             }
 699             idx->cluster[cl] =
 700                 av_malloc(AVI_INDEX_CLUSTER_SIZE * sizeof(AVIIentry));
 701             if (!idx->cluster[cl])
 702                 return AVERROR(ENOMEM);
 703             idx->ents_allocated += AVI_INDEX_CLUSTER_SIZE;
 704         }
 705
 706         idx->cluster[cl][id].flags = flags;
 707         idx->cluster[cl][id].pos   = avio_tell(pb) - avi->movi_list;
 708         idx->cluster[cl][id].len   = size;
 709         avist->max_size = FFMAX(avist->max_size, size);
 710         idx->entry++;
 711     }
 712
 713     avio_write(pb, tag, 4);
 714     avio_wl32(pb, size);
 715     avio_write(pb, pkt->data, size);
 716     if (size & 1)
 717         avio_w8(pb, 0);
 718
 719     return 0;
 720 }
 721
 722 static int avi_write_trailer(AVFormatContext *s)
 723 {
 724     AVIContext *avi = s->priv_data;
 725     AVIOContext *pb = s->pb;
 726     int res = 0;
 727     int i, j, n, nb_frames;
 728     int64_t file_size;
 729
 730     for (i = 0; i < s->nb_streams; i++) {
 731         AVIStream *avist = s->streams[i]->priv_data;
 732         write_skip_frames(s, i, avist->last_dts);
 733     }
 734
 735     if (pb->seekable) {
 736         if (avi->riff_id == 1) {
 737             ff_end_tag(pb, avi->movi_list);
 738             res = avi_write_idx1(s);
 739             ff_end_tag(pb, avi->riff_start);
 740         } else {
 741             avi_write_ix(s);
 742             ff_end_tag(pb, avi->movi_list);
 743             ff_end_tag(pb, avi->riff_start);
 744
 745             file_size = avio_tell(pb);
 746             avio_seek(pb, avi->odml_list - 8, SEEK_SET);
 747             ffio_wfourcc(pb, "LIST"); /* Making this AVI OpenDML one */
 748             avio_skip(pb, 16);
 749
 750             for (n = nb_frames = 0; n < s->nb_streams; n++) {
 751                 AVCodecContext *stream = s->streams[n]->codec;
 752                 AVIStream *avist       = s->streams[n]->priv_data;
 753
 754                 if (stream->codec_type == AVMEDIA_TYPE_VIDEO) {
 755                     if (nb_frames < avist->packet_count)
 756                         nb_frames = avist->packet_count;
 757                 } else {
 758                     if (stream->codec_id == AV_CODEC_ID_MP2 ||
 759                         stream->codec_id == AV_CODEC_ID_MP3)
 760                         nb_frames += avist->packet_count;
 761                 }
 762             }
 763             avio_wl32(pb, nb_frames);
 764             avio_seek(pb, file_size, SEEK_SET);
 765
 766             avi_write_counters(s, avi->riff_id);
 767         }
 768     }
 769
 770     for (i = 0; i < s->nb_streams; i++) {
 771         AVIStream *avist = s->streams[i]->priv_data;
 772         for (j = 0; j < avist->indexes.ents_allocated / AVI_INDEX_CLUSTER_SIZE; j++)
 773             av_freep(&avist->indexes.cluster[j]);
 774         av_freep(&avist->indexes.cluster);
 775         avist->indexes.ents_allocated = avist->indexes.entry = 0;
 776         if (pb->seekable) {
 777             avio_seek(pb, avist->frames_hdr_strm + 4, SEEK_SET);
 778             avio_wl32(pb, avist->max_size);
 779         }
 780     }
 781
 782     return res;
 783 }
 784
 785 AVOutputFormat ff_avi_muxer = {
 786     .name           = "avi",
 787     .long_name      = NULL_IF_CONFIG_SMALL("AVI (Audio Video Interleaved)"),
 788     .mime_type      = "video/x-msvideo",
 789     .extensions     = "avi",
 790     .priv_data_size = sizeof(AVIContext),
 791     .audio_codec    = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_AC3,
 792     .video_codec    = AV_CODEC_ID_MPEG4,
 793     .write_header   = avi_write_header,
 794     .write_packet   = avi_write_packet,
 795     .write_trailer  = avi_write_trailer,
 796     .codec_tag      = (const AVCodecTag * const []) {
 797         ff_codec_bmp_tags, ff_codec_wav_tags, 0
 798     },
 799 };