Merge commit 'e1eb0fc960163402bbb4e630185790488f7d28ed'
authorMatthieu Bouron <matthieu.bouron@stupeflix.com>
Thu, 23 Jun 2016 20:02:31 +0000 (22:02 +0200)
committerMatthieu Bouron <matthieu.bouron@stupeflix.com>
Thu, 23 Jun 2016 20:02:31 +0000 (22:02 +0200)
* commit 'e1eb0fc960163402bbb4e630185790488f7d28ed':
  movenc: Use packets in interleaving queues for the duration at the end of fragments

Merged-by: Matthieu Bouron <matthieu.bouron@stupeflix.com>
1  2 
libavformat/avformat.h
libavformat/internal.h
libavformat/movenc.c
libavformat/movenc.h
libavformat/mux.c
libavformat/version.h

diff --combined libavformat/avformat.h
index f66c39b1c19310d4c37a75551966492564ddb5c1,fbdfba4fb1dc2a22df9e0a82958bbd811be8a678..4eb11404ca2058d46f99d7a5c81a54042c2eb7b5
@@@ -1,20 -1,20 +1,20 @@@
  /*
   * copyright (c) 2001 Fabrice Bellard
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -50,7 -50,7 +50,7 @@@
   *
   * Main lavf structure used for both muxing and demuxing is AVFormatContext,
   * which exports all information about the file being read or written. As with
 - * most Libav structures, its size is not part of public ABI, so it cannot be
 + * most Libavformat structures, its size is not part of public ABI, so it cannot be
   * allocated on stack or directly with av_malloc(). To create an
   * AVFormatContext, use avformat_alloc_context() (some functions, like
   * avformat_open_input() might do that for you).
@@@ -67,7 -67,7 +67,7 @@@
   * with an AVFMT_NOFILE format).
   *
   * @section lavf_options Passing options to (de)muxers
 - * Lavf allows to configure muxers and demuxers using the @ref avoptions
 + * It is possible to configure lavf muxers and demuxers using the @ref avoptions
   * mechanism. Generic (format-independent) libavformat options are provided by
   * AVFormatContext, they can be examined from a user program by calling
   * av_opt_next() / av_opt_find() on an allocated AVFormatContext (or its AVClass
   * if its AVClass is non-NULL, and the protocols layer. See the discussion on
   * nesting in @ref avoptions documentation to learn how to access those.
   *
 + * @section urls
 + * URL strings in libavformat are made of a scheme/protocol, a ':', and a
 + * scheme specific string. URLs without a scheme and ':' used for local files
 + * are supported but deprecated. "file:" should be used for local files.
 + *
 + * It is important that the scheme string is not taken from untrusted
 + * sources without checks.
 + *
 + * Note that some schemes/protocols are quite powerful, allowing access to
 + * both local and remote files, parts of them, concatenations of them, local
 + * audio and video devices and so on.
 + *
   * @defgroup lavf_decoding Demuxing
   * @{
   * Demuxers read a media file and split it into chunks of data (@em packets). A
   * cleanup.
   *
   * @section lavf_decoding_open Opening a media file
 - * The minimum information required to open a file is its URL or filename, which
 + * The minimum information required to open a file is its URL, which
   * is passed to avformat_open_input(), as in the following code:
   * @code
 - * const char    *url = "in.mp3";
 + * const char    *url = "file:in.mp3";
   * AVFormatContext *s = NULL;
   * int ret = avformat_open_input(&s, url, NULL, NULL);
   * if (ret < 0)
   *
   * @defgroup lavf_io I/O Read/Write
   * @{
 + * @section lavf_io_dirlist Directory listing
 + * The directory listing API makes it possible to list files on remote servers.
 + *
 + * Some of possible use cases:
 + * - an "open file" dialog to choose files from a remote location,
 + * - a recursive media finder providing a player with an ability to play all
 + * files from a given directory.
 + *
 + * @subsection lavf_io_dirlist_open Opening a directory
 + * At first, a directory needs to be opened by calling avio_open_dir()
 + * supplied with a URL and, optionally, ::AVDictionary containing
 + * protocol-specific parameters. The function returns zero or positive
 + * integer and allocates AVIODirContext on success.
 + *
 + * @code
 + * AVIODirContext *ctx = NULL;
 + * if (avio_open_dir(&ctx, "smb://example.com/some_dir", NULL) < 0) {
 + *     fprintf(stderr, "Cannot open directory.\n");
 + *     abort();
 + * }
 + * @endcode
 + *
 + * This code tries to open a sample directory using smb protocol without
 + * any additional parameters.
 + *
 + * @subsection lavf_io_dirlist_read Reading entries
 + * Each directory's entry (i.e. file, another directory, anything else
 + * within ::AVIODirEntryType) is represented by AVIODirEntry.
 + * Reading consecutive entries from an opened AVIODirContext is done by
 + * repeatedly calling avio_read_dir() on it. Each call returns zero or
 + * positive integer if successful. Reading can be stopped right after the
 + * NULL entry has been read -- it means there are no entries left to be
 + * read. The following code reads all entries from a directory associated
 + * with ctx and prints their names to standard output.
 + * @code
 + * AVIODirEntry *entry = NULL;
 + * for (;;) {
 + *     if (avio_read_dir(ctx, &entry) < 0) {
 + *         fprintf(stderr, "Cannot list directory.\n");
 + *         abort();
 + *     }
 + *     if (!entry)
 + *         break;
 + *     printf("%s\n", entry->name);
 + *     avio_free_directory_entry(&entry);
 + * }
 + * @endcode
   * @}
   *
   * @defgroup lavf_codec Demuxers
  
  struct AVFormatContext;
  
 +struct AVDeviceInfoList;
 +struct AVDeviceCapabilitiesQuery;
  
  /**
   * @defgroup metadata_api Public Metadata API
   *
   * Metadata is exported or set as pairs of key/value strings in the 'metadata'
   * fields of the AVFormatContext, AVStream, AVChapter and AVProgram structs
 - * using the @ref lavu_dict "AVDictionary" API. Like all strings in Libav,
 + * using the @ref lavu_dict "AVDictionary" API. Like all strings in FFmpeg,
   * metadata is assumed to be UTF-8 encoded Unicode. Note that metadata
   * exported by demuxers isn't checked to be valid UTF-8 in most cases.
   *
@@@ -463,9 -402,6 +463,9 @@@ typedef struct AVProbeData 
      const char *mime_type; /**< mime_type, when known. */
  } AVProbeData;
  
 +#define AVPROBE_SCORE_RETRY (AVPROBE_SCORE_MAX/4)
 +#define AVPROBE_SCORE_STREAM_RETRY (AVPROBE_SCORE_MAX/4-1)
 +
  #define AVPROBE_SCORE_EXTENSION  50 ///< score for file extension
  #define AVPROBE_SCORE_MIME       75 ///< score for file mime type
  #define AVPROBE_SCORE_MAX       100 ///< maximum score
                                          timestamps. If not set the timestamp
                                          will be shifted in av_write_frame and
                                          av_interleaved_write_frame so they
 -                                        start from 0. */
 +                                        start from 0.
 +                                        The user or muxer can override this through
 +                                        AVFormatContext.avoid_negative_ts
 +                                        */
 +
 +#define AVFMT_SEEK_TO_PTS   0x4000000 /**< Seeking is based on PTS */
  
  /**
   * @addtogroup lavf_encoding
@@@ -573,67 -504,8 +573,67 @@@ typedef struct AVOutputFormat 
       *
       * @return 1 if the codec is supported, 0 if it is not.
       *         A negative number if unknown.
 +     *         MKTAG('A', 'P', 'I', 'C') if the codec is only supported as AV_DISPOSITION_ATTACHED_PIC
       */
      int (*query_codec)(enum AVCodecID id, int std_compliance);
 +
 +    void (*get_output_timestamp)(struct AVFormatContext *s, int stream,
 +                                 int64_t *dts, int64_t *wall);
 +    /**
 +     * Allows sending messages from application to device.
 +     */
 +    int (*control_message)(struct AVFormatContext *s, int type,
 +                           void *data, size_t data_size);
 +
 +    /**
 +     * Write an uncoded AVFrame.
 +     *
 +     * See av_write_uncoded_frame() for details.
 +     *
 +     * The library will free *frame afterwards, but the muxer can prevent it
 +     * by setting the pointer to NULL.
 +     */
 +    int (*write_uncoded_frame)(struct AVFormatContext *, int stream_index,
 +                               AVFrame **frame, unsigned flags);
 +    /**
 +     * Returns device list with it properties.
 +     * @see avdevice_list_devices() for more details.
 +     */
 +    int (*get_device_list)(struct AVFormatContext *s, struct AVDeviceInfoList *device_list);
 +    /**
 +     * Initialize device capabilities submodule.
 +     * @see avdevice_capabilities_create() for more details.
 +     */
 +    int (*create_device_capabilities)(struct AVFormatContext *s, struct AVDeviceCapabilitiesQuery *caps);
 +    /**
 +     * Free device capabilities submodule.
 +     * @see avdevice_capabilities_free() for more details.
 +     */
 +    int (*free_device_capabilities)(struct AVFormatContext *s, struct AVDeviceCapabilitiesQuery *caps);
 +    enum AVCodecID data_codec; /**< default data codec */
 +    /**
 +     * Initialize format. May allocate data here, and set any AVFormatContext or
 +     * AVStream parameters that need to be set before packets are sent.
 +     * This method must not write output.
 +     *
 +     * Any allocations made here must be freed in deinit().
 +     */
 +    int (*init)(struct AVFormatContext *);
 +    /**
 +     * Deinitialize format. If present, this is called whenever the muxer is being
 +     * destroyed, regardless of whether or not the header has been written.
 +     *
 +     * If a trailer is being written, this is called after write_trailer().
 +     *
 +     * This is called if init() fails as well.
 +     */
 +    void (*deinit)(struct AVFormatContext *);
 +    /**
 +     * Set up any necessary bitstream filtering and extract any extra data needed
 +     * for the global header.
 +     * Return 0 if more packets from this stream must be checked; 1 if not.
 +     */
 +    int (*check_bitstream)(struct AVFormatContext *, const AVPacket *pkt);
  } AVOutputFormat;
  /**
   * @}
@@@ -660,7 -532,7 +660,7 @@@ typedef struct AVInputFormat 
      /**
       * Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS,
       * AVFMT_GENERIC_INDEX, AVFMT_TS_DISCONT, AVFMT_NOBINSEARCH,
 -     * AVFMT_NOGENSEARCH, AVFMT_NO_BYTE_SEEK.
 +     * AVFMT_NOGENSEARCH, AVFMT_NO_BYTE_SEEK, AVFMT_SEEK_TO_PTS.
       */
      int flags;
  
       * Active streams are all streams that have AVStream.discard < AVDISCARD_ALL.
       */
      int (*read_seek2)(struct AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags);
 +
 +    /**
 +     * Returns device list with it properties.
 +     * @see avdevice_list_devices() for more details.
 +     */
 +    int (*get_device_list)(struct AVFormatContext *s, struct AVDeviceInfoList *device_list);
 +
 +    /**
 +     * Initialize device capabilities submodule.
 +     * @see avdevice_capabilities_create() for more details.
 +     */
 +    int (*create_device_capabilities)(struct AVFormatContext *s, struct AVDeviceCapabilitiesQuery *caps);
 +
 +    /**
 +     * Free device capabilities submodule.
 +     * @see avdevice_capabilities_free() for more details.
 +     */
 +    int (*free_device_capabilities)(struct AVFormatContext *s, struct AVDeviceCapabilitiesQuery *caps);
  } AVInputFormat;
  /**
   * @}
@@@ -798,19 -652,11 +798,19 @@@ enum AVStreamParseType 
      AVSTREAM_PARSE_HEADERS,    /**< Only parse headers, do not repack. */
      AVSTREAM_PARSE_TIMESTAMPS, /**< full parsing and interpolation of timestamps for frames not starting on a packet boundary */
      AVSTREAM_PARSE_FULL_ONCE,  /**< full parsing and repack of the first frame only, only implemented for H.264 currently */
 +    AVSTREAM_PARSE_FULL_RAW=MKTAG(0,'R','A','W'),       /**< full parsing and repack with timestamp and position generation by parser for raw
 +                                                             this assumes that each packet in the file contains no demuxer level headers and
 +                                                             just codec level data, otherwise position generation would fail */
  };
  
  typedef struct AVIndexEntry {
      int64_t pos;
 -    int64_t timestamp;
 +    int64_t timestamp;        /**<
 +                               * Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are available
 +                               * when seeking to this entry. That means preferable PTS on keyframe based formats.
 +                               * But demuxers can choose to store a different timestamp, if it is more convenient for the implementation or nothing better
 +                               * is known
 +                               */
  #define AVINDEX_KEYFRAME 0x0001
      int flags:2;
      int size:30; //Yeah, trying to keep the size of this small to reduce memory requirements (it is 24 vs. 32 bytes due to possible 8-byte alignment).
  
  typedef struct AVStreamInternal AVStreamInternal;
  
 +/**
 + * To specify text track kind (different from subtitles default).
 + */
 +#define AV_DISPOSITION_CAPTIONS     0x10000
 +#define AV_DISPOSITION_DESCRIPTIONS 0x20000
 +#define AV_DISPOSITION_METADATA     0x40000
 +
 +/**
 + * Options for behavior on timestamp wrap detection.
 + */
 +#define AV_PTS_WRAP_IGNORE      0   ///< ignore the wrap
 +#define AV_PTS_WRAP_ADD_OFFSET  1   ///< add the format specific offset on wrap detection
 +#define AV_PTS_WRAP_SUB_OFFSET  -1  ///< subtract the format specific offset on wrap detection
 +
  /**
   * Stream structure.
   * New fields can be added to the end with minor version bumps.
@@@ -904,12 -736,10 +904,12 @@@ typedef struct AVStream 
      AVRational time_base;
  
      /**
 -     * Decoding: pts of the first frame of the stream, in stream time base.
 +     * Decoding: pts of the first frame of the stream in presentation order, in stream time base.
       * Only set this if you are absolutely 100% sure that the value you set
       * it to really is the pts of the first frame.
       * This may be undefined (AV_NOPTS_VALUE).
 +     * @note The ASF header does NOT contain a correct start_time the ASF
 +     * demuxer must NOT set this.
       */
      int64_t start_time;
  
       * - muxing: May be set by the caller before avformat_write_header().
       *
       * Freed by libavformat in avformat_free_context().
 +     *
 +     * @see av_format_inject_global_side_data()
       */
      AVPacketSideData *side_data;
      /**
      /**
       * Stream information used internally by av_find_stream_info()
       */
 -#define MAX_STD_TIMEBASES (60*12+5)
 +#define MAX_STD_TIMEBASES (30*12+30+3+6)
      struct {
 -        int nb_decoded_frames;
 +        int64_t last_dts;
 +        int64_t duration_gcd;
 +        int duration_count;
 +        int64_t rfps_duration_sum;
 +        double (*duration_error)[2][MAX_STD_TIMEBASES];
 +        int64_t codec_info_duration;
 +        int64_t codec_info_duration_fields;
 +
 +        /**
 +         * 0  -> decoder has not been searched for yet.
 +         * >0 -> decoder found
 +         * <0 -> decoder with codec_id == -found_decoder has not been found
 +         */
          int found_decoder;
  
 +        int64_t last_duration;
 +
          /**
           * Those are used for average framerate estimation.
           */
      int pts_wrap_bits; /**< number of bits in pts (used for wrapping control) */
  
      // Timestamp generation support:
 +    /**
 +     * Timestamp corresponding to the last dts sync point.
 +     *
 +     * Initialized when AVCodecParserContext.dts_sync_point >= 0 and
 +     * a DTS is received from the underlying container. Otherwise set to
 +     * AV_NOPTS_VALUE by default.
 +     */
      int64_t first_dts;
      int64_t cur_dts;
      int64_t last_IP_pts;
      /**
       * Number of packets to buffer for codec probing
       */
 -#define MAX_PROBE_PACKETS 2500
      int probe_packets;
  
      /**
      int nb_index_entries;
      unsigned int index_entries_allocated_size;
  
 +    /**
 +     * Real base framerate of the stream.
 +     * This is the lowest framerate with which all timestamps can be
 +     * represented accurately (it is the least common multiple of all
 +     * framerates in the stream). Note, this value is just a guess!
 +     * For example, if the time base is 1/90000 and all frames have either
 +     * approximately 3600 or 1800 timer ticks, then r_frame_rate will be 50/1.
 +     *
 +     * Code outside avformat should access this field using:
 +     * av_stream_get/set_r_frame_rate(stream)
 +     */
 +    AVRational r_frame_rate;
 +
 +    /**
 +     * Stream Identifier
 +     * This is the MPEG-TS stream identifier +1
 +     * 0 means unknown
 +     */
 +    int stream_identifier;
 +
 +    int64_t interleaver_chunk_size;
 +    int64_t interleaver_chunk_duration;
 +
 +    /**
 +     * stream probing state
 +     * -1   -> probing finished
 +     *  0   -> no probing requested
 +     * rest -> perform probing with request_probe being the minimum score to accept.
 +     * NOT PART OF PUBLIC API
 +     */
 +    int request_probe;
 +    /**
 +     * Indicates that everything up to the next keyframe
 +     * should be discarded.
 +     */
 +    int skip_to_keyframe;
 +
 +    /**
 +     * Number of samples to skip at the start of the frame decoded from the next packet.
 +     */
 +    int skip_samples;
 +
 +    /**
 +     * If not 0, the number of samples that should be skipped from the start of
 +     * the stream (the samples are removed from packets with pts==0, which also
 +     * assumes negative timestamps do not happen).
 +     * Intended for use with formats such as mp3 with ad-hoc gapless audio
 +     * support.
 +     */
 +    int64_t start_skip_samples;
 +
 +    /**
 +     * If not 0, the first audio sample that should be discarded from the stream.
 +     * This is broken by design (needs global sample count), but can't be
 +     * avoided for broken by design formats such as mp3 with ad-hoc gapless
 +     * audio support.
 +     */
 +    int64_t first_discard_sample;
 +
 +    /**
 +     * The sample after last sample that is intended to be discarded after
 +     * first_discard_sample. Works on frame boundaries only. Used to prevent
 +     * early EOF if the gapless info is broken (considered concatenated mp3s).
 +     */
 +    int64_t last_discard_sample;
 +
 +    /**
 +     * Number of internally decoded frames, used internally in libavformat, do not access
 +     * its lifetime differs from info which is why it is not in that structure.
 +     */
 +    int nb_decoded_frames;
 +
 +    /**
 +     * Timestamp offset added to timestamps before muxing
 +     * NOT PART OF PUBLIC API
 +     */
 +    int64_t mux_ts_offset;
 +
 +    /**
 +     * Internal data to check for wrapping of the time stamp
 +     */
 +    int64_t pts_wrap_reference;
 +
 +    /**
 +     * Options for behavior, when a wrap is detected.
 +     *
 +     * Defined by AV_PTS_WRAP_ values.
 +     *
 +     * If correction is enabled, there are two possibilities:
 +     * If the first time stamp is near the wrap point, the wrap offset
 +     * will be subtracted, which will create negative time stamps.
 +     * Otherwise the offset will be added.
 +     */
 +    int pts_wrap_behavior;
 +
 +    /**
 +     * Internal data to prevent doing update_initial_durations() twice
 +     */
 +    int update_initial_durations_done;
 +
 +    /**
 +     * Internal data to generate dts from pts
 +     */
 +    int64_t pts_reorder_error[MAX_REORDER_DELAY+1];
 +    uint8_t pts_reorder_error_count[MAX_REORDER_DELAY+1];
 +
 +    /**
 +     * Internal data to analyze DTS and detect faulty mpeg streams
 +     */
 +    int64_t last_dts_for_order_check;
 +    uint8_t dts_ordered;
 +    uint8_t dts_misordered;
 +
 +    /**
 +     * Internal data to inject global side data
 +     */
 +    int inject_global_side_data;
 +
 +    /**
 +     * String containing paris of key and values describing recommended encoder configuration.
 +     * Paris are separated by ','.
 +     * Keys are separated from values by '='.
 +     */
 +    char *recommended_encoder_configuration;
 +
 +    /**
 +     * display aspect ratio (0 if unknown)
 +     * - encoding: unused
 +     * - decoding: Set by libavformat to calculate sample_aspect_ratio internally
 +     */
 +    AVRational display_aspect_ratio;
 +
 +    struct FFFrac *priv_pts;
 +
      /**
       * An opaque field for libavformat internal usage.
       * Must not be accessed in any way by callers.
      AVStreamInternal *internal;
  } AVStream;
  
 +AVRational av_stream_get_r_frame_rate(const AVStream *s);
 +void       av_stream_set_r_frame_rate(AVStream *s, AVRational r);
 +struct AVCodecParserContext *av_stream_get_parser(const AVStream *s);
 +char* av_stream_get_recommended_encoder_configuration(const AVStream *s);
 +void  av_stream_set_recommended_encoder_configuration(AVStream *s, char *configuration);
 +
 +/**
 + * Returns the pts of the last muxed packet + its duration
 + *
 + * the retuned value is undefined when used with a demuxer.
 + */
 +int64_t    av_stream_get_end_pts(const AVStream *st);
 +
  #define AV_PROGRAM_RUNNING 1
  
  /**
@@@ -1247,23 -908,6 +1247,23 @@@ typedef struct AVProgram 
      unsigned int   *stream_index;
      unsigned int   nb_stream_indexes;
      AVDictionary *metadata;
 +
 +    int program_num;
 +    int pmt_pid;
 +    int pcr_pid;
 +
 +    /*****************************************************************
 +     * All fields below this line are not part of the public API. They
 +     * may not be used outside of libavformat and can be changed and
 +     * removed at will.
 +     * New public fields should be added right above.
 +     *****************************************************************
 +     */
 +    int64_t start_time;
 +    int64_t end_time;
 +
 +    int64_t pts_wrap_reference;    ///< reference dts for wrap detection
 +    int pts_wrap_behavior;         ///< behavior on wrap detection
  } AVProgram;
  
  #define AVFMTCTX_NOHEADER      0x0001 /**< signal that no header is present
@@@ -1276,26 -920,6 +1276,26 @@@ typedef struct AVChapter 
      AVDictionary *metadata;
  } AVChapter;
  
 +
 +/**
 + * Callback used by devices to communicate with application.
 + */
 +typedef int (*av_format_control_message)(struct AVFormatContext *s, int type,
 +                                         void *data, size_t data_size);
 +
 +typedef int (*AVOpenCallback)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags,
 +                              const AVIOInterruptCB *int_cb, AVDictionary **options);
 +
 +/**
 + * The duration of a video can be estimated through various ways, and this enum can be used
 + * to know how the duration was estimated.
 + */
 +enum AVDurationEstimationMethod {
 +    AVFMT_DURATION_FROM_PTS,    ///< Duration accurately estimated from PTSes
 +    AVFMT_DURATION_FROM_STREAM, ///< Duration estimated from a stream with a known duration
 +    AVFMT_DURATION_FROM_BITRATE ///< Duration estimated from bitrate (less accurate)
 +};
 +
  typedef struct AVFormatInternal AVFormatInternal;
  
  /**
   * version bump.
   * sizeof(AVFormatContext) must not be used outside libav*, use
   * avformat_alloc_context() to create an AVFormatContext.
 + *
 + * Fields can be accessed through AVOptions (av_opt*),
 + * the name string used matches the associated command line parameter name and
 + * can be found in libavformat/options_table.h.
 + * The AVOption/command line parameter names differ in some cases from the C
 + * structure field names for historic reasons or brevity.
   */
  typedef struct AVFormatContext {
      /**
      /**
       * Total stream bitrate in bit/s, 0 if not
       * available. Never set it directly if the file_size and the
 -     * duration are known as Libav can compute it automatically.
 +     * duration are known as FFmpeg can compute it automatically.
       */
 -    int bit_rate;
 +    int64_t bit_rate;
  
      unsigned int packet_size;
      int max_delay;
   * This flag is mainly intended for testing.
   */
  #define AVFMT_FLAG_BITEXACT         0x0400
 +#define AVFMT_FLAG_MP4A_LATM    0x8000 ///< Enable RTP MP4A-LATM payload
 +#define AVFMT_FLAG_SORT_DTS    0x10000 ///< try to interleave outputted packets by dts (using this flag can slow demuxing down)
 +#define AVFMT_FLAG_PRIV_OPT    0x20000 ///< Enable use of private options by delaying codec open (this could be made default once all code is converted)
 +#define AVFMT_FLAG_KEEP_SIDE_DATA 0x40000 ///< Don't merge side data but keep it separate.
 +#define AVFMT_FLAG_FAST_SEEK   0x80000 ///< Enable fast, but inaccurate seeks for some formats
  
      /**
       * Maximum size of the data read from input for determining
       * the input container format.
       * Demuxing only, set by the caller before avformat_open_input().
       */
 -    unsigned int probesize;
 +    int64_t probesize;
  
      /**
       * Maximum duration (in AV_TIME_BASE units) of the data read
       * from input in avformat_find_stream_info().
       * Demuxing only, set by the caller before avformat_find_stream_info().
 +     * Can be set to 0 to let avformat choose using a heuristic.
       */
 -    int max_analyze_duration;
 +    int64_t max_analyze_duration;
  
      const uint8_t *key;
      int keylen;
       * Start time of the stream in real world time, in microseconds
       * since the Unix epoch (00:00 1st January 1970). That is, pts=0 in the
       * stream was captured at this real world time.
 -     * Muxing only, set by the caller before avformat_write_header().
 +     * - muxing: Set by the caller before avformat_write_header(). If set to
 +     *           either 0 or AV_NOPTS_VALUE, then the current wall-time will
 +     *           be used.
 +     * - demuxing: Set by libavformat. AV_NOPTS_VALUE if unknown. Note that
 +     *             the value may become known after some number of frames
 +     *             have been received.
       */
      int64_t start_time_realtime;
  
      /**
       * Avoid negative timestamps during muxing.
       * Any value of the AVFMT_AVOID_NEG_TS_* constants.
 -     * Note, this only works when using av_interleaved_write_frame.
 +     * Note, this only works when using av_interleaved_write_frame. (interleave_packet_per_dts is in use)
       * - muxing: Set by user
       * - demuxing: unused
       */
  #define AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE 1 ///< Shift timestamps so they are non negative
  #define AVFMT_AVOID_NEG_TS_MAKE_ZERO         2 ///< Shift timestamps so that they start at 0
  
 +    /**
 +     * Transport stream id.
 +     * This will be moved into demuxer private options. Thus no API/ABI compatibility
 +     */
 +    int ts_id;
 +
 +    /**
 +     * Audio preload in microseconds.
 +     * Note, not all formats support this and unpredictable things may happen if it is used when not supported.
 +     * - encoding: Set by user via AVOptions (NO direct access)
 +     * - decoding: unused
 +     */
 +    int audio_preload;
 +
 +    /**
 +     * Max chunk time in microseconds.
 +     * Note, not all formats support this and unpredictable things may happen if it is used when not supported.
 +     * - encoding: Set by user via AVOptions (NO direct access)
 +     * - decoding: unused
 +     */
 +    int max_chunk_duration;
 +
 +    /**
 +     * Max chunk size in bytes
 +     * Note, not all formats support this and unpredictable things may happen if it is used when not supported.
 +     * - encoding: Set by user via AVOptions (NO direct access)
 +     * - decoding: unused
 +     */
 +    int max_chunk_size;
 +
 +    /**
 +     * forces the use of wallclock timestamps as pts/dts of packets
 +     * This has undefined results in the presence of B frames.
 +     * - encoding: unused
 +     * - decoding: Set by user via AVOptions (NO direct access)
 +     */
 +    int use_wallclock_as_timestamps;
 +
 +    /**
 +     * avio flags, used to force AVIO_FLAG_DIRECT.
 +     * - encoding: unused
 +     * - decoding: Set by user via AVOptions (NO direct access)
 +     */
 +    int avio_flags;
 +
 +    /**
 +     * The duration field can be estimated through various ways, and this field can be used
 +     * to know how the duration was estimated.
 +     * - encoding: unused
 +     * - decoding: Read by user via AVOptions (NO direct access)
 +     */
 +    enum AVDurationEstimationMethod duration_estimation_method;
 +
 +    /**
 +     * Skip initial bytes when opening stream
 +     * - encoding: unused
 +     * - decoding: Set by user via AVOptions (NO direct access)
 +     */
 +    int64_t skip_initial_bytes;
 +
 +    /**
 +     * Correct single timestamp overflows
 +     * - encoding: unused
 +     * - decoding: Set by user via AVOptions (NO direct access)
 +     */
 +    unsigned int correct_ts_overflow;
 +
 +    /**
 +     * Force seeking to any (also non key) frames.
 +     * - encoding: unused
 +     * - decoding: Set by user via AVOptions (NO direct access)
 +     */
 +    int seek2any;
 +
 +    /**
 +     * Flush the I/O context after each packet.
 +     * - encoding: Set by user via AVOptions (NO direct access)
 +     * - decoding: unused
 +     */
 +    int flush_packets;
 +
 +    /**
 +     * format probing score.
 +     * The maximal score is AVPROBE_SCORE_MAX, its set when the demuxer probes
 +     * the format.
 +     * - encoding: unused
 +     * - decoding: set by avformat, read by user via av_format_get_probe_score() (NO direct access)
 +     */
 +    int probe_score;
 +
 +    /**
 +     * number of bytes to read maximally to identify format.
 +     * - encoding: unused
 +     * - decoding: set by user through AVOPtions (NO direct access)
 +     */
 +    int format_probesize;
 +
 +    /**
 +     * ',' separated list of allowed decoders.
 +     * If NULL then all are allowed
 +     * - encoding: unused
 +     * - decoding: set by user through AVOptions (NO direct access)
 +     */
 +    char *codec_whitelist;
 +
 +    /**
 +     * ',' separated list of allowed demuxers.
 +     * If NULL then all are allowed
 +     * - encoding: unused
 +     * - decoding: set by user through AVOptions (NO direct access)
 +     */
 +    char *format_whitelist;
 +
      /**
       * An opaque field for libavformat internal usage.
       * Must not be accessed in any way by callers.
      AVFormatInternal *internal;
  
      /**
 -     * Arbitrary user data set by the caller.
 +     * IO repositioned flag.
 +     * This is set by avformat when the underlaying IO context read pointer
 +     * is repositioned, for example when doing byte based seeking.
 +     * Demuxers can use the flag to detect such changes.
 +     */
 +    int io_repositioned;
 +
 +    /**
 +     * Forced video codec.
 +     * This allows forcing a specific decoder, even when there are multiple with
 +     * the same codec_id.
 +     * Demuxing: Set by user via av_format_set_video_codec (NO direct access).
 +     */
 +    AVCodec *video_codec;
 +
 +    /**
 +     * Forced audio codec.
 +     * This allows forcing a specific decoder, even when there are multiple with
 +     * the same codec_id.
 +     * Demuxing: Set by user via av_format_set_audio_codec (NO direct access).
 +     */
 +    AVCodec *audio_codec;
 +
 +    /**
 +     * Forced subtitle codec.
 +     * This allows forcing a specific decoder, even when there are multiple with
 +     * the same codec_id.
 +     * Demuxing: Set by user via av_format_set_subtitle_codec (NO direct access).
 +     */
 +    AVCodec *subtitle_codec;
 +
 +    /**
 +     * Forced data codec.
 +     * This allows forcing a specific decoder, even when there are multiple with
 +     * the same codec_id.
 +     * Demuxing: Set by user via av_format_set_data_codec (NO direct access).
 +     */
 +    AVCodec *data_codec;
 +
 +    /**
 +     * Number of bytes to be written as padding in a metadata header.
 +     * Demuxing: Unused.
 +     * Muxing: Set by user via av_format_set_metadata_header_padding.
 +     */
 +    int metadata_header_padding;
 +
 +    /**
 +     * User data.
 +     * This is a place for some private data of the user.
       */
      void *opaque;
  
      /**
 +     * Callback used by devices to communicate with application.
 +     */
 +    av_format_control_message control_message_cb;
 +
 +    /**
 +     * Output timestamp offset, in microseconds.
 +     * Muxing: set by user via AVOptions (NO direct access)
 +     */
 +    int64_t output_ts_offset;
 +
 +    /**
 +     * dump format separator.
 +     * can be ", " or "\n      " or anything else
 +     * Code outside libavformat should access this field using AVOptions
 +     * (NO direct access).
 +     * - muxing: Set by user.
 +     * - demuxing: Set by user.
 +     */
 +    uint8_t *dump_separator;
 +
 +    /**
 +     * Forced Data codec_id.
 +     * Demuxing: Set by user.
 +     */
 +    enum AVCodecID data_codec_id;
 +
 +#if FF_API_OLD_OPEN_CALLBACKS
 +    /**
 +     * Called to open further IO contexts when needed for demuxing.
 +     *
 +     * This can be set by the user application to perform security checks on
 +     * the URLs before opening them.
 +     * The function should behave like avio_open2(), AVFormatContext is provided
 +     * as contextual information and to reach AVFormatContext.opaque.
 +     *
 +     * If NULL then some simple checks are used together with avio_open2().
 +     *
 +     * Must not be accessed directly from outside avformat.
 +     * @See av_format_set_open_cb()
 +     *
 +     * Demuxing: Set by user.
 +     *
 +     * @deprecated Use io_open and io_close.
 +     */
 +    attribute_deprecated
 +    int (*open_cb)(struct AVFormatContext *s, AVIOContext **p, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options);
 +#endif
 +
 +    /**
 +     * ',' separated list of allowed protocols.
 +     * - encoding: unused
 +     * - decoding: set by user through AVOptions (NO direct access)
 +     */
 +    char *protocol_whitelist;
 +
 +    /*
       * A callback for opening new IO streams.
       *
       * Whenever a muxer or a demuxer needs to open an IO stream (typically from
      void (*io_close)(struct AVFormatContext *s, AVIOContext *pb);
  
      /**
 -     * A comma-separated list of protocol names that will not be used internally
 -     * by libavformat. If this field is a non-empty string, then protocols
 -     * listed here will be forbidden.
 -     *
 -     * This field should be set using AVOptions.
 +     * ',' separated list of disallowed protocols.
 +     * - encoding: unused
 +     * - decoding: set by user through AVOptions (NO direct access)
       */
      char *protocol_blacklist;
 -
 -    /**
 -     * A comma-separated list of protocol names that can be used internally by
 -     * libavformat. If this field is a non-empty string, all protocols not
 -     * listed here will be forbidden.
 -     *
 -     * This field should be set using AVOptions.
 -     */
 -    char *protocol_whitelist;
  } AVFormatContext;
  
 +int av_format_get_probe_score(const AVFormatContext *s);
 +AVCodec * av_format_get_video_codec(const AVFormatContext *s);
 +void      av_format_set_video_codec(AVFormatContext *s, AVCodec *c);
 +AVCodec * av_format_get_audio_codec(const AVFormatContext *s);
 +void      av_format_set_audio_codec(AVFormatContext *s, AVCodec *c);
 +AVCodec * av_format_get_subtitle_codec(const AVFormatContext *s);
 +void      av_format_set_subtitle_codec(AVFormatContext *s, AVCodec *c);
 +AVCodec * av_format_get_data_codec(const AVFormatContext *s);
 +void      av_format_set_data_codec(AVFormatContext *s, AVCodec *c);
 +int       av_format_get_metadata_header_padding(const AVFormatContext *s);
 +void      av_format_set_metadata_header_padding(AVFormatContext *s, int c);
 +void *    av_format_get_opaque(const AVFormatContext *s);
 +void      av_format_set_opaque(AVFormatContext *s, void *opaque);
 +av_format_control_message av_format_get_control_message_cb(const AVFormatContext *s);
 +void      av_format_set_control_message_cb(AVFormatContext *s, av_format_control_message callback);
 +#if FF_API_OLD_OPEN_CALLBACKS
 +attribute_deprecated AVOpenCallback av_format_get_open_cb(const AVFormatContext *s);
 +attribute_deprecated void av_format_set_open_cb(AVFormatContext *s, AVOpenCallback callback);
 +#endif
 +
 +/**
 + * This function will cause global side data to be injected in the next packet
 + * of each stream as well as after any subsequent seek.
 + */
 +void av_format_inject_global_side_data(AVFormatContext *s);
 +
 +/**
 + * Returns the method used to set ctx->duration.
 + *
 + * @return AVFMT_DURATION_FROM_PTS, AVFMT_DURATION_FROM_STREAM, or AVFMT_DURATION_FROM_BITRATE.
 + */
 +enum AVDurationEstimationMethod av_fmt_ctx_get_duration_estimation_method(const AVFormatContext* ctx);
 +
  typedef struct AVPacketList {
      AVPacket pkt;
      struct AVPacketList *next;
@@@ -1956,6 -1324,7 +1956,6 @@@ const char *avformat_license(void)
   *
   * @see av_register_input_format()
   * @see av_register_output_format()
 - * @see av_register_protocol()
   */
  void av_register_all(void);
  
@@@ -2021,9 -1390,6 +2021,9 @@@ const AVClass *avformat_get_class(void)
   *
   * When muxing, should be called by the user before avformat_write_header().
   *
 + * User is required to call avcodec_close() and avformat_free_context() to
 + * clean up the allocation by avformat_new_stream().
 + *
   * @param s media file handle
   * @param c If non-NULL, the AVCodecContext corresponding to the new stream
   * will be initialized to use this codec. This is needed for e.g. codec-specific
@@@ -2061,25 -1427,6 +2061,25 @@@ AVProgram *av_new_program(AVFormatConte
   */
  
  
 +/**
 + * Allocate an AVFormatContext for an output format.
 + * avformat_free_context() can be used to free the context and
 + * everything allocated by the framework within it.
 + *
 + * @param *ctx is set to the created format context, or to NULL in
 + * case of failure
 + * @param oformat format to use for allocating the context, if NULL
 + * format_name and filename are used instead
 + * @param format_name the name of output format to use for allocating the
 + * context, if NULL filename is used instead
 + * @param filename the name of the filename to use for allocating the
 + * context, may be NULL
 + * @return >= 0 in case of success, a negative AVERROR code in case of
 + * failure
 + */
 +int avformat_alloc_output_context2(AVFormatContext **ctx, AVOutputFormat *oformat,
 +                                   const char *format_name, const char *filename);
 +
  /**
   * @addtogroup lavf_decoding
   * @{
@@@ -2113,15 -1460,6 +2113,15 @@@ AVInputFormat *av_probe_input_format(AV
   */
  AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max);
  
 +/**
 + * Guess the file format.
 + *
 + * @param is_opened Whether the file is already opened; determines whether
 + *                  demuxers with or without AVFMT_NOFILE are probed.
 + * @param score_ret The score of the best detection.
 + */
 +AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret);
 +
  /**
   * Probe a bytestream to determine the input format. Each time a probe returns
   * with a score that is too low, the probe buffer size is increased and another
   *
   * @param pb the bytestream to probe
   * @param fmt the input format is put here
 - * @param filename the filename of the stream
 + * @param url the url of the stream
   * @param logctx the log context
   * @param offset the offset within the bytestream to probe from
   * @param max_probe_size the maximum probe buffer size (zero for default)
 - * @return 0 in case of success, a negative value corresponding to an
 + * @return the score in case of success, a negative value corresponding to an
 + *         the maximal score is AVPROBE_SCORE_MAX
   * AVERROR code otherwise
   */
 +int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt,
 +                           const char *url, void *logctx,
 +                           unsigned int offset, unsigned int max_probe_size);
 +
 +/**
 + * Like av_probe_input_buffer2() but returns 0 on success
 + */
  int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
 -                          const char *filename, void *logctx,
 +                          const char *url, void *logctx,
                            unsigned int offset, unsigned int max_probe_size);
  
  /**
   *           May be a pointer to NULL, in which case an AVFormatContext is allocated by this
   *           function and written into ps.
   *           Note that a user-supplied AVFormatContext will be freed on failure.
 - * @param filename Name of the stream to open.
 + * @param url URL of the stream to open.
   * @param fmt If non-NULL, this parameter forces a specific input format.
   *            Otherwise the format is autodetected.
   * @param options  A dictionary filled with AVFormatContext and demuxer-private options.
   *
   * @note If you want to use custom IO, preallocate the format context and set its pb field.
   */
 -int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options);
 +int avformat_open_input(AVFormatContext **ps, const char *url, AVInputFormat *fmt, AVDictionary **options);
 +
 +attribute_deprecated
 +int av_demuxer_open(AVFormatContext *ic);
  
  /**
   * Read packets of a media file to get stream information. This
   */
  int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options);
  
 +/**
 + * Find the programs which belong to a given stream.
 + *
 + * @param ic    media file handle
 + * @param last  the last found program, the search will start after this
 + *              program, or from the beginning if it is NULL
 + * @param s     stream index
 + * @return the next program which belongs to s, NULL if no program is found or
 + *         the last program is not among the programs of ic.
 + */
 +AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s);
 +
 +void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx);
 +
  /**
   * Find the "best" stream in the file.
   * The best stream is determined according to various heuristics as the most
@@@ -2297,7 -1610,6 +2297,7 @@@ int av_seek_frame(AVFormatContext *s, i
   * or if stream_index is -1, in AV_TIME_BASE units.
   * If flags contain AVSEEK_FLAG_ANY, then non-keyframes are treated as
   * keyframes (this may not be supported by all demuxers).
 + * If flags contain AVSEEK_FLAG_BACKWARD, it is ignored.
   *
   * @param s media file handle
   * @param stream_index index of the stream which is used as time base reference
   */
  int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags);
  
 +/**
 + * Discard all internally buffered data. This can be useful when dealing with
 + * discontinuities in the byte stream. Generally works only with formats that
 + * can resync. This includes headerless formats like MPEG-TS/TS but should also
 + * work with NUT, Ogg and in a limited way AVI for example.
 + *
 + * The set of streams, the detected duration, stream parameters and codecs do
 + * not change when calling this function. If you want a complete reset, it's
 + * better to open a new AVFormatContext.
 + *
 + * This does not flush the AVIOContext (s->pb). If necessary, call
 + * avio_flush(s->pb) before calling this function.
 + *
 + * @param s media file handle
 + * @return >=0 on success, error code otherwise
 + */
 +int avformat_flush(AVFormatContext *s);
 +
  /**
   * Start playing a network-based stream (e.g. RTSP stream) at the
   * current position.
@@@ -2377,7 -1671,6 +2377,7 @@@ void avformat_close_input(AVFormatConte
   *
   * @see av_opt_find, av_dict_set, avio_open, av_oformat_next.
   */
 +av_warn_unused_result
  int avformat_write_header(AVFormatContext *s, AVDictionary **options);
  
  /**
@@@ -2427,6 -1720,10 +2427,10 @@@ int av_write_frame(AVFormatContext *s, 
   * increasing dts. Callers doing their own interleaving should call
   * av_write_frame() instead of this function.
   *
+  * Using this function instead of av_write_frame() can give muxers advance
+  * knowledge of future packets, improving e.g. the behaviour of the mp4
+  * muxer for VFR content in fragmenting mode.
+  *
   * @param s media file handle
   * @param pkt The packet containing the data to be written.
   *            <br>
   */
  int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt);
  
 +/**
 + * Write an uncoded frame to an output media file.
 + *
 + * The frame must be correctly interleaved according to the container
 + * specification; if not, then av_interleaved_write_frame() must be used.
 + *
 + * See av_interleaved_write_frame() for details.
 + */
 +int av_write_uncoded_frame(AVFormatContext *s, int stream_index,
 +                           AVFrame *frame);
 +
 +/**
 + * Write an uncoded frame to an output media file.
 + *
 + * If the muxer supports it, this function makes it possible to write an AVFrame
 + * structure directly, without encoding it into a packet.
 + * It is mostly useful for devices and similar special muxers that use raw
 + * video or PCM data and will not serialize it into a byte stream.
 + *
 + * To test whether it is possible to use it with a given muxer and stream,
 + * use av_write_uncoded_frame_query().
 + *
 + * The caller gives up ownership of the frame and must not access it
 + * afterwards.
 + *
 + * @return  >=0 for success, a negative code on error
 + */
 +int av_interleaved_write_uncoded_frame(AVFormatContext *s, int stream_index,
 +                                       AVFrame *frame);
 +
 +/**
 + * Test whether a muxer supports uncoded frame.
 + *
 + * @return  >=0 if an uncoded frame can be written to that muxer and stream,
 + *          <0 if not
 + */
 +int av_write_uncoded_frame_query(AVFormatContext *s, int stream_index);
 +
  /**
   * Write the stream trailer to an output media file and free the
   * file private data.
@@@ -2532,25 -1791,6 +2536,25 @@@ enum AVCodecID av_guess_codec(AVOutputF
                              const char *filename, const char *mime_type,
                              enum AVMediaType type);
  
 +/**
 + * Get timing information for the data currently output.
 + * The exact meaning of "currently output" depends on the format.
 + * It is mostly relevant for devices that have an internal buffer and/or
 + * work in real time.
 + * @param s          media file handle
 + * @param stream     stream in the media file
 + * @param[out] dts   DTS of the last packet output for the stream, in stream
 + *                   time_base units
 + * @param[out] wall  absolute time when that packet whas output,
 + *                   in microsecond
 + * @return  0 if OK, AVERROR(ENOSYS) if the format does not support it
 + * Note: some formats or devices may not allow to measure dts and wall
 + * atomically.
 + */
 +int av_get_output_timestamp(struct AVFormatContext *s, int stream,
 +                            int64_t *dts, int64_t *wall);
 +
 +
  /**
   * @}
   */
