util/color: move color enums to their own module

src/lib.rs

@@ -9,10 +9,9 @@ pub mod util;
 pub use util::error::Error;
 pub use util::dictionary::Dictionary;
 pub use util::rational::Rational;
-pub use util::color_space::ColorSpace;
-pub use util::color_range::ColorRange;
 pub use util::media;
 pub use util::picture;
+pub use util::color;
 pub use util::frame::{self, Frame};
 
 pub mod format;

src/util/color/mod.rs

@@ -0,0 +1,11 @@
+pub mod range;
+pub use self::range::Range;
+
+pub mod space;
+pub use self::space::Space;
+
+pub mod primaries;
+pub use self::primaries::Primaries;
+
+pub mod transfer_characteristic;
+pub use self::transfer_characteristic::TransferCharacteristic;

src/util/color/primaries.rs

@@ -0,0 +1,53 @@
+use ffi::*;
+
+#[derive(Eq, PartialEq, Clone, Copy, Debug)]
+pub enum Primaries {
+	Reserved0,
+	BT709,
+	Unspecified,
+	Reserved,
+	BT470M,
+
+	BT470BG,
+	SMPTE170M,
+	SMPTE240M,
+	Film,
+	BT2020,
+}
+
+impl From<AVColorPrimaries> for Primaries {
+	fn from(value: AVColorPrimaries) -> Primaries {
+		match value {
+			AVCOL_PRI_RESERVED0   => Primaries::Reserved0,
+			AVCOL_PRI_BT709       => Primaries::BT709,
+			AVCOL_PRI_UNSPECIFIED => Primaries::Unspecified,
+			AVCOL_PRI_RESERVED    => Primaries::Reserved,
+			AVCOL_PRI_BT470M      => Primaries::BT470M,
+
+			AVCOL_PRI_BT470BG   => Primaries::BT470BG,
+			AVCOL_PRI_SMPTE170M => Primaries::SMPTE170M,
+			AVCOL_PRI_SMPTE240M => Primaries::SMPTE240M,
+			AVCOL_PRI_FILM      => Primaries::Film,
+			AVCOL_PRI_BT2020    => Primaries::BT2020,
+			AVCOL_PRI_NB        => Primaries::Reserved0
+		}
+	}
+}
+
+impl Into<AVColorPrimaries> for Primaries {
+	fn into(self) -> AVColorPrimaries {
+		match self {
+			Primaries::Reserved0   => AVCOL_PRI_RESERVED0,
+			Primaries::BT709       => AVCOL_PRI_BT709,
+			Primaries::Unspecified => AVCOL_PRI_UNSPECIFIED,
+			Primaries::Reserved    => AVCOL_PRI_RESERVED,
+			Primaries::BT470M      => AVCOL_PRI_BT470M,
+
+			Primaries::BT470BG   => AVCOL_PRI_BT470BG,
+			Primaries::SMPTE170M => AVCOL_PRI_SMPTE170M,
+			Primaries::SMPTE240M => AVCOL_PRI_SMPTE240M,
+			Primaries::Film      => AVCOL_PRI_FILM,
+			Primaries::BT2020    => AVCOL_PRI_BT2020,
+		}
+	}
+}

src/util/color/range.rs

@@ -0,0 +1,29 @@
+use ffi::*;
+
+#[derive(Eq, PartialEq, Clone, Copy, Debug)]
+pub enum Range {
+	Unspecified,
+	MPEG,
+	JPEG,
+}
+
+impl From<AVColorRange> for Range {
+	fn from(value: AVColorRange) -> Self {
+		match value {
+			AVCOL_RANGE_UNSPECIFIED => Range::Unspecified,
+			AVCOL_RANGE_MPEG        => Range::MPEG,
+			AVCOL_RANGE_JPEG        => Range::JPEG,
+			AVCOL_RANGE_NB          => Range::Unspecified
+		}
+	}
+}
+
+impl Into<AVColorRange> for Range {
+	fn into(self) -> AVColorRange {
+		match self {
+			Range::Unspecified => AVCOL_RANGE_UNSPECIFIED,
+			Range::MPEG        => AVCOL_RANGE_MPEG,
+			Range::JPEG        => AVCOL_RANGE_JPEG
+		}
+	}
+}

