decode_frames()

std::vector< Kakshya::DataVariant > MayaFlux::IO::SoundFileReader::decode_frames ( const std::shared_ptr< FFmpegDemuxContext > &  demux, const std::shared_ptr< AudioStreamContext > &  audio, uint64_t  num_frames, uint64_t  offset  )

private

Decode num_frames PCM frames starting at offset.

Parameters

ctx	FFmpeg context.
num_frames	Number of frames to decode.
offset	Frame offset from beginning.

Returns

DataVariant containing decoded data.

Caller must hold at least a shared lock on m_context_mutex.

Definition at line 460 of file SoundFileReader.cpp.

{
    if (!audio->is_valid()) {
        set_error("Invalid audio context for decoding");
        return {};
    }
 
    bool use_planar = (m_audio_options & AudioReadOptions::DEINTERLEAVE) != AudioReadOptions::NONE;
    int ch = static_cast<int>(audio->channels);
 
    std::vector<Kakshya::DataVariant> output;
    if (use_planar) {
        output.resize(ch);
        for (auto& v : output) {
            v = std::vector<double>();
            std::get<std::vector<double>>(v).reserve(num_frames);
        }
    } else {
        output.resize(1);
        output[0] = std::vector<double>();
        std::get<std::vector<double>>(output[0]).reserve(num_frames * static_cast<size_t>(ch));
    }
 
    uint64_t decoded = 0;
    bool eof_reached = false;
 
    AVPacket* pkt = av_packet_alloc();
    AVFrame* frame = av_frame_alloc();
    if (!pkt || !frame) {
        av_packet_free(&pkt);
        av_frame_free(&frame);
        set_error("Failed to allocate packet/frame");
        return {};
    }
 
    uint32_t out_rate = m_target_sample_rate > 0 ? m_target_sample_rate : audio->sample_rate;
    int max_resampled = static_cast<int>(av_rescale_rnd(
        static_cast<int64_t>(num_frames), out_rate, audio->sample_rate, AV_ROUND_UP));
 
    AVSampleFormat tgt_fmt = use_planar ? AV_SAMPLE_FMT_DBLP : AV_SAMPLE_FMT_DBL;
    uint8_t** resample_buf = nullptr;
    int linesize = 0;
 
    if (av_samples_alloc_array_and_samples(
            &resample_buf, &linesize, ch, max_resampled, tgt_fmt, 0)
        < 0) {
        av_packet_free(&pkt);
        av_frame_free(&frame);
        set_error("Failed to allocate resample buffer");
        return {};
    }
 
    while (decoded < num_frames) {
        if (!eof_reached) {
            int ret = av_read_frame(demux->format_context, pkt);
            if (ret == AVERROR_EOF) {
                eof_reached = true;
                avcodec_send_packet(audio->codec_context, nullptr);
            } else if (ret < 0) {
                eof_reached = true;
            } else if (pkt->stream_index == audio->stream_index) {
                avcodec_send_packet(audio->codec_context, pkt);
                av_packet_unref(pkt);
            } else {
                av_packet_unref(pkt);
            }
        }
 
        int receive_ret = 0;
        while (decoded < num_frames) {
            receive_ret = avcodec_receive_frame(audio->codec_context, frame);
 
            if (receive_ret == AVERROR(EAGAIN))
                break;
            if (receive_ret == AVERROR_EOF) {
                // decoded = num_frames;
                break;
            }
            if (receive_ret < 0)
                break;
 
            int out_samples = swr_convert(
                audio->swr_context,
                resample_buf, max_resampled,
                const_cast<const uint8_t**>(frame->data),
                frame->nb_samples);
 
            if (out_samples > 0) {
                uint64_t to_copy = std::min(static_cast<uint64_t>(out_samples),
                    num_frames - decoded);
                if (use_planar) {
                    for (int c = 0; c < ch; ++c) {
                        auto* src = reinterpret_cast<double*>(resample_buf[c]);
                        auto& dst = std::get<std::vector<double>>(output[c]);
                        dst.insert(dst.end(), src, src + to_copy);
                    }
                } else {
                    auto* src = reinterpret_cast<double*>(resample_buf[0]);
                    auto& dst = std::get<std::vector<double>>(output[0]);
                    dst.insert(dst.end(), src, src + to_copy * static_cast<uint64_t>(ch));
                }
                decoded += to_copy;
            }
            av_frame_unref(frame);
        }
 
        if (eof_reached && receive_ret == AVERROR_EOF)
            break;
    }
 
    while (true) {
        int n = swr_convert(audio->swr_context, resample_buf, max_resampled, nullptr, 0);
        if (n <= 0)
            break;
 
        uint64_t to_copy = std::min(static_cast<uint64_t>(n),
            (num_frames > decoded) ? (num_frames - decoded) : 0);
 
        if (to_copy > 0) {
            if (use_planar) {
                for (int c = 0; c < ch; ++c) {
                    auto* src = reinterpret_cast<double*>(resample_buf[c]);
                    auto& dst = std::get<std::vector<double>>(output[c]);
                    dst.insert(dst.end(), src, src + to_copy);
                }
            } else {
                auto* src = reinterpret_cast<double*>(resample_buf[0]);
                auto& dst = std::get<std::vector<double>>(output[0]);
                dst.insert(dst.end(), src, src + to_copy * static_cast<uint64_t>(ch));
            }
            decoded += to_copy;
        } else {
            break;
        }
    }
 
    av_freep(&resample_buf[0]);
    av_freep(&resample_buf);
    av_packet_free(&pkt);
    av_frame_free(&frame);
 
    m_current_frame_position += decoded;
    return output;
}

References MayaFlux::IO::DEINTERLEAVE, m_audio_options, m_current_frame_position, m_target_sample_rate, MayaFlux::IO::NONE, and set_error().

Referenced by read_all(), and read_frames().

Here is the call graph for this function:

Here is the caller graph for this function: