基于Qt + FFmpeg实现视频片段裁剪功能

导入视频
  -> VideoTrimPage 自动生成时间轴缩略图
  -> VideoTrimEditor 维护选区、播放头和预览
  -> 可选生成轻量音频峰值波形
  -> MediaAnalyzer 后台调度导出
  -> VideoClipProcessor 使用 FFmpeg stream copy 写出片段

VideoTrimPage.qml
    页面层：当前文件、缩略图刷新、音频峰值生成、导出参数和结果展示
        ↓
VideoTrimEditor.qml
    交互层：视频预览、缩略图时间轴、播放头、选区左右把柄、音频峰值轨
        ↓ selectionStartMs / selectionEndMs
MediaAnalyzer
    QML 门面：文件导入通知、异步缩略图、异步音频峰值、异步导出、状态回写
        ↓
VideoFrameExtractor / AudioDecoder / VideoClipProcessor
    FFmpeg 层：批量抽帧、流式音频峰值聚合、stream copy 裁剪导出

property var outputFormats: ["mp4", "mkv", "mov", "webm"]
property string exportModeNotice: "快速导出使用 stream copy，无重编码、画质无损，但起点按关键帧对齐。"

function generateThumbnails() {
    if (!mediaAnalyzer.videoTrimThumbnailBusy && appRoot.hasFile && appRoot.currentFileIsVideo())
        mediaAnalyzer.generateVideoTrimThumbnails(24, 180)
}

Timer {
    id: autoGenerateThumbnailsTimer
    interval: 50
    repeat: false
    onTriggered: page.generateThumbnails()
}

emit fileOpened();

Connections {
    target: mediaAnalyzer

    function onCurrentFileChanged() {
        page.refreshDefaultPath()
        autoGenerateThumbnailsTimer.restart()
    }

    function onFileOpened() {
        page.refreshDefaultPath()
        trimEditor.resetForImportedFile()
        autoGenerateThumbnailsTimer.restart()
    }
}

mediaAnalyzer.generateVideoTrimAudioPeaks(4096)

4096 * 2 * sizeof(qint16) = 16KB

VideoTrimEditor {
    id: trimEditor
    source: mediaAnalyzer.currentFileUrl
    thumbnails: mediaAnalyzer.videoTrimThumbnails
    thumbnailsLoading: mediaAnalyzer.videoTrimThumbnailBusy
    thumbnailProgress: mediaAnalyzer.videoTrimThumbnailProgress
    thumbnailTotal: mediaAnalyzer.videoTrimThumbnailTotal
    audioPeakData: mediaAnalyzer.videoTrimAudioPeakData
    audioPeakCount: mediaAnalyzer.videoTrimAudioPeakCount
    audioPcmData: mediaAnalyzer.videoTrimAudioPeakCount > 0 ? "" : mediaAnalyzer.pcmData
}

mediaAnalyzer.trimCurrentVideoCopy(Math.round(trimEditor.selectionStartMs),
                                   Math.round(trimEditor.selectionEndMs),
                                   outputPathField.text.trim(),
                                   formatBox.currentText,
                                   keepAudioBox.checked,
                                   keepSubtitleBox.checked,
                                   copyMetadataBox.checked)

property real selectionStartMs: 0
property real selectionEndMs: 0
property real playheadMs: displayPositionMs
property real displayPositionMs: 0
readonly property real durationMs: player.duration > 0 ? player.duration : inferredDuration()
readonly property bool hasSelection: selectionEndMs > selectionStartMs

function msForX(x) { ... }
function xForMs(ms) { ... }

selectionStartMs = 0
selectionEndMs = durationMs

function resetForImportedFile() {
    playAfterSeekTimer.stop()
    player.stop()
    userPlaybackRequested = false
    userAdjustedSelection = false
    playbackFinished = false
    pendingSeek = false
    pendingSeekMs = 0
    selectionStartMs = 0
    selectionEndMs = durationMs > 0 ? durationMs : 0
    setDisplayPosition(0)
    if (player.seekable)
        player.seek(0)
    selectionChanged(selectionStartMs, selectionEndMs)
}

editor.editSelectionFromTimeline(newStartMs, editor.selectionEndMs)
editor.editSelectionFromTimeline(editor.selectionStartMs, newEndMs)

var playheadStillInside = currentPlayhead >= selectionStartMs && currentPlayhead <= selectionEndMs
if (!playheadStillInside)
    requestPlayerSeek(selectionStartMs)

MouseArea {
    id: timelineClickArea
    anchors.fill: parent
    onPressed: {
        var target = editor.positionFromTimelineClick(mouse.x)
        if (target < 0) {
            mouse.accepted = false
        } else {
            editor.seekTo(target)
            mouse.accepted = true
        }
    }
}

ActionButton {
    text: (player.playbackState === MediaPlayer.PlayingState || playAfterSeekTimer.running) ? "暂停" : "播放"
    enabled: editor.source !== "" && editor.hasSelection
    onClicked: editor.togglePlayback()
}

function finishPlayback() {
    playAfterSeekTimer.stop()
    playbackFinished = true
    player.stop()
    requestPlayerSeek(selectionStartMs)
}

Timer {
    id: smoothPlayheadTimer
    interval: 16
    repeat: true
    running: editor.isPlaying
    onTriggered: {
        var elapsed = Date.now() - editor._lastSyncTime
        var interpolated = editor._lastSyncPosition + elapsed
        editor.displayPositionMs = editor.clampMs(interpolated)
    }
}

function requestPlayerSeek(ms) {
    pendingSeekMs = clampMs(Number(ms || 0))
    pendingSeek = true
    setDisplayPosition(pendingSeekMs)
    player.seek(pendingSeekMs)
}

if (Math.abs(player.position - pendingSeekMs) <= 250) {
    pendingSeek = false
    setDisplayPosition(player.position)
}

Image {
    source: editor.previewImageUrl
    visible: source !== ""
             && !editor.userPlaybackRequested
             && player.playbackState !== MediaPlayer.PlayingState
             && !playAfterSeekTimer.running
}

AudioPeakTrack {
    enabled: false
    peakData: editor.audioPeakData
    peakCount: editor.audioPeakCount
    selectionStartMs: Math.round(editor.selectionStartMs)
    selectionEndMs: Math.round(editor.selectionEndMs)
    positionMs: Math.round(editor.displayPositionMs)
}

videoTrimThumbnailBusy
videoTrimThumbnailProgress
videoTrimThumbnailTotal
videoTrimThumbnails

cancelVideoTrimThumbnailJob();
const int jobId = ++m_videoTrimThumbnailJobId;
QSharedPointer<QAtomicInt> cancelFlag(new QAtomicInt(0));

extractor.extractTimelineFrames(..., [=](int index, qint64 timestampMs, const QString &imagePath, const QVariantMap &) {
    if (cancelFlag->loadAcquire() != 0)
        return false;

    QVariantMap item;
    item.insert("timestampMs", timestampMs);
    item.insert("imageUrl", QUrl::fromLocalFile(imagePath).toString());
    item.insert("durationMs", durationMs);

    QMetaObject::invokeMethod(this, [this, jobId, item]() {
        if (jobId != m_videoTrimThumbnailJobId)
            return;
        appendVideoTrimThumbnail(item);
        setVideoTrimThumbnailState(m_videoTrimThumbnailBusy,
                                   m_videoTrimThumbnails.size(),
                                   m_videoTrimThumbnailTotal);
    }, Qt::QueuedConnection);
    return true;
}, &errorText);

avformat_open_input(...)
avformat_find_stream_info(...)
avcodec_open2(...)

for (timestamp in timestampsMs) {
    av_seek_frame(..., AVSEEK_FLAG_BACKWARD)
    avcodec_flush_buffers(codecCtx)
    av_read_frame(...)
    receiveAndSaveFrame(...)
}

MediaAnalyzer::generateVideoTrimAudioPeaks(4096)

每秒约 48000 * 2 * 2 = 192KB
1 小时约 691MB

bool decodeToPeaks(const QString &filePath,
                   int peakCount,
                   QByteArray *peakData,
                   QVariantMap *peakInfo,
                   QString *errorText,
                   const std::function<bool()> &shouldCancel) const;

qint16 min
qint16 max

cancelVideoTrimAudioPeakJob();
const int jobId = ++m_videoTrimAudioPeakJobId;
QSharedPointer<QAtomicInt> cancelFlag(new QAtomicInt(0));

Q_INVOKABLE bool trimCurrentVideoCopy(qint64 startMs,
                                      qint64 endMs,
                                      const QString &filePath,
                                      const QString &format,
                                      bool keepAudio,
                                      bool keepSubtitle,
                                      bool copyMetadata);

if (outputPath.startsWith("file:", Qt::CaseInsensitive))
    outputPath = QUrl(outputPath).toLocalFile();
if (outputPath.isEmpty())
    outputPath = defaultVideoTrimPath(format);

av_seek_frame(inCtx, videoStreamIndex, seekTarget, AVSEEK_FLAG_BACKWARD);

av_packet_rescale_ts(packet, inStream->time_base, outStream->time_base);
av_interleaved_write_frame(outCtx, packet);

jobId + QAtomicInt cancelFlag