ecmlib 1.0.0

use crate::common::{EccEdc, MSF, Optimizations, SectorType, StatusError};
use log::{debug, error, trace};

///
/// Encoder implementation to optimize the CD-ROM sectors data and reduce their size.
/// This "compression" produces a lossless encoding method.
///
pub struct Encoder {
    optimizations: Optimizations,
    applicable_optimizations: Optimizations,
    encoded_buffer: [u8; 2352],
    sector_type: SectorType,
    edc_ecc_calculator: EccEdc,
}

impl Encoder {
    ///
    /// Initialize the encoder library generating the required data.
    ///
    /// # Arguments
    ///
    /// * **optimizations**: The desired optimizations to apply to the encoded sectors.
    ///
    /// **NOTE**: The optimizations can vary depending of the sector type and the state.
    ///           Use the method get_last_used_optimizations() to return the last used optimizations.
    ///
    /// # Return
    ///
    /// **Encoder:** A new object instance to be used to encode the CD-ROM sectors with the provided optimizations.
    ///
    /// # Example
    ///
    /// ```text
    /// let encoder = Encoder::new();
    /// ```
    pub fn new(optimizations: Optimizations) -> Self {
        Encoder {
            optimizations: optimizations,
            applicable_optimizations: Optimizations::None,
            encoded_buffer: [0; 2352],
            sector_type: SectorType::Unknown,
            edc_ecc_calculator: EccEdc::new(),
        }
    }

    ///
    /// Returns the detected sector type during the encoding. This method must be used efter the encoding process.
    ///
    /// # Arguments
    ///
    /// **None**
    ///
    /// # Return
    ///
    /// **SectorType:** The detected sector type during the last encoding.
    ///
    pub fn get_sector_type(&self) -> SectorType {
        self.sector_type
    }

    ///
    /// Change the configured optimizations on-the-fly to be used in future encodings.
    ///
    /// # Arguments
    ///
    /// * **optimizations:** New optimizations to be used
    ///
    /// # Return
    ///
    /// **()**
    ///
    pub fn set_optimizations(&mut self, optimizations: Optimizations) {
        self.optimizations = optimizations;
    }

    ///
    /// Get the last used optimizations in the encoding process. These optimizations can differ to the configured optimizations.
    ///
    /// During the encoding process, the optimizations are checked to ensure that can be applied. If not, they are changed on-the-fly,
    /// and the way to return the last used optimizations is to use this function. The returned optimizations will be the real one used
    /// during the encoding process and must be provided to de decoder.
    ///
    /// # Arguments
    ///
    /// **None**
    ///
    /// # Return
    ///
    /// **Optimizations:** The last used optimizations
    ///
    pub fn get_last_used_optimizations(&self) -> Optimizations {
        self.applicable_optimizations
    }

