avdevice/decklink_dec: fix bitrate calculations

Reviewed-by: Deti Fliegl <deti@fliegl.de> Signed-off-by: Marton Balint <cus@passwd.hu>
2016-06-26 19:17:29 +02:00
306 changed files with 1336 additions and 3349 deletions
--- a/563
+++ b/563
@@ -1,565 +1,8 @@
 Entries are sorted chronologically from oldest to youngest within each release,
 releases are sorted from youngest to oldest.

-
-version 3.1.9:
- avcodec/cfhd: Check bpc before setting bpc in context
- avcodec/cfhd: Fix undefined shift
- avcodec/hevc_filter: Fix invalid shift
- avcodec/mpeg4videodec: Fix overflow in virtual_ref computation
- avcodec/lpc: signed integer overflow in compute_lpc_coefs() (aacdec_fixed)
- avcodec/wavpack: Fix undefined integer negation
- avcodec/aacdec_fixed: Check s for being too small
- avcodec/htmlsubtitles: Replace very slow redundant sscanf() calls by cleaner and faster code
- avcodec/h264: Fix mix of lossless and lossy MBs decoding
- avcodec/h264_mb: Fix 8x8dct in lossless for new versions of x264
- avcodec/h264_cabac: Fix CABAC+8x8dct in 4:4:4
- avcodec/takdec: Fixes: integer overflow in AV_SAMPLE_FMT_U8P output
- avcodec/jpeg2000dsp: Reorder operations in ict_int() to avoid 2 integer overflows
- avcodec/hevcpred_template: Fix left shift of negative value
- avcodec/hevcdec: Fix signed integer overflow in decode_lt_rps()
- avcodec/jpeg2000dec: Check nonzerobits more completely
- avcodec/shorten: Sanity check maxnlpc
- avcodec/truemotion2: Move skip computation after checks
- avcodec/jpeg2000: Fixes integer overflow in ff_jpeg2000_ceildivpow2()
- avcodec/hevcdec: Check nb_sps
- avcodec/hevc_refs: Check nb_refs in add_candidate_ref()
- avcodec/mpeg4videodec: Check sprite delta upshift against overflowing.
- avcodec/mpeg4videodec: Fix integer overflow in num_sprite_warping_points=2 case
- avcodec/aacsbr_fixed: Check shift in sbr_hf_assemble()
- avcodec/sbrdsp_fixed: Return an error from sbr_hf_apply_noise() if operations are impossible
- avcodec/jpeg2000dwt: Fix runtime error: left shift of negative value -123
- avcodec/wavpack: Fix runtime error: signed integer overflow: 1886191616 + 277872640 cannot be represented in type 'int'
- avcodec/snowdec: Fix runtime error: left shift of negative value -1
- avcodec/aacdec_fixed: Fix runtime error: left shift of negative value -1297616
- avcodec/tiff: Fix leak of geotags[].val
- avcodec/ra144: Fix runtime error: signed integer overflow: -2200 * 1033073 cannot be represented in type 'int'
- avcodec/flicvideo: Fix runtime error: signed integer overflow: 4864 * 459296 cannot be represented in type 'int'
- avcodec/cfhd: Check band parameters before storing them
- avcodec/indeo4: Check remaining data in Pic hdr extension parsing code
- avcodec/ac3dec_fixed: Fix multiple runtime error: signed integer overflow: -39271008 * 59 cannot be represented in type 'int'
- avcodec/mpeg4videodec: Fix runtime error: signed integer overflow: 53098 * 40448 cannot be represented in type 'int'
- avcodec/pafvideo: Fix assertion failure
- avcodec/takdec: Fix multiple runtime error: signed integer overflow: 637072 * 4096 cannot be represented in type 'int'
- avcodec/mjpegdec: Check that reference frame matches the current frame
- avcodec/tiff: Avoid loosing allocated geotag values
- avcodec/cavs: Fix runtime error: signed integer overflow: -12648062 * 256 cannot be represented in type 'int'
- avformat/hls: Check local file extensions
- avcodec/qdrw: Fix null pointer dereference
- avutil/softfloat: Fix sign error in and improve documentation of av_int2sf()
- avcodec/hevc_ps: Fix runtime error: index 32 out of bounds for type 'uint8_t [32]'
- avcodec/dxv: Check remaining bytes in dxv_decompress_raw()
- avcodec/pafvideo: Check packet size and frame code before ff_reget_buffer()
- avcodec/ac3dec_fixed: Fix runtime error: left shift of 419 by 23 places cannot be represented in type 'int'
- avformat/options: log filename on open
- avcodec/aacps: Fix runtime error: left shift of 1073741824 by 1 places cannot be represented in type 'INTFLOAT' (aka 'int')
- avcodec/wavpack: Fix runtime error: shift exponent 32 is too large for 32-bit type 'int'
- avcodec/wavpack: Fix runtime error: signed integer overflow: 2013265955 - -134217694 cannot be represented in type 'int'
- avcodec/cinepak: Check input packet size before frame reallocation
- avcodec/hevc_ps: Fix runtime error: signed integer overflow: 2147483628 + 256 cannot be represented in type 'int'
- avcodec/ra144: Fixes runtime error: signed integer overflow: 7160 * 327138 cannot be represented in type 'int'
- avcodec/pnm: Use ff_set_dimensions()
- avcodec/cavsdec: Fix runtime error: signed integer overflow: 59 + 2147483600 cannot be represented in type 'int'
- avformat/avidec: Limit formats in gab2 to srt and ass/ssa
- avcodec/acelp_pitch_delay: Fix runtime error: value 4.83233e+39 is outside the range of representable values of type 'float'
- avcodec/wavpack: Check float_shift
- avcodec/wavpack: Fix runtime error: signed integer overflow: 24 * -2147483648 cannot be represented in type 'int'
- avcodec/ansi: Fix frame memleak
- avcodec/jpeg2000dec: Use ff_set_dimensions()
- avcodec/truemotion2: Fix passing null pointer to memset()
- avcodec/truemotion2: Fix runtime error: left shift of 1 by 31 places cannot be represented in type 'int'
- avcodec/ra144: Fix runtime error: signed integer overflow: -2449 * 1398101 cannot be represented in type 'int'
- avcodec/ra144: Fix runtime error: signed integer overflow: 11184810 * 404 cannot be represented in type 'int'
- avcodec/aac_defines: Add missing () to AAC_HALF_SUM() macro
- avcodec/webp: Fixes null pointer dereference
- avcodec/aacdec_fixed: Fix runtime error: left shift of 1 by 31 places cannot be represented in type 'int'
- avcodec/ylc: Check count in build_vlc()
- avcodec/snow: Fix runtime error: signed integer overflow: 1086573993 + 1086573994 cannot be represented in type 'int'
- avcodec/jpeg2000: Fix runtime error: signed integer overflow: 4185 + 2147483394 cannot be represented in type 'int'
- avcodec/jpeg2000dec: Check tile offsets more completely
- avcodec/sheervideo: Check input buffer size before allocating and decoding
- avcodec/aacdec_fixed: Fix multiple runtime error: shift exponent 127 is too large for 32-bit type 'int'
- avcodec/wnv1: More strict buffer size check
- avcodec/libfdk-aacdec: Correct buffer_size parameter
- avcodec/sbrdsp_template: Fix: runtime error: signed integer overflow: 849815297 + 1315389781 cannot be represented in type 'int'
- avcodec/ivi_dsp: Fix runtime error: left shift of negative value -2
- doc/filters: Clarify scale2ref example
- avcodec/mlpdec: Do not leave invalid values in matrix_out_ch[] on error
- avcodec/ra144dec: Fix runtime error: left shift of negative value -17
- avformat/mux: Fix copy an paste typo
- avutil/internal: Do not enable CHECKED with DEBUG
- avcodec/aacdec_fixed: Fix runtime error: signed integer overflow: -2147483648 * -1 cannot be represented in type 'int'
- avcodec/smc: Check remaining input
- avcodec/jpeg2000dec: Fix copy and paste error
- avcodec/jpeg2000dec: Check tile offsets
- avcodec/sanm: Fix uninitialized reference frames
- avcodec/jpeglsdec: Check get_bits_left() before decoding a picture
- avcodec/ivi_dsp: Fix multiple runtime error: left shift of negative value -71
- avcodec/mjpegdec: Fix runtime error: signed integer overflow: -32767 * 130560 cannot be represented in type 'int'
- avcodec/aacdec_fixed: Fix runtime error: shift exponent 34 is too large for 32-bit type 'int'
- avcodec/mpeg4videodec: Check for multiple VOL headers
- avcodec/vmnc: Check location before use
- avcodec/takdec: Fix runtime error: signed integer overflow: 8192 * 524308 cannot be represented in type 'int'
- avcodec/aac_defines: Fix: runtime error: left shift of negative value -2
- avcodec/takdec: Fix runtime error: left shift of negative value -63
- avcodec/mlpdsp: Fix runtime error: signed integer overflow: -24419392 * 128 cannot be represented in type 'int'
- avcodec/sbrdsp_fixed: fix runtime error: left shift of 1 by 31 places cannot be represented in type 'int'
- avcodec/aacsbr_fixed: Fix multiple runtime error: shift exponent 170 is too large for 32-bit type 'int'
- avcodec/mlpdec: Do not leave a invalid num_primitive_matrices in the context
- avcodec/aacsbr_fixed: Fix multiple runtime error: shift exponent 150 is too large for 32-bit type 'int'
- avcodec/mimic: Use ff_set_dimensions() to set the dimensions
- avcodec/fic: Fix multiple runtime error: signed integer overflow: 5793 * 419752 cannot be represented in type 'int'
- avcodec/mlpdec: Fix: runtime error: left shift of negative value -8
- avcodec/dfa: Fix: runtime error: signed integer overflow: -14202 * 196877 cannot be represented in type 'int'
- avcodec/aacdec: Fix runtime error: signed integer overflow: 2147483520 + 255 cannot be represented in type 'int'
- avcodec/aacdec_template: Fix fixed point scale in decode_cce()
- avcodec/nvenc: remove unnecessary alignment
-
-
-version 3.1.8:
- avcodec/flicvideo: Check frame_size before decrementing
- avcodec/mlpdec: Fix runtime error: left shift of negative value -1
- avcodec/takdec: Fix  runtime error: left shift of negative value -42
- avcodec/hq_hqa: Fix: runtime error: signed integer overflow: -255 * 10180917 cannot be represented in type 'int'
- avcodec/hevc_sei: fix amount of bits skipped when reading picture timing SEI message
- avutil/hwcontext_dxva2: Don't improperly free IDirect3DSurface9 objects
- avcodec/aac_adtstoasc: fix ASC passthrough on small frames
- avformat/utils: free AVStream.codec properly in free_stream()
- avcodec/options: do a more thorough clean up in avcodec_copy_context()
- avcodec/options: factorize avcodec_copy_context() cleanup code
- avformat/concatdec: fix the h264 annexb extradata check
- avcodec/truemotion1: Fix multiple runtime error: signed integer overflow: 1246906962 * 2 cannot be represented in type 'int'
- avcodec/svq3: Fix runtime error: left shift of negative value -6
- avcodec/tiff: reset sampling[] if its invalid
- avcodec/aacps: Fix undefined behavior
- avcodec/opus_silk: Fix integer overflow and out of array read
- avcodec/flacdec: Return error code instead of 0 for failures
- avcodec/snowdec: Check width
- avcodec/webp: Update canvas size in vp8_lossy_decode_frame() as in vp8_lossless_decode_frame()
- avcodec/webp: Factor update_canvas_size() out
- avcodec/cllc: Check prefix
- avcodec/rscc: Check pixel_size for overflow
- avcodec/dds: Fix runtime error: left shift of 210 by 24 places cannot be represented in type 'int'
- avcodec/mpeg4videodec: Clear sprite wraping on unsupported cases in VOP decode
- avcodec/ac3dec: Fix: runtime error: index -1 out of bounds for type 'INTFLOAT [2]'
- avcodec/hqxdsp: Fix runtime error: signed integer overflow: -196264 * 11585 cannot be represented in type 'int'
- avcodec/g723_1dec: Fix LCG type
- libswscale/tests/swscale: Fix uninitialized variables
- avcodec/ffv1dec: Fix runtime error: signed integer overflow: 1550964438 + 1550964438 cannot be represented in type 'int'
- avcodec/webp: Fix signedness in prefix_code check
- avcodec/svq3: Fix runtime error: signed integer overflow: 169 * 12717677 cannot be represented in type 'int'
- avcodec/mlpdec: Check that there is enough data for headers
- avcodec/ac3dec: Keep track of band structure
- avcodec/webp: Add missing input padding
- avcodec/aacdec_fixed: Fix runtime error: left shift of negative value -1
- avcodec/aacsbr_template: Do not change bs_num_env before its checked
- avcodec/mlp: Fix multiple runtime error: left shift of negative value -1
- avcodec/vp8dsp: vp7_luma_dc_wht_c: Fix multiple runtime error: signed integer overflow: -1366381240 + -1262413604 cannot be represented in type 'int'
- avcodec/avcodec: Limit the number of side data elements per packet
- avcodec/texturedsp: Fix runtime error: left shift of 255 by 24 places cannot be represented in type 'int'
- avcodec/g723_1dec: Fix runtime error: left shift of negative value -1
- avcodec/wmv2dsp: Fix runtime error: signed integer overflow: 181 * -17047030 cannot be represented in type 'int'
- avcodec/diracdec: Fix Assertion frame->buf[0] failed at libavcodec/decode.c:610
- avcodec/msmpeg4dec: Check for cbpy VLC errors
- avcodec/cllc: Check num_bits
- avcodec/cllc: Factor VLC_BITS/DEPTH out, do not use repeated literal numbers
- avcodec/dvbsubdec: Check entry_id
- avcodec/aacdec_fixed: Fix multiple shift exponent 33 is too large for 32-bit type 'int'
- avcodec/mpeg12dec: Fixes runtime error: division by zero
- avcodec/webp: Always set pix_fmt
- avfilter/vf_uspp: Fix currently unused input frame dimensions
- avcodec/truemotion1: Fix multiple runtime error: left shift of negative value -1
- avcodec/eatqi: Fix runtime error: signed integer overflow: 4466147 * 1075 cannot be represented in type 'int'
- avcodec/dss_sp: Fix runtime error: signed integer overflow: 2147481189 + 4096 cannot be represented in type 'int'
- avformat/wavdec: Check chunk_size
- avcodec/cavs: Check updated MV
- avcodec/y41pdec: Fix width in input buffer size check
- avcodec/svq3: Fix multiple runtime error: signed integer overflow: -237341 * 24552 cannot be represented in type 'int'
- avcodec/texturedsp: Fix runtime error: left shift of 218 by 24 places cannot be represented in type 'int'
- avcodec/lagarith: Check scale_factor
- avcodec/lagarith: Fix runtime error: left shift of negative value -1
- avcodec/takdec: Fix multiple  runtime error: left shift of negative value -1
- avcodec/indeo2: Check for invalid VLCs
- avcodec/g723_1dec: Fix several integer related cases of undefined behaviour
- avcodec/htmlsubtitles: Check for string truncation and return error
- avcodec/bmvvideo: Fix runtime error: left shift of 137 by 24 places cannot be represented in type 'int'
- avcodec/dss_sp: Fix multiple runtime error: signed integer overflow: -15699 * -164039 cannot be represented in type 'int'
- avcodec/dvbsubdec: check region dimensions
- avcodec/vp8dsp: Fixes: runtime error: signed integer overflow: 1330143360 - -1023040530 cannot be represented in type 'int'
- avcodec/hqxdsp: Fix multiple runtime error: signed integer overflow: 248220 * 21407 cannot be represented in type 'int' in idct_col()
- avcodec/cavsdec: Check sym_factor
- avcodec/cdxl: Check format for BGR24
- avcodec/ffv1dec: Fix copying planes of paletted formats
- avcodec/wmv2dsp: Fix runtime error: signed integer overflow: 181 * -12156865 cannot be represented in type 'int'
- avcodec/xwddec: Check bpp more completely
- avcodec/s302m: Fix left shift of 8 by 28 places cannot be represented in type 'int'
- avcodec/eamad: Fix runtime error: signed integer overflow: 49674 * 49858 cannot be represented in type 'int'
- avcodec/g726: Fix runtime error: left shift of negative value -2
- avcodec/ra144: Fix runtime error: left shift of negative value -798
- avcodec/mss34dsp: Fix multiple signed integer overflow
- avcodec/targa_y216dec: Fix width type
- avcodec/texturedsp: Fix multiple runtime error: left shift of 255 by 24 places cannot be represented in type 'int'
- avcodec/ivi_dsp: Fix multiple left shift of negative value -2
- avcodec/svq3: Fix multiple runtime error: signed integer overflow: 44161 * 61694 cannot be represented in type 'int'
- avcodec/msmpeg4dec: Correct table depth
- avcodec/dds: Fix runtime error: left shift of 1 by 31 places cannot be represented in type 'int'
- avcodec/cdxl: Check format parameter
- avutil/softfloat: Fix overflow in av_div_sf()
- avcodec/hq_hqa: Fix runtime error: left shift of negative value -207
- avcodec/mss3: Change types in rac_get_model_sym() to match the types they are initialized from
- avcodec/shorten: Check k in get_uint()
- avcodec/webp: Fix null pointer dereference
- avcodec/dfa: Fix signed integer overflow: -2147483648 - 1 cannot be represented in type 'int'
- avcodec/g723_1: Fix multiple runtime error: left shift of negative value
- avcodec/mimic: Fix runtime error: left shift of negative value -1
- avcodec/fic: Fix multiple left shift of negative value -15
- avcodec/mlpdec: Fix runtime error: left shift of negative value -22
- avcodec/snowdec: Check qbias
- avutil/softfloat: Fix multiple runtime error: left shift of negative value -8
- avcodec/aacsbr_template: Do not leave bs_num_env invalid
- avcodec/mdec: Fix signed integer overflow: 28835400 * 83 cannot be represented in type 'int'
- avcodec/dfa: Fix off by 1 error
- avcodec/nellymoser: Fix multiple left shift of negative value -8591
- avcodec/cdxl: Fix signed integer overflow: 14243456 * 164 cannot be represented in type 'int'
- avcodec/g722: Fix multiple runtime error: left shift of negative value -1
- avcodec/dss_sp: Fix multiple left shift of negative value -466
- avcodec/wnv1: Fix runtime error: left shift of negative value -1
- avcodec/tiertexseqv: set the fixed dimenasions, do not depend on the demuxer doing so
- avcodec/mjpegdec: Fix runtime error: signed integer overflow: -24543 * 2031616 cannot be represented in type 'int'
- avcodec/cavsdec: Fix undefined behavior from integer overflow
- avcodec/dvdsubdec: Fix runtime error: left shift of 242 by 24 places cannot be represented in type 'int'
- libavcodec/mpeg4videodec: Convert sprite_offset to 64bit
- avcodec/pngdec: Use ff_set_dimensions()
- avcodec/msvideo1: Check buffer size before re-getting the frame
- avcodec/h264_cavlc: Fix undefined behavior on qscale overflow
- avcodec/dcadsp: Fix runtime error: signed integer overflow
- avcodec/svq3: Reject dx/dy beyond 16bit
- avcodec/svq3: Increase offsets to prevent integer overflows
- avcodec/indeo2: Check remaining bits in ir2_decode_plane()
- avcodec/vp3: Check remaining bits in unpack_dct_coeffs()
- doc/developer: Add terse documentation of assumed C implementation defined behavior
- avcodec/mdec: Fix runtime error: left shift of negative value -127
- avcodec/x86/vc1dsp_init: Fix build failure with --disable-optimizations and clang
- libavcodec/exr : fix float to uint16 conversion for negative float value
- avformat/webmdashenc: Validate the 'streams' adaptation sets parameter
- avformat/webmdashenc: Require the 'adaptation_sets' option to be set
- avformat/oggparseogm: Check ff_alloc_extradata() for failure
- avformat/oggparseogm: Check available data before reading global header
- avcodec/dvdsubdec: Fixes 2 runtime error: left shift of 170 by 24 places cannot be represented in type 'int'
- avformat/oggparsedaala: Do not leave an invalid value in gpshift
- avformat/oggparsedaala: Check duration for AV_NOPTS_VALUE
- avfilter/af_sofalizer: Fix bad shift
- avcodec: fix uninitialized variable read
- avfilter/avfiltergraph: Add assert to write down in machine readable form what is assumed about sample rates in swap_samplerates_on_filter()
- avcodec/tiff: Perform multiply in tiff_unpack_lzma() as 64bit
- omx: Fix OOM check
- avcodec/vdpau_hevc: Fix potential out-of-bounds write
- avcodec/h264_ps: Fix runtime error: signed integer overflow: 2147483647 + 26 cannot be represented in type 'int'
- avcodec/tiff: Check geotag count for being non zero
- avcodec/vp56: Check avctx->error_concealment before enabling EC
- avcodec/tiff: Check stripsize strippos for overflow
- avcodec/mpegaudiodec_template: Make l3_unscale() work with e=0
- avcodec/tiff: Check for multiple geo key directories
- avcodec/wavpack: Fix runtime error: shift exponent 32 is too large for 32-bit type 'int'
- avcodec/rv34: Fix runtime error: signed integer overflow: 36880 * 66288 cannot be represented in type 'int'
- avcodec/amrwbdec: Fix  runtime error: left shift of negative value -1
- avcodec/mpeg4videodec: Fix runtime error: signed integer overflow: -135088512 * 16 cannot be represented in type 'int'
- avcodec/h264_mvpred: Fix runtime error: left shift of negative value -1
- avcodec/mjpegdec: Fix runtime error: left shift of negative value -127
- avcodec/wavpack: Fix runtime error: left shift of negative value -5
- avcodec/wavpack: Fix runtime error: left shift of negative value -2
- avcodec/mpeg4videodec: Fix runtime error: signed integer overflow: 134527392 * 16 cannot be represented in type 'int'
- avcodec/mpeg12dec: Fix runtime error: left shift of negative value -13
- avcodec/h264_mvpred: Fix multiple runtime error: left shift of negative value
- avcodec/adxdec: Fix runtime error: left shift of negative value -1
- avcodec/mpeg4videodec: Improve the overflow checks in mpeg4_decode_sprite_trajectory()
- avcodec/mjpegdec: Fix runtime error: left shift of negative value -511
- avcodec/h264_direct: Fix runtime error: left shift of negative value -14
- avcodec/pictordec: Check plane value before doing value/mask computations
- avcodec/mpeg4videodec: Fix runtime error: left shift of negative value -2650
- avcodec/eac3dec: Fix runtime error: left shift of negative value -3
- avcodec/mpeg12dec: Fix runtime error: left shift of negative value -2
- avcodec/mpeg4videodec: Check the other 3 sprite points for intermediate overflows
- avcodec/mpeg4videodec: Check sprite_offset in addition to shifts
- avcodec/mpeg4video: Fix runtime error: left shift of negative value
- avcodec/ituh263dec: Fix runtime error: left shift of negative value -22
- avcodec/rv40: Fix runtime error: left shift of negative value
- avcodec/h264_cabac: runtime error: signed integer overflow: 2147483647 + 14 cannot be represented in type 'int'
- avcodec/mpeg4videodec: Fix runtime error: shift exponent -2 is negative
- avcodec/mjpegdec: Fix runtime error: left shift of negative value -507
- avcodec/eac3dec: Fix runtime error: left shift of negative value
- avcodec/htmlsubtitles: Fix reading one byte beyond the array
- avcodec/vp6: clear dimensions on failed resolution change in vp6_parse_header()
- avcodec/vp56: Reset have_undamaged_frame on resolution changes
- avcodec/vp8: Fix hang with slice threads
- avcodec/vp8: Check for the bitstream end per MB in decode_mb_row_no_filter()
- avcodec/vp568: Check that there is enough data for ff_vp56_init_range_decoder()
- avcodec/vp8: remove redundant check
- avcodec/vp56: Require a correctly decoded frame before using vp56_conceal_mb()
- avcodec/vp3: Do not return random positive values but the buf size
- avcodec/vp8: Check for bitsteam end in decode_mb_row_no_filter()
- avcodec/vp56: Factorize vp56_render_mb() out
- avcodec/vp3dsp: Fix multiple signed integer overflow: 46341 * 47523 cannot be represented in type 'int'
- Add CHECK/SUINT code
- avcodec/mpeg12dec: Fix runtime error: left shift of negative value -1
- avcodec/vp56: Clear dimensions in case of failure in the middle of a resolution change
- avcodec/vp56: Implement very basic error concealment
- avcodec/amrwbdec: Fix 2 runtime errors: left shift of negative value -1
- avcodec/pngdec: Fix runtime error: left shift of 152 by 24 places cannot be represented in type 'int'
- avcodec/vp56: Fix sign typo
- avcodec/mpegaudiodec_template: Correct return code on id3 tag discarding
- avcodec/rv34: Simplify and factor get_slice_offset() code
- avcodec/pictordec: Do not read more than nb_planes
- avcodec/srtdec: Fix signed integer overflow: 1811992524 * 384 cannot be represented in type 'int'
- avcodec/pngdec: Check bit depth for validity
- avcodec/mpeg12dec: Fix runtime error: left shift of negative value
- avcodec/wavpacl: Fix runtime error: left shift of negative value -1
- avformat/http: Check for truncated buffers in http_connect()
- lavf/mov.c: Avoid heap allocation wraps in mov_read_{senc,saiz}()
- lavf/mov.c: Avoid OOB in mov_read_udta_string()
- avformat/apng: fix setting frame delay when max_fps is set to no limit
- swresample/resample: free existing ResampleContext on reinit
- swresample/resample: move resample_free() higher in the file
- lavfi/buffersrc: fix directly setting channel layout
- lavf/mpeg: Initialize a stack variable used by memcmp().
- lavc/avpacket: Initialize a variable in error path.
-
-
-version 3.1.7:
- avcodec/h264_slice: Clear ref_counts on redundant slices
- lavf/mov.c: Avoid heap allocation wrap in mov_read_uuid
- lavf/mov.c: Avoid heap allocation wrap in mov_read_hdlr
- avcodec/pictordec: Fix logic error
- ffserver_config: Setup codecpar in add_codec()
- avcodec/movtextdec: Fix decode_styl() cleanup
- lavf/matroskadec: fix is_keyframe for early Blocks
- configure: bump year
- avcodec/pngdec: Check trns more completely
- avcodec/interplayvideo: Move parameter change check up
- avcodec/dca_lbr: Fix off by 1 error in freq check
- avcodec/mjpegdec: Check for for the bitstream end in mjpeg_decode_scan_progressive_ac()
- avformat/flacdec: Check avio_read result when reading flac block header.
- avcodec/utils: correct align value for interplay
- avcodec/vp56: Check for the bitstream end, pass error codes on
- avcodec/mjpegdec: Check remaining bitstream in ljpeg_decode_yuv_scan()
- avcodec/pngdec: Fix off by 1 size in decode_zbuf()
- avcodec/omx: Do not pass negative value into av_malloc()
- avformat/avidec: skip odml master index chunks in avi_sync
- avcodec/mjpegdec: Check for rgb before flipping
- avutil/random_seed: Reduce the time needed on systems with very low precision clock()
- avutil/random_seed: Improve get_generic_seed() with higher precision clock()
- avformat/mp3dec: fix msan warning when verifying mpa header
- avformat/utils: Print verbose error message if stream count exceeds max_streams
- avformat/options_table: Set the default maximum number of streams to 1000
- pgssubdec: reset rle_data_len/rle_remaining_len on allocation error
- avutil: Add av_image_check_size2()
- avformat: Add max_streams option
- avcodec/ffv1enc: Allocate smaller packet if the worst case size cannot be allocated
- avcodec/mpeg4videodec: Fix undefined shifts in mpeg4_decode_sprite_trajectory()
- avformat/oggdec: Skip streams in duration correction that did not had their duration set.
- avcodec/ffv1enc: Fix size of first slice
- avfilter/vf_hwupload_cuda: Add min/max limits for the 'device' option
- configure: check for strtoull on msvc
-
-version 3.1.6:
- configure: check for strtoull on msvc
- http: move chunk handling from http_read_stream() to http_buf_read().
- http: make length/offset-related variables unsigned.
- ffserver: Check chunk size
- Avoid using the term "file" and prefer "url" in some docs and comments
- avformat/rtmppkt: Check for packet size mismatches
- zmqsend: Initialize ret to 0
- avcodec/rawdec: check for side data before checking its size
- avcodec/flacdec: Fix undefined shift in decode_subframe()
- avcodec/get_bits: Fix get_sbits_long(0)
- avformat/ffmdec: Check media type for chunks
- avcodec/flacdec: Fix signed integer overflow in decode_subframe_fixed()
- avcodec/flacdsp_template: Fix undefined shift in flac_decorrelate_indep_c
- avformat/oggparsespeex: Check frames_per_packet and packet_size
- avformat/utils: Check start/end before computing duration in update_stream_timings()
- avcodec/flac_parser: Update nb_headers_buffered
- avformat/idroqdec: Check chunk_size for being too large
- avformat/utils: Fix type mismatch
- avformat/mpeg: Adjust vid probe threshold to correct mis-detection
- avcodec/rv40: Test remaining space in loop of get_dimension()
- avcodec/ituh263dec: Avoid spending a long time in slice sync
- avcodec/movtextdec: Add error message for tsmb_size check
- avcodec/movtextdec: Fix tsmb_size check==0 check
- avcodec/movtextdec: Fix potential integer overflow
- avcodec/sunrast: Fix input buffer pointer check
- avcodec/tscc:  Check side data size before use
- avcodec/rawdec: Check side data size before use
- avcodec/msvideo1: Check side data size before use
- avcodec/qpeg:  Check side data size before use
- avcodec/qtrle:  Check side data size before use
- avcodec/msrle:  Check side data size before use
- avcodec/kmvc:  Check side data size before use
- avcodec/idcinvideo: Check side data size before use
- avcodec/cinepak: Check side data size before use
- avcodec/8bps: Check side data size before use
- avformat/flvdec: Fix regression losing streams
- avcodec/dvdsubdec: Fix off by 1 error
- avformat/isom: Fix old API regression with exporting max bitrate
- avcodec/dvdsubdec: Fix buf_size check
- vp9: change order of operations in adapt_prob().
- avcodec/interplayvideo: Check side data size before use
- mss2: only use error correction for matching block counts
- softfloat: decrease MIN_EXP to cover full float range
- libopusdec: default to stereo for invalid number of channels
- flvdec: require need_context_update when changing codec id
- pgssubdec: only set w/h/linesize when allocating data
- sbgdec: prevent NULL pointer access
- rmdec: validate block alignment
- smacker: limit recursion depth of smacker_decode_bigtree
- mxfdec: fix NULL pointer dereference in mxf_read_packet_old
- ffmdec: validate codec parameters
- exr: reindent after previous commit
- exr: fix out-of-bounds read
- libschroedingerdec: fix leaking of framewithpts
- libschroedingerdec: don't produce empty frames
- softfloat: handle -INT_MAX correctly
- filmstripdec: correctly check image dimensions
- pnmdec: make sure v is capped by maxval
- smvjpegdec: make sure cur_frame is not negative
- icodec: correctly check avio_read return value
- dvbsubdec: fix division by zero in compute_default_clut
- proresdec_lgpl: explicitly check coff[3] against slice_data_size
- escape124: reject codebook size 0
- icodec: add ico_read_close to fix leaking ico->images
- icodec: fix leaking pkt on error
- mpegts: prevent division by zero
- matroskadec: fix NULL pointer dereference in webm_dash_manifest_read_header
- mpegaudio_parser: don't return AVERROR_PATCHWELCOME
- mxfdec: fix NULL pointer dereference
- lzf: update pointer p after realloc
- diracdec: check return code of get_buffer_with_edge
- ppc: pixblockdsp: do unaligned block accesses correctly again
- interplayacm: increase bitstream buffer size by AV_INPUT_BUFFER_PADDING_SIZE
- interplayacm: validate number of channels
- interplayacm: check for too large b
- mpeg12dec: unref discarded picture from extradata
- cavsdec: unref frame before referencing again
- dcstr: fix division by zero
- aiff: check block_align in aiff_read_packet
- rsd: limit number of channels
- avformat: prevent triggering request_probe assert in ff_read_packet
- westwood_aud: prevent division by zero
- astdec: fix division by zero
- aiffdec: fix division by zero
- avcodec/avpacket: fix leak on realloc in av_packet_add_side_data()
-
-version 3.1.5:
- avformat/mxfdec: Check size to avoid integer overflow in mxf_read_utf16_string()
- avcodec/mpegvideo_enc: Clear mmx state in ff_mpv_reallocate_putbitbuffer()
- avcodec/utils: Clear MMX state before returning from avcodec_default_execute*()
- doc/examples/demuxing_decoding: Drop AVFrame->pts use
- libopenjpegenc: fix out-of-bounds reads when filling the edges
- libopenjpegenc: stop reusing image data buffer for openjpeg 2
- configure: fix detection of libopenjpeg
- doc: fix various typos and grammar errors
- avformat/utils: Update codec_id before using it in the parser init
- cmdutils: fix typos
- lavfi: fix typos
- lavc: fix typos
- tools: fix grammar error
- ffmpeg: remove unused and errorneous AVFrame timestamp check
- Support for MIPS cpu P6600
- avutil/mips/generic_macros_msa: rename macro variable which causes segfault for mips r6
-
-version 3.1.4:
- avformat/avidec: Check nb_streams in read_gab2_sub()
- avformat/avidec: Remove ancient assert
- avfilter/vf_colorspace: fix range for output colorspace option
- lavc/mediacodecdec_h264: fix SODB escaping
- avcodec/nvenc: fix const options for hevc gpu setting
- avformat/avidec: Fix memleak with dv in avi
- lavc/movtextdec.c: Avoid infinite loop on invalid data.
- avcodec/ansi: Check dimensions
- avcodec/cavsdsp: use av_clip_uint8() for idct
- avformat/movenc: Check packet in mov_write_single_packet() too
- avformat/movenc: Factor check_pkt() out
- avformat/utils: fix timebase error in avformat_seek_file()
- avcodec/g726: Add missing ADDB output mask
- avcodec/avpacket: clear side_data_elems
- avformat/movenc: Check first DTS similar to dts difference
- avcodec/ccaption_dec: Use simple array instead of AVBuffer
- avcodec/svq3: Reintroduce slice_type
- avformat/mov: Fix potential integer overflow in mov_read_keys
- swscale/swscale_unscaled: Try to fix Rgb16ToPlanarRgb16Wrapper() with slices
- swscale/swscale_unscaled: Fix packed_16bpc_bswap() with slices
- avformat/avidec: Fix infinite loop in avi_read_nikon()
- lavf/utils: Avoid an overflow for huge negative durations.
- avformat/hls: Fix handling of EXT-X-BYTERANGE streams over 2GB
- lavc/avpacket: Fix undefined behaviour, do not pass a null pointer to memcpy().
- lavc/mjpegdec: Do not skip reading quantization tables.
- cmdutils: fix implicit declaration of SetDllDirectory function
-
-version 3.1.3:
- examples/demuxing_decoding: convert to codecpar
- avcodec/exr: Check tile positions
- avcodec/aacenc: Tighter input checks
- avformat/wtvdec: Check pointer before use
- libavcodec/wmalosslessdec: Check the remaining bits
- avcodec/adpcm: Fix adpcm_ima_wav padding
- avcodec/svq3: fix slice size check
- avcodec/diracdec: Check numx/y
- avcodec/h2645_parse: fix nal size
- avcodec/h2645_parse: Use get_nalsize() in ff_h2645_packet_split()
- h2645_parse: only read avc length code at the correct position
- h2645_parse: don't overread AnnexB NALs within an avc stream
- avcodec/h264_parser: Factor get_avc_nalsize() out
- avcodec/cfhd: Increase minimum band dimension to 3
- avcodec/indeo2: check ctab
- avformat/swfdec: Fix inflate() error code check
- avcodec/rawdec: Fix bits_per_coded_sample checks
- vcodec/h2645_parse: Clear buffer padding
- avcodec/h2645: Fix NAL unit padding
- avfilter/drawutils: Fix single plane with alpha
- cmdutils: check for SetDllDirectory() availability
-
-version 3.1.2:
- cmdutils: remove the current working directory from the DLL search path on win32
- avcodec/rawdec: Fix palette handling with changing palettes
- avcodec/raw: Fix decoding of ilacetest.mov
- avformat/mov: Enable mp3 parsing if a packet needs it
- avformat/hls: Use an array instead of stream offset for stream mapping
- avformat/hls: Sync starting segment across variants on live streams
- avformat/hls: Fix regression with ranged media segments
- avcodec/ffv1enc: Fix assertion failure with non zero bits per sample
- avfilter/af_hdcd: small fix in af_hdcd.c where gain was not being adjusted for "attenuate slowly"
- avformat/oggdec: Fix integer overflow with invalid pts
- ffplay: Fix invalid array index
- avcodec/alacenc: allocate bigger packets (cherry picked from commit 82b84c71b009884c8d041361027718b19922c76d)
- libavcodec/dnxhd: Enable 12-bit DNxHR support.
- lavc/vaapi_encode_h26x: Fix a crash if "." is not the decimal separator.
- jni: Return ENOSYS on unsupported platforms
- lavu/hwcontext_vaapi: Fix compilation if VA_FOURCC_ABGR is not defined.
- avcodec/vp9_parser: Check the input frame sizes for being consistent
- avformat/flvdec: parse keyframe before a\v stream was created add_keyframes_index() when stream created or keyframe parsed
- avformat/flvdec: splitting add_keyframes_index() out from parse_keyframes_index()
- libavformat/rtpdec_asf: zero initialize the AVIOContext struct
- libavutil/opt: Small bugfix in example.
- libx264: Increase x264 opts character limit to 4096
- avcodec/h264_parser: Set sps/pps_ref
- librtmp: Avoid an infiniloop setting connection arguments
- avformat/oggparsevp8: fix pts calculation on pages ending with an invisible frame
- lavc/Makefile: Fix standalone compilation of the svq3 decoder.
- lavf/vplayerdec: Improve auto-detection.
- lavc/mediacodecdec_h264: properly convert extradata to annex-b
- Revert "configure: Enable GCC vectorization on ≥4.9 on x86"
-
-version 3.1.1:
- doc/APIchanges: document the lavu/lavf field moves
- avformat/avformat: Move new field to the end of AVStream
- avformat/utils: update deprecated AVStream->codec when the context is updated
- avutil/frame: Move new field to the end of AVFrame
- libavcodec/exr : fix decoding piz float file.
- avformat/mov: Check sample size
- lavfi: Move new field to the end of AVFilterContext
- lavfi: Move new field to the end of AVFilterLink
- ffplay: Fix usage of private lavfi API
- lavc/mediacodecdec_h264: add missing NAL headers to SPS/PPS buffers
- lavc/pnm_parser: disable parsing for text based PNMs
+version <next>:
+- YUY2 Lossless Codec decoder


 version 3.1:
@@ -605,8 +48,6 @@ version 3.1:
 - CUDA CUVID H264/HEVC decoder
 - 10-bit depth support in native utvideo decoder
 - libutvideo wrapper removed
- YUY2 Lossless Codec decoder
- VideoToolbox H.264 encoder


 version 3.0:
--- a/2
+++ b/2
@@ -1 +1 @@
-3.1.9
+3.0.git
--- a/15
+++ b/15
@@ -1,15 +0,0 @@
-
-              ┌────────────────────────────────────────┐
-              │ RELEASE NOTES for FFmpeg 3.1 "Laplace" │
-              └────────────────────────────────────────┘
-
-   The FFmpeg Project proudly presents FFmpeg 3.1 "Laplace", about 4
-   months after the release of FFmpeg 3.0.
-
-   A complete Changelog is available at the root of the project, and the
-   complete Git history on http://source.ffmpeg.org.
-
-   We hope you will like this release as much as we enjoyed working on it, and
-   as usual, if you have any questions about it, or any FFmpeg related topic,
-   feel free to join us on the #ffmpeg IRC channel (on irc.freenode.net) or ask
-   on the mailing-lists.
--- a/cmdutils.c
+++ b/cmdutils.c
@@ -61,9 +61,6 @@
 #include <sys/time.h>
 #include <sys/resource.h>
 #endif
-#if HAVE_SETDLLDIRECTORY
-#include <windows.h>
-#endif

 static int init_report(const char *env);

@@ -110,15 +107,6 @@ static void log_callback_report(void *ptr, int level, const char *fmt, va_list v
    }
 }

-void init_dynload(void)
-{
-#if HAVE_SETDLLDIRECTORY
-    /* Calling SetDllDirectory with the empty string (but not NULL) removes the
-     * current working directory from the DLL search path as a security pre-caution. */
-    SetDllDirectory("");
-#endif
-}
-
 static void (*program_exit)(int ret);

 void register_exit(void (*cb)(int ret))
@@ -2111,7 +2099,7 @@ static int print_device_sources(AVInputFormat *fmt, AVDictionary *opts)
    if (!fmt || !fmt->priv_class  || !AV_IS_INPUT_DEVICE(fmt->priv_class->category))
        return AVERROR(EINVAL);

-    printf("Auto-detected sources for %s:\n", fmt->name);
+    printf("Audo-detected sources for %s:\n", fmt->name);
    if (!fmt->get_device_list) {
        ret = AVERROR(ENOSYS);
        printf("Cannot list sources. Not implemented.\n");
@@ -2141,7 +2129,7 @@ static int print_device_sinks(AVOutputFormat *fmt, AVDictionary *opts)
    if (!fmt || !fmt->priv_class  || !AV_IS_OUTPUT_DEVICE(fmt->priv_class->category))
        return AVERROR(EINVAL);

-    printf("Auto-detected sinks for %s:\n", fmt->name);
+    printf("Audo-detected sinks for %s:\n", fmt->name);
    if (!fmt->get_device_list) {
        ret = AVERROR(ENOSYS);
        printf("Cannot list sinks. Not implemented.\n");
--- a/cmdutils.h
+++ b/cmdutils.h
@@ -61,11 +61,6 @@ void register_exit(void (*cb)(int ret));
 */
 void exit_program(int ret) av_noreturn;

-/**
- * Initialize dynamic library loading
- */
-void init_dynload(void);
-
 /**
 * Initialize the cmdutils option system, in particular
 * allocate the *_opts contexts.
@@ -450,13 +445,13 @@ int show_devices(void *optctx, const char *opt, const char *arg);

 #if CONFIG_AVDEVICE
 /**
- * Print a listing containing autodetected sinks of the output device.
+ * Print a listing containing audodetected sinks of the output device.
 * Device name with options may be passed as an argument to limit results.
 */
 int show_sinks(void *optctx, const char *opt, const char *arg);

 /**
- * Print a listing containing autodetected sources of the input device.
+ * Print a listing containing audodetected sources of the input device.
 * Device name with options may be passed as an argument to limit results.
 */
 int show_sources(void *optctx, const char *opt, const char *arg);
--- a/28
+++ b/28
@@ -1935,7 +1935,6 @@ SYSTEM_FUNCS="
    sched_getaffinity
    SetConsoleTextAttribute
    SetConsoleCtrlHandler
-    SetDllDirectory
    setmode
    setrlimit
    Sleep
@@ -4336,7 +4335,7 @@ elif enabled mips; then
                enable mips32r2
                disable msa
            ;;
-            p5600|i6400|p6600)
+            p5600|i6400)
                disable mipsdsp
                disable mipsdspr2
            ;;
@@ -4401,10 +4400,6 @@ elif enabled mips; then
                enable mips64r6
                check_cflags "-mtune=i6400 -mabi=64" && check_cflags "-msched-weight -mload-store-pairs -funroll-loops" && check_ldflags "-mabi=64"
            ;;
-            p6600)
-                enable mips64r6
-                check_cflags "-mtune=p6600 -mabi=64" && check_cflags "-msched-weight -mload-store-pairs -funroll-loops" && check_ldflags "-mabi=64"
-            ;;
        esac
    else
        # We do not disable anything. Is up to the user to disable the unwanted features.
@@ -4534,7 +4529,7 @@ fi

 add_cppflags -D_ISOC99_SOURCE
 add_cxxflags -D__STDC_CONSTANT_MACROS
-add_cxxflags -std=c++98
+add_cxxflags -std=c++11
 check_cflags -std=c99
 check_cc -D_FILE_OFFSET_BITS=64 <<EOF && add_cppflags -D_FILE_OFFSET_BITS=64
 #include <stdlib.h>
@@ -5480,7 +5475,6 @@ check_func_headers windows.h MapViewOfFile
 check_func_headers windows.h PeekNamedPipe
 check_func_headers windows.h SetConsoleTextAttribute
 check_func_headers windows.h SetConsoleCtrlHandler
-check_func_headers windows.h SetDllDirectory
 check_func_headers windows.h Sleep
 check_func_headers windows.h VirtualAlloc
 check_struct windows.h "CONDITION_VARIABLE" Ptr
@@ -5675,11 +5669,10 @@ enabled libopencv         && { check_header opencv2/core/core_c.h &&
                                 require opencv opencv2/core/core_c.h cvCreateImageHeader -lopencv_core -lopencv_imgproc; } ||
                               require_pkg_config opencv opencv/cxcore.h cvCreateImageHeader; }
 enabled libopenh264       && require_pkg_config openh264 wels/codec_api.h WelsGetCodecVersion
