Changelog: Add back next marker

Signed-off-by: Michael Niedermayer <michael@niedermayer.cc>

Changelog

@@ -1,594 +1,7 @@
 Entries are sorted chronologically from oldest to youngest within each release,
 releases are sorted from youngest to oldest.
 
-version 3.2.9:
-- avcodec/snowdec: Check mv_scale
-- avcodec/pafvideo: Check for bitstream end in decode_0()
-- avcodec/ffv1dec: Fix out of array read in slice counting
-- avcodec/dirac_dwt: Fix integer overflow in COMPOSE_53iL0()
-- avcodec/mpeg_er: Clear mcsel in mpeg_er_decode_mb()
-- avcodec/mpeg4videodec: Use 64 bit intermediates for sprite delta
-- avcodec/x86/lossless_videoencdsp: Fix handling of small widths
-- avcodec/truemotion2: Fix integer overflows in tm2_high_chroma()
-- avcodec/aacdec_template: Clear tns present flag on error
-- avcodec/proresdec2: SKIP_BITS() does not work with len=32
-- avcodec/hevcdsp_template: Fix undefined shift
-- avcodec/jpeg2000: Check that codsty->log2_prec_widths/heights has been initialized
-- avcodec/takdec: Fix integer overflow in decode_lpc()
-- avcodec/proresdec2: Check bits in DECODE_CODEWORD(), fixes invalid shift
-- avcodec/takdec: Fix integer overflows in decode_subframe()
-- avcodec/dirac_dwt: Fix integer overflow in COMPOSE_FIDELITYi*()
-- avcodec/ffv1dec: Fix integer overflow in read_quant_table()
-- avcodec/svq3: Fix overflow in svq3_add_idct_c()
-- avcodec/pngdec: Clean up on av_frame_ref() failure
-
-version 3.2.8:
-- avcodec/hevc_ps: Fix c?_qp_offset_list size
-- avcodec/shorten: Move buffer allocation and offset init to end of read_header()
-- avcodec/jpeg2000dsp: Fix multiple integer overflows in ict_int()
-- avcodec/hevcdsp_template: Fix undefined shift in put_hevc_pel_bi_w_pixels
-- avcodec/diracdec: Fix overflow in DC computation
-- avcodec/dirac_vlc: limit res_bits in APPEND_RESIDUE()
-- libavcodec/h264_parse: don't use uninitialized value when chroma_format_idc==0
-- avformat/asfdec: Fix DoS in asf_build_simple_index()
-- avformat/mov: Fix DoS in read_tfra()
-- avcodec/dirac_vlc: Fix invalid shift in ff_dirac_golomb_read_32bit()
-- avcodec/dirac_dwt: Fix multiple overflows in 9/7 lifting
-- avcodec/diracdec: Fix integer overflow in INTRA_DC_PRED()
-- avformat/mxfdec: Fix Sign error in mxf_read_primer_pack()
-- avformat/mxfdec: Fix DoS issues in mxf_read_index_entry_array()
-- avformat/nsvdec: Fix DoS due to lack of eof check in nsvs_file_offset loop.
-- avcodec/snowdec: Fix integer overflow in decode_subband_slice_buffered()
-- avcodec/hevc_ps: Fix undefined shift in pcm code
-- avcodec/sbrdsp_fixed: Fix undefined overflows in autocorrelate()
-- avformat/mvdec: Fix DoS due to lack of eof check
-- avformat/rl2: Fix DoS due to lack of eof check
-- avformat/rmdec: Fix DoS due to lack of eof check
-- avformat/cinedec: Fix DoS due to lack of eof check
-- avformat/asfdec: Fix DoS due to lack of eof check
-- avformat/hls: Fix DoS due to infinite loop
-- ffprobe: Fix NULL pointer handling in color parameter printing
-- ffprobe: Fix null pointer dereference with color primaries
-- avcodec/hevc_ps: Check delta_pocs in ff_hevc_decode_short_term_rps()
-- avformat/rtpdec_h264: Fix heap-buffer-overflow
-- avformat/aviobuf: Fix signed integer overflow in avio_seek()
-- avformat/mov: Fix signed integer overflows with total_size
-- avcodec/utils: Fix signed integer overflow in rc_initial_buffer_occupancy initialization
-- avcodec/aacdec_template: Fix running cleanup in decode_ics_info()
-- avcodec/me_cmp: Fix crashes on ARM due to misalignment
-- avcodec/dirac_dwt_template: Fix integer overflow in vertical_compose53iL0()
-- avcodec/fic: Fixes signed integer overflow
-- avcodec/snowdec: Fix off by 1 error
-- avcodec/diracdec: Fixes integer overflow
-- avcodec/diracdec: Check perspective_exp and zrs_exp.
-- avcodec/ffv1dec_template: Fix undefined shift
-- avcodec/mpeg4videodec: Clear mcsel before decoding an image
-- avcodec/dirac_dwt: Fixes integer overflows in COMPOSE_DAUB97*
-- avcodec/aacdec_fixed: fix invalid shift in predict()
-- avcodec/h264_slice: Fix overflow in slice offset
-- avformat/utils: fix memory leak in avformat_free_context
-- avcodec/diracdsp: fix integer overflow
-- avcodec/diracdec: Check weight_log2denom
-- avfilter/vf_ssim: fix temp size calculation
-
-version 3.2.7:
-- avcodec/dirac_dwt: Fix multiple integer overflows in COMPOSE_DD97iH0()
-- avcodec/diracdec: Fix integer overflow in divide3()
-- avcodec/takdec: Fix integer overflow in decode_subframe()
-- avformat/rtmppkt: Convert ff_amf_get_field_value() to bytestream2
-- avformat/rtmppkt: Convert ff_amf_tag_size() to bytestream2
-- avcodec/diracdec: Fix integer overflow in signed multiplication in UNPACK_ARITH()
-- avcodec/dnxhddec: Move mb height check out of non hr branch
-- avcodec/hevc_ps: fix integer overflow in log2_parallel_merge_level_minus2
-- avformat/oggparsecelt: Do not re-allocate os->private
-- avcodec/ylc: Fix shift overflow
-- avcodec/aacps: Fix multiple integer overflow in map_val_34_to_20()
-- avcodec/aacdec_fixed: fix: left shift of negative value -1
-- avcodec/dirac_vlc: Fix undefined shift
-- doc/filters: typo in frei0r
-- avcodec/cfhd: Fix decoding regression due to height check
-- avcodec/aacdec_template (fixed point): Check gain in decode_cce() to avoid undefined shifts later
-- avcodec/ffv1dec_template: Fix signed integer overflow
-- avcodec/aacdec_template: Fix undefined integer overflow in apply_tns()
-- avcodec/magicyuv: Check that vlc len is not too large
-- avcodec/mjpegdec: Clip DC also on the negative side.
-- avcodec/aacps (fixed point): Fix multiple signed integer overflows
-- avcodec/ylc: Fix vlc of 31 bits
-- avcodec/sbrdsp_fixed: Fix integer overflow in sbr_hf_apply_noise()
-- avcodec/wavpack: Fix invalid shift
-- avcodec/h264_slice: Fix signed integer overflow
-- avcodec/hevc_ps: Fix integer overflow with beta/tc offsets
-- avcodec/cfhd: Fix invalid left shift of negative value
-- avcodec/vb: Check vertical GMC component before multiply
-- avcodec/jpeg2000dwt: Fix integer overflow in dwt_decode97_int()
-- avcodec/apedec: Fix integer overflow
-- avcodec/wavpack: Fix integer overflow in wv_unpack_stereo()
-- avcodec/mpeg4videodec: Fix GMC with videos of dimension 1
-- avcodec/wavpack: Fix integer overflow
-- avcodec/takdec: Fix integer overflow
-- avcodec/tiff: Update pointer only when the result is used
-- 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 outpu
-
-version 3.2.6:
-- 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/dnxhd_parser: Do not return invalid value from dnxhd_find_frame_end() on error
-- 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/libvpxdec: Check that display dimensions fit in the storage dimensions
-- 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/h264_parse: Check picture structure when initializig weight table
-- 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/cfhd: Fix runtime error: signed integer overflow: 65280 * 65288 cannot be represented in 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/dds: Fix runtime error: left shift of 145 by 24 places cannot be represented in type 'int'
-- 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/diracdec: Fix off by 1 error in quant check
-- 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/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/nvenc: remove unnecessary alignment
-- avutil/hwcontext_dxva2: Don't improperly free IDirect3DSurface9 objects
-- avcodec/hevc_sei: fix amount of bits skipped when reading picture timing SEI message
-- avcodec/aac_adtstoasc: fix ASC passthrough on small frames
-
-
-version 3.2.5:
-- 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/aacdec_template: Do not decode 2nd PCE if it will lead to failure
-- 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
-- avformat/mov: Check creation_time for overflow
-- avcodec/dvdsubdec: Fixes 2 runtime error: left shift of 170 by 24 places cannot be represented in type 'int'
-- avcodec/h264: Check weight values to be within the specs limits.
-- libavformat/mov: Fix memory leak, need to free the chapter tracks array
-- avformat/oggparsedaala: Do not leave an invalid value in gpshift
-- avformat/oggparsedaala: Check duration for AV_NOPTS_VALUE
-- avformat/libopenmpt: Check for avio_size() failure
-- 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
-- avformat/test/fifo_muxer: add check for FailingMuxerPacketData alloc
-- 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()
-- 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
-- hwcontext_vdpau: Fix missing subscripts
-- lavf/flacdec: Return maximum score if the streaminfo header is valid.
-- avcodec/dnxhd_parser: take into account compressed frame size and skip it
-- 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
-- avformat/matroskaenc: don't write DisplayUnit with value Unknown on WebM files
-- 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.2.4:
-- 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()
-- Changelog: fix typos
-
-version 3.2.3:
-- 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()
-- pgssubdec: reset rle_data_len/rle_remaining_len on allocation error
-- swscale: save ebx register when it is not available
-- 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()
-- libopenmpt: add missing avio_read return value check
-- avcodec/bsf: Fix av_bsf_list_free()
-- 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
-- lavf/utils.c Protect against accessing entries[nb_entries]
-- avutil/random_seed: Reduce the time needed on systems with very low precision clock()
-- swscale/swscale: Fix dereference of stride array before null check
-- 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
-- lavf/chromaprint: Update for version 1.4
-- 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
-- ffplay: fix sws_scale possible out of bounds array access
-- avfilter/vf_hwupload_cuda: Add min/max limits for the 'device' option
-
-version 3.2.2:
-- 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/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
-- avcodec/me_cmp: Fix median_sad size
-- avformat/utils: Fix type mismatch
-- 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
-
-version 3.2.1:
-- avcodec/aac_adtstoasc_bsf: validate and forward extradata if the stream is already ASC
-- 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
-- avformat/mpeg: Adjust vid probe threshold to correct mis-detection
-- avcodec/ass_split: Change order of operations in ass_split_section()
-- avcodec/rawdec: check for side data before checking its size
-- avcodec/avpacket: fix leak on realloc in av_packet_add_side_data()
-- avformat/apngenc: use the stream parameters extradata if available
-- Revert "apngdec: use side data to pass extradata to the decoder"
-- ffprobe: fix crash in case -of is specified with an empty string
-- libavcodec/exr : fix channel size calculation for uint32 channel
-- exr: fix out-of-bounds read
-- libschroedingerdec: fix leaking of framewithpts
-- libschroedingerdec: don't produce empty frames
-- dds: limit 4 bpp handling to AV_PIX_FMT_PAL8
-- mlz: limit next_code to data buffer size
-- 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
-- icodec: fix leaking pkt on error
-- dvbsubdec: fix division by zero in compute_default_clut
-- proresdec_lgpl: explicitly check coff[3] against slice_data_size
-- escape124: reject codebook size 0
-- 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
-- diracdec: clear slice_params_num_buf on allocation failure
-- diracdec: use correct buffer for slice_params_buf realloc
-- ppc: pixblockdsp: do unaligned block accesses correctly again
-- avformat: close parser if codec changed
-- fate: add streamcopy test for apng
-- apngdec: use side data to pass extradata to the decoder
-- mov: immediately return from mov_fix_index without old index entries
-- interplayacm: increase bitstream buffer size by AV_INPUT_BUFFER_PADDING_SIZE
-- interplayacm: validate number of channels
-- interplayacm: check for too large b
-- doc: fix spelling errors
-- configure: make sure LTO does not optimize out the test functions
-- fate: add apng encoding/muxing test
-- apng: use side data to pass extradata to muxer
-- avcodec/mpeg4videodec: Workaround interlaced mpeg4 edge MC bug
-- avcodec/mpegvideo: Fix edge emu buffer overlap with interlaced mpeg4
-- 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
-- ffmpeg: Fix bsf corrupting merged side data
-- avcodec/sunrast: Fix input buffer pointer check
-- avcodec/tscc:  Check side data size before use
-- avcodec/rscc: Fix constant
-- avcodec/rawdec: Check side data size before use
-- avcodec/rscc: 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
-- avformat/hls: Add missing error check for avcodec_parameters_copy()
-- avformat/hls: Fix probing mpegts audio streams that use probing
-- avformat/hls: Factor copying stream info to a separate function
+version <next>:
 
 version 3.2:
 - libopenmpt demuxer