src/util/color/space.rs

@@ -0,0 +1,66 @@
+use std::ffi::CStr;
+use std::str::from_utf8_unchecked;
+
+use ffi::*;
+
+#[derive(Eq, PartialEq, Clone, Copy, Debug)]
+pub enum Space {
+	RGB,
+	BT709,
+	Unspecified,
+	Reserved,
+	FCC,
+	BT470BG,
+	SMPTE170M,
+	SMPTE240M,
+	YCOCG,
+	YCGCO,
+	BT2020NCL,
+	BT2020CL,
+}
+
+impl Space {
+	pub fn name(&self) -> &'static str {
+		unsafe {
+			from_utf8_unchecked(CStr::from_ptr(av_get_colorspace_name((*self).into())).to_bytes())
+		}
+	}
+}
+
+impl From<AVColorSpace> for Space {
+	fn from(value: AVColorSpace) -> Self {
+		match value {
+			AVCOL_SPC_RGB         => Space::RGB,
+			AVCOL_SPC_BT709       => Space::BT709,
+			AVCOL_SPC_UNSPECIFIED => Space::Unspecified,
+			AVCOL_SPC_RESERVED    => Space::Reserved,
+			AVCOL_SPC_FCC         => Space::FCC,
+			AVCOL_SPC_BT470BG     => Space::BT470BG,
+			AVCOL_SPC_SMPTE170M   => Space::SMPTE170M,
+			AVCOL_SPC_SMPTE240M   => Space::SMPTE240M,
+			AVCOL_SPC_YCOCG       => Space::YCOCG,
+			AVCOL_SPC_BT2020_NCL  => Space::BT2020NCL,
+			AVCOL_SPC_BT2020_CL   => Space::BT2020CL,
+			AVCOL_SPC_NB          => Space::Unspecified
+		}
+	}
+}
+
+impl Into<AVColorSpace> for Space {
+	fn into(self) -> AVColorSpace {
+		match self {
+			Space::RGB         => AVCOL_SPC_RGB,
+			Space::BT709       => AVCOL_SPC_BT709,
+			Space::Unspecified => AVCOL_SPC_UNSPECIFIED,
+			Space::Reserved    => AVCOL_SPC_RESERVED,
+			Space::FCC         => AVCOL_SPC_FCC,
+			Space::BT470BG     => AVCOL_SPC_BT470BG,
+			Space::SMPTE170M   => AVCOL_SPC_SMPTE170M,
+			Space::SMPTE240M   => AVCOL_SPC_SMPTE240M,
+			Space::YCOCG       => AVCOL_SPC_YCOCG,
+			Space::YCGCO       => AVCOL_SPC_YCGCO,
+			Space::BT2020NCL   => AVCOL_SPC_BT2020_NCL,
+			Space::BT2020CL    => AVCOL_SPC_BT2020_CL
+		}
+	}
+}

src/util/color/transfer_characteristic.rs

