electron C++播放视频

Electron 是一个基于 Chromium 和 Node.js 的框架，可以用于开发跨平台的桌面应用程序。它提供了一组 API，可以让开发者使用 Web 技术构建桌面应用程序。如果你想在 Electron 中播放视频，可以使用 HTML5 的 video 标签。

如果你需要在 C++ 中播放视频，可以使用一些第三方库，例如 FFmpeg 或者 GStreamer。这些库可以让你在 C++ 中解码和渲染视频。

在 Electron 中使用 C++ 库可以使用 Node.js 的 C++ 插件。你可以编写一个 Node.js 插件，使用 C++ 调用第三方库来播放视频。然后在 Electron 中使用这个插件来播放视频。

这里提供一个简单的示例代码，使用 FFmpeg 在 C++ 中播放视频：

#include <iostream>
#include <string>
#include <thread>
#include <chrono>
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
}

int main(int argc, char** argv) {
    AVFormatContext* pFormatCtx = nullptr;
    AVCodecContext* pCodecCtx = nullptr;
    AVCodec* pCodec = nullptr;
    AVFrame* pFrame = nullptr;
    AVFrame* pFrameRGB = nullptr;
    uint8_t* buffer = nullptr;
    int videoStream = -1;
    int numBytes = 0;
    struct SwsContext* swsCtx = nullptr;
    AVPacket packet;

    // Open video file
    if (avformat_open_input(&pFormatCtx, "video.mp4", nullptr, nullptr) != 0) {
        std::cerr << "Failed to open video file" << std::endl;
        return -1;
    }

    // Retrieve stream information
    if (avformat_find_stream_info(pFormatCtx, nullptr) < 0) {
        std::cerr << "Failed to retrieve stream information" << std::endl;
        return -1;
    }

    // Find the first video stream
    for (unsigned int i = 0; i < pFormatCtx->nb_streams; i++) {
        if (pFormatCtx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
            videoStream = i;
            break;
        }
    }

    if (videoStream == -1) {
        std::cerr << "Failed to find video stream" << std::endl;
        return -1;
    }

    // Get a pointer to the codec context for the video stream
    pCodecCtx = avcodec_alloc_context3(nullptr);
    avcodec_parameters_to_context(pCodecCtx, pFormatCtx->streams[videoStream]->codecpar);
    pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
    if (pCodec == nullptr) {
        std::cerr << "Failed to find codec" << std::endl;
        return -1;
    }

    // Open codec
    if (avcodec_open2(pCodecCtx, pCodec, nullptr) < 0) {
        std::cerr << "Failed to open codec" << std::endl;
        return -1;
    }

    // Allocate video frame
    pFrame = av_frame_alloc();
    pFrameRGB = av_frame_alloc();
    if (pFrameRGB == nullptr || pFrame == nullptr) {
        std::cerr << "Failed to allocate video frame" << std::endl;
        return -1;
    }

    // Determine required buffer size and allocate buffer
    numBytes = av_image_get_buffer_size(AV_PIX_FMT_RGB24, pCodecCtx->width, pCodecCtx->height, 1);
    buffer = (uint8_t*)av_malloc(numBytes * sizeof(uint8_t));
    if (buffer == nullptr) {
        std::cerr << "Failed to allocate buffer" << std::endl;
        return -1;
    }

    // Assign appropriate parts of buffer to image planes in pFrameRGB
    av_image_fill_arrays(pFrameRGB->data, pFrameRGB->linesize, buffer, AV_PIX_FMT_RGB24, pCodecCtx->width, pCodecCtx->height, 1);

    // Initialize SWS context for software scaling
    swsCtx = sws_getContext(pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height, AV_PIX_FMT_RGB24, SWS_BILINEAR, nullptr, nullptr, nullptr);
    if (swsCtx == nullptr) {
        std::cerr << "Failed to initialize SWS context" << std::endl;
        return -1;
    }

    // Read frames and save first five frames to disk
    int frameCount = 0;
    while (av_read_frame(pFormatCtx, &packet) >= 0 && frameCount < 5) {
        // Is this a packet from the video stream?
        if (packet.stream_index == videoStream) {
            // Decode video frame
            int ret = avcodec_send_packet(pCodecCtx, &packet);
            if (ret < 0) {
                std::cerr << "Failed to send packet for decoding" << std::endl;
                return -1;
            }

            while (ret >= 0) {
                ret = avcodec_receive_frame(pCodecCtx, pFrame);
                if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                    break;
                }
                else if (ret < 0) {
                    std::cerr << "Failed to decode video frame" << std::endl;
                    return -1;
                }

                // Convert the image from its native format to RGB
                sws_scale(swsCtx, (uint8_t const* const*)pFrame->data, pFrame->linesize, 0, pCodecCtx->height, pFrameRGB->data, pFrameRGB->linesize);

                // Save the frame to disk
                std::string fileName = "frame" + std::to_string(frameCount) + ".ppm";
                FILE* file = fopen(fileName.c_str(), "wb");
                if (file == nullptr) {
                    std::cerr << "Failed to open file for saving frame" << std::endl;
                    return -1;
                }
                fprintf(file, "P6\n%d %d\n255\n", pCodecCtx->width, pCodecCtx->height);
                fwrite(pFrameRGB->data[0], 1, numBytes, file);
                fclose(file);
                std::cout << "Saved frame " << frameCount << std::endl;
                frameCount++;
            }
        }

        // Free the packet that was allocated by av_read_frame
        av_packet_unref(&packet);
    }

    // Clean up
    avformat_close_input(&pFormatCtx);
    avcodec_free_context(&pCodecCtx);
    av_frame_free(&pFrame);
    av_frame_free(&pFrameRGB);
    sws_freeContext(swsCtx);
    av_free(buffer);
    return 0;
}

这里的代码使用 FFmpeg 解码视频，并将每一帧转换为 RGB 格式，然后保存到磁盘上。你可以根据需要修改代码，将视频渲染到屏幕上，或者在 Electron 中使用 Node.js 插件调用这个 C++ 程序来播放视频。