◆ findAndDecodeFrame()

bool fl::third_party::Mp3StreamDecoderImpl::findAndDecodeFrame ( audio::Sample * out_sample )
private
Definition at line 425 of file mp3.cpp.hpp.
                                                                                  {
    if (!mDecoder) {
        return false;
    }
 
    // Try to decode from current buffer
    const fl::u8* inptr = mBuffer.get() + mBufferPos;
    fl::size bytes_left = mBufferFilled - mBufferPos;
 
    if (bytes_left == 0) {
        return false;
    }
 
    // Find sync word
    int offset = mDecoder->findSyncWord(inptr, bytes_left);
    if (offset < 0) {
        // No sync word found, consume buffer and try again
        mBufferPos = mBufferFilled;
        return false;
    }
 
    inptr += offset;
    bytes_left -= offset;
    mBufferPos += offset;
 
    // Try to decode one frame
    const fl::u8* decode_ptr = inptr;
    fl::size decode_bytes = bytes_left;
 
    /* The first frame may be a Xing/Info/VBRI header rather than audio. It is
       a complete, valid MPEG frame, so decoding it emits noise before the
       music; LAME also records how much encoder priming follows it. Inspect
       before decoding so the frame can be dropped whole (FastLED#4129). */
    if (!mInspectedFirstFrame) {
        mInspectedFirstFrame = true;
        Mp3VbrTag tag;
        if (Mp3ParseVbrTag(fl::span<const fl::u8>(inptr, bytes_left), &tag) &&
            tag.present) {
            mSkipTagFrame = true;
            mSkipSamples = tag.encoderDelay + MP3D_DECODER_DELAY;
        }
    }
 
    int result = mDecoder->decodeFrame(&decode_ptr, &decode_bytes);
 
    // Update buffer position based on how many bytes were consumed
    fl::size consumed = (decode_ptr - inptr);
    if (result != 0 && consumed == 0 && bytes_left == BUFFER_SIZE) {
        // A full buffer cannot grow to complete this frame. Drop one byte so
        // corrupt input cannot pin the streaming decoder on the same sync.
        consumed = 1;
    }
    mBufferPos += consumed;
    mBytesProcessed += consumed;
 
    if (result == 0 && mSkipTagFrame) {
        // The metadata frame itself: consumed above, never emitted.
        mSkipTagFrame = false;
        return false;
    }
 
    if (result == 0) {
        // Successfully decoded a frame
        Mp3Frame frame;
        frame.pcm = mDecoder->mPcmBuffer.get();
        frame.samples = mDecoder->mFrameInfo.outputSamps / mDecoder->mFrameInfo.nChans;
        frame.channels = mDecoder->mFrameInfo.nChans;
        frame.sample_rate = mDecoder->mFrameInfo.samprate;
        frame.bitrate = mDecoder->mFrameInfo.bitrate;
        frame.version = mDecoder->mFrameInfo.version;
        frame.layer = mDecoder->mFrameInfo.layer;
 
        // Update stream info on first successful decode
        if (!mHasDecodedFirstFrame) {
            mInfo.sampleRate = frame.sample_rate;
            mInfo.channels = static_cast<fl::u8>(frame.channels);
            mInfo.bitrate = frame.bitrate;
            mInfo.version = static_cast<fl::u8>(frame.version);
            mInfo.layer = static_cast<fl::u8>(frame.layer);
            mInfo.isValid = true;
            mHasDecodedFirstFrame = true;
        }
 
        /* Encoder priming plus the filterbank's own latency: not signal, and
           audible as a burst at the start of playback if emitted. */
        int first = 0;
        if (mSkipSamples > 0) {
            const fl::u32 available = static_cast<fl::u32>(frame.samples);
            const fl::u32 drop =
                mSkipSamples < available ? mSkipSamples : available;
            first = static_cast<int>(drop);
            mSkipSamples -= drop;
            if (first >= frame.samples) {
                return false; // whole frame was priming
            }
        }
        const int emitted = frame.samples - first;
 
        // Convert to audio::Sample (convert stereo to mono if needed)
        if (frame.channels == 2) {
            fl::vector<fl::i16> mono_pcm;
            mono_pcm.reserve(emitted);
 
            for (int i = first; i < frame.samples; i++) {
                fl::i32 left = frame.pcm[i * 2];
                fl::i32 right = frame.pcm[i * 2 + 1];
                fl::i32 avg = (left + right) / 2;
                mono_pcm.push_back(static_cast<fl::i16>(avg));
            }
 
            *out_sample = audio::Sample(mono_pcm);
        } else {
            // Mono audio - use directly
            *out_sample = audio::Sample(
                fl::span<const fl::i16>(frame.pcm + first, emitted));
        }
 
        return true;
    }
 
    return false;
}
Referenced by decodeNextFrame().
Here is the call graph for this function:
Here is the caller graph for this function: