Merge commit '2ded57371abead879bcee56da5131e5fac0d17ef'
authorMichael Niedermayer <michaelni@gmx.at>
Mon, 17 Nov 2014 20:55:23 +0000 (21:55 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Mon, 17 Nov 2014 20:55:23 +0000 (21:55 +0100)
* commit '2ded57371abead879bcee56da5131e5fac0d17ef':
  movenc: Add support for writing sidx atoms for DASH segments

Conflicts:
Changelog
libavformat/version.h

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

diff --combined Changelog
+++ b/Changelog
@@@ -2,315 -2,154 +2,316 @@@ Entries are sorted chronologically fro
  releases are sorted from youngest to oldest.
  
  version <next>:
 -- aliases and defaults for Ogg subtypes (opus, spx)
 -- HEVC/H.265 RTP payload format (draft v6) packetizer and depacketizer
 -- avplay now exits by default at the end of playback
 +- HEVC/H.265 RTP payload format (draft v6) packetizer
 +- SUP/PGS subtitle demuxer
 +- ffprobe -show_pixel_formats option
 +- CAST128 symmetric block cipher, ECB mode
 +- STL subtitle demuxer and decoder
 +- libutvideo YUV 4:2:2 10bit support
  - XCB-based screen-grabber
 +- UDP-Lite support (RFC 3828)
 +- xBR scaling filter
 +- AVFoundation screen capturing support
 +- ffserver supports codec private options
+ - creating DASH compatible fragmented MP4
  
 +version 2.4:
 +- Icecast protocol
 +- ported lenscorrection filter from frei0r filter
 +- large optimizations in dctdnoiz to make it usable
 +- ICY metadata are now requested by default with the HTTP protocol
 +- support for using metadata in stream specifiers in fftools
 +- LZMA compression support in TIFF decoder
 +- support for H.261 RTP payload format (RFC 4587)
 +- HEVC/H.265 RTP payload format (draft v6) depacketizer
 +- added codecview filter to visualize information exported by some codecs
 +- Matroska 3D support thorugh side data
 +- HTML generation using texi2html is deprecated in favor of makeinfo/texi2any
 +- silenceremove filter
  
 -version 11:
 -- libx265 encoder
 +
 +version 2.3:
 +- AC3 fixed-point decoding
  - shuffleplanes filter
 +- subfile protocol
 +- Phantom Cine demuxer
  - replaygain data export
 +- VP7 video decoder
  - Alias PIX image encoder and decoder
 -- BRender PIX image decoder
 -- Amazing Studio PAF playback support
 -- XBM decoder
 -- BMP standalone parser
 -- OpenEXR image decoder
 -- support encoding and decoding 4-channel SGI images
 +- Improvements to the BRender PIX image decoder
 +- Improvements to the XBM decoder
 +- QTKit input device
 +- improvements to OpenEXR image decoder
  - support decoding 16-bit RLE SGI images
 -- VP7 video decoder
 -- LucasArts SMUSH SANM video decoder
 -- LucasArts SMUSH VIMA audio decoder (ADPCM)
 -- LucasArts SMUSH demuxer
 -- MP2 encoding via TwoLAME
 -- asettb filter
 -- Silicon Graphics RLE 8-bit video decoder
 -- Silicon Graphics Motion Video Compressor 1 & 2 decoder
 -- Silicon Graphics Movie demuxer
 +- GDI screen grabbing for Windows
 +- alternative rendition support for HTTP Live Streaming
 +- AVFoundation input device
 +- Direct Stream Digital (DSD) decoder
 +- Magic Lantern Video (MLV) demuxer
  - On2 AVC (Audio for Video) decoder
 -- support for decoding through DXVA2 in avconv
 +- support for decoding through DXVA2 in ffmpeg
  - libbs2b-based stereo-to-binaural audio filter
 +- libx264 reference frames count limiting depending on level
  - native Opus decoder
  - display matrix export and rotation API
 -- drop avserver, it was unmaintained for years and largely broken
 -- Icecast protocol
 -- request Icecast metadata by default
 -- support for using metadata in stream specifiers in avtools
 -- Matroska 3D support
 +- WebVTT encoder
 +- showcqt multimedia filter
 +- zoompan filter
 +- signalstats filter
 +- hqx filter (hq2x, hq3x, hq4x)
 +- flanger filter
 +- Image format auto-detection
 +- LRC demuxer and muxer
 +- Samba protocol (via libsmbclient)
 +- WebM DASH Manifest muxer
 +- libfribidi support in drawtext
  
  
 -version 10:
 -- av_strnstr
 -- support ID3v2 tags in ASF files
 +version 2.2:
 +
 +- HNM version 4 demuxer and video decoder
 +- Live HDS muxer
 +- setsar/setdar filters now support variables in ratio expressions
 +- elbg filter
 +- string validation in ffprobe
 +- support for decoding through VDPAU in ffmpeg (the -hwaccel option)
 +- complete Voxware MetaSound decoder
 +- remove mp3_header_compress bitstream filter
 +- Windows resource files for shared libraries
 +- aeval filter
 +- stereoscopic 3d metadata handling
 +- WebP encoding via libwebp
 +- ATRAC3+ decoder
 +- VP8 in Ogg demuxing
 +- side & metadata support in NUT
 +- framepack filter
 +- XYZ12 rawvideo support in NUT
 +- Exif metadata support in WebP decoder
 +- OpenGL device
 +- Use metadata_header_padding to control padding in ID3 tags (currently used in
 +  MP3, AIFF, and OMA files), FLAC header, and the AVI "junk" block.
 +- Mirillis FIC video decoder
 +- Support DNx444
 +- libx265 encoder
 +- dejudder filter
 +- Autodetect VDA like all other hardware accelerations
 +- aliases and defaults for Ogg subtypes (opus, spx)
 +
 +
 +version 2.1:
 +
 +- aecho filter
 +- perspective filter ported from libmpcodecs
 +- ffprobe -show_programs option
 +- compand filter
 +- RTMP seek support
 +- when transcoding with ffmpeg (i.e. not streamcopying), -ss is now accurate
 +  even when used as an input option. Previous behavior can be restored with
 +  the -noaccurate_seek option.
 +- ffmpeg -t option can now be used for inputs, to limit the duration of
 +  data read from an input file
 +- incomplete Voxware MetaSound decoder
 +- read EXIF metadata from JPEG
 +- DVB teletext decoder
 +- phase filter ported from libmpcodecs
 +- w3fdif filter
 +- Opus support in Matroska
 +- FFV1 version 1.3 is stable and no longer experimental
 +- FFV1: YUVA(444,422,420) 9, 10 and 16 bit support
 +- changed DTS stream id in lavf mpeg ps muxer from 0x8a to 0x88, to be
 +  more consistent with other muxers.
 +- adelay filter
 +- pullup filter ported from libmpcodecs
 +- ffprobe -read_intervals option
 +- Lossless and alpha support for WebP decoder
 +- Error Resilient AAC syntax (ER AAC LC) decoding
 +- Low Delay AAC (ER AAC LD) decoding
 +- mux chapters in ASF files
 +- SFTP protocol (via libssh)
 +- libx264: add ability to encode in YUVJ422P and YUVJ444P
 +- Fraps: use BT.709 colorspace by default for yuv, as reference fraps decoder does
 +- make decoding alpha optional for prores, ffv1 and vp6 by setting
 +  the skip_alpha flag.
 +- ladspa wrapper filter
 +- native VP9 decoder
 +- dpx parser
 +- max_error_rate parameter in ffmpeg
 +- PulseAudio output device
 +- ReplayGain scanner
 +- Enhanced Low Delay AAC (ER AAC ELD) decoding (no LD SBR support)
 +- Linux framebuffer output device
 +- HEVC decoder
 +- raw HEVC, HEVC in MOV/MP4, HEVC in Matroska, HEVC in MPEG-TS demuxing
 +- mergeplanes filter
 +
 +
 +version 2.0:
 +
 +- curves filter
  - reference-counting for AVFrame and AVPacket data
 -- avconv now fails when input options are used for output file
 +- ffmpeg now fails when input options are used for output file
    or vice versa
 -- avconv options -filter_script and -filter_complex_script, which allow a
 +- support for Monkey's Audio versions from 3.93
 +- perms and aperms filters
 +- audio filtering support in ffplay
 +- 10% faster aac encoding on x86 and MIPS
 +- sine audio filter source
 +- WebP demuxing and decoding support
 +- ffmpeg options -filter_script and -filter_complex_script, which allow a
    filtergraph description to be read from a file
 +- OpenCL support
 +- audio phaser filter
 +- separatefields filter
 +- libquvi demuxer
  - uniform options syntax across all filters
 +- telecine filter
  - interlace filter
 -- JPEG 2000 decoder
 -- asetpts filter (same as setpts, but for audio)
 +- smptehdbars source
 +- inverse telecine filters (fieldmatch and decimate)
 +- colorbalance filter
 +- colorchannelmixer filter
 +- The matroska demuxer can now output proper verbatim ASS packets. It will
 +  become the default at the next libavformat major bump.
 +- decent native animated GIF encoding
 +- asetrate filter
 +- interleave filter
 +- timeline editing with filters
 +- vidstabdetect and vidstabtransform filters for video stabilization using
 +  the vid.stab library
 +- astats filter
  - trim and atrim filters
 -- avconv -t and -ss (output-only) options are now sample-accurate when
 +- ffmpeg -t and -ss (output-only) options are now sample-accurate when
    transcoding audio
  - Matroska muxer can now put the index at the beginning of the file.
 -- avconv -deinterlace option removed, the yadif filter should be used instead
 +- extractplanes filter
 +- avectorscope filter
 +- ADPCM DTK decoder
 +- ADP demuxer
 +- RSD demuxer
 +- RedSpark demuxer
 +- ADPCM IMA Radical decoder
 +- zmq filters
 +- DCT denoiser filter (dctdnoiz)
 +- Wavelet denoiser filter ported from libmpcodecs as owdenoise (formerly "ow")
  - Apple Intermediate Codec decoder
  - Escape 130 video decoder
 +- FTP protocol support
 +- V4L2 output device
 +- 3D LUT filter (lut3d)
 +- SMPTE 302M audio encoder
  - support for slice multithreading in libavfilter
 +- Hald CLUT support (generation and filtering)
  - VC-1 interlaced B-frame support
  - support for WavPack muxing (raw and in Matroska)
 +- XVideo output device
 +- vignette filter
 +- True Audio (TTA) encoder
  - Go2Webinar decoder
 +- mcdeint filter ported from libmpcodecs
 +- sab filter ported from libmpcodecs
 +- ffprobe -show_chapters option
  - WavPack encoding through libwavpack
 -- Added the -n parameter to avconv
 -- RTMP seek support
 -- when transcoding with avconv (i.e. not streamcopying), -ss is now accurate
 -  even when used as an input option. Previous behavior can be restored with
 -  the -noaccurate_seek option.
 -- avconv -t option can now be used for inputs, to limit the duration of
 -  data read from an input file
 -- Voxware MetaSound decoder
 -- WebP decoder
 -- Error Resilient AAC syntax (ER AAC LC) decoding
 -- Low Delay AAC (ER AAC LD) decoding
 -- mux chapters in ASF files
 -- Opus in Ogg demuxing
 -- Enhanced Low Delay AAC (ER AAC ELD) decoding (no LD SBR support)
 -- F4V muxer
 -- HNM version 4 demuxer and video decoder
 -- HEVC decoder
 -- raw HEVC, HEVC in MOV/MP4, HEVC in Matroska, HEVC in MPEG-TS demuxing
 -- remove avplay -vismv option, which has not worked for a long time
 -- Live HDS muxer
 -- setsar/setdar filters now support variables in ratio expressions
 -- dar variable in the scale filter now returns the actual DAR (i.e. a * sar)
 -- VP9 decoder
 -- support for decoding through VDPAU in avconv (the -hwaccel option)
 -- remove mp3_header_(de)compress bitstream filters
 -- stereoscopic 3d metadata handling
 -- png standalone parser
 -- WebP encoding via libwebp
 -- ATRAC3+ decoder
 -- framepack filter
 -- Mirillis FIC video decoder
 -- Support DNx444
 -- compand audio filter
 +- rotate filter
 +- spp filter ported from libmpcodecs
 +- libgme support
 +- psnr filter
  
  
 -version 9:
 -- av_basename and av_dirname
 -- adobe and limelight publisher authentication in RTMP
 +version 1.2:
 +
  - VDPAU hardware acceleration through normal hwaccel
  - SRTP support
 +- Error diffusion dither in Swscale
 +- Chained Ogg support
 +- Theora Midstream reconfiguration support
 +- EVRC decoder
 +- audio fade filter
 +- filtering audio with unknown channel layout
 +- allpass, bass, bandpass, bandreject, biquad, equalizer, highpass, lowpass
 +  and treble audio filter
 +- improved showspectrum filter, with multichannel support and sox-like colors
 +- histogram filter
 +- tee muxer
 +- il filter ported from libmpcodecs
 +- support ID3v2 tags in ASF files
 +- encrypted TTA stream decoding support
 +- RF64 support in WAV muxer
 +- noise filter ported from libmpcodecs
 +- Subtitles character encoding conversion
 +- blend filter
 +- stereo3d filter ported from libmpcodecs
  
  
 -version 9_beta3:
 -- ashowinfo audio filter
 +version 1.1:
 +
 +- stream disposition information printing in ffprobe
 +- filter for loudness analysis following EBU R128
 +- Opus encoder using libopus
 +- ffprobe -select_streams option
 +- Pinnacle TARGA CineWave YUV16 decoder
 +- TAK demuxer, decoder and parser
 +- DTS-HD demuxer
 +- remove -same_quant, it hasn't worked for years
 +- FFM2 support
 +- X-Face image encoder and decoder
  - 24-bit FLAC encoding
 -- audio volume filter
 -- deprecated the avconv -vol option. the volume filter is to be used instead.
  - multi-channel ALAC encoding up to 7.1
 -- TAK demuxer, parser, and decoder
 -- adaptive frame-level multithreading for H.264
 -
 -
 -version 9_beta2:
  - metadata (INFO tag) support in WAV muxer
 +- subtitles raw text decoder
  - support for building DLLs using MSVC
 -- remove avserver daemon mode
 +- LVF demuxer
 +- ffescape tool
 +- metadata (info chunk) support in CAF muxer
 +- field filter ported from libmpcodecs
 +- AVR demuxer
 +- geq filter ported from libmpcodecs
 +- remove ffserver daemon mode
 +- AST muxer/demuxer
 +- new expansion syntax for drawtext
 +- BRender PIX image decoder
 +- ffprobe -show_entries option
 +- ffprobe -sections option
 +- ADPCM IMA Dialogic decoder
 +- BRSTM demuxer
 +- animated GIF decoder and demuxer
 +- PVF demuxer
 +- subtitles filter
 +- IRCAM muxer/demuxer
 +- Paris Audio File demuxer
 +- Virtual concatenation demuxer
 +- VobSub demuxer
 +- JSON captions for TED talks decoding support
 +- SOX Resampler support in libswresample
 +- aselect filter
 +- SGI RLE 8-bit / Silicon Graphics RLE 8-bit video decoder
 +- Silicon Graphics Motion Video Compressor 1 & 2 decoder
 +- Silicon Graphics Movie demuxer
 +- apad filter
 +- Resolution & pixel format change support with multithreading for H.264
 +- documentation split into per-component manuals
 +- pp (postproc) filter ported from MPlayer
 +- NIST Sphere demuxer
 +- MPL2, VPlayer, MPlayer, AQTitle, PJS and SubViewer v1 subtitles demuxers and decoders
 +- Sony Wave64 muxer
 +- adobe and limelight publisher authentication in RTMP
 +- data: URI scheme
  - support building on the Plan 9 operating system
 -- ffv1: support version 1.3
 +- kerndeint filter ported from MPlayer
 +- histeq filter ported from VirtualDub
 +- Megalux Frame demuxer
 +- 012v decoder
 +- Improved AVC Intra decoding support
  
  
 -version 9_beta1:
 +version 1.0:
  
 -- XWD encoder and decoder
 -- Support for fragmentation in the mov/mp4 muxer
 -- ISMV (Smooth Streaming) muxer
 -- CDXL demuxer and decoder
 -- Apple ProRes encoder
 -- Sun Rasterfile Encoder
 -- remove libpostproc
 -- ID3v2 attached pictures reading and writing
 -- WMA Lossless decoder
 -- XBM encoder
 -- RealAudio Lossless decoder
 -- ZeroCodec decoder
 -- drop support for avconv without libavfilter
 -- add libavresample audio conversion library
 -- audio filters support in libavfilter and avconv
 -- add fps filter
 -- audio split filter
 -- audio mix filter
 -- avprobe output is now standard INI or JSON. The old format can still
 -  be used with -of old.
 +- INI and flat output in ffprobe
 +- Scene detection in libavfilter
  - Indeo Audio decoder
  - channelsplit audio filter
 +- setnsamples audio filter
 +- atempo filter
 +- ffprobe -show_data option
  - RTMPT protocol support
  - iLBC encoding/decoding via libilbc
  - Microsoft Screen 1 decoder
  - Microsoft Expression Encoder Screen decoder
  - RTMPS protocol support
  - RTMPTS protocol support
 -- JPEG 2000 encoding support through OpenJPEG
 -- G.723.1 demuxer and decoder
  - RTMPE protocol support
  - RTMPTE protocol support
 +- showwaves and showspectrum filter
 +- LucasArts SMUSH SANM playback support
 +- LucasArts SMUSH VIMA audio decoder (ADPCM)
 +- LucasArts SMUSH demuxer
 +- SAMI, RealText and SubViewer demuxers and decoders
 +- Heart Of Darkness PAF playback support
 +- iec61883 device
 +- asettb filter
 +- new option: -progress
 +- 3GPP Timed Text encoder/decoder
 +- GeoTIFF decoder support
 +- ffmpeg -(no)stdin option
 +- Opus decoder using libopus
 +- caca output device using libcaca
 +- alphaextract and alphamerge filters
 +- concat filter
 +- flite filter
  - Canopus Lossless Codec decoder
 -- avconv -shortest option is now per-output file,
 +- bitmap subtitles in filters (experimental and temporary)
 +- MP2 encoding via TwoLAME
 +- bmp parser
 +- smptebars source
 +- asetpts filter
 +- hue filter
 +- ICO muxer
 +- SubRip encoder and decoder without embedded timing
 +- edge detection filter
 +- framestep filter
 +- ffmpeg -shortest option is now per-output file
    -pass and -passlogfile are now per-output stream
 +- volume measurement filter
  - Ut Video encoder
  - Microsoft Screen 2 decoder
 +- smartblur filter ported from MPlayer
 +- CPiA decoder
 +- decimate filter ported from MPlayer
  - RTP depacketization of JPEG
  - Smooth Streaming live segmenter muxer
 +- F4V muxer
 +- sendcmd and asendcmd filters
 +- WebVTT demuxer and decoder (simple tags supported)
  - RTP packetization of JPEG
 -- Opus decoder and encoder using libopus
 -- remove -same_quant, it hasn't worked for years
 +- faststart option in the MOV/MP4 muxer
  - support for building with MSVC
  
  
 -version 0.8:
 +version 0.11:
  
 -- GSM audio parser
 -- SMJPEG muxer
 +- Fixes: CVE-2012-2772, CVE-2012-2774, CVE-2012-2775, CVE-2012-2776, CVE-2012-2777,
 +         CVE-2012-2779, CVE-2012-2782, CVE-2012-2783, CVE-2012-2784, CVE-2012-2785,
 +         CVE-2012-2786, CVE-2012-2787, CVE-2012-2788, CVE-2012-2789, CVE-2012-2790,
 +         CVE-2012-2791, CVE-2012-2792, CVE-2012-2793, CVE-2012-2794, CVE-2012-2795,
 +         CVE-2012-2796, CVE-2012-2797, CVE-2012-2798, CVE-2012-2799, CVE-2012-2800,
 +         CVE-2012-2801, CVE-2012-2802, CVE-2012-2803, CVE-2012-2804,
 +- v408 Quicktime and Microsoft AYUV Uncompressed 4:4:4:4 encoder and decoder
 +- setfield filter
 +- CDXL demuxer and decoder
 +- Apple ProRes encoder
 +- ffprobe -count_packets and -count_frames options
 +- Sun Rasterfile Encoder
 +- ID3v2 attached pictures reading and writing
 +- WMA Lossless decoder
 +- bluray protocol
 +- blackdetect filter
 +- libutvideo encoder wrapper (--enable-libutvideo)
 +- swapuv filter
 +- bbox filter
 +- XBM encoder and decoder
 +- RealAudio Lossless decoder
 +- ZeroCodec decoder
 +- tile video filter
 +- Metal Gear Solid: The Twin Snakes demuxer
 +- OpenEXR image decoder
 +- removelogo filter
 +- drop support for ffmpeg without libavfilter
 +- drawtext video filter: fontconfig support
 +- ffmpeg -benchmark_all option
 +- super2xsai filter ported from libmpcodecs
 +- add libavresample audio conversion library for compatibility
 +- MicroDVD decoder
 +- Avid Meridien (AVUI) encoder and decoder
 +- accept + prefix to -pix_fmt option to disable automatic conversions.
 +- complete audio filtering in libavfilter and ffmpeg
 +- add fps filter
 +- vorbis parser
 +- png parser
 +- audio mix filter
 +- ffv1: support (draft) version 1.3
  
  
 -version 0.8_beta2:
 +version 0.10:
  
 +- Fixes: CVE-2011-3929, CVE-2011-3934, CVE-2011-3935, CVE-2011-3936,
 +         CVE-2011-3937, CVE-2011-3940, CVE-2011-3941, CVE-2011-3944,
 +         CVE-2011-3945, CVE-2011-3946, CVE-2011-3947, CVE-2011-3949,
 +         CVE-2011-3950, CVE-2011-3951, CVE-2011-3952
 +- v410 Quicktime Uncompressed 4:4:4 10-bit encoder and decoder
 +- SBaGen (SBG) binaural beats script demuxer
 +- OpenMG Audio muxer
 +- Timecode extraction in DV and MOV
 +- thumbnail video filter
 +- XML output in ffprobe
 +- asplit audio filter
 +- tinterlace video filter
 +- astreamsync audio filter
 +- amerge audio filter
 +- ISMV (Smooth Streaming) muxer
 +- GSM audio parser
 +- SMJPEG muxer
 +- XWD encoder and decoder
  - Automatic thread count based on detection number of (available) CPU cores
 -- Deprecate libpostproc. If desired, the switch --enable-postproc will
 -  enable it but it may be removed in a later Libav release.
 +- y41p Brooktree Uncompressed 4:1:1 12-bit encoder and decoder
 +- ffprobe -show_error option
 +- Avid 1:1 10-bit RGB Packer codec
 +- v308 Quicktime Uncompressed 4:4:4 encoder and decoder
 +- yuv4 libquicktime packed 4:2:0 encoder and decoder
 +- ffprobe -show_frames option
 +- silencedetect audio filter
 +- ffprobe -show_program_version, -show_library_versions, -show_versions options
  - rv34: frame-level multi-threading
  - optimized iMDCT transform on x86 using SSE for for mpegaudiodec
 +- Improved PGS subtitle decoder
 +- dumpgraph option to lavfi device
 +- r210 and r10k encoders
 +- ffwavesynth decoder
 +- aviocat tool
 +- ffeval tool
 +- support encoding and decoding 4-channel SGI images
  
  
 -version 0.8_beta1:
 +version 0.9:
  
 +- openal input device added
 +- boxblur filter added
  - BWF muxer
  - Flash Screen Video 2 decoder
 -- ffplay/ffprobe/ffserver renamed to avplay/avprobe/avserver
 -- ffmpeg deprecated, added avconv, which is almost the same for now, except
 +- lavfi input device added
 +- added avconv, which is almost the same for now, except
  for a few incompatible changes in the options, which will hopefully make them
  easier to use. The changes are:
      * The options placement is now strictly enforced! While in theory the
      * -vframes/-aframes/-dframes options are now aliases to the new -frames option.
      * -vtag/-atag/-stag options are now aliases to the new -tag option.
  - XMV demuxer
 +- LOAS demuxer
 +- ashowinfo filter added
  - Windows Media Image decoder
 +- amovie source added
  - LATM muxer/demuxer
 -- showinfo filter
 -- split filter
 +- Speex encoder via libspeex
 +- JSON output in ffprobe
 +- WTV muxer
 +- Optional C++ Support (needed for libstagefright)
 +- H.264 Decoding on Android via Stagefright
 +- Prores decoder
 +- BIN/XBIN/ADF/IDF text file decoder
 +- aconvert audio filter added
 +- audio support to lavfi input device added
  - libcdio-paranoia input device for audio CD grabbing
 -- select filter
  - Apple ProRes decoder
  - CELT in Ogg demuxing
 +- G.723.1 demuxer and decoder
 +- libmodplug support (--enable-libmodplug)
  - VC-1 interlaced decoding
 -- lut, lutrgb, and lutyuv filters
 -- boxblur filter
 +- libutvideo wrapper (--enable-libutvideo)
 +- aevalsrc audio source added
  - Ut Video decoder
  - Speex encoding via libspeex
  - 4:2:2 H.264 decoding support
  - 4:2:2 and 4:4:4 H.264 encoding with libx264
  - Pulseaudio input device
 +- Prores encoder
 +- Video Decoder Acceleration (VDA) HWAccel module.
  - replacement Indeo 3 decoder
 +- new ffmpeg option: -map_channel
 +- volume audio filter added
 +- earwax audio filter added
 +- libv4l2 support (--enable-libv4l2)
  - TLS/SSL and HTTPS protocol support
  - AVOptions API rewritten and documented
  - most of CODEC_FLAG2_*, some CODEC_FLAG_* and many codec-specific fields in
  - Discworld II BMV decoding support
  - VBLE Decoder
  - OS X Video Decoder Acceleration (VDA) support
 +- compact and csv output in ffprobe
 +- pan audio filter
 +- IFF Amiga Continuous Bitmap (ACBM) decoder
 +- ass filter
  - CRI ADX audio format muxer and demuxer
  - Playstation Portable PMP format demuxer
 +- Microsoft Windows ICO demuxer
 +- life source
  - PCM format support in OMA demuxer
  - CLJR encoder
 +- new option: -report
  - Dxtory capture format decoder
 -- v410 QuickTime uncompressed 4:4:4 10-bit encoder and decoder
 -- OpenMG Audio muxer
 +- cellauto source
  - Simple segmenting muxer
  - Indeo 4 decoder
  - SMJPEG demuxer
  
  
 -version 0.7:
 -
 -- E-AC-3 audio encoder
 -- ac3enc: add channel coupling support
 -- floating-point sample format support for (E-)AC-3, DCA, AAC, Vorbis decoders
 -- H.264/MPEG frame-level multithreading
 -- av_metadata_* functions renamed to av_dict_* and moved to libavutil
 -- 4:4:4 H.264 decoding support
 -- 10-bit H.264 optimizations for x86
 -- bump libswscale for recently reported ABI break
 -
 -
 -version 0.7_beta2:
 -
 -- VP8 frame-level multithreading
 -- NEON optimizations for VP8
 -- removed a lot of deprecated API cruft
 -- FFT and IMDCT optimizations for AVX (Sandy Bridge) processors
 -- DPX image encoder
 -- SMPTE 302M AES3 audio decoder
 -- ffmpeg no longer quits after the 'q' key is pressed; use 'ctrl+c' instead
 -- 9bit and 10bit per sample support in the H.264 decoder
 -
 -
 -version 0.7_beta1:
 +version 0.8:
  
 +- many many things we forgot because we rather write code than changelogs
  - WebM support in Matroska de/muxer
  - low overhead Ogg muxing
  - MMS-TCP support
  - Demuxer for On2's IVF format
  - Pictor/PC Paint decoder
  - HE-AAC v2 decoder
 +- HE-AAC v2 encoding with libaacplus
  - libfaad2 wrapper removed
  - DTS-ES extension (XCh) decoding support
  - native VP8 decoder
  - RTP depacketization of QDM2
  - ANSI/ASCII art playback system
  - Lego Mindstorms RSO de/muxer
 +- libavcore added (and subsequently removed)
  - SubRip subtitle file muxer and demuxer
  - Chinese AVS encoding via libxavs
  - ffprobe -show_packets option added
  - replace the ocv_smooth filter with a more generic ocv filter
  - Windows Televison (WTV) demuxer
  - FFmpeg metadata format muxer and demuxer
 -- SubRip (srt) subtitle decoder
 +- SubRip (srt) subtitle encoder and decoder
  - floating-point AC-3 encoder added
  - Lagarith decoder
  - ffmpeg -copytb option added
  - sndio support for playback and record
  - Linux framebuffer input device added
  - Chronomaster DFA decoder
 -- Mobotix MxPEG decoder
 +- DPX image encoder
 +- MicroDVD subtitle file muxer and demuxer
 +- Playstation Portable PMP format demuxer
 +- fieldorder video filter added
  - AAC encoding via libvo-aacenc
  - AMR-WB encoding via libvo-amrwbenc
  - xWMA demuxer
 -- fieldorder video filter added
 +- Mobotix MxPEG decoder
 +- VP8 frame-multithreading
 +- NEON optimizations for VP8
 +- Lots of deprecated API cruft removed
 +- fft and imdct optimizations for AVX (Sandy Bridge) processors
 +- showinfo filter added
 +- SMPTE 302M AES3 audio decoder
 +- Apple Core Audio Format muxer
 +- 9bit and 10bit per sample support in the H.264 decoder
 +- 9bit and 10bit FFV1 encoding / decoding
 +- split filter added
 +- select filter added
 +- sdl output device added
 +- libmpcodecs video filter support (3 times as many filters than before)
 +- mpeg2 aspect ratio dection fixed
 +- libxvid aspect pickiness fixed
 +- Frame multithreaded decoding
 +- E-AC-3 audio encoder
 +- ac3enc: add channel coupling support
 +- floating-point sample format support to the ac3, eac3, dca, aac, and vorbis decoders.
 +- H264/MPEG frame-level multi-threading
 +- All av_metadata_* functions renamed to av_dict_* and moved to libavutil
 +- 4:4:4 H.264 decoding support
 +- 10-bit H.264 optimizations for x86
 +- lut, lutrgb, and lutyuv filters added
 +- buffersink libavfilter sink added
 +- Bump libswscale for recently reported ABI break
 +- New J2K encoder (via OpenJPEG)
 +
 +
 +version 0.7:
 +
 +- all the changes for 0.8, but keeping API/ABI compatibility with the 0.6 release
  
  
  version 0.6:
@@@ -955,7 -655,6 +956,7 @@@ version 0.5
  - Gopher client support
  - MXF D-10 muxer
  - generic metadata API
 +- flash ScreenVideo2 encoder
  
  
  version 0.4.9-pre1:
@@@ -1158,7 -857,7 +1159,7 @@@ version 0.4.5
  - MPEG-4 vol header fixes (Jonathan Marsden <snmjbm at pacbell.net>)
  - ARM optimizations (Lionel Ulmer <lionel.ulmer at free.fr>).
  - Windows porting of file converter
 -- added MJPEG raw format (input/ouput)
 +- added MJPEG raw format (input/output)
  - added JPEG image format support (input/output)
  
  
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", 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" },
      { "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" },
