Merge commit 'bb461370e34b1fa1637f34ce7d37b934ddb472d5'
authorMichael Niedermayer <michaelni@gmx.at>
Fri, 20 Sep 2013 09:56:26 +0000 (11:56 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Fri, 20 Sep 2013 10:06:15 +0000 (12:06 +0200)
* commit 'bb461370e34b1fa1637f34ce7d37b934ddb472d5':
  asfenc: mux chapters in ASF files using an ASF "marker" section

Conflicts:
Changelog
libavformat/version.h

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

diff --combined Changelog
+++ b/Changelog
  Entries are sorted chronologically from oldest to youngest within each release,
  releases are sorted from youngest to oldest.
  
 -version 10:
 -- av_strnstr
 -- support ID3v2 tags in ASF files
 +version <next>
 +
 +- 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
 +
 +
 +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
 -- new 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
 +- new 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
  - new interlace filter
 -- JPEG 2000 decoder
 -- new asetpts filter (same as setpts, but for audio)
 -- new trim and atrim filters
 -- avconv -t and -ss (output-only) options are now sample-accurate when
 +- 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
 +- 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
 -- incomplete 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
 +- 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 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 playback support
 +- 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
  
  
 -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:
@@@ -839,7 -593,6 +840,7 @@@ version 0.5
  - Gopher client support
  - MXF D-10 muxer
  - generic metadata API
 +- flash ScreenVideo2 encoder
  
  
  version 0.4.9-pre1:
@@@ -1042,7 -795,7 +1043,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/asfenc.c
@@@ -2,25 -2,25 +2,26 @@@
   * ASF muxer
   * Copyright (c) 2000, 2001 Fabrice Bellard
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
 +#include "libavutil/avassert.h"
  #include "libavutil/dict.h"
+ #include "libavutil/mathematics.h"
  #include "avformat.h"
  #include "avio_internal.h"
  #include "internal.h"
@@@ -32,7 -32,7 +33,7 @@@
  
  
  #define ASF_INDEXED_INTERVAL    10000000
 -#define ASF_INDEX_BLOCK         600
 +#define ASF_INDEX_BLOCK         (1<<9)
  
  #define ASF_PACKET_ERROR_CORRECTION_DATA_SIZE 0x2
  #define ASF_PACKET_ERROR_CORRECTION_FLAGS          \
@@@ -195,36 -195,33 +196,36 @@@ typedef struct 
      /* packet filling */
      unsigned char multi_payloads_present;
      int packet_size_left;
 -    int packet_timestamp_start;
 -    int packet_timestamp_end;
 +    int64_t packet_timestamp_start;
 +    int64_t packet_timestamp_end;
      unsigned int packet_nb_payloads;
      uint8_t packet_buf[PACKET_SIZE];
      AVIOContext pb;
      /* only for reading */
      uint64_t data_offset;                ///< beginning of the first data packet
  
 -    int64_t last_indexed_pts;
      ASFIndex *index_ptr;
 -    uint32_t nb_index_count;
      uint32_t nb_index_memory_alloc;
      uint16_t maximum_packet;
 +    uint32_t next_packet_number;
 +    uint16_t next_packet_count;
 +    uint64_t next_packet_offset;
 +    int      next_start_sec;
 +    int      end_sec;
  } ASFContext;
  
  static const AVCodecTag codec_asf_bmp_tags[] = {
 -    { AV_CODEC_ID_MPEG4,     MKTAG('M', 'P', '4', 'S') },
      { AV_CODEC_ID_MPEG4,     MKTAG('M', '4', 'S', '2') },
 +    { AV_CODEC_ID_MPEG4,     MKTAG('M', 'P', '4', 'S') },
      { AV_CODEC_ID_MSMPEG4V3, MKTAG('M', 'P', '4', '3') },
      { AV_CODEC_ID_NONE,      0 },
  };
  
  #define PREROLL_TIME 3100
  
 -static void put_guid(AVIOContext *s, const ff_asf_guid *g)
 +void ff_put_guid(AVIOContext *s, const ff_asf_guid *g)
  {
 -    assert(sizeof(*g) == 16);
 +    av_assert0(sizeof(*g) == 16);
      avio_write(s, *g, sizeof(*g));
  }
  
@@@ -248,7 -245,7 +249,7 @@@ static int64_t put_header(AVIOContext *
      int64_t pos;
  
      pos = avio_tell(pb);
 -    put_guid(pb, g);
 +    ff_put_guid(pb, g);
      avio_wl64(pb, 24);
      return pos;
  }
@@@ -291,6 -288,64 +292,64 @@@ static int64_t unix_to_file_time(int ti
      return t;
  }
  
 -    for (i = 0; i < asf->nb_index_count; i++) {
+ static int32_t get_send_time(ASFContext *asf, int64_t pres_time, uint64_t *offset)
+ {
+     int i;
+     int32_t send_time = 0;
+     *offset = asf->data_offset + DATA_HEADER_SIZE;
 -    put_guid(pb, &ff_asf_reserved_4);  // ASF spec mandates this reserved value
++    for (i = 0; i < asf->next_start_sec; i++) {
+         if (pres_time <= asf->index_ptr[i].send_time)
+             break;
+         send_time = asf->index_ptr[i].send_time;
+         *offset   = asf->index_ptr[i].offset;
+     }
+     return send_time / 10000;
+ }
+ static int asf_write_markers(AVFormatContext *s)
+ {
+     ASFContext *asf = s->priv_data;
+     AVIOContext *pb = s->pb;
+     int i;
+     AVRational scale = {1, 10000000};
+     int64_t hpos = put_header(pb, &ff_asf_marker_header);
++    ff_put_guid(pb, &ff_asf_reserved_4);// ASF spec mandates this reserved value
+     avio_wl32(pb, s->nb_chapters);     // markers count
+     avio_wl16(pb, 0);                  // ASF spec mandates 0 for this
+     avio_wl16(pb, 0);                  // name length 0, no name given
+     for (i = 0; i < s->nb_chapters; i++) {
+         AVChapter *c = s->chapters[i];
+         AVDictionaryEntry *t = av_dict_get(c->metadata, "title", NULL, 0);
+         int64_t pres_time = av_rescale_q(c->start, c->time_base, scale);
+         uint64_t offset;
+         int32_t send_time = get_send_time(asf, pres_time, &offset);
+         int len = 0;
+         uint8_t *buf;
+         AVIOContext *dyn_buf;
+         if (t) {
+             if (avio_open_dyn_buf(&dyn_buf) < 0)
+                 return AVERROR(ENOMEM);
+             avio_put_str16le(dyn_buf, t->value);
+             len = avio_close_dyn_buf(dyn_buf, &buf);
+         }
+         avio_wl64(pb, offset);            // offset of the packet with send_time
+         avio_wl64(pb, pres_time + PREROLL_TIME * 10000); // presentation time
+         avio_wl16(pb, 12 + len);          // entry length
+         avio_wl32(pb, send_time);         // send time
+         avio_wl32(pb, 0);                 // flags, should be 0
+         avio_wl32(pb, len / 2);           // marker desc length in WCHARS!
+         if (t) {
+             avio_write(pb, buf, len);     // marker desc
+             av_freep(&buf);
+         }
+     }
+     end_header(pb, hpos);
+     return 0;
+ }
  /* write the header (used two times if non streamed) */
  static int asf_write_header1(AVFormatContext *s, int64_t file_size,
                               int64_t data_chunk_size)
          put_chunk(s, 0x4824, 0, 0xc00); /* start of stream (length will be patched later) */
      }
  
 -    put_guid(pb, &ff_asf_header);
 +    ff_put_guid(pb, &ff_asf_header);
      avio_wl64(pb, -1); /* header length, will be patched after */
      avio_wl32(pb, 3 + has_title + !!metadata_count + s->nb_streams); /* number of chunks in header */
      avio_w8(pb, 1); /* ??? */
      /* file header */
      header_offset = avio_tell(pb);
      hpos          = put_header(pb, &ff_asf_file_header);
 -    put_guid(pb, &ff_asf_my_guid);
 +    ff_put_guid(pb, &ff_asf_my_guid);
      avio_wl64(pb, file_size);
      file_time = 0;
      avio_wl64(pb, unix_to_file_time(file_time));
  
      /* unknown headers */
      hpos = put_header(pb, &ff_asf_head1_guid);
 -    put_guid(pb, &ff_asf_head2_guid);
 +    ff_put_guid(pb, &ff_asf_head2_guid);
      avio_wl32(pb, 6);
      avio_wl16(pb, 0);
      end_header(pb, hpos);
          }
          end_header(pb, hpos);
      }
+     /* chapters using ASF markers */
+     if (!asf->is_streamed && s->nb_chapters) {
+         int ret;
+         if (ret = asf_write_markers(s))
+             return ret;
+     }
      /* stream headers */
      for (n = 0; n < s->nb_streams; n++) {
          int64_t es_pos;
  
          enc                 = s->streams[n]->codec;
          asf->streams[n].num = n + 1;
 -        asf->streams[n].seq = 0;
 +        asf->streams[n].seq = 1;
  
          switch (enc->codec_type) {
          case AVMEDIA_TYPE_AUDIO:
  
          hpos = put_header(pb, &ff_asf_stream_header);
          if (enc->codec_type == AVMEDIA_TYPE_AUDIO) {
 -            put_guid(pb, &ff_asf_audio_stream);
 -            put_guid(pb, &ff_asf_audio_conceal_spread);
 +            ff_put_guid(pb, &ff_asf_audio_stream);
 +            ff_put_guid(pb, &ff_asf_audio_conceal_spread);
          } else {
 -            put_guid(pb, &ff_asf_video_stream);
 -            put_guid(pb, &ff_asf_video_conceal_none);
 +            ff_put_guid(pb, &ff_asf_video_stream);
 +            ff_put_guid(pb, &ff_asf_video_conceal_none);
          }
          avio_wl64(pb, 0); /* ??? */
          es_pos = avio_tell(pb);
      /* media comments */
  
      hpos = put_header(pb, &ff_asf_codec_comment_header);
 -    put_guid(pb, &ff_asf_codec_comment1_header);
 +    ff_put_guid(pb, &ff_asf_codec_comment1_header);
      avio_wl32(pb, s->nb_streams);
      for (n = 0; n < s->nb_streams; n++) {
          AVCodec *p;
  
      /* movie chunk, followed by packets of packet_size */
      asf->data_offset = cur_pos;
 -    put_guid(pb, &ff_asf_data_header);
 +    ff_put_guid(pb, &ff_asf_data_header);
      avio_wl64(pb, data_chunk_size);
 -    put_guid(pb, &ff_asf_my_guid);
 +    ff_put_guid(pb, &ff_asf_my_guid);
      avio_wl64(pb, asf->nb_packets); /* nb packets */
      avio_w8(pb, 1); /* ??? */
      avio_w8(pb, 1); /* ??? */
@@@ -555,8 -615,10 +619,8 @@@ static int asf_write_header(AVFormatCon
      s->packet_size  = PACKET_SIZE;
      asf->nb_packets = 0;
  
 -    asf->last_indexed_pts      = 0;
      asf->index_ptr             = av_malloc(sizeof(ASFIndex) * ASF_INDEX_BLOCK);
      asf->nb_index_memory_alloc = ASF_INDEX_BLOCK;
 -    asf->nb_index_count        = 0;
      asf->maximum_packet        = 0;
  
      /* the data-chunk-size has to be 50 (DATA_HEADER_SIZE), which is
      ffio_init_context(&asf->pb, asf->packet_buf, s->packet_size, 1,
                        NULL, NULL, NULL, NULL);
  
 +    if (s->avoid_negative_ts < 0)
 +        s->avoid_negative_ts = 1;
 +
      return 0;
  }
  
@@@ -604,7 -663,7 +668,7 @@@ static int put_payload_parsing_info(AVF
      padsize -= PACKET_HEADER_MIN_SIZE;
      if (asf->multi_payloads_present)
          padsize--;
 -    assert(padsize >= 0);
 +    av_assert0(padsize >= 0);
  
      avio_w8(pb, ASF_PACKET_ERROR_CORRECTION_FLAGS);
      for (i = 0; i < ASF_PACKET_ERROR_CORRECTION_DATA_SIZE; i++)
@@@ -643,19 -702,20 +707,19 @@@ static void flush_packet(AVFormatContex
      ASFContext *asf = s->priv_data;
      int packet_hdr_size, packet_filled_size;
  
 -    assert(asf->packet_timestamp_end >= asf->packet_timestamp_start);
 +    av_assert0(asf->packet_timestamp_end >= asf->packet_timestamp_start);
  
      if (asf->is_streamed)
          put_chunk(s, 0x4424, s->packet_size, 0);
  
      packet_hdr_size = put_payload_parsing_info(s,
                                                 asf->packet_timestamp_start,
 -                                               asf->packet_timestamp_end -
 -                                               asf->packet_timestamp_start,
 +                                               asf->packet_timestamp_end - asf->packet_timestamp_start,
                                                 asf->packet_nb_payloads,
                                                 asf->packet_size_left);
  
      packet_filled_size = PACKET_SIZE - asf->packet_size_left;
 -    assert(packet_hdr_size <= asf->packet_size_left);
 +    av_assert0(packet_hdr_size <= asf->packet_size_left);
      memset(asf->packet_buf + packet_filled_size, 0, asf->packet_size_left);
  
      avio_write(s->pb, asf->packet_buf, s->packet_size - packet_hdr_size);
  }
  
  static void put_payload_header(AVFormatContext *s, ASFStream *stream,
 -                               int presentation_time, int m_obj_size,
 +                               int64_t presentation_time, int m_obj_size,
                                 int m_obj_offset, int payload_len, int flags)
  {
      ASFContext *asf = s->priv_data;
      avio_w8(pb, ASF_PAYLOAD_REPLICATED_DATA_LENGTH);
  
      avio_wl32(pb, m_obj_size);        // Replicated Data - Media Object Size
 -    avio_wl32(pb, presentation_time); // Replicated Data - Presentation Time
 +    avio_wl32(pb, (uint32_t) presentation_time); // Replicated Data - Presentation Time
  
      if (asf->multi_payloads_present) {
          avio_wl16(pb, payload_len);   // payload length
  }
  
  static void put_frame(AVFormatContext *s, ASFStream *stream, AVStream *avst,
 -                      int timestamp, const uint8_t *buf,
 +                      int64_t timestamp, const uint8_t *buf,
                        int m_obj_size, int flags)
  {
      ASFContext *asf = s->priv_data;
      stream->seq++;
  }
  
 +static int update_index(AVFormatContext *s, int start_sec,
 +                         uint32_t packet_number, uint16_t packet_count,
 +                         uint64_t packet_offset)
 +{
 +    ASFContext *asf = s->priv_data;
 +
 +    if (start_sec > asf->next_start_sec) {
 +        int i;
 +
 +        if (!asf->next_start_sec) {
 +            asf->next_packet_number = packet_number;
 +            asf->next_packet_count  = packet_count;
 +            asf->next_packet_offset = packet_offset;
 +        }
 +
 +        if (start_sec > asf->nb_index_memory_alloc) {
 +            int err;
 +            asf->nb_index_memory_alloc = (start_sec + ASF_INDEX_BLOCK) & ~(ASF_INDEX_BLOCK - 1);
 +            if ((err = av_reallocp_array(&asf->index_ptr,
 +                                         asf->nb_index_memory_alloc,
 +                                         sizeof(*asf->index_ptr))) < 0) {
 +                asf->nb_index_memory_alloc = 0;
 +                return err;
 +            }
 +        }
 +        for (i = asf->next_start_sec; i < start_sec; i++) {
 +            asf->index_ptr[i].packet_number = asf->next_packet_number;
 +            asf->index_ptr[i].packet_count  = asf->next_packet_count;
 +            asf->index_ptr[i].send_time     = asf->next_start_sec * INT64_C(10000000);
 +            asf->index_ptr[i].offset        = asf->next_packet_offset;
 +
 +        }
 +    }
 +    asf->maximum_packet     = FFMAX(asf->maximum_packet, packet_count);
 +    asf->next_packet_number = packet_number;
 +    asf->next_packet_count  = packet_count;
 +    asf->next_packet_offset = packet_offset;
 +    asf->next_start_sec     = start_sec;
 +
 +    return 0;
 +}
 +
  static int asf_write_packet(AVFormatContext *s, AVPacket *pkt)
  {
      ASFContext *asf = s->priv_data;
      AVIOContext *pb = s->pb;
      ASFStream *stream;
 -    int64_t duration;
      AVCodecContext *codec;
 -    int64_t packet_st, pts;
 -    int start_sec, i;
 +    uint32_t packet_number;
 +    int64_t pts;
 +    int start_sec;
      int flags = pkt->flags;
 +    int ret;
      uint64_t offset = avio_tell(pb);
  
      codec  = s->streams[pkt->stream_index]->codec;
          flags &= ~AV_PKT_FLAG_KEY;
  
      pts = (pkt->pts != AV_NOPTS_VALUE) ? pkt->pts : pkt->dts;
 -    assert(pts != AV_NOPTS_VALUE);
 -    duration      = pts * 10000;
 -    asf->duration = FFMAX(asf->duration, duration + pkt->duration * 10000);
 +    av_assert0(pts != AV_NOPTS_VALUE);
 +    pts *= 10000;
 +    asf->duration = FFMAX(asf->duration, pts + pkt->duration * 10000);
  
 -    packet_st = asf->nb_packets;
 +    packet_number = asf->nb_packets;
      put_frame(s, stream, s->streams[pkt->stream_index],
                pkt->dts, pkt->data, pkt->size, flags);
  
 +    start_sec = (int)((PREROLL_TIME * 10000 + pts + ASF_INDEXED_INTERVAL - 1)
 +              / ASF_INDEXED_INTERVAL);
 +
      /* check index */
      if ((!asf->is_streamed) && (flags & AV_PKT_FLAG_KEY)) {
 -        start_sec = (int)(duration / INT64_C(10000000));
 -        if (start_sec != (int)(asf->last_indexed_pts / INT64_C(10000000))) {
 -            for (i = asf->nb_index_count; i < start_sec; i++) {
 -                if (i >= asf->nb_index_memory_alloc) {
 -                    int err;
 -                    asf->nb_index_memory_alloc += ASF_INDEX_BLOCK;
 -                    if ((err = av_reallocp_array(&asf->index_ptr,
 -                                                asf->nb_index_memory_alloc,
 -                                                sizeof(*asf->index_ptr))) < 0) {
 -                       asf->nb_index_memory_alloc = 0;
 -                       return err;
 -                   }
 -                }
 -                // store
 -                asf->index_ptr[i].packet_number = (uint32_t)packet_st;
 -                asf->index_ptr[i].packet_count  = (uint16_t)(asf->nb_packets - packet_st);
 -                asf->index_ptr[i].send_time     = start_sec * INT64_C(10000000);
 -                asf->index_ptr[i].offset        = offset;
 -                asf->maximum_packet             = FFMAX(asf->maximum_packet,
 -                                                        (uint16_t)(asf->nb_packets - packet_st));
 -            }
 -            asf->nb_index_count   = start_sec;
 -            asf->last_indexed_pts = duration;
 -        }
 +        uint16_t packet_count = asf->nb_packets - packet_number;
 +        ret = update_index(s, start_sec, packet_number, packet_count, offset);
 +        if (ret < 0)
 +            return ret;
      }
 +    asf->end_sec = start_sec;
 +
      return 0;
  }
  
@@@ -854,9 -886,9 +918,9 @@@ static int asf_write_index(AVFormatCont
      AVIOContext *pb = s->pb;
      int i;
  
 -    put_guid(pb, &ff_asf_simple_index_header);
 +    ff_put_guid(pb, &ff_asf_simple_index_header);
      avio_wl64(pb, 24 + 16 + 8 + 4 + 4 + (4 + 2) * count);
 -    put_guid(pb, &ff_asf_my_guid);
 +    ff_put_guid(pb, &ff_asf_my_guid);
      avio_wl64(pb, ASF_INDEXED_INTERVAL);
      avio_wl32(pb, max);
      avio_wl32(pb, count);
@@@ -872,7 -904,6 +936,7 @@@ static int asf_write_trailer(AVFormatCo
  {
      ASFContext *asf = s->priv_data;
      int64_t file_size, data_size;
 +    int ret;
  
      /* flush the current packet */
      if (asf->pb.buf_ptr > asf->pb.buffer)
  
      /* write index */
      data_size = avio_tell(s->pb);
 -    if ((!asf->is_streamed) && (asf->nb_index_count != 0))
 -        asf_write_index(s, asf->index_ptr, asf->maximum_packet, asf->nb_index_count);
 +    if (!asf->is_streamed && asf->next_start_sec) {
 +        if ((ret = update_index(s, asf->end_sec + 1, 0, 0, 0)) < 0)
 +            return ret;
 +        asf_write_index(s, asf->index_ptr, asf->maximum_packet, asf->next_start_sec);
 +    }
      avio_flush(s->pb);
  
      if (asf->is_streamed || !s->pb->seekable) {
          asf_write_header1(s, file_size, data_size - asf->data_offset);
      }
  
 -    av_free(asf->index_ptr);
 +    av_freep(&asf->index_ptr);
      return 0;
  }
  
@@@ -907,7 -935,7 +971,7 @@@ AVOutputFormat ff_asf_muxer = 
      .mime_type      = "video/x-ms-asf",
      .extensions     = "asf,wmv,wma",
      .priv_data_size = sizeof(ASFContext),
 -    .audio_codec    = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_MP2,
 +    .audio_codec    = AV_CODEC_ID_WMAV2,
      .video_codec    = AV_CODEC_ID_MSMPEG4V3,
      .write_header   = asf_write_header,
      .write_packet   = asf_write_packet,
@@@ -926,7 -954,7 +990,7 @@@ AVOutputFormat ff_asf_stream_muxer = 
      .mime_type      = "video/x-ms-asf",
      .extensions     = "asf,wmv,wma",
      .priv_data_size = sizeof(ASFContext),
 -    .audio_codec    = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_MP2,
 +    .audio_codec    = AV_CODEC_ID_WMAV2,
      .video_codec    = AV_CODEC_ID_MSMPEG4V3,
      .write_header   = asf_write_stream_header,
      .write_packet   = asf_write_packet,
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/avutil.h"
  
  #define LIBAVFORMAT_VERSION_MAJOR 55
 -#define LIBAVFORMAT_VERSION_MINOR  5
 -#define LIBAVFORMAT_VERSION_MICRO  1
 +#define LIBAVFORMAT_VERSION_MINOR 18
- #define LIBAVFORMAT_VERSION_MICRO 100
++#define LIBAVFORMAT_VERSION_MICRO 101
  
  #define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \
                                                 LIBAVFORMAT_VERSION_MINOR, \
   * the public API and may change, break or disappear at any time.
   */
  
 +#ifndef FF_API_ALLOC_OUTPUT_CONTEXT
 +#define FF_API_ALLOC_OUTPUT_CONTEXT    (LIBAVFORMAT_VERSION_MAJOR < 56)
 +#endif
 +#ifndef FF_API_FORMAT_PARAMETERS
 +#define FF_API_FORMAT_PARAMETERS       (LIBAVFORMAT_VERSION_MAJOR < 56)
 +#endif
 +#ifndef FF_API_NEW_STREAM
 +#define FF_API_NEW_STREAM              (LIBAVFORMAT_VERSION_MAJOR < 56)
 +#endif
 +#ifndef FF_API_SET_PTS_INFO
 +#define FF_API_SET_PTS_INFO            (LIBAVFORMAT_VERSION_MAJOR < 56)
 +#endif
 +#ifndef FF_API_CLOSE_INPUT_FILE
 +#define FF_API_CLOSE_INPUT_FILE        (LIBAVFORMAT_VERSION_MAJOR < 56)
 +#endif
 +#ifndef FF_API_READ_PACKET
 +#define FF_API_READ_PACKET             (LIBAVFORMAT_VERSION_MAJOR < 56)
 +#endif
 +#ifndef FF_API_ASS_SSA
 +#define FF_API_ASS_SSA                 (LIBAVFORMAT_VERSION_MAJOR < 56)
 +#endif
 +#ifndef FF_API_R_FRAME_RATE
 +#define FF_API_R_FRAME_RATE            1
 +#endif
  #endif /* AVFORMAT_VERSION_H */