Symphonia not detecting CRC corruption in flac

[gtunes-dev]

Hi, folks.

I'm looking into using Symphonia to validate media files in a small project I'm working on. I don't intend to implement playback, so packets get dropped on the floor in the decode loop.

I have flac files that I have intentionally corrupted. FLAC in -t mode detects the corruption as bad CRCs. Claxon does, too. Symphonia doesn't appear to. Symphonia makes it through the decode loop, which ends with an Unexpected Eof (which is what I see for valid files, too).

Should Symphonia be detecting corruption as I expect it to?

Here's logging at trace with Symphonia's and my own logging. Code is below - it's a modified version of a sample and doesn't stray far from the original.

Any help would be very appreciated.

Thanks!

[2025-03-19T16:13:01Z TRACE fspulse::analysis] Begin: Symphonia validate: A Woman's Worth.flac
[2025-03-19T16:13:01Z DEBUG symphonia_core::probe] found a possible format marker within [66, 4c, 61, 43, 0, 0, 0, 22, 12, 0, 12, 0, 0, 9, 5e, 0] @ 0+2 bytes.
[2025-03-19T16:13:01Z INFO symphonia_core::probe] found the format marker [66, 4c, 61, 43] @ 0+2 bytes.
[2025-03-19T16:13:09Z TRACE fspulse::analysis] Error::IoError in next_packet: Custom { kind: UnexpectedEof, error: "end of stream" }
[2025-03-19T16:13:09Z TRACE fspulse::analysis] End: Symphonia validate: A Woman's Worth.flac

` pub fn validate_flac_symphonia(path: &Path, file_name: &str, is_valid_prog: &ProgressBar) -> Result<bool, FsPulseError> {
// Try to create a Symphonia decoder

    trace!("Begin: Symphonia validate: {}", file_name);
    let f = File::open(path)?;
    let mss = MediaSourceStream::new(Box::new(f), Default::default());

    let ext = path.extension();
    let mut hint = Hint::new();
    if let Some(ext_val) = ext {
        hint.with_extension(&ext_val.to_string_lossy());
    }

    let meta_opts: MetadataOptions = Default::default();
    let fmt_opts: FormatOptions = Default::default();

    // Probe the media source.
    //let probed = match symphonia::default::get_probe()
    //    .format(&hint, mss, &fmt_opts, &meta_opts) 
    let probed = match symphonia::default::get_probe()
        .format(&hint, mss, &fmt_opts, &meta_opts)

    {
        Ok(probed) => probed,
        Err(Error::IoError(io_err)) => {
            trace!("Error::IoError in get_probe: {:?}", io_err);
            is_valid_prog.println(format!("Analysis error ('{}'): {:?}", file_name, io_err));
            if io_err.kind() == io::ErrorKind::UnexpectedEof {  // occurs when file is too short to probe
                return Ok(true)
            } else {
                return Ok(false)
            }
        },
        Err(Error::Unsupported(err)) => {
            trace!("Error::Unsupported in get_probe: {:?}", err);
            return Ok(true);
        },
        Err(e) => {
            trace!("Error in get_probe: {:?}", e);
            //error!("{:?}", e);
            return Ok(false)
        }, // Handle all other errors
    };

    let mut format = probed.format;
    let mut dec_opts: DecoderOptions = Default::default();
    dec_opts.verify = true;

    let tracks = format.tracks().to_vec();
    let track_count = tracks.len();
    
    for track in tracks {
    //for track in tracks {
        
        let track_id = track.id;
        
        let mut decoder = match symphonia::default::get_codecs().make(&track.codec_params, &dec_opts) {
            Ok(decoder) => decoder, // Assign decoder if successful
            Err(symphonia::core::errors::Error::Unsupported(u)) => 
            {
                trace!("Error::Unsupported in get_codecs: {:?}", u); 
                return Ok(true) // Handle "Unsupported" error
            },
            Err(e) => {
                trace!("Error in get_codecs: {:?}", e); 
                return Ok(false) // Handle all other errors
            },
        };

        let mut track_title: Option<String> = None;

        if let Some(metadata) = format.metadata().current() {
            for tag in metadata.tags() {
                if tag.std_key == Some(StandardTagKey::TrackTitle) {
                    track_title = Some(tag.value.to_string());
                    break;
                }
            }
        }
        
        let track_title = track_title.unwrap_or_else(|| "unknown".to_string());

        is_valid_prog.set_message(format!("Validating '{}': Track {} ('{}') of {}", file_name, track_id, track_title, track_count));

        // The decode loop
        loop {
                // Get the next packet from the media format.
            let packet = match format.next_packet() {
                Ok(packet) => packet,
                Err(Error::ResetRequired) => {
                    // The track list has been changed. Re-examine it and create a new set of decoders,
                    // then restart the decode loop. This is an advanced feature and it is not
                    // unreasonable to consider this "the end." As of v0.5.0, the only usage of this is
                    // for chained OGG physical streams.
                    trace!("Error::ResetRequired in next_packet"); 
                    unimplemented!();
                },
                Err(Error::IoError(io_err)) => {
                    trace!("Error::IoError in next_packet: {:?}", io_err); 
                    if io_err.kind() == ErrorKind::UnexpectedEof {
                        // This is how Symphonia signals EOF - just break the loop
                        break;
                    } else {
                        return Err(FsPulseError::Error(io_err.to_string()));
                    }
                },
                Err(err) => {
                    trace!("Error in next_packet: {:?}", err); 
                    // A unrecoverable error occurred, halt decoding.
                    //println!("{:?}", err);
                    panic!("{}", err);
                }
            };

            // Consume any new metadata that has been read since the last packet.
            while !format.metadata().is_latest() {
                // Pop the old head of the metadata queue.
                format.metadata().pop();

                // Consume the new metadata at the head of the metadata queue.
            }

            // If the packet does not belong to the selected track, skip over it.
            if packet.track_id() != track.id {
                continue;
            }

            // Decode the packet into audio samples.
            match decoder.decode(&packet) {
                Ok(_decoded) => {
                    // Consume the decoded audio samples (see below).
                }
                Err(Error::IoError(io_err)) => {
                    // The packet failed to decode due to an IO error, skip the packet.
                    trace!("Error::IoError in decode: {:?}", io_err); 
                    return Ok(false)
                }
                Err(Error::DecodeError(err)) => {
                    // The packet failed to decode due to invalid data, skip the packet.
                    trace!("Error::DecodeError in decode: {:?}", err); 
                    return Ok(false)
                    //continue;
                }
                Err(err) => {
                    // An unrecoverable error occurred, halt decoding.
                    trace!("Error in decode: {:?}", err); 
                    panic!("{}", err);
                }
            }
        }
    }
    trace!("End: Symphonia validate: {}", file_name);
    Ok(true)
}`