Add 2.6 to maintained releases

Signed-off-by: Michael Niedermayer <michaelni@gmx.at>

Changelog

@@ -1,437 +1,6 @@
 Entries are sorted chronologically from oldest to youngest within each release,
 releases are sorted from youngest to oldest.
 
-version 2.6.7:
-- configure: bump copyright year to 2016
-- avformat/hls: Even stricter URL checks
-- avformat/hls: More strict url checks
-- swscale/utils: Detect and skip unneeded sws_setColorspaceDetails() calls
-- swscale/yuv2rgb: Increase YUV2RGB table headroom
-- swscale/yuv2rgb: Factor YUVRGB_TABLE_LUMA_HEADROOM out
-- avformat/hls: forbid all protocols except http(s) & file
-- avformat/aviobuf: Fix end check in put_str16()
-- avformat/asfenc: Check pts
-- avcodec/mpeg4video: Check time_incr
-- avcodec/wavpackenc: Check the number of channels
-- avcodec/wavpackenc: Headers are per channel
-- avcodec/dvdec: Fix "left shift of negative value -254"
-- avcodec/mjpegdec: Fix negative shift
-- avcodec/mss2: Check for repeat overflow
-- avformat: Add integer fps from 31 to 60 to get_std_framerate()
-- avcodec/mpegvideo_enc: Clip bits_per_raw_sample within valid range
-- avfilter/vf_scale: set proper out frame color range
-- avcodec/motion_est: Fix mv_penalty table size
-- avcodec/h264_slice: Fix integer overflow in implicit weight computation
-- swscale/utils: Use normal bilinear scaler if fast cannot be used due to tiny dimensions
-- avcodec/put_bits: Always check buffer end before writing
-- mjpegdec: extend check for incompatible values of s->rgb and s->ls
-- swscale/utils: Fix intermediate format for cascaded alpha downscaling
-- x86/float_dsp: zero extend offset from ff_scalarproduct_float_sse
-
-
-version 2.6.6:
-- nuv: sanitize negative fps rate
-- rawdec: only exempt BIT0 with need_copy from buffer sanity check
-- mlvdec: check that index_entries exist
-- nutdec: reject negative value_len in read_sm_data
-- xwddec: prevent overflow of lsize * avctx->height
-- nutdec: only copy the header if it exists
-- exr: fix out of bounds read in get_code
-- on2avc: limit number of bits to 30 in get_egolomb
-- avcodec/mpeg4videodec: also for empty partitioned slices
-- avcodec/h264_refs: Fix long_idx check
-- avfilter/vf_mpdecimate: Add missing emms_c()
-- avformat/mxfenc: Do not crash if there is no packet in the first stream
-- avformat/utils: estimate_timings_from_pts - increase retry counter, fixes invalid duration for ts files with hevc codec
-- avformat/matroskaenc: Check codecdelay before use
-- avutil/mathematics: Fix division by 0
-- avcodec/hevc: Check max ctb addresses for WPP
-- avcodec/vp3: ensure header is parsed successfully before tables
-- avcodec/jpeg2000dec: Check bpno in decode_cblk()
-- avcodec/pgssubdec: Fix left shift of 255 by 24 places cannot be represented in type int
-- swscale/utils: Fix for runtime error: left shift of negative value -1
-- avcodec/hevc: Fix integer overflow of entry_point_offset
-- avcodec/dirac_parser: Add basic validity checks for next_pu_offset and prev_pu_offset
-- avcodec/dirac_parser: Fix potential overflows in pointer checks
-- avcodec/wmaprodec: Check bits per sample to be within the range not causing integer overflows
-- avcodec/wmaprodec: Fix overflow of cutoff
-- avformat/smacker: fix integer overflow with pts_inc
-- avcodec/vp3: Fix "runtime error: left shift of negative value"
-- mpegencts: Fix overflow in cbr mode period calculations
-- avutil/timecode: Fix fps check
-- avutil/mathematics: return INT64_MIN (=AV_NOPTS_VALUE) from av_rescale_rnd() for overflows
-- avcodec/apedec: Check length in long_filter_high_3800()
-- avcodec/vp3: always set pix_fmt in theora_decode_header()
-- avutil/mathematics: Do not treat INT64_MIN as positive in av_rescale_rnd
-- avutil/integer: Fix av_mod_i() with negative dividend
-- avformat/dump: Fix integer overflow in av_dump_format()
-- avcodec/utils: Clear dimensions in ff_get_buffer() on failure
-- avcodec/utils: Use 64bit for aspect ratio calculation in avcodec_string()
-- avcodec/vp3: Clear context on reinitialization failure
-- avcodec/hevc: allocate entries unconditionally
-- avcodec/hevc_cabac: Fix multiple integer overflows
-- avcodec/jpeg2000dwt: Check ndeclevels before calling dwt_encode*()
-- avcodec/jpeg2000dwt: Check ndeclevels before calling dwt_decode*()
-- avcodec/hevc: Check entry_point_offsets
-- avcodec/cabac: Check initial cabac decoder state
-- avcodec/cabac_functions: Fix "left shift of negative value -31767"
-- avcodec/h264_slice: Limit max_contexts when slice_context_count is initialized
-- avcodec/vp8: Do not use num_coeff_partitions in thread/buffer setup
-- avcodec/mpeg4videodec: Check available data before reading custom matrix
-- mjpegdec: consider chroma subsampling in size check
-- avcodec/dirac_parser: Check that there is a previous PU before accessing it
-- sonic: make sure num_taps * channels is not larger than frame_size
-- opus_silk: fix typo causing overflow in silk_stabilize_lsf
-- ffm: reject invalid codec_id and codec_type
-- golomb: always check for invalid UE golomb codes in get_ue_golomb
-- aaccoder: prevent crash of anmr coder
-- ffmdec: reject zero-sized chunks
-- swscale/x86/rgb2rgb_template: Fallback to mmx in interleaveBytes() if the alignment is insufficient for SSE*
-- swscale/x86/rgb2rgb_template: Do not crash on misaligend stride
-- avcodec/ffv1dec: Clear quant_table_count if its invalid
-- avcodec/ffv1dec: Print an error if the quant table count is invalid
-- doc/filters/drawtext: fix centering example
-- mxfdec: check edit_rate also for physical_track
-- mpegvideo: clear overread in clear_context
-- dvdsubdec: validate offset2 similar to offset1
-- aacdec: don't return frames without data from aac_decode_er_frame
-- avcodec/takdec: Use memove, avoid undefined memcpy() use
-- riffdec: prevent negative bit rate
-- Merge commit 'd80811c94e068085aab797f9ba35790529126f85'
-- s302m: fix arithmetic exception
-- avcodec/s302m: Only set the sample rate when some data is output
-- vp9: add support for resolution changes in inter frames.
-
-
-version 2.6.5:
-- rtmpcrypt: Do the xtea decryption in little endian mode
-- avformat/matroskadec: Check subtitle stream before dereferencing
-- avformat/utils: Do not init parser if probing is unfinished
-- avcodec/jpeg2000dec: Fix potential integer overflow with tile dimensions
-- avcodec/jpeg2000dec: Check SIZ dimensions to be within the supported range
-- avcodec/jpeg2000: Check comp coords to be within the supported size
-- avcodec/jpeg2000: Use av_image_check_size() in ff_jpeg2000_init_component()
-- avcodec/wmaprodec: Check for overread in decode_packet()
-- avcodec/smacker: Check that the data size is a multiple of a sample vector
-- avcodec/takdec: Skip last p2 sample (which is unused)
-- avcodec/dxtory: Fix input size check in dxtory_decode_v1_410()
-- avcodec/dxtory: Fix input size check in dxtory_decode_v1_420()
-- avcodec/error_resilience: avoid accessing previous or next frames tables beyond height
-- avcodec/dpx: Move need_align to act per line
-- avcodec/flashsv: Check size before updating it
-- avcodec/ivi: Check image dimensions
-- avcodec/utils: Better check for channels in av_get_audio_frame_duration()
-- avcodec/jpeg2000dec: Check for duplicate SIZ marker
-- doc/ffmpeg: Clarify that the sdp_file option requires an rtp output.
-- ffmpeg: Don't try and write sdp info if none of the outputs had an rtp format.
-- jvdec: avoid unsigned overflow in comparison
-- avcodec/jpeg2000dec: Clip all tile coordinates
-- avcodec/hevc_ps: Check chroma_format_idc
-- avcodec/microdvddec: Check for string end in 'P' case
-- avcodec/dirac_parser: Fix undefined memcpy() use
-- avformat/xmv: Discard remainder of packet on error
-- avformat/xmv: factor return check out of if/else
-- avcodec/mpeg12dec: Do not call show_bits() with invalid bits
-- libavutil/channel_layout: Check strtol*() for failure
-- avcodec/ffv1dec: Check for 0 quant tables
-- avcodec/mjpegdec: Reinitialize IDCT on BPP changes
-- avcodec/mjpegdec: Check index in ljpeg_decode_yuv_scan() before using it
-- avutil/file_open: avoid file handle inheritance on Windows
-- opusdec: Don't run vector_fmul_scalar on zero length arrays
-- avcodec/ffv1: Initialize vlc_state on allocation
-- avcodec/ffv1dec: update progress in case of broken pointer chains
-- avcodec/ffv1dec: Clear slice coordinates if they are invalid or slice header decoding fails for other reasons
-- avformat/httpauth: Add space after commas in HTTP/RTSP auth header
-- avcodec/x86/sbrdsp: Fix using uninitialized upper 32bit of noise
-- avcodec/ffv1dec: Fix off by 1 error in quant_table_count check
-- avcodec/ffv1dec: Explicitly check read_quant_table() return value
-- avcodec/rangecoder: Check e
-- lavf/webvttenc: Require webvtt file to contain exactly one WebVTT stream.
-- avcodec/mjpegdec: Fix decoding RGBA RCT LJPEG
-- avfilter/af_asyncts: use llabs for int64_t
-- avcodec/g2meet: Also clear tile dimensions on header_fail
-- avcodec/g2meet: Fix potential overflow in tile dimensions check
-- avcodec/svq1dec: Check init_get_bits8() for failure
-- avcodec/tta: Check init_get_bits8() for failure
-- avcodec/vp3: Check init_get_bits8() for failure
-- swresample/swresample: Fix integer overflow in seed calculation
-- avformat/mov: Fix integer overflow in FFABS
-- avutil/common: Add FFNABS()
-- avutil/common: Document FFABS() corner case
-- avformat/dump: Fix integer overflow in aspect ratio calculation
-- avcodec/truemotion1: Check for even width
-- avcodec/mpeg12dec: Set dimensions in mpeg1_decode_sequence() only in absence of errors
-- avcodec/libopusenc: Fix infinite loop on flushing after 0 input
-- avformat/hevc: Check num_long_term_ref_pics_sps to avoid potentially long loops
-- avformat/hevc: Fix parsing errors
-- ffmpeg: Use correct codec_id for av_parser_change() check
-- ffmpeg: Check av_parser_change() for failure
-- ffmpeg: Check for RAWVIDEO and do not relay only on AVFMT_RAWPICTURE
-- ffmpeg: check avpicture_fill() return value
-- avformat/mux: Update sidedata in ff_write_chained()
-- avcodec/flashsvenc: Correct max dimension in error message
-- avcodec/svq1enc: Check dimensions
-- avcodec/dcaenc: clear bitstream end
-- libavcodec/aacdec_template: Use init_get_bits8() in aac_decode_frame()
-- rawdec: fix mjpeg probing buffer size check
-- rawdec: fix mjpeg probing
-- videodsp: don't overread edges in vfix3 emu_edge.
-- lavf/matroskadec: Fully parse and repack MP3 packets
-- avcodec/h264_mp4toannexb_bsf: Reorder operations in nal_size check
-- avformat/oggenc: Check segments_count for headers too
-- avformat/avidec: Workaround broken initial frame
-- hevc: properly handle no_rasl_output_flag when removing pictures from the DPB
-- hevc: fix wpp threading deadlock.
-- avcodec/ffv1: separate slice_count from max_slice_count
-- lavf/img2dec: Fix memory leak
-- avcodec/mp3: fix skipping zeros
-- avformat/srtdec: make sure we probe a number
-- avformat/srtdec: more lenient first line probing
-- doc: mention libavcodec can decode Opus natively
-- MAINTAINERS: Remove myself as leader
-
-
-version 2.6.4:
-- imc: use correct position for flcoeffs2 calculation
-- hevc: check slice address length
-- snow: remove an obsolete av_assert2
-- webp: fix infinite loop in webp_decode_frame
-- wavpack: limit extra_bits to 32 and use get_bits_long
-- ffmpeg: only count got_output/errors in decode_error_stat
-- ffmpeg: exit_on_error if decoding a packet failed
-- pthread_frame: forward error codes when flushing
-- huffyuvdec: validate image size
-- wavpack: use get_bits_long to read up to 32 bits
-- nutdec: check maxpos in read_sm_data before returning success
-- vc1dec: use get_bits_long and limit the read bits to 32
-- mpegaudiodec: copy AVFloatDSPContext from first context to all contexts
-- avcodec/vp8: Check buffer size in vp8_decode_frame_header()
-- avcodec/vp8: Fix null pointer dereference in ff_vp8_decode_free()
-- avcodec/diracdec: Check for hpel_base allocation failure
-- avcodec/rv34: Clear pointers in ff_rv34_decode_init_thread_copy()
-- avfilter/af_aresample: Check ff_all_* for allocation failures
-- avcodec/pthread_frame: clear priv_data, avoid stale pointer in error case
-- swscale/utils: Clear pix buffers
-- avutil/fifo: Fix the case where func() returns less bytes than requested in av_fifo_generic_write()
-- ffmpeg: Fix cleanup after failed allocation of output_files
-- avformat/mov: Fix deallocation when MOVStreamContext failed to allocate
-- ffmpeg: Fix crash with ost->last_frame allocation failure
-- ffmpeg: Fix cleanup with ost = NULL
-- avcodec/pthread_frame: check avctx on deallocation
-- avcodec/sanm: Reset sizes in destroy_buffers()
-- avcodec/alac: Clear pointers in allocate_buffers()
-- bytestream2: set the reader to the end when reading more than available
-- avcodec/utils: use a minimum 32pixel width in  avcodec_align_dimensions2() for H.264
-- avcodec/mpegvideo: Clear pointers in ff_mpv_common_init()
-- oggparsedirac: check return value of init_get_bits
-- wmalosslessdec: reset frame->nb_samples on packet loss
-- wmalosslessdec: avoid reading 0 bits with get_bits
-- avcodec/rawenc: Use ff_alloc_packet() instead of ff_alloc_packet2()
-- avcodec/aacsbr: Assert that bs_num_env is positive
-- avcodec/aacsbr: check that the element type matches before applying SBR
-- avcodec/h264_slice: Use w/h from the AVFrame instead of mb_w/h
-- vp9/update_prob: prevent out of bounds table read
-- avfilter/vf_transpose: Fix rounding error
-- avcodec/pngdec: Check values before updating context in decode_fctl_chunk()
-- avcodec/pngdec: Require a IHDR chunk before fctl
-- avcodec/pngdec: Only allow one IHDR chunk
-- wmavoice: limit wmavoice_decode_packet return value to packet size
-- swscale/swscale_unscaled: Fix rounding difference with RGBA output between little and big endian
-- ffmpeg: Do not use the data/size of a bitstream filter after failure
-- swscale/x86/rgb2rgb_template: fix signedness of v in shuffle_bytes_2103_{mmx,mmxext}
-- swscale/x86/rgb2rgb_template: add missing xmm clobbers
-- vda: unlock the pixel buffer base address.
-- swscale/rgb2rgb_template: Fix signedness of v in shuffle_bytes_2103_c()
-- swscale/rgb2rgb_template: Implement shuffle_bytes_0321_c and fix shuffle_bytes_2103_c on BE
-- swscale/rgb2rgb_template: Disable shuffle_bytes_2103_c on big endian
-- swr: Remember previously set int_sample_format from user
-- matroskadec: check audio sample rate
-- matroskadec: validate audio channels and bitdepth
-- avcodec/dpxenc: implement write16/32 as functions
-- postproc: fix unaligned access
-- ffmpeg: Free last_frame instead of just unref
-- avio: fix potential crashes when combining ffio_ensure_seekback + crc
-- examples/demuxing_decoding: use properties from frame instead of video_dec_ctx
-- h264: er: Copy from the previous reference only if compatible
-- sonic: set avctx->channels in sonic_decode_init
-- vp8: change mv_{min,max}.{x,y} type to int
-- vp9: change type of tile_size from unsigned to int64_t
-- arm: only enable setend on ARMv6
-- libopenjpegdec: check existence of image component data
-- mov: abort on EOF in ff_mov_read_chan
-- ffmpeg_opt: Check for localtime() failure
-- avformat: Fix bug in parse_rps for HEVC.
-- takdec: ensure chan2 is a valid channel index
-- avcodec/h264_slice: Use AVFrame diemensions for grayscale handling
-- avdevice/lavfi: do not rescale AV_NOPTS_VALUE in lavfi_read_packet()
-- libavutil/channel_layout: Correctly return layout when channel specification ends with a trailing 'c'.
-- avcodec/jpeg2000dec: Check that coords match before applying ICT
-- avformat/ffmdec: Check ffio_set_buf_size() return value
-- avcodec/adpcm: Check for overreads
-- avcodec/alsdec: Check for overread
-- avcodec/atrac3plusdec: consume only as many bytes as available
-- libavutil/softfloat: Fix av_normalize1_sf bias.
-- swresample/swresample: Cleanup on init failure.
-- Revert "avformat/rtpenc: check av_packet_get_side_data() return, fix null ptr dereference"
-- avformat/mxfenc: Accept MXF D-10 with 49.999840 Mbit/sec
-- swresample/dither: check memory allocation
-- libopenjpegenc: add NULL check for img before accessing it
-- swresample: Check the return value of resampler->init()
-- h264: Make sure reinit failures mark the context as not initialized
-- avfilter/x86/vf_fspp: Fix invalid combination of opcode and operands
-- ffmpeg_opt: Set the video VBV parameters only for the video stream from -target
-- avcodec/bitstream: Assert that there is enough space left in avpriv_copy_bits()
-- avcodec/put_bits: Assert that there is enough space left in skip_put_bytes()
-- avcodec/mpegvideo_enc: Update the buffer size as more slices are merged
-- avcodec/put_bits: Update size_in_bits in set_put_bits_buffer_size()
-- avformat/wavdec: Increase dts packet threshold to fix more misdetections
-- avformat/wavdec: Increase probe_packets limit
-- nutdec: abort if EOF is reached in decode_info_header/read_sm_data
-- nutdec: stop skipping bytes at EOF
-- nutdec: fix infinite resync loops
-- avformat/nutdec: Check X in 2nd branch of index reading
-- avformat/nutdec: Fix recovery when immedeately after seeking a failure happens
-- avformat/nutdec: Return error on EOF from get_str()
-- rtsp: Make sure we don't write too many transport entries into a fixed-size array
-- rtpenc_jpeg: handle case of picture dimensions not dividing by 8
-- avcodec/golomb: get_ur_golomb_jpegls: Fix reading huge k values
-- avformat/swfdec: Do not error out on pixel format changes
-- avformat/mov: Mark avio context of decompressed atoms as seekable
-- avcodec/mjpegenc_common: Use ff_mpv_reallocate_putbitbuffer()
-- avcodec/mpegvideo: Factor ff_mpv_reallocate_putbitbuffer() out
-- avfilter/x86/vf_hqdn3d: Fix register types
-- avcodec/exr: fix crash caused by merge
-- avcodec/x86/h264_weight: handle weight1=128
-- avcodec/dvbsubdec: Fix buf_size check in dvbsub_parse_display_definition_segment()
-- avcodec/hevc_ps: Only discard overread VPS if a previous is available
-- avcodec/flacenc: Fix Invalid Rice order
-- lavd/xcbgrab: fix comparison with screen size.
-
-version 2.6.3:
-- avcodec/libtheoraenc: Check for av_malloc failure
-- ffmpeg_opt: Fix -timestamp parsing
-- hevc: make avcodec_decode_video2() fail if get_format() fails
-- avcodec/cavsdec: Use ff_set_dimensions()
-- swr: fix alignment issue caused by 8ch sse functions
-- avcodec/mjpegdec: fix len computation in ff_mjpeg_decode_dqt()
-- avcodec/jpeg2000dec: fix boolean operator
-- avcodec/hevc_ps: Explicitly check num_tile_* for negative values
-- avformat/matroskadec: Cleanup error handling for bz2 & zlib
-- avformat/nutdec: Fix use of uinitialized value
-- tools/graph2dot: use larger data types than int for array/string sizes
-- avformat/matroskaenc: Check ff_vorbiscomment_length in put_flac_codecpriv()
-- avcodec/mpeg12dec: use the correct dimensions for checking SAR
-- xcbgrab: Validate the capture area
-- xcbgrab: Do not assume the non shm image data is always available
-- avfilter/lavfutils: disable frame threads when decoding a single image
-- avformat/mov: Do not read ACLR into extradata for H.264
-- ffmpeg: remove incorrect network deinit
-- OpenCL: Avoid potential buffer overflow in cmdutils_opencl.c
-- libvpxenc: only set noise reduction w/vp8
-- vp9: remove another optimization branch in iadst16 which causes overflows.
-- lavf: Reset global flag on deinit
-- network: Do not leave context locked on error
-- vp9: remove one optimization branch in iadst16 which causes overflows.
-- fate: Include branch information in the payload header
-- avformat/utils: Ensure that AVFMT_FLAG_CUSTOM_IO is set before use
-- avformat/img2dec: do not rewind custom io buffers
-- avcodec/alsdec: Use av_mallocz_array() for chan_data to ensure the arrays never contain random data
-- avcodec/atrac3plusdsp: fix on stack alignment
-- swresample/swresample-test: Randomly wipe out channel counts
-- swresample: Check channel layouts and channels against each other and print human readable error messages
-- swresample: Allow reinitialization without ever setting channel layouts (cherry picked from commit 80a28c7509a11114e1aea5b208d56c6646d69c07)
-- swresample: Allow reinitialization without ever setting channel counts
-- dashenc: replace attribute id with contentType for the AdaptationSet element
-- avformat/matroskaenc: Use avoid_negative_ts_use_pts if no stream writes dts
-- avformat/mux: Add avoid_negative_ts_use_pts
-- tests/fate-run: do not attempt to parse tiny_psnrs output if it failed
-- cafdec: free extradata before allocating it
-- imgutils: initialize palette padding bytes in av_image_alloc
-- aacdec: don't return frames without data
-- id3v2: catch avio_read errors in check_tag
-- avi: Validate sample_size
-- aacsbr: break infinite loop in sbr_hf_calc_npatches
-- diracdec: avoid overflow of bytes*8 in decode_lowdelay
-- diracdec: prevent overflow in data_unit_size check
-- avformat/matroskadec: Use tracks[k]->stream instead of s->streams[k]
-- matroskadec: use uint64_t instead of int for index_scale
-- pngdec: don't use AV_PIX_FMT_MONOBLACK for apng
-- pngdec: return correct error code from decode_frame_common
-- nutdec: fix illegal count check in decode_main_header
-- nutdec: fix memleaks on error in nut_read_header
-- apedec: prevent out of array writes in decode_array_0000
-- apedec: set s->samples only when init_frame_decoder succeeded
-- swscale/ppc/swscale_altivec.c: POWER LE support in yuv2planeX_8() delete macro GET_VF() it was wrong
-- alac: reject rice_limit 0 if compression is used
-- alsdec: only adapt order for positive max_order
-- bink: check vst->index_entries before using it
-- mpeg4videodec: only allow a positive length
-- aacpsy: correct calculation of minath in psy_3gpp_init
-- alsdec: validate time diff index
-- alsdec: ensure channel reordering is reversible
-- ac3: validate end in ff_ac3_bit_alloc_calc_mask
-- aacpsy: avoid psy_band->threshold becoming NaN
-- aasc: return correct buffer size from aasc_decode_frame
-- matroskadec: export cover art correctly
-- mxfenc: don't try to write footer without header
-- mxfenc: fix memleaks in mxf_write_footer
-- rtpenc_mpegts: Set chain->rtp_ctx only after avformat_write_header succeeded
-- rtpenc_mpegts: Free the right ->pb in the error path in the init function
-
-version 2.6.2:
-- avcodec/h264: Do not fail with randomly truncated VUIs
-- avcodec/h264_ps: Move truncation check from VUI to SPS
-- avcodec/h264: Be more tolerant to changing pps id between slices
-- avcodec/aacdec: Fix storing state before PCE decode
-- avcodec/h264: reset the counts in the correct context
-- avcodec/h264_slice: Do not reset mb_aff_frame per slice
-- avcodec/h264: finish previous slices before switching to single thread mode
-- avcodec/h264: Fix race between slices where one overwrites data from the next
-- avformat/utils: avoid discarded streams in av_find_default_stream_index()
-- ffmpeg: Fix extradata allocation
-- avcodec/h264_refs: Do not set reference to things which do not exist
-- avcodec/h264: Fail for invalid mixed IDR / non IDR frames in slice threading mode
-- Revert "avcodec/exr: fix memset first arg in reverse_lut()"
-- h264: avoid unnecessary calls to get_format
-- avutil/pca: Check for av_malloc* failures
-- avutil/cpu: add missing check for mmxext to av_force_cpu_flags
-- lavc/dnxhd: Fix pix_fmt change.
-- avformat/http: replace cookies with updated values instead of appending forever
-- avformat/hls: store cookies returned in HLS key response
-- avformat/rmdec: fix support for 0 sized mdpr
-- avcodec/msrledec: restructure msrle_decode_pal4() based on the line number instead of the pixel pointer
-- avcodec/hevc_ps: Check cropping parameters more correctly
-- hevc: make the crop sizes unsigned
-- avcodec/dnxhddec: Reset is_444 if format is not 444
-- avcodec/dnxhddec: Check that the frame is interlaced before using cur_field
-- mips/float_dsp: fix vector_fmul_window_mips on mips64
-- doc: Remove non-existing decklink options.
-
-version 2.6.1:
-- avformat/mov: Disallow ".." in dref unless use_absolute_path is set
-- avfilter/palettegen: make sure at least one frame was sent to the filter
-- avformat/mov: Check for string truncation in mov_open_dref()
-- ac3_fixed: fix out-of-bound read
-- mips/asmdefs: use _ABI64 as defined by gcc
-- hevc: delay ff_thread_finish_setup for hwaccel
-- avcodec/012v: Check dimensions more completely
-- asfenc: fix leaking asf->index_ptr on error
-- roqvideoenc: set enc->avctx in roq_encode_init
-- avcodec/options_table: remove extradata_size from the AVOptions table
-- ffmdec: limit the backward seek to the last resync position
-- Add dependencies to configure file for vf_fftfilt
-- ffmdec: make sure the time base is valid
-- ffmdec: fix infinite loop at EOF
-- ffmdec: initialize f_cprv, f_stvi and f_stau
-- arm: Suppress tags about used cpu arch and extensions
-- mxfdec: Fix the error handling for when strftime fails
-- avcodec/opusdec: Fix delayed sample value
-- avcodec/opusdec: Clear out pointers per packet
-- avcodec/utils: Align YUV411 by as much as the other YUV variants
-- lavc/hevcdsp: Fix compilation for arm with --disable-neon.
-- vp9: fix segmentation map retention with threading enabled.
-- Revert "avutil/opencl: is_compiled flag not being cleared in av_opencl_uninit"
-
 version 2.6:
 - nvenc encoder
 - 10bit spp filter
