Update for 3.4.4

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

.gitignore

@@ -29,6 +29,7 @@
 /ffmpeg
 /ffplay
 /ffprobe
+/ffserver
 /config.asm
 /config.h
 /coverage.info

.travis.yml

@@ -11,10 +11,6 @@ addons:
 compiler:
   - clang
   - gcc
-matrix:
-    exclude:
-        - os: osx
-          compiler: gcc
 cache:
   directories:
     - ffmpeg-samples

Changelog

@@ -1,15 +1,41 @@
 Entries are sorted chronologically from oldest to youngest within each release,
 releases are sorted from youngest to oldest.
 
-version 4.0.1:
+version 3.4.4:
+- avcodec/dvdsub_parser: Allocate input padding
+- avcodec/dvdsub_parser: Init output buf/size
+- avcodec/dirac_dwt_template: Fix signedness regression in interleave()
+- avformat/movenc: Write version 2 of audio atom if channels is not known
+- swresample/arm: rename labels to fix xcode build error
+- avcodec/imgconvert: fix possible null pointer dereference
+
+version 3.4.3:
+- avformat/movenc: Check input sample count
+- avcodec/mjpegdec: Check for odd progressive RGB
+- avformat/movenc: Check that frame_types other than EAC3_FRAME_TYPE_INDEPENDENT have a supported substream id
+- 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
+- avcodec/indeo4: Check for end of bitstream in decode_mb_info()
+- 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: Do not pass AVCodecParameters in avpriv_request_sample
+- 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()
 - 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.
@@ -24,41 +50,24 @@ version 4.0.1:
 - 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()
@@ -66,104 +75,219 @@ version 4.0.1:
 - 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
+- lavf/http.c: Free allocated client URLContext in case of error.
+- avcodec/dsicinvideo: Fail if there is only a small fraction of the data available that comprises a full frame
+- avcodec/dsicinvideo: Propagate errors from cin_decode_rle()
+- avcodec/dfa: Check dimension against maximum
+- avcodec/cinepak: Skip empty frames
+- avcodec/cinepak: move some checks prior to frame allocation
+- swresample/arm: remove unintentional relocation.
+- doc/APIchanges: Fix typos in hashes
+- avformat/utils: Check cur_dts in update_initial_timestamps() more
+- avcodec/utils: Enforce minimum width also for VP5/6
+- avcodec/truemotion2: Propagate out of bounds error from GET_TOK()
+- avformat/utils: Fix integer overflow in end time calculation in update_stream_timings()
+- avcodec/mjpegdec: Check input buffer size.
+- avcodec/h264_slice: Fix integer overflow with last_poc
+- avformat/mov: Fix extradata memleak
+- lavc/libopusdec: Allow avcodec_open2 to call .close
+- avcodec/movtextdec: Check style_start/end
+- avcodec/aacsbr_fixed: Fix integer overflow in sbr_hf_assemble()
+- libavcodec/rv34: error out earlier on missing references
+- swresample/swresample: Fix for seg fault in swr_convert_internal() -> sum2_float during dithering.
+- avcodec/aacdec_fixed: Fix integer overflow in apply_independent_coupling_fixed()
+- avcodec/cscd: Error out when LZ* decompression fails
+- avcodec/imgconvert: Fix loss mask bug in avcodec_find_best_pix_fmt_of_list()
+- avfilter/vf_signature: use av_strlcpy()
+- avcodec/utvideodec: Set pro flag based on fourcc
+- avcodec/wmalosslessdec: Fix null pointer dereference in decode_frame()
+- avcodec/tableprint_vlc: Fix build failure with --enable-hardcoded-tables
+- avformat/mov: Move +1 in check to avoid hypothetical overflow in add_ctts_entry()
+- avcodec/get_bits: Make sure the input bitstream with padding can be addressed
+- avformat/mov: Check STSC and remove invalid entries
+- avcodec/nuv: rtjpeg with dimensions less than 16 would result in no decoded pixels thus reject it
+- avcodec/nuv: Check for minimum input size for uncomprssed and rtjpeg
+- avcodec/wmalosslessdec: Reset num_saved_bits on error path
+- avformat/mov: Fix integer overflows related to sample_duration
+- avformat/img2dec: fix infinite loop
+- avformat/oggparsedaala: Do not adjust AV_NOPTS_VALUE
+- avformat/oggparseogm: Check lb against psize
+- avformat/oggparseogm: Fix undefined shift in ogm_packet()
+- avformat/avidec: Fix integer overflow in cum_len check
+- avformat/oggparsetheora: Do not adjust AV_NOPTS_VALUE
+- avformat/utils: Fix integer overflow of fps_first/last_dts
+- avformat/oggdec: Fix metadata memleak on multiple headers
+- libavformat/oggparsevorbis: Fix memleak on multiple headers
+- avformat/mov: Fix integer overflow in mov_get_stsc_samples()
+- avcodec/truemotion2rt: Check input buffer size
+- avcodec/g2meet: Check tile dimensions with av_image_check_size2()
+- avcodec/exr: fix invalid shift in unpack_14()
+- avcodec/bintext: sanity check dimensions
+- avcodec/utvideodec: Check subsample factors
+- avcodec/smc: Check input packet size
+- avcodec/cavsdec: Check alpha/beta offset
+- avcodec/diracdec: Fix integer overflow in mv computation
+- avcodec/h264_parse: Clear invalid chroma weights in ff_h264_pred_weight_table()
+- avcodec/aacdec_templat: Fix integer overflow in apply_ltp()
+- avcodec/jpeg2000dwt: Fix integer overflows in sr_1d53()
+- avcodec/diracdec: Use int64 in global mv to prevent overflow
+- avcodec/dxtory: Remove code that corrupts dimensions
+- avcodec/dirac_dwt_template: Fix Integer overflow in horizontal_compose_dd137i()
+- avcodec/hevcdec: Check luma/chroma_log2_weight_denom
+- avcodec/jpeg2000dec: Use av_image_check_size2()
+- avcodec/vp8: Check for bitstream end before vp7_fade_frame()
+- avcodec/exr: Check remaining bits in last get code loop
+- avutil/common: Fix integer overflow in av_clip_uint8_c() and av_clip_uint16_c()
+- avdevice/decklink_dec: Fix ;;
+- avcodec/h264_cabac: Tighten allowed coeff_abs range
+- avcodec/h264_cavlc: Set valid qscale value in ff_h264_decode_mb_cavlc()
+- avdevice/iec61883: free the private context at the end
+- avdevice/iec61883: return reference counted packets
+- configure: add nvcc to CMDLINE_SET
+- avcodec/mpeg4_unpack_bframes: make sure the packet is writable when data needs to be changed
+- avcodec/mp3_header_decompress: don't free the user provided packet on error
+- avcodec/extract_extradata: zero initalize the padding bytes in all allocated buffers
+- avformat/hvcc: zero initialize the nal buffers past the last written byte
+- swresample/rematrix: fix update of channel matrix if input or output layout is undefined
+- avformat/matroskadec: ignore CodecPrivate if the stream is VP9
 
+version 3.4.2:
+- avcodec/vp3: Error out on invalid num_coeffs in unpack_vlcs()
+- avcodec/mpeg4videodec: Ignore multiple VOL headers
+- avcodec/vp3: Check eob_run
+- avcodec/pafvideo: Check allocated frame size
+- avcodec/scpr: Fix reading a pixel before the first
+- avcodec/mpeg2dec: Fix field selection for skipped macroblocks
+- avcodec/huffyuvdec: Check input buffer size
+- avcodec/utvideodec: Fix bytes left check in decode_frame()
+- avcodec/wavpack: Fix integer overflow in FFABS
+- avcodec/aacsbr_fixed: Fix overflows in rounding in sbr_hf_assemble()
+- avcodec/exr: Fix memleaks in decode_header()
+- avcodec/mediacodecdec: use ff_hevc_ps_uninit()
+- avcodec/hevc_parser: use ff_hevc_uninit_parameter_sets()
+- avcodec/hevcdec: use ff_hevc_uninit_parameter_sets()
+- avcodec/hevc_ps: add a function to uninitialize parameter set buffers
+- avcodec/dirac_dwt: Fix several integer overflows
+- avcodec/indeo5: Do not leave frame_type set to an invalid value
+- avcodec/hevc_ps: Check log2_sao_offset_scale_*
+- avcodec/mpeg4videodec: Avoid possibly aliasing violating casts
+- avcodec/get_bits: Document the return code of get_vlc2()
+- avcodec/mpeg4videodec: Check mb_num also against 0
+- avfilter/vf_transpose: Fix used plane count.
+- avcodec/hevc_cabac: Check prefix so as to avoid invalid shifts in coeff_abs_level_remaining_decode()
+- avcodec/mjpegdec: Fix integer overflow in DC dequantization
+- avcodec/dxtory: Fix bits left checks
+- avcodec/hevc_cabac: Move prefix check in coeff_abs_level_remaining_decode() down
+- avcodec/truemotion2: Fix integer overflow in TM2_RECALC_BLOCK()
+- avcodec/snowdec: Fix integer overflow before htaps check
+- avcodec/ulti: Check number of blocks at init
+- avcodec/wavpack: Fix integer overflows in wv_unpack_stereo / mono
+- avcodec/jpeg2000: Check sum of sizes of band->prec before allocating
+- avcodec/ac3dec_fixed: Fix integer overflow in scale_coefs()
+- avformat/lrcdec: Fix memory leak in lrc_read_header()
+- avformat/matroskadec: Fix float-cast-overflow undefined behavior in matroska_parse_tracks()
+- lavfi/deinterlace_vaapi: fix can't show full option information.
+- configure:version 3.4.1: bump year
+- avcodec/utils: Avoid hardcoding duplicated types in sizeof()
+- avcodec/arm/sbrdsp_neon: Use a free register instead of putting 2 things in one
+- avcodec/h264addpx_template: Fixes integer overflows
+- avcodec/dirac_dwt: Fix overflows in COMPOSE_HAARiH0/COMPOSE_HAARiL0
+- avcodec/diracdec: Fix integer overflow with quant
+- avcodec/opus_parser: Check payload_len in parse_opus_ts_header()
+- avcodec/jpeg2000dsp: Fix integer overflows in ict_int()
+- avcodec/h264_slice: Do not attempt to render into frames already output
+- avcodec/dnxhddec: Check dc vlc
+- avcodec/exr: Check buf_size more completely
+- avcodec/flacdec: Fix overflow in multiplication in decode_subframe_fixed()
+- avcodec/hevcdsp_template: Fix Invalid shifts in put_hevc_qpel_bi_w_h() and put_hevc_qpel_bi_w_w()
+- avcodec/flacdec: avoid undefined shift
+- avcodec/hevcdsp_template.c: Fix undefined shift in FUNC(dequant)
+- avcodec/dirac_dwt: Fix integer overflow in COMPOSE_DD97iH0() and COMPOSE_DD137iL0()
+- avcodec/hevc_cabac: Fix integer overflow in ff_hevc_cu_qp_delta_abs()
+- tests/audiomatch: Add missing return code at the end of main()
+- avcodec/hevc_sei: Fix integer overflows in decode_nal_sei_message()
+- avcodec/hevcdsp_template: Fix undefined shift in put_hevc_qpel_bi_w_hv()
+- avcodec/h264_parse: Treat escaped and unescaped decoding error equal in decode_extradata_ps_mp4()
+- avcodec/vp9: mark frame as finished on decode_tiles() failure
+- libavfilter/af_dcshift.c: Fixed repeated spelling error
+- avfilter/formats: fix wrong function name in error message
 
-version 4.0:
-- 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.
-- VDA dropped (use VideoToolbox instead)
-- MagicYUV encoder
-- Raw AMR-NB and AMR-WB demuxers
-- TiVo ty/ty+ demuxer
-- Intel QSV-accelerated MJPEG encoding
-- PCE support for extended channel layouts in the AAC encoder
-- native aptX and aptX HD encoder and decoder
-- Raw aptX and aptX HD muxer and demuxer
-- NVIDIA NVDEC-accelerated H.264, HEVC, MJPEG, MPEG-1/2/4, VC1, VP8/9 hwaccel decoding
-- Intel QSV-accelerated overlay filter
-- mcompand audio filter
-- acontrast audio filter
-- OpenCL overlay filter
-- video mix filter
-- video normalize filter
-- audio lv2 wrapper filter
-- VAAPI MJPEG and VP8 decoding
-- AMD AMF H.264 and HEVC encoders
-- video fillborders filter
-- video setrange filter
-- nsp demuxer
-- support LibreSSL (via libtls)
-- AVX-512/ZMM support added
-- Dropped support for building for Windows XP. The minimum supported Windows
-  version is Windows Vista.
-- deconvolve video filter
-- entropy video filter
-- hilbert audio filter source
-- aiir audio filter
-- aiff: add support for CD-ROM XA ADPCM
-- Removed the ffserver program
-- Removed the ffmenc and ffmdec muxer and demuxer
-- VideoToolbox HEVC encoder and hwaccel
-- VAAPI-accelerated ProcAmp (color balance), denoise and sharpness filters
-- Add android_camera indev
-- codec2 en/decoding via libcodec2
-- muxer/demuxer for raw codec2 files and .c2 files
-- Moved nvidia codec headers into an external repository.
-  They can be found at http://git.videolan.org/?p=ffmpeg/nv-codec-headers.git
-- native SBC encoder and decoder
-- drmeter audio filter
-- hapqa_extract bitstream filter
-- filter_units bitstream filter
-- AV1 Support through libaom
-- E-AC-3 dependent frames support
-- bitstream filter for extracting E-AC-3 core
-- Haivision SRT protocol via libsrt
-- segafilm muxer
-- vfrdet filter
-
+version 3.4.1:
+- avcodec/vp9_superframe_split_bsf: Fix integer overflow in frame_size/total_size checks
+- avcodec/amrwbdec: Fix division by 0 in voice_factor()
+- avformat/utils: Fix warning: ISO C90 forbids mixed declarations and code
+- avcodec/decode: reset codec on receiving packet after EOF in compat_decode
+- avcodec/diracdsp: Fix integer overflow in PUT_SIGNED_RECT_CLAMPED()
+- avcodec/dirac_dwt: Fix integer overflows in COMPOSE_DAUB97*
+- avcodec/extract_extradata_bsf: Fix leak discovered via fuzzing
+- avcodec/vorbis: Fix another 1 << 31 > int32_t::max() with 1u.
+- avcodec/vorbis: 1 << 31 > int32_t::max(), so use 1u << 31 instead.
+- avformat/utils: Prevent undefined shift with wrap_bits > 64.
+- avcodec/j2kenc: Fix out of array access in encode_cblk()
+- avcodec/hevcdsp_template: Fix undefined shift in put_hevc_epel_bi_w_h()
+- lavf/mov: fix huge alloc in mov_read_ctts
+- avcodec/mlpdsp: Fix signed integer overflow, 2nd try
+- avcodec/h264idct_template: Fix integer overflow in ff_h264_idct8_add
+- avcodec/kgv1dec: Check that there is enough input for maximum RLE compression
+- avformat/aacdec: Fix leak in adts_aac_read_packet()
+- avcodec/dirac_dwt: Fix integer overflow in COMPOSE_FIDELITYi*
+- avcodec/sbrdsp_fixed: Fix integer overflow
+- avcodec/mpeg4videodec: Check also for negative versions in the validity check
+- Close ogg stream upon error when using AV_EF_EXPLODE.
+- Fix undefined shift on assumed 8-bit input.
+- Use ff_thread_once for fixed, float table init.
+- Fix leak of frame_duration_buffer in mov_fix_index().
+- avformat/mov: Propagate errors in mov_switch_root.
+- avcodec/hevcdsp_template: Fix invalid shift in put_hevc_epel_bi_w_v()
+- avcodec/mlpdsp: Fix undefined shift ff_mlp_pack_output()
+- avcodec/zmbv: Check that the buffer is large enough for mvec
+- avcodec/dirac_dwt: Fix integer overflow in COMPOSE_DD137iL0()
+- avcodec/wmv2dec: Check end of bitstream in parse_mb_skip() and ff_wmv2_decode_mb()
+- avcodec/snowdec: Check for remaining bitstream in decode_blocks()
+- avcodec/snowdec: Check intra block dc differences.
+- avformat/mov: Check size of STSC allocation
+- avcodec/vc2enc: Clear coef_buf on allocation
+- avcodec/h264dec: Fix potential array overread
+- avcodec/x86/mpegvideodsp: Fix signedness bug in need_emu
+- avcodec/aacpsdsp_template: Fix integer overflows in ps_decorrelate_c()
+- avcodec/aacdec_fixed: Fix undefined shift
+- avcodec/mdct_*: Fix integer overflow in addition in RESCALE()
+- avcodec/snowdec: Fix integer overflow in header parsing
+- avcodec/cngdec: Fix integer clipping
+- avcodec/sbrdsp_fixed: Fix integer overflow in shift in sbr_hf_g_filt_c()
+- avcodec/aacsbr_fixed: Fix division by zero in sbr_gain_calc()
+- avutil/softfloat: Add FLOAT_MIN
+- avcodec/h264idct_template: Fix integer overflows in ff_h264_idct8_add()
+- avcodec/xan: Check for bitstream end in xan_huffman_decode()
+- avcodec/exr: fix undefined shift in pxr24_uncompress()
+- avformat: Free the internal codec context at the end
+- avcodec/h264idct_template: Fix integer overflows in ff_h264_idct8_add()
+- avcodec/xan: Improve overlapping check
+- avcodec/aacdec_fixed: Fix integer overflow in apply_dependent_coupling_fixed()
+- avcodec/aacdec_fixed: Fix integer overflow in predict()
+- avcodec/jpeglsdec: Check for end of bitstream in ls_decode_line()
+- avcodec/jpeglsdec: Check ilv for being a supported value
+- tests/ffserver.regression.ref: update checksums to what ffserver currently produces
+- ffserver: Fix off by 1 error in path
+- avcodec/proresdec: align dequantization matrix buffers
+- avformat/matroskaenc: add missing allocation failure checks for stream durations
+- avformat/matroskaenc: actually enforce the stream limit
+- configure: Fix dependencies of aac_at decoder.
+- Don't manipulate duration when it's AV_NOPTS_VALUE.
+- lavfi/af_pan: fix sign handling in channel coefficient parser
+- avformat/hlsenc: write fmp4 init header after first AV frame
+- avformat/hlsenc: allocate space for terminating null
+- avformat/hlsenc: reindent hlsenc code
+- avformat/hlsenc: check hls segment mode for ignore the init filename
+- avformat/hlsenc: reindent hlsenc code
+- avformat/hlsenc: fix missing first segment bug in fmp4 mode
+- avformat/hlsenc: fix base_output_dirname is null when basename_size is 0 bug
+- ffplay: use SDL2 audio API
+- ffplay: only use hardware accelerated SDL texture formats
+- ffplay: create the window and the renderer before starting playback
+- ffmpeg: always init output stream before reaping filters
+- vc2enc_dwt: pad the temporary buffer by the slice size
+- lavu/arm: Check for have_vfp_vm instead of !have_vfpv3 for float_dsp_vfp
 
 version 3.4:
 - deflicker video filter

MAINTAINERS

@@ -29,6 +29,9 @@ ffplay:
 ffprobe:
   ffprobe.c                             Stefano Sabatini
 
+ffserver:
+  ffserver.c                            Reynaldo H. Verdejo Pinochet
+
 Commandline utility code:
   cmdutils.c, cmdutils.h                Michael Niedermayer
 
@@ -39,7 +42,7 @@ QuickTime faststart:
 Miscellaneous Areas
 ===================
 
-documentation                           Stefano Sabatini, Mike Melanson, Timothy Gu, Lou Logan, Gyan Doshi
+documentation                           Stefano Sabatini, Mike Melanson, Timothy Gu, Lou Logan
 project server                          Árpád Gereöffy, Michael Niedermayer, Reimar Doeffinger, Alexander Strasser, Nikolay Aleksandrov
 presets                                 Robert Swain
 metadata subsystem                      Aurelien Jacobs
@@ -139,7 +142,6 @@ Codecs:
   aacenc*, aaccoder.c                   Rostislav Pehlivanov
   alacenc.c                             Jaikrishnan Menon
   alsdec.c                              Thilo Borgmann, Umair Khan
-  aptx.c                                Aurelien Jacobs
   ass*                                  Aurelien Jacobs
   asv*                                  Michael Niedermayer
   atrac3plus*                           Maxim Poliakovski
@@ -156,7 +158,7 @@ Codecs:
   cpia.c                                Stephan Hilb
   crystalhd.c                           Philip Langdale
   cscd.c                                Reimar Doeffinger
-  cuviddec.c                            Timo Rothenpieler
+  cuvid.c                               Timo Rothenpieler
   dca*                                  foo86
   dirac*                                Rostislav Pehlivanov
   dnxhd*                                Baptiste Coudurier
@@ -168,7 +170,6 @@ Codecs:
   eacmv*, eaidct*, eat*                 Peter Ross
   evrc*                                 Paul B Mahol
   exif.c, exif.h                        Thilo Borgmann
-  exr.c                                 Martin Vignali
   ffv1*                                 Michael Niedermayer
   ffwavesynth.c                         Nicolas George
   fifo.c                                Jan Sebechlebsky
@@ -188,7 +189,6 @@ Codecs:
   jvdec.c                               Peter Ross
   lcl*.c                                Roberto Togni, Reimar Doeffinger
   libcelt_dec.c                         Nicolas George
-  libcodec2.c                           Tomas Härdin
   libdirac*                             David Conrad
   libgsm.c                              Michel Bardiaux
   libkvazaar.c                          Arttu Ylä-Outinen
@@ -212,7 +212,7 @@ Codecs:
   msrle.c                               Mike Melanson
   msvideo1.c                            Mike Melanson
   nuv.c                                 Reimar Doeffinger
-  nvdec*, nvenc*                        Timo Rothenpieler
+  nvenc*                                Timo Rothenpieler
   opus*                                 Rostislav Pehlivanov
   paf.*                                 Paul B Mahol
   pcx.c                                 Ivo van Poorten
@@ -242,10 +242,10 @@ Codecs:
   tta.c                                 Alex Beregszaszi, Jaikrishnan Menon
   ttaenc.c                              Paul B Mahol
   txd.c                                 Ivo van Poorten
-  v4l2_*                                Jorge Ramirez-Ortiz
   vc2*                                  Rostislav Pehlivanov
   vcr1.c                                Michael Niedermayer
-  videotoolboxenc.c                     Rick Kern, Aman Gupta
+  vda_h264_dec.c                        Xidorn Quan
+  videotoolboxenc.c                     Rick Kern
   vima.c                                Paul B Mahol
   vorbisdec.c                           Denes Balatoni, David Conrad
   vorbisenc.c                           Oded Shimon
@@ -268,11 +268,11 @@ Hardware acceleration:
   crystalhd.c                           Philip Langdale
   dxva2*                                Hendrik Leppkes, Laurent Aimar, Steve Lhomme
   d3d11va*                              Steve Lhomme
-  mediacodec*                           Matthieu Bouron, Aman Gupta
+  mediacodec*                           Matthieu Bouron
   vaapi*                                Gwenole Beauchesne
   vaapi_encode*                         Mark Thompson
   vdpau*                                Philip Langdale, Carl Eugen Hoyos
-  videotoolbox*                         Rick Kern, Aman Gupta
+  videotoolbox*                         Rick Kern
 
 
 libavdevice
@@ -282,7 +282,6 @@ libavdevice
 
 
   avfoundation.m                        Thilo Borgmann
-  android_camera.c                      Felix Matouschek
   decklink*                             Marton Balint
   dshow.c                               Roger Pack (CC rogerdpack@gmail.com)
   fbdev_enc.c                           Lukasz Marek
@@ -396,10 +395,8 @@ Muxers/Demuxers:
   brstm.c                               Paul B Mahol
   caf*                                  Peter Ross
   cdxl.c                                Paul B Mahol
-  codec2.c                              Tomas Härdin
   crc.c                                 Michael Niedermayer
   dashdec.c                             Steven Liu
-  dashenc.c                             Karthick Jeyapal
   daud.c                                Reimar Doeffinger
   dss.c                                 Oleksij Rempel
   dtsdec.c                              foo86
@@ -552,7 +549,6 @@ Ivan Uskov
 James Darnley
 Jan Ekström
 Joakim Plate
-Jun Zhao
 Kieran Kunhya
 Kirill Gavrilov
 Martin Storsjö
@@ -591,7 +587,6 @@ FFmpeg release signing key    FCF9 86EA 15E6 E293 A564 4F10 B432 2F04 D676 58D8
 Ganesh Ajjanagadde            C96A 848E 97C3 CEA2 AB72 5CE4 45F9 6A2D 3C36 FB1B
 Gwenole Beauchesne            2E63 B3A6 3E44 37E2 017D 2704 53C7 6266 B153 99C4
 Jaikrishnan Menon             61A1 F09F 01C9 2D45 78E1 C862 25DC 8831 AF70 D368
-James Almer                   7751 2E8C FD94 A169 57E6 9A7A 1463 01AD 7376 59E0
 Jean Delvare                  7CA6 9F44 60F1 BDC4 1FD2 C858 A552 6B9B B3CD 4E6A
 Loren Merritt                 ABD9 08F4 C920 3F65 D8BE 35D7 1540 DAA7 060F 56DE
 Lou Logan                     7D68 DC73 CBEF EABB 671A B6CF 621C 2E28 82F8 DC3A

Makefile

@@ -45,11 +45,12 @@ FF_DEP_LIBS  := $(DEP_LIBS)
 FF_STATIC_DEP_LIBS := $(STATIC_DEP_LIBS)
 
 $(TOOLS): %$(EXESUF): %.o
-	$(LD) $(LDFLAGS) $(LDEXEFLAGS) $(LD_O) $^ $(EXTRALIBS-$(*F)) $(EXTRALIBS) $(ELIBS)
+	$(LD) $(LDFLAGS) $(LDEXEFLAGS) $(LD_O) $^ $(ELIBS)
 
 target_dec_%_fuzzer$(EXESUF): target_dec_%_fuzzer.o $(FF_DEP_LIBS)
 	$(LD) $(LDFLAGS) $(LDEXEFLAGS) $(LD_O) $^ $(ELIBS) $(FF_EXTRALIBS) $(LIBFUZZER_PATH)
 
+tools/cws2fws$(EXESUF): ELIBS = $(ZLIB)
 tools/sofa2wavs$(EXESUF): ELIBS = $(FF_EXTRALIBS)
 tools/uncoded_frame$(EXESUF): $(FF_DEP_LIBS)
 tools/uncoded_frame$(EXESUF): ELIBS = $(FF_EXTRALIBS)
@@ -127,24 +128,25 @@ install-data: $(DATA_FILES)
 	$(Q)mkdir -p "$(DATADIR)"
 	$(INSTALL) -m 644 $(DATA_FILES) "$(DATADIR)"
 
-uninstall: uninstall-data uninstall-headers uninstall-libs uninstall-pkgconfig
+uninstall: uninstall-libs uninstall-headers uninstall-data
 
 uninstall-data:
 	$(RM) -r "$(DATADIR)"
 
 clean::
 	$(RM) $(CLEANSUFFIXES)
-	$(RM) $(addprefix compat/,$(CLEANSUFFIXES)) $(addprefix compat/*/,$(CLEANSUFFIXES))
+	$(RM) $(CLEANSUFFIXES:%=compat/msvcrt/%)
+	$(RM) $(CLEANSUFFIXES:%=compat/atomics/pthread/%)
+	$(RM) $(CLEANSUFFIXES:%=compat/%)
 	$(RM) -r coverage-html
 	$(RM) -rf coverage.info coverage.info.in lcov
 
-distclean:: clean
+distclean::
+	$(RM) $(DISTCLEANSUFFIXES)
 	$(RM) .version avversion.h config.asm config.h mapfile  \
 		ffbuild/.config ffbuild/config.* libavutil/avconfig.h \
 		version.h libavutil/ffversion.h libavcodec/codec_names.h \
-		libavcodec/bsf_list.c libavformat/protocol_list.c \
-		libavcodec/codec_list.c libavcodec/parser_list.c \
-		libavformat/muxer_list.c libavformat/demuxer_list.c
+		libavcodec/bsf_list.c libavformat/protocol_list.c
 ifeq ($(SRC_LINK),src)
 	$(RM) src
 endif
@@ -153,7 +155,6 @@ endif
 config:
 	$(SRC_PATH)/configure $(value FFMPEG_CONFIGURATION)
 
-build: all alltools examples testprogs
 check: all alltools examples testprogs fate
 
 include $(SRC_PATH)/tests/Makefile
@@ -169,5 +170,4 @@ $(sort $(OBJDIRS)):
 # so this saves some time on slow systems.
 .SUFFIXES:
 
-.PHONY: all all-yes alltools build check config testprogs
-.PHONY: *clean install* uninstall*
+.PHONY: all all-yes alltools check *clean config install* testprogs uninstall*

README.md

@@ -21,6 +21,8 @@ such as audio, video, subtitles and related metadata.
 * [ffplay](https://ffmpeg.org/ffplay.html) is a minimalistic multimedia player.
 * [ffprobe](https://ffmpeg.org/ffprobe.html) is a simple analysis tool to inspect
   multimedia content.
+* [ffserver](https://ffmpeg.org/ffserver.html) is a multimedia streaming server
+  for live broadcasts.
 * Additional small tools such as `aviocat`, `ismindex` and `qt-faststart`.
 
 ## Documentation

RELEASE

@@ -1 +1 @@
-4.0.1
+3.4.4

RELEASE_NOTES

@@ -1,13 +1,13 @@
 
-              ┌───────────────────────────────────┐
-              │ RELEASE NOTES for FFmpeg 4.0 "Wu" │
-              └───────────────────────────────────┘
+              ┌───────────────────────────────────────┐
+              │ RELEASE NOTES for FFmpeg 3.4 "Cantor" │
+              └───────────────────────────────────────┘
 
-   The FFmpeg Project proudly presents FFmpeg 4.0 "Wu", about 6
-   months after the release of FFmpeg 3.4.
+   The FFmpeg Project proudly presents FFmpeg 3.4 "Cantor", about 6
+   months after the release of FFmpeg 3.3.
 
    A complete Changelog is available at the root of the project, and the
-   complete Git history on https://git.ffmpeg.org/gitweb/ffmpeg.git
+   complete Git history on http://source.ffmpeg.org.
 
    We hope you will like this release as much as we enjoyed working on it, and
    as usual, if you have any questions about it, or any FFmpeg related topic,

compat/cuda/dynlink_cuda.h

@@ -0,0 +1,98 @@
+/*
+ * This copyright notice applies to this header file only:
+ *
+ * Copyright (c) 2016
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the software, and to permit persons to whom the
+ * software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#if !defined(AV_COMPAT_DYNLINK_CUDA_H) && !defined(CUDA_VERSION)
+#define AV_COMPAT_DYNLINK_CUDA_H
+
+#include <stddef.h>
+
+#define CUDA_VERSION 7050
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+#define CUDAAPI __stdcall
+#else
+#define CUDAAPI
+#endif
+
+#define CU_CTX_SCHED_BLOCKING_SYNC 4
+
+typedef int CUdevice;
+typedef void* CUarray;
+typedef void* CUcontext;
+typedef void* CUstream;
+#if defined(__x86_64) || defined(AMD64) || defined(_M_AMD64)
+typedef unsigned long long CUdeviceptr;
+#else
+typedef unsigned int CUdeviceptr;
+#endif
+
+typedef enum cudaError_enum {
+    CUDA_SUCCESS = 0
+} CUresult;
+
+typedef enum CUmemorytype_enum {
+    CU_MEMORYTYPE_HOST = 1,
+    CU_MEMORYTYPE_DEVICE = 2
+} CUmemorytype;
+
+typedef struct CUDA_MEMCPY2D_st {
+    size_t srcXInBytes;
+    size_t srcY;
+    CUmemorytype srcMemoryType;
+    const void *srcHost;
+    CUdeviceptr srcDevice;
+    CUarray srcArray;
+    size_t srcPitch;
+
+    size_t dstXInBytes;
+    size_t dstY;
+    CUmemorytype dstMemoryType;
+    void *dstHost;
+    CUdeviceptr dstDevice;
+    CUarray dstArray;
+    size_t dstPitch;
+
+    size_t WidthInBytes;
+    size_t Height;
+} CUDA_MEMCPY2D;
+
+typedef CUresult CUDAAPI tcuInit(unsigned int Flags);
+typedef CUresult CUDAAPI tcuDeviceGetCount(int *count);
+typedef CUresult CUDAAPI tcuDeviceGet(CUdevice *device, int ordinal);
+typedef CUresult CUDAAPI tcuDeviceGetName(char *name, int len, CUdevice dev);
+typedef CUresult CUDAAPI tcuDeviceComputeCapability(int *major, int *minor, CUdevice dev);
+typedef CUresult CUDAAPI tcuCtxCreate_v2(CUcontext *pctx, unsigned int flags, CUdevice dev);
+typedef CUresult CUDAAPI tcuCtxPushCurrent_v2(CUcontext *pctx);
+typedef CUresult CUDAAPI tcuCtxPopCurrent_v2(CUcontext *pctx);
+typedef CUresult CUDAAPI tcuCtxDestroy_v2(CUcontext ctx);
+typedef CUresult CUDAAPI tcuMemAlloc_v2(CUdeviceptr *dptr, size_t bytesize);
+typedef CUresult CUDAAPI tcuMemFree_v2(CUdeviceptr dptr);
+typedef CUresult CUDAAPI tcuMemcpy2D_v2(const CUDA_MEMCPY2D *pcopy);
+typedef CUresult CUDAAPI tcuGetErrorName(CUresult error, const char** pstr);
+typedef CUresult CUDAAPI tcuGetErrorString(CUresult error, const char** pstr);
+
+#endif

compat/cuda/dynlink_cuviddec.h

@@ -0,0 +1,886 @@
+/*
+ * This copyright notice applies to this header file only:
+ *
+ * Copyright (c) 2010-2017 NVIDIA Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the software, and to permit persons to whom the
+ * software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*****************************************************************************************************/
+//! \file cuviddec.h
+//! NVDECODE API provides video decoding interface to NVIDIA GPU devices.
+//! \date 2015-2017
+//! This file contains constants, structure definitions and function prototypes used for decoding.
+/*****************************************************************************************************/
+
+#if !defined(__CUDA_VIDEO_H__)
+#define __CUDA_VIDEO_H__
+
+#if defined(_WIN64) || defined(__LP64__) || defined(__x86_64) || defined(AMD64) || defined(_M_AMD64)
+#if (CUDA_VERSION >= 3020) && (!defined(CUDA_FORCE_API_VERSION) || (CUDA_FORCE_API_VERSION >= 3020))
+#define __CUVID_DEVPTR64
+#endif
+#endif
+
+#if defined(__cplusplus)
+extern "C" {
+#endif /* __cplusplus */
+
+#if defined(__CYGWIN__)
+typedef unsigned int tcu_ulong;
+#else
+typedef unsigned long tcu_ulong;
+#endif
+
+typedef void *CUvideodecoder;
+typedef struct _CUcontextlock_st *CUvideoctxlock;
+
+/*********************************************************************************/
+//! \enum cudaVideoCodec
+//! Video codec enums
+//! These enums are used in CUVIDDECODECREATEINFO and CUVIDDECODECAPS structures
+/*********************************************************************************/
+typedef enum cudaVideoCodec_enum {
+    cudaVideoCodec_MPEG1=0,                                         /**<  MPEG1             */
+    cudaVideoCodec_MPEG2,                                           /**<  MPEG2             */
+    cudaVideoCodec_MPEG4,                                           /**<  MPEG4             */
+    cudaVideoCodec_VC1,                                             /**<  VC1               */
+    cudaVideoCodec_H264,                                            /**<  H264              */
+    cudaVideoCodec_JPEG,                                            /**<  JPEG              */
+    cudaVideoCodec_H264_SVC,                                        /**<  H264-SVC          */
+    cudaVideoCodec_H264_MVC,                                        /**<  H264-MVC          */
+    cudaVideoCodec_HEVC,                                            /**<  HEVC              */
+    cudaVideoCodec_VP8,                                             /**<  VP8               */
+    cudaVideoCodec_VP9,                                             /**<  VP9               */
+    cudaVideoCodec_NumCodecs,                                       /**<  Max codecs        */
+    // Uncompressed YUV
+    cudaVideoCodec_YUV420 = (('I'<<24)|('Y'<<16)|('U'<<8)|('V')),   /**< Y,U,V (4:2:0)      */
+    cudaVideoCodec_YV12   = (('Y'<<24)|('V'<<16)|('1'<<8)|('2')),   /**< Y,V,U (4:2:0)      */
+    cudaVideoCodec_NV12   = (('N'<<24)|('V'<<16)|('1'<<8)|('2')),   /**< Y,UV  (4:2:0)      */
+    cudaVideoCodec_YUYV   = (('Y'<<24)|('U'<<16)|('Y'<<8)|('V')),   /**< YUYV/YUY2 (4:2:2)  */
+    cudaVideoCodec_UYVY   = (('U'<<24)|('Y'<<16)|('V'<<8)|('Y'))    /**< UYVY (4:2:2)       */
+} cudaVideoCodec;
+
+/*********************************************************************************/
+//! \enum cudaVideoSurfaceFormat
+//! Video surface format enums used for output format of decoded output
+//! These enums are used in CUVIDDECODECREATEINFO structure
+/*********************************************************************************/
+typedef enum cudaVideoSurfaceFormat_enum {
+    cudaVideoSurfaceFormat_NV12=0,       /**< NV12 format          */
+    cudaVideoSurfaceFormat_P016=1        /**< 16 bit semiplaner format. Can be used for 10 bit(6LSB bits 0),
+                                              12 bit (4LSB bits 0) */
+} cudaVideoSurfaceFormat;
+
+/******************************************************************************************************************/
+//! \enum cudaVideoDeinterlaceMode
+//! Deinterlacing mode enums
+//! These enums are used in CUVIDDECODECREATEINFO structure
+//! Use cudaVideoDeinterlaceMode_Weave for progressive content and for content that doesn't need deinterlacing
+//! cudaVideoDeinterlaceMode_Adaptive needs more video memory than other DImodes
+/******************************************************************************************************************/
+typedef enum cudaVideoDeinterlaceMode_enum {
+    cudaVideoDeinterlaceMode_Weave=0,   /**< Weave both fields (no deinterlacing) */
+    cudaVideoDeinterlaceMode_Bob,       /**< Drop one field                       */
+    cudaVideoDeinterlaceMode_Adaptive   /**< Adaptive deinterlacing               */
+} cudaVideoDeinterlaceMode;
+
+/**************************************************************************************************************/
+//! \enum cudaVideoChromaFormat
+//! Chroma format enums
+//! These enums are used in CUVIDDECODECREATEINFO and CUVIDDECODECAPS structures
+//! JPEG supports Monochrome, YUV 4:2:0, YUV 4:2:2 and YUV 4:4:4 chroma formats.
+//! H264, HEVC, VP9, VP8, VC1, MPEG1, MPEG2 and MPEG4 support YUV 4:2:0 chroma format only.
+/**************************************************************************************************************/
+typedef enum cudaVideoChromaFormat_enum {
+    cudaVideoChromaFormat_Monochrome=0,  /**< MonoChrome */
+    cudaVideoChromaFormat_420,           /**< YUV 4:2:0  */
+    cudaVideoChromaFormat_422,           /**< YUV 4:2:2  */
+    cudaVideoChromaFormat_444            /**< YUV 4:4:4  */
+} cudaVideoChromaFormat;
+
+/*************************************************************************************************************/
+//! \enum cudaVideoCreateFlags
+//! Decoder flag enums to select preferred decode path
+//! cudaVideoCreate_Default and cudaVideoCreate_PreferCUVID are most optimized, use these whenever possible
+/*************************************************************************************************************/
+typedef enum cudaVideoCreateFlags_enum {
+    cudaVideoCreate_Default     = 0x00,     /**< Default operation mode: use dedicated video engines                        */
+    cudaVideoCreate_PreferCUDA  = 0x01,     /**< Use CUDA-based decoder (requires valid vidLock object for multi-threading) */
+    cudaVideoCreate_PreferDXVA  = 0x02,     /**< Go through DXVA internally if possible (requires D3D9 interop)             */
+    cudaVideoCreate_PreferCUVID = 0x04      /**< Use dedicated video engines directly                                       */
+} cudaVideoCreateFlags;
+
+
+/**************************************************************************************************************/
+//! \struct CUVIDDECODECAPS;
+//! This structure is used in cuvidGetDecoderCaps API
+/**************************************************************************************************************/
+typedef struct _CUVIDDECODECAPS
+{
+    cudaVideoCodec          eCodecType;                 /**< IN: cudaVideoCodec_XXX                                 */
+    cudaVideoChromaFormat   eChromaFormat;              /**< IN: cudaVideoChromaFormat_XXX                          */
+    unsigned int            nBitDepthMinus8;            /**< IN: The Value "BitDepth minus 8"                       */
+    unsigned int            reserved1[3];               /**< Reserved for future use - set to zero                  */
+
+    unsigned char           bIsSupported;               /**< OUT: 1 if codec supported, 0 if not supported          */
+    unsigned char           reserved2[3];               /**< Reserved for future use - set to zero                  */
+    unsigned int            nMaxWidth;                  /**< OUT: Max supported coded width in pixels               */
+    unsigned int            nMaxHeight;                 /**< OUT: Max supported coded height in pixels              */
+    unsigned int            nMaxMBCount;                /**< OUT: Max supported macroblock count
+                                                                  CodedWidth*CodedHeight/256 must be <= nMaxMBCount */
+    unsigned short          nMinWidth;                  /**< OUT: Min supported coded width in pixels               */
+    unsigned short          nMinHeight;                 /**< OUT: Min supported coded height in pixels              */
+    unsigned int            reserved3[11];              /**< Reserved for future use - set to zero                  */
+} CUVIDDECODECAPS;
+
+/**************************************************************************************************************/
+//! \struct CUVIDDECODECREATEINFO
+//! This structure is used in cuvidCreateDecoder API
+/**************************************************************************************************************/
+typedef struct _CUVIDDECODECREATEINFO
+{
+    tcu_ulong ulWidth;                  /**< IN: Coded sequence width in pixels                                             */
+    tcu_ulong ulHeight;                 /**< IN: Coded sequence height in pixels                                            */
+    tcu_ulong ulNumDecodeSurfaces;      /**< IN: Maximum number of internal decode surfaces                                 */
+    cudaVideoCodec CodecType;           /**< IN: cudaVideoCodec_XXX                                                         */
+    cudaVideoChromaFormat ChromaFormat; /**< IN: cudaVideoChromaFormat_XXX                                                  */
+    tcu_ulong ulCreationFlags;          /**< IN: Decoder creation flags (cudaVideoCreateFlags_XXX)                          */
+    tcu_ulong bitDepthMinus8;           /**< IN: The value "BitDepth minus 8"                                               */
+    tcu_ulong ulIntraDecodeOnly;        /**< IN: Set 1 only if video has all intra frames (default value is 0). This will
+                                             optimize video memory for Intra frames only decoding. The support is limited
+                                             to specific codecs(H264 rightnow), the flag will be ignored for codecs which
+                                             are not supported. However decoding might fail if the flag is enabled in case
+                                             of supported codecs for regular bit streams having P and/or B frames.          */
+    tcu_ulong Reserved1[3];             /**< Reserved for future use - set to zero                                          */
+    /**
+    * IN: area of the frame that should be displayed
+    */
+    struct {
+        short left;
+        short top;
+        short right;
+        short bottom;
+    } display_area;
+
+    cudaVideoSurfaceFormat OutputFormat;       /**< IN: cudaVideoSurfaceFormat_XXX                                     */
+    cudaVideoDeinterlaceMode DeinterlaceMode;  /**< IN: cudaVideoDeinterlaceMode_XXX                                   */
+    tcu_ulong ulTargetWidth;                   /**< IN: Post-processed output width (Should be aligned to 2)           */
+    tcu_ulong ulTargetHeight;                  /**< IN: Post-processed output height (Should be aligbed to 2)          */
+    tcu_ulong ulNumOutputSurfaces;             /**< IN: Maximum number of output surfaces simultaneously mapped        */
+    CUvideoctxlock vidLock;                    /**< IN: If non-NULL, context lock used for synchronizing ownership of
+                                                    the cuda context. Needed for cudaVideoCreate_PreferCUDA decode     */
+    /**
+    * IN: target rectangle in the output frame (for aspect ratio conversion)
+    * if a null rectangle is specified, {0,0,ulTargetWidth,ulTargetHeight} will be used
+    */
+    struct {
+        short left;
+        short top;
+        short right;
+        short bottom;
+    } target_rect;
+    tcu_ulong Reserved2[5];                    /**< Reserved for future use - set to zero */
+} CUVIDDECODECREATEINFO;
+
+/*********************************************************/
+//! \struct CUVIDH264DPBENTRY
+//! H.264 DPB entry
+//! This structure is used in CUVIDH264PICPARAMS structure
+/*********************************************************/
+typedef struct _CUVIDH264DPBENTRY
+{
+    int PicIdx;                 /**< picture index of reference frame                                        */
+    int FrameIdx;               /**< frame_num(short-term) or LongTermFrameIdx(long-term)                    */
+    int is_long_term;           /**< 0=short term reference, 1=long term reference                           */
+    int not_existing;           /**< non-existing reference frame (corresponding PicIdx should be set to -1) */
+    int used_for_reference;     /**< 0=unused, 1=top_field, 2=bottom_field, 3=both_fields                    */
+    int FieldOrderCnt[2];       /**< field order count of top and bottom fields                              */
+} CUVIDH264DPBENTRY;
+
+/************************************************************/
+//! \struct CUVIDH264MVCEXT
+//! H.264 MVC picture parameters ext
+//! This structure is used in CUVIDH264PICPARAMS structure
+/************************************************************/
+typedef struct _CUVIDH264MVCEXT
+{
+    int num_views_minus1;                  /**< Max number of coded views minus 1 in video : Range - 0 to 1023              */
+    int view_id;                           /**< view identifier                                                             */
+    unsigned char inter_view_flag;         /**< 1 if used for inter-view prediction, 0 if not                               */
+    unsigned char num_inter_view_refs_l0;  /**< number of inter-view ref pics in RefPicList0                                */
+    unsigned char num_inter_view_refs_l1;  /**< number of inter-view ref pics in RefPicList1                                */
+    unsigned char MVCReserved8Bits;        /**< Reserved bits                                                               */
+    int InterViewRefsL0[16];               /**< view id of the i-th view component for inter-view prediction in RefPicList0 */
+    int InterViewRefsL1[16];               /**< view id of the i-th view component for inter-view prediction in RefPicList1 */
+} CUVIDH264MVCEXT;
+
+/*********************************************************/
+//! \struct CUVIDH264SVCEXT
+//! H.264 SVC picture parameters ext
+//! This structure is used in CUVIDH264PICPARAMS structure
+/*********************************************************/
+typedef struct _CUVIDH264SVCEXT
+{
+    unsigned char profile_idc;
+    unsigned char level_idc;
+    unsigned char DQId;
+    unsigned char DQIdMax;
+    unsigned char disable_inter_layer_deblocking_filter_idc;
+    unsigned char ref_layer_chroma_phase_y_plus1;
+    signed char   inter_layer_slice_alpha_c0_offset_div2;
+    signed char   inter_layer_slice_beta_offset_div2;
+
+    unsigned short DPBEntryValidFlag;
+    unsigned char inter_layer_deblocking_filter_control_present_flag;
+    unsigned char extended_spatial_scalability_idc;
+    unsigned char adaptive_tcoeff_level_prediction_flag;
+    unsigned char slice_header_restriction_flag;
+    unsigned char chroma_phase_x_plus1_flag;
+    unsigned char chroma_phase_y_plus1;
+
+    unsigned char tcoeff_level_prediction_flag;
+    unsigned char constrained_intra_resampling_flag;
+    unsigned char ref_layer_chroma_phase_x_plus1_flag;
+    unsigned char store_ref_base_pic_flag;
+    unsigned char Reserved8BitsA;
+    unsigned char Reserved8BitsB;
+
+    short scaled_ref_layer_left_offset;
+    short scaled_ref_layer_top_offset;
+    short scaled_ref_layer_right_offset;
+    short scaled_ref_layer_bottom_offset;
+    unsigned short Reserved16Bits;
+    struct _CUVIDPICPARAMS *pNextLayer; /**< Points to the picparams for the next layer to be decoded.
+                                             Linked list ends at the target layer. */
+    int bRefBaseLayer;                  /**< whether to store ref base pic */
+} CUVIDH264SVCEXT;
+
+/******************************************************/
+//! \struct CUVIDH264PICPARAMS
+//! H.264 picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/******************************************************/
+typedef struct _CUVIDH264PICPARAMS
+{
+    // SPS
+    int log2_max_frame_num_minus4;
+    int pic_order_cnt_type;
+    int log2_max_pic_order_cnt_lsb_minus4;
+    int delta_pic_order_always_zero_flag;
+    int frame_mbs_only_flag;
+    int direct_8x8_inference_flag;
+    int num_ref_frames;             // NOTE: shall meet level 4.1 restrictions
+    unsigned char residual_colour_transform_flag;
+    unsigned char bit_depth_luma_minus8;    // Must be 0 (only 8-bit supported)
+    unsigned char bit_depth_chroma_minus8;  // Must be 0 (only 8-bit supported)
+    unsigned char qpprime_y_zero_transform_bypass_flag;
+    // PPS
+    int entropy_coding_mode_flag;
+    int pic_order_present_flag;
+    int num_ref_idx_l0_active_minus1;
+    int num_ref_idx_l1_active_minus1;
+    int weighted_pred_flag;
+    int weighted_bipred_idc;
+    int pic_init_qp_minus26;
+    int deblocking_filter_control_present_flag;
+    int redundant_pic_cnt_present_flag;
+    int transform_8x8_mode_flag;
+    int MbaffFrameFlag;
+    int constrained_intra_pred_flag;
+    int chroma_qp_index_offset;
+    int second_chroma_qp_index_offset;
+    int ref_pic_flag;
+    int frame_num;
+    int CurrFieldOrderCnt[2];
+    // DPB
+    CUVIDH264DPBENTRY dpb[16];          // List of reference frames within the DPB
+    // Quantization Matrices (raster-order)
+    unsigned char WeightScale4x4[6][16];
+    unsigned char WeightScale8x8[2][64];
+    // FMO/ASO
+    unsigned char fmo_aso_enable;
+    unsigned char num_slice_groups_minus1;
+    unsigned char slice_group_map_type;
+    signed char pic_init_qs_minus26;
+    unsigned int slice_group_change_rate_minus1;
+    union
+    {
+        unsigned long long slice_group_map_addr;
+        const unsigned char *pMb2SliceGroupMap;
+    } fmo;
+    unsigned int Reserved[12];
+    // SVC/MVC
+    union
+    {
+        CUVIDH264MVCEXT mvcext;
+        CUVIDH264SVCEXT svcext;
+    };
+} CUVIDH264PICPARAMS;
+
+
+/********************************************************/
+//! \struct CUVIDMPEG2PICPARAMS
+//! MPEG-2 picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/********************************************************/
+typedef struct _CUVIDMPEG2PICPARAMS
+{
+    int ForwardRefIdx;          // Picture index of forward reference (P/B-frames)
+    int BackwardRefIdx;         // Picture index of backward reference (B-frames)
+    int picture_coding_type;
+    int full_pel_forward_vector;
+    int full_pel_backward_vector;
+    int f_code[2][2];
+    int intra_dc_precision;
+    int frame_pred_frame_dct;
+    int concealment_motion_vectors;
+    int q_scale_type;
+    int intra_vlc_format;
+    int alternate_scan;
+    int top_field_first;
+    // Quantization matrices (raster order)
+    unsigned char QuantMatrixIntra[64];
+    unsigned char QuantMatrixInter[64];
+} CUVIDMPEG2PICPARAMS;
+
+// MPEG-4 has VOP types instead of Picture types
+#define I_VOP 0
+#define P_VOP 1
+#define B_VOP 2
+#define S_VOP 3
+
+/*******************************************************/
+//! \struct CUVIDMPEG4PICPARAMS
+//! MPEG-4 picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/*******************************************************/
+typedef struct _CUVIDMPEG4PICPARAMS
+{
+    int ForwardRefIdx;          // Picture index of forward reference (P/B-frames)
+    int BackwardRefIdx;         // Picture index of backward reference (B-frames)
+    // VOL
+    int video_object_layer_width;
+    int video_object_layer_height;
+    int vop_time_increment_bitcount;
+    int top_field_first;
+    int resync_marker_disable;
+    int quant_type;
+    int quarter_sample;
+    int short_video_header;
+    int divx_flags;
+    // VOP
+    int vop_coding_type;
+    int vop_coded;
+    int vop_rounding_type;
+    int alternate_vertical_scan_flag;
+    int interlaced;
+    int vop_fcode_forward;
+    int vop_fcode_backward;
+    int trd[2];
+    int trb[2];
+    // Quantization matrices (raster order)
+    unsigned char QuantMatrixIntra[64];
+    unsigned char QuantMatrixInter[64];
+    int gmc_enabled;
+} CUVIDMPEG4PICPARAMS;
+
+/********************************************************/
+//! \struct CUVIDVC1PICPARAMS
+//! VC1 picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/********************************************************/
+typedef struct _CUVIDVC1PICPARAMS
+{
+    int ForwardRefIdx;      /**< Picture index of forward reference (P/B-frames) */
+    int BackwardRefIdx;     /**< Picture index of backward reference (B-frames)  */
+    int FrameWidth;         /**< Actual frame width                              */
+    int FrameHeight;        /**< Actual frame height                             */
+    // PICTURE
+    int intra_pic_flag;     /**< Set to 1 for I,BI frames */
+    int ref_pic_flag;       /**< Set to 1 for I,P frames  */
+    int progressive_fcm;    /**< Progressive frame        */
+    // SEQUENCE
+    int profile;
+    int postprocflag;
+    int pulldown;
+    int interlace;
+    int tfcntrflag;
+    int finterpflag;
+    int psf;
+    int multires;
+    int syncmarker;
+    int rangered;
+    int maxbframes;
+    // ENTRYPOINT
+    int panscan_flag;
+    int refdist_flag;
+    int extended_mv;
+    int dquant;
+    int vstransform;
+    int loopfilter;
+    int fastuvmc;
+    int overlap;
+    int quantizer;
+    int extended_dmv;
+    int range_mapy_flag;
+    int range_mapy;
+    int range_mapuv_flag;
+    int range_mapuv;
+    int rangeredfrm;    // range reduction state
+} CUVIDVC1PICPARAMS;
+
+/***********************************************************/
+//! \struct CUVIDJPEGPICPARAMS
+//! JPEG picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/***********************************************************/
+typedef struct _CUVIDJPEGPICPARAMS
+{
+    int Reserved;
+} CUVIDJPEGPICPARAMS;
+
+
+/*******************************************************/
+//! \struct CUVIDHEVCPICPARAMS
+//! HEVC picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/*******************************************************/
+typedef struct _CUVIDHEVCPICPARAMS
+{
+    // sps
+    int pic_width_in_luma_samples;
+    int pic_height_in_luma_samples;
+    unsigned char log2_min_luma_coding_block_size_minus3;
+    unsigned char log2_diff_max_min_luma_coding_block_size;
+    unsigned char log2_min_transform_block_size_minus2;
+    unsigned char log2_diff_max_min_transform_block_size;
+    unsigned char pcm_enabled_flag;
+    unsigned char log2_min_pcm_luma_coding_block_size_minus3;
+    unsigned char log2_diff_max_min_pcm_luma_coding_block_size;
+    unsigned char pcm_sample_bit_depth_luma_minus1;
+
+    unsigned char pcm_sample_bit_depth_chroma_minus1;
+    unsigned char pcm_loop_filter_disabled_flag;
+    unsigned char strong_intra_smoothing_enabled_flag;
+    unsigned char max_transform_hierarchy_depth_intra;
+    unsigned char max_transform_hierarchy_depth_inter;
+    unsigned char amp_enabled_flag;
+    unsigned char separate_colour_plane_flag;
+    unsigned char log2_max_pic_order_cnt_lsb_minus4;
+
+    unsigned char num_short_term_ref_pic_sets;
+    unsigned char long_term_ref_pics_present_flag;
+    unsigned char num_long_term_ref_pics_sps;
+    unsigned char sps_temporal_mvp_enabled_flag;
+    unsigned char sample_adaptive_offset_enabled_flag;
+    unsigned char scaling_list_enable_flag;
+    unsigned char IrapPicFlag;
+    unsigned char IdrPicFlag;
+
+    unsigned char bit_depth_luma_minus8;
+    unsigned char bit_depth_chroma_minus8;
+    unsigned char reserved1[14];
+
+    // pps
+    unsigned char dependent_slice_segments_enabled_flag;
+    unsigned char slice_segment_header_extension_present_flag;
+    unsigned char sign_data_hiding_enabled_flag;
+    unsigned char cu_qp_delta_enabled_flag;
+    unsigned char diff_cu_qp_delta_depth;
+    signed char init_qp_minus26;
+    signed char pps_cb_qp_offset;
+    signed char pps_cr_qp_offset;
+
+    unsigned char constrained_intra_pred_flag;
+    unsigned char weighted_pred_flag;
+    unsigned char weighted_bipred_flag;
+    unsigned char transform_skip_enabled_flag;
+    unsigned char transquant_bypass_enabled_flag;
+    unsigned char entropy_coding_sync_enabled_flag;
+    unsigned char log2_parallel_merge_level_minus2;
+    unsigned char num_extra_slice_header_bits;
+
+    unsigned char loop_filter_across_tiles_enabled_flag;
+    unsigned char loop_filter_across_slices_enabled_flag;
+    unsigned char output_flag_present_flag;
+    unsigned char num_ref_idx_l0_default_active_minus1;
+    unsigned char num_ref_idx_l1_default_active_minus1;
+    unsigned char lists_modification_present_flag;
+    unsigned char cabac_init_present_flag;
+    unsigned char pps_slice_chroma_qp_offsets_present_flag;
+
+    unsigned char deblocking_filter_override_enabled_flag;
+    unsigned char pps_deblocking_filter_disabled_flag;
+    signed char   pps_beta_offset_div2;
+    signed char   pps_tc_offset_div2;
+    unsigned char tiles_enabled_flag;
+    unsigned char uniform_spacing_flag;
+    unsigned char num_tile_columns_minus1;
+    unsigned char num_tile_rows_minus1;
+
+    unsigned short column_width_minus1[21];
+    unsigned short row_height_minus1[21];
+    unsigned int   reserved3[15];
+
+    // RefPicSets
+    int NumBitsForShortTermRPSInSlice;
+    int NumDeltaPocsOfRefRpsIdx;
+    int NumPocTotalCurr;
+    int NumPocStCurrBefore;
+    int NumPocStCurrAfter;
+    int NumPocLtCurr;
+    int CurrPicOrderCntVal;
+    int RefPicIdx[16];                      // [refpic] Indices of valid reference pictures (-1 if unused for reference)
+    int PicOrderCntVal[16];                 // [refpic]
+    unsigned char IsLongTerm[16];           // [refpic] 0=not a long-term reference, 1=long-term reference
+    unsigned char RefPicSetStCurrBefore[8]; // [0..NumPocStCurrBefore-1] -> refpic (0..15)
+    unsigned char RefPicSetStCurrAfter[8];  // [0..NumPocStCurrAfter-1] -> refpic (0..15)
+    unsigned char RefPicSetLtCurr[8];       // [0..NumPocLtCurr-1] -> refpic (0..15)
+    unsigned char RefPicSetInterLayer0[8];
+    unsigned char RefPicSetInterLayer1[8];
+    unsigned int  reserved4[12];
+
+    // scaling lists (diag order)
+    unsigned char ScalingList4x4[6][16];       // [matrixId][i]
+    unsigned char ScalingList8x8[6][64];       // [matrixId][i]
+    unsigned char ScalingList16x16[6][64];     // [matrixId][i]
+    unsigned char ScalingList32x32[2][64];     // [matrixId][i]
+    unsigned char ScalingListDCCoeff16x16[6];  // [matrixId]
+    unsigned char ScalingListDCCoeff32x32[2];  // [matrixId]
+} CUVIDHEVCPICPARAMS;
+
+
+/***********************************************************/
+//! \struct CUVIDVP8PICPARAMS
+//! VP8 picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/***********************************************************/
+typedef struct _CUVIDVP8PICPARAMS
+{
+    int width;
+    int height;
+    unsigned int first_partition_size;
+    //Frame Indexes
+    unsigned char LastRefIdx;
+    unsigned char GoldenRefIdx;
+    unsigned char AltRefIdx;
+    union {
+        struct {
+            unsigned char frame_type : 1;    /**< 0 = KEYFRAME, 1 = INTERFRAME  */
+            unsigned char version : 3;
+            unsigned char show_frame : 1;
+            unsigned char update_mb_segmentation_data : 1;    /**< Must be 0 if segmentation is not enabled */
+            unsigned char Reserved2Bits : 2;
+        };
+        unsigned char wFrameTagFlags;
+    };
+    unsigned char Reserved1[4];
+    unsigned int  Reserved2[3];
+} CUVIDVP8PICPARAMS;
+
+/***********************************************************/
+//! \struct CUVIDVP9PICPARAMS
+//! VP9 picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/***********************************************************/
+typedef struct _CUVIDVP9PICPARAMS
+{
+    unsigned int width;
+    unsigned int height;
+
+    //Frame Indices
+    unsigned char LastRefIdx;
+    unsigned char GoldenRefIdx;
+    unsigned char AltRefIdx;
+    unsigned char colorSpace;
+
+    unsigned short profile : 3;
+    unsigned short frameContextIdx : 2;
+    unsigned short frameType : 1;
+    unsigned short showFrame : 1;
+    unsigned short errorResilient : 1;
+    unsigned short frameParallelDecoding : 1;
+    unsigned short subSamplingX : 1;
+    unsigned short subSamplingY : 1;
+    unsigned short intraOnly : 1;
+    unsigned short allow_high_precision_mv : 1;
+    unsigned short refreshEntropyProbs : 1;
+    unsigned short reserved2Bits : 2;
+
+    unsigned short reserved16Bits;
+
+    unsigned char  refFrameSignBias[4];
+
+    unsigned char bitDepthMinus8Luma;
+    unsigned char bitDepthMinus8Chroma;
+    unsigned char loopFilterLevel;
+    unsigned char loopFilterSharpness;
+
+    unsigned char modeRefLfEnabled;
+    unsigned char log2_tile_columns;
+    unsigned char log2_tile_rows;
+
+    unsigned char segmentEnabled : 1;
+    unsigned char segmentMapUpdate : 1;
+    unsigned char segmentMapTemporalUpdate : 1;
+    unsigned char segmentFeatureMode : 1;
+    unsigned char reserved4Bits : 4;
+
+
+    unsigned char segmentFeatureEnable[8][4];
+    short         segmentFeatureData[8][4];
+    unsigned char mb_segment_tree_probs[7];
+    unsigned char segment_pred_probs[3];
+    unsigned char reservedSegment16Bits[2];
+
+    int qpYAc;
+    int qpYDc;
+    int qpChDc;
+    int qpChAc;
+
+    unsigned int activeRefIdx[3];
+    unsigned int resetFrameContext;
+    unsigned int mcomp_filter_type;
+    unsigned int mbRefLfDelta[4];
+    unsigned int mbModeLfDelta[2];
+    unsigned int frameTagSize;
+    unsigned int offsetToDctParts;
+    unsigned int reserved128Bits[4];
+
+} CUVIDVP9PICPARAMS;
+
+
+/******************************************************************************************/
+//! \struct CUVIDPICPARAMS
+//! Picture parameters for decoding
+//! This structure is used in cuvidDecodePicture API
+//! IN  for cuvidDecodePicture
+/******************************************************************************************/
+typedef struct _CUVIDPICPARAMS
+{
+    int PicWidthInMbs;                     /**< IN: Coded frame size in macroblocks                           */
+    int FrameHeightInMbs;                  /**< IN: Coded frame height in macroblocks                         */
+    int CurrPicIdx;                        /**< IN: Output index of the current picture                       */
+    int field_pic_flag;                    /**< IN: 0=frame picture, 1=field picture                          */
+    int bottom_field_flag;                 /**< IN: 0=top field, 1=bottom field (ignored if field_pic_flag=0) */
+    int second_field;                      /**< IN: Second field of a complementary field pair                */
+    // Bitstream data
+    unsigned int nBitstreamDataLen;        /**< IN: Number of bytes in bitstream data buffer                  */
+    const unsigned char *pBitstreamData;   /**< IN: Ptr to bitstream data for this picture (slice-layer)      */
+    unsigned int nNumSlices;               /**< IN: Number of slices in this picture                          */
+    const unsigned int *pSliceDataOffsets; /**< IN: nNumSlices entries, contains offset of each slice within
+                                                        the bitstream data buffer                             */
+    int ref_pic_flag;                      /**< IN: This picture is a reference picture                       */
+    int intra_pic_flag;                    /**< IN: This picture is entirely intra coded                      */
+    unsigned int Reserved[30];             /**< Reserved for future use                                       */
+    // IN: Codec-specific data
+    union {
+        CUVIDMPEG2PICPARAMS mpeg2;         /**< Also used for MPEG-1 */
+        CUVIDH264PICPARAMS  h264;
+        CUVIDVC1PICPARAMS   vc1;
+        CUVIDMPEG4PICPARAMS mpeg4;
+        CUVIDJPEGPICPARAMS  jpeg;
+        CUVIDHEVCPICPARAMS  hevc;
+        CUVIDVP8PICPARAMS   vp8;
+        CUVIDVP9PICPARAMS   vp9;
+        unsigned int CodecReserved[1024];
+    } CodecSpecific;
+} CUVIDPICPARAMS;
+
+
+/******************************************************/
+//! \struct CUVIDPROCPARAMS
+//! Picture parameters for postprocessing
+//! This structure is used in cuvidMapVideoFrame API
+/******************************************************/
+typedef struct _CUVIDPROCPARAMS
+{
+    int progressive_frame;              /**< IN: Input is progressive (deinterlace_mode will be ignored)                */
+    int second_field;                   /**< IN: Output the second field (ignored if deinterlace mode is Weave)         */
+    int top_field_first;                /**< IN: Input frame is top field first (1st field is top, 2nd field is bottom) */
+    int unpaired_field;                 /**< IN: Input only contains one field (2nd field is invalid)                   */
+    // The fields below are used for raw YUV input
+    unsigned int reserved_flags;        /**< Reserved for future use (set to zero)                                      */
+    unsigned int reserved_zero;         /**< Reserved (set to zero)                                                     */
+    unsigned long long raw_input_dptr;  /**< IN: Input CUdeviceptr for raw YUV extensions                               */
+    unsigned int raw_input_pitch;       /**< IN: pitch in bytes of raw YUV input (should be aligned appropriately)      */
+    unsigned int raw_input_format;      /**< IN: Input YUV format (cudaVideoCodec_enum)                                 */
+    unsigned long long raw_output_dptr; /**< IN: Output CUdeviceptr for raw YUV extensions                              */
+    unsigned int raw_output_pitch;      /**< IN: pitch in bytes of raw YUV output (should be aligned appropriately)     */
+    unsigned int Reserved1;             /**< Reserved for future use (set to zero)                                      */
+    CUstream output_stream;             /**< IN: stream object used by cuvidMapVideoFrame                               */
+    unsigned int Reserved[46];          /**< Reserved for future use (set to zero)                                      */
+    void *Reserved2[2];                 /**< Reserved for future use (set to zero)                                      */
+} CUVIDPROCPARAMS;
+
+
+/***********************************************************************************************************/
+//! VIDEO_DECODER
+//!
+//! In order to minimize decode latencies, there should be always at least 2 pictures in the decode
+//! queue at any time, in order to make sure that all decode engines are always busy.
+//!
+//! Overall data flow:
+//!  - cuvidGetDecoderCaps(...)
+//!  - cuvidCreateDecoder(...)
+//!  - For each picture:
+//!    + cuvidDecodePicture(N)
+//!    + cuvidMapVideoFrame(N-4)
+//!    + do some processing in cuda
+//!    + cuvidUnmapVideoFrame(N-4)
+//!    + cuvidDecodePicture(N+1)
+//!    + cuvidMapVideoFrame(N-3)
+//!    + ...
+//!  - cuvidDestroyDecoder(...)
+//!
+//! NOTE:
+//! - When the cuda context is created from a D3D device, the D3D device must also be created
+//!   with the D3DCREATE_MULTITHREADED flag.
+//! - There is a limit to how many pictures can be mapped simultaneously (ulNumOutputSurfaces)
+//! - cuvidDecodePicture may block the calling thread if there are too many pictures pending
+//!   in the decode queue
+/***********************************************************************************************************/
+
+
+/**********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidGetDecoderCaps(CUVIDDECODECAPS *pdc)
+//! Queries decode capabilities of NVDEC-HW based on CodecType, ChromaFormat and BitDepthMinus8 parameters.
+//! 1. Application fills IN parameters CodecType, ChromaFormat and BitDepthMinus8 of CUVIDDECODECAPS structure
+//! 2. On calling cuvidGetDecoderCaps, driver fills OUT parameters if the IN parameters are supported
+//!    If IN parameters passed to the driver are not supported by NVDEC-HW, then all OUT params are set to 0.
+//! E.g. on Geforce GTX 960:
+//!   App fills - eCodecType = cudaVideoCodec_H264; eChromaFormat = cudaVideoChromaFormat_420; nBitDepthMinus8 = 0;
+//!   Given IN parameters are supported, hence driver fills: bIsSupported = 1; nMinWidth   = 48; nMinHeight  = 16;
+//!   nMaxWidth = 4096; nMaxHeight = 4096; nMaxMBCount = 65536;
+//! CodedWidth*CodedHeight/256 must be less than or equal to nMaxMBCount
+/**********************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidGetDecoderCaps(CUVIDDECODECAPS *pdc);
+
+/********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidCreateDecoder(CUvideodecoder *phDecoder, CUVIDDECODECREATEINFO *pdci)
+//! Create the decoder object based on pdci. A handle to the created decoder is returned
+/********************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidCreateDecoder(CUvideodecoder *phDecoder, CUVIDDECODECREATEINFO *pdci);
+/********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidDestroyDecoder(CUvideodecoder hDecoder)
+//! Destroy the decoder object.
+/********************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidDestroyDecoder(CUvideodecoder hDecoder);
+
+/********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidDecodePicture(CUvideodecoder hDecoder, CUVIDPICPARAMS *pPicParams)
+//! Decode a single picture (field or frame)
+//! Kicks off HW decoding
+/********************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidDecodePicture(CUvideodecoder hDecoder, CUVIDPICPARAMS *pPicParams);
+
+
+#if !defined(__CUVID_DEVPTR64) || defined(__CUVID_INTERNAL)
+/************************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidMapVideoFrame(CUvideodecoder hDecoder, int nPicIdx, unsigned int *pDevPtr,
+//!                                         unsigned int  *pPitch, CUVIDPROCPARAMS *pVPP);
+//! Post-process and map video frame corresponding to nPicIdx for use in cuda. Returns cuda device pointer and associated
+//! pitch of the video frame
+/************************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidMapVideoFrame(CUvideodecoder hDecoder, int nPicIdx,
+                                           unsigned int *pDevPtr, unsigned int *pPitch,
+                                           CUVIDPROCPARAMS *pVPP);
+
+/********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidUnmapVideoFrame(CUvideodecoder hDecoder, unsigned int DevPtr)
+//! Unmap a previously mapped video frame
+/********************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidUnmapVideoFrame(CUvideodecoder hDecoder, unsigned int DevPtr);
+#endif
+
+#if defined(_WIN64) || defined(__LP64__) || defined(__x86_64) || defined(AMD64) || defined(_M_AMD64)
+/************************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidMapVideoFrame64(CUvideodecoder hDecoder, int nPicIdx, unsigned long long *pDevPtr,
+//!                                           unsigned int *pPitch, CUVIDPROCPARAMS *pVPP);
+//! Post-process and map video frame corresponding to nPicIdx for use in cuda. Returns cuda device pointer and associated
+//! pitch of the video frame
+/************************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidMapVideoFrame64(CUvideodecoder hDecoder, int nPicIdx, unsigned long long *pDevPtr,
+                                             unsigned int *pPitch, CUVIDPROCPARAMS *pVPP);
+
+/********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidUnmapVideoFrame64(CUvideodecoder hDecoder, unsigned long long DevPtr);
+//! Unmap a previously mapped video frame
+/********************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidUnmapVideoFrame64(CUvideodecoder hDecoder, unsigned long long DevPtr);
+
+#if defined(__CUVID_DEVPTR64) && !defined(__CUVID_INTERNAL)
+#define tcuvidMapVideoFrame      tcuvidMapVideoFrame64
+#define tcuvidUnmapVideoFrame    tcuvidUnmapVideoFrame64
+#endif
+#endif
+
+
+
+/********************************************************************************************************************/
+//!
+//! Context-locking: to facilitate multi-threaded implementations, the following 4 functions
+//! provide a simple mutex-style host synchronization. If a non-NULL context is specified
+//! in CUVIDDECODECREATEINFO, the codec library will acquire the mutex associated with the given
+//! context before making any cuda calls.
+//! A multi-threaded application could create a lock associated with a context handle so that
+//! multiple threads can safely share the same cuda context:
+//!  - use cuCtxPopCurrent immediately after context creation in order to create a 'floating' context
+//!    that can be passed to cuvidCtxLockCreate.
+//!  - When using a floating context, all cuda calls should only be made within a cuvidCtxLock/cuvidCtxUnlock section.
+//!
+//! NOTE: This is a safer alternative to cuCtxPushCurrent and cuCtxPopCurrent, and is not related to video
+//! decoder in any way (implemented as a critical section associated with cuCtx{Push|Pop}Current calls).
+/********************************************************************************************************************/
+
+/********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidCtxLockCreate(CUvideoctxlock *pLock, CUcontext ctx)
+//! This API is used to create CtxLock object
+/********************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidCtxLockCreate(CUvideoctxlock *pLock, CUcontext ctx);
+
+/********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidCtxLockDestroy(CUvideoctxlock lck)
+//! This API is used to free CtxLock object
+/********************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidCtxLockDestroy(CUvideoctxlock lck);
+
+/********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidCtxLock(CUvideoctxlock lck, unsigned int reserved_flags)
+//! This API is used to acquire ctxlock
+/********************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidCtxLock(CUvideoctxlock lck, unsigned int reserved_flags);
+
+/********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidCtxUnlock(CUvideoctxlock lck, unsigned int reserved_flags)
+//! This API is used to release ctxlock
+/********************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidCtxUnlock(CUvideoctxlock lck, unsigned int reserved_flags);
+
+/**********************************************************************************************/
+
+#if defined(__cplusplus)
+}
+#endif /* __cplusplus */
+
+#endif // __CUDA_VIDEO_H__

compat/cuda/dynlink_loader.h

@@ -1,33 +1,268 @@
 /*
- * This file is part of FFmpeg.
+ * This copyright notice applies to this header file only:
  *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
+ * Copyright (c) 2016
  *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the software, and to permit persons to whom the
+ * software is furnished to do so, subject to the following
+ * conditions:
  *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
  */
 
 #ifndef AV_COMPAT_CUDA_DYNLINK_LOADER_H
 #define AV_COMPAT_CUDA_DYNLINK_LOADER_H
 
-#include "libavutil/log.h"
+#include "compat/cuda/dynlink_cuda.h"
+#include "compat/cuda/dynlink_nvcuvid.h"
+#include "compat/nvenc/nvEncodeAPI.h"
 #include "compat/w32dlfcn.h"
 
-#define FFNV_LOAD_FUNC(path) dlopen((path), RTLD_LAZY)
-#define FFNV_SYM_FUNC(lib, sym) dlsym((lib), (sym))
-#define FFNV_FREE_FUNC(lib) dlclose(lib)
-#define FFNV_LOG_FUNC(logctx, msg, ...) av_log(logctx, AV_LOG_ERROR, msg,  __VA_ARGS__)
-#define FFNV_DEBUG_LOG_FUNC(logctx, msg, ...) av_log(logctx, AV_LOG_DEBUG, msg,  __VA_ARGS__)
+#include "libavutil/log.h"
+#include "libavutil/error.h"
 
-#include <ffnvcodec/dynlink_loader.h>
+#if defined(_WIN32)
+# define LIB_HANDLE HMODULE
+#else
+# define LIB_HANDLE void*
+#endif
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+# define CUDA_LIBNAME "nvcuda.dll"
+# define NVCUVID_LIBNAME "nvcuvid.dll"
+# if ARCH_X86_64
+#  define NVENC_LIBNAME "nvEncodeAPI64.dll"
+# else
+#  define NVENC_LIBNAME "nvEncodeAPI.dll"
+# endif
+#else
+# define CUDA_LIBNAME "libcuda.so.1"
+# define NVCUVID_LIBNAME "libnvcuvid.so.1"
+# define NVENC_LIBNAME "libnvidia-encode.so.1"
+#endif
+
+#define LOAD_LIBRARY(l, path)                                     \
+    do {                                                          \
+        if (!((l) = dlopen(path, RTLD_LAZY))) {                   \
+            av_log(NULL, AV_LOG_ERROR, "Cannot load %s\n", path); \
+            ret = AVERROR_UNKNOWN;                                \
+            goto error;                                           \
+        }                                                         \
+        av_log(NULL, AV_LOG_TRACE, "Loaded lib: %s\n", path);     \
+    } while (0)
+
+#define LOAD_SYMBOL(fun, tp, symbol)                                \
+    do {                                                            \
+        if (!((f->fun) = (tp*)dlsym(f->lib, symbol))) {             \
+            av_log(NULL, AV_LOG_ERROR, "Cannot load %s\n", symbol); \
+            ret = AVERROR_UNKNOWN;                                  \
+            goto error;                                             \
+        }                                                           \
+        av_log(NULL, AV_LOG_TRACE, "Loaded sym: %s\n", symbol);     \
+    } while (0)
+
+#define LOAD_SYMBOL_OPT(fun, tp, symbol)                                     \
+    do {                                                                     \
+        if (!((f->fun) = (tp*)dlsym(f->lib, symbol))) {                      \
+            av_log(NULL, AV_LOG_DEBUG, "Cannot load optional %s\n", symbol); \
+        } else {                                                             \
+            av_log(NULL, AV_LOG_TRACE, "Loaded sym: %s\n", symbol);          \
+        }                                                                    \
+    } while (0)
+
+#define GENERIC_LOAD_FUNC_PREAMBLE(T, n, N)  \
+    T *f;                                    \
+    int ret;                                 \
+                                             \
+    n##_free_functions(functions);           \
+                                             \
+    f = *functions = av_mallocz(sizeof(*f)); \
+    if (!f)                                  \
+        return AVERROR(ENOMEM);              \
+                                             \
+    LOAD_LIBRARY(f->lib, N);
+
+#define GENERIC_LOAD_FUNC_FINALE(n) \
+    return 0;                       \
+error:                              \
+    n##_free_functions(functions);  \
+    return ret;
+
+#define GENERIC_FREE_FUNC()              \
+    if (!functions)                      \
+        return;                          \
+    if (*functions && (*functions)->lib) \
+        dlclose((*functions)->lib);      \
+    av_freep(functions);
+
+#ifdef AV_COMPAT_DYNLINK_CUDA_H
+typedef struct CudaFunctions {
+    tcuInit *cuInit;
+    tcuDeviceGetCount *cuDeviceGetCount;
+    tcuDeviceGet *cuDeviceGet;
+    tcuDeviceGetName *cuDeviceGetName;
+    tcuDeviceComputeCapability *cuDeviceComputeCapability;
+    tcuCtxCreate_v2 *cuCtxCreate;
+    tcuCtxPushCurrent_v2 *cuCtxPushCurrent;
+    tcuCtxPopCurrent_v2 *cuCtxPopCurrent;
+    tcuCtxDestroy_v2 *cuCtxDestroy;
+    tcuMemAlloc_v2 *cuMemAlloc;
+    tcuMemFree_v2 *cuMemFree;
+    tcuMemcpy2D_v2 *cuMemcpy2D;
+    tcuGetErrorName *cuGetErrorName;
+    tcuGetErrorString *cuGetErrorString;
+
+    LIB_HANDLE lib;
+} CudaFunctions;
+#else
+typedef struct CudaFunctions CudaFunctions;
+#endif
+
+typedef struct CuvidFunctions {
+    tcuvidGetDecoderCaps *cuvidGetDecoderCaps;
+    tcuvidCreateDecoder *cuvidCreateDecoder;
+    tcuvidDestroyDecoder *cuvidDestroyDecoder;
+    tcuvidDecodePicture *cuvidDecodePicture;
+    tcuvidMapVideoFrame *cuvidMapVideoFrame;
+    tcuvidUnmapVideoFrame *cuvidUnmapVideoFrame;
+    tcuvidCtxLockCreate *cuvidCtxLockCreate;
+    tcuvidCtxLockDestroy *cuvidCtxLockDestroy;
+    tcuvidCtxLock *cuvidCtxLock;
+    tcuvidCtxUnlock *cuvidCtxUnlock;
+
+    tcuvidCreateVideoSource *cuvidCreateVideoSource;
+    tcuvidCreateVideoSourceW *cuvidCreateVideoSourceW;
+    tcuvidDestroyVideoSource *cuvidDestroyVideoSource;
+    tcuvidSetVideoSourceState *cuvidSetVideoSourceState;
+    tcuvidGetVideoSourceState *cuvidGetVideoSourceState;
+    tcuvidGetSourceVideoFormat *cuvidGetSourceVideoFormat;
+    tcuvidGetSourceAudioFormat *cuvidGetSourceAudioFormat;
+    tcuvidCreateVideoParser *cuvidCreateVideoParser;
+    tcuvidParseVideoData *cuvidParseVideoData;
+    tcuvidDestroyVideoParser *cuvidDestroyVideoParser;
+
+    LIB_HANDLE lib;
+} CuvidFunctions;
+
+typedef NVENCSTATUS NVENCAPI tNvEncodeAPICreateInstance(NV_ENCODE_API_FUNCTION_LIST *functionList);
+typedef NVENCSTATUS NVENCAPI tNvEncodeAPIGetMaxSupportedVersion(uint32_t* version);
+
+typedef struct NvencFunctions {
+    tNvEncodeAPICreateInstance *NvEncodeAPICreateInstance;
+    tNvEncodeAPIGetMaxSupportedVersion *NvEncodeAPIGetMaxSupportedVersion;
+
+    LIB_HANDLE lib;
+} NvencFunctions;
+
+#ifdef AV_COMPAT_DYNLINK_CUDA_H
+static inline void cuda_free_functions(CudaFunctions **functions)
+{
+    GENERIC_FREE_FUNC();
+}
+#endif
+
+static inline void cuvid_free_functions(CuvidFunctions **functions)
+{
+    GENERIC_FREE_FUNC();
+}
+
+static inline void nvenc_free_functions(NvencFunctions **functions)
+{
+    GENERIC_FREE_FUNC();
+}
+
+#ifdef AV_COMPAT_DYNLINK_CUDA_H
+static inline int cuda_load_functions(CudaFunctions **functions)
+{
+    GENERIC_LOAD_FUNC_PREAMBLE(CudaFunctions, cuda, CUDA_LIBNAME);
+
+    LOAD_SYMBOL(cuInit, tcuInit, "cuInit");
+    LOAD_SYMBOL(cuDeviceGetCount, tcuDeviceGetCount, "cuDeviceGetCount");
+    LOAD_SYMBOL(cuDeviceGet, tcuDeviceGet, "cuDeviceGet");
+    LOAD_SYMBOL(cuDeviceGetName, tcuDeviceGetName, "cuDeviceGetName");
+    LOAD_SYMBOL(cuDeviceComputeCapability, tcuDeviceComputeCapability, "cuDeviceComputeCapability");
+    LOAD_SYMBOL(cuCtxCreate, tcuCtxCreate_v2, "cuCtxCreate_v2");
+    LOAD_SYMBOL(cuCtxPushCurrent, tcuCtxPushCurrent_v2, "cuCtxPushCurrent_v2");
+    LOAD_SYMBOL(cuCtxPopCurrent, tcuCtxPopCurrent_v2, "cuCtxPopCurrent_v2");
+    LOAD_SYMBOL(cuCtxDestroy, tcuCtxDestroy_v2, "cuCtxDestroy_v2");
+    LOAD_SYMBOL(cuMemAlloc, tcuMemAlloc_v2, "cuMemAlloc_v2");
+    LOAD_SYMBOL(cuMemFree, tcuMemFree_v2, "cuMemFree_v2");
+    LOAD_SYMBOL(cuMemcpy2D, tcuMemcpy2D_v2, "cuMemcpy2D_v2");
+    LOAD_SYMBOL(cuGetErrorName, tcuGetErrorName, "cuGetErrorName");
+    LOAD_SYMBOL(cuGetErrorString, tcuGetErrorString, "cuGetErrorString");
+
+    GENERIC_LOAD_FUNC_FINALE(cuda);
+}
+#endif
+
+static inline int cuvid_load_functions(CuvidFunctions **functions)
+{
+    GENERIC_LOAD_FUNC_PREAMBLE(CuvidFunctions, cuvid, NVCUVID_LIBNAME);
+
+    LOAD_SYMBOL_OPT(cuvidGetDecoderCaps, tcuvidGetDecoderCaps, "cuvidGetDecoderCaps");
+    LOAD_SYMBOL(cuvidCreateDecoder, tcuvidCreateDecoder, "cuvidCreateDecoder");
+    LOAD_SYMBOL(cuvidDestroyDecoder, tcuvidDestroyDecoder, "cuvidDestroyDecoder");
+    LOAD_SYMBOL(cuvidDecodePicture, tcuvidDecodePicture, "cuvidDecodePicture");
+#ifdef __CUVID_DEVPTR64
+    LOAD_SYMBOL(cuvidMapVideoFrame, tcuvidMapVideoFrame, "cuvidMapVideoFrame64");
+    LOAD_SYMBOL(cuvidUnmapVideoFrame, tcuvidUnmapVideoFrame, "cuvidUnmapVideoFrame64");
+#else
+    LOAD_SYMBOL(cuvidMapVideoFrame, tcuvidMapVideoFrame, "cuvidMapVideoFrame");
+    LOAD_SYMBOL(cuvidUnmapVideoFrame, tcuvidUnmapVideoFrame, "cuvidUnmapVideoFrame");
+#endif
+    LOAD_SYMBOL(cuvidCtxLockCreate, tcuvidCtxLockCreate, "cuvidCtxLockCreate");
+    LOAD_SYMBOL(cuvidCtxLockDestroy, tcuvidCtxLockDestroy, "cuvidCtxLockDestroy");
+    LOAD_SYMBOL(cuvidCtxLock, tcuvidCtxLock, "cuvidCtxLock");
+    LOAD_SYMBOL(cuvidCtxUnlock, tcuvidCtxUnlock, "cuvidCtxUnlock");
+
+    LOAD_SYMBOL(cuvidCreateVideoSource, tcuvidCreateVideoSource, "cuvidCreateVideoSource");
+    LOAD_SYMBOL(cuvidCreateVideoSourceW, tcuvidCreateVideoSourceW, "cuvidCreateVideoSourceW");
+    LOAD_SYMBOL(cuvidDestroyVideoSource, tcuvidDestroyVideoSource, "cuvidDestroyVideoSource");
+    LOAD_SYMBOL(cuvidSetVideoSourceState, tcuvidSetVideoSourceState, "cuvidSetVideoSourceState");
+    LOAD_SYMBOL(cuvidGetVideoSourceState, tcuvidGetVideoSourceState, "cuvidGetVideoSourceState");
+    LOAD_SYMBOL(cuvidGetSourceVideoFormat, tcuvidGetSourceVideoFormat, "cuvidGetSourceVideoFormat");
+    LOAD_SYMBOL(cuvidGetSourceAudioFormat, tcuvidGetSourceAudioFormat, "cuvidGetSourceAudioFormat");
+    LOAD_SYMBOL(cuvidCreateVideoParser, tcuvidCreateVideoParser, "cuvidCreateVideoParser");
+    LOAD_SYMBOL(cuvidParseVideoData, tcuvidParseVideoData, "cuvidParseVideoData");
+    LOAD_SYMBOL(cuvidDestroyVideoParser, tcuvidDestroyVideoParser, "cuvidDestroyVideoParser");
+
+    GENERIC_LOAD_FUNC_FINALE(cuvid);
+}
+
+static inline int nvenc_load_functions(NvencFunctions **functions)
+{
+    GENERIC_LOAD_FUNC_PREAMBLE(NvencFunctions, nvenc, NVENC_LIBNAME);
+
+    LOAD_SYMBOL(NvEncodeAPICreateInstance, tNvEncodeAPICreateInstance, "NvEncodeAPICreateInstance");
+    LOAD_SYMBOL(NvEncodeAPIGetMaxSupportedVersion, tNvEncodeAPIGetMaxSupportedVersion, "NvEncodeAPIGetMaxSupportedVersion");
+
+    GENERIC_LOAD_FUNC_FINALE(nvenc);
+}
+
+#undef GENERIC_LOAD_FUNC_PREAMBLE
+#undef LOAD_LIBRARY
+#undef LOAD_SYMBOL
+#undef GENERIC_LOAD_FUNC_FINALE
+#undef GENERIC_FREE_FUNC
+#undef CUDA_LIBNAME
+#undef NVCUVID_LIBNAME
+#undef NVENC_LIBNAME
+#undef LIB_HANDLE
 
 #endif
+

compat/cuda/dynlink_nvcuvid.h

@@ -0,0 +1,356 @@
+/*
+ * This copyright notice applies to this header file only:
+ *
+ * Copyright (c) 2010-2017 NVIDIA Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the software, and to permit persons to whom the
+ * software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/********************************************************************************************************************/
+//! \file nvcuvid.h
+//!   NVDECODE API provides video decoding interface to NVIDIA GPU devices.
+//! \date 2015-2017
+//!  This file contains the interface constants, structure definitions and function prototypes.
+/********************************************************************************************************************/
+
+#if !defined(__NVCUVID_H__)
+#define __NVCUVID_H__
+
+#include "compat/cuda/dynlink_cuviddec.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif /* __cplusplus */
+
+/*********************************
+** Initialization
+*********************************/
+CUresult  CUDAAPI cuvidInit(unsigned int Flags);
+
+/***********************************************/
+//!
+//! High-level helper APIs for video sources
+//!
+/***********************************************/
+
+typedef void *CUvideosource;
+typedef void *CUvideoparser;
+typedef long long CUvideotimestamp;
+
+
+/************************************************************************/
+//! \enum cudaVideoState
+//! Video source state enums
+//! Used in cuvidSetVideoSourceState and cuvidGetVideoSourceState APIs
+/************************************************************************/
+typedef enum {
+    cudaVideoState_Error   = -1,    /**< Error state (invalid source)                  */
+    cudaVideoState_Stopped = 0,     /**< Source is stopped (or reached end-of-stream)  */
+    cudaVideoState_Started = 1      /**< Source is running and delivering data         */
+} cudaVideoState;
+
+/************************************************************************/
+//! \enum cudaAudioCodec
+//! Audio compression enums
+//! Used in CUAUDIOFORMAT structure
+/************************************************************************/
+typedef enum {
+    cudaAudioCodec_MPEG1=0,         /**< MPEG-1 Audio               */
+    cudaAudioCodec_MPEG2,           /**< MPEG-2 Audio               */
+    cudaAudioCodec_MP3,             /**< MPEG-1 Layer III Audio     */
+    cudaAudioCodec_AC3,             /**< Dolby Digital (AC3) Audio  */
+    cudaAudioCodec_LPCM,            /**< PCM Audio                  */
+    cudaAudioCodec_AAC,             /**< AAC Audio                  */
+} cudaAudioCodec;
+
+/************************************************************************************************/
+//! \ingroup STRUCTS
+//! \struct CUVIDEOFORMAT
+//! Video format
+//! Used in cuvidGetSourceVideoFormat API
+/************************************************************************************************/
+typedef struct
+{
+    cudaVideoCodec codec;                   /**< OUT: Compression format          */
+   /**
+    * OUT: frame rate = numerator / denominator (for example: 30000/1001)
+    */
+    struct {
+        /**< OUT: frame rate numerator   (0 = unspecified or variable frame rate) */
+        unsigned int numerator;
+        /**< OUT: frame rate denominator (0 = unspecified or variable frame rate) */
+        unsigned int denominator;
+    } frame_rate;
+    unsigned char progressive_sequence;     /**< OUT: 0=interlaced, 1=progressive                                      */
+    unsigned char bit_depth_luma_minus8;    /**< OUT: high bit depth luma. E.g, 2 for 10-bitdepth, 4 for 12-bitdepth   */
+    unsigned char bit_depth_chroma_minus8;  /**< OUT: high bit depth chroma. E.g, 2 for 10-bitdepth, 4 for 12-bitdepth */
+    unsigned char reserved1;                /**< Reserved for future use                                               */
+    unsigned int coded_width;               /**< OUT: coded frame width in pixels                                      */
+    unsigned int coded_height;              /**< OUT: coded frame height in pixels                                     */
+   /**
+    * area of the frame that should be displayed
+    * typical example:
+    * coded_width = 1920, coded_height = 1088
+    * display_area = { 0,0,1920,1080 }
+    */
+    struct {
+        int left;                           /**< OUT: left position of display rect    */
+        int top;                            /**< OUT: top position of display rect     */
+        int right;                          /**< OUT: right position of display rect   */
+        int bottom;                         /**< OUT: bottom position of display rect  */
+    } display_area;
+    cudaVideoChromaFormat chroma_format;    /**< OUT:  Chroma format                   */
+    unsigned int bitrate;                   /**< OUT: video bitrate (bps, 0=unknown)   */
+   /**
+    * OUT: Display Aspect Ratio = x:y (4:3, 16:9, etc)
+    */
+    struct {
+        int x;
+        int y;
+    } display_aspect_ratio;
+    /**
+    * Video Signal Description
+    * Refer section E.2.1 (VUI parameters semantics) of H264 spec file
+    */
+    struct {
+        unsigned char video_format          : 3; /**< OUT: 0-Component, 1-PAL, 2-NTSC, 3-SECAM, 4-MAC, 5-Unspecified     */
+        unsigned char video_full_range_flag : 1; /**< OUT: indicates the black level and luma and chroma range           */
+        unsigned char reserved_zero_bits    : 4; /**< Reserved bits                                                      */
+        unsigned char color_primaries;           /**< OUT: chromaticity coordinates of source primaries                  */
+        unsigned char transfer_characteristics;  /**< OUT: opto-electronic transfer characteristic of the source picture */
+        unsigned char matrix_coefficients;       /**< OUT: used in deriving luma and chroma signals from RGB primaries   */
+    } video_signal_description;
+    unsigned int seqhdr_data_length;             /**< OUT: Additional bytes following (CUVIDEOFORMATEX)                  */
+} CUVIDEOFORMAT;
+
+/****************************************************************/
+//! \ingroup STRUCTS
+//! \struct CUVIDEOFORMATEX
+//! Video format including raw sequence header information
+//! Used in cuvidGetSourceVideoFormat API
+/****************************************************************/
+typedef struct
+{
+    CUVIDEOFORMAT format;                 /**< OUT: CUVIDEOFORMAT structure */
+    unsigned char raw_seqhdr_data[1024];  /**< OUT: Sequence header data    */
+} CUVIDEOFORMATEX;
+
+/****************************************************************/
+//! \ingroup STRUCTS
+//! \struct CUAUDIOFORMAT
+//! Audio formats
+//! Used in cuvidGetSourceAudioFormat API
+/****************************************************************/
+typedef struct
+{
+    cudaAudioCodec codec;       /**< OUT: Compression format                                              */
+    unsigned int channels;      /**< OUT: number of audio channels                                        */
+    unsigned int samplespersec; /**< OUT: sampling frequency                                              */
+    unsigned int bitrate;       /**< OUT: For uncompressed, can also be used to determine bits per sample */
+    unsigned int reserved1;     /**< Reserved for future use                                              */
+    unsigned int reserved2;     /**< Reserved for future use                                              */
+} CUAUDIOFORMAT;
+
+
+/***************************************************************/
+//! \enum CUvideopacketflags
+//! Data packet flags
+//! Used in CUVIDSOURCEDATAPACKET structure
+/***************************************************************/
+typedef enum {
+    CUVID_PKT_ENDOFSTREAM   = 0x01,   /**< Set when this is the last packet for this stream  */
+    CUVID_PKT_TIMESTAMP     = 0x02,   /**< Timestamp is valid                                */
+    CUVID_PKT_DISCONTINUITY = 0x04,   /**< Set when a discontinuity has to be signalled      */
+    CUVID_PKT_ENDOFPICTURE  = 0x08,   /**< Set when the packet contains exactly one frame    */
+} CUvideopacketflags;
+
+/*****************************************************************************/
+//! \ingroup STRUCTS
+//! \struct CUVIDSOURCEDATAPACKET
+//! Data Packet
+//! Used in cuvidParseVideoData API
+//! IN for cuvidParseVideoData
+/*****************************************************************************/
+typedef struct _CUVIDSOURCEDATAPACKET
+{
+    tcu_ulong flags;                /**< IN: Combination of CUVID_PKT_XXX flags                              */
+    tcu_ulong payload_size;         /**< IN: number of bytes in the payload (may be zero if EOS flag is set) */
+    const unsigned char *payload;   /**< IN: Pointer to packet payload data (may be NULL if EOS flag is set) */
+    CUvideotimestamp timestamp;     /**< IN: Presentation time stamp (10MHz clock), only valid if
+                                             CUVID_PKT_TIMESTAMP flag is set                                 */
+} CUVIDSOURCEDATAPACKET;
+
+// Callback for packet delivery
+typedef int (CUDAAPI *PFNVIDSOURCECALLBACK)(void *, CUVIDSOURCEDATAPACKET *);
+
+/**************************************************************************************************************************/
+//! \ingroup STRUCTS
+//! \struct CUVIDSOURCEPARAMS
+//! Describes parameters needed in cuvidCreateVideoSource API
+//! NVDECODE API is intended for HW accelerated video decoding so CUvideosource doesn't have audio demuxer for all supported
+//! containers. It's recommended to clients to use their own or third party demuxer if audio support is needed.
+/**************************************************************************************************************************/
+typedef struct _CUVIDSOURCEPARAMS
+{
+    unsigned int ulClockRate;                   /**< IN: Time stamp units in Hz (0=default=10000000Hz)      */
+    unsigned int uReserved1[7];                 /**< Reserved for future use - set to zero                  */
+    void *pUserData;                            /**< IN: User private data passed in to the data handlers   */
+    PFNVIDSOURCECALLBACK pfnVideoDataHandler;   /**< IN: Called to deliver video packets                    */
+    PFNVIDSOURCECALLBACK pfnAudioDataHandler;   /**< IN: Called to deliver audio packets.                   */
+    void *pvReserved2[8];                       /**< Reserved for future use - set to NULL                  */
+} CUVIDSOURCEPARAMS;
+
+
+/**********************************************/
+//! \ingroup ENUMS
+//! \enum CUvideosourceformat_flags
+//! CUvideosourceformat_flags
+//! Used in cuvidGetSourceVideoFormat API
+/**********************************************/
+typedef enum {
+    CUVID_FMT_EXTFORMATINFO = 0x100             /**< Return extended format structure (CUVIDEOFORMATEX) */
+} CUvideosourceformat_flags;
+
+#if !defined(__APPLE__)
+/**************************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidCreateVideoSource(CUvideosource *pObj, const char *pszFileName, CUVIDSOURCEPARAMS *pParams)
+//! Create CUvideosource object. CUvideosource spawns demultiplexer thread that provides two callbacks:
+//! pfnVideoDataHandler() and pfnAudioDataHandler()
+//! NVDECODE API is intended for HW accelerated video decoding so CUvideosource doesn't have audio demuxer for all supported
+//! containers. It's recommended to clients to use their own or third party demuxer if audio support is needed.
+/**************************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidCreateVideoSource(CUvideosource *pObj, const char *pszFileName, CUVIDSOURCEPARAMS *pParams);
+
+/****************************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidCreateVideoSourceW(CUvideosource *pObj, const wchar_t *pwszFileName, CUVIDSOURCEPARAMS *pParams)
+//! Create video source object and initialize
+/****************************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidCreateVideoSourceW(CUvideosource *pObj, const wchar_t *pwszFileName, CUVIDSOURCEPARAMS *pParams);
+
+/*********************************************************************/
+//! \fn CUresult CUDAAPI cuvidDestroyVideoSource(CUvideosource obj)
+//! Destroy video source
+/*********************************************************************/
+typedef CUresult CUDAAPI tcuvidDestroyVideoSource(CUvideosource obj);
+
+/******************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidSetVideoSourceState(CUvideosource obj, cudaVideoState state)
+//! Set video source state
+/******************************************************************************************/
+typedef CUresult CUDAAPI tcuvidSetVideoSourceState(CUvideosource obj, cudaVideoState state);
+
+/******************************************************************************************/
+//! \fn cudaVideoState CUDAAPI cuvidGetVideoSourceState(CUvideosource obj)
+//! Get video source state
+/******************************************************************************************/
+typedef cudaVideoState CUDAAPI tcuvidGetVideoSourceState(CUvideosource obj);
+
+/****************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidGetSourceVideoFormat(CUvideosource obj, CUVIDEOFORMAT *pvidfmt, unsigned int flags)
+//! Gets details of video stream in pvidfmt
+/****************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidGetSourceVideoFormat(CUvideosource obj, CUVIDEOFORMAT *pvidfmt, unsigned int flags);
+
+/****************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidGetSourceAudioFormat(CUvideosource obj, CUAUDIOFORMAT *paudfmt, unsigned int flags)
+//! Get audio source format
+//! NVDECODE API is intended for HW accelarated video decoding so CUvideosource doesn't have audio demuxer for all suppported
+//! containers. It's recommended to clients to use their own or third party demuxer if audio support is needed.
+/****************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidGetSourceAudioFormat(CUvideosource obj, CUAUDIOFORMAT *paudfmt, unsigned int flags);
+
+#endif
+/**********************************************************************************/
+//! \ingroup STRUCTS
+//! \struct CUVIDPARSERDISPINFO
+//! Used in cuvidParseVideoData API with PFNVIDDISPLAYCALLBACK pfnDisplayPicture
+/**********************************************************************************/
+typedef struct _CUVIDPARSERDISPINFO
+{
+    int picture_index;          /**< OUT: Index of the current picture                                                         */
+    int progressive_frame;      /**< OUT: 1 if progressive frame; 0 otherwise                                                  */
+    int top_field_first;        /**< OUT: 1 if top field is displayed first; 0 otherwise                                       */
+    int repeat_first_field;     /**< OUT: Number of additional fields (1=ivtc, 2=frame doubling, 4=frame tripling,
+                                     -1=unpaired field)                                                                        */
+    CUvideotimestamp timestamp; /**< OUT: Presentation time stamp                                                              */
+} CUVIDPARSERDISPINFO;
+
+/***********************************************************************************************************************/
+//! Parser callbacks
+//! The parser will call these synchronously from within cuvidParseVideoData(), whenever a picture is ready to
+//! be decoded and/or displayed. First argument in functions is "void *pUserData" member of structure CUVIDSOURCEPARAMS
+/***********************************************************************************************************************/
+typedef int (CUDAAPI *PFNVIDSEQUENCECALLBACK)(void *, CUVIDEOFORMAT *);
+typedef int (CUDAAPI *PFNVIDDECODECALLBACK)(void *, CUVIDPICPARAMS *);
+typedef int (CUDAAPI *PFNVIDDISPLAYCALLBACK)(void *, CUVIDPARSERDISPINFO *);
+
+/**************************************/
+//! \ingroup STRUCTS
+//! \struct CUVIDPARSERPARAMS
+//! Used in cuvidCreateVideoParser API
+/**************************************/
+typedef struct _CUVIDPARSERPARAMS
+{
+    cudaVideoCodec CodecType;                   /**< IN: cudaVideoCodec_XXX                                                  */
+    unsigned int ulMaxNumDecodeSurfaces;        /**< IN: Max # of decode surfaces (parser will cycle through these)          */
+    unsigned int ulClockRate;                   /**< IN: Timestamp units in Hz (0=default=10000000Hz)                        */
+    unsigned int ulErrorThreshold;              /**< IN: % Error threshold (0-100) for calling pfnDecodePicture (100=always
+                                                     IN: call pfnDecodePicture even if picture bitstream is fully corrupted) */
+    unsigned int ulMaxDisplayDelay;             /**< IN: Max display queue delay (improves pipelining of decode with display)
+                                                         0=no delay (recommended values: 2..4)                               */
+    unsigned int uReserved1[5];                 /**< IN: Reserved for future use - set to 0                                  */
+    void *pUserData;                            /**< IN: User data for callbacks                                             */
+    PFNVIDSEQUENCECALLBACK pfnSequenceCallback; /**< IN: Called before decoding frames and/or whenever there is a fmt change */
+    PFNVIDDECODECALLBACK pfnDecodePicture;      /**< IN: Called when a picture is ready to be decoded (decode order)         */
+    PFNVIDDISPLAYCALLBACK pfnDisplayPicture;    /**< IN: Called whenever a picture is ready to be displayed (display order)  */
+    void *pvReserved2[7];                       /**< Reserved for future use - set to NULL                                   */
+    CUVIDEOFORMATEX *pExtVideoInfo;             /**< IN: [Optional] sequence header data from system layer                   */
+} CUVIDPARSERPARAMS;
+
+/************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidCreateVideoParser(CUvideoparser *pObj, CUVIDPARSERPARAMS *pParams)
+//! Create video parser object and initialize
+/************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidCreateVideoParser(CUvideoparser *pObj, CUVIDPARSERPARAMS *pParams);
+
+/************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidParseVideoData(CUvideoparser obj, CUVIDSOURCEDATAPACKET *pPacket)
+//! Parse the video data from source data packet in pPacket
+//! Extracts parameter sets like SPS, PPS, bitstream etc. from pPacket and
+//! calls back pfnDecodePicture with CUVIDPICPARAMS data for kicking of HW decoding
+/************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidParseVideoData(CUvideoparser obj, CUVIDSOURCEDATAPACKET *pPacket);
+
+/*******************************************************************/
+//! \fn CUresult CUDAAPI cuvidDestroyVideoParser(CUvideoparser obj)
+/*******************************************************************/
+typedef CUresult CUDAAPI tcuvidDestroyVideoParser(CUvideoparser obj);
+
+/**********************************************************************************************/
+
+#if defined(__cplusplus)
+}
+#endif /* __cplusplus */
+
+#endif // __NVCUVID_H__
+
+

compat/os2threads.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011-2017 KO Myung-Hun <komh@chollian.net>
+ * Copyright (c) 2011 KO Myung-Hun <komh@chollian.net>
  *
  * This file is part of FFmpeg.
  *
@@ -46,11 +46,9 @@ typedef struct {
 
 typedef void pthread_attr_t;
 
-typedef _fmutex pthread_mutex_t;
+typedef HMTX pthread_mutex_t;
 typedef void pthread_mutexattr_t;
 
-#define PTHREAD_MUTEX_INITIALIZER _FMUTEX_INITIALIZER
-
 typedef struct {
     HEV event_sem;
     HEV ack_sem;
@@ -100,28 +98,28 @@ static av_always_inline int pthread_join(pthread_t thread, void **value_ptr)
 static av_always_inline int pthread_mutex_init(pthread_mutex_t *mutex,
                                                const pthread_mutexattr_t *attr)
 {
-    _fmutex_create(mutex, 0);
+    DosCreateMutexSem(NULL, (PHMTX)mutex, 0, FALSE);
 
     return 0;
 }
 
 static av_always_inline int pthread_mutex_destroy(pthread_mutex_t *mutex)
 {
-    _fmutex_close(mutex);
+    DosCloseMutexSem(*(PHMTX)mutex);
 
     return 0;
 }
 
 static av_always_inline int pthread_mutex_lock(pthread_mutex_t *mutex)
 {
-    _fmutex_request(mutex, 0);
+    DosRequestMutexSem(*(PHMTX)mutex, SEM_INDEFINITE_WAIT);
 
     return 0;
 }
 
 static av_always_inline int pthread_mutex_unlock(pthread_mutex_t *mutex)
 {
-    _fmutex_release(mutex);
+    DosReleaseMutexSem(*(PHMTX)mutex);
 
     return 0;
 }

compat/tms470/math.h

@@ -16,12 +16,15 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#ifndef AVFILTER_OPENCL_SOURCE_H
-#define AVFILTER_OPENCL_SOURCE_H
+#ifndef COMPAT_TMS470_MATH_H
+#define COMPAT_TMS470_MATH_H
 
-extern const char *ff_opencl_source_avgblur;
-extern const char *ff_opencl_source_convolution;
-extern const char *ff_opencl_source_overlay;
-extern const char *ff_opencl_source_unsharp;
+#include_next <math.h>
 
-#endif /* AVFILTER_OPENCL_SOURCE_H */
+#undef INFINITY
+#undef NAN
+
+#define INFINITY (*(const float*)((const unsigned []){ 0x7f800000 }))
+#define NAN      (*(const float*)((const unsigned []){ 0x7fc00000 }))
+
+#endif /* COMPAT_TMS470_MATH_H */

compat/w32dlfcn.h

@@ -21,7 +21,6 @@
 
 #ifdef _WIN32
 #include <windows.h>
-#include "config.h"
 #if (_WIN32_WINNT < 0x0602) || HAVE_WINRT
 #include "libavutil/wchar_filename.h"
 #endif

compat/w32pthreads.h

@@ -39,6 +39,11 @@
 #include <windows.h>
 #include <process.h>
 
+#if _WIN32_WINNT < 0x0600 && defined(__MINGW32__)
+#undef MemoryBarrier
+#define MemoryBarrier __sync_synchronize
+#endif
+
 #include "libavutil/attributes.h"
 #include "libavutil/common.h"
 #include "libavutil/internal.h"
@@ -51,15 +56,24 @@ typedef struct pthread_t {
     void *ret;
 } pthread_t;
 
-/* use light weight mutex/condition variable API for Windows Vista and later */
-typedef SRWLOCK pthread_mutex_t;
+/* the conditional variable api for windows 6.0+ uses critical sections and
+ * not mutexes */
+typedef CRITICAL_SECTION pthread_mutex_t;
+
+/* This is the CONDITION_VARIABLE typedef for using Windows' native
+ * conditional variables on kernels 6.0+. */
+#if HAVE_CONDITION_VARIABLE_PTR
 typedef CONDITION_VARIABLE pthread_cond_t;
+#else
+typedef struct pthread_cond_t {
+    void *Ptr;
+} pthread_cond_t;
+#endif
 
-#define PTHREAD_MUTEX_INITIALIZER SRWLOCK_INIT
-#define PTHREAD_COND_INITIALIZER CONDITION_VARIABLE_INIT
-
+#if _WIN32_WINNT >= 0x0600
 #define InitializeCriticalSection(x) InitializeCriticalSectionEx(x, 0, 0)
 #define WaitForSingleObject(a, b) WaitForSingleObjectEx(a, b, FALSE)
+#endif
 
 static av_unused unsigned __stdcall attribute_align_arg win32thread_worker(void *arg)
 {
@@ -100,25 +114,26 @@ static av_unused int pthread_join(pthread_t thread, void **value_ptr)
 
 static inline int pthread_mutex_init(pthread_mutex_t *m, void* attr)
 {
-    InitializeSRWLock(m);
+    InitializeCriticalSection(m);
     return 0;
 }
 static inline int pthread_mutex_destroy(pthread_mutex_t *m)
 {
-    /* Unlocked SWR locks use no resources */
+    DeleteCriticalSection(m);
     return 0;
 }
 static inline int pthread_mutex_lock(pthread_mutex_t *m)
 {
-    AcquireSRWLockExclusive(m);
+    EnterCriticalSection(m);
     return 0;
 }
 static inline int pthread_mutex_unlock(pthread_mutex_t *m)
 {
-    ReleaseSRWLockExclusive(m);
+    LeaveCriticalSection(m);
     return 0;
 }
 
+#if _WIN32_WINNT >= 0x0600
 typedef INIT_ONCE pthread_once_t;
 #define PTHREAD_ONCE_INIT INIT_ONCE_STATIC_INIT
 
@@ -152,7 +167,7 @@ static inline int pthread_cond_broadcast(pthread_cond_t *cond)
 
 static inline int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
 {
-    SleepConditionVariableSRW(cond, mutex, INFINITE, 0);
+    SleepConditionVariableCS(cond, mutex, INFINITE);
     return 0;
 }
 
@@ -162,4 +177,242 @@ static inline int pthread_cond_signal(pthread_cond_t *cond)
     return 0;
 }
 
+#else // _WIN32_WINNT < 0x0600
+
+/* atomic init state of dynamically loaded functions */
+static LONG w32thread_init_state = 0;
+static av_unused void w32thread_init(void);
+
+/* for pre-Windows 6.0 platforms, define INIT_ONCE struct,
+ * compatible to the one used in the native API */
+
+typedef union pthread_once_t  {
+    void * Ptr;    ///< For the Windows 6.0+ native functions
+    LONG state;    ///< For the pre-Windows 6.0 compat code
+} pthread_once_t;
+
+#define PTHREAD_ONCE_INIT {0}
+
+/* function pointers to init once API on windows 6.0+ kernels */
+static BOOL (WINAPI *initonce_begin)(pthread_once_t *lpInitOnce, DWORD dwFlags, BOOL *fPending, void **lpContext);
+static BOOL (WINAPI *initonce_complete)(pthread_once_t *lpInitOnce, DWORD dwFlags, void *lpContext);
+
+/* pre-Windows 6.0 compat using a spin-lock */
+static inline void w32thread_once_fallback(LONG volatile *state, void (*init_routine)(void))
+{
+    switch (InterlockedCompareExchange(state, 1, 0)) {
+    /* Initial run */
+    case 0:
+        init_routine();
+        InterlockedExchange(state, 2);
+        break;
+    /* Another thread is running init */
+    case 1:
+        while (1) {
+            MemoryBarrier();
+            if (*state == 2)
+                break;
+            Sleep(0);
+        }
+        break;
+    /* Initialization complete */
+    case 2:
+        break;
+    }
+}
+
+static av_unused int pthread_once(pthread_once_t *once_control, void (*init_routine)(void))
+{
+    w32thread_once_fallback(&w32thread_init_state, w32thread_init);
+
+    /* Use native functions on Windows 6.0+ */
+    if (initonce_begin && initonce_complete) {
+        BOOL pending = FALSE;
+        initonce_begin(once_control, 0, &pending, NULL);
+        if (pending)
+            init_routine();
+        initonce_complete(once_control, 0, NULL);
+        return 0;
+    }
+
+    w32thread_once_fallback(&once_control->state, init_routine);
+    return 0;
+}
+
+/* for pre-Windows 6.0 platforms we need to define and use our own condition
+ * variable and api */
+
+typedef struct  win32_cond_t {
+    pthread_mutex_t mtx_broadcast;
+    pthread_mutex_t mtx_waiter_count;
+    volatile int waiter_count;
+    HANDLE semaphore;
+    HANDLE waiters_done;
+    volatile int is_broadcast;
+} win32_cond_t;
+
+/* function pointers to conditional variable API on windows 6.0+ kernels */
+static void (WINAPI *cond_broadcast)(pthread_cond_t *cond);
+static void (WINAPI *cond_init)(pthread_cond_t *cond);
+static void (WINAPI *cond_signal)(pthread_cond_t *cond);
+static BOOL (WINAPI *cond_wait)(pthread_cond_t *cond, pthread_mutex_t *mutex,
+                                DWORD milliseconds);
+
+static av_unused int pthread_cond_init(pthread_cond_t *cond, const void *unused_attr)
+{
+    win32_cond_t *win32_cond = NULL;
+
+    w32thread_once_fallback(&w32thread_init_state, w32thread_init);
+
+    if (cond_init) {
+        cond_init(cond);
+        return 0;
+    }
+
+    /* non native condition variables */
+    win32_cond = (win32_cond_t*)av_mallocz(sizeof(win32_cond_t));
+    if (!win32_cond)
+        return ENOMEM;
+    cond->Ptr = win32_cond;
+    win32_cond->semaphore = CreateSemaphore(NULL, 0, 0x7fffffff, NULL);
+    if (!win32_cond->semaphore)
+        return ENOMEM;
+    win32_cond->waiters_done = CreateEvent(NULL, TRUE, FALSE, NULL);
+    if (!win32_cond->waiters_done)
+        return ENOMEM;
+
+    pthread_mutex_init(&win32_cond->mtx_waiter_count, NULL);
+    pthread_mutex_init(&win32_cond->mtx_broadcast, NULL);
+    return 0;
+}
+
+static av_unused int pthread_cond_destroy(pthread_cond_t *cond)
+{
+    win32_cond_t *win32_cond = (win32_cond_t*)cond->Ptr;
+    /* native condition variables do not destroy */
+    if (cond_init)
+        return 0;
+
+    /* non native condition variables */
+    CloseHandle(win32_cond->semaphore);
+    CloseHandle(win32_cond->waiters_done);
+    pthread_mutex_destroy(&win32_cond->mtx_waiter_count);
+    pthread_mutex_destroy(&win32_cond->mtx_broadcast);
+    av_freep(&win32_cond);
+    cond->Ptr = NULL;
+    return 0;
+}
+
+static av_unused int pthread_cond_broadcast(pthread_cond_t *cond)
+{
+    win32_cond_t *win32_cond = (win32_cond_t*)cond->Ptr;
+    int have_waiter;
+
+    if (cond_broadcast) {
+        cond_broadcast(cond);
+        return 0;
+    }
+
+    /* non native condition variables */
+    pthread_mutex_lock(&win32_cond->mtx_broadcast);
+    pthread_mutex_lock(&win32_cond->mtx_waiter_count);
+    have_waiter = 0;
+
+    if (win32_cond->waiter_count) {
+        win32_cond->is_broadcast = 1;
+        have_waiter = 1;
+    }
+
+    if (have_waiter) {
+        ReleaseSemaphore(win32_cond->semaphore, win32_cond->waiter_count, NULL);
+        pthread_mutex_unlock(&win32_cond->mtx_waiter_count);
+        WaitForSingleObject(win32_cond->waiters_done, INFINITE);
+        ResetEvent(win32_cond->waiters_done);
+        win32_cond->is_broadcast = 0;
+    } else
+        pthread_mutex_unlock(&win32_cond->mtx_waiter_count);
+    pthread_mutex_unlock(&win32_cond->mtx_broadcast);
+    return 0;
+}
+
+static av_unused int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
+{
+    win32_cond_t *win32_cond = (win32_cond_t*)cond->Ptr;
+    int last_waiter;
+    if (cond_wait) {
+        cond_wait(cond, mutex, INFINITE);
+        return 0;
+    }
+
+    /* non native condition variables */
+    pthread_mutex_lock(&win32_cond->mtx_broadcast);
+    pthread_mutex_lock(&win32_cond->mtx_waiter_count);
+    win32_cond->waiter_count++;
+    pthread_mutex_unlock(&win32_cond->mtx_waiter_count);
+    pthread_mutex_unlock(&win32_cond->mtx_broadcast);
+
+    // unlock the external mutex
+    pthread_mutex_unlock(mutex);
+    WaitForSingleObject(win32_cond->semaphore, INFINITE);
+
+    pthread_mutex_lock(&win32_cond->mtx_waiter_count);
+    win32_cond->waiter_count--;
+    last_waiter = !win32_cond->waiter_count || !win32_cond->is_broadcast;
+    pthread_mutex_unlock(&win32_cond->mtx_waiter_count);
+
+    if (last_waiter)
+        SetEvent(win32_cond->waiters_done);
+
+    // lock the external mutex
+    return pthread_mutex_lock(mutex);
+}
+
+static av_unused int pthread_cond_signal(pthread_cond_t *cond)
+{
+    win32_cond_t *win32_cond = (win32_cond_t*)cond->Ptr;
+    int have_waiter;
+    if (cond_signal) {
+        cond_signal(cond);
+        return 0;
+    }
+
+    pthread_mutex_lock(&win32_cond->mtx_broadcast);
+
+    /* non-native condition variables */
+    pthread_mutex_lock(&win32_cond->mtx_waiter_count);
+    have_waiter = win32_cond->waiter_count;
+    pthread_mutex_unlock(&win32_cond->mtx_waiter_count);
+
+    if (have_waiter) {
+        ReleaseSemaphore(win32_cond->semaphore, 1, NULL);
+        WaitForSingleObject(win32_cond->waiters_done, INFINITE);
+        ResetEvent(win32_cond->waiters_done);
+    }
+
+    pthread_mutex_unlock(&win32_cond->mtx_broadcast);
+    return 0;
+}
+#endif
+
+static av_unused void w32thread_init(void)
+{
+#if _WIN32_WINNT < 0x0600
+    HMODULE kernel_dll = GetModuleHandle(TEXT("kernel32.dll"));
+    /* if one is available, then they should all be available */
+    cond_init      = (void (WINAPI*)(pthread_cond_t *))
+        GetProcAddress(kernel_dll, "InitializeConditionVariable");
+    cond_broadcast = (void (WINAPI*)(pthread_cond_t *))
+        GetProcAddress(kernel_dll, "WakeAllConditionVariable");
+    cond_signal    = (void (WINAPI*)(pthread_cond_t *))
+        GetProcAddress(kernel_dll, "WakeConditionVariable");
+    cond_wait      = (BOOL (WINAPI*)(pthread_cond_t *, pthread_mutex_t *, DWORD))
+        GetProcAddress(kernel_dll, "SleepConditionVariableCS");
+    initonce_begin = (BOOL (WINAPI*)(pthread_once_t *, DWORD, BOOL *, void **))
+        GetProcAddress(kernel_dll, "InitOnceBeginInitialize");
+    initonce_complete = (BOOL (WINAPI*)(pthread_once_t *, DWORD, void *))
+        GetProcAddress(kernel_dll, "InitOnceComplete");
+#endif
+
+}
+
 #endif /* COMPAT_W32PTHREADS_H */

compat/windows/makedef

@@ -45,11 +45,7 @@ libname=$(mktemp -u "library").lib
 
 trap 'rm -f -- $libname' EXIT
 
-if [ -n "$AR" ]; then
-    $AR rcs ${libname} $@ >/dev/null
-else
-    lib -out:${libname} $@ >/dev/null
-fi
+lib -out:${libname} $@ >/dev/null
 if [ $? != 0 ]; then
     echo "Could not create temporary library." >&2
     exit 1
@@ -58,7 +54,23 @@ fi
 IFS='
 '
 
-prefix="$EXTERN_PREFIX"
+# Determine if we're building for x86 or x86_64 and
+# set the symbol prefix accordingly.
+prefix=""
+arch=$(dumpbin -headers ${libname} |
+       tr '\t' ' ' |
+       grep '^ \+.\+machine \+(.\+)' |
+       head -1 |
+       sed -e 's/^ \{1,\}.\{1,\} \{1,\}machine \{1,\}(\(...\)).*/\1/')
+
+if [ "${arch}" = "x86" ]; then
+    prefix="_"
+else
+    if [ "${arch}" != "ARM" ] && [ "${arch}" != "x64" ]; then
+        echo "Unknown machine type." >&2
+        exit 1
+    fi
+fi
 
 started=0
 regex="none"
@@ -100,19 +112,7 @@ for line in $(cat ${vscript} | tr '\t' ' '); do
 '
 done
 
-if [ -n "$NM" ]; then
-    # Use eval, since NM="nm -g"
-    dump=$(eval "$NM --defined-only -g ${libname}" |
-              grep -v : |
-              grep -v ^$ |
-              cut -d' ' -f3 |
-              sed -e "s/^${prefix}//")
-else
-    dump=$(dumpbin -linkermember:1 ${libname} |
-              sed -e '/public symbols/,$!d' -e '/^ \{1,\}Summary/,$d' -e "s/ \{1,\}${prefix}/ /" -e 's/ \{1,\}/ /g' |
-              tail -n +2 |
-              cut -d' ' -f3)
-fi
+dump=$(dumpbin -linkermember:1 ${libname})
 
 rm ${libname}
 
@@ -121,6 +121,9 @@ list=""
 for exp in ${regex}; do
     list="${list}"'
 '$(echo "${dump}" |
+          sed -e '/public symbols/,$!d' -e '/^ \{1,\}Summary/,$d' -e "s/ \{1,\}${prefix}/ /" -e 's/ \{1,\}/ /g' |
+          tail -n +2 |
+          cut -d' ' -f3 |
           grep "^${exp}" |
           sed -e 's/^/    /')
 done

doc/APIchanges

@@ -2,166 +2,19 @@ Never assume the API of libav* to be stable unless at least 1 month has passed
 since the last major version increase or the API was added.
 
 The last version increases were:
-libavcodec:    2017-10-21
-libavdevice:   2017-10-21
-libavfilter:   2017-10-21
-libavformat:   2017-10-21
-libavresample: 2017-10-21
-libpostproc:   2017-10-21
-libswresample: 2017-10-21
-libswscale:    2017-10-21
-libavutil:     2017-10-21
+libavcodec:    2015-08-28
+libavdevice:   2015-08-28
+libavfilter:   2015-08-28
+libavformat:   2015-08-28
+libavresample: 2015-08-28
+libpostproc:   2015-08-28
+libswresample: 2015-08-28
+libswscale:    2015-08-28
+libavutil:     2015-08-28
 
 
 API changes, most recent first:
 
--------- 8< --------- FFmpeg 4.0 was cut here -------- 8< ---------
-
-2018-04-03 - d6fc031caf - lavu 56.13.100 - pixdesc.h
-  Deprecate AV_PIX_FMT_FLAG_PSEUDOPAL and make allocating a pseudo palette
-  optional for API users (see AV_PIX_FMT_FLAG_PSEUDOPAL doxygen for details).
-
-2018-04-01 - 860086ee16 - lavc 58.17.100 - avcodec.h
-  Add av_packet_make_refcounted().
-
-2018-04-01 - f1805d160d - lavfi 7.14.100 - avfilter.h
-  Deprecate use of avfilter_register(), avfilter_register_all(),
-  avfilter_next(). Add av_filter_iterate().
-
-2018-03-25 - b7d0d912ef - lavc 58.16.100 - avcodec.h
-  Add FF_SUB_CHARENC_MODE_IGNORE.
-
-2018-03-23 - db2a7c947e - lavu 56.12.100 - encryption_info.h
-  Add AVEncryptionInitInfo and AVEncryptionInfo structures to hold new side-data
-  for encryption info.
-
-2018-03-21 - f14ca60001 - lavc 58.15.100 - avcodec.h
-  Add av_packet_make_writable().
-
-2018-03-18 - 4b86ac27a0 - lavu 56.11.100 - frame.h
-  Add AV_FRAME_DATA_QP_TABLE_PROPERTIES and AV_FRAME_DATA_QP_TABLE_DATA.
-
-2018-03-15 - e0e72539cf - lavu 56.10.100 - opt.h
-  Add AV_OPT_FLAG_BSF_PARAM
-
-2018-03-07 - 950170bd3b - lavu 56.9.100 - crc.h
-  Add AV_CRC_8_EBU crc variant.
-
-2018-03-07 - 2a0eb86857 - lavc 58.14.100 - mediacodec.h
-  Change the default behavior of avcodec_flush() on mediacodec
-  video decoders. To restore the previous behavior, use the new
-  delay_flush=1 option.
-
-2018-03-01 - 6731f60598 - lavu 56.8.100 - frame.h
-  Add av_frame_new_side_data_from_buf().
-
-2018-02-15 - 8a8d0b319a
-  Change av_ripemd_update(), av_murmur3_update() and av_hash_update() length
-  parameter type to size_t at next major bump.
-
-2018-02-12 - bcab11a1a2 - lavfi 7.12.100 - avfilter.h
-  Add AVFilterContext.extra_hw_frames.
-
-2018-02-12 - d23fff0d8a - lavc 58.11.100 - avcodec.h
-  Add AVCodecContext.extra_hw_frames.
-
-2018-02-06 - 0694d87024 - lavf 58.9.100 - avformat.h
-  Deprecate use of av_register_input_format(), av_register_output_format(),
-  av_register_all(), av_iformat_next(), av_oformat_next().
-  Add av_demuxer_iterate(), and av_muxer_iterate().
-
-2018-02-06 - 36c85d6e77 - lavc 58.10.100 - avcodec.h
-  Deprecate use of avcodec_register(), avcodec_register_all(),
-  av_codec_next(), av_register_codec_parser(), and av_parser_next().
-  Add av_codec_iterate() and av_parser_iterate().
-
-2018-02-04 - ff46124b0d - lavf 58.8.100 - avformat.h
-  Deprecate the current names of the RTSP "timeout", "stimeout", "user-agent"
-  options. Introduce "listen_timeout" as replacement for the current "timeout"
-  option, and "user_agent" as replacement for "user-agent". Once the deprecation
-  is over, the old "timeout" option will be removed, and "stimeout" will be
-  renamed to "stimeout" (the "timeout" option will essentially change semantics).
-
-2018-01-28 - ea3672b7d6 - lavf 58.7.100 - avformat.h
-  Deprecate AVFormatContext filename field which had limited length, use the
-  new dynamically allocated url field instead.
-
-2018-01-28 - ea3672b7d6 - lavf 58.7.100 - avformat.h
-  Add url field to AVFormatContext and add ff_format_set_url helper function.
-
-2018-01-27 - 6194d7e564 - lavf 58.6.100 - avformat.h
-  Add AVFMTCTX_UNSEEKABLE (for HLS demuxer).
-
-2018-01-23 - 9f07cf7c00 - lavu 56.9.100 - aes_ctr.h
-  Add method to set the 16-byte IV.
-
-2018-01-16 - 631c56a8e4 - lavf 58.5.100 - avformat.h
-  Explicitly make avformat_network_init() and avformat_network_deinit() optional.
-  If these are not called, network initialization and deinitialization is
-  automatic, and unlike in older versions, fully supported, unless libavformat
-  is linked to ancient GnuTLS and OpenSSL.
-
-2018-01-16 - 6512ff72f9 - lavf 58.4.100 - avformat.h
-  Deprecate AVStream.recommended_encoder_configuration. It was useful only for
-  FFserver, which has been removed.
-
-2018-01-05 - 798dcf2432 - lavfi 7.11.101 - avfilter.h
-  Deprecate avfilter_link_get_channels(). Use av_buffersink_get_channels().
-
-2017-01-04 - c29038f304 - lavr 4.0.0 - avresample.h
-  Deprecate the entire library. Merged years ago to provide compatibility
-  with Libav, it remained unmaintained by the FFmpeg project and duplicated
-  functionality provided by libswresample.
-
-  In order to improve consistency and reduce attack surface, it has been deprecated.
-  Users of this library are asked to migrate to libswresample, which, as well as
-  providing more functionality, is faster and has higher accuracy.
-
-2017-12-26 - a04c2c707d - lavc 58.9.100 - avcodec.h
-  Deprecate av_lockmgr_register(). You need to build FFmpeg with threading
-  support enabled to get basic thread-safety (which is the default build
-  configuration).
-
-2017-12-24 - 8b81eabe57 - lavu 56.7.100 - cpu.h
-  AVX-512 flags added.
-
-2017-12-16 - 8bf4e6d3ce - lavc 58.8.100 - avcodec.h
-  The MediaCodec decoders now support AVCodecContext.hw_device_ctx.
-
-2017-12-16 - e4d9f05ca7 - lavu 56.6.100 - hwcontext.h hwcontext_mediacodec.h
-  Add AV_HWDEVICE_TYPE_MEDIACODEC and a new installed header with
-  MediaCodec-specific hwcontext definitions.
-
-2017-12-14 - b945fed629 - lavc 58.7.100 - avcodec.h
-  Add AV_CODEC_CAP_HARDWARE, AV_CODEC_CAP_HYBRID, and AVCodec.wrapper_name,
-  and mark all AVCodecs accordingly.
-
-2017-11-29 - d268094f88 - lavu 56.4.100 / 56.7.0 - stereo3d.h
-  Add view field to AVStereo3D structure and AVStereo3DView enum.
-
-2017-11-26 - 3a71bcc213 - lavc 58.6.100 - avcodec.h
-  Add const to AVCodecContext.hwaccel.
-
-2017-11-26 - 3536a3efb9 - lavc 58.5.100 - avcodec.h
-  Deprecate user visibility of the AVHWAccel structure and the functions
-  av_register_hwaccel() and av_hwaccel_next().
-
-2017-11-26 - 24cc0a53e9 - lavc 58.4.100 - avcodec.h
-  Add AVCodecHWConfig and avcodec_get_hw_config().
-
-2017-11-22 - 3650cb2dfa - lavu 56.3.100 - opencl.h
-  Remove experimental OpenCL API (av_opencl_*).
-
-2017-11-22 - b25d8ef0a7 - lavu 56.2.100 - hwcontext.h hwcontext_opencl.h
-  Add AV_HWDEVICE_TYPE_OPENCL and a new installed header with
-  OpenCL-specific hwcontext definitions.
-
-2017-11-22 - a050f56c09 - lavu 56.1.100 - pixfmt.h
-  Add AV_PIX_FMT_OPENCL.
-
-2017-11-11 - 48e4eda11d - lavc 58.3.100 - avcodec.h
-  Add avcodec_get_hw_frames_parameters().
-
 -------- 8< --------- FFmpeg 3.4 was cut here -------- 8< ---------
 
 2017-09-28 - b6cf66ae1c - lavc 57.106.104 - avcodec.h

doc/Doxyfile

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

doc/bitstream_filters.texi

@@ -50,22 +50,21 @@ DTS-HD.
 
 Add extradata to the beginning of the filtered packets.
 
-@table @option
-@item freq
 The additional argument specifies which packets should be filtered.
 It accepts the values:
 @table @samp
+@item a
+add extradata to all key packets, but only if @var{local_header} is
+set in the @option{flags2} codec context field
+
 @item k
-@item keyframe
 add extradata to all key packets
 
 @item e
-@item all
 add extradata to all packets
 @end table
-@end table
 
-If not specified it is assumed @samp{e}.
+If not specified it is assumed @samp{k}.
 
 For example the following @command{ffmpeg} command forces a global
 header (thus disabling individual packet headers) in the H.264 packets
@@ -75,10 +74,6 @@ the header stored in extradata to the key packets:
 ffmpeg -i INPUT -map 0 -flags:v +global_header -c:v libx264 -bsf:v dump_extra out.ts
 @end example
 
-@section eac3_core
-
-Extract the core from a E-AC-3 stream, dropping extra channels.
-
 @section extract_extradata
 
 Extract the in-band extradata.
@@ -97,126 +92,6 @@ When this option is enabled, the long-term headers are removed from the
 bitstream after extraction.
 @end table
 
-@section filter_units
-
-Remove units with types in or not in a given set from the stream.
-
-@table @option
-@item pass_types
-List of unit types or ranges of unit types to pass through while removing
-all others.  This is specified as a '|'-separated list of unit type values
-or ranges of values with '-'.
-
-@item remove_types
-Identical to @option{pass_types}, except the units in the given set
-removed and all others passed through.
-@end table
-
-Extradata is unchanged by this transformation, but note that if the stream
-contains inline parameter sets then the output may be unusable if they are
-removed.
-
-For example, to remove all non-VCL NAL units from an H.264 stream:
-@example
-ffmpeg -i INPUT -c:v copy -bsf:v 'filter_units=pass_types=1-5' OUTPUT
-@end example
-
-To remove all AUDs, SEI and filler from an H.265 stream:
-@example
-ffmpeg -i INPUT -c:v copy -bsf:v 'filter_units=remove_types=35|38-40' OUTPUT
-@end example
-
-@section hapqa_extract
-
-Extract Rgb or Alpha part of an HAPQA file, without recompression, in order to create an HAPQ or an HAPAlphaOnly file.
-
-@table @option
-@item texture
-Specifies the texture to keep.
-
-@table @option
-@item color
-@item alpha
-@end table
-
-@end table
-
-Convert HAPQA to HAPQ
-@example
-ffmpeg -i hapqa_inputfile.mov -c copy -bsf:v hapqa_extract=texture=color -tag:v HapY -metadata:s:v:0 encoder="HAPQ" hapq_file.mov
-@end example
-
-Convert HAPQA to HAPAlphaOnly
-@example
-ffmpeg -i hapqa_inputfile.mov -c copy -bsf:v hapqa_extract=texture=alpha -tag:v HapA -metadata:s:v:0 encoder="HAPAlpha Only" hapalphaonly_file.mov
-@end example
-
-@section h264_metadata
-
-Modify metadata embedded in an H.264 stream.
-
-@table @option
-@item aud
-Insert or remove AUD NAL units in all access units of the stream.
-
-@table @samp
-@item insert
-@item remove
-@end table
-
-@item sample_aspect_ratio
-Set the sample aspect ratio of the stream in the VUI parameters.
-
-@item video_format
-@item video_full_range_flag
-Set the video format in the stream (see H.264 section E.2.1 and
-table E-2).
-
-@item colour_primaries
-@item transfer_characteristics
-@item matrix_coefficients
-Set the colour description in the stream (see H.264 section E.2.1
-and tables E-3, E-4 and E-5).
-
-@item chroma_sample_loc_type
-Set the chroma sample location in the stream (see H.264 section
-E.2.1 and figure E-1).
-
-@item tick_rate
-Set the tick rate (num_units_in_tick / time_scale) in the VUI
-parameters.  This is the smallest time unit representable in the
-stream, and in many cases represents the field rate of the stream
-(double the frame rate).
-@item fixed_frame_rate_flag
-Set whether the stream has fixed framerate - typically this indicates
-that the framerate is exactly half the tick rate, but the exact
-meaning is dependent on interlacing and the picture structure (see
-H.264 section E.2.1 and table E-6).
-
-@item crop_left
-@item crop_right
-@item crop_top
-@item crop_bottom
-Set the frame cropping offsets in the SPS.  These values will replace
-the current ones if the stream is already cropped.
-
-These fields are set in pixels.  Note that some sizes may not be
-representable if the chroma is subsampled or the stream is interlaced
-(see H.264 section 7.4.2.1.1).
-
-@item sei_user_data
-Insert a string as SEI unregistered user data.  The argument must
-be of the form @emph{UUID+string}, where the UUID is as hex digits
-possibly separated by hyphens, and the string can be anything.
-
-For example, @samp{086f3693-b7b3-4f2c-9653-21492feee5b8+hello} will
-insert the string ``hello'' associated with the given UUID.
-
-@item delete_filler
-Deletes both filler NAL units and filler SEI messages.
-
-@end table
-
 @section h264_mp4toannexb
 
 Convert an H.264 bitstream from length prefixed mode to start code
@@ -236,69 +111,6 @@ ffmpeg -i INPUT.mp4 -codec copy -bsf:v h264_mp4toannexb OUTPUT.ts
 Please note that this filter is auto-inserted for MPEG-TS (muxer
 @code{mpegts}) and raw H.264 (muxer @code{h264}) output formats.
 
-@section h264_redundant_pps
-
-This applies a specific fixup to some Blu-ray streams which contain
-redundant PPSs modifying irrelevant parameters of the stream which
-confuse other transformations which require correct extradata.
-
-A new single global PPS is created, and all of the redundant PPSs
-within the stream are removed.
-
-@section hevc_metadata
-
-Modify metadata embedded in an HEVC stream.
-
-@table @option
-@item aud
-Insert or remove AUD NAL units in all access units of the stream.
-
-@table @samp
-@item insert
-@item remove
-@end table
-
-@item sample_aspect_ratio
-Set the sample aspect ratio in the stream in the VUI parameters.
-
-@item video_format
-@item video_full_range_flag
-Set the video format in the stream (see H.265 section E.3.1 and
-table E.2).
-
-@item colour_primaries
-@item transfer_characteristics
-@item matrix_coefficients
-Set the colour description in the stream (see H.265 section E.3.1
-and tables E.3, E.4 and E.5).
-
-@item chroma_sample_loc_type
-Set the chroma sample location in the stream (see H.265 section
-E.3.1 and figure E.1).
-
-@item tick_rate
-Set the tick rate in the VPS and VUI parameters (num_units_in_tick /
-time_scale).  Combined with @option{num_ticks_poc_diff_one}, this can
-set a constant framerate in the stream.  Note that it is likely to be
-overridden by container parameters when the stream is in a container.
-
-@item num_ticks_poc_diff_one
-Set poc_proportional_to_timing_flag in VPS and VUI and use this value
-to set num_ticks_poc_diff_one_minus1 (see H.265 sections 7.4.3.1 and
-E.3.1).  Ignored if @option{tick_rate} is not also set.
-
-@item crop_left
-@item crop_right
-@item crop_top
-@item crop_bottom
-Set the conformance window cropping offsets in the SPS.  These values
-will replace the current ones if the stream is already cropped.
-
-These fields are set in pixels.  Note that some sizes may not be
-representable if the chroma is subsampled (H.265 section 7.4.3.2.1).
-
-@end table
-
 @section hevc_mp4toannexb
 
 Convert an HEVC/H.265 bitstream from length prefixed mode to start code
@@ -386,42 +198,6 @@ See also the @ref{text2movsub} filter.
 
 Decompress non-standard compressed MP3 audio headers.
 
-@section mpeg2_metadata
-
-Modify metadata embedded in an MPEG-2 stream.
-
-@table @option
-@item display_aspect_ratio
-Set the display aspect ratio in the stream.
-
-The following fixed values are supported:
-@table @option
-@item 4/3
-@item 16/9
-@item 221/100
-@end table
-Any other value will result in square pixels being signalled instead
-(see H.262 section 6.3.3 and table 6-3).
-
-@item frame_rate
-Set the frame rate in the stream.  This is constructed from a table
-of known values combined with a small multiplier and divisor - if
-the supplied value is not exactly representable, the nearest
-representable value will be used instead (see H.262 section 6.3.3
-and table 6-4).
-
-@item video_format
-Set the video format in the stream (see H.262 section 6.3.6 and
-table 6-6).
-
-@item colour_primaries
-@item transfer_characteristics
-@item matrix_coefficients
-Set the colour description in the stream (see H.262 section 6.3.6
-and tables 6-7, 6-8 and 6-9).
-
-@end table
-
 @section mpeg4_unpack_bframes
 
 Unpack DivX-style packed B-frames.
@@ -499,14 +275,6 @@ codec) with metadata headers.
 
 See also the @ref{mov2textsub} filter.
 
-@section trace_headers
-
-Log trace output containing all syntax elements in the coded stream
-headers (everything above the level of individual coded blocks).
-This can be useful for debugging low-level stream issues.
-
-Supports H.264, H.265 and MPEG-2.
-
 @section vp9_superframe
 
 Merge VP9 invisible (alt-ref) frames back into VP9 superframes. This

doc/codecs.texi

@@ -44,6 +44,12 @@ Use 1/4 pel motion compensation.
 Use loop filter.
 @item qscale
 Use fixed qscale.
+@item gmc
+Use gmc.
+@item mv0
+Always try a mb with mv=<0,0>.
+@item input_preserved
+
 @item pass1
 Use internal 2pass ratecontrol in first pass mode.
 @item pass2
@@ -56,6 +62,8 @@ Do not draw edges.
 Set error[?] variables during encoding.
 @item truncated
 
+@item naq
+Normalize adaptive quantization.
 @item ildct
 Use interlaced DCT.
 @item low_delay
@@ -467,6 +475,8 @@ rate control
 macroblock (MB) type
 @item qp
 per-block quantization parameter (QP)
+@item mv
+motion vector
 @item dct_coeff
 
 @item green_metadata
@@ -476,12 +486,18 @@ display complexity metadata for the upcoming frame, GoP or for a given duration.
 
 @item startcode
 
+@item pts
+
 @item er
 error recognition
 @item mmco
 memory management control operations (H.264)
 @item bugs
 
+@item vis_qp
+visualize quantization parameter (QP), lower QP are tinted greener
+@item vis_mb_type
+visualize block types
 @item buffers
 picture buffer allocations
 @item thread_ops
@@ -490,6 +506,21 @@ threading operations
 skip motion compensation
 @end table
 
+@item vismv @var{integer} (@emph{decoding,video})
+Visualize motion vectors (MVs).
+
+This option is deprecated, see the codecview filter instead.
+
+Possible values:
+@table @samp
+@item pf
+forward predicted MVs of P-frames
+@item bf
+forward predicted MVs of B-frames
+@item bb
+backward predicted MVs of B-frames
+@end table
+
 @item cmp @var{integer} (@emph{encoding,video})
 Set full pel me compare function.
 
@@ -726,6 +757,8 @@ Set context model.
 
 @item slice_flags @var{integer}
 
+@item xvmc_acceleration @var{integer}
+
 @item mbd @var{integer} (@emph{encoding,video})
 Set macroblock decision algorithm (high quality mode).
 

doc/decoders.texi

@@ -25,6 +25,13 @@ enabled decoders.
 A description of some of the currently available video decoders
 follows.
 
+@section hevc
+
+HEVC / H.265 decoder.
+
+Note: the @option{skip_loop_filter} option has effect only at level
+@code{all}.
+
 @section rawvideo
 
 Raw video decoder.

doc/demuxers.texi

@@ -244,16 +244,6 @@ file subdir/file-2.wav
 @end example
 @end itemize
 
-@section dash
-
-Dynamic Adaptive Streaming over HTTP demuxer.
-
-This demuxer presents all AVStreams found in the manifest.
-By setting the discard flags on AVStreams the caller can decide
-which streams to actually receive.
-Each stream mirrors the @code{id} and @code{bandwidth} properties from the
-@code{<Representation>} as metadata keys named "id" and "variant_bitrate" respectively.
-
 @section flv, live_flv
 
 Adobe Flash Video Format demuxer.
@@ -326,14 +316,6 @@ segment index to start live streams at (negative values are from the end).
 @item max_reload
 Maximum number of times a insufficient list is attempted to be reloaded.
 Default value is 1000.
-
-@item http_persistent
-Use persistent HTTP connections. Applicable only for HTTP streams.
-Enabled by default.
-
-@item http_multiple
-Use multiple HTTP connections for downloading HTTP segments.
-Enabled by default for HTTP/1.1 servers.
 @end table
 
 @section image2

doc/developer.texi

@@ -10,7 +10,9 @@
 
 @contents
 
-@chapter Notes for external developers
+@chapter Developers Guide
+
+@section Notes for external developers
 
 This document is mostly useful for internal FFmpeg developers.
 External developers who need to use the API in their application should
@@ -28,13 +30,15 @@ For more detailed legal information about the use of FFmpeg in
 external programs read the @file{LICENSE} file in the source tree and
 consult @url{https://ffmpeg.org/legal.html}.
 
-@chapter Contributing
+@section Contributing
 
-There are 2 ways by which code gets into FFmpeg:
+There are 3 ways by which code gets into FFmpeg.
 @itemize @bullet
-@item Submitting patches to the ffmpeg-devel mailing list.
+@item Submitting patches to the main developer mailing list.
       See @ref{Submitting patches} for details.
 @item Directly committing changes to the main tree.
+@item Committing changes to a git clone, for example on github.com or
+      gitorious.org. And asking us to merge these changes.
 @end itemize
 
 Whichever way, changes should be reviewed by the maintainer of the code
@@ -43,9 +47,9 @@ The developer making the commit and the author are responsible for their changes
 and should try to fix issues their commit causes.
 
 @anchor{Coding Rules}
-@chapter Coding Rules
+@section Coding Rules
 
-@section Code formatting conventions
+@subsection Code formatting conventions
 
 There are the following guidelines regarding the indentation in files:
 
@@ -70,7 +74,7 @@ The presentation is one inspired by 'indent -i4 -kr -nut'.
 The main priority in FFmpeg is simplicity and small code size in order to
 minimize the bug count.
 
-@section Comments
+@subsection Comments
 Use the JavaDoc/Doxygen  format (see examples below) so that code documentation
 can be generated automatically. All nontrivial functions should have a comment
 above them explaining what the function does, even if it is just one sentence.
@@ -110,7 +114,7 @@ int myfunc(int my_parameter)
 ...
 @end example
 
-@section C language features
+@subsection C language features
 
 FFmpeg is programmed in the ISO C90 language with a few additional
 features from ISO C99, namely:
@@ -156,7 +160,7 @@ mixing statements and declarations;
 GCC statement expressions (@samp{(x = (@{ int y = 4; y; @})}).
 @end itemize
 
-@section Naming conventions
+@subsection Naming conventions
 All names should be composed with underscores (_), not CamelCase. For example,
 @samp{avfilter_get_video_buffer} is an acceptable function name and
 @samp{AVFilterGetVideo} is not. The exception from this are type names, like
@@ -180,7 +184,7 @@ e.g. @samp{ff_w64_demuxer}.
 @item
 For variables and functions visible outside of file scope, used internally
 across multiple libraries, use @code{avpriv_} as prefix, for example,
-@samp{avpriv_report_missing_feature}.
+@samp{avpriv_aac_parse_header}.
 
 @item
 Each library has its own prefix for public symbols, in addition to the
@@ -200,7 +204,7 @@ letter as they are reserved by the C standard. Names starting with @code{_}
 are reserved at the file level and may not be used for externally visible
 symbols. If in doubt, just avoid names starting with @code{_} altogether.
 
-@section Miscellaneous conventions
+@subsection Miscellaneous conventions
 
 @itemize @bullet
 @item
@@ -212,7 +216,7 @@ Casts should be used only when necessary. Unneeded parentheses
 should also be avoided if they don't make the code easier to understand.
 @end itemize
 
-@section Editor configuration
+@subsection Editor configuration
 In order to configure Vim to follow FFmpeg formatting conventions, paste
 the following snippet into your @file{.vimrc}:
 @example
@@ -245,9 +249,9 @@ For Emacs, add these roughly equivalent lines to your @file{.emacs.d/init.el}:
 (setq c-default-style "ffmpeg")
 @end lisp
 
-@chapter Development Policy
+@section Development Policy
 
-@section Patches/Committing
+@subsection Patches/Committing
 @subheading Licenses for patches must be compatible with FFmpeg.
 Contributions should be licensed under the
 @uref{http://www.gnu.org/licenses/lgpl-2.1.html, LGPL 2.1},
@@ -346,7 +350,7 @@ time-frame (12h for build failures and security fixes, 3 days small changes,
 1 week for big patches) then commit your patch if you think it is OK.
 Also note, the maintainer can simply ask for more time to review!
 
-@section Code
+@subsection Code
 @subheading API/ABI changes should be discussed before they are made.
 Do not change behavior of the programs (renaming options etc) or public
 API or ABI without first discussing it on the ffmpeg-devel mailing list.
@@ -377,29 +381,12 @@ Never write to unallocated memory, never write over the end of arrays,
 always check values read from some untrusted source before using them
 as array index or other risky things.
 
-@section Documentation/Other
-@subheading Subscribe to the ffmpeg-devel mailing list.
-It is important to be subscribed to the
-@uref{https://lists.ffmpeg.org/mailman/listinfo/ffmpeg-devel, ffmpeg-devel}
-mailing list. Almost any non-trivial patch is to be sent there for review.
-Other developers may have comments about your contribution. We expect you see
-those comments, and to improve it if requested. (N.B. Experienced committers
-have other channels, and may sometimes skip review for trivial fixes.) Also,
-discussion here about bug fixes and FFmpeg improvements by other developers may
-be helpful information for you. Finally, by being a list subscriber, your
-contribution will be posted immediately to the list, without the moderation
-hold which messages from non-subscribers experience.
-
-However, it is more important to the project that we receive your patch than
-that you be subscribed to the ffmpeg-devel list. If you have a patch, and don't
-want to subscribe and discuss the patch, then please do send it to the list
-anyway.
-
+@subsection Documentation/Other
 @subheading Subscribe to the ffmpeg-cvslog mailing list.
-Diffs of all commits are sent to the
-@uref{https://lists.ffmpeg.org/mailman/listinfo/ffmpeg-cvslog, ffmpeg-cvslog}
-mailing list. Some developers read this list to review all code base changes
-from all sources. Subscribing to this list is not mandatory.
+It is important to do this as the diffs of all commits are sent there and
+reviewed by all the other developers. Bugs and possible improvements or
+general questions regarding commits are discussed there. We expect you to
+react if problems with your code are uncovered.
 
 @subheading Keep the documentation up to date.
 Update the documentation if you change behavior or add features. If you are
@@ -419,7 +406,7 @@ finding a new maintainer and also don't forget to update the @file{MAINTAINERS}
 
 We think our rules are not too hard. If you have comments, contact us.
 
-@chapter Code of conduct
+@section Code of conduct
 
 Be friendly and respectful towards others and third parties.
 Treat others the way you yourself want to be treated.
@@ -449,7 +436,7 @@ Finally, keep in mind the immortal words of Bill and Ted,
 "Be excellent to each other."
 
 @anchor{Submitting patches}
-@chapter Submitting patches
+@section Submitting patches
 
 First, read the @ref{Coding Rules} above if you did not yet, in particular
 the rules regarding patch submission.
@@ -498,7 +485,7 @@ Give us a few days to react. But if some time passes without reaction,
 send a reminder by email. Your patch should eventually be dealt with.
 
 
-@chapter New codecs or formats checklist
+@section New codecs or formats checklist
 
 @enumerate
 @item
@@ -550,7 +537,7 @@ Did you make sure it compiles standalone, i.e. with
 @end enumerate
 
 
-@chapter Patch submission checklist
+@section patch submission checklist
 
 @enumerate
 @item
@@ -560,9 +547,9 @@ Does @code{make fate} pass with the patch applied?
 Was the patch generated with git format-patch or send-email?
 
 @item
-Did you sign-off your patch? (@code{git commit -s})
-See @uref{https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/plain/Documentation/process/submitting-patches.rst, Sign your work} for the meaning
-of @dfn{sign-off}.
+Did you sign off your patch? (git commit -s)
+See @url{http://git.kernel.org/?p=linux/kernel/git/torvalds/linux.git;a=blob_plain;f=Documentation/SubmittingPatches} for the meaning
+of sign off.
 
 @item
 Did you provide a clear git commit log message?
@@ -663,7 +650,7 @@ Test your code with valgrind and or Address Sanitizer to ensure it's free
 of leaks, out of array accesses, etc.
 @end enumerate
 
-@chapter Patch review process
+@section Patch review process
 
 All patches posted to ffmpeg-devel will be reviewed, unless they contain a
 clear note that the patch is not for the git master branch.
@@ -694,7 +681,7 @@ to be reviewed, please consider helping to review other patches, that is a great
 way to get everyone's patches reviewed sooner.
 
 @anchor{Regression tests}
-@chapter Regression tests
+@section Regression tests
 
 Before submitting a patch (or committing to the repository), you should at least
 test that you did not break anything.
@@ -705,7 +692,7 @@ Running 'make fate' accomplishes this, please see @url{fate.html} for details.
 this case, the reference results of the regression tests shall be modified
 accordingly].
 
-@section Adding files to the fate-suite dataset
+@subsection Adding files to the fate-suite dataset
 
 When there is no muxer or encoder available to generate test media for a
 specific test then the media has to be included in the fate-suite.
@@ -716,7 +703,7 @@ Once you have a working fate test and fate sample, provide in the commit
 message or introductory message for the patch series that you post to
 the ffmpeg-devel mailing list, a direct link to download the sample media.
 
-@section Visualizing Test Coverage
+@subsection Visualizing Test Coverage
 
 The FFmpeg build system allows visualizing the test coverage in an easy
 manner with the coverage tools @code{gcov}/@code{lcov}.  This involves
@@ -743,7 +730,7 @@ You can use the command @code{make lcov-reset} to reset the coverage
 measurements. You will need to rerun @code{make lcov} after running a
 new test.
 
-@section Using Valgrind
+@subsection Using Valgrind
 
 The configure script provides a shortcut for using valgrind to spot bugs
 related to memory handling. Just add the option
@@ -757,7 +744,7 @@ In case you need finer control over how valgrind is invoked, use the
 your configure line instead.
 
 @anchor{Release process}
-@chapter Release process
+@section Release process
 
 FFmpeg maintains a set of @strong{release branches}, which are the
 recommended deliverable for system integrators and distributors (such as
@@ -789,7 +776,7 @@ adjustments to the symbol versioning file. Please discuss such changes
 on the @strong{ffmpeg-devel} mailing list in time to allow forward planning.
 
 @anchor{Criteria for Point Releases}
-@section Criteria for Point Releases
+@subsection Criteria for Point Releases
 
 Changes that match the following criteria are valid candidates for
 inclusion into a point release:
@@ -813,7 +800,7 @@ point releases of the same release branch.
 The order for checking the rules is (1 OR 2 OR 3) AND 4.
 
 
-@section Release Checklist
+@subsection Release Checklist
 
 The release process involves the following steps:
 

doc/encoders.texi

@@ -64,6 +64,7 @@ to find an optimal combination by adding or subtracting a specific value from
 all quantizers and adjusting some individual quantizer a little.  Will tune
 itself based on whether @option{aac_is}, @option{aac_ms} and @option{aac_pns}
 are enabled.
+This is the default choice for a coder.
 
 @item anmr
 Average noise to mask ratio (ANMR) trellis-based solution.
@@ -76,10 +77,10 @@ Not currently recommended.
 @item fast
 Constant quantizer method.
 
-Uses a cheaper version of twoloop algorithm that doesn't try to do as many
-clever adjustments. Worse with low bitrates (less than 64kbps), but is better
-and much faster at higher bitrates.
-This is the default choice for a coder
+This method sets a constant quantizer for all bands. This is the fastest of all
+the methods and has no rate control or support for @option{aac_is} or
+@option{aac_pns}.
+Not recommended.
 
 @end table
 
@@ -981,11 +982,6 @@ Other values include 0 for mono and stereo, 1 for surround sound with masking
 and LFE bandwidth optimizations, and 255 for independent streams with an
 unspecified channel layout.
 
-@item apply_phase_inv (N.A.) (requires libopus >= 1.2)
-If set to 0, disables the use of phase inversion for intensity stereo,
-improving the quality of mono downmixes, but slightly reducing normal stereo
-quality. The default is 1 (phase inversion enabled).
-
 @end table
 
 @anchor{libshine}
@@ -1685,13 +1681,6 @@ colorspaces:
 @end table
 @item row-mt @var{boolean}
 Enable row based multi-threading.
-@item tune-content
-Set content type: default (0), screen (1), film (2).
-@item corpus-complexity
-Corpus VBR mode is a variant of standard VBR where the complexity distribution
-midpoint is passed in rather than calculated for a specific clip or chunk.
-
-The valid range is [0, 10000]. 0 (default) uses standard VBR.
 @end table
 
 @end table
@@ -2159,12 +2148,6 @@ Set the x265 preset.
 @item tune
 Set the x265 tune parameter.
 
-@item profile
-Set profile restrictions.
-
-@item crf
-Set the quality for constant quality mode.
-
 @item forced-idr
 Normally, when forcing a I-frame type, the encoder can select any type
 of I-frame. This option forces it to choose an IDR-frame.
@@ -2365,11 +2348,6 @@ Never write it.
 @itemx always
 Always write it.
 @end table
-@item video_format @var{integer}
-Specifies the video_format written into the sequence display extension
-indicating the source of the video pictures. The default is @samp{unspecified},
-can be @samp{component}, @samp{pal}, @samp{ntsc}, @samp{secam} or @samp{mac}.
-For maximum compatibility, use @samp{component}.
 @end table
 
 @section png

doc/examples/Makefile

@@ -19,8 +19,6 @@ EXAMPLES-$(CONFIG_RESAMPLING_AUDIO_EXAMPLE)  += resampling_audio
 EXAMPLES-$(CONFIG_SCALING_VIDEO_EXAMPLE)     += scaling_video
 EXAMPLES-$(CONFIG_TRANSCODE_AAC_EXAMPLE)     += transcode_aac
 EXAMPLES-$(CONFIG_TRANSCODING_EXAMPLE)       += transcoding
-EXAMPLES-$(CONFIG_VAAPI_ENCODE_EXAMPLE)      += vaapi_encode
-EXAMPLES-$(CONFIG_VAAPI_TRANSCODE_EXAMPLE)   += vaapi_transcode
 
 EXAMPLES       := $(EXAMPLES-yes:%=doc/examples/%$(PROGSSUF)$(EXESUF))
 EXAMPLES_G     := $(EXAMPLES-yes:%=doc/examples/%$(PROGSSUF)_g$(EXESUF))

doc/examples/avio_dir_cmd.c

@@ -143,6 +143,8 @@ int main(int argc, char *argv[])
         return 1;
     }
 
+    /* register codecs and formats and other lavf/lavc components*/
+    av_register_all();
     avformat_network_init();
 
     op = argv[1];

doc/examples/avio_reading.c

@@ -44,8 +44,6 @@ static int read_packet(void *opaque, uint8_t *buf, int buf_size)
     struct buffer_data *bd = (struct buffer_data *)opaque;
     buf_size = FFMIN(buf_size, bd->size);
 
-    if (!buf_size)
-        return AVERROR_EOF;
     printf("ptr:%p size:%zu\n", bd->ptr, bd->size);
 
     /* copy internal buffer data to buf */
@@ -74,6 +72,9 @@ int main(int argc, char *argv[])
     }
     input_filename = argv[1];
 
+    /* register codecs and formats and other lavf/lavc components*/
+    av_register_all();
+
     /* slurp file content into buffer */
     ret = av_file_map(input_filename, &buffer, &buffer_size, 0, NULL);
     if (ret < 0)

doc/examples/decode_audio.c

@@ -94,6 +94,9 @@ int main(int argc, char **argv)
     filename    = argv[1];
     outfilename = argv[2];
 
+    /* register all the codecs */
+    avcodec_register_all();
+
     pkt = av_packet_alloc();
 
     /* find the MPEG audio decoder */

doc/examples/decode_video.c

@@ -101,6 +101,8 @@ int main(int argc, char **argv)
     filename    = argv[1];
     outfilename = argv[2];
 
+    avcodec_register_all();
+
     pkt = av_packet_alloc();
     if (!pkt)
         exit(1);

doc/examples/demuxing_decoding.c

@@ -252,6 +252,9 @@ int main (int argc, char **argv)
     video_dst_filename = argv[2];
     audio_dst_filename = argv[3];
 
+    /* register all formats and codecs */
+    av_register_all();
+
     /* open input file, and allocate format context */
     if (avformat_open_input(&fmt_ctx, src_filename, NULL, NULL) < 0) {
         fprintf(stderr, "Could not open source file %s\n", src_filename);

doc/examples/encode_audio.c

@@ -138,6 +138,9 @@ int main(int argc, char **argv)
     }
     filename = argv[1];
 
+    /* register all the codecs */
+    avcodec_register_all();
+
     /* find the MP2 encoder */
     codec = avcodec_find_encoder(AV_CODEC_ID_MP2);
     if (!codec) {

doc/examples/encode_video.c

@@ -84,6 +84,8 @@ int main(int argc, char **argv)
     filename = argv[1];
     codec_name = argv[2];
 
+    avcodec_register_all();
+
     /* find the mpeg1video encoder */
     codec = avcodec_find_encoder_by_name(codec_name);
     if (!codec) {

doc/examples/extract_mvs.c

@@ -129,6 +129,8 @@ int main(int argc, char **argv)
     }
     src_filename = argv[1];
 
+    av_register_all();
+
     if (avformat_open_input(&fmt_ctx, src_filename, NULL, NULL) < 0) {
         fprintf(stderr, "Could not open source file %s\n", src_filename);
         exit(1);

doc/examples/filter_audio.c

@@ -64,13 +64,13 @@ static int init_filter_graph(AVFilterGraph **graph, AVFilterContext **src,
 {
     AVFilterGraph *filter_graph;
     AVFilterContext *abuffer_ctx;
-    const AVFilter  *abuffer;
+    AVFilter        *abuffer;
     AVFilterContext *volume_ctx;
-    const AVFilter  *volume;
+    AVFilter        *volume;
     AVFilterContext *aformat_ctx;
-    const AVFilter  *aformat;
+    AVFilter        *aformat;
     AVFilterContext *abuffersink_ctx;
-    const AVFilter  *abuffersink;
+    AVFilter        *abuffersink;
 
     AVDictionary *options_dict = NULL;
     uint8_t options_str[1024];
@@ -289,6 +289,8 @@ int main(int argc, char *argv[])
         return 1;
     }
 
+    avfilter_register_all();
+
     /* Allocate the frame we will be using to store the data. */
     frame  = av_frame_alloc();
     if (!frame) {

doc/examples/filtering_audio.c

@@ -32,6 +32,7 @@
 
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
+#include <libavfilter/avfiltergraph.h>
 #include <libavfilter/buffersink.h>
 #include <libavfilter/buffersrc.h>
 #include <libavutil/opt.h>
@@ -89,8 +90,8 @@ static int init_filters(const char *filters_descr)
 {
     char args[512];
     int ret = 0;
-    const AVFilter *abuffersrc  = avfilter_get_by_name("abuffer");
-    const AVFilter *abuffersink = avfilter_get_by_name("abuffersink");
+    AVFilter *abuffersrc  = avfilter_get_by_name("abuffer");
+    AVFilter *abuffersink = avfilter_get_by_name("abuffersink");
     AVFilterInOut *outputs = avfilter_inout_alloc();
     AVFilterInOut *inputs  = avfilter_inout_alloc();
     static const enum AVSampleFormat out_sample_fmts[] = { AV_SAMPLE_FMT_S16, -1 };
@@ -228,6 +229,9 @@ int main(int argc, char **argv)
         exit(1);
     }
 
+    av_register_all();
+    avfilter_register_all();
+
     if ((ret = open_input_file(argv[1])) < 0)
         goto end;
     if ((ret = init_filters(filter_descr)) < 0)

doc/examples/filtering_video.c

@@ -32,6 +32,7 @@
 
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
+#include <libavfilter/avfiltergraph.h>
 #include <libavfilter/buffersink.h>
 #include <libavfilter/buffersrc.h>
 #include <libavutil/opt.h>
@@ -92,8 +93,8 @@ static int init_filters(const char *filters_descr)
 {
     char args[512];
     int ret = 0;
-    const AVFilter *buffersrc  = avfilter_get_by_name("buffer");
-    const AVFilter *buffersink = avfilter_get_by_name("buffersink");
+    AVFilter *buffersrc  = avfilter_get_by_name("buffer");
+    AVFilter *buffersink = avfilter_get_by_name("buffersink");
     AVFilterInOut *outputs = avfilter_inout_alloc();
     AVFilterInOut *inputs  = avfilter_inout_alloc();
     AVRational time_base = fmt_ctx->streams[video_stream_index]->time_base;
@@ -222,6 +223,9 @@ int main(int argc, char **argv)
         exit(1);
     }
 
+    av_register_all();
+    avfilter_register_all();
+
     if ((ret = open_input_file(argv[1])) < 0)
         goto end;
     if ((ret = init_filters(filter_descr)) < 0)

doc/examples/http_multiclient.c

@@ -114,6 +114,7 @@ int main(int argc, char **argv)
     in_uri = argv[1];
     out_uri = argv[2];
 
+    av_register_all();
     avformat_network_init();
 
     if ((ret = av_dict_set(&options, "listen", "2", 0)) < 0) {

doc/examples/hw_decode.c

@@ -44,6 +44,34 @@ static AVBufferRef *hw_device_ctx = NULL;
 static enum AVPixelFormat hw_pix_fmt;
 static FILE *output_file = NULL;
 
+static enum AVPixelFormat find_fmt_by_hw_type(const enum AVHWDeviceType type)
+{
+    enum AVPixelFormat fmt;
+
+    switch (type) {
+    case AV_HWDEVICE_TYPE_VAAPI:
+        fmt = AV_PIX_FMT_VAAPI;
+        break;
+    case AV_HWDEVICE_TYPE_DXVA2:
+        fmt = AV_PIX_FMT_DXVA2_VLD;
+        break;
+    case AV_HWDEVICE_TYPE_D3D11VA:
+        fmt = AV_PIX_FMT_D3D11;
+        break;
+    case AV_HWDEVICE_TYPE_VDPAU:
+        fmt = AV_PIX_FMT_VDPAU;
+        break;
+    case AV_HWDEVICE_TYPE_VIDEOTOOLBOX:
+        fmt = AV_PIX_FMT_VIDEOTOOLBOX;
+        break;
+    default:
+        fmt = AV_PIX_FMT_NONE;
+        break;
+    }
+
+    return fmt;
+}
+
 static int hw_decoder_init(AVCodecContext *ctx, const enum AVHWDeviceType type)
 {
     int err = 0;
@@ -86,7 +114,7 @@ static int decode_write(AVCodecContext *avctx, AVPacket *packet)
         return ret;
     }
 
-    while (1) {
+    while (ret >= 0) {
         if (!(frame = av_frame_alloc()) || !(sw_frame = av_frame_alloc())) {
             fprintf(stderr, "Can not alloc frame\n");
             ret = AVERROR(ENOMEM);
@@ -138,10 +166,13 @@ static int decode_write(AVCodecContext *avctx, AVPacket *packet)
     fail:
         av_frame_free(&frame);
         av_frame_free(&sw_frame);
-        av_freep(&buffer);
+        if (buffer)
+            av_freep(&buffer);
         if (ret < 0)
             return ret;
     }
+
+    return 0;
 }
 
 int main(int argc, char *argv[])
@@ -153,20 +184,18 @@ int main(int argc, char *argv[])
     AVCodec *decoder = NULL;
     AVPacket packet;
     enum AVHWDeviceType type;
-    int i;
 
     if (argc < 4) {
-        fprintf(stderr, "Usage: %s <device type> <input file> <output file>\n", argv[0]);
+        fprintf(stderr, "Usage: %s <vaapi|vdpau|dxva2|d3d11va> <input file> <output file>\n", argv[0]);
         return -1;
     }
 
+    av_register_all();
+
     type = av_hwdevice_find_type_by_name(argv[1]);
-    if (type == AV_HWDEVICE_TYPE_NONE) {
-        fprintf(stderr, "Device type %s is not supported.\n", argv[1]);
-        fprintf(stderr, "Available device types:");
-        while((type = av_hwdevice_iterate_types(type)) != AV_HWDEVICE_TYPE_NONE)
-            fprintf(stderr, " %s", av_hwdevice_get_type_name(type));
-        fprintf(stderr, "\n");
+    hw_pix_fmt = find_fmt_by_hw_type(type);
+    if (hw_pix_fmt == -1) {
+        fprintf(stderr, "Cannot support '%s' in this example.\n", argv[1]);
         return -1;
     }
 
@@ -189,20 +218,6 @@ int main(int argc, char *argv[])
     }
     video_stream = ret;
 
-    for (i = 0;; i++) {
-        const AVCodecHWConfig *config = avcodec_get_hw_config(decoder, i);
-        if (!config) {
-            fprintf(stderr, "Decoder %s does not support device type %s.\n",
-                    decoder->name, av_hwdevice_get_type_name(type));
-            return -1;
-        }
-        if (config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX &&
-            config->device_type == type) {
-            hw_pix_fmt = config->pix_fmt;
-            break;
-        }
-    }
-
     if (!(decoder_ctx = avcodec_alloc_context3(decoder)))
         return AVERROR(ENOMEM);
 

doc/examples/metadata.c

@@ -44,6 +44,7 @@ int main (int argc, char **argv)
         return 1;
     }
 
+    av_register_all();
     if ((ret = avformat_open_input(&fmt_ctx, argv[1], NULL, NULL)))
         return ret;
 

doc/examples/muxing.c

@@ -488,9 +488,9 @@ static AVFrame *get_video_frame(OutputStream *ost)
             }
         }
         fill_yuv_image(ost->tmp_frame, ost->next_pts, c->width, c->height);
-        sws_scale(ost->sws_ctx, (const uint8_t * const *) ost->tmp_frame->data,
-                  ost->tmp_frame->linesize, 0, c->height, ost->frame->data,
-                  ost->frame->linesize);
+        sws_scale(ost->sws_ctx,
+                  (const uint8_t * const *)ost->tmp_frame->data, ost->tmp_frame->linesize,
+                  0, c->height, ost->frame->data, ost->frame->linesize);
     } else {
         fill_yuv_image(ost->frame, ost->next_pts, c->width, c->height);
     }
@@ -564,6 +564,9 @@ int main(int argc, char **argv)
     AVDictionary *opt = NULL;
     int i;
 
+    /* Initialize libavcodec, and register all codecs and formats. */
+    av_register_all();
+
     if (argc < 2) {
         printf("usage: %s output_file\n"
                "API example program to output a media file with libavformat.\n"

doc/examples/qsvdec.c

@@ -150,6 +150,8 @@ int main(int argc, char **argv)
 
     int ret, i;
 
+    av_register_all();
+
     if (argc < 3) {
         fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
         return 1;
@@ -208,6 +210,7 @@ int main(int argc, char **argv)
                video_st->codecpar->extradata_size);
         decoder_ctx->extradata_size = video_st->codecpar->extradata_size;
     }
+    decoder_ctx->refcounted_frames = 1;
 
     decoder_ctx->opaque      = &decode;
     decoder_ctx->get_format  = get_format;

doc/examples/remuxing.c

@@ -65,6 +65,8 @@ int main(int argc, char **argv)
     in_filename  = argv[1];
     out_filename = argv[2];
 
+    av_register_all();
+
     if ((ret = avformat_open_input(&ifmt_ctx, in_filename, 0, 0)) < 0) {
         fprintf(stderr, "Could not open input file '%s'", in_filename);
         goto end;

doc/examples/transcode_aac.c

@@ -1,6 +1,4 @@
 /*
- * Copyright (c) 2013-2018 Andreas Unterweger
- *
  * This file is part of FFmpeg.
  *
  * FFmpeg is free software; you can redistribute it and/or
@@ -10,7 +8,7 @@
  *
  * FFmpeg is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
@@ -20,11 +18,10 @@
 
 /**
  * @file
- * Simple audio converter
+ * simple audio converter
  *
  * @example transcode_aac.c
  * Convert an input audio file to AAC in an MP4 container using FFmpeg.
- * Formats other than MP4 are supported based on the output file extension.
  * @author Andreas Unterweger (dustsigns@gmail.com)
  */
 
@@ -43,18 +40,12 @@
 
 #include "libswresample/swresample.h"
 
-/* The output bit rate in bit/s */
+/** The output bit rate in kbit/s */
 #define OUTPUT_BIT_RATE 96000
-/* The number of output channels */
+/** The number of output channels */
 #define OUTPUT_CHANNELS 2
 
-/**
- * Open an input file and the required decoder.
- * @param      filename             File to be opened
- * @param[out] input_format_context Format context of opened file
- * @param[out] input_codec_context  Codec context of opened file
- * @return Error code (0 if successful)
- */
+/** Open an input file and the required decoder. */
 static int open_input_file(const char *filename,
                            AVFormatContext **input_format_context,
                            AVCodecContext **input_codec_context)
@@ -63,7 +54,7 @@ static int open_input_file(const char *filename,
     AVCodec *input_codec;
     int error;
 
-    /* Open the input file to read from it. */
+    /** Open the input file to read from it. */
     if ((error = avformat_open_input(input_format_context, filename, NULL,
                                      NULL)) < 0) {
         fprintf(stderr, "Could not open input file '%s' (error '%s')\n",
@@ -72,7 +63,7 @@ static int open_input_file(const char *filename,
         return error;
     }
 
-    /* Get information on the input file (number of streams etc.). */
+    /** Get information on the input file (number of streams etc.). */
     if ((error = avformat_find_stream_info(*input_format_context, NULL)) < 0) {
         fprintf(stderr, "Could not open find stream info (error '%s')\n",
                 av_err2str(error));
@@ -80,7 +71,7 @@ static int open_input_file(const char *filename,
         return error;
     }
 
-    /* Make sure that there is only one stream in the input file. */
+    /** Make sure that there is only one stream in the input file. */
     if ((*input_format_context)->nb_streams != 1) {
         fprintf(stderr, "Expected one audio input stream, but found %d\n",
                 (*input_format_context)->nb_streams);
@@ -88,14 +79,14 @@ static int open_input_file(const char *filename,
         return AVERROR_EXIT;
     }
 
-    /* Find a decoder for the audio stream. */
+    /** Find a decoder for the audio stream. */
     if (!(input_codec = avcodec_find_decoder((*input_format_context)->streams[0]->codecpar->codec_id))) {
         fprintf(stderr, "Could not find input codec\n");
         avformat_close_input(input_format_context);
         return AVERROR_EXIT;
     }
 
-    /* Allocate a new decoding context. */
+    /** allocate a new decoding context */
     avctx = avcodec_alloc_context3(input_codec);
     if (!avctx) {
         fprintf(stderr, "Could not allocate a decoding context\n");
@@ -103,7 +94,7 @@ static int open_input_file(const char *filename,
         return AVERROR(ENOMEM);
     }
 
-    /* Initialize the stream parameters with demuxer information. */
+    /** initialize the stream parameters with demuxer information */
     error = avcodec_parameters_to_context(avctx, (*input_format_context)->streams[0]->codecpar);
     if (error < 0) {
         avformat_close_input(input_format_context);
@@ -111,7 +102,7 @@ static int open_input_file(const char *filename,
         return error;
     }
 
-    /* Open the decoder for the audio stream to use it later. */
+    /** Open the decoder for the audio stream to use it later. */
     if ((error = avcodec_open2(avctx, input_codec, NULL)) < 0) {
         fprintf(stderr, "Could not open input codec (error '%s')\n",
                 av_err2str(error));
@@ -120,7 +111,7 @@ static int open_input_file(const char *filename,
         return error;
     }
 
-    /* Save the decoder context for easier access later. */
+    /** Save the decoder context for easier access later. */
     *input_codec_context = avctx;
 
     return 0;
@@ -130,11 +121,6 @@ static int open_input_file(const char *filename,
  * Open an output file and the required encoder.
  * Also set some basic encoder parameters.
  * Some of these parameters are based on the input file's parameters.
- * @param      filename              File to be opened
- * @param      input_codec_context   Codec context of input file
- * @param[out] output_format_context Format context of output file
- * @param[out] output_codec_context  Codec context of output file
- * @return Error code (0 if successful)
  */
 static int open_output_file(const char *filename,
                             AVCodecContext *input_codec_context,
@@ -147,7 +133,7 @@ static int open_output_file(const char *filename,
     AVCodec *output_codec          = NULL;
     int error;
 
-    /* Open the output file to write to it. */
+    /** Open the output file to write to it. */
     if ((error = avio_open(&output_io_context, filename,
                            AVIO_FLAG_WRITE)) < 0) {
         fprintf(stderr, "Could not open output file '%s' (error '%s')\n",
@@ -155,35 +141,32 @@ static int open_output_file(const char *filename,
         return error;
     }
 
-    /* Create a new format context for the output container format. */
+    /** Create a new format context for the output container format. */
     if (!(*output_format_context = avformat_alloc_context())) {
         fprintf(stderr, "Could not allocate output format context\n");
         return AVERROR(ENOMEM);
     }
 
-    /* Associate the output file (pointer) with the container format context. */
+    /** Associate the output file (pointer) with the container format context. */
     (*output_format_context)->pb = output_io_context;
 
-    /* Guess the desired container format based on the file extension. */
+    /** Guess the desired container format based on the file extension. */
     if (!((*output_format_context)->oformat = av_guess_format(NULL, filename,
                                                               NULL))) {
         fprintf(stderr, "Could not find output file format\n");
         goto cleanup;
     }
 
-    if (!((*output_format_context)->url = av_strdup(filename))) {
-        fprintf(stderr, "Could not allocate url.\n");
-        error = AVERROR(ENOMEM);
-        goto cleanup;
-    }
+    av_strlcpy((*output_format_context)->filename, filename,
+               sizeof((*output_format_context)->filename));
 
-    /* Find the encoder to be used by its name. */
+    /** Find the encoder to be used by its name. */
     if (!(output_codec = avcodec_find_encoder(AV_CODEC_ID_AAC))) {
         fprintf(stderr, "Could not find an AAC encoder.\n");
         goto cleanup;
     }
 
-    /* Create a new audio stream in the output file container. */
+    /** Create a new audio stream in the output file container. */
     if (!(stream = avformat_new_stream(*output_format_context, NULL))) {
         fprintf(stderr, "Could not create new stream\n");
         error = AVERROR(ENOMEM);
@@ -197,27 +180,31 @@ static int open_output_file(const char *filename,
         goto cleanup;
     }
 
-    /* Set the basic encoder parameters.
-     * The input file's sample rate is used to avoid a sample rate conversion. */
+    /**
+     * Set the basic encoder parameters.
+     * The input file's sample rate is used to avoid a sample rate conversion.
+     */
     avctx->channels       = OUTPUT_CHANNELS;
     avctx->channel_layout = av_get_default_channel_layout(OUTPUT_CHANNELS);
     avctx->sample_rate    = input_codec_context->sample_rate;
     avctx->sample_fmt     = output_codec->sample_fmts[0];
     avctx->bit_rate       = OUTPUT_BIT_RATE;
 
-    /* Allow the use of the experimental AAC encoder. */
+    /** Allow the use of the experimental AAC encoder */
     avctx->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;
 
-    /* Set the sample rate for the container. */
+    /** Set the sample rate for the container. */
     stream->time_base.den = input_codec_context->sample_rate;
     stream->time_base.num = 1;
 
-    /* Some container formats (like MP4) require global headers to be present.
-     * Mark the encoder so that it behaves accordingly. */
+    /**
+     * Some container formats (like MP4) require global headers to be present
+     * Mark the encoder so that it behaves accordingly.
+     */
     if ((*output_format_context)->oformat->flags & AVFMT_GLOBALHEADER)
         avctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
 
-    /* Open the encoder for the audio stream to use it later. */
+    /** Open the encoder for the audio stream to use it later. */
     if ((error = avcodec_open2(avctx, output_codec, NULL)) < 0) {
         fprintf(stderr, "Could not open output codec (error '%s')\n",
                 av_err2str(error));
@@ -230,7 +217,7 @@ static int open_output_file(const char *filename,
         goto cleanup;
     }
 
-    /* Save the encoder context for easier access later. */
+    /** Save the encoder context for easier access later. */
     *output_codec_context = avctx;
 
     return 0;
@@ -243,23 +230,16 @@ cleanup:
     return error < 0 ? error : AVERROR_EXIT;
 }
 
-/**
- * Initialize one data packet for reading or writing.
- * @param packet Packet to be initialized
- */
+/** Initialize one data packet for reading or writing. */
 static void init_packet(AVPacket *packet)
 {
     av_init_packet(packet);
-    /* Set the packet data and size so that it is recognized as being empty. */
+    /** Set the packet data and size so that it is recognized as being empty. */
     packet->data = NULL;
     packet->size = 0;
 }
 
-/**
- * Initialize one audio frame for reading from the input file.
- * @param[out] frame Frame to be initialized
- * @return Error code (0 if successful)
- */
+/** Initialize one audio frame for reading from the input file */
 static int init_input_frame(AVFrame **frame)
 {
     if (!(*frame = av_frame_alloc())) {
@@ -273,10 +253,6 @@ static int init_input_frame(AVFrame **frame)
  * Initialize the audio resampler based on the input and output codec settings.
  * If the input and output sample formats differ, a conversion is required
  * libswresample takes care of this, but requires initialization.
- * @param      input_codec_context  Codec context of the input file
- * @param      output_codec_context Codec context of the output file
- * @param[out] resample_context     Resample context for the required conversion
- * @return Error code (0 if successful)
  */
 static int init_resampler(AVCodecContext *input_codec_context,
                           AVCodecContext *output_codec_context,
@@ -284,7 +260,7 @@ static int init_resampler(AVCodecContext *input_codec_context,
 {
         int error;
 
-        /*
+        /**
          * Create a resampler context for the conversion.
          * Set the conversion parameters.
          * Default channel layouts based on the number of channels
@@ -303,14 +279,14 @@ static int init_resampler(AVCodecContext *input_codec_context,
             fprintf(stderr, "Could not allocate resample context\n");
             return AVERROR(ENOMEM);
         }
-        /*
+        /**
         * Perform a sanity check so that the number of converted samples is
         * not greater than the number of samples to be converted.
         * If the sample rates differ, this case has to be handled differently
         */
         av_assert0(output_codec_context->sample_rate == input_codec_context->sample_rate);
 
-        /* Open the resampler with the specified parameters. */
+        /** Open the resampler with the specified parameters. */
         if ((error = swr_init(*resample_context)) < 0) {
             fprintf(stderr, "Could not open resample context\n");
             swr_free(resample_context);
@@ -319,15 +295,10 @@ static int init_resampler(AVCodecContext *input_codec_context,
     return 0;
 }
 
-/**
- * Initialize a FIFO buffer for the audio samples to be encoded.
- * @param[out] fifo                 Sample buffer
- * @param      output_codec_context Codec context of the output file
- * @return Error code (0 if successful)
- */
+/** Initialize a FIFO buffer for the audio samples to be encoded. */
 static int init_fifo(AVAudioFifo **fifo, AVCodecContext *output_codec_context)
 {
-    /* Create the FIFO buffer based on the specified output sample format. */
+    /** Create the FIFO buffer based on the specified output sample format. */
     if (!(*fifo = av_audio_fifo_alloc(output_codec_context->sample_fmt,
                                       output_codec_context->channels, 1))) {
         fprintf(stderr, "Could not allocate FIFO\n");
@@ -336,11 +307,7 @@ static int init_fifo(AVAudioFifo **fifo, AVCodecContext *output_codec_context)
     return 0;
 }
 
-/**
- * Write the header of the output file container.
- * @param output_format_context Format context of the output file
- * @return Error code (0 if successful)
- */
+/** Write the header of the output file container. */
 static int write_output_file_header(AVFormatContext *output_format_context)
 {
     int error;
@@ -352,32 +319,20 @@ static int write_output_file_header(AVFormatContext *output_format_context)
     return 0;
 }
 
-/**
- * Decode one audio frame from the input file.
- * @param      frame                Audio frame to be decoded
- * @param      input_format_context Format context of the input file
- * @param      input_codec_context  Codec context of the input file
- * @param[out] data_present         Indicates whether data has been decoded
- * @param[out] finished             Indicates whether the end of file has
- *                                  been reached and all data has been
- *                                  decoded. If this flag is false, there
- *                                  is more data to be decoded, i.e., this
- *                                  function has to be called again.
- * @return Error code (0 if successful)
- */
+/** Decode one audio frame from the input file. */
 static int decode_audio_frame(AVFrame *frame,
                               AVFormatContext *input_format_context,
                               AVCodecContext *input_codec_context,
                               int *data_present, int *finished)
 {
-    /* Packet used for temporary storage. */
+    /** Packet used for temporary storage. */
     AVPacket input_packet;
     int error;
     init_packet(&input_packet);
 
-    /* Read one audio frame from the input file into a temporary packet. */
+    /** Read one audio frame from the input file into a temporary packet. */
     if ((error = av_read_frame(input_format_context, &input_packet)) < 0) {
-        /* If we are at the end of the file, flush the decoder below. */
+        /** If we are at the end of the file, flush the decoder below. */
         if (error == AVERROR_EOF)
             *finished = 1;
         else {
@@ -387,52 +342,34 @@ static int decode_audio_frame(AVFrame *frame,
         }
     }
 
-    /* Send the audio frame stored in the temporary packet to the decoder.
-     * The input audio stream decoder is used to do this. */
-    if ((error = avcodec_send_packet(input_codec_context, &input_packet)) < 0) {
-        fprintf(stderr, "Could not send packet for decoding (error '%s')\n",
+    /**
+     * Decode the audio frame stored in the temporary packet.
+     * The input audio stream decoder is used to do this.
+     * If we are at the end of the file, pass an empty packet to the decoder
+     * to flush it.
+     */
+    if ((error = avcodec_decode_audio4(input_codec_context, frame,
+                                       data_present, &input_packet)) < 0) {
+        fprintf(stderr, "Could not decode frame (error '%s')\n",
                 av_err2str(error));
+        av_packet_unref(&input_packet);
         return error;
     }
 
-    /* Receive one frame from the decoder. */
-    error = avcodec_receive_frame(input_codec_context, frame);
-    /* If the decoder asks for more data to be able to decode a frame,
-     * return indicating that no data is present. */
-    if (error == AVERROR(EAGAIN)) {
-        error = 0;
-        goto cleanup;
-    /* If the end of the input file is reached, stop decoding. */
-    } else if (error == AVERROR_EOF) {
-        *finished = 1;
-        error = 0;
-        goto cleanup;
-    } else if (error < 0) {
-        fprintf(stderr, "Could not decode frame (error '%s')\n",
-                av_err2str(error));
-        goto cleanup;
-    /* Default case: Return decoded data. */
-    } else {
-        *data_present = 1;
-        goto cleanup;
-    }
-
-cleanup:
+    /**
+     * If the decoder has not been flushed completely, we are not finished,
+     * so that this function has to be called again.
+     */
+    if (*finished && *data_present)
+        *finished = 0;
     av_packet_unref(&input_packet);
-    return error;
+    return 0;
 }
 
 /**
  * Initialize a temporary storage for the specified number of audio samples.
  * The conversion requires temporary storage due to the different format.
  * The number of audio samples to be allocated is specified in frame_size.
- * @param[out] converted_input_samples Array of converted samples. The
- *                                     dimensions are reference, channel
- *                                     (for multi-channel audio), sample.
- * @param      output_codec_context    Codec context of the output file
- * @param      frame_size              Number of samples to be converted in
- *                                     each round
- * @return Error code (0 if successful)
  */
 static int init_converted_samples(uint8_t ***converted_input_samples,
                                   AVCodecContext *output_codec_context,
@@ -440,7 +377,8 @@ static int init_converted_samples(uint8_t ***converted_input_samples,
 {
     int error;
 
-    /* Allocate as many pointers as there are audio channels.
+    /**
+     * Allocate as many pointers as there are audio channels.
      * Each pointer will later point to the audio samples of the corresponding
      * channels (although it may be NULL for interleaved formats).
      */
@@ -450,8 +388,10 @@ static int init_converted_samples(uint8_t ***converted_input_samples,
         return AVERROR(ENOMEM);
     }
 
-    /* Allocate memory for the samples of all channels in one consecutive
-     * block for convenience. */
+    /**
+     * Allocate memory for the samples of all channels in one consecutive
+     * block for convenience.
+     */
     if ((error = av_samples_alloc(*converted_input_samples, NULL,
                                   output_codec_context->channels,
                                   frame_size,
@@ -468,15 +408,8 @@ static int init_converted_samples(uint8_t ***converted_input_samples,
 
 /**
  * Convert the input audio samples into the output sample format.
- * The conversion happens on a per-frame basis, the size of which is
- * specified by frame_size.
- * @param      input_data       Samples to be decoded. The dimensions are
- *                              channel (for multi-channel audio), sample.
- * @param[out] converted_data   Converted samples. The dimensions are channel
- *                              (for multi-channel audio), sample.
- * @param      frame_size       Number of samples to be converted
- * @param      resample_context Resample context for the conversion
- * @return Error code (0 if successful)
+ * The conversion happens on a per-frame basis, the size of which is specified
+ * by frame_size.
  */
 static int convert_samples(const uint8_t **input_data,
                            uint8_t **converted_data, const int frame_size,
@@ -484,7 +417,7 @@ static int convert_samples(const uint8_t **input_data,
 {
     int error;
 
-    /* Convert the samples using the resampler. */
+    /** Convert the samples using the resampler. */
     if ((error = swr_convert(resample_context,
                              converted_data, frame_size,
                              input_data    , frame_size)) < 0) {
@@ -496,28 +429,23 @@ static int convert_samples(const uint8_t **input_data,
     return 0;
 }
 
-/**
- * Add converted input audio samples to the FIFO buffer for later processing.
- * @param fifo                    Buffer to add the samples to
- * @param converted_input_samples Samples to be added. The dimensions are channel
- *                                (for multi-channel audio), sample.
- * @param frame_size              Number of samples to be converted
- * @return Error code (0 if successful)
- */
+/** Add converted input audio samples to the FIFO buffer for later processing. */
 static int add_samples_to_fifo(AVAudioFifo *fifo,
                                uint8_t **converted_input_samples,
                                const int frame_size)
 {
     int error;
 
-    /* Make the FIFO as large as it needs to be to hold both,
-     * the old and the new samples. */
+    /**
+     * Make the FIFO as large as it needs to be to hold both,
+     * the old and the new samples.
+     */
     if ((error = av_audio_fifo_realloc(fifo, av_audio_fifo_size(fifo) + frame_size)) < 0) {
         fprintf(stderr, "Could not reallocate FIFO\n");
         return error;
     }
 
-    /* Store the new samples in the FIFO buffer. */
+    /** Store the new samples in the FIFO buffer. */
     if (av_audio_fifo_write(fifo, (void **)converted_input_samples,
                             frame_size) < frame_size) {
         fprintf(stderr, "Could not write data to FIFO\n");
@@ -527,20 +455,8 @@ static int add_samples_to_fifo(AVAudioFifo *fifo,
 }
 
 /**
- * Read one audio frame from the input file, decode, convert and store
+ * Read one audio frame from the input file, decodes, converts and stores
  * it in the FIFO buffer.
- * @param      fifo                 Buffer used for temporary storage
- * @param      input_format_context Format context of the input file
- * @param      input_codec_context  Codec context of the input file
- * @param      output_codec_context Codec context of the output file
- * @param      resampler_context    Resample context for the conversion
- * @param[out] finished             Indicates whether the end of file has
- *                                  been reached and all data has been
- *                                  decoded. If this flag is false,
- *                                  there is more data to be decoded,
- *                                  i.e., this function has to be called
- *                                  again.
- * @return Error code (0 if successful)
  */
 static int read_decode_convert_and_store(AVAudioFifo *fifo,
                                          AVFormatContext *input_format_context,
@@ -549,41 +465,45 @@ static int read_decode_convert_and_store(AVAudioFifo *fifo,
                                          SwrContext *resampler_context,
                                          int *finished)
 {
-    /* Temporary storage of the input samples of the frame read from the file. */
+    /** Temporary storage of the input samples of the frame read from the file. */
     AVFrame *input_frame = NULL;
-    /* Temporary storage for the converted input samples. */
+    /** Temporary storage for the converted input samples. */
     uint8_t **converted_input_samples = NULL;
-    int data_present = 0;
+    int data_present;
     int ret = AVERROR_EXIT;
 
-    /* Initialize temporary storage for one input frame. */
+    /** Initialize temporary storage for one input frame. */
     if (init_input_frame(&input_frame))
         goto cleanup;
-    /* Decode one frame worth of audio samples. */
+    /** Decode one frame worth of audio samples. */
     if (decode_audio_frame(input_frame, input_format_context,
                            input_codec_context, &data_present, finished))
         goto cleanup;
-    /* If we are at the end of the file and there are no more samples
+    /**
+     * If we are at the end of the file and there are no more samples
      * in the decoder which are delayed, we are actually finished.
-     * This must not be treated as an error. */
-    if (*finished) {
+     * This must not be treated as an error.
+     */
+    if (*finished && !data_present) {
         ret = 0;
         goto cleanup;
     }
-    /* If there is decoded data, convert and store it. */
+    /** If there is decoded data, convert and store it */
     if (data_present) {
-        /* Initialize the temporary storage for the converted input samples. */
+        /** Initialize the temporary storage for the converted input samples. */
         if (init_converted_samples(&converted_input_samples, output_codec_context,
                                    input_frame->nb_samples))
             goto cleanup;
 
-        /* Convert the input samples to the desired output sample format.
-         * This requires a temporary storage provided by converted_input_samples. */
+        /**
+         * Convert the input samples to the desired output sample format.
+         * This requires a temporary storage provided by converted_input_samples.
+         */
         if (convert_samples((const uint8_t**)input_frame->extended_data, converted_input_samples,
                             input_frame->nb_samples, resampler_context))
             goto cleanup;
 
-        /* Add the converted input samples to the FIFO buffer for later processing. */
+        /** Add the converted input samples to the FIFO buffer for later processing. */
         if (add_samples_to_fifo(fifo, converted_input_samples,
                                 input_frame->nb_samples))
             goto cleanup;
@@ -604,10 +524,6 @@ cleanup:
 /**
  * Initialize one input frame for writing to the output file.
  * The frame will be exactly frame_size samples large.
- * @param[out] frame                Frame to be initialized
- * @param      output_codec_context Codec context of the output file
- * @param      frame_size           Size of the frame
- * @return Error code (0 if successful)
  */
 static int init_output_frame(AVFrame **frame,
                              AVCodecContext *output_codec_context,
@@ -615,24 +531,28 @@ static int init_output_frame(AVFrame **frame,
 {
     int error;
 
-    /* Create a new frame to store the audio samples. */
+    /** Create a new frame to store the audio samples. */
     if (!(*frame = av_frame_alloc())) {
         fprintf(stderr, "Could not allocate output frame\n");
         return AVERROR_EXIT;
     }
 
-    /* Set the frame's parameters, especially its size and format.
+    /**
+     * Set the frame's parameters, especially its size and format.
      * av_frame_get_buffer needs this to allocate memory for the
      * audio samples of the frame.
      * Default channel layouts based on the number of channels
-     * are assumed for simplicity. */
+     * are assumed for simplicity.
+     */
     (*frame)->nb_samples     = frame_size;
     (*frame)->channel_layout = output_codec_context->channel_layout;
     (*frame)->format         = output_codec_context->sample_fmt;
     (*frame)->sample_rate    = output_codec_context->sample_rate;
 
-    /* Allocate the samples of the created frame. This call will make
-     * sure that the audio frame can hold as many samples as specified. */
+    /**
+     * Allocate the samples of the created frame. This call will make
+     * sure that the audio frame can hold as many samples as specified.
+     */
     if ((error = av_frame_get_buffer(*frame, 0)) < 0) {
         fprintf(stderr, "Could not allocate output frame samples (error '%s')\n",
                 av_err2str(error));
@@ -643,114 +563,87 @@ static int init_output_frame(AVFrame **frame,
     return 0;
 }
 
-/* Global timestamp for the audio frames. */
+/** Global timestamp for the audio frames */
 static int64_t pts = 0;
 
-/**
- * Encode one frame worth of audio to the output file.
- * @param      frame                 Samples to be encoded
- * @param      output_format_context Format context of the output file
- * @param      output_codec_context  Codec context of the output file
- * @param[out] data_present          Indicates whether data has been
- *                                   encoded
- * @return Error code (0 if successful)
- */
+/** Encode one frame worth of audio to the output file. */
 static int encode_audio_frame(AVFrame *frame,
                               AVFormatContext *output_format_context,
                               AVCodecContext *output_codec_context,
                               int *data_present)
 {
-    /* Packet used for temporary storage. */
+    /** Packet used for temporary storage. */
     AVPacket output_packet;
     int error;
     init_packet(&output_packet);
 
-    /* Set a timestamp based on the sample rate for the container. */
+    /** Set a timestamp based on the sample rate for the container. */
     if (frame) {
         frame->pts = pts;
         pts += frame->nb_samples;
     }
 
-    /* Send the audio frame stored in the temporary packet to the encoder.
-     * The output audio stream encoder is used to do this. */
-    error = avcodec_send_frame(output_codec_context, frame);
-    /* The encoder signals that it has nothing more to encode. */
-    if (error == AVERROR_EOF) {
-        error = 0;
-        goto cleanup;
-    } else if (error < 0) {
-        fprintf(stderr, "Could not send packet for encoding (error '%s')\n",
+    /**
+     * Encode the audio frame and store it in the temporary packet.
+     * The output audio stream encoder is used to do this.
+     */
+    if ((error = avcodec_encode_audio2(output_codec_context, &output_packet,
+                                       frame, data_present)) < 0) {
+        fprintf(stderr, "Could not encode frame (error '%s')\n",
                 av_err2str(error));
+        av_packet_unref(&output_packet);
         return error;
     }
 
-    /* Receive one encoded frame from the encoder. */
-    error = avcodec_receive_packet(output_codec_context, &output_packet);
-    /* If the encoder asks for more data to be able to provide an
-     * encoded frame, return indicating that no data is present. */
-    if (error == AVERROR(EAGAIN)) {
-        error = 0;
-        goto cleanup;
-    /* If the last frame has been encoded, stop encoding. */
-    } else if (error == AVERROR_EOF) {
-        error = 0;
-        goto cleanup;
-    } else if (error < 0) {
-        fprintf(stderr, "Could not encode frame (error '%s')\n",
-                av_err2str(error));
-        goto cleanup;
-    /* Default case: Return encoded data. */
-    } else {
-        *data_present = 1;
+    /** Write one audio frame from the temporary packet to the output file. */
+    if (*data_present) {
+        if ((error = av_write_frame(output_format_context, &output_packet)) < 0) {
+            fprintf(stderr, "Could not write frame (error '%s')\n",
+                    av_err2str(error));
+            av_packet_unref(&output_packet);
+            return error;
+        }
+
+        av_packet_unref(&output_packet);
     }
 
-    /* Write one audio frame from the temporary packet to the output file. */
-    if (*data_present &&
-        (error = av_write_frame(output_format_context, &output_packet)) < 0) {
-        fprintf(stderr, "Could not write frame (error '%s')\n",
-                av_err2str(error));
-        goto cleanup;
-    }
-
-cleanup:
-    av_packet_unref(&output_packet);
-    return error;
+    return 0;
 }
 
 /**
  * Load one audio frame from the FIFO buffer, encode and write it to the
  * output file.
- * @param fifo                  Buffer used for temporary storage
- * @param output_format_context Format context of the output file
- * @param output_codec_context  Codec context of the output file
- * @return Error code (0 if successful)
  */
 static int load_encode_and_write(AVAudioFifo *fifo,
                                  AVFormatContext *output_format_context,
                                  AVCodecContext *output_codec_context)
 {
-    /* Temporary storage of the output samples of the frame written to the file. */
+    /** Temporary storage of the output samples of the frame written to the file. */
     AVFrame *output_frame;
-    /* Use the maximum number of possible samples per frame.
+    /**
+     * Use the maximum number of possible samples per frame.
      * If there is less than the maximum possible frame size in the FIFO
-     * buffer use this number. Otherwise, use the maximum possible frame size. */
+     * buffer use this number. Otherwise, use the maximum possible frame size
+     */
     const int frame_size = FFMIN(av_audio_fifo_size(fifo),
                                  output_codec_context->frame_size);
     int data_written;
 
-    /* Initialize temporary storage for one output frame. */
+    /** Initialize temporary storage for one output frame. */
     if (init_output_frame(&output_frame, output_codec_context, frame_size))
         return AVERROR_EXIT;
 
-    /* Read as many samples from the FIFO buffer as required to fill the frame.
-     * The samples are stored in the frame temporarily. */
+    /**
+     * Read as many samples from the FIFO buffer as required to fill the frame.
+     * The samples are stored in the frame temporarily.
+     */
     if (av_audio_fifo_read(fifo, (void **)output_frame->data, frame_size) < frame_size) {
         fprintf(stderr, "Could not read data from FIFO\n");
         av_frame_free(&output_frame);
         return AVERROR_EXIT;
     }
 
-    /* Encode one frame worth of audio samples. */
+    /** Encode one frame worth of audio samples. */
     if (encode_audio_frame(output_frame, output_format_context,
                            output_codec_context, &data_written)) {
         av_frame_free(&output_frame);
@@ -760,11 +653,7 @@ static int load_encode_and_write(AVAudioFifo *fifo,
     return 0;
 }
 
-/**
- * Write the trailer of the output file container.
- * @param output_format_context Format context of the output file
- * @return Error code (0 if successful)
- */
+/** Write the trailer of the output file container. */
 static int write_output_file_trailer(AVFormatContext *output_format_context)
 {
     int error;
@@ -776,6 +665,7 @@ static int write_output_file_trailer(AVFormatContext *output_format_context)
     return 0;
 }
 
+/** Convert an audio file to an AAC file in an MP4 container. */
 int main(int argc, char **argv)
 {
     AVFormatContext *input_format_context = NULL, *output_format_context = NULL;
@@ -784,75 +674,90 @@ int main(int argc, char **argv)
     AVAudioFifo *fifo = NULL;
     int ret = AVERROR_EXIT;
 
-    if (argc != 3) {
+    if (argc < 3) {
         fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
         exit(1);
     }
 
-    /* Open the input file for reading. */
+    /** Register all codecs and formats so that they can be used. */
+    av_register_all();
+    /** Open the input file for reading. */
     if (open_input_file(argv[1], &input_format_context,
                         &input_codec_context))
         goto cleanup;
-    /* Open the output file for writing. */
+    /** Open the output file for writing. */
     if (open_output_file(argv[2], input_codec_context,
                          &output_format_context, &output_codec_context))
         goto cleanup;
-    /* Initialize the resampler to be able to convert audio sample formats. */
+    /** Initialize the resampler to be able to convert audio sample formats. */
     if (init_resampler(input_codec_context, output_codec_context,
                        &resample_context))
         goto cleanup;
-    /* Initialize the FIFO buffer to store audio samples to be encoded. */
+    /** Initialize the FIFO buffer to store audio samples to be encoded. */
     if (init_fifo(&fifo, output_codec_context))
         goto cleanup;
-    /* Write the header of the output file container. */
+    /** Write the header of the output file container. */
     if (write_output_file_header(output_format_context))
         goto cleanup;
 
-    /* Loop as long as we have input samples to read or output samples
-     * to write; abort as soon as we have neither. */
+    /**
+     * Loop as long as we have input samples to read or output samples
+     * to write; abort as soon as we have neither.
+     */
     while (1) {
-        /* Use the encoder's desired frame size for processing. */
+        /** Use the encoder's desired frame size for processing. */
         const int output_frame_size = output_codec_context->frame_size;
         int finished                = 0;
 
-        /* Make sure that there is one frame worth of samples in the FIFO
+        /**
+         * Make sure that there is one frame worth of samples in the FIFO
          * buffer so that the encoder can do its work.
          * Since the decoder's and the encoder's frame size may differ, we
          * need to FIFO buffer to store as many frames worth of input samples
-         * that they make up at least one frame worth of output samples. */
+         * that they make up at least one frame worth of output samples.
+         */
         while (av_audio_fifo_size(fifo) < output_frame_size) {
-            /* Decode one frame worth of audio samples, convert it to the
-             * output sample format and put it into the FIFO buffer. */
+            /**
+             * Decode one frame worth of audio samples, convert it to the
+             * output sample format and put it into the FIFO buffer.
+             */
             if (read_decode_convert_and_store(fifo, input_format_context,
                                               input_codec_context,
                                               output_codec_context,
                                               resample_context, &finished))
                 goto cleanup;
 
-            /* If we are at the end of the input file, we continue
-             * encoding the remaining audio samples to the output file. */
+            /**
+             * If we are at the end of the input file, we continue
+             * encoding the remaining audio samples to the output file.
+             */
             if (finished)
                 break;
         }
 
-        /* If we have enough samples for the encoder, we encode them.
+        /**
+         * If we have enough samples for the encoder, we encode them.
          * At the end of the file, we pass the remaining samples to
-         * the encoder. */
+         * the encoder.
+         */
         while (av_audio_fifo_size(fifo) >= output_frame_size ||
                (finished && av_audio_fifo_size(fifo) > 0))
-            /* Take one frame worth of audio samples from the FIFO buffer,
-             * encode it and write it to the output file. */
+            /**
+             * Take one frame worth of audio samples from the FIFO buffer,
+             * encode it and write it to the output file.
+             */
             if (load_encode_and_write(fifo, output_format_context,
                                       output_codec_context))
                 goto cleanup;
 
-        /* If we are at the end of the input file and have encoded
-         * all remaining samples, we can exit this loop and finish. */
+        /**
+         * If we are at the end of the input file and have encoded
+         * all remaining samples, we can exit this loop and finish.
+         */
         if (finished) {
             int data_written;
-            /* Flush the encoder as it may have delayed frames. */
+            /** Flush the encoder as it may have delayed frames. */
             do {
-                data_written = 0;
                 if (encode_audio_frame(NULL, output_format_context,
                                        output_codec_context, &data_written))
                     goto cleanup;
@@ -861,7 +766,7 @@ int main(int argc, char **argv)
         }
     }
 
-    /* Write the trailer of the output file container. */
+    /** Write the trailer of the output file container. */
     if (write_output_file_trailer(output_format_context))
         goto cleanup;
     ret = 0;

doc/examples/transcoding.c

@@ -30,6 +30,7 @@
 
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
+#include <libavfilter/avfiltergraph.h>
 #include <libavfilter/buffersink.h>
 #include <libavfilter/buffersrc.h>
 #include <libavutil/opt.h>
@@ -227,8 +228,8 @@ static int init_filter(FilteringContext* fctx, AVCodecContext *dec_ctx,
 {
     char args[512];
     int ret = 0;
-    const AVFilter *buffersrc = NULL;
-    const AVFilter *buffersink = NULL;
+    AVFilter *buffersrc = NULL;
+    AVFilter *buffersink = NULL;
     AVFilterContext *buffersrc_ctx = NULL;
     AVFilterContext *buffersink_ctx = NULL;
     AVFilterInOut *outputs = avfilter_inout_alloc();
@@ -517,6 +518,9 @@ int main(int argc, char **argv)
         return 1;
     }
 
+    av_register_all();
+    avfilter_register_all();
+
     if ((ret = open_input_file(argv[1])) < 0)
         goto end;
     if ((ret = open_output_file(argv[2])) < 0)

doc/examples/vaapi_encode.c

@@ -1,222 +0,0 @@
-/*
- * Video Acceleration API (video encoding) encode sample
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * Intel VAAPI-accelerated encoding example.
- *
- * @example vaapi_encode.c
- * This example shows how to do VAAPI-accelerated encoding. now only support NV12
- * raw file, usage like: vaapi_encode 1920 1080 input.yuv output.h264
- *
- */
-
-#include <stdio.h>
-#include <string.h>
-#include <errno.h>
-
-#include <libavcodec/avcodec.h>
-#include <libavutil/pixdesc.h>
-#include <libavutil/hwcontext.h>
-
-static int width, height;
-static AVBufferRef *hw_device_ctx = NULL;
-
-static int set_hwframe_ctx(AVCodecContext *ctx, AVBufferRef *hw_device_ctx)
-{
-    AVBufferRef *hw_frames_ref;
-    AVHWFramesContext *frames_ctx = NULL;
-    int err = 0;
-
-    if (!(hw_frames_ref = av_hwframe_ctx_alloc(hw_device_ctx))) {
-        fprintf(stderr, "Failed to create VAAPI frame context.\n");
-        return -1;
-    }
-    frames_ctx = (AVHWFramesContext *)(hw_frames_ref->data);
-    frames_ctx->format    = AV_PIX_FMT_VAAPI;
-    frames_ctx->sw_format = AV_PIX_FMT_NV12;
-    frames_ctx->width     = width;
-    frames_ctx->height    = height;
-    frames_ctx->initial_pool_size = 20;
-    if ((err = av_hwframe_ctx_init(hw_frames_ref)) < 0) {
-        fprintf(stderr, "Failed to initialize VAAPI frame context."
-                "Error code: %s\n",av_err2str(err));
-        av_buffer_unref(&hw_frames_ref);
-        return err;
-    }
-    ctx->hw_frames_ctx = av_buffer_ref(hw_frames_ref);
-    if (!ctx->hw_frames_ctx)
-        err = AVERROR(ENOMEM);
-
-    av_buffer_unref(&hw_frames_ref);
-    return err;
-}
-
-static int encode_write(AVCodecContext *avctx, AVFrame *frame, FILE *fout)
-{
-    int ret = 0;
-    AVPacket enc_pkt;
-
-    av_init_packet(&enc_pkt);
-    enc_pkt.data = NULL;
-    enc_pkt.size = 0;
-
-    if ((ret = avcodec_send_frame(avctx, frame)) < 0) {
-        fprintf(stderr, "Error code: %s\n", av_err2str(ret));
-        goto end;
-    }
-    while (1) {
-        ret = avcodec_receive_packet(avctx, &enc_pkt);
-        if (ret)
-            break;
-
-        enc_pkt.stream_index = 0;
-        ret = fwrite(enc_pkt.data, enc_pkt.size, 1, fout);
-        av_packet_unref(&enc_pkt);
-    }
-
-end:
-    ret = ((ret == AVERROR(EAGAIN)) ? 0 : -1);
-    return ret;
-}
-
-int main(int argc, char *argv[])
-{
-    int size, err;
-    FILE *fin = NULL, *fout = NULL;
-    AVFrame *sw_frame = NULL, *hw_frame = NULL;
-    AVCodecContext *avctx = NULL;
-    AVCodec *codec = NULL;
-    const char *enc_name = "h264_vaapi";
-
-    if (argc < 5) {
-        fprintf(stderr, "Usage: %s <width> <height> <input file> <output file>\n", argv[0]);
-        return -1;
-    }
-
-    width  = atoi(argv[1]);
-    height = atoi(argv[2]);
-    size   = width * height;
-
-    if (!(fin = fopen(argv[3], "r"))) {
-        fprintf(stderr, "Fail to open input file : %s\n", strerror(errno));
-        return -1;
-    }
-    if (!(fout = fopen(argv[4], "w+b"))) {
-        fprintf(stderr, "Fail to open output file : %s\n", strerror(errno));
-        err = -1;
-        goto close;
-    }
-
-    err = av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_VAAPI,
-                                 NULL, NULL, 0);
-    if (err < 0) {
-        fprintf(stderr, "Failed to create a VAAPI device. Error code: %s\n", av_err2str(err));
-        goto close;
-    }
-
-    if (!(codec = avcodec_find_encoder_by_name(enc_name))) {
-        fprintf(stderr, "Could not find encoder.\n");
-        err = -1;
-        goto close;
-    }
-
-    if (!(avctx = avcodec_alloc_context3(codec))) {
-        err = AVERROR(ENOMEM);
-        goto close;
-    }
-
-    avctx->width     = width;
-    avctx->height    = height;
-    avctx->time_base = (AVRational){1, 25};
-    avctx->framerate = (AVRational){25, 1};
-    avctx->sample_aspect_ratio = (AVRational){1, 1};
-    avctx->pix_fmt   = AV_PIX_FMT_VAAPI;
-
-    /* set hw_frames_ctx for encoder's AVCodecContext */
-    if ((err = set_hwframe_ctx(avctx, hw_device_ctx)) < 0) {
-        fprintf(stderr, "Failed to set hwframe context.\n");
-        goto close;
-    }
-
-    if ((err = avcodec_open2(avctx, codec, NULL)) < 0) {
-        fprintf(stderr, "Cannot open video encoder codec. Error code: %s\n", av_err2str(err));
-        goto close;
-    }
-
-    while (1) {
-        if (!(sw_frame = av_frame_alloc())) {
-            err = AVERROR(ENOMEM);
-            goto close;
-        }
-        /* read data into software frame, and transfer them into hw frame */
-        sw_frame->width  = width;
-        sw_frame->height = height;
-        sw_frame->format = AV_PIX_FMT_NV12;
-        if ((err = av_frame_get_buffer(sw_frame, 32)) < 0)
-            goto close;
-        if ((err = fread((uint8_t*)(sw_frame->data[0]), size, 1, fin)) <= 0)
-            break;
-        if ((err = fread((uint8_t*)(sw_frame->data[1]), size/2, 1, fin)) <= 0)
-            break;
-
-        if (!(hw_frame = av_frame_alloc())) {
-            err = AVERROR(ENOMEM);
-            goto close;
-        }
-        if ((err = av_hwframe_get_buffer(avctx->hw_frames_ctx, hw_frame, 0)) < 0) {
-            fprintf(stderr, "Error code: %s.\n", av_err2str(err));
-            goto close;
-        }
-        if (!hw_frame->hw_frames_ctx) {
-            err = AVERROR(ENOMEM);
-            goto close;
-        }
-        if ((err = av_hwframe_transfer_data(hw_frame, sw_frame, 0)) < 0) {
-            fprintf(stderr, "Error while transferring frame data to surface."
-                    "Error code: %s.\n", av_err2str(err));
-            goto close;
-        }
-
-        if ((err = (encode_write(avctx, hw_frame, fout))) < 0) {
-            fprintf(stderr, "Failed to encode.\n");
-            goto close;
-        }
-        av_frame_free(&hw_frame);
-        av_frame_free(&sw_frame);
-    }
-
-    /* flush encoder */
-    err = encode_write(avctx, NULL, fout);
-    if (err == AVERROR_EOF)
-        err = 0;
-
-close:
-    if (fin)
-        fclose(fin);
-    if (fout)
-        fclose(fout);
-    av_frame_free(&sw_frame);
-    av_frame_free(&hw_frame);
-    avcodec_free_context(&avctx);
-    av_buffer_unref(&hw_device_ctx);
-
-    return err;
-}

doc/examples/vaapi_transcode.c

@@ -1,304 +0,0 @@
-/*
- * Video Acceleration API (video transcoding) transcode sample
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * Intel VAAPI-accelerated transcoding example.
- *
- * @example vaapi_transcode.c
- * This example shows how to do VAAPI-accelerated transcoding.
- * Usage: vaapi_transcode input_stream codec output_stream
- * e.g: - vaapi_transcode input.mp4 h264_vaapi output_h264.mp4
- *      - vaapi_transcode input.mp4 vp9_vaapi output_vp9.ivf
- */
-
-#include <stdio.h>
-#include <errno.h>
-
-#include <libavutil/hwcontext.h>
-#include <libavcodec/avcodec.h>
-#include <libavformat/avformat.h>
-
-static AVFormatContext *ifmt_ctx = NULL, *ofmt_ctx = NULL;
-static AVBufferRef *hw_device_ctx = NULL;
-static AVCodecContext *decoder_ctx = NULL, *encoder_ctx = NULL;
-static int video_stream = -1;
-static AVStream *ost;
-static int initialized = 0;
-
-static enum AVPixelFormat get_vaapi_format(AVCodecContext *ctx,
-                                           const enum AVPixelFormat *pix_fmts)
-{
-    const enum AVPixelFormat *p;
-
-    for (p = pix_fmts; *p != AV_PIX_FMT_NONE; p++) {
-        if (*p == AV_PIX_FMT_VAAPI)
-            return *p;
-    }
-
-    fprintf(stderr, "Unable to decode this file using VA-API.\n");
-    return AV_PIX_FMT_NONE;
-}
-
-static int open_input_file(const char *filename)
-{
-    int ret;
-    AVCodec *decoder = NULL;
-    AVStream *video = NULL;
-
-    if ((ret = avformat_open_input(&ifmt_ctx, filename, NULL, NULL)) < 0) {
-        fprintf(stderr, "Cannot open input file '%s', Error code: %s\n",
-                filename, av_err2str(ret));
-        return ret;
-    }
-
-    if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) < 0) {
-        fprintf(stderr, "Cannot find input stream information. Error code: %s\n",
-                av_err2str(ret));
-        return ret;
-    }
-
-    ret = av_find_best_stream(ifmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &decoder, 0);
-    if (ret < 0) {
-        fprintf(stderr, "Cannot find a video stream in the input file. "
-                "Error code: %s\n", av_err2str(ret));
-        return ret;
-    }
-    video_stream = ret;
-
-    if (!(decoder_ctx = avcodec_alloc_context3(decoder)))
-        return AVERROR(ENOMEM);
-
-    video = ifmt_ctx->streams[video_stream];
-    if ((ret = avcodec_parameters_to_context(decoder_ctx, video->codecpar)) < 0) {
-        fprintf(stderr, "avcodec_parameters_to_context error. Error code: %s\n",
-                av_err2str(ret));
-        return ret;
-    }
-
-    decoder_ctx->hw_device_ctx = av_buffer_ref(hw_device_ctx);
-    if (!decoder_ctx->hw_device_ctx) {
-        fprintf(stderr, "A hardware device reference create failed.\n");
-        return AVERROR(ENOMEM);
-    }
-    decoder_ctx->get_format    = get_vaapi_format;
-
-    if ((ret = avcodec_open2(decoder_ctx, decoder, NULL)) < 0)
-        fprintf(stderr, "Failed to open codec for decoding. Error code: %s\n",
-                av_err2str(ret));
-
-    return ret;
-}
-
-static int encode_write(AVFrame *frame)
-{
-    int ret = 0;
-    AVPacket enc_pkt;
-
-    av_init_packet(&enc_pkt);
-    enc_pkt.data = NULL;
-    enc_pkt.size = 0;
-
-    if ((ret = avcodec_send_frame(encoder_ctx, frame)) < 0) {
-        fprintf(stderr, "Error during encoding. Error code: %s\n", av_err2str(ret));
-        goto end;
-    }
-    while (1) {
-        ret = avcodec_receive_packet(encoder_ctx, &enc_pkt);
-        if (ret)
-            break;
-
-        enc_pkt.stream_index = 0;
-        av_packet_rescale_ts(&enc_pkt, ifmt_ctx->streams[video_stream]->time_base,
-                             ofmt_ctx->streams[0]->time_base);
-        ret = av_interleaved_write_frame(ofmt_ctx, &enc_pkt);
-        if (ret < 0) {
-            fprintf(stderr, "Error during writing data to output file. "
-                    "Error code: %s\n", av_err2str(ret));
-            return -1;
-        }
-    }
-
-end:
-    if (ret == AVERROR_EOF)
-        return 0;
-    ret = ((ret == AVERROR(EAGAIN)) ? 0:-1);
-    return ret;
-}
-
-static int dec_enc(AVPacket *pkt, AVCodec *enc_codec)
-{
-    AVFrame *frame;
-    int ret = 0;
-
-    ret = avcodec_send_packet(decoder_ctx, pkt);
-    if (ret < 0) {
-        fprintf(stderr, "Error during decoding. Error code: %s\n", av_err2str(ret));
-        return ret;
-    }
-
-    while (ret >= 0) {
-        if (!(frame = av_frame_alloc()))
-            return AVERROR(ENOMEM);
-
-        ret = avcodec_receive_frame(decoder_ctx, frame);
-        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
-            av_frame_free(&frame);
-            return 0;
-        } else if (ret < 0) {
-            fprintf(stderr, "Error while decoding. Error code: %s\n", av_err2str(ret));
-            goto fail;
-        }
-
-        if (!initialized) {
-            /* we need to ref hw_frames_ctx of decoder to initialize encoder's codec.
-               Only after we get a decoded frame, can we obtain its hw_frames_ctx */
-            encoder_ctx->hw_frames_ctx = av_buffer_ref(decoder_ctx->hw_frames_ctx);
-            if (!encoder_ctx->hw_frames_ctx) {
-                ret = AVERROR(ENOMEM);
-                goto fail;
-            }
-            /* set AVCodecContext Parameters for encoder, here we keep them stay
-             * the same as decoder.
-             * 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;
-            encoder_ctx->width     = decoder_ctx->width;
-            encoder_ctx->height    = decoder_ctx->height;
-
-            if ((ret = avcodec_open2(encoder_ctx, enc_codec, NULL)) < 0) {
-                fprintf(stderr, "Failed to open encode codec. Error code: %s\n",
-                        av_err2str(ret));
-                goto fail;
-            }
-
-            if (!(ost = avformat_new_stream(ofmt_ctx, enc_codec))) {
-                fprintf(stderr, "Failed to allocate stream for output format.\n");
-                ret = AVERROR(ENOMEM);
-                goto fail;
-            }
-
-            ost->time_base = encoder_ctx->time_base;
-            ret = avcodec_parameters_from_context(ost->codecpar, encoder_ctx);
-            if (ret < 0) {
-                fprintf(stderr, "Failed to copy the stream parameters. "
-                        "Error code: %s\n", av_err2str(ret));
-                goto fail;
-            }
-
-            /* write the stream header */
-            if ((ret = avformat_write_header(ofmt_ctx, NULL)) < 0) {
-                fprintf(stderr, "Error while writing stream header. "
-                        "Error code: %s\n", av_err2str(ret));
-                goto fail;
-            }
-
-            initialized = 1;
-        }
-
-        if ((ret = encode_write(frame)) < 0)
-            fprintf(stderr, "Error during encoding and writing.\n");
-
-fail:
-        av_frame_free(&frame);
-        if (ret < 0)
-            return ret;
-    }
-    return 0;
-}
-
-int main(int argc, char **argv)
-{
-    int ret = 0;
-    AVPacket dec_pkt;
-    AVCodec *enc_codec;
-
-    if (argc != 4) {
-        fprintf(stderr, "Usage: %s <input file> <encode codec> <output file>\n"
-                "The output format is guessed according to the file extension.\n"
-                "\n", argv[0]);
-        return -1;
-    }
-
-    ret = av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_VAAPI, NULL, NULL, 0);
-    if (ret < 0) {
-        fprintf(stderr, "Failed to create a VAAPI device. Error code: %s\n", av_err2str(ret));
-        return -1;
-    }
-
-    if ((ret = open_input_file(argv[1])) < 0)
-        goto end;
-
-    if (!(enc_codec = avcodec_find_encoder_by_name(argv[2]))) {
-        fprintf(stderr, "Could not find encoder '%s'\n", argv[2]);
-        ret = -1;
-        goto end;
-    }
-
-    if ((ret = (avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, argv[3]))) < 0) {
-        fprintf(stderr, "Failed to deduce output format from file extension. Error code: "
-                "%s\n", av_err2str(ret));
-        goto end;
-    }
-
-    if (!(encoder_ctx = avcodec_alloc_context3(enc_codec))) {
-        ret = AVERROR(ENOMEM);
-        goto end;
-    }
-
-    ret = avio_open(&ofmt_ctx->pb, argv[3], AVIO_FLAG_WRITE);
-    if (ret < 0) {
-        fprintf(stderr, "Cannot open output file. "
-                "Error code: %s\n", av_err2str(ret));
-        goto end;
-    }
-
-    /* read all packets and only transcoding video */
-    while (ret >= 0) {
-        if ((ret = av_read_frame(ifmt_ctx, &dec_pkt)) < 0)
-            break;
-
-        if (video_stream == dec_pkt.stream_index)
-            ret = dec_enc(&dec_pkt, enc_codec);
-
-        av_packet_unref(&dec_pkt);
-    }
-
-    /* flush decoder */
-    dec_pkt.data = NULL;
-    dec_pkt.size = 0;
-    ret = dec_enc(&dec_pkt, enc_codec);
-    av_packet_unref(&dec_pkt);
-
-    /* flush encoder */
-    ret = encode_write(NULL);
-
-    /* write the trailer for output stream */
-    av_write_trailer(ofmt_ctx);
-
-end:
-    avformat_close_input(&ifmt_ctx);
-    avformat_close_input(&ofmt_ctx);
-    avcodec_free_context(&decoder_ctx);
-    avcodec_free_context(&encoder_ctx);
-    av_buffer_unref(&hw_device_ctx);
-    return ret;
-}

doc/faq.texi

@@ -501,71 +501,6 @@ ffmpeg -i ega_screen.nut -vf setdar=4/3 ega_screen_anamorphic.nut
 ffmpeg -i ega_screen.nut -aspect 4/3 -c copy ega_screen_overridden.nut
 @end example
 
-@anchor{background task}
-@section How do I run ffmpeg as a background task?
-
-ffmpeg normally checks the console input, for entries like "q" to stop
-and "?" to give help, while performing operations. ffmpeg does not have a way of
-detecting when it is running as a background task.
-When it checks the console input, that can cause the process running ffmpeg
-in the background to suspend.
-
-To prevent those input checks, allowing ffmpeg to run as a background task,
-use the @url{ffmpeg.html#stdin-option, @code{-nostdin} option}
-in the ffmpeg invocation. This is effective whether you run ffmpeg in a shell
-or invoke ffmpeg in its own process via an operating system API.
-
-As an alternative, when you are running ffmpeg in a shell, you can redirect
-standard input to @code{/dev/null} (on Linux and Mac OS)
-or @code{NUL} (on Windows). You can do this redirect either
-on the ffmpeg invocation, or from a shell script which calls ffmpeg.
-
-For example:
-
-@example
-ffmpeg -nostdin -i INPUT OUTPUT
-@end example
-
-or (on Linux, Mac OS, and other UNIX-like shells):
-
-@example
-ffmpeg -i INPUT OUTPUT </dev/null
-@end example
-
-or (on Windows):
-
-@example
-ffmpeg -i INPUT OUTPUT <NUL
-@end example
-
-@section How do I prevent ffmpeg from suspending with a message like @emph{suspended (tty output)}?
-
-If you run ffmpeg in the background, you may find that its process suspends.
-There may be a message like @emph{suspended (tty output)}. The question is how
-to prevent the process from being suspended.
-
-For example:
-
-@example
-% ffmpeg -i INPUT OUTPUT &> ~/tmp/log.txt &
-[1] 93352
-%
-[1]  + suspended (tty output)  ffmpeg -i INPUT OUTPUT &>
-@end example
-
-The message "tty output" notwithstanding, the problem here is that
-ffmpeg normally checks the console input when it runs. The operating system
-detects this, and suspends the process until you can bring it to the
-foreground and attend to it.
-
-The solution is to use the right techniques to tell ffmpeg not to consult
-console input. You can use the
-@url{ffmpeg.html#stdin-option, @code{-nostdin} option},
-or redirect standard input with @code{< /dev/null}.
-See FAQ
-@ref{background task, @emph{How do I run ffmpeg as a background task?}}
-for details.
-
 @chapter Development
 
 @section Are there examples illustrating how to use the FFmpeg libraries, particularly libavcodec and libavformat?

doc/fate.texi

@@ -147,26 +147,6 @@ process.
 The only thing left is to automate the execution of the fate.sh script and
 the synchronisation of the samples directory.
 
-@chapter Uploading new samples to the fate suite
-
-This is for developers who have an account on the fate suite server.
-If you upload new samples, please make sure they are as small as possible,
-space on each client, network bandwidth and so on benefit from smaller test cases.
-Also keep in mind older checkouts use existing sample files, that means in
-practice generally do not replace, remove or overwrite files as it likely would
-break older checkouts or releases.
-
-@example
-#First update your local samples copy:
-rsync -vauL --chmod=Dg+s,Duo+x,ug+rw,o+r,o-w,+X fate-suite.ffmpeg.org:/home/samples/fate-suite/ ~/fate-suite
-
-#Then do a dry run checking what would be uploaded:
-rsync -vanL --no-g --chmod=Dg+s,Duo+x,ug+rw,o+r,o-w,+X ~/fate-suite/ fate-suite.ffmpeg.org:/home/samples/fate-suite
-
-#Upload the files:
-rsync -vaL  --no-g --chmod=Dg+s,Duo+x,ug+rw,o+r,o-w,+X ~/fate-suite/ fate-suite.ffmpeg.org:/home/samples/fate-suite
-@end example
-
 
 @chapter FATE makefile targets and variables
 

doc/ffmpeg-bitstream-filters.texi

@@ -26,12 +26,12 @@ bitstream level modifications without performing decoding.
 @chapter See Also
 
 @ifhtml
-@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe},
+@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe}, @url{ffserver.html,ffserver},
 @url{libavcodec.html,libavcodec}
 @end ifhtml
 
 @ifnothtml
-ffmpeg(1), ffplay(1), ffprobe(1), libavcodec(3)
+ffmpeg(1), ffplay(1), ffprobe(1), ffserver(1), libavcodec(3)
 @end ifnothtml
 
 @include authors.texi

doc/ffmpeg-codecs.texi

@@ -23,12 +23,12 @@ the libavcodec library.
 @chapter See Also
 
 @ifhtml
-@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe},
+@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe}, @url{ffserver.html,ffserver},
 @url{libavcodec.html,libavcodec}
 @end ifhtml
 
 @ifnothtml
-ffmpeg(1), ffplay(1), ffprobe(1), libavcodec(3)
+ffmpeg(1), ffplay(1), ffprobe(1), ffserver(1), libavcodec(3)
 @end ifnothtml
 
 @include authors.texi

doc/ffmpeg-devices.texi

@@ -23,12 +23,12 @@ libavdevice library.
 @chapter See Also
 
 @ifhtml
-@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe},
+@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe}, @url{ffserver.html,ffserver},
 @url{libavdevice.html,libavdevice}
 @end ifhtml
 
 @ifnothtml
-ffmpeg(1), ffplay(1), ffprobe(1), libavdevice(3)
+ffmpeg(1), ffplay(1), ffprobe(1), ffserver(1), libavdevice(3)
 @end ifnothtml
 
 @include authors.texi

doc/ffmpeg-filters.texi

@@ -23,12 +23,12 @@ libavfilter library.
 @chapter See Also
 
 @ifhtml
-@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe},
+@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe}, @url{ffserver.html,ffserver},
 @url{libavfilter.html,libavfilter}
 @end ifhtml
 
 @ifnothtml
-ffmpeg(1), ffplay(1), ffprobe(1), libavfilter(3)
+ffmpeg(1), ffplay(1), ffprobe(1), ffserver(1), libavfilter(3)
 @end ifnothtml
 
 @include authors.texi

doc/ffmpeg-formats.texi

@@ -23,12 +23,12 @@ provided by the libavformat library.
 @chapter See Also
 
 @ifhtml
-@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe},
+@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe}, @url{ffserver.html,ffserver},
 @url{libavformat.html,libavformat}
 @end ifhtml
 
 @ifnothtml
-ffmpeg(1), ffplay(1), ffprobe(1), libavformat(3)
+ffmpeg(1), ffplay(1), ffprobe(1), ffserver(1), libavformat(3)
 @end ifnothtml
 
 @include authors.texi

doc/ffmpeg-protocols.texi

@@ -23,12 +23,12 @@ libavformat library.
 @chapter See Also
 
 @ifhtml
-@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe},
+@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe}, @url{ffserver.html,ffserver},
 @url{libavformat.html,libavformat}
 @end ifhtml
 
 @ifnothtml
-ffmpeg(1), ffplay(1), ffprobe(1), libavformat(3)
+ffmpeg(1), ffplay(1), ffprobe(1), ffserver(1), libavformat(3)
 @end ifnothtml
 
 @include authors.texi

doc/ffmpeg-resampler.texi

@@ -25,12 +25,12 @@ and convert audio format and packing layout.
 @chapter See Also
 
 @ifhtml
-@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe},
+@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe}, @url{ffserver.html,ffserver},
 @url{libswresample.html,libswresample}
 @end ifhtml
 
 @ifnothtml
-ffmpeg(1), ffplay(1), ffprobe(1), libswresample(3)
+ffmpeg(1), ffplay(1), ffprobe(1), ffserver(1), libswresample(3)
 @end ifnothtml
 
 @include authors.texi

doc/ffmpeg-scaler.texi

@@ -24,12 +24,12 @@ image rescaling and pixel format conversion.
 @chapter See Also
 
 @ifhtml
-@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe},
+@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe}, @url{ffserver.html,ffserver},
 @url{libswscale.html,libswscale}
 @end ifhtml
 
 @ifnothtml
-ffmpeg(1), ffplay(1), ffprobe(1), libswscale(3)
+ffmpeg(1), ffplay(1), ffprobe(1), ffserver(1), libswscale(3)
 @end ifnothtml
 
 @include authors.texi

doc/ffmpeg-utils.texi

@@ -23,12 +23,12 @@ by the libavutil library.
 @chapter See Also
 
 @ifhtml
-@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe},
+@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe}, @url{ffserver.html,ffserver},
 @url{libavutil.html,libavutil}
 @end ifhtml
 
 @ifnothtml
-ffmpeg(1), ffplay(1), ffprobe(1), libavutil(3)
+ffmpeg(1), ffplay(1), ffprobe(1), ffserver(1), libavutil(3)
 @end ifnothtml
 
 @include authors.texi

doc/ffmpeg.texi

@@ -289,8 +289,8 @@ see @ref{time duration syntax,,the Time duration section in the ffmpeg-utils(1)
 
 -to and -t are mutually exclusive and -t has priority.
 
-@item -to @var{position} (@emph{input/output})
-Stop writing the output or reading the input at @var{position}.
+@item -to @var{position} (@emph{output})
+Stop writing the output at @var{position}.
 @var{position} must be a time duration specification,
 see @ref{time duration syntax,,the Time duration section in the ffmpeg-utils(1) manual,ffmpeg-utils}.
 
@@ -413,10 +413,6 @@ they do not conflict with the standard, as in:
 ffmpeg -i myfile.avi -target vcd -bf 2 /tmp/vcd.mpg
 @end example
 
-@item -dn (@emph{output})
-Disable data recording. For full manual control see the @code{-map}
-option.
-
 @item -dframes @var{number} (@emph{output})
 Set the number of data frames to output. This is an obsolete alias for
 @code{-frames:d}, which you should use instead.
@@ -474,7 +470,6 @@ the encoding process. It is made of "@var{key}=@var{value}" lines. @var{key}
 consists of only alphanumeric characters. The last key of a sequence of
 progress information is always "progress".
 
-@anchor{stdin option}
 @item -stdin
 Enable interaction on standard input. On by default unless standard input is
 used as an input. To explicitly disable interaction you need to specify
@@ -575,8 +570,7 @@ stored at container level, but not the aspect ratio stored in encoded
 frames, if it exists.
 
 @item -vn (@emph{output})
-Disable video recording. For full manual control see the @code{-map}
-option.
+Disable video recording.
 
 @item -vcodec @var{codec} (@emph{output})
 Set the video codec. This is an alias for @code{-codec:v}.
@@ -762,43 +756,6 @@ If not specified, @samp{auto_any} is used.
 platform-appropriate subdevice (@samp{dxva2} or @samp{vaapi}) and then deriving a
 QSV device from that.)
 
-@item opencl
-@var{device} selects the platform and device as @emph{platform_index.device_index}.
-
-The set of devices can also be filtered using the key-value pairs to find only
-devices matching particular platform or device strings.
-
-The strings usable as filters are:
-@table @option
-@item platform_profile
-@item platform_version
-@item platform_name
-@item platform_vendor
-@item platform_extensions
-@item device_name
-@item device_vendor
-@item driver_version
-@item device_version
-@item device_profile
-@item device_extensions
-@item device_type
-@end table
-
-The indices and filters must together uniquely select a device.
-
-Examples:
-@table @emph
-@item -init_hw_device opencl:0.1
-Choose the second device on the first platform.
-
-@item -init_hw_device opencl:,device_name=Foo9000
-Choose the device with a name containing the string @emph{Foo9000}.
-
-@item -init_hw_device opencl:1,device_type=gpu,device_extensions=cl_khr_fp16
-Choose the GPU device on the second platform supporting the @emph{cl_khr_fp16}
-extension.
-@end table
-
 @end table
 
 @item -init_hw_device @var{type}[=@var{name}]@@@var{source}
@@ -829,6 +786,9 @@ Do not use any hardware acceleration (the default).
 @item auto
 Automatically select the hardware acceleration method.
 
+@item vda
+Use Apple VDA hardware acceleration.
+
 @item vdpau
 Use VDPAU (Video Decode and Presentation API for Unix) hardware acceleration.
 
@@ -891,8 +851,7 @@ default to the number of input audio channels. For input streams
 this option only makes sense for audio grabbing devices and raw demuxers
 and is mapped to the corresponding demuxer options.
 @item -an (@emph{output})
-Disable audio recording. For full manual control see the @code{-map}
-option.
+Disable audio recording.
 @item -acodec @var{codec} (@emph{input/output})
 Set the audio codec. This is an alias for @code{-codec:a}.
 @item -sample_fmt[:@var{stream_specifier}] @var{sample_fmt} (@emph{output,per-stream})
@@ -927,8 +886,7 @@ stereo but not 6 channels as 5.1. The default is to always try to guess. Use
 @item -scodec @var{codec} (@emph{input/output})
 Set the subtitle codec. This is an alias for @code{-codec:s}.
 @item -sn (@emph{output})
-Disable subtitle recording. For full manual control see the @code{-map}
-option.
+Disable subtitle recording.
 @item -sbsf @var{bitstream_filter}
 Deprecated, see -bsf
 @end table
@@ -1174,6 +1132,10 @@ loss).
 By default @command{ffmpeg} attempts to read the input(s) as fast as possible.
 This option will slow down the reading of the input(s) to the native frame rate
 of the input(s). It is useful for real-time output (e.g. live streaming).
+@item -loop_input
+Loop over the input stream. Currently it works only for image
+streams. This option is used for automatic FFserver testing.
+This option is deprecated, use -loop 1.
 @item -loop_output @var{number_of_times}
 Repeatedly loop output for formats that support looping such as animated GIF
 (0 will loop the output infinitely).
@@ -1291,8 +1253,6 @@ or as a floating point number (e.g. 0.04166, 2.0833e-5)
 
 Default value is 0.
 
-@item -bitexact (@emph{input/output})
-Enable bitexact mode for (de)muxer and (de/en)coder
 @item -shortest (@emph{output})
 Finish encoding when the shortest input stream ends.
 @item -dts_delta_threshold
@@ -1415,6 +1375,16 @@ file or device. With low latency / high rate live streams, packets may be
 discarded if they are not read in a timely manner; raising this value can
 avoid it.
 
+@item -override_ffserver (@emph{global})
+Overrides the input specifications from @command{ffserver}. Using this
+option you can map any input stream to @command{ffserver} and control
+many aspects of the encoding from @command{ffmpeg}. Without this
+option @command{ffmpeg} will transmit to @command{ffserver} what is
+requested by @command{ffserver}.
+
+The option is intended for cases where features are needed that cannot be
+specified to @command{ffserver} but can be to @command{ffmpeg}.
+
 @item -sdp_file @var{file} (@emph{global})
 Print sdp information for an output stream to @var{file}.
 This allows dumping sdp information when at least one output isn't an
@@ -1769,7 +1739,7 @@ ffmpeg -i src.ext -lmax 21*QP2LAMBDA dst.ext
 @ifset config-not-all
 @url{ffmpeg-all.html,ffmpeg-all},
 @end ifset
-@url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe},
+@url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe}, @url{ffserver.html,ffserver},
 @url{ffmpeg-utils.html,ffmpeg-utils},
 @url{ffmpeg-scaler.html,ffmpeg-scaler},
 @url{ffmpeg-resampler.html,ffmpeg-resampler},
@@ -1788,7 +1758,7 @@ ffmpeg(1),
 @ifset config-not-all
 ffmpeg-all(1),
 @end ifset
-ffplay(1), ffprobe(1),
+ffplay(1), ffprobe(1), ffserver(1),
 ffmpeg-utils(1), ffmpeg-scaler(1), ffmpeg-resampler(1),
 ffmpeg-codecs(1), ffmpeg-bitstream-filters(1), ffmpeg-formats(1),
 ffmpeg-devices(1), ffmpeg-protocols(1), ffmpeg-filters(1)

doc/ffplay.texi

@@ -291,7 +291,7 @@ Toggle full screen.
 @ifset config-not-all
 @url{ffplay-all.html,ffmpeg-all},
 @end ifset
-@url{ffmpeg.html,ffmpeg}, @url{ffprobe.html,ffprobe},
+@url{ffmpeg.html,ffmpeg}, @url{ffprobe.html,ffprobe}, @url{ffserver.html,ffserver},
 @url{ffmpeg-utils.html,ffmpeg-utils},
 @url{ffmpeg-scaler.html,ffmpeg-scaler},
 @url{ffmpeg-resampler.html,ffmpeg-resampler},
@@ -310,7 +310,7 @@ ffplay(1),
 @ifset config-not-all
 ffplay-all(1),
 @end ifset
-ffmpeg(1), ffprobe(1),
+ffmpeg(1), ffprobe(1), ffserver(1),
 ffmpeg-utils(1), ffmpeg-scaler(1), ffmpeg-resampler(1),
 ffmpeg-codecs(1), ffmpeg-bitstream-filters(1), ffmpeg-formats(1),
 ffmpeg-devices(1), ffmpeg-protocols(1), ffmpeg-filters(1)

doc/ffprobe.texi

@@ -653,7 +653,7 @@ DV, GXF and AVI timecodes are available in format metadata
 @ifset config-not-all
 @url{ffprobe-all.html,ffprobe-all},
 @end ifset
-@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay},
+@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffserver.html,ffserver},
 @url{ffmpeg-utils.html,ffmpeg-utils},
 @url{ffmpeg-scaler.html,ffmpeg-scaler},
 @url{ffmpeg-resampler.html,ffmpeg-resampler},
@@ -672,7 +672,7 @@ ffprobe(1),
 @ifset config-not-all
 ffprobe-all(1),
 @end ifset
-ffmpeg(1), ffplay(1),
+ffmpeg(1), ffplay(1), ffserver(1),
 ffmpeg-utils(1), ffmpeg-scaler(1), ffmpeg-resampler(1),
 ffmpeg-codecs(1), ffmpeg-bitstream-filters(1), ffmpeg-formats(1),
 ffmpeg-devices(1), ffmpeg-protocols(1), ffmpeg-filters(1)

doc/ffserver.conf

@@ -0,0 +1,372 @@
+# Port on which the server is listening. You must select a different
+# port from your standard HTTP web server if it is running on the same
+# computer.
+HTTPPort 8090
+
+# Address on which the server is bound. Only useful if you have
+# several network interfaces.
+HTTPBindAddress 0.0.0.0
+
+# Number of simultaneous HTTP connections that can be handled. It has
+# to be defined *before* the MaxClients parameter, since it defines the
+# MaxClients maximum limit.
+MaxHTTPConnections 2000
+
+# Number of simultaneous requests that can be handled. Since FFServer
+# is very fast, it is more likely that you will want to leave this high
+# and use MaxBandwidth, below.
+MaxClients 1000
+
+# This the maximum amount of kbit/sec that you are prepared to
+# consume when streaming to clients.
+MaxBandwidth 1000
+
+# Access log file (uses standard Apache log file format)
+# '-' is the standard output.
+CustomLog -
+
+##################################################################
+# Definition of the live feeds. Each live feed contains one video
+# and/or audio sequence coming from an ffmpeg encoder or another
+# ffserver. This sequence may be encoded simultaneously with several
+# codecs at several resolutions.
+
+<Feed feed1.ffm>
+
+# You must use 'ffmpeg' to send a live feed to ffserver. In this
+# example, you can type:
+#
+# ffmpeg http://localhost:8090/feed1.ffm
+
+# ffserver can also do time shifting. It means that it can stream any
+# previously recorded live stream. The request should contain:
+# "http://xxxx?date=[YYYY-MM-DDT][[HH:]MM:]SS[.m...]".You must specify
+# a path where the feed is stored on disk. You also specify the
+# maximum size of the feed, where zero means unlimited. Default:
+# File=/tmp/feed_name.ffm FileMaxSize=5M
+File /tmp/feed1.ffm
+FileMaxSize 200K
+
+# You could specify
+# ReadOnlyFile /saved/specialvideo.ffm
+# This marks the file as readonly and it will not be deleted or updated.
+
+# Specify launch in order to start ffmpeg automatically.
+# First ffmpeg must be defined with an appropriate path if needed,
+# after that options can follow, but avoid adding the http:// field
+#Launch ffmpeg
+
+# Only allow connections from localhost to the feed.
+ACL allow 127.0.0.1
+
+</Feed>
+
+
+##################################################################
+# Now you can define each stream which will be generated from the
+# original audio and video stream. Each format has a filename (here
+# 'test1.mpg'). FFServer will send this stream when answering a
+# request containing this filename.
+
+<Stream test1.mpg>
+
+# coming from live feed 'feed1'
+Feed feed1.ffm
+
+# Format of the stream : you can choose among:
+# mpeg       : MPEG-1 multiplexed video and audio
+# mpegvideo  : only MPEG-1 video
+# mp2        : MPEG-2 audio (use AudioCodec to select layer 2 and 3 codec)
+# ogg        : Ogg format (Vorbis audio codec)
+# rm         : RealNetworks-compatible stream. Multiplexed audio and video.
+# ra         : RealNetworks-compatible stream. Audio only.
+# mpjpeg     : Multipart JPEG (works with Netscape without any plugin)
+# jpeg       : Generate a single JPEG image.
+# mjpeg      : Generate a M-JPEG stream.
+# asf        : ASF compatible streaming (Windows Media Player format).
+# swf        : Macromedia Flash compatible stream
+# avi        : AVI format (MPEG-4 video, MPEG audio sound)
+Format mpeg
+
+# Bitrate for the audio stream. Codecs usually support only a few
+# different bitrates.
+AudioBitRate 32
+
+# Number of audio channels: 1 = mono, 2 = stereo
+AudioChannels 1
+
+# Sampling frequency for audio. When using low bitrates, you should
+# lower this frequency to 22050 or 11025. The supported frequencies
+# depend on the selected audio codec.
+AudioSampleRate 44100
+
+# Bitrate for the video stream
+VideoBitRate 64
+
+# Ratecontrol buffer size
+VideoBufferSize 40
+
+# Number of frames per second
+VideoFrameRate 3
+
+# Size of the video frame: WxH (default: 160x128)
+# The following abbreviations are defined: sqcif, qcif, cif, 4cif, qqvga,
+# qvga, vga, svga, xga, uxga, qxga, sxga, qsxga, hsxga, wvga, wxga, wsxga,
+# wuxga, woxga, wqsxga, wquxga, whsxga, whuxga, cga, ega, hd480, hd720,
+# hd1080
+VideoSize 160x128
+
+# Transmit only intra frames (useful for low bitrates, but kills frame rate).
+#VideoIntraOnly
+
+# If non-intra only, an intra frame is transmitted every VideoGopSize
+# frames. Video synchronization can only begin at an intra frame.
+VideoGopSize 12
+
+# More MPEG-4 parameters
+# VideoHighQuality
+# Video4MotionVector
+
+# Choose your codecs:
+#AudioCodec mp2
+#VideoCodec mpeg1video
+
+# Suppress audio
+#NoAudio
+
+# Suppress video
+#NoVideo
+
+#VideoQMin 3
+#VideoQMax 31
+
+# Set this to the number of seconds backwards in time to start. Note that
+# most players will buffer 5-10 seconds of video, and also you need to allow
+# for a keyframe to appear in the data stream.
+#Preroll 15
+
+# ACL:
+
+# You can allow ranges of addresses (or single addresses)
+#ACL ALLOW <first address> <last address>
+
+# You can deny ranges of addresses (or single addresses)
+#ACL DENY <first address> <last address>
+
+# You can repeat the ACL allow/deny as often as you like. It is on a per
+# stream basis. The first match defines the action. If there are no matches,
+# then the default is the inverse of the last ACL statement.
+#
+# Thus 'ACL allow localhost' only allows access from localhost.
+# 'ACL deny 1.0.0.0 1.255.255.255' would deny the whole of network 1 and
+# allow everybody else.
+
+</Stream>
+
+
+##################################################################
+# Example streams
+
+
+# Multipart JPEG
+
+#<Stream test.mjpg>
+#Feed feed1.ffm
+#Format mpjpeg
+#VideoFrameRate 2
+#VideoIntraOnly
+#NoAudio
+#Strict -1
+#</Stream>
+
+
+# Single JPEG
+
+#<Stream test.jpg>
+#Feed feed1.ffm
+#Format jpeg
+#VideoFrameRate 2
+#VideoIntraOnly
+##VideoSize 352x240
+#NoAudio
+#Strict -1
+#</Stream>
+
+
+# Flash
+
+#<Stream test.swf>
+#Feed feed1.ffm
+#Format swf
+#VideoFrameRate 2
+#VideoIntraOnly
+#NoAudio
+#</Stream>
+
+
+# ASF compatible
+
+<Stream test.asf>
+Feed feed1.ffm
+Format asf
+VideoFrameRate 15
+VideoSize 352x240
+VideoBitRate 256
+VideoBufferSize 40
+VideoGopSize 30
+AudioBitRate 64
+StartSendOnKey
+</Stream>
+
+
+# MP3 audio
+
+#<Stream test.mp3>
+#Feed feed1.ffm
+#Format mp2
+#AudioCodec mp3
+#AudioBitRate 64
+#AudioChannels 1
+#AudioSampleRate 44100
+#NoVideo
+#</Stream>
+
+
+# Ogg Vorbis audio
+
+#<Stream test.ogg>
+#Feed feed1.ffm
+#Metadata title "Stream title"
+#AudioBitRate 64
+#AudioChannels 2
+#AudioSampleRate 44100
+#NoVideo
+#</Stream>
+
+
+# Real with audio only at 32 kbits
+
+#<Stream test.ra>
+#Feed feed1.ffm
+#Format rm
+#AudioBitRate 32
+#NoVideo
+#NoAudio
+#</Stream>
+
+
+# Real with audio and video at 64 kbits
+
+#<Stream test.rm>
+#Feed feed1.ffm
+#Format rm
+#AudioBitRate 32
+#VideoBitRate 128
+#VideoFrameRate 25
+#VideoGopSize 25
+#NoAudio
+#</Stream>
+
+
+##################################################################
+# A stream coming from a file: you only need to set the input
+# filename and optionally a new format. Supported conversions:
+#    AVI -> ASF
+
+#<Stream file.rm>
+#File "/usr/local/httpd/htdocs/tlive.rm"
+#NoAudio
+#</Stream>
+
+#<Stream file.asf>
+#File "/usr/local/httpd/htdocs/test.asf"
+#NoAudio
+#Metadata author "Me"
+#Metadata copyright "Super MegaCorp"
+#Metadata title "Test stream from disk"
+#Metadata comment "Test comment"
+#</Stream>
+
+
+##################################################################
+# RTSP examples
+#
+# You can access this stream with the RTSP URL:
+#   rtsp://localhost:5454/test1-rtsp.mpg
+#
+# A non-standard RTSP redirector is also created. Its URL is:
+#   http://localhost:8090/test1-rtsp.rtsp
+
+#<Stream test1-rtsp.mpg>
+#Format rtp
+#File "/usr/local/httpd/htdocs/test1.mpg"
+#</Stream>
+
+
+# Transcode an incoming live feed to another live feed,
+# using libx264 and video presets
+
+#<Stream live.h264>
+#Format rtp
+#Feed feed1.ffm
+#VideoCodec libx264
+#VideoFrameRate 24
+#VideoBitRate 100
+#VideoSize 480x272
+#AVPresetVideo default
+#AVPresetVideo baseline
+#AVOptionVideo flags +global_header
+#
+#AudioCodec aac
+#AudioBitRate 32
+#AudioChannels 2
+#AudioSampleRate 22050
+#AVOptionAudio flags +global_header
+#</Stream>
+
+##################################################################
+# SDP/multicast examples
+#
+# If you want to send your stream in multicast, you must set the
+# multicast address with MulticastAddress. The port and the TTL can
+# also be set.
+#
+# An SDP file is automatically generated by ffserver by adding the
+# 'sdp' extension to the stream name (here
+# http://localhost:8090/test1-sdp.sdp). You should usually give this
+# file to your player to play the stream.
+#
+# The 'NoLoop' option can be used to avoid looping when the stream is
+# terminated.
+
+#<Stream test1-sdp.mpg>
+#Format rtp
+#File "/usr/local/httpd/htdocs/test1.mpg"
+#MulticastAddress 224.124.0.1
+#MulticastPort 5000
+#MulticastTTL 16
+#NoLoop
+#</Stream>
+
+
+##################################################################
+# Special streams
+
+# Server status
+
+<Stream stat.html>
+Format status
+
+# Only allow local people to get the status
+ACL allow localhost
+ACL allow 192.168.0.0 192.168.255.255
+
+#FaviconURL http://pond1.gladstonefamily.net:8080/favicon.ico
+</Stream>
+
+
+# Redirect index.html to the appropriate site
+
+<Redirect index.html>
+URL http://www.ffmpeg.org/
+</Redirect>

doc/ffserver.texi

@@ -0,0 +1,923 @@
+\input texinfo @c -*- texinfo -*-
+@documentencoding UTF-8
+
+@settitle ffserver Documentation
+@titlepage
+@center @titlefont{ffserver Documentation}
+@end titlepage
+
+@top
+
+@contents
+
+@chapter Synopsis
+
+ffserver [@var{options}]
+
+@chapter Description
+@c man begin DESCRIPTION
+
+@command{ffserver} is a streaming server for both audio and video.
+It supports several live feeds, streaming from files and time shifting
+on live feeds. You can seek to positions in the past on each live
+feed, provided you specify a big enough feed storage.
+
+@command{ffserver} is configured through a configuration file, which
+is read at startup. If not explicitly specified, it will read from
+@file{/etc/ffserver.conf}.
+
+@command{ffserver} receives prerecorded files or FFM streams from some
+@command{ffmpeg} instance as input, then streams them over
+RTP/RTSP/HTTP.
+
+An @command{ffserver} instance will listen on some port as specified
+in the configuration file. You can launch one or more instances of
+@command{ffmpeg} and send one or more FFM streams to the port where
+ffserver is expecting to receive them. Alternately, you can make
+@command{ffserver} launch such @command{ffmpeg} instances at startup.
+
+Input streams are called feeds, and each one is specified by a
+@code{<Feed>} section in the configuration file.
+
+For each feed you can have different output streams in various
+formats, each one specified by a @code{<Stream>} section in the
+configuration file.
+
+@chapter Detailed description
+
+@command{ffserver} works by forwarding streams encoded by
+@command{ffmpeg}, or pre-recorded streams which are read from disk.
+
+Precisely, @command{ffserver} acts as an HTTP server, accepting POST
+requests from @command{ffmpeg} to acquire the stream to publish, and
+serving RTSP clients or HTTP clients GET requests with the stream
+media content.
+
+A feed is an @ref{FFM} stream created by @command{ffmpeg}, and sent to
+a port where @command{ffserver} is listening.
+
+Each feed is identified by a unique name, corresponding to the name
+of the resource published on @command{ffserver}, and is configured by
+a dedicated @code{Feed} section in the configuration file.
+
+The feed publish URL is given by:
+@example
+http://@var{ffserver_ip_address}:@var{http_port}/@var{feed_name}
+@end example
+
+where @var{ffserver_ip_address} is the IP address of the machine where
+@command{ffserver} is installed, @var{http_port} is the port number of
+the HTTP server (configured through the @option{HTTPPort} option), and
+@var{feed_name} is the name of the corresponding feed defined in the
+configuration file.
+
+Each feed is associated to a file which is stored on disk. This stored
+file is used to send pre-recorded data to a player as fast as
+possible when new content is added in real-time to the stream.
+
+A "live-stream" or "stream" is a resource published by
+@command{ffserver}, and made accessible through the HTTP protocol to
+clients.
+
+A stream can be connected to a feed, or to a file. In the first case,
+the published stream is forwarded from the corresponding feed
+generated by a running instance of @command{ffmpeg}, in the second
+case the stream is read from a pre-recorded file.
+
+Each stream is identified by a unique name, corresponding to the name
+of the resource served by @command{ffserver}, and is configured by
+a dedicated @code{Stream} section in the configuration file.
+
+The stream access HTTP URL is given by:
+@example
+http://@var{ffserver_ip_address}:@var{http_port}/@var{stream_name}[@var{options}]
+@end example
+
+The stream access RTSP URL is given by:
+@example
+http://@var{ffserver_ip_address}:@var{rtsp_port}/@var{stream_name}[@var{options}]
+@end example
+
+@var{stream_name} is the name of the corresponding stream defined in
+the configuration file. @var{options} is a list of options specified
+after the URL which affects how the stream is served by
+@command{ffserver}. @var{http_port} and @var{rtsp_port} are the HTTP
+and RTSP ports configured with the options @var{HTTPPort} and
+@var{RTSPPort} respectively.
+
+In case the stream is associated to a feed, the encoding parameters
+must be configured in the stream configuration. They are sent to
+@command{ffmpeg} when setting up the encoding. This allows
+@command{ffserver} to define the encoding parameters used by
+the @command{ffmpeg} encoders.
+
+The @command{ffmpeg} @option{override_ffserver} commandline option
+allows one to override the encoding parameters set by the server.
+
+Multiple streams can be connected to the same feed.
+
+For example, you can have a situation described by the following
+graph:
+
+@verbatim
+               _________       __________
+              |         |     |          |
+ffmpeg 1 -----| feed 1  |-----| stream 1 |
+    \         |_________|\    |__________|
+     \                    \
+      \                    \   __________
+       \                    \ |          |
+        \                    \| stream 2 |
+         \                    |__________|
+          \
+           \   _________       __________
+            \ |         |     |          |
+             \| feed 2  |-----| stream 3 |
+              |_________|     |__________|
+
+               _________       __________
+              |         |     |          |
+ffmpeg 2 -----| feed 3  |-----| stream 4 |
+              |_________|     |__________|
+
+               _________       __________
+              |         |     |          |
+              | file 1  |-----| stream 5 |
+              |_________|     |__________|
+
+@end verbatim
+
+@anchor{FFM}
+@section FFM, FFM2 formats
+
+FFM and FFM2 are formats used by ffserver. They allow storing a wide variety of
+video and audio streams and encoding options, and can store a moving time segment
+of an infinite movie or a whole movie.
+
+FFM is version specific, and there is limited compatibility of FFM files
+generated by one version of ffmpeg/ffserver and another version of
+ffmpeg/ffserver. It may work but it is not guaranteed to work.
+
+FFM2 is extensible while maintaining compatibility and should work between
+differing versions of tools. FFM2 is the default.
+
+@section Status stream
+
+@command{ffserver} supports an HTTP interface which exposes the
+current status of the server.
+
+Simply point your browser to the address of the special status stream
+specified in the configuration file.
+
+For example if you have:
+@example
+<Stream status.html>
+Format status
+
+# Only allow local people to get the status
+ACL allow localhost
+ACL allow 192.168.0.0 192.168.255.255
+</Stream>
+@end example
+
+then the server will post a page with the status information when
+the special stream @file{status.html} is requested.
+
+@section How do I make it work?
+
+As a simple test, just run the following two command lines where INPUTFILE
+is some file which you can decode with ffmpeg:
+
+@example
+ffserver -f doc/ffserver.conf &
+ffmpeg -i INPUTFILE http://localhost:8090/feed1.ffm
+@end example
+
+At this point you should be able to go to your Windows machine and fire up
+Windows Media Player (WMP). Go to Open URL and enter
+
+@example
+    http://<linuxbox>:8090/test.asf
+@end example
+
+You should (after a short delay) see video and hear audio.
+
+WARNING: trying to stream test1.mpg doesn't work with WMP as it tries to
+transfer the entire file before starting to play.
+The same is true of AVI files.
+
+You should edit the @file{ffserver.conf} file to suit your needs (in
+terms of frame rates etc). Then install @command{ffserver} and
+@command{ffmpeg}, write a script to start them up, and off you go.
+
+@section What else can it do?
+
+You can replay video from .ffm files that was recorded earlier.
+However, there are a number of caveats, including the fact that the
+ffserver parameters must match the original parameters used to record the
+file. If they do not, then ffserver deletes the file before recording into it.
+(Now that I write this, it seems broken).
+
+You can fiddle with many of the codec choices and encoding parameters, and
+there are a bunch more parameters that you cannot control. Post a message
+to the mailing list if there are some 'must have' parameters. Look in
+ffserver.conf for a list of the currently available controls.
+
+It will automatically generate the ASX or RAM files that are often used
+in browsers. These files are actually redirections to the underlying ASF
+or RM file. The reason for this is that the browser often fetches the
+entire file before starting up the external viewer. The redirection files
+are very small and can be transferred quickly. [The stream itself is
+often 'infinite' and thus the browser tries to download it and never
+finishes.]
+
+@section Tips
+
+* When you connect to a live stream, most players (WMP, RA, etc) want to
+buffer a certain number of seconds of material so that they can display the
+signal continuously. However, ffserver (by default) starts sending data
+in realtime. This means that there is a pause of a few seconds while the
+buffering is being done by the player. The good news is that this can be
+cured by adding a '?buffer=5' to the end of the URL. This means that the
+stream should start 5 seconds in the past -- and so the first 5 seconds
+of the stream are sent as fast as the network will allow. It will then
+slow down to real time. This noticeably improves the startup experience.
+
+You can also add a 'Preroll 15' statement into the ffserver.conf that will
+add the 15 second prebuffering on all requests that do not otherwise
+specify a time. In addition, ffserver will skip frames until a key_frame
+is found. This further reduces the startup delay by not transferring data
+that will be discarded.
+
+@section Why does the ?buffer / Preroll stop working after a time?
+
+It turns out that (on my machine at least) the number of frames successfully
+grabbed is marginally less than the number that ought to be grabbed. This
+means that the timestamp in the encoded data stream gets behind realtime.
+This means that if you say 'Preroll 10', then when the stream gets 10
+or more seconds behind, there is no Preroll left.
+
+Fixing this requires a change in the internals of how timestamps are
+handled.
+
+@section Does the @code{?date=} stuff work.
+
+Yes (subject to the limitation outlined above). Also note that whenever you
+start ffserver, it deletes the ffm file (if any parameters have changed),
+thus wiping out what you had recorded before.
+
+The format of the @code{?date=xxxxxx} is fairly flexible. You should use one
+of the following formats (the 'T' is literal):
+
+@example
+* YYYY-MM-DDTHH:MM:SS     (localtime)
+* YYYY-MM-DDTHH:MM:SSZ    (UTC)
+@end example
+
+You can omit the YYYY-MM-DD, and then it refers to the current day. However
+note that @samp{?date=16:00:00} refers to 16:00 on the current day -- this
+may be in the future and so is unlikely to be useful.
+
+You use this by adding the ?date= to the end of the URL for the stream.
+For example:   @samp{http://localhost:8080/test.asf?date=2002-07-26T23:05:00}.
+@c man end
+
+@chapter Options
+@c man begin OPTIONS
+
+@include fftools-common-opts.texi
+
+@section Main options
+
+@table @option
+@item -f @var{configfile}
+Read configuration file @file{configfile}. If not specified it will
+read by default from @file{/etc/ffserver.conf}.
+
+@item -n
+Enable no-launch mode. This option disables all the @code{Launch}
+directives within the various @code{<Feed>} sections. Since
+@command{ffserver} will not launch any @command{ffmpeg} instances, you
+will have to launch them manually.
+
+@item -d
+Enable debug mode. This option increases log verbosity, and directs
+log messages to stdout. When specified, the @option{CustomLog} option
+is ignored.
+@end table
+
+@chapter Configuration file syntax
+
+@command{ffserver} reads a configuration file containing global
+options and settings for each stream and feed.
+
+The configuration file consists of global options and dedicated
+sections, which must be introduced by "<@var{SECTION_NAME}
+@var{ARGS}>" on a separate line and must be terminated by a line in
+the form "</@var{SECTION_NAME}>". @var{ARGS} is optional.
+
+Currently the following sections are recognized: @samp{Feed},
+@samp{Stream}, @samp{Redirect}.
+
+A line starting with @code{#} is ignored and treated as a comment.
+
+Name of options and sections are case-insensitive.
+
+@section ACL syntax
+An ACL (Access Control List) specifies the address which are allowed
+to access a given stream, or to write a given feed.
+
+It accepts the following forms
+@itemize
+@item
+Allow/deny access to @var{address}.
+@example
+ACL ALLOW <address>
+ACL DENY <address>
+@end example
+
+@item
+Allow/deny access to ranges of addresses from @var{first_address} to
+@var{last_address}.
+@example
+ACL ALLOW <first_address> <last_address>
+ACL DENY <first_address> <last_address>
+@end example
+@end itemize
+
+You can repeat the ACL allow/deny as often as you like. It is on a per
+stream basis. The first match defines the action. If there are no matches,
+then the default is the inverse of the last ACL statement.
+
+Thus 'ACL allow localhost' only allows access from localhost.
+'ACL deny 1.0.0.0 1.255.255.255' would deny the whole of network 1 and
+allow everybody else.
+
+@section Global options
+@table @option
+@item HTTPPort @var{port_number}
+@item Port @var{port_number}
+@item RTSPPort @var{port_number}
+
+@var{HTTPPort} sets the HTTP server listening TCP port number,
+@var{RTSPPort} sets the RTSP server listening TCP port number.
+
+@var{Port} is the equivalent of @var{HTTPPort} and is deprecated.
+
+You must select a different port from your standard HTTP web server if
+it is running on the same computer.
+
+If not specified, no corresponding server will be created.
+
+@item HTTPBindAddress @var{ip_address}
+@item BindAddress @var{ip_address}
+@item RTSPBindAddress @var{ip_address}
+Set address on which the HTTP/RTSP server is bound. Only useful if you
+have several network interfaces.
+
+@var{BindAddress} is the equivalent of @var{HTTPBindAddress} and is
+deprecated.
+
+@item MaxHTTPConnections @var{n}
+Set number of simultaneous HTTP connections that can be handled. It
+has to be defined @emph{before} the @option{MaxClients} parameter,
+since it defines the @option{MaxClients} maximum limit.
+
+Default value is 2000.
+
+@item MaxClients @var{n}
+Set number of simultaneous requests that can be handled. Since
+@command{ffserver} is very fast, it is more likely that you will want
+to leave this high and use @option{MaxBandwidth}.
+
+Default value is 5.
+
+@item MaxBandwidth @var{kbps}
+Set the maximum amount of kbit/sec that you are prepared to consume
+when streaming to clients.
+
+Default value is 1000.
+
+@item CustomLog @var{filename}
+Set access log file (uses standard Apache log file format). '-' is the
+standard output.
+
+If not specified @command{ffserver} will produce no log.
+
+In case the commandline option @option{-d} is specified this option is
+ignored, and the log is written to standard output.
+
+@item NoDaemon
+Set no-daemon mode. This option is currently ignored since now
+@command{ffserver} will always work in no-daemon mode, and is
+deprecated.
+
+@item UseDefaults
+@item NoDefaults
+Control whether default codec options are used for the all streams or not.
+Each stream may overwrite this setting for its own. Default is @var{UseDefaults}.
+The last occurrence overrides the previous if multiple definitions exist.
+@end table
+
+@section Feed section
+
+A Feed section defines a feed provided to @command{ffserver}.
+
+Each live feed contains one video and/or audio sequence coming from an
+@command{ffmpeg} encoder or another @command{ffserver}. This sequence
+may be encoded simultaneously with several codecs at several
+resolutions.
+
+A feed instance specification is introduced by a line in the form:
+@example
+<Feed FEED_FILENAME>
+@end example
+
+where @var{FEED_FILENAME} specifies the unique name of the FFM stream.
+
+The following options are recognized within a Feed section.
+
+@table @option
+@item File @var{filename}
+@item ReadOnlyFile @var{filename}
+Set the path where the feed file is stored on disk.
+
+If not specified, the @file{/tmp/FEED.ffm} is assumed, where
+@var{FEED} is the feed name.
+
+If @option{ReadOnlyFile} is used the file is marked as read-only and
+it will not be deleted or updated.
+
+@item Truncate
+Truncate the feed file, rather than appending to it. By default
+@command{ffserver} will append data to the file, until the maximum
+file size value is reached (see @option{FileMaxSize} option).
+
+@item FileMaxSize @var{size}
+Set maximum size of the feed file in bytes. 0 means unlimited. The
+postfixes @code{K} (2^10), @code{M} (2^20), and @code{G} (2^30) are
+recognized.
+
+Default value is 5M.
+
+@item Launch @var{args}
+Launch an @command{ffmpeg} command when creating @command{ffserver}.
+
+@var{args} must be a sequence of arguments to be provided to an
+@command{ffmpeg} instance. The first provided argument is ignored, and
+it is replaced by a path with the same dirname of the @command{ffserver}
+instance, followed by the remaining argument and terminated with a
+path corresponding to the feed.
+
+When the launched process exits, @command{ffserver} will launch
+another program instance.
+
+In case you need a more complex @command{ffmpeg} configuration,
+e.g. if you need to generate multiple FFM feeds with a single
+@command{ffmpeg} instance, you should launch @command{ffmpeg} by hand.
+
+This option is ignored in case the commandline option @option{-n} is
+specified.
+
+@item ACL @var{spec}
+Specify the list of IP address which are allowed or denied to write
+the feed. Multiple ACL options can be specified.
+@end table
+
+@section Stream section
+
+A Stream section defines a stream provided by @command{ffserver}, and
+identified by a single name.
+
+The stream is sent when answering a request containing the stream
+name.
+
+A stream section must be introduced by the line:
+@example
+<Stream STREAM_NAME>
+@end example
+
+where @var{STREAM_NAME} specifies the unique name of the stream.
+
+The following options are recognized within a Stream section.
+
+Encoding options are marked with the @emph{encoding} tag, and they are
+used to set the encoding parameters, and are mapped to libavcodec
+encoding options. Not all encoding options are supported, in
+particular it is not possible to set encoder private options. In order
+to override the encoding options specified by @command{ffserver}, you
+can use the @command{ffmpeg} @option{override_ffserver} commandline
+option.
+
+Only one of the @option{Feed} and @option{File} options should be set.
+
+@table @option
+@item Feed @var{feed_name}
+Set the input feed. @var{feed_name} must correspond to an existing
+feed defined in a @code{Feed} section.
+
+When this option is set, encoding options are used to setup the
+encoding operated by the remote @command{ffmpeg} process.
+
+@item File @var{filename}
+Set the filename of the pre-recorded input file to stream.
+
+When this option is set, encoding options are ignored and the input
+file content is re-streamed as is.
+
+@item Format @var{format_name}
+Set the format of the output stream.
+
+Must be the name of a format recognized by FFmpeg. If set to
+@samp{status}, it is treated as a status stream.
+
+@item InputFormat @var{format_name}
+Set input format. If not specified, it is automatically guessed.
+
+@item Preroll @var{n}
+Set this to the number of seconds backwards in time to start. Note that
+most players will buffer 5-10 seconds of video, and also you need to allow
+for a keyframe to appear in the data stream.
+
+Default value is 0.
+
+@item StartSendOnKey
+Do not send stream until it gets the first key frame. By default
+@command{ffserver} will send data immediately.
+
+@item MaxTime @var{n}
+Set the number of seconds to run. This value set the maximum duration
+of the stream a client will be able to receive.
+
+A value of 0 means that no limit is set on the stream duration.
+
+@item ACL @var{spec}
+Set ACL for the stream.
+
+@item DynamicACL @var{spec}
+
+@item RTSPOption @var{option}
+
+@item MulticastAddress @var{address}
+
+@item MulticastPort @var{port}
+
+@item MulticastTTL @var{integer}
+
+@item NoLoop
+
+@item FaviconURL @var{url}
+Set favicon (favourite icon) for the server status page. It is ignored
+for regular streams.
+
+@item Author @var{value}
+@item Comment @var{value}
+@item Copyright @var{value}
+@item Title @var{value}
+Set metadata corresponding to the option. All these options are
+deprecated in favor of @option{Metadata}.
+
+@item Metadata @var{key} @var{value}
+Set metadata value on the output stream.
+
+@item UseDefaults
+@item NoDefaults
+Control whether default codec options are used for the stream or not.
+Default is @var{UseDefaults} unless disabled globally.
+
+@item NoAudio
+@item NoVideo
+Suppress audio/video.
+
+@item AudioCodec @var{codec_name} (@emph{encoding,audio})
+Set audio codec.
+
+@item AudioBitRate @var{rate} (@emph{encoding,audio})
+Set bitrate for the audio stream in kbits per second.
+
+@item AudioChannels @var{n} (@emph{encoding,audio})
+Set number of audio channels.
+
+@item AudioSampleRate @var{n} (@emph{encoding,audio})
+Set sampling frequency for audio. When using low bitrates, you should
+lower this frequency to 22050 or 11025. The supported frequencies
+depend on the selected audio codec.
+
+@item AVOptionAudio [@var{codec}:]@var{option} @var{value} (@emph{encoding,audio})
+Set generic or private option for audio stream.
+Private option must be prefixed with codec name or codec must be defined before.
+
+@item AVPresetAudio @var{preset} (@emph{encoding,audio})
+Set preset for audio stream.
+
+@item VideoCodec @var{codec_name} (@emph{encoding,video})
+Set video codec.
+
+@item VideoBitRate @var{n} (@emph{encoding,video})
+Set bitrate for the video stream in kbits per second.
+
+@item VideoBitRateRange @var{range} (@emph{encoding,video})
+Set video bitrate range.
+
+A range must be specified in the form @var{minrate}-@var{maxrate}, and
+specifies the @option{minrate} and @option{maxrate} encoding options
+expressed in kbits per second.
+
+@item VideoBitRateRangeTolerance @var{n} (@emph{encoding,video})
+Set video bitrate tolerance in kbits per second.
+
+@item PixelFormat @var{pixel_format} (@emph{encoding,video})
+Set video pixel format.
+
+@item Debug @var{integer} (@emph{encoding,video})
+Set video @option{debug} encoding option.
+
+@item Strict @var{integer} (@emph{encoding,video})
+Set video @option{strict} encoding option.
+
+@item VideoBufferSize @var{n} (@emph{encoding,video})
+Set ratecontrol buffer size, expressed in KB.
+
+@item VideoFrameRate @var{n} (@emph{encoding,video})
+Set number of video frames per second.
+
+@item VideoSize (@emph{encoding,video})
+Set size of the video frame, must be an abbreviation or in the form
+@var{W}x@var{H}.  See @ref{video size syntax,,the Video size section
+in the ffmpeg-utils(1) manual,ffmpeg-utils}.
+
+Default value is @code{160x128}.
+
+@item VideoIntraOnly (@emph{encoding,video})
+Transmit only intra frames (useful for low bitrates, but kills frame rate).
+
+@item VideoGopSize @var{n} (@emph{encoding,video})
+If non-intra only, an intra frame is transmitted every VideoGopSize
+frames. Video synchronization can only begin at an intra frame.
+
+@item VideoTag @var{tag} (@emph{encoding,video})
+Set video tag.
+
+@item VideoHighQuality (@emph{encoding,video})
+@item Video4MotionVector (@emph{encoding,video})
+
+@item BitExact (@emph{encoding,video})
+Set bitexact encoding flag.
+
+@item IdctSimple (@emph{encoding,video})
+Set simple IDCT algorithm.
+
+@item Qscale @var{n} (@emph{encoding,video})
+Enable constant quality encoding, and set video qscale (quantization
+scale) value, expressed in @var{n} QP units.
+
+@item VideoQMin @var{n} (@emph{encoding,video})
+@item VideoQMax @var{n} (@emph{encoding,video})
+Set video qmin/qmax.
+
+@item VideoQDiff @var{integer} (@emph{encoding,video})
+Set video @option{qdiff} encoding option.
+
+@item LumiMask @var{float} (@emph{encoding,video})
+@item DarkMask @var{float} (@emph{encoding,video})
+Set @option{lumi_mask}/@option{dark_mask} encoding options.
+
+@item AVOptionVideo [@var{codec}:]@var{option} @var{value} (@emph{encoding,video})
+Set generic or private option for video stream.
+Private option must be prefixed with codec name or codec must be defined before.
+
+@item AVPresetVideo @var{preset} (@emph{encoding,video})
+Set preset for video stream.
+
+@var{preset} must be the path of a preset file.
+@end table
+
+@subsection Server status stream
+
+A server status stream is a special stream which is used to show
+statistics about the @command{ffserver} operations.
+
+It must be specified setting the option @option{Format} to
+@samp{status}.
+
+@section Redirect section
+
+A redirect section specifies where to redirect the requested URL to
+another page.
+
+A redirect section must be introduced by the line:
+@example
+<Redirect NAME>
+@end example
+
+where @var{NAME} is the name of the page which should be redirected.
+
+It only accepts the option @option{URL}, which specify the redirection
+URL.
+
+@chapter Stream examples
+
+@itemize
+@item
+Multipart JPEG
+@example
+<Stream test.mjpg>
+Feed feed1.ffm
+Format mpjpeg
+VideoFrameRate 2
+VideoIntraOnly
+NoAudio
+Strict -1
+</Stream>
+@end example
+
+@item
+Single JPEG
+@example
+<Stream test.jpg>
+Feed feed1.ffm
+Format jpeg
+VideoFrameRate 2
+VideoIntraOnly
+VideoSize 352x240
+NoAudio
+Strict -1
+</Stream>
+@end example
+
+@item
+Flash
+@example
+<Stream test.swf>
+Feed feed1.ffm
+Format swf
+VideoFrameRate 2
+VideoIntraOnly
+NoAudio
+</Stream>
+@end example
+
+@item
+ASF compatible
+@example
+<Stream test.asf>
+Feed feed1.ffm
+Format asf
+VideoFrameRate 15
+VideoSize 352x240
+VideoBitRate 256
+VideoBufferSize 40
+VideoGopSize 30
+AudioBitRate 64
+StartSendOnKey
+</Stream>
+@end example
+
+@item
+MP3 audio
+@example
+<Stream test.mp3>
+Feed feed1.ffm
+Format mp2
+AudioCodec mp3
+AudioBitRate 64
+AudioChannels 1
+AudioSampleRate 44100
+NoVideo
+</Stream>
+@end example
+
+@item
+Ogg Vorbis audio
+@example
+<Stream test.ogg>
+Feed feed1.ffm
+Metadata title "Stream title"
+AudioBitRate 64
+AudioChannels 2
+AudioSampleRate 44100
+NoVideo
+</Stream>
+@end example
+
+@item
+Real with audio only at 32 kbits
+@example
+<Stream test.ra>
+Feed feed1.ffm
+Format rm
+AudioBitRate 32
+NoVideo
+</Stream>
+@end example
+
+@item
+Real with audio and video at 64 kbits
+@example
+<Stream test.rm>
+Feed feed1.ffm
+Format rm
+AudioBitRate 32
+VideoBitRate 128
+VideoFrameRate 25
+VideoGopSize 25
+</Stream>
+@end example
+
+@item
+For stream coming from a file: you only need to set the input filename
+and optionally a new format.
+
+@example
+<Stream file.rm>
+File "/usr/local/httpd/htdocs/tlive.rm"
+NoAudio
+</Stream>
+@end example
+
+@example
+<Stream file.asf>
+File "/usr/local/httpd/htdocs/test.asf"
+NoAudio
+Metadata author "Me"
+Metadata copyright "Super MegaCorp"
+Metadata title "Test stream from disk"
+Metadata comment "Test comment"
+</Stream>
+@end example
+@end itemize
+
+@c man end
+
+@include config.texi
+@ifset config-all
+@ifset config-avutil
+@include utils.texi
+@end ifset
+@ifset config-avcodec
+@include codecs.texi
+@include bitstream_filters.texi
+@end ifset
+@ifset config-avformat
+@include formats.texi
+@include protocols.texi
+@end ifset
+@ifset config-avdevice
+@include devices.texi
+@end ifset
+@ifset config-swresample
+@include resampler.texi
+@end ifset
+@ifset config-swscale
+@include scaler.texi
+@end ifset
+@ifset config-avfilter
+@include filters.texi
+@end ifset
+@end ifset
+
+@chapter See Also
+
+@ifhtml
+@ifset config-all
+@url{ffserver.html,ffserver},
+@end ifset
+@ifset config-not-all
+@url{ffserver-all.html,ffserver-all},
+@end ifset
+the @file{doc/ffserver.conf} example,
+@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe},
+@url{ffmpeg-utils.html,ffmpeg-utils},
+@url{ffmpeg-scaler.html,ffmpeg-scaler},
+@url{ffmpeg-resampler.html,ffmpeg-resampler},
+@url{ffmpeg-codecs.html,ffmpeg-codecs},
+@url{ffmpeg-bitstream-filters.html,ffmpeg-bitstream-filters},
+@url{ffmpeg-formats.html,ffmpeg-formats},
+@url{ffmpeg-devices.html,ffmpeg-devices},
+@url{ffmpeg-protocols.html,ffmpeg-protocols},
+@url{ffmpeg-filters.html,ffmpeg-filters}
+@end ifhtml
+
+@ifnothtml
+@ifset config-all
+ffserver(1),
+@end ifset
+@ifset config-not-all
+ffserver-all(1),
+@end ifset
+the @file{doc/ffserver.conf} example, ffmpeg(1), ffplay(1), ffprobe(1),
+ffmpeg-utils(1), ffmpeg-scaler(1), ffmpeg-resampler(1),
+ffmpeg-codecs(1), ffmpeg-bitstream-filters(1), ffmpeg-formats(1),
+ffmpeg-devices(1), ffmpeg-protocols(1), ffmpeg-filters(1)
+@end ifnothtml
+
+@include authors.texi
+
+@ignore
+
+@setfilename ffserver
+@settitle ffserver video server
+
+@end ignore
+
+@bye

doc/fftools-common-opts.texi

@@ -42,20 +42,10 @@ streams, 'V' only matches video streams which are not attached pictures, video
 thumbnails or cover arts.  If @var{stream_index} is given, then it matches
 stream number @var{stream_index} of this type. Otherwise, it matches all
 streams of this type.
-@item p:@var{program_id}[:@var{stream_index}] or p:@var{program_id}[:@var{stream_type}[:@var{stream_index}]] or
-p:@var{program_id}:m:@var{key}[:@var{value}]
-In first version, if @var{stream_index} is given, then it matches the stream with number @var{stream_index}
+@item p:@var{program_id}[:@var{stream_index}]
+If @var{stream_index} is given, then it matches the stream with number @var{stream_index}
 in the program with the id @var{program_id}. Otherwise, it matches all streams in the
-program. In the second version, @var{stream_type} is one of following: 'v' for video, 'a' for audio, 's'
-for subtitle, 'd' for data. If @var{stream_index} is also given, then it matches
-stream number @var{stream_index} of this type in the program with the id @var{program_id}.
-Otherwise, if only @var{stream_type} is given, it matches all
-streams of this type in the program with the id @var{program_id}.
-In the third version matches streams in the program with the id @var{program_id} with the metadata
-tag @var{key} having the specified value. If
-@var{value} is not given, matches streams that contain the given tag with any
-value.
-
+program.
 @item #@var{stream_id} or i:@var{stream_id}
 Match the stream by stream id (e.g. PID in MPEG-TS container).
 @item m:@var{key}[:@var{value}]
@@ -178,24 +168,14 @@ The returned list cannot be assumed to be always complete.
 ffmpeg -sinks pulse,server=192.168.0.4
 @end example
 
-@item -loglevel [@var{flags}+]@var{loglevel} | -v [@var{flags}+]@var{loglevel}
-Set logging level and flags used by the library.
-
-The optional @var{flags} prefix can consist of the following values:
-@table @samp
-@item repeat
-Indicates that repeated log output should not be compressed to the first line
-and the "Last message repeated n times" line will be omitted.
-@item level
-Indicates that log output should add a @code{[level]} prefix to each message
-line. This can be used as an alternative to log coloring, e.g. when dumping the
-log to file.
-@end table
-Flags can also be used alone by adding a '+'/'-' prefix to set/reset a single
-flag without affecting other @var{flags} or changing @var{loglevel}. When
-setting both @var{flags} and @var{loglevel}, a '+' separator is expected
-between the last @var{flags} value and before @var{loglevel}.
-
+@item -loglevel [repeat+]@var{loglevel} | -v [repeat+]@var{loglevel}
+Set the logging level used by the library.
+Adding "repeat+" indicates that repeated log output should not be compressed
+to the first line and the "Last message repeated n times" line will be
+omitted. "repeat" can also be used alone.
+If "repeat" is used alone, and with no prior loglevel set, the default
+loglevel will be used. If multiple loglevel parameters are given, using
+'repeat' will not change the loglevel.
 @var{loglevel} is a string or a number containing one of the following values:
 @table @samp
 @item quiet, -8
@@ -221,17 +201,6 @@ Show everything, including debugging information.
 @item trace, 56
 @end table
 
-For example to enable repeated log output, add the @code{level} prefix, and set
-@var{loglevel} to @code{verbose}:
-@example
-ffmpeg -loglevel repeat+level+verbose -i input output
-@end example
-Another example that enables repeated log output without affecting current
-state of @code{level} prefix flag or @var{loglevel}:
-@example
-ffmpeg [...] -loglevel +repeat
-@end example
-
 By default the program logs to stderr. If coloring is supported by the
 terminal, colors are used to mark errors and warnings. Log coloring
 can be disabled setting the environment variable
@@ -346,6 +315,51 @@ Possible flags for this option are:
 @item k8
 @end table
 @end table
+
+@item -opencl_bench
+This option is used to benchmark all available OpenCL devices and print the
+results. This option is only available when FFmpeg has been compiled with
+@code{--enable-opencl}.
+
+When FFmpeg is configured with @code{--enable-opencl}, the options for the
+global OpenCL context are set via @option{-opencl_options}. See the
+"OpenCL Options" section in the ffmpeg-utils manual for the complete list of
+supported options. Amongst others, these options include the ability to select
+a specific platform and device to run the OpenCL code on. By default, FFmpeg
+will run on the first device of the first platform. While the options for the
+global OpenCL context provide flexibility to the user in selecting the OpenCL
+device of their choice, most users would probably want to select the fastest
+OpenCL device for their system.
+
+This option assists the selection of the most efficient configuration by
+identifying the appropriate device for the user's system. The built-in
+benchmark is run on all the OpenCL devices and the performance is measured for
+each device. The devices in the results list are sorted based on their
+performance with the fastest device listed first. The user can subsequently
+invoke @command{ffmpeg} using the device deemed most appropriate via
+@option{-opencl_options} to obtain the best performance for the OpenCL
+accelerated code.
+
+Typical usage to use the fastest OpenCL device involve the following steps.
+
+Run the command:
+@example
+ffmpeg -opencl_bench
+@end example
+Note down the platform ID (@var{pidx}) and device ID (@var{didx}) of the first
+i.e. fastest device in the list.
+Select the platform and device using the command:
+@example
+ffmpeg -opencl_options platform_idx=@var{pidx}:device_idx=@var{didx} ...
+@end example
+
+@item -opencl_options options (@emph{global})
+Set OpenCL environment options. This option is only available when
+FFmpeg has been compiled with @code{--enable-opencl}.
+
+@var{options} must be a list of @var{key}=@var{value} option pairs
+separated by ':'. See the ``OpenCL Options'' section in the
+ffmpeg-utils manual for the list of supported options.
 @end table
 
 @section AVOptions

doc/general.texi

@@ -17,14 +17,6 @@ for more formats. None of them are used by default, their use has to be
 explicitly requested by passing the appropriate flags to
 @command{./configure}.
 
-@section Alliance for Open Media libaom
-
-FFmpeg can make use of the libaom library for AV1 decoding.
-
-Go to @url{http://aomedia.org/} and follow the instructions for
-installing the library. Then pass @code{--enable-libaom} to configure to
-enable it.
-
 @section OpenJPEG
 
 FFmpeg can use the OpenJPEG libraries for encoding/decoding J2K videos.  Go to
@@ -93,24 +85,6 @@ Go to @url{http://www.twolame.org/} and follow the
 instructions for installing the library.
 Then pass @code{--enable-libtwolame} to configure to enable it.
 
-@section libcodec2 / codec2 general
-
-FFmpeg can make use of libcodec2 for codec2 encoding and decoding.
-There is currently no native decoder, so libcodec2 must be used for decoding.
-
-Go to @url{http://freedv.org/}, download "Codec 2 source archive".
-Build and install using CMake. Debian users can install the libcodec2-dev package instead.
-Once libcodec2 is installed you can pass @code{--enable-libcodec2} to configure to enable it.
-
-The easiest way to use codec2 is with .c2 files, since they contain the mode information required for decoding.
-To encode such a file, use a .c2 file extension and give the libcodec2 encoder the -mode option:
-@code{ffmpeg -i input.wav -mode 700C output.c2}.
-Playback is as simple as @code{ffplay output.c2}.
-For a list of supported modes, run @code{ffmpeg -h encoder=libcodec2}.
-Raw codec2 files are also supported.
-To make sense of them the mode in use needs to be specified as a format option:
-@code{ffmpeg -f codec2raw -mode 1300 -i input.raw output.wav}.
-
 @section libvpx
 
 FFmpeg can make use of the libvpx library for VP8/VP9 encoding.
@@ -251,18 +225,6 @@ The dispatcher is open source and can be downloaded from
 with the @code{--enable-libmfx} option and @code{pkg-config} needs to be able to
 locate the dispatcher's @code{.pc} files.
 
-@section AMD VCE
-
-FFmpeg can use the AMD Advanced Media Framework library for accelerated H.264
-and HEVC encoding on VCE enabled hardware under Windows.
-
-To enable support you must obtain the AMF framework header files from
-@url{https://github.com/GPUOpen-LibrariesAndSDKs/AMF.git}.
-
-Create an @code{AMF/} directory in the system include path.
-Copy the contents of @code{AMF/amf/public/include/} into that directory.
-Then configure FFmpeg with @code{--enable-amf}.
-
 
 @chapter Supported File Formats, Codecs or Features
 
@@ -328,10 +290,6 @@ library:
 @item BRSTM                     @tab   @tab X
     @tab Audio format used on the Nintendo Wii.
 @item BWF                       @tab X @tab X
-@item codec2 (raw)              @tab X @tab X
-    @tab Must be given -mode format option to decode correctly.
-@item codec2 (.c2 files)        @tab X @tab X
-    @tab Contains header with version and mode info, simplifying playback.
 @item CRI ADX                   @tab X @tab X
     @tab Audio-only format used in console video games.
 @item Discworld II BMV          @tab   @tab X
@@ -407,7 +365,6 @@ library:
 @item Interplay MVE             @tab   @tab X
     @tab Format used in various Interplay computer games.
 @item Iterated Systems ClearVideo @tab     @tab  X
-    @tab I-frames only
 @item IV8                       @tab   @tab X
     @tab A format generated by IndigoVision 8000 video server.
 @item IVF (On2)                 @tab X @tab X
@@ -467,7 +424,6 @@ library:
 @item NC camera feed            @tab   @tab X
     @tab NC (AVIP NC4600) camera streams
 @item NIST SPeech HEader REsources @tab   @tab X
-@item Computerized Speech Lab NSP @tab   @tab X
 @item NTT TwinVQ (VQF)          @tab   @tab X
     @tab Nippon Telegraph and Telephone Corporation TwinVQ.
 @item Nullsoft Streaming Video  @tab   @tab X
@@ -482,10 +438,6 @@ library:
 @item QCP                       @tab   @tab X
 @item raw ADTS (AAC)            @tab X @tab X
 @item raw AC-3                  @tab X @tab X
-@item raw AMR-NB                @tab   @tab X
-@item raw AMR-WB                @tab   @tab X
-@item raw aptX                  @tab X @tab X
-@item raw aptX HD               @tab X @tab X
 @item raw Chinese AVS video     @tab X @tab X
 @item raw CRI ADX               @tab X @tab X
 @item raw Dirac                 @tab X @tab X
@@ -509,7 +461,6 @@ library:
 @item raw NULL                  @tab X @tab
 @item raw video                 @tab X @tab X
 @item raw id RoQ                @tab X @tab
-@item raw SBC                   @tab X @tab X
 @item raw Shorten               @tab   @tab X
 @item raw TAK                   @tab   @tab X
 @item raw TrueHD                @tab X @tab X
@@ -559,7 +510,7 @@ library:
 @item SAP                       @tab X @tab X
 @item SBG                       @tab   @tab X
 @item SDP                       @tab   @tab X
-@item Sega FILM/CPK             @tab X @tab X
+@item Sega FILM/CPK             @tab   @tab X
     @tab Used in many Sega Saturn console games.
 @item Silicon Graphics Movie    @tab   @tab X
 @item Sierra SOL                @tab   @tab X
@@ -727,8 +678,6 @@ following image formats are supported:
 @item Autodesk Animator Flic video  @tab     @tab  X
 @item Autodesk RLE           @tab     @tab  X
     @tab fourcc: AASC
-@item AV1                    @tab     @tab  E
-    @tab Supported through external library libaom
 @item Avid 1:1 10-bit RGB Packer  @tab  X  @tab  X
     @tab fourcc: AVrp
 @item AVS (Audio Video Standard) video  @tab     @tab  X
@@ -843,7 +792,7 @@ following image formats are supported:
 @item LucasArts SANM/Smush   @tab     @tab  X
     @tab Used in LucasArts games / SMUSH animations.
 @item lossless MJPEG         @tab  X  @tab  X
-@item MagicYUV Video         @tab  X  @tab  X
+@item MagicYUV Video         @tab     @tab  X
 @item Mandsoft Screen Capture Codec  @tab     @tab  X
 @item Microsoft ATC Screen   @tab     @tab  X
     @tab Also known as Microsoft Screen 3.
@@ -1041,10 +990,6 @@ following image formats are supported:
 @item Amazing Studio PAF Audio @tab     @tab  X
 @item Apple lossless audio   @tab  X  @tab  X
     @tab QuickTime fourcc 'alac'
-@item aptX                   @tab  X  @tab  X
-    @tab Used in Bluetooth A2DP
-@item aptX HD                @tab  X  @tab  X
-    @tab Used in Bluetooth A2DP
 @item ATRAC1                 @tab     @tab  X
 @item ATRAC3                 @tab     @tab  X
 @item ATRAC3+                @tab     @tab  X
@@ -1052,8 +997,6 @@ following image formats are supported:
     @tab Used in Bink and Smacker files in many games.
 @item CELT                   @tab     @tab  E
     @tab decoding supported through external library libcelt
-@item codec2                 @tab  E  @tab  E
-    @tab en/decoding supported through external library libcodec2
 @item Delphine Software International CIN audio  @tab     @tab  X
     @tab Codec used in Delphine Software International games.
 @item Digital Speech Standard - Standard Play mode (DSS SP) @tab     @tab  X
@@ -1152,8 +1095,6 @@ following image formats are supported:
     @tab Real low bitrate AC-3 codec
 @item RealAudio Lossless     @tab     @tab  X
 @item RealAudio SIPR / ACELP.NET @tab     @tab  X
-@item SBC (low-complexity subband codec) @tab  X  @tab  X
-    @tab Used in Bluetooth A2DP
 @item Shorten                @tab     @tab  X
 @item Sierra VMD audio       @tab     @tab  X
     @tab Used in Sierra VMD files.

doc/indevs.texi

@@ -63,46 +63,6 @@ Set the number of channels. Default is 2.
 
 @end table
 
-@section android_camera
-
-Android camera input device.
-
-This input devices uses the Android Camera2 NDK API which is
-available on devices with API level 24+. The availability of
-android_camera is autodetected during configuration.
-
-This device allows capturing from all cameras on an Android device,
-which are integrated into the Camera2 NDK API.
-
-The available cameras are enumerated internally and can be selected
-with the @var{camera_index} parameter. The input file string is
-discarded.
-
-Generally the back facing camera has index 0 while the front facing
-camera has index 1.
-
-@subsection Options
-
-@table @option
-
-@item video_size
-Set the video size given as a string such as 640x480 or hd720.
-Falls back to the first available configuration reported by
-Android if requested video size is not available or by default.
-
-@item framerate
-Set the video framerate.
-Falls back to the first available configuration reported by
-Android if requested framerate is not available or by default (-1).
-
-@item camera_index
-Set the index of the camera to use. Default is 0.
-
-@item input_queue_size
-Set the maximum number of frames to buffer. Default is 5.
-
-@end table
-
 @section avfoundation
 
 AVFoundation input device.
@@ -278,8 +238,6 @@ This sets the input video format to the format given by the FourCC. To see
 the supported values of your device(s) use @option{list_formats}.
 Note that there is a FourCC @option{'pal '} that can also be used
 as @option{pal} (3 letters).
-Default behavior is autodetection of the input video format, if the hardware
-supports it.
 
 @item bm_v210
 This is a deprecated option, you can use @option{raw_format} instead.
@@ -338,13 +296,11 @@ Sets the audio input source. Must be @samp{unset}, @samp{embedded},
 
 @item video_pts
 Sets the video packet timestamp source. Must be @samp{video}, @samp{audio},
-@samp{reference}, @samp{wallclock} or @samp{abs_wallclock}.
-Defaults to @samp{video}.
+@samp{reference} or @samp{wallclock}. Defaults to @samp{video}.
 
 @item audio_pts
 Sets the audio packet timestamp source. Must be @samp{video}, @samp{audio},
-@samp{reference}, @samp{wallclock} or @samp{abs_wallclock}.
-Defaults to @samp{audio}.
+@samp{reference} or @samp{wallclock}. Defaults to @samp{audio}.
 
 @item draw_bars
 If set to @samp{true}, color bars are drawn in the event of a signal loss.
@@ -355,15 +311,6 @@ Sets maximum input buffer size in bytes. If the buffering reaches this value,
 incoming frames will be dropped.
 Defaults to @samp{1073741824}.
 
-@item audio_depth
-Sets the audio sample bit depth. Must be @samp{16} or @samp{32}.
-Defaults to @samp{16}.
-
-@item decklink_copyts
-If set to @option{true}, timestamps are forwarded as they are without removing
-the initial offset.
-Defaults to @option{false}.
-
 @end table
 
 @subsection Examples

doc/issue_tracker.txt

@@ -193,6 +193,9 @@ ffplay
 ffprobe
     issues in or related to ffprobe.c
 
+ffserver
+    issues in or related to ffserver.c
+
 postproc
     issues in libpostproc/*
 

doc/libav-merge.txt

@@ -94,13 +94,13 @@ Stuff that didn't reach the codebase:
   - a853388d2 hevc: change the stride of the MC buffer to be in bytes instead of elements
   - 0cef06df0 checkasm: add HEVC MC tests
   - e7078e842 hevcdsp: add x86 SIMD for MC
-  - 7993ec19a hevc: Add hevc_get_pixel_4/8/12/16/24/32/48/64
+- VAAPI VP8 decode hwaccel (currently under review: http://ffmpeg.org/pipermail/ffmpeg-devel/2017-February/thread.html#207348)
+- Removal of the custom atomic API (5cc0057f49, see http://ffmpeg.org/pipermail/ffmpeg-devel/2017-March/209003.html)
 - new bitstream reader (see http://ffmpeg.org/pipermail/ffmpeg-devel/2017-April/209609.html)
+- use of the bsf instead of our parser for vp9 superframes (see fa1749dd34)
 - use av_cpu_max_align() instead of hardcoding alignment requirements (see https://ffmpeg.org/pipermail/ffmpeg-devel/2017-September/215834.html)
   - f44ec22e0 lavc: use av_cpu_max_align() instead of hardcoding alignment requirements
   - 4de220d2e frame: allow align=0 (meaning automatic) for av_frame_get_buffer()
-- Support recovery from an already present HLS playlist (see 16cb06bb30)
-- Remove all output devices (see 8e7e042d41, 8d3db95f20, 6ce13070bd, d46cd24986 and https://ffmpeg.org/pipermail/ffmpeg-devel/2017-September/216904.html)
 
 Collateral damage that needs work locally:
 ------------------------------------------

doc/libavcodec.texi

@@ -26,13 +26,13 @@ implementing robust and fast codecs as well as for experimentation.
 @chapter See Also
 
 @ifhtml
-@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe},
+@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe}, @url{ffserver.html,ffserver},
 @url{ffmpeg-codecs.html,ffmpeg-codecs}, @url{ffmpeg-bitstream-filters.html,bitstream-filters},
 @url{libavutil.html,libavutil}
 @end ifhtml
 
 @ifnothtml
-ffmpeg(1), ffplay(1), ffprobe(1),
+ffmpeg(1), ffplay(1), ffprobe(1), ffserver(1),
 ffmpeg-codecs(1), ffmpeg-bitstream-filters(1),
 libavutil(3)
 @end ifnothtml

doc/libavdevice.texi

@@ -23,13 +23,13 @@ VfW, DShow, and ALSA.
 @chapter See Also
 
 @ifhtml
-@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe},
+@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe}, @url{ffserver.html,ffserver},
 @url{ffmpeg-devices.html,ffmpeg-devices},
 @url{libavutil.html,libavutil}, @url{libavcodec.html,libavcodec}, @url{libavformat.html,libavformat}
 @end ifhtml
 
 @ifnothtml
-ffmpeg(1), ffplay(1), ffprobe(1),
+ffmpeg(1), ffplay(1), ffprobe(1), ffserver(1),
 ffmpeg-devices(1),
 libavutil(3), libavcodec(3), libavformat(3)
 @end ifnothtml

doc/libavfilter.texi

@@ -21,14 +21,14 @@ framework containing several filters, sources and sinks.
 @chapter See Also
 
 @ifhtml
-@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe},
+@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe}, @url{ffserver.html,ffserver},
 @url{ffmpeg-filters.html,ffmpeg-filters},
 @url{libavutil.html,libavutil}, @url{libswscale.html,libswscale}, @url{libswresample.html,libswresample},
 @url{libavcodec.html,libavcodec}, @url{libavformat.html,libavformat}, @url{libavdevice.html,libavdevice}
 @end ifhtml
 
 @ifnothtml
-ffmpeg(1), ffplay(1), ffprobe(1),
+ffmpeg(1), ffplay(1), ffprobe(1), ffserver(1),
 ffmpeg-filters(1),
 libavutil(3), libswscale(3), libswresample(3), libavcodec(3), libavformat(3), libavdevice(3)
 @end ifnothtml

doc/libavformat.texi

@@ -26,13 +26,13 @@ resource.
 @chapter See Also
 
 @ifhtml
-@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe},
+@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe}, @url{ffserver.html,ffserver},
 @url{ffmpeg-formats.html,ffmpeg-formats}, @url{ffmpeg-protocols.html,ffmpeg-protocols},
 @url{libavutil.html,libavutil}, @url{libavcodec.html,libavcodec}
 @end ifhtml
 
 @ifnothtml
-ffmpeg(1), ffplay(1), ffprobe(1),
+ffmpeg(1), ffplay(1), ffprobe(1), ffserver(1),
 ffmpeg-formats(1), ffmpeg-protocols(1),
 libavutil(3), libavcodec(3)
 @end ifnothtml

doc/libavutil.texi

@@ -42,12 +42,12 @@ It should avoid useless features that almost no one needs.
 @chapter See Also
 
 @ifhtml
-@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe},
+@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe}, @url{ffserver.html,ffserver},
 @url{ffmpeg-utils.html,ffmpeg-utils}
 @end ifhtml
 
 @ifnothtml
-ffmpeg(1), ffplay(1), ffprobe(1),
+ffmpeg(1), ffplay(1), ffprobe(1), ffserver(1),
 ffmpeg-utils(1)
 @end ifnothtml
 

doc/libswresample.texi

@@ -48,13 +48,13 @@ enabled through dedicated options.
 @chapter See Also
 
 @ifhtml
-@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe},
+@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe}, @url{ffserver.html,ffserver},
 @url{ffmpeg-resampler.html,ffmpeg-resampler},
 @url{libavutil.html,libavutil}
 @end ifhtml
 
 @ifnothtml
-ffmpeg(1), ffplay(1), ffprobe(1),
+ffmpeg(1), ffplay(1), ffprobe(1), ffserver(1),
 ffmpeg-resampler(1),
 libavutil(3)
 @end ifnothtml

doc/libswscale.texi

@@ -41,13 +41,13 @@ colorspaces differ.
 @chapter See Also
 
 @ifhtml
-@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe},
+@url{ffmpeg.html,ffmpeg}, @url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe}, @url{ffserver.html,ffserver},
 @url{ffmpeg-scaler.html,ffmpeg-scaler},
 @url{libavutil.html,libavutil}
 @end ifhtml
 
 @ifnothtml
-ffmpeg(1), ffplay(1), ffprobe(1),
+ffmpeg(1), ffplay(1), ffprobe(1), ffserver(1),
 ffmpeg-scaler(1),
 libavutil(3)
 @end ifnothtml

doc/mailing-list-faq.texi

@@ -27,7 +27,8 @@ for examples.
 @item
 @url{https://lists.ffmpeg.org/mailman/listinfo/ffmpeg-user/, ffmpeg-user}:
 For questions involving unscripted usage or compilation of the FFmpeg
-command-line tools (@command{ffmpeg}, @command{ffprobe}, @command{ffplay}).
+command-line tools (@command{ffmpeg}, @command{ffprobe}, @command{ffplay},
+@command{ffserver}).
 
 @item
 @url{https://lists.ffmpeg.org/mailman/listinfo/libav-user/, libav-user}:

doc/muxers.texi

@@ -247,16 +247,6 @@ DASH-templated name to used for the initialization segment. Default is "init-str
 DASH-templated name to used for the media segments. Default is "chunk-stream$RepresentationID$-$Number%05d$.m4s"
 @item -utc_timing_url @var{utc_url}
 URL of the page that will return the UTC timestamp in ISO format. Example: "https://time.akamai.com/?iso"
-@item -http_user_agent @var{user_agent}
-Override User-Agent field in HTTP header. Applicable only for HTTP output.
-@item -http_persistent @var{http_persistent}
-Use persistent HTTP connections. Applicable only for HTTP output.
-@item -hls_playlist @var{hls_playlist}
-Generate HLS playlist files as well. The master playlist is generated with the filename master.m3u8.
-One media playlist file is generated for each stream with filenames media_0.m3u8, media_1.m3u8, etc.
-@item -streaming @var{streaming}
-Enable (1) or disable (0) chunk streaming mode of output. In chunk streaming
-mode, each frame will be a moof fragment which forms a chunk.
 @item -adaptation_sets @var{adaptation_sets}
 Assign streams to AdaptationSets. Syntax is "id=x,streams=a,b,c id=y,streams=d,e" with x and y being the IDs
 of the adaptation sets and a,b,c,d and e are the indices of the mapped streams.
@@ -264,8 +254,6 @@ of the adaptation sets and a,b,c,d and e are the indices of the mapped streams.
 To map all video (or audio) streams to an AdaptationSet, "v" (or "a") can be used as stream identifier instead of IDs.
 
 When no assignment is defined, this defaults to an AdaptationSet for each stream.
-@item -timeout @var{timeout}
-Set timeout for socket I/O operations. Applicable only for HTTP output.
 @end table
 
 @anchor{framecrc}
@@ -480,12 +468,9 @@ By default, the muxer creates a file for each segment produced. These files
 have the same name as the playlist, followed by a sequential number and a
 .ts extension.
 
-Make sure to require a closed GOP when encoding and to set the GOP
-size to fit your segment time constraint.
-
 For example, to convert an input file with @command{ffmpeg}:
 @example
-ffmpeg -i in.mkv -c:v h264 -flags +cgop -g 30 -hls_time 1 out.m3u8
+ffmpeg -i in.nut out.m3u8
 @end example
 This example will produce the playlist, @file{out.m3u8}, and segment files:
 @file{out0.ts}, @file{out1.ts}, @file{out2.ts}, etc.
@@ -513,12 +498,6 @@ Segment will be cut on the next key frame after this time has passed.
 Set the maximum number of playlist entries. If set to 0 the list file
 will contain all the segments. Default value is 5.
 
-@item hls_delete_threshold @var{size}
-Set the number of unreferenced segments to keep on disk before @code{hls_flags delete_segments}
-deletes them. Increase this to allow continue clients to download segments which
-were recently referenced in the playlist. Default value is 1, meaning segments older than
-@code{hls_list_size+1} will be deleted.
-
 @item hls_ts_options @var{options_list}
 Set output format options using a :-separated list of key=value
 parameters. Values containing @code{:} special characters must be
@@ -588,31 +567,6 @@ Should a relative path be specified, the path of the created segment
 files will be relative to the current working directory.
 When use_localtime_mkdir is set, the whole expanded value of @var{filename} will be written into the m3u8 segment list.
 
-When @code{var_stream_map} is set with two or more variant streams, the
-@var{filename} pattern must contain the string "%v", this string specifies
-the position of variant stream index in the generated segment file names.
-@example
-ffmpeg -i in.ts -b:v:0 1000k -b:v:1 256k -b:a:0 64k -b:a:1 32k \
-  -map 0:v -map 0:a -map 0:v -map 0:a -f hls -var_stream_map "v:0,a:0 v:1,a:1" \
-  -hls_segment_filename 'file_%v_%03d.ts' out_%v.m3u8
-@end example
-This example will produce the playlists segment file sets:
-@file{file_0_000.ts}, @file{file_0_001.ts}, @file{file_0_002.ts}, etc. and
-@file{file_1_000.ts}, @file{file_1_001.ts}, @file{file_1_002.ts}, etc.
-
-The string "%v" may be present in the filename or in the last directory name
-containing the file. If the string is present in the directory name, then
-sub-directories are created after expanding the directory name pattern. This
-enables creation of segments corresponding to different variant streams in
-subdirectories.
-@example
-ffmpeg -i in.ts -b:v:0 1000k -b:v:1 256k -b:a:0 64k -b:a:1 32k \
-  -map 0:v -map 0:a -map 0:v -map 0:a -f hls -var_stream_map "v:0,a:0 v:1,a:1" \
-  -hls_segment_filename 'vs%v/file_%03d.ts' vs%v/out.m3u8
-@end example
-This example will produce the playlists segment file sets:
-@file{vs0/file_000.ts}, @file{vs0/file_001.ts}, @file{vs0/file_002.ts}, etc. and
-@file{vs1/file_000.ts}, @file{vs1/file_001.ts}, @file{vs1/file_002.ts}, etc.
 
 @item use_localtime
 Use strftime() on @var{filename} to expand the segment filename with localtime.
@@ -739,15 +693,6 @@ the fmp4 files is used in hls after version 7.
 @item hls_fmp4_init_filename @var{filename}
 set filename to the fragment files header file, default filename is @file{init.mp4}.
 
-When @code{var_stream_map} is set with two or more variant streams, the
-@var{filename} pattern must contain the string "%v", this string specifies
-the position of variant stream index in the generated init file names.
-The string "%v" may be present in the filename or in the last directory name
-containing the file. If the string is present in the directory name, then
-sub-directories are created after expanding the directory name pattern. This
-enables creation of init files corresponding to different variant streams in
-subdirectories.
-
 @item hls_flags @var{flags}
 Possible values:
 
@@ -787,10 +732,6 @@ The file specified by @code{hls_key_info_file} will be checked periodically and
 detect updates to the encryption info. Be sure to replace this file atomically,
 including the file containing the AES encryption key.
 
-@item independent_segments
-Add the @code{#EXT-X-INDEPENDENT-SEGMENTS} to playlists that has video segments
-and when all the segments of that playlist are guaranteed to start with a Key frame.
-
 @item split_by_time
 Allow segments to start on frames other than keyframes. This improves
 behavior on some players when the time between keyframes is inconsistent,
@@ -853,128 +794,6 @@ files.
 @item http_user_agent
 Override User-Agent field in HTTP header. Applicable only for HTTP output.
 
-@item var_stream_map
-Map string which specifies how to group the audio, video and subtitle streams
-into different variant streams. The variant stream groups are separated
-by space.
-Expected string format is like this "a:0,v:0 a:1,v:1 ....". Here a:, v:, s: are
-the keys to specify audio, video and subtitle streams respectively.
-Allowed values are 0 to 9 (limited just based on practical usage).
-
-When there are two or more variant streams, the output filename pattern must
-contain the string "%v", this string specifies the position of variant stream
-index in the output media playlist filenames. The string "%v" may be present in
-the filename or in the last directory name containing the file. If the string is
-present in the directory name, then sub-directories are created after expanding
-the directory name pattern. This enables creation of variant streams in
-subdirectories.
-
-@example
-ffmpeg -re -i in.ts -b:v:0 1000k -b:v:1 256k -b:a:0 64k -b:a:1 32k \
-  -map 0:v -map 0:a -map 0:v -map 0:a -f hls -var_stream_map "v:0,a:0 v:1,a:1" \
-  http://example.com/live/out_%v.m3u8
-@end example
-This example creates two hls variant streams. The first variant stream will
-contain video stream of bitrate 1000k and audio stream of bitrate 64k and the
-second variant stream will contain video stream of bitrate 256k and audio
-stream of bitrate 32k. Here, two media playlist with file names out_0.m3u8 and
-out_1.m3u8 will be created.
-@example
-ffmpeg -re -i in.ts -b:v:0 1000k -b:v:1 256k -b:a:0 64k \
-  -map 0:v -map 0:a -map 0:v -f hls -var_stream_map "v:0 a:0 v:1" \
-  http://example.com/live/out_%v.m3u8
-@end example
-This example creates three hls variant streams. The first variant stream will
-be a video only stream with video bitrate 1000k, the second variant stream will
-be an audio only stream with bitrate 64k and the third variant stream will be a
-video only stream with bitrate 256k. Here, three media playlist with file names
-out_0.m3u8, out_1.m3u8 and out_2.m3u8 will be created.
-@example
-ffmpeg -re -i in.ts -b:v:0 1000k -b:v:1 256k -b:a:0 64k -b:a:1 32k \
-  -map 0:v -map 0:a -map 0:v -map 0:a -f hls -var_stream_map "v:0,a:0 v:1,a:1" \
-  http://example.com/live/vs_%v/out.m3u8
-@end example
-This example creates the variant streams in subdirectories. Here, the first
-media playlist is created at @file{http://example.com/live/vs_0/out.m3u8} and
-the second one at @file{http://example.com/live/vs_1/out.m3u8}.
-@example
-ffmpeg -re -i in.ts -b:a:0 32k -b:a:1 64k -b:v:0 1000k -b:v:1 3000k  \
-  -map 0:a -map 0:a -map 0:v -map 0:v -f hls \
-  -var_stream_map "a:0,agroup:aud_low a:1,agroup:aud_high v:0,agroup:aud_low v:1,agroup:aud_high" \
-  -master_pl_name master.m3u8 \
-  http://example.com/live/out_%v.m3u8
-@end example
-This example creates two audio only and two video only variant streams. In
-addition to the #EXT-X-STREAM-INF tag for each variant stream in the master
-playlist, #EXT-X-MEDIA tag is also added for the two audio only variant streams
-and they are mapped to the two video only variant streams with audio group names
-'aud_low' and 'aud_high'.
-
-By default, a single hls variant containing all the encoded streams is created.
-
-@item cc_stream_map
-Map string which specifies different closed captions groups and their
-attributes. The closed captions stream groups are separated by space.
-Expected string format is like this
-"ccgroup:<group name>,instreamid:<INSTREAM-ID>,language:<language code> ....".
-'ccgroup' and 'instreamid' are mandatory attributes. 'language' is an optional
-attribute.
-The closed captions groups configured using this option are mapped to different
-variant streams by providing the same 'ccgroup' name in the
-@code{var_stream_map} string. If @code{var_stream_map} is not set, then the
-first available ccgroup in @code{cc_stream_map} is mapped to the output variant
-stream. The examples for these two use cases are given below.
-
-@example
-ffmpeg -re -i in.ts -b:v 1000k -b:a 64k -a53cc 1 -f hls \
-  -cc_stream_map "ccgroup:cc,instreamid:CC1,language:en" \
-  -master_pl_name master.m3u8 \
-  http://example.com/live/out.m3u8
-@end example
-This example adds @code{#EXT-X-MEDIA} tag with @code{TYPE=CLOSED-CAPTIONS} in
-the master playlist with group name 'cc', langauge 'en' (english) and
-INSTREAM-ID 'CC1'. Also, it adds @code{CLOSED-CAPTIONS} attribute with group
-name 'cc' for the output variant stream.
-@example
-ffmpeg -re -i in.ts -b:v:0 1000k -b:v:1 256k -b:a:0 64k -b:a:1 32k \
-  -a53cc:0 1 -a53cc:1 1\
-  -map 0:v -map 0:a -map 0:v -map 0:a -f hls \
-  -cc_stream_map "ccgroup:cc,instreamid:CC1,language:en ccgroup:cc,instreamid:CC2,language:sp" \
-  -var_stream_map "v:0,a:0,ccgroup:cc v:1,a:1,ccgroup:cc" \
-  -master_pl_name master.m3u8 \
-  http://example.com/live/out_%v.m3u8
-@end example
-This example adds two @code{#EXT-X-MEDIA} tags with @code{TYPE=CLOSED-CAPTIONS} in
-the master playlist for the INSTREAM-IDs 'CC1' and 'CC2'. Also, it adds
-@code{CLOSED-CAPTIONS} attribute with group name 'cc' for the two output variant
-streams.
-
-@item master_pl_name
-Create HLS master playlist with the given name.
-
-@example
-ffmpeg -re -i in.ts -f hls -master_pl_name master.m3u8 http://example.com/live/out.m3u8
-@end example
-This example creates HLS master playlist with name master.m3u8 and it is
-published at http://example.com/live/
-
-@item master_pl_publish_rate
-Publish master play list repeatedly every after specified number of segment intervals.
-
-@example
-ffmpeg -re -i in.ts -f hls -master_pl_name master.m3u8 \
--hls_time 2 -master_pl_publish_rate 30 http://example.com/live/out.m3u8
-@end example
-
-This example creates HLS master playlist with name master.m3u8 and keep
-publishing it repeatedly every after 30 segments i.e. every after 60s.
-
-@item http_persistent
-Use persistent HTTP connections. Applicable only for HTTP output.
-
-@item timeout
-Set timeout for socket I/O operations. Applicable only for HTTP output.
-
 @end table
 
 @anchor{ico}
@@ -1075,18 +894,9 @@ can be used:
 ffmpeg -f v4l2 -r 1 -i /dev/video0 -f image2 -strftime 1 "%Y-%m-%d_%H-%M-%S.jpg"
 @end example
 
-You can set the file name with current frame's PTS:
-@example
-ffmpeg -f v4l2 -r 1 -i /dev/video0 -copyts -f image2 -frame_pts true %d.jpg"
-@end example
-
 @subsection Options
 
 @table @option
-@item frame_pts
-If set to 1, expand the filename with pts from pkt->pts.
-Default value is 0.
-
 @item start_number
 Start the sequence from the specified number. Default value is 1.
 
@@ -1839,9 +1649,6 @@ segment would usually span. Otherwise, the segment will be filled with the next
 packet written. Defaults to @code{0}.
 @end table
 
-Make sure to require a closed GOP when encoding and to set the GOP
-size to fit your segment time constraint.
-
 @subsection Examples
 
 @itemize
@@ -1850,7 +1657,7 @@ Remux the content of file @file{in.mkv} to a list of segments
 @file{out-000.nut}, @file{out-001.nut}, etc., and write the list of
 generated segments to @file{out.list}:
 @example
-ffmpeg -i in.mkv -codec hevc -flags +cgop -g 60 -map 0 -f segment -segment_list out.list out%03d.nut
+ffmpeg -i in.mkv -codec copy -map 0 -f segment -segment_list out.list out%03d.nut
 @end example
 
 @item

doc/protocols.texi

@@ -296,9 +296,6 @@ Use persistent connections if set to 1, default is 0.
 @item post_data
 Set custom HTTP post data.
 
-@item referer
-Set the Referer header. Include 'Referer: URL' header in HTTP request.
-
 @item user_agent
 Override the User-Agent header. If not specified the protocol will use a
 string describing the libavformat build. ("Lavf/<version>")
@@ -324,9 +321,6 @@ Sets the maximum delay in seconds after which to give up reconnecting
 @item mime_type
 Export the MIME type.
 
-@item http_version
-Exports the HTTP response version number. Usually "1.0" or "1.1".
-
 @item icy
 If set to 1 request ICY (SHOUTcast) metadata from the server. If the server
 supports this, the metadata has to be retrieved by the application by reading
@@ -369,7 +363,7 @@ If set to 1 enables experimental HTTP server. This can be used to send data when
 used as an output option, or read data from a client with HTTP POST when used as
 an input option.
 If set to 2 enables experimental multi-client HTTP server. This is not yet implemented
-in ffmpeg.c and thus must not be used as a command line option.
+in ffmpeg.c or ffserver.c and thus must not be used as a command line option.
 @example
 # Server side (sending):
 ffmpeg -i somefile.ogg -c copy -listen 1 -f ogg http://@var{server}:@var{port}
@@ -1155,146 +1149,6 @@ If set to any value, listen for an incoming connection. Outgoing connection is d
 Set the maximum number of streams. By default no limit is set.
 @end table
 
-@section srt
-
-Haivision Secure Reliable Transport Protocol via libsrt.
-
-The supported syntax for a SRT URL is:
-@example
-srt://@var{hostname}:@var{port}[?@var{options}]
-@end example
-
-@var{options} contains a list of &-separated options of the form
-@var{key}=@var{val}.
-
-or
-
-@example
-@var{options} srt://@var{hostname}:@var{port}
-@end example
-
-@var{options} contains a list of '-@var{key} @var{val}'
-options.
-
-This protocol accepts the following options.
-
-@table @option
-@item connect_timeout
-Connection timeout; SRT cannot connect for RTT > 1500 msec
-(2 handshake exchanges) with the default connect timeout of
-3 seconds. This option applies to the caller and rendezvous
-connection modes. The connect timeout is 10 times the value
-set for the rendezvous mode (which can be used as a
-workaround for this connection problem with earlier versions).
-
-@item ffs=@var{bytes}
-Flight Flag Size (Window Size), in bytes. FFS is actually an
-internal parameter and you should set it to not less than
-@option{recv_buffer_size} and @option{mss}. The default value
-is relatively large, therefore unless you set a very large receiver buffer,
-you do not need to change this option. Default value is 25600.
-
-@item inputbw=@var{bytes/seconds}
-Sender nominal input rate, in bytes per seconds. Used along with
-@option{oheadbw}, when @option{maxbw} is set to relative (0), to
-calculate maximum sending rate when recovery packets are sent
-along with the main media stream:
-@option{inputbw} * (100 + @option{oheadbw}) / 100
-if @option{inputbw} is not set while @option{maxbw} is set to
-relative (0), the actual input rate is evaluated inside
-the library. Default value is 0.
-
-@item iptos=@var{tos}
-IP Type of Service. Applies to sender only. Default value is 0xB8.
-
-@item ipttl=@var{ttl}
-IP Time To Live. Applies to sender only. Default value is 64.
-
-@item listen_timeout
-Set socket listen timeout.
-
-@item maxbw=@var{bytes/seconds}
-Maximum sending bandwidth, in bytes per seconds.
--1 infinite (CSRTCC limit is 30mbps)
-0 relative to input rate (see @option{inputbw})
->0 absolute limit value
-Default value is 0 (relative)
-
-@item mode=@var{caller|listener|rendezvous}
-Connection mode.
-@option{caller} opens client connection.
-@option{listener} starts server to listen for incoming connections.
-@option{rendezvous} use Rendez-Vous connection mode.
-Default value is caller.
-
-@item mss=@var{bytes}
-Maximum Segment Size, in bytes. Used for buffer allocation
-and rate calculation using a packet counter assuming fully
-filled packets. The smallest MSS between the peers is
-used. This is 1500 by default in the overall internet.
-This is the maximum size of the UDP packet and can be
-only decreased, unless you have some unusual dedicated
-network settings. Default value is 1500.
-
-@item nakreport=@var{1|0}
-If set to 1, Receiver will send `UMSG_LOSSREPORT` messages
-periodically until a lost packet is retransmitted or
-intentionally dropped. Default value is 1.
-
-@item oheadbw=@var{percents}
-Recovery bandwidth overhead above input rate, in percents.
-See @option{inputbw}. Default value is 25%.
-
-@item passphrase=@var{string}
-HaiCrypt Encryption/Decryption Passphrase string, length
-from 10 to 79 characters. The passphrase is the shared
-secret between the sender and the receiver. It is used
-to generate the Key Encrypting Key using PBKDF2
-(Password-Based Key Derivation Function). It is used
-only if @option{pbkeylen} is non-zero. It is used on
-the receiver only if the received data is encrypted.
-The configured passphrase cannot be recovered (write-only).
-
-@item pbkeylen=@var{bytes}
-Sender encryption key length, in bytes.
-Only can be set to 0, 16, 24 and 32.
-Enable sender encryption if not 0.
-Not required on receiver (set to 0),
-key size obtained from sender in HaiCrypt handshake.
-Default value is 0.
-
-@item recv_buffer_size=@var{bytes}
-Set receive buffer size, expressed in bytes.
-
-@item send_buffer_size=@var{bytes}
-Set send buffer size, expressed in bytes.
-
-@item rw_timeout
-Set raise error timeout for read/write optations.
-
-This option is only relevant in read mode:
-if no data arrived in more than this time
-interval, raise error.
-
-@item tlpktdrop=@var{1|0}
-Too-late Packet Drop. When enabled on receiver, it skips
-missing packets that have not been delivered in time and
-delivers the following packets to the application when
-their time-to-play has come. It also sends a fake ACK to
-the sender. When enabled on sender and enabled on the
-receiving peer, the sender drops the older packets that
-have no chance of being delivered in time. It was
-automatically enabled in the sender if the receiver
-supports it.
-
-@item tsbpddelay
-Timestamp-based Packet Delivery Delay.
-Used to absorb burst of missed packet retransmission.
-
-@end table
-
-For more information see: @url{https://github.com/Haivision/srt}.
-
 @section srtp
 
 Secure Real-time Transport Protocol.
@@ -1332,7 +1186,6 @@ Accepted options:
 Start offset of the extracted segment, in bytes.
 @item end
 End offset of the extracted segment, in bytes.
-If set to 0, extract till end of file.
 @end table
 
 Examples:
@@ -1348,11 +1201,6 @@ Play an AVI file directly from a TAR archive:
 subfile,,start,183241728,end,366490624,,:archive.tar
 @end example
 
-Play a MPEG-TS file from start offset till end:
-@example
-subfile,,start,32815239,end,0,,:video.ts
-@end example
-
 @section tee
 
 Writes the output to multiple protocols. The individual outputs are separated
@@ -1394,9 +1242,6 @@ Set receive buffer size, expressed bytes.
 
 @item send_buffer_size=@var{bytes}
 Set send buffer size, expressed bytes.
-
-@item tcp_nodelay=@var{1|0}
-Set TCP_NODELAY to disable Nagle's algorithm. Default value is 0.
 @end table
 
 The following example shows how to setup a listening TCP connection
@@ -1432,7 +1277,7 @@ If enabled, try to verify the peer that we are communicating with.
 Note, if using OpenSSL, this currently only makes sure that the
 peer certificate is signed by one of the root certificates in the CA
 database, but it does not validate that the certificate actually
-matches the host name we are trying to connect to. (With other backends,
+matches the host name we are trying to connect to. (With GnuTLS,
 the host name is validated as well.)
 
 This is disabled by default since it requires a CA database to be

doc/utils.texi

@@ -1057,3 +1057,33 @@ indication of the corresponding powers of 10 and of 2.
 @end table
 
 @c man end EXPRESSION EVALUATION
+
+@chapter OpenCL Options
+@c man begin OPENCL OPTIONS
+
+When FFmpeg is configured with @code{--enable-opencl}, it is possible
+to set the options for the global OpenCL context.
+
+The list of supported options follows:
+
+@table @option
+@item build_options
+Set build options used to compile the registered kernels.
+
+See reference "OpenCL Specification Version: 1.2 chapter 5.6.4".
+
+@item platform_idx
+Select the index of the platform to run OpenCL code.
+
+The specified index must be one of the indexes in the device list
+which can be obtained with @code{ffmpeg -opencl_bench} or @code{av_opencl_get_device_list()}.
+
+@item device_idx
+Select the index of the device used to run OpenCL code.
+
+The specified index must be one of the indexes in the device list which
+can be obtained with @code{ffmpeg -opencl_bench} or @code{av_opencl_get_device_list()}.
+
+@end table
+
+@c man end OPENCL OPTIONS

doc/writing_filters.txt

@@ -31,8 +31,10 @@ If everything went right, you should get a foobar.png with Lena edge-detected.
 That's it, your new playground is ready.
 
 Some little details about what's going on:
-libavfilter/allfilters.c:this file is parsed by the configure script, which in turn
-will define variables for the build system and the C:
+libavfilter/allfilters.c:avfilter_register_all() is called at runtime to create
+a list of the available filters, but it's important to know that this file is
+also parsed by the configure script, which in turn will define variables for
+the build system and the C:
 
     --- after running configure ---
 

ffbuild/common.mak

@@ -119,7 +119,7 @@ FFLIBS    := $($(NAME)_FFLIBS) $(FFLIBS-yes) $(FFLIBS)
 TESTPROGS += $(TESTPROGS-yes)
 
 LDLIBS       = $(FFLIBS:%=%$(BUILDSUF))
-FFEXTRALIBS := $(LDLIBS:%=$(LD_LIB)) $(foreach lib,EXTRALIBS-$(NAME) $(FFLIBS:%=EXTRALIBS-%),$($(lib))) $(EXTRALIBS)
+FFEXTRALIBS := $(LDLIBS:%=$(LD_LIB)) $(EXTRALIBS)
 
 OBJS      := $(sort $(OBJS:%=$(SUBDIR)%))
 SLIBOBJS  := $(sort $(SLIBOBJS:%=$(SUBDIR)%))
@@ -163,7 +163,8 @@ $(TOOLOBJS): | tools
 
 OBJDIRS := $(OBJDIRS) $(dir $(OBJS) $(HOBJS) $(HOSTOBJS) $(SLIBOBJS) $(TESTOBJS))
 
-CLEANSUFFIXES     = *.d *.gcda *.gcno *.h.c *.ho *.map *.o *.pc *.ptx *.ptx.c *.ver *.version *$(DEFAULT_X86ASMD).asm *~
+CLEANSUFFIXES     = *.d *.o *~ *.h.c *.gcda *.gcno *.map *.ver *.version *.ho *$(DEFAULT_X86ASMD).asm *.ptx *.ptx.c
+DISTCLEANSUFFIXES = *.pc
 LIBSUFFIXES       = *.a *.lib *.so *.so.* *.dylib *.dll *.def *.dll.a
 
 define RULES

ffbuild/library.mak

@@ -1,6 +1,6 @@
 include $(SRC_PATH)/ffbuild/common.mak
 
-ifeq (,$(filter %clean config,$(MAKECMDGOALS)))
+ifeq (,$(filter %clean,$(MAKECMDGOALS)))
 -include $(SUBDIR)lib$(NAME).version
 endif
 
@@ -31,15 +31,13 @@ define RULES
 $(TOOLS):     THISLIB = $(FULLNAME:%=$(LD_LIB))
 $(TESTPROGS): THISLIB = $(SUBDIR)$(LIBNAME)
 
-$(LIBOBJS): CPPFLAGS += -DBUILDING_$(NAME)
-
 $(TESTPROGS) $(TOOLS): %$(EXESUF): %.o
-	$$(LD) $(LDFLAGS) $(LDEXEFLAGS) $$(LD_O) $$(filter %.o,$$^) $$(THISLIB) $(FFEXTRALIBS) $$(EXTRALIBS-$$(*F)) $$(ELIBS)
+	$$(LD) $(LDFLAGS) $(LDEXEFLAGS) $$(LD_O) $$(filter %.o,$$^) $$(THISLIB) $(FFEXTRALIBS) $$(ELIBS)
 
 $(SUBDIR)lib$(NAME).version: $(SUBDIR)version.h | $(SUBDIR)
 	$$(M) $$(SRC_PATH)/ffbuild/libversion.sh $(NAME) $$< > $$@
 
-$(SUBDIR)lib$(FULLNAME).pc: $(SUBDIR)version.h ffbuild/config.sh | $(SUBDIR)
+$(SUBDIR)lib$(FULLNAME).pc: $(SUBDIR)version.h | $(SUBDIR)
 	$$(M) $$(SRC_PATH)/ffbuild/pkgconfig_generate.sh $(NAME) "$(DESC)"
 
 $(SUBDIR)lib$(NAME).ver: $(SUBDIR)lib$(NAME).v $(OBJS)
@@ -50,7 +48,7 @@ $(SUBDIR)$(SLIBNAME): $(SUBDIR)$(SLIBNAME_WITH_MAJOR)
 
 $(SUBDIR)$(SLIBNAME_WITH_MAJOR): $(OBJS) $(SLIBOBJS) $(SUBDIR)lib$(NAME).ver
 	$(SLIB_CREATE_DEF_CMD)
-	$$(LD) $(SHFLAGS) $(LDFLAGS) $(LDSOFLAGS) $$(LD_O) $$(filter %.o,$$^) $(FFEXTRALIBS)
+	$$(LD) $(SHFLAGS) $(LDFLAGS) $(LDLIBFLAGS) $$(LD_O) $$(filter %.o,$$^) $(FFEXTRALIBS)
 	$(SLIB_EXTRA_CMD)
 
 ifdef SUBDIR
@@ -61,6 +59,10 @@ clean::
 	$(RM) $(addprefix $(SUBDIR),$(CLEANFILES) $(CLEANSUFFIXES) $(LIBSUFFIXES)) \
 	    $(CLEANSUFFIXES:%=$(SUBDIR)$(ARCH)/%) $(CLEANSUFFIXES:%=$(SUBDIR)tests/%)
 
+distclean:: clean
+	$(RM) $(DISTCLEANSUFFIXES:%=$(SUBDIR)%) $(DISTCLEANSUFFIXES:%=$(SUBDIR)$(ARCH)/%) \
+            $(DISTCLEANSUFFIXES:%=$(SUBDIR)tests/%)
+
 install-lib$(NAME)-shared: $(SUBDIR)$(SLIBNAME)
 	$(Q)mkdir -p "$(SHLIBDIR)"
 	$$(INSTALL) -m 755 $$< "$(SHLIBDIR)/$(SLIB_INSTALL_NAME)"
@@ -93,10 +95,8 @@ uninstall-libs::
 
 uninstall-headers::
 	$(RM) $(addprefix "$(INCINSTDIR)/",$(HEADERS) $(BUILT_HEADERS))
-	-rmdir "$(INCINSTDIR)"
-
-uninstall-pkgconfig::
 	$(RM) "$(PKGCONFIGDIR)/lib$(FULLNAME).pc"
+	-rmdir "$(INCINSTDIR)"
 endef
 
 $(eval $(RULES))

fftools/Makefile

@@ -1,11 +1,12 @@
 AVPROGS-$(CONFIG_FFMPEG)   += ffmpeg
 AVPROGS-$(CONFIG_FFPLAY)   += ffplay
 AVPROGS-$(CONFIG_FFPROBE)  += ffprobe
+AVPROGS-$(CONFIG_FFSERVER) += ffserver
 
 AVPROGS     := $(AVPROGS-yes:%=%$(PROGSSUF)$(EXESUF))
 PROGS       += $(AVPROGS)
 
-AVBASENAMES  = ffmpeg ffplay ffprobe
+AVBASENAMES  = ffmpeg ffplay ffprobe ffserver
 ALLAVPROGS   = $(AVBASENAMES:%=%$(PROGSSUF)$(EXESUF))
 ALLAVPROGS_G = $(AVBASENAMES:%=%$(PROGSSUF)_g$(EXESUF))
 
@@ -16,6 +17,7 @@ ifndef CONFIG_VIDEOTOOLBOX
 OBJS-ffmpeg-$(CONFIG_VDA)          += fftools/ffmpeg_videotoolbox.o
 endif
 OBJS-ffmpeg-$(CONFIG_VIDEOTOOLBOX) += fftools/ffmpeg_videotoolbox.o
+OBJS-ffserver                      += fftools/ffserver_config.o
 
 define DOFFTOOL
 OBJS-$(1) += fftools/cmdutils.o fftools/$(1).o $(OBJS-$(1)-yes)
@@ -27,6 +29,7 @@ $(1)$(PROGSSUF)_g$(EXESUF): FF_EXTRALIBS += $(EXTRALIBS-$(1))
 -include $$(OBJS-$(1):.o=.d)
 endef
 
+$(foreach P,$(AVPROGS-yes),$(eval OBJS-$(P)-$(CONFIG_OPENCL) += fftools/cmdutils_opencl.o))
 $(foreach P,$(AVPROGS-yes),$(eval $(call DOFFTOOL,$(P))))
 
 all: $(AVPROGS)

fftools/cmdutils.c

@@ -38,7 +38,6 @@
 #include "libswscale/swscale.h"
 #include "libswresample/swresample.h"
 #include "libpostproc/postprocess.h"
-#include "libavutil/attributes.h"
 #include "libavutil/avassert.h"
 #include "libavutil/avstring.h"
 #include "libavutil/bprint.h"
@@ -881,54 +880,28 @@ int opt_loglevel(void *optctx, const char *opt, const char *arg)
         { "debug"  , AV_LOG_DEBUG   },
         { "trace"  , AV_LOG_TRACE   },
     };
-    const char *token;
     char *tail;
-    int flags = av_log_get_flags();
-    int level = av_log_get_level();
-    int cmd, i = 0;
+    int level;
+    int flags;
+    int i;
 
-    av_assert0(arg);
-    while (*arg) {
-        token = arg;
-        if (*token == '+' || *token == '-') {
-            cmd = *token++;
-        } else {
-            cmd = 0;
-        }
-        if (!i && !cmd) {
-            flags = 0;  /* missing relative prefix, build absolute value */
-        }
-        if (!strncmp(token, "repeat", 6)) {
-            if (cmd == '-') {
-                flags |= AV_LOG_SKIP_REPEATED;
-            } else {
-                flags &= ~AV_LOG_SKIP_REPEATED;
-            }
-            arg = token + 6;
-        } else if (!strncmp(token, "level", 5)) {
-            if (cmd == '-') {
-                flags &= ~AV_LOG_PRINT_LEVEL;
-            } else {
-                flags |= AV_LOG_PRINT_LEVEL;
-            }
-            arg = token + 5;
-        } else {
-            break;
-        }
-        i++;
-    }
-    if (!*arg) {
-        goto end;
-    } else if (*arg == '+') {
-        arg++;
-    } else if (!i) {
-        flags = av_log_get_flags();  /* level value without prefix, reset flags */
-    }
+    flags = av_log_get_flags();
+    tail = strstr(arg, "repeat");
+    if (tail)
+        flags &= ~AV_LOG_SKIP_REPEATED;
+    else
+        flags |= AV_LOG_SKIP_REPEATED;
+
+    av_log_set_flags(flags);
+    if (tail == arg)
+        arg += 6 + (arg[6]=='+');
+    if(tail && !*arg)
+        return 0;
 
     for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
         if (!strcmp(log_levels[i].name, arg)) {
-            level = log_levels[i].level;
-            goto end;
+            av_log_set_level(log_levels[i].level);
+            return 0;
         }
     }
 
@@ -940,9 +913,6 @@ int opt_loglevel(void *optctx, const char *opt, const char *arg)
             av_log(NULL, AV_LOG_FATAL, "\"%s\"\n", log_levels[i].name);
         exit_program(1);
     }
-
-end:
-    av_log_set_flags(flags);
     av_log_set_level(level);
     return 0;
 }
@@ -1288,10 +1258,8 @@ static int is_device(const AVClass *avclass)
 
 static int show_formats_devices(void *optctx, const char *opt, const char *arg, int device_only, int muxdemuxers)
 {
-    void *ifmt_opaque = NULL;
-    const AVInputFormat *ifmt  = NULL;
-    void *ofmt_opaque = NULL;
-    const AVOutputFormat *ofmt = NULL;
+    AVInputFormat *ifmt  = NULL;
+    AVOutputFormat *ofmt = NULL;
     const char *last_name;
     int is_dev;
 
@@ -1307,8 +1275,7 @@ static int show_formats_devices(void *optctx, const char *opt, const char *arg,
         const char *long_name = NULL;
 
         if (muxdemuxers !=SHOW_DEMUXERS) {
-            ofmt_opaque = NULL;
-            while ((ofmt = av_muxer_iterate(&ofmt_opaque))) {
+            while ((ofmt = av_oformat_next(ofmt))) {
                 is_dev = is_device(ofmt->priv_class);
                 if (!is_dev && device_only)
                     continue;
@@ -1321,8 +1288,7 @@ static int show_formats_devices(void *optctx, const char *opt, const char *arg,
             }
         }
         if (muxdemuxers != SHOW_MUXERS) {
-            ifmt_opaque = NULL;
-            while ((ifmt = av_demuxer_iterate(&ifmt_opaque))) {
+            while ((ifmt = av_iformat_next(ifmt))) {
                 is_dev = is_device(ifmt->priv_class);
                 if (!is_dev && device_only)
                     continue;
@@ -1636,7 +1602,7 @@ int show_bsfs(void *optctx, const char *opt, const char *arg)
     void *opaque = NULL;
 
     printf("Bitstream filters:\n");
-    while ((bsf = av_bsf_iterate(&opaque)))
+    while ((bsf = av_bsf_next(&opaque)))
         printf("%s\n", bsf->name);
     printf("\n");
     return 0;
@@ -1662,7 +1628,6 @@ int show_filters(void *optctx, const char *opt, const char *arg)
 #if CONFIG_AVFILTER
     const AVFilter *filter = NULL;
     char descr[64], *descr_cur;
-    void *opaque = NULL;
     int i, j;
     const AVFilterPad *pad;
 
@@ -1674,7 +1639,7 @@ int show_filters(void *optctx, const char *opt, const char *arg)
            "  V = Video input/output\n"
            "  N = Dynamic number and/or type of input/output\n"
            "  | = Source or sink filter\n");
-    while ((filter = av_filter_iterate(&opaque))) {
+    while ((filter = avfilter_next(filter))) {
         descr_cur = descr;
         for (i = 0; i < 2; i++) {
             if (i) {
@@ -1737,7 +1702,7 @@ int show_pix_fmts(void *optctx, const char *opt, const char *arg)
 #endif
 
     while ((pix_desc = av_pix_fmt_desc_next(pix_desc))) {
-        enum AVPixelFormat av_unused pix_fmt = av_pix_fmt_desc_get_id(pix_desc);
+        enum AVPixelFormat pix_fmt = av_pix_fmt_desc_get_id(pix_desc);
         printf("%c%c%c%c%c %-16s       %d            %2d\n",
                sws_isSupportedInput (pix_fmt)              ? 'I' : '.',
                sws_isSupportedOutput(pix_fmt)              ? 'O' : '.',
@@ -1931,22 +1896,6 @@ static void show_help_filter(const char *name)
 }
 #endif
 
-static void show_help_bsf(const char *name)
-{
-    const AVBitStreamFilter *bsf = av_bsf_get_by_name(name);
-
-    if (!bsf) {
-        av_log(NULL, AV_LOG_ERROR, "Unknown bit stream filter '%s'.\n", name);
-        return;
-    }
-
-    printf("Bit stream filter %s\n", bsf->name);
-    PRINT_CODEC_SUPPORTED(bsf, codec_ids, enum AVCodecID, "codecs",
-                          AV_CODEC_ID_NONE, GET_CODEC_NAME);
-    if (bsf->priv_class)
-        show_help_children(bsf->priv_class, AV_OPT_FLAG_BSF_PARAM);
-}
-
 int show_help(void *optctx, const char *opt, const char *arg)
 {
     char *topic, *par;
@@ -1973,8 +1922,6 @@ int show_help(void *optctx, const char *opt, const char *arg)
     } else if (!strcmp(topic, "filter")) {
         show_help_filter(par);
 #endif
-    } else if (!strcmp(topic, "bsf")) {
-        show_help_bsf(par);
     } else {
         show_help_default(topic, par);
     }

fftools/cmdutils.h

@@ -105,6 +105,12 @@ int opt_max_alloc(void *optctx, const char *opt, const char *arg);
 
 int opt_codec_debug(void *optctx, const char *opt, const char *arg);
 
+#if CONFIG_OPENCL
+int opt_opencl(void *optctx, const char *opt, const char *arg);
+
+int opt_opencl_bench(void *optctx, const char *opt, const char *arg);
+#endif
+
 /**
  * Limit the execution time.
  */
@@ -149,7 +155,6 @@ typedef struct SpecifierOpt {
         uint8_t *str;
         int        i;
         int64_t  i64;
-        uint64_t ui64;
         float      f;
         double   dbl;
     } u;
@@ -201,6 +206,17 @@ typedef struct OptionDef {
 void show_help_options(const OptionDef *options, const char *msg, int req_flags,
                        int rej_flags, int alt_flags);
 
+#if CONFIG_OPENCL
+#define CMDUTILS_COMMON_OPTIONS_OPENCL                                                                                  \
+    { "opencl_bench", OPT_EXIT, {.func_arg = opt_opencl_bench},                                                         \
+       "run benchmark on all OpenCL devices and show results" },                                                        \
+    { "opencl_options", HAS_ARG, {.func_arg = opt_opencl},                                                              \
+       "set OpenCL environment options" },                                                                              \
+
+#else
+#define CMDUTILS_COMMON_OPTIONS_OPENCL
+#endif
+
 #if CONFIG_AVDEVICE
 #define CMDUTILS_COMMON_OPTIONS_AVDEVICE                                                                                \
     { "sources"    , OPT_EXIT | HAS_ARG, { .func_arg = show_sources },                                                  \
@@ -240,6 +256,7 @@ void show_help_options(const OptionDef *options, const char *msg, int req_flags,
     { "max_alloc",   HAS_ARG,              { .func_arg = opt_max_alloc },    "set maximum size of a single allocated block", "bytes" }, \
     { "cpuflags",    HAS_ARG | OPT_EXPERT, { .func_arg = opt_cpuflags },     "force specific cpu flags", "flags" },     \
     { "hide_banner", OPT_BOOL | OPT_EXPERT, {&hide_banner},     "do not show program banner", "hide_banner" },          \
+    CMDUTILS_COMMON_OPTIONS_OPENCL                                                                                      \
     CMDUTILS_COMMON_OPTIONS_AVDEVICE                                                                                    \
 
 /**
@@ -625,9 +642,6 @@ void *grow_array(void *array, int elem_size, int *size, int new_size);
 #define GET_PIX_FMT_NAME(pix_fmt)\
     const char *name = av_get_pix_fmt_name(pix_fmt);
 
-#define GET_CODEC_NAME(id)\
-    const char *name = avcodec_descriptor_get(id)->name;
-
 #define GET_SAMPLE_FMT_NAME(sample_fmt)\
     const char *name = av_get_sample_fmt_name(sample_fmt)
 

fftools/cmdutils_opencl.c

@@ -0,0 +1,283 @@
+/*
+ * Copyright (C) 2013 Lenny Wang
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libavutil/opt.h"
+#include "libavutil/time.h"
+#include "libavutil/log.h"
+#include "libavutil/opencl.h"
+#include "libavutil/avstring.h"
+#include "cmdutils.h"
+
+typedef struct {
+    int platform_idx;
+    int device_idx;
+    char device_name[64];
+    int64_t runtime;
+} OpenCLDeviceBenchmark;
+
+const char *ocl_bench_source = AV_OPENCL_KERNEL(
+inline unsigned char clip_uint8(int a)
+{
+    if (a & (~0xFF))
+        return (-a)>>31;
+    else
+        return a;
+}
+
+kernel void unsharp_bench(
+                    global unsigned char *src,
+                    global unsigned char *dst,
+                    global int *mask,
+                    int width,
+                    int height)
+{
+    int i, j, local_idx, lc_idx, sum = 0;
+    int2 thread_idx, block_idx, global_idx, lm_idx;
+    thread_idx.x = get_local_id(0);
+    thread_idx.y = get_local_id(1);
+    block_idx.x = get_group_id(0);
+    block_idx.y = get_group_id(1);
+    global_idx.x = get_global_id(0);
+    global_idx.y = get_global_id(1);
+    local uchar data[32][32];
+    local int lc[128];
+
+    for (i = 0; i <= 1; i++) {
+        lm_idx.y = -8 + (block_idx.y + i) * 16 + thread_idx.y;
+        lm_idx.y = lm_idx.y < 0 ? 0 : lm_idx.y;
+        lm_idx.y = lm_idx.y >= height ? height - 1: lm_idx.y;
+        for (j = 0; j <= 1; j++) {
+            lm_idx.x = -8 + (block_idx.x + j) * 16 + thread_idx.x;
+            lm_idx.x = lm_idx.x < 0 ? 0 : lm_idx.x;
+            lm_idx.x = lm_idx.x >= width ? width - 1: lm_idx.x;
+            data[i*16 + thread_idx.y][j*16 + thread_idx.x] = src[lm_idx.y*width + lm_idx.x];
+        }
+    }
+    local_idx = thread_idx.y*16 + thread_idx.x;
+    if (local_idx < 128)
+        lc[local_idx] = mask[local_idx];
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    \n#pragma unroll\n
+    for (i = -4; i <= 4; i++) {
+        lm_idx.y = 8 + i + thread_idx.y;
+        \n#pragma unroll\n
+        for (j = -4; j <= 4; j++) {
+            lm_idx.x = 8 + j + thread_idx.x;
+            lc_idx = (i + 4)*8 + j + 4;
+            sum += (int)data[lm_idx.y][lm_idx.x] * lc[lc_idx];
+        }
+    }
+    int temp = (int)data[thread_idx.y + 8][thread_idx.x + 8];
+    int res = temp + (((temp - (int)((sum + 1<<15) >> 16))) >> 16);
+    if (global_idx.x < width && global_idx.y < height)
+        dst[global_idx.x + global_idx.y*width] = clip_uint8(res);
+}
+);
+
+#define OCLCHECK(method, ... )                                                 \
+do {                                                                           \
+    status = method(__VA_ARGS__);                                              \
+    if (status != CL_SUCCESS) {                                                \
+        av_log(NULL, AV_LOG_ERROR, # method " error '%s'\n",                   \
+               av_opencl_errstr(status));                                      \
+        ret = AVERROR_EXTERNAL;                                                \
+        goto end;                                                              \
+    }                                                                          \
+} while (0)
+
+#define CREATEBUF(out, flags, size)                                            \
+do {                                                                           \
+    out = clCreateBuffer(ext_opencl_env->context, flags, size, NULL, &status); \
+    if (status != CL_SUCCESS) {                                                \
+        av_log(NULL, AV_LOG_ERROR, "Could not create OpenCL buffer\n");        \
+        ret = AVERROR_EXTERNAL;                                                \
+        goto end;                                                              \
+    }                                                                          \
+} while (0)
+
+static void fill_rand_int(int *data, int n)
+{
+    int i;
+    srand(av_gettime());
+    for (i = 0; i < n; i++)
+        data[i] = rand();
+}
+
+#define OPENCL_NB_ITER 5
+static int64_t run_opencl_bench(AVOpenCLExternalEnv *ext_opencl_env)
+{
+    int i, arg = 0, width = 1920, height = 1088;
+    int64_t start, ret = 0;
+    cl_int status;
+    size_t kernel_len;
+    char *inbuf;
+    int *mask = NULL;
+    int buf_size = width * height * sizeof(char);
+    int mask_size = sizeof(uint32_t) * 128;
+
+    cl_mem cl_mask = NULL, cl_inbuf = NULL, cl_outbuf = NULL;
+    cl_kernel kernel = NULL;
+    cl_program program = NULL;
+    size_t local_work_size_2d[2] = {16, 16};
+    size_t global_work_size_2d[2] = {(size_t)width, (size_t)height};
+
+    if (!(inbuf = av_malloc(buf_size)) || !(mask = av_malloc(mask_size))) {
+        av_log(NULL, AV_LOG_ERROR, "Out of memory\n");
+        ret = AVERROR(ENOMEM);
+        goto end;
+    }
+    fill_rand_int((int*)inbuf, buf_size/4);
+    fill_rand_int(mask, mask_size/4);
+
+    CREATEBUF(cl_mask, CL_MEM_READ_ONLY, mask_size);
+    CREATEBUF(cl_inbuf, CL_MEM_READ_ONLY, buf_size);
+    CREATEBUF(cl_outbuf, CL_MEM_READ_WRITE, buf_size);
+
+    kernel_len = strlen(ocl_bench_source);
+    program = clCreateProgramWithSource(ext_opencl_env->context, 1, &ocl_bench_source,
+                                        &kernel_len, &status);
+    if (status != CL_SUCCESS || !program) {
+        av_log(NULL, AV_LOG_ERROR, "OpenCL unable to create benchmark program\n");
+        ret = AVERROR_EXTERNAL;
+        goto end;
+    }
+    status = clBuildProgram(program, 1, &(ext_opencl_env->device_id), NULL, NULL, NULL);
+    if (status != CL_SUCCESS) {
+        av_log(NULL, AV_LOG_ERROR, "OpenCL unable to build benchmark program\n");
+        ret = AVERROR_EXTERNAL;
+        goto end;
+    }
+    kernel = clCreateKernel(program, "unsharp_bench", &status);
+    if (status != CL_SUCCESS) {
+        av_log(NULL, AV_LOG_ERROR, "OpenCL unable to create benchmark kernel\n");
+        ret = AVERROR_EXTERNAL;
+        goto end;
+    }
+
+    OCLCHECK(clEnqueueWriteBuffer, ext_opencl_env->command_queue, cl_inbuf, CL_TRUE, 0,
+             buf_size, inbuf, 0, NULL, NULL);
+    OCLCHECK(clEnqueueWriteBuffer, ext_opencl_env->command_queue, cl_mask, CL_TRUE, 0,
+             mask_size, mask, 0, NULL, NULL);
+    OCLCHECK(clSetKernelArg, kernel, arg++, sizeof(cl_mem), &cl_inbuf);
+    OCLCHECK(clSetKernelArg, kernel, arg++, sizeof(cl_mem), &cl_outbuf);
+    OCLCHECK(clSetKernelArg, kernel, arg++, sizeof(cl_mem), &cl_mask);
+    OCLCHECK(clSetKernelArg, kernel, arg++, sizeof(cl_int), &width);
+    OCLCHECK(clSetKernelArg, kernel, arg++, sizeof(cl_int), &height);
+
+    start = av_gettime_relative();
+    for (i = 0; i < OPENCL_NB_ITER; i++)
+        OCLCHECK(clEnqueueNDRangeKernel, ext_opencl_env->command_queue, kernel, 2, NULL,
+                 global_work_size_2d, local_work_size_2d, 0, NULL, NULL);
+    clFinish(ext_opencl_env->command_queue);
+    ret = (av_gettime_relative() - start)/OPENCL_NB_ITER;
+end:
+    if (kernel)
+        clReleaseKernel(kernel);
+    if (program)
+        clReleaseProgram(program);
+    if (cl_inbuf)
+        clReleaseMemObject(cl_inbuf);
+    if (cl_outbuf)
+        clReleaseMemObject(cl_outbuf);
+    if (cl_mask)
+        clReleaseMemObject(cl_mask);
+    av_free(inbuf);
+    av_free(mask);
+    return ret;
+}
+
+static int compare_ocl_device_desc(const void *a, const void *b)
+{
+    const OpenCLDeviceBenchmark* va = (const OpenCLDeviceBenchmark*)a;
+    const OpenCLDeviceBenchmark* vb = (const OpenCLDeviceBenchmark*)b;
+    return FFDIFFSIGN(va->runtime , vb->runtime);
+}
+
+int opt_opencl_bench(void *optctx, const char *opt, const char *arg)
+{
+    int i, j, nb_devices = 0, count = 0, ret = 0;
+    int64_t score = 0;
+    AVOpenCLDeviceList *device_list;
+    AVOpenCLDeviceNode *device_node = NULL;
+    OpenCLDeviceBenchmark *devices = NULL;
+    cl_platform_id platform;
+
+    ret = av_opencl_get_device_list(&device_list);
+    if (ret < 0) {
+        return ret;
+    }
+    for (i = 0; i < device_list->platform_num; i++)
+        nb_devices += device_list->platform_node[i]->device_num;
+    if (!nb_devices) {
+        av_log(NULL, AV_LOG_ERROR, "No OpenCL device detected!\n");
+        av_opencl_free_device_list(&device_list);
+        return AVERROR(EINVAL);
+    }
+    if (!(devices = av_malloc_array(nb_devices, sizeof(OpenCLDeviceBenchmark)))) {
+        av_log(NULL, AV_LOG_ERROR, "Could not allocate buffer\n");
+        av_opencl_free_device_list(&device_list);
+        return AVERROR(ENOMEM);
+    }
+
+    for (i = 0; i < device_list->platform_num; i++) {
+        for (j = 0; j < device_list->platform_node[i]->device_num; j++) {
+            device_node = device_list->platform_node[i]->device_node[j];
+            platform = device_list->platform_node[i]->platform_id;
+            score = av_opencl_benchmark(device_node, platform, run_opencl_bench);
+            if (score > 0) {
+                devices[count].platform_idx = i;
+                devices[count].device_idx = j;
+                devices[count].runtime = score;
+                av_strlcpy(devices[count].device_name, device_node->device_name,
+                           sizeof(devices[count].device_name));
+                count++;
+            }
+        }
+    }
+    qsort(devices, count, sizeof(OpenCLDeviceBenchmark), compare_ocl_device_desc);
+    fprintf(stderr, "platform_idx\tdevice_idx\tdevice_name\truntime\n");
+    for (i = 0; i < count; i++)
+        fprintf(stdout, "%d\t%d\t%s\t%"PRId64"\n",
+                devices[i].platform_idx, devices[i].device_idx,
+                devices[i].device_name, devices[i].runtime);
+
+    av_opencl_free_device_list(&device_list);
+    av_free(devices);
+    return 0;
+}
+
+int opt_opencl(void *optctx, const char *opt, const char *arg)
+{
+    char *key, *value;
+    const char *opts = arg;
+    int ret = 0;
+    while (*opts) {
+        ret = av_opt_get_key_value(&opts, "=", ":", 0, &key, &value);
+        if (ret < 0)
+            return ret;
+        ret = av_opencl_set_option(key, value);
+        if (ret < 0)
+            return ret;
+        if (*opts)
+            opts++;
+    }
+    return ret;
+}

fftools/ffmpeg.c

@@ -61,7 +61,6 @@
 #include "libavutil/timestamp.h"
 #include "libavutil/bprint.h"
 #include "libavutil/time.h"
-#include "libavutil/thread.h"
 #include "libavutil/threadmessage.h"
 #include "libavcodec/mathops.h"
 #include "libavformat/os_support.h"
@@ -99,6 +98,10 @@
 #include <conio.h>
 #endif
 
+#if HAVE_PTHREADS
+#include <pthread.h>
+#endif
+
 #include <time.h>
 
 #include "ffmpeg.h"
@@ -158,7 +161,7 @@ static struct termios oldtty;
 static int restore_tty;
 #endif
 
-#if HAVE_THREADS
+#if HAVE_PTHREADS
 static void free_input_threads(void);
 #endif
 
@@ -217,18 +220,13 @@ static void sub2video_push_ref(InputStream *ist, int64_t pts)
 {
     AVFrame *frame = ist->sub2video.frame;
     int i;
-    int ret;
 
     av_assert1(frame->data[0]);
     ist->sub2video.last_pts = frame->pts = pts;
-    for (i = 0; i < ist->nb_filters; i++) {
-        ret = av_buffersrc_add_frame_flags(ist->filters[i]->filter, frame,
-                                           AV_BUFFERSRC_FLAG_KEEP_REF |
-                                           AV_BUFFERSRC_FLAG_PUSH);
-        if (ret != AVERROR_EOF && ret < 0)
-            av_log(NULL, AV_LOG_WARNING, "Error while add the frame to buffer source(%s).\n",
-                   av_err2str(ret));
-    }
+    for (i = 0; i < ist->nb_filters; i++)
+        av_buffersrc_add_frame_flags(ist->filters[i]->filter, frame,
+                                     AV_BUFFERSRC_FLAG_KEEP_REF |
+                                     AV_BUFFERSRC_FLAG_PUSH);
 }
 
 void sub2video_update(InputStream *ist, AVSubtitle *sub)
@@ -285,8 +283,7 @@ static void sub2video_heartbeat(InputStream *ist, int64_t pts)
         /* do not send the heartbeat frame if the subtitle is already ahead */
         if (pts2 <= ist2->sub2video.last_pts)
             continue;
-        if (pts2 >= ist2->sub2video.end_pts ||
-            (!ist2->sub2video.frame->data[0] && ist2->sub2video.end_pts < INT64_MAX))
+        if (pts2 >= ist2->sub2video.end_pts || !ist2->sub2video.frame->data[0])
             sub2video_update(ist2, NULL);
         for (j = 0, nb_reqs = 0; j < ist2->nb_filters; j++)
             nb_reqs += av_buffersrc_get_nb_failed_requests(ist2->filters[j]->filter);
@@ -298,15 +295,11 @@ static void sub2video_heartbeat(InputStream *ist, int64_t pts)
 static void sub2video_flush(InputStream *ist)
 {
     int i;
-    int ret;
 
     if (ist->sub2video.end_pts < INT64_MAX)
         sub2video_update(ist, NULL);
-    for (i = 0; i < ist->nb_filters; i++) {
-        ret = av_buffersrc_add_frame(ist->filters[i]->filter, NULL);
-        if (ret != AVERROR_EOF && ret < 0)
-            av_log(NULL, AV_LOG_WARNING, "Flush the frame error.\n");
-    }
+    for (i = 0; i < ist->nb_filters; i++)
+        av_buffersrc_add_frame(ist->filters[i]->filter, NULL);
 }
 
 /* end of sub2video hack */
@@ -334,14 +327,13 @@ static int main_return_code = 0;
 static void
 sigterm_handler(int sig)
 {
-    int ret;
     received_sigterm = sig;
     received_nb_signals++;
     term_exit_sigsafe();
     if(received_nb_signals > 3) {
-        ret = write(2/*STDERR_FILENO*/, "Received > 3 system signals, hard exiting\n",
-                    strlen("Received > 3 system signals, hard exiting\n"));
-        if (ret < 0) { /* Do nothing */ };
+        write(2/*STDERR_FILENO*/, "Received > 3 system signals, hard exiting\n",
+                           strlen("Received > 3 system signals, hard exiting\n"));
+
         exit(123);
     }
 }
@@ -407,9 +399,6 @@ void term_init(void)
 #ifdef SIGXCPU
     signal(SIGXCPU, sigterm_handler);
 #endif
-#ifdef SIGPIPE
-    signal(SIGPIPE, SIG_IGN); /* Broken pipe (POSIX). */
-#endif
 #if HAVE_SETCONSOLECTRLHANDLER
     SetConsoleCtrlHandler((PHANDLER_ROUTINE) CtrlHandler, TRUE);
 #endif
@@ -552,6 +541,9 @@ static void ffmpeg_cleanup(int ret)
         av_frame_free(&ost->last_frame);
         av_dict_free(&ost->encoder_opts);
 
+        av_parser_close(ost->parser);
+        avcodec_free_context(&ost->parser_avctx);
+
         av_freep(&ost->forced_keyframes);
         av_expr_free(ost->forced_keyframes_pexpr);
         av_freep(&ost->avfilter);
@@ -576,7 +568,7 @@ static void ffmpeg_cleanup(int ret)
 
         av_freep(&output_streams[i]);
     }
-#if HAVE_THREADS
+#if HAVE_PTHREADS
     free_input_threads();
 #endif
     for (i = 0; i < nb_input_files; i++) {
@@ -1207,6 +1199,24 @@ static void do_video_out(OutputFile *of,
 #endif
         return;
 
+#if FF_API_LAVF_FMT_RAWPICTURE
+    if (of->ctx->oformat->flags & AVFMT_RAWPICTURE &&
+        enc->codec->id == AV_CODEC_ID_RAWVIDEO) {
+        /* raw pictures are written as AVPicture structure to
+           avoid any copies. We support temporarily the older
+           method. */
+        if (in_picture->interlaced_frame)
+            mux_par->field_order = in_picture->top_field_first ? AV_FIELD_TB:AV_FIELD_BT;
+        else
+            mux_par->field_order = AV_FIELD_PROGRESSIVE;
+        pkt.data   = (uint8_t *)in_picture;
+        pkt.size   =  sizeof(AVPicture);
+        pkt.pts    = av_rescale_q(in_picture->pts, enc->time_base, ost->mux_timebase);
+        pkt.flags |= AV_PKT_FLAG_KEY;
+
+        output_packet(of, &pkt, ost, 0);
+    } else
+#endif
     {
         int forced_keyframe = 0;
         double pts_time;
@@ -1561,7 +1571,7 @@ static void print_final_stats(int64_t total_size)
         uint64_t total_packets = 0, total_size = 0;
 
         av_log(NULL, AV_LOG_VERBOSE, "Input file #%d (%s):\n",
-               i, f->ctx->url);
+               i, f->ctx->filename);
 
         for (j = 0; j < f->nb_streams; j++) {
             InputStream *ist = input_streams[f->ist_index + j];
@@ -1595,7 +1605,7 @@ static void print_final_stats(int64_t total_size)
         uint64_t total_packets = 0, total_size = 0;
 
         av_log(NULL, AV_LOG_VERBOSE, "Output file #%d (%s):\n",
-               i, of->ctx->url);
+               i, of->ctx->filename);
 
         for (j = 0; j < of->ctx->nb_streams; j++) {
             OutputStream *ost = output_streams[of->ost_index + j];
@@ -1635,7 +1645,8 @@ static void print_final_stats(int64_t total_size)
 
 static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)
 {
-    AVBPrint buf, buf_script;
+    char buf[1024];
+    AVBPrint buf_script;
     OutputStream *ost;
     AVFormatContext *oc;
     int64_t total_size;
@@ -1647,7 +1658,6 @@ static void print_report(int is_last_report, int64_t timer_start, int64_t cur_ti
     static int64_t last_time = -1;
     static int qp_histogram[52];
     int hours, mins, secs, us;
-    const char *hours_sign;
     int ret;
     float t;
 
@@ -1673,8 +1683,8 @@ static void print_report(int is_last_report, int64_t timer_start, int64_t cur_ti
     if (total_size <= 0) // FIXME improve avio_size() so it works with non seekable output too
         total_size = avio_tell(oc->pb);
 
+    buf[0] = '\0';
     vid = 0;
-    av_bprint_init(&buf, 0, AV_BPRINT_SIZE_AUTOMATIC);
     av_bprint_init(&buf_script, 0, 1);
     for (i = 0; i < nb_output_streams; i++) {
         float q = -1;
@@ -1684,7 +1694,7 @@ static void print_report(int is_last_report, int64_t timer_start, int64_t cur_ti
             q = ost->quality / (float) FF_QP2LAMBDA;
 
         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
-            av_bprintf(&buf, "q=%2.1f ", q);
+            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
             av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
                        ost->file_index, ost->index, q);
         }
@@ -1693,21 +1703,21 @@ static void print_report(int is_last_report, int64_t timer_start, int64_t cur_ti
 
             frame_number = ost->frame_number;
             fps = t > 1 ? frame_number / t : 0;
-            av_bprintf(&buf, "frame=%5d fps=%3.*f q=%3.1f ",
+            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3.*f q=%3.1f ",
                      frame_number, fps < 9.95, fps, q);
             av_bprintf(&buf_script, "frame=%d\n", frame_number);
             av_bprintf(&buf_script, "fps=%.1f\n", fps);
             av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
                        ost->file_index, ost->index, q);
             if (is_last_report)
-                av_bprintf(&buf, "L");
+                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
             if (qp_hist) {
                 int j;
                 int qp = lrintf(q);
                 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
                     qp_histogram[qp]++;
                 for (j = 0; j < 32; j++)
-                    av_bprintf(&buf, "%X", av_log2(qp_histogram[j] + 1));
+                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", av_log2(qp_histogram[j] + 1));
             }
 
             if ((enc->flags & AV_CODEC_FLAG_PSNR) && (ost->pict_type != AV_PICTURE_TYPE_NONE || is_last_report)) {
@@ -1716,7 +1726,7 @@ static void print_report(int is_last_report, int64_t timer_start, int64_t cur_ti
                 double scale, scale_sum = 0;
                 double p;
                 char type[3] = { 'Y','U','V' };
-                av_bprintf(&buf, "PSNR=");
+                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
                 for (j = 0; j < 3; j++) {
                     if (is_last_report) {
                         error = enc->error[j];
@@ -1730,12 +1740,12 @@ static void print_report(int is_last_report, int64_t timer_start, int64_t cur_ti
                     error_sum += error;
                     scale_sum += scale;
                     p = psnr(error / scale);
-                    av_bprintf(&buf, "%c:%2.2f ", type[j], p);
+                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], p);
                     av_bprintf(&buf_script, "stream_%d_%d_psnr_%c=%2.2f\n",
                                ost->file_index, ost->index, type[j] | 32, p);
                 }
                 p = psnr(error_sum / scale_sum);
-                av_bprintf(&buf, "*:%2.2f ", psnr(error_sum / scale_sum));
+                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
                 av_bprintf(&buf_script, "stream_%d_%d_psnr_all=%2.2f\n",
                            ost->file_index, ost->index, p);
             }
@@ -1755,62 +1765,57 @@ static void print_report(int is_last_report, int64_t timer_start, int64_t cur_ti
     secs %= 60;
     hours = mins / 60;
     mins %= 60;
-    hours_sign = (pts < 0) ? "-" : "";
 
     bitrate = pts && total_size >= 0 ? total_size * 8 / (pts / 1000.0) : -1;
     speed = t != 0.0 ? (double)pts / AV_TIME_BASE / t : -1;
 
-    if (total_size < 0) av_bprintf(&buf, "size=N/A time=");
-    else                av_bprintf(&buf, "size=%8.0fkB time=", total_size / 1024.0);
-    if (pts == AV_NOPTS_VALUE) {
-        av_bprintf(&buf, "N/A ");
-    } else {
-        av_bprintf(&buf, "%s%02d:%02d:%02d.%02d ",
-                   hours_sign, hours, mins, secs, (100 * us) / AV_TIME_BASE);
-    }
+    if (total_size < 0) snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
+                                 "size=N/A time=");
+    else                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
+                                 "size=%8.0fkB time=", total_size / 1024.0);
+    if (pts < 0)
+        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "-");
+    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
+             "%02d:%02d:%02d.%02d ", hours, mins, secs,
+             (100 * us) / AV_TIME_BASE);
 
     if (bitrate < 0) {
-        av_bprintf(&buf, "bitrate=N/A");
+        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),"bitrate=N/A");
         av_bprintf(&buf_script, "bitrate=N/A\n");
     }else{
-        av_bprintf(&buf, "bitrate=%6.1fkbits/s", bitrate);
+        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),"bitrate=%6.1fkbits/s", bitrate);
         av_bprintf(&buf_script, "bitrate=%6.1fkbits/s\n", bitrate);
     }
 
     if (total_size < 0) av_bprintf(&buf_script, "total_size=N/A\n");
     else                av_bprintf(&buf_script, "total_size=%"PRId64"\n", total_size);
-    if (pts == AV_NOPTS_VALUE) {
-        av_bprintf(&buf_script, "out_time_ms=N/A\n");
-        av_bprintf(&buf_script, "out_time=N/A\n");
-    } else {
-        av_bprintf(&buf_script, "out_time_ms=%"PRId64"\n", pts);
-        av_bprintf(&buf_script, "out_time=%s%02d:%02d:%02d.%06d\n",
-                   hours_sign, hours, mins, secs, us);
-    }
+    av_bprintf(&buf_script, "out_time_ms=%"PRId64"\n", pts);
+    av_bprintf(&buf_script, "out_time=%02d:%02d:%02d.%06d\n",
+               hours, mins, secs, us);
 
     if (nb_frames_dup || nb_frames_drop)
-        av_bprintf(&buf, " dup=%d drop=%d", nb_frames_dup, nb_frames_drop);
+        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
+                nb_frames_dup, nb_frames_drop);
     av_bprintf(&buf_script, "dup_frames=%d\n", nb_frames_dup);
     av_bprintf(&buf_script, "drop_frames=%d\n", nb_frames_drop);
 
     if (speed < 0) {
-        av_bprintf(&buf, " speed=N/A");
+        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf)," speed=N/A");
         av_bprintf(&buf_script, "speed=N/A\n");
     } else {
-        av_bprintf(&buf, " speed=%4.3gx", speed);
+        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf)," speed=%4.3gx", speed);
         av_bprintf(&buf_script, "speed=%4.3gx\n", speed);
     }
 
     if (print_stats || is_last_report) {
         const char end = is_last_report ? '\n' : '\r';
         if (print_stats==1 && AV_LOG_INFO > av_log_get_level()) {
-            fprintf(stderr, "%s    %c", buf.str, end);
+            fprintf(stderr, "%s    %c", buf, end);
         } else
-            av_log(NULL, AV_LOG_INFO, "%s    %c", buf.str, end);
+            av_log(NULL, AV_LOG_INFO, "%s    %c", buf, end);
 
     fflush(stderr);
     }
-    av_bprint_finalize(&buf, NULL);
 
     if (progress_avio) {
         av_bprintf(&buf_script, "progress=%s\n",
@@ -1830,19 +1835,6 @@ static void print_report(int is_last_report, int64_t timer_start, int64_t cur_ti
         print_final_stats(total_size);
 }
 
-static void ifilter_parameters_from_codecpar(InputFilter *ifilter, AVCodecParameters *par)
-{
-    // We never got any input. Set a fake format, which will
-    // come from libavformat.
-    ifilter->format                 = par->format;
-    ifilter->sample_rate            = par->sample_rate;
-    ifilter->channels               = par->channels;
-    ifilter->channel_layout         = par->channel_layout;
-    ifilter->width                  = par->width;
-    ifilter->height                 = par->height;
-    ifilter->sample_aspect_ratio    = par->sample_aspect_ratio;
-}
-
 static void flush_encoders(void)
 {
     int i, ret;
@@ -1869,8 +1861,18 @@ static void flush_encoders(void)
                 int x;
                 for (x = 0; x < fg->nb_inputs; x++) {
                     InputFilter *ifilter = fg->inputs[x];
-                    if (ifilter->format < 0)
-                        ifilter_parameters_from_codecpar(ifilter, ifilter->ist->st->codecpar);
+                    if (ifilter->format < 0) {
+                        AVCodecParameters *par = ifilter->ist->st->codecpar;
+                        // We never got any input. Set a fake format, which will
+                        // come from libavformat.
+                        ifilter->format                 = par->format;
+                        ifilter->sample_rate            = par->sample_rate;
+                        ifilter->channels               = par->channels;
+                        ifilter->channel_layout         = par->channel_layout;
+                        ifilter->width                  = par->width;
+                        ifilter->height                 = par->height;
+                        ifilter->sample_aspect_ratio    = par->sample_aspect_ratio;
+                    }
                 }
 
                 if (!ifilter_has_all_input_formats(fg))
@@ -1895,6 +1897,10 @@ static void flush_encoders(void)
 
         if (enc->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
             continue;
+#if FF_API_LAVF_FMT_RAWPICTURE
+        if (enc->codec_type == AVMEDIA_TYPE_VIDEO && (of->ctx->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == AV_CODEC_ID_RAWVIDEO)
+            continue;
+#endif
 
         if (enc->codec_type != AVMEDIA_TYPE_VIDEO && enc->codec_type != AVMEDIA_TYPE_AUDIO)
             continue;
@@ -1985,16 +1991,11 @@ static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *p
     InputFile   *f = input_files [ist->file_index];
     int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
     int64_t ost_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ost->mux_timebase);
-    AVPacket opkt = { 0 };
+    AVPicture pict;
+    AVPacket opkt;
 
     av_init_packet(&opkt);
 
-    // EOF: flush output bitstream filters.
-    if (!pkt) {
-        output_packet(of, &opkt, ost, 1);
-        return;
-    }
-
     if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
         !ost->copy_initial_nonkeyframes)
         return;
@@ -2052,17 +2053,49 @@ static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *p
     opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->mux_timebase);
 
     opkt.flags    = pkt->flags;
-
-    if (pkt->buf) {
-        opkt.buf = av_buffer_ref(pkt->buf);
-        if (!opkt.buf)
+    // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
+    if (  ost->st->codecpar->codec_id != AV_CODEC_ID_H264
+       && ost->st->codecpar->codec_id != AV_CODEC_ID_MPEG1VIDEO
+       && ost->st->codecpar->codec_id != AV_CODEC_ID_MPEG2VIDEO
+       && ost->st->codecpar->codec_id != AV_CODEC_ID_VC1
+       ) {
+        int ret = av_parser_change(ost->parser, ost->parser_avctx,
+                             &opkt.data, &opkt.size,
+                             pkt->data, pkt->size,
+                             pkt->flags & AV_PKT_FLAG_KEY);
+        if (ret < 0) {
+            av_log(NULL, AV_LOG_FATAL, "av_parser_change failed: %s\n",
+                   av_err2str(ret));
             exit_program(1);
+        }
+        if (ret) {
+            opkt.buf = av_buffer_create(opkt.data, opkt.size, av_buffer_default_free, NULL, 0);
+            if (!opkt.buf)
+                exit_program(1);
+        }
+    } else {
+        opkt.data = pkt->data;
+        opkt.size = pkt->size;
     }
-    opkt.data = pkt->data;
-    opkt.size = pkt->size;
-
     av_copy_packet_side_data(&opkt, pkt);
 
+#if FF_API_LAVF_FMT_RAWPICTURE
+    if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
+        ost->st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO &&
+        (of->ctx->oformat->flags & AVFMT_RAWPICTURE)) {
+        /* store AVPicture in AVPacket, as expected by the output format */
+        int ret = avpicture_fill(&pict, opkt.data, ost->st->codecpar->format, ost->st->codecpar->width, ost->st->codecpar->height);
+        if (ret < 0) {
+            av_log(NULL, AV_LOG_FATAL, "avpicture_fill failed: %s\n",
+                   av_err2str(ret));
+            exit_program(1);
+        }
+        opkt.data = (uint8_t *)&pict;
+        opkt.size = sizeof(AVPicture);
+        opkt.flags |= AV_PKT_FLAG_KEY;
+    }
+#endif
+
     output_packet(of, &opkt, ost, 0);
 }
 
@@ -2096,7 +2129,7 @@ static void check_decode_result(InputStream *ist, int *got_output, int ret)
 
     if (exit_on_error && *got_output && ist) {
         if (ist->decoded_frame->decode_error_flags || (ist->decoded_frame->flags & AV_FRAME_FLAG_CORRUPT)) {
-            av_log(NULL, AV_LOG_FATAL, "%s: corrupt decoded frame in stream %d\n", input_files[ist->file_index]->ctx->url, ist->st->index);
+            av_log(NULL, AV_LOG_FATAL, "%s: corrupt decoded frame in stream %d\n", input_files[ist->file_index]->ctx->filename, ist->st->index);
             exit_program(1);
         }
     }
@@ -2166,7 +2199,10 @@ static int ifilter_send_frame(InputFilter *ifilter, AVFrame *frame)
 
         ret = reap_filters(1);
         if (ret < 0 && ret != AVERROR_EOF) {
-            av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", av_err2str(ret));
+            char errbuf[128];
+            av_strerror(ret, errbuf, sizeof(errbuf));
+
+            av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", errbuf);
             return ret;
         }
 
@@ -2189,7 +2225,7 @@ static int ifilter_send_frame(InputFilter *ifilter, AVFrame *frame)
 
 static int ifilter_send_eof(InputFilter *ifilter, int64_t pts)
 {
-    int ret;
+    int i, j, ret;
 
     ifilter->eof = 1;
 
@@ -2199,11 +2235,16 @@ static int ifilter_send_eof(InputFilter *ifilter, int64_t pts)
             return ret;
     } else {
         // the filtergraph was never configured
-        if (ifilter->format < 0)
-            ifilter_parameters_from_codecpar(ifilter, ifilter->ist->st->codecpar);
-        if (ifilter->format < 0 && (ifilter->type == AVMEDIA_TYPE_AUDIO || ifilter->type == AVMEDIA_TYPE_VIDEO)) {
-            av_log(NULL, AV_LOG_ERROR, "Cannot determine format of input stream %d:%d after EOF\n", ifilter->ist->file_index, ifilter->ist->st->index);
-            return AVERROR_INVALIDDATA;
+        FilterGraph *fg = ifilter->graph;
+        for (i = 0; i < fg->nb_inputs; i++)
+            if (!fg->inputs[i]->eof)
+                break;
+        if (i == fg->nb_inputs) {
+            // All the input streams have finished without the filtergraph
+            // ever being configured.
+            // Mark the output streams as finished.
+            for (j = 0; j < fg->nb_outputs; j++)
+                finish_output_stream(fg->outputs[j]->ost);
         }
     }
 
@@ -2692,7 +2733,7 @@ static int process_input_packet(InputStream *ist, const AVPacket *pkt, int no_eo
     }
 
     /* handle stream copy */
-    if (!ist->decoding_needed && pkt) {
+    if (!ist->decoding_needed) {
         ist->dts = ist->next_dts;
         switch (ist->dec_ctx->codec_type) {
         case AVMEDIA_TYPE_AUDIO:
@@ -2722,7 +2763,7 @@ static int process_input_packet(InputStream *ist, const AVPacket *pkt, int no_eo
         ist->pts = ist->dts;
         ist->next_pts = ist->next_dts;
     }
-    for (i = 0; i < nb_output_streams; i++) {
+    for (i = 0; pkt && i < nb_output_streams; i++) {
         OutputStream *ost = output_streams[i];
 
         if (!check_output_constraints(ist, ost) || ost->encoding_needed)
@@ -2779,77 +2820,44 @@ fail:
     av_freep(&avc);
 }
 
+static const HWAccel *get_hwaccel(enum AVPixelFormat pix_fmt)
+{
+    int i;
+    for (i = 0; hwaccels[i].name; i++)
+        if (hwaccels[i].pix_fmt == pix_fmt)
+            return &hwaccels[i];
+    return NULL;
+}
+
 static enum AVPixelFormat get_format(AVCodecContext *s, const enum AVPixelFormat *pix_fmts)
 {
     InputStream *ist = s->opaque;
     const enum AVPixelFormat *p;
     int ret;
 
-    for (p = pix_fmts; *p != AV_PIX_FMT_NONE; p++) {
+    for (p = pix_fmts; *p != -1; p++) {
         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(*p);
-        const AVCodecHWConfig  *config = NULL;
-        int i;
+        const HWAccel *hwaccel;
 
         if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
             break;
 
-        if (ist->hwaccel_id == HWACCEL_GENERIC ||
-            ist->hwaccel_id == HWACCEL_AUTO) {
-            for (i = 0;; i++) {
-                config = avcodec_get_hw_config(s->codec, i);
-                if (!config)
-                    break;
-                if (!(config->methods &
-                      AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX))
-                    continue;
-                if (config->pix_fmt == *p)
-                    break;
-            }
-        }
-        if (config) {
-            if (config->device_type != ist->hwaccel_device_type) {
-                // Different hwaccel offered, ignore.
-                continue;
-            }
+        hwaccel = get_hwaccel(*p);
+        if (!hwaccel ||
+            (ist->active_hwaccel_id && ist->active_hwaccel_id != hwaccel->id) ||
+            (ist->hwaccel_id != HWACCEL_AUTO && ist->hwaccel_id != hwaccel->id))
+            continue;
 
-            ret = hwaccel_decode_init(s);
-            if (ret < 0) {
-                if (ist->hwaccel_id == HWACCEL_GENERIC) {
-                    av_log(NULL, AV_LOG_FATAL,
-                           "%s hwaccel requested for input stream #%d:%d, "
-                           "but cannot be initialized.\n",
-                           av_hwdevice_get_type_name(config->device_type),
-                           ist->file_index, ist->st->index);
-                    return AV_PIX_FMT_NONE;
-                }
-                continue;
-            }
-        } else {
-            const HWAccel *hwaccel = NULL;
-            int i;
-            for (i = 0; hwaccels[i].name; i++) {
-                if (hwaccels[i].pix_fmt == *p) {
-                    hwaccel = &hwaccels[i];
-                    break;
-                }
-            }
-            if (!hwaccel) {
-                // No hwaccel supporting this pixfmt.
-                continue;
-            }
-            if (hwaccel->id != ist->hwaccel_id) {
-                // Does not match requested hwaccel.
-                continue;
-            }
-
-            ret = hwaccel->init(s);
-            if (ret < 0) {
+        ret = hwaccel->init(s);
+        if (ret < 0) {
+            if (ist->hwaccel_id == hwaccel->id) {
                 av_log(NULL, AV_LOG_FATAL,
                        "%s hwaccel requested for input stream #%d:%d, "
                        "but cannot be initialized.\n", hwaccel->name,
                        ist->file_index, ist->st->index);
                 return AV_PIX_FMT_NONE;
             }
+            continue;
         }
 
         if (ist->hw_frames_ctx) {
@@ -2858,7 +2866,8 @@ static enum AVPixelFormat get_format(AVCodecContext *s, const enum AVPixelFormat
                 return AV_PIX_FMT_NONE;
         }
 
-        ist->hwaccel_pix_fmt = *p;
+        ist->active_hwaccel_id = hwaccel->id;
+        ist->hwaccel_pix_fmt   = *p;
         break;
     }
 
@@ -2905,7 +2914,7 @@ static int init_input_stream(int ist_index, char *error, int error_len)
 
         /* Useful for subtitles retiming by lavf (FIXME), skipping samples in
          * audio, and video decoders such as cuvid or mediacodec */
-        ist->dec_ctx->pkt_timebase = ist->st->time_base;
+        av_codec_set_pkt_timebase(ist->dec_ctx, ist->st->time_base);
 
         if (!av_dict_get(ist->decoder_opts, "threads", NULL, 0))
             av_dict_set(&ist->decoder_opts, "threads", "auto", 0);
@@ -2976,7 +2985,7 @@ static int check_init_output_file(OutputFile *of, int file_index)
     //assert_avoptions(of->opts);
     of->header_written = 1;
 
-    av_dump_format(of->ctx, file_index, of->ctx->url, 1);
+    av_dump_format(of->ctx, file_index, of->ctx->filename, 1);
 
     if (sdp_filename || want_sdp)
         print_sdp();
@@ -3109,6 +3118,11 @@ static int init_output_stream_streamcopy(OutputStream *ost)
             av_display_rotation_set((int32_t *)sd, -ost->rotate_override_value);
     }
 
+    ost->parser = av_parser_init(par_dst->codec_id);
+    ost->parser_avctx = avcodec_alloc_context3(NULL);
+    if (!ost->parser_avctx)
+        return AVERROR(ENOMEM);
+
     switch (par_dst->codec_type) {
     case AVMEDIA_TYPE_AUDIO:
         if (audio_volume != 256) {
@@ -3150,7 +3164,7 @@ static void set_encoder_id(OutputFile *of, OutputStream *ost)
     uint8_t *encoder_string;
     int encoder_string_len;
     int format_flags = 0;
-    int codec_flags = ost->enc_ctx->flags;
+    int codec_flags = 0;
 
     if (av_dict_get(ost->st->metadata, "encoder",  NULL, 0))
         return;
@@ -3484,8 +3498,7 @@ static int init_output_stream(OutputStream *ost, char *error, int error_len)
             av_buffersink_set_frame_size(ost->filter->filter,
                                             ost->enc_ctx->frame_size);
         assert_avoptions(ost->encoder_opts);
-        if (ost->enc_ctx->bit_rate && ost->enc_ctx->bit_rate < 1000 &&
-            ost->enc_ctx->codec_id != AV_CODEC_ID_CODEC2 /* don't complain about 700 bit/s modes */)
+        if (ost->enc_ctx->bit_rate && ost->enc_ctx->bit_rate < 1000)
             av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
                                          " It takes bits/s as argument, not kbits/s\n");
 
@@ -3549,6 +3562,14 @@ static int init_output_stream(OutputStream *ost, char *error, int error_len)
         ret = init_output_stream_streamcopy(ost);
         if (ret < 0)
             return ret;
+
+        /*
+         * FIXME: will the codec context used by the parser during streamcopy
+         * This should go away with the new parser API.
+         */
+        ret = avcodec_parameters_to_context(ost->parser_avctx, ost->st->codecpar);
+        if (ret < 0)
+            return ret;
     }
 
     // parse user provided disposition, and update stream values
@@ -3565,10 +3586,8 @@ static int init_output_stream(OutputStream *ost, char *error, int error_len)
             { "hearing_impaired"    , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_HEARING_IMPAIRED  },    .unit = "flags" },
             { "visual_impaired"     , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_VISUAL_IMPAIRED   },    .unit = "flags" },
             { "clean_effects"       , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CLEAN_EFFECTS     },    .unit = "flags" },
-            { "attached_pic"        , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_ATTACHED_PIC      },    .unit = "flags" },
             { "captions"            , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CAPTIONS          },    .unit = "flags" },
             { "descriptions"        , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DESCRIPTIONS      },    .unit = "flags" },
-            { "dependent"           , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DEPENDENT         },    .unit = "flags" },
             { "metadata"            , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_METADATA          },    .unit = "flags" },
             { NULL },
         };
@@ -3973,7 +3992,7 @@ static int check_keyboard_interaction(int64_t cur_time)
     return 0;
 }
 
-#if HAVE_THREADS
+#if HAVE_PTHREADS
 static void *input_thread(void *arg)
 {
     InputFile *f = arg;
@@ -4083,7 +4102,7 @@ static int get_input_packet(InputFile *f, AVPacket *pkt)
         }
     }
 
-#if HAVE_THREADS
+#if HAVE_PTHREADS
     if (nb_input_files > 1)
         return get_input_packet_mt(f, pkt);
 #endif
@@ -4143,6 +4162,12 @@ static int seek_to_start(InputFile *ifile, AVFormatContext *is)
         ist   = input_streams[ifile->ist_index + i];
         avctx = ist->dec_ctx;
 
+        // flush decoders
+        if (ist->decoding_needed) {
+            process_input_packet(ist, NULL, 1);
+            avcodec_flush_buffers(avctx);
+        }
+
         /* duration is the length of the last frame in a stream
          * when audio stream is present we don't care about
          * last video frame length because it's not defined exactly */
@@ -4159,17 +4184,14 @@ static int seek_to_start(InputFile *ifile, AVFormatContext *is)
                 AVRational sample_rate = {1, avctx->sample_rate};
 
                 duration = av_rescale_q(ist->nb_samples, sample_rate, ist->st->time_base);
-            } else {
+            } else
                 continue;
-            }
         } else {
             if (ist->framerate.num) {
-                duration = av_rescale_q(1, av_inv_q(ist->framerate), ist->st->time_base);
+                duration = av_rescale_q(1, ist->framerate, ist->st->time_base);
             } else if (ist->st->avg_frame_rate.num) {
-                duration = av_rescale_q(1, av_inv_q(ist->st->avg_frame_rate), ist->st->time_base);
-            } else {
-                duration = 1;
-            }
+                duration = av_rescale_q(1, ist->st->avg_frame_rate, ist->st->time_base);
+            } else duration = 1;
         }
         if (!ifile->duration)
             ifile->time_base = ist->st->time_base;
@@ -4211,22 +4233,9 @@ static int process_input(int file_index)
         return ret;
     }
     if (ret < 0 && ifile->loop) {
-        AVCodecContext *avctx;
-        for (i = 0; i < ifile->nb_streams; i++) {
-            ist = input_streams[ifile->ist_index + i];
-            avctx = ist->dec_ctx;
-            if (ist->decoding_needed) {
-                ret = process_input_packet(ist, NULL, 1);
-                if (ret>0)
-                    return 0;
-                avcodec_flush_buffers(avctx);
-            }
-        }
-        ret = seek_to_start(ifile, is);
-        if (ret < 0)
-            av_log(NULL, AV_LOG_WARNING, "Seek to start failed.\n");
-        else
-            ret = get_input_packet(ifile, &pkt);
+        if ((ret = seek_to_start(ifile, is)) < 0)
+            return ret;
+        ret = get_input_packet(ifile, &pkt);
         if (ret == AVERROR(EAGAIN)) {
             ifile->eagain = 1;
             return ret;
@@ -4234,7 +4243,7 @@ static int process_input(int file_index)
     }
     if (ret < 0) {
         if (ret != AVERROR_EOF) {
-            print_error(is->url, ret);
+            print_error(is->filename, ret);
             if (exit_on_error)
                 exit_program(1);
         }
@@ -4283,7 +4292,7 @@ static int process_input(int file_index)
         goto discard_packet;
 
     if (exit_on_error && (pkt.flags & AV_PKT_FLAG_CORRUPT)) {
-        av_log(NULL, AV_LOG_FATAL, "%s: corrupt input packet in stream %d\n", is->url, pkt.stream_index);
+        av_log(NULL, AV_LOG_FATAL, "%s: corrupt input packet in stream %d\n", is->filename, pkt.stream_index);
         exit_program(1);
     }
 
@@ -4597,7 +4606,7 @@ static int transcode(void)
 
     timer_start = av_gettime_relative();
 
-#if HAVE_THREADS
+#if HAVE_PTHREADS
     if ((ret = init_input_threads()) < 0)
         goto fail;
 #endif
@@ -4618,21 +4627,24 @@ static int transcode(void)
 
         ret = transcode_step();
         if (ret < 0 && ret != AVERROR_EOF) {
-            av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", av_err2str(ret));
+            char errbuf[128];
+            av_strerror(ret, errbuf, sizeof(errbuf));
+
+            av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", errbuf);
             break;
         }
 
         /* dump report by using the output first video and audio streams */
         print_report(0, timer_start, cur_time);
     }
-#if HAVE_THREADS
+#if HAVE_PTHREADS
     free_input_threads();
 #endif
 
     /* at the end of stream, we must flush the decoder buffers */
     for (i = 0; i < nb_input_streams; i++) {
         ist = input_streams[i];
-        if (!input_files[ist->file_index]->eof_reached) {
+        if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
             process_input_packet(ist, NULL, 0);
         }
     }
@@ -4647,11 +4659,11 @@ static int transcode(void)
             av_log(NULL, AV_LOG_ERROR,
                    "Nothing was written into output file %d (%s), because "
                    "at least one of its streams received no packets.\n",
-                   i, os->url);
+                   i, os->filename);
             continue;
         }
         if ((ret = av_write_trailer(os)) < 0) {
-            av_log(NULL, AV_LOG_ERROR, "Error writing trailer of %s: %s\n", os->url, av_err2str(ret));
+            av_log(NULL, AV_LOG_ERROR, "Error writing trailer of %s: %s\n", os->filename, av_err2str(ret));
             if (exit_on_error)
                 exit_program(1);
         }
@@ -4691,7 +4703,7 @@ static int transcode(void)
     ret = 0;
 
  fail:
-#if HAVE_THREADS
+#if HAVE_PTHREADS
     free_input_threads();
 #endif
 
@@ -4781,9 +4793,12 @@ int main(int argc, char **argv)
         argv++;
     }
 
+    avcodec_register_all();
 #if CONFIG_AVDEVICE
     avdevice_register_all();
 #endif
+    avfilter_register_all();
+    av_register_all();
     avformat_network_init();
 
     show_banner(argc, argv, options);

fftools/ffmpeg.h

@@ -25,6 +25,10 @@
 #include <stdio.h>
 #include <signal.h>
 
+#if HAVE_PTHREADS
+#include <pthread.h>
+#endif
+
 #include "cmdutils.h"
 
 #include "libavformat/avformat.h"
@@ -41,7 +45,6 @@
 #include "libavutil/hwcontext.h"
 #include "libavutil/pixfmt.h"
 #include "libavutil/rational.h"
-#include "libavutil/thread.h"
 #include "libavutil/threadmessage.h"
 
 #include "libswresample/swresample.h"
@@ -58,10 +61,14 @@
 enum HWAccelID {
     HWACCEL_NONE = 0,
     HWACCEL_AUTO,
-    HWACCEL_GENERIC,
+    HWACCEL_VDPAU,
+    HWACCEL_DXVA2,
+    HWACCEL_VDA,
     HWACCEL_VIDEOTOOLBOX,
     HWACCEL_QSV,
+    HWACCEL_VAAPI,
     HWACCEL_CUVID,
+    HWACCEL_D3D11VA,
 };
 
 typedef struct HWAccel {
@@ -69,6 +76,7 @@ typedef struct HWAccel {
     int (*init)(AVCodecContext *s);
     enum HWAccelID id;
     enum AVPixelFormat pix_fmt;
+    enum AVHWDeviceType device_type;
 } HWAccel;
 
 typedef struct HWDevice {
@@ -153,7 +161,6 @@ typedef struct OptionsContext {
     float mux_preload;
     float mux_max_delay;
     int shortest;
-    int bitexact;
 
     int video_disable;
     int audio_disable;
@@ -362,11 +369,11 @@ typedef struct InputStream {
 
     /* hwaccel options */
     enum HWAccelID hwaccel_id;
-    enum AVHWDeviceType hwaccel_device_type;
     char  *hwaccel_device;
     enum AVPixelFormat hwaccel_output_format;
 
     /* hwaccel context */
+    enum HWAccelID active_hwaccel_id;
     void  *hwaccel_ctx;
     void (*hwaccel_uninit)(AVCodecContext *s);
     int  (*hwaccel_get_buffer)(AVCodecContext *s, AVFrame *frame, int flags);
@@ -412,7 +419,7 @@ typedef struct InputFile {
     int rate_emu;
     int accurate_seek;
 
-#if HAVE_THREADS
+#if HAVE_PTHREADS
     AVThreadMessageQueue *in_thread_queue;
     pthread_t thread;           /* thread reading from this file */
     int non_blocking;           /* reading packets from the thread should not block */
@@ -526,6 +533,9 @@ typedef struct OutputStream {
 
     int keep_pix_fmt;
 
+    AVCodecParserContext *parser;
+    AVCodecContext       *parser_avctx;
+
     /* stats */
     // combined size of all the packets written
     uint64_t data_size;
@@ -614,6 +624,7 @@ extern const AVIOInterruptCB int_cb;
 
 extern const OptionDef options[];
 extern const HWAccel hwaccels[];
+extern int hwaccel_lax_profile_check;
 extern AVBufferRef *hw_device_ctx;
 #if CONFIG_QSV
 extern char *qsv_device;
@@ -651,6 +662,7 @@ int ifilter_parameters_from_frame(InputFilter *ifilter, const AVFrame *frame);
 
 int ffmpeg_parse_options(int argc, char **argv);
 
+int vda_init(AVCodecContext *s);
 int videotoolbox_init(AVCodecContext *s);
 int qsv_init(AVCodecContext *s);
 int cuvid_init(AVCodecContext *s);

fftools/ffmpeg_filter.c

@@ -340,7 +340,6 @@ int init_complex_filtergraph(FilterGraph *fg)
     graph = avfilter_graph_alloc();
     if (!graph)
         return AVERROR(ENOMEM);
-    graph->nb_threads = 1;
 
     ret = avfilter_graph_parse2(graph, fg->graph_desc, &inputs, &outputs);
     if (ret < 0)

fftools/ffmpeg_hw.c

@@ -64,31 +64,6 @@ static HWDevice *hw_device_add(void)
     return hw_devices[nb_hw_devices++];
 }
 
-static char *hw_device_default_name(enum AVHWDeviceType type)
-{
-    // Make an automatic name of the form "type%d".  We arbitrarily
-    // limit at 1000 anonymous devices of the same type - there is
-    // probably something else very wrong if you get to this limit.
-    const char *type_name = av_hwdevice_get_type_name(type);
-    char *name;
-    size_t index_pos;
-    int index, index_limit = 1000;
-    index_pos = strlen(type_name);
-    name = av_malloc(index_pos + 4);
-    if (!name)
-        return NULL;
-    for (index = 0; index < index_limit; index++) {
-        snprintf(name, index_pos + 4, "%s%d", type_name, index);
-        if (!hw_device_get_by_name(name))
-            break;
-    }
-    if (index >= index_limit) {
-        av_freep(&name);
-        return NULL;
-    }
-    return name;
-}
-
 int hw_device_init_from_string(const char *arg, HWDevice **dev_out)
 {
     // "type=name:device,key=value,key2=value2"
@@ -136,11 +111,27 @@ int hw_device_init_from_string(const char *arg, HWDevice **dev_out)
 
         p += 1 + k;
     } else {
-        name = hw_device_default_name(type);
+        // Give the device an automatic name of the form "type%d".
+        // We arbitrarily limit at 1000 anonymous devices of the same
+        // type - there is probably something else very wrong if you
+        // get to this limit.
+        size_t index_pos;
+        int index, index_limit = 1000;
+        index_pos = strlen(type_name);
+        name = av_malloc(index_pos + 4);
         if (!name) {
             err = AVERROR(ENOMEM);
             goto fail;
         }
+        for (index = 0; index < index_limit; index++) {
+            snprintf(name, index_pos + 4, "%s%d", type_name, index);
+            if (!hw_device_get_by_name(name))
+                break;
+        }
+        if (index >= index_limit) {
+            errmsg = "too many devices";
+            goto invalid;
+        }
     }
 
     if (!*p) {
@@ -223,49 +214,6 @@ fail:
     goto done;
 }
 
-static int hw_device_init_from_type(enum AVHWDeviceType type,
-                                    const char *device,
-                                    HWDevice **dev_out)
-{
-    AVBufferRef *device_ref = NULL;
-    HWDevice *dev;
-    char *name;
-    int err;
-
-    name = hw_device_default_name(type);
-    if (!name) {
-        err = AVERROR(ENOMEM);
-        goto fail;
-    }
-
-    err = av_hwdevice_ctx_create(&device_ref, type, device, NULL, 0);
-    if (err < 0) {
-        av_log(NULL, AV_LOG_ERROR,
-               "Device creation failed: %d.\n", err);
-        goto fail;
-    }
-
-    dev = hw_device_add();
-    if (!dev) {
-        err = AVERROR(ENOMEM);
-        goto fail;
-    }
-
-    dev->name = name;
-    dev->type = type;
-    dev->device_ref = device_ref;
-
-    if (dev_out)
-        *dev_out = dev;
-
-    return 0;
-
-fail:
-    av_freep(&name);
-    av_buffer_unref(&device_ref);
-    return err;
-}
-
 void hw_device_free_all(void)
 {
     int i;
@@ -278,130 +226,80 @@ void hw_device_free_all(void)
     nb_hw_devices = 0;
 }
 
-static HWDevice *hw_device_match_by_codec(const AVCodec *codec)
+static enum AVHWDeviceType hw_device_match_type_by_hwaccel(enum HWAccelID hwaccel_id)
 {
-    const AVCodecHWConfig *config;
-    HWDevice *dev;
     int i;
-    for (i = 0;; i++) {
-        config = avcodec_get_hw_config(codec, i);
-        if (!config)
-            return NULL;
-        if (!(config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX))
-            continue;
-        dev = hw_device_get_by_type(config->device_type);
-        if (dev)
-            return dev;
+    if (hwaccel_id == HWACCEL_NONE)
+        return AV_HWDEVICE_TYPE_NONE;
+    for (i = 0; hwaccels[i].name; i++) {
+        if (hwaccels[i].id == hwaccel_id)
+            return hwaccels[i].device_type;
     }
+    return AV_HWDEVICE_TYPE_NONE;
+}
+
+static enum AVHWDeviceType hw_device_match_type_in_name(const char *codec_name)
+{
+    const char *type_name;
+    enum AVHWDeviceType type;
+    for (type = av_hwdevice_iterate_types(AV_HWDEVICE_TYPE_NONE);
+         type != AV_HWDEVICE_TYPE_NONE;
+         type = av_hwdevice_iterate_types(type)) {
+        type_name = av_hwdevice_get_type_name(type);
+        if (strstr(codec_name, type_name))
+            return type;
+    }
+    return AV_HWDEVICE_TYPE_NONE;
 }
 
 int hw_device_setup_for_decode(InputStream *ist)
 {
-    const AVCodecHWConfig *config;
     enum AVHWDeviceType type;
-    HWDevice *dev = NULL;
-    int err, auto_device = 0;
+    HWDevice *dev;
+    int err;
 
     if (ist->hwaccel_device) {
         dev = hw_device_get_by_name(ist->hwaccel_device);
         if (!dev) {
-            if (ist->hwaccel_id == HWACCEL_AUTO) {
-                auto_device = 1;
-            } else if (ist->hwaccel_id == HWACCEL_GENERIC) {
-                type = ist->hwaccel_device_type;
-                err = hw_device_init_from_type(type, ist->hwaccel_device,
-                                               &dev);
-            } else {
-                // This will be dealt with by API-specific initialisation
-                // (using hwaccel_device), so nothing further needed here.
+            char *tmp;
+            type = hw_device_match_type_by_hwaccel(ist->hwaccel_id);
+            if (type == AV_HWDEVICE_TYPE_NONE) {
+                // No match - this isn't necessarily invalid, though,
+                // because an explicit device might not be needed or
+                // the hwaccel setup could be handled elsewhere.
                 return 0;
             }
-        } else {
-            if (ist->hwaccel_id == HWACCEL_AUTO) {
-                ist->hwaccel_device_type = dev->type;
-            } else if (ist->hwaccel_device_type != dev->type) {
-                av_log(ist->dec_ctx, AV_LOG_ERROR, "Invalid hwaccel device "
-                       "specified for decoder: device %s of type %s is not "
-                       "usable with hwaccel %s.\n", dev->name,
-                       av_hwdevice_get_type_name(dev->type),
-                       av_hwdevice_get_type_name(ist->hwaccel_device_type));
-                return AVERROR(EINVAL);
-            }
+            tmp = av_asprintf("%s:%s", av_hwdevice_get_type_name(type),
+                              ist->hwaccel_device);
+            if (!tmp)
+                return AVERROR(ENOMEM);
+            err = hw_device_init_from_string(tmp, &dev);
+            av_free(tmp);
+            if (err < 0)
+                return err;
         }
     } else {
-        if (ist->hwaccel_id == HWACCEL_AUTO) {
-            auto_device = 1;
-        } else if (ist->hwaccel_id == HWACCEL_GENERIC) {
-            type = ist->hwaccel_device_type;
+        if (ist->hwaccel_id != HWACCEL_NONE)
+            type = hw_device_match_type_by_hwaccel(ist->hwaccel_id);
+        else
+            type = hw_device_match_type_in_name(ist->dec->name);
+        if (type != AV_HWDEVICE_TYPE_NONE) {
             dev = hw_device_get_by_type(type);
-            if (!dev)
-                err = hw_device_init_from_type(type, NULL, &dev);
-        } else {
-            dev = hw_device_match_by_codec(ist->dec);
             if (!dev) {
-                // No device for this codec, but not using generic hwaccel
-                // and therefore may well not need one - ignore.
-                return 0;
-            }
-        }
-    }
-
-    if (auto_device) {
-        int i;
-        if (!avcodec_get_hw_config(ist->dec, 0)) {
-            // Decoder does not support any hardware devices.
-            return 0;
-        }
-        for (i = 0; !dev; i++) {
-            config = avcodec_get_hw_config(ist->dec, i);
-            if (!config)
-                break;
-            type = config->device_type;
-            dev = hw_device_get_by_type(type);
-            if (dev) {
-                av_log(ist->dec_ctx, AV_LOG_INFO, "Using auto "
-                       "hwaccel type %s with existing device %s.\n",
-                       av_hwdevice_get_type_name(type), dev->name);
-            }
-        }
-        for (i = 0; !dev; i++) {
-            config = avcodec_get_hw_config(ist->dec, i);
-            if (!config)
-                break;
-            type = config->device_type;
-            // Try to make a new device of this type.
-            err = hw_device_init_from_type(type, ist->hwaccel_device,
+                hw_device_init_from_string(av_hwdevice_get_type_name(type),
                                            &dev);
-            if (err < 0) {
-                // Can't make a device of this type.
-                continue;
             }
-            if (ist->hwaccel_device) {
-                av_log(ist->dec_ctx, AV_LOG_INFO, "Using auto "
-                       "hwaccel type %s with new device created "
-                       "from %s.\n", av_hwdevice_get_type_name(type),
-                       ist->hwaccel_device);
-            } else {
-                av_log(ist->dec_ctx, AV_LOG_INFO, "Using auto "
-                       "hwaccel type %s with new default device.\n",
-                       av_hwdevice_get_type_name(type));
-            }
-        }
-        if (dev) {
-            ist->hwaccel_device_type = type;
         } else {
-            av_log(ist->dec_ctx, AV_LOG_INFO, "Auto hwaccel "
-                   "disabled: no device found.\n");
-            ist->hwaccel_id = HWACCEL_NONE;
+            // No device required.
             return 0;
         }
     }
 
     if (!dev) {
-        av_log(ist->dec_ctx, AV_LOG_ERROR, "No device available "
-               "for decoder: device type %s needed for codec %s.\n",
+        av_log(ist->dec_ctx, AV_LOG_WARNING, "No device available "
+               "for decoder (device type %s for codec %s).\n",
                av_hwdevice_get_type_name(type), ist->dec->name);
-        return err;
+        return 0;
     }
 
     ist->dec_ctx->hw_device_ctx = av_buffer_ref(dev->device_ref);
@@ -413,16 +311,24 @@ int hw_device_setup_for_decode(InputStream *ist)
 
 int hw_device_setup_for_encode(OutputStream *ost)
 {
+    enum AVHWDeviceType type;
     HWDevice *dev;
 
-    dev = hw_device_match_by_codec(ost->enc);
-    if (dev) {
+    type = hw_device_match_type_in_name(ost->enc->name);
+    if (type != AV_HWDEVICE_TYPE_NONE) {
+        dev = hw_device_get_by_type(type);
+        if (!dev) {
+            av_log(ost->enc_ctx, AV_LOG_WARNING, "No device available "
+                   "for encoder (device type %s for codec %s).\n",
+                   av_hwdevice_get_type_name(type), ost->enc->name);
+            return 0;
+        }
         ost->enc_ctx->hw_device_ctx = av_buffer_ref(dev->device_ref);
         if (!ost->enc_ctx->hw_device_ctx)
             return AVERROR(ENOMEM);
         return 0;
     } else {
-        // No device required, or no device available.
+        // No device required.
         return 0;
     }
 }

fftools/ffmpeg_opt.c

@@ -66,17 +66,41 @@
 }
 
 const HWAccel hwaccels[] = {
+#if HAVE_VDPAU_X11
+    { "vdpau", hwaccel_decode_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU,
+      AV_HWDEVICE_TYPE_VDPAU },
+#endif
+#if CONFIG_D3D11VA
+    { "d3d11va", hwaccel_decode_init, HWACCEL_D3D11VA, AV_PIX_FMT_D3D11,
+      AV_HWDEVICE_TYPE_D3D11VA },
+#endif
+#if CONFIG_DXVA2
+    { "dxva2", hwaccel_decode_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD,
+      AV_HWDEVICE_TYPE_DXVA2 },
+#endif
+#if CONFIG_VDA
+    { "vda",   videotoolbox_init,   HWACCEL_VDA,   AV_PIX_FMT_VDA,
+      AV_HWDEVICE_TYPE_NONE },
+#endif
 #if CONFIG_VIDEOTOOLBOX
-    { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
+    { "videotoolbox",   videotoolbox_init,   HWACCEL_VIDEOTOOLBOX,   AV_PIX_FMT_VIDEOTOOLBOX,
+      AV_HWDEVICE_TYPE_NONE },
 #endif
 #if CONFIG_LIBMFX
-    { "qsv",   qsv_init,   HWACCEL_QSV,   AV_PIX_FMT_QSV },
+    { "qsv",   qsv_init,   HWACCEL_QSV,   AV_PIX_FMT_QSV,
+      AV_HWDEVICE_TYPE_NONE },
+#endif
+#if CONFIG_VAAPI
+    { "vaapi", hwaccel_decode_init, HWACCEL_VAAPI, AV_PIX_FMT_VAAPI,
+      AV_HWDEVICE_TYPE_VAAPI },
 #endif
 #if CONFIG_CUVID
-    { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA },
+    { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA,
+      AV_HWDEVICE_TYPE_NONE },
 #endif
     { 0 },
 };
+int hwaccel_lax_profile_check = 0;
 AVBufferRef *hw_device_ctx;
 HWDevice *filter_hw_device;
 
@@ -117,6 +141,7 @@ static int file_overwrite     = 0;
 static int no_file_overwrite  = 0;
 static int do_psnr            = 0;
 static int input_sync;
+static int override_ffserver  = 0;
 static int input_stream_potentially_available = 0;
 static int ignore_unknown_streams = 0;
 static int copy_unknown_streams = 0;
@@ -170,15 +195,12 @@ static void init_options(OptionsContext *o)
 
 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
 {
-    enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
     int i;
 
     printf("Hardware acceleration methods:\n");
-    while ((type = av_hwdevice_iterate_types(type)) !=
-           AV_HWDEVICE_TYPE_NONE)
-        printf("%s\n", av_hwdevice_get_type_name(type));
-    for (i = 0; hwaccels[i].name; i++)
+    for (i = 0; hwaccels[i].name; i++) {
         printf("%s\n", hwaccels[i].name);
+    }
     printf("\n");
     return 0;
 }
@@ -701,8 +723,7 @@ static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
         AVStream *st = ic->streams[i];
         AVCodecParameters *par = st->codecpar;
         InputStream *ist = av_mallocz(sizeof(*ist));
-        char *framerate = NULL, *hwaccel_device = NULL;
-        const char *hwaccel = NULL;
+        char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
         char *hwaccel_output_format = NULL;
         char *codec_tag = NULL;
         char *next;
@@ -766,20 +787,20 @@ static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
             exit_program(1);
         }
 
-        if (o->bitexact)
-            ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
-
         switch (par->codec_type) {
         case AVMEDIA_TYPE_VIDEO:
             if(!ist->dec)
                 ist->dec = avcodec_find_decoder(par->codec_id);
 #if FF_API_LOWRES
-            if (st->codec->lowres) {
-                ist->dec_ctx->lowres = st->codec->lowres;
+            if (av_codec_get_lowres(st->codec)) {
+                av_codec_set_lowres(ist->dec_ctx, av_codec_get_lowres(st->codec));
                 ist->dec_ctx->width  = st->codec->width;
                 ist->dec_ctx->height = st->codec->height;
                 ist->dec_ctx->coded_width  = st->codec->coded_width;
                 ist->dec_ctx->coded_height = st->codec->coded_height;
+#if FF_API_EMU_EDGE
+                ist->dec_ctx->flags |= CODEC_FLAG_EMU_EDGE;
+#endif
             }
 #endif
 
@@ -799,16 +820,11 @@ static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
 
             MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
             if (hwaccel) {
-                // The NVDEC hwaccels use a CUDA device, so remap the name here.
-                if (!strcmp(hwaccel, "nvdec"))
-                    hwaccel = "cuda";
-
                 if (!strcmp(hwaccel, "none"))
                     ist->hwaccel_id = HWACCEL_NONE;
                 else if (!strcmp(hwaccel, "auto"))
                     ist->hwaccel_id = HWACCEL_AUTO;
                 else {
-                    enum AVHWDeviceType type;
                     int i;
                     for (i = 0; hwaccels[i].name; i++) {
                         if (!strcmp(hwaccels[i].name, hwaccel)) {
@@ -817,23 +833,10 @@ static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
                         }
                     }
 
-                    if (!ist->hwaccel_id) {
-                        type = av_hwdevice_find_type_by_name(hwaccel);
-                        if (type != AV_HWDEVICE_TYPE_NONE) {
-                            ist->hwaccel_id = HWACCEL_GENERIC;
-                            ist->hwaccel_device_type = type;
-                        }
-                    }
-
                     if (!ist->hwaccel_id) {
                         av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
                                hwaccel);
                         av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
-                        type = AV_HWDEVICE_TYPE_NONE;
-                        while ((type = av_hwdevice_iterate_types(type)) !=
-                               AV_HWDEVICE_TYPE_NONE)
-                            av_log(NULL, AV_LOG_FATAL, "%s ",
-                                   av_hwdevice_get_type_name(type));
                         for (i = 0; hwaccels[i].name; i++)
                             av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
                         av_log(NULL, AV_LOG_FATAL, "\n");
@@ -974,21 +977,6 @@ static int open_input_file(OptionsContext *o, const char *filename)
     char *    data_codec_name = NULL;
     int scan_all_pmts_set = 0;
 
-    if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
-        o->stop_time = INT64_MAX;
-        av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
-    }
-
-    if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
-        int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
-        if (o->stop_time <= start_time) {
-            av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
-            exit_program(1);
-        } else {
-            o->recording_time = o->stop_time - start_time;
-        }
-    }
-
     if (o->format) {
         if (!(file_iformat = av_find_input_format(o->format))) {
             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
@@ -1008,6 +996,7 @@ static int open_input_file(OptionsContext *o, const char *filename)
         print_error(filename, AVERROR(ENOMEM));
         exit_program(1);
     }
+    ic->flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
     if (o->nb_audio_sample_rate) {
         av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
     }
@@ -1042,23 +1031,25 @@ static int open_input_file(OptionsContext *o, const char *filename)
     MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
     MATCH_PER_TYPE_OPT(codec_names, str,     data_codec_name, ic, "d");
 
-    if (video_codec_name)
-        ic->video_codec    = find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0);
-    if (audio_codec_name)
-        ic->audio_codec    = find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0);
-    if (subtitle_codec_name)
-        ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
-    if (data_codec_name)
-        ic->data_codec     = find_codec_or_die(data_codec_name    , AVMEDIA_TYPE_DATA    , 0);
+    ic->video_codec_id   = video_codec_name ?
+        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0)->id : AV_CODEC_ID_NONE;
+    ic->audio_codec_id   = audio_codec_name ?
+        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0)->id : AV_CODEC_ID_NONE;
+    ic->subtitle_codec_id= subtitle_codec_name ?
+        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
+    ic->data_codec_id    = data_codec_name ?
+        find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
 
-    ic->video_codec_id     = video_codec_name    ? ic->video_codec->id    : AV_CODEC_ID_NONE;
-    ic->audio_codec_id     = audio_codec_name    ? ic->audio_codec->id    : AV_CODEC_ID_NONE;
-    ic->subtitle_codec_id  = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
-    ic->data_codec_id      = data_codec_name     ? ic->data_codec->id     : AV_CODEC_ID_NONE;
+    if (video_codec_name)
+        av_format_set_video_codec   (ic, find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0));
+    if (audio_codec_name)
+        av_format_set_audio_codec   (ic, find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0));
+    if (subtitle_codec_name)
+        av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
+    if (data_codec_name)
+        av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
 
     ic->flags |= AVFMT_FLAG_NONBLOCK;
-    if (o->bitexact)
-        ic->flags |= AVFMT_FLAG_BITEXACT;
     ic->interrupt_callback = int_cb;
 
     if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
@@ -1160,7 +1151,7 @@ static int open_input_file(OptionsContext *o, const char *filename)
     f->loop = o->loop;
     f->duration = 0;
     f->time_base = (AVRational){ 1, 1 };
-#if HAVE_THREADS
+#if HAVE_PTHREADS
     f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
 #endif
 
@@ -1271,7 +1262,7 @@ static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *o
     if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
         MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
         if (!codec_name) {
-            ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
+            ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
                                                          NULL, ost->st->codecpar->codec_type);
             ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
             if (!ost->enc) {
@@ -1380,10 +1371,6 @@ static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, e
         ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
     }
 
-
-    if (o->bitexact)
-        ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
-
     MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
     if (time_base) {
         AVRational q;
@@ -1676,7 +1663,7 @@ static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, in
                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
                 exit_program(1);
             }
-            video_enc->chroma_intra_matrix = p;
+            av_codec_set_chroma_intra_matrix(video_enc, p);
             parse_matrix_coeffs(p, chroma_intra_matrix);
         }
         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
@@ -1996,6 +1983,57 @@ static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
     return 0;
 }
 
+static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
+{
+    int i, err;
+    AVFormatContext *ic = avformat_alloc_context();
+
+    ic->flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
+    ic->interrupt_callback = int_cb;
+    err = avformat_open_input(&ic, filename, NULL, NULL);
+    if (err < 0)
+        return err;
+    /* copy stream format */
+    for(i=0;i<ic->nb_streams;i++) {
+        AVStream *st;
+        OutputStream *ost;
+        AVCodec *codec;
+        const char *enc_config;
+
+        codec = avcodec_find_encoder(ic->streams[i]->codecpar->codec_id);
+        if (!codec) {
+            av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codecpar->codec_id);
+            return AVERROR(EINVAL);
+        }
+        if (codec->type == AVMEDIA_TYPE_AUDIO)
+            opt_audio_codec(o, "c:a", codec->name);
+        else if (codec->type == AVMEDIA_TYPE_VIDEO)
+            opt_video_codec(o, "c:v", codec->name);
+        ost   = new_output_stream(o, s, codec->type, -1);
+        st    = ost->st;
+
+        avcodec_get_context_defaults3(st->codec, codec);
+        enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
+        if (enc_config) {
+            AVDictionary *opts = NULL;
+            av_dict_parse_string(&opts, enc_config, "=", ",", 0);
+            av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
+            av_dict_free(&opts);
+        }
+
+        if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
+            choose_sample_fmt(st, codec);
+        else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
+            choose_pixel_fmt(st, st->codec, codec, st->codecpar->format);
+        avcodec_copy_context(ost->enc_ctx, st->codec);
+        if (enc_config)
+            av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
+    }
+
+    avformat_close_input(&ic);
+    return err;
+}
+
 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
                                AVFormatContext *oc)
 {
@@ -2054,6 +2092,7 @@ static int open_output_file(OptionsContext *o, const char *filename)
 {
     AVFormatContext *oc;
     int i, j, err;
+    AVOutputFormat *file_oformat;
     OutputFile *of;
     OutputStream *ost;
     InputStream  *ist;
@@ -2102,6 +2141,7 @@ static int open_output_file(OptionsContext *o, const char *filename)
     if (o->recording_time != INT64_MAX)
         oc->duration = o->recording_time;
 
+    file_oformat= oc->oformat;
     oc->interrupt_callback = int_cb;
 
     e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
@@ -2109,10 +2149,6 @@ static int open_output_file(OptionsContext *o, const char *filename)
         const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
         av_opt_eval_flags(oc, o, e->value, &format_flags);
     }
-    if (o->bitexact) {
-        format_flags |= AVFMT_FLAG_BITEXACT;
-        oc->flags    |= AVFMT_FLAG_BITEXACT;
-    }
 
     /* create streams for all unlabeled output pads */
     for (i = 0; i < nb_filtergraphs; i++) {
@@ -2132,7 +2168,47 @@ static int open_output_file(OptionsContext *o, const char *filename)
         }
     }
 
-    if (!o->nb_stream_maps) {
+    /* ffserver seeking with date=... needs a date reference */
+    if (!strcmp(file_oformat->name, "ffm") &&
+        !(format_flags & AVFMT_FLAG_BITEXACT) &&
+        av_strstart(filename, "http:", NULL)) {
+        int err = parse_option(o, "metadata", "creation_time=now", options);
+        if (err < 0) {
+            print_error(filename, err);
+            exit_program(1);
+        }
+    }
+
+    if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
+        av_strstart(filename, "http:", NULL)) {
+        int j;
+        /* special case for files sent to ffserver: we get the stream
+           parameters from ffserver */
+        int err = read_ffserver_streams(o, oc, filename);
+        if (err < 0) {
+            print_error(filename, err);
+            exit_program(1);
+        }
+        for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
+            ost = output_streams[j];
+            for (i = 0; i < nb_input_streams; i++) {
+                ist = input_streams[i];
+                if(ist->st->codecpar->codec_type == ost->st->codecpar->codec_type){
+                    ost->sync_ist= ist;
+                    ost->source_index= i;
+                    if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
+                    if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
+                    ist->discard = 0;
+                    ist->st->discard = ist->user_set_discard;
+                    break;
+                }
+            }
+            if(!ost->sync_ist){
+                av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codecpar->codec_type));
+                exit_program(1);
+            }
+        }
+    } else if (!o->nb_stream_maps) {
         char *subtitle_codec_name = NULL;
         /* pick the "best" stream of each type */
 
@@ -2334,7 +2410,7 @@ loop_end:
 #endif
 
     if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
-        av_dump_format(oc, nb_output_files - 1, oc->url, 1);
+        av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
         av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
         exit_program(1);
     }
@@ -2466,8 +2542,8 @@ loop_end:
 
     /* check filename in case of an image number is expected */
     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
-        if (!av_filename_number_test(oc->url)) {
-            print_error(oc->url, AVERROR(EINVAL));
+        if (!av_filename_number_test(oc->filename)) {
+            print_error(oc->filename, AVERROR(EINVAL));
             exit_program(1);
         }
     }
@@ -3114,7 +3190,7 @@ void show_help_default(const char *opt, const char *arg)
            "    -h      -- print basic options\n"
            "    -h long -- print more options\n"
            "    -h full -- print all options (including all format and codec specific options, very long)\n"
-           "    -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf\n"
+           "    -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
            "    See man %s for detailed description of the options.\n"
            "\n", program_name);
 
@@ -3159,7 +3235,6 @@ void show_help_default(const char *opt, const char *arg)
 #endif
         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
-        show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
     }
 }
 
@@ -3329,7 +3404,7 @@ const OptionDef options[] = {
                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
         "record or transcode \"duration\" seconds of audio/video",
         "duration" },
-    { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
+    { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
         "record or transcode stop time", "time_stop" },
     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
         "set the limit file size in bytes", "limit_size" },
@@ -3397,9 +3472,6 @@ const OptionDef options[] = {
     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
         "finish encoding within shortest input" },
-    { "bitexact",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
-                        OPT_OUTPUT | OPT_INPUT,                      { .off = OFFSET(bitexact) },
-        "bitexact mode" },
     { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
                         OPT_OUTPUT,                                  { .off = OFFSET(apad) },
         "audio pad", "" },
@@ -3458,7 +3530,7 @@ const OptionDef options[] = {
     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
         "print timestamp debugging info" },
     { "max_error_rate",  HAS_ARG | OPT_FLOAT,                        { &max_error_rate },
-        "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
+        "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
     { "discard",        OPT_STRING | HAS_ARG | OPT_SPEC |
                         OPT_INPUT,                                   { .off = OFFSET(discard) },
         "discard", "" },
@@ -3560,7 +3632,7 @@ const OptionDef options[] = {
     { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_output_formats) },
         "select output format used with HW accelerated decoding", "format" },
-#if CONFIG_VIDEOTOOLBOX
+#if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
     { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
 #endif
     { "hwaccels",         OPT_EXIT,                                              { .func_arg = show_hwaccels },
@@ -3568,6 +3640,8 @@ const OptionDef options[] = {
     { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
                           OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
         "automatically insert correct rotate filters" },
+    { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT,                        { &hwaccel_lax_profile_check},
+        "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
 
     /* audio options */
     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
@@ -3625,6 +3699,8 @@ const OptionDef options[] = {
         "set the maximum demux-decode delay", "seconds" },
     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
         "set the initial demux-decode delay", "seconds" },
+    { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
+        "override the options from ffserver", "" },
     { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
         "specify a file in which to print sdp information", "file" },
 

fftools/ffmpeg_videotoolbox.c

@@ -23,7 +23,12 @@
 #endif
 
 #include "libavcodec/avcodec.h"
-#include "libavcodec/videotoolbox.h"
+#if CONFIG_VDA
+#  include "libavcodec/vda.h"
+#endif
+#if CONFIG_VIDEOTOOLBOX
+#  include "libavcodec/videotoolbox.h"
+#endif
 #include "libavutil/imgutils.h"
 #include "ffmpeg.h"
 
@@ -109,7 +114,15 @@ static void videotoolbox_uninit(AVCodecContext *s)
 
     av_frame_free(&vt->tmp_frame);
 
-    av_videotoolbox_default_free(s);
+    if (ist->hwaccel_id == HWACCEL_VIDEOTOOLBOX) {
+#if CONFIG_VIDEOTOOLBOX
+        av_videotoolbox_default_free(s);
+#endif
+    } else {
+#if CONFIG_VDA
+        av_vda_default_free(s);
+#endif
+    }
     av_freep(&ist->hwaccel_ctx);
 }
 
@@ -134,7 +147,8 @@ int videotoolbox_init(AVCodecContext *s)
         goto fail;
     }
 
-    // TODO: reindent
+    if (ist->hwaccel_id == HWACCEL_VIDEOTOOLBOX) {
+#if CONFIG_VIDEOTOOLBOX
         if (!videotoolbox_pixfmt) {
             ret = av_videotoolbox_default_init(s);
         } else {
@@ -152,8 +166,31 @@ int videotoolbox_init(AVCodecContext *s)
             ret = av_videotoolbox_default_init2(s, vtctx);
             CFRelease(pixfmt_str);
         }
+#endif
+    } else {
+#if CONFIG_VDA
+        if (!videotoolbox_pixfmt) {
+            ret = av_vda_default_init(s);
+        } else {
+            AVVDAContext *vdactx = av_vda_alloc_context();
+            CFStringRef pixfmt_str = CFStringCreateWithCString(kCFAllocatorDefault,
+                                                               videotoolbox_pixfmt,
+                                                               kCFStringEncodingUTF8);
+#if HAVE_UTGETOSTYPEFROMSTRING
+            vdactx->cv_pix_fmt_type = UTGetOSTypeFromString(pixfmt_str);
+#else
+            av_log(s, loglevel, "UTGetOSTypeFromString() is not available "
+                   "on this platform, %s pixel format can not be honored from "
+                   "the command line\n", videotoolbox_pixfmt);
+#endif
+            ret = av_vda_default_init2(s, vdactx);
+            CFRelease(pixfmt_str);
+        }
+#endif
+    }
     if (ret < 0) {
-        av_log(NULL, loglevel, "Error creating Videotoolbox decoder.\n");
+        av_log(NULL, loglevel,
+               "Error creating %s decoder.\n", ist->hwaccel_id == HWACCEL_VIDEOTOOLBOX ? "Videotoolbox" : "VDA");
         goto fail;
     }
 

fftools/ffplay.c

@@ -609,7 +609,7 @@ static int decoder_decode_frame(Decoder *d, AVFrame *frame, AVSubtitle *sub) {
                         if (ret >= 0) {
                             AVRational tb = (AVRational){1, frame->sample_rate};
                             if (frame->pts != AV_NOPTS_VALUE)
-                                frame->pts = av_rescale_q(frame->pts, d->avctx->pkt_timebase, tb);
+                                frame->pts = av_rescale_q(frame->pts, av_codec_get_pkt_timebase(d->avctx), tb);
                             else if (d->next_pts != AV_NOPTS_VALUE)
                                 frame->pts = av_rescale_q(d->next_pts, d->next_pts_tb, tb);
                             if (frame->pts != AV_NOPTS_VALUE) {
@@ -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)
@@ -1285,6 +1284,7 @@ static void do_exit(VideoState *is)
         SDL_DestroyRenderer(renderer);
     if (window)
         SDL_DestroyWindow(window);
+    av_lockmgr_register(NULL);
     uninit_opts();
 #if CONFIG_AVFILTER
     av_freep(&vfilters_list);
@@ -2563,7 +2563,7 @@ static int stream_component_open(VideoState *is, int stream_index)
     ret = avcodec_parameters_to_context(avctx, ic->streams[stream_index]->codecpar);
     if (ret < 0)
         goto fail;
-    avctx->pkt_timebase = ic->streams[stream_index]->time_base;
+    av_codec_set_pkt_timebase(avctx, ic->streams[stream_index]->time_base);
 
     codec = avcodec_find_decoder(avctx->codec_id);
 
@@ -2584,15 +2584,22 @@ static int stream_component_open(VideoState *is, int stream_index)
     }
 
     avctx->codec_id = codec->id;
-    if (stream_lowres > codec->max_lowres) {
+    if(stream_lowres > av_codec_get_max_lowres(codec)){
         av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
-                codec->max_lowres);
-        stream_lowres = codec->max_lowres;
+                av_codec_get_max_lowres(codec));
+        stream_lowres = av_codec_get_max_lowres(codec);
     }
-    avctx->lowres = stream_lowres;
+    av_codec_set_lowres(avctx, stream_lowres);
 
+#if FF_API_EMU_EDGE
+    if(stream_lowres) avctx->flags |= CODEC_FLAG_EMU_EDGE;
+#endif
     if (fast)
         avctx->flags2 |= AV_CODEC_FLAG2_FAST;
+#if FF_API_EMU_EDGE
+    if(codec->capabilities & AV_CODEC_CAP_DR1)
+        avctx->flags |= CODEC_FLAG_EMU_EDGE;
+#endif
 
     opts = filter_codec_opts(codec_opts, avctx->codec_id, ic, ic->streams[stream_index], codec);
     if (!av_dict_get(opts, "threads", NULL, 0))
@@ -2713,8 +2720,8 @@ static int is_realtime(AVFormatContext *s)
     )
         return 1;
 
-    if(s->pb && (   !strncmp(s->url, "rtp:", 4)
-                 || !strncmp(s->url, "udp:", 4)
+    if(s->pb && (   !strncmp(s->filename, "rtp:", 4)
+                 || !strncmp(s->filename, "udp:", 4)
                 )
     )
         return 1;
@@ -2929,7 +2936,7 @@ static int read_thread(void *arg)
             ret = avformat_seek_file(is->ic, -1, seek_min, seek_target, seek_max, is->seek_flags);
             if (ret < 0) {
                 av_log(NULL, AV_LOG_ERROR,
-                       "%s: error while seeking\n", is->ic->url);
+                       "%s: error while seeking\n", is->ic->filename);
             } else {
                 if (is->audio_stream >= 0) {
                     packet_queue_flush(&is->audioq);
@@ -3641,6 +3648,27 @@ void show_help_default(const char *opt, const char *arg)
            );
 }
 
+static int lockmgr(void **mtx, enum AVLockOp op)
+{
+   switch(op) {
+      case AV_LOCK_CREATE:
+          *mtx = SDL_CreateMutex();
+          if(!*mtx) {
+              av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
+              return 1;
+          }
+          return 0;
+      case AV_LOCK_OBTAIN:
+          return !!SDL_LockMutex(*mtx);
+      case AV_LOCK_RELEASE:
+          return !!SDL_UnlockMutex(*mtx);
+      case AV_LOCK_DESTROY:
+          SDL_DestroyMutex(*mtx);
+          return 0;
+   }
+   return 1;
+}
+
 /* Called from the main */
 int main(int argc, char **argv)
 {
@@ -3656,6 +3684,10 @@ int main(int argc, char **argv)
 #if CONFIG_AVDEVICE
     avdevice_register_all();
 #endif
+#if CONFIG_AVFILTER
+    avfilter_register_all();
+#endif
+    av_register_all();
     avformat_network_init();
 
     init_opts();
@@ -3698,6 +3730,11 @@ int main(int argc, char **argv)
     SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
     SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
 
+    if (av_lockmgr_register(lockmgr)) {
+        av_log(NULL, AV_LOG_FATAL, "Could not initialize lock manager!\n");
+        do_exit(NULL);
+    }
+
     av_init_packet(&flush_pkt);
     flush_pkt.data = (uint8_t *)&flush_pkt;
 

fftools/ffprobe.c

@@ -2275,8 +2275,7 @@ static av_always_inline int process_frame(WriterContext *w,
             break;
 
         case AVMEDIA_TYPE_SUBTITLE:
-            if (*packet_new)
-                ret = avcodec_decode_subtitle2(dec_ctx, &sub, &got_frame, pkt);
+            ret = avcodec_decode_subtitle2(dec_ctx, &sub, &got_frame, pkt);
             *packet_new = 0;
             break;
         default:
@@ -2371,11 +2370,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;
@@ -2513,15 +2512,13 @@ static int show_stream(WriterContext *w, AVFormatContext *fmt_ctx, int stream_id
     case AVMEDIA_TYPE_VIDEO:
         print_int("width",        par->width);
         print_int("height",       par->height);
-#if FF_API_LAVF_AVCTX
         if (dec_ctx) {
             print_int("coded_width",  dec_ctx->coded_width);
             print_int("coded_height", dec_ctx->coded_height);
         }
-#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,
@@ -2781,7 +2778,7 @@ static int show_format(WriterContext *w, InputFile *ifile)
     int ret = 0;
 
     writer_print_section_header(w, SECTION_ID_FORMAT);
-    print_str_validate("filename", fmt_ctx->url);
+    print_str_validate("filename", fmt_ctx->filename);
     print_int("nb_streams",       fmt_ctx->nb_streams);
     print_int("nb_programs",      fmt_ctx->nb_programs);
     print_str("format_name",      fmt_ctx->iformat->name);
@@ -2795,7 +2792,7 @@ static int show_format(WriterContext *w, InputFile *ifile)
     else           print_str_opt("size", "N/A");
     if (fmt_ctx->bit_rate > 0) print_val    ("bit_rate", fmt_ctx->bit_rate, unit_bit_per_second_str);
     else                       print_str_opt("bit_rate", "N/A");
-    print_int("probe_score", fmt_ctx->probe_score);
+    print_int("probe_score", av_format_get_probe_score(fmt_ctx));
     if (do_show_format_tags)
         ret = show_tags(w, fmt_ctx->metadata, SECTION_ID_FORMAT_TAGS);
 
@@ -2831,6 +2828,8 @@ static int open_input_file(InputFile *ifile, const char *filename)
         exit_program(1);
     }
 
+    fmt_ctx->flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
+
     if (!av_dict_get(format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
         av_dict_set(&format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
         scan_all_pmts_set = 1;
@@ -2913,12 +2912,8 @@ static int open_input_file(InputFile *ifile, const char *filename)
                 av_dict_set(&codec_opts, "threads", "1", 0);
             }
 
-            ist->dec_ctx->pkt_timebase = stream->time_base;
+            av_codec_set_pkt_timebase(ist->dec_ctx, stream->time_base);
             ist->dec_ctx->framerate = stream->avg_frame_rate;
-#if FF_API_LAVF_AVCTX
-            ist->dec_ctx->coded_width = stream->codec->coded_width;
-            ist->dec_ctx->coded_height = stream->codec->coded_height;
-#endif
 
             if (avcodec_open2(ist->dec_ctx, codec, &opts) < 0) {
                 av_log(NULL, AV_LOG_WARNING, "Could not open codec for input stream %d\n",
@@ -3118,9 +3113,7 @@ static void ffprobe_show_pixel_formats(WriterContext *w)
             PRINT_PIX_FMT_FLAG(HWACCEL,   "hwaccel");
             PRINT_PIX_FMT_FLAG(PLANAR,    "planar");
             PRINT_PIX_FMT_FLAG(RGB,       "rgb");
-#if FF_API_PSEUDOPAL
             PRINT_PIX_FMT_FLAG(PSEUDOPAL, "pseudopal");
-#endif
             PRINT_PIX_FMT_FLAG(ALPHA,     "alpha");
             writer_print_section_footer(w);
         }
@@ -3569,6 +3562,7 @@ int main(int argc, char **argv)
 
     options = real_options;
     parse_loglevel(argc, argv, options);
+    av_register_all();
     avformat_network_init();
     init_opts();
 #if CONFIG_AVDEVICE

fftools/ffserver_config.h

@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef FFTOOLS_FFSERVER_CONFIG_H
+#define FFTOOLS_FFSERVER_CONFIG_H
+
+#define FFM_PACKET_SIZE 4096
+
+#include "libavutil/dict.h"
+#include "libavformat/avformat.h"
+#include "libavformat/network.h"
+
+#define FFSERVER_MAX_STREAMS 20
+
+/* each generated stream is described here */
+enum FFServerStreamType {
+    STREAM_TYPE_LIVE,
+    STREAM_TYPE_STATUS,
+    STREAM_TYPE_REDIRECT,
+};
+
+enum FFServerIPAddressAction {
+    IP_ALLOW = 1,
+    IP_DENY,
+};
+
+typedef struct FFServerIPAddressACL {
+    struct FFServerIPAddressACL *next;
+    enum FFServerIPAddressAction action;
+    /* These are in host order */
+    struct in_addr first;
+    struct in_addr last;
+} FFServerIPAddressACL;
+
+/**
+ * This holds the stream parameters for an AVStream, it cannot be a AVStream
+ * because AVStreams cannot be instanciated without a AVFormatContext, especially
+ * not outside libavformat.
+ *
+ * The fields of this struct have the same semantics as the fields of an AVStream.
+ */
+typedef struct LayeredAVStream {
+    int index;
+    int id;
+    AVCodecParameters *codecpar;
+    AVCodecContext *codec;
+    AVRational time_base;
+    int pts_wrap_bits;
+    AVRational sample_aspect_ratio;
+    char *recommended_encoder_configuration;
+} LayeredAVStream;
+
+/* description of each stream of the ffserver.conf file */
+typedef struct FFServerStream {
+    enum FFServerStreamType stream_type;
+    char filename[1024];          /* stream filename */
+    struct FFServerStream *feed;  /* feed we are using (can be null if coming from file) */
+    AVDictionary *in_opts;        /* input parameters */
+    AVDictionary *metadata;       /* metadata to set on the stream */
+    AVInputFormat *ifmt;          /* if non NULL, force input format */
+    AVOutputFormat *fmt;
+    FFServerIPAddressACL *acl;
+    char dynamic_acl[1024];
+    int nb_streams;
+    int prebuffer;                /* Number of milliseconds early to start */
+    int64_t max_time;             /* Number of milliseconds to run */
+    int send_on_key;
+    LayeredAVStream *streams[FFSERVER_MAX_STREAMS];
+    int feed_streams[FFSERVER_MAX_STREAMS]; /* index of streams in the feed */
+    char feed_filename[1024];     /* file name of the feed storage, or
+                                     input file name for a stream */
+    pid_t pid;                    /* Of ffmpeg process */
+    time_t pid_start;             /* Of ffmpeg process */
+    char **child_argv;
+    struct FFServerStream *next;
+    unsigned bandwidth;           /* bandwidth, in kbits/s */
+    /* RTSP options */
+    char *rtsp_option;
+    /* multicast specific */
+    int is_multicast;
+    struct in_addr multicast_ip;
+    int multicast_port;           /* first port used for multicast */
+    int multicast_ttl;
+    int loop;                     /* if true, send the stream in loops (only meaningful if file) */
+    char single_frame;            /* only single frame */
+
+    /* feed specific */
+    int feed_opened;              /* true if someone is writing to the feed */
+    int is_feed;                  /* true if it is a feed */
+    int readonly;                 /* True if writing is prohibited to the file */
+    int truncate;                 /* True if feeder connection truncate the feed file */
+    int conns_served;
+    int64_t bytes_served;
+    int64_t feed_max_size;        /* maximum storage size, zero means unlimited */
+    int64_t feed_write_index;     /* current write position in feed (it wraps around) */
+    int64_t feed_size;            /* current size of feed */
+    struct FFServerStream *next_feed;
+} FFServerStream;
+
+typedef struct FFServerConfig {
+    char *filename;
+    FFServerStream *first_feed;   /* contains only feeds */
+    FFServerStream *first_stream; /* contains all streams, including feeds */
+    unsigned int nb_max_http_connections;
+    unsigned int nb_max_connections;
+    uint64_t max_bandwidth;
+    int debug;
+    int bitexact;
+    char logfilename[1024];
+    struct sockaddr_in http_addr;
+    struct sockaddr_in rtsp_addr;
+    int errors;
+    int warnings;
+    int use_defaults;
+    // Following variables MUST NOT be used outside configuration parsing code.
+    enum AVCodecID guessed_audio_codec_id;
+    enum AVCodecID guessed_video_codec_id;
+    AVDictionary *video_opts;     /* AVOptions for video encoder */
+    AVDictionary *audio_opts;     /* AVOptions for audio encoder */
+    AVCodecContext *dummy_actx;   /* Used internally to test audio AVOptions. */
+    AVCodecContext *dummy_vctx;   /* Used internally to test video AVOptions. */
+    int no_audio;
+    int no_video;
+    int line_num;
+    int stream_use_defaults;
+} FFServerConfig;
+
+void ffserver_get_arg(char *buf, int buf_size, const char **pp);
+
+void ffserver_parse_acl_row(FFServerStream *stream, FFServerStream* feed,
+                            FFServerIPAddressACL *ext_acl,
+                            const char *p, const char *filename, int line_num);
+
+int ffserver_parse_ffconfig(const char *filename, FFServerConfig *config);
+
+void ffserver_free_child_args(void *argsp);
+
+#endif /* FFTOOLS_FFSERVER_CONFIG_H */