◆ initializeDecoder()

bool fl::third_party::SoftwareMpeg1Decoder::initializeDecoder ( )
private
Definition at line 251 of file software_decoder.cpp.hpp.
                                                         {
    if (!stream_) {
        setError("No input stream available");
        return false;
    }
 
    // Read the entire stream into memory for pl_mpeg
    // First, estimate the size by reading chunks
    const fl::size CHUNK_SIZE = 8192;
    fl::vector<fl::u8> tempBuffer;
 
    fl::u8 chunk[CHUNK_SIZE];
    fl::size bytesRead;
    do {
        bytesRead = stream_->read(chunk, CHUNK_SIZE);
        if (bytesRead > 0) {
            for (fl::size i = 0; i < bytesRead; ++i) {
                tempBuffer.push_back(chunk[i]);
            }
        }
    } while (bytesRead == CHUNK_SIZE);
 
    if (tempBuffer.empty()) {
        setError("Empty input stream - no data available");
        return false;
    }
 
    // Copy to our buffer
    decoderData_->totalSize = tempBuffer.size();
    decoderData_->inputBuffer.reset(new fl::u8[decoderData_->totalSize]);
    fl::memcpy(decoderData_->inputBuffer.get(), tempBuffer.data(), decoderData_->totalSize);
 
    // Create pl_mpeg instance with memory buffer
    decoderData_->plmpeg = fl::third_party::plm_create_with_memory(
        decoderData_->inputBuffer.get(),
        decoderData_->totalSize,
        0  // Don't free when done - we manage the memory
    );
 
    if (!decoderData_->plmpeg) {
        setError("Failed to create pl_mpeg decoder instance");
        return false;
    }
 
    // Enable/disable audio decoding based on config
    if (config_.skipAudio || !config_.audioCallback) {
        fl::third_party::plm_set_audio_enabled(decoderData_->plmpeg, 0);
    } else {
        fl::third_party::plm_set_audio_enabled(decoderData_->plmpeg, 1);
        fl::third_party::plm_set_audio_decode_callback(decoderData_->plmpeg,
            SoftwareMpeg1Decoder::audioDecodeCallback, this);
    }
 
    // Set looping if requested
    fl::third_party::plm_set_loop(decoderData_->plmpeg, config_.looping ? 1 : 0);
 
    // Set up video decode callback BEFORE any decoding to ensure callbacks work
    fl::third_party::plm_set_video_decode_callback(decoderData_->plmpeg,
        SoftwareMpeg1Decoder::videoDecodeCallback, this);
 
    // Try to get headers - for multiplexed streams with audio, this may require decoding
    // some frames before audio headers are found
    // Note: Video callback must be set first so we can capture frame dimensions
    if (!fl::third_party::plm_has_headers(decoderData_->plmpeg)) {
        // Temporarily allocate a minimal buffer for header decoding
        // We'll reallocate properly once we know dimensions
        fl::size temp_buffer_size = static_cast<fl::size>(1920ul * 1080ul * 3ul); // Max reasonable size for header decode
        decoderData_->rgbFrameBuffer.reset(new fl::u8[temp_buffer_size]);
 
        // Decode one frame to get headers
        fl::third_party::plm_decode(decoderData_->plmpeg, decoderData_->targetFrameDuration);
    }
 
    // Check if we at least have video - video headers are mandatory
    if (fl::third_party::plm_get_width(decoderData_->plmpeg) == 0 ||
        fl::third_party::plm_get_height(decoderData_->plmpeg) == 0) {
        setError("Failed to parse MPEG1 headers");
        return false;
    }
 
    // Audio headers might not be present yet if audio packets come later in the stream
    // This is OK - audio will work once we encounter audio packets during decode
 
    // Get video properties
    decoderData_->width = static_cast<fl::u16>(fl::third_party::plm_get_width(decoderData_->plmpeg));
    decoderData_->height = static_cast<fl::u16>(fl::third_party::plm_get_height(decoderData_->plmpeg));
    decoderData_->frameRate = static_cast<fl::u16>(fl::third_party::plm_get_framerate(decoderData_->plmpeg));
 
    if (decoderData_->width == 0 || decoderData_->height == 0) {
        setError("Invalid video dimensions from MPEG1 stream");
        return false;
    }
 
    // Now allocate properly sized buffers based on actual video dimensions
    allocateFrameBuffers();
    decoderData_->initialized = true;
    decoderData_->headerParsed = true;
    return true;
}
Referenced by begin().
Here is the call graph for this function:
Here is the caller graph for this function: