@0biwank/screen-capture 1.0.1 → 2.0.1

package/src/HLSMuxer/FileHLSMuxer.cpp

@@ -0,0 +1,345 @@
+#include "HLSMuxer/FileHLSMuxer.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+#include <dirent.h>
+#include <iostream>
+#include <sys/stat.h>
+#include <utility>
+
+extern "C" {
+#include <libavcodec/avcodec.h>
+#include <libavcodec/bsf.h>
+#include <libavcodec/packet.h>
+#include <libavformat/avformat.h>
+#include <libavutil/avutil.h>
+#include <libavutil/error.h>
+#include <libavutil/opt.h>
+}
+
+namespace {
+std::string av_error(int err) {
+    char buf[AV_ERROR_MAX_STRING_SIZE];
+    av_strerror(err, buf, sizeof(buf));
+    return std::string(buf);
+}
+
+bool is_avcc_h264(const AVCodecParameters* par) {
+    return par &&
+           par->codec_id == AV_CODEC_ID_H264 &&
+           par->extradata &&
+           par->extradata_size > 0 &&
+           static_cast<uint8_t>(par->extradata[0]) == 1;
+}
+}
+
+FileHLSMuxer::FileHLSMuxer() = default;
+
+FileHLSMuxer::~FileHLSMuxer() {
+    shutdown();
+}
+
+bool FileHLSMuxer::init(const std::string& output_dir,
+                        const std::string& recording_id,
+                        int segment_time_sec,
+                        const AVCodecContext* video_codec_ctx,
+                        const AVCodecContext* audio_codec_ctx)
+{
+    if (m_initialized) return true;
+    if (!video_codec_ctx || !audio_codec_ctx) {
+        std::cerr << "[FileHLSMuxer] video/audio codec context missing\n";
+        return false;
+    }
+    if (output_dir.empty() || recording_id.empty()) {
+        std::cerr << "[FileHLSMuxer] outputDir/recordingId required\n";
+        return false;
+    }
+
+    m_output_dir = output_dir;
+    m_recording_id = recording_id;
+    m_playlist_path = output_dir + "/playlist.m3u8";
+    m_fps = video_codec_ctx->framerate.num > 0 ? video_codec_ctx->framerate.num : 30;
+    m_sample_rate = audio_codec_ctx->sample_rate > 0 ? audio_codec_ctx->sample_rate : 48000;
+    m_audio_frame_samples = audio_codec_ctx->frame_size > 0 ? audio_codec_ctx->frame_size : 1024;
+    m_video_tb_num = video_codec_ctx->time_base.num > 0 ? video_codec_ctx->time_base.num : 1;
+    m_video_tb_den = video_codec_ctx->time_base.den > 0 ? video_codec_ctx->time_base.den : m_fps;
+    m_audio_tb_num = audio_codec_ctx->time_base.num > 0 ? audio_codec_ctx->time_base.num : 1;
+    m_audio_tb_den = audio_codec_ctx->time_base.den > 0 ? audio_codec_ctx->time_base.den : m_sample_rate;
+
+    int ret = avformat_alloc_output_context2(&m_fmt_ctx, nullptr, "hls", m_playlist_path.c_str());
+    if (ret < 0 || !m_fmt_ctx) {
+        std::cerr << "[FileHLSMuxer] alloc hls output failed: " << av_error(ret) << "\n";
+        return false;
+    }
+
+    m_video_stream = avformat_new_stream(m_fmt_ctx, nullptr);
+    if (!m_video_stream) {
+        std::cerr << "[FileHLSMuxer] failed to create video stream\n";
+        shutdown();
+        return false;
+    }
+    ret = avcodec_parameters_from_context(m_video_stream->codecpar, video_codec_ctx);
+    if (ret < 0) {
+        std::cerr << "[FileHLSMuxer] copy video codec params failed: " << av_error(ret) << "\n";
+        shutdown();
+        return false;
+    }
+    m_video_stream->time_base = video_codec_ctx->time_base;
+
+    m_audio_stream = avformat_new_stream(m_fmt_ctx, nullptr);
+    if (!m_audio_stream) {
+        std::cerr << "[FileHLSMuxer] failed to create audio stream\n";
+        shutdown();
+        return false;
+    }
+    ret = avcodec_parameters_from_context(m_audio_stream->codecpar, audio_codec_ctx);
+    if (ret < 0) {
+        std::cerr << "[FileHLSMuxer] copy audio codec params failed: " << av_error(ret) << "\n";
+        shutdown();
+        return false;
+    }
+    m_audio_stream->time_base = audio_codec_ctx->time_base;
+
+    if (!(m_fmt_ctx->oformat->flags & AVFMT_NOFILE)) {
+        ret = avio_open(&m_fmt_ctx->pb, m_playlist_path.c_str(), AVIO_FLAG_WRITE);
+        if (ret < 0) {
+            std::cerr << "[FileHLSMuxer] open playlist failed: " << av_error(ret)
+                      << " path=" << m_playlist_path << "\n";
+            shutdown();
+            return false;
+        }
+    }
+
+    AVDictionary* opts = nullptr;
+    const int safe_segment_time = std::max(1, segment_time_sec);
+    const std::string segment_pattern = output_dir + "/" + recording_id + "-video-%04d.ts";
+    av_dict_set(&opts, "hls_time", std::to_string(safe_segment_time).c_str(), 0);
+    av_dict_set(&opts, "hls_segment_filename", segment_pattern.c_str(), 0);
+    av_dict_set(&opts, "hls_list_size", "0", 0);
+    av_dict_set(&opts, "hls_playlist_type", "vod", 0);
+    av_dict_set(&opts, "hls_flags", "independent_segments+temp_file", 0);
+    av_dict_set(&opts, "hls_segment_type", "mpegts", 0);
+
+    ret = avformat_write_header(m_fmt_ctx, &opts);
+    av_dict_free(&opts);
+    if (ret < 0) {
+        std::cerr << "[FileHLSMuxer] write header failed: " << av_error(ret) << "\n";
+        shutdown();
+        return false;
+    }
+
+    if (!init_h264_bsf_if_needed()) {
+        shutdown();
+        return false;
+    }
+
+    m_initialized = true;
+    std::cerr << "[FileHLSMuxer] initialized playlist=" << m_playlist_path
+              << " segmentPattern=" << segment_pattern
+              << " hlsTime=" << safe_segment_time
+              << " fps=" << m_fps
+              << " sampleRate=" << m_sample_rate
+              << "\n";
+    return true;
+}
+
+void FileHLSMuxer::set_expected_segment_duration_ms(double duration_ms) {
+    m_expected_segment_duration_ms = duration_ms > 0.0 ? duration_ms : 0.0;
+}
+
+void FileHLSMuxer::set_segment_ready_callback(std::function<void(const std::string&)> callback) {
+    m_segment_ready_callback = std::move(callback);
+}
+
+bool FileHLSMuxer::init_h264_bsf_if_needed() {
+    if (!is_avcc_h264(m_video_stream ? m_video_stream->codecpar : nullptr)) {
+        return true;
+    }
+
+    const AVBitStreamFilter* bsf = av_bsf_get_by_name("h264_mp4toannexb");
+    if (!bsf) {
+        std::cerr << "[FileHLSMuxer] h264_mp4toannexb filter not found\n";
+        return false;
+    }
+
+    int ret = av_bsf_alloc(bsf, &m_h264_bsf_ctx);
+    if (ret < 0) {
+        std::cerr << "[FileHLSMuxer] bsf alloc failed: " << av_error(ret) << "\n";
+        return false;
+    }
+
+    ret = avcodec_parameters_copy(m_h264_bsf_ctx->par_in, m_video_stream->codecpar);
+    if (ret < 0) {
+        std::cerr << "[FileHLSMuxer] bsf parameter copy failed: " << av_error(ret) << "\n";
+        return false;
+    }
+    m_h264_bsf_ctx->time_base_in = m_video_stream->time_base;
+
+    ret = av_bsf_init(m_h264_bsf_ctx);
+    if (ret < 0) {
+        std::cerr << "[FileHLSMuxer] bsf init failed: " << av_error(ret) << "\n";
+        return false;
+    }
+
+    std::cerr << "[FileHLSMuxer] enabled h264_mp4toannexb\n";
+    return true;
+}
+
+void FileHLSMuxer::push_video(AVPacket* pkt) {
+    if (!pkt) return;
+    write_packet(pkt, true);
+    av_packet_free(&pkt);
+}
+
+void FileHLSMuxer::push_audio(AVPacket* pkt) {
+    if (!pkt) return;
+    write_packet(pkt, false);
+    av_packet_free(&pkt);
+}
+
+int FileHLSMuxer::write_packet(AVPacket* pkt, bool is_video) {
+    if (!m_initialized || !pkt) return AVERROR(EINVAL);
+
+    AVStream* stream = is_video ? m_video_stream : m_audio_stream;
+    if (!stream) return AVERROR(EINVAL);
+
+    if (pkt->duration <= 0) {
+        pkt->duration = is_video ? 1 : m_audio_frame_samples;
+    }
+    if (pkt->dts == AV_NOPTS_VALUE) {
+        pkt->dts = pkt->pts;
+    }
+
+    pkt->stream_index = stream->index;
+    av_packet_rescale_ts(
+        pkt,
+        is_video ? AVRational{m_video_tb_num, m_video_tb_den}
+                 : AVRational{m_audio_tb_num, m_audio_tb_den},
+        stream->time_base);
+
+    if (is_video) {
+        log_overlong_segment_if_needed(pkt);
+    }
+
+    if (is_video && m_h264_bsf_ctx) {
+        int ret = av_bsf_send_packet(m_h264_bsf_ctx, pkt);
+        if (ret < 0) {
+            std::cerr << "[FileHLSMuxer] bsf send failed: " << av_error(ret) << "\n";
+            return ret;
+        }
+
+        while ((ret = av_bsf_receive_packet(m_h264_bsf_ctx, pkt)) == 0) {
+            pkt->stream_index = stream->index;
+            ret = av_interleaved_write_frame(m_fmt_ctx, pkt);
+            av_packet_unref(pkt);
+            if (ret < 0) {
+                std::cerr << "[FileHLSMuxer] write video packet failed: " << av_error(ret) << "\n";
+                return ret;
+            }
+            notify_ready_segments();
+        }
+
+        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
+            return 0;
+        }
+        std::cerr << "[FileHLSMuxer] bsf receive failed: " << av_error(ret) << "\n";
+        return ret;
+    }
+
+    int ret = av_interleaved_write_frame(m_fmt_ctx, pkt);
+    if (ret < 0) {
+        std::cerr << "[FileHLSMuxer] write " << (is_video ? "video" : "audio")
+                  << " packet failed: " << av_error(ret) << "\n";
+    } else if (is_video) {
+        notify_ready_segments();
+    }
+    return ret;
+}
+
+void FileHLSMuxer::notify_ready_segments() {
+    if (!m_segment_ready_callback || m_output_dir.empty() || m_recording_id.empty()) {
+        return;
+    }
+
+    DIR* dir = opendir(m_output_dir.c_str());
+    if (!dir) {
+        return;
+    }
+
+    const std::string prefix = m_recording_id + "-video-";
+    const std::string suffix = ".ts";
+    while (dirent* entry = readdir(dir)) {
+        const std::string name = entry->d_name;
+        if (name.size() <= prefix.size() + suffix.size()) {
+            continue;
+        }
+        if (name.rfind(prefix, 0) != 0 ||
+            name.compare(name.size() - suffix.size(), suffix.size(), suffix) != 0) {
+            continue;
+        }
+
+        const std::string full_path = m_output_dir + "/" + name;
+        struct stat st {};
+        if (stat(full_path.c_str(), &st) != 0 || st.st_size <= 0) {
+            continue;
+        }
+
+        if (m_notified_segments.insert(full_path).second) {
+            std::cerr << "[FileHLSMuxer] segment ready path=" << full_path
+                      << " bytes=" << st.st_size << "\n";
+            m_segment_ready_callback(full_path);
+        }
+    }
+    closedir(dir);
+}
+
+void FileHLSMuxer::log_overlong_segment_if_needed(AVPacket* pkt) {
+    if (!pkt || !(pkt->flags & AV_PKT_FLAG_KEY) || pkt->pts == AV_NOPTS_VALUE) {
+        return;
+    }
+
+    if (m_last_segment_key_pts >= 0 && m_expected_segment_duration_ms > 0.0) {
+        const double dur_ms =
+            (pkt->pts - m_last_segment_key_pts) * av_q2d(m_video_stream->time_base) * 1000.0;
+        const double one_frame_ms = 1000.0 / std::max(1, m_fps);
+        if (dur_ms > m_expected_segment_duration_ms + one_frame_ms) {
+            std::cerr << "[FileHLSMuxer] Overlong native HLS segment cadence"
+                      << " durationMs=" << dur_ms
+                      << " expectedMs=" << m_expected_segment_duration_ms
+                      << " previousKeyPts=" << m_last_segment_key_pts
+                      << " currentKeyPts=" << pkt->pts
+                      << "\n";
+        }
+    }
+    m_last_segment_key_pts = pkt->pts;
+}
+
+void FileHLSMuxer::shutdown() {
+    if (m_h264_bsf_ctx) {
+        av_bsf_free(&m_h264_bsf_ctx);
+        m_h264_bsf_ctx = nullptr;
+    }
+
+    if (m_fmt_ctx) {
+        if (m_initialized) {
+            int ret = av_write_trailer(m_fmt_ctx);
+            if (ret < 0) {
+                std::cerr << "[FileHLSMuxer] write trailer failed: " << av_error(ret) << "\n";
+            } else {
+                std::cerr << "[FileHLSMuxer] finalized playlist=" << m_playlist_path << "\n";
+                notify_ready_segments();
+            }
+        }
+
+        if (!(m_fmt_ctx->oformat->flags & AVFMT_NOFILE)) {
+            avio_closep(&m_fmt_ctx->pb);
+        }
+        avformat_free_context(m_fmt_ctx);
+        m_fmt_ctx = nullptr;
+    }
+
+    m_video_stream = nullptr;
+    m_audio_stream = nullptr;
+    m_initialized = false;
+}