diff --git a/sys/Cargo.toml b/sys/Cargo.toml index 158cdd2..b4ee35f 100644 --- a/sys/Cargo.toml +++ b/sys/Cargo.toml @@ -15,9 +15,11 @@ keywords = ["audio", "video"] libc = "0.2" [build-dependencies] -num_cpus = "1" -gcc = "0.3" +num_cpus = "1" +gcc = "0.3" pkg-config = "0.3" +bindgen = { git = "https://github.com/servo/rust-bindgen.git" } +regex = "0.2" [features] default = ["avcodec", "avdevice", "avfilter", "avformat", "avresample", "swresample", "swscale"] diff --git a/sys/build.rs b/sys/build.rs index 52f84f5..3d06799 100644 --- a/sys/build.rs +++ b/sys/build.rs @@ -1,6 +1,8 @@ extern crate num_cpus; extern crate gcc; extern crate pkg_config; +extern crate bindgen; +extern crate regex; use std::env; use std::fs::{self, create_dir, File, symlink_metadata}; @@ -9,499 +11,894 @@ use std::path::PathBuf; use std::process::Command; use std::str; -fn version() -> String { - let major: u8 = env::var("CARGO_PKG_VERSION_MAJOR").unwrap().parse().unwrap(); - let minor: u8 = env::var("CARGO_PKG_VERSION_MINOR").unwrap().parse().unwrap(); +use regex::Regex; +use bindgen::callbacks::{IntKind, ParseCallbacks}; - format!("{}.{}", major, minor) +#[derive(Debug)] +struct IntCallbacks; + +impl ParseCallbacks for IntCallbacks { + fn int_macro(&self, _name: &str, value: i64) -> Option { + let ch_layout = Regex::new(r"^AV_CH").unwrap(); + let codec_cap = Regex::new(r"^AV_CODEC_CAP").unwrap(); + let codec_flag = Regex::new(r"^AV_CODEC_FLAG").unwrap(); + let error_max_size = Regex::new(r"^AV_ERROR_MAX_STRING_SIZE").unwrap(); + + if value >= i64::min_value() as i64 && value <= i64::max_value() as i64 && + ch_layout.is_match(_name) + { + Some(IntKind::ULongLong) + } else if value >= i32::min_value() as i64 && value <= i32::max_value() as i64 && + (codec_cap.is_match(_name) || codec_flag.is_match(_name)) + { + Some(IntKind::UInt) + } else if error_max_size.is_match(_name) { + Some(IntKind::Custom { + name: "usize", + is_signed: false, + }) + } else if value >= i32::min_value() as i64 && value <= i32::max_value() as i64 { + Some(IntKind::Int) + } else { + None + } + } +} + +fn version() -> String { + let major: u8 = env::var("CARGO_PKG_VERSION_MAJOR") + .unwrap() + .parse() + .unwrap(); + let minor: u8 = env::var("CARGO_PKG_VERSION_MINOR") + .unwrap() + .parse() + .unwrap(); + + format!("{}.{}", major, minor) } fn output() -> PathBuf { - PathBuf::from(env::var("OUT_DIR").unwrap()) + PathBuf::from(env::var("OUT_DIR").unwrap()) } fn source() -> PathBuf { - output().join(format!("ffmpeg-{}", version())) + output().join(format!("ffmpeg-{}", version())) } fn search() -> PathBuf { - let mut absolute = env::current_dir().unwrap(); - absolute.push(&output()); - absolute.push("dist"); + let mut absolute = env::current_dir().unwrap(); + absolute.push(&output()); + absolute.push("dist"); - absolute + absolute } fn fetch() -> io::Result<()> { - let status = try!(Command::new("git") - .current_dir(&output()) - .arg("clone") - .arg("-b") - .arg(format!("release/{}", version())) - .arg("https://github.com/FFmpeg/FFmpeg") - .arg(format!("ffmpeg-{}", version())) - .status()); + let status = try!( + Command::new("git") + .current_dir(&output()) + .arg("clone") + .arg("-b") + .arg(format!("release/{}", version())) + .arg("https://github.com/FFmpeg/FFmpeg") + .arg(format!("ffmpeg-{}", version())) + .status() + ); - if status.success() { - Ok(()) - } - else { - Err(io::Error::new(io::ErrorKind::Other, "fetch failed")) - } + if status.success() { + Ok(()) + } else { + Err(io::Error::new(io::ErrorKind::Other, "fetch failed")) + } } fn build() -> io::Result<()> { - let mut configure = Command::new("./configure"); - configure.current_dir(&source()); - configure.arg(format!("--prefix={}", search().to_string_lossy())); + let mut configure = Command::new("./configure"); + configure.current_dir(&source()); + configure.arg(format!("--prefix={}", search().to_string_lossy())); - if env::var("TARGET").unwrap() != env::var("HOST").unwrap() { - configure.arg(format!("--cross-prefix={}-", env::var("TARGET").unwrap())); - } + if env::var("TARGET").unwrap() != env::var("HOST").unwrap() { + configure.arg(format!("--cross-prefix={}-", env::var("TARGET").unwrap())); + } - // control debug build - if env::var("DEBUG").is_ok() { - configure.arg("--enable-debug"); - configure.arg("--disable-stripping"); - } - else { - configure.arg("--disable-debug"); - configure.arg("--enable-stripping"); - } + // control debug build + if env::var("DEBUG").is_ok() { + configure.arg("--enable-debug"); + configure.arg("--disable-stripping"); + } else { + configure.arg("--disable-debug"); + configure.arg("--enable-stripping"); + } - // make it static - configure.arg("--enable-static"); - configure.arg("--disable-shared"); + // make it static + configure.arg("--enable-static"); + configure.arg("--disable-shared"); - configure.arg("--enable-pic"); + configure.arg("--enable-pic"); - // do not build programs since we don't need them - configure.arg("--disable-programs"); + // do not build programs since we don't need them + configure.arg("--disable-programs"); - macro_rules! switch { - ($conf:expr, $feat:expr, $name:expr) => ( - if env::var(concat!("CARGO_FEATURE_", $feat)).is_ok() { - $conf.arg(concat!("--enable-", $name)); - } - else { - $conf.arg(concat!("--disable-", $name)); - } - ) - } + macro_rules! switch { + ($conf:expr, $feat:expr, $name:expr) => ( + if env::var(concat!("CARGO_FEATURE_", $feat)).is_ok() { + $conf.arg(concat!("--enable-", $name)); + } + else { + $conf.arg(concat!("--disable-", $name)); + } + ) + } - macro_rules! enable { - ($conf:expr, $feat:expr, $name:expr) => ( - if env::var(concat!("CARGO_FEATURE_", $feat)).is_ok() { - $conf.arg(concat!("--enable-", $name)); - } - ) - } + macro_rules! enable { + ($conf:expr, $feat:expr, $name:expr) => ( + if env::var(concat!("CARGO_FEATURE_", $feat)).is_ok() { + $conf.arg(concat!("--enable-", $name)); + } + ) + } - macro_rules! disable { - ($conf:expr, $feat:expr, $name:expr) => ( - if env::var(concat!("CARGO_FEATURE_", $feat)).is_err() { - $conf.arg(concat!("--disable-", $name)); - } - ) - } + // macro_rules! disable { + // ($conf:expr, $feat:expr, $name:expr) => ( + // if env::var(concat!("CARGO_FEATURE_", $feat)).is_err() { + // $conf.arg(concat!("--disable-", $name)); + // } + // ) + // } - // the binary using ffmpeg-sys must comply with GPL - switch!(configure, "BUILD_LICENSE_GPL", "gpl"); + // the binary using ffmpeg-sys must comply with GPL + switch!(configure, "BUILD_LICENSE_GPL", "gpl"); - // the binary using ffmpeg-sys must comply with (L)GPLv3 - switch!(configure, "BUILD_LICENSE_VERSION3", "version3"); + // the binary using ffmpeg-sys must comply with (L)GPLv3 + switch!(configure, "BUILD_LICENSE_VERSION3", "version3"); - // the binary using ffmpeg-sys cannot be redistributed - switch!(configure, "BUILD_LICENSE_NONFREE", "nonfree"); + // the binary using ffmpeg-sys cannot be redistributed + switch!(configure, "BUILD_LICENSE_NONFREE", "nonfree"); - // configure building libraries based on features - switch!(configure, "AVCODEC", "avcodec"); - switch!(configure, "AVDEVICE", "avdevice"); - switch!(configure, "AVFILTER", "avfilter"); - switch!(configure, "AVFORMAT", "avformat"); - switch!(configure, "AVRESAMPLE", "avresample"); - switch!(configure, "POSTPROC", "postproc"); - switch!(configure, "SWRESAMPLE", "swresample"); - switch!(configure, "SWSCALE", "swscale"); + // configure building libraries based on features + switch!(configure, "AVCODEC", "avcodec"); + switch!(configure, "AVDEVICE", "avdevice"); + switch!(configure, "AVFILTER", "avfilter"); + switch!(configure, "AVFORMAT", "avformat"); + switch!(configure, "AVRESAMPLE", "avresample"); + switch!(configure, "POSTPROC", "postproc"); + switch!(configure, "SWRESAMPLE", "swresample"); + switch!(configure, "SWSCALE", "swscale"); - // configure external SSL libraries - enable!(configure, "BUILD_LIB_GNUTLS", "gnutls"); - enable!(configure, "BUILD_LIB_OPENSSL", "openssl"); + // configure external SSL libraries + enable!(configure, "BUILD_LIB_GNUTLS", "gnutls"); + enable!(configure, "BUILD_LIB_OPENSSL", "openssl"); - // configure external filters - enable!(configure, "BUILD_LIB_FONTCONFIG", "fontconfig"); - enable!(configure, "BUILD_LIB_FREI0R", "frei0r"); - enable!(configure, "BUILD_LIB_LADSPA", "ladspa"); - enable!(configure, "BUILD_LIB_ASS", "libass"); - enable!(configure, "BUILD_LIB_FREETYPE", "libfreetype"); - enable!(configure, "BUILD_LIB_FRIBIDI", "libfribidi"); - enable!(configure, "BUILD_LIB_OPENCV", "libopencv"); + // configure external filters + enable!(configure, "BUILD_LIB_FONTCONFIG", "fontconfig"); + enable!(configure, "BUILD_LIB_FREI0R", "frei0r"); + enable!(configure, "BUILD_LIB_LADSPA", "ladspa"); + enable!(configure, "BUILD_LIB_ASS", "libass"); + enable!(configure, "BUILD_LIB_FREETYPE", "libfreetype"); + enable!(configure, "BUILD_LIB_FRIBIDI", "libfribidi"); + enable!(configure, "BUILD_LIB_OPENCV", "libopencv"); - // configure external encoders/decoders - enable!(configure, "BUILD_LIB_AACPLUS", "libaacplus"); - enable!(configure, "BUILD_LIB_CELT", "libcelt"); - enable!(configure, "BUILD_LIB_DCADEC", "libdcadec"); - enable!(configure, "BUILD_LIB_FAAC", "libfaac"); - enable!(configure, "BUILD_LIB_FDK_AAC", "libfdk-aac"); - enable!(configure, "BUILD_LIB_GSM", "libgsm"); - enable!(configure, "BUILD_LIB_ILBC", "libilbc"); - enable!(configure, "BUILD_LIB_VAZAAR", "libvazaar"); - enable!(configure, "BUILD_LIB_MP3LAME", "libmp3lame"); - enable!(configure, "BUILD_LIB_OPENCORE_AMRNB", "libopencore-amrnb"); - enable!(configure, "BUILD_LIB_OPENCORE_AMRWB", "libopencore-amrwrb"); - enable!(configure, "BUILD_LIB_OPENH264", "libopenh264"); - enable!(configure, "BUILD_LIB_OPENH265", "libopenh265"); - enable!(configure, "BUILD_LIB_OPENJPEG", "libopenjpeg"); - enable!(configure, "BUILD_LIB_OPUS", "libopus"); - enable!(configure, "BUILD_LIB_SCHROEDINGER", "libschroedinger"); - enable!(configure, "BUILD_LIB_SHINE", "libshine"); - enable!(configure, "BUILD_LIB_SNAPPY", "libsnappy"); - enable!(configure, "BUILD_LIB_SPEEX", "libspeex"); - enable!(configure, "BUILD_LIB_STAGEFRIGHT_H264", "libstagefright-h264"); - enable!(configure, "BUILD_LIB_THEORA", "libtheora"); - enable!(configure, "BUILD_LIB_TWOLAME", "libtwolame"); - enable!(configure, "BUILD_LIB_UTVIDEO", "libutvideo"); - enable!(configure, "BUILD_LIB_VO_AACENC", "libvo-aacenc"); - enable!(configure, "BUILD_LIB_VO_AMRWBENC", "libvo-amrwbenc"); - enable!(configure, "BUILD_LIB_VORBIS", "libvorbis"); - enable!(configure, "BUILD_LIB_VPX", "libvpx"); - enable!(configure, "BUILD_LIB_WAVPACK", "libwavpack"); - enable!(configure, "BUILD_LIB_WEBP", "libwebp"); - enable!(configure, "BUILD_LIB_X264", "libx264"); - enable!(configure, "BUILD_LIB_X265", "libx265"); - enable!(configure, "BUILD_LIB_AVS", "libavs"); - enable!(configure, "BUILD_LIB_XVID", "libxvid"); + // configure external encoders/decoders + enable!(configure, "BUILD_LIB_AACPLUS", "libaacplus"); + enable!(configure, "BUILD_LIB_CELT", "libcelt"); + enable!(configure, "BUILD_LIB_DCADEC", "libdcadec"); + enable!(configure, "BUILD_LIB_FAAC", "libfaac"); + enable!(configure, "BUILD_LIB_FDK_AAC", "libfdk-aac"); + enable!(configure, "BUILD_LIB_GSM", "libgsm"); + enable!(configure, "BUILD_LIB_ILBC", "libilbc"); + enable!(configure, "BUILD_LIB_VAZAAR", "libvazaar"); + enable!(configure, "BUILD_LIB_MP3LAME", "libmp3lame"); + enable!(configure, "BUILD_LIB_OPENCORE_AMRNB", "libopencore-amrnb"); + enable!(configure, "BUILD_LIB_OPENCORE_AMRWB", "libopencore-amrwrb"); + enable!(configure, "BUILD_LIB_OPENH264", "libopenh264"); + enable!(configure, "BUILD_LIB_OPENH265", "libopenh265"); + enable!(configure, "BUILD_LIB_OPENJPEG", "libopenjpeg"); + enable!(configure, "BUILD_LIB_OPUS", "libopus"); + enable!(configure, "BUILD_LIB_SCHROEDINGER", "libschroedinger"); + enable!(configure, "BUILD_LIB_SHINE", "libshine"); + enable!(configure, "BUILD_LIB_SNAPPY", "libsnappy"); + enable!(configure, "BUILD_LIB_SPEEX", "libspeex"); + enable!( + configure, + "BUILD_LIB_STAGEFRIGHT_H264", + "libstagefright-h264" + ); + enable!(configure, "BUILD_LIB_THEORA", "libtheora"); + enable!(configure, "BUILD_LIB_TWOLAME", "libtwolame"); + enable!(configure, "BUILD_LIB_UTVIDEO", "libutvideo"); + enable!(configure, "BUILD_LIB_VO_AACENC", "libvo-aacenc"); + enable!(configure, "BUILD_LIB_VO_AMRWBENC", "libvo-amrwbenc"); + enable!(configure, "BUILD_LIB_VORBIS", "libvorbis"); + enable!(configure, "BUILD_LIB_VPX", "libvpx"); + enable!(configure, "BUILD_LIB_WAVPACK", "libwavpack"); + enable!(configure, "BUILD_LIB_WEBP", "libwebp"); + enable!(configure, "BUILD_LIB_X264", "libx264"); + enable!(configure, "BUILD_LIB_X265", "libx265"); + enable!(configure, "BUILD_LIB_AVS", "libavs"); + enable!(configure, "BUILD_LIB_XVID", "libxvid"); - // other external libraries - enable!(configure, "BUILD_NVENC", "nvenc"); + // other external libraries + enable!(configure, "BUILD_NVENC", "nvenc"); - // configure external protocols - enable!(configure, "BUILD_LIB_SMBCLIENT", "libsmbclient"); - enable!(configure, "BUILD_LIB_SSH", "libssh"); + // configure external protocols + enable!(configure, "BUILD_LIB_SMBCLIENT", "libsmbclient"); + enable!(configure, "BUILD_LIB_SSH", "libssh"); - // configure misc build options - enable!(configure, "BUILD_PIC", "pic"); + // configure misc build options + enable!(configure, "BUILD_PIC", "pic"); - // run ./configure - let output = configure.output().expect(&format!("{:?} failed", configure)); - if !output.status.success() { - println!("configure: {}", String::from_utf8_lossy(&output.stdout)); + // run ./configure + let output = configure + .output() + .expect(&format!("{:?} failed", configure)); + if !output.status.success() { + println!("configure: {}", String::from_utf8_lossy(&output.stdout)); - return Err(io::Error::new(io::ErrorKind::Other, - format!("configure failed {}", String::from_utf8_lossy(&output.stderr)))); - } + return Err(io::Error::new( + io::ErrorKind::Other, + format!( + "configure failed {}", + String::from_utf8_lossy(&output.stderr) + ), + )); + } - // run make - if !try!(Command::new("make") - .arg("-j").arg(num_cpus::get().to_string()) - .current_dir(&source()).status()).success() { - return Err(io::Error::new(io::ErrorKind::Other, "make failed")); - } + // run make + if !try!( + Command::new("make") + .arg("-j") + .arg(num_cpus::get().to_string()) + .current_dir(&source()) + .status() + ).success() + { + return Err(io::Error::new(io::ErrorKind::Other, "make failed")); + } - // run make install - if !try!(Command::new("make").current_dir(&source()).arg("install").status()).success() { - return Err(io::Error::new(io::ErrorKind::Other, "make install failed")); - } + // run make install + if !try!( + Command::new("make") + .current_dir(&source()) + .arg("install") + .status() + ).success() + { + return Err(io::Error::new(io::ErrorKind::Other, "make install failed")); + } - Ok(()) + Ok(()) } -fn check_features(include_paths: Vec, infos: &Vec<(&'static str, Option<&'static str>, &'static str)>) { - let mut includes_code = String::new(); - let mut main_code = String::new(); +fn check_features( + include_paths: Vec, + infos: &Vec<(&'static str, Option<&'static str>, &'static str)>, +) { + let mut includes_code = String::new(); + let mut main_code = String::new(); - for &(header, feature, var) in infos { - if let Some(feature) = feature { - if env::var(format!("CARGO_FEATURE_{}", feature.to_uppercase())).is_err() { - continue - } - } + for &(header, feature, var) in infos { + if let Some(feature) = feature { + if env::var(format!("CARGO_FEATURE_{}", feature.to_uppercase())).is_err() { + continue; + } + } - let include = format!("#include <{}>", header); - if includes_code.find(&include).is_none() { - includes_code.push_str(&include); - includes_code.push_str(&"\n"); - } - includes_code.push_str(&format!(r#" - #ifndef {var} - #define {var} 0 - #define {var}_is_defined 0 - #else - #define {var}_is_defined 1 - #endif - "#, var=var)); + let include = format!("#include <{}>", header); + if includes_code.find(&include).is_none() { + includes_code.push_str(&include); + includes_code.push_str(&"\n"); + } + includes_code.push_str(&format!( + r#" + #ifndef {var} + #define {var} 0 + #define {var}_is_defined 0 + #else + #define {var}_is_defined 1 + #endif + "#, + var = var + )); - main_code.push_str(&format!(r#"printf("[{var}]%d%d\n", {var}, {var}_is_defined);"#, var=var)); - } + main_code.push_str(&format!( + r#"printf("[{var}]%d%d\n", {var}, {var}_is_defined);"#, + var = var + )); + } - let version_check_info = [("avcodec", 56, 60, 0, 80)]; - for &(lib, begin_version_major, end_version_major, begin_version_minor, end_version_minor) in version_check_info.iter() { - for version_major in begin_version_major..end_version_major { - for version_minor in begin_version_minor..end_version_minor { - main_code.push_str(&format!(r#"printf("[{lib}_version_greater_than_{version_major}_{version_minor}]%d\n", LIB{lib_uppercase}_VERSION_MAJOR > {version_major} || (LIB{lib_uppercase}_VERSION_MAJOR == {version_major} && LIB{lib_uppercase}_VERSION_MINOR > {version_minor}));"#, - lib=lib, - lib_uppercase=lib.to_uppercase(), - version_major=version_major, - version_minor=version_minor)); + let version_check_info = [("avcodec", 56, 60, 0, 80)]; + for &(lib, begin_version_major, end_version_major, begin_version_minor, end_version_minor) in + version_check_info.iter() + { + for version_major in begin_version_major..end_version_major { + for version_minor in begin_version_minor..end_version_minor { + main_code.push_str(&format!(r#"printf("[{lib}_version_greater_than_{version_major}_{version_minor}]%d\n", LIB{lib_uppercase}_VERSION_MAJOR > {version_major} || (LIB{lib_uppercase}_VERSION_MAJOR == {version_major} && LIB{lib_uppercase}_VERSION_MINOR > {version_minor}));"#, +lib=lib, +lib_uppercase=lib.to_uppercase(), +version_major=version_major, +version_minor=version_minor)); + } + } + } - } - } - } + let out_dir = output(); - let out_dir = output(); + write!( + File::create(out_dir.join("check.c")).expect("Failed to create file"), + r#" + #include + {includes_code} - write!(File::create(out_dir.join("check.c")).expect("Failed to create file"), r#" - #include - {includes_code} + int main() + {{ + {main_code} + return 0; + }} + "#, + includes_code = includes_code, + main_code = main_code + ).expect("Write failed"); - int main() - {{ - {main_code} - return 0; - }} - "#, includes_code=includes_code, main_code=main_code).expect("Write failed"); + let executable = out_dir.join(if cfg!(windows) { "check.exe" } else { "check" }); + let mut compiler = gcc::Config::new().get_compiler().to_command(); - let executable = out_dir.join(if cfg!(windows) { "check.exe" } else { "check" }); - let mut compiler = gcc::Config::new().get_compiler().to_command(); + for dir in include_paths { + compiler.arg("-I"); + compiler.arg(dir.to_string_lossy().into_owned()); + } + if !compiler + .current_dir(&out_dir) + .arg("-o") + .arg(&executable) + .arg("check.c") + .status() + .expect("Command failed") + .success() + { + panic!("Compile failed"); + } - for dir in include_paths { - compiler.arg("-I"); - compiler.arg(dir.to_string_lossy().into_owned()); - } - if !compiler.current_dir(&out_dir) - .arg("-o").arg(&executable) - .arg("check.c") - .status().expect("Command failed").success() { - panic!("Compile failed"); - } + let stdout_raw = Command::new(out_dir.join(&executable)) + .current_dir(&out_dir) + .output() + .expect("Check failed") + .stdout; + let stdout = str::from_utf8(stdout_raw.as_slice()).unwrap(); - let stdout_raw = Command::new(out_dir.join(&executable)).current_dir(&out_dir).output().expect("Check failed").stdout; - let stdout = str::from_utf8(stdout_raw.as_slice()).unwrap(); + println!("stdout={}", stdout); - println!("stdout={}",stdout); + for &(_, feature, var) in infos { + if let Some(feature) = feature { + if env::var(format!("CARGO_FEATURE_{}", feature.to_uppercase())).is_err() { + continue; + } + } - for &(_, feature, var) in infos { - if let Some(feature) = feature { - if env::var(format!("CARGO_FEATURE_{}", feature.to_uppercase())).is_err() { - continue - } - } + let var_str = format!("[{var}]", var = var); + let pos = stdout.find(&var_str).expect("Variable not found in output") + var_str.len(); + if &stdout[pos..pos + 1] == "1" { + println!(r#"cargo:rustc-cfg=feature="{}""#, var.to_lowercase()); + println!(r#"cargo:{}=true"#, var.to_lowercase()); + } - let var_str = format!("[{var}]", var=var); - let pos = stdout.find(&var_str).expect("Variable not found in output") + var_str.len(); - if &stdout[pos..pos+1] == "1" { - println!(r#"cargo:rustc-cfg=feature="{}""#, var.to_lowercase()); - println!(r#"cargo:{}=true"#, var.to_lowercase()); - } + // Also find out if defined or not (useful for cases where only the definition of a macro + // can be used as distinction) + if &stdout[pos + 1..pos + 2] == "1" { + println!( + r#"cargo:rustc-cfg=feature="{}_is_defined""#, + var.to_lowercase() + ); + println!(r#"cargo:{}_is_defined=true"#, var.to_lowercase()); + } + } - // Also find out if defined or not (useful for cases where only the definition of a macro - // can be used as distinction) - if &stdout[pos+1..pos+2] == "1" { - println!(r#"cargo:rustc-cfg=feature="{}_is_defined""#, var.to_lowercase()); - println!(r#"cargo:{}_is_defined=true"#, var.to_lowercase()); - } - } + for &(lib, begin_version_major, end_version_major, begin_version_minor, end_version_minor) in + version_check_info.iter() + { + for version_major in begin_version_major..end_version_major { + for version_minor in begin_version_minor..end_version_minor { + let search_str = format!( + "[{lib}_version_greater_than_{version_major}_{version_minor}]", + version_major = version_major, + version_minor = version_minor, + lib = lib + ); + let pos = stdout + .find(&search_str) + .expect("Variable not found in output") + + search_str.len(); - for &(lib, begin_version_major, end_version_major, begin_version_minor, end_version_minor) in version_check_info.iter() { - for version_major in begin_version_major..end_version_major { - for version_minor in begin_version_minor..end_version_minor { - let search_str = format!("[{lib}_version_greater_than_{version_major}_{version_minor}]", - version_major=version_major, - version_minor=version_minor, - lib=lib); - let pos = stdout.find(&search_str).expect("Variable not found in output") + search_str.len(); + if &stdout[pos..pos + 1] == "1" { + println!( + r#"cargo:rustc-cfg=feature="{}""#, + &search_str[1..(search_str.len() - 1)] + ); + } + } + } + } +} - if &stdout[pos .. pos + 1] == "1" { - println!(r#"cargo:rustc-cfg=feature="{}""#, &search_str[1..(search_str.len() - 1)]); - } - } - } - } +fn search_include(include_paths: &Vec, header: &str) -> String { + for dir in include_paths { + let include = dir.join(header); + if fs::metadata(&include).is_ok() { + return format!("{}", include.as_path().to_str().unwrap()); + } + } + String::new() } fn main() { - let statik = env::var("CARGO_FEATURE_STATIC").is_ok(); + let statik = env::var("CARGO_FEATURE_STATIC").is_ok(); - let include_paths: Vec = if env::var("CARGO_FEATURE_BUILD").is_ok() { - println!("cargo:rustc-link-search=native={}", search().join("lib").to_string_lossy()); + let include_paths: Vec = if env::var("CARGO_FEATURE_BUILD").is_ok() { + println!( + "cargo:rustc-link-search=native={}", + search().join("lib").to_string_lossy() + ); - if env::var("CARGO_FEATURE_BUILD_ZLIB").is_ok() && cfg!(target_os = "linux") { - println!("cargo:rustc-link-lib=z"); - } + if env::var("CARGO_FEATURE_BUILD_ZLIB").is_ok() && cfg!(target_os = "linux") { + println!("cargo:rustc-link-lib=z"); + } - if fs::metadata(&search().join("lib").join("libavutil.a")).is_err() { - fs::create_dir_all(&output()).ok().expect("failed to create build directory"); - fetch().unwrap(); - build().unwrap(); - } + if fs::metadata(&search().join("lib").join("libavutil.a")).is_err() { + fs::create_dir_all(&output()) + .ok() + .expect("failed to create build directory"); + fetch().unwrap(); + build().unwrap(); + } - // Check additional required libraries. - { - let config_mak = source().join("config.mak"); - let file = File::open(config_mak).unwrap(); - let reader = BufReader::new(file); - let extra_libs = reader.lines() - .find(|ref line| line.as_ref().unwrap().starts_with("EXTRALIBS")) - .map(|line| line.unwrap()).unwrap(); + // Check additional required libraries. + { + let config_mak = source().join("config.mak"); + let file = File::open(config_mak).unwrap(); + let reader = BufReader::new(file); + let extra_libs = reader + .lines() + .find(|ref line| line.as_ref().unwrap().starts_with("EXTRALIBS")) + .map(|line| line.unwrap()) + .unwrap(); - let linker_args = extra_libs.split('=').last().unwrap().split(' '); - let include_libs = linker_args.filter(|v| v.starts_with("-l")).map(|flag| &flag[2..]); + let linker_args = extra_libs.split('=').last().unwrap().split(' '); + let include_libs = linker_args + .filter(|v| v.starts_with("-l")) + .map(|flag| &flag[2..]); - for lib in include_libs { - println!("cargo:rustc-link-lib={}", lib); - } - } + for lib in include_libs { + println!("cargo:rustc-link-lib={}", lib); + } + } - vec![search().join("include")] - } - // Use prebuilt library - else if let Ok(ffmpeg_dir) = env::var("FFMPEG_DIR") { - let ffmpeg_dir = PathBuf::from(ffmpeg_dir); + vec![search().join("include")] + } + // Use prebuilt library + else if let Ok(ffmpeg_dir) = env::var("FFMPEG_DIR") { + let ffmpeg_dir = PathBuf::from(ffmpeg_dir); - println!("cargo:rustc-link-search=native={}", - ffmpeg_dir.join("lib").to_string_lossy()); + println!( + "cargo:rustc-link-search=native={}", + ffmpeg_dir.join("lib").to_string_lossy() + ); - vec![ffmpeg_dir.join("include")] - } - // Fallback to pkg-config - else { - pkg_config::Config::new() - .statik(statik) - .probe("libavcodec").unwrap().include_paths - }; + vec![ffmpeg_dir.join("include")] + } + // Fallback to pkg-config + else { + pkg_config::Config::new() + .statik(statik) + .probe("libavformat") + .unwrap(); - if statik && cfg!(target_os = "macos") { - let frameworks = vec![ - "AppKit", "AudioToolbox", "AVFoundation", "CoreFoundation", - "CoreGraphics", "CoreMedia", "CoreServices", "CoreVideo", - "Foundation", "OpenCL", "OpenGL", "QTKit", "QuartzCore", - "Security", "VideoDecodeAcceleration", "VideoToolbox" - ]; - for f in frameworks { - println!("cargo:rustc-link-lib=framework={}", f); - } - } + pkg_config::Config::new() + .statik(statik) + .probe("libavdevice") + .unwrap(); - check_features(include_paths.clone(), &vec![ - ("libavutil/avutil.h", None, "FF_API_OLD_AVOPTIONS"), + pkg_config::Config::new() + .statik(statik) + .probe("libavcodec") + .unwrap() + .include_paths + }; - ("libavutil/avutil.h", None, "FF_API_PIX_FMT"), - ("libavutil/avutil.h", None, "FF_API_CONTEXT_SIZE"), - ("libavutil/avutil.h", None, "FF_API_PIX_FMT_DESC"), - ("libavutil/avutil.h", None, "FF_API_AV_REVERSE"), - ("libavutil/avutil.h", None, "FF_API_AUDIOCONVERT"), - ("libavutil/avutil.h", None, "FF_API_CPU_FLAG_MMX2"), - ("libavutil/avutil.h", None, "FF_API_LLS_PRIVATE"), - ("libavutil/avutil.h", None, "FF_API_AVFRAME_LAVC"), - ("libavutil/avutil.h", None, "FF_API_VDPAU"), - ("libavutil/avutil.h", None, "FF_API_GET_CHANNEL_LAYOUT_COMPAT"), - ("libavutil/avutil.h", None, "FF_API_XVMC"), - ("libavutil/avutil.h", None, "FF_API_OPT_TYPE_METADATA"), - ("libavutil/avutil.h", None, "FF_API_DLOG"), - ("libavutil/avutil.h", None, "FF_API_HMAC"), - ("libavutil/avutil.h", None, "FF_API_VAAPI"), - ("libavutil/avutil.h", None, "FF_API_PKT_PTS"), - ("libavutil/avutil.h", None, "FF_API_ERROR_FRAME"), - ("libavutil/avutil.h", None, "FF_API_FRAME_QP"), + if statik && cfg!(target_os = "macos") { + let frameworks = vec![ + "AppKit", + "AudioToolbox", + "AVFoundation", + "CoreFoundation", + "CoreGraphics", + "CoreMedia", + "CoreServices", + "CoreVideo", + "Foundation", + "OpenCL", + "OpenGL", + "QTKit", + "QuartzCore", + "Security", + "VideoDecodeAcceleration", + "VideoToolbox", + ]; + for f in frameworks { + println!("cargo:rustc-link-lib=framework={}", f); + } + } - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_VIMA_DECODER"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_REQUEST_CHANNELS"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_OLD_DECODE_AUDIO"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_OLD_ENCODE_AUDIO"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_OLD_ENCODE_VIDEO"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_CODEC_ID"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_AUDIO_CONVERT"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_AVCODEC_RESAMPLE"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_DEINTERLACE"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_DESTRUCT_PACKET"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_GET_BUFFER"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_MISSING_SAMPLE"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_LOWRES"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_CAP_VDPAU"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_BUFS_VDPAU"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_VOXWARE"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_SET_DIMENSIONS"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_DEBUG_MV"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_AC_VLC"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_OLD_MSMPEG4"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_ASPECT_EXTENDED"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_THREAD_OPAQUE"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_CODEC_PKT"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_ARCH_ALPHA"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_XVMC"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_ERROR_RATE"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_QSCALE_TYPE"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_MB_TYPE"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_MAX_BFRAMES"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_NEG_LINESIZES"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_EMU_EDGE"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_ARCH_SH4"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_ARCH_SPARC"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_UNUSED_MEMBERS"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_IDCT_XVIDMMX"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_INPUT_PRESERVED"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_NORMALIZE_AQP"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_GMC"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_MV0"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_CODEC_NAME"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_AFD"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_VISMV"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_DV_FRAME_PROFILE"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_AUDIOENC_DELAY"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_VAAPI_CONTEXT"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_AVCTX_TIMEBASE"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_MPV_OPT"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_STREAM_CODEC_TAG"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_QUANT_BIAS"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_RC_STRATEGY"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_CODED_FRAME"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_MOTION_EST"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_WITHOUT_PREFIX"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_CONVERGENCE_DURATION"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_PRIVATE_OPT"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_CODER_TYPE"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_RTP_CALLBACK"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_STAT_BITS"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_VBV_DELAY"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_SIDEDATA_ONLY_PKT"), - ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_AVPICTURE"), + check_features( + include_paths.clone(), + &vec![ + ("libavutil/avutil.h", None, "FF_API_OLD_AVOPTIONS"), - ("libavformat/avformat.h", Some("avformat"), "FF_API_LAVF_BITEXACT"), - ("libavformat/avformat.h", Some("avformat"), "FF_API_LAVF_FRAC"), - ("libavformat/avformat.h", Some("avformat"), "FF_API_URL_FEOF"), - ("libavformat/avformat.h", Some("avformat"), "FF_API_PROBESIZE_32"), - ("libavformat/avformat.h", Some("avformat"), "FF_API_LAVF_AVCTX"), - ("libavformat/avformat.h", Some("avformat"), "FF_API_OLD_OPEN_CALLBACKS"), + ("libavutil/avutil.h", None, "FF_API_PIX_FMT"), + ("libavutil/avutil.h", None, "FF_API_CONTEXT_SIZE"), + ("libavutil/avutil.h", None, "FF_API_PIX_FMT_DESC"), + ("libavutil/avutil.h", None, "FF_API_AV_REVERSE"), + ("libavutil/avutil.h", None, "FF_API_AUDIOCONVERT"), + ("libavutil/avutil.h", None, "FF_API_CPU_FLAG_MMX2"), + ("libavutil/avutil.h", None, "FF_API_LLS_PRIVATE"), + ("libavutil/avutil.h", None, "FF_API_AVFRAME_LAVC"), + ("libavutil/avutil.h", None, "FF_API_VDPAU"), + ( + "libavutil/avutil.h", + None, + "FF_API_GET_CHANNEL_LAYOUT_COMPAT" + ), + ("libavutil/avutil.h", None, "FF_API_XVMC"), + ("libavutil/avutil.h", None, "FF_API_OPT_TYPE_METADATA"), + ("libavutil/avutil.h", None, "FF_API_DLOG"), + ("libavutil/avutil.h", None, "FF_API_HMAC"), + ("libavutil/avutil.h", None, "FF_API_VAAPI"), + ("libavutil/avutil.h", None, "FF_API_PKT_PTS"), + ("libavutil/avutil.h", None, "FF_API_ERROR_FRAME"), + ("libavutil/avutil.h", None, "FF_API_FRAME_QP"), - ("libavfilter/avfilter.h", Some("avfilter"), "FF_API_AVFILTERPAD_PUBLIC"), - ("libavfilter/avfilter.h", Some("avfilter"), "FF_API_FOO_COUNT"), - ("libavfilter/avfilter.h", Some("avfilter"), "FF_API_OLD_FILTER_OPTS"), - ("libavfilter/avfilter.h", Some("avfilter"), "FF_API_OLD_FILTER_OPTS_ERROR"), - ("libavfilter/avfilter.h", Some("avfilter"), "FF_API_AVFILTER_OPEN"), - ("libavfilter/avfilter.h", Some("avfilter"), "FF_API_OLD_FILTER_REGISTER"), - ("libavfilter/avfilter.h", Some("avfilter"), "FF_API_OLD_GRAPH_PARSE"), - ("libavfilter/avfilter.h", Some("avfilter"), "FF_API_NOCONST_GET_NAME"), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_VIMA_DECODER" + ), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_REQUEST_CHANNELS" + ), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_OLD_DECODE_AUDIO" + ), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_OLD_ENCODE_AUDIO" + ), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_OLD_ENCODE_VIDEO" + ), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_CODEC_ID"), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_AUDIO_CONVERT" + ), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_AVCODEC_RESAMPLE" + ), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_DEINTERLACE" + ), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_DESTRUCT_PACKET" + ), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_GET_BUFFER"), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_MISSING_SAMPLE" + ), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_LOWRES"), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_CAP_VDPAU"), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_BUFS_VDPAU"), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_VOXWARE"), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_SET_DIMENSIONS" + ), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_DEBUG_MV"), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_AC_VLC"), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_OLD_MSMPEG4" + ), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_ASPECT_EXTENDED" + ), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_THREAD_OPAQUE" + ), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_CODEC_PKT"), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_ARCH_ALPHA"), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_XVMC"), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_ERROR_RATE"), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_QSCALE_TYPE" + ), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_MB_TYPE"), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_MAX_BFRAMES" + ), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_NEG_LINESIZES" + ), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_EMU_EDGE"), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_ARCH_SH4"), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_ARCH_SPARC"), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_UNUSED_MEMBERS" + ), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_IDCT_XVIDMMX" + ), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_INPUT_PRESERVED" + ), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_NORMALIZE_AQP" + ), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_GMC"), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_MV0"), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_CODEC_NAME"), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_AFD"), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_VISMV"), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_DV_FRAME_PROFILE" + ), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_AUDIOENC_DELAY" + ), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_VAAPI_CONTEXT" + ), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_AVCTX_TIMEBASE" + ), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_MPV_OPT"), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_STREAM_CODEC_TAG" + ), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_QUANT_BIAS"), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_RC_STRATEGY" + ), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_CODED_FRAME" + ), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_MOTION_EST"), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_WITHOUT_PREFIX" + ), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_CONVERGENCE_DURATION" + ), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_PRIVATE_OPT" + ), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_CODER_TYPE"), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_RTP_CALLBACK" + ), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_STAT_BITS"), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_VBV_DELAY"), + ( + "libavcodec/avcodec.h", + Some("avcodec"), + "FF_API_SIDEDATA_ONLY_PKT" + ), + ("libavcodec/avcodec.h", Some("avcodec"), "FF_API_AVPICTURE"), - ("libavresample/avresample.h", Some("avresample"), "FF_API_RESAMPLE_CLOSE_OPEN"), + ( + "libavformat/avformat.h", + Some("avformat"), + "FF_API_LAVF_BITEXACT" + ), + ( + "libavformat/avformat.h", + Some("avformat"), + "FF_API_LAVF_FRAC" + ), + ( + "libavformat/avformat.h", + Some("avformat"), + "FF_API_URL_FEOF" + ), + ( + "libavformat/avformat.h", + Some("avformat"), + "FF_API_PROBESIZE_32" + ), + ( + "libavformat/avformat.h", + Some("avformat"), + "FF_API_LAVF_AVCTX" + ), + ( + "libavformat/avformat.h", + Some("avformat"), + "FF_API_OLD_OPEN_CALLBACKS" + ), - ("libswscale/swscale.h", Some("swscale"), "FF_API_SWS_CPU_CAPS"), - ("libswscale/swscale.h", Some("swscale"), "FF_API_ARCH_BFIN"), - ]); + ( + "libavfilter/avfilter.h", + Some("avfilter"), + "FF_API_AVFILTERPAD_PUBLIC" + ), + ( + "libavfilter/avfilter.h", + Some("avfilter"), + "FF_API_FOO_COUNT" + ), + ( + "libavfilter/avfilter.h", + Some("avfilter"), + "FF_API_OLD_FILTER_OPTS" + ), + ( + "libavfilter/avfilter.h", + Some("avfilter"), + "FF_API_OLD_FILTER_OPTS_ERROR" + ), + ( + "libavfilter/avfilter.h", + Some("avfilter"), + "FF_API_AVFILTER_OPEN" + ), + ( + "libavfilter/avfilter.h", + Some("avfilter"), + "FF_API_OLD_FILTER_REGISTER" + ), + ( + "libavfilter/avfilter.h", + Some("avfilter"), + "FF_API_OLD_GRAPH_PARSE" + ), + ( + "libavfilter/avfilter.h", + Some("avfilter"), + "FF_API_NOCONST_GET_NAME" + ), - let tmp = std::env::current_dir().unwrap().join("tmp"); - if symlink_metadata(&tmp).is_err() { - create_dir(&tmp).expect("Failed to create temporary output dir"); - } - let mut f = File::create(tmp.join(".build")) - .expect("Filed to create .build"); - let tool = gcc::Config::new().get_compiler(); - write!(f, "{}", tool.path().to_string_lossy().into_owned()) - .expect("failed to write cmd"); - for arg in tool.args() { - write!(f, " {}", arg.to_str().unwrap()).expect("failed to write arg"); - } - for dir in include_paths { - write!(f, " -I {}", dir.to_string_lossy().into_owned()) - .expect("failed to write incdir"); - } + ( + "libavresample/avresample.h", + Some("avresample"), + "FF_API_RESAMPLE_CLOSE_OPEN" + ), + + ( + "libswscale/swscale.h", + Some("swscale"), + "FF_API_SWS_CPU_CAPS" + ), + ("libswscale/swscale.h", Some("swscale"), "FF_API_ARCH_BFIN"), + ], + ); + + let tmp = std::env::current_dir().unwrap().join("tmp"); + if symlink_metadata(&tmp).is_err() { + create_dir(&tmp).expect("Failed to create temporary output dir"); + } + let mut f = File::create(tmp.join(".build")).expect("Filed to create .build"); + let tool = gcc::Config::new().get_compiler(); + write!(f, "{}", tool.path().to_string_lossy().into_owned()).expect("failed to write cmd"); + for arg in tool.args() { + write!(f, " {}", arg.to_str().unwrap()).expect("failed to write arg"); + } + for dir in &include_paths { + write!(f, " -I {}", dir.to_string_lossy().into_owned()).expect("failed to write incdir"); + } + let clang_includes = include_paths + .iter() + .map(|include| format!("-I{}", include.to_string_lossy())); + + // The bindgen::Builder is the main entry point + // to bindgen, and lets you build up options for + // the resulting bindings. + let bindings = bindgen::Builder::default() + .clang_args(clang_includes) + .ctypes_prefix("libc") + .hide_type("AV_CH_LAYOUT_NATIVE") + .hide_type("AVRational") + // https://github.com/servo/rust-bindgen/issues/687 + .hide_type("FP_NAN") + .hide_type("FP_INFINITE") + .hide_type("FP_ZERO") + .hide_type("FP_SUBNORMAL") + .hide_type("FP_NORMAL") + // https://github.com/servo/rust-bindgen/issues/550 + .hide_type("max_align_t") + .prepend_enum_name(false) + .parse_callbacks(Box::new(IntCallbacks)) + // The input header we would like to generate + // bindings for. + .header(search_include(&include_paths, "libavcodec/avcodec.h")) + + .header(search_include(&include_paths, "libavformat/avformat.h")) + + .header(search_include(&include_paths, "libavutil/rational.h")) + .header(search_include(&include_paths, "libavutil/avutil.h")) + .header(search_include(&include_paths, "libavutil/pixfmt.h")) + .header(search_include(&include_paths, "libavutil/time.h")) + + .header(search_include(&include_paths, "libavfilter/buffersrc.h")) + .header(search_include(&include_paths, "libavfilter/avfilter.h")) + .header(search_include(&include_paths, "libavfilter/buffersink.h")) + + .header(search_include(&include_paths, "libswresample/swresample.h")) + + .header(search_include(&include_paths, "libswscale/swscale.h")) + + .header(search_include(&include_paths, "libavdevice/avdevice.h")) + // Finish the builder and generate the bindings. + .generate() + // Unwrap the Result and panic on failure. + .expect("Unable to generate bindings"); + + // Write the bindings to the $OUT_DIR/bindings.rs file. + bindings + .write_to_file(output().join("bindings.rs")) + .expect("Couldn't write bindings!"); } diff --git a/sys/src/avcodec/codec.rs b/sys/src/avcodec/codec.rs deleted file mode 100644 index c8bbfc2..0000000 --- a/sys/src/avcodec/codec.rs +++ /dev/null @@ -1,1662 +0,0 @@ -use libc::{c_void, c_char, c_uchar, c_int, c_uint, c_float, uint8_t, int16_t, uint16_t, uint32_t, int64_t, uint64_t, size_t}; -use avutil::*; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVCodecID { - AV_CODEC_ID_NONE, - - /* video codecs */ - AV_CODEC_ID_MPEG1VIDEO, - AV_CODEC_ID_MPEG2VIDEO, - #[cfg(feature = "ff_api_xvmc")] - AV_CODEC_ID_MPEG2VIDEO_XVMC, - AV_CODEC_ID_H261, - AV_CODEC_ID_H263, - AV_CODEC_ID_RV10, - AV_CODEC_ID_RV20, - AV_CODEC_ID_MJPEG, - AV_CODEC_ID_MJPEGB, - AV_CODEC_ID_LJPEG, - AV_CODEC_ID_SP5X, - AV_CODEC_ID_JPEGLS, - AV_CODEC_ID_MPEG4, - AV_CODEC_ID_RAWVIDEO, - AV_CODEC_ID_MSMPEG4V1, - AV_CODEC_ID_MSMPEG4V2, - AV_CODEC_ID_MSMPEG4V3, - AV_CODEC_ID_WMV1, - AV_CODEC_ID_WMV2, - AV_CODEC_ID_H263P, - AV_CODEC_ID_H263I, - AV_CODEC_ID_FLV1, - AV_CODEC_ID_SVQ1, - AV_CODEC_ID_SVQ3, - AV_CODEC_ID_DVVIDEO, - AV_CODEC_ID_HUFFYUV, - AV_CODEC_ID_CYUV, - AV_CODEC_ID_H264, - AV_CODEC_ID_INDEO3, - AV_CODEC_ID_VP3, - AV_CODEC_ID_THEORA, - AV_CODEC_ID_ASV1, - AV_CODEC_ID_ASV2, - AV_CODEC_ID_FFV1, - AV_CODEC_ID_4XM, - AV_CODEC_ID_VCR1, - AV_CODEC_ID_CLJR, - AV_CODEC_ID_MDEC, - AV_CODEC_ID_ROQ, - AV_CODEC_ID_INTERPLAY_VIDEO, - AV_CODEC_ID_XAN_WC3, - AV_CODEC_ID_XAN_WC4, - AV_CODEC_ID_RPZA, - AV_CODEC_ID_CINEPAK, - AV_CODEC_ID_WS_VQA, - AV_CODEC_ID_MSRLE, - AV_CODEC_ID_MSVIDEO1, - AV_CODEC_ID_IDCIN, - AV_CODEC_ID_8BPS, - AV_CODEC_ID_SMC, - AV_CODEC_ID_FLIC, - AV_CODEC_ID_TRUEMOTION1, - AV_CODEC_ID_VMDVIDEO, - AV_CODEC_ID_MSZH, - AV_CODEC_ID_ZLIB, - AV_CODEC_ID_QTRLE, - AV_CODEC_ID_TSCC, - AV_CODEC_ID_ULTI, - AV_CODEC_ID_QDRAW, - AV_CODEC_ID_VIXL, - AV_CODEC_ID_QPEG, - AV_CODEC_ID_PNG, - AV_CODEC_ID_PPM, - AV_CODEC_ID_PBM, - AV_CODEC_ID_PGM, - AV_CODEC_ID_PGMYUV, - AV_CODEC_ID_PAM, - AV_CODEC_ID_FFVHUFF, - AV_CODEC_ID_RV30, - AV_CODEC_ID_RV40, - AV_CODEC_ID_VC1, - AV_CODEC_ID_WMV3, - AV_CODEC_ID_LOCO, - AV_CODEC_ID_WNV1, - AV_CODEC_ID_AASC, - AV_CODEC_ID_INDEO2, - AV_CODEC_ID_FRAPS, - AV_CODEC_ID_TRUEMOTION2, - AV_CODEC_ID_BMP, - AV_CODEC_ID_CSCD, - AV_CODEC_ID_MMVIDEO, - AV_CODEC_ID_ZMBV, - AV_CODEC_ID_AVS, - AV_CODEC_ID_SMACKVIDEO, - AV_CODEC_ID_NUV, - AV_CODEC_ID_KMVC, - AV_CODEC_ID_FLASHSV, - AV_CODEC_ID_CAVS, - AV_CODEC_ID_JPEG2000, - AV_CODEC_ID_VMNC, - AV_CODEC_ID_VP5, - AV_CODEC_ID_VP6, - AV_CODEC_ID_VP6F, - AV_CODEC_ID_TARGA, - AV_CODEC_ID_DSICINVIDEO, - AV_CODEC_ID_TIERTEXSEQVIDEO, - AV_CODEC_ID_TIFF, - AV_CODEC_ID_GIF, - AV_CODEC_ID_DXA, - AV_CODEC_ID_DNXHD, - AV_CODEC_ID_THP, - AV_CODEC_ID_SGI, - AV_CODEC_ID_C93, - AV_CODEC_ID_BETHSOFTVID, - AV_CODEC_ID_PTX, - AV_CODEC_ID_TXD, - AV_CODEC_ID_VP6A, - AV_CODEC_ID_AMV, - AV_CODEC_ID_VB, - AV_CODEC_ID_PCX, - AV_CODEC_ID_SUNRAST, - AV_CODEC_ID_INDEO4, - AV_CODEC_ID_INDEO5, - AV_CODEC_ID_MIMIC, - AV_CODEC_ID_RL2, - AV_CODEC_ID_ESCAPE124, - AV_CODEC_ID_DIRAC, - AV_CODEC_ID_BFI, - AV_CODEC_ID_CMV, - AV_CODEC_ID_MOTIONPIXELS, - AV_CODEC_ID_TGV, - AV_CODEC_ID_TGQ, - AV_CODEC_ID_TQI, - AV_CODEC_ID_AURA, - AV_CODEC_ID_AURA2, - AV_CODEC_ID_V210X, - AV_CODEC_ID_TMV, - AV_CODEC_ID_V210, - AV_CODEC_ID_DPX, - AV_CODEC_ID_MAD, - AV_CODEC_ID_FRWU, - AV_CODEC_ID_FLASHSV2, - AV_CODEC_ID_CDGRAPHICS, - AV_CODEC_ID_R210, - AV_CODEC_ID_ANM, - AV_CODEC_ID_BINKVIDEO, - AV_CODEC_ID_IFF_ILBM, - AV_CODEC_ID_KGV1, - AV_CODEC_ID_YOP, - AV_CODEC_ID_VP8, - AV_CODEC_ID_PICTOR, - AV_CODEC_ID_ANSI, - AV_CODEC_ID_A64_MULTI, - AV_CODEC_ID_A64_MULTI5, - AV_CODEC_ID_R10K, - AV_CODEC_ID_MXPEG, - AV_CODEC_ID_LAGARITH, - AV_CODEC_ID_PRORES, - AV_CODEC_ID_JV, - AV_CODEC_ID_DFA, - AV_CODEC_ID_WMV3IMAGE, - AV_CODEC_ID_VC1IMAGE, - AV_CODEC_ID_UTVIDEO, - AV_CODEC_ID_BMV_VIDEO, - AV_CODEC_ID_VBLE, - AV_CODEC_ID_DXTORY, - AV_CODEC_ID_V410, - AV_CODEC_ID_XWD, - AV_CODEC_ID_CDXL, - AV_CODEC_ID_XBM, - AV_CODEC_ID_ZEROCODEC, - AV_CODEC_ID_MSS1, - AV_CODEC_ID_MSA1, - AV_CODEC_ID_TSCC2, - AV_CODEC_ID_MTS2, - AV_CODEC_ID_CLLC, - AV_CODEC_ID_MSS2, - AV_CODEC_ID_VP9, - AV_CODEC_ID_AIC, - AV_CODEC_ID_ESCAPE130, - AV_CODEC_ID_G2M, - AV_CODEC_ID_WEBP, - AV_CODEC_ID_HNM4_VIDEO, - AV_CODEC_ID_HEVC, - AV_CODEC_ID_FIC, - AV_CODEC_ID_ALIAS_PIX, - AV_CODEC_ID_BRENDER_PIX, - AV_CODEC_ID_PAF_VIDEO, - AV_CODEC_ID_EXR, - AV_CODEC_ID_VP7, - AV_CODEC_ID_SANM, - AV_CODEC_ID_SGIRLE, - AV_CODEC_ID_MVC1, - AV_CODEC_ID_MVC2, - AV_CODEC_ID_HQX, - AV_CODEC_ID_TDSC, - AV_CODEC_ID_HQ_HQA, - AV_CODEC_ID_HAP, - AV_CODEC_ID_DDS, - AV_CODEC_ID_DXV, - AV_CODEC_ID_SCREENPRESSO, - AV_CODEC_ID_RSCC, - - AV_CODEC_ID_Y41P = 0x8000, - AV_CODEC_ID_AVRP, - AV_CODEC_ID_012V, - AV_CODEC_ID_AVUI, - AV_CODEC_ID_AYUV, - AV_CODEC_ID_TARGA_Y216, - AV_CODEC_ID_V308, - AV_CODEC_ID_V408, - AV_CODEC_ID_YUV4, - AV_CODEC_ID_AVRN, - AV_CODEC_ID_CPIA, - AV_CODEC_ID_XFACE, - AV_CODEC_ID_SNOW, - AV_CODEC_ID_SMVJPEG, - AV_CODEC_ID_APNG, - AV_CODEC_ID_DAALA, - AV_CODEC_ID_CFHD, - AV_CODEC_ID_TRUEMOTION2RT, - AV_CODEC_ID_M101, - AV_CODEC_ID_MAGICYUV, - AV_CODEC_ID_SHEERVIDEO, - AV_CODEC_ID_YLC, - - /* various PCM "codecs" */ - AV_CODEC_ID_PCM_S16LE = 0x10000, - AV_CODEC_ID_PCM_S16BE, - AV_CODEC_ID_PCM_U16LE, - AV_CODEC_ID_PCM_U16BE, - AV_CODEC_ID_PCM_S8, - AV_CODEC_ID_PCM_U8, - AV_CODEC_ID_PCM_MULAW, - AV_CODEC_ID_PCM_ALAW, - AV_CODEC_ID_PCM_S32LE, - AV_CODEC_ID_PCM_S32BE, - AV_CODEC_ID_PCM_U32LE, - AV_CODEC_ID_PCM_U32BE, - AV_CODEC_ID_PCM_S24LE, - AV_CODEC_ID_PCM_S24BE, - AV_CODEC_ID_PCM_U24LE, - AV_CODEC_ID_PCM_U24BE, - AV_CODEC_ID_PCM_S24DAUD, - AV_CODEC_ID_PCM_ZORK, - AV_CODEC_ID_PCM_S16LE_PLANAR, - AV_CODEC_ID_PCM_DVD, - AV_CODEC_ID_PCM_F32BE, - AV_CODEC_ID_PCM_F32LE, - AV_CODEC_ID_PCM_F64BE, - AV_CODEC_ID_PCM_F64LE, - AV_CODEC_ID_PCM_BLURAY, - AV_CODEC_ID_PCM_LXF, - AV_CODEC_ID_S302M, - AV_CODEC_ID_PCM_S8_PLANAR, - AV_CODEC_ID_PCM_S24LE_PLANAR, - AV_CODEC_ID_PCM_S32LE_PLANAR, - AV_CODEC_ID_PCM_S16BE_PLANAR, - - AV_CODEC_ID_PCM_S64LE = 0x10800, - AV_CODEC_ID_PCM_S64BE, - - /* various ADPCM codecs */ - AV_CODEC_ID_ADPCM_IMA_QT = 0x11000, - AV_CODEC_ID_ADPCM_IMA_WAV, - AV_CODEC_ID_ADPCM_IMA_DK3, - AV_CODEC_ID_ADPCM_IMA_DK4, - AV_CODEC_ID_ADPCM_IMA_WS, - AV_CODEC_ID_ADPCM_IMA_SMJPEG, - AV_CODEC_ID_ADPCM_MS, - AV_CODEC_ID_ADPCM_4XM, - AV_CODEC_ID_ADPCM_XA, - AV_CODEC_ID_ADPCM_ADX, - AV_CODEC_ID_ADPCM_EA, - AV_CODEC_ID_ADPCM_G726, - AV_CODEC_ID_ADPCM_CT, - AV_CODEC_ID_ADPCM_SWF, - AV_CODEC_ID_ADPCM_YAMAHA, - AV_CODEC_ID_ADPCM_SBPRO_4, - AV_CODEC_ID_ADPCM_SBPRO_3, - AV_CODEC_ID_ADPCM_SBPRO_2, - AV_CODEC_ID_ADPCM_THP, - AV_CODEC_ID_ADPCM_IMA_AMV, - AV_CODEC_ID_ADPCM_EA_R1, - AV_CODEC_ID_ADPCM_EA_R3, - AV_CODEC_ID_ADPCM_EA_R2, - AV_CODEC_ID_ADPCM_IMA_EA_SEAD, - AV_CODEC_ID_ADPCM_IMA_EA_EACS, - AV_CODEC_ID_ADPCM_EA_XAS, - AV_CODEC_ID_ADPCM_EA_MAXIS_XA, - AV_CODEC_ID_ADPCM_IMA_ISS, - AV_CODEC_ID_ADPCM_G722, - AV_CODEC_ID_ADPCM_IMA_APC, - AV_CODEC_ID_ADPCM_VIMA, - - AV_CODEC_ID_ADPCM_AFC = 0x11800, - AV_CODEC_ID_ADPCM_IMA_OKI, - AV_CODEC_ID_ADPCM_DTK, - AV_CODEC_ID_ADPCM_IMA_RAD, - AV_CODEC_ID_ADPCM_G726LE, - AV_CODEC_ID_ADPCM_THP_LE, - AV_CODEC_ID_ADPCM_PSX, - AV_CODEC_ID_ADPCM_AICA, - AV_CODEC_ID_ADPCM_IMA_DAT4, - AV_CODEC_ID_ADPCM_MTAF, - - /* AMR */ - AV_CODEC_ID_AMR_NB = 0x12000, - AV_CODEC_ID_AMR_WB, - - /* RealAudio codecs*/ - AV_CODEC_ID_RA_144 = 0x13000, - AV_CODEC_ID_RA_288, - - /* various DPCM codecs */ - AV_CODEC_ID_ROQ_DPCM = 0x14000, - AV_CODEC_ID_INTERPLAY_DPCM, - AV_CODEC_ID_XAN_DPCM, - AV_CODEC_ID_SOL_DPCM, - - AV_CODEC_ID_SDX2_DPCM = 0x14800, - - /* audio codecs */ - AV_CODEC_ID_MP2 = 0x15000, - AV_CODEC_ID_MP3, - AV_CODEC_ID_AAC, - AV_CODEC_ID_AC3, - AV_CODEC_ID_DTS, - AV_CODEC_ID_VORBIS, - AV_CODEC_ID_DVAUDIO, - AV_CODEC_ID_WMAV1, - AV_CODEC_ID_WMAV2, - AV_CODEC_ID_MACE3, - AV_CODEC_ID_MACE6, - AV_CODEC_ID_VMDAUDIO, - AV_CODEC_ID_FLAC, - AV_CODEC_ID_MP3ADU, - AV_CODEC_ID_MP3ON4, - AV_CODEC_ID_SHORTEN, - AV_CODEC_ID_ALAC, - AV_CODEC_ID_WESTWOOD_SND1, - AV_CODEC_ID_GSM, - AV_CODEC_ID_QDM2, - AV_CODEC_ID_COOK, - AV_CODEC_ID_TRUESPEECH, - AV_CODEC_ID_TTA, - AV_CODEC_ID_SMACKAUDIO, - AV_CODEC_ID_QCELP, - AV_CODEC_ID_WAVPACK, - AV_CODEC_ID_DSICINAUDIO, - AV_CODEC_ID_IMC, - AV_CODEC_ID_MUSEPACK7, - AV_CODEC_ID_MLP, - AV_CODEC_ID_GSM_MS, - AV_CODEC_ID_ATRAC3, - #[cfg(feature = "ff_api_voxware")] - AV_CODEC_ID_VOXWARE, - AV_CODEC_ID_APE, - AV_CODEC_ID_NELLYMOSER, - AV_CODEC_ID_MUSEPACK8, - AV_CODEC_ID_SPEEX, - AV_CODEC_ID_WMAVOICE, - AV_CODEC_ID_WMAPRO, - AV_CODEC_ID_WMALOSSLESS, - AV_CODEC_ID_ATRAC3P, - AV_CODEC_ID_EAC3, - AV_CODEC_ID_SIPR, - AV_CODEC_ID_MP1, - AV_CODEC_ID_TWINVQ, - AV_CODEC_ID_TRUEHD, - AV_CODEC_ID_MP4ALS, - AV_CODEC_ID_ATRAC1, - AV_CODEC_ID_BINKAUDIO_RDFT, - AV_CODEC_ID_BINKAUDIO_DCT, - AV_CODEC_ID_AAC_LATM, - AV_CODEC_ID_QDMC, - AV_CODEC_ID_CELT, - AV_CODEC_ID_G723_1, - AV_CODEC_ID_G729, - AV_CODEC_ID_8SVX_EXP, - AV_CODEC_ID_8SVX_FIB, - AV_CODEC_ID_BMV_AUDIO, - AV_CODEC_ID_RALF, - AV_CODEC_ID_IAC, - AV_CODEC_ID_ILBC, - AV_CODEC_ID_OPUS, - AV_CODEC_ID_COMFORT_NOISE, - AV_CODEC_ID_TAK, - AV_CODEC_ID_METASOUND, - AV_CODEC_ID_PAF_AUDIO, - AV_CODEC_ID_ON2AVC, - AV_CODEC_ID_DSS_SP, - - AV_CODEC_ID_FFWAVESYNTH = 0x15800, - AV_CODEC_ID_SONIC, - AV_CODEC_ID_SONIC_LS, - AV_CODEC_ID_EVRC, - AV_CODEC_ID_SMV, - AV_CODEC_ID_DSD_LSBF, - AV_CODEC_ID_DSD_MSBF, - AV_CODEC_ID_DSD_LSBF_PLANAR, - AV_CODEC_ID_DSD_MSBF_PLANAR, - AV_CODEC_ID_4GV, - AV_CODEC_ID_INTERPLAY_ACM, - AV_CODEC_ID_XMA1, - AV_CODEC_ID_XMA2, - AV_CODEC_ID_DST, - - /* subtitle codecs */ - AV_CODEC_ID_DVD_SUBTITLE = 0x17000, - AV_CODEC_ID_DVB_SUBTITLE, - AV_CODEC_ID_TEXT, - AV_CODEC_ID_XSUB, - AV_CODEC_ID_SSA, - AV_CODEC_ID_MOV_TEXT, - AV_CODEC_ID_HDMV_PGS_SUBTITLE, - AV_CODEC_ID_DVB_TELETEXT, - AV_CODEC_ID_SRT, - - AV_CODEC_ID_MICRODVD = 0x17800, - AV_CODEC_ID_EIA_608, - AV_CODEC_ID_JACOSUB, - AV_CODEC_ID_SAMI, - AV_CODEC_ID_REALTEXT, - AV_CODEC_ID_STL, - AV_CODEC_ID_SUBVIEWER1, - AV_CODEC_ID_SUBVIEWER, - AV_CODEC_ID_SUBRIP, - AV_CODEC_ID_WEBVTT, - AV_CODEC_ID_MPL2, - AV_CODEC_ID_VPLAYER, - AV_CODEC_ID_PJS, - AV_CODEC_ID_ASS, - AV_CODEC_ID_HDMV_TEXT_SUBTITLE, - - /* other specific kind of codecs (generally used for attachments) */ - AV_CODEC_ID_TTF = 0x18000, - - AV_CODEC_ID_SCTE_35, // Contain timestamp estimated through PCR of program stream. - AV_CODEC_ID_BINTEXT = 0x18800, - AV_CODEC_ID_XBIN, - AV_CODEC_ID_IDF, - AV_CODEC_ID_OTF, - AV_CODEC_ID_SMPTE_KLV, - AV_CODEC_ID_DVD_NAV, - AV_CODEC_ID_TIMED_ID3, - AV_CODEC_ID_BIN_DATA, - - AV_CODEC_ID_PROBE = 0x19000, - - AV_CODEC_ID_MPEG2TS = 0x20000, - AV_CODEC_ID_MPEG4SYSTEMS = 0x20001, - AV_CODEC_ID_FFMETADATA = 0x21000, - AV_CODEC_ID_WRAPPED_AVFRAME = 0x21001, -} - -pub const AV_CODEC_ID_IFF_BYTERUN1: AVCodecID = AVCodecID::AV_CODEC_ID_IFF_ILBM; -pub const AV_CODEC_ID_H265: AVCodecID = AVCodecID::AV_CODEC_ID_HEVC; - -pub const AV_CODEC_ID_VIMA: AVCodecID = AVCodecID::AV_CODEC_ID_ADPCM_VIMA; - -pub const AV_CODEC_ID_FIRST_AUDIO: AVCodecID = AVCodecID::AV_CODEC_ID_PCM_S16LE; -pub const AV_CODEC_ID_FIRST_SUBTITLE: AVCodecID = AVCodecID::AV_CODEC_ID_DVD_SUBTITLE; -pub const AV_CODEC_ID_FIRST_UNKNOWN: AVCodecID = AVCodecID::AV_CODEC_ID_TTF; - -#[derive(Debug)] -#[repr(C)] -pub struct AVCodecDescriptor { - id: AVCodecID, - kind: AVMediaType, - - name: *const c_char, - long_name: *const c_char, - - props: c_int, - mime_types: *const *const c_char, - profiles: *const AVProfile, -} - -pub const AV_CODEC_PROP_INTRA_ONLY: c_int = 1 << 0; -pub const AV_CODEC_PROP_LOSSY: c_int = 1 << 1; -pub const AV_CODEC_PROP_LOSSLESS: c_int = 1 << 2; -pub const AV_CODEC_PROP_REORDER: c_int = 1 << 3; -pub const AV_CODEC_PROP_BITMAP_SUB: c_int = 1 << 16; -pub const AV_CODEC_PROP_TEXT_SUB: c_int = 1 << 17; - -pub const AV_INPUT_BUFFER_PADDING_SIZE: c_int = 32; -pub const AV_MIN_BUFFER_SIZE: c_int = 16384; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum Motion_Est_ID { - ME_ZERO = 1, - ME_FULL, - ME_LOG, - ME_PHODS, - ME_EPZS, - ME_X1, - ME_HEX, - ME_UMH, - ME_TESA, - ME_ITER = 50, -} - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVDiscard{ - AVDISCARD_NONE = -16, - AVDISCARD_DEFAULT = 0, - AVDISCARD_NONREF = 8, - AVDISCARD_BIDIR = 16, - AVDISCARD_NONINTRA = 24, - AVDISCARD_NONKEY = 32, - AVDISCARD_ALL = 48, -} - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVAudioServiceType { - AV_AUDIO_SERVICE_TYPE_MAIN = 0, - AV_AUDIO_SERVICE_TYPE_EFFECTS = 1, - AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED = 2, - AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED = 3, - AV_AUDIO_SERVICE_TYPE_DIALOGUE = 4, - AV_AUDIO_SERVICE_TYPE_COMMENTARY = 5, - AV_AUDIO_SERVICE_TYPE_EMERGENCY = 6, - AV_AUDIO_SERVICE_TYPE_VOICE_OVER = 7, - AV_AUDIO_SERVICE_TYPE_KARAOKE = 8, - AV_AUDIO_SERVICE_TYPE_NB, -} - -#[derive(Debug)] -#[repr(C)] -pub struct RcOverride { - start_frame: c_int, - end_frame: c_int, - qscale: c_int, - quality_factor: c_float, -} - -pub const AV_CODEC_FLAG_UNALIGNED: c_uint = 0x0001; -pub const AV_CODEC_FLAG_QSCALE: c_uint = 0x0002; -pub const AV_CODEC_FLAG_4MV: c_uint = 0x0004; -pub const AV_CODEC_FLAG_OUTPUT_CORRUPT: c_uint = 0x0008; -pub const AV_CODEC_FLAG_QPEL: c_uint = 0x0010; -pub const AV_CODEC_FLAG_PASS1: c_uint = 0x0200; -pub const AV_CODEC_FLAG_PASS2: c_uint = 0x0400; -pub const AV_CODEC_FLAG_LOOP_FILTER: c_uint = 0x0800; -pub const AV_CODEC_FLAG_GRAY: c_uint = 0x2000; -pub const AV_CODEC_FLAG_PSNR: c_uint = 0x8000; -pub const AV_CODEC_FLAG_TRUNCATED: c_uint = 0x00010000; -pub const AV_CODEC_FLAG_INTERLACED_DCT: c_uint = 0x00040000; -pub const AV_CODEC_FLAG_LOW_DELAY: c_uint = 0x00080000; -pub const AV_CODEC_FLAG_GLOBAL_HEADER: c_uint = 0x00400000; -pub const AV_CODEC_FLAG_BITEXACT: c_uint = 0x00800000; -pub const AV_CODEC_FLAG_AC_PRED: c_uint = 0x01000000; -pub const AV_CODEC_FLAG_INTERLACED_ME: c_uint = 0x20000000; -pub const AV_CODEC_FLAG_CLOSED_GOP: c_uint = 0x80000000; - -pub const AV_CODEC_FLAG2_FAST: c_uint = 0x00000001; -pub const AV_CODEC_FLAG2_NO_OUTPUT: c_uint = 0x00000004; -pub const AV_CODEC_FLAG2_LOCAL_HEADER: c_uint = 0x00000008; -pub const AV_CODEC_FLAG2_DROP_FRAME_TIMECODE: c_uint = 0x00002000; -pub const AV_CODEC_FLAG2_CHUNKS: c_uint = 0x00008000; -pub const AV_CODEC_FLAG2_IGNORE_CROP: c_uint = 0x00010000; -pub const AV_CODEC_FLAG2_SHOW_ALL: c_uint = 0x00400000; -pub const AV_CODEC_FLAG2_EXPORT_MVS: c_uint = 0x10000000; -pub const AV_CODEC_FLAG2_SKIP_MANUAL: c_uint = 0x20000000; -pub const AV_CODEC_FLAG2_NO_FLUSH_NOOP: c_uint = 0x40000000; - -pub const AV_CODEC_CAP_DRAW_HORIZ_BAND: c_uint = 0x0001; -pub const AV_CODEC_CAP_DR1: c_uint = 0x0002; -pub const AV_CODEC_CAP_TRUNCATED: c_uint = 0x0008; -pub const AV_CODEC_CAP_DELAY: c_uint = 0x0020; -pub const AV_CODEC_CAP_SMALL_LAST_FRAME: c_uint = 0x0040; -pub const AV_CODEC_CAP_HWACCEL_VDPAU: c_uint = 0x0080; -pub const AV_CODEC_CAP_SUBFRAMES: c_uint = 0x0100; -pub const AV_CODEC_CAP_EXPERIMENTAL: c_uint = 0x0200; -pub const AV_CODEC_CAP_CHANNEL_CONF: c_uint = 0x0400; -pub const AV_CODEC_CAP_FRAME_THREADS: c_uint = 0x1000; -pub const AV_CODEC_CAP_SLICE_THREADS: c_uint = 0x2000; -pub const AV_CODEC_CAP_PARAM_CHANGE: c_uint = 0x4000; -pub const AV_CODEC_CAP_AUTO_THREADS: c_uint = 0x8000; -pub const AV_CODEC_CAP_VARIABLE_FRAME_SIZE: c_uint = 0x10000; -pub const AV_CODEC_CAP_AVOID_PROBING: c_uint = 0x20000; -pub const AV_CODEC_CAP_INTRA_ONLY: c_uint = 0x40000000; -pub const AV_CODEC_CAP_LOSSLESS: c_uint = 0x80000000; - -pub const HWACCEL_CODEC_CAP_EXPERIMENTAL: c_uint = 0x0200; - -pub const MB_TYPE_INTRA4x4: c_int = 0x0001; -pub const MB_TYPE_INTRA16x16: c_int = 0x0002; -pub const MB_TYPE_INTRA_PCM: c_int = 0x0004; -pub const MB_TYPE_16x16: c_int = 0x0008; -pub const MB_TYPE_16x8: c_int = 0x0010; -pub const MB_TYPE_8x16: c_int = 0x0020; -pub const MB_TYPE_8x8: c_int = 0x0040; -pub const MB_TYPE_INTERLACED: c_int = 0x0080; -pub const MB_TYPE_DIRECT2: c_int = 0x0100; -pub const MB_TYPE_ACPRED: c_int = 0x0200; -pub const MB_TYPE_GMC: c_int = 0x0400; -pub const MB_TYPE_SKIP: c_int = 0x0800; -pub const MB_TYPE_P0L0: c_int = 0x1000; -pub const MB_TYPE_P1L0: c_int = 0x2000; -pub const MB_TYPE_P0L1: c_int = 0x4000; -pub const MB_TYPE_P1L1: c_int = 0x8000; -pub const MB_TYPE_L0: c_int = MB_TYPE_P0L0 | MB_TYPE_P1L0; -pub const MB_TYPE_L1: c_int = MB_TYPE_P0L1 | MB_TYPE_P1L1; -pub const MB_TYPE_L0L1: c_int = MB_TYPE_L0 | MB_TYPE_L1; -pub const MB_TYPE_QUANT: c_int = 0x00010000; -pub const MB_TYPE_CBP: c_int = 0x00020000; - -#[derive(Debug)] -#[repr(C)] -pub struct AVPanScan { - id: c_int, - width: c_int, - height: c_int, - position: [[int16_t; 2]; 3], -} - -#[derive(Debug)] -#[repr(C)] -pub struct AVCPBProperties { - max_bitrate: c_int, - min_bitrate: c_int, - avg_bitrate: c_int, - buffer_size: c_int, - vbv_delay: uint64_t, -} - -pub const FF_QSCALE_TYPE_MPEG1: c_int = 0; -pub const FF_QSCALE_TYPE_MPEG2: c_int = 1; -pub const FF_QSCALE_TYPE_H264: c_int = 2; -pub const FF_QSCALE_TYPE_VP56: c_int = 3; - -pub const AV_GET_BUFFER_FLAG_REF: c_int = 1 << 0; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVPacketSideDataType { - AV_PKT_DATA_PALETTE, - AV_PKT_DATA_NEW_EXTRADATA, - AV_PKT_DATA_PARAM_CHANGE, - AV_PKT_DATA_H263_MB_INFO, - AV_PKT_DATA_REPLAYGAIN, - AV_PKT_DATA_DISPLAYMATRIX, - AV_PKT_DATA_STEREO3D, - AV_PKT_DATA_AUDIO_SERVICE_TYPE, - AV_PKT_DATA_QUALITY_STATS, - AV_PKT_DATA_FALLBACK_TRACK, - AV_PKT_DATA_CPB_PROPERTIES, - AV_PKT_DATA_SKIP_SAMPLES = 70, - AV_PKT_DATA_JP_DUALMONO, - AV_PKT_DATA_STRINGS_METADATA, - AV_PKT_DATA_SUBTITLE_POSITION, - AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL, - AV_PKT_DATA_WEBVTT_IDENTIFIER, - AV_PKT_DATA_WEBVTT_SETTINGS, - AV_PKT_DATA_METADATA_UPDATE, - AV_PKT_DATA_MPEGTS_STREAM_ID, - AV_PKT_DATA_MASTERING_DISPLAY_METADATA, -} - -pub const AV_PKT_DATA_QUALITY_FACTOR: AVPacketSideDataType = - AVPacketSideDataType::AV_PKT_DATA_QUALITY_STATS; - -#[derive(Debug)] -#[repr(C)] -pub struct AVPacketSideData { - pub data: *mut uint8_t, - pub size: c_int, - pub kind: AVPacketSideDataType, -} - -#[repr(C)] -pub struct AVPacket { - pub buf: *mut AVBufferRef, - pub pts: int64_t, - pub dts: int64_t, - pub data: *mut uint8_t, - pub size: c_int, - pub stream_index: c_int, - pub flags: c_int, - pub side_data: *mut AVPacketSideData, - pub side_data_elems: c_int, - pub duration: int64_t, - pub pos: int64_t, - #[cfg(feature = "ff_api_convergence_duration")] - pub convergence_duration: int64_t, -} - -pub const AV_PKT_FLAG_KEY: c_int = 0x0001; -pub const AV_PKT_FLAG_CORRUPT: c_int = 0x0002; -pub const AV_PKT_FLAG_DISCARD: c_int = 0x0004; - -pub enum AVSideDataParamChangeFlags { - AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT = 0x0001, - AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT = 0x0002, - AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE = 0x0004, - AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS = 0x0008, -} - -pub type AVCodecInternal = c_void; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVFieldOrder { - AV_FIELD_UNKNOWN, - AV_FIELD_PROGRESSIVE, - AV_FIELD_TT, - AV_FIELD_BB, - AV_FIELD_TB, - AV_FIELD_BT, -} - -pub const FF_COMPRESSION_DEFAULT: c_int = -1; -pub const FF_ASPECT_EXTENDED: c_int = 15; -pub const FF_RC_STRATEGY_XVID: c_int = 1; -pub const FF_DEFAULT_QUANT_BIAS: c_int = 999999; - -pub const FF_PRED_LEFT: c_int = 0; -pub const FF_PRED_PLANE: c_int = 1; -pub const FF_PRED_MEDIAN: c_int = 2; - -pub const FF_CMP_SAD: c_int = 0; -pub const FF_CMP_SSE: c_int = 1; -pub const FF_CMP_SATD: c_int = 2; -pub const FF_CMP_DCT: c_int = 3; -pub const FF_CMP_PSNR: c_int = 4; -pub const FF_CMP_BIT: c_int = 5; -pub const FF_CMP_RD: c_int = 6; -pub const FF_CMP_ZERO: c_int = 7; -pub const FF_CMP_VSAD: c_int = 8; -pub const FF_CMP_VSSE: c_int = 9; -pub const FF_CMP_NSSE: c_int = 10; -pub const FF_CMP_W53: c_int = 11; -pub const FF_CMP_W97: c_int = 12; -pub const FF_CMP_DCTMAX: c_int = 13; -pub const FF_CMP_DCT264: c_int = 14; -pub const FF_CMP_CHROMA: c_int = 256; - -pub const SLICE_FLAG_CODED_ORDER: c_int = 0x0001; -pub const SLICE_FLAG_ALLOW_FIELD: c_int = 0x0002; -pub const SLICE_FLAG_ALLOW_PLANE: c_int = 0x0004; - -pub const FF_MB_DECISION_SIMPLE: c_int = 0; -pub const FF_MB_DECISION_BITS: c_int = 1; -pub const FF_MB_DECISION_RD: c_int = 2; - -pub const FF_CODER_TYPE_VLC: c_int = 0; -pub const FF_CODER_TYPE_AC: c_int = 1; -pub const FF_CODER_TYPE_RAW: c_int = 2; -pub const FF_CODER_TYPE_RLE: c_int = 3; -pub const FF_CODER_TYPE_DEFLATE: c_int = 4; - -pub const FF_BUG_AUTODETECT: c_int = 1; -pub const FF_BUG_OLD_MSMPEG4: c_int = 2; -pub const FF_BUG_XVID_ILACE: c_int = 4; -pub const FF_BUG_UMP4: c_int = 8; -pub const FF_BUG_NO_PADDING: c_int = 16; -pub const FF_BUG_AMV: c_int = 32; -pub const FF_BUG_AC_VLC: c_int = 0; -pub const FF_BUG_QPEL_CHROMA: c_int = 64; -pub const FF_BUG_STD_QPEL: c_int = 128; -pub const FF_BUG_QPEL_CHROMA2: c_int = 256; -pub const FF_BUG_DIRECT_BLOCKSIZE: c_int = 512; -pub const FF_BUG_EDGE: c_int = 1024; -pub const FF_BUG_HPEL_CHROMA: c_int = 2048; -pub const FF_BUG_DC_CLIP: c_int = 4096; -pub const FF_BUG_MS: c_int = 8192; -pub const FF_BUG_TRUNCATED: c_int = 16384; - -pub const FF_COMPLIANCE_VERY_STRICT: c_int = 2; -pub const FF_COMPLIANCE_STRICT: c_int = 1; -pub const FF_COMPLIANCE_NORMAL: c_int = 0; -pub const FF_COMPLIANCE_UNOFFICIAL: c_int = -1; -pub const FF_COMPLIANCE_EXPERIMENTAL: c_int = -2; - -pub const FF_EC_GUESS_MVS: c_int = 1; -pub const FF_EC_DEBLOCK: c_int = 2; -pub const FF_EC_FAVOR_INTER: c_int = 256; - -pub const FF_DEBUG_PICT_INFO: c_int = 1; -pub const FF_DEBUG_RC: c_int = 2; -pub const FF_DEBUG_BITSTREAM: c_int = 4; -pub const FF_DEBUG_MB_TYPE: c_int = 8; -pub const FF_DEBUG_QP: c_int = 16; -pub const FF_DEBUG_MV: c_int = 32; -pub const FF_DEBUG_DCT_COEFF: c_int = 0x00000040; -pub const FF_DEBUG_SKIP: c_int = 0x00000080; -pub const FF_DEBUG_STARTCODE: c_int = 0x00000100; -pub const FF_DEBUG_PTS: c_int = 0x00000200; -pub const FF_DEBUG_ER: c_int = 0x00000400; -pub const FF_DEBUG_MMCO: c_int = 0x00000800; -pub const FF_DEBUG_BUGS: c_int = 0x00001000; -pub const FF_DEBUG_VIS_QP: c_int = 0x00002000; -pub const FF_DEBUG_VIS_MB_TYPE: c_int = 0x00004000; -pub const FF_DEBUG_BUFFERS: c_int = 0x00008000; -pub const FF_DEBUG_THREADS: c_int = 0x00010000; -pub const FF_DEBUG_GREEN_MD: c_int = 0x00800000; -pub const FF_DEBUG_NOMC: c_int = 0x01000000; - -pub const AV_EF_CRCCHECK: c_int = 1 << 0; -pub const AV_EF_BITSTREAM: c_int = 1 << 1; -pub const AV_EF_BUFFER: c_int = 1 << 2; -pub const AV_EF_EXPLODE: c_int = 1 << 3; -pub const AV_EF_IGNORE_ERR: c_int = 1 << 15; -pub const AV_EF_CAREFUL: c_int = 1 << 16; -pub const AV_EF_COMPLIANT: c_int = 1 << 17; -pub const AV_EF_AGGRESSIVE: c_int = 1 << 18; - -pub const FF_DCT_AUTO: c_int = 0; -pub const FF_DCT_FASTINT: c_int = 1; -pub const FF_DCT_INT: c_int = 2; -pub const FF_DCT_MMX: c_int = 3; -pub const FF_DCT_ALTIVEC: c_int = 5; -pub const FF_DCT_FAAN: c_int = 6; - -pub const FF_IDCT_AUTO: c_int = 0; -pub const FF_IDCT_INT: c_int = 1; -pub const FF_IDCT_SIMPLE: c_int = 2; -pub const FF_IDCT_SIMPLEMMX: c_int = 3; -pub const FF_IDCT_ARM: c_int = 7; -pub const FF_IDCT_ALTIVEC: c_int = 8; -pub const FF_IDCT_SH4: c_int = 9; -pub const FF_IDCT_SIMPLEARM: c_int = 10; -pub const FF_IDCT_IPP: c_int = 13; -pub const FF_IDCT_XVID: c_int = 14; -pub const FF_IDCT_XVIDMMX: c_int = 14; -pub const FF_IDCT_SIMPLEARMV5TE: c_int = 16; -pub const FF_IDCT_SIMPLEARMV6: c_int = 17; -pub const FF_IDCT_SIMPLEVIS: c_int = 18; -pub const FF_IDCT_FAAN: c_int = 20; -pub const FF_IDCT_SIMPLENEON: c_int = 22; -pub const FF_IDCT_SIMPLEALPHA: c_int = 23; -pub const FF_IDCT_SIMPLEAUTO: c_int = 128; - -pub const FF_THREAD_FRAME: c_int = 1; -pub const FF_THREAD_SLICE: c_int = 2; - -pub const FF_PROFILE_UNKNOWN: c_int = -99; -pub const FF_PROFILE_RESERVED: c_int = -100; - -pub const FF_PROFILE_AAC_MAIN: c_int = 0; -pub const FF_PROFILE_AAC_LOW: c_int = 1; -pub const FF_PROFILE_AAC_SSR: c_int = 2; -pub const FF_PROFILE_AAC_LTP: c_int = 3; -pub const FF_PROFILE_AAC_HE: c_int = 4; -pub const FF_PROFILE_AAC_HE_V2: c_int = 28; -pub const FF_PROFILE_AAC_LD: c_int = 22; -pub const FF_PROFILE_AAC_ELD: c_int = 38; -pub const FF_PROFILE_MPEG2_AAC_LOW: c_int = 128; -pub const FF_PROFILE_MPEG2_AAC_HE: c_int = 131; - -pub const FF_PROFILE_DNXHD: c_int = 0; -pub const FF_PROFILE_DNXHR_LB: c_int = 1; -pub const FF_PROFILE_DNXHR_SQ: c_int = 2; -pub const FF_PROFILE_DNXHR_HQ: c_int = 3; -pub const FF_PROFILE_DNXHR_HQX: c_int = 4; -pub const FF_PROFILE_DNXHR_444: c_int = 5; - -pub const FF_PROFILE_DTS: c_int = 20; -pub const FF_PROFILE_DTS_ES: c_int = 30; -pub const FF_PROFILE_DTS_96_24: c_int = 40; -pub const FF_PROFILE_DTS_HD_HRA: c_int = 50; -pub const FF_PROFILE_DTS_HD_MA: c_int = 60; -pub const FF_PROFILE_DTS_EXPRESS: c_int = 70; - -pub const FF_PROFILE_MPEG2_422: c_int = 0; -pub const FF_PROFILE_MPEG2_HIGH: c_int = 1; -pub const FF_PROFILE_MPEG2_SS: c_int = 2; -pub const FF_PROFILE_MPEG2_SNR_SCALABLE: c_int = 3; -pub const FF_PROFILE_MPEG2_MAIN: c_int = 4; -pub const FF_PROFILE_MPEG2_SIMPLE: c_int = 5; - -pub const FF_PROFILE_H264_CONSTRAINED: c_int = 1 << 9; -pub const FF_PROFILE_H264_INTRA: c_int = 1 << 11; - -pub const FF_PROFILE_H264_BASELINE: c_int = 66; -pub const FF_PROFILE_H264_CONSTRAINED_BASELINE: c_int = 66 | FF_PROFILE_H264_CONSTRAINED; -pub const FF_PROFILE_H264_MAIN: c_int = 77; -pub const FF_PROFILE_H264_EXTENDED: c_int = 88; -pub const FF_PROFILE_H264_HIGH: c_int = 100; -pub const FF_PROFILE_H264_HIGH_10: c_int = 110; -pub const FF_PROFILE_H264_HIGH_10_INTRA: c_int = 110 | FF_PROFILE_H264_INTRA; -pub const FF_PROFILE_H264_MULTIVIEW_HIGH: c_int = 118; -pub const FF_PROFILE_H264_HIGH_422: c_int = 122; -pub const FF_PROFILE_H264_HIGH_422_INTRA: c_int = 122 | FF_PROFILE_H264_INTRA; -pub const FF_PROFILE_H264_STEREO_HIGH: c_int = 128; -pub const FF_PROFILE_H264_HIGH_444: c_int = 144; -pub const FF_PROFILE_H264_HIGH_444_PREDICTIVE: c_int = 244; -pub const FF_PROFILE_H264_HIGH_444_INTRA: c_int = 244 | FF_PROFILE_H264_INTRA; -pub const FF_PROFILE_H264_CAVLC_444: c_int = 44; - -pub const FF_PROFILE_VC1_SIMPLE: c_int = 0; -pub const FF_PROFILE_VC1_MAIN: c_int = 1; -pub const FF_PROFILE_VC1_COMPLEX: c_int = 2; -pub const FF_PROFILE_VC1_ADVANCED: c_int = 3; - -pub const FF_PROFILE_MPEG4_SIMPLE: c_int = 0; -pub const FF_PROFILE_MPEG4_SIMPLE_SCALABLE: c_int = 1; -pub const FF_PROFILE_MPEG4_CORE: c_int = 2; -pub const FF_PROFILE_MPEG4_MAIN: c_int = 3; -pub const FF_PROFILE_MPEG4_N_BIT: c_int = 4; -pub const FF_PROFILE_MPEG4_SCALABLE_TEXTURE: c_int = 5; -pub const FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION: c_int = 6; -pub const FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE: c_int = 7; -pub const FF_PROFILE_MPEG4_HYBRID: c_int = 8; -pub const FF_PROFILE_MPEG4_ADVANCED_REAL_TIME: c_int = 9; -pub const FF_PROFILE_MPEG4_CORE_SCALABLE: c_int = 10; -pub const FF_PROFILE_MPEG4_ADVANCED_CODING: c_int = 11; -pub const FF_PROFILE_MPEG4_ADVANCED_CORE: c_int = 12; -pub const FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE: c_int = 13; -pub const FF_PROFILE_MPEG4_SIMPLE_STUDIO: c_int = 14; -pub const FF_PROFILE_MPEG4_ADVANCED_SIMPLE: c_int = 15; - -pub const FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0: c_int = 0; -pub const FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1: c_int = 1; -pub const FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION: c_int = 2; -pub const FF_PROFILE_JPEG2000_DCINEMA_2K: c_int = 3; -pub const FF_PROFILE_JPEG2000_DCINEMA_4K: c_int = 4; - -pub const FF_PROFILE_VP9_0: c_int = 0; -pub const FF_PROFILE_VP9_1: c_int = 1; -pub const FF_PROFILE_VP9_2: c_int = 2; -pub const FF_PROFILE_VP9_3: c_int = 3; - -pub const FF_PROFILE_HEVC_MAIN: c_int = 1; -pub const FF_PROFILE_HEVC_MAIN_10: c_int = 2; -pub const FF_PROFILE_HEVC_MAIN_STILL_PICTURE: c_int = 3; -pub const FF_PROFILE_HEVC_REXT: c_int = 4; - -pub const FF_LEVEL_UNKNOWN: c_int = -99; - -pub const FF_SUB_CHARENC_MODE_DO_NOTHING: c_int = -1; -pub const FF_SUB_CHARENC_MODE_AUTOMATIC: c_int = 0; -pub const FF_SUB_CHARENC_MODE_PRE_DECODER: c_int = 1; - -pub const FF_CODEC_PROPERTY_LOSSLESS: c_int = 0x00000001; -pub const FF_CODEC_PROPERTY_CLOSED_CAPTIONS: c_int = 0x00000002; - -#[repr(C)] -pub struct AVCodecContext { - pub av_class: *const AVClass, - pub log_level_offset: c_int, - pub codec_type: AVMediaType, - pub codec: *const AVCodec, - #[cfg(any(feature="ff_api_codec_name", not(feature="ff_api_codec_name_is_defined")))] - pub codec_name: [c_char; 32], - pub codec_id: AVCodecID, - pub codec_tag: c_uint, - #[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, - pub bit_rate: int64_t, - pub bit_rate_tolerance: c_int, - pub global_quality: c_int, - pub compression_level: c_int, - pub flags: c_int, - pub flags2: c_int, - pub extradata: *mut uint8_t, - pub extradata_size: c_int, - pub time_base: AVRational, - pub ticks_per_frame: c_int, - pub delay: c_int, - pub width: c_int, - pub height: c_int, - pub coded_width: c_int, - pub coded_height: c_int, - pub gop_size: c_int, - pub pix_fmt: AVPixelFormat, - #[cfg(feature = "ff_api_motion_est")] - pub me_method: c_int, - pub draw_horiz_band: Option, - pub get_format: Option AVPixelFormat>, - pub max_b_frames: c_int, - pub b_quant_factor: c_float, - #[cfg(feature = "ff_api_rc_strategy")] - pub rc_strategy: c_int, - #[cfg(feature = "ff_api_private_opt")] - pub b_frame_strategy: c_int, - pub b_quant_offset: c_float, - pub has_b_frames: c_int, - #[cfg(feature = "ff_api_private_opt")] - pub mpeg_quant: c_int, - pub i_quant_factor: c_float, - pub i_quant_offset: c_float, - pub lumi_masking: c_float, - pub temporal_cplx_masking: c_float, - pub spatial_cplx_masking: c_float, - pub p_masking: c_float, - pub dark_masking: c_float, - pub slice_count: c_int, - #[cfg(feature = "ff_api_private_opt")] - pub prediction_method: c_int, - pub slice_offset: *mut c_int, - pub sample_aspect_ratio: AVRational, - pub me_cmp: c_int, - pub me_sub_cmp: c_int, - pub mb_cmp: c_int, - pub ildct_cmp: c_int, - pub dia_size: c_int, - pub last_predictor_count: c_int, - #[cfg(feature = "ff_api_private_opt")] - pub pre_me: c_int, - pub me_pre_cmp: c_int, - pub pre_dia_size: c_int, - pub me_subpel_quality: c_int, - #[cfg(feature = "ff_api_afd")] - pub dtg_active_format: c_int, - pub me_range: c_int, - #[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, - #[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, - #[cfg(feature = "ff_api_private_opt")] - pub scenechange_threshold: c_int, - #[cfg(feature = "ff_api_private_opt")] - pub noise_reduction: c_int, - #[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, - #[cfg(feature = "ff_api_mpv_opt")] - pub border_masking: c_float, - pub mb_lmin: c_int, - pub mb_lmax: c_int, - #[cfg(feature = "ff_api_private_opt")] - pub me_penalty_compensation: c_int, - pub bidir_refine: c_int, - #[cfg(feature = "ff_api_private_opt")] - pub brd_scale: c_int, - pub keyint_min: c_int, - pub refs: c_int, - #[cfg(feature = "ff_api_private_opt")] - pub chromaoffset: c_int, - #[cfg(feature = "ff_api_unused_members")] - pub scenechange_factor: c_int, - pub mv0_threshold: c_int, - #[cfg(feature = "ff_api_private_opt")] - pub b_sensitivity: c_int, - pub color_primaries: AVColorPrimaries, - pub color_trc: AVColorTransferCharacteristic, - pub colorspace: AVColorSpace, - pub color_range: AVColorRange, - pub chroma_sample_location: AVChromaLocation, - pub slices: c_int, - pub field_order: AVFieldOrder, - pub sample_rate: c_int, - pub channels: c_int, - pub sample_fmt: AVSampleFormat, - pub frame_size: c_int, - pub frame_number: c_int, - pub block_align: c_int, - pub cutoff: 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_buffer2: Option c_int>, - pub refcounted_frames: c_int, - pub qcompress: c_float, - pub qblur: c_float, - pub qmin: c_int, - pub qmax: c_int, - pub max_qdiff: c_int, - #[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, - #[cfg(feature = "ff_api_mpv_opt")] - pub rc_eq: *const c_char, - pub rc_max_rate: int64_t, - pub rc_min_rate: int64_t, - #[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, - #[cfg(feature = "ff_api_coder_type")] - pub coder_type: c_int, - #[cfg(feature = "ff_api_private_opt")] - pub context_model: c_int, - #[cfg(feature = "ff_api_mpv_opt")] - pub lmin: c_int, - #[cfg(feature = "ff_api_mpv_opt")] - pub lmax: c_int, - #[cfg(feature = "ff_api_private_opt")] - pub frame_skip_threshold: c_int, - #[cfg(feature = "ff_api_private_opt")] - pub frame_skip_factor: c_int, - #[cfg(feature = "ff_api_private_opt")] - pub frame_skip_exp: c_int, - #[cfg(feature = "ff_api_private_opt")] - pub frame_skip_cmp: c_int, - pub trellis: c_int, - #[cfg(feature = "ff_api_private_opt")] - pub min_prediction_order: c_int, - #[cfg(feature = "ff_api_private_opt")] - pub max_prediction_order: c_int, - #[cfg(feature = "ff_api_private_opt")] - pub timecode_frame_start: int64_t, - #[cfg(feature = "ff_api_rtp_callback")] - pub rtp_callback: Option, - #[cfg(feature = "ff_api_private_opt")] - pub rtp_payload_size: c_int, - #[cfg(feature = "ff_api_stat_bits")] - pub mv_bits: c_int, - #[cfg(feature = "ff_api_stat_bits")] - pub header_bits: c_int, - #[cfg(feature = "ff_api_stat_bits")] - pub i_tex_bits: c_int, - #[cfg(feature = "ff_api_stat_bits")] - pub p_tex_bits: c_int, - #[cfg(feature = "ff_api_stat_bits")] - pub i_count: c_int, - #[cfg(feature = "ff_api_stat_bits")] - pub p_count: c_int, - #[cfg(feature = "ff_api_stat_bits")] - pub skip_count: c_int, - #[cfg(feature = "ff_api_stat_bits")] - pub misc_bits: c_int, - #[cfg(feature = "ff_api_stat_bits")] - pub frame_bits: c_int, - pub stats_out: *mut c_char, - pub stats_in: *mut c_char, - pub workaround_bugs: c_int, - pub strict_std_compliance: c_int, - pub error_concealment: c_int, - pub debug: c_int, - #[cfg(feature = "ff_api_debug_mv")] - pub debug_mv: c_int, - pub err_recognition: c_int, - pub reordered_opaque: int64_t, - pub hwaccel: *mut AVHWAccel, - pub hwaccel_context: *mut c_void, - pub error: [uint64_t; AV_NUM_DATA_POINTERS], - pub dct_alog: c_int, - pub idct_algo: c_int, - pub bits_per_coded_sample: c_int, - pub bits_per_raw_sample: c_int, - #[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 nsse_weight: c_int, - pub profile: c_int, - pub level: c_int, - pub skip_loop_filter: AVDiscard, - pub skip_idct: AVDiscard, - pub skip_frame: AVDiscard, - pub subtitle_header: *mut uint8_t, - pub subtitle_header_size: c_int, - #[cfg(feature = "ff_api_error_rate")] - pub error_rate: c_int, - #[cfg(feature = "ff_api_vbv_delay")] - pub vbv_delay: uint64_t, - #[cfg(feature = "ff_api_sidedata_only_pkt")] - pub side_data_only_packets: c_int, - pub initial_padding: c_int, - pub framerate: AVRational, - pub sw_pix_fmt: AVPixelFormat, - pub pkt_timebase: AVRational, - pub codec_descriptor: *const AVCodecDescriptor, - #[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, - pub pts_correction_last_dts: int64_t, - pub sub_charenc: *mut c_char, - pub sub_charenc_mode: c_int, - pub skip_alpha: c_int, - pub seek_preroll: c_int, - #[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, - pub properties: c_uint, - pub coded_size_data: *mut AVPacketSideData, - pub nb_coded_size_fata: c_int, - pub hw_frames_ctx: *mut AVBufferRef, - pub sub_text_format: c_int, - pub trailing_padding: c_int, -} - -#[derive(Debug)] -#[repr(C)] -pub struct AVProfile { - pub profile: c_int, - pub name: *const c_char, -} - -pub type AVCodecDefault = c_void; - -#[repr(C)] -pub struct AVCodec { - pub name: *const c_char, - pub long_name: *const c_char, - pub kind: AVMediaType, - pub id: AVCodecID, - pub capabilities: c_int, - pub supported_framerates: *const AVRational, - pub pix_fmts: *const AVPixelFormat, - pub supported_samplerates: *const c_int, - pub sample_fmts: *const AVSampleFormat, - pub channel_layouts: *const uint64_t, - pub max_lowres: uint8_t, - pub priv_class: *const AVClass, - pub profiles: *const AVProfile, - - pub priv_data_size: c_int, - pub next: *mut AVCodec, - pub init_thread_copy: Option c_int>, - pub update_thread_context: extern fn(*mut AVCodecContext, *const AVCodecContext) -> c_int, - pub defaults: *const AVCodecDefault, - pub init_static_data: extern fn(*mut AVCodec), - pub init: extern fn(*mut AVCodecContext) -> c_int, - pub encode_sub: extern fn(*mut AVCodecContext, *mut uint8_t, c_int, *const AVSubtitle) -> c_int, - pub encode2: extern fn(*mut AVCodecContext, *mut AVPacket, *const AVFrame, *mut c_int) -> c_int, - pub decode: extern fn(*mut AVCodecContext, *mut c_void, *mut c_int, *mut AVPacket) -> c_int, - pub close: extern fn(*mut AVCodecContext) -> c_int, - pub send_frame: extern fn(*mut AVCodecContext, *const AVFrame) -> c_int, - pub send_packet: extern fn(*mut AVCodecContext, *const AVPacket) -> c_int, - pub receive_frame: extern fn(*mut AVCodecContext, *mut AVFrame) -> c_int, - pub receive_packet: extern fn(*mut AVCodecContext, *mut AVPacket) -> c_int, - pub flush: extern fn(*mut AVCodecContext), - pub caps_internal: c_int, -} - -pub type MpegEncContext = c_void; - -#[repr(C)] -pub struct AVHWAccel { - pub name: *const c_char, - pub kind: AVMediaType, - pub id: AVCodecID, - pub pix_fmt: AVPixelFormat, - pub capabilities: c_int, - - pub next: *mut AVHWAccel, - pub alloc_frame: extern fn(*mut AVCodecContext, *mut AVFrame) -> c_int, - pub start_frame: extern fn(*mut AVCodecContext, *const uint8_t, uint32_t) -> c_int, - pub decode_slice: extern fn(*mut AVCodecContext, *const uint8_t, uint32_t) -> c_int, - pub end_frame: extern fn(*mut AVCodecContext) -> c_int, - pub frame_priv_data_size: c_int, - pub decode_mb: extern fn(*mut MpegEncContext), - pub init: extern fn(*mut AVCodecContext) -> c_int, - pub uninit: extern fn(*mut AVCodecContext) -> c_int, - pub priv_data_size: c_int, -} - -pub const AV_HWACCEL_FLAG_IGNORE_LEVEL: c_int = 1 << 0; -pub const AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH: c_int = 1 << 1; - -#[derive(Debug)] -#[repr(C)] -pub struct AVPicture { - pub data: [*mut uint8_t; AV_NUM_DATA_POINTERS], - pub linesize: [c_int; AV_NUM_DATA_POINTERS], -} - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVSubtitleType { - SUBTITLE_NONE, - SUBTITLE_BITMAP, - SUBTITLE_TEXT, - SUBTITLE_ASS, -} - -pub const AV_SUBTITLE_FLAG_FORCED: c_int = 0x00000001; - -#[derive(Debug)] -#[repr(C)] -pub struct AVSubtitleRect { - pub x: c_int, - pub y: c_int, - pub w: c_int, - pub h: c_int, - pub nb_colors: c_int, - #[cfg(feature = "ff_api_avpicture")] - pub pict: AVPicture, - pub data: [*mut uint8_t; 4], - pub linesize: [c_int; 4], - pub kind: AVSubtitleType, - pub text: *mut c_char, - pub ass: *mut c_char, - pub flags: c_int, -} - -#[derive(Debug)] -#[repr(C)] -pub struct AVSubtitle { - pub format: uint16_t, - pub start_display_time: uint32_t, - pub end_display_time: uint32_t, - pub num_rects: c_uint, - pub rects: *mut *mut AVSubtitleRect, - pub pts: int64_t, -} - -#[derive(Debug)] -#[repr(C)] -pub struct AVCodecParameters { - pub codec_type: AVMediaType, - pub codec_id: AVCodecID, - pub codec_tag: uint32_t, - pub extradata: *mut uint8_t, - pub extradata_size: c_int, - pub format: c_int, - pub bit_rate: int64_t, - pub bits_per_coded_sample: c_int, - pub bits_per_raw_sample: c_int, - pub profile: c_int, - pub level: c_int, - pub width: c_int, - pub height: c_int, - pub sample_aspect_ratio: AVRational, - pub field_order: AVFieldOrder, - pub color_range: AVColorRange, - pub color_primaries: AVColorPrimaries, - pub color_trc: AVColorTransferCharacteristic, - pub color_space: AVColorSpace, - pub chroma_location: AVChromaLocation, - pub video_delay: c_int, - pub channel_layout: uint64_t, - pub channels: c_int, - pub sample_rate: c_int, - pub block_align: c_int, - pub frame_size: c_int, - pub initial_padding: c_int, - pub trailing_padding: c_int, - pub seek_preroll: c_int, -} - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVPictureStructure { - AV_PICTURE_STRUCTURE_UNKNOWN, - AV_PICTURE_STRUCTURE_TOP_FIELD, - AV_PICTURE_STRUCTURE_BOTTOM_FIELD, - AV_PICTURE_STRUCTURE_FRAME, -} - -pub const AV_PARSER_PTS_NB: usize = 4; - -pub const PARSER_FLAG_COMPLETE_FRAMES: c_int = 0x0001; -pub const PARSER_FLAG_ONCE: c_int = 0x0002; -pub const PARSER_FLAG_FETCHED_OFFSET: c_int = 0x0004; -pub const PARSER_FLAG_USE_CODEC_TS: c_int = 0x1000; - -#[derive(Debug)] -#[repr(C)] -pub struct AVCodecParserContext { - pub priv_data: *mut c_void, - pub parser: *mut AVCodecParser, - pub frame_offset: int64_t, - pub cur_offset: int64_t, - pub next_frame_offset: int64_t, - pub pict_type: c_int, - pub repeat_pict: c_int, - pub pts: int64_t, - pub dts: int64_t, - - pub last_pts: int64_t, - pub last_dts: int64_t, - pub fetch_timestamp: c_int, - pub cur_frame_start_index: c_int, - pub cur_frame_offset: [int64_t; AV_PARSER_PTS_NB], - pub cur_frame_pts: [int64_t; AV_PARSER_PTS_NB], - pub cur_frame_dts: [int64_t; AV_PARSER_PTS_NB], - pub flags: c_int, - pub offset: int64_t, - pub cur_frame_end: [int64_t; AV_PARSER_PTS_NB], - pub key_frame: c_int, - #[cfg(feature = "ff_api_convergence_duration")] - pub convergence_duration: int64_t, - pub dts_sync_point: c_int, - pub dts_ref_dts_delta: c_int, - pub pts_dts_delta: c_int, - pub cur_frame_pos: [int64_t; AV_PARSER_PTS_NB], - pub pos: int64_t, - pub last_pos: int64_t, - pub duration: c_int, - pub field_order: AVFieldOrder, - pub picture_structure: AVPictureStructure, - pub output_picture_number: c_int, - pub width: c_int, - pub height: c_int, - pub coded_width: c_int, - pub coded_height: c_int, - pub format: c_int, -} - -#[repr(C)] -pub struct AVCodecParser { - pub codec_ids: [c_int; 5], - pub priv_data_size: c_int, - pub parser_init: extern fn(*mut AVCodecParserContext) -> c_int, - pub parser_parse: extern fn(*mut AVCodecParserContext, *mut AVCodecContext, *const *const uint8_t, *mut c_int, *const uint8_t, c_int) -> c_int, - pub parser_close: extern fn(*mut AVCodecParserContext), - pub split: extern fn(*mut AVCodecContext, *const uint8_t, c_int) -> c_int, - pub next: *mut AVCodecParser, -} - -#[derive(Debug)] -#[repr(C)] -pub struct AVBitStreamFilterContext { - pub priv_data: *mut c_void, - pub filter: *mut AVBitStreamFilter, - pub parser: *mut AVCodecParserContext, - pub next: *mut AVBitStreamFilterContext, - pub args: *mut c_char, -} - -pub type AVBSFInternal = c_void; - -#[derive(Debug)] -#[repr(C)] -pub struct AVBSFContext { - pub av_class: *const AVClass, - pub filter: *const AVBitStreamFilter, - pub internal: *mut AVBSFInternal, - pub priv_data: *mut c_void, - pub par_in: *mut AVCodecParameters, - pub par_out: *mut AVCodecParameters, - pub time_base_in: AVRational, - pub time_base_out: AVRational, -} - -#[repr(C)] -pub struct AVBitStreamFilter { - pub name: *const c_char, - pub codec_ids: *const AVCodecID, - pub priv_class: *const AVClass, - pub priv_data_size: c_int, - pub init: extern fn(*mut AVBSFContext) -> c_int, - pub filter: extern fn(*mut AVBSFContext, *mut AVPacket) -> c_int, - pub close: extern fn(*mut AVBSFContext), -} - -pub type AVBSFList = c_void; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVLockOp { - AV_LOCK_CREATE, - AV_LOCK_OBTAIN, - AV_LOCK_RELEASE, - AV_LOCK_DESTROY, -} - -extern { - pub fn av_codec_get_pkt_timebase(avctx: *const AVCodecContext) -> AVRational; - pub fn av_codec_set_pkt_timebase(avctx: *mut AVCodecContext, val: AVRational); - - pub fn av_codec_get_codec_descriptor(avctx: *const AVCodecContext) -> *const AVCodecDescriptor; - pub fn av_codec_set_codec_descriptor(avctx: *mut AVCodecContext, val: *const AVCodecDescriptor); - - pub fn av_codec_get_codec_properties(avctx: *const AVCodecContext) -> c_uint; - - pub fn av_codec_get_lowres(avctx: *const AVCodecContext) -> c_int; - pub fn av_codec_set_lowres(avctx: *mut AVCodecContext, val: c_int); - - pub fn av_codec_get_seek_preroll(avctx: *const AVCodecContext) -> c_int; - pub fn av_codec_set_seek_preroll(avctx: *mut AVCodecContext, val: c_int); - - pub fn av_codec_get_chroma_intra_matrix(avctx: *const AVCodecContext) -> *mut uint16_t; - pub fn av_codec_set_chroma_intra_matrix(avctx: *mut AVCodecContext, val: *mut uint16_t); - - pub fn av_codec_get_max_lowres(codec: *const AVCodec) -> c_int; - - pub fn av_codec_next(c: *const AVCodec) -> *mut AVCodec; - - pub fn avcodec_version() -> c_uint; - pub fn avcodec_configuration() -> *const c_char; - pub fn avcodec_license() -> *const c_char; - - pub fn avcodec_register(codec: *mut AVCodec); - pub fn avcodec_register_all(); - - pub fn avcodec_alloc_context3(codec: *const AVCodec) -> *mut AVCodecContext; - pub fn avcodec_free_context(avctx: *mut *mut AVCodecContext); - pub fn avcodec_get_context_defaults3(s: *mut AVCodecContext, codec: *const AVCodec) -> c_int; - - pub fn avcodec_get_class() -> *const AVClass; - pub fn avcodec_get_frame_class() -> *const AVClass; - pub fn avcodec_get_subtitle_rect_class() -> *const AVClass; - - pub fn avcodec_copy_context(dest: *mut AVCodecContext, src: *const AVCodecContext) -> c_int; - - pub fn avcodec_parameters_alloc() -> *mut AVCodecParameters; - pub fn avcodec_parameters_free(par: *mut *mut AVCodecParameters); - pub fn avcodec_parameters_copy(dst: *mut AVCodecParameters, src: *const AVCodecParameters) -> c_int; - pub fn avcodec_parameters_from_context(par: *mut AVCodecParameters, - codec: *const AVCodecContext) -> c_int; - pub fn avcodec_parameters_to_context(codec: *mut AVCodecContext, - par: *const AVCodecParameters) -> c_int; - - pub fn avcodec_open2(avctx: *mut AVCodecContext, codec: *const AVCodec, options: *mut *mut AVDictionary) -> c_int; - pub fn avcodec_close(avctx: *mut AVCodecContext) -> c_int; - - pub fn avsubtitle_free(sub: *mut AVSubtitle); - - pub fn av_packet_alloc() -> *mut AVPacket; - pub fn av_packet_clone(src: *mut AVPacket) -> *mut AVPacket; - pub fn av_packet_free(pkt: *mut *mut AVPacket); - pub fn av_init_packet(pkt: *mut AVPacket); - pub fn av_new_packet(pkt: *mut AVPacket, size: c_int) -> c_int; - pub fn av_shrink_packet(pkt: *mut AVPacket, size: c_int); - pub fn av_grow_packet(pkt: *mut AVPacket, grow_by: c_int) -> c_int; - pub fn av_packet_from_data(pkt: *mut AVPacket, data: *mut uint8_t, size: c_int) -> c_int; - pub fn av_dup_packet(pkt: *mut AVPacket) -> c_int; - pub fn av_copy_packet(dst: *mut AVPacket, src: *const AVPacket) -> c_int; - pub fn av_copy_packet_side_data(dst: *mut AVPacket, src: *const AVPacket) -> c_int; - pub fn av_free_packet(pkt: *mut AVPacket); - pub fn av_packet_new_side_data(pkt: *mut AVPacket, kind: AVPacketSideDataType, size: c_int) -> *mut uint8_t; - pub fn av_packet_add_side_data(pkt: *mut AVPacket, kind: AVPacketSideDataType, - data: *mut uint8_t, size: size_t) -> c_int; - pub fn av_packet_shrink_side_data(pkt: *mut AVPacket, kind: AVPacketSideDataType, size: c_int) -> c_int; - pub fn av_packet_get_side_data(pkt: *mut AVPacket, kind: AVPacketSideDataType, size: *mut c_int) -> *mut uint8_t; - pub fn av_packet_merge_side_data(pkt: *mut AVPacket) -> c_int; - pub fn av_packet_split_side_data(pkt: *mut AVPacket) -> c_int; - pub fn av_packet_side_data_name(kind: AVPacketSideDataType) -> *const c_char; - pub fn av_packet_pack_dictionary(dict: *mut AVDictionary, size: *mut c_int) -> *mut uint8_t; - pub fn av_packet_unpack_dictionary(data: *const uint8_t, size: c_int, dict: *mut *mut AVDictionary) -> c_int; - pub fn av_packet_free_side_data(pkt: *mut AVPacket); - pub fn av_packet_ref(dst: *mut AVPacket, src: *const AVPacket) -> c_int; - pub fn av_packet_unref(pkt: *mut AVPacket); - pub fn av_packet_move_ref(dst: *mut AVPacket, src: *mut AVPacket); - pub fn av_packet_copy_props(dst: *mut AVPacket, src: *const AVPacket) -> c_int; - pub fn av_packet_rescale_ts(pkt: *mut AVPacket, tb_src: AVRational, tb_dst: AVRational); - - pub fn avcodec_find_decoder(id: AVCodecID) -> *mut AVCodec; - pub fn avcodec_find_decoder_by_name(name: *const c_char) -> *mut AVCodec; - - pub fn avcodec_default_get_buffer2(s: *mut AVCodecContext, frame: *mut AVFrame, flags: c_int) -> c_int; - - pub fn avcodec_align_dimensions(s: *mut AVCodecContext, width: *mut c_int, height: *mut c_int); - pub fn avcodec_align_dimensions2(s: *mut AVCodecContext, width: *mut c_int, height: *mut c_int, linesize_align: *mut c_int); - - pub fn avcodec_enum_to_chroma_pos(xpos: *mut c_int, ypos: *mut c_int, pos: AVChromaLocation) -> c_int; - pub fn avcodec_chroma_pos_to_enum(xpos: c_int, ypos: c_int) -> AVChromaLocation; - - pub fn avcodec_decode_audio4(avctx: *mut AVCodecContext, frame: *mut AVFrame, got_frame_ptr: *mut c_int, avpkt: *const AVPacket) -> c_int; - pub fn avcodec_decode_video2(avctx: *mut AVCodecContext, picture: *mut AVFrame, got_picture_ptr: *mut c_int, avpkt: *const AVPacket) -> c_int; - pub fn avcodec_decode_subtitle2(avctx: *mut AVCodecContext, sub: *mut AVSubtitle, got_sub_ptr: *mut c_int, avpkt: *const AVPacket) -> c_int; - - pub fn avcodec_send_packet(avctx: *mut AVCodecContext, avpkt: *const AVPacket) -> c_int; - pub fn avcodec_receive_frame(avctx: *mut AVCodecContext, frame: *mut AVFrame) -> c_int; - pub fn avcodec_send_frame(avctx: *mut AVCodecContext, frame: *const AVFrame) -> c_int; - pub fn avcodec_receive_packet(avctx: *mut AVCodecContext, packet: *mut AVPacket) -> c_int; - - pub fn av_parser_next(c: *const AVCodecParser) -> *mut AVCodecParser; - pub fn av_register_codec_parser(parser: *mut AVCodecParser); - pub fn av_parser_init(codec_id: c_int) -> *mut AVCodecParserContext; - pub fn av_parser_parse2(s: *mut AVCodecParserContext, avctx: *mut AVCodecContext, poutbuf: *mut *mut uint8_t, poutbuf_size: *mut c_int, buf: *const uint8_t, buf_size: c_int, pts: int64_t, dts: int64_t, pos: int64_t) -> c_int; - pub fn av_parser_change(s: *mut AVCodecParserContext, avctx: *mut AVCodecContext, poutbuf: *mut *mut uint8_t, poutbuf_size: *mut c_int, buf: *const uint8_t, buf_size: c_int, keyframe: c_int) -> c_int; - pub fn av_parser_close(s: *mut AVCodecParserContext); - - pub fn avcodec_find_encoder(id: AVCodecID) -> *mut AVCodec; - pub fn avcodec_find_encoder_by_name(name: *const c_char) -> *mut AVCodec; - pub fn avcodec_encode_audio2(avctx: *mut AVCodecContext, avpkt: *mut AVPacket, frame: *const AVFrame, got_packet_ptr: *mut c_int) -> c_int; - pub fn avcodec_encode_video2(avctx: *mut AVCodecContext, avpkt: *mut AVPacket, frame: *const AVFrame, got_packet_ptr: *mut c_int) -> c_int; - pub fn avcodec_encode_subtitle(avctx: *mut AVCodecContext, buf: *mut uint8_t, buf_size: c_int, sub: *const AVSubtitle) -> c_int; - - pub fn avpicture_alloc(picture: *mut AVPicture, pix_fmt: AVPixelFormat, width: c_int, height: c_int) -> c_int; - pub fn avpicture_free(picture: *mut AVPicture); - pub fn avpicture_fill(picture: *mut AVPicture, ptr: *const uint8_t, pix_fmt: AVPixelFormat, width: c_int, height: c_int) -> c_int; - pub fn avpicture_layout(src: *const AVPicture, pix_fmt: AVPixelFormat, width: c_int, height: c_int, dest: *mut c_uchar, dest_size: c_int) -> c_int; - pub fn avpicture_get_size(pix_fmt: AVPixelFormat, width: c_int, height: c_int) -> c_int; - - pub fn av_picture_copy(dst: *mut AVPicture, src: *const AVPicture, pix_fmt: AVPixelFormat, width: c_int, height: c_int); - pub fn av_picture_crop(dst: *mut AVPicture, src: *const AVPicture, pix_fmt: AVPixelFormat, top_band: c_int, left_band: c_int) -> c_int; - pub fn av_picture_pad(dst: *mut AVPicture, src: *const AVPicture, height: c_int, width: c_int, pix_fmt: AVPixelFormat, padtop: c_int, padbottom: c_int, padleft: c_int, padright: c_int, color: *mut c_int) -> c_int; - - pub fn avcodec_get_chroma_sub_sample(pix_fmt: AVPixelFormat, h_shift: *mut c_int, v_shift: *mut c_int); - pub fn avcodec_pix_fmt_to_codec_tag(pix_fmt: AVPixelFormat) -> c_uint; - pub fn avcodec_get_pix_fmt_loss(dst_pix_fmt: AVPixelFormat, src_pix_fmt: AVPixelFormat, has_alpha: c_int) -> c_int; - pub fn avcodec_find_best_pix_fmt_of_list(pix_fmt_list: *const AVPixelFormat, src_pix_fmt: AVPixelFormat, has_alpha: c_int, loss_ptr: *mut c_int) -> AVPixelFormat; - pub fn avcodec_find_best_pix_fmt_of_2(dst_pix_fmt1: AVPixelFormat, dst_pix_fmt2: AVPixelFormat, src_pix_fmt: AVPixelFormat, has_alpha: c_int, loss_ptr: *mut c_int) -> AVPixelFormat; - pub fn avcodec_find_best_pix_fmt2(dst_pix_fmt1: AVPixelFormat, dst_pix_fmt2: AVPixelFormat, src_pix_fmt: AVPixelFormat, has_alpha: c_int, loss_ptr: *mut c_int) -> AVPixelFormat; - pub fn avcodec_default_get_format(s: *mut AVCodecContext, fmt: *const AVPixelFormat) -> AVPixelFormat; - - pub fn av_get_codec_tag_string(buf: *mut c_char, buf_size: size_t, codec_tag: c_uint) -> size_t; - pub fn avcodec_string(buf: *mut c_char, buf_size: c_int, enc: *mut AVCodecContext, encode: c_int); - pub fn av_get_profile_name(codec: *const AVCodec, profile: c_int) -> *const c_char; - pub fn avcodec_profile_name(codec_id: AVCodecID, profile: c_int) -> *const c_char; - pub fn avcodec_default_execute(c: *mut AVCodecContext, func: extern fn(*mut AVCodecContext, *mut c_void) -> c_int, arg: *mut c_void, ret: *mut c_int, count: c_int, size: c_int) -> c_int; - pub fn avcodec_default_execute2(c: *mut AVCodecContext, func: extern fn(*mut AVCodecContext, *mut c_void, c_int, c_int) -> c_int, arg: *mut c_void, ret: *mut c_int, count: c_int) -> c_int; - pub fn avcodec_fill_audio_frame(frame: *mut AVFrame, nb_channels: c_int, sample_fmt: AVSampleFormat, buf: *const uint8_t, buf_size: c_int, align: c_int) -> c_int; - pub fn avcodec_flush_buffers(avctx: *mut AVCodecContext); - pub fn av_get_bits_per_sample(codec_id: AVCodecID) -> c_int; - pub fn av_get_pcm_codec(fmt: AVSampleFormat, be: c_int) -> AVCodecID; - pub fn av_get_exact_bits_per_sample(codec_id: AVCodecID) -> c_int; - pub fn av_get_audio_frame_duration(avctx: *mut AVCodecContext, frame_bytes: c_int) -> c_int; - pub fn av_get_audio_frame_duration2(par: *mut AVCodecParameters, frame_bytes: c_int) -> c_int; - - pub fn av_bsf_get_by_name(name: *const c_char) -> *const AVBitStreamFilter; - pub fn av_bsf_next(opaque: *mut *mut c_void) -> *const AVBitStreamFilter; - pub fn av_bsf_alloc(filter: *const AVBitStreamFilter, ctx: *mut *mut AVBSFContext) -> c_int; - pub fn av_bsf_init(ctx: *mut AVBSFContext) -> c_int; - pub fn av_bsf_send_packet(ctx: *mut AVBSFContext, pkt: *mut AVPacket) -> c_int; - pub fn av_bsf_receive_packet(ctx: *mut AVBSFContext, pkt: *mut AVPacket) -> c_int; - pub fn av_bsf_free(ctx: *mut *mut AVBSFContext); - pub fn av_bsf_get_class() -> *const AVClass; - pub fn av_bsf_list_alloc() -> *mut AVBSFList; - pub fn av_bsf_list_free(lst: *mut *mut AVBSFList); - pub fn av_bsf_list_append(lst: *mut AVBSFList, bsf: *mut AVBSFContext) -> c_int; - pub fn av_bsf_list_append2(lst: *mut AVBSFList, bsf_name: *const c_char, options: *mut *mut AVDictionary) -> c_int; - pub fn av_bsf_list_finalize(lst: *mut *mut AVBSFList, bsf: *mut *mut AVBSFContext) -> c_int; - pub fn av_bsf_list_parse_str(str: *const c_char, bsf: *mut *mut AVBSFContext) -> c_int; - pub fn av_bsf_get_null_filter(bsf: *mut *mut AVBSFContext) -> c_int; - - pub fn av_fast_padded_malloc(ptr: *mut c_void, size: *mut c_uint, min_size: size_t); - pub fn av_fast_padded_mallocz(ptr: *mut c_void, size: *mut c_uint, min_size: size_t); - pub fn av_xiphlacing(s: *mut c_uchar, v: c_uint) -> c_uint; - - pub fn av_register_hwaccel(hwaccel: *mut AVHWAccel); - pub fn av_hwaccel_next(hwaccel: *const AVHWAccel) -> *mut AVHWAccel; - - pub fn av_lockmgr_register(cb: extern fn(*mut *mut c_void, AVLockOp) -> c_int) -> c_int; - - pub fn avcodec_get_type(codec_id: AVCodecID) -> AVMediaType; - pub fn avcodec_get_name(id: AVCodecID) -> *const c_char; - pub fn avcodec_is_open(s: *mut AVCodecContext) -> c_int; - pub fn av_codec_is_encoder(codec: *const AVCodec) -> c_int; - pub fn av_codec_is_decoder(codec: *const AVCodec) -> c_int; - - pub fn avcodec_descriptor_get(id: AVCodecID) -> *const AVCodecDescriptor; - pub fn avcodec_descriptor_next(prev: *const AVCodecDescriptor) -> *const AVCodecDescriptor; - pub fn avcodec_descriptor_get_by_name(name: *const c_char) -> *const AVCodecDescriptor; - - pub fn av_cpb_properties_alloc(size: *mut size_t) -> *mut AVCPBProperties; -} diff --git a/sys/src/avcodec/dv_profile.rs b/sys/src/avcodec/dv_profile.rs deleted file mode 100644 index 088ada7..0000000 --- a/sys/src/avcodec/dv_profile.rs +++ /dev/null @@ -1,32 +0,0 @@ -use libc::{c_int, c_uint, uint8_t}; -use super::super::avutil::{AVPixelFormat, AVRational}; - -pub const DV_PROFILE_BYTES: c_int = 6 * 80; - -#[derive(Debug)] -#[repr(C)] -pub struct AVDVProfile { - pub dsf: c_int, - pub video_type: c_int, - pub frame_size: c_int, - pub difseg_size: c_int, - pub n_difchan: c_int, - pub time_base: AVRational, - pub ltc_divisor: c_int, - pub height: c_int, - pub width: c_int, - pub sar: [AVRational; 2], - pub pix_fmt: AVPixelFormat, - pub bpm: c_int, - pub block_sizes: *const uint8_t, - pub audio_stride: c_int, - pub audio_min_samples: [c_int; 3], - pub audio_samples_dist: [c_int; 5], - pub audio_shuffle: [*const uint8_t; 9], -} - -extern { - pub fn av_dv_frame_profile(sys: *const AVDVProfile, frame: *const uint8_t, buf_size: c_uint) -> *const AVDVProfile; - pub fn av_dv_codec_profile(width: c_int, height: c_int, pix_fmt: AVPixelFormat) -> *const AVDVProfile; - pub fn av_dv_codec_profile2(width: c_int, height: c_int, pix_fmt: AVPixelFormat, frame_rate: AVRational) -> AVDVProfile; -} diff --git a/sys/src/avcodec/dxva2.rs b/sys/src/avcodec/dxva2.rs deleted file mode 100644 index 5e3406d..0000000 --- a/sys/src/avcodec/dxva2.rs +++ /dev/null @@ -1,15 +0,0 @@ -use libc::{c_void, c_uint, uint64_t}; - -pub const FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG: uint64_t = 1; -pub const FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO: uint64_t = 2; - -#[derive(Debug)] -#[repr(C)] -pub struct dxva_context { - pub decoder: *mut c_void, - pub cfg: *const c_void, - pub surface_count: c_uint, - pub surface: *mut c_void, - pub workaround: uint64_t, - pub report_id: c_uint, -} diff --git a/sys/src/avcodec/fft.rs b/sys/src/avcodec/fft.rs deleted file mode 100644 index 841bac9..0000000 --- a/sys/src/avcodec/fft.rs +++ /dev/null @@ -1,55 +0,0 @@ -use libc::{c_void, c_int, c_float, c_double}; - -pub type FFTSample = c_float; - -#[derive(Debug)] -#[repr(C)] -pub struct FFTComplex { - pub re: FFTSample, - pub im: FFTSample, -} - -pub type FFTContext = c_void; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum RDFTransformType { - DFT_R2C, - IDFT_C2R, - IDFT_R2C, - DFT_C2R, -} - -pub type RDFTContext = c_void; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum DCTTransformType { - DCT_II = 0, - DCT_III, - DCT_I, - DST_I, -} - -pub type DCTContext = c_void; - -extern { - pub fn av_fft_init(nbits: c_int, inverse: c_int) -> *mut FFTContext; - pub fn av_fft_permute(s: *mut FFTContext, z: *mut FFTComplex); - pub fn av_fft_calc(s: *mut FFTContext, z: *mut FFTComplex); - pub fn av_fft_end(s: *mut FFTContext); - - pub fn av_mdct_init(nbits: c_int, inverse: c_int, scale: c_double) -> *mut FFTContext; - pub fn av_imdct_calc(s: *mut FFTContext, output: *mut FFTSample, input: *const FFTSample); - pub fn av_imdct_half(s: *mut FFTContext, output: *mut FFTSample, input: *const FFTSample); - pub fn av_mdct_calc(s: *mut FFTContext, output: *mut FFTSample, input: *const FFTSample); - pub fn av_mdct_end(s: *mut FFTContext); - - pub fn av_rdft_init(nbits: c_int, trans: RDFTransformType) -> *mut RDFTContext; - pub fn av_rdft_calc(s: *mut RDFTContext, data: *mut FFTSample); - pub fn av_rdft_end(s: *mut RDFTContext); - - pub fn av_dct_init(nbits: c_int, kind: DCTTransformType) -> *mut DCTContext; - pub fn av_dct_calc(s: *mut DCTContext, data: *mut FFTSample); - pub fn av_dct_end(s: *mut DCTContext); -} diff --git a/sys/src/avcodec/mod.rs b/sys/src/avcodec/mod.rs deleted file mode 100644 index dbef20b..0000000 --- a/sys/src/avcodec/mod.rs +++ /dev/null @@ -1,41 +0,0 @@ -mod codec; -pub use self::codec::*; -pub use self::codec::AVCodecID::*; -pub use self::codec::Motion_Est_ID::*; -pub use self::codec::AVDiscard::*; -pub use self::codec::AVAudioServiceType::*; -pub use self::codec::AVPacketSideDataType::*; -pub use self::codec::AVFieldOrder::*; -pub use self::codec::AVSubtitleType::*; -pub use self::codec::AVPictureStructure::*; -pub use self::codec::AVLockOp::*; - -mod fft; -pub use self::fft::*; -pub use self::fft::RDFTransformType::*; -pub use self::fft::DCTTransformType::*; - -mod dv_profile; -pub use self::dv_profile::*; - -mod dxva2; -pub use self::dxva2::*; - -mod qsv; -pub use self::qsv::*; - -mod vaapi; -pub use self::vaapi::*; - -mod vda; -pub use self::vda::*; - -mod vobis_parser; -pub use self::vobis_parser::*; - -mod xvmc; -pub use self::xvmc::*; - -#[cfg_attr(feature = "static", link(name = "avcodec", kind = "static"))] -#[cfg_attr(not(feature = "static"), link(name = "avcodec"))] -extern { } diff --git a/sys/src/avcodec/qsv.rs b/sys/src/avcodec/qsv.rs deleted file mode 100644 index e2660f0..0000000 --- a/sys/src/avcodec/qsv.rs +++ /dev/null @@ -1,14 +0,0 @@ -use libc::{c_void, c_int}; - -#[derive(Debug)] -#[repr(C)] -pub struct AVQSVContext { - pub session: *mut c_void, - pub iopattern: c_int, - pub ext_buffers: *mut *mut c_void, - pub nb_ext_buffers: c_int, -} - -extern { - pub fn av_qsv_alloc_context() -> *mut AVQSVContext; -} diff --git a/sys/src/avcodec/vaapi.rs b/sys/src/avcodec/vaapi.rs deleted file mode 100644 index b65ff3d..0000000 --- a/sys/src/avcodec/vaapi.rs +++ /dev/null @@ -1,33 +0,0 @@ -use libc::{c_void, c_uint, uint8_t, uint32_t}; - -#[derive(Debug)] -#[repr(C)] -pub struct vaapi_context { - pub display: *mut c_void, - pub config_id: uint32_t, - pub context_id: uint32_t, - #[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, -} diff --git a/sys/src/avcodec/vda.rs b/sys/src/avcodec/vda.rs deleted file mode 100644 index fd7c09e..0000000 --- a/sys/src/avcodec/vda.rs +++ /dev/null @@ -1,33 +0,0 @@ -use libc::{c_void, c_int, uint8_t, uint32_t}; -use super::codec::AVCodecContext; - -#[derive(Debug)] -#[repr(C)] -pub struct vda_context { - pub decoder: *mut c_void, - pub cv_buffer: *mut c_void, - pub use_sync_decoding: c_int, - pub width: c_int, - pub height: c_int, - pub format: c_int, - pub cv_pix_fmt_type: i32, - pub priv_bitstream: *mut uint8_t, - pub priv_bitstream_size: c_int, - pub priv_allocated_size: c_int, - pub use_ref_buffer: c_int, -} - -#[repr(C)] -pub struct AVVDAContext { - pub decoder: *mut c_void, - pub output_callback: extern fn(*mut c_void, *mut c_void, i32, uint32_t, *mut c_void), -} - -extern { - pub fn ff_vda_create_decoder(vda_ctx: *mut vda_context, extradata: *mut uint8_t, extradata_size: c_int) -> c_int; - pub fn ff_vda_destroy_decoder(vda_ctx: *mut vda_context) -> c_int; - - pub fn av_vda_alloc_context() -> *mut AVVDAContext; - pub fn av_vda_default_init(avctx: *mut AVCodecContext) -> c_int; - pub fn av_vda_default_free(avctx: *mut AVCodecContext); -} diff --git a/sys/src/avcodec/vobis_parser.rs b/sys/src/avcodec/vobis_parser.rs deleted file mode 100644 index 816798c..0000000 --- a/sys/src/avcodec/vobis_parser.rs +++ /dev/null @@ -1,15 +0,0 @@ -use libc::{c_void, c_int, uint8_t}; - -pub type AVVorbisParseContext = c_void; - -pub const VORBIS_FLAG_HEADER: c_int = 0x00000001; -pub const VORBIS_FLAG_COMMENT: c_int = 0x00000002; -pub const VORBIS_FLAG_SETUP: c_int = 0x00000004; - -extern { - pub fn av_vorbis_parse_init(extradata: *const uint8_t, extradata_size: c_int) -> *mut AVVorbisParseContext; - pub fn av_vorbis_parse_free(s: *mut *mut AVVorbisParseContext); - pub fn av_vorbis_parse_frame_flags(s: *mut AVVorbisParseContext, buf: *const uint8_t, buf_size: c_int, flags: *mut c_int) -> c_int; - pub fn av_vorbis_parse_frame(s: *mut AVVorbisParseContext, buf: *const uint8_t, buf_size: c_int) -> c_int; - pub fn av_vorbis_parse_reset(s: *mut AVVorbisParseContext); -} diff --git a/sys/src/avcodec/xvmc.rs b/sys/src/avcodec/xvmc.rs deleted file mode 100644 index ea6935b..0000000 --- a/sys/src/avcodec/xvmc.rs +++ /dev/null @@ -1,23 +0,0 @@ -use libc::{c_void, c_short, c_int, c_uint}; - -pub const AV_XVMC_ID: c_int = 0x1DC711C0; - -#[derive(Debug)] -#[repr(C)] -pub struct xvmc_pix_fmt { - pub xvmc_id: c_int, - pub data_blocks: *mut c_short, - pub mv_blocks: *mut c_void, - pub allocated_mv_blocks: c_int, - pub allocated_data_blocks: c_int, - pub idct: c_int, - pub unsigned_intra: c_int, - pub p_surface: *mut c_void, - pub p_past_surface: *mut c_void, - pub p_future_surface: *mut c_void, - pub picture_structure: c_uint, - pub flags: c_uint, - pub start_mv_blocks_num: c_int, - pub filled_mv_blocks_num: c_int, - pub next_free_data_block_num: c_int, -} diff --git a/sys/src/avdevice/device.rs b/sys/src/avdevice/device.rs deleted file mode 100644 index 3f362f5..0000000 --- a/sys/src/avdevice/device.rs +++ /dev/null @@ -1,106 +0,0 @@ -use libc::{c_void, c_char, c_int, c_uint, int64_t, size_t}; -use super::super::avutil::{AVClass, AVPixelFormat, AVSampleFormat, AVOption, AVDictionary, AVRational}; -use super::super::avcodec::{AVCodecID}; -use super::super::avformat::{AVFormatContext, AVInputFormat, AVOutputFormat}; - -#[derive(Debug)] -#[repr(C)] -pub struct AVDeviceRect { - pub x: c_int, - pub y: c_int, - pub width: c_int, - pub height: c_int, -} - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVAppToDevMessageType { - AV_APP_TO_DEV_NONE = MKBETAG!(b'N', b'O', b'N', b'E'), - AV_APP_TO_DEV_WINDOW_SIZE = MKBETAG!(b'G', b'E', b'O', b'M'), - AV_APP_TO_DEV_WINDOW_REPAINT = MKBETAG!(b'R', b'E', b'P', b'A'), - AV_APP_TO_DEV_PAUSE = MKBETAG!(b'P', b'A', b'U', b' '), - AV_APP_TO_DEV_PLAY = MKBETAG!(b'P', b'L', b'A', b'Y'), - AV_APP_TO_DEV_TOGGLE_PAUSE = MKBETAG!(b'P', b'A', b'U', b'T'), - AV_APP_TO_DEV_SET_VOLUME = MKBETAG!(b'S', b'V', b'O', b'L'), - AV_APP_TO_DEV_MUTE = MKBETAG!(b' ', b'M', b'U', b'T'), - AV_APP_TO_DEV_UNMUTE = MKBETAG!(b'U', b'M', b'U', b'T'), - AV_APP_TO_DEV_TOGGLE_MUTE = MKBETAG!(b'T', b'M', b'U', b'T'), - AV_APP_TO_DEV_GET_VOLUME = MKBETAG!(b'G', b'V', b'O', b'L'), - AV_APP_TO_DEV_GET_MUTE = MKBETAG!(b'G', b'M', b'U', b'T'), -} - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVDevToAppMessageType { - AV_DEV_TO_APP_NONE = MKBETAG!(b'N', b'O', b'N', b'E'), - AV_DEV_TO_APP_CREATE_WINDOW_BUFFER = MKBETAG!(b'B', b'C', b'R', b'E'), - AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER = MKBETAG!(b'B', b'P', b'R', b'E'), - AV_DEV_TO_APP_DISPLAY_WINDOW_BUFFER = MKBETAG!(b'B', b'D', b'I', b'S'), - AV_DEV_TO_APP_DESTROY_WINDOW_BUFFER = MKBETAG!(b'B', b'D', b'E', b'S'), - AV_DEV_TO_APP_BUFFER_OVERFLOW = MKBETAG!(b'B', b'O', b'F', b'L'), - AV_DEV_TO_APP_BUFFER_UNDERFLOW = MKBETAG!(b'B', b'U', b'F', b'L'), - AV_DEV_TO_APP_BUFFER_READABLE = MKBETAG!(b'B', b'R', b'D', b' '), - AV_DEV_TO_APP_BUFFER_WRITABLE = MKBETAG!(b'B', b'W', b'R', b' '), - AV_DEV_TO_APP_MUTE_STATE_CHANGED = MKBETAG!(b'C', b'M', b'U', b'T'), - AV_DEV_TO_APP_VOLUME_LEVEL_CHANGED = MKBETAG!(b'C', b'V', b'O', b'L'), -} - -#[derive(Debug)] -#[repr(C)] -pub struct AVDeviceCapabilitiesQuery { - pub av_class: *const AVClass, - pub device_context: *const AVFormatContext, - pub codec: AVCodecID, - pub sample_format: AVSampleFormat, - pub pixel_format: AVPixelFormat, - pub sample_rate: c_int, - pub channels: c_int, - pub channel_layout: int64_t, - pub window_width: c_int, - pub window_height: c_int, - pub frame_width: c_int, - pub frame_height: c_int, - pub fps: AVRational, -} - -#[derive(Debug)] -#[repr(C)] -pub struct AVDeviceInfo { - pub device_name: *mut c_char, - pub device_description: *mut c_char, -} - -#[derive(Debug)] -#[repr(C)] -pub struct AVDeviceInfoList { - pub devices: *mut *mut AVDeviceInfo, - pub nb_devices: c_int, - pub default_device: c_int, -} - -extern { - pub static av_device_capabilities: *const AVOption; - - pub fn avdevice_version() -> c_uint; - pub fn avdevice_configuration() -> *const c_char; - pub fn avdevice_license() -> *const c_char; - - pub fn avdevice_register_all(); - - pub fn av_input_audio_device_next(d: *mut AVInputFormat) -> *mut AVInputFormat; - pub fn av_input_video_device_next(d: *mut AVInputFormat) -> *mut AVInputFormat; - - pub fn av_output_audio_device_next(d: *mut AVOutputFormat) -> *mut AVOutputFormat; - pub fn av_output_video_device_next(d: *mut AVOutputFormat) -> *mut AVOutputFormat; - - pub fn avdevice_app_to_dev_control_message(s: *const AVFormatContext, kind: AVAppToDevMessageType, data: *mut c_void, data_size: size_t) -> c_int; - pub fn avdevice_dev_to_app_control_message(s: *const AVFormatContext, kind: AVDevToAppMessageType, data: *mut c_void, data_size: size_t) -> c_int; - - pub fn avdevice_capabilities_create(caps: *mut *mut AVDeviceCapabilitiesQuery, s: *const AVFormatContext, device_options: *mut *mut AVDictionary) -> c_int; - pub fn avdevice_capabilities_free(caps: *mut *mut AVDeviceCapabilitiesQuery, s: *const AVFormatContext); - - pub fn avdevice_list_devices(s: *const AVFormatContext, device_list: *mut *mut AVDeviceInfoList) -> c_int; - pub fn avdevice_free_list_devices(device_list: *mut *mut AVDeviceInfoList); - pub fn avdevice_list_input_sources(device: *mut AVInputFormat, device_name: *const c_char, device_options: *mut AVDictionary, device_list: *mut *mut AVDeviceInfoList) -> c_int; - pub fn avdevice_list_output_sinks(device: *mut AVOutputFormat, device_name: *const c_char, device_options: *mut AVDictionary, device_list: *mut *mut AVDeviceInfoList) -> c_int; -} diff --git a/sys/src/avdevice/mod.rs b/sys/src/avdevice/mod.rs deleted file mode 100644 index f30eace..0000000 --- a/sys/src/avdevice/mod.rs +++ /dev/null @@ -1,6 +0,0 @@ -mod device; -pub use self::device::*; - -#[cfg_attr(feature = "static", link(name = "avdevice", kind = "static"))] -#[cfg_attr(not(feature = "static"), link(name = "avdevice"))] -extern { } diff --git a/sys/src/avfilter/buffersink.rs b/sys/src/avfilter/buffersink.rs deleted file mode 100644 index 7350c1e..0000000 --- a/sys/src/avfilter/buffersink.rs +++ /dev/null @@ -1,32 +0,0 @@ -use libc::{c_int, c_uint, int64_t}; -use ::avfilter::filter::AVFilterContext; -use ::avutil::{AVFrame, AVPixelFormat, AVSampleFormat, AVRational}; - -pub const AV_BUFFERSINK_FLAG_PEEK: c_int = 1; -pub const AV_BUFFERSINK_FLAG_NO_REQUEST: c_int = 2; - -#[repr(C)] -pub struct AVBufferSinkParams { - pub pixel_fmts: *const AVPixelFormat, -} - -#[repr(C)] -pub struct AVABufferSinkParams { - pub sample_fmts: *const AVSampleFormat, - pub channel_layouts: *const int64_t, - pub channel_counts: *const c_int, - pub all_channel_counts: c_int, - pub sample_rates: *mut c_int, -} - -extern { - pub fn av_buffersink_get_frame_flags(ctx: *mut AVFilterContext, frame: *mut AVFrame, flags: c_int) -> c_int; - - pub fn av_buffersink_params_alloc() -> *mut AVBufferSinkParams; - pub fn av_abuffersink_params_alloc() -> *mut AVABufferSinkParams; - - pub fn av_buffersink_set_frame_size(ctx: *mut AVFilterContext, frame_size: c_uint); - pub fn av_buffersink_get_frame_rate(ctx: *mut AVFilterContext) -> AVRational; - pub fn av_buffersink_get_frame(ctx: *mut AVFilterContext, frame: *mut AVFrame) -> c_int; - pub fn av_buffersink_get_samples(ctx: *mut AVFilterContext, frame: *mut AVFrame, nb_samples: c_int) -> c_int; -} diff --git a/sys/src/avfilter/buffersrc.rs b/sys/src/avfilter/buffersrc.rs deleted file mode 100644 index 1863b8b..0000000 --- a/sys/src/avfilter/buffersrc.rs +++ /dev/null @@ -1,31 +0,0 @@ -use libc::{c_int, c_uint, int64_t}; -use ::avfilter::filter::{AVFilterContext}; -use ::avutil::{AVFrame, AVRational, AVBufferRef}; - -pub const AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT: c_int = 1; -pub const AV_BUFFERSRC_FLAG_PUSH: c_int = 4; -pub const AV_BUFFERSRC_FLAG_KEEP_REF: c_int = 8; - -#[repr(C)] -pub struct AVBufferSrcParameters { - pub format: c_int, - pub time_base: AVRational, - pub width: c_int, - pub height: c_int, - pub sample_aspect_ratio: AVRational, - pub frame_rate: AVRational, - pub hw_frames_ctx: *mut AVBufferRef, - pub sample_rate: c_int, - pub channel_layout: int64_t, -} - -extern { - pub fn av_buffersrc_get_nb_failed_requests(buffer_src: *const AVFilterContext) -> c_uint; - - pub fn av_buffersrc_parameters_alloc() -> *mut AVBufferSrcParameters; - pub fn av_buffersrc_parameters_set(ctx: *mut AVFilterContext, param: *mut AVBufferSrcParameters) -> c_int; - - pub fn av_buffersrc_write_frame(ctx: *mut AVFilterContext, frame: *const AVFrame) -> c_int; - pub fn av_buffersrc_add_frame(ctx: *mut AVFilterContext, frame: *mut AVFrame) -> c_int; - pub fn av_buffersrc_add_frame_flags(buffer_src: *mut AVFilterContext, frame: *mut AVFrame, flags: c_int) -> c_int; -} diff --git a/sys/src/avfilter/filter.rs b/sys/src/avfilter/filter.rs deleted file mode 100644 index ce70c1b..0000000 --- a/sys/src/avfilter/filter.rs +++ /dev/null @@ -1,194 +0,0 @@ -use libc::{c_void, c_char, c_int, c_uint, c_double, int64_t, uint64_t}; -use ::avutil::{AVClass, AVRational, AVMediaType, AVDictionary, AVFrame, AVBufferRef}; - -pub type AVFilterPad = c_void; -pub type AVFilterCommand = c_void; -pub type AVFilterChannelLayouts = c_void; -pub type AVFilterFormats = c_void; - -pub const AVFILTER_FLAG_DYNAMIC_INPUTS: c_int = 1 << 0; -pub const AVFILTER_FLAG_DYNAMIC_OUTPUTS: c_int = 1 << 1; -pub const AVFILTER_FLAG_SLICE_THREADS: c_int = 1 << 2; -pub const AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC: c_int = 1 << 16; -pub const AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL: c_int = 1 << 17; -pub const AVFILTER_FLAG_SUPPORT_TIMELINE: c_int = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL; - -#[repr(C)] -pub struct AVFilter { - pub name: *const c_char, - pub description: *const c_char, - pub inputs: *const AVFilterPad, - pub outputs: *const AVFilterPad, - pub priv_class: *const AVClass, - pub flags: c_int, - - pub init: extern fn(*mut AVFilterContext) -> c_int, - pub init_dict: extern fn(*mut AVFilterContext, *mut *mut AVDictionary) -> c_int, - pub uninit: extern fn(*mut AVFilterContext), - pub query_formats: extern fn(*mut AVFilterContext) -> c_int, - pub priv_size: c_int, - pub next: *mut AVFilter, - pub process_command: extern fn(*mut AVFilterContext, cmd: *const c_char, arg: *const c_char, *mut c_char, c_int, c_int) -> c_int, - pub init_opaque: extern fn(*mut AVFilterContext, *mut c_void) -> c_int, -} - -pub const AVFILTER_THREAD_SLICE: c_int = 1 << 0; - -pub type AVFilterInternal = c_void; - -#[repr(C)] -pub struct AVFilterContext { - pub av_class: *const AVClass, - pub filter: *const AVFilter, - pub name: *mut c_char, - pub input_pads: *mut AVFilterPad, - pub inputs: *mut *mut AVFilterLink, - pub nb_inputs: c_uint, - pub output_pads: *mut AVFilterPad, - pub outputs: *mut *mut AVFilterLink, - pub nb_outputs: c_uint, - pub private: *mut c_void, - pub graph: *mut AVFilterGraph, - pub thread_type: c_int, - pub internal: *mut AVFilterInternal, - pub command_queue: *mut AVFilterCommand, - pub enable_str: *mut c_char, - pub enable: *mut c_void, - pub var_values: *mut c_double, - pub is_disabled: c_int, - pub hw_device_ctx: AVBufferRef, - pub nb_threads: c_int, -} - -pub const AVLINK_UNINIT: c_int = 0; -pub const AVLINK_STARTINIT: c_int = 1; -pub const AVLINK_INIT: c_int = 2; - -#[repr(C)] -pub struct AVFilterLink { - pub src: *mut AVFilterContext, - pub srcpad: *mut AVFilterPad, - pub dst: *mut AVFilterContext, - pub dstpad: *mut AVFilterPad, - pub kind: AVMediaType, - pub w: c_int, - pub h: c_int, - pub sample_aspect_ratio: AVRational, - pub channel_layout: uint64_t, - pub sample_rate: c_int, - pub format: c_int, - pub time_base: AVRational, - - pub in_formats: *mut AVFilterFormats, - pub out_formats: *mut AVFilterFormats, - pub in_samplerates: *mut AVFilterFormats, - pub out_samplerates: *mut AVFilterFormats, - pub in_channel_layouts: *mut AVFilterChannelLayouts, - pub out_channel_layouts: *mut AVFilterChannelLayouts, - pub request_samples: c_int, - pub init_state: c_int, - pub graph: *mut AVFilterGraph, - pub current_pts: int64_t, - pub current_pts_us: int64_t, - pub age_index: c_int, - pub frame_rate: AVRational, - pub partial_buf: *mut AVFrame, - pub partial_buf_size: c_int, - pub min_samples: c_int, - pub max_samples: c_int, - pub status: c_int, - pub channels: c_int, - pub flags: c_uint, - pub frame_count: int64_t, - pub video_frame_pool: *mut c_void, - pub frame_wanted_in: c_int, - pub frame_wanted_out: c_int, - pub hw_frames_ctx: *mut AVBufferRef, -} - -pub const AVFILTER_CMD_FLAG_ONE: c_int = 1; -pub const AVFILTER_CMD_FLAG_FAST: c_int = 2; - -pub type AVFilterGraphInternal = c_void; - -pub type avfilter_action_func = extern fn(*mut AVFilterContext, *mut c_void, c_int, c_int) -> c_int; -pub type avfilter_execute_func = extern fn(*mut AVFilterContext, avfilter_action_func, *mut c_void, *mut c_int, c_int) -> c_int; - -#[repr(C)] -pub struct AVFilterGraph { - pub av_class: *const AVClass, - pub filters: *mut *mut AVFilterContext, - pub nb_filters: c_uint, - pub scale_sws_opts: *mut c_char, - pub resample_lavr_opts: *mut c_char, - pub thread_type: c_int, - pub nb_threads: c_int, - pub internal: *mut AVFilterGraphInternal, - pub opaque: *mut c_void, - pub execute: avfilter_execute_func, - pub aresample_swr_opts: *mut c_char, - pub sink_links: *mut *mut AVFilterLink, - pub sink_links_count: c_int, - pub disable_auto_convert: c_uint, -} - -pub const AVFILTER_AUTO_CONVERT_ALL: c_int = 0; -pub const AVFILTER_AUTO_CONVERT_NONE: c_int = -1; - -#[repr(C)] -pub struct AVFilterInOut { - pub name: *mut c_char, - pub filter_ctx: *mut AVFilterContext, - pub pad_idx: c_int, - pub next: *mut AVFilterInOut, -} - -extern { - pub fn avfilter_version() -> c_uint; - pub fn avfilter_configuration() -> *const c_char; - pub fn avfilter_license() -> *const c_char; - - pub fn avfilter_pad_count(pads: *const AVFilterPad) -> c_int; - pub fn avfilter_pad_get_name(pads: *const AVFilterPad, pad_idx: c_int) -> *const c_char; - pub fn avfilter_pad_get_type(pads: *const AVFilterPad, pad_idx: c_int) -> AVMediaType; - - pub fn avfilter_link(src: *mut AVFilterContext, srcpad: c_uint, dst: *mut AVFilterContext, dstpad: c_uint) -> c_int; - pub fn avfilter_link_free(link: *mut *mut AVFilterLink); - pub fn avfilter_link_get_channels(link: *mut AVFilterLink) -> c_int; - pub fn avfilter_link_set_closed(link: *mut AVFilterLink, closed: c_int); - pub fn avfilter_config_links(filter: *mut AVFilterContext) -> c_int; - - pub fn avfilter_process_command(filter: *mut AVFilterContext, cmd: *const c_char, arg: *const c_char, res: *const c_char, res_len: c_int, flags: c_int) -> c_int; - - pub fn avfilter_register_all(); - pub fn avfilter_register(filter: *const AVFilter) -> c_int; - - pub fn avfilter_get_by_name(name: *const c_char) -> *mut AVFilter; - pub fn avfilter_next(prev: *const AVFilter) -> *const AVFilter; - - pub fn avfilter_init_str(ctx: *mut AVFilterContext, args: *const c_char) -> c_int; - pub fn avfilter_init_dict(ctx: *mut AVFilterContext, options: *mut *mut AVDictionary) -> c_int; - pub fn avfilter_free(filter: *mut AVFilterContext); - pub fn avfilter_insert_filter(link: *mut AVFilterLink, filt: *mut AVFilterContext, filt_srcpad_idx: c_uint, filt_dstpad_idx: c_uint) -> c_int; - - pub fn avfilter_get_class() -> *const AVClass; - - pub fn avfilter_graph_alloc() -> *mut AVFilterGraph; - pub fn avfilter_graph_alloc_filter(graph: *mut AVFilterGraph, filter: *const AVFilter, name: *const c_char) -> *mut AVFilterContext; - pub fn avfilter_graph_get_filter(graph: *mut AVFilterGraph, name: *const c_char) -> *mut AVFilterContext; - pub fn avfilter_graph_create_filter(filt_ctx: *mut *mut AVFilterContext, filt: *const AVFilter, name: *const c_char, args: *const c_char, opaque: *mut c_void, graph_ctx: *mut AVFilterGraph) -> c_int; - pub fn avfilter_graph_set_auto_convert(graph: *mut AVFilterGraph, flags: c_uint); - pub fn avfilter_graph_config(graphctx: *mut AVFilterGraph, log_ctx: *mut c_void) -> c_int; - pub fn avfilter_graph_free(graph: *mut *mut AVFilterGraph); - - pub fn avfilter_inout_alloc() -> *mut AVFilterInOut; - pub fn avfilter_inout_free(inout: *mut *mut AVFilterInOut); - - pub fn avfilter_graph_parse(graph: *mut AVFilterGraph, filters: *const c_char, inputs: *mut AVFilterInOut, outputs: *mut AVFilterInOut, log_ctx: *mut c_void) -> c_int; - pub fn avfilter_graph_parse_ptr(graph: *mut AVFilterGraph, filters: *const c_char, inputs: *mut *mut AVFilterInOut, outputs: *mut *mut AVFilterInOut, log_ctx: *mut c_void) -> c_int; - pub fn avfilter_graph_parse2(graph: *mut AVFilterGraph, filters: *const c_char, inputs: *mut *mut AVFilterInOut, outputs: *mut *mut AVFilterInOut) -> c_int; - pub fn avfilter_graph_send_command(graph: *mut AVFilterGraph, target: *const c_char, cmd: *const c_char, arg: *const c_char, res: *mut c_char, res_len: c_int, flags: c_int) -> c_int; - pub fn avfilter_graph_queue_command(graph: *mut AVFilterGraph, target: *const c_char, cmd: *const c_char, arg: *const c_char, flags: c_int, ts: c_double) -> c_int; - pub fn avfilter_graph_dump(graph: *const AVFilterGraph, options: *const c_char) -> *mut c_char; - pub fn avfilter_graph_request_oldest(graph: *mut AVFilterGraph) -> c_int; -} diff --git a/sys/src/avfilter/mod.rs b/sys/src/avfilter/mod.rs deleted file mode 100644 index 72864bf..0000000 --- a/sys/src/avfilter/mod.rs +++ /dev/null @@ -1,12 +0,0 @@ -mod filter; -pub use self::filter::*; - -mod buffersink; -pub use self::buffersink::*; - -mod buffersrc; -pub use self::buffersrc::*; - -#[cfg_attr(feature = "static", link(name = "avfilter", kind = "static"))] -#[cfg_attr(not(feature = "static"), link(name = "avfilter"))] -extern { } diff --git a/sys/src/avformat/format.rs b/sys/src/avformat/format.rs deleted file mode 100644 index c613e1b..0000000 --- a/sys/src/avformat/format.rs +++ /dev/null @@ -1,611 +0,0 @@ -use libc::{c_void, c_char, c_uchar, c_int, c_uint, c_double, uint8_t, int64_t, size_t, FILE}; -use super::io::{AVIOContext, AVIOInterruptCB}; -use super::super::avutil::{AVClass, AVRational, AVDictionary, AVFrame, AVMediaType}; -use super::super::avcodec::{AVCodec, AVCodecID, AVCodecContext, AVCodecParameters, AVPacket, AVPacketSideData, AVCodecParserContext, AVDiscard}; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub struct AVFrac { - pub val: int64_t, - pub num: int64_t, - pub den: int64_t, -} - -pub type AVCodecTag = c_void; - -#[derive(Debug)] -#[repr(C)] -pub struct AVProbeData { - pub filename: *const c_char, - pub buf: *mut c_uchar, - pub buf_size: c_int, - pub mime_type: *const c_char, -} - -pub const AVPROBE_SCORE_EXTENSION: c_int = 50; -pub const AVPROBE_SCORE_MIME: c_int = 75; -pub const AVPROBE_SCORE_MAX: c_int = 100; -pub const AVPROBE_SCORE_RETRY: c_int = AVPROBE_SCORE_MAX / 4; -pub const AVPROBE_SCORE_STREAM_RETRY: c_int = AVPROBE_SCORE_MAX / 4 - 1; - -pub const AVPROBE_PADDING_SIZE: c_int = 32; - -pub const AVFMT_NOFILE: c_int = 0x0001; -pub const AVFMT_NEEDNUMBER: c_int = 0x0002; -pub const AVFMT_SHOW_IDS: c_int = 0x0008; -pub const AVFMT_RAWPICTURE: c_int = 0x0020; -pub const AVFMT_GLOBALHEADER: c_int = 0x0040; -pub const AVFMT_NOTIMESTAMPS: c_int = 0x0080; -pub const AVFMT_GENERIC_INDEX: c_int = 0x0100; -pub const AVFMT_TS_DISCONT: c_int = 0x0200; -pub const AVFMT_VARIABLE_FPS: c_int = 0x0400; -pub const AVFMT_NODIMENSIONS: c_int = 0x0800; -pub const AVFMT_NOSTREAMS: c_int = 0x1000; -pub const AVFMT_NOBINSEARCH: c_int = 0x2000; -pub const AVFMT_NOGENSEARCH: c_int = 0x4000; -pub const AVFMT_NO_BYTE_SEEK: c_int = 0x8000; -pub const AVFMT_ALLOW_FLUSH: c_int = 0x10000; -pub const AVFMT_TS_NONSTRICT: c_int = 0x20000; -pub const AVFMT_TS_NEGATIVE: c_int = 0x40000; -pub const AVFMT_SEEK_TO_PTS: c_int = 0x4000000; - -#[repr(C)] -pub struct AVOutputFormat { - pub name: *const c_char, - pub long_name: *const c_char, - - pub mime_type: *const c_char, - pub extensions: *const c_char, - - pub audio_codec: AVCodecID, - pub video_codec: AVCodecID, - pub subtitle_codec: AVCodecID, - - pub flags: c_int, - pub codec_tag: *const *const AVCodecTag, - pub priv_class: *const AVClass, - pub next: *mut AVOutputFormat, - pub priv_data_size: c_int, - - pub write_header: extern fn(ctx: *mut AVFormatContext) -> c_int, - pub write_packet: extern fn(ctx: *mut AVFormatContext, pkt: *mut AVPacket) -> c_int, - pub write_trailer: extern fn(ctx: *mut AVFormatContext) -> c_int, - - pub interleave_packet: extern fn(ctx: *mut AVFormatContext, out: *mut AVPacket, inp: *mut AVPacket, flush: c_int) -> c_int, - pub query_codec: extern fn(id: AVCodecID, std_compliance: c_int) -> c_int, - pub get_output_timestamp: extern fn(ctx: *mut AVFormatContext, stream: c_int, dts: *mut int64_t, wall: *mut int64_t), - pub control_message: extern fn(ctx: *mut AVFormatContext, kind: c_int, data: *mut c_void, data_size: size_t) -> c_int, - pub write_uncoded_frame: extern fn(ctx: *mut AVFormatContext, stream_index: c_int, frame: *mut *mut AVFrame, flags: c_uint) -> c_int, - - pub get_device_list: extern fn(ctx: *mut AVFormatContext, device_list: *mut c_void) -> c_int, - pub create_device_capabilities: extern fn(ctx: *mut AVFormatContext, caps: *mut c_void) -> c_int, - pub free_device_capabilities: extern fn(ctx: *mut AVFormatContext, caps: *mut c_void) -> c_int, - - pub data_codec: AVCodecID, - - pub init: extern fn(ctx: *mut AVFormatContext) -> c_int, - pub deinit: extern fn(ctx: *mut AVFormatContext), - pub check_bitstream: extern fn(ctx: *mut AVFormatContext, pkt: *const AVPacket) -> c_int, -} - -#[repr(C)] -pub struct AVInputFormat { - pub name: *const c_char, - pub long_name: *const c_char, - - pub flags: c_int, - pub extensions: *const c_char, - pub codec_tag: *const *const AVCodecTag, - pub priv_class: *const AVClass, - pub mime_type: *const c_char, - pub next: *mut AVInputFormat, - pub raw_codec_id: c_int, - pub priv_data_size: c_int, - - pub read_probe: extern fn(data: *mut AVProbeData) -> c_int, - pub read_header: extern fn(ctx: *mut AVFormatContext) -> c_int, - pub read_packet: extern fn(ctx: *mut AVFormatContext, pkt: *mut AVPacket) -> c_int, - pub read_close: extern fn(ctx: *mut AVFormatContext) -> c_int, - pub read_seek: extern fn(ctx: *mut AVFormatContext, stream_index: c_int, timestamp: int64_t, flags: c_int) -> c_int, - pub read_timestamp: extern fn(ctx: *mut AVFormatContext, stream_index: c_int, pos: *mut int64_t, pos_limit: int64_t) -> int64_t, - pub read_play: extern fn(ctx: *mut AVFormatContext) -> c_int, - pub read_pause: extern fn(ctx: *mut AVFormatContext) -> c_int, - pub read_seek2: extern fn(ctx: *mut AVFormatContext, stream_index: c_int, min_ts: int64_t, ts: int64_t, max_ts: int64_t, flags: c_int) -> c_int, - - pub get_device_list: extern fn(ctx: *mut AVFormatContext, device_list: *mut c_void) -> c_int, - pub create_device_capabilities: extern fn(ctx: *mut AVFormatContext, caps: *mut c_void) -> c_int, - pub free_device_capabilities: extern fn(ctx: *mut AVFormatContext, caps: *mut c_void) -> c_int, -} - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVStreamParseType { - AVSTREAM_PARSE_NONE, - AVSTREAM_PARSE_FULL, - AVSTREAM_PARSE_HEADERS, - AVSTREAM_PARSE_TIMESTAMPS, - AVSTREAM_PARSE_FULL_ONCE, - AVSTREAM_PARSE_FULL_RAW = MKTAG!(0, b'R', b'A', b'W'), -} - -#[derive(Debug)] -#[repr(C)] -pub struct AVIndexEntry { - pub pos: int64_t, - pub timestamp: int64_t, - data: i32, - pub min_distance: c_int, -} - -impl AVIndexEntry { - pub fn flags(&self) -> c_int { - self.data >> 30 - } - - pub fn size(&self) -> c_int { - self.data & 0b00111111111111111111111111111111 - } -} - -pub const AVINDEX_KEYFRAME: c_int = 0x0001; -pub const AVINDEX_DISCARD_FRAME: c_int = 0x0002; - -pub const AV_DISPOSITION_DEFAULT: c_int = 0x0001; -pub const AV_DISPOSITION_DUB: c_int = 0x0002; -pub const AV_DISPOSITION_ORIGINAL: c_int = 0x0004; -pub const AV_DISPOSITION_COMMENT: c_int = 0x0008; -pub const AV_DISPOSITION_LYRICS: c_int = 0x0010; -pub const AV_DISPOSITION_KARAOKE: c_int = 0x0020; -pub const AV_DISPOSITION_FORCED: c_int = 0x0040; -pub const AV_DISPOSITION_HEARING_IMPAIRED: c_int = 0x0080; -pub const AV_DISPOSITION_VISUAL_IMPAIRED: c_int = 0x0100; -pub const AV_DISPOSITION_CLEAN_EFFECTS: c_int = 0x0200; -pub const AV_DISPOSITION_ATTACHED_PIC: c_int = 0x0400; -pub const AV_DISPOSITION_TIMED_THUMBNAILS: c_int = 0x0800; -pub const AV_DISPOSITION_CAPTIONS: c_int = 0x10000; -pub const AV_DISPOSITION_DESCRIPTIONS: c_int = 0x20000; -pub const AV_DISPOSITION_METADATA: c_int = 0x40000; - -pub type AVStreamInternal = c_void; - -pub const AV_PTS_WRAP_IGNORE: c_int = 0; -pub const AV_PTS_WRAP_ADD_OFFSET: c_int = 1; -pub const AV_PTS_WRAP_SUB_OFFSET: c_int = -1; - -pub const AVSTREAM_EVENT_FLAG_METADATA_UPDATED: c_int = 0x0001; - -pub const MAX_STD_TIMEBASES: usize = 30 * 12 + 7 + 6; -pub const MAX_PROBE_PACKETS: usize = 2500; -pub const MAX_REORDER_DELAY: usize = 16; - -#[repr(C)] -pub struct AVStreamInfo { - pub last_dts: int64_t, - pub duration_gcd: int64_t, - pub duration_count: c_int, - pub rfps_duration_sum: int64_t, - pub duration_error: [[extern fn() -> c_double; MAX_STD_TIMEBASES]; 2], - pub codec_info_duration: int64_t, - pub codec_info_duration_fields: int64_t, - pub found_decoder: c_int, - pub last_duration: int64_t, - pub fps_first_dts: int64_t, - pub fps_first_dts_idx: c_int, - pub fps_last_dts: int64_t, - pub fps_last_dts_idx: c_int, -} - -#[repr(C)] -pub struct AVStream { - pub index: c_int, - pub id: c_int, - #[cfg(feature = "ff_api_lavf_avctx")] - pub codec: *mut AVCodecContext, - pub priv_data: *mut c_void, - #[cfg(feature = "ff_api_lavf_frac")] - pub pts: AVFrac, - pub time_base: AVRational, - pub start_time: int64_t, - pub duration: int64_t, - pub nb_frames: int64_t, - pub disposition: c_int, - pub discard: AVDiscard, - pub sample_aspect_ratio: AVRational, - pub metadata: *mut AVDictionary, - pub avg_frame_rate: AVRational, - pub attached_pic: AVPacket, - pub side_data: *mut AVPacketSideData, - pub nb_side_data: c_int, - pub event_flags: c_int, - pub info: *mut AVStreamInfo, - pub pts_wrap_bits: c_int, - pub first_dts: int64_t, - pub cur_dts: int64_t, - pub last_IP_pts: int64_t, - pub last_IP_duration: c_int, - pub probe_packets: c_int, - pub codec_info_nb_frames: c_int, - pub need_parsing: AVStreamParseType, - pub parser: *mut AVCodecParserContext, - pub last_in_packet_buffer: *mut AVPacketList, - pub probe_data: AVProbeData, - pub pts_buffer: [int64_t; MAX_REORDER_DELAY + 1], - pub index_entries: *mut AVIndexEntry, - pub nb_index_entries: c_int, - pub index_entries_allocated_size: c_uint, - pub r_frame_rate: AVRational, - pub stream_identifiers: c_int, - pub interleaver_chunk_size: int64_t, - pub interleaver_chunk_duration: int64_t, - pub request_probe: c_int, - pub skip_to_keyframe: c_int, - pub skip_samples: c_int, - pub start_skip_samples: int64_t, - pub first_discard_sample: int64_t, - pub last_discard_sample: int64_t, - pub nb_decoded_frames: c_int, - pub mux_ts_offset: int64_t, - pub pts_wrap_reference: int64_t, - pub pts_wrap_behavior: c_int, - pub update_initial_durations_done: c_int, - pub pts_reorder_error: [int64_t; MAX_REORDER_DELAY + 1], - pub pts_reorder_error_count: [uint8_t; MAX_REORDER_DELAY + 1], - pub last_dts_for_order_check: int64_t, - pub dts_ordered: uint8_t, - pub dts_misordered: uint8_t, - pub inject_global_side_data: c_int, - pub recommended_encoder_configuration: *mut c_char, - pub display_aspect_ratio: AVRational, - pub priv_pts: *mut c_void, - pub internal: *mut AVStreamInternal, - pub codecpar: *mut AVCodecParameters, -} - -pub const AV_PROGRAM_RUNNING: c_int = 1; - -#[derive(Debug)] -#[repr(C)] -pub struct AVProgram { - pub id: c_int, - pub flags: c_int, - pub discard: AVDiscard, - pub stream_index: *mut c_uint, - pub nb_stream_indexes: c_uint, - pub metadata: *mut AVDictionary, - pub program_num: c_int, - pub pmt_pid: c_int, - pub pcr_pid: c_int, - - pub start_time: int64_t, - pub end_time: int64_t, - pub pts_wrap_reference: int64_t, - pub pts_wrap_behavior: c_int, -} - -pub const AVFMTCTX_NOHEADER: c_int = 0x0001; - -#[derive(Debug)] -#[repr(C)] -pub struct AVChapter { - pub id: c_int, - pub time_base: AVRational, - pub start: int64_t, - pub end: int64_t, - pub metadata: *mut AVDictionary, -} - -pub type av_format_control_message = extern fn(s: *mut AVFormatContext, kind: c_int, data: *mut c_void, data_size: size_t) -> c_int; -pub type AVOpenCallback = extern fn(*mut AVFormatContext, *mut *mut AVIOContext, *const c_char, c_int, *const AVIOInterruptCB, *mut *mut AVDictionary) -> c_int; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVDurationEstimationMethod { - AVFMT_DURATION_FROM_PTS, - AVFMT_DURATION_FROM_STREAM, - AVFMT_DURATION_FROM_BITRATE, -} - -pub type AVFormatInternal = c_void; - -#[repr(C)] -pub struct AVFormatContext { - pub av_class: *const AVClass, - - pub iformat: *mut AVInputFormat, - pub oformat: *mut AVOutputFormat, - - pub priv_data: *mut c_void, - - pub pb: *mut AVIOContext, - - pub ctx_flags: c_int, - - pub nb_streams: c_uint, - pub streams: *mut *mut AVStream, - - pub filename: [c_char; 1024], - - pub start_time: int64_t, - pub duration: int64_t, - - pub bit_rate: int64_t, - pub packet_size: c_uint, - pub max_delay: c_int, - pub flags: c_int, - - pub probesize: int64_t, - pub max_analyze_duration: int64_t, - - pub key: *const uint8_t, - pub keylen: c_int, - - pub nb_programs: c_uint, - pub programs: *mut *mut AVProgram, - - pub video_codec_id: AVCodecID, - pub audio_codec_id: AVCodecID, - pub subtitle_codec_id: AVCodecID, - - pub max_index_size: c_uint, - pub max_picture_buffer: c_uint, - - pub nb_chapters: c_uint, - pub chapters: *mut *mut AVChapter, - - pub metadata: *mut AVDictionary, - - pub start_time_realtime: int64_t, - pub fps_probe_size: c_int, - pub error_recognition: c_int, - - pub interrupt_callback: AVIOInterruptCB, - - pub debug: c_int, - - pub max_interleave_delta: int64_t, - pub strict_std_compliance: c_int, - pub event_flags: c_int, - pub max_ts_probe: c_int, - pub avoid_negative_ts: c_int, - pub ts_id: c_int, - pub audio_preload: c_int, - - pub max_chunk_duration: c_int, - pub max_chunk_size: c_int, - - pub use_wallclock_as_timestamp: c_int, - pub avio_flags: c_int, - pub duration_estimation_method: AVDurationEstimationMethod, - pub skip_initial_bytes: int64_t, - pub correct_ts_overflow: c_uint, - pub seek2any: c_int, - pub flush_packets: c_int, - pub probe_score: c_int, - pub format_probesize: c_int, - - pub codec_whitelist: *mut c_char, - pub format_whitelist: *mut c_char, - - pub internal: *mut AVFormatInternal, - - pub io_repositioned: c_int, - - pub video_codec: *mut AVCodec, - pub audio_codec: *mut AVCodec, - pub subtitle_codec: *mut AVCodec, - pub data_codec: *mut AVCodec, - - pub metadata_header_padding: c_int, - pub opaque: *mut c_void, - - pub control_message_cb: av_format_control_message, - - pub output_ts_offset: int64_t, - - pub dump_separator: *mut uint8_t, - pub data_codec_id: AVCodecID, - - #[cfg(feature = "ff_api_old_open_callbacks")] - pub open_cb: extern fn(*mut AVFormatContext, *mut *mut AVIOContext, *const c_char, c_int, *const AVIOInterruptCB, *mut *mut AVDictionary) -> c_int, - - pub protocol_whitelist: *mut c_char, - - pub io_open: extern fn(*mut AVFormatContext, *mut *mut AVIOContext, *const c_char, c_int, *const AVIOInterruptCB, *mut *mut AVDictionary) -> c_int, - pub io_close: extern fn(*mut AVFormatContext, *mut AVIOContext), - - pub protocol_blacklist: *mut c_char, -} - -pub const AVFMT_FLAG_GENPTS: c_int = 0x0001; -pub const AVFMT_FLAG_IGNIDX: c_int = 0x0002; -pub const AVFMT_FLAG_NONBLOCK: c_int = 0x0004; -pub const AVFMT_FLAG_IGNDTS: c_int = 0x0008; -pub const AVFMT_FLAG_NOFILLIN: c_int = 0x0010; -pub const AVFMT_FLAG_NOPARSE: c_int = 0x0020; -pub const AVFMT_FLAG_NOBUFFER: c_int = 0x0040; -pub const AVFMT_FLAG_CUSTOM_IO: c_int = 0x0080; -pub const AVFMT_FLAG_DISCARD_CORRUPT: c_int = 0x0100; -pub const AVFMT_FLAG_FLUSH_PACKETS: c_int = 0x0200; -pub const AVFMT_FLAG_BITEXACT: c_int = 0x0400; -pub const AVFMT_FLAG_MP4A_LATM: c_int = 0x8000; -pub const AVFMT_FLAG_SORT_DTS: c_int = 0x10000; -pub const AVFMT_FLAG_PRIV_OPT: c_int = 0x20000; -pub const AVFMT_FLAG_KEEP_SIDE_DATA: c_int = 0x40000; -pub const AVFMT_FLAG_FAST_SEEK: c_int = 0x80000; -pub const AVFMT_FLAG_SHORTEST: c_int = 0x100000; -pub const AVFMT_FLAG_AUTO_BSF: c_int = 0x200000; - -pub const FF_FDEBUG_TS: c_int = 0x0001; - -pub const AVFMT_EVENT_FLAG_METADATA_UPDATED: c_int = 0x0001; - -pub const AVFMT_AVOID_NEG_TS_AUTO: c_int = -1; -pub const AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE: c_int = 1; -pub const AVFMT_AVOID_NEG_TS_MAKE_ZERO: c_int = 2; - -#[repr(C)] -pub struct AVPacketList { - pub pkt: AVPacket, - pub next: *mut AVPacketList, -} - -pub const AVSEEK_FLAG_BACKWARD: c_int = 1; -pub const AVSEEK_FLAG_BYTE: c_int = 2; -pub const AVSEEK_FLAG_ANY: c_int = 4; -pub const AVSEEK_FLAG_FRAME: c_int = 8; - -pub const AVSTREAM_INIT_IN_WRITE_HEADER: c_int = 0; -pub const AVSTREAM_INIT_IN_INIT_OUTPUT: c_int = 1; - -pub const AV_FRAME_FILENAME_FLAGS_MULTIPLE: c_int = 1; - -#[repr(C)] -pub enum AVTimebaseSource { - AVFMT_TBCF_AUTO = -1, - AVFMT_TBCF_DECODER, - AVFMT_TBCF_DEMUXER, - AVFMT_TBCF_R_FRAMERATE, -} - -extern { - pub fn av_get_packet(s: *mut AVIOContext, pkt: *mut AVPacket, size: c_int) -> c_int; - pub fn av_append_packet(s: *mut AVIOContext, pkt: *mut AVPacket, size: c_int) -> c_int; - - pub fn av_stream_get_r_frame_rate(s: *const AVStream) -> AVRational; - pub fn av_stream_set_r_frame_rate(s: *mut AVStream, r: AVRational); - - pub fn av_stream_get_parser(s: *const AVStream) -> *mut AVCodecParserContext; - - pub fn av_stream_get_recommended_encoder_configuration(s: *const AVStream) -> *mut c_char; - pub fn av_stream_set_recommended_encoder_configuration(s: *mut AVStream, configuration: *mut c_char); - - pub fn av_stream_get_end_pts(st: *const AVStream); - - pub fn av_format_get_probe_score(s: *const AVFormatContext) -> c_int; - - pub fn av_format_get_video_codec(s: *const AVFormatContext) -> *mut AVCodec; - pub fn av_format_set_video_codec(s: *mut AVFormatContext, c: *mut AVCodec); - - pub fn av_format_get_audio_codec(s: *const AVFormatContext) -> *mut AVCodec; - pub fn av_format_set_audio_codec(s: *mut AVFormatContext, c: *mut AVCodec); - - pub fn av_format_get_subtitle_codec(s: *const AVFormatContext) -> *mut AVCodec; - pub fn av_format_set_subtitle_codec(s: *mut AVFormatContext, c: *mut AVCodec); - - pub fn av_format_get_data_codec(s: *const AVFormatContext) -> *mut AVCodec; - pub fn av_format_set_data_codec(s: *mut AVFormatContext, c: *mut AVCodec); - - pub fn av_format_get_metadata_header_padding(s: *const AVFormatContext) -> c_int; - pub fn av_format_set_metadata_header_padding(s: *mut AVFormatContext, c: c_int); - - pub fn av_format_get_opaque(s: *const AVFormatContext) -> *mut c_void; - pub fn av_format_set_opaque(s: *mut AVFormatContext, opaque: *mut c_void); - - pub fn av_format_get_control_message_cb(s: *const AVFormatContext) -> av_format_control_message; - pub fn av_format_set_control_message_cb(s: *mut AVFormatContext, callback: av_format_control_message); - - pub fn av_format_get_open_cb(s: *const AVFormatContext) -> AVOpenCallback; - pub fn av_format_set_open_cb(s: *mut AVFormatContext, callback: AVOpenCallback); - - pub fn av_format_inject_global_side_data(s: *mut AVFormatContext); - - pub fn av_fmt_ctx_get_duration_estimation_method(ctx: *const AVFormatContext) -> AVDurationEstimationMethod; - - pub fn avformat_version() -> c_uint; - pub fn avformat_configuration() -> *const c_char; - pub fn avformat_license() -> *const c_char; - - pub fn av_register_all(); - pub fn av_register_input_format(format: *const AVInputFormat); - pub fn av_register_output_format(format: *const AVOutputFormat); - - pub fn avformat_network_init() -> c_int; - pub fn avformat_network_deinit() -> c_int; - - pub fn av_iformat_next(f: *const AVInputFormat) -> *mut AVInputFormat; - pub fn av_oformat_next(f: *const AVOutputFormat) -> *mut AVOutputFormat; - - pub fn avformat_alloc_context() -> *mut AVFormatContext; - pub fn avformat_free_context(s: *mut AVFormatContext); - pub fn avformat_get_class() -> *const AVClass; - - pub fn avformat_new_stream(s: *mut AVFormatContext, c: *const AVCodec) -> *mut AVStream; - pub fn av_stream_get_side_data(stream: *mut AVStream, kind: AVPacketSideData, size: *mut c_int) -> *mut uint8_t; - - pub fn av_new_program(s: *mut AVFormatContext, id: c_int) -> *mut AVProgram; - - pub fn avformat_alloc_output_context2(ctx: *mut *mut AVFormatContext, oformat: *const AVOutputFormat, format_name: *const c_char, filename: *const c_char) -> c_int; - - pub fn av_find_input_format(short_name: *const c_char) -> *mut AVInputFormat; - pub fn av_probe_input_format(pd: *mut AVProbeData, is_opened: c_int) -> *mut AVInputFormat; - pub fn av_probe_input_format2(pd: *mut AVProbeData, is_opened: c_int, score_max: *mut c_int) -> *mut AVInputFormat; - pub fn av_probe_input_format3(pd: *mut AVProbeData, is_opened: c_int, score_ret: *mut c_int) -> *mut AVInputFormat; - pub fn av_probe_input_buffer2(pb: *mut AVIOContext, fmt: *mut *mut AVInputFormat, filename: *const c_char, logctx: *mut c_void, offset: c_uint, max_probe_size: c_uint) -> c_int; - pub fn av_probe_input_buffer(pb: *mut AVIOContext, fmt: *mut *mut AVInputFormat, filename: *const c_char, logctx: *mut c_void, offset: c_uint, max_probe_size: c_uint) -> c_int; - - pub fn avformat_open_input(ps: *mut *mut AVFormatContext, filename: *const c_char, fmt: *const AVInputFormat, options: *mut *mut AVDictionary) -> c_int; - pub fn avformat_find_stream_info(ic: *mut AVFormatContext, options: *mut *mut AVDictionary) -> c_int; - pub fn av_find_program_from_stream(ic: *const AVFormatContext, last: *mut AVProgram, s: c_int) -> *mut AVProgram; - pub fn av_program_add_stream_index(ac: *mut AVFormatContext, progid: c_int, idx: c_uint); - pub fn av_find_best_stream(ic: *const AVFormatContext, kind: AVMediaType, wanted_stream_nb: c_int, related_stream: c_int, decoder_ret: *mut *mut AVCodec, flags: c_int) -> c_int; - - pub fn av_read_frame(s: *mut AVFormatContext, pkt: *mut AVPacket) -> c_int; - pub fn av_seek_frame(s: *mut AVFormatContext, stream_index: c_int, timestamp: int64_t, flags: c_int) -> c_int; - pub fn avformat_seek_file(s: *mut AVFormatContext, stream_index: c_int, min_ts: int64_t, ts: int64_t, max_ts: int64_t, flags: c_int) -> c_int; - pub fn avformat_flush(s: *mut AVFormatContext) -> c_int; - pub fn av_read_play(s: *mut AVFormatContext) -> c_int; - pub fn av_read_pause(s: *mut AVFormatContext) -> c_int; - pub fn avformat_close_input(s: *mut *mut AVFormatContext); - - pub fn avformat_write_header(s: *mut AVFormatContext, options: *mut *mut AVDictionary) -> c_int; - pub fn avformat_init_output(s: *mut AVFormatContext, options: *mut *mut AVDictionary) -> c_int; - pub fn av_write_frame(s: *mut AVFormatContext, pkt: *const AVPacket) -> c_int; - pub fn av_interleaved_write_frame(s: *mut AVFormatContext, pkt: *const AVPacket) -> c_int; - pub fn av_write_uncoded_frame(s: *mut AVFormatContext, stream_index: c_int, frame: *mut AVFrame) -> c_int; - pub fn av_interleaved_write_uncoded_frame(s: *mut AVFormatContext, stream_index: c_int, frame: *mut AVFrame) -> c_int; - pub fn av_write_uncoded_frame_query(s: *mut AVFormatContext, stream_index: c_int) -> c_int; - pub fn av_write_trailer(s: *mut AVFormatContext) -> c_int; - - pub fn av_guess_format(short_name: *const c_char, filename: *const c_char, mime_type: *const c_char) -> *mut AVOutputFormat; - pub fn av_guess_codec(fmt: *const AVOutputFormat, short_name: *const c_char, filename: *const c_char, mime_type: *const c_char, kind: AVMediaType) -> AVCodecID; - - pub fn av_get_output_timestamp(s: *mut AVFormatContext, stream: c_int, dts: *mut int64_t, wall: *mut int64_t) -> c_int; - - pub fn av_hex_dump(f: *mut FILE, buf: *mut uint8_t, size: c_int); - pub fn av_hex_dump_log(avcl: *mut c_void, level: c_int, buf: *const uint8_t, size: c_int); - pub fn av_pkt_dump2(f: *mut FILE, pkt: *const AVPacket, dump_payload: c_int, st: *const AVStream); - pub fn av_pkt_dump_log2(avcl: *mut c_void, level: c_int, pkt: *const AVPacket, dump_payload: c_int, st: *const AVStream); - - pub fn av_codec_get_id(tags: *const *const AVCodecTag, tag: c_uint) -> AVCodecID; - pub fn av_codec_get_tag(tags: *const *const AVCodecTag, id: AVCodecID) -> c_uint; - pub fn av_codec_get_tag2(tags: *const *const AVCodecTag, id: AVCodecID, tag: *mut c_uint) -> c_int; - pub fn av_find_default_stream_index(s: *mut AVFormatContext) -> c_int; - - pub fn av_index_search_timestamp(st: *mut AVStream, timestamp: int64_t, flags: c_int) -> c_int; - pub fn av_add_index_entry(st: *mut AVStream, pos: int64_t, timestamp: int64_t, size: c_int, distance: c_int, flags: c_int) -> c_int; - pub fn av_url_split(proto: *mut c_char, proto_size: c_int, authorization: *mut c_char, authorization_size: c_int, hostname: *mut c_char, hostname_size: c_int, port_ptr: *mut c_int, path: *mut c_char, path_size: c_int, url: *const c_char); - - pub fn av_dump_format(ic: *const AVFormatContext, index: c_int, url: *const c_char, is_output: c_int); - - pub fn av_get_frame_filename2(buf: *mut c_char, buf_size: c_int, - path: *const c_char, number: c_int, flags: c_int) -> c_int; - pub fn av_get_frame_filename(buf: *mut c_char, buf_size: c_int, path: *const c_char, number: c_int) -> c_int; - pub fn av_filename_number_test(filename: *const c_char) -> c_int; - pub fn av_sdp_create(ac: *mut *mut AVFormatContext, n_files: c_int, buf: *mut c_char, size: c_int) -> c_int; - pub fn av_match_ext(filename: *const c_char, extensions: *const c_char) -> c_int; - - pub fn avformat_query_codec(ofmt: *const AVOutputFormat, codec_id: AVCodecID, std_compliance: c_int) -> c_int; - pub fn avformat_get_riff_video_tags() -> *const AVCodecTag; - pub fn avformat_get_riff_audio_tags() -> *const AVCodecTag; - pub fn avformat_get_mov_video_tags() -> *const AVCodecTag; - pub fn avformat_get_mov_audio_tags() -> *const AVCodecTag; - - pub fn av_guess_sample_aspect_ratio(format: *mut AVFormatContext, stream: *mut AVStream, frame: *mut AVFrame) -> AVRational; - pub fn av_guess_frame_rate(ctx: *mut AVFormatContext, stream: *mut AVStream, frame: *mut AVStream) -> AVRational; - - pub fn avformat_match_stream_specifier(s: *mut AVFormatContext, st: *mut AVStream, spec: *const c_char) -> c_int; - pub fn avformat_queue_attached_pictures(s: *mut AVFormatContext) -> c_int; - - pub fn avformat_transfer_internal_stream_timing_info(ofmt: *const AVOutputFormat, ost: *mut AVStream, ist: *const AVStream, copy_tb: AVTimebaseSource) -> c_int; - pub fn av_stream_get_codec_timebase(st: *const AVStream) -> AVRational; -} diff --git a/sys/src/avformat/io.rs b/sys/src/avformat/io.rs deleted file mode 100644 index 49d31bf..0000000 --- a/sys/src/avformat/io.rs +++ /dev/null @@ -1,184 +0,0 @@ -use libc::{c_void, c_char, c_uchar, c_int, c_uint, c_ulong, uint8_t, int64_t, uint64_t, size_t, SEEK_CUR}; -use super::super::avutil::{AVClass, AVBPrint, AVDictionary}; - -pub type URLContext = c_void; - -pub const AVIO_SEEKABLE_NORMAL: c_int = 0x0001; - -#[repr(C)] -pub struct AVIOInterruptCB { - pub callback: extern fn(*mut c_void) -> c_int, - pub opaque: *mut c_void, -} - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVIODirEntryType { - AVIO_ENTRY_UNKNOWN, - AVIO_ENTRY_BLOCK_DEVICE, - AVIO_ENTRY_CHARACTER_DEVICE, - AVIO_ENTRY_DIRECTORY, - AVIO_ENTRY_NAMED_PIPE, - AVIO_ENTRY_SYMBOLIC_LINK, - AVIO_ENTRY_SOCKET, - AVIO_ENTRY_FILE, - AVIO_ENTRY_SERVER, - AVIO_ENTRY_SHARE, - AVIO_ENTRY_WORKGROUP, -} - -#[repr(C)] -pub struct AVIODirEntry { - name: *mut c_char, - kind: c_int, - utf8: c_int, - - size: int64_t, - modification_timestamp: int64_t, - - access_timestamp: int64_t, - - status_change_timestamp: int64_t, - - user_id: int64_t, - group_id: int64_t, - filemode: int64_t, -} - -#[repr(C)] -pub struct AVIODirContext { - url_context: *mut URLContext, -} - -#[repr(C)] -pub enum AVIODataMarkerType { - AVIO_DATA_MARKER_HEADER, - AVIO_DATA_MARKER_SYNC_POINT, - AVIO_DATA_MARKER_BOUNDARY_POINT, - AVIO_DATA_MARKER_UNKNOWN, - AVIO_DATA_MARKER_TRAILER, -} - -#[repr(C)] -pub struct AVIOContext { - pub av_class: *mut AVClass, - pub buffer: *mut c_uchar, - pub buffer_size: c_int, - pub buf_ptr: *mut c_uchar, - pub buf_end: *mut c_uchar, - pub opaque: *mut c_void, - pub read_packet: extern fn(*mut c_void, *mut uint8_t, c_int) -> c_int, - pub write_packet: extern fn(*mut c_void, *mut uint8_t, c_int) -> c_int, - pub seek: extern fn(*mut c_void, int64_t, c_int) -> int64_t, - pub pos: int64_t, - pub must_flush: c_int, - pub eof_reached: c_int, - pub write_flag: c_int, - pub max_packet_size: c_int, - pub checksum: c_ulong, - pub checksum_ptr: *mut c_uchar, - pub update_checksum: extern fn(c_ulong, *const uint8_t, c_uint) -> c_uint, - pub error: c_int, - pub read_pause: extern fn(*mut c_void, c_int) -> c_int, - pub read_seek: extern fn(*mut c_void, c_int, int64_t, c_int) -> int64_t, - pub seekable: c_int, - pub maxsize: int64_t, - pub direct: c_int, - pub bytes_read: int64_t, - pub seek_count: c_int, - pub writeout_count: c_int, - pub orig_buffer_size: c_int, - pub short_seek_threshold: c_int, - pub protocol_whitelist: *const c_char, - pub protocol_blacklist: *const c_char, - pub write_data_type: extern fn(opaque: *mut c_void, buf: *mut uint8_t, buf_size: c_int, - kind: AVIODataMarkerType, time: int64_t) -> c_int, - pub ignore_boundary_point: c_int, - pub current_type: AVIODataMarkerType, - pub last_time: int64_t, -} - -pub const AVSEEK_SIZE: c_int = 0x10000; -pub const AVSEEK_FORCE: c_int = 0x20000; - -#[inline(always)] -pub unsafe fn avio_tell(s: *mut AVIOContext) -> int64_t { - avio_seek(s, 0, SEEK_CUR) -} - -pub const AVIO_FLAG_READ: c_int = 1; -pub const AVIO_FLAG_WRITE: c_int = 2; -pub const AVIO_FLAG_READ_WRITE: c_int = AVIO_FLAG_READ | AVIO_FLAG_WRITE; -pub const AVIO_FLAG_NONBLOCK: c_int = 8; -pub const AVIO_FLAG_DIRECT: c_int = 0x8000; - -extern { - pub fn avio_find_protocol_name(url: *const c_char) -> *const c_char; - pub fn avio_check(url: *const c_char, flags: c_int) -> c_int; - - pub fn avpriv_io_move(url_src: *const c_char, url_dst: *const c_char) -> c_int; - pub fn avpriv_io_delete(url: *const c_char) -> c_int; - - pub fn avio_open_dir(s: *mut *mut AVIODirContext, url: *const c_char, options: *mut *mut AVDictionary) -> c_int; - pub fn avio_read_dir(s: *mut AVIODirContext, next: *mut *mut AVIODirEntry) -> c_int; - pub fn avio_close_dir(s: *mut *mut AVIODirContext) -> c_int; - pub fn avio_free_directory_entry(entry: *mut *mut AVIODirEntry); - pub fn avio_alloc_context(buffer: *mut c_uchar, buffer_size: c_int, write_flag: c_int, opaque: *mut c_void, read_packet: extern fn(*mut c_void, *mut uint8_t, c_int) -> c_int, write_packet: extern fn(*mut c_void, *mut uint8_t, c_int) -> c_int, seek: extern fn(*mut c_void, int64_t, c_int) -> int64_t) -> *mut AVIOContext; - - pub fn avio_w8(s: *mut AVIOContext, b: c_int); - pub fn avio_write(s: *mut AVIOContext, buf: *const c_uchar, size: c_int); - pub fn avio_wl64(s: *mut AVIOContext, val: uint64_t); - pub fn avio_wb64(s: *mut AVIOContext, val: uint64_t); - pub fn avio_wl32(s: *mut AVIOContext, val: c_uint); - pub fn avio_wb32(s: *mut AVIOContext, val: c_uint); - pub fn avio_wl24(s: *mut AVIOContext, val: c_uint); - pub fn avio_wb24(s: *mut AVIOContext, val: c_uint); - pub fn avio_wl16(s: *mut AVIOContext, val: c_uint); - pub fn avio_wb16(s: *mut AVIOContext, val: c_uint); - - pub fn avio_put_str(s: *mut AVIOContext, string: *const c_char) -> c_int; - pub fn avio_put_str16le(s: *mut AVIOContext, string: *const c_char) -> c_int; - pub fn avio_put_str16be(s: *mut AVIOContext, string: *const c_char) -> c_int; - - pub fn avio_write_marker(s: *mut AVIOContext, time: int64_t, kind: AVIODataMarkerType); - - pub fn avio_seek(s: *mut AVIOContext, offset: int64_t, whence: c_int) -> int64_t; - pub fn avio_skip(s: *mut AVIOContext, offset: int64_t) -> int64_t; - pub fn avio_size(s: *mut AVIOContext) -> int64_t; - pub fn avio_feof(s: *mut AVIOContext) -> c_int; - - pub fn avio_printf(s: *mut AVIOContext, fmt: *const c_char, ...) -> c_int; - pub fn avio_flush(s: *mut AVIOContext); - - pub fn avio_read(s: *mut AVIOContext, buf: *mut c_uchar, size: c_int) -> c_int; - pub fn avio_r8(s: *mut AVIOContext) -> c_int; - pub fn avio_rl16(s: *mut AVIOContext) -> c_uint; - pub fn avio_rl24(s: *mut AVIOContext) -> c_uint; - pub fn avio_rl32(s: *mut AVIOContext) -> c_uint; - pub fn avio_rl64(s: *mut AVIOContext) -> uint64_t; - pub fn avio_rb16(s: *mut AVIOContext) -> c_uint; - pub fn avio_rb24(s: *mut AVIOContext) -> c_uint; - pub fn avio_rb32(s: *mut AVIOContext) -> c_uint; - pub fn avio_rb64(s: *mut AVIOContext) -> uint64_t; - - pub fn avio_get_str(pb: *mut AVIOContext, maxlen: c_int, buf: *mut c_char, buflen: c_int) -> c_int; - pub fn avio_get_str16le(pb: *mut AVIOContext, maxlen: c_int, buf: *mut c_char, buflen: c_int) -> c_int; - pub fn avio_get_str16be(pb: *mut AVIOContext, maxlen: c_int, buf: *mut c_char, buflen: c_int) -> c_int; - - pub fn avio_open(s: *mut *mut AVIOContext, url: *const c_char, flags: c_int) -> c_int; - pub fn avio_open2(s: *mut *mut AVIOContext, url: *const c_char, flags: c_int, int_cb: *const AVIOInterruptCB, options: *mut *mut AVDictionary) -> c_int; - - pub fn avio_close(s: *mut AVIOContext) -> c_int; - pub fn avio_closep(s: *mut *mut AVIOContext) -> c_int; - - pub fn avio_open_dyn_buf(s: *mut *mut AVIOContext) -> c_int; - pub fn avio_close_dyn_buf(s: *mut AVIOContext, pbuffer: *mut *mut uint8_t) -> c_int; - - pub fn avio_enum_protocols(opaque: *mut *mut c_void, output: c_int) -> *const c_char; - pub fn avio_pause(h: *mut AVIOContext, pause: c_int) -> c_int; - pub fn avio_seek_time(h: *mut AVIOContext, stream_index: c_int, timestamp: int64_t, flags: c_int) -> int64_t; - pub fn avio_read_to_bprint(h: *mut AVIOContext, pb: *mut AVBPrint, max_size: size_t) -> c_int; - - pub fn avio_accept(s: *mut AVIOContext, c: *mut *mut AVIOContext) -> c_int; - pub fn avio_handshake(c: *mut AVIOContext) -> c_int; -} diff --git a/sys/src/avformat/mod.rs b/sys/src/avformat/mod.rs deleted file mode 100644 index 5a5c922..0000000 --- a/sys/src/avformat/mod.rs +++ /dev/null @@ -1,9 +0,0 @@ -mod format; -pub use self::format::*; - -mod io; -pub use self::io::*; - -#[cfg_attr(feature = "static", link(name = "avformat", kind = "static"))] -#[cfg_attr(not(feature = "static"), link(name = "avformat"))] -extern { } diff --git a/sys/src/avresample/mod.rs b/sys/src/avresample/mod.rs deleted file mode 100644 index 33e5dd8..0000000 --- a/sys/src/avresample/mod.rs +++ /dev/null @@ -1,9 +0,0 @@ -mod resample; -pub use self::resample::*; -pub use self::resample::AVMixCoeffType::*; -pub use self::resample::AVResampleFilterType::*; -pub use self::resample::AVResampleDitherMethod::*; - -#[cfg_attr(feature = "static", link(name = "avresample", kind = "static"))] -#[cfg_attr(not(feature = "static"), link(name = "avresample"))] -extern { } diff --git a/sys/src/avresample/resample.rs b/sys/src/avresample/resample.rs deleted file mode 100644 index 4607698..0000000 --- a/sys/src/avresample/resample.rs +++ /dev/null @@ -1,61 +0,0 @@ -use libc::{c_void, c_char, c_int, c_uint, c_double, uint8_t, uint64_t}; -use ::avutil::{AVClass, AVMatrixEncoding, AVFrame}; - -pub const AVRESAMPLE_MAX_CHANNELS: c_int = 32; - -pub type AVAudioResampleContext = c_void; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVMixCoeffType { - AV_MIX_COEFF_TYPE_Q8, - AV_MIX_COEFF_TYPE_Q15, - AV_MIX_COEFF_TYPE_FLT, - AV_MIX_COEFF_TYPE_NB, -} - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVResampleFilterType { - AV_RESAMPLE_FILTER_TYPE_CUBIC, - AV_RESAMPLE_FILTER_TYPE_BLACKMAN_NUTTALL, - AV_RESAMPLE_FILTER_TYPE_KAISER, -} - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVResampleDitherMethod { - AV_RESAMPLE_DITHER_NONE, - AV_RESAMPLE_DITHER_RECTANGULAR, - AV_RESAMPLE_DITHER_TRIANGULAR, - AV_RESAMPLE_DITHER_TRIANGULAR_HP, - AV_RESAMPLE_DITHER_TRIANGULAR_NS, - AV_RESAMPLE_DITHER_NB, -} - -extern { - pub fn avresample_version() -> c_uint; - pub fn avresample_configuration() -> *const c_char; - pub fn avresample_license() -> *const c_char; - - pub fn avresample_get_class() -> *const AVClass; - - pub fn avresample_alloc_context() -> *mut AVAudioResampleContext; - pub fn avresample_open(avr: *mut AVAudioResampleContext) -> c_int; - pub fn avresample_is_open(avr: *mut AVAudioResampleContext) -> c_int; - pub fn avresample_close(avr: *mut AVAudioResampleContext); - pub fn avresample_free(avr: *mut *mut AVAudioResampleContext); - - pub fn avresample_build_matrix(in_layout: uint64_t, out_layout: uint64_t, center_mix_level: c_double, surround_mix_level: c_double, lfe_mix_level: c_double, normalize: c_int, matrix: *mut c_double, stride: c_int, matrix_encoding: AVMatrixEncoding) -> c_int; - pub fn avresample_get_matrix(avr: *mut AVAudioResampleContext, matrix: *mut c_double, stride: c_int) -> c_int; - pub fn avresample_set_matrix(avr: *mut AVAudioResampleContext, matrix: *const c_double, stride: c_int) -> c_int; - pub fn avresample_set_channel_mapping(avr: *mut AVAudioResampleContext, channel_map: *const c_int) -> c_int; - pub fn avresample_set_compensation(avr: *mut AVAudioResampleContext, sample_delta: c_int, compensation_distance: c_int) -> c_int; - pub fn avresample_get_out_samples(avr: *mut AVAudioResampleContext, in_nb_samples: c_int) -> c_int; - pub fn avresample_convert(avr: *mut AVAudioResampleContext, output: *mut *mut uint8_t, out_plane_size: c_int, out_samples: c_int, input: *mut *mut uint8_t, in_plane_size: c_int, in_samples: c_int) -> c_int; - pub fn avresample_get_delay(avr: *mut AVAudioResampleContext) -> c_int; - pub fn avresample_available(avr: *mut AVAudioResampleContext) -> c_int; - pub fn avresample_read(avr: *mut AVAudioResampleContext, output: *mut *mut uint8_t, nb_samples: c_int) -> c_int; - pub fn avresample_convert_frame(avr: *mut AVAudioResampleContext, output: *mut AVFrame, input: *const AVFrame) -> c_int; - pub fn avresample_config(avr: *mut AVAudioResampleContext, output: *mut AVFrame, input: *const AVFrame) -> c_int; -} diff --git a/sys/src/avutil/adler32.rs b/sys/src/avutil/adler32.rs deleted file mode 100644 index 5cecdab..0000000 --- a/sys/src/avutil/adler32.rs +++ /dev/null @@ -1,5 +0,0 @@ -use libc::{c_int, c_ulong, uint8_t}; - -extern { - pub fn av_adler32_update(adler: c_ulong, buf: *const uint8_t, len: c_int) -> c_ulong; -} diff --git a/sys/src/avutil/aes.rs b/sys/src/avutil/aes.rs deleted file mode 100644 index 9628ab6..0000000 --- a/sys/src/avutil/aes.rs +++ /dev/null @@ -1,11 +0,0 @@ -use libc::{c_void, c_int, uint8_t}; - -pub type AVAES = c_void; - -extern { - pub static av_aes_size: c_int; - - pub fn av_aes_alloc() -> *mut AVAES; - pub fn av_aes_init(a: *mut AVAES, key: *const uint8_t, key_bits: c_int, decrypt: c_int) -> c_int; - pub fn av_aes_crypt(a: *mut AVAES, dst: *mut uint8_t, src: *const uint8_t, count: c_int, iv: *mut uint8_t, decrypt: c_int); -} diff --git a/sys/src/avutil/audio_fifo.rs b/sys/src/avutil/audio_fifo.rs deleted file mode 100644 index 48d0f59..0000000 --- a/sys/src/avutil/audio_fifo.rs +++ /dev/null @@ -1,17 +0,0 @@ -use libc::{c_void, c_int}; -use super::samplefmt::AVSampleFormat; - -pub type AVAudioFifo = c_void; - -extern { - pub fn av_audio_fifo_free(af: *mut AVAudioFifo); - pub fn av_audio_fifo_alloc(sample_fmt: AVSampleFormat, channels: c_int, nb_samples: c_int) -> *mut AVAudioFifo; - pub fn av_audio_fifo_realloc(af: *mut AVAudioFifo, nb_samples: c_int) -> c_int; - pub fn av_audio_fifo_write(af: *mut AVAudioFifo, data: *mut *mut c_void, nb_samples: c_int) -> c_int; - pub fn av_audio_fifo_peek(af: *mut AVAudioFifo, data: *mut *mut c_void, nb_samples: c_int) -> c_int; - pub fn av_audio_fifo_read(af: *mut AVAudioFifo, data: *mut *mut c_void, nb_samples: c_int) -> c_int; - pub fn av_audio_fifo_drain(af: *mut AVAudioFifo, nb_samples: c_int) -> c_int; - pub fn av_audio_fifo_reset(af: *mut AVAudioFifo); - pub fn av_audio_fifo_size(af: *mut AVAudioFifo) -> c_int; - pub fn av_audio_fifo_space(af: *mut AVAudioFifo) -> c_int; -} diff --git a/sys/src/avutil/base64.rs b/sys/src/avutil/base64.rs deleted file mode 100644 index 27e2b1c..0000000 --- a/sys/src/avutil/base64.rs +++ /dev/null @@ -1,11 +0,0 @@ -use libc::{c_char, c_int, uint8_t, size_t}; - -#[inline(always)] -pub fn AV_BASE64_SIZE(x: size_t) -> size_t { - (x + 2) / 3 * 4 + 1 -} - -extern { - pub fn av_base64_decode(out: *mut uint8_t, inp: *const c_char, out_size: c_int) -> c_int; - pub fn av_base64_encode(out: *mut c_char, out_size: c_int, inp: *const uint8_t, in_size: c_int) -> *mut c_char; -} diff --git a/sys/src/avutil/blowfish.rs b/sys/src/avutil/blowfish.rs deleted file mode 100644 index 90d644b..0000000 --- a/sys/src/avutil/blowfish.rs +++ /dev/null @@ -1,16 +0,0 @@ -use libc::{c_int, uint8_t, uint32_t}; - -pub const AV_BF_ROUNDS: c_int = 16; - -#[repr(C)] -pub struct AVBlowfish { - pub p: [uint32_t; AV_BF_ROUNDS as usize + 2], - pub s: [[uint32_t; 256]; 4], -} - -extern { - pub fn av_blowfish_alloc() -> *mut AVBlowfish; - pub fn av_blowfish_init(ctx: *mut AVBlowfish, key: *const uint8_t, key_len: c_int); - pub fn av_blowfish_crypt_ecb(ctx: *mut AVBlowfish, xl: *mut uint32_t, xr: *mut uint32_t, decrypt: c_int); - pub fn av_blowfish_crypt(ctx: *mut AVBlowfish, dst: *mut uint8_t, src: *const uint8_t, count: c_int, iv: *mut uint8_t, decrypt: c_int); -} diff --git a/sys/src/avutil/bprint.rs b/sys/src/avutil/bprint.rs deleted file mode 100644 index 5d1b2ea..0000000 --- a/sys/src/avutil/bprint.rs +++ /dev/null @@ -1,36 +0,0 @@ -use libc::{c_void, c_char, c_uchar, c_uint, c_int}; -use super::string::AVEscapeMode; - -#[repr(C)] -pub struct AVBPrint { - pub string: *mut c_char, - pub len: c_uint, - pub size: c_uint, - pub size_max: c_uint, - - buffer: [c_char; 1024], -} - -#[inline(always)] -pub unsafe fn av_bprint_is_complete(buf: *const AVBPrint) -> c_int { - if (*buf).len < (*buf).size { - 1 - } - else { - 0 - } -} - -extern { - pub fn av_bprint_init(buf: *mut AVBPrint, size_init: c_uint, size_max: c_uint); - pub fn av_bprint_init_for_buffer(buf: *mut AVBPrint, buffer: *mut c_char, size: c_uint); - pub fn av_bprintf(buf: *mut AVBPrint, fmt: *const c_char, ...); - //pub fn av_vbprintf(buf: *mut AVBPrint, fmt: *const c_char, vl_arg: va_list); - pub fn av_bprint_chars(buf: *mut AVBPrint, c: c_char, n: c_uint); - pub fn av_bprint_append_data(buf: *mut AVBPrint, data: *const c_char, size: c_uint); - pub fn av_bprint_strftime(buf: *mut AVBPrint, fmt: *const c_char, tm: *const c_void); - pub fn av_bprint_get_buffer(buf: *mut AVBPrint, size: c_uint, mem: *mut *mut c_uchar, actual_size: *mut c_uint); - pub fn av_bprint_clear(buf: *mut AVBPrint); - pub fn av_bprint_finalize(buf: *mut AVBPrint, ret_str: *mut *mut c_char) -> c_int; - pub fn av_bprint_escape(dstbuf: *mut AVBPrint, src: *const c_char, special_chars: *const c_char, mode: AVEscapeMode, flags: c_int); -} diff --git a/sys/src/avutil/buffer.rs b/sys/src/avutil/buffer.rs deleted file mode 100644 index 635f36e..0000000 --- a/sys/src/avutil/buffer.rs +++ /dev/null @@ -1,33 +0,0 @@ -use libc::{c_void, c_int, uint8_t}; - -pub type AVBuffer = c_void; - -#[derive(Debug)] -#[repr(C)] -pub struct AVBufferRef { - pub buffer: *mut AVBuffer, - pub data: *mut uint8_t, - pub size: c_int, -} - -pub type AVBufferPool = c_void; - -pub const AV_BUFFER_FLAG_READONLY: c_int = 1; - -extern { - pub fn av_buffer_alloc(size: c_int) -> *mut AVBufferRef; - pub fn av_buffer_allocz(size: c_int) -> *mut AVBufferRef; - pub fn av_buffer_create(data: *mut uint8_t, size: c_int, free: extern fn(*mut c_void, *mut uint8_t), opaque: *mut c_void, flags: c_int) -> *mut AVBufferRef; - pub fn av_buffer_default_free(opaque: *mut c_void, data: *mut uint8_t); - pub fn av_buffer_ref(buf: *mut AVBufferRef) -> *mut AVBufferRef; - pub fn av_buffer_unref(buf: *mut *mut AVBufferRef); - pub fn av_buffer_is_writable(buf: *const AVBufferRef) -> c_int; - pub fn av_buffer_get_opaque(buf: *const AVBufferRef) -> *mut c_void; - pub fn av_buffer_get_ref_count(buf: *const AVBufferRef) -> c_int; - pub fn av_buffer_make_writable(buf: *mut *mut AVBufferRef) -> c_int; - pub fn av_buffer_realloc(buf: *mut *mut AVBufferRef, size: c_int) -> c_int; - - pub fn av_buffer_pool_init(size: c_int, alloc: extern fn(c_int) -> *mut AVBufferRef) -> *mut AVBufferPool; - pub fn av_buffer_pool_uninit(pool: *mut *mut AVBufferPool); - pub fn av_buffer_pool_get(pool: *mut AVBufferPool) -> *mut AVBufferRef; -} diff --git a/sys/src/avutil/camellia.rs b/sys/src/avutil/camellia.rs deleted file mode 100644 index 0dc9d6e..0000000 --- a/sys/src/avutil/camellia.rs +++ /dev/null @@ -1,11 +0,0 @@ -use libc::{c_void, c_int, uint8_t}; - -pub type AVCAMELLIA = c_void; - -extern { - pub static av_camellia_size: c_int; - - pub fn av_camellia_alloc() -> *mut AVCAMELLIA; - pub fn av_camellia_init(ctx: *mut AVCAMELLIA, key: *const uint8_t, key_bits: c_int) -> c_int; - pub fn av_camellia_crypt(ctx: *mut AVCAMELLIA, dst: *mut uint8_t, src: *const uint8_t, count: c_int, iv: *mut uint8_t, decrypt: c_int); -} diff --git a/sys/src/avutil/cast5.rs b/sys/src/avutil/cast5.rs deleted file mode 100644 index 8f19217..0000000 --- a/sys/src/avutil/cast5.rs +++ /dev/null @@ -1,12 +0,0 @@ -use libc::{c_void, c_int, uint8_t}; - -pub type AVCAST5 = c_void; - -extern { - pub static av_cast5_size: c_int; - - pub fn av_cast5_alloc() -> *mut AVCAST5; - pub fn av_cast5_init(ctx: *mut AVCAST5, key: *const uint8_t, key_bits: c_int) -> c_int; - pub fn av_cast5_crypt(ctx: *mut AVCAST5, dst: *mut uint8_t, src: *const uint8_t, count: c_int, decrypt: c_int); - pub fn av_cast5_crypt2(ctx: *mut AVCAST5, dst: *mut uint8_t, src: *const uint8_t, count: c_int, iv: *mut uint8_t, decrypt: c_int); -} diff --git a/sys/src/avutil/channel_layout.rs b/sys/src/avutil/channel_layout.rs index b95de0a..0f3d7a3 100644 --- a/sys/src/avutil/channel_layout.rs +++ b/sys/src/avutil/channel_layout.rs @@ -1,85 +1,3 @@ -use libc::{c_char, c_int, c_uint, c_ulonglong, uint64_t, int64_t}; -use super::bprint::AVBPrint; - -pub const AV_CH_FRONT_LEFT: c_ulonglong = 0x00000001; -pub const AV_CH_FRONT_RIGHT: c_ulonglong = 0x00000002; -pub const AV_CH_FRONT_CENTER: c_ulonglong = 0x00000004; -pub const AV_CH_LOW_FREQUENCY: c_ulonglong = 0x00000008; -pub const AV_CH_BACK_LEFT: c_ulonglong = 0x00000010; -pub const AV_CH_BACK_RIGHT: c_ulonglong = 0x00000020; -pub const AV_CH_FRONT_LEFT_OF_CENTER: c_ulonglong = 0x00000040; -pub const AV_CH_FRONT_RIGHT_OF_CENTER: c_ulonglong = 0x00000080; -pub const AV_CH_BACK_CENTER: c_ulonglong = 0x00000100; -pub const AV_CH_SIDE_LEFT: c_ulonglong = 0x00000200; -pub const AV_CH_SIDE_RIGHT: c_ulonglong = 0x00000400; -pub const AV_CH_TOP_CENTER: c_ulonglong = 0x00000800; -pub const AV_CH_TOP_FRONT_LEFT: c_ulonglong = 0x00001000; -pub const AV_CH_TOP_FRONT_CENTER: c_ulonglong = 0x00002000; -pub const AV_CH_TOP_FRONT_RIGHT: c_ulonglong = 0x00004000; -pub const AV_CH_TOP_BACK_LEFT: c_ulonglong = 0x00008000; -pub const AV_CH_TOP_BACK_CENTER: c_ulonglong = 0x00010000; -pub const AV_CH_TOP_BACK_RIGHT: c_ulonglong = 0x00020000; -pub const AV_CH_STEREO_LEFT: c_ulonglong = 0x20000000; -pub const AV_CH_STEREO_RIGHT: c_ulonglong = 0x40000000; -pub const AV_CH_WIDE_LEFT: c_ulonglong = 0x0000000080000000; -pub const AV_CH_WIDE_RIGHT: c_ulonglong = 0x0000000100000000; -pub const AV_CH_SURROUND_DIRECT_LEFT: c_ulonglong = 0x0000000200000000; -pub const AV_CH_SURROUND_DIRECT_RIGHT: c_ulonglong = 0x0000000400000000; -pub const AV_CH_LOW_FREQUENCY_2: c_ulonglong = 0x0000000800000000; +use libc::c_ulonglong; pub const AV_CH_LAYOUT_NATIVE: c_ulonglong = 0x8000000000000000; - -pub const AV_CH_LAYOUT_MONO: c_ulonglong = AV_CH_FRONT_CENTER; -pub const AV_CH_LAYOUT_STEREO: c_ulonglong = AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT; -pub const AV_CH_LAYOUT_2POINT1: c_ulonglong = AV_CH_LAYOUT_STEREO | AV_CH_LOW_FREQUENCY; -pub const AV_CH_LAYOUT_2_1: c_ulonglong = AV_CH_LAYOUT_STEREO | AV_CH_BACK_CENTER; -pub const AV_CH_LAYOUT_SURROUND: c_ulonglong = AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER; -pub const AV_CH_LAYOUT_3POINT1: c_ulonglong = AV_CH_LAYOUT_SURROUND | AV_CH_LOW_FREQUENCY; -pub const AV_CH_LAYOUT_4POINT0: c_ulonglong = AV_CH_LAYOUT_SURROUND | AV_CH_BACK_CENTER; -pub const AV_CH_LAYOUT_4POINT1: c_ulonglong = AV_CH_LAYOUT_4POINT0 | AV_CH_LOW_FREQUENCY; -pub const AV_CH_LAYOUT_2_2: c_ulonglong = AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT; -pub const AV_CH_LAYOUT_QUAD: c_ulonglong = AV_CH_LAYOUT_STEREO | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT; -pub const AV_CH_LAYOUT_5POINT0: c_ulonglong = AV_CH_LAYOUT_SURROUND | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT; -pub const AV_CH_LAYOUT_5POINT1: c_ulonglong = AV_CH_LAYOUT_5POINT0 | AV_CH_LOW_FREQUENCY; -pub const AV_CH_LAYOUT_5POINT0_BACK: c_ulonglong = AV_CH_LAYOUT_SURROUND | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT; -pub const AV_CH_LAYOUT_5POINT1_BACK: c_ulonglong = AV_CH_LAYOUT_5POINT0_BACK | AV_CH_LOW_FREQUENCY; -pub const AV_CH_LAYOUT_6POINT0: c_ulonglong = AV_CH_LAYOUT_5POINT0 | AV_CH_BACK_CENTER; -pub const AV_CH_LAYOUT_6POINT0_FRONT: c_ulonglong = AV_CH_LAYOUT_2_2 | AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER; -pub const AV_CH_LAYOUT_HEXAGONAL: c_ulonglong = AV_CH_LAYOUT_5POINT0_BACK | AV_CH_BACK_CENTER; -pub const AV_CH_LAYOUT_6POINT1: c_ulonglong = AV_CH_LAYOUT_5POINT1 | AV_CH_BACK_CENTER; -pub const AV_CH_LAYOUT_6POINT1_BACK: c_ulonglong = AV_CH_LAYOUT_5POINT1_BACK | AV_CH_BACK_CENTER; -pub const AV_CH_LAYOUT_6POINT1_FRONT: c_ulonglong = AV_CH_LAYOUT_6POINT0_FRONT | AV_CH_LOW_FREQUENCY; -pub const AV_CH_LAYOUT_7POINT0: c_ulonglong = AV_CH_LAYOUT_5POINT0 | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT; -pub const AV_CH_LAYOUT_7POINT0_FRONT: c_ulonglong = AV_CH_LAYOUT_5POINT0 | AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER; -pub const AV_CH_LAYOUT_7POINT1: c_ulonglong = AV_CH_LAYOUT_5POINT1 | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT; -pub const AV_CH_LAYOUT_7POINT1_WIDE: c_ulonglong = AV_CH_LAYOUT_5POINT1 | AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER; -pub const AV_CH_LAYOUT_7POINT1_WIDE_BACK: c_ulonglong = AV_CH_LAYOUT_5POINT1_BACK | AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER; -pub const AV_CH_LAYOUT_OCTAGONAL: c_ulonglong = AV_CH_LAYOUT_5POINT0 | AV_CH_BACK_LEFT | AV_CH_BACK_CENTER | AV_CH_BACK_RIGHT; -pub const AV_CH_LAYOUT_HEXADECAGONAL: c_ulonglong = AV_CH_LAYOUT_OCTAGONAL | AV_CH_WIDE_LEFT | AV_CH_WIDE_RIGHT | AV_CH_TOP_BACK_LEFT | AV_CH_TOP_BACK_RIGHT | AV_CH_TOP_BACK_CENTER | AV_CH_TOP_FRONT_CENTER | AV_CH_TOP_FRONT_LEFT | AV_CH_TOP_FRONT_RIGHT; -pub const AV_CH_LAYOUT_STEREO_DOWNMIX: c_ulonglong = AV_CH_STEREO_LEFT | AV_CH_STEREO_RIGHT; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVMatrixEncoding { - AV_MATRIX_ENCODING_NONE, - AV_MATRIX_ENCODING_DOLBY, - AV_MATRIX_ENCODING_DPLII, - AV_MATRIX_ENCODING_DPLIIX, - AV_MATRIX_ENCODING_DPLIIZ, - AV_MATRIX_ENCODING_DOLBYEX, - AV_MATRIX_ENCODING_DOLBYHEADPHONE, - AV_MATRIX_ENCODING_NB -} - -extern { - pub fn av_get_channel_layout(name: *const c_char) -> uint64_t; - pub fn av_get_channel_layout_string(buf: *mut c_char, buf_size: c_int, nb_channels: c_int, channel_layout: uint64_t); - pub fn av_bprint_channel_layout(bp: *mut AVBPrint, nb_channels: c_int, channel_layout: uint64_t); - pub fn av_get_channel_layout_nb_channels(channel_layout: uint64_t) -> c_int; - pub fn av_get_default_channel_layout(nb_channels: c_int) -> int64_t; - pub fn av_get_channel_layout_channel_index(channel_layout: uint64_t, channel: uint64_t) -> c_int; - pub fn av_channel_layout_extract_channel(channel_layout: uint64_t, index: c_int) -> uint64_t; - pub fn av_get_channel_name(channel: uint64_t) -> *const c_char; - pub fn av_get_channel_description(channel: uint64_t) -> *const c_char; - pub fn av_get_standard_channel_layout(index: c_uint, layout: *mut uint64_t, name: *const *const c_char) -> c_int; -} diff --git a/sys/src/avutil/cpu.rs b/sys/src/avutil/cpu.rs deleted file mode 100644 index 3d9b192..0000000 --- a/sys/src/avutil/cpu.rs +++ /dev/null @@ -1,44 +0,0 @@ -use libc::{c_char, c_int, c_uint}; - -pub const AV_CPU_FLAG_FORCE: c_uint = 0x80000000; -pub const AV_CPU_FLAG_MMX: c_uint = 0x0001; -pub const AV_CPU_FLAG_MMXEXT: c_uint = 0x0002; -pub const AV_CPU_FLAG_MMX2: c_uint = 0x0002; -pub const AV_CPU_FLAG_3DNOW: c_uint = 0x0004; -pub const AV_CPU_FLAG_SSE: c_uint = 0x0008; -pub const AV_CPU_FLAG_SSE2: c_uint = 0x0010; -pub const AV_CPU_FLAG_SSE2SLOW: c_uint = 0x40000000; -pub const AV_CPU_FLAG_3DNOWEXT: c_uint = 0x0020; -pub const AV_CPU_FLAG_SSE3: c_uint = 0x0040; -pub const AV_CPU_FLAG_SSE3SLOW: c_uint = 0x20000000; -pub const AV_CPU_FLAG_SSSE3: c_uint = 0x0080; -pub const AV_CPU_FLAG_ATOM: c_uint = 0x10000000; -pub const AV_CPU_FLAG_SSE4: c_uint = 0x0100; -pub const AV_CPU_FLAG_SSE42: c_uint = 0x0200; -pub const AV_CPU_FLAG_AVX: c_uint = 0x4000; -pub const AV_CPU_FLAG_AVXSLOW: c_uint = 0x8000000; -pub const AV_CPU_FLAG_XOP: c_uint = 0x0400; -pub const AV_CPU_FLAG_FMA4: c_uint = 0x0800; -pub const AV_CPU_FLAG_CMOV: c_uint = 0x1001000; -pub const AV_CPU_FLAG_AVX2: c_uint = 0x8000; -pub const AV_CPU_FLAG_FMA3: c_uint = 0x10000; -pub const AV_CPU_FLAG_BMI1: c_uint = 0x20000; -pub const AV_CPU_FLAG_BMI2: c_uint = 0x40000; -pub const AV_CPU_FLAG_ALTIVEC: c_uint = 0x0001; -pub const AV_CPU_FLAG_VSX: c_uint = 0x0002; -pub const AV_CPU_FLAG_POWER8: c_uint = 0x0004; -pub const AV_CPU_FLAG_ARMV5TE: c_uint = 1 << 0; -pub const AV_CPU_FLAG_ARMV6: c_uint = 1 << 1; -pub const AV_CPU_FLAG_ARMV6T2: c_uint = 1 << 2; -pub const AV_CPU_FLAG_VFP: c_uint = 1 << 3; -pub const AV_CPU_FLAG_VFPV3: c_uint = 1 << 4; -pub const AV_CPU_FLAG_NEON: c_uint = 1 << 5; -pub const AV_CPU_FLAG_ARMV8: c_uint = 1 << 6; -pub const AV_CPU_FLAG_SETEND: c_uint = 1 << 16; - -extern { - pub fn av_get_cpu_flags() -> c_int; - pub fn av_force_cpu_flags(flags: c_int); - pub fn av_parse_cpu_caps(flags: *mut c_uint, s: *const c_char) -> c_int; - pub fn av_cpu_count() -> c_int; -} diff --git a/sys/src/avutil/crc.rs b/sys/src/avutil/crc.rs deleted file mode 100644 index e63a86d..0000000 --- a/sys/src/avutil/crc.rs +++ /dev/null @@ -1,22 +0,0 @@ -use libc::{c_int, uint8_t, uint32_t, size_t}; - -pub type AVCRC = uint32_t; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVCRCId { - AV_CRC_8_ATM, - AV_CRC_16_ANSI, - AV_CRC_16_CCITT, - AV_CRC_32_IEEE, - AV_CRC_32_IEEE_LE, - AV_CRC_16_ANSI_LE, - AV_CRC_24_IEEE = 12, - AV_CRC_MAX, -} - -extern { - pub fn av_crc_init(ctx: *mut AVCRC, le: c_int, bits: c_int, poly: uint32_t, ctx_size: c_int) -> c_int; - pub fn av_crc_get_table(crc_id: AVCRCId) -> *const AVCRC; - pub fn av_crc(ctx: *const AVCRC, crc: uint32_t, buffer: *const uint8_t, length: size_t) -> uint32_t; -} diff --git a/sys/src/avutil/dict.rs b/sys/src/avutil/dict.rs deleted file mode 100644 index 0235dcc..0000000 --- a/sys/src/avutil/dict.rs +++ /dev/null @@ -1,27 +0,0 @@ -use libc::{c_void, c_int, c_char, int64_t}; - -pub const AV_DICT_MATCH_CASE: c_int = 1; -pub const AV_DICT_IGNORE_SUFFIX: c_int = 2; -pub const AV_DICT_DONT_STRDUP_KEY: c_int = 4; -pub const AV_DICT_DONT_STRDUP_VAL: c_int = 8; -pub const AV_DICT_DONT_OVERWRITE: c_int = 16; -pub const AV_DICT_APPEND: c_int = 32; - -#[repr(C)] -pub struct AVDictionaryEntry { - pub key: *mut c_char, - pub value: *mut c_char, -} - -pub type AVDictionary = c_void; - -extern { - pub fn av_dict_get(m: *const AVDictionary, key: *const c_char, prev: *const AVDictionaryEntry, flags: c_int) -> *mut AVDictionaryEntry; - pub fn av_dict_count(m: *const AVDictionary) -> c_int; - pub fn av_dict_set(pm: *mut *mut AVDictionary, key: *const c_char, value: *const c_char, flags: c_int) -> c_int; - pub fn av_dict_set_int(pm: *mut *mut AVDictionary, key: *const c_char, value: int64_t, flags: c_int) -> c_int; - pub fn av_dict_parse_string(pm: *mut *mut AVDictionary, string: *const c_char, key_val_sep: *const c_char, pairs_sep: *const c_char, flags: c_int) -> c_int; - pub fn av_dict_copy(dst: *mut *mut AVDictionary, src: *const AVDictionary, flags: c_int); - pub fn av_dict_free(m: *mut *mut AVDictionary); - pub fn av_dict_get_string(m: *const AVDictionary, buffer: *mut *mut c_char, key_val_sep: c_char, pairs_sep: c_char) -> c_int; -} diff --git a/sys/src/avutil/display.rs b/sys/src/avutil/display.rs deleted file mode 100644 index 6cbec40..0000000 --- a/sys/src/avutil/display.rs +++ /dev/null @@ -1,7 +0,0 @@ -use libc::{c_int, int32_t, c_double}; - -extern { - pub fn av_display_rotation_get(matrix: *const int32_t) -> c_double; - pub fn av_display_rotation_set(matrix: *mut int32_t, angle: c_double); - pub fn av_display_matrix_flip(matrix: *mut int32_t, hflip: c_int, vflip: c_int); -} diff --git a/sys/src/avutil/downmix_info.rs b/sys/src/avutil/downmix_info.rs deleted file mode 100644 index 9504689..0000000 --- a/sys/src/avutil/downmix_info.rs +++ /dev/null @@ -1,30 +0,0 @@ -use libc::{c_double}; -use super::frame::AVFrame; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVDownmixType { - AV_DOWNMIX_TYPE_UNKNOWN, - AV_DOWNMIX_TYPE_LORO, - AV_DOWNMIX_TYPE_LTRT, - AV_DOWNMIX_TYPE_DPLII, - AV_DOWNMIX_TYPE_NB, -} - -#[derive(Debug)] -#[repr(C)] -pub struct AVDownmixInfo { - pub preferred_downmix_type: AVDownmixType, - - pub center_mix_level: c_double, - pub center_mix_level_ltrt: c_double, - - pub surround_mix_level: c_double, - pub surround_mix_level_ltrt: c_double, - - pub lfe_mix_level: c_double, -} - -extern { - pub fn av_downmix_info_update_side_data(frame: *mut AVFrame) -> *mut AVDownmixInfo; -} diff --git a/sys/src/avutil/error.rs b/sys/src/avutil/error.rs index 922bb09..352d11a 100644 --- a/sys/src/avutil/error.rs +++ b/sys/src/avutil/error.rs @@ -2,12 +2,12 @@ use libc::{c_char, c_int, size_t}; #[inline(always)] pub fn AVERROR(e: c_int) -> c_int { - -e + -e } #[inline(always)] pub fn AVUNERROR(e: c_int) -> c_int { - -e + -e } macro_rules! FFERRTAG { @@ -15,46 +15,45 @@ macro_rules! FFERRTAG { (-MKTAG!($a, $b, $c, $d) as c_int) } -pub const AVERROR_BSF_NOT_FOUND: c_int = FFERRTAG!(0xF8, b'B', b'S', b'F'); -pub const AVERROR_BUG: c_int = FFERRTAG!(b'B', b'U', b'G', b'!'); -pub const AVERROR_BUFFER_TOO_SMALL: c_int = FFERRTAG!(b'B', b'U', b'F', b'S'); -pub const AVERROR_DECODER_NOT_FOUND: c_int = FFERRTAG!(0xF8, b'D', b'E', b'C'); -pub const AVERROR_DEMUXER_NOT_FOUND: c_int = FFERRTAG!(0xF8, b'D', b'E', b'M'); -pub const AVERROR_ENCODER_NOT_FOUND: c_int = FFERRTAG!(0xF8, b'E', b'N', b'C'); -pub const AVERROR_EOF: c_int = FFERRTAG!(b'E', b'O', b'F', b' '); -pub const AVERROR_EXIT: c_int = FFERRTAG!(b'E', b'X', b'I', b'T'); -pub const AVERROR_EXTERNAL: c_int = FFERRTAG!(b'E', b'X', b'T', b' '); -pub const AVERROR_FILTER_NOT_FOUND: c_int = FFERRTAG!(0xF8, b'F', b'I', b'L'); -pub const AVERROR_INVALIDDATA: c_int = FFERRTAG!(b'I', b'N', b'D', b'A'); -pub const AVERROR_MUXER_NOT_FOUND: c_int = FFERRTAG!(0xF8, b'M', b'U', b'X'); -pub const AVERROR_OPTION_NOT_FOUND: c_int = FFERRTAG!(0xF8, b'O', b'P', b'T'); -pub const AVERROR_PATCHWELCOME: c_int = FFERRTAG!(b'P', b'A', b'W', b'E'); +pub const AVERROR_BSF_NOT_FOUND: c_int = FFERRTAG!(0xF8, b'B', b'S', b'F'); +pub const AVERROR_BUG: c_int = FFERRTAG!(b'B', b'U', b'G', b'!'); +pub const AVERROR_BUFFER_TOO_SMALL: c_int = FFERRTAG!(b'B', b'U', b'F', b'S'); +pub const AVERROR_DECODER_NOT_FOUND: c_int = FFERRTAG!(0xF8, b'D', b'E', b'C'); +pub const AVERROR_DEMUXER_NOT_FOUND: c_int = FFERRTAG!(0xF8, b'D', b'E', b'M'); +pub const AVERROR_ENCODER_NOT_FOUND: c_int = FFERRTAG!(0xF8, b'E', b'N', b'C'); +pub const AVERROR_EOF: c_int = FFERRTAG!(b'E', b'O', b'F', b' '); +pub const AVERROR_EXIT: c_int = FFERRTAG!(b'E', b'X', b'I', b'T'); +pub const AVERROR_EXTERNAL: c_int = FFERRTAG!(b'E', b'X', b'T', b' '); +pub const AVERROR_FILTER_NOT_FOUND: c_int = FFERRTAG!(0xF8, b'F', b'I', b'L'); +pub const AVERROR_INVALIDDATA: c_int = FFERRTAG!(b'I', b'N', b'D', b'A'); +pub const AVERROR_MUXER_NOT_FOUND: c_int = FFERRTAG!(0xF8, b'M', b'U', b'X'); +pub const AVERROR_OPTION_NOT_FOUND: c_int = FFERRTAG!(0xF8, b'O', b'P', b'T'); +pub const AVERROR_PATCHWELCOME: c_int = FFERRTAG!(b'P', b'A', b'W', b'E'); pub const AVERROR_PROTOCOL_NOT_FOUND: c_int = FFERRTAG!(0xF8, b'P', b'R', b'O'); pub const AVERROR_STREAM_NOT_FOUND: c_int = FFERRTAG!(0xF8, b'S', b'T', b'R'); -pub const AVERROR_BUG2: c_int = FFERRTAG!(b'B', b'U', b'G', b' '); -pub const AVERROR_UNKNOWN: c_int = FFERRTAG!(b'U', b'N', b'K', b'N'); -pub const AVERROR_EXPERIMENTAL: c_int = -0x2bb2afa8; -pub const AVERROR_INPUT_CHANGED: c_int = -0x636e6701; -pub const AVERROR_OUTPUT_CHANGED: c_int = -0x636e6702; +pub const AVERROR_BUG2: c_int = FFERRTAG!(b'B', b'U', b'G', b' '); +pub const AVERROR_UNKNOWN: c_int = FFERRTAG!(b'U', b'N', b'K', b'N'); -pub const AVERROR_HTTP_BAD_REQUEST: c_int = FFERRTAG!(0xF8, b'4', b'0', b'0'); +pub const AVERROR_HTTP_BAD_REQUEST: c_int = FFERRTAG!(0xF8, b'4', b'0', b'0'); pub const AVERROR_HTTP_UNAUTHORIZED: c_int = FFERRTAG!(0xF8, b'4', b'0', b'1'); -pub const AVERROR_HTTP_FORBIDDEN: c_int = FFERRTAG!(0xF8, b'4', b'0', b'3'); -pub const AVERROR_HTTP_NOT_FOUND: c_int = FFERRTAG!(0xF8, b'4', b'0', b'4'); -pub const AVERROR_HTTP_OTHER_4XX: c_int = FFERRTAG!(0xF8, b'4', b'X', b'X'); +pub const AVERROR_HTTP_FORBIDDEN: c_int = FFERRTAG!(0xF8, b'4', b'0', b'3'); +pub const AVERROR_HTTP_NOT_FOUND: c_int = FFERRTAG!(0xF8, b'4', b'0', b'4'); +pub const AVERROR_HTTP_OTHER_4XX: c_int = FFERRTAG!(0xF8, b'4', b'X', b'X'); pub const AVERROR_HTTP_SERVER_ERROR: c_int = FFERRTAG!(0xF8, b'5', b'X', b'X'); -pub const AV_ERROR_MAX_STRING_SIZE: size_t = 64; - #[inline(always)] -pub unsafe fn av_make_error_string(errbuf: *mut c_char, errbuf_size: size_t, errnum: c_int) -> *mut c_char { - av_strerror(errnum, errbuf, errbuf_size); +pub unsafe fn av_make_error_string( + errbuf: *mut c_char, + errbuf_size: size_t, + errnum: c_int, +) -> *mut c_char { + av_strerror(errnum, errbuf, errbuf_size); - errbuf + errbuf } -extern { - pub fn av_strerror(errnum: c_int, errbuf: *mut c_char, errbuf_size: size_t) -> c_int; +extern "C" { + pub fn av_strerror(errnum: c_int, errbuf: *mut c_char, errbuf_size: size_t) -> c_int; } diff --git a/sys/src/avutil/eval.rs b/sys/src/avutil/eval.rs deleted file mode 100644 index 14f21f8..0000000 --- a/sys/src/avutil/eval.rs +++ /dev/null @@ -1,23 +0,0 @@ -use libc::{c_void, c_char, c_int, c_double}; - -pub type AVExpr = c_void; - -extern { - pub fn av_expr_parse_and_eval(res: *mut c_double, s: *const c_char, - const_names: *const *const c_char, const_values: *const c_double, - func1_names: *const *const c_char, funcs1: *const extern fn(*mut c_void, c_double) -> c_double, - func2_names: *const *const c_char, funcs2: *const extern fn(*mut c_void, c_double, c_double) -> c_double, - opaque: *mut c_void, log_offset: c_int, log_ctx: *mut c_void) -> c_int; - - pub fn av_expr_parse(expr: *mut *mut AVExpr, s: *const c_char, - const_names: *const *const c_char, const_values: *const c_double, - func1_names: *const *const c_char, funcs1: *const extern fn(*mut c_void, c_double) -> c_double, - func2_names: *const *const c_char, funcs2: *const extern fn(*mut c_void, c_double, c_double) -> c_double, - log_offset: c_int, log_ctx: *mut c_void) -> c_int; - - pub fn av_expr_eval(e: *mut AVExpr, const_values: *const c_double, opaque: *mut c_void) -> c_double; - - pub fn av_expr_free(e: *mut AVExpr); - - pub fn av_strtod(numstr: *const c_char, tail: *mut *mut c_char) -> c_double; -} diff --git a/sys/src/avutil/fifo.rs b/sys/src/avutil/fifo.rs deleted file mode 100644 index 50a6079..0000000 --- a/sys/src/avutil/fifo.rs +++ /dev/null @@ -1,45 +0,0 @@ -use libc::{c_void, c_int, c_uint, uint8_t, uint32_t, size_t}; - -#[derive(Debug)] -#[repr(C)] -pub struct AVFifoBuffer { - pub buffer: *mut uint8_t, - - pub rptr: *mut uint8_t, - pub wptr: *mut uint8_t, - pub end: *mut uint8_t, - - pub rndx: uint32_t, - pub wndx: uint32_t, -} - -#[inline(always)] -pub unsafe fn av_fifo_peek2(f: *const AVFifoBuffer, offs: c_int) -> *mut uint8_t { - let ptr = (*f).rptr.offset(offs as isize); - - if ptr > (*f).end { - (*f).buffer.offset((ptr as usize - (*f).end as usize) as isize) - } - else if ptr < (*f).buffer { - (*f).end.offset(-(((*f).buffer as usize - ptr as usize) as isize)) - } - else { - ptr - } -} - -extern { - pub fn av_fifo_alloc(size: c_uint) -> *mut AVFifoBuffer; - pub fn av_fifo_alloc_array(nmemb: size_t, size: size_t) -> *mut AVFifoBuffer; - pub fn av_fifo_free(f: *mut AVFifoBuffer); - pub fn av_fifo_freep(f: *mut *mut AVFifoBuffer); - pub fn av_fifo_reset(f: *mut AVFifoBuffer); - pub fn av_fifo_size(f: *const AVFifoBuffer) -> c_int; - pub fn av_fifo_space(f: *const AVFifoBuffer) -> c_int; - pub fn av_fifo_generic_peek(f: *mut AVFifoBuffer, dest: *mut c_void, buf_size: c_int, func: extern fn(*mut c_void, *mut c_void, c_int)) -> c_int; - pub fn av_fifo_generic_read(f: *mut AVFifoBuffer, dest: *mut c_void, buf_size: c_int, func: extern fn(*mut c_void, *mut c_void, c_int)) -> c_int; - pub fn av_fifo_generic_write(f: *mut AVFifoBuffer, src: *mut c_void, size: c_int, func: extern fn(*mut c_void, *mut c_void, c_int) -> c_int) -> c_int; - pub fn av_fifo_realloc2(f: *mut AVFifoBuffer, size: c_uint) -> c_int; - pub fn av_fifo_grow(f: *mut AVFifoBuffer, additional_space: c_int) -> c_int; - pub fn av_fifo_drain(f: *mut AVFifoBuffer, size: c_int); -} diff --git a/sys/src/avutil/file.rs b/sys/src/avutil/file.rs deleted file mode 100644 index c9b9636..0000000 --- a/sys/src/avutil/file.rs +++ /dev/null @@ -1,7 +0,0 @@ -use libc::{c_void, c_char, c_int, uint8_t, size_t}; - -extern { - pub fn av_file_map(filename: *const c_char, bufptr: *mut *mut uint8_t, size: *mut size_t, log_offset: c_int, log_ctx: *mut c_void) -> c_int; - pub fn av_file_unmap(bufptr: *mut uint8_t, size: size_t); - pub fn av_tempfile(prefix: *const c_char, filename: *mut *mut c_char, log_offset: c_int, log_ctx: *mut c_void) -> c_int; -} diff --git a/sys/src/avutil/frame.rs b/sys/src/avutil/frame.rs deleted file mode 100644 index 7960ce9..0000000 --- a/sys/src/avutil/frame.rs +++ /dev/null @@ -1,197 +0,0 @@ -use libc::{c_void, c_char, c_int, int8_t, uint8_t}; -use libc::{int64_t, uint64_t}; -use super::dict::AVDictionary; -use super::rational::AVRational; -use super::buffer::AVBufferRef; -use super::pixfmt::{AVColorPrimaries, AVColorRange, AVColorSpace, AVColorTransferCharacteristic, AVChromaLocation}; -use super::util::AVPictureType; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVFrameSideDataType { - AV_FRAME_DATA_PANSCAN, - AV_FRAME_DATA_A53_CC, - AV_FRAME_DATA_STEREO3D, - AV_FRAME_DATA_MATRIXENCODING, - AV_FRAME_DATA_DOWNMIX_INFO, - AV_FRAME_DATA_REPLAYGAIN, - AV_FRAME_DATA_DISPLAYMATRIX, - AV_FRAME_DATA_AFD, - AV_FRAME_DATA_MOTION_VECTORS, - AV_FRAME_DATA_SKIP_SAMPLES, - AV_FRAME_DATA_AUDIO_SERVICE_TYPE, - AV_FRAME_DATA_MASTERING_DISPLAY_METADATA, - AV_FRAME_DATA_GOP_TIMECODE, -} - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVActiveFormatDescription { - AV_AFD_SAME = 8, - AV_AFD_4_3 = 9, - AV_AFD_16_9 = 10, - AV_AFD_14_9 = 11, - AV_AFD_4_3_SP_14_9 = 13, - AV_AFD_16_9_SP_14_9 = 14, - AV_AFD_SP_4_3 = 15, -} - -#[derive(Debug)] -#[repr(C)] -pub struct AVFrameSideData { - pub kind: AVFrameSideDataType, - pub data: *mut uint8_t, - pub size: c_int, - pub metadata: *mut AVDictionary, - pub buf: *mut AVBufferRef, -} - -pub const AV_NUM_DATA_POINTERS: usize = 8; - -pub const AV_FRAME_FLAG_CORRUPT: c_int = 1 << 0; -pub const AV_FRAME_FLAG_DISCARD: c_int = 1 << 2; - -pub const FF_DECODE_ERROR_INVALID_BITSTREAM: c_int = 1; -pub const FF_DECODE_ERROR_MISSING_REFERENCE: c_int = 2; - -#[derive(Debug)] -#[repr(C)] -pub struct AVFrame { - pub data: [*mut uint8_t; AV_NUM_DATA_POINTERS], - pub linesize: [c_int; AV_NUM_DATA_POINTERS], - pub extended_data: *mut *mut uint8_t, - - pub width: c_int, - pub height: c_int, - pub nb_samples: c_int, - - pub format: c_int, - pub key_frame: c_int, - pub pict_type: AVPictureType, - - pub sample_aspect_ratio: AVRational, - pub pts: int64_t, - #[cfg(feature = "ff_api_pkt_pts")] - pub pkt_pts: int64_t, - pub pkt_dts: int64_t, - - pub coded_picture_number: c_int, - pub display_picture_number: c_int, - - pub quality: c_int, - - pub opaque: *mut c_void, - #[cfg(feature = "ff_api_error_frame")] - pub error: [uint64_t; AV_NUM_DATA_POINTERS], - - pub repeat_pict: c_int, - pub interlaced_frame: c_int, - pub top_field_first: c_int, - - pub palette_has_changed: c_int, - - pub reordered_opaque: int64_t, - - pub sample_rate: c_int, - pub channel_layout: uint64_t, - - pub buf: [*mut AVBufferRef; AV_NUM_DATA_POINTERS], - pub extended_buf: *mut *mut AVBufferRef, - pub nb_extended_buf: c_int, - - pub side_data: *mut *mut AVFrameSideData, - pub nb_side_data: c_int, - - pub flags: c_int, - - pub color_range: AVColorRange, - pub color_primaries: AVColorPrimaries, - pub color_trc: AVColorTransferCharacteristic, - pub colorspace: AVColorSpace, - pub chroma_location: AVChromaLocation, - - pub best_effort_timestamp: int64_t, - pub pkt_pos: int64_t, - pub pkt_duration: int64_t, - - pub metadata: *mut AVDictionary, - pub decode_error_flags: c_int, - - pub channels: c_int, - pub pkt_size: c_int, - - #[cfg(feature = "ff_api_frame_qp")] - pub qscale_table: *mut int8_t, - #[cfg(feature = "ff_api_frame_qp")] - pub qstride: c_int, - #[cfg(feature = "ff_api_frame_qp")] - pub qscale_type: c_int, - #[cfg(feature = "ff_api_frame_qp")] - pub qp_table_buf: *mut AVBufferRef, - - pub hw_frames_ctx: *mut AVBufferRef, -} - -extern { - pub fn av_frame_get_best_effort_timestamp(frame: *const AVFrame) -> int64_t; - pub fn av_frame_set_best_effort_timestamp(frame: *mut AVFrame, val: int64_t); - - pub fn av_frame_get_pkt_duration(frame: *const AVFrame) -> int64_t; - pub fn av_frame_set_pkt_duration(frame: *mut AVFrame, val: int64_t); - - pub fn av_frame_get_pkt_pos(frame: *const AVFrame) -> int64_t; - pub fn av_frame_set_pkt_pos(frame: *mut AVFrame, val: int64_t); - - pub fn av_frame_get_channel_layout(frame: *const AVFrame) -> int64_t; - pub fn av_frame_set_channel_layout(frame: *mut AVFrame, val: int64_t); - - pub fn av_frame_get_channels(frame: *const AVFrame) -> c_int; - pub fn av_frame_set_channels(frame: *mut AVFrame, val: c_int); - - pub fn av_frame_get_sample_rate(frame: *const AVFrame) -> c_int; - pub fn av_frame_set_sample_rate(frame: *mut AVFrame, val: c_int); - - pub fn av_frame_get_metadata(frame: *const AVFrame) -> *mut AVDictionary; - pub fn av_frame_set_metadata(frame: *mut AVFrame, val: *mut AVDictionary); - - pub fn av_frame_get_decode_error_flags(frame: *const AVFrame) -> c_int; - pub fn av_frame_set_decode_error_flags(frame: *mut AVFrame, val: c_int); - - pub fn av_frame_get_pkt_size(frame: *const AVFrame) -> c_int; - pub fn av_frame_set_pkt_size(frame: *mut AVFrame, val: c_int); - - pub fn av_frame_get_metadatap(frame: *mut AVFrame) -> *mut *mut AVDictionary; - - pub fn av_frame_get_qp_table(f: *mut AVFrame, stride: *mut c_int, kind: *mut c_int); - pub fn av_frame_set_qp_table(f: *mut AVFrame, buf: *mut AVBufferRef, stride: c_int, kind: c_int) -> c_int; - - pub fn av_frame_get_colorspace(frame: *const AVFrame) -> AVColorSpace; - pub fn av_frame_set_colorspace(frame: *mut AVFrame, val: AVColorSpace); - - pub fn av_frame_get_color_range(frame: *const AVFrame) -> AVColorRange; - pub fn av_frame_set_color_range(frame: *mut AVFrame, val: AVColorRange); - - pub fn av_get_colorspace_name(val: AVColorSpace) -> *const c_char; - - pub fn av_frame_alloc() -> *mut AVFrame; - pub fn av_frame_free(frame: *mut *mut AVFrame); - pub fn av_frame_ref(dst: *mut AVFrame, src: *const AVFrame) -> c_int; - pub fn av_frame_clone(src: *const AVFrame) -> *mut AVFrame; - pub fn av_frame_unref(frame: *mut AVFrame); - pub fn av_frame_move_ref(dst: *mut AVFrame, src: *mut AVFrame); - - pub fn av_frame_get_buffer(frame: *mut AVFrame, align: c_int) -> c_int; - - pub fn av_frame_is_writable(frame: *mut AVFrame) -> c_int; - pub fn av_frame_make_writable(frame: *mut AVFrame) -> c_int; - - pub fn av_frame_copy(dst: *mut AVFrame, src: *const AVFrame) -> c_int; - pub fn av_frame_copy_props(dst: *mut AVFrame, src: *const AVFrame) -> c_int; - - pub fn av_frame_get_plane_buffer(frame: *mut AVFrame, plane: c_int) -> *mut AVBufferRef; - - pub fn av_frame_new_side_data(frame: *mut AVFrame, kind: AVFrameSideDataType, size: c_int) -> *mut AVFrameSideData; - pub fn av_frame_get_side_data(frame: *const AVFrame, kind: AVFrameSideDataType) -> *mut AVFrameSideData; - pub fn av_frame_remove_side_data(frame: *mut AVFrame, kind: AVFrameSideDataType); - pub fn av_frame_side_data_name(kind: AVFrameSideDataType) -> *const c_char; -} diff --git a/sys/src/avutil/hash.rs b/sys/src/avutil/hash.rs deleted file mode 100644 index 2280617..0000000 --- a/sys/src/avutil/hash.rs +++ /dev/null @@ -1,19 +0,0 @@ -use libc::{c_void, c_char, c_int, uint8_t}; - -pub type AVHashContext = c_void; - -pub const AV_HASH_MAX_SIZE: c_int = 64; - -extern { - pub fn av_hash_alloc(ctx: *mut *mut AVHashContext, name: *const c_char) -> c_int; - pub fn av_hash_names(i: c_int) -> *const c_char; - pub fn av_hash_get_name(ctx: *const AVHashContext) -> *const c_char; - pub fn av_hash_get_size(ctx: *const AVHashContext) -> c_int; - pub fn av_hash_init(ctx: *mut AVHashContext); - pub fn av_hash_update(ctx: *mut AVHashContext, src: *const uint8_t, len: c_int); - pub fn av_hash_final(ctx: *mut AVHashContext, dst: *mut uint8_t); - pub fn av_hash_final_bin(ctx: *mut AVHashContext, dst: *mut uint8_t, size: c_int); - pub fn av_hash_final_hex(ctx: *mut AVHashContext, dst: *mut uint8_t, size: c_int); - pub fn av_hash_final_b64(ctx: *mut AVHashContext, dst: *mut uint8_t, size: c_int); - pub fn av_hash_freep(ctx: *mut *mut AVHashContext); -} diff --git a/sys/src/avutil/hmac.rs b/sys/src/avutil/hmac.rs deleted file mode 100644 index dc03e6e..0000000 --- a/sys/src/avutil/hmac.rs +++ /dev/null @@ -1,27 +0,0 @@ -use libc::{c_void, c_int, c_uint, uint8_t}; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVHMACType { - AV_HMAC_MD5, - AV_HMAC_SHA1, - AV_HMAC_SHA224, - AV_HMAC_SHA256, - #[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, -} - -pub type AVHMAC = c_void; - -extern { - pub fn av_hmac_alloc(kind: AVHMACType) -> *mut AVHMAC; - pub fn av_hmac_free(ctx: *mut AVHMAC); - pub fn av_hmac_init(ctx: *mut AVHMAC, key: *const uint8_t, keylen: c_uint); - pub fn av_hmac_update(ctx: *mut AVHMAC, data: *const uint8_t, len: c_uint); - pub fn av_hmac_final(ctx: *mut AVHMAC, out: *mut uint8_t, outlen: c_uint) -> c_int; - pub fn av_hmac_calc(ctx: *mut AVHMAC, data: *const uint8_t, len: c_uint, key: *const uint8_t, keylen: c_uint, out: *mut uint8_t, outlen: c_uint) -> c_int; -} diff --git a/sys/src/avutil/imgutils.rs b/sys/src/avutil/imgutils.rs deleted file mode 100644 index a49c80b..0000000 --- a/sys/src/avutil/imgutils.rs +++ /dev/null @@ -1,22 +0,0 @@ -use libc::{c_void, c_int, c_uint, uint8_t}; -use super::pixdesc::AVPixFmtDescriptor; -use super::pixfmt::AVPixelFormat; -use super::rational::AVRational; - -extern { - pub fn av_image_fill_max_pixsteps(max_pixsteps: *mut c_int, max_pixstep_comps: *mut c_int, pixdesc: *const AVPixFmtDescriptor); - pub fn av_image_get_linesize(pix_fmt: AVPixelFormat, width: c_int, plane: c_int) -> c_int; - pub fn av_image_fill_linesizes(linesizes: *mut c_int, pix_fmt: AVPixelFormat, width: c_int) -> c_int; - pub fn av_image_fill_pointers(data: *mut *mut uint8_t, pix_fmt: AVPixelFormat, height: c_int, ptr: *mut uint8_t, linesizes: *const c_int) -> c_int; - - pub fn av_image_alloc(pointers: *mut *mut uint8_t, linesizes: *mut c_int, w: c_int, h: c_int, pix_fmt: AVPixelFormat, align: c_int) -> c_int; - - pub fn av_image_copy_plane(dst: *mut uint8_t, dst_linesize: c_int, src: *const uint8_t, src_linesize: c_int, bytewidth: c_int, height: c_int); - pub fn av_image_copy(dst_data: *mut *mut uint8_t, dst_linesizes: *mut c_int, src_data: *const *const uint8_t, src_linesizes: *const c_int, pix_fmt: AVPixelFormat, width: c_int, height: c_int); - - pub fn av_image_fill_arrays(dst_data: *mut *mut uint8_t, dst_linesize: *mut c_int, src: *const uint8_t, pix_fmt: AVPixelFormat, width: c_int, height: c_int, align: c_int) -> c_int; - pub fn av_image_get_buffer_size(pix_fmt: AVPixelFormat, width: c_int, height: c_int, align: c_int) -> c_int; - pub fn av_image_copy_to_buffer(dst: *mut uint8_t, dst_size: c_int, src_data: *const *const uint8_t, src_linesize: *const c_int, pix_fmt: AVPixelFormat, width: c_int, height: c_int, align: c_int) -> c_int; - pub fn av_image_check_size(w: c_uint, h: c_uint, log_offset: c_int, log_ctx: *mut c_void) -> c_int; - pub fn av_image_check_sar(w: c_uint, h: c_uint, sar: AVRational) -> c_int; -} diff --git a/sys/src/avutil/lfg.rs b/sys/src/avutil/lfg.rs deleted file mode 100644 index 7bfc6c4..0000000 --- a/sys/src/avutil/lfg.rs +++ /dev/null @@ -1,32 +0,0 @@ -use libc::{c_int, c_uint, c_double}; - -#[repr(C)] -pub struct AVLFG { - pub state: [c_uint; 64], - pub index: c_int, -} - -#[inline(always)] -pub unsafe fn av_lfg_get(ctx: *mut AVLFG) -> c_uint { - (*ctx).state[((*ctx).index & 63) as usize] = (*ctx).state[(((*ctx).index - 24) & 63) as usize] + (*ctx).state[(((*ctx).index - 55) & 63) as usize]; - (*ctx).index += 1; - - (*ctx).state[(((*ctx).index - 1) & 63) as usize] -} - -#[inline(always)] -pub unsafe fn av_mlfg_get(ctx: *mut AVLFG) -> c_uint { - let a = (*ctx).state[(((*ctx).index - 55) & 63) as usize]; - let b = (*ctx).state[(((*ctx).index - 24) & 63) as usize]; - let c = 2 * a * b + a + b; - - (*ctx).index += 1; - (*ctx).state[(((*ctx).index - 1) & 63) as usize] = c; - - c -} - -extern { - pub fn av_lfg_init(c: *mut AVLFG, seed: c_uint); - pub fn av_bmg_get(lfg: *mut AVLFG, out: *mut c_double); -} diff --git a/sys/src/avutil/log.rs b/sys/src/avutil/log.rs deleted file mode 100644 index 83401b3..0000000 --- a/sys/src/avutil/log.rs +++ /dev/null @@ -1,92 +0,0 @@ -use libc::{c_void, c_char, c_int}; -use super::opt::{AVOption, AVOptionRanges}; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVClassCategory { - AV_CLASS_CATEGORY_NA = 0, - AV_CLASS_CATEGORY_INPUT, - AV_CLASS_CATEGORY_OUTPUT, - AV_CLASS_CATEGORY_MUXER, - AV_CLASS_CATEGORY_DEMUXER, - AV_CLASS_CATEGORY_ENCODER, - AV_CLASS_CATEGORY_DECODER, - AV_CLASS_CATEGORY_FILTER, - AV_CLASS_CATEGORY_BITSTREAM_FILTER, - AV_CLASS_CATEGORY_SWSCALER, - AV_CLASS_CATEGORY_SWRESAMPLER, - AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT = 40, - AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT, - AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT, - AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT, - AV_CLASS_CATEGORY_DEVICE_OUTPUT, - AV_CLASS_CATEGORY_DEVICE_INPUT, - AV_CLASS_CATEGORY_NB, -} - -#[inline(always)] -pub fn AV_IS_INPUT_DEVICE(category: AVClassCategory) -> bool { - category == AVClassCategory::AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT || - category == AVClassCategory::AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT || - category == AVClassCategory::AV_CLASS_CATEGORY_DEVICE_INPUT -} - -#[inline(always)] -pub fn AV_IS_OUTPUT_DEVICE(category: AVClassCategory) -> bool { - category == AVClassCategory::AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT || - category == AVClassCategory::AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT || - category == AVClassCategory::AV_CLASS_CATEGORY_DEVICE_OUTPUT -} - -#[repr(C)] -pub struct AVClass { - pub class_name: *const c_char, - pub item_name: extern fn(ctx: *mut c_void) -> *const c_char, - - pub option: *const AVOption, - pub version: c_int, - - pub log_level_offset_offset: c_int, - pub parent_log_context_offset: c_int, - - pub child_next: extern fn(obj: *mut c_void, prev: *mut c_void) -> *mut c_void, - pub child_class_next: extern fn(prev: *const AVClass) -> *const AVClass, - - pub category: AVClassCategory, - - pub get_category: extern fn(ctx: *mut c_void) -> AVClassCategory, - pub query_ranges: extern fn(ranges: *mut *mut AVOptionRanges, obj: *mut c_void, key: *const c_char, flags: c_int) -> c_int, -} - -pub const AV_LOG_QUIET: c_int = -8; -pub const AV_LOG_PANIC: c_int = 0; -pub const AV_LOG_FATAL: c_int = 8; -pub const AV_LOG_ERROR: c_int = 16; -pub const AV_LOG_WARNING: c_int = 24; -pub const AV_LOG_INFO: c_int = 32; -pub const AV_LOG_VERBOSE: c_int = 40; -pub const AV_LOG_DEBUG: c_int = 48; -pub const AV_LOG_TRACE: c_int = 56; -pub const AV_LOG_MAX_OFFSET: c_int = (AV_LOG_DEBUG - AV_LOG_QUIET); - -pub const AV_LOG_SKIP_REPEATED: c_int = 1; -pub const AV_LOG_PRINT_LEVEL: c_int = 2; - -#[inline(always)] -pub fn AV_LOG_C(x: c_int) -> c_int { - x << 8 -} - -extern { - pub fn av_log(avcl: *mut c_void, level: c_int, fmt: *const c_char, ...); - //pub fn av_vlog(avcl: *mut c_void, level: c_int, fmt: *const c_char, vl: va_list); - pub fn av_log_get_level() -> c_int; - pub fn av_log_set_level(level: c_int); - //pub fn av_log_set_callback(callback: extern fn(*mut c_void, c_int, *const c_char, va_list)); - //pub fn av_log_default_callback(avcl: *mut c_void, level: c_int, fmt: *const c_char, vl: va_list); - pub fn av_default_item_name(ctx: *mut c_void) -> *const c_char; - pub fn av_default_get_category(ptr: *mut c_void) -> AVClassCategory; - //pub fn av_log_format_line(ptr: *mut c_void, level: c_int, fmt: *const c_char, vl: va_list, line: *mut c_char, line_size: c_int, print_prefix: *mut c_int); - pub fn av_log_set_flags(arg: c_int); - pub fn av_log_get_flags() -> c_int; -} diff --git a/sys/src/avutil/lzo.rs b/sys/src/avutil/lzo.rs deleted file mode 100644 index 2de72ef..0000000 --- a/sys/src/avutil/lzo.rs +++ /dev/null @@ -1,12 +0,0 @@ -use libc::{c_void, c_int}; - -pub const AV_LZO_INPUT_DEPLETED: c_int = 1; -pub const AV_LZO_OUTPUT_FULL: c_int = 2; -pub const AV_LZO_INVALID_BACKPTR: c_int = 4; -pub const AV_LZO_ERROR: c_int = 8; -pub const AV_LZO_INPUT_PADDING: c_int = 8; -pub const AV_LZO_OUTPUT_PADDING: c_int = 12; - -extern { - pub fn av_lzo1x_decode(out: *mut c_void, outlen: *mut c_int, inp: *const c_void, inlen: *mut c_int) -> c_int; -} diff --git a/sys/src/avutil/mathematics.rs b/sys/src/avutil/mathematics.rs deleted file mode 100644 index b60d036..0000000 --- a/sys/src/avutil/mathematics.rs +++ /dev/null @@ -1,25 +0,0 @@ -use libc::{c_int, int64_t, uint64_t}; -use super::rational::AVRational; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVRounding { - AV_ROUND_ZERO = 0, - AV_ROUND_INF = 1, - AV_ROUND_DOWN = 2, - AV_ROUND_UP = 3, - AV_ROUND_NEAR_INF = 5, - AV_ROUND_PASS_MINMAX = 8192, -} - -extern { - pub fn av_gcd(a: int64_t, b: int64_t) -> int64_t; - pub fn av_rescale(a: int64_t, b: int64_t, c: int64_t) -> int64_t; - pub fn av_rescale_rnd(a: int64_t, b: int64_t, c: int64_t, r: AVRounding) -> int64_t; - pub fn av_rescale_q(a: int64_t, bq: AVRational, cq: AVRational) -> int64_t; - pub fn av_rescale_q_rnd(a: int64_t, bq: AVRational, cq: AVRational, r: AVRounding) -> int64_t; - pub fn av_compare_ts(ts_a: int64_t, tb_a: AVRational, ts_b: int64_t, tb_b: AVRational) -> c_int; - pub fn av_compare_mod(a: uint64_t, b: uint64_t, m: uint64_t) -> int64_t; - pub fn av_rescale_delta(in_tb: AVRational, in_ts: int64_t, fs_tb: AVRational, duration: c_int, last: *mut int64_t, out_tb: AVRational) -> int64_t; - pub fn av_add_stable(ts_tb: AVRational, ts: int64_t, inc_tb: AVRational, inc: int64_t) -> int64_t; -} diff --git a/sys/src/avutil/md5.rs b/sys/src/avutil/md5.rs deleted file mode 100644 index 97218dd..0000000 --- a/sys/src/avutil/md5.rs +++ /dev/null @@ -1,13 +0,0 @@ -use libc::{c_void, c_int, uint8_t}; - -pub type AVMD5 = c_void; - -extern { - pub static av_md5_size: c_int; - - pub fn av_md5_alloc() -> *mut AVMD5; - pub fn av_md5_init(ctx: *mut AVMD5); - pub fn av_md5_update(ctx: *mut AVMD5, src: *const uint8_t, len: c_int); - pub fn av_md5_final(ctx: *mut AVMD5, dst: *mut uint8_t); - pub fn av_md5_sum(dst: *mut uint8_t, src: *const uint8_t, len: c_int); -} diff --git a/sys/src/avutil/mem.rs b/sys/src/avutil/mem.rs deleted file mode 100644 index 619730c..0000000 --- a/sys/src/avutil/mem.rs +++ /dev/null @@ -1,65 +0,0 @@ -use libc::{c_void, c_char, c_int, c_uint, uint8_t, size_t}; -use std::ptr; -//use std::mem; -//use super::error::AVERROR; - -#[inline(always)] -pub unsafe fn av_malloc_array(nmemb: size_t, size: size_t) -> *mut c_void { - if size == 0 || nmemb >= c_int::max_value() as size_t / size { - ptr::null_mut() - } - else { - av_malloc(nmemb * size) - } -} - -#[inline(always)] -pub unsafe fn av_mallocz_array(nmemb: size_t, size: size_t) -> *mut c_void { - if size == 0 || nmemb >= c_int::max_value() as size_t / size { - ptr::null_mut() - } - else { - av_mallocz(nmemb * size) - } -} - -//#[inline(always)] -//pub unsafe fn av_size_mult(a: size_t, b: size_t, r: *mut size_t) -> c_int { -// use libc::EINVAL; -// -// let t = a * b; -// -// if (a | b) >= (1 << (mem::size_of::() * 4)) && a != 0 && t / a != b { -// AVERROR(EINVAL) -// } -// else { -// *r = t; -// -// 0 -// } -//} - -extern { - pub fn av_malloc(size: size_t) -> *mut c_void; - pub fn av_realloc(ptr: *mut c_void, size: size_t) -> *mut c_void; - pub fn av_realloc_f(ptr: *mut c_void, nelem: size_t, elsize: size_t) -> *mut c_void; - pub fn av_reallocp(ptr: *mut c_void, size: size_t) -> c_int; - pub fn av_realloc_array(ptr: *mut c_void, nmemb: size_t, size: size_t) -> *mut c_void; - pub fn av_reallocp_array(ptr: *mut c_void, nmemb: size_t, size: size_t) -> c_int; - pub fn av_free(ptr: *mut c_void); - pub fn av_mallocz(size: size_t) -> *mut c_void; - pub fn av_calloc(nmemb: size_t, size: size_t) -> *mut c_void; - pub fn av_strdup(s: *const c_char) -> *mut c_char; - pub fn av_strndup(s: *const c_char, len: size_t) -> *mut c_char; - pub fn av_memdup(p: *const c_void, size: size_t) -> *mut c_void; - pub fn av_freep(ptr: *mut c_void); - - pub fn av_dynarray_add(tab_ptr: *mut c_void, nb_ptr: *mut c_int, elem: *mut c_void); - pub fn av_dynarray_add_nofree(tab_ptr: *mut c_void, nb_ptr: *mut c_int, elem: *mut c_void) -> c_int; - pub fn av_dynarray2_add(tab_ptr: *mut *mut c_void, nb_ptr: *mut c_int, elem_size: size_t, elem_data: *const uint8_t); - - pub fn av_max_alloc(max: size_t); - pub fn av_memcpy_backptr(dst: *mut uint8_t, back: c_int, cnt: c_int); - pub fn av_fast_realloc(ptr: *mut c_void, size: *mut c_uint, min_size: size_t) -> *mut c_void; - pub fn av_fast_malloc(ptr: *mut c_void, size: *mut c_uint, min_size: size_t); -} diff --git a/sys/src/avutil/mod.rs b/sys/src/avutil/mod.rs index 56057a4..874a69f 100644 --- a/sys/src/avutil/mod.rs +++ b/sys/src/avutil/mod.rs @@ -1,175 +1,17 @@ #[macro_use] mod macros; -mod adler32; -pub use self::adler32::*; - -mod aes; -pub use self::aes::*; - -mod audio_fifo; -pub use self::audio_fifo::*; - -mod string; -pub use self::string::*; -pub use self::string::AVEscapeMode::*; - -mod base64; -pub use self::base64::*; - -mod blowfish; -pub use self::blowfish::*; - -mod bprint; -pub use self::bprint::*; - -mod buffer; -pub use self::buffer::*; - -mod camellia; -pub use self::camellia::*; - -mod cast5; -pub use self::cast5::*; - -mod channel_layout; -pub use self::channel_layout::*; -pub use self::channel_layout::AVMatrixEncoding::*; - -mod cpu; -pub use self::cpu::*; - -mod crc; -pub use self::crc::*; -pub use self::crc::AVCRCId::*; - -mod dict; -pub use self::dict::*; - -mod display; -pub use self::display::*; - -mod downmix_info; -pub use self::downmix_info::*; - mod error; pub use self::error::*; -mod eval; -pub use self::eval::*; - -mod fifo; -pub use self::fifo::*; - -mod file; -pub use self::file::*; - -mod frame; -pub use self::frame::*; -pub use self::frame::AVFrameSideDataType::*; - -mod hash; -pub use self::hash::*; - -mod hmac; -pub use self::hmac::*; -pub use self::hmac::AVHMACType::*; - -mod imgutils; -pub use self::imgutils::*; - -mod lfg; -pub use self::lfg::*; - -mod log; -pub use self::log::*; -pub use self::log::AVClassCategory::*; - -mod lzo; -pub use self::lzo::*; - -mod mathematics; -pub use self::mathematics::*; -pub use self::mathematics::AVRounding::*; - -mod md5; -pub use self::md5::*; - -mod mem; -pub use self::mem::*; - -mod motion_vector; -pub use self::motion_vector::*; - -mod murmur3; -pub use self::murmur3::*; - -mod opt; -pub use self::opt::*; -pub use self::opt::AVOptionType::*; - -mod parseutils; -pub use self::parseutils::*; - -mod pixdesc; -pub use self::pixdesc::*; - -mod pixfmt; -pub use self::pixfmt::*; -pub use self::pixfmt::AVPixelFormat::*; -pub use self::pixfmt::default::*; -pub use self::pixfmt::AVColorPrimaries::*; -pub use self::pixfmt::AVColorTransferCharacteristic::*; -pub use self::pixfmt::AVColorSpace::*; -pub use self::pixfmt::AVColorRange::*; -pub use self::pixfmt::AVChromaLocation::*; - -mod random_seed; -pub use self::random_seed::*; +mod util; +pub use self::util::*; mod rational; pub use self::rational::*; -mod replaygain; -pub use self::replaygain::*; +mod channel_layout; +pub use self::channel_layout::*; -mod ripemd; -pub use self::ripemd::*; - -mod samplefmt; -pub use self::samplefmt::*; -pub use self::samplefmt::AVSampleFormat::*; - -mod sha; -pub use self::sha::*; - -mod sha512; -pub use self::sha512::*; - -mod stereo3d; -pub use self::stereo3d::*; -pub use self::stereo3d::AVStereo3DType::*; - -mod threadmessage; -pub use self::threadmessage::*; - -mod time; -pub use self::time::*; - -mod timecode; -pub use self::timecode::*; - -mod twofish; -pub use self::twofish::*; - -mod xtea; -pub use self::xtea::*; - -mod util; -pub use self::util::*; -pub use self::util::AVMediaType::*; -pub use self::util::AVPictureType::*; - -#[cfg_attr(feature = "static", link(name = "avutil", kind = "static"))] -#[cfg_attr(not(feature = "static"), link(name = "avutil"))] -extern { } +mod pixfmt; +pub use self::pixfmt::*; diff --git a/sys/src/avutil/motion_vector.rs b/sys/src/avutil/motion_vector.rs deleted file mode 100644 index 858936b..0000000 --- a/sys/src/avutil/motion_vector.rs +++ /dev/null @@ -1,18 +0,0 @@ -use libc::{uint8_t, int16_t, int32_t, uint64_t}; - -#[derive(Debug)] -#[repr(C)] -pub struct AVMotionVector { - pub source: int32_t, - - pub w: uint8_t, - pub h: uint8_t, - - pub src_x: int16_t, - pub src_y: int16_t, - - pub dst_x: int16_t, - pub dst_y: int16_t, - - pub flags: uint64_t, -} diff --git a/sys/src/avutil/murmur3.rs b/sys/src/avutil/murmur3.rs deleted file mode 100644 index e29e44f..0000000 --- a/sys/src/avutil/murmur3.rs +++ /dev/null @@ -1,11 +0,0 @@ -use libc::{c_void, c_int, uint8_t, uint64_t}; - -pub type AVMurMur3 = c_void; - -extern { - pub fn av_murmur3_alloc() -> *mut AVMurMur3; - pub fn av_murmur3_init_seeded(c: *mut AVMurMur3, seed: uint64_t); - pub fn av_murmur3_init(c: *mut AVMurMur3); - pub fn av_murmur3_update(c: *mut AVMurMur3, src: *const uint8_t, len: c_int); - pub fn av_murmur3_final(c: *mut AVMurMur3, dst: *mut uint8_t); -} diff --git a/sys/src/avutil/opt.rs b/sys/src/avutil/opt.rs deleted file mode 100644 index 45b5c47..0000000 --- a/sys/src/avutil/opt.rs +++ /dev/null @@ -1,142 +0,0 @@ -use libc::{c_void, c_char, c_int, c_uint, c_float, c_double, uint8_t, int64_t}; -use super::rational::AVRational; -use super::dict::AVDictionary; -use super::log::AVClass; -use super::pixfmt::AVPixelFormat; -use super::samplefmt::AVSampleFormat; - -pub const AV_OPT_FLAG_IMPLICIT_KEY: c_int = 1; -pub const AV_OPT_FLAG_ENCODING_PARAM: c_int = 1; -pub const AV_OPT_FLAG_DECODING_PARAM: c_int = 2; -pub const AV_OPT_FLAG_AUDIO_PARAM: c_int = 8; -pub const AV_OPT_FLAG_VIDEO_PARAM: c_int = 16; -pub const AV_OPT_FLAG_SUBTITLE_PARAM: c_int = 32; -pub const AV_OPT_FLAG_EXPORT: c_int = 64; -pub const AV_OPT_FLAG_READONLY: c_int = 128; -pub const AV_OPT_FLAG_FILTERING_PARAM: c_int = 1 << 16; - -pub const AV_OPT_SEARCH_CHILDREN: c_int = 0x0001; -pub const AV_OPT_SEARCH_FAKE_OBJ: c_int = 0x0002; -pub const AV_OPT_MULTI_COMPONENT_RANGE: c_int = 0x1000; -pub const AV_OPT_SERIALIZE_SKIP_DEFAULTS: c_int = 0x00000001; -pub const AV_OPT_SERIALIZE_OPT_FLAGS_EXACT: c_int = 0x00000002; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVOptionType { - AV_OPT_TYPE_FLAGS, - AV_OPT_TYPE_INT, - AV_OPT_TYPE_INT64, - AV_OPT_TYPE_DOUBLE, - AV_OPT_TYPE_FLOAT, - AV_OPT_TYPE_STRING, - AV_OPT_TYPE_RATIONAL, - AV_OPT_TYPE_BINARY, - AV_OPT_TYPE_DICT, - AV_OPT_TYPE_CONST = 128, - - AV_OPT_TYPE_IMAGE_SIZE = MKBETAG!(b'S', b'I', b'Z', b'E'), - AV_OPT_TYPE_PIXEL_FMT = MKBETAG!(b'P', b'F', b'M', b'T'), - AV_OPT_TYPE_SAMPLE_FMT = MKBETAG!(b'S', b'F', b'M', b'T'), - AV_OPT_TYPE_VIDEO_RATE = MKBETAG!(b'V', b'R', b'A', b'T'), - AV_OPT_TYPE_DURATION = MKBETAG!(b'D', b'U', b'R', b' '), - AV_OPT_TYPE_COLOR = MKBETAG!(b'C', b'O', b'L', b'R'), - AV_OPT_TYPE_CHANNEL_LAYOUT = MKBETAG!(b'C', b'H', b'L', b'A'), -} - -#[derive(Debug)] -#[repr(C)] -pub struct AVOption { - pub name: *const c_char, - pub help: *const c_char, - - pub offset: c_int, - pub kind: AVOptionType, - - pub default_val: [u8; 8], - - pub min: c_double, - pub max: c_double, - - pub unit: *const c_char, -} - -#[derive(Debug)] -#[repr(C)] -pub struct AVOptionRange { - pub str: *const c_char, - - pub value_min: c_double, - pub value_max: c_double, - - pub component_min: c_double, - pub component_max: c_double, - - pub is_range: c_int, -} - -#[derive(Debug)] -#[repr(C)] -pub struct AVOptionRanges { - pub range: *mut *mut AVOptionRange, - - pub nb_ranges: c_int, - pub nb_components: c_int, -} - -extern { - pub fn av_opt_show2(obj: *mut c_void, av_log_obj: *mut c_void, req_flags: c_int, rej_flags: c_int) -> c_int; - pub fn av_opt_set_defaults(s: *mut c_void); - pub fn av_set_options_string(ctx: *mut c_void, opts: *const c_char, key_val_sep: *const c_char, pairs_sep: *const c_char) -> c_int; - pub fn av_opt_set_from_string(ctx: *mut c_void, opts: *const c_char, shorthand: *const *const c_char, key_val_sep: *const c_char, pairs_sep: *const c_char) -> c_int; - pub fn av_opt_free(obj: *mut c_void); - pub fn av_opt_flag_is_set(obj: *mut c_void, field_name: *const c_char, flag_name: *const c_char) -> c_int; - pub fn av_opt_set_dict(obj: *mut c_void, options: *mut *mut AVDictionary) -> c_int; - pub fn av_opt_set_dict2(obj: *mut c_void, options: *mut *mut AVDictionary, search_flags: c_int) -> c_int; - pub fn av_opt_get_key_value(ropts: *const *const c_char, key_val_sep: *const c_char, pairs_sep: *const c_char, flags: c_uint, rkey: *mut *mut c_char, rval: *mut *mut c_char) -> c_int; - - pub fn av_opt_eval_flags(obj: *mut c_void, o: *mut AVOption, val: *const c_char, flags_out: *mut c_int) -> c_int; - pub fn av_opt_eval_int(obj: *mut c_void, o: *mut AVOption, val: *const c_char, int_out: *mut c_int) -> c_int; - pub fn av_opt_eval_int64(obj: *mut c_void, o: *mut AVOption, val: *const c_char, int64_out: *mut int64_t) -> c_int; - pub fn av_opt_eval_float(obj: *mut c_void, o: *mut AVOption, val: *const c_char, float_out: *mut c_float) -> c_int; - pub fn av_opt_eval_double(obj: *mut c_void, o: *mut AVOption, val: *const c_char, double_out: *mut c_double) -> c_int; - pub fn av_opt_eval_q(obj: *mut c_void, o: *mut AVOption, val: *const c_char, q_out: *mut AVRational) -> c_int; - - pub fn av_opt_find(obj: *mut c_void, name: *const c_char, unit: *const c_char, opt_flags: c_int, search_flags: c_int) -> *const AVOption; - pub fn av_opt_find2(obj: *mut c_void, name: *const c_char, unit: *const c_char, opt_flags: c_int, search_flags: c_int, target_obj: *mut *mut c_void) -> *const AVOption; - - pub fn av_opt_next(obj: *mut c_void, prev: *const AVOption) -> *const AVOption; - pub fn av_opt_child_next(obj: *mut c_void, prev: *mut c_void) -> *mut c_void; - pub fn av_opt_child_class_next(parent: *const AVClass, prev: *const AVClass) -> *const AVClass; - - pub fn av_opt_set(obj: *mut c_void, name: *const c_char, val: *const c_char, search_flags: c_int) -> c_int; - pub fn av_opt_set_int(obj: *mut c_void, name: *const c_char, val: int64_t, search_flags: c_int) -> c_int; - pub fn av_opt_set_double(obj: *mut c_void, name: *const c_char, val: c_double, search_flags: c_int) -> c_int; - pub fn av_opt_set_q(obj: *mut c_void, name: *const c_char, val: AVRational, search_flags: c_int) -> c_int; - pub fn av_opt_set_bin(obj: *mut c_void, name: *const c_char, val: *const uint8_t, len: c_int, search_flags: c_int) -> c_int; - pub fn av_opt_set_image_size(obj: *mut c_void, name: *const c_char, w: c_int, h: c_int, search_flags: c_int) -> c_int; - pub fn av_opt_set_pixel_fmt(obj: *mut c_void, name: *const c_char, fmt: AVPixelFormat, search_flags: c_int) -> c_int; - pub fn av_opt_set_sample_fmt(obj: *mut c_void, name: *const c_char, fmt: AVSampleFormat, search_flags: c_int) -> c_int; - pub fn av_opt_set_video_rate(obj: *mut c_void, name: *const c_char, val: AVRational, search_flags: c_int) -> c_int; - pub fn av_opt_set_channel_layout(obj: *mut c_void, name: *const c_char, ch_layout: int64_t, search_flags: c_int) -> c_int; - pub fn av_opt_set_dict_val(obj: *mut c_void, name: *const c_char, val: *const AVDictionary, search_flags: c_int) -> c_int; - - pub fn av_opt_get(obj: *mut c_void, name: *const c_char, search_flags: c_int, out_val: *mut *mut uint8_t) -> c_int; - pub fn av_opt_get_int(obj: *mut c_void, name: *const c_char, search_flags: c_int, out_val: *mut int64_t) -> c_int; - pub fn av_opt_get_double(obj: *mut c_void, name: *const c_char, search_flags: c_int, out_val: *mut c_double) -> c_int; - pub fn av_opt_get_image_size(obj: *mut c_void, name: *const c_char, search_flags: c_int, w_out: *mut c_int, h_out: *mut c_int) -> c_int; - pub fn av_opt_get_pixel_fmt(obj: *mut c_void, name: *const c_char, search_flags: c_int, out_fmt: *mut AVPixelFormat) -> c_int; - pub fn av_opt_get_sample_fmt(obj: *mut c_void, name: *const c_char, search_flags: c_int, out_fmt: *mut AVSampleFormat) -> c_int; - pub fn av_opt_get_video_rate(obj: *mut c_void, name: *const c_char, search_flags: c_int, out_val: *mut AVRational) -> c_int; - pub fn av_opt_get_channel_layout(obj: *mut c_void, name: *const c_char, search_flags: c_int, ch_layout: *mut int64_t) -> c_int; - pub fn av_opt_get_dict_val(obj: *mut c_void, name: *const c_char, search_flags: c_int, out_val: *mut *mut AVDictionary) -> c_int; - - pub fn av_opt_ptr(avclass: *const AVClass, obj: *mut c_void, name: *const c_char); - pub fn av_opt_freep_ranges(ranges: *mut *mut AVOptionRanges); - pub fn av_opt_query_ranges(ranges: *mut *mut AVOptionRanges, obj: *mut c_void, key: *const c_char, flags: c_int) -> c_int; - pub fn av_opt_copy(dest: *mut c_void, src: *mut c_void) -> c_int; - pub fn av_opt_query_ranges_default(ranges: *mut *mut AVOptionRanges, obj: *mut c_void, key: *const c_char, flags: c_int) -> c_int; - pub fn av_opt_is_set_to_default(obj: *mut c_void, o: *const AVOption) -> c_int; - pub fn av_opt_is_set_to_default_by_name(obj: *mut c_void, name: *const c_char, search_flags: c_int) -> c_int; - pub fn av_opt_serialize(obj: *mut c_void, opt_flags: c_int, flags: c_int, buffer: *mut *mut c_char, key_val_sep: c_char, pairs_sep: c_char) -> c_int; -} diff --git a/sys/src/avutil/parseutils.rs b/sys/src/avutil/parseutils.rs deleted file mode 100644 index 62de07b..0000000 --- a/sys/src/avutil/parseutils.rs +++ /dev/null @@ -1,21 +0,0 @@ -use libc::{c_void, c_char, c_int, uint8_t, int64_t, time_t}; -use std::ptr; -use super::rational::AVRational; -use super::log::AV_LOG_MAX_OFFSET; - -#[inline(always)] -pub unsafe fn av_parse_ratio_quiet(q: *mut AVRational, string: *const c_char, max: c_int) -> c_int { - av_parse_ratio(q, string, max, AV_LOG_MAX_OFFSET, ptr::null_mut()) -} - -extern { - pub fn av_parse_ratio(q: *mut AVRational, string: *const c_char, max: c_int, log_offset: c_int, log_ctx: *mut c_void) -> c_int; - pub fn av_parse_video_size(width_ptr: *mut c_int, height_ptr: *mut c_int, string: *const c_char) -> c_int; - pub fn av_parse_video_rate(rate: *mut AVRational, string: *const c_char) -> c_int; - pub fn av_parse_color(rgba_color: *mut uint8_t, color_string: *const c_char, slen: c_int, log_ctx: *mut c_void) -> c_int; - pub fn av_get_known_color_name(color_idx: c_int, rgb: *const *const uint8_t) -> *const c_char; - pub fn av_parse_time(timeval: *mut int64_t, timestr: *const c_char, duration: c_int) -> c_int; - pub fn av_find_info_tag(arg: *mut c_char, arg_size: c_int, tag1: *const c_char, info: *const c_char) -> c_int; - pub fn av_small_strptime(p: *const c_char, fmt: *const c_char, dt: *mut c_void) -> *mut c_char; - pub fn av_timegm(tm: *mut c_void) -> time_t; -} diff --git a/sys/src/avutil/pixdesc.rs b/sys/src/avutil/pixdesc.rs deleted file mode 100644 index 666886c..0000000 --- a/sys/src/avutil/pixdesc.rs +++ /dev/null @@ -1,101 +0,0 @@ -use libc::{c_char, c_int, uint8_t, uint16_t}; -use super::pixfmt::{AVPixelFormat, AVColorRange, AVColorPrimaries, AVColorTransferCharacteristic, AVColorSpace, AVChromaLocation}; - -#[derive(Debug)] -#[repr(C)] -pub struct AVComponentDescriptor { - pub data: uint16_t, -} - -impl AVComponentDescriptor { - pub fn plane(&self) -> uint16_t { - self.data >> 14 - } - - pub fn step_minus1(&self) -> uint16_t { - self.data >> 11 & 0b111 - } - - pub fn offset_plus1(&self) -> uint16_t { - self.data >> 8 & 0b111 - } - - pub fn shift(&self) -> uint16_t { - self.data >> 5 & 0b111 - } - - pub fn depth_minus1(&self) -> uint16_t { - self.data >> 1 & 0b1111 - } -} - -#[derive(Debug)] -#[repr(C)] -pub struct AVPixFmtDescriptor { - pub name: *const c_char, - - pub nb_components: uint8_t, - - pub log2_chroma_w: uint8_t, - pub log2_chroma_h: uint8_t, - - pub flags: uint8_t, - - pub comp: [AVComponentDescriptor; 4], - - pub alias: *const c_char, -} - -pub const AV_PIX_FMT_FLAG_BE: c_int = 1 << 0; -pub const AV_PIX_FMT_FLAG_PAL: c_int = 1 << 1; -pub const AV_PIX_FMT_FLAG_BITSTREAM: c_int = 1 << 2; -pub const AV_PIX_FMT_FLAG_HWACCEL: c_int = 1 << 3; -pub const AV_PIX_FMT_FLAG_PLANAR: c_int = 1 << 4; -pub const AV_PIX_FMT_FLAG_RGB: c_int = 1 << 5; -pub const AV_PIX_FMT_FLAG_PSEUDOPAL: c_int = 1 << 6; -pub const AV_PIX_FMT_FLAG_ALPHA: c_int = 1 << 7; - -pub const PIX_FMT_BE: c_int = AV_PIX_FMT_FLAG_BE; -pub const PIX_FMT_PAL: c_int = AV_PIX_FMT_FLAG_PAL; -pub const PIX_FMT_BITSTREAM: c_int = AV_PIX_FMT_FLAG_BITSTREAM; -pub const PIX_FMT_HWACCEL: c_int = AV_PIX_FMT_FLAG_HWACCEL; -pub const PIX_FMT_PLANAR: c_int = AV_PIX_FMT_FLAG_PLANAR; -pub const PIX_FMT_RGB: c_int = AV_PIX_FMT_FLAG_RGB; -pub const PIX_FMT_PSEUDOPAL: c_int = AV_PIX_FMT_FLAG_PSEUDOPAL; -pub const PIX_FMT_ALPHA: c_int = AV_PIX_FMT_FLAG_ALPHA; - -pub const FF_LOSS_RESOLUTION: c_int = 0x0001; -pub const FF_LOSS_DEPTH: c_int = 0x0002; -pub const FF_LOSS_COLORSPACE: c_int = 0x0004; -pub const FF_LOSS_ALPHA: c_int = 0x0008; -pub const FF_LOSS_COLORQUANT: c_int = 0x0010; -pub const FF_LOSS_CHROMA: c_int = 0x0020; - -extern { - pub fn av_read_image_line(dst: *mut uint16_t, data: *const *const uint8_t, linesize: *const c_int, desc: *const AVPixFmtDescriptor, x: c_int, y: c_int, c: c_int, w: c_int, read_pal_component: c_int); - pub fn av_write_image_line(src: *const uint16_t, data: *const *const uint8_t, linesize: *const c_int, desc: *const AVPixFmtDescriptor, x: c_int, y: c_int, c: c_int, w: c_int); - - pub fn av_get_pix_fmt(name: *const c_char) -> AVPixelFormat; - pub fn av_get_pix_fmt_name(pix_fmt: AVPixelFormat) -> *const c_char; - pub fn av_get_pix_fmt_string(buf: *mut c_char, buf_size: c_int, pix_fmt: AVPixelFormat) -> *mut c_char; - - pub fn av_get_bits_per_pixel(pixdesc: *const AVPixFmtDescriptor) -> c_int; - pub fn av_get_padded_bits_per_pixel(pixdesc: *const AVPixFmtDescriptor) -> c_int; - - pub fn av_pix_fmt_desc_get(pix_fmt: AVPixelFormat) -> *const AVPixFmtDescriptor; - pub fn av_pix_fmt_desc_next(prev: *const AVPixFmtDescriptor) -> *const AVPixFmtDescriptor; - pub fn av_pix_fmt_desc_get_id(desc: *const AVPixFmtDescriptor) -> AVPixelFormat; - - pub fn av_pix_fmt_get_chroma_sub_sample(pix_fmt: AVPixelFormat, h_shift: *mut c_int, v_shift: *mut c_int) -> c_int; - pub fn av_pix_fmt_count_planes(pix_fmt: AVPixelFormat) -> c_int; - pub fn av_pix_fmt_swap_endianness(pix_fmt: AVPixelFormat) -> AVPixelFormat; - - pub fn av_get_pix_fmt_loss(dst_pix_fmt: AVPixelFormat, src_pix_fmt: AVPixelFormat, has_alpha: c_int) -> c_int; - pub fn av_find_best_pix_fmt_of_2(dst_pix_fmt1: AVPixelFormat, dst_pix_fmt2: AVPixelFormat, src_pix_fmt: AVPixelFormat, has_alpha: c_int, loss_ptr: *mut c_int) -> AVPixelFormat; - - pub fn av_color_range_name(range: AVColorRange) -> *const c_char; - pub fn av_color_primaries_name(primaries: AVColorPrimaries) -> *const c_char; - pub fn av_color_transfer_name(transfer: AVColorTransferCharacteristic) -> *const c_char; - pub fn av_color_space_name(space: AVColorSpace) -> *const c_char; - pub fn av_chroma_location_name(location: AVChromaLocation) -> *const c_char; -} diff --git a/sys/src/avutil/pixfmt.rs b/sys/src/avutil/pixfmt.rs index 9ec5991..e222ca4 100644 --- a/sys/src/avutil/pixfmt.rs +++ b/sys/src/avutil/pixfmt.rs @@ -1,449 +1,235 @@ -use libc::{c_int}; - -pub const AVPALETTE_SIZE: c_int = 1024; -pub const AVPALETTE_COUNT: c_int = 256; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVPixelFormat { - AV_PIX_FMT_NONE = -1, - AV_PIX_FMT_YUV420P, - AV_PIX_FMT_YUYV422, - AV_PIX_FMT_RGB24, - AV_PIX_FMT_BGR24, - AV_PIX_FMT_YUV422P, - AV_PIX_FMT_YUV444P, - AV_PIX_FMT_YUV410P, - AV_PIX_FMT_YUV411P, - AV_PIX_FMT_GRAY8, - AV_PIX_FMT_MONOWHITE, - AV_PIX_FMT_MONOBLACK, - AV_PIX_FMT_PAL8, - AV_PIX_FMT_YUVJ420P, - AV_PIX_FMT_YUVJ422P, - AV_PIX_FMT_YUVJ444P, - #[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, - AV_PIX_FMT_BGR4, - AV_PIX_FMT_BGR4_BYTE, - AV_PIX_FMT_RGB8, - AV_PIX_FMT_RGB4, - AV_PIX_FMT_RGB4_BYTE, - AV_PIX_FMT_NV12, - AV_PIX_FMT_NV21, - - AV_PIX_FMT_ARGB, - AV_PIX_FMT_RGBA, - AV_PIX_FMT_ABGR, - AV_PIX_FMT_BGRA, - - AV_PIX_FMT_GRAY16BE, - AV_PIX_FMT_GRAY16LE, - AV_PIX_FMT_YUV440P, - AV_PIX_FMT_YUVJ440P, - AV_PIX_FMT_YUVA420P, - #[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, - - AV_PIX_FMT_RGB565BE, - AV_PIX_FMT_RGB565LE, - AV_PIX_FMT_RGB555BE, - AV_PIX_FMT_RGB555LE, - - AV_PIX_FMT_BGR565BE, - AV_PIX_FMT_BGR565LE, - AV_PIX_FMT_BGR555BE, - AV_PIX_FMT_BGR555LE, - - #[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, - - #[cfg(not(feature = "ff_api_vaapi"))] - AV_PIX_FMT_VAAPI, - - AV_PIX_FMT_YUV420P16LE, - AV_PIX_FMT_YUV420P16BE, - AV_PIX_FMT_YUV422P16LE, - AV_PIX_FMT_YUV422P16BE, - AV_PIX_FMT_YUV444P16LE, - AV_PIX_FMT_YUV444P16BE, - #[cfg(feature = "ff_api_vdpau")] - AV_PIX_FMT_VDPAU_MPEG4, - AV_PIX_FMT_DXVA2_VLD, - - AV_PIX_FMT_RGB444LE, - AV_PIX_FMT_RGB444BE, - AV_PIX_FMT_BGR444LE, - AV_PIX_FMT_BGR444BE, - AV_PIX_FMT_YA8, - - AV_PIX_FMT_BGR48BE, - AV_PIX_FMT_BGR48LE, - - AV_PIX_FMT_YUV420P9BE, - AV_PIX_FMT_YUV420P9LE, - AV_PIX_FMT_YUV420P10BE, - AV_PIX_FMT_YUV420P10LE, - AV_PIX_FMT_YUV422P10BE, - AV_PIX_FMT_YUV422P10LE, - AV_PIX_FMT_YUV444P9BE, - AV_PIX_FMT_YUV444P9LE, - AV_PIX_FMT_YUV444P10BE, - AV_PIX_FMT_YUV444P10LE, - AV_PIX_FMT_YUV422P9BE, - AV_PIX_FMT_YUV422P9LE, - AV_PIX_FMT_VDA_VLD, - - AV_PIX_FMT_GBRP, - AV_PIX_FMT_GBRP9BE, - AV_PIX_FMT_GBRP9LE, - AV_PIX_FMT_GBRP10BE, - AV_PIX_FMT_GBRP10LE, - AV_PIX_FMT_GBRP16BE, - AV_PIX_FMT_GBRP16LE, - - AV_PIX_FMT_YUVA422P_LIBAV, - AV_PIX_FMT_YUVA444P_LIBAV, - - AV_PIX_FMT_YUVA420P9BE, - AV_PIX_FMT_YUVA420P9LE, - AV_PIX_FMT_YUVA422P9BE, - AV_PIX_FMT_YUVA422P9LE, - AV_PIX_FMT_YUVA444P9BE, - AV_PIX_FMT_YUVA444P9LE, - AV_PIX_FMT_YUVA420P10BE, - AV_PIX_FMT_YUVA420P10LE, - AV_PIX_FMT_YUVA422P10BE, - AV_PIX_FMT_YUVA422P10LE, - AV_PIX_FMT_YUVA444P10BE, - AV_PIX_FMT_YUVA444P10LE, - AV_PIX_FMT_YUVA420P16BE, - AV_PIX_FMT_YUVA420P16LE, - AV_PIX_FMT_YUVA422P16BE, - AV_PIX_FMT_YUVA422P16LE, - AV_PIX_FMT_YUVA444P16BE, - AV_PIX_FMT_YUVA444P16LE, - - AV_PIX_FMT_VDPAU, - - AV_PIX_FMT_XYZ12LE, - AV_PIX_FMT_XYZ12BE, - AV_PIX_FMT_NV16, - AV_PIX_FMT_NV20LE, - AV_PIX_FMT_NV20BE, - - AV_PIX_FMT_RGBA64BE_LIBAV, - AV_PIX_FMT_RGBA64LE_LIBAV, - AV_PIX_FMT_BGRA64BE_LIBAV, - AV_PIX_FMT_BGRA64LE_LIBAV, - - AV_PIX_FMT_YVYU422, - - AV_PIX_FMT_VDA, - - AV_PIX_FMT_YA16BE, - AV_PIX_FMT_YA16LE, - - AV_PIX_FMT_GBRAP_LIBAV, - AV_PIX_FMT_GBRAP16BE_LIBAV, - AV_PIX_FMT_GBRAP16LE_LIBAV, - AV_PIX_FMT_QSV, - AV_PIX_FMT_MMAL, - - AV_PIX_FMT_D3D11VA_VLD, - - AV_PIX_FMT_CUDA, - - AV_PIX_FMT_0RGB = 0x123 + 4, - AV_PIX_FMT_RGB0, - AV_PIX_FMT_0BGR, - AV_PIX_FMT_BGR0, - AV_PIX_FMT_YUVA444P, - AV_PIX_FMT_YUVA422P, - - AV_PIX_FMT_YUV420P12BE, - AV_PIX_FMT_YUV420P12LE, - AV_PIX_FMT_YUV420P14BE, - AV_PIX_FMT_YUV420P14LE, - AV_PIX_FMT_YUV422P12BE, - AV_PIX_FMT_YUV422P12LE, - AV_PIX_FMT_YUV422P14BE, - AV_PIX_FMT_YUV422P14LE, - AV_PIX_FMT_YUV444P12BE, - AV_PIX_FMT_YUV444P12LE, - AV_PIX_FMT_YUV444P14BE, - AV_PIX_FMT_YUV444P14LE, - AV_PIX_FMT_GBRP12BE, - AV_PIX_FMT_GBRP12LE, - AV_PIX_FMT_GBRP14BE, - AV_PIX_FMT_GBRP14LE, - AV_PIX_FMT_GBRAP, - AV_PIX_FMT_GBRAP16BE, - AV_PIX_FMT_GBRAP16LE, - AV_PIX_FMT_YUVJ411P, - - AV_PIX_FMT_BAYER_BGGR8, - AV_PIX_FMT_BAYER_RGGB8, - AV_PIX_FMT_BAYER_GBRG8, - AV_PIX_FMT_BAYER_GRBG8, - AV_PIX_FMT_BAYER_BGGR16LE, - AV_PIX_FMT_BAYER_BGGR16BE, - AV_PIX_FMT_BAYER_RGGB16LE, - AV_PIX_FMT_BAYER_RGGB16BE, - AV_PIX_FMT_BAYER_GBRG16LE, - AV_PIX_FMT_BAYER_GBRG16BE, - AV_PIX_FMT_BAYER_GRBG16LE, - AV_PIX_FMT_BAYER_GRBG16BE, - - AV_PIX_FMT_YUV440P10LE, - AV_PIX_FMT_YUV440P10BE, - AV_PIX_FMT_YUV440P12LE, - AV_PIX_FMT_YUV440P12BE, - AV_PIX_FMT_AYUV64LE, - AV_PIX_FMT_AYUV64BE, - - AV_PIX_FMT_VIDEOTOOLBOX, - - AV_PIX_FMT_NB, -} - -#[cfg(feature = "ff_api_xvmc")] -pub const AV_PIX_FMT_XVMC: AVPixelFormat = AVPixelFormat::AV_PIX_FMT_XVMC_MPEG2_IDCT; -pub const AV_PIX_FMT_Y400A: AVPixelFormat = AVPixelFormat::AV_PIX_FMT_YA8; -pub const AV_PIX_FMT_GRAY8A: AVPixelFormat = AVPixelFormat::AV_PIX_FMT_YA8; -pub const AV_PIX_FMT_GBR24P: AVPixelFormat = AVPixelFormat::AV_PIX_FMT_GBRP; +use AVPixelFormat; +use AVPixelFormat::*; #[cfg(target_endian = "little")] -pub mod default { - use super::AVPixelFormat; - use super::AVPixelFormat::*; +pub const AV_PIX_FMT_RGB32: AVPixelFormat = AV_PIX_FMT_BGRA; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_RGB32_1: AVPixelFormat = AV_PIX_FMT_ABGR; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_BGR32: AVPixelFormat = AV_PIX_FMT_RGBA; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_BGR32_1: AVPixelFormat = AV_PIX_FMT_ARGB; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_0RGB32: AVPixelFormat = AV_PIX_FMT_BGR0; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_0BGR32: AVPixelFormat = AV_PIX_FMT_RGB0; - pub const AV_PIX_FMT_RGB32: AVPixelFormat = AV_PIX_FMT_BGRA; - pub const AV_PIX_FMT_RGB32_1: AVPixelFormat = AV_PIX_FMT_ABGR; - pub const AV_PIX_FMT_BGR32: AVPixelFormat = AV_PIX_FMT_RGBA; - pub const AV_PIX_FMT_BGR32_1: AVPixelFormat = AV_PIX_FMT_ARGB; - pub const AV_PIX_FMT_0RGB32: AVPixelFormat = AV_PIX_FMT_BGR0; - pub const AV_PIX_FMT_0BGR32: AVPixelFormat = AV_PIX_FMT_RGB0; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_GRAY16: AVPixelFormat = AV_PIX_FMT_GRAY16LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YA16: AVPixelFormat = AV_PIX_FMT_YA16LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_RGB48: AVPixelFormat = AV_PIX_FMT_RGB48LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_RGB565: AVPixelFormat = AV_PIX_FMT_RGB565LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_RGB555: AVPixelFormat = AV_PIX_FMT_RGB555LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_RGB444: AVPixelFormat = AV_PIX_FMT_RGB444LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_BGR48: AVPixelFormat = AV_PIX_FMT_BGR48LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_BGR565: AVPixelFormat = AV_PIX_FMT_BGR565LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_BGR555: AVPixelFormat = AV_PIX_FMT_BGR555LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_BGR444: AVPixelFormat = AV_PIX_FMT_BGR444LE; - pub const AV_PIX_FMT_GRAY16: AVPixelFormat = AV_PIX_FMT_GRAY16LE; - pub const AV_PIX_FMT_YA16: AVPixelFormat = AV_PIX_FMT_YA16LE; - pub const AV_PIX_FMT_RGB48: AVPixelFormat = AV_PIX_FMT_RGB48LE; - pub const AV_PIX_FMT_RGB565: AVPixelFormat = AV_PIX_FMT_RGB565LE; - pub const AV_PIX_FMT_RGB555: AVPixelFormat = AV_PIX_FMT_RGB555LE; - pub const AV_PIX_FMT_RGB444: AVPixelFormat = AV_PIX_FMT_RGB444LE; - pub const AV_PIX_FMT_BGR48: AVPixelFormat = AV_PIX_FMT_BGR48LE; - pub const AV_PIX_FMT_BGR565: AVPixelFormat = AV_PIX_FMT_BGR565LE; - pub const AV_PIX_FMT_BGR555: AVPixelFormat = AV_PIX_FMT_BGR555LE; - pub const AV_PIX_FMT_BGR444: AVPixelFormat = AV_PIX_FMT_BGR444LE; +pub const AV_PIX_FMT_YUV420P9: AVPixelFormat = AV_PIX_FMT_YUV420P9LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUV422P9: AVPixelFormat = AV_PIX_FMT_YUV422P9LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUV444P9: AVPixelFormat = AV_PIX_FMT_YUV444P9LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUV420P10: AVPixelFormat = AV_PIX_FMT_YUV420P10LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUV422P10: AVPixelFormat = AV_PIX_FMT_YUV422P10LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUV440P10: AVPixelFormat = AV_PIX_FMT_YUV440P10LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUV444P10: AVPixelFormat = AV_PIX_FMT_YUV444P10LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUV420P12: AVPixelFormat = AV_PIX_FMT_YUV420P12LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUV422P12: AVPixelFormat = AV_PIX_FMT_YUV422P12LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUV440P12: AVPixelFormat = AV_PIX_FMT_YUV440P12LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUV444P12: AVPixelFormat = AV_PIX_FMT_YUV444P12LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUV420P14: AVPixelFormat = AV_PIX_FMT_YUV420P14LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUV422P14: AVPixelFormat = AV_PIX_FMT_YUV422P14LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUV444P14: AVPixelFormat = AV_PIX_FMT_YUV444P14LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUV420P16: AVPixelFormat = AV_PIX_FMT_YUV420P16LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUV422P16: AVPixelFormat = AV_PIX_FMT_YUV422P16LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUV444P16: AVPixelFormat = AV_PIX_FMT_YUV444P16LE; - pub const AV_PIX_FMT_YUV420P9: AVPixelFormat = AV_PIX_FMT_YUV420P9LE; - pub const AV_PIX_FMT_YUV422P9: AVPixelFormat = AV_PIX_FMT_YUV422P9LE; - pub const AV_PIX_FMT_YUV444P9: AVPixelFormat = AV_PIX_FMT_YUV444P9LE; - pub const AV_PIX_FMT_YUV420P10: AVPixelFormat = AV_PIX_FMT_YUV420P10LE; - pub const AV_PIX_FMT_YUV422P10: AVPixelFormat = AV_PIX_FMT_YUV422P10LE; - pub const AV_PIX_FMT_YUV440P10: AVPixelFormat = AV_PIX_FMT_YUV440P10LE; - pub const AV_PIX_FMT_YUV444P10: AVPixelFormat = AV_PIX_FMT_YUV444P10LE; - pub const AV_PIX_FMT_YUV420P12: AVPixelFormat = AV_PIX_FMT_YUV420P12LE; - pub const AV_PIX_FMT_YUV422P12: AVPixelFormat = AV_PIX_FMT_YUV422P12LE; - pub const AV_PIX_FMT_YUV440P12: AVPixelFormat = AV_PIX_FMT_YUV440P12LE; - pub const AV_PIX_FMT_YUV444P12: AVPixelFormat = AV_PIX_FMT_YUV444P12LE; - pub const AV_PIX_FMT_YUV420P14: AVPixelFormat = AV_PIX_FMT_YUV420P14LE; - pub const AV_PIX_FMT_YUV422P14: AVPixelFormat = AV_PIX_FMT_YUV422P14LE; - pub const AV_PIX_FMT_YUV444P14: AVPixelFormat = AV_PIX_FMT_YUV444P14LE; - pub const AV_PIX_FMT_YUV420P16: AVPixelFormat = AV_PIX_FMT_YUV420P16LE; - pub const AV_PIX_FMT_YUV422P16: AVPixelFormat = AV_PIX_FMT_YUV422P16LE; - pub const AV_PIX_FMT_YUV444P16: AVPixelFormat = AV_PIX_FMT_YUV444P16LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_GBRP9: AVPixelFormat = AV_PIX_FMT_GBRP9LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_GBRP10: AVPixelFormat = AV_PIX_FMT_GBRP10LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_GBRP12: AVPixelFormat = AV_PIX_FMT_GBRP12LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_GBRP14: AVPixelFormat = AV_PIX_FMT_GBRP14LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_GBRP16: AVPixelFormat = AV_PIX_FMT_GBRP16LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_GBRAP16: AVPixelFormat = AV_PIX_FMT_GBRAP16LE; - pub const AV_PIX_FMT_GBRP9: AVPixelFormat = AV_PIX_FMT_GBRP9LE; - pub const AV_PIX_FMT_GBRP10: AVPixelFormat = AV_PIX_FMT_GBRP10LE; - pub const AV_PIX_FMT_GBRP12: AVPixelFormat = AV_PIX_FMT_GBRP12LE; - pub const AV_PIX_FMT_GBRP14: AVPixelFormat = AV_PIX_FMT_GBRP14LE; - pub const AV_PIX_FMT_GBRP16: AVPixelFormat = AV_PIX_FMT_GBRP16LE; - pub const AV_PIX_FMT_GBRAP16: AVPixelFormat = AV_PIX_FMT_GBRAP16LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_BAYER_BGGR16: AVPixelFormat = AV_PIX_FMT_BAYER_BGGR16LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_BAYER_RGGB16: AVPixelFormat = AV_PIX_FMT_BAYER_RGGB16LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_BAYER_GBRG16: AVPixelFormat = AV_PIX_FMT_BAYER_GBRG16LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_BAYER_GRBG16: AVPixelFormat = AV_PIX_FMT_BAYER_GRBG16LE; - pub const AV_PIX_FMT_BAYER_BGGR16: AVPixelFormat = AV_PIX_FMT_BAYER_BGGR16LE; - pub const AV_PIX_FMT_BAYER_RGGB16: AVPixelFormat = AV_PIX_FMT_BAYER_RGGB16LE; - pub const AV_PIX_FMT_BAYER_GBRG16: AVPixelFormat = AV_PIX_FMT_BAYER_GBRG16LE; - pub const AV_PIX_FMT_BAYER_GRBG16: AVPixelFormat = AV_PIX_FMT_BAYER_GRBG16LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUVA420P9: AVPixelFormat = AV_PIX_FMT_YUVA420P9LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUVA422P9: AVPixelFormat = AV_PIX_FMT_YUVA422P9LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUVA444P9: AVPixelFormat = AV_PIX_FMT_YUVA444P9LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUVA420P10: AVPixelFormat = AV_PIX_FMT_YUVA420P10LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUVA422P10: AVPixelFormat = AV_PIX_FMT_YUVA422P10LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUVA444P10: AVPixelFormat = AV_PIX_FMT_YUVA444P10LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUVA420P16: AVPixelFormat = AV_PIX_FMT_YUVA420P16LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUVA422P16: AVPixelFormat = AV_PIX_FMT_YUVA422P16LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_YUVA444P16: AVPixelFormat = AV_PIX_FMT_YUVA444P16LE; - pub const AV_PIX_FMT_YUVA420P9: AVPixelFormat = AV_PIX_FMT_YUVA420P9LE; - pub const AV_PIX_FMT_YUVA422P9: AVPixelFormat = AV_PIX_FMT_YUVA422P9LE; - pub const AV_PIX_FMT_YUVA444P9: AVPixelFormat = AV_PIX_FMT_YUVA444P9LE; - pub const AV_PIX_FMT_YUVA420P10: AVPixelFormat = AV_PIX_FMT_YUVA420P10LE; - pub const AV_PIX_FMT_YUVA422P10: AVPixelFormat = AV_PIX_FMT_YUVA422P10LE; - pub const AV_PIX_FMT_YUVA444P10: AVPixelFormat = AV_PIX_FMT_YUVA444P10LE; - pub const AV_PIX_FMT_YUVA420P16: AVPixelFormat = AV_PIX_FMT_YUVA420P16LE; - pub const AV_PIX_FMT_YUVA422P16: AVPixelFormat = AV_PIX_FMT_YUVA422P16LE; - pub const AV_PIX_FMT_YUVA444P16: AVPixelFormat = AV_PIX_FMT_YUVA444P16LE; - - pub const AV_PIX_FMT_XYZ12: AVPixelFormat = AV_PIX_FMT_XYZ12LE; - pub const AV_PIX_FMT_NV20: AVPixelFormat = AV_PIX_FMT_NV20LE; - pub const AV_PIX_FMT_AYUV64: AVPixelFormat = AV_PIX_FMT_AYUV64LE; -} +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_XYZ12: AVPixelFormat = AV_PIX_FMT_XYZ12LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_NV20: AVPixelFormat = AV_PIX_FMT_NV20LE; +#[cfg(target_endian = "little")] +pub const AV_PIX_FMT_AYUV64: AVPixelFormat = AV_PIX_FMT_AYUV64LE; #[cfg(target_endian = "big")] -pub mod default { - use super::AVPixelFormat; - use super::AVPixelFormat::*; +pub const AV_PIX_FMT_RGB32: AVPixelFormat = AV_PIX_FMT_ARGB; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_RGB32_1: AVPixelFormat = AV_PIX_FMT_RGBA; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_BGR32: AVPixelFormat = AV_PIX_FMT_ABGR; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_BGR32_1: AVPixelFormat = AV_PIX_FMT_BGRA; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_0RGB32: AVPixelFormat = AV_PIX_FMT_0RGB; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_0BGR32: AVPixelFormat = AV_PIX_FMT_0BGR; - pub const AV_PIX_FMT_RGB32: AVPixelFormat = AV_PIX_FMT_ARGB; - pub const AV_PIX_FMT_RGB32_1: AVPixelFormat = AV_PIX_FMT_RGBA; - pub const AV_PIX_FMT_BGR32: AVPixelFormat = AV_PIX_FMT_ABGR; - pub const AV_PIX_FMT_BGR32_1: AVPixelFormat = AV_PIX_FMT_BGRA; - pub const AV_PIX_FMT_0RGB32: AVPixelFormat = AV_PIX_FMT_0RGB; - pub const AV_PIX_FMT_0BGR32: AVPixelFormat = AV_PIX_FMT_0BGR; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_GRAY16: AVPixelFormat = AV_PIX_FMT_GRAY16BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YA16: AVPixelFormat = AV_PIX_FMT_YA16BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_RGB48: AVPixelFormat = AV_PIX_FMT_RGB48BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_RGB565: AVPixelFormat = AV_PIX_FMT_RGB565BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_RGB555: AVPixelFormat = AV_PIX_FMT_RGB555BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_RGB444: AVPixelFormat = AV_PIX_FMT_RGB444BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_BGR48: AVPixelFormat = AV_PIX_FMT_BGR48BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_BGR565: AVPixelFormat = AV_PIX_FMT_BGR565BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_BGR555: AVPixelFormat = AV_PIX_FMT_BGR555BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_BGR444: AVPixelFormat = AV_PIX_FMT_BGR444BE; - pub const AV_PIX_FMT_GRAY16: AVPixelFormat = AV_PIX_FMT_GRAY16BE; - pub const AV_PIX_FMT_YA16: AVPixelFormat = AV_PIX_FMT_YA16BE; - pub const AV_PIX_FMT_RGB48: AVPixelFormat = AV_PIX_FMT_RGB48BE; - pub const AV_PIX_FMT_RGB565: AVPixelFormat = AV_PIX_FMT_RGB565BE; - pub const AV_PIX_FMT_RGB555: AVPixelFormat = AV_PIX_FMT_RGB555BE; - pub const AV_PIX_FMT_RGB444: AVPixelFormat = AV_PIX_FMT_RGB444BE; - pub const AV_PIX_FMT_BGR48: AVPixelFormat = AV_PIX_FMT_BGR48BE; - pub const AV_PIX_FMT_BGR565: AVPixelFormat = AV_PIX_FMT_BGR565BE; - pub const AV_PIX_FMT_BGR555: AVPixelFormat = AV_PIX_FMT_BGR555BE; - pub const AV_PIX_FMT_BGR444: AVPixelFormat = AV_PIX_FMT_BGR444BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUV420P9: AVPixelFormat = AV_PIX_FMT_YUV420P9BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUV422P9: AVPixelFormat = AV_PIX_FMT_YUV422P9BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUV444P9: AVPixelFormat = AV_PIX_FMT_YUV444P9BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUV420P10: AVPixelFormat = AV_PIX_FMT_YUV420P10BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUV422P10: AVPixelFormat = AV_PIX_FMT_YUV422P10BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUV440P10: AVPixelFormat = AV_PIX_FMT_YUV440P10BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUV444P10: AVPixelFormat = AV_PIX_FMT_YUV444P10BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUV420P12: AVPixelFormat = AV_PIX_FMT_YUV420P12BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUV422P12: AVPixelFormat = AV_PIX_FMT_YUV422P12BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUV440P12: AVPixelFormat = AV_PIX_FMT_YUV440P12BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUV444P12: AVPixelFormat = AV_PIX_FMT_YUV444P12BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUV420P14: AVPixelFormat = AV_PIX_FMT_YUV420P14BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUV422P14: AVPixelFormat = AV_PIX_FMT_YUV422P14BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUV444P14: AVPixelFormat = AV_PIX_FMT_YUV444P14BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUV420P16: AVPixelFormat = AV_PIX_FMT_YUV420P16BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUV422P16: AVPixelFormat = AV_PIX_FMT_YUV422P16BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUV444P16: AVPixelFormat = AV_PIX_FMT_YUV444P16BE; - pub const AV_PIX_FMT_YUV420P9: AVPixelFormat = AV_PIX_FMT_YUV420P9BE; - pub const AV_PIX_FMT_YUV422P9: AVPixelFormat = AV_PIX_FMT_YUV422P9BE; - pub const AV_PIX_FMT_YUV444P9: AVPixelFormat = AV_PIX_FMT_YUV444P9BE; - pub const AV_PIX_FMT_YUV420P10: AVPixelFormat = AV_PIX_FMT_YUV420P10BE; - pub const AV_PIX_FMT_YUV422P10: AVPixelFormat = AV_PIX_FMT_YUV422P10BE; - pub const AV_PIX_FMT_YUV440P10: AVPixelFormat = AV_PIX_FMT_YUV440P10BE; - pub const AV_PIX_FMT_YUV444P10: AVPixelFormat = AV_PIX_FMT_YUV444P10BE; - pub const AV_PIX_FMT_YUV420P12: AVPixelFormat = AV_PIX_FMT_YUV420P12BE; - pub const AV_PIX_FMT_YUV422P12: AVPixelFormat = AV_PIX_FMT_YUV422P12BE; - pub const AV_PIX_FMT_YUV440P12: AVPixelFormat = AV_PIX_FMT_YUV440P12BE; - pub const AV_PIX_FMT_YUV444P12: AVPixelFormat = AV_PIX_FMT_YUV444P12BE; - pub const AV_PIX_FMT_YUV420P14: AVPixelFormat = AV_PIX_FMT_YUV420P14BE; - pub const AV_PIX_FMT_YUV422P14: AVPixelFormat = AV_PIX_FMT_YUV422P14BE; - pub const AV_PIX_FMT_YUV444P14: AVPixelFormat = AV_PIX_FMT_YUV444P14BE; - pub const AV_PIX_FMT_YUV420P16: AVPixelFormat = AV_PIX_FMT_YUV420P16BE; - pub const AV_PIX_FMT_YUV422P16: AVPixelFormat = AV_PIX_FMT_YUV422P16BE; - pub const AV_PIX_FMT_YUV444P16: AVPixelFormat = AV_PIX_FMT_YUV444P16BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_GBRP9: AVPixelFormat = AV_PIX_FMT_GBRP9BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_GBRP10: AVPixelFormat = AV_PIX_FMT_GBRP10BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_GBRP12: AVPixelFormat = AV_PIX_FMT_GBRP12BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_GBRP14: AVPixelFormat = AV_PIX_FMT_GBRP14BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_GBRP16: AVPixelFormat = AV_PIX_FMT_GBRP16BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_GBRAP16: AVPixelFormat = AV_PIX_FMT_GBRAP16BE; - pub const AV_PIX_FMT_GBRP9: AVPixelFormat = AV_PIX_FMT_GBRP9BE; - pub const AV_PIX_FMT_GBRP10: AVPixelFormat = AV_PIX_FMT_GBRP10BE; - pub const AV_PIX_FMT_GBRP12: AVPixelFormat = AV_PIX_FMT_GBRP12BE; - pub const AV_PIX_FMT_GBRP14: AVPixelFormat = AV_PIX_FMT_GBRP14BE; - pub const AV_PIX_FMT_GBRP16: AVPixelFormat = AV_PIX_FMT_GBRP16BE; - pub const AV_PIX_FMT_GBRAP16: AVPixelFormat = AV_PIX_FMT_GBRAP16BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_BAYER_BGGR16: AVPixelFormat = AV_PIX_FMT_BAYER_BGGR16BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_BAYER_RGGB16: AVPixelFormat = AV_PIX_FMT_BAYER_RGGB16BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_BAYER_GBRG16: AVPixelFormat = AV_PIX_FMT_BAYER_GBRG16BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_BAYER_GRBG16: AVPixelFormat = AV_PIX_FMT_BAYER_GRBG16BE; - pub const AV_PIX_FMT_BAYER_BGGR16: AVPixelFormat = AV_PIX_FMT_BAYER_BGGR16BE; - pub const AV_PIX_FMT_BAYER_RGGB16: AVPixelFormat = AV_PIX_FMT_BAYER_RGGB16BE; - pub const AV_PIX_FMT_BAYER_GBRG16: AVPixelFormat = AV_PIX_FMT_BAYER_GBRG16BE; - pub const AV_PIX_FMT_BAYER_GRBG16: AVPixelFormat = AV_PIX_FMT_BAYER_GRBG16BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUVA420P9: AVPixelFormat = AV_PIX_FMT_YUVA420P9BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUVA422P9: AVPixelFormat = AV_PIX_FMT_YUVA422P9BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUVA444P9: AVPixelFormat = AV_PIX_FMT_YUVA444P9BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUVA420P10: AVPixelFormat = AV_PIX_FMT_YUVA420P10BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUVA422P10: AVPixelFormat = AV_PIX_FMT_YUVA422P10BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUVA444P10: AVPixelFormat = AV_PIX_FMT_YUVA444P10BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUVA420P16: AVPixelFormat = AV_PIX_FMT_YUVA420P16BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUVA422P16: AVPixelFormat = AV_PIX_FMT_YUVA422P16BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_YUVA444P16: AVPixelFormat = AV_PIX_FMT_YUVA444P16BE; - pub const AV_PIX_FMT_YUVA420P9: AVPixelFormat = AV_PIX_FMT_YUVA420P9BE; - pub const AV_PIX_FMT_YUVA422P9: AVPixelFormat = AV_PIX_FMT_YUVA422P9BE; - pub const AV_PIX_FMT_YUVA444P9: AVPixelFormat = AV_PIX_FMT_YUVA444P9BE; - pub const AV_PIX_FMT_YUVA420P10: AVPixelFormat = AV_PIX_FMT_YUVA420P10BE; - pub const AV_PIX_FMT_YUVA422P10: AVPixelFormat = AV_PIX_FMT_YUVA422P10BE; - pub const AV_PIX_FMT_YUVA444P10: AVPixelFormat = AV_PIX_FMT_YUVA444P10BE; - pub const AV_PIX_FMT_YUVA420P16: AVPixelFormat = AV_PIX_FMT_YUVA420P16BE; - pub const AV_PIX_FMT_YUVA422P16: AVPixelFormat = AV_PIX_FMT_YUVA422P16BE; - pub const AV_PIX_FMT_YUVA444P16: AVPixelFormat = AV_PIX_FMT_YUVA444P16BE; - - pub const AV_PIX_FMT_XYZ12: AVPixelFormat = AV_PIX_FMT_XYZ12BE; - pub const AV_PIX_FMT_NV20: AVPixelFormat = AV_PIX_FMT_NV20BE; - pub const AV_PIX_FMT_AYUV64: AVPixelFormat = AV_PIX_FMT_AYUV64BE; -} - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVColorPrimaries { - AVCOL_PRI_RESERVED0 = 0, - AVCOL_PRI_BT709 = 1, - AVCOL_PRI_UNSPECIFIED = 2, - AVCOL_PRI_RESERVED = 3, - AVCOL_PRI_BT470M = 4, - - AVCOL_PRI_BT470BG = 5, - AVCOL_PRI_SMPTE170M = 6, - AVCOL_PRI_SMPTE240M = 7, - AVCOL_PRI_FILM = 8, - AVCOL_PRI_BT2020 = 9, - AVCOL_PRI_NB, -} - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVColorTransferCharacteristic { - AVCOL_TRC_RESERVED0 = 0, - AVCOL_TRC_BT709 = 1, - AVCOL_TRC_UNSPECIFIED = 2, - AVCOL_TRC_RESERVED = 3, - AVCOL_TRC_GAMMA22 = 4, - AVCOL_TRC_GAMMA28 = 5, - AVCOL_TRC_SMPTE170M = 6, - AVCOL_TRC_SMPTE240M = 7, - AVCOL_TRC_LINEAR = 8, - AVCOL_TRC_LOG = 9, - AVCOL_TRC_LOG_SQRT = 10, - AVCOL_TRC_IEC61966_2_4 = 11, - AVCOL_TRC_BT1361_ECG = 12, - AVCOL_TRC_IEC61966_2_1 = 13, - AVCOL_TRC_BT2020_10 = 14, - AVCOL_TRC_BT2020_12 = 15, - AVCOL_TRC_NB, -} - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVColorSpace { - AVCOL_SPC_RGB = 0, - AVCOL_SPC_BT709 = 1, - AVCOL_SPC_UNSPECIFIED = 2, - AVCOL_SPC_RESERVED = 3, - AVCOL_SPC_FCC = 4, - AVCOL_SPC_BT470BG = 5, - AVCOL_SPC_SMPTE170M = 6, - AVCOL_SPC_SMPTE240M = 7, - AVCOL_SPC_YCOCG = 8, - AVCOL_SPC_BT2020_NCL = 9, - AVCOL_SPC_BT2020_CL = 10, - AVCOL_SPC_NB, -} - -pub const AVCOL_SPC_YCGCO: AVColorSpace = AVColorSpace::AVCOL_SPC_YCOCG; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVColorRange { - AVCOL_RANGE_UNSPECIFIED = 0, - AVCOL_RANGE_MPEG = 1, - AVCOL_RANGE_JPEG = 2, - AVCOL_RANGE_NB, -} - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVChromaLocation { - AVCHROMA_LOC_UNSPECIFIED = 0, - AVCHROMA_LOC_LEFT = 1, - AVCHROMA_LOC_CENTER = 2, - AVCHROMA_LOC_TOPLEFT = 3, - AVCHROMA_LOC_TOP = 4, - AVCHROMA_LOC_BOTTOMLEFT = 5, - AVCHROMA_LOC_BOTTOM = 6, - AVCHROMA_LOC_NB, -} +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_XYZ12: AVPixelFormat = AV_PIX_FMT_XYZ12BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_NV20: AVPixelFormat = AV_PIX_FMT_NV20BE; +#[cfg(target_endian = "big")] +pub const AV_PIX_FMT_AYUV64: AVPixelFormat = AV_PIX_FMT_AYUV64BE; diff --git a/sys/src/avutil/random_seed.rs b/sys/src/avutil/random_seed.rs deleted file mode 100644 index ad7543b..0000000 --- a/sys/src/avutil/random_seed.rs +++ /dev/null @@ -1,5 +0,0 @@ -use libc::uint32_t; - -extern { - pub fn av_get_random_seed() -> uint32_t; -} diff --git a/sys/src/avutil/rational.rs b/sys/src/avutil/rational.rs index 38f89ee..dd0c2bc 100644 --- a/sys/src/avutil/rational.rs +++ b/sys/src/avutil/rational.rs @@ -1,53 +1,41 @@ -use libc::{c_int, uint32_t, int64_t, c_double}; +use libc::{c_int, int64_t, c_double}; #[derive(Eq, PartialEq, Copy, Clone, Debug)] #[repr(C)] pub struct AVRational { - pub num: c_int, - pub den: c_int, + pub num: c_int, + pub den: c_int, } #[inline(always)] pub unsafe fn av_make_q(num: c_int, den: c_int) -> AVRational { - AVRational { num: num, den: den } + AVRational { num: num, den: den } } #[inline(always)] pub unsafe fn av_cmp_q(a: AVRational, b: AVRational) -> c_int { - let tmp: int64_t = a.num as int64_t * b.den as int64_t - b.num as int64_t * a.den as int64_t; + let tmp: int64_t = a.num as int64_t * b.den as int64_t - b.num as int64_t * a.den as int64_t; - if tmp != 0 { - (((tmp ^ a.den as int64_t ^ b.den as int64_t) >> 63) | 1) as c_int - } - else if b.den != 0 && a.den != 0 { - 0 - } - else if a.num != 0 && b.num != 0 { - ((a.num as int64_t >> 31) - (b.num as int64_t >> 31)) as c_int - } - else { - c_int::min_value() - } + if tmp != 0 { + (((tmp ^ a.den as int64_t ^ b.den as int64_t) >> 63) | 1) as c_int + } else if b.den != 0 && a.den != 0 { + 0 + } else if a.num != 0 && b.num != 0 { + ((a.num as int64_t >> 31) - (b.num as int64_t >> 31)) as c_int + } else { + c_int::min_value() + } } #[inline(always)] pub unsafe fn av_q2d(a: AVRational) -> c_double { - a.num as c_double / a.den as c_double + a.num as c_double / a.den as c_double } #[inline(always)] pub unsafe fn av_inv_q(q: AVRational) -> AVRational { - AVRational { num: q.den, den: q.num } -} - -extern { - pub fn av_reduce(dst_num: *mut c_int, dst_den: *mut c_int, num: int64_t, den: int64_t, max: int64_t) -> c_int; - pub fn av_mul_q(b: AVRational, c: AVRational) -> AVRational; - pub fn av_div_q(b: AVRational, c: AVRational) -> AVRational; - pub fn av_add_q(b: AVRational, c: AVRational) -> AVRational; - pub fn av_sub_q(b: AVRational, c: AVRational) -> AVRational; - pub fn av_d2q(d: c_double, max: c_int) -> AVRational; - pub fn av_nearer_q(q: AVRational, q1: AVRational, q2: AVRational) -> c_int; - pub fn av_find_nearest_q_idx(q: AVRational, q_list: *const AVRational) -> c_int; - pub fn av_q2intfloat(q: AVRational) -> uint32_t; + AVRational { + num: q.den, + den: q.num, + } } diff --git a/sys/src/avutil/replaygain.rs b/sys/src/avutil/replaygain.rs deleted file mode 100644 index 764b6c9..0000000 --- a/sys/src/avutil/replaygain.rs +++ /dev/null @@ -1,10 +0,0 @@ -use libc::{int32_t, uint32_t}; - -#[derive(Debug)] -#[repr(C)] -pub struct AVReplayGain { - pub track_gain: int32_t, - pub track_peak: uint32_t, - pub album_gain: int32_t, - pub album_peak: uint32_t, -} diff --git a/sys/src/avutil/ripemd.rs b/sys/src/avutil/ripemd.rs deleted file mode 100644 index 83e238d..0000000 --- a/sys/src/avutil/ripemd.rs +++ /dev/null @@ -1,11 +0,0 @@ -use libc::{c_void, c_int, c_uint, uint8_t}; - -pub type AVRIPEMD = c_void; - -extern { - pub static av_ripemd_size: c_int; - - pub fn av_ripemd_init(context: *mut AVRIPEMD, bits: c_int) -> c_int; - pub fn av_ripemd_update(context: *mut AVRIPEMD, data: *const uint8_t, len: c_uint); - pub fn av_ripemd_final(context: *mut AVRIPEMD, digest: *mut uint8_t); -} diff --git a/sys/src/avutil/samplefmt.rs b/sys/src/avutil/samplefmt.rs deleted file mode 100644 index e5b5dd4..0000000 --- a/sys/src/avutil/samplefmt.rs +++ /dev/null @@ -1,37 +0,0 @@ -use libc::{c_char, c_int, uint8_t}; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVSampleFormat { - AV_SAMPLE_FMT_NONE = -1, - AV_SAMPLE_FMT_U8, - AV_SAMPLE_FMT_S16, - AV_SAMPLE_FMT_S32, - AV_SAMPLE_FMT_FLT, - AV_SAMPLE_FMT_DBL, - - AV_SAMPLE_FMT_U8P, - AV_SAMPLE_FMT_S16P, - AV_SAMPLE_FMT_S32P, - AV_SAMPLE_FMT_FLTP, - AV_SAMPLE_FMT_DBLP, - - AV_SAMPLE_FMT_NB -} - -extern { - pub fn av_get_sample_fmt_name(sample_fmt: AVSampleFormat) -> *const c_char; - pub fn av_get_sample_fmt(name: *const c_char) -> AVSampleFormat; - pub fn av_get_alt_sample_fmt(sample_fmt: AVSampleFormat, planar: c_int) -> AVSampleFormat; - pub fn av_get_packed_sample_fmt(sample_fmt: AVSampleFormat) -> AVSampleFormat; - pub fn av_get_planar_sample_fmt(sample_fmt: AVSampleFormat) -> AVSampleFormat; - pub fn av_get_sample_fmt_string(buf: *mut c_char, buf_size: c_int, sample_fmt: AVSampleFormat) -> *mut c_char; - pub fn av_get_bytes_per_sample(sample_fmt: AVSampleFormat) -> c_int; - pub fn av_sample_fmt_is_planar(sample_fmt: AVSampleFormat) -> c_int; - pub fn av_samples_get_buffer_size(linesize: *mut c_int, nb_channels: c_int, nb_samples: c_int, sample_fmt: AVSampleFormat, align: c_int) -> c_int; - pub fn av_samples_fill_arrays(audio_data: *mut *mut uint8_t, linesize: *mut c_int, buf: *const uint8_t, nb_channels: c_int, nb_samples: c_int, sample_fmt: AVSampleFormat, align: c_int) -> c_int; - pub fn av_samples_alloc(audio_data: *mut *mut uint8_t, linesize: *mut c_int, nb_channels: c_int, nb_samples: c_int, sample_fmt: AVSampleFormat, align: c_int) -> c_int; - pub fn av_samples_alloc_array_and_samples(audio_data: *mut *mut *mut uint8_t, linesize: *mut c_int, nb_channels: c_int, nb_samples: c_int, sample_fmt: AVSampleFormat, align: c_int) -> c_int; - pub fn av_samples_copy(dst: *mut *mut uint8_t, src: *mut *const uint8_t, dst_offset: c_int, src_offset: c_int, nb_samples: c_int, nb_channels: c_int, sample_fmt: AVSampleFormat) -> c_int; - pub fn av_samples_set_silence(audio_data: *mut *mut uint8_t, offset: c_int, nb_samples: c_int, nb_channels: c_int, sample_fmt: AVSampleFormat) -> c_int; -} diff --git a/sys/src/avutil/sha.rs b/sys/src/avutil/sha.rs deleted file mode 100644 index 721f72f..0000000 --- a/sys/src/avutil/sha.rs +++ /dev/null @@ -1,12 +0,0 @@ -use libc::{c_void, c_int, c_uint, uint8_t}; - -pub type AVSHA = c_void; - -extern { - pub static av_sha_size: c_int; - - pub fn av_sha_alloc() -> *mut AVSHA; - pub fn av_sha_init(context: *mut AVSHA, bits: c_int) -> c_int; - pub fn av_sha_update(context: *mut AVSHA, data: *const uint8_t, len: c_uint); - pub fn av_sha_final(context: *mut AVSHA, digest: *mut uint8_t); -} diff --git a/sys/src/avutil/sha512.rs b/sys/src/avutil/sha512.rs deleted file mode 100644 index d9dd740..0000000 --- a/sys/src/avutil/sha512.rs +++ /dev/null @@ -1,12 +0,0 @@ -use libc::{c_void, c_int, c_uint, uint8_t}; - -pub type AVSHA512 = c_void; - -extern { - pub static av_sha512_size: c_int; - - pub fn av_sha512_alloc() -> *mut AVSHA512; - pub fn av_sha512_init(context: *mut AVSHA512, bits: c_int) -> c_int; - pub fn av_sha512_update(context: *mut AVSHA512, data: *const uint8_t, len: c_uint); - pub fn av_sha512_final(context: *mut AVSHA512, digest: *mut uint8_t); -} diff --git a/sys/src/avutil/stereo3d.rs b/sys/src/avutil/stereo3d.rs deleted file mode 100644 index 0b6393d..0000000 --- a/sys/src/avutil/stereo3d.rs +++ /dev/null @@ -1,29 +0,0 @@ -use libc::{c_int}; -use super::frame::AVFrame; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVStereo3DType { - AV_STEREO3D_2D, - AV_STEREO3D_SIDEBYSIDE, - AV_STEREO3D_TOPBOTTOM, - AV_STEREO3D_FRAMESEQUENCE, - AV_STEREO3D_CHECKERBOARD, - AV_STEREO3D_SIDEBYSIDE_QUINCUNX, - AV_STEREO3D_LINES, - AV_STEREO3D_COLUMNS, -} - -pub const AV_STEREO3D_FLAG_INVERT: c_int = 1 << 0; - -#[derive(Debug)] -#[repr(C)] -pub struct AVStereo3D { - pub kind: AVStereo3DType, - pub flags: c_int, -} - -extern { - pub fn av_stereo3d_alloc() -> *mut AVStereo3D; - pub fn av_stereo3d_create_side_data(frame: *mut AVFrame) -> *mut AVStereo3D; -} diff --git a/sys/src/avutil/string.rs b/sys/src/avutil/string.rs deleted file mode 100644 index 2d10b30..0000000 --- a/sys/src/avutil/string.rs +++ /dev/null @@ -1,83 +0,0 @@ -use libc::{c_char, c_int, c_uint, uint8_t, int32_t, size_t, c_double}; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVEscapeMode { - AV_ESCAPE_MODE_AUTO, - AV_ESCAPE_MODE_BACKSLASH, - AV_ESCAPE_MODE_QUOTE, -} - -pub const AV_ESCAPE_FLAG_WHITESPACE: c_int = 0x01; -pub const AV_ESCAPE_FLAG_STRICT: c_int = 0x02; - -pub const AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES: c_uint = 1; -pub const AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS: c_uint = 2; -pub const AV_UTF8_FLAG_ACCEPT_SURROGATES: c_uint = 4; -pub const AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES: c_uint = 8; -pub const AV_UTF8_FLAG_ACCEPT_ALL: c_uint = AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES | AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS | AV_UTF8_FLAG_ACCEPT_SURROGATES; - - -#[inline(always)] -pub unsafe fn av_strnlen(s: *const c_char, len: size_t) -> size_t { - let mut result = 0; - let mut ptr = s; - - while result < len && *ptr != 0 { - ptr = ptr.offset(1); - result += 1; - } - - result -} - -#[inline(always)] -pub unsafe fn av_toupper(c: c_int) -> c_int { - if c >= b'a' as c_int && c <= b'z' as c_int { - c ^ 0x20 - } - else { - c - } -} - -#[inline(always)] -pub unsafe fn av_tolower(c: c_int) -> c_int { - if c >= b'A' as c_int && c <= b'Z' as c_int { - c ^ 0x20 - } - else { - c - } -} - -extern { - pub fn av_strstart(string: *const c_char, pfx: *const c_char, ptr: *const *const c_char) -> c_int; - pub fn av_stristart(string: *const c_char, pfx: *const c_char, ptr: *const *const c_char) -> c_int; - pub fn av_stristr(haystack: *const c_char, needle: *const c_char) -> *mut c_char; - pub fn av_strnstr(haystack: *const c_char, needle: *const c_char, hay_length: size_t) -> *mut c_char; - pub fn av_strlcpy(dst: *mut c_char, src: *const c_char, size: size_t) -> size_t; - pub fn av_strlcat(dst: *mut c_char, src: *const c_char, size: size_t) -> size_t; - pub fn av_strlcatf(dst: *mut c_char, size: size_t, fmt: *const c_char, ...) -> size_t; - pub fn av_asprintf(fmt: *const c_char, ...) -> *mut c_char; - pub fn av_d2str(d: c_double) -> *mut c_char; - pub fn av_get_token(buf: *const *const c_char, term: *const c_char) -> *mut c_char; - pub fn av_strtok(s: *mut c_char, delim: *const c_char, saveptr: *mut *mut c_char) -> *mut c_char; - - pub fn av_isdigit(c: c_int) -> c_int; - pub fn av_isgraph(c: c_int) -> c_int; - pub fn av_isspace(c: c_int) -> c_int; - pub fn av_isxdigit(c: c_int) -> c_int; - - pub fn av_strcasecmp(a: *const c_char, b: *const c_char) -> c_int; - pub fn av_strncasecmp(a: *const c_char, b: *const c_char, n: size_t) -> c_int; - - pub fn av_basename(path: *const c_char) -> *const c_char; - pub fn av_dirname(path: *mut c_char) -> *const c_char; - - pub fn av_match_name(name: *const c_char, names: *const c_char) -> c_int; - pub fn av_append_path_component(path: *const c_char, component: *const c_char) -> *mut c_char; - pub fn av_escape(dst: *mut *mut c_char, src: *const c_char, special_chars: *const c_char, mode: AVEscapeMode, flags: c_int) -> c_int; - pub fn av_utf8_decode(codep: *mut int32_t, bufp: *const *const uint8_t, buf_end: *const uint8_t, flags: c_uint) -> c_int; - pub fn av_match_list(name: *const c_char, list: *const c_char, separator: c_char) -> c_int; -} diff --git a/sys/src/avutil/threadmessage.rs b/sys/src/avutil/threadmessage.rs deleted file mode 100644 index ac46032..0000000 --- a/sys/src/avutil/threadmessage.rs +++ /dev/null @@ -1,14 +0,0 @@ -use libc::{c_void, c_int, c_uint}; - -pub type AVThreadMessageQueue = c_void; - -pub const AV_THREAD_MESSAGE_NONBLOCK: c_uint = 1; - -extern { - pub fn av_thread_message_queue_alloc(mq: *mut *mut AVThreadMessageQueue, nelem: c_uint, elsize: c_uint) -> c_int; - pub fn av_thread_message_queue_free(mq: *mut *mut AVThreadMessageQueue); - pub fn av_thread_message_queue_send(mq: *mut AVThreadMessageQueue, msg: *mut c_void, flags: c_uint) -> c_int; - pub fn av_thread_message_queue_recv(mq: *mut AVThreadMessageQueue, msg: *mut c_void, flags: c_uint) -> c_int; - pub fn av_thread_message_queue_set_err_send(mq: *mut AVThreadMessageQueue, err: c_int); - pub fn av_thread_message_queue_set_err_recv(mq: *mut AVThreadMessageQueue, err: c_int); -} diff --git a/sys/src/avutil/time.rs b/sys/src/avutil/time.rs deleted file mode 100644 index c288545..0000000 --- a/sys/src/avutil/time.rs +++ /dev/null @@ -1,8 +0,0 @@ -use libc::{c_int, c_uint, int64_t}; - -extern { - pub fn av_gettime() -> int64_t; - pub fn av_gettime_relative() -> int64_t; - pub fn av_gettime_relative_is_monotonic() -> c_int; - pub fn av_usleep(usec: c_uint) -> c_int; -} diff --git a/sys/src/avutil/timecode.rs b/sys/src/avutil/timecode.rs deleted file mode 100644 index ddc2eac..0000000 --- a/sys/src/avutil/timecode.rs +++ /dev/null @@ -1,26 +0,0 @@ -use libc::{c_void, c_char, c_int, c_uint, uint32_t}; -use super::rational::AVRational; - -pub const AV_TIMECODE_FLAG_DROPFRAME: uint32_t = 1 << 0; -pub const AV_TIMECODE_FLAG_24HOURSMAX: uint32_t = 1 << 1; -pub const AV_TIMECODE_FLAG_ALLOWNEGATIVE: uint32_t = 1 << 2; - -#[derive(Debug)] -#[repr(C)] -pub struct AVTimecode { - pub start: c_int, - pub flags: uint32_t, - pub rate: AVRational, - pub fps: c_uint, -} - -extern { - pub fn av_timecode_adjust_ntsc_framenum2(framenum: c_int, fps: c_int) -> c_int; - pub fn av_timecode_get_smpte_from_framenum(tc: *const AVTimecode, framenum: c_int) -> uint32_t; - pub fn av_timecode_make_string(tc: *const AVTimecode, buf: *mut c_char, framenum: c_int) -> *mut c_char; - pub fn av_timecode_make_smpte_tc_string(buf: *mut c_char, tcsmpte: uint32_t, prevent_df: c_int) -> *mut c_char; - pub fn av_timecode_make_mpeg_tc_string(buf: *mut c_char, tc25bit: uint32_t) -> *mut c_char; - pub fn av_timecode_init(tc: *mut AVTimecode, rate: AVRational, flags: c_int, frame_start: c_int, log_ctx: *mut c_void) -> c_int; - pub fn av_timecode_init_from_string(tc: *mut AVTimecode, rate: AVRational, string: *const c_char, log_ctx: *mut c_void) -> c_int; - pub fn av_timecode_check_frame_rate(rate: AVRational) -> c_int; -} diff --git a/sys/src/avutil/twofish.rs b/sys/src/avutil/twofish.rs deleted file mode 100644 index 3d2cff0..0000000 --- a/sys/src/avutil/twofish.rs +++ /dev/null @@ -1,11 +0,0 @@ -use libc::{c_void, c_int, uint8_t}; - -pub type AVTWOFISH = c_void; - -extern { - pub static av_twofish_size: c_int; - - pub fn av_twofish_alloc() -> *mut AVTWOFISH; - pub fn av_twofish_init(ctx: *mut AVTWOFISH, key: *const uint8_t, key_bits: c_int) -> c_int; - pub fn av_twofish_crypt(ctx: *mut AVTWOFISH, dst: *mut uint8_t, src: *const uint8_t, count: c_int, iv: *mut uint8_t, decrypt: c_int); -} diff --git a/sys/src/avutil/util.rs b/sys/src/avutil/util.rs index cff7ef1..201d076 100644 --- a/sys/src/avutil/util.rs +++ b/sys/src/avutil/util.rs @@ -1,51 +1,8 @@ -use libc::{c_int, c_uint, c_char, int64_t}; -use super::rational::AVRational; +use libc::{c_int, int64_t}; +use {AVRational, AV_TIME_BASE}; -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVMediaType { - AVMEDIA_TYPE_UNKNOWN = -1, - AVMEDIA_TYPE_VIDEO, - AVMEDIA_TYPE_AUDIO, - AVMEDIA_TYPE_DATA, - AVMEDIA_TYPE_SUBTITLE, - AVMEDIA_TYPE_ATTACHMENT, - AVMEDIA_TYPE_NB -} - -pub const FF_LAMBDA_SHIFT: c_int = 7; -pub const FF_LAMBDA_SCALE: c_int = 1 << FF_LAMBDA_SHIFT; -pub const FF_QP2LAMBDA: c_int = 118; -pub const FF_LAMBDA_MAX: c_int = 256 * 128 - 1; - -pub const FF_QUALITY_SCALE: c_int = FF_LAMBDA_SCALE; - -pub const AV_NOPTS_VALUE: int64_t = 0x8000000000000000u64 as int64_t; -pub const AV_TIME_BASE: int64_t = 1000000; -pub const AV_TIME_BASE_Q: AVRational = AVRational { num: 1, den: AV_TIME_BASE as c_int }; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum AVPictureType { - AV_PICTURE_TYPE_NONE = 0, - AV_PICTURE_TYPE_I, - AV_PICTURE_TYPE_P, - AV_PICTURE_TYPE_B, - AV_PICTURE_TYPE_S, - AV_PICTURE_TYPE_SI, - AV_PICTURE_TYPE_SP, - AV_PICTURE_TYPE_BI, -} - -extern { - pub fn avutil_version() -> c_uint; - - pub fn av_version_info() -> *const c_char; - pub fn avutil_configuration() -> *const c_char; - pub fn avutil_license() -> *const c_char; - - pub fn av_get_media_type_string(media_type: AVMediaType) -> *const c_char; - pub fn av_get_picture_type_char(pict_type: AVPictureType) -> c_char; - - pub fn av_get_time_base_q() -> AVRational; -} +pub const AV_NOPTS_VALUE: int64_t = 0x8000000000000000u64 as int64_t; +pub const AV_TIME_BASE_Q: AVRational = AVRational { + num: 1, + den: AV_TIME_BASE as c_int, +}; diff --git a/sys/src/avutil/xtea.rs b/sys/src/avutil/xtea.rs deleted file mode 100644 index 579f1b9..0000000 --- a/sys/src/avutil/xtea.rs +++ /dev/null @@ -1,13 +0,0 @@ -use libc::{c_int, uint8_t, uint32_t}; - -#[derive(Debug)] -#[repr(C)] -pub struct AVXTEA { - pub key: [uint32_t; 16], -} - -extern { - pub fn av_xtea_alloc() -> *mut AVXTEA; - pub fn av_xtea_init(ctx: *mut AVXTEA, key: *const uint8_t); - pub fn av_xtea_crypt(ctx: *mut AVXTEA, dst: *mut uint8_t, src: *const uint8_t, count: c_int, iv: *mut uint8_t, decrypt: c_int); -} diff --git a/sys/src/lib.rs b/sys/src/lib.rs index e260baf..72bc1e9 100644 --- a/sys/src/lib.rs +++ b/sys/src/lib.rs @@ -1,47 +1,11 @@ -#![allow(non_camel_case_types, non_snake_case, non_upper_case_globals)] +#![allow(non_upper_case_globals)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] extern crate libc; +include!(concat!(env!("OUT_DIR"), "/bindings.rs")); + #[macro_use] mod avutil; pub use avutil::*; - -#[cfg(feature = "avcodec")] -mod avcodec; -#[cfg(feature = "avcodec")] -pub use avcodec::*; - -#[cfg(feature = "avdevice")] -mod avdevice; -#[cfg(feature = "avdevice")] -pub use avdevice::*; - -#[cfg(feature = "avformat")] -mod avformat; -#[cfg(feature = "avformat")] -pub use avformat::*; - -#[cfg(feature = "avfilter")] -mod avfilter; -#[cfg(feature = "avfilter")] -pub use avfilter::*; - -#[cfg(feature = "avresample")] -mod avresample; -#[cfg(feature = "avresample")] -pub use avresample::*; - -#[cfg(feature = "postproc")] -mod postproc; -#[cfg(feature = "postproc")] -pub use postproc::*; - -#[cfg(feature = "swresample")] -mod swresample; -#[cfg(feature = "swresample")] -pub use swresample::*; - -#[cfg(feature = "swscale")] -mod swscale; -#[cfg(feature = "swscale")] -pub use swscale::*; diff --git a/sys/src/postproc/mod.rs b/sys/src/postproc/mod.rs deleted file mode 100644 index a108768..0000000 --- a/sys/src/postproc/mod.rs +++ /dev/null @@ -1,6 +0,0 @@ -mod postproc; -pub use self::postproc::*; - -#[cfg_attr(feature = "static", link(name = "postproc", kind = "static"))] -#[cfg_attr(not(feature = "static"), link(name = "postproc"))] -extern { } diff --git a/sys/src/postproc/postproc.rs b/sys/src/postproc/postproc.rs deleted file mode 100644 index 57a2392..0000000 --- a/sys/src/postproc/postproc.rs +++ /dev/null @@ -1,36 +0,0 @@ -use libc::{c_void, c_char, c_int, c_uint, int8_t, uint8_t}; - -pub type pp_context = c_void; -pub type pp_mode = c_void; -pub type QP_STORE_T = int8_t; - -pub const PP_QUALITY_MAX: c_int = 6; - -pub const PP_CPU_CAPS_MMX: c_uint = 0x80000000; -pub const PP_CPU_CAPS_MMX2: c_uint = 0x20000000; -pub const PP_CPU_CAPS_3DNOW: c_uint = 0x40000000; -pub const PP_CPU_CAPS_ALTIVEC: c_uint = 0x10000000; -pub const PP_CPU_CAPS_AUTO: c_uint = 0x00080000; - -pub const PP_FORMAT: c_int = 0x00000008; -pub const PP_FORMAT_420: c_int = 0x00000011 | PP_FORMAT; -pub const PP_FORMAT_422: c_int = 0x00000001 | PP_FORMAT; -pub const PP_FORMAT_411: c_int = 0x00000002 | PP_FORMAT; -pub const PP_FORMAT_444: c_int = 0x00000000 | PP_FORMAT; -pub const PP_FORMAT_440: c_int = 0x00000010 | PP_FORMAT; - -pub const PP_PICT_TYPE_QP2: c_int = 0x00000010; - -extern { - pub fn postproc_version() -> c_uint; - pub fn postproc_configuration() -> *const c_char; - pub fn postproc_license() -> *const c_char; - - pub fn pp_postprocess(src: *const *const uint8_t, srcStride: *const *const c_int, dst: *mut *mut uint8_t, dstStride: *mut *mut c_int, horizontalSize: c_int, verticalSize: c_int, QP_store: *const QP_STORE_T, QP_stride: c_int, mode: *mut pp_mode, ppContext: *mut pp_context, pict_type: c_int); - - pub fn pp_get_mode_by_name_and_quality(name: *const c_char, quality: c_int) -> *mut pp_mode; - pub fn pp_free_mode(mode: *mut pp_mode); - - pub fn pp_get_context(width: c_int, height: c_int, flags: c_int) -> *mut pp_context; - pub fn pp_free_context(ppContext: *mut pp_context); -} diff --git a/sys/src/swresample/mod.rs b/sys/src/swresample/mod.rs deleted file mode 100644 index c700513..0000000 --- a/sys/src/swresample/mod.rs +++ /dev/null @@ -1,9 +0,0 @@ -mod resample; -pub use self::resample::*; -pub use self::resample::SwrDitherType::*; -pub use self::resample::SwrEngine::*; -pub use self::resample::SwrFilterType::*; - -#[cfg_attr(feature = "static", link(name = "swresample", kind = "static"))] -#[cfg_attr(not(feature = "static"), link(name = "swresample"))] -extern { } diff --git a/sys/src/swresample/resample.rs b/sys/src/swresample/resample.rs deleted file mode 100644 index d8faeae..0000000 --- a/sys/src/swresample/resample.rs +++ /dev/null @@ -1,70 +0,0 @@ -use libc::{c_void, c_char, c_int, c_uint, c_double, uint8_t, int64_t}; -use ::avutil::{AVClass, AVFrame, AVSampleFormat}; - -pub const SWR_CH_MAX: c_int = 32; - -pub const SWR_FLAG_RESAMPLE: c_int = 1; - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum SwrDitherType { - SWR_DITHER_NONE = 0, - SWR_DITHER_RECTANGULAR, - SWR_DITHER_TRIANGULAR, - SWR_DITHER_TRIANGULAR_HIGHPASS, - - SWR_DITHER_NS = 64, - SWR_DITHER_NS_LIPSHITZ, - SWR_DITHER_NS_F_WEIGHTED, - SWR_DITHER_NS_MODIFIED_E_WEIGHTED, - SWR_DITHER_NS_IMPROVED_E_WEIGHTED, - SWR_DITHER_NS_SHIBATA, - SWR_DITHER_NS_LOW_SHIBATA, - SWR_DITHER_NS_HIGH_SHIBATA, - SWR_DITHER_NB, -} - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum SwrEngine { - SWR_ENGINE_SWR, - SWR_ENGINE_SOXR, - SWR_ENGINE_NB, -} - -#[derive(Eq, PartialEq, Copy, Clone, Debug)] -#[repr(C)] -pub enum SwrFilterType { - SWR_FILTER_TYPE_CUBIC, - SWR_FILTER_TYPE_BLACKMAN_NUTTALL, - SWR_FILTER_TYPE_KAISER, -} - -pub type SwrContext = c_void; - -extern { - pub fn swresample_version() -> c_uint; - pub fn swresample_configuration() -> *const c_char; - pub fn swresample_license() -> *const c_char; - - pub fn swr_get_class() -> *const AVClass; - - pub fn swr_alloc() -> *mut SwrContext; - pub fn swr_init(s: *mut SwrContext) -> c_int; - pub fn swr_is_initialized(s: *const SwrContext) -> c_int; - pub fn swr_alloc_set_opts(s: *mut SwrContext, out_ch_layout: int64_t, out_sample_fmt: AVSampleFormat, out_sample_rate: c_int, in_ch_layout: int64_t, in_sample_fmt: AVSampleFormat, in_sample_rate: c_int, log_offset: c_int, log_ctx: *mut c_void) -> *mut SwrContext; - pub fn swr_free(s: *mut *mut SwrContext); - pub fn swr_close(s: *mut SwrContext); - pub fn swr_convert(s: *mut SwrContext, output: *mut *mut uint8_t, out_count: c_int, input: *const *const uint8_t, in_count: c_int) -> c_int; - pub fn swr_next_pts(s: *const SwrContext, pts: int64_t) -> int64_t; - pub fn swr_set_compensation(s: *mut SwrContext, sample_delta: c_int, compensation_distance: c_int) -> c_int; - pub fn swr_set_channel_mapping(s: *mut SwrContext, channel_map: *const c_int) -> c_int; - pub fn swr_set_matrix(s: *mut SwrContext, matrix: *const c_double, stride: c_int) -> c_int; - pub fn swr_drop_output(s: *mut SwrContext, count: c_int) -> c_int; - pub fn swr_inject_silence(s: *mut SwrContext, count: c_int) -> c_int; - pub fn swr_get_delay(s: *const SwrContext, base: int64_t) -> int64_t; - pub fn swr_get_out_samples(s: *const SwrContext, in_samples: c_int) -> c_int; - - pub fn swr_convert_frame(swr: *mut SwrContext, output: *mut AVFrame, input: *const AVFrame) -> c_int; - pub fn swr_config_frame(swr: *mut SwrContext, output: *mut AVFrame, input: *const AVFrame) -> c_int; -} diff --git a/sys/src/swscale/mod.rs b/sys/src/swscale/mod.rs deleted file mode 100644 index 8db9c77..0000000 --- a/sys/src/swscale/mod.rs +++ /dev/null @@ -1,6 +0,0 @@ -mod scale; -pub use self::scale::*; - -#[cfg_attr(feature = "static", link(name = "swscale", kind = "static"))] -#[cfg_attr(not(feature = "static"), link(name = "swscale"))] -extern { } diff --git a/sys/src/swscale/scale.rs b/sys/src/swscale/scale.rs deleted file mode 100644 index 5141ab3..0000000 --- a/sys/src/swscale/scale.rs +++ /dev/null @@ -1,107 +0,0 @@ -use libc::{c_void, c_char, c_int, c_uint, c_float, c_double, uint8_t}; -use ::avutil::{AVPixelFormat, AVClass}; - -pub const SWS_FAST_BILINEAR: c_int = 1; -pub const SWS_BILINEAR: c_int = 2; -pub const SWS_BICUBIC: c_int = 4; -pub const SWS_X: c_int = 8; -pub const SWS_POINT: c_int = 0x10; -pub const SWS_AREA: c_int = 0x20; -pub const SWS_BICUBLIN: c_int = 0x40; -pub const SWS_GAUSS: c_int = 0x80; -pub const SWS_SINC: c_int = 0x100; -pub const SWS_LANCZOS: c_int = 0x200; -pub const SWS_SPLINE: c_int = 0x400; -pub const SWS_SRC_V_CHR_DROP_MASK: c_int = 0x30000; -pub const SWS_SRC_V_CHR_DROP_SHIFT: c_int = 16; -pub const SWS_PARAM_DEFAULT: c_int = 123456; -pub const SWS_PRINT_INFO: c_int = 0x1000; -pub const SWS_FULL_CHR_H_INT: c_int = 0x2000; -pub const SWS_FULL_CHR_H_INP: c_int = 0x4000; -pub const SWS_DIRECT_BGR: c_int = 0x8000; -pub const SWS_ACCURATE_RND: c_int = 0x40000; -pub const SWS_BITEXACT: c_int = 0x80000; -pub const SWS_ERROR_DIFFUSION: c_int = 0x800000; - -pub const SWS_CPU_CAPS_MMX: c_uint = 0x80000000; -pub const SWS_CPU_CAPS_MMXEXT: c_uint = 0x20000000; -pub const SWS_CPU_CAPS_MMX2: c_uint = 0x20000000; -pub const SWS_CPU_CAPS_3DNOW: c_uint = 0x40000000; -pub const SWS_CPU_CAPS_ALTIVEC: c_uint = 0x10000000; -pub const SWS_CPU_CAPS_BFIN: c_uint = 0x01000000; -pub const SWS_CPU_CAPS_SSE2: c_uint = 0x02000000; - -pub const SWS_MAX_REDUCE_CUTOFF: c_float = 0.002; - -pub const SWS_CS_ITU709: c_int = 1; -pub const SWS_CS_FCC: c_int = 4; -pub const SWS_CS_ITU601: c_int = 5; -pub const SWS_CS_ITU624: c_int = 5; -pub const SWS_CS_SMPTE170M: c_int = 5; -pub const SWS_CS_SMPTE240M: c_int = 7; -pub const SWS_CS_DEFAULT: c_int = 5; - -#[derive(Debug)] -#[repr(C)] -pub struct SwsVector { - pub coeff: *mut c_double, - pub length: c_int, -} - -#[derive(Debug)] -#[repr(C)] -pub struct SwsFilter { - pub lumH: *mut SwsVector, - pub lumV: *mut SwsVector, - pub chrH: *mut SwsVector, - pub chrV: *mut SwsVector, -} - -pub type SwsContext = c_void; - -extern { - pub fn swscale_version() -> c_uint; - pub fn swscale_configuration() -> *const c_char; - pub fn swscale_license() -> *const c_char; - - pub fn sws_getCoefficients(colorspace: c_int) -> *const c_int; - - pub fn sws_isSupportedInput(pix_fmt: AVPixelFormat) -> c_int; - pub fn sws_isSupportedOutput(pix_fmt: AVPixelFormat) -> c_int; - pub fn sws_isSupportedEndiannessConversion(pix_fmt: AVPixelFormat) -> c_int; - - pub fn sws_alloc_context() -> *mut SwsContext; - pub fn sws_init_context(sws_context: *mut SwsContext, srcFilter: *mut SwsFilter, dstFilter: *mut SwsFilter) -> c_int; - pub fn sws_freeContext(sws_context: *mut SwsContext); - pub fn sws_getContext(srcW: c_int, srcH: c_int, srcFormat: AVPixelFormat, dstW: c_int, dstH: c_int, dstFormat: AVPixelFormat, flags: c_int, srcFilter: *mut SwsFilter, dstFilter: *mut SwsFilter, param: *const c_double) -> *mut SwsContext; - - pub fn sws_scale(c: *mut SwsContext, srcSlice: *const *const uint8_t, srcStride: *const c_int, srcSliceY: c_int, srcSliceH: c_int, dst: *mut *mut uint8_t, dstStride: *mut c_int) -> c_int; - - pub fn sws_setColorspaceDetails(c: *mut SwsContext, inv_table: *const *const c_int, srcRange: c_int, table: *const *const c_int, dstRange: c_int, brightness: c_int, contrast: c_int, saturation: c_int) -> c_int; - pub fn sws_getColorspaceDetails(c: *mut SwsContext, inv_table: *mut *mut c_int, srcRange: *mut c_int, table: *mut *mut c_int, dstRange: *mut c_int, brightness: *mut c_int, contrast: *mut c_int, saturation: *mut c_int) -> c_int; - - pub fn sws_allocVec(length: c_int) -> *mut SwsVector; - pub fn sws_getGaussianVec(variance: c_double, quality: c_double) -> *mut SwsVector; - pub fn sws_getConstVec(c: c_double, length: c_int) -> *mut SwsVector; - pub fn sws_getIdentityVec() -> *mut SwsVector; - - pub fn sws_scaleVec(a: *mut SwsVector, scalar: c_double); - pub fn sws_normalizeVec(a: *mut SwsVector, height: c_double); - pub fn sws_convVec(a: *mut SwsVector, b: *const SwsVector); - pub fn sws_addVec(a: *mut SwsVector, b: *const SwsVector); - pub fn sws_subVec(a: *mut SwsVector, b: *const SwsVector); - pub fn sws_shiftVec(a: *mut SwsVector, shift: c_int); - - pub fn sws_cloneVec(a: *const SwsVector) -> *mut SwsVector; - pub fn sws_printVec2(a: *const SwsVector, log_ctx: *mut AVClass, log_level: c_int); - pub fn sws_freeVec(a: *mut SwsVector); - - pub fn sws_getDefaultFilter(lumaGBlur: c_float, chromaGBlur: c_float, lumaSharpen: c_float, chromaSharpen: c_float, chromaHShift: c_float, chromaVShift: c_float, verbose: c_int) -> *mut SwsFilter; - pub fn sws_freeFilter(filter: *mut SwsFilter); - - pub fn sws_getCachedContext(context: *mut SwsContext, srcW: c_int, srcH: c_int, srcFormat: AVPixelFormat, dstW: c_int, dstH: c_int, dstFormat: AVPixelFormat, flags: c_int, srcFilter: *mut SwsFilter, dstFilter: *mut SwsFilter, param: *const c_double) -> *mut SwsContext; - pub fn sws_convertPalette8ToPacked32(src: *const uint8_t, dst: *mut uint8_t, num_pixels: c_int, palette: *const uint8_t); - pub fn sws_convertPalette8ToPacked24(src: *const uint8_t, dst: *mut uint8_t, num_pixels: c_int, palette: *const uint8_t); - - pub fn sws_get_class() -> *const AVClass; -} diff --git a/sys/tests/data/ffmpeg-structs.c b/sys/tests/data/ffmpeg-structs.c deleted file mode 100644 index 410a6bc..0000000 --- a/sys/tests/data/ffmpeg-structs.c +++ /dev/null @@ -1,30 +0,0 @@ -#include - -#include - -int main() -{ - #define p(_struct, _member) { \ - _struct* p = 0; \ - unsigned _mysizeof = (unsigned)((size_t)( (&p->_member) + 1 ) - (size_t)( &p->_member )); \ - printf("[" #_struct "::" #_member " @ %u-%u]\n", (unsigned)offsetof(_struct, _member), _mysizeof); \ - } - - p(AVCodecContext, av_class); - p(AVCodecContext, codec_id); - p(AVCodecContext, bit_rate); - p(AVCodecContext, bit_rate_tolerance); - p(AVCodecContext, width); - p(AVCodecContext, height); - p(AVCodecContext, coded_width); - p(AVCodecContext, pix_fmt); - p(AVCodecContext, sample_rate); - p(AVCodecContext, channels); - p(AVCodecContext, sample_fmt); - p(AVCodecContext, frame_size); - p(AVCodecContext, frame_number); - p(AVCodecContext, block_align); - // p(AVCodecContext, b_frame_strategy); - - return 0; -} diff --git a/sys/tests/lib.rs b/sys/tests/lib.rs deleted file mode 100644 index b63a1c4..0000000 --- a/sys/tests/lib.rs +++ /dev/null @@ -1,103 +0,0 @@ -extern crate libc; -extern crate ffmpeg_sys; - -use std::fs::{create_dir, File, symlink_metadata}; -use std::io::{Write, BufRead, BufReader}; -use std::mem; -use std::path::{Path, PathBuf}; -use std::process::Command; -use std::str; - -use ffmpeg_sys::AVCodecContext; - -fn output() -> PathBuf { - let mut ret = std::env::current_dir().unwrap(); - ret.push(&Path::new("tmp")); - if symlink_metadata(&ret).is_err() { - create_dir(&ret).expect("Failed to create temporary output dir"); - } - ret -} - -// Checks if byte offsets in C vs. Rust match -#[test] -fn check_struct_byte_offsets() { - let out_dir = output(); - let executable = out_dir.join(if cfg!(windows) { "ffmpeg-structs.exe" } else { "ffmpeg-structs" }); - - let curr_dir = std::env::current_dir().unwrap(); - let f = File::open(curr_dir.join("tmp/.build")) - .expect("Filed to open .build"); - let f = BufReader::new(f); - let args: Vec = f.lines().nth(0).unwrap().unwrap() - .split(' ').map(String::from).collect(); - - println!("Compiling ffmpeg-structs.c"); - - if !Command::new(&args[0]) - .args(&args[1..]) - .arg("-o").arg(&executable) - .arg("tests/data/ffmpeg-structs.c") - .status() - .expect("ffmpeg-structs compile failed") - .success() { - panic!("ffmpeg-structs compile failed"); - } - - println!("Running ffmpeg-structs ({:?})", executable); - let stdout_raw = Command::new(&executable).current_dir(&out_dir).output().expect("ffmpeg-structs failed").stdout; - - println!("Writing ffmpeg-structs output file"); - File::create(out_dir.join("ffmpeg-structs.out")).expect("ffmpeg-structs.out 1").write_all(&stdout_raw[..]).expect("ffmpeg-structs.out 2"); - - let stdout = str::from_utf8(stdout_raw.as_slice()).unwrap(); - let mut matching = vec!(); - let mut errors = vec!(); - - // This should check same fields as ffmpeg-structs.c - macro_rules! p { - ($the_struct:ident, $the_field:ident) => {{ - println!("Test field size for {}::{}", stringify!($the_struct), stringify!($the_field)); - let ptr : &$the_struct = unsafe { mem::uninitialized() }; - let expected = format!("[{}::{} @ {}-{}]", stringify!($the_struct), stringify!($the_field), (&ptr.$the_field) as *const _ as usize - ptr as *const _ as usize, mem::size_of_val(&ptr.$the_field)); - - if stdout.find(&expected).is_none() { - let actual_prefix = format!("[{}::{} @ ", stringify!($the_struct), stringify!($the_field)); - let mut actual = String::from("not found"); - for line in stdout.lines() { - if line.find(&actual_prefix).is_some() { - actual = line.to_string(); - break - } - } - errors.push(format!("Struct field position as specified in Rust code ({}) is different from C ({})", expected, actual)); - } - else { - matching.push(format!(" - {}", expected)); - } - }}; - } - - p!(AVCodecContext, av_class); - p!(AVCodecContext, codec_id); - p!(AVCodecContext, bit_rate); - p!(AVCodecContext, bit_rate_tolerance); - p!(AVCodecContext, width); - p!(AVCodecContext, height); - p!(AVCodecContext, coded_width); - p!(AVCodecContext, pix_fmt); - p!(AVCodecContext, sample_rate); - p!(AVCodecContext, channels); - p!(AVCodecContext, sample_fmt); - p!(AVCodecContext, frame_size); - p!(AVCodecContext, frame_number); - p!(AVCodecContext, block_align); - - // p!(AVCodecContext, b_frame_strategy); // TODO: make conditional somehow with cfg!(feature="ff_api_private_opt") - - println!("These struct fields have matching position/size in Rust and C code:\n{}", matching.join("\n")); - - if !errors.is_empty() { - panic!(errors.join("\n")); - } -}