Merge commit 'cf589faa5b7aed3bb38e08dcd00bd951e69686d1'
authorMichael Niedermayer <michaelni@gmx.at>
Fri, 31 Oct 2014 00:46:25 +0000 (01:46 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Fri, 31 Oct 2014 00:46:25 +0000 (01:46 +0100)
* commit 'cf589faa5b7aed3bb38e08dcd00bd951e69686d1':
  movenc: Add a flag for using default-base-is-moof in tfhd atoms

Conflicts:
libavformat/version.h

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
doc/muxers.texi
libavformat/movenc.c
libavformat/movenc.h
libavformat/version.h

diff --combined doc/muxers.texi
@@@ -1,10 -1,10 +1,10 @@@
  @chapter Muxers
  @c man begin MUXERS
  
 -Muxers are configured elements in Libav which allow writing
 +Muxers are configured elements in FFmpeg which allow writing
  multimedia streams to a particular type of file.
  
 -When you configure your Libav build, all the supported muxers
 +When you configure your FFmpeg build, all the supported muxers
  are enabled by default. You can list all available muxers using the
  configure option @code{--list-muxers}.
  
@@@ -13,30 -13,11 +13,30 @@@ You can disable all the muxers with th
  with the options @code{--enable-muxer=@var{MUXER}} /
  @code{--disable-muxer=@var{MUXER}}.
  
 -The option @code{-formats} of the av* tools will display the list of
 +The option @code{-formats} of the ff* tools will display the list of
  enabled muxers.
  
  A description of some of the currently available muxers follows.
  
 +@anchor{aiff}
 +@section aiff
 +
 +Audio Interchange File Format muxer.
 +
 +@subsection Options
 +
 +It accepts the following options:
 +
 +@table @option
 +@item write_id3v2
 +Enable ID3v2 tags writing when set to 1. Default is 0 (disabled).
 +
 +@item id3v2_version
 +Select ID3v2 version to write. Currently only version 3 and 4 (aka.
 +ID3v2.3 and ID3v2.4) are supported. The default is version 4.
 +
 +@end table
 +
  @anchor{crc}
  @section crc
  
@@@ -51,254 -32,95 +51,254 @@@ The output of the muxer consists of a s
  CRC=0x@var{CRC}, where @var{CRC} is a hexadecimal number 0-padded to
  8 digits containing the CRC for all the decoded input frames.
  
 +See also the @ref{framecrc} muxer.
 +
 +@subsection Examples
 +
  For example to compute the CRC of the input, and store it in the file
  @file{out.crc}:
  @example
 -avconv -i INPUT -f crc out.crc
 +ffmpeg -i INPUT -f crc out.crc
  @end example
  
  You can print the CRC to stdout with the command:
  @example
 -avconv -i INPUT -f crc -
 +ffmpeg -i INPUT -f crc -
  @end example
  
 -You can select the output format of each frame with @command{avconv} by
 +You can select the output format of each frame with @command{ffmpeg} by
  specifying the audio and video codec and format. For example to
  compute the CRC of the input audio converted to PCM unsigned 8-bit
  and the input video converted to MPEG-2 video, use the command:
  @example
 -avconv -i INPUT -c:a pcm_u8 -c:v mpeg2video -f crc -
 +ffmpeg -i INPUT -c:a pcm_u8 -c:v mpeg2video -f crc -
  @end example
  
 -See also the @ref{framecrc} muxer.
 -
  @anchor{framecrc}
  @section framecrc
  
 -Per-frame CRC (Cyclic Redundancy Check) testing format.
 +Per-packet CRC (Cyclic Redundancy Check) testing format.
  
 -This muxer computes and prints the Adler-32 CRC for each decoded audio
 -and video frame. By default audio frames are converted to signed
 +This muxer computes and prints the Adler-32 CRC for each audio
 +and video packet. By default audio frames are converted to signed
  16-bit raw audio and video frames to raw video before computing the
  CRC.
  
  The output of the muxer consists of a line for each audio and video
 -frame of the form: @var{stream_index}, @var{frame_dts},
 -@var{frame_size}, 0x@var{CRC}, where @var{CRC} is a hexadecimal
 -number 0-padded to 8 digits containing the CRC of the decoded frame.
 +packet of the form:
 +@example
 +@var{stream_index}, @var{packet_dts}, @var{packet_pts}, @var{packet_duration}, @var{packet_size}, 0x@var{CRC}
 +@end example
  
 -For example to compute the CRC of each decoded frame in the input, and
 -store it in the file @file{out.crc}:
 +@var{CRC} is a hexadecimal number 0-padded to 8 digits containing the
 +CRC of the packet.
 +
 +@subsection Examples
 +
 +For example to compute the CRC of the audio and video frames in
 +@file{INPUT}, converted to raw audio and video packets, and store it
 +in the file @file{out.crc}:
  @example
 -avconv -i INPUT -f framecrc out.crc
 +ffmpeg -i INPUT -f framecrc out.crc
  @end example
  
 -You can print the CRC of each decoded frame to stdout with the command:
 +To print the information to stdout, use the command:
  @example
 -avconv -i INPUT -f framecrc -
 +ffmpeg -i INPUT -f framecrc -
  @end example
  
 -You can select the output format of each frame with @command{avconv} by
 -specifying the audio and video codec and format. For example, to
 +With @command{ffmpeg}, you can select the output format to which the
 +audio and video frames are encoded before computing the CRC for each
 +packet by specifying the audio and video codec. For example, to
  compute the CRC of each decoded input audio frame converted to PCM
  unsigned 8-bit and of each decoded input video frame converted to
  MPEG-2 video, use the command:
  @example
 -avconv -i INPUT -c:a pcm_u8 -c:v mpeg2video -f framecrc -
 +ffmpeg -i INPUT -c:a pcm_u8 -c:v mpeg2video -f framecrc -
  @end example
  
  See also the @ref{crc} muxer.
  
 +@anchor{framemd5}
 +@section framemd5
 +
 +Per-packet MD5 testing format.
 +
 +This muxer computes and prints the MD5 hash for each audio
 +and video packet. By default audio frames are converted to signed
 +16-bit raw audio and video frames to raw video before computing the
 +hash.
 +
 +The output of the muxer consists of a line for each audio and video
 +packet of the form:
 +@example
 +@var{stream_index}, @var{packet_dts}, @var{packet_pts}, @var{packet_duration}, @var{packet_size}, @var{MD5}
 +@end example
 +
 +@var{MD5} is a hexadecimal number representing the computed MD5 hash
 +for the packet.
 +
 +@subsection Examples
 +
 +For example to compute the MD5 of the audio and video frames in
 +@file{INPUT}, converted to raw audio and video packets, and store it
 +in the file @file{out.md5}:
 +@example
 +ffmpeg -i INPUT -f framemd5 out.md5
 +@end example
 +
 +To print the information to stdout, use the command:
 +@example
 +ffmpeg -i INPUT -f framemd5 -
 +@end example
 +
 +See also the @ref{md5} muxer.
 +
 +@anchor{gif}
 +@section gif
 +
 +Animated GIF muxer.
 +
 +It accepts the following options:
 +
 +@table @option
 +@item loop
 +Set the number of times to loop the output. Use @code{-1} for no loop, @code{0}
 +for looping indefinitely (default).
 +
 +@item final_delay
 +Force the delay (expressed in centiseconds) after the last frame. Each frame
 +ends with a delay until the next frame. The default is @code{-1}, which is a
 +special value to tell the muxer to re-use the previous delay. In case of a
 +loop, you might want to customize this value to mark a pause for instance.
 +@end table
 +
 +For example, to encode a gif looping 10 times, with a 5 seconds delay between
 +the loops:
 +@example
 +ffmpeg -i INPUT -loop 10 -final_delay 500 out.gif
 +@end example
 +
 +Note 1: if you wish to extract the frames in separate GIF files, you need to
 +force the @ref{image2} muxer:
 +@example
 +ffmpeg -i INPUT -c:v gif -f image2 "out%d.gif"
 +@end example
 +
 +Note 2: the GIF format has a very small time base: the delay between two frames
 +can not be smaller than one centi second.
 +
  @anchor{hls}
  @section hls
  
  Apple HTTP Live Streaming muxer that segments MPEG-TS according to
 -the HTTP Live Streaming specification.
 +the HTTP Live Streaming (HLS) specification.
 +
 +It creates a playlist file, and one or more segment files. The output filename
 +specifies the playlist filename.
  
 -It creates a playlist file and numbered segment files. The output
 -filename specifies the playlist filename; the segment filenames
 -receive the same basename as the playlist, a sequential number and
 -a .ts extension.
 +By default, the muxer creates a file for each segment produced. These files
 +have the same name as the playlist, followed by a sequential number and a
 +.ts extension.
  
 +For example, to convert an input file with @command{ffmpeg}:
  @example
 -avconv -i in.nut out.m3u8
 +ffmpeg -i in.nut out.m3u8
  @end example
 +This example will produce the playlist, @file{out.m3u8}, and segment files:
 +@file{out0.ts}, @file{out1.ts}, @file{out2.ts}, etc.
 +
 +See also the @ref{segment} muxer, which provides a more generic and
 +flexible implementation of a segmenter, and can be used to perform HLS
 +segmentation.
 +
 +@subsection Options
 +
 +This muxer supports the following options:
  
  @table @option
 -@item -hls_time @var{seconds}
 -Set the segment length in seconds.
 -@item -hls_list_size @var{size}
 -Set the maximum number of playlist entries.
 -@item -hls_wrap @var{wrap}
 -Set the number after which index wraps.
 -@item -start_number @var{number}
 -Start the sequence from @var{number}.
 -@item -hls_base_url @var{baseurl}
 +@item hls_time @var{seconds}
 +Set the segment length in seconds. Default value is 2.
 +
 +@item hls_list_size @var{size}
 +Set the maximum number of playlist entries. If set to 0 the list file
 +will contain all the segments. Default value is 5.
 +
 +@item hls_ts_options @var{options_list}
 +Set output format options using a :-separated list of key=value
 +parameters. Values containing @code{:} special characters must be
 +escaped.
 +
 +@item hls_wrap @var{wrap}
 +Set the number after which the segment filename number (the number
 +specified in each segment file) wraps. If set to 0 the number will be
 +never wrapped. Default value is 0.
 +
 +This option is useful to avoid to fill the disk with many segment
 +files, and limits the maximum number of segment files written to disk
 +to @var{wrap}.
 +
 +@item start_number @var{number}
 +Start the playlist sequence number from @var{number}. Default value is
 +0.
 +
 +@item hls_allow_cache @var{allowcache}
 +Explicitly set whether the client MAY (1) or MUST NOT (0) cache media segments.
 +
 +@item hls_base_url @var{baseurl}
  Append @var{baseurl} to every entry in the playlist.
  Useful to generate playlists with absolute paths.
 -@item -hls_allow_cache @var{allowcache}
 -Explicitly set whether the client MAY (1) or MUST NOT (0) cache media segments
 +
 +Note that the playlist sequence number must be unique for each segment
 +and it is not to be confused with the segment filename sequence number
 +which can be cyclic, for example if the @option{wrap} option is
 +specified.
 +
 +@item hls_flags single_file
 +If this flag is set, the muxer will store all segments in a single MPEG-TS
 +file, and will use byte ranges in the playlist. HLS playlists generated with
 +this way will have the version number 4.
 +For example:
 +@example
 +ffmpeg -i in.nut -hls_flags single_file out.m3u8
 +@end example
 +Will produce the playlist, @file{out.m3u8}, and a single segment file,
 +@file{out.ts}.
  @end table
  
 +@anchor{ico}
 +@section ico
 +
 +ICO file muxer.
 +
 +Microsoft's icon file format (ICO) has some strict limitations that should be noted:
 +
 +@itemize
 +@item
 +Size cannot exceed 256 pixels in any dimension
 +
 +@item
 +Only BMP and PNG images can be stored
 +
 +@item
 +If a BMP image is used, it must be one of the following pixel formats:
 +@example
 +BMP Bit Depth      FFmpeg Pixel Format
 +1bit               pal8
 +4bit               pal8
 +8bit               pal8
 +16bit              rgb555le
 +24bit              bgr24
 +32bit              bgra
 +@end example
 +
 +@item
 +If a BMP image is used, it must use the BITMAPINFOHEADER DIB header
 +
 +@item
 +If a PNG image is used, it must use the rgba pixel format
 +@end itemize
 +
  @anchor{image2}
  @section image2
  
@@@ -329,91 -151,64 +329,91 @@@ The pattern "img%%-%d.jpg" will specif
  form @file{img%-1.jpg}, @file{img%-2.jpg}, ..., @file{img%-10.jpg},
  etc.
  
 -The following example shows how to use @command{avconv} for creating a
 +@subsection Examples
 +
 +The following example shows how to use @command{ffmpeg} for creating a
  sequence of files @file{img-001.jpeg}, @file{img-002.jpeg}, ...,
  taking one image every second from the input video:
  @example
 -avconv -i in.avi -vsync 1 -r 1 -f image2 'img-%03d.jpeg'
 +ffmpeg -i in.avi -vsync 1 -r 1 -f image2 'img-%03d.jpeg'
  @end example
  
 -Note that with @command{avconv}, if the format is not specified with the
 +Note that with @command{ffmpeg}, if the format is not specified with the
  @code{-f} option and the output filename specifies an image file
  format, the image2 muxer is automatically selected, so the previous
  command can be written as:
  @example
 -avconv -i in.avi -vsync 1 -r 1 'img-%03d.jpeg'
 +ffmpeg -i in.avi -vsync 1 -r 1 'img-%03d.jpeg'
  @end example
  
  Note also that the pattern must not necessarily contain "%d" or
  "%0@var{N}d", for example to create a single image file
  @file{img.jpeg} from the input video you can employ the command:
  @example
 -avconv -i in.avi -f image2 -frames:v 1 img.jpeg
 +ffmpeg -i in.avi -f image2 -frames:v 1 img.jpeg
  @end example
  
 -@table @option
 -@item -start_number @var{number}
 -Start the sequence from @var{number}.
 +The @option{strftime} option allows you to expand the filename with
 +date and time information. Check the documentation of
 +the @code{strftime()} function for the syntax.
  
 -@item -update @var{number}
 -If @var{number} is nonzero, the filename will always be interpreted as just a
 -filename, not a pattern, and this file will be continuously overwritten with new
 -images.
 +For example to generate image files from the @code{strftime()}
 +"%Y-%m-%d_%H-%M-%S" pattern, the following @command{ffmpeg} command
 +can be used:
 +@example
 +ffmpeg -f v4l2 -r 1 -i /dev/video0 -f image2 -strftime 1 "%Y-%m-%d_%H-%M-%S.jpg"
 +@end example
  
 +@subsection Options
 +
 +@table @option
 +@item start_number
 +Start the sequence from the specified number. Default value is 1. Must
 +be a non-negative number.
 +
 +@item update
 +If set to 1, the filename will always be interpreted as just a
 +filename, not a pattern, and the corresponding file will be continuously
 +overwritten with new images. Default value is 0.
 +
 +@item strftime
 +If set to 1, expand the filename with date and time information from
 +@code{strftime()}. Default value is 0.
  @end table
  
 +The image muxer supports the .Y.U.V image file format. This format is
 +special in that that each image frame consists of three files, for
 +each of the YUV420P components. To read or write this image file format,
 +specify the name of the '.Y' file. The muxer will automatically open the
 +'.U' and '.V' files as required.
 +
  @section matroska
  
  Matroska container muxer.
  
  This muxer implements the matroska and webm container specs.
  
 +@subsection Metadata
 +
  The recognized metadata settings in this muxer are:
  
  @table @option
 +@item title
 +Set title name provided to a single track.
  
 -@item title=@var{title name}
 -Name provided to a single track
 -@end table
 +@item language
 +Specify the language of the track in the Matroska languages form.
  
 -@table @option
 +The language can be either the 3 letters bibliographic ISO-639-2 (ISO
 +639-2/B) form (like "fre" for French), or a language code mixed with a
 +country code for specialities in languages (like "fre-ca" for Canadian
 +French).
  
 -@item language=@var{language name}
 -Specifies the language of the track in the Matroska languages form
 -@end table
 -
 -@table @option
 +@item stereo_mode
 +Set stereo 3D video layout of two views in a single video track.
  
 -@item STEREO_MODE=@var{mode}
 -Stereo 3D video layout of two views in a single video track
 -@table @option
 +The following values are recognized:
 +@table @samp
  @item mono
  video is not stereo
  @item left_right
@@@ -449,14 -244,13 +449,14 @@@ Both eyes laced in one Block, Right-ey
  
  For example a 3D WebM clip can be created using the following command line:
  @example
 -avconv -i sample_left_right_clip.mpg -an -c:v libvpx -metadata STEREO_MODE=left_right -y stereo_clip.webm
 +ffmpeg -i sample_left_right_clip.mpg -an -c:v libvpx -metadata stereo_mode=left_right -y stereo_clip.webm
  @end example
  
 +@subsection Options
 +
  This muxer supports the following options:
  
  @table @option
 -
  @item reserve_index_space
  By default, this muxer writes the index for seeking (called cues in Matroska
  terms) at the end of the file, because it cannot know in advance how much space
@@@ -471,44 -265,15 +471,44 @@@ for most use cases should be about 50k
  
  Note that cues are only written if the output is seekable and this option will
  have no effect if it is not.
 -
  @end table
  
 +@anchor{md5}
 +@section md5
 +
 +MD5 testing format.
 +
 +This muxer computes and prints the MD5 hash of all the input audio
 +and video frames. By default audio frames are converted to signed
 +16-bit raw audio and video frames to raw video before computing the
 +hash.
 +
 +The output of the muxer consists of a single line of the form:
 +MD5=@var{MD5}, where @var{MD5} is a hexadecimal number representing
 +the computed MD5 hash.
 +
 +For example to compute the MD5 hash of the input converted to raw
 +audio and video, and store it in the file @file{out.md5}:
 +@example
 +ffmpeg -i INPUT -f md5 out.md5
 +@end example
 +
 +You can print the MD5 to stdout with the command:
 +@example
 +ffmpeg -i INPUT -f md5 -
 +@end example
 +
 +See also the @ref{framemd5} muxer.
 +
  @section mov, mp4, ismv
  
 +MOV/MP4/ISMV (Smooth Streaming) muxer.
 +
  The mov/mp4/ismv muxer supports fragmentation. Normally, a MOV/MP4
  file has all the metadata about all packets stored in one location
  (written at the end of the file, it can be moved to the start for
 -better playback using the @command{qt-faststart} tool). A fragmented
 +better playback by adding @var{faststart} to the @var{movflags}, or
 +using the @command{qt-faststart} tool). A fragmented
  file consists of a number of fragments, where packets and metadata
  about these packets are stored together. Writing a fragmented
  file has the advantage that the file is decodable even if the
@@@ -518,15 -283,10 +518,15 @@@ very long files (since writing normal M
  every single packet in memory until the file is closed). The downside
  is that it is less compatible with other applications.
  
 +@subsection Options
 +
  Fragmentation is enabled by setting one of the AVOptions that define
  how to cut the file into fragments:
  
  @table @option
 +@item -moov_size @var{bytes}
 +Reserves space for the moov atom at the beginning of the file instead of placing the
 +moov atom at the end. If the space reserved is insufficient, muxing will fail.
  @item -movflags frag_keyframe
  Start a new fragment at each video keyframe.
  @item -frag_duration @var{duration}
@@@ -537,7 -297,7 +537,7 @@@ Create fragments that contain up to @va
  Allow the caller to manually choose when to cut fragments, by
  calling @code{av_write_frame(ctx, NULL)} to write a fragment with
  the packets written so far. (This is only useful with other
 -applications integrating libavformat, not from @command{avconv}.)
 +applications integrating libavformat, not from @command{ffmpeg}.)
  @item -min_frag_duration @var{duration}
  Don't create fragments that are shorter than @var{duration} microseconds long.
  @end table
@@@ -572,25 -332,27 +572,32 @@@ This option is implicitly set when writ
  Run a second pass moving the index (moov atom) to the beginning of the file.
  This operation can take a while, and will not work in various situations such
  as fragmented output, thus it is not enabled by default.
 +@item -movflags rtphint
 +Add RTP hinting tracks to the output file.
  @item -movflags disable_chpl
  Disable Nero chapter markers (chpl atom).  Normally, both Nero chapters
  and a QuickTime chapter track are written to the file. With this option
  set, only the QuickTime chapter track will be written. Nero chapters can
 -cause failures when the file is reprocessed with certain tagging programs.
 +cause failures when the file is reprocessed with certain tagging programs, like
 +mp3Tag 2.61a and iTunes 11.3, most likely other versions are affected as well.
  @item -movflags omit_tfhd_offset
  Do not write any absolute base_data_offset in tfhd atoms. This avoids
  tying fragments to absolute byte positions in the file/streams.
+ @item -movflags default_base_moof
+ Similarly to the omit_tfhd_offset, this flag avoids writing the
+ absolute base_data_offset field in tfhd atoms, but does so by using
+ the new default-base-is-moof flag instead. This flag is new from
+ 14496-12:2012. This may make the fragments easier to parse in certain
+ circumstances (avoiding basing track fragment location calculations
+ on the implicit end of the previous track fragment).
  @end table
  
 +@subsection Example
 +
  Smooth Streaming content can be pushed in real time to a publishing
  point on IIS with this muxer. Example:
  @example
 -avconv -re @var{<normal input/transcoding options>} -movflags isml+frag_keyframe -f ismv http://server/publishingpoint.isml/Streams(Encoder1)
 +ffmpeg -re @var{<normal input/transcoding options>} -movflags isml+frag_keyframe -f ismv http://server/publishingpoint.isml/Streams(Encoder1)
  @end example
  
  @section mp3
@@@ -631,19 -393,18 +638,19 @@@ Examples
  
  Write an mp3 with an ID3v2.3 header and an ID3v1 footer:
  @example
 -avconv -i INPUT -id3v2_version 3 -write_id3v1 1 out.mp3
 +ffmpeg -i INPUT -id3v2_version 3 -write_id3v1 1 out.mp3
  @end example
  
 -Attach a picture to an mp3:
 +To attach a picture to an mp3 file select both the audio and the picture stream
 +with @code{map}:
  @example
 -avconv -i input.mp3 -i cover.png -c copy -metadata:s:v title="Album cover"
 --metadata:s:v comment="Cover (Front)" out.mp3
 +ffmpeg -i input.mp3 -i cover.png -c copy -map 0 -map 1
 +-metadata:s:v title="Album cover" -metadata:s:v comment="Cover (Front)" out.mp3
  @end example
  
  Write a "clean" MP3 without any extra features:
  @example
 -avconv -i input.wav -write_xing 0 -id3v2_version 0 out.mp3
 +ffmpeg -i input.wav -write_xing 0 -id3v2_version 0 out.mp3
  @end example
  
  @section mpegts
@@@ -652,13 -413,6 +659,13 @@@ MPEG transport stream muxer
  
  This muxer implements ISO 13818-1 and part of ETSI EN 300 468.
  
 +The recognized metadata settings in mpegts muxer are @code{service_provider}
 +and @code{service_name}. If they are not set the default for
 +@code{service_provider} is "FFmpeg" and the default for
 +@code{service_name} is "Service01".
 +
 +@subsection Options
 +
  The muxer options are:
  
  @table @option
@@@ -675,49 -429,20 +682,49 @@@ Set the service_id (default 0x0001) als
  Set the first PID for PMT (default 0x1000, max 0x1f00).
  @item -mpegts_start_pid @var{number}
  Set the first PID for data packets (default 0x0100, max 0x0f00).
 +@item -mpegts_m2ts_mode @var{number}
 +Enable m2ts mode if set to 1. Default value is -1 which disables m2ts mode.
  @item -muxrate @var{number}
  Set a constant muxrate (default VBR).
  @item -pcr_period @var{numer}
  Override the default PCR retransmission time (default 20ms), ignored
  if variable muxrate is selected.
 +@item -pes_payload_size @var{number}
 +Set minimum PES packet payload in bytes.
 +@item -mpegts_flags @var{flags}
 +Set flags (see below).
 +@item -mpegts_copyts @var{number}
 +Preserve original timestamps, if value is set to 1. Default value is -1, which
 +results in shifting timestamps so that they start from 0.
 +@item -tables_version @var{number}
 +Set PAT, PMT and SDT version (default 0, valid values are from 0 to 31, inclusively).
 +This option allows updating stream structure so that standard consumer may
 +detect the change. To do so, reopen output AVFormatContext (in case of API
 +usage) or restart ffmpeg instance, cyclically changing tables_version value:
 +@example
 +ffmpeg -i source1.ts -codec copy -f mpegts -tables_version 0 udp://1.1.1.1:1111
 +ffmpeg -i source2.ts -codec copy -f mpegts -tables_version 1 udp://1.1.1.1:1111
 +...
 +ffmpeg -i source3.ts -codec copy -f mpegts -tables_version 31 udp://1.1.1.1:1111
 +ffmpeg -i source1.ts -codec copy -f mpegts -tables_version 0 udp://1.1.1.1:1111
 +ffmpeg -i source2.ts -codec copy -f mpegts -tables_version 1 udp://1.1.1.1:1111
 +...
 +@end example
  @end table
  
 -The recognized metadata settings in mpegts muxer are @code{service_provider}
 -and @code{service_name}. If they are not set the default for
 -@code{service_provider} is "Libav" and the default for
 -@code{service_name} is "Service01".
 +Option mpegts_flags may take a set of such flags:
 +
 +@table @option
 +@item resend_headers
 +Reemit PAT/PMT before writing the next packet.
 +@item latm
 +Use LATM packetization for AAC.
 +@end table
 +
 +@subsection Example
  
  @example
 -avconv -i file.mpg -c copy \
 +ffmpeg -i file.mpg -c copy \
       -mpegts_original_network_id 0x1122 \
       -mpegts_transport_stream_id 0x3344 \
       -mpegts_service_id 0x5566 \
@@@ -735,19 -460,19 +742,19 @@@ Null muxer
  This muxer does not generate any output file, it is mainly useful for
  testing or benchmarking purposes.
  
 -For example to benchmark decoding with @command{avconv} you can use the
 +For example to benchmark decoding with @command{ffmpeg} you can use the
  command:
  @example
 -avconv -benchmark -i INPUT -f null out.null
 +ffmpeg -benchmark -i INPUT -f null out.null
  @end example
  
  Note that the above command does not read or write the @file{out.null}
 -file, but specifying the output file is required by the @command{avconv}
 +file, but specifying the output file is required by the @command{ffmpeg}
  syntax.
  
  Alternatively you can write the command as:
  @example
 -avconv -benchmark -i INPUT -f null -
 +ffmpeg -benchmark -i INPUT -f null -
  @end example
  
  @section nut
@@@ -758,20 -483,13 +765,20 @@@ Change the syncpoint usage in nut
  @table @option
  @item @var{default} use the normal low-overhead seeking aids.
  @item @var{none} do not use the syncpoints at all, reducing the overhead but making the stream non-seekable;
 +    Use of this option is not recommended, as the resulting files are very damage
 +    sensitive and seeking is not possible. Also in general the overhead from
 +    syncpoints is negligible. Note, -@code{write_index} 0 can be used to disable
 +    all growing data tables, allowing to mux endless streams with limited memory
 +    and wihout these disadvantages.
  @item @var{timestamped} extend the syncpoint with a wallclock field.
  @end table
  The @var{none} and @var{timestamped} flags are experimental.
 +@item -write_index @var{bool}
 +Write index at the end, the default is to write an index.
  @end table
  
  @example
 -avconv -i INPUT -f_strict experimental -syncpoints none - | processor
 +ffmpeg -i INPUT -f_strict experimental -syncpoints none - | processor
  @end example
  
  @section ogg