+     { "dash", "Write DASH compatible fragmented MP4", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_DASH}, 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},
 +    { "video_track_timescale", "set timescale of all video tracks", offsetof(MOVMuxContext, video_track_timescale), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
      { "brand",    "Override major brand", offsetof(MOVMuxContext, major_brand),   AV_OPT_TYPE_STRING, {.str = NULL}, .flags = AV_OPT_FLAG_ENCODING_PARAM },
      { "use_editlist", "use edit list", offsetof(MOVMuxContext, use_editlist), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, AV_OPT_FLAG_ENCODING_PARAM},
      { NULL },
@@@ -86,8 -81,6 +87,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;
@@@ -124,15 -117,13 +125,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
@@@ -188,10 -179,10 +189,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;
@@@ -288,212 -279,6 +289,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).
@@@ -504,22 -289,6 +505,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);
  }
  
@@@ -647,9 -386,6 +648,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
@@@ -668,11 -404,9 +669,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) {
@@@ -851,20 -578,13 +852,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;
@@@ -887,17 -607,9 +888,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 if (track->enc->codec_id == AV_CODEC_ID_ADPCM_G726)
 +                avio_wb16(pb, track->enc->bits_per_coded_sample);
 +            else
 +                avio_wb16(pb, 16);
 +            avio_wb16(pb, track->audio_vbr ? -2 : 0); /* compression ID */
 +        } else { /* reserved for mp4/3gp */
 +            avio_wb16(pb, 2);
 +            avio_wb16(pb, 16);
 +            avio_wb16(pb, 0);
 +        }
  
          avio_wb16(pb, 0); /* packet size (= 0) */
          avio_wb16(pb, track->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)
@@@ -1004,6 -688,19 +1005,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);
@@@ -1032,11 -729,7 +1033,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 */
@@@ -1086,7 -779,6 +1087,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');
@@@ -1118,10 -810,8 +1119,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;
@@@ -1131,20 -821,20 +1132,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 },
@@@ -1307,24 -867,15 +1308,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;
  }
  
@@@ -1336,17 -887,11 +1337,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
@@@ -1383,7 -928,7 +1384,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') },
@@@ -1477,36 -1022,9 +1478,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);
@@@ -1608,57 -1122,9 +1609,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);
  }
  
@@@ -1697,7 -1162,7 +1698,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++) {
@@@ -1738,7 -1203,7 +1739,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);
@@@ -1773,7 -1238,6 +1774,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 */
  
@@@ -1819,32 -1283,9 +1820,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)
@@@ -1930,19 -1342,16 +1931,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";
@@@ -2011,14 -1420,14 +2012,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 -1487,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)) {
@@@ -2261,7 -1648,6 +2262,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
@@@ -2386,18 -1772,15 +2387,18 @@@ 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->entry &&
 -        (track->mode == MODE_PSP || track->flags & MOV_TRACK_CTTS ||
 -        track->cluster[0].dts || is_clcp_track(track))) {
 +
 +    av_assert2(mov->use_editlist >= 0);
 +
 +
 +    if (track->entry) {
          if (mov->use_editlist)
 -            mov_write_edts_tag(pb, mov, track);  // PSP Movies require edts box
 +            mov_write_edts_tag(pb, mov, track);  // PSP Movies and several other cases require edts box
          else if ((track->entry && track->cluster[0].dts) || track->mode == MODE_PSP || is_clcp_track(track))
              av_log(mov->fc, AV_LOG_WARNING,
                     "Not writing any edit list even though one would have been required\n");
      }
 +
      if (track->tref_tag)
          mov_write_tref_tag(pb, track);
      mov_write_mdia_tag(pb, mov, 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);
          }
      }
