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

   1 /*
   2  * Matroska muxer
   3  * Copyright (c) 2007 David Conrad
   4  *
   5  * This file is part of Libav.
   6  *
   7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <stdint.h>
  23
  24 #include "avc.h"
  25 #include "hevc.h"
  26 #include "avformat.h"
  27 #include "avlanguage.h"
  28 #include "flacenc.h"
  29 #include "internal.h"
  30 #include "isom.h"
  31 #include "matroska.h"
  32 #include "riff.h"
  33 #include "vorbiscomment.h"
  34 #include "wv.h"
  35
  36 #include "libavutil/avstring.h"
  37 #include "libavutil/channel_layout.h"
  38 #include "libavutil/dict.h"
  39 #include "libavutil/intfloat.h"
  40 #include "libavutil/intreadwrite.h"
  41 #include "libavutil/lfg.h"
  42 #include "libavutil/mathematics.h"
  43 #include "libavutil/opt.h"
  44 #include "libavutil/random_seed.h"
  45 #include "libavutil/samplefmt.h"
  46 #include "libavutil/stereo3d.h"
  47
  48 #include "libavcodec/xiph.h"
  49 #include "libavcodec/mpeg4audio.h"
  50
  51 typedef struct ebml_master {
  52     int64_t         pos;                ///< absolute offset in the file where the master's elements start
  53     int             sizebytes;          ///< how many bytes were reserved for the size
  54 } ebml_master;
  55
  56 typedef struct mkv_seekhead_entry {
  57     unsigned int    elementid;
  58     uint64_t        segmentpos;
  59 } mkv_seekhead_entry;
  60
  61 typedef struct mkv_seekhead {
  62     int64_t                 filepos;
  63     int64_t                 segment_offset;     ///< the file offset to the beginning of the segment
  64     int                     reserved_size;      ///< -1 if appending to file
  65     int                     max_entries;
  66     mkv_seekhead_entry      *entries;
  67     int                     num_entries;
  68 } mkv_seekhead;
  69
  70 typedef struct mkv_cuepoint {
  71     uint64_t        pts;
  72     int             tracknum;
  73     int64_t         cluster_pos;        ///< file offset of the cluster containing the block
  74 } mkv_cuepoint;
  75
  76 typedef struct mkv_cues {
  77     int64_t         segment_offset;
  78     mkv_cuepoint    *entries;
  79     int             num_entries;
  80 } mkv_cues;
  81
  82 typedef struct mkv_track {
  83     int             write_dts;
  84     int             sample_rate;
  85     int64_t         sample_rate_offset;
  86     int64_t         codecpriv_offset;
  87     int64_t         ts_offset;
  88 } mkv_track;
  89
  90 #define MODE_MATROSKAv2 0x01
  91 #define MODE_WEBM       0x02
  92
  93 typedef struct MatroskaMuxContext {
  94     const AVClass  *class;
  95     int             mode;
  96     AVIOContext   *dyn_bc;
  97     ebml_master     segment;
  98     int64_t         segment_offset;
  99     ebml_master     cluster;
 100     int64_t         cluster_pos;        ///< file offset of the current cluster
 101     int64_t         cluster_pts;
 102     int64_t         duration_offset;
 103     int64_t         duration;
 104     mkv_seekhead    *main_seekhead;
 105     mkv_cues        *cues;
 106     mkv_track       *tracks;
 107
 108     AVPacket        cur_audio_pkt;
 109
 110     int have_attachments;
 111     int have_video;
 112
 113     int reserve_cues_space;
 114     int cluster_size_limit;
 115     int64_t cues_pos;
 116     int64_t cluster_time_limit;
 117     int wrote_chapters;
 118 } MatroskaMuxContext;
 119
 120
 121 /** 2 bytes * 3 for EBML IDs, 3 1-byte EBML lengths, 8 bytes for 64 bit
 122  * offset, 4 bytes for target EBML ID */
 123 #define MAX_SEEKENTRY_SIZE 21
 124
 125 /** per-cuepoint-track - 3 1-byte EBML IDs, 3 1-byte EBML sizes, 2
 126  * 8-byte uint max */
 127 #define MAX_CUETRACKPOS_SIZE 22
 128
 129 /** per-cuepoint - 2 1-byte EBML IDs, 2 1-byte EBML sizes, 8-byte uint max */
 130 #define MAX_CUEPOINT_SIZE(num_tracks) 12 + MAX_CUETRACKPOS_SIZE * num_tracks
 131
 132 static int ebml_id_size(unsigned int id)
 133 {
 134     return (av_log2(id + 1) - 1) / 7 + 1;
 135 }
 136
 137 static void put_ebml_id(AVIOContext *pb, unsigned int id)
 138 {
 139     int i = ebml_id_size(id);
 140     while (i--)
 141         avio_w8(pb, id >> (i * 8));
 142 }
 143
 144 /**
 145  * Write an EBML size meaning "unknown size".
 146  *
 147  * @param bytes The number of bytes the size should occupy (maximum: 8).
 148  */
 149 static void put_ebml_size_unknown(AVIOContext *pb, int bytes)
 150 {
 151     assert(bytes <= 8);
 152     avio_w8(pb, 0x1ff >> bytes);
 153     while (--bytes)
 154         avio_w8(pb, 0xff);
 155 }
 156
 157 /**
 158  * Calculate how many bytes are needed to represent a given number in EBML.
 159  */
 160 static int ebml_num_size(uint64_t num)
 161 {
 162     int bytes = 1;
 163     while ((num + 1) >> bytes * 7)
 164         bytes++;
 165     return bytes;
 166 }
 167
 168 /**
 169  * Write a number in EBML variable length format.
 170  *
 171  * @param bytes The number of bytes that need to be used to write the number.
 172  *              If zero, any number of bytes can be used.
 173  */
 174 static void put_ebml_num(AVIOContext *pb, uint64_t num, int bytes)
 175 {
 176     int i, needed_bytes = ebml_num_size(num);
 177
 178     // sizes larger than this are currently undefined in EBML
 179     assert(num < (1ULL << 56) - 1);
 180
 181     if (bytes == 0)
 182         // don't care how many bytes are used, so use the min
 183         bytes = needed_bytes;
 184     // the bytes needed to write the given size would exceed the bytes
 185     // that we need to use, so write unknown size. This shouldn't happen.
 186     assert(bytes >= needed_bytes);
 187
 188     num |= 1ULL << bytes * 7;
 189     for (i = bytes - 1; i >= 0; i--)
 190         avio_w8(pb, num >> i * 8);
 191 }
 192
 193 static void put_ebml_uint(AVIOContext *pb, unsigned int elementid, uint64_t val)
 194 {
 195     int i, bytes = 1;
 196     uint64_t tmp = val;
 197     while (tmp >>= 8)
 198         bytes++;
 199
 200     put_ebml_id(pb, elementid);
 201     put_ebml_num(pb, bytes, 0);
 202     for (i = bytes - 1; i >= 0; i--)
 203         avio_w8(pb, val >> i * 8);
 204 }
 205
 206 static void put_ebml_float(AVIOContext *pb, unsigned int elementid, double val)
 207 {
 208     put_ebml_id(pb, elementid);
 209     put_ebml_num(pb, 8, 0);
 210     avio_wb64(pb, av_double2int(val));
 211 }
 212
 213 static void put_ebml_binary(AVIOContext *pb, unsigned int elementid,
 214                             const void *buf, int size)
 215 {
 216     put_ebml_id(pb, elementid);
 217     put_ebml_num(pb, size, 0);
 218     avio_write(pb, buf, size);
 219 }
 220
 221 static void put_ebml_string(AVIOContext *pb, unsigned int elementid,
 222                             const char *str)
 223 {
 224     put_ebml_binary(pb, elementid, str, strlen(str));
 225 }
 226
 227 /**
 228  * Write a void element of a given size. Useful for reserving space in
 229  * the file to be written to later.
 230  *
 231  * @param size The number of bytes to reserve, which must be at least 2.
 232  */
 233 static void put_ebml_void(AVIOContext *pb, uint64_t size)
 234 {
 235     int64_t currentpos = avio_tell(pb);
 236
 237     assert(size >= 2);
 238
 239     put_ebml_id(pb, EBML_ID_VOID);
 240     // we need to subtract the length needed to store the size from the
 241     // size we need to reserve so 2 cases, we use 8 bytes to store the
 242     // size if possible, 1 byte otherwise
 243     if (size < 10)
 244         put_ebml_num(pb, size - 1, 0);
 245     else
 246         put_ebml_num(pb, size - 9, 8);
 247     while (avio_tell(pb) < currentpos + size)
 248         avio_w8(pb, 0);
 249 }
 250
 251 static ebml_master start_ebml_master(AVIOContext *pb, unsigned int elementid,
 252                                      uint64_t expectedsize)
 253 {
 254     int bytes = expectedsize ? ebml_num_size(expectedsize) : 8;
 255     put_ebml_id(pb, elementid);
 256     put_ebml_size_unknown(pb, bytes);
 257     return (ebml_master) {avio_tell(pb), bytes };
 258 }
 259
 260 static void end_ebml_master(AVIOContext *pb, ebml_master master)
 261 {
 262     int64_t pos = avio_tell(pb);
 263
 264     if (avio_seek(pb, master.pos - master.sizebytes, SEEK_SET) < 0)
 265         return;
 266     put_ebml_num(pb, pos - master.pos, master.sizebytes);
 267     avio_seek(pb, pos, SEEK_SET);
 268 }
 269
 270 static void put_xiph_size(AVIOContext *pb, int size)
 271 {
 272     int i;
 273     for (i = 0; i < size / 255; i++)
 274         avio_w8(pb, 255);
 275     avio_w8(pb, size % 255);
 276 }
 277
 278 /**
 279  * Initialize a mkv_seekhead element to be ready to index level 1 Matroska
 280  * elements. If a maximum number of elements is specified, enough space
 281  * will be reserved at the current file location to write a seek head of
 282  * that size.
 283  *
 284  * @param segment_offset The absolute offset to the position in the file
 285  *                       where the segment begins.
 286  * @param numelements The maximum number of elements that will be indexed
 287  *                    by this seek head, 0 if unlimited.
 288  */
 289 static mkv_seekhead *mkv_start_seekhead(AVIOContext *pb, int64_t segment_offset,
 290                                         int numelements)
 291 {
 292     mkv_seekhead *new_seekhead = av_mallocz(sizeof(mkv_seekhead));
 293     if (!new_seekhead)
 294         return NULL;
 295
 296     new_seekhead->segment_offset = segment_offset;
 297
 298     if (numelements > 0) {
 299         new_seekhead->filepos = avio_tell(pb);
 300         // 21 bytes max for a seek entry, 10 bytes max for the SeekHead ID
 301         // and size, and 3 bytes to guarantee that an EBML void element
 302         // will fit afterwards
 303         new_seekhead->reserved_size = numelements * MAX_SEEKENTRY_SIZE + 13;
 304         new_seekhead->max_entries   = numelements;
 305         put_ebml_void(pb, new_seekhead->reserved_size);
 306     }
 307     return new_seekhead;
 308 }
 309
 310 static int mkv_add_seekhead_entry(mkv_seekhead *seekhead, unsigned int elementid, uint64_t filepos)
 311 {
 312     int err;
 313
 314     // don't store more elements than we reserved space for
 315     if (seekhead->max_entries > 0 && seekhead->max_entries <= seekhead->num_entries)
 316         return -1;
 317
 318     if ((err = av_reallocp_array(&seekhead->entries, seekhead->num_entries + 1,
 319                                  sizeof(*seekhead->entries))) < 0) {
 320         seekhead->num_entries = 0;
 321         return err;
 322     }
 323
 324     seekhead->entries[seekhead->num_entries].elementid    = elementid;
 325     seekhead->entries[seekhead->num_entries++].segmentpos = filepos - seekhead->segment_offset;
 326
 327     return 0;
 328 }
 329
 330 /**
 331  * Write the seek head to the file and free it. If a maximum number of
 332  * elements was specified to mkv_start_seekhead(), the seek head will
 333  * be written at the location reserved for it. Otherwise, it is written
 334  * at the current location in the file.
 335  *
 336  * @return The file offset where the seekhead was written,
 337  * -1 if an error occurred.
 338  */
 339 static int64_t mkv_write_seekhead(AVIOContext *pb, mkv_seekhead *seekhead)
 340 {
 341     ebml_master metaseek, seekentry;
 342     int64_t currentpos;
 343     int i;
 344
 345     currentpos = avio_tell(pb);
 346
 347     if (seekhead->reserved_size > 0) {
 348         if (avio_seek(pb, seekhead->filepos, SEEK_SET) < 0) {
 349             currentpos = -1;
 350             goto fail;
 351         }
 352     }
 353
 354     metaseek = start_ebml_master(pb, MATROSKA_ID_SEEKHEAD, seekhead->reserved_size);
 355     for (i = 0; i < seekhead->num_entries; i++) {
 356         mkv_seekhead_entry *entry = &seekhead->entries[i];
 357
 358         seekentry = start_ebml_master(pb, MATROSKA_ID_SEEKENTRY, MAX_SEEKENTRY_SIZE);
 359
 360         put_ebml_id(pb, MATROSKA_ID_SEEKID);
 361         put_ebml_num(pb, ebml_id_size(entry->elementid), 0);
 362         put_ebml_id(pb, entry->elementid);
 363
 364         put_ebml_uint(pb, MATROSKA_ID_SEEKPOSITION, entry->segmentpos);
 365         end_ebml_master(pb, seekentry);
 366     }
 367     end_ebml_master(pb, metaseek);
 368
 369     if (seekhead->reserved_size > 0) {
 370         uint64_t remaining = seekhead->filepos + seekhead->reserved_size - avio_tell(pb);
 371         put_ebml_void(pb, remaining);
 372         avio_seek(pb, currentpos, SEEK_SET);
 373
 374         currentpos = seekhead->filepos;
 375     }
 376 fail:
 377     av_free(seekhead->entries);
 378     av_free(seekhead);
 379
 380     return currentpos;
 381 }
 382
 383 static mkv_cues *mkv_start_cues(int64_t segment_offset)
 384 {
 385     mkv_cues *cues = av_mallocz(sizeof(mkv_cues));
 386     if (!cues)
 387         return NULL;
 388
 389     cues->segment_offset = segment_offset;
 390     return cues;
 391 }
 392
 393 static int mkv_add_cuepoint(mkv_cues *cues, int stream, int64_t ts, int64_t cluster_pos)
 394 {
 395     int err;
 396
 397     if (ts < 0)
 398         return 0;
 399
 400     if ((err = av_reallocp_array(&cues->entries, cues->num_entries + 1,
 401                                  sizeof(*cues->entries))) < 0) {
 402         cues->num_entries = 0;
 403         return err;
 404     }
 405
 406     cues->entries[cues->num_entries].pts           = ts;
 407     cues->entries[cues->num_entries].tracknum      = stream + 1;
 408     cues->entries[cues->num_entries++].cluster_pos = cluster_pos - cues->segment_offset;
 409
 410     return 0;
 411 }
 412
 413 static int64_t mkv_write_cues(AVIOContext *pb, mkv_cues *cues, int num_tracks)
 414 {
 415     ebml_master cues_element;
 416     int64_t currentpos;
 417     int i, j;
 418
 419     currentpos = avio_tell(pb);
 420     cues_element = start_ebml_master(pb, MATROSKA_ID_CUES, 0);
 421
 422     for (i = 0; i < cues->num_entries; i++) {
 423         ebml_master cuepoint, track_positions;
 424         mkv_cuepoint *entry = &cues->entries[i];
 425         uint64_t pts = entry->pts;
 426
 427         cuepoint = start_ebml_master(pb, MATROSKA_ID_POINTENTRY, MAX_CUEPOINT_SIZE(num_tracks));
 428         put_ebml_uint(pb, MATROSKA_ID_CUETIME, pts);
 429
 430         // put all the entries from different tracks that have the exact same
 431         // timestamp into the same CuePoint
 432         for (j = 0; j < cues->num_entries - i && entry[j].pts == pts; j++) {
 433             track_positions = start_ebml_master(pb, MATROSKA_ID_CUETRACKPOSITION, MAX_CUETRACKPOS_SIZE);
 434             put_ebml_uint(pb, MATROSKA_ID_CUETRACK          , entry[j].tracknum   );
 435             put_ebml_uint(pb, MATROSKA_ID_CUECLUSTERPOSITION, entry[j].cluster_pos);
 436             end_ebml_master(pb, track_positions);
 437         }
 438         i += j - 1;
 439         end_ebml_master(pb, cuepoint);
 440     }
 441     end_ebml_master(pb, cues_element);
 442
 443     return currentpos;
 444 }
 445
 446 static int put_xiph_codecpriv(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par)
 447 {
 448     uint8_t *header_start[3];
 449     int header_len[3];
 450     int first_header_size;
 451     int j;
 452
 453     if (par->codec_id == AV_CODEC_ID_VORBIS)
 454         first_header_size = 30;
 455     else
 456         first_header_size = 42;
 457
 458     if (avpriv_split_xiph_headers(par->extradata, par->extradata_size,
 459                               first_header_size, header_start, header_len) < 0) {
 460         av_log(s, AV_LOG_ERROR, "Extradata corrupt.\n");
 461         return -1;
 462     }
 463
 464     avio_w8(pb, 2);                    // number packets - 1
 465     for (j = 0; j < 2; j++) {
 466         put_xiph_size(pb, header_len[j]);
 467     }
 468     for (j = 0; j < 3; j++)
 469         avio_write(pb, header_start[j], header_len[j]);
 470
 471     return 0;
 472 }
 473
 474 static int put_wv_codecpriv(AVIOContext *pb, AVCodecParameters *par)
 475 {
 476     if (par->extradata && par->extradata_size == 2)
 477         avio_write(pb, par->extradata, 2);
 478     else
 479         avio_wl16(pb, 0x403); // fallback to the version mentioned in matroska specs
 480     return 0;
 481 }
 482
 483 static int put_flac_codecpriv(AVFormatContext *s,
 484                               AVIOContext *pb, AVCodecParameters *par)
 485 {
 486     int write_comment = (par->channel_layout &&
 487                          !(par->channel_layout & ~0x3ffffULL) &&
 488                          !ff_flac_is_native_layout(par->channel_layout));
 489     int ret = ff_flac_write_header(pb, par->extradata, par->extradata_size,
 490                                    !write_comment);
 491
 492     if (ret < 0)
 493         return ret;
 494
 495     if (write_comment) {
 496         const char *vendor = (s->flags & AVFMT_FLAG_BITEXACT) ?
 497                              "Libav" : LIBAVFORMAT_IDENT;
 498         AVDictionary *dict = NULL;
 499         uint8_t buf[32], *data, *p;
 500         int len;
 501
 502         snprintf(buf, sizeof(buf), "0x%"PRIx64, par->channel_layout);
 503         av_dict_set(&dict, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", buf, 0);
 504
 505         len = ff_vorbiscomment_length(dict, vendor);
 506         data = av_malloc(len + 4);
 507         if (!data) {
 508             av_dict_free(&dict);
 509             return AVERROR(ENOMEM);
 510         }
 511
 512         data[0] = 0x84;
 513         AV_WB24(data + 1, len);
 514
 515         p = data + 4;
 516         ff_vorbiscomment_write(&p, &dict, vendor);
 517
 518         avio_write(pb, data, len + 4);
 519
 520         av_freep(&data);
 521         av_dict_free(&dict);
 522     }
 523
 524     return 0;
 525 }
 526
 527 static int get_aac_sample_rates(AVFormatContext *s, uint8_t *extradata, int extradata_size,
 528                                 int *sample_rate, int *output_sample_rate)
 529 {
 530     MPEG4AudioConfig mp4ac;
 531     int ret;
 532
 533     ret = avpriv_mpeg4audio_get_config(&mp4ac, extradata,
 534                                        extradata_size * 8, 1);
 535     /* Don't abort if the failure is because of missing extradata. Assume in that
 536      * case a bitstream filter will provide the muxer with the extradata in the
 537      * first packet.
 538      * Abort however if s->pb is not seekable, as we would not be able to seek back
 539      * to write the sample rate elements once the extradata shows up, anyway. */
 540     if (ret < 0 && (extradata_size || !(s->pb->seekable & AVIO_SEEKABLE_NORMAL))) {
 541         av_log(s, AV_LOG_ERROR,
 542                "Error parsing AAC extradata, unable to determine samplerate.\n");
 543         return AVERROR(EINVAL);
 544     }
 545
 546     if (ret < 0) {
 547         /* This will only happen when this function is called while writing the
 548          * header and no extradata is available. The space for this element has
 549          * to be reserved for when this function is called again after the
 550          * extradata shows up in the first packet, as there's no way to know if
 551          * output_sample_rate will be different than sample_rate or not. */
 552         *output_sample_rate = *sample_rate;
 553     } else {
 554         *sample_rate        = mp4ac.sample_rate;
 555         *output_sample_rate = mp4ac.ext_sample_rate;
 556     }
 557     return 0;
 558 }
 559
 560 static int mkv_write_native_codecprivate(AVFormatContext *s,
 561                                          AVCodecParameters *par,
 562                                          AVIOContext *dyn_cp)
 563 {
 564     switch (par->codec_id) {
 565     case AV_CODEC_ID_VORBIS:
 566     case AV_CODEC_ID_THEORA:
 567         return put_xiph_codecpriv(s, dyn_cp, par);
 568     case AV_CODEC_ID_FLAC:
 569         return put_flac_codecpriv(s, dyn_cp, par);
 570     case AV_CODEC_ID_WAVPACK:
 571         return put_wv_codecpriv(dyn_cp, par);
 572     case AV_CODEC_ID_H264:
 573         return ff_isom_write_avcc(dyn_cp, par->extradata,
 574                                   par->extradata_size);
 575     case AV_CODEC_ID_HEVC:
 576         return ff_isom_write_hvcc(dyn_cp, par->extradata,
 577                                   par->extradata_size, 0);
 578     case AV_CODEC_ID_ALAC:
 579         if (par->extradata_size < 36) {
 580             av_log(s, AV_LOG_ERROR,
 581                    "Invalid extradata found, ALAC expects a 36-byte "
 582                    "QuickTime atom.");
 583             return AVERROR_INVALIDDATA;
 584         } else
 585             avio_write(dyn_cp, par->extradata + 12,
 586                        par->extradata_size - 12);
 587         break;
 588     default:
 589         if (par->extradata_size)
 590         avio_write(dyn_cp, par->extradata, par->extradata_size);
 591     }
 592
 593     return 0;
 594 }
 595
 596 static int mkv_write_codecprivate(AVFormatContext *s, AVIOContext *pb,
 597                                   AVCodecParameters *par,
 598                                   int native_id, int qt_id)
 599 {
 600     AVIOContext *dyn_cp;
 601     uint8_t *codecpriv;
 602     int ret, codecpriv_size;
 603
 604     ret = avio_open_dyn_buf(&dyn_cp);
 605     if (ret < 0)
 606         return ret;
 607
 608     if (native_id) {
 609         ret = mkv_write_native_codecprivate(s, par, dyn_cp);
 610     } else if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
 611         if (qt_id) {
 612             if (!par->codec_tag)
 613                 par->codec_tag = ff_codec_get_tag(ff_codec_movvideo_tags,
 614                                                   par->codec_id);
 615             if (par->extradata_size)
 616                 avio_write(dyn_cp, par->extradata, par->extradata_size);
 617         } else {
 618             if (!par->codec_tag)
 619                 par->codec_tag = ff_codec_get_tag(ff_codec_bmp_tags,
 620                                                   par->codec_id);
 621             if (!par->codec_tag) {
 622                 av_log(s, AV_LOG_ERROR, "No bmp codec ID found.\n");
 623                 ret = -1;
 624             }
 625
 626             ff_put_bmp_header(dyn_cp, par, ff_codec_bmp_tags, 0);
 627         }
 628     } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
 629         unsigned int tag;
 630         tag = ff_codec_get_tag(ff_codec_wav_tags, par->codec_id);
 631         if (!tag) {
 632             av_log(s, AV_LOG_ERROR, "No wav codec ID found.\n");
 633             ret = -1;
 634         }
 635         if (!par->codec_tag)
 636             par->codec_tag = tag;
 637
 638         ff_put_wav_header(s, dyn_cp, par);
 639     }
 640
 641     codecpriv_size = avio_close_dyn_buf(dyn_cp, &codecpriv);
 642     if (codecpriv_size)
 643         put_ebml_binary(pb, MATROSKA_ID_CODECPRIVATE, codecpriv,
 644                         codecpriv_size);
 645     av_free(codecpriv);
 646     return ret;
 647 }
 648
 649 static void mkv_write_field_order(AVIOContext *pb,
 650                                   enum AVFieldOrder field_order)
 651 {
 652     switch (field_order) {
 653     case AV_FIELD_UNKNOWN:
 654         put_ebml_uint(pb, MATROSKA_ID_VIDEOFLAGINTERLACED,
 655                       MATROSKA_VIDEO_INTERLACE_FLAG_UNDETERMINED);
 656         break;
 657     case AV_FIELD_PROGRESSIVE:
 658         put_ebml_uint(pb, MATROSKA_ID_VIDEOFLAGINTERLACED,
 659                       MATROSKA_VIDEO_INTERLACE_FLAG_PROGRESSIVE);
 660         break;
 661     case AV_FIELD_TT:
 662     case AV_FIELD_BB:
 663     case AV_FIELD_TB:
 664     case AV_FIELD_BT:
 665         put_ebml_uint(pb, MATROSKA_ID_VIDEOFLAGINTERLACED,
 666                       MATROSKA_VIDEO_INTERLACE_FLAG_INTERLACED);
 667         switch (field_order) {
 668         case AV_FIELD_TT:
 669             put_ebml_uint(pb, MATROSKA_ID_VIDEOFIELDORDER,
 670                           MATROSKA_VIDEO_FIELDORDER_TT);
 671             break;
 672         case AV_FIELD_BB:
 673              put_ebml_uint(pb, MATROSKA_ID_VIDEOFIELDORDER,
 674                           MATROSKA_VIDEO_FIELDORDER_BB);
 675             break;
 676         case AV_FIELD_TB:
 677             put_ebml_uint(pb, MATROSKA_ID_VIDEOFIELDORDER,
 678                           MATROSKA_VIDEO_FIELDORDER_TB);
 679             break;
 680         case AV_FIELD_BT:
 681             put_ebml_uint(pb, MATROSKA_ID_VIDEOFIELDORDER,
 682                           MATROSKA_VIDEO_FIELDORDER_BT);
 683             break;
 684         }
 685     }
 686 }
 687
 688 static int mkv_write_stereo_mode(AVFormatContext *s, AVIOContext *pb,
 689                                  AVStream *st, int mode)
 690 {
 691     int i;
 692     int display_width, display_height;
 693     int h_width = 1, h_height = 1;
 694     AVCodecParameters *par = st->codecpar;
 695     AVDictionaryEntry *tag;
 696     MatroskaVideoStereoModeType format = MATROSKA_VIDEO_STEREOMODE_TYPE_NB;
 697
 698     // convert metadata into proper side data and add it to the stream
 699     if ((tag = av_dict_get(s->metadata, "stereo_mode", NULL, 0))) {
 700         int stereo_mode = atoi(tag->value);
 701         if (stereo_mode < MATROSKA_VIDEO_STEREOMODE_TYPE_NB &&
 702             stereo_mode != 10 && stereo_mode != 12) {
 703             int ret = ff_mkv_stereo3d_conv(st, stereo_mode);
 704             if (ret < 0)
 705                 return ret;
 706         }
 707     }
 708
 709     // iterate to find the stereo3d side data
 710     for (i = 0; i < st->nb_side_data; i++) {
 711         AVPacketSideData sd = st->side_data[i];
 712         if (sd.type == AV_PKT_DATA_STEREO3D) {
 713             AVStereo3D *stereo = (AVStereo3D *)sd.data;
 714
 715             switch (stereo->type) {
 716             case AV_STEREO3D_2D:
 717                 format = MATROSKA_VIDEO_STEREOMODE_TYPE_MONO;
 718                 break;
 719             case AV_STEREO3D_SIDEBYSIDE:
 720                 format = (stereo->flags & AV_STEREO3D_FLAG_INVERT)
 721                     ? MATROSKA_VIDEO_STEREOMODE_TYPE_RIGHT_LEFT
 722                     : MATROSKA_VIDEO_STEREOMODE_TYPE_LEFT_RIGHT;
 723                 h_width = 2;
 724                 break;
 725             case AV_STEREO3D_TOPBOTTOM:
 726                 format = MATROSKA_VIDEO_STEREOMODE_TYPE_TOP_BOTTOM;
 727                 if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
 728                     format--;
 729                 h_height = 2;
 730                 break;
 731             case AV_STEREO3D_CHECKERBOARD:
 732                 format = MATROSKA_VIDEO_STEREOMODE_TYPE_CHECKERBOARD_LR;
 733                 if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
 734                     format--;
 735                 break;
 736             case AV_STEREO3D_LINES:
 737                 format = MATROSKA_VIDEO_STEREOMODE_TYPE_ROW_INTERLEAVED_LR;
 738                 if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
 739                     format--;
 740                 h_height = 2;
 741                 break;
 742             case AV_STEREO3D_COLUMNS:
 743                 format = MATROSKA_VIDEO_STEREOMODE_TYPE_COL_INTERLEAVED_LR;
 744                 if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
 745                     format--;
 746                 h_width = 2;
 747                 break;
 748             case AV_STEREO3D_FRAMESEQUENCE:
 749                 format = MATROSKA_VIDEO_STEREOMODE_TYPE_BOTH_EYES_BLOCK_LR;
 750                 if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
 751                     format++;
 752                 break;
 753             }
 754
 755             break;
 756         }
 757     }
 758
 759     // if webm, do not write unsupported modes
 760     if (mode == MODE_WEBM &&
 761         (format > MATROSKA_VIDEO_STEREOMODE_TYPE_TOP_BOTTOM &&
 762          format != MATROSKA_VIDEO_STEREOMODE_TYPE_RIGHT_LEFT))
 763         format = MATROSKA_VIDEO_STEREOMODE_TYPE_NB;
 764
 765     // write StereoMode if format is valid
 766     if (format < MATROSKA_VIDEO_STEREOMODE_TYPE_NB)
 767         put_ebml_uint(pb, MATROSKA_ID_VIDEOSTEREOMODE, format);
 768
 769     // write DisplayWidth and DisplayHeight, they contain the size of
 770     // a single source view and/or the display aspect ratio
 771     display_width  = par->width  / h_width;
 772     display_height = par->height / h_height;
 773     if (st->sample_aspect_ratio.num) {
 774         display_width *= av_q2d(st->sample_aspect_ratio);
 775         put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYUNIT, 3); // DAR
 776     }
 777     if (st->sample_aspect_ratio.num ||
 778         format < MATROSKA_VIDEO_STEREOMODE_TYPE_NB) {
 779         put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH,  display_width);
 780         put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, display_height);
 781     }
 782
 783     return 0;
 784 }
 785
 786 static int mkv_write_track(AVFormatContext *s, MatroskaMuxContext *mkv,
 787                            int i, AVIOContext *pb)
 788 {
 789     AVStream *st = s->streams[i];
 790     AVCodecParameters *par = st->codecpar;
 791     ebml_master subinfo, track;
 792     int native_id = 0;
 793     int qt_id = 0;
 794     int bit_depth = av_get_bits_per_sample(par->codec_id);
 795     int sample_rate = par->sample_rate;
 796     int output_sample_rate = 0;
 797     int j, ret;
 798     AVDictionaryEntry *tag;
 799
 800     // ms precision is the de-facto standard timescale for mkv files
 801     avpriv_set_pts_info(st, 64, 1, 1000);
 802
 803     if (par->codec_type == AVMEDIA_TYPE_ATTACHMENT) {
 804         mkv->have_attachments = 1;
 805         return 0;
 806     }
 807
 808     if (!bit_depth)
 809         bit_depth = av_get_bytes_per_sample(par->format) << 3;
 810
 811     if (par->codec_id == AV_CODEC_ID_AAC) {
 812         ret = get_aac_sample_rates(s, par->extradata, par->extradata_size, &sample_rate,
 813                                    &output_sample_rate);
 814         if (ret < 0)
 815             return ret;
 816     }
 817
 818     track = start_ebml_master(pb, MATROSKA_ID_TRACKENTRY, 0);
 819     put_ebml_uint (pb, MATROSKA_ID_TRACKNUMBER     , i + 1);
 820     put_ebml_uint (pb, MATROSKA_ID_TRACKUID        , i + 1);
 821     put_ebml_uint (pb, MATROSKA_ID_TRACKFLAGLACING , 0);    // no lacing (yet)
 822
 823     if ((tag = av_dict_get(st->metadata, "title", NULL, 0)))
 824         put_ebml_string(pb, MATROSKA_ID_TRACKNAME, tag->value);
 825     tag = av_dict_get(st->metadata, "language", NULL, 0);
 826     put_ebml_string(pb, MATROSKA_ID_TRACKLANGUAGE, tag ? tag->value:"und");
 827
 828     // The default value for TRACKFLAGDEFAULT is 1, so add element
 829     // if we need to clear it.
 830     if (!(st->disposition & AV_DISPOSITION_DEFAULT))
 831         put_ebml_uint(pb, MATROSKA_ID_TRACKFLAGDEFAULT, !!(st->disposition & AV_DISPOSITION_DEFAULT));
 832     if (st->disposition & AV_DISPOSITION_FORCED)
 833         put_ebml_uint(pb, MATROSKA_ID_TRACKFLAGFORCED, !!(st->disposition & AV_DISPOSITION_FORCED));
 834
 835     if (par->codec_type == AVMEDIA_TYPE_AUDIO && par->initial_padding) {
 836         mkv->tracks[i].ts_offset = av_rescale_q(par->initial_padding,
 837                                                 (AVRational){ 1, par->sample_rate },
 838                                                 st->time_base);
 839
 840         put_ebml_uint(pb, MATROSKA_ID_CODECDELAY,
 841                       av_rescale_q(par->initial_padding,
 842                                    (AVRational){ 1, par->sample_rate },
 843                                    (AVRational){ 1, 1000000000 }));
 844     }
 845
 846     // look for a codec ID string specific to mkv to use,
 847     // if none are found, use AVI codes
 848     for (j = 0; ff_mkv_codec_tags[j].id != AV_CODEC_ID_NONE; j++) {
 849         if (ff_mkv_codec_tags[j].id == par->codec_id) {
 850             put_ebml_string(pb, MATROSKA_ID_CODECID, ff_mkv_codec_tags[j].str);
 851             native_id = 1;
 852             break;
 853         }
 854     }
 855
 856     if (mkv->mode == MODE_WEBM && !(par->codec_id == AV_CODEC_ID_VP8 ||
 857                                     par->codec_id == AV_CODEC_ID_VP9 ||
 858                                     par->codec_id == AV_CODEC_ID_OPUS ||
 859                                     par->codec_id == AV_CODEC_ID_VORBIS)) {
 860         av_log(s, AV_LOG_ERROR,
 861                "Only VP8 or VP9 video and Vorbis or Opus audio are supported for WebM.\n");
 862         return AVERROR(EINVAL);
 863     }
 864
 865     switch (par->codec_type) {
 866     case AVMEDIA_TYPE_VIDEO:
 867         mkv->have_video = 1;
 868         put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_VIDEO);
 869         if (st->avg_frame_rate.num > 0 && st->avg_frame_rate.den > 0)
 870             put_ebml_uint(pb, MATROSKA_ID_TRACKDEFAULTDURATION, 1E9 / av_q2d(st->avg_frame_rate));
 871
 872         if (!native_id &&
 873             ff_codec_get_tag(ff_codec_movvideo_tags, par->codec_id) &&
 874             (!ff_codec_get_tag(ff_codec_bmp_tags,    par->codec_id) ||
 875              par->codec_id == AV_CODEC_ID_SVQ1 ||
 876              par->codec_id == AV_CODEC_ID_SVQ3 ||
 877              par->codec_id == AV_CODEC_ID_CINEPAK))
 878             qt_id = 1;
 879
 880         if (qt_id)
 881             put_ebml_string(pb, MATROSKA_ID_CODECID, "V_QUICKTIME");
 882         else if (!native_id) {
 883             // if there is no mkv-specific codec ID, use VFW mode
 884             put_ebml_string(pb, MATROSKA_ID_CODECID, "V_MS/VFW/FOURCC");
 885             mkv->tracks[i].write_dts = 1;
 886         }
 887
 888         subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKVIDEO, 0);
 889
 890         put_ebml_uint (pb, MATROSKA_ID_VIDEOPIXELWIDTH , par->width);
 891         put_ebml_uint (pb, MATROSKA_ID_VIDEOPIXELHEIGHT, par->height);
 892
 893         mkv_write_field_order(pb, par->field_order);
 894
 895         // check both side data and metadata for stereo information,
 896         // write the result to the bitstream if any is found
 897         ret = mkv_write_stereo_mode(s, pb, st, mkv->mode);
 898         if (ret < 0)
 899             return ret;
 900
 901         end_ebml_master(pb, subinfo);
 902         break;
 903
 904     case AVMEDIA_TYPE_AUDIO:
 905         put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_AUDIO);
 906
 907         if (!native_id)
 908             // no mkv-specific ID, use ACM mode
 909             put_ebml_string(pb, MATROSKA_ID_CODECID, "A_MS/ACM");
 910
 911         subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKAUDIO, 0);
 912         put_ebml_uint  (pb, MATROSKA_ID_AUDIOCHANNELS    , par->channels);
 913
 914         mkv->tracks[i].sample_rate_offset = avio_tell(pb);
 915         put_ebml_float (pb, MATROSKA_ID_AUDIOSAMPLINGFREQ, sample_rate);
 916         if (output_sample_rate)
 917             put_ebml_float(pb, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate);
 918         if (bit_depth)
 919             put_ebml_uint(pb, MATROSKA_ID_AUDIOBITDEPTH, bit_depth);
 920         end_ebml_master(pb, subinfo);
 921         break;
 922
 923     case AVMEDIA_TYPE_SUBTITLE:
 924         put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_SUBTITLE);
 925         if (!native_id) {
 926             av_log(s, AV_LOG_ERROR, "Subtitle codec %d is not supported.\n", par->codec_id);
 927             return AVERROR(ENOSYS);
 928         }
 929         break;
 930     default:
 931         av_log(s, AV_LOG_ERROR, "Only audio, video, and subtitles are supported for Matroska.\n");
 932         break;
 933     }
 934
 935     mkv->tracks[i].codecpriv_offset = avio_tell(pb);
 936     ret = mkv_write_codecprivate(s, pb, par, native_id, qt_id);
 937     if (ret < 0)
 938         return ret;
 939
 940     end_ebml_master(pb, track);
 941
 942     return 0;
 943 }
 944
 945 static int mkv_write_tracks(AVFormatContext *s)
 946 {
 947     MatroskaMuxContext *mkv = s->priv_data;
 948     AVIOContext *pb = s->pb;
 949     ebml_master tracks;
 950     int i, ret;
 951
 952     ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_TRACKS, avio_tell(pb));
 953     if (ret < 0)
 954         return ret;
 955
 956     tracks = start_ebml_master(pb, MATROSKA_ID_TRACKS, 0);
 957     for (i = 0; i < s->nb_streams; i++) {
 958         ret = mkv_write_track(s, mkv, i, pb);
 959         if (ret < 0)
 960             return ret;
 961     }
 962     end_ebml_master(pb, tracks);
 963     return 0;
 964 }
 965
 966 static int mkv_write_chapters(AVFormatContext *s)
 967 {
 968     MatroskaMuxContext *mkv = s->priv_data;
 969     AVIOContext *pb = s->pb;
 970     ebml_master chapters, editionentry;
 971     AVRational scale = {1, 1E9};
 972     int i, ret;
 973
 974     if (!s->nb_chapters || mkv->wrote_chapters)
 975         return 0;
 976
 977     ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_CHAPTERS, avio_tell(pb));
 978     if (ret < 0) return ret;
 979
 980     chapters     = start_ebml_master(pb, MATROSKA_ID_CHAPTERS    , 0);
 981     editionentry = start_ebml_master(pb, MATROSKA_ID_EDITIONENTRY, 0);
 982     put_ebml_uint(pb, MATROSKA_ID_EDITIONFLAGDEFAULT, 1);
 983     put_ebml_uint(pb, MATROSKA_ID_EDITIONFLAGHIDDEN , 0);
 984     for (i = 0; i < s->nb_chapters; i++) {
 985         ebml_master chapteratom, chapterdisplay;
 986         AVChapter *c     = s->chapters[i];
 987         int64_t chapterstart = av_rescale_q(c->start, c->time_base, scale);
 988         int64_t chapterend   = av_rescale_q(c->end,   c->time_base, scale);
 989         AVDictionaryEntry *t = NULL;
 990         if (chapterstart < 0 || chapterstart > chapterend || chapterend < 0) {
 991             av_log(s, AV_LOG_ERROR,
 992                    "Invalid chapter start (%"PRId64") or end (%"PRId64").\n",
 993                    chapterstart, chapterend);
 994             return AVERROR_INVALIDDATA;
 995         }
 996
 997         chapteratom = start_ebml_master(pb, MATROSKA_ID_CHAPTERATOM, 0);
 998         put_ebml_uint(pb, MATROSKA_ID_CHAPTERUID, c->id);
 999         put_ebml_uint(pb, MATROSKA_ID_CHAPTERTIMESTART, chapterstart);
1000         put_ebml_uint(pb, MATROSKA_ID_CHAPTERTIMEEND, chapterend);
1001         put_ebml_uint(pb, MATROSKA_ID_CHAPTERFLAGHIDDEN , 0);
1002         put_ebml_uint(pb, MATROSKA_ID_CHAPTERFLAGENABLED, 1);
1003         if ((t = av_dict_get(c->metadata, "title", NULL, 0))) {
1004             chapterdisplay = start_ebml_master(pb, MATROSKA_ID_CHAPTERDISPLAY, 0);
1005             put_ebml_string(pb, MATROSKA_ID_CHAPSTRING, t->value);
1006             put_ebml_string(pb, MATROSKA_ID_CHAPLANG  , "und");
1007             end_ebml_master(pb, chapterdisplay);
1008         }
1009         end_ebml_master(pb, chapteratom);
1010     }
1011     end_ebml_master(pb, editionentry);
1012     end_ebml_master(pb, chapters);
1013
1014     mkv->wrote_chapters = 1;
1015     return 0;
1016 }
1017
1018 static int mkv_write_simpletag(AVIOContext *pb, AVDictionaryEntry *t)
1019 {
1020     uint8_t *key = av_strdup(t->key);
1021     uint8_t *p   = key;
1022     const uint8_t *lang = NULL;
1023     ebml_master tag;
1024
1025     if (!key)
1026         return AVERROR(ENOMEM);
1027
1028     if ((p = strrchr(p, '-')) &&
1029         (lang = av_convert_lang_to(p + 1, AV_LANG_ISO639_2_BIBL)))
1030         *p = 0;
1031
1032     p = key;
1033     while (*p) {
1034         if (*p == ' ')
1035             *p = '_';
1036         else if (*p >= 'a' && *p <= 'z')
1037             *p -= 'a' - 'A';
1038         p++;
1039     }
1040
1041     tag = start_ebml_master(pb, MATROSKA_ID_SIMPLETAG, 0);
1042     put_ebml_string(pb, MATROSKA_ID_TAGNAME, key);
1043     if (lang)
1044         put_ebml_string(pb, MATROSKA_ID_TAGLANG, lang);
1045     put_ebml_string(pb, MATROSKA_ID_TAGSTRING, t->value);
1046     end_ebml_master(pb, tag);
1047
1048     av_freep(&key);
1049     return 0;
1050 }
1051
1052 static int mkv_write_tag(AVFormatContext *s, AVDictionary *m, unsigned int elementid,
1053                          unsigned int uid, ebml_master *tags)
1054 {
1055     MatroskaMuxContext *mkv = s->priv_data;
1056     ebml_master tag, targets;
1057     AVDictionaryEntry *t = NULL;
1058     int ret;
1059
1060     if (!tags->pos) {
1061         ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_TAGS, avio_tell(s->pb));
1062         if (ret < 0) return ret;
1063
1064         *tags = start_ebml_master(s->pb, MATROSKA_ID_TAGS, 0);
1065     }
1066
1067     tag     = start_ebml_master(s->pb, MATROSKA_ID_TAG,        0);
1068     targets = start_ebml_master(s->pb, MATROSKA_ID_TAGTARGETS, 0);
1069     if (elementid)
1070         put_ebml_uint(s->pb, elementid, uid);
1071     end_ebml_master(s->pb, targets);
1072
1073     while ((t = av_dict_get(m, "", t, AV_DICT_IGNORE_SUFFIX))) {
1074         if (av_strcasecmp(t->key, "title") &&
1075             av_strcasecmp(t->key, "encoding_tool") &&
1076             (elementid != MATROSKA_ID_TAGTARGETS_TRACKUID ||
1077              av_strcasecmp(t->key, "language"))) {
1078             ret = mkv_write_simpletag(s->pb, t);
1079             if (ret < 0)
1080                 return ret;
1081         }
1082     }
1083
1084     end_ebml_master(s->pb, tag);
1085     return 0;
1086 }
1087
1088 static int mkv_write_tags(AVFormatContext *s)
1089 {
1090     ebml_master tags = {0};
1091     int i, ret;
1092
1093     ff_metadata_conv_ctx(s, ff_mkv_metadata_conv, NULL);
1094
1095     if (av_dict_get(s->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX)) {
1096         ret = mkv_write_tag(s, s->metadata, 0, 0, &tags);
1097         if (ret < 0) return ret;
1098     }
1099
1100     for (i = 0; i < s->nb_streams; i++) {
1101         AVStream *st = s->streams[i];
1102
1103         if (!av_dict_get(st->metadata, "", 0, AV_DICT_IGNORE_SUFFIX))
1104             continue;
1105
1106         ret = mkv_write_tag(s, st->metadata, MATROSKA_ID_TAGTARGETS_TRACKUID, i + 1, &tags);
1107         if (ret < 0) return ret;
1108     }
1109
1110     for (i = 0; i < s->nb_chapters; i++) {
1111         AVChapter *ch = s->chapters[i];
1112
1113         if (!av_dict_get(ch->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX))
1114             continue;
1115
1116         ret = mkv_write_tag(s, ch->metadata, MATROSKA_ID_TAGTARGETS_CHAPTERUID, ch->id, &tags);
1117         if (ret < 0) return ret;
1118     }
1119
1120     if (tags.pos)
1121         end_ebml_master(s->pb, tags);
1122     return 0;
1123 }
1124
1125 static int mkv_write_attachments(AVFormatContext *s)
1126 {
1127     MatroskaMuxContext *mkv = s->priv_data;
1128     AVIOContext *pb = s->pb;
1129     ebml_master attachments;
1130     AVLFG c;
1131     int i, ret;
1132
1133     if (!mkv->have_attachments)
1134         return 0;
1135
1136     av_lfg_init(&c, av_get_random_seed());
1137
1138     ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_ATTACHMENTS, avio_tell(pb));
1139     if (ret < 0) return ret;
1140
1141     attachments = start_ebml_master(pb, MATROSKA_ID_ATTACHMENTS, 0);
1142
1143     for (i = 0; i < s->nb_streams; i++) {
1144         AVStream *st = s->streams[i];
1145         ebml_master attached_file;
1146         AVDictionaryEntry *t;
1147         const char *mimetype = NULL;
1148
1149         if (st->codecpar->codec_type != AVMEDIA_TYPE_ATTACHMENT)
1150             continue;
1151
1152         attached_file = start_ebml_master(pb, MATROSKA_ID_ATTACHEDFILE, 0);
1153
1154         if (t = av_dict_get(st->metadata, "title", NULL, 0))
1155             put_ebml_string(pb, MATROSKA_ID_FILEDESC, t->value);
1156         if (!(t = av_dict_get(st->metadata, "filename", NULL, 0))) {
1157             av_log(s, AV_LOG_ERROR, "Attachment stream %d has no filename tag.\n", i);
1158             return AVERROR(EINVAL);
1159         }
1160         put_ebml_string(pb, MATROSKA_ID_FILENAME, t->value);
1161         if (t = av_dict_get(st->metadata, "mimetype", NULL, 0))
1162             mimetype = t->value;
1163         else if (st->codecpar->codec_id != AV_CODEC_ID_NONE ) {
1164             int i;
1165             for (i = 0; ff_mkv_mime_tags[i].id != AV_CODEC_ID_NONE; i++)
1166                 if (ff_mkv_mime_tags[i].id == st->codecpar->codec_id) {
1167                     mimetype = ff_mkv_mime_tags[i].str;
1168                     break;
1169                 }
1170             for (i = 0; ff_mkv_image_mime_tags[i].id != AV_CODEC_ID_NONE; i++)
1171                 if (ff_mkv_image_mime_tags[i].id == st->codecpar->codec_id) {
1172                     mimetype = ff_mkv_image_mime_tags[i].str;
1173                     break;
1174                 }
1175         }
1176         if (!mimetype) {
1177             av_log(s, AV_LOG_ERROR, "Attachment stream %d has no mimetype tag and "
1178                                     "it cannot be deduced from the codec id.\n", i);
1179             return AVERROR(EINVAL);
1180         }
1181
1182         put_ebml_string(pb, MATROSKA_ID_FILEMIMETYPE, mimetype);
1183         put_ebml_binary(pb, MATROSKA_ID_FILEDATA, st->codecpar->extradata, st->codecpar->extradata_size);
1184         put_ebml_uint(pb, MATROSKA_ID_FILEUID, av_lfg_get(&c));
1185         end_ebml_master(pb, attached_file);
1186     }
1187     end_ebml_master(pb, attachments);
1188
1189     return 0;
1190 }
1191
1192 static int mkv_write_header(AVFormatContext *s)
1193 {
1194     MatroskaMuxContext *mkv = s->priv_data;
1195     AVIOContext *pb = s->pb;
1196     ebml_master ebml_header, segment_info;
1197     AVDictionaryEntry *tag;
1198     int ret, i;
1199
1200     if (!strcmp(s->oformat->name, "webm"))
1201         mkv->mode = MODE_WEBM;
1202     else
1203         mkv->mode = MODE_MATROSKAv2;
1204
1205     mkv->tracks = av_mallocz(s->nb_streams * sizeof(*mkv->tracks));
1206     if (!mkv->tracks)
1207         return AVERROR(ENOMEM);
1208
1209     ebml_header = start_ebml_master(pb, EBML_ID_HEADER, 0);
1210     put_ebml_uint   (pb, EBML_ID_EBMLVERSION        ,           1);
1211     put_ebml_uint   (pb, EBML_ID_EBMLREADVERSION    ,           1);
1212     put_ebml_uint   (pb, EBML_ID_EBMLMAXIDLENGTH    ,           4);
1213     put_ebml_uint   (pb, EBML_ID_EBMLMAXSIZELENGTH  ,           8);
1214     put_ebml_string (pb, EBML_ID_DOCTYPE            , s->oformat->name);
1215     put_ebml_uint   (pb, EBML_ID_DOCTYPEVERSION     ,           4);
1216     put_ebml_uint   (pb, EBML_ID_DOCTYPEREADVERSION ,           2);
1217     end_ebml_master(pb, ebml_header);
1218
1219     mkv->segment = start_ebml_master(pb, MATROSKA_ID_SEGMENT, 0);
1220     mkv->segment_offset = avio_tell(pb);
1221
1222     // we write 2 seek heads - one at the end of the file to point to each
1223     // cluster, and one at the beginning to point to all other level one
1224     // elements (including the seek head at the end of the file), which
1225     // isn't more than 10 elements if we only write one of each other
1226     // currently defined level 1 element
1227     mkv->main_seekhead    = mkv_start_seekhead(pb, mkv->segment_offset, 10);
1228     if (!mkv->main_seekhead)
1229         return AVERROR(ENOMEM);
1230
1231     ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_INFO, avio_tell(pb));
1232     if (ret < 0) return ret;
1233
1234     segment_info = start_ebml_master(pb, MATROSKA_ID_INFO, 0);
1235     put_ebml_uint(pb, MATROSKA_ID_TIMECODESCALE, 1000000);
1236     if ((tag = av_dict_get(s->metadata, "title", NULL, 0)))
1237         put_ebml_string(pb, MATROSKA_ID_TITLE, tag->value);
1238     if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
1239         uint32_t segment_uid[4];
1240         AVLFG lfg;
1241
1242         av_lfg_init(&lfg, av_get_random_seed());
1243
1244         for (i = 0; i < 4; i++)
1245             segment_uid[i] = av_lfg_get(&lfg);
1246
1247         put_ebml_string(pb, MATROSKA_ID_MUXINGAPP, LIBAVFORMAT_IDENT);
1248         if ((tag = av_dict_get(s->metadata, "encoding_tool", NULL, 0)))
1249             put_ebml_string(pb, MATROSKA_ID_WRITINGAPP, tag->value);
1250         else
1251             put_ebml_string(pb, MATROSKA_ID_WRITINGAPP, LIBAVFORMAT_IDENT);
1252         put_ebml_binary(pb, MATROSKA_ID_SEGMENTUID, segment_uid, 16);
1253     }
1254
1255     // reserve space for the duration
1256     mkv->duration = 0;
1257     mkv->duration_offset = avio_tell(pb);
1258     put_ebml_void(pb, 11);                  // assumes double-precision float to be written
1259     end_ebml_master(pb, segment_info);
1260
1261     ret = mkv_write_tracks(s);
1262     if (ret < 0)
1263         return ret;
1264
1265     if (mkv->mode != MODE_WEBM) {
1266         ret = mkv_write_chapters(s);
1267         if (ret < 0)
1268             return ret;
1269
1270         ret = mkv_write_tags(s);
1271         if (ret < 0)
1272             return ret;
1273
1274         ret = mkv_write_attachments(s);
1275         if (ret < 0)
1276             return ret;
1277     }
1278
1279     if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
1280         mkv_write_seekhead(pb, mkv->main_seekhead);
1281
1282     mkv->cues = mkv_start_cues(mkv->segment_offset);
1283     if (!mkv->cues)
1284         return AVERROR(ENOMEM);
1285
1286     if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && mkv->reserve_cues_space) {
1287         mkv->cues_pos = avio_tell(pb);
1288         put_ebml_void(pb, mkv->reserve_cues_space);
1289     }
1290
1291     av_init_packet(&mkv->cur_audio_pkt);
1292     mkv->cur_audio_pkt.size = 0;
1293
1294     avio_flush(pb);
1295
1296     // start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or
1297     // after 4k and on a keyframe
1298     if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
1299         if (mkv->cluster_time_limit < 0)
1300             mkv->cluster_time_limit = 5000;
1301         if (mkv->cluster_size_limit < 0)
1302             mkv->cluster_size_limit = 5 * 1024 * 1024;
1303     } else {
1304         if (mkv->cluster_time_limit < 0)
1305             mkv->cluster_time_limit = 1000;
1306         if (mkv->cluster_size_limit < 0)
1307             mkv->cluster_size_limit = 32 * 1024;
1308     }
1309
1310     return 0;
1311 }
1312
1313 static int mkv_blockgroup_size(int pkt_size)
1314 {
1315     int size = pkt_size + 4;
1316     size += ebml_num_size(size);
1317     size += 2;              // EBML ID for block and block duration
1318     size += 8;              // max size of block duration
1319     size += ebml_num_size(size);
1320     size += 1;              // blockgroup EBML ID
1321     return size;
1322 }
1323
1324 static int ass_get_duration(AVFormatContext *s, const uint8_t *p)
1325 {
1326     int sh, sm, ss, sc, eh, em, es, ec;
1327     uint64_t start, end;
1328
1329     if (sscanf(p, "%*[^,],%d:%d:%d%*c%d,%d:%d:%d%*c%d",
1330                &sh, &sm, &ss, &sc, &eh, &em, &es, &ec) != 8)
1331         return 0;
1332
1333     if (sh > 9 || sm > 59 || ss > 59 || sc > 99 ||
1334         eh > 9 || em > 59 || es > 59 || ec > 99) {
1335         av_log(s, AV_LOG_WARNING,
1336                "Non-standard time reference %d:%d:%d.%d,%d:%d:%d.%d\n",
1337                sh, sm, ss, sc, eh, em, es, ec);
1338         return 0;
1339     }
1340
1341     start = 3600000 * sh + 60000 * sm + 1000 * ss + 10 * sc;
1342     end   = 3600000 * eh + 60000 * em + 1000 * es + 10 * ec;
1343
1344     if (start > end) {
1345         av_log(s, AV_LOG_WARNING,
1346                "Unexpected time reference %d:%d:%d.%d,%d:%d:%d.%d\n",
1347                sh, sm, ss, sc, eh, em, es, ec);
1348         return 0;
1349     }
1350
1351     return end - start;
1352 }
1353
1354 static int mkv_write_ass_blocks(AVFormatContext *s, AVIOContext *pb,
1355                                 AVPacket *pkt)
1356 {
1357     MatroskaMuxContext *mkv = s->priv_data;
1358     int i, layer = 0, max_duration = 0, size, line_size, data_size = pkt->size;
1359     uint8_t *start, *end, *data = pkt->data;
1360     ebml_master blockgroup;
1361     char buffer[2048];
1362
1363     while (data_size) {
1364         int duration = ass_get_duration(s, data);
1365         max_duration = FFMAX(duration, max_duration);
1366         end          = memchr(data, '\n', data_size);
1367         size         = line_size = end ? end - data + 1 : data_size;
1368         size        -= end ? (end[-1] == '\r') + 1 : 0;
1369         start        = data;
1370         for (i = 0; i < 3; i++, start++)
1371             if (!(start = memchr(start, ',', size - (start - data))))
1372                 return max_duration;
1373         size -= start - data;
1374         sscanf(data, "Dialogue: %d,", &layer);
1375         i = snprintf(buffer, sizeof(buffer), "%" PRId64 ",%d,",
1376                      s->streams[pkt->stream_index]->nb_frames, layer);
1377         size = FFMIN(i + size, sizeof(buffer));
1378         memcpy(buffer + i, start, size - i);
1379
1380         av_log(s, AV_LOG_DEBUG,
1381                "Writing block at offset %" PRIu64 ", size %d, "
1382                "pts %" PRId64 ", duration %d\n",
1383                avio_tell(pb), size, pkt->pts, duration);
1384         blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP,
1385                                        mkv_blockgroup_size(size));
1386         put_ebml_id(pb, MATROSKA_ID_BLOCK);
1387         put_ebml_num(pb, size + 4, 0);
1388         // this assumes stream_index is less than 126
1389         avio_w8(pb, 0x80 | (pkt->stream_index + 1));
1390         avio_wb16(pb, pkt->pts - mkv->cluster_pts);
1391         avio_w8(pb, 0);
1392         avio_write(pb, buffer, size);
1393         put_ebml_uint(pb, MATROSKA_ID_BLOCKDURATION, duration);
1394         end_ebml_master(pb, blockgroup);
1395
1396         data      += line_size;
1397         data_size -= line_size;
1398     }
1399
1400     return max_duration;
1401 }
1402
1403 static int mkv_strip_wavpack(const uint8_t *src, uint8_t **pdst, int *size)
1404 {
1405     uint8_t *dst;
1406     int srclen = *size;
1407     int offset = 0;
1408     int ret;
1409
1410     dst = av_malloc(srclen);
1411     if (!dst)
1412         return AVERROR(ENOMEM);
1413
1414     while (srclen >= WV_HEADER_SIZE) {
1415         WvHeader header;
1416
1417         ret = ff_wv_parse_header(&header, src);
1418         if (ret < 0)
1419             goto fail;
1420         src    += WV_HEADER_SIZE;
1421         srclen -= WV_HEADER_SIZE;
1422
1423         if (srclen < header.blocksize) {
1424             ret = AVERROR_INVALIDDATA;
1425             goto fail;
1426         }
1427
1428         if (header.initial) {
1429             AV_WL32(dst + offset, header.samples);
1430             offset += 4;
1431         }
1432         AV_WL32(dst + offset,     header.flags);
1433         AV_WL32(dst + offset + 4, header.crc);
1434         offset += 8;
1435
1436         if (!(header.initial && header.final)) {
1437             AV_WL32(dst + offset, header.blocksize);
1438             offset += 4;
1439         }
1440
1441         memcpy(dst + offset, src, header.blocksize);
1442         src    += header.blocksize;
1443         srclen -= header.blocksize;
1444         offset += header.blocksize;
1445     }
1446
1447     *pdst = dst;
1448     *size = offset;
1449
1450     return 0;
1451 fail:
1452     av_freep(&dst);
1453     return ret;
1454 }
1455
1456 static void mkv_write_block(AVFormatContext *s, AVIOContext *pb,
1457                             unsigned int blockid, AVPacket *pkt, int flags)
1458 {
1459     MatroskaMuxContext *mkv = s->priv_data;
1460     AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
1461     uint8_t *data = NULL;
1462     int offset = 0, size = pkt->size;
1463     int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts;
1464
1465     av_log(s, AV_LOG_DEBUG, "Writing block at offset %" PRIu64 ", size %d, "
1466            "pts %" PRId64 ", dts %" PRId64 ", duration %" PRId64 ", flags %d\n",
1467            avio_tell(pb), pkt->size, pkt->pts, pkt->dts, pkt->duration, flags);
1468     if (par->codec_id == AV_CODEC_ID_H264 && par->extradata_size > 0 &&
1469         (AV_RB24(par->extradata) == 1 || AV_RB32(par->extradata) == 1))
1470         ff_avc_parse_nal_units_buf(pkt->data, &data, &size);
1471     else if (par->codec_id == AV_CODEC_ID_HEVC && par->extradata_size > 6 &&
1472              (AV_RB24(par->extradata) == 1 || AV_RB32(par->extradata) == 1))
1473         /* extradata is Annex B, assume the bitstream is too and convert it */
1474         ff_hevc_annexb2mp4_buf(pkt->data, &data, &size, 0, NULL);
1475     else if (par->codec_id == AV_CODEC_ID_WAVPACK) {
1476         int ret = mkv_strip_wavpack(pkt->data, &data, &size);
1477         if (ret < 0) {
1478             av_log(s, AV_LOG_ERROR, "Error stripping a WavPack packet.\n");
1479             return;
1480         }
1481     } else
1482         data = pkt->data;
1483
1484     if (par->codec_id == AV_CODEC_ID_PRORES) {
1485         /* Matroska specification requires to remove the first QuickTime atom
1486          */
1487         size  -= 8;
1488         offset = 8;
1489     }
1490
1491     put_ebml_id(pb, blockid);
1492     put_ebml_num(pb, size + 4, 0);
1493     // this assumes stream_index is less than 126
1494     avio_w8(pb, 0x80 | (pkt->stream_index + 1));
1495     avio_wb16(pb, ts - mkv->cluster_pts);
1496     avio_w8(pb, flags);
1497     avio_write(pb, data + offset, size);
1498     if (data != pkt->data)
1499         av_free(data);
1500 }
1501
1502 static int srt_get_duration(uint8_t **buf)
1503 {
1504     int i, duration = 0;
1505
1506     for (i = 0; i < 2 && !duration; i++) {
1507         int s_hour, s_min, s_sec, s_hsec, e_hour, e_min, e_sec, e_hsec;
1508         if (sscanf(*buf, "%d:%2d:%2d%*1[,.]%3d --> %d:%2d:%2d%*1[,.]%3d",
1509                    &s_hour, &s_min, &s_sec, &s_hsec,
1510                    &e_hour, &e_min, &e_sec, &e_hsec) == 8) {
1511             s_min += 60 * s_hour;
1512             e_min += 60 * e_hour;
1513             s_sec += 60 * s_min;
1514
1515             e_sec  += 60 * e_min;
1516             s_hsec += 1000 * s_sec;
1517             e_hsec += 1000 * e_sec;
1518
1519             duration = e_hsec - s_hsec;
1520         }
1521         *buf += strcspn(*buf, "\n") + 1;
1522     }
1523     return duration;
1524 }
1525
1526 static int mkv_write_srt_blocks(AVFormatContext *s, AVIOContext *pb,
1527                                 AVPacket *pkt)
1528 {
1529     ebml_master blockgroup;
1530     AVPacket pkt2 = *pkt;
1531     int64_t duration = srt_get_duration(&pkt2.data);
1532     pkt2.size -= pkt2.data - pkt->data;
1533
1534     blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP,
1535                                    mkv_blockgroup_size(pkt2.size));
1536     mkv_write_block(s, pb, MATROSKA_ID_BLOCK, &pkt2, 0);
1537     put_ebml_uint(pb, MATROSKA_ID_BLOCKDURATION, duration);
1538     end_ebml_master(pb, blockgroup);
1539
1540     return duration;
1541 }
1542
1543 static void mkv_flush_dynbuf(AVFormatContext *s)
1544 {
1545     MatroskaMuxContext *mkv = s->priv_data;
1546     int bufsize;
1547     uint8_t *dyn_buf;
1548
1549     if (!mkv->dyn_bc)
1550         return;
1551
1552     bufsize = avio_close_dyn_buf(mkv->dyn_bc, &dyn_buf);
1553     avio_write(s->pb, dyn_buf, bufsize);
1554     av_free(dyn_buf);
1555     mkv->dyn_bc = NULL;
1556 }
1557
1558 static int mkv_check_new_extra_data(AVFormatContext *s, AVPacket *pkt)
1559 {
1560     MatroskaMuxContext *mkv = s->priv_data;
1561     AVCodecParameters *par  = s->streams[pkt->stream_index]->codecpar;
1562     mkv_track *track        = &mkv->tracks[pkt->stream_index];
1563     uint8_t *side_data;
1564     int side_data_size = 0, ret;
1565
1566     side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA,
1567                                         &side_data_size);
1568
1569     switch (par->codec_id) {
1570     case AV_CODEC_ID_AAC:
1571         if (side_data_size && (s->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
1572             int output_sample_rate = 0;
1573             int64_t curpos;
1574             ret = get_aac_sample_rates(s, side_data, side_data_size, &track->sample_rate,
1575                                        &output_sample_rate);
1576             if (ret < 0)
1577                 return ret;
1578             if (!output_sample_rate)
1579                 output_sample_rate = track->sample_rate; // Space is already reserved, so it's this or a void element.
1580             curpos = avio_tell(s->pb);
1581             avio_seek(s->pb, track->sample_rate_offset, SEEK_SET);
1582             put_ebml_float(s->pb, MATROSKA_ID_AUDIOSAMPLINGFREQ, track->sample_rate);
1583             put_ebml_float(s->pb, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate);
1584             avio_seek(s->pb, curpos, SEEK_SET);
1585         } else if (!par->extradata_size && !track->sample_rate) {
1586             // No extradata (codecpar or packet side data).
1587             av_log(s, AV_LOG_ERROR, "Error parsing AAC extradata, unable to determine samplerate.\n");
1588             return AVERROR(EINVAL);
1589         }
1590         break;
1591     case AV_CODEC_ID_FLAC:
1592         if (side_data_size && (s->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
1593             AVCodecParameters *codecpriv_par;
1594             int64_t curpos;
1595             if (side_data_size != par->extradata_size) {
1596                 av_log(s, AV_LOG_ERROR, "Invalid FLAC STREAMINFO metadata for output stream %d\n",
1597                        pkt->stream_index);
1598                 return AVERROR(EINVAL);
1599             }
1600             codecpriv_par = avcodec_parameters_alloc();
1601             if (!codecpriv_par)
1602                 return AVERROR(ENOMEM);
1603             ret = avcodec_parameters_copy(codecpriv_par, par);
1604             if (ret < 0) {
1605                 avcodec_parameters_free(&codecpriv_par);
1606                 return ret;
1607             }
1608             memcpy(codecpriv_par->extradata, side_data, side_data_size);
1609             curpos = avio_tell(s->pb);
1610             avio_seek(s->pb, track->codecpriv_offset, SEEK_SET);
1611             mkv_write_codecprivate(s, s->pb, codecpriv_par, 1, 0);
1612             avio_seek(s->pb, curpos, SEEK_SET);
1613             avcodec_parameters_free(&codecpriv_par);
1614         }
1615         break;
1616     default:
1617         if (side_data_size)
1618             av_log(s, AV_LOG_DEBUG, "Ignoring new extradata in a packet for stream %d.\n", pkt->stream_index);
1619         break;
1620     }
1621
1622     return 0;
1623 }
1624
1625 static int mkv_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
1626 {
1627     MatroskaMuxContext *mkv = s->priv_data;
1628     AVIOContext *pb         = s->pb;
1629     AVCodecParameters *par  = s->streams[pkt->stream_index]->codecpar;
1630     int keyframe            = !!(pkt->flags & AV_PKT_FLAG_KEY);
1631     int duration            = pkt->duration;
1632     int ret;
1633     int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts;
1634
1635     if (ts == AV_NOPTS_VALUE) {
1636         av_log(s, AV_LOG_ERROR, "Can't write packet with unknown timestamp\n");
1637         return AVERROR(EINVAL);
1638     }
1639     ts += mkv->tracks[pkt->stream_index].ts_offset;
1640
1641     if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
1642         if (!mkv->dyn_bc) {
1643             ret = avio_open_dyn_buf(&mkv->dyn_bc);
1644             if (ret < 0)
1645                 return ret;
1646         }
1647         pb = mkv->dyn_bc;
1648     }
1649
1650     if (!mkv->cluster_pos) {
1651         mkv->cluster_pos = avio_tell(s->pb);
1652         mkv->cluster     = start_ebml_master(pb, MATROSKA_ID_CLUSTER, 0);
1653         put_ebml_uint(pb, MATROSKA_ID_CLUSTERTIMECODE, FFMAX(0, ts));
1654         mkv->cluster_pts = FFMAX(0, ts);
1655     }
1656
1657     if (par->codec_type != AVMEDIA_TYPE_SUBTITLE) {
1658         mkv_write_block(s, pb, MATROSKA_ID_SIMPLEBLOCK, pkt, keyframe << 7);
1659     } else if (par->codec_id == AV_CODEC_ID_SSA) {
1660         duration = mkv_write_ass_blocks(s, pb, pkt);
1661     } else if (par->codec_id == AV_CODEC_ID_SRT) {
1662         duration = mkv_write_srt_blocks(s, pb, pkt);
1663     } else {
1664         ebml_master blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP,
1665                                                    mkv_blockgroup_size(pkt->size));
1666         duration = pkt->duration;
1667 #if FF_API_CONVERGENCE_DURATION
1668 FF_DISABLE_DEPRECATION_WARNINGS
1669         if (pkt->convergence_duration)
1670             duration = pkt->convergence_duration;
1671 FF_ENABLE_DEPRECATION_WARNINGS
1672 #endif
1673         mkv_write_block(s, pb, MATROSKA_ID_BLOCK, pkt, 0);
1674         put_ebml_uint(pb, MATROSKA_ID_BLOCKDURATION, duration);
1675         end_ebml_master(pb, blockgroup);
1676     }
1677
1678     if (par->codec_type == AVMEDIA_TYPE_VIDEO && keyframe) {
1679         ret = mkv_add_cuepoint(mkv->cues, pkt->stream_index, ts,
1680                                mkv->cluster_pos);
1681         if (ret < 0)
1682             return ret;
1683     }
1684
1685     mkv->duration = FFMAX(mkv->duration, ts + duration);
1686     return 0;
1687 }
1688
1689 static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt)
1690 {
1691     MatroskaMuxContext *mkv = s->priv_data;
1692     int codec_type          = s->streams[pkt->stream_index]->codecpar->codec_type;
1693     int keyframe            = !!(pkt->flags & AV_PKT_FLAG_KEY);
1694     int cluster_size;
1695     int64_t cluster_time;
1696     AVIOContext *pb;
1697     int ret;
1698
1699     ret = mkv_check_new_extra_data(s, pkt);
1700     if (ret < 0)
1701         return ret;
1702
1703     if (mkv->tracks[pkt->stream_index].write_dts)
1704         cluster_time = pkt->dts - mkv->cluster_pts;
1705     else
1706         cluster_time = pkt->pts - mkv->cluster_pts;
1707     cluster_time += mkv->tracks[pkt->stream_index].ts_offset;
1708
1709     // start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or
1710     // after 4k and on a keyframe
1711     if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
1712         pb = s->pb;
1713         cluster_size = avio_tell(pb) - mkv->cluster_pos;
1714     } else {
1715         pb = mkv->dyn_bc;
1716         cluster_size = avio_tell(pb);
1717     }
1718
1719     if (mkv->cluster_pos &&
1720         (cluster_size > mkv->cluster_size_limit ||
1721          cluster_time > mkv->cluster_time_limit ||
1722          (codec_type == AVMEDIA_TYPE_VIDEO && keyframe &&
1723           cluster_size > 4 * 1024))) {
1724         av_log(s, AV_LOG_DEBUG,
1725                "Starting new cluster at offset %" PRIu64 " bytes, "
1726                "pts %" PRIu64 "dts %" PRIu64 "\n",
1727                avio_tell(pb), pkt->pts, pkt->dts);
1728         end_ebml_master(pb, mkv->cluster);
1729         mkv->cluster_pos = 0;
1730         if (mkv->dyn_bc)
1731             mkv_flush_dynbuf(s);
1732         avio_flush(s->pb);
1733     }
1734
1735     if (!mkv->cluster_pos)
1736         avio_write_marker(s->pb,
1737                           av_rescale_q(pkt->dts, s->streams[pkt->stream_index]->time_base, AV_TIME_BASE_Q),
1738                           keyframe && (mkv->have_video ? codec_type == AVMEDIA_TYPE_VIDEO : 1) ? AVIO_DATA_MARKER_SYNC_POINT : AVIO_DATA_MARKER_BOUNDARY_POINT);
1739
1740     // check if we have an audio packet cached
1741     if (mkv->cur_audio_pkt.size > 0) {
1742         ret = mkv_write_packet_internal(s, &mkv->cur_audio_pkt);
1743         av_packet_unref(&mkv->cur_audio_pkt);
1744         if (ret < 0) {
1745             av_log(s, AV_LOG_ERROR,
1746                    "Could not write cached audio packet ret:%d\n", ret);
1747             return ret;
1748         }
1749     }
1750
1751     // buffer an audio packet to ensure the packet containing the video
1752     // keyframe's timecode is contained in the same cluster for WebM
1753     if (codec_type == AVMEDIA_TYPE_AUDIO) {
1754         ret = av_packet_ref(&mkv->cur_audio_pkt, pkt);
1755     } else
1756         ret = mkv_write_packet_internal(s, pkt);
1757     return ret;
1758 }
1759
1760 static int mkv_write_flush_packet(AVFormatContext *s, AVPacket *pkt)
1761 {
1762     MatroskaMuxContext *mkv = s->priv_data;
1763     AVIOContext *pb;
1764     if (s->pb->seekable & AVIO_SEEKABLE_NORMAL)
1765         pb = s->pb;
1766     else
1767         pb = mkv->dyn_bc;
1768     if (!pkt) {
1769         if (mkv->cluster_pos) {
1770             av_log(s, AV_LOG_DEBUG,
1771                    "Flushing cluster at offset %" PRIu64 " bytes\n",
1772                    avio_tell(pb));
1773             end_ebml_master(pb, mkv->cluster);
1774             mkv->cluster_pos = 0;
1775             if (mkv->dyn_bc)
1776                 mkv_flush_dynbuf(s);
1777             avio_flush(s->pb);
1778         }
1779         return 1;
1780     }
1781     return mkv_write_packet(s, pkt);
1782 }
1783
1784 static int mkv_write_trailer(AVFormatContext *s)
1785 {
1786     MatroskaMuxContext *mkv = s->priv_data;
1787     AVIOContext *pb = s->pb;
1788     int64_t currentpos, cuespos;
1789     int ret;
1790
1791     // check if we have an audio packet cached
1792     if (mkv->cur_audio_pkt.size > 0) {
1793         ret = mkv_write_packet_internal(s, &mkv->cur_audio_pkt);
1794         av_packet_unref(&mkv->cur_audio_pkt);
1795         if (ret < 0) {
1796             av_log(s, AV_LOG_ERROR,
1797                    "Could not write cached audio packet ret:%d\n", ret);
1798             return ret;
1799         }
1800     }
1801
1802     if (mkv->dyn_bc) {
1803         end_ebml_master(mkv->dyn_bc, mkv->cluster);
1804         mkv_flush_dynbuf(s);
1805     } else if (mkv->cluster_pos) {
1806         end_ebml_master(pb, mkv->cluster);
1807     }
1808
1809     if (mkv->mode != MODE_WEBM) {
1810         ret = mkv_write_chapters(s);
1811         if (ret < 0)
1812             return ret;
1813     }
1814
1815     if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
1816         if (mkv->cues->num_entries) {
1817             if (mkv->reserve_cues_space) {
1818                 int64_t cues_end;
1819
1820                 currentpos = avio_tell(pb);
1821                 avio_seek(pb, mkv->cues_pos, SEEK_SET);
1822
1823                 cuespos  = mkv_write_cues(pb, mkv->cues, s->nb_streams);
1824                 cues_end = avio_tell(pb);
1825                 if (cues_end > cuespos + mkv->reserve_cues_space) {
1826                     av_log(s, AV_LOG_ERROR,
1827                            "Insufficient space reserved for cues: %d "
1828                            "(needed: %" PRId64 ").\n",
1829                            mkv->reserve_cues_space, cues_end - cuespos);
1830                     return AVERROR(EINVAL);
1831                 }
1832
1833                 if (cues_end < cuespos + mkv->reserve_cues_space)
1834                     put_ebml_void(pb, mkv->reserve_cues_space -
1835                                   (cues_end - cuespos));
1836
1837                 avio_seek(pb, currentpos, SEEK_SET);
1838             } else {
1839                 cuespos = mkv_write_cues(pb, mkv->cues, s->nb_streams);
1840             }
1841
1842             ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_CUES,
1843                                          cuespos);
1844             if (ret < 0)
1845                 return ret;
1846         }
1847
1848         mkv_write_seekhead(pb, mkv->main_seekhead);
1849
1850         // update the duration
1851         av_log(s, AV_LOG_DEBUG, "end duration = %" PRIu64 "\n", mkv->duration);
1852         currentpos = avio_tell(pb);
1853         avio_seek(pb, mkv->duration_offset, SEEK_SET);
1854         put_ebml_float(pb, MATROSKA_ID_DURATION, mkv->duration);
1855
1856         avio_seek(pb, currentpos, SEEK_SET);
1857     }
1858
1859     end_ebml_master(pb, mkv->segment);
1860     av_free(mkv->tracks);
1861     av_freep(&mkv->cues->entries);
1862     av_freep(&mkv->cues);
1863
1864     return 0;
1865 }
1866
1867 static int mkv_query_codec(enum AVCodecID codec_id, int std_compliance)
1868 {
1869     int i;
1870     for (i = 0; ff_mkv_codec_tags[i].id != AV_CODEC_ID_NONE; i++)
1871         if (ff_mkv_codec_tags[i].id == codec_id)
1872             return 1;
1873
1874     if (std_compliance < FF_COMPLIANCE_NORMAL) {
1875         enum AVMediaType type = avcodec_get_type(codec_id);
1876         // mkv theoretically supports any video/audio through VFW/ACM
1877         if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO)
1878             return 1;
1879     }
1880
1881     return 0;
1882 }
1883
1884 #define OFFSET(x) offsetof(MatroskaMuxContext, x)
1885 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM
1886 static const AVOption options[] = {
1887     { "reserve_index_space", "Reserve a given amount of space (in bytes) at the beginning of the file for the index (cues).", OFFSET(reserve_cues_space), AV_OPT_TYPE_INT,   { .i64 = 0 },   0, INT_MAX,   FLAGS },
1888     { "cluster_size_limit",  "Store at most the provided amount of bytes in a cluster. ",                                     OFFSET(cluster_size_limit), AV_OPT_TYPE_INT  , { .i64 = -1 }, -1, INT_MAX,   FLAGS },
1889     { "cluster_time_limit",  "Store at most the provided number of milliseconds in a cluster.",                               OFFSET(cluster_time_limit), AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, INT64_MAX, FLAGS },
1890     { NULL },
1891 };
1892
1893 #if CONFIG_MATROSKA_MUXER
1894 static const AVClass matroska_class = {
1895     .class_name = "matroska muxer",
1896     .item_name  = av_default_item_name,
1897     .option     = options,
1898     .version    = LIBAVUTIL_VERSION_INT,
1899 };
1900
1901 AVOutputFormat ff_matroska_muxer = {
1902     .name              = "matroska",
1903     .long_name         = NULL_IF_CONFIG_SMALL("Matroska"),
1904     .mime_type         = "video/x-matroska",
1905     .extensions        = "mkv",
1906     .priv_data_size    = sizeof(MatroskaMuxContext),
1907     .audio_codec       = CONFIG_LIBVORBIS_ENCODER ?
1908                          AV_CODEC_ID_VORBIS : AV_CODEC_ID_AC3,
1909     .video_codec       = CONFIG_LIBX264_ENCODER ?
1910                          AV_CODEC_ID_H264 : AV_CODEC_ID_MPEG4,
1911     .write_header      = mkv_write_header,
1912     .write_packet      = mkv_write_flush_packet,
1913     .write_trailer     = mkv_write_trailer,
1914     .flags             = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS |
1915                          AVFMT_TS_NONSTRICT | AVFMT_ALLOW_FLUSH,
1916     .codec_tag         = (const AVCodecTag* const []){
1917          ff_codec_bmp_tags, ff_codec_wav_tags, 0
1918     },
1919     .subtitle_codec    = AV_CODEC_ID_SSA,
1920     .query_codec       = mkv_query_codec,
1921     .priv_class        = &matroska_class,
1922 };
1923 #endif
1924
1925 #if CONFIG_WEBM_MUXER
1926 static const AVClass webm_class = {
1927     .class_name = "webm muxer",
1928     .item_name  = av_default_item_name,
1929     .option     = options,
1930     .version    = LIBAVUTIL_VERSION_INT,
1931 };
1932
1933 AVOutputFormat ff_webm_muxer = {
1934     .name              = "webm",
1935     .long_name         = NULL_IF_CONFIG_SMALL("WebM"),
1936     .mime_type         = "video/webm",
1937     .extensions        = "webm",
1938     .priv_data_size    = sizeof(MatroskaMuxContext),
1939     .audio_codec       = CONFIG_LIBOPUS_ENCODER ? AV_CODEC_ID_OPUS : AV_CODEC_ID_VORBIS,
1940     .video_codec       = CONFIG_LIBVPX_VP9_ENCODER? AV_CODEC_ID_VP9 : AV_CODEC_ID_VP8,
1941     .write_header      = mkv_write_header,
1942     .write_packet      = mkv_write_flush_packet,
1943     .write_trailer     = mkv_write_trailer,
1944     .flags             = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS |
1945                          AVFMT_TS_NONSTRICT | AVFMT_ALLOW_FLUSH,
1946     .priv_class        = &webm_class,
1947 };
1948 #endif
1949
1950 #if CONFIG_MATROSKA_AUDIO_MUXER
1951 static const AVClass mka_class = {
1952     .class_name = "matroska audio muxer",
1953     .item_name  = av_default_item_name,
1954     .option     = options,
1955     .version    = LIBAVUTIL_VERSION_INT,
1956 };
1957 AVOutputFormat ff_matroska_audio_muxer = {
1958     .name              = "matroska",
1959     .long_name         = NULL_IF_CONFIG_SMALL("Matroska"),
1960     .mime_type         = "audio/x-matroska",
1961     .extensions        = "mka",
1962     .priv_data_size    = sizeof(MatroskaMuxContext),
1963     .audio_codec       = CONFIG_LIBVORBIS_ENCODER ?
1964                          AV_CODEC_ID_VORBIS : AV_CODEC_ID_AC3,
1965     .video_codec       = AV_CODEC_ID_NONE,
1966     .write_header      = mkv_write_header,
1967     .write_packet      = mkv_write_flush_packet,
1968     .write_trailer     = mkv_write_trailer,
1969     .flags             = AVFMT_GLOBALHEADER | AVFMT_TS_NONSTRICT |
1970                          AVFMT_ALLOW_FLUSH,
1971     .codec_tag         = (const AVCodecTag* const []){ ff_codec_wav_tags, 0 },
1972     .priv_class        = &mka_class,
1973 };
1974 #endif