feat: RawBmp::colors

Additional work that was required by `RawBmp::colors`:
- Making `DynamicRawColors` public.
- Making `DynamicRawColors` implement iterator.
- Refactoring logic.
- Rename `Rle{4,8}Pixels` to `Rle{4,8}Colors`
- Due to removal of position handling in `Rle{4,8}Pixels`, they can no
  longer assert the the new line corresponds with the width. I left the
  assertion functionally the same, but with slightly different approach.
  Personally, I don't think it is necessary that that assert there at
  all - like, either way the image would be broken and developer will
  have to fix the `bmp` file, that assertion isn't helpful at all.

Author: Ddystopia

src/lib.rs

@@ -211,7 +211,7 @@ pub use header::CompressionMethod;
 pub use header::{Bpp, ChannelMasks, Header, RowOrder};
 pub use iter::Pixels;
 pub use raw_bmp::RawBmp;
-pub use raw_iter::{RawColors, RawPixel, RawPixels, Rle4Pixels, Rle8Pixels};
+pub use raw_iter::{RawColors, RawPixel, RawPixels, Rle4Colors, Rle8Colors};
 
 /// A BMP-format bitmap.
 ///
@@ -293,19 +293,20 @@ where
                 let fallback_color = C::from(Rgb888::BLACK);
                 if let Some(color_table) = self.raw_bmp.color_table() {
                     if header.compression_method == CompressionMethod::Rle4 {
-                        let mut colors = Rle4Pixels::new(&self.raw_bmp).map(|raw_pixel| {
+                        let (mut colors, _points) = Rle4Colors::new(&self.raw_bmp);
+                        let map_color = |color: RawU4| {
                             color_table
-                                .get(raw_pixel.color)
+                                .get(color.into_inner() as u32)
                                 .map(Into::into)
                                 .unwrap_or(fallback_color)
-                        });
+                        };
                         // RLE produces pixels in bottom-up order, so we draw them line by line rather than the entire bitmap at once.
                         for y in (0..area.size.height).rev() {
+                            colors.start_a_line();
+
                             let row = Rectangle::new(Point::new(0, y as i32), slice_size);
-                            target.fill_contiguous(
-                                &row,
-                                colors.by_ref().take(area.size.width as usize),
-                            )?;
+                            let colors = colors.by_ref().map(map_color);
+                            target.fill_contiguous(&row, colors.take(area.size.width as usize))?;
                         }
                         Ok(())
                     } else {
@@ -327,19 +328,20 @@ where
                 let fallback_color = C::from(Rgb888::BLACK);
                 if let Some(color_table) = self.raw_bmp.color_table() {
                     if header.compression_method == CompressionMethod::Rle8 {
-                        let mut colors = Rle8Pixels::new(&self.raw_bmp).map(|raw_pixel| {
+                        let (mut colors, _points) = Rle8Colors::new(&self.raw_bmp);
+                        let map_color = |color: RawU8| {
                             color_table
-                                .get(raw_pixel.color)
+                                .get(color.into_inner() as u32)
                                 .map(Into::into)
                                 .unwrap_or(fallback_color)
-                        });
+                        };
                         // RLE produces pixels in bottom-up order, so we draw them line by line rather than the entire bitmap at once.
                         for y in (0..area.size.height).rev() {
+                            colors.start_a_line();
+
                             let row = Rectangle::new(Point::new(0, y as i32), slice_size);
-                            target.fill_contiguous(
-                                &row,
-                                colors.by_ref().take(area.size.width as usize),
-                            )?;
+                            let colors = colors.by_ref().map(map_color);
+                            target.fill_contiguous(&row, colors.take(area.size.width as usize))?;
                         }
                         Ok(())
                     } else {

src/raw_bmp.rs

@@ -8,7 +8,7 @@ use embedded_graphics::{
 use crate::{
     color_table::ColorTable,
     header::{Bpp, Header},
-    raw_iter::RawPixels,
+    raw_iter::{DynamicRawColors, RawPixels},
     try_const, ChannelMasks, ParseError, RowOrder,
 };
 
@@ -103,6 +103,11 @@ impl<'a> RawBmp<'a> {
         RawPixels::new(self)
     }
 
+    /// Return an iterator over the raw colors in the image. Positions are dependent on the row order.
+    pub fn colors(&self) -> DynamicRawColors<'_> {
+        self.pixels().colors
+    }
+
     /// Returns the raw color of a pixel.
     ///
     /// Returns `None` if `p` is outside the image bounding box. Note that this function doesn't