    ///
    /// Encodes a sector removing the non essential data based on the configured optimizations.
    ///
    /// # Arguments
    ///
    /// * **sector:** The sector data to be optimized
    /// * **sector_number:** The sector number used to detect if the optimization is possible.
    /// * **sector_type:** The sector type to process. Useful to skip the detection step if you already know the sector type.
    /// * **force:** force the encoding without checking the optimizations
    ///
    /// # Return
    ///
    /// **Vec(u8):** Encoded stream.
    ///
    pub fn encode_sector(
        &mut self,
        sector: &[u8],
        sector_number: u32,
        sector_type: Option<SectorType>,
        force: bool,
    ) -> Result<Vec<u8>, StatusError> {
        debug!("Encoding the sector.");
        // Check if there is enough data to work with it.
        if sector.len() < 2352 {
            return Err(StatusError::NotEnoughSectorData);
        }

        // Get the sector type
        match sector_type {
            Some(s_type) => {
                trace!("The sector type was provided by the user: {:?}", s_type);
                self.sector_type = s_type;
            }
            None => {
                trace!("Detecting the sector type.");
                self.sector_type = self.detect_sector_type(sector).unwrap();
                trace!("The detected type is: {:?}", self.sector_type);
            }
        }

        // Validate the optimizations if force is false
        self.applicable_optimizations = if !force {
            debug!("Force is false so optimizations will be tested.");
            self.check_optimizations(sector, sector_number, self.sector_type, self.optimizations)
        } else {
            debug!("Force is true. The provided optimizations will be used.");
            self.optimizations
        };

        // Reset the output buffer
        trace!("Clearing the output buffer.");
        self.encoded_buffer = [0; 2352];

        // Process the CDDA sector using the optimizations
        if self.sector_type == SectorType::Cdda || self.sector_type == SectorType::CddaGap {
            trace!("Running the CDDA encoding function");
            return Ok(self.encode_sector_cdda(sector));
        }

        // Process the Mode1 sector using the optimizations
        if self.sector_type == SectorType::Mode1
            || self.sector_type == SectorType::Mode1Gap
            || self.sector_type == SectorType::Mode1Raw
        {
            trace!("Running the Mode1 encoding function");
            return Ok(self.encode_sector_mode1(sector));
        }

        if self.sector_type == SectorType::Mode2 || self.sector_type == SectorType::Mode2Gap {
            trace!("Running the Mode2 encoding function");
            return Ok(self.encode_sector_mode2(sector));
        }

        if self.sector_type == SectorType::Mode2Xa1
            || self.sector_type == SectorType::Mode2Xa1Gap
            || self.sector_type == SectorType::Mode2Xa2
            || self.sector_type == SectorType::Mode2Xa2Gap
            || self.sector_type == SectorType::Mode2XaGap
        {
            trace!("Running the Mode2 XA encoding function");
            return Ok(self.encode_sector_mode2_xa(sector));
        }

        // This should not happen
        error!("Unknown format detected...");
        Err(StatusError::UnknownFormat(format!(
            "{:?}",
            self.sector_type
        )))
    }

    ///
    /// Encodes a CDDA sector using the provided optimizations
    ///
    /// # Arguments
    ///
    /// * **sector:** The slice with the sector data to be procesed
    ///
    /// # Return
    ///
    /// **Vec(u8):** Encoded stream.
    ///
    fn encode_sector_cdda(&mut self, sector: &[u8]) -> Vec<u8> {
        match (
            self.sector_type,
            self.applicable_optimizations
                .contains(Optimizations::RemoveGap),
        ) {
            // If the sector is a GAP and the GAP optimization is enabled return empty
            (SectorType::CddaGap, true) => Vec::new(),
            // Otherwise copy the sector
            _ => {
                self.encoded_buffer.copy_from_slice(sector);
                self.encoded_buffer.to_vec()
            }
        }
    }

    ///
    /// Encodes a Mode 1 sector using the provided optimizations
    ///
    /// # Arguments
    ///
    /// * **sector:** The slice with the sector data to be procesed
    ///
    /// # Return
    ///
    /// **Vec(u8):** Encoded stream.
    ///
    fn encode_sector_mode1(&mut self, sector: &[u8]) -> Vec<u8> {
        let mut current_offset: usize = 0;

        // Sync data
        if !self
            .applicable_optimizations
            .contains(Optimizations::RemoveSync)
        {
            self.encoded_buffer[current_offset..current_offset + 12]
                .copy_from_slice(&sector[0x0..=0xB]);
            current_offset += 12;
        }

        // MSF data
        if !self
            .applicable_optimizations
            .contains(Optimizations::RemoveMSF)
        {
            self.encoded_buffer[current_offset..current_offset + 3]
                .copy_from_slice(&sector[0xC..=0xE]);
            current_offset += 3;
        }

        // Mode data
        if !self
            .applicable_optimizations
            .contains(Optimizations::RemoveMode)
        {
            self.encoded_buffer[current_offset] = sector[0xF];
            current_offset += 1;
        }

        // Sector Data
        // The Mode1 RAW sector contains full random data from this point to the end
        // Copy the entire sector and return the slice
        if self.sector_type == SectorType::Mode1Raw {
            self.encoded_buffer[current_offset..current_offset + 2336]
                .copy_from_slice(&sector[0x10..=0x92F]);
            current_offset += 2336;

            return self.encoded_buffer[..current_offset].to_vec();
        }
        // The other Mode1 sectors allows to remove more data so we will continue
        if !self
            .applicable_optimizations
            .contains(Optimizations::RemoveGap)
            || self.sector_type == SectorType::Mode1
        {
            self.encoded_buffer[current_offset..current_offset + 2048]
                .copy_from_slice(&sector[0x10..=0x80F]);
            current_offset += 2048;
        }

        // EDC data
        if !self
            .applicable_optimizations
            .contains(Optimizations::RemoveEDC)
        {
            self.encoded_buffer[current_offset..current_offset + 4]
                .copy_from_slice(&sector[0x810..=0x813]);
            current_offset += 4;
        }

        // Blanks data
        if !self
            .applicable_optimizations
            .contains(Optimizations::RemoveBlanks)
        {
            self.encoded_buffer[current_offset..current_offset + 8]
                .copy_from_slice(&sector[0x814..=0x81B]);
            current_offset += 8;
        }

        // ECC data
        if !self
            .applicable_optimizations
            .contains(Optimizations::RemoveECC)
        {
            self.encoded_buffer[current_offset..current_offset + 276]
                .copy_from_slice(&sector[0x81C..=0x92F]);
            current_offset += 276;
        }

        // Return the stored data
        self.encoded_buffer[..current_offset].to_vec()
    }

    ///
    /// Encodes a Mode 2 sector using the provided optimizations
    ///
    /// # Arguments
    ///
    /// * **sector:** The slice with the sector data to be procesed
    ///
    /// # Return
    ///
    /// **Vec(u8):** Encoded stream.
    ///
    fn encode_sector_mode2(&mut self, sector: &[u8]) -> Vec<u8> {
        let mut current_offset: usize = 0;

        // Sync data
        if !self
            .applicable_optimizations
            .contains(Optimizations::RemoveSync)
        {
            self.encoded_buffer[current_offset..current_offset + 12]
                .copy_from_slice(&sector[0x0..=0xB]);
            current_offset += 12;
        }

        // MSF data
        if !self
            .applicable_optimizations
            .contains(Optimizations::RemoveMSF)
        {
            self.encoded_buffer[current_offset..current_offset + 3]
                .copy_from_slice(&sector[0xC..=0xE]);
            current_offset += 3;
        }

        // Mode data
        if !self
            .applicable_optimizations
            .contains(Optimizations::RemoveMode)
        {
            self.encoded_buffer[current_offset] = sector[0xF];
            current_offset += 1;
        }

        // Sector Data
        if !self
            .applicable_optimizations
            .contains(Optimizations::RemoveGap)
            || self.sector_type == SectorType::Mode2
        {
            self.encoded_buffer[current_offset..current_offset + 2336]
                .copy_from_slice(&sector[0x10..=0x92F]);
            current_offset += 2336;
        }

        // Return the stored data
        self.encoded_buffer[..current_offset].to_vec()
    }

