build: check headers for ifdefs

sys/build.rs

@@ -1,6 +1,6 @@
 use std::env;
-use std::fs;
-use std::io;
+use std::fs::{self, File};
+use std::io::{self, Write};
 use std::path::PathBuf;
 use std::process::Command;
 
@@ -218,8 +218,129 @@ fn build() -> io::Result<()> {
 	Ok(())
 }
 
+fn feature(header: &str, feature: Option<&str>, var: &str) -> io::Result<()> {
+	if let Some(feature) = feature {
+		if env::var(format!("CARGO_FEATURE_{}", feature.to_uppercase())).is_err() {
+			return Ok(());
+		}
+	}
+
+	try!(write!(try!(File::create(output().join("check.c"))), r#"
+		#include <stdio.h>
+		#include <{}>
+
+		int
+		main (int argc, char* argv[])
+		{{
+			printf("%d\n", {});
+			return 0;
+		}}
+	"#, header, var));
+
+	if Command::new("cc").current_dir(&output()).arg("-o").arg("check").arg("check.c").status().is_err() {
+		return Ok(());
+	}
+
+	if try!(Command::new("./check").current_dir(&output()).output()).stdout[0] == b'1' {
+		println!(r#"cargo:rustc-cfg=feature="{}""#, var.to_lowercase());
+	}
+
+	Ok(())
+}
+
 fn main() {
 	if env::var("CARGO_FEATURE_BUILD").is_err() {
+		feature("libavutil/avutil.h", None, "FF_API_OLD_AVOPTIONS").unwrap();
+		feature("libavutil/avutil.h", None, "FF_API_PIX_FMT").unwrap();
+		feature("libavutil/avutil.h", None, "FF_API_CONTEXT_SIZE").unwrap();
+		feature("libavutil/avutil.h", None, "FF_API_PIX_FMT_DESC").unwrap();
+		feature("libavutil/avutil.h", None, "FF_API_AV_REVERSE").unwrap();
+		feature("libavutil/avutil.h", None, "FF_API_AUDIOCONVERT").unwrap();
+		feature("libavutil/avutil.h", None, "FF_API_CPU_FLAG_MMX2").unwrap();
+		feature("libavutil/avutil.h", None, "FF_API_LLS_PRIVATE").unwrap();
+		feature("libavutil/avutil.h", None, "FF_API_AVFRAME_LAVC").unwrap();
+		feature("libavutil/avutil.h", None, "FF_API_VDPAU").unwrap();
+		feature("libavutil/avutil.h", None, "FF_API_GET_CHANNEL_LAYOUT_COMPAT").unwrap();
+		feature("libavutil/avutil.h", None, "FF_API_XVMC").unwrap();
+		feature("libavutil/avutil.h", None, "FF_API_OPT_TYPE_METADATA").unwrap();
+		feature("libavutil/avutil.h", None, "FF_API_DLOG").unwrap();
+		feature("libavutil/avutil.h", None, "FF_API_HMAC").unwrap();
+		feature("libavutil/avutil.h", None, "FF_API_VAAPI").unwrap();
+
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_VIMA_DECODER").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_REQUEST_CHANNELS").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_OLD_DECODE_AUDIO").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_OLD_ENCODE_AUDIO").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_OLD_ENCODE_VIDEO").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_CODEC_ID").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_AUDIO_CONVERT").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_AVCODEC_RESAMPLE").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_DEINTERLACE").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_DESTRUCT_PACKET").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_GET_BUFFER").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_MISSING_SAMPLE").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_LOWRES").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_CAP_VDPAU").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_BUFS_VDPAU").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_VOXWARE").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_SET_DIMENSIONS").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_DEBUG_MV").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_AC_VLC").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_OLD_MSMPEG4").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_ASPECT_EXTENDED").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_THREAD_OPAQUE").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_CODEC_PKT").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_ARCH_ALPHA").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_XVMC").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_ERROR_RATE").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_QSCALE_TYPE").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_MB_TYPE").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_MAX_BFRAMES").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_NEG_LINESIZES").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_EMU_EDGE").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_ARCH_SH4").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_ARCH_SPARC").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_UNUSED_MEMBERS").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_IDCT_XVIDMMX").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_INPUT_PRESERVED").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_NORMALIZE_AQP").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_GMC").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_MV0").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_CODEC_NAME").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_AFD").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_VISMV").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_DV_FRAME_PROFILE").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_AUDIOENC_DELAY").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_VAAPI_CONTEXT").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_AVCTX_TIMEBASE").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_MPV_OPT").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_STREAM_CODEC_TAG").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_QUANT_BIAS").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_RC_STRATEGY").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_CODED_FRAME").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_MOTION_EST").unwrap();
+		feature("libavcodec/avcodec.h", Some("avcodec"), "FF_API_WITHOUT_PREFIX").unwrap();
+
+		feature("libavformat/avformat.h", Some("avformat"), "FF_API_LAVF_BITEXACT").unwrap();
+		feature("libavformat/avformat.h", Some("avformat"), "FF_API_LAVF_FRAC").unwrap();
+		feature("libavformat/avformat.h", Some("avformat"), "FF_API_URL_FEOF").unwrap();
+		feature("libavformat/avformat.h", Some("avformat"), "FF_API_PROBESIZE_32").unwrap();
+
+		feature("libavfilter/avfilter.h", Some("avfilter"), "FF_API_AVFILTERPAD_PUBLIC").unwrap();
+		feature("libavfilter/avfilter.h", Some("avfilter"), "FF_API_FOO_COUNT").unwrap();
+		feature("libavfilter/avfilter.h", Some("avfilter"), "FF_API_AVFILTERBUFFER").unwrap();
+		feature("libavfilter/avfilter.h", Some("avfilter"), "FF_API_OLD_FILTER_OPTS").unwrap();
+		feature("libavfilter/avfilter.h", Some("avfilter"), "FF_API_OLD_FILTER_OPTS_ERROR").unwrap();
+		feature("libavfilter/avfilter.h", Some("avfilter"), "FF_API_AVFILTER_OPEN").unwrap();
+		feature("libavfilter/avfilter.h", Some("avfilter"), "FF_API_OLD_FILTER_REGISTER").unwrap();
+		feature("libavfilter/avfilter.h", Some("avfilter"), "FF_API_OLD_GRAPH_PARSE").unwrap();
+		feature("libavfilter/avfilter.h", Some("avfilter"), "FF_API_NOCONST_GET_NAME").unwrap();
+
+		feature("libavresample/avresample.h", Some("avresample"), "FF_API_RESAMPLE_CLOSE_OPEN").unwrap();
+
+		feature("libswscale/swscale.h", Some("swscale"), "FF_API_SWS_CPU_CAPS").unwrap();
+		feature("libswscale/swscale.h", Some("swscale"), "FF_API_ARCH_BFIN").unwrap();
+
 		return;
 	}
 