@@ -0,0 +1,68 @@
+use ffi::*;
+
+#[derive(Eq, PartialEq, Clone, Copy, Debug)]
+pub enum TransferCharacteristic {
+	Reserved0,
+	BT709,
+	Unspecified,
+	Reserved,
+	GAMMA22,
+	GAMMA28,
+	SMPTE170M,
+	SMPTE240M,
+	Linear,
+	Log,
+	LogSqrt,
+	IEC61966_2_4,
+	BT1361_ECG,
+	IEC61966_2_1,
+	BT2020_10,
+	BT2020_12,
+}
+
+impl From<AVColorTransferCharacteristic> for TransferCharacteristic {
+	fn from(value: AVColorTransferCharacteristic) -> TransferCharacteristic {
+		match value {
+			AVCOL_TRC_RESERVED0    => TransferCharacteristic::Reserved0,
+			AVCOL_TRC_BT709        => TransferCharacteristic::BT709,
+			AVCOL_TRC_UNSPECIFIED  => TransferCharacteristic::Unspecified,
+			AVCOL_TRC_RESERVED     => TransferCharacteristic::Reserved,
+			AVCOL_TRC_GAMMA22      => TransferCharacteristic::GAMMA22,
+			AVCOL_TRC_GAMMA28      => TransferCharacteristic::GAMMA28,
+			AVCOL_TRC_SMPTE170M    => TransferCharacteristic::SMPTE170M,
+			AVCOL_TRC_SMPTE240M    => TransferCharacteristic::SMPTE240M,
+			AVCOL_TRC_LINEAR       => TransferCharacteristic::Linear,
+			AVCOL_TRC_LOG          => TransferCharacteristic::Log,
+			AVCOL_TRC_LOG_SQRT     => TransferCharacteristic::LogSqrt,
+			AVCOL_TRC_IEC61966_2_4 => TransferCharacteristic::IEC61966_2_4,
+			AVCOL_TRC_BT1361_ECG   => TransferCharacteristic::BT1361_ECG,
+			AVCOL_TRC_IEC61966_2_1 => TransferCharacteristic::IEC61966_2_1,
+			AVCOL_TRC_BT2020_10    => TransferCharacteristic::BT2020_10,
+			AVCOL_TRC_BT2020_12    => TransferCharacteristic::BT2020_12,
+			AVCOL_TRC_NB           => TransferCharacteristic::Reserved0
+		}
+	}
+}
+
+impl Into<AVColorTransferCharacteristic> for TransferCharacteristic {
+	fn into(self) -> AVColorTransferCharacteristic {
+		match self {
+			TransferCharacteristic::Reserved0    => AVCOL_TRC_RESERVED0,
+			TransferCharacteristic::BT709        => AVCOL_TRC_BT709,
+			TransferCharacteristic::Unspecified  => AVCOL_TRC_UNSPECIFIED,
+			TransferCharacteristic::Reserved     => AVCOL_TRC_RESERVED,
+			TransferCharacteristic::GAMMA22      => AVCOL_TRC_GAMMA22,
+			TransferCharacteristic::GAMMA28      => AVCOL_TRC_GAMMA28,
+			TransferCharacteristic::SMPTE170M    => AVCOL_TRC_SMPTE170M,
+			TransferCharacteristic::SMPTE240M    => AVCOL_TRC_SMPTE240M,
+			TransferCharacteristic::Linear       => AVCOL_TRC_LINEAR,
+			TransferCharacteristic::Log          => AVCOL_TRC_LOG,
+			TransferCharacteristic::LogSqrt      => AVCOL_TRC_LOG_SQRT,
+			TransferCharacteristic::IEC61966_2_4 => AVCOL_TRC_IEC61966_2_4,
+			TransferCharacteristic::BT1361_ECG   => AVCOL_TRC_BT1361_ECG,
+			TransferCharacteristic::IEC61966_2_1 => AVCOL_TRC_IEC61966_2_1,
+			TransferCharacteristic::BT2020_10    => AVCOL_TRC_BT2020_10,
+			TransferCharacteristic::BT2020_12    => AVCOL_TRC_BT2020_12
+		}
+	}
+}

src/util/color_range.rs

@@ -1,29 +0,0 @@
-use ffi::*;
-
-#[derive(Eq, PartialEq, Clone, Copy, Debug)]
-pub enum ColorRange {
-	Unspecified,
-	MPEG,
-	JPEG,
-}
-
-impl From<AVColorRange> for ColorRange {
-	fn from(value: AVColorRange) -> Self {
-		match value {
-			AVCOL_RANGE_UNSPECIFIED => ColorRange::Unspecified,
-			AVCOL_RANGE_MPEG        => ColorRange::MPEG,
-			AVCOL_RANGE_JPEG        => ColorRange::JPEG,
-			AVCOL_RANGE_NB          => ColorRange::Unspecified
-		}
-	}
-}
-
-impl Into<AVColorRange> for ColorRange {
-	fn into(self) -> AVColorRange {
-		match self {
-			ColorRange::Unspecified => AVCOL_RANGE_UNSPECIFIED,
-			ColorRange::MPEG        => AVCOL_RANGE_MPEG,
-			ColorRange::JPEG        => AVCOL_RANGE_JPEG
-		}
-	}
-}

src/util/color_space.rs

@@ -1,64 +0,0 @@
-use std::ffi::CStr;
-use std::str::from_utf8_unchecked;
-
-use ffi::*;
-
-#[derive(Eq, PartialEq, Clone, Copy, Debug)]
-pub enum ColorSpace {
-	RGB,
-	BT709,
-	Unspecified,
-	Reserved,
-	FCC,
-	BT470BG,
-	SMPTE170M,
-	SMPTE240M,
-	YCOCG,
-	BT2020NCL,
-	BT2020CL,
-}
-
-impl ColorSpace {
-	pub fn name(&self) -> &'static str {
-		unsafe {
-			from_utf8_unchecked(CStr::from_ptr(av_get_colorspace_name((*self).into())).to_bytes())
-		}
-	}
-}
-
-impl From<AVColorSpace> for ColorSpace {
-	fn from(value: AVColorSpace) -> Self {
-		match value {
-			AVCOL_SPC_RGB         => ColorSpace::RGB,
-			AVCOL_SPC_BT709       => ColorSpace::BT709,
-			AVCOL_SPC_UNSPECIFIED => ColorSpace::Unspecified,
-			AVCOL_SPC_RESERVED    => ColorSpace::Reserved,
-			AVCOL_SPC_FCC         => ColorSpace::FCC,
-			AVCOL_SPC_BT470BG     => ColorSpace::BT470BG,
-			AVCOL_SPC_SMPTE170M   => ColorSpace::SMPTE170M,
-			AVCOL_SPC_SMPTE240M   => ColorSpace::SMPTE240M,
-			AVCOL_SPC_YCOCG       => ColorSpace::YCOCG,
-			AVCOL_SPC_BT2020_NCL  => ColorSpace::BT2020NCL,
-			AVCOL_SPC_BT2020_CL   => ColorSpace::BT2020CL,
-			AVCOL_SPC_NB          => ColorSpace::Unspecified
-		}
-	}
-}
-
-impl Into<AVColorSpace> for ColorSpace {
-	fn into(self) -> AVColorSpace {
-		match self {
-			ColorSpace::RGB         => AVCOL_SPC_RGB,
-			ColorSpace::BT709       => AVCOL_SPC_BT709,
-			ColorSpace::Unspecified => AVCOL_SPC_UNSPECIFIED,
-			ColorSpace::Reserved    => AVCOL_SPC_RESERVED,
-			ColorSpace::FCC         => AVCOL_SPC_FCC,
-			ColorSpace::BT470BG     => AVCOL_SPC_BT470BG,
-			ColorSpace::SMPTE170M   => AVCOL_SPC_SMPTE170M,
-			ColorSpace::SMPTE240M   => AVCOL_SPC_SMPTE240M,
-			ColorSpace::YCOCG       => AVCOL_SPC_YCOCG,
-			ColorSpace::BT2020NCL   => AVCOL_SPC_BT2020_NCL,
-			ColorSpace::BT2020CL    => AVCOL_SPC_BT2020_CL
-		}
-	}
-}

src/util/mod.rs

@@ -3,8 +3,7 @@ pub mod error;
 pub mod rational;
 pub mod media;
 pub mod picture;
-pub mod color_space;
+pub mod color;
-pub mod color_range;
 pub mod sample_format;
 pub mod pixel_format;
 pub mod frame;