fferris-sys 0.0.0

DO NOT USE THIS
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use std::{fs::File, io::Write};

#[cfg(feature = "__bindgen")]
use bindgen::callbacks::{EnumVariantValue, ParseCallbacks};

#[cfg(feature = "__bindgen")]
extern crate bindgen;

//#[cfg(feature = "__bindgen")]
//#[path = "src/gen.rs"]
//mod gen;
//
//#[cfg(feature = "__bindgen")]
//#[derive(Debug)]
//struct Processor;
//#[cfg(feature = "__bindgen")]
//impl ParseCallbacks for Processor {
//    fn enum_variant_name(
//        &self,
//        enum_name: Option<&str>,
//        original_variant_name: &str,
//        variant_value: bindgen::callbacks::EnumVariantValue,
//    ) -> Option<String> {
//        match enum_name {
//            Some("enum AVCodecID") => {
//                if let Some(varname) = original_variant_name.strip_prefix("AV_CODEC_ID_") {
//                    if let EnumVariantValue::Unsigned(val) = variant_value {
//                        if val == gen::FIRST_AUDIO
//                            || val == gen::FIRST_SUBTITLE
//                            || val == gen::FIRST_UNKNOWN
//                        {
//                            None
//                        } else {
//                            Some(if val > gen::FIRST_UNKNOWN || val == 0 {
//                                varname.to_string()
//                            } else if val > gen::FIRST_SUBTITLE {
//                                format!("Sub{varname}")
//                            } else if val > gen::FIRST_AUDIO {
//                                format!("Audio{varname}")
//                            } else {
//                                format!("Video{varname}")
//                            })
//                        }
//                    } else {
//                        None
//                    }
//                } else {
//                    panic!()
//                }
//            }
//            _ => None,
//        }
//    }
//}

fn main() {
    // Only run bindgen if the super special feature is enabled
    //
    // libav is MASSIVE and not everybody needs to generate the bindings themself.
    // Regenerating the bindings while developing FFerris gets old FAST.
    #[cfg(feature = "__bindgen")]
    {
        std::process::Command::new("clang")
            .args(["-lavutil", "-lavcodec", "src/codec.c"])
            .output()
            .unwrap();
        let out = std::process::Command::new("./a.out")
            .output()
            .unwrap()
            .stdout;

        let mut f = File::options()
            .write(true)
            .create(true)
            .truncate(true)
            .open("src/gen.rs")
            .unwrap();

        f.write_all(out.as_slice()).unwrap();

        const VALID_ENUMS: &'static [&'static str] =
            &["AVMediaType", "AVPixelFormat", "AVClassCategory"];

        let mut b = bindgen::builder()
            // Use core for no_std compatibility
            .use_core()
            // TODO: Do I need this...?
            .generate_cstr(true)
            // Dynamic linking sucks
            .dynamic_link_require_all(true)
            .sort_semantically(true)
            .enable_function_attribute_detection()
            // It was causing me trouble, so I got rid of it.
            // Something related to floating point numbers I think?
            // TODO: Look into this you idiot
            .blocklist_item("FP_.*")
            // Break now; fix later
            .rustified_enum(".*")
            .newtype_enum("AVPixelFormat")
            .translate_enum_integer_types(true);
        //    .parse_callbacks(Box::new(Processor));

        // Includes are conditional, based on Rust features
        // Need to let clang know
        {
            #[cfg(feature = "avformat")]
            {
                b = b.clang_arg("-D__FFERRIS_ENABLE_AVFORMAT");
            }

            #[cfg(feature = "avcodec")]
            {
                b = b.clang_arg("-D__FFERRIS_ENABLE_AVCODEC");
            }

            #[cfg(feature = "avfilter")]
            {
                b = b.clang_arg("-D__FFERRIS_ENABLE_AVFILTER");
            }

            #[cfg(feature = "avdevice")]
            {
                b = b.clang_arg("-D__FFERRIS_ENABLE_AVDEVICE");
            }
        }

        b
            // All the comments because I like LSP autocomplete
            .clang_arg("-fretain-comments-from-system-headers")
            .clang_arg("-fparse-all-comments")
            // Include the include header file with my includes in it
            .header("src/include.h")
            // Finally generate the bindings :)
            .generate()
            .unwrap()
            .write_to_file("src/bindings.rs")
            .unwrap();
    }

    for f in ["src/include.h", "src/gen.c"] {
        println!("cargo::rerun-if-changed={f}");
    }

    println!("cargo::rustc-link-search=/usr/lib");
    println!("cargo::rustc-link-lib=avutil");

    #[cfg(feature = "avformat")]
    println!("cargo::rustc-link-lib=avformat");

    #[cfg(feature = "avcodec")]
    println!("cargo::rustc-link-lib=avcodec");

    #[cfg(feature = "avfilter")]
    println!("cargo::rustc-link-lib=avfilter");

    #[cfg(feature = "avdevice")]
    println!("cargo::rustc-link-lib=avdevice");
}