decode_frames()

std::vector< Kakshya::DataVariant > MayaFlux::IO::SoundFileReader::decode_frames ( std::shared_ptr< FFmpegContext >  ctx, uint64_t  num_frames, uint64_t  offset  )

private

Decode a specific number of frames from the file.

Parameters

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

Returns

DataVariant containing decoded data.

Definition at line 554 of file SoundFileReader.cpp.

{
    if (!ctx || !ctx->is_valid() || !ctx->swr_context) {
        set_error("Invalid context for decoding");
        return {};
    }
 
    std::vector<Kakshya::DataVariant> output_data;
    uint64_t frames_decoded = 0;
 
    AVPacket* packet = av_packet_alloc();
    AVFrame* frame = av_frame_alloc();
 
    if (!packet || !frame) {
        av_packet_free(&packet);
        av_frame_free(&frame);
        set_error("Failed to allocate packet/frame");
        return {};
    }
 
    int channels = ctx->channels;
    bool use_planar = (m_audio_options & AudioReadOptions::DEINTERLEAVE) != AudioReadOptions::NONE;
 
    if (use_planar) {
        output_data.resize(channels);
        for (auto& channel_vector : output_data) {
            channel_vector = std::vector<double>();
            std::get<std::vector<double>>(channel_vector).reserve(num_frames);
        }
    } else {
        output_data.resize(1);
        output_data[0] = std::vector<double>();
        std::get<std::vector<double>>(output_data[0]).reserve(num_frames * channels);
    }
 
    uint8_t** resample_buffer = nullptr;
    int resample_linesize = 0;
 
    int max_resample_samples = av_rescale_rnd(
        num_frames,
        m_target_sample_rate > 0 ? m_target_sample_rate : ctx->sample_rate,
        ctx->sample_rate,
        AV_ROUND_UP);
 
    AVSampleFormat target_format = use_planar ? AV_SAMPLE_FMT_DBLP : AV_SAMPLE_FMT_DBL;
 
    int alloc_ret = av_samples_alloc_array_and_samples(
        &resample_buffer, &resample_linesize,
        channels, max_resample_samples, target_format, 0);
 
    if (alloc_ret < 0 || !resample_buffer) {
        av_packet_free(&packet);
        av_frame_free(&frame);
        set_error("Failed to allocate resample buffer");
        return {};
    }
 
    while (frames_decoded < num_frames) {
        int ret = av_read_frame(ctx->format_context, packet);
 
        if (ret < 0) {
            if (ret == AVERROR_EOF) {
                avcodec_send_packet(ctx->codec_context, nullptr);
            } else {
                break;
            }
        } else if (packet->stream_index != ctx->audio_stream_index) {
            av_packet_unref(packet);
            continue;
        } else {
            ret = avcodec_send_packet(ctx->codec_context, packet);
            av_packet_unref(packet);
 
            if (ret < 0 && ret != AVERROR(EAGAIN)) {
                continue;
            }
        }
 
        while (ret >= 0 && frames_decoded < num_frames) {
            ret = avcodec_receive_frame(ctx->codec_context, frame);
 
            if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                break;
            } else if (ret < 0) {
                break;
            }
 
            int out_samples = swr_convert(ctx->swr_context,
                resample_buffer, max_resample_samples,
                (const uint8_t**)frame->data, frame->nb_samples);
 
            if (out_samples > 0) {
                uint64_t samples_to_copy = std::min(
                    static_cast<uint64_t>(out_samples),
                    num_frames - frames_decoded);
 
                if (use_planar) {
                    for (int ch = 0; ch < channels; ++ch) {
                        double* channel_data = reinterpret_cast<double*>(resample_buffer[ch]);
                        auto& channel_vector = std::get<std::vector<double>>(output_data[ch]);
                        channel_vector.insert(channel_vector.end(),
                            channel_data, channel_data + samples_to_copy);
                    }
                } else {
                    double* interleaved_data = reinterpret_cast<double*>(resample_buffer[0]);
                    auto& interleaved_vector = std::get<std::vector<double>>(output_data[0]);
                    interleaved_vector.insert(interleaved_vector.end(),
                        interleaved_data, interleaved_data + samples_to_copy * channels);
                }
 
                frames_decoded += samples_to_copy;
            }
 
            av_frame_unref(frame);
        }
 
        if (ret == AVERROR_EOF) {
            break;
        }
    }
 
    av_frame_free(&frame);
    av_packet_free(&packet);
 
    if (resample_buffer) {
        av_freep(&resample_buffer[0]);
        av_freep(&resample_buffer);
    }
 
    m_current_frame_position = offset + frames_decoded;
    return output_data;
}

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

Referenced by read_frames().

Here is the call graph for this function:

Here is the caller graph for this function: