注：这段代码存在问题，在点击关闭按钮时不能退出。后续添加了qttimer和qt线程的处理方式
    代码 videocapture.h

    1. #ifndef VIDEOCAPTURE_H
    2. #define VIDEOCAPTURE_H
    4. #include <iostream>
    5. #include <QWidget>
    6. #include <QLabel>
    7. #include <QPushButton>
    8. #include <QCloseEvent>
    10. extern "C"
    11. {
    12.     #include <stdio.h>
    13.     #include <libavcodec/avcodec.h>
    14.     #include <libavformat/avformat.h>
    15.     #include <libswscale/swscale.h>
    16.     #include <libavdevice/avdevice.h>
    17.     #include <libavformat/version.h>
    18.     #include <libavutil/time.h>
    19.     #include <libavutil/mathematics.h>
    20.     //#include <libavutil/imgutils.h">
    21.     #include <SDL2/SDL.h>
    22. }
    24. //event message
    25. #define REFRESH_EVENT (SDL_USEREVENT + 1)
    26. #define QUIT_EVENT (SDL_USEREVENT + 2)
    28. QT_BEGIN_NAMESPACE
    29. namespace Ui { class VideoCapture; }
    30. QT_END_NAMESPACE
    32. class VideoCapture : public QWidget
    33. {
    34.     Q_OBJECT
    36. public:
    37.     VideoCapture(QWidget *parent = nullptr);
    38.     ~VideoCapture();
    40.     void close_play();
    42. private:
    43.     QLabel *label;
    44.     Ui::VideoCapture *ui;
    45.     QPushButton *start_btn;
    46.     QRect rect;
    47.     bool isplay;
    49. private slots:
    50.     void start_play();
    52. protected:
    53.      void closeEvent(QCloseEvent *event);
    54. };
    55. #endif // VIDEOCAPTURE_H

    代码 videocapture.cpp

    1. #include "videocapture.h"
    2. #include "ui_videocapture.h"
    3. #include <QDebug>
    4. #include <QTimer>
    6. VideoCapture::VideoCapture(QWidget *parent)
    7.     : QWidget(parent)
    8.     , ui(new Ui::VideoCapture)
    9. {
    10.     ui->setupUi(this);
    11.     qDebug() << "123";
    12.     this->setFixedSize(1280,720);
    13.     label = new QLabel(this);
    14.     label->resize(1280,720);
    16.     qDebug() << "456";
    17.     label->move(0,0);
    18.     rect = label->geometry();//记录widget位置，恢复时使用
    19.     isplay = false;
    20.     start_btn = new QPushButton("btn1" ,this);
    21.     connect(start_btn,&QPushButton::clicked,this,&VideoCapture::start_play);
    22.     connect(start_btn,&QPushButton::clicked,this,&VideoCapture::start_play);
    23. }
    25. VideoCapture::~VideoCapture()
    26. {
    27.     delete ui;
    28. }
    30. static AVFrame* create_frame(int width, int height, AVPixelFormat pix_fmt)
    31. {
    32.     int ret = 0;
    33.     AVFrame* frame = NULL;
    35.     frame = av_frame_alloc();
    36.     if (!frame)
    37.     {
    38.         printf("Error, No Memory!\n");
    39.         goto __ERROR;
    40.     }
    42.     //设置参数
    43.     frame->width = width;
    44.     frame->height = height;
    45.     frame->format = pix_fmt;
    47.     //alloc inner memory
    48.     ret = av_frame_get_buffer(frame, 32); //按32位对齐 【视频必须是32位对齐】
    49.     if (ret < 0)
    50.     {
    51.         printf("Error, Failed to alloc buffer for frame!\n");
    52.         goto __ERROR;
    53.     }
    55.     return frame;
    56. __ERROR:
    57.     if (frame)
    58.     {
    59.         av_frame_free(&frame);
    60.     }
    61.     return NULL;
    62. }
    64. int thread_exit = 0;
    66. int refresh_video_timer(void *udata)
    67. {
    68.     thread_exit = 0;
    70.     while (!thread_exit)
    71.     {
    72.         SDL_Event event;
    73.         event.type = REFRESH_EVENT;
    74.         SDL_PushEvent(&event);
    75.         SDL_Delay(40);
    76.     }
    78.     thread_exit = 0;
    80.     //push quit event
    81.     SDL_Event event;
    82.     event.type = QUIT_EVENT;
    83.     SDL_PushEvent(&event);
    85.     return 0;
    86. }
    88. void VideoCapture::close_play()
    89. {
    90.     thread_exit = 1;
    91.     SDL_Event event;
    92.     event.type = QUIT_EVENT;
    93.     SDL_PushEvent(&event);
    94. }
    96. void VideoCapture::closeEvent(QCloseEvent *event)
    97. {
    98.     thread_exit = 1;
    99.     isplay = 0;
    100. }
    102. void VideoCapture::start_play()
    103. {
    104.     //使用ffmpeg -dshow采集视频
    105.     int ret = 0;
    106.     AVInputFormat *in_format = nullptr;
    107.     AVFormatContext* fmt_ctx = nullptr;
    108.     AVDictionary* options = nullptr;
    109.     char device_name[256] = "video=Integrated Webcam";
    110.     isplay = true;
    111.     SDL_Rect sdlRect;
    113.     //av_register_all();
    114.     avdevice_register_all();
    116.     in_format = av_find_input_format("dshow");
    117.     if (in_format == nullptr) {
    118.        std::cout<< "av_find_input_format error!" << std::endl;
    119.        //goto _END;
    120.     }
    122.     //设置采样参数
    123.     av_dict_set(&options, "video_size", "1280*720", 0);
    124.     av_dict_set(&options, "framerate", "10", 0);
    125.     av_dict_set(&options, "pixel_format", "yuyv422", 0);
    127.     if ((ret = avformat_open_input(&fmt_ctx, device_name, in_format, &options)) != 0) {
    128.         std::cout << "Failed to open video device,"  << ret << std::endl;
    129.         //goto _END;
    130.     }
    132.     AVPacket* pkt = av_packet_alloc();
    133.     av_init_packet(pkt);
    135.     //sdl初始化 ------------ start -------------
    136.     if (SDL_Init(SDL_INIT_VIDEO)) {
    137.         qDebug() << "Could not initialize SDL";
    138.         return;
    139.     }
    141.     SDL_Window* screen;
    142.     //SDL 2.0 Support for multiple windows
    143.     screen = SDL_CreateWindowFrom((void *)label->winId());
    144.     //screen = SDL_CreateWindow("Simplest Video Play SDL2", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
    145.     //    screen_w, screen_h, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
    146.     if (!screen) {
    147.         printf("SDL: could not create window - exiting:%s\n", SDL_GetError());
    148.         return;
    149.     }
    150.     SDL_Renderer* sdlRenderer = SDL_CreateRenderer(screen, -1, 0);
    152.     Uint32 pixformat = 0;
    153.     //IYUV: Y + U + V  (3 planes)
    154.     //YV12: Y + V + U  (3 planes)
    155.     pixformat = SDL_PIXELFORMAT_IYUV;
    157.     const int pixel_w = 1280, pixel_h = 720;
    158.     SDL_Texture* sdlTexture1 = SDL_CreateTexture(sdlRenderer, pixformat, SDL_TEXTUREACCESS_STREAMING, pixel_w, pixel_h);
    160.     //sdl初始化 ------------- end --------------
    162.     //图像格式转换------------------------------start----------------------
    163.     //图像转换参数
    164.     AVFrame* frame_yuyv422 = NULL;
    165.     AVFrame* frame_yuv420 = NULL;
    166.     struct SwsContext* img_convert_ctx = NULL;
    167.     AVPixelFormat in_pix_fmt = AV_PIX_FMT_YUYV422;
    168.     AVPixelFormat out_pix_fmt = AV_PIX_FMT_YUV420P;
    169.     static int sws_flags = SWS_BICUBIC; //差值算法,双三次
    171.     //创建avframe
    172.     frame_yuyv422 = create_frame(1280, 720, in_pix_fmt);
    173.     frame_yuv420 = create_frame(1280, 720, out_pix_fmt);
    175.     //设置转换context
    176.     if (img_convert_ctx == NULL)
    177.     {
    178.         img_convert_ctx = sws_getContext(1280, 720,
    179.             (AVPixelFormat)in_pix_fmt,
    180.             1280,
    181.             720,
    182.             (AVPixelFormat)out_pix_fmt,
    183.             sws_flags, NULL, NULL, NULL);
    184.         if (img_convert_ctx == NULL)
    185.         {
    186.             std::cout << "Cannot initialize the conversion context\n" << std::endl;
    187.         }
    188.     }
    189.     //图像格式转换------------------------------end----------------------
    191.     SDL_Event event;
    192.     SDL_Thread *timer_thread = NULL;
    193.     timer_thread = SDL_CreateThread(refresh_video_timer,
    194.                                     NULL,
    195.                                     NULL);
    197.     while (isplay) {
    198.         SDL_WaitEvent(&event);
    200.         if (event.type == REFRESH_EVENT){
    201.             while (!av_read_frame(fmt_ctx, pkt)) {
    202.                 printf("Size of collected data %d\n", pkt->size);
    204.                 // (宽*高)*（yuv420=1.5/yuv422=2/yuv444=3）
    205.                 //fwrite(pkt->data, 1, 1280 * 720 *2, out_file);
    207.                 int numBytes = avpicture_get_size(in_pix_fmt,1280,720);
    208.                 uint8_t *out_buffer = (uint8_t *) av_malloc(numBytes * sizeof(uint8_t));
    210.                 ret = avpicture_fill((AVPicture*)frame_yuv420, out_buffer, (AVPixelFormat)out_pix_fmt, 1280, 720);
    211.                 ret = avpicture_fill((AVPicture*)frame_yuyv422, (unsigned char*)pkt->data, (AVPixelFormat)in_pix_fmt, 1280, 720);
    212.                 std::cout << "avpicture_fill: " << ret << std::endl;
    213.     //            av_image_fill_arrays(frame_yuyv422->data, frame_yuyv422->linesize, pkt->data, in_pix_fmt, 1280, 720, 4);
    214.                 //yuyv422 -> yuv420p
    215.                 ret = sws_scale(img_convert_ctx, frame_yuyv422->data, frame_yuyv422->linesize,
    216.                     0, 720, frame_yuv420->data, frame_yuv420->linesize);
    217.                 std::cout << "sws_scale-ret:" << ret<< std::endl;
    220.                 //SDL_UpdateTexture(sdlTexture1, NULL, pkt->data, pixel_w);
    221.                 SDL_UpdateTexture(sdlTexture1, NULL, frame_yuv420->data[0], 1280);
    225.                 SDL_RenderClear(sdlRenderer);
    227.                 sdlRect.x = 0;
    228.                 sdlRect.y = 0;
    229.                 sdlRect.w = pixel_w;
    230.                 sdlRect.h = pixel_h;
    231.                 SDL_RenderCopy(sdlRenderer, sdlTexture1, NULL, &sdlRect);
    233.                 SDL_RenderPresent(sdlRenderer);
    234.                 //Delay 40ms
    235.                 SDL_Delay(40);
    236.                 std::cout << "delay 40ms" << std::endl;
    237.                 if (out_buffer)
    238.                     av_free(out_buffer);
    239.             }
    241.         } else if (event.type == SDL_WINDOWEVENT) {
    242.             //if resize
    243.             //SDL_GetWindowSize(window, &w_width, &w_height);
    244.         }
    245.         else if (event.type == SDL_QUIT) {
    246.             thread_exit = 1;
    247.         } else if (event.type == QUIT_EVENT) {
    248.             break;
    249.         }
    251.         SDL_DestroyTexture(sdlTexture1);
    252.         SDL_DestroyRenderer(sdlRenderer);
    253.         SDL_DestroyWindow(screen);
    254.         SDL_Quit();
    255.         av_packet_unref(pkt);
    256.     }
    258.  //_END:
    259.     if (pkt) {
    260.         av_packet_free(&pkt);
    261.         pkt = nullptr;
    262.     }
    263.     if (fmt_ctx) {
    264.         avformat_close_input(&fmt_ctx);
    265.         fmt_ctx = nullptr;
    266.     }
    268.     if (frame_yuyv422)
    269.     {
    270.         av_frame_free(&frame_yuyv422);
    271.         frame_yuyv422 = NULL;
    272.     }
    273.     if (frame_yuv420)
    274.     {
    275.         av_frame_free(&frame_yuv420);
    276.         frame_yuv420 = NULL;
    277.     }
    279.     SDL_DestroyRenderer(sdlRenderer);
    280.     SDL_DestroyWindow(screen);
    281.     SDL_Quit();
    283.     return;
    284. }