ping www.baidu.com
1.

sudo apt-get install xrdp
1.

pi@raspberrypi:~ $ sudo raspi-config
1.

1. pi@raspberrypi:~ $ sudo apt-get update
2. pi@raspberrypi:~ $ sudo apt-get install qt5-default
3. pi@raspberrypi:~ $ sudo apt-get install qtcreator
4. pi@raspberrypi:~ $ sudo apt-get install qtmultimedia5-dev
5. pi@raspberrypi:~ $ sudo apt-get install libqt5serialport5-dev
1.
2.
3.
4.
5.

sudo apt-get install libomxil-bellagio-dev
1.

mv /home/pi/Downloads/x264-master.tar.bz2 ./
tar xvf x264-master.tar.bz2 
cd x264-master/
./configure --prefix=$PWD/_install  --enable-shared
make && make install
sudo cp _install/include /usr/ -rf
sudo cp _install/lib /usr/ -rf
1.
2.
3.
4.
5.
6.
7.

[wbyq@wbyq ffmpeg-4.2.2]$ ./configure --enable-shared --prefix=$PWD/_install --enable-gpl --enable-libx264 --enable-omx-rpi --enable-mmal --enable-hwaccel=h264_mmal --enable-decoder=h264_mmal --enable-encoder=h264_omx --enable-omx
1.

[wbyq@wbyq ffmpeg-4.2.2]$ make && make install
1.

int VideoDecodThread::StartPlay()
{
    is_started = false;
    AVFormatContext *input_ctx = NULL;
    int video_stream, ret;
    AVStream *video = NULL;
    AVCodecContext *decoder_ctx = NULL;
    AVCodec *decoder = NULL;
    AVPacket packet;
    enum AVHWDeviceType type;
    int i;


    /*音频相关--------------------------开始*/

    AVFrame *PCM_pFrame = nullptr;

    int audio_stream_index = -1;
    AVCodec  *audio_pCodec= nullptr;

    #define MAX_AUDIO_FRAME_SIZE  192000

    //设置音频转码后输出相关参数
    //采样的布局方式
    uint64_t out_channel_layout = AV_CH_LAYOUT_MONO;
    //采样个数
    int out_nb_samples = 1024;
    //采样格式
    enum AVSampleFormat  sample_fmt = AV_SAMPLE_FMT_S16;
    //采样率
    int out_sample_rate = 44100;
    //通道数
    int out_channels;
    int audio_buffer_size;
    uint8_t *audio_buffer;
    int64_t in_channel_layout;
    struct SwrContext *audio_convert_ctx;

    /*音频相关--------------------------结束*/

/*
Hardware acceleration methods:
cuda
dxva2
qsv
d3d11va
qsv
cuvid
*/
    //1. 根据名称查找解码器的类型
    type = av_hwdevice_find_type_by_name(m_HardwareName.data());
    if (type == AV_HWDEVICE_TYPE_NONE)
    {
        fprintf(stderr, "Device type %s is not supported.\n",m_HardwareName.data());
        fprintf(stderr, "可用设备类型:");
        while((type = av_hwdevice_iterate_types(type)) != AV_HWDEVICE_TYPE_NONE)
            fprintf(stderr, " %s", av_hwdevice_get_type_name(type));
        fprintf(stderr, "\n");
        return -1;
    }

    //2. 打开多媒体流,并且获取一些信息
    if (avformat_open_input(&input_ctx,m_MediaFile, NULL, NULL) != 0)
    {
        fprintf(stderr, "无法打开输入文件 '%s'\n",m_MediaFile);
        return -1;
    }

    //3. 读取媒体文件的数据包以获取流信息
    if (avformat_find_stream_info(input_ctx, NULL) < 0)
    {
        fprintf(stderr, "找不到输入流信息.\n");
        return -1;
    }

    LogSend(tr("媒体中流的数量: %1\n").arg(input_ctx->nb_streams));
    for(int i = 0; i < input_ctx->nb_streams; ++i)
    {
        const AVStream* stream = input_ctx->streams[i];
        if(stream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
        {
            audio_stream_index = i;
            //查找解码器
            audio_pCodec=avcodec_find_decoder(stream->codecpar->codec_id);
            //打开解码器
            int err = avcodec_open2(stream->codec,audio_pCodec, nullptr);
            if(err!=0)
            {
                LogSend(tr("音频解码器打开失败.\n"));
                return 0;
            }
            else
            {
                //初始化音频解码相关的参数
                PCM_pFrame = av_frame_alloc();// 存放解码后PCM数据的缓冲区

                //创建packet,用于存储解码前音频的数据
                //packet = (AVPacket *)malloc(sizeof(AVPacket));
                //av_init_packet(packet);

                //通道数
                out_channels = av_get_channel_layout_nb_channels(out_channel_layout);
                //创建buffer
                audio_buffer_size = av_samples_get_buffer_size(nullptr, out_channels, out_nb_samples, sample_fmt, 1);
                //注意要用av_malloc
                audio_buffer = (uint8_t *)av_malloc(MAX_AUDIO_FRAME_SIZE * 2);

                in_channel_layout = av_get_default_channel_layout(input_ctx->streams[audio_stream_index]->codec->channels);
                //打开转码器
                audio_convert_ctx = swr_alloc();
                //设置转码参数
                audio_convert_ctx = swr_alloc_set_opts(audio_convert_ctx, out_channel_layout, sample_fmt, out_sample_rate, \
                                                 in_channel_layout, input_ctx->streams[audio_stream_index]->codec->sample_fmt, input_ctx->streams[audio_stream_index]->codec->sample_rate, 0, nullptr);
                //初始化转码器
                swr_init(audio_convert_ctx);
                qDebug()<<"音频流配置初始化完成...";

                //启动音频播放子线程
                audio_queue_data.clear_queue();
                m_AudioPlayThread.m_run=1;
                m_AudioPlayThread.start();
            }
            break;
        }
    }



    /* 查找视频流信息*/
    ret = av_find_best_stream(input_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &decoder, 0);
    if (ret < 0)
    {
        fprintf(stderr, "在输入文件中找不到视频流\n");
        return -1;
    }
    video_stream = ret;

    for (i = 0;; i++)
    {
        const AVCodecHWConfig *config = avcodec_get_hw_config(decoder, i);
        if (!config)
        {
            fprintf(stderr, "Decoder %s does not support device type %s.\n",
                    decoder->name, av_hwdevice_get_type_name(type));
            return -1;
        }
        if (config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX &&
            config->device_type == type)
        {
            hw_pix_fmt = config->pix_fmt;
            break;
        }
    }

    if (!(decoder_ctx = avcodec_alloc_context3(decoder)))
        return AVERROR(ENOMEM);


    video = input_ctx->streams[video_stream];
    if (avcodec_parameters_to_context(decoder_ctx, video->codecpar) < 0)
        return -1;

    //得到视频帧的宽高
    video_width=video->codecpar->width;
    video_height=video->codecpar->height;
    LogSend(tr("视频帧的尺寸(以像素为单位): (宽X高)%1x%2 像素格式: %3\n").arg(
        video->codecpar->width).arg(video->codecpar->height).arg(video->codecpar->format));


    decoder_ctx->get_format  = get_hw_format;

    if (hw_decoder_init(decoder_ctx, type) < 0)
    {
        qDebug()<<"硬件加速-解码器初始化失败...";
        return -1;
    }


    if ((ret = avcodec_open2(decoder_ctx, decoder, NULL)) < 0)
    {
        fprintf(stderr, "Failed to open codec for stream #%u\n", video_stream);
        return -1;
    }

    //计算图像所占字节大小
    int numBytes = avpicture_get_size(AV_PIX_FMT_NV12,video_width,video_height);
    out_buffer_NV12 = (uint8_t*)av_malloc(numBytes * sizeof(uint8_t));


    qDebug()<<"format_ctx->duration:"<<input_ctx->duration;

    /* 实际解码并转储原始数据 */
    //表示视频加载成功
    while(1)
    {
        m_AudioPlayThread.m_run=m_run;
        if(m_run==0)
        {
            break;
        }
        if(m_run == 2)
        {
            msleep(100); //暂停播放
            continue;
        }

        if (is_CurrentSeekPos)
        {
            is_CurrentSeekPos = 0;
            //偏移到指定位置再开始解码    AVSEEK_FLAG_BACKWARD 向后找最近的关键帧
            av_seek_frame(input_ctx, -1, m_n64CurrentSeekPos* AV_TIME_BASE, AVSEEK_FLAG_BACKWARD);
            qDebug()<<"跳转的位置:"<<m_n64CurrentSeekPos;
        }

        if ((ret = av_read_frame(input_ctx, &packet)) < 0)
            break;


        //如果当前一包数据是视频帧
        if (video_stream == packet.stream_index)
        {
            //等待音频同步,当音频队列里的数据包小于5的时候再继续解码
            while(audio_queue_data.get_queue_cnt()>5)
            {
                msleep(10);
            }

            //计算程序运行时间方法
            QTime timedebuge;//声明一个时钟对象
            timedebuge.start();//开始计时
            ret = decode_write(decoder_ctx, &packet);
            qDebug()<<"处理一帧总耗时："<<timedebuge.elapsed()<<"ms";//输出计时

            //当前时间
           video_clock = av_q2d(input_ctx->streams[video_stream]->time_base) * packet.pts;

           qDebug()<<"pkt.pts:"<<packet.pts<<"video_clock:"<<video_clock;
           //时间信号
           sig_getCurrentTime(video_clock, input_ctx->duration *1.0 / AV_TIME_BASE);

        }
        //如果是音频包
        else if(packet.stream_index == audio_stream_index)
        {
            if(audio_stream_index==-1)continue;

           //2. 发送帧
            if (avcodec_send_packet(input_ctx->streams[audio_stream_index]->codec,&packet) != 0)
            {
                av_packet_unref(&packet);//不成功就释放这个pkt
                continue;
            }

            //3. 解码帧
            if (avcodec_receive_frame(input_ctx->streams[audio_stream_index]->codec, PCM_pFrame) != 0)
            {
                av_packet_unref(&packet);//不成功就释放这个pkt
                continue;
            }

            //转码
            swr_convert(audio_convert_ctx, &audio_buffer, MAX_AUDIO_FRAME_SIZE, (const uint8_t **)PCM_pFrame->data, PCM_pFrame->nb_samples);

            //保存数据到队列
            struct AudioData audio_data;
            audio_data.audio_buffer=(uint8_t *)malloc(audio_buffer_size);
            audio_data.audio_buffer_size=audio_buffer_size;
            memcpy(audio_data.audio_buffer,audio_buffer,audio_buffer_size);
            audio_queue_data.write_queue(audio_data);

        }

       //释放
       av_packet_unref(&packet);
    }

    /* flush the decoder */
    packet.data = NULL;
    packet.size = 0;
    ret = decode_write(decoder_ctx, &packet);
    av_packet_unref(&packet);

    avcodec_free_context(&decoder_ctx);
    avformat_close_input(&input_ctx);
    av_buffer_unref(&hw_device_ctx);

    if(out_buffer_NV12)av_free(out_buffer_NV12);

    if(audio_stream_index!=-1)
    {
        av_free(audio_buffer);
        swr_free(&audio_convert_ctx);
        av_frame_free(&PCM_pFrame);
        m_AudioPlayThread.m_run=0;
        m_AudioPlayThread.quit();
        m_AudioPlayThread.wait();
    }

    LogSend("视频音频解码播放器的线程退出成功.\n");
    return 0;
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.
137.
138.
139.
140.
141.
142.
143.
144.
145.
146.
147.
148.
149.
150.
151.
152.
153.
154.
155.
156.
157.
158.
159.
160.
161.
162.
163.
164.
165.
166.
167.
168.
169.
170.
171.
172.
173.
174.
175.
176.
177.
178.
179.
180.
181.
182.
183.
184.
185.
186.
187.
188.
189.
190.
191.
192.
193.
194.
195.
196.
197.
198.
199.
200.
201.
202.
203.
204.
205.
206.
207.
208.
209.
210.
211.
212.
213.
214.
215.
216.
217.
218.
219.
220.
221.
222.
223.
224.
225.
226.
227.
228.
229.
230.
231.
232.
233.
234.
235.
236.
237.
238.
239.
240.
241.
242.
243.
244.
245.
246.
247.
248.
249.
250.
251.
252.
253.
254.
255.
256.
257.
258.
259.
260.
261.
262.
263.
264.
265.
266.
267.
268.
269.
270.
271.
272.
273.
274.
275.
276.
277.
278.
279.
280.
281.
282.
283.
284.
285.
286.
287.
288.
289.
290.
291.
292.
293.
294.
295.
296.
297.
298.
299.
300.
301.

int ffmpeg_dec()
{
    ffmpeg_laliu_run_flag=true;
    int video_width=0;
    int video_height=0;

    // Allocate an AVFormatContext
    AVFormatContext* format_ctx = avformat_alloc_context();
    format_ctx->interrupt_callback.callback = interrupt_cb; //--------注册回调函数

    // 打开rtsp：打开输入流并读取标题。 编解码器未打开
    QByteArray url =m_rtmp_addr.toUtf8();// "rtmp://193.112.142.152:8888/live/abcd";

    //打印ffmpge的版本
    LogSend(QString("FFMPEG版本: %1\n").arg(av_version_info()));

    LogSend(QString("拉流地址: %1\n").arg(m_rtmp_addr));
    int ret = -1;

    LogSend(QString("正在打开输入流并读取头信息.\n"));

    ret = avformat_open_input(&format_ctx, url.data(), nullptr, nullptr);
    if(ret != 0)
    {
        LogSend(QString("无法打开网址: %1, return value: %2 \n").arg(url.data()).arg(ret));

        qDebug()<<"m_rtmp_addr:"<<m_rtmp_addr;
        qDebug()<<"url:"<<url;
        qDebug()<<"rtmp_buff:"<<url.data();
        return -1;
    }

    LogSend(QString("正在读取媒体文件的数据包以获取流信息.\n"));

    // 读取媒体文件的数据包以获取流信息
    ret = avformat_find_stream_info(format_ctx, nullptr);
    if(ret < 0)
    {
        LogSend(tr("无法获取流信息: %1\n").arg(ret));
        return -1;
    }

    AVCodec  *video_pCodec;
    AVCodec  *audio_pCodec;
    // audio/video stream index
    int video_stream_index = -1;
    int audio_stream_index = -1;

    LogSend(tr("视频中流的数量: %1\n").arg(format_ctx->nb_streams));
    for(int i = 0; i < format_ctx->nb_streams; ++i)
    {
        const AVStream* stream = format_ctx->streams[i];
        LogSend(tr("编码数据的类型: %1\n").arg(stream->codecpar->codec_id));
        if(stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
        {
            //查找解码器
            video_pCodec=avcodec_find_decoder(stream->codecpar->codec_id);
            //打开解码器
            int err = avcodec_open2(stream->codec,video_pCodec, NULL);
            if(err!=0)
            {
                  LogSend(tr("H264解码器打开失败.\n"));
                  return 0;
            }
            video_stream_index = i;
            //得到视频帧的宽高
            video_width=stream->codecpar->width;
            video_height=stream->codecpar->height;

            LogSend(tr("视频帧的尺寸(以像素为单位): (宽X高)%1x%2 像素格式: %3\n").arg(
                stream->codecpar->width).arg(stream->codecpar->height).arg(stream->codecpar->format));
        }
        else if(stream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
        {
            audio_stream_index = i;
            qDebug()<<tr("音频样本格式: %1").arg(stream->codecpar->format);
            //查找解码器
            audio_pCodec=avcodec_find_decoder(stream->codecpar->codec_id);
            //打开解码器
            int err = avcodec_open2(stream->codec,audio_pCodec, nullptr);
            if(err!=0)
            {
                  LogSend(tr("AAC解码器打开失败.\n"));
                  return 0;
            }
        }
    }

    //初始化解码相关的参数
    AVFrame *yuv420p_pFrame = nullptr;
    AVFrame *PCM_pFrame = nullptr;
    AVPacket *packet;
    uint8_t *buffer;
    struct SwrContext *convert_ctx;
    int buffer_size;

    if (video_stream_index == -1)
    {
         LogSend("没有检测到视频流.\n");
         return -1;
    }
    else
    {
          yuv420p_pFrame = av_frame_alloc();// 存放解码后YUV数据的缓冲区
    }

    //申请存放yuv420p数据的空间
    yuv420p_data=new unsigned char[video_width*video_height*3/2];
    //申请存放rgb24数据的空间
    rgb24_data=new unsigned char[video_width*video_height*3];
    int y_size=video_width*video_height;

    AVPacket pkt;
    int re;

    LogSend("开始读取数据包...\n");
    while(ffmpeg_laliu_run_flag)
    {
        //读取一帧数据
        ret=av_read_frame(format_ctx, &pkt);
        if(ret < 0)
        {
            continue;
        }

        //得到视频包
        if(pkt.stream_index == video_stream_index)
        {
            //解码视频 frame
             re = avcodec_send_packet(format_ctx->streams[video_stream_index]->codec,&pkt);//发送视频帧
             if (re != 0)
             {
                 av_packet_unref(&pkt);//不成功就释放这个pkt
                 continue;
             }
             re = avcodec_receive_frame(format_ctx->streams[video_stream_index]->codec, yuv420p_pFrame);//接受后对视频帧进行解码
             if (re != 0)
             {
                 av_packet_unref(&pkt);//不成功就释放这个pkt
                 continue;
             }

            //将YUV数据拷贝到缓冲区
            memcpy(yuv420p_data,(const void *)yuv420p_pFrame->data[0],y_size);
            memcpy(yuv420p_data+y_size,(const void *)yuv420p_pFrame->data[1],y_size/4);
            memcpy(yuv420p_data+y_size+y_size/4,(const void *)yuv420p_pFrame->data[2],y_size/4);
            //将yuv420p转为RGB24格式
            YUV420P_to_RGB24(yuv420p_data,rgb24_data,video_width,video_height);
            //加载图片数据
            QImage image(rgb24_data,video_width,video_height,QImage::Format_RGB888);
            VideoDataOutput(image); //发送信号
        }
        av_packet_unref(&pkt);
    }

    avformat_close_input(&format_ctx);//释放解封装器的空间，以防空间被快速消耗完
    avformat_free_context(format_ctx);


    return 0;
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.
137.
138.
139.
140.
141.
142.
143.
144.
145.
146.
147.
148.
149.
150.
151.
152.
153.
154.
155.
156.
157.
158.
159.
160.
161.