Compare commits
1 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Michael Niedermayer
|
3c1ecb057d |
@@ -1,935 +1,7 @@
|
||||
Entries are sorted chronologically from oldest to youngest within each release,
|
||||
releases are sorted from youngest to oldest.
|
||||
|
||||
version 4.0.6:
|
||||
avcodec/dstdec: Replace AC overread check by sample rate check
|
||||
avcodec/hevc_mp4toannexb_bsf: Check NAL size against available input
|
||||
lavf/webm_chunk: Fix NULL dereference
|
||||
avcodec/ttaenc: Fix undefined shift
|
||||
fftools/ffmpeg: Free swresample dictionary during cleanup
|
||||
avfilter/vf_xbr: Fix left shift of negative number
|
||||
avfilter/vf_hqx: Fix undefined left shifts of negative numbers
|
||||
avcodec/jpeg2000dwt: Fix undefined shifts of negative numbers
|
||||
avcodec/ituh263dec: Fix undefined left shift of negative number
|
||||
avcodec/dnxhdenc: Fix undefined left shifts of negative numbers
|
||||
swscale/utils: Fix invalid left shifts of negative numbers
|
||||
swscale/x86/swscale: Fix undefined left shifts of negative numbers
|
||||
avcodec/exr: Fix undefined left shifts of negative numbers
|
||||
avformat/movenc: Fix undefined shift
|
||||
avcodec/pcm: Fix undefined shifts
|
||||
avcodec/wavpackenc: Fix undefined shifts
|
||||
avcodec/ac3enc: Fix invalid shift
|
||||
avcodec/tdsc: Fix undefined shifts
|
||||
fftools/ffmpeg_opt: Fix signed integer overflow
|
||||
avformat/mov: Fix reel_name size check
|
||||
avformat/mov: Fix memleak upon encountering repeating tags
|
||||
avformat/matroskaenc: Don't use NULL for %s format string
|
||||
avformat/webvttdec: Fix memleak upon read header failure
|
||||
avformat/vplayerdec: Fix memleak upon read header failure
|
||||
avformat/tedcaptionsdec: Fix memleak upon read header failure
|
||||
avformat/subviewerdec: Fix memleak upon read header failure
|
||||
avformat/subviewer1dec: Fix memleak upon read header failure
|
||||
avformat/stldec: Fix memleak upon read header failure
|
||||
avformat/srtdec: Fix memleak upon read header failure
|
||||
avformat/sccdec: Fix memleak upon read header failure
|
||||
avformat/samidec: Fix memleak upon read header failure
|
||||
avformat/pjsdec: Fix memleak upon read header failure
|
||||
avformat/mpsubdec: Fix memleak upon read header failure
|
||||
avformat/mpl2dec: Fix memleak upon read header failure
|
||||
avformat/microdvddec: Fix memleak upon read header failure
|
||||
avformat/lrcdec: Fix memleak upon read header failure
|
||||
avformat/jacosubdec: Fix memleak upon read header failure
|
||||
avformat/assdec: Fix memleak upon read header failure
|
||||
avformat/aqtitledec: Fix memleak upon read header failure
|
||||
avformat/mov: Fix memleaks upon read_header failure
|
||||
avformat/omadec: Fix memleaks upon read_header failure
|
||||
avformat/matroskadec: Fix memleaks in WebM DASH manifest demuxer
|
||||
avformat/matroskadec: Use right number of tracks
|
||||
avformat/matroskadec: Fix handling gigantic durations
|
||||
avcodec/cinepakenc: Fix invalid shifts
|
||||
avcodec/cbs_h2645: Fix potential out-of-bounds array access
|
||||
h264_redundant_pps: Fix memleak in case of errors
|
||||
avformat/aviobuf: Don't check for overflow after it happened
|
||||
avformat/matroskaenc: Fix memleak upon encountering bogus chapter
|
||||
fftools/ffmpeg_opt: Check attachment filesize
|
||||
avformat/webmdashenc: Check codec types
|
||||
avformat/avidec: Fix memleak with embedded GAB2 subtitles
|
||||
avformat/webmdashenc: Fix memleak upon realloc failure
|
||||
avformat/matroskadec: Don't discard the upper 32bits of TrackNumber
|
||||
avformat/hnm: Check for extradata allocation failure
|
||||
avformat/subtitles: Don't increment packet counter prematurely
|
||||
avformat/bethsoftvid: Fix potential memleak upon reallocation failure
|
||||
avformat/smoothstreaming: Fix memleaks on errors
|
||||
avformat/matroskaenc: Check BlockAdditional size before use
|
||||
avformat/utils: Fix memleaks in avformat_open_input()
|
||||
avcodec/cavsdsp: Fix undefined left shifts of negative numbers
|
||||
avformat/mov: Don't leak MOVFragmentStreamInfo on error
|
||||
avformat/hevc: Fix potential leak in case of ff_hevc_annexb2mp4_buf failure
|
||||
avformat/matroskaenc: Check for reformatting errors
|
||||
avcodec/ra144enc: Fix invalid left shift of negative number
|
||||
avcodec/adxenc: Avoid undefined left shift of negative numbers
|
||||
avcodec/adpcm: Fix undefined left shifts of negative numbers
|
||||
avformat/segafilmenc: Fix undefined left shift of 1 by 31 places
|
||||
avcodec/proresenc_anatoliy: Fix invalid left shift of negative number
|
||||
avformat/wtvdec: Fix memleak when reading header fails
|
||||
avformat/fitsdec: Fix potential leak of string in AVBPrint
|
||||
avformat/matroskadec: Fix use-after-free when demuxing ProRes
|
||||
avformat/matroskadec: Fix demuxing ProRes
|
||||
avcodec/bitstream: Don't check for undefined behaviour after it happened
|
||||
avformat/mov: fix memleaks
|
||||
libavformat/mov: Fix memleaks when demuxing DV audio
|
||||
avformat/utils: reorder duration computation to avoid overflow
|
||||
avcodec/pngdec: Check for fctl after idat
|
||||
avformat/hls: Pass a copy of the URL for probing
|
||||
avformat/hls: check segment duration value of EXTINF
|
||||
avutil/common: Fix integer overflow in av_ceil_log2_c()
|
||||
avcodec/wmalosslessdec: fix overflow with pred in revert_cdlms
|
||||
avformat/mvdec: Fix integer overflow with billions of channels
|
||||
avformat/microdvddec: skip malformed lines without frame number.
|
||||
avformat/mxfdec: free duplicated utf16 strings
|
||||
avformat/4xm: Check that a video stream was created before returning packets for it
|
||||
avcodec/ffwavesynth: Avoid undefined operation on ts overflow
|
||||
avcodec/mpeg4videodec: Fix 2 integer overflows in get_amv()
|
||||
avcodec/lossless_audiodsp: Fix undefined overflows in scalarproduct_and_madd_int16_c()
|
||||
avcodec/sonic: Fix several integer overflows
|
||||
avcodec/mpeg4videodec: avoid invalid values and reinitialize in format changes for studio profile
|
||||
avcodec/pixlet: Fix log(0) check
|
||||
avcodec/iff: Fix off by x error
|
||||
avcodec/wmalosslessdec: Check block_align maximum
|
||||
avcodec/loco: Fix signed integer overflow in loco_get_rice()
|
||||
avformat/thp: Check fps
|
||||
avformat/mpl2dec: Fix integer overflow with duration
|
||||
avcodec/mpeg12dec: remove outdated comments
|
||||
avcodec/snowdec: Avoid integer overflow with huge qlog
|
||||
avformat/mov: Check if DTS is AV_NOPTS_VALUE in mov_find_next_sample().
|
||||
avcodec/mpeg12dec: Fix got_output
|
||||
avformat/4xm: Cleanup on GET_LIST_HEADER() failure
|
||||
avcodec/lzf: Consider the needed size in reallocation
|
||||
avformat/mlvdec: fail reading a packet with 0 streams
|
||||
avformat/thp: Check compcount
|
||||
avcodec/adpcm: XA: Check shift similar to filter
|
||||
avcodec/huffyuvdec: Test vertical coordinate more often
|
||||
avcodec/hq_hqa: Check info size
|
||||
avcodec/wmalosslessdec: Fix integer overflow in mclms_predict()
|
||||
avcodec/vp9dsp_template: Fix integer overflow(s) in iadst16_1d()
|
||||
avcodec/h264dec: Disable forced small_padding on flag2 fast
|
||||
avformat/oggparsevorbis: Error out on double init of vp
|
||||
avcodec/pnmdec: Use unsigned for maxval rescaling
|
||||
avcodec/ivi: Clear got_p_frame before decoding a new frame using it
|
||||
avcodec/dsddec: Check channels
|
||||
avcodec/xvididct: Fix integer overflow in idct_row()
|
||||
avcodec/wmalosslessdec: Fix integer overflows in revert_inter_ch_decorr()
|
||||
avformat/mpegenc: Fix integer overflow with AV_NOPTS_VALUE
|
||||
avformat/swfenc: Fix integer overflow in frame rate handling
|
||||
avformat/aadec: Check toc_size to contain the minimum to demuxer uses
|
||||
avcodec/cbs_h265_syntax_template: Limit num_long_term_pics more strictly
|
||||
avformat/mov: Don't allow negative sample sizes.
|
||||
mpeg4videoenc: Don't crash with -fsanitize=bounds
|
||||
avformat/mpegts: Shuffle avio_seek
|
||||
avcodec/binkaudio: Fix 2Ghz sample_rate
|
||||
avcodec/adpcm: Fix integer overflow in ADPCM THP
|
||||
avcodec/ralf: Check num_blocks before use
|
||||
avcodec/iff: Test video_size being non zero
|
||||
avcodec/utvideodec: Fix integer overflow in decode_plane()
|
||||
avcodec/ttadsp: Fix several integer overflows in tta_filter_process_c()
|
||||
avcodec/ralf: Fix integer overflow in decode_block()
|
||||
avcodec/nuv: widen buf_size type
|
||||
avcodec/iff: Fix several integer overflows
|
||||
avcodec/g729postfilter: Clip gain before scaling with AGC_FAC1
|
||||
avcodec/alac: Fix integer overflow with 24/20bps samples
|
||||
avcodec/dstdec: Check sample rate
|
||||
avformat/thp: Require a video stream
|
||||
avformat/mpeg: Decrease score by 1 for files with very little valid data
|
||||
avcodec/pngdec: Check length in fdAT
|
||||
avcodec/g2meet: Check tile_width in epic_jb_decode_tile()
|
||||
avcodec/hapdec: Check tex_size more strictly and before using it
|
||||
avcodec/vp9dsp_template: Fix integer overflows in idct32_1d()
|
||||
avcodec/alacdsp: Fix invalid shift in append_extra_bits()
|
||||
libavcodec/wmalosslessdec: prevent sum of positive numbers from becoming negative
|
||||
avcodec/dstdec: Fix integer overflow in read_table()
|
||||
avcodec/txd: Check for input size against the header size.
|
||||
avcodec/svq1dec: Check that there is data left after the header
|
||||
avcodec/cbs_h265_syntax_template: Check num_negative/positive_pics when inter_ref_pic_set_prediction_flag is set
|
||||
avcodec/intrax8: Check for end of bitstream in ff_intrax8_decode_picture()
|
||||
avcodec/hevc_mp4toannexb_bsf: Check nalu_size
|
||||
avcodec/iff: Check length before memcpy() in decode_deep_rle32()
|
||||
avcodec/iff: Fix invalid pointer intermediates in decode_deep_rle32()
|
||||
avcodec/pngdec: Pass ret from decode_iccp_chunk()
|
||||
avcodec/rv40dsp: Fix integer overflows in rv40_weight_func_*()
|
||||
avcodec/ac3dec_fixed: Fix several invalid left shifts in scale_coefs()
|
||||
avcodec/flac_parser: Do not lose header count in find_headers_search()
|
||||
avcodec/audiodsp: Fix integer overflow in scalarproduct_int16_c()
|
||||
avformat/oggdec: Check for EOF after page header
|
||||
swscale/yuv2rgb: Fix vertical dither offset with slices
|
||||
avcodec/dpcm: clip exponent into supported range in XAN DPCM
|
||||
avcodec/flacdsp_template: Fix invalid shifts in decorrelate
|
||||
avcodec/xvididct: Fix integer overflow in MULT()
|
||||
avcodec/ffwavesynth: Correct undefined overflow of PINK_UNIT
|
||||
avcodec/cbs_h264_syntax_template: fix off by 1 error with slice_group_change_cycle
|
||||
swscale/output: Fix integer overflow in yuv2rgb_write_full() with out of range input
|
||||
swscale/output: Fix integer overflow in alpha computation in yuv2gbrp16_full_X_c()
|
||||
libavformat/amr.c: Check return value from avio_read()
|
||||
libavformat/mov.c: Free aes_decrypt to avoid leaking memory
|
||||
libavformat/oggdec.c: Check return value from avio_read()
|
||||
avformat/asfdec_f: Fix overflow check in get_tag()
|
||||
avformat/nsvdec: Fix memleaks on errors while reading the header
|
||||
avcodec/ffwavesynth: Fix integer overflow in computation of ddphi
|
||||
avcodec/adpcm: Fix invalid shift in AV_CODEC_ID_ADPCM_PSX
|
||||
avcodec/mpeg12dec: Fix invalid shift in mpeg2_fast_decode_block_intra()
|
||||
avcodec/cbs_h2645: Treat slices without data as invalid
|
||||
avcodec/cbs_h2645: Remove dead code to delete trailing zeroes
|
||||
avcodec/mpegaudioenc_template: fix invalid shift of sample
|
||||
avcodec/motion_est_template: Fix invalid shifts in no_sub_motion_search()
|
||||
libavformat/avienc: Check bits per sample for PAL8
|
||||
avformat/mpegts: Improve the position determination for avpriv_mpegts_parse_packet()
|
||||
avcodec/magicyuv: Check that there are enough lines for interlacing to be possible
|
||||
avformat/mvdec: Check stream numbers
|
||||
avcodec/pcm: Fix invalid shift in AV_CODEC_ID_PCM_LXF
|
||||
avcodec/qdm2: Check fft_coefs_index
|
||||
avformat/utils: Fix integer overflow with complex time bases in avformat_find_stream_info()
|
||||
avformat/avidec: Avoid integer overflow in NI switch check
|
||||
fftools/ffmpeg: Fix integer overflow in duration computation in seek_to_start()
|
||||
avfilter/vf_aspect: Fix integer overflow in compute_dar()
|
||||
avcodec/apedec: Fix invalid shift with 24 bps
|
||||
avformat/utils: Fix undefined behavior in ff_configure_buffers_for_index()
|
||||
avcodec/dpcm: Fix integer overflow in AV_CODEC_ID_GREMLIN_DPCM
|
||||
avcodec/wmalosslessdec: Fix integer overflow with sliding in padding bits
|
||||
avcodec/wmalosslessdec: Fix loop in revert_acfilter()
|
||||
avcodec/lagarith: Sanity check scale
|
||||
avcodec/apedec: Fix integer overflows in predictor_decode_mono_3950()
|
||||
avcodec/ralf: Fix integer overflow in apply_lpc()
|
||||
avcodec/dca_lbr: Fix some error codes and error passing
|
||||
avcodec/wmavoice: Fix rounding and integer anomalies in calc_input_response()
|
||||
avcodec/wmavoice: sanity check block_align
|
||||
avcodec/pcm: Fix invalid shift in pcm_decode_frame for LXF
|
||||
avcodec/snappy: Sanity check bytestream2_get_levarint()
|
||||
avcodec/mlpdsp: Fix a invalid shift in ff_mlp_rematrix_channel()
|
||||
avcodec/avdct: Clear IDCTDSPContext context
|
||||
avcodec/x86/diracdsp: Fix high bits on Windows x86_64
|
||||
avformat/mov: Check STCO location
|
||||
avcodec/wmalosslessdec: Fix multiple integer overflows
|
||||
avcodec/apedec: Fix undefined integer overflow in decode_array_0000()
|
||||
avcodec/smacker: Check space before decoding type
|
||||
avcodec/rawdec: Use linesize in b64a
|
||||
avcodec/iff: Over-allocate ham_palbuf for HAM6 IFF-PBM
|
||||
avcodec/x86/diracdsp: Fix incorrect src addressing in dequant_subband_32()
|
||||
avfilter/vf_find_rect: Remove assert
|
||||
avfilter/vf_find_rect: Increase worst case score
|
||||
swscale/input: Fix several invalid shifts related to rgb2yuv constants
|
||||
swscale/output: Fix several invalid shifts in yuv2rgb_full_1_c_template()
|
||||
swscale/swscale: Fix several invalid shifts related to vChrDrop
|
||||
avcodec/hevc_mp4toannexb_bsf: check that nalu size doesnt overflow
|
||||
avcodec/hevc_mp4toannexb_bsf: Avoid NULL memcpy()
|
||||
avcodec/wmalosslessdec: move channel check up
|
||||
avcodec/cbs_h2645: Skip all 0 NAL units
|
||||
avcodec/adpcm: Fix overflow in FFABS() IMA_EA_EACS
|
||||
avcodec/alac: Fix integer overflow in LPC coefficient adaption
|
||||
avcodec/g729postfilter: Optimize out overflowing multiplication from apply_tilt_comp()
|
||||
avcodec/vc1dec: Check field_mode for sprites
|
||||
avcodec/vc1dec: Limit bits by the actual bitstream size
|
||||
avcodec/vmdaudio: Check block_align more
|
||||
configure: bump year
|
||||
avcodec/pgssubdec: Free subtitle on error
|
||||
avcodec/ffwavesynth: Fix undefined overflow in wavesynth_synth_sample()
|
||||
avcodec/cook: Use 3 stage VLC decoding for channel_coupling
|
||||
avcodec/wmalosslessdec: Fixes undefined overflow in dequantization in decode_subframe()
|
||||
avcodec/sonic: Check e in get_symbol()
|
||||
avcodec/twinvqdec: Correct overflow in block align check
|
||||
avcodec/vc1dec: Fix "return -1" cases
|
||||
avcodec/vc1dec: Free sprite_output_frame on error
|
||||
avcodec/wmadec: Keep track of exponent initialization per channel
|
||||
avcodec/iff: Check that video_size is large enough for the read parameters
|
||||
avcodec/adpcm: Clip predictor for APC
|
||||
avcodec/targa: Check colors vs. available space
|
||||
avcodec/dstdec: Use get_ur_golomb_jpegls()
|
||||
avcodec/wmavoice: Check remaining input in parse_packet_header()
|
||||
avcodec/wmalosslessdec: Fix 2 overflows in mclms
|
||||
avcodec/wmaprodec: Fixes integer overflow with 32bit samples
|
||||
avcodec/adpcm: Fix invalid shift in xa_decode()
|
||||
avcodec/wmalosslessdec: Fix several integer issues
|
||||
avcodec/wmalosslessdec: Check that padding bits is not more than sample bits
|
||||
avcodec/iff: Skip overflowing runs in decode_delta_d()
|
||||
avcodec/pnm: Check that the header is not truncated
|
||||
avcodec/mp3_header_decompress_bsf: Check sample_rate_index
|
||||
avformat/rmdec: Initialize and sanity check offset in ivr_read_header()
|
||||
avcodec/apedec: Fix 2 integer overflows
|
||||
avformat/id3v2: Fix double-free on error
|
||||
avcodec/wmaprodec: Set packet_loss when we error out on a sanity check
|
||||
avcodec/wmaprodec: Check offset
|
||||
avcodec/truemotion2: Fix 2 integer overflows in tm2_low_res_block()
|
||||
avcodec/wmaprodec: Check if the channel sum of all internal contexts match the external
|
||||
avcodec/g729dec: require buf_size to be non 0
|
||||
avcodec/alac: Fix integer overflow in lpc_prediction() with sign
|
||||
avcodec/wmaprodec: Fix buflen computation in save_bits()
|
||||
avcodec/vc1_block: Fix integer overflow in AC rescaling in vc1_decode_i_block_adv()
|
||||
avcodec/vmdaudio: Check chunk counts to avoid integer overflow
|
||||
avformat/mxfdec: Clear metadata_sets_count in mxf_read_close()
|
||||
avcodec/nuv: Use ff_set_dimensions()
|
||||
avcodec/ffwavesynth: Fix integer overflow with pink_ts_cur/next
|
||||
avcodec/ralf: Fix integer overflows with the filter coefficient in decode_channel()
|
||||
avcodec/g729dec: Use 64bit and clip in scalar product
|
||||
avcodec/mxpegdec: Check for multiple SOF
|
||||
avcodec/nuv: Move comptype check up
|
||||
avcodec/wmavoice: Fix integer overflow in synth_frame()
|
||||
avcodec/rawdec: Check bits_per_coded_sample more pedantically for 16bit cases
|
||||
avutil/lfg: Correct index increment type to avoid undefined behavior
|
||||
avcodec/cngdec: Remove AV_CODEC_CAP_DELAY
|
||||
libavcodec/libvpxenc: Don't free user-provided AVPacket
|
||||
libavcodec/libmp3lame: Don't free user-provided AVPacket
|
||||
avcodec/libopusenc: Don't free user-provided AVPacket
|
||||
avcodec/cbs_h265: fix writing extension_data bits
|
||||
avformat/matroskadec: Fix default value of BlockAddID
|
||||
|
||||
|
||||
version 4.0.5:
|
||||
avcodec/iff: Move index use after check in decodeplane8()
|
||||
avcodec/atrac3: Check for huge block aligns
|
||||
avcodec/ralf: use multiply instead of shift to avoid undefined behavior in decode_block()
|
||||
avcodec/wmadec: Require previous exponents for reuse
|
||||
avcodec/vc1_block: Fix undefined behavior in ac prediction rescaling
|
||||
avcodec/qdm2: The smallest header seems to have 2 bytes so treat 1 as invalid
|
||||
avcodec/apedec: Fixes integer overflow of res+*data in do_apply_filter()
|
||||
avcodec/sonic: Fix integer overflow in predictor_calc_error()
|
||||
avformat/mp3dec: Check that the frame fits within the probe buffer
|
||||
lavc/tableprint_vlc: Remove avpriv_request_sample() from included files.
|
||||
avcodec/wmaprodec: get frame during frame decode
|
||||
avcodec/interplayacm: Fix overflow of last unused value
|
||||
avcodec/adpcm: Fix undefined behavior with negative predictions in IMA OKI
|
||||
avcodec/cook: Move up and extend block_align check
|
||||
avcodec/sbcdec: Fix integer overflows in sbc_synthesize_four()
|
||||
avcodec/twinvq: Check block_align
|
||||
avcodec/cook: Enlarge gain table
|
||||
avcodec/cook: Check samples_per_channel earlier
|
||||
avcodec/atrac3plus: Check split point in fill mode 3
|
||||
avcodec/wmavoice: Check sample_rate
|
||||
avcodec/xsubdec: fix overflow in alpha handling
|
||||
avcodec/iff: Check available space before entering loop in decode_long_vertical_delta2() / decode_long_vertical_delta()
|
||||
avcodec/apedec: Fix integer overflow in filter_3800()
|
||||
avutil/lfg: Document the AVLFG struct
|
||||
avcodec/ffv1dec: Use a different error message for the slice level CRC
|
||||
avcodec/apedec: Fix undefined integer overflow in long_filter_ehigh_3830()
|
||||
avcodec/dstdec: Check that AC probabilities are within range
|
||||
avcodec/dstdec: Check read_table() for failure
|
||||
avcodec/snowenc: Set mb_num to avoid ratecontrol floating point divisions by 0.0
|
||||
avcodec/snowenc: Fix 2 undefined shifts
|
||||
avformat/nutenc: Do not pass NULL to memcmp() in get_needed_flags()
|
||||
avcodec/aptx: Check the number of channels
|
||||
avcodec/aacdec_template: Check samplerate
|
||||
avcodec/truemotion2: Fix several integer overflows in tm2_low_res_block()
|
||||
avcodec/utils: Check block_align
|
||||
avcodec/wmalosslessdec: Fix some integer anomalies
|
||||
avcodec/adpcm: Fix invalid shifts in ADPCM DTK
|
||||
avcodec/apedec: Only clear the needed buffer space, instead of all
|
||||
avcodec/libvorbisdec: Fix insufficient input checks leading to out of array reads
|
||||
avcodec/g723_1dec: fix invalid shift with negative sid_gain
|
||||
avcodec/vp5: Check render_x/y
|
||||
avcodec/qdrw: Check input for header/skiped space before get_buffer()
|
||||
avcodec/ralf: Skip initializing unused filter variables
|
||||
avcodec/takdec: Fix overflow with large sample rates
|
||||
avcodec/alsdec: Check that input space for header exists in read_diff_float_data()
|
||||
avformat/pjsdec: Check duration for overflow
|
||||
avcodec/ptx: Check that the input contains at least one line
|
||||
avcodec/alac: Fix integer overflow in LPC
|
||||
avcodec/smacker: Fix integer overflows in pred[] in smka_decode_frame()
|
||||
avcodec/aliaspixdec: Check input size against minimal picture size
|
||||
avcodec/ffwavesynth: Fix integer overflows in pink noise addition
|
||||
avcodec/vc1_block: Fixes integer overflow in vc1_decode_i_block_adv()
|
||||
avcodec/wmalosslessdec: Check block_align
|
||||
avcodec/g729postfilter: Fix left shift of negative value
|
||||
avcodec/binkaudio: Check sample rate
|
||||
avcodec/sbcdec: Fix integer overflows in sbc_synthesize_eight()
|
||||
avcodec/adpcm: Check initial predictor for ADPCM_IMA_EA_EACS
|
||||
avcodec/g723_1dec: Fix overflow in shift
|
||||
avcodec/apedec: Fix integer overflow in predictor_update_3930()
|
||||
avcodec/g729postfilter: Fix undefined intermediate pointers
|
||||
avcodec/g729postfilter: Fix undefined shifts
|
||||
avcodec/lsp: Fix undefined shifts in lsp2poly()
|
||||
avcodec/adpcm: Fix left shifts in AV_CODEC_ID_ADPCM_EA
|
||||
avformat/shortendec: Check k in probe
|
||||
avfilter/vf_geq: Use av_clipd() instead of av_clipf()
|
||||
avcodec/wmaprodec: Check that the streams channels do not exceed the overall channels
|
||||
avcodec/qdmc: Check input space in qdmc_get_vlc()
|
||||
avcodec/pcm: Check bits_per_coded_sample
|
||||
avcodec/exr: Allow duplicate use of channel indexes
|
||||
avcodec/fitsdec: Fail on 0 naxisn
|
||||
avcodec/dxv: Subtract 12 earlier in dxv_decompress_cocg()
|
||||
libavcodec/dxv: Remove redundant seek
|
||||
avcodec/ituh263dec: Check input for minimal frame size
|
||||
avcodec/truemotion1: Check that the input has enough space for a minimal index_stream
|
||||
avformat/mpsubdec: Clear queue on error
|
||||
avcodec/sunrast: Check that the input is large enough for the maximally compressed image
|
||||
avcodec/sunrast: Check for availability of maplength before allocating image
|
||||
avformat/subtitles: Check nb_subs in ff_subtitles_queue_finalize()
|
||||
avcodec/wmaprodec: Check if there is a stream
|
||||
avcodec/g2meet: Check for end of input in jpg_decode_block()
|
||||
avcodec/g2meet: Check if adjusted pixel was on the stack
|
||||
avformat/electronicarts: If no packet has been read at the end do not treat it as if theres a packet
|
||||
avcodec/dxv: Check op_offset in dxv_decompress_yo()
|
||||
avcodec/utils: Check sample_rate before opening the decoder
|
||||
avcodec/aptx: Fix multiple shift anomalies
|
||||
avcodec/fitsdec: fix use of uninitialised values
|
||||
avcodec/motionpixels: Mark 2 functions as always_inline
|
||||
avcodec/ituh263dec: Make the condition for the studio slice start code match between ff_h263_resync() and ff_mpeg4_decode_studio_slice_header()
|
||||
avcodec/ralf: Fix integer overflow in decode_channel()
|
||||
vcodec/vc1: compute rangex/y only for P/B frames
|
||||
avcodec/vc1_pred: Fix invalid shifts in scaleforopp()
|
||||
avcodec/vc1_block: Fix invalid shift with rangeredfrm
|
||||
avcodec/vc1: Check for excessive resolution
|
||||
avcodec/vc1: check REFDIST
|
||||
avcodec/apedec: Fix several integer overflows in predictor_update_filter() and do_apply_filter()
|
||||
avcodec/hevc_cabac: Tighten the limit on k in ff_hevc_cu_qp_delta_abs()
|
||||
avcodec/4xm: Check index in decode_i_block() also in the path where its not used.
|
||||
avcodec/atrac3: Check block_align
|
||||
avcodec/alsdec: Avoid dereferencing context pointer in inner interleave loop
|
||||
avcodec/fitsdec: Prevent division by 0 with huge data_max
|
||||
avcodec/dstdec: Fix integer overflow in samples_per_frame computation
|
||||
avcodec/g729_parser: Check block_size
|
||||
avcodec/sbcdec: Initialize number of channels
|
||||
avcodec/utils: Optimize ff_color_frame() using memcpy()
|
||||
avcodec/aacdec: Check if we run out of input in read_stream_mux_config()
|
||||
avcodec/utils: Use av_memcpy_backptr() in ff_color_frame()
|
||||
avcodec/smacker: Fix integer overflow in signed int multiply in SMK_BLK_FILL
|
||||
avcodec/alac: Fix invalid shifts in 20/24 bps
|
||||
avcodec/alac: fix undefined behavior with INT_MIN in lpc_prediction()
|
||||
avcodec/ffwavesynth: Fix integer overflow in timestamps
|
||||
avcodec/dxv: Check op_offset in both directions
|
||||
avcodec/adpcm: Check number of channels for MTAF
|
||||
avcodec/sunrast: Fix indention
|
||||
avcodec/sunrast: Fix return type for "unsupported (compression) type"
|
||||
avformat/mov: Check for EOF in mov_read_meta()
|
||||
avcodec/hevcdec: Fix memleak of a53_caption
|
||||
avformat/cdxl: Fix integer overflow in intermediate
|
||||
avcodec/hevcdec: repeat character in skiped
|
||||
avcodec/gdv: Replace assert() checking bitstream by if()
|
||||
libavcodec/utils: Free threads on init failure
|
||||
avcodec/htmlsubtitles: Avoid locale dependant isdigit()
|
||||
avcodec/alsdec: Check k from being outside what our implementation can handle
|
||||
avcodec/takdec: Fix integer overflow in decorrelate()
|
||||
avcodec/aacps: Fix integer overflows in hybrid_synthesis()
|
||||
avcodec/mpeg4videodec: Fix integer overflow in mpeg4_decode_studio_block()
|
||||
avcodec/vp56rac: delay signaling an error on truncated input
|
||||
avcodec/vp5/6/8: use vpX_rac_is_end()
|
||||
avcodec/vp56: Add vpX_rac_is_end() to check for the end of input
|
||||
avcodec/qdm2: Check frame size
|
||||
avcodec/vc1_pred: Fix refdist in scaleforopp()
|
||||
avcodec/vorbisdec: fix FASTDIV usage for vr_type == 2
|
||||
avcodec/iff: Check for overlap in cmap_read_palette()
|
||||
avcodec/apedec: Fix 32bit int overflow in do_apply_filter()
|
||||
avcodec/ralf: fix undefined shift in extend_code()
|
||||
avcodec/ralf: fix undefined shift
|
||||
avcodec/bgmc: Check input space in ff_bgmc_decode_init()
|
||||
avcodec/truemotion2: Fix multiple integer overflows in tm2_null_res_block()
|
||||
avcodec/vc1dec: Require res_sprite for wmv3images
|
||||
avcodec/vc1_block: Check for double escapes
|
||||
avcodec/vorbisdec: Check get_vlc2() failure
|
||||
avcodec/tta: Fix integer overflow in prediction
|
||||
avcodec/vb: Check input packet size to be large enough to contain flags
|
||||
avcodec/cavsdec: Limit the number of access units per packet to 2
|
||||
avcodec/alac: Check for bps of 0
|
||||
avcodec/alac: Fix multiple integer overflows in lpc_prediction()
|
||||
avcodec/rl2: set dimensions
|
||||
avcodec/aacdec: Add FF_CODEC_CAP_INIT_CLEANUP
|
||||
avcodec/idcinvideo: Add 320x240 default maximum resolution
|
||||
avformat/realtextdec: free queue on error
|
||||
avcodec/alsdec: Fix integer overflow in decode_var_block_data()
|
||||
avcodec/alsdec: Limit maximum channels to 512
|
||||
avcodec/anm: Check input size for a frame with just a stop code
|
||||
avcodec/flicvideo: Optimize and Simplify FLI_COPY in flic_decode_frame_24BPP() by using bytestream2_get_buffer()
|
||||
avcodec/loco: Check left column value
|
||||
avcodec/ffwavesynth: Fixes invalid shift with pink noise seeking
|
||||
avcodec/ffwavesynth: Fix integer overflow for some corner case values
|
||||
avcodec/indeo2: Check remaining input more often
|
||||
avcodec/diracdec: Check that slices are fewer than pixels
|
||||
avcodec/vp56: Consider the alpha start as end of the prior header
|
||||
avcodec/4xm: Check for end of input in decode_p_block()
|
||||
avcodec/hevcdec: Check delta_luma_weight_l0/1
|
||||
avcodec/hnm4video: Optimize postprocess_current_frame()
|
||||
avcodec/hevc_refs: Optimize 16bit generate_missing_ref()
|
||||
avcodec/scpr: Use av_memcpy_backptr() in type 17 and 33
|
||||
avcodec/dds: Use ff_set_dimensions()
|
||||
avcodec/mpc8: Fix 32bit mask/enum
|
||||
avcodec/alsdec: Fix integer overflows of raw_samples in decode_var_block_data()
|
||||
avcodec/alsdec: Fix integer overflow of raw_samples in decode_blocks()
|
||||
avcodec/alsdec: fix mantisse shift
|
||||
avcodec/aacdec_template: fix integer overflow in imdct_and_windowing()
|
||||
libavcodec/iff: Use unsigned to avoid undefined behaviour
|
||||
avcodec/alsdec: Check for block_length <= 0 in read_var_block_data()
|
||||
avcodec/vqavideo: Set video size
|
||||
avcodec/sanm: Check extradata_size before allocations
|
||||
avcodec/mss1: check for overread and forward errors
|
||||
avcodec/dirac_parser: Fix overflow in dts
|
||||
avcodec/ralf: Fix undefined pointer in decode_channel()
|
||||
avcodec/ralf: Fix integer overflow in apply_lpc()
|
||||
avcodec/vorbisdec: Implement vr->classifications = 1
|
||||
avcodec/vorbisdec: Check parameters in vorbis_floor0_decode() before divide
|
||||
avformat/realtextdec: Check for duplicate extradata in realtext_read_header()
|
||||
avcodec/apedec: Fix 2 signed overflows
|
||||
avcodec/mss3: Check for the rac stream being invalid in rac_normalize()
|
||||
avcodec/vc1_block: Check get_vlc2() return before use
|
||||
avcodec/apedec: Do not partially clear data array
|
||||
avcodec/hnm4video: Forward errors of decode_interframe_v4()
|
||||
avcodec/clearvideo: fix invalid shift in tile size check
|
||||
avcodec/vp3: Check that theora is theora
|
||||
avcodec/vc1_pred: Fix invalid shift in scaleforsame()
|
||||
avcodec/vc1_block: Fix integer overflow in ff_vc1_pred_dc()
|
||||
avcodec/truemotion2: Fix several integer overflows in tm2_motion_block()
|
||||
avcodec/apedec: make left/right unsigned to avoid undefined behavior
|
||||
avcodec/apedec: Fix multiple integer overflows and undefined behaviorin filter_3800()
|
||||
avformat/mpc: deallocate frames array on errors
|
||||
avcodec/eatqi: Check for minimum frame size
|
||||
avcodec/eatgv: Check remaining size after the keyframe header
|
||||
avcodec/assdec: undefined use of memcpy()
|
||||
avcodec/brenderpix: Check input size before allocating image
|
||||
lafv/wavdec: Fail bext parsing on incomplete reads
|
||||
avcodec/utils: fix leak of subtitle_header on error path
|
||||
avcodec/utils: Check close before calling it
|
||||
avcodec/vorbisdec: Check vlc for floor0 dec vector offset
|
||||
avcodec/vorbisdec: amplitude bits can be more than 25 bits
|
||||
avutil/softfloat_ieee754: Fix odd bit position for exponent and sign in av_bits2sf_ieee754()
|
||||
avcodec/apedec: Fix various integer overflows
|
||||
avcodec/apedec: Fix multiple integer overflows in predictor_update_filter()
|
||||
avcodec/alsdec: fix undefined shift in multiply()
|
||||
avcodec/alsdec: Fix 2 integer overflows
|
||||
avcodec/flicvideo: Make line_packets int
|
||||
avcodec/dvbsubdec: Use ff_set_dimensions()
|
||||
avcodec/ffwavesynth: Check if there is enough extradata before allocation
|
||||
avcodec/ffwavesynth: More correct cast in wavesynth_seek()
|
||||
avcodec/ffwavesynth: Check sample rate before use
|
||||
avcodec/dnxhd_parser: Fix parser when input does not have nicely sized packets
|
||||
avcodec/dnxhd_parser: remove unneeded code
|
||||
avformat/utils: Check rfps_duration_sum for overflow
|
||||
avcodec/h264_refs: Also check reference in ff_h264_build_ref_list()
|
||||
avcodec/parser: Check next index validity in ff_combine_frame()
|
||||
avcodec/ivi: Ask for samples with odd tiles
|
||||
avformat/xmv: Make bitrate 64bit
|
||||
avcodec/pngdec: Check that previous_picture has same w/h/format
|
||||
avcodec/huffyuv: remove gray8a (the format is listed but not supported by the implementation)
|
||||
avcodec/mpc8: Fixes invalid shift in mpc8_decode_frame()
|
||||
avcodec/utils, avcodec_open2: close codec on failure
|
||||
avcodec/golomb: Correct the doxy about get_ue_golomb() and errors
|
||||
avformat/utils: Check timebase before use in estimate_timings()
|
||||
avcodec/hq_hqa: Use ff_set_dimensions()
|
||||
avcodec/rv10: Fix integer overflow in aspect ratio compare
|
||||
avcodec/4xm: Fix signed integer overflows in idct()
|
||||
avcodec/qdm2: Check checksum_size for 0
|
||||
avcodec/qdm2: error out of qdm2_fft_decode_tones() before entering endless loop
|
||||
avcodec/qdm2: Do not read out of array in fix_coding_method_array()
|
||||
avcodec/svq3: Use ff_set_dimension()
|
||||
avcodec/iff: Check ham vs bpp
|
||||
avcodec/ffwavesynth: use uint32_t to compute difference, it is enough
|
||||
avcodec/ffwavesynth: Simplify lcg_seek(), avoid negative case
|
||||
avcodec/ffwavesynth: Fix backward lcg_seek()
|
||||
avcodec/flicvideo: Fix off by 1 error in flic_decode_frame_24BPP()
|
||||
avcodec/vc1_block: Check for vlc error in vc1_decode_ac_coeff()
|
||||
avcodec/alac: Check lpc_quant
|
||||
avcodec/dxv: Initialize tex_funct to NULL
|
||||
avcodec/alsdec: Add FF_CODEC_CAP_INIT_CLEANUP
|
||||
avcodec/alsdec: Fix integer overflow with buffer number
|
||||
avcodec/alsdec: Fixes signed integer overflow in LSB addition
|
||||
avcodec/alsdec: Check opt_order / sb_length in ra_block handling
|
||||
avcodec/alsdec: Fix integer overflow with shifting samples
|
||||
avcodec/alsdec: Fix undefined behavior in decode_rice()
|
||||
avcodec/alsdec: Fixes invalid shifts in read_var_block_data() and INTERLEAVE_OUTPUT()
|
||||
avcodec/hevc_ps: Change num_tile_rows/columns checks to sps->ctb_height/weight
|
||||
avcodec/hevc_ps: Fix integer overflow with num_tile_rows and num_tile_columns
|
||||
avcodec/apedec: Add k < 24 check to the only k++ case which lacks such a check
|
||||
avformat/aviobuf: Delay buffer downsizing until asserts are met
|
||||
avcodec/fitsdec: Check data_min/max
|
||||
avcodec/m101: Fix off be 2 error
|
||||
avcodec/qdm2: Move fft_order check up
|
||||
avcodec/libvorbisdec: Check extradata size
|
||||
avformat/vqf: Check header_size
|
||||
avcodec/utils: Check bits_per_coded_sample
|
||||
avcodec/videodsp_template: Fix overflow of addition
|
||||
avcodec/alsdec: Fix invalid shift in multiply()
|
||||
avcodec/ffwavesynth: Check ts_end - ts_start for overflow
|
||||
avcodec/vc1dsp: Avoid undefined shifts in vc1_v_s_overlap_c / vc1_h_s_overlap_c
|
||||
avcodec/tta: Fix undefined shift
|
||||
avcodec/qdmc: Fix integer overflows in PRNG
|
||||
avcodec/bintext: Check font height
|
||||
avcodec/binkdsp: Fix integer overflows in idct
|
||||
avcodec/bink: Fix integer overflow in unquantize_dct_coeffs()
|
||||
avcodec/motionpixels: Check for vlc error in mp_get_vlc()
|
||||
avcodec/loco: Limit lossy parameter so it is sane and does not overflow
|
||||
avformat/mov: Set fragment.found_tfhd only after TFHD has been parsed
|
||||
avcodec/xpmdec: Do not use context dimensions as temporary variables
|
||||
avcodec/fitsdec: Fix division by 0 in size check
|
||||
avcodec/aacpsdsp_template: Fix integer overflow in ps_hybrid_analysis_c()
|
||||
avcodec/truemotion2: Fix integer overflow in last loop in tm2_update_block()
|
||||
avcodec/iff: finetune the palette size check in the mask case
|
||||
avcodec/iff: Fix mask_buf / mask_palbuf leak
|
||||
avformat/icodec: Free ico->images on error paths
|
||||
avformat/wsddec: Fix undefined shift
|
||||
avcodec/fmvc: Check if header fields are available before allocating the image
|
||||
avcodec/bink: Reorder operations in init to avoid memleak on error
|
||||
avformat/wtvdec: Avoid (32bit signed) sectors
|
||||
avcodec/bitstream: Check for more conflicting codes in build_table()
|
||||
avcodec/bitstream: Check for integer code truncation in build_table()
|
||||
avformat/sbgdec: Fixes integer overflow in str_to_time() with hours
|
||||
avformat/vpk: Check offset for validity
|
||||
avformat/vpk: Fix integer overflow in samples_per_block computation
|
||||
avcodec/mjpegdec: Check for non ls PAL8
|
||||
avcodec/interplayvideo: check decoding_map_size with video_data_size
|
||||
avcodec/h264_parse: Use 64bit for expectedpoc and expected_delta_per_poc_cycle
|
||||
avcodec/mss4: Check input size against skip bits
|
||||
avcodec/dxv: Check op_offset in dxv_decompress_cocg()
|
||||
avcodec/diracdec: Fix integer overflow in global_mv()
|
||||
avcodec/vmnc: Check available space against chunks before reget_buffer()
|
||||
avcodec/aacdec_template: skip apply_tns() if max_sfb is 0 (from previous header decode failure)
|
||||
avcodec/aacdec_fixed: Handle more extreem cases in noise_scale()
|
||||
avcodec/aacdec_template: Merge 3 #ifs related to noise handling
|
||||
avcodec/aacdec_fixed: ssign seems always -1 in noise_scale(), simplify
|
||||
avformat/mp3enc: Avoid SEEK_END as it is unsupported
|
||||
avcodec/truemotion2: Fix several integer overflows in tm2_update_block()
|
||||
avformat/webm_chunk: Specify expected argument length of get_chunk_filename()
|
||||
avformat/webm_chunk: Check header filename length
|
||||
avcodec/cpia: Check input size also against linesizes and EOL
|
||||
swscale/tests/swscale: Lengthen pixfmt name buffer to 21 bytes
|
||||
libswcale: Fix possible string overflow in test.
|
||||
avcodec/hq_hqa: Check available space before reading slice offsets
|
||||
lavf/webm_chunk: Respect buffer size
|
||||
avcodec/fits: Check bitpix
|
||||
avcodec/jvdec: Use ff_get_buffer() when the content is not reused
|
||||
avcodec/truemotion2: Fix 2 integer overflows in tm2_update_block()
|
||||
avcodec/gdv: Check input palette size before rescale()
|
||||
avcodec/jpeg2000: Check stepsize before using it
|
||||
avcodec/aacdec_fixed: Fix undefined shift in noise_scale()
|
||||
avutil/avstring: Fix bug and undefined behavior in av_strncasecmp()
|
||||
avformat/mov: Skip stsd adjustment without chunks
|
||||
avformat/aadec: Check for scanf() failure
|
||||
avcodec/ccaption_dec: Add a blank like at the end to avoid rollup reading from outside
|
||||
avcodec/ivi: Move buffer/block end check to caller of ivi_dc_transform()
|
||||
avcodec/diracdec: Use 64bit in intermediate of global motion vector field generation
|
||||
avcodec/truemotion2: Fix integer overflow in tm2_decode_blocks()
|
||||
avcodec/rscc: Check that the to be uncompressed input is large enough
|
||||
avcodec/nvenc: add driver version info for latest SDKs
|
||||
avcodec/bsf: check that AVBSFInternal was allocated before dereferencing it
|
||||
lavf/rawenc: Only accept the appropriate stream type for raw muxers.
|
||||
avcodec/h263dec: fix hwaccel decoding
|
||||
avutil/mem: Fix invalid use of av_alloc_size
|
||||
avformat/aacdec: resync to the next adts frame on invalid data instead of aborting
|
||||
avformat/aacdec: factorize the adts frame resync code
|
||||
movsub_bsf: Fix mov2textsub regression
|
||||
avformat/aacdec: fix demuxing of small frames
|
||||
avcodec/cuviddec: improve progressive frame detection
|
||||
|
||||
version 4.0.4:
|
||||
- avcodec/hevcdec: Avoid only partly skiping duplicate first slices
|
||||
- lavc/bmp: Avoid a heap buffer overwrite for 1bpp input.
|
||||
- avcodec/mpegpicture: Check size of edge_emu_buffer
|
||||
- avformat/mov: Fix potential integer overflow in entry check in mov_read_trun()
|
||||
- avcodec/truemotion2: Fix integer overflow in tm2_null_res_block()
|
||||
- avcodec/dfa: Check the chunk header is not truncated
|
||||
- avcodec/clearvideo: Check remaining data in P frames
|
||||
- avcodec/dvbsubdec: Check object position
|
||||
- avcodec/cdgraphics: Use ff_set_dimensions()
|
||||
- avformat/gdv: Check fps
|
||||
- configure: use vpx_codec_vp8_dx/cx for libvpx-vp8 checking
|
||||
- configure: add missing pthreads extralibs dependency for libvpx-vp9
|
||||
- avcodec/mpeg4videodec: Check idx in mpeg4_decode_studio_block()
|
||||
- avcodec/dxv: Correct integer overflow in get_opcodes()
|
||||
- avcodec/scpr: Fix use of uninitialized variable
|
||||
- avcodec/qpeg: Limit copy in qpeg_decode_intra() to the available bytes
|
||||
- avcodec/aic: Check remaining bits in aic_decode_coeffs()
|
||||
- avcodec/gdv: Check for truncated tags in decompress_5()
|
||||
- avcodec/bethsoftvideo: Check block_type
|
||||
- avcodec/jpeg2000dwt: Fix integer overflow in dwt_decode97_int()
|
||||
- avcodec/error_resilience: Use a symmetric check for skipping MV estimation
|
||||
- avcodec/mlpdec: Insuffient typo
|
||||
- avcodec/zmbv: obtain frame later
|
||||
- avcodec/jvdec: Check available input space before decode8x8()
|
||||
- avcodec/h264_direct: Fix overflow in POC comparission
|
||||
- avformat/webmdashenc: Check id in adaption_sets
|
||||
- avformat/http: Fix Out-of-Bounds access in process_line()
|
||||
- avformat/ftp: Fix Out-of-Bounds Access and Information Leak in ftp.c:393
|
||||
- avcodec/htmlsubtitles: Fixes denial of service due to use of sscanf in inner loop for handling braces
|
||||
- avcodec/htmlsubtitles: Fixes denial of service due to use of sscanf in inner loop for tag scaning
|
||||
- avformat/matroskadec: Do not leak queued packets on sync errors
|
||||
- avcodec/mpeg4videodec: Clear interlaced_dct for studio profile
|
||||
- avformat/mov: Do not use reference stream in mov_read_sidx() if there is no reference stream
|
||||
- avcodec/sbrdsp_fixed.c: remove input value limit for sbr_sum_square_c()
|
||||
- avformat/mov: validate chunk_count vs stsc_data
|
||||
- avformat/mov.c: require tfhd to begin parsing trun
|
||||
- avcodec/pgssubdec: Check for duplicate display segments
|
||||
- avformat/rtsp: Check number of streams in sdp_parse_line()
|
||||
- avformat/rtsp: Clear reply in every iteration in ff_rtsp_connect()
|
||||
- avcodec/fic: Check that there is input left in fic_decode_block()
|
||||
- avcodec/tiff: Check for 12bit gray fax
|
||||
- avutil/imgutils: Optimize memset_bytes() by using av_memcpy_backptr()
|
||||
- avutil/mem: Optimize fill32() by unrolling and using 64bit
|
||||
- configure: bump year
|
||||
- avcodec/diracdec: Check component quant
|
||||
- avcodec/tests/rangecoder: initialize array to avoid valgrind warning
|
||||
- avcodec/h264_slice: Fix integer overflow in implicit_weight_table()
|
||||
- avcodec/exr: set layer_match in all branches
|
||||
- avcodec/exr: Check for duplicate channel index
|
||||
- avcodec/4xm: Fix returned error codes
|
||||
- avformat/libopenmpt: Fix successfull typo
|
||||
- avcodec/v4l2_m2m: fix cant typo
|
||||
- avcodec/mjpegbdec: Fix some misplaced {} and spaces
|
||||
- avformat/wvdec: detect and error out on WavPack DSD files
|
||||
- avcodec/mips: Fix failed case: hevc-conformance-AMP_A_Samsung_* when enable msa
|
||||
- avcodec/fic: Fail on invalid slice size/off
|
||||
- postproc/postprocess_template: remove FF_REG_sp from clobber list
|
||||
- postproc/postprocess_template: Avoid using %4 for the threshold compare
|
||||
- avcodec/rpza: Check that there is enough data for all the blocks
|
||||
- avcodec/rpza: Move frame allocation to a later point
|
||||
- avcodec/avcodec: Document the data type for AV_PKT_DATA_MPEGTS_STREAM_ID
|
||||
- avformat/mpegts: Fix side data type for stream id
|
||||
- tests/fate/filter-video: increase fuzz for fate-filter-refcmp-psnr-rgb
|
||||
- avcodec/mjpegdec: Fix indention of ljpeg_decode_yuv_scan()
|
||||
- lavf/id3v2: fail read_apic on EOF reading mimetype
|
||||
- avformat/nutenc: Document trailer index assert better
|
||||
- lavf/mov: ensure only one tkhd per trak
|
||||
- avcodec/clearvideo: Check remaining input bits in P macro block loop
|
||||
- avcodec/dxv: Check that there is enough data to decompress
|
||||
- avcodec/ppc/hevcdsp: Fix build failures with powerpc-linux-gnu-gcc-4.8 with --disable-optimizations
|
||||
- avcodec/msvideo1: Check for too small dimensions
|
||||
- avcodec/wmv2dec: Skip I frame if its smaller than 1/8 of the minimal size
|
||||
- avcodec/msmpeg4dec: Skip frame if its smaller than 1/8 of the minimal size
|
||||
- avcodec/truemotion2rt: Fix rounding in input size check
|
||||
- avcodec/truemotion2: fix integer overflows in tm2_low_chroma()
|
||||
- avcodec/pngdec: Check compression method
|
||||
- fftools/ffmpeg: Repair reinit_filter feature
|
||||
- avcodec/shorten: Fix integer overflow with offset
|
||||
- h264_redundant_pps: Fix logging context
|
||||
- avcodec/cavsdec: Propagate error codes inside decode_mb_i()
|
||||
- avcodec/mpeg4videodec: Clear partitioned frame in decode_studio_vop_header()
|
||||
- avcodec/mpegaudio_parser: Consume more than 0 bytes in case of the unsupported mp3adu case
|
||||
- avcodec/hevcdec: decode at most one slice reporting being the first in the picture
|
||||
- avformat/dsfdec: fix calculation of size of data chunk
|
||||
- avformat/dsfdec: properly handle padded last packet
|
||||
- avcodec/hevcdec: fix non-ref frame judgement
|
||||
- avcodec/libaomenc: remove AVOption related to frame partitions
|
||||
|
||||
version 4.0.3:
|
||||
- avutil/integer: Fix integer overflow in av_mul_i()
|
||||
- avcodec/msrle: Check that the input is large enough to contain a end of picture code
|
||||
- avformat/ftp: return AVERROR_EOF for EOF
|
||||
- avcodec/libx264: remove FF_CODEC_CAP_INIT_THREADSAFE flag
|
||||
- avcodec/jpeg2000dec: Fix off by 1 error in JPEG2000_PGOD_CPRL handling
|
||||
- avcodec/mpeg4videodec: Fix typo in sprite delta check
|
||||
- avcodec/h264_cavlc: Check mb_skip_run
|
||||
- avcodec/ra144: Fix integer overflow in add_wav()
|
||||
- avformat/utils: Never store negative values in last_IP_duration
|
||||
- avformat/utils: Fix integer overflow in discontinuity check
|
||||
- Revert "avcodec/cbs_h264: silence errors about end_of_seq nalus"
|
||||
- avcodec/cbs: ensure user_data is padded for GBC parsing
|
||||
- avcodec/cbs: fix crash in sei_pic_timestamp
|
||||
- avcodec/cbs_h264: silence errors about end_of_seq nalus
|
||||
- avcodec/cuviddec: properly take deinterlacing and display delay into account for buffer_full check
|
||||
- avcodec/h2645_parse: skip NALUs with no content after stripping all the trailing zeros
|
||||
- configure: <fflib>_deps: validate, reduce sensitivity
|
||||
- configure: speed up check_deps()
|
||||
- configure: speed up print_enabled_components()
|
||||
- configure: speed up flatten_extralibs_wrapper()
|
||||
- avformat/utils: Fix potential integer overflow in extract_extradata()
|
||||
- avcodec/unary: Improve get_unary() docs
|
||||
- avcodec/gdv: Replace divisions by shifts in rescale()
|
||||
- avcodec/ac3dec: Fix shift signedness in mask creation
|
||||
- avcodec/eac3dec: Check that channel_map does not contain more than EAC3_MAX_CHANNELS
|
||||
- doc/examples/vaapi_transcode: Fix the typo
|
||||
- avcodec/dvdsubdec: Sanity check len in decode_rle()
|
||||
- avcodec/mpeg4videodec: Fix undefined shift in get_amv()
|
||||
- avcodec/zmbv: Check that the decompressed data size is correct
|
||||
- avcodec/zmbv: Update decomp_len in raw frames
|
||||
- avcodec/shorten: Fix bitstream end check in read_header()
|
||||
- avcodec/dvdsubdec: Avoid branch in decode_run_8bit()
|
||||
- avcodec/h264_refs: Document last if() in ff_h264_execute_ref_pic_marking()
|
||||
- avcodec/ra144: Fix undefined integer overflow in add_wav()
|
||||
- avcodec/indeo4: Check dimensions in decode_pic_hdr()
|
||||
- avformat/mov: Error on too large stsd entry counts.
|
||||
- examples: Fix use of AV_CODEC_FLAG_GLOBAL_HEADER
|
||||
- avcodec/hq_hqa: Check remaining input bits in hqa_decode_mb()
|
||||
- avcodec/vb: Check for end of bytestream before reading blocktype
|
||||
- avcodec/snowdec: Fix integer overflow with motion vector residual
|
||||
- avcodec/mpeg4videodec: Fix slice end detection in mpeg4_decode_studio_mb()
|
||||
- avformat/nsvdec: Do not parse multiple NSVf
|
||||
- avformat/dashdec: Fix strlen(rep_id_val) with it being NULL
|
||||
- avformat/mlvdec: read_string() received unsigned size, make the argument unsigned
|
||||
- avformat/rmdec: Fix EOF check in the stream loop in ivr_read_header()
|
||||
- avcodec/scpr: Check for min > max in decompress_p()
|
||||
- avcodec/shorten: Fix signed 32bit overflow in shift in shorten_decode_frame()
|
||||
- avcodec/shorten: Fix integer overflow in residual/LPC combination
|
||||
- avcodec/shorten: Check verbatim length
|
||||
- avcodec/mpegaudio_parser: Initialize poutbuf*
|
||||
- avcodec/aacpsdsp_template: Fix integer overflow in ps_stereo_interpolate_c()
|
||||
- avformat/flvenc: Check audio packet size
|
||||
- lavc/svq3: Fix regression decoding some files.
|
||||
- avcodec/mlp_parser: Check if synccode is within buffer
|
||||
- avcodec/qtrle: Check remaining bytestream in qtrle_decode_XYbpp()
|
||||
- avcodec/diracdec: Check bytes count in else branch in decode_lowdelay() too
|
||||
- avcodec/diracdec: Check slice numbers for overflows in relation to picture dimensions
|
||||
- avcodec/diracdec: Change frame_number to 64bit as its a 32bit from the bitstream and we also have a -1 special case
|
||||
- avcodec/dirac_dwt_template: Fix several integer overflows in horizontal_compose_daub97i()
|
||||
- avcodec/diracdec: Prevent integer overflow in intermediate in global_mv()
|
||||
- swresample/swresample: Fix input channel count in resample_first computation
|
||||
- avutil/pixfmt: Document chroma plane size for odd resolutions
|
||||
- lavf/libsmbclient: return AVERROR_EOF for EOF.
|
||||
- lavc/videotoolboxenc: Fix compilation on osx 10.10.5 Yosemite
|
||||
- avcodec/mediacodecdec: fix SEGV on modern nvidia decoders
|
||||
- avcodec/bitstream_filters: check the input argument of av_bsf_get_by_name() for NULL
|
||||
- avformat/librtmp: fix returning EOF from Read/Write
|
||||
- avcodec/videotoolboxenc: fix undefined behavior with rc_max_rate=0
|
||||
|
||||
|
||||
version 4.0.2:
|
||||
- avcodec/dvdsub_parser: Allocate input padding
|
||||
- avcodec/dvdsub_parser: Init output buf/size
|
||||
- avcodec/dirac_dwt_template: Fix signedness regression in interleave()
|
||||
- avformat/mov: Simplify last element computation in mov_estimate_video_delay()
|
||||
- avformat/mov: Break out of inner loop early in mov_estimate_video_delay()
|
||||
- avformat/mov: Eliminate variable buf_size from mov_estimate_video_delay()
|
||||
- avformat/mov: remove modulo operations from mov_estimate_video_delay()
|
||||
- avformat/movenc: Write version 2 of audio atom if channels is not known
|
||||
- swresample/arm: rename labels to fix xcode build error
|
||||
- avformat/movenc: Check input sample count
|
||||
- avcodec/mjpegdec: Check for odd progressive RGB
|
||||
- avcodec/vp8_parser: Do not leave data/size uninitialized
|
||||
- avformat/mms: Add missing chunksize check
|
||||
- avformat/pva: Check for EOF before retrying in read_part_of_packet()
|
||||
- avformat/rmdec: Do not pass mime type in rm_read_multi() to ff_rm_read_mdpr_codecdata()
|
||||
- avformat/asfdec_o: Check size_bmp more fully
|
||||
- avformat/mxfdec: Fix av_log context
|
||||
- avcodec/mpeg4videodec: Check for bitstream end in read_quant_matrix_ext()
|
||||
- avcodec/indeo4: Check for end of bitstream in decode_mb_info()
|
||||
- avcodec/ac3dec: Check channel_map index
|
||||
- avcodec/mpeg4videodec: Remove use of FF_PROFILE_MPEG4_SIMPLE_STUDIO as indicator of studio profile
|
||||
- avcodec/shorten: Fix undefined addition in shorten_decode_frame()
|
||||
- avcodec/shorten: Fix undefined integer overflow
|
||||
- avcodec/jpeg2000dec: Fixes invalid shifts in jpeg2000_decode_packets_po_iteration()
|
||||
- avcodec/jpeg2000dec: Check that there are enough bytes for all tiles
|
||||
- avformat/movenc: Use mov->fc consistently for av_log()
|
||||
- avcodec/mpeg4videodec: Check read profile before setting it
|
||||
- avformat/movenc: Do not pass AVCodecParameters in avpriv_request_sample
|
||||
- avcodec/ac3_parser: Check init_get_bits8() for failure
|
||||
- avformat/movenc: Check that frame_types other than EAC3_FRAME_TYPE_INDEPENDENT have a supported substream id
|
||||
- avcodec/dpx: Check elements in 12bps planar path
|
||||
- avcodec/escape124: Fix spelling errors in comment
|
||||
- avcodec/ra144: Fix integer overflow in ff_eval_refl()
|
||||
- avcodec/cscd: Check output buffer size for lzo.
|
||||
- avcodec/escape124: Check buf_size against num_superblocks
|
||||
- avcodec/h264_parser: Reduce needed history for parsing mb index
|
||||
- avcodec/magicyuv: Check bits left in flags&1 branch
|
||||
- avcodec/mjpegdec: Check for end of bitstream in ljpeg_decode_rgb_scan()
|
||||
- ffmpeg: fix -stream_loop with multiple inputs
|
||||
- ffmpeg: factorize input thread creation and destruction
|
||||
- avformat/mpegts: parse large PMTs with multiple tables
|
||||
- Revert "avcodec/mediacodecdec: wait on first frame after input buffers are full"
|
||||
- avcodec/videotoolboxenc: fix invalid session on iOS
|
||||
- avcodec/videotoolboxenc: split initialization
|
||||
- avcodec/videotoolboxenc: fix mutex/cond leak in error path
|
||||
|
||||
version 4.0.1:
|
||||
- avcodec/aacdec_fixed: Fix undefined integer overflow in apply_independent_coupling_fixed()
|
||||
- avcodec/dirac_dwt_template: Fix undefined behavior in interleave()
|
||||
- avutil/common: Fix undefined behavior in av_clip_uintp2_c()
|
||||
- fftools/ffmpeg: Fallback to duration if sample rate is unavailable
|
||||
- avformat/mov: Only set pkt->duration to non negative values
|
||||
- avcodec/mpeg4videodec: Clear bits_per_raw_sample if it has originated from a previous instance
|
||||
- avformat/movenc: fix recognization of cover image streams
|
||||
- avformat/movenc: properly handle cover image codecs
|
||||
- avcodec/h264_slice: Fix overflow in recovery_frame computation
|
||||
- avcodec/h264_ps: Move MAX_LOG2_MAX_FRAME_NUM to header so it can be used in h264_sei
|
||||
- avcodec/h264_mc_template: Only prefetch motion if the list is used.
|
||||
- avcodec/xwddec: Use ff_set_dimensions()
|
||||
- avcodec/wavpack: Fix overflow in adding tail
|
||||
- avcodec/shorten: Fix multiple integer overflows
|
||||
- avcodec/shorten: Fix undefined shift in fix_bitshift()
|
||||
- avcodec/shorten: Fix a negative left shift in shorten_decode_frame()
|
||||
- avcodec/shorten: Sanity check nmeans
|
||||
- avcodec/shorten: Check non COMM chunk len before skip in decode_aiff_header()
|
||||
- avcodec/mjpegdec: Fix integer overflow in ljpeg_decode_rgb_scan()
|
||||
- avcodec/truemotion2: Fix overflow in tm2_apply_deltas()
|
||||
- avcodec/opus_silk: Change silk_lsf2lpc() slightly toward silk/NLSF2A.c
|
||||
- avcodec/amrwbdec: Fix division by 0 in find_hb_gain()
|
||||
- avcodec/h263dec: Reinitialize idct context if it has not been setup for the active profile
|
||||
- avcodec/idctdsp: Clear idct/idct_add for studio profile
|
||||
- avformat/mov: replace a value error by clipping into valid range in mov_read_stsc()
|
||||
- avformat/bintext: Reduce detection for random .bin files as it more likely is not a multimedia related file
|
||||
- avformat/mov: Break out early if chunk_count is 0 in mov_build_index()
|
||||
- avcodec/fic: Avoid some magic numbers related to cursors
|
||||
- avcodec/mpeg4video: Detect reference studio streams as studio streams
|
||||
- avcodec/mpeg4videodec: Do not corrupt bits_per_raw_sample
|
||||
- avcodec/mpeg4videode: Eliminate out of loop VOP startcode reading for studio profile
|
||||
- avcodec/g2meet: ask for sample with overflowing RGB
|
||||
- avcodec/idctdsp: Transmit studio_profile to init instead of using AVCodecContext profile
|
||||
- avcodec/ac3dec: Check that the number of channels with dependant streams is valid
|
||||
- avcodec/ac3dec: Fix null pointer dereference in ac3_decode_frame()
|
||||
- avcodec/aacdec_fixed: use 64bit to avoid overflow in rounding in apply_dependent_coupling_fixed()
|
||||
- oavcodec/aacpsdsp_template: Use unsigned for hs0X to prevent undefined behavior
|
||||
- avcodec/g723_1dec: Clip bits2 in both directions
|
||||
- avcodec/mpeg4videoenc: Use 64 bit for times in mpeg4_encode_gop_header()
|
||||
- avcodec/mlpdec: Only change noise_type if the related fields are valid
|
||||
- indeo4: Decode all or nothing of a band header.
|
||||
- avcodec/ac3dec: Use frame_size if superframe_size is 0
|
||||
- avformat/mov: Only fail for STCO/STSC contradictions if both exist
|
||||
- avcodec/dirac_dwt: Fix integer overflow in COMPOSE_DD97iH0 / COMPOSE_DD137iL0
|
||||
- avcodec/fic: Check available input space for cursor
|
||||
- avcodec/mpeg4videodec: Check bps (VOL header) before VOP for studio profile
|
||||
- avcodec/g2meet: Check RGB upper limit
|
||||
- avcodec/jpeg2000dec: Fix undefined shift in the jpeg2000_decode_packets_po_iteration() CPRL case
|
||||
- avcodec/jpeg2000dec: Skip init for component in CPRL if nothing is to be done
|
||||
- avcodec/g2meet: Change order of operations to avoid undefined behavior
|
||||
- avcodec/flac_parser: Fix infinite loop
|
||||
- avcodec/mpeg4videodec: Split decode_studio_vol_header() out of decode_studiovisualobject()
|
||||
- avcodec/mpeg4videodec: Move decode_studiovisualobject() parsing in the branch for visual object parsing
|
||||
- avcodec/mpeg4video_parser: Avoid litteral 0x1B6, use named constant instead
|
||||
- avcodec/mpeg4video_parser: Fix incorrect spliting of MPEG-4 studio frames
|
||||
- avformat/m4vdec: Use the same constant names as libavcodec
|
||||
- avformat/m4vdec: Fix detection of raw MPEG-4 ES Studio
|
||||
- avcodec/wavpack: Fix integer overflow in DEC_MED() / INC_MED()
|
||||
- avcodec/wavpack: Fix integer overflow in wv_unpack_stereo()
|
||||
- avcodec/error_resilience: Fix integer overflow in filter181()
|
||||
- avcodec/h263dec: Check slice_ret in mspeg4 slice loop
|
||||
- avcodec/elsdec: Fix memleaks
|
||||
- avcodec/vc1_block: simplify ac_val computation
|
||||
- avcodec/ffv1enc: Check that the crc + version combination is supported
|
||||
- configure: The eac3_core bitstream filter needs the ac3 parser.
|
||||
- configure: fix arm inline asm checks
|
||||
- lavf/libssh: translate a read of 0 to EOF
|
||||
- ffprobe: fix SEGV when new streams are added
|
||||
- avformat/mpegts: fix incorrect indentation
|
||||
- avformat/mpegts: initialize section_buf to fix valgrind test failure
|
||||
- avformat/mpegts: reindent after last change
|
||||
- avformat/mpegts: parse sections with multiple tables
|
||||
- avformat/mpegts: clean up whitespace
|
||||
- avformat/mpegts: use MAX_SECTION_SIZE instead of hardcoded value
|
||||
- avformat/mpegts: skip non-PMT tids earlier
|
||||
- avcodec/mediacodecdec: add workaround for buggy amlogic mpeg2 decoder
|
||||
- avcodec/mediacodecdec: wait on first frame after input buffers are full
|
||||
- avcodec/mediacodecdec: restructure mediacodec_receive_frame
|
||||
- avcodec/mediacodec_wrapper: add helper to fetch SDK_INT
|
||||
- avcodec/mediacodecdec: refactor pts handling
|
||||
- avcodec/mediacodecdec: use AV_TIME_BASE_Q
|
||||
- avcodec/mediacodecdec: clarify delay_flush specific code
|
||||
- avcodec/videotoolbox: fix decoding of some HEVC videos
|
||||
- avcodec/hevc: remove videotoolbox hack
|
||||
- avcodec/videotoolbox: split h264/hevc callbacks
|
||||
- avcodec/videotoolbox: cleanups
|
||||
- avcodec/videotoolbox: fix kVTCouldNotFindVideoDecoderErr trying to decode HEVC on iOS
|
||||
- avcodec/videotoolbox: improve logging of decoder errors
|
||||
- avcodec/xwddec: fix palette alpha
|
||||
- avformat/webm_chunk: always use a static buffer for get_chunk_filename
|
||||
- configure: fix configure check for lilv-0
|
||||
- avcodec/nvdec_hevc: fix scaling lists
|
||||
- avcodec/hevcdec: make ff_hevc_frame_nb_refs take a const pointer
|
||||
- lavf/bluray: translate a read of 0 to EOF
|
||||
- lavf/dashenc: don't call flush_init_segment before avformat_write_header
|
||||
- avdevice/decklink_dec: unref packets on avpacket_queue_put error
|
||||
- avcodec/hnm4video: fix palette alpha
|
||||
- avcodec/anm: fix palette alpha
|
||||
- avformat/qtpalette: parse color table according to the QuickTime file format specs
|
||||
- ffplay: Fix realloc_texture when input texture is NULL.
|
||||
- hwcontext_vaapi: Fix compilation with libva versions < 1.4.0
|
||||
- lavf/qsv: clone the frame which may be managed by framework
|
||||
- lavf: make overlay_qsv work based on framesync
|
||||
- avformat/segafilm - revert keyframe detection
|
||||
- avformat/utils: refactor upstream_stream_timings
|
||||
- avformat/utils: ignore outlier durations on subtitle/data streams as well
|
||||
|
||||
|
||||
version 4.0:
|
||||
version <next>:
|
||||
- Bitstream filters for editing metadata in H.264, HEVC and MPEG-2 streams
|
||||
- Dropped support for OpenJPEG versions 2.0 and below. Using OpenJPEG now
|
||||
requires 2.1 (or later) and pkg-config.
|
||||
|
||||
@@ -1,15 +0,0 @@
|
||||
|
||||
┌───────────────────────────────────┐
|
||||
│ RELEASE NOTES for FFmpeg 4.0 "Wu" │
|
||||
└───────────────────────────────────┘
|
||||
|
||||
The FFmpeg Project proudly presents FFmpeg 4.0 "Wu", about 6
|
||||
months after the release of FFmpeg 3.4.
|
||||
|
||||
A complete Changelog is available at the root of the project, and the
|
||||
complete Git history on https://git.ffmpeg.org/gitweb/ffmpeg.git
|
||||
|
||||
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.
|
||||
@@ -668,10 +668,13 @@ disable_sanitized(){
|
||||
do_enable_deep(){
|
||||
for var; do
|
||||
enabled $var && continue
|
||||
set -- $var
|
||||
eval enable_deep \$${var}_select
|
||||
var=$1
|
||||
eval enable_deep_weak \$${var}_suggest
|
||||
eval sel="\$${var}_select"
|
||||
eval sgs="\$${var}_suggest"
|
||||
pushvar var sgs
|
||||
enable_deep $sel
|
||||
popvar sgs
|
||||
enable_deep_weak $sgs
|
||||
popvar var
|
||||
done
|
||||
}
|
||||
|
||||
@@ -683,9 +686,9 @@ enable_deep(){
|
||||
enable_deep_weak(){
|
||||
for var; do
|
||||
disabled $var && continue
|
||||
set -- $var
|
||||
pushvar var
|
||||
do_enable_deep $var
|
||||
var=$1
|
||||
popvar var
|
||||
enable_weak $var
|
||||
done
|
||||
}
|
||||
@@ -745,49 +748,40 @@ is_in(){
|
||||
return 1
|
||||
}
|
||||
|
||||
# The cfg loop is very hot (several thousands iterations), and in bash also
|
||||
# potentialy quite slow. Try to abort the iterations early, preferably without
|
||||
# calling functions. 70%+ of the time cfg is already done or without deps.
|
||||
check_deps(){
|
||||
for cfg; do
|
||||
eval [ x\$${cfg}_checking = xdone ] && continue
|
||||
eval [ x\$${cfg}_checking = xinprogress ] && die "Circular dependency for $cfg."
|
||||
enabled ${cfg}_checking && die "Circular dependency for $cfg."
|
||||
disabled ${cfg}_checking && continue
|
||||
enable ${cfg}_checking
|
||||
|
||||
eval "
|
||||
dep_all=\$${cfg}_deps
|
||||
dep_any=\$${cfg}_deps_any
|
||||
dep_con=\$${cfg}_conflict
|
||||
dep_sel=\$${cfg}_select
|
||||
dep_sgs=\$${cfg}_suggest
|
||||
dep_ifa=\$${cfg}_if
|
||||
dep_ifn=\$${cfg}_if_any
|
||||
"
|
||||
eval dep_all="\$${cfg}_deps"
|
||||
eval dep_any="\$${cfg}_deps_any"
|
||||
eval dep_con="\$${cfg}_conflict"
|
||||
eval dep_sel="\$${cfg}_select"
|
||||
eval dep_sgs="\$${cfg}_suggest"
|
||||
eval dep_ifa="\$${cfg}_if"
|
||||
eval dep_ifn="\$${cfg}_if_any"
|
||||
|
||||
# most of the time here $cfg has no deps - avoid costly no-op work
|
||||
if [ "$dep_all$dep_any$dep_con$dep_sel$dep_sgs$dep_ifa$dep_ifn" ]; then
|
||||
eval ${cfg}_checking=inprogress
|
||||
pushvar cfg dep_all dep_any dep_con dep_sel dep_sgs dep_ifa dep_ifn
|
||||
check_deps $dep_all $dep_any $dep_con $dep_sel $dep_sgs $dep_ifa $dep_ifn
|
||||
popvar cfg dep_all dep_any dep_con dep_sel dep_sgs dep_ifa dep_ifn
|
||||
|
||||
set -- $cfg "$dep_all" "$dep_any" "$dep_con" "$dep_sel" "$dep_sgs" "$dep_ifa" "$dep_ifn"
|
||||
check_deps $dep_all $dep_any $dep_con $dep_sel $dep_sgs $dep_ifa $dep_ifn
|
||||
cfg=$1; dep_all=$2; dep_any=$3; dep_con=$4; dep_sel=$5 dep_sgs=$6; dep_ifa=$7; dep_ifn=$8
|
||||
[ -n "$dep_ifa" ] && { enabled_all $dep_ifa && enable_weak $cfg; }
|
||||
[ -n "$dep_ifn" ] && { enabled_any $dep_ifn && enable_weak $cfg; }
|
||||
enabled_all $dep_all || { disable $cfg && requested $cfg && die "ERROR: $cfg requested, but not all dependencies are satisfied: $dep_all"; }
|
||||
enabled_any $dep_any || { disable $cfg && requested $cfg && die "ERROR: $cfg requested, but not any dependency is satisfied: $dep_any"; }
|
||||
disabled_all $dep_con || { disable $cfg && requested $cfg && die "ERROR: $cfg requested, but some conflicting dependencies are unsatisfied: $dep_con"; }
|
||||
disabled_any $dep_sel && { disable $cfg && requested $cfg && die "ERROR: $cfg requested, but some selected dependency is unsatisfied: $dep_sel"; }
|
||||
|
||||
[ -n "$dep_ifa" ] && { enabled_all $dep_ifa && enable_weak $cfg; }
|
||||
[ -n "$dep_ifn" ] && { enabled_any $dep_ifn && enable_weak $cfg; }
|
||||
enabled_all $dep_all || { disable $cfg && requested $cfg && die "ERROR: $cfg requested, but not all dependencies are satisfied: $dep_all"; }
|
||||
enabled_any $dep_any || { disable $cfg && requested $cfg && die "ERROR: $cfg requested, but not any dependency is satisfied: $dep_any"; }
|
||||
disabled_all $dep_con || { disable $cfg && requested $cfg && die "ERROR: $cfg requested, but some conflicting dependencies are unsatisfied: $dep_con"; }
|
||||
disabled_any $dep_sel && { disable $cfg && requested $cfg && die "ERROR: $cfg requested, but some selected dependency is unsatisfied: $dep_sel"; }
|
||||
enabled $cfg && enable_deep_weak $dep_sel $dep_sgs
|
||||
|
||||
enabled $cfg && enable_deep_weak $dep_sel $dep_sgs
|
||||
for dep in $dep_all $dep_any $dep_sel $dep_sgs; do
|
||||
# filter out library deps, these do not belong in extralibs
|
||||
is_in $dep $LIBRARY_LIST && continue
|
||||
enabled $dep && eval append ${cfg}_extralibs ${dep}_extralibs
|
||||
done
|
||||
|
||||
for dep in $dep_all $dep_any $dep_sel $dep_sgs; do
|
||||
# filter out library deps, these do not belong in extralibs
|
||||
is_in $dep $LIBRARY_LIST && continue
|
||||
enabled $dep && eval append ${cfg}_extralibs ${dep}_extralibs
|
||||
done
|
||||
fi
|
||||
|
||||
eval ${cfg}_checking=done
|
||||
disable ${cfg}_checking
|
||||
done
|
||||
}
|
||||
|
||||
@@ -842,37 +836,22 @@ prepend(){
|
||||
eval "$var=\"$* \$$var\""
|
||||
}
|
||||
|
||||
reverse () {
|
||||
eval '
|
||||
reverse_out=
|
||||
for v in $'$1'; do
|
||||
reverse_out="$v $reverse_out"
|
||||
done
|
||||
'$1'=$reverse_out
|
||||
'
|
||||
}
|
||||
|
||||
# keeps the last occurence of each non-unique item
|
||||
unique(){
|
||||
unique_out=
|
||||
eval unique_in=\$$1
|
||||
reverse unique_in
|
||||
for v in $unique_in; do
|
||||
# " $unique_out" +space such that every item is surrounded with spaces
|
||||
case " $unique_out" in *" $v "*) continue; esac # already in list
|
||||
unique_out="$unique_out$v "
|
||||
var=$1
|
||||
uniq_list=""
|
||||
for tok in $(eval echo \$$var); do
|
||||
uniq_list="$(filter_out $tok $uniq_list) $tok"
|
||||
done
|
||||
reverse unique_out
|
||||
eval $1=\$unique_out
|
||||
eval "$var=\"${uniq_list}\""
|
||||
}
|
||||
|
||||
resolve(){
|
||||
resolve_out=
|
||||
eval resolve_in=\$$1
|
||||
for v in $resolve_in; do
|
||||
eval 'resolve_out="$resolve_out$'$v' "'
|
||||
var=$1
|
||||
tmpvar=
|
||||
for entry in $(eval echo \$$var); do
|
||||
tmpvar="$tmpvar $(eval echo \$${entry})"
|
||||
done
|
||||
eval $1=\$resolve_out
|
||||
eval "$var=\"${tmpvar}\""
|
||||
}
|
||||
|
||||
add_cppflags(){
|
||||
@@ -1057,7 +1036,7 @@ EOF
|
||||
|
||||
check_insn(){
|
||||
log check_insn "$@"
|
||||
check_inline_asm ${1}_inline "\"$2\""
|
||||
check_inline_asm ${1}_inline "$2"
|
||||
check_as ${1}_external "$2"
|
||||
}
|
||||
|
||||
@@ -1805,17 +1784,16 @@ FEATURE_LIST="
|
||||
swscale_alpha
|
||||
"
|
||||
|
||||
# this list should be kept in linking order
|
||||
LIBRARY_LIST="
|
||||
avcodec
|
||||
avdevice
|
||||
avfilter
|
||||
swscale
|
||||
postproc
|
||||
avformat
|
||||
avcodec
|
||||
swresample
|
||||
avresample
|
||||
avutil
|
||||
postproc
|
||||
swresample
|
||||
swscale
|
||||
"
|
||||
|
||||
LICENSE_LIST="
|
||||
@@ -2394,7 +2372,6 @@ CMDLINE_SET="
|
||||
malloc_prefix
|
||||
nm
|
||||
optflags
|
||||
nvcc
|
||||
nvccflags
|
||||
pkg_config
|
||||
pkg_config_flags
|
||||
@@ -3001,7 +2978,6 @@ vc1_parser_select="vc1dsp"
|
||||
|
||||
# bitstream_filters
|
||||
aac_adtstoasc_bsf_select="adts_header"
|
||||
eac3_core_bsf_select="ac3_parser"
|
||||
filter_units_bsf_select="cbs"
|
||||
h264_metadata_bsf_deps="const_nan"
|
||||
h264_metadata_bsf_select="cbs_h264"
|
||||
@@ -3085,7 +3061,7 @@ libopus_encoder_deps="libopus"
|
||||
libopus_encoder_select="audio_frame_queue"
|
||||
librsvg_decoder_deps="librsvg"
|
||||
libshine_encoder_deps="libshine"
|
||||
libshine_encoder_select="audio_frame_queue mpegaudioheader"
|
||||
libshine_encoder_select="audio_frame_queue"
|
||||
libspeex_decoder_deps="libspeex"
|
||||
libspeex_encoder_deps="libspeex"
|
||||
libspeex_encoder_select="audio_frame_queue"
|
||||
@@ -3457,7 +3433,7 @@ vaapi_transcode_example_deps="avcodec avformat avutil h264_vaapi_encoder"
|
||||
cpu_init_extralibs="pthreads_extralibs"
|
||||
cws2fws_extralibs="zlib_extralibs"
|
||||
|
||||
# libraries, in any order
|
||||
# libraries, in linking order
|
||||
avcodec_deps="avutil"
|
||||
avcodec_suggest="libm"
|
||||
avcodec_select="null_bsf"
|
||||
@@ -4434,7 +4410,7 @@ probe_cc(){
|
||||
_flags_filter=msvc_flags
|
||||
_ld_lib='lib%.a'
|
||||
_ld_path='-libpath:'
|
||||
elif $_cc -nologo- 2>&1 | grep -q Microsoft || { $_cc -v 2>&1 | grep -q clang && $_cc -? > /dev/null 2>&1; }; then
|
||||
elif $_cc -nologo- 2>&1 | grep -q Microsoft || $_cc -v 2>&1 | grep -q clang && $_cc -? > /dev/null 2>&1; then
|
||||
_type=msvc
|
||||
_ident=$($_cc 2>&1 | head -n1 | tr -d '\r')
|
||||
_DEPCMD='$(DEP$(1)) $(DEP$(1)FLAGS) $($(1)DEP_FLAGS) $< 2>&1 | awk '\''/including/ { sub(/^.*file: */, ""); gsub(/\\/, "/"); if (!match($$0, / /)) print "$@:", $$0 }'\'' > $(@:.o=.d)'
|
||||
@@ -5852,8 +5828,7 @@ check_header asm/types.h
|
||||
check_builtin stdatomic stdatomic.h "atomic_int foo, bar = ATOMIC_VAR_INIT(-1); atomic_store(&foo, 0); foo += bar"
|
||||
|
||||
check_lib advapi32 "windows.h" RegCloseKey -ladvapi32
|
||||
check_lib bcrypt "windows.h bcrypt.h" BCryptGenRandom -lbcrypt &&
|
||||
check_cpp_condition bcrypt bcrypt.h "defined BCRYPT_RNG_ALGORITHM"
|
||||
check_lib bcrypt "windows.h bcrypt.h" BCryptGenRandom -lbcrypt
|
||||
check_lib ole32 "windows.h" CoTaskMemFree -lole32
|
||||
check_lib shell32 "windows.h shellapi.h" CommandLineToArgvW -lshell32
|
||||
check_lib psapi "windows.h psapi.h" GetProcessMemoryInfo -lpsapi
|
||||
@@ -5985,7 +5960,7 @@ enabled gnutls && require_pkg_config gnutls gnutls gnutls/gnutls.h gn
|
||||
enabled jni && { [ $target_os = "android" ] && check_header jni.h && enabled pthreads || die "ERROR: jni not found"; }
|
||||
enabled ladspa && require_header ladspa.h
|
||||
enabled libaom && require_pkg_config libaom "aom >= 0.1.0" aom/aom_codec.h aom_codec_version
|
||||
enabled lv2 && require_pkg_config lv2 lilv-0 "lilv/lilv.h" lilv_world_new
|
||||
enabled lv2 && require_pkg_config lv2 lilv-0 "lilv-0/lilv/lilv.h" lilv_world_new
|
||||
enabled libiec61883 && require libiec61883 libiec61883/iec61883.h iec61883_cmp_connect -lraw1394 -lavc1394 -lrom1394 -liec61883
|
||||
enabled libass && require_pkg_config libass libass ass/ass.h ass_library_init
|
||||
enabled libbluray && require_pkg_config libbluray libbluray libbluray/bluray.h bd_open
|
||||
@@ -6073,21 +6048,21 @@ enabled libvorbis && require_pkg_config libvorbis vorbis vorbis/codec.h
|
||||
enabled libvpx && {
|
||||
enabled libvpx_vp8_decoder && {
|
||||
check_pkg_config libvpx_vp8_decoder "vpx >= 1.4.0" "vpx/vpx_decoder.h vpx/vp8dx.h" vpx_codec_vp8_dx ||
|
||||
check_lib libvpx_vp8_decoder "vpx/vpx_decoder.h vpx/vp8dx.h" "vpx_codec_vp8_dx VPX_IMG_FMT_HIGHBITDEPTH" "-lvpx $libm_extralibs $pthreads_extralibs" ||
|
||||
check_lib libvpx_vp8_decoder "vpx/vpx_decoder.h vpx/vp8dx.h" "vpx_codec_dec_init_ver VPX_IMG_FMT_HIGHBITDEPTH" -lvpx ||
|
||||
die "ERROR: libvpx decoder version must be >=1.4.0";
|
||||
}
|
||||
enabled libvpx_vp8_encoder && {
|
||||
check_pkg_config libvpx_vp8_encoder "vpx >= 1.4.0" "vpx/vpx_encoder.h vpx/vp8cx.h" vpx_codec_vp8_cx ||
|
||||
check_lib libvpx_vp8_encoder "vpx/vpx_encoder.h vpx/vp8cx.h" "vpx_codec_vp8_cx VPX_IMG_FMT_HIGHBITDEPTH" "-lvpx $libm_extralibs $pthreads_extralibs" ||
|
||||
check_lib libvpx_vp8_encoder "vpx/vpx_encoder.h vpx/vp8cx.h" "vpx_codec_enc_init_ver VPX_IMG_FMT_HIGHBITDEPTH" -lvpx ||
|
||||
die "ERROR: libvpx encoder version must be >=1.4.0";
|
||||
}
|
||||
enabled libvpx_vp9_decoder && {
|
||||
check_pkg_config libvpx_vp9_decoder "vpx >= 1.4.0" "vpx/vpx_decoder.h vpx/vp8dx.h" vpx_codec_vp9_dx ||
|
||||
check_lib libvpx_vp9_decoder "vpx/vpx_decoder.h vpx/vp8dx.h" "vpx_codec_vp9_dx VPX_IMG_FMT_HIGHBITDEPTH" "-lvpx $libm_extralibs $pthreads_extralibs"
|
||||
check_lib libvpx_vp9_decoder "vpx/vpx_decoder.h vpx/vp8dx.h" "vpx_codec_vp9_dx VPX_IMG_FMT_HIGHBITDEPTH" "-lvpx $libm_extralibs"
|
||||
}
|
||||
enabled libvpx_vp9_encoder && {
|
||||
check_pkg_config libvpx_vp9_encoder "vpx >= 1.4.0" "vpx/vpx_encoder.h vpx/vp8cx.h" vpx_codec_vp9_cx ||
|
||||
check_lib libvpx_vp9_encoder "vpx/vpx_encoder.h vpx/vp8cx.h" "vpx_codec_vp9_cx VPX_IMG_FMT_HIGHBITDEPTH" "-lvpx $libm_extralibs $pthreads_extralibs"
|
||||
check_lib libvpx_vp9_encoder "vpx/vpx_encoder.h vpx/vp8cx.h" "vpx_codec_vp9_cx VPX_IMG_FMT_HIGHBITDEPTH" "-lvpx $libm_extralibs"
|
||||
}
|
||||
if disabled_all libvpx_vp8_decoder libvpx_vp9_decoder libvpx_vp8_encoder libvpx_vp9_encoder; then
|
||||
die "libvpx enabled but no supported decoders found"
|
||||
@@ -6169,7 +6144,7 @@ fi
|
||||
|
||||
if enabled sdl2; then
|
||||
SDL2_CONFIG="${cross_prefix}sdl2-config"
|
||||
test_pkg_config sdl2 "sdl2 >= 2.0.1 sdl2 < 3.0.0" SDL_events.h SDL_PollEvent
|
||||
test_pkg_config sdl2 "sdl2 >= 2.0.1 sdl2 < 2.1.0" SDL_events.h SDL_PollEvent
|
||||
if disabled sdl2 && "${SDL2_CONFIG}" --version > /dev/null 2>&1; then
|
||||
sdl2_cflags=$("${SDL2_CONFIG}" --cflags)
|
||||
sdl2_extralibs=$("${SDL2_CONFIG}" --libs)
|
||||
@@ -6704,19 +6679,14 @@ if test $target_os = "haiku"; then
|
||||
fi
|
||||
|
||||
flatten_extralibs(){
|
||||
nested_entries=
|
||||
unset nested_entries
|
||||
list_name=$1
|
||||
eval list=\$${1}
|
||||
for entry in $list; do
|
||||
entry_copy=$entry
|
||||
resolve entry_copy
|
||||
flat_entries=
|
||||
for e in $entry_copy; do
|
||||
case $e in
|
||||
*_extralibs) nested_entries="$nested_entries$e ";;
|
||||
*) flat_entries="$flat_entries$e ";;
|
||||
esac
|
||||
done
|
||||
append nested_entries $(filter '*_extralibs' $entry_copy)
|
||||
flat_entries=$(filter_out '*_extralibs' $entry_copy)
|
||||
eval $entry="\$flat_entries"
|
||||
done
|
||||
append $list_name "$nested_entries"
|
||||
@@ -6784,7 +6754,7 @@ done
|
||||
|
||||
enabled zlib && add_cppflags -DZLIB_CONST
|
||||
|
||||
# conditional library dependencies, in any order
|
||||
# conditional library dependencies, in linking order
|
||||
enabled afftfilt_filter && prepend avfilter_deps "avcodec"
|
||||
enabled afir_filter && prepend avfilter_deps "avcodec"
|
||||
enabled amovie_filter && prepend avfilter_deps "avformat avcodec"
|
||||
@@ -6826,36 +6796,11 @@ enabled sdl2_outdev && add_cflags $(filter_out '-Dmain=SDL_main' $sdl2_cflag
|
||||
|
||||
enabled opus_decoder && prepend avcodec_deps "swresample"
|
||||
|
||||
# reorder the items at var $1 to align with the items order at var $2 .
|
||||
# die if an item at $1 is not at $2 .
|
||||
reorder_by(){
|
||||
eval rb_in=\$$1
|
||||
eval rb_ordered=\$$2
|
||||
|
||||
for rb in $rb_in; do
|
||||
is_in $rb $rb_ordered || die "$rb at \$$1 is not at \$$2"
|
||||
done
|
||||
|
||||
rb_out=
|
||||
for rb in $rb_ordered; do
|
||||
is_in $rb $rb_in && rb_out="$rb_out$rb "
|
||||
done
|
||||
eval $1=\$rb_out
|
||||
}
|
||||
|
||||
# deps-expand fflib $1: N x {append all expanded deps; unique}
|
||||
# within a set of N items, N expansions are enough to expose a cycle.
|
||||
expand_deps(){
|
||||
unique ${1}_deps # required for the early break test.
|
||||
for dummy in $LIBRARY_LIST; do # N iteratios
|
||||
eval deps=\$${1}_deps
|
||||
append ${1}_deps $(map 'eval echo \$${v}_deps' $deps)
|
||||
unique ${1}_deps
|
||||
eval '[ ${#deps} = ${#'${1}_deps'} ]' && break # doesn't expand anymore
|
||||
done
|
||||
|
||||
eval is_in $1 \$${1}_deps && die "Dependency cycle at ${1}_deps"
|
||||
reorder_by ${1}_deps LIBRARY_LIST # linking order is expected later
|
||||
lib_deps=${1}_deps
|
||||
eval "deps=\$$lib_deps"
|
||||
append $lib_deps $(map 'eval echo \$${v}_deps' $deps)
|
||||
unique $lib_deps
|
||||
}
|
||||
|
||||
#we have to remove gpl from the deps here as some code assumes all lib deps are libs
|
||||
@@ -7155,7 +7100,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 2020
|
||||
#define CONFIG_THIS_YEAR 2018
|
||||
#define FFMPEG_DATADIR "$(eval c_escape $datadir)"
|
||||
#define AVCONV_DATADIR "$(eval c_escape $datadir)"
|
||||
#define CC_IDENT "$(c_escape ${cc_ident:-Unknown compiler})"
|
||||
@@ -7216,10 +7161,9 @@ echo "#endif /* AVUTIL_AVCONFIG_H */" >> $TMPH
|
||||
|
||||
cp_if_changed $TMPH libavutil/avconfig.h
|
||||
|
||||
# full_filter_name_foo=vf_foo
|
||||
# full_filter_name_bar=asrc_bar
|
||||
# ...
|
||||
eval "$(sed -n "s/^extern AVFilter ff_\([avfsinkrc]\{2,5\}\)_\(.*\);/full_filter_name_\2=\1_\2/p" $source_path/libavfilter/allfilters.c)"
|
||||
full_filter_name(){
|
||||
sed -n "s/^extern AVFilter ff_\([avfsinkrc]\{2,5\}\)_$1;/\1_$1/p" $source_path/libavfilter/allfilters.c
|
||||
}
|
||||
|
||||
# generate the lists of enabled components
|
||||
print_enabled_components(){
|
||||
@@ -7232,13 +7176,13 @@ print_enabled_components(){
|
||||
if enabled $c; then
|
||||
case $name in
|
||||
filter_list)
|
||||
eval c=\$full_filter_name_${c%_filter}
|
||||
c=$(full_filter_name $(remove_suffix _filter $c))
|
||||
;;
|
||||
indev_list)
|
||||
c=${c%_indev}_demuxer
|
||||
c=$(add_suffix _demuxer $(remove_suffix _indev $c))
|
||||
;;
|
||||
outdev_list)
|
||||
c=${c%_outdev}_muxer
|
||||
c=$(add_suffix _muxer $(remove_suffix _outdev $c))
|
||||
;;
|
||||
esac
|
||||
printf " &ff_%s,\n" $c >> $TMPH
|
||||
|
||||
+2
-2
@@ -889,7 +889,7 @@ API changes, most recent first:
|
||||
Add av_opt_get_dict_val/set_dict_val with AV_OPT_TYPE_DICT to support
|
||||
dictionary types being set as options.
|
||||
|
||||
2014-08-13 - afbd4b7e09 - lavf 56.01.0 - avformat.h
|
||||
2014-08-13 - afbd4b8 - lavf 56.01.0 - avformat.h
|
||||
Add AVFormatContext.event_flags and AVStream.event_flags for signaling to
|
||||
the user when events happen in the file/stream.
|
||||
|
||||
@@ -906,7 +906,7 @@ API changes, most recent first:
|
||||
2014-08-08 - 5c3c671 - lavf 55.53.100 - avio.h
|
||||
Add avio_feof() and deprecate url_feof().
|
||||
|
||||
2014-08-07 - bb789016d4 - lsws 2.1.3 - swscale.h
|
||||
2014-08-07 - bb78903 - lsws 2.1.3 - swscale.h
|
||||
sws_getContext is not going to be removed in the future.
|
||||
|
||||
2014-08-07 - a561662 / ad1ee5f - lavc 55.73.101 / 55.57.3 - avcodec.h
|
||||
|
||||
+1
-1
@@ -38,7 +38,7 @@ PROJECT_NAME = FFmpeg
|
||||
# could be handy for archiving the generated documentation or if some version
|
||||
# control system is used.
|
||||
|
||||
PROJECT_NUMBER = 4.0.6
|
||||
PROJECT_NUMBER =
|
||||
|
||||
# Using the PROJECT_BRIEF tag one can provide an optional one line description
|
||||
# for a project that appears at the top of each page and should give viewer a
|
||||
|
||||
@@ -172,9 +172,6 @@ static int open_output_file(const char *filename)
|
||||
enc_ctx->time_base = (AVRational){1, enc_ctx->sample_rate};
|
||||
}
|
||||
|
||||
if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
|
||||
enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
|
||||
|
||||
/* Third parameter can be used to pass settings to encoder */
|
||||
ret = avcodec_open2(enc_ctx, encoder, NULL);
|
||||
if (ret < 0) {
|
||||
@@ -186,6 +183,8 @@ static int open_output_file(const char *filename)
|
||||
av_log(NULL, AV_LOG_ERROR, "Failed to copy encoder parameters to output stream #%u\n", i);
|
||||
return ret;
|
||||
}
|
||||
if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
|
||||
enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
|
||||
|
||||
out_stream->time_base = enc_ctx->time_base;
|
||||
stream_ctx[i].enc_ctx = enc_ctx;
|
||||
|
||||
@@ -177,7 +177,7 @@ static int dec_enc(AVPacket *pkt, AVCodec *enc_codec)
|
||||
}
|
||||
/* set AVCodecContext Parameters for encoder, here we keep them stay
|
||||
* the same as decoder.
|
||||
* xxx: now the sample can't handle resolution change case.
|
||||
* xxx: now the the sample can't handle resolution change case.
|
||||
*/
|
||||
encoder_ctx->time_base = av_inv_q(decoder_ctx->framerate);
|
||||
encoder_ctx->pix_fmt = AV_PIX_FMT_VAAPI;
|
||||
|
||||
+33
-65
@@ -561,7 +561,6 @@ static void ffmpeg_cleanup(int ret)
|
||||
ost->audio_channels_mapped = 0;
|
||||
|
||||
av_dict_free(&ost->sws_dict);
|
||||
av_dict_free(&ost->swr_opts);
|
||||
|
||||
avcodec_free_context(&ost->enc_ctx);
|
||||
avcodec_parameters_free(&ost->ref_par);
|
||||
@@ -2122,6 +2121,9 @@ static int ifilter_send_frame(InputFilter *ifilter, AVFrame *frame)
|
||||
|
||||
/* determine if the parameters for this input changed */
|
||||
need_reinit = ifilter->format != frame->format;
|
||||
if (!!ifilter->hw_frames_ctx != !!frame->hw_frames_ctx ||
|
||||
(ifilter->hw_frames_ctx && ifilter->hw_frames_ctx->data != frame->hw_frames_ctx->data))
|
||||
need_reinit = 1;
|
||||
|
||||
switch (ifilter->ist->st->codecpar->codec_type) {
|
||||
case AVMEDIA_TYPE_AUDIO:
|
||||
@@ -2135,13 +2137,6 @@ static int ifilter_send_frame(InputFilter *ifilter, AVFrame *frame)
|
||||
break;
|
||||
}
|
||||
|
||||
if (!ifilter->ist->reinit_filters && fg->graph)
|
||||
need_reinit = 0;
|
||||
|
||||
if (!!ifilter->hw_frames_ctx != !!frame->hw_frames_ctx ||
|
||||
(ifilter->hw_frames_ctx && ifilter->hw_frames_ctx->data != frame->hw_frames_ctx->data))
|
||||
need_reinit = 1;
|
||||
|
||||
if (need_reinit) {
|
||||
ret = ifilter_parameters_from_frame(ifilter, frame);
|
||||
if (ret < 0)
|
||||
@@ -2701,12 +2696,8 @@ static int process_input_packet(InputStream *ist, const AVPacket *pkt, int no_eo
|
||||
ist->dts = ist->next_dts;
|
||||
switch (ist->dec_ctx->codec_type) {
|
||||
case AVMEDIA_TYPE_AUDIO:
|
||||
if (ist->dec_ctx->sample_rate) {
|
||||
ist->next_dts += ((int64_t)AV_TIME_BASE * ist->dec_ctx->frame_size) /
|
||||
ist->dec_ctx->sample_rate;
|
||||
} else {
|
||||
ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
|
||||
}
|
||||
ist->next_dts += ((int64_t)AV_TIME_BASE * ist->dec_ctx->frame_size) /
|
||||
ist->dec_ctx->sample_rate;
|
||||
break;
|
||||
case AVMEDIA_TYPE_VIDEO:
|
||||
if (ist->framerate.num) {
|
||||
@@ -4020,63 +4011,49 @@ static void *input_thread(void *arg)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void free_input_thread(int i)
|
||||
{
|
||||
InputFile *f = input_files[i];
|
||||
AVPacket pkt;
|
||||
|
||||
if (!f || !f->in_thread_queue)
|
||||
return;
|
||||
av_thread_message_queue_set_err_send(f->in_thread_queue, AVERROR_EOF);
|
||||
while (av_thread_message_queue_recv(f->in_thread_queue, &pkt, 0) >= 0)
|
||||
av_packet_unref(&pkt);
|
||||
|
||||
pthread_join(f->thread, NULL);
|
||||
f->joined = 1;
|
||||
av_thread_message_queue_free(&f->in_thread_queue);
|
||||
}
|
||||
|
||||
static void free_input_threads(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < nb_input_files; i++)
|
||||
free_input_thread(i);
|
||||
}
|
||||
for (i = 0; i < nb_input_files; i++) {
|
||||
InputFile *f = input_files[i];
|
||||
AVPacket pkt;
|
||||
|
||||
static int init_input_thread(int i)
|
||||
{
|
||||
int ret;
|
||||
InputFile *f = input_files[i];
|
||||
if (!f || !f->in_thread_queue)
|
||||
continue;
|
||||
av_thread_message_queue_set_err_send(f->in_thread_queue, AVERROR_EOF);
|
||||
while (av_thread_message_queue_recv(f->in_thread_queue, &pkt, 0) >= 0)
|
||||
av_packet_unref(&pkt);
|
||||
|
||||
if (nb_input_files == 1)
|
||||
return 0;
|
||||
|
||||
if (f->ctx->pb ? !f->ctx->pb->seekable :
|
||||
strcmp(f->ctx->iformat->name, "lavfi"))
|
||||
f->non_blocking = 1;
|
||||
ret = av_thread_message_queue_alloc(&f->in_thread_queue,
|
||||
f->thread_queue_size, sizeof(AVPacket));
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
if ((ret = pthread_create(&f->thread, NULL, input_thread, f))) {
|
||||
av_log(NULL, AV_LOG_ERROR, "pthread_create failed: %s. Try to increase `ulimit -v` or decrease `ulimit -s`.\n", strerror(ret));
|
||||
pthread_join(f->thread, NULL);
|
||||
f->joined = 1;
|
||||
av_thread_message_queue_free(&f->in_thread_queue);
|
||||
return AVERROR(ret);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int init_input_threads(void)
|
||||
{
|
||||
int i, ret;
|
||||
|
||||
if (nb_input_files == 1)
|
||||
return 0;
|
||||
|
||||
for (i = 0; i < nb_input_files; i++) {
|
||||
ret = init_input_thread(i);
|
||||
InputFile *f = input_files[i];
|
||||
|
||||
if (f->ctx->pb ? !f->ctx->pb->seekable :
|
||||
strcmp(f->ctx->iformat->name, "lavfi"))
|
||||
f->non_blocking = 1;
|
||||
ret = av_thread_message_queue_alloc(&f->in_thread_queue,
|
||||
f->thread_queue_size, sizeof(AVPacket));
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
if ((ret = pthread_create(&f->thread, NULL, input_thread, f))) {
|
||||
av_log(NULL, AV_LOG_ERROR, "pthread_create failed: %s. Try to increase `ulimit -v` or decrease `ulimit -s`.\n", strerror(ret));
|
||||
av_thread_message_queue_free(&f->in_thread_queue);
|
||||
return AVERROR(ret);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -4194,8 +4171,7 @@ static int seek_to_start(InputFile *ifile, AVFormatContext *is)
|
||||
ifile->time_base = ist->st->time_base;
|
||||
/* the total duration of the stream, max_pts - min_pts is
|
||||
* the duration of the stream without the last frame */
|
||||
if (ist->max_pts > ist->min_pts && ist->max_pts - (uint64_t)ist->min_pts < INT64_MAX - duration)
|
||||
duration += ist->max_pts - ist->min_pts;
|
||||
duration += ist->max_pts - ist->min_pts;
|
||||
ifile->time_base = duration_max(duration, &ifile->duration, ist->st->time_base,
|
||||
ifile->time_base);
|
||||
}
|
||||
@@ -4219,7 +4195,7 @@ static int process_input(int file_index)
|
||||
AVFormatContext *is;
|
||||
InputStream *ist;
|
||||
AVPacket pkt;
|
||||
int ret, thread_ret, i, j;
|
||||
int ret, i, j;
|
||||
int64_t duration;
|
||||
int64_t pkt_dts;
|
||||
|
||||
@@ -4242,15 +4218,7 @@ static int process_input(int file_index)
|
||||
avcodec_flush_buffers(avctx);
|
||||
}
|
||||
}
|
||||
#if HAVE_THREADS
|
||||
free_input_thread(file_index);
|
||||
#endif
|
||||
ret = seek_to_start(ifile, is);
|
||||
#if HAVE_THREADS
|
||||
thread_ret = init_input_thread(file_index);
|
||||
if (thread_ret < 0)
|
||||
return thread_ret;
|
||||
#endif
|
||||
if (ret < 0)
|
||||
av_log(NULL, AV_LOG_WARNING, "Seek to start failed.\n");
|
||||
else
|
||||
|
||||
@@ -1,4 +1,3 @@
|
||||
|
||||
/*
|
||||
* ffmpeg option parsing
|
||||
*
|
||||
@@ -2303,14 +2302,12 @@ loop_end:
|
||||
o->attachments[i]);
|
||||
exit_program(1);
|
||||
}
|
||||
if (len > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE ||
|
||||
!(attachment = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE))) {
|
||||
av_log(NULL, AV_LOG_FATAL, "Attachment %s too large.\n",
|
||||
if (!(attachment = av_malloc(len))) {
|
||||
av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
|
||||
o->attachments[i]);
|
||||
exit_program(1);
|
||||
}
|
||||
avio_read(pb, attachment, len);
|
||||
memset(attachment + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
|
||||
|
||||
ost = new_attachment_stream(o, oc, -1);
|
||||
ost->stream_copy = 0;
|
||||
@@ -2702,14 +2699,13 @@ static int opt_target(void *optctx, const char *opt, const char *arg)
|
||||
} else {
|
||||
/* Try to determine PAL/NTSC by peeking in the input files */
|
||||
if (nb_input_files) {
|
||||
int i, j;
|
||||
int i, j, fr;
|
||||
for (j = 0; j < nb_input_files; j++) {
|
||||
for (i = 0; i < input_files[j]->nb_streams; i++) {
|
||||
AVStream *st = input_files[j]->ctx->streams[i];
|
||||
int64_t fr;
|
||||
if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
|
||||
continue;
|
||||
fr = st->time_base.den * 1000LL / st->time_base.num;
|
||||
fr = st->time_base.den * 1000 / st->time_base.num;
|
||||
if (fr == 25000) {
|
||||
norm = PAL;
|
||||
break;
|
||||
|
||||
+2
-3
@@ -834,11 +834,10 @@ static int realloc_texture(SDL_Texture **texture, Uint32 new_format, int new_wid
|
||||
{
|
||||
Uint32 format;
|
||||
int access, w, h;
|
||||
if (!*texture || SDL_QueryTexture(*texture, &format, &access, &w, &h) < 0 || new_width != w || new_height != h || new_format != format) {
|
||||
if (SDL_QueryTexture(*texture, &format, &access, &w, &h) < 0 || new_width != w || new_height != h || new_format != format) {
|
||||
void *pixels;
|
||||
int pitch;
|
||||
if (*texture)
|
||||
SDL_DestroyTexture(*texture);
|
||||
SDL_DestroyTexture(*texture);
|
||||
if (!(*texture = SDL_CreateTexture(renderer, new_format, SDL_TEXTUREACCESS_STREAMING, new_width, new_height)))
|
||||
return -1;
|
||||
if (SDL_SetTextureBlendMode(*texture, blendmode) < 0)
|
||||
|
||||
+3
-3
@@ -2371,11 +2371,11 @@ static int read_interval_packets(WriterContext *w, InputFile *ifile,
|
||||
goto end;
|
||||
}
|
||||
while (!av_read_frame(fmt_ctx, &pkt)) {
|
||||
if (fmt_ctx->nb_streams > nb_streams) {
|
||||
if (ifile->nb_streams > nb_streams) {
|
||||
REALLOCZ_ARRAY_STREAM(nb_streams_frames, nb_streams, fmt_ctx->nb_streams);
|
||||
REALLOCZ_ARRAY_STREAM(nb_streams_packets, nb_streams, fmt_ctx->nb_streams);
|
||||
REALLOCZ_ARRAY_STREAM(selected_streams, nb_streams, fmt_ctx->nb_streams);
|
||||
nb_streams = fmt_ctx->nb_streams;
|
||||
nb_streams = ifile->nb_streams;
|
||||
}
|
||||
if (selected_streams[pkt.stream_index]) {
|
||||
AVRational tb = ifile->streams[pkt.stream_index].st->time_base;
|
||||
@@ -2521,7 +2521,7 @@ static int show_stream(WriterContext *w, AVFormatContext *fmt_ctx, int stream_id
|
||||
#endif
|
||||
print_int("has_b_frames", par->video_delay);
|
||||
sar = av_guess_sample_aspect_ratio(fmt_ctx, stream, NULL);
|
||||
if (sar.num) {
|
||||
if (sar.den) {
|
||||
print_q("sample_aspect_ratio", sar, ':');
|
||||
av_reduce(&dar.num, &dar.den,
|
||||
par->width * sar.num,
|
||||
|
||||
+3
-9
@@ -158,7 +158,7 @@ typedef struct FourXContext {
|
||||
#define FIX_1_847759065 121095
|
||||
#define FIX_2_613125930 171254
|
||||
|
||||
#define MULTIPLY(var, const) ((int)((var) * (unsigned)(const)) >> 16)
|
||||
#define MULTIPLY(var, const) (((var) * (const)) >> 16)
|
||||
|
||||
static void idct(int16_t block[64])
|
||||
{
|
||||
@@ -351,8 +351,6 @@ static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src,
|
||||
index = size2index[log2h][log2w];
|
||||
av_assert0(index >= 0);
|
||||
|
||||
if (get_bits_left(&f->gb) < 1)
|
||||
return AVERROR_INVALIDDATA;
|
||||
h = 1 << log2h;
|
||||
code = get_vlc2(&f->gb, block_type_vlc[1 - (f->version > 1)][index].table,
|
||||
BLOCK_TYPE_VLC_BITS, 1);
|
||||
@@ -500,7 +498,7 @@ static int decode_i_block(FourXContext *f, int16_t *block)
|
||||
|
||||
if (get_bits_left(&f->gb) < 2){
|
||||
av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
|
||||
return AVERROR_INVALIDDATA;
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* DC coef */
|
||||
@@ -525,10 +523,6 @@ static int decode_i_block(FourXContext *f, int16_t *block)
|
||||
break;
|
||||
if (code == 0xf0) {
|
||||
i += 16;
|
||||
if (i >= 64) {
|
||||
av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
if (code & 0xf) {
|
||||
level = get_xbits(&f->gb, code & 0xf);
|
||||
@@ -738,7 +732,7 @@ static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
|
||||
for (x = 0; x < width; x += 16) {
|
||||
unsigned int color[4] = { 0 }, bits;
|
||||
if (buf_end - buf < 8)
|
||||
return AVERROR_INVALIDDATA;
|
||||
return -1;
|
||||
// warning following is purely guessed ...
|
||||
color[0] = bytestream2_get_le16u(&g3);
|
||||
color[1] = bytestream2_get_le16u(&g3);
|
||||
|
||||
+2
-4
@@ -411,8 +411,6 @@ static int read_stream_mux_config(struct LATMContext *latmctx,
|
||||
} else {
|
||||
int esc;
|
||||
do {
|
||||
if (get_bits_left(gb) < 9)
|
||||
return AVERROR_INVALIDDATA;
|
||||
esc = get_bits(gb, 1);
|
||||
skip_bits(gb, 8);
|
||||
} while (esc);
|
||||
@@ -563,7 +561,7 @@ AVCodec ff_aac_decoder = {
|
||||
AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE
|
||||
},
|
||||
.capabilities = AV_CODEC_CAP_CHANNEL_CONF | AV_CODEC_CAP_DR1,
|
||||
.caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
|
||||
.caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
|
||||
.channel_layouts = aac_channel_layout,
|
||||
.flush = flush,
|
||||
.priv_class = &aac_decoder_class,
|
||||
@@ -588,7 +586,7 @@ AVCodec ff_aac_latm_decoder = {
|
||||
AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE
|
||||
},
|
||||
.capabilities = AV_CODEC_CAP_CHANNEL_CONF | AV_CODEC_CAP_DR1,
|
||||
.caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
|
||||
.caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
|
||||
.channel_layouts = aac_channel_layout,
|
||||
.flush = flush,
|
||||
.profiles = NULL_IF_CONFIG_SMALL(ff_aac_profiles),
|
||||
|
||||
@@ -195,12 +195,12 @@ static void subband_scale(int *dst, int *src, int scale, int offset, int len)
|
||||
|
||||
static void noise_scale(int *coefs, int scale, int band_energy, int len)
|
||||
{
|
||||
int s = -scale;
|
||||
int ssign = scale < 0 ? -1 : 1;
|
||||
int s = FFABS(scale);
|
||||
unsigned int round;
|
||||
int i, out, c = exp2tab[s & 3];
|
||||
int nlz = 0;
|
||||
|
||||
av_assert0(s >= 0);
|
||||
while (band_energy > 0x7fff) {
|
||||
band_energy >>= 1;
|
||||
nlz++;
|
||||
@@ -216,20 +216,15 @@ static void noise_scale(int *coefs, int scale, int band_energy, int len)
|
||||
round = s ? 1 << (s-1) : 0;
|
||||
for (i=0; i<len; i++) {
|
||||
out = (int)(((int64_t)coefs[i] * c) >> 32);
|
||||
coefs[i] = -((int)(out+round) >> s);
|
||||
coefs[i] = ((int)(out+round) >> s) * ssign;
|
||||
}
|
||||
}
|
||||
else {
|
||||
s = s + 32;
|
||||
if (s > 0) {
|
||||
round = 1 << (s-1);
|
||||
for (i=0; i<len; i++) {
|
||||
out = (int)((int64_t)((int64_t)coefs[i] * c + round) >> s);
|
||||
coefs[i] = -out;
|
||||
}
|
||||
} else {
|
||||
for (i=0; i<len; i++)
|
||||
coefs[i] = -(int64_t)coefs[i] * c * (1 << -s);
|
||||
round = 1 << (s-1);
|
||||
for (i=0; i<len; i++) {
|
||||
out = (int)((int64_t)((int64_t)coefs[i] * c + round) >> s);
|
||||
coefs[i] = out * ssign;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -390,7 +385,7 @@ static void apply_dependent_coupling_fixed(AACContext *ac,
|
||||
for (k = offsets[i]; k < offsets[i + 1]; k++) {
|
||||
tmp = (int)(((int64_t)src[group * 128 + k] * c + \
|
||||
(int64_t)0x1000000000) >> 37);
|
||||
dest[group * 128 + k] += (tmp + (int64_t)round) >> shift;
|
||||
dest[group * 128 + k] += (tmp + round) >> shift;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -441,7 +436,7 @@ static void apply_independent_coupling_fixed(AACContext *ac,
|
||||
else {
|
||||
for (i = 0; i < len; i++) {
|
||||
tmp = (int)(((int64_t)src[i] * c + (int64_t)0x1000000000) >> 37);
|
||||
dest[i] += tmp * (1U << shift);
|
||||
dest[i] += tmp * (1 << shift);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1157,9 +1157,6 @@ static av_cold int aac_decode_init(AVCodecContext *avctx)
|
||||
AACContext *ac = avctx->priv_data;
|
||||
int ret;
|
||||
|
||||
if (avctx->sample_rate > 96000)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
ret = ff_thread_once(&aac_table_init, &aac_static_table_init);
|
||||
if (ret != 0)
|
||||
return AVERROR_UNKNOWN;
|
||||
@@ -1676,24 +1673,25 @@ static int decode_spectrum_and_dequant(AACContext *ac, INTFLOAT coef[1024],
|
||||
}
|
||||
} else if (cbt_m1 == NOISE_BT - 1) {
|
||||
for (group = 0; group < (AAC_SIGNE)g_len; group++, cfo+=128) {
|
||||
#if !USE_FIXED
|
||||
float scale;
|
||||
#endif /* !USE_FIXED */
|
||||
INTFLOAT band_energy;
|
||||
#if USE_FIXED
|
||||
|
||||
for (k = 0; k < off_len; k++) {
|
||||
ac->random_state = lcg_random(ac->random_state);
|
||||
#if USE_FIXED
|
||||
cfo[k] = ac->random_state >> 3;
|
||||
#else
|
||||
cfo[k] = ac->random_state;
|
||||
#endif /* USE_FIXED */
|
||||
}
|
||||
|
||||
#if USE_FIXED
|
||||
band_energy = ac->fdsp->scalarproduct_fixed(cfo, cfo, off_len);
|
||||
band_energy = fixed_sqrt(band_energy, 31);
|
||||
noise_scale(cfo, sf[idx], band_energy, off_len);
|
||||
#else
|
||||
float scale;
|
||||
|
||||
for (k = 0; k < off_len; k++) {
|
||||
ac->random_state = lcg_random(ac->random_state);
|
||||
cfo[k] = ac->random_state;
|
||||
}
|
||||
|
||||
band_energy = ac->fdsp->scalarproduct_float(cfo, cfo, off_len);
|
||||
scale = sf[idx] / sqrtf(band_energy);
|
||||
ac->fdsp->vector_fmul_scalar(cfo, cfo, scale, off_len);
|
||||
@@ -2495,9 +2493,6 @@ static void apply_tns(INTFLOAT coef_param[1024], TemporalNoiseShaping *tns,
|
||||
INTFLOAT tmp[TNS_MAX_ORDER+1];
|
||||
UINTFLOAT *coef = coef_param;
|
||||
|
||||
if(!mmm)
|
||||
return;
|
||||
|
||||
for (w = 0; w < ics->num_windows; w++) {
|
||||
bottom = ics->num_swb;
|
||||
for (filt = 0; filt < tns->n_filt[w]; filt++) {
|
||||
@@ -2662,7 +2657,7 @@ static void imdct_and_windowing(AACContext *ac, SingleChannelElement *sce)
|
||||
ac->mdct.imdct_half(&ac->mdct, buf, in);
|
||||
#if USE_FIXED
|
||||
for (i=0; i<1024; i++)
|
||||
buf[i] = (buf[i] + 4LL) >> 3;
|
||||
buf[i] = (buf[i] + 4) >> 3;
|
||||
#endif /* USE_FIXED */
|
||||
}
|
||||
|
||||
|
||||
+18
-18
@@ -414,33 +414,33 @@ static void hybrid_synthesis(PSDSPContext *dsp, INTFLOAT out[2][38][64],
|
||||
memset(out[0][n], 0, 5*sizeof(out[0][n][0]));
|
||||
memset(out[1][n], 0, 5*sizeof(out[1][n][0]));
|
||||
for (i = 0; i < 12; i++) {
|
||||
out[0][n][0] += (UINTFLOAT)in[ i][n][0];
|
||||
out[1][n][0] += (UINTFLOAT)in[ i][n][1];
|
||||
out[0][n][0] += in[ i][n][0];
|
||||
out[1][n][0] += in[ i][n][1];
|
||||
}
|
||||
for (i = 0; i < 8; i++) {
|
||||
out[0][n][1] += (UINTFLOAT)in[12+i][n][0];
|
||||
out[1][n][1] += (UINTFLOAT)in[12+i][n][1];
|
||||
out[0][n][1] += in[12+i][n][0];
|
||||
out[1][n][1] += in[12+i][n][1];
|
||||
}
|
||||
for (i = 0; i < 4; i++) {
|
||||
out[0][n][2] += (UINTFLOAT)in[20+i][n][0];
|
||||
out[1][n][2] += (UINTFLOAT)in[20+i][n][1];
|
||||
out[0][n][3] += (UINTFLOAT)in[24+i][n][0];
|
||||
out[1][n][3] += (UINTFLOAT)in[24+i][n][1];
|
||||
out[0][n][4] += (UINTFLOAT)in[28+i][n][0];
|
||||
out[1][n][4] += (UINTFLOAT)in[28+i][n][1];
|
||||
out[0][n][2] += in[20+i][n][0];
|
||||
out[1][n][2] += in[20+i][n][1];
|
||||
out[0][n][3] += in[24+i][n][0];
|
||||
out[1][n][3] += in[24+i][n][1];
|
||||
out[0][n][4] += in[28+i][n][0];
|
||||
out[1][n][4] += in[28+i][n][1];
|
||||
}
|
||||
}
|
||||
dsp->hybrid_synthesis_deint(out, in + 27, 5, len);
|
||||
} else {
|
||||
for (n = 0; n < len; n++) {
|
||||
out[0][n][0] = (UINTFLOAT)in[0][n][0] + in[1][n][0] + in[2][n][0] +
|
||||
(UINTFLOAT)in[3][n][0] + in[4][n][0] + in[5][n][0];
|
||||
out[1][n][0] = (UINTFLOAT)in[0][n][1] + in[1][n][1] + in[2][n][1] +
|
||||
(UINTFLOAT)in[3][n][1] + in[4][n][1] + in[5][n][1];
|
||||
out[0][n][1] = (UINTFLOAT)in[6][n][0] + in[7][n][0];
|
||||
out[1][n][1] = (UINTFLOAT)in[6][n][1] + in[7][n][1];
|
||||
out[0][n][2] = (UINTFLOAT)in[8][n][0] + in[9][n][0];
|
||||
out[1][n][2] = (UINTFLOAT)in[8][n][1] + in[9][n][1];
|
||||
out[0][n][0] = in[0][n][0] + in[1][n][0] + in[2][n][0] +
|
||||
in[3][n][0] + in[4][n][0] + in[5][n][0];
|
||||
out[1][n][0] = in[0][n][1] + in[1][n][1] + in[2][n][1] +
|
||||
in[3][n][1] + in[4][n][1] + in[5][n][1];
|
||||
out[0][n][1] = in[6][n][0] + in[7][n][0];
|
||||
out[1][n][1] = in[6][n][1] + in[7][n][1];
|
||||
out[0][n][2] = in[8][n][0] + in[9][n][0];
|
||||
out[1][n][2] = in[8][n][1] + in[9][n][1];
|
||||
}
|
||||
dsp->hybrid_synthesis_deint(out, in + 7, 3, len);
|
||||
}
|
||||
|
||||
@@ -54,10 +54,10 @@ static void ps_hybrid_analysis_c(INTFLOAT (*out)[2], INTFLOAT (*in)[2],
|
||||
INT64FLOAT sum_im = (INT64FLOAT)filter[i][6][0] * in[6][1];
|
||||
|
||||
for (j = 0; j < 6; j++) {
|
||||
INT64FLOAT in0_re = in[j][0];
|
||||
INT64FLOAT in0_im = in[j][1];
|
||||
INT64FLOAT in1_re = in[12-j][0];
|
||||
INT64FLOAT in1_im = in[12-j][1];
|
||||
INTFLOAT in0_re = in[j][0];
|
||||
INTFLOAT in0_im = in[j][1];
|
||||
INTFLOAT in1_re = in[12-j][0];
|
||||
INTFLOAT in1_im = in[12-j][1];
|
||||
sum_re += (INT64FLOAT)filter[i][j][0] * (in0_re + in1_re) -
|
||||
(INT64FLOAT)filter[i][j][1] * (in0_im - in1_im);
|
||||
sum_im += (INT64FLOAT)filter[i][j][0] * (in0_im + in1_im) +
|
||||
@@ -150,10 +150,10 @@ static void ps_stereo_interpolate_c(INTFLOAT (*l)[2], INTFLOAT (*r)[2],
|
||||
INTFLOAT h1 = h[0][1];
|
||||
INTFLOAT h2 = h[0][2];
|
||||
INTFLOAT h3 = h[0][3];
|
||||
UINTFLOAT hs0 = h_step[0][0];
|
||||
UINTFLOAT hs1 = h_step[0][1];
|
||||
UINTFLOAT hs2 = h_step[0][2];
|
||||
UINTFLOAT hs3 = h_step[0][3];
|
||||
INTFLOAT hs0 = h_step[0][0];
|
||||
INTFLOAT hs1 = h_step[0][1];
|
||||
INTFLOAT hs2 = h_step[0][2];
|
||||
INTFLOAT hs3 = h_step[0][3];
|
||||
int n;
|
||||
|
||||
for (n = 0; n < len; n++) {
|
||||
@@ -181,10 +181,10 @@ static void ps_stereo_interpolate_ipdopd_c(INTFLOAT (*l)[2], INTFLOAT (*r)[2],
|
||||
INTFLOAT h01 = h[0][1], h11 = h[1][1];
|
||||
INTFLOAT h02 = h[0][2], h12 = h[1][2];
|
||||
INTFLOAT h03 = h[0][3], h13 = h[1][3];
|
||||
UINTFLOAT hs00 = h_step[0][0], hs10 = h_step[1][0];
|
||||
UINTFLOAT hs01 = h_step[0][1], hs11 = h_step[1][1];
|
||||
UINTFLOAT hs02 = h_step[0][2], hs12 = h_step[1][2];
|
||||
UINTFLOAT hs03 = h_step[0][3], hs13 = h_step[1][3];
|
||||
INTFLOAT hs00 = h_step[0][0], hs10 = h_step[1][0];
|
||||
INTFLOAT hs01 = h_step[0][1], hs11 = h_step[1][1];
|
||||
INTFLOAT hs02 = h_step[0][2], hs12 = h_step[1][2];
|
||||
INTFLOAT hs03 = h_step[0][3], hs13 = h_step[1][3];
|
||||
int n;
|
||||
|
||||
for (n = 0; n < len; n++) {
|
||||
|
||||
@@ -162,9 +162,7 @@ int avpriv_ac3_parse_header(AC3HeaderInfo **phdr, const uint8_t *buf,
|
||||
return AVERROR(ENOMEM);
|
||||
hdr = *phdr;
|
||||
|
||||
err = init_get_bits8(&gb, buf, size);
|
||||
if (err < 0)
|
||||
return AVERROR_INVALIDDATA;
|
||||
init_get_bits8(&gb, buf, size);
|
||||
err = ff_ac3_parse_header(&gb, hdr);
|
||||
if (err < 0)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
+25
-23
@@ -106,6 +106,25 @@ static const uint8_t ac3_default_coeffs[8][5][2] = {
|
||||
{ { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
|
||||
};
|
||||
|
||||
static const uint64_t custom_channel_map_locations[16][2] = {
|
||||
{ 1, AV_CH_FRONT_LEFT },
|
||||
{ 1, AV_CH_FRONT_CENTER },
|
||||
{ 1, AV_CH_FRONT_RIGHT },
|
||||
{ 1, AV_CH_SIDE_LEFT },
|
||||
{ 1, AV_CH_SIDE_RIGHT },
|
||||
{ 0, AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER },
|
||||
{ 0, AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT },
|
||||
{ 0, AV_CH_BACK_CENTER },
|
||||
{ 0, AV_CH_TOP_CENTER },
|
||||
{ 0, AV_CH_SURROUND_DIRECT_LEFT | AV_CH_SURROUND_DIRECT_RIGHT },
|
||||
{ 0, AV_CH_WIDE_LEFT | AV_CH_WIDE_RIGHT },
|
||||
{ 0, AV_CH_TOP_FRONT_LEFT | AV_CH_TOP_FRONT_RIGHT},
|
||||
{ 0, AV_CH_TOP_FRONT_CENTER },
|
||||
{ 0, AV_CH_TOP_BACK_LEFT | AV_CH_TOP_BACK_RIGHT },
|
||||
{ 0, AV_CH_LOW_FREQUENCY_2 },
|
||||
{ 1, AV_CH_LOW_FREQUENCY },
|
||||
};
|
||||
|
||||
/**
|
||||
* Symmetrical Dequantization
|
||||
* reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
|
||||
@@ -1671,7 +1690,6 @@ dependent_frame:
|
||||
|
||||
if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
|
||||
uint64_t ich_layout = avpriv_ac3_channel_layout_tab[s->prev_output_mode & ~AC3_OUTPUT_LFEON];
|
||||
int channel_map_size = ff_ac3_channels_tab[s->output_mode & ~AC3_OUTPUT_LFEON] + s->lfe_on;
|
||||
uint64_t channel_layout;
|
||||
int extend = 0;
|
||||
|
||||
@@ -1681,41 +1699,30 @@ dependent_frame:
|
||||
channel_layout = ich_layout;
|
||||
for (ch = 0; ch < 16; ch++) {
|
||||
if (s->channel_map & (1 << (EAC3_MAX_CHANNELS - ch - 1))) {
|
||||
channel_layout |= ff_eac3_custom_channel_map_locations[ch][1];
|
||||
channel_layout |= custom_channel_map_locations[ch][1];
|
||||
}
|
||||
}
|
||||
if (av_get_channel_layout_nb_channels(channel_layout) > EAC3_MAX_CHANNELS) {
|
||||
av_log(avctx, AV_LOG_ERROR, "Too many channels (%d) coded\n",
|
||||
av_get_channel_layout_nb_channels(channel_layout));
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
|
||||
avctx->channel_layout = channel_layout;
|
||||
avctx->channels = av_get_channel_layout_nb_channels(channel_layout);
|
||||
|
||||
for (ch = 0; ch < EAC3_MAX_CHANNELS; ch++) {
|
||||
if (s->channel_map & (1 << (EAC3_MAX_CHANNELS - ch - 1))) {
|
||||
if (ff_eac3_custom_channel_map_locations[ch][0]) {
|
||||
if (custom_channel_map_locations[ch][0]) {
|
||||
int index = av_get_channel_layout_channel_index(channel_layout,
|
||||
ff_eac3_custom_channel_map_locations[ch][1]);
|
||||
custom_channel_map_locations[ch][1]);
|
||||
if (index < 0)
|
||||
return AVERROR_INVALIDDATA;
|
||||
if (extend >= channel_map_size)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
extended_channel_map[index] = offset + channel_map[extend++];
|
||||
} else {
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 64; i++) {
|
||||
if ((1ULL << i) & ff_eac3_custom_channel_map_locations[ch][1]) {
|
||||
if ((1LL << i) & custom_channel_map_locations[ch][1]) {
|
||||
int index = av_get_channel_layout_channel_index(channel_layout,
|
||||
1ULL << i);
|
||||
1LL << i);
|
||||
if (index < 0)
|
||||
return AVERROR_INVALIDDATA;
|
||||
if (extend >= channel_map_size)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
extended_channel_map[index] = offset + channel_map[extend++];
|
||||
}
|
||||
}
|
||||
@@ -1731,9 +1738,7 @@ dependent_frame:
|
||||
|
||||
for (ch = 0; ch < avctx->channels; ch++) {
|
||||
int map = extended_channel_map[ch];
|
||||
av_assert0(ch>=AV_NUM_DATA_POINTERS || frame->extended_data[ch] == frame->data[ch]);
|
||||
memcpy((SHORTFLOAT *)frame->extended_data[ch],
|
||||
s->output_buffer[map],
|
||||
memcpy((SHORTFLOAT *)frame->data[ch], s->output_buffer[map],
|
||||
s->num_blocks * AC3_BLOCK_SIZE * sizeof(SHORTFLOAT));
|
||||
}
|
||||
|
||||
@@ -1795,9 +1800,6 @@ dependent_frame:
|
||||
|
||||
*got_frame_ptr = 1;
|
||||
|
||||
if (!s->superframe_size)
|
||||
return FFMIN(full_buf_size, s->frame_size);
|
||||
|
||||
return FFMIN(full_buf_size, s->superframe_size);
|
||||
}
|
||||
|
||||
|
||||
@@ -107,30 +107,29 @@ static void scale_coefs (
|
||||
}
|
||||
} else {
|
||||
shift = -shift;
|
||||
mul <<= shift;
|
||||
for (i=0; i<len; i+=8) {
|
||||
|
||||
temp = src[i] * mul;
|
||||
temp1 = src[i+1] * mul;
|
||||
temp2 = src[i+2] * mul;
|
||||
|
||||
dst[i] = temp;
|
||||
dst[i] = temp << shift;
|
||||
temp3 = src[i+3] * mul;
|
||||
|
||||
dst[i+1] = temp1;
|
||||
dst[i+1] = temp1 << shift;
|
||||
temp4 = src[i + 4] * mul;
|
||||
dst[i+2] = temp2;
|
||||
dst[i+2] = temp2 << shift;
|
||||
|
||||
temp5 = src[i+5] * mul;
|
||||
dst[i+3] = temp3;
|
||||
dst[i+3] = temp3 << shift;
|
||||
temp6 = src[i+6] * mul;
|
||||
|
||||
dst[i+4] = temp4;
|
||||
dst[i+4] = temp4 << shift;
|
||||
temp7 = src[i+7] * mul;
|
||||
|
||||
dst[i+5] = temp5;
|
||||
dst[i+6] = temp6;
|
||||
dst[i+7] = temp7;
|
||||
dst[i+5] = temp5 << shift;
|
||||
dst[i+6] = temp6 << shift;
|
||||
dst[i+7] = temp7 << shift;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
+1
-1
@@ -1065,7 +1065,7 @@ static int bit_alloc(AC3EncodeContext *s, int snr_offset)
|
||||
{
|
||||
int blk, ch;
|
||||
|
||||
snr_offset = (snr_offset - 240) * 4;
|
||||
snr_offset = (snr_offset - 240) << 2;
|
||||
|
||||
reset_block_bap(s);
|
||||
for (blk = 0; blk < s->num_blocks; blk++) {
|
||||
|
||||
@@ -314,21 +314,3 @@ const uint16_t ff_eac3_default_chmap[8] = {
|
||||
AC3_CHMAP_L | AC3_CHMAP_R | AC3_CHMAP_L_SUR | AC3_CHMAP_R_SUR,
|
||||
AC3_CHMAP_L | AC3_CHMAP_C | AC3_CHMAP_R | AC3_CHMAP_L_SUR | AC3_CHMAP_R_SUR
|
||||
};
|
||||
const uint64_t ff_eac3_custom_channel_map_locations[16][2] = {
|
||||
{ 1, AV_CH_FRONT_LEFT },
|
||||
{ 1, AV_CH_FRONT_CENTER },
|
||||
{ 1, AV_CH_FRONT_RIGHT },
|
||||
{ 1, AV_CH_SIDE_LEFT },
|
||||
{ 1, AV_CH_SIDE_RIGHT },
|
||||
{ 0, AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER },
|
||||
{ 0, AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT },
|
||||
{ 0, AV_CH_BACK_CENTER },
|
||||
{ 0, AV_CH_TOP_CENTER },
|
||||
{ 0, AV_CH_SURROUND_DIRECT_LEFT | AV_CH_SURROUND_DIRECT_RIGHT },
|
||||
{ 0, AV_CH_WIDE_LEFT | AV_CH_WIDE_RIGHT },
|
||||
{ 0, AV_CH_TOP_FRONT_LEFT | AV_CH_TOP_FRONT_RIGHT},
|
||||
{ 0, AV_CH_TOP_FRONT_CENTER },
|
||||
{ 0, AV_CH_TOP_BACK_LEFT | AV_CH_TOP_BACK_RIGHT },
|
||||
{ 0, AV_CH_LOW_FREQUENCY_2 },
|
||||
{ 1, AV_CH_LOW_FREQUENCY },
|
||||
};
|
||||
|
||||
@@ -50,8 +50,6 @@ extern const uint16_t ff_ac3_fast_gain_tab[8];
|
||||
extern const uint16_t ff_eac3_default_chmap[8];
|
||||
extern const uint8_t ff_ac3_band_start_tab[AC3_CRITICAL_BANDS+1];
|
||||
extern const uint8_t ff_ac3_bin_to_band_tab[253];
|
||||
extern const uint64_t ff_eac3_custom_channel_map_locations[16][2];
|
||||
|
||||
|
||||
/** Custom channel map locations bitmask
|
||||
* Other channels described in documentation:
|
||||
|
||||
+21
-36
@@ -110,10 +110,6 @@ static av_cold int adpcm_decode_init(AVCodecContext * avctx)
|
||||
case AV_CODEC_ID_ADPCM_MTAF:
|
||||
min_channels = 2;
|
||||
max_channels = 8;
|
||||
if (avctx->channels & 1) {
|
||||
avpriv_request_sample(avctx, "channel count %d\n", avctx->channels);
|
||||
return AVERROR_PATCHWELCOME;
|
||||
}
|
||||
break;
|
||||
case AV_CODEC_ID_ADPCM_PSX:
|
||||
max_channels = 8;
|
||||
@@ -139,8 +135,8 @@ static av_cold int adpcm_decode_init(AVCodecContext * avctx)
|
||||
break;
|
||||
case AV_CODEC_ID_ADPCM_IMA_APC:
|
||||
if (avctx->extradata && avctx->extradata_size >= 8) {
|
||||
c->status[0].predictor = av_clip_intp2(AV_RL32(avctx->extradata ), 18);
|
||||
c->status[1].predictor = av_clip_intp2(AV_RL32(avctx->extradata + 4), 18);
|
||||
c->status[0].predictor = AV_RL32(avctx->extradata);
|
||||
c->status[1].predictor = AV_RL32(avctx->extradata + 4);
|
||||
}
|
||||
break;
|
||||
case AV_CODEC_ID_ADPCM_IMA_WS:
|
||||
@@ -293,7 +289,7 @@ static inline int16_t adpcm_ima_oki_expand_nibble(ADPCMChannelStatus *c, int nib
|
||||
c->predictor = av_clip_intp2(predictor, 11);
|
||||
c->step_index = step_index;
|
||||
|
||||
return c->predictor * 16;
|
||||
return c->predictor << 4;
|
||||
}
|
||||
|
||||
static inline int16_t adpcm_ct_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
|
||||
@@ -382,10 +378,6 @@ static int xa_decode(AVCodecContext *avctx, int16_t *out0, int16_t *out1,
|
||||
avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter);
|
||||
filter=0;
|
||||
}
|
||||
if (shift < 0) {
|
||||
avpriv_request_sample(avctx, "unknown XA-ADPCM shift %d", shift);
|
||||
shift = 0;
|
||||
}
|
||||
f0 = xa_adpcm_table[filter][0];
|
||||
f1 = xa_adpcm_table[filter][1];
|
||||
|
||||
@@ -396,7 +388,7 @@ static int xa_decode(AVCodecContext *avctx, int16_t *out0, int16_t *out1,
|
||||
d = in[16+i+j*4];
|
||||
|
||||
t = sign_extend(d, 4);
|
||||
s = t*(1<<shift) + ((s_1*f0 + s_2*f1+32)>>6);
|
||||
s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
|
||||
s_2 = s_1;
|
||||
s_1 = av_clip_int16(s);
|
||||
out0[j] = s_1;
|
||||
@@ -411,14 +403,10 @@ static int xa_decode(AVCodecContext *avctx, int16_t *out0, int16_t *out1,
|
||||
|
||||
shift = 12 - (in[5+i*2] & 15);
|
||||
filter = in[5+i*2] >> 4;
|
||||
if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table) || shift < 0) {
|
||||
if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) {
|
||||
avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter);
|
||||
filter=0;
|
||||
}
|
||||
if (shift < 0) {
|
||||
avpriv_request_sample(avctx, "unknown XA-ADPCM shift %d", shift);
|
||||
shift = 0;
|
||||
}
|
||||
|
||||
f0 = xa_adpcm_table[filter][0];
|
||||
f1 = xa_adpcm_table[filter][1];
|
||||
@@ -427,7 +415,7 @@ static int xa_decode(AVCodecContext *avctx, int16_t *out0, int16_t *out1,
|
||||
d = in[16+i+j*4];
|
||||
|
||||
t = sign_extend(d >> 4, 4);
|
||||
s = t*(1<<shift) + ((s_1*f0 + s_2*f1+32)>>6);
|
||||
s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
|
||||
s_2 = s_1;
|
||||
s_1 = av_clip_int16(s);
|
||||
out1[j] = s_1;
|
||||
@@ -1153,11 +1141,8 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
}
|
||||
for (i=0; i<=st; i++) {
|
||||
for (i=0; i<=st; i++)
|
||||
c->status[i].predictor = bytestream2_get_le32u(&gb);
|
||||
if (FFABS((int64_t)c->status[i].predictor) > (1<<16))
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
|
||||
for (n = nb_samples >> (1 - st); n > 0; n--) {
|
||||
int byte = bytestream2_get_byteu(&gb);
|
||||
@@ -1204,8 +1189,8 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
|
||||
|
||||
for (count2 = 0; count2 < 28; count2++) {
|
||||
byte = bytestream2_get_byteu(&gb);
|
||||
next_left_sample = sign_extend(byte >> 4, 4) * (1 << shift_left);
|
||||
next_right_sample = sign_extend(byte, 4) * (1 << shift_right);
|
||||
next_left_sample = sign_extend(byte >> 4, 4) << shift_left;
|
||||
next_right_sample = sign_extend(byte, 4) << shift_right;
|
||||
|
||||
next_left_sample = (next_left_sample +
|
||||
(current_left_sample * coeff1l) +
|
||||
@@ -1244,7 +1229,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
|
||||
if (st) byte[1] = bytestream2_get_byteu(&gb);
|
||||
for(i = 4; i >= 0; i-=4) { /* Pairwise samples LL RR (st) or LL LL (mono) */
|
||||
for(channel = 0; channel < avctx->channels; channel++) {
|
||||
int sample = sign_extend(byte[channel] >> i, 4) * (1 << shift[channel]);
|
||||
int sample = sign_extend(byte[channel] >> i, 4) << shift[channel];
|
||||
sample = (sample +
|
||||
c->status[channel].sample1 * coeff[channel][0] +
|
||||
c->status[channel].sample2 * coeff[channel][1] + 0x80) >> 8;
|
||||
@@ -1305,10 +1290,10 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
|
||||
|
||||
for (count2=0; count2<28; count2++) {
|
||||
if (count2 & 1)
|
||||
next_sample = (unsigned)sign_extend(byte, 4) << shift;
|
||||
next_sample = sign_extend(byte, 4) << shift;
|
||||
else {
|
||||
byte = bytestream2_get_byte(&gb);
|
||||
next_sample = (unsigned)sign_extend(byte >> 4, 4) << shift;
|
||||
next_sample = sign_extend(byte >> 4, 4) << shift;
|
||||
}
|
||||
|
||||
next_sample += (current_sample * coeff1) +
|
||||
@@ -1359,11 +1344,11 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
|
||||
int level, pred;
|
||||
int byte = bytestream2_get_byteu(&gb);
|
||||
|
||||
level = sign_extend(byte >> 4, 4) * (1 << shift[n]);
|
||||
level = sign_extend(byte >> 4, 4) << shift[n];
|
||||
pred = s[-1] * coeff[0][n] + s[-2] * coeff[1][n];
|
||||
s[0] = av_clip_int16((level + pred + 0x80) >> 8);
|
||||
|
||||
level = sign_extend(byte, 4) * (1 << shift[n]);
|
||||
level = sign_extend(byte, 4) << shift[n];
|
||||
pred = s[0] * coeff[0][n] + s[-1] * coeff[1][n];
|
||||
s[1] = av_clip_int16((level + pred + 0x80) >> 8);
|
||||
}
|
||||
@@ -1520,8 +1505,8 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
|
||||
sampledat = sign_extend(byte >> 4, 4);
|
||||
}
|
||||
|
||||
sampledat = ((prev1 * factor1 + prev2 * factor2) >> 11) +
|
||||
sampledat * scale;
|
||||
sampledat = ((prev1 * factor1 + prev2 * factor2) +
|
||||
((sampledat * scale) << 11)) >> 11;
|
||||
*samples = av_clip_int16(sampledat);
|
||||
prev2 = prev1;
|
||||
prev1 = *samples++;
|
||||
@@ -1583,8 +1568,8 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
|
||||
int byte = bytestream2_get_byteu(&gb);
|
||||
int index = (byte >> 4) & 7;
|
||||
unsigned int exp = byte & 0x0F;
|
||||
int64_t factor1 = table[ch][index * 2];
|
||||
int64_t factor2 = table[ch][index * 2 + 1];
|
||||
int factor1 = table[ch][index * 2];
|
||||
int factor2 = table[ch][index * 2 + 1];
|
||||
|
||||
/* Decode 14 samples. */
|
||||
for (n = 0; n < 14 && (i * 14 + n < nb_samples); n++) {
|
||||
@@ -1598,7 +1583,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
|
||||
}
|
||||
|
||||
sampledat = ((c->status[ch].sample1 * factor1
|
||||
+ c->status[ch].sample2 * factor2) >> 11) + sampledat * (1 << exp);
|
||||
+ c->status[ch].sample2 * factor2) >> 11) + (sampledat << exp);
|
||||
*samples = av_clip_int16(sampledat);
|
||||
c->status[ch].sample2 = c->status[ch].sample1;
|
||||
c->status[ch].sample1 = *samples++;
|
||||
@@ -1645,7 +1630,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
|
||||
else
|
||||
sampledat = sign_extend(byte >> 4, 4);
|
||||
|
||||
sampledat = ((sampledat * (1 << 12)) >> (header & 0xf)) * (1 << 6) + prev;
|
||||
sampledat = (((sampledat << 12) >> (header & 0xf)) << 6) + prev;
|
||||
*samples++ = av_clip_int16(sampledat >> 6);
|
||||
c->status[channel].sample2 = c->status[channel].sample1;
|
||||
c->status[channel].sample1 = sampledat;
|
||||
@@ -1682,7 +1667,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
|
||||
scale = sign_extend(byte, 4);
|
||||
}
|
||||
|
||||
scale = scale * (1 << 12);
|
||||
scale = scale << 12;
|
||||
sample = (int)((scale >> shift) + (c->status[channel].sample1 * xa_adpcm_table[filter][0] + c->status[channel].sample2 * xa_adpcm_table[filter][1]) / 64);
|
||||
}
|
||||
*samples++ = av_clip_int16(sample);
|
||||
|
||||
+3
-3
@@ -48,7 +48,7 @@ static void adx_encode(ADXContext *c, uint8_t *adx, const int16_t *wav,
|
||||
s2 = prev->s2;
|
||||
for (i = 0, j = 0; j < 32; i += channels, j++) {
|
||||
s0 = wav[i];
|
||||
d = s0 + ((-c->coeff[0] * s1 - c->coeff[1] * s2) >> COEFF_BITS);
|
||||
d = ((s0 << COEFF_BITS) - c->coeff[0] * s1 - c->coeff[1] * s2) >> COEFF_BITS;
|
||||
if (max < d)
|
||||
max = d;
|
||||
if (min > d)
|
||||
@@ -79,13 +79,13 @@ static void adx_encode(ADXContext *c, uint8_t *adx, const int16_t *wav,
|
||||
s1 = prev->s1;
|
||||
s2 = prev->s2;
|
||||
for (i = 0, j = 0; j < 32; i += channels, j++) {
|
||||
d = wav[i] + ((-c->coeff[0] * s1 - c->coeff[1] * s2) >> COEFF_BITS);
|
||||
d = ((wav[i] << COEFF_BITS) - c->coeff[0] * s1 - c->coeff[1] * s2) >> COEFF_BITS;
|
||||
|
||||
d = av_clip_intp2(ROUNDED_DIV(d, scale), 3);
|
||||
|
||||
put_sbits(&pb, 4, d);
|
||||
|
||||
s0 = d * scale + ((c->coeff[0] * s1 + c->coeff[1] * s2) >> COEFF_BITS);
|
||||
s0 = ((d << COEFF_BITS) * scale + c->coeff[0] * s1 + c->coeff[1] * s2) >> COEFF_BITS;
|
||||
s2 = s1;
|
||||
s1 = s0;
|
||||
}
|
||||
|
||||
@@ -208,9 +208,6 @@ static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst,
|
||||
int mb, idx;
|
||||
unsigned val;
|
||||
|
||||
if (get_bits_left(gb) < 5)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
has_skips = get_bits1(gb);
|
||||
coeff_type = get_bits1(gb);
|
||||
coeff_bits = get_bits(gb, 3);
|
||||
|
||||
+11
-13
@@ -171,12 +171,12 @@ static inline int sign_only(int v)
|
||||
return v ? FFSIGN(v) : 0;
|
||||
}
|
||||
|
||||
static void lpc_prediction(int32_t *error_buffer, uint32_t *buffer_out,
|
||||
static void lpc_prediction(int32_t *error_buffer, int32_t *buffer_out,
|
||||
int nb_samples, int bps, int16_t *lpc_coefs,
|
||||
int lpc_order, int lpc_quant)
|
||||
{
|
||||
int i;
|
||||
uint32_t *pred = buffer_out;
|
||||
int32_t *pred = buffer_out;
|
||||
|
||||
/* first sample always copies */
|
||||
*buffer_out = *error_buffer;
|
||||
@@ -208,27 +208,27 @@ static void lpc_prediction(int32_t *error_buffer, uint32_t *buffer_out,
|
||||
for (; i < nb_samples; i++) {
|
||||
int j;
|
||||
int val = 0;
|
||||
unsigned error_val = error_buffer[i];
|
||||
int error_val = error_buffer[i];
|
||||
int error_sign;
|
||||
int d = *pred++;
|
||||
|
||||
/* LPC prediction */
|
||||
for (j = 0; j < lpc_order; j++)
|
||||
val += (pred[j] - d) * lpc_coefs[j];
|
||||
val = (val + (1LL << (lpc_quant - 1))) >> lpc_quant;
|
||||
val = (val + (1 << (lpc_quant - 1))) >> lpc_quant;
|
||||
val += d + error_val;
|
||||
buffer_out[i] = sign_extend(val, bps);
|
||||
|
||||
/* adapt LPC coefficients */
|
||||
error_sign = sign_only(error_val);
|
||||
if (error_sign) {
|
||||
for (j = 0; j < lpc_order && (int)(error_val * error_sign) > 0; j++) {
|
||||
for (j = 0; j < lpc_order && error_val * error_sign > 0; j++) {
|
||||
int sign;
|
||||
val = d - pred[j];
|
||||
sign = sign_only(val) * error_sign;
|
||||
lpc_coefs[j] -= sign;
|
||||
val *= (unsigned)sign;
|
||||
error_val -= (val >> lpc_quant) * (j + 1U);
|
||||
val *= sign;
|
||||
error_val -= (val >> lpc_quant) * (j + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -250,12 +250,10 @@ static int decode_element(AVCodecContext *avctx, AVFrame *frame, int ch_index,
|
||||
|
||||
alac->extra_bits = get_bits(&alac->gb, 2) << 3;
|
||||
bps = alac->sample_size - alac->extra_bits + channels - 1;
|
||||
if (bps > 32) {
|
||||
if (bps > 32U) {
|
||||
avpriv_report_missing_feature(avctx, "bps %d", bps);
|
||||
return AVERROR_PATCHWELCOME;
|
||||
}
|
||||
if (bps < 1)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
/* whether the frame is compressed */
|
||||
is_compressed = !get_bits1(&alac->gb);
|
||||
@@ -308,7 +306,7 @@ static int decode_element(AVCodecContext *avctx, AVFrame *frame, int ch_index,
|
||||
rice_history_mult[ch] = get_bits(&alac->gb, 3);
|
||||
lpc_order[ch] = get_bits(&alac->gb, 5);
|
||||
|
||||
if (lpc_order[ch] >= alac->max_samples_per_frame || !lpc_quant[ch])
|
||||
if (lpc_order[ch] >= alac->max_samples_per_frame)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
/* read the predictor table */
|
||||
@@ -397,13 +395,13 @@ static int decode_element(AVCodecContext *avctx, AVFrame *frame, int ch_index,
|
||||
case 20: {
|
||||
for (ch = 0; ch < channels; ch++) {
|
||||
for (i = 0; i < alac->nb_samples; i++)
|
||||
alac->output_samples_buffer[ch][i] *= 1U << 12;
|
||||
alac->output_samples_buffer[ch][i] <<= 12;
|
||||
}}
|
||||
break;
|
||||
case 24: {
|
||||
for (ch = 0; ch < channels; ch++) {
|
||||
for (i = 0; i < alac->nb_samples; i++)
|
||||
alac->output_samples_buffer[ch][i] *= 1U << 8;
|
||||
alac->output_samples_buffer[ch][i] <<= 8;
|
||||
}}
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -49,7 +49,7 @@ static void append_extra_bits(int32_t *buffer[2], int32_t *extra_bits_buffer[2],
|
||||
|
||||
for (ch = 0; ch < channels; ch++)
|
||||
for (i = 0; i < nb_samples; i++)
|
||||
buffer[ch][i] = ((unsigned)buffer[ch][i] << extra_bits) | extra_bits_buffer[ch][i];
|
||||
buffer[ch][i] = (buffer[ch][i] << extra_bits) | extra_bits_buffer[ch][i];
|
||||
}
|
||||
|
||||
av_cold void ff_alacdsp_init(ALACDSPContext *c)
|
||||
|
||||
@@ -62,9 +62,6 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
if (bytestream2_get_bytes_left(&gb) < width*height / 255)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
ret = ff_get_buffer(avctx, f, 0);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
+25
-55
@@ -348,11 +348,6 @@ static av_cold int read_specific_config(ALSDecContext *ctx)
|
||||
if (als_id != MKBETAG('A','L','S','\0'))
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
if (avctx->channels > FF_SANE_NB_CHANNELS) {
|
||||
avpriv_request_sample(avctx, "Huge number of channels\n");
|
||||
return AVERROR_PATCHWELCOME;
|
||||
}
|
||||
|
||||
ctx->cur_frame_length = sconf->frame_length;
|
||||
|
||||
// read channel config
|
||||
@@ -492,7 +487,7 @@ static void parse_bs_info(const uint32_t bs_info, unsigned int n,
|
||||
static int32_t decode_rice(GetBitContext *gb, unsigned int k)
|
||||
{
|
||||
int max = get_bits_left(gb) - k;
|
||||
unsigned q = get_unary(gb, 0, max);
|
||||
int q = get_unary(gb, 0, max);
|
||||
int r = k ? get_bits1(gb) : !(q & 1);
|
||||
|
||||
if (k > 1) {
|
||||
@@ -512,7 +507,7 @@ static void parcor_to_lpc(unsigned int k, const int32_t *par, int32_t *cof)
|
||||
int i, j;
|
||||
|
||||
for (i = 0, j = k - 1; i < j; i++, j--) {
|
||||
unsigned tmp1 = ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20);
|
||||
int tmp1 = ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20);
|
||||
cof[j] += ((MUL64(par[k], cof[i]) + (1 << 19)) >> 20);
|
||||
cof[i] += tmp1;
|
||||
}
|
||||
@@ -662,7 +657,7 @@ static int read_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
|
||||
|
||||
// do not continue in case of a damaged stream since
|
||||
// block_length must be evenly divisible by sub_blocks
|
||||
if (bd->block_length & (sub_blocks - 1) || bd->block_length <= 0) {
|
||||
if (bd->block_length & (sub_blocks - 1)) {
|
||||
av_log(avctx, AV_LOG_WARNING,
|
||||
"Block length is not evenly divisible by the number of subblocks.\n");
|
||||
return AVERROR_INVALIDDATA;
|
||||
@@ -772,8 +767,8 @@ static int read_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
|
||||
if (*bd->use_ltp) {
|
||||
int r, c;
|
||||
|
||||
bd->ltp_gain[0] = decode_rice(gb, 1) * 8;
|
||||
bd->ltp_gain[1] = decode_rice(gb, 2) * 8;
|
||||
bd->ltp_gain[0] = decode_rice(gb, 1) << 3;
|
||||
bd->ltp_gain[1] = decode_rice(gb, 2) << 3;
|
||||
|
||||
r = get_unary(gb, 0, 4);
|
||||
c = get_bits(gb, 2);
|
||||
@@ -784,8 +779,8 @@ static int read_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
|
||||
|
||||
bd->ltp_gain[2] = ltp_gain_values[r][c];
|
||||
|
||||
bd->ltp_gain[3] = decode_rice(gb, 2) * 8;
|
||||
bd->ltp_gain[4] = decode_rice(gb, 1) * 8;
|
||||
bd->ltp_gain[3] = decode_rice(gb, 2) << 3;
|
||||
bd->ltp_gain[4] = decode_rice(gb, 1) << 3;
|
||||
|
||||
*bd->ltp_lag = get_bits(gb, ctx->ltp_lag_length);
|
||||
*bd->ltp_lag += FFMAX(4, opt_order + 1);
|
||||
@@ -794,20 +789,14 @@ static int read_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
|
||||
|
||||
// read first value and residuals in case of a random access block
|
||||
if (bd->ra_block) {
|
||||
start = FFMIN(opt_order, 3);
|
||||
av_assert0(sb_length <= sconf->frame_length);
|
||||
if (sb_length <= start) {
|
||||
// opt_order or sb_length may be corrupted, either way this is unsupported and not well defined in the specification
|
||||
av_log(avctx, AV_LOG_ERROR, "Sub block length smaller or equal start\n");
|
||||
return AVERROR_PATCHWELCOME;
|
||||
}
|
||||
|
||||
if (opt_order)
|
||||
bd->raw_samples[0] = decode_rice(gb, avctx->bits_per_raw_sample - 4);
|
||||
if (opt_order > 1)
|
||||
bd->raw_samples[1] = decode_rice(gb, FFMIN(s[0] + 3, ctx->s_max));
|
||||
if (opt_order > 2)
|
||||
bd->raw_samples[2] = decode_rice(gb, FFMIN(s[0] + 1, ctx->s_max));
|
||||
|
||||
start = FFMIN(opt_order, 3);
|
||||
}
|
||||
|
||||
// read all residuals
|
||||
@@ -821,9 +810,7 @@ static int read_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
|
||||
unsigned int low;
|
||||
unsigned int value;
|
||||
|
||||
int ret = ff_bgmc_decode_init(gb, &high, &low, &value);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
ff_bgmc_decode_init(gb, &high, &low, &value);
|
||||
|
||||
current_res = bd->raw_samples + start;
|
||||
|
||||
@@ -833,9 +820,6 @@ static int read_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
|
||||
k [sb] = s[sb] > b ? s[sb] - b : 0;
|
||||
delta[sb] = 5 - s[sb] + k[sb];
|
||||
|
||||
if (k[sb] >= 32)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
ff_bgmc_decode(gb, sb_len, current_res,
|
||||
delta[sb], sx[sb], &high, &low, &value, ctx->bgmc_lut, ctx->bgmc_lut_status);
|
||||
|
||||
@@ -877,7 +861,7 @@ static int read_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
|
||||
res >>= 1;
|
||||
|
||||
if (cur_k) {
|
||||
res *= 1U << cur_k;
|
||||
res *= 1 << cur_k;
|
||||
res |= get_bits_long(gb, cur_k);
|
||||
}
|
||||
}
|
||||
@@ -928,7 +912,7 @@ static int decode_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
|
||||
y = 1 << 6;
|
||||
|
||||
for (base = begin; base < end; base++, tab++)
|
||||
y += (uint64_t)MUL64(bd->ltp_gain[tab], raw_samples[base]);
|
||||
y += MUL64(bd->ltp_gain[tab], raw_samples[base]);
|
||||
|
||||
raw_samples[ltp_smp] += y >> 7;
|
||||
}
|
||||
@@ -940,7 +924,7 @@ static int decode_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
|
||||
y = 1 << 19;
|
||||
|
||||
for (sb = 0; sb < smp; sb++)
|
||||
y += (uint64_t)MUL64(lpc_cof[sb], raw_samples[-(sb + 1)]);
|
||||
y += MUL64(lpc_cof[sb], raw_samples[-(sb + 1)]);
|
||||
|
||||
*raw_samples++ -= y >> 20;
|
||||
parcor_to_lpc(smp, quant_cof, lpc_cof);
|
||||
@@ -956,7 +940,7 @@ static int decode_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
|
||||
|
||||
// reconstruct difference signal for prediction (joint-stereo)
|
||||
if (bd->js_blocks && bd->raw_other) {
|
||||
uint32_t *left, *right;
|
||||
int32_t *left, *right;
|
||||
|
||||
if (bd->raw_other > raw_samples) { // D = R - L
|
||||
left = raw_samples;
|
||||
@@ -990,7 +974,7 @@ static int decode_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
|
||||
y = 1 << 19;
|
||||
|
||||
for (sb = -opt_order; sb < 0; sb++)
|
||||
y += (uint64_t)MUL64(lpc_cof[sb], raw_samples[sb]);
|
||||
y += MUL64(lpc_cof[sb], raw_samples[sb]);
|
||||
|
||||
*raw_samples -= y >> 20;
|
||||
}
|
||||
@@ -1049,7 +1033,7 @@ static int decode_block(ALSDecContext *ctx, ALSBlockData *bd)
|
||||
|
||||
if (*bd->shift_lsbs)
|
||||
for (smp = 0; smp < bd->block_length; smp++)
|
||||
bd->raw_samples[smp] = (unsigned)bd->raw_samples[smp] << *bd->shift_lsbs;
|
||||
bd->raw_samples[smp] <<= *bd->shift_lsbs;
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1185,10 +1169,10 @@ static int decode_blocks(ALSDecContext *ctx, unsigned int ra_frame,
|
||||
av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel pair.\n");
|
||||
|
||||
for (s = 0; s < div_blocks[b]; s++)
|
||||
bd[0].raw_samples[s] = bd[1].raw_samples[s] - (unsigned)bd[0].raw_samples[s];
|
||||
bd[0].raw_samples[s] = bd[1].raw_samples[s] - bd[0].raw_samples[s];
|
||||
} else if (bd[1].js_blocks) {
|
||||
for (s = 0; s < div_blocks[b]; s++)
|
||||
bd[1].raw_samples[s] = bd[1].raw_samples[s] + (unsigned)bd[0].raw_samples[s];
|
||||
bd[1].raw_samples[s] = bd[1].raw_samples[s] + bd[0].raw_samples[s];
|
||||
}
|
||||
|
||||
offset += div_blocks[b];
|
||||
@@ -1395,9 +1379,6 @@ static SoftFloat_IEEE754 multiply(SoftFloat_IEEE754 a, SoftFloat_IEEE754 b) {
|
||||
mantissa_temp = (uint64_t)a.mant * (uint64_t)b.mant;
|
||||
mask_64 = (uint64_t)0x1 << 47;
|
||||
|
||||
if (!mantissa_temp)
|
||||
return FLOAT_0;
|
||||
|
||||
// Count the valid bit count
|
||||
while (!(mantissa_temp & mask_64) && mask_64) {
|
||||
bit_count--;
|
||||
@@ -1414,11 +1395,7 @@ static SoftFloat_IEEE754 multiply(SoftFloat_IEEE754 a, SoftFloat_IEEE754 b) {
|
||||
}
|
||||
}
|
||||
|
||||
if (cutoff_bit_count >= 0) {
|
||||
mantissa = (unsigned int)(mantissa_temp >> cutoff_bit_count);
|
||||
} else {
|
||||
mantissa = (unsigned int)(mantissa_temp <<-cutoff_bit_count);
|
||||
}
|
||||
mantissa = (unsigned int)(mantissa_temp >> cutoff_bit_count);
|
||||
|
||||
// Need one more shift?
|
||||
if (mantissa & 0x01000000ul) {
|
||||
@@ -1430,7 +1407,7 @@ static SoftFloat_IEEE754 multiply(SoftFloat_IEEE754 a, SoftFloat_IEEE754 b) {
|
||||
return_val = 0x80000000U;
|
||||
}
|
||||
|
||||
return_val |= ((unsigned)av_clip(a.exp + b.exp + bit_count - 47, -126, 127) << 23) & 0x7F800000;
|
||||
return_val |= (a.exp + b.exp + bit_count - 47) << 23;
|
||||
return_val |= mantissa;
|
||||
return av_bits2sf_ieee754(return_val);
|
||||
}
|
||||
@@ -1475,9 +1452,6 @@ static int read_diff_float_data(ALSDecContext *ctx, unsigned int ra_frame) {
|
||||
ff_mlz_flush_dict(ctx->mlz);
|
||||
}
|
||||
|
||||
if (avctx->channels * 8 > get_bits_left(gb))
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
for (c = 0; c < avctx->channels; ++c) {
|
||||
if (use_acf) {
|
||||
//acf_flag
|
||||
@@ -1818,17 +1792,15 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr,
|
||||
#define INTERLEAVE_OUTPUT(bps) \
|
||||
{ \
|
||||
int##bps##_t *dest = (int##bps##_t*)frame->data[0]; \
|
||||
int channels = avctx->channels; \
|
||||
int32_t **raw_samples = ctx->raw_samples; \
|
||||
shift = bps - ctx->avctx->bits_per_raw_sample; \
|
||||
if (!ctx->cs_switch) { \
|
||||
for (sample = 0; sample < ctx->cur_frame_length; sample++) \
|
||||
for (c = 0; c < channels; c++) \
|
||||
*dest++ = raw_samples[c][sample] * (1U << shift); \
|
||||
for (c = 0; c < avctx->channels; c++) \
|
||||
*dest++ = ctx->raw_samples[c][sample] << shift; \
|
||||
} else { \
|
||||
for (sample = 0; sample < ctx->cur_frame_length; sample++) \
|
||||
for (c = 0; c < channels; c++) \
|
||||
*dest++ = raw_samples[sconf->chan_pos[c]][sample] * (1U << shift);\
|
||||
for (c = 0; c < avctx->channels; c++) \
|
||||
*dest++ = ctx->raw_samples[sconf->chan_pos[c]][sample] << shift; \
|
||||
} \
|
||||
}
|
||||
|
||||
@@ -2012,8 +1984,6 @@ static av_cold int decode_init(AVCodecContext *avctx)
|
||||
|
||||
// allocate quantized parcor coefficient buffer
|
||||
num_buffers = sconf->mc_coding ? avctx->channels : 1;
|
||||
if (num_buffers * (uint64_t)num_buffers > INT_MAX) // protect chan_data_buffer allocation
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
ctx->quant_cof = av_malloc_array(num_buffers, sizeof(*ctx->quant_cof));
|
||||
ctx->lpc_cof = av_malloc_array(num_buffers, sizeof(*ctx->lpc_cof));
|
||||
@@ -2146,6 +2116,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
|
||||
return 0;
|
||||
|
||||
fail:
|
||||
decode_end(avctx);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@@ -2171,5 +2142,4 @@ AVCodec ff_als_decoder = {
|
||||
.decode = decode_frame,
|
||||
.flush = flush,
|
||||
.capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
|
||||
.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
|
||||
};
|
||||
|
||||
@@ -862,20 +862,15 @@ static float find_hb_gain(AMRWBContext *ctx, const float *synth,
|
||||
{
|
||||
int wsp = (vad > 0);
|
||||
float tilt;
|
||||
float tmp;
|
||||
|
||||
if (ctx->fr_cur_mode == MODE_23k85)
|
||||
return qua_hb_gain[hb_idx] * (1.0f / (1 << 14));
|
||||
|
||||
tmp = ctx->celpm_ctx.dot_productf(synth, synth + 1, AMRWB_SFR_SIZE - 1);
|
||||
|
||||
if (tmp > 0) {
|
||||
tilt = tmp / ctx->celpm_ctx.dot_productf(synth, synth, AMRWB_SFR_SIZE);
|
||||
} else
|
||||
tilt = 0;
|
||||
tilt = ctx->celpm_ctx.dot_productf(synth, synth + 1, AMRWB_SFR_SIZE - 1) /
|
||||
ctx->celpm_ctx.dot_productf(synth, synth, AMRWB_SFR_SIZE);
|
||||
|
||||
/* return gain bounded by [0.1, 1.0] */
|
||||
return av_clipf((1.0 - tilt) * (1.25 - 0.25 * wsp), 0.1, 1.0);
|
||||
return av_clipf((1.0 - FFMAX(0.0, tilt)) * (1.25 - 0.25 * wsp), 0.1, 1.0);
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
+1
-4
@@ -54,7 +54,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
|
||||
|
||||
bytestream2_skipu(&s->gb, 16 * 8);
|
||||
for (i = 0; i < 256; i++)
|
||||
s->palette[i] = (0xFFU << 24) | bytestream2_get_le32u(&s->gb);
|
||||
s->palette[i] = bytestream2_get_le32u(&s->gb);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -119,9 +119,6 @@ static int decode_frame(AVCodecContext *avctx,
|
||||
uint8_t *dst, *dst_end;
|
||||
int count, ret;
|
||||
|
||||
if (buf_size < 7)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
if ((ret = ff_reget_buffer(avctx, s->frame)) < 0)
|
||||
return ret;
|
||||
dst = s->frame->data[0];
|
||||
|
||||
+29
-31
@@ -460,7 +460,7 @@ static inline void update_rice(APERice *rice, unsigned int x)
|
||||
|
||||
if (rice->ksum < lim)
|
||||
rice->k--;
|
||||
else if (rice->ksum >= (1 << (rice->k + 5)) && rice->k < 24)
|
||||
else if (rice->ksum >= (1 << (rice->k + 5)))
|
||||
rice->k++;
|
||||
}
|
||||
|
||||
@@ -554,7 +554,7 @@ static inline int ape_decode_value_3990(APEContext *ctx, APERice *rice)
|
||||
overflow = range_get_symbol(ctx, counts_3980, counts_diff_3980);
|
||||
|
||||
if (overflow == (MODEL_ELEMENTS - 1)) {
|
||||
overflow = (unsigned)range_decode_bits(ctx, 16) << 16;
|
||||
overflow = range_decode_bits(ctx, 16) << 16;
|
||||
overflow |= range_decode_bits(ctx, 16);
|
||||
}
|
||||
|
||||
@@ -589,7 +589,7 @@ static void decode_array_0000(APEContext *ctx, GetBitContext *gb,
|
||||
int32_t *out, APERice *rice, int blockstodecode)
|
||||
{
|
||||
int i;
|
||||
unsigned ksummax, ksummin;
|
||||
int ksummax, ksummin;
|
||||
|
||||
rice->ksum = 0;
|
||||
for (i = 0; i < FFMIN(blockstodecode, 5); i++) {
|
||||
@@ -610,7 +610,7 @@ static void decode_array_0000(APEContext *ctx, GetBitContext *gb,
|
||||
ksummin = rice->k ? (1 << rice->k + 6) : 0;
|
||||
for (; i < blockstodecode; i++) {
|
||||
out[i] = get_rice_ook(&ctx->gb, rice->k);
|
||||
rice->ksum += out[i] - (unsigned)out[i - 64];
|
||||
rice->ksum += out[i] - out[i - 64];
|
||||
while (rice->ksum < ksummin) {
|
||||
rice->k--;
|
||||
ksummin = rice->k ? ksummin >> 1 : 0;
|
||||
@@ -836,7 +836,7 @@ static av_always_inline int filter_fast_3320(APEPredictor *p,
|
||||
else
|
||||
p->coeffsA[filter][0]--;
|
||||
|
||||
p->filterA[filter] += (unsigned)p->lastA[filter];
|
||||
p->filterA[filter] += p->lastA[filter];
|
||||
|
||||
return p->filterA[filter];
|
||||
}
|
||||
@@ -859,9 +859,9 @@ static av_always_inline int filter_3800(APEPredictor *p,
|
||||
return predictionA;
|
||||
}
|
||||
d2 = p->buf[delayA];
|
||||
d1 = (p->buf[delayA] - p->buf[delayA - 1]) * 2U;
|
||||
d0 = p->buf[delayA] + ((p->buf[delayA - 2] - p->buf[delayA - 1]) * 8U);
|
||||
d3 = p->buf[delayB] * 2U - p->buf[delayB - 1];
|
||||
d1 = (p->buf[delayA] - p->buf[delayA - 1]) << 1;
|
||||
d0 = p->buf[delayA] + ((p->buf[delayA - 2] - p->buf[delayA - 1]) << 3);
|
||||
d3 = p->buf[delayB] * 2 - p->buf[delayB - 1];
|
||||
d4 = p->buf[delayB];
|
||||
|
||||
predictionA = d0 * p->coeffsA[filter][0] +
|
||||
@@ -881,7 +881,7 @@ static av_always_inline int filter_3800(APEPredictor *p,
|
||||
p->coeffsB[filter][1] -= (((d4 >> 30) & 2) - 1) * sign;
|
||||
|
||||
p->filterB[filter] = p->lastA[filter] + (predictionB >> shift);
|
||||
p->filterA[filter] = p->filterB[filter] + (unsigned)((int)(p->filterA[filter] * 31U) >> 5);
|
||||
p->filterA[filter] = p->filterB[filter] + ((p->filterA[filter] * 31) >> 5);
|
||||
|
||||
return p->filterA[filter];
|
||||
}
|
||||
@@ -902,7 +902,7 @@ static void long_filter_high_3800(int32_t *buffer, int order, int shift, int len
|
||||
dotprod = 0;
|
||||
sign = APESIGN(buffer[i]);
|
||||
for (j = 0; j < order; j++) {
|
||||
dotprod += delay[j] * (unsigned)coeffs[j];
|
||||
dotprod += delay[j] * coeffs[j];
|
||||
coeffs[j] += ((delay[j] >> 31) | 1) * sign;
|
||||
}
|
||||
buffer[i] -= dotprod >> shift;
|
||||
@@ -916,8 +916,7 @@ static void long_filter_ehigh_3830(int32_t *buffer, int length)
|
||||
{
|
||||
int i, j;
|
||||
int32_t dotprod, sign;
|
||||
int32_t delay[8] = { 0 };
|
||||
uint32_t coeffs[8] = { 0 };
|
||||
int32_t coeffs[8] = { 0 }, delay[8] = { 0 };
|
||||
|
||||
for (i = 0; i < length; i++) {
|
||||
dotprod = 0;
|
||||
@@ -1052,7 +1051,7 @@ static av_always_inline int predictor_update_3930(APEPredictor *p,
|
||||
d3 * p->coeffsA[filter][3];
|
||||
|
||||
p->lastA[filter] = decoded + (predictionA >> 9);
|
||||
p->filterA[filter] = p->lastA[filter] + ((int)(p->filterA[filter] * 31U) >> 5);
|
||||
p->filterA[filter] = p->lastA[filter] + ((p->filterA[filter] * 31) >> 5);
|
||||
|
||||
sign = APESIGN(decoded);
|
||||
p->coeffsA[filter][0] += ((d0 < 0) * 2 - 1) * sign;
|
||||
@@ -1122,7 +1121,7 @@ static av_always_inline int predictor_update_filter(APEPredictor *p,
|
||||
|
||||
p->buf[delayA] = p->lastA[filter];
|
||||
p->buf[adaptA] = APESIGN(p->buf[delayA]);
|
||||
p->buf[delayA - 1] = p->buf[delayA] - (unsigned)p->buf[delayA - 1];
|
||||
p->buf[delayA - 1] = p->buf[delayA] - p->buf[delayA - 1];
|
||||
p->buf[adaptA - 1] = APESIGN(p->buf[delayA - 1]);
|
||||
|
||||
predictionA = p->buf[delayA ] * p->coeffsA[filter][0] +
|
||||
@@ -1131,9 +1130,9 @@ static av_always_inline int predictor_update_filter(APEPredictor *p,
|
||||
p->buf[delayA - 3] * p->coeffsA[filter][3];
|
||||
|
||||
/* Apply a scaled first-order filter compression */
|
||||
p->buf[delayB] = p->filterA[filter ^ 1] - ((int)(p->filterB[filter] * 31U) >> 5);
|
||||
p->buf[delayB] = p->filterA[filter ^ 1] - ((p->filterB[filter] * 31) >> 5);
|
||||
p->buf[adaptB] = APESIGN(p->buf[delayB]);
|
||||
p->buf[delayB - 1] = p->buf[delayB] - (unsigned)p->buf[delayB - 1];
|
||||
p->buf[delayB - 1] = p->buf[delayB] - p->buf[delayB - 1];
|
||||
p->buf[adaptB - 1] = APESIGN(p->buf[delayB - 1]);
|
||||
p->filterB[filter] = p->filterA[filter ^ 1];
|
||||
|
||||
@@ -1143,8 +1142,8 @@ static av_always_inline int predictor_update_filter(APEPredictor *p,
|
||||
p->buf[delayB - 3] * p->coeffsB[filter][3] +
|
||||
p->buf[delayB - 4] * p->coeffsB[filter][4];
|
||||
|
||||
p->lastA[filter] = decoded + ((int)((unsigned)predictionA + (predictionB >> 1)) >> 10);
|
||||
p->filterA[filter] = p->lastA[filter] + ((int)(p->filterA[filter] * 31U) >> 5);
|
||||
p->lastA[filter] = decoded + ((predictionA + (predictionB >> 1)) >> 10);
|
||||
p->filterA[filter] = p->lastA[filter] + ((p->filterA[filter] * 31) >> 5);
|
||||
|
||||
sign = APESIGN(decoded);
|
||||
p->coeffsA[filter][0] += p->buf[adaptA ] * sign;
|
||||
@@ -1203,14 +1202,14 @@ static void predictor_decode_mono_3950(APEContext *ctx, int count)
|
||||
A = *decoded0;
|
||||
|
||||
p->buf[YDELAYA] = currentA;
|
||||
p->buf[YDELAYA - 1] = p->buf[YDELAYA] - (unsigned)p->buf[YDELAYA - 1];
|
||||
p->buf[YDELAYA - 1] = p->buf[YDELAYA] - p->buf[YDELAYA - 1];
|
||||
|
||||
predictionA = p->buf[YDELAYA ] * p->coeffsA[0][0] +
|
||||
p->buf[YDELAYA - 1] * p->coeffsA[0][1] +
|
||||
p->buf[YDELAYA - 2] * p->coeffsA[0][2] +
|
||||
p->buf[YDELAYA - 3] * p->coeffsA[0][3];
|
||||
|
||||
currentA = A + (unsigned)(predictionA >> 10);
|
||||
currentA = A + (predictionA >> 10);
|
||||
|
||||
p->buf[YADAPTCOEFFSA] = APESIGN(p->buf[YDELAYA ]);
|
||||
p->buf[YADAPTCOEFFSA - 1] = APESIGN(p->buf[YDELAYA - 1]);
|
||||
@@ -1230,7 +1229,7 @@ static void predictor_decode_mono_3950(APEContext *ctx, int count)
|
||||
p->buf = p->historybuffer;
|
||||
}
|
||||
|
||||
p->filterA[0] = currentA + (unsigned)((int)(p->filterA[0] * 31U) >> 5);
|
||||
p->filterA[0] = currentA + ((p->filterA[0] * 31) >> 5);
|
||||
*(decoded0++) = p->filterA[0];
|
||||
}
|
||||
|
||||
@@ -1267,8 +1266,8 @@ static void do_apply_filter(APEContext *ctx, int version, APEFilter *f,
|
||||
f->delay - order,
|
||||
f->adaptcoeffs - order,
|
||||
order, APESIGN(*data));
|
||||
res = (int)(res + (1U << (fracbits - 1))) >> fracbits;
|
||||
res += (unsigned)*data;
|
||||
res = (res + (1 << (fracbits - 1))) >> fracbits;
|
||||
res += *data;
|
||||
*data++ = res;
|
||||
|
||||
/* Update the output history */
|
||||
@@ -1283,7 +1282,7 @@ static void do_apply_filter(APEContext *ctx, int version, APEFilter *f,
|
||||
/* Version 3.98 and later files */
|
||||
|
||||
/* Update the adaption coefficients */
|
||||
absres = res < 0 ? -(unsigned)res : res;
|
||||
absres = FFABS(res);
|
||||
if (absres)
|
||||
*f->adaptcoeffs = APESIGN(res) *
|
||||
(8 << ((absres > f->avg * 3) + (absres > f->avg * 4 / 3)));
|
||||
@@ -1298,7 +1297,7 @@ static void do_apply_filter(APEContext *ctx, int version, APEFilter *f,
|
||||
else
|
||||
*f->adaptcoeffs = 0;
|
||||
|
||||
f->avg += (int)(absres - (unsigned)f->avg) / 16;
|
||||
f->avg += (absres - f->avg) / 16;
|
||||
|
||||
f->adaptcoeffs[-1] >>= 1;
|
||||
f->adaptcoeffs[-2] >>= 1;
|
||||
@@ -1377,7 +1376,7 @@ static void ape_unpack_mono(APEContext *ctx, int count)
|
||||
|
||||
static void ape_unpack_stereo(APEContext *ctx, int count)
|
||||
{
|
||||
unsigned left, right;
|
||||
int32_t left, right;
|
||||
int32_t *decoded0 = ctx->decoded[0];
|
||||
int32_t *decoded1 = ctx->decoded[1];
|
||||
|
||||
@@ -1394,7 +1393,7 @@ static void ape_unpack_stereo(APEContext *ctx, int count)
|
||||
|
||||
/* Decorrelate and scale to output depth */
|
||||
while (count--) {
|
||||
left = *decoded1 - (unsigned)(*decoded0 / 2);
|
||||
left = *decoded1 - (*decoded0 / 2);
|
||||
right = left + *decoded0;
|
||||
|
||||
*(decoded0++) = left;
|
||||
@@ -1452,8 +1451,7 @@ static int ape_decode_frame(AVCodecContext *avctx, void *data,
|
||||
if (s->fileversion >= 3900) {
|
||||
if (offset > 3) {
|
||||
av_log(avctx, AV_LOG_ERROR, "Incorrect offset passed\n");
|
||||
av_freep(&s->data);
|
||||
s->data_size = 0;
|
||||
s->data = NULL;
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
if (s->data_end - s->ptr < offset) {
|
||||
@@ -1501,7 +1499,7 @@ static int ape_decode_frame(AVCodecContext *avctx, void *data,
|
||||
av_fast_malloc(&s->decoded_buffer, &s->decoded_size, decoded_buffer_size);
|
||||
if (!s->decoded_buffer)
|
||||
return AVERROR(ENOMEM);
|
||||
memset(s->decoded_buffer, 0, decoded_buffer_size);
|
||||
memset(s->decoded_buffer, 0, s->decoded_size);
|
||||
s->decoded[0] = s->decoded_buffer;
|
||||
s->decoded[1] = s->decoded_buffer + FFALIGN(blockstodecode, 8);
|
||||
|
||||
@@ -1543,7 +1541,7 @@ static int ape_decode_frame(AVCodecContext *avctx, void *data,
|
||||
for (ch = 0; ch < s->channels; ch++) {
|
||||
sample24 = (int32_t *)frame->data[ch];
|
||||
for (i = 0; i < blockstodecode; i++)
|
||||
*sample24++ = s->decoded[ch][i] * 256;
|
||||
*sample24++ = s->decoded[ch][i] << 8;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
+8
-11
@@ -480,7 +480,7 @@ static void aptx_update_codeword_history(Channel *channel)
|
||||
int32_t cw = ((channel->quantize[0].quantized_sample & 3) << 0) +
|
||||
((channel->quantize[1].quantized_sample & 2) << 1) +
|
||||
((channel->quantize[2].quantized_sample & 1) << 3);
|
||||
channel->codeword_history = (cw << 8) + ((unsigned)channel->codeword_history << 4);
|
||||
channel->codeword_history = (cw << 8) + (channel->codeword_history << 4);
|
||||
}
|
||||
|
||||
static void aptx_generate_dither(Channel *channel)
|
||||
@@ -492,9 +492,9 @@ static void aptx_generate_dither(Channel *channel)
|
||||
aptx_update_codeword_history(channel);
|
||||
|
||||
m = (int64_t)5184443 * (channel->codeword_history >> 7);
|
||||
d = (m * 4) + (m >> 22);
|
||||
d = (m << 2) + (m >> 22);
|
||||
for (subband = 0; subband < NB_SUBBANDS; subband++)
|
||||
channel->dither[subband] = (unsigned)d << (23 - 5*subband);
|
||||
channel->dither[subband] = d << (23 - 5*subband);
|
||||
channel->dither_parity = (d >> 25) & 1;
|
||||
}
|
||||
|
||||
@@ -759,12 +759,12 @@ static void aptx_invert_quantization(InvertQuantize *invert_quantize,
|
||||
if (quantized_sample < 0)
|
||||
qr = -qr;
|
||||
|
||||
qr = rshift64_clip24((qr * (1LL<<32)) + MUL64(dither, tables->invert_quantize_dither_factors[idx]), 32);
|
||||
qr = rshift64_clip24(((int64_t)qr<<32) + MUL64(dither, tables->invert_quantize_dither_factors[idx]), 32);
|
||||
invert_quantize->reconstructed_difference = MUL64(invert_quantize->quantization_factor, qr) >> 19;
|
||||
|
||||
/* update factor_select */
|
||||
factor_select = 32620 * invert_quantize->factor_select;
|
||||
factor_select = rshift32(factor_select + (tables->quantize_factor_select_offset[idx] * (1 << 15)), 15);
|
||||
factor_select = rshift32(factor_select + (tables->quantize_factor_select_offset[idx] << 15), 15);
|
||||
invert_quantize->factor_select = av_clip(factor_select, 0, tables->factor_max);
|
||||
|
||||
/* update quantization factor */
|
||||
@@ -801,7 +801,7 @@ static void aptx_prediction_filtering(Prediction *prediction,
|
||||
prediction->previous_reconstructed_sample = reconstructed_sample;
|
||||
|
||||
reconstructed_differences = aptx_reconstructed_differences_update(prediction, reconstructed_difference, order);
|
||||
srd0 = FFDIFFSIGN(reconstructed_difference, 0) * (1 << 23);
|
||||
srd0 = FFDIFFSIGN(reconstructed_difference, 0) << 23;
|
||||
for (i = 0; i < order; i++) {
|
||||
int32_t srd = FF_SIGNBIT(reconstructed_differences[-i-1]) | 1;
|
||||
prediction->d_weight[i] -= rshift32(prediction->d_weight[i] - srd*srd0, 8);
|
||||
@@ -830,7 +830,7 @@ static void aptx_process_subband(InvertQuantize *invert_quantize,
|
||||
|
||||
range = 0x100000;
|
||||
sw1 = rshift32(-same_sign[1] * prediction->s_weight[1], 1);
|
||||
sw1 = (av_clip(sw1, -range, range) & ~0xF) * 16;
|
||||
sw1 = (av_clip(sw1, -range, range) & ~0xF) << 4;
|
||||
|
||||
range = 0x300000;
|
||||
weight[0] = 254 * prediction->s_weight[0] + 0x800000*same_sign[0] + sw1;
|
||||
@@ -989,9 +989,6 @@ static av_cold int aptx_init(AVCodecContext *avctx)
|
||||
AptXContext *s = avctx->priv_data;
|
||||
int chan, subband;
|
||||
|
||||
if (avctx->channels != 2)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
s->hd = avctx->codec->id == AV_CODEC_ID_APTX_HD;
|
||||
s->block_size = s->hd ? 6 : 4;
|
||||
|
||||
@@ -1047,7 +1044,7 @@ static int aptx_decode_frame(AVCodecContext *avctx, void *data,
|
||||
for (channel = 0; channel < NB_CHANNELS; channel++)
|
||||
for (sample = 0; sample < 4; sample++)
|
||||
AV_WN32A(&frame->data[channel][4*(opos+sample)],
|
||||
samples[channel][sample] * 256);
|
||||
samples[channel][sample] << 8);
|
||||
}
|
||||
|
||||
*got_frame_ptr = 1;
|
||||
|
||||
+1
-2
@@ -31,8 +31,7 @@ static av_cold int ass_decode_init(AVCodecContext *avctx)
|
||||
avctx->subtitle_header = av_malloc(avctx->extradata_size + 1);
|
||||
if (!avctx->subtitle_header)
|
||||
return AVERROR(ENOMEM);
|
||||
if (avctx->extradata_size)
|
||||
memcpy(avctx->subtitle_header, avctx->extradata, avctx->extradata_size);
|
||||
memcpy(avctx->subtitle_header, avctx->extradata, avctx->extradata_size);
|
||||
avctx->subtitle_header[avctx->extradata_size] = 0;
|
||||
avctx->subtitle_header_size = avctx->extradata_size;
|
||||
return 0;
|
||||
|
||||
+1
-1
@@ -964,7 +964,7 @@ static av_cold int atrac3_decode_init(AVCodecContext *avctx)
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
|
||||
if (avctx->block_align > 1024 || avctx->block_align <= 0)
|
||||
if (avctx->block_align >= UINT_MAX / 2)
|
||||
return AVERROR(EINVAL);
|
||||
|
||||
q->decoded_bytes_buffer = av_mallocz(FFALIGN(avctx->block_align, 4) +
|
||||
|
||||
@@ -456,10 +456,6 @@ static int decode_channel_wordlen(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
|
||||
} else if (chan->fill_mode == 3) {
|
||||
pos = ch_num ? chan->num_coded_vals + chan->split_point
|
||||
: ctx->num_quant_units - chan->split_point;
|
||||
if (pos > FF_ARRAY_ELEMS(chan->qu_wordlen)) {
|
||||
av_log(avctx, AV_LOG_ERROR, "Split point beyond array\n");
|
||||
pos = FF_ARRAY_ELEMS(chan->qu_wordlen);
|
||||
}
|
||||
for (i = chan->num_coded_vals; i < pos; i++)
|
||||
chan->qu_wordlen[i] = 1;
|
||||
}
|
||||
|
||||
@@ -79,7 +79,7 @@ static void vector_clipf_c(float *dst, const float *src, int len,
|
||||
static int32_t scalarproduct_int16_c(const int16_t *v1, const int16_t *v2,
|
||||
int order)
|
||||
{
|
||||
unsigned res = 0;
|
||||
int res = 0;
|
||||
|
||||
while (order--)
|
||||
res += *v1++ **v2++;
|
||||
|
||||
@@ -1312,7 +1312,7 @@ enum AVPacketSideDataType {
|
||||
AV_PKT_DATA_METADATA_UPDATE,
|
||||
|
||||
/**
|
||||
* MPEGTS stream ID as uint8_t, this is required to pass the stream ID
|
||||
* MPEGTS stream ID, this is required to pass the stream ID
|
||||
* information from the demuxer to the corresponding muxer.
|
||||
*/
|
||||
AV_PKT_DATA_MPEGTS_STREAM_ID,
|
||||
|
||||
+1
-1
@@ -100,7 +100,7 @@ int avcodec_dct_init(AVDCT *dsp)
|
||||
|
||||
#if CONFIG_IDCTDSP
|
||||
{
|
||||
IDCTDSPContext idsp = {0};
|
||||
IDCTDSPContext idsp;
|
||||
ff_idctdsp_init(&idsp, avctx);
|
||||
COPY(idsp, idct);
|
||||
COPY(idsp, idct_permutation);
|
||||
|
||||
@@ -109,11 +109,6 @@ static int bethsoftvid_decode_frame(AVCodecContext *avctx,
|
||||
if(yoffset >= avctx->height)
|
||||
return AVERROR_INVALIDDATA;
|
||||
dst += vid->frame->linesize[0] * yoffset;
|
||||
case VIDEO_P_FRAME:
|
||||
case VIDEO_I_FRAME:
|
||||
break;
|
||||
default:
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
|
||||
// main code
|
||||
|
||||
+1
-6
@@ -485,17 +485,12 @@ av_cold void ff_bgmc_end(uint8_t **cf_lut, int **cf_lut_status)
|
||||
|
||||
|
||||
/** Initialize decoding and reads the first value */
|
||||
int ff_bgmc_decode_init(GetBitContext *gb, unsigned int *h,
|
||||
void ff_bgmc_decode_init(GetBitContext *gb, unsigned int *h,
|
||||
unsigned int *l, unsigned int *v)
|
||||
{
|
||||
if (get_bits_left(gb) < VALUE_BITS)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
*h = TOP_VALUE;
|
||||
*l = 0;
|
||||
*v = get_bits_long(gb, VALUE_BITS);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
+1
-1
@@ -40,7 +40,7 @@ int ff_bgmc_init(AVCodecContext *avctx, uint8_t **cf_lut, int **cf_lut_status);
|
||||
void ff_bgmc_end(uint8_t **cf_lut, int **cf_lut_status);
|
||||
|
||||
|
||||
int ff_bgmc_decode_init(GetBitContext *gb,
|
||||
void ff_bgmc_decode_init(GetBitContext *gb,
|
||||
unsigned int *h, unsigned int *l, unsigned int *v);
|
||||
|
||||
|
||||
|
||||
+6
-6
@@ -694,15 +694,15 @@ static int read_dct_coeffs(GetBitContext *gb, int32_t block[64],
|
||||
return quant_idx;
|
||||
}
|
||||
|
||||
static void unquantize_dct_coeffs(int32_t block[64], const uint32_t quant[64],
|
||||
static void unquantize_dct_coeffs(int32_t block[64], const int32_t quant[64],
|
||||
int coef_count, int coef_idx[64],
|
||||
const uint8_t *scan)
|
||||
{
|
||||
int i;
|
||||
block[0] = (int)(block[0] * quant[0]) >> 11;
|
||||
block[0] = (block[0] * quant[0]) >> 11;
|
||||
for (i = 0; i < coef_count; i++) {
|
||||
int idx = coef_idx[i];
|
||||
block[scan[idx]] = (int)(block[scan[idx]] * quant[idx]) >> 11;
|
||||
block[scan[idx]] = (block[scan[idx]] * quant[idx]) >> 11;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1314,13 +1314,13 @@ static av_cold int decode_init(AVCodecContext *avctx)
|
||||
}
|
||||
c->avctx = avctx;
|
||||
|
||||
if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
|
||||
return ret;
|
||||
|
||||
c->last = av_frame_alloc();
|
||||
if (!c->last)
|
||||
return AVERROR(ENOMEM);
|
||||
|
||||
if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
|
||||
return ret;
|
||||
|
||||
avctx->pix_fmt = c->has_alpha ? AV_PIX_FMT_YUVA420P : AV_PIX_FMT_YUV420P;
|
||||
|
||||
ff_blockdsp_init(&c->bdsp, avctx);
|
||||
|
||||
@@ -95,8 +95,6 @@ static av_cold int decode_init(AVCodecContext *avctx)
|
||||
if (avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT) {
|
||||
// audio is already interleaved for the RDFT format variant
|
||||
avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
|
||||
if (sample_rate > INT_MAX / avctx->channels)
|
||||
return AVERROR_INVALIDDATA;
|
||||
sample_rate *= avctx->channels;
|
||||
s->channels = 1;
|
||||
if (!s->version_b)
|
||||
@@ -109,7 +107,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
|
||||
s->frame_len = 1 << frame_len_bits;
|
||||
s->overlap_len = s->frame_len / 16;
|
||||
s->block_size = (s->frame_len - s->overlap_len) * s->channels;
|
||||
sample_rate_half = (sample_rate + 1LL) / 2;
|
||||
sample_rate_half = (sample_rate + 1) / 2;
|
||||
if (avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT)
|
||||
s->root = 2.0 / (sqrt(s->frame_len) * 32768.0);
|
||||
else
|
||||
|
||||
@@ -33,22 +33,20 @@
|
||||
#define A3 3784
|
||||
#define A4 -5352
|
||||
|
||||
#define MUL(X,Y) ((int)((unsigned)(X) * (Y)) >> 11)
|
||||
|
||||
#define IDCT_TRANSFORM(dest,s0,s1,s2,s3,s4,s5,s6,s7,d0,d1,d2,d3,d4,d5,d6,d7,munge,src) {\
|
||||
const int a0 = (src)[s0] + (src)[s4]; \
|
||||
const int a1 = (src)[s0] - (src)[s4]; \
|
||||
const int a2 = (src)[s2] + (src)[s6]; \
|
||||
const int a3 = MUL(A1, (src)[s2] - (src)[s6]); \
|
||||
const int a3 = (A1*((src)[s2] - (src)[s6])) >> 11; \
|
||||
const int a4 = (src)[s5] + (src)[s3]; \
|
||||
const int a5 = (src)[s5] - (src)[s3]; \
|
||||
const int a6 = (src)[s1] + (src)[s7]; \
|
||||
const int a7 = (src)[s1] - (src)[s7]; \
|
||||
const int b0 = a4 + a6; \
|
||||
const int b1 = MUL(A3, a5 + a7); \
|
||||
const int b2 = MUL(A4, a5) - b0 + b1; \
|
||||
const int b3 = MUL(A1, a6 - a4) - b2; \
|
||||
const int b4 = MUL(A2, a7) + b3 - b1; \
|
||||
const int b1 = (A3*(a5 + a7)) >> 11; \
|
||||
const int b2 = ((A4*a5) >> 11) - b0 + b1; \
|
||||
const int b3 = (A1*(a6 - a4) >> 11) - b2; \
|
||||
const int b4 = ((A2*a7) >> 11) + b3 - b1; \
|
||||
(dest)[d0] = munge(a0+a2 +b0); \
|
||||
(dest)[d1] = munge(a1+a3-a2+b2); \
|
||||
(dest)[d2] = munge(a1-a3+a2+b3); \
|
||||
|
||||
@@ -63,10 +63,6 @@ static av_cold int decode_init(AVCodecContext *avctx)
|
||||
av_log(avctx, AV_LOG_ERROR, "not enough extradata\n");
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
if (!s->font_height) {
|
||||
av_log(avctx, AV_LOG_ERROR, "invalid font height\n");
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
} else {
|
||||
s->font_height = 8;
|
||||
s->flags = 0;
|
||||
|
||||
@@ -162,9 +162,9 @@ static int build_table(VLC *vlc, int table_nb_bits, int nb_codes,
|
||||
uint32_t code;
|
||||
volatile VLC_TYPE (* volatile table)[2]; // the double volatile is needed to prevent an internal compiler error in gcc 4.2
|
||||
|
||||
table_size = 1 << table_nb_bits;
|
||||
if (table_nb_bits > 30)
|
||||
return -1;
|
||||
table_size = 1 << table_nb_bits;
|
||||
table_index = alloc_table(vlc, table_size, flags & INIT_VLC_USE_NEW_STATIC);
|
||||
ff_dlog(NULL, "new table index=%d size=%d\n", table_index, table_size);
|
||||
if (table_index < 0)
|
||||
@@ -188,9 +188,8 @@ static int build_table(VLC *vlc, int table_nb_bits, int nb_codes,
|
||||
}
|
||||
for (k = 0; k < nb; k++) {
|
||||
int bits = table[j][1];
|
||||
int oldsym = table[j][0];
|
||||
ff_dlog(NULL, "%4x: code=%d n=%d\n", j, i, n);
|
||||
if ((bits || oldsym) && (bits != n || oldsym != symbol)) {
|
||||
if (bits != 0 && bits != n) {
|
||||
av_log(NULL, AV_LOG_ERROR, "incorrect codes\n");
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
@@ -227,10 +226,6 @@ static int build_table(VLC *vlc, int table_nb_bits, int nb_codes,
|
||||
/* note: realloc has been done, so reload tables */
|
||||
table = (volatile VLC_TYPE (*)[2])&vlc->table[table_index];
|
||||
table[j][0] = index; //code
|
||||
if (table[j][0] != index) {
|
||||
avpriv_request_sample(NULL, "strange codes");
|
||||
return AVERROR_PATCHWELCOME;
|
||||
}
|
||||
i = k-1;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -77,9 +77,6 @@ const AVBitStreamFilter *av_bsf_get_by_name(const char *name)
|
||||
const AVBitStreamFilter *f = NULL;
|
||||
void *i = 0;
|
||||
|
||||
if (!name)
|
||||
return NULL;
|
||||
|
||||
while ((f = av_bsf_iterate(&i))) {
|
||||
if (!strcmp(f->name, name))
|
||||
return f;
|
||||
|
||||
+1
-4
@@ -291,7 +291,7 @@ static int bmp_decode_frame(AVCodecContext *avctx,
|
||||
case 1:
|
||||
for (i = 0; i < avctx->height; i++) {
|
||||
int j;
|
||||
for (j = 0; j < avctx->width >> 3; j++) {
|
||||
for (j = 0; j < n; j++) {
|
||||
ptr[j*8+0] = buf[j] >> 7;
|
||||
ptr[j*8+1] = (buf[j] >> 6) & 1;
|
||||
ptr[j*8+2] = (buf[j] >> 5) & 1;
|
||||
@@ -301,9 +301,6 @@ static int bmp_decode_frame(AVCodecContext *avctx,
|
||||
ptr[j*8+6] = (buf[j] >> 1) & 1;
|
||||
ptr[j*8+7] = buf[j] & 1;
|
||||
}
|
||||
for (j = 0; j < (avctx->width & 7); j++) {
|
||||
ptr[avctx->width - (avctx->width & 7) + j] = buf[avctx->width >> 3] >> (7 - j) & 1;
|
||||
}
|
||||
buf += n;
|
||||
ptr += linesize;
|
||||
}
|
||||
|
||||
@@ -204,10 +204,6 @@ static int pix_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
|
||||
avpriv_request_sample(avctx, "Format %d", hdr.format);
|
||||
return AVERROR_PATCHWELCOME;
|
||||
}
|
||||
bytes_per_scanline = bytes_pp * hdr.width;
|
||||
|
||||
if (bytestream2_get_bytes_left(&gb) < hdr.height * bytes_per_scanline)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
if ((ret = ff_set_dimensions(avctx, hdr.width, hdr.height)) < 0)
|
||||
return ret;
|
||||
@@ -265,6 +261,7 @@ static int pix_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
|
||||
bytestream2_skip(&gb, 8);
|
||||
|
||||
// read the image data to the buffer
|
||||
bytes_per_scanline = bytes_pp * hdr.width;
|
||||
bytes_left = bytestream2_get_bytes_left(&gb);
|
||||
|
||||
if (chunk_type != IMAGE_DATA_CHUNK || data_len != bytes_left ||
|
||||
|
||||
+1
-2
@@ -47,8 +47,7 @@ void av_bsf_free(AVBSFContext **pctx)
|
||||
|
||||
av_opt_free(ctx);
|
||||
|
||||
if (ctx->internal)
|
||||
av_packet_free(&ctx->internal->buffer_pkt);
|
||||
av_packet_free(&ctx->internal->buffer_pkt);
|
||||
av_freep(&ctx->internal);
|
||||
av_freep(&ctx->priv_data);
|
||||
|
||||
|
||||
+8
-25
@@ -591,21 +591,14 @@ static int decode_residual_block(AVSContext *h, GetBitContext *gb,
|
||||
}
|
||||
|
||||
|
||||
static inline int decode_residual_chroma(AVSContext *h)
|
||||
static inline void decode_residual_chroma(AVSContext *h)
|
||||
{
|
||||
if (h->cbp & (1 << 4)) {
|
||||
int ret = decode_residual_block(h, &h->gb, chroma_dec, 0,
|
||||
if (h->cbp & (1 << 4))
|
||||
decode_residual_block(h, &h->gb, chroma_dec, 0,
|
||||
ff_cavs_chroma_qp[h->qp], h->cu, h->c_stride);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
}
|
||||
if (h->cbp & (1 << 5)) {
|
||||
int ret = decode_residual_block(h, &h->gb, chroma_dec, 0,
|
||||
if (h->cbp & (1 << 5))
|
||||
decode_residual_block(h, &h->gb, chroma_dec, 0,
|
||||
ff_cavs_chroma_qp[h->qp], h->cv, h->c_stride);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int decode_residual_inter(AVSContext *h)
|
||||
@@ -656,7 +649,6 @@ static int decode_mb_i(AVSContext *h, int cbp_code)
|
||||
uint8_t top[18];
|
||||
uint8_t *left = NULL;
|
||||
uint8_t *d;
|
||||
int ret;
|
||||
|
||||
ff_cavs_init_mb(h);
|
||||
|
||||
@@ -700,11 +692,8 @@ static int decode_mb_i(AVSContext *h, int cbp_code)
|
||||
ff_cavs_load_intra_pred_luma(h, top, &left, block);
|
||||
h->intra_pred_l[h->pred_mode_Y[scan3x3[block]]]
|
||||
(d, top, left, h->l_stride);
|
||||
if (h->cbp & (1<<block)) {
|
||||
ret = decode_residual_block(h, gb, intra_dec, 1, h->qp, d, h->l_stride);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
}
|
||||
if (h->cbp & (1<<block))
|
||||
decode_residual_block(h, gb, intra_dec, 1, h->qp, d, h->l_stride);
|
||||
}
|
||||
|
||||
/* chroma intra prediction */
|
||||
@@ -714,9 +703,7 @@ static int decode_mb_i(AVSContext *h, int cbp_code)
|
||||
h->intra_pred_c[pred_mode_uv](h->cv, &h->top_border_v[h->mbx * 10],
|
||||
h->left_border_v, h->c_stride);
|
||||
|
||||
ret = decode_residual_chroma(h);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
decode_residual_chroma(h);
|
||||
ff_cavs_filter(h, I_8X8);
|
||||
set_mv_intra(h);
|
||||
return 0;
|
||||
@@ -1215,7 +1202,6 @@ static int cavs_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
|
||||
int input_size, ret;
|
||||
const uint8_t *buf_end;
|
||||
const uint8_t *buf_ptr;
|
||||
int frame_start = 0;
|
||||
|
||||
if (buf_size == 0) {
|
||||
if (!h->low_delay && h->DPB[0].f->data[0]) {
|
||||
@@ -1249,9 +1235,6 @@ static int cavs_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
|
||||
h->got_keyframe = 1;
|
||||
}
|
||||
case PIC_PB_START_CODE:
|
||||
if (frame_start > 1)
|
||||
return AVERROR_INVALIDDATA;
|
||||
frame_start ++;
|
||||
if (*got_frame)
|
||||
av_frame_unref(data);
|
||||
*got_frame = 0;
|
||||
|
||||
+24
-24
@@ -201,20 +201,20 @@ static void cavs_idct8_add_c(uint8_t *dst, int16_t *block, ptrdiff_t stride)
|
||||
src[0][0] += 8;
|
||||
|
||||
for( i = 0; i < 8; i++ ) {
|
||||
const int a0 = 3 * src[i][1] - 2 * src[i][7];
|
||||
const int a1 = 3 * src[i][3] + 2 * src[i][5];
|
||||
const int a2 = 2 * src[i][3] - 3 * src[i][5];
|
||||
const int a3 = 2 * src[i][1] + 3 * src[i][7];
|
||||
const int a0 = 3*src[i][1] - (src[i][7]<<1);
|
||||
const int a1 = 3*src[i][3] + (src[i][5]<<1);
|
||||
const int a2 = (src[i][3]<<1) - 3*src[i][5];
|
||||
const int a3 = (src[i][1]<<1) + 3*src[i][7];
|
||||
|
||||
const int b4 = 2 * (a0 + a1 + a3) + a1;
|
||||
const int b5 = 2 * (a0 - a1 + a2) + a0;
|
||||
const int b6 = 2 * (a3 - a2 - a1) + a3;
|
||||
const int b7 = 2 * (a0 - a2 - a3) - a2;
|
||||
const int b4 = ((a0 + a1 + a3)<<1) + a1;
|
||||
const int b5 = ((a0 - a1 + a2)<<1) + a0;
|
||||
const int b6 = ((a3 - a2 - a1)<<1) + a3;
|
||||
const int b7 = ((a0 - a2 - a3)<<1) - a2;
|
||||
|
||||
const int a7 = 4 * src[i][2] - 10 * src[i][6];
|
||||
const int a6 = 4 * src[i][6] + 10 * src[i][2];
|
||||
const int a5 = 8 * (src[i][0] - src[i][4]) + 4;
|
||||
const int a4 = 8 * (src[i][0] + src[i][4]) + 4;
|
||||
const int a7 = (src[i][2]<<2) - 10*src[i][6];
|
||||
const int a6 = (src[i][6]<<2) + 10*src[i][2];
|
||||
const int a5 = ((src[i][0] - src[i][4]) << 3) + 4;
|
||||
const int a4 = ((src[i][0] + src[i][4]) << 3) + 4;
|
||||
|
||||
const int b0 = a4 + a6;
|
||||
const int b1 = a5 + a7;
|
||||
@@ -231,20 +231,20 @@ static void cavs_idct8_add_c(uint8_t *dst, int16_t *block, ptrdiff_t stride)
|
||||
src[i][7] = (b0 - b4) >> 3;
|
||||
}
|
||||
for( i = 0; i < 8; i++ ) {
|
||||
const int a0 = 3 * src[1][i] - 2 * src[7][i];
|
||||
const int a1 = 3 * src[3][i] + 2 * src[5][i];
|
||||
const int a2 = 2 * src[3][i] - 3 * src[5][i];
|
||||
const int a3 = 2 * src[1][i] + 3 * src[7][i];
|
||||
const int a0 = 3*src[1][i] - (src[7][i]<<1);
|
||||
const int a1 = 3*src[3][i] + (src[5][i]<<1);
|
||||
const int a2 = (src[3][i]<<1) - 3*src[5][i];
|
||||
const int a3 = (src[1][i]<<1) + 3*src[7][i];
|
||||
|
||||
const int b4 = 2 * (a0 + a1 + a3) + a1;
|
||||
const int b5 = 2 * (a0 - a1 + a2) + a0;
|
||||
const int b6 = 2 * (a3 - a2 - a1) + a3;
|
||||
const int b7 = 2 * (a0 - a2 - a3) - a2;
|
||||
const int b4 = ((a0 + a1 + a3)<<1) + a1;
|
||||
const int b5 = ((a0 - a1 + a2)<<1) + a0;
|
||||
const int b6 = ((a3 - a2 - a1)<<1) + a3;
|
||||
const int b7 = ((a0 - a2 - a3)<<1) - a2;
|
||||
|
||||
const int a7 = 4 * src[2][i] - 10 * src[6][i];
|
||||
const int a6 = 4 * src[6][i] + 10 * src[2][i];
|
||||
const int a5 = 8 * (src[0][i] - src[4][i]);
|
||||
const int a4 = 8 * (src[0][i] + src[4][i]);
|
||||
const int a7 = (src[2][i]<<2) - 10*src[6][i];
|
||||
const int a6 = (src[6][i]<<2) + 10*src[2][i];
|
||||
const int a5 = (src[0][i] - src[4][i]) << 3;
|
||||
const int a4 = (src[0][i] + src[4][i]) << 3;
|
||||
|
||||
const int b0 = a4 + a6;
|
||||
const int b1 = a5 + a7;
|
||||
|
||||
+16
-11
@@ -479,10 +479,7 @@ static int cbs_h2645_fragment_add_nals(CodedBitstreamContext *ctx,
|
||||
// Remove trailing zeroes.
|
||||
while (size > 0 && nal->data[size - 1] == 0)
|
||||
--size;
|
||||
if (size == 0) {
|
||||
av_log(ctx->log_ctx, AV_LOG_VERBOSE, "Discarding empty 0 NAL unit\n");
|
||||
continue;
|
||||
}
|
||||
av_assert0(size > 0);
|
||||
|
||||
data = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
|
||||
if (!data)
|
||||
@@ -666,7 +663,7 @@ static int cbs_h26 ## h26n ## _replace_ ## ps_var(CodedBitstreamContext *ctx, \
|
||||
{ \
|
||||
CodedBitstreamH26 ## h26n ## Context *priv = ctx->priv_data; \
|
||||
unsigned int id = ps_var->id_element; \
|
||||
if (id >= FF_ARRAY_ELEMS(priv->ps_var)) { \
|
||||
if (id > FF_ARRAY_ELEMS(priv->ps_var)) { \
|
||||
av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid " #ps_name \
|
||||
" id : %d.\n", id); \
|
||||
return AVERROR_INVALIDDATA; \
|
||||
@@ -768,11 +765,15 @@ static int cbs_h264_read_nal_unit(CodedBitstreamContext *ctx,
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
if (!cbs_h2645_read_more_rbsp_data(&gbc))
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
pos = get_bits_count(&gbc);
|
||||
len = unit->data_size;
|
||||
if (!unit->data[len - 1]) {
|
||||
int z;
|
||||
for (z = 0; z < len && !unit->data[len - z - 1]; z++);
|
||||
av_log(ctx->log_ctx, AV_LOG_DEBUG, "Deleted %d trailing zeroes "
|
||||
"from slice data.\n", z);
|
||||
len -= z;
|
||||
}
|
||||
|
||||
slice->data_size = len - pos / 8;
|
||||
slice->data_ref = av_buffer_alloc(slice->data_size +
|
||||
@@ -934,11 +935,15 @@ static int cbs_h265_read_nal_unit(CodedBitstreamContext *ctx,
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
if (!cbs_h2645_read_more_rbsp_data(&gbc))
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
pos = get_bits_count(&gbc);
|
||||
len = unit->data_size;
|
||||
if (!unit->data[len - 1]) {
|
||||
int z;
|
||||
for (z = 0; z < len && !unit->data[len - z - 1]; z++);
|
||||
av_log(ctx->log_ctx, AV_LOG_DEBUG, "Deleted %d trailing zeroes "
|
||||
"from slice data.\n", z);
|
||||
len -= z;
|
||||
}
|
||||
|
||||
slice->data_size = len - pos / 8;
|
||||
slice->data_ref = av_buffer_alloc(slice->data_size +
|
||||
|
||||
@@ -539,12 +539,6 @@ static int FUNC(sei_pic_timestamp)(CodedBitstreamContext *ctx, RWContext *rw,
|
||||
}
|
||||
|
||||
sps = h264->active_sps;
|
||||
if (!sps) {
|
||||
av_log(ctx->log_ctx, AV_LOG_ERROR,
|
||||
"No active SPS for pic_timestamp.\n");
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
|
||||
if (sps->vui.nal_hrd_parameters_present_flag)
|
||||
time_offset_length = sps->vui.nal_hrd_parameters.time_offset_length;
|
||||
else if (sps->vui.vcl_hrd_parameters_present_flag)
|
||||
@@ -656,7 +650,7 @@ static int FUNC(sei_user_data_registered)(CodedBitstreamContext *ctx, RWContext
|
||||
*payload_size = i + current->data_length;
|
||||
#endif
|
||||
|
||||
allocate(current->data, current->data_length + AV_INPUT_BUFFER_PADDING_SIZE);
|
||||
allocate(current->data, current->data_length);
|
||||
for (j = 0; j < current->data_length; j++)
|
||||
xu(8, itu_t_t35_payload_byte, current->data[j], 0x00, 0xff);
|
||||
|
||||
@@ -1240,7 +1234,7 @@ static int FUNC(slice_header)(CodedBitstreamContext *ctx, RWContext *rw,
|
||||
(sps->pic_height_in_map_units_minus1 + 1);
|
||||
max = (pic_size + pps->slice_group_change_rate_minus1) /
|
||||
(pps->slice_group_change_rate_minus1 + 1);
|
||||
bits = av_ceil_log2(max + 1);
|
||||
bits = av_log2(2 * max - 1);
|
||||
|
||||
u(bits, slice_group_change_cycle, 0, max);
|
||||
}
|
||||
|
||||
@@ -80,7 +80,7 @@ static int FUNC(extension_data)(CodedBitstreamContext *ctx, RWContext *rw,
|
||||
}
|
||||
#else
|
||||
for (k = 0; k < current->bit_length; k++)
|
||||
xu(1, extension_data, current->data[k / 8] >> (7 - k % 8) & 1, 0, 1);
|
||||
xu(1, extension_data, current->data[k / 8] >> (7 - k % 8), 0, 1);
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
@@ -545,8 +545,6 @@ static int FUNC(st_ref_pic_set)(CodedBitstreamContext *ctx, RWContext *rw,
|
||||
}
|
||||
}
|
||||
|
||||
if (i > 15)
|
||||
return AVERROR_INVALIDDATA;
|
||||
infer(num_negative_pics, i);
|
||||
for (i = 0; i < current->num_negative_pics; i++) {
|
||||
infer(delta_poc_s0_minus1[i],
|
||||
@@ -576,8 +574,6 @@ static int FUNC(st_ref_pic_set)(CodedBitstreamContext *ctx, RWContext *rw,
|
||||
}
|
||||
}
|
||||
|
||||
if (i + current->num_negative_pics > 15)
|
||||
return AVERROR_INVALIDDATA;
|
||||
infer(num_positive_pics, i);
|
||||
for (i = 0; i < current->num_positive_pics; i++) {
|
||||
infer(delta_poc_s1_minus1[i],
|
||||
@@ -1313,7 +1309,7 @@ static int FUNC(slice_segment_header)(CodedBitstreamContext *ctx, RWContext *rw,
|
||||
infer(num_long_term_sps, 0);
|
||||
idx_size = 0;
|
||||
}
|
||||
ue(num_long_term_pics, 0, HEVC_MAX_REFS - current->num_long_term_sps);
|
||||
ue(num_long_term_pics, 0, HEVC_MAX_LONG_TERM_REF_PICS);
|
||||
|
||||
for (i = 0; i < current->num_long_term_sps +
|
||||
current->num_long_term_pics; i++) {
|
||||
|
||||
@@ -71,7 +71,7 @@ static int FUNC(user_data)(CodedBitstreamContext *ctx, RWContext *rw,
|
||||
av_assert0(k % 8 == 0);
|
||||
current->user_data_length = k /= 8;
|
||||
if (k > 0) {
|
||||
current->user_data_ref = av_buffer_allocz(k + AV_INPUT_BUFFER_PADDING_SIZE);
|
||||
current->user_data_ref = av_buffer_alloc(k);
|
||||
if (!current->user_data_ref)
|
||||
return AVERROR(ENOMEM);
|
||||
current->user_data = current->user_data_ref->data;
|
||||
|
||||
@@ -212,10 +212,10 @@ static const unsigned char pac2_attribs[32][3] = // Color, font, ident
|
||||
|
||||
struct Screen {
|
||||
/* +1 is used to compensate null character of string */
|
||||
uint8_t characters[SCREEN_ROWS+1][SCREEN_COLUMNS+1];
|
||||
uint8_t charsets[SCREEN_ROWS+1][SCREEN_COLUMNS+1];
|
||||
uint8_t colors[SCREEN_ROWS+1][SCREEN_COLUMNS+1];
|
||||
uint8_t fonts[SCREEN_ROWS+1][SCREEN_COLUMNS+1];
|
||||
uint8_t characters[SCREEN_ROWS][SCREEN_COLUMNS+1];
|
||||
uint8_t charsets[SCREEN_ROWS][SCREEN_COLUMNS+1];
|
||||
uint8_t colors[SCREEN_ROWS][SCREEN_COLUMNS+1];
|
||||
uint8_t fonts[SCREEN_ROWS][SCREEN_COLUMNS+1];
|
||||
/*
|
||||
* Bitmask of used rows; if a bit is not set, the
|
||||
* corresponding row is not used.
|
||||
|
||||
@@ -80,8 +80,11 @@ static av_cold int cdg_decode_init(AVCodecContext *avctx)
|
||||
return AVERROR(ENOMEM);
|
||||
cc->transparency = -1;
|
||||
|
||||
avctx->width = CDG_FULL_WIDTH;
|
||||
avctx->height = CDG_FULL_HEIGHT;
|
||||
avctx->pix_fmt = AV_PIX_FMT_PAL8;
|
||||
return ff_set_dimensions(avctx, CDG_FULL_WIDTH, CDG_FULL_HEIGHT);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void cdg_border_preset(CDGraphicsContext *cc, uint8_t *data)
|
||||
|
||||
+5
-29
@@ -315,11 +315,14 @@ static int cinepak_decode_strip (CinepakContext *s,
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
|
||||
static int cinepak_predecode_check (CinepakContext *s)
|
||||
static int cinepak_decode (CinepakContext *s)
|
||||
{
|
||||
int num_strips;
|
||||
const uint8_t *eod = (s->data + s->size);
|
||||
int i, result, strip_size, frame_flags, num_strips;
|
||||
int y0 = 0;
|
||||
int encoded_buf_size;
|
||||
|
||||
frame_flags = s->data[0];
|
||||
num_strips = AV_RB16 (&s->data[8]);
|
||||
encoded_buf_size = AV_RB24(&s->data[1]);
|
||||
|
||||
@@ -350,21 +353,6 @@ static int cinepak_predecode_check (CinepakContext *s)
|
||||
s->sega_film_skip_bytes = 0;
|
||||
}
|
||||
|
||||
if (s->size < 10 + s->sega_film_skip_bytes + num_strips * 12)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int cinepak_decode (CinepakContext *s)
|
||||
{
|
||||
const uint8_t *eod = (s->data + s->size);
|
||||
int i, result, strip_size, frame_flags, num_strips;
|
||||
int y0 = 0;
|
||||
|
||||
frame_flags = s->data[0];
|
||||
num_strips = AV_RB16 (&s->data[8]);
|
||||
|
||||
s->data += 10 + s->sega_film_skip_bytes;
|
||||
|
||||
num_strips = FFMIN(num_strips, MAX_STRIPS);
|
||||
@@ -444,7 +432,6 @@ static int cinepak_decode_frame(AVCodecContext *avctx,
|
||||
const uint8_t *buf = avpkt->data;
|
||||
int ret = 0, buf_size = avpkt->size;
|
||||
CinepakContext *s = avctx->priv_data;
|
||||
int num_strips;
|
||||
|
||||
s->data = buf;
|
||||
s->size = buf_size;
|
||||
@@ -452,17 +439,6 @@ static int cinepak_decode_frame(AVCodecContext *avctx,
|
||||
if (s->size < 10)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
num_strips = AV_RB16 (&s->data[8]);
|
||||
|
||||
//Empty frame, do not waste time
|
||||
if (!num_strips && (!s->palette_video || !av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL)))
|
||||
return buf_size;
|
||||
|
||||
if ((ret = cinepak_predecode_check(s)) < 0) {
|
||||
av_log(avctx, AV_LOG_ERROR, "cinepak_predecode_check failed\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
if ((ret = ff_reget_buffer(avctx, s->frame)) < 0)
|
||||
return ret;
|
||||
|
||||
|
||||
@@ -544,9 +544,8 @@ static int encode_mode(CinepakEncContext *s, int h,
|
||||
uint8_t *last_data[4], int last_linesize[4],
|
||||
strip_info *info, unsigned char *buf)
|
||||
{
|
||||
int x, y, z, bits, temp_size, header_ofs, ret = 0, mb_count = s->w * h / MB_AREA;
|
||||
int x, y, z, flags, bits, temp_size, header_ofs, ret = 0, mb_count = s->w * h / MB_AREA;
|
||||
int needs_extra_bit, should_write_temp;
|
||||
uint32_t flags;
|
||||
unsigned char temp[64]; // 32/2 = 16 V4 blocks at 4 B each -> 64 B
|
||||
mb_info *mb;
|
||||
uint8_t *sub_scratch_data[4] = { 0 }, *sub_last_data[4] = { 0 };
|
||||
@@ -600,7 +599,7 @@ static int encode_mode(CinepakEncContext *s, int h,
|
||||
flags = 0;
|
||||
for (y = x; y < FFMIN(x + 32, mb_count); y++)
|
||||
if (s->mb[y].best_encoding == ENC_V4)
|
||||
flags |= 1U << (31 - y + x);
|
||||
flags |= 1 << (31 - y + x);
|
||||
|
||||
AV_WB32(&buf[ret], flags);
|
||||
ret += 4;
|
||||
@@ -627,13 +626,13 @@ static int encode_mode(CinepakEncContext *s, int h,
|
||||
|
||||
for (x = 0; x < mb_count; x++) {
|
||||
mb = &s->mb[x];
|
||||
flags |= (uint32_t)(mb->best_encoding != ENC_SKIP) << (31 - bits++);
|
||||
flags |= (mb->best_encoding != ENC_SKIP) << (31 - bits++);
|
||||
needs_extra_bit = 0;
|
||||
should_write_temp = 0;
|
||||
|
||||
if (mb->best_encoding != ENC_SKIP) {
|
||||
if (bits < 32)
|
||||
flags |= (uint32_t)(mb->best_encoding == ENC_V4) << (31 - bits++);
|
||||
flags |= (mb->best_encoding == ENC_V4) << (31 - bits++);
|
||||
else
|
||||
needs_extra_bit = 1;
|
||||
}
|
||||
@@ -652,7 +651,7 @@ static int encode_mode(CinepakEncContext *s, int h,
|
||||
}
|
||||
|
||||
if (needs_extra_bit) {
|
||||
flags = (uint32_t)(mb->best_encoding == ENC_V4) << 31;
|
||||
flags = (mb->best_encoding == ENC_V4) << 31;
|
||||
bits = 1;
|
||||
}
|
||||
|
||||
|
||||
@@ -558,9 +558,6 @@ static int clv_decode_frame(AVCodecContext *avctx, void *data,
|
||||
} else {
|
||||
int plane;
|
||||
|
||||
if (c->pmb_width * c->pmb_height > 8LL*(buf_size - bytestream2_tell(&gb)))
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
if ((ret = ff_reget_buffer(avctx, c->pic)) < 0)
|
||||
return ret;
|
||||
|
||||
@@ -576,8 +573,6 @@ static int clv_decode_frame(AVCodecContext *avctx, void *data,
|
||||
|
||||
for (j = 0; j < c->pmb_height; j++) {
|
||||
for (i = 0; i < c->pmb_width; i++) {
|
||||
if (get_bits_left(&c->gb) <= 0)
|
||||
return AVERROR_INVALIDDATA;
|
||||
if (get_bits1(&c->gb)) {
|
||||
MV mv = mvi_predict(&c->mvi, i, j, zero_mv);
|
||||
|
||||
@@ -665,7 +660,7 @@ static av_cold int clv_decode_init(AVCodecContext *avctx)
|
||||
}
|
||||
|
||||
c->tile_shift = av_log2(c->tile_size);
|
||||
if (1U << c->tile_shift != c->tile_size) {
|
||||
if (1 << c->tile_shift != c->tile_size) {
|
||||
av_log(avctx, AV_LOG_ERROR, "Tile size: %d, is not power of 2.\n", c->tile_size);
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
|
||||
+1
-1
@@ -174,5 +174,5 @@ AVCodec ff_comfortnoise_decoder = {
|
||||
.close = cng_decode_close,
|
||||
.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
|
||||
AV_SAMPLE_FMT_NONE },
|
||||
.capabilities = AV_CODEC_CAP_DR1,
|
||||
.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_DR1,
|
||||
};
|
||||
|
||||
+17
-17
@@ -143,7 +143,7 @@ typedef struct cook {
|
||||
|
||||
/* generate tables and related variables */
|
||||
int gain_size_factor;
|
||||
float gain_table[31];
|
||||
float gain_table[23];
|
||||
|
||||
/* data buffers */
|
||||
|
||||
@@ -185,8 +185,8 @@ static av_cold void init_gain_table(COOKContext *q)
|
||||
{
|
||||
int i;
|
||||
q->gain_size_factor = q->samples_per_channel / 8;
|
||||
for (i = 0; i < 31; i++)
|
||||
q->gain_table[i] = pow(pow2tab[i + 48],
|
||||
for (i = 0; i < 23; i++)
|
||||
q->gain_table[i] = pow(pow2tab[i + 52],
|
||||
(1.0 / (double) q->gain_size_factor));
|
||||
}
|
||||
|
||||
@@ -670,7 +670,7 @@ static void interpolate_float(COOKContext *q, float *buffer,
|
||||
for (i = 0; i < q->gain_size_factor; i++)
|
||||
buffer[i] *= fc1;
|
||||
} else { // smooth gain
|
||||
fc2 = q->gain_table[15 + (gain_index_next - gain_index)];
|
||||
fc2 = q->gain_table[11 + (gain_index_next - gain_index)];
|
||||
for (i = 0; i < q->gain_size_factor; i++) {
|
||||
buffer[i] *= fc1;
|
||||
fc1 *= fc2;
|
||||
@@ -759,7 +759,7 @@ static int decouple_info(COOKContext *q, COOKSubpacket *p, int *decouple_tab)
|
||||
for (i = 0; i < length; i++)
|
||||
decouple_tab[start + i] = get_vlc2(&q->gb,
|
||||
p->channel_coupling.table,
|
||||
p->channel_coupling.bits, 3);
|
||||
p->channel_coupling.bits, 2);
|
||||
else
|
||||
for (i = 0; i < length; i++) {
|
||||
int v = get_bits(&q->gb, p->js_vlc_bits);
|
||||
@@ -1075,9 +1075,6 @@ static av_cold int cook_decode_init(AVCodecContext *avctx)
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
|
||||
if (avctx->block_align >= INT_MAX / 8)
|
||||
return AVERROR(EINVAL);
|
||||
|
||||
/* Initialize RNG. */
|
||||
av_lfg_init(&q->random_state, 0);
|
||||
|
||||
@@ -1220,15 +1217,6 @@ static av_cold int cook_decode_init(AVCodecContext *avctx)
|
||||
return AVERROR_PATCHWELCOME;
|
||||
}
|
||||
}
|
||||
|
||||
/* Try to catch some obviously faulty streams, otherwise it might be exploitable */
|
||||
if (q->samples_per_channel != 256 && q->samples_per_channel != 512 &&
|
||||
q->samples_per_channel != 1024) {
|
||||
avpriv_request_sample(avctx, "samples_per_channel = %d",
|
||||
q->samples_per_channel);
|
||||
return AVERROR_PATCHWELCOME;
|
||||
}
|
||||
|
||||
/* Generate tables */
|
||||
init_pow2table();
|
||||
init_gain_table(q);
|
||||
@@ -1237,6 +1225,10 @@ static av_cold int cook_decode_init(AVCodecContext *avctx)
|
||||
if ((ret = init_cook_vlc_tables(q)))
|
||||
return ret;
|
||||
|
||||
|
||||
if (avctx->block_align >= UINT_MAX / 2)
|
||||
return AVERROR(EINVAL);
|
||||
|
||||
/* Pad the databuffer with:
|
||||
DECODE_BYTES_PAD1 or DECODE_BYTES_PAD2 for decode_bytes(),
|
||||
AV_INPUT_BUFFER_PADDING_SIZE, for the bitstreamreader. */
|
||||
@@ -1260,6 +1252,14 @@ static av_cold int cook_decode_init(AVCodecContext *avctx)
|
||||
q->saturate_output = saturate_output_float;
|
||||
}
|
||||
|
||||
/* Try to catch some obviously faulty streams, otherwise it might be exploitable */
|
||||
if (q->samples_per_channel != 256 && q->samples_per_channel != 512 &&
|
||||
q->samples_per_channel != 1024) {
|
||||
avpriv_request_sample(avctx, "samples_per_channel = %d",
|
||||
q->samples_per_channel);
|
||||
return AVERROR_PATCHWELCOME;
|
||||
}
|
||||
|
||||
avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
|
||||
if (channel_mask)
|
||||
avctx->channel_layout = channel_mask;
|
||||
|
||||
+1
-1
@@ -63,7 +63,7 @@ static int cpia_decode_frame(AVCodecContext *avctx,
|
||||
uint8_t *y, *u, *v, *y_end, *u_end, *v_end;
|
||||
|
||||
// Check header
|
||||
if ( avpkt->size < FRAME_HEADER_SIZE + avctx->height * 3
|
||||
if ( avpkt->size < FRAME_HEADER_SIZE
|
||||
|| header[0] != MAGIC_0 || header[1] != MAGIC_1
|
||||
|| (header[17] != SUBSAMPLE_420 && header[17] != SUBSAMPLE_422)
|
||||
|| (header[18] != YUVORDER_YUYV && header[18] != YUVORDER_UYVY)
|
||||
|
||||
+1
-1
@@ -81,7 +81,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
|
||||
switch ((buf[0] >> 1) & 7) {
|
||||
case 0: { // lzo compression
|
||||
int outlen = c->decomp_size, inlen = buf_size - 2;
|
||||
if (av_lzo1x_decode(c->decomp_buf, &outlen, &buf[2], &inlen) || outlen) {
|
||||
if (av_lzo1x_decode(c->decomp_buf, &outlen, &buf[2], &inlen)) {
|
||||
av_log(avctx, AV_LOG_ERROR, "error during lzo decompression\n");
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
|
||||
+18
-37
@@ -70,7 +70,6 @@ typedef struct CuvidContext
|
||||
int deint_mode;
|
||||
int deint_mode_current;
|
||||
int64_t prev_pts;
|
||||
int progressive_sequence;
|
||||
|
||||
int internal_error;
|
||||
int decoder_flushing;
|
||||
@@ -83,7 +82,7 @@ typedef struct CuvidContext
|
||||
CUVIDDECODECAPS caps8, caps10, caps12;
|
||||
|
||||
CUVIDPARSERPARAMS cuparseinfo;
|
||||
CUVIDEOFORMATEX *cuparse_ext;
|
||||
CUVIDEOFORMATEX cuparse_ext;
|
||||
|
||||
CudaFunctions *cudl;
|
||||
CuvidFunctions *cvdl;
|
||||
@@ -229,8 +228,6 @@ static int CUDAAPI cuvid_handle_video_sequence(void *opaque, CUVIDEOFORMAT* form
|
||||
? cudaVideoDeinterlaceMode_Weave
|
||||
: ctx->deint_mode;
|
||||
|
||||
ctx->progressive_sequence = format->progressive_sequence;
|
||||
|
||||
if (!format->progressive_sequence && ctx->deint_mode_current == cudaVideoDeinterlaceMode_Weave)
|
||||
avctx->flags |= AV_CODEC_FLAG_INTERLACED_DCT;
|
||||
else
|
||||
@@ -363,9 +360,6 @@ static int CUDAAPI cuvid_handle_picture_display(void *opaque, CUVIDPARSERDISPINF
|
||||
parsed_frame.dispinfo = *dispinfo;
|
||||
ctx->internal_error = 0;
|
||||
|
||||
// For some reason, dispinfo->progressive_frame is sometimes wrong.
|
||||
parsed_frame.dispinfo.progressive_frame = ctx->progressive_sequence;
|
||||
|
||||
if (ctx->deint_mode_current == cudaVideoDeinterlaceMode_Weave) {
|
||||
av_fifo_generic_write(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
|
||||
} else {
|
||||
@@ -384,11 +378,7 @@ static int cuvid_is_buffer_full(AVCodecContext *avctx)
|
||||
{
|
||||
CuvidContext *ctx = avctx->priv_data;
|
||||
|
||||
int delay = ctx->cuparseinfo.ulMaxDisplayDelay;
|
||||
if (ctx->deint_mode != cudaVideoDeinterlaceMode_Weave && !ctx->drop_second_field)
|
||||
delay *= 2;
|
||||
|
||||
return (av_fifo_size(ctx->frame_queue) / sizeof(CuvidParsedFrame)) + delay >= ctx->nb_surfaces;
|
||||
return (av_fifo_size(ctx->frame_queue) / sizeof(CuvidParsedFrame)) + 2 > ctx->nb_surfaces;
|
||||
}
|
||||
|
||||
static int cuvid_decode_packet(AVCodecContext *avctx, const AVPacket *avpkt)
|
||||
@@ -709,7 +699,6 @@ static av_cold int cuvid_decode_end(AVCodecContext *avctx)
|
||||
av_buffer_unref(&ctx->hwdevice);
|
||||
|
||||
av_freep(&ctx->key_frame);
|
||||
av_freep(&ctx->cuparse_ext);
|
||||
|
||||
cuvid_free_functions(&ctx->cvdl);
|
||||
|
||||
@@ -814,8 +803,6 @@ static av_cold int cuvid_decode_init(AVCodecContext *avctx)
|
||||
CUcontext cuda_ctx = NULL;
|
||||
CUcontext dummy;
|
||||
const AVBitStreamFilter *bsf;
|
||||
uint8_t *extradata;
|
||||
int extradata_size;
|
||||
int ret = 0;
|
||||
|
||||
enum AVPixelFormat pix_fmts[3] = { AV_PIX_FMT_CUDA,
|
||||
@@ -912,8 +899,11 @@ static av_cold int cuvid_decode_init(AVCodecContext *avctx)
|
||||
ctx->cudl = device_hwctx->internal->cuda_dl;
|
||||
|
||||
memset(&ctx->cuparseinfo, 0, sizeof(ctx->cuparseinfo));
|
||||
memset(&ctx->cuparse_ext, 0, sizeof(ctx->cuparse_ext));
|
||||
memset(&seq_pkt, 0, sizeof(seq_pkt));
|
||||
|
||||
ctx->cuparseinfo.pExtVideoInfo = &ctx->cuparse_ext;
|
||||
|
||||
switch (avctx->codec->id) {
|
||||
#if CONFIG_H264_CUVID_DECODER
|
||||
case AV_CODEC_ID_H264:
|
||||
@@ -983,26 +973,17 @@ static av_cold int cuvid_decode_init(AVCodecContext *avctx)
|
||||
goto error;
|
||||
}
|
||||
|
||||
extradata = ctx->bsf->par_out->extradata;
|
||||
extradata_size = ctx->bsf->par_out->extradata_size;
|
||||
} else {
|
||||
extradata = avctx->extradata;
|
||||
extradata_size = avctx->extradata_size;
|
||||
ctx->cuparse_ext.format.seqhdr_data_length = ctx->bsf->par_out->extradata_size;
|
||||
memcpy(ctx->cuparse_ext.raw_seqhdr_data,
|
||||
ctx->bsf->par_out->extradata,
|
||||
FFMIN(sizeof(ctx->cuparse_ext.raw_seqhdr_data), ctx->bsf->par_out->extradata_size));
|
||||
} else if (avctx->extradata_size > 0) {
|
||||
ctx->cuparse_ext.format.seqhdr_data_length = avctx->extradata_size;
|
||||
memcpy(ctx->cuparse_ext.raw_seqhdr_data,
|
||||
avctx->extradata,
|
||||
FFMIN(sizeof(ctx->cuparse_ext.raw_seqhdr_data), avctx->extradata_size));
|
||||
}
|
||||
|
||||
ctx->cuparse_ext = av_mallocz(sizeof(*ctx->cuparse_ext)
|
||||
+ FFMAX(extradata_size - (int)sizeof(ctx->cuparse_ext->raw_seqhdr_data), 0));
|
||||
if (!ctx->cuparse_ext) {
|
||||
ret = AVERROR(ENOMEM);
|
||||
goto error;
|
||||
}
|
||||
|
||||
if (extradata_size > 0)
|
||||
memcpy(ctx->cuparse_ext->raw_seqhdr_data, extradata, extradata_size);
|
||||
ctx->cuparse_ext->format.seqhdr_data_length = extradata_size;
|
||||
|
||||
ctx->cuparseinfo.pExtVideoInfo = ctx->cuparse_ext;
|
||||
|
||||
ctx->key_frame = av_mallocz(ctx->nb_surfaces * sizeof(int));
|
||||
if (!ctx->key_frame) {
|
||||
ret = AVERROR(ENOMEM);
|
||||
@@ -1031,8 +1012,8 @@ static av_cold int cuvid_decode_init(AVCodecContext *avctx)
|
||||
if (ret < 0)
|
||||
goto error;
|
||||
|
||||
seq_pkt.payload = ctx->cuparse_ext->raw_seqhdr_data;
|
||||
seq_pkt.payload_size = ctx->cuparse_ext->format.seqhdr_data_length;
|
||||
seq_pkt.payload = ctx->cuparse_ext.raw_seqhdr_data;
|
||||
seq_pkt.payload_size = ctx->cuparse_ext.format.seqhdr_data_length;
|
||||
|
||||
if (seq_pkt.payload && seq_pkt.payload_size) {
|
||||
ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &seq_pkt));
|
||||
@@ -1091,8 +1072,8 @@ static void cuvid_flush(AVCodecContext *avctx)
|
||||
if (ret < 0)
|
||||
goto error;
|
||||
|
||||
seq_pkt.payload = ctx->cuparse_ext->raw_seqhdr_data;
|
||||
seq_pkt.payload_size = ctx->cuparse_ext->format.seqhdr_data_length;
|
||||
seq_pkt.payload = ctx->cuparse_ext.raw_seqhdr_data;
|
||||
seq_pkt.payload_size = ctx->cuparse_ext.format.seqhdr_data_length;
|
||||
|
||||
if (seq_pkt.payload && seq_pkt.payload_size) {
|
||||
ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &seq_pkt));
|
||||
|
||||
+69
-93
@@ -154,7 +154,7 @@ static int parse_lfe_24(DCALbrDecoder *s)
|
||||
step_i = get_bits(&s->gb, 8);
|
||||
if (step_i > step_max) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE step size index\n");
|
||||
return AVERROR_INVALIDDATA;
|
||||
return -1;
|
||||
}
|
||||
|
||||
step = ff_dca_lfe_step_size_24[step_i];
|
||||
@@ -208,7 +208,7 @@ static int parse_lfe_16(DCALbrDecoder *s)
|
||||
step_i = get_bits(&s->gb, 8);
|
||||
if (step_i > step_max) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE step size index\n");
|
||||
return AVERROR_INVALIDDATA;
|
||||
return -1;
|
||||
}
|
||||
|
||||
step = ff_dca_lfe_step_size_16[step_i];
|
||||
@@ -246,17 +246,14 @@ static int parse_lfe_16(DCALbrDecoder *s)
|
||||
|
||||
static int parse_lfe_chunk(DCALbrDecoder *s, LBRChunk *chunk)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (!(s->flags & LBR_FLAG_LFE_PRESENT))
|
||||
return 0;
|
||||
|
||||
if (!chunk->len)
|
||||
return 0;
|
||||
|
||||
ret = init_get_bits8(&s->gb, chunk->data, chunk->len);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
if (init_get_bits8(&s->gb, chunk->data, chunk->len) < 0)
|
||||
return -1;
|
||||
|
||||
// Determine bit depth from chunk size
|
||||
if (chunk->len >= 52)
|
||||
@@ -265,7 +262,7 @@ static int parse_lfe_chunk(DCALbrDecoder *s, LBRChunk *chunk)
|
||||
return parse_lfe_16(s);
|
||||
|
||||
av_log(s->avctx, AV_LOG_ERROR, "LFE chunk too short\n");
|
||||
return AVERROR_INVALIDDATA;
|
||||
return -1;
|
||||
}
|
||||
|
||||
static inline int parse_vlc(GetBitContext *s, VLC *vlc, int max_depth)
|
||||
@@ -294,13 +291,13 @@ static int parse_tonal(DCALbrDecoder *s, int group)
|
||||
for (freq = 1;; freq++) {
|
||||
if (get_bits_left(&s->gb) < 1) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "Tonal group chunk too short\n");
|
||||
return AVERROR_INVALIDDATA;
|
||||
return -1;
|
||||
}
|
||||
|
||||
diff = parse_vlc(&s->gb, &ff_dca_vlc_tnl_grp[group], 2);
|
||||
if (diff >= FF_ARRAY_ELEMS(ff_dca_fst_amp)) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "Invalid tonal frequency diff\n");
|
||||
return AVERROR_INVALIDDATA;
|
||||
return -1;
|
||||
}
|
||||
|
||||
diff = get_bitsz(&s->gb, diff >> 2) + ff_dca_fst_amp[diff];
|
||||
@@ -310,7 +307,7 @@ static int parse_tonal(DCALbrDecoder *s, int group)
|
||||
freq += diff - 2;
|
||||
if (freq >> (5 - group) > s->nsubbands * 4 - 6) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "Invalid spectral line offset\n");
|
||||
return AVERROR_INVALIDDATA;
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Main channel
|
||||
@@ -361,21 +358,19 @@ static int parse_tonal(DCALbrDecoder *s, int group)
|
||||
|
||||
static int parse_tonal_chunk(DCALbrDecoder *s, LBRChunk *chunk)
|
||||
{
|
||||
int sb, group, ret;
|
||||
int sb, group;
|
||||
|
||||
if (!chunk->len)
|
||||
return 0;
|
||||
|
||||
ret = init_get_bits8(&s->gb, chunk->data, chunk->len);
|
||||
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
if (init_get_bits8(&s->gb, chunk->data, chunk->len) < 0)
|
||||
return -1;
|
||||
|
||||
// Scale factors
|
||||
if (chunk->id == LBR_CHUNK_SCF || chunk->id == LBR_CHUNK_TONAL_SCF) {
|
||||
if (get_bits_left(&s->gb) < 36) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "Tonal scale factor chunk too short\n");
|
||||
return AVERROR_INVALIDDATA;
|
||||
return -1;
|
||||
}
|
||||
for (sb = 0; sb < 6; sb++)
|
||||
s->tonal_scf[sb] = get_bits(&s->gb, 6);
|
||||
@@ -383,25 +378,20 @@ static int parse_tonal_chunk(DCALbrDecoder *s, LBRChunk *chunk)
|
||||
|
||||
// Tonal groups
|
||||
if (chunk->id == LBR_CHUNK_TONAL || chunk->id == LBR_CHUNK_TONAL_SCF)
|
||||
for (group = 0; group < 5; group++) {
|
||||
ret = parse_tonal(s, group);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
}
|
||||
for (group = 0; group < 5; group++)
|
||||
if (parse_tonal(s, group) < 0)
|
||||
return -1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int parse_tonal_group(DCALbrDecoder *s, LBRChunk *chunk)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (!chunk->len)
|
||||
return 0;
|
||||
|
||||
ret = init_get_bits8(&s->gb, chunk->data, chunk->len);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
if (init_get_bits8(&s->gb, chunk->data, chunk->len) < 0)
|
||||
return -1;
|
||||
|
||||
return parse_tonal(s, chunk->id);
|
||||
}
|
||||
@@ -414,7 +404,7 @@ static int ensure_bits(GetBitContext *s, int n)
|
||||
{
|
||||
int left = get_bits_left(s);
|
||||
if (left < 0)
|
||||
return AVERROR_INVALIDDATA;
|
||||
return -1;
|
||||
if (left < n) {
|
||||
skip_bits_long(s, left);
|
||||
return 1;
|
||||
@@ -443,7 +433,7 @@ static int parse_scale_factors(DCALbrDecoder *s, uint8_t *scf)
|
||||
dist = parse_vlc(&s->gb, &ff_dca_vlc_rsd_apprx, 1) + 1;
|
||||
if (dist > 7 - sf) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "Invalid scale factor distance\n");
|
||||
return AVERROR_INVALIDDATA;
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (ensure_bits(&s->gb, 20))
|
||||
@@ -508,26 +498,22 @@ static int parse_st_code(GetBitContext *s, int min_v)
|
||||
|
||||
static int parse_grid_1_chunk(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
|
||||
{
|
||||
int ch, sb, sf, nsubbands, ret;
|
||||
int ch, sb, sf, nsubbands;
|
||||
|
||||
if (!chunk->len)
|
||||
return 0;
|
||||
|
||||
ret = init_get_bits8(&s->gb, chunk->data, chunk->len);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
if (init_get_bits8(&s->gb, chunk->data, chunk->len) < 0)
|
||||
return -1;
|
||||
|
||||
// Scale factors
|
||||
nsubbands = ff_dca_scf_to_grid_1[s->nsubbands - 1] + 1;
|
||||
for (sb = 2; sb < nsubbands; sb++) {
|
||||
ret = parse_scale_factors(s, s->grid_1_scf[ch1][sb]);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
if (ch1 != ch2 && ff_dca_grid_1_to_scf[sb] < s->min_mono_subband) {
|
||||
ret = parse_scale_factors(s, s->grid_1_scf[ch2][sb]);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
}
|
||||
if (parse_scale_factors(s, s->grid_1_scf[ch1][sb]) < 0)
|
||||
return -1;
|
||||
if (ch1 != ch2 && ff_dca_grid_1_to_scf[sb] < s->min_mono_subband
|
||||
&& parse_scale_factors(s, s->grid_1_scf[ch2][sb]) < 0)
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (get_bits_left(&s->gb) < 1)
|
||||
@@ -546,7 +532,7 @@ static int parse_grid_1_chunk(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch
|
||||
|
||||
if (get_bits_left(&s->gb) < 0) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "First grid chunk too short\n");
|
||||
return AVERROR_INVALIDDATA;
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Stereo image for partial mono mode
|
||||
@@ -576,16 +562,14 @@ static int parse_grid_1_chunk(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch
|
||||
|
||||
static int parse_grid_1_sec_ch(DCALbrDecoder *s, int ch2)
|
||||
{
|
||||
int sb, nsubbands, ret;
|
||||
int sb, nsubbands;
|
||||
|
||||
// Scale factors
|
||||
nsubbands = ff_dca_scf_to_grid_1[s->nsubbands - 1] + 1;
|
||||
for (sb = 2; sb < nsubbands; sb++) {
|
||||
if (ff_dca_grid_1_to_scf[sb] >= s->min_mono_subband) {
|
||||
ret = parse_scale_factors(s, s->grid_1_scf[ch2][sb]);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
}
|
||||
if (ff_dca_grid_1_to_scf[sb] >= s->min_mono_subband
|
||||
&& parse_scale_factors(s, s->grid_1_scf[ch2][sb]) < 0)
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Average values for third grid
|
||||
@@ -725,7 +709,7 @@ static int parse_ts(DCALbrDecoder *s, int ch1, int ch2,
|
||||
s->sb_indices[sb] = sb_reorder;
|
||||
}
|
||||
if (sb_reorder >= s->nsubbands)
|
||||
return AVERROR_INVALIDDATA;
|
||||
return -1;
|
||||
|
||||
// Third grid scale factors
|
||||
if (sb == 12) {
|
||||
@@ -747,7 +731,7 @@ static int parse_ts(DCALbrDecoder *s, int ch1, int ch2,
|
||||
|
||||
quant_level = s->quant_levels[ch1 / 2][sb];
|
||||
if (!quant_level)
|
||||
return AVERROR_INVALIDDATA;
|
||||
return -1;
|
||||
|
||||
// Time samples for one or both channels
|
||||
if (sb < s->max_mono_subband && sb_reorder >= s->min_mono_subband) {
|
||||
@@ -808,14 +792,13 @@ static int parse_lpc(DCALbrDecoder *s, int ch1, int ch2, int start_sb, int end_s
|
||||
static int parse_high_res_grid(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
|
||||
{
|
||||
int quant_levels[DCA_LBR_SUBBANDS];
|
||||
int sb, ch, ol, st, max_sb, profile, ret;
|
||||
int sb, ch, ol, st, max_sb, profile;
|
||||
|
||||
if (!chunk->len)
|
||||
return 0;
|
||||
|
||||
ret = init_get_bits8(&s->gb, chunk->data, chunk->len);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
if (init_get_bits8(&s->gb, chunk->data, chunk->len) < 0)
|
||||
return -1;
|
||||
|
||||
// Quantizer profile
|
||||
profile = get_bits(&s->gb, 8);
|
||||
@@ -849,20 +832,18 @@ static int parse_high_res_grid(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int c
|
||||
s->quant_levels[ch1 / 2][sb] = quant_levels[sb];
|
||||
|
||||
// LPC for the first two subbands
|
||||
ret = parse_lpc(s, ch1, ch2, 0, 2);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
if (parse_lpc(s, ch1, ch2, 0, 2) < 0)
|
||||
return -1;
|
||||
|
||||
// Time-samples for the first two subbands of main channel
|
||||
ret = parse_ts(s, ch1, ch2, 0, 2, 0);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
if (parse_ts(s, ch1, ch2, 0, 2, 0) < 0)
|
||||
return -1;
|
||||
|
||||
// First two bands of the first grid
|
||||
for (sb = 0; sb < 2; sb++)
|
||||
for (ch = ch1; ch <= ch2; ch++)
|
||||
if ((ret = parse_scale_factors(s, s->grid_1_scf[ch][sb])) < 0)
|
||||
return ret;
|
||||
if (parse_scale_factors(s, s->grid_1_scf[ch][sb]) < 0)
|
||||
return -1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -911,42 +892,39 @@ static int parse_grid_2(DCALbrDecoder *s, int ch1, int ch2,
|
||||
|
||||
static int parse_ts1_chunk(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
|
||||
{
|
||||
int ret;
|
||||
if (!chunk->len)
|
||||
return 0;
|
||||
if ((ret = init_get_bits8(&s->gb, chunk->data, chunk->len)) < 0)
|
||||
return ret;
|
||||
if ((ret = parse_lpc(s, ch1, ch2, 2, 3)) < 0)
|
||||
return ret;
|
||||
if ((ret = parse_ts(s, ch1, ch2, 2, 4, 0)) < 0)
|
||||
return ret;
|
||||
if ((ret = parse_grid_2(s, ch1, ch2, 0, 1, 0)) < 0)
|
||||
return ret;
|
||||
if ((ret = parse_ts(s, ch1, ch2, 4, 6, 0)) < 0)
|
||||
return ret;
|
||||
if (init_get_bits8(&s->gb, chunk->data, chunk->len) < 0)
|
||||
return -1;
|
||||
if (parse_lpc(s, ch1, ch2, 2, 3) < 0)
|
||||
return -1;
|
||||
if (parse_ts(s, ch1, ch2, 2, 4, 0) < 0)
|
||||
return -1;
|
||||
if (parse_grid_2(s, ch1, ch2, 0, 1, 0) < 0)
|
||||
return -1;
|
||||
if (parse_ts(s, ch1, ch2, 4, 6, 0) < 0)
|
||||
return -1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int parse_ts2_chunk(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (!chunk->len)
|
||||
return 0;
|
||||
if ((ret = init_get_bits8(&s->gb, chunk->data, chunk->len)) < 0)
|
||||
return ret;
|
||||
if ((ret = parse_grid_2(s, ch1, ch2, 1, 3, 0)) < 0)
|
||||
return ret;
|
||||
if ((ret = parse_ts(s, ch1, ch2, 6, s->max_mono_subband, 0)) < 0)
|
||||
return ret;
|
||||
if (init_get_bits8(&s->gb, chunk->data, chunk->len) < 0)
|
||||
return -1;
|
||||
if (parse_grid_2(s, ch1, ch2, 1, 3, 0) < 0)
|
||||
return -1;
|
||||
if (parse_ts(s, ch1, ch2, 6, s->max_mono_subband, 0) < 0)
|
||||
return -1;
|
||||
if (ch1 != ch2) {
|
||||
if ((ret = parse_grid_1_sec_ch(s, ch2)) < 0)
|
||||
return ret;
|
||||
if ((ret = parse_grid_2(s, ch1, ch2, 0, 3, 1)) < 0)
|
||||
return ret;
|
||||
if (parse_grid_1_sec_ch(s, ch2) < 0)
|
||||
return -1;
|
||||
if (parse_grid_2(s, ch1, ch2, 0, 3, 1) < 0)
|
||||
return -1;
|
||||
}
|
||||
if ((ret = parse_ts(s, ch1, ch2, s->min_mono_subband, s->nsubbands, 1)) < 0)
|
||||
return ret;
|
||||
if (parse_ts(s, ch1, ch2, s->min_mono_subband, s->nsubbands, 1) < 0)
|
||||
return -1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -954,13 +932,11 @@ static int init_sample_rate(DCALbrDecoder *s)
|
||||
{
|
||||
double scale = (-1.0 / (1 << 17)) * sqrt(1 << (2 - s->limited_range));
|
||||
int i, br_per_ch = s->bit_rate_scaled / s->nchannels_total;
|
||||
int ret;
|
||||
|
||||
ff_mdct_end(&s->imdct);
|
||||
|
||||
ret = ff_mdct_init(&s->imdct, s->freq_range + 6, 1, scale);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
if (ff_mdct_init(&s->imdct, s->freq_range + 6, 1, scale) < 0)
|
||||
return -1;
|
||||
|
||||
for (i = 0; i < 32 << s->freq_range; i++)
|
||||
s->window[i] = ff_dca_long_window[i << (2 - s->freq_range)];
|
||||
@@ -999,7 +975,7 @@ static int alloc_sample_buffer(DCALbrDecoder *s)
|
||||
// Reallocate time sample buffer
|
||||
av_fast_mallocz(&s->ts_buffer, &s->ts_size, nsamples * sizeof(float));
|
||||
if (!s->ts_buffer)
|
||||
return AVERROR(ENOMEM);
|
||||
return -1;
|
||||
|
||||
ptr = s->ts_buffer + DCA_LBR_TIME_HISTORY;
|
||||
for (ch = 0; ch < s->nchannels; ch++) {
|
||||
@@ -1820,7 +1796,7 @@ av_cold int ff_dca_lbr_init(DCALbrDecoder *s)
|
||||
init_tables();
|
||||
|
||||
if (!(s->fdsp = avpriv_float_dsp_alloc(0)))
|
||||
return AVERROR(ENOMEM);
|
||||
return -1;
|
||||
|
||||
s->lbr_rand = 1;
|
||||
return 0;
|
||||
|
||||
+3
-4
@@ -613,7 +613,6 @@ static int dds_decode(AVCodecContext *avctx, void *data,
|
||||
AVFrame *frame = data;
|
||||
int mipmap;
|
||||
int ret;
|
||||
int width, height;
|
||||
|
||||
ff_texturedsp_init(&ctx->texdsp);
|
||||
bytestream2_init(gbc, avpkt->data, avpkt->size);
|
||||
@@ -632,9 +631,9 @@ static int dds_decode(AVCodecContext *avctx, void *data,
|
||||
|
||||
bytestream2_skip(gbc, 4); // flags
|
||||
|
||||
height = bytestream2_get_le32(gbc);
|
||||
width = bytestream2_get_le32(gbc);
|
||||
ret = ff_set_dimensions(avctx, width, height);
|
||||
avctx->height = bytestream2_get_le32(gbc);
|
||||
avctx->width = bytestream2_get_le32(gbc);
|
||||
ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
|
||||
if (ret < 0) {
|
||||
av_log(avctx, AV_LOG_ERROR, "Invalid image size %dx%d.\n",
|
||||
avctx->width, avctx->height);
|
||||
|
||||
+1
-3
@@ -41,7 +41,7 @@ static av_cold int dfa_decode_init(AVCodecContext *avctx)
|
||||
|
||||
avctx->pix_fmt = AV_PIX_FMT_PAL8;
|
||||
|
||||
if (!avctx->width || !avctx->height || FFMAX(avctx->width, avctx->height) >= (1<<16))
|
||||
if (!avctx->width || !avctx->height)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
av_assert0(av_image_check_size(avctx->width, avctx->height, 0, avctx) >= 0);
|
||||
@@ -355,8 +355,6 @@ static int dfa_decode_frame(AVCodecContext *avctx,
|
||||
|
||||
bytestream2_init(&gb, avpkt->data, avpkt->size);
|
||||
while (bytestream2_get_bytes_left(&gb) > 0) {
|
||||
if (bytestream2_get_bytes_left(&gb) < 12)
|
||||
return AVERROR_INVALIDDATA;
|
||||
bytestream2_skip(&gb, 4);
|
||||
chunk_size = bytestream2_get_le32(&gb);
|
||||
chunk_type = bytestream2_get_le32(&gb);
|
||||
|
||||
@@ -99,10 +99,10 @@ void ff_spatial_idwt_slice2(DWTContext *d, int y);
|
||||
(b1 + (unsigned)((int)(b0 + (unsigned)(b2) + 1) >> 1))
|
||||
|
||||
#define COMPOSE_DD97iH0(b0, b1, b2, b3, b4)\
|
||||
(int)(((unsigned)(b2) + ((int)(9U*b1 + 9U*b3 - b4 - b0 + 8) >> 4)))
|
||||
(int)(((unsigned)(b2) + ((int)(-b0 + 9U*b1 + 9U*b3 - b4 + 8) >> 4)))
|
||||
|
||||
#define COMPOSE_DD137iL0(b0, b1, b2, b3, b4)\
|
||||
(int)(((unsigned)(b2) - ((int)(9U*b1 + 9U*b3 - b4 - b0 + 16) >> 5)))
|
||||
(int)(((unsigned)(b2) - ((int)(-b0 + 9U*b1 + 9U*b3 - b4 + 16) >> 5)))
|
||||
|
||||
#define COMPOSE_HAARiL0(b0, b1)\
|
||||
((int)(b0 - (unsigned)((int)(b1 + 1U) >> 1)))
|
||||
|
||||
@@ -57,8 +57,8 @@ static av_always_inline void RENAME(interleave)(TYPE *dst, TYPE *src0, TYPE *src
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < w2; i++) {
|
||||
dst[2*i ] = ((int)(src0[i] + (unsigned)add)) >> shift;
|
||||
dst[2*i+1] = ((int)(src1[i] + (unsigned)add)) >> shift;
|
||||
dst[2*i ] = (src0[i] + add) >> shift;
|
||||
dst[2*i+1] = (src1[i] + add) >> shift;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -190,15 +190,15 @@ static void RENAME(horizontal_compose_daub97i)(uint8_t *_b, uint8_t *_temp, int
|
||||
|
||||
// second stage combined with interleave and shift
|
||||
b0 = b2 = COMPOSE_DAUB97iL0(temp[w2], temp[0], temp[w2]);
|
||||
b[0] = ~((~b0) >> 1);
|
||||
b[0] = (b0 + 1) >> 1;
|
||||
for (x = 1; x < w2; x++) {
|
||||
b2 = COMPOSE_DAUB97iL0(temp[x+w2-1], temp[x ], temp[x+w2]);
|
||||
b1 = COMPOSE_DAUB97iH0( b0, temp[x+w2-1], b2 );
|
||||
b[2*x-1] = ~((~b1) >> 1);
|
||||
b[2*x ] = ~((~b2) >> 1);
|
||||
b[2*x-1] = (b1 + 1) >> 1;
|
||||
b[2*x ] = (b2 + 1) >> 1;
|
||||
b0 = b2;
|
||||
}
|
||||
b[w-1] = ~((~COMPOSE_DAUB97iH0(b2, temp[w-1], b2)) >> 1);
|
||||
b[w-1] = (COMPOSE_DAUB97iH0(b2, temp[w-1], b2) + 1) >> 1;
|
||||
}
|
||||
|
||||
static void RENAME(vertical_compose_dirac53iH0)(uint8_t *_b0, uint8_t *_b1, uint8_t *_b2,
|
||||
|
||||
@@ -212,7 +212,7 @@ static int dirac_combine_frame(AVCodecParserContext *s, AVCodecContext *avctx,
|
||||
if (parse_timing_info && pu1.prev_pu_offset >= 13) {
|
||||
uint8_t *cur_pu = pc->buffer +
|
||||
pc->index - 13 - pu1.prev_pu_offset;
|
||||
int64_t pts = AV_RB32(cur_pu + 13);
|
||||
int pts = AV_RB32(cur_pu + 13);
|
||||
if (s->last_pts == 0 && s->last_dts == 0)
|
||||
s->dts = pts - 1;
|
||||
else
|
||||
|
||||
+6
-19
@@ -141,7 +141,7 @@ typedef struct DiracContext {
|
||||
GetBitContext gb;
|
||||
AVDiracSeqHeader seq;
|
||||
int seen_sequence_header;
|
||||
int64_t frame_number; /* number of the next frame to display */
|
||||
int frame_number; /* number of the next frame to display */
|
||||
Plane plane[3];
|
||||
int chroma_x_shift;
|
||||
int chroma_y_shift;
|
||||
@@ -668,10 +668,6 @@ static void decode_component(DiracContext *s, int comp)
|
||||
b->length = get_interleaved_ue_golomb(&s->gb);
|
||||
if (b->length) {
|
||||
b->quant = get_interleaved_ue_golomb(&s->gb);
|
||||
if (b->quant > (DIRAC_MAX_QUANT_INDEX - 1)) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "Unsupported quant %d\n", b->quant);
|
||||
b->quant = 0;
|
||||
}
|
||||
align_get_bits(&s->gb);
|
||||
b->coeff_data = s->gb.buffer + get_bits_count(&s->gb)/8;
|
||||
b->length = FFMIN(b->length, FFMAX(get_bits_left(&s->gb)/8, 0));
|
||||
@@ -990,10 +986,6 @@ static int decode_lowdelay(DiracContext *s)
|
||||
for (slice_x = 0; bufsize > 0 && slice_x < s->num_x; slice_x++) {
|
||||
bytes = (slice_num+1) * (int64_t)s->lowdelay.bytes.num / s->lowdelay.bytes.den
|
||||
- slice_num * (int64_t)s->lowdelay.bytes.num / s->lowdelay.bytes.den;
|
||||
if (bytes >= INT_MAX || bytes*8 > bufsize) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "too many bytes\n");
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
slices[slice_num].bytes = bytes;
|
||||
slices[slice_num].slice_x = slice_x;
|
||||
slices[slice_num].slice_y = slice_y;
|
||||
@@ -1251,12 +1243,7 @@ static int dirac_unpack_idwt_params(DiracContext *s)
|
||||
else {
|
||||
s->num_x = get_interleaved_ue_golomb(gb);
|
||||
s->num_y = get_interleaved_ue_golomb(gb);
|
||||
if (s->num_x * s->num_y == 0 || s->num_x * (uint64_t)s->num_y > INT_MAX ||
|
||||
s->num_x * (uint64_t)s->avctx->width > INT_MAX ||
|
||||
s->num_y * (uint64_t)s->avctx->height > INT_MAX ||
|
||||
s->num_x > s->avctx->width ||
|
||||
s->num_y > s->avctx->height
|
||||
) {
|
||||
if (s->num_x * s->num_y == 0 || s->num_x * (uint64_t)s->num_y > INT_MAX) {
|
||||
av_log(s->avctx,AV_LOG_ERROR,"Invalid numx/y\n");
|
||||
s->num_x = s->num_y = 0;
|
||||
return AVERROR_INVALIDDATA;
|
||||
@@ -1411,9 +1398,9 @@ static void global_mv(DiracContext *s, DiracBlock *block, int x, int y, int ref)
|
||||
int *b = s->globalmc[ref].pan_tilt;
|
||||
int *c = s->globalmc[ref].perspective;
|
||||
|
||||
int64_t m = (1<<ep) - (c[0]*(int64_t)x + c[1]*(int64_t)y);
|
||||
int64_t mx = m * (int64_t)((A[0][0] * (int64_t)x + A[0][1]*(int64_t)y) + (1LL<<ez) * b[0]);
|
||||
int64_t my = m * (int64_t)((A[1][0] * (int64_t)x + A[1][1]*(int64_t)y) + (1LL<<ez) * b[1]);
|
||||
int m = (1<<ep) - (c[0]*x + c[1]*y);
|
||||
int64_t mx = m * (int64_t)((A[0][0] * x + A[0][1]*y) + (1<<ez) * b[0]);
|
||||
int64_t my = m * (int64_t)((A[1][0] * x + A[1][1]*y) + (1<<ez) * b[1]);
|
||||
|
||||
block->u.mv[ref][0] = (mx + (1<<(ez+ep))) >> (ez+ep);
|
||||
block->u.mv[ref][1] = (my + (1<<(ez+ep))) >> (ez+ep);
|
||||
@@ -2323,7 +2310,7 @@ static int dirac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
|
||||
}
|
||||
|
||||
if (*got_frame)
|
||||
s->frame_number = picture->display_picture_number + 1LL;
|
||||
s->frame_number = picture->display_picture_number + 1;
|
||||
|
||||
return buf_idx;
|
||||
}
|
||||
|
||||
@@ -79,9 +79,10 @@ static int dnxhd_find_frame_end(DNXHDParserContext *dctx,
|
||||
if (remaining <= 0)
|
||||
continue;
|
||||
}
|
||||
remaining += i - 47;
|
||||
dctx->remaining = remaining;
|
||||
if (buf_size >= dctx->remaining) {
|
||||
if (buf_size - i + 47 >= dctx->remaining) {
|
||||
int remaining = dctx->remaining;
|
||||
|
||||
pc->frame_start_found = 0;
|
||||
pc->state64 = -1;
|
||||
dctx->cur_byte = 0;
|
||||
|
||||
@@ -220,7 +220,7 @@ static av_cold int dnxhd_init_vlc(DNXHDEncContext *ctx)
|
||||
ctx->vlc_bits += max_level * 2;
|
||||
for (level = -max_level; level < max_level; level++) {
|
||||
for (run = 0; run < 2; run++) {
|
||||
int index = level * (1 << 1) | run;
|
||||
int index = (level << 1) | run;
|
||||
int sign, offset = 0, alevel = level;
|
||||
|
||||
MASK_ABS(sign, alevel);
|
||||
@@ -610,7 +610,7 @@ void dnxhd_encode_block(DNXHDEncContext *ctx, int16_t *block,
|
||||
slevel = block[j];
|
||||
if (slevel) {
|
||||
int run_level = i - last_non_zero - 1;
|
||||
int rlevel = slevel * (1 << 1) | !!run_level;
|
||||
int rlevel = (slevel << 1) | !!run_level;
|
||||
put_bits(&ctx->m.pb, ctx->vlc_bits[rlevel], ctx->vlc_codes[rlevel]);
|
||||
if (run_level)
|
||||
put_bits(&ctx->m.pb, ctx->run_bits[run_level],
|
||||
@@ -690,7 +690,7 @@ int dnxhd_calc_ac_bits(DNXHDEncContext *ctx, int16_t *block, int last_index)
|
||||
level = block[j];
|
||||
if (level) {
|
||||
int run_level = i - last_non_zero - 1;
|
||||
bits += ctx->vlc_bits[level * (1 << 1) |
|
||||
bits += ctx->vlc_bits[(level << 1) |
|
||||
!!run_level] + ctx->run_bits[run_level];
|
||||
last_non_zero = i;
|
||||
}
|
||||
|
||||
+4
-3
@@ -305,8 +305,9 @@ static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
|
||||
shift[ch] -= (2 * n);
|
||||
diff = sign_extend((diff &~ 3) << 8, 16);
|
||||
|
||||
/* saturate the shifter to 0..31 */
|
||||
shift[ch] = av_clip_uintp2(shift[ch], 5);
|
||||
/* saturate the shifter to a lower limit of 0 */
|
||||
if (shift[ch] < 0)
|
||||
shift[ch] = 0;
|
||||
|
||||
diff >>= shift[ch];
|
||||
predictor[ch] += diff;
|
||||
@@ -366,7 +367,7 @@ static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
|
||||
while (output_samples < samples_end) {
|
||||
uint8_t n = bytestream2_get_byteu(&gb);
|
||||
|
||||
*output_samples++ = s->sample[idx] += (unsigned)s->array[n];
|
||||
*output_samples++ = s->sample[idx] += s->array[n];
|
||||
idx ^= 1;
|
||||
}
|
||||
}
|
||||
|
||||
+4
-6
@@ -408,14 +408,12 @@ static int decode_frame(AVCodecContext *avctx,
|
||||
if (elements == 4)
|
||||
*dst[3]++ = read16(&buf, endian) >> 4;
|
||||
} else {
|
||||
if (elements >= 3)
|
||||
*dst[2]++ = read12in32(&buf, &rgbBuffer,
|
||||
&n_datum, endian);
|
||||
*dst[2]++ = read12in32(&buf, &rgbBuffer,
|
||||
&n_datum, endian);
|
||||
*dst[0]++ = read12in32(&buf, &rgbBuffer,
|
||||
&n_datum, endian);
|
||||
if (elements >= 2)
|
||||
*dst[1]++ = read12in32(&buf, &rgbBuffer,
|
||||
&n_datum, endian);
|
||||
*dst[1]++ = read12in32(&buf, &rgbBuffer,
|
||||
&n_datum, endian);
|
||||
if (elements == 4)
|
||||
*dst[3]++ = read12in32(&buf, &rgbBuffer,
|
||||
&n_datum, endian);
|
||||
|
||||
@@ -44,9 +44,6 @@ static av_cold int decode_init(AVCodecContext *avctx)
|
||||
int i;
|
||||
uint8_t silence;
|
||||
|
||||
if (!avctx->channels)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
ff_init_dsd_data();
|
||||
|
||||
s = av_malloc_array(sizeof(DSDContext), avctx->channels);
|
||||
|
||||
@@ -158,9 +158,6 @@ static int cin_decode_lzss(const unsigned char *src, int src_size,
|
||||
}
|
||||
}
|
||||
|
||||
if (dst_end - dst > dst_size - dst_size/10)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -187,10 +184,6 @@ static int cin_decode_rle(const unsigned char *src, int src_size,
|
||||
}
|
||||
dst += len;
|
||||
}
|
||||
|
||||
if (dst_end - dst > dst_size - dst_size/10)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -233,35 +226,27 @@ static int cinvideo_decode_frame(AVCodecContext *avctx,
|
||||
* surface.width = surface.pitch */
|
||||
switch (bitmap_frame_type) {
|
||||
case 9:
|
||||
res = cin_decode_rle(buf, bitmap_frame_size,
|
||||
cin_decode_rle(buf, bitmap_frame_size,
|
||||
cin->bitmap_table[CIN_CUR_BMP], cin->bitmap_size);
|
||||
if (res < 0)
|
||||
return res;
|
||||
break;
|
||||
case 34:
|
||||
res = cin_decode_rle(buf, bitmap_frame_size,
|
||||
cin_decode_rle(buf, bitmap_frame_size,
|
||||
cin->bitmap_table[CIN_CUR_BMP], cin->bitmap_size);
|
||||
if (res < 0)
|
||||
return res;
|
||||
cin_apply_delta_data(cin->bitmap_table[CIN_PRE_BMP],
|
||||
cin->bitmap_table[CIN_CUR_BMP], cin->bitmap_size);
|
||||
break;
|
||||
case 35:
|
||||
bitmap_frame_size = cin_decode_huffman(buf, bitmap_frame_size,
|
||||
cin->bitmap_table[CIN_INT_BMP], cin->bitmap_size);
|
||||
res = cin_decode_rle(cin->bitmap_table[CIN_INT_BMP], bitmap_frame_size,
|
||||
cin_decode_rle(cin->bitmap_table[CIN_INT_BMP], bitmap_frame_size,
|
||||
cin->bitmap_table[CIN_CUR_BMP], cin->bitmap_size);
|
||||
if (res < 0)
|
||||
return res;
|
||||
break;
|
||||
case 36:
|
||||
bitmap_frame_size = cin_decode_huffman(buf, bitmap_frame_size,
|
||||
cin->bitmap_table[CIN_INT_BMP],
|
||||
cin->bitmap_size);
|
||||
res = cin_decode_rle(cin->bitmap_table[CIN_INT_BMP], bitmap_frame_size,
|
||||
cin_decode_rle(cin->bitmap_table[CIN_INT_BMP], bitmap_frame_size,
|
||||
cin->bitmap_table[CIN_CUR_BMP], cin->bitmap_size);
|
||||
if (res < 0)
|
||||
return res;
|
||||
cin_apply_delta_data(cin->bitmap_table[CIN_PRE_BMP],
|
||||
cin->bitmap_table[CIN_CUR_BMP], cin->bitmap_size);
|
||||
break;
|
||||
|
||||
+5
-23
@@ -37,7 +37,7 @@
|
||||
#define DST_MAX_CHANNELS 6
|
||||
#define DST_MAX_ELEMENTS (2 * DST_MAX_CHANNELS)
|
||||
|
||||
#define DSD_FS44(sample_rate) (sample_rate * 8LL / 44100)
|
||||
#define DSD_FS44(sample_rate) (sample_rate * 8 / 44100)
|
||||
|
||||
#define DST_SAMPLES_PER_FRAME(sample_rate) (588 * DSD_FS44(sample_rate))
|
||||
|
||||
@@ -85,16 +85,6 @@ static av_cold int decode_init(AVCodecContext *avctx)
|
||||
return AVERROR_PATCHWELCOME;
|
||||
}
|
||||
|
||||
// the sample rate is only allowed to be 64,128,256 * 44100 by ISO/IEC 14496-3:2005(E)
|
||||
// We are a bit more tolerant here, but this check is needed to bound the size and duration
|
||||
if (avctx->sample_rate > 512 * 44100)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
|
||||
if (DST_SAMPLES_PER_FRAME(avctx->sample_rate) & 7) {
|
||||
return AVERROR_PATCHWELCOME;
|
||||
}
|
||||
|
||||
avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
|
||||
|
||||
for (i = 0; i < avctx->channels; i++)
|
||||
@@ -130,7 +120,7 @@ static int read_map(GetBitContext *gb, Table *t, unsigned int map[DST_MAX_CHANNE
|
||||
|
||||
static av_always_inline int get_sr_golomb_dst(GetBitContext *gb, unsigned int k)
|
||||
{
|
||||
int v = get_ur_golomb_jpegls(gb, k, get_bits_left(gb), 0);
|
||||
int v = get_ur_golomb(gb, k, get_bits_left(gb), 0);
|
||||
if (v && get_bits1(gb))
|
||||
v = -v;
|
||||
return v;
|
||||
@@ -165,16 +155,12 @@ static int read_table(GetBitContext *gb, Table *t, const int8_t code_pred_coeff[
|
||||
for (j = method + 1; j < t->length[i]; j++) {
|
||||
int c, x = 0;
|
||||
for (k = 0; k < method + 1; k++)
|
||||
x += code_pred_coeff[method][k] * (unsigned)t->coeff[i][j - k - 1];
|
||||
x += code_pred_coeff[method][k] * t->coeff[i][j - k - 1];
|
||||
c = get_sr_golomb_dst(gb, lsb_size);
|
||||
if (x >= 0)
|
||||
c -= (x + 4) / 8;
|
||||
else
|
||||
c += (-x + 3) / 8;
|
||||
if (!is_signed) {
|
||||
if (c < offset || c >= offset + (1<<coeff_bits))
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
t->coeff[i][j] = c;
|
||||
}
|
||||
}
|
||||
@@ -312,15 +298,11 @@ static int decode_frame(AVCodecContext *avctx, void *data,
|
||||
|
||||
/* Filter Coef Sets (10.12) */
|
||||
|
||||
ret = read_table(gb, &s->fsets, fsets_code_pred_coeff, 7, 9, 1, 0);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
read_table(gb, &s->fsets, fsets_code_pred_coeff, 7, 9, 1, 0);
|
||||
|
||||
/* Probability Tables (10.13) */
|
||||
|
||||
ret = read_table(gb, &s->probs, probs_code_pred_coeff, 6, 7, 0, 1);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
read_table(gb, &s->probs, probs_code_pred_coeff, 6, 7, 0, 1);
|
||||
|
||||
/* Arithmetic Coded Data (10.11) */
|
||||
|
||||
|
||||
@@ -93,7 +93,7 @@ static const AVClass dump_extradata_class = {
|
||||
.class_name = "dump_extradata bsf",
|
||||
.item_name = av_default_item_name,
|
||||
.option = options,
|
||||
.version = LIBAVUTIL_VERSION_INT,
|
||||
.version = LIBAVUTIL_VERSION_MAJOR,
|
||||
};
|
||||
|
||||
const AVBitStreamFilter ff_dump_extradata_bsf = {
|
||||
|
||||
+2
-10
@@ -1261,13 +1261,6 @@ static int dvbsub_parse_region_segment(AVCodecContext *avctx,
|
||||
display->y_pos = AV_RB16(buf) & 0xfff;
|
||||
buf += 2;
|
||||
|
||||
if (display->x_pos >= region->width ||
|
||||
display->y_pos >= region->height) {
|
||||
av_log(avctx, AV_LOG_ERROR, "Object outside region\n");
|
||||
av_free(display);
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
|
||||
if ((object->type == 1 || object->type == 2) && buf+1 < buf_end) {
|
||||
display->fgcolor = *buf++;
|
||||
display->bgcolor = *buf++;
|
||||
@@ -1572,9 +1565,8 @@ static int dvbsub_parse_display_definition_segment(AVCodecContext *avctx,
|
||||
display_def->width = bytestream_get_be16(&buf) + 1;
|
||||
display_def->height = bytestream_get_be16(&buf) + 1;
|
||||
if (!avctx->width || !avctx->height) {
|
||||
int ret = ff_set_dimensions(avctx, display_def->width, display_def->height);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
avctx->width = display_def->width;
|
||||
avctx->height = display_def->height;
|
||||
}
|
||||
|
||||
if (info_byte & 1<<3) { // display_window_flag
|
||||
|
||||
@@ -44,9 +44,6 @@ static int dvdsub_parse(AVCodecParserContext *s,
|
||||
{
|
||||
DVDSubParseContext *pc = s->priv_data;
|
||||
|
||||
*poutbuf = buf;
|
||||
*poutbuf_size = buf_size;
|
||||
|
||||
if (pc->packet_index == 0) {
|
||||
if (buf_size < 2 || AV_RB16(buf) && buf_size < 6) {
|
||||
if (buf_size)
|
||||
@@ -57,11 +54,7 @@ static int dvdsub_parse(AVCodecParserContext *s,
|
||||
if (pc->packet_len == 0) /* HD-DVD subpicture packet */
|
||||
pc->packet_len = AV_RB32(buf+2);
|
||||
av_freep(&pc->packet);
|
||||
if ((unsigned)pc->packet_len > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
|
||||
av_log(avctx, AV_LOG_ERROR, "packet length %d is invalid\n", pc->packet_len);
|
||||
return buf_size;
|
||||
}
|
||||
pc->packet = av_malloc(pc->packet_len + AV_INPUT_BUFFER_PADDING_SIZE);
|
||||
pc->packet = av_malloc(pc->packet_len);
|
||||
}
|
||||
if (pc->packet) {
|
||||
if (pc->packet_index + buf_size <= pc->packet_len) {
|
||||
|
||||
@@ -82,7 +82,10 @@ static int decode_run_8bit(GetBitContext *gb, int *color)
|
||||
{
|
||||
int len;
|
||||
int has_run = get_bits1(gb);
|
||||
*color = get_bits(gb, 2 + 6*get_bits1(gb));
|
||||
if (get_bits1(gb))
|
||||
*color = get_bits(gb, 8);
|
||||
else
|
||||
*color = get_bits(gb, 2);
|
||||
if (has_run) {
|
||||
if (get_bits1(gb)) {
|
||||
len = get_bits(gb, 7);
|
||||
@@ -124,8 +127,6 @@ static int decode_rle(uint8_t *bitmap, int linesize, int w, int h,
|
||||
len = decode_run_8bit(&gb, &color);
|
||||
else
|
||||
len = decode_run_2bit(&gb, &color);
|
||||
if (len != INT_MAX && len > w - x)
|
||||
return AVERROR_INVALIDDATA;
|
||||
len = FFMIN(len, w - x);
|
||||
memset(d + x, color, len);
|
||||
x += len;
|
||||
|
||||
+3
-19
@@ -426,8 +426,7 @@ static int fill_optable(unsigned *table0, OpcodeTable *table1, int nb_elements)
|
||||
static int get_opcodes(GetByteContext *gb, uint32_t *table, uint8_t *dst, int op_size, int nb_elements)
|
||||
{
|
||||
OpcodeTable optable[1024];
|
||||
int sum, x, val, lshift, rshift, ret, i, idx;
|
||||
int64_t size_in_bits;
|
||||
int sum, x, val, lshift, rshift, ret, size_in_bits, i, idx;
|
||||
unsigned endoffset, newoffset, offset;
|
||||
unsigned next;
|
||||
uint8_t *src = (uint8_t *)gb->buffer;
|
||||
@@ -743,9 +742,6 @@ static int dxv_decompress_cocg(DXVContext *ctx, GetByteContext *gb,
|
||||
int skip0, skip1, oi0 = 0, oi1 = 0;
|
||||
int ret, state0 = 0, state1 = 0;
|
||||
|
||||
if (op_offset < 12 || op_offset - 12 > bytestream2_get_bytes_left(gb))
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
dst = tex_data;
|
||||
bytestream2_skip(gb, op_offset - 12);
|
||||
if (op_size0 > max_op_size0)
|
||||
@@ -753,6 +749,7 @@ static int dxv_decompress_cocg(DXVContext *ctx, GetByteContext *gb,
|
||||
skip0 = dxv_decompress_opcodes(gb, op_data0, op_size0);
|
||||
if (skip0 < 0)
|
||||
return skip0;
|
||||
bytestream2_seek(gb, data_start + op_offset + skip0 - 12, SEEK_SET);
|
||||
if (op_size1 > max_op_size1)
|
||||
return AVERROR_INVALIDDATA;
|
||||
skip1 = dxv_decompress_opcodes(gb, op_data1, op_size1);
|
||||
@@ -781,7 +778,7 @@ static int dxv_decompress_cocg(DXVContext *ctx, GetByteContext *gb,
|
||||
return ret;
|
||||
}
|
||||
|
||||
bytestream2_seek(gb, data_start - 12 + op_offset + skip0 + skip1, SEEK_SET);
|
||||
bytestream2_seek(gb, data_start + op_offset + skip0 + skip1 - 12, SEEK_SET);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -796,9 +793,6 @@ static int dxv_decompress_yo(DXVContext *ctx, GetByteContext *gb,
|
||||
uint8_t *dst, *table0[256] = { 0 }, *table1[256] = { 0 };
|
||||
int ret, state = 0, skip, oi = 0, v, vv;
|
||||
|
||||
if (op_offset < 8 || op_offset - 8 > bytestream2_get_bytes_left(gb))
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
dst = tex_data;
|
||||
bytestream2_skip(gb, op_offset - 8);
|
||||
if (op_size > max_op_size)
|
||||
@@ -1057,10 +1051,6 @@ static int dxv_decode(AVCodecContext *avctx, void *data,
|
||||
avctx->pix_fmt = AV_PIX_FMT_RGBA;
|
||||
avctx->colorspace = AVCOL_SPC_RGB;
|
||||
|
||||
ctx->tex_funct = NULL;
|
||||
ctx->tex_funct_planar[0] = NULL;
|
||||
ctx->tex_funct_planar[1] = NULL;
|
||||
|
||||
tag = bytestream2_get_le32(gbc);
|
||||
switch (tag) {
|
||||
case MKBETAG('D', 'X', 'T', '1'):
|
||||
@@ -1202,12 +1192,6 @@ static int dxv_decode(AVCodecContext *avctx, void *data,
|
||||
ret = decompress_tex(avctx);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
{
|
||||
int w_block = avctx->coded_width / ctx->texture_block_w;
|
||||
int h_block = avctx->coded_height / ctx->texture_block_h;
|
||||
if (w_block * h_block * ctx->tex_step > ctx->tex_size * 8LL)
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
|
||||
tframe.f = data;
|
||||
ret = ff_thread_get_buffer(avctx, &tframe, 0);
|
||||
|
||||
+2
-12
@@ -349,18 +349,8 @@ static int ff_eac3_parse_header(AC3DecodeContext *s)
|
||||
/* dependent stream channel map */
|
||||
if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
|
||||
if (get_bits1(gbc)) {
|
||||
int64_t channel_layout = 0;
|
||||
int channel_map = get_bits(gbc, 16);
|
||||
av_log(s->avctx, AV_LOG_DEBUG, "channel_map: %0X\n", channel_map);
|
||||
|
||||
for (i = 0; i < 16; i++)
|
||||
if (channel_map & (1 << (EAC3_MAX_CHANNELS - i - 1)))
|
||||
channel_layout |= ff_eac3_custom_channel_map_locations[i][1];
|
||||
|
||||
if (av_popcount64(channel_layout) > EAC3_MAX_CHANNELS) {
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
s->channel_map = channel_map;
|
||||
s->channel_map = get_bits(gbc, 16);
|
||||
av_log(s->avctx, AV_LOG_DEBUG, "channel_map: %0X\n", s->channel_map);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -300,9 +300,6 @@ static int tgv_decode_frame(AVCodecContext *avctx,
|
||||
s->palette[i] = 0xFFU << 24 | AV_RB24(buf);
|
||||
buf += 3;
|
||||
}
|
||||
if (buf_end - buf < 5) {
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
}
|
||||
|
||||
if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
|
||||
|
||||
@@ -131,9 +131,6 @@ static int tqi_decode_frame(AVCodecContext *avctx,
|
||||
AVFrame *frame = data;
|
||||
int ret, w, h;
|
||||
|
||||
if (buf_size < 12)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
t->avctx = avctx;
|
||||
|
||||
w = AV_RL16(&buf[0]);
|
||||
|
||||
+5
-3
@@ -271,7 +271,7 @@ void ff_els_decoder_init(ElsDecCtx *ctx, const uint8_t *in, size_t data_size)
|
||||
|
||||
void ff_els_decoder_uninit(ElsUnsignedRung *rung)
|
||||
{
|
||||
av_freep(&rung->rem_rung_list);
|
||||
av_free(rung->rem_rung_list);
|
||||
}
|
||||
|
||||
static int els_import_byte(ElsDecCtx *ctx)
|
||||
@@ -391,10 +391,12 @@ unsigned ff_els_decode_unsigned(ElsDecCtx *ctx, ElsUnsignedRung *ur)
|
||||
if (ur->rung_list_size <= (ur->avail_index + 2) * sizeof(ElsRungNode)) {
|
||||
// remember rung_node position
|
||||
ptrdiff_t pos = rung_node - ur->rem_rung_list;
|
||||
ctx->err = av_reallocp(&ur->rem_rung_list,
|
||||
ur->rem_rung_list = av_realloc(ur->rem_rung_list,
|
||||
ur->rung_list_size +
|
||||
RUNG_SPACE);
|
||||
if (ctx->err < 0) {
|
||||
if (!ur->rem_rung_list) {
|
||||
av_free(ur->rem_rung_list);
|
||||
ctx->err = AVERROR(ENOMEM);
|
||||
return 0;
|
||||
}
|
||||
memset((uint8_t *) ur->rem_rung_list + ur->rung_list_size, 0,
|
||||
|
||||
@@ -107,7 +107,7 @@ static void filter181(int16_t *data, int width, int height, ptrdiff_t stride)
|
||||
dc = -prev_dc +
|
||||
data[x + y * stride] * 8 -
|
||||
data[x + 1 + y * stride];
|
||||
dc = (av_clip(dc, INT_MIN/10923, INT_MAX/10923 - 32768) * 10923 + 32768) >> 16;
|
||||
dc = (dc * 10923 + 32768) >> 16;
|
||||
prev_dc = data[x + y * stride];
|
||||
data[x + y * stride] = dc;
|
||||
}
|
||||
@@ -123,7 +123,7 @@ static void filter181(int16_t *data, int width, int height, ptrdiff_t stride)
|
||||
dc = -prev_dc +
|
||||
data[x + y * stride] * 8 -
|
||||
data[x + (y + 1) * stride];
|
||||
dc = (av_clip(dc, INT_MIN/10923, INT_MAX/10923 - 32768) * 10923 + 32768) >> 16;
|
||||
dc = (dc * 10923 + 32768) >> 16;
|
||||
prev_dc = data[x + y * stride];
|
||||
data[x + y * stride] = dc;
|
||||
}
|
||||
@@ -437,7 +437,7 @@ static void guess_mv(ERContext *s)
|
||||
}
|
||||
|
||||
if ((!(s->avctx->error_concealment&FF_EC_GUESS_MVS)) ||
|
||||
num_avail <= FFMAX(mb_width, mb_height) / 2) {
|
||||
num_avail <= mb_width / 2) {
|
||||
for (mb_y = 0; mb_y < 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;
|
||||
@@ -814,7 +814,8 @@ static int er_supported(ERContext *s)
|
||||
{
|
||||
if(s->avctx->hwaccel && s->avctx->hwaccel->decode_slice ||
|
||||
!s->cur_pic.f ||
|
||||
s->cur_pic.field_picture
|
||||
s->cur_pic.field_picture ||
|
||||
s->avctx->profile == FF_PROFILE_MPEG4_SIMPLE_STUDIO
|
||||
)
|
||||
return 0;
|
||||
return 1;
|
||||
|
||||
@@ -221,11 +221,7 @@ static int escape124_decode_frame(AVCodecContext *avctx,
|
||||
|
||||
// This call also guards the potential depth reads for the
|
||||
// codebook unpacking.
|
||||
// Check if the amount we will read minimally is available on input.
|
||||
// The 64 represent the immediately next 2 frame_* elements read, the 23/4320
|
||||
// represent a lower bound of the space needed for skipped superblocks. Non
|
||||
// skipped SBs need more space.
|
||||
if (get_bits_left(&gb) < 64 + s->num_superblocks * 23LL / 4320)
|
||||
if (get_bits_left(&gb) < 64)
|
||||
return -1;
|
||||
|
||||
frame_flags = get_bits_long(&gb, 32);
|
||||
|
||||
+1
-10
@@ -881,7 +881,7 @@ static int pxr24_uncompress(EXRContext *s, const uint8_t *src,
|
||||
in = ptr[3] + s->xdelta;
|
||||
|
||||
for (j = 0; j < s->xdelta; ++j) {
|
||||
uint32_t diff = ((uint32_t)*(ptr[0]++) << 24) |
|
||||
uint32_t diff = (*(ptr[0]++) << 24) |
|
||||
(*(ptr[1]++) << 16) |
|
||||
(*(ptr[2]++) << 8 ) |
|
||||
(*(ptr[3]++));
|
||||
@@ -1307,7 +1307,6 @@ static int decode_header(EXRContext *s, AVFrame *frame)
|
||||
int magic_number, version, i, flags, sar = 0;
|
||||
int layer_match = 0;
|
||||
int ret;
|
||||
int dup_channels = 0;
|
||||
|
||||
s->current_channel_offset = 0;
|
||||
s->xmin = ~0;
|
||||
@@ -1390,7 +1389,6 @@ static int decode_header(EXRContext *s, AVFrame *frame)
|
||||
if (*ch_gb.buffer == '.')
|
||||
ch_gb.buffer++; /* skip dot if not given */
|
||||
} else {
|
||||
layer_match = 0;
|
||||
av_log(s->avctx, AV_LOG_INFO,
|
||||
"Channel doesn't match layer : %s.\n", ch_gb.buffer);
|
||||
}
|
||||
@@ -1465,13 +1463,6 @@ static int decode_header(EXRContext *s, AVFrame *frame)
|
||||
}
|
||||
s->pixel_type = current_pixel_type;
|
||||
s->channel_offsets[channel_index] = s->current_channel_offset;
|
||||
} else if (channel_index >= 0) {
|
||||
av_log(s->avctx, AV_LOG_WARNING,
|
||||
"Multiple channels with index %d.\n", channel_index);
|
||||
if (++dup_channels > 10) {
|
||||
ret = AVERROR_INVALIDDATA;
|
||||
goto fail;
|
||||
}
|
||||
}
|
||||
|
||||
s->channels = av_realloc(s->channels,
|
||||
|
||||
@@ -900,7 +900,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPac
|
||||
unsigned crc = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, v);
|
||||
if (crc) {
|
||||
int64_t ts = avpkt->pts != AV_NOPTS_VALUE ? avpkt->pts : avpkt->dts;
|
||||
av_log(f->avctx, AV_LOG_ERROR, "slice CRC mismatch %X!", crc);
|
||||
av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!", crc);
|
||||
if (ts != AV_NOPTS_VALUE && avctx->pkt_timebase.num) {
|
||||
av_log(f->avctx, AV_LOG_ERROR, "at %f seconds\n", ts*av_q2d(avctx->pkt_timebase));
|
||||
} else if (ts != AV_NOPTS_VALUE) {
|
||||
|
||||
@@ -539,10 +539,6 @@ static av_cold int encode_init(AVCodecContext *avctx)
|
||||
s->ec = (s->version >= 3);
|
||||
}
|
||||
|
||||
// CRC requires version 3+
|
||||
if (s->ec)
|
||||
s->version = FFMAX(s->version, 3);
|
||||
|
||||
if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
|
||||
av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
+24
-22
@@ -113,12 +113,18 @@ static uint32_t lcg_next(uint32_t *s)
|
||||
return *s;
|
||||
}
|
||||
|
||||
static void lcg_seek(uint32_t *s, uint32_t dt)
|
||||
static void lcg_seek(uint32_t *s, int64_t dt)
|
||||
{
|
||||
uint32_t a, c, t = *s;
|
||||
|
||||
a = LCG_A;
|
||||
c = LCG_C;
|
||||
if (dt >= 0) {
|
||||
a = LCG_A;
|
||||
c = LCG_C;
|
||||
} else { /* coefficients for a step backward */
|
||||
a = LCG_AI;
|
||||
c = (uint32_t)(LCG_AI * LCG_C);
|
||||
dt = -dt;
|
||||
}
|
||||
while (dt) {
|
||||
if (dt & 1)
|
||||
t = a * t + c;
|
||||
@@ -215,12 +221,12 @@ static void wavesynth_seek(struct wavesynth_context *ws, int64_t ts)
|
||||
ws->next_inter = i;
|
||||
ws->next_ts = i < ws->nb_inter ? ws->inter[i].ts_start : INF_TS;
|
||||
*last = -1;
|
||||
lcg_seek(&ws->dither_state, (uint32_t)ts - (uint32_t)ws->cur_ts);
|
||||
lcg_seek(&ws->dither_state, ts - ws->cur_ts);
|
||||
if (ws->pink_need) {
|
||||
uint64_t pink_ts_cur = (ws->cur_ts + (uint64_t)PINK_UNIT - 1) & ~(PINK_UNIT - 1);
|
||||
uint64_t pink_ts_next = ts & ~(PINK_UNIT - 1);
|
||||
int64_t pink_ts_cur = (ws->cur_ts + PINK_UNIT - 1) & ~(PINK_UNIT - 1);
|
||||
int64_t pink_ts_next = ts & ~(PINK_UNIT - 1);
|
||||
int pos = ts & (PINK_UNIT - 1);
|
||||
lcg_seek(&ws->pink_state, (uint32_t)(pink_ts_next - pink_ts_cur) * 2);
|
||||
lcg_seek(&ws->pink_state, (pink_ts_next - pink_ts_cur) << 1);
|
||||
if (pos) {
|
||||
pink_fill(ws);
|
||||
ws->pink_pos = pos;
|
||||
@@ -247,7 +253,7 @@ static int wavesynth_parse_extradata(AVCodecContext *avc)
|
||||
edata_end = edata + avc->extradata_size;
|
||||
ws->nb_inter = AV_RL32(edata);
|
||||
edata += 4;
|
||||
if (ws->nb_inter < 0 || (edata_end - edata) / 24 < ws->nb_inter)
|
||||
if (ws->nb_inter < 0)
|
||||
return AVERROR(EINVAL);
|
||||
ws->inter = av_calloc(ws->nb_inter, sizeof(*ws->inter));
|
||||
if (!ws->inter)
|
||||
@@ -261,16 +267,13 @@ static int wavesynth_parse_extradata(AVCodecContext *avc)
|
||||
in->type = AV_RL32(edata + 16);
|
||||
in->channels = AV_RL32(edata + 20);
|
||||
edata += 24;
|
||||
if (in->ts_start < cur_ts ||
|
||||
in->ts_end <= in->ts_start ||
|
||||
(uint64_t)in->ts_end - in->ts_start > INT64_MAX
|
||||
)
|
||||
if (in->ts_start < cur_ts || in->ts_end <= in->ts_start)
|
||||
return AVERROR(EINVAL);
|
||||
cur_ts = in->ts_start;
|
||||
dt = in->ts_end - in->ts_start;
|
||||
switch (in->type) {
|
||||
case WS_SINE:
|
||||
if (edata_end - edata < 20 || avc->sample_rate <= 0)
|
||||
if (edata_end - edata < 20)
|
||||
return AVERROR(EINVAL);
|
||||
f1 = AV_RL32(edata + 0);
|
||||
f2 = AV_RL32(edata + 4);
|
||||
@@ -281,7 +284,7 @@ static int wavesynth_parse_extradata(AVCodecContext *avc)
|
||||
dphi1 = frac64(f1, (int64_t)avc->sample_rate << 16);
|
||||
dphi2 = frac64(f2, (int64_t)avc->sample_rate << 16);
|
||||
in->dphi0 = dphi1;
|
||||
in->ddphi = (int64_t)(dphi2 - (uint64_t)dphi1) / dt;
|
||||
in->ddphi = (dphi2 - dphi1) / dt;
|
||||
if (phi & 0x80000000) {
|
||||
phi &= ~0x80000000;
|
||||
if (phi >= i)
|
||||
@@ -301,8 +304,8 @@ static int wavesynth_parse_extradata(AVCodecContext *avc)
|
||||
default:
|
||||
return AVERROR(EINVAL);
|
||||
}
|
||||
in->amp0 = (uint64_t)a1 << 32;
|
||||
in->damp = (int64_t)(((uint64_t)a2 << 32) - ((uint64_t)a1 << 32)) / dt;
|
||||
in->amp0 = (int64_t)a1 << 32;
|
||||
in->damp = (((int64_t)a2 << 32) - ((int64_t)a1 << 32)) / dt;
|
||||
}
|
||||
if (edata != edata_end)
|
||||
return AVERROR(EINVAL);
|
||||
@@ -350,8 +353,7 @@ fail:
|
||||
static void wavesynth_synth_sample(struct wavesynth_context *ws, int64_t ts,
|
||||
int32_t *channels)
|
||||
{
|
||||
int32_t amp, *cv;
|
||||
unsigned val;
|
||||
int32_t amp, val, *cv;
|
||||
struct ws_interval *in;
|
||||
int i, *last, pink;
|
||||
uint32_t c, all_ch = 0;
|
||||
@@ -378,7 +380,7 @@ static void wavesynth_synth_sample(struct wavesynth_context *ws, int64_t ts,
|
||||
in->dphi += in->ddphi;
|
||||
break;
|
||||
case WS_NOISE:
|
||||
val = amp * (unsigned)pink;
|
||||
val = amp * pink;
|
||||
break;
|
||||
default:
|
||||
val = 0;
|
||||
@@ -386,7 +388,7 @@ static void wavesynth_synth_sample(struct wavesynth_context *ws, int64_t ts,
|
||||
all_ch |= in->channels;
|
||||
for (c = in->channels, cv = channels; c; c >>= 1, cv++)
|
||||
if (c & 1)
|
||||
*cv += (unsigned)val;
|
||||
*cv += val;
|
||||
}
|
||||
val = (int32_t)lcg_next(&ws->dither_state) >> 16;
|
||||
for (c = all_ch, cv = channels; c; c >>= 1, cv++)
|
||||
@@ -444,7 +446,7 @@ static int wavesynth_decode(AVCodecContext *avc, void *rframe, int *rgot_frame,
|
||||
if (r < 0)
|
||||
return r;
|
||||
pcm = (int16_t *)frame->data[0];
|
||||
for (s = 0; s < duration; s++, ts+=(uint64_t)1) {
|
||||
for (s = 0; s < duration; s++, ts++) {
|
||||
memset(channels, 0, avc->channels * sizeof(*channels));
|
||||
if (ts >= ws->next_ts)
|
||||
wavesynth_enter_intervals(ws, ts);
|
||||
@@ -452,7 +454,7 @@ static int wavesynth_decode(AVCodecContext *avc, void *rframe, int *rgot_frame,
|
||||
for (c = 0; c < avc->channels; c++)
|
||||
*(pcm++) = channels[c] >> 16;
|
||||
}
|
||||
ws->cur_ts += (uint64_t)duration;
|
||||
ws->cur_ts += duration;
|
||||
*rgot_frame = 1;
|
||||
return packet->size;
|
||||
}
|
||||
|
||||
+1
-11
@@ -82,7 +82,6 @@ static const uint8_t fic_qmat_lq[64] = {
|
||||
static const uint8_t fic_header[7] = { 0, 0, 1, 'F', 'I', 'C', 'V' };
|
||||
|
||||
#define FIC_HEADER_SIZE 27
|
||||
#define CURSOR_OFFSET 59
|
||||
|
||||
static av_always_inline void fic_idct(int16_t *blk, int step, int shift, int rnd)
|
||||
{
|
||||
@@ -139,9 +138,6 @@ static int fic_decode_block(FICContext *ctx, GetBitContext *gb,
|
||||
{
|
||||
int i, num_coeff;
|
||||
|
||||
if (get_bits_left(gb) < 8)
|
||||
return AVERROR_INVALIDDATA;
|
||||
|
||||
/* Is it a skip block? */
|
||||
if (get_bits1(gb)) {
|
||||
*is_p = 1;
|
||||
@@ -341,10 +337,6 @@ static int fic_decode_frame(AVCodecContext *avctx, void *data,
|
||||
skip_cursor = 1;
|
||||
}
|
||||
|
||||
if (!skip_cursor && avpkt->size < CURSOR_OFFSET + sizeof(ctx->cursor_buf)) {
|
||||
skip_cursor = 1;
|
||||
}
|
||||
|
||||
/* Slice height for all but the last slice. */
|
||||
ctx->slice_h = 16 * (ctx->aligned_height >> 4) / nslices;
|
||||
if (ctx->slice_h % 16)
|
||||
@@ -383,8 +375,6 @@ static int fic_decode_frame(AVCodecContext *avctx, void *data,
|
||||
slice_h = FFALIGN(avctx->height - ctx->slice_h * (nslices - 1), 16);
|
||||
} else {
|
||||
slice_size = AV_RB32(src + tsize + FIC_HEADER_SIZE + slice * 4 + 4);
|
||||
if (slice_size < slice_off)
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
|
||||
if (slice_size < slice_off || slice_size > msize)
|
||||
@@ -426,7 +416,7 @@ static int fic_decode_frame(AVCodecContext *avctx, void *data,
|
||||
|
||||
/* Draw cursor. */
|
||||
if (!skip_cursor) {
|
||||
memcpy(ctx->cursor_buf, src + CURSOR_OFFSET, sizeof(ctx->cursor_buf));
|
||||
memcpy(ctx->cursor_buf, src + 59, 32 * 32 * 4);
|
||||
fic_draw_cursor(avctx, cur_x, cur_y);
|
||||
}
|
||||
|
||||
|
||||
@@ -138,17 +138,6 @@ int avpriv_fits_header_parse_line(void *avcl, FITSHeader *header, const uint8_t
|
||||
case STATE_BITPIX:
|
||||
CHECK_KEYWORD("BITPIX");
|
||||
CHECK_VALUE("BITPIX", bitpix);
|
||||
|
||||
switch(header->bitpix) {
|
||||
case 8:
|
||||
case 16:
|
||||
case 32: case -32:
|
||||
case 64: case -64: break;
|
||||
default:
|
||||
av_log(avcl, AV_LOG_ERROR, "invalid value of BITPIX %d\n", header->bitpix); \
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
|
||||
dict_set_if_not_null(metadata, keyword, value);
|
||||
|
||||
header->state = STATE_NAXIS;
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user