RELEASE

@@ -1 +1 @@
-3.2.9
+3.0.git

RELEASE_NOTES

@@ -1,15 +0,0 @@
-
-              ┌────────────────────────────────────────┐
-              │ RELEASE NOTES for FFmpeg 3.2 "Hypatia" │
-              └────────────────────────────────────────┘
-
-   The FFmpeg Project proudly presents FFmpeg 3.2 "Hypatia", about 4
-   months after the release of FFmpeg 3.1.
-
-   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.

configure

@@ -1146,16 +1146,10 @@ check_func_headers(){
         for hdr in $headers; do
             print_include $hdr
         done
-        echo "#include <stdint.h>"
         for func in $funcs; do
             echo "long check_$func(void) { return (long) $func; }"
         done
-        echo "int main(void) { int ret = 0;"
-        # LTO could optimize out the test functions without this
-        for func in $funcs; do
-            echo " ret |= ((intptr_t)check_$func) & 0xFFFF;"
-        done
-        echo "return ret; }"
+        echo "int main(void) { return 0; }"
     } | check_ld "cc" "$@" && enable $funcs && enable_safe $headers
 }
 
@@ -1651,6 +1645,7 @@ CONFIG_LIST="
     $PROGRAM_LIST
     $SUBSYSTEM_LIST
     fontconfig
+    incompatible_libav_abi
     memalign_hack
     memory_poisoning
     neon_clobber_test
@@ -1803,6 +1798,7 @@ HAVE_LIST_CMDLINE="
 HAVE_LIST_PUB="
     bigendian
     fast_unaligned
+    incompatible_libav_abi
 "
 
 HEADERS_LIST="
@@ -6271,7 +6267,6 @@ __declspec($_restrict) void* foo(int);
 EOF
     fi
     check_func strtoll || add_cflags -Dstrtoll=_strtoi64
-    check_func strtoull || add_cflags -Dstrtoull=_strtoui64
     # the new SSA optimzer in VS2015 U3 is mis-optimizing some parts of the code
     # this flag should be re-checked on newer compiler releases and put under a
     # version check once its fixed
@@ -6703,7 +6698,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})"

doc/Doxyfile

@@ -38,7 +38,7 @@ PROJECT_NAME           = FFmpeg
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 3.2.9
+PROJECT_NUMBER         =
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

doc/demuxers.texi

@@ -293,24 +293,6 @@ used to end the output video at the length of the shortest input file,
 which in this case is @file{input.mp4} as the GIF in this example loops
 infinitely.
 
-@section hls
-
-HLS demuxer
-
-It accepts the following options:
-
-@table @option
-@item live_start_index
-segment index to start live streams at (negative values are from the end).
-
-@item allowed_extensions
-',' separated list of file extensions that hls is allowed to access.
-
-@item max_reload
-Maximum number of times a insufficient list is attempted to be reloaded.
-Default value is 1000.
-@end table
-
 @section image2
 
 Image file demuxer.

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

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,
@@ -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})

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

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

doc/filters.texi

@@ -8217,7 +8217,7 @@ It accepts the following parameters:
 @item filter_name
 The name of the frei0r effect to load. If the environment variable
 @env{FREI0R_PATH} is defined, the frei0r effect is searched for in each of the
-directories specified by the colon-separated list in @env{FREI0R_PATH}.
+directories specified by the colon-separated list in @env{FREIOR_PATH}.
 Otherwise, the standard frei0r paths are searched, in this order:
 @file{HOME/.frei0r-1/lib/}, @file{/usr/local/lib/frei0r-1/},
 @file{/usr/lib/frei0r-1/}.
@@ -9665,7 +9665,7 @@ Scene change detection method. Scene change leads motion vectors to be in random
 @item none
 Disable scene change detection.
 @item fdiff
-Frame difference. Corresponding pixel values are compared and if it satisfies @var{scd_threshold} scene change is detected.
+Frame difference. Corresponding pixel values are compared and if it statisfies @var{scd_threshold} scene change is detected.
 @end table
 Default method is @samp{fdiff}.
 
@@ -11915,7 +11915,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

doc/formats.texi

@@ -63,7 +63,7 @@ This ensures that file and data checksums are reproducible and match between
 platforms. Its primary use is for regression testing.
 @item shortest
 Stop muxing at the end of the shortest stream.
-It may be needed to increase max_interleave_delta to avoid flushing the longer
+It may be needed to increase max_interleave_delta to avoid flusing the longer
 streams before EOF.
 @end table
 
@@ -209,10 +209,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

ffmpeg.c

@@ -789,7 +789,6 @@ static void output_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost)
     if (ost->nb_bitstream_filters) {
         int idx;
 
-        av_packet_split_side_data(pkt);
         ret = av_bsf_send_packet(ost->bsf_ctx[0], pkt);
         if (ret < 0)
             goto finish;

ffmpeg_opt.c

@@ -3108,8 +3108,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,

ffplay.c

@@ -874,11 +874,11 @@ static int upload_texture(SDL_Texture *tex, AVFrame *frame, struct SwsContext **
                 frame->width, frame->height, frame->format, frame->width, frame->height,
                 AV_PIX_FMT_BGRA, sws_flags, NULL, NULL, NULL);
             if (*img_convert_ctx != NULL) {
-                uint8_t *pixels[4];
-                int pitch[4];
-                if (!SDL_LockTexture(tex, NULL, (void **)pixels, pitch)) {
+                uint8_t *pixels;
+                int pitch;
+                if (!SDL_LockTexture(tex, NULL, (void **)&pixels, &pitch)) {
                     sws_scale(*img_convert_ctx, (const uint8_t * const *)frame->data, frame->linesize,
-                              0, frame->height, pixels, pitch);
+                              0, frame->height, &pixels, &pitch);
                     SDL_UnlockTexture(tex);
                 }
             } else {
@@ -904,8 +904,8 @@ static void video_image_display(VideoState *is)
 
                 if (vp->pts >= sp->pts + ((float) sp->sub.start_display_time / 1000)) {
                     if (!sp->uploaded) {
-                        uint8_t* pixels[4];
-                        int pitch[4];
+                        uint8_t *pixels;
+                        int pitch;
                         int i;
                         if (!sp->width || !sp->height) {
                             sp->width = vp->width;
@@ -930,9 +930,9 @@ static void video_image_display(VideoState *is)
                                 av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
                                 return;
                             }
-                            if (!SDL_LockTexture(is->sub_texture, (SDL_Rect *)sub_rect, (void **)pixels, pitch)) {
+                            if (!SDL_LockTexture(is->sub_texture, (SDL_Rect *)sub_rect, (void **)&pixels, &pitch)) {
                                 sws_scale(is->sub_convert_ctx, (const uint8_t * const *)sub_rect->data, sub_rect->linesize,
-                                          0, sub_rect->h, pixels, pitch);
+                                          0, sub_rect->h, &pixels, &pitch);
                                 SDL_UnlockTexture(is->sub_texture);
                             }
                         }

ffprobe.c

@@ -1789,56 +1789,6 @@ static void print_pkt_side_data(WriterContext *w,
     writer_print_section_footer(w);
 }
 
-static void print_color_range(WriterContext *w, enum AVColorRange color_range, const char *fallback)
-{
-    const char *val = av_color_range_name(color_range);
-    if (!val || color_range == AVCOL_RANGE_UNSPECIFIED) {
-        print_str_opt("color_range", fallback);
-    } else {
-        print_str("color_range", val);
-    }
-}
-
-static void print_color_space(WriterContext *w, enum AVColorSpace color_space)
-{
-    const char *val = av_color_space_name(color_space);
-    if (!val || color_space == AVCOL_SPC_UNSPECIFIED) {
-        print_str_opt("color_space", "unknown");
-    } else {
-        print_str("color_space", val);
-    }
-}
-
-static void print_primaries(WriterContext *w, enum AVColorPrimaries color_primaries)
-{
-    const char *val = av_color_primaries_name(color_primaries);
-    if (!val || color_primaries == AVCOL_PRI_UNSPECIFIED) {
-        print_str_opt("color_primaries", "unknown");
-    } else {
-        print_str("color_primaries", val);
-    }
-}
-
-static void print_color_trc(WriterContext *w, enum AVColorTransferCharacteristic color_trc)
-{
-    const char *val = av_color_transfer_name(color_trc);
-    if (!val || color_trc == AVCOL_TRC_UNSPECIFIED) {
-        print_str_opt("color_transfer", "unknown");
-    } else {
-        print_str("color_transfer", val);
-    }
-}
-
-static void print_chroma_location(WriterContext *w, enum AVChromaLocation chroma_location)
-{
-    const char *val = av_chroma_location_name(chroma_location);
-    if (!val || chroma_location == AVCHROMA_LOC_UNSPECIFIED) {
-        print_str_opt("chroma_location", "unspecified");
-    } else {
-        print_str("chroma_location", val);
-    }
-}
-
 static void show_packet(WriterContext *w, InputFile *ifile, AVPacket *pkt, int packet_idx)
 {
     char val_str[128];
@@ -2294,12 +2244,29 @@ static int show_stream(WriterContext *w, AVFormatContext *fmt_ctx, int stream_id
         if (s) print_str    ("pix_fmt", s);
         else   print_str_opt("pix_fmt", "unknown");
         print_int("level",   par->level);
+        if (par->color_range != AVCOL_RANGE_UNSPECIFIED)
+            print_str    ("color_range", av_color_range_name(par->color_range));
+        else
+            print_str_opt("color_range", "N/A");
 
-        print_color_range(w, par->color_range, "N/A");
-        print_color_space(w, par->color_space);
-        print_color_trc(w, par->color_trc);
-        print_primaries(w, par->color_primaries);
-        print_chroma_location(w, par->chroma_location);
+        s = av_get_colorspace_name(par->color_space);
+        if (s) print_str    ("color_space", s);
+        else   print_str_opt("color_space", "unknown");
+
+        if (par->color_trc != AVCOL_TRC_UNSPECIFIED)
+            print_str("color_transfer", av_color_transfer_name(par->color_trc));
+        else
+            print_str_opt("color_transfer", av_color_transfer_name(par->color_trc));
+
+        if (par->color_primaries != AVCOL_PRI_UNSPECIFIED)
+            print_str("color_primaries", av_color_primaries_name(par->color_primaries));
+        else
+            print_str_opt("color_primaries", av_color_primaries_name(par->color_primaries));
+
+        if (par->chroma_location != AVCHROMA_LOC_UNSPECIFIED)
+            print_str("chroma_location", av_chroma_location_name(par->chroma_location));
+        else
+            print_str_opt("chroma_location", av_chroma_location_name(par->chroma_location));
 
         if (par->field_order == AV_FIELD_PROGRESSIVE)
             print_str("field_order", "progressive");
@@ -3344,12 +3311,6 @@ int main(int argc, char **argv)
         goto end;
     }
     w_name = av_strtok(print_format, "=", &buf);
-    if (!w_name) {
-        av_log(NULL, AV_LOG_ERROR,
-               "No name specified for the output format\n");
-        ret = AVERROR(EINVAL);
-        goto end;
-    }
     w_args = buf;
 
     if (show_data_hash) {

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;

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;
 }
 

libavcodec/4xm.c

@@ -532,7 +532,7 @@ static int decode_i_block(FourXContext *f, int16_t *block)
             }
             i    += code >> 4;
             if (i >= 64) {
-                av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
+                av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
                 return 0;
             }
 

libavcodec/8bps.c

@@ -122,15 +122,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);

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;
@@ -136,16 +136,8 @@ fail:
 
 static int aac_adtstoasc_init(AVBSFContext *ctx)
 {
-    /* Validate the extradata if the stream is already MPEG-4 AudioSpecificConfig */
-    if (ctx->par_in->extradata) {
-        MPEG4AudioConfig mp4ac;
-        int ret = avpriv_mpeg4audio_get_config(&mp4ac, ctx->par_in->extradata,
-                                               ctx->par_in->extradata_size * 8, 1);
-        if (ret < 0) {
-            av_log(ctx, AV_LOG_ERROR, "Error parsing AudioSpecificConfig extradata!\n");
-            return ret;
-        }
-    }
+    av_freep(&ctx->par_out->extradata);
+    ctx->par_out->extradata_size = 0;
 
     return 0;
 }

libavcodec/aac_defines.h

@@ -35,7 +35,6 @@
 #define AAC_RENAME(x)       x ## _fixed
 #define AAC_RENAME_32(x)    x ## _fixed_32
 typedef int                 INTFLOAT;
-typedef unsigned            UINTFLOAT;  ///< Equivalent to INTFLOAT, Used as temporal cast to avoid undefined sign overflow operations.
 typedef int64_t             INT64FLOAT;
 typedef int16_t             SHORTFLOAT;
 typedef SoftFloat           AAC_FLOAT;
@@ -46,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)
@@ -73,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
@@ -84,7 +83,6 @@ typedef int                 AAC_SIGNE;
 #define AAC_RENAME(x)       x
 #define AAC_RENAME_32(x)    x
 typedef float               INTFLOAT;
-typedef float               UINTFLOAT;
 typedef float               INT64FLOAT;
 typedef float               SHORTFLOAT;
 typedef float               AAC_FLOAT;

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)) {

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;
@@ -305,12 +296,8 @@ static av_always_inline void predict(PredictorState *ps, int *coef,
     if (output_enable) {
         int shift = 28 - pv.exp;
 
-        if (shift < 31) {
-            if (shift > 0) {
-                *coef += (pv.mant + (1 << (shift - 1))) >> shift;
-            } else
-                *coef += pv.mant << -shift;
-        }
+        if (shift < 31)
+            *coef += (pv.mant + (1 << (shift - 1))) >> shift;
     }
 
     e0 = av_int2sf(*coef, 2);
@@ -375,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);
 
@@ -394,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;
                         }
                     }
                 }
@@ -434,7 +419,7 @@ static void apply_independent_coupling_fixed(AACContext *ac,
     else {
       for (i = 0; i < len; i++) {
           tmp = (int)(((int64_t)src[i] * c + (int64_t)0x1000000000) >> 37);
-          dest[i] += tmp * (1 << shift);
+          dest[i] += tmp << shift;
       }
     }
 }

libavcodec/aacdec_template.c

@@ -406,15 +406,11 @@ static uint64_t sniff_channel_order(uint8_t (*layout_map)[3], int tags)
 /**
  * Save current output configuration if and only if it has been locked.
  */
-static int push_output_configuration(AACContext *ac) {
-    int pushed = 0;
-
+static void push_output_configuration(AACContext *ac) {
     if (ac->oc[1].status == OC_LOCKED || ac->oc[0].status == OC_NONE) {
         ac->oc[0] = ac->oc[1];
-        pushed = 1;
     }
     ac->oc[1].status = OC_NONE;
-    return pushed;
 }
 
 /**
@@ -1259,8 +1255,6 @@ static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics,
     const MPEG4AudioConfig *const m4ac = &ac->oc[1].m4ac;
     const int aot = m4ac->object_type;
     const int sampling_index = m4ac->sampling_index;
-    int ret_fail = AVERROR_INVALIDDATA;
-
     if (aot != AOT_ER_AAC_ELD) {
         if (get_bits1(gb)) {
             av_log(ac->avctx, AV_LOG_ERROR, "Reserved bit set.\n");
@@ -1311,10 +1305,8 @@ static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics,
                 ics->num_swb       =    ff_aac_num_swb_512[sampling_index];
                 ics->tns_max_bands =  ff_tns_max_bands_512[sampling_index];
             }
-            if (!ics->num_swb || !ics->swb_offset) {
-                ret_fail = AVERROR_BUG;
-                goto fail;
-            }
+            if (!ics->num_swb || !ics->swb_offset)
+                return AVERROR_BUG;
         } else {
             ics->swb_offset    =    ff_swb_offset_1024[sampling_index];
             ics->num_swb       =   ff_aac_num_swb_1024[sampling_index];
@@ -1338,8 +1330,7 @@ static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics,
                 if (aot == AOT_ER_AAC_LD) {
                     av_log(ac->avctx, AV_LOG_ERROR,
                            "LTP in ER AAC LD not yet implemented.\n");
-                    ret_fail = AVERROR_PATCHWELCOME;
-                    goto fail;
+                    return AVERROR_PATCHWELCOME;
                 }
                 if ((ics->ltp.present = get_bits(gb, 1)))
                     decode_ltp(&ics->ltp, gb, ics->max_sfb);
@@ -1358,7 +1349,7 @@ static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics,
     return 0;
 fail:
     ics->max_sfb = 0;
-    return ret_fail;
+    return AVERROR_INVALIDDATA;
 }
 
 /**
@@ -1945,17 +1936,16 @@ static int decode_ics(AACContext *ac, SingleChannelElement *sce,
     global_gain = get_bits(gb, 8);
 
     if (!common_window && !scale_flag) {
-        ret = decode_ics_info(ac, ics, gb);
-        if (ret < 0)
-            goto fail;
+        if (decode_ics_info(ac, ics, gb) < 0)
+            return AVERROR_INVALIDDATA;
     }
 
     if ((ret = decode_band_types(ac, sce->band_type,
                                  sce->band_type_run_end, gb, ics)) < 0)
-        goto fail;
+        return ret;
     if ((ret = decode_scalefactors(ac, sce->sf, gb, global_gain, ics,
                                   sce->band_type, sce->band_type_run_end)) < 0)
-        goto fail;
+        return ret;
 
     pulse_present = 0;
     if (!scale_flag) {
@@ -1963,48 +1953,37 @@ static int decode_ics(AACContext *ac, SingleChannelElement *sce,
             if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
                 av_log(ac->avctx, AV_LOG_ERROR,
                        "Pulse tool not allowed in eight short sequence.\n");
-                ret = AVERROR_INVALIDDATA;
-                goto fail;
+                return AVERROR_INVALIDDATA;
             }
             if (decode_pulses(&pulse, gb, ics->swb_offset, ics->num_swb)) {
                 av_log(ac->avctx, AV_LOG_ERROR,
                        "Pulse data corrupt or invalid.\n");
-                ret = AVERROR_INVALIDDATA;
-                goto fail;
+                return AVERROR_INVALIDDATA;
             }
         }
         tns->present = get_bits1(gb);
-        if (tns->present && !er_syntax) {
-            ret = decode_tns(ac, tns, gb, ics);
-            if (ret < 0)
-                goto fail;
-        }
+        if (tns->present && !er_syntax)
+            if (decode_tns(ac, tns, gb, ics) < 0)
+                return AVERROR_INVALIDDATA;
         if (!eld_syntax && get_bits1(gb)) {
             avpriv_request_sample(ac->avctx, "SSR");
-            ret = AVERROR_PATCHWELCOME;
-            goto fail;
+            return AVERROR_PATCHWELCOME;
         }
         // I see no textual basis in the spec for this occurring after SSR gain
         // control, but this is what both reference and real implmentations do
-        if (tns->present && er_syntax) {
-            ret = decode_tns(ac, tns, gb, ics);
-            if (ret < 0)
-                goto fail;
-        }
+        if (tns->present && er_syntax)
+            if (decode_tns(ac, tns, gb, ics) < 0)
+                return AVERROR_INVALIDDATA;
     }
 
-    ret = decode_spectrum_and_dequant(ac, out, gb, sce->sf, pulse_present,
-                                    &pulse, ics, sce->band_type);
-    if (ret < 0)
-        goto fail;
+    if (decode_spectrum_and_dequant(ac, out, gb, sce->sf, pulse_present,
+                                    &pulse, ics, sce->band_type) < 0)
+        return AVERROR_INVALIDDATA;
 
     if (ac->oc[1].m4ac.object_type == AOT_AAC_MAIN && !common_window)
         apply_prediction(ac, sce);
 
     return 0;
-fail:
-    tns->present = 0;
-    return ret;
 }
 
 /**
@@ -2176,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;
@@ -2194,10 +2169,6 @@ static int decode_cce(AACContext *ac, GetBitContext *gb, ChannelElement *che)
             cge = coup->coupling_point == AFTER_IMDCT ? 1 : get_bits1(gb);
             gain = cge ? get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60: 0;
             gain_cache = GET_GAIN(scale, gain);
-#if USE_FIXED
-            if ((abs(gain_cache)-1024) >> 3 > 30)
-                return AVERROR(ERANGE);
-#endif
         }
         if (coup->coupling_point == AFTER_IMDCT) {
             coup->gain[c][0] = gain_cache;
@@ -2215,10 +2186,6 @@ static int decode_cce(AACContext *ac, GetBitContext *gb, ChannelElement *che)
                                     t >>= 1;
                                 }
                                 gain_cache = GET_GAIN(scale, t) * s;
-#if USE_FIXED
-                                if ((abs(gain_cache)-1024) >> 3 > 30)
-                                    return AVERROR(ERANGE);
-#endif
                             }
                         }
                         coup->gain[c][idx] = gain_cache;
@@ -2392,7 +2359,7 @@ static int decode_extension_payload(AACContext *ac, GetBitContext *gb, int cnt,
  * @param   decode  1 if tool is used normally, 0 if tool is used in LTP.
  * @param   coef    spectral coefficients
  */
-static void apply_tns(INTFLOAT coef_param[1024], TemporalNoiseShaping *tns,
+static void apply_tns(INTFLOAT coef[1024], TemporalNoiseShaping *tns,
                       IndividualChannelStream *ics, int decode)
 {
     const int mmm = FFMIN(ics->tns_max_bands, ics->max_sfb);
@@ -2400,7 +2367,6 @@ static void apply_tns(INTFLOAT coef_param[1024], TemporalNoiseShaping *tns,
     int bottom, top, order, start, end, size, inc;
     INTFLOAT lpc[TNS_MAX_ORDER];
     INTFLOAT tmp[TNS_MAX_ORDER+1];
-    UINTFLOAT *coef = coef_param;
 
     for (w = 0; w < ics->num_windows; w++) {
         bottom = ics->num_swb;
@@ -2430,7 +2396,7 @@ static void apply_tns(INTFLOAT coef_param[1024], TemporalNoiseShaping *tns,
                 // ar filter
                 for (m = 0; m < size; m++, start += inc)
                     for (i = 1; i <= FFMIN(m, order); i++)
-                        coef[start] -= AAC_MUL26((INTFLOAT)coef[start - i * inc], lpc[i - 1]);
+                        coef[start] -= AAC_MUL26(coef[start - i * inc], lpc[i - 1]);
             } else {
                 // ma filter
                 for (m = 0; m < size; m++, start += inc) {
@@ -3036,13 +3002,7 @@ static int aac_decode_frame_int(AVCodecContext *avctx, void *data,
         case TYPE_PCE: {
             uint8_t layout_map[MAX_ELEM_ID*4][3];
             int tags;
-
-            int pushed = push_output_configuration(ac);
-            if (pce_found && !pushed) {
-                err = AVERROR_INVALIDDATA;
-                goto fail;
-            }
-
+            push_output_configuration(ac);
             tags = decode_pce(avctx, &ac->oc[1].m4ac, layout_map, gb);
             if (tags < 0) {
                 err = tags;

libavcodec/aacps.c

@@ -499,13 +499,13 @@ static void map_idx_34_to_20(int8_t *par_mapped, const int8_t *par, int full)
 static void map_val_34_to_20(INTFLOAT par[PS_MAX_NR_IIDICC])
 {
 #if USE_FIXED
-    par[ 0] = (int)(((int64_t)(par[ 0] + (unsigned)(par[ 1]>>1)) * 1431655765 + \
+    par[ 0] = (int)(((int64_t)(par[ 0] + (par[ 1]>>1)) * 1431655765 + \
                       0x40000000) >> 31);
-    par[ 1] = (int)(((int64_t)((par[ 1]>>1) + (unsigned)par[ 2]) * 1431655765 + \
+    par[ 1] = (int)(((int64_t)((par[ 1]>>1) + par[ 2]) * 1431655765 + \
                       0x40000000) >> 31);
-    par[ 2] = (int)(((int64_t)(par[ 3] + (unsigned)(par[ 4]>>1)) * 1431655765 + \
+    par[ 2] = (int)(((int64_t)(par[ 3] + (par[ 4]>>1)) * 1431655765 + \
                       0x40000000) >> 31);
-    par[ 3] = (int)(((int64_t)((par[ 4]>>1) + (unsigned)par[ 5]) * 1431655765 + \
+    par[ 3] = (int)(((int64_t)((par[ 4]>>1) + par[ 5]) * 1431655765 + \
                       0x40000000) >> 31);
 #else
     par[ 0] = (2*par[ 0] +   par[ 1]) * 0.33333333f;
@@ -692,17 +692,26 @@ static void decorrelation(PSContext *ps, INTFLOAT (*out)[32][2], const INTFLOAT
     for (i = 0; i < NR_PAR_BANDS[is34]; i++) {
         for (n = n0; n < nL; n++) {
             int decayed_peak;
+            int denom;
+
             decayed_peak = (int)(((int64_t)peak_decay_factor * \
                                            peak_decay_nrg[i] + 0x40000000) >> 31);
             peak_decay_nrg[i] = FFMAX(decayed_peak, power[i][n]);
-            power_smooth[i] += (power[i][n] + 2LL - power_smooth[i]) >> 2;
-            peak_decay_diff_smooth[i] += (peak_decay_nrg[i] + 2LL - power[i][n] - \
-                                          peak_decay_diff_smooth[i]) >> 2;
-
-            if (peak_decay_diff_smooth[i]) {
-                transient_gain[i][n] = FFMIN(power_smooth[i]*43691LL / peak_decay_diff_smooth[i], 1<<16);
-            } else
-                transient_gain[i][n] = 1 << 16;
+            power_smooth[i] += (power[i][n] - power_smooth[i] + 2) >> 2;
+            peak_decay_diff_smooth[i] += (peak_decay_nrg[i] - power[i][n] - \
+                                          peak_decay_diff_smooth[i] + 2) >> 2;
+            denom = peak_decay_diff_smooth[i] + (peak_decay_diff_smooth[i] >> 1);
+            if (denom > power_smooth[i]) {
+              int p = power_smooth[i];
+              while (denom < 0x40000000) {
+                denom <<= 1;
+                p <<= 1;
+              }
+              transient_gain[i][n] = p / (denom >> 16);
+            }
+            else {
+              transient_gain[i][n] = 1 << 16;
+            }
         }
     }
 #else
@@ -933,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];
@@ -966,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);
         }
     }

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;

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) {

libavcodec/ac3dec.c

@@ -747,31 +747,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.
@@ -898,8 +897,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) {
@@ -1033,8 +1031,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++) {
@@ -1334,7 +1331,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];

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)

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) {

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],

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;

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;
     }
 }

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;
@@ -94,11 +98,6 @@ static av_cold int decode_init(AVCodecContext *avctx)
         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;
 }
 

libavcodec/apedec.c

@@ -1412,7 +1412,6 @@ static int ape_decode_frame(AVCodecContext *avctx, void *data,
     int32_t *sample24;
     int i, ch, ret;
     int blockstodecode;
-    uint64_t decoded_buffer_size;
 
     /* this should never be negative, but bad things will happen if it is, so
        check it just to make sure. */
@@ -1468,7 +1467,7 @@ static int ape_decode_frame(AVCodecContext *avctx, void *data,
                 skip_bits_long(&s->gb, offset);
         }
 
-        if (!nblocks || nblocks > INT_MAX / 2 / sizeof(*s->decoded_buffer) - 8) {
+        if (!nblocks || nblocks > INT_MAX) {
             av_log(avctx, AV_LOG_ERROR, "Invalid sample count: %"PRIu32".\n",
                    nblocks);
             return AVERROR_INVALIDDATA;
@@ -1494,9 +1493,8 @@ static int ape_decode_frame(AVCodecContext *avctx, void *data,
         blockstodecode = s->samples;
 
     /* reallocate decoded sample buffer if needed */
-    decoded_buffer_size = 2LL * FFALIGN(blockstodecode, 8) * sizeof(*s->decoded_buffer);
-    av_assert0(decoded_buffer_size <= INT_MAX);
-    av_fast_malloc(&s->decoded_buffer, &s->decoded_size, decoded_buffer_size);
+    av_fast_malloc(&s->decoded_buffer, &s->decoded_size,
+                   2 * FFALIGN(blockstodecode, 8) * sizeof(*s->decoded_buffer));
     if (!s->decoded_buffer)
         return AVERROR(ENOMEM);
     memset(s->decoded_buffer, 0, s->decoded_size);

libavcodec/ass_split.c

@@ -275,7 +275,7 @@ static const char *ass_split_section(ASSSplitContext *ctx, const char *buf)
         }
         if (section->format_header && !order) {
             len = strlen(section->format_header);
-            if (!strncmp(buf, section->format_header, len) && buf[len] == ':') {
+            if (buf[len] == ':' && !strncmp(buf, section->format_header, len)) {
                 buf += len + 1;
                 while (!is_eol(*buf)) {
                     buf = skip_space(buf);

libavcodec/avcodec.h

@@ -1536,17 +1536,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
@@ -2888,7 +2878,6 @@ typedef struct AVCodecContext {
 #define FF_BUG_DC_CLIP          4096
 #define FF_BUG_MS               8192 ///< Work around various bugs in Microsoft's broken decoders.
 #define FF_BUG_TRUNCATED       16384
-#define FF_BUG_IEDGE           32768
 
     /**
      * strictly follow the standard (MPEG-4, ...).
@@ -5577,8 +5566,15 @@ enum AVPixelFormat avcodec_find_best_pix_fmt_of_2(enum AVPixelFormat dst_pix_fmt
                                             enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
 
 attribute_deprecated
+#if AV_HAVE_INCOMPATIBLE_LIBAV_ABI
+enum AVPixelFormat avcodec_find_best_pix_fmt2(const enum AVPixelFormat *pix_fmt_list,
+                                              enum AVPixelFormat src_pix_fmt,
+                                              int has_alpha, int *loss_ptr);
+#else
 enum AVPixelFormat avcodec_find_best_pix_fmt2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2,
                                             enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
+#endif
+
 
 enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat * fmt);
 

libavcodec/avpacket.c

@@ -295,17 +295,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 +347,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 +430,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);

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;
                 }

libavcodec/bsf.c

@@ -403,7 +403,7 @@ void av_bsf_list_free(AVBSFList **lst)
 {
     int i;
 
-    if (!*lst)
+    if (*lst)
         return;
 
     for (i = 0; i < (*lst)->nb_bsfs; ++i)

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);
 }

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;

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;

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) {
                 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].a_height) {
+            if (data < 3 || 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) {
                 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) {
                 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) {
                 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) {
                 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)
@@ -506,7 +501,7 @@ static int cfhd_decode(AVCodecContext *avctx, void *data, int *got_frame,
             int highpass_a_width = s->plane[s->channel_num].band[s->level][s->subband_num].a_width;
             int highpass_a_height = s->plane[s->channel_num].band[s->level][s->subband_num].a_height;
             int highpass_stride = s->plane[s->channel_num].band[s->level][s->subband_num].stride;
-            int expected;
+            int expected = highpass_height * highpass_stride;
             int a_expected = highpass_a_height * highpass_a_width;
             int level, run, coeff;
             int count = 0, bytes;
@@ -517,12 +512,11 @@ static int cfhd_decode(AVCodecContext *avctx, void *data, int *got_frame,
                 goto end;
             }
 
-            if (highpass_height > highpass_a_height || highpass_width > highpass_a_width || a_expected < highpass_height * (uint64_t)highpass_stride) {
+            if (highpass_height > highpass_a_height || highpass_width > highpass_a_width || a_expected < expected) {
                 av_log(avctx, AV_LOG_ERROR, "Too many highpass coefficients\n");
                 ret = AVERROR(EINVAL);
                 goto end;
             }
-            expected = highpass_height * highpass_stride;
 
             av_log(avctx, AV_LOG_DEBUG, "Start subband coeffs plane %i level %i codebook %i expected %i\n", s->channel_num, s->level, s->codebook, expected);
 
@@ -663,7 +657,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;
             }
@@ -716,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;
         }

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);
         }
     }
 

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;

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;
             }

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)

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,
@@ -680,7 +680,7 @@ static int dds_decode(AVCodecContext *avctx, void *data,
         /* Use the decompress function on the texture, one block per thread. */
         ctx->tex_data = gbc->buffer;
         avctx->execute2(avctx, decompress_texture_thread, frame, NULL, ctx->slice_count);
-    } else if (!ctx->paletted && ctx->bpp == 4 && avctx->pix_fmt == AV_PIX_FMT_PAL8) {
+    } else if (!ctx->paletted && ctx->bpp == 4) {
         uint8_t *dst = frame->data[0];
         int x, y, i;
 
@@ -691,7 +691,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;
@@ -722,7 +722,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;

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;

libavcodec/dirac_dwt.h

@@ -93,13 +93,13 @@ void ff_spatial_idwt_slice2(DWTContext *d, int y);
 
 // shared stuff for simd optimizations
 #define COMPOSE_53iL0(b0, b1, b2)\
-    (b1 - ((int)(b0 + (unsigned)(b2) + 2) >> 2))
+    (b1 - ((b0 + b2 + 2) >> 2))
 
 #define COMPOSE_DIRAC53iH0(b0, b1, b2)\
-    (b1 + ((int)(b0 + (unsigned)(b2) + 1) >> 1))
+    (b1 + ((b0 + b2 + 1) >> 1))
 
 #define COMPOSE_DD97iH0(b0, b1, b2, b3, b4)\
-    (b2 + ((int)(-b0 + 9U*b1 + 9U*b3 - b4 + 8) >> 4))
+    (b2 + ((-b0 + 9*b1 + 9*b3 - b4 + 8) >> 4))
 
 #define COMPOSE_DD137iL0(b0, b1, b2, b3, b4)\
     (b2 - ((-b0 + 9*b1 + 9*b3 - b4 + 16) >> 5))
@@ -111,22 +111,22 @@ void ff_spatial_idwt_slice2(DWTContext *d, int y);
     (b0 + b1)
 
 #define COMPOSE_FIDELITYiL0(b0, b1, b2, b3, b4, b5, b6, b7, b8)\
-    (b4 - ((int)(-8*(b0+(unsigned)b8) + 21*(b1+(unsigned)b7) - 46*(b2+(unsigned)b6) + 161*(b3+(unsigned)b5) + 128) >> 8))
+    (b4 - ((-8*(b0+b8) + 21*(b1+b7) - 46*(b2+b6) + 161*(b3+b5) + 128) >> 8))
 
 #define COMPOSE_FIDELITYiH0(b0, b1, b2, b3, b4, b5, b6, b7, b8)\
-    (b4 + ((int)(-2*(b0+(unsigned)b8) + 10*(b1+(unsigned)b7) - 25*(b2+(unsigned)b6) +  81*(b3+(unsigned)b5) + 128) >> 8))
+    (b4 + ((-2*(b0+b8) + 10*(b1+b7) - 25*(b2+b6) + 81*(b3+b5) + 128) >> 8))
 
 #define COMPOSE_DAUB97iL1(b0, b1, b2)\
-    (b1 - ((int)(1817*(b0 + (unsigned)b2) + 2048) >> 12))
+    (b1 - ((1817*(b0 + b2) + 2048) >> 12))
 
 #define COMPOSE_DAUB97iH1(b0, b1, b2)\
-    (b1 - ((int)( 113*(b0 + (unsigned)b2) + 64) >> 7))
+    (b1 - (( 113*(b0 + b2) + 64) >> 7))
 
 #define COMPOSE_DAUB97iL0(b0, b1, b2)\
-    (b1 + ((int)( 217*(b0 + (unsigned)b2) + 2048) >> 12))
+    (b1 + (( 217*(b0 + b2) + 2048) >> 12))
 
 #define COMPOSE_DAUB97iH0(b0, b1, b2)\
-    (b1 + ((int)(6497*(b0 + (unsigned)b2) + 2048) >> 12))
+    (b1 + ((6497*(b0 + b2) + 2048) >> 12))
 
 
 #endif /* AVCODEC_DWT_H */

libavcodec/dirac_dwt_template.c

@@ -49,7 +49,7 @@ static void RENAME(vertical_compose53iL0)(uint8_t *_b0, uint8_t *_b1, uint8_t *_
     TYPE *b1 = (TYPE *)_b1;
     TYPE *b2 = (TYPE *)_b2;
     for (i = 0; i < width; i++)
-        b1[i] -= (int)(b0[i] + (unsigned)b2[i] + 2) >> 2;
+        b1[i] -= (b0[i] + b2[i] + 2) >> 2;
 }
 
 static av_always_inline void RENAME(interleave)(TYPE *dst, TYPE *src0, TYPE *src1, int w2,

libavcodec/dirac_vlc.c

@@ -37,7 +37,7 @@
 
 #define APPEND_RESIDUE(N, M)                                                   \
     N          |= M >> (N ## _bits);                                           \
-    N ## _bits  = (N ## _bits + (M ## _bits)) & 0x3F
+    N ## _bits +=      (M ## _bits)
 
 int ff_dirac_golomb_read_32bit(DiracGolombLUT *lut_ctx, const uint8_t *buf,
                                int bytes, uint8_t *_dst, int coeffs)
@@ -216,14 +216,9 @@ static void generate_offset_lut(DiracGolombLUT *lut, int off)
         INIT_RESIDUE(res);
         SET_RESIDUE(res, idx, LUT_BITS);
 
+        l->preamble      = CONVERT_TO_RESIDUE(res >> (RSIZE_BITS - off), off);
         l->preamble_bits = off;
-        if (off) {
-            l->preamble  = CONVERT_TO_RESIDUE(res >> (RSIZE_BITS - off), off);
-            l->sign      = ((l->preamble >> (RSIZE_BITS - l->preamble_bits)) & 1) ? -1 : +1;
-        } else {
-            l->preamble  = 0;
-            l->sign = 1;
-        }
+        l->sign = ((l->preamble >> (RSIZE_BITS - l->preamble_bits)) & 1) ? -1 : +1;
 
         search_for_golomb(l, res << off, LUT_BITS - off);
     }

libavcodec/diracdec.c

@@ -248,7 +248,7 @@ enum dirac_subband {
 /* magic number division by 3 from schroedinger */
 static inline int divide3(int x)
 {
-    return (int)((x+1U)*21845 + 10922) >> 16;
+    return ((x+1)*21845 + 10922) >> 16;
 }
 
 static DiracFrame *remove_frame(DiracFrame *framelist[], int picnum)
@@ -436,7 +436,7 @@ static av_cold int dirac_decode_end(AVCodecContext *avctx)
 static inline int coeff_unpack_golomb(GetBitContext *gb, int qfactor, int qoffset)
 {
     int coeff = dirac_get_se_golomb(gb);
-    const unsigned sign = FFSIGN(coeff);
+    const int sign = FFSIGN(coeff);
     if (coeff)
         coeff = sign*((sign * coeff * qfactor + qoffset) >> 2);
     return coeff;
@@ -448,8 +448,7 @@ static inline int coeff_unpack_golomb(GetBitContext *gb, int qfactor, int qoffse
     static inline void coeff_unpack_arith_##n(DiracArith *c, int qfactor, int qoffset, \
                                               SubBand *b, type *buf, int x, int y) \
     { \
-        int sign, sign_pred = 0, pred_ctx = CTX_ZPZN_F1; \
-        unsigned coeff; \
+        int coeff, sign, sign_pred = 0, pred_ctx = CTX_ZPZN_F1; \
         const int mstride = -(b->stride >> (1+b->pshift)); \
         if (b->parent) { \
             const type *pbuf = (type *)b->parent->ibuf; \
@@ -580,7 +579,7 @@ static inline void codeblock(DiracContext *s, SubBand *b,
     } \
 
 INTRA_DC_PRED(8, int16_t)
-INTRA_DC_PRED(10, uint32_t)
+INTRA_DC_PRED(10, int32_t)
 
 /**
  * Dirac Specification ->
@@ -818,7 +817,7 @@ static int decode_hq_slice(DiracContext *s, DiracSlice *slice, uint8_t *tmp_buf)
     skip_bits_long(gb, 8*s->highquality.prefix_bytes);
     quant_idx = get_bits(gb, 8);
 
-    if (quant_idx > DIRAC_MAX_QUANT_INDEX - 1) {
+    if (quant_idx > DIRAC_MAX_QUANT_INDEX) {
         av_log(s->avctx, AV_LOG_ERROR, "Invalid quantization index - %i\n", quant_idx);
         return AVERROR_INVALIDDATA;
     }
@@ -908,10 +907,9 @@ static int decode_lowdelay(DiracContext *s)
     int slice_num = 0;
 
     if (s->slice_params_num_buf != (s->num_x * s->num_y)) {
-        s->slice_params_buf = av_realloc_f(s->slice_params_buf, s->num_x * s->num_y, sizeof(DiracSlice));
+        s->slice_params_buf = av_realloc_f(s->thread_buf, s->num_x * s->num_y, sizeof(DiracSlice));
         if (!s->slice_params_buf) {
             av_log(s->avctx, AV_LOG_ERROR, "slice params buffer allocation failure\n");
-            s->slice_params_num_buf = 0;
             return AVERROR(ENOMEM);
         }
         s->slice_params_num_buf = s->num_x * s->num_y;
@@ -1155,10 +1153,6 @@ static int dirac_unpack_prediction_parameters(DiracContext *s)
                 s->globalmc[ref].perspective[0]  = dirac_get_se_golomb(gb);
                 s->globalmc[ref].perspective[1]  = dirac_get_se_golomb(gb);
             }
-            if (s->globalmc[ref].perspective_exp + (uint64_t)s->globalmc[ref].zrs_exp > 30) {
-                return AVERROR_INVALIDDATA;
-            }
-
         }
     }
 
@@ -1177,11 +1171,6 @@ static int dirac_unpack_prediction_parameters(DiracContext *s)
 
     if (get_bits1(gb)) {
         s->weight_log2denom = get_interleaved_ue_golomb(gb);
-        if (s->weight_log2denom < 1 || s->weight_log2denom > 8) {
-            av_log(s->avctx, AV_LOG_ERROR, "weight_log2denom unsupported or invalid\n");
-            s->weight_log2denom = 1;
-            return AVERROR_INVALIDDATA;
-        }
         s->weight[0] = dirac_get_se_golomb(gb);
         if (s->num_refs == 2)
             s->weight[1] = dirac_get_se_golomb(gb);
@@ -1416,7 +1405,7 @@ static void decode_block_params(DiracContext *s, DiracArith arith[8], DiracBlock
     if (!block->ref) {
         pred_block_dc(block, stride, x, y);
         for (i = 0; i < 3; i++)
-            block->u.dc[i] += (unsigned)dirac_get_arith_int(arith+1+i, CTX_DC_F1, CTX_DC_DATA);
+            block->u.dc[i] += dirac_get_arith_int(arith+1+i, CTX_DC_F1, CTX_DC_DATA);
         return;
     }
 
@@ -1985,9 +1974,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;
                 }
 
@@ -2051,9 +2038,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;

libavcodec/diracdsp.c

@@ -199,7 +199,7 @@ static void dequant_subband_ ## PX ## _c(uint8_t *src, uint8_t *dst, ptrdiff_t s
         for (i = 0; i < tot_h; i++) {                                                      \
             c = *src_r++;                                                                  \
             sign = FFSIGN(c)*(!!c);                                                        \
-            c = (FFABS(c)*(unsigned)qf + qs) >> 2;                                                   \
+            c = (FFABS(c)*qf + qs) >> 2;                                                   \
             *dst_r++ = c*sign;                                                             \
         }                                                                                  \
         src += tot_h << (sizeof(PX) >> 1);                                                 \

libavcodec/dnxhd_parser.c

@@ -31,24 +31,8 @@ typedef struct {
     ParseContext pc;
     int interlaced;
     int cur_field; /* first field is 0, second is 1 */
-    int cur_byte;
-    int remaining;
-    int w, h;
 } DNXHDParserContext;
 
-static int dnxhd_get_hr_frame_size(int cid, int w, int h)
-{
-    int result, i = ff_dnxhd_get_cid_table(cid);
-
-    if (i < 0)
-        return i;
-
-    result = ((h + 15) / 16) * ((w + 15) / 16) * ff_dnxhd_cid_table[i].packet_scale.num / ff_dnxhd_cid_table[i].packet_scale.den;
-    result = (result + 2048) / 4096 * 4096;
-
-    return FFMAX(result, 8192);
-}
-
 static int dnxhd_find_frame_end(DNXHDParserContext *dctx,
                                 const uint8_t *buf, int buf_size)
 {
@@ -67,67 +51,30 @@ static int dnxhd_find_frame_end(DNXHDParserContext *dctx,
                 pic_found = 1;
                 interlaced = (state&2)>>1; /* byte following the 5-byte header prefix */
                 cur_field = state&1;
-                dctx->cur_byte = 0;
-                dctx->remaining = 0;
                 break;
             }
         }
     }
 
-    if (pic_found && !dctx->remaining) {
+    if (pic_found) {
         if (!buf_size) /* EOF considered as end of frame */
             return 0;
         for (; i < buf_size; i++) {
-            dctx->cur_byte++;
             state = (state << 8) | buf[i];
-
-            if (dctx->cur_byte == 24) {
-                dctx->h = (state >> 32) & 0xFFFF;
-            } else if (dctx->cur_byte == 26) {
-                dctx->w = (state >> 32) & 0xFFFF;
-            } else if (dctx->cur_byte == 42) {
-                int cid = (state >> 32) & 0xFFFFFFFF;
-                int remaining;
-
-                if (cid <= 0)
-                    continue;
-
-                remaining = avpriv_dnxhd_get_frame_size(cid);
-                if (remaining <= 0) {
-                    remaining = dnxhd_get_hr_frame_size(cid, dctx->w, dctx->h);
-                    if (remaining <= 0)
-                        continue;
-                }
-                dctx->remaining = remaining;
-                if (buf_size - i >= dctx->remaining && (!dctx->interlaced || dctx->cur_field)) {
-                    int remaining = dctx->remaining;
-
+            if (ff_dnxhd_check_header_prefix(state & 0xffffffffff00LL) != 0) {
+                if (!interlaced || dctx->cur_field) {
                     pc->frame_start_found = 0;
                     pc->state64 = -1;
                     dctx->interlaced = interlaced;
                     dctx->cur_field = 0;
-                    dctx->cur_byte = 0;
-                    dctx->remaining = 0;
-                    return remaining;
+                    return i - 5;
                 } else {
-                    dctx->remaining -= buf_size;
+                    /* continue, to get the second field */
+                    dctx->interlaced = interlaced = (state&2)>>1;
+                    dctx->cur_field = cur_field = state&1;
                 }
             }
         }
-    } else if (pic_found) {
-        if (dctx->remaining > buf_size) {
-            dctx->remaining -= buf_size;
-        } else {
-            int remaining = dctx->remaining;
-
-            pc->frame_start_found = 0;
-            pc->state64 = -1;
-            dctx->interlaced = interlaced;
-            dctx->cur_field = 0;
-            dctx->cur_byte = 0;
-            dctx->remaining = 0;
-            return remaining;
-        }
     }
     pc->frame_start_found = pic_found;
     pc->state64 = state;

libavcodec/dnxhddec.c

@@ -294,18 +294,14 @@ static int dnxhd_decode_header(DNXHDContext *ctx, AVFrame *frame,
     if (ctx->mb_height > 68 && ff_dnxhd_check_header_prefix_hr(header_prefix)) {
         ctx->data_offset = 0x170 + (ctx->mb_height << 2);
     } else {
-        if (ctx->mb_height > 68) {
+        if (ctx->mb_height > 68 ||
+            (ctx->mb_height << frame->interlaced_frame) > (ctx->height + 15) >> 4) {
             av_log(ctx->avctx, AV_LOG_ERROR,
                    "mb height too big: %d\n", ctx->mb_height);
             return AVERROR_INVALIDDATA;
         }
         ctx->data_offset = 0x280;
     }
-    if ((ctx->mb_height << frame->interlaced_frame) > (ctx->height + 15) >> 4) {
-        av_log(ctx->avctx, AV_LOG_ERROR,
-                "mb height too big: %d\n", ctx->mb_height);
-        return AVERROR_INVALIDDATA;
-    }
 
     if (buf_size < ctx->data_offset) {
         av_log(ctx->avctx, AV_LOG_ERROR,

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;
 

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);
 

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;
     }
 }
 
@@ -189,12 +189,12 @@ static void guess_palette(DVDSubContext* ctx,
                 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);
             }
         }
     }

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;
 }

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;

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;

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;

libavcodec/escape124.c

@@ -249,10 +249,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);

libavcodec/exr.c

@@ -218,9 +218,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
@@ -1428,7 +1428,8 @@ 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->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,
@@ -1437,6 +1438,7 @@ static int decode_header(EXRContext *s)
                         }
                         s->pixel_type                     = current_pixel_type;
                         s->channel_offsets[channel_index] = s->current_channel_offset;
+                    }
                 }
 
                 s->channels = av_realloc(s->channels,
@@ -1448,11 +1450,7 @@ static int decode_header(EXRContext *s)
                 channel->xsub       = xsub;
                 channel->ysub       = ysub;
 
-                if (current_pixel_type == EXR_HALF) {
-                    s->current_channel_offset += 2;
-                } else {/* Float or UINT32 */
-                    s->current_channel_offset += 4;
-                }
+                s->current_channel_offset += 1 << current_pixel_type;
             }
 
             /* Check if all channels are set with an offset or if the channels

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++;
@@ -359,7 +358,7 @@ static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale)
     memset(state, 128, sizeof(state));
 
     for (v = 0; i < 128; v++) {
-        unsigned len = get_symbol(c, state, 0) + 1U;
+        unsigned len = get_symbol(c, state, 0) + 1;
 
         if (len > 128 - i || !len)
             return AVERROR_INVALIDDATA;
@@ -684,7 +683,7 @@ static int read_header(FFV1Context *f)
     } else {
         const uint8_t *p = c->bytestream_end;
         for (f->slice_count = 0;
-             f->slice_count < MAX_SLICES && 3 + 5*!!f->ec < p - c->bytestream_start;
+             f->slice_count < MAX_SLICES && 3 < p - c->bytestream_start;
              f->slice_count++) {
             int trailer = 3 + 5*!!f->ec;
             int size = AV_RB24(p-trailer);
@@ -884,7 +883,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;
@@ -892,12 +891,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,

libavcodec/ffv1dec_template.c

@@ -96,7 +96,7 @@ static av_always_inline void RENAME(decode_line)(FFV1Context *s, int w,
         }
 
         if (sign)
-            diff = -(unsigned)diff;
+            diff = -diff;
 
         sample[1][x] = av_mod_uintp2(RENAME(predict)(sample[1] + x, sample[0] + x) + diff, bits);
     }
@@ -149,7 +149,7 @@ static void RENAME(decode_rgb_frame)(FFV1Context *s, uint8_t *src[3], int w, int
             }
 
             if (lbd)
-                *((uint32_t*)(src[0] + x*4 + stride[0]*y)) = b + ((unsigned)g<<8) + ((unsigned)r<<16) + ((unsigned)a<<24);
+                *((uint32_t*)(src[0] + x*4 + stride[0]*y)) = b + (g<<8) + (r<<16) + (a<<24);
             else if (sizeof(TYPE) == 4) {
                 *((uint16_t*)(src[0] + x*2 + stride[0]*y)) = g;
                 *((uint16_t*)(src[1] + x*2 + stride[1]*y)) = b;

libavcodec/ffv1enc.c

@@ -1089,6 +1089,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;
@@ -1144,11 +1145,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;
 
@@ -1182,17 +1178,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 *));

libavcodec/fic.c

@@ -84,26 +84,26 @@ static const uint8_t fic_header[7] = { 0, 0, 1, 'F', 'I', 'C', 'V' };
 
 static av_always_inline void fic_idct(int16_t *blk, int step, int shift, int rnd)
 {
-    const unsigned t0 =  27246 * blk[3 * step] + 18405 * blk[5 * step];
-    const unsigned t1 =  27246 * blk[5 * step] - 18405 * blk[3 * step];
-    const unsigned t2 =   6393 * blk[7 * step] + 32139 * blk[1 * step];
-    const unsigned t3 =   6393 * blk[1 * step] - 32139 * blk[7 * step];
-    const unsigned t4 = 5793U * ((int)(t2 + t0 + 0x800) >> 12);
-    const unsigned t5 = 5793U * ((int)(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 t0 =  27246 * blk[3 * step] + 18405 * blk[5 * step];
+    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 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)

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.                                     */

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;

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,

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--;

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));

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;
     }
 }

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

libavcodec/g723_1dec.c

@@ -488,7 +488,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));
@@ -517,7 +517,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;\
     }\
 }
@@ -664,7 +664,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;
@@ -695,13 +695,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--;
     }
@@ -733,7 +733,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;
         }
     }
@@ -777,7 +777,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;
            }
@@ -815,7 +815,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++) {
@@ -904,7 +904,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;

libavcodec/g726.c

@@ -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)

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);
 }
 

libavcodec/h264_cabac.c

@@ -1743,7 +1743,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 ) { \
@@ -2347,41 +2347,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 = !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;
 
@@ -2389,6 +2370,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;
@@ -2419,14 +2408,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);

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->ps.pps, 0, sl->qscale);
         sl->chroma_qp[1] = get_chroma_qp(h->ps.pps, 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;
         }

libavcodec/h264_direct.c

@@ -614,7 +614,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,

libavcodec/h264_mb.c

@@ -637,7 +637,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),

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];               \
             }                                   \
         }                                       \

libavcodec/h264_parse.c

@@ -26,31 +26,29 @@
 
 int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps,
                               const int *ref_count, int slice_type_nos,
-                              H264PredWeightTable *pwt,
-                              int picture_structure, void *logctx)
+                              H264PredWeightTable *pwt, void *logctx)
 {
     int list, i, j;
     int luma_def, chroma_def;
 
     pwt->use_weight             = 0;
     pwt->use_weight_chroma      = 0;
-
     pwt->luma_log2_weight_denom = get_ue_golomb(gb);
+    if (sps->chroma_format_idc)
+        pwt->chroma_log2_weight_denom = get_ue_golomb(gb);
+
     if (pwt->luma_log2_weight_denom > 7U) {
         av_log(logctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is out of range\n", pwt->luma_log2_weight_denom);
         pwt->luma_log2_weight_denom = 0;
     }
-    luma_def = 1 << pwt->luma_log2_weight_denom;
-
-    if (sps->chroma_format_idc) {
-        pwt->chroma_log2_weight_denom = get_ue_golomb(gb);
-        if (pwt->chroma_log2_weight_denom > 7U) {
-            av_log(logctx, AV_LOG_ERROR, "chroma_log2_weight_denom %d is out of range\n", pwt->chroma_log2_weight_denom);
-            pwt->chroma_log2_weight_denom = 0;
-        }
-        chroma_def = 1 << pwt->chroma_log2_weight_denom;
+    if (pwt->chroma_log2_weight_denom > 7U) {
+        av_log(logctx, AV_LOG_ERROR, "chroma_log2_weight_denom %d is out of range\n", pwt->chroma_log2_weight_denom);
+        pwt->chroma_log2_weight_denom = 0;
     }
 
+    luma_def   = 1 << pwt->luma_log2_weight_denom;
+    chroma_def = 1 << pwt->chroma_log2_weight_denom;
+
     for (list = 0; list < 2; list++) {
         pwt->luma_weight_flag[list]   = 0;
         pwt->chroma_weight_flag[list] = 0;
@@ -61,9 +59,6 @@ int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps,
             if (luma_weight_flag) {
                 pwt->luma_weight[i][list][0] = get_se_golomb(gb);
                 pwt->luma_weight[i][list][1] = get_se_golomb(gb);
-                if ((int8_t)pwt->luma_weight[i][list][0] != pwt->luma_weight[i][list][0] ||
-                    (int8_t)pwt->luma_weight[i][list][1] != pwt->luma_weight[i][list][1])
-                    goto out_range_weight;
                 if (pwt->luma_weight[i][list][0] != luma_def ||
                     pwt->luma_weight[i][list][1] != 0) {
                     pwt->use_weight             = 1;
@@ -81,9 +76,6 @@ int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps,
                     for (j = 0; j < 2; j++) {
                         pwt->chroma_weight[i][list][j][0] = get_se_golomb(gb);
                         pwt->chroma_weight[i][list][j][1] = get_se_golomb(gb);
-                        if ((int8_t)pwt->chroma_weight[i][list][j][0] != pwt->chroma_weight[i][list][j][0] ||
-                            (int8_t)pwt->chroma_weight[i][list][j][1] != pwt->chroma_weight[i][list][j][1])
-                            goto out_range_weight;
                         if (pwt->chroma_weight[i][list][j][0] != chroma_def ||
                             pwt->chroma_weight[i][list][j][1] != 0) {
                             pwt->use_weight_chroma        = 1;
@@ -100,15 +92,11 @@ int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps,
             }
 
             // for MBAFF
-            if (picture_structure == PICT_FRAME) {
-                pwt->luma_weight[16 + 2 * i][list][0] = pwt->luma_weight[16 + 2 * i + 1][list][0] = pwt->luma_weight[i][list][0];
-                pwt->luma_weight[16 + 2 * i][list][1] = pwt->luma_weight[16 + 2 * i + 1][list][1] = pwt->luma_weight[i][list][1];
-                if (sps->chroma_format_idc) {
-                    for (j = 0; j < 2; j++) {
-                        pwt->chroma_weight[16 + 2 * i][list][j][0] = pwt->chroma_weight[16 + 2 * i + 1][list][j][0] = pwt->chroma_weight[i][list][j][0];
-                        pwt->chroma_weight[16 + 2 * i][list][j][1] = pwt->chroma_weight[16 + 2 * i + 1][list][j][1] = pwt->chroma_weight[i][list][j][1];
-                    }
-                }
+            pwt->luma_weight[16 + 2 * i][list][0] = pwt->luma_weight[16 + 2 * i + 1][list][0] = pwt->luma_weight[i][list][0];
+            pwt->luma_weight[16 + 2 * i][list][1] = pwt->luma_weight[16 + 2 * i + 1][list][1] = pwt->luma_weight[i][list][1];
+            for (j = 0; j < 2; j++) {
+                pwt->chroma_weight[16 + 2 * i][list][j][0] = pwt->chroma_weight[16 + 2 * i + 1][list][j][0] = pwt->chroma_weight[i][list][j][0];
+                pwt->chroma_weight[16 + 2 * i][list][j][1] = pwt->chroma_weight[16 + 2 * i + 1][list][j][1] = pwt->chroma_weight[i][list][j][1];
             }
         }
         if (slice_type_nos != AV_PICTURE_TYPE_B)
@@ -116,9 +104,6 @@ int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps,
     }
     pwt->use_weight = pwt->use_weight || pwt->use_weight_chroma;
     return 0;
-out_range_weight:
-    avpriv_request_sample(logctx, "Out of range weight\n");
-    return AVERROR_INVALIDDATA;
 }
 
 /**

libavcodec/h264_parse.h

@@ -55,8 +55,7 @@ typedef struct H264POCContext {
 
 int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps,
                               const int *ref_count, int slice_type_nos,
-                              H264PredWeightTable *pwt,
-                              int picture_structure, void *logctx);
+                              H264PredWeightTable *pwt, void *logctx);
 
 /**
  * Check if the top & left blocks are available if needed & change the

libavcodec/h264_parser.c

@@ -202,7 +202,7 @@ static int scan_mmco_reset(AVCodecParserContext *s, GetBitContext *gb,
     if ((p->ps.pps->weighted_pred && slice_type_nos == AV_PICTURE_TYPE_P) ||
         (p->ps.pps->weighted_bipred_idc == 1 && slice_type_nos == AV_PICTURE_TYPE_B))
         ff_h264_pred_weight_table(gb, p->ps.sps, ref_count, slice_type_nos,
-                                  &pwt, p->picture_structure, logctx);
+                                  &pwt, logctx);
 
     if (get_bits1(gb)) { // adaptive_ref_pic_marking_mode_flag
         int i;

libavcodec/h264_ps.c

@@ -812,8 +812,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);

libavcodec/h264_slice.c

@@ -1684,13 +1684,9 @@ static int h264_slice_header_parse(const H264Context *h, H264SliceContext *sl,
     }
     if ((pps->weighted_pred && sl->slice_type_nos == AV_PICTURE_TYPE_P) ||
         (pps->weighted_bipred_idc == 1 &&
-         sl->slice_type_nos == AV_PICTURE_TYPE_B)) {
-        ret = ff_h264_pred_weight_table(&sl->gb, sps, sl->ref_count,
-                                  sl->slice_type_nos, &sl->pwt,
-                                  picture_structure, h->avctx);
-        if (ret < 0)
-            return ret;
-    }
+         sl->slice_type_nos == AV_PICTURE_TYPE_B))
+        ff_h264_pred_weight_table(&sl->gb, sps, sl->ref_count,
+                                  sl->slice_type_nos, &sl->pwt, h->avctx);
 
     sl->explicit_ref_marking = 0;
     if (nal->ref_idc) {
@@ -1709,7 +1705,7 @@ static int h264_slice_header_parse(const H264Context *h, H264SliceContext *sl,
     }
 
     sl->last_qscale_diff = 0;
-    tmp = pps->init_qp + (unsigned)get_se_golomb(&sl->gb);
+    tmp = pps->init_qp + get_se_golomb(&sl->gb);
     if (tmp > 51 + 6 * (sps->bit_depth_luma - 8)) {
         av_log(h->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp);
         return AVERROR_INVALIDDATA;
@@ -1739,19 +1735,17 @@ static int h264_slice_header_parse(const H264Context *h, H264SliceContext *sl,
             sl->deblocking_filter ^= 1;  // 1<->0
 
         if (sl->deblocking_filter) {
-            int slice_alpha_c0_offset_div2 = get_se_golomb(&sl->gb);
-            int slice_beta_offset_div2     = get_se_golomb(&sl->gb);
-            if (slice_alpha_c0_offset_div2 >  6 ||
-                slice_alpha_c0_offset_div2 < -6 ||
-                slice_beta_offset_div2 >  6     ||
-                slice_beta_offset_div2 < -6) {
+            sl->slice_alpha_c0_offset = get_se_golomb(&sl->gb) * 2;
+            sl->slice_beta_offset     = get_se_golomb(&sl->gb) * 2;
+            if (sl->slice_alpha_c0_offset >  12 ||
+                sl->slice_alpha_c0_offset < -12 ||
+                sl->slice_beta_offset >  12     ||
+                sl->slice_beta_offset < -12) {
                 av_log(h->avctx, AV_LOG_ERROR,
                        "deblocking filter parameters %d %d out of range\n",
-                       slice_alpha_c0_offset_div2, slice_beta_offset_div2);
+                       sl->slice_alpha_c0_offset, sl->slice_beta_offset);
                 return AVERROR_INVALIDDATA;
             }
-            sl->slice_alpha_c0_offset = slice_alpha_c0_offset_div2 * 2;
-            sl->slice_beta_offset     = slice_beta_offset_div2 * 2;
         }
     }
 
@@ -1777,10 +1771,8 @@ int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl,
         return ret;
 
     // discard redundant pictures
-    if (sl->redundant_pic_count > 0) {
-        sl->ref_count[0] = sl->ref_count[1] = 0;
+    if (sl->redundant_pic_count > 0)
         return 0;
-    }
 
     if (sl->first_mb_addr == 0 || !h->current_slice) {
         if (h->setup_finished) {

libavcodec/hevc.c

@@ -246,8 +246,6 @@ static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
         nb_sps = get_ue_golomb_long(gb);
     nb_sh = get_ue_golomb_long(gb);
 
-    if (nb_sps > sps->num_long_term_ref_pics_sps)
-        return AVERROR_INVALIDDATA;
     if (nb_sh + (uint64_t)nb_sps > FF_ARRAY_ELEMS(rps->poc))
         return AVERROR_INVALIDDATA;
 
@@ -271,16 +269,12 @@ static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
 
         delta_poc_msb_present = get_bits1(gb);
         if (delta_poc_msb_present) {
-            int64_t delta = get_ue_golomb_long(gb);
-            int64_t poc;
+            int delta = get_ue_golomb_long(gb);
 
             if (i && i != nb_sps)
                 delta += prev_delta_msb;
 
-            poc = rps->poc[i] + s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
-            if (poc != (int32_t)poc)
-                return AVERROR_INVALIDDATA;
-            rps->poc[i] = poc;
+            rps->poc[i] += s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
             prev_delta_msb = delta;
         }
     }

libavcodec/hevc.h

@@ -545,8 +545,8 @@ typedef struct HEVCPPS {
     uint8_t chroma_qp_offset_list_enabled_flag;
     uint8_t diff_cu_chroma_qp_offset_depth;
     uint8_t chroma_qp_offset_list_len_minus1;
-    int8_t  cb_qp_offset_list[6];
-    int8_t  cr_qp_offset_list[6];
+    int8_t  cb_qp_offset_list[5];
+    int8_t  cr_qp_offset_list[5];
     uint8_t log2_sao_offset_scale_luma;
     uint8_t log2_sao_offset_scale_chroma;
 

libavcodec/hevc_filter.c

@@ -470,7 +470,7 @@ static int get_pcm(HEVCContext *s, int x, int y)
 
 #define TC_CALC(qp, bs)                                                 \
     tctable[av_clip((qp) + DEFAULT_INTRA_TC_OFFSET * ((bs) - 1) +       \
-                    (tc_offset & -2),                                   \
+                    (tc_offset >> 1 << 1),                              \
                     0, MAX_QP + DEFAULT_INTRA_TC_OFFSET)]
 
 static void deblocking_filter_CTB(HEVCContext *s, int x0, int y0)

libavcodec/hevc_ps.c

@@ -169,12 +169,6 @@ int ff_hevc_decode_short_term_rps(GetBitContext *gb, AVCodecContext *avctx,
             }
         }
 
-        if (k >= FF_ARRAY_ELEMS(rps->used)) {
-            av_log(avctx, AV_LOG_ERROR,
-                   "Invalid num_delta_pocs: %d\n", k);
-            return AVERROR_INVALIDDATA;
-        }
-
         rps->num_delta_pocs    = k;
         rps->num_negative_pics = k0;
         // sort in increasing order (smallest first)
@@ -224,12 +218,6 @@ int ff_hevc_decode_short_term_rps(GetBitContext *gb, AVCodecContext *avctx,
             prev = 0;
             for (i = 0; i < rps->num_negative_pics; i++) {
                 delta_poc = get_ue_golomb_long(gb) + 1;
-                if (delta_poc < 1 || delta_poc > 32768) {
-                    av_log(avctx, AV_LOG_ERROR,
-                        "Invalid value of delta_poc: %d\n",
-                        delta_poc);
-                    return AVERROR_INVALIDDATA;
-                }
                 prev -= delta_poc;
                 rps->delta_poc[i] = prev;
                 rps->used[i]      = get_bits1(gb);
@@ -237,12 +225,6 @@ int ff_hevc_decode_short_term_rps(GetBitContext *gb, AVCodecContext *avctx,
             prev = 0;
             for (i = 0; i < nb_positive_pics; i++) {
                 delta_poc = get_ue_golomb_long(gb) + 1;
-                if (delta_poc < 1 || delta_poc > 32768) {
-                    av_log(avctx, AV_LOG_ERROR,
-                        "Invalid value of delta_poc: %d\n",
-                        delta_poc);
-                    return AVERROR_INVALIDDATA;
-                }
                 prev += delta_poc;
                 rps->delta_poc[rps->num_negative_pics + i] = prev;
                 rps->used[rps->num_negative_pics + i]      = get_bits1(gb);
@@ -768,7 +750,7 @@ static int scaling_list_data(GetBitContext *gb, AVCodecContext *avctx, ScalingLi
                                   ff_hevc_diag_scan8x8_x[i];
 
                     scaling_list_delta_coef = get_se_golomb(gb);
-                    next_coef = (next_coef + 256U + scaling_list_delta_coef) % 256;
+                    next_coef = (next_coef + scaling_list_delta_coef + 256) % 256;
                     sl->sl[size_id][matrix_id][pos] = next_coef;
                 }
             }
@@ -1026,10 +1008,10 @@ int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
         sps->pcm.log2_min_pcm_cb_size = get_ue_golomb_long(gb) + 3;
         sps->pcm.log2_max_pcm_cb_size = sps->pcm.log2_min_pcm_cb_size +
                                         get_ue_golomb_long(gb);
-        if (FFMAX(sps->pcm.bit_depth, sps->pcm.bit_depth_chroma) > sps->bit_depth) {
+        if (sps->pcm.bit_depth > sps->bit_depth) {
             av_log(avctx, AV_LOG_ERROR,
-                   "PCM bit depth (%d, %d) is greater than normal bit depth (%d)\n",
-                   sps->pcm.bit_depth, sps->pcm.bit_depth_chroma, sps->bit_depth);
+                   "PCM bit depth (%d) is greater than normal bit depth (%d)\n",
+                   sps->pcm.bit_depth, sps->bit_depth);
             return AVERROR_INVALIDDATA;
         }
 
@@ -1450,7 +1432,6 @@ int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx,
     int i, ret = 0;
     unsigned int pps_id = 0;
     ptrdiff_t nal_size;
-    unsigned log2_parallel_merge_level_minus2;
 
     AVBufferRef *pps_buf;
     HEVCPPS *pps = av_mallocz(sizeof(*pps));
@@ -1621,22 +1602,20 @@ int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx,
         pps->deblocking_filter_override_enabled_flag = get_bits1(gb);
         pps->disable_dbf                             = get_bits1(gb);
         if (!pps->disable_dbf) {
-            int beta_offset_div2 = get_se_golomb(gb);
-            int tc_offset_div2   = get_se_golomb(gb) ;
-            if (beta_offset_div2 < -6 || beta_offset_div2 > 6) {
+            pps->beta_offset = get_se_golomb(gb) * 2;
+            pps->tc_offset = get_se_golomb(gb) * 2;
+            if (pps->beta_offset/2 < -6 || pps->beta_offset/2 > 6) {
                 av_log(avctx, AV_LOG_ERROR, "pps_beta_offset_div2 out of range: %d\n",
-                       beta_offset_div2);
+                       pps->beta_offset/2);
                 ret = AVERROR_INVALIDDATA;
                 goto err;
             }
-            if (tc_offset_div2 < -6 || tc_offset_div2 > 6) {
+            if (pps->tc_offset/2 < -6 || pps->tc_offset/2 > 6) {
                 av_log(avctx, AV_LOG_ERROR, "pps_tc_offset_div2 out of range: %d\n",
-                       tc_offset_div2);
+                       pps->tc_offset/2);
                 ret = AVERROR_INVALIDDATA;
                 goto err;
             }
-            pps->beta_offset = 2 * beta_offset_div2;
-            pps->tc_offset   = 2 *   tc_offset_div2;
         }
     }
 
@@ -1648,14 +1627,13 @@ int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx,
             goto err;
     }
     pps->lists_modification_present_flag = get_bits1(gb);
-    log2_parallel_merge_level_minus2     = get_ue_golomb_long(gb);
-    if (log2_parallel_merge_level_minus2 > sps->log2_ctb_size) {
+    pps->log2_parallel_merge_level       = get_ue_golomb_long(gb) + 2;
+    if (pps->log2_parallel_merge_level > sps->log2_ctb_size) {
         av_log(avctx, AV_LOG_ERROR, "log2_parallel_merge_level_minus2 out of range: %d\n",
-               log2_parallel_merge_level_minus2);
+               pps->log2_parallel_merge_level - 2);
         ret = AVERROR_INVALIDDATA;
         goto err;
     }
-    pps->log2_parallel_merge_level       = log2_parallel_merge_level_minus2 + 2;
 
     pps->slice_header_extension_present_flag = get_bits1(gb);
 

libavcodec/hevc_refs.c

@@ -438,7 +438,7 @@ static int add_candidate_ref(HEVCContext *s, RefPicList *list,
 {
     HEVCFrame *ref = find_ref_idx(s, poc);
 
-    if (ref == s->ref || list->nb_refs >= MAX_REFS)
+    if (ref == s->ref)
         return AVERROR_INVALIDDATA;
 
     if (!ref) {

libavcodec/hevc_sei.c

@@ -145,7 +145,7 @@ static int decode_nal_sei_display_orientation(HEVCContext *s)
     return 0;
 }
 
-static int decode_pic_timing(HEVCContext *s, int size)
+static int decode_pic_timing(HEVCContext *s)
 {
     GetBitContext *gb = &s->HEVClc->gb;
     HEVCSPS *sps;
@@ -166,12 +166,8 @@ static int decode_pic_timing(HEVCContext *s, int size)
         }
         get_bits(gb, 2);                   // source_scan_type
         get_bits(gb, 1);                   // duplicate_flag
-        skip_bits1(gb);
-        size--;
     }
-    skip_bits_long(gb, 8 * size);
-
-    return 0;
+    return 1;
 }
 
 static int decode_registered_user_data_closed_caption(HEVCContext *s, int size)
@@ -301,8 +297,9 @@ static int decode_nal_sei_prefix(HEVCContext *s, int type, int size)
         return decode_nal_sei_display_orientation(s);
     case SEI_TYPE_PICTURE_TIMING:
         {
-            int ret = decode_pic_timing(s, size);
+            int ret = decode_pic_timing(s);
             av_log(s->avctx, AV_LOG_DEBUG, "Skipped PREFIX SEI %d\n", type);
+            skip_bits(gb, 8 * size);
             return ret;
         }
     case SEI_TYPE_MASTERING_DISPLAY_INFO:

libavcodec/hevcdsp_template.c

@@ -599,7 +599,7 @@ static void FUNC(put_hevc_pel_bi_w_pixels)(uint8_t *_dst, ptrdiff_t _dststride,
     ox1     = ox1 * (1 << (BIT_DEPTH - 8));
     for (y = 0; y < height; y++) {
         for (x = 0; x < width; x++) {
-            dst[x] = av_clip_pixel(( (src[x] << (14 - BIT_DEPTH)) * wx1 + src2[x] * wx0 + (ox0 + ox1 + 1) * (1 << log2Wd)) >> (log2Wd + 1));
+            dst[x] = av_clip_pixel(( (src[x] << (14 - BIT_DEPTH)) * wx1 + src2[x] * wx0 + ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));
         }
         src  += srcstride;
         dst  += dststride;
@@ -1492,7 +1492,7 @@ static void FUNC(put_hevc_epel_bi_w_hv)(uint8_t *_dst, ptrdiff_t _dststride, uin
     for (y = 0; y < height; y++) {
         for (x = 0; x < width; x++)
             dst[x] = av_clip_pixel(((EPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx1 + src2[x] * wx0 +
-                                    ((ox0 + ox1 + 1) * (1 << log2Wd))) >> (log2Wd + 1));
+                                    ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));
         tmp  += MAX_PB_SIZE;
         dst  += dststride;
         src2 += MAX_PB_SIZE;

libavcodec/hevcpred_template.c

@@ -35,7 +35,7 @@ static av_always_inline void FUNC(intra_pred)(HEVCContext *s, int x0, int y0,
 #define MVF(x, y) \
     (s->ref->tab_mvf[(x) + (y) * min_pu_width])
 #define MVF_PU(x, y) \
-    MVF(PU(x0 + ((x) * (1 << hshift))), PU(y0 + ((y) * (1 << vshift))))
+    MVF(PU(x0 + ((x) << hshift)), PU(y0 + ((y) << vshift)))
 #define IS_INTRA(x, y) \
     (MVF_PU(x, y).pred_flag == PF_INTRA)
 #define MIN_TB_ADDR_ZS(x, y) \

libavcodec/hq_hqa.c

@@ -68,11 +68,11 @@ static int hq_decode_block(HQContext *c, GetBitContext *gb, int16_t block[64],
     memset(block, 0, 64 * sizeof(*block));
 
     if (!is_hqa) {
-        block[0] = get_sbits(gb, 9) * 64;
+        block[0] = get_sbits(gb, 9) << 6;
         q = ff_hq_quants[qsel][is_chroma][get_bits(gb, 2)];
     } else {
         q = ff_hq_quants[qsel][is_chroma][get_bits(gb, 2)];
-        block[0] = get_sbits(gb, 9) * 64;
+        block[0] = get_sbits(gb, 9) << 6;
     }
 
     for (;;) {
@@ -83,7 +83,7 @@ static int hq_decode_block(HQContext *c, GetBitContext *gb, int16_t block[64],
         pos += ff_hq_ac_skips[val];
         if (pos >= 64)
             break;
-        block[ff_zigzag_direct[pos]] = (int)(ff_hq_ac_syms[val] * (unsigned)q[pos]) >> 12;
+        block[ff_zigzag_direct[pos]] = (ff_hq_ac_syms[val] * q[pos]) >> 12;
         pos++;
     }