sys/src/avcodec/codec.rs

@@ -9,7 +9,8 @@ pub enum AVCodecID {
 	/* video codecs */
 	AV_CODEC_ID_MPEG1VIDEO,
 	AV_CODEC_ID_MPEG2VIDEO,
-	AV_CODEC_ID_MPEG2VIDEO_XVMC, // XXX: #if FF_API_XVMC
+	#[cfg(feature = "ff_api_xvmc")]
+	AV_CODEC_ID_MPEG2VIDEO_XVMC,
 	AV_CODEC_ID_H261,
 	AV_CODEC_ID_H263,
 	AV_CODEC_ID_RV10,
@@ -350,7 +351,8 @@ pub enum AVCodecID {
 	AV_CODEC_ID_MLP,
 	AV_CODEC_ID_GSM_MS,
 	AV_CODEC_ID_ATRAC3,
-	AV_CODEC_ID_VOXWARE, // XXX: #if VOXWARE
+	#[cfg(feature = "voxware")]
+	AV_CODEC_ID_VOXWARE,
 	AV_CODEC_ID_APE,
 	AV_CODEC_ID_NELLYMOSER,
 	AV_CODEC_ID_MUSEPACK8,
@@ -669,8 +671,10 @@ pub struct AVPacket {
 	pub side_data: *mut AVPacketSideData,
 	pub side_data_elems: c_int,
 	pub duration: c_int,
-	pub destruct: Option<extern fn(*mut AVPacket)>, // XXX: #if FF_API_DESTRUCT_PACKET
-	pub private: *mut c_void, // XXX: #if FF_API_DESTRUCT_PACKET
+	#[cfg(feature = "ff_api_destruct_packet")]
+	pub destruct: Option<extern fn(*mut AVPacket)>,
+	#[cfg(feature = "ff_api_destruct_packet")]
+	pub private: *mut c_void,
 	pub pos: int64_t,
 	pub convergence_duration: int64_t,
 }
@@ -919,10 +923,12 @@ pub struct AVCodecContext {
 	pub log_level_offset: c_int,
 	pub codec_type: AVMediaType,
 	pub codec: *const AVCodec,
-	pub codec_name: [c_char; 32], // XXX: #if FF_API_CODEC_NAME
+	#[cfg(feature = "ff_api_codec_name")]
+	pub codec_name: [c_char; 32],
 	pub codec_id: AVCodecID,
 	pub codec_tag: c_uint,
-	pub stream_codec_tag: c_uint, // XXX: #if FF_API_STREAM_CODEC_TAG
+	#[cfg(feature = "ff_api_stream_codec_tag")]
+	pub stream_codec_tag: c_uint,
 	pub priv_data: *mut c_void,
 	pub internal: *mut AVCodecInternal,
 	pub opaque: *mut c_void,
@@ -943,12 +949,14 @@ pub struct AVCodecContext {
 	pub coded_height: c_int,
 	pub gop_size: c_int,
 	pub pix_fmt: AVPixelFormat,
-	pub me_method: c_int, // XXX: #if FF_API_MOTION_EST
+	#[cfg(feature = "ff_api_motion_est")]
+	pub me_method: c_int,
 	pub draw_horiz_band: Option<extern fn(*mut AVCodecContext, *const AVFrame, *mut c_int, c_int, c_int, c_int)>,
 	pub get_format: Option<extern fn(*mut AVCodecContext, *const AVPixelFormat) -> AVPixelFormat>,
 	pub max_b_frames: c_int,
 	pub b_quant_factor: c_float,
-	pub rc_strategy: c_int, // XXX: #if FF_API_RC_STRATEGY
+	#[cfg(feature = "ff_api_rc_strategy")]
+	pub rc_strategy: c_int,
 	pub b_frame_strategy: c_int,
 	pub b_quant_offset: c_float,
 	pub has_b_frames: c_int,
@@ -974,23 +982,30 @@ pub struct AVCodecContext {
 	pub me_pre_cmp: c_int,
 	pub pre_dia_size: c_int,
 	pub me_subpel_quality: c_int,
-	pub dtg_active_format: c_int, // XXX: #if FF_API_AFD
+	#[cfg(feature = "ff_api_afd")]
+	pub dtg_active_format: c_int,
 	pub me_range: c_int,
-	pub intra_quant_bias: c_int, // XXX: #if FF_API_QUANT_BIAS
-	pub inter_quant_bias: c_int, // XXX: #if FF_API_QUANT_BIAS
+	#[cfg(feature = "ff_api_quant_bias")]
+	pub intra_quant_bias: c_int,
+	#[cfg(feature = "ff_api_quant_bias")]
+	pub inter_quant_bias: c_int,
 	pub slice_flags: c_int,
-	pub xvmc_acceleration: c_int, // XXX: #if FF_API_XVMC
+	#[cfg(feature = "ff_api_xvmc")]
+	pub xvmc_acceleration: c_int,
 	pub mb_decision: c_int,
 	pub intra_matrix: *mut uint16_t,
 	pub inter_matrix: *mut uint16_t,
 	pub scenechange_threshold: c_int,
 	pub noise_reduction: c_int,
-	pub me_threshold: c_int, // XXX: #if FF_API_MPV_OPT
-	pub mb_threshold: c_int, // XXX: #if FF_API_MPV_OPT
+	#[cfg(feature = "ff_api_mpv_opt")]
+	pub me_threshold: c_int,
+	#[cfg(feature = "ff_api_mpv_opt")]
+	pub mb_threshold: c_int,
 	pub intra_dc_precision: c_int,
 	pub skip_top: c_int,
 	pub skip_bottom: c_int,
-	pub border_masking: c_float, // XXX: #if FF_API_MPV_OPT
+	#[cfg(feature = "ff_api_mpv_opt")]
+	pub border_masking: c_float,
 	pub mb_lmin: c_int,
 	pub mb_lmax: c_int,
 	pub me_penalty_compensation: c_int,
@@ -999,7 +1014,8 @@ pub struct AVCodecContext {
 	pub keyint_min: c_int,
 	pub refs: c_int,
 	pub chromaoffset: c_int,
-	pub scenechange_factor: c_int, // XXX: #if FF_API_UNUSED_MEMBERS
+	#[cfg(feature = "ff_api_unused_members")]
+	pub scenechange_factor: c_int,
 	pub mv0_threshold: c_int,
 	pub b_sensitivity: c_int,
 	pub color_primaries: AVColorPrimaries,
@@ -1016,14 +1032,18 @@ pub struct AVCodecContext {
 	pub frame_number: c_int,
 	pub block_align: c_int,
 	pub cutoff: c_int,
-	pub request_channels: c_int, // #if FF_API_REQUEST_CHANNELS
+	#[cfg(feature = "ff_api_request_channels")]
+	pub request_channels: c_int,
 	pub channel_layout: uint64_t,
 	pub request_channel_layout: uint64_t,
 	pub audio_service_type: AVAudioServiceType,
 	pub request_sample_fmt: AVSampleFormat,
-	pub get_buffer: Option<extern fn(*mut AVCodecContext, *mut AVFrame) -> c_int>, // XXX: #if FF_API_GET_BUFFER
-	pub release_buffer: Option<extern fn(*mut AVCodecContext, *mut AVFrame)>, // XXX: #if FF_API_GET_BUFFER
-	pub reget_buffer: Option<extern fn(*mut AVCodecContext, *mut AVFrame) -> c_int>, // XXX: #if FF_API_GET_BUFFER
+	#[cfg(feature = "ff_api_get_buffer")]
+	pub get_buffer: Option<extern fn(*mut AVCodecContext, *mut AVFrame) -> c_int>,
+	#[cfg(feature = "ff_api_get_buffer")]
+	pub release_buffer: Option<extern fn(*mut AVCodecContext, *mut AVFrame)>,
+	#[cfg(feature = "ff_api_get_buffer")]
+	pub reget_buffer: Option<extern fn(*mut AVCodecContext, *mut AVFrame) -> c_int>,
 	pub get_buffer2: Option<extern fn(*mut AVCodecContext, *mut AVFrame, c_int) -> c_int>,
 	pub refcounted_frames: c_int,
 	pub qcompress: c_float,
@@ -1031,24 +1051,32 @@ pub struct AVCodecContext {
 	pub qmin: c_int,
 	pub qmax: c_int,
 	pub max_qdiff: c_int,
-	pub rc_qsquish: c_float, // XXX: #if FF_API_MPV_OPT
-	pub rc_qmod_amp: c_float, // XXX: #if FF_API_MPV_OPT
-	pub rc_qmod_freq: c_int, // XXX: #if FF_API_MPV_OPT
+	#[cfg(feature = "ff_api_mpv_opt")]
+	pub rc_qsquish: c_float,
+	#[cfg(feature = "ff_api_mpv_opt")]
+	pub rc_qmod_amp: c_float,
+	#[cfg(feature = "ff_api_mpv_opt")]
+	pub rc_qmod_freq: c_int,
 	pub rc_buffer_size: c_int,
 	pub rc_override_count: c_int,
 	pub rc_override: *mut RcOverride,
-	pub rc_eq: *const c_char, // XXX: #if FF_API_MPV_OPT
+	#[cfg(feature = "ff_api_mpv_opt")]
+	pub rc_eq: *const c_char,
 	pub rc_max_rate: c_int,
 	pub rc_min_rate: c_int,
-	pub rc_buffer_aggressivity: c_float, // XXX: #if FF_API_MPV_OPT
-	pub rc_initial_cplx: c_float, // XXX: #if FF_API_MPV_OPT
+	#[cfg(feature = "ff_api_mpv_opt")]
+	pub rc_buffer_aggressivity: c_float,
+	#[cfg(feature = "ff_api_mpv_opt")]
+	pub rc_initial_cplx: c_float,
 	pub rc_max_available_vbv_use: c_float,
 	pub rc_min_vbvb_overflow_use: c_float,
 	pub rc_initial_buffer_occupancy: c_int,
 	pub coder_type: c_int,
 	pub context_model: c_int,
-	pub lmin: c_int, // XXX: #if FF_API_MPV_OPT
-	pub lmax: c_int, // XXX: #if FF_API_MPV_OPT
+	#[cfg(feature = "ff_api_mpv_opt")]
+	pub lmin: c_int, 
+	#[cfg(feature = "ff_api_mpv_opt")]
+	pub lmax: c_int, 
 	pub frame_skip_threshold: c_int,
 	pub frame_skip_factor: c_int,
 	pub frame_skip_exp: c_int,
@@ -1083,15 +1111,18 @@ pub struct AVCodecContext {
 	pub idct_algo: c_int,
 	pub bits_per_coded_sample: c_int,
 	pub bits_per_raw_sample: c_int,
-	pub lowres: c_int, // XXX: #if FF_API_LOWRES
-	pub coded_frame: *mut AVFrame, // XXX: #if FF_API_CODED_FRAME
+	#[cfg(feature = "ff_api_lowres")]
+	pub lowres: c_int,
+	#[cfg(feature = "ff_api_coded_frame")]
+	pub coded_frame: *mut AVFrame,
 	pub thread_count: c_int,
 	pub thread_type: c_int,
 	pub active_thread_type: c_int,
 	pub thread_safe_callbacks: c_int,
 	pub execute: extern fn(*mut AVCodecContext, extern fn(*mut AVCodecContext, *mut c_void) -> c_int, *mut c_void, *mut c_int, c_int, c_int) -> c_int,
 	pub execute2: extern fn(*mut AVCodecContext, extern fn(*mut AVCodecContext, *mut c_void, c_int, c_int) -> c_int, *mut c_void, *mut c_int, c_int) -> c_int,
-	pub thread_opaque: *mut c_void, // XXX: #if FF_API_THREAD_OPAQUE
+	#[cfg(feature = "ff_api_thread_opaque")]
+	pub thread_opaque: *mut c_void,
 	pub nsse_weight: c_int,
 	pub profile: c_int,
 	pub level: c_int,
@@ -1100,8 +1131,10 @@ pub struct AVCodecContext {
 	pub skip_frame: AVDiscard,
 	pub subtitle_header: *mut uint8_t,
 	pub subtitle_header_size: c_int,
-	pub error_rate: c_int, // XXX: #if FF_API_ERROR_RATE
-	pub pkt: *mut AVPacket, // XXX: #if FF_API_CODEC_PKT
+	#[cfg(feature = "ff_api_error_rate")]
+	pub error_rate: c_int,
+	#[cfg(feature = "ff_api_codec_pkt")]
+	pub pkt: *mut AVPacket,
 	pub vbv_delay: uint64_t,
 	pub side_data_only_packets: c_int,
 	pub initial_padding: c_int,
@@ -1109,7 +1142,8 @@ pub struct AVCodecContext {
 	pub sw_pix_fmt: AVPixelFormat,
 	pub pkt_timebase: AVRational,
 	pub codec_descriptor: *const AVCodecDescriptor,
-	// pub lowres: c_int, // XXX: #if !FF_API_LOWRES
+	#[cfg(not(feature = "ff_api_lowres"))]
+	pub lowres: c_int,
 	pub pts_correction_num_faulty_pts: int64_t,
 	pub pts_correction_num_faulty_dts: int64_t,
 	pub pts_correction_last_pts: int64_t,
@@ -1118,7 +1152,8 @@ pub struct AVCodecContext {
 	pub sub_charenc_mode: c_int,
 	pub skip_alpha: c_int,
 	pub seek_preroll: c_int,
-	// pub debug_mv: c_int, // XXX: #if !FF_API_DEBUG_MV
+	#[cfg(not(feature = "ff_api_debug_mv"))]
+	pub debug_mv: c_int,
 	pub chroma_intra_matrix: *mut uint16_t,
 	pub dump_separator: *mut uint8_t,
 	pub codec_whitelist: *mut c_char,

sys/src/avcodec/vaapi.rs

@@ -6,16 +6,28 @@ pub struct vaapi_context {
 	pub display: *mut c_void,
 	pub config_id: uint32_t,
 	pub context_id: uint32_t,
-	pub pic_param_buf_id: uint32_t, // XXX: #if FF_API_VAAPI_CONTEXT
-	pub iq_matrix_buf_id: uint32_t, // XXX: #if FF_API_VAAPI_CONTEXT
-	pub bitplane_buf_id: uint32_t, // XXX: #if FF_API_VAAPI_CONTEXT
-	pub slice_buf_ids: *mut uint32_t, // XXX: #if FF_API_VAAPI_CONTEXT
-	pub n_slice_buf_ids: c_uint, // XXX: #if FF_API_VAAPI_CONTEXT
-	pub slice_buf_ids_alloc: c_uint, // XXX: #if FF_API_VAAPI_CONTEXT
-	pub slice_params: *mut c_void, // XXX: #if FF_API_VAAPI_CONTEXT
-	pub slice_param_size: c_uint, // XXX: #if FF_API_VAAPI_CONTEXT
-	pub slice_params_alloc: c_uint, // XXX: #if FF_API_VAAPI_CONTEXT
-	pub slice_count: c_uint, // XXX: #if FF_API_VAAPI_CONTEXT
-	pub slice_data: *const uint8_t, // XXX: #if FF_API_VAAPI_CONTEXT
-	pub slice_data_size: uint32_t, // XXX: #if FF_API_VAAPI_CONTEXT
+	#[cfg(feature = "ff_api_vaapi_context")]
+	pub pic_param_buf_id: uint32_t,
+	#[cfg(feature = "ff_api_vaapi_context")]
+	pub iq_matrix_buf_id: uint32_t,
+	#[cfg(feature = "ff_api_vaapi_context")]
+	pub bitplane_buf_id: uint32_t,
+	#[cfg(feature = "ff_api_vaapi_context")]
+	pub slice_buf_ids: *mut uint32_t,
+	#[cfg(feature = "ff_api_vaapi_context")]
+	pub n_slice_buf_ids: c_uint,
+	#[cfg(feature = "ff_api_vaapi_context")]
+	pub slice_buf_ids_alloc: c_uint,
+	#[cfg(feature = "ff_api_vaapi_context")]
+	pub slice_params: *mut c_void,
+	#[cfg(feature = "ff_api_vaapi_context")]
+	pub slice_param_size: c_uint,
+	#[cfg(feature = "ff_api_vaapi_context")]
+	pub slice_params_alloc: c_uint,
+	#[cfg(feature = "ff_api_vaapi_context")]
+	pub slice_count: c_uint,
+	#[cfg(feature = "ff_api_vaapi_context")]
+	pub slice_data: *const uint8_t,
+	#[cfg(feature = "ff_api_vaapi_context")]
+	pub slice_data_size: uint32_t,
 }

sys/src/avfilter/buffersrc.rs

@@ -8,7 +8,7 @@ pub const AV_BUFFERSRC_FLAG_PUSH:            c_int = 4;
 pub const AV_BUFFERSRC_FLAG_KEEP_REF:        c_int = 8;
 
 extern {
-	// XXX: #if FF_API_AVFILTERBUFFER
+	#[cfg(feature = "ff_api_avfilterbuffer")]
 	pub fn av_buffersrc_add_ref(buffer_src: *mut AVFilterContext, picref: *mut AVFilterBufferRef, flags: c_int) -> c_int;
 
 	pub fn av_buffersrc_get_nb_failed_requests(buffer_src: *const AVFilterContext) -> c_uint;

sys/src/avfilter/filter.rs

@@ -159,7 +159,8 @@ pub struct AVFilterLink {
 	pub in_channel_layouts: *mut AVFilterChannelLayouts,
 	pub out_channel_layouts: *mut AVFilterChannelLayouts,
 	pub request_samples: c_int,
-	pub pool: *mut AVFilterPool, // XXX: #if FF_API_AVFILTERBUFFER
+	#[cfg(feature = "ff_api_avfilterbuffer")]
+	pub pool: *mut AVFilterPool,
 	pub graph: *mut AVFilterGraph,
 	pub current_pts: int64_t,
 	pub age_index: c_int,
@@ -168,7 +169,8 @@ pub struct AVFilterLink {
 	pub partial_buf_size: c_int,
 	pub min_samples: c_int,
 	pub max_samples: c_int,
-	pub cur_buf_copy: *mut AVFilterBufferRef, // XXX: #if FF_API_AVFILTERBUFFER
+	#[cfg(feature = "ff_api_avfilterbuffer")]
+	pub cur_buf_copy: *mut AVFilterBufferRef,
 	pub closed: c_int,
 	pub channels: c_int,
 	pub frame_requested: c_uint,

sys/src/avformat/format.rs

@@ -193,7 +193,8 @@ pub struct AVStream {
 	pub id: c_int,
 	pub codec: *mut AVCodecContext,
 	pub priv_data: *mut c_void,
-	pub pts: AVFrac, // XXX: #if FF_API_LAVF_FRAC
+	#[cfg(feature = "ff_api_lavf_frac")]
+	pub pts: AVFrac,
 	pub time_base: AVRational,
 	pub start_time: int64_t,
 	pub duration: int64_t,
@@ -321,8 +322,10 @@ pub struct AVFormatContext {
 	pub max_delay:   c_int,
 	pub flags:       c_int,
 
-	pub probesize: c_uint, // XXX: #if FF_API_PROBESIZE_32
-	pub max_analyze_duration: c_int, // XXX: #if FF_API_PROBESIZE_32
+	#[cfg(feature = "ff_api_probesize_32")]
+	pub probesize: c_uint,
+	#[cfg(feature = "ff_api_probesize_32")]
+	pub max_analyze_duration: c_int,
 
 	pub key:    *const uint8_t,
 	pub keylen: c_int,
@@ -389,11 +392,15 @@ pub struct AVFormatContext {
 	pub control_message_cb: av_format_control_message,
 
 	pub output_ts_offset: int64_t,
-	pub max_analyze_duration2: int64_t, // XXX: #if FF_API_PROBESIZE_32
-	pub probesize2: int64_t, // XXX: #if FF_API_PROBESIZE_32
+	#[cfg(feature = "ff_api_probesize_32")]
+	pub max_analyze_duration2: int64_t,
+	#[cfg(feature = "ff_api_probesize_32")]
+	pub probesize2: int64_t,
 
-// pub max_analyze_duration: int64_t, // XXX: #if !FF_API_PROBESIZE_32
-// pub probesize: int64_t, // XXX: #if !FF_API_PROBESIZE_32
+	#[cfg(not(feature = "ff_api_probesize_32"))]
+	pub max_analyze_duration: int64_t,
+	#[cfg(not(feature = "ff_api_probesize_32"))]
+	pub probesize: int64_t,
 
 	pub dump_separator: *mut uint8_t,
 	pub data_codec_id: AVCodecID,

sys/src/avutil/frame.rs

@@ -51,7 +51,8 @@ pub struct AVFrame {
 	pub key_frame: c_int,
 	pub pict_type: AVPictureType,
 
-	pub base: [*mut uint8_t; AV_NUM_DATA_POINTERS], // XXX: #if FF_API_AVFRAME_LAVC
+	#[cfg(feature = "ff_api_avframe_lavc")]
+	pub base: [*mut uint8_t; AV_NUM_DATA_POINTERS],
 
 	pub sample_aspect_ratio: AVRational,
 	pub pts: int64_t,
@@ -63,20 +64,30 @@ pub struct AVFrame {
 
 	pub quality: c_int,
 
-	pub reference: c_int, // XXX: #if FF_API_AVFRAME_LAVC
-	pub qscale_table: *mut int8_t, // XXX: #if FF_API_AVFRAME_LAVC
-	pub qstride: c_int, // XXX: #if FF_API_AVFRAME_LAVC
-	pub qscale_type: c_int, // XXX: #if FF_API_AVFRAME_LAVC
-	pub mbskip_table: *mut uint8_t, // XXX: #if FF_API_AVFRAME_LAVC
-	pub motion_val: [*mut [int16_t; 2]; 2], // XXX: #if FF_API_AVFRAME_LAVC
-	pub mb_type: *mut uint32_t, // XXX: #if FF_API_AVFRAME_LAVC
-	pub dct_coeff: *mut c_short, // XXX: #if FF_API_AVFRAME_LAVC
-	pub ref_index: [*mut int8_t; 2], // XXX: #if FF_API_AVFRAME_LAVC
+	#[cfg(feature = "ff_api_avframe_lavc")]
+	pub reference: c_int,
+	#[cfg(feature = "ff_api_avframe_lavc")]
+	pub qscale_table: *mut int8_t,
+	#[cfg(feature = "ff_api_avframe_lavc")]
+	pub qstride: c_int,
+	#[cfg(feature = "ff_api_avframe_lavc")]
+	pub qscale_type: c_int,
+	#[cfg(feature = "ff_api_avframe_lavc")]
+	pub mbskip_table: *mut uint8_t,
+	#[cfg(feature = "ff_api_avframe_lavc")]
+	pub motion_val: [*mut [int16_t; 2]; 2],
+	#[cfg(feature = "ff_api_avframe_lavc")]
+	pub mb_type: *mut uint32_t,
+	#[cfg(feature = "ff_api_avframe_lavc")]
+	pub dct_coeff: *mut c_short,
+	#[cfg(feature = "ff_api_avframe_lavc")]
+	pub ref_index: [*mut int8_t; 2],
 
 	pub opaque: *mut c_void,
 	pub error: [uint64_t; AV_NUM_DATA_POINTERS],
 
-	pub type_: c_int, // XXX: #if FF_API_AVFRAME_LAVC
+	#[cfg(feature = "ff_api_avframe_lavc")]
+	pub type_: c_int,
 
 	pub repeat_pict: c_int,
 	pub interlaced_frame: c_int,
@@ -84,15 +95,21 @@ pub struct AVFrame {
 
 	pub palette_has_changed: c_int,
 
-	pub buffer_hints: c_int, // XXX: #if FF_API_AVFRAME_LAVC
-	pub pan_scan: *mut c_void, // XXX: #if FF_API_AVFRAME_LAVC
+	#[cfg(feature = "ff_api_avframe_lavc")]
+	pub buffer_hints: c_int,
+	#[cfg(feature = "ff_api_avframe_lavc")]
+	pub pan_scan: *mut c_void,
 
 	pub reordered_opaque: int64_t,
 
-	pub hwaccel_picture_private: *mut c_void, // XXX: #if FF_API_AVFRAME_LAVC
-	pub owner: *mut c_void, // XXX: #if FF_API_AVFRAME_LAVC
-	pub thread_opaque: *mut c_void, // XXX: #if FF_API_AVFRAME_LAVC
-	pub motion_subsample_log2: uint8_t, // XXX: #if FF_API_AVFRAME_LAVC
+	#[cfg(feature = "ff_api_avframe_lavc")]
+	pub hwaccel_picture_private: *mut c_void,
+	#[cfg(feature = "ff_api_avframe_lavc")]
+	pub owner: *mut c_void,
+	#[cfg(feature = "ff_api_avframe_lavc")]
+	pub thread_opaque: *mut c_void,
+	#[cfg(feature = "ff_api_avframe_lavc")]
+	pub motion_subsample_log2: uint8_t,
 
 	pub sample_rate: c_int,
 	pub channel_layout: uint64_t,

sys/src/avutil/hmac.rs

@@ -7,8 +7,10 @@ pub enum AVHMACType {
 	AV_HMAC_SHA1,
 	AV_HMAC_SHA224,
 	AV_HMAC_SHA256,
-	AV_HMAC_SHA224_DEPRECATED = 10, // XXX: #if FF_API_HMAC
-	AV_HMAC_SHA256_DEPRECATED, // XXX: #if FF_API_HMAC
+	#[cfg(feature = "ff_api_hmac")]
+	AV_HMAC_SHA224_DEPRECATED = 10,
+	#[cfg(feature = "ff_api_hmac")]
+	AV_HMAC_SHA256_DEPRECATED,
 	AV_HMAC_SHA384 = 12,
 	AV_HMAC_SHA512,
 }

sys/src/avutil/pixfmt.rs

@@ -22,8 +22,10 @@ pub enum AVPixelFormat {
 	AV_PIX_FMT_YUVJ420P,
 	AV_PIX_FMT_YUVJ422P,
 	AV_PIX_FMT_YUVJ444P,
-	AV_PIX_FMT_XVMC_MPEG2_MC, // XXX: #if FF_API_XVMC
-	AV_PIX_FMT_XVMC_MPEG2_IDCT, // XXX: #if FF_API_XVMC
+	#[cfg(feature = "ff_api_xvmc")]
+	AV_PIX_FMT_XVMC_MPEG2_MC,
+	#[cfg(feature = "ff_api_xvmc")]
+	AV_PIX_FMT_XVMC_MPEG2_IDCT,
 	AV_PIX_FMT_UYVY422,
 	AV_PIX_FMT_UYYVYY411,
 	AV_PIX_FMT_BGR8,
@@ -45,11 +47,16 @@ pub enum AVPixelFormat {
 	AV_PIX_FMT_YUV440P,
 	AV_PIX_FMT_YUVJ440P,
 	AV_PIX_FMT_YUVA420P,
-	AV_PIX_FMT_VDPAU_H264, // XXX: #if FF_API_VDPAU
-	AV_PIX_FMT_VDPAU_MPEG1, // XXX: #if FF_API_VDPAU
-	AV_PIX_FMT_VDPAU_MPEG2, // XXX: #if FF_API_VDPAU
-	AV_PIX_FMT_VDPAU_WMV3, // XXX: #if FF_API_VDPAU
-	AV_PIX_FMT_VDPAU_VC1, // XXX: #if FF_API_VDPAU
+	#[cfg(feature = "ff_api_vdpau")]
+	AV_PIX_FMT_VDPAU_H264,
+	#[cfg(feature = "ff_api_vdpau")]
+	AV_PIX_FMT_VDPAU_MPEG1,
+	#[cfg(feature = "ff_api_vdpau")]
+	AV_PIX_FMT_VDPAU_MPEG2,
+	#[cfg(feature = "ff_api_vdpau")]
+	AV_PIX_FMT_VDPAU_WMV3,
+	#[cfg(feature = "ff_api_vdpau")]
+	AV_PIX_FMT_VDPAU_VC1,
 	AV_PIX_FMT_RGB48BE,
 	AV_PIX_FMT_RGB48LE,
 
@@ -63,11 +70,15 @@ pub enum AVPixelFormat {
 	AV_PIX_FMT_BGR555BE,
 	AV_PIX_FMT_BGR555LE,
 
-	AV_PIX_FMT_VAAPI_MOCO, // XXX: #if FF_API_VAAPI
-	AV_PIX_FMT_VAAPI_IDCT, // XXX: #if FF_API_VAAPI
-	AV_PIX_FMT_VAAPI_VLD, // XXX: #if FF_API_VAAPI
+	#[cfg(feature = "ff_api_vaapi")]
+	AV_PIX_FMT_VAAPI_MOCO,
+	#[cfg(feature = "ff_api_vaapi")]
+	AV_PIX_FMT_VAAPI_IDCT,
+	#[cfg(feature = "ff_api_vaapi")]
+	AV_PIX_FMT_VAAPI_VLD,
 
-// AV_PIX_FMT_VAAPI, // XXX: #if !FF_API_VAAPI
+	#[cfg(not(feature = "ff_api_vaapi"))]
+	AV_PIX_FMT_VAAPI,
 
 	AV_PIX_FMT_YUV420P16LE,
 	AV_PIX_FMT_YUV420P16BE,
@@ -75,7 +86,8 @@ pub enum AVPixelFormat {
 	AV_PIX_FMT_YUV422P16BE,
 	AV_PIX_FMT_YUV444P16LE,
 	AV_PIX_FMT_YUV444P16BE,
-	AV_PIX_FMT_VDPAU_MPEG4, // XXX: #if FF_API_VDPAU
+	#[cfg(feature = "ff_api_vdpau")]
+	AV_PIX_FMT_VDPAU_MPEG4,
 	AV_PIX_FMT_DXVA2_VLD,
 
 	AV_PIX_FMT_RGB444LE,