Debian Codegraph @

.cargo/vendor/rgb/src/legacy/internal/convert/mod.rs

raw
1 use super::pixel::{ComponentSlice, ComponentMap};
2 use crate::alt::{BGR, BGRA, GRB, Gray, GrayAlpha, ARGB, ABGR};
3 use crate::{RGB, RGBA};
4 use core::{mem, slice};
5
6 mod array;
7 mod tuple;
8
9 /// Use [`::bytemuck::cast_slice()`] instead.
10 ///
11 /// Casts a slice of bytes into a slice of pixels, e.g. `[u8]` to `[RGB8]`.
12 ///
13 /// See also `FromSlice`
14 pub trait AsPixels<PixelType> {
15 /// Use [`::bytemuck::cast_slice()`] instead.
16 ///
17 /// Reinterpret the slice as a read-only/shared slice of pixels.
18 /// Multiple consecutive elements in the slice are intepreted as a single pixel
19 /// (depending on format, e.g. 3 for RGB, 4 for RGBA).
20 ///
21 /// Leftover elements are ignored if the slice isn't evenly divisible into pixels.
22 ///
23 /// Use this method only when the type is known from context.
24 /// See also `FromSlice`.
25 fn as_pixels(&self) -> &[PixelType];
26 /// Use [`::bytemuck::cast_slice_mut()`] instead.
27 ///
28 /// Reinterpret the slice as a mutable/exclusive slice of pixels.
29 /// Multiple consecutive elements in the slice are intepreted as a single pixel
30 /// (depending on format, e.g. 3 for RGB, 4 for RGBA).
31 ///
32 /// Leftover elements are ignored if the slice isn't evenly divisible into pixels.
33 ///
34 /// Use this method only when the type is known from context.
35 /// See also `FromSlice`.
36 fn as_pixels_mut(&mut self) -> &mut [PixelType];
37 }
38
39 macro_rules! as_pixels_impl {
40 ($typ:ident, $elems:expr) => {
41 impl<T> AsPixels<$typ<T>> for [T] {
42 fn as_pixels(&self) -> &[$typ<T>] {
43 unsafe {
44 slice::from_raw_parts(self.as_ptr() as *const _, self.len() / $elems)
45 }
46 }
47
48 fn as_pixels_mut(&mut self) -> &mut [$typ<T>] {
49 unsafe {
50 slice::from_raw_parts_mut(self.as_mut_ptr() as *mut _, self.len() / $elems)
51 }
52 }
53 }
54 };
55 }
56
57 as_pixels_impl! {RGB, 3}
58 as_pixels_impl! {RGBA, 4}
59 as_pixels_impl! {BGR, 3}
60 as_pixels_impl! {BGRA, 4}
61 as_pixels_impl! {GRB, 3}
62 as_pixels_impl! {Gray, 1}
63 as_pixels_impl! {GrayAlpha, 2}
64 as_pixels_impl! {ARGB, 4}
65 as_pixels_impl! {ABGR, 4}
66
67 /// Use [`::bytemuck::cast_slice()`] or [`::bytemuck::from_bytes()`] to convert
68 ///
69 /// Cast a slice of component values (bytes) as a slice of RGB/RGBA pixels
70 ///
71 /// If there's any incomplete pixel at the end of the slice it is ignored.
72 pub trait FromSlice<T: Copy> {
73 /// Reinterpert slice as RGB pixels
74 fn as_rgb(&self) -> &[RGB<T>];
75 /// Reinterpert slice as RGBA pixels
76 fn as_rgba(&self) -> &[RGBA<T>];
77 /// Reinterpert slice as alpha-first ARGB pixels
78 fn as_argb(&self) -> &[ARGB<T>];
79 /// Reinterpert mutable slice as RGB pixels
80 fn as_rgb_mut(&mut self) -> &mut [RGB<T>];
81 /// Reinterpert mutable slice as RGBA pixels
82 fn as_rgba_mut(&mut self) -> &mut [RGBA<T>];
83 /// Reinterpert mutable slice as alpha-first ARGB pixels
84 fn as_argb_mut(&mut self) -> &mut [ARGB<T>];
85
86 /// Reinterpert mutable slice as grayscale pixels
87 fn as_gray(&self) -> &[Gray<T>];
88 /// Reinterpert mutable slice as grayscale pixels with alpha
89 fn as_gray_alpha(&self) -> &[GrayAlpha<T>];
90 /// Reinterpert mutable slice as grayscale pixels
91 fn as_gray_mut(&mut self) -> &mut [Gray<T>];
92 /// Reinterpert mutable slice as grayscale pixels with alpha
93 fn as_gray_alpha_mut(&mut self) -> &mut [GrayAlpha<T>];
94
95 /// Reinterpert slice as reverse-order BGR pixels
96 fn as_bgr(&self) -> &[BGR<T>];
97 /// Reinterpert slice as reverse-order BGRA pixels
98 fn as_bgra(&self) -> &[BGRA<T>];
99 /// Reinterpert slice as reverse-order ABGR pixels
100 fn as_abgr(&self) -> &[ABGR<T>];
101 /// Reinterpert ntable slice as reverse-order BGR pixels
102 fn as_bgr_mut(&mut self) -> &mut [BGR<T>];
103 /// Reinterpert mutable slice as reverse-order alpha-last BGRA pixels
104 fn as_bgra_mut(&mut self) -> &mut [BGRA<T>];
105 /// Reinterpert mutable slice as reverse-order alpha-first ABGR pixels
106 fn as_abgr_mut(&mut self) -> &mut [ABGR<T>];
107 }
108
109 impl<T: Copy> FromSlice<T> for [T] {
110 #[inline]
111 fn as_rgb(&self) -> &[RGB<T>] {
112 unsafe { from_items_to_struct(self) }
113 }
114
115 #[inline]
116 fn as_rgba(&self) -> &[RGBA<T>] {
117 unsafe { from_items_to_struct(self) }
118 }
119
120 #[inline]
121 fn as_argb(&self) -> &[ARGB<T>] {
122 unsafe { from_items_to_struct(self) }
123 }
124
125 #[inline]
126 fn as_rgb_mut(&mut self) -> &mut [RGB<T>] {
127 unsafe { from_items_to_struct_mut(self) }
128 }
129
130 #[inline]
131 fn as_rgba_mut(&mut self) -> &mut [RGBA<T>] {
132 unsafe { from_items_to_struct_mut(self) }
133 }
134
135 #[inline]
136 fn as_argb_mut(&mut self) -> &mut [ARGB<T>] {
137 unsafe { from_items_to_struct_mut(self) }
138 }
139
140 #[inline]
141 fn as_gray(&self) -> &[Gray<T>] {
142 unsafe { from_items_to_struct(self) }
143 }
144
145 #[inline]
146 fn as_gray_alpha(&self) -> &[GrayAlpha<T>] {
147 unsafe { from_items_to_struct(self) }
148 }
149
150 #[inline]
151 fn as_gray_mut(&mut self) -> &mut [Gray<T>] {
152 unsafe { from_items_to_struct_mut(self) }
153 }
154
155 #[inline]
156 fn as_gray_alpha_mut(&mut self) -> &mut [GrayAlpha<T>] {
157 unsafe { from_items_to_struct_mut(self) }
158 }
159
160 #[inline]
161 fn as_bgr(&self) -> &[BGR<T>] {
162 unsafe { from_items_to_struct(self) }
163 }
164
165 #[inline]
166 fn as_abgr(&self) -> &[ABGR<T>] {
167 unsafe { from_items_to_struct(self) }
168 }
169
170 #[inline]
171 fn as_bgra(&self) -> &[BGRA<T>] {
172 unsafe { from_items_to_struct(self) }
173 }
174
175 #[inline]
176 fn as_bgr_mut(&mut self) -> &mut [BGR<T>] {
177 unsafe { from_items_to_struct_mut(self) }
178 }
179
180 #[inline]
181 fn as_bgra_mut(&mut self) -> &mut [BGRA<T>] {
182 unsafe { from_items_to_struct_mut(self) }
183 }
184
185 #[inline]
186 fn as_abgr_mut(&mut self) -> &mut [ABGR<T>] {
187 unsafe { from_items_to_struct_mut(self) }
188 }
189 }
190
191 #[inline(always)]
192 unsafe fn from_items_to_struct<F, T>(from: &[F]) -> &[T] {
193 debug_assert_eq!(0, mem::size_of::<T>() % mem::size_of::<F>());
194 let len = from.len() / (mem::size_of::<T>() / mem::size_of::<F>());
195 slice::from_raw_parts(from.as_ptr().cast::<T>(), len)
196 }
197
198 #[inline(always)]
199 unsafe fn from_items_to_struct_mut<F, T>(from: &mut [F]) -> &mut [T] {
200 debug_assert_eq!(0, mem::size_of::<T>() % mem::size_of::<F>());
201 let len = from.len() / (mem::size_of::<T>() / mem::size_of::<F>());
202 slice::from_raw_parts_mut(from.as_mut_ptr().cast::<T>(), len)
203 }
204
205 macro_rules! rgb_impl_from {
206 ($typename:ident, $from:ty, $to:ty) => {
207 impl From<$typename<$from>> for $typename<$to> {
208 #[inline(always)]
209 fn from(other: $typename<$from>) -> Self {
210 other.map(core::convert::Into::into)
211 }
212 }
213 };
214 }
215
216 rgb_impl_from! {RGB, u8,i16}
217 rgb_impl_from! {RGB, u8,i32}
218 rgb_impl_from! {RGB, u8,u16}
219 rgb_impl_from! {RGB, u8,u32}
220 rgb_impl_from! {RGB, u16,i32}
221 rgb_impl_from! {RGB, u16,u32}
222 rgb_impl_from! {RGB, u16,u64}
223
224 rgb_impl_from! {RGB, u8,f32}
225 rgb_impl_from! {RGB, u8,f64}
226 rgb_impl_from! {RGB, u16,f32}
227 rgb_impl_from! {RGB, u16,f64}
228
229 rgb_impl_from! {RGB, i16,f32}
230 rgb_impl_from! {RGB, i16,f64}
231
232 rgb_impl_from! {RGB, i32,f64}
233 rgb_impl_from! {RGB, f32,f64}
234
235 rgb_impl_from! {RGBA, u16,i32}
236 rgb_impl_from! {RGBA, u16,u32}
237 rgb_impl_from! {RGBA, u16,u64}
238
239 rgb_impl_from! {RGBA, u8,i16}
240 rgb_impl_from! {RGBA, u8,u16}
241 rgb_impl_from! {RGBA, u8,u32}
242 rgb_impl_from! {RGBA, u8,f32}
243 rgb_impl_from! {RGBA, u8,f64}
244 rgb_impl_from! {RGBA, u16,f32}
245 rgb_impl_from! {RGBA, u16,f64}
246
247 rgb_impl_from! {RGBA, i16,f32}
248 rgb_impl_from! {RGBA, i16,f64}
249
250 rgb_impl_from! {RGBA, i32,f64}
251 rgb_impl_from! {RGBA, f32,f64}
252
253 macro_rules! reorder_impl_from {
254 (@rgb $t1:ident, $t2:ident) => {
255 reorder_impl_from!(@once $t1, $t2, r, g, b);
256 reorder_impl_from!(@once $t2, $t1, r, g, b);
257 };
258 (@rgba $t1:ident, $t2:ident) => {
259 reorder_impl_from!(@once $t1, $t2, r, g, b, a);
260 reorder_impl_from!(@once $t2, $t1, r, g, b, a);
261 };
262 (@once $t1:ident, $t2:ident, $($component:ident),+) => {
263 impl<T> From<$t1<T>> for $t2<T> where T: ::core::clone::Clone {
264 fn from(other: $t1<T>) -> Self {
265 let $t1 { $($component),+ } = other;
266 Self {
267 $($component),+
268 }
269 }
270 }
271 }
272 }
273
274 reorder_impl_from!(@rgba RGBA, ARGB);
275 reorder_impl_from!(@rgba ABGR, ARGB);
276 reorder_impl_from!(@rgba BGRA, ARGB);
277 reorder_impl_from!(@rgba BGRA, ABGR);
278
279 reorder_impl_from!(@rgb RGB, BGR);
280 reorder_impl_from!(@rgba BGRA, RGBA);
281 reorder_impl_from!(@rgba ABGR, RGBA);
282 reorder_impl_from!(@rgb RGB, GRB);
283
284 impl<T: Clone> From<Gray<T>> for RGB<T> {
285 #[inline(always)]
286 #[allow(deprecated)]
287 fn from(other: Gray<T>) -> Self {
288 Self {
289 r: other.0.clone(),
290 g: other.0.clone(),
291 b: other.0,
292 }
293 }
294 }
295
296 impl<T: Clone> From<Gray<T>> for RGBA<T, u8> {
297 #[inline(always)]
298 #[allow(deprecated)]
299 fn from(other: Gray<T>) -> Self {
300 Self {
301 r: other.0.clone(),
302 g: other.0.clone(),
303 b: other.0,
304 a: 255,
305 }
306 }
307 }
308
309 impl<T: Clone, A> From<GrayAlpha<T, A>> for RGBA<T, A> {
310 #[inline(always)]
311 #[allow(deprecated)]
312 fn from(other: GrayAlpha<T, A>) -> Self {
313 Self {
314 r: other.0.clone(),
315 g: other.0.clone(),
316 b: other.0,
317 a: other.1,
318 }
319 }
320 }
321
322 #[cfg(not(feature = "unstable-experimental"))]
323 impl<T> AsRef<T> for Gray<T> {
324 #[inline(always)]
325 #[allow(deprecated)]
326 fn as_ref(&self) -> &T {
327 &self.0
328 }
329 }
330
331 #[cfg(not(feature = "unstable-experimental"))]
332 impl<T> AsRef<[T]> for RGB<T> {
333 #[inline(always)]
334 fn as_ref(&self) -> &[T] {
335 self.as_slice()
336 }
337 }
338
339 #[cfg(feature = "unstable-experimental")]
340 impl<T> AsRef<[T; 3]> for RGB<T> {
341 fn as_ref(&self) -> &[T; 3] {
342 unsafe { &*(self as *const Self).cast() }
343 }
344 }
345
346 #[cfg(not(feature = "unstable-experimental"))]
347 impl<T> AsRef<[T]> for RGBA<T> {
348 #[inline(always)]
349 fn as_ref(&self) -> &[T] {
350 self.as_slice()
351 }
352 }
353
354 #[cfg(feature = "unstable-experimental")]
355 impl<T> AsRef<[T; 4]> for RGBA<T> {
356 fn as_ref(&self) -> &[T; 4] {
357 unsafe { &*(self as *const Self).cast() }
358 }
359 }
360
361 impl<T> AsRef<[T; 4]> for ARGB<T> {
362 fn as_ref(&self) -> &[T; 4] {
363 unsafe { &*(self as *const Self).cast() }
364 }
365 }
366
367 impl<T> AsRef<[T; 4]> for BGRA<T> {
368 fn as_ref(&self) -> &[T; 4] {
369 unsafe { &*(self as *const Self).cast() }
370 }
371 }
372
373 impl<T> AsRef<[T; 4]> for ABGR<T> {
374 fn as_ref(&self) -> &[T; 4] {
375 unsafe { &*(self as *const Self).cast() }
376 }
377 }
378
379 #[cfg(not(feature = "unstable-experimental"))]
380 impl<T> AsRef<T> for GrayAlpha<T> {
381 #[inline(always)]
382 #[allow(deprecated)]
383 fn as_ref(&self) -> &T {
384 &self.0
385 }
386 }
387
388 #[cfg(feature = "unstable-experimental")]
389 impl<T> AsRef<[T; 2]> for GrayAlpha<T> {
390 fn as_ref(&self) -> &[T; 2] {
391 unsafe { &*(self as *const Self).cast() }
392 }
393 }
394
395 #[cfg(not(feature = "unstable-experimental"))]
396 impl<T> AsMut<T> for Gray<T> {
397 #[inline(always)]
398 #[allow(deprecated)]
399 fn as_mut(&mut self) -> &mut T {
400 &mut self.0
401 }
402 }
403
404 #[cfg(not(feature = "unstable-experimental"))]
405 impl<T> AsMut<[T]> for RGB<T> {
406 #[inline(always)]
407 fn as_mut(&mut self) -> &mut [T] {
408 self.as_mut_slice()
409 }
410 }
411
412 #[cfg(feature = "unstable-experimental")]
413 impl<T> AsMut<[T; 3]> for RGB<T> {
414 fn as_mut(&mut self) -> &mut [T; 3] {
415 unsafe { &mut *(self as *mut Self).cast() }
416 }
417 }
418
419 #[cfg(not(feature = "unstable-experimental"))]
420 impl<T> AsMut<[T]> for RGBA<T> {
421 #[inline(always)]
422 fn as_mut(&mut self) -> &mut [T] {
423 self.as_mut_slice()
424 }
425 }
426
427 #[cfg(feature = "unstable-experimental")]
428 impl<T> AsMut<[T; 4]> for RGBA<T> {
429 fn as_mut(&mut self) -> &mut [T; 4] {
430 unsafe { &mut *(self as *mut Self).cast() }
431 }
432 }
433
434 #[cfg(not(feature = "unstable-experimental"))]
435 impl<T> AsMut<T> for GrayAlpha<T> {
436 #[inline(always)]
437 #[allow(deprecated)]
438 fn as_mut(&mut self) -> &mut T {
439 &mut self.0
440 }
441 }
442
443 #[cfg(feature = "unstable-experimental")]
444 impl<T> AsMut<[T; 2]> for GrayAlpha<T> {
445 fn as_mut(&mut self) -> &mut [T; 2] {
446 unsafe { &mut *(self as *mut Self).cast() }
447 }
448 }
449
450 #[test]
451 fn argb_converts() {
452 let argb = ARGB { a: 0xffu8, r: 0xfa, g: 0xfb, b: 0xfc };
453 let rgba = RGBA { a: 0xffu8, r: 0xfa, g: 0xfb, b: 0xfc };
454
455 assert_eq!(RGBA::from(argb), rgba);
456 assert_eq!(ARGB::from(rgba), argb);
457 assert_eq!(rgba.rgb(), argb.rgb());
458
459 let bgra = BGRA { a: 0xffu8, r: 0x1f, g: 0x2f, b: 0x3f };
460 let abgr = ABGR { a: 0xffu8, r: 0x1f, g: 0x2f, b: 0x3f };
461
462 assert_eq!(BGRA::from(abgr), bgra);
463 assert_eq!(ABGR::from(bgra), abgr);
464 }
465
466 #[test]
467 fn converts() {
468 assert_eq!([1,2].as_gray(), [Gray::new(1), Gray::new(2)]);
469 assert_eq!([3].as_gray_mut(), [Gray::new(3)]);
470 assert_eq!([1,2].as_gray_alpha(), [GrayAlpha::new(1, 2)]);
471 // excess bytes are ignored
472 assert_eq!([1,2,3].as_gray_alpha_mut(), [GrayAlpha::new(1, 2)]);
473 assert_eq!([1,2,3,4].as_gray_alpha_mut(), [GrayAlpha::new(1, 2), GrayAlpha::new(3, 4)]);
474
475 assert_eq!(RGBA::new(1u8,2,3,255), RGB::new(1u8,2,3).into());
476 assert_eq!(RGBA::new(1u16,2,3,65535), RGB::new(1u16,2,3).into());
477 assert_eq!(BGRA{r:1u8,g:2u8,b:3u8,a:255u8}, BGR{r:1u8,g:2u8,b:3u8}.into());
478 assert_eq!(BGRA{r:1u8,g:2u8,b:3u8,a:255u8}, RGB{r:1u8,g:2u8,b:3u8}.into());
479 assert_eq!(RGBA {r:1u8,g:2,b:3,a:4u8}, BGRA{r:1u8,g:2u8,b:3u8,a:4u8}.into());
480 assert_eq!(BGR {r:1u8,g:2,b:3u8}, RGB {r:1u8,g:2,b:3u8}.into());
481 assert_eq!(RGB {r:1u16,g:0x5678,b:0xABCDu16}, BGR {r:1u16,g:0x5678,b:0xABCDu16}.into());
482 assert_eq!(BGR {r:0x1234567u32,g:2,b:3u32}, RGB {r:0x1234567u32,g:2,b:3u32}.into());
483
484 assert_eq!(&[1u8,2,3,4], RGBA {r:1u8,g:2,b:3,a:4u8}.as_slice());
485 assert_eq!(&[1u8,2,3,4], RGBA {r:1u8,g:2,b:3,a:4u8}.as_ref());
486 assert_eq!(&[1u8,2,3], RGB {r:1u8,g:2,b:3}.as_slice());
487 assert_eq!(&[1u8,2,3], RGB {r:1u8,g:2,b:3}.as_ref());
488
489 assert_eq!(&[1u8,2,3], RGB {r:1u8,g:2,b:3}.as_mut_slice());
490 assert_eq!(&[1u8,2,3], RGB {r:1u8,g:2,b:3}.as_mut());
491 }
492
493
494 #[test]
495 #[cfg(feature = "unstable-experimental")]
496 fn as_refs() {
497 let mut r = RGBA::new(1u8,2,3,4u8);
498 assert_eq!(&[1,2,3,4], AsRef::<[u8; 4]>::as_ref(&r));
499 assert_eq!([1,2,3,4], *AsMut::<[u8; 4]>::as_mut(&mut r));
500
501 let mut r = GrayAlpha::new(1u8,4u8);
502 assert_eq!(&[1,4], AsRef::<[u8; 2]>::as_ref(&r));
503 assert_eq!([1,4], *AsMut::<[u8; 2]>::as_mut(&mut r));
504 }