@@@ -789,397 -507,44 +796,397 @@@ situations, giving a small seek granula
  overhead.
  @end table
  
 -@section segment
 +@anchor{segment}
 +@section segment, stream_segment, ssegment
  
  Basic stream segmenter.
  
 -The segmenter muxer outputs streams to a number of separate files of nearly
 +This muxer outputs streams to a number of separate files of nearly
  fixed duration. Output filename pattern can be set in a fashion similar to
  @ref{image2}.
  
 -Every segment starts with a video keyframe, if a video stream is present.
 +@code{stream_segment} is a variant of the muxer used to write to
 +streaming output formats, i.e. which do not require global headers,
 +and is recommended for outputting e.g. to MPEG transport stream segments.
 +@code{ssegment} is a shorter alias for @code{stream_segment}.
 +
 +Every segment starts with a keyframe of the selected reference stream,
 +which is set through the @option{reference_stream} option.
 +
 +Note that if you want accurate splitting for a video file, you need to
 +make the input key frames correspond to the exact splitting times
 +expected by the segmenter, or the segment muxer will start the new
 +segment with the key frame found next after the specified start
 +time.
 +
  The segment muxer works best with a single constant frame rate video.
  
 -Optionally it can generate a flat list of the created segments, one segment
 -per line.
 +Optionally it can generate a list of the created segments, by setting
 +the option @var{segment_list}. The list type is specified by the
 +@var{segment_list_type} option. The entry filenames in the segment
 +list are set by default to the basename of the corresponding segment
 +files.
 +
 +See also the @ref{hls} muxer, which provides a more specific
 +implementation for HLS segmentation.
 +
 +@subsection Options
 +
 +The segment muxer supports the following options:
  
  @table @option
 +@item reference_stream @var{specifier}
 +Set the reference stream, as specified by the string @var{specifier}.
 +If @var{specifier} is set to @code{auto}, the reference is chosen
 +automatically. Otherwise it must be a stream specifier (see the ``Stream
 +specifiers'' chapter in the ffmpeg manual) which specifies the
 +reference stream. The default value is @code{auto}.
 +
  @item segment_format @var{format}
  Override the inner container format, by default it is guessed by the filename
  extension.
 -@item segment_time @var{t}
 -Set segment duration to @var{t} seconds.
 +
 +@item segment_format_options @var{options_list}
 +Set output format options using a :-separated list of key=value
 +parameters. Values containing the @code{:} special character must be
 +escaped.
 +
  @item segment_list @var{name}
 -Generate also a listfile named @var{name}.
 +Generate also a listfile named @var{name}. If not specified no
 +listfile is generated.
 +
 +@item segment_list_flags @var{flags}
 +Set flags affecting the segment list generation.
 +
 +It currently supports the following flags:
 +@table @samp
 +@item cache
 +Allow caching (only affects M3U8 list files).
 +
 +@item live
 +Allow live-friendly file generation.
 +@end table
 +
  @item segment_list_type @var{type}
  Select the listing format.
  @table @option
  @item @var{flat} use a simple flat list of entries.
  @item @var{hls} use a m3u8-like structure.
  @end table
 +
  @item segment_list_size @var{size}
 -Overwrite the listfile once it reaches @var{size} entries.
 +Update the list file so that it contains at most @var{size}
 +segments. If 0 the list file will contain all the segments. Default
 +value is 0.
 +
  @item segment_list_entry_prefix @var{prefix}
  Prepend @var{prefix} to each entry. Useful to generate absolute paths.
 +By default no prefix is applied.
 +
 +The following values are recognized:
 +@table @samp
 +@item flat
 +Generate a flat list for the created segments, one segment per line.
 +
 +@item csv, ext
 +Generate a list for the created segments, one segment per line,
 +each line matching the format (comma-separated values):
 +@example
 +@var{segment_filename},@var{segment_start_time},@var{segment_end_time}
 +@end example
 +
 +@var{segment_filename} is the name of the output file generated by the
 +muxer according to the provided pattern. CSV escaping (according to
 +RFC4180) is applied if required.
 +
 +@var{segment_start_time} and @var{segment_end_time} specify
 +the segment start and end time expressed in seconds.
 +
 +A list file with the suffix @code{".csv"} or @code{".ext"} will
 +auto-select this format.
 +
 +@samp{ext} is deprecated in favor or @samp{csv}.
 +
 +@item ffconcat
 +Generate an ffconcat file for the created segments. The resulting file
 +can be read using the FFmpeg @ref{concat} demuxer.
 +
 +A list file with the suffix @code{".ffcat"} or @code{".ffconcat"} will
 +auto-select this format.
 +
 +@item m3u8
 +Generate an extended M3U8 file, version 3, compliant with
 +@url{http://tools.ietf.org/id/draft-pantos-http-live-streaming}.
 +
 +A list file with the suffix @code{".m3u8"} will auto-select this format.
 +@end table
 +
 +If not specified the type is guessed from the list file name suffix.
 +
 +@item segment_time @var{time}
 +Set segment duration to @var{time}, the value must be a duration
 +specification. Default value is "2". See also the
 +@option{segment_times} option.
 +
 +Note that splitting may not be accurate, unless you force the
 +reference stream key-frames at the given time. See the introductory
 +notice and the examples below.
 +
 +@item segment_atclocktime @var{1|0}
 +If set to "1" split at regular clock time intervals starting from 00:00
 +o'clock. The @var{time} value specified in @option{segment_time} is
 +used for setting the length of the splitting interval.
 +
 +For example with @option{segment_time} set to "900" this makes it possible
 +to create files at 12:00 o'clock, 12:15, 12:30, etc.
 +
 +Default value is "0".
 +
 +@item segment_time_delta @var{delta}
 +Specify the accuracy time when selecting the start time for a
 +segment, expressed as a duration specification. Default value is "0".
 +
 +When delta is specified a key-frame will start a new segment if its
 +PTS satisfies the relation:
 +@example
 +PTS >= start_time - time_delta
 +@end example
 +
 +This option is useful when splitting video content, which is always
 +split at GOP boundaries, in case a key frame is found just before the
 +specified split time.
 +
 +In particular may be used in combination with the @file{ffmpeg} option
 +@var{force_key_frames}. The key frame times specified by
 +@var{force_key_frames} may not be set accurately because of rounding
 +issues, with the consequence that a key frame time may result set just
 +before the specified time. For constant frame rate videos a value of
 +1/(2*@var{frame_rate}) should address the worst case mismatch between
 +the specified time and the time set by @var{force_key_frames}.
 +
 +@item segment_times @var{times}
 +Specify a list of split points. @var{times} contains a list of comma
 +separated duration specifications, in increasing order. See also
 +the @option{segment_time} option.
 +
 +@item segment_frames @var{frames}
 +Specify a list of split video frame numbers. @var{frames} contains a
 +list of comma separated integer numbers, in increasing order.
 +
 +This option specifies to start a new segment whenever a reference
 +stream key frame is found and the sequential number (starting from 0)
 +of the frame is greater or equal to the next value in the list.
 +
  @item segment_wrap @var{limit}
  Wrap around segment index once it reaches @var{limit}.
 +
 +@item segment_start_number @var{number}
 +Set the sequence number of the first segment. Defaults to @code{0}.
 +
 +@item reset_timestamps @var{1|0}
 +Reset timestamps at the begin of each segment, so that each segment
 +will start with near-zero timestamps. It is meant to ease the playback
 +of the generated segments. May not work with some combinations of
 +muxers/codecs. It is set to @code{0} by default.
 +
 +@item initial_offset @var{offset}
 +Specify timestamp offset to apply to the output packet timestamps. The
 +argument must be a time duration specification, and defaults to 0.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Remux the content of file @file{in.mkv} to a list of segments
 +@file{out-000.nut}, @file{out-001.nut}, etc., and write the list of
 +generated segments to @file{out.list}:
 +@example
 +ffmpeg -i in.mkv -codec copy -map 0 -f segment -segment_list out.list out%03d.nut
 +@end example
 +
 +@item
 +Segment input and set output format options for the output segments:
 +@example
 +ffmpeg -i in.mkv -f segment -segment_time 10 -segment_format_options movflags=+faststart out%03d.mp4
 +@end example
 +
 +@item
 +Segment the input file according to the split points specified by the
 +@var{segment_times} option:
 +@example
 +ffmpeg -i in.mkv -codec copy -map 0 -f segment -segment_list out.csv -segment_times 1,2,3,5,8,13,21 out%03d.nut
 +@end example
 +
 +@item
 +Use the @command{ffmpeg} @option{force_key_frames}
 +option to force key frames in the input at the specified location, together
 +with the segment option @option{segment_time_delta} to account for
 +possible roundings operated when setting key frame times.
 +@example
 +ffmpeg -i in.mkv -force_key_frames 1,2,3,5,8,13,21 -codec:v mpeg4 -codec:a pcm_s16le -map 0 \
 +-f segment -segment_list out.csv -segment_times 1,2,3,5,8,13,21 -segment_time_delta 0.05 out%03d.nut
 +@end example
 +In order to force key frames on the input file, transcoding is
 +required.
 +
 +@item
 +Segment the input file by splitting the input file according to the
 +frame numbers sequence specified with the @option{segment_frames} option:
 +@example
 +ffmpeg -i in.mkv -codec copy -map 0 -f segment -segment_list out.csv -segment_frames 100,200,300,500,800 out%03d.nut
 +@end example
 +
 +@item
 +Convert the @file{in.mkv} to TS segments using the @code{libx264}
 +and @code{libfaac} encoders:
 +@example
 +ffmpeg -i in.mkv -map 0 -codec:v libx264 -codec:a libfaac -f ssegment -segment_list out.list out%03d.ts
 +@end example
 +
 +@item
 +Segment the input file, and create an M3U8 live playlist (can be used
 +as live HLS source):
 +@example
 +ffmpeg -re -i in.mkv -codec copy -map 0 -f segment -segment_list playlist.m3u8 \
 +-segment_list_flags +live -segment_time 10 out%03d.mkv
 +@end example
 +@end itemize
 +
 +@section smoothstreaming
 +
 +Smooth Streaming muxer generates a set of files (Manifest, chunks) suitable for serving with conventional web server.
 +
 +@table @option
 +@item window_size
 +Specify the number of fragments kept in the manifest. Default 0 (keep all).
 +
 +@item extra_window_size
 +Specify the number of fragments kept outside of the manifest before removing from disk. Default 5.
 +
 +@item lookahead_count
 +Specify the number of lookahead fragments. Default 2.
 +
 +@item min_frag_duration
 +Specify the minimum fragment duration (in microseconds). Default 5000000.
 +
 +@item remove_at_exit
 +Specify whether to remove all fragments when finished. Default 0 (do not remove).
 +
 +@end table
 +
 +@section tee
 +
 +The tee muxer can be used to write the same data to several files or any
 +other kind of muxer. It can be used, for example, to both stream a video to
 +the network and save it to disk at the same time.
 +
 +It is different from specifying several outputs to the @command{ffmpeg}
 +command-line tool because the audio and video data will be encoded only once
 +with the tee muxer; encoding can be a very expensive process. It is not
 +useful when using the libavformat API directly because it is then possible
 +to feed the same packets to several muxers directly.
 +
 +The slave outputs are specified in the file name given to the muxer,
 +separated by '|'. If any of the slave name contains the '|' separator,
 +leading or trailing spaces or any special character, it must be
 +escaped (see @ref{quoting_and_escaping,,the "Quoting and escaping"
 +section in the ffmpeg-utils(1) manual,ffmpeg-utils}).
 +
 +Muxer options can be specified for each slave by prepending them as a list of
 +@var{key}=@var{value} pairs separated by ':', between square brackets. If
 +the options values contain a special character or the ':' separator, they
 +must be escaped; note that this is a second level escaping.
 +
 +The following special options are also recognized:
 +@table @option
 +@item f
 +Specify the format name. Useful if it cannot be guessed from the
 +output name suffix.
 +
 +@item bsfs[/@var{spec}]
 +Specify a list of bitstream filters to apply to the specified
 +output.
 +
 +It is possible to specify to which streams a given bitstream filter
 +applies, by appending a stream specifier to the option separated by
 +@code{/}. @var{spec} must be a stream specifier (see @ref{Format
 +stream specifiers}).  If the stream specifier is not specified, the
 +bitstream filters will be applied to all streams in the output.
 +
 +Several bitstream filters can be specified, separated by ",".
 +
 +@item select
 +Select the streams that should be mapped to the slave output,
 +specified by a stream specifier. If not specified, this defaults to
 +all the input streams.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Encode something and both archive it in a WebM file and stream it
 +as MPEG-TS over UDP (the streams need to be explicitly mapped):
 +@example
 +ffmpeg -i ... -c:v libx264 -c:a mp2 -f tee -map 0:v -map 0:a
 +  "archive-20121107.mkv|[f=mpegts]udp://10.0.1.255:1234/"
 +@end example
 +
 +@item
 +Use @command{ffmpeg} to encode the input, and send the output
 +to three different destinations. The @code{dump_extra} bitstream
 +filter is used to add extradata information to all the output video
 +keyframes packets, as requested by the MPEG-TS format. The select
 +option is applied to @file{out.aac} in order to make it contain only
 +audio packets.
 +@example
 +ffmpeg -i ... -map 0 -flags +global_header -c:v libx264 -c:a aac -strict experimental
 +       -f tee "[bsfs/v=dump_extra]out.ts|[movflags=+faststart]out.mp4|[select=a]out.aac"
 +@end example
 +
 +@item
 +As below, but select only stream @code{a:1} for the audio output. Note
 +that a second level escaping must be performed, as ":" is a special
 +character used to separate options.
 +@example
 +ffmpeg -i ... -map 0 -flags +global_header -c:v libx264 -c:a aac -strict experimental
 +       -f tee "[bsfs/v=dump_extra]out.ts|[movflags=+faststart]out.mp4|[select=\'a:1\']out.aac"
 +@end example
 +@end itemize
 +
 +Note: some codecs may need different options depending on the output format;
 +the auto-detection of this can not work with the tee muxer. The main example
 +is the @option{global_header} flag.
 +
 +@section webm_dash_manifest
 +
 +WebM DASH Manifest muxer.
 +
 +This muxer implements the WebM DASH Manifest specification to generate the DASH manifest XML.
 +
 +@subsection Options
 +
 +This muxer supports the following options:
 +
 +@table @option
 +@item adaptation_sets
 +This option has the following syntax: "id=x,streams=a,b,c id=y,streams=d,e" where x and y are the
 +unique identifiers of the adaptation sets and a,b,c,d and e are the indices of the corresponding
 +audio and video streams. Any number of adaptation sets can be added using this option.
  @end table
  
 +@subsection Example
  @example
 -avconv -i in.mkv -c copy -map 0 -f segment -list out.list out%03d.nut
 +ffmpeg -f webm_dash_manifest -i video1.webm \
 +       -f webm_dash_manifest -i video2.webm \
 +       -f webm_dash_manifest -i audio1.webm \
 +       -f webm_dash_manifest -i audio2.webm \
 +       -map 0 -map 1 -map 2 -map 3 \
 +       -c copy \
 +       -f webm_dash_manifest \
 +       -adaptation_sets "id=0,streams=0,1 id=1,streams=2,3" \
 +       manifest.xml
  @end example
  
  @c man end MUXERS
diff --combined libavformat/movenc.c
@@@ -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/opt.h"
  #include "libavutil/dict.h"
 +#include "libavutil/pixdesc.h"
 +#include "libavutil/timecode.h"
  #include "hevc.h"
  #include "rtpenc.h"
  #include "mov_chan.h"
@@@ -54,7 -50,6 +54,7 @@@
  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 (not supported by QuickTime)", 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" },
      { "faststart", "Run a second pass to put the index (moov atom) at the beginning of the file", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_FASTSTART}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
      { "omit_tfhd_offset", "Omit the base data offset in tfhd atoms", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_OMIT_TFHD_OFFSET}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
      { "disable_chpl", "Disable Nero chapter atom", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_DISABLE_CHPL}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
