How to use in async code about claxon HOT 2 CLOSED

Thank you so much for taking the time. I'll be implementing the General Solution in my project, it sounds like exactly what I want to do.

from claxon.

Excellent library!

Thanks!

Would returning io::ErrorKind::WouldBlock from io::Read make the reads for samples retryable?

Maybe in a few lucky cases that would work, but in general it will not. A flac stream consists of frames, and each frame needs to be decoded in one go. Decoding of a frame cannot be suspended or resumed, because all of the state required for it lives on the call stack, in local variables. When the decoder returns the IO error, the call stack is lost. The lucky case is when the io::ErrorKind::WouldBlock happens exactly at the start of a frame, then you could retry decoding that frame.

What would be the best way to use the library in an environment where future bytes may not exist yet?

I can think of a few ways to go about this, ranging from easy but not guaranteed to work, to complicated but general.

Easy but cheating solution

I think the easiest way to do this right now, is to run the decoder on a separate thread, with a blocking reader, possibly backed by std::sync::mpsc::channel::<Box<[u8]>>. The promise could then send the bytes to the channel. This does require a new thread though, which as far as I am aware is not currently possible in WASM.

Easy but not general solution

The streaminfo metadata block may contain information about the maximum frame size in max_frame_size. If you know that your input can supply at least max_frame_size bytes, then it should be safe to decode one frame with FrameReader::read_next_or_eof. You would need some out of band way to know when you are done decoding, for example by checking whether the underlying input encountered EOF, or by comparing the number of samples decoded against the number of samples in the streaminfo, if that is present.

General solution

A more involved solution would be to implement a buffer that keeps consumed bytes around for a while. On top of this, you can decode frame by frame with FrameReader::read_next_or_eof. That would work roughly like this:

• Before reading the frame, record the current offset in the buffer.
• Try to decode the frame.
• If it succeeds, the buffer until the current offset can safely be dropped.
• If it fails due to WouldBlock, rewind to the start of the frame, and try to decode it again at a later time, when more data is available.

You could use input::BufferedReader as a starting point, it already has everything you need, only it drops the old contents of the buffer when it needs to be replenished. A rewindable buffered reader would instead append new contents, until an explicit clear after decoding a block.

from claxon.