Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Mon, 2 Jul 2012 19:19:41 +0000 (21:19 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Mon, 2 Jul 2012 19:19:41 +0000 (21:19 +0200)
* qatar/master:
  asfdec: read attached pictures.
  apetag: reindent
  apetag: export attached covers as video streams.
  apetag: fix the amount of data read from binary tags.
  apetag: make sure avio_get_str() doesn't read more than it should.
  mov: read itunes cover art.
  snow: remove VLA in mc_block()
  intfloat: Don't use designated initializers in the public headers
  snow: remove a VLA.
  doc: Remind devs to check return values, especially for malloc() et al
  MS ATC Screen (aka MSS3) decoder
  vf_yadif: move x86 init code to x86/yadif.c
  vf_gradfun: move x86 init code to x86/gradfun.c
  roqvideo: Remove a totally unused dspcontext
  smacker: remove some unused code
  dsicin: remove dead assignment
  aacdec: remove dead assignment
  rl2: remove dead assignment
  proresenc: make a variable local to the loop where it is used
  alsdec: remove dead assignments

Conflicts:
Changelog
doc/developer.texi
libavcodec/allcodecs.c
libavcodec/avcodec.h
libavcodec/version.h
libavfilter/gradfun.h
libavfilter/x86/gradfun.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
28 files changed:
1  2 
Changelog
doc/developer.texi
doc/general.texi
libavcodec/Makefile
libavcodec/aacdec.c
libavcodec/allcodecs.c
libavcodec/alsdec.c
libavcodec/avcodec.h
libavcodec/dsicinav.c
libavcodec/mss3.c
libavcodec/proresenc_kostya.c
libavcodec/rl2.c
libavcodec/roqvideo.h
libavcodec/smacker.c
libavcodec/snow.c
libavcodec/snowenc.c
libavcodec/version.h
libavfilter/gradfun.h
libavfilter/vf_gradfun.c
libavfilter/vf_yadif.c
libavfilter/x86/gradfun.c
libavfilter/x86/yadif.c
libavfilter/x86/yadif_template.c
libavfilter/yadif.h
libavformat/apetag.c
libavformat/asfdec.c
libavformat/mov.c
libavformat/riff.c

diff --combined Changelog
+++ b/Changelog
  Entries are sorted chronologically from oldest to youngest within each release,
  releases are sorted from youngest to oldest.
  
 -version <next>:
 -
 -- XWD encoder and decoder
 -- Support for fragmentation in the mov/mp4 muxer
 -- ISMV (Smooth Streaming) muxer
 +version next:
 +- 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
 +- join audio filter
 +- audio channel mapping filter
++- Microsoft ATC Screen decoder
 +- showwaves filter
 +- LucasArts SMUSH playback support
 +- SAMI demuxer and decoder
 +- RealText demuxer and decoder
 +
 +
 +version 0.11:
 +
 +- 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
 -- remove libpostproc
  - ID3v2 attached pictures reading and writing
  - WMA Lossless decoder
 -- XBM encoder
 +- bluray protocol
 +- blackdetect filter
 +- libutvideo encoder wrapper (--enable-libutvideo)
 +- swapuv filter
 +- bbox filter
 +- XBM encoder and decoder
  - RealAudio Lossless decoder
  - ZeroCodec decoder
 -- drop support for avconv without libavfilter
 -- add libavresample audio conversion library
 -- audio filters support in libavfilter and avconv
 +- 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
 -- audio split filter
 +- vorbis parser
 +- png parser
  - audio mix filter
 -- avprobe output is now standard INI or JSON. The old format can still
 -  be used with -of old.
 -- Indeo Audio decoder
 -- channelsplit audio filter
 -- RTMPT protocol support
 -- iLBC encoding/decoding via libilbc
 -- Microsoft Screen 1 decoder
 -- join audio filter
 -- audio channel mapping filter
 -- Microsoft ATC Screen decoder
  
  
 -version 0.8:
 +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
 -
 -
 -version 0.8_beta2:
 -
 +- 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:
@@@ -602,7 -509,6 +603,7 @@@ version 0.5
  - Gopher client support
  - MXF D-10 muxer
  - generic metadata API
 +- flash ScreenVideo2 encoder
  
  
  version 0.4.9-pre1:
@@@ -805,7 -711,7 +806,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 doc/developer.texi
  @section API
  @itemize @bullet
  @item libavcodec is the library containing the codecs (both encoding and
 -decoding). Look at @file{libavcodec/apiexample.c} to see how to use it.
 +decoding). Look at @file{doc/examples/decoding_encoding.c} to see how to use
 +it.
  
  @item libavformat is the library containing the file format handling (mux and
 -demux code for several formats). Look at @file{avplay.c} to use it in a
 -player. See @file{libavformat/output-example.c} to use it to generate
 -audio or video streams.
 +demux code for several formats). Look at @file{ffplay.c} to use it in a
 +player. See @file{doc/examples/muxing.c} to use it to generate audio or video
 +streams.
  
  @end itemize
  
 -@section Integrating libav in your program
 -
 -Shared libraries should be used whenever is possible in order to reduce
 -the effort distributors have to pour to support programs and to ensure
 -only the public api is used.
 -
 -You can use Libav in your commercial program, but you must abide to the
 -license, LGPL or GPL depending on the specific features used, please refer
 -to @uref{http://libav.org/legal.html, our legal page} for a quick checklist and to
 -the following links for the exact text of each license:
 -@uref{http://git.libav.org/?p=libav.git;a=blob;f=COPYING.GPLv2, GPL version 2},
 -@uref{http://git.libav.org/?p=libav.git;a=blob;f=COPYING.GPLv3, GPL version 3},
 -@uref{http://git.libav.org/?p=libav.git;a=blob;f=COPYING.LGPLv2.1, LGPL version 2.1},
 -@uref{http://git.libav.org/?p=libav.git;a=blob;f=COPYING.LGPLv3, LGPL version 3}.
 -Any modification to the source code can be suggested for inclusion.
 -The best way to proceed is to send your patches to the
 -@uref{https://lists.libav.org/mailman/listinfo/libav-devel, libav-devel}
 -mailing list.
 +@section Integrating libavcodec or libavformat in your program
 +
 +You can integrate all the source code of the libraries to link them
 +statically to avoid any version problem. All you need is to provide a
 +'config.mak' and a 'config.h' in the parent directory. See the defines
 +generated by ./configure to understand what is needed.
 +
 +You can use libavcodec or libavformat in your commercial program, but
 +@emph{any patch you make must be published}. The best way to proceed is
 +to send your patches to the FFmpeg mailing list.
 +
 +@section Contributing
 +
 +There are 3 ways by which code gets into ffmpeg.
 +@itemize @bullet
 +@item Submitting Patches to the main developer mailing list
 +      see @ref{Submitting patches} for details.
 +@item Directly committing changes to the main tree.
 +@item Committing changes to a git clone, for example on github.com or
 +      gitorious.org. And asking us to merge these changes.
 +@end itemize
 +
 +Whichever way, changes should be reviewed by the maintainer of the code
 +before they are committed. And they should follow the @ref{Coding Rules}.
 +The developer making the commit and the author are responsible for their changes
 +and should try to fix issues their commit causes.
  
  @anchor{Coding Rules}
  @section Coding Rules
  
  @subsection Code formatting conventions
 -The code is written in K&R C style. That means the following:
 -@itemize @bullet
 -@item
 -The control statements are formatted by putting space between the statement
 -and parenthesis in the following way:
 -@example
 -for (i = 0; i < filter->input_count; i++) @{
 -@end example
 -@item
 -The case statement is always located at the same level as the switch itself:
 -@example
 -switch (link->init_state) @{
 -case AVLINK_INIT:
 -    continue;
 -case AVLINK_STARTINIT:
 -    av_log(filter, AV_LOG_INFO, "circular filter chain detected");
 -    return 0;
 -@end example
 -@item
 -Braces in function declarations are written on the new line:
 -@example
 -const char *avfilter_configuration(void)
 -@{
 -    return LIBAV_CONFIGURATION;
 -@}
 -@end example
 -@item
 -Do not check for NULL values by comparison, @samp{if (p)} and
 -@samp{if (!p)} are correct; @samp{if (p == NULL)} and @samp{if (p != NULL)}
 -are not.
 -@item
 -In case of a single-statement if, no curly braces are required:
 -@example
 -if (!pic || !picref)
 -    goto fail;
 -@end example
 -@item
 -Do not put spaces immediately inside parentheses. @samp{if (ret)} is
 -a valid style; @samp{if ( ret )} is not.
 -@end itemize
  
  There are the following guidelines regarding the indentation in files:
  @itemize @bullet
@@@ -70,7 -101,7 +70,7 @@@ and only if this improves readability
  @end itemize
  The presentation is one inspired by 'indent -i4 -kr -nut'.
  
 -The main priority in Libav is simplicity and small code size in order to
 +The main priority in FFmpeg is simplicity and small code size in order to
  minimize the bug count.
  
  @subsection Comments
@@@ -115,7 -146,7 +115,7 @@@ int myfunc(int my_parameter
  
  @subsection C language features
  
 -Libav is programmed in the ISO C90 language with a few additional
 +FFmpeg is programmed in the ISO C90 language with a few additional
  features from ISO C99, namely:
  @itemize @bullet
  @item
@@@ -147,10 -178,10 +147,10 @@@ GCC statement expressions (@samp{(x = (
  @end itemize
  
  @subsection Naming conventions
 -All names are using underscores (_), not CamelCase. For example,
 -@samp{avfilter_get_video_buffer} is a valid function name and
 -@samp{AVFilterGetVideo} is not. The only exception from this are structure
 -names; they should always be in the CamelCase
 +All names are using underscores (_), not CamelCase. For example, @samp{avfilter_get_video_buffer} is
 +a valid function name and @samp{AVFilterGetVideo} is not. The exception from this are type names, like
 +for example structs and enums; they should always be in the CamelCase
 +
  
  There are following conventions for naming variables and functions:
  @itemize @bullet
@@@ -181,10 -212,10 +181,10 @@@ should also be avoided if they don't ma
  @end itemize
  
  @subsection Editor configuration
 -In order to configure Vim to follow Libav formatting conventions, paste
 +In order to configure Vim to follow FFmpeg formatting conventions, paste
  the following snippet into your @file{.vimrc}:
  @example
 -" indentation rules for libav: 4 spaces, no tabs
 +" indentation rules for FFmpeg: 4 spaces, no tabs
  set expandtab
  set shiftwidth=4
  set softtabstop=4
@@@ -201,7 -232,7 +201,7 @@@ autocmd InsertEnter * match ForbiddenWh
  
  For Emacs, add these roughly equivalent lines to your @file{.emacs.d/init.el}:
  @example
 -(c-add-style "libav"
 +(c-add-style "ffmpeg"
               '("k&r"
                 (c-basic-offset . 4)
                 (indent-tabs-mode nil)
                  (statement-cont . (c-lineup-assignments +)))
                 )
               )
 -(setq c-default-style "libav")
 +(setq c-default-style "ffmpeg")
  @end example
  
  @section Development Policy
     an "or any later version" clause is also acceptable, but LGPL is
     preferred.
  @item
 -   All the patches MUST be reviewed in the mailing list before they are
 -   committed.
 -@item
 -   The Libav coding style should remain consistent. Changes to
 -   conform will be suggested during the review or implemented on commit.
 -@item
 -   Patches should be generated using @code{git format-patch} or directly sent
 -   using @code{git send-email}.
 -   Please make sure you give the proper credit by setting the correct author
 -   in the commit.
 -@item
 -   The commit message should have a short first line in the form of
 -   @samp{topic: short description} as header, separated by a newline
 -   from the body consting in few lines explaining the reason of the patch.
 -   Referring to the issue on the bug tracker does not exempt to report an
 -   excerpt of the bug.
 -@item
 -   Work in progress patches should be sent to the mailing list with the [WIP]
 -   or the [RFC] tag.
 -@item
 -   Branches in public personal repos are advised as way to
 -   work on issues collaboratively.
 +   You must not commit code which breaks FFmpeg! (Meaning unfinished but
 +   enabled code which breaks compilation or compiles but does not work or
 +   breaks the regression tests)
 +   You can commit unfinished stuff (for testing etc), but it must be disabled
 +   (#ifdef etc) by default so it does not interfere with other developers'
 +   work.
  @item
 -   You do not have to over-test things. If it works for you and you think it
 -   should work for others, send it to the mailing list for review.
 -   If you have doubt about portability please state it in the submission so
 -   people with specific hardware could test it.
 +   You do not have to over-test things. If it works for you, and you think it
 +   should work for others, then commit. If your code has problems
 +   (portability, triggers compiler bugs, unusual environment etc) they will be
 +   reported and eventually fixed.
  @item
     Do not commit unrelated changes together, split them into self-contained
     pieces. Also do not forget that if part B depends on part A, but A does not
     Keeping changes well split into self-contained parts makes reviewing and
     understanding them on the commit log mailing list easier. This also helps
     in case of debugging later on.
 -@item
 -   Patches that change behavior of the programs (renaming options etc) or
 -   public API or ABI should be discussed in depth and possible few days should
 -   pass between discussion and commit.
 -   Changes to the build system (Makefiles, configure script) which alter
 -   the expected behavior should be considered in the same regard.
 +   Also if you have doubts about splitting or not splitting, do not hesitate to
 +   ask/discuss it on the developer mailing list.
 +@item
 +   Do not change behavior of the programs (renaming options etc) or public
 +   API or ABI without first discussing it on the ffmpeg-devel mailing list.
 +   Do not remove functionality from the code. Just improve!
 +
 +   Note: Redundant code can be removed.
 +@item
 +   Do not commit changes to the build system (Makefiles, configure script)
 +   which change behavior, defaults etc, without asking first. The same
 +   applies to compiler warning fixes, trivial looking fixes and to code
 +   maintained by other developers. We usually have a reason for doing things
 +   the way we do. Send your changes as patches to the ffmpeg-devel mailing
 +   list, and if the code maintainers say OK, you may commit. This does not
 +   apply to files you wrote and/or maintain.
 +@item
 +   We refuse source indentation and other cosmetic changes if they are mixed
 +   with functional changes, such commits will be rejected and removed. Every
 +   developer has his own indentation style, you should not change it. Of course
 +   if you (re)write something, you can use your own style, even though we would
 +   prefer if the indentation throughout FFmpeg was consistent (Many projects
 +   force a given indentation style - we do not.). If you really need to make
 +   indentation changes (try to avoid this), separate them strictly from real
 +   changes.
 +
 +   NOTE: If you had to put if()@{ .. @} over a large (> 5 lines) chunk of code,
 +   then either do NOT change the indentation of the inner part within (do not
 +   move it to the right)! or do so in a separate commit
 +@item
 +   Always fill out the commit log message. Describe in a few lines what you
 +   changed and why. You can refer to mailing list postings if you fix a
 +   particular bug. Comments such as "fixed!" or "Changed it." are unacceptable.
 +   Recommended format:
 +   area changed: Short 1 line description
 +
 +   details describing what and why and giving references.
 +@item
 +   Make sure the author of the commit is set correctly. (see git commit --author)
 +   If you apply a patch, send an
 +   answer to ffmpeg-devel (or wherever you got the patch from) saying that
 +   you applied the patch.
  @item
     When applying patches that have been discussed (at length) on the mailing
     list, reference the thread in the log message.
  @item
 -    Subscribe to the
 -    @uref{https://lists.libav.org/mailman/listinfo/libav-devel, libav-devel} and
 -    @uref{https://lists.libav.org/mailman/listinfo/libav-commits, libav-commits}
 -    mailing lists.
 -    Bugs and possible improvements or general questions regarding commits
 -    are discussed on libav-devel. We expect you to react if problems with
 -    your code are uncovered.
 +    Do NOT commit to code actively maintained by others without permission.
 +    Send a patch to ffmpeg-devel instead. If no one answers within a reasonable
 +    timeframe (12h for build failures and security fixes, 3 days small changes,
 +    1 week for big patches) then commit your patch if you think it is OK.
 +    Also note, the maintainer can simply ask for more time to review!
 +@item
 +    Subscribe to the ffmpeg-cvslog mailing list. The diffs of all commits
 +    are sent there and reviewed by all the other developers. Bugs and possible
 +    improvements or general questions regarding commits are discussed there. We
 +    expect you to react if problems with your code are uncovered.
  @item
      Update the documentation if you change behavior or add features. If you are
 -    unsure how best to do this, send an [RFC] patch to libav-devel.
 +    unsure how best to do this, send a patch to ffmpeg-devel, the documentation
 +    maintainer(s) will review and commit your stuff.
  @item
 -    All discussions and decisions should be reported on the public developer
 -    mailing list, so that there is a reference to them.
 -    Other media (e.g. IRC) should be used for coordination and immediate
 -    collaboration.
 +    Try to keep important discussions and requests (also) on the public
 +    developer mailing list, so that all developers can benefit from them.
  @item
      Never write to unallocated memory, never write over the end of arrays,
      always check values read from some untrusted source before using them
 -    as array index or other risky things. Always use valgrind to doublecheck.
 +    as array index or other risky things.
  @item
 -    Remember to check if you need to bump versions for the specific libav
 +    Remember to check if you need to bump versions for the specific libav*
      parts (libavutil, libavcodec, libavformat) you are changing. You need
      to change the version integer.
      Incrementing the first component means no backward compatibility to
      Incrementing the third component means a noteworthy binary compatible
      change (e.g. encoder bug fix that matters for the decoder).
  @item
 -    Compiler warnings indicate potential bugs or code with bad style.
 +    Compiler warnings indicate potential bugs or code with bad style. If a type of
 +    warning always points to correct and clean code, that warning should
 +    be disabled, not the code changed.
 +    Thus the remaining warnings can either be bugs or correct code.
      If it is a bug, the bug has to be fixed. If it is not, the code should
      be changed to not generate a warning unless that causes a slowdown
      or obfuscates the code.
 -    If a type of warning leads to too many false positives, that warning
 -    should be disabled, not the code changed.
  @item
      If you add a new file, give it a proper license header. Do not copy and
      paste it from a random place, use an existing file as template.
  
  We think our rules are not too hard. If you have comments, contact us.
  
 -Note, some rules were borrowed from the MPlayer project.
 +Note, these rules are mostly borrowed from the MPlayer project.
  
 +@anchor{Submitting patches}
  @section Submitting patches
  
  First, read the @ref{Coding Rules} above if you did not yet, in particular
  the rules regarding patch submission.
  
 -As stated already, please do not submit a patch which contains several
 -unrelated changes.
 +When you submit your patch, please use @code{git format-patch} or
 +@code{git send-email}. We cannot read other diffs :-)
 +
 +Also please do not submit a patch which contains several unrelated changes.
  Split it into separate, self-contained pieces. This does not mean splitting
  file by file. Instead, make the patch as small as possible while still
  keeping it as a logical unit that contains an individual change, even
  if it spans multiple files. This makes reviewing your patches much easier
  for us and greatly increases your chances of getting your patch applied.
  
 -Use the patcheck tool of Libav to check your patch.
 +Use the patcheck tool of FFmpeg to check your patch.
  The tool is located in the tools directory.
  
 -Run the @ref{Regression Tests} before submitting a patch in order to verify
 +Run the @ref{Regression tests} before submitting a patch in order to verify
  it does not cause unexpected problems.
  
  Patches should be posted as base64 encoded attachments (or any other
  encoding which ensures that the patch will not be trashed during
 -transmission) to the
 -@uref{https://lists.libav.org/mailman/listinfo/libav-devel, libav-devel}
 -mailing list.
 +transmission) to the ffmpeg-devel mailing list, see
 +@url{http://lists.ffmpeg.org/mailman/listinfo/ffmpeg-devel}
  
  It also helps quite a bit if you tell us what the patch does (for example
  'replaces lrint by lrintf'), and why (for example '*BSD isn't C99 compliant
 -and has no lrint()'). This kind of explanation should be the body of the
 -commit message.
 +and has no lrint()')
  
  Also please if you send several patches, send each patch as a separate mail,
  do not attach several unrelated patches to the same mail.
  
 -Use @code{git send-email} when possible since it will properly send patches
 -without requiring extra care.
 -
  Your patch will be reviewed on the mailing list. You will likely be asked
  to make some changes and are expected to send in an improved version that
  incorporates the requests from the review. This process may go through
 -several iterations. Once your patch is deemed good enough, it will be
 -committed to the official Libav tree.
 +several iterations. Once your patch is deemed good enough, some developer
 +will pick it up and commit it to the official FFmpeg tree.
  
  Give us a few days to react. But if some time passes without reaction,
  send a reminder by email. Your patch should eventually be dealt with.
  @item
      Did you add the CodecID to @file{avcodec.h}?
  @item
 -    If it has a fourcc, did you add it to @file{libavformat/riff.c},
 +    If it has a fourCC, did you add it to @file{libavformat/riff.c},
      even if it is only a decoder?
  @item
      Did you add a rule to compile the appropriate files in the Makefile?
 -    Remember to do this even if you are just adding a format to a file that
 -    is already being compiled by some other rule, like a raw demuxer.
 +    Remember to do this even if you're just adding a format to a file that is
 +    already being compiled by some other rule, like a raw demuxer.
  @item
      Did you add an entry to the table of supported formats or codecs in
      @file{doc/general.texi}?
  
  @enumerate
  @item
 -    Does @code{make check} pass with the patch applied?
 +    Does @code{make fate} pass with the patch applied?
 +@item
 +    Was the patch generated with git format-patch or send-email?
  @item
 -    Is the patch against latest Libav git master branch?
 +    Did you sign off your patch? (git commit -s)
 +    See @url{http://kerneltrap.org/files/Jeremy/DCO.txt} for the meaning
 +    of sign off.
  @item
 -    Are you subscribed to the
 -    @uref{https://lists.libav.org/mailman/listinfo/libav-devel, libav-devel}
 -    mailing list? (Only list subscribers are allowed to post.)
 +    Did you provide a clear git commit log message?
 +@item
 +    Is the patch against latest FFmpeg git master branch?
 +@item
 +    Are you subscribed to ffmpeg-devel?
 +    (the list is subscribers only due to spam)
  @item
      Have you checked that the changes are minimal, so that the same cannot be
      achieved with a smaller patch and/or simpler final code?
      If the patch fixes a bug, did you provide enough information, including
      a sample, so the bug can be reproduced and the fix can be verified?
      Note please do not attach samples >100k to mails but rather provide a
 -    URL, you can upload to ftp://upload.libav.org
 +    URL, you can upload to ftp://upload.ffmpeg.org
  @item
      Did you provide a verbose summary about what the patch does change?
  @item
      patch easily?
  @item
      If you added a new file, did you insert a license header? It should be
 -    taken from Libav, not randomly copied and pasted from somewhere else.
 +    taken from FFmpeg, not randomly copied and pasted from somewhere else.
  @item
      You should maintain alphabetical order in alphabetically ordered lists as
      long as doing so does not break API/ABI compatibility.
      Lines with similar content should be aligned vertically when doing so
      improves readability.
  @item
 +    Consider to add a regression test for your code.
 +@item
 +    If you added YASM code please check that things still work with --disable-yasm
++@item
+     Make sure you check the return values of function and return appropriate
+     error codes. Especially memory allocation functions like @code{malloc()}
+     are notoriously left unchecked, which is a serious problem.
  @end enumerate
  
  @section Patch review process
  
 -All patches posted to the
 -@uref{https://lists.libav.org/mailman/listinfo/libav-devel, libav-devel}
 -mailing list will be reviewed, unless they contain a
 +All patches posted to ffmpeg-devel will be reviewed, unless they contain a
  clear note that the patch is not for the git master branch.
  Reviews and comments will be posted as replies to the patch on the
  mailing list. The patch submitter then has to take care of every comment,
@@@ -507,26 -512,22 +511,26 @@@ After a patch is approved it will be co
  We will review all submitted patches, but sometimes we are quite busy so
  especially for large patches this can take several weeks.
  
 -When resubmitting patches, if their size grew or during the review different
 -issues arisen please split the patch so each issue has a specific patch.
 +If you feel that the review process is too slow and you are willing to try to
 +take over maintainership of the area of code you change then just clone
 +git master and maintain the area of code there. We will merge each area from
 +where its best maintained.
  
 -@anchor{Regression Tests}
 -@section Regression Tests
 +When resubmitting patches, please do not make any significant changes
 +not related to the comments received during review. Such patches will
 +be rejected. Instead, submit significant changes or new features as
 +separate patches.
  
 -Before submitting a patch (or committing to the repository), you should at
 -least make sure that it does not break anything.
 +@anchor{Regression tests}
 +@section Regression tests
  
 -If the code changed has already a test present in FATE you should run it,
 -otherwise it is advised to add it.
 +Before submitting a patch (or committing to the repository), you should at least
 +test that you did not break anything.
  
 -Improvements to codec or demuxer might change the FATE results. Make sure
 -to commit the update reference with the change and to explain in the comment
 -why the expected result changed.
 +Running 'make fate' accomplishes this, please see @url{fate.html} for details.
  
 -Please refer to @url{fate.html}.
 +[Of course, some patches may change the results of the regression tests. In
 +this case, the reference results of the regression tests shall be modified
 +accordingly].
  
  @bye
diff --combined doc/general.texi
  
  @chapter External libraries
  
 -Libav can be hooked up with a number of external libraries to add support
 +FFmpeg can be hooked up with a number of external libraries to add support
  for more formats. None of them are used by default, their use has to be
  explicitly requested by passing the appropriate flags to
  @command{./configure}.
  
 +@section OpenJPEG
 +
 +FFmpeg can use the OpenJPEG libraries for encoding/decoding J2K videos.  Go to
 +@url{http://www.openjpeg.org/} to get the libraries and follow the installation
 +instructions.  To enable using OpenJPEG in FFmpeg, pass @code{--enable-libopenjpeg} to
 +@file{./configure}.
 +
 +
  @section OpenCORE and VisualOn libraries
  
  Spun off Google Android sources, OpenCore and VisualOn libraries provide
@@@ -33,13 -25,13 +33,13 @@@ encoders for a number of audio codecs
  OpenCORE and VisualOn libraries are under the Apache License 2.0
  (see @url{http://www.apache.org/licenses/LICENSE-2.0} for details), which is
  incompatible with the LGPL version 2.1 and GPL version 2. You have to
 -upgrade Libav's license to LGPL version 3 (or if you have enabled
 +upgrade FFmpeg's license to LGPL version 3 (or if you have enabled
  GPL components, GPL version 3) to use it.
  @end float
  
  @subsection OpenCORE AMR
  
 -Libav can make use of the OpenCORE libraries for AMR-NB
 +FFmpeg can make use of the OpenCORE libraries for AMR-NB
  decoding/encoding and AMR-WB decoding.
  
  Go to @url{http://sourceforge.net/projects/opencore-amr/} and follow the
@@@ -49,7 -41,7 +49,7 @@@ Then pass @code{--enable-libopencore-am
  
  @subsection VisualOn AAC encoder library
  
 -Libav can make use of the VisualOn AACenc library for AAC encoding.
 +FFmpeg can make use of the VisualOn AACenc library for AAC encoding.
  
  Go to @url{http://sourceforge.net/projects/opencore-amr/} and follow the
  instructions for installing the library.
@@@ -57,7 -49,7 +57,7 @@@ Then pass @code{--enable-libvo-aacenc} 
  
  @subsection VisualOn AMR-WB encoder library
  
 -Libav can make use of the VisualOn AMR-WBenc library for AMR-WB encoding.
 +FFmpeg can make use of the VisualOn AMR-WBenc library for AMR-WB encoding.
  
  Go to @url{http://sourceforge.net/projects/opencore-amr/} and follow the
  instructions for installing the library.
@@@ -65,7 -57,7 +65,7 @@@ Then pass @code{--enable-libvo-amrwbenc
  
  @section LAME
  
 -Libav can make use of the LAME library for MP3 encoding.
 +FFmpeg can make use of the LAME library for MP3 encoding.
  
  Go to @url{http://lame.sourceforge.net/} and follow the
  instructions for installing the library.
@@@ -73,7 -65,7 +73,7 @@@ Then pass @code{--enable-libmp3lame} t
  
  @section libvpx
  
 -Libav can make use of the libvpx library for VP8 encoding.
 +FFmpeg can make use of the libvpx library for VP8 encoding.
  
  Go to @url{http://www.webmproject.org/} and follow the instructions for
  installing the library. Then pass @code{--enable-libvpx} to configure to
@@@ -81,7 -73,7 +81,7 @@@ enable it
  
  @section x264
  
 -Libav can make use of the x264 library for H.264 encoding.
 +FFmpeg can make use of the x264 library for H.264 encoding.
  
  Go to @url{http://www.videolan.org/developers/x264.html} and follow the
  instructions for installing the library. Then pass @code{--enable-libx264} to
@@@ -90,14 -82,14 +90,14 @@@ configure to enable it
  @float NOTE
  x264 is under the GNU Public License Version 2 or later
  (see @url{http://www.gnu.org/licenses/old-licenses/gpl-2.0.html} for
 -details), you must upgrade Libav's license to GPL in order to use it.
 +details), you must upgrade FFmpeg's license to GPL in order to use it.
  @end float
  
  @section libilbc
  
  iLBC is a narrowband speech codec that has been made freely available
  by Google as part of the WebRTC project. libilbc is a packaging friendly
 -copy of the iLBC codec. Libav can make use of the libilbc library for
 +copy of the iLBC codec. FFmpeg can make use of the libilbc library for
  iLBC encoding and decoding.
  
  Go to @url{https://github.com/dekkers/libilbc} and follow the instructions for
@@@ -106,13 -98,13 +106,13 @@@ enable it
  
  
  
 -@chapter Supported File Formats and Codecs
 +@chapter Supported File Formats, Codecs or Features
  
  You can use the @code{-formats} and @code{-codecs} options to have an exhaustive list.
  
  @section File Formats
  
 -Libav supports the following file formats through the @code{libavformat}
 +FFmpeg supports the following file formats through the @code{libavformat}
  library:
  
  @multitable @columnfractions .4 .1 .1 .4
  @item 4xm                       @tab   @tab X
      @tab 4X Technologies format, used in some games.
  @item 8088flex TMV              @tab   @tab X
 +@item ACT Voice                 @tab   @tab X
 +    @tab contains G.729 audio
  @item Adobe Filmstrip           @tab X @tab X
  @item Audio IFF (AIFF)          @tab X @tab X
  @item American Laser Games MM   @tab   @tab X
      @tab Multimedia format used in games like Mad Dog McCree.
  @item 3GPP AMR                  @tab X @tab X
  @item Apple HTTP Live Streaming @tab   @tab X
 +@item Artworx Data Format       @tab   @tab X
  @item ASF                       @tab X @tab X
  @item AVI                       @tab X @tab X
  @item AVISynth                  @tab   @tab X
      @tab Audio and video format used in some games by Beam Software.
  @item Bethesda Softworks VID    @tab   @tab X
      @tab Used in some games from Bethesda Softworks.
 +@item Binary text               @tab   @tab X
  @item Bink                      @tab   @tab X
      @tab Multimedia format used by many games.
  @item Bitmap Brothers JV        @tab   @tab X
      @tab Video format used by CD+G karaoke disks
  @item Commodore CDXL            @tab   @tab X
      @tab Amiga CD video format
 -@item Core Audio Format         @tab   @tab X
 +@item Core Audio Format         @tab X @tab X
      @tab Apple Core Audio Format
  @item CRC testing format        @tab X @tab
  @item Creative Voice            @tab X @tab X
  @item Electronic Arts cdata  @tab    @tab X
  @item Electronic Arts Multimedia  @tab    @tab X
      @tab Used in various EA games; files have extensions like WVE and UV2.
 -@item FFM (AVserver live feed)  @tab X @tab X
 +@item FFM (FFserver live feed)  @tab X @tab X
  @item Flash (SWF)               @tab X @tab X
  @item Flash 9 (AVM2)            @tab X @tab X
      @tab Only embedded audio is decoded.
  @item framecrc testing format   @tab X @tab
  @item FunCom ISS                @tab   @tab X
      @tab Audio format used in various games from FunCom like The Longest Journey.
 +@item G.723.1                   @tab X @tab X
 +@item G.729 BIT                 @tab X @tab X
 +@item G.729 raw                 @tab   @tab X
  @item GIF Animation             @tab X @tab
  @item GXF                       @tab X @tab X
      @tab General eXchange Format SMPTE 360M, used by Thomson Grass Valley
           playout servers.
 +@item iCEDraw File              @tab   @tab X
 +@item ICO                       @tab   @tab X
 +    @tab Microsoft Windows ICO
  @item id Quake II CIN video     @tab   @tab X
  @item id RoQ                    @tab X @tab X
 -    @tab Used in Quake III, Jedi Knight 2, other computer games.
 +    @tab Used in Quake III, Jedi Knight 2 and other computer games.
  @item IEC61937 encapsulation @tab X @tab X
  @item IFF                       @tab   @tab X
      @tab Interchange File Format
  @item LATM                      @tab X @tab X
  @item LMLM4                     @tab   @tab X
      @tab Used by Linux Media Labs MPEG-4 PCI boards
 +@item LOAS                      @tab   @tab X
 +    @tab contains LATM multiplexed AAC audio
  @item LXF                       @tab   @tab X
      @tab VR native stream format, used by Leitch/Harris' video servers.
  @item Matroska                  @tab X @tab X
  @item MAXIS XA                  @tab   @tab X
      @tab Used in Sim City 3000; file extension .xa.
  @item MD Studio                 @tab   @tab X
 +@item Metal Gear Solid: The Twin Snakes @tab @tab X
  @item Mobotix .mxg              @tab   @tab X
  @item Monkey's Audio            @tab   @tab X
  @item Motion Pixels MVI         @tab   @tab X
  @item RTP                       @tab X @tab X
  @item RTSP                      @tab X @tab X
  @item SAP                       @tab X @tab X
 +@item SBG                       @tab   @tab X
  @item SDP                       @tab   @tab X
  @item Sega FILM/CPK             @tab   @tab X
      @tab Used in many Sega Saturn console games.
      @tab Multimedia format used by many games.
  @item SMJPEG                    @tab X @tab X
      @tab Used in certain Loki game ports.
 +@item Smush                     @tab   @tab X
 +    @tab Multimedia format used in some LucasArts games.
  @item Sony OpenMG (OMA)         @tab X @tab X
      @tab Audio format used in Sony Sonic Stage and Sony Vegas.
  @item Sony PlayStation STR      @tab   @tab X
  @item WAV                       @tab X @tab X
  @item WavPack                   @tab   @tab X
  @item WebM                      @tab X @tab X
 -@item Windows Televison (WTV)   @tab   @tab X
 +@item Windows Televison (WTV)   @tab X @tab X
  @item Wing Commander III movie  @tab   @tab X
      @tab Multimedia format used in Origin's Wing Commander III computer game.
  @item Westwood Studios audio    @tab   @tab X
      @tab Microsoft video container used in Xbox games.
  @item xWMA                      @tab   @tab X
      @tab Microsoft audio container used by XAudio 2.
 +@item eXtended BINary text (XBIN) @tab @tab X
  @item YUV4MPEG pipe             @tab X @tab X
  @item Psygnosis YOP             @tab   @tab X
  @item ZeroCodec Lossless Video  @tab   @tab X
  
  @section Image Formats
  
 -Libav can read and write images for each frame of a video sequence. The
 +FFmpeg can read and write images for each frame of a video sequence. The
  following image formats are supported:
  
  @multitable @columnfractions .4 .1 .1 .4
      @tab Microsoft BMP image
  @item DPX          @tab X @tab X
      @tab Digital Picture Exchange
 +@item EXR          @tab   @tab X
 +    @tab OpenEXR
  @item JPEG         @tab X @tab X
      @tab Progressive JPEG is not supported.
 -@item JPEG 2000    @tab   @tab E
 -    @tab decoding supported through external library libopenjpeg
 +@item JPEG 2000    @tab X @tab X
  @item JPEG-LS      @tab X @tab X
  @item LJPEG        @tab X @tab
      @tab Lossless JPEG
  @item PIC          @tab @tab X
      @tab Pictor/PC Paint
  @item PNG          @tab X @tab X
 -    @tab 2/4 bpp not supported yet
  @item PPM          @tab X @tab X
      @tab Portable PixelMap image
  @item PTX          @tab   @tab X
      @tab YUV, JPEG and some extension is not supported yet.
  @item Truevision Targa  @tab X @tab X
      @tab Targa (.TGA) image format
 -@item XBM  @tab X @tab
 +@item XBM  @tab X @tab X
      @tab X BitMap image format
  @item XWD  @tab X @tab X
      @tab X Window Dump image format
      @tab Creates video suitable to be played on a commodore 64 (multicolor mode).
  @item American Laser Games MM  @tab    @tab X
      @tab Used in games like Mad Dog McCree.
 -@item AMV Video              @tab     @tab  X
 +@item AMV Video              @tab  X  @tab  X
      @tab Used in Chinese MP3 players.
  @item ANSI/ASCII art         @tab     @tab  X
  @item Apple MJPEG-B          @tab     @tab  X
  @item Autodesk Animator Flic video  @tab     @tab  X
  @item Autodesk RLE           @tab     @tab  X
      @tab fourcc: AASC
 +@item Avid 1:1 10-bit RGB Packer  @tab  X  @tab  X
 +    @tab fourcc: AVrp
  @item AVS (Audio Video Standard) video  @tab     @tab  X
      @tab Video encoding used by the Creature Shock game.
 +@item AYUV                   @tab  X  @tab  X
 +    @tab Microsoft uncompressed packed 4:4:4:4
  @item Beam Software VB       @tab     @tab  X
  @item Bethesda VID video     @tab     @tab  X
      @tab Used in some games from Bethesda Softworks.
  @item Bink Video             @tab     @tab  X
  @item Bitmap Brothers JV video  @tab   @tab X
 +@item y41p Brooktree uncompressed 4:1:1 12-bit     @tab  X  @tab  X
  @item Brute Force & Ignorance   @tab   @tab X
      @tab Used in the game Flash Traffic: City of Angels.
  @item C93 video              @tab     @tab  X
  @item Creative YUV (CYUV)    @tab     @tab  X
  @item DFA                    @tab     @tab  X
      @tab Codec used in Chronomaster game.
 -@item Dirac                  @tab  E  @tab  E
 +@item Dirac                  @tab  E  @tab  X
      @tab supported through external library libschroedinger
  @item Deluxe Paint Animation @tab     @tab  X
  @item DNxHD                  @tab   X @tab  X
  @item Electronic Arts TGQ video  @tab     @tab  X
  @item Electronic Arts TQI video  @tab     @tab  X
  @item Escape 124             @tab     @tab  X
 +@item Escape 130             @tab     @tab  X
  @item FFmpeg video codec #1  @tab  X  @tab  X
 -    @tab experimental lossless codec (fourcc: FFV1)
 +    @tab lossless codec (fourcc: FFV1)
  @item Flash Screen Video v1  @tab  X  @tab  X
      @tab fourcc: FSV1
 -@item Flash Screen Video v2  @tab     @tab  X
 +@item Flash Screen Video v2  @tab  X  @tab  X
  @item Flash Video (FLV)      @tab  X  @tab  X
      @tab Sorenson H.263 used in Flash
  @item Forward Uncompressed   @tab     @tab  X
      @tab Used in the game Cyberia from Interplay.
  @item Interplay MVE video    @tab     @tab  X
      @tab Used in Interplay .MVE files.
 +@item J2K @tab  X  @tab  X
  @item Karl Morton's video codec  @tab     @tab  X
      @tab Codec used in Worms games.
  @item Kega Game Video (KGV1) @tab      @tab  X
  @item LCL (LossLess Codec Library) MSZH  @tab     @tab  X
  @item LCL (LossLess Codec Library) ZLIB  @tab  E  @tab  E
  @item LOCO                   @tab     @tab  X
 +@item LucasArts Smush        @tab     @tab  X
 +    @tab Used in LucasArts games.
  @item lossless MJPEG         @tab  X  @tab  X
+ @item Microsoft ATC Screen   @tab     @tab  X
+     @tab Also known as Microsoft Screen 3.
  @item Microsoft RLE          @tab     @tab  X
  @item Microsoft Screen 1     @tab     @tab  X
      @tab Also known as Windows Media Video V7 Screen.
      @tab fourcc: VP80, encoding supported through external library libvpx
  @item planar RGB             @tab     @tab  X
      @tab fourcc: 8BPS
 +@item Prores                 @tab     @tab  X
 +    @tab fourcc: apch,apcn,apcs,apco
  @item Q-team QPEG            @tab     @tab  X
      @tab fourccs: QPEG, Q1.0, Q1.1
  @item QuickTime 8BPS video   @tab     @tab  X
      @tab fourcc: 'smc '
  @item QuickTime video (RPZA) @tab     @tab  X
      @tab fourcc: rpza
 -@item R10K AJA Kona 10-bit RGB Codec     @tab     @tab  X
 -@item R210 Quicktime Uncompressed RGB 10-bit     @tab     @tab  X
 +@item R10K AJA Kona 10-bit RGB Codec     @tab  X  @tab  X
 +@item R210 Quicktime Uncompressed RGB 10-bit     @tab  X  @tab  X
  @item Raw Video              @tab  X  @tab  X
  @item RealVideo 1.0          @tab  X  @tab  X
  @item RealVideo 2.0          @tab  X  @tab  X
      @tab Codec used in DOS CD-ROM FlashBack game.
  @item Ut Video               @tab     @tab  X
  @item v210 QuickTime uncompressed 4:2:2 10-bit     @tab  X  @tab  X
 +@item v308 QuickTime uncompressed 4:4:4            @tab  X  @tab  X
 +@item v408 QuickTime uncompressed 4:4:4:4          @tab  X  @tab  X
  @item v410 QuickTime uncompressed 4:4:4 10-bit     @tab  X  @tab  X
  @item VBLE Lossless Codec    @tab     @tab  X
  @item VMware Screen Codec / VMware Video  @tab     @tab  X
  @item WMV7                   @tab  X  @tab  X
  @item YAMAHA SMAF            @tab  X  @tab  X
  @item Psygnosis YOP Video    @tab     @tab  X
 +@item yuv4                   @tab  X  @tab  X
 +    @tab libquicktime uncompressed packed 4:2:0
  @item ZLIB                   @tab  X  @tab  X
      @tab part of LCL, encoder experimental
  @item Zip Motion Blocks Video  @tab   X @tab  X
  @multitable @columnfractions .4 .1 .1 .4
  @item Name @tab Encoding @tab Decoding @tab Comments
  @item 8SVX audio             @tab     @tab  X
 +@item AAC+                   @tab  E  @tab  X
 +    @tab encoding supported through external library libaacplus
  @item AAC                    @tab  E  @tab  X
      @tab encoding supported through external library libfaac and libvo-aacenc
  @item AC-3                   @tab IX  @tab  X
  @item Atrac 3                @tab     @tab  X
  @item Bink Audio             @tab     @tab  X
      @tab Used in Bink and Smacker files in many games.
 +@item CELT                   @tab     @tab  E
 +    @tab decoding supported through external library libcelt
  @item Delphine Software International CIN audio  @tab     @tab  X
      @tab Codec used in Delphine Software International games.
  @item Discworld II BMV Audio @tab     @tab  X
  @item COOK                   @tab     @tab  X
      @tab All versions except 5.1 are supported.
 -@item DCA (DTS Coherent Acoustics)  @tab     @tab  X
 +@item DCA (DTS Coherent Acoustics)  @tab  X  @tab  X
  @item DPCM id RoQ            @tab  X  @tab  X
 -    @tab Used in Quake III, Jedi Knight 2, other computer games.
 +    @tab Used in Quake III, Jedi Knight 2 and other computer games.
  @item DPCM Interplay         @tab     @tab  X
      @tab Used in various Interplay computer games.
  @item DPCM Sierra Online     @tab     @tab  X
  @item DV audio               @tab     @tab  X
  @item Enhanced AC-3          @tab  X  @tab  X
  @item FLAC (Free Lossless Audio Codec)  @tab  X  @tab  IX
 +@item G.723.1                @tab X @tab X
 +@item G.729                  @tab     @tab  X
  @item GSM                    @tab  E  @tab  X
      @tab encoding supported through external library libgsm
  @item GSM Microsoft variant  @tab  E  @tab  X
      @tab Used in Sierra VMD files.
  @item Smacker audio          @tab     @tab  X
  @item SMPTE 302M AES3 audio  @tab     @tab  X
 +@item Sonic                  @tab  X  @tab  X
 +    @tab experimental codec
 +@item Sonic lossless         @tab  X  @tab  X
 +    @tab experimental codec
  @item Speex                  @tab  E  @tab  E
      @tab supported through external library libspeex
  @item True Audio (TTA)       @tab     @tab  X
  @item TrueHD                 @tab     @tab  X
      @tab Used in HD-DVD and Blu-Ray discs.
  @item TwinVQ (VQF flavor)    @tab     @tab  X
 +@item VIMA                   @tab     @tab  X
 +    @tab Used in LucasArts SMUSH animations.
  @item Vorbis                 @tab  E  @tab  X
      @tab A native but very primitive encoder exists.
  @item WavPack                @tab     @tab  X
@@@ -861,12 -811,8 +863,12 @@@ performance on systems without hardwar
  @item SSA/ASS      @tab X @tab X @tab X @tab X
  @item DVB          @tab X @tab X @tab X @tab X
  @item DVD          @tab X @tab X @tab X @tab X
 +@item JACOsub      @tab X @tab X @tab   @tab X
 +@item MicroDVD     @tab X @tab X @tab   @tab X
  @item PGS          @tab   @tab   @tab   @tab X
 -@item SubRip (SRT) @tab X @tab X @tab   @tab X
 +@item RealText     @tab   @tab X @tab   @tab X
 +@item SAMI         @tab   @tab X @tab   @tab X
 +@item SubRip (SRT) @tab X @tab X @tab X @tab X
  @item XSUB         @tab   @tab   @tab X @tab X
  @end multitable
  
  @item RTMP         @tab X
  @item RTMPE        @tab E
  @item RTMPS        @tab E
 -@item RTMPT        @tab X
 +@item RTMPT        @tab E
  @item RTMPTE       @tab E
  @item RTP          @tab X
  @item SCTP         @tab X
  
  @code{X} means that input/output is supported.
  
 +@section Timecode
 +
 +@multitable @columnfractions .4 .1 .1
 +@item Codec/format      @tab Read   @tab Write
 +@item AVI               @tab X      @tab X
 +@item DV                @tab X      @tab X
 +@item GXF               @tab X      @tab X
 +@item MOV               @tab X      @tab X
 +@item MPEG1/2           @tab X      @tab X
 +@item MXF               @tab X      @tab X
 +@end multitable
 +
  @bye
diff --combined libavcodec/Makefile
@@@ -1,5 -1,3 +1,5 @@@
 +include $(SUBDIR)../config.mak
 +
  NAME = avcodec
  FFLIBS = avutil
  
@@@ -25,7 -23,6 +25,7 @@@ OBJS = allcodecs.
         options.o                                                        \
         parser.o                                                         \
         raw.o                                                            \
 +       rawdec.o                                                         \
         resample.o                                                       \
         resample2.o                                                      \
         simple_idct.o                                                    \
  # parts needed for many different codecs
  OBJS-$(CONFIG_AANDCT)                  += aandcttab.o
  OBJS-$(CONFIG_AC3DSP)                  += ac3dsp.o
 +OBJS-$(CONFIG_CRYSTALHD)               += crystalhd.o
  OBJS-$(CONFIG_ENCODERS)                += faandct.o jfdctfst.o jfdctint.o
  OBJS-$(CONFIG_DCT)                     += dct.o dct32_fixed.o dct32_float.o
 -OBJS-$(CONFIG_DWT)                     += dwt.o
 +OBJS-$(CONFIG_DWT)                     += dwt.o snow.o
  OBJS-$(CONFIG_DXVA2)                   += dxva2.o
  FFT-OBJS-$(CONFIG_HARDCODED_TABLES)    += cos_tables.o cos_fixed_tables.o
  OBJS-$(CONFIG_FFT)                     += avfft.o fft_fixed.o fft_float.o \
@@@ -88,14 -84,10 +88,14 @@@ OBJS-$(CONFIG_AMRWB_DECODER)           
                                            acelp_vectors.o             \
                                            acelp_pitch_delay.o lsp.o
  OBJS-$(CONFIG_AMV_DECODER)             += sp5xdec.o mjpegdec.o mjpeg.o
 +OBJS-$(CONFIG_AMV_ENCODER)             += mjpegenc.o mjpeg.o           \
 +                                          mpegvideo_enc.o motion_est.o \
 +                                          ratecontrol.o mpeg12data.o   \
 +                                          mpegvideo.o
  OBJS-$(CONFIG_ANM_DECODER)             += anm.o
  OBJS-$(CONFIG_ANSI_DECODER)            += ansi.o cga_data.o
  OBJS-$(CONFIG_APE_DECODER)             += apedec.o
 -OBJS-$(CONFIG_ASS_DECODER)             += assdec.o ass.o
 +OBJS-$(CONFIG_ASS_DECODER)             += assdec.o ass.o ass_split.o
  OBJS-$(CONFIG_ASS_ENCODER)             += assenc.o ass.o
  OBJS-$(CONFIG_ASV1_DECODER)            += asv1.o mpeg12data.o
  OBJS-$(CONFIG_ASV1_ENCODER)            += asv1.o mpeg12data.o
@@@ -105,19 -97,12 +105,19 @@@ OBJS-$(CONFIG_ATRAC1_DECODER)          
  OBJS-$(CONFIG_ATRAC3_DECODER)          += atrac3.o atrac.o
  OBJS-$(CONFIG_AURA_DECODER)            += cyuv.o
  OBJS-$(CONFIG_AURA2_DECODER)           += aura.o
 +OBJS-$(CONFIG_AVRP_DECODER)            += r210dec.o
 +OBJS-$(CONFIG_AVRP_ENCODER)            += r210enc.o
  OBJS-$(CONFIG_AVS_DECODER)             += avs.o
 +OBJS-$(CONFIG_AVUI_DECODER)            += avuidec.o
 +OBJS-$(CONFIG_AVUI_ENCODER)            += avuienc.o
 +OBJS-$(CONFIG_AYUV_DECODER)            += v408dec.o
 +OBJS-$(CONFIG_AYUV_ENCODER)            += v408enc.o
  OBJS-$(CONFIG_BETHSOFTVID_DECODER)     += bethsoftvideo.o
  OBJS-$(CONFIG_BFI_DECODER)             += bfi.o
  OBJS-$(CONFIG_BINK_DECODER)            += bink.o binkdsp.o
  OBJS-$(CONFIG_BINKAUDIO_DCT_DECODER)   += binkaudio.o wma.o wma_common.o
  OBJS-$(CONFIG_BINKAUDIO_RDFT_DECODER)  += binkaudio.o wma.o wma_common.o
 +OBJS-$(CONFIG_BINTEXT_DECODER)         += bintext.o cga_data.o
  OBJS-$(CONFIG_BMP_DECODER)             += bmp.o msrledec.o
  OBJS-$(CONFIG_BMP_ENCODER)             += bmpenc.o
  OBJS-$(CONFIG_BMV_VIDEO_DECODER)       += bmv.o
@@@ -135,9 -120,6 +135,9 @@@ OBJS-$(CONFIG_CSCD_DECODER)            
  OBJS-$(CONFIG_CYUV_DECODER)            += cyuv.o
  OBJS-$(CONFIG_DCA_DECODER)             += dca.o synth_filter.o dcadsp.o \
                                            dca_parser.o
 +OBJS-$(CONFIG_DCA_ENCODER)             += dcaenc.o
 +OBJS-$(CONFIG_DIRAC_DECODER)           += diracdec.o dirac.o diracdsp.o \
 +                                          dirac_arith.o mpeg12data.o dwt.o
  OBJS-$(CONFIG_DFA_DECODER)             += dfa.o
  OBJS-$(CONFIG_DNXHD_DECODER)           += dnxhddec.o dnxhddata.o
  OBJS-$(CONFIG_DNXHD_ENCODER)           += dnxhdenc.o dnxhddata.o       \
@@@ -172,34 -154,26 +172,34 @@@ OBJS-$(CONFIG_EIGHTBPS_DECODER)        
  OBJS-$(CONFIG_EIGHTSVX_EXP_DECODER)    += 8svx.o
  OBJS-$(CONFIG_EIGHTSVX_FIB_DECODER)    += 8svx.o
  OBJS-$(CONFIG_ESCAPE124_DECODER)       += escape124.o
 +OBJS-$(CONFIG_ESCAPE130_DECODER)       += escape130.o
 +OBJS-$(CONFIG_EXR_DECODER)             += exr.o
  OBJS-$(CONFIG_FFV1_DECODER)            += ffv1.o rangecoder.o
  OBJS-$(CONFIG_FFV1_ENCODER)            += ffv1.o rangecoder.o
  OBJS-$(CONFIG_FFVHUFF_DECODER)         += huffyuv.o
  OBJS-$(CONFIG_FFVHUFF_ENCODER)         += huffyuv.o
 +OBJS-$(CONFIG_FFWAVESYNTH_DECODER)     += ffwavesynth.o
  OBJS-$(CONFIG_FLAC_DECODER)            += flacdec.o flacdata.o flac.o
 -OBJS-$(CONFIG_FLAC_ENCODER)            += flacenc.o flacdata.o flac.o
 +OBJS-$(CONFIG_FLAC_ENCODER)            += flacenc.o flacdata.o flac.o vorbis_data.o
  OBJS-$(CONFIG_FLASHSV_DECODER)         += flashsv.o
  OBJS-$(CONFIG_FLASHSV_ENCODER)         += flashsvenc.o
 +OBJS-$(CONFIG_FLASHSV2_ENCODER)        += flashsv2enc.o
  OBJS-$(CONFIG_FLASHSV2_DECODER)        += flashsv.o
  OBJS-$(CONFIG_FLIC_DECODER)            += flicvideo.o
  OBJS-$(CONFIG_FOURXM_DECODER)          += 4xm.o
  OBJS-$(CONFIG_FRAPS_DECODER)           += fraps.o
  OBJS-$(CONFIG_FRWU_DECODER)            += frwu.o
 +OBJS-$(CONFIG_G723_1_DECODER)          += g723_1.o acelp_vectors.o \
 +                                          celp_filters.o celp_math.o
 +OBJS-$(CONFIG_G723_1_ENCODER)          += g723_1.o acelp_vectors.o celp_math.o
 +OBJS-$(CONFIG_G729_DECODER)            += g729dec.o lsp.o celp_math.o acelp_filters.o acelp_pitch_delay.o acelp_vectors.o g729postfilter.o
  OBJS-$(CONFIG_GIF_DECODER)             += gifdec.o lzw.o
  OBJS-$(CONFIG_GIF_ENCODER)             += gif.o lzwenc.o
  OBJS-$(CONFIG_GSM_DECODER)             += gsmdec.o gsmdec_data.o msgsmdec.o
  OBJS-$(CONFIG_GSM_MS_DECODER)          += gsmdec.o gsmdec_data.o msgsmdec.o
 -OBJS-$(CONFIG_H261_DECODER)            += h261dec.o h261.o \
 +OBJS-$(CONFIG_H261_DECODER)            += h261dec.o h261.o h261data.o  \
                                            mpegvideo.o error_resilience.o
 -OBJS-$(CONFIG_H261_ENCODER)            += h261enc.o h261.o             \
 +OBJS-$(CONFIG_H261_ENCODER)            += h261enc.o h261.o h261data.o  \
                                            mpegvideo_enc.o motion_est.o \
                                            ratecontrol.o mpeg12data.o   \
                                            mpegvideo.o
@@@ -225,7 -199,6 +225,7 @@@ OBJS-$(CONFIG_HUFFYUV_DECODER)         
  OBJS-$(CONFIG_HUFFYUV_ENCODER)         += huffyuv.o
  OBJS-$(CONFIG_IAC_DECODER)             += imc.o
  OBJS-$(CONFIG_IDCIN_DECODER)           += idcinvideo.o
 +OBJS-$(CONFIG_IDF_DECODER)             += bintext.o cga_data.o
  OBJS-$(CONFIG_IFF_BYTERUN1_DECODER)    += iff.o
  OBJS-$(CONFIG_IFF_ILBM_DECODER)        += iff.o
  OBJS-$(CONFIG_IMC_DECODER)             += imc.o
@@@ -235,9 -208,6 +235,9 @@@ OBJS-$(CONFIG_INDEO4_DECODER)          
  OBJS-$(CONFIG_INDEO5_DECODER)          += indeo5.o ivi_common.o ivi_dsp.o
  OBJS-$(CONFIG_INTERPLAY_DPCM_DECODER)  += dpcm.o
  OBJS-$(CONFIG_INTERPLAY_VIDEO_DECODER) += interplayvideo.o
 +OBJS-$(CONFIG_JACOSUB_DECODER)         += jacosubdec.o ass.o
 +OBJS-$(CONFIG_JPEG2000_DECODER)        += j2kdec.o mqcdec.o mqc.o j2k.o j2k_dwt.o
 +OBJS-$(CONFIG_JPEG2000_ENCODER)        += j2kenc.o mqcenc.o mqc.o j2k.o j2k_dwt.o
  OBJS-$(CONFIG_JPEGLS_DECODER)          += jpeglsdec.o jpegls.o \
                                            mjpegdec.o mjpeg.o
  OBJS-$(CONFIG_JPEGLS_ENCODER)          += jpeglsenc.o jpegls.o
@@@ -254,7 -224,6 +254,7 @@@ OBJS-$(CONFIG_MACE3_DECODER)           
  OBJS-$(CONFIG_MACE6_DECODER)           += mace.o
  OBJS-$(CONFIG_MDEC_DECODER)            += mdec.o mpeg12.o mpeg12data.o \
                                            mpegvideo.o error_resilience.o
 +OBJS-$(CONFIG_MICRODVD_DECODER)        += microdvddec.o ass.o
  OBJS-$(CONFIG_MIMIC_DECODER)           += mimic.o
  OBJS-$(CONFIG_MJPEG_DECODER)           += mjpegdec.o mjpeg.o
  OBJS-$(CONFIG_MJPEG_ENCODER)           += mjpegenc.o mjpeg.o           \
@@@ -295,13 -264,10 +295,13 @@@ OBJS-$(CONFIG_MPC7_DECODER)            
  OBJS-$(CONFIG_MPC8_DECODER)            += mpc8.o mpc.o mpegaudiodec.o      \
                                            mpegaudiodecheader.o mpegaudio.o \
                                            mpegaudiodata.o
 +OBJS-$(CONFIG_MPEGVIDEO_DECODER)       += mpeg12.o mpeg12data.o \
 +                                          mpegvideo.o error_resilience.o
  OBJS-$(CONFIG_MPEG_XVMC_DECODER)       += mpegvideo_xvmc.o
  OBJS-$(CONFIG_MPEG1VIDEO_DECODER)      += mpeg12.o mpeg12data.o \
                                            mpegvideo.o error_resilience.o
  OBJS-$(CONFIG_MPEG1VIDEO_ENCODER)      += mpeg12enc.o mpegvideo_enc.o \
 +                                          timecode.o                  \
                                            motion_est.o ratecontrol.o  \
                                            mpeg12.o mpeg12data.o       \
                                            mpegvideo.o error_resilience.o
@@@ -310,7 -276,6 +310,7 @@@ OBJS-$(CONFIG_MPEG2_VAAPI_HWACCEL)     
  OBJS-$(CONFIG_MPEG2VIDEO_DECODER)      += mpeg12.o mpeg12data.o \
                                            mpegvideo.o error_resilience.o
  OBJS-$(CONFIG_MPEG2VIDEO_ENCODER)      += mpeg12enc.o mpegvideo_enc.o \
 +                                          timecode.o                  \
                                            motion_est.o ratecontrol.o  \
                                            mpeg12.o mpeg12data.o       \
                                            mpegvideo.o error_resilience.o
@@@ -327,9 -292,9 +327,10 @@@ OBJS-$(CONFIG_MSMPEG4V3_ENCODER)       
                                            h263dec.o h263.o ituh263dec.o        \
                                            mpeg4videodec.o
  OBJS-$(CONFIG_MSRLE_DECODER)           += msrle.o msrledec.o
+ OBJS-$(CONFIG_MSA1_DECODER)            += mss3.o
  OBJS-$(CONFIG_MSS1_DECODER)            += mss1.o
  OBJS-$(CONFIG_MSVIDEO1_DECODER)        += msvideo1.o
 +OBJS-$(CONFIG_MSVIDEO1_ENCODER)        += msvideo1enc.o elbg.o
  OBJS-$(CONFIG_MSZH_DECODER)            += lcldec.o
  OBJS-$(CONFIG_MXPEG_DECODER)           += mxpegdec.o mjpegdec.o mjpeg.o
  OBJS-$(CONFIG_NELLYMOSER_DECODER)      += nellymoserdec.o nellymoser.o
@@@ -352,11 -317,8 +353,11 @@@ OBJS-$(CONFIG_PNG_DECODER)             
  OBJS-$(CONFIG_PNG_ENCODER)             += png.o pngenc.o
  OBJS-$(CONFIG_PPM_DECODER)             += pnmdec.o pnm.o
  OBJS-$(CONFIG_PPM_ENCODER)             += pnmenc.o pnm.o
 -OBJS-$(CONFIG_PRORES_DECODER)          += proresdec.o proresdata.o proresdsp.o
 -OBJS-$(CONFIG_PRORES_ENCODER)          += proresenc.o proresdata.o proresdsp.o
 +OBJS-$(CONFIG_PRORES_DECODER)          += proresdec2.o proresdsp.o
 +OBJS-$(CONFIG_PRORES_LGPL_DECODER)     += proresdec_lgpl.o proresdsp.o proresdata.o
 +OBJS-$(CONFIG_PRORES_ENCODER)          += proresenc_anatoliy.o
 +OBJS-$(CONFIG_PRORES_ANATOLIY_ENCODER) += proresenc_anatoliy.o
 +OBJS-$(CONFIG_PRORES_KOSTYA_ENCODER)   += proresenc_kostya.o proresdata.o proresdsp.o
  OBJS-$(CONFIG_PTX_DECODER)             += ptx.o
  OBJS-$(CONFIG_QCELP_DECODER)           += qcelpdec.o celp_math.o         \
                                            celp_filters.o acelp_vectors.o \
@@@ -369,9 -331,7 +370,9 @@@ OBJS-$(CONFIG_QPEG_DECODER)            
  OBJS-$(CONFIG_QTRLE_DECODER)           += qtrle.o
  OBJS-$(CONFIG_QTRLE_ENCODER)           += qtrleenc.o
  OBJS-$(CONFIG_R10K_DECODER)            += r210dec.o
 +OBJS-$(CONFIG_R10K_ENCODER)            += r210enc.o
  OBJS-$(CONFIG_R210_DECODER)            += r210dec.o
 +OBJS-$(CONFIG_R210_ENCODER)            += r210enc.o
  OBJS-$(CONFIG_RA_144_DECODER)          += ra144dec.o ra144.o celp_filters.o
  OBJS-$(CONFIG_RA_144_ENCODER)          += ra144enc.o ra144.o celp_filters.o \
                                            audio_frame_queue.o
@@@ -379,7 -339,6 +380,7 @@@ OBJS-$(CONFIG_RA_288_DECODER)          
  OBJS-$(CONFIG_RALF_DECODER)            += ralf.o
  OBJS-$(CONFIG_RAWVIDEO_DECODER)        += rawdec.o
  OBJS-$(CONFIG_RAWVIDEO_ENCODER)        += rawenc.o
 +OBJS-$(CONFIG_REALTEXT_DECODER)        += realtextdec.o ass.o
  OBJS-$(CONFIG_RL2_DECODER)             += rl2.o
  OBJS-$(CONFIG_ROQ_DECODER)             += roqvideodec.o roqvideo.o
  OBJS-$(CONFIG_ROQ_ENCODER)             += roqvideoenc.o roqvideo.o elbg.o
@@@ -394,9 -353,7 +395,9 @@@ OBJS-$(CONFIG_RV30_DECODER)            
                                            mpegvideo.o error_resilience.o
  OBJS-$(CONFIG_RV40_DECODER)            += rv40.o rv34.o rv34dsp.o rv40dsp.o \
                                            mpegvideo.o error_resilience.o
 +OBJS-$(CONFIG_SAMI_DECODER)            += samidec.o ass.o
  OBJS-$(CONFIG_S302M_DECODER)           += s302m.o
 +OBJS-$(CONFIG_SANM_DECODER)            += sanm.o
  OBJS-$(CONFIG_SGI_DECODER)             += sgidec.o
  OBJS-$(CONFIG_SGI_ENCODER)             += sgienc.o rle.o
  OBJS-$(CONFIG_SHORTEN_DECODER)         += shorten.o
@@@ -414,12 -371,8 +415,12 @@@ OBJS-$(CONFIG_SNOW_ENCODER)            
                                            error_resilience.o ituh263enc.o  \
                                            mpegvideo_enc.o mpeg12data.o
  OBJS-$(CONFIG_SOL_DPCM_DECODER)        += dpcm.o
 +OBJS-$(CONFIG_SONIC_DECODER)           += sonic.o
 +OBJS-$(CONFIG_SONIC_ENCODER)           += sonic.o
 +OBJS-$(CONFIG_SONIC_LS_ENCODER)        += sonic.o
  OBJS-$(CONFIG_SP5X_DECODER)            += sp5xdec.o mjpegdec.o mjpeg.o
  OBJS-$(CONFIG_SRT_DECODER)             += srtdec.o ass.o
 +OBJS-$(CONFIG_SRT_ENCODER)             += srtenc.o ass_split.o
  OBJS-$(CONFIG_SUNRAST_DECODER)         += sunrast.o
  OBJS-$(CONFIG_SUNRAST_ENCODER)         += sunrastenc.o
  OBJS-$(CONFIG_SVQ1_DECODER)            += svq1dec.o svq1.o h263.o \
@@@ -443,7 -396,6 +444,7 @@@ OBJS-$(CONFIG_TIERTEXSEQVIDEO_DECODER) 
  OBJS-$(CONFIG_TIFF_DECODER)            += tiff.o lzw.o faxcompr.o
  OBJS-$(CONFIG_TIFF_ENCODER)            += tiffenc.o rle.o lzwenc.o
  OBJS-$(CONFIG_TMV_DECODER)             += tmv.o cga_data.o
 +OBJS-$(CONFIG_TRUEHD_DECODER)          += mlpdec.o mlpdsp.o
  OBJS-$(CONFIG_TRUEMOTION1_DECODER)     += truemotion1.o
  OBJS-$(CONFIG_TRUEMOTION2_DECODER)     += truemotion2.o
  OBJS-$(CONFIG_TRUESPEECH_DECODER)      += truespeech.o
@@@ -455,10 -407,6 +456,10 @@@ OBJS-$(CONFIG_ULTI_DECODER)            
  OBJS-$(CONFIG_UTVIDEO_DECODER)         += utvideo.o
  OBJS-$(CONFIG_V210_DECODER)            += v210dec.o
  OBJS-$(CONFIG_V210_ENCODER)            += v210enc.o
 +OBJS-$(CONFIG_V308_DECODER)            += v308dec.o
 +OBJS-$(CONFIG_V308_ENCODER)            += v308enc.o
 +OBJS-$(CONFIG_V408_DECODER)            += v408dec.o
 +OBJS-$(CONFIG_V408_ENCODER)            += v408enc.o
  OBJS-$(CONFIG_V410_DECODER)            += v410dec.o
  OBJS-$(CONFIG_V410_ENCODER)            += v410enc.o
  OBJS-$(CONFIG_V210X_DECODER)           += v210x.o
@@@ -507,19 -455,13 +508,19 @@@ OBJS-$(CONFIG_WS_SND1_DECODER)         
  OBJS-$(CONFIG_XAN_DPCM_DECODER)        += dpcm.o
  OBJS-$(CONFIG_XAN_WC3_DECODER)         += xan.o
  OBJS-$(CONFIG_XAN_WC4_DECODER)         += xxan.o
 +OBJS-$(CONFIG_XBIN_DECODER)            += bintext.o cga_data.o
 +OBJS-$(CONFIG_XBM_DECODER)             += xbmdec.o
  OBJS-$(CONFIG_XBM_ENCODER)             += xbmenc.o
  OBJS-$(CONFIG_XL_DECODER)              += xl.o
  OBJS-$(CONFIG_XSUB_DECODER)            += xsubdec.o
  OBJS-$(CONFIG_XSUB_ENCODER)            += xsubenc.o
  OBJS-$(CONFIG_XWD_DECODER)             += xwddec.o
  OBJS-$(CONFIG_XWD_ENCODER)             += xwdenc.o
 +OBJS-$(CONFIG_Y41P_DECODER)            += y41pdec.o
 +OBJS-$(CONFIG_Y41P_ENCODER)            += y41penc.o
  OBJS-$(CONFIG_YOP_DECODER)             += yop.o
 +OBJS-$(CONFIG_YUV4_DECODER)            += yuv4dec.o
 +OBJS-$(CONFIG_YUV4_ENCODER)            += yuv4enc.o
  OBJS-$(CONFIG_ZEROCODEC_DECODER)       += zerocodec.o
  OBJS-$(CONFIG_ZLIB_DECODER)            += lcldec.o
  OBJS-$(CONFIG_ZLIB_ENCODER)            += lclenc.o
@@@ -615,50 -557,42 +616,50 @@@ OBJS-$(CONFIG_ADPCM_THP_DECODER
  OBJS-$(CONFIG_ADPCM_XA_DECODER)           += adpcm.o adpcm_data.o
  OBJS-$(CONFIG_ADPCM_YAMAHA_DECODER)       += adpcm.o adpcm_data.o
  OBJS-$(CONFIG_ADPCM_YAMAHA_ENCODER)       += adpcmenc.o adpcm_data.o
 +OBJS-$(CONFIG_VIMA_DECODER)               += vima.o adpcm_data.o
  
  # libavformat dependencies
  OBJS-$(CONFIG_ADTS_MUXER)              += mpeg4audio.o
  OBJS-$(CONFIG_ADX_DEMUXER)             += adx.o
  OBJS-$(CONFIG_CAF_DEMUXER)             += mpeg4audio.o mpegaudiodata.o
  OBJS-$(CONFIG_DV_DEMUXER)              += dv_profile.o
 -OBJS-$(CONFIG_DV_MUXER)                += dv_profile.o
 -OBJS-$(CONFIG_FLAC_DEMUXER)            += flacdec.o flacdata.o flac.o
 -OBJS-$(CONFIG_FLAC_MUXER)              += flacdec.o flacdata.o flac.o
 +OBJS-$(CONFIG_DV_MUXER)                += dv_profile.o timecode.o
 +OBJS-$(CONFIG_FLAC_DEMUXER)            += flacdec.o flacdata.o flac.o vorbis_data.o \
 +                                          vorbis_parser.o xiph.o
 +OBJS-$(CONFIG_FLAC_MUXER)              += flacdec.o flacdata.o flac.o vorbis_data.o
  OBJS-$(CONFIG_FLV_DEMUXER)             += mpeg4audio.o
  OBJS-$(CONFIG_GXF_DEMUXER)             += mpeg12data.o
  OBJS-$(CONFIG_IFF_DEMUXER)             += iff.o
  OBJS-$(CONFIG_LATM_MUXER)              += mpeg4audio.o
 -OBJS-$(CONFIG_MATROSKA_AUDIO_MUXER)    += xiph.o mpeg4audio.o \
 +OBJS-$(CONFIG_MATROSKA_AUDIO_MUXER)    += xiph.o mpeg4audio.o vorbis_data.o \
                                            flacdec.o flacdata.o flac.o
  OBJS-$(CONFIG_MATROSKA_DEMUXER)        += mpeg4audio.o mpegaudiodata.o
  OBJS-$(CONFIG_MATROSKA_MUXER)          += xiph.o mpeg4audio.o \
                                            flacdec.o flacdata.o flac.o \
 -                                          mpegaudiodata.o
 +                                          mpegaudiodata.o vorbis_data.o
 +OBJS-$(CONFIG_MP2_MUXER)               += mpegaudiodata.o mpegaudiodecheader.o
  OBJS-$(CONFIG_MP3_MUXER)               += mpegaudiodata.o mpegaudiodecheader.o
 -OBJS-$(CONFIG_MOV_DEMUXER)             += mpeg4audio.o mpegaudiodata.o ac3tab.o
 +OBJS-$(CONFIG_MOV_DEMUXER)             += mpeg4audio.o mpegaudiodata.o ac3tab.o timecode.o
  OBJS-$(CONFIG_MOV_MUXER)               += mpeg4audio.o mpegaudiodata.o
  OBJS-$(CONFIG_MPEGTS_MUXER)            += mpegvideo.o mpeg4audio.o
  OBJS-$(CONFIG_MPEGTS_DEMUXER)          += mpeg4audio.o mpegaudiodata.o
 +OBJS-$(CONFIG_MXF_MUXER)               += timecode.o
  OBJS-$(CONFIG_NUT_MUXER)               += mpegaudiodata.o
  OBJS-$(CONFIG_OGG_DEMUXER)             += flacdec.o flacdata.o flac.o \
 -                                          dirac.o mpeg12data.o vorbis_parser.o
 -OBJS-$(CONFIG_OGG_MUXER)               += xiph.o flacdec.o flacdata.o flac.o
 +                                          dirac.o mpeg12data.o vorbis_parser.o \
 +                                          xiph.o vorbis_data.o
 +OBJS-$(CONFIG_OGG_MUXER)               += xiph.o flacdec.o flacdata.o flac.o \
 +                                          vorbis_data.o
  OBJS-$(CONFIG_RTP_MUXER)               += mpeg4audio.o mpegvideo.o xiph.o
  OBJS-$(CONFIG_SPDIF_DEMUXER)           += aacadtsdec.o mpeg4audio.o
  OBJS-$(CONFIG_WEBM_MUXER)              += xiph.o mpeg4audio.o \
                                            flacdec.o flacdata.o flac.o \
 -                                          mpegaudiodata.o
 +                                          mpegaudiodata.o vorbis_data.o
  OBJS-$(CONFIG_WTV_DEMUXER)             += mpeg4audio.o mpegaudiodata.o
  
  # external codec libraries
 +OBJS-$(CONFIG_LIBAACPLUS_ENCODER)         += libaacplus.o
 +OBJS-$(CONFIG_LIBCELT_DECODER)            += libcelt_dec.o
  OBJS-$(CONFIG_LIBFAAC_ENCODER)            += libfaac.o audio_frame_queue.o
  OBJS-$(CONFIG_LIBGSM_DECODER)             += libgsm.o
  OBJS-$(CONFIG_LIBGSM_ENCODER)             += libgsm.o
@@@ -668,29 -602,21 +669,29 @@@ OBJS-$(CONFIG_LIBILBC_DECODER
  OBJS-$(CONFIG_LIBILBC_ENCODER)            += libilbc.o
  OBJS-$(CONFIG_LIBMP3LAME_ENCODER)         += libmp3lame.o mpegaudiodecheader.o \
                                               audio_frame_queue.o
 -OBJS-$(CONFIG_LIBOPENCORE_AMRNB_DECODER)  += libopencore-amr.o
 -OBJS-$(CONFIG_LIBOPENCORE_AMRNB_ENCODER)  += libopencore-amr.o
 +OBJS-$(CONFIG_LIBOPENCORE_AMRNB_DECODER)  += libopencore-amr.o \
 +                                             audio_frame_queue.o
 +OBJS-$(CONFIG_LIBOPENCORE_AMRNB_ENCODER)  += libopencore-amr.o \
 +                                             audio_frame_queue.o
  OBJS-$(CONFIG_LIBOPENCORE_AMRWB_DECODER)  += libopencore-amr.o
 -OBJS-$(CONFIG_LIBOPENJPEG_DECODER)        += libopenjpeg.o
 +OBJS-$(CONFIG_LIBOPENJPEG_DECODER)        += libopenjpegdec.o
 +OBJS-$(CONFIG_LIBOPENJPEG_ENCODER)        += libopenjpegenc.o
  OBJS-$(CONFIG_LIBSCHROEDINGER_DECODER)    += libschroedingerdec.o \
                                               libschroedinger.o
  OBJS-$(CONFIG_LIBSCHROEDINGER_ENCODER)    += libschroedingerenc.o \
                                               libschroedinger.o
  OBJS-$(CONFIG_LIBSPEEX_DECODER)           += libspeexdec.o
  OBJS-$(CONFIG_LIBSPEEX_ENCODER)           += libspeexenc.o audio_frame_queue.o
 +OBJS-$(CONFIG_LIBSTAGEFRIGHT_H264_DECODER)+= libstagefright.o
  OBJS-$(CONFIG_LIBTHEORA_ENCODER)          += libtheoraenc.o
 -OBJS-$(CONFIG_LIBVO_AACENC_ENCODER)       += libvo-aacenc.o mpeg4audio.o
 +OBJS-$(CONFIG_LIBUTVIDEO_DECODER)         += libutvideodec.o
 +OBJS-$(CONFIG_LIBUTVIDEO_ENCODER)         += libutvideoenc.o
 +OBJS-$(CONFIG_LIBVO_AACENC_ENCODER)       += libvo-aacenc.o mpeg4audio.o \
 +                                             audio_frame_queue.o
  OBJS-$(CONFIG_LIBVO_AMRWBENC_ENCODER)     += libvo-amrwbenc.o
 -OBJS-$(CONFIG_LIBVORBIS_ENCODER)          += libvorbis.o audio_frame_queue.o \
 -                                             vorbis_data.o vorbis_parser.o
 +OBJS-$(CONFIG_LIBVORBIS_DECODER)          += libvorbisdec.o
 +OBJS-$(CONFIG_LIBVORBIS_ENCODER)          += libvorbisenc.o audio_frame_queue.o \
 +                                             vorbis_data.o vorbis_parser.o xiph.o
  OBJS-$(CONFIG_LIBVPX_DECODER)             += libvpxdec.o
  OBJS-$(CONFIG_LIBVPX_ENCODER)             += libvpxenc.o
  OBJS-$(CONFIG_LIBX264_ENCODER)            += libx264.o
@@@ -710,8 -636,7 +711,8 @@@ OBJS-$(CONFIG_DIRAC_PARSER)            
  OBJS-$(CONFIG_DNXHD_PARSER)            += dnxhd_parser.o
  OBJS-$(CONFIG_DVBSUB_PARSER)           += dvbsub_parser.o
  OBJS-$(CONFIG_DVDSUB_PARSER)           += dvdsub_parser.o
 -OBJS-$(CONFIG_FLAC_PARSER)             += flac_parser.o flacdata.o flac.o
 +OBJS-$(CONFIG_FLAC_PARSER)             += flac_parser.o flacdata.o flac.o \
 +                                          vorbis_data.o
  OBJS-$(CONFIG_GSM_PARSER)              += gsm_parser.o
  OBJS-$(CONFIG_H261_PARSER)             += h261_parser.o
  OBJS-$(CONFIG_H263_PARSER)             += h263_parser.o
@@@ -728,7 -653,6 +729,7 @@@ OBJS-$(CONFIG_MPEG4VIDEO_PARSER)       
                                            mpegvideo.o error_resilience.o \
                                            mpeg4videodec.o mpeg4video.o \
                                            ituh263dec.o h263dec.o
 +OBJS-$(CONFIG_PNG_PARSER)              += png_parser.o
  OBJS-$(CONFIG_MPEGAUDIO_PARSER)        += mpegaudio_parser.o \
                                            mpegaudiodecheader.o mpegaudiodata.o
  OBJS-$(CONFIG_MPEGVIDEO_PARSER)        += mpegvideo_parser.o    \
@@@ -762,9 -686,8 +763,9 @@@ OBJS-$(CONFIG_REMOVE_EXTRADATA_BSF
  OBJS-$(CONFIG_TEXT2MOVSUB_BSF)            += movsub_bsf.o
  
  # thread libraries
 -OBJS-$(HAVE_PTHREADS)                  += pthread.o
 -OBJS-$(HAVE_W32THREADS)                += pthread.o
 +OBJS-$(HAVE_PTHREADS)                  += pthread.o frame_thread_encoder.o
 +OBJS-$(HAVE_W32THREADS)                += pthread.o frame_thread_encoder.o
 +OBJS-$(HAVE_OS2THREADS)                += pthread.o frame_thread_encoder.o
  
  # inverse.o contains the ff_inverse table definition, which is used by
  # the FASTDIV macro (from libavutil); since referencing the external
@@@ -775,21 -698,20 +776,21 @@@ OBJS-$(!CONFIG_SMALL)                  
  SKIPHEADERS                            += %_tablegen.h                  \
                                            %_tables.h                    \
                                            aac_tablegen_decl.h           \
 +                                          codec_names.h                 \
                                            fft-internal.h                \
                                            tableprint.h                  \
                                            $(ARCH)/vp56_arith.h          \
  
  SKIPHEADERS-$(CONFIG_DXVA2)            += dxva2.h dxva2_internal.h
  SKIPHEADERS-$(CONFIG_LIBSCHROEDINGER)  += libschroedinger.h
 +SKIPHEADERS-$(CONFIG_LIBUTVIDEO)       += libutvideo.h
  SKIPHEADERS-$(CONFIG_MPEG_XVMC_DECODER) += xvmc.h
  SKIPHEADERS-$(CONFIG_VAAPI)            += vaapi_internal.h
  SKIPHEADERS-$(CONFIG_VDA)              += vda.h vda_internal.h
  SKIPHEADERS-$(CONFIG_VDPAU)            += vdpau.h
 +SKIPHEADERS-$(HAVE_OS2THREADS)         += os2threads.h
  SKIPHEADERS-$(HAVE_W32THREADS)         += w32pthreads.h
  
 -EXAMPLES = api
 -
  TESTPROGS = cabac                                                       \
              dct                                                         \
              fft                                                         \
              golomb                                                      \
              iirfilter                                                   \
              rangecoder                                                  \
 +            raw                                                         \
 +            snowenc                                                     \
  
  TESTPROGS-$(HAVE_MMX) += motion
  TESTOBJS = dctref.o
@@@ -850,10 -770,3 +851,10 @@@ $(SUBDIR)motionpixels.o: $(SUBDIR)motio
  $(SUBDIR)pcm.o: $(SUBDIR)pcm_tables.h
  $(SUBDIR)qdm2.o: $(SUBDIR)qdm2_tables.h
  endif
 +
 +CODEC_NAMES_SH := $(SRC_PATH)/$(SUBDIR)codec_names.sh
 +AVCODEC_H      := $(SRC_PATH)/$(SUBDIR)avcodec.h
 +$(SUBDIR)codec_names.h: $(CODEC_NAMES_SH) config.h $(AVCODEC_H)
 +      $(CC) $(CPPFLAGS) $(CFLAGS) -E $(AVCODEC_H) | \
 +      $(CODEC_NAMES_SH) config.h $@
 +$(SUBDIR)utils.o: $(SUBDIR)codec_names.h
diff --combined libavcodec/aacdec.c
@@@ -7,20 -7,20 +7,20 @@@
   * Copyright (c) 2008-2010 Paul Kendall <paul@kcbbs.gen.nz>
   * Copyright (c) 2010      Janne Grunau <janne-libav@jannau.net>
   *
 - * 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
   */
  
  static VLC vlc_scalefactors;
  static VLC vlc_spectral[11];
  
 -static const char overread_err[] = "Input buffer exhausted before END element found\n";
 +#define overread_err "Input buffer exhausted before END element found\n"
  
  static int count_channels(uint8_t (*layout)[3], int tags)
  {
  /**
   * Check for the channel element in the current channel position configuration.
   * If it exists, make sure the appropriate element is allocated and map the
 - * channel order to match the internal Libav channel layout.
 + * channel order to match the internal FFmpeg channel layout.
   *
   * @param   che_pos current channel position configuration
   * @param   type channel element type
@@@ -149,10 -149,6 +149,10 @@@ static av_cold int che_configure(AACCon
              ff_aac_sbr_ctx_init(ac, &ac->che[type][id]->sbr);
          }
          if (type != TYPE_CCE) {
 +            if (*channels >= MAX_CHANNELS - (type == TYPE_CPE || (type == TYPE_SCE && ac->oc[1].m4ac.ps == 1))) {
 +                av_log(ac->avctx, AV_LOG_ERROR, "Too many channels\n");
 +                return AVERROR_INVALIDDATA;
 +            }
              ac->output_data[(*channels)++] = ac->che[type][id]->ch[0].ret;
              if (type == TYPE_CPE ||
                  (type == TYPE_SCE && ac->oc[1].m4ac.ps == 1)) {
@@@ -370,11 -366,9 +370,11 @@@ static void push_output_configuration(A
   */
  static void pop_output_configuration(AACContext *ac) {
      if (ac->oc[1].status != OC_LOCKED) {
 -        ac->oc[1] = ac->oc[0];
 -        ac->avctx->channels = ac->oc[1].channels;
 -        ac->avctx->channel_layout = ac->oc[1].channel_layout;
 +        if (ac->oc[0].status == OC_LOCKED) {
 +            ac->oc[1] = ac->oc[0];
 +            ac->avctx->channels = ac->oc[1].channels;
 +            ac->avctx->channel_layout = ac->oc[1].channel_layout;
 +        }
      }
  }
  
@@@ -419,31 -413,13 +419,31 @@@ static int output_configure(AACContext 
      }
  
      memcpy(ac->tag_che_map, ac->che, 4 * MAX_ELEM_ID * sizeof(ac->che[0][0]));
 -    avctx->channel_layout = ac->oc[1].channel_layout = layout;
 +    if (layout) avctx->channel_layout = layout;
 +    ac->oc[1].channel_layout = layout;
      avctx->channels = ac->oc[1].channels = channels;
      ac->oc[1].status = oc_type;
  
      return 0;
  }
  
 +static void flush(AVCodecContext *avctx)
 +{
 +    AACContext *ac= avctx->priv_data;
 +    int type, i, j;
 +
 +    for (type = 3; type >= 0; type--) {
 +        for (i = 0; i < MAX_ELEM_ID; i++) {
 +            ChannelElement *che = ac->che[type][i];
 +            if (che) {
 +                for (j = 0; j <= 1; j++) {
 +                    memset(che->ch[j].saved, 0, sizeof(che->ch[j].saved));
 +                }
 +            }
 +        }
 +    }
 +}
 +
  /**
   * Set up channel positions based on a default channel configuration
   * as specified in table 1.17.
@@@ -477,8 -453,6 +477,8 @@@ static ChannelElement *get_che(AACConte
          int layout_map_tags;
          push_output_configuration(ac);
  
 +        av_log(ac->avctx, AV_LOG_DEBUG, "mono with CPE\n");
 +
          if (set_default_channel_config(ac->avctx, layout_map, &layout_map_tags,
                                         2) < 0)
              return NULL;
          int layout_map_tags;
          push_output_configuration(ac);
  
 +        av_log(ac->avctx, AV_LOG_DEBUG, "stereo with SCE\n");
 +
          if (set_default_channel_config(ac->avctx, layout_map, &layout_map_tags,
                                         1) < 0)
              return NULL;
@@@ -575,8 -547,6 +575,8 @@@ static void decode_channel_map(uint8_t 
          case AAC_CHANNEL_LFE:
              syn_ele = TYPE_LFE;
              break;
 +        default:
 +            av_assert0(0);
          }
          layout_map[0][0] = syn_ele;
          layout_map[0][1] = get_bits(gb, 4);
@@@ -619,10 -589,6 +619,10 @@@ static int decode_pce(AVCodecContext *a
      if (get_bits1(gb))
          skip_bits(gb, 3); // mixdown_coeff_index and pseudo_surround
  
 +    if (get_bits_left(gb) < 4 * (num_front + num_side + num_back + num_lfe + num_assoc_data + num_cc)) {
 +        av_log(avctx, AV_LOG_ERROR, "decode_pce: " overread_err);
 +        return -1;
 +    }
      decode_channel_map(layout_map       , AAC_CHANNEL_FRONT, gb, num_front);
      tags = num_front;
      decode_channel_map(layout_map + tags, AAC_CHANNEL_SIDE,  gb, num_side);
      /* comment field, first byte is length */
      comment_len = get_bits(gb, 8) * 8;
      if (get_bits_left(gb) < comment_len) {
 -        av_log(avctx, AV_LOG_ERROR, overread_err);
 +        av_log(avctx, AV_LOG_ERROR, "decode_pce: " overread_err);
          return -1;
      }
      skip_bits_long(gb, comment_len);
@@@ -740,9 -706,9 +740,9 @@@ static int decode_audio_specific_config
      GetBitContext gb;
      int i;
  
 -    av_dlog(avctx, "extradata size %d\n", avctx->extradata_size);
 -    for (i = 0; i < avctx->extradata_size; i++)
 -         av_dlog(avctx, "%02x ", avctx->extradata[i]);
 +    av_dlog(avctx, "audio specific config size %d\n", bit_size >> 3);
 +    for (i = 0; i < bit_size >> 3; i++)
 +         av_dlog(avctx, "%02x ", data[i]);
      av_dlog(avctx, "\n");
  
      init_get_bits(&gb, data, bit_size);
@@@ -842,14 -808,6 +842,14 @@@ static av_cold int aac_decode_init(AVCo
      ac->avctx = avctx;
      ac->oc[1].m4ac.sample_rate = avctx->sample_rate;
  
 +    if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
 +        avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
 +        output_scale_factor = 1.0 / 32768.0;
 +    } else {
 +        avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 +        output_scale_factor = 1.0;
 +    }
 +
      if (avctx->extradata_size > 0) {
          if (decode_audio_specific_config(ac, ac->avctx, &ac->oc[1].m4ac,
                                           avctx->extradata,
          }
      }
  
 -    if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
 -        avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
 -        output_scale_factor = 1.0 / 32768.0;
 -    } else {
 -        avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 -        output_scale_factor = 1.0;
 -    }
 -
      AAC_INIT_VLC_STATIC( 0, 304);
      AAC_INIT_VLC_STATIC( 1, 270);
      AAC_INIT_VLC_STATIC( 2, 550);
@@@ -942,7 -908,7 +942,7 @@@ static int skip_data_stream_element(AAC
          align_get_bits(gb);
  
      if (get_bits_left(gb) < 8 * count) {
 -        av_log(ac->avctx, AV_LOG_ERROR, overread_err);
 +        av_log(ac->avctx, AV_LOG_ERROR, "skip_data_stream_element: "overread_err);
          return -1;
      }
      skip_bits_long(gb, 8 * count);
@@@ -1023,11 -989,11 +1023,11 @@@ static int decode_ics_info(AACContext *
          if (ics->predictor_present) {
              if (ac->oc[1].m4ac.object_type == AOT_AAC_MAIN) {
                  if (decode_prediction(ac, ics, gb)) {
 -                    return AVERROR_INVALIDDATA;
 +                    goto fail;
                  }
              } else if (ac->oc[1].m4ac.object_type == AOT_AAC_LC) {
                  av_log(ac->avctx, AV_LOG_ERROR, "Prediction is not allowed in AAC-LC.\n");
 -                return AVERROR_INVALIDDATA;
 +                goto fail;
              } else {
                  if ((ics->ltp.present = get_bits(gb, 1)))
                      decode_ltp(ac, &ics->ltp, gb, ics->max_sfb);
          av_log(ac->avctx, AV_LOG_ERROR,
                 "Number of scalefactor bands in group (%d) exceeds limit (%d).\n",
                 ics->max_sfb, ics->num_swb);
 -        return AVERROR_INVALIDDATA;
 +        goto fail;
      }
  
      return 0;
 +fail:
 +    ics->max_sfb = 0;
 +    return AVERROR_INVALIDDATA;
  }
  
  /**
@@@ -1076,7 -1039,7 +1076,7 @@@ static int decode_band_types(AACContex
                  sect_len_incr = get_bits(gb, bits);
                  sect_end += sect_len_incr;
                  if (get_bits_left(gb) < 0) {
 -                    av_log(ac->avctx, AV_LOG_ERROR, overread_err);
 +                    av_log(ac->avctx, AV_LOG_ERROR, "decode_band_types: "overread_err);
                      return -1;
                  }
                  if (sect_end > ics->max_sfb) {
@@@ -1308,7 -1271,7 +1308,7 @@@ static inline float *VMUL4S(float *dst
      t.i = s.i ^ (sign & 1U<<31);
      *dst++ = v[idx>>4 & 3] * t.f;
  
-     sign <<= nz & 1; nz >>= 1;
+     sign <<= nz & 1;
      t.i = s.i ^ (sign & 1U<<31);
      *dst++ = v[idx>>6 & 3] * t.f;
  
@@@ -2359,11 -2322,9 +2359,11 @@@ static int parse_adts_frame_header(AACC
  
      size = avpriv_aac_parse_header(gb, &hdr_info);
      if (size > 0) {
 -        if (hdr_info.num_aac_frames != 1) {
 +        if (!ac->warned_num_aac_frames && hdr_info.num_aac_frames != 1) {
 +            // This is 2 for "VLB " audio in NSV files.
 +            // See samples/nsv/vlb_audio.
              av_log_missing_feature(ac->avctx, "More than one AAC RDB per ADTS frame is", 0);
 -            return -1;
 +            ac->warned_num_aac_frames = 1;
          }
          push_output_configuration(ac);
          if (hdr_info.chan_config) {
@@@ -2470,8 -2431,6 +2470,8 @@@ static int aac_decode_frame_int(AVCodec
                  pop_output_configuration(ac);
              } else {
                  err = output_configure(ac, layout_map, tags, 0, OC_TRIAL_PCE);
 +                if (!err)
 +                    ac->oc[1].m4ac.chan_config = 0;
                  pce_found = 1;
              }
              break;
              if (elem_id == 15)
                  elem_id += get_bits(gb, 8) - 1;
              if (get_bits_left(gb) < 8 * elem_id) {
 -                    av_log(avctx, AV_LOG_ERROR, overread_err);
 +                    av_log(avctx, AV_LOG_ERROR, "TYPE_FIL: "overread_err);
                      err = -1;
                      goto fail;
              }
@@@ -2562,7 -2521,7 +2562,7 @@@ static int aac_decode_frame(AVCodecCont
                                         AV_PKT_DATA_NEW_EXTRADATA,
                                         &new_extradata_size);
  
 -    if (new_extradata) {
 +    if (new_extradata && 0) {
          av_free(avctx->extradata);
          avctx->extradata = av_mallocz(new_extradata_size +
                                        FF_INPUT_BUFFER_PADDING_SIZE);
@@@ -2616,7 -2575,7 +2616,7 @@@ static av_cold int aac_decode_close(AVC
  
  struct LATMContext {
      AACContext      aac_ctx;             ///< containing AACContext
 -    int             initialized;         ///< initilized after a valid extradata was seen
 +    int             initialized;         ///< initialized after a valid extradata was seen
  
      // parser data
      int             audio_mux_version_A; ///< LATM syntax version
@@@ -2893,7 -2852,6 +2893,7 @@@ AVCodec ff_aac_decoder = 
      },
      .capabilities    = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
      .channel_layouts = aac_channel_layout,
 +    .flush = flush,
  };
  
  /*
@@@ -2915,5 -2873,4 +2915,5 @@@ AVCodec ff_aac_latm_decoder = 
      },
      .capabilities    = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
      .channel_layouts = aac_channel_layout,
 +    .flush = flush,
  };
diff --combined libavcodec/allcodecs.c
@@@ -2,20 -2,20 +2,20 @@@
   * Provide registration of all codecs, parsers and bitstream filters for libavcodec.
   * Copyright (c) 2002 Fabrice Bellard
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -58,10 -58,8 +58,10 @@@ void avcodec_register_all(void
      REGISTER_HWACCEL (H264_DXVA2, h264_dxva2);
      REGISTER_HWACCEL (H264_VAAPI, h264_vaapi);
      REGISTER_HWACCEL (H264_VDA, h264_vda);
 +    REGISTER_HWACCEL (MPEG1_VDPAU, mpeg1_vdpau);
      REGISTER_HWACCEL (MPEG2_DXVA2, mpeg2_dxva2);
      REGISTER_HWACCEL (MPEG2_VAAPI, mpeg2_vaapi);
 +    REGISTER_HWACCEL (MPEG2_VDPAU, mpeg2_vdpau);
      REGISTER_HWACCEL (MPEG4_VAAPI, mpeg4_vaapi);
      REGISTER_HWACCEL (VC1_DXVA2, vc1_dxva2);
      REGISTER_HWACCEL (VC1_VAAPI, vc1_vaapi);
      REGISTER_ENCODER (A64MULTI, a64multi);
      REGISTER_ENCODER (A64MULTI5, a64multi5);
      REGISTER_DECODER (AASC, aasc);
 -    REGISTER_DECODER (AMV, amv);
 +    REGISTER_ENCDEC  (AMV, amv);
      REGISTER_DECODER (ANM, anm);
      REGISTER_DECODER (ANSI, ansi);
      REGISTER_ENCDEC  (ASV1, asv1);
      REGISTER_ENCDEC  (ASV2, asv2);
      REGISTER_DECODER (AURA, aura);
      REGISTER_DECODER (AURA2, aura2);
 +    REGISTER_ENCDEC  (AVRP, avrp);
      REGISTER_DECODER (AVS, avs);
 +    REGISTER_ENCDEC  (AVUI, avui);
 +    REGISTER_ENCDEC  (AYUV, ayuv);
      REGISTER_DECODER (BETHSOFTVID, bethsoftvid);
      REGISTER_DECODER (BFI, bfi);
      REGISTER_DECODER (BINK, bink);
@@@ -97,7 -92,6 +97,7 @@@
      REGISTER_DECODER (CSCD, cscd);
      REGISTER_DECODER (CYUV, cyuv);
      REGISTER_DECODER (DFA, dfa);
 +    REGISTER_DECODER (DIRAC, dirac);
      REGISTER_ENCDEC  (DNXHD, dnxhd);
      REGISTER_ENCDEC  (DPX, dpx);
      REGISTER_DECODER (DSICINVIDEO, dsicinvideo);
      REGISTER_DECODER (EIGHTSVX_EXP, eightsvx_exp);
      REGISTER_DECODER (EIGHTSVX_FIB, eightsvx_fib);
      REGISTER_DECODER (ESCAPE124, escape124);
 +    REGISTER_DECODER (ESCAPE130, escape130);
 +    REGISTER_DECODER (EXR, exr);
      REGISTER_ENCDEC  (FFV1, ffv1);
      REGISTER_ENCDEC  (FFVHUFF, ffvhuff);
      REGISTER_ENCDEC  (FLASHSV, flashsv);
 -    REGISTER_DECODER (FLASHSV2, flashsv2);
 +    REGISTER_ENCDEC  (FLASHSV2, flashsv2);
      REGISTER_DECODER (FLIC, flic);
      REGISTER_ENCDEC  (FLV, flv);
      REGISTER_DECODER (FOURXM, fourxm);
      REGISTER_DECODER (H263I, h263i);
      REGISTER_ENCODER (H263P, h263p);
      REGISTER_DECODER (H264, h264);
 +    REGISTER_DECODER (H264_CRYSTALHD, h264_crystalhd);
      REGISTER_DECODER (H264_VDPAU, h264_vdpau);
      REGISTER_ENCDEC  (HUFFYUV, huffyuv);
      REGISTER_DECODER (IDCIN, idcin);
      REGISTER_DECODER (INDEO4, indeo4);
      REGISTER_DECODER (INDEO5, indeo5);
      REGISTER_DECODER (INTERPLAY_VIDEO, interplay_video);
 +    REGISTER_ENCDEC  (JPEG2000, jpeg2000);
      REGISTER_ENCDEC  (JPEGLS, jpegls);
      REGISTER_DECODER (JV, jv);
      REGISTER_DECODER (KGV1, kgv1);
      REGISTER_ENCDEC  (MPEG1VIDEO, mpeg1video);
      REGISTER_ENCDEC  (MPEG2VIDEO, mpeg2video);
      REGISTER_ENCDEC  (MPEG4, mpeg4);
 +    REGISTER_DECODER (MPEG4_CRYSTALHD, mpeg4_crystalhd);
      REGISTER_DECODER (MPEG4_VDPAU, mpeg4_vdpau);
 +    REGISTER_DECODER (MPEGVIDEO, mpegvideo);
      REGISTER_DECODER (MPEG_VDPAU, mpeg_vdpau);
      REGISTER_DECODER (MPEG1_VDPAU, mpeg1_vdpau);
 +    REGISTER_DECODER (MPEG2_CRYSTALHD, mpeg2_crystalhd);
+     REGISTER_DECODER (MSA1, msa1);
 +    REGISTER_DECODER (MSMPEG4_CRYSTALHD, msmpeg4_crystalhd);
      REGISTER_DECODER (MSMPEG4V1, msmpeg4v1);
      REGISTER_ENCDEC  (MSMPEG4V2, msmpeg4v2);
      REGISTER_ENCDEC  (MSMPEG4V3, msmpeg4v3);
      REGISTER_DECODER (MSRLE, msrle);
      REGISTER_DECODER (MSS1, mss1);
 -    REGISTER_DECODER (MSVIDEO1, msvideo1);
 +    REGISTER_ENCDEC  (MSVIDEO1, msvideo1);
      REGISTER_DECODER (MSZH, mszh);
      REGISTER_DECODER (MXPEG, mxpeg);
      REGISTER_DECODER (NUV, nuv);
      REGISTER_ENCDEC  (PNG, png);
      REGISTER_ENCDEC  (PPM, ppm);
      REGISTER_ENCDEC  (PRORES, prores);
 +    REGISTER_ENCODER (PRORES_ANATOLIY, prores_anatoliy);
 +    REGISTER_ENCODER (PRORES_KOSTYA, prores_kostya);
 +    REGISTER_DECODER (PRORES_LGPL, prores_lgpl);
      REGISTER_DECODER (PTX, ptx);
      REGISTER_DECODER (QDRAW, qdraw);
      REGISTER_DECODER (QPEG, qpeg);
      REGISTER_ENCDEC  (QTRLE, qtrle);
 -    REGISTER_DECODER (R10K,  r10k);
 -    REGISTER_DECODER (R210,  r210);
 +    REGISTER_ENCDEC  (R10K,  r10k);
 +    REGISTER_ENCDEC  (R210,  r210);
      REGISTER_ENCDEC  (RAWVIDEO, rawvideo);
      REGISTER_DECODER (RL2, rl2);
      REGISTER_ENCDEC  (ROQ, roq);
      REGISTER_DECODER (RV30, rv30);
      REGISTER_DECODER (RV40, rv40);
      REGISTER_DECODER (S302M, s302m);
 +    REGISTER_DECODER (SANM, sanm);
      REGISTER_ENCDEC  (SGI, sgi);
      REGISTER_DECODER (SMACKER, smacker);
      REGISTER_DECODER (SMC, smc);
      REGISTER_DECODER (UTVIDEO, utvideo);
      REGISTER_ENCDEC  (V210,  v210);
      REGISTER_DECODER (V210X, v210x);
 +    REGISTER_ENCDEC  (V308, v308);
 +    REGISTER_ENCDEC  (V408, v408);
      REGISTER_ENCDEC  (V410, v410);
      REGISTER_DECODER (VB, vb);
      REGISTER_DECODER (VBLE, vble);
      REGISTER_DECODER (VC1, vc1);
 +    REGISTER_DECODER (VC1_CRYSTALHD, vc1_crystalhd);
      REGISTER_DECODER (VC1_VDPAU, vc1_vdpau);
      REGISTER_DECODER (VC1IMAGE, vc1image);
      REGISTER_DECODER (VCR1, vcr1);
      REGISTER_ENCDEC  (WMV1, wmv1);
      REGISTER_ENCDEC  (WMV2, wmv2);
      REGISTER_DECODER (WMV3, wmv3);
 +    REGISTER_DECODER (WMV3_CRYSTALHD, wmv3_crystalhd);
      REGISTER_DECODER (WMV3_VDPAU, wmv3_vdpau);
      REGISTER_DECODER (WMV3IMAGE, wmv3image);
      REGISTER_DECODER (WNV1, wnv1);
      REGISTER_DECODER (XAN_WC3, xan_wc3);
      REGISTER_DECODER (XAN_WC4, xan_wc4);
 -    REGISTER_ENCODER (XBM, xbm);
 +    REGISTER_ENCDEC  (XBM, xbm);
      REGISTER_DECODER (XL, xl);
      REGISTER_ENCDEC  (XWD, xwd);
 +    REGISTER_ENCDEC  (Y41P, y41p);
      REGISTER_DECODER (YOP, yop);
 +    REGISTER_ENCDEC  (YUV4, yuv4);
      REGISTER_DECODER (ZEROCODEC, zerocodec);
      REGISTER_ENCDEC  (ZLIB, zlib);
      REGISTER_ENCDEC  (ZMBV, zmbv);
      REGISTER_DECODER (BINKAUDIO_RDFT, binkaudio_rdft);
      REGISTER_DECODER (BMV_AUDIO, bmv_audio);
      REGISTER_DECODER (COOK, cook);
 -    REGISTER_DECODER (DCA, dca);
 +    REGISTER_ENCDEC  (DCA, dca);
      REGISTER_DECODER (DSICINAUDIO, dsicinaudio);
      REGISTER_ENCDEC  (EAC3, eac3);
 +    REGISTER_DECODER (FFWAVESYNTH, ffwavesynth);
      REGISTER_ENCDEC  (FLAC, flac);
 +    REGISTER_ENCDEC  (G723_1, g723_1);
 +    REGISTER_DECODER (G729, g729);
      REGISTER_DECODER (GSM, gsm);
      REGISTER_DECODER (GSM_MS, gsm_ms);
      REGISTER_DECODER (IAC, iac);
      REGISTER_DECODER (SHORTEN, shorten);
      REGISTER_DECODER (SIPR, sipr);
      REGISTER_DECODER (SMACKAUD, smackaud);
 +    REGISTER_ENCDEC  (SONIC, sonic);
 +    REGISTER_ENCODER (SONIC_LS, sonic_ls);
      REGISTER_DECODER (TRUEHD, truehd);
      REGISTER_DECODER (TRUESPEECH, truespeech);
      REGISTER_DECODER (TTA, tta);
      REGISTER_DECODER (ADPCM_THP, adpcm_thp);
      REGISTER_DECODER (ADPCM_XA, adpcm_xa);
      REGISTER_ENCDEC  (ADPCM_YAMAHA, adpcm_yamaha);
 +    REGISTER_DECODER (VIMA, vima);
  
      /* subtitles */
      REGISTER_ENCDEC  (ASS, ass);
      REGISTER_ENCDEC  (DVBSUB, dvbsub);
      REGISTER_ENCDEC  (DVDSUB, dvdsub);
 +    REGISTER_DECODER (JACOSUB, jacosub);
 +    REGISTER_DECODER (MICRODVD, microdvd);
      REGISTER_DECODER (PGSSUB, pgssub);
 -    REGISTER_DECODER (SRT, srt);
 +    REGISTER_DECODER (REALTEXT, realtext);
 +    REGISTER_DECODER (SAMI, sami);
 +    REGISTER_ENCDEC  (SRT, srt);
      REGISTER_ENCDEC  (XSUB, xsub);
  
      /* external libraries */
 +    REGISTER_DECODER (LIBCELT, libcelt);
      REGISTER_ENCODER (LIBFAAC, libfaac);
      REGISTER_ENCDEC  (LIBGSM, libgsm);
      REGISTER_ENCDEC  (LIBGSM_MS, libgsm_ms);
      REGISTER_ENCODER (LIBMP3LAME, libmp3lame);
      REGISTER_ENCDEC  (LIBOPENCORE_AMRNB, libopencore_amrnb);
      REGISTER_DECODER (LIBOPENCORE_AMRWB, libopencore_amrwb);
 -    REGISTER_DECODER (LIBOPENJPEG, libopenjpeg);
 +    REGISTER_ENCDEC  (LIBOPENJPEG, libopenjpeg);
      REGISTER_ENCDEC  (LIBSCHROEDINGER, libschroedinger);
      REGISTER_ENCDEC  (LIBSPEEX, libspeex);
 +    REGISTER_DECODER (LIBSTAGEFRIGHT_H264, libstagefright_h264);
      REGISTER_ENCODER (LIBTHEORA, libtheora);
 +    REGISTER_ENCDEC  (LIBUTVIDEO, libutvideo);
      REGISTER_ENCODER (LIBVO_AACENC, libvo_aacenc);
      REGISTER_ENCODER (LIBVO_AMRWBENC, libvo_amrwbenc);
 -    REGISTER_ENCODER (LIBVORBIS, libvorbis);
 +    REGISTER_ENCDEC  (LIBVORBIS, libvorbis);
      REGISTER_ENCDEC  (LIBVPX, libvpx);
      REGISTER_ENCODER (LIBX264, libx264);
 +    REGISTER_ENCODER (LIBX264RGB, libx264rgb);
      REGISTER_ENCODER (LIBXAVS, libxavs);
      REGISTER_ENCODER (LIBXVID, libxvid);
 +    REGISTER_ENCODER (LIBAACPLUS, libaacplus);
 +
 +    /* text */
 +    REGISTER_DECODER (BINTEXT, bintext);
 +    REGISTER_DECODER (XBIN, xbin);
 +    REGISTER_DECODER (IDF, idf);
  
      /* parsers */
      REGISTER_PARSER  (AAC, aac);
      REGISTER_PARSER  (MPEG4VIDEO, mpeg4video);
      REGISTER_PARSER  (MPEGAUDIO, mpegaudio);
      REGISTER_PARSER  (MPEGVIDEO, mpegvideo);
 +    REGISTER_PARSER  (PNG, png);
      REGISTER_PARSER  (PNM, pnm);
      REGISTER_PARSER  (RV30, rv30);
      REGISTER_PARSER  (RV40, rv40);
diff --combined libavcodec/alsdec.c
@@@ -2,20 -2,20 +2,20 @@@
   * MPEG-4 ALS decoder
   * Copyright (c) 2009 Thilo Borgmann <thilo.borgmann _at_ googlemail.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
   */
  
@@@ -394,7 -394,7 +394,7 @@@ static av_cold int read_specific_config
          if (get_bits_left(&gb) < 32)
              return -1;
  
 -        if (avctx->err_recognition & AV_EF_CRCCHECK) {
 +        if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
              ctx->crc_table = av_crc_get_table(AV_CRC_32_IEEE_LE);
              ctx->crc       = 0xFFFFFFFF;
              ctx->crc_org   = ~get_bits_long(&gb, 32);
@@@ -651,11 -651,6 +651,11 @@@ static int read_var_block_data(ALSDecCo
          for (k = 1; k < sub_blocks; k++)
              s[k] = s[k - 1] + decode_rice(gb, 0);
      }
 +    for (k = 0; k < sub_blocks; k++)
 +        if (s[k] > 32) {
 +            av_log(avctx, AV_LOG_ERROR, "k invalid for rice code.\n");
 +            return -1;
 +        }
  
      if (get_bits1(gb))
          *bd->shift_lsbs = get_bits(gb, 4) + 1;
              int opt_order_length = av_ceil_log2(av_clip((bd->block_length >> 3) - 1,
                                                  2, sconf->max_order + 1));
              *bd->opt_order       = get_bits(gb, opt_order_length);
 +            if (*bd->opt_order > sconf->max_order) {
 +                *bd->opt_order = sconf->max_order;
 +                av_log(avctx, AV_LOG_ERROR, "Predictor order too large!\n");
 +                return -1;
 +            }
          } else {
              *bd->opt_order = sconf->max_order;
          }
                      int rice_param = parcor_rice_table[sconf->coef_table][k][1];
                      int offset     = parcor_rice_table[sconf->coef_table][k][0];
                      quant_cof[k] = decode_rice(gb, rice_param) + offset;
 +                    if (quant_cof[k] < -64 || quant_cof[k] > 63) {
 +                        av_log(avctx, AV_LOG_ERROR, "Quantization coefficient %d is out of range!\n", quant_cof[k]);
 +                        return AVERROR_INVALIDDATA;
 +                    }
                  }
  
                  // read coefficients 20 to 126
              bd->ltp_gain[0]   = decode_rice(gb, 1) << 3;
              bd->ltp_gain[1]   = decode_rice(gb, 2) << 3;
  
 -            r                 = get_unary(gb, 0, 4);
 +            r                 = get_unary(gb, 0, 3);
              c                 = get_bits(gb, 2);
              bd->ltp_gain[2]   = ltp_gain_values[r][c];
  
          int          delta[8];
          unsigned int k    [8];
          unsigned int b = av_clip((av_ceil_log2(bd->block_length) - 3) >> 1, 0, 5);
-         unsigned int i = start;
+         unsigned int i;
  
          // read most significant bits
          unsigned int high;
  
          current_res = bd->raw_samples + start;
  
-         for (sb = 0; sb < sub_blocks; sb++, i = 0) {
+         for (sb = 0; sb < sub_blocks; sb++) {
              k    [sb] = s[sb] > b ? s[sb] - b : 0;
              delta[sb] = 5 - s[sb] + k[sb];
  
 -            ff_bgmc_decode(gb, sb_length, current_res,
 +            ff_bgmc_decode(gb, sb_length - i, current_res,
                          delta[sb], sx[sb], &high, &low, &value, ctx->bgmc_lut, ctx->bgmc_lut_status);
  
 -            current_res += sb_length;
 +            current_res += sb_length - i;
          }
  
          ff_bgmc_decode_end(gb);
@@@ -1025,8 -1011,8 +1025,8 @@@ static void zero_remaining(unsigned in
  {
      unsigned int count = 0;
  
 -    for (; b < b_max; b++)
 -        count += div_blocks[b];
 +    while (b < b_max)
 +        count += div_blocks[b++];
  
      if (count)
          memset(buf, 0, sizeof(*buf) * count);
@@@ -1132,7 -1118,7 +1132,7 @@@ static int decode_blocks(ALSDecContext 
          // reconstruct joint-stereo blocks
          if (bd[0].js_blocks) {
              if (bd[1].js_blocks)
 -                av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel pair!\n");
 +                av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel pair.\n");
  
              for (s = 0; s < div_blocks[b]; s++)
                  bd[0].raw_samples[s] = bd[1].raw_samples[s] - bd[0].raw_samples[s];
@@@ -1226,7 -1212,7 +1226,7 @@@ static int revert_channel_correlation(A
      }
  
      if (dep == channels) {
 -        av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel correlation!\n");
 +        av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel correlation.\n");
          return -1;
      }
  
@@@ -1381,7 -1367,8 +1381,7 @@@ static int read_frame_data(ALSDecContex
                  bd.raw_samples = ctx->raw_samples[c] + offset;
                  bd.raw_other   = NULL;
  
 -                read_block(ctx, &bd);
 -                if (read_channel_data(ctx, ctx->chan_data[c], c))
 +                if (read_block(ctx, &bd) || read_channel_data(ctx, ctx->chan_data[c], c))
                      return -1;
              }
  
                  bd.lpc_cof     = ctx->lpc_cof[c];
                  bd.quant_cof   = ctx->quant_cof[c];
                  bd.raw_samples = ctx->raw_samples[c] + offset;
 -                decode_block(ctx, &bd);
 +                if (decode_block(ctx, &bd))
 +                    return -1;
              }
  
              memset(reverted_channels, 0, avctx->channels * sizeof(*reverted_channels));
@@@ -1451,7 -1437,7 +1451,7 @@@ static int decode_frame(AVCodecContext 
          ctx->cur_frame_length = sconf->frame_length;
  
      // decode the frame data
 -    if ((invalid_frame = read_frame_data(ctx, ra_frame) < 0))
 +    if ((invalid_frame = read_frame_data(ctx, ra_frame)) < 0)
          av_log(ctx->avctx, AV_LOG_WARNING,
                 "Reading frame data failed. Skipping RA unit.\n");
  
      }
  
      // update CRC
 -    if (sconf->crc_enabled && (avctx->err_recognition & AV_EF_CRCCHECK)) {
 +    if (sconf->crc_enabled && (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL))) {
          int swap = HAVE_BIGENDIAN != sconf->msb_first;
  
          if (ctx->avctx->bits_per_raw_sample == 24) {
          // check CRC sums if this is the last frame
          if (ctx->cur_frame_length != sconf->frame_length &&
              ctx->crc_org != ctx->crc) {
 -            av_log(avctx, AV_LOG_ERROR, "CRC error.\n");
 +            av_log(avctx, AV_LOG_ERROR, "CRC error!\n");
          }
      }
  
@@@ -1593,12 -1579,12 +1593,12 @@@ static av_cold int decode_init(AVCodecC
      ctx->avctx = avctx;
  
      if (!avctx->extradata) {
 -        av_log(avctx, AV_LOG_ERROR, "Missing required ALS extradata.\n");
 +        av_log(avctx, AV_LOG_ERROR, "Missing required ALS extradata!\n");
          return -1;
      }
  
      if (read_specific_config(ctx)) {
 -        av_log(avctx, AV_LOG_ERROR, "Reading ALSSpecificConfig failed.\n");
 +        av_log(avctx, AV_LOG_ERROR, "Reading ALSSpecificConfig failed!\n");
          decode_end(avctx);
          return -1;
      }
      if (!ctx->quant_cof              || !ctx->lpc_cof        ||
          !ctx->quant_cof_buffer       || !ctx->lpc_cof_buffer ||
          !ctx->lpc_cof_reversed_buffer) {
 -        av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
 +        av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed!\n");
          return AVERROR(ENOMEM);
      }
  
          !ctx->opt_order || !ctx->store_prev_samples ||
          !ctx->use_ltp  || !ctx->ltp_lag ||
          !ctx->ltp_gain || !ctx->ltp_gain_buffer) {
 -        av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
 +        av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed!\n");
          decode_end(avctx);
          return AVERROR(ENOMEM);
      }
                                             num_buffers);
  
          if (!ctx->chan_data_buffer || !ctx->chan_data || !ctx->reverted_channels) {
 -            av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
 +            av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed!\n");
              decode_end(avctx);
              return AVERROR(ENOMEM);
          }
  
      // allocate previous raw sample buffer
      if (!ctx->prev_raw_samples || !ctx->raw_buffer|| !ctx->raw_samples) {
 -        av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
 +        av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed!\n");
          decode_end(avctx);
          return AVERROR(ENOMEM);
      }
  
      // allocate crc buffer
      if (HAVE_BIGENDIAN != sconf->msb_first && sconf->crc_enabled &&
 -        (avctx->err_recognition & AV_EF_CRCCHECK)) {
 +        (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL))) {
          ctx->crc_buffer = av_malloc(sizeof(*ctx->crc_buffer) *
                                      ctx->cur_frame_length *
                                      avctx->channels *
                                      av_get_bytes_per_sample(avctx->sample_fmt));
          if (!ctx->crc_buffer) {
 -            av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
 +            av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed!\n");
              decode_end(avctx);
              return AVERROR(ENOMEM);
          }
diff --combined libavcodec/avcodec.h
@@@ -1,20 -1,20 +1,20 @@@
  /*
   * copyright (c) 2001 Fabrice Bellard
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -34,7 -34,6 +34,7 @@@
  #include "libavutil/log.h"
  #include "libavutil/pixfmt.h"
  #include "libavutil/rational.h"
 +#include "libavutil/audioconvert.h"
  
  #include "libavcodec/version.h"
  /**
@@@ -87,8 -86,7 +87,8 @@@
   *
   * If you add a codec ID to this list, add it so that
   * 1. no value of a existing codec ID changes (that would break ABI),
 - * 2. it is as close as possible to similar codecs.
 + * 2. Give it a value which when taken as ASCII is recognized uniquely by a human as this specific codec.
 + *    This ensures that 2 forks can independently add CodecIDs without producing conflicts.
   */
  enum CodecID {
      CODEC_ID_NONE,
      CODEC_ID_XBM,
      CODEC_ID_ZEROCODEC,
      CODEC_ID_MSS1,
+     CODEC_ID_MSA1,
 +    CODEC_ID_Y41P       = MKBETAG('Y','4','1','P'),
 +    CODEC_ID_ESCAPE130  = MKBETAG('E','1','3','0'),
 +    CODEC_ID_EXR        = MKBETAG('0','E','X','R'),
 +    CODEC_ID_AVRP       = MKBETAG('A','V','R','P'),
 +
 +    CODEC_ID_G2M        = MKBETAG( 0 ,'G','2','M'),
 +    CODEC_ID_AVUI       = MKBETAG('A','V','U','I'),
 +    CODEC_ID_AYUV       = MKBETAG('A','Y','U','V'),
 +    CODEC_ID_V308       = MKBETAG('V','3','0','8'),
 +    CODEC_ID_V408       = MKBETAG('V','4','0','8'),
 +    CODEC_ID_YUV4       = MKBETAG('Y','U','V','4'),
 +    CODEC_ID_SANM       = MKBETAG('S','A','N','M'),
  
      /* various PCM "codecs" */
      CODEC_ID_FIRST_AUDIO = 0x10000,     ///< A dummy id pointing at the start of audio codecs
      CODEC_ID_ADPCM_IMA_ISS,
      CODEC_ID_ADPCM_G722,
      CODEC_ID_ADPCM_IMA_APC,
 +    CODEC_ID_VIMA       = MKBETAG('V','I','M','A'),
  
      /* AMR */
      CODEC_ID_AMR_NB = 0x12000,
      CODEC_ID_RALF,
      CODEC_ID_IAC,
      CODEC_ID_ILBC,
 +    CODEC_ID_FFWAVESYNTH = MKBETAG('F','F','W','S'),
 +    CODEC_ID_8SVX_RAW    = MKBETAG('8','S','V','X'),
 +    CODEC_ID_SONIC       = MKBETAG('S','O','N','C'),
 +    CODEC_ID_SONIC_LS    = MKBETAG('S','O','N','L'),
  
      /* subtitle codecs */
      CODEC_ID_FIRST_SUBTITLE = 0x17000,          ///< A dummy ID pointing at the start of subtitle codecs.
      CODEC_ID_HDMV_PGS_SUBTITLE,
      CODEC_ID_DVB_TELETEXT,
      CODEC_ID_SRT,
 +    CODEC_ID_MICRODVD   = MKBETAG('m','D','V','D'),
 +    CODEC_ID_EIA_608    = MKBETAG('c','6','0','8'),
 +    CODEC_ID_JACOSUB    = MKBETAG('J','S','U','B'),
 +    CODEC_ID_SAMI       = MKBETAG('S','A','M','I'),
 +    CODEC_ID_REALTEXT   = MKBETAG('R','T','X','T'),
  
      /* other specific kind of codecs (generally used for attachments) */
      CODEC_ID_FIRST_UNKNOWN = 0x18000,           ///< A dummy ID pointing at the start of various fake codecs.
      CODEC_ID_TTF = 0x18000,
 +    CODEC_ID_BINTEXT    = MKBETAG('B','T','X','T'),
 +    CODEC_ID_XBIN       = MKBETAG('X','B','I','N'),
 +    CODEC_ID_IDF        = MKBETAG( 0 ,'I','D','F'),
  
      CODEC_ID_PROBE = 0x19000, ///< codec_id is not known (like CODEC_ID_NONE) but lavf should attempt to identify it
  
   * Note: If the first 23 bits of the additional bytes are not 0, then damaged
   * MPEG bitstreams could cause overread and segfault.
   */
 -#define FF_INPUT_BUFFER_PADDING_SIZE 8
 +#define FF_INPUT_BUFFER_PADDING_SIZE 16
  
  /**
   * @ingroup lavc_encoding
@@@ -534,7 -508,6 +535,7 @@@ enum AVColorSpace
      AVCOL_SPC_YCOCG       = 8, ///< Used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16
      AVCOL_SPC_NB             , ///< Not part of ABI
  };
 +#define AVCOL_SPC_YCGCO AVCOL_SPC_YCOCG
  
  enum AVColorRange{
      AVCOL_RANGE_UNSPECIFIED = 0,
@@@ -620,7 -593,6 +621,7 @@@ typedef struct RcOverride
  #define CODEC_FLAG2_FAST          0x00000001 ///< Allow non spec compliant speedup tricks.
  #define CODEC_FLAG2_NO_OUTPUT     0x00000004 ///< Skip bitstream encoding.
  #define CODEC_FLAG2_LOCAL_HEADER  0x00000008 ///< Place global headers at every keyframe instead of in extradata.
 +#define CODEC_FLAG2_DROP_FRAME_TIMECODE 0x00002000 ///< timecode is in drop frame format. DEPRECATED!!!!
  #if FF_API_MPV_GLOBAL_OPTS
  #define CODEC_FLAG_CBP_RD         0x04000000 ///< Use rate distortion optimization for cbp.
  #define CODEC_FLAG_QP_RD          0x08000000 ///< Use rate distortion optimization for qp selectioon.
  #define CODEC_FLAG2_SKIP_RD       0x00004000 ///< RD optimal MB level residual skipping
  #endif
  #define CODEC_FLAG2_CHUNKS        0x00008000 ///< Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries.
 +#define CODEC_FLAG2_SHOW_ALL      0x00400000 ///< Show all frames before the first keyframe
  
  /* Unsupported options :
   *              Syntax Arithmetic coding (SAC)
   * Codec should fill in channel configuration and samplerate instead of container
   */
  #define CODEC_CAP_CHANNEL_CONF     0x0400
 +
  /**
   * Codec is able to deal with negative linesizes
   */
  #define CODEC_CAP_NEG_LINESIZES    0x0800
 +
  /**
   * Codec supports frame-level multithreading.
   */
   * Audio encoder supports receiving a different number of samples in each call.
   */
  #define CODEC_CAP_VARIABLE_FRAME_SIZE 0x10000
 +/**
 + * Codec is intra only.
 + */
 +#define CODEC_CAP_INTRA_ONLY       0x40000000
 +/**
 + * Codec is lossless.
 + */
 +#define CODEC_CAP_LOSSLESS         0x80000000
  
  //The following defines may change, don't expect compatibility if you use them.
  #define MB_TYPE_INTRA4x4   0x0001
@@@ -932,12 -893,9 +933,12 @@@ enum AVSideDataParamChangeFlags 
  /**
   * Audio Video Frame.
   * New fields can be added to the end of AVFRAME with minor version
 - * bumps. Removal, reordering and changes to existing fields require
 + * bumps. Similarly fields that are marked as to be only accessed by
 + * av_opt_ptr() can be reordered. This allows 2 forks to add fields
 + * without breaking compatibility with each other.
 + * Removal, reordering and changes in the remaining cases require
   * a major version bump.
 - * sizeof(AVFrame) must not be used outside libav*.
 + * sizeof(AVFrame) must not be used outside libavcodec.
   */
  typedef struct AVFrame {
  #define AV_NUM_DATA_POINTERS 8
      int64_t reordered_opaque;
  
      /**
 -     * hardware accelerator private data (Libav-allocated)
 +     * hardware accelerator private data (FFmpeg-allocated)
       * - encoding: unused
       * - decoding: Set by libavcodec
       */
       * Sample rate of the audio data.
       *
       * - encoding: unused
 -     * - decoding: set by get_buffer()
 +     * - decoding: read by user
       */
      int sample_rate;
  
       * Channel layout of the audio data.
       *
       * - encoding: unused
 -     * - decoding: set by get_buffer()
 +     * - decoding: read by user.
       */
      uint64_t channel_layout;
 +
 +    /**
 +     * frame timestamp estimated using various heuristics, in stream time base
 +     * Code outside libavcodec should access this field using:
 +     * av_frame_get_best_effort_timestamp(frame)
 +     * - encoding: unused
 +     * - decoding: set by libavcodec, read by user.
 +     */
 +    int64_t best_effort_timestamp;
 +
 +    /**
 +     * reordered pos from the last AVPacket that has been input into the decoder
 +     * Code outside libavcodec should access this field using:
 +     * av_frame_get_pkt_pos(frame)
 +     * - encoding: unused
 +     * - decoding: Read by user.
 +     */
 +    int64_t pkt_pos;
 +
 +    /**
 +     * duration of the corresponding packet, expressed in
 +     * AVStream->time_base units, 0 if unknown.
 +     * Code outside libavcodec should access this field using:
 +     * av_frame_get_pkt_duration(frame)
 +     * - encoding: unused
 +     * - decoding: Read by user.
 +     */
 +    int64_t pkt_duration;
  } AVFrame;
  
 +/**
 + * Accessors for some AVFrame fields.
 + * The position of these field in the structure is not part of the ABI,
 + * they should not be accessed directly outside libavcodec.
 + */
 +int64_t av_frame_get_best_effort_timestamp(const AVFrame *frame);
 +int64_t av_frame_get_pkt_duration         (const AVFrame *frame);
 +int64_t av_frame_get_pkt_pos              (const AVFrame *frame);
 +int64_t av_frame_get_channel_layout       (const AVFrame *frame);
 +int     av_frame_get_sample_rate          (const AVFrame *frame);
 +void    av_frame_set_best_effort_timestamp(AVFrame *frame, int64_t val);
 +void    av_frame_set_pkt_duration         (AVFrame *frame, int64_t val);
 +void    av_frame_set_pkt_pos              (AVFrame *frame, int64_t val);
 +void    av_frame_set_channel_layout       (AVFrame *frame, int64_t val);
 +void    av_frame_set_sample_rate          (AVFrame *frame, int     val);
 +
  struct AVCodecInternal;
  
  enum AVFieldOrder {
   * New fields can be added to the end with minor version bumps.
   * Removal, reordering and changes to existing fields require a major
   * version bump.
 + * Please use AVOptions (av_opt* / av_set/get*()) to access these fields from user
 + * applications.
   * sizeof(AVCodecContext) must not be used outside libav*.
   */
  typedef struct AVCodecContext {
      int ticks_per_frame;
  
      /**
 -     * Encoder delay.
 +     * Encoding: Number of frames delay there will be from the encoder input to
 +     *           the decoder output. (we assume the decoder matches the spec)
 +     * Decoding: Number of frames delay in addition to what a standard decoder
 +     *           as specified in the spec would produce.
       *
       * Video:
       *   Number of frames the decoded output will be delayed relative to the
       *   time, including any delay.
       *
       * - encoding: Set by libavcodec.
 -     * - decoding: unused
 +     * - decoding: Set by libavcodec.
       */
      int delay;
  
      int width, height;
  
      /**
 -     * Bitstream width / height, may be different from width/height.
 +     * Bitstream width / height, may be different from width/height if lowres enabled.
       * - encoding: unused
       * - decoding: Set by user before init if known. Codec should override / dynamically change if needed.
       */
      /**
       * Pixel format, see PIX_FMT_xxx.
       * May be set by the demuxer if known from headers.
 -     * May be overriden by the decoder if it knows better.
 +     * May be overridden by the decoder if it knows better.
       * - encoding: Set by user.
       * - decoding: Set by user if known, overridden by libavcodec if known
       */
      /**
       * Audio channel layout.
       * - encoding: set by user.
 -     * - decoding: set by libavcodec.
 +     * - decoding: set by user, may be overwritten by libavcodec.
       */
      uint64_t channel_layout;
  
      enum AVAudioServiceType audio_service_type;
  
      /**
 -     * Used to request a sample format from the decoder.
 -     * - encoding: unused.
 +     * desired sample format
 +     * - encoding: Not used.
       * - decoding: Set by user.
 +     * Decoder will decode to this format if it can.
       */
      enum AVSampleFormat request_sample_fmt;
  
  
      /**
       * ratecontrol qmin qmax limiting method
 -     * 0-> clipping, 1-> use a nice continous function to limit qscale wthin qmin/qmax.
 +     * 0-> clipping, 1-> use a nice continuous function to limit qscale wthin qmin/qmax.
       * - encoding: Set by user.
       * - decoding: unused
       */
      int max_prediction_order;
  
      /**
 -     * GOP timecode frame start number, in non drop frame format
 -     * - encoding: Set by user.
 -     * - decoding: unused
 +     * GOP timecode frame start number
 +     * - encoding: Set by user, in non drop frame format
 +     * - decoding: Set by libavcodec (timecode in the 25 bits format, -1 if unset)
       */
      int64_t timecode_frame_start;
  
  #define AV_EF_BUFFER    (1<<2)
  #define AV_EF_EXPLODE   (1<<3)
  
 +#define AV_EF_CAREFUL    (1<<16)
 +#define AV_EF_COMPLIANT  (1<<17)
 +#define AV_EF_AGGRESSIVE (1<<18)
 +
 +
      /**
       * opaque 64bit number (generally a PTS) that will be reordered and
       * output in AVFrame.reordered_opaque
       * Hardware accelerator context.
       * For some hardware accelerators, a global context needs to be
       * provided by the user. In that case, this holds display-dependent
 -     * data Libav cannot instantiate itself. Please refer to the
 -     * Libav HW accelerator documentation to know how to fill this
 +     * data FFmpeg cannot instantiate itself. Please refer to the
 +     * FFmpeg HW accelerator documentation to know how to fill this
       * is. e.g. for VA API, this is a struct vaapi_context.
       * - encoding: unused
       * - decoding: Set by user
       * - encoding: unused
       * - decoding: Set by user.
       */
 -    attribute_deprecated int lowres;
 +     int lowres;
  
      /**
       * the picture in the bitstream
       * - decoding: unused.
       */
      uint64_t vbv_delay;
 +
 +    /**
 +     * Current statistics for PTS correction.
 +     * - decoding: maintained and used by libavcodec, not intended to be used by user apps
 +     * - encoding: unused
 +     */
 +    int64_t pts_correction_num_faulty_pts; /// Number of incorrect PTS values so far
 +    int64_t pts_correction_num_faulty_dts; /// Number of incorrect DTS values so far
 +    int64_t pts_correction_last_pts;       /// PTS of the last frame
 +    int64_t pts_correction_last_dts;       /// DTS of the last frame
  } AVCodecContext;
  
  /**
@@@ -2976,7 -2869,7 +2977,7 @@@ typedef struct AVCodec 
      const int *supported_samplerates;       ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0
      const enum AVSampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
      const uint64_t *channel_layouts;         ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
 -    attribute_deprecated uint8_t max_lowres; ///< maximum value for lowres supported by the decoder
 +    uint8_t max_lowres;                     ///< maximum value for lowres supported by the decoder
      const AVClass *priv_class;              ///< AVClass for the private context
      const AVProfile *profiles;              ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
  
@@@ -3152,6 -3045,9 +3153,6 @@@ typedef struct AVPicture 
   * @}
   */
  
 -#define AVPALETTE_SIZE 1024
 -#define AVPALETTE_COUNT 256
 -
  enum AVSubtitleType {
      SUBTITLE_NONE,
  
@@@ -3188,16 -3084,10 +3189,16 @@@ typedef struct AVSubtitleRect 
  
      /**
       * 0 terminated ASS/SSA compatible event line.
 -     * The pressentation of this is unaffected by the other values in this
 +     * The presentation of this is unaffected by the other values in this
       * struct.
       */
      char *ass;
 +
 +    /**
 +     * 1 indicates this subtitle is a forced subtitle.
 +     * A forced subtitle should be displayed even when subtitles are hidden.
 +     */
 +    int forced;
  } AVSubtitleRect;
  
  typedef struct AVSubtitle {
@@@ -3253,40 -3143,6 +3254,40 @@@ void avcodec_register(AVCodec *codec)
   */
  void avcodec_register_all(void);
  
 +
 +#if FF_API_ALLOC_CONTEXT
 +/**
 + * Allocate an AVCodecContext and set its fields to default values.  The
 + * resulting struct can be deallocated by simply calling av_free().
 + *
 + * @return An AVCodecContext filled with default values or NULL on failure.
 + * @see avcodec_get_context_defaults
 + *
 + * @deprecated use avcodec_alloc_context3()
 + */
 +attribute_deprecated
 +AVCodecContext *avcodec_alloc_context(void);
 +
 +/** THIS FUNCTION IS NOT YET PART OF THE PUBLIC API!
 + *  we WILL change its arguments and name a few times! */
 +attribute_deprecated
 +AVCodecContext *avcodec_alloc_context2(enum AVMediaType);
 +
 +/**
 + * Set the fields of the given AVCodecContext to default values.
 + *
 + * @param s The AVCodecContext of which the fields should be set to default values.
 + * @deprecated use avcodec_get_context_defaults3
 + */
 +attribute_deprecated
 +void avcodec_get_context_defaults(AVCodecContext *s);
 +
 +/** THIS FUNCTION IS NOT YET PART OF THE PUBLIC API!
 + *  we WILL change its arguments and name a few times! */
 +attribute_deprecated
 +void avcodec_get_context_defaults2(AVCodecContext *s, enum AVMediaType);
 +#endif
 +
  /**
   * Allocate an AVCodecContext and set its fields to default values.  The
   * resulting struct can be deallocated by calling avcodec_close() on it followed
@@@ -3324,22 -3180,6 +3325,22 @@@ int avcodec_get_context_defaults3(AVCod
  const AVClass *avcodec_get_class(void);
  
  /**
 + * Get the AVClass for AVFrame. It can be used in combination with
 + * AV_OPT_SEARCH_FAKE_OBJ for examining options.
 + *
 + * @see av_opt_find().
 + */
 +const AVClass *avcodec_get_frame_class(void);
 +
 +/**
 + * Get the AVClass for AVSubtitleRect. It can be used in combination with
 + * AV_OPT_SEARCH_FAKE_OBJ for examining options.
 + *
 + * @see av_opt_find().
 + */
 +const AVClass *avcodec_get_subtitle_rect_class(void);
 +
 +/**
   * Copy the settings of the source AVCodecContext into the destination
   * AVCodecContext. The resulting destination codec context will be
   * unopened, i.e. you are required to call avcodec_open2() before you
@@@ -3368,40 -3208,6 +3369,40 @@@ AVFrame *avcodec_alloc_frame(void)
   */
  void avcodec_get_frame_defaults(AVFrame *pic);
  
 +#if FF_API_AVCODEC_OPEN
 +/**
 + * Initialize the AVCodecContext to use the given AVCodec. Prior to using this
 + * function the context has to be allocated.
 + *
 + * The functions avcodec_find_decoder_by_name(), avcodec_find_encoder_by_name(),
 + * avcodec_find_decoder() and avcodec_find_encoder() provide an easy way for
 + * retrieving a codec.
 + *
 + * @warning This function is not thread safe!
 + *
 + * @code
 + * avcodec_register_all();
 + * codec = avcodec_find_decoder(CODEC_ID_H264);
 + * if (!codec)
 + *     exit(1);
 + *
 + * context = avcodec_alloc_context3(codec);
 + *
 + * if (avcodec_open(context, codec) < 0)
 + *     exit(1);
 + * @endcode
 + *
 + * @param avctx The context which will be set up to use the given codec.
 + * @param codec The codec to use within the context.
 + * @return zero on success, a negative value on error
 + * @see avcodec_alloc_context3, avcodec_find_decoder, avcodec_find_encoder, avcodec_close
 + *
 + * @deprecated use avcodec_open2
 + */
 +attribute_deprecated
 +int avcodec_open(AVCodecContext *avctx, AVCodec *codec);
 +#endif
 +
  /**
   * Initialize the AVCodecContext to use the given AVCodec. Prior to using this
   * function the context has to be allocated with avcodec_alloc_context3().
@@@ -3559,11 -3365,6 +3560,11 @@@ int av_packet_shrink_side_data(AVPacke
  uint8_t* av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
                                   int *size);
  
 +int av_packet_merge_side_data(AVPacket *pkt);
 +
 +int av_packet_split_side_data(AVPacket *pkt);
 +
 +
  /**
   * @}
   */
@@@ -3719,7 -3520,7 +3720,7 @@@ attribute_deprecated int avcodec_decode
   *         AVPacket is returned.
   */
  int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame,
 -                          int *got_frame_ptr, AVPacket *avpkt);
 +                          int *got_frame_ptr, const AVPacket *avpkt);
  
  /**
   * Decode the video frame of size avpkt->size from avpkt->data into picture.
   */
  int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
                           int *got_picture_ptr,
 -                         AVPacket *avpkt);
 +                         const AVPacket *avpkt);
  
  /**
   * Decode a subtitle message.
@@@ -3829,7 -3630,6 +3830,7 @@@ typedef struct AVCodecParserContext 
  #define PARSER_FLAG_ONCE                      0x0002
  /// Set if the parser has a valid file offset
  #define PARSER_FLAG_FETCHED_OFFSET            0x0004
 +#define PARSER_FLAG_USE_CODEC_TS              0x1000
  
      int64_t offset;      ///< byte offset from starting packet start
      int64_t cur_frame_end[AV_PARSER_PTS_NB];
@@@ -4055,12 -3855,11 +4056,12 @@@ int attribute_deprecated avcodec_encode
   *                  The user can supply an output buffer by setting
   *                  avpkt->data and avpkt->size prior to calling the
   *                  function, but if the size of the user-provided data is not
 - *                  large enough, encoding will fail. All other AVPacket fields
 - *                  will be reset by the encoder using av_init_packet(). If
 - *                  avpkt->data is NULL, the encoder will allocate it.
 - *                  The encoder will set avpkt->size to the size of the
 - *                  output packet.
 + *                  large enough, encoding will fail. If avpkt->data and
 + *                  avpkt->size are set, avpkt->destruct must also be set. All
 + *                  other AVPacket fields will be reset by the encoder using
 + *                  av_init_packet(). If avpkt->data is NULL, the encoder will
 + *                  allocate it. The encoder will set avpkt->size to the size
 + *                  of the output packet.
   *
   *                  If this function fails or produces no output, avpkt will be
   *                  freed using av_free_packet() (i.e. avpkt->destruct will be
@@@ -4264,19 -4063,42 +4265,19 @@@ int avpicture_alloc(AVPicture *picture
  void avpicture_free(AVPicture *picture);
  
  /**
 - * Fill in the AVPicture fields.
 - * The fields of the given AVPicture are filled in by using the 'ptr' address
 - * which points to the image data buffer. Depending on the specified picture
 - * format, one or multiple image data pointers and line sizes will be set.
 - * If a planar format is specified, several pointers will be set pointing to
 - * the different picture planes and the line sizes of the different planes
 - * will be stored in the lines_sizes array.
 - * Call with ptr == NULL to get the required size for the ptr buffer.
 - *
 - * To allocate the buffer and fill in the AVPicture fields in one call,
 - * use avpicture_alloc().
 + * Fill in the AVPicture fields, always assume a linesize alignment of
 + * 1.
   *
 - * @param picture AVPicture whose fields are to be filled in
 - * @param ptr Buffer which will contain or contains the actual image data
 - * @param pix_fmt The format in which the picture data is stored.
 - * @param width the width of the image in pixels
 - * @param height the height of the image in pixels
 - * @return size of the image data in bytes
 + * @see av_image_fill_arrays()
   */
  int avpicture_fill(AVPicture *picture, uint8_t *ptr,
                     enum PixelFormat pix_fmt, int width, int height);
  
  /**
 - * Copy pixel data from an AVPicture into a buffer.
 - * The data is stored compactly, without any gaps for alignment or padding
 - * which may be applied by avpicture_fill().
 + * Copy pixel data from an AVPicture into a buffer, always assume a
 + * linesize alignment of 1.
   *
 - * @see avpicture_get_size()
 - *
 - * @param[in] src AVPicture containing image data
 - * @param[in] pix_fmt The format in which the picture data is stored.
 - * @param[in] width the width of the image in pixels.
 - * @param[in] height the height of the image in pixels.
 - * @param[out] dest A buffer into which picture data will be copied.
 - * @param[in] dest_size The size of 'dest'.
 - * @return The number of bytes written to dest, or a negative value (error code) on error.
 + * @see av_image_copy_to_buffer()
   */
  int avpicture_layout(const AVPicture* src, enum PixelFormat pix_fmt, int width, int height,
                       unsigned char *dest, int dest_size);
  /**
   * Calculate the size in bytes that a picture of the given width and height
   * would occupy if stored in the given picture format.
 - * Note that this returns the size of a compact representation as generated
 - * by avpicture_layout(), which can be smaller than the size required for e.g.
 - * avpicture_fill().
 + * Always assume a linesize alignment of 1.
   *
 - * @param pix_fmt the given picture format
 - * @param width the width of the image
 - * @param height the height of the image
 - * @return Image data size in bytes or -1 on error (e.g. too large dimensions).
 + * @see av_image_get_buffer_size().
   */
  int avpicture_get_size(enum PixelFormat pix_fmt, int width, int height);
  
  int avpicture_deinterlace(AVPicture *dst, const AVPicture *src,
                            enum PixelFormat pix_fmt, int width, int height);
  /**
 - * Copy image src to dst. Wraps av_picture_data_copy() above.
 + * Copy image src to dst. Wraps av_image_copy().
   */
  void av_picture_copy(AVPicture *dst, const AVPicture *src,
                       enum PixelFormat pix_fmt, int width, int height);
@@@ -4364,8 -4191,7 +4365,8 @@@ unsigned int avcodec_pix_fmt_to_codec_t
   * @param[in] dst_pix_fmt destination pixel format
   * @param[in] src_pix_fmt source pixel format
   * @param[in] has_alpha Whether the source pixel format alpha channel is used.
 - * @return Combination of flags informing you what kind of losses will occur.
 + * @return Combination of flags informing you what kind of losses will occur
 + * (maximum loss for an invalid dst_pix_fmt).
   */
  int avcodec_get_pix_fmt_loss(enum PixelFormat dst_pix_fmt, enum PixelFormat src_pix_fmt,
                               int has_alpha);
   * The pixel formats from which it chooses one, are determined by the
   * pix_fmt_mask parameter.
   *
 + * Note, only the first 64 pixel formats will fit in pix_fmt_mask.
 + *
   * @code
   * src_pix_fmt = PIX_FMT_YUV420P;
 - * pix_fmt_mask = (1 << PIX_FMT_YUV422P) || (1 << PIX_FMT_RGB24);
 + * pix_fmt_mask = (1 << PIX_FMT_YUV422P) | (1 << PIX_FMT_RGB24);
   * dst_pix_fmt = avcodec_find_best_pix_fmt(pix_fmt_mask, src_pix_fmt, alpha, &loss);
   * @endcode
   *
  enum PixelFormat avcodec_find_best_pix_fmt(int64_t pix_fmt_mask, enum PixelFormat src_pix_fmt,
                                int has_alpha, int *loss_ptr);
  
 +/**
 + * Find the best pixel format to convert to given a certain source pixel
 + * format and a selection of two destination pixel formats. When converting from
 + * one pixel format to another, information loss may occur.  For example, when converting
 + * from RGB24 to GRAY, the color information will be lost. Similarly, other losses occur when
 + * converting from some formats to other formats. avcodec_find_best_pix_fmt2() selects which of
 + * the given pixel formats should be used to suffer the least amount of loss.
 + *
 + * If one of the destination formats is PIX_FMT_NONE the other pixel format (if valid) will be
 + * returned.
 + *
 + * @code
 + * src_pix_fmt = PIX_FMT_YUV420P;
 + * dst_pix_fmt1= PIX_FMT_RGB24;
 + * dst_pix_fmt2= PIX_FMT_GRAY8;
 + * dst_pix_fmt3= PIX_FMT_RGB8;
 + * loss= FF_LOSS_CHROMA; // don't care about chroma loss, so chroma loss will be ignored.
 + * dst_pix_fmt = avcodec_find_best_pix_fmt2(dst_pix_fmt1, dst_pix_fmt2, src_pix_fmt, alpha, &loss);
 + * dst_pix_fmt = avcodec_find_best_pix_fmt2(dst_pix_fmt, dst_pix_fmt3, src_pix_fmt, alpha, &loss);
 + * @endcode
 + *
 + * @param[in] dst_pix_fmt1 One of the two destination pixel formats to choose from
 + * @param[in] dst_pix_fmt2 The other of the two destination pixel formats to choose from
 + * @param[in] src_pix_fmt Source pixel format
 + * @param[in] has_alpha Whether the source pixel format alpha channel is used.
 + * @param[in, out] loss_ptr Combination of loss flags. In: selects which of the losses to ignore, i.e.
 + *                               NULL or value of zero means we care about all losses. Out: the loss
 + *                               that occurs when converting from src to selected dst pixel format.
 + * @return The best pixel format to convert to or -1 if none was found.
 + */
 +enum PixelFormat avcodec_find_best_pix_fmt2(enum PixelFormat dst_pix_fmt1, enum PixelFormat dst_pix_fmt2,
 +                                            enum PixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
 +
  enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum PixelFormat * fmt);
  
  /**
@@@ -4498,14 -4289,6 +4499,14 @@@ void avcodec_default_free_buffers(AVCod
  int av_get_bits_per_sample(enum CodecID codec_id);
  
  /**
 + * Return the PCM codec associated with a sample format.
 + * @param be  endianness, 0 for little, 1 for big,
 + *            -1 (or anything else) for native
 + * @return  CODEC_ID_PCM_* or CODEC_ID_NONE
 + */
 +enum CodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be);
 +
 +/**
   * Return codec bits per sample.
   * Only return non-zero if the bits per sample is exactly correct, not an
   * approximation.
@@@ -4579,11 -4362,11 +4580,11 @@@ void *av_fast_realloc(void *ptr, unsign
  void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size);
  
  /**
 - * Allocate a buffer with padding, reusing the given one if large enough.
 - *
   * Same behaviour av_fast_malloc but the buffer has additional
 - * FF_INPUT_PADDING_SIZE at the end which will always memset to 0.
 + * FF_INPUT_PADDING_SIZE at the end which will will always be 0.
   *
 + * In addition the whole buffer will initially and after resizes
 + * be 0-initialized so that no uninitialized data will ever appear.
   */
  void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size);
  
@@@ -4598,7 -4381,7 +4599,7 @@@ unsigned int av_xiphlacing(unsigned cha
  
  /**
   * Log a generic warning message about a missing feature. This function is
 - * intended to be used internally by Libav (libavcodec, libavformat, etc.)
 + * intended to be used internally by FFmpeg (libavcodec, libavformat, etc.)
   * only, and would normally not be used by applications.
   * @param[in] avc a pointer to an arbitrary struct of which the first field is
   * a pointer to an AVClass struct
@@@ -4612,7 -4395,7 +4613,7 @@@ void av_log_missing_feature(void *avc, 
  
  /**
   * Log a generic warning message asking for a sample. This function is
 - * intended to be used internally by Libav (libavcodec, libavformat, etc.)
 + * intended to be used internally by FFmpeg (libavcodec, libavformat, etc.)
   * only, and would normally not be used by applications.
   * @param[in] avc a pointer to an arbitrary struct of which the first field is
   * a pointer to an AVClass struct
@@@ -4649,7 -4432,7 +4650,7 @@@ enum AVLockOp 
   * lockmgr should store/get a pointer to a user allocated mutex. It's
   * NULL upon AV_LOCK_CREATE and != NULL for all other ops.
   *
 - * @param cb User defined callback. Note: Libav may invoke calls to this
 + * @param cb User defined callback. Note: FFmpeg may invoke calls to this
   *           callback during the call to av_lockmgr_register().
   *           Thus, the application must be prepared to handle that.
   *           If cb is set to NULL the lockmgr will be unregistered.
@@@ -4664,12 -4447,6 +4665,12 @@@ int av_lockmgr_register(int (*cb)(void 
  enum AVMediaType avcodec_get_type(enum CodecID codec_id);
  
  /**
 + * Get the name of a codec.
 + * @return  a static string identifying the codec; never NULL
 + */
 +const char *avcodec_get_name(enum CodecID id);
 +
 +/**
   * @return a positive value if s is open (i.e. avcodec_open2() was called on it
   * with no corresponding avcodec_close()), 0 otherwise.
   */
diff --combined libavcodec/dsicinav.c
@@@ -2,20 -2,20 +2,20 @@@
   * Delphine Software International CIN Audio/Video Decoders
   * Copyright (c) 2006 Gregory Montoir (cyx@users.sourceforge.net)
   *
 - * 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
   */
  
@@@ -95,7 -95,6 +95,7 @@@ static av_cold int cinvideo_decode_init
      cin->avctx = avctx;
      avctx->pix_fmt = PIX_FMT_PAL8;
  
 +    avcodec_get_frame_defaults(&cin->frame);
      cin->frame.data[0] = NULL;
  
      cin->bitmap_size = avctx->width * avctx->height;
@@@ -122,7 -121,7 +122,7 @@@ static int cin_decode_huffman(const uns
      unsigned char *dst_end = dst + dst_size;
      const unsigned char *src_end = src + src_size;
  
-     memcpy(huff_code_table, src, 15); src += 15; src_size -= 15;
+     memcpy(huff_code_table, src, 15); src += 15;
  
      while (src < src_end) {
          huff_code = *src++;
@@@ -179,29 -178,24 +179,29 @@@ static int cin_decode_lzss(const unsign
      return 0;
  }
  
 -static void cin_decode_rle(const unsigned char *src, int src_size, unsigned char *dst, int dst_size)
 +static int cin_decode_rle(const unsigned char *src, int src_size, unsigned char *dst, int dst_size)
  {
      int len, code;
      unsigned char *dst_end = dst + dst_size;
      const unsigned char *src_end = src + src_size;
  
 -    while (src < src_end && dst < dst_end) {
 +    while (src + 1 < src_end && dst < dst_end) {
          code = *src++;
          if (code & 0x80) {
              len = code - 0x7F;
              memset(dst, *src++, FFMIN(len, dst_end - dst));
          } else {
              len = code + 1;
 +            if (len > src_end-src) {
 +                av_log(0, AV_LOG_ERROR, "RLE overread\n");
 +                return AVERROR_INVALIDDATA;
 +            }
              memcpy(dst, src, FFMIN(len, dst_end - dst));
              src += len;
          }
          dst += len;
      }
 +    return 0;
  }
  
  static int cinvideo_decode_frame(AVCodecContext *avctx,
          if (palette_colors_count > 256)
              return AVERROR_INVALIDDATA;
          for (i = 0; i < palette_colors_count; ++i) {
 -            cin->palette[i] = bytestream_get_le24(&buf);
 +            cin->palette[i] = 0xFF << 24 | bytestream_get_le24(&buf);
              bitmap_frame_size -= 3;
          }
      } else {
          for (i = 0; i < palette_colors_count; ++i) {
 -            cin->palette[buf[0]] = AV_RL24(buf+1);
 +            cin->palette[buf[0]] = 0xFF << 24 | AV_RL24(buf+1);
              buf += 4;
              bitmap_frame_size -= 4;
          }
diff --combined libavcodec/mss3.c
index 0000000,37d8aee..4f33984
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,967 +1,967 @@@
 - * This file is part of Libav.
+ /*
+  * Microsoft Screen 3 (aka Microsoft ATC Screen) decoder
+  * Copyright (c) 2012 Konstantin Shishkov
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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 FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ /**
+  * @file
+  * Microsoft Screen 3 (aka Microsoft ATC Screen) decoder
+  */
+ #include "avcodec.h"
+ #include "bytestream.h"
+ #define HEADER_SIZE 27
+ #define MODEL2_SCALE       13
+ #define MODEL_SCALE        15
+ #define MODEL256_SEC_SCALE  9
+ typedef struct Model2 {
+     int      upd_val, till_rescale;
+     unsigned zero_freq,  zero_weight;
+     unsigned total_freq, total_weight;
+ } Model2;
+ typedef struct Model {
+     int weights[16], freqs[16];
+     int num_syms;
+     int tot_weight;
+     int upd_val, max_upd_val, till_rescale;
+ } Model;
+ typedef struct Model256 {
+     int weights[256], freqs[256];
+     int tot_weight;
+     int secondary[68];
+     int sec_size;
+     int upd_val, max_upd_val, till_rescale;
+ } Model256;
+ #define RAC_BOTTOM 0x01000000
+ typedef struct RangeCoder {
+     const uint8_t *src, *src_end;
+     uint32_t range, low;
+     int got_error;
+ } RangeCoder;
+ enum BlockType {
+     FILL_BLOCK = 0,
+     IMAGE_BLOCK,
+     DCT_BLOCK,
+     HAAR_BLOCK,
+     SKIP_BLOCK
+ };
+ typedef struct BlockTypeContext {
+     int      last_type;
+     Model    bt_model[5];
+ } BlockTypeContext;
+ typedef struct FillBlockCoder {
+     int      fill_val;
+     Model    coef_model;
+ } FillBlockCoder;
+ typedef struct ImageBlockCoder {
+     Model256 esc_model, vec_entry_model;
+     Model    vec_size_model;
+     Model    vq_model[125];
+ } ImageBlockCoder;
+ typedef struct DCTBlockCoder {
+     int      *prev_dc;
+     int      prev_dc_stride;
+     int      prev_dc_height;
+     int      quality;
+     uint16_t qmat[64];
+     Model    dc_model;
+     Model2   sign_model;
+     Model256 ac_model;
+ } DCTBlockCoder;
+ typedef struct HaarBlockCoder {
+     int      quality, scale;
+     Model256 coef_model;
+     Model    coef_hi_model;
+ } HaarBlockCoder;
+ typedef struct MSS3Context {
+     AVCodecContext   *avctx;
+     AVFrame          pic;
+     int              got_error;
+     RangeCoder       coder;
+     BlockTypeContext btype[3];
+     FillBlockCoder   fill_coder[3];
+     ImageBlockCoder  image_coder[3];
+     DCTBlockCoder    dct_coder[3];
+     HaarBlockCoder   haar_coder[3];
+     int              dctblock[64];
+     int              hblock[16 * 16];
+ } MSS3Context;
+ static const uint8_t mss3_luma_quant[64] = {
+     16,  11,  10,  16,  24,  40,  51,  61,
+     12,  12,  14,  19,  26,  58,  60,  55,
+     14,  13,  16,  24,  40,  57,  69,  56,
+     14,  17,  22,  29,  51,  87,  80,  62,
+     18,  22,  37,  56,  68, 109, 103,  77,
+     24,  35,  55,  64,  81, 104, 113,  92,
+     49,  64,  78,  87, 103, 121, 120, 101,
+     72,  92,  95,  98, 112, 100, 103,  99
+ };
+ static const uint8_t mss3_chroma_quant[64] = {
+     17, 18, 24, 47, 99, 99, 99, 99,
+     18, 21, 26, 66, 99, 99, 99, 99,
+     24, 26, 56, 99, 99, 99, 99, 99,
+     47, 66, 99, 99, 99, 99, 99, 99,
+     99, 99, 99, 99, 99, 99, 99, 99,
+     99, 99, 99, 99, 99, 99, 99, 99,
+     99, 99, 99, 99, 99, 99, 99, 99,
+     99, 99, 99, 99, 99, 99, 99, 99
+ };
+ const uint8_t zigzag_scan[64] = {
+     0,   1,  8, 16,  9,  2,  3, 10,
+     17, 24, 32, 25, 18, 11,  4,  5,
+     12, 19, 26, 33, 40, 48, 41, 34,
+     27, 20, 13,  6,  7, 14, 21, 28,
+     35, 42, 49, 56, 57, 50, 43, 36,
+     29, 22, 15, 23, 30, 37, 44, 51,
+     58, 59, 52, 45, 38, 31, 39, 46,
+     53, 60, 61, 54, 47, 55, 62, 63
+ };
+ static void model2_reset(Model2 *m)
+ {
+     m->zero_weight  = 1;
+     m->total_weight = 2;
+     m->zero_freq    = 0x1000;
+     m->total_freq   = 0x2000;
+     m->upd_val      = 4;
+     m->till_rescale = 4;
+ }
+ static void model2_update(Model2 *m, int bit)
+ {
+     unsigned scale;
+     if (!bit)
+         m->zero_weight++;
+     m->till_rescale--;
+     if (m->till_rescale)
+         return;
+     m->total_weight += m->upd_val;
+     if (m->total_weight > 0x2000) {
+         m->total_weight = (m->total_weight + 1) >> 1;
+         m->zero_weight  = (m->zero_weight  + 1) >> 1;
+         if (m->total_weight == m->zero_weight)
+             m->total_weight = m->zero_weight + 1;
+     }
+     m->upd_val = m->upd_val * 5 >> 2;
+     if (m->upd_val > 64)
+         m->upd_val = 64;
+     scale = 0x80000000u / m->total_weight;
+     m->zero_freq    = m->zero_weight  * scale >> 18;
+     m->total_freq   = m->total_weight * scale >> 18;
+     m->till_rescale = m->upd_val;
+ }
+ static void model_update(Model *m, int val)
+ {
+     int i, sum = 0;
+     unsigned scale;
+     m->weights[val]++;
+     m->till_rescale--;
+     if (m->till_rescale)
+         return;
+     m->tot_weight += m->upd_val;
+     if (m->tot_weight > 0x8000) {
+         m->tot_weight = 0;
+         for (i = 0; i < m->num_syms; i++) {
+             m->weights[i]  = (m->weights[i] + 1) >> 1;
+             m->tot_weight +=  m->weights[i];
+         }
+     }
+     scale = 0x80000000u / m->tot_weight;
+     for (i = 0; i < m->num_syms; i++) {
+         m->freqs[i] = sum * scale >> 16;
+         sum += m->weights[i];
+     }
+     m->upd_val = m->upd_val * 5 >> 2;
+     if (m->upd_val > m->max_upd_val)
+         m->upd_val = m->max_upd_val;
+     m->till_rescale = m->upd_val;
+ }
+ static void model_reset(Model *m)
+ {
+     int i;
+     m->tot_weight   = 0;
+     for (i = 0; i < m->num_syms - 1; i++)
+         m->weights[i] = 1;
+     m->weights[m->num_syms - 1] = 0;
+     m->upd_val      = m->num_syms;
+     m->till_rescale = 1;
+     model_update(m, m->num_syms - 1);
+     m->till_rescale =
+     m->upd_val      = (m->num_syms + 6) >> 1;
+ }
+ static av_cold void model_init(Model *m, int num_syms)
+ {
+     m->num_syms    = num_syms;
+     m->max_upd_val = 8 * num_syms + 48;
+     model_reset(m);
+ }
+ static void model256_update(Model256 *m, int val)
+ {
+     int i, sum = 0;
+     unsigned scale;
+     int send, sidx = 1;
+     m->weights[val]++;
+     m->till_rescale--;
+     if (m->till_rescale)
+         return;
+     m->tot_weight += m->upd_val;
+     if (m->tot_weight > 0x8000) {
+         m->tot_weight = 0;
+         for (i = 0; i < 256; i++) {
+             m->weights[i]  = (m->weights[i] + 1) >> 1;
+             m->tot_weight +=  m->weights[i];
+         }
+     }
+     scale = 0x80000000u / m->tot_weight;
+     m->secondary[0] = 0;
+     for (i = 0; i < 256; i++) {
+         m->freqs[i] = sum * scale >> 16;
+         sum += m->weights[i];
+         send = m->freqs[i] >> MODEL256_SEC_SCALE;
+         while (sidx <= send)
+             m->secondary[sidx++] = i - 1;
+     }
+     while (sidx < m->sec_size)
+         m->secondary[sidx++] = 255;
+     m->upd_val = m->upd_val * 5 >> 2;
+     if (m->upd_val > m->max_upd_val)
+         m->upd_val = m->max_upd_val;
+     m->till_rescale = m->upd_val;
+ }
+ static void model256_reset(Model256 *m)
+ {
+     int i;
+     for (i = 0; i < 255; i++)
+         m->weights[i] = 1;
+     m->weights[255] = 0;
+     m->tot_weight   = 0;
+     m->upd_val      = 256;
+     m->till_rescale = 1;
+     model256_update(m, 255);
+     m->till_rescale =
+     m->upd_val      = (256 + 6) >> 1;
+ }
+ static av_cold void model256_init(Model256 *m)
+ {
+     m->max_upd_val = 8 * 256 + 48;
+     m->sec_size    = (1 << 6) + 2;
+     model256_reset(m);
+ }
+ static void rac_init(RangeCoder *c, const uint8_t *src, int size)
+ {
+     int i;
+     c->src       = src;
+     c->src_end   = src + size;
+     c->low       = 0;
+     for (i = 0; i < FFMIN(size, 4); i++)
+         c->low = (c->low << 8) | *c->src++;
+     c->range     = 0xFFFFFFFF;
+     c->got_error = 0;
+ }
+ static void rac_normalise(RangeCoder *c)
+ {
+     for (;;) {
+         c->range <<= 8;
+         c->low   <<= 8;
+         if (c->src < c->src_end) {
+             c->low |= *c->src++;
+         } else if (!c->low) {
+             c->got_error = 1;
+             return;
+         }
+         if (c->range >= RAC_BOTTOM)
+             return;
+     }
+ }
+ static int rac_get_bit(RangeCoder *c)
+ {
+     int bit;
+     c->range >>= 1;
+     bit = (c->range <= c->low);
+     if (bit)
+         c->low -= c->range;
+     if (c->range < RAC_BOTTOM)
+         rac_normalise(c);
+     return bit;
+ }
+ static int rac_get_bits(RangeCoder *c, int nbits)
+ {
+     int val;
+     c->range >>= nbits;
+     val = c->low / c->range;
+     c->low -= c->range * val;
+     if (c->range < RAC_BOTTOM)
+         rac_normalise(c);
+     return val;
+ }
+ static int rac_get_model2_sym(RangeCoder *c, Model2 *m)
+ {
+     int bit, helper;
+     helper = m->zero_freq * (c->range >> MODEL2_SCALE);
+     bit    = (c->low >= helper);
+     if (bit) {
+         c->low   -= helper;
+         c->range -= helper;
+     } else {
+         c->range  = helper;
+     }
+     if (c->range < RAC_BOTTOM)
+         rac_normalise(c);
+     model2_update(m, bit);
+     return bit;
+ }
+ static int rac_get_model_sym(RangeCoder *c, Model *m)
+ {
+     int prob, prob2, helper, val;
+     int end, end2;
+     prob       = 0;
+     prob2      = c->range;
+     c->range >>= MODEL_SCALE;
+     val        = 0;
+     end        = m->num_syms >> 1;
+     end2       = m->num_syms;
+     do {
+         helper = m->freqs[end] * c->range;
+         if (helper <= c->low) {
+             val   = end;
+             prob  = helper;
+         } else {
+             end2  = end;
+             prob2 = helper;
+         }
+         end = (end2 + val) >> 1;
+     } while (end != val);
+     c->low  -= prob;
+     c->range = prob2 - prob;
+     if (c->range < RAC_BOTTOM)
+         rac_normalise(c);
+     model_update(m, val);
+     return val;
+ }
+ static int rac_get_model256_sym(RangeCoder *c, Model256 *m)
+ {
+     int prob, prob2, helper, val;
+     int start, end;
+     int ssym;
+     prob2      = c->range;
+     c->range >>= MODEL_SCALE;
+     helper     = c->low / c->range;
+     ssym       = helper >> MODEL256_SEC_SCALE;
+     val        = m->secondary[ssym];
+     end = start = m->secondary[ssym + 1] + 1;
+     while (end > val + 1) {
+         ssym = (end + val) >> 1;
+         if (m->freqs[ssym] <= helper) {
+             end = start;
+             val = ssym;
+         } else {
+             end   = (end + val) >> 1;
+             start = ssym;
+         }
+     }
+     prob = m->freqs[val] * c->range;
+     if (val != 255)
+         prob2 = m->freqs[val + 1] * c->range;
+     c->low  -= prob;
+     c->range = prob2 - prob;
+     if (c->range < RAC_BOTTOM)
+         rac_normalise(c);
+     model256_update(m, val);
+     return val;
+ }
+ static int decode_block_type(RangeCoder *c, BlockTypeContext *bt)
+ {
+     bt->last_type = rac_get_model_sym(c, &bt->bt_model[bt->last_type]);
+     return bt->last_type;
+ }
+ static int decode_coeff(RangeCoder *c, Model *m)
+ {
+     int val, sign;
+     val = rac_get_model_sym(c, m);
+     if (val) {
+         sign = rac_get_bit(c);
+         if (val > 1) {
+             val--;
+             val = (1 << val) + rac_get_bits(c, val);
+         }
+         if (!sign)
+             val = -val;
+     }
+     return val;
+ }
+ static void decode_fill_block(RangeCoder *c, FillBlockCoder *fc,
+                               uint8_t *dst, int stride, int block_size)
+ {
+     int i;
+     fc->fill_val += decode_coeff(c, &fc->coef_model);
+     for (i = 0; i < block_size; i++, dst += stride)
+         memset(dst, fc->fill_val, block_size);
+ }
+ static void decode_image_block(RangeCoder *c, ImageBlockCoder *ic,
+                                uint8_t *dst, int stride, int block_size)
+ {
+     int i, j;
+     int vec_size;
+     int vec[4];
+     int prev_line[16];
+     int A, B, C;
+     vec_size = rac_get_model_sym(c, &ic->vec_size_model) + 2;
+     for (i = 0; i < vec_size; i++)
+         vec[i] = rac_get_model256_sym(c, &ic->vec_entry_model);
+     for (; i < 4; i++)
+         vec[i] = 0;
+     memset(prev_line, 0, sizeof(prev_line));
+     for (j = 0; j < block_size; j++) {
+         A = 0;
+         B = 0;
+         for (i = 0; i < block_size; i++) {
+             C = B;
+             B = prev_line[i];
+             A = rac_get_model_sym(c, &ic->vq_model[A + B * 5 + C * 25]);
+             prev_line[i] = A;
+             if (A < 4)
+                dst[i] = vec[A];
+             else
+                dst[i] = rac_get_model256_sym(c, &ic->esc_model);
+         }
+         dst += stride;
+     }
+ }
+ static int decode_dct(RangeCoder *c, DCTBlockCoder *bc, int *block,
+                       int bx, int by)
+ {
+     int skip, val, sign, pos = 1, zz_pos, dc;
+     int blk_pos = bx + by * bc->prev_dc_stride;
+     memset(block, 0, sizeof(*block) * 64);
+     dc = decode_coeff(c, &bc->dc_model);
+     if (by) {
+         if (bx) {
+             int l, tl, t;
+             l  = bc->prev_dc[blk_pos - 1];
+             tl = bc->prev_dc[blk_pos - 1 - bc->prev_dc_stride];
+             t  = bc->prev_dc[blk_pos     - bc->prev_dc_stride];
+             if (FFABS(t - tl) <= FFABS(l - tl))
+                 dc += l;
+             else
+                 dc += t;
+         } else {
+             dc += bc->prev_dc[blk_pos - bc->prev_dc_stride];
+         }
+     } else if (bx) {
+         dc += bc->prev_dc[bx - 1];
+     }
+     bc->prev_dc[blk_pos] = dc;
+     block[0]             = dc * bc->qmat[0];
+     while (pos < 64) {
+         val = rac_get_model256_sym(c, &bc->ac_model);
+         if (!val)
+             return 0;
+         if (val == 0xF0) {
+             pos += 16;
+             continue;
+         }
+         skip = val >> 4;
+         val  = val & 0xF;
+         if (!val)
+             return -1;
+         pos += skip;
+         if (pos >= 64)
+             return -1;
+         sign = rac_get_model2_sym(c, &bc->sign_model);
+         if (val > 1) {
+             val--;
+             val = (1 << val) + rac_get_bits(c, val);
+         }
+         if (!sign)
+             val = -val;
+         zz_pos = zigzag_scan[pos];
+         block[zz_pos] = val * bc->qmat[zz_pos];
+         pos++;
+     }
+     return pos == 64 ? 0 : -1;
+ }
+ #define DCT_TEMPLATE(blk, step, SOP, shift)                         \
+     const int t0 = -39409 * blk[7 * step] -  58980 * blk[1 * step]; \
+     const int t1 =  39410 * blk[1 * step] -  58980 * blk[7 * step]; \
+     const int t2 = -33410 * blk[5 * step] - 167963 * blk[3 * step]; \
+     const int t3 =  33410 * blk[3 * step] - 167963 * blk[5 * step]; \
+     const int t4 =          blk[3 * step] +          blk[7 * step]; \
+     const int t5 =          blk[1 * step] +          blk[5 * step]; \
+     const int t6 =  77062 * t4            +  51491 * t5;            \
+     const int t7 =  77062 * t5            -  51491 * t4;            \
+     const int t8 =  35470 * blk[2 * step] -  85623 * blk[6 * step]; \
+     const int t9 =  35470 * blk[6 * step] +  85623 * blk[2 * step]; \
+     const int tA = SOP(blk[0 * step] - blk[4 * step]);              \
+     const int tB = SOP(blk[0 * step] + blk[4 * step]);              \
+                                                                     \
+     blk[0 * step] = (  t1 + t6  + t9 + tB) >> shift;                \
+     blk[1 * step] = (  t3 + t7  + t8 + tA) >> shift;                \
+     blk[2 * step] = (  t2 + t6  - t8 + tA) >> shift;                \
+     blk[3 * step] = (  t0 + t7  - t9 + tB) >> shift;                \
+     blk[4 * step] = (-(t0 + t7) - t9 + tB) >> shift;                \
+     blk[5 * step] = (-(t2 + t6) - t8 + tA) >> shift;                \
+     blk[6 * step] = (-(t3 + t7) + t8 + tA) >> shift;                \
+     blk[7 * step] = (-(t1 + t6) + t9 + tB) >> shift;                \
+ #define SOP_ROW(a) ((a) << 16) + 0x2000
+ #define SOP_COL(a) ((a + 32) << 16)
+ static void dct_put(uint8_t *dst, int stride, int *block)
+ {
+     int i, j;
+     int *ptr;
+     ptr = block;
+     for (i = 0; i < 8; i++) {
+         DCT_TEMPLATE(ptr, 1, SOP_ROW, 13);
+         ptr += 8;
+     }
+     ptr = block;
+     for (i = 0; i < 8; i++) {
+         DCT_TEMPLATE(ptr, 8, SOP_COL, 22);
+         ptr++;
+     }
+     ptr = block;
+     for (j = 0; j < 8; j++) {
+         for (i = 0; i < 8; i++)
+             dst[i] = av_clip_uint8(ptr[i] + 128);
+         dst += stride;
+         ptr += 8;
+     }
+ }
+ static void decode_dct_block(RangeCoder *c, DCTBlockCoder *bc,
+                              uint8_t *dst, int stride, int block_size,
+                              int *block, int mb_x, int mb_y)
+ {
+     int i, j;
+     int bx, by;
+     int nblocks = block_size >> 3;
+     bx = mb_x * nblocks;
+     by = mb_y * nblocks;
+     for (j = 0; j < nblocks; j++) {
+         for (i = 0; i < nblocks; i++) {
+             if (decode_dct(c, bc, block, bx + i, by + j)) {
+                 c->got_error = 1;
+                 return;
+             }
+             dct_put(dst + i * 8, stride, block);
+         }
+         dst += 8 * stride;
+     }
+ }
+ static void decode_haar_block(RangeCoder *c, HaarBlockCoder *hc,
+                               uint8_t *dst, int stride, int block_size,
+                               int *block)
+ {
+     const int hsize = block_size >> 1;
+     int A, B, C, D, t1, t2, t3, t4;
+     int i, j;
+     for (j = 0; j < block_size; j++) {
+         for (i = 0; i < block_size; i++) {
+             if (i < hsize && j < hsize)
+                 block[i] = rac_get_model256_sym(c, &hc->coef_model);
+             else
+                 block[i] = decode_coeff(c, &hc->coef_hi_model);
+             block[i] *= hc->scale;
+         }
+         block += block_size;
+     }
+     block -= block_size * block_size;
+     for (j = 0; j < hsize; j++) {
+         for (i = 0; i < hsize; i++) {
+             A = block[i];
+             B = block[i + hsize];
+             C = block[i + hsize * block_size];
+             D = block[i + hsize * block_size + hsize];
+             t1 = A - B;
+             t2 = C - D;
+             t3 = A + B;
+             t4 = C + D;
+             dst[i * 2]              = av_clip_uint8(t1 - t2);
+             dst[i * 2 + stride]     = av_clip_uint8(t1 + t2);
+             dst[i * 2 + 1]          = av_clip_uint8(t3 - t4);
+             dst[i * 2 + 1 + stride] = av_clip_uint8(t3 + t4);
+         }
+         block += block_size;
+         dst   += stride * 2;
+     }
+ }
+ static void gen_quant_mat(uint16_t *qmat, const uint8_t *ref, float scale)
+ {
+     int i;
+     for (i = 0; i < 64; i++)
+         qmat[i] = (uint16_t)(ref[i] * scale + 50.0) / 100;
+ }
+ static void reset_coders(MSS3Context *ctx, int quality)
+ {
+     int i, j;
+     for (i = 0; i < 3; i++) {
+         ctx->btype[i].last_type = SKIP_BLOCK;
+         for (j = 0; j < 5; j++)
+             model_reset(&ctx->btype[i].bt_model[j]);
+         ctx->fill_coder[i].fill_val = 0;
+         model_reset(&ctx->fill_coder[i].coef_model);
+         model256_reset(&ctx->image_coder[i].esc_model);
+         model256_reset(&ctx->image_coder[i].vec_entry_model);
+         model_reset(&ctx->image_coder[i].vec_size_model);
+         for (j = 0; j < 125; j++)
+             model_reset(&ctx->image_coder[i].vq_model[j]);
+         if (ctx->dct_coder[i].quality != quality) {
+             float scale;
+             ctx->dct_coder[i].quality = quality;
+             if (quality > 50)
+                 scale = 200.0f - 2 * quality;
+             else
+                 scale = 5000.0f / quality;
+             gen_quant_mat(ctx->dct_coder[i].qmat,
+                           i ? mss3_chroma_quant : mss3_luma_quant,
+                           scale);
+         }
+         memset(ctx->dct_coder[i].prev_dc, 0,
+                sizeof(*ctx->dct_coder[i].prev_dc) *
+                ctx->dct_coder[i].prev_dc_stride *
+                ctx->dct_coder[i].prev_dc_height);
+         model_reset(&ctx->dct_coder[i].dc_model);
+         model2_reset(&ctx->dct_coder[i].sign_model);
+         model256_reset(&ctx->dct_coder[i].ac_model);
+         if (ctx->haar_coder[i].quality != quality) {
+             ctx->haar_coder[i].quality = quality;
+             ctx->haar_coder[i].scale   = 17 - 7 * quality / 50;
+         }
+         model_reset(&ctx->haar_coder[i].coef_hi_model);
+         model256_reset(&ctx->haar_coder[i].coef_model);
+     }
+ }
+ static av_cold void init_coders(MSS3Context *ctx)
+ {
+     int i, j;
+     for (i = 0; i < 3; i++) {
+         for (j = 0; j < 5; j++)
+             model_init(&ctx->btype[i].bt_model[j], 5);
+         model_init(&ctx->fill_coder[i].coef_model, 12);
+         model256_init(&ctx->image_coder[i].esc_model);
+         model256_init(&ctx->image_coder[i].vec_entry_model);
+         model_init(&ctx->image_coder[i].vec_size_model, 3);
+         for (j = 0; j < 125; j++)
+             model_init(&ctx->image_coder[i].vq_model[j], 5);
+         model_init(&ctx->dct_coder[i].dc_model, 12);
+         model256_init(&ctx->dct_coder[i].ac_model);
+         model_init(&ctx->haar_coder[i].coef_hi_model, 12);
+         model256_init(&ctx->haar_coder[i].coef_model);
+     }
+ }
+ static int mss3_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
+                              AVPacket *avpkt)
+ {
+     const uint8_t *buf = avpkt->data;
+     int buf_size = avpkt->size;
+     MSS3Context *c = avctx->priv_data;
+     RangeCoder *acoder = &c->coder;
+     GetByteContext gb;
+     uint8_t *dst[3];
+     int dec_width, dec_height, dec_x, dec_y, quality, keyframe;
+     int x, y, i, mb_width, mb_height, blk_size, btype;
+     int ret;
+     if (buf_size < HEADER_SIZE) {
+         av_log(avctx, AV_LOG_ERROR,
+                "Frame should have at least %d bytes, got %d instead\n",
+                HEADER_SIZE, buf_size);
+         return AVERROR_INVALIDDATA;
+     }
+     bytestream2_init(&gb, buf, buf_size);
+     keyframe   = bytestream2_get_be32(&gb);
+     if (keyframe & ~0x301) {
+         av_log(avctx, AV_LOG_ERROR, "Invalid frame type %X\n", keyframe);
+         return AVERROR_INVALIDDATA;
+     }
+     keyframe   = !(keyframe & 1);
+     bytestream2_skip(&gb, 6);
+     dec_x      = bytestream2_get_be16(&gb);
+     dec_y      = bytestream2_get_be16(&gb);
+     dec_width  = bytestream2_get_be16(&gb);
+     dec_height = bytestream2_get_be16(&gb);
+     if (dec_x + dec_width > avctx->width ||
+         dec_y + dec_height > avctx->height ||
+         (dec_width | dec_height) & 0xF) {
+         av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d +%d,%d\n",
+                dec_width, dec_height, dec_x, dec_y);
+         return AVERROR_INVALIDDATA;
+     }
+     bytestream2_skip(&gb, 4);
+     quality    = bytestream2_get_byte(&gb);
+     if (quality < 1 || quality > 100) {
+         av_log(avctx, AV_LOG_ERROR, "Invalid quality setting %d\n", quality);
+         return AVERROR_INVALIDDATA;
+     }
+     bytestream2_skip(&gb, 4);
+     if (keyframe && !bytestream2_get_bytes_left(&gb)) {
+         av_log(avctx, AV_LOG_ERROR, "Keyframe without data found\n");
+         return AVERROR_INVALIDDATA;
+     }
+     if (!keyframe && c->got_error)
+         return buf_size;
+     c->got_error = 0;
+     c->pic.reference    = 3;
+     c->pic.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE |
+                           FF_BUFFER_HINTS_REUSABLE;
+     if ((ret = avctx->reget_buffer(avctx, &c->pic)) < 0) {
+         av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
+         return ret;
+     }
+     c->pic.key_frame = keyframe;
+     c->pic.pict_type = keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
+     if (!bytestream2_get_bytes_left(&gb)) {
+         *data_size = sizeof(AVFrame);
+         *(AVFrame*)data = c->pic;
+         return buf_size;
+     }
+     reset_coders(c, quality);
+     rac_init(acoder, buf + HEADER_SIZE, buf_size - HEADER_SIZE);
+     mb_width  = dec_width  >> 4;
+     mb_height = dec_height >> 4;
+     dst[0] = c->pic.data[0] + dec_x     +  dec_y      * c->pic.linesize[0];
+     dst[1] = c->pic.data[1] + dec_x / 2 + (dec_y / 2) * c->pic.linesize[1];
+     dst[2] = c->pic.data[2] + dec_x / 2 + (dec_y / 2) * c->pic.linesize[2];
+     for (y = 0; y < mb_height; y++) {
+         for (x = 0; x < mb_width; x++) {
+             for (i = 0; i < 3; i++) {
+                 blk_size = 8 << !i;
+                 btype = decode_block_type(acoder, c->btype + i);
+                 switch (btype) {
+                 case FILL_BLOCK:
+                     decode_fill_block(acoder, c->fill_coder + i,
+                                       dst[i] + x * blk_size,
+                                       c->pic.linesize[i], blk_size);
+                     break;
+                 case IMAGE_BLOCK:
+                     decode_image_block(acoder, c->image_coder + i,
+                                        dst[i] + x * blk_size,
+                                        c->pic.linesize[i], blk_size);
+                     break;
+                 case DCT_BLOCK:
+                     decode_dct_block(acoder, c->dct_coder + i,
+                                      dst[i] + x * blk_size,
+                                      c->pic.linesize[i], blk_size,
+                                      c->dctblock, x, y);
+                     break;
+                 case HAAR_BLOCK:
+                     decode_haar_block(acoder, c->haar_coder + i,
+                                       dst[i] + x * blk_size,
+                                       c->pic.linesize[i], blk_size,
+                                       c->hblock);
+                     break;
+                 }
+                 if (c->got_error || acoder->got_error) {
+                     av_log(avctx, AV_LOG_ERROR, "Error decoding block %d,%d\n",
+                            x, y);
+                     c->got_error = 1;
+                     return AVERROR_INVALIDDATA;
+                 }
+             }
+         }
+         dst[0] += c->pic.linesize[0] * 16;
+         dst[1] += c->pic.linesize[1] * 8;
+         dst[2] += c->pic.linesize[2] * 8;
+     }
+     *data_size = sizeof(AVFrame);
+     *(AVFrame*)data = c->pic;
+     return buf_size;
+ }
+ static av_cold int mss3_decode_init(AVCodecContext *avctx)
+ {
+     MSS3Context * const c = avctx->priv_data;
+     int i;
+     c->avctx = avctx;
+     if ((avctx->width & 0xF) || (avctx->height & 0xF)) {
+         av_log(avctx, AV_LOG_ERROR,
+                "Image dimensions should be a multiple of 16.\n");
+         return AVERROR_INVALIDDATA;
+     }
+     c->got_error = 0;
+     for (i = 0; i < 3; i++) {
+         int b_width  = avctx->width  >> (2 + !!i);
+         int b_height = avctx->height >> (2 + !!i);
+         c->dct_coder[i].prev_dc_stride = b_width;
+         c->dct_coder[i].prev_dc_height = b_height;
+         c->dct_coder[i].prev_dc = av_malloc(sizeof(*c->dct_coder[i].prev_dc) *
+                                             b_width * b_height);
+         if (!c->dct_coder[i].prev_dc) {
+             av_log(avctx, AV_LOG_ERROR, "Cannot allocate buffer\n");
+             while (i >= 0) {
+                 av_freep(&c->dct_coder[i].prev_dc);
+                 i--;
+             }
+             return AVERROR(ENOMEM);
+         }
+     }
+     avctx->pix_fmt     = PIX_FMT_YUV420P;
+     avctx->coded_frame = &c->pic;
+     init_coders(c);
+     return 0;
+ }
+ static av_cold int mss3_decode_end(AVCodecContext *avctx)
+ {
+     MSS3Context * const c = avctx->priv_data;
+     int i;
+     if (c->pic.data[0])
+         avctx->release_buffer(avctx, &c->pic);
+     for (i = 0; i < 3; i++)
+         av_freep(&c->dct_coder[i].prev_dc);
+     return 0;
+ }
+ AVCodec ff_msa1_decoder = {
+     .name           = "msa1",
+     .type           = AVMEDIA_TYPE_VIDEO,
+     .id             = CODEC_ID_MSA1,
+     .priv_data_size = sizeof(MSS3Context),
+     .init           = mss3_decode_init,
+     .close          = mss3_decode_end,
+     .decode         = mss3_decode_frame,
+     .capabilities   = CODEC_CAP_DR1,
+     .long_name      = NULL_IF_CONFIG_SMALL("MS ATC Screen"),
+ };
index b5339c6,0000000..7755d71
mode 100644,000000..100644
--- /dev/null
@@@ -1,1036 -1,0 +1,1035 @@@
-     int mbs_per_slice = ctx->mbs_per_slice;
 +/*
 + * Apple ProRes encoder
 + *
 + * Copyright (c) 2012 Konstantin Shishkov
 + *
 + * This encoder appears to be based on Anatoliy Wassermans considering
 + * similarities in the bugs.
 + *
 + * This file is part of Libav.
 + *
 + * Libav 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,
 + * 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
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +#include "libavutil/opt.h"
 +#include "avcodec.h"
 +#include "put_bits.h"
 +#include "bytestream.h"
 +#include "internal.h"
 +#include "proresdsp.h"
 +#include "proresdata.h"
 +
 +#define CFACTOR_Y422 2
 +#define CFACTOR_Y444 3
 +
 +#define MAX_MBS_PER_SLICE 8
 +
 +#define MAX_PLANES 3 // should be increased to 4 when there's PIX_FMT_YUV444AP10
 +
 +enum {
 +    PRORES_PROFILE_PROXY = 0,
 +    PRORES_PROFILE_LT,
 +    PRORES_PROFILE_STANDARD,
 +    PRORES_PROFILE_HQ,
 +};
 +
 +enum {
 +    QUANT_MAT_PROXY = 0,
 +    QUANT_MAT_LT,
 +    QUANT_MAT_STANDARD,
 +    QUANT_MAT_HQ,
 +    QUANT_MAT_DEFAULT,
 +};
 +
 +static const uint8_t prores_quant_matrices[][64] = {
 +    { // proxy
 +         4,  7,  9, 11, 13, 14, 15, 63,
 +         7,  7, 11, 12, 14, 15, 63, 63,
 +         9, 11, 13, 14, 15, 63, 63, 63,
 +        11, 11, 13, 14, 63, 63, 63, 63,
 +        11, 13, 14, 63, 63, 63, 63, 63,
 +        13, 14, 63, 63, 63, 63, 63, 63,
 +        13, 63, 63, 63, 63, 63, 63, 63,
 +        63, 63, 63, 63, 63, 63, 63, 63,
 +    },
 +    { // LT
 +         4,  5,  6,  7,  9, 11, 13, 15,
 +         5,  5,  7,  8, 11, 13, 15, 17,
 +         6,  7,  9, 11, 13, 15, 15, 17,
 +         7,  7,  9, 11, 13, 15, 17, 19,
 +         7,  9, 11, 13, 14, 16, 19, 23,
 +         9, 11, 13, 14, 16, 19, 23, 29,
 +         9, 11, 13, 15, 17, 21, 28, 35,
 +        11, 13, 16, 17, 21, 28, 35, 41,
 +    },
 +    { // standard
 +         4,  4,  5,  5,  6,  7,  7,  9,
 +         4,  4,  5,  6,  7,  7,  9,  9,
 +         5,  5,  6,  7,  7,  9,  9, 10,
 +         5,  5,  6,  7,  7,  9,  9, 10,
 +         5,  6,  7,  7,  8,  9, 10, 12,
 +         6,  7,  7,  8,  9, 10, 12, 15,
 +         6,  7,  7,  9, 10, 11, 14, 17,
 +         7,  7,  9, 10, 11, 14, 17, 21,
 +    },
 +    { // high quality
 +         4,  4,  4,  4,  4,  4,  4,  4,
 +         4,  4,  4,  4,  4,  4,  4,  4,
 +         4,  4,  4,  4,  4,  4,  4,  4,
 +         4,  4,  4,  4,  4,  4,  4,  5,
 +         4,  4,  4,  4,  4,  4,  5,  5,
 +         4,  4,  4,  4,  4,  5,  5,  6,
 +         4,  4,  4,  4,  5,  5,  6,  7,
 +         4,  4,  4,  4,  5,  6,  7,  7,
 +    },
 +    { // codec default
 +         4,  4,  4,  4,  4,  4,  4,  4,
 +         4,  4,  4,  4,  4,  4,  4,  4,
 +         4,  4,  4,  4,  4,  4,  4,  4,
 +         4,  4,  4,  4,  4,  4,  4,  4,
 +         4,  4,  4,  4,  4,  4,  4,  4,
 +         4,  4,  4,  4,  4,  4,  4,  4,
 +         4,  4,  4,  4,  4,  4,  4,  4,
 +         4,  4,  4,  4,  4,  4,  4,  4,
 +    },
 +};
 +
 +#define NUM_MB_LIMITS 4
 +static const int prores_mb_limits[NUM_MB_LIMITS] = {
 +    1620, // up to 720x576
 +    2700, // up to 960x720
 +    6075, // up to 1440x1080
 +    9216, // up to 2048x1152
 +};
 +
 +static const struct prores_profile {
 +    const char *full_name;
 +    uint32_t    tag;
 +    int         min_quant;
 +    int         max_quant;
 +    int         br_tab[NUM_MB_LIMITS];
 +    int         quant;
 +} prores_profile_info[4] = {
 +    {
 +        .full_name = "proxy",
 +        .tag       = MKTAG('a', 'p', 'c', 'o'),
 +        .min_quant = 4,
 +        .max_quant = 8,
 +        .br_tab    = { 300, 242, 220, 194 },
 +        .quant     = QUANT_MAT_PROXY,
 +    },
 +    {
 +        .full_name = "LT",
 +        .tag       = MKTAG('a', 'p', 'c', 's'),
 +        .min_quant = 1,
 +        .max_quant = 9,
 +        .br_tab    = { 720, 560, 490, 440 },
 +        .quant     = QUANT_MAT_LT,
 +    },
 +    {
 +        .full_name = "standard",
 +        .tag       = MKTAG('a', 'p', 'c', 'n'),
 +        .min_quant = 1,
 +        .max_quant = 6,
 +        .br_tab    = { 1050, 808, 710, 632 },
 +        .quant     = QUANT_MAT_STANDARD,
 +    },
 +    {
 +        .full_name = "high quality",
 +        .tag       = MKTAG('a', 'p', 'c', 'h'),
 +        .min_quant = 1,
 +        .max_quant = 6,
 +        .br_tab    = { 1566, 1216, 1070, 950 },
 +        .quant     = QUANT_MAT_HQ,
 +    }
 +// for 4444 profile bitrate numbers are { 2350, 1828, 1600, 1425 }
 +};
 +
 +#define TRELLIS_WIDTH 16
 +#define SCORE_LIMIT   INT_MAX / 2
 +
 +struct TrellisNode {
 +    int prev_node;
 +    int quant;
 +    int bits;
 +    int score;
 +};
 +
 +#define MAX_STORED_Q 16
 +
 +typedef struct ProresThreadData {
 +    DECLARE_ALIGNED(16, DCTELEM, blocks)[MAX_PLANES][64 * 4 * MAX_MBS_PER_SLICE];
 +    DECLARE_ALIGNED(16, uint16_t, emu_buf)[16 * 16];
 +    int16_t custom_q[64];
 +    struct TrellisNode *nodes;
 +} ProresThreadData;
 +
 +typedef struct ProresContext {
 +    AVClass *class;
 +    DECLARE_ALIGNED(16, DCTELEM, blocks)[MAX_PLANES][64 * 4 * MAX_MBS_PER_SLICE];
 +    DECLARE_ALIGNED(16, uint16_t, emu_buf)[16*16];
 +    int16_t quants[MAX_STORED_Q][64];
 +    int16_t custom_q[64];
 +    const uint8_t *quant_mat;
 +
 +    ProresDSPContext dsp;
 +    ScanTable  scantable;
 +
 +    int mb_width, mb_height;
 +    int mbs_per_slice;
 +    int num_chroma_blocks, chroma_factor;
 +    int slices_width;
 +    int num_slices;
 +    int num_planes;
 +    int bits_per_mb;
 +    int force_quant;
 +
 +    char *vendor;
 +    int quant_sel;
 +
 +    int frame_size;
 +
 +    int profile;
 +    const struct prores_profile *profile_info;
 +
 +    int *slice_q;
 +
 +    ProresThreadData *tdata;
 +} ProresContext;
 +
 +static void get_slice_data(ProresContext *ctx, const uint16_t *src,
 +                           int linesize, int x, int y, int w, int h,
 +                           DCTELEM *blocks, uint16_t *emu_buf,
 +                           int mbs_per_slice, int blocks_per_mb, int is_chroma)
 +{
 +    const uint16_t *esrc;
 +    const int mb_width = 4 * blocks_per_mb;
 +    int elinesize;
 +    int i, j, k;
 +
 +    for (i = 0; i < mbs_per_slice; i++, src += mb_width) {
 +        if (x >= w) {
 +            memset(blocks, 0, 64 * (mbs_per_slice - i) * blocks_per_mb
 +                              * sizeof(*blocks));
 +            return;
 +        }
 +        if (x + mb_width <= w && y + 16 <= h) {
 +            esrc      = src;
 +            elinesize = linesize;
 +        } else {
 +            int bw, bh, pix;
 +
 +            esrc      = emu_buf;
 +            elinesize = 16 * sizeof(*emu_buf);
 +
 +            bw = FFMIN(w - x, mb_width);
 +            bh = FFMIN(h - y, 16);
 +
 +            for (j = 0; j < bh; j++) {
 +                memcpy(emu_buf + j * 16,
 +                       (const uint8_t*)src + j * linesize,
 +                       bw * sizeof(*src));
 +                pix = emu_buf[j * 16 + bw - 1];
 +                for (k = bw; k < mb_width; k++)
 +                    emu_buf[j * 16 + k] = pix;
 +            }
 +            for (; j < 16; j++)
 +                memcpy(emu_buf + j * 16,
 +                       emu_buf + (bh - 1) * 16,
 +                       mb_width * sizeof(*emu_buf));
 +        }
 +        if (!is_chroma) {
 +            ctx->dsp.fdct(esrc, elinesize, blocks);
 +            blocks += 64;
 +            if (blocks_per_mb > 2) {
 +                ctx->dsp.fdct(src + 8, linesize, blocks);
 +                blocks += 64;
 +            }
 +            ctx->dsp.fdct(src + linesize * 4, linesize, blocks);
 +            blocks += 64;
 +            if (blocks_per_mb > 2) {
 +                ctx->dsp.fdct(src + linesize * 4 + 8, linesize, blocks);
 +                blocks += 64;
 +            }
 +        } else {
 +            ctx->dsp.fdct(esrc, elinesize, blocks);
 +            blocks += 64;
 +            ctx->dsp.fdct(src + linesize * 4, linesize, blocks);
 +            blocks += 64;
 +            if (blocks_per_mb > 2) {
 +                ctx->dsp.fdct(src + 8, linesize, blocks);
 +                blocks += 64;
 +                ctx->dsp.fdct(src + linesize * 4 + 8, linesize, blocks);
 +                blocks += 64;
 +            }
 +        }
 +
 +        x += mb_width;
 +    }
 +}
 +
 +/**
 + * Write an unsigned rice/exp golomb codeword.
 + */
 +static inline void encode_vlc_codeword(PutBitContext *pb, unsigned codebook, int val)
 +{
 +    unsigned int rice_order, exp_order, switch_bits, switch_val;
 +    int exponent;
 +
 +    /* number of prefix bits to switch between Rice and expGolomb */
 +    switch_bits = (codebook & 3) + 1;
 +    rice_order  =  codebook >> 5;       /* rice code order */
 +    exp_order   = (codebook >> 2) & 7;  /* exp golomb code order */
 +
 +    switch_val  = switch_bits << rice_order;
 +
 +    if (val >= switch_val) {
 +        val -= switch_val - (1 << exp_order);
 +        exponent = av_log2(val);
 +
 +        put_bits(pb, exponent - exp_order + switch_bits, 0);
 +        put_bits(pb, exponent + 1, val);
 +    } else {
 +        exponent = val >> rice_order;
 +
 +        if (exponent)
 +            put_bits(pb, exponent, 0);
 +        put_bits(pb, 1, 1);
 +        if (rice_order)
 +            put_sbits(pb, rice_order, val);
 +    }
 +}
 +
 +#define GET_SIGN(x)  ((x) >> 31)
 +#define MAKE_CODE(x) (((x) << 1) ^ GET_SIGN(x))
 +
 +static void encode_dcs(PutBitContext *pb, DCTELEM *blocks,
 +                       int blocks_per_slice, int scale)
 +{
 +    int i;
 +    int codebook = 3, code, dc, prev_dc, delta, sign, new_sign;
 +
 +    prev_dc = (blocks[0] - 0x4000) / scale;
 +    encode_vlc_codeword(pb, FIRST_DC_CB, MAKE_CODE(prev_dc));
 +    sign     = 0;
 +    codebook = 3;
 +    blocks  += 64;
 +
 +    for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
 +        dc       = (blocks[0] - 0x4000) / scale;
 +        delta    = dc - prev_dc;
 +        new_sign = GET_SIGN(delta);
 +        delta    = (delta ^ sign) - sign;
 +        code     = MAKE_CODE(delta);
 +        encode_vlc_codeword(pb, ff_prores_dc_codebook[codebook], code);
 +        codebook = (code + (code & 1)) >> 1;
 +        codebook = FFMIN(codebook, 3);
 +        sign     = new_sign;
 +        prev_dc  = dc;
 +    }
 +}
 +
 +static void encode_acs(PutBitContext *pb, DCTELEM *blocks,
 +                       int blocks_per_slice,
 +                       int plane_size_factor,
 +                       const uint8_t *scan, const int16_t *qmat)
 +{
 +    int idx, i;
 +    int run, level, run_cb, lev_cb;
 +    int max_coeffs, abs_level;
 +
 +    max_coeffs = blocks_per_slice << 6;
 +    run_cb     = ff_prores_run_to_cb_index[4];
 +    lev_cb     = ff_prores_lev_to_cb_index[2];
 +    run        = 0;
 +
 +    for (i = 1; i < 64; i++) {
 +        for (idx = scan[i]; idx < max_coeffs; idx += 64) {
 +            level = blocks[idx] / qmat[scan[i]];
 +            if (level) {
 +                abs_level = FFABS(level);
 +                encode_vlc_codeword(pb, ff_prores_ac_codebook[run_cb], run);
 +                encode_vlc_codeword(pb, ff_prores_ac_codebook[lev_cb],
 +                                    abs_level - 1);
 +                put_sbits(pb, 1, GET_SIGN(level));
 +
 +                run_cb = ff_prores_run_to_cb_index[FFMIN(run, 15)];
 +                lev_cb = ff_prores_lev_to_cb_index[FFMIN(abs_level, 9)];
 +                run    = 0;
 +            } else {
 +                run++;
 +            }
 +        }
 +    }
 +}
 +
 +static int encode_slice_plane(ProresContext *ctx, PutBitContext *pb,
 +                              const uint16_t *src, int linesize,
 +                              int mbs_per_slice, DCTELEM *blocks,
 +                              int blocks_per_mb, int plane_size_factor,
 +                              const int16_t *qmat)
 +{
 +    int blocks_per_slice, saved_pos;
 +
 +    saved_pos = put_bits_count(pb);
 +    blocks_per_slice = mbs_per_slice * blocks_per_mb;
 +
 +    encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
 +    encode_acs(pb, blocks, blocks_per_slice, plane_size_factor,
 +               ctx->scantable.permutated, qmat);
 +    flush_put_bits(pb);
 +
 +    return (put_bits_count(pb) - saved_pos) >> 3;
 +}
 +
 +static int encode_slice(AVCodecContext *avctx, const AVFrame *pic,
 +                        PutBitContext *pb,
 +                        int sizes[4], int x, int y, int quant,
 +                        int mbs_per_slice)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +    int i, xp, yp;
 +    int total_size = 0;
 +    const uint16_t *src;
 +    int slice_width_factor = av_log2(mbs_per_slice);
 +    int num_cblocks, pwidth;
 +    int plane_factor, is_chroma;
 +    uint16_t *qmat;
 +
 +    if (ctx->force_quant) {
 +        qmat = ctx->quants[0];
 +    } else if (quant < MAX_STORED_Q) {
 +        qmat = ctx->quants[quant];
 +    } else {
 +        qmat = ctx->custom_q;
 +        for (i = 0; i < 64; i++)
 +            qmat[i] = ctx->quant_mat[i] * quant;
 +    }
 +
 +    for (i = 0; i < ctx->num_planes; i++) {
 +        is_chroma    = (i == 1 || i == 2);
 +        plane_factor = slice_width_factor + 2;
 +        if (is_chroma)
 +            plane_factor += ctx->chroma_factor - 3;
 +        if (!is_chroma || ctx->chroma_factor == CFACTOR_Y444) {
 +            xp          = x << 4;
 +            yp          = y << 4;
 +            num_cblocks = 4;
 +            pwidth      = avctx->width;
 +        } else {
 +            xp          = x << 3;
 +            yp          = y << 4;
 +            num_cblocks = 2;
 +            pwidth      = avctx->width >> 1;
 +        }
 +        src = (const uint16_t*)(pic->data[i] + yp * pic->linesize[i]) + xp;
 +
 +        get_slice_data(ctx, src, pic->linesize[i], xp, yp,
 +                       pwidth, avctx->height, ctx->blocks[0], ctx->emu_buf,
 +                       mbs_per_slice, num_cblocks, is_chroma);
 +        sizes[i] = encode_slice_plane(ctx, pb, src, pic->linesize[i],
 +                                      mbs_per_slice, ctx->blocks[0],
 +                                      num_cblocks, plane_factor,
 +                                      qmat);
 +        total_size += sizes[i];
 +    }
 +    return total_size;
 +}
 +
 +static inline int estimate_vlc(unsigned codebook, int val)
 +{
 +    unsigned int rice_order, exp_order, switch_bits, switch_val;
 +    int exponent;
 +
 +    /* number of prefix bits to switch between Rice and expGolomb */
 +    switch_bits = (codebook & 3) + 1;
 +    rice_order  =  codebook >> 5;       /* rice code order */
 +    exp_order   = (codebook >> 2) & 7;  /* exp golomb code order */
 +
 +    switch_val  = switch_bits << rice_order;
 +
 +    if (val >= switch_val) {
 +        val -= switch_val - (1 << exp_order);
 +        exponent = av_log2(val);
 +
 +        return exponent * 2 - exp_order + switch_bits + 1;
 +    } else {
 +        return (val >> rice_order) + rice_order + 1;
 +    }
 +}
 +
 +static int estimate_dcs(int *error, DCTELEM *blocks, int blocks_per_slice,
 +                        int scale)
 +{
 +    int i;
 +    int codebook = 3, code, dc, prev_dc, delta, sign, new_sign;
 +    int bits;
 +
 +    prev_dc  = (blocks[0] - 0x4000) / scale;
 +    bits     = estimate_vlc(FIRST_DC_CB, MAKE_CODE(prev_dc));
 +    sign     = 0;
 +    codebook = 3;
 +    blocks  += 64;
 +    *error  += FFABS(blocks[0] - 0x4000) % scale;
 +
 +    for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
 +        dc       = (blocks[0] - 0x4000) / scale;
 +        *error  += FFABS(blocks[0] - 0x4000) % scale;
 +        delta    = dc - prev_dc;
 +        new_sign = GET_SIGN(delta);
 +        delta    = (delta ^ sign) - sign;
 +        code     = MAKE_CODE(delta);
 +        bits    += estimate_vlc(ff_prores_dc_codebook[codebook], code);
 +        codebook = (code + (code & 1)) >> 1;
 +        codebook = FFMIN(codebook, 3);
 +        sign     = new_sign;
 +        prev_dc  = dc;
 +    }
 +
 +    return bits;
 +}
 +
 +static int estimate_acs(int *error, DCTELEM *blocks, int blocks_per_slice,
 +                        int plane_size_factor,
 +                        const uint8_t *scan, const int16_t *qmat)
 +{
 +    int idx, i;
 +    int run, level, run_cb, lev_cb;
 +    int max_coeffs, abs_level;
 +    int bits = 0;
 +
 +    max_coeffs = blocks_per_slice << 6;
 +    run_cb     = ff_prores_run_to_cb_index[4];
 +    lev_cb     = ff_prores_lev_to_cb_index[2];
 +    run        = 0;
 +
 +    for (i = 1; i < 64; i++) {
 +        for (idx = scan[i]; idx < max_coeffs; idx += 64) {
 +            level   = blocks[idx] / qmat[scan[i]];
 +            *error += FFABS(blocks[idx]) % qmat[scan[i]];
 +            if (level) {
 +                abs_level = FFABS(level);
 +                bits += estimate_vlc(ff_prores_ac_codebook[run_cb], run);
 +                bits += estimate_vlc(ff_prores_ac_codebook[lev_cb],
 +                                     abs_level - 1) + 1;
 +
 +                run_cb = ff_prores_run_to_cb_index[FFMIN(run, 15)];
 +                lev_cb = ff_prores_lev_to_cb_index[FFMIN(abs_level, 9)];
 +                run    = 0;
 +            } else {
 +                run++;
 +            }
 +        }
 +    }
 +
 +    return bits;
 +}
 +
 +static int estimate_slice_plane(ProresContext *ctx, int *error, int plane,
 +                                const uint16_t *src, int linesize,
 +                                int mbs_per_slice,
 +                                int blocks_per_mb, int plane_size_factor,
 +                                const int16_t *qmat, ProresThreadData *td)
 +{
 +    int blocks_per_slice;
 +    int bits;
 +
 +    blocks_per_slice = mbs_per_slice * blocks_per_mb;
 +
 +    bits  = estimate_dcs(error, td->blocks[plane], blocks_per_slice, qmat[0]);
 +    bits += estimate_acs(error, td->blocks[plane], blocks_per_slice,
 +                         plane_size_factor, ctx->scantable.permutated, qmat);
 +
 +    return FFALIGN(bits, 8);
 +}
 +
 +static int find_slice_quant(AVCodecContext *avctx, const AVFrame *pic,
 +                            int trellis_node, int x, int y, int mbs_per_slice,
 +                            ProresThreadData *td)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +    int i, q, pq, xp, yp;
 +    const uint16_t *src;
 +    int slice_width_factor = av_log2(mbs_per_slice);
 +    int num_cblocks[MAX_PLANES], pwidth;
 +    int plane_factor[MAX_PLANES], is_chroma[MAX_PLANES];
 +    const int min_quant = ctx->profile_info->min_quant;
 +    const int max_quant = ctx->profile_info->max_quant;
 +    int error, bits, bits_limit;
 +    int mbs, prev, cur, new_score;
 +    int slice_bits[TRELLIS_WIDTH], slice_score[TRELLIS_WIDTH];
 +    int overquant;
 +    uint16_t *qmat;
 +
 +    mbs = x + mbs_per_slice;
 +
 +    for (i = 0; i < ctx->num_planes; i++) {
 +        is_chroma[i]    = (i == 1 || i == 2);
 +        plane_factor[i] = slice_width_factor + 2;
 +        if (is_chroma[i])
 +            plane_factor[i] += ctx->chroma_factor - 3;
 +        if (!is_chroma[i] || ctx->chroma_factor == CFACTOR_Y444) {
 +            xp             = x << 4;
 +            yp             = y << 4;
 +            num_cblocks[i] = 4;
 +            pwidth         = avctx->width;
 +        } else {
 +            xp             = x << 3;
 +            yp             = y << 4;
 +            num_cblocks[i] = 2;
 +            pwidth         = avctx->width >> 1;
 +        }
 +        src = (const uint16_t*)(pic->data[i] + yp * pic->linesize[i]) + xp;
 +
 +        get_slice_data(ctx, src, pic->linesize[i], xp, yp,
 +                       pwidth, avctx->height, td->blocks[i], td->emu_buf,
 +                       mbs_per_slice, num_cblocks[i], is_chroma[i]);
 +    }
 +
 +    for (q = min_quant; q < max_quant + 2; q++) {
 +        td->nodes[trellis_node + q].prev_node = -1;
 +        td->nodes[trellis_node + q].quant     = q;
 +    }
 +
 +    // todo: maybe perform coarser quantising to fit into frame size when needed
 +    for (q = min_quant; q <= max_quant; q++) {
 +        bits  = 0;
 +        error = 0;
 +        for (i = 0; i < ctx->num_planes; i++) {
 +            bits += estimate_slice_plane(ctx, &error, i,
 +                                         src, pic->linesize[i],
 +                                         mbs_per_slice,
 +                                         num_cblocks[i], plane_factor[i],
 +                                         ctx->quants[q], td);
 +        }
 +        if (bits > 65000 * 8) {
 +            error = SCORE_LIMIT;
 +            break;
 +        }
 +        slice_bits[q]  = bits;
 +        slice_score[q] = error;
 +    }
 +    if (slice_bits[max_quant] <= ctx->bits_per_mb * mbs_per_slice) {
 +        slice_bits[max_quant + 1]  = slice_bits[max_quant];
 +        slice_score[max_quant + 1] = slice_score[max_quant] + 1;
 +        overquant = max_quant;
 +    } else {
 +        for (q = max_quant + 1; q < 128; q++) {
 +            bits  = 0;
 +            error = 0;
 +            if (q < MAX_STORED_Q) {
 +                qmat = ctx->quants[q];
 +            } else {
 +                qmat = td->custom_q;
 +                for (i = 0; i < 64; i++)
 +                    qmat[i] = ctx->quant_mat[i] * q;
 +            }
 +            for (i = 0; i < ctx->num_planes; i++) {
 +                bits += estimate_slice_plane(ctx, &error, i,
 +                                             src, pic->linesize[i],
 +                                             mbs_per_slice,
 +                                             num_cblocks[i], plane_factor[i],
 +                                             qmat, td);
 +            }
 +            if (bits <= ctx->bits_per_mb * mbs_per_slice)
 +                break;
 +        }
 +
 +        slice_bits[max_quant + 1]  = bits;
 +        slice_score[max_quant + 1] = error;
 +        overquant = q;
 +    }
 +    td->nodes[trellis_node + max_quant + 1].quant = overquant;
 +
 +    bits_limit = mbs * ctx->bits_per_mb;
 +    for (pq = min_quant; pq < max_quant + 2; pq++) {
 +        prev = trellis_node - TRELLIS_WIDTH + pq;
 +
 +        for (q = min_quant; q < max_quant + 2; q++) {
 +            cur = trellis_node + q;
 +
 +            bits  = td->nodes[prev].bits + slice_bits[q];
 +            error = slice_score[q];
 +            if (bits > bits_limit)
 +                error = SCORE_LIMIT;
 +
 +            if (td->nodes[prev].score < SCORE_LIMIT && error < SCORE_LIMIT)
 +                new_score = td->nodes[prev].score + error;
 +            else
 +                new_score = SCORE_LIMIT;
 +            if (td->nodes[cur].prev_node == -1 ||
 +                td->nodes[cur].score >= new_score) {
 +
 +                td->nodes[cur].bits      = bits;
 +                td->nodes[cur].score     = new_score;
 +                td->nodes[cur].prev_node = prev;
 +            }
 +        }
 +    }
 +
 +    error = td->nodes[trellis_node + min_quant].score;
 +    pq    = trellis_node + min_quant;
 +    for (q = min_quant + 1; q < max_quant + 2; q++) {
 +        if (td->nodes[trellis_node + q].score <= error) {
 +            error = td->nodes[trellis_node + q].score;
 +            pq    = trellis_node + q;
 +        }
 +    }
 +
 +    return pq;
 +}
 +
 +static int find_quant_thread(AVCodecContext *avctx, void *arg,
 +                             int jobnr, int threadnr)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +    ProresThreadData *td = ctx->tdata + threadnr;
 +    int mbs_per_slice = ctx->mbs_per_slice;
 +    int x, y = jobnr, mb, q = 0;
 +
 +    for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
 +        while (ctx->mb_width - x < mbs_per_slice)
 +            mbs_per_slice >>= 1;
 +        q = find_slice_quant(avctx, avctx->coded_frame,
 +                             (mb + 1) * TRELLIS_WIDTH, x, y,
 +                             mbs_per_slice, td);
 +    }
 +
 +    for (x = ctx->slices_width - 1; x >= 0; x--) {
 +        ctx->slice_q[x + y * ctx->slices_width] = td->nodes[q].quant;
 +        q = td->nodes[q].prev_node;
 +    }
 +
 +    return 0;
 +}
 +
 +static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
 +                        const AVFrame *pic, int *got_packet)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +    uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *tmp;
 +    uint8_t *picture_size_pos;
 +    PutBitContext pb;
 +    int x, y, i, mb, q = 0;
 +    int sizes[4] = { 0 };
 +    int slice_hdr_size = 2 + 2 * (ctx->num_planes - 1);
 +    int frame_size, picture_size, slice_size;
-         mbs_per_slice = ctx->mbs_per_slice;
 +    int pkt_size, ret;
 +
 +    *avctx->coded_frame           = *pic;
 +    avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
 +    avctx->coded_frame->key_frame = 1;
 +
 +    pkt_size = ctx->frame_size + FF_MIN_BUFFER_SIZE;
 +
 +    if ((ret = ff_alloc_packet2(avctx, pkt, pkt_size)) < 0)
 +        return ret;
 +
 +    orig_buf = pkt->data;
 +
 +    // frame atom
 +    orig_buf += 4;                              // frame size
 +    bytestream_put_be32  (&orig_buf, FRAME_ID); // frame container ID
 +    buf = orig_buf;
 +
 +    // frame header
 +    tmp = buf;
 +    buf += 2;                                   // frame header size will be stored here
 +    bytestream_put_be16  (&buf, 0);             // version 1
 +    bytestream_put_buffer(&buf, ctx->vendor, 4);
 +    bytestream_put_be16  (&buf, avctx->width);
 +    bytestream_put_be16  (&buf, avctx->height);
 +    bytestream_put_byte  (&buf, ctx->chroma_factor << 6); // frame flags
 +    bytestream_put_byte  (&buf, 0);             // reserved
 +    bytestream_put_byte  (&buf, avctx->color_primaries);
 +    bytestream_put_byte  (&buf, avctx->color_trc);
 +    bytestream_put_byte  (&buf, avctx->colorspace);
 +    bytestream_put_byte  (&buf, 0x40);          // source format and alpha information
 +    bytestream_put_byte  (&buf, 0);             // reserved
 +    if (ctx->quant_sel != QUANT_MAT_DEFAULT) {
 +        bytestream_put_byte  (&buf, 0x03);      // matrix flags - both matrices are present
 +        // luma quantisation matrix
 +        for (i = 0; i < 64; i++)
 +            bytestream_put_byte(&buf, ctx->quant_mat[i]);
 +        // chroma quantisation matrix
 +        for (i = 0; i < 64; i++)
 +            bytestream_put_byte(&buf, ctx->quant_mat[i]);
 +    } else {
 +        bytestream_put_byte  (&buf, 0x00);      // matrix flags - default matrices are used
 +    }
 +    bytestream_put_be16  (&tmp, buf - orig_buf); // write back frame header size
 +
 +    // picture header
 +    picture_size_pos = buf + 1;
 +    bytestream_put_byte  (&buf, 0x40);          // picture header size (in bits)
 +    buf += 4;                                   // picture data size will be stored here
 +    bytestream_put_be16  (&buf, ctx->num_slices); // total number of slices
 +    bytestream_put_byte  (&buf, av_log2(ctx->mbs_per_slice) << 4); // slice width and height in MBs
 +
 +    // seek table - will be filled during slice encoding
 +    slice_sizes = buf;
 +    buf += ctx->num_slices * 2;
 +
 +    // slices
 +    if (!ctx->force_quant) {
 +        ret = avctx->execute2(avctx, find_quant_thread, NULL, NULL,
 +                              ctx->mb_height);
 +        if (ret)
 +            return ret;
 +    }
 +
 +    for (y = 0; y < ctx->mb_height; y++) {
++        int mbs_per_slice = ctx->mbs_per_slice;
 +        for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
 +            q = ctx->force_quant ? ctx->force_quant
 +                                 : ctx->slice_q[mb + y * ctx->slices_width];
 +
 +            while (ctx->mb_width - x < mbs_per_slice)
 +                mbs_per_slice >>= 1;
 +
 +            bytestream_put_byte(&buf, slice_hdr_size << 3);
 +            slice_hdr = buf;
 +            buf += slice_hdr_size - 1;
 +            init_put_bits(&pb, buf, (pkt_size - (buf - orig_buf)) * 8);
 +            encode_slice(avctx, pic, &pb, sizes, x, y, q, mbs_per_slice);
 +
 +            bytestream_put_byte(&slice_hdr, q);
 +            slice_size = slice_hdr_size + sizes[ctx->num_planes - 1];
 +            for (i = 0; i < ctx->num_planes - 1; i++) {
 +                bytestream_put_be16(&slice_hdr, sizes[i]);
 +                slice_size += sizes[i];
 +            }
 +            bytestream_put_be16(&slice_sizes, slice_size);
 +            buf += slice_size - slice_hdr_size;
 +        }
 +    }
 +
 +    orig_buf -= 8;
 +    frame_size = buf - orig_buf;
 +    picture_size = buf - picture_size_pos - 6;
 +    bytestream_put_be32(&orig_buf, frame_size);
 +    bytestream_put_be32(&picture_size_pos, picture_size);
 +
 +    pkt->size   = frame_size;
 +    pkt->flags |= AV_PKT_FLAG_KEY;
 +    *got_packet = 1;
 +
 +    return 0;
 +}
 +
 +static av_cold int encode_close(AVCodecContext *avctx)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +    int i;
 +
 +    if (avctx->coded_frame->data[0])
 +        avctx->release_buffer(avctx, avctx->coded_frame);
 +
 +    av_freep(&avctx->coded_frame);
 +
 +    if (ctx->tdata) {
 +        for (i = 0; i < avctx->thread_count; i++)
 +            av_free(ctx->tdata[i].nodes);
 +    }
 +    av_freep(&ctx->tdata);
 +    av_freep(&ctx->slice_q);
 +
 +    return 0;
 +}
 +
 +static av_cold int encode_init(AVCodecContext *avctx)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +    int mps;
 +    int i, j;
 +    int min_quant, max_quant;
 +
 +    avctx->bits_per_raw_sample = 10;
 +    avctx->coded_frame = avcodec_alloc_frame();
 +    if (!avctx->coded_frame)
 +        return AVERROR(ENOMEM);
 +
 +    ff_proresdsp_init(&ctx->dsp, avctx);
 +    ff_init_scantable(ctx->dsp.dct_permutation, &ctx->scantable,
 +                      ff_prores_progressive_scan);
 +
 +    mps = ctx->mbs_per_slice;
 +    if (mps & (mps - 1)) {
 +        av_log(avctx, AV_LOG_ERROR,
 +               "there should be an integer power of two MBs per slice\n");
 +        return AVERROR(EINVAL);
 +    }
 +
 +    ctx->chroma_factor = avctx->pix_fmt == PIX_FMT_YUV422P10
 +                         ? CFACTOR_Y422
 +                         : CFACTOR_Y444;
 +    ctx->profile_info  = prores_profile_info + ctx->profile;
 +    ctx->num_planes    = 3;
 +
 +    ctx->mb_width      = FFALIGN(avctx->width,  16) >> 4;
 +    ctx->mb_height     = FFALIGN(avctx->height, 16) >> 4;
 +    ctx->slices_width  = ctx->mb_width / mps;
 +    ctx->slices_width += av_popcount(ctx->mb_width - ctx->slices_width * mps);
 +    ctx->num_slices    = ctx->mb_height * ctx->slices_width;
 +
 +    if (ctx->quant_sel == -1)
 +        ctx->quant_mat = prores_quant_matrices[ctx->profile_info->quant];
 +    else
 +        ctx->quant_mat = prores_quant_matrices[ctx->quant_sel];
 +
 +    if (strlen(ctx->vendor) != 4) {
 +        av_log(avctx, AV_LOG_ERROR, "vendor ID should be 4 bytes\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    ctx->force_quant = avctx->global_quality / FF_QP2LAMBDA;
 +    if (!ctx->force_quant) {
 +        if (!ctx->bits_per_mb) {
 +            for (i = 0; i < NUM_MB_LIMITS - 1; i++)
 +                if (prores_mb_limits[i] >= ctx->mb_width * ctx->mb_height)
 +                    break;
 +            ctx->bits_per_mb   = ctx->profile_info->br_tab[i];
 +        } else if (ctx->bits_per_mb < 128) {
 +            av_log(avctx, AV_LOG_ERROR, "too few bits per MB, please set at least 128\n");
 +            return AVERROR_INVALIDDATA;
 +        }
 +
 +        min_quant = ctx->profile_info->min_quant;
 +        max_quant = ctx->profile_info->max_quant;
 +        for (i = min_quant; i < MAX_STORED_Q; i++) {
 +            for (j = 0; j < 64; j++)
 +                ctx->quants[i][j] = ctx->quant_mat[j] * i;
 +        }
 +
 +        ctx->slice_q = av_malloc(ctx->num_slices * sizeof(*ctx->slice_q));
 +        if (!ctx->slice_q) {
 +            encode_close(avctx);
 +            return AVERROR(ENOMEM);
 +        }
 +
 +        ctx->tdata = av_mallocz(avctx->thread_count * sizeof(*ctx->tdata));
 +        if (!ctx->tdata) {
 +            encode_close(avctx);
 +            return AVERROR(ENOMEM);
 +        }
 +
 +        for (j = 0; j < avctx->thread_count; j++) {
 +            ctx->tdata[j].nodes = av_malloc((ctx->slices_width + 1)
 +                                            * TRELLIS_WIDTH
 +                                            * sizeof(*ctx->tdata->nodes));
 +            if (!ctx->tdata[j].nodes) {
 +                encode_close(avctx);
 +                return AVERROR(ENOMEM);
 +            }
 +            for (i = min_quant; i < max_quant + 2; i++) {
 +                ctx->tdata[j].nodes[i].prev_node = -1;
 +                ctx->tdata[j].nodes[i].bits      = 0;
 +                ctx->tdata[j].nodes[i].score     = 0;
 +            }
 +        }
 +    } else {
 +        int ls = 0;
 +
 +        if (ctx->force_quant > 64) {
 +            av_log(avctx, AV_LOG_ERROR, "too large quantiser, maximum is 64\n");
 +            return AVERROR_INVALIDDATA;
 +        }
 +
 +        for (j = 0; j < 64; j++) {
 +            ctx->quants[0][j] = ctx->quant_mat[j] * ctx->force_quant;
 +            ls += av_log2((1 << 11)  / ctx->quants[0][j]) * 2 + 1;
 +        }
 +
 +        ctx->bits_per_mb = ls * 8;
 +        if (ctx->chroma_factor == CFACTOR_Y444)
 +            ctx->bits_per_mb += ls * 4;
 +        if (ctx->num_planes == 4)
 +            ctx->bits_per_mb += ls * 4;
 +    }
 +
 +    ctx->frame_size = ctx->num_slices * (2 + 2 * ctx->num_planes
 +                                         + (2 * mps * ctx->bits_per_mb) / 8)
 +                      + 200;
 +
 +    avctx->codec_tag   = ctx->profile_info->tag;
 +
 +    av_log(avctx, AV_LOG_DEBUG, "profile %d, %d slices, %d bits per MB\n",
 +           ctx->profile, ctx->num_slices, ctx->bits_per_mb);
 +    av_log(avctx, AV_LOG_DEBUG, "estimated frame size %d\n",
 +           ctx->frame_size);
 +
 +    return 0;
 +}
 +
 +#define OFFSET(x) offsetof(ProresContext, x)
 +#define VE     AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 +
 +static const AVOption options[] = {
 +    { "mbs_per_slice", "macroblocks per slice", OFFSET(mbs_per_slice),
 +        AV_OPT_TYPE_INT, { 8 }, 1, MAX_MBS_PER_SLICE, VE },
 +    { "profile",       NULL, OFFSET(profile), AV_OPT_TYPE_INT,
 +        { PRORES_PROFILE_STANDARD },
 +        PRORES_PROFILE_PROXY, PRORES_PROFILE_HQ, VE, "profile" },
 +    { "proxy",         NULL, 0, AV_OPT_TYPE_CONST, { PRORES_PROFILE_PROXY },
 +        0, 0, VE, "profile" },
 +    { "lt",            NULL, 0, AV_OPT_TYPE_CONST, { PRORES_PROFILE_LT },
 +        0, 0, VE, "profile" },
 +    { "standard",      NULL, 0, AV_OPT_TYPE_CONST, { PRORES_PROFILE_STANDARD },
 +        0, 0, VE, "profile" },
 +    { "hq",            NULL, 0, AV_OPT_TYPE_CONST, { PRORES_PROFILE_HQ },
 +        0, 0, VE, "profile" },
 +    { "vendor", "vendor ID", OFFSET(vendor),
 +        AV_OPT_TYPE_STRING, { .str = "Lavc" }, CHAR_MIN, CHAR_MAX, VE },
 +    { "bits_per_mb", "desired bits per macroblock", OFFSET(bits_per_mb),
 +        AV_OPT_TYPE_INT, { 0 }, 0, 8192, VE },
 +    { "quant_mat", "quantiser matrix", OFFSET(quant_sel), AV_OPT_TYPE_INT,
 +        { -1 }, -1, QUANT_MAT_DEFAULT, VE, "quant_mat" },
 +    { "auto",          NULL, 0, AV_OPT_TYPE_CONST, { -1 },
 +        0, 0, VE, "quant_mat" },
 +    { "proxy",         NULL, 0, AV_OPT_TYPE_CONST, { QUANT_MAT_PROXY },
 +        0, 0, VE, "quant_mat" },
 +    { "lt",            NULL, 0, AV_OPT_TYPE_CONST, { QUANT_MAT_LT },
 +        0, 0, VE, "quant_mat" },
 +    { "standard",      NULL, 0, AV_OPT_TYPE_CONST, { QUANT_MAT_STANDARD },
 +        0, 0, VE, "quant_mat" },
 +    { "hq",            NULL, 0, AV_OPT_TYPE_CONST, { QUANT_MAT_HQ },
 +        0, 0, VE, "quant_mat" },
 +    { "default",       NULL, 0, AV_OPT_TYPE_CONST, { QUANT_MAT_DEFAULT },
 +        0, 0, VE, "quant_mat" },
 +    { NULL }
 +};
 +
 +static const AVClass proresenc_class = {
 +    .class_name = "ProRes encoder",
 +    .item_name  = av_default_item_name,
 +    .option     = options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
 +AVCodec ff_prores_kostya_encoder = {
 +    .name           = "prores_kostya",
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = CODEC_ID_PRORES,
 +    .priv_data_size = sizeof(ProresContext),
 +    .init           = encode_init,
 +    .close          = encode_close,
 +    .encode2        = encode_frame,
 +    .capabilities   = CODEC_CAP_SLICE_THREADS,
 +    .long_name      = NULL_IF_CONFIG_SMALL("Apple ProRes (iCodec Pro)"),
 +    .pix_fmts       = (const enum PixelFormat[]) {
 +                          PIX_FMT_YUV422P10, PIX_FMT_YUV444P10, PIX_FMT_NONE
 +                      },
 +    .priv_class     = &proresenc_class,
 +};
diff --combined libavcodec/rl2.c
@@@ -2,20 -2,20 +2,20 @@@
   * RL2 Video Decoder
   * Copyright (C) 2008 Sascha Sommer (saschasommer@freenet.de)
   *
 - * 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
   */
  
@@@ -51,7 -51,7 +51,7 @@@ typedef struct Rl2Context 
   * @param s rl2 context
   * @param in input buffer
   * @param size input buffer size
 - * @param out ouput buffer
 + * @param out output buffer
   * @param stride stride of the output buffer
   * @param video_base offset of the rle data inside the frame
   */
@@@ -64,7 -64,7 +64,7 @@@ static void rl2_rle_decode(Rl2Context *
      const unsigned char* back_frame = s->back_frame;
      const unsigned char* in_end = in + size;
      const unsigned char* out_end = out + stride * s->avctx->height;
-     unsigned char* line_end = out + s->avctx->width;
+     unsigned char* line_end;
  
      /** copy start of the background frame */
      for(i=0;i<=base_y;i++){
@@@ -133,7 -133,6 +133,7 @@@ static av_cold int rl2_decode_init(AVCo
      int i;
      s->avctx = avctx;
      avctx->pix_fmt = PIX_FMT_PAL8;
 +    avcodec_get_frame_defaults(&s->frame);
  
      /** parse extra data */
      if(!avctx->extradata || avctx->extradata_size < EXTRADATA1_SIZE){
  
      /** initialize palette */
      for(i=0;i<AVPALETTE_COUNT;i++)
 -        s->palette[i] = AV_RB24(&avctx->extradata[6 + i * 3]);
 +        s->palette[i] = 0xFF << 24 | AV_RB24(&avctx->extradata[6 + i * 3]);
  
      /** decode background frame if present */
      back_size = avctx->extradata_size - EXTRADATA1_SIZE;
diff --combined libavcodec/roqvideo.h
@@@ -2,20 -2,20 +2,20 @@@
   * Copyright (C) 2003 Mike Melanson
   * Copyright (C) 2003 Dr. Tim Ferguson
   *
 - * 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
   */
  
@@@ -45,7 -45,6 +45,6 @@@ struct RoqTempData
  typedef struct RoqContext {
  
      AVCodecContext *avctx;
-     DSPContext dsp;
      AVFrame frames[2];
      AVFrame *last_frame;
      AVFrame *current_frame;
diff --combined libavcodec/smacker.c
@@@ -2,20 -2,20 +2,20 @@@
   * Smacker decoder
   * Copyright (c) 2006 Konstantin Shishkov
   *
 - * 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
   */
  
@@@ -96,10 -96,6 +96,10 @@@ enum SmkBlockTypes 
   */
  static int smacker_decode_tree(GetBitContext *gb, HuffContext *hc, uint32_t prefix, int length)
  {
 +    if(length > 32) {
 +        av_log(NULL, AV_LOG_ERROR, "length too long\n");
 +        return -1;
 +    }
      if(!get_bits1(gb)){ //Leaf
          if(hc->current >= 256){
              av_log(NULL, AV_LOG_ERROR, "Tree size exceeded!\n");
@@@ -137,13 -133,9 +137,9 @@@ static int smacker_decode_bigtree(GetBi
          return -1;
      }
      if(!get_bits1(gb)){ //Leaf
-         int val, i1, i2, b1, b2;
-         b1 = get_bits_count(gb);
+         int val, i1, i2;
          i1 = ctx->v1->table ? get_vlc2(gb, ctx->v1->table, SMKTREE_BITS, 3) : 0;
-         b1 = get_bits_count(gb) - b1;
-         b2 = get_bits_count(gb);
          i2 = ctx->v2->table ? get_vlc2(gb, ctx->v2->table, SMKTREE_BITS, 3) : 0;
-         b2 = get_bits_count(gb) - b2;
          if (i1 < 0 || i2 < 0)
              return -1;
          val = ctx->recode1[i1] | (ctx->recode2[i2] << 8);
  }
  
  /**
 - * Store large tree as Libav's vlc codes
 + * Store large tree as FFmpeg's vlc codes
   */
  static int smacker_decode_header_tree(SmackVContext *smk, GetBitContext *gb, int **recodes, int *last, int size)
  {
      if(ctx.last[0] == -1) ctx.last[0] = huff.current++;
      if(ctx.last[1] == -1) ctx.last[1] = huff.current++;
      if(ctx.last[2] == -1) ctx.last[2] = huff.current++;
 +    if(huff.current > huff.length){
 +        ctx.last[0] = ctx.last[1] = ctx.last[2] = 1;
 +        av_log(smk->avctx, AV_LOG_ERROR, "bigtree damaged\n");
 +        return -1;
 +    }
  
      *recodes = huff.values;
  
@@@ -376,7 -363,7 +372,7 @@@ static int decode_frame(AVCodecContext 
      if (avpkt->size <= 769)
          return 0;
  
 -    smk->pic.reference = 1;
 +    smk->pic.reference = 3;
      smk->pic.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;
      if(avctx->reget_buffer(avctx, &smk->pic) < 0){
          av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
          smk->pic.pict_type = AV_PICTURE_TYPE_P;
  
      for(i = 0; i < 256; i++)
 -        *pal++ = bytestream2_get_be24u(&gb2);
 +        *pal++ = 0xFF << 24 | bytestream2_get_be24u(&gb2);
  
      last_reset(smk->mmap_tbl, smk->mmap_last);
      last_reset(smk->mclr_tbl, smk->mclr_last);
@@@ -530,7 -517,6 +526,7 @@@ static av_cold int decode_init(AVCodecC
  
      avctx->pix_fmt = PIX_FMT_PAL8;
  
 +    avcodec_get_frame_defaults(&c->pic);
  
      /* decode huffman trees from extradata */
      if(avctx->extradata_size < 16){
@@@ -669,26 -655,16 +665,26 @@@ static int smka_decode_frame(AVCodecCon
          for(i = 0; i <= stereo; i++)
              *samples++ = pred[i];
          for(; i < unp_size / 2; i++) {
 +            if(get_bits_left(&gb)<0)
 +                return -1;
              if(i & stereo) {
                  if(vlc[2].table)
                      res = get_vlc2(&gb, vlc[2].table, SMKTREE_BITS, 3);
                  else
                      res = 0;
 +                if (res < 0) {
 +                    av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
 +                    return AVERROR_INVALIDDATA;
 +                }
                  val  = h[2].values[res];
                  if(vlc[3].table)
                      res = get_vlc2(&gb, vlc[3].table, SMKTREE_BITS, 3);
                  else
                      res = 0;
 +                if (res < 0) {
 +                    av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
 +                    return AVERROR_INVALIDDATA;
 +                }
                  val |= h[3].values[res] << 8;
                  pred[1] += sign_extend(val, 16);
                  *samples++ = av_clip_int16(pred[1]);
                      res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
                  else
                      res = 0;
 +                if (res < 0) {
 +                    av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
 +                    return AVERROR_INVALIDDATA;
 +                }
                  val  = h[0].values[res];
                  if(vlc[1].table)
                      res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
                  else
                      res = 0;
 +                if (res < 0) {
 +                    av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
 +                    return AVERROR_INVALIDDATA;
 +                }
                  val |= h[1].values[res] << 8;
                  pred[0] += sign_extend(val, 16);
                  *samples++ = av_clip_int16(pred[0]);
          for(i = 0; i <= stereo; i++)
              *samples8++ = pred[i];
          for(; i < unp_size; i++) {
 +            if(get_bits_left(&gb)<0)
 +                return -1;
              if(i & stereo){
                  if(vlc[1].table)
                      res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
                  else
                      res = 0;
 +                if (res < 0) {
 +                    av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
 +                    return AVERROR_INVALIDDATA;
 +                }
                  pred[1] += sign_extend(h[1].values[res], 8);
                  *samples8++ = av_clip_uint8(pred[1]);
              } else {
                      res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
                  else
                      res = 0;
 +                if (res < 0) {
 +                    av_log(avctx, AV_LOG_ERROR, "invalid vlc\n");
 +                    return AVERROR_INVALIDDATA;
 +                }
                  pred[0] += sign_extend(h[0].values[res], 8);
                  *samples8++ = av_clip_uint8(pred[0]);
              }
diff --combined libavcodec/snow.c
@@@ -1,20 -1,20 +1,20 @@@
  /*
   * Copyright (C) 2004 Michael Niedermayer <michaelni@gmx.at>
   *
 - * 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
   */
  
@@@ -31,6 -31,9 +31,6 @@@
  #include "mathops.h"
  #include "h263.h"
  
 -#undef NDEBUG
 -#include <assert.h>
 -
  
  void ff_snow_inner_add_yblock(const uint8_t *obmc, const int obmc_stride, uint8_t * * block, int b_w, int b_h,
                                int src_x, int src_y, int src_stride, slice_buffer * sb, int add, uint8_t * dst8){
@@@ -140,11 -143,11 +140,11 @@@ static void mc_block(Plane *p, uint8_t 
  
      int x, y, b, r, l;
      int16_t tmpIt   [64*(32+HTAPS_MAX)];
-     uint8_t tmp2t[3][stride*(32+HTAPS_MAX)];
+     uint8_t tmp2t[3][64*(32+HTAPS_MAX)];
      int16_t *tmpI= tmpIt;
      uint8_t *tmp2= tmp2t[0];
      const uint8_t *hpel[11];
 -    assert(dx<16 && dy<16);
 +    av_assert2(dx<16 && dy<16);
      r= brane[dx + 16*dy]&15;
      l= brane[dx + 16*dy]>>4;
  
                  tmp2[x]= am;
              }
              tmpI+= 64;
-             tmp2+= stride;
+             tmp2+= 64;
              src += stride;
          }
          src -= stride*y;
                  tmp2[x]= am;
              }
              src += stride;
-             tmp2+= stride;
+             tmp2+= 64;
          }
          src -= stride*y;
      }
                  tmp2[x]= am;
              }
              tmpI+= 64;
-             tmp2+= stride;
+             tmp2+= 64;
          }
      }
  
      hpel[ 0]= src;
-     hpel[ 1]= tmp2t[0] + stride*(HTAPS_MAX/2-1);
+     hpel[ 1]= tmp2t[0] + 64*(HTAPS_MAX/2-1);
      hpel[ 2]= src + 1;
  
      hpel[ 4]= tmp2t[1];
      hpel[ 6]= tmp2t[1] + 1;
  
      hpel[ 8]= src + stride;
-     hpel[ 9]= hpel[1] + stride;
+     hpel[ 9]= hpel[1] + 64;
      hpel[10]= hpel[8] + 1;
  
+ #define MC_STRIDE(x) (needs[x] ? 64 : stride)
      if(b==15){
-         const uint8_t *src1= hpel[dx/8 + dy/8*4  ];
-         const uint8_t *src2= hpel[dx/8 + dy/8*4+1];
-         const uint8_t *src3= hpel[dx/8 + dy/8*4+4];
-         const uint8_t *src4= hpel[dx/8 + dy/8*4+5];
+         int dxy = dx / 8 + dy / 8 * 4;
+         const uint8_t *src1 = hpel[dxy    ];
+         const uint8_t *src2 = hpel[dxy + 1];
+         const uint8_t *src3 = hpel[dxy + 4];
+         const uint8_t *src4 = hpel[dxy + 5];
+         int stride1 = MC_STRIDE(dxy);
+         int stride2 = MC_STRIDE(dxy + 1);
+         int stride3 = MC_STRIDE(dxy + 4);
+         int stride4 = MC_STRIDE(dxy + 5);
          dx&=7;
          dy&=7;
          for(y=0; y < b_h; y++){
                  dst[x]= ((8-dx)*(8-dy)*src1[x] + dx*(8-dy)*src2[x]+
                           (8-dx)*   dy *src3[x] + dx*   dy *src4[x]+32)>>6;
              }
-             src1+=stride;
-             src2+=stride;
-             src3+=stride;
-             src4+=stride;
+             src1+=stride1;
+             src2+=stride2;
+             src3+=stride3;
+             src4+=stride4;
              dst +=stride;
          }
      }else{
          const uint8_t *src1= hpel[l];
          const uint8_t *src2= hpel[r];
+         int stride1 = MC_STRIDE(l);
+         int stride2 = MC_STRIDE(r);
          int a= weight[((dx&7) + (8*(dy&7)))];
          int b= 8-a;
          for(y=0; y < b_h; y++){
              for(x=0; x < b_w; x++){
                  dst[x]= (a*src1[x] + b*src2[x] + 4)>>3;
              }
-             src1+=stride;
-             src2+=stride;
+             src1+=stride1;
+             src2+=stride2;
              dst +=stride;
          }
      }
@@@ -325,7 -337,7 +334,7 @@@ void ff_snow_pred_block(SnowContext *s
          }
      }else{
          uint8_t *src= s->last_picture[block->ref].data[plane_index];
 -        const int scale= plane_index ?  s->mv_scale : 2*s->mv_scale;
 +        const int scale= plane_index ?  (2*s->mv_scale)>>s->chroma_h_shift : 2*s->mv_scale;
          int mx= block->mx*scale;
          int my= block->my*scale;
          const int dx= mx&15;
              s->dsp.emulated_edge_mc(tmp + MB_SIZE, src, stride, b_w+HTAPS_MAX-1, b_h+HTAPS_MAX-1, sx, sy, w, h);
              src= tmp + MB_SIZE;
          }
 +
 +        av_assert2(s->chroma_h_shift == s->chroma_v_shift); // only one mv_scale
 +
  //        assert(b_w == b_h || 2*b_w == b_h || b_w == 2*b_h);
  //        assert(!(b_w&(b_w-1)));
 -        assert(b_w>1 && b_h>1);
 -        assert((tab_index>=0 && tab_index<4) || b_w==32);
 +        av_assert2(b_w>1 && b_h>1);
 +        av_assert2((tab_index>=0 && tab_index<4) || b_w==32);
          if((dx&3) || (dy&3) || !(b_w == b_h || 2*b_w == b_h || b_w == 2*b_h) || (b_w&(b_w-1)) || !s->plane[plane_index].fast_mc )
              mc_block(&s->plane[plane_index], dst, src, stride, b_w, b_h, dx, dy);
          else if(b_w==32){
              s->dsp.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst    ,src + 3       + 3*stride,stride);
              s->dsp.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst+b_h,src + 3 + b_h + 3*stride,stride);
          }else{
 -            assert(2*b_w==b_h);
 +            av_assert2(2*b_w==b_h);
              s->dsp.put_h264_qpel_pixels_tab[tab_index  ][dy+(dx>>2)](dst           ,src + 3 + 3*stride           ,stride);
              s->dsp.put_h264_qpel_pixels_tab[tab_index  ][dy+(dx>>2)](dst+b_w*stride,src + 3 + 3*stride+b_w*stride,stride);
          }
  
  #define mca(dx,dy,b_w)\
  static void mc_block_hpel ## dx ## dy ## b_w(uint8_t *dst, const uint8_t *src, int stride, int h){\
 -    assert(h==b_w);\
 +    av_assert2(h==b_w);\
      mc_block(NULL, dst, src-(HTAPS_MAX/2-1)-(HTAPS_MAX/2-1)*stride, stride, b_w, b_w, dx, dy);\
  }
  
@@@ -448,7 -457,7 +457,7 @@@ av_cold int ff_snow_common_init(AVCodec
              ff_scale_mv_ref[i][j] = 256*(i+1)/(j+1);
  
      s->avctx->get_buffer(s->avctx, &s->mconly_picture);
 -    s->scratchbuf = av_malloc(s->mconly_picture.linesize[0]*7*MB_SIZE);
 +    s->scratchbuf = av_mallocz(s->mconly_picture.linesize[0]*7*MB_SIZE);
  
      return 0;
  }
@@@ -513,8 -522,8 +522,8 @@@ static void halfpel_interpol(SnowContex
  
      for(p=0; p<3; p++){
          int is_chroma= !!p;
 -        int w= s->avctx->width  >>is_chroma;
 -        int h= s->avctx->height >>is_chroma;
 +        int w= is_chroma ? s->avctx->width >>s->chroma_h_shift : s->avctx->width;
 +        int h= is_chroma ? s->avctx->height>>s->chroma_v_shift : s->avctx->height;
          int ls= frame->linesize[p];
          uint8_t *src= frame->data[p];
  
@@@ -573,11 -582,11 +582,11 @@@ int ff_snow_frame_start(SnowContext *s)
                            s->current_picture.linesize[0], w   , h   ,
                            EDGE_WIDTH  , EDGE_WIDTH  , EDGE_TOP | EDGE_BOTTOM);
          s->dsp.draw_edges(s->current_picture.data[1],
 -                          s->current_picture.linesize[1], w>>1, h>>1,
 -                          EDGE_WIDTH/2, EDGE_WIDTH/2, EDGE_TOP | EDGE_BOTTOM);
 +                          s->current_picture.linesize[1], w>>s->chroma_h_shift, h>>s->chroma_v_shift,
 +                          EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);
          s->dsp.draw_edges(s->current_picture.data[2],
 -                          s->current_picture.linesize[2], w>>1, h>>1,
 -                          EDGE_WIDTH/2, EDGE_WIDTH/2, EDGE_TOP | EDGE_BOTTOM);
 +                          s->current_picture.linesize[2], w>>s->chroma_h_shift, h>>s->chroma_v_shift,
 +                          EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);
      }
  
      ff_snow_release_buffer(s->avctx);
          }
      }
  
 -    s->current_picture.reference= 1;
 +    s->current_picture.reference= 3;
      if(s->avctx->get_buffer(s->avctx, &s->current_picture) < 0){
          av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
          return -1;
@@@ -636,10 -645,8 +645,10 @@@ av_cold void ff_snow_common_end(SnowCon
      for(i=0; i<MAX_REF_FRAMES; i++){
          av_freep(&s->ref_mvs[i]);
          av_freep(&s->ref_scores[i]);
 -        if(s->last_picture[i].data[0])
 +        if(s->last_picture[i].data[0]) {
 +            av_assert0(s->last_picture[i].data[0] != s->current_picture.data[0]);
              s->avctx->release_buffer(s->avctx, &s->last_picture[i]);
 +        }
      }
  
      for(plane_index=0; plane_index<3; plane_index++){
diff --combined libavcodec/snowenc.c
@@@ -1,20 -1,20 +1,20 @@@
  /*
   * Copyright (C) 2004 Michael Niedermayer <michaelni@gmx.at>
   *
 - * 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
   */
  
@@@ -22,7 -22,6 +22,7 @@@
  #include "libavutil/log.h"
  #include "libavutil/opt.h"
  #include "avcodec.h"
 +#include "internal.h"
  #include "dsputil.h"
  #include "dwt.h"
  #include "snow.h"
@@@ -215,12 -214,12 +215,12 @@@ static av_cold int encode_init(AVCodecC
  
      avctx->coded_frame= &s->current_picture;
      switch(avctx->pix_fmt){
 -//    case PIX_FMT_YUV444P:
 +    case PIX_FMT_YUV444P:
  //    case PIX_FMT_YUV422P:
      case PIX_FMT_YUV420P:
 -    case PIX_FMT_GRAY8:
 +//     case PIX_FMT_GRAY8:
  //    case PIX_FMT_YUV411P:
 -//    case PIX_FMT_YUV410P:
 +    case PIX_FMT_YUV410P:
          s->colorspace_type= 0;
          break;
  /*    case PIX_FMT_RGB32:
          av_log(avctx, AV_LOG_ERROR, "pixel format not supported\n");
          return -1;
      }
 -//    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
 -    s->chroma_h_shift= 1;
 -    s->chroma_v_shift= 1;
 +    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
  
      ff_set_cmp(&s->dsp, s->dsp.me_cmp, s->avctx->me_cmp);
      ff_set_cmp(&s->dsp, s->dsp.me_sub_cmp, s->avctx->me_sub_cmp);
          }
      }
  
 +    s->runs = av_malloc(avctx->width * avctx->height * sizeof(*s->runs));
 +
      return 0;
  }
  
  //near copy & paste from dsputil, FIXME
 -static int pix_sum(uint8_t * pix, int line_size, int w)
 +static int pix_sum(uint8_t * pix, int line_size, int w, int h)
  {
      int s, i, j;
  
      s = 0;
 -    for (i = 0; i < w; i++) {
 +    for (i = 0; i < h; i++) {
          for (j = 0; j < w; j++) {
              s += pix[0];
              pix ++;
@@@ -323,8 -322,8 +323,8 @@@ static int encode_q_branch(SnowContext 
      const int stride= s->current_picture.linesize[0];
      const int uvstride= s->current_picture.linesize[1];
      uint8_t *current_data[3]= { s->input_picture.data[0] + (x + y*  stride)*block_w,
 -                                s->input_picture.data[1] + (x + y*uvstride)*block_w/2,
 -                                s->input_picture.data[2] + (x + y*uvstride)*block_w/2};
 +                                s->input_picture.data[1] + ((x*block_w)>>s->chroma_h_shift) + ((y*uvstride*block_w)>>s->chroma_v_shift),
 +                                s->input_picture.data[2] + ((x*block_w)>>s->chroma_h_shift) + ((y*uvstride*block_w)>>s->chroma_v_shift)};
      int P[10][2];
      int16_t last_mv[3][2];
      int qpel= !!(s->avctx->flags & CODEC_FLAG_QPEL); //unused
      score += (s->lambda2*(get_rac_count(&pc)-base_bits))>>FF_LAMBDA_SHIFT;
  
      block_s= block_w*block_w;
 -    sum = pix_sum(current_data[0], stride, block_w);
 +    sum = pix_sum(current_data[0], stride, block_w, block_w);
      l= (sum + block_s/2)/block_s;
      iscore = pix_norm1(current_data[0], stride, block_w) - 2*l*sum + l*l*block_s;
  
 -    block_s= block_w*block_w>>2;
 -    sum = pix_sum(current_data[1], uvstride, block_w>>1);
 +    block_s= block_w*block_w>>(s->chroma_h_shift + s->chroma_v_shift);
 +    sum = pix_sum(current_data[1], uvstride, block_w>>s->chroma_h_shift, block_w>>s->chroma_v_shift);
      cb= (sum + block_s/2)/block_s;
  //    iscore += pix_norm1(&current_mb[1][0], uvstride, block_w>>1) - 2*cb*sum + cb*cb*block_s;
 -    sum = pix_sum(current_data[2], uvstride, block_w>>1);
 +    sum = pix_sum(current_data[2], uvstride, block_w>>s->chroma_h_shift, block_w>>s->chroma_v_shift);
      cr= (sum + block_s/2)/block_s;
  //    iscore += pix_norm1(&current_mb[2][0], uvstride, block_w>>1) - 2*cr*sum + cr*cr*block_s;
  
@@@ -574,10 -573,9 +574,10 @@@ static int get_dc(SnowContext *s, int m
      int i, x2, y2;
      Plane *p= &s->plane[plane_index];
      const int block_size = MB_SIZE >> s->block_max_depth;
 -    const int block_w    = plane_index ? block_size/2 : block_size;
 -    const uint8_t *obmc  = plane_index ? ff_obmc_tab[s->block_max_depth+1] : ff_obmc_tab[s->block_max_depth];
 -    const int obmc_stride= plane_index ? block_size : 2*block_size;
 +    const int block_w    = plane_index ? block_size>>s->chroma_h_shift : block_size;
 +    const int block_h    = plane_index ? block_size>>s->chroma_v_shift : block_size;
 +    const uint8_t *obmc  = plane_index ? ff_obmc_tab[s->block_max_depth+s->chroma_h_shift] : ff_obmc_tab[s->block_max_depth];
 +    const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;
      const int ref_stride= s->current_picture.linesize[plane_index];
      uint8_t *src= s-> input_picture.data[plane_index];
      IDWTELEM *dst= (IDWTELEM*)s->m.obmc_scratchpad + plane_index*block_size*block_size*4; //FIXME change to unsigned
      int ab=0;
      int aa=0;
  
 +    av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc stuff above
 +
      b->type|= BLOCK_INTRA;
      b->color[plane_index]= 0;
      memset(dst, 0, obmc_stride*obmc_stride*sizeof(IDWTELEM));
          int mb_x2= mb_x + (i &1) - 1;
          int mb_y2= mb_y + (i>>1) - 1;
          int x= block_w*mb_x2 + block_w/2;
 -        int y= block_w*mb_y2 + block_w/2;
 +        int y= block_h*mb_y2 + block_h/2;
  
 -        add_yblock(s, 0, NULL, dst + ((i&1)+(i>>1)*obmc_stride)*block_w, NULL, obmc,
 -                    x, y, block_w, block_w, w, h, obmc_stride, ref_stride, obmc_stride, mb_x2, mb_y2, 0, 0, plane_index);
 +        add_yblock(s, 0, NULL, dst + (i&1)*block_w + (i>>1)*obmc_stride*block_h, NULL, obmc,
 +                    x, y, block_w, block_h, w, h, obmc_stride, ref_stride, obmc_stride, mb_x2, mb_y2, 0, 0, plane_index);
  
 -        for(y2= FFMAX(y, 0); y2<FFMIN(h, y+block_w); y2++){
 +        for(y2= FFMAX(y, 0); y2<FFMIN(h, y+block_h); y2++){
              for(x2= FFMAX(x, 0); x2<FFMIN(w, x+block_w); x2++){
 -                int index= x2-(block_w*mb_x - block_w/2) + (y2-(block_w*mb_y - block_w/2))*obmc_stride;
 +                int index= x2-(block_w*mb_x - block_w/2) + (y2-(block_h*mb_y - block_h/2))*obmc_stride;
                  int obmc_v= obmc[index];
                  int d;
 -                if(y<0) obmc_v += obmc[index + block_w*obmc_stride];
 +                if(y<0) obmc_v += obmc[index + block_h*obmc_stride];
                  if(x<0) obmc_v += obmc[index + block_w];
 -                if(y+block_w>h) obmc_v += obmc[index - block_w*obmc_stride];
 +                if(y+block_h>h) obmc_v += obmc[index - block_h*obmc_stride];
                  if(x+block_w>w) obmc_v += obmc[index - block_w];
                  //FIXME precalculate this or simplify it somehow else
  
@@@ -666,12 -662,11 +666,12 @@@ static inline int get_block_bits(SnowCo
      }
  }
  
- static int get_block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index, const uint8_t *obmc_edged){
+ static int get_block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index, uint8_t (*obmc_edged)[MB_SIZE * 2]){
      Plane *p= &s->plane[plane_index];
      const int block_size = MB_SIZE >> s->block_max_depth;
 -    const int block_w    = plane_index ? block_size/2 : block_size;
 -    const int obmc_stride= plane_index ? block_size : 2*block_size;
 +    const int block_w    = plane_index ? block_size>>s->chroma_h_shift : block_size;
 +    const int block_h    = plane_index ? block_size>>s->chroma_v_shift : block_size;
 +    const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;
      const int ref_stride= s->current_picture.linesize[plane_index];
      uint8_t *dst= s->current_picture.data[plane_index];
      uint8_t *src= s->  input_picture.data[plane_index];
      int rate= 0;
      const int penalty_factor= get_penalty_factor(s->lambda, s->lambda2, s->avctx->me_cmp);
      int sx= block_w*mb_x - block_w/2;
 -    int sy= block_w*mb_y - block_w/2;
 +    int sy= block_h*mb_y - block_h/2;
      int x0= FFMAX(0,-sx);
      int y0= FFMAX(0,-sy);
      int x1= FFMIN(block_w*2, w-sx);
 -    int y1= FFMIN(block_w*2, h-sy);
 +    int y1= FFMIN(block_h*2, h-sy);
      int i,x,y;
  
 -    ff_snow_pred_block(s, cur, tmp, ref_stride, sx, sy, block_w*2, block_w*2, &s->block[mb_x + mb_y*b_stride], plane_index, w, h);
 +    av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc and square assumtions below chckinhg only block_w
 +
 +    ff_snow_pred_block(s, cur, tmp, ref_stride, sx, sy, block_w*2, block_h*2, &s->block[mb_x + mb_y*b_stride], plane_index, w, h);
  
      for(y=y0; y<y1; y++){
-         const uint8_t *obmc1= obmc_edged + y*obmc_stride;
+         const uint8_t *obmc1= obmc_edged[y];
          const IDWTELEM *pred1 = pred + y*obmc_stride;
          uint8_t *cur1 = cur + y*ref_stride;
          uint8_t *dst1 = dst + sx + (sy+y)*ref_stride;
          else
              x0 = block_w;
          if(mb_y == 0)
 -            y1 = block_w;
 +            y1 = block_h;
          else
 -            y0 = block_w;
 +            y0 = block_h;
          for(y=y0; y<y1; y++)
              memcpy(dst + sx+x0 + (sy+y)*ref_stride, cur + x0 + y*ref_stride, x1-x0);
      }
@@@ -771,10 -764,9 +771,10 @@@ static int get_4block_rd(SnowContext *s
      int i, y2;
      Plane *p= &s->plane[plane_index];
      const int block_size = MB_SIZE >> s->block_max_depth;
 -    const int block_w    = plane_index ? block_size/2 : block_size;
 -    const uint8_t *obmc  = plane_index ? ff_obmc_tab[s->block_max_depth+1] : ff_obmc_tab[s->block_max_depth];
 -    const int obmc_stride= plane_index ? block_size : 2*block_size;
 +    const int block_w    = plane_index ? block_size>>s->chroma_h_shift : block_size;
 +    const int block_h    = plane_index ? block_size>>s->chroma_v_shift : block_size;
 +    const uint8_t *obmc  = plane_index ? ff_obmc_tab[s->block_max_depth+s->chroma_h_shift] : ff_obmc_tab[s->block_max_depth];
 +    const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;
      const int ref_stride= s->current_picture.linesize[plane_index];
      uint8_t *dst= s->current_picture.data[plane_index];
      uint8_t *src= s-> input_picture.data[plane_index];
      int rate= 0;
      const int penalty_factor= get_penalty_factor(s->lambda, s->lambda2, s->avctx->me_cmp);
  
 +    av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc and square assumtions below
 +
      for(i=0; i<9; i++){
          int mb_x2= mb_x + (i%3) - 1;
          int mb_y2= mb_y + (i/3) - 1;
          int x= block_w*mb_x2 + block_w/2;
 -        int y= block_w*mb_y2 + block_w/2;
 +        int y= block_h*mb_y2 + block_h/2;
  
          add_yblock(s, 0, NULL, zero_dst, dst, obmc,
 -                   x, y, block_w, block_w, w, h, /*dst_stride*/0, ref_stride, obmc_stride, mb_x2, mb_y2, 1, 1, plane_index);
 +                   x, y, block_w, block_h, w, h, /*dst_stride*/0, ref_stride, obmc_stride, mb_x2, mb_y2, 1, 1, plane_index);
  
          //FIXME find a cleaner/simpler way to skip the outside stuff
          for(y2= y; y2<0; y2++)
              memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);
 -        for(y2= h; y2<y+block_w; y2++)
 +        for(y2= h; y2<y+block_h; y2++)
              memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);
          if(x<0){
 -            for(y2= y; y2<y+block_w; y2++)
 +            for(y2= y; y2<y+block_h; y2++)
                  memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, -x);
          }
          if(x+block_w > w){
 -            for(y2= y; y2<y+block_w; y2++)
 +            for(y2= y; y2<y+block_h; y2++)
                  memcpy(dst + w + y2*ref_stride, src + w + y2*ref_stride, x+block_w - w);
          }
  
          assert(block_w== 8 || block_w==16);
 -        distortion += s->dsp.me_cmp[block_w==8](&s->m, src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_w);
 +        distortion += s->dsp.me_cmp[block_w==8](&s->m, src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_h);
      }
  
      if(plane_index==0){
      return distortion + rate*penalty_factor;
  }
  
 -static int encode_subband_c0run(SnowContext *s, SubBand *b, IDWTELEM *src, IDWTELEM *parent, int stride, int orientation){
 +static int encode_subband_c0run(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation){
      const int w= b->width;
      const int h= b->height;
      int x, y;
  
      if(1){
          int run=0;
 -        int runs[w*h];
          int run_index=0;
          int max_index;
  
                  }
                  if(!(/*ll|*/l|lt|t|rt|p)){
                      if(v){
 -                        runs[run_index++]= run;
 +                        s->runs[run_index++]= run;
                          run=0;
                      }else{
                          run++;
              }
          }
          max_index= run_index;
 -        runs[run_index++]= run;
 +        s->runs[run_index++]= run;
          run_index=0;
 -        run= runs[run_index++];
 +        run= s->runs[run_index++];
  
          put_symbol2(&s->c, b->state[30], max_index, 0);
          if(run_index <= max_index)
                      put_rac(&s->c, &b->state[0][context], !!v);
                  }else{
                      if(!run){
 -                        run= runs[run_index++];
 +                        run= s->runs[run_index++];
  
                          if(run_index <= max_index)
                              put_symbol2(&s->c, b->state[1], run, 3);
      return 0;
  }
  
 -static int encode_subband(SnowContext *s, SubBand *b, IDWTELEM *src, IDWTELEM *parent, int stride, int orientation){
 +static int encode_subband(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation){
  //    encode_subband_qtree(s, b, src, parent, stride, orientation);
  //    encode_subband_z0run(s, b, src, parent, stride, orientation);
      return encode_subband_c0run(s, b, src, parent, stride, orientation);
  //    encode_subband_dzr(s, b, src, parent, stride, orientation);
  }
  
- static av_always_inline int check_block(SnowContext *s, int mb_x, int mb_y, int p[3], int intra, const uint8_t *obmc_edged, int *best_rd){
+ static av_always_inline int check_block(SnowContext *s, int mb_x, int mb_y, int p[3], int intra, uint8_t (*obmc_edged)[MB_SIZE * 2], int *best_rd){
      const int b_stride= s->b_width << s->block_max_depth;
      BlockNode *block= &s->block[mb_x + mb_y * b_stride];
      BlockNode backup= *block;
  
  /* special case for int[2] args we discard afterwards,
   * fixes compilation problem with gcc 2.95 */
- static av_always_inline int check_block_inter(SnowContext *s, int mb_x, int mb_y, int p0, int p1, const uint8_t *obmc_edged, int *best_rd){
+ static av_always_inline int check_block_inter(SnowContext *s, int mb_x, int mb_y, int p0, int p1, uint8_t (*obmc_edged)[MB_SIZE * 2], int *best_rd){
      int p[2] = {p0, p1};
      return check_block(s, mb_x, mb_y, p, 0, obmc_edged, best_rd);
  }
@@@ -1083,7 -1074,7 +1083,7 @@@ static void iterative_me(SnowContext *s
                  BlockNode *blb= mb_x           && mb_y+1<b_height ? &s->block[index+b_stride-1] : NULL;
                  BlockNode *brb= mb_x+1<b_width && mb_y+1<b_height ? &s->block[index+b_stride+1] : NULL;
                  const int b_w= (MB_SIZE >> s->block_max_depth);
-                 uint8_t obmc_edged[b_w*2][b_w*2];
+                 uint8_t obmc_edged[MB_SIZE * 2][MB_SIZE * 2];
  
                  if(pass && (block->type & BLOCK_OPT))
                      continue;
                  //FIXME precalculate
                  {
                      int x, y;
-                     memcpy(obmc_edged, ff_obmc_tab[s->block_max_depth], b_w*b_w*4);
+                     for (y = 0; y < b_w * 2; y++)
+                         memcpy(obmc_edged[y], ff_obmc_tab[s->block_max_depth] + y * b_w * 2, b_w * 2);
                      if(mb_x==0)
                          for(y=0; y<b_w*2; y++)
                              memset(obmc_edged[y], obmc_edged[y][0] + obmc_edged[y][b_w-1], b_w);
                      uint8_t *dst= s->current_picture.data[0];
                      const int stride= s->current_picture.linesize[0];
                      const int block_w= MB_SIZE >> s->block_max_depth;
 +                    const int block_h= MB_SIZE >> s->block_max_depth;
                      const int sx= block_w*mb_x - block_w/2;
 -                    const int sy= block_w*mb_y - block_w/2;
 +                    const int sy= block_h*mb_y - block_h/2;
                      const int w= s->plane[0].width;
                      const int h= s->plane[0].height;
                      int y;
  
                      for(y=sy; y<0; y++)
                          memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
 -                    for(y=h; y<sy+block_w*2; y++)
 +                    for(y=h; y<sy+block_h*2; y++)
                          memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
                      if(sx<0){
 -                        for(y=sy; y<sy+block_w*2; y++)
 +                        for(y=sy; y<sy+block_h*2; y++)
                              memcpy(dst + sx + y*stride, src + sx + y*stride, -sx);
                      }
                      if(sx+block_w*2 > w){
 -                        for(y=sy; y<sy+block_w*2; y++)
 +                        for(y=sy; y<sy+block_h*2; y++)
                              memcpy(dst + w + y*stride, src + w + y*stride, sx+block_w*2 - w);
                      }
                  }
                  // get previous score (cannot be cached due to OBMC)
                  if(pass > 0 && (block->type&BLOCK_INTRA)){
                      int color0[3]= {block->color[0], block->color[1], block->color[2]};
-                     check_block(s, mb_x, mb_y, color0, 1, *obmc_edged, &best_rd);
+                     check_block(s, mb_x, mb_y, color0, 1, obmc_edged, &best_rd);
                  }else
-                     check_block_inter(s, mb_x, mb_y, block->mx, block->my, *obmc_edged, &best_rd);
+                     check_block_inter(s, mb_x, mb_y, block->mx, block->my, obmc_edged, &best_rd);
  
                  ref_b= *block;
                  ref_rd= best_rd;
                      block->ref= ref;
                      best_rd= INT_MAX;
  
-                     check_block_inter(s, mb_x, mb_y, mvr[0][0], mvr[0][1], *obmc_edged, &best_rd);
-                     check_block_inter(s, mb_x, mb_y, 0, 0, *obmc_edged, &best_rd);
+                     check_block_inter(s, mb_x, mb_y, mvr[0][0], mvr[0][1], obmc_edged, &best_rd);
+                     check_block_inter(s, mb_x, mb_y, 0, 0, obmc_edged, &best_rd);
                      if(tb)
-                         check_block_inter(s, mb_x, mb_y, mvr[-b_stride][0], mvr[-b_stride][1], *obmc_edged, &best_rd);
+                         check_block_inter(s, mb_x, mb_y, mvr[-b_stride][0], mvr[-b_stride][1], obmc_edged, &best_rd);
                      if(lb)
-                         check_block_inter(s, mb_x, mb_y, mvr[-1][0], mvr[-1][1], *obmc_edged, &best_rd);
+                         check_block_inter(s, mb_x, mb_y, mvr[-1][0], mvr[-1][1], obmc_edged, &best_rd);
                      if(rb)
-                         check_block_inter(s, mb_x, mb_y, mvr[1][0], mvr[1][1], *obmc_edged, &best_rd);
+                         check_block_inter(s, mb_x, mb_y, mvr[1][0], mvr[1][1], obmc_edged, &best_rd);
                      if(bb)
-                         check_block_inter(s, mb_x, mb_y, mvr[b_stride][0], mvr[b_stride][1], *obmc_edged, &best_rd);
+                         check_block_inter(s, mb_x, mb_y, mvr[b_stride][0], mvr[b_stride][1], obmc_edged, &best_rd);
  
                      /* fullpel ME */
                      //FIXME avoid subpel interpolation / round to nearest integer
                          dia_change=0;
                          for(i=0; i<FFMAX(s->avctx->dia_size, 1); i++){
                              for(j=0; j<i; j++){
-                                 dia_change |= check_block_inter(s, mb_x, mb_y, block->mx+4*(i-j), block->my+(4*j), *obmc_edged, &best_rd);
-                                 dia_change |= check_block_inter(s, mb_x, mb_y, block->mx-4*(i-j), block->my-(4*j), *obmc_edged, &best_rd);
-                                 dia_change |= check_block_inter(s, mb_x, mb_y, block->mx+4*(i-j), block->my-(4*j), *obmc_edged, &best_rd);
-                                 dia_change |= check_block_inter(s, mb_x, mb_y, block->mx-4*(i-j), block->my+(4*j), *obmc_edged, &best_rd);
+