findAndDecodeFrame()

bool fl::third_party::Mp3StreamDecoderImpl::findAndDecodeFrame ( audio::Sample * out_sample )

private

Definition at line 250 of file mp3.cpp.hpp.

                                                                     {
    if (!mDecoder) {
        return false;
    }
 
    // Try to decode from current buffer
    const fl::u8* inptr = mBuffer.data() + 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;
 
    int result = mDecoder->decodeFrame(&decode_ptr, &decode_bytes);
 
    // Update buffer position based on how many bytes were consumed
    fl::size consumed = (decode_ptr - inptr);
    mBufferPos += consumed;
    mBytesProcessed += consumed;
 
    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;
        }
 
        // Convert to audio::Sample (convert stereo to mono if needed)
        if (frame.channels == 2) {
            fl::vector<fl::i16> mono_pcm;
            mono_pcm.reserve(frame.samples);
 
            for (int i = 0; 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, frame.samples));
        }
 
        return true;
    }
 
    return false;
}

References fl::third_party::Mp3Frame::bitrate, fl::third_party::Mp3Frame::channels, fl::third_party::Mp3Frame::layer, mBuffer, mBufferFilled, mBufferPos, mBytesProcessed, mDecoder, mHasDecodedFirstFrame, mInfo, offset(), fl::third_party::Mp3Frame::pcm, fl::vector< T >::push_back(), fl::vector< T >::reserve(), fl::third_party::Mp3Frame::sample_rate, fl::third_party::Mp3Frame::samples, and fl::third_party::Mp3Frame::version.

Referenced by decodeNextFrame().

Here is the call graph for this function:

Here is the caller graph for this function: