diff --git a/Cargo.toml b/Cargo.toml
index 5858e9d6..69bb2ff6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -41,8 +41,8 @@ tiff = { version = "0.8.0", optional = true }
 ravif = { version = "0.11.0", optional = true }
 rgb = { version = "0.8.25", optional = true }
 mp4parse = { version = "0.12.0", optional = true }
-dav1d = { version = "0.6.0", optional = true }
-dcv-color-primitives = { version = "0.4.0", optional = true }
+dav1d = { git = "https://github.com/rust-av/dav1d-rs.git", optional = true }
+dcv-color-primitives = { version = "0.5.2", optional = true }
 color_quant = "1.1"
 exr = { version = "1.5.0", optional = true }
 qoi = { version = "0.4", optional = true }
diff --git a/src/codecs/avif/decoder.rs b/src/codecs/avif/decoder.rs
index c8b3a955..e97e2437 100644
--- a/src/codecs/avif/decoder.rs
+++ b/src/codecs/avif/decoder.rs
@@ -34,23 +34,42 @@ impl<R: Read> AvifDecoder<R> {
     /// Create a new decoder that reads its input from `r`.
     pub fn new(mut r: R) -> ImageResult<Self> {
         let ctx = read_avif(&mut r, ParseStrictness::Normal).map_err(error_map)?;
-        let mut primary_decoder = dav1d::Decoder::new();
-        let coded = ctx.primary_item_coded_data();
-        primary_decoder
-            .send_data(coded, None, None, None)
-            .map_err(error_map)?;
+        let mut dsettings = dav1d::Settings::new();
+        dsettings.set_n_threads(1);  // any value except 1 breaks the program
+        let mut primary_decoder = dav1d::Decoder::with_settings(&dsettings).unwrap();
+        let coded = ctx.primary_item_coded_data().to_owned();
+        //match 
+        primary_decoder.send_data(coded, None, None, None).map_err(error_map)?;
+        //{
+        //    Err(err) if err.is_again() => {
+        //        loop {
+        //            match primary_decoder.send_pending_data() {
+        //                Err(err) if err.is_again() => continue,
+        //                Err(err) => {
+        //                    panic!("Error sending pending data to the decoder: {}", err);
+        //                }
+        //                _ => break,
+        //            };
+        //        };
+        //    }
+        //    Err(err) => {
+        //        panic!("Error sending data to the decoder: {}", err);
+        //    }
+        //    _ => (),
+        //    }
         let picture = primary_decoder.get_picture().map_err(error_map)?;
         let alpha_item = ctx.alpha_item_coded_data();
-        let alpha_picture = if !alpha_item.is_empty() {
-            let mut alpha_decoder = dav1d::Decoder::new();
-            alpha_decoder
-                .send_data(alpha_item, None, None, None)
-                .map_err(error_map)?;
-            Some(alpha_decoder.get_picture().map_err(error_map)?)
-        } else {
-            None
-        };
+        let alpha_picture = None; //if !alpha_item.is_empty() {
+        //let mut alpha_decoder = dav1d::Decoder::new();
+        //alpha_decoder = None;
+        //    .send_data(alpha_item, None, None, None)
+        //    .map_err(error_map)?;
+        //Some(alpha_decoder.get_picture().map_err(error_map)?)
+        //} else {
+        //    None
+        //};
         let icc_profile = ctx.icc_colour_information().ok().map(|x| x.to_vec());
+        
         assert_eq!(picture.bit_depth(), 8);
         Ok(AvifDecoder {
             inner: PhantomData,
@@ -58,6 +77,7 @@ impl<R: Read> AvifDecoder<R> {
             alpha_picture,
             icc_profile,
         })
+        
     }
 }
 
@@ -102,16 +122,14 @@ impl<'a, R: 'a + Read> ImageDecoder<'a> for AvifDecoder<R> {
 
     fn read_image(self, buf: &mut [u8]) -> ImageResult<()> {
         assert_eq!(u64::try_from(buf.len()), Ok(self.total_bytes()));
-
         dcp::initialize();
-
         if self.picture.pixel_layout() != PixelLayout::I400 {
             let pixel_format = match self.picture.pixel_layout() {
                 PixelLayout::I400 => todo!(),
                 PixelLayout::I420 => dcp::PixelFormat::I420,
                 PixelLayout::I422 => dcp::PixelFormat::I422,
                 PixelLayout::I444 => dcp::PixelFormat::I444,
-                PixelLayout::Unknown => panic!("Unknown pixel layout"),
+                //PixelLayout::Unknown => panic!("Unknown pixel layout"),
             };
             let src_format = dcp::ImageFormat {
                 pixel_format,
@@ -120,7 +138,7 @@ impl<'a, R: 'a + Read> ImageDecoder<'a> for AvifDecoder<R> {
             };
             let dst_format = dcp::ImageFormat {
                 pixel_format: dcp::PixelFormat::Rgba,
-                color_space: dcp::ColorSpace::Lrgb,
+                color_space: dcp::ColorSpace::Rgb,
                 num_planes: 1,
             };
             let (width, height) = self.dimensions();
@@ -136,6 +154,7 @@ impl<'a, R: 'a + Read> ImageDecoder<'a> for AvifDecoder<R> {
                 self.picture.stride(PlanarImageComponent::V) as usize,
             ];
             let dst_buffers = &mut [&mut buf[..]];
+            println!("debug here dcp convert 1");
             dcp::convert_image(
                 width,
                 height,
@@ -147,6 +166,7 @@ impl<'a, R: 'a + Read> ImageDecoder<'a> for AvifDecoder<R> {
                 dst_buffers,
             )
             .map_err(error_map)?;
+        println!("debug here dcp convert 2");
         } else {
             let plane = self.picture.plane(PlanarImageComponent::Y);
             buf.copy_from_slice(plane.as_ref());