+     { "default_base_moof", "Set the default-base-is-moof flag in tfhd atoms", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_DEFAULT_BASE_MOOF}, 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_INT, {.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},
 +    { "use_editlist", "use edit list", offsetof(MOVMuxContext, use_editlist), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, 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 },
      { NULL },
  };
@@@ -85,8 -79,6 +86,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;
@@@ -109,13 -101,6 +110,13 @@@ static int64_t update_size(AVIOContext 
      return curpos - pos;
  }
  
 +static int supports_edts(MOVMuxContext *mov)
 +{
 +    // EDTS with fragments is tricky as we don't know the duration when its written
 +    // also we might end up having to write the EDTS before the first packet, which would fail
 +    return (mov->use_editlist<0 && !(mov->flags & FF_MOV_FLAG_FRAGMENT)) || mov->use_editlist>0;
 +}
 +
  static int co64_required(const MOVTrack *track)
  {
      if (track->entry > 0 && track->cluster[track->entry - 1].pos + track->data_offset > UINT32_MAX)
@@@ -130,15 -115,13 +131,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
@@@ -194,10 -177,10 +195,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;
@@@ -294,212 -277,6 +295,212 @@@ 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 */
 +};
 +
 +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_header2(&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->enc, "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_header2(&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_free_packet(pkt);
 +        if ((ret = av_copy_packet(pkt, &info->pkt)) < 0)
 +            return ret;
 +        av_free_packet(&info->pkt);
 +        info->num_blocks = 0;
 +    }
 +
 +    return pkt->size;
 +}
 +
 +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_free_packet(&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).
@@@ -510,22 -287,6 +511,22 @@@ static int mov_write_extradata_tag(AVIO
      return track->enc->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
  {
      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, track->enc->rc_buffer_size >> 3); // Buffersize DB
  
 -    avio_wb32(pb, FFMAX(track->enc->bit_rate, track->enc->rc_max_rate)); // maxbitrate (FIXME should be max rate in any 1 sec window)
 -    if (track->enc->rc_max_rate != track->enc->rc_min_rate ||
 -        track->enc->rc_min_rate == 0)
 -        avio_wb32(pb, 0); // vbr
 -    else
 -        avio_wb32(pb, track->enc->rc_max_rate); // avg bitrate
 +    avg_bitrate = compute_avg_bitrate(track);
 +    // maxbitrate (FIXME should be max rate in any 1 sec window)
 +    avio_wb32(pb, FFMAX3(track->enc->bit_rate, track->enc->rc_max_rate, avg_bitrate));
 +    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(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->enc->codec_tag = av_bswap16(track->tag >> 16);
 -    ff_put_wav_header(pb, track->enc);
 +    if ((ret = ff_put_wav_header(pb, track->enc, 0)) < 0)
 +        return ret;
      return update_size(pb, pos);
  }
  
  static int mov_write_wfex_tag(AVIOContext *pb, MOVTrack *track)
  {
 +    int ret;
      int64_t pos = avio_tell(pb);
      avio_wb32(pb, 0);
      ffio_wfourcc(pb, "wfex");
 -    ff_put_wav_header(pb, track->enc);
 +    if ((ret = ff_put_wav_header(pb, track->enc, FF_PUT_WAV_HEADER_FORCE_WAVEFORMATEX)) < 0)
 +        return ret;
      return update_size(pb, pos);
  }
  
@@@ -653,9 -384,6 +654,9 @@@ static int mov_write_chan_tag(AVIOConte
          return 0;
      }
  
 +    if (track->multichannel_as_mono)
 +        return 0;
 +
      avio_wb32(pb, 0);           // Size
      ffio_wfourcc(pb, "chan");   // Type
      avio_w8(pb, 0);             // Version
@@@ -674,11 -402,9 +675,11 @@@ static int mov_write_wave_tag(AVIOConte
      avio_wb32(pb, 0);     /* size */
      ffio_wfourcc(pb, "wave");
  
 +    if (track->enc->codec_id != AV_CODEC_ID_QDM2) {
      avio_wb32(pb, 12);    /* size */
      ffio_wfourcc(pb, "frma");
      avio_wl32(pb, track->tag);
 +    }
  
      if (track->enc->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->enc->codec_id))  {
 +      mov_write_enda_tag(pb);
 +    } else if (mov_pcm_be_gt16(track->enc->codec_id))  {
 +      mov_write_enda_tag_be(pb);
      } else if (track->enc->codec_id == AV_CODEC_ID_AMR_NB) {
          mov_write_amr_tag(pb, track);
      } else if (track->enc->codec_id == AV_CODEC_ID_AC3) {
          mov_write_ac3_tag(pb, track);
 -    } else if (track->enc->codec_id == AV_CODEC_ID_ALAC) {
 +    } else if (track->enc->codec_id == AV_CODEC_ID_EAC3) {
 +        mov_write_eac3_tag(pb, track);
 +    } else if (track->enc->codec_id == AV_CODEC_ID_ALAC ||
 +               track->enc->codec_id == AV_CODEC_ID_QDM2) {
          mov_write_extradata_tag(pb, track);
      } else if (track->enc->codec_id == AV_CODEC_ID_ADPCM_MS ||
                 track->enc->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) {
@@@ -857,20 -576,13 +858,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->enc->frame_size;
 +
      /* use 1 for raw PCM */
      if (!track->audio_vbr)
          return 1;
@@@ -893,17 -605,9 +894,17 @@@ static int mov_write_audio_tag(AVIOCont
      uint32_t tag = track->tag;
  
      if (track->mode == MODE_MOV) {
 -        if (mov_get_lpcm_flags(track->enc->codec_id))
 -            tag = AV_RL32("lpcm");
 -        version = 2;
 +        if (track->timescale > UINT16_MAX) {
 +            if (mov_get_lpcm_flags(track->enc->codec_id))
 +                tag = AV_RL32("lpcm");
 +            version = 2;
 +        } else if (track->audio_vbr || mov_pcm_le_gt16(track->enc->codec_id) ||
 +                   mov_pcm_be_gt16(track->enc->codec_id) ||
 +                   track->enc->codec_id == AV_CODEC_ID_ADPCM_MS ||
 +                   track->enc->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV ||
 +                   track->enc->codec_id == AV_CODEC_ID_QDM2) {
 +            version = 1;
 +        }
      }
  
      avio_wb32(pb, 0); /* size */
          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->enc->channels);
 +            if (track->enc->codec_id == AV_CODEC_ID_PCM_U8 ||
 +                track->enc->codec_id == AV_CODEC_ID_PCM_S8)
 +                avio_wb16(pb, 8); /* bits per 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->enc->sample_rate <= UINT16_MAX ?
          avio_wb16(pb, 0); /* Reserved */
      }
  
 +    if (version == 1) { /* SoundDescription V1 extended info */
 +        if (mov_pcm_le_gt16(track->enc->codec_id) ||
 +            mov_pcm_be_gt16(track->enc->codec_id))
 +            avio_wb32(pb, 1); /*  must be 1 for  uncompressed formats */
 +        else
 +            avio_wb32(pb, track->enc->frame_size); /* Samples per packet */
 +        avio_wb32(pb, track->sample_size / track->enc->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->enc->codec_id == AV_CODEC_ID_AAC           ||
           track->enc->codec_id == AV_CODEC_ID_AC3           ||
 +         track->enc->codec_id == AV_CODEC_ID_EAC3          ||
           track->enc->codec_id == AV_CODEC_ID_AMR_NB        ||
           track->enc->codec_id == AV_CODEC_ID_ALAC          ||
           track->enc->codec_id == AV_CODEC_ID_ADPCM_MS      ||
 -         track->enc->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV))
 +         track->enc->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV ||
 +         track->enc->codec_id == AV_CODEC_ID_QDM2          ||
 +         (mov_pcm_le_gt16(track->enc->codec_id) && version==1) ||
 +         (mov_pcm_be_gt16(track->enc->codec_id) && version==1)))
          mov_write_wave_tag(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->enc->codec_id == AV_CODEC_ID_AC3)
          mov_write_ac3_tag(pb, track);
 +    else if (track->enc->codec_id == AV_CODEC_ID_EAC3)
 +        mov_write_eac3_tag(pb, track);
      else if (track->enc->codec_id == AV_CODEC_ID_ALAC)
          mov_write_extradata_tag(pb, track);
      else if (track->enc->codec_id == AV_CODEC_ID_WMAPRO)
@@@ -1008,6 -686,19 +1009,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);
@@@ -1036,11 -727,7 +1037,11 @@@ static int mov_write_avid_tag(AVIOConte
      ffio_wfourcc(pb, "ACLR");
      ffio_wfourcc(pb, "ACLR");
      ffio_wfourcc(pb, "0001");
 -    avio_wb32(pb, 2); /* yuv range: full 1 / normal 2 */
 +    if (track->enc->color_range == AVCOL_RANGE_MPEG) { /* Legal range (16-235) */
 +        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 */
@@@ -1090,7 -777,6 +1091,7 @@@ static int mp4_get_codec_tag(AVFormatCo
      if      (track->enc->codec_id == AV_CODEC_ID_H264)      tag = MKTAG('a','v','c','1');
      else if (track->enc->codec_id == AV_CODEC_ID_HEVC)      tag = MKTAG('h','e','v','1');
      else if (track->enc->codec_id == AV_CODEC_ID_AC3)       tag = MKTAG('a','c','-','3');
 +    else if (track->enc->codec_id == AV_CODEC_ID_EAC3)      tag = MKTAG('e','c','-','3');
      else if (track->enc->codec_id == AV_CODEC_ID_DIRAC)     tag = MKTAG('d','r','a','c');
      else if (track->enc->codec_id == AV_CODEC_ID_MOV_TEXT)  tag = MKTAG('t','x','3','g');
      else if (track->enc->codec_id == AV_CODEC_ID_VC1)       tag = MKTAG('v','c','-','1');
@@@ -1122,10 -808,8 +1123,10 @@@ static int ipod_get_codec_tag(AVFormatC
             tag == MKTAG('t', 'e', 'x', 't'))))
          tag = ff_codec_get_tag(codec_ipod_tags, track->enc->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;
@@@ -1135,20 -819,20 +1136,20 @@@ static int mov_get_dv_codec_tag(AVForma
  {
      int tag;
  
 -    if (track->enc->width == 720) /* SD */
 -        if (track->enc->height == 480) /* NTSC */
 +    if (track->enc->width == 720) /* SD */
 +        if (track->enc->height == 480) /* NTSC */
              if  (track->enc->pix_fmt == AV_PIX_FMT_YUV422P) tag = MKTAG('d','v','5','n');
              else                                            tag = MKTAG('d','v','c',' ');
 -        else if (track->enc->pix_fmt == AV_PIX_FMT_YUV422P) tag = MKTAG('d','v','5','p');
 +       }else if (track->enc->pix_fmt == AV_PIX_FMT_YUV422P) tag = MKTAG('d','v','5','p');
          else if (track->enc->pix_fmt == AV_PIX_FMT_YUV420P) tag = MKTAG('d','v','c','p');
          else                                                tag = MKTAG('d','v','p','p');
 -    else if (track->enc->height == 720) /* HD 720 line */
 +    } else if (track->enc->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->enc->height == 1080) /* HD 1080 line */
 +    } else if (track->enc->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->codec->time_base.den, st->codec->time_base.num};
 +    /* if the codec time base makes no sense, try to fallback on stream frame rate */
 +    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;
 +    }
 +
 +    return rate;
 +}
 +
 +static int mov_get_mpeg2_xdcam_codec_tag(AVFormatContext *s, MOVTrack *track)
 +{
 +    int tag = track->enc->codec_tag;
 +    int interlaced = track->enc->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->enc->pix_fmt == AV_PIX_FMT_YUV420P) {
 +        if (track->enc->width == 1280 && track->enc->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->enc->width == 1440 && track->enc->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->enc->width == 1920 && track->enc->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->enc->pix_fmt == AV_PIX_FMT_YUV422P) {
 +        if (track->enc->width == 1280 && track->enc->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->enc->width == 1920 && track->enc->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->enc->codec_tag;
 +    int interlaced = track->enc->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->enc->pix_fmt == AV_PIX_FMT_YUV420P10) {
 +        if (track->enc->width == 960 && track->enc->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->enc->width == 1440 && track->enc->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->enc->pix_fmt == AV_PIX_FMT_YUV422P10) {
 +        if (track->enc->width == 1280 && track->enc->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->enc->width == 1920 && track->enc->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');
 +            }
 +        }
 +    }
 +
 +    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 },
@@@ -1311,24 -865,15 +1312,24 @@@ static int mov_get_rawvideo_codec_tag(A
  {
      int tag = track->enc->codec_tag;
      int i;
 +    enum AVPixelFormat pix_fmt;
  
      for (i = 0; i < FF_ARRAY_ELEMS(mov_pix_fmt_tags); i++) {
          if (track->enc->pix_fmt == mov_pix_fmt_tags[i].pix_fmt) {
              tag = mov_pix_fmt_tags[i].tag;
              track->enc->bits_per_coded_sample = mov_pix_fmt_tags[i].bps;
 -            break;
 +            if (track->enc->codec_tag == mov_pix_fmt_tags[i].tag)
 +                break;
          }
      }
  
 +    pix_fmt = avpriv_find_pix_fmt(avpriv_pix_fmt_bps_mov,
 +                                  track->enc->bits_per_coded_sample);
 +    if (tag == MKTAG('r','a','w',' ') &&
 +        track->enc->pix_fmt != pix_fmt &&
 +        track->enc->pix_fmt != 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->enc->pix_fmt));
      return tag;
  }
  
@@@ -1340,17 -885,11 +1341,17 @@@ static int mov_get_codec_tag(AVFormatCo
                   (track->enc->codec_id == AV_CODEC_ID_DVVIDEO ||
                    track->enc->codec_id == AV_CODEC_ID_RAWVIDEO ||
                    track->enc->codec_id == AV_CODEC_ID_H263 ||
 +                  track->enc->codec_id == AV_CODEC_ID_H264 ||
 +                  track->enc->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
                    av_get_bits_per_sample(track->enc->codec_id)))) { // pcm audio
          if (track->enc->codec_id == AV_CODEC_ID_DVVIDEO)
              tag = mov_get_dv_codec_tag(s, track);
          else if (track->enc->codec_id == AV_CODEC_ID_RAWVIDEO)
              tag = mov_get_rawvideo_codec_tag(s, track);
 +        else if (track->enc->codec_id == AV_CODEC_ID_MPEG2VIDEO)
 +            tag = mov_get_mpeg2_xdcam_codec_tag(s, track);
 +        else if (track->enc->codec_id == AV_CODEC_ID_H264)
 +            tag = mov_get_h264_codec_tag(s, track);
          else if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) {
              tag = ff_codec_get_tag(ff_codec_movvideo_tags, track->enc->codec_id);
              if (!tag) { // if no mac fcc found, try with Microsoft tags
@@@ -1387,7 -926,7 +1388,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') },
@@@ -1481,36 -1020,9 +1482,36 @@@ static int mov_write_pasp_tag(AVIOConte
      return 16;
  }
  
 -static int mov_write_video_tag(AVIOContext *pb, MOVTrack *track)
 +static void find_compressor(char * compressor_name, int len, MOVTrack *track)
  {
      AVDictionaryEntry *encoder;
 +    int xdcam_res =  (track->enc->width == 1280 && track->enc->height == 720)
 +                  || (track->enc->width == 1440 && track->enc->height == 1080)
 +                  || (track->enc->width == 1920 && track->enc->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->enc->codec_id == AV_CODEC_ID_MPEG2VIDEO && xdcam_res) {
 +        int interlaced = track->enc->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->enc->pix_fmt == AV_PIX_FMT_YUV422P) {
 +            av_strlcatf(compressor_name, len, " HD422");
 +        } else if(track->enc->width == 1440) {
 +            av_strlcatf(compressor_name, len, " HD");
 +        } else
 +            av_strlcatf(compressor_name, len, " EX");
 +
 +        av_strlcatf(compressor_name, len, " %d%c", track->enc->height, interlaced ? 'i' : 'p');
 +
 +        av_strlcatf(compressor_name, len, "%d", rate * (interlaced + 1));
 +    }
 +}
 +
 +static int mov_write_video_tag(AVIOContext *pb, MOVTrack *track)
 +{
      int64_t pos = avio_tell(pb);
      char compressor_name[32] = { 0 };
  
      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);
  
          mov_write_esds_tag(pb, track);
      else if (track->enc->codec_id == AV_CODEC_ID_H263)
          mov_write_d263_tag(pb);
 -    else if (track->enc->codec_id == AV_CODEC_ID_SVQ3)
 -        mov_write_svq3_tag(pb);
 -    else if (track->enc->codec_id == AV_CODEC_ID_DNXHD)
 +    else if (track->enc->codec_id == AV_CODEC_ID_AVUI ||
 +            track->enc->codec_id == AV_CODEC_ID_SVQ3) {
 +        mov_write_extradata_tag(pb, track);
 +        avio_wb32(pb, 0);
 +    } else if (track->enc->codec_id == AV_CODEC_ID_DNXHD)
          mov_write_avid_tag(pb, track);
      else if (track->enc->codec_id == AV_CODEC_ID_HEVC)
          mov_write_hvcc_tag(pb, track);
 -    else if (track->enc->codec_id == AV_CODEC_ID_H264) {
 +    else if (track->enc->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->enc->field_order != AV_FIELD_UNKNOWN)
 -        mov_write_fiel_tag(pb, track);
 -    else if (track->enc->codec_id == AV_CODEC_ID_VC1 && track->vos_len > 0)
 +    } else if (track->enc->codec_id == AV_CODEC_ID_VC1 && track->vos_len > 0)
          mov_write_dvc1_tag(pb, track);
      else if (track->enc->codec_id == AV_CODEC_ID_VP6F ||
               track->enc->codec_id == AV_CODEC_ID_VP6A) {
      } else if (track->vos_len > 0)
          mov_write_glbl_tag(pb, track);
  
 +    if (track->enc->codec_id != AV_CODEC_ID_H264 &&
 +        track->enc->codec_id != AV_CODEC_ID_MPEG4 &&
 +        track->enc->codec_id != AV_CODEC_ID_DNXHD)
 +        if (track->enc->field_order != AV_FIELD_UNKNOWN)
 +            mov_write_fiel_tag(pb, track);
 +
      if (track->enc->sample_aspect_ratio.den && track->enc->sample_aspect_ratio.num &&
          track->enc->sample_aspect_ratio.den != track->enc->sample_aspect_ratio.num) {
          mov_write_pasp_tag(pb, track);
@@@ -1612,57 -1120,9 +1613,57 @@@ 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 = av_rescale(track->timescale, track->enc->time_base.num, track->enc->time_base.den);
 +    int nb_frames = 1.0/av_q2d(track->enc->time_base) + 0.5;
 +    AVDictionaryEntry *t = NULL;
 +
 +    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 */
 +
 +    if (track->st)
 +        t = av_dict_get(track->st->metadata, "reel_name", NULL, 0);
 +
 +    if (t && utf8len(t->value))
 +        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->enc->extradata_size)
          avio_write(pb, track->enc->extradata, track->enc->extradata_size);
 +#endif
      return update_size(pb, pos);
  }
  