@@ -466,7 +35,8 @@ version 2.6:
 - Fix stsd atom corruption in DNxHD QuickTimes
 - Canopus HQX decoder
 - RTP depacketization of T.140 text (RFC 4103)
-- Port MIPS optimizations to 64-bit
+- VP9 RTP payload format (draft 0) experimental depacketizer
+- Port MIPS opttimizations to 64-bit
 
 
 version 2.5:

MAINTAINERS

@@ -14,6 +14,7 @@ patches and related discussions.
 Project Leader
 ==============
 
+Michael Niedermayer
   final design decisions
 
 

RELEASE

@@ -1 +1 @@
-2.6.7
+2.5.git

RELEASE_NOTES

@@ -1,65 +0,0 @@
-
-              ┌─────────────────────────────────────────────┐
-              │ RELEASE NOTES for FFmpeg 2.6 "Grothendieck" │
-              └─────────────────────────────────────────────┘
-
-   The FFmpeg Project proudly presents FFmpeg 2.6 "Grothendieck", about 3
-   months after the release of FFmpeg 2.5.
-
-   A lot of important work got in this time, so let's start talking about what
-   we like to brag the most about: features.
-
-   A lot of people will probably be happy to hear that we now have support for
-   NVENC — the Nvidia Video Encoder interface for H.264 encoding — thanks to
-   Timo Rothenpieler, with some little help from NVIDIA and Philip Langdale.
-
-   People in the broadcasting industry might also be interested in the first
-   steps of closed captions support with the introduction of a decoder by
-   Anshul Maheswhwari.
-
-   Regarding filters love, we improved and added many. We could talk about the
-   10-bit support in spp, but maybe it's more important to mention the addition
-   of colorlevels (yet another color handling filter), tblend (allowing you
-   to for example run a diff between successive frames of a video stream), or
-   the dcshift audio filter.
-
-   There are also two other important filters landing in libavfilter: palettegen
-   and paletteuse. Both submitted by the Stupeflix company. These filters will
-   be very useful in case you are looking for creating high quality GIFs, a
-   format that still bravely fights annihilation in 2015.
-
-   There are many other new features, but let's follow-up on one big cleanup
-   achievement: the libmpcodecs (MPlayer filters) wrapper is finally dead. The
-   last remaining filters (softpulldown/repeatfields, eq*, and various
-   postprocessing filters) were ported by Arwa Arif (OPW student) and Paul B
-   Mahol.
-
-   Concerning API changes, there are not many things to mention. Though, the
-   introduction of device inputs and outputs listing by Lukasz Marek is a
-   notable addition (try ffmpeg -sources or ffmpeg -sinks for an example of
-   the usage). As usual, see doc/APIchanges for more information.
-
-   Now let's talk about optimizations. Ronald S. Bultje made the VP9 decoder
-   usable on x86 32-bit systems and pre-ssse3 CPUs like Phenom (even dual core
-   Athlons can play 1080p 30fps VP9 content now), so we now secretly hope for
-   Google and Mozilla to use ffvp9 instead of libvpx. But VP9 is not the
-   center of attention anymore, and HEVC/H.265 is also getting many
-   improvements, which include C and x86 ASM optimizations, mainly from James
-   Almer, Christophe Gisquet and Pierre-Edouard Lepere.
-
-   Even though we had many x86 contributions, it is not the only architecture
-   getting some love, with Seppo Tomperi adding ARM NEON optimizations to the
-   HEVC stack, and James Cowgill adding MIPS64 assembly for all kind of audio
-   processing code in libavcodec.
-
-   And finally, Michael Niedermayer is still fixing many bugs, dealing with
-   most of the boring work such as making releases, applying tons of
-   contributors patches, and daily merging the changes from the Libav project.
-
-   A more 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.

cmdutils_opencl.c

@@ -22,7 +22,6 @@
 #include "libavutil/time.h"
 #include "libavutil/log.h"
 #include "libavutil/opencl.h"
-#include "libavutil/avstring.h"
 #include "cmdutils.h"
 
 typedef struct {
@@ -239,8 +238,7 @@ int opt_opencl_bench(void *optctx, const char *opt, const char *arg)
                 devices[count].platform_idx = i;
                 devices[count].device_idx = j;
                 devices[count].runtime = score;
-                av_strlcpy(devices[count].device_name, device_node->device_name,
-                           sizeof(devices[count].device_name));
+                strcpy(devices[count].device_name, device_node->device_name);
                 count++;
             }
         }

configure

@@ -1769,7 +1769,6 @@ SYSTEM_FUNCS="
 TOOLCHAIN_FEATURES="
     as_dn_directive
     as_func
-    as_object_arch
     asm_mod_q
     attribute_may_alias
     attribute_packed
@@ -2596,8 +2595,6 @@ deshake_filter_select="pixelutils"
 drawtext_filter_deps="libfreetype"
 ebur128_filter_deps="gpl"
 eq_filter_deps="gpl"
-fftfilt_filter_deps="avcodec"
-fftfilt_filter_select="rdft"
 flite_filter_deps="libflite"
 frei0r_filter_deps="frei0r dlopen"
 frei0r_src_filter_deps="frei0r dlopen"
@@ -4563,11 +4560,6 @@ EOF
     check_as <<EOF && enable as_dn_directive
 ra .dn d0.i16
 .unreq ra
-EOF
-
-    # llvm's integrated assembler supports .object_arch from llvm 3.5
-    [ "$objformat" = elf ] && check_as <<EOF && enable as_object_arch
-.object_arch armv4
 EOF
 
     [ $target_os != win32 ] && enabled_all armv6t2 shared !pic && enable_weak_pic
@@ -5459,7 +5451,6 @@ enabled asyncts_filter      && prepend avfilter_deps "avresample"
 enabled atempo_filter       && prepend avfilter_deps "avcodec"
 enabled ebur128_filter && enabled swresample && prepend avfilter_deps "swresample"
 enabled elbg_filter         && prepend avfilter_deps "avcodec"
-enabled fftfilt_filter      && prepend avfilter_deps "avcodec"
 enabled mcdeint_filter      && prepend avfilter_deps "avcodec"
 enabled movie_filter    && prepend avfilter_deps "avformat avcodec"
 enabled pan_filter          && prepend avfilter_deps "swresample"
@@ -5748,7 +5739,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 2016
+#define CONFIG_THIS_YEAR 2015
 #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

@@ -31,7 +31,7 @@ PROJECT_NAME           = FFmpeg
 # This could be handy for archiving the generated documentation or
 # if some version control system is used.
 
-PROJECT_NUMBER         = 2.6.7
+PROJECT_NUMBER         =
 
 # With the PROJECT_LOGO tag one can specify a logo or icon that is included
 # in the documentation. The maximum height of the logo should not exceed 55

doc/examples/demuxing_decoding.c

@@ -81,24 +81,22 @@ static int decode_packet(int *got_frame, int cached)
             fprintf(stderr, "Error decoding video frame (%s)\n", av_err2str(ret));
             return ret;
         }
