@0biwank/screen-capture 2.0.1 → 2.0.2

package/src/HLSMuxer/AudioEncoder.cpp

@@ -1,484 +0,0 @@
-#include "HLSMuxer/AudioEncoder.h"
-#include <iostream>
-#include <sstream>
-#include <iomanip>
-#include <algorithm>
-
-extern "C"
-{
-#include <libavcodec/avcodec.h>
-#include <libavformat/avformat.h>
-#include <libswresample/swresample.h>
-#include <libavutil/opt.h>
-#include <libavutil/channel_layout.h>
-#include <libavutil/audio_fifo.h>
-}
-
-AudioEncoder::AudioEncoder()
-{
-    m_codecContext = nullptr;
-    m_codec = nullptr;
-    m_frame = nullptr;
-    m_swrContext = nullptr;
-    m_formatContext = nullptr;
-    m_stream = nullptr;
-    m_audioFifo = nullptr;
-
-    m_sampleCount = 0;
-    m_pts = 0;
-    m_nextInputPts = 0;
-    currentChunkIndex = 0;
-    m_initialized = false;
-}
-
-AudioEncoder::~AudioEncoder()
-{
-    cleanup();
-    while (!m_packetQueue.empty())
-    {
-        AVPacket *pkt = m_packetQueue.front();
-        m_packetQueue.pop();
-        av_packet_free(&pkt);
-    }
-}
-
-bool AudioEncoder::initialize(int sampleRate, int channels, int bitrate, OutputMode mode)
-{
-    m_codec = avcodec_find_encoder(AV_CODEC_ID_AAC);
-    if (!m_codec)
-    {
-        std::cerr << "AAC encoder not found!" << std::endl;
-        return false;
-    }
-    m_codecContext = avcodec_alloc_context3(m_codec);
-    if (!m_codecContext)
-    {
-        std::cerr << "Could not allocate codec context" << std::endl;
-        return false;
-    }
-    m_codecContext->bit_rate = bitrate;
-    m_codecContext->sample_fmt = AV_SAMPLE_FMT_FLTP;
-    m_codecContext->sample_rate = sampleRate;
-    av_channel_layout_default(&m_codecContext->ch_layout, channels);
-
-    m_sampleRate = sampleRate;
-    m_channels = channels;
-    m_bitrate = bitrate;
-    this->mode = mode;
-
-    int ret = avcodec_open2(m_codecContext, m_codec, nullptr);
-    if (ret < 0)
-    {
-        std::cerr << "Could not open codec" << std::endl;
-        cleanup();
-        return false;
-    }
-    // Set a sensible time base for audio frames (pts in samples)
-    m_codecContext->time_base = AVRational{1, sampleRate};
-    m_swrContext = swr_alloc();
-    if (!m_swrContext)
-    {
-        std::cerr << "Could not allocate SWR context" << std::endl;
-        cleanup();
-        return false;
-    }
-
-    // Set input and output parameters
-    av_opt_set_chlayout(m_swrContext, "in_chlayout", &m_codecContext->ch_layout, 0);
-    av_opt_set_int(m_swrContext, "in_sample_rate", sampleRate, 0);
-    av_opt_set_sample_fmt(m_swrContext, "in_sample_fmt", AV_SAMPLE_FMT_S16, 0);
-
-    av_opt_set_chlayout(m_swrContext, "out_chlayout", &m_codecContext->ch_layout, 0);
-    av_opt_set_int(m_swrContext, "out_sample_rate", sampleRate, 0);
-    av_opt_set_sample_fmt(m_swrContext, "out_sample_fmt", m_codecContext->sample_fmt, 0);
-
-    ret = swr_init(m_swrContext);
-    if (ret < 0)
-    {
-        std::cerr << "Could not initialize SWR context" << std::endl;
-        cleanup();
-        return false;
-    }
-    m_frame = av_frame_alloc();
-    if (!m_frame)
-    {
-        cleanup();
-        return false;
-    }
-    m_frame->format = m_codecContext->sample_fmt;
-    m_frame->ch_layout = m_codecContext->ch_layout;
-    m_frame->sample_rate = m_codecContext->sample_rate;
-    m_frame->nb_samples = m_codecContext->frame_size;
-
-    ret = av_frame_get_buffer(m_frame, 0);
-    if (ret < 0)
-    {
-        std::cerr << "Could not allocate frame buffer" << std::endl;
-        cleanup();
-        return false;
-    }
-
-    m_audioFifo = av_audio_fifo_alloc(
-        m_codecContext->sample_fmt,
-        m_codecContext->ch_layout.nb_channels,
-        m_codecContext->frame_size * 2);
-
-    if (!m_audioFifo)
-    {
-        std::cerr << "Could not allocate audio FIFO" << std::endl;
-        cleanup();
-        return false;
-    }
-
-    if (mode == OutputMode::STANDALONE)
-    {
-        avformat_alloc_output_context2(&m_formatContext, nullptr, "mpegts", nullptr);
-        if (!m_formatContext)
-        {
-            std::cerr << "Could not create output context for TS" << std::endl;
-            cleanup();
-            return false;
-        }
-
-        m_stream = avformat_new_stream(m_formatContext, nullptr);
-        if (!m_stream)
-        {
-            std::cerr << "Could not create audio stream" << std::endl;
-            cleanup();
-            return false;
-        }
-
-        avcodec_parameters_from_context(m_stream->codecpar, m_codecContext);
-        // Use the same time base as the codec context for simplicity
-        m_stream->time_base = m_codecContext->time_base;
-        targetChunkDuration = 4.0;
-        currentSegmentStartPts = 0;
-        currentSegmentDuration = 0.0;
-    }
-    m_initialized = true;
-    return true;
-}
-
-bool AudioEncoder::encodeSamples(const uint8_t *samples, int numSamples, int64_t pts)
-{
-    if (!m_initialized)
-    {
-        std::cerr << "Encoder is not initialized!" << std::endl;
-        return false;
-    }
-    int samplesToEncode = numSamples;
-    const uint8_t* samplesToUse = samples;
-    if (pts >= 0) {
-        if (pts < m_nextInputPts) {
-            const int64_t overlap = m_nextInputPts - pts;
-            if (overlap >= numSamples) {
-                return true;
-            }
-            const int bytesPerFrame = m_channels * static_cast<int>(sizeof(int16_t));
-            samplesToUse = samples + (overlap * bytesPerFrame);
-            samplesToEncode = static_cast<int>(numSamples - overlap);
-            pts = m_nextInputPts;
-        }
-
-        if (pts > m_nextInputPts + m_codecContext->frame_size &&
-            av_audio_fifo_size(m_audioFifo) > 0)
-        {
-            av_audio_fifo_reset(m_audioFifo);
-            m_sampleCount = pts;
-        } else if (av_audio_fifo_size(m_audioFifo) == 0) {
-            m_sampleCount = pts;
-        }
-    }
-
-    if (samplesToEncode <= 0) {
-        return true;
-    }
-
-    uint8_t **resampledData = nullptr;
-    int linesize;
-    int resampledSamples = av_samples_alloc_array_and_samples(
-        &resampledData,
-        &linesize,
-        m_codecContext->ch_layout.nb_channels,
-        samplesToEncode,
-        m_codecContext->sample_fmt,
-        0);
-    if (resampledSamples < 0)
-    {
-        std::cerr << "Could not allocate resampled buffer" << std::endl;
-        return false;
-    }
-    const uint8_t *inputData[1] = {samplesToUse};
-    int outputSamples = swr_convert(
-        m_swrContext,
-        resampledData,
-        samplesToEncode,
-        inputData,
-        samplesToEncode);
-
-    if (outputSamples < 0)
-    {
-        av_freep(&resampledData[0]);
-        av_freep(&resampledData);
-        return false;
-    }
-
-    av_audio_fifo_write(m_audioFifo, (void **)resampledData, outputSamples);
-    while (av_audio_fifo_size(m_audioFifo) >= m_codecContext->frame_size)
-    {
-        av_frame_make_writable(m_frame);
-        av_audio_fifo_read(m_audioFifo, (void **)m_frame->data, m_codecContext->frame_size);
-        m_frame->pts = m_sampleCount;
-        m_pts = m_frame->pts;
-
-        int ret = avcodec_send_frame(m_codecContext, m_frame);
-        if (ret < 0)
-        {
-            std::cerr << "Error sending frame to encoder" << std::endl;
-            av_freep(&resampledData[0]);
-            av_freep(&resampledData);
-            return false;
-        }
-
-        while (ret >= 0)
-        {
-            AVPacket *packet = av_packet_alloc();
-            ret = avcodec_receive_packet(m_codecContext, packet);
-
-            if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
-            {
-                av_packet_free(&packet);
-                break;
-            }
-
-            if (mode == OutputMode::MUXED)
-            {
-                m_packetQueue.push(packet);
-            }
-            else if (mode == OutputMode::STANDALONE)
-            {
-                if (shouldStartNewChunk() || currentChunkIndex == 0)
-                {
-                    // Close current chunk if exists
-                    if (m_formatContext && m_formatContext->pb)
-                    {
-                        av_write_trailer(m_formatContext);
-                        avio_closep(&m_formatContext->pb);
-
-                        currentSegmentDuration = (m_pts - currentSegmentStartPts) * av_q2d(m_codecContext->time_base);
-                    }
-
-                    // Generate filename for new chunk
-                    std::ostringstream filename;
-                    filename << "audio_chunk" << std::setfill('0') << std::setw(3) << currentChunkIndex << ".ts";
-                    std::string chunkFilename = filename.str();
-                    m_chunkFileNames.push_back(chunkFilename);
-
-                    // Open new chunk file
-                    if (avio_open(&m_formatContext->pb, chunkFilename.c_str(), AVIO_FLAG_WRITE) < 0)
-                    {
-                        std::cerr << "Could not open output file: " << chunkFilename << std::endl;
-                        av_packet_free(&packet);
-                        break;
-                    }
-
-                    // Write header for new chunk
-                    if (avformat_write_header(m_formatContext, nullptr) < 0)
-                    {
-                        std::cerr << "Could not write header for new chunk" << std::endl;
-                        av_packet_free(&packet);
-                        break;
-                    }
-
-                    currentChunkIndex++;
-                    currentSegmentStartPts = m_pts;
-                }
-
-                // Write packet to current chunk
-                packet->stream_index = m_stream->index;
-                av_packet_rescale_ts(packet, m_codecContext->time_base, m_stream->time_base);
-                if (av_interleaved_write_frame(m_formatContext, packet) < 0)
-                {
-                    std::cerr << "Failed to write audio packet" << std::endl;
-                }
-                av_packet_free(&packet);
-            }
-        }
-        m_sampleCount += m_codecContext->frame_size;
-    }
-    if (pts >= 0) {
-        m_nextInputPts = std::max<int64_t>(m_nextInputPts, pts + samplesToEncode);
-    } else {
-        m_nextInputPts = std::max<int64_t>(m_nextInputPts, m_sampleCount);
-    }
-    av_freep(&resampledData[0]);
-    av_freep(&resampledData);
-
-    return true;
-}
-
-bool AudioEncoder::hasPackets() const
-{
-    return !m_packetQueue.empty();
-}
-
-AVPacket *AudioEncoder::getNextPacket()
-{
-    if (m_packetQueue.empty())
-    {
-        return nullptr;
-    }
-    AVPacket *packet = m_packetQueue.front();
-    m_packetQueue.pop();
-    return packet;
-}
-
-bool AudioEncoder::shouldStartNewChunk() const
-{
-    double duration = (m_pts - currentSegmentStartPts) * av_q2d(m_codecContext->time_base);
-    return duration >= targetChunkDuration;
-}
-
-void AudioEncoder::forceNewChunk()
-{
-}
-
-void AudioEncoder::cleanup()
-{
-    // Flush encoder to get remaining packets
-    if (m_initialized && m_codecContext)
-    {
-        flushEncoder();
-        
-        // Finalize last segment if in STANDALONE mode
-        if (mode == OutputMode::STANDALONE && m_formatContext && m_formatContext->pb)
-        {
-            // Update duration for the final segment
-            currentSegmentDuration = (m_pts - currentSegmentStartPts) * av_q2d(m_codecContext->time_base);
-            
-            av_write_trailer(m_formatContext);
-            avio_closep(&m_formatContext->pb);
-        }
-    }
-    
-    if (mode != OutputMode::MUXED)
-    {
-        while (!m_packetQueue.empty())
-        {
-            AVPacket *pkt = m_packetQueue.front();
-            m_packetQueue.pop();
-            av_packet_free(&pkt);
-        }
-    }
-    if (m_audioFifo)
-    {
-        av_audio_fifo_free(m_audioFifo);
-        m_audioFifo = nullptr;
-    }
-    if (m_frame)
-    {
-        av_frame_free(&m_frame);
-        m_frame = nullptr;
-    }
-    if (m_swrContext)
-    {
-        swr_free(&m_swrContext);
-        m_swrContext = nullptr;
-    }
-    if (m_formatContext)
-    {
-        if (m_formatContext->pb)
-        {
-            // Should already be closed above, but ensure it's closed
-            avio_closep(&m_formatContext->pb);
-        }
-        avformat_free_context(m_formatContext);
-        m_formatContext = nullptr;
-    }
-    if (m_codecContext)
-    {
-        avcodec_free_context(&m_codecContext);
-        m_codecContext = nullptr;
-    }
-    m_initialized = false;
-}
-
-std::string AudioEncoder::generatePlaylist() const
-{
-    if (mode != OutputMode::STANDALONE || m_chunkFileNames.empty())
-    {
-        return "";
-    }
-
-    std::string playlist = "#EXTM3U\n";
-    playlist += "#EXT-X-VERSION:3\n";
-    playlist += "#EXT-X-TARGETDURATION:" + std::to_string(static_cast<int>(targetChunkDuration + 1)) + "\n";
-    playlist += "#EXT-X-MEDIA-SEQUENCE:0\n";
-
-    for (size_t i = 0; i < m_chunkFileNames.size(); ++i)
-    {
-        double duration = targetChunkDuration;
-        if (i == m_chunkFileNames.size() - 1 && currentSegmentDuration > 0)
-        {
-            duration = currentSegmentDuration; // Last segment might be shorter
-        }
-
-        playlist += "#EXTINF:" + std::to_string(duration) + ",\n";
-        playlist += m_chunkFileNames[i] + "\n";
-    }
-
-    // Add end marker if encoding is complete
-    if (!m_initialized)
-    {
-        playlist += "#EXT-X-ENDLIST\n";
-    }
-
-    return playlist;
-}
-
-// Drain encoder and handle remaining packets based on mode
-void AudioEncoder::flushEncoder()
-{
-    if (!m_codecContext)
-        return;
-
-    // Send NULL frame to signal flushing
-    int ret = avcodec_send_frame(m_codecContext, nullptr);
-    if (ret < 0 && ret != AVERROR_EOF)
-        return;
-
-    while (true)
-    {
-        AVPacket *packet = av_packet_alloc();
-        ret = avcodec_receive_packet(m_codecContext, packet);
-        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
-        {
-            av_packet_free(&packet);
-            break;
-        }
-        if (ret < 0)
-        {
-            av_packet_free(&packet);
-            break;
-        }
-
-        if (mode == OutputMode::MUXED)
-        {
-            m_packetQueue.push(packet);
-        }
-        else if (mode == OutputMode::STANDALONE && m_formatContext && m_formatContext->pb)
-        {
-            packet->stream_index = m_stream->index;
-            av_packet_rescale_ts(packet, m_codecContext->time_base, m_stream->time_base);
-            if (av_interleaved_write_frame(m_formatContext, packet) < 0)
-            {
-                std::cerr << "Failed to write flushed audio packet" << std::endl;
-            }
-            av_packet_free(&packet);
-        }
-        else
-        {
-            av_packet_free(&packet);
-        }
-    }
-}