#[cfg(all(test, feature = "std"))]
mod tests;
use crate::{
ChromaLocation, ColorInfo, ColorMatrix, DynamicRange, KernelMatrix, PixelFormat, PixelSink,
Primaries, Transfer, UnsupportedKernelMatrixError,
};
#[cfg(feature = "xyz")]
use crate::{
frame::Xyz12Frame,
source::{Xyz12, Xyz12Sink, xyz12_to},
};
#[cfg(feature = "bayer")]
use crate::{
frame::{BayerFrame, BayerFrame16, BayerSink, BayerSink16, bayer_to, bayer16_to_endian},
source::{Bayer, Bayer16},
};
#[cfg(feature = "mono")]
use crate::{
frame::{MonoblackFrame, MonowhiteFrame, Pal8Frame},
source::{
Monoblack, MonoblackSink, Monowhite, MonowhiteSink, Pal8, Pal8Sink, monoblack_to, monowhite_to,
pal8_to,
},
};
#[cfg(feature = "yuv-planar")]
use crate::{
frame::{
Yuv410pFrame, Yuv411pFrame, Yuv420pFrame, Yuv420pFrame16, Yuv422pFrame, Yuv422pFrame16,
Yuv440pFrame, Yuv440pFrame16, Yuv444pFrame, Yuv444pFrame16, Yuv444pMsbFrame,
},
source::{
Yuv410p, Yuv410pSink, Yuv411p, Yuv411pSink, Yuv420p, Yuv420p9, Yuv420p9Sink, Yuv420p10,
Yuv420p10Sink, Yuv420p12, Yuv420p12Sink, Yuv420p14, Yuv420p14Sink, Yuv420p16, Yuv420p16Sink,
Yuv420pSink, Yuv422p, Yuv422p9, Yuv422p9Sink, Yuv422p10, Yuv422p10Sink, Yuv422p12,
Yuv422p12Sink, Yuv422p14, Yuv422p14Sink, Yuv422p16, Yuv422p16Sink, Yuv422pSink, Yuv440p,
Yuv440p10, Yuv440p10Sink, Yuv440p12, Yuv440p12Sink, Yuv440pSink, Yuv444p, Yuv444p9,
Yuv444p9Sink, Yuv444p10, Yuv444p10Msb, Yuv444p10MsbSink, Yuv444p10Sink, Yuv444p12,
Yuv444p12Msb, Yuv444p12MsbSink, Yuv444p12Sink, Yuv444p14, Yuv444p14Sink, Yuv444p16,
Yuv444p16Sink, Yuv444pSink, yuv410p_to, yuv411p_to, yuv420p_to, yuv420p9_to_endian,
yuv420p10_to_endian, yuv420p12_to_endian, yuv420p14_to_endian, yuv420p16_to_endian, yuv422p_to,
yuv422p9_to_endian, yuv422p10_to_endian, yuv422p12_to_endian, yuv422p14_to_endian,
yuv422p16_to_endian, yuv440p_to, yuv440p10_to_endian, yuv440p12_to_endian, yuv444p_to,
yuv444p9_to_endian, yuv444p10_msb_to_endian, yuv444p10_to_endian, yuv444p12_msb_to_endian,
yuv444p12_to_endian, yuv444p14_to_endian, yuv444p16_to_endian,
},
};
#[cfg(feature = "yuv-semi-planar")]
use crate::{
frame::{
Nv12Frame, Nv16Frame, Nv20Frame, Nv21Frame, Nv24Frame, Nv42Frame, PnFrame, PnFrame422,
PnFrame444,
},
source::{
Nv12, Nv12Sink, Nv16, Nv16Sink, Nv20, Nv20Sink, Nv21, Nv21Sink, Nv24, Nv24Sink, Nv42, Nv42Sink,
P010, P010Sink, P012, P012Sink, P016, P016Sink, P210, P210Sink, P212, P212Sink, P216, P216Sink,
P410, P410Sink, P412, P412Sink, P416, P416Sink, nv12_to, nv16_to, nv20_to_endian, nv21_to,
nv24_to, nv42_to, p010_to_endian, p012_to_endian, p016_to_endian, p210_to_endian,
p212_to_endian, p216_to_endian, p410_to_endian, p412_to_endian, p416_to_endian,
},
};
#[cfg(feature = "yuv-packed")]
use crate::{
frame::{Uyvy422Frame, Uyyvyy411Frame, Yuyv422Frame, Yvyu422Frame},
source::{
Uyvy422, Uyvy422Sink, Uyyvyy411, Uyyvyy411Sink, Yuyv422, Yuyv422Sink, Yvyu422, Yvyu422Sink,
uyvy422_to, uyyvyy411_to, yuyv422_to, yvyu422_to,
},
};
#[cfg(feature = "y2xx")]
use crate::{
frame::Y2xxFrame,
source::{
Y210, Y210Sink, Y212, Y212Sink, Y216, Y216Sink, y210_to_endian, y212_to_endian, y216_to_endian,
},
};
#[cfg(feature = "yuv-444-packed")]
use crate::{
frame::{
Ayuv64Frame, AyuvFrame, UyvaFrame, V30XFrame, V410Frame, VuyaFrame, VuyxFrame, Vyu444Frame,
Xv36Frame, Xv48Frame,
},
source::{
Ayuv, Ayuv64, Ayuv64Sink, AyuvSink, Uyva, UyvaSink, V30X, V30XSink, V410, V410Sink, Vuya,
VuyaSink, Vuyx, VuyxSink, Vyu444, Vyu444Sink, Xv36, Xv36Sink, Xv48, Xv48Sink, ayuv_to,
ayuv64_to_endian, uyva_to, v30x_to, v410_to_endian, vuya_to, vuyx_to, vyu444_to,
xv36_to_endian, xv48_to_endian,
},
};
#[cfg(feature = "v210")]
use crate::{
frame::V210Frame,
source::{V210, V210Sink, v210_to_endian},
};
#[cfg(feature = "yuva")]
use crate::{
frame::{
Yuva420pFrame, Yuva420pFrame16, Yuva422pFrame, Yuva422pFrame16, Yuva444pFrame, Yuva444pFrame16,
},
source::{
Yuva420p, Yuva420p9, Yuva420p9Sink, Yuva420p10, Yuva420p10Sink, Yuva420p12, Yuva420p12Sink,
Yuva420p16, Yuva420p16Sink, Yuva420pSink, Yuva422p, Yuva422p9, Yuva422p9Sink, Yuva422p10,
Yuva422p10Sink, Yuva422p12, Yuva422p12Sink, Yuva422p16, Yuva422p16Sink, Yuva422pSink, Yuva444p,
Yuva444p9, Yuva444p9Sink, Yuva444p10, Yuva444p10Sink, Yuva444p12, Yuva444p12Sink, Yuva444p14,
Yuva444p14Sink, Yuva444p16, Yuva444p16Sink, Yuva444pSink, yuva420p_to, yuva420p9_to_endian,
yuva420p10_to_endian, yuva420p12_to_endian, yuva420p16_to_endian, yuva422p_to,
yuva422p9_to_endian, yuva422p10_to_endian, yuva422p12_to_endian, yuva422p16_to_endian,
yuva444p_to, yuva444p9_to_endian, yuva444p10_to_endian, yuva444p12_to_endian,
yuva444p14_to_endian, yuva444p16_to_endian,
},
};
#[cfg(feature = "rgb")]
use crate::{
frame::{
AbgrFrame, ArgbFrame, Bgr24Frame, Bgr48Frame, Bgra64Frame, BgraFrame, BgrxFrame, Rgb24Frame,
Rgb48Frame, Rgb96Frame, Rgba64Frame, Rgba128Frame, RgbaFrame, RgbxFrame, X2Bgr10Frame,
X2Rgb10Frame, XbgrFrame, XrgbFrame,
},
source::{
Abgr, AbgrSink, Argb, ArgbSink, Bgr24, Bgr24Sink, Bgr48, Bgr48Sink, Bgra, Bgra64, Bgra64Sink,
BgraSink, Bgrx, BgrxSink, Rgb24, Rgb24Sink, Rgb48, Rgb48Sink, Rgb96, Rgb96Sink, Rgba, Rgba64,
Rgba64Sink, Rgba128, Rgba128Sink, RgbaSink, Rgbx, RgbxSink, X2Bgr10, X2Bgr10Sink, X2Rgb10,
X2Rgb10Sink, Xbgr, XbgrSink, Xrgb, XrgbSink, abgr_to, argb_to, bgr24_to, bgr48_to_endian,
bgra_to, bgra64_to_endian, bgrx_to, rgb24_to, rgb48_to_endian, rgb96_to_endian, rgba_to,
rgba64_to_endian, rgba128_to_endian, rgbx_to, x2bgr10_to_endian, x2rgb10_to_endian, xbgr_to,
xrgb_to,
},
};
#[cfg(feature = "rgb-legacy")]
use crate::{
frame::{
Bgr4ByteFrame, Bgr4Frame, Bgr8Frame, Bgr444Frame, Bgr555Frame, Bgr565Frame, Rgb4ByteFrame,
Rgb4Frame, Rgb8Frame, Rgb444Frame, Rgb555Frame, Rgb565Frame,
},
source::{
Bgr4, Bgr4Byte, Bgr4ByteSink, Bgr4Sink, Bgr8, Bgr8Sink, Bgr444, Bgr444Sink, Bgr555, Bgr555Sink,
Bgr565, Bgr565Sink, Rgb4, Rgb4Byte, Rgb4ByteSink, Rgb4Sink, Rgb8, Rgb8Sink, Rgb444, Rgb444Sink,
Rgb555, Rgb555Sink, Rgb565, Rgb565Sink, bgr4_byte_to, bgr4_to, bgr8_to, bgr444_to, bgr555_to,
bgr565_to, rgb4_byte_to, rgb4_to, rgb8_to, rgb444_to, rgb555_to, rgb565_to,
},
};
#[cfg(feature = "rgb-float")]
use crate::{
frame::{Rgbaf16Frame, Rgbaf32Frame, Rgbf16Frame, Rgbf32Frame},
source::{
Rgbaf16, Rgbaf16Sink, Rgbaf32, Rgbaf32Sink, Rgbf16, Rgbf16Sink, Rgbf32, Rgbf32Sink,
rgbaf16_to_endian, rgbaf32_to_endian, rgbf16_to_endian, rgbf32_to_endian,
},
};
#[cfg(feature = "gray")]
use crate::{
frame::{
Gray8Frame, Gray16Frame, Gray32Frame, GrayNFrame, Grayf16Frame, Grayf32Frame, Ya8Frame,
Ya16Frame, Yaf16Frame, Yaf32Frame,
},
source::{
Gray8, Gray8Sink, Gray9, Gray9Sink, Gray10, Gray10Sink, Gray12, Gray12Sink, Gray14, Gray14Sink,
Gray16, Gray16Sink, Gray32, Gray32Sink, Grayf16, Grayf16Sink, Grayf32, Grayf32Sink, Ya8,
Ya8Sink, Ya16, Ya16Sink, Yaf16, Yaf16Sink, Yaf32, Yaf32Sink, gray8_to, gray9_to_endian,
gray10_to_endian, gray12_to_endian, gray14_to_endian, gray16_to_endian, gray32_to_endian,
grayf16_to_endian, grayf32_to_endian, ya8_to, ya16_to_endian, yaf16_to_endian, yaf32_to_endian,
},
};
#[cfg(feature = "gbr")]
use crate::{
frame::{
Gbrap32Frame, GbrapFrame, GbrapHighBitFrame, Gbrapf16Frame, Gbrapf32Frame, GbrpFrame,
GbrpHighBitFrame, GbrpMsbFrame, Gbrpf16Frame, Gbrpf32Frame,
},
source::{
Gbrap, Gbrap10, Gbrap10Sink, Gbrap12, Gbrap12Sink, Gbrap14, Gbrap14Sink, Gbrap16, Gbrap16Sink,
Gbrap32, Gbrap32Sink, GbrapSink, Gbrapf16, Gbrapf16Sink, Gbrapf32, Gbrapf32Sink, Gbrp, Gbrp9,
Gbrp9Sink, Gbrp10, Gbrp10Msb, Gbrp10MsbSink, Gbrp10Sink, Gbrp12, Gbrp12Msb, Gbrp12MsbSink,
Gbrp12Sink, Gbrp14, Gbrp14Sink, Gbrp16, Gbrp16Sink, GbrpSink, Gbrpf16, Gbrpf16Sink, Gbrpf32,
Gbrpf32Sink, gbrap_to, gbrap10_to_endian, gbrap12_to_endian, gbrap14_to_endian,
gbrap16_to_endian, gbrap32_to_endian, gbrapf16_to_endian, gbrapf32_to_endian, gbrp_to,
gbrp9_to_endian, gbrp10_msb_to_endian, gbrp10_to_endian, gbrp12_msb_to_endian,
gbrp12_to_endian, gbrp14_to_endian, gbrp16_to_endian, gbrpf16_to_endian, gbrpf32_to_endian,
},
};
pub trait Walker<S> {
type Frame<'a>;
type Options;
fn walk(src: &Self::Frame<'_>, opts: &Self::Options, sink: &mut S) -> Result<(), S::Error>
where
S: PixelSink;
}
#[cfg(any(
feature = "xyz",
feature = "bayer",
feature = "mono",
feature = "yuv-planar",
feature = "yuv-semi-planar",
feature = "yuv-packed",
feature = "yuv-444-packed",
feature = "y2xx",
feature = "v210",
feature = "yuva",
feature = "rgb",
feature = "rgb-float",
feature = "rgb-legacy",
feature = "gray",
feature = "gbr",
))]
macro_rules! walker {
($marker:ty, $sink:path, $frame:ident, $opts:ty, |$s:ident, $o:ident, $k:ident| $body:expr) => {
impl<S> Walker<S> for $marker
where
S: $sink,
{
type Frame<'a> = $frame<'a>;
type Options = $opts;
#[inline(always)]
fn walk($s: &Self::Frame<'_>, $o: &Self::Options, $k: &mut S) -> Result<(), S::Error>
where
S: PixelSink,
{
$body
}
}
};
(@convert @rgb_u16($depth:literal) @const(cfg: $src_cfg:meta) $c:ident: $cty:ty; $marker:ty, $sink:ident, $frame:ident, $opts:ty, |$s:ident, $o:ident, $k:ident| $body:expr) => {
walker!(@convert_const_cfg [$depth] $src_cfg; $c: $cty; $marker, $sink, $frame, $opts, |$s, $o, $k| $body);
};
(@convert @rgb_u16($depth:literal) @const $c:ident: $cty:ty; $marker:ty, $sink:ident, $frame:ident, $opts:ty, |$s:ident, $o:ident, $k:ident| $body:expr) => {
walker!(@convert_const [$depth] $c: $cty; $marker, $sink, $frame, $opts, |$s, $o, $k| $body);
};
(@convert @rgb_u16($depth:literal) $marker:ty, $sink:path, $frame:ident, $opts:ty, |$s:ident, $o:ident, $k:ident| $body:expr) => {
walker!(@convert_plain [$depth] $marker, $sink, $frame, $opts, |$s, $o, $k| $body);
};
(@convert @rgb_u16($r:literal, $g:literal, $b:literal) $marker:ty, $sink:path, $frame:ident, $opts:ty, |$s:ident, $o:ident, $k:ident| $body:expr) => {
walker!(@convert_plain [($r, $g, $b)] $marker, $sink, $frame, $opts, |$s, $o, $k| $body);
};
(@convert $marker:ty, $sink:path, $frame:ident, $opts:ty, |$s:ident, $o:ident, $k:ident| $body:expr) => {
walker!(@convert_plain [none] $marker, $sink, $frame, $opts, |$s, $o, $k| $body);
};
(@convert_plain [$face:tt] $marker:ty, $sink:path, $frame:ident, $opts:ty, |$s:ident, $o:ident, $k:ident| $body:expr) => {
walker!($marker, $sink, $frame, $opts, |$s, $o, $k| $body);
#[cfg(any(feature = "std", feature = "alloc"))]
impl $crate::convert::sealed::Sealed for $frame<'_> {}
#[cfg(any(feature = "std", feature = "alloc"))]
impl $crate::convert::Source for $frame<'_> {
type Marker = $marker;
type Options = $opts;
#[inline]
fn dimensions(&self) -> (usize, usize) {
(self.width() as usize, self.height() as usize)
}
#[inline]
fn walk_mixed<R>(
&self,
$o: &$opts,
$k: &mut $crate::sinker::MixedSinker<'_, $marker, R>,
) -> Result<(), $crate::sinker::MixedSinkerError>
where
R: $crate::resample::Resampler,
{
let $s = self;
$body
}
#[inline]
fn attach_rgba<'sink, R>(
sink: &mut $crate::sinker::MixedSinker<'sink, $marker, R>,
buf: &'sink mut [u8],
) -> Result<(), $crate::sinker::MixedSinkerError>
where
R: $crate::resample::Resampler,
{
sink.set_rgba(buf)?;
Ok(())
}
walker!(@rgb_u16_attach $face; $marker);
}
walker!(@rgb_u16_source $face; any(feature = "std", feature = "alloc"); [] $frame<'_>; $marker);
};
(@convert @const $c:ident: $cty:ty; $marker:ty, $sink:ident, $frame:ident, $opts:ty, |$s:ident, $o:ident, $k:ident| $body:expr) => {
walker!(@convert_const [none] $c: $cty; $marker, $sink, $frame, $opts, |$s, $o, $k| $body);
};
(@convert_const [$face:tt] $c:ident: $cty:ty; $marker:ty, $sink:ident, $frame:ident, $opts:ty, |$s:ident, $o:ident, $k:ident| $body:expr) => {
walker!(@const $c: $cty; $marker, $sink, $frame, $opts, |$s, $o, $k| $body);
#[cfg(any(feature = "std", feature = "alloc"))]
impl<const $c: $cty> $crate::convert::sealed::Sealed for $frame<'_, $c> {}
#[cfg(any(feature = "std", feature = "alloc"))]
impl<const $c: $cty> $crate::convert::Source for $frame<'_, $c> {
type Marker = $marker;
type Options = $opts;
#[inline]
fn dimensions(&self) -> (usize, usize) {
(self.width() as usize, self.height() as usize)
}
#[inline]
fn walk_mixed<R>(
&self,
$o: &$opts,
$k: &mut $crate::sinker::MixedSinker<'_, $marker, R>,
) -> Result<(), $crate::sinker::MixedSinkerError>
where
R: $crate::resample::Resampler,
{
let $s = self;
$body
}
#[inline]
fn attach_rgba<'sink, R>(
sink: &mut $crate::sinker::MixedSinker<'sink, $marker, R>,
buf: &'sink mut [u8],
) -> Result<(), $crate::sinker::MixedSinkerError>
where
R: $crate::resample::Resampler,
{
sink.set_rgba(buf)?;
Ok(())
}
walker!(@rgb_u16_attach $face; $marker);
}
walker!(@rgb_u16_source $face; any(feature = "std", feature = "alloc"); [const $c: $cty] $frame<'_, $c>; $marker);
};
(@convert @const(cfg: $src_cfg:meta) $c:ident: $cty:ty; $marker:ty, $sink:ident, $frame:ident, $opts:ty, |$s:ident, $o:ident, $k:ident| $body:expr) => {
walker!(@convert_const_cfg [none] $src_cfg; $c: $cty; $marker, $sink, $frame, $opts, |$s, $o, $k| $body);
};
(@convert_const_cfg [$face:tt] $src_cfg:meta; $c:ident: $cty:ty; $marker:ty, $sink:ident, $frame:ident, $opts:ty, |$s:ident, $o:ident, $k:ident| $body:expr) => {
walker!(@const $c: $cty; $marker, $sink, $frame, $opts, |$s, $o, $k| $body);
#[cfg(all(any(feature = "std", feature = "alloc"), $src_cfg))]
impl<const $c: $cty> $crate::convert::sealed::Sealed for $frame<'_, $c> {}
#[cfg(all(any(feature = "std", feature = "alloc"), $src_cfg))]
impl<const $c: $cty> $crate::convert::Source for $frame<'_, $c> {
type Marker = $marker;
type Options = $opts;
#[inline]
fn dimensions(&self) -> (usize, usize) {
(self.width() as usize, self.height() as usize)
}
#[inline]
fn walk_mixed<R>(
&self,
$o: &$opts,
$k: &mut $crate::sinker::MixedSinker<'_, $marker, R>,
) -> Result<(), $crate::sinker::MixedSinkerError>
where
R: $crate::resample::Resampler,
{
let $s = self;
$body
}
#[inline]
fn attach_rgba<'sink, R>(
sink: &mut $crate::sinker::MixedSinker<'sink, $marker, R>,
buf: &'sink mut [u8],
) -> Result<(), $crate::sinker::MixedSinkerError>
where
R: $crate::resample::Resampler,
{
sink.set_rgba(buf)?;
Ok(())
}
walker!(@rgb_u16_attach $face; $marker);
}
walker!(@rgb_u16_source $face; all(any(feature = "std", feature = "alloc"), $src_cfg); [const $c: $cty] $frame<'_, $c>; $marker);
};
(@convert @const_bits $bits:literal, $be:ident; $marker:ident, $sink:ident, $frame:ident, $opts:ty, |$s:ident, $o:ident, $k:ident| $body:expr) => {
walker!(@const_bits $bits, $be; $marker, $sink, $frame, $opts, |$s, $o, $k| $body);
#[cfg(any(feature = "std", feature = "alloc"))]
impl<const $be: bool> $crate::convert::sealed::Sealed for $frame<'_, $bits, $be> {}
#[cfg(any(feature = "std", feature = "alloc"))]
impl<const $be: bool> $crate::convert::Source for $frame<'_, $bits, $be> {
type Marker = $marker<$be>;
type Options = $opts;
#[inline]
fn dimensions(&self) -> (usize, usize) {
(self.width() as usize, self.height() as usize)
}
#[inline]
fn walk_mixed<R>(
&self,
$o: &$opts,
$k: &mut $crate::sinker::MixedSinker<'_, $marker<$be>, R>,
) -> Result<(), $crate::sinker::MixedSinkerError>
where
R: $crate::resample::Resampler,
{
let $s = self;
$body
}
#[inline]
fn attach_rgba<'sink, R>(
sink: &mut $crate::sinker::MixedSinker<'sink, $marker<$be>, R>,
buf: &'sink mut [u8],
) -> Result<(), $crate::sinker::MixedSinkerError>
where
R: $crate::resample::Resampler,
{
sink.set_rgba(buf)?;
Ok(())
}
walker!(@rgb_u16_attach $bits; $marker<$be>);
}
walker!(@rgb_u16_source $bits; any(feature = "std", feature = "alloc"); [const $be: bool] $frame<'_, $bits, $be>; $marker<$be>);
};
(@rgb_u16_attach none; $marker:ty) => {
#[inline]
fn attach_rgb_u16<'sink, R>(
_sink: &mut $crate::sinker::MixedSinker<'sink, $marker, R>,
_buf: &'sink mut [u16],
) -> Result<(), $crate::sinker::MixedSinkerError>
where
R: $crate::resample::Resampler,
{
Ok(())
}
};
(@rgb_u16_attach $face:tt; $marker:ty) => {
#[inline]
fn attach_rgb_u16<'sink, R>(
sink: &mut $crate::sinker::MixedSinker<'sink, $marker, R>,
buf: &'sink mut [u16],
) -> Result<(), $crate::sinker::MixedSinkerError>
where
R: $crate::resample::Resampler,
{
sink.set_rgb_u16(buf)?;
Ok(())
}
};
(@rgb_u16_source none; $gate:meta; [$($generics:tt)*] $frame:ty; $marker:ty) => {
#[cfg($gate)]
const _: () = {
#[allow(dead_code)]
fn faceless<R: $crate::resample::Resampler, $($generics)*>(
mut sink: $crate::sinker::MixedSinker<'_, $marker, R>,
faceless: $crate::convert::Faceless,
) {
use $crate::convert::FacelessSink as _;
sink.set_rgb_u16(faceless);
let _ = sink.with_rgb_u16(faceless);
}
};
};
(@rgb_u16_source ($r:literal, $g:literal, $b:literal); $gate:meta; [$($generics:tt)*] $frame:ty; $marker:ty) => {
#[cfg($gate)]
impl<$($generics)*> $crate::convert::RgbU16Source for $frame {
const RGB_U16_DEPTHS: $crate::convert::RgbDepths = $crate::convert::RgbDepths::new($r, $g, $b);
}
};
(@rgb_u16_source $depth:literal; $gate:meta; [$($generics:tt)*] $frame:ty; $marker:ty) => {
#[cfg($gate)]
impl<$($generics)*> $crate::convert::RgbU16Source for $frame {
const RGB_U16_DEPTHS: $crate::convert::RgbDepths = $crate::convert::RgbDepths::splat($depth);
}
};
(@const $c:ident: $cty:ty; $marker:ty, $sink:ident, $frame:ident, $opts:ty, |$s:ident, $o:ident, $k:ident| $body:expr) => {
impl<const $c: $cty, S> Walker<S> for $marker
where
S: $sink<$c>,
{
type Frame<'a> = $frame<'a, $c>;
type Options = $opts;
#[inline(always)]
fn walk($s: &Self::Frame<'_>, $o: &Self::Options, $k: &mut S) -> Result<(), S::Error>
where
S: PixelSink,
{
$body
}
}
};
(@const_bits $bits:literal, $be:ident; $marker:ident, $sink:ident, $frame:ident, $opts:ty, |$s:ident, $o:ident, $k:ident| $body:expr) => {
impl<const $be: bool, S> Walker<S> for $marker<$be>
where
S: $sink<$be>,
{
type Frame<'a> = $frame<'a, $bits, $be>;
type Options = $opts;
#[inline(always)]
fn walk($s: &Self::Frame<'_>, $o: &Self::Options, $k: &mut S) -> Result<(), S::Error>
where
S: PixelSink,
{
$body
}
}
};
(@const2 $bits:ident: $bty:ty, $be:ident: $bety:ty; $marker:ident, $sink:ident, $frame:ident, $opts:ty, |$s:ident, $o:ident, $k:ident| $body:expr) => {
impl<const $bits: $bty, const $be: $bety, S> Walker<S> for $marker<$bits, $be>
where
S: $sink<$bits, $be>,
{
type Frame<'a> = $frame<'a, $bits, $be>;
type Options = $opts;
#[inline(always)]
fn walk($s: &Self::Frame<'_>, $o: &Self::Options, $k: &mut S) -> Result<(), S::Error>
where
S: PixelSink,
{
$body
}
}
};
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct YuvOptions {
full_range: bool,
}
impl YuvOptions {
#[inline(always)]
pub const fn new() -> Self {
Self { full_range: false }
}
#[inline]
pub const fn from_color_spec(spec: &ColorSpec) -> Self {
Self {
full_range: spec.full_range,
}
}
#[inline(always)]
pub const fn full_range(&self) -> bool {
self.full_range
}
#[deprecated(note = "use ColorSpec::resolve to pin format-implied ranges")]
#[inline(always)]
pub const fn set_full_range(&mut self) -> &mut Self {
self.full_range = true;
self
}
#[deprecated(note = "use ColorSpec::resolve to pin format-implied ranges")]
#[must_use]
#[inline(always)]
pub const fn with_full_range(mut self) -> Self {
self.full_range = true;
self
}
#[deprecated(note = "use ColorSpec::resolve to pin format-implied ranges")]
#[inline(always)]
pub const fn update_full_range(&mut self, full_range: bool) -> &mut Self {
self.full_range = full_range;
self
}
#[deprecated(note = "use ColorSpec::resolve to pin format-implied ranges")]
#[must_use]
#[inline(always)]
pub const fn maybe_full_range(mut self, full_range: bool) -> Self {
self.full_range = full_range;
self
}
#[deprecated(note = "use ColorSpec::resolve to pin format-implied ranges")]
#[inline(always)]
pub const fn clear_full_range(&mut self) -> &mut Self {
self.full_range = false;
self
}
}
impl Default for YuvOptions {
#[inline(always)]
fn default() -> Self {
Self::new()
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ColorSpec {
format: PixelFormat,
full_range: bool,
matrix: ColorMatrix,
primaries: Primaries,
transfer: Transfer,
chroma_location: ChromaLocation,
}
impl ColorSpec {
#[inline]
pub fn resolve(fmt: PixelFormat, stream_range: DynamicRange, matrix: ColorMatrix) -> Self {
Self::from_info(
fmt,
ColorInfo::UNSPECIFIED
.with_range(stream_range)
.with_matrix(matrix),
)
}
#[inline]
pub fn from_info(fmt: PixelFormat, stream: ColorInfo) -> Self {
let (format, pinned) = fmt.canonical();
let range = match pinned {
Some(pinned_range) => pinned_range,
None => stream.range(),
};
Self {
format,
full_range: matches!(range, DynamicRange::Full),
matrix: stream.matrix(),
primaries: stream.primaries(),
transfer: stream.transfer(),
chroma_location: stream.chroma_location(),
}
}
#[inline]
pub fn of_matrix(matrix: KernelMatrix) -> Self {
Self::from_info(
PixelFormat::None,
ColorInfo::UNSPECIFIED.with_matrix(ColorMatrix::from(matrix)),
)
}
#[inline(always)]
pub fn format(&self) -> PixelFormat {
self.format.clone()
}
#[inline(always)]
pub const fn full_range(&self) -> bool {
self.full_range
}
#[inline(always)]
pub fn matrix(&self) -> ColorMatrix {
self.matrix.clone()
}
#[inline]
pub fn kernel_matrix(&self) -> Result<KernelMatrix, UnsupportedKernelMatrixError> {
match &self.matrix {
ColorMatrix::Ictcp
| ColorMatrix::ChromaDerivedCl
| ColorMatrix::IptC2
| ColorMatrix::Smpte2085
| ColorMatrix::Rgb => Ok(KernelMatrix::Bt709),
other => KernelMatrix::try_from(other),
}
}
#[inline(always)]
pub fn primaries(&self) -> Primaries {
self.primaries.clone()
}
#[inline(always)]
pub fn transfer(&self) -> Transfer {
self.transfer.clone()
}
#[inline(always)]
pub fn chroma_location(&self) -> ChromaLocation {
self.chroma_location.clone()
}
}
#[cfg(feature = "bayer")]
#[cfg_attr(docsrs, doc(cfg(feature = "bayer")))]
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct BayerOptions {
pattern: crate::raw::BayerPattern,
demosaic: crate::raw::BayerDemosaic,
wb: crate::raw::WhiteBalance,
ccm: crate::raw::ColorCorrectionMatrix,
}
#[cfg(feature = "bayer")]
#[cfg_attr(docsrs, doc(cfg(feature = "bayer")))]
impl BayerOptions {
#[inline(always)]
pub const fn new(pattern: crate::raw::BayerPattern) -> Self {
Self {
pattern,
demosaic: crate::raw::BayerDemosaic::Bilinear,
wb: crate::raw::WhiteBalance::neutral(),
ccm: crate::raw::ColorCorrectionMatrix::identity(),
}
}
#[inline(always)]
pub const fn pattern(&self) -> crate::raw::BayerPattern {
self.pattern
}
#[inline(always)]
pub const fn demosaic(&self) -> crate::raw::BayerDemosaic {
self.demosaic
}
#[inline(always)]
pub const fn wb(&self) -> crate::raw::WhiteBalance {
self.wb
}
#[inline(always)]
pub const fn ccm(&self) -> crate::raw::ColorCorrectionMatrix {
self.ccm
}
#[must_use]
#[inline(always)]
pub const fn with_demosaic(mut self, demosaic: crate::raw::BayerDemosaic) -> Self {
self.demosaic = demosaic;
self
}
#[must_use]
#[inline(always)]
pub const fn with_wb(mut self, wb: crate::raw::WhiteBalance) -> Self {
self.wb = wb;
self
}
#[must_use]
#[inline(always)]
pub const fn with_ccm(mut self, ccm: crate::raw::ColorCorrectionMatrix) -> Self {
self.ccm = ccm;
self
}
}
#[cfg(feature = "xyz")]
#[cfg_attr(docsrs, doc(cfg(feature = "xyz")))]
walker!(@convert @rgb_u16(16) @const BE: bool; Xyz12<BE>, Xyz12Sink, Xyz12Frame, (),
|src, opts, sink| { let _ = opts; xyz12_to::<BE, _>(src, sink) });
#[cfg(feature = "bayer")]
#[cfg_attr(docsrs, doc(cfg(feature = "bayer")))]
walker!(
Bayer,
BayerSink,
BayerFrame,
BayerOptions,
|src, opts, sink| bayer_to(
src,
opts.pattern(),
opts.demosaic(),
opts.wb(),
opts.ccm(),
sink
)
);
#[cfg(feature = "bayer")]
#[cfg_attr(docsrs, doc(cfg(feature = "bayer")))]
walker!(@const2 BITS: u32, BE: bool; Bayer16, BayerSink16, BayerFrame16, BayerOptions,
|src, opts, sink| bayer16_to_endian::<BITS, BE, _>(src, opts.pattern(), opts.demosaic(), opts.wb(), opts.ccm(), sink));
#[cfg(feature = "mono")]
#[cfg_attr(docsrs, doc(cfg(feature = "mono")))]
walker!(@convert @rgb_u16(16) Pal8, Pal8Sink, Pal8Frame, (), |src, _opts, sink| pal8_to(
src, sink
));
#[cfg(feature = "mono")]
#[cfg_attr(docsrs, doc(cfg(feature = "mono")))]
walker!(@convert @rgb_u16(8)
Monoblack,
MonoblackSink,
MonoblackFrame,
YuvOptions,
|src, opts, sink| monoblack_to(src, opts.full_range(), sink)
);
#[cfg(feature = "mono")]
#[cfg_attr(docsrs, doc(cfg(feature = "mono")))]
walker!(@convert @rgb_u16(8)
Monowhite,
MonowhiteSink,
MonowhiteFrame,
YuvOptions,
|src, opts, sink| monowhite_to(src, opts.full_range(), sink)
);
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert
Yuv420p,
Yuv420pSink,
Yuv420pFrame,
YuvOptions,
|src, opts, sink| yuv420p_to(src, opts.full_range(), sink)
);
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert
Yuv422p,
Yuv422pSink,
Yuv422pFrame,
YuvOptions,
|src, opts, sink| yuv422p_to(src, opts.full_range(), sink)
);
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert
Yuv444p,
Yuv444pSink,
Yuv444pFrame,
YuvOptions,
|src, opts, sink| yuv444p_to(src, opts.full_range(), sink)
);
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert
Yuv440p,
Yuv440pSink,
Yuv440pFrame,
YuvOptions,
|src, opts, sink| yuv440p_to(src, opts.full_range(), sink)
);
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert
Yuv410p,
Yuv410pSink,
Yuv410pFrame,
YuvOptions,
|src, opts, sink| yuv410p_to(src, opts.full_range(), sink)
);
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert
Yuv411p,
Yuv411pSink,
Yuv411pFrame,
YuvOptions,
|src, opts, sink| yuv411p_to(src, opts.full_range(), sink)
);
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert @const_bits 9, BE; Yuv420p9, Yuv420p9Sink, Yuv420pFrame16, YuvOptions,
|src, opts, sink| yuv420p9_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert @const_bits 10, BE; Yuv420p10, Yuv420p10Sink, Yuv420pFrame16, YuvOptions,
|src, opts, sink| yuv420p10_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert @const_bits 12, BE; Yuv420p12, Yuv420p12Sink, Yuv420pFrame16, YuvOptions,
|src, opts, sink| yuv420p12_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert @const_bits 14, BE; Yuv420p14, Yuv420p14Sink, Yuv420pFrame16, YuvOptions,
|src, opts, sink| yuv420p14_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert @const_bits 16, BE; Yuv420p16, Yuv420p16Sink, Yuv420pFrame16, YuvOptions,
|src, opts, sink| yuv420p16_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert @const_bits 9, BE; Yuv422p9, Yuv422p9Sink, Yuv422pFrame16, YuvOptions,
|src, opts, sink| yuv422p9_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert @const_bits 10, BE; Yuv422p10, Yuv422p10Sink, Yuv422pFrame16, YuvOptions,
|src, opts, sink| yuv422p10_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert @const_bits 12, BE; Yuv422p12, Yuv422p12Sink, Yuv422pFrame16, YuvOptions,
|src, opts, sink| yuv422p12_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert @const_bits 14, BE; Yuv422p14, Yuv422p14Sink, Yuv422pFrame16, YuvOptions,
|src, opts, sink| yuv422p14_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert @const_bits 16, BE; Yuv422p16, Yuv422p16Sink, Yuv422pFrame16, YuvOptions,
|src, opts, sink| yuv422p16_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert @const_bits 9, BE; Yuv444p9, Yuv444p9Sink, Yuv444pFrame16, YuvOptions,
|src, opts, sink| yuv444p9_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert @const_bits 10, BE; Yuv444p10, Yuv444p10Sink, Yuv444pFrame16, YuvOptions,
|src, opts, sink| yuv444p10_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert @const_bits 12, BE; Yuv444p12, Yuv444p12Sink, Yuv444pFrame16, YuvOptions,
|src, opts, sink| yuv444p12_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert @const_bits 10, BE; Yuv444p10Msb, Yuv444p10MsbSink, Yuv444pMsbFrame, YuvOptions,
|src, opts, sink| yuv444p10_msb_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert @const_bits 12, BE; Yuv444p12Msb, Yuv444p12MsbSink, Yuv444pMsbFrame, YuvOptions,
|src, opts, sink| yuv444p12_msb_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert @const_bits 14, BE; Yuv444p14, Yuv444p14Sink, Yuv444pFrame16, YuvOptions,
|src, opts, sink| yuv444p14_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert @const_bits 16, BE; Yuv444p16, Yuv444p16Sink, Yuv444pFrame16, YuvOptions,
|src, opts, sink| yuv444p16_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert @const_bits 10, BE; Yuv440p10, Yuv440p10Sink, Yuv440pFrame16, YuvOptions,
|src, opts, sink| yuv440p10_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-planar")))]
walker!(@convert @const_bits 12, BE; Yuv440p12, Yuv440p12Sink, Yuv440pFrame16, YuvOptions,
|src, opts, sink| yuv440p12_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-semi-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-semi-planar")))]
walker!(@convert Nv12, Nv12Sink, Nv12Frame, YuvOptions, |src, opts, sink| {
nv12_to(src, opts.full_range(), sink)
});
#[cfg(feature = "yuv-semi-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-semi-planar")))]
walker!(@convert Nv16, Nv16Sink, Nv16Frame, YuvOptions, |src, opts, sink| {
nv16_to(src, opts.full_range(), sink)
});
#[cfg(feature = "yuv-semi-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-semi-planar")))]
walker!(@convert Nv21, Nv21Sink, Nv21Frame, YuvOptions, |src, opts, sink| {
nv21_to(src, opts.full_range(), sink)
});
#[cfg(feature = "yuv-semi-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-semi-planar")))]
walker!(@convert Nv24, Nv24Sink, Nv24Frame, YuvOptions, |src, opts, sink| {
nv24_to(src, opts.full_range(), sink)
});
#[cfg(feature = "yuv-semi-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-semi-planar")))]
walker!(@convert Nv42, Nv42Sink, Nv42Frame, YuvOptions, |src, opts, sink| {
nv42_to(src, opts.full_range(), sink)
});
#[cfg(feature = "yuv-semi-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-semi-planar")))]
walker!(@convert @rgb_u16(10) @const BE: bool; Nv20<BE>, Nv20Sink, Nv20Frame, YuvOptions,
|src, opts, sink| nv20_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-semi-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-semi-planar")))]
walker!(@convert @const_bits 10, BE; P010, P010Sink, PnFrame, YuvOptions,
|src, opts, sink| p010_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-semi-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-semi-planar")))]
walker!(@convert @const_bits 12, BE; P012, P012Sink, PnFrame, YuvOptions,
|src, opts, sink| p012_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-semi-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-semi-planar")))]
walker!(@convert @const_bits 16, BE; P016, P016Sink, PnFrame, YuvOptions,
|src, opts, sink| p016_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-semi-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-semi-planar")))]
walker!(@convert @const_bits 10, BE; P210, P210Sink, PnFrame422, YuvOptions,
|src, opts, sink| p210_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-semi-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-semi-planar")))]
walker!(@convert @const_bits 12, BE; P212, P212Sink, PnFrame422, YuvOptions,
|src, opts, sink| p212_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-semi-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-semi-planar")))]
walker!(@convert @const_bits 16, BE; P216, P216Sink, PnFrame422, YuvOptions,
|src, opts, sink| p216_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-semi-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-semi-planar")))]
walker!(@convert @const_bits 10, BE; P410, P410Sink, PnFrame444, YuvOptions,
|src, opts, sink| p410_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-semi-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-semi-planar")))]
walker!(@convert @const_bits 12, BE; P412, P412Sink, PnFrame444, YuvOptions,
|src, opts, sink| p412_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-semi-planar")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-semi-planar")))]
walker!(@convert @const_bits 16, BE; P416, P416Sink, PnFrame444, YuvOptions,
|src, opts, sink| p416_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-packed")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-packed")))]
walker!(@convert
Yuyv422,
Yuyv422Sink,
Yuyv422Frame,
YuvOptions,
|src, opts, sink| yuyv422_to(src, opts.full_range(), sink)
);
#[cfg(feature = "yuv-packed")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-packed")))]
walker!(@convert
Uyvy422,
Uyvy422Sink,
Uyvy422Frame,
YuvOptions,
|src, opts, sink| uyvy422_to(src, opts.full_range(), sink)
);
#[cfg(feature = "yuv-packed")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-packed")))]
walker!(@convert
Yvyu422,
Yvyu422Sink,
Yvyu422Frame,
YuvOptions,
|src, opts, sink| yvyu422_to(src, opts.full_range(), sink)
);
#[cfg(feature = "yuv-packed")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-packed")))]
walker!(@convert
Uyyvyy411,
Uyyvyy411Sink,
Uyyvyy411Frame,
YuvOptions,
|src, opts, sink| uyyvyy411_to(src, opts.full_range(), sink)
);
#[cfg(feature = "y2xx")]
#[cfg_attr(docsrs, doc(cfg(feature = "y2xx")))]
walker!(@convert @const_bits 10, BE; Y210, Y210Sink, Y2xxFrame, YuvOptions,
|src, opts, sink| y210_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "y2xx")]
#[cfg_attr(docsrs, doc(cfg(feature = "y2xx")))]
walker!(@convert @const_bits 12, BE; Y212, Y212Sink, Y2xxFrame, YuvOptions,
|src, opts, sink| y212_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "y2xx")]
#[cfg_attr(docsrs, doc(cfg(feature = "y2xx")))]
walker!(@convert @const_bits 16, BE; Y216, Y216Sink, Y2xxFrame, YuvOptions,
|src, opts, sink| y216_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-444-packed")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-444-packed")))]
walker!(@convert Vuya, VuyaSink, VuyaFrame, YuvOptions, |src, opts, sink| {
vuya_to(src, opts.full_range(), sink)
});
#[cfg(feature = "yuv-444-packed")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-444-packed")))]
walker!(@convert Vuyx, VuyxSink, VuyxFrame, YuvOptions, |src, opts, sink| {
vuyx_to(src, opts.full_range(), sink)
});
#[cfg(feature = "yuv-444-packed")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-444-packed")))]
walker!(@convert Ayuv, AyuvSink, AyuvFrame, YuvOptions, |src, opts, sink| {
ayuv_to(src, opts.full_range(), sink)
});
#[cfg(feature = "yuv-444-packed")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-444-packed")))]
walker!(@convert Uyva, UyvaSink, UyvaFrame, YuvOptions, |src, opts, sink| {
uyva_to(src, opts.full_range(), sink)
});
#[cfg(feature = "yuv-444-packed")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-444-packed")))]
#[rustfmt::skip]
walker!(@convert Vyu444, Vyu444Sink, Vyu444Frame, YuvOptions, |src, opts, sink| {
vyu444_to(src, opts.full_range(), sink)
});
#[cfg(feature = "yuv-444-packed")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-444-packed")))]
walker!(@convert @rgb_u16(10) V30X, V30XSink, V30XFrame, YuvOptions, |src, opts, sink| {
v30x_to(src, opts.full_range(), sink)
});
#[cfg(feature = "yuv-444-packed")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-444-packed")))]
walker!(@convert @rgb_u16(10) @const BE: bool; V410<BE>, V410Sink, V410Frame, YuvOptions,
|src, opts, sink| v410_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-444-packed")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-444-packed")))]
walker!(@convert @rgb_u16(12) @const BE: bool; Xv36<BE>, Xv36Sink, Xv36Frame, YuvOptions,
|src, opts, sink| xv36_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-444-packed")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-444-packed")))]
walker!(@convert @rgb_u16(16) @const BE: bool; Xv48<BE>, Xv48Sink, Xv48Frame, YuvOptions,
|src, opts, sink| xv48_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuv-444-packed")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuv-444-packed")))]
walker!(@convert @rgb_u16(16) @const BE: bool; Ayuv64<BE>, Ayuv64Sink, Ayuv64Frame, YuvOptions,
|src, opts, sink| ayuv64_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "v210")]
#[cfg_attr(docsrs, doc(cfg(feature = "v210")))]
walker!(@convert @rgb_u16(10) @const BE: bool; V210<BE>, V210Sink, V210Frame, YuvOptions,
|src, opts, sink| v210_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuva")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuva")))]
walker!(@convert
Yuva420p,
Yuva420pSink,
Yuva420pFrame,
YuvOptions,
|src, opts, sink| yuva420p_to(src, opts.full_range(), sink)
);
#[cfg(feature = "yuva")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuva")))]
walker!(@convert
Yuva422p,
Yuva422pSink,
Yuva422pFrame,
YuvOptions,
|src, opts, sink| yuva422p_to(src, opts.full_range(), sink)
);
#[cfg(feature = "yuva")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuva")))]
walker!(@convert
Yuva444p,
Yuva444pSink,
Yuva444pFrame,
YuvOptions,
|src, opts, sink| yuva444p_to(src, opts.full_range(), sink)
);
#[cfg(feature = "yuva")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuva")))]
walker!(@convert @const_bits 9, BE; Yuva420p9, Yuva420p9Sink, Yuva420pFrame16, YuvOptions,
|src, opts, sink| yuva420p9_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuva")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuva")))]
walker!(@convert @const_bits 10, BE; Yuva420p10, Yuva420p10Sink, Yuva420pFrame16, YuvOptions,
|src, opts, sink| yuva420p10_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuva")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuva")))]
walker!(@convert @const_bits 12, BE; Yuva420p12, Yuva420p12Sink, Yuva420pFrame16, YuvOptions,
|src, opts, sink| yuva420p12_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuva")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuva")))]
walker!(@convert @const_bits 16, BE; Yuva420p16, Yuva420p16Sink, Yuva420pFrame16, YuvOptions,
|src, opts, sink| yuva420p16_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuva")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuva")))]
walker!(@convert @const_bits 9, BE; Yuva422p9, Yuva422p9Sink, Yuva422pFrame16, YuvOptions,
|src, opts, sink| yuva422p9_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuva")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuva")))]
walker!(@convert @const_bits 10, BE; Yuva422p10, Yuva422p10Sink, Yuva422pFrame16, YuvOptions,
|src, opts, sink| yuva422p10_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuva")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuva")))]
walker!(@convert @const_bits 12, BE; Yuva422p12, Yuva422p12Sink, Yuva422pFrame16, YuvOptions,
|src, opts, sink| yuva422p12_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuva")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuva")))]
walker!(@convert @const_bits 16, BE; Yuva422p16, Yuva422p16Sink, Yuva422pFrame16, YuvOptions,
|src, opts, sink| yuva422p16_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuva")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuva")))]
walker!(@convert @const_bits 9, BE; Yuva444p9, Yuva444p9Sink, Yuva444pFrame16, YuvOptions,
|src, opts, sink| yuva444p9_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuva")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuva")))]
walker!(@convert @const_bits 10, BE; Yuva444p10, Yuva444p10Sink, Yuva444pFrame16, YuvOptions,
|src, opts, sink| yuva444p10_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuva")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuva")))]
walker!(@convert @const_bits 12, BE; Yuva444p12, Yuva444p12Sink, Yuva444pFrame16, YuvOptions,
|src, opts, sink| yuva444p12_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuva")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuva")))]
walker!(@convert @const_bits 14, BE; Yuva444p14, Yuva444p14Sink, Yuva444pFrame16, YuvOptions,
|src, opts, sink| yuva444p14_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "yuva")]
#[cfg_attr(docsrs, doc(cfg(feature = "yuva")))]
walker!(@convert @const_bits 16, BE; Yuva444p16, Yuva444p16Sink, Yuva444pFrame16, YuvOptions,
|src, opts, sink| yuva444p16_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "rgb")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb")))]
walker!(@convert
Rgb24,
Rgb24Sink,
Rgb24Frame,
YuvOptions,
|src, opts, sink| rgb24_to(src, opts.full_range(), sink)
);
#[cfg(feature = "rgb")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb")))]
walker!(@convert
Bgr24,
Bgr24Sink,
Bgr24Frame,
YuvOptions,
|src, opts, sink| bgr24_to(src, opts.full_range(), sink)
);
#[cfg(feature = "rgb")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb")))]
walker!(@convert Rgba, RgbaSink, RgbaFrame, YuvOptions, |src, opts, sink| {
rgba_to(src, opts.full_range(), sink)
});
#[cfg(feature = "rgb")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb")))]
walker!(@convert Bgra, BgraSink, BgraFrame, YuvOptions, |src, opts, sink| {
bgra_to(src, opts.full_range(), sink)
});
#[cfg(feature = "rgb")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb")))]
walker!(@convert Argb, ArgbSink, ArgbFrame, YuvOptions, |src, opts, sink| {
argb_to(src, opts.full_range(), sink)
});
#[cfg(feature = "rgb")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb")))]
walker!(@convert Abgr, AbgrSink, AbgrFrame, YuvOptions, |src, opts, sink| {
abgr_to(src, opts.full_range(), sink)
});
#[cfg(feature = "rgb")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb")))]
walker!(@convert Xrgb, XrgbSink, XrgbFrame, YuvOptions, |src, opts, sink| {
xrgb_to(src, opts.full_range(), sink)
});
#[cfg(feature = "rgb")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb")))]
walker!(@convert Rgbx, RgbxSink, RgbxFrame, YuvOptions, |src, opts, sink| {
rgbx_to(src, opts.full_range(), sink)
});
#[cfg(feature = "rgb")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb")))]
walker!(@convert Xbgr, XbgrSink, XbgrFrame, YuvOptions, |src, opts, sink| {
xbgr_to(src, opts.full_range(), sink)
});
#[cfg(feature = "rgb")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb")))]
walker!(@convert Bgrx, BgrxSink, BgrxFrame, YuvOptions, |src, opts, sink| {
bgrx_to(src, opts.full_range(), sink)
});
#[cfg(feature = "rgb")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb")))]
walker!(@convert @rgb_u16(16) @const BE: bool; Rgb48<BE>, Rgb48Sink, Rgb48Frame, YuvOptions,
|src, opts, sink| rgb48_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "rgb")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb")))]
walker!(@convert @rgb_u16(16) @const BE: bool; Bgr48<BE>, Bgr48Sink, Bgr48Frame, YuvOptions,
|src, opts, sink| bgr48_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "rgb")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb")))]
walker!(@convert @rgb_u16(16) @const BE: bool; Rgba64<BE>, Rgba64Sink, Rgba64Frame, YuvOptions,
|src, opts, sink| rgba64_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "rgb")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb")))]
walker!(@convert @rgb_u16(16) @const BE: bool; Bgra64<BE>, Bgra64Sink, Bgra64Frame, YuvOptions,
|src, opts, sink| bgra64_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "rgb")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb")))]
walker!(@convert @rgb_u16(16) @const BE: bool; Rgb96<BE>, Rgb96Sink, Rgb96Frame, YuvOptions,
|src, opts, sink| rgb96_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "rgb")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb")))]
walker!(@convert @rgb_u16(16) @const BE: bool; Rgba128<BE>, Rgba128Sink, Rgba128Frame, YuvOptions,
|src, opts, sink| rgba128_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "rgb")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb")))]
walker!(@convert @rgb_u16(10) @const BE: bool; X2Rgb10<BE>, X2Rgb10Sink, X2Rgb10Frame, YuvOptions,
|src, opts, sink| x2rgb10_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "rgb")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb")))]
walker!(@convert @rgb_u16(10) @const BE: bool; X2Bgr10<BE>, X2Bgr10Sink, X2Bgr10Frame, YuvOptions,
|src, opts, sink| x2bgr10_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "rgb-float")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb-float")))]
walker!(@convert @rgb_u16(16) @const(cfg: any(feature = "rgb", feature = "yuv-planar")) BE: bool; Rgbf16<BE>, Rgbf16Sink, Rgbf16Frame, YuvOptions,
|src, opts, sink| rgbf16_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "rgb-float")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb-float")))]
walker!(@convert @rgb_u16(16) @const(cfg: any(feature = "rgb", feature = "yuv-planar")) BE: bool; Rgbf32<BE>, Rgbf32Sink, Rgbf32Frame, YuvOptions,
|src, opts, sink| rgbf32_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "rgb-float")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb-float")))]
walker!(@convert @rgb_u16(16) @const(cfg: any(feature = "rgb", feature = "yuv-planar")) BE: bool; Rgbaf16<BE>, Rgbaf16Sink, Rgbaf16Frame, YuvOptions,
|src, opts, sink| rgbaf16_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "rgb-float")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb-float")))]
walker!(@convert @rgb_u16(16) @const(cfg: any(feature = "rgb", feature = "yuv-planar")) BE: bool; Rgbaf32<BE>, Rgbaf32Sink, Rgbaf32Frame, YuvOptions,
|src, opts, sink| rgbaf32_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "rgb-legacy")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb-legacy")))]
walker!(@convert @rgb_u16(5, 6, 5)
Rgb565,
Rgb565Sink,
Rgb565Frame,
YuvOptions,
|src, opts, sink| rgb565_to(src, opts.full_range(), sink)
);
#[cfg(feature = "rgb-legacy")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb-legacy")))]
walker!(@convert @rgb_u16(5, 6, 5)
Bgr565,
Bgr565Sink,
Bgr565Frame,
YuvOptions,
|src, opts, sink| bgr565_to(src, opts.full_range(), sink)
);
#[cfg(feature = "rgb-legacy")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb-legacy")))]
walker!(@convert @rgb_u16(5)
Rgb555,
Rgb555Sink,
Rgb555Frame,
YuvOptions,
|src, opts, sink| rgb555_to(src, opts.full_range(), sink)
);
#[cfg(feature = "rgb-legacy")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb-legacy")))]
walker!(@convert @rgb_u16(5)
Bgr555,
Bgr555Sink,
Bgr555Frame,
YuvOptions,
|src, opts, sink| bgr555_to(src, opts.full_range(), sink)
);
#[cfg(feature = "rgb-legacy")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb-legacy")))]
walker!(@convert @rgb_u16(4)
Rgb444,
Rgb444Sink,
Rgb444Frame,
YuvOptions,
|src, opts, sink| rgb444_to(src, opts.full_range(), sink)
);
#[cfg(feature = "rgb-legacy")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb-legacy")))]
walker!(@convert @rgb_u16(4)
Bgr444,
Bgr444Sink,
Bgr444Frame,
YuvOptions,
|src, opts, sink| bgr444_to(src, opts.full_range(), sink)
);
#[cfg(feature = "rgb-legacy")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb-legacy")))]
walker!(@convert @rgb_u16(3, 3, 2) Rgb8, Rgb8Sink, Rgb8Frame, YuvOptions, |src, opts, sink| {
rgb8_to(src, opts.full_range(), sink)
});
#[cfg(feature = "rgb-legacy")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb-legacy")))]
walker!(@convert @rgb_u16(3, 3, 2) Bgr8, Bgr8Sink, Bgr8Frame, YuvOptions, |src, opts, sink| {
bgr8_to(src, opts.full_range(), sink)
});
#[cfg(feature = "rgb-legacy")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb-legacy")))]
walker!(@convert @rgb_u16(1, 2, 1)
Rgb4Byte,
Rgb4ByteSink,
Rgb4ByteFrame,
YuvOptions,
|src, opts, sink| rgb4_byte_to(src, opts.full_range(), sink)
);
#[cfg(feature = "rgb-legacy")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb-legacy")))]
walker!(@convert @rgb_u16(1, 2, 1)
Bgr4Byte,
Bgr4ByteSink,
Bgr4ByteFrame,
YuvOptions,
|src, opts, sink| bgr4_byte_to(src, opts.full_range(), sink)
);
#[cfg(feature = "rgb-legacy")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb-legacy")))]
walker!(@convert @rgb_u16(1, 2, 1) Rgb4, Rgb4Sink, Rgb4Frame, YuvOptions, |src, opts, sink| {
rgb4_to(src, opts.full_range(), sink)
});
#[cfg(feature = "rgb-legacy")]
#[cfg_attr(docsrs, doc(cfg(feature = "rgb-legacy")))]
walker!(@convert @rgb_u16(1, 2, 1) Bgr4, Bgr4Sink, Bgr4Frame, YuvOptions, |src, opts, sink| {
bgr4_to(src, opts.full_range(), sink)
});
#[cfg(feature = "gray")]
#[cfg_attr(docsrs, doc(cfg(feature = "gray")))]
walker!(@convert
Gray8,
Gray8Sink,
Gray8Frame,
YuvOptions,
|src, opts, sink| gray8_to(src, opts.full_range(), sink)
);
#[cfg(feature = "gray")]
#[cfg_attr(docsrs, doc(cfg(feature = "gray")))]
walker!(@convert @rgb_u16(8)
Ya8,
Ya8Sink,
Ya8Frame,
YuvOptions,
|src, opts, sink| ya8_to(src, opts.full_range(), sink)
);
#[cfg(feature = "gray")]
#[cfg_attr(docsrs, doc(cfg(feature = "gray")))]
walker!(@convert @const_bits 9, BE; Gray9, Gray9Sink, GrayNFrame, YuvOptions,
|src, opts, sink| gray9_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "gray")]
#[cfg_attr(docsrs, doc(cfg(feature = "gray")))]
walker!(@convert @const_bits 10, BE; Gray10, Gray10Sink, GrayNFrame, YuvOptions,
|src, opts, sink| gray10_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "gray")]
#[cfg_attr(docsrs, doc(cfg(feature = "gray")))]
walker!(@convert @const_bits 12, BE; Gray12, Gray12Sink, GrayNFrame, YuvOptions,
|src, opts, sink| gray12_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "gray")]
#[cfg_attr(docsrs, doc(cfg(feature = "gray")))]
walker!(@convert @const_bits 14, BE; Gray14, Gray14Sink, GrayNFrame, YuvOptions,
|src, opts, sink| gray14_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "gray")]
#[cfg_attr(docsrs, doc(cfg(feature = "gray")))]
walker!(@convert @rgb_u16(16) @const BE: bool; Gray16<BE>, Gray16Sink, Gray16Frame, YuvOptions,
|src, opts, sink| gray16_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "gray")]
#[cfg_attr(docsrs, doc(cfg(feature = "gray")))]
walker!(@convert @rgb_u16(16) @const BE: bool; Gray32<BE>, Gray32Sink, Gray32Frame, YuvOptions,
|src, opts, sink| gray32_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "gray")]
#[cfg_attr(docsrs, doc(cfg(feature = "gray")))]
walker!(@convert @rgb_u16(16) @const BE: bool; Ya16<BE>, Ya16Sink, Ya16Frame, YuvOptions,
|src, opts, sink| ya16_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "gray")]
#[cfg_attr(docsrs, doc(cfg(feature = "gray")))]
walker!(@convert @rgb_u16(16) @const BE: bool; Grayf16<BE>, Grayf16Sink, Grayf16Frame, YuvOptions,
|src, opts, sink| grayf16_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "gray")]
#[cfg_attr(docsrs, doc(cfg(feature = "gray")))]
walker!(@convert @rgb_u16(16) @const BE: bool; Grayf32<BE>, Grayf32Sink, Grayf32Frame, YuvOptions,
|src, opts, sink| grayf32_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "gray")]
#[cfg_attr(docsrs, doc(cfg(feature = "gray")))]
walker!(@convert @rgb_u16(16) @const BE: bool; Yaf16<BE>, Yaf16Sink, Yaf16Frame, YuvOptions,
|src, opts, sink| yaf16_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "gray")]
#[cfg_attr(docsrs, doc(cfg(feature = "gray")))]
walker!(@convert @rgb_u16(16) @const BE: bool; Yaf32<BE>, Yaf32Sink, Yaf32Frame, YuvOptions,
|src, opts, sink| yaf32_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "gbr")]
#[cfg_attr(docsrs, doc(cfg(feature = "gbr")))]
walker!(@convert Gbrp, GbrpSink, GbrpFrame, YuvOptions, |src, opts, sink| {
gbrp_to(src, opts.full_range(), sink)
});
#[cfg(feature = "gbr")]
#[cfg_attr(docsrs, doc(cfg(feature = "gbr")))]
walker!(@convert
Gbrap,
GbrapSink,
GbrapFrame,
YuvOptions,
|src, opts, sink| gbrap_to(src, opts.full_range(), sink)
);
#[cfg(feature = "gbr")]
#[cfg_attr(docsrs, doc(cfg(feature = "gbr")))]
walker!(@convert @const_bits 9, BE; Gbrp9, Gbrp9Sink, GbrpHighBitFrame, YuvOptions,
|src, opts, sink| gbrp9_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "gbr")]
#[cfg_attr(docsrs, doc(cfg(feature = "gbr")))]
walker!(@convert @const_bits 10, BE; Gbrp10, Gbrp10Sink, GbrpHighBitFrame, YuvOptions,
|src, opts, sink| gbrp10_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "gbr")]
#[cfg_attr(docsrs, doc(cfg(feature = "gbr")))]
walker!(@convert @const_bits 12, BE; Gbrp12, Gbrp12Sink, GbrpHighBitFrame, YuvOptions,
|src, opts, sink| gbrp12_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "gbr")]
#[cfg_attr(docsrs, doc(cfg(feature = "gbr")))]
walker!(@convert @const_bits 14, BE; Gbrp14, Gbrp14Sink, GbrpHighBitFrame, YuvOptions,
|src, opts, sink| gbrp14_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "gbr")]
#[cfg_attr(docsrs, doc(cfg(feature = "gbr")))]
walker!(@convert @const_bits 16, BE; Gbrp16, Gbrp16Sink, GbrpHighBitFrame, YuvOptions,
|src, opts, sink| gbrp16_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "gbr")]
#[cfg_attr(docsrs, doc(cfg(feature = "gbr")))]
walker!(@convert @const_bits 10, BE; Gbrap10, Gbrap10Sink, GbrapHighBitFrame, YuvOptions,
|src, opts, sink| gbrap10_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "gbr")]
#[cfg_attr(docsrs, doc(cfg(feature = "gbr")))]
walker!(@convert @const_bits 12, BE; Gbrap12, Gbrap12Sink, GbrapHighBitFrame, YuvOptions,
|src, opts, sink| gbrap12_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "gbr")]
#[cfg_attr(docsrs, doc(cfg(feature = "gbr")))]
walker!(@convert @const_bits 14, BE; Gbrap14, Gbrap14Sink, GbrapHighBitFrame, YuvOptions,
|src, opts, sink| gbrap14_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "gbr")]
#[cfg_attr(docsrs, doc(cfg(feature = "gbr")))]
walker!(@convert @const_bits 16, BE; Gbrap16, Gbrap16Sink, GbrapHighBitFrame, YuvOptions,
|src, opts, sink| gbrap16_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "gbr")]
#[cfg_attr(docsrs, doc(cfg(feature = "gbr")))]
walker!(@convert @rgb_u16(16) @const BE: bool; Gbrap32<BE>, Gbrap32Sink, Gbrap32Frame, YuvOptions,
|src, opts, sink| gbrap32_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "gbr")]
#[cfg_attr(docsrs, doc(cfg(feature = "gbr")))]
walker!(@convert @const_bits 10, BE; Gbrp10Msb, Gbrp10MsbSink, GbrpMsbFrame, YuvOptions,
|src, opts, sink| gbrp10_msb_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "gbr")]
#[cfg_attr(docsrs, doc(cfg(feature = "gbr")))]
walker!(@convert @const_bits 12, BE; Gbrp12Msb, Gbrp12MsbSink, GbrpMsbFrame, YuvOptions,
|src, opts, sink| gbrp12_msb_to_endian::<_, BE>(src, opts.full_range(), sink));
#[cfg(feature = "gbr")]
#[cfg_attr(docsrs, doc(cfg(feature = "gbr")))]
walker!(@convert @rgb_u16(16) @const BE: bool; Gbrpf16<BE>, Gbrpf16Sink, Gbrpf16Frame, (),
|src, _opts, sink| gbrpf16_to_endian::<_, BE>(src, sink));
#[cfg(feature = "gbr")]
#[cfg_attr(docsrs, doc(cfg(feature = "gbr")))]
walker!(@convert @rgb_u16(16) @const BE: bool; Gbrpf32<BE>, Gbrpf32Sink, Gbrpf32Frame, (),
|src, _opts, sink| gbrpf32_to_endian::<_, BE>(src, sink));
#[cfg(feature = "gbr")]
#[cfg_attr(docsrs, doc(cfg(feature = "gbr")))]
walker!(@convert @rgb_u16(16) @const BE: bool; Gbrapf16<BE>, Gbrapf16Sink, Gbrapf16Frame, (),
|src, _opts, sink| gbrapf16_to_endian::<_, BE>(src, sink));
#[cfg(feature = "gbr")]
#[cfg_attr(docsrs, doc(cfg(feature = "gbr")))]
walker!(@convert @rgb_u16(16) @const BE: bool; Gbrapf32<BE>, Gbrapf32Sink, Gbrapf32Frame, (),
|src, _opts, sink| gbrapf32_to_endian::<_, BE>(src, sink));