-enabled libopenjpeg       && { { check_lib2 openjpeg-2.1/openjpeg.h opj_version -lopenjp2 -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
-                               check_lib2 openjpeg-2.1/openjpeg.h opj_version -lopenjp2 ||
-                               { check_lib2 openjpeg-2.0/openjpeg.h opj_version -lopenjp2 -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
-                               { check_lib2 openjpeg-1.5/openjpeg.h opj_version -lopenjpeg -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
-                               { check_lib2 openjpeg.h opj_version -lopenjpeg -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
+enabled libopenjpeg       && { check_lib openjpeg-2.1/openjpeg.h opj_version -lopenjp2 -DOPJ_STATIC ||
+                               check_lib openjpeg-2.0/openjpeg.h opj_version -lopenjp2 -DOPJ_STATIC ||
+                               check_lib openjpeg-1.5/openjpeg.h opj_version -lopenjpeg -DOPJ_STATIC ||
+                               check_lib openjpeg.h opj_version -lopenjpeg -DOPJ_STATIC ||
                               die "ERROR: libopenjpeg not found"; }
 enabled libopus           && require_pkg_config opus opus_multistream.h opus_multistream_decoder_create
 enabled libpulse          && require_pkg_config libpulse pulse/pulseaudio.h pa_context_new
@@ -6132,7 +6125,11 @@ elif enabled ccc; then
    add_cflags -msg_disable nonstandcast
    add_cflags -msg_disable unsupieee
 elif enabled gcc; then
-    check_optflags -fno-tree-vectorize
+    case $gcc_basever in
+        4.9*) enabled x86 || check_optflags -fno-tree-vectorize ;;
+        4.*)                 check_optflags -fno-tree-vectorize ;;
+        *)    enabled x86 || check_optflags -fno-tree-vectorize ;;
+    esac
    check_cflags -Werror=format-security
    check_cflags -Werror=implicit-function-declaration
    check_cflags -Werror=missing-prototypes
@@ -6197,7 +6194,6 @@ __declspec($_restrict) void* foo(int);
 EOF
    fi
    check_func strtoll || add_cflags -Dstrtoll=_strtoi64
-    check_func strtoull || add_cflags -Dstrtoull=_strtoui64
 fi

 for pfx in "" host_; do
@@ -6624,7 +6620,7 @@ cat > $TMPH <<EOF
 #define FFMPEG_CONFIG_H
 #define FFMPEG_CONFIGURATION "$(c_escape $FFMPEG_CONFIGURATION)"
 #define FFMPEG_LICENSE "$(c_escape $license)"
-#define CONFIG_THIS_YEAR 2017
+#define CONFIG_THIS_YEAR 2016
 #define FFMPEG_DATADIR "$(eval c_escape $datadir)"
 #define AVCONV_DATADIR "$(eval c_escape $datadir)"
 #define CC_IDENT "$(c_escape ${cc_ident:-Unknown compiler})"
--- a/doc/APIchanges
+++ b/doc/APIchanges
@@ -15,30 +15,14 @@ libavutil:     2015-08-28

 API changes, most recent first:

-2016-06-30 - c1c7e0ab - lavf 57.41.100 - avformat.h
-  Moved codecpar field from AVStream to the end of the struct, so that
-  the following private fields are in the same location as in FFmpeg 3.0 (lavf 57.25.100).
-
-2016-06-30 - 042fb69d - lavu 55.28.100 - frame.h
-  Moved hw_frames_ctx field from AVFrame to the end of the struct, so that
-  the following private fields are in the same location as in FFmpeg 3.0 (lavu 55.17.103).
-
-2016-06-29 - 1a751455 - lavfi 6.47.100 - avfilter.h
-  Fix accidental ABI breakage in AVFilterContext.
-  ABI was broken in 8688d3a, lavfi 6.42.100 and released as ffmpeg 3.1.
-
-  Because of this, ffmpeg and ffplay built against lavfi>=6.42.100 will not be
-  compatible with lavfi>=6.47.100. Potentially also affects other users of
-  libavfilter if they are using one of the affected fields.
-
-------- 8< --------- FFmpeg 3.1 was cut here -------- 8< ---------
-
-2016-06-26 - 481f320 / 1c9e861 - lavu 55.27.100 / 55.13.0 - hwcontext.h
+2016-06-26 - xxxxxxx / 1c9e861 - lavu 55.27.100 / 55.13.0 - hwcontext.h
  Add av_hwdevice_ctx_create().

-2016-06-26 - b95534b / e47b8bb - lavc 57.48.101 / 57.19.1 - avcodec.h
+2016-06-26 - xxxxxxx / e47b8bb - lavc 57.48.101 / 57.19.1 - avcodec.h
  Adjust values for JPEG 2000 profiles.

+-------- 8< --------- FFmpeg 3.1 was cut here -------- 8< ---------
+
 2016-06-23 - 5d75e46 / db7968b - lavf 57.40.100 / 57.7.0 - avio.h
  Add AVIODataMarkerType, write_data_type, ignore_boundary_point and
  avio_write_marker.
--- a/doc/Doxyfile
+++ b/doc/Doxyfile
@@ -31,7 +31,7 @@ PROJECT_NAME           = FFmpeg
 # This could be handy for archiving the generated documentation or
 # if some version control system is used.

-PROJECT_NUMBER         = 3.1.9
+PROJECT_NUMBER         =

 # With the PROJECT_LOGO tag one can specify a logo or icon that is included
 # in the documentation. The maximum height of the logo should not exceed 55
--- a/doc/codecs.texi
+++ b/doc/codecs.texi
@@ -1173,7 +1173,7 @@ Set to 1 to disable processing alpha (transparency). This works like the
 instead of alpha. Default is 0.

@item codec_whitelist @var{list} (@emph{input})
-"," separated list of allowed decoders. By default all are allowed.
+"," separated List of allowed decoders. By default all are allowed.

@item dump_separator @var{string} (@emph{input})
 Separator used to separate the fields printed on the command line about the
--- a/doc/demuxers.texi
+++ b/doc/demuxers.texi
@@ -72,7 +72,7 @@ Do not try to resynchronize by looking for a certain optional start code.
 Virtual concatenation script demuxer.

 This demuxer reads a list of files and other directives from a text file and
-demuxes them one after the other, as if all their packets had been muxed
+demuxes them one after the other, as if all their packet had been muxed
 together.

 The timestamps in the files are adjusted so that the first file starts at 0
@@ -107,7 +107,7 @@ Identify the script type and version. It also sets the @option{safe} option
 to 1 if it was -1.

 To make FFmpeg recognize the format automatically, this directive must
-appear exactly as is (no extra space or byte-order-mark) on the very first
+appears exactly as is (no extra space or byte-order-mark) on the very first
 line of the script.

@item @code{duration @var{dur}}
--- a/doc/developer.texi
+++ b/doc/developer.texi
@@ -131,11 +131,6 @@ designated struct initializers (@samp{struct s x = @{ .i = 17 @};});

@item
 compound literals (@samp{x = (struct s) @{ 17, 23 @};}).
-
-@item
-Implementation defined behavior for signed integers is assumed to match the
-expected behavior for two's complement. Non representable values in integer
-casts are binary truncated. Shift right of signed values uses sign extension.
@end itemize

 These features are supported by all compilers we care about, so we will not
--- a/doc/examples/demuxing_decoding.c
+++ b/doc/examples/demuxing_decoding.c
@@ -93,9 +93,10 @@ static int decode_packet(int *got_frame, int cached)
                return -1;
            }

-            printf("video_frame%s n:%d coded_n:%d\n",
+            printf("video_frame%s n:%d coded_n:%d pts:%s\n",
                   cached ? "(cached)" : "",
-                   video_frame_count++, frame->coded_picture_number);
+                   video_frame_count++, frame->coded_picture_number,
+                   av_ts2timestr(frame->pts, &video_dec_ctx->time_base));

            /* copy decoded frame to destination buffer:
             * this is required since rawvideo expects non aligned data */
@@ -147,10 +148,11 @@ static int decode_packet(int *got_frame, int cached)
 }

 static int open_codec_context(int *stream_idx,
-                              AVCodecContext **dec_ctx, AVFormatContext *fmt_ctx, enum AVMediaType type)
+                              AVFormatContext *fmt_ctx, enum AVMediaType type)
 {
    int ret, stream_index;
    AVStream *st;
+    AVCodecContext *dec_ctx = NULL;
    AVCodec *dec = NULL;
    AVDictionary *opts = NULL;

@@ -164,31 +166,17 @@ static int open_codec_context(int *stream_idx,
        st = fmt_ctx->streams[stream_index];

        /* find decoder for the stream */
-        dec = avcodec_find_decoder(st->codecpar->codec_id);
+        dec_ctx = st->codec;
+        dec = avcodec_find_decoder(dec_ctx->codec_id);
        if (!dec) {
            fprintf(stderr, "Failed to find %s codec\n",
                    av_get_media_type_string(type));
            return AVERROR(EINVAL);
        }

-        /* Allocate a codec context for the decoder */
-        *dec_ctx = avcodec_alloc_context3(dec);
-        if (!*dec_ctx) {
-            fprintf(stderr, "Failed to allocate the %s codec context\n",
-                    av_get_media_type_string(type));
-            return AVERROR(ENOMEM);
-        }
-
-        /* Copy codec parameters from input stream to output codec context */
-        if ((ret = avcodec_parameters_to_context(*dec_ctx, st->codecpar)) < 0) {
-            fprintf(stderr, "Failed to copy %s codec parameters to decoder context\n",
-                    av_get_media_type_string(type));
-            return ret;
-        }
-
        /* Init the decoders, with or without reference counting */
        av_dict_set(&opts, "refcounted_frames", refcount ? "1" : "0", 0);
-        if ((ret = avcodec_open2(*dec_ctx, dec, &opts)) < 0) {
+        if ((ret = avcodec_open2(dec_ctx, dec, &opts)) < 0) {
            fprintf(stderr, "Failed to open %s codec\n",
                    av_get_media_type_string(type));
            return ret;
@@ -267,8 +255,9 @@ int main (int argc, char **argv)
        exit(1);
    }

-    if (open_codec_context(&video_stream_idx, &video_dec_ctx, fmt_ctx, AVMEDIA_TYPE_VIDEO) >= 0) {
+    if (open_codec_context(&video_stream_idx, fmt_ctx, AVMEDIA_TYPE_VIDEO) >= 0) {
        video_stream = fmt_ctx->streams[video_stream_idx];
+        video_dec_ctx = video_stream->codec;

        video_dst_file = fopen(video_dst_filename, "wb");
        if (!video_dst_file) {
@@ -290,8 +279,9 @@ int main (int argc, char **argv)
        video_dst_bufsize = ret;
    }

-    if (open_codec_context(&audio_stream_idx, &audio_dec_ctx, fmt_ctx, AVMEDIA_TYPE_AUDIO) >= 0) {
+    if (open_codec_context(&audio_stream_idx, fmt_ctx, AVMEDIA_TYPE_AUDIO) >= 0) {
        audio_stream = fmt_ctx->streams[audio_stream_idx];
+        audio_dec_ctx = audio_stream->codec;
        audio_dst_file = fopen(audio_dst_filename, "wb");
        if (!audio_dst_file) {
            fprintf(stderr, "Could not open destination file %s\n", audio_dst_filename);
@@ -379,8 +369,8 @@ int main (int argc, char **argv)
    }

 end:
-    avcodec_free_context(&video_dec_ctx);
-    avcodec_free_context(&audio_dec_ctx);
+    avcodec_close(video_dec_ctx);
+    avcodec_close(audio_dec_ctx);
    avformat_close_input(&fmt_ctx);
    if (video_dst_file)
        fclose(video_dst_file);
--- a/doc/ffmpeg.texi
+++ b/doc/ffmpeg.texi
@@ -12,7 +12,7 @@

@chapter Synopsis

-ffmpeg [@var{global_options}] @{[@var{input_file_options}] -i @file{input_url}@} ... @{[@var{output_file_options}] @file{output_url}@} ...
+ffmpeg [@var{global_options}] @{[@var{input_file_options}] -i @file{input_file}@} ... @{[@var{output_file_options}] @file{output_file}@} ...

@chapter Description
@c man begin DESCRIPTION
@@ -24,10 +24,10 @@ rates and resize video on the fly with a high quality polyphase filter.
@command{ffmpeg} reads from an arbitrary number of input "files" (which can be regular
 files, pipes, network streams, grabbing devices, etc.), specified by the
@code{-i} option, and writes to an arbitrary number of output "files", which are
-specified by a plain output url. Anything found on the command line which
-cannot be interpreted as an option is considered to be an output url.
+specified by a plain output filename. Anything found on the command line which
+cannot be interpreted as an option is considered to be an output filename.

-Each input or output url can, in principle, contain any number of streams of
+Each input or output file can, in principle, contain any number of streams of
 different types (video/audio/subtitle/attachment/data). The allowed number and/or
 types of streams may be limited by the container format. Selecting which
 streams from which inputs will go into which output is either done automatically
@@ -243,8 +243,8 @@ Force input or output file format. The format is normally auto detected for inpu
 files and guessed from the file extension for output files, so this option is not
 needed in most cases.

-@item -i @var{url} (@emph{input})
-input file url
+@item -i @var{filename} (@emph{input})
+input file name

@item -y (@emph{global})
 Overwrite output files without asking.
@@ -281,7 +281,7 @@ libx264, and the 138th audio, which will be encoded with libvorbis.
 When used as an input option (before @code{-i}), limit the @var{duration} of
 data read from the input file.

-When used as an output option (before an output url), stop writing the
+When used as an output option (before an output filename), stop writing the
 output after its duration reaches @var{duration}.

@var{duration} must be a time duration specification,
@@ -310,7 +310,7 @@ extra segment between the seek point and @var{position} will be decoded and
 discarded. When doing stream copy or when @option{-noaccurate_seek} is used, it
 will be preserved.

-When used as an output option (before an output url), decodes but discards
+When used as an output option (before an output filename), decodes but discards
 input until the timestamps reach @var{position}.

@var{position} must be a time duration specification,
@@ -1008,7 +1008,7 @@ Dump each input packet to stderr.
@item -hex (@emph{global})
 When dumping packets, also dump the payload.
@item -re (@emph{input})
-Read input at native frame rate. Mainly used to simulate a grab device,
+Read input at native frame rate. Mainly used to simulate a grab device.
 or live input stream (e.g. when reading from a file). Should not be used
 with actual grab devices or live input streams (where it can cause packet
 loss).
@@ -1129,7 +1129,7 @@ may be reassigned to a different value.
 For example, to set the stream 0 PID to 33 and the stream 1 PID to 36 for
 an output mpegts file:
@example
-ffmpeg -i inurl -streamid 0:33 -streamid 1:36 out.ts
+ffmpeg -i infile -streamid 0:33 -streamid 1:36 out.ts
@end example

@item -bsf[:@var{stream_specifier}] @var{bitstream_filters} (@emph{output,per-stream})
--- a/doc/ffplay.texi
+++ b/doc/ffplay.texi
@@ -12,7 +12,7 @@

@chapter Synopsis

-ffplay [@var{options}] [@file{input_url}]
+ffplay [@var{options}] [@file{input_file}]

@chapter Description
@c man begin DESCRIPTION
@@ -106,8 +106,8 @@ the input audio.
 Use the option "-filters" to show all the available filters (including
 sources and sinks).

-@item -i @var{input_url}
-Read @var{input_url}.
+@item -i @var{input_file}
+Read @var{input_file}.
@end table

@section Advanced options
--- a/doc/ffprobe.texi
+++ b/doc/ffprobe.texi
@@ -12,7 +12,7 @@

@chapter Synopsis

-ffprobe [@var{options}] [@file{input_url}]
+ffprobe [@var{options}] [@file{input_file}]

@chapter Description
@c man begin DESCRIPTION
@@ -24,8 +24,8 @@ For example it can be used to check the format of the container used
 by a multimedia stream and the format and type of each media stream
 contained in it.

-If a url is specified in input, ffprobe will try to open and
-probe the url content. If the url cannot be opened or recognized as
+If a filename is specified in input, ffprobe will try to open and
+probe the file content. If the file cannot be opened or recognized as
 a multimedia file, a positive exit code is returned.

 ffprobe may be employed both as a standalone application or in
@@ -332,8 +332,8 @@ with name "PIXEL_FORMAT".
 Force bitexact output, useful to produce output which is not dependent
 on the specific build.

-@item -i @var{input_url}
-Read @var{input_url}.
+@item -i @var{input_file}
+Read @var{input_file}.

@end table
@c man end
--- a/doc/fftools-common-opts.texi
+++ b/doc/fftools-common-opts.texi
@@ -176,10 +176,10 @@ loglevel will be used. If multiple loglevel parameters are given, using
 Show nothing at all; be silent.
@item panic, 0
 Only show fatal errors which could lead the process to crash, such as
-an assertion failure. This is not currently used for anything.
+and assert failure. This is not currently used for anything.
@item fatal, 8
 Only show fatal errors. These are errors after which the process absolutely
-cannot continue.
+cannot continue after.
@item error, 16
 Show all errors, including ones which can be recovered from.
@item warning, 24
@@ -195,13 +195,13 @@ Show everything, including debugging information.
@item trace, 56
@end table

-By default the program logs to stderr. If coloring is supported by the
+By default the program logs to stderr, if coloring is supported by the
 terminal, colors are used to mark errors and warnings. Log coloring
 can be disabled setting the environment variable
@env{AV_LOG_FORCE_NOCOLOR} or @env{NO_COLOR}, or can be forced setting
 the environment variable @env{AV_LOG_FORCE_COLOR}.
 The use of the environment variable @env{NO_COLOR} is deprecated and
-will be dropped in a future FFmpeg version.
+will be dropped in a following FFmpeg version.

@item -report
 Dump full command line and console output to a file named
--- a/doc/filters.texi
+++ b/doc/filters.texi
@@ -845,14 +845,14 @@ A gate is mainly used to reduce lower parts of a signal. This kind of signal
 processing reduces disturbing noise between useful signals.

 Gating is done by detecting the volume below a chosen level @var{threshold}
-and dividing it by the factor set with @var{ratio}. The bottom of the noise
+and divide it by the factor set with @var{ratio}. The bottom of the noise
 floor is set via @var{range}. Because an exact manipulation of the signal
 would cause distortion of the waveform the reduction can be levelled over
 time. This is done by setting @var{attack} and @var{release}.

@var{attack} determines how long the signal has to fall below the threshold
 before any reduction will occur and @var{release} sets the time the signal
-has to rise above the threshold to reduce the reduction again.
+has to raise above the threshold to reduce the reduction again.
 Shorter signals than the chosen attack time will be left untouched.

@table @option
@@ -869,7 +869,7 @@ If a signal rises above this level the gain reduction is released.
 Default is 0.125. Allowed range is from 0 to 1.

@item ratio
-Set a ratio by which the signal is reduced.
+Set a ratio about which the signal is reduced.
 Default is 2. Allowed range is from 1 to 9000.

@item attack
@@ -892,19 +892,19 @@ Default is 2.828427125. Allowed range is from 1 to 8.

@item detection
 Choose if exact signal should be taken for detection or an RMS like one.
-Default is @code{rms}. Can be @code{peak} or @code{rms}.
+Default is rms. Can be peak or rms.

@item link
 Choose if the average level between all channels or the louder channel affects
 the reduction.
-Default is @code{average}. Can be @code{average} or @code{maximum}.
+Default is average. Can be average or maximum.
@end table

@section alimiter

-The limiter prevents an input signal from rising over a desired threshold.
+The limiter prevents input signal from raising over a desired threshold.
 This limiter uses lookahead technology to prevent your signal from distorting.
-It means that there is a small delay after the signal is processed. Keep in mind
+It means that there is a small delay after signal is processed. Keep in mind
 that the delay it produces is the attack time you set.

 The filter accepts the following options:
@@ -1353,7 +1353,7 @@ Set the number of samples per each output audio frame.

 The last output packet may contain a different number of samples, as
 the filter will flush all the remaining samples when the input audio
-signals its end.
+signal its end.

 The filter accepts the following options:

@@ -2445,7 +2445,7 @@ filtering with large delay. Default is disabled.
 Enable multichannels evaluation on gain. Default is disabled.

@item zero_phase
-Enable zero phase mode by subtracting timestamp to compensate delay.
+Enable zero phase mode by substracting timestamp to compensate delay.
 Default is disabled.
@end table

@@ -3216,7 +3216,7 @@ Can be specified in dB (in case "dB" is appended to the specified value)
 or amplitude ratio. Default value is @code{0}.

@item leave_silence
-This indicates that @var{stop_duration} length of audio should be left intact
+This indicate that @var{stop_duration} length of audio should be left intact
 at the beginning of each period of silence.
 For example, if you want to remove long pauses between words but do not want
 to remove the pauses completely. Default value is @code{0}.
@@ -6622,10 +6622,10 @@ This option does not exist, please see the timeline system

@item alpha
 Draw the text applying alpha blending. The value can
-be a number between 0.0 and 1.0.
-The expression accepts the same variables @var{x, y} as well.
+be either a number between 0.0 and 1.0
+The expression accepts the same variables @var{x, y} do.
 The default value is 1.
-Please see @var{fontcolor_expr}.
+Please see fontcolor_expr

@item fontsize
 The font size to be used for drawing text.
@@ -6808,7 +6808,7 @@ the following expansion mechanism is used.
 The backslash character @samp{\}, followed by any character, always expands to
 the second character.

-Sequences of the form @code{%@{...@}} are expanded. The text between the
+Sequence of the form @code{%@{...@}} are expanded. The text between the
 braces is a function name, possibly followed by arguments separated by ':'.
 If the arguments contain special characters or delimiters (':' or '@}'),
 they should be escaped.
@@ -8714,8 +8714,8 @@ value.

 Detect video interlacing type.

-This filter tries to detect if the input frames are interlaced, progressive,
-top or bottom field first. It will also try to detect fields that are
+This filter tries to detect if the input frames as interlaced, progressive,
+top or bottom field first. It will also try and detect fields that are
 repeated between adjacent frames (a sign of telecine).

 Single frame detection considers only immediately adjacent frames when classifying each frame.
@@ -8782,7 +8782,7 @@ Set progressive threshold.
 Threshold for repeated field detection.
@item half_life
 Number of frames after which a given frame's contribution to the
-statistics is halved (i.e., it contributes only 0.5 to its
+statistics is halved (i.e., it contributes only 0.5 to it's
 classification). The default of 0 means that all frames seen are given
 full weight of 1.0 forever.
@item analyze_interlaced_flag
@@ -11514,7 +11514,7 @@ uses the reference video instead of the main input as basis.

@itemize
@item
-Scale a subtitle stream (b) to match the main video (a) in size before overlaying
+Scale a subtitle stream to match the main video in size before overlaying
@example
 'scale2ref[b][a];[a][b]overlay'
@end example
@@ -14281,7 +14281,7 @@ syntax is deprecated:
 Create a pattern generated by an elementary cellular automaton.

 The initial state of the cellular automaton can be defined through the
-@option{filename} and @option{pattern} options. If such options are
+@option{filename}, and @option{pattern} options. If such options are
 not specified an initial state is created randomly.

 At each new frame a new row in the video is filled with the result of
@@ -15324,7 +15324,7 @@ Temporally interleave frames from several inputs.
 These filters read frames from several inputs and send the oldest
 queued frame to the output.

-Input streams must have well defined, monotonically increasing frame
+Input streams must have a well defined, monotonically increasing frame
 timestamp values.

 In order to submit one frame to output, these filters need to enqueue
@@ -15332,9 +15332,9 @@ at least one frame for each input, so they cannot work in case one
 input is not yet terminated and will not receive incoming frames.

 For example consider the case when one input is a @code{select} filter
-which always drops input frames. The @code{interleave} filter will keep
+which always drop input frames. The @code{interleave} filter will keep
 reading from that input, but it will never be able to send new frames
-to output until the input sends an end-of-stream signal.
+to output until the input will send an end-of-stream signal.

 Also, depending on inputs synchronization, the filters will drop
 frames in case one input receives more frames than the other ones, and
--- a/doc/formats.texi
+++ b/doc/formats.texi
@@ -195,7 +195,7 @@ delayed bt the time duration specified in @var{offset}. Default value
 is @code{0} (meaning that no offset is applied).

@item format_whitelist @var{list} (@emph{input})
-"," separated list of allowed demuxers. By default all are allowed.
+"," separated List of allowed demuxers. By default all are allowed.

@item dump_separator @var{string} (@emph{input})
 Separator used to separate the fields printed on the command line about the
@@ -205,10 +205,6 @@ For example to separate the fields with newlines and indention:
 ffprobe -dump_separator "
                          "  -i ~/videos/matrixbench_mpeg2.mpg
@end example
-
-@item max_streams @var{integer} (@emph{input})
-Specifies the maximum number of streams. This can be used to reject files that
-would require too many resources due to a large number of streams.
@end table

@c man end FORMAT OPTIONS
--- a/doc/indevs.texi
+++ b/doc/indevs.texi
@@ -656,7 +656,7 @@ is an exact value. For HDV, it is not frame exact, since HDV does
 not have a fixed frame size.

@item dvguid
-Select the capture device by specifying its GUID. Capturing will only
+Select the capture device by specifying it's GUID. Capturing will only
 be performed from the specified device and fails if no device with the
 given GUID is found. This is useful to select the input if multiple
 devices are connected at the same time.
@@ -1319,7 +1319,7 @@ ffmpeg -f x11grab -framerate 25 -video_size cif -i :0.0+10,20 out.mpg

@table @option
@item draw_mouse
-Specify whether to draw the mouse pointer. A value of @code{0} specifies
+Specify whether to draw the mouse pointer. A value of @code{0} specify
 not to draw the pointer. Default value is @code{1}.

@item follow_mouse
--- a/doc/muxers.texi
+++ b/doc/muxers.texi
@@ -274,14 +274,14 @@ the loops:
 ffmpeg -i INPUT -loop 10 -final_delay 500 out.gif
@end example

-Note 1: if you wish to extract the frames into separate GIF files, you need to
+Note 1: if you wish to extract the frames in separate GIF files, you need to
 force the @ref{image2} muxer:
@example
 ffmpeg -i INPUT -c:v gif -f image2 "out%d.gif"
@end example

-Note 2: the GIF format has a very large time base: the delay between two frames
-can therefore not be smaller than one centi second.
+Note 2: the GIF format has a very small time base: the delay between two frames
+can not be smaller than one centi second.

@anchor{hash}
@section hash
--- a/doc/platform.texi
+++ b/doc/platform.texi
@@ -173,7 +173,7 @@ earlier, place @code{c99wrap.exe} and @code{c99conv.exe} somewhere in your
 Next, make sure any other headers and libs you want to use, such as zlib, are
 located in a spot that the compiler can see. Do so by modifying the @code{LIB}
 and @code{INCLUDE} environment variables to include the @strong{Windows-style}
-paths to these directories. Alternatively, you can try to use the
+paths to these directories. Alternatively, you can try and use the
@code{--extra-cflags}/@code{--extra-ldflags} configure options. If using MSVC
 2012 or earlier, place @code{inttypes.h} somewhere the compiler can see too.

--- a/doc/protocols.texi
+++ b/doc/protocols.texi
@@ -355,7 +355,7 @@ autodetection in the future.
 If set to 1 enables experimental HTTP server. This can be used to send data when
 used as an output option, or read data from a client with HTTP POST when used as
 an input option.
-If set to 2 enables experimental multi-client HTTP server. This is not yet implemented
+If set to 2 enables experimental mutli-client HTTP server. This is not yet implemented
 in ffmpeg.c or ffserver.c and thus must not be used as a command line option.
@example
 # Server side (sending):
--- a/ffmpeg.c
+++ b/ffmpeg.c
@@ -2026,7 +2026,12 @@ static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
            }
    }

-    if (decoded_frame->pkt_pts != AV_NOPTS_VALUE) {
+    /* if the decoder provides a pts, use it instead of the last packet pts.
+       the decoder could be delaying output by a packet or more. */
+    if (decoded_frame->pts != AV_NOPTS_VALUE) {
+        ist->dts = ist->next_dts = ist->pts = ist->next_pts = av_rescale_q(decoded_frame->pts, avctx->time_base, AV_TIME_BASE_Q);
+        decoded_frame_tb   = avctx->time_base;
+    } else if (decoded_frame->pkt_pts != AV_NOPTS_VALUE) {
        decoded_frame->pts = decoded_frame->pkt_pts;
        decoded_frame_tb   = ist->st->time_base;
    } else if (pkt->pts != AV_NOPTS_VALUE) {
@@ -4298,8 +4303,6 @@ int main(int argc, char **argv)
    int ret;
    int64_t ti;

-    init_dynload();
-
    register_exit(ffmpeg_cleanup);

    setvbuf(stderr,NULL,_IONBF,0); /* win32 runtime needs this */
--- a/ffmpeg_opt.c
+++ b/ffmpeg_opt.c
@@ -3009,8 +3009,8 @@ enum OptGroup {
 };

 static const OptionGroupDef groups[] = {
-    [GROUP_OUTFILE] = { "output url",  NULL, OPT_OUTPUT },
-    [GROUP_INFILE]  = { "input url",   "i",  OPT_INPUT },
+    [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
+    [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
 };

 static int open_files(OptionGroupList *l, const char *inout,
--- a/ffplay.c
+++ b/ffplay.c
@@ -2725,7 +2725,7 @@ static int stream_component_open(VideoState *is, int stream_index)
                goto fail;
            link = is->out_audio_filter->inputs[0];
            sample_rate    = link->sample_rate;
-            nb_channels    = avfilter_link_get_channels(link);
+            nb_channels    = link->channels;
            channel_layout = link->channel_layout;
        }
 #else
@@ -2936,7 +2936,7 @@ static int read_thread(void *arg)
        AVStream *st = ic->streams[i];
        enum AVMediaType type = st->codecpar->codec_type;
        st->discard = AVDISCARD_ALL;
-        if (type >= 0 && wanted_stream_spec[type] && st_index[type] == -1)
+        if (wanted_stream_spec[type] && st_index[type] == -1)
            if (avformat_match_stream_specifier(ic, st, wanted_stream_spec[type]) > 0)
                st_index[type] = i;
    }
@@ -3776,8 +3776,6 @@ int main(int argc, char **argv)
    char dummy_videodriver[] = "SDL_VIDEODRIVER=dummy";
    char alsa_bufsize[] = "SDL_AUDIO_ALSA_SET_BUFFER_SIZE=1";

-    init_dynload();
-
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
    parse_loglevel(argc, argv, options);

--- a/ffprobe.c
+++ b/ffprobe.c
@@ -3241,8 +3241,6 @@ int main(int argc, char **argv)
    char *w_name = NULL, *w_args = NULL;
    int ret, i;

-    init_dynload();
-
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
    register_exit(ffprobe_cleanup);

--- a/ffserver.c
+++ b/ffserver.c
@@ -2702,10 +2702,8 @@ static int http_receive_data(HTTPContext *c)
        } else if (c->buffer_ptr - c->buffer >= 2 &&
                   !memcmp(c->buffer_ptr - 1, "\r\n", 2)) {
            c->chunk_size = strtol(c->buffer, 0, 16);
-            if (c->chunk_size <= 0) { // end of stream or invalid chunk size
-                c->chunk_size = 0;
+            if (c->chunk_size == 0) // end of stream
                goto fail;
-            }
            c->buffer_ptr = c->buffer;
            break;
        } else if (++loop_run > 10)
@@ -2727,7 +2725,6 @@ static int http_receive_data(HTTPContext *c)
            /* end of connection : close it */
            goto fail;
        else {
-            av_assert0(len <= c->chunk_size);
            c->chunk_size -= len;
            c->buffer_ptr += len;
            c->data_count += len;
@@ -3983,7 +3980,6 @@ int main(int argc, char **argv)
    int cfg_parsed;
    int ret = EXIT_FAILURE;

-    init_dynload();

    config.filename = av_strdup("/etc/ffserver.conf");

--- a/ffserver_config.c
+++ b/ffserver_config.c
@@ -323,8 +323,6 @@ done:
    av_dict_free(&recommended);
    av_stream_set_recommended_encoder_configuration(st, enc_config);
    st->codec = av;
-    st->codecpar = avcodec_parameters_alloc();
-    avcodec_parameters_from_context(st->codecpar, av);
    stream->streams[stream->nb_streams++] = st;
 }

--- a/libavcodec/8bps.c
+++ b/libavcodec/8bps.c
@@ -119,15 +119,12 @@ static int decode_frame(AVCodecContext *avctx, void *data,
    }

    if (avctx->bits_per_coded_sample <= 8) {
-        int size;
        const uint8_t *pal = av_packet_get_side_data(avpkt,
                                                     AV_PKT_DATA_PALETTE,
-                                                     &size);
-        if (pal && size == AVPALETTE_SIZE) {
+                                                     NULL);
+        if (pal) {
            frame->palette_has_changed = 1;
            memcpy(c->pal, pal, AVPALETTE_SIZE);
-        } else if (pal) {
-            av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);
        }

        memcpy (frame->data[1], c->pal, AVPALETTE_SIZE);
--- a/libavcodec/Makefile
+++ b/libavcodec/Makefile
@@ -528,8 +528,7 @@ OBJS-$(CONFIG_SUNRAST_ENCODER)         += sunrastenc.o
 OBJS-$(CONFIG_SVQ1_DECODER)            += svq1dec.o svq1.o svq13.o h263data.o
 OBJS-$(CONFIG_SVQ1_ENCODER)            += svq1enc.o svq1.o  h263data.o  \
                                          h263.o ituh263enc.o
-OBJS-$(CONFIG_SVQ3_DECODER)            += svq3.o svq13.o mpegutils.o \
-                                          h264_parse.o h264data.o h264_ps.o h2645_parse.o
+OBJS-$(CONFIG_SVQ3_DECODER)            += svq3.o svq13.o mpegutils.o h264_parse.o h264data.o
 OBJS-$(CONFIG_TEXT_DECODER)            += textdec.o ass.o
 OBJS-$(CONFIG_TEXT_ENCODER)            += srtenc.o ass_split.o
 OBJS-$(CONFIG_TAK_DECODER)             += takdec.o tak.o takdsp.o
--- a/libavcodec/aac_adtstoasc_bsf.c
+++ b/libavcodec/aac_adtstoasc_bsf.c
@@ -49,14 +49,14 @@ static int aac_adtstoasc_filter(AVBSFContext *bsfc, AVPacket *out)
    if (ret < 0)
        return ret;

-    if (bsfc->par_in->extradata && in->size >= 2 && (AV_RB16(in->data) >> 4) != 0xfff)
-        goto finish;
-
    if (in->size < AAC_ADTS_HEADER_SIZE)
        goto packet_too_small;

    init_get_bits(&gb, in->data, AAC_ADTS_HEADER_SIZE * 8);

+    if (bsfc->par_in->extradata && show_bits(&gb, 12) != 0xfff)
+        goto finish;
+
    if (avpriv_aac_parse_header(&gb, &hdr) < 0) {
        av_log(bsfc, AV_LOG_ERROR, "Error parsing ADTS frame header!\n");
        ret = AVERROR_INVALIDDATA;
--- a/libavcodec/aac_defines.h
+++ b/libavcodec/aac_defines.h
@@ -45,7 +45,7 @@ typedef int                 AAC_SIGNE;
 #define Q30(x)              (int)((x)*1073741824.0 + 0.5)
 #define Q31(x)              (int)((x)*2147483648.0 + 0.5)
 #define RANGE15(x)          x
-#define GET_GAIN(x, y)      (-(y) * (1 << (x))) + 1024
+#define GET_GAIN(x, y)      (-(y) << (x)) + 1024
 #define AAC_MUL16(x, y)     (int)(((int64_t)(x) * (y) + 0x8000) >> 16)
 #define AAC_MUL26(x, y)     (int)(((int64_t)(x) * (y) + 0x2000000) >> 26)
 #define AAC_MUL30(x, y)     (int)(((int64_t)(x) * (y) + 0x20000000) >> 30)
@@ -72,7 +72,7 @@ typedef int                 AAC_SIGNE;
 #define AAC_MSUB31_V3(x, y, z)    (int)((((int64_t)(x) * (z)) - \
                                      ((int64_t)(y) * (z)) + \
                                        0x40000000) >> 31)
-#define AAC_HALF_SUM(x, y)  (((x) >> 1) + ((y) >> 1))
+#define AAC_HALF_SUM(x, y)  (x) >> 1 + (y) >> 1
 #define AAC_SRA_R(x, y)     (int)(((x) + (1 << ((y) - 1))) >> (y))

 #else
--- a/libavcodec/aacdec.c
+++ b/libavcodec/aacdec.c
@@ -424,8 +424,6 @@ static int read_payload_length_info(struct LATMContext *ctx, GetBitContext *gb)
    if (ctx->frame_length_type == 0) {
        int mux_slot_length = 0;
        do {
-            if (get_bits_left(gb) < 8)
-                return AVERROR_INVALIDDATA;
            tmp = get_bits(gb, 8);
            mux_slot_length += tmp;
        } while (tmp == 255);
@@ -455,7 +453,7 @@ static int read_audio_mux_element(struct LATMContext *latmctx,
    }
    if (latmctx->audio_mux_version_A == 0) {
        int mux_slot_length_bytes = read_payload_length_info(latmctx, gb);
-        if (mux_slot_length_bytes < 0 || mux_slot_length_bytes * 8LL > get_bits_left(gb)) {
+        if (mux_slot_length_bytes * 8 > get_bits_left(gb)) {
            av_log(latmctx->aac_ctx.avctx, AV_LOG_ERROR, "incomplete frame\n");
            return AVERROR_INVALIDDATA;
        } else if (mux_slot_length_bytes * 8 + 256 < get_bits_left(gb)) {
--- a/libavcodec/aacdec_fixed.c
+++ b/libavcodec/aacdec_fixed.c
@@ -125,7 +125,7 @@ static inline int *DEC_SQUAD(int *dst, unsigned idx)
 static inline int *DEC_UPAIR(int *dst, unsigned idx, unsigned sign)
 {
    dst[0] = (idx & 15) * (1 - (sign & 0xFFFFFFFE));
-    dst[1] = (idx >> 4 & 15) * (1 - ((sign & 1) * 2));
+    dst[1] = (idx >> 4 & 15) * (1 - ((sign & 1) << 1));

    return dst + 2;
 }
@@ -134,16 +134,16 @@ static inline int *DEC_UQUAD(int *dst, unsigned idx, unsigned sign)
 {
    unsigned nz = idx >> 12;

-    dst[0] = (idx & 3) * (1 + (((int)sign >> 31) * 2));
+    dst[0] = (idx & 3) * (1 + (((int)sign >> 31) << 1));
    sign <<= nz & 1;
    nz >>= 1;
-    dst[1] = (idx >> 2 & 3) * (1 + (((int)sign >> 31) * 2));
+    dst[1] = (idx >> 2 & 3) * (1 + (((int)sign >> 31) << 1));
    sign <<= nz & 1;
    nz >>= 1;
-    dst[2] = (idx >> 4 & 3) * (1 + (((int)sign >> 31) * 2));
+    dst[2] = (idx >> 4 & 3) * (1 + (((int)sign >> 31) << 1));
    sign <<= nz & 1;
    nz >>= 1;
-    dst[3] = (idx >> 6 & 3) * (1 + (((int)sign >> 31) * 2));
+    dst[3] = (idx >> 6 & 3) * (1 + (((int)sign >> 31) << 1));

    return dst + 4;
 }
@@ -171,25 +171,20 @@ static void subband_scale(int *dst, int *src, int scale, int offset, int len)

    s = offset - (s >> 2);

-    if (s > 31) {
-        for (i=0; i<len; i++) {
-            dst[i] = 0;
-        }
-    } else if (s > 0) {
+    if (s > 0) {
        round = 1 << (s-1);
        for (i=0; i<len; i++) {
            out = (int)(((int64_t)src[i] * c) >> 32);
            dst[i] = ((int)(out+round) >> s) * ssign;
        }
-    } else if (s > -32) {
+    }
+    else {
        s = s + 32;
        round = 1 << (s-1);
        for (i=0; i<len; i++) {
            out = (int)((int64_t)((int64_t)src[i] * c + round) >> s);
-            dst[i] = out * (unsigned)ssign;
+            dst[i] = out * ssign;
        }
-    } else {
-        av_log(NULL, AV_LOG_ERROR, "Overflow in subband_scale()\n");
    }
 }

@@ -208,12 +203,8 @@ static void noise_scale(int *coefs, int scale, int band_energy, int len)
    c /= band_energy;
    s = 21 + nlz - (s >> 2);

-    if (s > 31) {
-        for (i=0; i<len; i++) {
-            coefs[i] = 0;
-        }
-    } else if (s >= 0) {
-        round = s ? 1 << (s-1) : 0;
+    if (s > 0) {
+        round = 1 << (s-1);
        for (i=0; i<len; i++) {
            out = (int)(((int64_t)coefs[i] * c) >> 32);
            coefs[i] = ((int)(out+round) >> s) * ssign;
@@ -371,9 +362,7 @@ static void apply_dependent_coupling_fixed(AACContext *ac,
                    shift = (gain-1024) >> 3;
                }

-                if (shift < -31) {
-                    // Nothing to do
-                } else if (shift < 0) {
+                if (shift < 0) {
                    shift = -shift;
                    round = 1 << (shift - 1);

@@ -390,7 +379,7 @@ static void apply_dependent_coupling_fixed(AACContext *ac,
                        for (k = offsets[i]; k < offsets[i + 1]; k++) {
                            tmp = (int)(((int64_t)src[group * 128 + k] * c + \
                                        (int64_t)0x1000000000) >> 37);
-                            dest[group * 128 + k] += tmp * (1 << shift);
+                            dest[group * 128 + k] += tmp << shift;
                        }
                    }
                }
--- a/libavcodec/aacdec_template.c
+++ b/libavcodec/aacdec_template.c
@@ -2155,11 +2155,7 @@ static int decode_cce(AACContext *ac, GetBitContext *gb, ChannelElement *che)
    coup->coupling_point += get_bits1(gb) || (coup->coupling_point >> 1);

    sign  = get_bits(gb, 1);
-#if USE_FIXED
-    scale = get_bits(gb, 2);
-#else
-    scale = cce_scale[get_bits(gb, 2)];
-#endif
+    scale = AAC_RENAME(cce_scale)[get_bits(gb, 2)];

    if ((ret = decode_ics(ac, sce, gb, 0, 0)))
        return ret;
--- a/libavcodec/aacenc.c
+++ b/libavcodec/aacenc.c
@@ -622,8 +622,8 @@ static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
            }

            for (k = 0; k < 1024; k++) {
-                if (!(fabs(cpe->ch[ch].coeffs[k]) < 1E16)) { // Ensure headroom for energy calculation
-                    av_log(avctx, AV_LOG_ERROR, "Input contains (near) NaN/+-Inf\n");
+                if (!isfinite(cpe->ch[ch].coeffs[k])) {
+                    av_log(avctx, AV_LOG_ERROR, "Input contains NaN/+-Inf\n");
                    return AVERROR(EINVAL);
                }
            }
--- a/libavcodec/aacps.c
+++ b/libavcodec/aacps.c
@@ -942,7 +942,7 @@ static void stereo_processing(PSContext *ps, INTFLOAT (*l)[32][2], INTFLOAT (*r)
            int stop  = ps->border_position[e+1];
            INTFLOAT width = Q30(1.f) / ((stop - start) ? (stop - start) : 1);
 #if USE_FIXED
-            width = FFMIN(2U*width, INT_MAX);
+            width <<= 1;
 #endif
            b = k_to_i[k];
            h[0][0] = H11[0][e][b];
@@ -975,7 +975,7 @@ static void stereo_processing(PSContext *ps, INTFLOAT (*l)[32][2], INTFLOAT (*r)
                h_step[1][3] = AAC_MSUB31_V3(H22[1][e+1][b], h[1][3], width);
            }
            ps->dsp.stereo_interpolate[!PS_BASELINE && ps->enable_ipdopd](
-                l[k] + 1 + start, r[k] + 1 + start,
+                l[k] + start + 1, r[k] + start + 1,
                h, h_step, stop - start);
        }
    }
--- a/libavcodec/aacsbr_fixed.c
+++ b/libavcodec/aacsbr_fixed.c
@@ -288,8 +288,6 @@ static void sbr_hf_inverse_filter(SBRDSPContext *dsp,
        shift = a00.exp;
        if (shift >= 3)
            alpha0[k][0] = 0x7fffffff;
-        else if (shift <= -30)
-            alpha0[k][0] = 0;
        else {
            a00.mant <<= 1;
            shift = 2-shift;
@@ -304,8 +302,6 @@ static void sbr_hf_inverse_filter(SBRDSPContext *dsp,
        shift = a01.exp;
        if (shift >= 3)
            alpha0[k][1] = 0x7fffffff;
-        else if (shift <= -30)
-            alpha0[k][1] = 0;
        else {
            a01.mant <<= 1;
            shift = 2-shift;
@@ -319,8 +315,6 @@ static void sbr_hf_inverse_filter(SBRDSPContext *dsp,
        shift = a10.exp;
        if (shift >= 3)
            alpha1[k][0] = 0x7fffffff;
-        else if (shift <= -30)
-            alpha1[k][0] = 0;
        else {
            a10.mant <<= 1;
            shift = 2-shift;
@@ -335,8 +329,6 @@ static void sbr_hf_inverse_filter(SBRDSPContext *dsp,
        shift = a11.exp;
        if (shift >= 3)
            alpha1[k][1] = 0x7fffffff;
-        else if (shift <= -30)
-            alpha1[k][1] = 0;
        else {
            a11.mant <<= 1;
            shift = 2-shift;
@@ -575,33 +567,20 @@ static void sbr_hf_assemble(int Y1[38][64][2],

                SoftFloat *in  = sbr->s_m[e];
                for (m = 0; m+1 < m_max; m+=2) {
-                    int shift2;
-                    shift = 22 - in[m  ].exp;
-                    shift2= 22 - in[m+1].exp;
-                    if (shift < 1 || shift2 < 1) {
-                        av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_assemble, shift=%d,%d\n", shift, shift2);
-                        return;
-                    }
-                    if (shift < 32) {
-                        round = 1 << (shift-1);
-                        out[2*m  ] += (in[m  ].mant * A + round) >> shift;
-                    }
+                  shift = 22 - in[m  ].exp;
+                  round = 1 << (shift-1);
+                  out[2*m  ] += (in[m  ].mant * A + round) >> shift;

-                    if (shift2 < 32) {
-                        round = 1 << (shift2-1);
-                        out[2*m+2] += (in[m+1].mant * B + round) >> shift2;
-                    }
+                  shift = 22 - in[m+1].exp;
+                  round = 1 << (shift-1);
+                  out[2*m+2] += (in[m+1].mant * B + round) >> shift;
                }
                if(m_max&1)
                {
-                    shift = 22 - in[m  ].exp;
-                    if (shift < 1) {
-                        av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_assemble, shift=%d\n", shift);
-                        return;
-                    } else if (shift < 32) {
-                        round = 1 << (shift-1);
-                        out[2*m  ] += (in[m  ].mant * A + round) >> shift;
-                    }
+                  shift = 22 - in[m  ].exp;
+                  round = 1 << (shift-1);
+
+                  out[2*m  ] += (in[m  ].mant * A + round) >> shift;
                }
            }
            indexnoise = (indexnoise + m_max) & 0x1ff;
--- a/libavcodec/aacsbr_template.c
+++ b/libavcodec/aacsbr_template.c
@@ -623,26 +623,24 @@ static int read_sbr_grid(AACContext *ac, SpectralBandReplication *sbr,
    int abs_bord_trail = 16;
    int num_rel_lead, num_rel_trail;
    unsigned bs_num_env_old = ch_data->bs_num_env;
-    int bs_frame_class, bs_num_env;

    ch_data->bs_freq_res[0] = ch_data->bs_freq_res[ch_data->bs_num_env];
    ch_data->bs_amp_res = sbr->bs_amp_res_header;
    ch_data->t_env_num_env_old = ch_data->t_env[bs_num_env_old];

-    switch (bs_frame_class = get_bits(gb, 2)) {
+    switch (ch_data->bs_frame_class = get_bits(gb, 2)) {
    case FIXFIX:
-        bs_num_env = 1 << get_bits(gb, 2);
-        if (bs_num_env > 4) {
-            av_log(ac->avctx, AV_LOG_ERROR,
-                   "Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n",
-                   bs_num_env);
-            return -1;
-        }
-        ch_data->bs_num_env = bs_num_env;
+        ch_data->bs_num_env                 = 1 << get_bits(gb, 2);
        num_rel_lead                        = ch_data->bs_num_env - 1;
        if (ch_data->bs_num_env == 1)
            ch_data->bs_amp_res = 0;

+        if (ch_data->bs_num_env > 4) {
+            av_log(ac->avctx, AV_LOG_ERROR,
+                   "Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n",
+                   ch_data->bs_num_env);
+            return -1;
+        }

        ch_data->t_env[0]                   = 0;
        ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
@@ -690,15 +688,14 @@ static int read_sbr_grid(AACContext *ac, SpectralBandReplication *sbr,
        abs_bord_trail                     += get_bits(gb, 2);
        num_rel_lead                        = get_bits(gb, 2);
        num_rel_trail                       = get_bits(gb, 2);
-        bs_num_env                          = num_rel_lead + num_rel_trail + 1;
+        ch_data->bs_num_env                 = num_rel_lead + num_rel_trail + 1;

-        if (bs_num_env > 5) {
+        if (ch_data->bs_num_env > 5) {
            av_log(ac->avctx, AV_LOG_ERROR,
                   "Invalid bitstream, too many SBR envelopes in VARVAR type SBR frame: %d\n",
-                   bs_num_env);
+                   ch_data->bs_num_env);
            return -1;
        }
-        ch_data->bs_num_env = bs_num_env;

        ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;

@@ -713,7 +710,6 @@ static int read_sbr_grid(AACContext *ac, SpectralBandReplication *sbr,
        get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env);
        break;
    }
-    ch_data->bs_frame_class = bs_frame_class;

    av_assert0(bs_pointer >= 0);
    if (bs_pointer > ch_data->bs_num_env + 1) {
--- a/libavcodec/ac3dec.c
+++ b/libavcodec/ac3dec.c
@@ -744,31 +744,30 @@ static void ac3_upmix_delay(AC3DecodeContext *s)
 * @param[in] default_band_struct default band structure table
 * @param[out] num_bands number of bands (optionally NULL)
 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
- * @param[in,out] band_struct current band structure
 */
 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
                                  int ecpl, int start_subband, int end_subband,
                                  const uint8_t *default_band_struct,
-                                  int *num_bands, uint8_t *band_sizes,
-                                  uint8_t *band_struct, int band_struct_size)
+                                  int *num_bands, uint8_t *band_sizes)
 {
    int subbnd, bnd, n_subbands, n_bands=0;
    uint8_t bnd_sz[22];
+    uint8_t coded_band_struct[22];
+    const uint8_t *band_struct;

    n_subbands = end_subband - start_subband;

-    if (!blk)
-        memcpy(band_struct, default_band_struct, band_struct_size);
-
-    av_assert0(band_struct_size >= start_subband + n_subbands);
-
-    band_struct += start_subband + 1;
-
    /* decode band structure from bitstream or use default */
    if (!eac3 || get_bits1(gbc)) {
        for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
-            band_struct[subbnd] = get_bits1(gbc);
+            coded_band_struct[subbnd] = get_bits1(gbc);
        }
+        band_struct = coded_band_struct;
+    } else if (!blk) {
+        band_struct = &default_band_struct[start_subband+1];
+    } else {
+        /* no change in band structure */
+        return;
    }

    /* calculate number of bands and band sizes based on band structure.
@@ -895,8 +894,7 @@ static int decode_audio_block(AC3DecodeContext *s, int blk)
                                  start_subband, end_subband,
                                  ff_eac3_default_spx_band_struct,
                                  &s->num_spx_bands,
-                                  s->spx_band_sizes,
-                                  s->spx_band_struct, sizeof(s->spx_band_struct));
+                                  s->spx_band_sizes);
        }
    }
    if (!s->eac3 || !s->spx_in_use) {
@@ -1030,8 +1028,7 @@ static int decode_audio_block(AC3DecodeContext *s, int blk)
            decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
                                  cpl_end_subband,
                                  ff_eac3_default_cpl_band_struct,
-                                  &s->num_cpl_bands, s->cpl_band_sizes,
-                                  s->cpl_band_struct, sizeof(s->cpl_band_struct));
+                                  &s->num_cpl_bands, s->cpl_band_sizes);
        } else {
            /* coupling not in use */
            for (ch = 1; ch <= fbw_channels; ch++) {
@@ -1331,7 +1328,7 @@ static int decode_audio_block(AC3DecodeContext *s, int blk)
    for (ch = 1; ch <= s->channels; ch++) {
        int audio_channel = 0;
        INTFLOAT gain;
-        if (s->channel_mode == AC3_CHMODE_DUALMONO && ch <= 2)
+        if (s->channel_mode == AC3_CHMODE_DUALMONO)
            audio_channel = 2-ch;
        if (s->heavy_compression && s->compression_exists[audio_channel])
            gain = s->heavy_dynamic_range[audio_channel];
--- a/libavcodec/ac3dec.h
+++ b/libavcodec/ac3dec.h
@@ -128,7 +128,6 @@ typedef struct AC3DecodeContext {
    int phase_flags_in_use;                 ///< phase flags in use                     (phsflginu)
    int phase_flags[AC3_MAX_CPL_BANDS];     ///< phase flags                            (phsflg)
    int num_cpl_bands;                      ///< number of coupling bands               (ncplbnd)
-    uint8_t cpl_band_struct[AC3_MAX_CPL_BANDS];
    uint8_t cpl_band_sizes[AC3_MAX_CPL_BANDS]; ///< number of coeffs in each coupling band
    int firstchincpl;                       ///< first channel in coupling
    int first_cpl_coords[AC3_MAX_CHANNELS]; ///< first coupling coordinates states      (firstcplcos)
@@ -145,7 +144,6 @@ typedef struct AC3DecodeContext {
    int spx_dst_start_freq;                     ///< spx starting frequency bin for copying (copystartmant)
                                                ///< the copy region ends at the start of the spx region.
    int num_spx_bands;                          ///< number of spx bands                    (nspxbnds)
-    uint8_t spx_band_struct[SPX_MAX_BANDS];
    uint8_t spx_band_sizes[SPX_MAX_BANDS];      ///< number of bins in each spx band
    uint8_t first_spx_coords[AC3_MAX_CHANNELS]; ///< first spx coordinates states           (firstspxcos)
    INTFLOAT spx_noise_blend[AC3_MAX_CHANNELS][SPX_MAX_BANDS]; ///< spx noise blending factor  (nblendfact)
--- a/libavcodec/ac3dec_fixed.c
+++ b/libavcodec/ac3dec_fixed.c
@@ -65,11 +65,11 @@ static void scale_coefs (
    int len)
 {
    int i, shift, round;
-    unsigned mul;
+    int16_t mul;
    int temp, temp1, temp2, temp3, temp4, temp5, temp6, temp7;

    mul = (dynrng & 0x1f) + 0x20;
-    shift = 4 - (sign_extend(dynrng, 9) >> 5);
+    shift = 4 - ((dynrng << 23) >> 28);
    if (shift > 0 ) {
      round = 1 << (shift-1);
      for (i=0; i<len; i+=8) {
--- a/libavcodec/acelp_pitch_delay.c
+++ b/libavcodec/acelp_pitch_delay.c
@@ -135,7 +135,7 @@ float ff_amr_set_fixed_gain(float fixed_gain_factor, float fixed_mean_energy,
        ff_exp10(0.05 *
              (avpriv_scalarproduct_float_c(pred_table, prediction_error, 4) +
               energy_mean)) /
-        sqrtf(fixed_mean_energy ? fixed_mean_energy : 1.0);
+        sqrtf(fixed_mean_energy);

    // update quantified prediction error energy history
    memmove(&prediction_error[0], &prediction_error[1],
--- a/libavcodec/adpcm.c
+++ b/libavcodec/adpcm.c
@@ -803,7 +803,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
        if (avctx->bits_per_coded_sample != 4) {
            int samples_per_block = ff_adpcm_ima_block_samples[avctx->bits_per_coded_sample - 2];
            int block_size = ff_adpcm_ima_block_sizes[avctx->bits_per_coded_sample - 2];
-            uint8_t temp[20 + AV_INPUT_BUFFER_PADDING_SIZE] = { 0 };
+            uint8_t temp[20] = { 0 };
            GetBitContext g;

            for (n = 0; n < (nb_samples - 1) / samples_per_block; n++) {
--- a/libavcodec/adxdec.c
+++ b/libavcodec/adxdec.c
@@ -81,7 +81,7 @@ static int adx_decode(ADXContext *c, int16_t *out, int offset,
    s2 = prev->s2;
    for (i = 0; i < BLOCK_SAMPLES; i++) {
        d  = get_sbits(&gb, 4);
-        s0 = ((d * (1 << COEFF_BITS)) * scale + c->coeff[0] * s1 + c->coeff[1] * s2) >> COEFF_BITS;
+        s0 = ((d << COEFF_BITS) * scale + c->coeff[0] * s1 + c->coeff[1] * s2) >> COEFF_BITS;
        s2 = s1;
        s1 = av_clip_int16(s0);
        *out++ = s1;
--- a/libavcodec/alacenc.c
+++ b/libavcodec/alacenc.c
@@ -623,7 +623,7 @@ static int alac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
    else
        max_frame_size = s->max_coded_frame_size;

-    if ((ret = ff_alloc_packet2(avctx, avpkt, 4 * max_frame_size, 0)) < 0)
+    if ((ret = ff_alloc_packet2(avctx, avpkt, 2 * max_frame_size, 0)) < 0)
        return ret;

    /* use verbatim mode for compression_level 0 */
--- a/libavcodec/amrwbdec.c
+++ b/libavcodec/amrwbdec.c
@@ -262,7 +262,7 @@ static void decode_pitch_lag_high(int *lag_int, int *lag_frac, int pitch_index,
            *lag_frac = pitch_index - (*lag_int << 2) + 136;
        } else if (pitch_index < 440) {
            *lag_int  = (pitch_index + 257 - 376) >> 1;
-            *lag_frac = (pitch_index - (*lag_int << 1) + 256 - 376) * 2;
+            *lag_frac = (pitch_index - (*lag_int << 1) + 256 - 376) << 1;
            /* the actual resolution is 1/2 but expressed as 1/4 */
        } else {
            *lag_int  = pitch_index - 280;
@@ -292,7 +292,7 @@ static void decode_pitch_lag_low(int *lag_int, int *lag_frac, int pitch_index,
    if (subframe == 0 || (subframe == 2 && mode != MODE_6k60)) {
        if (pitch_index < 116) {
            *lag_int  = (pitch_index + 69) >> 1;
-            *lag_frac = (pitch_index - (*lag_int << 1) + 68) * 2;
+            *lag_frac = (pitch_index - (*lag_int << 1) + 68) << 1;
        } else {
            *lag_int  = pitch_index - 24;
            *lag_frac = 0;
@@ -302,7 +302,7 @@ static void decode_pitch_lag_low(int *lag_int, int *lag_frac, int pitch_index,
                                AMRWB_P_DELAY_MIN, AMRWB_P_DELAY_MAX - 15);
    } else {
        *lag_int  = (pitch_index + 1) >> 1;
-        *lag_frac = (pitch_index - (*lag_int << 1)) * 2;
+        *lag_frac = (pitch_index - (*lag_int << 1)) << 1;
        *lag_int += *base_lag_int;
    }
 }
--- a/libavcodec/ansi.c
+++ b/libavcodec/ansi.c
@@ -80,6 +80,10 @@ static av_cold int decode_init(AVCodecContext *avctx)
    AnsiContext *s = avctx->priv_data;
    avctx->pix_fmt = AV_PIX_FMT_PAL8;

+    s->frame = av_frame_alloc();
+    if (!s->frame)
+        return AVERROR(ENOMEM);
+
    /* defaults */
    s->font        = avpriv_vga16_font;
    s->font_height = 16;
@@ -90,15 +94,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
        int ret = ff_set_dimensions(avctx, 80 << 3, 25 << 4);
        if (ret < 0)
            return ret;
-    } else if (avctx->width % FONT_WIDTH || avctx->height % s->font_height) {
-        av_log(avctx, AV_LOG_ERROR, "Invalid dimensions %d %d\n", avctx->width, avctx->height);
-        return AVERROR(EINVAL);
    }
-
-    s->frame = av_frame_alloc();
-    if (!s->frame)
-        return AVERROR(ENOMEM);
-
    return 0;
 }

--- a/libavcodec/asvenc.c
+++ b/libavcodec/asvenc.c
@@ -61,7 +61,7 @@ static inline void asv2_put_level(ASV1Context *a, PutBitContext *pb, int level)
    } else {
        put_bits(pb, ff_asv2_level_tab[31][1], ff_asv2_level_tab[31][0]);
        if (level < -128 || level > 127) {
-            av_log(a->avctx, AV_LOG_WARNING, "Clipping level %d, increase qscale\n", level);
+            av_log(a->avctx, AV_LOG_WARNING, "Cliping level %d, increase qscale\n", level);
            level = av_clip_int8(level);
        }
        asv2_put_bits(pb, 8, level & 0xFF);
--- a/libavcodec/avcodec.h
+++ b/libavcodec/avcodec.h
@@ -1515,17 +1515,7 @@ enum AVPacketSideDataType {
     * should be associated with a video stream and containts data in the form
     * of the AVMasteringDisplayMetadata struct.
     */
-    AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
-
-    /**
-     * The number of side data elements (in fact a bit more than it).
-     * This is not part of the public API/ABI in the sense that it may
-     * change when new side data types are added.
-     * This must stay the last enum value.
-     * If its value becomes huge, some code using it
-     * needs to be updated as it assumes it to be smaller than other limits.
-     */
-    AV_PKT_DATA_NB
+    AV_PKT_DATA_MASTERING_DISPLAY_METADATA
 };

 #define AV_PKT_DATA_QUALITY_FACTOR AV_PKT_DATA_QUALITY_STATS //DEPRECATED
--- a/libavcodec/avpacket.c
+++ b/libavcodec/avpacket.c
@@ -139,8 +139,7 @@ int av_grow_packet(AVPacket *pkt, int grow_by)
        pkt->buf = av_buffer_alloc(new_size);
        if (!pkt->buf)
            return AVERROR(ENOMEM);
-        if (pkt->size > 0)
-            memcpy(pkt->buf->data, pkt->data, pkt->size);
+        memcpy(pkt->buf->data, pkt->data, pkt->size);
        pkt->data = pkt->buf->data;
    }
    pkt->size += grow_by;
@@ -199,7 +198,6 @@ static int copy_packet_data(AVPacket *pkt, const AVPacket *src, int dup)
 {
    pkt->data      = NULL;
    pkt->side_data = NULL;
-    pkt->side_data_elems = 0;
    if (pkt->buf) {
        AVBufferRef *ref = av_buffer_ref(src->buf);
        if (!ref)
@@ -209,11 +207,9 @@ static int copy_packet_data(AVPacket *pkt, const AVPacket *src, int dup)
    } else {
        DUP_DATA(pkt->data, src->data, pkt->size, 1, ALLOC_BUF);
    }
-    if (src->side_data_elems && dup) {
+    if (pkt->side_data_elems && dup)
        pkt->side_data = src->side_data;
-        pkt->side_data_elems = src->side_data_elems;
-    }
-    if (src->side_data_elems && !dup) {
+    if (pkt->side_data_elems && !dup) {
        return av_copy_packet_side_data(pkt, src);
    }
    return 0;
@@ -295,17 +291,16 @@ FF_ENABLE_DEPRECATION_WARNINGS
 int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
                            uint8_t *data, size_t size)
 {
-    AVPacketSideData *tmp;
    int elems = pkt->side_data_elems;

-    if ((unsigned)elems + 1 > AV_PKT_DATA_NB)
+    if ((unsigned)elems + 1 > INT_MAX / sizeof(*pkt->side_data))
        return AVERROR(ERANGE);

-    tmp = av_realloc(pkt->side_data, (elems + 1) * sizeof(*tmp));
-    if (!tmp)
+    pkt->side_data = av_realloc(pkt->side_data,
+                                (elems + 1) * sizeof(*pkt->side_data));
+    if (!pkt->side_data)
        return AVERROR(ENOMEM);

-    pkt->side_data = tmp;
    pkt->side_data[elems].data = data;
    pkt->side_data[elems].size = size;
    pkt->side_data[elems].type = type;
@@ -348,8 +343,6 @@ uint8_t *av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
            return pkt->side_data[i].data;
        }
    }
-    if (size)
-        *size = 0;
    return NULL;
 }

@@ -433,9 +426,6 @@ int av_packet_split_side_data(AVPacket *pkt){
            p-= size+5;
        }

-        if (i > AV_PKT_DATA_NB)
-            return AVERROR(ERANGE);
-
        pkt->side_data = av_malloc_array(i, sizeof(*pkt->side_data));
        if (!pkt->side_data)
            return AVERROR(ENOMEM);
--- a/libavcodec/bmvvideo.c
+++ b/libavcodec/bmvvideo.c
@@ -107,7 +107,7 @@ static int decode_bmv_frame(const uint8_t *source, int src_len, uint8_t *frame,
                    if (src < source || src >= source_end)
                        return AVERROR_INVALIDDATA;
                    shift += 2;
-                    val |= (unsigned)*src << shift;
+                    val |= *src << shift;
                    if (*src & 0xC)
                        break;
                }
--- a/libavcodec/cavs.c
+++ b/libavcodec/cavs.c
@@ -537,7 +537,8 @@ void ff_cavs_inter(AVSContext *h, enum cavs_mb mb_type)
 static inline void scale_mv(AVSContext *h, int *d_x, int *d_y,
                            cavs_vector *src, int distp)
 {
-    int64_t den = h->scale_den[FFMAX(src->ref, 0)];
+    int den = h->scale_den[FFMAX(src->ref, 0)];
+
    *d_x = (src->x * distp * den + 256 + FF_SIGNBIT(src->x)) >> 9;
    *d_y = (src->y * distp * den + 256 + FF_SIGNBIT(src->y)) >> 9;
 }
@@ -612,15 +613,8 @@ void ff_cavs_mv(AVSContext *h, enum cavs_mv_loc nP, enum cavs_mv_loc nC,
        mv_pred_median(h, mvP, mvA, mvB, mvC);

    if (mode < MV_PRED_PSKIP) {
-        int mx = get_se_golomb(&h->gb) + (unsigned)mvP->x;
-        int my = get_se_golomb(&h->gb) + (unsigned)mvP->y;
-
-        if (mx != (int16_t)mx || my != (int16_t)my) {
-            av_log(h->avctx, AV_LOG_ERROR, "MV %d %d out of supported range\n", mx, my);
-        } else {
-            mvP->x = mx;
-            mvP->y = my;
-        }
+        mvP->x += get_se_golomb(&h->gb);
+        mvP->y += get_se_golomb(&h->gb);
    }
    set_mvs(mvP, size);
 }
--- a/libavcodec/cavsdec.c
+++ b/libavcodec/cavsdec.c
@@ -465,7 +465,7 @@ static inline void mv_pred_direct(AVSContext *h, cavs_vector *pmv_fw,
                                  cavs_vector *col_mv)
 {
    cavs_vector *pmv_bw = pmv_fw + MV_BWD_OFFS;
-    unsigned den = h->direct_den[col_mv->ref];
+    int den = h->direct_den[col_mv->ref];
    int m = FF_SIGNBIT(col_mv->x);

    pmv_fw->dist = h->dist[1];
@@ -615,7 +615,7 @@ static inline int decode_residual_inter(AVSContext *h)

    /* get quantizer */
    if (h->cbp && !h->qp_fixed)
-        h->qp = (h->qp + (unsigned)get_se_golomb(&h->gb)) & 63;
+        h->qp = (h->qp + get_se_golomb(&h->gb)) & 63;
    for (block = 0; block < 4; block++)
        if (h->cbp & (1 << block))
            decode_residual_block(h, &h->gb, inter_dec, 0, h->qp,
@@ -1031,10 +1031,6 @@ static int decode_pic(AVSContext *h)
    h->scale_den[1] = h->dist[1] ? 512/h->dist[1] : 0;
    if (h->cur.f->pict_type == AV_PICTURE_TYPE_B) {
        h->sym_factor = h->dist[0] * h->scale_den[1];
-        if (FFABS(h->sym_factor) > 32768) {
-            av_log(h->avctx, AV_LOG_ERROR, "sym_factor %d too large\n", h->sym_factor);
-            return AVERROR_INVALIDDATA;
-        }
    } else {
        h->direct_den[0] = h->dist[0] ? 16384 / h->dist[0] : 0;
        h->direct_den[1] = h->dist[1] ? 16384 / h->dist[1] : 0;
@@ -1221,8 +1217,6 @@ static int cavs_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
                h->got_keyframe = 1;
            }
        case PIC_PB_START_CODE:
-            if (*got_frame)
-                av_frame_unref(data);
            *got_frame = 0;
            if (!h->got_keyframe)
                break;
--- a/libavcodec/cavsdsp.c
+++ b/libavcodec/cavsdsp.c
@@ -188,6 +188,7 @@ static void cavs_filter_ch_c(uint8_t *d, int stride, int alpha, int beta, int tc
 static void cavs_idct8_add_c(uint8_t *dst, int16_t *block, int stride) {
    int i;
    int16_t (*src)[8] = (int16_t(*)[8])block;
+    const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP;

    src[0][0] += 8;

@@ -242,14 +243,14 @@ static void cavs_idct8_add_c(uint8_t *dst, int16_t *block, int stride) {
        const int b2 = a5 - a7;
        const int b3 = a4 - a6;

-        dst[i + 0*stride] = av_clip_uint8( dst[i + 0*stride] + ((b0 + b4) >> 7));
-        dst[i + 1*stride] = av_clip_uint8( dst[i + 1*stride] + ((b1 + b5) >> 7));
-        dst[i + 2*stride] = av_clip_uint8( dst[i + 2*stride] + ((b2 + b6) >> 7));
-        dst[i + 3*stride] = av_clip_uint8( dst[i + 3*stride] + ((b3 + b7) >> 7));
-        dst[i + 4*stride] = av_clip_uint8( dst[i + 4*stride] + ((b3 - b7) >> 7));
-        dst[i + 5*stride] = av_clip_uint8( dst[i + 5*stride] + ((b2 - b6) >> 7));
-        dst[i + 6*stride] = av_clip_uint8( dst[i + 6*stride] + ((b1 - b5) >> 7));
-        dst[i + 7*stride] = av_clip_uint8( dst[i + 7*stride] + ((b0 - b4) >> 7));
+        dst[i + 0*stride] = cm[ dst[i + 0*stride] + ((b0 + b4) >> 7)];
+        dst[i + 1*stride] = cm[ dst[i + 1*stride] + ((b1 + b5) >> 7)];
+        dst[i + 2*stride] = cm[ dst[i + 2*stride] + ((b2 + b6) >> 7)];
+        dst[i + 3*stride] = cm[ dst[i + 3*stride] + ((b3 + b7) >> 7)];
+        dst[i + 4*stride] = cm[ dst[i + 4*stride] + ((b3 - b7) >> 7)];
+        dst[i + 5*stride] = cm[ dst[i + 5*stride] + ((b2 - b6) >> 7)];
+        dst[i + 6*stride] = cm[ dst[i + 6*stride] + ((b1 - b5) >> 7)];
+        dst[i + 7*stride] = cm[ dst[i + 7*stride] + ((b0 - b4) >> 7)];
    }
 }

--- a/libavcodec/ccaption_dec.c
+++ b/libavcodec/ccaption_dec.c
@@ -247,8 +247,7 @@ typedef struct CCaptionSubContext {
    int64_t last_real_time;
    char prev_cmd[2];
    /* buffer to store pkt data */
-    uint8_t *pktbuf;
-    int pktbuf_size;
+    AVBufferRef *pktbuf;
    int readorder;
 } CCaptionSubContext;

@@ -274,7 +273,11 @@ static av_cold int init_decoder(AVCodecContext *avctx)
    if (ret < 0) {
        return ret;
    }
-
+    /* allocate pkt buffer */
+    ctx->pktbuf = av_buffer_alloc(128);
+    if (!ctx->pktbuf) {
+        ret = AVERROR(ENOMEM);
+    }
    return ret;
 }

@@ -282,8 +285,7 @@ static av_cold int close_decoder(AVCodecContext *avctx)
 {
    CCaptionSubContext *ctx = avctx->priv_data;
    av_bprint_finalize(&ctx->buffer, NULL);
-    av_freep(&ctx->pktbuf);
-    ctx->pktbuf_size = 0;
+    av_buffer_unref(&ctx->pktbuf);
    return 0;
 }

@@ -727,13 +729,16 @@ static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avp
    int ret = 0;
    int i;

-    av_fast_padded_malloc(&ctx->pktbuf, &ctx->pktbuf_size, len);
-    if (!ctx->pktbuf) {
-        av_log(ctx, AV_LOG_WARNING, "Insufficient Memory of %d truncated to %d\n", len, ctx->pktbuf_size);
-        return AVERROR(ENOMEM);
+    if (ctx->pktbuf->size < len) {
+        ret = av_buffer_realloc(&ctx->pktbuf, len);
+         if (ret < 0) {
+            av_log(ctx, AV_LOG_WARNING, "Insufficient Memory of %d truncated to %d\n", len, ctx->pktbuf->size);
+            len = ctx->pktbuf->size;
+            ret = 0;
+        }
    }
-    memcpy(ctx->pktbuf, avpkt->data, len);
-    bptr = ctx->pktbuf;
+    memcpy(ctx->pktbuf->data, avpkt->data, len);
+    bptr = ctx->pktbuf->data;

    for (i  = 0; i < len; i += 3) {
        uint8_t cc_type = *(bptr + i) & 3;
--- a/libavcodec/cdxl.c
+++ b/libavcodec/cdxl.c
@@ -275,11 +275,11 @@ static int cdxl_decode_frame(AVCodecContext *avctx, void *data,
    else
        aligned_width = FFALIGN(c->avctx->width, 16);
    c->padded_bits  = aligned_width - c->avctx->width;
-    if (c->video_size < aligned_width * avctx->height * (int64_t)c->bpp / 8)
+    if (c->video_size < aligned_width * avctx->height * c->bpp / 8)
        return AVERROR_INVALIDDATA;
-    if (!encoding && c->palette_size && c->bpp <= 8 && c->format != CHUNKY) {
+    if (!encoding && c->palette_size && c->bpp <= 8) {
        avctx->pix_fmt = AV_PIX_FMT_PAL8;
-    } else if (encoding == 1 && (c->bpp == 6 || c->bpp == 8) && c->format != CHUNKY) {
+    } else if (encoding == 1 && (c->bpp == 6 || c->bpp == 8)) {
        if (c->palette_size != (1 << (c->bpp - 1)))
            return AVERROR_INVALIDDATA;
        avctx->pix_fmt = AV_PIX_FMT_BGR24;
--- a/libavcodec/cfhd.c
+++ b/libavcodec/cfhd.c
@@ -258,11 +258,6 @@ static int cfhd_decode(AVCodecContext *avctx, void *data, int *got_frame,
            s->coded_height = data;
        } else if (tag == 101) {
            av_log(avctx, AV_LOG_DEBUG, "Bits per component: %"PRIu16"\n", data);
-            if (data < 1 || data > 31) {
-                av_log(avctx, AV_LOG_ERROR, "Bits per component %d is invalid\n", data);
-                ret = AVERROR(EINVAL);
-                break;
-            }
            s->bpc = data;
        } else if (tag == 12) {
            av_log(avctx, AV_LOG_DEBUG, "Channel Count: %"PRIu16"\n", data);
@@ -322,22 +317,22 @@ static int cfhd_decode(AVCodecContext *avctx, void *data, int *got_frame,
            s->prescale_shift[2] = (data >> 6) & 0x7;
            av_log(avctx, AV_LOG_DEBUG, "Prescale shift (VC-5): %x\n", data);
        } else if (tag == 27) {
+            s->plane[s->channel_num].band[0][0].width  = data;
+            s->plane[s->channel_num].band[0][0].stride = data;
            av_log(avctx, AV_LOG_DEBUG, "Lowpass width %"PRIu16"\n", data);
-            if (data < 3 || data > s->plane[s->channel_num].band[0][0].a_width) {
+            if (data < 2 || data > s->plane[s->channel_num].band[0][0].a_width) {
                av_log(avctx, AV_LOG_ERROR, "Invalid lowpass width\n");
                ret = AVERROR(EINVAL);
                break;
            }
-            s->plane[s->channel_num].band[0][0].width  = data;
-            s->plane[s->channel_num].band[0][0].stride = data;
        } else if (tag == 28) {
+            s->plane[s->channel_num].band[0][0].height = data;
            av_log(avctx, AV_LOG_DEBUG, "Lowpass height %"PRIu16"\n", data);
-            if (data < 3 || data > s->plane[s->channel_num].band[0][0].height) {
+            if (data < 2 || data > s->plane[s->channel_num].band[0][0].height) {
                av_log(avctx, AV_LOG_ERROR, "Invalid lowpass height\n");
                ret = AVERROR(EINVAL);
                break;
            }
-            s->plane[s->channel_num].band[0][0].height = data;
        } else if (tag == 1)
            av_log(avctx, AV_LOG_DEBUG, "Sample type? %"PRIu16"\n", data);
        else if (tag == 10) {
@@ -368,39 +363,39 @@ static int cfhd_decode(AVCodecContext *avctx, void *data, int *got_frame,
                av_log(avctx, AV_LOG_DEBUG, "Tag/Value = %x %x\n", tag2, val2);
            }
        } else if (tag == 41) {
+            s->plane[s->channel_num].band[s->level][s->subband_num].width  = data;
+            s->plane[s->channel_num].band[s->level][s->subband_num].stride = FFALIGN(data, 8);
            av_log(avctx, AV_LOG_DEBUG, "Highpass width %i channel %i level %i subband %i\n", data, s->channel_num, s->level, s->subband_num);
-            if (data < 3) {
+            if (data < 2) {
                av_log(avctx, AV_LOG_ERROR, "Invalid highpass width\n");
                ret = AVERROR(EINVAL);
                break;
            }
-            s->plane[s->channel_num].band[s->level][s->subband_num].width  = data;
-            s->plane[s->channel_num].band[s->level][s->subband_num].stride = FFALIGN(data, 8);
        } else if (tag == 42) {
+            s->plane[s->channel_num].band[s->level][s->subband_num].height = data;
            av_log(avctx, AV_LOG_DEBUG, "Highpass height %i\n", data);
-            if (data < 3) {
+            if (data < 2) {
                av_log(avctx, AV_LOG_ERROR, "Invalid highpass height\n");
                ret = AVERROR(EINVAL);
                break;
            }
-            s->plane[s->channel_num].band[s->level][s->subband_num].height = data;
        } else if (tag == 49) {
+            s->plane[s->channel_num].band[s->level][s->subband_num].width  = data;
+            s->plane[s->channel_num].band[s->level][s->subband_num].stride = FFALIGN(data, 8);
            av_log(avctx, AV_LOG_DEBUG, "Highpass width2 %i\n", data);
-            if (data < 3) {
+            if (data < 2) {
                av_log(avctx, AV_LOG_ERROR, "Invalid highpass width2\n");
                ret = AVERROR(EINVAL);
                break;
            }
-            s->plane[s->channel_num].band[s->level][s->subband_num].width  = data;
-            s->plane[s->channel_num].band[s->level][s->subband_num].stride = FFALIGN(data, 8);
        } else if (tag == 50) {
+            s->plane[s->channel_num].band[s->level][s->subband_num].height = data;
            av_log(avctx, AV_LOG_DEBUG, "Highpass height2 %i\n", data);
-            if (data < 3) {
+            if (data < 2) {
                av_log(avctx, AV_LOG_ERROR, "Invalid highpass height2\n");
                ret = AVERROR(EINVAL);
                break;
            }
-            s->plane[s->channel_num].band[s->level][s->subband_num].height = data;
        } else if (tag == 71) {
            s->codebook = data;
            av_log(avctx, AV_LOG_DEBUG, "Codebook %i\n", s->codebook);
@@ -409,12 +404,12 @@ static int cfhd_decode(AVCodecContext *avctx, void *data, int *got_frame,
            av_log(avctx, AV_LOG_DEBUG, "Other codebook? %i\n", s->codebook);
        } else if (tag == 70) {
            av_log(avctx, AV_LOG_DEBUG, "Subsampling or bit-depth flag? %i\n", data);
-            if (!(data == 10 || data == 12)) {
+            s->bpc = data;
+            if (!(s->bpc == 10 || s->bpc == 12)) {
                av_log(avctx, AV_LOG_ERROR, "Invalid bits per channel\n");
                ret = AVERROR(EINVAL);
                break;
            }
-            s->bpc = data;
        } else if (tag == 84) {
            av_log(avctx, AV_LOG_DEBUG, "Sample format? %i\n", data);
            if (data == 1)
@@ -715,7 +710,7 @@ static int cfhd_decode(AVCodecContext *avctx, void *data, int *got_frame,
        output = s->plane[plane].subband[0];
        for (i = 0; i < lowpass_height * 2; i++) {
            for (j = 0; j < lowpass_width * 2; j++)
-                output[j] *= 4;
+                output[j] <<= 2;

            output += lowpass_width * 2;
        }
--- a/libavcodec/cinepak.c
+++ b/libavcodec/cinepak.c
@@ -322,6 +322,9 @@ static int cinepak_decode (CinepakContext *s)
    int           y0 = 0;
    int           encoded_buf_size;

+    if (s->size < 10)
+        return AVERROR_INVALIDDATA;
+
    frame_flags = s->data[0];
    num_strips  = AV_RB16 (&s->data[8]);
    encoded_buf_size = AV_RB24(&s->data[1]);
@@ -436,20 +439,14 @@ static int cinepak_decode_frame(AVCodecContext *avctx,
    s->data = buf;
    s->size = buf_size;

-    if (s->size < 10)
-        return AVERROR_INVALIDDATA;
-
    if ((ret = ff_reget_buffer(avctx, s->frame)) < 0)
        return ret;

    if (s->palette_video) {
-        int size;
-        const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &size);
-        if (pal && size == AVPALETTE_SIZE) {
+        const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
+        if (pal) {
            s->frame->palette_has_changed = 1;
            memcpy(s->pal, pal, AVPALETTE_SIZE);
-        } else if (pal) {
-            av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);
        }
    }

--- a/libavcodec/cllc.c
+++ b/libavcodec/cllc.c
@@ -29,10 +29,6 @@
 #include "avcodec.h"
 #include "internal.h"

-#define VLC_BITS 7
-#define VLC_DEPTH 2
-
-
 typedef struct CLLCContext {
    AVCodecContext *avctx;
    BswapDSPContext bdsp;
@@ -55,13 +51,6 @@ static int read_code_table(CLLCContext *ctx, GetBitContext *gb, VLC *vlc)

    num_lens = get_bits(gb, 5);

-    if (num_lens > VLC_BITS * VLC_DEPTH) {
-        vlc->table = NULL;
-
-        av_log(ctx->avctx, AV_LOG_ERROR, "To long VLCs %d\n", num_lens);
-        return AVERROR_INVALIDDATA;
-    }
-
    for (i = 0; i < num_lens; i++) {
        num_codes      = get_bits(gb, 9);
        num_codes_sum += num_codes;
@@ -81,15 +70,11 @@ static int read_code_table(CLLCContext *ctx, GetBitContext *gb, VLC *vlc)

            count++;
        }
-        if (prefix > (65535 - 256)/2) {
-            vlc->table = NULL;
-            return AVERROR_INVALIDDATA;
-        }

        prefix <<= 1;
    }

-    return ff_init_vlc_sparse(vlc, VLC_BITS, count, bits, 1, 1,
+    return ff_init_vlc_sparse(vlc, 7, count, bits, 1, 1,
                              codes, 2, 2, symbols, 1, 1, 0);
 }

@@ -116,7 +101,7 @@ static int read_argb_line(CLLCContext *ctx, GetBitContext *gb, int *top_left,
    for (i = 0; i < ctx->avctx->width; i++) {
        /* Always get the alpha component */
        UPDATE_CACHE(bits, gb);
-        GET_VLC(code, bits, gb, vlc[0].table, VLC_BITS, VLC_DEPTH);
+        GET_VLC(code, bits, gb, vlc[0].table, 7, 2);

        pred[0] += code;
        dst[0]   = pred[0];
@@ -125,21 +110,21 @@ static int read_argb_line(CLLCContext *ctx, GetBitContext *gb, int *top_left,
        if (dst[0]) {
            /* Red */
            UPDATE_CACHE(bits, gb);
-            GET_VLC(code, bits, gb, vlc[1].table, VLC_BITS, VLC_DEPTH);
+            GET_VLC(code, bits, gb, vlc[1].table, 7, 2);

            pred[1] += code;
            dst[1]   = pred[1];

            /* Green */
            UPDATE_CACHE(bits, gb);
-            GET_VLC(code, bits, gb, vlc[2].table, VLC_BITS, VLC_DEPTH);
+            GET_VLC(code, bits, gb, vlc[2].table, 7, 2);

            pred[2] += code;
            dst[2]   = pred[2];

            /* Blue */
            UPDATE_CACHE(bits, gb);
-            GET_VLC(code, bits, gb, vlc[3].table, VLC_BITS, VLC_DEPTH);
+            GET_VLC(code, bits, gb, vlc[3].table, 7, 2);

            pred[3] += code;
            dst[3]   = pred[3];
@@ -181,7 +166,7 @@ static int read_rgb24_component_line(CLLCContext *ctx, GetBitContext *gb,
    /* Simultaneously read and restore the line */
    for (i = 0; i < ctx->avctx->width; i++) {
        UPDATE_CACHE(bits, gb);
-        GET_VLC(code, bits, gb, vlc->table, VLC_BITS, VLC_DEPTH);
+        GET_VLC(code, bits, gb, vlc->table, 7, 2);

        pred  += code;
        dst[0] = pred;
@@ -210,7 +195,7 @@ static int read_yuv_component_line(CLLCContext *ctx, GetBitContext *gb,
    /* Simultaneously read and restore the line */
    for (i = 0; i < ctx->avctx->width >> is_chroma; i++) {
        UPDATE_CACHE(bits, gb);
-        GET_VLC(code, bits, gb, vlc->table, VLC_BITS, VLC_DEPTH);
+        GET_VLC(code, bits, gb, vlc->table, 7, 2);

        pred     += code;
        outbuf[i] = pred;
--- a/libavcodec/dca_lbr.c
+++ b/libavcodec/dca_lbr.c
@@ -310,7 +310,7 @@ static int parse_tonal(DCALbrDecoder *s, int group)
                break;  // End of subframe

            freq += diff - 2;
-            if (freq >> (5 - group) > s->nsubbands * 4 - 6) {
+            if (freq >> (5 - group) > s->nsubbands * 4 - 5) {
                av_log(s->avctx, AV_LOG_ERROR, "Invalid spectral line offset\n");
                return -1;
            }
--- a/libavcodec/dcadsp.c
+++ b/libavcodec/dcadsp.c
@@ -320,7 +320,7 @@ static void dmix_sub_c(int32_t *dst, const int32_t *src, int coeff, ptrdiff_t le
    int i;

    for (i = 0; i < len; i++)
-        dst[i] -= (unsigned)mul15(src[i], coeff);
+        dst[i] -= mul15(src[i], coeff);
 }

 static void dmix_add_c(int32_t *dst, const int32_t *src, int coeff, ptrdiff_t len)
--- a/libavcodec/dds.c
+++ b/libavcodec/dds.c
@@ -39,7 +39,7 @@

 #define DDPF_FOURCC    (1 <<  2)
 #define DDPF_PALETTE   (1 <<  5)
-#define DDPF_NORMALMAP (1U << 31)
+#define DDPF_NORMALMAP (1 << 31)

 enum DDSPostProc {
    DDS_NONE = 0,
@@ -688,7 +688,7 @@ static int dds_decode(AVCodecContext *avctx, void *data,
                        (frame->data[1][2+i*4]<<0)+
                        (frame->data[1][1+i*4]<<8)+
                        (frame->data[1][0+i*4]<<16)+
-                        ((unsigned)frame->data[1][3+i*4]<<24)
+                        (frame->data[1][3+i*4]<<24)
                );

            frame->palette_has_changed = 1;
--- a/libavcodec/dfa.c
+++ b/libavcodec/dfa.c
@@ -67,8 +67,7 @@ static int decode_tsw1(GetByteContext *gb, uint8_t *frame, int width, int height
    const uint8_t *frame_start = frame;
    const uint8_t *frame_end   = frame + width * height;
    int mask = 0x10000, bitbuf = 0;
-    int v, count;
-    unsigned segments;
+    int v, count, segments;
    unsigned offset;

    segments = bytestream2_get_le32(gb);
@@ -176,7 +175,7 @@ static int decode_dds1(GetByteContext *gb, uint8_t *frame, int width, int height
                return AVERROR_INVALIDDATA;
            frame += v;
        } else {
-            if (frame_end - frame < width + 4)
+            if (frame_end - frame < width + 3)
                return AVERROR_INVALIDDATA;
            frame[0] = frame[1] =
            frame[width] = frame[width + 1] =  bytestream2_get_byte(gb);
@@ -250,7 +249,7 @@ static int decode_wdlt(GetByteContext *gb, uint8_t *frame, int width, int height
        segments = bytestream2_get_le16u(gb);
        while ((segments & 0xC000) == 0xC000) {
            unsigned skip_lines = -(int16_t)segments;
-            int64_t delta = -((int16_t)segments * (int64_t)width);
+            unsigned delta = -((int16_t)segments * width);
            if (frame_end - frame <= delta || y + lines + skip_lines > height)
                return AVERROR_INVALIDDATA;
            frame    += delta;
--- a/libavcodec/diracdec.c
+++ b/libavcodec/diracdec.c
@@ -1153,11 +1153,6 @@ static int dirac_unpack_idwt_params(DiracContext *s)
    else {
        s->num_x        = get_interleaved_ue_golomb(gb);
        s->num_y        = get_interleaved_ue_golomb(gb);
-        if (s->num_x * s->num_y == 0 || s->num_x * (uint64_t)s->num_y > INT_MAX) {
-            av_log(s->avctx,AV_LOG_ERROR,"Invalid numx/y\n");
-            s->num_x = s->num_y = 0;
-            return AVERROR_INVALIDDATA;
-        }
        if (s->ld_picture) {
            s->lowdelay.bytes.num = get_interleaved_ue_golomb(gb);
            s->lowdelay.bytes.den = get_interleaved_ue_golomb(gb);
@@ -1900,9 +1895,7 @@ static int dirac_decode_picture_header(DiracContext *s)
            for (j = 0; j < MAX_FRAMES; j++)
                if (!s->all_frames[j].avframe->data[0]) {
                    s->ref_pics[i] = &s->all_frames[j];
-                    ret = get_buffer_with_edge(s->avctx, s->ref_pics[i]->avframe, AV_GET_BUFFER_FLAG_REF);
-                    if (ret < 0)
-                        return ret;
+                    get_buffer_with_edge(s->avctx, s->ref_pics[i]->avframe, AV_GET_BUFFER_FLAG_REF);
                    break;
                }

@@ -1966,9 +1959,9 @@ static int get_delayed_pic(DiracContext *s, AVFrame *picture, int *got_frame)

    if (out) {
        out->reference ^= DELAYED_PIC_REF;
+        *got_frame = 1;
        if((ret = av_frame_ref(picture, out->avframe)) < 0)
            return ret;
-        *got_frame = 1;
    }

    return 0;
--- a/libavcodec/dnxhddec.c
+++ b/libavcodec/dnxhddec.c
@@ -118,6 +118,11 @@ static int dnxhd_init_vlc(DNXHDContext *ctx, uint32_t cid, int bitdepth)
            av_log(ctx->avctx, AV_LOG_ERROR, "bit depth mismatches %d %d\n", ff_dnxhd_cid_table[index].bit_depth, bitdepth);
            return AVERROR_INVALIDDATA;
        }
+        if (bitdepth > 10) {
+            avpriv_request_sample(ctx->avctx, "DNXHR 12-bit");
+            if (ctx->avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL)
+                return AVERROR_PATCHWELCOME;
+        }
        ctx->cid_table = &ff_dnxhd_cid_table[index];
        av_log(ctx->avctx, AV_LOG_VERBOSE, "Profile cid %d.\n", cid);

@@ -128,7 +133,7 @@ static int dnxhd_init_vlc(DNXHDContext *ctx, uint32_t cid, int bitdepth)
        init_vlc(&ctx->ac_vlc, DNXHD_VLC_BITS, 257,
                 ctx->cid_table->ac_bits, 1, 1,
                 ctx->cid_table->ac_codes, 2, 2, 0);
-        init_vlc(&ctx->dc_vlc, DNXHD_DC_VLC_BITS, bitdepth > 8 ? 14 : 12,
+        init_vlc(&ctx->dc_vlc, DNXHD_DC_VLC_BITS, bitdepth + 4,
                 ctx->cid_table->dc_bits, 1, 1,
                 ctx->cid_table->dc_codes, 1, 1, 0);
        init_vlc(&ctx->run_vlc, DNXHD_VLC_BITS, 62,
--- a/libavcodec/dss_sp.c
+++ b/libavcodec/dss_sp.c
@@ -33,7 +33,7 @@

 #define DSS_SP_FRAME_SIZE        42
 #define DSS_SP_SAMPLE_COUNT     (66 * SUBFRAMES)
-#define DSS_SP_FORMULA(a, b, c) ((int)((((a) * (1 << 15)) + (b) * (unsigned)(c)) + 0x4000) >> 15)
+#define DSS_SP_FORMULA(a, b, c) (((((a) << 15) + (b) * (c)) + 0x4000) >> 15)

 typedef struct DssSpSubframe {
    int16_t gain;
@@ -499,7 +499,7 @@ static void dss_sp_scale_vector(int32_t *vec, int bits, int size)
            vec[i] = vec[i] >> -bits;
    else
        for (i = 0; i < size; i++)
-            vec[i] = vec[i] * (1 << bits);
+            vec[i] = vec[i] << bits;
 }

 static void dss_sp_update_buf(int32_t *hist, int32_t *vector)
@@ -524,12 +524,12 @@ static void dss_sp_shift_sq_sub(const int32_t *filter_buf,
        tmp = dst[a] * filter_buf[0];

        for (i = 14; i > 0; i--)
-            tmp -= error_buf[i] * (unsigned)filter_buf[i];
+            tmp -= error_buf[i] * filter_buf[i];

        for (i = 14; i > 0; i--)
            error_buf[i] = error_buf[i - 1];

-        tmp = (int)(tmp + 4096U) >> 13;
+        tmp = (tmp + 4096) >> 13;

        error_buf[1] = tmp;

--- a/libavcodec/dvbsubdec.c
+++ b/libavcodec/dvbsubdec.c
@@ -24,7 +24,6 @@
 #include "bytestream.h"
 #include "internal.h"
 #include "libavutil/colorspace.h"
-#include "libavutil/imgutils.h"
 #include "libavutil/opt.h"

 #define DVBSUB_PAGE_SEGMENT     0x10
@@ -811,7 +810,7 @@ static void compute_default_clut(AVSubtitleRect *rect, int w, int h)
        list_inv[     i ] = bestv;
    }

-    count = FFMAX(i - 1, 1);
+    count = i - 1;
    for (i--; i>=0; i--) {
        int v = i*255/count;
        AV_WN32(rect->data[1] + 4*list_inv[i], RGBA(v/2,v,v/2,v));
@@ -1218,9 +1217,9 @@ static int dvbsub_parse_clut_segment(AVCodecContext *avctx,
                return AVERROR_INVALIDDATA;
        }

-        if (depth & 0x80 && entry_id < 4)
+        if (depth & 0x80)
            clut->clut4[entry_id] = RGBA(r,g,b,255 - alpha);
-        else if (depth & 0x40 && entry_id < 16)
+        else if (depth & 0x40)
            clut->clut16[entry_id] = RGBA(r,g,b,255 - alpha);
        else if (depth & 0x20)
            clut->clut256[entry_id] = RGBA(r,g,b,255 - alpha);
@@ -1243,7 +1242,6 @@ static int dvbsub_parse_region_segment(AVCodecContext *avctx,
    DVBSubObject *object;
    DVBSubObjectDisplay *display;
    int fill;
-    int ret;

    if (buf_size < 10)
        return AVERROR_INVALIDDATA;
@@ -1272,12 +1270,6 @@ static int dvbsub_parse_region_segment(AVCodecContext *avctx,
    region->height = AV_RB16(buf);
    buf += 2;

-    ret = av_image_check_size(region->width, region->height, 0, avctx);
-    if (ret < 0) {
-        region->width= region->height= 0;
-        return ret;
-    }
-
    if (region->width * region->height != region->buf_size) {
        av_free(region->pbuf);

--- a/libavcodec/dvdsubdec.c
+++ b/libavcodec/dvdsubdec.c
@@ -60,7 +60,7 @@ static void yuv_a_to_rgba(const uint8_t *ycbcr, const uint8_t *alpha, uint32_t *
        cb = *ycbcr++;
        YUV_TO_RGB1_CCIR(cb, cr);
        YUV_TO_RGB2_CCIR(r, g, b, y);
-        *rgba++ = ((unsigned)*alpha++ << 24) | (r << 16) | (g << 8) | b;
+        *rgba++ = (*alpha++ << 24) | (r << 16) | (g << 8) | b;
    }
 }

@@ -185,16 +185,16 @@ static void guess_palette(DVDSubContext* ctx,
    for(i = 0; i < 4; i++) {
        if (alpha[i] != 0) {
            if (!color_used[colormap[i]])  {
-                level = level_map[nb_opaque_colors - 1][j];
+                level = level_map[nb_opaque_colors][j];
                r = (((subtitle_color >> 16) & 0xff) * level) >> 8;
                g = (((subtitle_color >> 8) & 0xff) * level) >> 8;
                b = (((subtitle_color >> 0) & 0xff) * level) >> 8;
-                rgba_palette[i] = b | (g << 8) | (r << 16) | ((alpha[i] * 17U) << 24);
+                rgba_palette[i] = b | (g << 8) | (r << 16) | ((alpha[i] * 17) << 24);
                color_used[colormap[i]] = (i + 1);
                j++;
            } else {
                rgba_palette[i] = (rgba_palette[color_used[colormap[i]] - 1] & 0x00ffffff) |
-                                    ((alpha[i] * 17U) << 24);
+                                    ((alpha[i] * 17) << 24);
            }
        }
    }
@@ -548,8 +548,7 @@ static int append_to_cached_buf(AVCodecContext *avctx,
 {
    DVDSubContext *ctx = avctx->priv_data;

-    av_assert0(buf_size >= 0 && ctx->buf_size <= sizeof(ctx->buf));
-    if (buf_size >= sizeof(ctx->buf) - ctx->buf_size) {
+    if (ctx->buf_size >= sizeof(ctx->buf) - buf_size) {
        av_log(avctx, AV_LOG_WARNING, "Attempt to reconstruct "
               "too large SPU packets aborted.\n");
        ctx->buf_size = 0;
--- a/libavcodec/dxv.c
+++ b/libavcodec/dxv.c
@@ -331,9 +331,6 @@ static int dxv_decompress_raw(AVCodecContext *avctx)
    DXVContext *ctx = avctx->priv_data;
    GetByteContext *gbc = &ctx->gbc;

-    if (bytestream2_get_bytes_left(gbc) < ctx->tex_size)
-        return AVERROR_INVALIDDATA;
-
    bytestream2_get_buffer(gbc, ctx->tex_data, ctx->tex_size);
    return 0;
 }
--- a/libavcodec/eac3dec.c
+++ b/libavcodec/eac3dec.c
@@ -252,7 +252,7 @@ static void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch)
            /* Vector Quantization */
            int v = get_bits(gbc, bits);
            for (blk = 0; blk < 6; blk++) {
-                s->pre_mantissa[ch][bin][blk] = ff_eac3_mantissa_vq[hebap][v][blk] * (1 << 8);
+                s->pre_mantissa[ch][bin][blk] = ff_eac3_mantissa_vq[hebap][v][blk] << 8;
            }
        } else {
            /* Gain Adaptive Quantization */
@@ -271,16 +271,16 @@ static void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch)
                    int b;
                    int mbits = bits - (2 - log_gain);
                    mant = get_sbits(gbc, mbits);
-                    mant = ((unsigned)mant) << (23 - (mbits - 1));
+                    mant <<= (23 - (mbits - 1));
                    /* remap mantissa value to correct for asymmetric quantization */
                    if (mant >= 0)
                        b = 1 << (23 - log_gain);
                    else
-                        b = ff_eac3_gaq_remap_2_4_b[hebap-8][log_gain-1] * (1 << 8);
+                        b = ff_eac3_gaq_remap_2_4_b[hebap-8][log_gain-1] << 8;
                    mant += ((ff_eac3_gaq_remap_2_4_a[hebap-8][log_gain-1] * (int64_t)mant) >> 15) + b;
                } else {
                    /* small mantissa, no GAQ, or Gk=1 */
-                    mant *= (1 << 24 - bits);
+                    mant <<= 24 - bits;
                    if (!log_gain) {
                        /* remap mantissa value for no GAQ or Gk=1 */
                        mant += (ff_eac3_gaq_remap_1[hebap-8] * (int64_t)mant) >> 15;
--- a/libavcodec/eamad.c
+++ b/libavcodec/eamad.c
@@ -284,7 +284,7 @@ static int decode_frame(AVCodecContext *avctx,

    if (avctx->width != width || avctx->height != height) {
        av_frame_unref(s->last_frame);
-        if((width * (int64_t)height)/2048*7 > bytestream2_get_bytes_left(&gb))
+        if((width * height)/2048*7 > bytestream2_get_bytes_left(&gb))
            return AVERROR_INVALIDDATA;
        if ((ret = ff_set_dimensions(avctx, width, height)) < 0)
            return ret;
--- a/libavcodec/eatqi.c
+++ b/libavcodec/eatqi.c
@@ -112,7 +112,7 @@ static inline void tqi_idct_put(AVCodecContext *avctx, AVFrame *frame,

 static void tqi_calculate_qtable(TqiContext *t, int quant)
 {
-    const int64_t qscale = (215 - 2*quant)*5;
+    const int qscale = (215 - 2*quant)*5;
    int i;

    t->intra_matrix[0] = (ff_inv_aanscales[0] * ff_mpeg1_default_intra_matrix[0]) >> 11;
--- a/libavcodec/escape124.c
+++ b/libavcodec/escape124.c
@@ -250,10 +250,6 @@ static int escape124_decode_frame(AVCodecContext *avctx,
                // This codebook can be cut off at places other than
                // powers of 2, leaving some of the entries undefined.
                cb_size = get_bits_long(&gb, 20);
-                if (!cb_size) {
-                    av_log(avctx, AV_LOG_ERROR, "Invalid codebook size 0.\n");
-                    return AVERROR_INVALIDDATA;
-                }
                cb_depth = av_log2(cb_size - 1) + 1;
            } else {
                cb_depth = get_bits(&gb, 4);
--- a/libavcodec/exr.c
+++ b/libavcodec/exr.c
@@ -216,9 +216,9 @@ static union av_intfloat32 exr_half2float(uint16_t hf)
 *
 * @return normalized 16-bit unsigned int
 */
-static inline uint16_t exr_flt2uint(int32_t v)
+static inline uint16_t exr_flt2uint(uint32_t v)
 {
-    int32_t exp = v >> 23;
+    unsigned int exp = v >> 23;
    // "HACK": negative values result in exp<  0, so clipping them to 0
    // is also handled by this condition, avoids explicit check for sign bit.
    if (exp <= 127 + 7 - 24) // we would shift out all bits anyway
@@ -749,9 +749,6 @@ static int piz_uncompress(EXRContext *s, const uint8_t *src, int ssize,
    uint16_t *tmp = (uint16_t *)td->tmp;
    uint8_t *out;
    int ret, i, j;
-    int pixel_half_size;/* 1 for half, 2 for float and uint32 */
-    EXRChannel *channel;
-    int tmp_offset;

    if (!td->bitmap)
        td->bitmap = av_malloc(BITMAP_SIZE);
@@ -784,38 +781,24 @@ static int piz_uncompress(EXRContext *s, const uint8_t *src, int ssize,

    ptr = tmp;
    for (i = 0; i < s->nb_channels; i++) {
-        channel = &s->channels[i];
+        EXRChannel *channel = &s->channels[i];
+        int size = channel->pixel_type;

-        if (channel->pixel_type == EXR_HALF)
-            pixel_half_size = 1;
-        else
-            pixel_half_size = 2;
-
-        for (j = 0; j < pixel_half_size; j++)
-            wav_decode(ptr + j, td->xsize, pixel_half_size, td->ysize,
-                       td->xsize * pixel_half_size, maxval);
-        ptr += td->xsize * td->ysize * pixel_half_size;
+        for (j = 0; j < size; j++)
+            wav_decode(ptr + j, td->xsize, size, td->ysize,
+                       td->xsize * size, maxval);
+        ptr += td->xsize * td->ysize * size;
    }

    apply_lut(td->lut, tmp, dsize / sizeof(uint16_t));

    out = td->uncompressed_data;
-    for (i = 0; i < td->ysize; i++) {
-        tmp_offset = 0;
+    for (i = 0; i < td->ysize; i++)
        for (j = 0; j < s->nb_channels; j++) {
-            uint16_t *in;
-            EXRChannel *channel = &s->channels[j];
-            if (channel->pixel_type == EXR_HALF)
-                pixel_half_size = 1;
-            else
-                pixel_half_size = 2;
-
-            in = tmp + tmp_offset * td->xsize * td->ysize + i * td->xsize * pixel_half_size;
-            tmp_offset += pixel_half_size;
-            memcpy(out, in, td->xsize * 2 * pixel_half_size);
-            out += td->xsize * 2 * pixel_half_size;
+            uint16_t *in = tmp + j * td->xsize * td->ysize + i * td->xsize;
+            memcpy(out, in, td->xsize * 2);
+            out += td->xsize * 2;
        }
-    }

    return 0;
 }
@@ -1027,9 +1010,8 @@ static int decode_block(AVCodecContext *avctx, void *tdata,
    uint64_t line_offset, uncompressed_size;
    uint16_t *ptr_x;
    uint8_t *ptr;
-    uint32_t data_size;
-    uint64_t line, col = 0;
-    uint64_t tileX, tileY, tileLevelX, tileLevelY;
+    uint32_t data_size, line, col = 0;
+    uint32_t tileX, tileY, tileLevelX, tileLevelY;
    const uint8_t *src;
    int axmax = (avctx->width - (s->xmax + 1)) * 2 * s->desc->nb_components; /* nb pixel to add at the right of the datawindow */
    int bxmin = s->xmin * 2 * s->desc->nb_components; /* nb pixel to add at the left of the datawindow */
@@ -1060,18 +1042,9 @@ static int decode_block(AVCodecContext *avctx, void *tdata,
            return AVERROR_PATCHWELCOME;
        }

-        if (s->xmin || s->ymin) {
-            avpriv_report_missing_feature(s->avctx, "Tiles with xmin/ymin");
-            return AVERROR_PATCHWELCOME;
-        }
-
        line = s->tile_attr.ySize * tileY;
        col = s->tile_attr.xSize * tileX;

-        if (line < s->ymin || line > s->ymax ||
-            col  < s->xmin || col  > s->xmax)
-            return AVERROR_INVALIDDATA;
-
        td->ysize = FFMIN(s->tile_attr.ySize, s->ydelta - tileY * s->tile_attr.ySize);
        td->xsize = FFMIN(s->tile_attr.xSize, s->xdelta - tileX * s->tile_attr.xSize);

@@ -1417,15 +1390,17 @@ static int decode_header(EXRContext *s)
                    return AVERROR_PATCHWELCOME;
                }

-                if (channel_index >= 0 && s->channel_offsets[channel_index] == -1) { /* channel has not been previously assigned */
-                    if (s->pixel_type != EXR_UNKNOWN &&
-                        s->pixel_type != current_pixel_type) {
-                        av_log(s->avctx, AV_LOG_ERROR,
-                               "RGB channels not of the same depth.\n");
-                        return AVERROR_INVALIDDATA;
+                if (s->channel_offsets[channel_index] == -1){/* channel have not been previously assign */
+                    if (channel_index >= 0) {
+                        if (s->pixel_type != EXR_UNKNOWN &&
+                            s->pixel_type != current_pixel_type) {
+                            av_log(s->avctx, AV_LOG_ERROR,
+                                   "RGB channels not of the same depth.\n");
+                            return AVERROR_INVALIDDATA;
+                        }
+                        s->pixel_type                     = current_pixel_type;
+                        s->channel_offsets[channel_index] = s->current_channel_offset;
                    }
-                    s->pixel_type                     = current_pixel_type;
-                    s->channel_offsets[channel_index] = s->current_channel_offset;
                }

                s->channels = av_realloc(s->channels,
--- a/libavcodec/ffv1dec.c
+++ b/libavcodec/ffv1dec.c
@@ -45,8 +45,7 @@ static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state,
    if (get_rac(c, state + 0))
        return 0;
    else {
-        int i, e;
-        unsigned a;
+        int i, e, a;
        e = 0;
        while (get_rac(c, state + 1 + FFMIN(e, 9))) { // 1..10
            e++;
@@ -1004,7 +1003,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPac
            const uint8_t *src[4];
            uint8_t *dst[4];
            ff_thread_await_progress(&f->last_picture, INT_MAX, 0);
-            for (j = 0; j < desc->nb_components; j++) {
+            for (j = 0; j < 4; j++) {
                int pixshift = desc->comp[j].depth > 8;
                int sh = (j == 1 || j == 2) ? f->chroma_h_shift : 0;
                int sv = (j == 1 || j == 2) ? f->chroma_v_shift : 0;
@@ -1012,12 +1011,6 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPac
                         (fs->slice_y >> sv) + ((fs->slice_x >> sh) << pixshift);
                src[j] = f->last_picture.f->data[j] + f->last_picture.f->linesize[j] *
                         (fs->slice_y >> sv) + ((fs->slice_x >> sh) << pixshift);
-
-            }
-            if (desc->flags & AV_PIX_FMT_FLAG_PAL ||
-                desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL) {
-                dst[1] = p->data[1];
-                src[1] = f->last_picture.f->data[1];
            }
            av_image_copy(dst, p->linesize, src,
                          f->last_picture.f->linesize,
--- a/libavcodec/ffv1enc.c
+++ b/libavcodec/ffv1enc.c
@@ -781,12 +781,14 @@ FF_ENABLE_DEPRECATION_WARNINGS
        s->colorspace = 1;
        s->transparency = 1;
        s->chroma_planes = 1;
-        s->bits_per_raw_sample = 8;
+        if (!avctx->bits_per_raw_sample)
+            s->bits_per_raw_sample = 8;
        break;
    case AV_PIX_FMT_0RGB32:
        s->colorspace = 1;
        s->chroma_planes = 1;
-        s->bits_per_raw_sample = 8;
+        if (!avctx->bits_per_raw_sample)
+            s->bits_per_raw_sample = 8;
        break;
    case AV_PIX_FMT_GBRP9:
        if (!avctx->bits_per_raw_sample)
@@ -1223,6 +1225,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
    FFV1Context *f      = avctx->priv_data;
    RangeCoder *const c = &f->slice_context[0]->c;
    AVFrame *const p    = f->picture.f;
+    int used_count      = 0;
    uint8_t keystate    = 128;
    uint8_t *buf_p;
    int i, ret;
@@ -1278,11 +1281,6 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
    if (f->version > 3)
        maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;

-    if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
-        av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
-        maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
-    }
-
    if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
        return ret;

@@ -1316,17 +1314,11 @@ FF_ENABLE_DEPRECATION_WARNINGS
        }
    }

-    for (i = 0; i < f->slice_count; i++) {
+    for (i = 1; i < f->slice_count; i++) {
        FFV1Context *fs = f->slice_context[i];
-        uint8_t *start  = pkt->data + pkt->size * (int64_t)i / f->slice_count;
+        uint8_t *start  = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
        int len         = pkt->size / f->slice_count;
-        if (i) {
-            ff_init_range_encoder(&fs->c, start, len);
-        } else {
-            av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
-            av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
-            fs->c.bytestream_end = fs->c.bytestream_start + len;
-        }
+        ff_init_range_encoder(&fs->c, start, len);
    }
    avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
                   f->slice_count, sizeof(void *));
--- a/libavcodec/fic.c
+++ b/libavcodec/fic.c
@@ -88,22 +88,22 @@ static av_always_inline void fic_idct(int16_t *blk, int step, int shift, int rnd
    const int t1 =  27246 * blk[5 * step] - 18405 * blk[3 * step];
    const int t2 =   6393 * blk[7 * step] + 32139 * blk[1 * step];
    const int t3 =   6393 * blk[1 * step] - 32139 * blk[7 * step];
-    const unsigned t4 = 5793U * (t2 + t0 + 0x800 >> 12);
-    const unsigned t5 = 5793U * (t3 + t1 + 0x800 >> 12);
-    const unsigned t6 = t2 - t0;
-    const unsigned t7 = t3 - t1;
-    const unsigned t8 =  17734 * blk[2 * step] - 42813 * blk[6 * step];
-    const unsigned t9 =  17734 * blk[6 * step] + 42814 * blk[2 * step];
-    const unsigned tA = (blk[0 * step] - blk[4 * step]) * 32768 + rnd;
-    const unsigned tB = (blk[0 * step] + blk[4 * step]) * 32768 + rnd;
-    blk[0 * step] = (int)(  t4       + t9 + tB) >> shift;
-    blk[1 * step] = (int)(  t6 + t7  + t8 + tA) >> shift;
-    blk[2 * step] = (int)(  t6 - t7  - t8 + tA) >> shift;
-    blk[3 * step] = (int)(  t5       - t9 + tB) >> shift;
-    blk[4 * step] = (int)( -t5       - t9 + tB) >> shift;
-    blk[5 * step] = (int)(-(t6 - t7) - t8 + tA) >> shift;
-    blk[6 * step] = (int)(-(t6 + t7) + t8 + tA) >> shift;
-    blk[7 * step] = (int)( -t4       + t9 + tB) >> shift;
+    const int t4 = 5793 * (t2 + t0 + 0x800 >> 12);
+    const int t5 = 5793 * (t3 + t1 + 0x800 >> 12);
+    const int t6 = t2 - t0;
+    const int t7 = t3 - t1;
+    const int t8 =  17734 * blk[2 * step] - 42813 * blk[6 * step];
+    const int t9 =  17734 * blk[6 * step] + 42814 * blk[2 * step];
+    const int tA = (blk[0 * step] - blk[4 * step] << 15) + rnd;
+    const int tB = (blk[0 * step] + blk[4 * step] << 15) + rnd;
+    blk[0 * step] = (  t4       + t9 + tB) >> shift;
+    blk[1 * step] = (  t6 + t7  + t8 + tA) >> shift;
+    blk[2 * step] = (  t6 - t7  - t8 + tA) >> shift;
+    blk[3 * step] = (  t5       - t9 + tB) >> shift;
+    blk[4 * step] = ( -t5       - t9 + tB) >> shift;
+    blk[5 * step] = (-(t6 - t7) - t8 + tA) >> shift;
+    blk[6 * step] = (-(t6 + t7) + t8 + tA) >> shift;
+    blk[7 * step] = ( -t4       + t9 + tB) >> shift;
 }

 static void fic_idct_put(uint8_t *dst, int stride, int16_t *block)
--- a/libavcodec/flac_parser.c
+++ b/libavcodec/flac_parser.c
@@ -586,12 +586,10 @@ static int flac_parse(AVCodecParserContext *s, AVCodecContext *avctx,
            temp = curr->next;
            av_freep(&curr->link_penalty);
            av_free(curr);
-            fpc->nb_headers_buffered--;
        }
        fpc->headers = fpc->best_header->next;
        av_freep(&fpc->best_header->link_penalty);
        av_freep(&fpc->best_header);
-        fpc->nb_headers_buffered--;
    }

    /* Find and score new headers.                                     */
--- a/libavcodec/flacdec.c
+++ b/libavcodec/flacdec.c
@@ -201,12 +201,12 @@ static int get_metadata_size(const uint8_t *buf, int buf_size)
    buf += 4;
    do {
        if (buf_end - buf < 4)
-            return AVERROR_INVALIDDATA;
+            return 0;
        flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
        buf += 4;
        if (buf_end - buf < metadata_size) {
            /* need more data in order to read the complete header */
-            return AVERROR_INVALIDDATA;
+            return 0;
        }
        buf += metadata_size;
    } while (!metadata_last);
@@ -268,8 +268,7 @@ static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
                                 int pred_order, int bps)
 {
    const int blocksize = s->blocksize;
-    unsigned av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d);
-    int i;
+    int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
    int ret;

    /* warm up samples */
@@ -448,7 +447,7 @@ static inline int decode_subframe(FLACContext *s, int channel)
    if (wasted) {
        int i;
        for (i = 0; i < s->blocksize; i++)
-            decoded[i] = (unsigned)decoded[i] << wasted;
+            decoded[i] <<= wasted;
    }

    return 0;
--- a/libavcodec/flacdsp_template.c
+++ b/libavcodec/flacdsp_template.c
@@ -56,7 +56,7 @@ static void FUNC(flac_decorrelate_indep_c)(uint8_t **out, int32_t **in,

    for (j = 0; j < len; j++)
        for (i = 0; i < channels; i++)
-            S(samples, i, j) = (int)((unsigned)in[i][j] << shift);
+            S(samples, i, j) = in[i][j] << shift;
 }

 static void FUNC(flac_decorrelate_ls_c)(uint8_t **out, int32_t **in,
--- a/libavcodec/flicvideo.c
+++ b/libavcodec/flicvideo.c
@@ -202,9 +202,6 @@ static int flic_decode_frame_8BPP(AVCodecContext *avctx,
    num_chunks = bytestream2_get_le16(&g2);
    bytestream2_skip(&g2, 8);  /* skip padding */

-    if (frame_size < 16)
-        return AVERROR_INVALIDDATA;
-
    frame_size -= 16;

    /* iterate through the chunks */
@@ -275,14 +272,10 @@ static int flic_decode_frame_8BPP(AVCodecContext *avctx,
            while (compressed_lines > 0) {
                if (bytestream2_tell(&g2) + 2 > stream_ptr_after_chunk)
                    break;
-                if (y_ptr > pixel_limit)
-                    return AVERROR_INVALIDDATA;
                line_packets = bytestream2_get_le16(&g2);
                if ((line_packets & 0xC000) == 0xC000) {
                    // line skip opcode
                    line_packets = -line_packets;
-                    if (line_packets > s->avctx->height)
-                        return AVERROR_INVALIDDATA;
                    y_ptr += line_packets * s->frame->linesize[0];
                } else if ((line_packets & 0xC000) == 0x4000) {
                    av_log(avctx, AV_LOG_ERROR, "Undefined opcode (%x) in DELTA_FLI\n", line_packets);
@@ -331,8 +324,6 @@ static int flic_decode_frame_8BPP(AVCodecContext *avctx,
        case FLI_LC:
            /* line compressed */
            starting_line = bytestream2_get_le16(&g2);
-            if (starting_line >= s->avctx->height)
-                return AVERROR_INVALIDDATA;
            y_ptr = 0;
            y_ptr += starting_line * s->frame->linesize[0];

@@ -531,8 +522,6 @@ static int flic_decode_frame_15_16BPP(AVCodecContext *avctx,
    if (frame_size > buf_size)
        frame_size = buf_size;

-    if (frame_size < 16)
-        return AVERROR_INVALIDDATA;
    frame_size -= 16;

    /* iterate through the chunks */
@@ -569,13 +558,9 @@ static int flic_decode_frame_15_16BPP(AVCodecContext *avctx,
            while (compressed_lines > 0) {
                if (bytestream2_tell(&g2) + 2 > stream_ptr_after_chunk)
                    break;
-                if (y_ptr > pixel_limit)
-                    return AVERROR_INVALIDDATA;
                line_packets = bytestream2_get_le16(&g2);
                if (line_packets < 0) {
                    line_packets = -line_packets;
-                    if (line_packets > s->avctx->height)
-                        return AVERROR_INVALIDDATA;
                    y_ptr += line_packets * s->frame->linesize[0];
                } else {
                    compressed_lines--;
--- a/libavcodec/g722.c
+++ b/libavcodec/g722.c
@@ -88,14 +88,14 @@ static inline void s_zero(int cur_diff, struct G722Band *band)
        ACCUM(3, band->diff_mem[2], 1);
        ACCUM(2, band->diff_mem[1], 1);
        ACCUM(1, band->diff_mem[0], 1);
-        ACCUM(0, cur_diff * 2, 1);
+        ACCUM(0, cur_diff << 1, 1);
    } else {
        ACCUM(5, band->diff_mem[4], 0);
        ACCUM(4, band->diff_mem[3], 0);
        ACCUM(3, band->diff_mem[2], 0);
        ACCUM(2, band->diff_mem[1], 0);
        ACCUM(1, band->diff_mem[0], 0);
-        ACCUM(0, cur_diff * 2, 0);
+        ACCUM(0, cur_diff << 1, 0);
    }
    #undef ACCUM
    band->s_zero = s_zero;
@@ -119,14 +119,14 @@ static void do_adaptive_prediction(struct G722Band *band, const int cur_diff)
    band->part_reconst_mem[0] = cur_part_reconst;

    band->pole_mem[1] = av_clip((sg[0] * av_clip(band->pole_mem[0], -8191, 8191) >> 5) +
-                                (sg[1] * 128) + (band->pole_mem[1] * 127 >> 7), -12288, 12288);
+                                (sg[1] << 7) + (band->pole_mem[1] * 127 >> 7), -12288, 12288);

    limit = 15360 - band->pole_mem[1];
    band->pole_mem[0] = av_clip(-192 * sg[0] + (band->pole_mem[0] * 255 >> 8), -limit, limit);

    s_zero(cur_diff, band);

-    cur_qtzd_reconst = av_clip_int16((band->s_predictor + cur_diff) * 2);
+    cur_qtzd_reconst = av_clip_int16((band->s_predictor + cur_diff) << 1);
    band->s_predictor = av_clip_int16(band->s_zero +
                                      (band->pole_mem[0] * cur_qtzd_reconst >> 15) +
                                      (band->pole_mem[1] * band->prev_qtzd_reconst >> 15));
--- a/libavcodec/g723_1.c
+++ b/libavcodec/g723_1.c
@@ -41,7 +41,7 @@ int ff_g723_1_scale_vector(int16_t *dst, const int16_t *vector, int length)
    bits= FFMAX(bits, 0);

    for (i = 0; i < length; i++)
-        dst[i] = (vector[i] * (1 << bits)) >> 3;
+        dst[i] = vector[i] << bits >> 3;

    return bits - 3;
 }
@@ -125,9 +125,9 @@ static void lsp2lpc(int16_t *lpc)
    for (j = 0; j < LPC_ORDER; j++) {
        int index     = (lpc[j] >> 7) & 0x1FF;
        int offset    = lpc[j] & 0x7f;
-        int temp1     = cos_tab[index] * (1 << 16);
+        int temp1     = cos_tab[index] << 16;
        int temp2     = (cos_tab[index + 1] - cos_tab[index]) *
-                          (((offset << 8) + 0x80) << 1);
+                          ((offset << 8) + 0x80) << 1;

        lpc[j] = -(av_sat_dadd32(1 << 15, temp1 + temp2) >> 16);
    }
@@ -138,11 +138,11 @@ static void lsp2lpc(int16_t *lpc)
     */
    /* Initialize with values in Q28 */
    f1[0] = 1 << 28;
-    f1[1] = (lpc[0] + lpc[2]) * (1 << 14);
+    f1[1] = (lpc[0] << 14) + (lpc[2] << 14);
    f1[2] = lpc[0] * lpc[2] + (2 << 28);

    f2[0] = 1 << 28;
-    f2[1] = (lpc[1] + lpc[3]) * (1 << 14);
+    f2[1] = (lpc[1] << 14) + (lpc[3] << 14);
    f2[2] = lpc[1] * lpc[3] + (2 << 28);

    /*
@@ -162,8 +162,8 @@ static void lsp2lpc(int16_t *lpc)

        f1[0] >>= 1;
        f2[0] >>= 1;
-        f1[1] = ((lpc[2 * i]     * 65536 >> i) + f1[1]) >> 1;
-        f2[1] = ((lpc[2 * i + 1] * 65536 >> i) + f2[1]) >> 1;
+        f1[1] = ((lpc[2 * i]     << 16 >> i) + f1[1]) >> 1;
+        f2[1] = ((lpc[2 * i + 1] << 16 >> i) + f2[1]) >> 1;
    }

    /* Convert polynomial coefficients to LPC coefficients */
@@ -171,8 +171,8 @@ static void lsp2lpc(int16_t *lpc)
        int64_t ff1 = f1[i + 1] + f1[i];
        int64_t ff2 = f2[i + 1] - f2[i];

-        lpc[i] = av_clipl_int32(((ff1 + ff2) * 8) + (1 << 15)) >> 16;
-        lpc[LPC_ORDER - i - 1] = av_clipl_int32(((ff1 - ff2) * 8) +
+        lpc[i] = av_clipl_int32(((ff1 + ff2) << 3) + (1 << 15)) >> 16;
+        lpc[LPC_ORDER - i - 1] = av_clipl_int32(((ff1 - ff2) << 3) +
                                                (1 << 15)) >> 16;
    }
 }
--- a/libavcodec/g723_1.h
+++ b/libavcodec/g723_1.h
@@ -55,7 +55,7 @@
 * @param b 16 bit multiplier
 */
 #define MULL2(a, b) \
-        ((((a) >> 16) * (b) * 2) + (((a) & 0xffff) * (b) >> 15))
+        ((((a) >> 16) * (b) << 1) + (((a) & 0xffff) * (b) >> 15))

 /**
 * G723.1 frame types
--- a/libavcodec/g723_1dec.c
+++ b/libavcodec/g723_1dec.c
@@ -487,7 +487,7 @@ static void residual_interp(int16_t *buf, int16_t *out, int lag,
                          (FRAME_LEN - lag) * sizeof(*out));
    } else {  /* Unvoiced */
        for (i = 0; i < FRAME_LEN; i++) {
-            *rseed = (int16_t)(*rseed * 521 + 259);
+            *rseed = *rseed * 521 + 259;
            out[i] = gain * *rseed >> 15;
        }
        memset(buf, 0, (FRAME_LEN + PITCH_MAX) * sizeof(*buf));
@@ -516,7 +516,7 @@ static void residual_interp(int16_t *buf, int16_t *out, int lag,
                      (iir_coef)[n - 1] * ((dest)[m - n] >> in_shift);\
        }\
 \
-        (dest)[m] = av_clipl_int32(((src)[m] * 65536) + (filter * 8) +\
+        (dest)[m] = av_clipl_int32(((src)[m] << 16) + (filter << 3) +\
                                   (1 << 15)) >> res_shift;\
    }\
 }
@@ -663,7 +663,7 @@ static int estimate_sid_gain(G723_1_Context *p)
        t = p->sid_gain << shift;
    else
        t = p->sid_gain >> -shift;
-    x = av_clipl_int32(t * (int64_t)cng_filt[0] >> 16);
+    x = t * cng_filt[0] >> 16;

    if (x >= cng_bseg[2])
        return 0x3F;
@@ -694,13 +694,13 @@ static int estimate_sid_gain(G723_1_Context *p)
    if (y <= 0) {
        t = seg * 32 + (val + 1 << seg2);
        t = t * t - x;
-        val = (seg2 - 1) * 16 + val;
+        val = (seg2 - 1 << 4) + val;
        if (t >= y)
            val++;
    } else {
        t = seg * 32 + (val - 1 << seg2);
        t = t * t - x;
-        val = (seg2 - 1) * 16 + val;
+        val = (seg2 - 1 << 4) + val;
        if (t >= y)
            val--;
    }
@@ -732,7 +732,7 @@ static void generate_noise(G723_1_Context *p)
        off[i * 2 + 1] = ((t >> 1) & 1) + SUBFRAME_LEN;
        t >>= 2;
        for (j = 0; j < 11; j++) {
-            signs[i * 11 + j] = ((t & 1) * 2 - 1)  * (1 << 14);
+            signs[i * 11 + j] = (t & 1) * 2 - 1 << 14;
            t >>= 1;
        }
    }
@@ -776,7 +776,7 @@ static void generate_noise(G723_1_Context *p)
        sum = 0;
        if (shift < 0) {
           for (j = 0; j < SUBFRAME_LEN * 2; j++) {
-               t      = vector_ptr[j] * (1 << -shift);
+               t      = vector_ptr[j] << -shift;
               sum   += t * t;
               tmp[j] = t;
           }
@@ -814,7 +814,7 @@ static void generate_noise(G723_1_Context *p)
        if (shift < 0)
           x >>= -shift;
        else
-           x *= 1 << shift;
+           x <<= shift;
        x = av_clip(x, -10000, 10000);

        for (j = 0; j < 11; j++) {
@@ -903,7 +903,7 @@ static int g723_1_decode_frame(AVCodecContext *avctx, void *data,
                                             &p->subframe[i], p->cur_rate);
                /* Get the total excitation */
                for (j = 0; j < SUBFRAME_LEN; j++) {
-                    int v = av_clip_int16(vector_ptr[j] * 2);
+                    int v = av_clip_int16(vector_ptr[j] << 1);
                    vector_ptr[j] = av_clip_int16(v + acb_vector[j]);
                }
                vector_ptr += SUBFRAME_LEN;
--- a/libavcodec/g726.c
+++ b/libavcodec/g726.c
@@ -206,7 +206,7 @@ static int16_t g726_decode(G726Context* c, int I)

    if (I_sig)  /* get the sign */
        dq = -dq;
-    re_signal = (int16_t)(c->se + dq);
+    re_signal = c->se + dq;

    /* Update second order predictor coefficient A2 and A1 */
    pk0 = (c->sez + dq) ? sgn(c->sez + dq) : 0;
@@ -269,7 +269,7 @@ static int16_t g726_decode(G726Context* c, int I)
        c->se += mult(i2f(c->a[i] >> 2, &f), &c->sr[i]);
    c->se >>= 1;

-    return av_clip(re_signal * 4, -0xffff, 0xffff);
+    return av_clip(re_signal << 2, -0xffff, 0xffff);
 }

 static av_cold int g726_reset(G726Context *c)
--- a/libavcodec/get_bits.h
+++ b/libavcodec/get_bits.h
@@ -369,10 +369,6 @@ static inline uint64_t get_bits64(GetBitContext *s, int n)
 */
 static inline int get_sbits_long(GetBitContext *s, int n)
 {
-    // sign_extend(x, 0) is undefined
-    if (!n)
-        return 0;
-
    return sign_extend(get_bits_long(s, n), n);
 }

--- a/libavcodec/h264.c
+++ b/libavcodec/h264.c
@@ -898,7 +898,7 @@ static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size)
    }

    ret = ff_h2645_packet_split(&h->pkt, buf, buf_size, avctx, h->is_avc,
-                                h->nal_length_size, avctx->codec_id, avctx->flags2 & AV_CODEC_FLAG2_FAST);
+                                h->nal_length_size, avctx->codec_id);
    if (ret < 0) {
        av_log(avctx, AV_LOG_ERROR,
               "Error splitting the input into NAL units.\n");
@@ -1023,8 +1023,7 @@ again:
 #endif
                } else
                    context_count++;
-            } else
-                sl->ref_count[0] = sl->ref_count[1] = 0;
+            }
            break;
        case NAL_DPA:
        case NAL_DPB:
--- a/libavcodec/h264.h
+++ b/libavcodec/h264.h
@@ -57,6 +57,8 @@

 #define MAX_DELAYED_PIC_COUNT  16

+#define MAX_MBPAIR_SIZE (256*1024) // a tighter bound could be calculated if someone cares about a few bytes
+
 /* Compiling in interlaced support reduces the speed
 * of progressive decoding by about 2%. */
 #define ALLOW_INTERLACE
--- a/libavcodec/h2645_parse.c
+++ b/libavcodec/h2645_parse.c
@@ -30,11 +30,10 @@
 #include "h2645_parse.h"

 int ff_h2645_extract_rbsp(const uint8_t *src, int length,
-                          H2645NAL *nal, int small_padding)
+                          H2645NAL *nal)
 {
    int i, si, di;
    uint8_t *dst;
-    int64_t padding = small_padding ? 0 : MAX_MBPAIR_SIZE;

    nal->skipped_bytes = 0;
 #define STARTCODE_TEST                                                  \
@@ -82,17 +81,16 @@ int ff_h2645_extract_rbsp(const uint8_t *src, int length,
    }
 #endif /* HAVE_FAST_UNALIGNED */

-    if (i >= length - 1 && small_padding) { // no escaped 0
+    if (i >= length - 1) { // no escaped 0
        nal->data     =
        nal->raw_data = src;
        nal->size     =
        nal->raw_size = length;
        return length;
-    } else if (i > length)
-        i = length;
+    }

-    av_fast_padded_malloc(&nal->rbsp_buffer, &nal->rbsp_buffer_size,
-                          length + padding);
+    av_fast_malloc(&nal->rbsp_buffer, &nal->rbsp_buffer_size,
+                   length + AV_INPUT_BUFFER_PADDING_SIZE);
    if (!nal->rbsp_buffer)
        return AVERROR(ENOMEM);

@@ -249,7 +247,7 @@ static int h264_parse_nal_header(H2645NAL *nal, void *logctx)

 int ff_h2645_packet_split(H2645Packet *pkt, const uint8_t *buf, int length,
                          void *logctx, int is_nalff, int nal_length_size,
-                          enum AVCodecID codec_id, int small_padding)
+                          enum AVCodecID codec_id)
 {
    int consumed, ret = 0;
    const uint8_t *next_avc = is_nalff ? buf : buf + length;
@@ -260,21 +258,19 @@ int ff_h2645_packet_split(H2645Packet *pkt, const uint8_t *buf, int length,
        int extract_length = 0;
        int skip_trailing_zeros = 1;

-        if (buf == next_avc) {
-            int i = 0;
-            extract_length = get_nalsize(nal_length_size,
-                                         buf, length, &i, logctx);
-            if (extract_length < 0)
-                return extract_length;
-
+        if (buf >= next_avc) {
+            int i;
+            for (i = 0; i < nal_length_size; i++)
+                extract_length = (extract_length << 8) | buf[i];
            buf    += nal_length_size;
            length -= nal_length_size;

+            if (extract_length > length) {
+                av_log(logctx, AV_LOG_ERROR, "Invalid NAL unit size.\n");
+                return AVERROR_INVALIDDATA;
+            }
            next_avc = buf + extract_length;
        } else {
-            if (buf > next_avc)
-                av_log(logctx, AV_LOG_WARNING, "Exceeded next NALFF position, re-syncing.\n");
-
            /* search start code */
            while (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
                ++buf;
@@ -294,7 +290,7 @@ int ff_h2645_packet_split(H2645Packet *pkt, const uint8_t *buf, int length,

            buf           += 3;
            length        -= 3;
-            extract_length = FFMIN(length, next_avc - buf);
+            extract_length = length;

            if (buf >= next_avc) {
                /* skip to the start of the next NAL */
@@ -326,7 +322,7 @@ int ff_h2645_packet_split(H2645Packet *pkt, const uint8_t *buf, int length,
        }
        nal = &pkt->nals[pkt->nb_nals];

-        consumed = ff_h2645_extract_rbsp(buf, extract_length, nal, small_padding);
+        consumed = ff_h2645_extract_rbsp(buf, extract_length, nal);
        if (consumed < 0)
            return consumed;

--- a/libavcodec/h2645_parse.h
+++ b/libavcodec/h2645_parse.h
@@ -26,8 +26,6 @@
 #include "avcodec.h"
 #include "get_bits.h"

-#define MAX_MBPAIR_SIZE (256*1024) // a tighter bound could be calculated if someone cares about a few bytes
-
 typedef struct H2645NAL {
    uint8_t *rbsp_buffer;
    int rbsp_buffer_size;
@@ -76,38 +74,18 @@ typedef struct H2645Packet {
 * Extract the raw (unescaped) bitstream.
 */
 int ff_h2645_extract_rbsp(const uint8_t *src, int length,
-                          H2645NAL *nal, int small_padding);
+                          H2645NAL *nal);

 /**
 * Split an input packet into NAL units.
 */
 int ff_h2645_packet_split(H2645Packet *pkt, const uint8_t *buf, int length,
                          void *logctx, int is_nalff, int nal_length_size,
-                          enum AVCodecID codec_id, int small_padding);
+                          enum AVCodecID codec_id);

 /**
 * Free all the allocated memory in the packet.
 */
 void ff_h2645_packet_uninit(H2645Packet *pkt);

-static inline int get_nalsize(int nal_length_size, const uint8_t *buf,
-                              int buf_size, int *buf_index, void *logctx)
-{
-    int i, nalsize = 0;
-
-    if (*buf_index >= buf_size - nal_length_size) {
-        // the end of the buffer is reached, refill it
-        return AVERROR(EAGAIN);
-    }
-
-    for (i = 0; i < nal_length_size; i++)
-        nalsize = ((unsigned)nalsize << 8) | buf[(*buf_index)++];
-    if (nalsize <= 0 || nalsize > buf_size - *buf_index) {
-        av_log(logctx, AV_LOG_ERROR,
-               "Invalid nal size %d\n", nalsize);
-        return AVERROR_INVALIDDATA;
-    }
-    return nalsize;
-}
-
 #endif /* AVCODEC_H2645_PARSE_H */
--- a/libavcodec/h264_cabac.c
+++ b/libavcodec/h264_cabac.c
@@ -1744,7 +1744,7 @@ decode_cabac_residual_internal(const H264Context *h, H264SliceContext *sl,
                while( j-- ) { \
                    coeff_abs += coeff_abs + get_cabac_bypass( CC ); \
                } \
-                coeff_abs+= 14U; \
+                coeff_abs+= 14; \
            } \
 \
            if( is_dc ) { \
@@ -2348,41 +2348,22 @@ decode_intra_mb:
    if (CHROMA444(h) && IS_8x8DCT(mb_type)){
        int i;
        uint8_t *nnz_cache = sl->non_zero_count_cache;
-        if (h->sei.unregistered.x264_build < 151U) {
-            for (i = 0; i < 2; i++){
-                if (sl->left_type[LEFT(i)] && !IS_8x8DCT(sl->left_type[LEFT(i)])) {
-                    nnz_cache[3+8* 1 + 2*8*i]=
-                    nnz_cache[3+8* 2 + 2*8*i]=
-                    nnz_cache[3+8* 6 + 2*8*i]=
-                    nnz_cache[3+8* 7 + 2*8*i]=
-                    nnz_cache[3+8*11 + 2*8*i]=
-                    nnz_cache[3+8*12 + 2*8*i]= IS_INTRA(mb_type) ? 64 : 0;
-                }
-            }
-            if (sl->top_type && !IS_8x8DCT(sl->top_type)){
-                uint32_t top_empty = !IS_INTRA(mb_type) ? 0 : 0x40404040;
-                AV_WN32A(&nnz_cache[4+8* 0], top_empty);
-                AV_WN32A(&nnz_cache[4+8* 5], top_empty);
-                AV_WN32A(&nnz_cache[4+8*10], top_empty);
-            }
-        } else {
-            for (i = 0; i < 2; i++){
-                if (sl->left_type[LEFT(i)] && !IS_8x8DCT(sl->left_type[LEFT(i)])) {
-                    nnz_cache[3+8* 1 + 2*8*i]=
-                    nnz_cache[3+8* 2 + 2*8*i]=
-                    nnz_cache[3+8* 6 + 2*8*i]=
-                    nnz_cache[3+8* 7 + 2*8*i]=
-                    nnz_cache[3+8*11 + 2*8*i]=
-                    nnz_cache[3+8*12 + 2*8*i]= !IS_INTRA_PCM(sl->left_type[LEFT(i)]) ? 0 : 64;
-                }
-            }
-            if (sl->top_type && !IS_8x8DCT(sl->top_type)){
-                uint32_t top_empty = !IS_INTRA_PCM(sl->top_type) ? 0 : 0x40404040;
-                AV_WN32A(&nnz_cache[4+8* 0], top_empty);
-                AV_WN32A(&nnz_cache[4+8* 5], top_empty);
-                AV_WN32A(&nnz_cache[4+8*10], top_empty);
+        for (i = 0; i < 2; i++){
+            if (sl->left_type[LEFT(i)] && !IS_8x8DCT(sl->left_type[LEFT(i)])) {
+                nnz_cache[3+8* 1 + 2*8*i]=
+                nnz_cache[3+8* 2 + 2*8*i]=
+                nnz_cache[3+8* 6 + 2*8*i]=
+                nnz_cache[3+8* 7 + 2*8*i]=
+                nnz_cache[3+8*11 + 2*8*i]=
+                nnz_cache[3+8*12 + 2*8*i]= IS_INTRA(mb_type) ? 64 : 0;
            }
        }
+        if (sl->top_type && !IS_8x8DCT(sl->top_type)){
+            uint32_t top_empty = CABAC(h) && !IS_INTRA(mb_type) ? 0 : 0x40404040;
+            AV_WN32A(&nnz_cache[4+8* 0], top_empty);
+            AV_WN32A(&nnz_cache[4+8* 5], top_empty);
+            AV_WN32A(&nnz_cache[4+8*10], top_empty);
+        }
    }
    h->cur_pic.mb_type[mb_xy] = mb_type;

@@ -2390,6 +2371,14 @@ decode_intra_mb:
        const uint8_t *scan, *scan8x8;
        const uint32_t *qmul;

+        if(IS_INTERLACED(mb_type)){
+            scan8x8 = sl->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
+            scan    = sl->qscale ? h->field_scan : h->field_scan_q0;
+        }else{
+            scan8x8 = sl->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
+            scan    = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
+        }
+
        // decode_cabac_mb_dqp
        if(get_cabac_noinline( &sl->cabac, &sl->cabac_state[60 + (sl->last_qscale_diff != 0)])){
            int val = 1;
@@ -2420,14 +2409,6 @@ decode_intra_mb:
        }else
            sl->last_qscale_diff=0;

-        if(IS_INTERLACED(mb_type)){
-            scan8x8 = sl->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
-            scan    = sl->qscale ? h->field_scan : h->field_scan_q0;
-        }else{
-            scan8x8 = sl->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
-            scan    = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
-        }
-
        decode_cabac_luma_residual(h, sl, scan, scan8x8, pixel_shift, mb_type, cbp, 0);
        if (CHROMA444(h)) {
            decode_cabac_luma_residual(h, sl, scan, scan8x8, pixel_shift, mb_type, cbp, 1);
--- a/libavcodec/h264_cavlc.c
+++ b/libavcodec/h264_cavlc.c
@@ -1102,9 +1102,17 @@ decode_intra_mb:
        const uint8_t *scan, *scan8x8;
        const int max_qp = 51 + 6 * (h->ps.sps->bit_depth_luma - 8);

+        if(IS_INTERLACED(mb_type)){
+            scan8x8 = sl->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
+            scan    = sl->qscale ? h->field_scan : h->field_scan_q0;
+        }else{
+            scan8x8 = sl->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
+            scan    = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
+        }
+
        dquant= get_se_golomb(&sl->gb);

-        sl->qscale += (unsigned)dquant;
+        sl->qscale += dquant;

        if (((unsigned)sl->qscale) > max_qp){
            if (sl->qscale < 0) sl->qscale += max_qp + 1;
@@ -1118,14 +1126,6 @@ decode_intra_mb:
        sl->chroma_qp[0] = get_chroma_qp(h, 0, sl->qscale);
        sl->chroma_qp[1] = get_chroma_qp(h, 1, sl->qscale);

-        if(IS_INTERLACED(mb_type)){
-            scan8x8 = sl->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
-            scan    = sl->qscale ? h->field_scan : h->field_scan_q0;
-        }else{
-            scan8x8 = sl->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
-            scan    = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
-        }
-
        if ((ret = decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ) {
            return -1;
        }
--- a/libavcodec/h264_direct.c
+++ b/libavcodec/h264_direct.c
@@ -613,7 +613,7 @@ single_col:

                {
                    const int16_t *mv_col = l1mv[x8 * 3 + y8 * b4_stride];
-                    int my_col            = (mv_col[1] * (1 << y_shift)) / 2;
+                    int my_col            = (mv_col[1] << y_shift) / 2;
                    int mx                = (scale * mv_col[0] + 128) >> 8;
                    int my                = (scale * my_col    + 128) >> 8;
                    fill_rectangle(&sl->mv_cache[0][scan8[i8 * 4]], 2, 2, 8,
--- a/libavcodec/h264_mb.c
+++ b/libavcodec/h264_mb.c
@@ -636,7 +636,7 @@ static av_always_inline void hl_decode_mb_predict_luma(const H264Context *h,
                uint8_t *const ptr = dest_y + block_offset[i];
                const int dir      = sl->intra4x4_pred_mode_cache[scan8[i]];
                if (transform_bypass && h->ps.sps->profile_idc == 244 && dir <= 1) {
-                    if (h->sei.unregistered.x264_build < 151U) {
+                    if (h->sei.unregistered.x264_build != -1) {
                        h->hpc.pred8x8l_add[dir](ptr, sl->mb + (i * 16 + p * 256 << pixel_shift), linesize);
                    } else
                        h->hpc.pred8x8l_filter_add[dir](ptr, sl->mb + (i * 16 + p * 256 << pixel_shift),
--- a/libavcodec/h264_mvpred.h
+++ b/libavcodec/h264_mvpred.h
@@ -68,7 +68,7 @@ static av_always_inline int fetch_diagonal_mv(const H264Context *h, H264SliceCon
            }
            if (MB_FIELD(sl) && !IS_INTERLACED(sl->left_type[0])) {
                // left shift will turn LIST_NOT_USED into PART_NOT_AVAILABLE, but that's OK.
-                SET_DIAG_MV(/ 2, *2, sl->left_mb_xy[i >= 36], ((i >> 2)) & 3);
+                SET_DIAG_MV(/ 2, << 1, sl->left_mb_xy[i >= 36], ((i >> 2)) & 3);
            }
        }
 #undef SET_DIAG_MV
@@ -248,7 +248,7 @@ static av_always_inline void pred_8x16_motion(const H264Context *const h,
            if (IS_INTERLACED(type)) {          \
                refn >>= 1;                     \
                AV_COPY32(mvbuf[idx], mvn);     \
-                mvbuf[idx][1] *= 2;             \
+                mvbuf[idx][1] <<= 1;            \
                mvn = mvbuf[idx];               \
            }                                   \
        }                                       \
--- a/libavcodec/h264_parse.c
+++ b/libavcodec/h264_parse.c
@@ -327,7 +327,7 @@ static int decode_extradata_ps(const uint8_t *data, int size, H264ParamSets *ps,
    H2645Packet pkt = { 0 };
    int i, ret = 0;

-    ret = ff_h2645_packet_split(&pkt, data, size, logctx, is_avc, 2, AV_CODEC_ID_H264, 1);
+    ret = ff_h2645_packet_split(&pkt, data, size, logctx, is_avc, 2, AV_CODEC_ID_H264);
    if (ret < 0) {
        ret = 0;
        goto fail;
--- a/libavcodec/h264_parser.c
+++ b/libavcodec/h264_parser.c
@@ -226,6 +226,26 @@ static int scan_mmco_reset(AVCodecParserContext *s, GetBitContext *gb,
    return 0;
 }

+static inline int get_avc_nalsize(H264ParseContext *p, const uint8_t *buf,
+                                  int buf_size, int *buf_index, void *logctx)
+{
+    int i, nalsize = 0;
+
+    if (*buf_index >= buf_size - p->nal_length_size) {
+        // the end of the buffer is reached, refill it
+        return AVERROR(EAGAIN);
+    }
+
+    for (i = 0; i < p->nal_length_size; i++)
+        nalsize = ((unsigned)nalsize << 8) | buf[(*buf_index)++];
+    if (nalsize <= 0 || nalsize > buf_size - *buf_index) {
+        av_log(logctx, AV_LOG_ERROR,
+               "AVC: nal size %d\n", nalsize);
+        return AVERROR_INVALIDDATA;
+    }
+    return nalsize;
+}
+
 /**
 * Parse NAL units of found picture and decode some basic information.
 *
@@ -266,7 +286,7 @@ static inline int parse_nal_units(AVCodecParserContext *s,
        int src_length, consumed, nalsize = 0;

        if (buf_index >= next_avc) {
-            nalsize = get_nalsize(p->nal_length_size, buf, buf_size, &buf_index, avctx);
+            nalsize = get_avc_nalsize(p, buf, buf_size, &buf_index, avctx);
            if (nalsize < 0)
                break;
            next_avc = buf_index + nalsize;
@@ -296,7 +316,7 @@ static inline int parse_nal_units(AVCodecParserContext *s,
            }
            break;
        }
-        consumed = ff_h2645_extract_rbsp(buf + buf_index, src_length, &nal, 1);
+        consumed = ff_h2645_extract_rbsp(buf + buf_index, src_length, &nal);
        if (consumed < 0)
            break;

@@ -347,26 +367,13 @@ static inline int parse_nal_units(AVCodecParserContext *s,
                       "non-existing PPS %u referenced\n", pps_id);
                goto fail;
            }
-
-            av_buffer_unref(&p->ps.pps_ref);
-            av_buffer_unref(&p->ps.sps_ref);
-            p->ps.pps = NULL;
-            p->ps.sps = NULL;
-            p->ps.pps_ref = av_buffer_ref(p->ps.pps_list[pps_id]);
-            if (!p->ps.pps_ref)
-                goto fail;
-            p->ps.pps = (const PPS*)p->ps.pps_ref->data;
-
+            p->ps.pps = (const PPS*)p->ps.pps_list[pps_id]->data;
            if (!p->ps.sps_list[p->ps.pps->sps_id]) {
                av_log(avctx, AV_LOG_ERROR,
                       "non-existing SPS %u referenced\n", p->ps.pps->sps_id);
                goto fail;
            }
-
-            p->ps.sps_ref = av_buffer_ref(p->ps.sps_list[p->ps.pps->sps_id]);
-            if (!p->ps.sps_ref)
-                goto fail;
-            p->ps.sps = (SPS*)p->ps.sps_ref->data;
+            p->ps.sps = (SPS*)p->ps.sps_list[p->ps.pps->sps_id]->data;

            sps = p->ps.sps;

--- a/libavcodec/h264_ps.c
+++ b/libavcodec/h264_ps.c
@@ -803,8 +803,8 @@ int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avct

    pps->weighted_pred                        = get_bits1(gb);
    pps->weighted_bipred_idc                  = get_bits(gb, 2);
-    pps->init_qp                              = get_se_golomb(gb) + 26U + qp_bd_offset;
-    pps->init_qs                              = get_se_golomb(gb) + 26U + qp_bd_offset;
+    pps->init_qp                              = get_se_golomb(gb) + 26 + qp_bd_offset;
+    pps->init_qs                              = get_se_golomb(gb) + 26 + qp_bd_offset;
    pps->chroma_qp_index_offset[0]            = get_se_golomb(gb);
    pps->deblocking_filter_parameters_present = get_bits1(gb);
    pps->constrained_intra_pred               = get_bits1(gb);
--- a/Show More
+++ b/Show More
@@ -1 +1 @@
 .1.9
 .0.git