How can I use the Pixel trait with different channel orderings (e.g. BGR, RGB, ABGR, ..)

[terhechte]

Hey! I'm using palette to iterate over the bytes of an image via the pixel trait:

let pixels = Rgb::<encoding::Srgb, u8>::from_raw_slice(data);
for pixel in pixels {
  let converted: palette::Srgba<f64> = pixel.into_format()
}

However, sometimes the images don't come in as RGB but as BGR. How could I achieve parsing the pixels correctly? I tried to use packed but couldn't figure out how to convert Packed to Rgba:

let pixels = palette::Packed<palette::rgb::channels::Argb>::from_raw_slice(data);
for pixel in pixels {
  let color = palette::rgb::Rgba::<palette::encoding::Srgb, u32>::from(pixel);
}}

This yields the error:

the trait bound `Alpha<Rgb<Srgb, u32>, u32>: From<&Packed>` is not satisfied

Thanks in advance! Also, thanks for this great package.

[Ogeon]

Hi, this use case is sadly not fully developed in the currently released version. Pixel, as you have noticed, doesn't change the data. It will only change the type the compiler sees it as. Packed was added to cover the case where one want to represent a color as the bytes in a u32. It gives you the channel reordering but not the byte array representation. It only works with [u32] buffers, where a single u32 is a single pixel. This will be improved in the next version, currently on the master branch, as you can see in this example.

To explain the error above, you would have to convert to palette::Srgba<u8>, not palette::Srgba<u32>. The former has u8 channels while the latter has u32 channels, and Packed represents a 4 * u8 large color. But it wouldn't solve your problem, unless the byte order of u32 happen to match the byte order in the data buffer. It may not do that on every architecture.

You have a couple of options for how to solve this. One is to use the master branch for now, but that's not always possible. Especially if you want to publish on crates.io. Another is to make your own Bgr struct and add #[derive(Pixel)] and #[repr(C)] to it. It's pretty simple as long as you don't need anything special. I can explain more if anything is unclear.

You could also use the bytemuck crate to cast your data to [[u8; 4]], loop over it as for &[alpha, blue, green, red] in pixels and construct your Srgba from those variables. All of these options should produce the same result in practice, but with different pros and cons.

[terhechte]

Thank you for the very detailed response! For now I might just go with master or use the bytemuck crate. Very helpful, thanks! :)

[Ogeon]

You're welcome! Keep in mind that you can lock the dependency to a specific commit if you go with the master branch. That will prevent accidental breaking changes when you run cargo update (unless you always want the latest commit). And feedback and bug reports are always welcome!