@@@ -2514,7 -1897,15 +2515,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) */
@@@ -2600,79 -1991,28 +2601,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);
  }
  
@@@ -2726,26 -2057,6 +2727,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;
@@@ -2819,6 -2130,9 +2820,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);
@@@ -2879,7 -2189,6 +2880,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)
@@@ -3024,7 -2295,7 +3025,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");
@@@ -3231,7 -2501,7 +3232,7 @@@ static int mov_write_trun_tag(AVIOConte
  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
      };
@@@ -3253,7 -2523,7 +3254,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;
@@@ -3405,7 -2676,78 +3406,78 @@@ static int mov_write_moof_tag_internal(
      return update_size(pb, pos);
  }
  
- static int mov_write_moof_tag(AVIOContext *pb, MOVMuxContext *mov, int tracks)
+ static int mov_write_sidx_tag(AVIOContext *pb,
+                               MOVTrack *track, int ref_size, int total_sidx_size)
+ {
+     int64_t pos = avio_tell(pb), offset_pos, end_pos;
+     int64_t presentation_time = track->start_dts + track->frag_start +
+                                 track->cluster[0].cts;
+     int64_t duration = track->start_dts + track->track_duration -
+                        track->cluster[0].dts;
+     int64_t offset;
+     int starts_with_SAP = track->cluster[0].flags & MOV_SYNC_SAMPLE;
+     // pts<0 should be cut away using edts
+     if (presentation_time < 0)
+         presentation_time = 0;
+     avio_wb32(pb, 0); /* size */
+     ffio_wfourcc(pb, "sidx");
+     avio_w8(pb, 1); /* version */
+     avio_wb24(pb, 0);
+     avio_wb32(pb, track->track_id); /* reference_ID */
+     avio_wb32(pb, track->timescale); /* timescale */
+     avio_wb64(pb, presentation_time); /* earliest_presentation_time */
+     offset_pos = avio_tell(pb);
+     avio_wb64(pb, 0); /* first_offset (offset to referenced moof) */
+     avio_wb16(pb, 0); /* reserved */
+     avio_wb16(pb, 1); /* reference_count */
+     avio_wb32(pb, (0 << 31) | (ref_size & 0x7fffffff)); /* reference_type (0 = media) | referenced_size */
+     avio_wb32(pb, duration); /* subsegment_duration */
+     avio_wb32(pb, (starts_with_SAP << 31) | (0 << 28) | 0); /* starts_with_SAP | SAP_type | SAP_delta_time */
+     end_pos = avio_tell(pb);
+     offset = pos + total_sidx_size - end_pos;
+     avio_seek(pb, offset_pos, SEEK_SET);
+     avio_wb64(pb, offset);
+     avio_seek(pb, end_pos, SEEK_SET);
+     return update_size(pb, pos);
+ }
+ static int mov_write_sidx_tags(AVIOContext *pb, MOVMuxContext *mov,
+                                int tracks, int ref_size)
+ {
+     int i, round, ret;
+     AVIOContext *avio_buf;
+     int total_size = 0;
+     for (round = 0; round < 2; round++) {
+         // First run one round to calculate the total size of all
+         // sidx atoms.
+         // This would be much simpler if we'd only write one sidx
+         // atom, for the first track in the moof.
+         if (round == 0) {
+             if ((ret = ffio_open_null_buf(&avio_buf)) < 0)
+                 return ret;
+         } else {
+             avio_buf = pb;
+         }
+         for (i = 0; i < mov->nb_streams; i++) {
+             MOVTrack *track = &mov->tracks[i];
+             if (tracks >= 0 && i != tracks)
+                 continue;
+             if (!track->entry)
+                 continue;
+             total_size -= mov_write_sidx_tag(avio_buf, track, ref_size,
+                                              total_size);
+         }
+         if (round == 0)
+             total_size = ffio_close_null_buf(avio_buf);
+     }
+     return 0;
+ }
+ static int mov_write_moof_tag(AVIOContext *pb, MOVMuxContext *mov, int tracks,
+                               int64_t mdat_size)
  {
      AVIOContext *avio_buf;
      int ret, moof_size;
      mov_write_moof_tag_internal(avio_buf, mov, tracks, 0);
      moof_size = ffio_close_null_buf(avio_buf);
  
+     if (mov->flags & FF_MOV_FLAG_DASH)
+         mov_write_sidx_tags(pb, mov, tracks, moof_size + 8 + mdat_size);
      if ((ret = mov_add_tfra_entries(pb, mov, tracks)) < 0)
          return ret;
  
@@@ -3706,8 -3051,10 +3781,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);
  
          if (write_moof) {
              avio_flush(s->pb);
  
-             mov_write_moof_tag(s->pb, mov, moof_tracks);
+             mov_write_moof_tag(s->pb, mov, moof_tracks, mdat_size);
              mov->fragments++;
  
              avio_wb32(s->pb, mdat_size + 8);
@@@ -3814,21 -3164,6 +3889,21 @@@ int ff_mov_write_packet(AVFormatContex
      int size = pkt->size, ret = 0;
      uint8_t *reformatted_data = NULL;
  
 +    if (trk->entry) {
 +        int64_t duration = pkt->dts - trk->cluster[trk->entry - 1].dts;
 +        if (duration < 0 || duration > INT_MAX) {
 +            av_log(s, AV_LOG_ERROR, "Application provided duration: %"PRId64" / timestamp: %"PRId64" is out of range for mov/mp4 format\n",
 +                duration, pkt->dts
 +            );
 +
 +            pkt->dts = trk->cluster[trk->entry - 1].dts + 1;
 +            pkt->pts = AV_NOPTS_VALUE;
 +        }
 +        if (pkt->duration < 0) {
 +            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 && !mov->use_editlist &&
          s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO) {
          /* Not using edit lists and shifting the first track to start from zero.
                     "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");
          ff_mov_add_hinted_packet(s, pkt, trk->hint_track, trk->entry,
                                   reformatted_data, size);
  
 +end:
  err:
 +
      av_free(reformatted_data);
      return ret;
  }
  
 -static int mov_write_packet(AVFormatContext *s, AVPacket *pkt)
 +static int mov_write_single_packet(AVFormatContext *s, AVPacket *pkt)
  {
 -    if (!pkt) {
 -        mov_flush_fragment(s);
 -        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
@@@ -4302,20 -3463,18 +4377,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);
@@@ -4390,8 -3549,8 +4465,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 ||
      if (mov->mode == MODE_ISM)
          mov->flags |= FF_MOV_FLAG_EMPTY_MOOV | FF_MOV_FLAG_SEPARATE_MOOF |
                        FF_MOV_FLAG_FRAGMENT;
+     if (mov->flags & FF_MOV_FLAG_DASH)
+         mov->flags |= FF_MOV_FLAG_FRAGMENT | FF_MOV_FLAG_EMPTY_MOOV |
+                       FF_MOV_FLAG_DEFAULT_BASE_MOOF;
  
      /* faststart: moov at the beginning of the file, if supported */
      if (mov->flags & FF_MOV_FLAG_FASTSTART) {
              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 (mov->use_editlist < 0) {
          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)
@@@ -4852,19 -3898,6 +4930,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);
          }
@@@ -5080,7 -4101,7 +5158,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 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_OMIT_TFHD_OFFSET      (1 <<  8)
  #define FF_MOV_FLAG_DISABLE_CHPL          (1 <<  9)
  #define FF_MOV_FLAG_DEFAULT_BASE_MOOF     (1 << 10)
+ #define FF_MOV_FLAG_DASH                  (1 << 11)
  
  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  5
 +#define LIBAVFORMAT_VERSION_MINOR  13
- #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 */