    ///
    /// Encodes a Mode 2 XA sector using the provided optimizations
    ///
    /// # Arguments
    ///
    /// * **sector:** The slice with the sector data to be procesed
    ///
    /// # Return
    ///
    /// **Vec(u8):** Encoded stream.
    ///
    fn encode_sector_mode2_xa(&mut self, sector: &[u8]) -> Vec<u8> {
        let mut current_offset: usize = 0;

        // Sync data
        if !self
            .applicable_optimizations
            .contains(Optimizations::RemoveSync)
        {
            self.encoded_buffer[current_offset..current_offset + 12]
                .copy_from_slice(&sector[0x0..=0xB]);
            current_offset += 12;
        }

        // MSF data
        if !self
            .applicable_optimizations
            .contains(Optimizations::RemoveMSF)
        {
            self.encoded_buffer[current_offset..current_offset + 3]
                .copy_from_slice(&sector[0xC..=0xE]);
            current_offset += 3;
        }

        // Mode data
        if !self
            .applicable_optimizations
            .contains(Optimizations::RemoveMode)
        {
            self.encoded_buffer[current_offset] = sector[0xF];
            current_offset += 1;
        }

        // Flags data
        if !self
            .applicable_optimizations
            .contains(Optimizations::RemoveRedundantFlag)
        {
            debug!("Copying both XA Flags");
            self.encoded_buffer[current_offset..current_offset + 8]
                .copy_from_slice(&sector[0x10..=0x17]);
            current_offset += 8;
        } else {
            debug!("Copying just one copy of the XA Flags");
            self.encoded_buffer[current_offset..current_offset + 4]
                .copy_from_slice(&sector[0x10..=0x13]);
            current_offset += 4;
        }

        // Sector Data
        // If remove GAP is not enabled or the sector is a data sector, copy the data block
        if !self
            .applicable_optimizations
            .contains(Optimizations::RemoveGap)
            || self.sector_type == SectorType::Mode2Xa1
            || self.sector_type == SectorType::Mode2Xa2
        {
            // The XA GAP is fully zeroed, so will be copied only if no GAP optimization is enabled
            if self.sector_type == SectorType::Mode2XaGap {
                self.encoded_buffer[current_offset..current_offset + 2328]
                    .copy_from_slice(&sector[0x18..=0x92F]);
                current_offset += 2328;

                return self.encoded_buffer[..current_offset].to_vec();
            }

            // The optimization is not enabled or sector is XA1
            if self.sector_type == SectorType::Mode2Xa1Gap
                || self.sector_type == SectorType::Mode2Xa1
            {
                self.encoded_buffer[current_offset..current_offset + 2048]
                    .copy_from_slice(&sector[0x18..=0x817]);
                current_offset += 2048;
            }

            if self.sector_type == SectorType::Mode2Xa2Gap
                || self.sector_type == SectorType::Mode2Xa2
            {
                self.encoded_buffer[current_offset..current_offset + 2324]
                    .copy_from_slice(&sector[0x18..=0x92B]);
                current_offset += 2324;
            }
        }

        // The Mode2 XA Gap doesn't have more data to process. Just return...
        if self.sector_type == SectorType::Mode2XaGap {
            return self.encoded_buffer[..current_offset].to_vec();
        }

        // Mode2 XA1/XA2 must continue with the EDC/ECC
        // EDC data
        if !self
            .applicable_optimizations
            .contains(Optimizations::RemoveEDC)
        {
            if self.sector_type == SectorType::Mode2Xa1
                || self.sector_type == SectorType::Mode2Xa1Gap
            {
                // Sector is a Mode2 XA1
                self.encoded_buffer[current_offset..current_offset + 4]
                    .copy_from_slice(&sector[0x818..=0x81B]);
            } else {
                // Sector is a Mode2 XA2
                self.encoded_buffer[current_offset..current_offset + 4]
                    .copy_from_slice(&sector[0x92C..=0x92F]);
            }
            current_offset += 4;
        }

        // ECC data (Only XA1)
        if !self
            .applicable_optimizations
            .contains(Optimizations::RemoveECC)
            && (self.sector_type == SectorType::Mode2Xa1
                || self.sector_type == SectorType::Mode2Xa1Gap)
        {
            self.encoded_buffer[current_offset..current_offset + 276]
                .copy_from_slice(&sector[0x81C..=0x92F]);
            current_offset += 276;
        }

        // Return the stored data
        self.encoded_buffer[..current_offset].to_vec()
    }

