dep: Remove libc (CCExtractor#136)

Author: ldm0

Cargo.toml

@@ -22,7 +22,6 @@ exclude = [".github"]
 doctest = false
 
 [dependencies]
-libc = "0.2"
 
 [build-dependencies]
 bindgen = "0.70"

src/avutil/_avutil.rs

@@ -1,7 +1,8 @@
 use crate::ffi::{AVRational, AV_TIME_BASE};
+use std::ffi::c_int;
 
 pub const AV_NOPTS_VALUE: i64 = 0x8000000000000000u64 as i64;
 pub const AV_TIME_BASE_Q: AVRational = AVRational {
     num: 1,
-    den: AV_TIME_BASE as libc::c_int,
+    den: AV_TIME_BASE as c_int,
 };

src/avutil/error.rs

@@ -1,4 +1,5 @@
-use libc::c_int;
+use std::ffi::c_char;
+use std::ffi::c_int;
 use std::ffi::CStr;
 use super::common::MKTAG;
 use crate::ffi;
@@ -62,16 +63,16 @@ pub const AV_ERROR_MAX_STRING_SIZE: usize   = 64;
 /// # Safety
 /// Safety requirements is the same as the  av_strerror()`
 pub unsafe fn av_make_error_string(
-    errbuf: *mut libc::c_char,
-    errbuf_size: libc::size_t,
-    errnum: libc::c_int
-) -> *mut libc::c_char {
+    errbuf: *mut c_char,
+    errbuf_size: usize,
+    errnum: c_int
+) -> *mut c_char {
     ffi::av_strerror(errnum, errbuf, errbuf_size);
     errbuf
 }
 
 pub fn av_err2str(
-    errnum: libc::c_int
+    errnum: c_int
 ) -> String {
     let mut errbuf = [0u8; AV_ERROR_MAX_STRING_SIZE];
     let errbuf_ptr = errbuf.as_mut_ptr() as _;

src/avutil/rational.rs

@@ -2,14 +2,15 @@
 /// in linked library. So we need this.
 /// Ref: https://github.com/rust-lang/rust-bindgen/issues/1344
 use crate::ffi::AVRational;
+use std::ffi::{c_double, c_int};
 
 /// Create an AVRational.
 ///
 /// Useful for compilers that do not support compound literals.
 ///
 /// @note The return value is not reduced.
 /// @see av_reduce()
-pub const fn av_make_q(num: libc::c_int, den: libc::c_int) -> AVRational {
+pub const fn av_make_q(num: c_int, den: c_int) -> AVRational {
     AVRational { num, den }
 }
 
@@ -23,26 +24,26 @@ pub const fn av_make_q(num: libc::c_int, den: libc::c_int) -> AVRational {
 ///         - 1 if `a > b`
 ///         - -1 if `a < b`
 ///         - `INT_MIN` if one of the values is of the form `0 / 0`
-pub fn av_cmp_q(a: AVRational, b: AVRational) -> libc::c_int {
+pub fn av_cmp_q(a: AVRational, b: AVRational) -> c_int {
     let tmp = i64::from(a.num) * i64::from(b.den) - i64::from(b.num) * i64::from(a.den);
 
     if tmp != 0 {
-        (((tmp ^ i64::from(a.den) ^ i64::from(b.den)) >> 63) | 1) as libc::c_int
+        (((tmp ^ i64::from(a.den) ^ i64::from(b.den)) >> 63) | 1) as c_int
     } else if b.den != 0 && a.den != 0 {
         0
     } else if a.num != 0 && b.num != 0 {
         (a.num >> 31) - (b.num >> 31)
     } else {
-        libc::c_int::MIN
+        c_int::MIN
     }
 }
 
 /// Convert an AVRational to a `double`.
 /// @param a AVRational to convert
 /// @return `a` in floating-point form
 /// @see av_d2q()
-pub fn av_q2d(a: AVRational) -> libc::c_double {
-    libc::c_double::from(a.num) / libc::c_double::from(a.den)
+pub fn av_q2d(a: AVRational) -> c_double {
+    c_double::from(a.num) / c_double::from(a.den)
 }
 
 /// Invert a rational.