@@@ -2598,7 -1838,7 +2602,7 @@@ void av_hex_dump_log(void *avcl, int le
   * @param dump_payload True if the payload must be displayed, too.
   * @param st AVStream that the packet belongs to
   */
 -void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st);
 +void av_pkt_dump2(FILE *f, const AVPacket *pkt, int dump_payload, const AVStream *st);
  
  
  /**
   * @param dump_payload True if the payload must be displayed, too.
   * @param st AVStream that the packet belongs to
   */
 -void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
 -                      AVStream *st);
 +void av_pkt_dump_log2(void *avcl, int level, const AVPacket *pkt, int dump_payload,
 +                      const AVStream *st);
  
  /**
   * Get the AVCodecID for the given codec tag tag.
@@@ -2635,18 -1875,6 +2639,18 @@@ enum AVCodecID av_codec_get_id(const st
   */
  unsigned int av_codec_get_tag(const struct AVCodecTag * const *tags, enum AVCodecID id);
  
 +/**
 + * Get the codec tag for the given codec id.
 + *
 + * @param tags list of supported codec_id - codec_tag pairs, as stored
 + * in AVInputFormat.codec_tag and AVOutputFormat.codec_tag
 + * @param id codec id that should be searched for in the list
 + * @param tag A pointer to the found tag
 + * @return 0 if id was not found in tags, > 0 if it was found
 + */
 +int av_codec_get_tag2(const struct AVCodecTag * const *tags, enum AVCodecID id,
 +                      unsigned int *tag);
 +
  int av_find_default_stream_index(AVFormatContext *s);
  
  /**
@@@ -2705,9 -1933,9 +2709,9 @@@ void av_url_split(char *proto,         
   * codec and time base.
   *
   * @param ic        the context to analyze
 - * @param index     the index to print, if you have multiple inputs or outputs
 + * @param index     index of the stream to dump information about
   * @param url       the URL to print, such as source or destination file
 - * @param is_output whether the context is input or output
 + * @param is_output Select whether the specified context is an input(0) or output(1)
   */
  void av_dump_format(AVFormatContext *ic,
                      int index,
@@@ -2798,80 -2026,10 +2802,80 @@@ const struct AVCodecTag *avformat_get_r
   * @return the table mapping RIFF FourCCs for audio to AVCodecID.
   */
  const struct AVCodecTag *avformat_get_riff_audio_tags(void);
 +/**
 + * @return the table mapping MOV FourCCs for video to libavcodec AVCodecID.
 + */
 +const struct AVCodecTag *avformat_get_mov_video_tags(void);
 +/**
 + * @return the table mapping MOV FourCCs for audio to AVCodecID.
 + */
 +const struct AVCodecTag *avformat_get_mov_audio_tags(void);
 +
  /**
   * @}
   */
  
 +/**
 + * Guess the sample aspect ratio of a frame, based on both the stream and the
 + * frame aspect ratio.
 + *
 + * Since the frame aspect ratio is set by the codec but the stream aspect ratio
 + * is set by the demuxer, these two may not be equal. This function tries to
 + * return the value that you should use if you would like to display the frame.
 + *
 + * Basic logic is to use the stream aspect ratio if it is set to something sane
 + * otherwise use the frame aspect ratio. This way a container setting, which is
 + * usually easy to modify can override the coded value in the frames.
 + *
 + * @param format the format context which the stream is part of
 + * @param stream the stream which the frame is part of
 + * @param frame the frame with the aspect ratio to be determined
 + * @return the guessed (valid) sample_aspect_ratio, 0/1 if no idea
 + */
 +AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame);
 +
 +/**
 + * Guess the frame rate, based on both the container and codec information.
 + *
 + * @param ctx the format context which the stream is part of
 + * @param stream the stream which the frame is part of
 + * @param frame the frame for which the frame rate should be determined, may be NULL
 + * @return the guessed (valid) frame rate, 0/1 if no idea
 + */
 +AVRational av_guess_frame_rate(AVFormatContext *ctx, AVStream *stream, AVFrame *frame);
 +
 +/**
 + * Check if the stream st contained in s is matched by the stream specifier
 + * spec.
 + *
 + * See the "stream specifiers" chapter in the documentation for the syntax
 + * of spec.
 + *
 + * @return  >0 if st is matched by spec;
 + *          0  if st is not matched by spec;
 + *          AVERROR code if spec is invalid
 + *
 + * @note  A stream specifier can match several streams in the format.
 + */
 +int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
 +                                    const char *spec);
 +
 +int avformat_queue_attached_pictures(AVFormatContext *s);
 +
 +/**
 + * Apply a list of bitstream filters to a packet.
 + *
 + * @param codec AVCodecContext, usually from an AVStream
 + * @param pkt the packet to apply filters to. If, on success, the returned
 + *        packet has size == 0 and side_data_elems == 0, it indicates that
 + *        the packet should be dropped
 + * @param bsfc a NULL-terminated list of filters to apply
 + * @return  >=0 on success;
 + *          AVERROR code on failure
 + */
 +int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
 +                               AVBitStreamFilterContext *bsfc);
 +
  /**
   * @}
   */
diff --combined libavformat/internal.h
index 99015271b6afc83b452ab4bd81f14037b8e5a7fd,bbdfd2f719c23c85b4feaeec66a0cb5696a6c99a..6b7f677950136499e8608806d41dc6cbe66b320c
@@@ -1,20 -1,20 +1,20 @@@
  /*
   * copyright (c) 2001 Fabrice Bellard
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  #define AVFORMAT_INTERNAL_H
  
  #include <stdint.h>
 +
 +#include "libavutil/bprint.h"
  #include "avformat.h"
  #include "os_support.h"
  
  #define MAX_URL_SIZE 4096
  
 +/** size of probe buffer, for guessing file type from file contents */
 +#define PROBE_BUF_MIN 2048
 +#define PROBE_BUF_MAX (1 << 20)
 +
 +#define MAX_PROBE_PACKETS 2500
 +
  #ifdef DEBUG
  #    define hex_dump_debug(class, buf, size) av_hex_dump_log(class, AV_LOG_DEBUG, buf, size)
  #else
 -#    define hex_dump_debug(class, buf, size)
 +#    define hex_dump_debug(class, buf, size) do { if (0) av_hex_dump_log(class, AV_LOG_DEBUG, buf, size); } while(0)
  #endif
  
  typedef struct AVCodecTag {
@@@ -51,18 -43,6 +51,18 @@@ typedef struct CodecMime
      enum AVCodecID id;
  } CodecMime;
  
 +/*************************************************/
 +/* fractional numbers for exact pts handling */
 +
 +/**
 + * The exact value of the fractional number is: 'val + num / den'.
 + * num is assumed to be 0 <= num < den.
 + */
 +typedef struct FFFrac {
 +    int64_t val, num, den;
 +} FFFrac;
 +
 +
  struct AVFormatInternal {
      /**
       * Number of streams relevant for interleaving.
      /**
       * Offset to remap timestamps to be non-negative.
       * Expressed in timebase units.
 +     * @see AVStream.mux_ts_offset
       */
      int64_t offset;
  
  #if FF_API_COMPUTE_PKT_FIELDS2
      int missing_ts_warning;
  #endif
 +
 +    int inject_global_side_data;
 +
 +    int avoid_negative_ts_use_pts;
 +
 +    /**
 +     * Whether or not a header has already been written
 +     */
 +    int header_written;
 +    int write_header_ret;
  };
  
  struct AVStreamInternal {
       * from dts.
       */
      int reorder;
 +
 +    /**
 +     * bitstream filter to run on stream
 +     * - encoding: Set by muxer using ff_stream_add_bitstream_filter
 +     * - decoding: unused
 +     */
 +    AVBitStreamFilterContext *bsfc;
 +
 +    /**
 +     * Whether or not check_bitstream should still be run on each packet
 +     */
 +    int bitstream_checked;
 +
      /**
       * The codec context used by avformat_find_stream_info, the parser, etc.
       */
  
      enum AVCodecID orig_codec_id;
  
 -#if FF_API_LAVF_AVCTX
 -    // whether the deprecated stream codec context needs
 -    // to be filled from the codec parameters
 -    int need_codec_update;
 -#endif
 +    /**
 +     * Whether the internal avctx needs to be updated from codecpar (after a late change to codecpar)
 +     */
 +    int need_context_update;
  };
  
 -void ff_dynarray_add(intptr_t **tab_ptr, int *nb_ptr, intptr_t elem);
 -
  #ifdef __GNUC__
  #define dynarray_add(tab, nb_ptr, elem)\
  do {\
      __typeof__(tab) _tab = (tab);\
      __typeof__(elem) _elem = (elem);\
      (void)sizeof(**_tab == _elem); /* check that types are compatible */\
 -    ff_dynarray_add((intptr_t **)_tab, nb_ptr, (intptr_t)_elem);\
 +    av_dynarray_add(_tab, nb_ptr, _elem);\
  } while(0)
  #else
  #define dynarray_add(tab, nb_ptr, elem)\
  do {\
 -    ff_dynarray_add((intptr_t **)(tab), nb_ptr, (intptr_t)(elem));\
 +    av_dynarray_add((tab), nb_ptr, (elem));\
  } while(0)
  #endif
  
@@@ -192,10 -151,11 +192,10 @@@ char *ff_data_to_hex(char *buf, const u
   */
  int ff_hex_to_data(uint8_t *data, const char *p);
  
 -void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx);
 -
  /**
   * Add packet to AVFormatContext->packet_buffer list, determining its
   * interleaved position using compare() function argument.
 + * @return 0, or < 0 on error
   */
  int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *));
@@@ -239,11 -199,10 +239,11 @@@ void ff_sdp_write_media(char *buff, in
   * @param dst_stream the stream index within dst to write the packet to
   * @param pkt the packet to be written
   * @param src the muxer the packet originally was intended for
 + * @param interleave 0->use av_write_frame, 1->av_interleaved_write_frame
   * @return the value av_write_frame returned
   */
  int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
 -                     AVFormatContext *src);
 +                     AVFormatContext *src, int interleave);
  
  /**
   * Get the length in bytes which is needed to store val as v.
@@@ -314,8 -273,6 +314,8 @@@ int ff_add_index_entry(AVIndexEntry **i
                         unsigned int *index_entries_allocated_size,
                         int64_t pos, int64_t timestamp, int size, int distance, int flags);
  
 +void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance);
 +
  /**
   * Add a new chapter.
   *
@@@ -339,6 -296,11 +339,6 @@@ void ff_reduce_index(AVFormatContext *s
  
  enum AVCodecID ff_guess_image2_codec(const char *filename);
  
 -/**
 - * Convert a date string in ISO8601 format to Unix timestamp.
 - */
 -int64_t ff_iso8601_to_unix_time(const char *datestr);
 -
  /**
   * Perform a binary search using av_index_search_timestamp() and
   * AVInputFormat.read_timestamp().
@@@ -359,9 -321,6 +359,9 @@@ int ff_seek_frame_binary(AVFormatContex
   */
  void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp);
  
 +int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
 +                    int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ));
 +
  /**
   * Perform a binary search using read_timestamp().
   *
@@@ -431,8 -390,6 +431,8 @@@ int ff_read_packet(AVFormatContext *s, 
  int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out,
                                   AVPacket *pkt, int flush);
  
 +void ff_free_stream(AVFormatContext *s, AVStream *st);
 +
  /**
   * Return the frame duration in seconds. Return 0 if not available.
   */
@@@ -458,37 -415,12 +458,37 @@@ enum AVCodecID ff_codec_get_id(const AV
   */
  enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags);
  
 +/**
 + * Chooses a timebase for muxing the specified stream.
 + *
 + * The chosen timebase allows sample accurate timestamps based
 + * on the framerate or sample rate for audio streams. It also is
 + * at least as precise as 1/min_precision would be.
 + */
 +AVRational ff_choose_timebase(AVFormatContext *s, AVStream *st, int min_precision);
 +
 +/**
 + * Chooses a timebase for muxing the specified stream.
 + */
 +enum AVChromaLocation ff_choose_chroma_location(AVFormatContext *s, AVStream *st);
 +
  /**
   * Generate standard extradata for AVC-Intra based on width/height and field
   * order.
   */
  int ff_generate_avci_extradata(AVStream *st);
  
 +/**
 + * Add a bitstream filter to a stream.
 + *
 + * @param st output stream to add a filter to
 + * @param name the name of the filter to add
 + * @param args filter-specific argument string
 + * @return  >0 on success;
 + *          AVERROR code on failure
 + */
 +int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args);
 +
  /**
   * Wrap errno on rename() error.
   *
   * @param newpath destination path
   * @return        0 or AVERROR on failure
   */
 -static inline int ff_rename(const char *oldpath, const char *newpath)
 +static inline int ff_rename(const char *oldpath, const char *newpath, void *logctx)
  {
 -    if (rename(oldpath, newpath) == -1)
 -        return AVERROR(errno);
 -    return 0;
 +    int ret = 0;
 +    if (rename(oldpath, newpath) == -1) {
 +        ret = AVERROR(errno);
 +        if (logctx)
 +            av_log(logctx, AV_LOG_ERROR, "failed to rename file %s to %s\n", oldpath, newpath);
 +    }
 +    return ret;
  }
  
  /**
 + * Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end
 + * which is always set to 0.
 + *
 + * @param size size of extradata
 + * @return 0 if OK, AVERROR_xxx on error
 + */
 +int ff_alloc_extradata(AVCodecParameters *par, int size);
 +
 +/**
 + * Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end
 + * which is always set to 0 and fill it from pb.
 + *
 + * @param size size of extradata
 + * @return >= 0 if OK, AVERROR_xxx on error
 + */
 +int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size);
 +
 +/**
 + * add frame for rfps calculation.
 + *
 + * @param dts timestamp of the i-th frame
 + * @return 0 if OK, AVERROR_xxx on error
 + */
 +int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t dts);
 +
 +void ff_rfps_calculate(AVFormatContext *ic);
 +
 +/**
 + * Flags for AVFormatContext.write_uncoded_frame()
 + */
 +enum AVWriteUncodedFrameFlags {
 +
 +    /**
 +     * Query whether the feature is possible on this stream.
 +     * The frame argument is ignored.
 +     */
 +    AV_WRITE_UNCODED_FRAME_QUERY           = 0x0001,
 +
 +};
 +
 +/**
 + * Copies the whilelists from one context to the other
 + */
 +int ff_copy_whiteblacklists(AVFormatContext *dst, AVFormatContext *src);
 +
 +int ffio_open2_wrapper(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags,
 +                       const AVIOInterruptCB *int_cb, AVDictionary **options);
 +
 +/**
 + * Returned by demuxers to indicate that data was consumed but discarded
 + * (ignored streams or junk data). The framework will re-call the demuxer.
 + */
 +#define FFERROR_REDO FFERRTAG('R','E','D','O')
 +
 +/*
   * A wrapper around AVFormatContext.io_close that should be used
   * instead of calling the pointer directly.
   */
  void ff_format_io_close(AVFormatContext *s, AVIOContext **pb);
  
 +/**
 + * Parse creation_time in AVFormatContext metadata if exists and warn if the
 + * parsing fails.
 + *
 + * @param s AVFormatContext
 + * @param timestamp parsed timestamp in microseconds, only set on successful parsing
 + * @param return_seconds set this to get the number of seconds in timestamp instead of microseconds
 + * @return 1 if OK, 0 if the metadata was not present, AVERROR(EINVAL) on parse error
 + */
 +int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds);
 +
 +/**
 + * Standardize creation_time metadata in AVFormatContext to an ISO-8601
 + * timestamp string.
 + *
 + * @param s AVFormatContext
 + * @return <0 on error
 + */
 +int ff_standardize_creation_time(AVFormatContext *s);
 +
 +#define CONTAINS_PAL 2
 +/**
 + * Reshuffles the lines to use the user specified stride.
 + *
 + * @param ppkt input and output packet
 + * @return negative error code or
 + *         0 if no new packet was allocated
 + *         non-zero if a new packet was allocated and ppkt has to be freed
 + *         CONTAINS_PAL if in addition to a new packet the old contained a palette
 + */
 +int ff_reshuffle_raw_rgb(AVFormatContext *s, AVPacket **ppkt, AVCodecParameters *par, int expected_stride);
 +
 +/**
 + * Retrieves the palette from a packet, either from side data, or
 + * appended to the video data in the packet itself (raw video only).
 + * It is commonly used after a call to ff_reshuffle_raw_rgb().
 + *
 + * Use 0 for the ret parameter to check for side data only.
 + *
 + * @param pkt pointer to packet before calling ff_reshuffle_raw_rgb()
 + * @param ret return value from ff_reshuffle_raw_rgb(), or 0
 + * @param palette pointer to palette buffer
 + * @return negative error code or
 + *         1 if the packet has a palette, else 0
 + */
 +int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette);
 +
 +/**
 + * Finalize buf into extradata and set its size appropriately.
 + */
 +int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf);
 +
+ /**
+  * Find the next packet in the interleaving queue for the given stream.
+  * The packet is not removed from the interleaving queue, but only
+  * a pointer to it is returned.
+  *
+  * @return a pointer to the next packet, or NULL if no packet is queued
+  *         for this stream.
+  */
+ const AVPacket *ff_interleaved_peek(AVFormatContext *s, int stream);
  #endif /* AVFORMAT_INTERNAL_H */
diff --combined libavformat/movenc.c
index 4e5f65f24b088384b5a3ff1b1b4996c06999b550,ae754e13e3e3008da27df433d3a9c7dab6b499e7..0a7983658ebb007990130a73807c12d4f4a2562d
@@@ -4,20 -4,20 +4,20 @@@
   * Copyright (c) 2004 Gildas Bazin <gbazin at videolan dot org>
   * Copyright (c) 2009 Baptiste Coudurier <baptiste dot coudurier at gmail dot com>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  #include "avio.h"
  #include "isom.h"
  #include "avc.h"
 +#include "libavcodec/ac3_parser.h"
  #include "libavcodec/get_bits.h"
  #include "libavcodec/put_bits.h"
  #include "libavcodec/vc1_common.h"
 +#include "libavcodec/raw.h"
  #include "internal.h"
  #include "libavutil/avstring.h"
  #include "libavutil/intfloat.h"
  #include "libavutil/mathematics.h"
 +#include "libavutil/libm.h"
  #include "libavutil/opt.h"
  #include "libavutil/dict.h"
 +#include "libavutil/pixdesc.h"
 +#include "libavutil/timecode.h"
 +#include "libavutil/color_utils.h"
  #include "hevc.h"
  #include "rtpenc.h"
  #include "mov_chan.h"
 +#include "vpcc.h"
  
  static const AVOption options[] = {
      { "movflags", "MOV muxer flags", offsetof(MOVMuxContext, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
      { "rtphint", "Add RTP hint tracks", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_RTP_HINT}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
 +    { "moov_size", "maximum moov size so it can be placed at the begin", offsetof(MOVMuxContext, reserved_moov_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, 0 },
      { "empty_moov", "Make the initial moov atom empty", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_EMPTY_MOOV}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
      { "frag_keyframe", "Fragment at video keyframes", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_FRAG_KEYFRAME}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
      { "separate_moof", "Write separate moof/mdat atoms for each track", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_SEPARATE_MOOF}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
      { "frag_discont", "Signal that the next fragment is discontinuous from earlier ones", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_FRAG_DISCONT}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
      { "delay_moov", "Delay writing the initial moov until the first fragment is cut, or until the first fragment flush", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_DELAY_MOOV}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
      { "global_sidx", "Write a global sidx index at the start of the file", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_GLOBAL_SIDX}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
 +    { "write_colr", "Write colr atom (Experimental, may be renamed or changed, do not use from scripts)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_WRITE_COLR}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
 +    { "write_gama", "Write deprecated gama atom", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_WRITE_GAMA}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
      FF_RTP_FLAG_OPTS(MOVMuxContext, rtp_flags),
 -    { "skip_iods", "Skip writing iods atom.", offsetof(MOVMuxContext, iods_skip), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
 +    { "skip_iods", "Skip writing iods atom.", offsetof(MOVMuxContext, iods_skip), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
      { "iods_audio_profile", "iods audio profile atom.", offsetof(MOVMuxContext, iods_audio_profile), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 255, AV_OPT_FLAG_ENCODING_PARAM},
      { "iods_video_profile", "iods video profile atom.", offsetof(MOVMuxContext, iods_video_profile), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 255, AV_OPT_FLAG_ENCODING_PARAM},
      { "frag_duration", "Maximum fragment duration", offsetof(MOVMuxContext, max_fragment_duration), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
      { "min_frag_duration", "Minimum fragment duration", offsetof(MOVMuxContext, min_fragment_duration), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
      { "frag_size", "Maximum fragment size", offsetof(MOVMuxContext, max_fragment_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
      { "ism_lookahead", "Number of lookahead entries for ISM files", offsetof(MOVMuxContext, ism_lookahead), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
 +    { "video_track_timescale", "set timescale of all video tracks", offsetof(MOVMuxContext, video_track_timescale), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
      { "brand",    "Override major brand", offsetof(MOVMuxContext, major_brand),   AV_OPT_TYPE_STRING, {.str = NULL}, .flags = AV_OPT_FLAG_ENCODING_PARAM },
 -    { "use_editlist", "use edit list", offsetof(MOVMuxContext, use_editlist), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, AV_OPT_FLAG_ENCODING_PARAM},
 +    { "use_editlist", "use edit list", offsetof(MOVMuxContext, use_editlist), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, AV_OPT_FLAG_ENCODING_PARAM},
      { "fragment_index", "Fragment number of the next fragment", offsetof(MOVMuxContext, fragments), AV_OPT_TYPE_INT, {.i64 = 1}, 1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
 +    { "mov_gamma", "gamma value for gama atom", offsetof(MOVMuxContext, gamma), AV_OPT_TYPE_FLOAT, {.dbl = 0.0 }, 0.0, 10, AV_OPT_FLAG_ENCODING_PARAM},
      { "frag_interleave", "Interleave samples within fragments (max number of consecutive samples, lower is tighter interleaving, but with more overhead)", offsetof(MOVMuxContext, frag_interleave), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
 +    { "encryption_scheme",    "Configures the encryption scheme, allowed values are none, cenc-aes-ctr", offsetof(MOVMuxContext, encryption_scheme_str),   AV_OPT_TYPE_STRING, {.str = NULL}, .flags = AV_OPT_FLAG_ENCODING_PARAM },
 +    { "encryption_key", "The media encryption key (hex)", offsetof(MOVMuxContext, encryption_key), AV_OPT_TYPE_BINARY, .flags = AV_OPT_FLAG_ENCODING_PARAM },
 +    { "encryption_kid", "The media encryption key identifier (hex)", offsetof(MOVMuxContext, encryption_kid), AV_OPT_TYPE_BINARY, .flags = AV_OPT_FLAG_ENCODING_PARAM },
      { NULL },
  };
  
@@@ -98,8 -83,6 +98,8 @@@ static const AVClass flavor ## _muxer_c
      .version    = LIBAVUTIL_VERSION_INT,\
  };
  
 +static int get_moov_size(AVFormatContext *s);
 +
  static int utf8len(const uint8_t *b)
  {
      int len = 0;
@@@ -136,15 -119,13 +136,15 @@@ static int mov_write_stco_tag(AVIOConte
      int mode64 = co64_required(track); // use 32 bit size variant if possible
      int64_t pos = avio_tell(pb);
      avio_wb32(pb, 0); /* size */
 -    if (mode64) {
 +    if (mode64)
          ffio_wfourcc(pb, "co64");
 -    else
 +    else
          ffio_wfourcc(pb, "stco");
      avio_wb32(pb, 0); /* version & flags */
 -    avio_wb32(pb, track->entry); /* entry count */
 +    avio_wb32(pb, track->chunkCount); /* entry count */
      for (i = 0; i < track->entry; i++) {
 +        if (!track->cluster[i].chunkNum)
 +            continue;
          if (mode64 == 1)
              avio_wb64(pb, track->cluster[i].pos + track->data_offset);
          else
@@@ -200,10 -181,10 +200,10 @@@ static int mov_write_stsc_tag(AVIOConte
      ffio_wfourcc(pb, "stsc");
      avio_wb32(pb, 0); // version & flags
      entryPos = avio_tell(pb);
 -    avio_wb32(pb, track->entry); // entry count
 +    avio_wb32(pb, track->chunkCount); // entry count
      for (i = 0; i < track->entry; i++) {
 -        if (oldval != track->cluster[i].samples_in_chunk) {
 -            avio_wb32(pb, i + 1); // first chunk
 +        if (oldval != track->cluster[i].samples_in_chunk && track->cluster[i].chunkNum) {
 +            avio_wb32(pb, track->cluster[i].chunkNum); // first chunk
              avio_wb32(pb, track->cluster[i].samples_in_chunk); // samples per chunk
              avio_wb32(pb, 0x1); // sample description index
              oldval = track->cluster[i].samples_in_chunk;
@@@ -300,214 -281,6 +300,214 @@@ static int mov_write_ac3_tag(AVIOContex
      return 11;
  }
  
 +struct eac3_info {
 +    AVPacket pkt;
 +    uint8_t ec3_done;
 +    uint8_t num_blocks;
 +
 +    /* Layout of the EC3SpecificBox */
 +    /* maximum bitrate */
 +    uint16_t data_rate;
 +    /* number of independent substreams */
 +    uint8_t  num_ind_sub;
 +    struct {
 +        /* sample rate code (see ff_ac3_sample_rate_tab) 2 bits */
 +        uint8_t fscod;
 +        /* bit stream identification 5 bits */
 +        uint8_t bsid;
 +        /* one bit reserved */
 +        /* audio service mixing (not supported yet) 1 bit */
 +        /* bit stream mode 3 bits */
 +        uint8_t bsmod;
 +        /* audio coding mode 3 bits */
 +        uint8_t acmod;
 +        /* sub woofer on 1 bit */
 +        uint8_t lfeon;
 +        /* 3 bits reserved */
 +        /* number of dependent substreams associated with this substream 4 bits */
 +        uint8_t num_dep_sub;
 +        /* channel locations of the dependent substream(s), if any, 9 bits */
 +        uint16_t chan_loc;
 +        /* if there is no dependent substream, then one bit reserved instead */
 +    } substream[1]; /* TODO: support 8 independent substreams */
 +};
 +
 +#if CONFIG_AC3_PARSER
 +static int handle_eac3(MOVMuxContext *mov, AVPacket *pkt, MOVTrack *track)
 +{
 +    GetBitContext gbc;
 +    AC3HeaderInfo tmp, *hdr = &tmp;
 +    struct eac3_info *info;
 +    int num_blocks;
 +
 +    if (!track->eac3_priv && !(track->eac3_priv = av_mallocz(sizeof(*info))))
 +        return AVERROR(ENOMEM);
 +    info = track->eac3_priv;
 +
 +    init_get_bits(&gbc, pkt->data, pkt->size * 8);
 +    if (avpriv_ac3_parse_header(&gbc, &hdr) < 0) {
 +        /* drop the packets until we see a good one */
 +        if (!track->entry) {
 +            av_log(mov, AV_LOG_WARNING, "Dropping invalid packet from start of the stream\n");
 +            return 0;
 +        }
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    info->data_rate = FFMAX(info->data_rate, hdr->bit_rate / 1000);
 +    num_blocks = hdr->num_blocks;
 +
 +    if (!info->ec3_done) {
 +        /* AC-3 substream must be the first one */
 +        if (hdr->bitstream_id <= 10 && hdr->substreamid != 0)
 +            return AVERROR(EINVAL);
 +
 +        /* this should always be the case, given that our AC-3 parser
 +         * concatenates dependent frames to their independent parent */
 +        if (hdr->frame_type == EAC3_FRAME_TYPE_INDEPENDENT) {
 +            /* substream ids must be incremental */
 +            if (hdr->substreamid > info->num_ind_sub + 1)
 +                return AVERROR(EINVAL);
 +
 +            if (hdr->substreamid == info->num_ind_sub + 1) {
 +                //info->num_ind_sub++;
 +                avpriv_request_sample(track->par, "Multiple independent substreams");
 +                return AVERROR_PATCHWELCOME;
 +            } else if (hdr->substreamid < info->num_ind_sub ||
 +                       hdr->substreamid == 0 && info->substream[0].bsid) {
 +                info->ec3_done = 1;
 +                goto concatenate;
 +            }
 +        }
 +
 +        /* fill the info needed for the "dec3" atom */
 +        info->substream[hdr->substreamid].fscod = hdr->sr_code;
 +        info->substream[hdr->substreamid].bsid  = hdr->bitstream_id;
 +        info->substream[hdr->substreamid].bsmod = hdr->bitstream_mode;
 +        info->substream[hdr->substreamid].acmod = hdr->channel_mode;
 +        info->substream[hdr->substreamid].lfeon = hdr->lfe_on;
 +
 +        /* Parse dependent substream(s), if any */
 +        if (pkt->size != hdr->frame_size) {
 +            int cumul_size = hdr->frame_size;
 +            int parent = hdr->substreamid;
 +
 +            while (cumul_size != pkt->size) {
 +                int i;
 +                init_get_bits(&gbc, pkt->data + cumul_size, (pkt->size - cumul_size) * 8);
 +                if (avpriv_ac3_parse_header(&gbc, &hdr) < 0)
 +                    return AVERROR_INVALIDDATA;
 +                if (hdr->frame_type != EAC3_FRAME_TYPE_DEPENDENT)
 +                    return AVERROR(EINVAL);
 +                cumul_size += hdr->frame_size;
 +                info->substream[parent].num_dep_sub++;
 +
 +                /* header is parsed up to lfeon, but custom channel map may be needed */
 +                /* skip bsid */
 +                skip_bits(&gbc, 5);
 +                /* skip volume control params */
 +                for (i = 0; i < (hdr->channel_mode ? 1 : 2); i++) {
 +                    skip_bits(&gbc, 5); // skip dialog normalization
 +                    if (get_bits1(&gbc)) {
 +                        skip_bits(&gbc, 8); // skip compression gain word
 +                    }
 +                }
 +                /* get the dependent stream channel map, if exists */
 +                if (get_bits1(&gbc))
 +                    info->substream[parent].chan_loc |= (get_bits(&gbc, 16) >> 5) & 0x1f;
 +                else
 +                    info->substream[parent].chan_loc |= hdr->channel_mode;
 +            }
 +        }
 +    }
 +
 +concatenate:
 +    if (!info->num_blocks && num_blocks == 6)
 +        return pkt->size;
 +    else if (info->num_blocks + num_blocks > 6)
 +        return AVERROR_INVALIDDATA;
 +
 +    if (!info->num_blocks) {
 +        int ret;
 +        if ((ret = av_copy_packet(&info->pkt, pkt)) < 0)
 +            return ret;
 +        info->num_blocks = num_blocks;
 +        return 0;
 +    } else {
 +        int ret;
 +        if ((ret = av_grow_packet(&info->pkt, pkt->size)) < 0)
 +            return ret;
 +        memcpy(info->pkt.data + info->pkt.size - pkt->size, pkt->data, pkt->size);
 +        info->num_blocks += num_blocks;
 +        info->pkt.duration += pkt->duration;
 +        if ((ret = av_copy_packet_side_data(&info->pkt, pkt)) < 0)
 +            return ret;
 +        if (info->num_blocks != 6)
 +            return 0;
 +        av_packet_unref(pkt);
 +        if ((ret = av_copy_packet(pkt, &info->pkt)) < 0)
 +            return ret;
 +        av_packet_unref(&info->pkt);
 +        info->num_blocks = 0;
 +    }
 +
 +    return pkt->size;
 +}
 +#endif
 +
 +static int mov_write_eac3_tag(AVIOContext *pb, MOVTrack *track)
 +{
 +    PutBitContext pbc;
 +    uint8_t *buf;
 +    struct eac3_info *info;
 +    int size, i;
 +
 +    if (!track->eac3_priv)
 +        return AVERROR(EINVAL);
 +
 +    info = track->eac3_priv;
 +    size = 2 + 4 * (info->num_ind_sub + 1);
 +    buf = av_malloc(size);
 +    if (!buf) {
 +        size = AVERROR(ENOMEM);
 +        goto end;
 +    }
 +
 +    init_put_bits(&pbc, buf, size);
 +    put_bits(&pbc, 13, info->data_rate);
 +    put_bits(&pbc,  3, info->num_ind_sub);
 +    for (i = 0; i <= info->num_ind_sub; i++) {
 +        put_bits(&pbc, 2, info->substream[i].fscod);
 +        put_bits(&pbc, 5, info->substream[i].bsid);
 +        put_bits(&pbc, 1, 0); /* reserved */
 +        put_bits(&pbc, 1, 0); /* asvc */
 +        put_bits(&pbc, 3, info->substream[i].bsmod);
 +        put_bits(&pbc, 3, info->substream[i].acmod);
 +        put_bits(&pbc, 1, info->substream[i].lfeon);
 +        put_bits(&pbc, 5, 0); /* reserved */
 +        put_bits(&pbc, 4, info->substream[i].num_dep_sub);
 +        if (!info->substream[i].num_dep_sub) {
 +            put_bits(&pbc, 1, 0); /* reserved */
 +            size--;
 +        } else {
 +            put_bits(&pbc, 9, info->substream[i].chan_loc);
 +        }
 +    }
 +    flush_put_bits(&pbc);
 +
 +    avio_wb32(pb, size + 8);
 +    ffio_wfourcc(pb, "dec3");
 +    avio_write(pb, buf, size);
 +
 +    av_free(buf);
 +
 +end:
 +    av_packet_unref(&info->pkt);
 +    av_freep(&track->eac3_priv);
 +
 +    return size;
 +}
 +
  /**
   * This function writes extradata "as is".
   * Extradata must be formatted like a valid atom (with size and tag).
@@@ -518,22 -291,6 +518,22 @@@ static int mov_write_extradata_tag(AVIO
      return track->par->extradata_size;
  }
  
 +static int mov_write_enda_tag(AVIOContext *pb)
 +{
 +    avio_wb32(pb, 10);
 +    ffio_wfourcc(pb, "enda");
 +    avio_wb16(pb, 1); /* little endian */
 +    return 10;
 +}
 +
 +static int mov_write_enda_tag_be(AVIOContext *pb)
 +{
 +  avio_wb32(pb, 10);
 +  ffio_wfourcc(pb, "enda");
 +  avio_wb16(pb, 0); /* big endian */
 +  return 10;
 +}
 +
  static void put_descr(AVIOContext *pb, int tag, unsigned int size)
  {
      int i = 3;
      avio_w8(pb, size & 0x7F);
  }
  
 +static unsigned compute_avg_bitrate(MOVTrack *track)
 +{
 +    uint64_t size = 0;
 +    int i;
 +    if (!track->track_duration)
 +        return 0;
 +    for (i = 0; i < track->entry; i++)
 +        size += track->cluster[i].size;
 +    return size * 8 * track->timescale / track->track_duration;
 +}
 +
  static int mov_write_esds_tag(AVIOContext *pb, MOVTrack *track) // Basic
  {
      AVCPBProperties *props;
      int64_t pos = avio_tell(pb);
      int decoder_specific_info_len = track->vos_len ? 5 + track->vos_len : 0;
 +    unsigned avg_bitrate;
  
      avio_wb32(pb, 0); // size
      ffio_wfourcc(pb, "esds");
  
      avio_wb24(pb, props ? props->buffer_size / 8 : 0); // Buffersize DB
  
 -    avio_wb32(pb, props ? FFMAX(props->max_bitrate, props->avg_bitrate) : track->par->bit_rate); // maxbitrate (FIXME should be max rate in any 1 sec window)
 -    if (!props || !props->min_bitrate || props->max_bitrate != props->min_bitrate)
 -        avio_wb32(pb, 0); // vbr
 -    else
 -        avio_wb32(pb, props->max_bitrate); // avg bitrate
 +    avg_bitrate = compute_avg_bitrate(track);
 +    avio_wb32(pb, props ? FFMAX3(props->max_bitrate, props->avg_bitrate, avg_bitrate) : FFMAX(track->par->bit_rate, avg_bitrate)); // maxbitrate (FIXME should be max rate in any 1 sec window)
 +    avio_wb32(pb, avg_bitrate);
  
      if (track->vos_len) {
          // DecoderSpecific info descriptor
      return update_size(pb, pos);
  }
  
 +static int mov_pcm_le_gt16(enum AVCodecID codec_id)
 +{
 +    return codec_id == AV_CODEC_ID_PCM_S24LE ||
 +           codec_id == AV_CODEC_ID_PCM_S32LE ||
 +           codec_id == AV_CODEC_ID_PCM_F32LE ||
 +           codec_id == AV_CODEC_ID_PCM_F64LE;
 +}
 +
 +static int mov_pcm_be_gt16(enum AVCodecID codec_id)
 +{
 +    return codec_id == AV_CODEC_ID_PCM_S24BE ||
 +           codec_id == AV_CODEC_ID_PCM_S32BE ||
 +           codec_id == AV_CODEC_ID_PCM_F32BE ||
 +           codec_id == AV_CODEC_ID_PCM_F64BE;
 +}
 +
  static int mov_write_ms_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
  {
 +    int ret;
      int64_t pos = avio_tell(pb);
      avio_wb32(pb, 0);
      avio_wl32(pb, track->tag); // store it byteswapped
      track->par->codec_tag = av_bswap16(track->tag >> 16);
 -    ff_put_wav_header(s, pb, track->st->codecpar);
 +    if ((ret = ff_put_wav_header(s, pb, track->par, 0)) < 0)
 +        return ret;
      return update_size(pb, pos);
  }
  
  static int mov_write_wfex_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
  {
 +    int ret;
      int64_t pos = avio_tell(pb);
      avio_wb32(pb, 0);
      ffio_wfourcc(pb, "wfex");
 -    ff_put_wav_header(s, pb, track->st->codecpar);
 +    if ((ret = ff_put_wav_header(s, pb, track->st->codecpar, FF_PUT_WAV_HEADER_FORCE_WAVEFORMATEX)) < 0)
 +        return ret;
      return update_size(pb, pos);
  }
  
@@@ -664,9 -391,6 +664,9 @@@ static int mov_write_chan_tag(AVFormatC
          return 0;
      }
  
 +    if (track->multichannel_as_mono)
 +        return 0;
 +
      avio_wb32(pb, 0);           // Size
      ffio_wfourcc(pb, "chan");   // Type
      avio_w8(pb, 0);             // Version
@@@ -685,11 -409,9 +685,11 @@@ static int mov_write_wave_tag(AVFormatC
      avio_wb32(pb, 0);     /* size */
      ffio_wfourcc(pb, "wave");
  
 +    if (track->par->codec_id != AV_CODEC_ID_QDM2) {
      avio_wb32(pb, 12);    /* size */
      ffio_wfourcc(pb, "frma");
      avio_wl32(pb, track->tag);
 +    }
  
      if (track->par->codec_id == AV_CODEC_ID_AAC) {
          /* useless atom needed by mplayer, ipod, not needed by quicktime */
          ffio_wfourcc(pb, "mp4a");
          avio_wb32(pb, 0);
          mov_write_esds_tag(pb, track);
 +    } else if (mov_pcm_le_gt16(track->par->codec_id))  {
 +      mov_write_enda_tag(pb);
 +    } else if (mov_pcm_be_gt16(track->par->codec_id))  {
 +      mov_write_enda_tag_be(pb);
      } else if (track->par->codec_id == AV_CODEC_ID_AMR_NB) {
          mov_write_amr_tag(pb, track);
      } else if (track->par->codec_id == AV_CODEC_ID_AC3) {
          mov_write_ac3_tag(pb, track);
 -    } else if (track->par->codec_id == AV_CODEC_ID_ALAC) {
 +    } else if (track->par->codec_id == AV_CODEC_ID_EAC3) {
 +        mov_write_eac3_tag(pb, track);
 +    } else if (track->par->codec_id == AV_CODEC_ID_ALAC ||
 +               track->par->codec_id == AV_CODEC_ID_QDM2) {
          mov_write_extradata_tag(pb, track);
      } else if (track->par->codec_id == AV_CODEC_ID_ADPCM_MS ||
                 track->par->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) {
@@@ -869,20 -584,13 +869,20 @@@ static int get_cluster_duration(MOVTrac
      else
          next_dts = track->cluster[cluster_idx + 1].dts;
  
 -    return next_dts - track->cluster[cluster_idx].dts;
 +    next_dts -= track->cluster[cluster_idx].dts;
 +
 +    av_assert0(next_dts >= 0);
 +    av_assert0(next_dts <= INT_MAX);
 +
 +    return next_dts;
  }
  
  static int get_samples_per_packet(MOVTrack *track)
  {
      int i, first_duration;
  
 +// return track->par->frame_size;
 +
      /* use 1 for raw PCM */
      if (!track->audio_vbr)
          return 1;
      return first_duration;
  }
  
 -static int mov_write_audio_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
 +static int mov_write_audio_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
  {
      int64_t pos = avio_tell(pb);
      int version = 0;
      uint32_t tag = track->tag;
  
      if (track->mode == MODE_MOV) {
 -        if (mov_get_lpcm_flags(track->par->codec_id))
 -            tag = AV_RL32("lpcm");
 -        version = 2;
 +        if (track->timescale > UINT16_MAX) {
 +            if (mov_get_lpcm_flags(track->par->codec_id))
 +                tag = AV_RL32("lpcm");
 +            version = 2;
 +        } else if (track->audio_vbr || mov_pcm_le_gt16(track->par->codec_id) ||
 +                   mov_pcm_be_gt16(track->par->codec_id) ||
 +                   track->par->codec_id == AV_CODEC_ID_ADPCM_MS ||
 +                   track->par->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV ||
 +                   track->par->codec_id == AV_CODEC_ID_QDM2) {
 +            version = 1;
 +        }
      }
  
      avio_wb32(pb, 0); /* size */
 -    avio_wl32(pb, tag); // store it byteswapped
 +    if (mov->encryption_scheme != MOV_ENC_NONE) {
 +        ffio_wfourcc(pb, "enca");
 +    } else {
 +        avio_wl32(pb, tag); // store it byteswapped
 +    }
      avio_wb32(pb, 0); /* Reserved */
      avio_wb16(pb, 0); /* Reserved */
      avio_wb16(pb, 1); /* Data-reference index, XXX  == 1 */
          avio_wb32(pb, track->sample_size);
          avio_wb32(pb, get_samples_per_packet(track));
      } else {
 -        /* reserved for mp4/3gp */
 -        avio_wb16(pb, 2);
 -        avio_wb16(pb, 16);
 -        avio_wb16(pb, 0);
 +        if (track->mode == MODE_MOV) {
 +            avio_wb16(pb, track->par->channels);
 +            if (track->par->codec_id == AV_CODEC_ID_PCM_U8 ||
 +                track->par->codec_id == AV_CODEC_ID_PCM_S8)
 +                avio_wb16(pb, 8); /* bits per sample */
 +            else if (track->par->codec_id == AV_CODEC_ID_ADPCM_G726)
 +                avio_wb16(pb, track->par->bits_per_coded_sample);
 +            else
 +                avio_wb16(pb, 16);
 +            avio_wb16(pb, track->audio_vbr ? -2 : 0); /* compression ID */
 +        } else { /* reserved for mp4/3gp */
 +            avio_wb16(pb, 2);
 +            avio_wb16(pb, 16);
 +            avio_wb16(pb, 0);
 +        }
  
          avio_wb16(pb, 0); /* packet size (= 0) */
          avio_wb16(pb, track->par->sample_rate <= UINT16_MAX ?
          avio_wb16(pb, 0); /* Reserved */
      }
  
 +    if (version == 1) { /* SoundDescription V1 extended info */
 +        if (mov_pcm_le_gt16(track->par->codec_id) ||
 +            mov_pcm_be_gt16(track->par->codec_id))
 +            avio_wb32(pb, 1); /*  must be 1 for  uncompressed formats */
 +        else
 +            avio_wb32(pb, track->par->frame_size); /* Samples per packet */
 +        avio_wb32(pb, track->sample_size / track->par->channels); /* Bytes per packet */
 +        avio_wb32(pb, track->sample_size); /* Bytes per frame */
 +        avio_wb32(pb, 2); /* Bytes per sample */
 +    }
 +
      if (track->mode == MODE_MOV &&
          (track->par->codec_id == AV_CODEC_ID_AAC           ||
           track->par->codec_id == AV_CODEC_ID_AC3           ||
 +         track->par->codec_id == AV_CODEC_ID_EAC3          ||
           track->par->codec_id == AV_CODEC_ID_AMR_NB        ||
           track->par->codec_id == AV_CODEC_ID_ALAC          ||
           track->par->codec_id == AV_CODEC_ID_ADPCM_MS      ||
 -         track->par->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV))
 +         track->par->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV ||
 +         track->par->codec_id == AV_CODEC_ID_QDM2          ||
 +         (mov_pcm_le_gt16(track->par->codec_id) && version==1) ||
 +         (mov_pcm_be_gt16(track->par->codec_id) && version==1)))
          mov_write_wave_tag(s, pb, track);
      else if (track->tag == MKTAG('m','p','4','a'))
          mov_write_esds_tag(pb, track);
          mov_write_amr_tag(pb, track);
      else if (track->par->codec_id == AV_CODEC_ID_AC3)
          mov_write_ac3_tag(pb, track);
 +    else if (track->par->codec_id == AV_CODEC_ID_EAC3)
 +        mov_write_eac3_tag(pb, track);
      else if (track->par->codec_id == AV_CODEC_ID_ALAC)
          mov_write_extradata_tag(pb, track);
      else if (track->par->codec_id == AV_CODEC_ID_WMAPRO)
      if (track->mode == MODE_MOV && track->par->codec_type == AVMEDIA_TYPE_AUDIO)
          mov_write_chan_tag(s, pb, track);
  
 +    if (mov->encryption_scheme != MOV_ENC_NONE) {
 +        ff_mov_cenc_write_sinf_tag(track, pb, mov->encryption_kid);
 +    }
 +
      return update_size(pb, pos);
  }
  
@@@ -1030,6 -694,19 +1030,6 @@@ static int mov_write_d263_tag(AVIOConte
      return 0xf;
  }
  
 -/* TODO: No idea about these values */
 -static int mov_write_svq3_tag(AVIOContext *pb)
 -{
 -    avio_wb32(pb, 0x15);
 -    ffio_wfourcc(pb, "SMI ");
 -    ffio_wfourcc(pb, "SEQH");
 -    avio_wb32(pb, 0x5);
 -    avio_wb32(pb, 0xe2c0211d);
 -    avio_wb32(pb, 0xc0000000);
 -    avio_w8(pb, 0);
 -    return 0x15;
 -}
 -
  static int mov_write_avcc_tag(AVIOContext *pb, MOVTrack *track)
  {
      int64_t pos = avio_tell(pb);
      return update_size(pb, pos);
  }
  
 +static int mov_write_vpcc_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
 +{
 +    int64_t pos = avio_tell(pb);
 +
 +    avio_wb32(pb, 0);
 +    ffio_wfourcc(pb, "vpcC");
 +    avio_wb32(pb, 0); /* version & flags */
 +    ff_isom_write_vpcc(s, pb, track->par);
 +    return update_size(pb, pos);
 +}
 +
  static int mov_write_hvcc_tag(AVIOContext *pb, MOVTrack *track)
  {
      int64_t pos = avio_tell(pb);
  static int mov_write_avid_tag(AVIOContext *pb, MOVTrack *track)
  {
      int i;
 +    int interlaced;
 +    int cid;
 +
 +    if (track->vos_data && track->vos_len > 0x29) {
 +        if (track->vos_data[0] == 0x00 &&
 +            track->vos_data[1] == 0x00 &&
 +            track->vos_data[2] == 0x02 &&
 +            track->vos_data[3] == 0x80 &&
 +            (track->vos_data[4] == 0x01 || track->vos_data[4] == 0x02)) {
 +            /* looks like a DNxHD bit stream */
 +            interlaced = (track->vos_data[5] & 2);
 +            cid = AV_RB32(track->vos_data + 0x28);
 +        } else {
 +            av_log(NULL, AV_LOG_WARNING, "Could not locate DNxHD bit stream in vos_data\n");
 +            return 0;
 +        }
 +    } else {
 +        av_log(NULL, AV_LOG_WARNING, "Could not locate DNxHD bit stream, vos_data too small\n");
 +        return 0;
 +    }
 +
      avio_wb32(pb, 24); /* size */
      ffio_wfourcc(pb, "ACLR");
      ffio_wfourcc(pb, "ACLR");
      ffio_wfourcc(pb, "0001");
 -    avio_wb32(pb, 2); /* yuv range: full 1 / normal 2 */
 +    if (track->par->color_range == AVCOL_RANGE_MPEG || /* Legal range (16-235) */
 +        track->par->color_range == AVCOL_RANGE_UNSPECIFIED) {
 +        avio_wb32(pb, 1); /* Corresponds to 709 in official encoder */
 +    } else { /* Full range (0-255) */
 +        avio_wb32(pb, 2); /* Corresponds to RGB in official encoder */
 +    }
      avio_wb32(pb, 0); /* unknown */
  
      avio_wb32(pb, 24); /* size */
      ffio_wfourcc(pb, "ARES");
      ffio_wfourcc(pb, "ARES");
      ffio_wfourcc(pb, "0001");
 -    avio_wb32(pb, AV_RB32(track->vos_data + 0x28)); /* dnxhd cid, some id ? */
 +    avio_wb32(pb, cid); /* dnxhd cid, some id ? */
      avio_wb32(pb, track->par->width);
      /* values below are based on samples created with quicktime and avid codecs */
 -    if (track->vos_data[5] & 2) { // interlaced
 +    if (interlaced) {
          avio_wb32(pb, track->par->height / 2);
          avio_wb32(pb, 2); /* unknown */
          avio_wb32(pb, 0); /* unknown */
      for (i = 0; i < 10; i++)
          avio_wb64(pb, 0);
  
 -    /* extra padding for stsd needed */
 -    avio_wb32(pb, 0);
 +    return 0;
 +}
 +
 +static int mov_write_dpxe_tag(AVIOContext *pb, MOVTrack *track)
 +{
 +    avio_wb32(pb, 12);
 +    ffio_wfourcc(pb, "DpxE");
 +    if (track->par->extradata_size >= 12 &&
 +        !memcmp(&track->par->extradata[4], "DpxE", 4)) {
 +        avio_wb32(pb, track->par->extradata[11]);
 +    } else {
 +        avio_wb32(pb, 1);
 +    }
      return 0;
  }
  
@@@ -1155,9 -784,7 +1155,9 @@@ static int mp4_get_codec_tag(AVFormatCo
  
      if      (track->par->codec_id == AV_CODEC_ID_H264)      tag = MKTAG('a','v','c','1');
      else if (track->par->codec_id == AV_CODEC_ID_HEVC)      tag = MKTAG('h','e','v','1');
 +    else if (track->par->codec_id == AV_CODEC_ID_VP9)       tag = MKTAG('v','p','0','9');
      else if (track->par->codec_id == AV_CODEC_ID_AC3)       tag = MKTAG('a','c','-','3');
 +    else if (track->par->codec_id == AV_CODEC_ID_EAC3)      tag = MKTAG('e','c','-','3');
      else if (track->par->codec_id == AV_CODEC_ID_DIRAC)     tag = MKTAG('d','r','a','c');
      else if (track->par->codec_id == AV_CODEC_ID_MOV_TEXT)  tag = MKTAG('t','x','3','g');
      else if (track->par->codec_id == AV_CODEC_ID_VC1)       tag = MKTAG('v','c','-','1');
@@@ -1189,10 -816,8 +1189,10 @@@ static int ipod_get_codec_tag(AVFormatC
             tag == MKTAG('t', 'e', 'x', 't'))))
          tag = ff_codec_get_tag(codec_ipod_tags, track->par->codec_id);
  
 -    if (!av_match_ext(s->filename, "m4a") && !av_match_ext(s->filename, "m4v"))
 -        av_log(s, AV_LOG_WARNING, "Warning, extension is not .m4a nor .m4v "
 +    if (!av_match_ext(s->filename, "m4a") &&
 +        !av_match_ext(s->filename, "m4b") &&
 +        !av_match_ext(s->filename, "m4v"))
 +        av_log(s, AV_LOG_WARNING, "Warning, extension is not .m4a, .m4v nor  .m4b "
                 "Quicktime/Ipod might not play the file\n");
  
      return tag;
@@@ -1202,20 -827,20 +1202,20 @@@ static int mov_get_dv_codec_tag(AVForma
  {
      int tag;
  
 -    if (track->par->width == 720) /* SD */
 -        if (track->par->height == 480) /* NTSC */
 -            if  (track->par->format  == AV_PIX_FMT_YUV422P) tag = MKTAG('d','v','5','n');
 +    if (track->par->width == 720) /* SD */
 +        if (track->par->height == 480) /* NTSC */
 +            if  (track->par->format == AV_PIX_FMT_YUV422P) tag = MKTAG('d','v','5','n');
              else                                            tag = MKTAG('d','v','c',' ');
 -        else if (track->par->format  == AV_PIX_FMT_YUV422P) tag = MKTAG('d','v','5','p');
 -        else if (track->par->format  == AV_PIX_FMT_YUV420P) tag = MKTAG('d','v','c','p');
 +       }else if (track->par->format == AV_PIX_FMT_YUV422P) tag = MKTAG('d','v','5','p');
 +        else if (track->par->format == AV_PIX_FMT_YUV420P) tag = MKTAG('d','v','c','p');
          else                                                tag = MKTAG('d','v','p','p');
 -    else if (track->par->height == 720) /* HD 720 line */
 +    } else if (track->par->height == 720) { /* HD 720 line */
          if  (track->st->time_base.den == 50)                tag = MKTAG('d','v','h','q');
          else                                                tag = MKTAG('d','v','h','p');
 -    else if (track->par->height == 1080) /* HD 1080 line */
 +    } else if (track->par->height == 1080) { /* HD 1080 line */
          if  (track->st->time_base.den == 25)                tag = MKTAG('d','v','h','5');
          else                                                tag = MKTAG('d','v','h','6');
 -    else {
 +    else {
          av_log(s, AV_LOG_ERROR, "unsupported height for dv codec\n");
          return 0;
      }
      return tag;
  }
  
 +static AVRational find_fps(AVFormatContext *s, AVStream *st)
 +{
 +    AVRational rate = st->avg_frame_rate;
 +
 +#if FF_API_LAVF_AVCTX
 +    FF_DISABLE_DEPRECATION_WARNINGS
 +    rate = av_inv_q(st->codec->time_base);
 +    if (av_timecode_check_frame_rate(rate) < 0) {
 +        av_log(s, AV_LOG_DEBUG, "timecode: tbc=%d/%d invalid, fallback on %d/%d\n",
 +               rate.num, rate.den, st->avg_frame_rate.num, st->avg_frame_rate.den);
 +        rate = st->avg_frame_rate;
 +    }
 +    FF_ENABLE_DEPRECATION_WARNINGS
 +#endif
 +
 +    return rate;
 +}
 +
 +static int mov_get_mpeg2_xdcam_codec_tag(AVFormatContext *s, MOVTrack *track)
 +{
 +    int tag = track->par->codec_tag;
 +    int interlaced = track->par->field_order > AV_FIELD_PROGRESSIVE;
 +    AVStream *st = track->st;
 +    int rate = av_q2d(find_fps(s, st));
 +
 +    if (!tag)
 +        tag = MKTAG('m', '2', 'v', '1'); //fallback tag
 +
 +    if (track->par->format == AV_PIX_FMT_YUV420P) {
 +        if (track->par->width == 1280 && track->par->height == 720) {
 +            if (!interlaced) {
 +                if      (rate == 24) tag = MKTAG('x','d','v','4');
 +                else if (rate == 25) tag = MKTAG('x','d','v','5');
 +                else if (rate == 30) tag = MKTAG('x','d','v','1');
 +                else if (rate == 50) tag = MKTAG('x','d','v','a');
 +                else if (rate == 60) tag = MKTAG('x','d','v','9');
 +            }
 +        } else if (track->par->width == 1440 && track->par->height == 1080) {
 +            if (!interlaced) {
 +                if      (rate == 24) tag = MKTAG('x','d','v','6');
 +                else if (rate == 25) tag = MKTAG('x','d','v','7');
 +                else if (rate == 30) tag = MKTAG('x','d','v','8');
 +            } else {
 +                if      (rate == 25) tag = MKTAG('x','d','v','3');
 +                else if (rate == 30) tag = MKTAG('x','d','v','2');
 +            }
 +        } else if (track->par->width == 1920 && track->par->height == 1080) {
 +            if (!interlaced) {
 +                if      (rate == 24) tag = MKTAG('x','d','v','d');
 +                else if (rate == 25) tag = MKTAG('x','d','v','e');
 +                else if (rate == 30) tag = MKTAG('x','d','v','f');
 +            } else {
 +                if      (rate == 25) tag = MKTAG('x','d','v','c');
 +                else if (rate == 30) tag = MKTAG('x','d','v','b');
 +            }
 +        }
 +    } else if (track->par->format == AV_PIX_FMT_YUV422P) {
 +        if (track->par->width == 1280 && track->par->height == 720) {
 +            if (!interlaced) {
 +                if      (rate == 24) tag = MKTAG('x','d','5','4');
 +                else if (rate == 25) tag = MKTAG('x','d','5','5');
 +                else if (rate == 30) tag = MKTAG('x','d','5','1');
 +                else if (rate == 50) tag = MKTAG('x','d','5','a');
 +                else if (rate == 60) tag = MKTAG('x','d','5','9');
 +            }
 +        } else if (track->par->width == 1920 && track->par->height == 1080) {
 +            if (!interlaced) {
 +                if      (rate == 24) tag = MKTAG('x','d','5','d');
 +                else if (rate == 25) tag = MKTAG('x','d','5','e');
 +                else if (rate == 30) tag = MKTAG('x','d','5','f');
 +            } else {
 +                if      (rate == 25) tag = MKTAG('x','d','5','c');
 +                else if (rate == 30) tag = MKTAG('x','d','5','b');
 +            }
 +        }
 +    }
 +
 +    return tag;
 +}
 +
 +static int mov_get_h264_codec_tag(AVFormatContext *s, MOVTrack *track)
 +{
 +    int tag = track->par->codec_tag;
 +    int interlaced = track->par->field_order > AV_FIELD_PROGRESSIVE;
 +    AVStream *st = track->st;
 +    int rate = av_q2d(find_fps(s, st));
 +
 +    if (!tag)
 +        tag = MKTAG('a', 'v', 'c', 'i'); //fallback tag
 +
 +    if (track->par->format == AV_PIX_FMT_YUV420P10) {
 +        if (track->par->width == 960 && track->par->height == 720) {
 +            if (!interlaced) {
 +                if      (rate == 24) tag = MKTAG('a','i','5','p');
 +                else if (rate == 25) tag = MKTAG('a','i','5','q');
 +                else if (rate == 30) tag = MKTAG('a','i','5','p');
 +                else if (rate == 50) tag = MKTAG('a','i','5','q');
 +                else if (rate == 60) tag = MKTAG('a','i','5','p');
 +            }
 +        } else if (track->par->width == 1440 && track->par->height == 1080) {
 +            if (!interlaced) {
 +                if      (rate == 24) tag = MKTAG('a','i','5','3');
 +                else if (rate == 25) tag = MKTAG('a','i','5','2');
 +                else if (rate == 30) tag = MKTAG('a','i','5','3');
 +            } else {
 +                if      (rate == 50) tag = MKTAG('a','i','5','5');
 +                else if (rate == 60) tag = MKTAG('a','i','5','6');
 +            }
 +        }
 +    } else if (track->par->format == AV_PIX_FMT_YUV422P10) {
 +        if (track->par->width == 1280 && track->par->height == 720) {
 +            if (!interlaced) {
 +                if      (rate == 24) tag = MKTAG('a','i','1','p');
 +                else if (rate == 25) tag = MKTAG('a','i','1','q');
 +                else if (rate == 30) tag = MKTAG('a','i','1','p');
 +                else if (rate == 50) tag = MKTAG('a','i','1','q');
 +                else if (rate == 60) tag = MKTAG('a','i','1','p');
 +            }
 +        } else if (track->par->width == 1920 && track->par->height == 1080) {
 +            if (!interlaced) {
 +                if      (rate == 24) tag = MKTAG('a','i','1','3');
 +                else if (rate == 25) tag = MKTAG('a','i','1','2');
 +                else if (rate == 30) tag = MKTAG('a','i','1','3');
 +            } else {
 +                if      (rate == 25) tag = MKTAG('a','i','1','5');
 +                else if (rate == 50) tag = MKTAG('a','i','1','5');
 +                else if (rate == 60) tag = MKTAG('a','i','1','6');
 +            }
 +        } else if (   track->par->width == 4096 && track->par->height == 2160
 +                   || track->par->width == 3840 && track->par->height == 2160
 +                   || track->par->width == 2048 && track->par->height == 1080) {
 +            tag = MKTAG('a','i','v','x');
 +        }
 +    }
 +
 +    return tag;
 +}
 +
  static const struct {
      enum AVPixelFormat pix_fmt;
      uint32_t tag;
      unsigned bps;
  } mov_pix_fmt_tags[] = {
 +    { AV_PIX_FMT_YUYV422, MKTAG('y','u','v','2'),  0 },
      { AV_PIX_FMT_YUYV422, MKTAG('y','u','v','s'),  0 },
      { AV_PIX_FMT_UYVY422, MKTAG('2','v','u','y'),  0 },
      { AV_PIX_FMT_RGB555BE,MKTAG('r','a','w',' '), 16 },
@@@ -1387,24 -873,15 +1387,24 @@@ static int mov_get_rawvideo_codec_tag(A
  {
      int tag = track->par->codec_tag;
      int i;
 +    enum AVPixelFormat pix_fmt;
  
      for (i = 0; i < FF_ARRAY_ELEMS(mov_pix_fmt_tags); i++) {
          if (track->par->format == mov_pix_fmt_tags[i].pix_fmt) {
              tag = mov_pix_fmt_tags[i].tag;
              track->par->bits_per_coded_sample = mov_pix_fmt_tags[i].bps;
 -            break;
 +            if (track->par->codec_tag == mov_pix_fmt_tags[i].tag)
 +                break;
          }
      }
  
 +    pix_fmt = avpriv_find_pix_fmt(avpriv_pix_fmt_bps_mov,
 +                                  track->par->bits_per_coded_sample);
 +    if (tag == MKTAG('r','a','w',' ') &&
 +        track->par->format != pix_fmt &&
 +        track->par->format != AV_PIX_FMT_NONE)
 +        av_log(s, AV_LOG_ERROR, "%s rawvideo cannot be written to mov, output file will be unreadable\n",
 +               av_get_pix_fmt_name(track->par->format));
      return tag;
  }
  
@@@ -1416,17 -893,11 +1416,17 @@@ static int mov_get_codec_tag(AVFormatCo
                   (track->par->codec_id == AV_CODEC_ID_DVVIDEO ||
                    track->par->codec_id == AV_CODEC_ID_RAWVIDEO ||
                    track->par->codec_id == AV_CODEC_ID_H263 ||
 +                  track->par->codec_id == AV_CODEC_ID_H264 ||
 +                  track->par->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
                    av_get_bits_per_sample(track->par->codec_id)))) { // pcm audio
          if (track->par->codec_id == AV_CODEC_ID_DVVIDEO)
              tag = mov_get_dv_codec_tag(s, track);
          else if (track->par->codec_id == AV_CODEC_ID_RAWVIDEO)
              tag = mov_get_rawvideo_codec_tag(s, track);
 +        else if (track->par->codec_id == AV_CODEC_ID_MPEG2VIDEO)
 +            tag = mov_get_mpeg2_xdcam_codec_tag(s, track);
 +        else if (track->par->codec_id == AV_CODEC_ID_H264)
 +            tag = mov_get_h264_codec_tag(s, track);
          else if (track->par->codec_type == AVMEDIA_TYPE_VIDEO) {
              tag = ff_codec_get_tag(ff_codec_movvideo_tags, track->par->codec_id);
              if (!tag) { // if no mac fcc found, try with Microsoft tags
@@@ -1463,7 -934,7 +1463,7 @@@ static const AVCodecTag codec_3gp_tags[
      { AV_CODEC_ID_NONE, 0 },
  };
  
 -static const AVCodecTag codec_f4v_tags[] = {
 +static const AVCodecTag codec_f4v_tags[] = { // XXX: add GIF/PNG/JPEG?
      { AV_CODEC_ID_MP3,    MKTAG('.','m','p','3') },
      { AV_CODEC_ID_AAC,    MKTAG('m','p','4','a') },
      { AV_CODEC_ID_H264,   MKTAG('a','v','c','1') },
@@@ -1514,11 -985,11 +1514,11 @@@ static const uint16_t fiel_data[] = 
      0x0000, 0x0100, 0x0201, 0x0206, 0x0209, 0x020e
  };
  
 -static int mov_write_fiel_tag(AVIOContext *pb, MOVTrack *track)
 +static int mov_write_fiel_tag(AVIOContext *pb, MOVTrack *track, int field_order)
  {
      unsigned mov_field_order = 0;
 -    if (track->par->field_order < FF_ARRAY_ELEMS(fiel_data))
 -        mov_field_order = fiel_data[track->par->field_order];
 +    if (field_order < FF_ARRAY_ELEMS(fiel_data))
 +        mov_field_order = fiel_data[field_order];
      else
          return 0;
      avio_wb32(pb, 10);
@@@ -1557,145 -1028,14 +1557,145 @@@ static int mov_write_pasp_tag(AVIOConte
      return 16;
  }
  
 -static int mov_write_video_tag(AVIOContext *pb, MOVTrack *track)
 +static int mov_write_gama_tag(AVIOContext *pb, MOVTrack *track, double gamma)
 +{
 +    uint32_t gama = 0;
 +    if (gamma <= 0.0)
 +    {
 +        gamma = avpriv_get_gamma_from_trc(track->par->color_trc);
 +    }
 +    av_log(pb, AV_LOG_DEBUG, "gamma value %g\n", gamma);
 +
 +    if (gamma > 1e-6) {
 +        gama = (uint32_t)lrint((double)(1<<16) * gamma);
 +        av_log(pb, AV_LOG_DEBUG, "writing gama value %d\n", gama);
 +
 +        av_assert0(track->mode == MODE_MOV);
 +        avio_wb32(pb, 12);
 +        ffio_wfourcc(pb, "gama");
 +        avio_wb32(pb, gama);
 +        return 12;
 +    }
 +    else {
 +        av_log(pb, AV_LOG_WARNING, "gamma value unknown, unable to write gama atom\n");
 +    }
 +    return 0;
 +}
 +
 +static int mov_write_colr_tag(AVIOContext *pb, MOVTrack *track)
 +{
 +    // Ref (MOV): https://developer.apple.com/library/mac/technotes/tn2162/_index.html#//apple_ref/doc/uid/DTS40013070-CH1-TNTAG9
 +    // Ref (MP4): ISO/IEC 14496-12:2012
 +
 +    if (track->par->color_primaries == AVCOL_PRI_UNSPECIFIED &&
 +        track->par->color_trc == AVCOL_TRC_UNSPECIFIED &&
 +        track->par->color_space == AVCOL_SPC_UNSPECIFIED) {
 +        if ((track->par->width >= 1920 && track->par->height >= 1080)
 +          || (track->par->width == 1280 && track->par->height == 720)) {
 +            av_log(NULL, AV_LOG_WARNING, "color primaries unspecified, assuming bt709\n");
 +            track->par->color_primaries = AVCOL_PRI_BT709;
 +        } else if (track->par->width == 720 && track->height == 576) {
 +            av_log(NULL, AV_LOG_WARNING, "color primaries unspecified, assuming bt470bg\n");
 +            track->par->color_primaries = AVCOL_PRI_BT470BG;
 +        } else if (track->par->width == 720 &&
 +                   (track->height == 486 || track->height == 480)) {
 +            av_log(NULL, AV_LOG_WARNING, "color primaries unspecified, assuming smpte170\n");
 +            track->par->color_primaries = AVCOL_PRI_SMPTE170M;
 +        } else {
 +            av_log(NULL, AV_LOG_WARNING, "color primaries unspecified, unable to assume anything\n");
 +        }
 +        switch (track->par->color_primaries) {
 +        case AVCOL_PRI_BT709:
 +            track->par->color_trc = AVCOL_TRC_BT709;
 +            track->par->color_space = AVCOL_SPC_BT709;
 +            break;
 +        case AVCOL_PRI_SMPTE170M:
 +        case AVCOL_PRI_BT470BG:
 +            track->par->color_trc = AVCOL_TRC_BT709;
 +            track->par->color_space = AVCOL_SPC_SMPTE170M;
 +            break;
 +        }
 +    }
 +
 +    /* We should only ever be called by MOV or MP4. */
 +    av_assert0(track->mode == MODE_MOV || track->mode == MODE_MP4);
 +
 +    avio_wb32(pb, 18 + (track->mode == MODE_MP4));
 +    ffio_wfourcc(pb, "colr");
 +    if (track->mode == MODE_MP4)
 +        ffio_wfourcc(pb, "nclx");
 +    else
 +        ffio_wfourcc(pb, "nclc");
 +    switch (track->par->color_primaries) {
 +    case AVCOL_PRI_BT709:     avio_wb16(pb, 1); break;
 +    case AVCOL_PRI_SMPTE170M:
 +    case AVCOL_PRI_SMPTE240M: avio_wb16(pb, 6); break;
 +    case AVCOL_PRI_BT470BG:   avio_wb16(pb, 5); break;
 +    default:                  avio_wb16(pb, 2);
 +    }
 +    switch (track->par->color_trc) {
 +    case AVCOL_TRC_BT709:     avio_wb16(pb, 1); break;
 +    case AVCOL_TRC_SMPTE170M: avio_wb16(pb, 1); break; // remapped
 +    case AVCOL_TRC_SMPTE240M: avio_wb16(pb, 7); break;
 +    default:                  avio_wb16(pb, 2);
 +    }
 +    switch (track->par->color_space) {
 +    case AVCOL_SPC_BT709:     avio_wb16(pb, 1); break;
 +    case AVCOL_SPC_BT470BG:
 +    case AVCOL_SPC_SMPTE170M: avio_wb16(pb, 6); break;
 +    case AVCOL_SPC_SMPTE240M: avio_wb16(pb, 7); break;
 +    default:                  avio_wb16(pb, 2);
 +    }
 +
 +    if (track->mode == MODE_MP4) {
 +        int full_range = track->par->color_range == AVCOL_RANGE_JPEG;
 +        avio_w8(pb, full_range << 7);
 +        return 19;
 +    } else {
 +        return 18;
 +    }
 +}
 +
 +static void find_compressor(char * compressor_name, int len, MOVTrack *track)
  {
      AVDictionaryEntry *encoder;
 +    int xdcam_res =  (track->par->width == 1280 && track->par->height == 720)
 +                  || (track->par->width == 1440 && track->par->height == 1080)
 +                  || (track->par->width == 1920 && track->par->height == 1080);
 +
 +    if (track->mode == MODE_MOV &&
 +        (encoder = av_dict_get(track->st->metadata, "encoder", NULL, 0))) {
 +        av_strlcpy(compressor_name, encoder->value, 32);
 +    } else if (track->par->codec_id == AV_CODEC_ID_MPEG2VIDEO && xdcam_res) {
 +        int interlaced = track->par->field_order > AV_FIELD_PROGRESSIVE;
 +        AVStream *st = track->st;
 +        int rate = av_q2d(find_fps(NULL, st));
 +        av_strlcatf(compressor_name, len, "XDCAM");
 +        if (track->par->format == AV_PIX_FMT_YUV422P) {
 +            av_strlcatf(compressor_name, len, " HD422");
 +        } else if(track->par->width == 1440) {
 +            av_strlcatf(compressor_name, len, " HD");
 +        } else
 +            av_strlcatf(compressor_name, len, " EX");
 +
 +        av_strlcatf(compressor_name, len, " %d%c", track->par->height, interlaced ? 'i' : 'p');
 +
 +        av_strlcatf(compressor_name, len, "%d", rate * (interlaced + 1));
 +    }
 +}
 +
 +static int mov_write_video_tag(AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
 +{
      int64_t pos = avio_tell(pb);
      char compressor_name[32] = { 0 };
 +    int avid = 0;
  
      avio_wb32(pb, 0); /* size */
 -    avio_wl32(pb, track->tag); // store it byteswapped
 +    if (mov->encryption_scheme != MOV_ENC_NONE) {
 +        ffio_wfourcc(pb, "encv");
 +    } else {
 +        avio_wl32(pb, track->tag); // store it byteswapped
 +    }
      avio_wb32(pb, 0); /* Reserved */
      avio_wb16(pb, 0); /* Reserved */
      avio_wb16(pb, 1); /* Data-reference index */
      avio_wb16(pb, 1); /* Frame count (= 1) */
  
      /* FIXME not sure, ISO 14496-1 draft where it shall be set to 0 */
 -    if (track->mode == MODE_MOV &&
 -        (encoder = av_dict_get(track->st->metadata, "encoder", NULL, 0)))
 -        av_strlcpy(compressor_name, encoder->value, 32);
 +    find_compressor(compressor_name, 32, track);
      avio_w8(pb, strlen(compressor_name));
      avio_write(pb, compressor_name, 31);
  
      if (track->mode == MODE_MOV && track->par->bits_per_coded_sample)
 -        avio_wb16(pb, track->par->bits_per_coded_sample);
 +        avio_wb16(pb, track->par->bits_per_coded_sample |
 +                  (track->par->format == AV_PIX_FMT_GRAY8 ? 0x20 : 0));
      else
          avio_wb16(pb, 0x18); /* Reserved */
 -    avio_wb16(pb, 0xffff); /* Reserved */
 +
 +    if (track->mode == MODE_MOV && track->par->format == AV_PIX_FMT_PAL8) {
 +        int pal_size = 1 << track->par->bits_per_coded_sample;
 +        int i;
 +        avio_wb16(pb, 0);             /* Color table ID */
 +        avio_wb32(pb, 0);             /* Color table seed */
 +        avio_wb16(pb, 0x8000);        /* Color table flags */
 +        avio_wb16(pb, pal_size - 1);  /* Color table size (zero-relative) */
 +        for (i = 0; i < pal_size; i++) {
 +            uint32_t rgb = track->palette[i];
 +            uint16_t r = (rgb >> 16) & 0xff;
 +            uint16_t g = (rgb >> 8)  & 0xff;
 +            uint16_t b = rgb         & 0xff;
 +            avio_wb16(pb, 0);
 +            avio_wb16(pb, (r << 8) | r);
 +            avio_wb16(pb, (g << 8) | g);
 +            avio_wb16(pb, (b << 8) | b);
 +        }
 +    } else
 +        avio_wb16(pb, 0xffff); /* Reserved */
 +
      if (track->tag == MKTAG('m','p','4','v'))
          mov_write_esds_tag(pb, track);
      else if (track->par->codec_id == AV_CODEC_ID_H263)
          mov_write_d263_tag(pb);
 -    else if (track->par->codec_id == AV_CODEC_ID_SVQ3)
 -        mov_write_svq3_tag(pb);
 -    else if (track->par->codec_id == AV_CODEC_ID_DNXHD)
 +    else if (track->par->codec_id == AV_CODEC_ID_AVUI ||
 +            track->par->codec_id == AV_CODEC_ID_SVQ3) {
 +        mov_write_extradata_tag(pb, track);
 +        avio_wb32(pb, 0);
 +    } else if (track->par->codec_id == AV_CODEC_ID_DNXHD) {
          mov_write_avid_tag(pb, track);
 -    else if (track->par->codec_id == AV_CODEC_ID_HEVC)
 +        avid = 1;
 +    } else if (track->par->codec_id == AV_CODEC_ID_HEVC)
          mov_write_hvcc_tag(pb, track);
 -    else if (track->par->codec_id == AV_CODEC_ID_H264) {
 +    else if (track->par->codec_id == AV_CODEC_ID_H264 && !TAG_IS_AVCI(track->tag)) {
          mov_write_avcc_tag(pb, track);
          if (track->mode == MODE_IPOD)
              mov_write_uuid_tag_ipod(pb);
 -    } else if (track->par->field_order != AV_FIELD_UNKNOWN)
 -        mov_write_fiel_tag(pb, track);
 -    else if (track->par->codec_id == AV_CODEC_ID_VC1 && track->vos_len > 0)
 +    } else if (track->par->codec_id == AV_CODEC_ID_VP9) {
 +        mov_write_vpcc_tag(mov->fc, pb, track);
 +    else if (track->par->codec_id == AV_CODEC_ID_VC1 && track->vos_len > 0)
          mov_write_dvc1_tag(pb, track);
      else if (track->par->codec_id == AV_CODEC_ID_VP6F ||
               track->par->codec_id == AV_CODEC_ID_VP6A) {
          /* Don't write any potential extradata here - the cropping
           * is signalled via the normal width/height fields. */
 +    } else if (track->par->codec_id == AV_CODEC_ID_R10K) {
 +        if (track->par->codec_tag == MKTAG('R','1','0','k'))
 +            mov_write_dpxe_tag(pb, track);
      } else if (track->vos_len > 0)
          mov_write_glbl_tag(pb, track);
  
 +    if (track->par->codec_id != AV_CODEC_ID_H264 &&
 +        track->par->codec_id != AV_CODEC_ID_MPEG4 &&
 +        track->par->codec_id != AV_CODEC_ID_DNXHD) {
 +        int field_order = track->par->field_order;
 +
 +#if FF_API_LAVF_AVCTX
 +    FF_DISABLE_DEPRECATION_WARNINGS
 +    if (field_order != track->st->codec->field_order && track->st->codec->field_order != AV_FIELD_UNKNOWN)
 +        field_order = track->st->codec->field_order;
 +    FF_ENABLE_DEPRECATION_WARNINGS
 +#endif
 +
 +        if (field_order != AV_FIELD_UNKNOWN)
 +            mov_write_fiel_tag(pb, track, field_order);
 +    }
 +
 +    if (mov->flags & FF_MOV_FLAG_WRITE_GAMA) {
 +        if (track->mode == MODE_MOV)
 +            mov_write_gama_tag(pb, track, mov->gamma);
 +        else
 +            av_log(mov->fc, AV_LOG_WARNING, "Not writing 'gama' atom. Format is not MOV.\n");
 +    }
 +    if (mov->flags & FF_MOV_FLAG_WRITE_COLR) {
 +        if (track->mode == MODE_MOV || track->mode == MODE_MP4)
 +            mov_write_colr_tag(pb, track);
 +        else
 +            av_log(mov->fc, AV_LOG_WARNING, "Not writing 'colr' atom. Format is not MOV or MP4.\n");
 +    }
 +
      if (track->par->sample_aspect_ratio.den && track->par->sample_aspect_ratio.num &&
          track->par->sample_aspect_ratio.den != track->par->sample_aspect_ratio.num) {
          mov_write_pasp_tag(pb, track);
      }
  
 +    if (mov->encryption_scheme != MOV_ENC_NONE) {
 +        ff_mov_cenc_write_sinf_tag(track, pb, mov->encryption_kid);
 +    }
 +
 +    /* extra padding for avid stsd */
 +    /* https://developer.apple.com/library/mac/documentation/QuickTime/QTFF/QTFFChap2/qtff2.html#//apple_ref/doc/uid/TP40000939-CH204-61112 */
 +    if (avid)
 +        avio_wb32(pb, 0);
 +
      return update_size(pb, pos);
  }
  
@@@ -1851,70 -1128,9 +1851,70 @@@ static int mov_write_rtp_tag(AVIOContex
      return update_size(pb, pos);
  }
  
 +static int mov_write_source_reference_tag(AVIOContext *pb, MOVTrack *track, const char *reel_name)
 +{
 +    uint64_t str_size =strlen(reel_name);
 +    int64_t pos = avio_tell(pb);
 +
 +    if (str_size >= UINT16_MAX){
 +        av_log(NULL, AV_LOG_ERROR, "reel_name length %"PRIu64" is too large\n", str_size);
 +        avio_wb16(pb, 0);
 +        return AVERROR(EINVAL);
 +    }
 +
 +    avio_wb32(pb, 0);                              /* size */
 +    ffio_wfourcc(pb, "name");                      /* Data format */
 +    avio_wb16(pb, str_size);                       /* string size */
 +    avio_wb16(pb, track->language);                /* langcode */
 +    avio_write(pb, reel_name, str_size);           /* reel name */
 +    return update_size(pb,pos);
 +}
 +
  static int mov_write_tmcd_tag(AVIOContext *pb, MOVTrack *track)
  {
      int64_t pos = avio_tell(pb);
 +#if 1
 +    int frame_duration;
 +    int nb_frames;
 +    AVDictionaryEntry *t = NULL;
 +
 +    if (!track->st->avg_frame_rate.num || !track->st->avg_frame_rate.den) {
 +#if FF_API_LAVF_AVCTX
 +    FF_DISABLE_DEPRECATION_WARNINGS
 +        frame_duration = av_rescale(track->timescale, track->st->codec->time_base.num, track->st->codec->time_base.den);
 +        nb_frames      = ROUNDED_DIV(track->st->codec->time_base.den, track->st->codec->time_base.num);
 +    FF_ENABLE_DEPRECATION_WARNINGS
 +#else
 +        av_log(NULL, AV_LOG_ERROR, "avg_frame_rate not set for tmcd track.\n");
 +        return AVERROR(EINVAL);
 +#endif
 +    } else {
 +        frame_duration = av_rescale(track->timescale, track->st->avg_frame_rate.num, track->st->avg_frame_rate.den);
 +        nb_frames      = ROUNDED_DIV(track->st->avg_frame_rate.den, track->st->avg_frame_rate.num);
 +    }
 +
 +    if (nb_frames > 255) {
 +        av_log(NULL, AV_LOG_ERROR, "fps %d is too large\n", nb_frames);
 +        return AVERROR(EINVAL);
 +    }
 +
 +    avio_wb32(pb, 0); /* size */
 +    ffio_wfourcc(pb, "tmcd");               /* Data format */
 +    avio_wb32(pb, 0);                       /* Reserved */
 +    avio_wb32(pb, 1);                       /* Data reference index */
 +    avio_wb32(pb, 0);                       /* Flags */
 +    avio_wb32(pb, track->timecode_flags);   /* Flags (timecode) */
 +    avio_wb32(pb, track->timescale);        /* Timescale */
 +    avio_wb32(pb, frame_duration);          /* Frame duration */
 +    avio_w8(pb, nb_frames);                 /* Number of frames */
 +    avio_w8(pb, 0);                         /* Reserved */
 +
 +    t = av_dict_get(track->st->metadata, "reel_name", NULL, 0);
 +    if (t && utf8len(t->value) && track->mode != MODE_MP4)
 +        mov_write_source_reference_tag(pb, track, t->value);
 +    else
 +        avio_wb16(pb, 0); /* zero size */
 +#else
  
      avio_wb32(pb, 0); /* size */
      ffio_wfourcc(pb, "tmcd");               /* Data format */
      avio_wb32(pb, 1);                       /* Data reference index */
      if (track->par->extradata_size)
          avio_write(pb, track->par->extradata, track->par->extradata_size);
 +#endif
      return update_size(pb, pos);
  }
  
 -static int mov_write_stsd_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
 +static int mov_write_stsd_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
  {
      int64_t pos = avio_tell(pb);
      avio_wb32(pb, 0); /* size */
      avio_wb32(pb, 0); /* version & flags */
      avio_wb32(pb, 1); /* entry count */
      if (track->par->codec_type == AVMEDIA_TYPE_VIDEO)
 -        mov_write_video_tag(pb, track);
 +        mov_write_video_tag(pb, mov, track);
      else if (track->par->codec_type == AVMEDIA_TYPE_AUDIO)
 -        mov_write_audio_tag(s, pb, track);
 +        mov_write_audio_tag(s, pb, mov, track);
      else if (track->par->codec_type == AVMEDIA_TYPE_SUBTITLE)
          mov_write_subtitle_tag(pb, track);
      else if (track->par->codec_tag == MKTAG('r','t','p',' '))
@@@ -1953,7 -1168,7 +1953,7 @@@ static int mov_write_ctts_tag(AVIOConte
      uint32_t atom_size;
      int i;
  
 -    ctts_entries = av_malloc((track->entry + 1) * sizeof(*ctts_entries)); /* worst case */
 +    ctts_entries = av_malloc_array((track->entry + 1), sizeof(*ctts_entries)); /* worst case */
      if (!ctts_entries)
          return AVERROR(ENOMEM);
      ctts_entries[0].count = 1;
@@@ -1998,7 -1213,7 +1998,7 @@@ static int mov_write_stts_tag(AVIOConte
          entries = 1;
      } else {
          if (track->entry) {
 -            stts_entries = av_malloc(track->entry * sizeof(*stts_entries)); /* worst case */
 +            stts_entries = av_malloc_array(track->entry, sizeof(*stts_entries)); /* worst case */
              if (!stts_entries)
                  return AVERROR(ENOMEM);
          }
@@@ -2035,21 -1250,18 +2035,21 @@@ static int mov_write_dref_tag(AVIOConte
      avio_wb32(pb, 1); /* entry count */
  
      avio_wb32(pb, 0xc); /* size */
 +    //FIXME add the alis and rsrc atom
      ffio_wfourcc(pb, "url ");
      avio_wb32(pb, 1); /* version & flags */
  
      return 28;
  }
  
 -static int mov_write_stbl_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
 +static int mov_write_stbl_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
  {
      int64_t pos = avio_tell(pb);
 +    int ret;
 +
      avio_wb32(pb, 0); /* size */
      ffio_wfourcc(pb, "stbl");
 -    mov_write_stsd_tag(s, pb, track);
 +    mov_write_stsd_tag(s, pb, mov, track);
      mov_write_stts_tag(pb, track);
      if ((track->par->codec_type == AVMEDIA_TYPE_VIDEO ||
           track->par->codec_tag == MKTAG('r','t','p',' ')) &&
      if (track->mode == MODE_MOV && track->flags & MOV_TRACK_STPS)
          mov_write_stss_tag(pb, track, MOV_PARTIAL_SYNC_SAMPLE);
      if (track->par->codec_type == AVMEDIA_TYPE_VIDEO &&
 -        track->flags & MOV_TRACK_CTTS && track->entry)
 -        mov_write_ctts_tag(pb, track);
 +        track->flags & MOV_TRACK_CTTS && track->entry) {
 +
 +        if ((ret = mov_write_ctts_tag(pb, track)) < 0)
 +            return ret;
 +    }
      mov_write_stsc_tag(pb, track);
      mov_write_stsz_tag(pb, track);
      mov_write_stco_tag(pb, track);
 +    if (mov->encryption_scheme == MOV_ENC_CENC_AES_CTR) {
 +        ff_mov_cenc_write_stbl_atoms(&track->cenc, pb);
 +    }
      return update_size(pb, pos);
  }
  
@@@ -2089,32 -1295,9 +2089,32 @@@ static int mov_write_nmhd_tag(AVIOConte
      return 12;
  }
  
 -static int mov_write_gmhd_tag(AVIOContext *pb)
 +static int mov_write_tcmi_tag(AVIOContext *pb, MOVTrack *track)
  {
 -    avio_wb32(pb, 0x20);   /* size */
 +    int64_t pos = avio_tell(pb);
 +    const char *font = "Lucida Grande";
 +    avio_wb32(pb, 0);                   /* size */
 +    ffio_wfourcc(pb, "tcmi");           /* timecode media information atom */
 +    avio_wb32(pb, 0);                   /* version & flags */
 +    avio_wb16(pb, 0);                   /* text font */
 +    avio_wb16(pb, 0);                   /* text face */
 +    avio_wb16(pb, 12);                  /* text size */
 +    avio_wb16(pb, 0);                   /* (unknown, not in the QT specs...) */
 +    avio_wb16(pb, 0x0000);              /* text color (red) */
 +    avio_wb16(pb, 0x0000);              /* text color (green) */
 +    avio_wb16(pb, 0x0000);              /* text color (blue) */
 +    avio_wb16(pb, 0xffff);              /* background color (red) */
 +    avio_wb16(pb, 0xffff);              /* background color (green) */
 +    avio_wb16(pb, 0xffff);              /* background color (blue) */
 +    avio_w8(pb, strlen(font));          /* font len (part of the pascal string) */
 +    avio_write(pb, font, strlen(font)); /* font name */
 +    return update_size(pb, pos);
 +}
 +
 +static int mov_write_gmhd_tag(AVIOContext *pb, MOVTrack *track)
 +{
 +    int64_t pos = avio_tell(pb);
 +    avio_wb32(pb, 0);      /* size */
      ffio_wfourcc(pb, "gmhd");
      avio_wb32(pb, 0x18);   /* gmin size */
      ffio_wfourcc(pb, "gmin");/* generic media info */
      avio_wb16(pb, 0x8000); /* opColor (b?) */
      avio_wb16(pb, 0);      /* balance */
      avio_wb16(pb, 0);      /* reserved */
 -    return 0x20;
 +
 +    /*
 +     * This special text atom is required for
 +     * Apple Quicktime chapters. The contents
 +     * don't appear to be documented, so the
 +     * bytes are copied verbatim.
 +     */
 +    if (track->tag != MKTAG('c','6','0','8')) {
 +    avio_wb32(pb, 0x2C);   /* size */
 +    ffio_wfourcc(pb, "text");
 +    avio_wb16(pb, 0x01);
 +    avio_wb32(pb, 0x00);
 +    avio_wb32(pb, 0x00);
 +    avio_wb32(pb, 0x00);
 +    avio_wb32(pb, 0x01);
 +    avio_wb32(pb, 0x00);
 +    avio_wb32(pb, 0x00);
 +    avio_wb32(pb, 0x00);
 +    avio_wb32(pb, 0x00004000);
 +    avio_wb16(pb, 0x0000);
 +    }
 +
 +    if (track->par->codec_tag == MKTAG('t','m','c','d')) {
 +        int64_t tmcd_pos = avio_tell(pb);
 +        avio_wb32(pb, 0); /* size */
 +        ffio_wfourcc(pb, "tmcd");
 +        mov_write_tcmi_tag(pb, track);
 +        update_size(pb, tmcd_pos);
 +    }
 +    return update_size(pb, pos);
  }
  
  static int mov_write_smhd_tag(AVIOContext *pb)
@@@ -2200,19 -1354,16 +2200,19 @@@ static int mov_write_hdlr_tag(AVFormatC
              hdlr_type = "soun";
              descr     = "SoundHandler";
          } else if (track->par->codec_type == AVMEDIA_TYPE_SUBTITLE) {
 -            if (track->tag == MKTAG('t','x','3','g')) {
 -                hdlr_type = "sbtl";
 -            } else if (track->tag == MKTAG('m','p','4','s')) {
 -                hdlr_type = "subp";
 -            } else if (is_clcp_track(track)) {
 +            if (is_clcp_track(track)) {
                  hdlr_type = "clcp";
 +                descr = "ClosedCaptionHandler";
              } else {
 -                hdlr_type = "text";
 -            }
 +                if (track->tag == MKTAG('t','x','3','g')) {
 +                    hdlr_type = "sbtl";
 +                } else if (track->tag == MKTAG('m','p','4','s')) {
 +                    hdlr_type = "subp";
 +                } else {
 +                    hdlr_type = "text";
 +                }
              descr = "SubtitleHandler";
 +            }
          } else if (track->par->codec_tag == MKTAG('r','t','p',' ')) {
              hdlr_type = "hint";
              descr     = "HintHandler";
@@@ -2270,11 -1421,9 +2270,11 @@@ static int mov_write_hmhd_tag(AVIOConte
      return 28;
  }
  
 -static int mov_write_minf_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
 +static int mov_write_minf_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
  {
      int64_t pos = avio_tell(pb);
 +    int ret;
 +
      avio_wb32(pb, 0); /* size */
      ffio_wfourcc(pb, "minf");
      if (track->par->codec_type == AVMEDIA_TYPE_VIDEO)
          mov_write_smhd_tag(pb);
      else if (track->par->codec_type == AVMEDIA_TYPE_SUBTITLE) {
          if (track->tag == MKTAG('t','e','x','t') || is_clcp_track(track)) {
 -            mov_write_gmhd_tag(pb);
 +            mov_write_gmhd_tag(pb, track);
          } else {
              mov_write_nmhd_tag(pb);
          }
      } else if (track->tag == MKTAG('r','t','p',' ')) {
          mov_write_hmhd_tag(pb);
      } else if (track->tag == MKTAG('t','m','c','d')) {
 -        mov_write_gmhd_tag(pb);
 +        if (track->mode == MODE_MP4)
 +            mov_write_nmhd_tag(pb);
 +        else
 +            mov_write_gmhd_tag(pb, track);
      }
      if (track->mode == MODE_MOV) /* FIXME: Why do it for MODE_MOV only ? */
          mov_write_hdlr_tag(s, pb, NULL);
      mov_write_dinf_tag(pb);
 -    mov_write_stbl_tag(s, pb, track);
 +    if ((ret = mov_write_stbl_tag(s, pb, mov, track)) < 0)
 +        return ret;
      return update_size(pb, pos);
  }
  
@@@ -2346,35 -1491,14 +2346,35 @@@ static int mov_write_mdia_tag(AVFormatC
                                MOVMuxContext *mov, MOVTrack *track)
  {
      int64_t pos = avio_tell(pb);
 +    int ret;
 +
      avio_wb32(pb, 0); /* size */
      ffio_wfourcc(pb, "mdia");
      mov_write_mdhd_tag(pb, mov, track);
      mov_write_hdlr_tag(s, pb, track);
 -    mov_write_minf_tag(s, pb, track);
 +    if ((ret = mov_write_minf_tag(s, pb, mov, track)) < 0)
 +        return ret;
      return update_size(pb, pos);
  }
  
 +/* transformation matrix
 +     |a  b  u|
 +     |c  d  v|
 +     |tx ty w| */
 +static void write_matrix(AVIOContext *pb, int16_t a, int16_t b, int16_t c,
 +                         int16_t d, int16_t tx, int16_t ty)
 +{
 +    avio_wb32(pb, a << 16);  /* 16.16 format */
 +    avio_wb32(pb, b << 16);  /* 16.16 format */
 +    avio_wb32(pb, 0);        /* u in 2.30 format */
 +    avio_wb32(pb, c << 16);  /* 16.16 format */
 +    avio_wb32(pb, d << 16);  /* 16.16 format */
 +    avio_wb32(pb, 0);        /* v in 2.30 format */
 +    avio_wb32(pb, tx << 16); /* 16.16 format */
 +    avio_wb32(pb, ty << 16); /* 16.16 format */
 +    avio_wb32(pb, 1 << 30);  /* w in 2.30 format */
 +}
 +
  static int mov_write_tkhd_tag(AVIOContext *pb, MOVMuxContext *mov,
                                MOVTrack *track, AVStream *st)
  {
                                        track->timescale, AV_ROUND_UP);
      int version = duration < INT32_MAX ? 0 : 1;
      int flags   = MOV_TKHD_FLAG_IN_MOVIE;
 +    int rotation = 0;
      int group   = 0;
  
      uint32_t *display_matrix = NULL;
      avio_wb16(pb, 0); /* reserved */
  
      /* Matrix structure */
 +    if (st && st->metadata) {
 +        AVDictionaryEntry *rot = av_dict_get(st->metadata, "rotate", NULL, 0);
 +        rotation = (rot && rot->value) ? atoi(rot->value) : 0;
 +    }
      if (display_matrix) {
          for (i = 0; i < 9; i++)
              avio_wb32(pb, display_matrix[i]);
 +    } else if (rotation == 90) {
 +        write_matrix(pb,  0,  1, -1,  0, track->par->height, 0);
 +    } else if (rotation == 180) {
 +        write_matrix(pb, -1,  0,  0, -1, track->par->width, track->par->height);
 +    } else if (rotation == 270) {
 +        write_matrix(pb,  0, -1,  1,  0, 0, track->par->width);
      } else {
 -        avio_wb32(pb, 0x00010000); /* reserved */
 -        avio_wb32(pb, 0x0); /* reserved */
 -        avio_wb32(pb, 0x0); /* reserved */
 -        avio_wb32(pb, 0x0); /* reserved */
 -        avio_wb32(pb, 0x00010000); /* reserved */
 -        avio_wb32(pb, 0x0); /* reserved */
 -        avio_wb32(pb, 0x0); /* reserved */
 -        avio_wb32(pb, 0x0); /* reserved */
 -        avio_wb32(pb, 0x40000000); /* reserved */
 +        write_matrix(pb,  1,  0,  0,  1, 0, 0);
      }
 -
      /* Track width and height, for visual only */
      if (st && (track->par->codec_type == AVMEDIA_TYPE_VIDEO ||
                 track->par->codec_type == AVMEDIA_TYPE_SUBTITLE)) {
 +        int64_t track_width_1616;
          if (track->mode == MODE_MOV) {
 -            avio_wb32(pb, track->par->width << 16);
 -            avio_wb32(pb, track->height << 16);
 +            track_width_1616 = track->par->width * 0x10000ULL;
          } else {
 -            double sample_aspect_ratio = av_q2d(st->sample_aspect_ratio);
 -            if (!sample_aspect_ratio || track->height != track->par->height)
 -                sample_aspect_ratio = 1;
 -            avio_wb32(pb, sample_aspect_ratio * track->par->width * 0x10000);
 -            avio_wb32(pb, track->height * 0x10000);
 +            track_width_1616 = av_rescale(st->sample_aspect_ratio.num,
 +                                                  track->par->width * 0x10000LL,
 +                                                  st->sample_aspect_ratio.den);
 +            if (!track_width_1616 ||
 +                track->height != track->par->height ||
 +                track_width_1616 > UINT32_MAX)
 +                track_width_1616 = track->par->width * 0x10000ULL;
 +        }
 +        if (track_width_1616 > UINT32_MAX) {
 +            av_log(mov->fc, AV_LOG_WARNING, "track width is too large\n");
 +            track_width_1616 = 0;
          }
 +        avio_wb32(pb, track_width_1616);
 +        if (track->height > 0xFFFF) {
 +            av_log(mov->fc, AV_LOG_WARNING, "track height is too large\n");
 +            avio_wb32(pb, 0);
 +        } else
 +            avio_wb32(pb, track->height * 0x10000U);
      } else {
          avio_wb32(pb, 0);
          avio_wb32(pb, 0);
@@@ -2526,21 -1636,7 +2526,21 @@@ static int mov_write_edts_tag(AVIOConte
      int version = duration < INT32_MAX ? 0 : 1;
      int entry_size, entry_count, size;
      int64_t delay, start_ct = track->start_cts;
 -    delay = av_rescale_rnd(track->start_dts + start_ct, MOV_TIMESCALE,
 +    int64_t start_dts = track->start_dts;
 +
 +    if (track->entry) {
 +        if (start_dts != track->cluster[0].dts || start_ct != track->cluster[0].cts) {
 +
 +            av_log(mov->fc, AV_LOG_DEBUG,
 +                   "EDTS using dts:%"PRId64" cts:%d instead of dts:%"PRId64" cts:%"PRId64" tid:%d\n",
 +                   track->cluster[0].dts, track->cluster[0].cts,
 +                   start_dts, start_ct, track->track_id);
 +            start_dts = track->cluster[0].dts;
 +            start_ct  = track->cluster[0].cts;
 +        }
 +    }
 +
 +    delay = av_rescale_rnd(start_dts + start_ct, MOV_TIMESCALE,
                             track->timescale, AV_ROUND_DOWN);
      version |= delay < INT32_MAX ? 0 : 1;
  
      } else {
          /* Avoid accidentally ending up with start_ct = -1 which has got a
           * special meaning. Normally start_ct should end up positive or zero
 -         * here, but use FFMIN in case dts is a small positive integer
 +         * here, but use FFMIN in case dts is a small positive integer
           * rounded to 0 when represented in MOV_TIMESCALE units. */
 -        start_ct  = -FFMIN(track->start_dts, 0);
 +        av_assert0(av_rescale_rnd(start_dts, MOV_TIMESCALE, track->timescale, AV_ROUND_DOWN) <= 0);
 +        start_ct  = -FFMIN(start_dts, 0);
          /* Note, this delay is calculated from the pts of the first sample,
           * ensuring that we don't reduce the duration for cases with
           * dts<0 pts=0. */
@@@ -2694,38 -1789,31 +2694,38 @@@ static int mov_write_track_udta_tag(AVI
      return 0;
  }
  
 -static int mov_write_trak_tag(AVIOContext *pb, MOVMuxContext *mov,
 +static int mov_write_trak_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov,
                                MOVTrack *track, AVStream *st)
  {
      int64_t pos = avio_tell(pb);
      int entry_backup = track->entry;
 +    int chunk_backup = track->chunkCount;
 +    int ret;
 +
      /* If we want to have an empty moov, but some samples already have been
       * buffered (delay_moov), pretend that no samples have been written yet. */
      if (mov->flags & FF_MOV_FLAG_EMPTY_MOOV)
 -        track->entry = 0;
 +        track->chunkCount = track->entry = 0;
  
      avio_wb32(pb, 0); /* size */
      ffio_wfourcc(pb, "trak");
      mov_write_tkhd_tag(pb, mov, track, st);
 -    if (track->start_dts != AV_NOPTS_VALUE &&
 -        (track->mode == MODE_PSP || track->flags & MOV_TRACK_CTTS ||
 -        track->start_dts || is_clcp_track(track))) {
 +
 +    av_assert2(mov->use_editlist >= 0);
 +
 +    if (track->start_dts != AV_NOPTS_VALUE) {
          if (mov->use_editlist)
 -            mov_write_edts_tag(pb, mov, track);  // PSP Movies require edts box
 +            mov_write_edts_tag(pb, mov, track);  // PSP Movies and several other cases require edts box
          else if ((track->entry && track->cluster[0].dts) || track->mode == MODE_PSP || is_clcp_track(track))
              av_log(mov->fc, AV_LOG_WARNING,
                     "Not writing any edit list even though one would have been required\n");
      }
 +
      if (track->tref_tag)
          mov_write_tref_tag(pb, track);
 -    mov_write_mdia_tag(mov->fc, pb, mov, track);
 +
 +    if ((ret = mov_write_mdia_tag(s, pb, mov, track)) < 0)
 +        return ret;
      if (track->mode == MODE_PSP)
          mov_write_uuid_tag_psp(pb, track); // PSP Movies require this uuid box
      if (track->tag == MKTAG('r','t','p',' '))
      if (track->mode == MODE_MOV) {
          if (track->par->codec_type == AVMEDIA_TYPE_VIDEO) {
              double sample_aspect_ratio = av_q2d(st->sample_aspect_ratio);
 -            if ((0.0 != sample_aspect_ratio && 1.0 != sample_aspect_ratio)) {
 +            if (st->sample_aspect_ratio.num && 1.0 != sample_aspect_ratio) {
                  mov_write_tapt_tag(pb, track);
              }
          }
 -        if (is_clcp_track(track)) {
 +        if (is_clcp_track(track) && st->sample_aspect_ratio.num) {
              mov_write_tapt_tag(pb, track);
          }
      }
      mov_write_track_udta_tag(pb, mov, st);
      track->entry = entry_backup;
 +    track->chunkCount = chunk_backup;
      return update_size(pb, pos);
  }
  
@@@ -2803,12 -1890,12 +2803,12 @@@ static int mov_write_mvex_tag(AVIOConte
  static int mov_write_mvhd_tag(AVIOContext *pb, MOVMuxContext *mov)
  {
      int max_track_id = 1, i;
 -    int64_t max_track_len_temp, max_track_len = 0;
 +    int64_t max_track_len = 0;
      int version;
  
      for (i = 0; i < mov->nb_streams; i++) {
          if (mov->tracks[i].entry > 0 && mov->tracks[i].timescale) {
 -            max_track_len_temp = av_rescale_rnd(mov->tracks[i].track_duration,
 +            int64_t max_track_len_temp = av_rescale_rnd(mov->tracks[i].track_duration,
                                                  MOV_TIMESCALE,
                                                  mov->tracks[i].timescale,
                                                  AV_ROUND_UP);
      }
  
      version = max_track_len < UINT32_MAX ? 0 : 1;
 -    (version == 1) ? avio_wb32(pb, 120) : avio_wb32(pb, 108); /* size */
 +    avio_wb32(pb, version == 1 ? 120 : 108); /* size */
 +
      ffio_wfourcc(pb, "mvhd");
      avio_w8(pb, version);
      avio_wb24(pb, 0); /* flags */
      avio_wb32(pb, 0); /* reserved */
  
      /* Matrix structure */
 -    avio_wb32(pb, 0x00010000); /* reserved */
 -    avio_wb32(pb, 0x0); /* reserved */
 -    avio_wb32(pb, 0x0); /* reserved */
 -    avio_wb32(pb, 0x0); /* reserved */
 -    avio_wb32(pb, 0x00010000); /* reserved */
 -    avio_wb32(pb, 0x0); /* reserved */
 -    avio_wb32(pb, 0x0); /* reserved */
 -    avio_wb32(pb, 0x0); /* reserved */
 -    avio_wb32(pb, 0x40000000); /* reserved */
 +    write_matrix(pb, 1, 0, 0, 1, 0, 0);
  
      avio_wb32(pb, 0); /* reserved (preview time) */
      avio_wb32(pb, 0); /* reserved (preview duration) */
@@@ -2934,79 -2028,28 +2934,79 @@@ static int mov_write_string_metadata(AV
      return mov_write_string_tag(pb, name, t->value, lang, long_style);
  }
  
 -/* iTunes track number */
 +/* iTunes bpm number */
 +static int mov_write_tmpo_tag(AVIOContext *pb, AVFormatContext *s)
 +{
 +    AVDictionaryEntry *t = av_dict_get(s->metadata, "tmpo", NULL, 0);
 +    int size = 0, tmpo = t ? atoi(t->value) : 0;
 +    if (tmpo) {
 +        size = 26;
 +        avio_wb32(pb, size);
 +        ffio_wfourcc(pb, "tmpo");
 +        avio_wb32(pb, size-8); /* size */
 +        ffio_wfourcc(pb, "data");
 +        avio_wb32(pb, 0x15);  //type specifier
 +        avio_wb32(pb, 0);
 +        avio_wb16(pb, tmpo);        // data
 +    }
 +    return size;
 +}
 +
 +/* iTunes track or disc number */
  static int mov_write_trkn_tag(AVIOContext *pb, MOVMuxContext *mov,
 -                              AVFormatContext *s)
 +                              AVFormatContext *s, int disc)
  {
 -    AVDictionaryEntry *t = av_dict_get(s->metadata, "track", NULL, 0);
 +    AVDictionaryEntry *t = av_dict_get(s->metadata,
 +                                       disc ? "disc" : "track",
 +                                       NULL, 0);
      int size = 0, track = t ? atoi(t->value) : 0;
      if (track) {
 +        int tracks = 0;
 +        char *slash = strchr(t->value, '/');
 +        if (slash)
 +            tracks = atoi(slash + 1);
          avio_wb32(pb, 32); /* size */
 -        ffio_wfourcc(pb, "trkn");
 +        ffio_wfourcc(pb, disc ? "disk" : "trkn");
          avio_wb32(pb, 24); /* size */
          ffio_wfourcc(pb, "data");
          avio_wb32(pb, 0);        // 8 bytes empty
          avio_wb32(pb, 0);
          avio_wb16(pb, 0);        // empty
 -        avio_wb16(pb, track);    // track number
 -        avio_wb16(pb, 0);        // total track number
 +        avio_wb16(pb, track);    // track / disc number
 +        avio_wb16(pb, tracks);   // total track / disc number
          avio_wb16(pb, 0);        // empty
          size = 32;
      }
      return size;
  }
  
 +static int mov_write_int8_metadata(AVFormatContext *s, AVIOContext *pb,
 +                                   const char *name, const char *tag,
 +                                   int len)
 +{
 +    AVDictionaryEntry *t = NULL;
 +    uint8_t num;
 +    int size = 24 + len;
 +
 +    if (len != 1 && len != 4)
 +        return -1;
 +
 +    if (!(t = av_dict_get(s->metadata, tag, NULL, 0)))
 +        return 0;
 +    num = atoi(t->value);
 +
 +    avio_wb32(pb, size);
 +    ffio_wfourcc(pb, name);
 +    avio_wb32(pb, size - 8);
 +    ffio_wfourcc(pb, "data");
 +    avio_wb32(pb, 0x15);
 +    avio_wb32(pb, 0);
 +    if (len==4) avio_wb32(pb, num);
 +    else        avio_w8 (pb, num);
 +
 +    return size;
 +}
 +
  /* iTunes meta data list */
  static int mov_write_ilst_tag(AVIOContext *pb, MOVMuxContext *mov,
                                AVFormatContext *s)
      mov_write_string_metadata(s, pb, "tvsh",    "show"     , 1);
      mov_write_string_metadata(s, pb, "tven",    "episode_id",1);
      mov_write_string_metadata(s, pb, "tvnn",    "network"  , 1);
 -    mov_write_trkn_tag(pb, mov, s);
 +    mov_write_int8_metadata  (s, pb, "tves",    "episode_sort",4);
 +    mov_write_int8_metadata  (s, pb, "tvsn",    "season_number",4);
 +    mov_write_int8_metadata  (s, pb, "stik",    "media_type",1);
 +    mov_write_int8_metadata  (s, pb, "hdvd",    "hd_video",  1);
 +    mov_write_int8_metadata  (s, pb, "pgap",    "gapless_playback",1);
 +    mov_write_int8_metadata  (s, pb, "cpil",    "compilation", 1);
 +    mov_write_trkn_tag(pb, mov, s, 0); // track number
 +    mov_write_trkn_tag(pb, mov, s, 1); // disc number
 +    mov_write_tmpo_tag(pb, s);
      return update_size(pb, pos);
  }
  
@@@ -3061,26 -2096,6 +3061,26 @@@ static int mov_write_meta_tag(AVIOConte
      return size;
  }
  
 +static int mov_write_raw_metadata_tag(AVFormatContext *s, AVIOContext *pb,
 +                                      const char *name, const char *key)
 +{
 +    int len;
 +    AVDictionaryEntry *t;
 +
 +    if (!(t = av_dict_get(s->metadata, key, NULL, 0)))
 +        return 0;
 +
 +    len = strlen(t->value);
 +    if (len > 0) {
 +        int size = len + 8;
 +        avio_wb32(pb, size);
 +        ffio_wfourcc(pb, name);
 +        avio_write(pb, t->value, len);
 +        return size;
 +    }
 +    return 0;
 +}
 +
  static int ascii_to_wc(AVIOContext *pb, const uint8_t *b)
  {
      int val;
@@@ -3173,17 -2188,13 +3173,17 @@@ static int mov_write_udta_tag(AVIOConte
          mov_write_string_metadata(s, pb_buf, "\251aut", "author",      0);
          mov_write_string_metadata(s, pb_buf, "\251alb", "album",       0);
          mov_write_string_metadata(s, pb_buf, "\251day", "date",        0);
 -        if (!(s->flags & AVFMT_FLAG_BITEXACT))
 -            mov_write_string_metadata(s, pb_buf, "\251swr", "encoder", 0);
 +        mov_write_string_metadata(s, pb_buf, "\251swr", "encoder",     0);
 +        // currently ignored by mov.c
          mov_write_string_metadata(s, pb_buf, "\251des", "comment",     0);
 +        // add support for libquicktime, this atom is also actually read by mov.c
 +        mov_write_string_metadata(s, pb_buf, "\251cmt", "comment",     0);
          mov_write_string_metadata(s, pb_buf, "\251gen", "genre",       0);
          mov_write_string_metadata(s, pb_buf, "\251cpy", "copyright",   0);
          mov_write_string_metadata(s, pb_buf, "\251mak", "make",        0);
          mov_write_string_metadata(s, pb_buf, "\251mod", "model",       0);
 +        mov_write_string_metadata(s, pb_buf, "\251xyz", "location",    0);
 +        mov_write_raw_metadata_tag(s, pb_buf, "XMP_", "xmp");
      } else {
          /* iTunes meta data */
          mov_write_meta_tag(pb_buf, mov, s);
@@@ -3241,8 -2252,7 +3241,8 @@@ static int mov_write_uuidusmt_tag(AVIOC
          avio_wb16(pb, 0x0);                  /* ? */
          avio_wb16(pb, 0x021C);               /* data */
  
 -        mov_write_psp_udta_tag(pb, LIBAVCODEC_IDENT,      "eng", 0x04);
 +        if (!(s->flags & AVFMT_FLAG_BITEXACT))
 +            mov_write_psp_udta_tag(pb, LIBAVCODEC_IDENT,      "eng", 0x04);
          mov_write_psp_udta_tag(pb, title->value,          "eng", 0x01);
          mov_write_psp_udta_tag(pb, "2006/04/01 11:11:11", "und", 0x03);
  
      return 0;
  }
  
 +static void build_chunks(MOVTrack *trk)
 +{
 +    int i;
 +    MOVIentry *chunk = &trk->cluster[0];
 +    uint64_t chunkSize = chunk->size;
 +    chunk->chunkNum = 1;
 +    if (trk->chunkCount)
 +        return;
 +    trk->chunkCount = 1;
 +    for (i = 1; i<trk->entry; i++){
 +        if (chunk->pos + chunkSize == trk->cluster[i].pos &&
 +            chunkSize + trk->cluster[i].size < (1<<20)){
 +            chunkSize             += trk->cluster[i].size;
 +            chunk->samples_in_chunk += trk->cluster[i].entries;
 +        } else {
 +            trk->cluster[i].chunkNum = chunk->chunkNum+1;
 +            chunk=&trk->cluster[i];
 +            chunkSize = chunk->size;
 +            trk->chunkCount++;
 +        }
 +    }
 +}
 +
  static int mov_write_moov_tag(AVIOContext *pb, MOVMuxContext *mov,
                                AVFormatContext *s)
  {
  
          mov->tracks[i].time     = mov->time;
          mov->tracks[i].track_id = i + 1;
 +
 +        if (mov->tracks[i].entry)
 +            build_chunks(&mov->tracks[i]);
      }
  
      if (mov->chapter_track)
              }
          }
      }
 +    for (i = 0; i < mov->nb_streams; i++) {
 +        if (mov->tracks[i].tag == MKTAG('t','m','c','d')) {
 +            int src_trk = mov->tracks[i].src_track;
 +            mov->tracks[src_trk].tref_tag = mov->tracks[i].tag;
 +            mov->tracks[src_trk].tref_id  = mov->tracks[i].track_id;
 +            //src_trk may have a different timescale than the tmcd track
 +            mov->tracks[i].track_duration = av_rescale(mov->tracks[src_trk].track_duration,
 +                                                       mov->tracks[i].timescale,
 +                                                       mov->tracks[src_trk].timescale);
 +        }
 +    }
  
      mov_write_mvhd_tag(pb, mov);
      if (mov->mode != MODE_MOV && !mov->iods_skip)
          mov_write_iods_tag(pb, mov);
      for (i = 0; i < mov->nb_streams; i++) {
          if (mov->tracks[i].entry > 0 || mov->flags & FF_MOV_FLAG_FRAGMENT) {
 -            mov_write_trak_tag(pb, mov, &(mov->tracks[i]), i < s->nb_streams ? s->streams[i] : NULL);
 +            int ret = mov_write_trak_tag(s, pb, mov, &(mov->tracks[i]), i < s->nb_streams ? s->streams[i] : NULL);
 +            if (ret < 0)
 +                return ret;
          }
      }
      if (mov->flags & FF_MOV_FLAG_FRAGMENT)
@@@ -3387,8 -2358,7 +3387,8 @@@ static int mov_write_isml_manifest(AVIO
      avio_printf(pb, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
      avio_printf(pb, "<smil xmlns=\"http://www.w3.org/2001/SMIL20/Language\">\n");
      avio_printf(pb, "<head>\n");
 -    avio_printf(pb, "<meta name=\"creator\" content=\"%s\" />\n",
 +    if (!(mov->fc->flags & AVFMT_FLAG_BITEXACT))
 +        avio_printf(pb, "<meta name=\"creator\" content=\"%s\" />\n",
                      LIBAVFORMAT_IDENT);
      avio_printf(pb, "</head>\n");
      avio_printf(pb, "<body>\n");
          } else {
              continue;
          }
 -        avio_printf(pb, "<%s systemBitrate=\"%d\">\n", type,
 -                                                       track->par->bit_rate);
 +        avio_printf(pb, "<%s systemBitrate=\"%"PRId64"\">\n", type,
 +                    (int64_t)track->par->bit_rate);
          param_write_int(pb, "systemBitrate", track->par->bit_rate);
          param_write_int(pb, "trackID", track_id);
          if (track->par->codec_type == AVMEDIA_TYPE_VIDEO) {
              param_write_int(pb, "DisplayHeight", track->par->height);
          } else {
              if (track->par->codec_id == AV_CODEC_ID_AAC) {
 -                param_write_string(pb, "FourCC", "AACL");
 +                switch (track->par->profile)
 +                {
 +                    case FF_PROFILE_AAC_HE_V2:
 +                        param_write_string(pb, "FourCC", "AACP");
 +                        break;
 +                    case FF_PROFILE_AAC_HE:
 +                        param_write_string(pb, "FourCC", "AACH");
 +                        break;
 +                    default:
 +                        param_write_string(pb, "FourCC", "AACL");
 +                }
              } else if (track->par->codec_id == AV_CODEC_ID_WMAPRO) {
                  param_write_string(pb, "FourCC", "WMAP");
              }
@@@ -3645,7 -2605,8 +3645,7 @@@ static int mov_write_tfrf_tag(AVIOConte
          int free_size = 16 * (mov->ism_lookahead - n);
          avio_wb32(pb, free_size);
          ffio_wfourcc(pb, "free");
 -        for (i = 0; i < free_size - 8; i++)
 -            avio_w8(pb, 0);
 +        ffio_fill(pb, 0, free_size - 8);
      }
  
      return 0;
@@@ -4099,22 -3060,9 +4099,22 @@@ static void mov_write_uuidprof_tag(AVIO
  static int mov_write_identification(AVIOContext *pb, AVFormatContext *s)
  {
      MOVMuxContext *mov = s->priv_data;
 +    int i;
 +
      mov_write_ftyp_tag(pb,s);
      if (mov->mode == MODE_PSP) {
 -        if (s->nb_streams != 2) {
 +        int video_streams_nb = 0, audio_streams_nb = 0, other_streams_nb = 0;
 +        for (i = 0; i < s->nb_streams; i++) {
 +            AVStream *st = s->streams[i];
 +            if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
 +                video_streams_nb++;
 +            else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
 +                audio_streams_nb++;
 +            else
 +                other_streams_nb++;
 +            }
 +
 +        if (video_streams_nb != 1 || audio_streams_nb != 1 || other_streams_nb) {
              av_log(s, AV_LOG_ERROR, "PSP mode need one video and one audio stream\n");
              return AVERROR(EINVAL);
          }
@@@ -4235,12 -3183,30 +4235,31 @@@ static int mov_flush_fragment(AVFormatC
      MOVMuxContext *mov = s->priv_data;
      int i, first_track = -1;
      int64_t mdat_size = 0;
 +    int ret;
      int has_video = 0, starts_with_key = 0, first_video_track = 1;
  
      if (!(mov->flags & FF_MOV_FLAG_FRAGMENT))
          return 0;
  
+     // Try to fill in the duration of the last packet in each stream
+     // from queued packets in the interleave queues. If the flushing
+     // of fragments was triggered automatically by an AVPacket, we
+     // already have reliable info for the end of that track, but other
+     // tracks may need to be filled in.
+     for (i = 0; i < s->nb_streams; i++) {
+         MOVTrack *track = &mov->tracks[i];
+         if (!track->end_reliable) {
+             AVPacket *next = ff_interleaved_peek(s, i);
+             if (next) {
+                 track->track_duration = next->dts - track->start_dts;
+                 if (next->pts != AV_NOPTS_VALUE)
+                     track->end_pts = next->pts;
+                 else
+                     track->end_pts = next->dts;
+             }
+         }
+     }
      for (i = 0; i < mov->nb_streams; i++) {
          MOVTrack *track = &mov->tracks[i];
          if (track->entry <= 1)
  
      if (!mov->moov_written) {
          int64_t pos = avio_tell(s->pb);
 -        int ret;
 -        AVIOContext *moov_buf;
          uint8_t *buf;
 -        int buf_size;
 +        int buf_size, moov_size;
  
          for (i = 0; i < mov->nb_streams; i++)
              if (!mov->tracks[i].entry)
          if (i < mov->nb_streams && !force)
              return 0;
  
 -        if ((ret = ffio_open_null_buf(&moov_buf)) < 0)
 -            return ret;
 -        mov_write_moov_tag(moov_buf, mov, s);
 -        buf_size = ffio_close_null_buf(moov_buf);
 +        moov_size = get_moov_size(s);
          for (i = 0; i < mov->nb_streams; i++)
 -            mov->tracks[i].data_offset = pos + buf_size + 8;
 +            mov->tracks[i].data_offset = pos + moov_size + 8;
  
          avio_write_marker(s->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_HEADER);
          if (mov->flags & FF_MOV_FLAG_DELAY_MOOV)
              mov_write_identification(s->pb, s);
 -        mov_write_moov_tag(s->pb, mov, s);
 +        if ((ret = mov_write_moov_tag(s->pb, mov, s)) < 0)
 +            return ret;
  
          if (mov->flags & FF_MOV_FLAG_DELAY_MOOV) {
              if (mov->flags & FF_MOV_FLAG_GLOBAL_SIDX)
                                               mov->tracks[i].track_duration -
                                               mov->tracks[i].cluster[0].dts;
              mov->tracks[i].entry = 0;
+             mov->tracks[i].end_reliable = 0;
          }
          avio_flush(s->pb);
          return 0;
              track->frag_start += duration;
          track->entry = 0;
          track->entries_flushed = 0;
+         track->end_reliable = 0;
          if (!mov->frag_interleave) {
              if (!track->mdat_buf)
                  continue;
@@@ -4441,21 -3413,6 +4462,21 @@@ int ff_mov_write_packet(AVFormatContex
      int size = pkt->size, ret = 0;
      uint8_t *reformatted_data = NULL;
  
 +    if (trk->entry) {
 +        int64_t duration = pkt->dts - trk->cluster[trk->entry - 1].dts;
 +        if (duration < 0 || duration > INT_MAX) {
 +            av_log(s, AV_LOG_ERROR, "Application provided duration: %"PRId64" / timestamp: %"PRId64" is out of range for mov/mp4 format\n",
 +                duration, pkt->dts
 +            );
 +
 +            pkt->dts = trk->cluster[trk->entry - 1].dts + 1;
 +            pkt->pts = AV_NOPTS_VALUE;
 +        }
 +    }
 +    if (pkt->duration < 0 || pkt->duration > INT_MAX) {
 +        av_log(s, AV_LOG_ERROR, "Application provided duration: %"PRId64" is invalid\n", pkt->duration);
 +        return AVERROR(EINVAL);
 +    }
      if (mov->flags & FF_MOV_FLAG_FRAGMENT) {
          int ret;
          if (mov->moov_written || mov->flags & FF_MOV_FLAG_EMPTY_MOOV) {
  
      if (par->codec_id == AV_CODEC_ID_AMR_NB) {
          /* We must find out how many AMR blocks there are in one packet */
 -        static uint16_t packed_size[16] =
 +        static const uint16_t packed_size[16] =
              {13, 14, 16, 18, 20, 21, 27, 32, 6, 0, 0, 0, 0, 0, 0, 1};
          int len = 0;
  
              av_log(s, AV_LOG_ERROR, "fatal error, input is not a single packet, implement a AVParser for it\n");
              return -1;
          }
 +    } else if (par->codec_id == AV_CODEC_ID_ADPCM_MS ||
 +               par->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) {
 +        samples_in_chunk = trk->par->frame_size;
      } else if (trk->sample_size)
          samples_in_chunk = size / trk->sample_size;
      else
          samples_in_chunk = 1;
  
      /* copy extradata if it exists */
 -    if (trk->vos_len == 0 && par->extradata_size > 0) {
 +    if (trk->vos_len == 0 && par->extradata_size > 0 &&
 +        !TAG_IS_AVCI(trk->tag) &&
 +        (par->codec_id != AV_CODEC_ID_DNXHD)) {
          trk->vos_len  = par->extradata_size;
          trk->vos_data = av_malloc(trk->vos_len);
          if (!trk->vos_data) {
          memcpy(trk->vos_data, par->extradata, trk->vos_len);
      }
  
 -    if (par->codec_id == AV_CODEC_ID_H264 && trk->vos_len > 0 && *(uint8_t *)trk->vos_data != 1) {
 +    if (par->codec_id == AV_CODEC_ID_AAC && pkt->size > 2 &&
 +        (AV_RB16(pkt->data) & 0xfff0) == 0xfff0) {
 +        if (!s->streams[pkt->stream_index]->nb_frames) {
 +            av_log(s, AV_LOG_ERROR, "Malformed AAC bitstream detected: "
 +                   "use the audio bitstream filter 'aac_adtstoasc' to fix it "
 +                   "('-bsf:a aac_adtstoasc' option with ffmpeg)\n");
 +            return -1;
 +        }
 +        av_log(s, AV_LOG_WARNING, "aac bitstream error\n");
 +    }
 +    if (par->codec_id == AV_CODEC_ID_H264 && trk->vos_len > 0 && *(uint8_t *)trk->vos_data != 1 && !TAG_IS_AVCI(trk->tag)) {
          /* from x264 or from bytestream H.264 */
          /* NAL reformatting needed */
          if (trk->hint_track >= 0 && trk->hint_track < mov->nb_streams) {
                                         &size);
              avio_write(pb, reformatted_data, size);
          } else {
 -            size = ff_avc_parse_nal_units(pb, pkt->data, pkt->size);
 +            if (mov->encryption_scheme == MOV_ENC_CENC_AES_CTR) {
 +                size = ff_mov_cenc_avc_parse_nal_units(&trk->cenc, pb, pkt->data, size);
 +                if (size < 0) {
 +                    ret = size;
 +                    goto err;
 +                }
 +            } else {
 +                size = ff_avc_parse_nal_units(pb, pkt->data, pkt->size);
 +            }
          }
      } else if (par->codec_id == AV_CODEC_ID_HEVC && trk->vos_len > 6 &&
                 (AV_RB24(trk->vos_data) == 1 || AV_RB32(trk->vos_data) == 1)) {
          } else {
              size = ff_hevc_annexb2mp4(pb, pkt->data, pkt->size, 0, NULL);
          }
 -    } else {
 +#if CONFIG_AC3_PARSER
 +    } else if (par->codec_id == AV_CODEC_ID_EAC3) {
 +        size = handle_eac3(mov, pkt, trk);
 +        if (size < 0)
 +            return size;
 +        else if (!size)
 +            goto end;
          avio_write(pb, pkt->data, size);
 +#endif
 +    } else {
 +        if (mov->encryption_scheme == MOV_ENC_CENC_AES_CTR) {
 +            if (par->codec_id == AV_CODEC_ID_H264 && par->extradata_size > 4) {
 +                int nal_size_length = (par->extradata[4] & 0x3) + 1;
 +                ret = ff_mov_cenc_avc_write_nal_units(s, &trk->cenc, nal_size_length, pb, pkt->data, size);
 +            } else {
 +                ret = ff_mov_cenc_write_packet(&trk->cenc, pb, pkt->data, size);
 +            }
 +
 +            if (ret) {
 +                goto err;
 +            }
 +        } else {
 +            avio_write(pb, pkt->data, size);
 +        }
      }
  
      if ((par->codec_id == AV_CODEC_ID_DNXHD ||
  
      trk->cluster[trk->entry].pos              = avio_tell(pb) - size;
      trk->cluster[trk->entry].samples_in_chunk = samples_in_chunk;
 +    trk->cluster[trk->entry].chunkNum         = 0;
      trk->cluster[trk->entry].size             = size;
      trk->cluster[trk->entry].entries          = samples_in_chunk;
      trk->cluster[trk->entry].dts              = pkt->dts;
              trk->frag_discont = 0;
          }
      }
 +
      if (!trk->entry && trk->start_dts == AV_NOPTS_VALUE && !mov->use_editlist &&
          s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO) {
          /* Not using edit lists and shifting the first track to start from zero.
                     pkt->stream_index, pkt->dts);
      }
      trk->track_duration = pkt->dts - trk->start_dts + pkt->duration;
 +    trk->last_sample_is_subtitle_end = 0;
  
      if (pkt->pts == AV_NOPTS_VALUE) {
          av_log(s, AV_LOG_WARNING, "pts has no value\n");
          ff_mov_add_hinted_packet(s, pkt, trk->hint_track, trk->entry,
                                   reformatted_data, size);
  
 +end:
  err:
 +
      av_free(reformatted_data);
      return ret;
  }
  
 -static int mov_write_packet(AVFormatContext *s, AVPacket *pkt)
 +static int mov_write_single_packet(AVFormatContext *s, AVPacket *pkt)
  {
 -    if (!pkt) {
 -        mov_flush_fragment(s, 1);
 -        return 1;
 -    } else {
          MOVMuxContext *mov = s->priv_data;
          MOVTrack *trk = &mov->tracks[pkt->stream_index];
          AVCodecParameters *par = trk->par;
              return 0;             /* Discard 0 sized packets */
          }
  
 -        if (trk->entry)
 +        if (trk->entry && pkt->stream_index < s->nb_streams)
              frag_duration = av_rescale_q(pkt->dts - trk->cluster[0].dts,
                                           s->streams[pkt->stream_index]->time_base,
                                           AV_TIME_BASE_Q);
                      trk->end_pts = pkt->pts;
                  else
                      trk->end_pts = pkt->dts;
+                 trk->end_reliable = 1;
                  mov_auto_flush_fragment(s, 0);
              }
          }
  
          return ff_mov_write_packet(s, pkt);
 +}
 +
 +static int mov_write_subtitle_end_packet(AVFormatContext *s,
 +                                         int stream_index,
 +                                         int64_t dts) {
 +    AVPacket end;
 +    uint8_t data[2] = {0};
 +    int ret;
 +
 +    av_init_packet(&end);
 +    end.size = sizeof(data);
 +    end.data = data;
 +    end.pts = dts;
 +    end.dts = dts;
 +    end.duration = 0;
 +    end.stream_index = stream_index;
 +
 +    ret = mov_write_single_packet(s, &end);
 +    av_packet_unref(&end);
 +
 +    return ret;
 +}
 +
 +static int mov_write_packet(AVFormatContext *s, AVPacket *pkt)
 +{
 +    if (!pkt) {
 +        mov_flush_fragment(s, 1);
 +        return 1;
 +    } else {
 +        int i;
 +        MOVMuxContext *mov = s->priv_data;
 +        MOVTrack *trk = &mov->tracks[pkt->stream_index];
 +
 +        if (!pkt->size)
 +            return mov_write_single_packet(s, pkt); /* Passthrough. */
 +
 +        /*
 +         * Subtitles require special handling.
 +         *
 +         * 1) For full complaince, every track must have a sample at
 +         * dts == 0, which is rarely true for subtitles. So, as soon
 +         * as we see any packet with dts > 0, write an empty subtitle
 +         * at dts == 0 for any subtitle track with no samples in it.
 +         *
 +         * 2) For each subtitle track, check if the current packet's
 +         * dts is past the duration of the last subtitle sample. If
 +         * so, we now need to write an end sample for that subtitle.
 +         *
 +         * This must be done conditionally to allow for subtitles that
 +         * immediately replace each other, in which case an end sample
 +         * is not needed, and is, in fact, actively harmful.
 +         *
 +         * 3) See mov_write_trailer for how the final end sample is
 +         * handled.
 +         */
 +        for (i = 0; i < mov->nb_streams; i++) {
 +            MOVTrack *trk = &mov->tracks[i];
 +            int ret;
 +
 +            if (trk->par->codec_id == AV_CODEC_ID_MOV_TEXT &&
 +                trk->track_duration < pkt->dts &&
 +                (trk->entry == 0 || !trk->last_sample_is_subtitle_end)) {
 +                ret = mov_write_subtitle_end_packet(s, i, trk->track_duration);
 +                if (ret < 0) return ret;
 +                trk->last_sample_is_subtitle_end = 1;
 +            }
 +        }
 +
 +        if (trk->mode == MODE_MOV && trk->par->codec_type == AVMEDIA_TYPE_VIDEO) {
 +            AVPacket *opkt = pkt;
 +            int reshuffle_ret, ret;
 +            if (trk->is_unaligned_qt_rgb) {
 +                int64_t bpc = trk->par->bits_per_coded_sample != 15 ? trk->par->bits_per_coded_sample : 16;
 +                int expected_stride = ((trk->par->width * bpc + 15) >> 4)*2;
 +                reshuffle_ret = ff_reshuffle_raw_rgb(s, &pkt, trk->par, expected_stride);
 +                if (reshuffle_ret < 0)
 +                    return reshuffle_ret;
 +            } else
 +                reshuffle_ret = 0;
 +            if (trk->par->format == AV_PIX_FMT_PAL8 && !trk->pal_done) {
 +                ret = ff_get_packet_palette(s, opkt, reshuffle_ret, trk->palette);
 +                if (ret < 0)
 +                    goto fail;
 +                if (ret)
 +                    trk->pal_done++;
 +            } else if (trk->par->codec_id == AV_CODEC_ID_RAWVIDEO &&
 +                       (trk->par->format == AV_PIX_FMT_GRAY8 ||
 +                       trk->par->format == AV_PIX_FMT_MONOBLACK)) {
 +                for (i = 0; i < pkt->size; i++)
 +                    pkt->data[i] = ~pkt->data[i];
 +            }
 +            if (reshuffle_ret) {
 +                ret = mov_write_single_packet(s, pkt);
 +fail:
 +                if (reshuffle_ret)
 +                    av_packet_free(&pkt);
 +                return ret;
 +            }
 +        }
 +
 +        return mov_write_single_packet(s, pkt);
      }
  }
  
  // as samples, and a tref pointing from the other tracks to the chapter one.
  static int mov_create_chapter_track(AVFormatContext *s, int tracknum)
  {
 +    AVIOContext *pb;
 +
      MOVMuxContext *mov = s->priv_data;
      MOVTrack *track = &mov->tracks[tracknum];
      AVPacket pkt = { .stream_index = tracknum, .flags = AV_PKT_FLAG_KEY };
      int i, len;
 -    // These properties are required to make QT recognize the chapter track
 -    uint8_t chapter_properties[43] = { 0, 0, 0, 0, 0, 0, 0, 1, };
  
      track->mode = mov->mode;
      track->tag = MKTAG('t','e','x','t');
      if (!track->par)
          return AVERROR(ENOMEM);
      track->par->codec_type = AVMEDIA_TYPE_SUBTITLE;
 -    track->par->extradata = av_malloc(sizeof(chapter_properties));
 -    if (!track->par->extradata)
 +#if 0
 +    // These properties are required to make QT recognize the chapter track
 +    uint8_t chapter_properties[43] = { 0, 0, 0, 0, 0, 0, 0, 1, };
 +    if (ff_alloc_extradata(track->par, sizeof(chapter_properties)))
          return AVERROR(ENOMEM);
 -    track->par->extradata_size = sizeof(chapter_properties);
      memcpy(track->par->extradata, chapter_properties, sizeof(chapter_properties));
 +#else
 +    if (avio_open_dyn_buf(&pb) >= 0) {
 +        int size;
 +        uint8_t *buf;
 +
 +        /* Stub header (usually for Quicktime chapter track) */
 +        // TextSampleEntry
 +        avio_wb32(pb, 0x01); // displayFlags
 +        avio_w8(pb, 0x00);   // horizontal justification
 +        avio_w8(pb, 0x00);   // vertical justification
 +        avio_w8(pb, 0x00);   // bgColourRed
 +        avio_w8(pb, 0x00);   // bgColourGreen
 +        avio_w8(pb, 0x00);   // bgColourBlue
 +        avio_w8(pb, 0x00);   // bgColourAlpha
 +        // BoxRecord
 +        avio_wb16(pb, 0x00); // defTextBoxTop
 +        avio_wb16(pb, 0x00); // defTextBoxLeft
 +        avio_wb16(pb, 0x00); // defTextBoxBottom
 +        avio_wb16(pb, 0x00); // defTextBoxRight
 +        // StyleRecord
 +        avio_wb16(pb, 0x00); // startChar
 +        avio_wb16(pb, 0x00); // endChar
 +        avio_wb16(pb, 0x01); // fontID
 +        avio_w8(pb, 0x00);   // fontStyleFlags
 +        avio_w8(pb, 0x00);   // fontSize
 +        avio_w8(pb, 0x00);   // fgColourRed
 +        avio_w8(pb, 0x00);   // fgColourGreen
 +        avio_w8(pb, 0x00);   // fgColourBlue
 +        avio_w8(pb, 0x00);   // fgColourAlpha
 +        // FontTableBox
 +        avio_wb32(pb, 0x0D); // box size
 +        ffio_wfourcc(pb, "ftab"); // box atom name
 +        avio_wb16(pb, 0x01); // entry count
 +        // FontRecord
 +        avio_wb16(pb, 0x01); // font ID
 +        avio_w8(pb, 0x00);   // font name length
 +
 +        if ((size = avio_close_dyn_buf(pb, &buf)) > 0) {
 +            track->par->extradata = buf;
 +            track->par->extradata_size = size;
 +        } else {
 +            av_freep(&buf);
 +        }
 +    }
 +#endif
  
      for (i = 0; i < s->nb_chapters; i++) {
          AVChapter *c = s->chapters[i];
      return 0;
  }
  
 +
 +static int mov_check_timecode_track(AVFormatContext *s, AVTimecode *tc, int src_index, const char *tcstr)
 +{
 +    int ret;
 +
 +    /* compute the frame number */
 +    ret = av_timecode_init_from_string(tc, find_fps(s,  s->streams[src_index]), tcstr, s);
 +    return ret;
 +}
 +
 +static int mov_create_timecode_track(AVFormatContext *s, int index, int src_index, AVTimecode tc)
 +{
 +    int ret;
 +    MOVMuxContext *mov  = s->priv_data;
 +    MOVTrack *track     = &mov->tracks[index];
 +    AVStream *src_st    = s->streams[src_index];
 +    AVPacket pkt    = {.stream_index = index, .flags = AV_PKT_FLAG_KEY, .size = 4};
 +    AVRational rate = find_fps(s, src_st);
 +
 +    /* tmcd track based on video stream */
 +    track->mode      = mov->mode;
 +    track->tag       = MKTAG('t','m','c','d');
 +    track->src_track = src_index;
 +    track->timescale = mov->tracks[src_index].timescale;
 +    if (tc.flags & AV_TIMECODE_FLAG_DROPFRAME)
 +        track->timecode_flags |= MOV_TIMECODE_FLAG_DROPFRAME;
 +
 +    /* set st to src_st for metadata access*/
 +    track->st = src_st;
 +
 +    /* encode context: tmcd data stream */
 +    track->par = avcodec_parameters_alloc();
 +    if (!track->par)
 +        return AVERROR(ENOMEM);
 +    track->par->codec_type = AVMEDIA_TYPE_DATA;
 +    track->par->codec_tag  = track->tag;
 +    track->st->avg_frame_rate = av_inv_q(rate);
 +
 +    /* the tmcd track just contains one packet with the frame number */
 +    pkt.data = av_malloc(pkt.size);
 +    if (!pkt.data)
 +        return AVERROR(ENOMEM);
 +    AV_WB32(pkt.data, tc.start);
 +    ret = ff_mov_write_packet(s, &pkt);
 +    av_free(pkt.data);
 +    return ret;
 +}
 +
  /*
   * st->disposition controls the "enabled" flag in the tkhd tag.
   * QuickTime will not play a track if it is not enabled.  So make sure
@@@ -5073,24 -3790,17 +5095,24 @@@ static void mov_free(AVFormatContext *s
      MOVMuxContext *mov = s->priv_data;
      int i;
  
 -    if (mov->chapter_track)
 -        avcodec_parameters_free(&mov->tracks[mov->chapter_track].par);
 +    if (mov->chapter_track) {
 +        if (mov->tracks[mov->chapter_track].par)
 +            av_freep(&mov->tracks[mov->chapter_track].par->extradata);
 +        av_freep(&mov->tracks[mov->chapter_track].par);
 +    }
  
      for (i = 0; i < mov->nb_streams; i++) {
          if (mov->tracks[i].tag == MKTAG('r','t','p',' '))
              ff_mov_close_hinting(&mov->tracks[i]);
 +        else if (mov->tracks[i].tag == MKTAG('t','m','c','d') && mov->nb_meta_tmcd)
 +            av_freep(&mov->tracks[i].par);
          av_freep(&mov->tracks[i].cluster);
          av_freep(&mov->tracks[i].frag_info);
  
          if (mov->tracks[i].vos_len)
 -            av_free(mov->tracks[i].vos_data);
 +            av_freep(&mov->tracks[i].vos_data);
 +
 +        ff_mov_cenc_free(&mov->tracks[i].cenc);
      }
  
      av_freep(&mov->tracks);
@@@ -5105,9 -3815,9 +5127,9 @@@ static uint32_t rgb_to_yuv(uint32_t rgb
      g = (rgb >>  8) & 0xFF;
      b = (rgb      ) & 0xFF;
  
 -    y  = av_clip_uint8( 16. +  0.257 * r + 0.504 * g + 0.098 * b);
 -    cb = av_clip_uint8(128. -  0.148 * r - 0.291 * g + 0.439 * b);
 -    cr = av_clip_uint8(128. +  0.439 * r - 0.368 * g - 0.071 * b);
 +    y  = av_clip_uint8(( 16000 +  257 * r + 504 * g +  98 * b)/1000);
 +    cb = av_clip_uint8((128000 -  148 * r - 291 * g + 439 * b)/1000);
 +    cr = av_clip_uint8((128000 +  439 * r - 368 * g -  71 * b)/1000);
  
      return (y << 16) | (cr << 8) | cb;
  }
@@@ -5165,8 -3875,8 +5187,8 @@@ static int mov_write_header(AVFormatCon
  {
      AVIOContext *pb = s->pb;
      MOVMuxContext *mov = s->priv_data;
 -    AVDictionaryEntry *t;
 -    int i, ret, hint_track = 0;
 +    AVDictionaryEntry *t, *global_tcr = av_dict_get(s->metadata, "timecode", NULL, 0);
 +    int i, ret, hint_track = 0, tmcd_track = 0;
  
      mov->fc = s;
  
          mov->flags |= FF_MOV_FLAG_FRAGMENT | FF_MOV_FLAG_EMPTY_MOOV |
                        FF_MOV_FLAG_DEFAULT_BASE_MOOF;
  
 +    if (mov->flags & FF_MOV_FLAG_FASTSTART) {
 +        mov->reserved_moov_size = -1;
 +    }
 +
      if (mov->use_editlist < 0) {
          mov->use_editlist = 1;
          if (mov->flags & FF_MOV_FLAG_FRAGMENT &&
          return AVERROR(EINVAL);
      }
  
 -
      if (!(mov->flags & FF_MOV_FLAG_DELAY_MOOV)) {
          if ((ret = mov_write_identification(pb, s)) < 0)
              return ret;
          }
      }
  
 +    if (mov->mode == MODE_MOV || mov->mode == MODE_MP4) {
 +        tmcd_track = mov->nb_streams;
 +
 +        /* +1 tmcd track for each video stream with a timecode */
 +        for (i = 0; i < s->nb_streams; i++) {
 +            AVStream *st = s->streams[i];
 +            t = global_tcr;
 +            if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
 +                (t || (t=av_dict_get(st->metadata, "timecode", NULL, 0)))) {
 +                AVTimecode tc;
 +                ret = mov_check_timecode_track(s, &tc, i, t->value);
 +                if (ret >= 0)
 +                    mov->nb_meta_tmcd++;
 +            }
 +        }
 +
 +        /* check if there is already a tmcd track to remux */
 +        if (mov->nb_meta_tmcd) {
 +            for (i = 0; i < s->nb_streams; i++) {
 +                AVStream *st = s->streams[i];
 +                if (st->codecpar->codec_tag == MKTAG('t','m','c','d')) {
 +                    av_log(s, AV_LOG_WARNING, "You requested a copy of the original timecode track "
 +                           "so timecode metadata are now ignored\n");
 +                    mov->nb_meta_tmcd = 0;
 +                }
 +            }
 +        }
 +
 +        mov->nb_streams += mov->nb_meta_tmcd;
 +    }
 +
      // Reserve an extra stream for chapters for the case where chapters
      // are written in the trailer
 -    mov->tracks = av_mallocz((mov->nb_streams + 1) * sizeof(*mov->tracks));
 +    mov->tracks = av_mallocz_array((mov->nb_streams + 1), sizeof(*mov->tracks));
      if (!mov->tracks)
          return AVERROR(ENOMEM);
  
 +    if (mov->encryption_scheme_str != NULL && strcmp(mov->encryption_scheme_str, "none") != 0) {
 +        if (strcmp(mov->encryption_scheme_str, "cenc-aes-ctr") == 0) {
 +            mov->encryption_scheme = MOV_ENC_CENC_AES_CTR;
 +
 +            if (mov->encryption_key_len != AES_CTR_KEY_SIZE) {
 +                av_log(s, AV_LOG_ERROR, "Invalid encryption key len %d expected %d\n",
 +                    mov->encryption_key_len, AES_CTR_KEY_SIZE);
 +                ret = AVERROR(EINVAL);
 +                goto error;
 +            }
 +
 +            if (mov->encryption_kid_len != CENC_KID_SIZE) {
 +                av_log(s, AV_LOG_ERROR, "Invalid encryption kid len %d expected %d\n",
 +                    mov->encryption_kid_len, CENC_KID_SIZE);
 +                ret = AVERROR(EINVAL);
 +                goto error;
 +            }
 +        } else {
 +            av_log(s, AV_LOG_ERROR, "unsupported encryption scheme %s\n",
 +                mov->encryption_scheme_str);
 +            ret = AVERROR(EINVAL);
 +            goto error;
 +        }
 +    }
 +
      for (i = 0; i < s->nb_streams; i++) {
          AVStream *st= s->streams[i];
          MOVTrack *track= &mov->tracks[i];
          track->mode = mov->mode;
          track->tag  = mov_find_codec_tag(s, track);
          if (!track->tag) {
 -            av_log(s, AV_LOG_ERROR, "track %d: could not find tag, "
 -                   "codec not currently supported in container\n", i);
 +            av_log(s, AV_LOG_ERROR, "Could not find tag for codec %s in stream #%d, "
 +                   "codec not currently supported in container\n",
 +                   avcodec_get_name(st->codecpar->codec_id), i);
 +            ret = AVERROR(EINVAL);
              goto error;
          }
          /* If hinting of this track is enabled by a later hint track,
                  track->tag == MKTAG('m','x','5','p') || track->tag == MKTAG('m','x','5','n')) {
                  if (st->codecpar->width != 720 || (st->codecpar->height != 608 && st->codecpar->height != 512)) {
                      av_log(s, AV_LOG_ERROR, "D-10/IMX must use 720x608 or 720x512 video resolution\n");
 +                    ret = AVERROR(EINVAL);
                      goto error;
                  }
                  track->height = track->tag >> 24 == 'n' ? 486 : 576;
              }
 -            track->timescale = st->time_base.den;
 +            if (mov->video_track_timescale) {
 +                track->timescale = mov->video_track_timescale;
 +            } else {
 +                track->timescale = st->time_base.den;
 +                while(track->timescale < 10000)
 +                    track->timescale *= 2;
 +            }
 +            if (st->codecpar->width > 65535 || st->codecpar->height > 65535) {
 +                av_log(s, AV_LOG_ERROR, "Resolution %dx%d too large for mov/mp4\n", st->codecpar->width, st->codecpar->height);
 +                ret = AVERROR(EINVAL);
 +                goto error;
 +            }
              if (track->mode == MODE_MOV && track->timescale > 100000)
                  av_log(s, AV_LOG_WARNING,
                         "WARNING codec timebase is very high. If duration is too long,\n"
                         "file may not be playable by quicktime. Specify a shorter timebase\n"
                         "or choose different container.\n");
 +            if (track->mode == MODE_MOV &&
 +                track->par->codec_id == AV_CODEC_ID_RAWVIDEO &&
 +                track->tag == MKTAG('r','a','w',' ')) {
 +                enum AVPixelFormat pix_fmt = track->par->format;
 +                if (pix_fmt == AV_PIX_FMT_NONE && track->par->bits_per_coded_sample == 1)
 +                    pix_fmt = AV_PIX_FMT_MONOWHITE;
 +                track->is_unaligned_qt_rgb =
 +                        pix_fmt == AV_PIX_FMT_RGB24 ||
 +                        pix_fmt == AV_PIX_FMT_BGR24 ||
 +                        pix_fmt == AV_PIX_FMT_PAL8 ||
 +                        pix_fmt == AV_PIX_FMT_GRAY8 ||
 +                        pix_fmt == AV_PIX_FMT_MONOWHITE ||
 +                        pix_fmt == AV_PIX_FMT_MONOBLACK;
 +            }
 +            if (track->mode == MODE_MP4 &&
 +                track->par->codec_id == AV_CODEC_ID_VP9) {
 +                if (s->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
 +                    av_log(s, AV_LOG_ERROR,
 +                           "VP9 in MP4 support is experimental, add "
 +                           "'-strict %d' if you want to use it.\n",
 +                           FF_COMPLIANCE_EXPERIMENTAL);
 +                    ret = AVERROR_EXPERIMENTAL;
 +                    goto error;
 +                }
 +            }
          } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
              track->timescale = st->codecpar->sample_rate;
 -            /* set sample_size for PCM and ADPCM */
 -            if (av_get_bits_per_sample(st->codecpar->codec_id) ||
 -                st->codecpar->codec_id == AV_CODEC_ID_ILBC) {
 +            if (!st->codecpar->frame_size && !av_get_bits_per_sample(st->codecpar->codec_id)) {
 +                av_log(s, AV_LOG_WARNING, "track %d: codec frame size is not set\n", i);
 +                track->audio_vbr = 1;
 +            }else if (st->codecpar->codec_id == AV_CODEC_ID_ADPCM_MS ||
 +                     st->codecpar->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV ||
 +                     st->codecpar->codec_id == AV_CODEC_ID_ILBC){
                  if (!st->codecpar->block_align) {
 -                    av_log(s, AV_LOG_ERROR, "track %d: codec block align is not set\n", i);
 +                    av_log(s, AV_LOG_ERROR, "track %d: codec block align is not set for adpcm\n", i);
 +                    ret = AVERROR(EINVAL);
                      goto error;
                  }
                  track->sample_size = st->codecpar->block_align;
 +            }else if (st->codecpar->frame_size > 1){ /* assume compressed audio */
 +                track->audio_vbr = 1;
 +            }else{
 +                track->sample_size = (av_get_bits_per_sample(st->codecpar->codec_id) >> 3) * st->codecpar->channels;
              }
 -            /* set audio_vbr for compressed audio */
 -            if (av_get_bits_per_sample(st->codecpar->codec_id) < 8) {
 +            if (st->codecpar->codec_id == AV_CODEC_ID_ILBC ||
 +                st->codecpar->codec_id == AV_CODEC_ID_ADPCM_IMA_QT) {
                  track->audio_vbr = 1;
              }
              if (track->mode != MODE_MOV &&
                  track->par->codec_id == AV_CODEC_ID_MP3 && track->timescale < 16000) {
 -                av_log(s, AV_LOG_ERROR, "track %d: muxing mp3 at %dhz is not supported\n",
 -                       i, track->par->sample_rate);
 -                goto error;
 +                if (s->strict_std_compliance >= FF_COMPLIANCE_NORMAL) {
 +                    av_log(s, AV_LOG_ERROR, "track %d: muxing mp3 at %dhz is not standard, to mux anyway set strict to -1\n",
 +                        i, track->par->sample_rate);
 +                    ret = AVERROR(EINVAL);
 +                    goto error;
 +                } else {
 +                    av_log(s, AV_LOG_WARNING, "track %d: muxing mp3 at %dhz is not standard in MP4\n",
 +                           i, track->par->sample_rate);
 +                }
              }
          } else if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
              track->timescale = st->time_base.den;
          } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
              track->timescale = st->time_base.den;
 +        } else {
 +            track->timescale = MOV_TIMESCALE;
          }
          if (!track->height)
              track->height = st->codecpar->height;
          if (st->codecpar->extradata_size) {
              if (st->codecpar->codec_id == AV_CODEC_ID_DVD_SUBTITLE)
                  mov_create_dvd_sub_decoder_specific_info(track, st);
 -            else {
 +            else if (!TAG_IS_AVCI(track->tag) && st->codecpar->codec_id != AV_CODEC_ID_DNXHD) {
                  track->vos_len  = st->codecpar->extradata_size;
                  track->vos_data = av_malloc(track->vos_len);
 -                if (!track->vos_data)
 +                if (!track->vos_data) {
 +                    ret = AVERROR(ENOMEM);
                      goto error;
 +                }
                  memcpy(track->vos_data, st->codecpar->extradata, track->vos_len);
              }
          }
 +
 +        if (mov->encryption_scheme == MOV_ENC_CENC_AES_CTR) {
 +            ret = ff_mov_cenc_init(&track->cenc, mov->encryption_key,
 +                track->par->codec_id == AV_CODEC_ID_H264, s->flags & AVFMT_FLAG_BITEXACT);
 +            if (ret) {
 +                goto error;
 +            }
 +        }
 +    }
 +
 +    for (i = 0; i < s->nb_streams; i++) {
 +        int j;
 +        AVStream *st= s->streams[i];
 +        MOVTrack *track= &mov->tracks[i];
 +
 +        if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO ||
 +            track->par->channel_layout != AV_CH_LAYOUT_MONO)
 +            continue;
 +
 +        for (j = 0; j < s->nb_streams; j++) {
 +            AVStream *stj= s->streams[j];
 +            MOVTrack *trackj= &mov->tracks[j];
 +            if (j == i)
 +                continue;
 +
 +            if (stj->codecpar->codec_type != AVMEDIA_TYPE_AUDIO ||
 +                trackj->par->channel_layout != AV_CH_LAYOUT_MONO ||
 +                trackj->language != track->language ||
 +                trackj->tag != track->tag
 +            )
 +                continue;
 +            track->multichannel_as_mono++;
 +        }
      }
  
      enable_tracks(s);
  
 +
 +    if (mov->reserved_moov_size){
 +        mov->reserved_header_pos = avio_tell(pb);
 +        if (mov->reserved_moov_size > 0)
 +            avio_skip(pb, mov->reserved_moov_size);
 +    }
 +
      if (mov->flags & FF_MOV_FLAG_FRAGMENT) {
          /* If no fragmentation options have been set, set a default. */
          if (!(mov->flags & (FF_MOV_FLAG_FRAG_KEYFRAME |
          mov_write_mdat_tag(pb, mov);
      }
  
 -    if (t = av_dict_get(s->metadata, "creation_time", NULL, 0))
 -        mov->time = ff_iso8601_to_unix_time(t->value);
 +    ff_parse_creation_time_metadata(s, &mov->time, 1);
      if (mov->time)
          mov->time += 0x7C25B080; // 1970 based -> 1904 based
  
      if (mov->chapter_track)
 -        if (mov_create_chapter_track(s, mov->chapter_track) < 0)
 +        if ((ret = mov_create_chapter_track(s, mov->chapter_track)) < 0)
              goto error;
  
      if (mov->flags & FF_MOV_FLAG_RTP_HINT) {
              AVStream *st = s->streams[i];
              if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
                  st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
 -                ff_mov_init_hinting(s, hint_track, i);
 +                if ((ret = ff_mov_init_hinting(s, hint_track, i)) < 0)
 +                    goto error;
                  hint_track++;
              }
          }
      }
  
 +    if (mov->nb_meta_tmcd) {
 +        /* Initialize the tmcd tracks */
 +        for (i = 0; i < s->nb_streams; i++) {
 +            AVStream *st = s->streams[i];
 +            t = global_tcr;
 +
 +            if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
 +                AVTimecode tc;
 +                if (!t)
 +                    t = av_dict_get(st->metadata, "timecode", NULL, 0);
 +                if (!t)
 +                    continue;
 +                if (mov_check_timecode_track(s, &tc, i, t->value) < 0)
 +                    continue;
 +                if ((ret = mov_create_timecode_track(s, tmcd_track, i, tc)) < 0)
 +                    goto error;
 +                tmcd_track++;
 +            }
 +        }
 +    }
 +
      avio_flush(pb);
  
      if (mov->flags & FF_MOV_FLAG_ISML)
  
      if (mov->flags & FF_MOV_FLAG_EMPTY_MOOV &&
          !(mov->flags & FF_MOV_FLAG_DELAY_MOOV)) {
 -        mov_write_moov_tag(pb, mov, s);
 +        if ((ret = mov_write_moov_tag(pb, mov, s)) < 0)
 +            return ret;
          avio_flush(pb);
          mov->moov_written = 1;
          if (mov->flags & FF_MOV_FLAG_GLOBAL_SIDX)
      return 0;
   error:
      mov_free(s);
 -    return -1;
 +    return ret;
  }
  
  static int get_moov_size(AVFormatContext *s)
  
      if ((ret = ffio_open_null_buf(&moov_buf)) < 0)
          return ret;
 -    mov_write_moov_tag(moov_buf, mov, s);
 +    if ((ret = mov_write_moov_tag(moov_buf, mov, s)) < 0)
 +        return ret;
      return ffio_close_null_buf(moov_buf);
  }
  
@@@ -5738,19 -4269,6 +5760,19 @@@ static int mov_write_trailer(AVFormatCo
      int i;
      int64_t moov_pos;
  
 +    /*
 +     * Before actually writing the trailer, make sure that there are no
 +     * dangling subtitles, that need a terminating sample.
 +     */
 +    for (i = 0; i < mov->nb_streams; i++) {
 +        MOVTrack *trk = &mov->tracks[i];
 +        if (trk->par->codec_id == AV_CODEC_ID_MOV_TEXT &&
 +            !trk->last_sample_is_subtitle_end) {
 +            mov_write_subtitle_end_packet(s, i, trk->track_duration);
 +            trk->last_sample_is_subtitle_end = 1;
 +        }
 +    }
 +
      // If there were no chapters when the header was written, but there
      // are chapters now, write them in the trailer.  This only works
      // when we are not doing fragments.
              ffio_wfourcc(pb, "mdat");
              avio_wb64(pb, mov->mdat_size + 16);
          }
 -        avio_seek(pb, moov_pos, SEEK_SET);
 +        avio_seek(pb, mov->reserved_moov_size > 0 ? mov->reserved_header_pos : moov_pos, SEEK_SET);
  
          if (mov->flags & FF_MOV_FLAG_FASTSTART) {
              av_log(s, AV_LOG_INFO, "Starting second pass: moving the moov atom to the beginning of the file\n");
              res = shift_data(s);
 -            if (res == 0) {
 -                avio_seek(pb, mov->reserved_header_pos, SEEK_SET);
 -                mov_write_moov_tag(pb, mov, s);
 +            if (res < 0)
 +                goto error;
 +            avio_seek(pb, mov->reserved_header_pos, SEEK_SET);
 +            if ((res = mov_write_moov_tag(pb, mov, s)) < 0)
 +                goto error;
 +        } else if (mov->reserved_moov_size > 0) {
 +            int64_t size;
 +            if ((res = mov_write_moov_tag(pb, mov, s)) < 0)
 +                goto error;
 +            size = mov->reserved_moov_size - (avio_tell(pb) - mov->reserved_header_pos);
 +            if (size < 8){
 +                av_log(s, AV_LOG_ERROR, "reserved_moov_size is too small, needed %"PRId64" additional\n", 8-size);
 +                res = AVERROR(EINVAL);
 +                goto error;
              }
 +            avio_wb32(pb, size);
 +            ffio_wfourcc(pb, "free");
 +            ffio_fill(pb, 0, size - 8);
 +            avio_seek(pb, moov_pos, SEEK_SET);
          } else {
 -            mov_write_moov_tag(pb, mov, s);
 +            if ((res = mov_write_moov_tag(pb, mov, s)) < 0)
 +                goto error;
          }
 +        res = 0;
      } else {
          mov_auto_flush_fragment(s, 1);
          for (i = 0; i < mov->nb_streams; i++)
             mov->tracks[i].data_offset = 0;
          if (mov->flags & FF_MOV_FLAG_GLOBAL_SIDX) {
 +            int64_t end;
              av_log(s, AV_LOG_INFO, "Starting second pass: inserting sidx atoms\n");
              res = shift_data(s);
 -            if (res == 0) {
 -                int64_t end = avio_tell(pb);
 -                avio_seek(pb, mov->reserved_header_pos, SEEK_SET);
 -                mov_write_sidx_tags(pb, mov, -1, 0);
 -                avio_seek(pb, end, SEEK_SET);
 -                avio_write_marker(s->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_TRAILER);
 -                mov_write_mfra_tag(pb, mov);
 -            }
 +            if (res < 0)
 +                goto error;
 +            end = avio_tell(pb);
 +            avio_seek(pb, mov->reserved_header_pos, SEEK_SET);
 +            mov_write_sidx_tags(pb, mov, -1, 0);
 +            avio_seek(pb, end, SEEK_SET);
 +            avio_write_marker(s->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_TRAILER);
 +            mov_write_mfra_tag(pb, mov);
          } else {
              avio_write_marker(s->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_TRAILER);
              mov_write_mfra_tag(pb, mov);
@@@ -5877,7 -4377,7 +5899,7 @@@ MOV_CLASS(mp4
  AVOutputFormat ff_mp4_muxer = {
      .name              = "mp4",
      .long_name         = NULL_IF_CONFIG_SMALL("MP4 (MPEG-4 Part 14)"),
 -    .mime_type         = "application/mp4",
 +    .mime_type         = "video/mp4",
      .extensions        = "mp4",
      .priv_data_size    = sizeof(MOVMuxContext),
      .audio_codec       = AV_CODEC_ID_AAC,
@@@ -5931,7 -4431,7 +5953,7 @@@ MOV_CLASS(ipod
  AVOutputFormat ff_ipod_muxer = {
      .name              = "ipod",
      .long_name         = NULL_IF_CONFIG_SMALL("iPod H.264 MP4 (MPEG-4 Part 14)"),
 -    .mime_type         = "application/mp4",
 +    .mime_type         = "video/mp4",
      .extensions        = "m4v,m4a",
      .priv_data_size    = sizeof(MOVMuxContext),
      .audio_codec       = AV_CODEC_ID_AAC,
@@@ -5949,7 -4449,7 +5971,7 @@@ MOV_CLASS(ismv
  AVOutputFormat ff_ismv_muxer = {
      .name              = "ismv",
      .long_name         = NULL_IF_CONFIG_SMALL("ISMV/ISMA (Smooth Streaming)"),
 -    .mime_type         = "application/mp4",
 +    .mime_type         = "video/mp4",
      .extensions        = "ismv,isma",
      .priv_data_size    = sizeof(MOVMuxContext),
      .audio_codec       = AV_CODEC_ID_AAC,
@@@ -5975,7 -4475,7 +5997,7 @@@ AVOutputFormat ff_f4v_muxer = 
      .write_header      = mov_write_header,
      .write_packet      = mov_write_packet,
      .write_trailer     = mov_write_trailer,
 -    .flags             = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH | AVFMT_TS_NEGATIVE,
 +    .flags             = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH,
      .codec_tag         = (const AVCodecTag* const []){ codec_f4v_tags, 0 },
      .priv_class        = &f4v_muxer_class,
  };
diff --combined libavformat/movenc.h
index 1090085a5ac51af6369fa69f5f7f397930a981b3,6c922fb5df939452a7cd6c7e5276c9fbf43b6536..c4fded89bb6b5b637e0cfd6069b3173edc0ce0ed
@@@ -4,20 -4,20 +4,20 @@@
   * Copyright (c) 2004 Gildas Bazin <gbazin at videolan dot org>
   * Copyright (c) 2009 Baptiste Coudurier <baptiste dot coudurier at gmail dot com>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -25,7 -25,6 +25,7 @@@
  #define AVFORMAT_MOVENC_H
  
  #include "avformat.h"
 +#include "movenccenc.h"
  
  #define MOV_FRAG_INFO_ALLOC_INCREMENT 64
  #define MOV_INDEX_CLUSTER_SIZE 1024
@@@ -37,7 -36,7 +37,7 @@@
  #define MODE_MOV  0x02
  #define MODE_3GP  0x04
  #define MODE_PSP  0x08 // example working PSP command line:
 -// avconv -i testinput.avi  -f psp -r 14.985 -s 320x240 -b 768 -ar 24000 -ab 32 M4V00001.MP4
 +// ffmpeg -i testinput.avi  -f psp -r 14.985 -s 320x240 -b 768 -ar 24000 -ab 32 M4V00001.MP4
  #define MODE_3G2  0x10
  #define MODE_IPOD 0x20
  #define MODE_ISM  0x40
@@@ -48,7 -47,6 +48,7 @@@ typedef struct MOVIentry 
      int64_t      dts;
      unsigned int size;
      unsigned int samples_in_chunk;
 +    unsigned int chunkNum;              ///< Chunk number if the current entry is a chunk start otherwise 0
      unsigned int entries;
      int          cts;
  #define MOV_SYNC_SAMPLE         0x0001
@@@ -84,25 -82,18 +84,25 @@@ typedef struct MOVTrack 
      unsigned    timescale;
      uint64_t    time;
      int64_t     track_duration;
 +    int         last_sample_is_subtitle_end;
      long        sample_count;
      long        sample_size;
 +    long        chunkCount;
      int         has_keyframes;
  #define MOV_TRACK_CTTS         0x0001
  #define MOV_TRACK_STPS         0x0002
  #define MOV_TRACK_ENABLED      0x0004
      uint32_t    flags;
 +#define MOV_TIMECODE_FLAG_DROPFRAME     0x0001
 +#define MOV_TIMECODE_FLAG_24HOURSMAX    0x0002
 +#define MOV_TIMECODE_FLAG_ALLOWNEGATIVE 0x0004
 +    uint32_t    timecode_flags;
      int         language;
      int         track_id;
      int         tag; ///< stsd fourcc
      AVStream        *st;
      AVCodecParameters *par;
 +    int multichannel_as_mono;
  
      int         vos_len;
      uint8_t     *vos_data;
      int64_t     start_dts;
      int64_t     start_cts;
      int64_t     end_pts;
+     int         end_reliable;
  
      int         hint_track;   ///< the track that hints this track, -1 if no hint track is set
 -    int         src_track;    ///< the track that this hint track describes
 +    int         src_track;    ///< the track that this hint (or tmcd) track describes
      AVFormatContext *rtp_ctx; ///< the format context for the hinting rtp muxer
      uint32_t    prev_rtp_ts;
      int64_t     cur_rtp_ts_unwrapped;
          int     packet_entry;
          int     slices;
      } vc1_info;
 +
 +    void       *eac3_priv;
 +
 +    MOVMuxCencContext cenc;
 +
 +    uint32_t palette[AVPALETTE_COUNT];
 +    int pal_done;
 +
 +    int is_unaligned_qt_rgb;
  } MOVTrack;
  
 +typedef enum {
 +    MOV_ENC_NONE = 0,
 +    MOV_ENC_CENC_AES_CTR,
 +} MOVEncryptionScheme;
 +
  typedef struct MOVMuxContext {
      const AVClass *av_class;
      int     mode;
      int64_t time;
      int     nb_streams;
 +    int     nb_meta_tmcd;  ///< number of new created tmcd track based on metadata (aka not data copy)
      int     chapter_track; ///< qt chapter track number
      int64_t mdat_pos;
      uint64_t mdat_size;
  
      int flags;
      int rtp_flags;
 +
      int iods_skip;
      int iods_video_profile;
      int iods_audio_profile;
      AVIOContext *mdat_buf;
      int first_trun;
  
 +    int video_track_timescale;
 +
 +    int reserved_moov_size; ///< 0 for disabled, -1 for automatic, size otherwise
      int64_t reserved_header_pos;
  
      char *major_brand;
      AVFormatContext *fc;
  
      int use_editlist;
 +    float gamma;
 +
      int frag_interleave;
      int missing_duration_warned;
 +
 +    char *encryption_scheme_str;
 +    MOVEncryptionScheme encryption_scheme;
 +    uint8_t *encryption_key;
 +    int encryption_key_len;
 +    uint8_t *encryption_kid;
 +    int encryption_kid_len;
 +
  } MOVMuxContext;
  
  #define FF_MOV_FLAG_RTP_HINT              (1 <<  0)
  #define FF_MOV_FLAG_FRAG_DISCONT          (1 << 12)
  #define FF_MOV_FLAG_DELAY_MOOV            (1 << 13)
  #define FF_MOV_FLAG_GLOBAL_SIDX           (1 << 14)
 +#define FF_MOV_FLAG_WRITE_COLR            (1 << 15)
 +#define FF_MOV_FLAG_WRITE_GAMA            (1 << 16)
  
  int ff_mov_write_packet(AVFormatContext *s, AVPacket *pkt);
  
diff --combined libavformat/mux.c
index 8488043006b5ed3401525f78e09dff886cedb29a,c41c477ab42a6f32e51763b0573d730bb1ccf873..10b2750e3fbc57b5b0ef3be92b261a8319d6974c
@@@ -1,21 -1,21 +1,21 @@@
  /*
 - * muxing functions for use within Libav
 + * muxing functions for use within FFmpeg
   * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  #include "libavutil/opt.h"
  #include "libavutil/dict.h"
  #include "libavutil/pixdesc.h"
 +#include "libavutil/timestamp.h"
  #include "metadata.h"
  #include "id3v2.h"
 +#include "libavutil/avassert.h"
  #include "libavutil/avstring.h"
  #include "libavutil/internal.h"
  #include "libavutil/mathematics.h"
  #include "network.h"
  #endif
  
 -#undef NDEBUG
 -#include <assert.h>
 -
  /**
   * @file
 - * muxing functions for use within Libav
 + * muxing functions for use within libavformat
   */
  
 +/* fraction handling */
 +
 +/**
 + * f = val + (num / den) + 0.5.
 + *
 + * 'num' is normalized so that it is such as 0 <= num < den.
 + *
 + * @param f fractional number
 + * @param val integer value
 + * @param num must be >= 0
 + * @param den must be >= 1
 + */
 +static void frac_init(FFFrac *f, int64_t val, int64_t num, int64_t den)
 +{
 +    num += (den >> 1);
 +    if (num >= den) {
 +        val += num / den;
 +        num  = num % den;
 +    }
 +    f->val = val;
 +    f->num = num;
 +    f->den = den;
 +}
 +
 +/**
 + * Fractional addition to f: f = f + (incr / f->den).
 + *
 + * @param f fractional number
 + * @param incr increment, can be positive or negative
 + */
 +static void frac_add(FFFrac *f, int64_t incr)
 +{
 +    int64_t num, den;
 +
 +    num = f->num + incr;
 +    den = f->den;
 +    if (num < 0) {
 +        f->val += num / den;
 +        num     = num % den;
 +        if (num < 0) {
 +            num += den;
 +            f->val--;
 +        }
 +    } else if (num >= den) {
 +        f->val += num / den;
 +        num     = num % den;
 +    }
 +    f->num = num;
 +}
 +
 +AVRational ff_choose_timebase(AVFormatContext *s, AVStream *st, int min_precision)
 +{
 +    AVRational q;
 +    int j;
 +
 +    q = st->time_base;
 +
 +    for (j=2; j<14; j+= 1+(j>2))
 +        while (q.den / q.num < min_precision && q.num % j == 0)
 +            q.num /= j;
 +    while (q.den / q.num < min_precision && q.den < (1<<24))
 +        q.den <<= 1;
 +
 +    return q;
 +}
 +
 +enum AVChromaLocation ff_choose_chroma_location(AVFormatContext *s, AVStream *st)
 +{
 +    AVCodecParameters *par = st->codecpar;
 +    const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(par->format);
 +
 +    if (par->chroma_location != AVCHROMA_LOC_UNSPECIFIED)
 +        return par->chroma_location;
 +
 +    if (pix_desc) {
 +        if (pix_desc->log2_chroma_h == 0) {
 +            return AVCHROMA_LOC_TOPLEFT;
 +        } else if (pix_desc->log2_chroma_w == 1 && pix_desc->log2_chroma_h == 1) {
 +            if (par->field_order == AV_FIELD_UNKNOWN || par->field_order == AV_FIELD_PROGRESSIVE) {
 +                switch (par->codec_id) {
 +                case AV_CODEC_ID_MJPEG:
 +                case AV_CODEC_ID_MPEG1VIDEO: return AVCHROMA_LOC_CENTER;
 +                }
 +            }
 +            if (par->field_order == AV_FIELD_UNKNOWN || par->field_order != AV_FIELD_PROGRESSIVE) {
 +                switch (par->codec_id) {
 +                case AV_CODEC_ID_MPEG2VIDEO: return AVCHROMA_LOC_LEFT;
 +                }
 +            }
 +        }
 +    }
 +
 +    return AVCHROMA_LOC_UNSPECIFIED;
 +
 +}
 +
 +int avformat_alloc_output_context2(AVFormatContext **avctx, AVOutputFormat *oformat,
 +                                   const char *format, const char *filename)
 +{
 +    AVFormatContext *s = avformat_alloc_context();
 +    int ret = 0;
 +
 +    *avctx = NULL;
 +    if (!s)
 +        goto nomem;
 +
 +    if (!oformat) {
 +        if (format) {
 +            oformat = av_guess_format(format, NULL, NULL);
 +            if (!oformat) {
 +                av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
 +                ret = AVERROR(EINVAL);
 +                goto error;
 +            }
 +        } else {
 +            oformat = av_guess_format(NULL, filename, NULL);
 +            if (!oformat) {
 +                ret = AVERROR(EINVAL);
 +                av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
 +                       filename);
 +                goto error;
 +            }
 +        }
 +    }
 +
 +    s->oformat = oformat;
 +    if (s->oformat->priv_data_size > 0) {
 +        s->priv_data = av_mallocz(s->oformat->priv_data_size);
 +        if (!s->priv_data)
 +            goto nomem;
 +        if (s->oformat->priv_class) {
 +            *(const AVClass**)s->priv_data= s->oformat->priv_class;
 +            av_opt_set_defaults(s->priv_data);
 +        }
 +    } else
 +        s->priv_data = NULL;
 +
 +    if (filename)
 +        av_strlcpy(s->filename, filename, sizeof(s->filename));
 +    *avctx = s;
 +    return 0;
 +nomem:
 +    av_log(s, AV_LOG_ERROR, "Out of memory\n");
 +    ret = AVERROR(ENOMEM);
 +error:
 +    avformat_free_context(s);
 +    return ret;
 +}
 +
  static int validate_codec_tag(AVFormatContext *s, AVStream *st)
  {
      const AVCodecTag *avctag;
      int n;
      enum AVCodecID id = AV_CODEC_ID_NONE;
 -    unsigned int tag  = 0;
 +    int64_t tag  = -1;
  
      /**
       * Check that tag + id is in the table
      }
      if (id != AV_CODEC_ID_NONE)
          return 0;
 -    if (tag && (s->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
 +    if (tag >= 0 && (s->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
          return 0;
      return 1;
  }
@@@ -240,42 -92,23 +240,42 @@@ static int init_muxer(AVFormatContext *
      AVCodecParameters *par = NULL;
      AVOutputFormat *of = s->oformat;
      const AVCodecDescriptor *desc;
 +    AVDictionaryEntry *e;
  
      if (options)
          av_dict_copy(&tmp, *options, 0);
  
      if ((ret = av_opt_set_dict(s, &tmp)) < 0)
          goto fail;
 +    if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
 +        (ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
 +        goto fail;
  
 -#if FF_API_LAVF_BITEXACT && FF_API_LAVF_AVCTX
 +#if FF_API_LAVF_AVCTX
  FF_DISABLE_DEPRECATION_WARNINGS
 -    if (s->nb_streams && s->streams[0]->codec->flags & AV_CODEC_FLAG_BITEXACT)
 -        s->flags |= AVFMT_FLAG_BITEXACT;
 +    if (s->nb_streams && s->streams[0]->codec->flags & AV_CODEC_FLAG_BITEXACT) {
 +        if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
 +#if FF_API_LAVF_BITEXACT
 +            av_log(s, AV_LOG_WARNING,
 +                   "Setting the AVFormatContext to bitexact mode, because "
 +                   "the AVCodecContext is in that mode. This behavior will "
 +                   "change in the future. To keep the current behavior, set "
 +                   "AVFormatContext.flags |= AVFMT_FLAG_BITEXACT.\n");
 +            s->flags |= AVFMT_FLAG_BITEXACT;
 +#else
 +            av_log(s, AV_LOG_WARNING,
 +                   "The AVFormatContext is not in set to bitexact mode, only "
 +                   "the AVCodecContext. If this is not intended, set "
 +                   "AVFormatContext.flags |= AVFMT_FLAG_BITEXACT.\n");
 +#endif
 +        }
 +    }
  FF_ENABLE_DEPRECATION_WARNINGS
  #endif
  
      // some sanity checks
      if (s->nb_streams == 0 && !(of->flags & AVFMT_NOSTREAMS)) {
 -        av_log(s, AV_LOG_ERROR, "no streams\n");
 +        av_log(s, AV_LOG_ERROR, "No streams to mux were specified\n");
          ret = AVERROR(EINVAL);
          goto fail;
      }
@@@ -309,12 -142,6 +309,12 @@@ FF_DISABLE_DEPRECATION_WARNING
  FF_ENABLE_DEPRECATION_WARNINGS
  #endif
  
 +        /* update internal context from codecpar, old bsf api needs this
 +         * FIXME: remove when autobsf uses new bsf API */
 +        ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
 +        if (ret < 0)
 +            goto fail;
 +
          if (!st->time_base.num) {
              /* fall back on the default timebase values */
              if (par->codec_type == AVMEDIA_TYPE_AUDIO && par->sample_rate)
                  ret = AVERROR(EINVAL);
                  goto fail;
              }
 -
 -            if (av_cmp_q(st->sample_aspect_ratio,
 -                         par->sample_aspect_ratio)) {
 +            if (av_cmp_q(st->sample_aspect_ratio, par->sample_aspect_ratio)
 +                && fabs(av_q2d(st->sample_aspect_ratio) - av_q2d(par->sample_aspect_ratio)) > 0.004*av_q2d(st->sample_aspect_ratio)
 +            ) {
                  if (st->sample_aspect_ratio.num != 0 &&
                      st->sample_aspect_ratio.den != 0 &&
 -                    par->sample_aspect_ratio.den != 0 &&
 +                    par->sample_aspect_ratio.num != 0 &&
                      par->sample_aspect_ratio.den != 0) {
                      av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
 -                            "(%d/%d) and encoder layer (%d/%d)\n",
 -                            st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
 -                            par->sample_aspect_ratio.num,
 -                            par->sample_aspect_ratio.den);
 +                           "(%d/%d) and encoder layer (%d/%d)\n",
 +                           st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
 +                           par->sample_aspect_ratio.num,
 +                           par->sample_aspect_ratio.den);
                      ret = AVERROR(EINVAL);
                      goto fail;
                  }
              st->internal->reorder = 1;
  
          if (of->codec_tag) {
 -            if (par->codec_tag &&
 -                par->codec_id == AV_CODEC_ID_RAWVIDEO &&
 -                !av_codec_get_tag(of->codec_tag, par->codec_id) &&
 -                !validate_codec_tag(s, st)) {
 +            if (   par->codec_tag
 +                && par->codec_id == AV_CODEC_ID_RAWVIDEO
 +                && (   av_codec_get_tag(of->codec_tag, par->codec_id) == 0
 +                    || av_codec_get_tag(of->codec_tag, par->codec_id) == MKTAG('r', 'a', 'w', ' '))
 +                && !validate_codec_tag(s, st)) {
                  // the current rawvideo encoding system ends up setting
 -                // the wrong codec_tag for avi, we override it here
 +                // the wrong codec_tag for avi/mov, we override it here
                  par->codec_tag = 0;
              }
              if (par->codec_tag) {
                  if (!validate_codec_tag(s, st)) {
 -                    char tagbuf[32];
 +                    char tagbuf[32], tagbuf2[32];
                      av_get_codec_tag_string(tagbuf, sizeof(tagbuf), par->codec_tag);
 +                    av_get_codec_tag_string(tagbuf2, sizeof(tagbuf2), av_codec_get_tag(s->oformat->codec_tag, par->codec_id));
                      av_log(s, AV_LOG_ERROR,
 -                           "Tag %s/0x%08x incompatible with output codec id '%d'\n",
 -                           tagbuf, par->codec_tag, par->codec_id);
 +                           "Tag %s/0x%08x incompatible with output codec id '%d' (%s)\n",
 +                           tagbuf, par->codec_tag, par->codec_id, tagbuf2);
                      ret = AVERROR_INVALIDDATA;
                      goto fail;
                  }
          if (of->priv_class) {
              *(const AVClass **)s->priv_data = of->priv_class;
              av_opt_set_defaults(s->priv_data);
 -            if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
 +            if ((ret = av_opt_set_dict2(s->priv_data, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
                  goto fail;
          }
      }
      /* set muxer identification string */
      if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
          av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
 +    } else {
 +        av_dict_set(&s->metadata, "encoder", NULL, 0);
 +    }
 +
 +    for (e = NULL; e = av_dict_get(s->metadata, "encoder-", e, AV_DICT_IGNORE_SUFFIX); ) {
 +        av_dict_set(&s->metadata, e->key, NULL, 0);
      }
  
      if (options) {
           *options = tmp;
      }
  
 +    if (s->oformat->init && (ret = s->oformat->init(s)) < 0) {
 +        if (s->oformat->deinit)
 +            s->oformat->deinit(s);
 +        goto fail;
 +    }
 +
      return 0;
  
  fail:
      return ret;
  }
  
 -int avformat_write_header(AVFormatContext *s, AVDictionary **options)
 +static int init_pts(AVFormatContext *s)
  {
 -    int ret = 0;
 +    int i;
 +    AVStream *st;
  
 -    if (ret = init_muxer(s, options))
 -        return ret;
 +    /* init PTS generation */
 +    for (i = 0; i < s->nb_streams; i++) {
 +        int64_t den = AV_NOPTS_VALUE;
 +        st = s->streams[i];
 +
 +        switch (st->codecpar->codec_type) {
 +        case AVMEDIA_TYPE_AUDIO:
 +            den = (int64_t)st->time_base.num * st->codecpar->sample_rate;
 +            break;
 +        case AVMEDIA_TYPE_VIDEO:
 +            den = (int64_t)st->time_base.num * st->time_base.den;
 +            break;
 +        default:
 +            break;
 +        }
 +
 +        if (!st->priv_pts)
 +            st->priv_pts = av_mallocz(sizeof(*st->priv_pts));
 +        if (!st->priv_pts)
 +            return AVERROR(ENOMEM);
 +
 +        if (den != AV_NOPTS_VALUE) {
 +            if (den <= 0)
 +                return AVERROR_INVALIDDATA;
  
 +            frac_init(st->priv_pts, 0, 0, den);
 +        }
 +    }
 +
 +    return 0;
 +}
 +
 +static int write_header_internal(AVFormatContext *s)
 +{
      if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
          avio_write_marker(s->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_HEADER);
      if (s->oformat->write_header) {
 -        ret = s->oformat->write_header(s);
 +        int ret = s->oformat->write_header(s);
 +        if (ret >= 0 && s->pb && s->pb->error < 0)
 +            ret = s->pb->error;
 +        s->internal->write_header_ret = ret;
          if (ret < 0)
              return ret;
 +        if (s->flush_packets && s->pb && s->pb->error >= 0 && s->flags & AVFMT_FLAG_FLUSH_PACKETS)
 +            avio_flush(s->pb);
      }
 +    s->internal->header_written = 1;
      if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
          avio_write_marker(s->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_UNKNOWN);
 +    return 0;
 +}
 +
 +int avformat_write_header(AVFormatContext *s, AVDictionary **options)
 +{
 +    int ret = 0;
 +
 +    if ((ret = init_muxer(s, options)) < 0)
 +        return ret;
 +
 +    if (!s->oformat->check_bitstream) {
 +        ret = write_header_internal(s);
 +        if (ret < 0)
 +            goto fail;
 +    }
  
 -    if (s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_AUTO) {
 +    if ((ret = init_pts(s)) < 0)
 +        goto fail;
 +
 +    if (s->avoid_negative_ts < 0) {
 +        av_assert2(s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_AUTO);
          if (s->oformat->flags & (AVFMT_TS_NEGATIVE | AVFMT_NOTIMESTAMPS)) {
              s->avoid_negative_ts = 0;
          } else
      }
  
      return 0;
 +
 +fail:
 +    if (s->oformat->deinit)
 +        s->oformat->deinit(s);
 +    return ret;
  }
  
 +#define AV_PKT_FLAG_UNCODED_FRAME 0x2000
 +
 +/* Note: using sizeof(AVFrame) from outside lavu is unsafe in general, but
 +   it is only being used internally to this file as a consistency check.
 +   The value is chosen to be very unlikely to appear on its own and to cause
 +   immediate failure if used anywhere as a real size. */
 +#define UNCODED_FRAME_PACKET_SIZE (INT_MIN / 3 * 2 + (int)sizeof(AVFrame))
 +
 +
  #if FF_API_COMPUTE_PKT_FIELDS2 && FF_API_LAVF_AVCTX
  FF_DISABLE_DEPRECATION_WARNINGS
  //FIXME merge with compute_pkt_fields
 -static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt)
 +static int compute_muxer_pkt_fields(AVFormatContext *s, AVStream *st, AVPacket *pkt)
  {
 -    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
 +    int delay = FFMAX(st->codecpar->video_delay, st->internal->avctx->max_b_frames > 0);
      int num, den, i;
 +    int frame_size;
  
      if (!s->internal->missing_ts_warning &&
          !(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&
          s->internal->missing_ts_warning = 1;
      }
  
 -    av_log(s, AV_LOG_TRACE, "compute_pkt_fields2: pts:%" PRId64 " dts:%" PRId64 " cur_dts:%" PRId64 " b:%d size:%d st:%d\n",
 -            pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
 +    if (s->debug & FF_FDEBUG_TS)
 +        av_log(s, AV_LOG_TRACE, "compute_muxer_pkt_fields: pts:%s dts:%s cur_dts:%s b:%d size:%d st:%d\n",
 +            av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), delay, pkt->size, pkt->stream_index);
  
 -/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
 - *      return AVERROR(EINVAL);*/
 +    if (pkt->duration < 0 && st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) {
 +        av_log(s, AV_LOG_WARNING, "Packet with invalid duration %"PRId64" in stream %d\n",
 +               pkt->duration, pkt->stream_index);
 +        pkt->duration = 0;
 +    }
  
      /* duration field */
      if (pkt->duration == 0) {
      if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay == 0)
          pkt->pts = pkt->dts;
  
 +    //XXX/FIXME this is a temporary hack until all encoders output pts
 +    if ((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay) {
 +        static int warned;
 +        if (!warned) {
 +            av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");
 +            warned = 1;
 +        }
 +        pkt->dts =
 +//        pkt->pts= st->cur_dts;
 +            pkt->pts = st->priv_pts->val;
 +    }
 +
      //calculate dts from pts
      if (pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
          st->pts_buffer[0] = pkt->pts;
  
      if (st->cur_dts && st->cur_dts != AV_NOPTS_VALUE &&
          ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&
 +          st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE &&
 +          st->codecpar->codec_type != AVMEDIA_TYPE_DATA &&
            st->cur_dts >= pkt->dts) || st->cur_dts > pkt->dts)) {
          av_log(s, AV_LOG_ERROR,
 -               "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %" PRId64 " >= %" PRId64 "\n",
 -               st->index, st->cur_dts, pkt->dts);
 +               "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %s >= %s\n",
 +               st->index, av_ts2str(st->cur_dts), av_ts2str(pkt->dts));
          return AVERROR(EINVAL);
      }
      if (pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts) {
          av_log(s, AV_LOG_ERROR,
 -               "pts %" PRId64 " < dts %" PRId64 " in stream %d\n",
 -               pkt->pts, pkt->dts,
 +               "pts (%s) < dts (%s) in stream %d\n",
 +               av_ts2str(pkt->pts), av_ts2str(pkt->dts),
                 st->index);
          return AVERROR(EINVAL);
      }
  
 -    av_log(s, AV_LOG_TRACE, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n",
 -            pkt->pts, pkt->dts);
 -    st->cur_dts = pkt->dts;
 +    if (s->debug & FF_FDEBUG_TS)
 +        av_log(s, AV_LOG_TRACE, "av_write_frame: pts2:%s dts2:%s\n",
 +            av_ts2str(pkt->pts), av_ts2str(pkt->dts));
  
 +    st->cur_dts = pkt->dts;
 +    st->priv_pts->val = pkt->dts;
 +
 +    /* update pts */
 +    switch (st->codec->codec_type) {
 +    case AVMEDIA_TYPE_AUDIO:
 +        frame_size = (pkt->flags & AV_PKT_FLAG_UNCODED_FRAME) ?
 +                     ((AVFrame *)pkt->data)->nb_samples :
 +                     av_get_audio_frame_duration(st->codec, pkt->size);
 +
 +        /* HACK/FIXME, we skip the initial 0 size packets as they are most
 +         * likely equal to the encoder delay, but it would be better if we
 +         * had the real timestamps from the encoder */
 +        if (frame_size >= 0 && (pkt->size || st->priv_pts->num != st->priv_pts->den >> 1 || st->priv_pts->val)) {
 +            frac_add(st->priv_pts, (int64_t)st->time_base.den * frame_size);
 +        }
 +        break;
 +    case AVMEDIA_TYPE_VIDEO:
 +        frac_add(st->priv_pts, (int64_t)st->time_base.den * st->time_base.num);
 +        break;
 +    }
      return 0;
  }
  FF_ENABLE_DEPRECATION_WARNINGS
  #endif
  
 -/*
 +/**
 + * Make timestamps non negative, move side data from payload to internal struct, call muxer, and restore
 + * sidedata.
 + *
   * FIXME: this function should NEVER get undefined pts/dts beside when the
   * AVFMT_NOTIMESTAMPS is set.
   * Those additional safety checks should be dropped once the correct checks
   * are set in the callers.
   */
 -
  static int write_packet(AVFormatContext *s, AVPacket *pkt)
  {
 -    int ret;
 +    int ret, did_split;
 +
 +    if (s->output_ts_offset) {
 +        AVStream *st = s->streams[pkt->stream_index];
 +        int64_t offset = av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
 +
 +        if (pkt->dts != AV_NOPTS_VALUE)
 +            pkt->dts += offset;
 +        if (pkt->pts != AV_NOPTS_VALUE)
 +            pkt->pts += offset;
 +    }
 +
      if (s->avoid_negative_ts > 0) {
 -        AVRational time_base = s->streams[pkt->stream_index]->time_base;
 -        int64_t offset = 0;
 +        AVStream *st = s->streams[pkt->stream_index];
 +        int64_t offset = st->mux_ts_offset;
 +        int64_t ts = s->internal->avoid_negative_ts_use_pts ? pkt->pts : pkt->dts;
 +
 +        if (s->internal->offset == AV_NOPTS_VALUE && ts != AV_NOPTS_VALUE &&
 +            (ts < 0 || s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO)) {
 +            s->internal->offset = -ts;
 +            s->internal->offset_timebase = st->time_base;
 +        }
  
 -        if (s->internal->offset == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
 -            (pkt->dts < 0 || s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO)) {
 -            s->internal->offset = -pkt->dts;
 -            s->internal->offset_timebase = time_base;
 +        if (s->internal->offset != AV_NOPTS_VALUE && !offset) {
 +            offset = st->mux_ts_offset =
 +                av_rescale_q_rnd(s->internal->offset,
 +                                 s->internal->offset_timebase,
 +                                 st->time_base,
 +                                 AV_ROUND_UP);
          }
 -        if (s->internal->offset != AV_NOPTS_VALUE)
 -            offset = av_rescale_q(s->internal->offset, s->internal->offset_timebase, time_base);
  
          if (pkt->dts != AV_NOPTS_VALUE)
              pkt->dts += offset;
          if (pkt->pts != AV_NOPTS_VALUE)
              pkt->pts += offset;
  
 -        if (pkt->dts != AV_NOPTS_VALUE && pkt->dts < 0) {
 -            av_log(s, AV_LOG_WARNING,
 -                   "Packets poorly interleaved, failed to avoid negative "
 -                   "timestamp %"PRId64" in stream %d.\n"
 -                   "Try -max_interleave_delta 0 as a possible workaround.\n",
 -                   pkt->dts, pkt->stream_index);
 +        if (s->internal->avoid_negative_ts_use_pts) {
 +            if (pkt->pts != AV_NOPTS_VALUE && pkt->pts < 0) {
 +                av_log(s, AV_LOG_WARNING, "failed to avoid negative "
 +                    "pts %s in stream %d.\n"
 +                    "Try -avoid_negative_ts 1 as a possible workaround.\n",
 +                    av_ts2str(pkt->dts),
 +                    pkt->stream_index
 +                );
 +            }
 +        } else {
 +            av_assert2(pkt->dts == AV_NOPTS_VALUE || pkt->dts >= 0 || s->max_interleave_delta > 0);
 +            if (pkt->dts != AV_NOPTS_VALUE && pkt->dts < 0) {
 +                av_log(s, AV_LOG_WARNING,
 +                    "Packets poorly interleaved, failed to avoid negative "
 +                    "timestamp %s in stream %d.\n"
 +                    "Try -max_interleave_delta 0 as a possible workaround.\n",
 +                    av_ts2str(pkt->dts),
 +                    pkt->stream_index
 +                );
 +            }
          }
      }
 -    ret = s->oformat->write_packet(s, pkt);
 +
 +    did_split = av_packet_split_side_data(pkt);
 +
 +    if (!s->internal->header_written) {
 +        ret = s->internal->write_header_ret ? s->internal->write_header_ret : write_header_internal(s);
 +        if (ret < 0)
 +            goto fail;
 +    }
 +
 +    if ((pkt->flags & AV_PKT_FLAG_UNCODED_FRAME)) {
 +        AVFrame *frame = (AVFrame *)pkt->data;
 +        av_assert0(pkt->size == UNCODED_FRAME_PACKET_SIZE);
 +        ret = s->oformat->write_uncoded_frame(s, pkt->stream_index, &frame, 0);
 +        av_frame_free(&frame);
 +    } else {
 +        ret = s->oformat->write_packet(s, pkt);
 +    }
  
      if (s->pb && ret >= 0) {
 -        if (s->flags & AVFMT_FLAG_FLUSH_PACKETS)
 +        if (s->flush_packets && s->flags & AVFMT_FLAG_FLUSH_PACKETS)
              avio_flush(s->pb);
          if (s->pb->error < 0)
              ret = s->pb->error;
      }
  
 +fail:
 +    if (did_split)
 +        av_packet_merge_side_data(pkt);
 +
      return ret;
  }
  
@@@ -826,104 -474,55 +826,104 @@@ int av_write_frame(AVFormatContext *s, 
          return ret;
  
      if (!pkt) {
 -        if (s->oformat->flags & AVFMT_ALLOW_FLUSH)
 -            return s->oformat->write_packet(s, pkt);
 +        if (s->oformat->flags & AVFMT_ALLOW_FLUSH) {
 +            if (!s->internal->header_written) {
 +                ret = s->internal->write_header_ret ? s->internal->write_header_ret : write_header_internal(s);
 +                if (ret < 0)
 +                    return ret;
 +            }
 +            ret = s->oformat->write_packet(s, NULL);
 +            if (s->flush_packets && s->pb && s->pb->error >= 0 && s->flags & AVFMT_FLAG_FLUSH_PACKETS)
 +                avio_flush(s->pb);
 +            if (ret >= 0 && s->pb && s->pb->error < 0)
 +                ret = s->pb->error;
 +            return ret;
 +        }
          return 1;
      }
  
  #if FF_API_COMPUTE_PKT_FIELDS2 && FF_API_LAVF_AVCTX
 -    ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
 +    ret = compute_muxer_pkt_fields(s, s->streams[pkt->stream_index], pkt);
  
      if (ret < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
          return ret;
  #endif
  
      ret = write_packet(s, pkt);
 +    if (ret >= 0 && s->pb && s->pb->error < 0)
 +        ret = s->pb->error;
  
      if (ret >= 0)
          s->streams[pkt->stream_index]->nb_frames++;
      return ret;
  }
  
 +#define CHUNK_START 0x1000
 +
  int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
  {
      int ret;
      AVPacketList **next_point, *this_pktl;
 +    AVStream *st   = s->streams[pkt->stream_index];
 +    int chunked    = s->max_chunk_size || s->max_chunk_duration;
  
      this_pktl      = av_mallocz(sizeof(AVPacketList));
      if (!this_pktl)
          return AVERROR(ENOMEM);
 -
 -    if ((ret = av_packet_ref(&this_pktl->pkt, pkt)) < 0) {
 -        av_free(this_pktl);
 -        return ret;
 +    if ((pkt->flags & AV_PKT_FLAG_UNCODED_FRAME)) {
 +        av_assert0(pkt->size == UNCODED_FRAME_PACKET_SIZE);
 +        av_assert0(((AVFrame *)pkt->data)->buf);
 +        this_pktl->pkt = *pkt;
 +        pkt->buf = NULL;
 +        pkt->side_data = NULL;
 +        pkt->side_data_elems = 0;
 +    } else {
 +        if ((ret = av_packet_ref(&this_pktl->pkt, pkt)) < 0) {
 +            av_free(this_pktl);
 +            return ret;
 +        }
      }
  
      if (s->streams[pkt->stream_index]->last_in_packet_buffer) {
 -        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
 -    } else
 +        next_point = &(st->last_in_packet_buffer->next);
 +    } else {
          next_point = &s->internal->packet_buffer;
 +    }
  
 +    if (chunked) {
 +        uint64_t max= av_rescale_q_rnd(s->max_chunk_duration, AV_TIME_BASE_Q, st->time_base, AV_ROUND_UP);
 +        st->interleaver_chunk_size     += pkt->size;
 +        st->interleaver_chunk_duration += pkt->duration;
 +        if (   (s->max_chunk_size && st->interleaver_chunk_size > s->max_chunk_size)
 +            || (max && st->interleaver_chunk_duration           > max)) {
 +            st->interleaver_chunk_size      = 0;
 +            this_pktl->pkt.flags |= CHUNK_START;
 +            if (max && st->interleaver_chunk_duration > max) {
 +                int64_t syncoffset = (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)*max/2;
 +                int64_t syncto = av_rescale(pkt->dts + syncoffset, 1, max)*max - syncoffset;
 +
 +                st->interleaver_chunk_duration += (pkt->dts - syncto)/8 - max;
 +            } else
 +                st->interleaver_chunk_duration = 0;
 +        }
 +    }
      if (*next_point) {
 +        if (chunked && !(this_pktl->pkt.flags & CHUNK_START))
 +            goto next_non_null;
 +
          if (compare(s, &s->internal->packet_buffer_end->pkt, pkt)) {
 -            while (!compare(s, &(*next_point)->pkt, pkt))
 +            while (   *next_point
 +                   && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
 +                       || !compare(s, &(*next_point)->pkt, pkt)))
                  next_point = &(*next_point)->next;
 -            goto next_non_null;
 +            if (*next_point)
 +                goto next_non_null;
          } else {
              next_point = &(s->internal->packet_buffer_end->next);
          }
      }
 -    assert(!*next_point);
 +    av_assert1(!*next_point);
  
      s->internal->packet_buffer_end = this_pktl;
  next_non_null:
@@@ -945,16 -544,6 +945,16 @@@ static int interleave_compare_dts(AVFor
      AVStream *st2 = s->streams[next->stream_index];
      int comp      = av_compare_ts(next->dts, st2->time_base, pkt->dts,
                                    st->time_base);
 +    if (s->audio_preload && ((st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) != (st2->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))) {
 +        int64_t ts = av_rescale_q(pkt ->dts, st ->time_base, AV_TIME_BASE_Q) - s->audio_preload*(st ->codecpar->codec_type == AVMEDIA_TYPE_AUDIO);
 +        int64_t ts2= av_rescale_q(next->dts, st2->time_base, AV_TIME_BASE_Q) - s->audio_preload*(st2->codecpar->codec_type == AVMEDIA_TYPE_AUDIO);
 +        if (ts == ts2) {
 +            ts= ( pkt ->dts* st->time_base.num*AV_TIME_BASE - s->audio_preload*(int64_t)(st ->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)* st->time_base.den)*st2->time_base.den
 +               -( next->dts*st2->time_base.num*AV_TIME_BASE - s->audio_preload*(int64_t)(st2->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)*st2->time_base.den)* st->time_base.den;
 +            ts2=0;
 +        }
 +        comp= (ts>ts2) - (ts<ts2);
 +    }
  
      if (comp == 0)
          return pkt->stream_index < next->stream_index;
@@@ -966,7 -555,6 +966,7 @@@ int ff_interleave_packet_per_dts(AVForm
  {
      AVPacketList *pktl;
      int stream_count = 0;
 +    int noninterleaved_count = 0;
      int i, ret;
  
      if (pkt) {
              return ret;
      }
  
 -    if (s->max_interleave_delta > 0 && s->internal->packet_buffer && !flush) {
 +    for (i = 0; i < s->nb_streams; i++) {
 +        if (s->streams[i]->last_in_packet_buffer) {
 +            ++stream_count;
 +        } else if (s->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_ATTACHMENT &&
 +                   s->streams[i]->codecpar->codec_id != AV_CODEC_ID_VP8 &&
 +                   s->streams[i]->codecpar->codec_id != AV_CODEC_ID_VP9) {
 +            ++noninterleaved_count;
 +        }
 +    }
 +
 +    if (s->internal->nb_interleaved_streams == stream_count)
 +        flush = 1;
 +
 +    if (s->max_interleave_delta > 0 &&
 +        s->internal->packet_buffer &&
 +        !flush &&
 +        s->internal->nb_interleaved_streams == stream_count+noninterleaved_count
 +    ) {
          AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
          int64_t delta_dts = INT64_MIN;
          int64_t top_dts = av_rescale_q(top_pkt->dts,
                                      s->streams[i]->time_base,
                                      AV_TIME_BASE_Q);
              delta_dts = FFMAX(delta_dts, last_dts - top_dts);
 -            stream_count++;
          }
  
          if (delta_dts > s->max_interleave_delta) {
                     delta_dts, s->max_interleave_delta);
              flush = 1;
          }
 -    } else {
 -        for (i = 0; i < s->nb_streams; i++)
 -            stream_count += !!s->streams[i]->last_in_packet_buffer;
      }
  
 -
 -    if (stream_count && (s->internal->nb_interleaved_streams == stream_count || flush)) {
 +    if (stream_count && flush) {
 +        AVStream *st;
          pktl = s->internal->packet_buffer;
          *out = pktl->pkt;
 +        st   = s->streams[out->stream_index];
  
          s->internal->packet_buffer = pktl->next;
          if (!s->internal->packet_buffer)
              s->internal->packet_buffer_end = NULL;
  
 -        if (s->streams[out->stream_index]->last_in_packet_buffer == pktl)
 -            s->streams[out->stream_index]->last_in_packet_buffer = NULL;
 +        if (st->last_in_packet_buffer == pktl)
 +            st->last_in_packet_buffer = NULL;
          av_freep(&pktl);
 +
          return 1;
      } else {
          av_init_packet(out);
      }
  }
  
+ const AVPacket *ff_interleaved_peek(AVFormatContext *s, int stream)
+ {
+     AVPacketList *pktl = s->internal->packet_buffer;
+     while (pktl) {
+         if (pktl->pkt.stream_index == stream)
+             return &pktl->pkt;
+         pktl = pktl->next;
+     }
+     return NULL;
+ }
  /**
   * Interleave an AVPacket correctly so it can be muxed.
   * @param out the interleaved packet will be output here
@@@ -1070,34 -654,12 +1081,34 @@@ int av_interleaved_write_frame(AVFormat
          goto fail;
  
      if (pkt) {
 -#if FF_API_COMPUTE_PKT_FIELDS2 && FF_API_LAVF_AVCTX
          AVStream *st = s->streams[pkt->stream_index];
  
 -        av_log(s, AV_LOG_TRACE, "av_interleaved_write_frame size:%d dts:%" PRId64 " pts:%" PRId64 "\n",
 -                pkt->size, pkt->dts, pkt->pts);
 -        if ((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
 +        if (s->oformat->check_bitstream) {
 +            if (!st->internal->bitstream_checked) {
 +                if ((ret = s->oformat->check_bitstream(s, pkt)) < 0)
 +                    goto fail;
 +                else if (ret == 1)
 +                    st->internal->bitstream_checked = 1;
 +            }
 +        }
 +
 +        av_apply_bitstream_filters(st->internal->avctx, pkt, st->internal->bsfc);
 +        if (pkt->size == 0 && pkt->side_data_elems == 0)
 +            return 0;
 +        if (!st->codecpar->extradata && st->internal->avctx->extradata) {
 +            int eret = ff_alloc_extradata(st->codecpar, st->internal->avctx->extradata_size);
 +            if (eret < 0)
 +                return AVERROR(ENOMEM);
 +            st->codecpar->extradata_size = st->internal->avctx->extradata_size;
 +            memcpy(st->codecpar->extradata, st->internal->avctx->extradata, st->internal->avctx->extradata_size);
 +        }
 +
 +        if (s->debug & FF_FDEBUG_TS)
 +            av_log(s, AV_LOG_TRACE, "av_interleaved_write_frame size:%d dts:%s pts:%s\n",
 +                pkt->size, av_ts2str(pkt->dts), av_ts2str(pkt->pts));
 +
 +#if FF_API_COMPUTE_PKT_FIELDS2 && FF_API_LAVF_AVCTX
 +        if ((ret = compute_muxer_pkt_fields(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
              goto fail;
  #endif
  
  
          if (ret < 0)
              return ret;
 +        if(s->pb && s->pb->error)
 +            return s->pb->error;
      }
  fail:
      av_packet_unref(pkt);
@@@ -1144,7 -704,7 +1155,7 @@@ int av_write_trailer(AVFormatContext *s
      for (;; ) {
          AVPacket pkt;
          ret = interleave_packet(s, &pkt, NULL, 1);
 -        if (ret < 0) //FIXME cleanup needed for ret<0 ?
 +        if (ret < 0)
              goto fail;
          if (!ret)
              break;
  
          if (ret < 0)
              goto fail;
 +        if(s->pb && s->pb->error)
 +            goto fail;
      }
  
 -    if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
 -        avio_write_marker(s->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_TRAILER);
 -    if (s->oformat->write_trailer)
 +    if (!s->internal->header_written) {
 +        ret = s->internal->write_header_ret ? s->internal->write_header_ret : write_header_internal(s);
 +        if (ret < 0)
 +            goto fail;
 +    }
 +
 +fail:
 +    if (s->internal->header_written && s->oformat->write_trailer) {
 +        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
 +            avio_write_marker(s->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_TRAILER);
 +        if (ret >= 0) {
          ret = s->oformat->write_trailer(s);
 +        } else {
 +            s->oformat->write_trailer(s);
 +        }
 +    }
  
 -    if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
 -        avio_flush(s->pb);
 +    if (s->oformat->deinit)
 +        s->oformat->deinit(s);
  
 -fail:
 +    if (s->pb)
 +       avio_flush(s->pb);
 +    if (ret == 0)
 +       ret = s->pb ? s->pb->error : 0;
      for (i = 0; i < s->nb_streams; i++) {
          av_freep(&s->streams[i]->priv_data);
          av_freep(&s->streams[i]->index_entries);
      return ret;
  }
  
 +int av_get_output_timestamp(struct AVFormatContext *s, int stream,
 +                            int64_t *dts, int64_t *wall)
 +{
 +    if (!s->oformat || !s->oformat->get_output_timestamp)
 +        return AVERROR(ENOSYS);
 +    s->oformat->get_output_timestamp(s, stream, dts, wall);
 +    return 0;
 +}
 +
  int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
 -                     AVFormatContext *src)
 +                     AVFormatContext *src, int interleave)
  {
      AVPacket local_pkt;
 +    int ret;
  
      local_pkt = *pkt;
      local_pkt.stream_index = dst_stream;
          local_pkt.dts = av_rescale_q(pkt->dts,
                                       src->streams[pkt->stream_index]->time_base,
                                       dst->streams[dst_stream]->time_base);
 -    return av_write_frame(dst, &local_pkt);
 +    if (pkt->duration)
 +        local_pkt.duration = av_rescale_q(pkt->duration,
 +                                          src->streams[pkt->stream_index]->time_base,
 +                                          dst->streams[dst_stream]->time_base);
 +
 +    if (interleave) ret = av_interleaved_write_frame(dst, &local_pkt);
 +    else            ret = av_write_frame(dst, &local_pkt);
 +    pkt->buf = local_pkt.buf;
 +    pkt->side_data       = local_pkt.side_data;
 +    pkt->side_data_elems = local_pkt.side_data_elems;
 +    return ret;
 +}
 +
 +static int av_write_uncoded_frame_internal(AVFormatContext *s, int stream_index,
 +                                           AVFrame *frame, int interleaved)
 +{
 +    AVPacket pkt, *pktp;
 +
 +    av_assert0(s->oformat);
 +    if (!s->oformat->write_uncoded_frame)
 +        return AVERROR(ENOSYS);
 +
 +    if (!frame) {
 +        pktp = NULL;
 +    } else {
 +        pktp = &pkt;
 +        av_init_packet(&pkt);
 +        pkt.data = (void *)frame;
 +        pkt.size         = UNCODED_FRAME_PACKET_SIZE;
 +        pkt.pts          =
 +        pkt.dts          = frame->pts;
 +        pkt.duration     = av_frame_get_pkt_duration(frame);
 +        pkt.stream_index = stream_index;
 +        pkt.flags |= AV_PKT_FLAG_UNCODED_FRAME;
 +    }
 +
 +    return interleaved ? av_interleaved_write_frame(s, pktp) :
 +                         av_write_frame(s, pktp);
 +}
 +
 +int av_write_uncoded_frame(AVFormatContext *s, int stream_index,
 +                           AVFrame *frame)
 +{
 +    return av_write_uncoded_frame_internal(s, stream_index, frame, 0);
 +}
 +
 +int av_interleaved_write_uncoded_frame(AVFormatContext *s, int stream_index,
 +                                       AVFrame *frame)
 +{
 +    return av_write_uncoded_frame_internal(s, stream_index, frame, 1);
 +}
 +
 +int av_write_uncoded_frame_query(AVFormatContext *s, int stream_index)
 +{
 +    av_assert0(s->oformat);
 +    if (!s->oformat->write_uncoded_frame)
 +        return AVERROR(ENOSYS);
 +    return s->oformat->write_uncoded_frame(s, stream_index, NULL,
 +                                           AV_WRITE_UNCODED_FRAME_QUERY);
  }
diff --combined libavformat/version.h
index 543afbb166449f0a3f7ad5449964d0b088a07ab9,1e1105fe5c5c5f2780bb5828b2a9b07f65b6c5ff..544d4363eb174d401cd93244a45ff87266d3a0dc
@@@ -1,20 -1,20 +1,20 @@@
  /*
   * Version macros.
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  
  #include "libavutil/version.h"
  
 -#define LIBAVFORMAT_VERSION_MAJOR 57
 -#define LIBAVFORMAT_VERSION_MINOR  7
 -#define LIBAVFORMAT_VERSION_MICRO  1
 +// Major bumping may affect Ticket5467, 5421, 5451(compatibility with Chromium)
 +// Also please add any ticket numbers that you belive might be affected here
 +#define LIBAVFORMAT_VERSION_MAJOR  57
 +#define LIBAVFORMAT_VERSION_MINOR  40
- #define LIBAVFORMAT_VERSION_MICRO 100
++#define LIBAVFORMAT_VERSION_MICRO 101
  
  #define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \
                                                 LIBAVFORMAT_VERSION_MINOR, \
   * FF_API_* defines may be placed below to indicate public API that will be
   * dropped at a future version bump. The defines themselves are not part of
   * the public API and may change, break or disappear at any time.
 + *
 + * @note, when bumping the major version it is recommended to manually
 + * disable each FF_API_* in its own commit instead of disabling them all
 + * at once through the bump. This improves the git bisect-ability of the change.
 + *
   */
  #ifndef FF_API_LAVF_BITEXACT
  #define FF_API_LAVF_BITEXACT            (LIBAVFORMAT_VERSION_MAJOR < 58)
  #ifndef FF_API_LAVF_CODEC_TB
  #define FF_API_LAVF_CODEC_TB            (LIBAVFORMAT_VERSION_MAJOR < 58)
  #endif
 +#ifndef FF_API_URL_FEOF
 +#define FF_API_URL_FEOF                 (LIBAVFORMAT_VERSION_MAJOR < 58)
 +#endif
  #ifndef FF_API_LAVF_FMT_RAWPICTURE
  #define FF_API_LAVF_FMT_RAWPICTURE      (LIBAVFORMAT_VERSION_MAJOR < 58)
  #endif
  #ifndef FF_API_COMPUTE_PKT_FIELDS2
  #define FF_API_COMPUTE_PKT_FIELDS2      (LIBAVFORMAT_VERSION_MAJOR < 58)
  #endif
 +#ifndef FF_API_OLD_OPEN_CALLBACKS
 +#define FF_API_OLD_OPEN_CALLBACKS       (LIBAVFORMAT_VERSION_MAJOR < 58)
 +#endif
  #ifndef FF_API_LAVF_AVCTX
  #define FF_API_LAVF_AVCTX               (LIBAVFORMAT_VERSION_MAJOR < 58)
  #endif
  
 +#ifndef FF_API_R_FRAME_RATE
 +#define FF_API_R_FRAME_RATE            1
 +#endif
  #endif /* AVFORMAT_VERSION_H */