+        if (video_dec_ctx->width != width || video_dec_ctx->height != height ||
+            video_dec_ctx->pix_fmt != pix_fmt) {
+            /* To handle this change, one could call av_image_alloc again and
+             * decode the following frames into another rawvideo file. */
+            fprintf(stderr, "Error: Width, height and pixel format have to be "
+                    "constant in a rawvideo file, but the width, height or "
+                    "pixel format of the input video changed:\n"
+                    "old: width = %d, height = %d, format = %s\n"
+                    "new: width = %d, height = %d, format = %s\n",
+                    width, height, av_get_pix_fmt_name(pix_fmt),
+                    video_dec_ctx->width, video_dec_ctx->height,
+                    av_get_pix_fmt_name(video_dec_ctx->pix_fmt));
+            return -1;
+        }
 
         if (*got_frame) {
-
-            if (frame->width != width || frame->height != height ||
-                frame->format != pix_fmt) {
-                /* To handle this change, one could call av_image_alloc again and
-                 * decode the following frames into another rawvideo file. */
-                fprintf(stderr, "Error: Width, height and pixel format have to be "
-                        "constant in a rawvideo file, but the width, height or "
-                        "pixel format of the input video changed:\n"
-                        "old: width = %d, height = %d, format = %s\n"
-                        "new: width = %d, height = %d, format = %s\n",
-                        width, height, av_get_pix_fmt_name(pix_fmt),
-                        frame->width, frame->height,
-                        av_get_pix_fmt_name(frame->format));
-                return -1;
-            }
-
             printf("video_frame%s n:%d coded_n:%d pts:%s\n",
                    cached ? "(cached)" : "",
                    video_frame_count++, frame->coded_picture_number,

doc/faq.texi

@@ -349,7 +349,7 @@ FFmpeg has a @url{http://ffmpeg.org/ffmpeg-protocols.html#concat,
 @code{concat}} protocol designed specifically for that, with examples in the
 documentation.
 
-A few multimedia containers (MPEG-1, MPEG-2 PS, DV) allow one to concatenate
+A few multimedia containers (MPEG-1, MPEG-2 PS, DV) allow to concatenate
 video by merely concatenating the files containing them.
 
 Hence you may concatenate your multimedia files by first transcoding them to

doc/ffmpeg.texi

@@ -1175,9 +1175,9 @@ The option is intended for cases where features are needed that cannot be
 specified to @command{ffserver} but can be to @command{ffmpeg}.
 
 @item -sdp_file @var{file} (@emph{global})
-Print sdp information for an output stream to @var{file}.
+Print sdp information to @var{file}.
 This allows dumping sdp information when at least one output isn't an
-rtp stream. (Requires at least one of the output formats to be rtp).
+rtp stream.
 
 @item -discard (@emph{input})
 Allows discarding specific streams or frames of streams at the demuxer.

doc/ffserver.texi

@@ -72,7 +72,7 @@ the HTTP server (configured through the @option{HTTPPort} option), and
 configuration file.
 
 Each feed is associated to a file which is stored on disk. This stored
-file is used to send pre-recorded data to a player as fast as
+file is used to allow to send pre-recorded data to a player as fast as
 possible when new content is added in real-time to the stream.
 
 A "live-stream" or "stream" is a resource published by

doc/fftools-common-opts.texi

@@ -261,14 +261,10 @@ Possible flags for this option are:
 @item sse4.1
 @item sse4.2
 @item avx
-@item avx2
 @item xop
-@item fma3
 @item fma4
 @item 3dnow
 @item 3dnowext
-@item bmi1
-@item bmi2
 @item cmov
 @end table
 @item ARM
@@ -279,13 +275,6 @@ Possible flags for this option are:
 @item vfp
 @item vfpv3
 @item neon
-@item setend
-@end table
-@item AArch64
-@table @samp
-@item armv8
-@item vfp
-@item neon
 @end table
 @item PowerPC
 @table @samp

doc/filters.texi

@@ -3486,7 +3486,7 @@ Set number overlapping pixels for each block. Since the filter can be slow, you
 may want to reduce this value, at the cost of a less effective filter and the
 risk of various artefacts.
 
-If the overlapping value doesn't permit processing the whole input width or
+If the overlapping value doesn't allow to process the whole input width or
 height, a warning will be displayed and according borders won't be denoised.
 
 Default value is @var{blocksize}-1, which is the best possible setting.
@@ -4243,7 +4243,7 @@ within the parameter list.
 @item
 Show the text at the center of the video frame:
 @example
-drawtext="fontsize=30:fontfile=FreeSerif.ttf:text='hello world':x=(w-text_w)/2:y=(h-text_h)/2"
+drawtext="fontsize=30:fontfile=FreeSerif.ttf:text='hello world':x=(w-text_w)/2:y=(h-text_h-line_h)/2"
 @end example
 
 @item

doc/formats.texi

@@ -23,7 +23,7 @@ Reduce buffering.
 
 @item probesize @var{integer} (@emph{input})
 Set probing size in bytes, i.e. the size of the data to analyze to get
-stream information. A higher value will enable detecting more
+stream information. A higher value will allow to detect more
 information in case it is dispersed into the stream, but will increase
 latency. Must be an integer not lesser than 32. It is 5000000 by default.
 
@@ -67,7 +67,7 @@ Default is 0.
 
 @item analyzeduration @var{integer} (@emph{input})
 Specify how many microseconds are analyzed to probe the input. A
-higher value will enable detecting more accurate information, but will
+higher value will allow to detect more accurate information, but will
 increase latency. It defaults to 5,000,000 microseconds = 5 seconds.
 
 @item cryptokey @var{hexadecimal string} (@emph{input})

doc/general.texi

@@ -948,8 +948,8 @@ following image formats are supported:
 @item Musepack SV8           @tab     @tab  X
 @item Nellymoser Asao        @tab  X  @tab  X
 @item On2 AVC (Audio for Video Codec) @tab     @tab  X
-@item Opus                   @tab  E  @tab  X
-    @tab encoding supported through external library libopus
+@item Opus                   @tab  E  @tab  E
+    @tab supported through external library libopus
 @item PCM A-law              @tab  X  @tab  X
 @item PCM mu-law             @tab  X  @tab  X
 @item PCM signed 8-bit planar  @tab  X  @tab  X

doc/indevs.texi

@@ -1,7 +1,7 @@
 @chapter Input Devices
 @c man begin INPUT DEVICES
 
-Input devices are configured elements in FFmpeg which enable accessing
+Input devices are configured elements in FFmpeg which allow to access
 the data coming from a multimedia device attached to your system.
 
 When you configure your FFmpeg build, all the supported input devices
@@ -150,81 +150,6 @@ $ ffmpeg -f avfoundation -pixel_format bgr0 -i "default:none" out.avi
 
 BSD video input device.
 
-@section decklink
-
-The decklink input device provides capture capabilities for Blackmagic
-DeckLink devices.
-
-To enable this input device, you need the Blackmagic DeckLink SDK and you
-need to configure with the appropriate @code{--extra-cflags}
-and @code{--extra-ldflags}.
-On Windows, you need to run the IDL files through @command{widl}.
-
-DeckLink is very picky about the formats it supports. Pixel format is
-uyvy422 or v210, framerate and video size must be determined for your device with
-@command{-list_formats 1}. Audio sample rate is always 48 kHz and the number
-of channels can be 2, 8 or 16.
-
-@subsection Options
-
-@table @option
-
-@item list_devices
-If set to @option{true}, print a list of devices and exit.
-Defaults to @option{false}.
-
-@item list_formats
-If set to @option{true}, print a list of supported formats and exit.
-Defaults to @option{false}.
-
-@item bm_v210
-If set to @samp{1}, video is captured in 10 bit v210 instead
-of uyvy422. Not all Blackmagic devices support this option.
-
-@end table
-
-@subsection Examples
-
-@itemize
-
-@item
-List input devices:
-@example
-ffmpeg -f decklink -list_devices 1 -i dummy
-@end example
-
-@item
-List supported formats:
-@example
-ffmpeg -f decklink -list_formats 1 -i 'Intensity Pro'
-@end example
-
-@item
-Capture video clip at 1080i50 (format 11):
-@example
-ffmpeg -f decklink -i 'Intensity Pro@@11' -acodec copy -vcodec copy output.avi
-@end example
-
-@item
-Capture video clip at 1080i50 10 bit:
-@example
-ffmpeg -bm_v210 1 -f decklink -i 'UltraStudio Mini Recorder@@11' -acodec copy -vcodec copy output.avi
-@end example
-
-@item
-Capture video clip at 720p50 with 32bit audio:
-@example
-ffmpeg -bm_audiodepth 32 -f decklink -i 'UltraStudio Mini Recorder@@14' -acodec copy -vcodec copy output.avi
-@end example
-
-@item
-Capture video clip at 576i50 with 8 audio channels:
-@example
-ffmpeg -bm_channels 8 -f decklink -i 'UltraStudio Mini Recorder@@3' -acodec copy -vcodec copy output.avi
-@end example
-
-@end itemize
-
 @section dshow
 
 Windows DirectShow input device.
@@ -1184,8 +1109,89 @@ The syntax is:
 -grab_x @var{x_offset} -grab_y @var{y_offset}
 @end example
 
-Set the grabbing region coordinates. They are expressed as offset from the top left
+Set the grabing region coordinates. The are expressed as offset from the top left
 corner of the X11 window. The default value is 0.
 
+@section decklink
+
+The decklink input device provides capture capabilities for Blackmagic
+DeckLink devices.
+
+To enable this input device, you need the Blackmagic DeckLink SDK and you
+need to configure with the appropriate @code{--extra-cflags}
+and @code{--extra-ldflags}.
+On Windows, you need to run the IDL files through @command{widl}.
+
+DeckLink is very picky about the formats it supports. Pixel format is
+uyvy422 or v210, framerate and video size must be determined for your device with
+@command{-list_formats 1}. Audio sample rate is always 48 kHz and the number
+of channels can be 2, 8 or 16.
+
+@subsection Options
+
+@table @option
+
+@item list_devices
+If set to @option{true}, print a list of devices and exit.
+Defaults to @option{false}.
+
+@item list_formats
+If set to @option{true}, print a list of supported formats and exit.
+Defaults to @option{false}.
+
+@item bm_v210
+If set to @samp{1}, video is captured in 10 bit v210 instead
+of uyvy422. Not all Blackmagic devices support this option.
+
+@item bm_channels <CHANNELS>
+Number of audio channels, can be 2, 8 or 16
+
+@item bm_audiodepth <BITDEPTH>
+Audio bit depth, can be 16 or 32.
+
+@end table
+
+@subsection Examples
+
+@itemize
+
+@item
+List input devices:
+@example
+ffmpeg -f decklink -list_devices 1 -i dummy
+@end example
+
+@item
+List supported formats:
+@example
+ffmpeg -f decklink -list_formats 1 -i 'Intensity Pro'
+@end example
+
+@item
+Capture video clip at 1080i50 (format 11):
+@example
+ffmpeg -f decklink -i 'Intensity Pro@@11' -acodec copy -vcodec copy output.avi
+@end example
+
+@item
+Capture video clip at 1080i50 10 bit:
+@example
+ffmpeg -bm_v210 1 -f decklink -i 'UltraStudio Mini Recorder@@11' -acodec copy -vcodec copy output.avi
+@end example
+
+@item
+Capture video clip at 720p50 with 32bit audio:
+@example
+ffmpeg -bm_audiodepth 32 -f decklink -i 'UltraStudio Mini Recorder@@14' -acodec copy -vcodec copy output.avi
+@end example
+
+@item
+Capture video clip at 576i50 with 8 audio channels:
+@example
+ffmpeg -bm_channels 8 -f decklink -i 'UltraStudio Mini Recorder@@3' -acodec copy -vcodec copy output.avi
+@end example
+
+@end itemize
+
 
 @c man end INPUT DEVICES

doc/protocols.texi

@@ -63,7 +63,7 @@ cache:@var{URL}
 
 Physical concatenation protocol.
 
-Read and seek from many resources in sequence as if they were
+Allow to read and seek from many resource in sequence as if they were
 a unique resource.
 
 A URL accepted by this protocol has the syntax:
@@ -117,7 +117,7 @@ ffmpeg -i "data:image/gif;base64,R0lGODdhCAAIAMIEAAAAAAAA//8AAP//AP/////////////
 
 File access protocol.
 
-Read from or write to a file.
+Allow to read from or write to a file.
 
 A file URL can have the form:
 @example
@@ -155,7 +155,7 @@ time, which is valuable for files on slow medium.
 
 FTP (File Transfer Protocol).
 
-Read from or write to remote resources using FTP protocol.
+Allow to read from or write to remote resources using FTP protocol.
 
 Following syntax is required.
 @example
@@ -374,7 +374,7 @@ be seekable, so they will fail with the MD5 output protocol.
 
 UNIX pipe access protocol.
 
-Read and write from UNIX pipes.
+Allow to read and write from UNIX pipes.
 
 The accepted syntax is:
 @example
@@ -614,7 +614,7 @@ For more information see: @url{http://www.samba.org/}.
 
 Secure File Transfer Protocol via libssh
 
-Read from or write to remote resources using SFTP protocol.
+Allow to read from or write to remote resources using SFTP protocol.
 
 Following syntax is required.
 

doc/utils.texi

@@ -844,7 +844,7 @@ Return 1.0 if @var{x} is +/-INFINITY, 0.0 otherwise.
 Return 1.0 if @var{x} is NAN, 0.0 otherwise.
 
 @item ld(var)
-Load the value of the internal variable with number
+Allow to load the value of the internal variable with number
 @var{var}, which was previously stored with st(@var{var}, @var{expr}).
 The function returns the loaded value.
 
@@ -912,7 +912,7 @@ Compute the square root of @var{expr}. This is equivalent to
 Compute expression @code{1/(1 + exp(4*x))}.
 
 @item st(var, expr)
-Store the value of the expression @var{expr} in an internal
+Allow to store the value of the expression @var{expr} in an internal
 variable. @var{var} specifies the number of the variable where to
 store the value, and it is a value ranging from 0 to 9. The function
 returns the value stored in the internal variable.

ffmpeg.c

@@ -351,6 +351,7 @@ void term_init(void)
         signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
     }
 #endif
+    avformat_network_deinit();
 
     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).    */
     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
@@ -455,10 +456,7 @@ static void ffmpeg_cleanup(int ret)
     /* close files */
     for (i = 0; i < nb_output_files; i++) {
         OutputFile *of = output_files[i];
-        AVFormatContext *s;
-        if (!of)
-            continue;
-        s = of->ctx;
+        AVFormatContext *s = of->ctx;
         if (s && s->oformat && !(s->oformat->flags & AVFMT_NOFILE))
             avio_closep(&s->pb);
         avformat_free_context(s);
@@ -468,12 +466,7 @@ static void ffmpeg_cleanup(int ret)
     }
     for (i = 0; i < nb_output_streams; i++) {
         OutputStream *ost = output_streams[i];
-        AVBitStreamFilterContext *bsfc;
-
-        if (!ost)
-            continue;
-
-        bsfc = ost->bitstream_filters;
+        AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
         while (bsfc) {
             AVBitStreamFilterContext *next = bsfc->next;
             av_bitstream_filter_close(bsfc);
@@ -657,7 +650,6 @@ static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
             if (!new_pkt.buf)
                 exit_program(1);
         } else if (a < 0) {
-            new_pkt = *pkt;
             av_log(NULL, AV_LOG_ERROR, "Failed to open bitstream filter %s for stream %d with codec %s",
                    bsfc->filter->name, pkt->stream_index,
                    avctx->codec ? avctx->codec->name : "copy");
@@ -1164,10 +1156,7 @@ static void do_video_out(AVFormatContext *s,
     if (!ost->last_frame)
         ost->last_frame = av_frame_alloc();
     av_frame_unref(ost->last_frame);
-    if (next_picture && ost->last_frame)
-        av_frame_ref(ost->last_frame, next_picture);
-    else
-        av_frame_free(&ost->last_frame);
+    av_frame_ref(ost->last_frame, next_picture);
 }
 
 static double psnr(double d)
@@ -1767,21 +1756,17 @@ static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *p
 
     opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
     opkt.flags    = pkt->flags;
+
     // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
-    if (  ost->st->codec->codec_id != AV_CODEC_ID_H264
-       && ost->st->codec->codec_id != AV_CODEC_ID_MPEG1VIDEO
-       && ost->st->codec->codec_id != AV_CODEC_ID_MPEG2VIDEO
-       && ost->st->codec->codec_id != AV_CODEC_ID_VC1
+    if (  ost->enc_ctx->codec_id != AV_CODEC_ID_H264
+       && ost->enc_ctx->codec_id != AV_CODEC_ID_MPEG1VIDEO
+       && ost->enc_ctx->codec_id != AV_CODEC_ID_MPEG2VIDEO
+       && ost->enc_ctx->codec_id != AV_CODEC_ID_VC1
        ) {
-        int ret = av_parser_change(ost->parser, ost->st->codec,
+        if (av_parser_change(ost->parser, ost->st->codec,
                              &opkt.data, &opkt.size,
                              pkt->data, pkt->size,
-                             pkt->flags & AV_PKT_FLAG_KEY);
-        if (ret < 0) {
-            av_log(NULL, AV_LOG_FATAL, "av_parser_change failed\n");
-            exit_program(1);
-        }
-        if (ret) {
+                             pkt->flags & AV_PKT_FLAG_KEY)) {
             opkt.buf = av_buffer_create(opkt.data, opkt.size, av_buffer_default_free, NULL, 0);
             if (!opkt.buf)
                 exit_program(1);
@@ -1792,15 +1777,9 @@ static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *p
     }
     av_copy_packet_side_data(&opkt, pkt);
 
-    if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
-        ost->st->codec->codec_id == AV_CODEC_ID_RAWVIDEO &&
-        (of->ctx->oformat->flags & AVFMT_RAWPICTURE)) {
+    if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (of->ctx->oformat->flags & AVFMT_RAWPICTURE)) {
         /* store AVPicture in AVPacket, as expected by the output format */
-        int ret = avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
-        if (ret < 0) {
-            av_log(NULL, AV_LOG_FATAL, "avpicture_fill failed\n");
-            exit_program(1);
-        }
+        avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
         opkt.data = (uint8_t *)&pict;
         opkt.size = sizeof(AVPicture);
         opkt.flags |= AV_PKT_FLAG_KEY;
@@ -1851,12 +1830,9 @@ static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
         ret = AVERROR_INVALIDDATA;
     }
 
-    if (*got_output || ret<0)
+    if (*got_output || ret<0 || pkt->size)
         decode_error_stat[ret<0] ++;
 
-    if (ret < 0 && exit_on_error)
-        exit_program(1);
-
     if (!*got_output || ret < 0) {
         if (!pkt->size) {
             for (i = 0; i < ist->nb_filters; i++)
@@ -1999,12 +1975,9 @@ static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
             );
     }
 
-    if (*got_output || ret<0)
+    if (*got_output || ret<0 || pkt->size)
         decode_error_stat[ret<0] ++;
 
-    if (ret < 0 && exit_on_error)
-        exit_program(1);
-
     if (*got_output && ret >= 0) {
         if (ist->dec_ctx->width  != decoded_frame->width ||
             ist->dec_ctx->height != decoded_frame->height ||
@@ -2120,12 +2093,9 @@ static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
     int i, ret = avcodec_decode_subtitle2(ist->dec_ctx,
                                           &subtitle, got_output, pkt);
 
-    if (*got_output || ret<0)
+    if (*got_output || ret<0 || pkt->size)
         decode_error_stat[ret<0] ++;
 
-    if (ret < 0 && exit_on_error)
-        exit_program(1);
-
     if (ret < 0 || !*got_output) {
         if (!pkt->size)
             sub2video_flush(ist);
@@ -2337,9 +2307,6 @@ static void print_sdp(void)
         }
     }
 
-    if (!j)
-        goto fail;
-
     av_sdp_create(avc, j, sdp, sizeof(sdp));
 
     if (!sdp_filename) {
@@ -2355,7 +2322,6 @@ static void print_sdp(void)
         }
     }
 
-fail:
     av_freep(&avc);
 }
 
@@ -2700,13 +2666,11 @@ static int transcode_init(void)
             enc_ctx->rc_max_rate    = dec_ctx->rc_max_rate;
             enc_ctx->rc_buffer_size = dec_ctx->rc_buffer_size;
             enc_ctx->field_order    = dec_ctx->field_order;
-            if (dec_ctx->extradata_size) {
-                enc_ctx->extradata      = av_mallocz(extra_size);
-                if (!enc_ctx->extradata) {
-                    return AVERROR(ENOMEM);
-                }
-                memcpy(enc_ctx->extradata, dec_ctx->extradata, dec_ctx->extradata_size);
+            enc_ctx->extradata      = av_mallocz(extra_size);
+            if (!enc_ctx->extradata) {
+                return AVERROR(ENOMEM);
             }
+            memcpy(enc_ctx->extradata, dec_ctx->extradata, dec_ctx->extradata_size);
             enc_ctx->extradata_size= dec_ctx->extradata_size;
             enc_ctx->bits_per_coded_sample  = dec_ctx->bits_per_coded_sample;
 

ffmpeg_opt.c

@@ -2282,9 +2282,9 @@ static int opt_target(void *optctx, const char *opt, const char *arg)
         opt_default(NULL, "g", norm == PAL ? "15" : "18");
 
         opt_default(NULL, "b:v", "1150000");
-        opt_default(NULL, "maxrate:v", "1150000");
-        opt_default(NULL, "minrate:v", "1150000");
-        opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
+        opt_default(NULL, "maxrate", "1150000");
+        opt_default(NULL, "minrate", "1150000");
+        opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
 
         opt_default(NULL, "b:a", "224000");
         parse_option(o, "ar", "44100", options);
@@ -2311,9 +2311,9 @@ static int opt_target(void *optctx, const char *opt, const char *arg)
         opt_default(NULL, "g", norm == PAL ? "15" : "18");
 
         opt_default(NULL, "b:v", "2040000");
-        opt_default(NULL, "maxrate:v", "2516000");
-        opt_default(NULL, "minrate:v", "0"); // 1145000;
-        opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
+        opt_default(NULL, "maxrate", "2516000");
+        opt_default(NULL, "minrate", "0"); // 1145000;
+        opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
         opt_default(NULL, "scan_offset", "1");
 
         opt_default(NULL, "b:a", "224000");
@@ -2333,9 +2333,9 @@ static int opt_target(void *optctx, const char *opt, const char *arg)
         opt_default(NULL, "g", norm == PAL ? "15" : "18");
 
         opt_default(NULL, "b:v", "6000000");
-        opt_default(NULL, "maxrate:v", "9000000");
-        opt_default(NULL, "minrate:v", "0"); // 1500000;
-        opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
+        opt_default(NULL, "maxrate", "9000000");
+        opt_default(NULL, "minrate", "0"); // 1500000;
+        opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
 
         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
@@ -2379,9 +2379,6 @@ static int opt_vstats(void *optctx, const char *opt, const char *arg)
     time_t today2 = time(NULL);
     struct tm *today = localtime(&today2);
 
-    if (!today)
-        return AVERROR(errno);
-
     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
              today->tm_sec);
     return opt_vstats_file(NULL, opt, filename);
@@ -2862,7 +2859,7 @@ const OptionDef options[] = {
     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
         "set the input ts scale", "scale" },
-    { "timestamp",      HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_recording_timestamp },
+    { "timestamp",      HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_recording_timestamp },
         "set the recording timestamp ('now' to set the current time)", "time" },
     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
         "add metadata", "string=string" },

ffmpeg_vda.c

@@ -77,8 +77,6 @@ static int vda_retrieve_data(AVCodecContext *s, AVFrame *frame)
                   frame->width, frame->height);
 
     ret = av_frame_copy_props(vda->tmp_frame, frame);
-    CVPixelBufferUnlockBaseAddress(pixbuf, kCVPixelBufferLock_ReadOnly);
-
     if (ret < 0)
         return ret;
 

libavcodec/012v.c

@@ -38,15 +38,15 @@ static av_cold int zero12v_decode_init(AVCodecContext *avctx)
 static int zero12v_decode_frame(AVCodecContext *avctx, void *data,
                                 int *got_frame, AVPacket *avpkt)
 {
-    int line, ret;
+    int line = 0, ret;
     const int width = avctx->width;
     AVFrame *pic = data;
     uint16_t *y, *u, *v;
     const uint8_t *line_end, *src = avpkt->data;
     int stride = avctx->width * 8 / 3;
 
-    if (width <= 1 || avctx->height <= 0) {
-        av_log(avctx, AV_LOG_ERROR, "Dimensions %dx%d not supported.\n", width, avctx->height);
+    if (width == 1) {
+        av_log(avctx, AV_LOG_ERROR, "Width 1 not supported.\n");
         return AVERROR_INVALIDDATA;
     }
 
@@ -67,45 +67,45 @@ static int zero12v_decode_frame(AVCodecContext *avctx, void *data,
     pic->pict_type = AV_PICTURE_TYPE_I;
     pic->key_frame = 1;
 
+    y = (uint16_t *)pic->data[0];
+    u = (uint16_t *)pic->data[1];
+    v = (uint16_t *)pic->data[2];
     line_end = avpkt->data + stride;
-    for (line = 0; line < avctx->height; line++) {
-        uint16_t y_temp[6] = {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000};
-        uint16_t u_temp[3] = {0x8000, 0x8000, 0x8000};
-        uint16_t v_temp[3] = {0x8000, 0x8000, 0x8000};
-        int x;
-        y = (uint16_t *)(pic->data[0] + line * pic->linesize[0]);
-        u = (uint16_t *)(pic->data[1] + line * pic->linesize[1]);
-        v = (uint16_t *)(pic->data[2] + line * pic->linesize[2]);
 
-        for (x = 0; x < width; x += 6) {
-            uint32_t t;
-
-            if (width - x < 6 || line_end - src < 16) {
-                y = y_temp;
-                u = u_temp;
-                v = v_temp;
-            }
-
-            if (line_end - src < 4)
-                break;
-
-            t = AV_RL32(src);
+    while (line++ < avctx->height) {
+        while (1) {
+            uint32_t t = AV_RL32(src);
             src += 4;
             *u++ = t <<  6 & 0xFFC0;
             *y++ = t >>  4 & 0xFFC0;
             *v++ = t >> 14 & 0xFFC0;
 
-            if (line_end - src < 4)
+            if (src >= line_end - 1) {
+                *y = 0x80;
+                src++;
+                line_end += stride;
+                y = (uint16_t *)(pic->data[0] + line * pic->linesize[0]);
+                u = (uint16_t *)(pic->data[1] + line * pic->linesize[1]);
+                v = (uint16_t *)(pic->data[2] + line * pic->linesize[2]);
                 break;
+            }
 
             t = AV_RL32(src);
             src += 4;
             *y++ = t <<  6 & 0xFFC0;
             *u++ = t >>  4 & 0xFFC0;
             *y++ = t >> 14 & 0xFFC0;
-
-            if (line_end - src < 4)
+            if (src >= line_end - 2) {
+                if (!(width & 1)) {
+                    *y = 0x80;
+                    src += 2;
+                }
+                line_end += stride;
+                y = (uint16_t *)(pic->data[0] + line * pic->linesize[0]);
+                u = (uint16_t *)(pic->data[1] + line * pic->linesize[1]);
+                v = (uint16_t *)(pic->data[2] + line * pic->linesize[2]);
                 break;
+            }
 
             t = AV_RL32(src);
             src += 4;
@@ -113,8 +113,15 @@ static int zero12v_decode_frame(AVCodecContext *avctx, void *data,
             *y++ = t >>  4 & 0xFFC0;
             *u++ = t >> 14 & 0xFFC0;
 
-            if (line_end - src < 4)
+            if (src >= line_end - 1) {
+                *y = 0x80;
+                src++;
+                line_end += stride;
+                y = (uint16_t *)(pic->data[0] + line * pic->linesize[0]);
+                u = (uint16_t *)(pic->data[1] + line * pic->linesize[1]);
+                v = (uint16_t *)(pic->data[2] + line * pic->linesize[2]);
                 break;
+            }
 
             t = AV_RL32(src);
             src += 4;
@@ -122,21 +129,18 @@ static int zero12v_decode_frame(AVCodecContext *avctx, void *data,
             *v++ = t >>  4 & 0xFFC0;
             *y++ = t >> 14 & 0xFFC0;
 
-            if (width - x < 6)
+            if (src >= line_end - 2) {
+                if (width & 1) {
+                    *y = 0x80;
+                    src += 2;
+                }
+                line_end += stride;
+                y = (uint16_t *)(pic->data[0] + line * pic->linesize[0]);
+                u = (uint16_t *)(pic->data[1] + line * pic->linesize[1]);
+                v = (uint16_t *)(pic->data[2] + line * pic->linesize[2]);
                 break;
+            }
         }
-
-        if (x < width) {
-            y = x   + (uint16_t *)(pic->data[0] + line * pic->linesize[0]);
-            u = x/2 + (uint16_t *)(pic->data[1] + line * pic->linesize[1]);
-            v = x/2 + (uint16_t *)(pic->data[2] + line * pic->linesize[2]);
-            memcpy(y, y_temp, sizeof(*y) * (width - x));
-            memcpy(u, u_temp, sizeof(*u) * (width - x + 1) / 2);
-            memcpy(v, v_temp, sizeof(*v) * (width - x + 1) / 2);
-        }
-
-        line_end += stride;
-        src = line_end - stride;
     }
 
     *got_frame = 1;

libavcodec/Makefile

@@ -217,7 +217,7 @@ OBJS-$(CONFIG_DVVIDEO_DECODER)         += dvdec.o dv.o dvdata.o
 OBJS-$(CONFIG_DVVIDEO_ENCODER)         += dvenc.o dv.o dvdata.o
 OBJS-$(CONFIG_DXA_DECODER)             += dxa.o
 OBJS-$(CONFIG_DXTORY_DECODER)          += dxtory.o
-OBJS-$(CONFIG_EAC3_DECODER)            += eac3_data.o
+OBJS-$(CONFIG_EAC3_DECODER)            += eac3dec.o eac3_data.o
 OBJS-$(CONFIG_EAC3_ENCODER)            += eac3enc.o eac3_data.o
 OBJS-$(CONFIG_EACMV_DECODER)           += eacmv.o
 OBJS-$(CONFIG_EAMAD_DECODER)           += eamad.o eaidct.o mpeg12.o \

libavcodec/aaccoder.c

@@ -691,7 +691,7 @@ static void search_for_quantizers_anmr(AVCodecContext *avctx, AACEncContext *s,
     }
     while (idx) {
         sce->sf_idx[bandaddr[idx]] = minq + q0;
-        minq = FFMAX(paths[idx][minq].prev, 0);
+        minq = paths[idx][minq].prev;
         idx--;
     }
     //set the same quantizers inside window groups

libavcodec/aacdec.c

@@ -424,7 +424,7 @@ 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 void push_output_configuration(AACContext *ac) {
-    if (ac->oc[1].status == OC_LOCKED || ac->oc[0].status == OC_NONE) {
+    if (ac->oc[1].status == OC_LOCKED) {
         ac->oc[0] = ac->oc[1];
     }
     ac->oc[1].status = OC_NONE;
@@ -900,7 +900,7 @@ static int decode_eld_specific_config(AACContext *ac, AVCodecContext *avctx,
         if (len == 15 + 255)
             len += get_bits(gb, 16);
         if (get_bits_left(gb) < len * 8 + 4) {
-            av_log(avctx, AV_LOG_ERROR, overread_err);
+            av_log(ac->avctx, AV_LOG_ERROR, overread_err);
             return AVERROR_INVALIDDATA;
         }
         skip_bits_long(gb, 8 * len);
@@ -2919,11 +2919,6 @@ static int aac_decode_er_frame(AVCodecContext *avctx, void *data,
 
     spectral_to_sample(ac);
 
-    if (!ac->frame->data[0] && samples) {
-        av_log(avctx, AV_LOG_ERROR, "no frame data found\n");
-        return AVERROR_INVALIDDATA;
-    }
-
     ac->frame->nb_samples = samples;
     ac->frame->sample_rate = avctx->sample_rate;
     *got_frame_ptr = 1;
@@ -3078,12 +3073,6 @@ static int aac_decode_frame_int(AVCodecContext *avctx, void *data,
             AV_WL32(side, 2*AV_RL32(side));
     }
 
-    if (!ac->frame->data[0] && samples) {
-        av_log(avctx, AV_LOG_ERROR, "no frame data found\n");
-        err = AVERROR_INVALIDDATA;
-        goto fail;
-    }
-
     *got_frame_ptr = !!samples;
     if (samples) {
         ac->frame->nb_samples = samples;
@@ -3153,7 +3142,7 @@ static int aac_decode_frame(AVCodecContext *avctx, void *data,
     if (INT_MAX / 8 <= buf_size)
         return AVERROR_INVALIDDATA;
 
-    if ((err = init_get_bits8(&gb, buf, buf_size)) < 0)
+    if ((err = init_get_bits(&gb, buf, buf_size * 8)) < 0)
         return err;
 
     switch (ac->oc[1].m4ac.object_type) {

libavcodec/aacpsy.c

@@ -313,7 +313,7 @@ static av_cold int psy_3gpp_init(FFPsyContext *ctx) {
     ctx->bitres.size   = 6144 - pctx->frame_bits;
     ctx->bitres.size  -= ctx->bitres.size % 8;
     pctx->fill_level   = ctx->bitres.size;
-    minath = ath(3410 - 0.733 * ATH_ADD, ATH_ADD);
+    minath = ath(3410, ATH_ADD);
     for (j = 0; j < 2; j++) {
         AacPsyCoeffs *coeffs = pctx->psy_coef[j];
         const uint8_t *band_sizes = ctx->bands[j];
@@ -727,10 +727,7 @@ static void psy_3gpp_analyze_channel(FFPsyContext *ctx, int channel,
                     if (active_lines > 0.0f)
                         band->thr = calc_reduced_thr_3gpp(band, coeffs[g].min_snr, reduction);
                     pe += calc_pe_3gpp(band);
-                    if (band->thr > 0.0f)
-                        band->norm_fac = band->active_lines / band->thr;
-                    else
-                        band->norm_fac = 0.0f;
+                    band->norm_fac = band->active_lines / band->thr;
                     norm_fac += band->norm_fac;
                 }
             }

libavcodec/aacsbr.c

@@ -514,7 +514,7 @@ static int sbr_make_f_master(AACContext *ac, SpectralBandReplication *sbr,
 /// High Frequency Generation - Patch Construction (14496-3 sp04 p216 fig. 4.46)
 static int sbr_hf_calc_npatches(AACContext *ac, SpectralBandReplication *sbr)
 {
-    int i, k, last_k = -1, last_msb = -1, sb = 0;
+    int i, k, sb = 0;
     int msb = sbr->k[0];
     int usb = sbr->kx[1];
     int goal_sb = ((1000 << 11) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
@@ -528,12 +528,6 @@ static int sbr_hf_calc_npatches(AACContext *ac, SpectralBandReplication *sbr)
 
     do {
         int odd = 0;
-        if (k == last_k && msb == last_msb) {
-            av_log(ac->avctx, AV_LOG_ERROR, "patch construction failed\n");
-            return AVERROR_INVALIDDATA;
-        }
-        last_k = k;
-        last_msb = msb;
         for (i = k; i == k || sb > (sbr->k[0] - 1 + msb - odd); i--) {
             sb = sbr->f_master[i];
             odd = (sb + sbr->k[0]) & 1;
@@ -1018,8 +1012,6 @@ static unsigned int read_sbr_data(AACContext *ac, SpectralBandReplication *sbr,
 {
     unsigned int cnt = get_bits_count(gb);
 
-    sbr->id_aac = id_aac;
-
     if (id_aac == TYPE_SCE || id_aac == TYPE_CCE) {
         if (read_sbr_single_channel_element(ac, sbr, gb)) {
             sbr_turnoff(sbr);
@@ -1696,12 +1688,6 @@ void ff_sbr_apply(AACContext *ac, SpectralBandReplication *sbr, int id_aac,
     int nch = (id_aac == TYPE_CPE) ? 2 : 1;
     int err;
 
-    if (id_aac != sbr->id_aac) {
-        av_log(ac->avctx, AV_LOG_ERROR,
-            "element type mismatch %d != %d\n", id_aac, sbr->id_aac);
-        sbr_turnoff(sbr);
-    }
-
     if (!sbr->kx_and_m_pushed) {
         sbr->kx[0] = sbr->kx[1];
         sbr->m[0] = sbr->m[1];
@@ -1725,7 +1711,6 @@ void ff_sbr_apply(AACContext *ac, SpectralBandReplication *sbr, int id_aac,
             sbr->c.sbr_hf_inverse_filter(&sbr->dsp, sbr->alpha0, sbr->alpha1,
                                          (const float (*)[40][2]) sbr->X_low, sbr->k[0]);
             sbr_chirp(sbr, &sbr->data[ch]);
-            av_assert0(sbr->data[ch].bs_num_env > 0);
             sbr_hf_gen(ac, sbr, sbr->X_high,
                        (const float (*)[40][2]) sbr->X_low,
                        (const float (*)[2]) sbr->alpha0,

libavcodec/aasc.c

@@ -137,7 +137,7 @@ static int aasc_decode_frame(AVCodecContext *avctx,
         return ret;
 
     /* report that the buffer was completely consumed */
-    return avpkt->size;
+    return buf_size;
 }
 
 static av_cold int aasc_decode_end(AVCodecContext *avctx)

libavcodec/ac3.c

@@ -131,9 +131,6 @@ int ff_ac3_bit_alloc_calc_mask(AC3BitAllocParameters *s, int16_t *band_psd,
     int band_start, band_end, begin, end1;
     int lowcomp, fastleak, slowleak;
 
-    if (end <= 0)
-        return AVERROR_INVALIDDATA;
-
     /* excitation function */
     band_start = ff_ac3_bin_to_band_tab[start];
     band_end   = ff_ac3_bin_to_band_tab[end-1] + 1;

libavcodec/ac3dec.c

@@ -872,7 +872,7 @@ static int decode_audio_block(AC3DecodeContext *s, int blk)
                 start_subband += start_subband - 7;
             end_subband    = get_bits(gbc, 3) + 5;
 #if USE_FIXED
-            s->spx_dst_end_freq = end_freq_inv_tab[end_subband-5];
+            s->spx_dst_end_freq = end_freq_inv_tab[end_subband];
 #endif
             if (end_subband   > 7)
                 end_subband   += end_subband   - 7;
@@ -939,7 +939,7 @@ static int decode_audio_block(AC3DecodeContext *s, int blk)
                             nblend = 0;
                             sblend = 0x800000;
                         } else if (nratio > 0x7fffff) {
-                            nblend = 14529495; // sqrt(3) in FP.23
+                            nblend = 0x800000;
                             sblend = 0;
                         } else {
                             nblend = fixed_sqrt(nratio, 23);

libavcodec/ac3dec.h

@@ -243,19 +243,19 @@ typedef struct AC3DecodeContext {
  * Parse the E-AC-3 frame header.
  * This parses both the bit stream info and audio frame header.
  */
-static int ff_eac3_parse_header(AC3DecodeContext *s);
+int ff_eac3_parse_header(AC3DecodeContext *s);
 
 /**
  * Decode mantissas in a single channel for the entire frame.
  * This is used when AHT mode is enabled.
  */
-static void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch);
+void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch);
 
 /**
  * Apply spectral extension to each channel by copying lower frequency
  * coefficients to higher frequency bins and applying side information to
  * approximate the original high frequency signal.
  */
-static void ff_eac3_apply_spectral_extension(AC3DecodeContext *s);
+void ff_eac3_apply_spectral_extension(AC3DecodeContext *s);
 
 #endif /* AVCODEC_AC3DEC_H */

libavcodec/ac3dec_fixed.c

@@ -164,7 +164,6 @@ static void ac3_downmix_c_fixed16(int16_t **samples, int16_t (*matrix)[2],
     }
 }
 
-#include "eac3dec.c"
 #include "ac3dec.c"
 
 static const AVOption options[] = {

libavcodec/ac3dec_float.c

@@ -28,7 +28,6 @@
  * Upmix delay samples from stereo to original channel layout.
  */
 #include "ac3dec.h"
-#include "eac3dec.c"
 #include "ac3dec.c"
 
 static const AVOption options[] = {

libavcodec/adpcm.c

@@ -578,8 +578,6 @@ static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb,
     case AV_CODEC_ID_ADPCM_IMA_DK4:
         if (avctx->block_align > 0)
             buf_size = FFMIN(buf_size, avctx->block_align);
-        if (buf_size < 4 * ch)
-            return AVERROR_INVALIDDATA;
         nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch;
         break;
     case AV_CODEC_ID_ADPCM_IMA_RAD:
@@ -593,15 +591,13 @@ static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb,
         int bsamples = ff_adpcm_ima_block_samples[avctx->bits_per_coded_sample - 2];
         if (avctx->block_align > 0)
             buf_size = FFMIN(buf_size, avctx->block_align);
-        if (buf_size < 4 * ch)
-            return AVERROR_INVALIDDATA;
         nb_samples = 1 + (buf_size - 4 * ch) / (bsize * ch) * bsamples;
         break;
     }
     case AV_CODEC_ID_ADPCM_MS:
         if (avctx->block_align > 0)
             buf_size = FFMIN(buf_size, avctx->block_align);
-        nb_samples = (buf_size - 6 * ch) * 2 / ch;
+        nb_samples = 2 + (buf_size - 7 * ch) * 2 / ch;
         break;
     case AV_CODEC_ID_ADPCM_SBPRO_2:
     case AV_CODEC_ID_ADPCM_SBPRO_3:
@@ -614,8 +610,6 @@ static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb,
         case AV_CODEC_ID_ADPCM_SBPRO_4: samples_per_byte = 2; break;
         }
         if (!s->status[0].step_index) {
-            if (buf_size < ch)
-                return AVERROR_INVALIDDATA;
             nb_samples++;
             buf_size -= ch;
         }
@@ -1534,11 +1528,6 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
 
     *got_frame_ptr = 1;
 
-    if (avpkt->size < bytestream2_tell(&gb)) {
-        av_log(avctx, AV_LOG_ERROR, "Overread of %d < %d\n", avpkt->size, bytestream2_tell(&gb));
-        return avpkt->size;
-    }
-
     return bytestream2_tell(&gb);
 }
 

libavcodec/alac.c

@@ -316,11 +316,6 @@ static int decode_element(AVCodecContext *avctx, AVFrame *frame, int ch_index,
         int lpc_quant[2];
         int rice_history_mult[2];
 
-        if (!alac->rice_limit) {
-            avpriv_request_sample(alac->avctx, "Compression with rice limit 0");
-            return AVERROR(ENOSYS);
-        }
-
         decorr_shift       = get_bits(&alac->gb, 8);
         decorr_left_weight = get_bits(&alac->gb, 8);
 
@@ -533,12 +528,6 @@ static int allocate_buffers(ALACContext *alac)
     int ch;
     int buf_size = alac->max_samples_per_frame * sizeof(int32_t);
 
-    for (ch = 0; ch < 2; ch++) {
-        alac->predict_error_buffer[ch]  = NULL;
-        alac->output_samples_buffer[ch] = NULL;
-        alac->extra_bits_buffer[ch]     = NULL;
-    }
-
     for (ch = 0; ch < FFMIN(alac->channels, 2); ch++) {
         FF_ALLOC_OR_GOTO(alac->avctx, alac->predict_error_buffer[ch],
                          buf_size, buf_alloc_fail);

libavcodec/alsdec.c

@@ -357,15 +357,11 @@ static av_cold int read_specific_config(ALSDecContext *ctx)
 
         ctx->cs_switch = 1;
 
-        for (i = 0; i < avctx->channels; i++) {
-            sconf->chan_pos[i] = -1;
-        }
-
         for (i = 0; i < avctx->channels; i++) {
             int idx;
 
             idx = get_bits(&gb, chan_pos_bits);
-            if (idx >= avctx->channels || sconf->chan_pos[idx] != -1) {
+            if (idx >= avctx->channels) {
                 av_log(avctx, AV_LOG_WARNING, "Invalid channel reordering.\n");
                 ctx->cs_switch = 0;
                 break;
@@ -682,7 +678,7 @@ static int read_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
 
 
     if (!sconf->rlslms) {
-        if (sconf->adapt_order && sconf->max_order) {
+        if (sconf->adapt_order) {
             int opt_order_length = av_ceil_log2(av_clip((bd->block_length >> 3) - 1,
                                                 2, sconf->max_order + 1));
             *bd->opt_order       = get_bits(gb, opt_order_length);
@@ -1246,7 +1242,6 @@ static int revert_channel_correlation(ALSDecContext *ctx, ALSBlockData *bd,
     ALSChannelData *ch = cd[c];
     unsigned int   dep = 0;
     unsigned int channels = ctx->avctx->channels;
-    unsigned int channel_size = ctx->sconf.frame_length + ctx->sconf.max_order;
 
     if (reverted[c])
         return 0;
@@ -1277,9 +1272,9 @@ static int revert_channel_correlation(ALSDecContext *ctx, ALSBlockData *bd,
     bd->raw_samples = ctx->raw_samples[c] + offset;
 
     for (dep = 0; !ch[dep].stop_flag; dep++) {
-        ptrdiff_t smp;
-        ptrdiff_t begin = 1;
-        ptrdiff_t end   = bd->block_length - 1;
+        unsigned int smp;
+        unsigned int begin = 1;
+        unsigned int end   = bd->block_length - 1;
         int64_t y;
         int32_t *master = ctx->raw_samples[ch[dep].master_channel] + offset;
 
@@ -1291,28 +1286,11 @@ static int revert_channel_correlation(ALSDecContext *ctx, ALSBlockData *bd,
 
             if (ch[dep].time_diff_sign) {
                 t      = -t;
-                if (begin < t) {
-                    av_log(ctx->avctx, AV_LOG_ERROR, "begin %td smaller than time diff index %d.\n", begin, t);
-                    return AVERROR_INVALIDDATA;
-                }
                 begin -= t;
             } else {
-                if (end < t) {
-                    av_log(ctx->avctx, AV_LOG_ERROR, "end %td smaller than time diff index %d.\n", end, t);
-                    return AVERROR_INVALIDDATA;
-                }
                 end   -= t;
             }
 
-            if (FFMIN(begin - 1, begin - 1 + t) < ctx->raw_buffer - master ||
-                FFMAX(end   + 1,   end + 1 + t) > ctx->raw_buffer + channels * channel_size - master) {
-                av_log(ctx->avctx, AV_LOG_ERROR,
-                       "sample pointer range [%p, %p] not contained in raw_buffer [%p, %p].\n",
-                       master + FFMIN(begin - 1, begin - 1 + t), master + FFMAX(end + 1,   end + 1 + t),
-                       ctx->raw_buffer, ctx->raw_buffer + channels * channel_size);
-                return AVERROR_INVALIDDATA;
-            }
-
             for (smp = begin; smp < end; smp++) {
                 y  = (1 << 6) +
                      MUL64(ch[dep].weighting[0], master[smp - 1    ]) +
@@ -1325,16 +1303,6 @@ static int revert_channel_correlation(ALSDecContext *ctx, ALSBlockData *bd,
                 bd->raw_samples[smp] += y >> 7;
             }
         } else {
-
-            if (begin - 1 < ctx->raw_buffer - master ||
-                end   + 1 > ctx->raw_buffer + channels * channel_size - master) {
-                av_log(ctx->avctx, AV_LOG_ERROR,
-                       "sample pointer range [%p, %p] not contained in raw_buffer [%p, %p].\n",
-                       master + begin - 1, master + end + 1,
-                       ctx->raw_buffer, ctx->raw_buffer + channels * channel_size);
-                return AVERROR_INVALIDDATA;
-            }
-
             for (smp = begin; smp < end; smp++) {
                 y  = (1 << 6) +
                      MUL64(ch[dep].weighting[0], master[smp - 1]) +
@@ -1493,11 +1461,6 @@ static int read_frame_data(ALSDecContext *ctx, unsigned int ra_frame)
 
     // TODO: read_diff_float_data
 
-    if (get_bits_left(gb) < 0) {
-        av_log(ctx->avctx, AV_LOG_ERROR, "Overread %d\n", -get_bits_left(gb));
-        return AVERROR_INVALIDDATA;
-    }
-
     return 0;
 }
 
@@ -1703,12 +1666,6 @@ static av_cold int decode_init(AVCodecContext *avctx)
         avctx->sample_fmt          = sconf->resolution > 1
                                      ? AV_SAMPLE_FMT_S32 : AV_SAMPLE_FMT_S16;
         avctx->bits_per_raw_sample = (sconf->resolution + 1) * 8;
-        if (avctx->bits_per_raw_sample > 32) {
-            av_log(avctx, AV_LOG_ERROR, "Bits per raw sample %d larger than 32.\n",
-                   avctx->bits_per_raw_sample);
-            ret = AVERROR_INVALIDDATA;
-            goto fail;
-        }
     }
 
     // set maximum Rice parameter for progressive decoding based on resolution
@@ -1771,9 +1728,9 @@ static av_cold int decode_init(AVCodecContext *avctx)
 
     // allocate and assign channel data buffer for mcc mode
     if (sconf->mc_coding) {
-        ctx->chan_data_buffer  = av_mallocz(sizeof(*ctx->chan_data_buffer) *
+        ctx->chan_data_buffer  = av_malloc(sizeof(*ctx->chan_data_buffer) *
                                            num_buffers * num_buffers);
-        ctx->chan_data         = av_mallocz(sizeof(*ctx->chan_data) *
+        ctx->chan_data         = av_malloc(sizeof(*ctx->chan_data) *
                                            num_buffers);
         ctx->reverted_channels = av_malloc(sizeof(*ctx->reverted_channels) *
                                            num_buffers);

libavcodec/apedec.c

@@ -592,14 +592,14 @@ static void decode_array_0000(APEContext *ctx, GetBitContext *gb,
     int ksummax, ksummin;
 
     rice->ksum = 0;
-    for (i = 0; i < FFMIN(blockstodecode, 5); i++) {
+    for (i = 0; i < 5; i++) {
         out[i] = get_rice_ook(&ctx->gb, 10);
         rice->ksum += out[i];
     }
     rice->k = av_log2(rice->ksum / 10) + 1;
     if (rice->k >= 24)
         return;
-    for (; i < FFMIN(blockstodecode, 64); i++) {
+    for (; i < 64; i++) {
         out[i] = get_rice_ook(&ctx->gb, rice->k);
         rice->ksum += out[i];
         rice->k = av_log2(rice->ksum / ((i + 1) * 2)) + 1;
@@ -892,9 +892,6 @@ static void long_filter_high_3800(int32_t *buffer, int order, int shift, int len
     int32_t dotprod, sign;
     int32_t coeffs[256], delay[256];
 
-    if (order >= length)
-        return;
-
     memset(coeffs, 0, order * sizeof(*coeffs));
     for (i = 0; i < order; i++)
         delay[i] = buffer[i];
@@ -1464,13 +1461,13 @@ static int ape_decode_frame(AVCodecContext *avctx, void *data,
                    nblocks);
             return AVERROR_INVALIDDATA;
         }
+        s->samples = nblocks;
 
         /* Initialize the frame decoder */
         if (init_frame_decoder(s) < 0) {
             av_log(avctx, AV_LOG_ERROR, "Error reading frame header\n");
             return AVERROR_INVALIDDATA;
         }
-        s->samples = nblocks;
     }
 
     if (!s->data) {

libavcodec/arm/Makefile

@@ -37,7 +37,6 @@ OBJS-$(CONFIG_DCA_DECODER)             += arm/dcadsp_init_arm.o
 OBJS-$(CONFIG_FLAC_DECODER)            += arm/flacdsp_init_arm.o        \
                                           arm/flacdsp_arm.o
 OBJS-$(CONFIG_FLAC_ENCODER)            += arm/flacdsp_init_arm.o
-OBJS-$(CONFIG_HEVC_DECODER)            += arm/hevcdsp_init_arm.o
 OBJS-$(CONFIG_MLP_DECODER)             += arm/mlpdsp_init_arm.o
 OBJS-$(CONFIG_VC1_DECODER)             += arm/vc1dsp_init_arm.o
 OBJS-$(CONFIG_VORBIS_DECODER)          += arm/vorbisdsp_init_arm.o

libavcodec/arm/hevcdsp_arm.h

@@ -1,26 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_ARM_HEVCDSP_ARM_H
-#define AVCODEC_ARM_HEVCDSP_ARM_H
-
-#include "libavcodec/hevcdsp.h"
-
-void ff_hevcdsp_init_neon(HEVCDSPContext *c, const int bit_depth);
-
-#endif /* AVCODEC_ARM_HEVCDSP_ARM_H */

libavcodec/arm/hevcdsp_init_arm.c

@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2014 Seppo Tomperi <seppo.tomperi@vtt.fi>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#include "libavutil/attributes.h"
-#include "libavutil/arm/cpu.h"
-#include "libavcodec/hevcdsp.h"
-#include "hevcdsp_arm.h"
-
-av_cold void ff_hevcdsp_init_arm(HEVCDSPContext *c, const int bit_depth)
-{
-    int cpu_flags = av_get_cpu_flags();
-
-    if (have_neon(cpu_flags))
-        ff_hevcdsp_init_neon(c, bit_depth);
-}

libavcodec/arm/hevcdsp_init_neon.c

@@ -21,7 +21,6 @@
 #include "libavutil/attributes.h"
 #include "libavutil/arm/cpu.h"
 #include "libavcodec/hevcdsp.h"
-#include "hevcdsp_arm.h"
 
 void ff_hevc_v_loop_filter_luma_neon(uint8_t *_pix, ptrdiff_t _stride, int _beta, int *_tc, uint8_t *_no_p, uint8_t *_no_q);
 void ff_hevc_h_loop_filter_luma_neon(uint8_t *_pix, ptrdiff_t _stride, int _beta, int *_tc, uint8_t *_no_p, uint8_t *_no_q);
@@ -142,8 +141,9 @@ void ff_hevc_put_qpel_bi_neon_wrapper(uint8_t *dst, ptrdiff_t dststride, uint8_t
     put_hevc_qpel_uw_neon[my][mx](dst, dststride, src, srcstride, width, height, src2, MAX_PB_SIZE);
 }
 
-av_cold void ff_hevcdsp_init_neon(HEVCDSPContext *c, const int bit_depth)
+static av_cold void hevcdsp_init_neon(HEVCDSPContext *c, const int bit_depth)
 {
+#if HAVE_NEON
     if (bit_depth == 8) {
         int x;
         c->hevc_v_loop_filter_luma     = ff_hevc_v_loop_filter_luma_neon;
@@ -221,4 +221,13 @@ av_cold void ff_hevcdsp_init_neon(HEVCDSPContext *c, const int bit_depth)
         c->put_hevc_qpel_uni[8][0][0]  = ff_hevc_put_qpel_uw_pixels_w48_neon_8;
         c->put_hevc_qpel_uni[9][0][0]  = ff_hevc_put_qpel_uw_pixels_w64_neon_8;
     }
+#endif // HAVE_NEON
+}
+
+void ff_hevcdsp_init_arm(HEVCDSPContext *c, const int bit_depth)
+{
+    int cpu_flags = av_get_cpu_flags();
+
+    if (have_neon(cpu_flags))
+        hevcdsp_init_neon(c, bit_depth);
 }

libavcodec/atrac3plusdec.c

@@ -381,7 +381,7 @@ static int atrac3p_decode_frame(AVCodecContext *avctx, void *data,
 
     *got_frame_ptr = 1;
 
-    return FFMIN(avctx->block_align, avpkt->size);
+    return avctx->block_align;
 }
 
 AVCodec ff_atrac3p_decoder = {

libavcodec/atrac3plusdsp.c

@@ -599,8 +599,8 @@ void ff_atrac3p_ipqf(FFTContext *dct_ctx, Atrac3pIPQFChannelCtx *hist,
                      const float *in, float *out)
 {
     int i, s, sb, t, pos_now, pos_next;
-    LOCAL_ALIGNED(32, float, idct_in, [ATRAC3P_SUBBANDS]);
-    LOCAL_ALIGNED(32, float, idct_out, [ATRAC3P_SUBBANDS]);
+    DECLARE_ALIGNED(32, float, idct_in)[ATRAC3P_SUBBANDS];
+    DECLARE_ALIGNED(32, float, idct_out)[ATRAC3P_SUBBANDS];
 
     memset(out, 0, ATRAC3P_FRAME_SAMPLES * sizeof(*out));
 

libavcodec/bitstream.c

@@ -69,8 +69,6 @@ void avpriv_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
     if (length == 0)
         return;
 
-    av_assert0(length <= put_bits_left(pb));
-
     if (CONFIG_SMALL || words < 16 || put_bits_count(pb) & 7) {
         for (i = 0; i < words; i++)
             put_bits(pb, 16, AV_RB16(src + 2 * i));

libavcodec/bytestream.h

@@ -71,10 +71,8 @@ static av_always_inline type bytestream2_get_ ## name ## u(GetByteContext *g)  \
 }                                                                              \
 static av_always_inline type bytestream2_get_ ## name(GetByteContext *g)       \
 {                                                                              \
-    if (g->buffer_end - g->buffer < bytes) {                                   \
-        g->buffer = g->buffer_end;                                             \
+    if (g->buffer_end - g->buffer < bytes)                                     \
         return 0;                                                              \
-    }                                                                          \
     return bytestream2_get_ ## name ## u(g);                                   \
 }                                                                              \
 static av_always_inline type bytestream2_peek_ ## name(GetByteContext *g)      \

libavcodec/cabac.c

@@ -51,7 +51,7 @@ void ff_init_cabac_encoder(CABACContext *c, uint8_t *buf, int buf_size){
  *
  * @param buf_size size of buf in bits
  */
-int ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size){
+void ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size){
     c->bytestream_start=
     c->bytestream= buf;
     c->bytestream_end= buf + buf_size;
@@ -64,9 +64,6 @@ int ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size){
 #endif
     c->low+= ((*c->bytestream++)<<2) + 2;
     c->range= 0x1FE;
-    if ((c->range<<(CABAC_BITS+1)) < c->low)
-        return AVERROR_INVALIDDATA;
-    return 0;
 }
 
 void ff_init_cabac_states(void)

libavcodec/cabac.h

@@ -56,7 +56,7 @@ typedef struct CABACContext{
 }CABACContext;
 
 void ff_init_cabac_encoder(CABACContext *c, uint8_t *buf, int buf_size);
-int ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size);
+void ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size);
 void ff_init_cabac_states(void);
 
 #endif /* AVCODEC_CABAC_H */

libavcodec/cabac_functions.h

@@ -74,8 +74,7 @@ static inline void renorm_cabac_decoder_once(CABACContext *c){
 
 #ifndef get_cabac_inline
 static void refill2(CABACContext *c){
-    int i;
-    unsigned x;
+    int i, x;
 
     x= c->low ^ (c->low-1);
     i= 7 - ff_h264_norm_shift[x>>(CABAC_BITS-1)];
@@ -191,8 +190,7 @@ static av_unused const uint8_t* skip_bytes(CABACContext *c, int n) {
 #endif
     if ((int) (c->bytestream_end - ptr) < n)
         return NULL;
-    if (ff_init_cabac_decoder(c, ptr + n, c->bytestream_end - ptr - n) < 0)
-        return NULL;
+    ff_init_cabac_decoder(c, ptr + n, c->bytestream_end - ptr - n);
 
     return ptr;
 }

libavcodec/cavsdec.c

@@ -563,11 +563,6 @@ static int decode_residual_block(AVSContext *h, GetBitContext *gb,
                 return AVERROR_INVALIDDATA;
             }
             esc_code = get_ue_code(gb, esc_golomb_order);
-            if (esc_code < 0 || esc_code > 32767) {
-                av_log(h->avctx, AV_LOG_ERROR, "esc_code invalid\n");
-                return AVERROR_INVALIDDATA;
-            }
-
             level    = esc_code + (run > r->max_run ? 1 : r->level_add[run]);
             while (level > r->inc_limit)
                 r++;
@@ -1123,7 +1118,6 @@ static int decode_seq_header(AVSContext *h)
 {
     int frame_rate_code;
     int width, height;
-    int ret;
 
     h->profile = get_bits(&h->gb, 8);
     h->level   = get_bits(&h->gb, 8);
@@ -1140,6 +1134,9 @@ static int decode_seq_header(AVSContext *h)
         av_log(h->avctx, AV_LOG_ERROR, "Dimensions invalid\n");
         return AVERROR_INVALIDDATA;
     }
+    h->width  = width;
+    h->height = height;
+
     skip_bits(&h->gb, 2); //chroma format
     skip_bits(&h->gb, 3); //sample_precision
     h->aspect_ratio = get_bits(&h->gb, 4);
@@ -1148,16 +1145,11 @@ static int decode_seq_header(AVSContext *h)
     skip_bits1(&h->gb);    //marker_bit
     skip_bits(&h->gb, 12); //bit_rate_upper
     h->low_delay =  get_bits1(&h->gb);
-
-    ret = ff_set_dimensions(h->avctx, width, height);
-    if (ret < 0)
-        return ret;
-
-    h->width  = width;
-    h->height = height;
     h->mb_width  = (h->width  + 15) >> 4;
     h->mb_height = (h->height + 15) >> 4;
     h->avctx->framerate = ff_mpeg12_frame_rate_tab[frame_rate_code];
+    h->avctx->width  = h->width;
+    h->avctx->height = h->height;
     if (!h->top_qp)
         return ff_cavs_init_top_lines(h);
     return 0;

libavcodec/dcadec.c

@@ -226,14 +226,6 @@ static int dca_parse_audio_coding_header(DCAContext *s, int base_channel,
     }
 
     nchans = get_bits(&s->gb, 3) + 1;
-    if (xxch && nchans >= 3) {
-        av_log(s->avctx, AV_LOG_ERROR, "nchans %d is too large\n", nchans);
-        return AVERROR_INVALIDDATA;
-    } else if (nchans + base_channel > DCA_PRIM_CHANNELS_MAX) {
-        av_log(s->avctx, AV_LOG_ERROR, "channel sum %d + %d is too large\n", nchans, base_channel);
-        return AVERROR_INVALIDDATA;
-    }
-
     s->total_channels = nchans + base_channel;
     s->prim_channels  = s->total_channels;
 
@@ -434,10 +426,6 @@ static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)
 
     if (!base_channel) {
         s->subsubframes[s->current_subframe]    = get_bits(&s->gb, 2) + 1;
-        if (block_index + s->subsubframes[s->current_subframe] > s->sample_blocks/8) {
-            s->subsubframes[s->current_subframe] = 1;
-            return AVERROR_INVALIDDATA;
-        }
         s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
     }
 
@@ -1132,13 +1120,8 @@ int ff_dca_xbr_parse_frame(DCAContext *s)
     for(i = 0; i < num_chsets; i++) {
         n_xbr_ch[i] = get_bits(&s->gb, 3) + 1;
         k = get_bits(&s->gb, 2) + 5;
-        for(j = 0; j < n_xbr_ch[i]; j++) {
+        for(j = 0; j < n_xbr_ch[i]; j++)
             active_bands[i][j] = get_bits(&s->gb, k) + 1;
-            if (active_bands[i][j] > DCA_SUBBANDS) {
-                av_log(s->avctx, AV_LOG_ERROR, "too many active subbands (%d)\n", active_bands[i][j]);
-                return AVERROR_INVALIDDATA;
-            }
-        }
     }
 
     /* skip to the end of the header */
@@ -1180,34 +1163,23 @@ int ff_dca_xbr_parse_frame(DCAContext *s)
                 for(i = 0; i < n_xbr_ch[chset]; i++) {
                     const uint32_t *scale_table;
                     int nbits;
-                    int scale_table_size;
 
                     if (s->scalefactor_huffman[chan_base+i] == 6) {
                         scale_table = ff_dca_scale_factor_quant7;
-                        scale_table_size = FF_ARRAY_ELEMS(ff_dca_scale_factor_quant7);
                     } else {
                         scale_table = ff_dca_scale_factor_quant6;
-                        scale_table_size = FF_ARRAY_ELEMS(ff_dca_scale_factor_quant6);
                     }
 
                     nbits = anctemp[i];
 
                     for(j = 0; j < active_bands[chset][i]; j++) {
                         if(abits_high[i][j] > 0) {
-                            int index = get_bits(&s->gb, nbits);
-                            if (index >= scale_table_size) {
-                                av_log(s->avctx, AV_LOG_ERROR, "scale table index %d invalid\n", index);
-                                return AVERROR_INVALIDDATA;
-                            }
-                            scale_table_high[i][j][0] = scale_table[index];
+                            scale_table_high[i][j][0] =
+                                scale_table[get_bits(&s->gb, nbits)];
 
                             if(xbr_tmode && s->transition_mode[i][j]) {
-                                int index = get_bits(&s->gb, nbits);
-                                if (index >= scale_table_size) {
-                                    av_log(s->avctx, AV_LOG_ERROR, "scale table index %d invalid\n", index);
-                                    return AVERROR_INVALIDDATA;
-                                }
-                                scale_table_high[i][j][1] = scale_table[index];
+                                scale_table_high[i][j][1] =
+                                    scale_table[get_bits(&s->gb, nbits)];
                             }
                         }
                     }

libavcodec/dcaenc.c

@@ -939,10 +939,6 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
     for (i = 0; i < SUBFRAMES; i++)
         put_subframe(c, i);
 
-
-    for (i = put_bits_count(&c->pb); i < 8*c->frame_size; i++)
-        put_bits(&c->pb, 1, 0);
-
     flush_put_bits(&c->pb);
 
     avpkt->pts      = frame->pts;

libavcodec/dirac_parser.c

@@ -100,12 +100,10 @@ typedef struct DiracParseUnit {
 static int unpack_parse_unit(DiracParseUnit *pu, DiracParseContext *pc,
                              int offset)
 {
-    int8_t *start;
-
-    if (offset < 0 || pc->index - 13 < offset)
+    uint8_t *start = pc->buffer + offset;
+    uint8_t *end   = pc->buffer + pc->index;
+    if (start < pc->buffer || (start + 13 > end))
         return 0;
-
-    start = pc->buffer + offset;
     pu->pu_type = start[4];
 
     pu->next_pu_offset = AV_RB32(start + 5);
@@ -114,15 +112,6 @@ static int unpack_parse_unit(DiracParseUnit *pu, DiracParseContext *pc,
     if (pu->pu_type == 0x10 && pu->next_pu_offset == 0)
         pu->next_pu_offset = 13;
 
-    if (pu->next_pu_offset && pu->next_pu_offset < 13) {
-        av_log(NULL, AV_LOG_ERROR, "next_pu_offset %d is invalid\n", pu->next_pu_offset);
-        return 0;
-    }
-    if (pu->prev_pu_offset && pu->prev_pu_offset < 13) {
-        av_log(NULL, AV_LOG_ERROR, "prev_pu_offset %d is invalid\n", pu->prev_pu_offset);
-        return 0;
-    }
-
     return 1;
 }
 
@@ -134,7 +123,7 @@ static int dirac_combine_frame(AVCodecParserContext *s, AVCodecContext *avctx,
     DiracParseContext *pc = s->priv_data;
 
     if (pc->overread_index) {
-        memmove(pc->buffer, pc->buffer + pc->overread_index,
+        memcpy(pc->buffer, pc->buffer + pc->overread_index,
                pc->index - pc->overread_index);
         pc->index         -= pc->overread_index;
         pc->overread_index = 0;
@@ -201,7 +190,7 @@ static int dirac_combine_frame(AVCodecParserContext *s, AVCodecContext *avctx,
         }
 
         /* Get the picture number to set the pts and dts*/
-        if (parse_timing_info && pu1.prev_pu_offset >= 13) {
+        if (parse_timing_info) {
             uint8_t *cur_pu = pc->buffer +
                               pc->index - 13 - pu1.prev_pu_offset;
             int pts = AV_RB32(cur_pu + 13);

libavcodec/diracdec.c

@@ -801,10 +801,7 @@ static int decode_lowdelay(DiracContext *s)
             slice_num++;
 
             buf     += bytes;
-            if (bufsize/8 >= bytes)
-                bufsize -= bytes*8;
-            else
-                bufsize = 0;
+            bufsize -= bytes*8;
         }
 
     avctx->execute(avctx, decode_lowdelay_slice, slices, NULL, slice_num,
@@ -902,14 +899,6 @@ static int dirac_unpack_prediction_parameters(DiracContext *s)
     /*[DIRAC_STD] 11.2.4 motion_data_dimensions()
       Calculated in function dirac_unpack_block_motion_data */
 
-    if (s->plane[0].xblen % (1 << s->chroma_x_shift) != 0 ||
-        s->plane[0].yblen % (1 << s->chroma_y_shift) != 0 ||
-        !s->plane[0].xblen || !s->plane[0].yblen) {
-        av_log(s->avctx, AV_LOG_ERROR,
-               "invalid x/y block length (%d/%d) for x/y chroma shift (%d/%d)\n",
-               s->plane[0].xblen, s->plane[0].yblen, s->chroma_x_shift, s->chroma_y_shift);
-        return AVERROR_INVALIDDATA;
-    }
     if (!s->plane[0].xbsep || !s->plane[0].ybsep || s->plane[0].xbsep < s->plane[0].xblen/2 || s->plane[0].ybsep < s->plane[0].yblen/2) {
         av_log(s->avctx, AV_LOG_ERROR, "Block separation too small\n");
         return -1;
@@ -1564,7 +1553,7 @@ static void select_dsp_funcs(DiracContext *s, int width, int height, int xblen,
     }
 }
 
-static int interpolate_refplane(DiracContext *s, DiracFrame *ref, int plane, int width, int height)
+static void interpolate_refplane(DiracContext *s, DiracFrame *ref, int plane, int width, int height)
 {
     /* chroma allocates an edge of 8 when subsampled
        which for 4:2:2 means an h edge of 16 and v edge of 8
@@ -1576,14 +1565,11 @@ static int interpolate_refplane(DiracContext *s, DiracFrame *ref, int plane, int
 
     /* no need for hpel if we only have fpel vectors */
     if (!s->mv_precision)
-        return 0;
+        return;
 
     for (i = 1; i < 4; i++) {
         if (!ref->hpel_base[plane][i])
             ref->hpel_base[plane][i] = av_malloc((height+2*edge) * ref->avframe->linesize[plane] + 32);
-        if (!ref->hpel_base[plane][i]) {
-            return AVERROR(ENOMEM);
-        }
         /* we need to be 16-byte aligned even for chroma */
         ref->hpel[plane][i] = ref->hpel_base[plane][i] + edge*ref->avframe->linesize[plane] + 16;
     }
@@ -1597,8 +1583,6 @@ static int interpolate_refplane(DiracContext *s, DiracFrame *ref, int plane, int
         s->mpvencdsp.draw_edges(ref->hpel[plane][3], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
     }
     ref->interpolated[plane] = 1;
-
-    return 0;
 }
 
 /**
@@ -1651,11 +1635,8 @@ static int dirac_decode_frame_internal(DiracContext *s)
 
             select_dsp_funcs(s, p->width, p->height, p->xblen, p->yblen);
 
-            for (i = 0; i < s->num_refs; i++) {
-                int ret = interpolate_refplane(s, s->ref_pics[i], comp, p->width, p->height);
-                if (ret < 0)
-                    return ret;
-            }
+            for (i = 0; i < s->num_refs; i++)
+                interpolate_refplane(s, s->ref_pics[i], comp, p->width, p->height);
 
             memset(s->mctmp, 0, 4*p->yoffset*p->stride);
 
@@ -1761,12 +1742,6 @@ static int dirac_decode_picture_header(DiracContext *s)
                     get_buffer_with_edge(s->avctx, s->ref_pics[i]->avframe, AV_GET_BUFFER_FLAG_REF);
                     break;
                 }
-
-        if (!s->ref_pics[i]) {
-            av_log(s->avctx, AV_LOG_ERROR, "Reference could not be allocated\n");
-            return -1;
-        }
-
     }
 
     /* retire the reference frames that are not used anymore */
@@ -1962,8 +1937,8 @@ static int dirac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
             break;
 
         data_unit_size = AV_RB32(buf+buf_idx+5);
-        if (data_unit_size > buf_size - buf_idx || !data_unit_size) {
-            if(data_unit_size > buf_size - buf_idx)
+        if (buf_idx + data_unit_size > buf_size || !data_unit_size) {
+            if(buf_idx + data_unit_size > buf_size)
             av_log(s->avctx, AV_LOG_ERROR,
                    "Data unit with size %d is larger than input buffer, discarding\n",
                    data_unit_size);

libavcodec/dnxhddec.c

@@ -119,7 +119,6 @@ static int dnxhd_decode_header(DNXHDContext *ctx, AVFrame *frame,
     static const uint8_t header_prefix[]    = { 0x00, 0x00, 0x02, 0x80, 0x01 };
     static const uint8_t header_prefix444[] = { 0x00, 0x00, 0x02, 0x80, 0x02 };
     int i, cid, ret;
-    int old_bit_depth = ctx->bit_depth;
 
     if (buf_size < 0x280) {
         av_log(ctx->avctx, AV_LOG_ERROR, "buffer too small (%d < 640).\n",
@@ -144,6 +143,10 @@ static int dnxhd_decode_header(DNXHDContext *ctx, AVFrame *frame,
 
     av_dlog(ctx->avctx, "width %d, height %d\n", ctx->width, ctx->height);
 
+    if (!ctx->bit_depth) {
+        ff_blockdsp_init(&ctx->bdsp, ctx->avctx);
+        ff_idctdsp_init(&ctx->idsp, ctx->avctx);
+    }
     if (buf[0x21] == 0x58) { /* 10 bit */
         ctx->bit_depth = ctx->avctx->bits_per_raw_sample = 10;
 
@@ -154,23 +157,17 @@ static int dnxhd_decode_header(DNXHDContext *ctx, AVFrame *frame,
         } else {
             ctx->decode_dct_block = dnxhd_decode_dct_block_10;
             ctx->pix_fmt = AV_PIX_FMT_YUV422P10;
-            ctx->is_444 = 0;
         }
     } else if (buf[0x21] == 0x38) { /* 8 bit */
         ctx->bit_depth = ctx->avctx->bits_per_raw_sample = 8;
 
         ctx->pix_fmt = AV_PIX_FMT_YUV422P;
-        ctx->is_444 = 0;
         ctx->decode_dct_block = dnxhd_decode_dct_block_8;
     } else {
         av_log(ctx->avctx, AV_LOG_ERROR, "invalid bit depth value (%d).\n",
                buf[0x21]);
         return AVERROR_INVALIDDATA;
     }
-    if (ctx->bit_depth != old_bit_depth) {
-        ff_blockdsp_init(&ctx->bdsp, ctx->avctx);
-        ff_idctdsp_init(&ctx->idsp, ctx->avctx);
-    }
 
     cid = AV_RB32(buf + 0x28);
     av_dlog(ctx->avctx, "compression id %d\n", cid);
@@ -376,7 +373,7 @@ static int dnxhd_decode_macroblock(DNXHDContext *ctx, AVFrame *frame,
     dest_u = frame->data[1] + ((y * dct_linesize_chroma) << 4) + (x << (3 + shift1 + ctx->is_444));
     dest_v = frame->data[2] + ((y * dct_linesize_chroma) << 4) + (x << (3 + shift1 + ctx->is_444));
 
-    if (frame->interlaced_frame && ctx->cur_field) {
+    if (ctx->cur_field) {
         dest_y += frame->linesize[0];
         dest_u += frame->linesize[1];
         dest_v += frame->linesize[2];

libavcodec/dpx.c

@@ -348,11 +348,11 @@ static int decode_frame(AVCodecContext *avctx,
                 // For 12 bit, ignore alpha
                 if (elements == 4)
                     buf += 2;
+                // Jump to next aligned position
+                buf += need_align;
             }
             for (i = 0; i < 3; i++)
                 ptr[i] += p->linesize[i];
-            // Jump to next aligned position
-            buf += need_align;
         }
         break;
     case 16:

libavcodec/dpxenc.c

@@ -75,20 +75,17 @@ static av_cold int encode_init(AVCodecContext *avctx)
     return 0;
 }
 
-static av_always_inline void write16_internal(int big_endian, void *p, int value)
-{
-    if (big_endian) AV_WB16(p, value);
-    else            AV_WL16(p, value);
-}
+#define write16(p, value) \
+do { \
+    if (s->big_endian) AV_WB16(p, value); \
+    else               AV_WL16(p, value); \
+} while(0)
 
-static av_always_inline void write32_internal(int big_endian, void *p, int value)
-{
-    if (big_endian) AV_WB32(p, value);
-    else            AV_WL32(p, value);
-}
-
-#define write16(p, value) write16_internal(s->big_endian, p, value)
-#define write32(p, value) write32_internal(s->big_endian, p, value)
+#define write32(p, value) \
+do { \
+    if (s->big_endian) AV_WB32(p, value); \
+    else               AV_WL32(p, value); \
+} while(0)
 
 static void encode_rgb48_10bit(AVCodecContext *avctx, const AVPicture *pic, uint8_t *dst)
 {

libavcodec/dvbsubdec.c

@@ -1197,12 +1197,8 @@ static int dvbsub_parse_region_segment(AVCodecContext *avctx,
         region->buf_size = region->width * region->height;
 
         region->pbuf = av_malloc(region->buf_size);
-        if (!region->pbuf) {
-            region->buf_size =
-            region->width =
-            region->height = 0;
+        if (!region->pbuf)
             return AVERROR(ENOMEM);
-        }
 
         fill = 1;
         region->dirty = 0;
@@ -1421,7 +1417,7 @@ static void save_display_set(DVBSubContext *ctx)
 
         pbuf = av_malloc(width * height * 4);
         if (!pbuf)
-            return;
+            return AVERROR(ENOMEM);
 
         for (display = ctx->display_list; display; display = display->next) {
             region = get_region(ctx, display->region_id);
@@ -1503,10 +1499,10 @@ static int dvbsub_parse_display_definition_segment(AVCodecContext *avctx,
         avctx->height = display_def->height;
     }
 
-    if (info_byte & 1<<3) { // display_window_flag
-        if (buf_size < 13)
-            return AVERROR_INVALIDDATA;
+    if (buf_size < 13)
+        return AVERROR_INVALIDDATA;
 
+    if (info_byte & 1<<3) { // display_window_flag
         display_def->x = bytestream_get_be16(&buf);
         display_def->width  = bytestream_get_be16(&buf) - display_def->x + 1;
         display_def->y = bytestream_get_be16(&buf);

libavcodec/dvdec.c

@@ -333,7 +333,7 @@ static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
                                     dct_mode                        * 22 * 64 +
                                     (quant + ff_dv_quant_offset[class1]) * 64];
             }
-            dc = dc * 4;
+            dc = dc << 2;
             /* convert to unsigned because 128 is not added in the
              * standard IDCT */
             dc                   += 1024;

libavcodec/dvdsubdec.c

@@ -346,7 +346,7 @@ static int decode_dvd_subtitles(DVDSubContext *ctx, AVSubtitle *sub_header,
             }
         }
     the_end:
-        if (offset1 >= 0 && offset2 >= 0) {
+        if (offset1 >= 0) {
             int w, h;
             uint8_t *bitmap;
 

libavcodec/dxtory.c

@@ -65,7 +65,7 @@ static int dxtory_decode_v1_410(AVCodecContext *avctx, AVFrame *pic,
     uint8_t *Y1, *Y2, *Y3, *Y4, *U, *V;
     int ret;
 
-    if (src_size < FFALIGN(avctx->width, 4) * FFALIGN(avctx->height, 4) * 9LL / 8) {
+    if (src_size < avctx->width * avctx->height * 9LL / 8) {
         av_log(avctx, AV_LOG_ERROR, "packet too small\n");
         return AVERROR_INVALIDDATA;
     }
@@ -108,7 +108,7 @@ static int dxtory_decode_v1_420(AVCodecContext *avctx, AVFrame *pic,
     uint8_t *Y1, *Y2, *U, *V;
     int ret;
 
-    if (src_size < FFALIGN(avctx->width, 2) * FFALIGN(avctx->height, 2) * 3LL / 2) {
+    if (src_size < avctx->width * avctx->height * 3LL / 2) {
         av_log(avctx, AV_LOG_ERROR, "packet too small\n");
         return AVERROR_INVALIDDATA;
     }

libavcodec/eac3dec.c

@@ -63,7 +63,7 @@ typedef enum {
 
 #define EAC3_SR_CODE_REDUCED  3
 
-static void ff_eac3_apply_spectral_extension(AC3DecodeContext *s)
+void ff_eac3_apply_spectral_extension(AC3DecodeContext *s)
 {
     int bin, bnd, ch, i;
     uint8_t wrapflag[SPX_MAX_BANDS]={1,0,}, num_copy_sections, copy_sizes[SPX_MAX_BANDS];
@@ -101,7 +101,7 @@ static void ff_eac3_apply_spectral_extension(AC3DecodeContext *s)
         for (i = 0; i < num_copy_sections; i++) {
             memcpy(&s->transform_coeffs[ch][bin],
                    &s->transform_coeffs[ch][s->spx_dst_start_freq],
-                   copy_sizes[i]*sizeof(INTFLOAT));
+                   copy_sizes[i]*sizeof(float));
             bin += copy_sizes[i];
         }
 
@@ -124,7 +124,7 @@ static void ff_eac3_apply_spectral_extension(AC3DecodeContext *s)
             bin = s->spx_src_start_freq - 2;
             for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
                 if (wrapflag[bnd]) {
-                    INTFLOAT *coeffs = &s->transform_coeffs[ch][bin];
+                    float *coeffs = &s->transform_coeffs[ch][bin];
                     coeffs[0] *= atten_tab[0];
                     coeffs[1] *= atten_tab[1];
                     coeffs[2] *= atten_tab[2];
@@ -142,11 +142,6 @@ static void ff_eac3_apply_spectral_extension(AC3DecodeContext *s)
         for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
             float nscale = s->spx_noise_blend[ch][bnd] * rms_energy[bnd] * (1.0f / INT32_MIN);
             float sscale = s->spx_signal_blend[ch][bnd];
-#if USE_FIXED
-            // spx_noise_blend and spx_signal_blend are both FP.23
-            nscale *= 1.0 / (1<<23);
-            sscale *= 1.0 / (1<<23);
-#endif
             for (i = 0; i < s->spx_band_sizes[bnd]; i++) {
                 float noise  = nscale * (int32_t)av_lfg_get(&s->dith_state);
                 s->transform_coeffs[ch][bin]   *= sscale;
@@ -200,7 +195,7 @@ static void idct6(int pre_mant[6])
     pre_mant[5] = even0 - odd0;
 }
 
-static void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch)
+void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch)
 {
     int bin, blk, gs;
     int end_bap, gaq_mode;
@@ -293,7 +288,7 @@ static void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch)
     }
 }
 
-static int ff_eac3_parse_header(AC3DecodeContext *s)
+int ff_eac3_parse_header(AC3DecodeContext *s)
 {
     int i, blk, ch;
     int ac3_exponent_strategy, parse_aht_info, parse_spx_atten_data;

libavcodec/error_resilience.c

@@ -378,19 +378,14 @@ static void guess_mv(ERContext *s)
 #define MV_UNCHANGED 1
     const int mb_stride = s->mb_stride;
     const int mb_width  = s->mb_width;
-    int mb_height = s->mb_height;
+    const int mb_height = s->mb_height;
     int i, depth, num_avail;
     int mb_x, mb_y, mot_step, mot_stride;
 
-    if (s->last_pic.f && s->last_pic.f->data[0])
-        mb_height = FFMIN(mb_height, (s->last_pic.f->height+15)>>4);
-    if (s->next_pic.f && s->next_pic.f->data[0])
-        mb_height = FFMIN(mb_height, (s->next_pic.f->height+15)>>4);
-
     set_mv_strides(s, &mot_step, &mot_stride);
 
     num_avail = 0;
-    for (i = 0; i < mb_width * mb_height; i++) {
+    for (i = 0; i < s->mb_num; i++) {
         const int mb_xy = s->mb_index2xy[i];
         int f = 0;
         int error = s->error_status_table[mb_xy];
@@ -415,7 +410,7 @@ static void guess_mv(ERContext *s)
 
     if ((!(s->avctx->error_concealment&FF_EC_GUESS_MVS)) ||
         num_avail <= mb_width / 2) {
-        for (mb_y = 0; mb_y < mb_height; mb_y++) {
+        for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
             for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
                 const int mb_xy = mb_x + mb_y * s->mb_stride;
                 int mv_dir = (s->last_pic.f && s->last_pic.f->data[0]) ? MV_DIR_FORWARD : MV_DIR_BACKWARD;
@@ -444,7 +439,7 @@ static void guess_mv(ERContext *s)
             int score_sum = 0;
 
             changed = 0;
-            for (mb_y = 0; mb_y < mb_height; mb_y++) {
+            for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
                 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
                     const int mb_xy        = mb_x + mb_y * s->mb_stride;
                     int mv_predictor[8][2] = { { 0 } };
@@ -677,7 +672,7 @@ skip_last_mv:
         if (none_left)
             return;
 
-        for (i = 0; i < mb_width * mb_height; i++) {
+        for (i = 0; i < s->mb_num; i++) {
             int mb_xy = s->mb_index2xy[i];
             if (fixed[mb_xy])
                 fixed[mb_xy] = MV_FROZEN;

libavcodec/exr.c

@@ -322,7 +322,7 @@ static uint16_t reverse_lut(const uint8_t *bitmap, uint16_t *lut)
 
     i = k - 1;
 
-    memset(lut + k, 0, (USHORT_RANGE - k) * 2);
+    memset(lut + k * 2, 0, (USHORT_RANGE - k) * 2);
 
     return i;
 }
@@ -459,7 +459,7 @@ static int huf_build_dec_table(const uint64_t *hcode, int im,
         lc += 8;                                                              \
 }
 
-#define get_code(po, rlc, c, lc, gb, out, oe, outb)                           \
+#define get_code(po, rlc, c, lc, gb, out, oe)                                 \
 {                                                                             \
         if (po == rlc) {                                                      \
             if (lc < 8)                                                       \
@@ -468,7 +468,7 @@ static int huf_build_dec_table(const uint64_t *hcode, int im,
                                                                               \
             cs = c >> lc;                                                     \
                                                                               \
-            if (out + cs > oe || out == outb)                                 \
+            if (out + cs > oe)                                                \
                 return AVERROR_INVALIDDATA;                                   \
                                                                               \
             s = out[-1];                                                      \
@@ -501,7 +501,7 @@ static int huf_decode(const uint64_t *hcode, const HufDec *hdecod,
 
             if (pl.len) {
                 lc -= pl.len;
-                get_code(pl.lit, rlc, c, lc, gb, out, oe, outb);
+                get_code(pl.lit, rlc, c, lc, gb, out, oe);
             } else {
                 int j;
 
@@ -518,7 +518,7 @@ static int huf_decode(const uint64_t *hcode, const HufDec *hdecod,
                         if ((hcode[pl.p[j]] >> 6) ==
                             ((c >> (lc - l)) & ((1LL << l) - 1))) {
                             lc -= l;
-                            get_code(pl.p[j], rlc, c, lc, gb, out, oe, outb);
+                            get_code(pl.p[j], rlc, c, lc, gb, out, oe);
                             break;
                         }
                     }
@@ -539,7 +539,7 @@ static int huf_decode(const uint64_t *hcode, const HufDec *hdecod,
 
         if (pl.len) {
             lc -= pl.len;
-            get_code(pl.lit, rlc, c, lc, gb, out, oe, outb);
+            get_code(pl.lit, rlc, c, lc, gb, out, oe);
         } else {
             return AVERROR_INVALIDDATA;
         }
@@ -1010,22 +1010,6 @@ static int decode_header(EXRContext *s)
     int current_channel_offset = 0;
     int magic_number, version, flags, i;
 
-    s->xmin               = ~0;
-    s->xmax               = ~0;
-    s->ymin               = ~0;
-    s->ymax               = ~0;
-    s->xdelta             = ~0;
-    s->ydelta             = ~0;
-    s->channel_offsets[0] = -1;
-    s->channel_offsets[1] = -1;
-    s->channel_offsets[2] = -1;
-    s->channel_offsets[3] = -1;
-    s->pixel_type         = EXR_UNKNOWN;
-    s->compression        = EXR_UNKN;
-    s->nb_channels        = 0;
-    s->w                  = 0;
-    s->h                  = 0;
-
     if (bytestream2_get_bytes_left(&s->gb) < 10) {
         av_log(s->avctx, AV_LOG_ERROR, "Header too short to parse.\n");
         return AVERROR_INVALIDDATA;
@@ -1366,6 +1350,21 @@ static av_cold int decode_init(AVCodecContext *avctx)
     float one_gamma = 1.0f / s->gamma;
 
     s->avctx              = avctx;
+    s->xmin               = ~0;
+    s->xmax               = ~0;
+    s->ymin               = ~0;
+    s->ymax               = ~0;
+    s->xdelta             = ~0;
+    s->ydelta             = ~0;
+    s->channel_offsets[0] = -1;
+    s->channel_offsets[1] = -1;
+    s->channel_offsets[2] = -1;
+    s->channel_offsets[3] = -1;
+    s->pixel_type         = EXR_UNKNOWN;
+    s->compression        = EXR_UNKN;
+    s->nb_channels        = 0;
+    s->w                  = 0;
+    s->h                  = 0;
 
     if (one_gamma > 0.9999f && one_gamma < 1.0001f) {
         for (i = 0; i < 65536; ++i)

libavcodec/ffv1.c

@@ -66,7 +66,7 @@ av_cold int ffv1_common_init(AVCodecContext *avctx)
 
 av_cold int ffv1_init_slice_state(FFV1Context *f, FFV1Context *fs)
 {
-    int j, i;
+    int j;
 
     fs->plane_count  = f->plane_count;
     fs->transparency = f->transparency;
@@ -80,15 +80,10 @@ av_cold int ffv1_init_slice_state(FFV1Context *f, FFV1Context *fs)
             if (!p->state)
                 return AVERROR(ENOMEM);
         } else {
-            if (!p->vlc_state) {
-                p->vlc_state = av_mallocz_array(p->context_count, sizeof(VlcState));
-                if (!p->vlc_state)
-                    return AVERROR(ENOMEM);
-                for (i = 0; i < p->context_count; i++) {
-                    p->vlc_state[i].error_sum = 4;
-                    p->vlc_state[i].count     = 1;
-                }
-            }
+            if (!p->vlc_state)
+                p->vlc_state = av_malloc_array(p->context_count, sizeof(VlcState));
+            if (!p->vlc_state)
+                return AVERROR(ENOMEM);
         }
     }
 
@@ -106,7 +101,7 @@ av_cold int ffv1_init_slice_state(FFV1Context *f, FFV1Context *fs)
 av_cold int ffv1_init_slices_state(FFV1Context *f)
 {
     int i, ret;
-    for (i = 0; i < f->max_slice_count; i++) {
+    for (i = 0; i < f->slice_count; i++) {
         FFV1Context *fs = f->slice_context[i];
         if ((ret = ffv1_init_slice_state(f, fs)) < 0)
             return AVERROR(ENOMEM);
@@ -118,10 +113,10 @@ av_cold int ffv1_init_slice_contexts(FFV1Context *f)
 {
     int i;
 
-    f->max_slice_count = f->num_h_slices * f->num_v_slices;
-    av_assert0(f->max_slice_count > 0);
+    f->slice_count = f->num_h_slices * f->num_v_slices;
+    av_assert0(f->slice_count > 0);
 
-    for (i = 0; i < f->max_slice_count; i++) {
+    for (i = 0; i < f->slice_count; i++) {
         FFV1Context *fs = av_mallocz(sizeof(*fs));
         int sx          = i % f->num_h_slices;
         int sy          = i / f->num_h_slices;
@@ -206,7 +201,7 @@ av_cold int ffv1_close(AVCodecContext *avctx)
         ff_thread_release_buffer(avctx, &s->last_picture);
     av_frame_free(&s->last_picture.f);
 
-    for (j = 0; j < s->max_slice_count; j++) {
+    for (j = 0; j < s->slice_count; j++) {
         FFV1Context *fs = s->slice_context[j];
         for (i = 0; i < s->plane_count; i++) {
             PlaneContext *p = &fs->plane[i];
@@ -220,14 +215,14 @@ av_cold int ffv1_close(AVCodecContext *avctx)
     av_freep(&avctx->stats_out);
     for (j = 0; j < s->quant_table_count; j++) {
         av_freep(&s->initial_states[j]);
-        for (i = 0; i < s->max_slice_count; i++) {
+        for (i = 0; i < s->slice_count; i++) {
             FFV1Context *sf = s->slice_context[i];
             av_freep(&sf->rc_stat2[j]);
         }
         av_freep(&s->rc_stat2[j]);
     }
 
-    for (i = 0; i < s->max_slice_count; i++)
+    for (i = 0; i < s->slice_count; i++)
         av_freep(&s->slice_context[i]);
 
     return 0;

libavcodec/ffv1.h

@@ -117,7 +117,6 @@ typedef struct FFV1Context {
 
     struct FFV1Context *slice_context[MAX_SLICES];
     int slice_count;
-    int max_slice_count;
     int num_v_slices;
     int num_h_slices;
     int slice_width;

libavcodec/ffv1dec.c

@@ -47,11 +47,8 @@ static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state,
     else {
         int i, e, a;
         e = 0;
-        while (get_rac(c, state + 1 + FFMIN(e, 9))) { // 1..10
+        while (get_rac(c, state + 1 + FFMIN(e, 9))) // 1..10
             e++;
-            if (e > 31)
-                return AVERROR_INVALIDDATA;
-        }
 
         a = 1;
         for (i = e - 1; i >= 0; i--)
@@ -306,7 +303,7 @@ static int decode_slice_header(FFV1Context *f, FFV1Context *fs)
     for (i = 0; i < f->plane_count; i++) {
         PlaneContext * const p = &fs->plane[i];
         int idx = get_symbol(c, state, 0);
-        if (idx >= (unsigned)f->quant_table_count) {
+        if (idx > (unsigned)f->quant_table_count) {
             av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
             return -1;
         }
@@ -409,7 +406,6 @@ static int decode_slice(AVCodecContext *c, void *arg)
         if (ffv1_init_slice_state(f, fs) < 0)
             return AVERROR(ENOMEM);
         if (decode_slice_header(f, fs) < 0) {
-            fs->slice_x = fs->slice_y = fs->slice_height = fs->slice_width = 0;
             fs->slice_damaged = 1;
             return AVERROR_INVALIDDATA;
         }
@@ -504,10 +500,7 @@ static int read_quant_tables(RangeCoder *c,
     int context_count = 1;
 
     for (i = 0; i < 5; i++) {
-        int ret = read_quant_table(c, quant_table[i], context_count);
-        if (ret < 0)
-            return ret;
-        context_count *= ret;
+        context_count *= read_quant_table(c, quant_table[i], context_count);
         if (context_count > 32768U) {
             return AVERROR_INVALIDDATA;
         }
@@ -553,12 +546,6 @@ static int read_extra_header(FFV1Context *f)
     f->num_h_slices               = 1 + get_symbol(c, state, 0);
     f->num_v_slices               = 1 + get_symbol(c, state, 0);
 
-    if (f->chroma_h_shift > 4U || f->chroma_v_shift > 4U) {
-        av_log(f->avctx, AV_LOG_ERROR, "chroma shift parameters %d %d are invalid\n",
-               f->chroma_h_shift, f->chroma_v_shift);
-        return AVERROR_INVALIDDATA;
-    }
-
     if (f->num_h_slices > (unsigned)f->width  || !f->num_h_slices ||
         f->num_v_slices > (unsigned)f->height || !f->num_v_slices
        ) {
@@ -567,11 +554,8 @@ static int read_extra_header(FFV1Context *f)
     }
 
     f->quant_table_count = get_symbol(c, state, 0);
-    if (f->quant_table_count > (unsigned)MAX_QUANT_TABLES || !f->quant_table_count) {
-        av_log(f->avctx, AV_LOG_ERROR, "quant table count %d is invalid\n", f->quant_table_count);
-        f->quant_table_count = 0;
+    if (f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
         return AVERROR_INVALIDDATA;
-    }
 
     for (i = 0; i < f->quant_table_count; i++) {
         f->context_count[i] = read_quant_tables(c, f->quant_tables[i]);
@@ -667,12 +651,6 @@ static int read_header(FFV1Context *f)
             }
         }
 
-        if (chroma_h_shift > 4U || chroma_v_shift > 4U) {
-            av_log(f->avctx, AV_LOG_ERROR, "chroma shift parameters %d %d are invalid\n",
-                   chroma_h_shift, chroma_v_shift);
-            return AVERROR_INVALIDDATA;
-        }
-
         f->colorspace                 = colorspace;
         f->avctx->bits_per_raw_sample = bits_per_raw_sample;
         f->chroma_planes              = chroma_planes;
@@ -780,7 +758,6 @@ static int read_header(FFV1Context *f)
             av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
             return AVERROR_INVALIDDATA;
         }
-        f->slice_count = f->max_slice_count;
     } else if (f->version < 3) {
         f->slice_count = get_symbol(c, state, 0);
     } else {
@@ -795,8 +772,8 @@ static int read_header(FFV1Context *f)
             p -= size + trailer;
         }
     }
-    if (f->slice_count > (unsigned)MAX_SLICES || f->slice_count <= 0 || f->slice_count > f->max_slice_count) {
-        av_log(f->avctx, AV_LOG_ERROR, "slice count %d is invalid (max=%d)\n", f->slice_count, f->max_slice_count);
+    if (f->slice_count > (unsigned)MAX_SLICES || f->slice_count <= 0) {
+        av_log(f->avctx, AV_LOG_ERROR, "slice count %d is invalid\n", f->slice_count);
         return AVERROR_INVALIDDATA;
     }
 
@@ -938,7 +915,6 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPac
         else                     v = buf_p - c->bytestream_start;
         if (buf_p - c->bytestream_start < v) {
             av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
-            ff_thread_report_progress(&f->picture, INT_MAX, 0);
             return AVERROR_INVALIDDATA;
         }
         buf_p -= v;
@@ -1020,7 +996,6 @@ static int init_thread_copy(AVCodecContext *avctx)
     f->picture.f      = NULL;
     f->last_picture.f = NULL;
     f->sample_buffer  = NULL;
-    f->max_slice_count = 0;
     f->slice_count = 0;
 
     for (i = 0; i < f->quant_table_count; i++) {
@@ -1096,7 +1071,7 @@ static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
         av_assert0(!fdst->sample_buffer);
     }
 
-    av_assert1(fdst->max_slice_count == fsrc->max_slice_count);
+    av_assert1(fdst->slice_count == fsrc->slice_count);
 
 
     ff_thread_release_buffer(dst, &fdst->picture);

libavcodec/ffv1enc.c

@@ -962,7 +962,6 @@ slices_ok:
 
     if ((ret = ffv1_init_slice_contexts(s)) < 0)
         return ret;
-    s->slice_count = s->max_slice_count;
     if ((ret = ffv1_init_slices_state(s)) < 0)
         return ret;
 
@@ -972,7 +971,7 @@ slices_ok:
         if (!avctx->stats_out)
             return AVERROR(ENOMEM);
         for (i = 0; i < s->quant_table_count; i++)
-            for (j = 0; j < s->max_slice_count; j++) {
+            for (j = 0; j < s->slice_count; j++) {
                 FFV1Context *sf = s->slice_context[j];
                 av_assert0(!sf->rc_stat2[i]);
                 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *
@@ -1196,7 +1195,6 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
             for (i = 0; i < f->quant_table_count; i++)
                 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));
 
-            av_assert0(f->slice_count == f->max_slice_count);
             for (j = 0; j < f->slice_count; j++) {
                 FFV1Context *fs = f->slice_context[j];
                 for (i = 0; i < 256; i++) {

libavcodec/flacenc.c

@@ -663,7 +663,7 @@ static uint64_t calc_rice_params(RiceContext *rc, int pmin, int pmax,
     bits[pmin] = UINT32_MAX;
     for (i = pmax; ; ) {
         bits[i] = calc_optimal_rice_params(&tmp_rc, i, sums, n, pred_order);
-        if (bits[i] < bits[opt_porder] || pmax == pmin) {
+        if (bits[i] < bits[opt_porder]) {
             opt_porder = i;
             *rc = tmp_rc;
         }

libavcodec/flashsv.c

@@ -413,10 +413,6 @@ static int flashsv_decode_frame(AVCodecContext *avctx, void *data,
                 }
 
                 if (has_diff) {
-                    if (size < 3) {
-                        av_log(avctx, AV_LOG_ERROR, "size too small for diff\n");
-                        return AVERROR_INVALIDDATA;
-                    }
                     if (!s->keyframe) {
                         av_log(avctx, AV_LOG_ERROR,
                                "Inter frame without keyframe\n");
@@ -444,10 +440,6 @@ static int flashsv_decode_frame(AVCodecContext *avctx, void *data,
                     int row = get_bits(&gb, 8);
                     av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_curr %dx%d\n",
                            i, j, col, row);
-                    if (size < 3) {
-                        av_log(avctx, AV_LOG_ERROR, "size too small for zlibprime_curr\n");
-                        return AVERROR_INVALIDDATA;
-                    }
                     size -= 2;
                     avpriv_request_sample(avctx, "zlibprime_curr");
                     return AVERROR_PATCHWELCOME;

libavcodec/flashsvenc.c

@@ -111,7 +111,7 @@ static av_cold int flashsv_encode_init(AVCodecContext *avctx)
 
     if (avctx->width > 4095 || avctx->height > 4095) {
         av_log(avctx, AV_LOG_ERROR,
-               "Input dimensions too large, input must be max 4095x4095 !\n");
+               "Input dimensions too large, input must be max 4096x4096 !\n");
         return AVERROR_INVALIDDATA;
     }
 

libavcodec/g2meet.c

@@ -738,7 +738,7 @@ static int g2m_decode_frame(AVCodecContext *avctx, void *data,
             c->tile_height = bytestream2_get_be32(&bc);
             if (c->tile_width <= 0 || c->tile_height <= 0 ||
                 ((c->tile_width | c->tile_height) & 0xF) ||
-                c->tile_width * (uint64_t)c->tile_height >= INT_MAX / 4
+                c->tile_width * 4LL * c->tile_height >= INT_MAX
             ) {
                 av_log(avctx, AV_LOG_ERROR,
                        "Invalid tile dimensions %dx%d\n",
@@ -869,8 +869,6 @@ header_fail:
     c->height  = 0;
     c->tiles_x =
     c->tiles_y = 0;
-    c->tile_width =
-    c->tile_height = 0;
     return ret;
 }
 

libavcodec/golomb.h

@@ -68,7 +68,7 @@ static inline int get_ue_golomb(GetBitContext *gb)
         int log = 2 * av_log2(buf) - 31;
         LAST_SKIP_BITS(re, gb, 32 - log);
         CLOSE_READER(re, gb);
-        if (log < 7) {
+        if (CONFIG_FTRAPV && log < 0) {
             av_log(NULL, AV_LOG_ERROR, "Invalid UE golomb code\n");
             return AVERROR_INVALIDDATA;
         }
@@ -337,16 +337,8 @@ static inline int get_ur_golomb_jpegls(GetBitContext *gb, int k, int limit,
 
         if (i < limit - 1) {
             if (k) {
-                if (k > MIN_CACHE_BITS - 1) {
-                    buf = SHOW_UBITS(re, gb, 16) << (k-16);
-                    LAST_SKIP_BITS(re, gb, 16);
-                    UPDATE_CACHE(re, gb);
-                    buf |= SHOW_UBITS(re, gb, k-16);
-                    LAST_SKIP_BITS(re, gb, k-16);
-                } else {
-                    buf = SHOW_UBITS(re, gb, k);
-                    LAST_SKIP_BITS(re, gb, k);
-                }
+                buf = SHOW_UBITS(re, gb, k);
+                LAST_SKIP_BITS(re, gb, k);
             } else {
                 buf = 0;
             }

libavcodec/h264.c

@@ -1499,6 +1499,9 @@ static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size,
                 continue;
 
 again:
+            if (   (!(avctx->active_thread_type & FF_THREAD_FRAME) || nals_needed >= nal_index)
+                && !h->current_slice)
+                h->au_pps_id = -1;
             /* Ignore per frame NAL unit type during extradata
              * parsing. Decoding slices is not possible in codec init
              * with frame-mt */
@@ -1534,14 +1537,8 @@ again:
                     ret = -1;
                     goto end;
                 }
-                if(!idr_cleared) {
-                    if (h->current_slice && (avctx->active_thread_type & FF_THREAD_SLICE)) {
-                        av_log(h, AV_LOG_ERROR, "invalid mixed IDR / non IDR frames cannot be decoded in slice multithreading mode\n");
-                        ret = AVERROR_INVALIDDATA;
-                        goto end;
-                    }
+                if(!idr_cleared)
                     idr(h); // FIXME ensure we don't lose some frames if there is reordering
-                }
                 idr_cleared = 1;
                 h->has_recovery_point = 1;
             case NAL_SLICE:
@@ -1549,10 +1546,6 @@ again:
                 hx->intra_gb_ptr      =
                 hx->inter_gb_ptr      = &hx->gb;
 
-                if (   nals_needed >= nal_index
-                    || (!(avctx->active_thread_type & FF_THREAD_FRAME) && !context_count))
-                    h->au_pps_id = -1;
-
                 if ((err = ff_h264_decode_slice_header(hx, h)))
                     break;
 
@@ -1636,9 +1629,7 @@ again:
                 break;
             case NAL_SPS:
                 init_get_bits(&h->gb, ptr, bit_length);
-                if (ff_h264_decode_seq_parameter_set(h, 0) >= 0)
-                    break;
-                if (h->is_avc ? nalsize : 1) {
+                if (ff_h264_decode_seq_parameter_set(h) < 0 && (h->is_avc ? nalsize : 1)) {
                     av_log(h->avctx, AV_LOG_DEBUG,
                            "SPS decoding failure, trying again with the complete NAL\n");
                     if (h->is_avc)
@@ -1647,11 +1638,8 @@ again:
                         break;
                     init_get_bits(&h->gb, &buf[buf_index + 1 - consumed],
                                   8*(next_avc - buf_index + consumed - 1));
-                    if (ff_h264_decode_seq_parameter_set(h, 0) >= 0)
-                        break;
+                    ff_h264_decode_seq_parameter_set(h);
                 }
-                init_get_bits(&h->gb, ptr, bit_length);
-                ff_h264_decode_seq_parameter_set(h, 1);
 
                 break;
             case NAL_PPS:
@@ -1684,14 +1672,8 @@ again:
             if (err < 0 || err == SLICE_SKIPED) {
                 if (err < 0)
                     av_log(h->avctx, AV_LOG_ERROR, "decode_slice_header error\n");
-                hx->ref_count[0] = hx->ref_count[1] = hx->list_count = 0;
+                h->ref_count[0] = h->ref_count[1] = h->list_count = 0;
             } else if (err == SLICE_SINGLETHREAD) {
-                if (context_count > 1) {
-                    ret = ff_h264_execute_decode_slices(h, context_count - 1);
-                    if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
-                        goto end;
-                    context_count = 0;
-                }
                 /* Slice could not be decoded in parallel mode, copy down
                  * NAL unit stuff to context 0 and restart. Note that
                  * rbsp_buffer is not transferred, but since we no longer

libavcodec/h264.h

@@ -536,7 +536,6 @@ typedef struct H264Context {
     int mb_x, mb_y;
     int resync_mb_x;
     int resync_mb_y;
-    int mb_index_end;
     int mb_skip_run;
     int mb_height, mb_width;
     int mb_stride;
@@ -777,7 +776,7 @@ int ff_h264_decode_sei(H264Context *h);
 /**
  * Decode SPS
  */
-int ff_h264_decode_seq_parameter_set(H264Context *h, int ignore_truncation);
+int ff_h264_decode_seq_parameter_set(H264Context *h);
 
 /**
  * compute profile from sps

libavcodec/h264_cabac.c

@@ -2000,7 +2000,6 @@ decode_intra_mb:
         const int mb_size = ff_h264_mb_sizes[h->sps.chroma_format_idc] *
                             h->sps.bit_depth_luma >> 3;
         const uint8_t *ptr;
-        int ret;
 
         // We assume these blocks are very rare so we do not optimize it.
         // FIXME The two following lines get the bitstream position in the cabac
@@ -2017,9 +2016,7 @@ decode_intra_mb:
         h->intra_pcm_ptr = ptr;
         ptr += mb_size;
 
-        ret = ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
-        if (ret < 0)
-            return ret;
+        ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
 
         // All blocks are present
         h->cbp_table[mb_xy] = 0xf7ef;

libavcodec/h264_mp4toannexb_bsf.c

@@ -182,7 +182,7 @@ static int h264_mp4toannexb_filter(AVBitStreamFilterContext *bsfc,
         buf      += ctx->length_size;
         unit_type = *buf & 0x1f;
 
-        if (nal_size > buf_end - buf || nal_size < 0)
+        if (buf + nal_size > buf_end || nal_size < 0)
             goto fail;
 
         if (unit_type == 7)

libavcodec/h264_parser.c

@@ -280,7 +280,7 @@ static inline int parse_nal_units(AVCodecParserContext *s,
         init_get_bits(&h->gb, ptr, 8 * dst_length);
         switch (h->nal_unit_type) {
         case NAL_SPS:
-            ff_h264_decode_seq_parameter_set(h, 0);
+            ff_h264_decode_seq_parameter_set(h);
             break;
         case NAL_PPS:
             ff_h264_decode_picture_parameter_set(h, h->gb.size_in_bits);

libavcodec/h264_ps.c

@@ -241,6 +241,12 @@ static inline int decode_vui_parameters(H264Context *h, SPS *sps)
         }
     }
 
+    if (get_bits_left(&h->gb) < 0) {
+        av_log(h->avctx, AV_LOG_ERROR,
+               "Overread VUI by %d bits\n", -get_bits_left(&h->gb));
+        return AVERROR_INVALIDDATA;
+    }
+
     return 0;
 }
 
@@ -297,7 +303,7 @@ static void decode_scaling_matrices(H264Context *h, SPS *sps,
     }
 }
 
-int ff_h264_decode_seq_parameter_set(H264Context *h, int ignore_truncation)
+int ff_h264_decode_seq_parameter_set(H264Context *h)
 {
     int profile_idc, level_idc, constraint_set_flags = 0;
     unsigned int sps_id;
@@ -517,13 +523,6 @@ int ff_h264_decode_seq_parameter_set(H264Context *h, int ignore_truncation)
             goto fail;
     }
 
-    if (get_bits_left(&h->gb) < 0) {
-        av_log(h->avctx, ignore_truncation ? AV_LOG_WARNING : AV_LOG_ERROR,
-               "Overread %s by %d bits\n", sps->vui_parameters_present_flag ? "VUI" : "SPS", -get_bits_left(&h->gb));
-        if (!ignore_truncation)
-            goto fail;
-    }
-
     if (!sps->sar.den)
         sps->sar.den = 1;
 

libavcodec/h264_refs.c

@@ -276,7 +276,7 @@ int ff_h264_decode_ref_pic_list_reordering(H264Context *h)
 
                     long_idx = pic_num_extract(h, pic_id, &pic_structure);
 
-                    if (long_idx > 31U) {
+                    if (long_idx > 31) {
                         av_log(h->avctx, AV_LOG_ERROR,
                                "long_term_pic_idx overflow\n");
                         return AVERROR_INVALIDDATA;
@@ -705,7 +705,7 @@ int ff_h264_execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count)
          */
         if (h->short_ref_count && h->short_ref[0] == h->cur_pic_ptr) {
             /* Just mark the second field valid */
-            h->cur_pic_ptr->reference |= h->picture_structure;
+            h->cur_pic_ptr->reference = PICT_FRAME;
         } else if (h->cur_pic_ptr->long_ref) {
             av_log(h->avctx, AV_LOG_ERROR, "illegal short term reference "
                                            "assignment for second field "

libavcodec/h264_slice.c

@@ -242,11 +242,11 @@ static int alloc_picture(H264Context *h, H264Picture *pic)
         av_pix_fmt_get_chroma_sub_sample(pic->f.format,
                                          &h_chroma_shift, &v_chroma_shift);
 
-        for(i=0; i<FF_CEIL_RSHIFT(pic->f.height, v_chroma_shift); i++) {
+        for(i=0; i<FF_CEIL_RSHIFT(h->avctx->height, v_chroma_shift); i++) {
             memset(pic->f.data[1] + pic->f.linesize[1]*i,
-                   0x80, FF_CEIL_RSHIFT(pic->f.width, h_chroma_shift));
+                   0x80, FF_CEIL_RSHIFT(h->avctx->width, h_chroma_shift));
             memset(pic->f.data[2] + pic->f.linesize[2]*i,
-                   0x80, FF_CEIL_RSHIFT(pic->f.width, h_chroma_shift));
+                   0x80, FF_CEIL_RSHIFT(h->avctx->width, h_chroma_shift));
         }
     }
 
@@ -893,7 +893,7 @@ static void implicit_weight_table(H264Context *h, int field)
             cur_poc = h->cur_pic_ptr->field_poc[h->picture_structure - 1];
         }
         if (h->ref_count[0] == 1 && h->ref_count[1] == 1 && !FRAME_MBAFF(h) &&
-            h->ref_list[0][0].poc + (int64_t)h->ref_list[1][0].poc == 2 * cur_poc) {
+            h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2 * cur_poc) {
             h->use_weight        = 0;
             h->use_weight_chroma = 0;
             return;
@@ -914,7 +914,7 @@ static void implicit_weight_table(H264Context *h, int field)
     h->chroma_log2_weight_denom = 5;
 
     for (ref0 = ref_start; ref0 < ref_count0; ref0++) {
-        int64_t poc0 = h->ref_list[0][ref0].poc;
+        int poc0 = h->ref_list[0][ref0].poc;
         for (ref1 = ref_start; ref1 < ref_count1; ref1++) {
             int w = 32;
             if (!h->ref_list[0][ref0].long_ref && !h->ref_list[1][ref1].long_ref) {
@@ -1194,7 +1194,6 @@ static int h264_slice_header_init(H264Context *h, int reinit)
         nb_slices = max_slices;
     }
     h->slice_context_count = nb_slices;
-    h->max_contexts = FFMIN(h->max_contexts, nb_slices);
 
     if (!HAVE_THREADS || !(h->avctx->active_thread_type & FF_THREAD_SLICE)) {
         ret = ff_h264_context_init(h);
@@ -1290,7 +1289,6 @@ int ff_h264_decode_slice_header(H264Context *h, H264Context *h0)
     int field_pic_flag, bottom_field_flag;
     int first_slice = h == h0 && !h0->current_slice;
     int frame_num, picture_structure, droppable;
-    int mb_aff_frame, last_mb_aff_frame;
     PPS *pps;
 
     h->qpel_put = h->h264qpel.put_h264_qpel_pixels_tab;
@@ -1418,8 +1416,7 @@ int ff_h264_decode_slice_header(H264Context *h, H264Context *h0)
                      || h->mb_width  != h->sps.mb_width
                      || h->mb_height != h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag)
                     ));
-    if (h0->avctx->pix_fmt == AV_PIX_FMT_NONE
-        || (non_j_pixfmt(h0->avctx->pix_fmt) != non_j_pixfmt(get_pixel_format(h0, 0))))
+    if (non_j_pixfmt(h0->avctx->pix_fmt) != non_j_pixfmt(get_pixel_format(h0, 0)))
         must_reinit = 1;
 
     if (first_slice && av_cmp_q(h->sps.sar, h->avctx->sample_aspect_ratio))
@@ -1455,7 +1452,6 @@ int ff_h264_decode_slice_header(H264Context *h, H264Context *h0)
 
     if (h->context_initialized &&
         (must_reinit || needs_reinit)) {
-        h->context_initialized = 0;
         if (h != h0) {
             av_log(h->avctx, AV_LOG_ERROR,
                    "changing width %d -> %d / height %d -> %d on "
@@ -1516,8 +1512,7 @@ int ff_h264_decode_slice_header(H264Context *h, H264Context *h0)
     }
 
     h->mb_mbaff        = 0;
-    mb_aff_frame       = 0;
-    last_mb_aff_frame  = h0->mb_aff_frame;
+    h->mb_aff_frame    = 0;
     last_pic_structure = h0->picture_structure;
     last_pic_droppable = h0->droppable;
     droppable          = h->nal_ref_idc == 0;
@@ -1535,13 +1530,12 @@ int ff_h264_decode_slice_header(H264Context *h, H264Context *h0)
             picture_structure = PICT_TOP_FIELD + bottom_field_flag;
         } else {
             picture_structure = PICT_FRAME;
-            mb_aff_frame      = h->sps.mb_aff;
+            h->mb_aff_frame      = h->sps.mb_aff;
         }
     }
     if (h0->current_slice) {
         if (last_pic_structure != picture_structure ||
-            last_pic_droppable != droppable ||
-            last_mb_aff_frame  != mb_aff_frame) {
+            last_pic_droppable != droppable) {
             av_log(h->avctx, AV_LOG_ERROR,
                    "Changing field mode (%d -> %d) between slices is not allowed\n",
                    last_pic_structure, h->picture_structure);
@@ -1557,7 +1551,6 @@ int ff_h264_decode_slice_header(H264Context *h, H264Context *h0)
     h->picture_structure = picture_structure;
     h->droppable         = droppable;
     h->frame_num         = frame_num;
-    h->mb_aff_frame      = mb_aff_frame;
     h->mb_field_decoding_flag = picture_structure != PICT_FRAME;
 
     if (h0->current_slice == 0) {
@@ -1670,17 +1663,14 @@ int ff_h264_decode_slice_header(H264Context *h, H264Context *h0)
              * vectors.  Given we are concealing a lost frame, this probably
              * is not noticeable by comparison, but it should be fixed. */
             if (h->short_ref_count) {
-                if (prev &&
-                    h->short_ref[0]->f.width == prev->f.width &&
-                    h->short_ref[0]->f.height == prev->f.height &&
-                    h->short_ref[0]->f.format == prev->f.format) {
+                if (prev) {
                     av_image_copy(h->short_ref[0]->f.data,
                                   h->short_ref[0]->f.linesize,
                                   (const uint8_t **)prev->f.data,
                                   prev->f.linesize,
-                                  prev->f.format,
-                                  prev->f.width,
-                                  prev->f.height);
+                                  h->avctx->pix_fmt,
+                                  h->mb_width  * 16,
+                                  h->mb_height * 16);
                     h->short_ref[0]->poc = prev->poc + 2;
                 }
                 h->short_ref[0]->frame_num = h->prev_frame_num;
@@ -2422,32 +2412,20 @@ static int decode_slice(struct AVCodecContext *avctx, void *arg)
     }
 
     if (h->pps.cabac) {
-        int ret;
         /* realign */
         align_get_bits(&h->gb);
 
         /* init cabac */
-        ret = ff_init_cabac_decoder(&h->cabac,
+        ff_init_cabac_decoder(&h->cabac,
                               h->gb.buffer + get_bits_count(&h->gb) / 8,
                               (get_bits_left(&h->gb) + 7) / 8);
-        if (ret < 0)
-            return ret;
 
         ff_h264_init_cabac_states(h);
 
         for (;;) {
             // START_TIMER
-            int ret, eos;
-
-            if (h->mb_x + h->mb_y * h->mb_width >= h->mb_index_end) {
-                av_log(h->avctx, AV_LOG_ERROR, "Slice overlaps next at %d\n",
-                       h->mb_index_end);
-                er_add_slice(h, h->resync_mb_x, h->resync_mb_y, h->mb_x,
-                             h->mb_y, ER_MB_ERROR);
-                return AVERROR_INVALIDDATA;
-            }
-
-            ret = ff_h264_decode_mb_cabac(h);
+            int ret = ff_h264_decode_mb_cabac(h);
+            int eos;
             // STOP_TIMER("decode_mb_cabac")
 
             if (ret >= 0)
@@ -2509,17 +2487,7 @@ static int decode_slice(struct AVCodecContext *avctx, void *arg)
         }
     } else {
         for (;;) {
-            int ret;
-
-            if (h->mb_x + h->mb_y * h->mb_width >= h->mb_index_end) {
-                av_log(h->avctx, AV_LOG_ERROR, "Slice overlaps next at %d\n",
-                       h->mb_index_end);
-                er_add_slice(h, h->resync_mb_x, h->resync_mb_y, h->mb_x,
-                             h->mb_y, ER_MB_ERROR);
-                return AVERROR_INVALIDDATA;
-            }
-
-            ret = ff_h264_decode_mb_cavlc(h);
+            int ret = ff_h264_decode_mb_cavlc(h);
 
             if (ret >= 0)
                 ff_h264_hl_decode_mb(h);
@@ -2607,33 +2575,19 @@ int ff_h264_execute_decode_slices(H264Context *h, unsigned context_count)
 
     av_assert0(h->mb_y < h->mb_height);
 
-    h->mb_index_end = INT_MAX;
-
     if (h->avctx->hwaccel ||
         h->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)
         return 0;
     if (context_count == 1) {
         return decode_slice(avctx, &h);
     } else {
-        int j, mb_index;
         av_assert0(context_count > 0);
-        for (i = 0; i < context_count; i++) {
-            int mb_index_end = h->mb_width * h->mb_height;
+        for (i = 1; i < context_count; i++) {
             hx                 = h->thread_context[i];
-            mb_index = hx->resync_mb_x + hx->resync_mb_y * h->mb_width;
-            if (CONFIG_ERROR_RESILIENCE && i) {
+            if (CONFIG_ERROR_RESILIENCE) {
                 hx->er.error_count = 0;
             }
             hx->x264_build     = h->x264_build;
-            for (j = 0; j < context_count; j++) {
-                H264Context *sl2 = h->thread_context[j];
-                int mb_index2 = sl2->resync_mb_x + sl2->resync_mb_y * h->mb_width;
-
-                if (i==j || mb_index > mb_index2)
-                    continue;
-                mb_index_end = FFMIN(mb_index_end, mb_index2);
-            }
-            hx->mb_index_end = mb_index_end;
         }
 
         avctx->execute(avctx, decode_slice, h->thread_context,

libavcodec/hevc.c

@@ -440,7 +440,7 @@ static int hls_slice_header(HEVCContext *s)
 
         slice_address_length = av_ceil_log2(s->sps->ctb_width *
                                             s->sps->ctb_height);
-        sh->slice_segment_addr = slice_address_length ? get_bits(gb, slice_address_length) : 0;
+        sh->slice_segment_addr = get_bits(gb, slice_address_length);
         if (sh->slice_segment_addr >= s->sps->ctb_width * s->sps->ctb_height) {
             av_log(s->avctx, AV_LOG_ERROR,
                    "Invalid slice segment address: %u.\n",
@@ -694,29 +694,15 @@ static int hls_slice_header(HEVCContext *s)
 
     sh->num_entry_point_offsets = 0;
     if (s->pps->tiles_enabled_flag || s->pps->entropy_coding_sync_enabled_flag) {
-        unsigned num_entry_point_offsets = get_ue_golomb_long(gb);
-        // It would be possible to bound this tighter but this here is simpler
-        if (num_entry_point_offsets > get_bits_left(gb)) {
-            av_log(s->avctx, AV_LOG_ERROR, "num_entry_point_offsets %d is invalid\n", num_entry_point_offsets);
-            return AVERROR_INVALIDDATA;
-        }
-
-        sh->num_entry_point_offsets = num_entry_point_offsets;
+        sh->num_entry_point_offsets = get_ue_golomb_long(gb);
         if (sh->num_entry_point_offsets > 0) {
             int offset_len = get_ue_golomb_long(gb) + 1;
             int segments = offset_len >> 4;
             int rest = (offset_len & 15);
-
-            if (offset_len < 1 || offset_len > 32) {
-                sh->num_entry_point_offsets = 0;
-                av_log(s->avctx, AV_LOG_ERROR, "offset_len %d is invalid\n", offset_len);
-                return AVERROR_INVALIDDATA;
-            }
-
             av_freep(&sh->entry_point_offset);
             av_freep(&sh->offset);
             av_freep(&sh->size);
-            sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(unsigned));
+            sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
             sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
             sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
             if (!sh->entry_point_offset || !sh->offset || !sh->size) {
@@ -789,8 +775,6 @@ static int hls_slice_header(HEVCContext *s)
     s->HEVClc->tu.cu_qp_offset_cb = 0;
     s->HEVClc->tu.cu_qp_offset_cr = 0;
 
-    s->no_rasl_output_flag = IS_IDR(s) || IS_BLA(s) || (s->nal_unit_type == NAL_CRA_NUT && s->last_eos);
-
     return 0;
 }
 
@@ -2381,8 +2365,6 @@ static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int
 
         if (more_data < 0) {
             s->tab_slice_address[ctb_addr_rs] = -1;
-            avpriv_atomic_int_set(&s1->wpp_err,  1);
-            ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
             return more_data;
         }
 
@@ -2420,8 +2402,8 @@ static int hls_slice_data_wpp(HEVCContext *s, const uint8_t *nal, int length)
     HEVCLocalContext *lc = s->HEVClc;
     int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
     int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
-    int64_t offset;
-    int64_t startheader, cmpt = 0;
+    int offset;
+    int startheader, cmpt = 0;
     int i, j, res = 0;
 
     if (!ret || !arg) {
@@ -2430,18 +2412,11 @@ static int hls_slice_data_wpp(HEVCContext *s, const uint8_t *nal, int length)
         return AVERROR(ENOMEM);
     }
 
-    if (s->sh.slice_ctb_addr_rs + s->sh.num_entry_point_offsets * s->sps->ctb_width >= s->sps->ctb_width * s->sps->ctb_height) {
-        av_log(s->avctx, AV_LOG_ERROR, "WPP ctb addresses are wrong (%d %d %d %d)\n",
-            s->sh.slice_ctb_addr_rs, s->sh.num_entry_point_offsets,
-            s->sps->ctb_width, s->sps->ctb_height
-        );
-        res = AVERROR_INVALIDDATA;
-        goto error;
-    }
-
-    ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
 
     if (!s->sList[1]) {
+        ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
+
+
         for (i = 1; i < s->threads_number; i++) {
             s->sList[i] = av_malloc(sizeof(HEVCContext));
             memcpy(s->sList[i], s, sizeof(HEVCContext));
@@ -2474,11 +2449,6 @@ static int hls_slice_data_wpp(HEVCContext *s, const uint8_t *nal, int length)
     }
     if (s->sh.num_entry_point_offsets != 0) {
         offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
-        if (length < offset) {
-            av_log(s->avctx, AV_LOG_ERROR, "entry_point_offset table is corrupted\n");
-            res = AVERROR_INVALIDDATA;
-            goto error;
-        }
         s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
         s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
 
@@ -2505,7 +2475,6 @@ static int hls_slice_data_wpp(HEVCContext *s, const uint8_t *nal, int length)
 
     for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
         res += ret[i];
-error:
     av_free(ret);
     av_free(arg);
     return res;
@@ -2631,8 +2600,7 @@ static int hevc_frame_start(HEVCContext *s)
     if (ret < 0)
         goto fail;
 
-    if (!s->avctx->hwaccel)
-        ff_thread_finish_setup(s->avctx);
+    ff_thread_finish_setup(s->avctx);
 
     return 0;
 
@@ -3014,6 +2982,7 @@ static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
 
     /* parse the NAL units */
     for (i = 0; i < s->nb_nals; i++) {
+        int ret;
         s->skipped_bytes = s->skipped_bytes_nal[i];
         s->skipped_bytes_pos = s->skipped_bytes_pos_nal[i];
 
@@ -3373,7 +3342,6 @@ static int hevc_update_thread_context(AVCodecContext *dst,
     s->pocTid0    = s0->pocTid0;
     s->max_ra     = s0->max_ra;
     s->eos        = s0->eos;
-    s->no_rasl_output_flag = s0->no_rasl_output_flag;
 
     s->is_nalff        = s0->is_nalff;
     s->nal_length_size = s0->nal_length_size;
@@ -3468,7 +3436,6 @@ static av_cold int hevc_decode_init(AVCodecContext *avctx)
 
     s->enable_parallel_tiles = 0;
     s->picture_struct = 0;
-    s->eos = 1;
 
     if(avctx->active_thread_type & FF_THREAD_SLICE)
         s->threads_number = avctx->thread_count;
@@ -3510,7 +3477,6 @@ static void hevc_decode_flush(AVCodecContext *avctx)
     HEVCContext *s = avctx->priv_data;
     ff_hevc_flush_dpb(s);
     s->max_ra = INT_MAX;
-    s->eos = 1;
 }
 
 #define OFFSET(x) offsetof(HEVCContext, x)

libavcodec/hevc.h

@@ -298,10 +298,10 @@ typedef struct RefPicListTab {
 } RefPicListTab;
 
 typedef struct HEVCWindow {
-    unsigned int left_offset;
-    unsigned int right_offset;
-    unsigned int top_offset;
-    unsigned int bottom_offset;
+    int left_offset;
+    int right_offset;
+    int top_offset;
+    int bottom_offset;
 } HEVCWindow;
 
 typedef struct VUI {
@@ -609,7 +609,7 @@ typedef struct SliceHeader {
 
     unsigned int max_num_merge_cand; ///< 5 - 5_minus_max_num_merge_cand
 
-    unsigned *entry_point_offset;
+    int *entry_point_offset;
     int * offset;
     int * size;
     int num_entry_point_offsets;
@@ -844,7 +844,6 @@ typedef struct HEVCContext {
     int bs_height;
 
     int is_decoded;
-    int no_rasl_output_flag;
 
     HEVCPredContext hpc;
     HEVCDSPContext hevcdsp;

libavcodec/hevc_cabac.c

@@ -883,13 +883,11 @@ static av_always_inline int mvd_decode(HEVCContext *s)
     int k = 1;
 
     while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
-        ret += 1U << k;
+        ret += 1 << k;
         k++;
     }
-    if (k == CABAC_MAX_BIN) {
+    if (k == CABAC_MAX_BIN)
         av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
-        return 0;
-    }
     while (k--)
         ret += get_cabac_bypass(&s->HEVClc->cc) << k;
     return get_cabac_bypass_sign(&s->HEVClc->cc, -ret);
@@ -1027,10 +1025,8 @@ static av_always_inline int coeff_abs_level_remaining_decode(HEVCContext *s, int
 
     while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc))
         prefix++;
-    if (prefix == CABAC_MAX_BIN) {
+    if (prefix == CABAC_MAX_BIN)
         av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
-        return 0;
-    }
     if (prefix < 3) {
         for (i = 0; i < rc_rice_param; i++)
             suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);

libavcodec/hevc_parser.c

@@ -200,7 +200,7 @@ static inline int parse_nal_units(AVCodecParserContext *s, AVCodecContext *avctx
 
                 slice_address_length = av_ceil_log2_c(h->sps->ctb_width *
                                                       h->sps->ctb_height);
-                sh->slice_segment_addr = slice_address_length ? get_bits(gb, slice_address_length) : 0;
+                sh->slice_segment_addr = get_bits(gb, slice_address_length);
                 if (sh->slice_segment_addr >= h->sps->ctb_width * h->sps->ctb_height) {
                     av_log(h->avctx, AV_LOG_ERROR, "Invalid slice segment address: %u.\n",
                            sh->slice_segment_addr);

libavcodec/hevc_ps.c

@@ -424,8 +424,7 @@ int ff_hevc_decode_nal_vps(HEVCContext *s)
 
     vps->vps_max_layer_id   = get_bits(gb, 6);
     vps->vps_num_layer_sets = get_ue_golomb_long(gb) + 1;
-    if (vps->vps_num_layer_sets < 1 || vps->vps_num_layer_sets > 1024 ||
-        (vps->vps_num_layer_sets - 1LL) * (vps->vps_max_layer_id + 1LL) > get_bits_left(gb)) {
+    if ((vps->vps_num_layer_sets - 1LL) * (vps->vps_max_layer_id + 1LL) > get_bits_left(gb)) {
         av_log(s->avctx, AV_LOG_ERROR, "too many layer_id_included_flags\n");
         goto err;
     }
@@ -442,11 +441,6 @@ int ff_hevc_decode_nal_vps(HEVCContext *s)
         if (vps->vps_poc_proportional_to_timing_flag)
             vps->vps_num_ticks_poc_diff_one = get_ue_golomb_long(gb) + 1;
         vps->vps_num_hrd_parameters = get_ue_golomb_long(gb);
-        if (vps->vps_num_hrd_parameters > (unsigned)vps->vps_num_layer_sets) {
-            av_log(s->avctx, AV_LOG_ERROR,
-                   "vps_num_hrd_parameters %d is invalid\n", vps->vps_num_hrd_parameters);
-            goto err;
-        }
         for (i = 0; i < vps->vps_num_hrd_parameters; i++) {
             int common_inf_present = 1;
 
@@ -461,8 +455,7 @@ int ff_hevc_decode_nal_vps(HEVCContext *s)
     if (get_bits_left(gb) < 0) {
         av_log(s->avctx, AV_LOG_ERROR,
                "Overread VPS by %d bits\n", -get_bits_left(gb));
-        if (s->vps_list[vps_id])
-            goto err;
+        goto err;
     }
 
     av_buffer_unref(&s->vps_list[vps_id]);
@@ -762,9 +755,6 @@ int ff_hevc_decode_nal_sps(HEVCContext *s)
     }
 
     sps->chroma_format_idc = get_ue_golomb_long(gb);
-    if (sps->chroma_format_idc > 3U) {
-        return AVERROR_INVALIDDATA;
-    }
 
     if (sps->chroma_format_idc == 3)
         sps->separate_colour_plane_flag = get_bits1(gb);
@@ -1049,8 +1039,7 @@ int ff_hevc_decode_nal_sps(HEVCContext *s)
                          (sps->output_window.left_offset + sps->output_window.right_offset);
     sps->output_height = sps->height -
                          (sps->output_window.top_offset + sps->output_window.bottom_offset);
-    if (sps->width  <= sps->output_window.left_offset + (int64_t)sps->output_window.right_offset  ||
-        sps->height <= sps->output_window.top_offset  + (int64_t)sps->output_window.bottom_offset) {
+    if (sps->output_width <= 0 || sps->output_height <= 0) {
         av_log(s->avctx, AV_LOG_WARNING, "Invalid visible frame dimensions: %dx%d.\n",
                sps->output_width, sps->output_height);
         if (s->avctx->err_recognition & AV_EF_EXPLODE) {
@@ -1326,14 +1315,14 @@ int ff_hevc_decode_nal_pps(HEVCContext *s)
     if (pps->tiles_enabled_flag) {
         pps->num_tile_columns = get_ue_golomb_long(gb) + 1;
         pps->num_tile_rows    = get_ue_golomb_long(gb) + 1;
-        if (pps->num_tile_columns <= 0 ||
+        if (pps->num_tile_columns == 0 ||
             pps->num_tile_columns >= sps->width) {
             av_log(s->avctx, AV_LOG_ERROR, "num_tile_columns_minus1 out of range: %d\n",
                    pps->num_tile_columns - 1);
             ret = AVERROR_INVALIDDATA;
             goto err;
         }
-        if (pps->num_tile_rows <= 0 ||
+        if (pps->num_tile_rows == 0 ||
             pps->num_tile_rows >= sps->height) {
             av_log(s->avctx, AV_LOG_ERROR, "num_tile_rows_minus1 out of range: %d\n",
                    pps->num_tile_rows - 1);

libavcodec/hevc_refs.c

@@ -174,7 +174,7 @@ int ff_hevc_output_frame(HEVCContext *s, AVFrame *out, int flush)
         int min_poc   = INT_MAX;
         int i, min_idx, ret;
 
-        if (s->sh.no_output_of_prior_pics_flag == 1 && s->no_rasl_output_flag == 1) {
+        if (s->sh.no_output_of_prior_pics_flag == 1) {
             for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
                 HEVCFrame *frame = &s->DPB[i];
                 if (!(frame->flags & HEVC_FRAME_FLAG_BUMPING) && frame->poc != s->poc &&

libavcodec/hevc_sei.c

@@ -126,11 +126,6 @@ static int active_parameter_sets(HEVCContext *s)
     get_bits(gb, 1); // num_sps_ids_minus1
     num_sps_ids_minus1 = get_ue_golomb_long(gb); // num_sps_ids_minus1
 
-    if (num_sps_ids_minus1 < 0 || num_sps_ids_minus1 > 15) {
-        av_log(s->avctx, AV_LOG_ERROR, "num_sps_ids_minus1 %d invalid\n", num_sps_ids_minus1);
-        return AVERROR_INVALIDDATA;
-    }
-
     active_seq_parameter_set_id = get_ue_golomb_long(gb);
     if (active_seq_parameter_set_id >= MAX_SPS_COUNT) {
         av_log(s->avctx, AV_LOG_ERROR, "active_parameter_set_id %d invalid\n", active_seq_parameter_set_id);

libavcodec/huffyuvdec.c

@@ -37,7 +37,6 @@
 #include "huffyuv.h"
 #include "huffyuvdsp.h"
 #include "thread.h"
-#include "libavutil/imgutils.h"
 #include "libavutil/pixdesc.h"
 
 #define classic_shift_luma_table_size 42
@@ -292,10 +291,6 @@ static av_cold int decode_init(AVCodecContext *avctx)
     HYuvContext *s = avctx->priv_data;
     int ret;
 
-    ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
-    if (ret < 0)
-        return ret;
-
     ff_huffyuvdsp_init(&s->hdsp);
     memset(s->vlc, 0, 4 * sizeof(VLC));
 

libavcodec/imc.c

@@ -426,7 +426,7 @@ static void imc_decode_level_coefficients_raw(IMCContext *q, int *levlCoeffBuf,
 
     pos = q->coef0_pos;
     flcoeffs1[pos] = 20000.0 / pow (2, levlCoeffBuf[0] * 0.18945); // 0.18945 = log2(10) * 0.05703125
-    flcoeffs2[pos] = log2f(flcoeffs1[pos]);
+    flcoeffs2[pos] = log2f(flcoeffs1[0]);
     tmp  = flcoeffs1[pos];
     tmp2 = flcoeffs2[pos];
 

libavcodec/ituh263enc.c

@@ -43,7 +43,7 @@
 /**
  * Table of number of bits a motion vector component needs.
  */
-static uint8_t mv_penalty[MAX_FCODE+1][MAX_DMV*2+1];
+static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
 
 /**
  * Minimal fcode that a motion vector component would need.
@@ -676,7 +676,7 @@ static av_cold void init_mv_penalty_and_fcode(MpegEncContext *s)
     int mv;
 
     for(f_code=1; f_code<=MAX_FCODE; f_code++){
-        for(mv=-MAX_DMV; mv<=MAX_DMV; mv++){
+        for(mv=-MAX_MV; mv<=MAX_MV; mv++){
             int len;
 
             if(mv==0) len= ff_mvtab[0][1];
@@ -697,7 +697,7 @@ static av_cold void init_mv_penalty_and_fcode(MpegEncContext *s)
                 }
             }
 
-            mv_penalty[f_code][mv+MAX_DMV]= len;
+            mv_penalty[f_code][mv+MAX_MV]= len;
         }
     }
 

libavcodec/ivi_common.c

@@ -30,7 +30,6 @@
 
 #define BITSTREAM_READER_LE
 #include "libavutil/attributes.h"
-#include "libavutil/imgutils.h"
 #include "libavutil/timer.h"
 #include "avcodec.h"
 #include "get_bits.h"
@@ -311,7 +310,7 @@ av_cold int ff_ivi_init_planes(IVIPlaneDesc *planes, const IVIPicConfig *cfg,
 
     ivi_free_buffers(planes);
 
-    if (av_image_check_size(cfg->pic_width, cfg->pic_height, 0, NULL) < 0 ||
+    if (cfg->pic_width < 1 || cfg->pic_height < 1 ||
         cfg->luma_bands < 1 || cfg->chroma_bands < 1)
         return AVERROR_INVALIDDATA;
 

libavcodec/jpeg2000.c

@@ -28,7 +28,6 @@
 #include "libavutil/attributes.h"
 #include "libavutil/avassert.h"
 #include "libavutil/common.h"
-#include "libavutil/imgutils.h"
 #include "libavutil/mem.h"
 #include "avcodec.h"
 #include "jpeg2000.h"
@@ -211,17 +210,9 @@ int ff_jpeg2000_init_component(Jpeg2000Component *comp,
                                    codsty->nreslevels2decode - 1,
                                    codsty->transform))
         return ret;
-
-    if (av_image_check_size(comp->coord[0][1] - comp->coord[0][0],
-                            comp->coord[1][1] - comp->coord[1][0], 0, avctx))
-        return AVERROR_INVALIDDATA;
+    // component size comp->coord is uint16_t so ir cannot overflow
     csize = (comp->coord[0][1] - comp->coord[0][0]) *
             (comp->coord[1][1] - comp->coord[1][0]);
-    if (comp->coord[0][1] > 32768 ||
-        comp->coord[1][1] > 32768) {
-        av_log(avctx, AV_LOG_ERROR, "component size too large\n");
-        return AVERROR_PATCHWELCOME;
-    }
 
     if (codsty->transform == FF_DWT97) {
         comp->i_data = NULL;

libavcodec/jpeg2000dec.c

@@ -252,10 +252,6 @@ static int get_siz(Jpeg2000DecoderContext *s)
         avpriv_request_sample(s->avctx, "Support for image offsets");
         return AVERROR_PATCHWELCOME;
     }
-    if (s->width > 32768U || s->height > 32768U) {
-        avpriv_request_sample(s->avctx, "Large Dimensions");
-        return AVERROR_PATCHWELCOME;
-    }
 
     if (ncomponents <= 0) {
         av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
@@ -690,10 +686,10 @@ static int init_tile(Jpeg2000DecoderContext *s, int tileno)
         Jpeg2000QuantStyle  *qntsty = tile->qntsty + compno;
         int ret; // global bandno
 
-        comp->coord_o[0][0] = av_clip(tilex       * (int64_t)s->tile_width  + s->tile_offset_x, s->image_offset_x, s->width);
-        comp->coord_o[0][1] = av_clip((tilex + 1) * (int64_t)s->tile_width  + s->tile_offset_x, s->image_offset_x, s->width);
-        comp->coord_o[1][0] = av_clip(tiley       * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
-        comp->coord_o[1][1] = av_clip((tiley + 1) * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
+        comp->coord_o[0][0] = FFMAX(tilex       * s->tile_width  + s->tile_offset_x, s->image_offset_x);
+        comp->coord_o[0][1] = FFMIN((tilex + 1) * s->tile_width  + s->tile_offset_x, s->width);
+        comp->coord_o[1][0] = FFMAX(tiley       * s->tile_height + s->tile_offset_y, s->image_offset_y);
+        comp->coord_o[1][1] = FFMIN((tiley + 1) * s->tile_height + s->tile_offset_y, s->height);
 
         comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
         comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
@@ -1081,10 +1077,6 @@ static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
     ff_mqc_initdec(&t1->mqc, cblk->data);
 
     while (passno--) {
-        if (bpno < 0) {
-            av_log(s->avctx, AV_LOG_ERROR, "bpno became negative\n");
-            return AVERROR_INVALIDDATA;
-        }
         switch(pass_t) {
         case 0:
             decode_sigpass(t1, width, height, bpno + 1, bandpos,
@@ -1156,16 +1148,11 @@ static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
     int i, csize = 1;
     void *src[3];
 
-    for (i = 1; i < 3; i++) {
+    for (i = 1; i < 3; i++)
         if (tile->codsty[0].transform != tile->codsty[i].transform) {
             av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
             return;
         }
-        if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
-            av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
-            return;
-        }
-    }
 
     for (i = 0; i < 3; i++)
         if (tile->codsty[0].transform == FF_DWT97)
@@ -1364,7 +1351,6 @@ static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
     memset(s->codsty, 0, sizeof(s->codsty));
     memset(s->qntsty, 0, sizeof(s->qntsty));
     s->numXtiles = s->numYtiles = 0;
-    s->ncomponents = 0;
 }
 
 static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
@@ -1419,10 +1405,6 @@ static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
 
         switch (marker) {
         case JPEG2000_SIZ:
-            if (s->ncomponents) {
-                av_log(s->avctx, AV_LOG_ERROR, "Duplicate SIZ\n");
-                return AVERROR_INVALIDDATA;
-            }
             ret = get_siz(s);
             if (!s->tile)
                 s->numXtiles = s->numYtiles = 0;
@@ -1577,7 +1559,7 @@ static int jp2_find_codestream(Jpeg2000DecoderContext *s)
                         int cn   = bytestream2_get_be16(&s->g);
                         int av_unused typ  = bytestream2_get_be16(&s->g);
                         int asoc = bytestream2_get_be16(&s->g);
-                        if (cn < 4 && asoc < 4)
+                        if (cn < 4 || asoc < 4)
                             s->cdef[cn] = asoc;
                     }
                 }

libavcodec/jpeg2000dwt.c

@@ -540,9 +540,6 @@ int ff_jpeg2000_dwt_init(DWTContext *s, uint16_t border[2][2],
 
 int ff_dwt_encode(DWTContext *s, void *t)
 {
-    if (s->ndeclevels == 0)
-        return 0;
-
     switch(s->type){
         case FF_DWT97:
             dwt_encode97_float(s, t); break;
@@ -558,9 +555,6 @@ int ff_dwt_encode(DWTContext *s, void *t)
 
 int ff_dwt_decode(DWTContext *s, void *t)
 {
-    if (s->ndeclevels == 0)
-        return 0;
-
     switch (s->type) {
     case FF_DWT97:
         dwt_decode97_float(s, t);

libavcodec/libopenjpegdec.c

@@ -358,15 +358,6 @@ static int libopenjpeg_decode_frame(AVCodecContext *avctx,
         goto done;
     }
 
-    for (i = 0; i < image->numcomps; i++) {
-        if (!image->comps[i].data) {
-            av_log(avctx, AV_LOG_ERROR,
-                   "Image component %d contains no data.\n", i);
-            ret = AVERROR_INVALIDDATA;
-            goto done;
-        }
-    }
-
     desc       = av_pix_fmt_desc_get(avctx->pix_fmt);
     pixel_size = desc->comp[0].step_minus1 + 1;
     ispacked   = libopenjpeg_ispacked(avctx->pix_fmt);

libavcodec/libopenjpegenc.c

@@ -200,9 +200,6 @@ static opj_image_t *mj2_create_image(AVCodecContext *avctx, opj_cparameters_t *p
 
     img = opj_image_create(numcomps, cmptparm, color_space);
 
-    if (!img)
-        return NULL;
-
     // x0, y0 is the top left corner of the image
     // x1, y1 is the width, height of the reference grid
     img->x0 = 0;

libavcodec/libopusenc.c

@@ -326,7 +326,7 @@ static int libopus_encode(AVCodecContext *avctx, AVPacket *avpkt,
         } else
             audio = frame->data[0];
     } else {
-        if (!opus->afq.remaining_samples || (!opus->afq.frame_alloc && !opus->afq.frame_count))
+        if (!opus->afq.remaining_samples)
             return 0;
         audio = opus->samples;
         memset(audio, 0, opus->opts.packet_size * sample_size);

libavcodec/libtheoraenc.c

@@ -111,8 +111,6 @@ static int get_stats(AVCodecContext *avctx, int eos)
         // libtheora generates a summary header at the end
         memcpy(h->stats, buf, bytes);
         avctx->stats_out = av_malloc(b64_size);
-        if (!avctx->stats_out)
-            return AVERROR(ENOMEM);
         av_base64_encode(avctx->stats_out, b64_size, h->stats, h->stats_offset);
     }
     return 0;

libavcodec/libvpxenc.c

@@ -441,10 +441,9 @@ static av_cold int vpx_init(AVCodecContext *avctx,
         codecctl_int(avctx, VP8E_SET_ARNR_STRENGTH,    ctx->arnr_strength);
     if (ctx->arnr_type >= 0)
         codecctl_int(avctx, VP8E_SET_ARNR_TYPE,        ctx->arnr_type);
-    if (avctx->codec_id == AV_CODEC_ID_VP8) {
-        codecctl_int(avctx, VP8E_SET_NOISE_SENSITIVITY, avctx->noise_reduction);
+    codecctl_int(avctx, VP8E_SET_NOISE_SENSITIVITY, avctx->noise_reduction);
+    if (avctx->codec_id == AV_CODEC_ID_VP8)
         codecctl_int(avctx, VP8E_SET_TOKEN_PARTITIONS,  av_log2(avctx->slices));
-    }
 #if FF_API_MPV_OPT
     FF_DISABLE_DEPRECATION_WARNINGS
     if (avctx->mb_threshold) {

libavcodec/microdvddec.c

@@ -164,8 +164,6 @@ static char *microdvd_load_tags(struct microdvd_tag *tags, char *s)
 
         /* Position */
         case 'P':
-            if (!*s)
-                break;
             tag.persistent = MICRODVD_PERSISTENT_ON;
             tag.data1 = (*s++ == '1');
             if (*s != '}')