    ///
    /// Analyzes the sector data to determine the sector type.
    ///
    /// # Arguments
    ///
    /// * **sector:** The slice with the sector data to be used
    ///
    /// # Return
    ///
    /// **SectorType:** Sector type detected in the sector.
    ///
    pub fn detect_sector_type(&self, sector: &[u8]) -> Result<SectorType, StatusError> {
        // Check if there is enough data to work with it.
        if sector.len() < 2352 {
            return Err(StatusError::NotEnoughSectorData);
        }

        if sector[..0x00C]
            == [
                0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00,
            ]
        {
            debug!("Sync data detected... Sector is a data sector.");
            // Sector is a MODE1/MODE2 sector
            if sector[0x00F] == 0x01
                && sector[0x814..0x81C] == [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
            {
                //  The sector is for sure a MODE1 sector, but we will check the EDC
                debug!(
                    "The sector seems to be a MODE1 sector. Checking the EDC & ECC to be sure of the type."
                );
                // Check if the generated EDC matches the sector EDC. If not, maybe the sector is damaged or copy protected and will be marked as RAW.
                let sector_edc = &sector[0x810..0x814];
                let generated_edc = self.edc_ecc_calculator.generate_edc(&sector[..0x810]);

                if generated_edc.to_le_bytes() == sector_edc
                    && self.edc_ecc_calculator.check_ecc(
                        &sector[0x0C..0x10],
                        &sector[0x10..],
                        &sector[0x81C..0x930],
                    )
                {
                    debug!("MODE1 sector detected... Checking if it is a GAP.");
                    if sector[0x10..0x810].iter().all(|&b| b == 0) {
                        debug!("The sector is a MODE1 GAP sector.");
                        return Ok(SectorType::Mode1Gap);
                    } else {
                        debug!("The sector is a normal MODE1 sector.");
                        return Ok(SectorType::Mode1);
                    }
                } else {
                    debug!(
                        "The EDC cannot be verified. The sector will be threated as RAW (non compliant)."
                    );
                    return Ok(SectorType::Mode1Raw);
                }
            } else if sector[0x00F] == 0x02 {
                // The sector is MODE2, and now we will detect what kind.
                //
                // Checking for a MODE2 GAP Sector
                debug!("Mode 2 sector detected. Checking if is just a GAP");
                if sector[0x10..0x930].iter().all(|&b| b == 0) {
                    debug!("The sector is a MODE2 GAP sector.");
                    return Ok(SectorType::Mode2Gap);
                }

                // Checking for a MODE2 XA GAP sector. It's a wrong type, but it is used in some games and can free some space.
                debug!("Checking if it's an XA GAP sector type.");
                if sector[0x10..0x14] == sector[0x14..0x18]
                    && sector[0x18..0x930].iter().all(|&b| b == 0)
                {
                    debug!("Mode 2 XA GAP detected.");
                    return Ok(SectorType::Mode2XaGap);
                }

                // Checking for a MODE2 XA1 sector.
                let sector_edc = &sector[0x818..0x81C];
                let generated_edc = self.edc_ecc_calculator.generate_edc(&sector[0x10..0x818]);
                let address = [0; 4];
                if generated_edc.to_le_bytes() == sector_edc
                    && self.edc_ecc_calculator.check_ecc(
                        &address,
                        &sector[0x10..],
                        &sector[0x81C..],
                    )
                {
                    // It is a MODE2 XA1 sector. Checking if it is a GAP.
                    if sector[0x18..0x818].iter().all(|&b| b == 0) {
                        debug!("Mode 2 XA1 GAP detected.");
                        return Ok(SectorType::Mode2Xa1Gap);
                    } else {
                        debug!("Mode 2 XA1 detected.");
                        return Ok(SectorType::Mode2Xa1);
                    }
                }

                // Checking for a MODE2 XA2 sector.
                let sector_edc = &sector[0x92C..0x930];
                let generated_edc = self.edc_ecc_calculator.generate_edc(&sector[0x10..0x92C]);
                if generated_edc.to_le_bytes() == sector_edc {
                    // It is a MODE2 XA1 sector. Checking if it is a GAP.
                    if sector[0x18..0x92C].iter().all(|&b| b == 0) {
                        debug!("Mode 2 XA2 GAP detected.");
                        return Ok(SectorType::Mode2Xa2Gap);
                    } else {
                        debug!("Mode 2 XA2 detected.");
                        return Ok(SectorType::Mode2Xa2);
                    }
                }

                // No XA detected, so the sector might be a Mode 2 standard sector
                debug!("The sector might be a non XA Mode 2 sector.");
                return Ok(SectorType::Mode2);
            }
        } else {
            debug!("Raw sector detected... It may be a CDDA sector. Checking for a GAP sector.");
            if sector.iter().all(|&b| b == 0) {
                debug!("The sector is a CDDA GAP sector.");
                return Ok(SectorType::CddaGap);
            } else {
                debug!("The sector is a normal CDDA sector.");
                return Ok(SectorType::Cdda);
            }
        }

        Ok(SectorType::Unknown)
    }

    ///
    /// This function will check that is possible to apply all the optimizations to the sector
    /// and will remove those that are not applicable.
    ///
    /// # Arguments
    ///
    /// * **sector:** The sector data
    /// * **sector_numer:** The sector number to check the MSF
    /// * **sector_type:** The sector type to determine the detection mode
    /// * **optimizations:** Optimizations that will be applied
    ///
    /// # Result
    ///
    /// **Optimizations:** Applicable optimizations after the checks.
    ///
    pub fn check_optimizations(
        &self,
        sector: &[u8],
        sector_number: u32,
        sector_type: SectorType,
        optimizations: Optimizations,
    ) -> Optimizations {
        debug!("Checking the applicable optimizations.");
        //
        // NOTE: The GAP optimization will not be checked because if a sector was detected as GAP
        //       is because the GAP is there and it is correct. There is no reason to check it again.
        //
        //       The SYNC and Mode are intrinsic to the type of sector so will not be checked too.
        //
        let mut applicable_optimizations = optimizations;

        // A CDDA is just raw data that cannot be processed, so the only applicable optimization is GAP remove and cannot fail.
        if sector_type == SectorType::Cdda || sector_type == SectorType::CddaGap {
            debug!("The sector is a CDDA type so there are no tests to do.");
            return applicable_optimizations;
        }

        // Now we will check the MSF which is common of all non CDDA sectors
        let sector_msf = MSF::sectors_to_msf(sector_number);
        trace!(
            "Comparing the original MSF ({:02x}{:02x}{:02x}) against the generated MSF ({:02x}{:02x}{:02x}).",
            sector[0xC], sector[0xD], sector[0xE], sector_msf[0], sector_msf[1], sector_msf[02]
        );
        if sector[0xC..0xF] != sector_msf {
            trace!("The MSF doesn't matches so will be removed as applicable optimization.");
            // The sector number doesn't matches and cannot be optimized.
            applicable_optimizations.remove(Optimizations::RemoveMSF);
        }

        // The MODE1 sector will not be checked:
        //
        // * MSF was already checked above
        // * Blank data is used to determine the mode
        // * ECC and EDC were checked to determine the compliant MODE1 sector
        //
        // The MODE2 sector is all data and the MSF was already checked above, so will be skipped too.
        //
        // Only the sectors MODE2 XA1/2 will be checked
        //
        trace!("Comparing the redundant flags to determine if matches.");
        if sector_type == SectorType::Mode2Xa1
            || sector_type == SectorType::Mode2Xa1Gap
            || sector_type == SectorType::Mode2Xa2
            || sector_type == SectorType::Mode2Xa2Gap
            || sector_type == SectorType::Mode2Gap
        {
            // Like the MODE1 sector, the ECC and EDC was checked to determine the correct sector mode so will not be checked again.
            // Only the flags must be checked.

            if sector[0x10..0x14] != sector[0x14..0x18] {
                applicable_optimizations.remove(Optimizations::RemoveRedundantFlag);
            }
        }

        trace!("Applicable optimizations: {:?}", applicable_optimizations);

        applicable_optimizations
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fs;
    use std::path::Path;

    ///
    /// Test to determine the correct sector detection
    ///
    #[test]
    fn check_sector_detection() {
        // Sectors list to be checked
        let sectors: [(SectorType, &'static str, &'static str); 10] = [
            (SectorType::Cdda, "cdda.bin", "CDDA"),
            (SectorType::CddaGap, "cdda_gap.bin", "CDDA GAP"),
            (SectorType::Mode1, "mode1.bin", "Mode1"),
            (SectorType::Mode1Gap, "mode1_gap.bin", "Mode1 GAP"),
            (SectorType::Mode1Raw, "mode1_raw.bin", "Mode1 RAW"),
            (SectorType::Mode2, "mode2.bin", "Mode2"),
            (SectorType::Mode2Gap, "mode2_gap.bin", "Mode2 GAP"),
            (SectorType::Mode2Xa1, "mode2_xa1.bin", "Mode2 XA1"),
            (
                SectorType::Mode2Xa1Gap,
                "mode2_xa1_gap.bin",
                "Mode2 XA1 GAP",
            ),
            (SectorType::Mode2XaGap, "mode2_xa_gap.bin", "Mode2 XA GAP"),
        ];

        // Initialize the encoder
        let encoder = Encoder::new(Optimizations::None);
        // Check every sector
        for (sector_type, file, sector_type_str) in &sectors {
            // Open the file
            let path = Path::new("tests/data").join(file);
            let sector = fs::read(path).expect("Cannot open test sector.");

            // Check that the filesize is correct
            assert_eq!(
                sector.len(),
                2352,
                "The sector {} must be 2352 bytes length.",
                sector_type_str
            );

            // Time to verify the detection function.
            assert_eq!(
                encoder.detect_sector_type(&sector).unwrap(),
                *sector_type,
                "The sector {} was not correctly identified ({}).",
                sector_type_str,
                file
            );

            println!("Sector {} detected correcly.", sector_type_str)
        }
    }
}