@@@ -1701,7 -1160,7 +1702,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 */
      ctts_entries[0].count = 1;
      ctts_entries[0].duration = track->cluster[0].cts;
      for (i = 1; i < track->entry; i++) {
@@@ -1742,7 -1201,7 +1743,7 @@@ static int mov_write_stts_tag(AVIOConte
          entries = 1;
      } else {
          stts_entries = track->entry ?
 -                       av_malloc(track->entry * sizeof(*stts_entries)) : /* worst case */
 +                       av_malloc_array(track->entry, sizeof(*stts_entries)) : /* worst case */
                         NULL;
          for (i = 0; i < track->entry; i++) {
              int duration = get_cluster_duration(track, i);
@@@ -1777,7 -1236,6 +1778,7 @@@ 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 */
  
@@@ -1823,32 -1281,9 +1824,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)
 +{
 +    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)
  {
 -    avio_wb32(pb, 0x20);   /* size */
 +    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->enc->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)
@@@ -1934,19 -1340,16 +1935,19 @@@ static int mov_write_hdlr_tag(AVIOConte
              hdlr_type = "soun";
              descr     = "SoundHandler";
          } else if (track->enc->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->enc->codec_tag == MKTAG('r','t','p',' ')) {
              hdlr_type = "hint";
              descr     = "HintHandler";
@@@ -2015,14 -1418,14 +2016,14 @@@ static int mov_write_minf_tag(AVIOConte
          mov_write_smhd_tag(pb);
      else if (track->enc->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);
 +        mov_write_gmhd_tag(pb, track);
      }
      if (track->mode == MODE_MOV) /* FIXME: Why do it for MODE_MOV only ? */
          mov_write_hdlr_tag(pb, NULL);
@@@ -2078,24 -1481,6 +2079,24 @@@ static int mov_write_mdia_tag(AVIOConte
      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;
  
  
      avio_wb16(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 */
 -
 +    if (st && st->metadata) {
 +        AVDictionaryEntry *rot = av_dict_get(st->metadata, "rotate", NULL, 0);
 +        rotation = (rot && rot->value) ? atoi(rot->value) : 0;
 +    }
 +    if (rotation == 90) {
 +        write_matrix(pb,  0,  1, -1,  0, track->enc->height, 0);
 +    } else if (rotation == 180) {
 +        write_matrix(pb, -1,  0,  0, -1, track->enc->width, track->enc->height);
 +    } else if (rotation == 270) {
 +        write_matrix(pb,  0, -1,  1,  0, 0, track->enc->width);
 +    } else {
 +        write_matrix(pb,  1,  0,  0,  1, 0, 0);
 +    }
      /* Track width and height, for visual only */
      if (st && (track->enc->codec_type == AVMEDIA_TYPE_VIDEO ||
                 track->enc->codec_type == AVMEDIA_TYPE_SUBTITLE)) {
@@@ -2259,7 -1640,6 +2260,7 @@@ static int mov_write_edts_tag(AVIOConte
           * special meaning. Normally start_ct should end up positive or zero
           * here, but use FFMIN in case dts is a a small positive integer
           * rounded to 0 when represented in MOV_TIMESCALE units. */
 +        av_assert0(av_rescale_rnd(track->cluster[0].dts, MOV_TIMESCALE, track->timescale, AV_ROUND_DOWN) <= 0);
          start_ct  = -FFMIN(track->cluster[0].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
@@@ -2384,8 -1764,11 +2385,8 @@@ static int mov_write_trak_tag(AVIOConte
      avio_wb32(pb, 0); /* size */
      ffio_wfourcc(pb, "trak");
      mov_write_tkhd_tag(pb, mov, track, st);
 -    if (track->mode == MODE_PSP || track->flags & MOV_TRACK_CTTS ||
 -        (track->entry && track->cluster[0].dts) ||
 -        is_clcp_track(track)) {
 -        mov_write_edts_tag(pb, mov, track);  // PSP Movies require edts box
 -    }
 +    if (supports_edts(mov))
 +        mov_write_edts_tag(pb, mov, track);  // PSP Movies and several other cases require edts box
      if (track->tref_tag)
          mov_write_tref_tag(pb, track);
      mov_write_mdia_tag(pb, track);
      if (track->mode == MODE_MOV) {
          if (track->enc->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);
          }
      }
@@@ -2502,7 -1885,15 +2503,7 @@@ static int mov_write_mvhd_tag(AVIOConte
      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) */
@@@ -2588,79 -1979,28 +2589,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, "\251wrt", "composer" , 1);
      mov_write_string_metadata(s, pb, "\251alb", "album"    , 1);
      mov_write_string_metadata(s, pb, "\251day", "date"     , 1);
 -    if (!mov_write_string_metadata(s, pb, "\251too", "encoding_tool", 1))
 +    if (!mov->exact &&
 +        !mov_write_string_metadata(s, pb, "\251too", "encoding_tool", 1))
          mov_write_string_tag(pb, "\251too", LIBAVFORMAT_IDENT, 0, 1);
      mov_write_string_metadata(s, pb, "\251cmt", "comment"  , 1);
      mov_write_string_metadata(s, pb, "\251gen", "genre"    , 1);
      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);
  }
  
@@@ -2714,26 -2045,6 +2715,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;
@@@ -2807,6 -2118,9 +2808,6 @@@ static int mov_write_udta_tag(AVIOConte
      int ret, size;
      uint8_t *buf;
  
 -    if (s->flags & AVFMT_FLAG_BITEXACT)
 -        return 0;
 -
      ret = avio_open_dyn_buf(&pb_buf);
      if (ret < 0)
          return ret;
          mov_write_string_metadata(s, pb_buf, "\251alb", "album",       0);
          mov_write_string_metadata(s, pb_buf, "\251day", "date",        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_raw_metadata_tag(s, pb_buf, "XMP_", "xmp");
      } else {
          /* iTunes meta data */
          mov_write_meta_tag(pb_buf, mov, s);
@@@ -2867,7 -2177,6 +2868,7 @@@ static void mov_write_psp_udta_tag(AVIO
  
  static int mov_write_uuidusmt_tag(AVIOContext *pb, AVFormatContext *s)
  {
 +    MOVMuxContext *mov = s->priv_data;
      AVDictionaryEntry *title = av_dict_get(s->metadata, "title", NULL, 0);
      int64_t pos, pos2;
  
          avio_wb16(pb, 0x0);                  /* ? */
          avio_wb16(pb, 0x021C);               /* data */
  
 -        mov_write_psp_udta_tag(pb, LIBAVCODEC_IDENT,      "eng", 0x04);
 +        if (!mov->exact)
 +            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)
                  mov->tracks[mov->tracks[i].src_track].track_id;
          }
      }
 +    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)
@@@ -3012,7 -2283,7 +3013,7 @@@ static int mov_write_isml_manifest(AVIO
  {
      int64_t pos = avio_tell(pb);
      int i;
 -    const uint8_t uuid[] = {
 +    static const uint8_t uuid[] = {
          0xa5, 0xd4, 0x0b, 0x30, 0xe8, 0x14, 0x11, 0xdd,
          0xba, 0x2f, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66
      };
      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->exact)
 +        avio_printf(pb, "<meta name=\"creator\" content=\"%s\" />\n",
                      LIBAVFORMAT_IDENT);
      avio_printf(pb, "</head>\n");
      avio_printf(pb, "<body>\n");
@@@ -3117,6 -2387,10 +3118,10 @@@ static int mov_write_tfhd_tag(AVIOConte
      }
      if (mov->flags & FF_MOV_FLAG_OMIT_TFHD_OFFSET)
          flags &= ~MOV_TFHD_BASE_DATA_OFFSET;
+     if (mov->flags & FF_MOV_FLAG_DEFAULT_BASE_MOOF) {
+         flags &= ~MOV_TFHD_BASE_DATA_OFFSET;
+         flags |= MOV_TFHD_DEFAULT_BASE_IS_MOOF;
+     }
  
      /* Don't set a default sample size, the silverlight player refuses
       * to play files with that set. Don't set a default sample duration,
@@@ -3188,7 -2462,7 +3193,7 @@@ static int mov_write_trun_tag(AVIOConte
  
      avio_wb32(pb, track->entry); /* sample count */
      if (mov->flags & FF_MOV_FLAG_OMIT_TFHD_OFFSET &&
-         !(mov->flags & FF_MOV_FLAG_SEPARATE_MOOF) &&
+         !(mov->flags & (FF_MOV_FLAG_SEPARATE_MOOF | FF_MOV_FLAG_DEFAULT_BASE_MOOF)) &&
          !mov->first_trun)
          avio_wb32(pb, 0); /* Later tracks follow immediately after the previous one */
      else
  static int mov_write_tfxd_tag(AVIOContext *pb, MOVTrack *track)
  {
      int64_t pos = avio_tell(pb);
 -    const uint8_t uuid[] = {
 +    static const uint8_t uuid[] = {
          0x6d, 0x1d, 0x9b, 0x05, 0x42, 0xd5, 0x44, 0xe6,
          0x80, 0xe2, 0x14, 0x1d, 0xaf, 0xf7, 0x57, 0xb2
      };
@@@ -3237,7 -2511,7 +3242,7 @@@ static int mov_write_tfrf_tag(AVIOConte
  {
      int n = track->nb_frag_info - 1 - entry, i;
      int size = 8 + 16 + 4 + 1 + 16*n;
 -    const uint8_t uuid[] = {
 +    static const uint8_t uuid[] = {
          0xd4, 0x80, 0x7e, 0xf2, 0xca, 0x39, 0x46, 0x95,
          0x8e, 0x54, 0x26, 0xcb, 0x9e, 0x46, 0xa7, 0x9f
      };
          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;
@@@ -3447,6 -2722,8 +3452,8 @@@ static int mov_write_ftyp_tag(AVIOConte
          minor =     has_h264 ? 0x20000 : 0x10000;
      } else if (mov->mode == MODE_PSP)
          ffio_wfourcc(pb, "MSNV");
+     else if (mov->mode == MODE_MP4 && mov->flags & FF_MOV_FLAG_DEFAULT_BASE_MOOF)
+         ffio_wfourcc(pb, "iso5"); // Required when using default-base-is-moof
      else if (mov->mode == MODE_MP4)
          ffio_wfourcc(pb, "isom");
      else if (mov->mode == MODE_IPOD)
          ffio_wfourcc(pb, "qt  ");
      else if (mov->mode == MODE_ISM) {
          ffio_wfourcc(pb, "piff");
-         ffio_wfourcc(pb, "iso2");
-     } else {
+         if (!(mov->flags & FF_MOV_FLAG_DEFAULT_BASE_MOOF))
+             ffio_wfourcc(pb, "iso2");
+     } else if (!(mov->flags & FF_MOV_FLAG_DEFAULT_BASE_MOOF)) {
          ffio_wfourcc(pb, "isom");
          ffio_wfourcc(pb, "iso2");
          if (has_h264)
@@@ -3640,8 -2918,10 +3648,8 @@@ static int mov_flush_fragment(AVFormatC
  
      if (!(mov->flags & FF_MOV_FLAG_EMPTY_MOOV) && mov->fragments == 0) {
          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)
              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;
  
          mov_write_moov_tag(s->pb, mov, s);
  
@@@ -3764,21 -3047,6 +3772,21 @@@ int ff_mov_write_packet(AVFormatContex
      int size = pkt->size;
      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) {
 +            av_log(s, AV_LOG_ERROR, "Application provided duration: %d is invalid\n", pkt->duration);
 +            return AVERROR(EINVAL);
 +        }
 +    }
      if (mov->flags & FF_MOV_FLAG_FRAGMENT) {
          int ret;
          if (mov->fragments > 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 (enc->codec_id == AV_CODEC_ID_ADPCM_MS ||
 +               enc->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) {
 +        samples_in_chunk = enc->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 && enc->extradata_size > 0) {
 +    if (trk->vos_len == 0 && enc->extradata_size > 0 && !TAG_IS_AVCI(trk->tag)) {
          trk->vos_len  = enc->extradata_size;
          trk->vos_data = av_malloc(trk->vos_len);
          memcpy(trk->vos_data, enc->extradata, trk->vos_len);
      }
  
 -    if (enc->codec_id == AV_CODEC_ID_H264 && trk->vos_len > 0 && *(uint8_t *)trk->vos_data != 1) {
 +    if (enc->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 (enc->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 h264 */
          /* nal reformating needed */
          if (trk->hint_track >= 0 && trk->hint_track < mov->nb_streams) {
          } else {
              size = ff_hevc_annexb2mp4(pb, pkt->data, pkt->size, 0, NULL);
          }
 +    } else if (enc->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);
      } else {
          avio_write(pb, pkt->data, size);
      }
  
      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;
           * of this packet to be what the previous packets duration implies. */
          trk->cluster[trk->entry].dts = trk->start_dts + trk->track_duration;
      }
 +    if (!trk->entry && trk->start_dts == AV_NOPTS_VALUE && !supports_edts(mov)) {
 +        trk->cluster[trk->entry].dts = trk->start_dts = 0;
 +    }
      if (trk->start_dts == AV_NOPTS_VALUE) {
          trk->start_dts = pkt->dts;
          if (pkt->dts && mov->flags & FF_MOV_FLAG_EMPTY_MOOV)
                     "empty_moov.\n", 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");
      if (trk->hint_track >= 0 && trk->hint_track < mov->nb_streams)
          ff_mov_add_hinted_packet(s, pkt, trk->hint_track, trk->entry,
                                   reformatted_data, size);
 +end:
      av_free(reformatted_data);
      return 0;
  }
  
 -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);
 -        return 1;
 -    } else {
          MOVMuxContext *mov = s->priv_data;
          MOVTrack *trk = &mov->tracks[pkt->stream_index];
          AVCodecContext *enc = trk->enc;
          if (!pkt->size)
              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);
          }
  
          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_free_packet(&end);
 +
 +    return ret;
 +}
 +
 +static int mov_write_packet(AVFormatContext *s, AVPacket *pkt)
 +{
 +    if (!pkt) {
 +        mov_flush_fragment(s);
 +        return 1;
 +    } else {
 +        int i;
 +        MOVMuxContext *mov = s->priv_data;
 +
 +        if (!pkt->size) return 0; /* Discard 0 sized packets */
 +
 +        /*
 +         * 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->enc->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;
 +            }
 +        }
 +
 +        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->enc)
          return AVERROR(ENOMEM);
      track->enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
 -    track->enc->extradata = av_malloc(sizeof(chapter_properties));
 -    if (!track->enc->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->enc, sizeof(chapter_properties)))
          return AVERROR(ENOMEM);
 -    track->enc->extradata_size = sizeof(chapter_properties);
      memcpy(track->enc->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->enc->extradata = buf;
 +            track->enc->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_create_timecode_track(AVFormatContext *s, int index, int src_index, const char *tcstr)
 +{
 +    int ret;
 +    MOVMuxContext *mov  = s->priv_data;
 +    MOVTrack *track     = &mov->tracks[index];
 +    AVStream *src_st    = s->streams[src_index];
 +    AVTimecode tc;
 +    AVPacket pkt    = {.stream_index = index, .flags = AV_PKT_FLAG_KEY, .size = 4};
 +    AVRational rate = find_fps(s, src_st);
 +
 +    /* compute the frame number */
 +    ret = av_timecode_init_from_string(&tc, rate, tcstr, s);
 +    if (ret < 0)
 +        return ret;
 +
 +    /* 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->enc = avcodec_alloc_context3(NULL);
 +    track->enc->codec_type = AVMEDIA_TYPE_DATA;
 +    track->enc->codec_tag  = track->tag;
 +    track->enc->time_base  = av_inv_q(rate);
 +
 +    /* the tmcd track just contains one packet with the frame number */
 +    pkt.data = av_malloc(pkt.size);
 +    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
@@@ -4238,20 -3331,18 +4246,20 @@@ static void mov_free(AVFormatContext *s
  
      if (mov->chapter_track) {
          if (mov->tracks[mov->chapter_track].enc)
 -            av_free(mov->tracks[mov->chapter_track].enc->extradata);
 +            av_freep(&mov->tracks[mov->chapter_track].enc->extradata);
          av_freep(&mov->tracks[mov->chapter_track].enc);
      }
  
      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].enc);
          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);
      }
  
      av_freep(&mov->tracks);
@@@ -4326,8 -3417,8 +4334,8 @@@ static int mov_write_header(AVFormatCon
  {
      AVIOContext *pb = s->pb;
      MOVMuxContext *mov = s->priv_data;
 -    AVDictionaryEntry *t;
 -    int i, 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;
  
          else if (!strcmp("f4v", s->oformat->name)) mov->mode = MODE_F4V;
      }
  
 +    if (s->flags & AVFMT_FLAG_BITEXACT)
 +        mov->exact = 1;
 +
      /* Set the FRAGMENT flag if any of the fragmentation methods are
       * enabled. */
      if (mov->max_fragment_duration || mov->max_fragment_size ||
              av_log(s, AV_LOG_WARNING, "The faststart flag is incompatible "
                     "with fragmentation, disabling faststart\n");
              mov->flags &= ~FF_MOV_FLAG_FASTSTART;
 -        }
 +        } else
 +            mov->reserved_moov_size = -1;
 +    }
 +
 +    if (!supports_edts(mov) && s->avoid_negative_ts < 0) {
 +        s->avoid_negative_ts = 2;
      }
  
      /* Non-seekable output is ok if using fragmentation. If ism_lookahead
          return AVERROR(EINVAL);
      }
  
 -
      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->codec->codec_type == AVMEDIA_TYPE_VIDEO)
 +                video_streams_nb++;
 +            else if (st->codec->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);
          }
          }
      }
  
 +    if (mov->mode == MODE_MOV) {
 +        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];
 +            if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
 +                (global_tcr || av_dict_get(st->metadata, "timecode", NULL, 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->codec->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);
  
          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->codec->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->codec->width != 720 || (st->codec->height != 608 && st->codec->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->codec->width > 65535 || st->codec->height > 65535) {
 +                av_log(s, AV_LOG_ERROR, "Resolution %dx%d too large for mov/mp4\n", st->codec->width, st->codec->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"
                         "or choose different container.\n");
          } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
              track->timescale = st->codec->sample_rate;
 -            /* set sample_size for PCM and ADPCM */
 -            if (av_get_bits_per_sample(st->codec->codec_id) ||
 -                st->codec->codec_id == AV_CODEC_ID_ILBC) {
 +            if (!st->codec->frame_size && !av_get_bits_per_sample(st->codec->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->codec->codec_id == AV_CODEC_ID_ADPCM_MS ||
 +                     st->codec->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV ||
 +                     st->codec->codec_id == AV_CODEC_ID_ILBC){
                  if (!st->codec->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->codec->block_align;
 +            }else if (st->codec->frame_size > 1){ /* assume compressed audio */
 +                track->audio_vbr = 1;
 +            }else{
 +                track->sample_size = (av_get_bits_per_sample(st->codec->codec_id) >> 3) * st->codec->channels;
              }
 -            /* set audio_vbr for compressed audio */
 -            if (av_get_bits_per_sample(st->codec->codec_id) < 8) {
 +            if (st->codec->codec_id == AV_CODEC_ID_ILBC ||
 +                st->codec->codec_id == AV_CODEC_ID_ADPCM_IMA_QT) {
                  track->audio_vbr = 1;
              }
              if (track->mode != MODE_MOV &&
                  track->enc->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->enc->sample_rate);
 +                ret = AVERROR(EINVAL);
                  goto error;
              }
          } else if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
              track->timescale = st->time_base.den;
          } else if (st->codec->codec_type == AVMEDIA_TYPE_DATA) {
              track->timescale = st->time_base.den;
 +        } else {
 +            track->timescale = MOV_TIMESCALE;
          }
          if (!track->height)
              track->height = st->codec->height;
          if (st->codec->extradata_size) {
              if (st->codec->codec_id == AV_CODEC_ID_DVD_SUBTITLE)
                  mov_create_dvd_sub_decoder_specific_info(track, st);
 -            else {
 +            else if (!TAG_IS_AVCI(track->tag)){
                  track->vos_len  = st->codec->extradata_size;
                  track->vos_data = av_malloc(track->vos_len);
                  memcpy(track->vos_data, st->codec->extradata, track->vos_len);
          }
      }
  
 +    for (i = 0; i < s->nb_streams; i++) {
 +        int j;
 +        AVStream *st= s->streams[i];
 +        MOVTrack *track= &mov->tracks[i];
 +
 +        if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO ||
 +            track->enc->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->codec->codec_type != AVMEDIA_TYPE_AUDIO ||
 +                trackj->enc->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_moov_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->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->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
                  st->codec->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->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
 +                if (!t)
 +                    t = av_dict_get(st->metadata, "timecode", NULL, 0);
 +                if (!t)
 +                    continue;
 +                if ((ret = mov_create_timecode_track(s, tmcd_track, i, t->value)) < 0)
 +                    goto error;
 +                tmcd_track++;
 +            }
 +        }
 +    }
 +
      avio_flush(pb);
  
      if (mov->flags & FF_MOV_FLAG_ISML)
      return 0;
   error:
      mov_free(s);
 -    return -1;
 +    return ret;
  }
  
  static int get_moov_size(AVFormatContext *s)
@@@ -4775,19 -3746,6 +4783,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->enc->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_moov_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");
                  avio_seek(pb, mov->reserved_moov_pos, SEEK_SET);
                  mov_write_moov_tag(pb, mov, s);
              }
 +        } else if (mov->reserved_moov_size > 0) {
 +            int64_t size;
 +            mov_write_moov_tag(pb, mov, s);
 +            size = mov->reserved_moov_size - (avio_tell(pb) - mov->reserved_moov_pos);
 +            if (size < 8){
 +                av_log(s, AV_LOG_ERROR, "reserved_moov_size is too small, needed %"PRId64" additional\n", 8-size);
 +                return -1;
 +            }
 +            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);
          }
@@@ -5003,7 -3949,7 +5011,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
@@@ -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
   */
  
@@@ -36,7 -36,7 +36,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
@@@ -47,7 -47,6 +47,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
@@@ -82,25 -81,18 +82,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;
      AVCodecContext *enc;
 +    int multichannel_as_mono;
  
      int         vos_len;
      uint8_t     *vos_data;
      int64_t     start_dts;
  
      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;
  } MOVTrack;
  
  typedef struct MOVMuxContext {
      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 exact;
 +
      int iods_skip;
      int iods_video_profile;
      int iods_audio_profile;
      AVIOContext *mdat_buf;
      int first_trun;
  
 +    int use_editlist;
 +    int video_track_timescale;
 +
 +    int reserved_moov_size; ///< 0 for disabled, -1 for automatic, size otherwise
      int64_t reserved_moov_pos;
  
      char *major_brand;
  #define FF_MOV_FLAG_FASTSTART 128
  #define FF_MOV_FLAG_OMIT_TFHD_OFFSET 256
  #define FF_MOV_FLAG_DISABLE_CHPL 512
+ #define FF_MOV_FLAG_DEFAULT_BASE_MOOF 1024
  
  int ff_mov_write_packet(AVFormatContext *s, AVPacket *pkt);
  
diff --combined libavformat/version.h
@@@ -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
   */
  
@@@ -30,8 -30,8 +30,8 @@@
  #include "libavutil/version.h"
  
  #define LIBAVFORMAT_VERSION_MAJOR 56
 -#define LIBAVFORMAT_VERSION_MINOR  6
 -#define LIBAVFORMAT_VERSION_MICRO  2
 +#define LIBAVFORMAT_VERSION_MINOR  11
- #define LIBAVFORMAT_VERSION_MICRO 100
++#define LIBAVFORMAT_VERSION_MICRO 101
  
  #define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \
                                                 LIBAVFORMAT_VERSION_MINOR, \
  #ifndef FF_API_LAVF_CODEC_TB
  #define FF_API_LAVF_CODEC_TB            (LIBAVFORMAT_VERSION_MAJOR < 57)
  #endif
 +#ifndef FF_API_URL_FEOF
 +#define FF_API_URL_FEOF                 (LIBAVFORMAT_VERSION_MAJOR < 57)
 +#endif
  
 +#ifndef FF_API_R_FRAME_RATE
 +#define FF_API_R_FRAME_RATE            1
 +#endif
  #endif /* AVFORMAT_VERSION_H */