send_fifo_frame()

bool MayaFlux::IO::AudioEncodeContext::send_fifo_frame ( FFmpegMuxContext &  mux, bool  pad_to_frame_size  )

private

Pull one frame from the FIFO and send it to the encoder.

If the FIFO has fewer samples than frame_size, pads with silence. Drains all output packets into the mux after sending.

Definition at line 310 of file AudioEncodeContext.cpp.

{
    int frame_size = codec_context->frame_size > 0
        ? codec_context->frame_size
        : av_audio_fifo_size(fifo);
 
    AVFrame* frame = av_frame_alloc();
    if (!frame) {
        m_last_error = "av_frame_alloc failed";
        return false;
    }
 
    frame->nb_samples = frame_size;
    frame->format = codec_context->sample_fmt;
    frame->sample_rate = codec_context->sample_rate;
    av_channel_layout_copy(&frame->ch_layout, &codec_context->ch_layout);
 
    if (av_frame_get_buffer(frame, 0) < 0) {
        m_last_error = "av_frame_get_buffer failed";
        av_frame_free(&frame);
        return false;
    }
 
    if (av_frame_make_writable(frame) < 0) {
        m_last_error = "av_frame_make_writable failed";
        av_frame_free(&frame);
        return false;
    }
 
    int available = av_audio_fifo_size(fifo);
    int to_read = std::min(available, frame_size);
 
    int read = av_audio_fifo_read(fifo,
        reinterpret_cast<void**>(frame->data), to_read);
 
    if (read < to_read) {
        m_last_error = "av_audio_fifo_read returned fewer samples than expected";
        av_frame_free(&frame);
        return false;
    }
 
    if (pad_to_frame_size && read < frame_size) {
        int pad_samples = frame_size - read;
        int bytes_per_sample = av_get_bytes_per_sample(codec_context->sample_fmt);
        bool is_planar = av_sample_fmt_is_planar(codec_context->sample_fmt);
        int planes = is_planar ? static_cast<int>(m_channels) : 1;
        int samples_per_plane = is_planar ? pad_samples : pad_samples * static_cast<int>(m_channels);
 
        for (int p = 0; p < planes; ++p) {
            std::memset(
                frame->data[p] + static_cast<ptrdiff_t>(read) * bytes_per_sample * (is_planar ? 1 : static_cast<int>(m_channels)),
                0,
                static_cast<size_t>(samples_per_plane) * static_cast<size_t>(bytes_per_sample));
        }
        frame->nb_samples = frame_size;
    } else {
        frame->nb_samples = read;
    }
 
    frame->pts = m_pts;
    m_pts += frame->nb_samples;
 
    int ret = avcodec_send_frame(codec_context, frame);
    av_frame_free(&frame);
 
    if (ret < 0) {
        char errbuf[AV_ERROR_MAX_STRING_SIZE];
        av_strerror(ret, errbuf, sizeof(errbuf));
        m_last_error = std::string("avcodec_send_frame failed: ") + errbuf;
        return false;
    }
 
    return drain_packets(mux);
}

References codec_context, drain_packets(), fifo, m_channels, m_last_error, and m_pts.

Referenced by drain(), and encode_frames().

Here is the call graph for this function:

Here is the caller graph for this function: