devbox
代码探险家
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

FFMPEG音视频开发指南（一）_ffmpeg 开发

作者：代码探险家 | 2024-08-18 00:09:19

赞

踩

ffmpeg 开发

前言

FFmpeg是一款开源软件，用于生成处理多媒体数据的各类库和程序。FFmpeg可以转码、处理视频和图
片（调整视频、图片大小，去噪等）、打包、传输及播放视频。作为最受欢迎的视频和图像处理软件，
早已经被各行各业的不同公司所广泛使用。

当前文章内容分为3个部分。

  1. 安装ffmpeg，通过源码进行编译ffmpeg
  2. 介绍常用的命令行处理，视频转码、摄像头录制、摄像头推流、比如：推流到B站直播间。
  3. Ffmpeg代码开发案例：提供Linux多个代码案例可以直接运行，完成的功能与上面的命令一样。

开发环境介绍：

  1. linux操作系统： Red Hat 6.3
  2. FFMEG版本:   3.0.2
  3. 虚拟机:  VMware® Workstation 15 Pro
  4. USB摄像头：罗技C270i
  5. 笔记本自带摄像头：ThinkPad E480

一、安装X264编码器

1.1 安装Yasm库

在PC机Linux编译X264需要yasm库。

Yasm是一个完全重写的NASM汇编。它支持x86和AMD64指令集。

Yasm库的官网下载地址: Download - The Yasm Modular Assembler Project

配置编译:

  1. ./configure
  2. make
  3. make install

1.2 安装X264编码器

x264是一个免费软件 库和应用程序，用于将视频流编码为 H.264 / MPEG-4 AVC压缩格式，并根据GNU GPL的条款发布。

下载地址: x264, the best H.264/AVC encoder - VideoLAN

功能概述

(1)、提供一流的性能，压缩和功能。

(2)、实现出色的性能，在一台消费者级别的计算机上实时编码4个或更多1080p流。

(3)、提供最好的质量，具有最先进的心理视觉优化。

(4)、许多不同应用程序所必需的支持功能，例如电视广播，蓝光低延迟视频应用程序和Web视频。

(5)、x264构成了许多网络视频服务的核心，例如Youtube，Facebook，Vimeo和Hulu。它已被电视广播公司和ISP广泛使用。

编码器功能

(1)、8x8和4x4自适应空间变换

(2)、自适应B帧放置

(3)、B帧作为参考/任意帧顺序

(4)、CAVLC / CABAC熵编码

(5)、自定义量化矩阵

(6)、内部：所有宏块类型（具有所有预测的16x16、8x8、4x4和PCM）

(7)、Inter P：所有分区（从16x16到4x4）

(8)、Inter B：从16x16到8x8的分区（包括跳过/直接）

(9)、隔行扫描（MBAFF）

(10)、多个参考系

(11)、速率控制：恒定量化器，恒定质量，单通道或多通道ABR，可选VBV

(12)、场景切换检测

(13)、B帧中的时空直接模式，自适应模式选择

(14)、在多个CPU上并行编码

(15)、预测性无损模式

(16)、用于细节保留的Psy优化（自适应量化，psy-RD，psy-网格）

(17)、任意调整比特率分布的区域

X264库编译配置：

  1. [root@wbyq x264-snapshot-20160527-2245]# ./configure --prefix=$PWD/_install --enable-shared --enable-static
  2. [root@wbyq x264-snapshot-20160527-2245]# make install
  3. [root@wbyq x264-snapshot-20160527-2245]# cd _install/
  4. [root@wbyq _install]# tree
  5. .
  6. ├── bin
  7. │   └── x264
  8. ├── include
  9. │   ├── x264_config.h
  10. │   └── x264.h
  11. └── lib
  12.     ├── libx264.a
  13.     ├── libx264.so -> libx264.so.148
  14.     ├── libx264.so.148
  15.     └── pkgconfig
  16.         └── x264.pc
  17. 4 directories, 7 files

1.3 库的路径环境变量

为了方便ffmepg命令执行时，可以找到x264的动态库，可以将生成的动态库拷贝到/usr/lib目录下，或者将库路径加入到LD_LIBRARY_PATH 环境变量里。

二、安装FFMPEG库

2.1 FFMPEG介绍

FFmpeg是领先的多媒体框架，能够解码，编码， 转码，mux，demux，流，过滤和播放几乎所有内容。它支持最模糊的古代格式，直至最前沿。无论它们是由某些标准委员会，社区还是公司设计的。它还具有高度的可移植性：FFmpeg可在各种构建环境，机器体系结构和配置下，跨Linux，Mac OS X，Microsoft Windows，BSD，Solaris等编译，运行并通过我们的测试基础架构 FATE。

它包含可以由应用程序使用的libavcodec，libavutil，libavformat，libavfilter，libavdevice，libswscale和libswresample。与ffmpeg，ffplay和ffprobe一样，最终用户也可以使用它们进行转码和播放。

FFmpeg开发库：

(1)、libavutil是一个包含简化程序功能的库，其中包括随机数生成器，数据结构，数学例程，核心多媒体实用程序等。

(2)、libavcodec是一个库，其中包含音频/视频编解码器的解码器和编码器。

(3)、libavformat是一个包含用于多媒体容器格式的解复用器和复用器的库。

(4)、libavdevice是一个包含输入和输出设备的库，用于从许多常见的多媒体输入/输出软件框架（包Video4Linux，Video4Linux2，VfW和ALSA）中获取和呈现。

(5)、libavfilter是一个包含媒体过滤器的库。

(6)、libswscale是一个执行高度优化的图像缩放和颜色空间/像素格式转换操作的库。

(7)、libswresample是一个执行高度优化的音频重采样，重矩阵化和样本格式转换操作的库。

2.2 下载编译FFMPEG(3.0.2与4.2.2)

下载地址: https://ffmpeg.org/download.html

配置FFMPEG：

[root@wbyq ffmpeg-3.0.2]#./configure --enable-shared --enable-static --prefix=$PWD/_install --enable-gpl --extra-cflags=-I/home/wbyq/pc_work/x264-snapshot-20160527-2245/_install/include --extra-ldflags=-L/home/wbyq/pc_work/x264-snapshot-20160527-2245/_install/lib --enable-ffserver --enable-ffmpeg --enable-libx264

编译安装:

  1. [root@wbyq ffmpeg-3.0.2]# make
  2. [root@wbyq ffmpeg-3.0.2]# make install

FFMPEG最新版本4.2.2编译配置：

截止编写文档时，FFMPEG最新版本是4.2.2。

 图2-2-1

编译配置方法如下:

  1. [root@wbyq ffmpeg-4.2.2]# ./configure --enable-static --enable-shared --prefix=$PWD/_install --extra-cflags=-I/home/wbyq/pc_work/x264-snapshot-20160527-2245/_install/include --extra-ldflags=-L/home/wbyq/pc_work/x264-snapshot-20160527-2245/_install/lib --enable-ffmpeg --enable-libx264 --enable-gpl
  2. [root@wbyq ffmpeg-4.2.2]#make
  3. [root@wbyq ffmpeg-4.2.2]#make install

编译完成之后，将生成的动态库文件拷贝到/usr/lib目录下，可执行文件拷贝到/usr/bin目录下，方便后期调用。

  1. [root@wbyq /home/wbyq/pc_work/ffmpeg-3.0.2/_install/lib]# cp *.so* /usr/lib
  2. [root@wbyq /home/wbyq/pc_work/ffmpeg-3.0.2/_install/bin]# cp ffmpeg /usr/bin/

查看当前FFMPEG版本信息:

2.3 当前编译环境介绍

ffmpeg version 3.0.2 Copyright (c) 2000-2016 the FFmpeg developers

  built with gcc 4.4.6 (GCC) 20120305 (Red Hat 4.4.6-4)

  configuration: --enable-shared --enable-static --prefix=/home/wbyq/pc_work/ffmpeg-3.0.2/_install --enable-gpl --extra-cflags=-I/home/wbyq/pc_work/x264-snapshot-20160527-2245/_install/include --extra-ldflags=-L/home/wbyq/pc_work/x264-snapshot-20160527-2245/_install/lib --enable-ffserver --enable-ffmpeg --enable-libx264

  libavutil      55. 17.103 / 55. 17.103

  libavcodec     57. 24.102 / 57. 24.102

  libavformat    57. 25.100 / 57. 25.100

  libavdevice    57.  0.101 / 57.  0.101

  libavfilter     6. 31.100 /  6. 31.100

  libswscale      4.  0.100 /  4.  0.100

  libswresample   2.  0.101 /  2.  0.101

  libpostproc    54.  0.100 / 54.  0.100

linux操作系统： Red Hat 6.3

FFMEG版本:   3.0.2

虚拟机:  VMware® Workstation 15 Pro

USB摄像头：罗技C270i

笔记本自带摄像头：ThinkPad E480

三、ffmpeg命令行的常用用法(3.0.2)

3.1 ffmpeg命令介绍

Ffmpeg源码编译完成之后，会生成一个ffmpeg可执行文件。

ffmpeg是一个非常快速的视频和音频转换器，也可以从实时音频/视频源中获取。它还可以在任意采样率之间转换，并使用高质量的多相滤波器即时调整视频大小。

ffmpeg从该选项指定的任意数量的输入“文件”（可以是常规文件，管道，网络流，抓取设备等）中读取 -i，并写入任意数量的由以下参数指定的输出“文件”一个普通的输出网址。在命令行上找到的所有不能解释为选项的内容都被视为输出URL。

每个输入或输出URL原则上都可以包含任意数量的不同类型的流（视频/音频/字幕/附件/数据）。流的允许数量和/或类型可能会受到容器格式的限制。选择是从哪个输入流进入哪个输出，是自动完成还是通过-map选项进行选择（请参阅“流选择”一章）。

要在选项中引用输入文件，必须使用其索引（从0开始）。例如，第一个输入文件是0，第二个输入文件是，1等等。类似地，文件中的流由其索引引用。例如，2:3引用第三输入文件中的第四流。另请参阅“流说明符”一章。

通常，选项将应用于下一个指定的文件。因此，顺序很重要，您可以在命令行上多次使用相同的选项。然后，将每次出现都应用于下一个输入或输出文件。该规则的例外是全局选项（例如，详细级别），应首先指定。

不要混合输入文件和输出文件–首先指定所有输入文件，然后指定所有输出文件。也不要混用属于不同文件的选项。所有选项仅适用于下一个输入或输出文件，并且在文件之间重置。

3.2 使用ffmpeg命令推流视频文件到B站

先到B站注册账号，开通直播间，在右上角头像--个人中心进入直播间。

图3-1

图3-2

 

图3-3

 

图3-4

命令行执行命令:

  1. [root@wbyq ffmpeg-3.0.2]# ./ffmpeg -re -i "/mnt/hgfs/linux-share-dir/123.mp4" -c copy -vcodec libx264 -acodec aac -f flv "<你的rtmp地址><你的直播码>" 
  2.  
  3. 参数解析：
  4. -vcodec libx264 指定视频编码格式
  5. -acodec aac 指定音频编码格式
  6. 推流给B站的视频，一定要指定视频编码为x264，音频aac否则可能导致传递过去的视频无法播放，或者无法推流。
  7. 这里的rtmp地址和直播码，需要替换成自己B站的地址。
  8. -i 参数是指定视频源文件。
  9. 推流成功之后，在自己的直播间可以看到推流的视频。

 自己的直播间地址，在B站个人中心—我的直播间选项里可以看到。

图3-5

3.3 视频和音频单独抓取

如果指定输入格式和设备，则ffmpeg可以直接捕获视频和音频。

Linux下捕获摄像头的数据保存成视频文件:

  1. # ffmpeg -f video4linux2 -s 1280x720 -i /dev/video0 test.mp4
  2. 参数介绍:
  3. -s 指定摄像头输出的图像尺寸
  4. -i 摄像头的设备节点
  5. test.mp4 是保存的视频文件名称
  6. -f video4linux2是指定框架

Linux下捕获声卡的数据保存成音频文件：

  1. (1)# ffmpeg -f alsa -ac 2 -ar 44100 -i default out.wav
  2. 参数介绍:
  3. -i 指定声卡设备名称。这里default表示选择默认声卡。
  4. out.wav 捕获的音频数据保存的文件名称
  5. -f 是指定音频驱动类型。alsa是linux下音频驱动框架。 oss是另外一种音频框架。
  6. -ar <freq> 设置音频采样率,以HZ为单位
  7. -ac <channels> 设置音频通道数(单声道、双声道)
  8. (2)# ffmpeg -f alsa -ac 1 -ar 44100 -i default -t 30 out.wav
  9. 参数介绍:
  10. -t 30 表示录制30秒就自动停止
  11.  
  12. (3)# ffmpeg -f alsa -ac 1 -ar 16000 -i hw:0 -t 10 out.wav
  13. 参数介绍：
  14. 	这里的hw:0 也表示选择默认的声卡设备录音。

列出当前主机上的声卡设备：

  1. [root@wbyq linux-share-dir]# arecord -l   (列出声卡设备数量)
  2. **** List of CAPTURE Hardware Devices ****
  3. card 0: AudioPCI [Ensoniq AudioPCI], device 0: ES1371/1 [ES1371 DAC2/ADC]
  4.   Subdevices: 1/1
  5.   Subdevice #0: subdevice #0
  6. card 1: U0x46d0x825 [USB Device 0x46d:0x825], device 0: USB Audio [USB Audio]
  7.   Subdevices: 0/1
  8.   Subdevice #0: subdevice #0
  9.  
  10. [root@wbyq linux-share-dir]# arecord -L   (列出声卡设备详细信息)
  11. default
  12.     Default
  13. front:CARD=AudioPCI,DEV=0
  14.     Ensoniq AudioPCI, ES1371 DAC2/ADC
  15.     Front speakers
  16. surround40:CARD=AudioPCI,DEV=0
  17.     Ensoniq AudioPCI, ES1371 DAC2/ADC
  18.     4.0 Surround output to Front and Rear speakers
  19. iec958:CARD=AudioPCI,DEV=0
  20.     Ensoniq AudioPCI, ES1371 DAC2/ADC
  21.     IEC958 (S/PDIF) Digital Audio Output
  22. front:CARD=U0x46d0x825,DEV=0
  23.     USB Device 0x46d:0x825, USB Audio
  24.     Front speakers
  25. surround40:CARD=U0x46d0x825,DEV=0
  26.     USB Device 0x46d:0x825, USB Audio
  27.     4.0 Surround output to Front and Rear speakers
  28. surround41:CARD=U0x46d0x825,DEV=0
  29.     USB Device 0x46d:0x825, USB Audio
  30.     4.1 Surround output to Front, Rear and Subwoofer speakers
  31. surround50:CARD=U0x46d0x825,DEV=0
  32.     USB Device 0x46d:0x825, USB Audio
  33.     5.0 Surround output to Front, Center and Rear speakers
  34. surround51:CARD=U0x46d0x825,DEV=0
  35.     USB Device 0x46d:0x825, USB Audio
  36.     5.1 Surround output to Front, Center, Rear and Subwoofer speakers
  37. surround71:CARD=U0x46d0x825,DEV=0
  38.     USB Device 0x46d:0x825, USB Audio
  39.     7.1 Surround output to Front, Center, Side, Rear and Woofer speakers
  40. iec958:CARD=U0x46d0x825,DEV=0
  41.     USB Device 0x46d:0x825, USB Audio
  42.     IEC958 (S/PDIF) Digital Audio Output

使用arecord -L命令列出了声卡名字之后，就可以选择指定声卡录制声音，其中front:xxx 就是声卡的名字。

选择指定的声卡录制声音示例：

  1. (1). 选择USB摄像头的音频设备录音
  2. # ffmpeg -f alsa -ac 1 -ar 44100 -i front:CARD=U0x46d0x825,DEV=0 -t 10 out.wav
  3.  
  4. (2). 选择电脑自带的声卡录音
  5. # ffmpeg -f alsa -ac 1 -ar 44100 -i front:CARD=AudioPCI,DEV=0 -t 10 out.wav

FFMPEG录制音频的其他参数:

  1. # ffmpeg --help
  2. 音频选项：
  3. -aframes number 设置要输出的音频帧数
  4. -aq quality 设置音频质量（特定于编解码器）
  5. -ar rate 设置音频采样率（以Hz为单位）
  6. -ac channel 设置音频通道数
  7. -an 禁用音频
  8. -acodec codec 强制音频编解码器复制到流
  9. -vol volume   更改音频音量（256=正常）
  10. -af filter_graph 设置音频过滤器

3.4 录制带声音的视频

命令示例：

  1. #ffmpeg -f alsa -ac 1 -ar 44100 -i front:CARD=U0x46d0x825,DEV=0 -f video4linux2 -i /dev/video0 out.mpg
  2.  
  3. #ffmpeg -f alsa -ac 1 -ar 16000 -i front:CARD=U0x46d0x825,DEV=0 -f video4linux2 -i /dev/video0 out.mp4
  4. 录制MP4格式的视频时，音频采样率设置16000效果比较好一些。
  5. 采用MP4格式录制视频的详细信息(视频H264、音频AAC):
  6. Output #0, mp4, to 'out.mp4':
  7.   Metadata:
  8.     encoder         : Lavf57.25.100
  9.     Stream #0:0: Video: h264 (libx264) ([33][0][0][0] / 0x0021), yuv422p, 640x480, q=-1--1, 30 fps, 15360 tbn, 30 tbc
  10.     Metadata:
  11.       encoder         : Lavc57.24.102 libx264
  12.     Side data:
  13.       unknown side data type 10 (24 bytes)
  14.     Stream #0:1: Audio: aac (LC) ([64][0][0][0] / 0x0040), 16000 Hz, mono, fltp, 69 kb/s
  15.     Metadata:
  16.       encoder         : Lavc57.24.102 aac
  17. Stream mapping:
  18.   Stream #1:0 -> #0:0 (rawvideo (native) -> h264 (libx264))
  19.   Stream #0:0 -> #0:1 (pcm_s16le (native) -> aac (native))

采用MPG格式录制视频的详细信息(视频mpeg1video、音频mp2):

  1. Output #0, mpeg, to 'out.mpg':
  2.   Metadata:
  3.     encoder         : Lavf57.25.100
  4.     Stream #0:0: Video: mpeg1video, yuv420p, 640x480, q=2-31, 200 kb/s, 30 fps, 90k tbn, 30 tbc
  5.     Metadata:
  6.       encoder         : Lavc57.24.102 mpeg1video
  7.     Side data:
  8.       unknown side data type 10 (24 bytes)
  9.     Stream #0:1: Audio: mp2, 48000 Hz, mono, s16, 384 kb/s
  10.     Metadata:
  11.       encoder         : Lavc57.24.102 mp2
  12. Stream mapping:
  13.   Stream #1:0 -> #0:0 (rawvideo (native) -> mpeg1video (native))
  14.   Stream #0:0 -> #0:1 (pcm_s16le (native) -> mp2 (native))

3.5 视频与图片之间互转

视频转为图片:

  1. # ffmpeg -i 123.mp4 image_%d.jpg
  2. 将123.mp4的视频每一帧画面保存为一张张图片。

图片转为视频:

# ffmpeg -f image2 -i image_%d.jpg video.mpg

3.6 列出FFMPEG支持的编码器

  1. [root@wbyq ffmpeg_video]# ffmpeg -encoders
  2. ffmpeg version 4.2.2 Copyright (c) 2000-2019 the FFmpeg developers
  3.   built with gcc 4.4.6 (GCC) 20120305 (Red Hat 4.4.6-4)
  4.   configuration: --enable-static --enable-shared --prefix=/home/wbyq/pc_work/ffmpeg-4.2.2/_install --extra-cflags=-I/home/wbyq/pc_work/x264-snapshot-20160527-2245/_install/include --extra-ldflags=-L/home/wbyq/pc_work/x264-snapshot-20160527-2245/_install/lib --enable-ffmpeg --enable-libx264 --enable-gpl
  5.   libavutil      56. 31.100 / 56. 31.100
  6.   libavcodec     58. 54.100 / 58. 54.100
  7.   libavformat    58. 29.100 / 58. 29.100
  8.   libavdevice    58.  8.100 / 58.  8.100
  9.   libavfilter     7. 57.100 /  7. 57.100
  10.   libswscale      5.  5.100 /  5.  5.100
  11.   libswresample   3.  5.100 /  3.  5.100
  12.   libpostproc    55.  5.100 / 55.  5.100
  13. Encoders:
  14.  V..... = Video
  15.  A..... = Audio
  16.  S..... = Subtitle
  17.  .F.... = Frame-level multithreading
  18.  ..S... = Slice-level multithreading
  19.  ...X.. = Codec is experimental
  20.  ....B. = Supports draw_horiz_band
  21.  .....D = Supports direct rendering method 1
  22.  ------
  23.  V..... a64multi             Multicolor charset for Commodore 64 (codec a64_multi)
  24.  V..... a64multi5            Multicolor charset for Commodore 64, extended with 5th color (colram) (codec a64_multi5)
  25.  V..... alias_pix            Alias/Wavefront PIX image
  26.  V..... amv                  AMV Video
  27.  V..... apng                 APNG (Animated Portable Network Graphics) image
  28.  V..... asv1                 ASUS V1
  29.  V..... asv2                 ASUS V2
  30.  V..... avrp                 Avid 1:1 10-bit RGB Packer
  31.  V..X.. avui                 Avid Meridien Uncompressed
  32.  V..... ayuv                 Uncompressed packed MS 4:4:4:4
  33.  V..... bmp                  BMP (Windows and OS/2 bitmap)
  34.  V..... cinepak              Cinepak
  35.  V..... cljr                 Cirrus Logic AccuPak
  36.  V.S... vc2                  SMPTE VC-2 (codec dirac)
  37.  VFS... dnxhd                VC3/DNxHD
  38.  V..... dpx                  DPX (Digital Picture Exchange) image
  39.  VFS... dvvideo              DV (Digital Video)
  40.  V.S... ffv1                 FFmpeg video codec #1
  41.  VF.... ffvhuff              Huffyuv FFmpeg variant
  42.  V..... fits                 Flexible Image Transport System
  43.  V..... flashsv              Flash Screen Video
  44.  V..... flashsv2             Flash Screen Video Version 2
  45.  V..... flv                  FLV / Sorenson Spark / Sorenson H.263 (Flash Video) (codec flv1)
  46.  V..... gif                  GIF (Graphics Interchange Format)
  47.  V..... h261                 H.261
  48.  V..... h263                 H.263 / H.263-1996
  49.  V.S... h263p                H.263+ / H.263-1998 / H.263 version 2
  50.  V..... libx264              libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (codec h264)
  51.  V..... libx264rgb           libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 RGB (codec h264)
  52.  VF.... huffyuv              Huffyuv / HuffYUV
  53.  V..... jpeg2000             JPEG 2000
  54.  VF.... jpegls               JPEG-LS
  55.  VF.... ljpeg                Lossless JPEG
  56.  VF.... magicyuv             MagicYUV video
  57.  VFS... mjpeg                MJPEG (Motion JPEG)
  58.  V.S... mpeg1video           MPEG-1 video
  59.  V.S... mpeg2video           MPEG-2 video
  60.  V.S... mpeg4                MPEG-4 part 2
  61.  V..... msmpeg4v2            MPEG-4 part 2 Microsoft variant version 2
  62.  V..... msmpeg4              MPEG-4 part 2 Microsoft variant version 3 (codec msmpeg4v3)
  63.  V..... msvideo1             Microsoft Video-1
  64.  V..... pam                  PAM (Portable AnyMap) image
  65.  V..... pbm                  PBM (Portable BitMap) image
  66.  V..... pcx                  PC Paintbrush PCX image
  67.  V..... pgm                  PGM (Portable GrayMap) image
  68.  V..... pgmyuv               PGMYUV (Portable GrayMap YUV) image
  69.  VF.... png                  PNG (Portable Network Graphics) image
  70.  V..... ppm                  PPM (Portable PixelMap) image
  71.  VF.... prores               Apple ProRes
  72.  VF.... prores_aw            Apple ProRes (codec prores)
  73.  VFS... prores_ks            Apple ProRes (iCodec Pro) (codec prores)
  74.  V..... qtrle                QuickTime Animation (RLE) video
  75.  V..... r10k                 AJA Kona 10-bit RGB Codec
  76.  V..... r210                 Uncompressed RGB 10-bit
  77.  V..... rawvideo             raw video
  78.  V..... roqvideo             id RoQ video (codec roq)
  79.  V..... rv10                 RealVideo 1.0
  80.  V..... rv20                 RealVideo 2.0
  81.  V..... sgi                  SGI image
  82.  V..... snow                 Snow
  83.  V..... sunrast              Sun Rasterfile image
  84.  V..... svq1                 Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1
  85.  V..... targa                Truevision Targa image
  86.  VF.... tiff                 TIFF image
  87.  VF.... utvideo              Ut Video
  88.  V..... v210                 Uncompressed 4:2:2 10-bit
  89.  V..... v308                 Uncompressed packed 4:4:4
  90.  V..... v408                 Uncompressed packed QT 4:4:4:4
  91.  V..... v410                 Uncompressed 4:4:4 10-bit
  92.  V..... wmv1                 Windows Media Video 7
  93.  V..... wmv2                 Windows Media Video 8
  94.  V..... wrapped_avframe      AVFrame to AVPacket passthrough
  95.  V..... xbm                  XBM (X BitMap) image
  96.  V..... xface                X-face image
  97.  V..... xwd                  XWD (X Window Dump) image
  98.  V..... y41p                 Uncompressed YUV 4:1:1 12-bit
  99.  V..... yuv4                 Uncompressed packed 4:2:0
  100.  VF.... zlib                 LCL (LossLess Codec Library) ZLIB
  101.  V..... zmbv                 Zip Motion Blocks Video
  102.  A..... aac                  AAC (Advanced Audio Coding)
  103.  A..... ac3                  ATSC A/52A (AC-3)
  104.  A..... ac3_fixed            ATSC A/52A (AC-3) (codec ac3)
  105.  A..... adpcm_adx            SEGA CRI ADX ADPCM
  106.  A..... g722                 G.722 ADPCM (codec adpcm_g722)
  107.  A..... g726                 G.726 ADPCM (codec adpcm_g726)
  108.  A..... g726le               G.726 little endian ADPCM ("right-justified") (codec adpcm_g726le)
  109.  A..... adpcm_ima_qt         ADPCM IMA QuickTime
  110.  A..... adpcm_ima_wav        ADPCM IMA WAV
  111.  A..... adpcm_ms             ADPCM Microsoft
  112.  A..... adpcm_swf            ADPCM Shockwave Flash
  113.  A..... adpcm_yamaha         ADPCM Yamaha
  114.  A..... alac                 ALAC (Apple Lossless Audio Codec)
  115.  A..... aptx                 aptX (Audio Processing Technology for Bluetooth)
  116.  A..... aptx_hd              aptX HD (Audio Processing Technology for Bluetooth)
  117.  A..... comfortnoise         RFC 3389 comfort noise generator
  118.  A..X.. dca                  DCA (DTS Coherent Acoustics) (codec dts)
  119.  A..... eac3                 ATSC A/52 E-AC-3
  120.  A..... flac                 FLAC (Free Lossless Audio Codec)
  121.  A..... g723_1               G.723.1
  122.  A..X.. mlp                  MLP (Meridian Lossless Packing)
  123.  A..... mp2                  MP2 (MPEG audio layer 2)
  124.  A..... mp2fixed             MP2 fixed point (MPEG audio layer 2) (codec mp2)
  125.  A..... nellymoser           Nellymoser Asao
  126.  A..X.. opus                 Opus
  127.  A..... pcm_alaw             PCM A-law / G.711 A-law
  128.  A..... pcm_dvd              PCM signed 16|20|24-bit big-endian for DVD media
  129.  A..... pcm_f32be            PCM 32-bit floating point big-endian
  130.  A..... pcm_f32le            PCM 32-bit floating point little-endian
  131.  A..... pcm_f64be            PCM 64-bit floating point big-endian
  132.  A..... pcm_f64le            PCM 64-bit floating point little-endian
  133.  A..... pcm_mulaw            PCM mu-law / G.711 mu-law
  134.  A..... pcm_s16be            PCM signed 16-bit big-endian
  135.  A..... pcm_s16be_planar     PCM signed 16-bit big-endian planar
  136.  A..... pcm_s16le            PCM signed 16-bit little-endian
  137.  A..... pcm_s16le_planar     PCM signed 16-bit little-endian planar
  138.  A..... pcm_s24be            PCM signed 24-bit big-endian
  139.  A..... pcm_s24daud          PCM D-Cinema audio signed 24-bit
  140.  A..... pcm_s24le            PCM signed 24-bit little-endian
  141.  A..... pcm_s24le_planar     PCM signed 24-bit little-endian planar
  142.  A..... pcm_s32be            PCM signed 32-bit big-endian
  143.  A..... pcm_s32le            PCM signed 32-bit little-endian
  144.  A..... pcm_s32le_planar     PCM signed 32-bit little-endian planar
  145.  A..... pcm_s64be            PCM signed 64-bit big-endian
  146.  A..... pcm_s64le            PCM signed 64-bit little-endian
  147.  A..... pcm_s8               PCM signed 8-bit
  148.  A..... pcm_s8_planar        PCM signed 8-bit planar
  149.  A..... pcm_u16be            PCM unsigned 16-bit big-endian
  150.  A..... pcm_u16le            PCM unsigned 16-bit little-endian
  151.  A..... pcm_u24be            PCM unsigned 24-bit big-endian
  152.  A..... pcm_u24le            PCM unsigned 24-bit little-endian
  153.  A..... pcm_u32be            PCM unsigned 32-bit big-endian
  154.  A..... pcm_u32le            PCM unsigned 32-bit little-endian
  155.  A..... pcm_u8               PCM unsigned 8-bit
  156.  A..... pcm_vidc             PCM Archimedes VIDC
  157.  A..... real_144             RealAudio 1.0 (14.4K) (codec ra_144)
  158.  A..... roq_dpcm             id RoQ DPCM
  159.  A..X.. s302m                SMPTE 302M
  160.  A..... sbc                  SBC (low-complexity subband codec)
  161.  A..X.. sonic                Sonic
  162.  A..X.. sonicls              Sonic lossless
  163.  A..X.. truehd               TrueHD
  164.  A..... tta                  TTA (True Audio)
  165.  A..X.. vorbis               Vorbis
  166.  A..... wavpack              WavPack
  167.  A..... wmav1                Windows Media Audio 1
  168.  A..... wmav2                Windows Media Audio 2
  169.  S..... ssa                  ASS (Advanced SubStation Alpha) subtitle (codec ass)
  170.  S..... ass                  ASS (Advanced SubStation Alpha) subtitle
  171.  S..... dvbsub               DVB subtitles (codec dvb_subtitle)
  172.  S..... dvdsub               DVD subtitles (codec dvd_subtitle)
  173.  S..... mov_text             3GPP Timed Text subtitle
  174.  S..... srt                  SubRip subtitle (codec subrip)
  175.  S..... subrip               SubRip subtitle
  176.  S..... text                 Raw text subtitle
  177.  S..... webvtt               WebVTT subtitle
  178.  S..... xsub                 DivX subtitles (XSUB)

3.7 推流本地摄像头视频音频到流媒体服务器(4.2.2)

(1). 在红帽6.3系统上运行: 推流本地实时音频视频到流媒体服务器

示例：

  1. [wbyq@wbyq linux_c]$ ffmpeg -f video4linux2  -r 12 -s 640x480 -i /dev/video0 -f alsa -i default -ar 44100 -ac 1 -f mp3 -qscale 10 -f flv "rtmp://47.92.114.13:8086/live/123"
  2.  
  3. 参数解析：
  4. -f video4linux2 指定linux下的视频驱动框架
  5. -s 640x480  指定视频尺寸
  6. -i /dev/video0 摄像头节点
  7. f alsa 声卡驱动框架
  8. -i default  选择声卡，这里选择默认声卡
  9. -ar 44100  声音采样频率
  10. -ac 1   单声道
  11. -f mp3  MP3音频
  12. -qscale 10 设置画面质量，值越小画面质量越高
  13. f flv   指定封装格式
  14. "rtmp://47.92.114.13:8086/live/123"  流媒体服务器地址

(2). 推流同时保存视频到本地

示例:

  1. [wbyq@wbyq linux-share-dir]$ ffmpeg -thread_queue_size 128 -f video4linux2  -r 12 -s 1280x720 -i /dev/video0 -f alsa -i default -ar 44100 -ac 1 -f mp3 -qscale 5 -f flv "rtmp://47.92.114.13:8086/live/123" output.h264
  2.  
  3. 参数解析:
  4. 当这个任务消耗有点大时，-thread_queue_size 必须设置一个比较大的值，不然会看到 FFmpeg输出的日志信息中不停的提醒：[video4linux2,v4l2 @ 0x25fbc40] Thread message queue blocking; consider raising the thread_queue_size option (current value: 8)，拍摄到的视频也会出现莫名其妙的错误，比如帧率很高，无法正常播放，视频不流畅等等。把 -thread_queue_size 设置为一个比较大的值，直到看不到该提示即可。

下面截图是使用ffmpeg将本地摄像头和声卡的数据推流到自己搭建的流媒体服务器之后，再使用VLC软件拉流进行显示，也可以使用Mplayer播放器进行拉流显示。

Linux下搭建流媒体服务器：ginx+rtmp+ffmpeg 可以实现。

图3-7-1 windows下使用VLC软件拉流显示效果

 Mplayer命令拉流显示流媒体视频示例:

mplayer -framedrop rtmp://47.92.114.13:8086/live/123

图3-7-2 linux下使用Mplayer拉流显示效果

服务器也可以直接采用B站的服务器，直接在B站注册账号，实名认证，开通直播功能，获取直播地址，然后直接推流即可，步骤可以参考3.2小节。

示例代码：

  1. [wbyq@wbyq linux-share-dir]$ ffmpeg -thread_queue_size 128 -f video4linux2  -r 12 -s 1280x720 -i /dev/video0 -f alsa -i default -ar 44100 -ac 1 -f mp3 -qscale 5 -vcodec libx264 -acodec aac -f flv "rtmp://js.live-send.acg.tv/live-js/?streamname=live_68130189_71037877&key=b95d4cfda0c196518f104839fe5e7573"
  2.  
  3. 参数解析：
  4. vcodec libx264  指定视频编码为x264格式
  5. -acodec aac     指定音频编码为aac

 注意：推流到B站的实时视频，一定要指定视频编码为X264，音频为aac，否则推流过去可能会显示不出来。

图3-7-2

3.8 给推流视频添加水印

(1). 添加静态水印

 

  1. ffmpeg -re -i "/mnt/hgfs/linux-share-dir/Video_2020-01-18_1.wmv" -c copy -vcodec libx264 -acodec aac -vf drawtext="fontfile=arial.ttf:x=w-tw:fontcolor=red:fontsize=80:text='XiaoLong肖龙'" -f flv "rtmp://js.live-send.acg.tv/live-js/?streamname=live_68130189_71037877&key=b95d4cfda0c196518f104839fe5e7573"
  2.  
  3. 参数介绍：
  4. 上面黄色底色部分代码是添加水印的代码。
  5. fontcolor=red：设置颜色为红色
  6. fontsize=80    设置字体大小为80
  7. text='DS小龙哥' 设置显示的文本

 

(2). 添加动态时间水印

示例1: 在右上角添加时间水印

ffmpeg -re -i "/mnt/hgfs/linux-share-dir/Video_2020-01-18 1.wmv" -c copy -vcodec libx264 -acodec aac -vf drawtext="expansion=strftime:basetime=$(date +%s -d '2020-02-27 16:06:21'):fontfile=arial.ttf:x=w-tw:fontcolor=red:fontsize=30:text='%Y-%m-%d  %H\\:%M\\: %S" -f flv "rtmp://js.live-send.acg.tv/live-js/?streamname=live_68130189_71037877&key=b95d4cfda0c196518f104839fe5e7573"

示例2:

ffmpeg -re -i "/mnt/hgfs/linux-share-dir/Video_2020-01-18_贪吃蛇游戏制作_1.wmv" -c copy -vcodec libx264 -acodec aac -vf drawtext="expansion=strftime:basetime=$(date +%s -d '2020-02-27 16:06:21'):fontfile=arial.ttf:x=w-tw:fontcolor=red:fontsize=80:text='XiaoLong肖龙 %Y-%m-%d  %H\\:%M\\: %S" -f flv "rtmp://js.live-send.acg.tv/live-js/?streamname=live_68130189_71037877&key=b95d4cfda0c196518f104839fe5e7573"

四、ffmpeg代码开发示例

4.1 FFMPE采集摄像头数据保存(3.0.2版本)

FFmpeg中有一个和多媒体设备交互的类库：Libavdevice。

使用这个库可以读取电脑（或者其他设备上）的多媒体设备的数据或者输出数据到指定的多媒体设备上。

最简单的例子，调用Libavdevice库读取摄像头的一帧YUV数据，并保存成output.yuv文件。

Libavdevice支持以下设备作为输入端：

  1. alsa
  2. avfoundation
  3. bktr
  4. dshow
  5. dv1394
  6. fbdev
  7. gdigrab
  8. iec61883
  9. jack
  10. lavfi
  11. libcdio
  12. libdc1394
  13. openal
  14. oss
  15. pulse
  16. qtkit
  17. sndio
  18. video4linux2, v4l2
  19. vfwcap
  20. x11grab
  21. decklink

Libavdevice支持以下设备作为输出端：

  1. alsa
  2. caca
  3. decklink
  4. fbdev
  5. opengl
  6. oss
  7. pulse
  8. sdl
  9. sndio
  10. xv

示例代码： 采集一帧摄像头的数据，保存到本地

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include "libavcodec/avcodec.h"
  4. #include "libavformat/avformat.h"
  5. #include "libswscale/swscale.h"
  6. #include "libavdevice/avdevice.h"
  7.  
  8. int main(int argc, char* argv[])  
  9. {  
  10.     AVFormatContext *pFormatCtx;  
  11.     int             i, videoindex;  
  12.     AVCodecContext  *pCodecCtx;  
  13.     AVCodec         *pCodec;  
  14.       
  15.     av_register_all();  
  16.     avformat_network_init();  
  17.     pFormatCtx=avformat_alloc_context();  
  18.     
  19.     //注册设备 
  20.     avdevice_register_all();  
  21.       
  22.     //Linux  
  23.     AVInputFormat *ifmt=av_find_input_format("video4linux2");  
  24.     if(avformat_open_input(&pFormatCtx,"/dev/video0",ifmt,NULL)!=0)
  25.     {  
  26.         printf("无法打开输入流。/dev/video0\n");  
  27.         return -1;  
  28.     }
  29.     if(avformat_find_stream_info(pFormatCtx,NULL)<0)  
  30.     {  
  31.         printf("找不到流信息。\n");  
  32.         return -1;  
  33.     }  
  34.     videoindex=-1;  
  35.     for(i=0;i<pFormatCtx->nb_streams;i++)   
  36.     if(pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO)  
  37.     {  
  38.         videoindex=i;  
  39.         break;  
  40.     }
  41.     if(videoindex==-1)  
  42.     {  
  43.         printf("找不到视频流.\n");  
  44.         return -1;  
  45.     }  
  46.     pCodecCtx=pFormatCtx->streams[videoindex]->codec;  
  47.     pCodec=avcodec_find_decoder(pCodecCtx->codec_id);  
  48.     if(pCodec==NULL)  
  49.     {  
  50.         printf("找不到编解码器。\n");  
  51.         return -1;  
  52.     }  
  53.     if(avcodec_open2(pCodecCtx, pCodec,NULL)<0)  
  54.     {  
  55.         printf("无法打开编解码器。\n");  
  56.         return -1;  
  57.     }  
  58.     AVFrame *pFrame,*pFrameYUV;  
  59.     pFrame=av_frame_alloc();  
  60.     pFrameYUV=av_frame_alloc();  
  61.     unsigned char *out_buffer=(unsigned char *)av_malloc(av_image_get_buffer_size(AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height,16));   // avpicture_get_size
  62.     
  63.     av_image_fill_arrays((AVPicture *)pFrameYUV->data,(AVPicture *)pFrameYUV->linesize,out_buffer, AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height,16); 
  64.  
  65.     //根据获取摄像头的宽高和指定的像素格式420，分配空间
  66.     printf("摄像头尺寸：width=%d height=%d \n",pCodecCtx->width, pCodecCtx->height);  
  67.     int screen_w=0,screen_h=0;  
  68.     int ret, got_picture;  
  69.     AVPacket *packet=(AVPacket *)av_malloc(sizeof(AVPacket));  
  70.  
  71.     FILE *fp_yuv=fopen("output.yuv","wb+");      
  72.  
  73.     struct SwsContext *img_convert_ctx;  
  74.     img_convert_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height, AV_PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);   
  75.     //配置图像格式转换以及缩放参数
  76.     if(av_read_frame(pFormatCtx, packet)>=0)
  77.     {  
  78.         //输出图像的大小
  79.         printf("数据大小=%d\n",packet->size);
  80.         //将数据写入文件
  81.         if(packet->stream_index==videoindex)
  82.         {  
  83.             ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, packet);  //解码从摄像头获取的数据，pframe结构
  84.             if(ret < 0)
  85.             {  
  86.                 printf("解码Error.\n");  
  87.                 return -1;  
  88.             }  
  89.             if(got_picture)
  90.             {  
  91.                 sws_scale(img_convert_ctx,(const unsigned char* const*)pFrame->data, pFrame->linesize, 0, pCodecCtx->height, pFrameYUV->data, pFrameYUV->linesize);  //根据前面配置的缩放参数，进行图像格式转换以及缩放等操作
  92.                 int y_size=pCodecCtx->width*pCodecCtx->height;  
  93.                 
  94.                 fwrite(pFrameYUV->data[0],1,y_size,fp_yuv);    //Y     
  95.                 fwrite(pFrameYUV->data[1],1,y_size/4,fp_yuv);  //U    
  96.                 fwrite(pFrameYUV->data[2],1,y_size/4,fp_yuv);  //V    
  97.             }  
  98.         }  
  99.         av_packet_unref(packet);       
  100.     }  
  101.     sws_freeContext(img_convert_ctx);  
  102.     fclose(fp_yuv);  
  103.     av_free(out_buffer);  
  104.     av_free(pFrameYUV);  
  105.     avcodec_close(pCodecCtx);  
  106.     avformat_close_input(&pFormatCtx);  
  107.     return 0;  
  108. }

Makefile文件代码：

  1. app:
  2. gcc ffmpeg_video.c -I /home/wbyq/pc_work/ffmpeg-3.0.2/_install/include -L /home/wbyq/pc_work/ffmpeg-3.0.2/_install/lib -lavcodec -lavfilter -lavutil -lswresample -lavdevice -lavformat -lpostproc -lswscale

编译运行代码示例:

  1. [wbyq@wbyq ffmpeg_video]$ make
  2. gcc -o app ffmpeg_video.c -I /home/wbyq/pc_work/ffmpeg-3.0.2/_install/include -L /home/wbyq/pc_work/ffmpeg-3.0.2/_install/lib -lavcodec -lavfilter -lavutil -lswresample -lavdevice -lavformat -lpostproc -lswscale -lm -L/home/wbyq/pc_work/x264-snapshot-20160527-2245/_install/lib -lx264
  3. [wbyq@wbyq ffmpeg_video]$ ./app 
  4. 摄像头尺寸：width=640 height=480 
  5. 数据大小=614400

说明：

如果使用其他版本的FFMPEG编译本代码，出现如下警告：不建议使用‘xxxxxx’(声明于 xxxxx:xxx),

直接打开当前使用的FFMPEG源码，找到推荐的函数，替换旧函数即可

由于保存的图片是YUV格式，不能使用常规图片软件查看，windows下可以下载“7yuv”软件进行查看。

7yuv是一种方便的工具，用于编辑和可视化原始图形数据和二进制文件。它是辅助开发游戏，视频编解码器和常规图形编程的宝贵工具。 支持多种表面格式，包括RGB和YUV像素格式。 7yuv打开任何文件，无论类型或大小。数据以原始二进制格式处理，7yuv允许“位真编辑”。可以在图形，十六进制或文本模式下编辑数据。

图4-1-1

4.2 FFMPEG读取摄像头数据并编码保存视频(4.2.2版本)

常见的视频封装器与编码器的对应关系：

图4-2-1

使用FFMPEG命令捕获摄像头数据录制成视频：

  1. [wbyq@wbyq ffmpeg_video]$ ffmpeg -f video4linux2 -s 1280x720 -i /dev/video0 -vcodec libx264 -f flv test.flv
  2. 参数解析:
  3. -f <flv> 指定封装器名称。指定了封装器，不管文件后缀是什么，都会采用指定的封装器来封装文件。
  4. -vcodec <libx264> 指定编码器 
  5. -i </dev/video0>  指定摄像头设备的节点
  6. -f <video4linux2> 指定设备类型
  7. -s <1280x720>     指定图像的尺寸

下面代码，参考源码/doc/example/muxing.c例子，采集摄像头一帧帧YUV数据，经过编码，封装成并保存成视频文件。

示例代码：

  1. #include <stdlib.h>  
  2. #include <stdio.h>  
  3. #include <string.h>  
  4. #include <math.h>  
  5. #include <libavutil/avassert.h>  
  6. #include <libavutil/channel_layout.h>  
  7. #include <libavutil/opt.h>  
  8. #include <libavutil/mathematics.h>  
  9. #include <libavutil/timestamp.h>  
  10. #include <libavformat/avformat.h>  
  11. #include <libswscale/swscale.h>  
  12. #include <libswresample/swresample.h>  
  13.  
  14. #define STREAM_DURATION   50.0 /*录制视频的持续时间  秒*/
  15. #define STREAM_FRAME_RATE 5     /* images/s  这里可以根据摄像头的采集速度来设置帧率 */
  16. #define STREAM_PIX_FMT    AV_PIX_FMT_YUV420P /* default pix_fmt */  
  17. #define SCALE_FLAGS SWS_BICUBIC  
  18.  
  19. //存放视频的宽度和高度
  20. int video_width;
  21. int video_height;
  22.  
  23. // 单个输出AVStream的包装器 
  24. typedef struct OutputStream
  25. {  
  26.     AVStream *st;  
  27.     AVCodecContext *enc;  
  28.     /*下一帧的点数*/  
  29.     int64_t next_pts;  
  30.     int samples_count;  
  31.     AVFrame *frame;  
  32.     AVFrame *tmp_frame;  
  33.     float t, tincr, tincr2;  
  34.     struct SwsContext *sws_ctx;  
  35.     struct SwrContext *swr_ctx;  
  36. }OutputStream;  
  37.  
  38. typedef struct IntputDev
  39. {  
  40.     AVCodecContext  *pCodecCtx;  
  41.     AVCodec         *pCodec;  
  42.     AVFormatContext *v_ifmtCtx;  
  43.     int  videoindex;  
  44.     struct SwsContext *img_convert_ctx;  
  45.     AVPacket *in_packet;  
  46.     AVFrame *pFrame,*pFrameYUV;  
  47. }IntputDev;  
  48.  
  49. static void log_packet(const AVFormatContext *fmt_ctx, const AVPacket *pkt)  
  50. {  
  51.     AVRational *time_base = &fmt_ctx->streams[pkt->stream_index]->time_base;  
  52.     printf("pts:%s pts_time:%s dts:%s dts_time:%s duration:%s duration_time:%s stream_index:%d\n",  
  53.            av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, time_base),  
  54.            av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, time_base),  
  55.            av_ts2str(pkt->duration), av_ts2timestr(pkt->duration, time_base),  
  56.            pkt->stream_index);  
  57. }  
  58.  
  59. static int write_frame(AVFormatContext *fmt_ctx, const AVRational *time_base, AVStream *st, AVPacket *pkt)  
  60. {  
  61.     /* 将输出数据包时间戳值从编解码器重新调整为流时基 */  
  62.     av_packet_rescale_ts(pkt, *time_base, st->time_base);  
  63.     pkt->stream_index = st->index;  
  64.  
  65.     /*将压缩的帧写入媒体文件。*/  
  66.     log_packet(fmt_ctx, pkt);  
  67.     return av_interleaved_write_frame(fmt_ctx, pkt);  
  68. }  
  69.  
  70. /*添加输出流。 */  
  71. static void add_stream(OutputStream *ost, AVFormatContext *oc,AVCodec **codec,enum AVCodecID codec_id)  
  72. {  
  73.     AVCodecContext *c;  
  74.     int i;  
  75.     /* find the encoder */ 
  76.  
  77.     *codec = avcodec_find_encoder(codec_id);  
  78.     if (!(*codec))
  79.     {  
  80.         fprintf(stderr, "Could not find encoder for '%s'\n",  
  81.                 avcodec_get_name(codec_id));  
  82.         exit(1);  
  83.     }  
  84.     ost->st = avformat_new_stream(oc, NULL);  
  85.  
  86.     if (!ost->st) {  
  87.         fprintf(stderr, "Could not allocate stream\n");  
  88.         exit(1);  
  89.     }  
  90.     ost->st->id = oc->nb_streams-1;  
  91.     c = avcodec_alloc_context3(*codec);  
  92.     if (!c) {  
  93.         fprintf(stderr, "Could not alloc an encoding context\n");  
  94.         exit(1);  
  95.     }  
  96.     ost->enc = c;   
  97.     switch((*codec)->type)
  98.     {  
  99.         case AVMEDIA_TYPE_AUDIO:  
  100.             c->sample_fmt  = (*codec)->sample_fmts ?  
  101.                 (*codec)->sample_fmts[0] : AV_SAMPLE_FMT_FLTP;  
  102.             c->bit_rate    = 64000;  
  103.             c->sample_rate = 44100;  
  104.             if ((*codec)->supported_samplerates) {  
  105.                 c->sample_rate = (*codec)->supported_samplerates[0];  
  106.                 for (i = 0; (*codec)->supported_samplerates[i]; i++) {  
  107.                     if ((*codec)->supported_samplerates[i] == 44100)  
  108.                         c->sample_rate = 44100;  
  109.                 }  
  110.             }  
  111.             c->channels        = av_get_channel_layout_nb_channels(c->channel_layout);  
  112.             c->channel_layout = AV_CH_LAYOUT_STEREO;  
  113.             if ((*codec)->channel_layouts) {  
  114.                 c->channel_layout = (*codec)->channel_layouts[0];  
  115.                 for (i = 0; (*codec)->channel_layouts[i]; i++) {  
  116.                     if ((*codec)->channel_layouts[i] == AV_CH_LAYOUT_STEREO)  
  117.                         c->channel_layout = AV_CH_LAYOUT_STEREO;  
  118.                 }  
  119.             }  
  120.             c->channels        = av_get_channel_layout_nb_channels(c->channel_layout);  
  121.             ost->st->time_base = (AVRational){ 1, c->sample_rate };  
  122.             break;  
  123.       
  124.         case AVMEDIA_TYPE_VIDEO:  
  125.             c->codec_id = codec_id;  
  126.             c->bit_rate = 2500000;  //平均比特率,例子代码默认值是400000
  127.             /* 分辨率必须是2的倍数。*/  
  128.             c->width=video_width;  
  129.             c->height=video_height;  
  130.             /*时基：这是基本的时间单位（以秒为单位）
  131.              *表示其中的帧时间戳。 对于固定fps内容，
  132.              *时基应为1 /framerate，时间戳增量应为
  133.              *等于1。*/  
  134.             ost->st->time_base = (AVRational){1,STREAM_FRAME_RATE};  //帧率设置
  135.             c->time_base       = ost->st->time_base;  
  136.             c->gop_size      = 12; /* 最多每十二帧发射一帧内帧 */  
  137.             c->pix_fmt       = STREAM_PIX_FMT;  
  138.             if(c->codec_id == AV_CODEC_ID_MPEG2VIDEO)
  139.             {  
  140.                 /* 只是为了测试，我们还添加了B帧 */  
  141.                 c->max_b_frames = 2;  
  142.             }  
  143.             if(c->codec_id == AV_CODEC_ID_MPEG1VIDEO)
  144.             {  
  145.                 /*需要避免使用其中一些系数溢出的宏块。
  146.                  *普通视频不会发生这种情况，因为
  147.                  *色度平面的运动与亮度平面不匹配。 */ 
  148.                 c->mb_decision = 2;  
  149.             }   
  150.         break;  
  151.       
  152.         default:  
  153.             break;  
  154.     }  
  155.   
  156.     /* 某些格式希望流头分开。 */  
  157.     if (oc->oformat->flags & AVFMT_GLOBALHEADER)  
  158.         c->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;    
  159. }  
  160.  
  161. static AVFrame *alloc_picture(enum AVPixelFormat pix_fmt, int width, int height)  
  162. {  
  163.     AVFrame *picture;  
  164.     int ret;  
  165.     picture = av_frame_alloc();  
  166.     if (!picture)  
  167.         return NULL;  
  168.     picture->format = pix_fmt;  
  169.     picture->width  = width;  
  170.     picture->height = height;  
  171.   
  172.     /* 为帧数据分配缓冲区 */  
  173.     ret = av_frame_get_buffer(picture, 32);  
  174.     if(ret<0)
  175.     {  
  176.         fprintf(stderr, "Could not allocate frame data.\n");  
  177.         exit(1);  
  178.     }  
  179.     return picture;  
  180. }  
  181.   
  182. static void open_video(AVFormatContext *oc, AVCodec *codec, OutputStream *ost, AVDictionary *opt_arg)  
  183. {  
  184.     int ret;  
  185.     AVCodecContext *c = ost->enc;  
  186.     AVDictionary *opt = NULL;  
  187.   
  188.     av_dict_copy(&opt, opt_arg, 0);  
  189.   
  190.     /* open the codec */  
  191.     ret = avcodec_open2(c, codec, &opt);  
  192.     av_dict_free(&opt);  
  193.     if (ret < 0)
  194.     {  
  195.         fprintf(stderr, "Could not open video codec: %s\n", av_err2str(ret));  
  196.         exit(1);  
  197.     }  
  198.   
  199.     /* 分配并初始化可重用框架 */  
  200.     ost->frame = alloc_picture(c->pix_fmt, c->width, c->height);  
  201.     if (!ost->frame)
  202.     {  
  203.         fprintf(stderr, "Could not allocate video frame\n");  
  204.         exit(1);  
  205.     }  
  206.     printf("ost->frame alloc success fmt=%d w=%d h=%d\n",c->pix_fmt,c->width, c->height);  
  207.   
  208.   
  209.     /*如果输出格式不是YUV420P，则为临时YUV420P
  210.     *也需要图片。 然后将其转换为所需的
  211.     *输出格式。 */
  212.     ost->tmp_frame = NULL;  
  213.     if(c->pix_fmt != AV_PIX_FMT_YUV420P)
  214.     {  
  215.         ost->tmp_frame = alloc_picture(AV_PIX_FMT_YUV420P, c->width, c->height);  
  216.         if (!ost->tmp_frame)
  217.         {  
  218.             fprintf(stderr, "Could not allocate temporary picture\n");  
  219.             exit(1);  
  220.         }  
  221.     }  
  222.   
  223.     /* 将流参数复制到多路复用器*/  
  224.     ret=avcodec_parameters_from_context(ost->st->codecpar, c);  
  225.     if(ret<0)
  226.     {  
  227.         fprintf(stderr, "Could not copy the stream parameters\n");  
  228.         exit(1);  
  229.     }  
  230. }
  231.  
  232. /*
  233.   *编码一个视频帧
  234.   *编码完成后返回1，否则返回0
  235.   */  
  236. static int write_video_frame(AVFormatContext *oc, OutputStream *ost,AVFrame *frame)  
  237. {  
  238.     int ret;  
  239.     AVCodecContext *c;  
  240.     int got_packet=0;  
  241.     AVPacket pkt={0};  
  242.     if(frame==NULL)  
  243.         return 1;  
  244.     c = ost->enc;  
  245.     av_init_packet(&pkt);  
  246.     /* 编码图像*/  
  247.     ret = avcodec_encode_video2(c, &pkt, frame, &got_packet);  
  248.     if(ret<0)
  249.     {  
  250.         fprintf(stderr, "Error encoding video frame: %s\n", av_err2str(ret));  
  251.         exit(1);  
  252.     }  
  253.     printf("--------------video- pkt.pts=%s\n",av_ts2str(pkt.pts));  
  254.     printf("----st.num=%d st.den=%d codec.num=%d codec.den=%d---------\n",ost->st->time_base.num,ost->st->time_base.den,  
  255.             c->time_base.num,c->time_base.den);         
  256.     if(got_packet)
  257.     {  
  258.         ret = write_frame(oc, &c->time_base, ost->st, &pkt);  
  259.     }else
  260.     {  
  261.         ret = 0;  
  262.     }  
  263.     if(ret<0)
  264.     {  
  265.         fprintf(stderr, "Error while writing video frame: %s\n", av_err2str(ret));  
  266.         exit(1);  
  267.     }  
  268.     return (frame || got_packet) ? 0 : 1;  
  269. }  
  270.   
  271.   
  272. static AVFrame *get_video_frame(OutputStream *ost,IntputDev* input,int *got_pic)  
  273. {  
  274.     int ret, got_picture;  
  275.     AVCodecContext *c = ost->enc;  
  276.     AVFrame * ret_frame=NULL;  
  277.     if(av_compare_ts(ost->next_pts, c->time_base,STREAM_DURATION, (AVRational){1,1})>=0)  
  278.         return NULL;  
  279.   
  280.     /*当我们将帧传递给编码器时，它可能会保留对它的引用
  281.     *内部,确保我们在这里不覆盖它*/
  282.     if (av_frame_make_writable(ost->frame)<0)  
  283.         exit(1);  
  284.     if(av_read_frame(input->v_ifmtCtx, input->in_packet)>=0)
  285.     {  
  286.         if(input->in_packet->stream_index==input->videoindex)
  287.         {  
  288.             ret = avcodec_decode_video2(input->pCodecCtx, input->pFrame, &got_picture, input->in_packet);  
  289.             *got_pic=got_picture;  
  290.             if(ret<0)
  291.             {  
  292.                 printf("Decode Error.\n");  
  293.                 av_packet_unref(input->in_packet);  
  294.                 return NULL;  
  295.             }  
  296.             if(got_picture)
  297.             {  
  298.                 sws_scale(input->img_convert_ctx, (const unsigned char* const*)input->pFrame->data, input->pFrame->linesize, 0, input->pCodecCtx->height, ost->frame->data,  ost->frame->linesize);  
  299.                 ost->frame->pts =ost->next_pts++;  
  300.                 ret_frame= ost->frame;    
  301.             }  
  302.         }  
  303.         av_packet_unref(input->in_packet);  
  304.     }  
  305.     return ret_frame;  
  306. }  
  307. static void close_stream(AVFormatContext *oc, OutputStream *ost)  
  308. {  
  309.     avcodec_free_context(&ost->enc);  
  310.     av_frame_free(&ost->frame);  
  311.     av_frame_free(&ost->tmp_frame);  
  312.     sws_freeContext(ost->sws_ctx);  
  313.     swr_free(&ost->swr_ctx);  
  314. }  
  315.  
  316. /*
  317. 采集摄像头数据编码成MP4视频
  318. */  
  319. int main(int argc, char **argv)  
  320. {  
  321.     OutputStream video_st = { 0 }, audio_st = { 0 };  
  322.     const char *filename;  
  323.     AVOutputFormat *fmt;  
  324.     AVFormatContext *oc;  
  325.     AVCodec *audio_codec, *video_codec;  
  326.     int ret;  
  327.     int have_video = 0, have_audio = 0;  
  328.     int encode_video = 0, encode_audio = 0;  
  329.     AVDictionary *opt = NULL;  
  330.     int i;  
  331.   
  332.     if(argc<3)
  333.     {  
  334.         //./app /dev/video0 123.mp4
  335.         printf("用法: %s <摄像头设备节点> <文件名称> \n", argv[0]);  
  336.         return 1;  
  337.     }  
  338.   
  339.     filename = argv[2];  
  340.     printf("当前存储的视频文件名称:%s\n",filename);
  341.     /*分配输出媒体环境*/
  342.     avformat_alloc_output_context2(&oc, NULL, NULL, filename);  
  343.     if(!oc)
  344.     {  
  345.         printf("无法从文件扩展名推断出输出格式：使用MPEG。\n");  
  346.         avformat_alloc_output_context2(&oc, NULL, "mpeg", filename);  
  347.     }  
  348.     if(!oc)return 1;  
  349.     //添加摄像头----------------------------------
  350.     IntputDev video_input={0};  
  351.     AVCodecContext  *pCodecCtx;  
  352.     AVCodec         *pCodec;  
  353.     AVFormatContext *v_ifmtCtx;  
  354.     avdevice_register_all();  
  355.     v_ifmtCtx = avformat_alloc_context();  
  356.     //Linux下指定摄像头信息  
  357.     AVInputFormat *ifmt=av_find_input_format("video4linux2");  
  358.     if(avformat_open_input(&v_ifmtCtx,argv[1],ifmt,NULL)!=0)
  359.     {  
  360.         printf("无法打开输入流.%s\n",argv[1]);  
  361.         return -1;  
  362.     }
  363.     if(avformat_find_stream_info(v_ifmtCtx,NULL)<0)  
  364.     {  
  365.         printf("找不到流信息.\n");  
  366.         return -1;  
  367.     }
  368.     int videoindex=-1;  
  369.     for(i=0; i<v_ifmtCtx->nb_streams; i++)   
  370.     if(v_ifmtCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO)  
  371.     {  
  372.         videoindex=i;  
  373.         printf("videoindex=%d\n",videoindex);
  374.         break;  
  375.     }
  376.     if(videoindex==-1)  
  377.     {  
  378.         printf("找不到视频流。\n");  
  379.         return -1;  
  380.     }  
  381.     pCodecCtx=v_ifmtCtx->streams[videoindex]->codec; 
  382.     pCodec=avcodec_find_decoder(pCodecCtx->codec_id);  
  383.     if(pCodec==NULL)  
  384.     {  
  385.         printf("找不到编解码器。\n");  
  386.         return -1;  
  387.     }  
  388.     if(avcodec_open2(pCodecCtx, pCodec,NULL)<0)  
  389.     {  
  390.         printf("无法打开编解码器。\n");  
  391.         return -1;  
  392.     }  
  393.   
  394.     AVFrame *pFrame,*pFrameYUV;  
  395.     pFrame=av_frame_alloc();  
  396.     pFrameYUV=av_frame_alloc();
  397.     
  398.     unsigned char *out_buffer=(unsigned char *)av_malloc(av_image_get_buffer_size(AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height,16));  
  399.     av_image_fill_arrays((AVPicture *)pFrameYUV->data,(AVPicture *)pFrameYUV->linesize, out_buffer, AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height,16);  
  400.     printf("摄像头尺寸(WxH): %d x %d \n",pCodecCtx->width, pCodecCtx->height);  
  401.     video_width=pCodecCtx->width;
  402.     video_height=pCodecCtx->height;
  403.     struct SwsContext *img_convert_ctx;  
  404.     img_convert_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height, AV_PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);   
  405.     AVPacket *in_packet=(AVPacket *)av_malloc(sizeof(AVPacket));  
  406.     video_input.img_convert_ctx=img_convert_ctx;  
  407.     video_input.in_packet=in_packet;  
  408.     video_input.pCodecCtx=pCodecCtx;  
  409.     video_input.pCodec=pCodec;  
  410.     video_input.v_ifmtCtx=v_ifmtCtx;  
  411.     video_input.videoindex=videoindex;  
  412.     video_input.pFrame=pFrame;  
  413.     video_input.pFrameYUV=pFrameYUV;  
  414.     //-----------------------------添加摄像头结束
  415.     fmt=oc->oformat;  
  416.     /*使用默认格式的编解码器添加音频和视频流并初始化编解码器。*/ 
  417.     printf("fmt->video_codec = %d\n", fmt->video_codec);  
  418.     if(fmt->video_codec != AV_CODEC_ID_NONE)
  419.     {  
  420.         add_stream(&video_st,oc,&video_codec,fmt->video_codec);  
  421.         have_video=1;  
  422.         encode_video=1;  
  423.     }  
  424.     /*现在已经设置了所有参数，可以打开音频并视频编解码器，并分配必要的编码缓冲区。*/
  425.     if(have_video)open_video(oc, video_codec, &video_st, opt);  
  426.     av_dump_format(oc,0,filename,1);  
  427.     /* 打开输出文件(如果需要) */  
  428.     if(!(fmt->flags & AVFMT_NOFILE))
  429.     {  
  430.         ret=avio_open(&oc->pb,filename,AVIO_FLAG_WRITE);  
  431.         if(ret<0)
  432.         {  
  433.             fprintf(stderr, "打不开'%s': %s\n", filename,av_err2str(ret));  
  434.             return 1;  
  435.         }  
  436.     }  
  437.     /* 编写流头(如果有)*/  
  438.     ret=avformat_write_header(oc, &opt);  
  439.     if(ret<0)
  440.     {  
  441.         fprintf(stderr, "打开输出文件时发生错误: %s\n",av_err2str(ret));  
  442.         return 1;  
  443.     }  
  444.     int got_pic;  
  445.     while(encode_video)
  446.     {  
  447.         /*选择要编码的流*/    
  448.         AVFrame *frame=get_video_frame(&video_st,&video_input,&got_pic);  
  449.         if(!got_pic)  
  450.         {  
  451.             usleep(10000);  
  452.             continue;  
  453.         }
  454.         encode_video=!write_video_frame(oc,&video_st,frame);  
  455.     }  
  456.     av_write_trailer(oc);  
  457.     sws_freeContext(video_input.img_convert_ctx);  
  458.     avcodec_close(video_input.pCodecCtx);  
  459.     av_free(video_input.pFrameYUV);  
  460.     av_free(video_input.pFrame);      
  461.     avformat_close_input(&video_input.v_ifmtCtx); 
  462.     /*关闭每个编解码器*/  
  463.     if (have_video)close_stream(oc, &video_st);
  464.     /*关闭输出文件*/ 
  465.     if (!(fmt->flags & AVFMT_NOFILE))avio_closep(&oc->pb);  
  466.     /*释放流*/  
  467.     avformat_free_context(oc); 
  468.     return 0;  
  469. }
  470. Makefile文件代码：
  471. app:
  472.     gcc ffmpeg_video.c -I /home/wbyq/pc_work/ffmpeg-4.2.2/_install/include -L /home/wbyq/pc_work/ffmpeg-4.2.2/_install/lib -lavcodec -lavfilter -lavutil -lswresample -lavdevice -lavformat -lpostproc -lswscale
  473. 运行示例：
  474. [root@wbyq ffmpeg_video]# make
  475. gcc ffmpeg_video.c -I /home/wbyq/pc_work/ffmpeg-4.2.2/_install/include -L /home/wbyq/pc_work/ffmpeg-4.2.2/_install/lib -lavcodec -lavfilter -lavutil -lswresample -lavdevice -lavformat -lpostproc -lswscale
  476. ffmpeg_video.c: 在函数‘write_video_frame’中:
  477. ffmpeg_video.c:248: 警告：不建议使用‘avcodec_encode_video2’(声明于 /home/wbyq/pc_work/ffmpeg-4.2.2/_install/include/libavcodec/avcodec.h:5462)
  478. ffmpeg_video.c: 在函数‘get_video_frame’中:
  479. ffmpeg_video.c:289: 警告：不建议使用‘avcodec_decode_video2’(声明于 /home/wbyq/pc_work/ffmpeg-4.2.2/_install/include/libavcodec/avcodec.h:4828)
  480. ffmpeg_video.c: 在函数‘main’中:
  481. ffmpeg_video.c:371: 警告：不建议使用‘codec’(声明于 /home/wbyq/pc_work/ffmpeg-4.2.2/_install/include/libavformat/avformat.h:885)
  482. ffmpeg_video.c:382: 警告：不建议使用‘codec’(声明于 /home/wbyq/pc_work/ffmpeg-4.2.2/_install/include/libavformat/avformat.h:885)
  483.  
  484. [root@wbyq ffmpeg_video]# ./a.out /dev/video1 1.mp4
  485. 当前存储的视频文件名称:1.mp4
  486. videoindex=0
  487. 摄像头尺寸(WxH): 1280 x 720 
  488. fmt->video_codec = 27
  489. [libx264 @ 0x8795a80] using cpu capabilities: MMX2 SSE2Fast SSSE3 SSE4.2 AVX FMA3
  490. [libx264 @ 0x8795a80] profile High, level 3.1
  491. [libx264 @ 0x8795a80] 264 - core 148 - H.264/MPEG-4 AVC codec - Copyleft 2003-2016 - http://www.videolan.org/x264.html - options: cabac=1 ref=3 deblock=1:0:0 analyse=0x3:0x113 me=hex subme=7 psy=1 psy_rd=1.00:0.00 mixed_ref=1 me_range=16 chroma_me=1 trellis=1 8x8dct=1 cqm=0 deadzone=21,11 fast_pskip=1 chroma_qp_offset=-2 threads=3 lookahead_threads=1 sliced_threads=0 nr=0 decimate=1 interlaced=0 bluray_compat=0 constrained_intra=0 bframes=3 b_pyramid=2 b_adapt=1 b_bias=0 direct=1 weightb=1 open_gop=0 weightp=2 keyint=12 keyint_min=1 scenecut=40 intra_refresh=0 rc_lookahead=12 rc=abr mbtree=1 bitrate=2500 ratetol=1.0 qcomp=0.60 qpmin=0 qpmax=69 qpstep=4 ip_ratio=1.40 aq=1:1.00
  492. ost->frame alloc success fmt=0 w=1280 h=720
  493. Output #0, mp4, to '1.mp4':
  494. Stream #0:0: Video: h264, yuv420p, 1280x720, q=2-31, 2500 kb/s, 5 tbn
  495. ………………省略…………..

4.3 FFMPEG使用代码方式推流视频到流媒体服务器

推流本地视频文件到流媒体服务器，与3.2章节的命令效果是一样的。

示例代码：

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <math.h>
  5. #include <libavutil/avassert.h>
  6. #include <libavutil/channel_layout.h>
  7. #include <libavutil/opt.h>
  8. #include <libavutil/mathematics.h>
  9. #include <libavutil/timestamp.h>
  10. #include <libavformat/avformat.h>
  11. #include <libswscale/swscale.h>
  12. #include <libswresample/swresample.h>
  13. #include <signal.h>
  14.  
  15. int main(int argc, char * argv[])
  16. {    
  17.     AVFormatContext *pInFmtContext = NULL;    
  18.     AVStream *in_stream;
  19.     AVCodecContext *pInCodecCtx;
  20.     AVCodec *pInCodec;
  21.     AVPacket *in_packet;
  22.     AVFormatContext * pOutFmtContext;
  23.     AVOutputFormat *outputFmt;
  24.     AVStream * out_stream;
  25.     AVRational frame_rate; 
  26.     double duration;
  27.     int ret;
  28.     char in_file[128] = {0};
  29.     char out_file[256] = {0};
  30.     int videoindex = -1;
  31.     int audioindex = -1;
  32.     int video_frame_count = 0;
  33.     int audio_frame_count = 0;
  34.     int video_frame_size = 0;
  35.     int audio_frame_size = 0;
  36.     int i;
  37.     int got_picture;
  38.     if(argc < 2)
  39.     {
  40.         printf("Usage: a.out <in_filename> <url>\n");
  41.         return -1;
  42.     }
  43.     memcpy(in_file, argv[1], strlen(argv[1]));
  44.     memcpy(out_file, argv[2], strlen(argv[2]));
  45.     if(avformat_open_input ( &pInFmtContext, in_file, NULL, NULL) < 0)
  46.     {
  47.         printf("avformat_open_input failed\n");         
  48.         return -1;    
  49.     }
  50.     
  51.     //查询输入流中的所有流信息
  52.     if(avformat_find_stream_info(pInFmtContext, NULL) < 0)
  53.     {
  54.         printf("avformat_find_stream_info failed\n");
  55.         return -1;
  56.     }
  57.     //print 
  58.     av_dump_format(pInFmtContext, 0, in_file, 0); 
  59.     ret = avformat_alloc_output_context2(&pOutFmtContext, NULL, "flv", out_file);
  60.     if(ret < 0)
  61.     {
  62.         printf("avformat_alloc_output_context2 failed\n");
  63.         return -1;
  64.     }        
  65.     for(i=0; i < pInFmtContext->nb_streams; i++)
  66.     {
  67.         in_stream = pInFmtContext->streams[i];
  68.         if( in_stream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
  69.         {
  70.             audioindex = i;
  71.         }
  72.         if( in_stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
  73.         {
  74.             videoindex = i;
  75.             frame_rate = av_guess_frame_rate(pInFmtContext, in_stream, NULL);
  76.             printf("video: frame_rate:%d/%d\n", frame_rate.num, frame_rate.den);
  77.             printf("video: frame_rate:%d/%d\n", frame_rate.den, frame_rate.num);
  78.             duration = av_q2d((AVRational){frame_rate.den, frame_rate.num});       
  79.         }
  80.         
  81.         pInCodec = avcodec_find_decoder(in_stream->codecpar->codec_id);
  82.         printf("%x, %d\n", pInCodec, in_stream->codecpar->codec_id);
  83.         out_stream = avformat_new_stream(pOutFmtContext,  pInCodec);//in_stream->codec->codec);
  84.         if( out_stream == NULL)
  85.         {
  86.             printf("avformat_new_stream failed:%d\n",i);
  87.         }
  88.  
  89.         ret = avcodec_parameters_copy(out_stream->codecpar, in_stream->codecpar);
  90.         if( ret < 0)
  91.         {
  92.             printf("avcodec_parameters_copy failed:%d\n", i);
  93.         }
  94.         out_stream->codecpar->codec_tag = 0;
  95.         if(pOutFmtContext->oformat->flags & AVFMT_GLOBALHEADER)
  96.         {//AVFMT_GLOBALHEADER代表封装格式包含“全局头”（即整个文件的文件头），大部分封装格式是这样的。一些封装格式没有“全局头”，比如MPEG2TS
  97.             out_stream->codec->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
  98.         }        
  99.     }
  100.     av_dump_format(pOutFmtContext,0,out_file,1); 
  101.     ret=avio_open(&pOutFmtContext->pb, out_file, AVIO_FLAG_WRITE);
  102.     if(ret<0)
  103.     {
  104.         printf("avio_open failed:%d\n", ret);
  105.         return -1;
  106.     }
  107.     int64_t start_time = av_gettime();
  108.     ret = avformat_write_header(pOutFmtContext, NULL);
  109.     in_packet = av_packet_alloc();
  110.     while(1)
  111.     {
  112.         ret=av_read_frame(pInFmtContext, in_packet);
  113.         if(ret<0)
  114.         {
  115.             printf("read frame end\n");
  116.             break;
  117.         }
  118.         in_stream = pInFmtContext->streams[in_packet->stream_index];
  119.         if(in_packet->stream_index == videoindex)
  120.         {
  121.             video_frame_size += in_packet->size;
  122.             printf("recv %5d video frame %5d-%5d\n", ++video_frame_count, in_packet->size, video_frame_size);
  123.         }
  124.  
  125.         if(in_packet->stream_index == audioindex)
  126.         {
  127.             audio_frame_size += in_packet->size;
  128.             printf("recv %5d audio frame %5d-%5d\n", ++audio_frame_count, in_packet->size, audio_frame_size);
  129.         }
  130.         
  131.         int codec_type = in_stream->codecpar->codec_type;
  132.         if(codec_type == AVMEDIA_TYPE_VIDEO)
  133.         {
  134.             //根据pts时间与系统时间的关系来计算延时时间,该方案更优
  135.             AVRational  dst_time_base = {1, AV_TIME_BASE};
  136.             int64_t pts_time=av_rescale_q(in_packet->pts,in_stream->time_base, dst_time_base); 
  137.             int64_t now_time=av_gettime() - start_time;
  138.             if(pts_time > now_time)
  139.             av_usleep(pts_time - now_time);
  140.         }
  141.         out_stream = pOutFmtContext->streams[in_packet->stream_index];
  142.         av_packet_rescale_ts(in_packet,in_stream->time_base, out_stream->time_base);
  143.         in_packet->pos = -1;
  144.         ret = av_interleaved_write_frame(pOutFmtContext, in_packet);
  145.         if(ret<0)
  146.         {
  147.             printf("av_interleaved_write_frame failed\n");
  148.             break;
  149.         }
  150.         av_packet_unref(in_packet); 
  151.     }
  152.     av_write_trailer(pOutFmtContext);
  153.     av_packet_free(&in_packet);
  154.     avformat_close_input(&pInFmtContext);
  155.     avio_close( pOutFmtContext->pb);
  156.     avformat_free_context(pOutFmtContext);
  157.     return 0;
  158. }

Makefile文件代码：

  1. app:
  2.     gcc ffmpeg_video.c -I /home/wbyq/pc_work/ffmpeg-4.2.2/_install/include -L /home/wbyq/pc_work/ffmpeg-4.2.2/_install/lib -lavcodec -lavfilter -lavutil -lswresample -lavdevice -lavformat -lpostproc -lswscale

编译运行示例：

[root@wbyq ffmpeg_video]# ./a.out /mnt/hgfs/linux-share-dir/1-39-508.mp4 rtmp://js.live-send.acg.tv/live-js/?streamname=live_68130189_71037877&key=b95d4cfda0c196518f104839fe5e7573

4.4 QT调用FFMPEG库捕获一帧摄像头图像

第一步: 在QT的工程文件(xxx.pro)里添加FFMPEG和X264的头文件、库文件路径(MiGW编译器)

  1. #指定库的路径
  2. unix:LIBS += -L/home/wbyq/work_pc/ffmpeg-4.2.2/_install/lib -lavcodec
  3. unix:LIBS += -L/home/wbyq/work_pc/ffmpeg-4.2.2/_install/lib -lavfilter
  4. unix:LIBS += -L/home/wbyq/work_pc/ffmpeg-4.2.2/_install/lib -lavutil
  5. unix:LIBS += -L/home/wbyq/work_pc/ffmpeg-4.2.2/_install/lib -lavdevice
  6. unix:LIBS += -L/home/wbyq/work_pc/ffmpeg-4.2.2/_install/lib -lavformat
  7. unix:LIBS += -L/home/wbyq/work_pc/ffmpeg-4.2.2/_install/lib -lpostproc
  8. unix:LIBS += -L/home/wbyq/work_pc/ffmpeg-4.2.2/_install/lib -lswscale
  9. unix:LIBS += -L/home/wbyq/work_pc/ffmpeg-4.2.2/_install/lib -lswresample
  10. unix:LIBS += -L/home/wbyq/work_pc/x264-snapshot-20181217-2245/_install/lib -lx264
  11.  
  12. #制定头文件的路径
  13. INCLUDEPATH+=/home/wbyq/work_pc/ffmpeg-4.2.2/_install/include
  14. INCLUDEPATH+=/home/wbyq/work_pc/x264-snapshot-20181217-2245/_install/include

如果在C++代码里穿插C语言代码可以在头文件里指定使用C语言方式调用即可。(MiGW编译器)

  1. #指定库的路径
  2. unix:LIBS += -L$$PWD/ffmpeg_x264_lib/lib -lavcodec
  3. unix:LIBS += -L$$PWD/ffmpeg_x264_lib/lib -lavfilter
  4. unix:LIBS += -L$$PWD/ffmpeg_x264_lib/lib -lavutil
  5. unix:LIBS += -L$$PWD/ffmpeg_x264_lib/lib -lavdevice
  6. unix:LIBS += -L$$PWD/ffmpeg_x264_lib/lib -lavformat
  7. unix:LIBS += -L$$PWD/ffmpeg_x264_lib/lib -lpostproc
  8. unix:LIBS += -L$$PWD/ffmpeg_x264_lib/lib -lswscale
  9. unix:LIBS += -L$$PWD/ffmpeg_x264_lib/lib -lswresample
  10. unix:LIBS += -L$$PWD/ffmpeg_x264_lib/lib -lx264
  11.  
  12. #制定头文件的路径
  13. INCLUDEPATH+=$$PWD/ffmpeg_x264_lib/include

再加路径的时候的可以使用$$PWD获取当前路径，方便填路径:

  1. extern "C"
  2. {
  3.     #include "ffmpeg_get_image.h"
  4. }

如果是MSVC编译器，可以使用#pragma comment(lib,...)这种方式导入lib。

直接在cpp代码里编写代码，加入库：

  1. #pragma comment(lib,"libavcodec.a")
  2. #pragma comment(lib,"libavfilter.a")
  3. #pragma comment(lib,"libavutil.a")
  4. #pragma comment(lib,"libswresample.a")
  5. #pragma comment(lib,"libx264.a")
  6. #pragma comment(lib,"libavdevice.a")
  7. #pragma comment(lib,"libavformat.a")
  8. #pragma comment(lib,"libavdevice.a")
  9. #pragma comment(lib,"libpostproc.a")
  10. #pragma comment(lib,"libswscale.a")

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/代码探险家/article/detail/994963
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号