您现在的位置是：网站首页> 多媒体开发

ffplay -allowed_extensions ALL -autoexit -alwaysontop -x 1280 -y 720 -window_title “cctv6 电影频道” -i https://epg.pw/stream/12222da81a59a4b766eebab3c8c43f4fa910637ea182be42e2affdae3ebb845c.m3u8

查看全部命令以下命令，保存后查看

ffplay -help > D:\ffplaycommand.txt

-allowed_extensions ALL 允许所有文件格式的输入，播放本地m3u8文件要用到。

-autoexit 播放完自动退出，对于直播流无效

-alwaysontop 窗口总显示在最前面

-x 1280 -y 720 调整窗口大小为1280*720

-window_title 设置窗口标题（默认为输入文件名）。

-showmode 1 -vn 显示音频流，禁用视频流，节省宽带与电脑性能，适用于国外纯音乐频道听歌

-vf scale=iw/2:ih/2 -vf视频滤镜，scale=iw/2:ih/2是播放时质量变成原来的一半

-vf histeq=0.200:0.210:weak 颜色分布调整

-vf hflip 水平翻转

-fs 全屏

-aspect 4:3 纵横比设置纵横比（4:3、16:9或1.3333、1.7777）

-an/vn/sn 禁用音、视频、字幕

-ss 01:40:20 -t 60 没有 -to 这个用法，区别于ffmpeg

-bytes 按字节搜索。

-seek_interval 100 快进一次100秒

-nodisp禁用图形显示。

-noborder无边框窗口。

-volume [0-100]

-f fmt强制格式。

-left 0 设置窗口左侧的 x 位置（默认为居中窗口）。

-top 0 设置窗口顶部的 y 位置（默认为居中窗口）。

-loop 2 循环播放动画<2>次。0 表示永远。

-showmode 0/video 显示视频

-showmode 1/waves 显示音频波形

-showmode 2/rdft 使用 RDFT（（逆）实离散傅里叶变换）显示音频频段

默认值为“视频”，如果视频不存在或无法播放 “RDFT”被自动选中。

您可以通过以下方式以交互方式循环切换可用的显示模式按 W 键。

-af -filter:a 缩写，提示输入音频过滤器名称

三、窗口操作

鼠标拖动可以调节窗口到任意大小

鼠标左键双击切换全屏

按q,ESC退出

暂停p，SPC

切换静音m

分别减少和增加音量。9, 0/, *

←/→ 向后/向前搜索 10 秒。

↓/↑ 向后/向前寻求 1 分钟。

PgUp/PgDn 寻求上一章/下一章。或者如果没有章节向后/向前搜索 10 分钟。

鼠标右键单击播放进度跳到。

在当前程序中循环音频通道。v

循环视频频道。t

循环当前节目中的字幕频道。c

循环程序。w

循环视频过滤器或显示模式。s

四、批处理播放前设置参数

set SDL_AUDIODRIVER=directsound

chcp 65001

set SDL_AUDIODRIVER=directsound 为调用声卡的内容，一些笔记本无法自己调用

chcp 65001 调用中文编码，出现乱码时调用或去除

最后一行为ffplay命令，名称要加双引号，防止名称中有空格造成错误。

重命名为“cctv6 电影频道”，后缀改成.bat,双击即可播放文件。

ffmpeg 4.4版本对MP4文件进行AES-CTR加密，和流式加密

一、对于普通的加密方式

加密方式：

# 使用AES-128-CBC算法对视频文件进行加密

ffmpeg -i input.mp4 -c:v copy -c:a copy -encryption_scheme cenc-aes-ctr -encryption_key 0123456789ABCDEF0123456789ABCDEF -encryption_kid 0123456789ABCDEF0123456789ABCDEF encrypted.mp4

对应的解密

# 使用相同的密钥和KID对加密的视频文件进行解密

ffmpeg -decryption_key 0123456789ABCDEF0123456789ABCDEF -i encrypted.mp4 -c:v copy -c:a copy decrypted.mp4

ffplay -decryption_key 0123456789ABCDEF0123456789ABCDEF -i encrypted.mp4

直接使用下面的命令就行

ffmpeg -i animal.mp4 -vcodec copy -acodec copy -encryption_scheme cenc-aes-ctr -encryption_key c7e16c4403654b85847037383f0c2db3 -encryption_kid a7e61c373e219033c21091fa607bf3b8 -encryption_iv 1234567890abcdef1234567890abcdef encrypted_IV3.mp4

简单解释一下各种参数的作用，

-vcodec copy -acodec copy 只是将 animal.mp4的音视频数据直接拷贝到encrypted_IV3.mp4中

-encryption_scheme cenc-aes-ctr 表示采用的加密算法是cenc-aes-ctr

-encryption_key c7e16c4403654b85847037383f0c2db3 表是encryption_key 的值是c7e16c4403654b85847037383f0c2db3，这个值就是解密用的key

-encryption_kid a7e61c373e219033c21091fa607bf3b8 表示encryption_kid 的值是a7e61c373e219033c21091fa607bf3b8，加解密就是key和id的比对

-encryption_iv 1234567890abcdef1234567890abcdef 表示加密的初始向量IV为1234567890abcdef1234567890abcdef，这个参数可以不加，ffmpeg是有默认值的

encrypted_IV3.mp4 是加密后的MP4

播放的话，采用的是ffplay，命令行如下

ffplay encrypted_IV.mp4 -decryption_key c7e16c4403654b85847037383f0c2db3 -decryption_iv 1234567890abcdef1234567890abcdef

-decryption_key 解密用的密钥，就是加密的encryption_key的值

-decryption_iv 如果加密的时候有设置加密初始向量的值，那么这里也需要加，对应的是encryption_iv的值，如果加密的时候采用的是默认的，这里可以不加

对于代码加密代码，此处复制的别人的，项目并不需要这个，我就没做验证

AVDictionary *opts = NULL;

// 指定加密参数

av_dict_set(&format_opts, "encryption_scheme", "cenc-aes-ctr", 0);

av_dict_set(&format_opts, "encryption_key", "c7e16c4403654b85847037383f0c2db3", 0);

av_dict_set(&format_opts, "encryption_kid", "a7e61c373e219033c21091fa607bf3b8", 0);

ret = avformat_write_header(AVFormatContext, &format_opts);

解密的代码也是别人的，但我是经过验证的，确认可行

AVDictionary *format_opts = NULL;

// 指定解密key

av_dict_set(&format_opts, "decryption_key", "c7e16c4403654b85847037383f0c2db3", 0);

av_dict_set(&format_opts, "decryption_iv", "1234567890abcdef1234567890abcdef", 0);

err = avformat_open_input(&AVFormatContext, "path", AVInputFormat, &format_opts);

二、对于流式的加密方式

命令行如下

ffmpeg -i animal.mp4 -movflags frag_keyframe -encryption_scheme cenc-aes-ctr -encryption_key c7e16c4403654b85847037383f0c2db3 -encryption_kid a7e61c373e219033c21091fa607bf3b8 encrypted.mp4

重复的参数我就不赘述了，

-movflags 选项用于设置MOV或MP4容器（文件格式）的特定标志。这些标志会改变输出文件的结构或行为。

frag_keyframe 强制每个关键帧都开始一个新的片段，使文件适合于流式传输。这个参数就是区分流式还是普通的一个关键参数

播放的话和普通的一致。

出现下面这三个字段，就是说明成功了。工具我用的是Bento4，Bento4有个命令mp4dump可以查看。

三、需要注意的是---moov

ffmpeg有一个参数，叫empty_moov 。当你创建一个MP4文件时，通常它首先写入一个moov原子（也就是元数据），然后是mdat原子（包含实际的音频/视频数据）。但是，如果你想开始记录并在之后添加元数据，你需要首先写入一个空的moov原子，简单理解就是：

普通的MP4 的格式（从上到下）： moov -> data

加了empty_moov的MP4格式: empty_moov -> data -> moov

如果你把moov移动到了MP4末尾的同时做了aes-ctr加密，就会出错，因为ffmpeg在解密aes-ctr时要先知道加密的重要参数，而这个参数就在moov中，然后才能进行解密，如果moov放在了末尾，那ffmpeg就不知道要怎么解密了。该情况下我遇到的错误有下面几种

[mov,mp4,m4a,3gp,3g2,mj2 @ 0x149204a10] Incorrect number of samples in encryption info

[mov,mp4,m4a,3gp,3g2,mj2 @ 0x1426658b0] saio atom found without saiz

[h264 @ 0x7f93ba8a3e00] Invalid NAL unit size (217505651 > 1332).

[h264 @ 0x7f93ba8a3e00] Error splitting the input into NAL units.

ffmpeg加密推流

ffmpeg 推流到抖音

ffmpeg -re -i input.mp4 -c:v libx264 -preset veryfast -maxrate 1500k -bufsize 1500k -pix_fmt yuv420p -g 30 -c:a aac -b:a 128k -ar 44100 -ac 2 -f flv rtmp://your_douyin_rtmp_server/stream

请将input.mp4替换为你想要推流的视频文件路径，并将rtmp://your_douyin_rtmp_server/stream替换为你从抖音获取的实际RTMP服务器地址。

确保你的FFmpeg版本是最新的，以支持与抖音服务器的RTMP流媒体传输。如果你需要更多的推流参数定制，请查看FFmpeg的官方文档以获取更多信息。

其他命令：

ffmpeg查看电脑设备

输入下面的语句即可列出电脑的设备

ffmpeg -list_devices true -f dshow -i dummy

测试摄像头是否可用

cmd中输入下面语句并回车（USB2.0 PC CAMERA为摄像头名称）

ffplay -f dshow -i video="USB2.0 PC CAMERA"

查看摄像头和麦克风信息

cmd中输入下面语句即可查询摄像头信息

ffmpeg -list_options true -f dshow -i video="USB2.0 PC CAMERA"

cmd中输入下面语句即可查询麦克风信息

ffmpeg -list_options true -f dshow -i audio="麦克风 (2- USB2.0 MIC)"

本地视频的推流

ffmpeg.exe -re -i demo.wmv -f flv rtmp://127.0.0.1:1935/live/123

摄像头推流

ffmpeg -f dshow -i video="USB2.0 PC CAMERA" -vcodec libx264 -preset:v ultrafast -tune:v zerolatency -f flv rtmp://127.0.0.1:1935/live/123

麦克风推流

ffmpeg -f dshow -i audio="麦克风 (2- USB2.0 MIC)" -vcodec libx264 -preset:v ultrafast -tune:v zerolatency -f flv rtmp://127.0.0.1:1935/live/123

摄像头&麦克风推流

ffmpeg -f dshow -i video="USB2.0 PC CAMERA" -f dshow -i audio="麦克风 (2- USB2.0 MIC)" -vcodec libx264 -preset:v ultrafast -tune:v zerolatency -f flv rtmp://127.0.0.1:1935/live/123

或者

ffmpeg -f dshow -i video="USB2.0 PC CAMERA":audio="麦克风 (2- USB2.0 MIC)" -vcodec libx264 -r 25 -preset:v ultrafast -tune:v zerolatency -f flv rtmp://127.0.0.1:1935/live/123

ffmpeg 命令行编程相关

通过ffmpeg转码后的,如何给某几个ts单独添加水印

基于c#生成M3U8或者M3U格式的HLS视频流

ffmpeg推流

ffmpeg为视频设置透明度的几种方案

两个视频视频帧像素融合

ffmpeg命令行帮助

ffmpeg -h

ffmpeg -h long

ffmpeg -h full

ffmpeg -h type=name

ffmpeg -h filter=scale

输出如下：

scale AVOptions:

w <string> ..FV..... Output video width

width <string> ..FV..... Output video width

h <string> ..FV..... Output video height

height <string> ..FV..... Output video height

flags <string> ..FV..... Flags to pass to libswscale (default "bilinear")

interl <boolean> ..FV..... set interlacing (default false)

in_color_matrix <string> ..FV..... set input YCbCr type (default "auto")

out_color_matrix <string> ..FV..... set output YCbCr type

in_range <int> ..FV..... set input color range (from 0 to 2) (default auto)

...

这就告诉我们scale滤镜有w、h等参数,我们就这样使用scale滤镜，

ffmpeg -i input.mp4 -filter_complex "scale=w=iw/2h=ih/2" output.mp4

其中iw代表输入视频的宽，ih代表输入视频的高，这条命令就把输入的视频缩小一倍，这里你可能会有疑问，我都不记得那些滤镜的名字，就无法使用这个去查了，哈哈不要急，还记得上面的帮助命令吗，ffmpeg -filters可以输出所有的滤镜名字了，如果你觉的输出太多，你不好找的话，你只要记得这个滤镜大概是叫什么名字、包含什么字母，你就借助grep指令去输出里面搜索关键字，这样就只会输出你关心的滤镜名了，如ffmpeg -filters | grep over

-h topic show help

-? topic show help

-help topic show help

--help topic show help

-version show version

-buildconf show build configuration

-formats show available formats

-muxers show available muxers

-demuxers show available demuxers

-devices show available devices

-codecs show available codecs

-decoders show available decoders

-encoders show available encoders

-bsfs show available bit stream filters

-protocols show available protocols

-filters show available filters

-pix_fmts show available pixel formats

-layouts show standard channel layouts

-sample_fmts show available audio sample formats

-dispositions show available stream dispositions

-colors show available color names

-sources device list sources of the input device

-sinks device list sinks of the output device

-hwaccels show available HW acceleration methods

Global options (affect whole program instead of just one file):

-loglevel loglevel set logging level

-v loglevel set logging level

-report generate a report

-max_alloc bytes set maximum size of a single allocated block

-y overwrite output files

-n never overwrite output files

-ignore_unknown Ignore unknown stream types

-filter_threads number of non-complex filter threads

-filter_complex_threads number of threads for -filter_complex

-stats print progress report during encoding

-max_error_rate maximum error rate ratio of decoding errors (0.0: no errors, 1.

0: 100% errors) above which ffmpeg returns an error instead of success.

Per-file main options:

-f fmt force format

-c codec codec name

-codec codec codec name

-pre preset preset name

-map_metadata outfile[,metadata]:infile[,metadata] set metadata information of

outfile from infile

-t duration record or transcode "duration" seconds of audio/video

-to time_stop record or transcode stop time

-fs limit_size set the limit file size in bytes

-ss time_off set the start time offset

-sseof time_off set the start time offset relative to EOF

-seek_timestamp enable/disable seeking by timestamp with -ss

-timestamp time set the recording timestamp ('now' to set the current time)

-metadata string=string add metadata

-program title=string:st=number... add program with specified streams

-target type specify target file type ("vcd", "svcd", "dvd", "dv" or "dv5

0" with optional prefixes "pal-", "ntsc-" or "film-")

-apad audio pad

-frames number set the number of frames to output

-filter filter_graph set stream filtergraph

-filter_script filename read stream filtergraph description from a file

-reinit_filter reinit filtergraph on input parameter changes

-discard discard

-disposition disposition

Video options:

-vframes number set the number of video frames to output

-r rate set frame rate (Hz value, fraction or abbreviation)

-fpsmax rate set max frame rate (Hz value, fraction or abbreviation)

-s size set frame size (WxH or abbreviation)

-aspect aspect set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)

-display_rotation angle set pure counter-clockwise rotation in degrees for stre

am(s)

-display_hflip set display horizontal flip for stream(s) (overrides any dis

play rotation if it is not set)

-display_vflip set display vertical flip for stream(s) (overrides any displ

ay rotation if it is not set)

-vn disable video

-vcodec codec force video codec ('copy' to copy stream)

-timecode hh:mm:ss[:;.]ff set initial TimeCode value.

-pass n select the pass number (1 to 3)

-vf filter_graph set video filters

-b bitrate video bitrate (please use -b:v)

-dn disable data

Audio options:

-aframes number set the number of audio frames to output

-aq quality set audio quality (codec-specific)

-ar rate set audio sampling rate (in Hz)

-ac channels set number of audio channels

-an disable audio

-acodec codec force audio codec ('copy' to copy stream)

-ab bitrate audio bitrate (please use -b:a)

-af filter_graph set audio filters

Subtitle options:

-s size set frame size (WxH or abbreviation)

-sn disable subtitle

-scodec codec force subtitle codec ('copy' to copy stream)

-stag fourcc/tag force subtitle tag/fourcc

-fix_sub_duration fix subtitles duration

-canvas_size size set canvas size (WxH or abbreviation)

-spre preset set the subtitle options to the indicated preset

得到ffmpeg命令行输出

SynchronizationContext SyncContext = null;

public Form1()

{

InitializeComponent();

SyncContext = SynchronizationContext.Current;

}

void soundProcess(string infn, string outfn)

{

string aa, aa2;

aa = aa2 = "DEAD";

var app = new Process();

string param = "",outString="";

app.StartInfo.UseShellExecute = false;

app.StartInfo.RedirectStandardOutput = true;

app.StartInfo.RedirectStandardError = true;

app.StartInfo.CreateNoWindow = true;

app.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;

app.StartInfo.FileName = @"ffmpeg.exe";

//app.StartInfo.Arguments = string.Format(@"-i ""{0}"" -ab 192k -y {2} ""{1}""", infn, outfn, param);

app.StartInfo.Arguments = string.Format(@"-i ""{0}"" -f mp3 -acodec libmp3lame -y ""{1}""", infn, outfn);

app.EnableRaisingEvents = true;

List<string> m_outList = new List<string>();

app.Start();

try

{

app.PriorityClass = ProcessPriorityClass.BelowNormal;

}

catch (Exception ex)

{

if (!Regex.IsMatch(ex.Message, @"Cannot process request because the process .*has exited"))

throw ex;

}

app.Exited += (s, a) =>

{

SyncContext.Post(m =>

{

MessageBox.Show("退出");

}, "");

return;

};

app.OutputDataReceived += (s, a) =>

{

if (a.Data == null)

{

//mre_output.Set();

return;

}

};

app.ErrorDataReceived += (s, a) =>

{

if (a.Data == null)

{

//mre_error.Set();

//MessageBox.Show(outString);

SyncContext.Post(m => {

var result = m as List<string>;

textBox1.Lines = result.ToArray();

}, m_outList);

return;

}

else

{

outString += a.Data;

m_outList.Add(a.Data);

}

};

}

soundProcess("c:\\outmp3\\1_cd.wav", "c:\\out\\cd.mp3");

得到ffmpeg命令行内存输出

void soundProcessMem(string infn, string outfn)

{

string aa, aa2;

aa = aa2 = "DEAD";

var app = new Process();

string param = "", outString = "";

app.StartInfo.UseShellExecute = false;

app.StartInfo.RedirectStandardOutput = true;

app.StartInfo.RedirectStandardError = true;

app.StartInfo.CreateNoWindow = true;

app.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;

//*/

app.StartInfo.FileName = @"ffmpeg.exe";

//app.StartInfo.Arguments = string.Format(@"-i ""{0}"" -ab 192k -y {2} ""{1}""", infn, outfn, param);

app.StartInfo.Arguments = string.Format(@"-i ""{0}"" -f mp3 -acodec libmp3lame -y pipe:1", infn);

app.EnableRaisingEvents = true;

List<string> m_outList = new List<string>();

app.Start();

try

{

app.PriorityClass = ProcessPriorityClass.BelowNormal;

}

catch (Exception ex)

{

if (!Regex.IsMatch(ex.Message, @"Cannot process request because the process .*has exited"))

throw ex;

}

FileStream baseStream = app.StandardOutput.BaseStream as FileStream;

app.Exited += (s, a) =>

{

SyncContext.Post(m =>

{

MessageBox.Show("退出");

}, "");

return;

};

app.OutputDataReceived += (s, a) =>

{

if (a.Data == null)

{

//mre_output.Set();

return;

}

};

app.ErrorDataReceived += (s, a) =>

{

if (a.Data == null)

{

//mre_error.Set();

//MessageBox.Show(outString);

SyncContext.Post(m =>

{

var result = m as List<string>;

textBox1.Lines = result.ToArray();

}, m_outList);

return;

}

else

{

outString += a.Data;

m_outList.Add(a.Data);

}

};

byte[] audioData;

int lastRead = 0;

using (MemoryStream ms = new MemoryStream())

{

byte[] buffer = new byte[5000];

{

lastRead = baseStream.Read(buffer, 0, buffer.Length);

ms.Write(buffer, 0, lastRead);

} while (lastRead > 0);

audioData = ms.ToArray();

}

using (FileStream s = new FileStream(outfn, FileMode.Create))

{

s.Write(audioData, 0, audioData.Length);

}

//aa = app.StandardOutput.ReadToEnd();

// app.BeginOutputReadLine();

//app.BeginErrorReadLine();

}

private void button5_Click(object sender, EventArgs e)

{

soundProcessMem("c:\\outmp3\\1_cd.wav", "c:\\out\\cd.mp3");

return;

}

内存数据

var proc= new Process();

。。。

FileStream baseStream = proc.StandardOutput.BaseStream as FileStream;

byte[] audioData;

int lastRead = 0;

using (MemoryStream ms = new MemoryStream())

{

byte[] buffer = new byte[5000];

{

lastRead = baseStream.Read(buffer, 0, buffer.Length);

ms.Write(buffer, 0, lastRead);

} while (lastRead > 0);

audioData = ms.ToArray();

}

using(FileStream s = new FileStream(Path.Combine(WorkingFolder, "pipe_output_01.mp3"), FileMode.Create))

{

s.Write(audioData, 0, audioData.Length);

}

将视频文件转为m3u8

ffmpeg -i D:\video\video.mp4 -c:v libx264 -hls_time 10 -hls_list_size 0 -c:a aac -strict -2 -f hls D:\video\9s.m3u8

一次性完成转换和切片，切片时长为10秒，这样就会切出每个10秒的视频片段。

通过ffmpeg转码后的,如何给某几个ts单独添加水印

视频添加水印和压缩：

ffmpeg -i g:\hy.mp4 -i g:\logo.png -filter_complex overlay -c:v libx264 -c:a aac -strict -2 -f hls -hls_list_size 0 -hls_time 15 g:\videos\hy.m3u8

默认的每片长度为 2 秒，m3u8 文件中默认只保存最新的 5 条片的信息，导致最后播放的时候只能播最后的一小部分（直播的时候特别注意）。

-hls_time n 设置每片的长度，默认值为 2，单位为秒。

-hls_list_size n 设置播放列表保存的最多条目，设置为 0 会保存有所片信息，默认值为5。

-hls_wrap n 设置多少片之后开始覆盖，如果设置为0则不会覆盖，默认值为0。这个选项能够避免在磁盘上存储过多的片，而且能够限制写入磁盘的最多的片的数量。

-hls_start_number n 设置播放列表中 sequence number 的值为 number，默认值为 0。

注意：播放列表的 sequence number 对每个 segment 来说都必须是唯一的，而且它不能和片的文件名（当使用 wrap 选项时，文件名有可能会重复使用）混淆。

ffmpeg -i g:\hy.mp4 -vf "drawtext='fontfile=FreeSans.ttf:text=anlun_xn:fontcolor=red'" -c:v libx264 -c:a aac -strict -2 -f hls -hls_list_size 0 -hls_time 15 g:\videos\hy.m3u8

ffmpeg -i g:\hy.mp4 -vf "drawtext='fontfile=FreeSans.ttf:text=anlun_xn:fontcolor=red:x=if(eq(mod(t,30),0),rand(0,(W-tw)),x): y=if(eq(mod(t,30),0),rand(0,(H-th)),y)'" -c:v libx264 -c:a aac -strict -2 -f hls -hls_list_size 0 -hls_time 15 g:\videos\hy.m3u8

m3u8内容介绍

EXTM3U：这个是M3U8文件必须包含的标签，并且必须在文件的第一行，所有的M3U8文件中必须包含这个标签。

EXT-X-VERSION：M3U8文件的版本，常见的是3（目前最高版本应该是7）。

EXT-X-TARGETDURATION：该标签指定了媒体文件持续时间的最大值，播放文件列表中的媒体文件在EXTINF标签中定义的持续时间必须小于或者等于该标签指定的持续时间。该标签在播放列表文件中必须出现一次。

EXT-X-MEDIA-SEQUENCE：M3U8直播是的直播切换序列，当播放打开M3U8时，以这个标签的值作为参考，播放对应的序列号的切片。

EXTINF：EXTINF为M3U8列表中每一个分片的duration，如上面例子输出信息中的第一片的duration为10秒。在EXTINF标签中，除了duration值，还可以包含可选的描述信息，主要为标注切片信息，使用逗号分隔开。

MIME里加入

.m3u8 application/octet-stream

.ts application/octet-stream

MIME配置问题

(1) 在VS启动中必须配置下文件播放地址

</staticContent>

（2）当发布的时候需要配置IIS的

.m3u8 application/x-mpegURL

.ts video/MP2T

这里有个坑，当我用上面命令行生成hls视频后，我发现每个ts的时长不是我指定的2s，而是10s。查阅资料后发现，ts切片的大小严格依赖于原始视频的GOP大小，因为必选保证一个ts内至少包含一个GOP，否则这个ts分片就无法使用。当然解决方式也很简单，我们只需要再新增一个参数 -force_key_frames "expr:gte(t,n_forced*2)" 这个参数的作用就是让视频GOP大小为2s，这样就能保证ts分片大小是我们想要的2s了。完整命令如下：

ffmpeg -i input.mp4 -c:v copy -force_key_frames "expr:gte(t,n_forced*2)" -hls_time 2 -hls_segment_filename %d.ts -f hls output/playlist.m3u8

基于c#生成M3U8或者M3U格式的HLS视频流

生成M3U8或者M3U格式的HLS视频流可以通过以下步骤实现：

1. 将视频文件转换为HLS格式的视频流；

2. 生成M3U8或者M3U文件，指定视频流文件的地址和长度信息；

3. 将生成的M3U8或者M3U文件上传到服务器，供客户端访问。

以下是一个基于c#生成M3U8文件的示例代码：

using System;

using System.IO;

using System.Text;

namespace M3U8Generator

{

class Program

{

static void Main(string[] args)

{

string baseFilePath = @"D:\video\";

string m3u8FilePath = baseFilePath + "video.m3u8";

string tsFolder = baseFilePath + "ts\\";

string videoFileName = "video.mp4";

int segmentDuration = 10;

int segmentCount = 0;

StringBuilder sb = new StringBuilder();

sb.AppendLine("#EXTM3U");

sb.AppendLine("#EXT-X-VERSION:3");

sb.AppendLine("#EXT-X-TARGETDURATION:" + segmentDuration);

sb.AppendLine("#EXT-X-MEDIA-SEQUENCE:0");

// 分段处理视频流

while (true)

{

string tsFileName = "segment_" + segmentCount.ToString().PadLeft(5, '0') + ".ts";

string tsFilePath = tsFolder + tsFileName;

int length = Convert.ToInt32(segmentDuration * 1000);

if (File.Exists(tsFilePath))

{

string segmentLine = string.Format("#EXTINF:{0},\r\n{1}", length, tsFileName);

sb.AppendLine(segmentLine);

segmentCount++;

}

else

{

break;

}

File.WriteAllText(m3u8FilePath, sb.ToString());

Console.WriteLine("M3U8 file generated successfully.");

}

注解：

1. 代码中的baseFilePath、videoFileName、segmentDuration、tsFolder分别代表视频文件所在的路径、视频文件名、每个分段的时长（单位：秒）、保存分段视频流的文件夹。

2. 在分段处理视频流时，需要保证每个分段视频流的文件名是“segment_00000.ts”、“segment_00001.ts”等等，这样才能在生成M3U8文件时正确地指定每个分段的地址。

3. 代码中使用了StringBuilder来拼接M3U8文件的内容。在使用StringBuilder时，需要注意线程安全性和字符串的编码方式。

ffmpeg推流

rtmp推流 ffmpeg -re -stream_loop -1 -i f:/mp4/10.mp4 -c copy -f flv rtmp://192.168.0.110:6908/stream

rtsp推流 ffmpeg -re -stream_loop -1 -i f:/mp4/10.mp4 -c copy -f rtsp rtsp://192.168.0.110:6907/stream

远程推流 ffmpeg -re -stream_loop -1 -i f:/mp4/11.mp4 -c copy -f flv rtmp://47.114.127.78:6908/stream

网络设备 ffmpeg -i rtsp://admin:Admin123456@192.168.0.64:554/Streaming/Channels/101 -c copy -f flv rtmp://192.168.0.110:6908/stream

重新编码 ffmpeg -i "rtsp://admin:Admin123456@192.168.0.64:554/Streaming/Channels/101?transportmode=unicast&profile=Profile_2" -vcodec libx264 -acodec aac -f flv rtmp://192.168.0.110:6908/stream

实时桌面 ffmpeg -f gdigrab -r 30 -i desktop -vcodec libx264 -preset:v ultrafast -tune:v zerolatency -f rtsp -g 5 -an rtsp://192.168.0.110:6907/stream

本地设备 ffmpeg -f dshow -i video="USB Video Device":audio="麦克风 (USB Audio Device)" -vcodec libx264 -preset:v ultrafast -tune:v zerolatency -f rtsp rtsp://192.168.0.110:6907/stream

播放设备 ffplay -f dshow video="USB Video Device":audio="麦克风 (USB Audio Device)"

执行ffmpeg/ffplay 命令行不显示顶部固定编译参数等信息 -hide_banner，不要打印任何日志信息包括实时的解码编码信息 -loglevel quiet。

ffmpeg为视频设置透明度的几种方案

方案一：推荐在这里插入图片描述

ffmpeg -i a2.mp4 -i a3.mp4 -filter_complex [0:v]format=yuva444p,colorchannelmixer=aa=0.5[valpha];[1:v][valpha]overlay=(W-w)/2:(H-h)/2 -ss 0 -t 5 -y overlay4.mp4

方案二：对图片有效，经过测试

ffmpeg -i in4.png -i a3.mp4 -filter_complex [0:v]geq=a='122':lum='lum(X,Y)':cb='cb(X,Y)':cr='cr(X,Y)'[topV];[1:v][topV]overlay=(W-w)/2:(H-h)/2 -ss 0 -t 5 -y overlay3.mp4

同方案二，只是先将视频转换成一张张帧序列然后再使用方案二

此处经过测试，同样在ffmpeg 4.13下。Windows，Android，iOS 只有IOS下可以对视频进行geq，所以其他平台只能先转换成图片序列，然后再做geq

//此处经过测试，同样在ffmpeg 4.13下。Windows，Android，iOS 只有IOS下可以对视频进行geq

ffmpeg -i a2.mp4 -i a3.mp4 -filter_complex [0:v]geq=a='122':lum='lum(X,Y)':cb='cb(X,Y)':cr='cr(X,Y)'[topV];[1:v][topV]overlay=(W-w)/2:(H-h)/2 -ss 0 -t 5 -y overlay2.mp4

使用ffmpeg将PNG图片序列转为透明背景视频的命令行如下：

ffmpeg -i %d.png -vcodec qtrle movie_with_alpha.mov

ffmpeg -i %d.png -vcodec ffvhuff movie_with_alpha.avi

ffmpeg -i %d.png -vcodec huffyuv movie_with_alpha.avi

绿幕视频变透明背景

#（将没有透明通道的mp4格式转换为带透明通道的mov）

'ffmpeg -i input.mp4 -vf "chromakey=0x00FF00:0.2:0.3" -c copy -c:v png output.mov'

#（这一行的输出结果在web端播放是透明的，在本地播放是绿幕）

'ffmpeg -y -i output.mov -vf "chromakey=0x00FF00:0.25:0.1" -c copy -c:v libvpx-vp9 -c:a libopus output.webm'

参数说明：

-vf: 指定应用于视频的视频过滤器。

chromakey: 指定要应用的视频过滤器名称，即绿幕抠图。

0x00FF00: 指定绿幕背景的颜色值，这里是绿色（RGB颜色值）。

0.2: 指定要抠图的颜色范围宽度，即相似度阈值。范围在0到1之间，数值越小则颜色抠图越精确。

0.3: 指定抠图时所使用的平滑因子，范围在0到1之间，数值越大则抠图结果越平滑。

按指定尺寸对视频进行裁剪

查看原视频尺寸

ffprobe -v error -select_streams v:0 -show_entries stream=width,height -of csv=s=x:p=0 input.mp4

例如，如果你想从一个1280x720的视频中裁剪出一个宽度为640，高度为480的视频片段，并且裁剪区域的左上角起始于位置(200, 100)，命令应该这样写：

ffmpeg -i input.mp4 -filter:v “crop=640:480:200:100” output.mp4

两个视频视频帧像素融合

如果你想要将两个视频的帧像素进行融合，可以使用FFmpeg的"blend"过滤器。下面是一个示例命令，展示了如何使用FFmpeg将两个视频的帧像素进行融合：

ffmpeg -i input1.mp4 -i input2.mp4 -filter_complex "[0:v][1:v]blend=all_expr='A*(if(gte(T,2),1,T/2))+B*(1-(if(gte(T,2),1,T/2)))'" output.mp4

这个命令假设你有两个输入文件，分别命名为input1.mp4和input2.mp4。命令会将两个视频的帧像素进行融合，并将输出保存为output.mp4。

你需要替换示例命令中的输入文件名和输出文件名，以适应你自己的文件。

在示例命令中，-filter_complex选项指定了复杂的过滤器图表。我们使用了"blend"过滤器，并通过表达式all_expr控制了帧像素的融合方式。

在这个示例中，我们使用了一个简单的线性混合表达式：

A*(if(gte(T,2),1,T/2))+B*(1-(if(gte(T,2),1,T/2)))

其中，A代表第一个输入视频的像素值，B代表第二个输入视频的像素值，T代表当前帧的时间。这个表达式的意思是，如果时间大于等于2秒，则完全显示第一个视频的像素值，否则将两个视频的像素按比例混合。

请注意，两个视频的分辨率和帧率应该是相同的，以便能够正确进行帧像素的融合

FFMPEG学习整理（FFMPEG官网）

FFMPEG下载

在 windows 环境，FFmpeg 有两个网址可以下载安装包。

0.点击进入官网

1，gyn FFmpeg build

2，BtbN FFmpeg-Builds

20230314重头来

一、ffmpeg介绍

文章最后有福利

FFmpeg是一套可以用来记录、转换数字音频、视频，并能将其转化为流的开源计算机程序。采用LGPL或GPL许可证。它提供了录制、转换以及流化音视频的完整解决方案。它包含了非常先进的音频/视频编解码库libavcodec，为了保证高可移植性和编解码质量，libavcodec里很多code都是从头开发的。

框图如图所示：

二、编解码基础知识

（1）封装格式

所谓封装格式是指音视频的组合格式，例如最常见的封装格式有mp4、mp3、flv等。简单来说，我们平时接触到的带有后缀的音视频文件都是一种封装格式。

（2）编码格式

以mp4为例，通常应该包含有视频和音频。视频的编码格式为YUV420P，音频的编码格式为PCM。再以YUV420编码格式为例。我们知道通常图像的显示为RGB（红绿蓝三原色），在视频压缩的时候会首先将代表每一帧画面的RGB压缩为YUV，再按照关键帧（I帧），过渡帧（P帧或B帧）进行运算和编码。解码的过程正好相反，解码器会读到I帧，并根据I帧运算和解码P帧以及B帧。并最终根据视频文件预设的FPS还原每一帧画面的RGB数据。最后推送给显卡。所以通常我们说的编码过程就包括：画面采集、转码、编码再封装。

（3）视频解码和音频解码有什么区别

FPS是图像领域中的定义，是指画面每秒传输帧数，通俗来讲就是指动画或视频的画面数。FPS太低画面会感觉闪烁不够连贯，FPS越高需要显卡性能越好。一些高速摄像机的采集速度能够达到11000帧/秒，那么在播放这类影片的时候我们是否也需要以11000帧/秒播放呢？当然不是，通常我们会按照25帧/秒或者60帧/秒设定图像的FPS值。但是由于视频存在关键帧和过渡帧的区别，关键帧保存了完整的画面而过渡帧只是保存了与前一帧画面的变化部分，需要通过关键帧计算获得。因此我们需要对每一帧都进行解码，即获取画面的YUV数据。同时只对我们真正需要显示的画面进行转码，即将YUV数据转换成RGB数据，包括计算画面的宽高等。

三、代码实现

（1）注册FFmpeg组件

//注册和初始化FFmpeg封装器和网络设备

（2）打开文件和创建输入设备

AVFormatContext 表示一个封装器，

在读取多媒体文件的时候，它负责保存与封装和编解码有关的上下文信息。

（3）遍历流并初始化解码器

封装器中保存了各种流媒体的通道，通常视频通道为0，音频通道为1。

除此以外可能还包含字幕流通道等。

第2步和第3步基本就是打开多媒体文件的主要步骤，

解码和转码的所有参数都可以在这里获取。

接下来我们就需要循环进行读取、解码、转码直到播放完成。

（4）读取压缩数据

/*之所以称为压缩数据主要是为了区分AVPacket和AVFrame两个结构体。

AVPacket表示一幅经过了关键帧或过渡帧编码后的画面，

AVFrame表示一个AVPacket经过解码后的完整YUV画面*/

（5）解码

（6）视频转码

// 720p输出标准

这里需要解释一下outWidth * outHeight * 4计算理由：

720p标准的视频画面包含720 * 480个像素点，

每一个像素点包含了RGBA4类数据，每一类数据分别由1个byte即8个bit表示。

因此一幅完整画面所占的大小为outWidth * outHeight * 4。

（7）音频转码

四、代码地址

基于qt的FFmpeg客户端（Linux版本）：

服务端可采用LIVE555服务器，参考博文：

1.1ffmpeg程序的使用

FFmpeg项目由以下几部分组成：

FFmpeg视频文件转换命令行工具,也支持经过实时电视卡抓取和编码成视频文件；
ffserver基于HTTP、RTSP用于实时广播的多媒体服务器.也支持时间平移；
ffplay用 SDL和FFmpeg库开发的一个简单的媒体播放器；
libavcodec一个包含了所有FFmpeg音视频编解码器的库。为了保证最优性能和高可复用性，大多数编解码器从头开发的；
libavformat一个包含了所有的普通音视格式的解析器和产生器的库。

1.2 谁在使用ffmpeg

使用FFMPEG作为内核视频播放器：Mplayer，ffplay，射手播放器，暴风影音，KMPlayer，QQ影音...
使用FFMPEG作为内核的Directshow Filter：ffdshow，lav filters...
使用FFMPEG作为内核的转码工具：ffmpeg，格式工厂...

2.如何安装

FFmpeg可以在Windows、Linux还有Mac OS等多种操作系统中进行安装和使用。

FFmpeg分为3个版本：Static、 Shared、 Dev

前两个版本可以直接在命令行中使用。包含了三个exe:ffmpeg.exe，ffplay.exe，ffprobe.exe
Static版本中的exe体积较大,那是因为相关的Dll都已经编译进exe里面去了。
Shared版本中exe的体积相对小很多,是因为它们运行的时候还需要到相关的dll中调用相应的功能
Dev版本用于开发,里面包含了库文件xxx.lib以及头文件xxx.h

3.怎么使用

3.1 命令行工具的使用

3.11 ffmpeg.exe

3.12 ffplay.exe

主要用于播放的应用程序

3.13 ffprobe.exe

ffprobe是用于查看文件格式的应用程序。

总结说明

常用API函数

1、注册、初始化相关函数

avdevice_register_all()：对设备进行注册，如V4L2。

avformat_network_init()：初始化网络库，以及网络加密协议相关的库，如openSSL。

2、封装格式相关函数

avformat_alloc_context()：申请一个AVFormatContext结构的内存，并进行简单初始化。

avformat_free_context()：释放AVFormatContext结构的内存。

avformat_close_input()：关闭解复用器；关闭后就不再需要使用avformat_free_context()进行释放。

avformat_open_input(AVFormatContext **ps, const char *url, ff_const59 AVInputFormat *fmt, AVDictionary **options)：打开输入视频文件。

参数说明：

AVFormatContext **ps, 格式化的上下文。要注意，如果传入的是一个AVFormatContext*的指针，则该空间须自己手动清理，若传入的指针为空，则FFmpeg会内部自己创建。

const char *filename, 传入的文件地址。支持http,RTSP,以及普通的本地文件。地址最终会存入到AVFormatContext结构体当中。

AVInputFormat *fmt, 指定输入的封装格式。一般传NULL，由FFmpeg自行探测。

AVDictionary **options, 其它参数设置。它是一个字典，用于参数传递，不传则写NULL);

avformat_find_stream_info()：获取音视频文件信息。

av_read_frame()：读取音视频包。

avformat_seek_file()：定位文件。

av_seek_frame()：定位文件。

封装应用流程

3、解码器相关函数

avcodec_alloc_context3()：分配解码器上下文。

avcodec_find_decoder()：根据ID查找解码器。

avcodec_find_decoder_by_name()：根据解码器名字查找解码器。

avcodec_open2()：打开编解码器。

avcodec_send_packet()：发送给编码数据包。

avcodec_receive_frame()：接收解码后数据。

avcodec_free_context()：释放解码器上下文，包含了avcodec_close()。

avcodec_close()：关闭解码器。

解码应用流程

常用数据结构

1、AVFormatContext

封装格式上下文结构体，也是统领全局的结构体，保存了视频文件封装格式相关信息。

iformat：输入媒体的AVInputFormat，比如指向AVInputFormat ff_flv_demuxer

nb_streams：输入媒体的AVStream 个数

streams：输入媒体的AVStream []数组

duration：输入媒体的时长（以微秒为单位），计算方式可以参考av_dump_format()函数。

bit_rate：输入媒体的码率

2、AVInputFormat

每种封装格式（例如FLV, MKV, MP4, AVI）对应一个该结构体。

name：封装格式名称

extensions：封装格式的扩展名

id：封装格式ID

一些封装格式处理的接口函数,比如read_packet()

3、AVStream

视频文件中每个视频（音频）流对应一个该结构体。

index：标识该视频/音频流

time_base：该流的时基， PTS*time_base=真正的时间（秒）

avg_frame_rate：该流的帧率

duration：该视频/音频流长度

codecpar：编解码器参数属性

4、AVCodecParameters

codec_type：媒体类型，比如AVMEDIA_TYPE_VIDEO AVMEDIA_TYPE_AUDIO等

codec_id：编解码器类型，比如AV_CODEC_ID_H264AV_CODEC_ID_AAC等。

5、AVCodecContext

编解码器上下文结构体，保存了视频（音频）编解码相关信息。

codec：编解码器的AVCodec，比如指向AVCodec ff_aac_latm_decoder

width, height：图像的宽高（只针对视频）

pix_fmt：像素格式（只针对视频）

sample_rate：采样率（只针对音频）

channels：声道数（只针对音频）

sample_fmt：采样格式（只针对音频）

6、AVCodec

每种视频（音频）编解码器(例如H.264解码器)对应一个该结构体。

name：编解码器名称

type：编解码器类型

id：编解码器ID

一些编解码的接口函数，比如int (*decode)()

7、AVPacket

存储一帧压缩编码数据。

pts：显示时间戳

dts：解码时间戳

data：压缩编码数据

size：压缩编码数据大小

pos:数据的偏移地址

stream_index：所属的AVStream

8、AVFrame

存储一帧解码后像素（采样）数据。

data：解码后的图像像素数据（音频采样数据）

linesize：对视频来说是图像中一行像素的大小；对音频来说是整个音频帧的大小

width, height：图像的宽高（只针对视频）

key_frame：是否为关键帧（只针对视频）。

pict_type：帧类型（只针对视频）。例如I， P， B

sample_rate：音频采样率（只针对音频）

nb_samples：音频每通道采样数（只针对音频）

pts：显示时间戳

9、AVOutputFormat

1）描述

AVOutputFormat 表示输出文件容器格式，AVOutputFormat结构主要包含的信息有：

封装名称描述

编码格式信息（video/audio 默认编码格式，支持的编码格式列表）

对封装的操作函数（write_header,write_packet,write_tailer等）

ffmpeg支持各种各样的输出文件格式，MP4，FLV，3GP等。

AVOutputFormat结构保存了这些格式的信息和一些常规设置。

解压

static void decode(AVCodecContext *dec_ctx, AVFrame *frame, AVPacket *pkt,

const char *filename)

{

char buf[1024];

int ret;

ret = avcodec_send_packet(dec_ctx, pkt);

if (ret < 0) {

fprintf(stderr, "Error sending a packet for decoding\n");

exit(1);

}

while (ret >= 0) {

ret = avcodec_receive_frame(dec_ctx, frame);

if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)

return;

else if (ret < 0) {

fprintf(stderr, "Error during decoding\n");

exit(1);

}

printf("saving frame %3d\n", dec_ctx->frame_number);

fflush(stdout);

/* the picture is allocated by the decoder. no need to

free it */

snprintf(buf, sizeof(buf), "%s-%d", filename, dec_ctx->frame_number);

pgm_save(frame->data[0], frame->linesize[0],

frame->width, frame->height, buf);

}

压缩：

static void encode(AVCodecContext *enc_ctx, AVFrame *frame, AVPacket *pkt,

FILE *outfile)

{

int ret;

/* send the frame to the encoder */

if (frame)

printf("Send frame %3"PRId64"\n", frame->pts);

ret = avcodec_send_frame(enc_ctx, frame);

if (ret < 0) {

fprintf(stderr, "Error sending a frame for encoding\n");

exit(1);

}

while (ret >= 0) {

ret = avcodec_receive_packet(enc_ctx, pkt);

if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)

return;

else if (ret < 0) {

fprintf(stderr, "Error during encoding\n");

exit(1);

}

printf("Write packet %3"PRId64" (size=%5d)\n", pkt->pts, pkt->size);

fwrite(pkt->data, 1, pkt->size, outfile);

av_packet_unref(pkt);

}

视频解压

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <libavcodec/avcodec.h>

#define INBUF_SIZE 4096

static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,

char *filename)

{

FILE *f;

int i;

f = fopen(filename,"w");

fprintf(f, "P5\n%d %d\n%d\n", xsize, ysize, 255);

for (i = 0; i < ysize; i++)

fwrite(buf + i * wrap, 1, xsize, f);

fclose(f);

}

static void decode(AVCodecContext *dec_ctx, AVFrame *frame, AVPacket *pkt,

const char *filename)

{

char buf[1024];

int ret;

ret = avcodec_send_packet(dec_ctx, pkt);

if (ret < 0) {

fprintf(stderr, "Error sending a packet for decoding\n");

exit(1);

}

while (ret >= 0) {

ret = avcodec_receive_frame(dec_ctx, frame);

if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)

return;

else if (ret < 0) {

fprintf(stderr, "Error during decoding\n");

exit(1);

}

printf("saving frame %3d\n", dec_ctx->frame_number);

fflush(stdout);

/* the picture is allocated by the decoder. no need to

free it */

snprintf(buf, sizeof(buf), "%s-%d", filename, dec_ctx->frame_number);

pgm_save(frame->data[0], frame->linesize[0],

frame->width, frame->height, buf);

}

int main(int argc, char **argv)

{

const char *filename, *outfilename;

const AVCodec *codec;

AVCodecParserContext *parser;

AVCodecContext *c= NULL;

FILE *f;

AVFrame *frame;

uint8_t inbuf[INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];

uint8_t *data;

size_t data_size;

int ret;

AVPacket *pkt;

if (argc <= 2) {

fprintf(stderr, "Usage: %s <input file> <output file>\n"

"And check your input file is encoded by mpeg1video please.\n", argv[0]);

exit(0);

}

filename = argv[1];

outfilename = argv[2];

pkt = av_packet_alloc();

if (!pkt)

exit(1);

/* set end of buffer to 0 (this ensures that no overreading happens for damaged MPEG streams) */

memset(inbuf + INBUF_SIZE, 0, AV_INPUT_BUFFER_PADDING_SIZE);

/* find the MPEG-1 video decoder */

codec = avcodec_find_decoder(AV_CODEC_ID_MPEG1VIDEO);

if (!codec) {

fprintf(stderr, "Codec not found\n");

exit(1);

}

parser = av_parser_init(codec->id);

if (!parser) {

fprintf(stderr, "parser not found\n");

exit(1);

}

c = avcodec_alloc_context3(codec);

if (!c) {

fprintf(stderr, "Could not allocate video codec context\n");

exit(1);

}

/* For some codecs, such as msmpeg4 and mpeg4, width and height

MUST be initialized there because this information is not

available in the bitstream. */

/* open it */

if (avcodec_open2(c, codec, NULL) < 0) {

fprintf(stderr, "Could not open codec\n");

exit(1);

}

f = fopen(filename, "rb");

if (!f) {

fprintf(stderr, "Could not open %s\n", filename);

exit(1);

}

frame = av_frame_alloc();

if (!frame) {

fprintf(stderr, "Could not allocate video frame\n");

exit(1);

}

while (!feof(f)) {

/* read raw data from the input file */

data_size = fread(inbuf, 1, INBUF_SIZE, f);

if (!data_size)

break;

/* use the parser to split the data into frames */

data = inbuf;

while (data_size > 0) {

ret = av_parser_parse2(parser, c, &pkt->data, &pkt->size,

data, data_size, AV_NOPTS_VALUE, AV_NOPTS_VALUE, 0);

if (ret < 0) {

fprintf(stderr, "Error while parsing\n");

exit(1);

}

data += ret;

data_size -= ret;

if (pkt->size)

decode(c, frame, pkt, outfilename);

}

/* flush the decoder */

decode(c, frame, NULL, outfilename);

fclose(f);

av_parser_close(parser);

avcodec_free_context(&c);

av_frame_free(&frame);

av_packet_free(&pkt);

return 0;

}

音频解压

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <libavutil/frame.h>

#include <libavutil/mem.h>

#include <libavcodec/avcodec.h>

#define AUDIO_INBUF_SIZE 20480

#define AUDIO_REFILL_THRESH 4096

static int get_format_from_sample_fmt(const char **fmt,

enum AVSampleFormat sample_fmt)

{

int i;

struct sample_fmt_entry {

enum AVSampleFormat sample_fmt; const char *fmt_be, *fmt_le;

} sample_fmt_entries[] = {

{ AV_SAMPLE_FMT_U8, "u8", "u8" },

{ AV_SAMPLE_FMT_S16, "s16be", "s16le" },

{ AV_SAMPLE_FMT_S32, "s32be", "s32le" },

{ AV_SAMPLE_FMT_FLT, "f32be", "f32le" },

{ AV_SAMPLE_FMT_DBL, "f64be", "f64le" },

};

*fmt = NULL;

for (i = 0; i < FF_ARRAY_ELEMS(sample_fmt_entries); i++) {

struct sample_fmt_entry *entry = &sample_fmt_entries[i];

if (sample_fmt == entry->sample_fmt) {

*fmt = AV_NE(entry->fmt_be, entry->fmt_le);

return 0;

}

fprintf(stderr,

"sample format %s is not supported as output format\n",

av_get_sample_fmt_name(sample_fmt));

return -1;

}

static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame,

FILE *outfile)

{

int i, ch;

int ret, data_size;

/* send the packet with the compressed data to the decoder */

ret = avcodec_send_packet(dec_ctx, pkt);

if (ret < 0) {

fprintf(stderr, "Error submitting the packet to the decoder\n");

exit(1);

}

/* read all the output frames (in general there may be any number of them */

while (ret >= 0) {

ret = avcodec_receive_frame(dec_ctx, frame);

if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)

return;

else if (ret < 0) {

fprintf(stderr, "Error during decoding\n");

exit(1);

}

data_size = av_get_bytes_per_sample(dec_ctx->sample_fmt);

if (data_size < 0) {

/* This should not occur, checking just for paranoia */

fprintf(stderr, "Failed to calculate data size\n");

exit(1);

}

for (i = 0; i < frame->nb_samples; i++)

for (ch = 0; ch < dec_ctx->channels; ch++)

fwrite(frame->data[ch] + data_size*i, 1, data_size, outfile);

}

int main(int argc, char **argv)

{

const char *outfilename, *filename;

const AVCodec *codec;

AVCodecContext *c= NULL;

AVCodecParserContext *parser = NULL;

int len, ret;

FILE *f, *outfile;

uint8_t inbuf[AUDIO_INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];

uint8_t *data;

size_t data_size;

AVPacket *pkt;

AVFrame *decoded_frame = NULL;

enum AVSampleFormat sfmt;

int n_channels = 0;

const char *fmt;

if (argc <= 2) {

fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);

exit(0);

}

filename = argv[1];

outfilename = argv[2];

pkt = av_packet_alloc();

/* find the MPEG audio decoder */

codec = avcodec_find_decoder(AV_CODEC_ID_MP2);

if (!codec) {

fprintf(stderr, "Codec not found\n");

exit(1);

}

parser = av_parser_init(codec->id);

if (!parser) {

fprintf(stderr, "Parser not found\n");

exit(1);

}

c = avcodec_alloc_context3(codec);

if (!c) {

fprintf(stderr, "Could not allocate audio codec context\n");

exit(1);

}

/* open it */

if (avcodec_open2(c, codec, NULL) < 0) {

fprintf(stderr, "Could not open codec\n");

exit(1);

}

f = fopen(filename, "rb");

if (!f) {

fprintf(stderr, "Could not open %s\n", filename);

exit(1);

}

outfile = fopen(outfilename, "wb");

if (!outfile) {

av_free(c);

exit(1);

}

/* decode until eof */

data = inbuf;

data_size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);

while (data_size > 0) {

if (!decoded_frame) {

if (!(decoded_frame = av_frame_alloc())) {

fprintf(stderr, "Could not allocate audio frame\n");

exit(1);

}

ret = av_parser_parse2(parser, c, &pkt->data, &pkt->size,

data, data_size,

AV_NOPTS_VALUE, AV_NOPTS_VALUE, 0);

if (ret < 0) {

fprintf(stderr, "Error while parsing\n");

exit(1);

}

data += ret;

data_size -= ret;

if (pkt->size)

decode(c, pkt, decoded_frame, outfile);

if (data_size < AUDIO_REFILL_THRESH) {

memmove(inbuf, data, data_size);

data = inbuf;

len = fread(data + data_size, 1,

AUDIO_INBUF_SIZE - data_size, f);

if (len > 0)

data_size += len;

}

/* flush the decoder */

pkt->data = NULL;

pkt->size = 0;

decode(c, pkt, decoded_frame, outfile);

/* print output pcm infomations, because there have no metadata of pcm */

sfmt = c->sample_fmt;

if (av_sample_fmt_is_planar(sfmt)) {

const char *packed = av_get_sample_fmt_name(sfmt);

printf("Warning: the sample format the decoder produced is planar "

"(%s). This example will output the first channel only.\n",

packed ? packed : "?");

sfmt = av_get_packed_sample_fmt(sfmt);

}

n_channels = c->channels;

if ((ret = get_format_from_sample_fmt(&fmt, sfmt)) < 0)

goto end;

printf("Play the output audio file with the command:\n"

"ffplay -f %s -ac %d -ar %d %s\n",

fmt, n_channels, c->sample_rate,

outfilename);

end:

fclose(outfile);

fclose(f);

avcodec_free_context(&c);

av_parser_close(parser);

av_frame_free(&decoded_frame);

av_packet_free(&pkt);

return 0;

}

视频压缩

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <libavcodec/avcodec.h>

#include <libavutil/opt.h>

#include <libavutil/imgutils.h>

static void encode(AVCodecContext *enc_ctx, AVFrame *frame, AVPacket *pkt,

FILE *outfile)

{

int ret;

/* send the frame to the encoder */

if (frame)

printf("Send frame %3"PRId64"\n", frame->pts);

ret = avcodec_send_frame(enc_ctx, frame);

if (ret < 0) {

fprintf(stderr, "Error sending a frame for encoding\n");

exit(1);

}

while (ret >= 0) {

ret = avcodec_receive_packet(enc_ctx, pkt);

if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)

return;

else if (ret < 0) {

fprintf(stderr, "Error during encoding\n");

exit(1);

}

printf("Write packet %3"PRId64" (size=%5d)\n", pkt->pts, pkt->size);

fwrite(pkt->data, 1, pkt->size, outfile);

av_packet_unref(pkt);

}

int main(int argc, char **argv)

{

const char *filename, *codec_name;

const AVCodec *codec;

AVCodecContext *c= NULL;

int i, ret, x, y;

FILE *f;

AVFrame *frame;

AVPacket *pkt;

uint8_t endcode[] = { 0, 0, 1, 0xb7 };

if (argc <= 2) {

fprintf(stderr, "Usage: %s <output file> <codec name>\n", argv[0]);

exit(0);

}

filename = argv[1];

codec_name = argv[2];

/* find the mpeg1video encoder */

codec = avcodec_find_encoder_by_name(codec_name);

if (!codec) {

fprintf(stderr, "Codec '%s' not found\n", codec_name);

exit(1);

}

c = avcodec_alloc_context3(codec);

if (!c) {

fprintf(stderr, "Could not allocate video codec context\n");

exit(1);

}

pkt = av_packet_alloc();

if (!pkt)

exit(1);

/* put sample parameters */

c->bit_rate = 400000;

/* resolution must be a multiple of two */

c->width = 352;

c->height = 288;

/* frames per second */

c->time_base = (AVRational){1, 25};

c->framerate = (AVRational){25, 1};

/* emit one intra frame every ten frames

* check frame pict_type before passing frame

* to encoder, if frame->pict_type is AV_PICTURE_TYPE_I

* then gop_size is ignored and the output of encoder

* will always be I frame irrespective to gop_size

c->gop_size = 10;

c->max_b_frames = 1;

c->pix_fmt = AV_PIX_FMT_YUV420P;

if (codec->id == AV_CODEC_ID_H264)

av_opt_set(c->priv_data, "preset", "slow", 0);

/* open it */

ret = avcodec_open2(c, codec, NULL);

if (ret < 0) {

fprintf(stderr, "Could not open codec: %s\n", av_err2str(ret));

exit(1);

}

f = fopen(filename, "wb");

if (!f) {

fprintf(stderr, "Could not open %s\n", filename);

exit(1);

}

frame = av_frame_alloc();

if (!frame) {

fprintf(stderr, "Could not allocate video frame\n");

exit(1);

}

frame->format = c->pix_fmt;

frame->width = c->width;

frame->height = c->height;

ret = av_frame_get_buffer(frame, 32);

if (ret < 0) {

fprintf(stderr, "Could not allocate the video frame data\n");

exit(1);

}

/* encode 1 second of video */

for (i = 0; i < 25; i++) {

fflush(stdout);

/* make sure the frame data is writable */

ret = av_frame_make_writable(frame);

if (ret < 0)

exit(1);

/* prepare a dummy image */

/* Y */

for (y = 0; y < c->height; y++) {

for (x = 0; x < c->width; x++) {

frame->data[0][y * frame->linesize[0] + x] = x + y + i * 3;

}

/* Cb and Cr */

for (y = 0; y < c->height/2; y++) {

for (x = 0; x < c->width/2; x++) {

frame->data[1][y * frame->linesize[1] + x] = 128 + y + i * 2;

frame->data[2][y * frame->linesize[2] + x] = 64 + x + i * 5;

}

frame->pts = i;

/* encode the image */

encode(c, frame, pkt, f);

}

/* flush the encoder */

encode(c, NULL, pkt, f);

/* add sequence end code to have a real MPEG file */

if (codec->id == AV_CODEC_ID_MPEG1VIDEO || codec->id == AV_CODEC_ID_MPEG2VIDEO)

fwrite(endcode, 1, sizeof(endcode), f);

fclose(f);

avcodec_free_context(&c);

av_frame_free(&frame);

av_packet_free(&pkt);

return 0;

}

音频压缩

#include <stdint.h>

#include <stdio.h>

#include <stdlib.h>

#include <libavcodec/avcodec.h>

#include <libavutil/channel_layout.h>

#include <libavutil/common.h>

#include <libavutil/frame.h>

#include <libavutil/samplefmt.h>

/* check that a given sample format is supported by the encoder */

static int check_sample_fmt(const AVCodec *codec, enum AVSampleFormat sample_fmt)

{

const enum AVSampleFormat *p = codec->sample_fmts;

while (*p != AV_SAMPLE_FMT_NONE) {

if (*p == sample_fmt)

return 1;

p++;

}

return 0;

}

/* just pick the highest supported samplerate */

static int select_sample_rate(const AVCodec *codec)

{

const int *p;

int best_samplerate = 0;

if (!codec->supported_samplerates)

return 44100;

p = codec->supported_samplerates;

while (*p) {

if (!best_samplerate || abs(44100 - *p) < abs(44100 - best_samplerate))

best_samplerate = *p;

p++;

}

return best_samplerate;

}

/* select layout with the highest channel count */

static int select_channel_layout(const AVCodec *codec)

{

const uint64_t *p;

uint64_t best_ch_layout = 0;

int best_nb_channels = 0;

if (!codec->channel_layouts)

return AV_CH_LAYOUT_STEREO;

p = codec->channel_layouts;

while (*p) {

int nb_channels = av_get_channel_layout_nb_channels(*p);

if (nb_channels > best_nb_channels) {

best_ch_layout = *p;

best_nb_channels = nb_channels;

}

p++;

}

return best_ch_layout;

}

static void encode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt,

FILE *output)

{

int ret;

/* send the frame for encoding */

ret = avcodec_send_frame(ctx, frame);

if (ret < 0) {

fprintf(stderr, "Error sending the frame to the encoder\n");

exit(1);

}

/* read all the available output packets (in general there may be any

* number of them */

while (ret >= 0) {

ret = avcodec_receive_packet(ctx, pkt);

if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)

return;

else if (ret < 0) {

fprintf(stderr, "Error encoding audio frame\n");

exit(1);

}

fwrite(pkt->data, 1, pkt->size, output);

av_packet_unref(pkt);

}

int main(int argc, char **argv)

{

const char *filename;

const AVCodec *codec;

AVCodecContext *c= NULL;

AVFrame *frame;

AVPacket *pkt;

int i, j, k, ret;

FILE *f;

uint16_t *samples;

float t, tincr;

if (argc <= 1) {

fprintf(stderr, "Usage: %s <output file>\n", argv[0]);

return 0;

}

filename = argv[1];

/* find the MP2 encoder */

codec = avcodec_find_encoder(AV_CODEC_ID_MP2);

if (!codec) {

fprintf(stderr, "Codec not found\n");

exit(1);

}

c = avcodec_alloc_context3(codec);

if (!c) {

fprintf(stderr, "Could not allocate audio codec context\n");

exit(1);

}

/* put sample parameters */

c->bit_rate = 64000;

/* check that the encoder supports s16 pcm input */

c->sample_fmt = AV_SAMPLE_FMT_S16;

if (!check_sample_fmt(codec, c->sample_fmt)) {

fprintf(stderr, "Encoder does not support sample format %s",

av_get_sample_fmt_name(c->sample_fmt));

exit(1);

}

/* select other audio parameters supported by the encoder */

c->sample_rate = select_sample_rate(codec);

c->channel_layout = select_channel_layout(codec);

c->channels = av_get_channel_layout_nb_channels(c->channel_layout);

/* open it */

if (avcodec_open2(c, codec, NULL) < 0) {

fprintf(stderr, "Could not open codec\n");

exit(1);

}

f = fopen(filename, "wb");

if (!f) {

fprintf(stderr, "Could not open %s\n", filename);

exit(1);

}

/* packet for holding encoded output */

pkt = av_packet_alloc();

if (!pkt) {

fprintf(stderr, "could not allocate the packet\n");

exit(1);

}

/* frame containing input raw audio */

frame = av_frame_alloc();

if (!frame) {

fprintf(stderr, "Could not allocate audio frame\n");

exit(1);

}

frame->nb_samples = c->frame_size;

frame->format = c->sample_fmt;

frame->channel_layout = c->channel_layout;

/* allocate the data buffers */

ret = av_frame_get_buffer(frame, 0);

if (ret < 0) {

fprintf(stderr, "Could not allocate audio data buffers\n");

exit(1);

}

/* encode a single tone sound */

t = 0;

tincr = 2 * M_PI * 440.0 / c->sample_rate;

for (i = 0; i < 200; i++) {

/* make sure the frame is writable -- makes a copy if the encoder

* kept a reference internally */

ret = av_frame_make_writable(frame);

if (ret < 0)

exit(1);

samples = (uint16_t*)frame->data[0];

for (j = 0; j < c->frame_size; j++) {

samples[2*j] = (int)(sin(t) * 10000);

for (k = 1; k < c->channels; k++)

samples[2*j + k] = samples[2*j];

t += tincr;

}

encode(c, frame, pkt, f);

}

/* flush the encoder */

encode(c, NULL, pkt, f);

fclose(f);

av_frame_free(&frame);

av_packet_free(&pkt);

avcodec_free_context(&c);

return 0;

}

ffmpeg常用api介绍

av_log_set_callback

函数原型：

void av_log_set_callback(void(*)(void *, int, const char *, va_list) callback)

设置日志打印的回调。

av_log

函数原型：

void av_log(void* avcl, int level, const char *fmt, ...)

输出日志。

av_malloc

av_malloc()就是简单的封装了系统函数malloc()，并做了一些错误检查工作。

avformat_alloc_output_context2()

函数原型

int avformat_alloc_output_context2(AVFormatContext **ctx, AVOutputFormat * oformat, const char * format_name, const char * filename)

初始化一个用于输出的AVFormatContext结构体

avformat_network_init

全局地初始化网络组件，需要用到网络功能的时候需要调用。

av_register_all

初始化libavformat和注册所有的复用器和解复用器和协议。

如果不调用这个函数，可以使用av_register_input_format()和av_register_out_format()来选择支持的格式。

AVPacket

AVPacket是存储压缩编码数据的数据结构。

通常是解复用器的输出，然后被传递给解码器。或者是编码器的输出，然后被传递给复用器。

AVPacket.size:data的大小。

AVPacket.dts:解码时间戳。

AVPacket.stream_index:标识该AVPacket所属的视频/音频流。

av_copy_packet

函数原型：

int av_copy_packet(AVPacket * dst, const AVPacket * src)

复制packet，包含内容。

av_packet_unref

函数原型：

void av_packet_unref(AVPacket * pkt)

解除packet引用的buffer，并且将其余的字段重置为默认值。

AVCodecContext

这是一个描述解码器上下文的数据结构，包含了众多编解码器需要的参数信息。

AVCodec

存储编码器信息的结构体。

主要包含以下信息：

const char *name：编解码器的名字的简称

const char *long_name：编解码器名字的全称

enum AVMediaType type：指明了类型，是视频，音频，还是字幕

enum AVCodecID id：ID，不重复

const AVRational *supported_framerates：支持的帧率（仅视频）

const enum AVPixelFormat *pix_fmts：支持的像素格式（仅视频）,如RGB24、YUV420P等。

const int *supported_samplerates：支持的采样率（仅音频）

const enum AVSampleFormat *sample_fmts：支持的采样格式（仅音频）

const uint64_t *channel_layouts：支持的声道数（仅音频）

int priv_data_size：私有数据的大小

avcodec_send_packet

将原始分组数据作为解码器的输入。

在函数内部，会拷贝相关的AVCodecContext结构变量，将这些结构变量应用到解码的每一个包。例如

AVCodecContext.skip_frame参数通知解码器扔掉包含该帧的包。

avcodec_alloc_context3()

创建AVCodecContext结构体。

avcodec_parameters_to_context

将音频流信息拷贝到新的AVCodecContext结构体中。

avcodec_free_context

释放AVCodecContext和与之相关联的所有内容，并且把指针置空。

avcodec_open2

原型：

int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)

使用给定的AVCodec初始化AVCodecContext。

在使用这个函数之前需要使用avcodec_alloc_context3()分配的context。

av_frame_alloc

原型

AVFrame* av_frame_alloc(void)

分配一个avframe和设置字段的默认值。分配出来的AVFrame必须使用av_frame_free()释放。

avcodec_receive_frame

原型

int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)

返回解码器输出的解码数据

av_read_pause

原型

int av_read_pause(AVFormatContext *s)

暂停网络流（例如RSTP流），使用av_read_play()重新开始。

av_read_play

原型

int av_read_play(AVFrameContext *s)

从当前的位置开始播放网络流（例如RSTP流）。

av_seek_frame

原型

int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)

seek到某个时间点的关键帧。

av_read_frame

原型

int av_read_frame(AVFormatContext *s, AVPacket *pkt)

读取码流中的音频若干帧或者视频一帧。例如，解码视频的时候，每解码一个视频帧，需要先调用av_read_frame()获得一帧视频的压缩数据，然后才能对该数据进行解码。

AVFormatContext

这个结构体描述了一个媒体文件或媒体流的构成和基本信息。

这是FFMpeg中最为基本的一个结构，是其他所有结构的根，是一个多媒体文件或流的根本抽象。

avformat_alloc_context

分配一个AVFormatContext，使用avformat_free_context来释放分配出来的AVFormatContext。

avformat_open_input

原型

int avformat_open_input(AVFormatContext **ps, const char *url, AVInputFormat *fmt, AVDictionary **options)

打开输出的流和读取头信息。需要使用avformat_close_input关闭打开的流。

avformat_close_input

原型

void avformat_close_input(AVFormatContext **s)

关闭一个打开的输入AVFormatContext，释放它得很所有内容和把指针(*s)置空。

av_dump_format

原型

void av_dump_format(AVFormatContext *ic, int index, const char * url, int is_output)

打印输入或者输出格式的详细信息，比如duration, bitrate, streams, container, programs, metadata, side data, codec and time base。

avformat_new_stream

原型

AVStream* avformat_new_stream(AVFormatContext *s, const AVCodec* c)

添加一个stream到媒体文件中。

avformat_write_header

原型

int avformat_write_header(AVFormatContext *s, AVDictionary ** options)

分配一个stream的私有数据而且写stream的header到一个输出的媒体文件。

AVPixelFormat

像素格式的枚举类型，例如AV_PIX_FMT_YUV420P、AV_PIX_FMT_RGB24

AVMediaType

媒体类型的枚举类型，如AVMEDIA_TYPE_VIDEO(视频)、AVMEDIA_TYPE_AUDIO(音频)、AVMEDIA_TYPE_SUBTITLE(字幕)

avformat_find_stream_info

原型

int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)

读取视音频数据来获取一些相关的信息。

av_file_map

原型：

av_file_map(const char *filename, uint8_t **bufptr, size_t * size, int log_offset, void * log_ctx)

读取文件名为filename的文件，并将其内容放入新分配的缓冲区中。

如果成功，则将bufptr设置为读缓冲区或映射缓冲区，并将size设置为*bufptr中缓冲区的字节大小。返回的缓冲区必须使用av_file_unmap()释放。

AVInputFormat

AVInputFormat为FFMPEG的解复用器对象。

AVStream

该结构体描述一个媒体流。

AVCodecParameters

该结构体描述了编码的流的属性。

avcodec_parameters_copy

原型

int avcodec_parameters_copy(AVCodecParameter *dst, const AVCodecParameter* src)

把src中的内容拷贝到dst中。

AVRational

这个结构标识一个分数，num为分数，den为分母。

AVCodecID

解码器标识ID的枚举类型。

swr_alloc

原型

struct SwrContext* swr_alloc(void)

分配一个SwrContext，如果你使用这个函数，需要在调用swr_init()之前设置SwrContext的参数（手工的或者调用swr_alloc_set_opts()）

SwrContext

libswresample 的上下文信息。

不像libavcodec和libavformat，这个结构是不透明的，如果你需要设置选项，你必须使用AVOptions而不能直接给这个结构的成员赋值。

swr_alloc_set_opts

原型

struct SwrContext* swr_alloc_set_opts(struct SwrContext *s,

int64_t out_ch_layout,

enum AVSampleFormat out_sample_fmt,

int out_sample_rate,

int64_t in_ch_layout,

enum AVSampleFormat in_sample_fmt,

int in_sample_rate,

int log_offset,

void *log_ctx

)

设置通用的参数，如果SwrContext为空则分配一个SwrContext。

swr_init

原型

init swr_init(struct SwrContext *s)

在参数设置好以后初始化context。

swr_free

原型

void swr_free(struct SwrContext ** s)

释放给定的SwrContext，并且把指针置为空。

sws_getContext

原型

struct SwsContext* sws_getContext ( int srcW,

int srcH,

enum AVPixelFormat srcFormat,

int dstW,

int dstH,

enum AVPixelFormat dstFormat,

int flags,

SwsFilter * srcFilter,

SwsFilter * dstFilter,

const double * param

)

分配和返回一个SwsContext。

avio_open

原型

int avio_open(AVIOContext **s, const char* filename, int flags)

创建和初始化一个AVIOContext用于访问filename指示的资源。

avio_closep

原型

int avio_closep(AVIOContext **s)

关闭AVIOContext** s打开的资源，释放它并且把指针置为空。

AV_ROUND

AV_ROUND_ZERO = 0, // Round toward zero. 趋近于0

AV_ROUND_INF = 1, // Round away from zero. 趋远于0

AV_ROUND_DOWN = 2, // Round toward -infinity. 趋于更小的整数

AV_ROUND_UP = 3, // Round toward +infinity. 趋于更大的整数

AV_ROUND_NEAR_INF = 5, // Round to nearest and halfway cases away from zero.

// 四舍五入,小于0.5取值趋向0,大于0.5取值趋远于0

avio_alloc_context

原型

AVIOContext* avio_alloc_context(unsigned char* buffer,

int buffer_size,

int write_flag,

void* opaque,

int(*)(void *opaque, uint8_t *buf, int buf_size) read_packet,

int(*)(void *opaque, uint8_t *buf, int buf_size) write_packet,

int64_t(*)(void *opaque, int64_t offset, int whence) seek)

分配和初始化一个AVIOContext用于缓冲的I/O。之后需要使用avio_context_free()释放。

av_file_unmap

原型

void av_file_unmap(uint8_t *bufptr, size_t size)

取消映射或释放av_file_map()创建的缓冲区bufptr。

作者：smallest_one

链接：https://www.jianshu.com/p/b6b8c185a617

来源：简书

简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

=======================================================

//打开一个封装文件

avformat_open_input(&fmt_ctx, input_filename, NULL, NULL);

//获得封装文件的streamer流信息

avformat_find_stream_info(fmt_ctx, NULL);

//获得封装文件中音频或者视频流的id号

av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);

//获得音频或视频的codec

pCodecCtx = pFormatCtx->streams[0]->codec;

pCodec = avcodec_find_decoder(pCodecCtx->codec_id); /

origin_par = fmt_ctx->streams[video_stream]->codecpar;

codec = avcodec_find_decoder(origin_par->codec_id);

avcodec_find_encoder(AV_CODEC_ID_FLAC);

//打开codec

avcodec_open2(pCodecCtx, pCodec, NULL);

//根据AVCodec创建AVCodecContext

AVCodecContext* ctx = avcodec_alloc_context3((AVCodec*)enc);

//申请一帧画面的大小

byte_buffer_size = av_image_get_buffer_size(pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height, 16);

byte_buffer = av_malloc(byte_buffer_size);

//申请音频的大小

byte_buffer_size = av_samples_get_buffer_size(NULL, pCodecCtx->channels, pCodecCtx->sample_rate, pCodecCtx->sample_fmt, 1);

//读取封装文件里的一包数据

av_read_frame(pFormatCtx, &rd_packet);

保存此一包数据(比如h264压缩数据)

fwrite(rd_packet.data, 1, rd_packet.size, video_fp);

//AVPAcket/AVFrame的申请以及初始化操作

av_init_packet(&pkt);

fr = av_frame_alloc();

//解码成yuv的AVFrame

avcodec_decode_video2(ctx, fr, &got_frame, &pkt);

//将AVFrame结构体保存的一帧yuv数据转换成unsigned char*

number_of_written_bytes = av_image_copy_to_buffer(byte_buffer, byte_buffer_size, (const uint8_t* const *)fr->data, (const int*) fr->linesize, ctx->pix_fmt, ctx->width, ctx->height, 1);/

out_frame_bytes = out_frame->nb_samples * out_frame->channels * sizeof(uint16_t);

memcpy(raw_out + out_offset, out_frame->data[0], out_frame_bytes);

out_offset += out_frame_bytes;

//AVFrame中buffer分配的两种方式(只是分配空间)

msg.frame->format = AV_PIX_FMT_RGBA;

msg.frame->width = 320;

msg.frame->height = 240;

ret = av_frame_get_buffer(msg.frame, 32); //int av_frame_get_buffer(AVFrame *frame, int align);

av_frame_get_buffer(in_frame, 32);

int av_image_alloc(uint8_t *pointers[4], int linesizes[4], int w, int h, enum AVPixelFormat pix_fmt, int align);

out_frame = av_frame_alloc();

avcodec_encode_audio2(enc_ctx, &enc_pkt, in_frame, &got_output); //编码

avcodec_decode_audio4(dec_ctx, out_frame, &got_output, &enc_pkt); //解码

//线程相关

av_thread_message_queue_send(wd->queue, &msg, 0);

av_thread_message_queue_recv(rd->queue, &msg, 0);

//FFmpeg进行H.264编码

yuv->pts = vpts;

vpts++;

avcodec_send_frame(vc, yuv);

avcodec_receive_packet(vc, &pack);

//FFmpeg进行视频格式封装和推流

pack.pts = av_rescale_q(pack.pts, vc->time_base, vs->time_base);

pack.dts = av_rescale_q(pack.dts, vc->time_base, vs->time_base);

pack.duration = av_rescale_q(pack.duration, vc->time_base, vs->time_base);

//像素格式转换

sws_getCachedContext()

sws_scale()

///实例介绍

https://linux.cn/article-10932-1.html

//封装格式变换:

ffmpeg -i z.flv -strict -2 z.mp4

ffmpeg -i z.flv -qscale 0 -strict -2 z.avi //-qscale 0 维持你的源视频文件的质量

//视频封装文件保存为音频文件

ffmpeg -i z.flv -vn -ar 44100 -ac 2 -ab 320 -f mp3 output.mp3

ffmpeg -i z.flv -vn(禁止视频) -ar 44100(采样率) -ac(通道数) 2 -ab(比特率) 320 -f(输出文件格式) mp3 output.mp3

//更改视频文件的分辨率

ffmpeg -i z.mp4 -filter:v scale=1280:720 -c:a copy output.mp4

ffmpeg -i input.mp4 -s 1280x720 -c:a copy output.mp4

ffmpeg -i z.mp4 -filter:v(视频过滤器) scale(拉伸过滤器)=1280:720 -c:a copy output.mp4

ffmpeg -i input.mp4 -s(尺寸裁剪) 1280x720 -c:a copy output.mp4

//压缩视频文件

//压缩音频文件(减少通道数,采样率,比特率等)

ffmpeg -i input.mp3 -ab 128 output.mp3

//从封装文件中获取视频流

ffmpeg -i z.mp4 -an video.mp4

//从封装文件中获取音频流

ffmpeg -i z.mp4 -vn audio.mp4

ffmpeg -i z.mp4 -vn -ab 256 -ar 48000 audio.mp3

//从视频中提取图片

ffmpeg -i input.mp4 -r 1 -f image2 image-%2d.png

ffmpeg -i input.mp4 -r(每秒钟提取一张图片(视频30s,则会提取30张图片)) 1 -f image2 image-%2d.png

//裁剪视频

ffmpeg -i input.mp4 -filter:v crop=320:120:200:150 output.mp4

ffmpeg -i input.mp4 -filter:v(视频过滤器) "crop(裁剪过滤器)=w:h:x:y" output.mp4

//转换一个视频的具体的部分(比如从视频开始到指定时间转换为其它格式)

ffmpeg -i input.mp4 -t 10.10 output.avi

ffmpeg -i input.mp4 -t(从视频开始到10s10ms处保存为avi格式) 10.10 output.avi

//使用开始和停止时间剪下一段媒体文件

ffmpeg -i z.mp4 -ss 00:00:10 -codec copy -t 50 output.mp4

ffmpeg -i z.mp4 -ss 00:00:10 -codec copy -t 50 output.avi

//设置视频的屏幕高宽比

ffmpeg -i input.mp4 -aspect 16:9 output.mp4

ffmpeg -i input.mp4 -aspect(设置宽高比) 16:9 output.mp4

//添加海报图像到音频文件

ffmpeg -loop 1 -i image-15.png -i audio.mp3 -c:v libx264 -c:a aac -strict experimental -b:a 192k -shortest output.mp4

ffmpeg -loop 1 -i inputimage.jpg -i inputaudio.mp3 -c:v(指定视频编解码模块) libx264 -c:a((指定音频编解码模块)) aac -strict experimental -b:a(?) 192k -shortest output.mp4

//切分视频文件为多个部分

ffmpeg -i input.mp4 -t 00:00:30 -c copy part1.mp4 -ss 00:00:30 -codec copy part2.mp4 //-c 和 -codec 同一个效果

//接合或合并多个视频部分到一个

ffmpeg -f concat -safe 0 -i join.txt -c copy output.mp4

//添加字幕到一个视频文件

ffmpeg -i input.mp4 -i subtitle.srt -map 0 -map 1 -c copy -c:v libx264 -crf 23 -preset veryfast output.mp4

//增加/减少视频播放速度

ffmpeg -i input.mp4 -vf "setpts=0.5*PTS" output.mp4

//创建动画的 GIF

ffmpeg -ss 00:00:20 -i sample.mp4 -to 10 -r 10 -vf scale=200:-1 cutekid_cry.gif

===================================================================

av_register_all

该函数在所有基于FFmpeg的应用程序中几乎都是第一个被调用的

这个函数把全局的解码器，编码器等结构体注册到一些全局的对象表里，以便后面跑表调用

注册的类型：复用器，解复用器，编码器，解码器，包解析器，BitStreamFilter(位流处理器)等

av_register_all调用了avcodec_register_all，avcodec_register_all注册了和编解码器有关的组件：硬件加速器，解码器，编码器，Parser，Bitstream Filter。av_register_all除了调用avcodec_register_all之外，还注册了复用器，解复用器，协议处理器

下面附上复用器，解复用器，协议处理器的代码

注册复用器的函数是av_register_output_format

注册解复用器的函数是av_register_input_format

注册协议处理器的函数是ffurl_register_protocol

avcodec_register_all()

avcodec_register_all注册了和编解码器有关的组件：硬件加速器，解码器，编码器，Parser，Bitstream Filter。

硬件加速器注册函数:av_register_hwaccel()

编码器注册函数:avcodec_register()

parser注册函数:av_register_parser()

Bitstream Filter注册函数:av_register_bitstream_filter()

内存的分配和释放

内存操作的几个常见函数位于 libavutil\mem.c

先说下size_t,这个类型在FFmpeg中多次出现，它的作用其实就是为了增强程序的可移植性而定义的，不同系统上，定义size_t可能不一样，它实际上就是unsigned int

为什么要内存对齐：内存对齐是什么就不说了，c语言的，很多也有点忘记了，直接看结论吧：内存不对齐对cpu对性能是有影响的

av_malloc()

源码也自己去看，除去源码中一大推宏类似于CONFIG_MEMORY_POISONING，因为这个宏默认都是为0的，源码函数可精简为

void *av_malloc(size_t size)

{

void *ptr = NULL;

/* let's disallow possibly ambiguous cases */

if (size > (max_alloc_size - 32))

return NULL;

ptr = malloc(size);

if(!ptr && !size) {

size = 1;

ptr= av_malloc(1);

}

return ptr;

所以可以看出来，av_malloc()只是封装了系统的malloc()，并且做了一些错误检查的工作

av_realloc

用于对申请的内存的大小进行调整

跟av_malloc()一样，除去没用的宏，精简为

void *av_realloc(void *ptr, size_t size)

{

/* let's disallow possibly ambiguous cases */

if (size > (max_alloc_size - 32))

return NULL;

return realloc(ptr, size + !size);

}

可以看出来，av_realloc()其实就是封装系统的realloc()

av_mallocz()

av_mallocz()可以理解为av_mallocz()+zeromemory

精简后

void *av_mallocz(size_t size)

{

void *ptr = av_malloc(size);

if (ptr)

memset(ptr, 0, size);

return ptr;

}

可以看出来就是调用了av_malloc(size)之后，又调用memset()将分配的内存设置为0

av_calloc()

它是简单的封装了av_mallocz()

void *av_calloc(size_t nmemb, size_t size)

{

if (size <= 0 || nmemb >= INT_MAX / size)

return NULL;

return av_mallocz(nmemb * size);

}

从代码中可以看出，它调用av_mallocz()分配了nmemb * size个字节的内存

av_free()

用于释放申请的内存，除去没用的宏之外，代码如下

void av_free(void *ptr)

{

free(ptr);

}

就是封装了free()

av_freep()

简单了封装了av_free()，并且在释放内存之后将目标指针设置为NULL

void av_freep(void *arg)

{

void **ptr = (void **)arg;

av_free(*ptr);

*ptr = NULL;

}

FFmpeg典型代码例子

//视频解码

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <libavcodec/avcodec.h>

#define INBUF_SIZE 4096

static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,

char *filename)

{

FILE *f;

int i;

f = fopen(filename,"w");

fprintf(f, "P5\n%d %d\n%d\n", xsize, ysize, 255);

for (i = 0; i < ysize; i++)

fwrite(buf + i * wrap, 1, xsize, f);

fclose(f);

}

static void decode(AVCodecContext *dec_ctx, AVFrame *frame, AVPacket *pkt,

const char *filename)

{

char buf[1024];

int ret;

ret = avcodec_send_packet(dec_ctx, pkt);

if (ret < 0) {

fprintf(stderr, "Error sending a packet for decoding\n");

exit(1);

}

while (ret >= 0) {

ret = avcodec_receive_frame(dec_ctx, frame);

if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)

return;

else if (ret < 0) {

fprintf(stderr, "Error during decoding\n");

exit(1);

}

printf("saving frame %3d\n", dec_ctx->frame_number);

fflush(stdout);

/* the picture is allocated by the decoder. no need to

free it */

snprintf(buf, sizeof(buf), "%s-%d", filename, dec_ctx->frame_number);

pgm_save(frame->data[0], frame->linesize[0],

frame->width, frame->height, buf);

}

int main(int argc, char **argv)

{

const char *filename, *outfilename;

const AVCodec *codec;

AVCodecParserContext *parser;

AVCodecContext *c= NULL;

FILE *f;

AVFrame *frame;

uint8_t inbuf[INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];

uint8_t *data;

size_t data_size;

int ret;

AVPacket *pkt;

if (argc <= 2) {

fprintf(stderr, "Usage: %s <input file> <output file>\n"

"And check your input file is encoded by mpeg1video please.\n", argv[0]);

exit(0);

}

filename = argv[1];

outfilename = argv[2];

pkt = av_packet_alloc();

if (!pkt)

exit(1);

/* set end of buffer to 0 (this ensures that no overreading happens for damaged MPEG streams) */

memset(inbuf + INBUF_SIZE, 0, AV_INPUT_BUFFER_PADDING_SIZE);

/* find the MPEG-1 video decoder */

codec = avcodec_find_decoder(AV_CODEC_ID_MPEG1VIDEO);

if (!codec) {

fprintf(stderr, "Codec not found\n");

exit(1);

}

parser = av_parser_init(codec->id);

if (!parser) {

fprintf(stderr, "parser not found\n");

exit(1);

}

c = avcodec_alloc_context3(codec);

if (!c) {

fprintf(stderr, "Could not allocate video codec context\n");

exit(1);

}

/* For some codecs, such as msmpeg4 and mpeg4, width and height

MUST be initialized there because this information is not

available in the bitstream. */

/* open it */

if (avcodec_open2(c, codec, NULL) < 0) {

fprintf(stderr, "Could not open codec\n");

exit(1);

}

f = fopen(filename, "rb");

if (!f) {

fprintf(stderr, "Could not open %s\n", filename);

exit(1);

}

frame = av_frame_alloc();

if (!frame) {

fprintf(stderr, "Could not allocate video frame\n");

exit(1);

}

while (!feof(f)) {

/* read raw data from the input file */

data_size = fread(inbuf, 1, INBUF_SIZE, f);

if (!data_size)

break;

/* use the parser to split the data into frames */

data = inbuf;

while (data_size > 0) {

ret = av_parser_parse2(parser, c, &pkt->data, &pkt->size,

data, data_size, AV_NOPTS_VALUE, AV_NOPTS_VALUE, 0);

if (ret < 0) {

fprintf(stderr, "Error while parsing\n");

exit(1);

}

data += ret;

data_size -= ret;

if (pkt->size)

decode(c, frame, pkt, outfilename);

}

/* flush the decoder */

decode(c, frame, NULL, outfilename);

fclose(f);

av_parser_close(parser);

avcodec_free_context(&c);

av_frame_free(&frame);

av_packet_free(&pkt);

return 0;

}

//视频压缩

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <libavcodec/avcodec.h>

#include <libavutil/opt.h>

#include <libavutil/imgutils.h>

static void encode(AVCodecContext *enc_ctx, AVFrame *frame, AVPacket *pkt,

FILE *outfile)

{

int ret;

/* send the frame to the encoder */

if (frame)

printf("Send frame %3"PRId64"\n", frame->pts);

ret = avcodec_send_frame(enc_ctx, frame);

if (ret < 0) {

fprintf(stderr, "Error sending a frame for encoding\n");

exit(1);

}

while (ret >= 0) {

ret = avcodec_receive_packet(enc_ctx, pkt);

if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)

return;

else if (ret < 0) {

fprintf(stderr, "Error during encoding\n");

exit(1);

}

printf("Write packet %3"PRId64" (size=%5d)\n", pkt->pts, pkt->size);

fwrite(pkt->data, 1, pkt->size, outfile);

av_packet_unref(pkt);

}

int main(int argc, char **argv)

{

const char *filename, *codec_name;

const AVCodec *codec;

AVCodecContext *c= NULL;

int i, ret, x, y;

FILE *f;

AVFrame *frame;

AVPacket *pkt;

uint8_t endcode[] = { 0, 0, 1, 0xb7 };

if (argc <= 2) {

fprintf(stderr, "Usage: %s <output file> <codec name>\n", argv[0]);

exit(0);

}

filename = argv[1];

codec_name = argv[2];

/* find the mpeg1video encoder */

codec = avcodec_find_encoder_by_name(codec_name);

if (!codec) {

fprintf(stderr, "Codec '%s' not found\n", codec_name);

exit(1);

}

c = avcodec_alloc_context3(codec);

if (!c) {

fprintf(stderr, "Could not allocate video codec context\n");

exit(1);

}

pkt = av_packet_alloc();

if (!pkt)

exit(1);

/* put sample parameters */

c->bit_rate = 400000;

/* resolution must be a multiple of two */

c->width = 352;

c->height = 288;

/* frames per second */

c->time_base = (AVRational){1, 25};

c->framerate = (AVRational){25, 1};

/* emit one intra frame every ten frames

* check frame pict_type before passing frame

* to encoder, if frame->pict_type is AV_PICTURE_TYPE_I

* then gop_size is ignored and the output of encoder

* will always be I frame irrespective to gop_size

c->gop_size = 10;

c->max_b_frames = 1;

c->pix_fmt = AV_PIX_FMT_YUV420P;

if (codec->id == AV_CODEC_ID_H264)

av_opt_set(c->priv_data, "preset", "slow", 0);

/* open it */

ret = avcodec_open2(c, codec, NULL);

if (ret < 0) {

fprintf(stderr, "Could not open codec: %s\n", av_err2str(ret));

exit(1);

}

f = fopen(filename, "wb");

if (!f) {

fprintf(stderr, "Could not open %s\n", filename);

exit(1);

}

frame = av_frame_alloc();

if (!frame) {

fprintf(stderr, "Could not allocate video frame\n");

exit(1);

}

frame->format = c->pix_fmt;

frame->width = c->width;

frame->height = c->height;

ret = av_frame_get_buffer(frame, 32);

if (ret < 0) {

fprintf(stderr, "Could not allocate the video frame data\n");

exit(1);

}

/* encode 1 second of video */

for (i = 0; i < 25; i++) {

fflush(stdout);

/* make sure the frame data is writable */

ret = av_frame_make_writable(frame);

if (ret < 0)

exit(1);

/* prepare a dummy image */

/* Y */

for (y = 0; y < c->height; y++) {

for (x = 0; x < c->width; x++) {

frame->data[0][y * frame->linesize[0] + x] = x + y + i * 3;

}

/* Cb and Cr */

for (y = 0; y < c->height/2; y++) {

for (x = 0; x < c->width/2; x++) {

frame->data[1][y * frame->linesize[1] + x] = 128 + y + i * 2;

frame->data[2][y * frame->linesize[2] + x] = 64 + x + i * 5;

}

frame->pts = i;

/* encode the image */

encode(c, frame, pkt, f);

}

/* flush the encoder */

encode(c, NULL, pkt, f);

/* add sequence end code to have a real MPEG file */

if (codec->id == AV_CODEC_ID_MPEG1VIDEO || codec->id == AV_CODEC_ID_MPEG2VIDEO)

fwrite(endcode, 1, sizeof(endcode), f);

fclose(f);

avcodec_free_context(&c);

av_frame_free(&frame);

av_packet_free(&pkt);

return 0;

}

//音频解码

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <libavutil/frame.h>

#include <libavutil/mem.h>

#include <libavcodec/avcodec.h>

#define AUDIO_INBUF_SIZE 20480

#define AUDIO_REFILL_THRESH 4096

static int get_format_from_sample_fmt(const char **fmt,

enum AVSampleFormat sample_fmt)

{

int i;

struct sample_fmt_entry {

enum AVSampleFormat sample_fmt; const char *fmt_be, *fmt_le;

} sample_fmt_entries[] = {

{ AV_SAMPLE_FMT_U8, "u8", "u8" },

{ AV_SAMPLE_FMT_S16, "s16be", "s16le" },

{ AV_SAMPLE_FMT_S32, "s32be", "s32le" },

{ AV_SAMPLE_FMT_FLT, "f32be", "f32le" },

{ AV_SAMPLE_FMT_DBL, "f64be", "f64le" },

};

*fmt = NULL;

for (i = 0; i < FF_ARRAY_ELEMS(sample_fmt_entries); i++) {

struct sample_fmt_entry *entry = &sample_fmt_entries[i];

if (sample_fmt == entry->sample_fmt) {

*fmt = AV_NE(entry->fmt_be, entry->fmt_le);

return 0;

}

fprintf(stderr,

"sample format %s is not supported as output format\n",

av_get_sample_fmt_name(sample_fmt));

return -1;

}

static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame,

FILE *outfile)

{

int i, ch;

int ret, data_size;

/* send the packet with the compressed data to the decoder */

ret = avcodec_send_packet(dec_ctx, pkt);

if (ret < 0) {

fprintf(stderr, "Error submitting the packet to the decoder\n");

exit(1);

}

/* read all the output frames (in general there may be any number of them */

while (ret >= 0) {

ret = avcodec_receive_frame(dec_ctx, frame);

if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)

return;

else if (ret < 0) {

fprintf(stderr, "Error during decoding\n");

exit(1);

}

data_size = av_get_bytes_per_sample(dec_ctx->sample_fmt);

if (data_size < 0) {

/* This should not occur, checking just for paranoia */

fprintf(stderr, "Failed to calculate data size\n");

exit(1);

}

for (i = 0; i < frame->nb_samples; i++)

for (ch = 0; ch < dec_ctx->channels; ch++)

fwrite(frame->data[ch] + data_size*i, 1, data_size, outfile);

}

int main(int argc, char **argv)

{

const char *outfilename, *filename;

const AVCodec *codec;

AVCodecContext *c= NULL;

AVCodecParserContext *parser = NULL;

int len, ret;

FILE *f, *outfile;

uint8_t inbuf[AUDIO_INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];

uint8_t *data;

size_t data_size;

AVPacket *pkt;

AVFrame *decoded_frame = NULL;

enum AVSampleFormat sfmt;

int n_channels = 0;

const char *fmt;

if (argc <= 2) {

fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);

exit(0);

}

filename = argv[1];

outfilename = argv[2];

pkt = av_packet_alloc();

/* find the MPEG audio decoder */

codec = avcodec_find_decoder(AV_CODEC_ID_MP2);

if (!codec) {

fprintf(stderr, "Codec not found\n");

exit(1);

}

parser = av_parser_init(codec->id);

if (!parser) {

fprintf(stderr, "Parser not found\n");

exit(1);

}

c = avcodec_alloc_context3(codec);

if (!c) {

fprintf(stderr, "Could not allocate audio codec context\n");

exit(1);

}

/* open it */

if (avcodec_open2(c, codec, NULL) < 0) {

fprintf(stderr, "Could not open codec\n");

exit(1);

}

f = fopen(filename, "rb");

if (!f) {

fprintf(stderr, "Could not open %s\n", filename);

exit(1);

}

outfile = fopen(outfilename, "wb");

if (!outfile) {

av_free(c);

exit(1);

}

/* decode until eof */

data = inbuf;

data_size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);

while (data_size > 0) {

if (!decoded_frame) {

if (!(decoded_frame = av_frame_alloc())) {

fprintf(stderr, "Could not allocate audio frame\n");

exit(1);

}

ret = av_parser_parse2(parser, c, &pkt->data, &pkt->size,

data, data_size,

AV_NOPTS_VALUE, AV_NOPTS_VALUE, 0);

if (ret < 0) {

fprintf(stderr, "Error while parsing\n");

exit(1);

}

data += ret;

data_size -= ret;

if (pkt->size)

decode(c, pkt, decoded_frame, outfile);

if (data_size < AUDIO_REFILL_THRESH) {

memmove(inbuf, data, data_size);

data = inbuf;

len = fread(data + data_size, 1,

AUDIO_INBUF_SIZE - data_size, f);

if (len > 0)

data_size += len;

}

/* flush the decoder */

pkt->data = NULL;

pkt->size = 0;

decode(c, pkt, decoded_frame, outfile);

/* print output pcm infomations, because there have no metadata of pcm */

sfmt = c->sample_fmt;

if (av_sample_fmt_is_planar(sfmt)) {

const char *packed = av_get_sample_fmt_name(sfmt);

printf("Warning: the sample format the decoder produced is planar "

"(%s). This example will output the first channel only.\n",

packed ? packed : "?");

sfmt = av_get_packed_sample_fmt(sfmt);

}

n_channels = c->channels;

if ((ret = get_format_from_sample_fmt(&fmt, sfmt)) < 0)

goto end;

printf("Play the output audio file with the command:\n"

"ffplay -f %s -ac %d -ar %d %s\n",

fmt, n_channels, c->sample_rate,

outfilename);

end:

fclose(outfile);

fclose(f);

avcodec_free_context(&c);

av_parser_close(parser);

av_frame_free(&decoded_frame);

av_packet_free(&pkt);

return 0;

}

//音频压缩

#include <stdint.h>

#include <stdio.h>

#include <stdlib.h>

#include <libavcodec/avcodec.h>

#include <libavutil/channel_layout.h>

#include <libavutil/common.h>

#include <libavutil/frame.h>

#include <libavutil/samplefmt.h>

/* check that a given sample format is supported by the encoder */

static int check_sample_fmt(const AVCodec *codec, enum AVSampleFormat sample_fmt)

{

const enum AVSampleFormat *p = codec->sample_fmts;

while (*p != AV_SAMPLE_FMT_NONE) {

if (*p == sample_fmt)

return 1;

p++;

}

return 0;

}

/* just pick the highest supported samplerate */

static int select_sample_rate(const AVCodec *codec)

{

const int *p;

int best_samplerate = 0;

if (!codec->supported_samplerates)

return 44100;

p = codec->supported_samplerates;

while (*p) {

if (!best_samplerate || abs(44100 - *p) < abs(44100 - best_samplerate))

best_samplerate = *p;

p++;

}

return best_samplerate;

}

/* select layout with the highest channel count */

static int select_channel_layout(const AVCodec *codec)

{

const uint64_t *p;

uint64_t best_ch_layout = 0;

int best_nb_channels = 0;

if (!codec->channel_layouts)

return AV_CH_LAYOUT_STEREO;

p = codec->channel_layouts;

while (*p) {

int nb_channels = av_get_channel_layout_nb_channels(*p);

if (nb_channels > best_nb_channels) {

best_ch_layout = *p;

best_nb_channels = nb_channels;

}

p++;

}

return best_ch_layout;

}

static void encode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt,

FILE *output)

{

int ret;

/* send the frame for encoding */

ret = avcodec_send_frame(ctx, frame);

if (ret < 0) {

fprintf(stderr, "Error sending the frame to the encoder\n");

exit(1);

}

/* read all the available output packets (in general there may be any

* number of them */

while (ret >= 0) {

ret = avcodec_receive_packet(ctx, pkt);

if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)

return;

else if (ret < 0) {

fprintf(stderr, "Error encoding audio frame\n");

exit(1);

}

fwrite(pkt->data, 1, pkt->size, output);

av_packet_unref(pkt);

}

int main(int argc, char **argv)

{

const char *filename;

const AVCodec *codec;

AVCodecContext *c= NULL;

AVFrame *frame;

AVPacket *pkt;

int i, j, k, ret;

FILE *f;

uint16_t *samples;

float t, tincr;

if (argc <= 1) {

fprintf(stderr, "Usage: %s <output file>\n", argv[0]);

return 0;

}

filename = argv[1];

/* find the MP2 encoder */

codec = avcodec_find_encoder(AV_CODEC_ID_MP2);

if (!codec) {

fprintf(stderr, "Codec not found\n");

exit(1);

}

c = avcodec_alloc_context3(codec);

if (!c) {

fprintf(stderr, "Could not allocate audio codec context\n");

exit(1);

}

/* put sample parameters */

c->bit_rate = 64000;

/* check that the encoder supports s16 pcm input */

c->sample_fmt = AV_SAMPLE_FMT_S16;

if (!check_sample_fmt(codec, c->sample_fmt)) {

fprintf(stderr, "Encoder does not support sample format %s",

av_get_sample_fmt_name(c->sample_fmt));

exit(1);

}

/* select other audio parameters supported by the encoder */

c->sample_rate = select_sample_rate(codec);

c->channel_layout = select_channel_layout(codec);

c->channels = av_get_channel_layout_nb_channels(c->channel_layout);

/* open it */

if (avcodec_open2(c, codec, NULL) < 0) {

fprintf(stderr, "Could not open codec\n");

exit(1);

}

f = fopen(filename, "wb");

if (!f) {

fprintf(stderr, "Could not open %s\n", filename);

exit(1);

}

/* packet for holding encoded output */

pkt = av_packet_alloc();

if (!pkt) {

fprintf(stderr, "could not allocate the packet\n");

exit(1);

}

/* frame containing input raw audio */

frame = av_frame_alloc();

if (!frame) {

fprintf(stderr, "Could not allocate audio frame\n");

exit(1);

}

frame->nb_samples = c->frame_size;

frame->format = c->sample_fmt;

frame->channel_layout = c->channel_layout;

/* allocate the data buffers */

ret = av_frame_get_buffer(frame, 0);

if (ret < 0) {

fprintf(stderr, "Could not allocate audio data buffers\n");

exit(1);

}

/* encode a single tone sound */

t = 0;

tincr = 2 * M_PI * 440.0 / c->sample_rate;

for (i = 0; i < 200; i++) {

/* make sure the frame is writable -- makes a copy if the encoder

* kept a reference internally */

ret = av_frame_make_writable(frame);

if (ret < 0)

exit(1);

samples = (uint16_t*)frame->data[0];

for (j = 0; j < c->frame_size; j++) {

samples[2*j] = (int)(sin(t) * 10000);

for (k = 1; k < c->channels; k++)

samples[2*j + k] = samples[2*j];

t += tincr;

}

encode(c, frame, pkt, f);

}

/* flush the encoder */

encode(c, NULL, pkt, f);

fclose(f);

av_frame_free(&frame);

av_packet_free(&pkt);

avcodec_free_context(&c);

return 0;

}

//目录遍历

#include <libavcodec/avcodec.h>

#include <libavformat/avformat.h>

#include <libavformat/avio.h>

static const char *type_string(int type)

{

switch (type) {

case AVIO_ENTRY_DIRECTORY:

return "<DIR>";

case AVIO_ENTRY_FILE:

return "<FILE>";

case AVIO_ENTRY_BLOCK_DEVICE:

return "<BLOCK DEVICE>";

case AVIO_ENTRY_CHARACTER_DEVICE:

return "<CHARACTER DEVICE>";

case AVIO_ENTRY_NAMED_PIPE:

return "<PIPE>";

case AVIO_ENTRY_SYMBOLIC_LINK:

return "<LINK>";

case AVIO_ENTRY_SOCKET:

return "<SOCKET>";

case AVIO_ENTRY_SERVER:

return "<SERVER>";

case AVIO_ENTRY_SHARE:

return "<SHARE>";

case AVIO_ENTRY_WORKGROUP:

return "<WORKGROUP>";

case AVIO_ENTRY_UNKNOWN:

default:

break;

}

return "<UNKNOWN>";

}

static int list_op(const char *input_dir)

{

AVIODirEntry *entry = NULL;

AVIODirContext *ctx = NULL;

int cnt, ret;

char filemode[4], uid_and_gid[20];

if ((ret = avio_open_dir(&ctx, input_dir, NULL)) < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot open directory: %s.\n", av_err2str(ret));

goto fail;

}

cnt = 0;

for (;;) {

if ((ret = avio_read_dir(ctx, &entry)) < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot list directory: %s.\n", av_err2str(ret));

goto fail;

}

if (!entry)

break;

if (entry->filemode == -1) {

snprintf(filemode, 4, "???");

} else {

snprintf(filemode, 4, "%3"PRIo64, entry->filemode);

}

snprintf(uid_and_gid, 20, "%"PRId64"(%"PRId64")", entry->user_id, entry->group_id);

if (cnt == 0)

av_log(NULL, AV_LOG_INFO, "%-9s %12s %30s %10s %s %16s %16s %16s\n",

"TYPE", "SIZE", "NAME", "UID(GID)", "UGO", "MODIFIED",

"ACCESSED", "STATUS_CHANGED");

av_log(NULL, AV_LOG_INFO, "%-9s %12"PRId64" %30s %10s %s %16"PRId64" %16"PRId64" %16"PRId64"\n",

type_string(entry->type),

entry->size,

entry->name,

uid_and_gid,

filemode,

entry->modification_timestamp,

entry->access_timestamp,

entry->status_change_timestamp);

avio_free_directory_entry(&entry);

cnt++;

};

fail:

avio_close_dir(&ctx);

return ret;

}

static void usage(const char *program_name)

{

fprintf(stderr, "usage: %s input_dir\n"

"API example program to show how to list files in directory "

"accessed through AVIOContext.\n", program_name);

}

int main(int argc, char *argv[])

{

int ret;

av_log_set_level(AV_LOG_DEBUG);

if (argc < 2) {

usage(argv[0]);

return 1;

}

avformat_network_init();

ret = list_op(argv[1]);

avformat_network_deinit();

return ret < 0 ? 1 : 0;

}

//文件操作

#include <libavcodec/avcodec.h>

#include <libavformat/avformat.h>

#include <libavformat/avio.h>

#include <libavutil/file.h>

struct buffer_data {

uint8_t *ptr;

size_t size; ///< size left in the buffer

};

static int read_packet(void *opaque, uint8_t *buf, int buf_size)

{

struct buffer_data *bd = (struct buffer_data *)opaque;

buf_size = FFMIN(buf_size, bd->size);

if (!buf_size)

return AVERROR_EOF;

printf("ptr:%p size:%zu\n", bd->ptr, bd->size);

/* copy internal buffer data to buf */

memcpy(buf, bd->ptr, buf_size);

bd->ptr += buf_size;

bd->size -= buf_size;

return buf_size;

}

int main(int argc, char *argv[])

{

AVFormatContext *fmt_ctx = NULL;

AVIOContext *avio_ctx = NULL;

uint8_t *buffer = NULL, *avio_ctx_buffer = NULL;

size_t buffer_size, avio_ctx_buffer_size = 4096;

char *input_filename = NULL;

int ret = 0;

struct buffer_data bd = { 0 };

if (argc != 2) {

fprintf(stderr, "usage: %s input_file\n"

"API example program to show how to read from a custom buffer "

"accessed through AVIOContext.\n", argv[0]);

return 1;

}

input_filename = argv[1];

/* slurp file content into buffer */

ret = av_file_map(input_filename, &buffer, &buffer_size, 0, NULL);

if (ret < 0)

goto end;

/* fill opaque structure used by the AVIOContext read callback */

bd.ptr = buffer;

bd.size = buffer_size;

if (!(fmt_ctx = avformat_alloc_context())) {

ret = AVERROR(ENOMEM);

goto end;

}

avio_ctx_buffer = av_malloc(avio_ctx_buffer_size);

if (!avio_ctx_buffer) {

ret = AVERROR(ENOMEM);

goto end;

}

avio_ctx = avio_alloc_context(avio_ctx_buffer, avio_ctx_buffer_size,

0, &bd, &read_packet, NULL, NULL);

if (!avio_ctx) {

ret = AVERROR(ENOMEM);

goto end;

}

fmt_ctx->pb = avio_ctx;

ret = avformat_open_input(&fmt_ctx, NULL, NULL, NULL);

if (ret < 0) {

fprintf(stderr, "Could not open input\n");

goto end;

}

ret = avformat_find_stream_info(fmt_ctx, NULL);

if (ret < 0) {

fprintf(stderr, "Could not find stream information\n");

goto end;

}

av_dump_format(fmt_ctx, 0, input_filename, 0);

end:

avformat_close_input(&fmt_ctx);

/* note: the internal buffer could have changed, and be != avio_ctx_buffer */

if (avio_ctx)

av_freep(&avio_ctx->buffer);

avio_context_free(&avio_ctx);

av_file_unmap(buffer, buffer_size);

if (ret < 0) {

fprintf(stderr, "Error occurred: %s\n", av_err2str(ret));

return 1;

}

return 0;

}

//使用audio Filter

#include <unistd.h>

#include <libavcodec/avcodec.h>

#include <libavformat/avformat.h>

#include <libavfilter/buffersink.h>

#include <libavfilter/buffersrc.h>

#include <libavutil/opt.h>

static const char *filter_descr = "aresample=8000,aformat=sample_fmts=s16:channel_layouts=mono";

static const char *player = "ffplay -f s16le -ar 8000 -ac 1 -";

static AVFormatContext *fmt_ctx;

static AVCodecContext *dec_ctx;

AVFilterContext *buffersink_ctx;

AVFilterContext *buffersrc_ctx;

AVFilterGraph *filter_graph;

static int audio_stream_index = -1;

static int open_input_file(const char *filename)

{

int ret;

AVCodec *dec;

if ((ret = avformat_open_input(&fmt_ctx, filename, NULL, NULL)) < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");

return ret;

}

if ((ret = avformat_find_stream_info(fmt_ctx, NULL)) < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");

return ret;

}

/* select the audio stream */

ret = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_AUDIO, -1, -1, &dec, 0);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot find an audio stream in the input file\n");

return ret;

}

audio_stream_index = ret;

/* create decoding context */

dec_ctx = avcodec_alloc_context3(dec);

if (!dec_ctx)

return AVERROR(ENOMEM);

avcodec_parameters_to_context(dec_ctx, fmt_ctx->streams[audio_stream_index]->codecpar);

/* init the audio decoder */

if ((ret = avcodec_open2(dec_ctx, dec, NULL)) < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot open audio decoder\n");

return ret;

}

return 0;

}

static int init_filters(const char *filters_descr)

{

char args[512];

int ret = 0;

const AVFilter *abuffersrc = avfilter_get_by_name("abuffer");

const AVFilter *abuffersink = avfilter_get_by_name("abuffersink");

AVFilterInOut *outputs = avfilter_inout_alloc();

AVFilterInOut *inputs = avfilter_inout_alloc();

static const enum AVSampleFormat out_sample_fmts[] = { AV_SAMPLE_FMT_S16, -1 };

static const int64_t out_channel_layouts[] = { AV_CH_LAYOUT_MONO, -1 };

static const int out_sample_rates[] = { 8000, -1 };

const AVFilterLink *outlink;

AVRational time_base = fmt_ctx->streams[audio_stream_index]->time_base;

filter_graph = avfilter_graph_alloc();

if (!outputs || !inputs || !filter_graph) {

ret = AVERROR(ENOMEM);

goto end;

}

/* buffer audio source: the decoded frames from the decoder will be inserted here. */

if (!dec_ctx->channel_layout)

dec_ctx->channel_layout = av_get_default_channel_layout(dec_ctx->channels);

snprintf(args, sizeof(args),

"time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%"PRIx64,

time_base.num, time_base.den, dec_ctx->sample_rate,

av_get_sample_fmt_name(dec_ctx->sample_fmt), dec_ctx->channel_layout);

ret = avfilter_graph_create_filter(&buffersrc_ctx, abuffersrc, "in",

args, NULL, filter_graph);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer source\n");

goto end;

}

/* buffer audio sink: to terminate the filter chain. */

ret = avfilter_graph_create_filter(&buffersink_ctx, abuffersink, "out",

NULL, NULL, filter_graph);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer sink\n");

goto end;

}

ret = av_opt_set_int_list(buffersink_ctx, "sample_fmts", out_sample_fmts, -1,

AV_OPT_SEARCH_CHILDREN);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot set output sample format\n");

goto end;

}

ret = av_opt_set_int_list(buffersink_ctx, "channel_layouts", out_channel_layouts, -1,

AV_OPT_SEARCH_CHILDREN);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot set output channel layout\n");

goto end;

}

ret = av_opt_set_int_list(buffersink_ctx, "sample_rates", out_sample_rates, -1,

AV_OPT_SEARCH_CHILDREN);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot set output sample rate\n");

goto end;

}

* Set the endpoints for the filter graph. The filter_graph will

* be linked to the graph described by filters_descr.

* The buffer source output must be connected to the input pad of

* the first filter described by filters_descr; since the first

* filter input label is not specified, it is set to "in" by

* default.

outputs->name = av_strdup("in");

outputs->filter_ctx = buffersrc_ctx;

outputs->pad_idx = 0;

outputs->next = NULL;

* The buffer sink input must be connected to the output pad of

* the last filter described by filters_descr; since the last

* filter output label is not specified, it is set to "out" by

* default.

inputs->name = av_strdup("out");

inputs->filter_ctx = buffersink_ctx;

inputs->pad_idx = 0;

inputs->next = NULL;

if ((ret = avfilter_graph_parse_ptr(filter_graph, filters_descr,

&inputs, &outputs, NULL)) < 0)

goto end;

if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)

goto end;

/* Print summary of the sink buffer

* Note: args buffer is reused to store channel layout string */

outlink = buffersink_ctx->inputs[0];

av_get_channel_layout_string(args, sizeof(args), -1, outlink->channel_layout);

av_log(NULL, AV_LOG_INFO, "Output: srate:%dHz fmt:%s chlayout:%s\n",

(int)outlink->sample_rate,

(char *)av_x_if_null(av_get_sample_fmt_name(outlink->format), "?"),

args);

end:

avfilter_inout_free(&inputs);

avfilter_inout_free(&outputs);

return ret;

}

static void print_frame(const AVFrame *frame)

{

const int n = frame->nb_samples * av_get_channel_layout_nb_channels(frame->channel_layout);

const uint16_t *p = (uint16_t*)frame->data[0];

const uint16_t *p_end = p + n;

while (p < p_end) {

fputc(*p & 0xff, stdout);

fputc(*p>>8 & 0xff, stdout);

p++;

}

fflush(stdout);

}

int main(int argc, char **argv)

{

int ret;

AVPacket packet;

AVFrame *frame = av_frame_alloc();

AVFrame *filt_frame = av_frame_alloc();

if (!frame || !filt_frame) {

perror("Could not allocate frame");

exit(1);

}

if (argc != 2) {

fprintf(stderr, "Usage: %s file | %s\n", argv[0], player);

exit(1);

}

if ((ret = open_input_file(argv[1])) < 0)

goto end;

if ((ret = init_filters(filter_descr)) < 0)

goto end;

/* read all packets */

while (1) {

if ((ret = av_read_frame(fmt_ctx, &packet)) < 0)

break;

if (packet.stream_index == audio_stream_index) {

ret = avcodec_send_packet(dec_ctx, &packet);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Error while sending a packet to the decoder\n");

break;

}

while (ret >= 0) {

ret = avcodec_receive_frame(dec_ctx, frame);

if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {

break;

} else if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Error while receiving a frame from the decoder\n");

goto end;

}

if (ret >= 0) {

/* push the audio data from decoded frame into the filtergraph */

if (av_buffersrc_add_frame_flags(buffersrc_ctx, frame, AV_BUFFERSRC_FLAG_KEEP_REF) < 0) {

av_log(NULL, AV_LOG_ERROR, "Error while feeding the audio filtergraph\n");

break;

}

/* pull filtered audio from the filtergraph */

while (1) {

ret = av_buffersink_get_frame(buffersink_ctx, filt_frame);

if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)

break;

if (ret < 0)

goto end;

print_frame(filt_frame);

av_frame_unref(filt_frame);

}

av_frame_unref(frame);

}

av_packet_unref(&packet);

}

end:

avfilter_graph_free(&filter_graph);

avcodec_free_context(&dec_ctx);

avformat_close_input(&fmt_ctx);

av_frame_free(&frame);

av_frame_free(&filt_frame);

if (ret < 0 && ret != AVERROR_EOF) {

fprintf(stderr, "Error occurred: %s\n", av_err2str(ret));

exit(1);

}

exit(0);

}

//使用视频Filter

#define _XOPEN_SOURCE 600 /* for usleep */

#include <unistd.h>

#include <stdio.h>

#include <stdlib.h>

#include <libavcodec/avcodec.h>

#include <libavformat/avformat.h>

#include <libavfilter/buffersink.h>

#include <libavfilter/buffersrc.h>

#include <libavutil/opt.h>

const char *filter_descr = "scale=78:24,transpose=cclock";

/* other way:

scale=78:24 [scl]; [scl] transpose=cclock // assumes "[in]" and "[out]" to be input output pads respectively

static AVFormatContext *fmt_ctx;

static AVCodecContext *dec_ctx;

AVFilterContext *buffersink_ctx;

AVFilterContext *buffersrc_ctx;

AVFilterGraph *filter_graph;

static int video_stream_index = -1;

static int64_t last_pts = AV_NOPTS_VALUE;

static int open_input_file(const char *filename)

{

int ret;

AVCodec *dec;

if ((ret = avformat_open_input(&fmt_ctx, filename, NULL, NULL)) < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");

return ret;

}

if ((ret = avformat_find_stream_info(fmt_ctx, NULL)) < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");

return ret;

}

/* select the video stream */

ret = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &dec, 0);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot find a video stream in the input file\n");

return ret;

}

video_stream_index = ret;

/* create decoding context */

dec_ctx = avcodec_alloc_context3(dec);

if (!dec_ctx)

return AVERROR(ENOMEM);

avcodec_parameters_to_context(dec_ctx, fmt_ctx->streams[video_stream_index]->codecpar);

/* init the video decoder */

if ((ret = avcodec_open2(dec_ctx, dec, NULL)) < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot open video decoder\n");

return ret;

}

return 0;

}

static int init_filters(const char *filters_descr)

{

char args[512];

int ret = 0;

const AVFilter *buffersrc = avfilter_get_by_name("buffer");

const AVFilter *buffersink = avfilter_get_by_name("buffersink");

AVFilterInOut *outputs = avfilter_inout_alloc();

AVFilterInOut *inputs = avfilter_inout_alloc();

AVRational time_base = fmt_ctx->streams[video_stream_index]->time_base;

enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE };

filter_graph = avfilter_graph_alloc();

if (!outputs || !inputs || !filter_graph) {

ret = AVERROR(ENOMEM);

goto end;

}

/* buffer video source: the decoded frames from the decoder will be inserted here. */

snprintf(args, sizeof(args),

"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",

dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,

time_base.num, time_base.den,

dec_ctx->sample_aspect_ratio.num, dec_ctx->sample_aspect_ratio.den);

ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",

args, NULL, filter_graph);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");

goto end;

}

/* buffer video sink: to terminate the filter chain. */

ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",

NULL, NULL, filter_graph);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");

goto end;

}

ret = av_opt_set_int_list(buffersink_ctx, "pix_fmts", pix_fmts,

AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot set output pixel format\n");

goto end;

}

* Set the endpoints for the filter graph. The filter_graph will

* be linked to the graph described by filters_descr.

* The buffer source output must be connected to the input pad of

* the first filter described by filters_descr; since the first

* filter input label is not specified, it is set to "in" by

* default.

outputs->name = av_strdup("in");

outputs->filter_ctx = buffersrc_ctx;

outputs->pad_idx = 0;

outputs->next = NULL;

* The buffer sink input must be connected to the output pad of

* the last filter described by filters_descr; since the last

* filter output label is not specified, it is set to "out" by

* default.

inputs->name = av_strdup("out");

inputs->filter_ctx = buffersink_ctx;

inputs->pad_idx = 0;

inputs->next = NULL;

if ((ret = avfilter_graph_parse_ptr(filter_graph, filters_descr,

&inputs, &outputs, NULL)) < 0)

goto end;

if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)

goto end;

end:

avfilter_inout_free(&inputs);

avfilter_inout_free(&outputs);

return ret;

}

static void display_frame(const AVFrame *frame, AVRational time_base)

{

int x, y;

uint8_t *p0, *p;

int64_t delay;

if (frame->pts != AV_NOPTS_VALUE) {

if (last_pts != AV_NOPTS_VALUE) {

/* sleep roughly the right amount of time;

* usleep is in microseconds, just like AV_TIME_BASE. */

delay = av_rescale_q(frame->pts - last_pts,

time_base, AV_TIME_BASE_Q);

if (delay > 0 && delay < 1000000)

usleep(delay);

}

last_pts = frame->pts;

}

/* Trivial ASCII grayscale display. */

p0 = frame->data[0];

puts("\033c");

for (y = 0; y < frame->height; y++) {

p = p0;

for (x = 0; x < frame->width; x++)

putchar(" .-+#"[*(p++) / 52]);

putchar('\n');

p0 += frame->linesize[0];

}

fflush(stdout);

}

int main(int argc, char **argv)

{

int ret;

AVPacket packet;

AVFrame *frame;

AVFrame *filt_frame;

if (argc != 2) {

fprintf(stderr, "Usage: %s file\n", argv[0]);

exit(1);

}

frame = av_frame_alloc();

filt_frame = av_frame_alloc();

if (!frame || !filt_frame) {

perror("Could not allocate frame");

exit(1);

}

if ((ret = open_input_file(argv[1])) < 0)

goto end;

if ((ret = init_filters(filter_descr)) < 0)

goto end;

/* read all packets */

while (1) {

if ((ret = av_read_frame(fmt_ctx, &packet)) < 0)

break;

if (packet.stream_index == video_stream_index) {

ret = avcodec_send_packet(dec_ctx, &packet);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Error while sending a packet to the decoder\n");

break;

}

while (ret >= 0) {

ret = avcodec_receive_frame(dec_ctx, frame);

if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {

break;

} else if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Error while receiving a frame from the decoder\n");

goto end;

}

frame->pts = frame->best_effort_timestamp;

/* push the decoded frame into the filtergraph */

if (av_buffersrc_add_frame_flags(buffersrc_ctx, frame, AV_BUFFERSRC_FLAG_KEEP_REF) < 0) {

av_log(NULL, AV_LOG_ERROR, "Error while feeding the filtergraph\n");

break;

}

/* pull filtered frames from the filtergraph */

while (1) {

ret = av_buffersink_get_frame(buffersink_ctx, filt_frame);

if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)

break;

if (ret < 0)

goto end;

display_frame(filt_frame, buffersink_ctx->inputs[0]->time_base);

av_frame_unref(filt_frame);

}

av_frame_unref(frame);

}

av_packet_unref(&packet);

}

end:

avfilter_graph_free(&filter_graph);

avcodec_free_context(&dec_ctx);

avformat_close_input(&fmt_ctx);

av_frame_free(&frame);

av_frame_free(&filt_frame);

if (ret < 0 && ret != AVERROR_EOF) {

fprintf(stderr, "Error occurred: %s\n", av_err2str(ret));

exit(1);

}

exit(0);

}

//一个 AudioFilter

#include <inttypes.h>

#include <math.h>

#include <stdio.h>

#include <stdlib.h>

#include "libavutil/channel_layout.h"

#include "libavutil/md5.h"

#include "libavutil/mem.h"

#include "libavutil/opt.h"

#include "libavutil/samplefmt.h"

#include "libavfilter/avfilter.h"

#include "libavfilter/buffersink.h"

#include "libavfilter/buffersrc.h"

#define INPUT_SAMPLERATE 48000

#define INPUT_FORMAT AV_SAMPLE_FMT_FLTP

#define INPUT_CHANNEL_LAYOUT AV_CH_LAYOUT_5POINT0

#define VOLUME_VAL 0.90

static int init_filter_graph(AVFilterGraph **graph, AVFilterContext **src,

AVFilterContext **sink)

{

AVFilterGraph *filter_graph;

AVFilterContext *abuffer_ctx;

const AVFilter *abuffer;

AVFilterContext *volume_ctx;

const AVFilter *volume;

AVFilterContext *aformat_ctx;

const AVFilter *aformat;

AVFilterContext *abuffersink_ctx;

const AVFilter *abuffersink;

AVDictionary *options_dict = NULL;

uint8_t options_str[1024];

uint8_t ch_layout[64];

int err;

/* Create a new filtergraph, which will contain all the filters. */

filter_graph = avfilter_graph_alloc();

if (!filter_graph) {

fprintf(stderr, "Unable to create filter graph.\n");

return AVERROR(ENOMEM);

}

/* Create the abuffer filter;

* it will be used for feeding the data into the graph. */

abuffer = avfilter_get_by_name("abuffer");

if (!abuffer) {

fprintf(stderr, "Could not find the abuffer filter.\n");

return AVERROR_FILTER_NOT_FOUND;

}

abuffer_ctx = avfilter_graph_alloc_filter(filter_graph, abuffer, "src");

if (!abuffer_ctx) {

fprintf(stderr, "Could not allocate the abuffer instance.\n");

return AVERROR(ENOMEM);

}

/* Set the filter options through the AVOptions API. */

av_get_channel_layout_string(ch_layout, sizeof(ch_layout), 0, INPUT_CHANNEL_LAYOUT);

av_opt_set (abuffer_ctx, "channel_layout", ch_layout, AV_OPT_SEARCH_CHILDREN);

av_opt_set (abuffer_ctx, "sample_fmt", av_get_sample_fmt_name(INPUT_FORMAT), AV_OPT_SEARCH_CHILDREN);

av_opt_set_q (abuffer_ctx, "time_base", (AVRational){ 1, INPUT_SAMPLERATE }, AV_OPT_SEARCH_CHILDREN);

av_opt_set_int(abuffer_ctx, "sample_rate", INPUT_SAMPLERATE, AV_OPT_SEARCH_CHILDREN);

/* Now initialize the filter; we pass NULL options, since we have already

* set all the options above. */

err = avfilter_init_str(abuffer_ctx, NULL);

if (err < 0) {

fprintf(stderr, "Could not initialize the abuffer filter.\n");

return err;

}

/* Create volume filter. */

volume = avfilter_get_by_name("volume");

if (!volume) {

fprintf(stderr, "Could not find the volume filter.\n");

return AVERROR_FILTER_NOT_FOUND;

}

volume_ctx = avfilter_graph_alloc_filter(filter_graph, volume, "volume");

if (!volume_ctx) {

fprintf(stderr, "Could not allocate the volume instance.\n");

return AVERROR(ENOMEM);

}

/* A different way of passing the options is as key/value pairs in a

* dictionary. */

av_dict_set(&options_dict, "volume", AV_STRINGIFY(VOLUME_VAL), 0);

err = avfilter_init_dict(volume_ctx, &options_dict);

av_dict_free(&options_dict);

if (err < 0) {

fprintf(stderr, "Could not initialize the volume filter.\n");

return err;

}

/* Create the aformat filter;

* it ensures that the output is of the format we want. */

aformat = avfilter_get_by_name("aformat");

if (!aformat) {

fprintf(stderr, "Could not find the aformat filter.\n");

return AVERROR_FILTER_NOT_FOUND;

}

aformat_ctx = avfilter_graph_alloc_filter(filter_graph, aformat, "aformat");

if (!aformat_ctx) {

fprintf(stderr, "Could not allocate the aformat instance.\n");

return AVERROR(ENOMEM);

}

/* A third way of passing the options is in a string of the form

* key1=value1:key2=value2.... */

snprintf(options_str, sizeof(options_str),

"sample_fmts=%s:sample_rates=%d:channel_layouts=0x%"PRIx64,

av_get_sample_fmt_name(AV_SAMPLE_FMT_S16), 44100,

(uint64_t)AV_CH_LAYOUT_STEREO);

err = avfilter_init_str(aformat_ctx, options_str);

if (err < 0) {

av_log(NULL, AV_LOG_ERROR, "Could not initialize the aformat filter.\n");

return err;

}

/* Finally create the abuffersink filter;

* it will be used to get the filtered data out of the graph. */

abuffersink = avfilter_get_by_name("abuffersink");

if (!abuffersink) {

fprintf(stderr, "Could not find the abuffersink filter.\n");

return AVERROR_FILTER_NOT_FOUND;

}

abuffersink_ctx = avfilter_graph_alloc_filter(filter_graph, abuffersink, "sink");

if (!abuffersink_ctx) {

fprintf(stderr, "Could not allocate the abuffersink instance.\n");

return AVERROR(ENOMEM);

}

/* This filter takes no options. */

err = avfilter_init_str(abuffersink_ctx, NULL);

if (err < 0) {

fprintf(stderr, "Could not initialize the abuffersink instance.\n");

return err;

}

/* Connect the filters;

* in this simple case the filters just form a linear chain. */

err = avfilter_link(abuffer_ctx, 0, volume_ctx, 0);

if (err >= 0)

err = avfilter_link(volume_ctx, 0, aformat_ctx, 0);

if (err >= 0)

err = avfilter_link(aformat_ctx, 0, abuffersink_ctx, 0);

if (err < 0) {

fprintf(stderr, "Error connecting filters\n");

return err;

}

/* Configure the graph. */

err = avfilter_graph_config(filter_graph, NULL);

if (err < 0) {

av_log(NULL, AV_LOG_ERROR, "Error configuring the filter graph\n");

return err;

}

*graph = filter_graph;

*src = abuffer_ctx;

*sink = abuffersink_ctx;

return 0;

}

/* Do something useful with the filtered data: this simple

* example just prints the MD5 checksum of each plane to stdout. */

static int process_output(struct AVMD5 *md5, AVFrame *frame)

{

int planar = av_sample_fmt_is_planar(frame->format);

int channels = av_get_channel_layout_nb_channels(frame->channel_layout);

int planes = planar ? channels : 1;

int bps = av_get_bytes_per_sample(frame->format);

int plane_size = bps * frame->nb_samples * (planar ? 1 : channels);

int i, j;

for (i = 0; i < planes; i++) {

uint8_t checksum[16];

av_md5_init(md5);

av_md5_sum(checksum, frame->extended_data[i], plane_size);

fprintf(stdout, "plane %d: 0x", i);

for (j = 0; j < sizeof(checksum); j++)

fprintf(stdout, "%02X", checksum[j]);

fprintf(stdout, "\n");

}

fprintf(stdout, "\n");

return 0;

}

/* Construct a frame of audio data to be filtered;

* this simple example just synthesizes a sine wave. */

static int get_input(AVFrame *frame, int frame_num)

{

int err, i, j;

#define FRAME_SIZE 1024

/* Set up the frame properties and allocate the buffer for the data. */

frame->sample_rate = INPUT_SAMPLERATE;

frame->format = INPUT_FORMAT;

frame->channel_layout = INPUT_CHANNEL_LAYOUT;

frame->nb_samples = FRAME_SIZE;

frame->pts = frame_num * FRAME_SIZE;

err = av_frame_get_buffer(frame, 0);

if (err < 0)

return err;

/* Fill the data for each channel. */

for (i = 0; i < 5; i++) {

float *data = (float*)frame->extended_data[i];

for (j = 0; j < frame->nb_samples; j++)

data[j] = sin(2 * M_PI * (frame_num + j) * (i + 1) / FRAME_SIZE);

}

return 0;

}

int main(int argc, char *argv[])

{

struct AVMD5 *md5;

AVFilterGraph *graph;

AVFilterContext *src, *sink;

AVFrame *frame;

uint8_t errstr[1024];

float duration;

int err, nb_frames, i;

if (argc < 2) {

fprintf(stderr, "Usage: %s <duration>\n", argv[0]);

return 1;

}

duration = atof(argv[1]);

nb_frames = duration * INPUT_SAMPLERATE / FRAME_SIZE;

if (nb_frames <= 0) {

fprintf(stderr, "Invalid duration: %s\n", argv[1]);

return 1;

}

/* Allocate the frame we will be using to store the data. */

frame = av_frame_alloc();

if (!frame) {

fprintf(stderr, "Error allocating the frame\n");

return 1;

}

md5 = av_md5_alloc();

if (!md5) {

fprintf(stderr, "Error allocating the MD5 context\n");

return 1;

}

/* Set up the filtergraph. */

err = init_filter_graph(&graph, &src, &sink);

if (err < 0) {

fprintf(stderr, "Unable to init filter graph:");

goto fail;

}

/* the main filtering loop */

for (i = 0; i < nb_frames; i++) {

/* get an input frame to be filtered */

err = get_input(frame, i);

if (err < 0) {

fprintf(stderr, "Error generating input frame:");

goto fail;

}

/* Send the frame to the input of the filtergraph. */

err = av_buffersrc_add_frame(src, frame);

if (err < 0) {

av_frame_unref(frame);

fprintf(stderr, "Error submitting the frame to the filtergraph:");

goto fail;

}

/* Get all the filtered output that is available. */

while ((err = av_buffersink_get_frame(sink, frame)) >= 0) {

/* now do something with our filtered frame */

err = process_output(md5, frame);

if (err < 0) {

fprintf(stderr, "Error processing the filtered frame:");

goto fail;

}

av_frame_unref(frame);

}

if (err == AVERROR(EAGAIN)) {

/* Need to feed more frames in. */

continue;

} else if (err == AVERROR_EOF) {

/* Nothing more to do, finish. */

break;

} else if (err < 0) {

/* An error occurred. */

fprintf(stderr, "Error filtering the data:");

goto fail;

}

avfilter_graph_free(&graph);

av_frame_free(&frame);

av_freep(&md5);

return 0;

fail:

av_strerror(err, errstr, sizeof(errstr));

fprintf(stderr, "%s\n", errstr);

return 1;

}

//视频参数改变

#include <libavutil/imgutils.h>

#include <libavutil/parseutils.h>

#include <libswscale/swscale.h>

static void fill_yuv_image(uint8_t *data[4], int linesize[4],

int width, int height, int frame_index)

{

int x, y;

/* Y */

for (y = 0; y < height; y++)

for (x = 0; x < width; x++)

data[0][y * linesize[0] + x] = x + y + frame_index * 3;

/* Cb and Cr */

for (y = 0; y < height / 2; y++) {

for (x = 0; x < width / 2; x++) {

data[1][y * linesize[1] + x] = 128 + y + frame_index * 2;

data[2][y * linesize[2] + x] = 64 + x + frame_index * 5;

}

int main(int argc, char **argv)

{

uint8_t *src_data[4], *dst_data[4];

int src_linesize[4], dst_linesize[4];

int src_w = 320, src_h = 240, dst_w, dst_h;

enum AVPixelFormat src_pix_fmt = AV_PIX_FMT_YUV420P, dst_pix_fmt = AV_PIX_FMT_RGB24;

const char *dst_size = NULL;

const char *dst_filename = NULL;

FILE *dst_file;

int dst_bufsize;

struct SwsContext *sws_ctx;

int i, ret;

if (argc != 3) {

fprintf(stderr, "Usage: %s output_file output_size\n"

"API example program to show how to scale an image with libswscale.\n"

"This program generates a series of pictures, rescales them to the given "

"output_size and saves them to an output file named output_file\n."

"\n", argv[0]);

exit(1);

}

dst_filename = argv[1];

dst_size = argv[2];

if (av_parse_video_size(&dst_w, &dst_h, dst_size) < 0) {

fprintf(stderr,

"Invalid size '%s', must be in the form WxH or a valid size abbreviation\n",

dst_size);

exit(1);

}

dst_file = fopen(dst_filename, "wb");

if (!dst_file) {

fprintf(stderr, "Could not open destination file %s\n", dst_filename);

exit(1);

}

/* create scaling context */

sws_ctx = sws_getContext(src_w, src_h, src_pix_fmt,

dst_w, dst_h, dst_pix_fmt,

SWS_BILINEAR, NULL, NULL, NULL);

if (!sws_ctx) {

fprintf(stderr,

"Impossible to create scale context for the conversion "

"fmt:%s s:%dx%d -> fmt:%s s:%dx%d\n",

av_get_pix_fmt_name(src_pix_fmt), src_w, src_h,

av_get_pix_fmt_name(dst_pix_fmt), dst_w, dst_h);

ret = AVERROR(EINVAL);

goto end;

}

/* allocate source and destination image buffers */

if ((ret = av_image_alloc(src_data, src_linesize,

src_w, src_h, src_pix_fmt, 16)) < 0) {

fprintf(stderr, "Could not allocate source image\n");

goto end;

}

/* buffer is going to be written to rawvideo file, no alignment */

if ((ret = av_image_alloc(dst_data, dst_linesize,

dst_w, dst_h, dst_pix_fmt, 1)) < 0) {

fprintf(stderr, "Could not allocate destination image\n");

goto end;

}

dst_bufsize = ret;

for (i = 0; i < 100; i++) {

/* generate synthetic video */

fill_yuv_image(src_data, src_linesize, src_w, src_h, i);

/* convert to destination format */

sws_scale(sws_ctx, (const uint8_t * const*)src_data,

src_linesize, 0, src_h, dst_data, dst_linesize);

/* write scaled image to file */

fwrite(dst_data[0], 1, dst_bufsize, dst_file);

}

fprintf(stderr, "Scaling succeeded. Play the output file with the command:\n"

"ffplay -f rawvideo -pix_fmt %s -video_size %dx%d %s\n",

av_get_pix_fmt_name(dst_pix_fmt), dst_w, dst_h, dst_filename);

end:

fclose(dst_file);

av_freep(&src_data[0]);

av_freep(&dst_data[0]);

sws_freeContext(sws_ctx);

return ret < 0;

}

//音频重新采样

#include <libavutil/opt.h>

#include <libavutil/channel_layout.h>

#include <libavutil/samplefmt.h>

#include <libswresample/swresample.h>

static int get_format_from_sample_fmt(const char **fmt,

enum AVSampleFormat sample_fmt)

{

int i;

struct sample_fmt_entry {

enum AVSampleFormat sample_fmt; const char *fmt_be, *fmt_le;

} sample_fmt_entries[] = {

{ AV_SAMPLE_FMT_U8, "u8", "u8" },

{ AV_SAMPLE_FMT_S16, "s16be", "s16le" },

{ AV_SAMPLE_FMT_S32, "s32be", "s32le" },

{ AV_SAMPLE_FMT_FLT, "f32be", "f32le" },

{ AV_SAMPLE_FMT_DBL, "f64be", "f64le" },

};

*fmt = NULL;

for (i = 0; i < FF_ARRAY_ELEMS(sample_fmt_entries); i++) {

struct sample_fmt_entry *entry = &sample_fmt_entries[i];

if (sample_fmt == entry->sample_fmt) {

*fmt = AV_NE(entry->fmt_be, entry->fmt_le);

return 0;

}

fprintf(stderr,

"Sample format %s not supported as output format\n",

av_get_sample_fmt_name(sample_fmt));

return AVERROR(EINVAL);

}

/**

* Fill dst buffer with nb_samples, generated starting from t.

static void fill_samples(double *dst, int nb_samples, int nb_channels, int sample_rate, double *t)

{

int i, j;

double tincr = 1.0 / sample_rate, *dstp = dst;

const double c = 2 * M_PI * 440.0;

/* generate sin tone with 440Hz frequency and duplicated channels */

for (i = 0; i < nb_samples; i++) {

*dstp = sin(c * *t);

for (j = 1; j < nb_channels; j++)

dstp[j] = dstp[0];

dstp += nb_channels;

*t += tincr;

}

int main(int argc, char **argv)

{

int64_t src_ch_layout = AV_CH_LAYOUT_STEREO, dst_ch_layout = AV_CH_LAYOUT_SURROUND;

int src_rate = 48000, dst_rate = 44100;

uint8_t **src_data = NULL, **dst_data = NULL;

int src_nb_channels = 0, dst_nb_channels = 0;

int src_linesize, dst_linesize;

int src_nb_samples = 1024, dst_nb_samples, max_dst_nb_samples;

enum AVSampleFormat src_sample_fmt = AV_SAMPLE_FMT_DBL, dst_sample_fmt = AV_SAMPLE_FMT_S16;

const char *dst_filename = NULL;

FILE *dst_file;

int dst_bufsize;

const char *fmt;

struct SwrContext *swr_ctx;

double t;

int ret;

if (argc != 2) {

fprintf(stderr, "Usage: %s output_file\n"

"API example program to show how to resample an audio stream with libswresample.\n"

"This program generates a series of audio frames, resamples them to a specified "

"output format and rate and saves them to an output file named output_file.\n",

argv[0]);

exit(1);

}

dst_filename = argv[1];

dst_file = fopen(dst_filename, "wb");

if (!dst_file) {

fprintf(stderr, "Could not open destination file %s\n", dst_filename);

exit(1);

}

/* create resampler context */

swr_ctx = swr_alloc();

if (!swr_ctx) {

fprintf(stderr, "Could not allocate resampler context\n");

ret = AVERROR(ENOMEM);

goto end;

}

/* set options */

av_opt_set_int(swr_ctx, "in_channel_layout", src_ch_layout, 0);

av_opt_set_int(swr_ctx, "in_sample_rate", src_rate, 0);

av_opt_set_sample_fmt(swr_ctx, "in_sample_fmt", src_sample_fmt, 0);

av_opt_set_int(swr_ctx, "out_channel_layout", dst_ch_layout, 0);

av_opt_set_int(swr_ctx, "out_sample_rate", dst_rate, 0);

av_opt_set_sample_fmt(swr_ctx, "out_sample_fmt", dst_sample_fmt, 0);

/* initialize the resampling context */

if ((ret = swr_init(swr_ctx)) < 0) {

fprintf(stderr, "Failed to initialize the resampling context\n");

goto end;

}

/* allocate source and destination samples buffers */

src_nb_channels = av_get_channel_layout_nb_channels(src_ch_layout);

ret = av_samples_alloc_array_and_samples(&src_data, &src_linesize, src_nb_channels,

src_nb_samples, src_sample_fmt, 0);

if (ret < 0) {

fprintf(stderr, "Could not allocate source samples\n");

goto end;

}

/* compute the number of converted samples: buffering is avoided

* ensuring that the output buffer will contain at least all the

* converted input samples */

max_dst_nb_samples = dst_nb_samples =

av_rescale_rnd(src_nb_samples, dst_rate, src_rate, AV_ROUND_UP);

/* buffer is going to be directly written to a rawaudio file, no alignment */

dst_nb_channels = av_get_channel_layout_nb_channels(dst_ch_layout);

ret = av_samples_alloc_array_and_samples(&dst_data, &dst_linesize, dst_nb_channels,

dst_nb_samples, dst_sample_fmt, 0);

if (ret < 0) {

fprintf(stderr, "Could not allocate destination samples\n");

goto end;

}

t = 0;

do {

/* generate synthetic audio */

fill_samples((double *)src_data[0], src_nb_samples, src_nb_channels, src_rate, &t);

/* compute destination number of samples */

dst_nb_samples = av_rescale_rnd(swr_get_delay(swr_ctx, src_rate) +

src_nb_samples, dst_rate, src_rate, AV_ROUND_UP);

if (dst_nb_samples > max_dst_nb_samples) {

av_freep(&dst_data[0]);

ret = av_samples_alloc(dst_data, &dst_linesize, dst_nb_channels,

dst_nb_samples, dst_sample_fmt, 1);

if (ret < 0)

break;

max_dst_nb_samples = dst_nb_samples;

}

/* convert to destination format */

ret = swr_convert(swr_ctx, dst_data, dst_nb_samples, (const uint8_t **)src_data, src_nb_samples);

if (ret < 0) {

fprintf(stderr, "Error while converting\n");

goto end;

}

dst_bufsize = av_samples_get_buffer_size(&dst_linesize, dst_nb_channels,

ret, dst_sample_fmt, 1);

if (dst_bufsize < 0) {

fprintf(stderr, "Could not get sample buffer size\n");

goto end;

}

printf("t:%f in:%d out:%d\n", t, src_nb_samples, ret);

fwrite(dst_data[0], 1, dst_bufsize, dst_file);

} while (t < 10);

if ((ret = get_format_from_sample_fmt(&fmt, dst_sample_fmt)) < 0)

goto end;

fprintf(stderr, "Resampling succeeded. Play the output file with the command:\n"

"ffplay -f %s -channel_layout %"PRId64" -channels %d -ar %d %s\n",

fmt, dst_ch_layout, dst_nb_channels, dst_rate, dst_filename);

end:

fclose(dst_file);

if (src_data)

av_freep(&src_data[0]);

av_freep(&src_data);

if (dst_data)

av_freep(&dst_data[0]);

av_freep(&dst_data);

swr_free(&swr_ctx);

return ret < 0;

}

ffmpeg4.2重要结构说明

AVFrame

打开文件夹：avio_open_dir()

读取文件夹：avio_read_dir()

关闭文件夹：avio_close_dir()

结构体, 操作目录的上下文：AVIODirContext()

目录项，用于存放文件名，文件大小等信息：AVIODirEntry()

#include <libavutil/log.h>

#include <libavformat/avformat.h>

int main(int arc, char *argv[])

{

int ret;

// 文件内容上下文

AVIODirContext *ctx = NULL;

// 文件信息上下文

AVIODirEntry *entry = NULL;

// 设置日志等级

av_log_set_level(AV_LOG_INFO);

// 打开文件夹, ctx：上下文， ./当前文件夹

ret = avio_open_dir(&ctx, "./", NULL);

if (ret < 0){

av_log(NULL, AV_LOG_ERROR, "找不到文件夹%s\n", av_err2str(ret));

return -1;

}

while(1){

// 读文件夹操作

ret = avio_read_dir(ctx, &entry);

// 如果读取失败

if (ret < 0){

av_log(NULL, AV_LOG_ERROR, "Cant read dir: %s\n", av_err2str(ret));

// return -1; 这里直接退出可能会忘记文件的退出，照成内存泄漏，使用goto

goto __fail;

}

// 如果读取成功，需要判断一下entry

if(!entry){

break;

}

// 打印文件信息, PRId64 是 64的宏信息

av_log(NULL, AV_LOG_INFO, "%12"PRId64" %s \n",

entry->size,

entry->name);

// 要进行entry的释放

avio_free_directory_entry(&entry);

}

// 关闭文件夹

__fail:

avio_close_dir(&ctx);

return 0;

}

ffmpeg添加实时水印

这次需要测试直播延时，添加一个实时的时间水印方便对比，命令如下：

ffmpeg -i src.mp4 -c:v h264 -vf drawtext=text="%{localtime}":x=100:y=100:fontfile='C\:\\Windows\\fonts\\Arial.ttf':fontsize=24:fontcolor=red -c:a aac -f mpegts udp://127.0.0.1:6000

FFmpeg不必写入文件。它可以写到stdout:

ffmpeg -i $input -f mp3 -

-表示标准输出。由于没有文件名，因此需要使用-f指定格式。

如果这样调用它，则可以直接从Process的InputStream读取mp3流。

ffmpeg怎么把批量的图片生成视频

我给出正解：

ffmpeg -i /mnt/11m夜店_H264.vod /mnt/h264/ffmpeg-0.5.1/picture/1m%04d.jpg -vcodec mjpeg -ss 0:1:2 -t 0:0:1

以上将视频 1分02秒处开始，持续1秒长的视频输出为jpg的序列

-ss 起始时间

-t 持续时间。

如果你要从片头开始，转换前2分钟为图片序列，则是：

ffmpeg -i /mnt/11m夜店_H264.vod /mnt/h264/ffmpeg-0.5.1/picture/1m%04d.jpg -vcodec mjpeg -ss 0:0:0 -t 0:2:0

另外告诉你，输出的图片数量是25/s的

ffmpeg常用命令-调整视频颜色

1.hue：调整视频色调、饱和度、亮度

h:色调角度度数（0到360），默认值为0

s:饱和度（-10到10），默认值为1

b:亮度（-10到10），默认值为0

命令格式：ffmpeg -i 源视频地址 -vf hue=s=1:b=1:h=90 -b 输出比特率输出视频地址

使用例子：ffmpeg -i d:\2.flv -vf hue=b=1 -b 600k d:\outTemp.flv（调整饱和度）

2.colorbalance：颜色平衡，调整RGB得值的权重，分为三个阶层，用于调整饱和度和调整颜色偏移值

rs、gs、bs:调整红色，绿色和蓝色阴影（最暗的像素）（范围：-1到1）

rm、gm、bm:调整红色，绿色和蓝色中间色（中等像素）（范围：-1到1）

rh、gh、bh:调整红色，绿色和蓝色的亮点（最亮的像素）（范围：-1到1）

命令格式：ffmpeg -i 源视频地址 -vf colorbalance=rh=.3:gh=.3:bh=.3 -b 输出比特率输出视频地址

使用例子：ffmpeg -i d:\2.flv -vf colorbalance=rh=.3 -b 600k d:\outTemp.flv（增加红色权重）

3.给视频增加背景音乐

命令格式：

FFMPEG 滤镜使用

简单滤镜通常是指处理的滤镜中包含一个或多个滤镜链(filterchain)，当包含多个滤镜时，每个滤镜以逗号分隔构成一个滤镜序列，这样的滤镜序列被称之为滤镜链(filterchain)。语法如下：

filter1,fiter2,filter3,...,filterN-2,filterN-1,filterN

ffmpeg -i src.mp4-vf hqdn3d,pad=2*iw dest.mp4

-i src.mp4：指定输入音/视频源；

-vf：指定简单视频滤镜，“-vf”等同“-filter:v”,

如果处理音频，该参数应为"-af"，且“-af”等同“-filter:a”;

"hqdn3d,pad=2*iw"：表示包含两个滤镜的滤镜链，其中"hqdn3d"滤镜用于降噪、"pad=2*iw"滤镜用于将图像的宽度填充到输入宽度的2倍；

dest.mp4：输出视频，为输入视频经过降噪、填充宽度后的输出结果。

ffmpeg B 站命令行

ffmpeg史诗级教学

ffmpeg将多个视频拼接,并有转场效果

利用ffmpeg命令将多个视频拼接起来并有转场效果

ffmpeg -i v0.mp4 -i v1.mp4 -i v2.mp4 -i v3.mp4 -i v4.mp4 -filter_complex \

'[0][1]xfade=transition=hlslice:duration=1:offset=2[V01]; \

[V01][2]xfade=transition=radial:duration=1:offset=4[V02]; \

[V02][3]xfade=transition=dissolve:duration=1:offset=6[V03]; \

[V03][4]xfade=transition=vuslice:duration=1:offset=8,format=yuv420p[video]; \

[0:a][1:a]acrossfade=d=0.5:c1=tri:c2=tri[A01]; \

[A01][2:a]acrossfade=d=0.5:c1=tri:c2=tri[A02]; \

[A02][3:a]acrossfade=d=0.5:c1=tri:c2=tri[A03]; \

[A03][4:a]acrossfade=d=0.5:c1=tri:c2=tri[audio]' \

-map '[video]' -map '[audio]' -movflags +faststart xfade.mp4

我用的java ffmpeg.exe -i input1.p4 -i input2.mp4 -filter_complex xfade=transition=fade:duration=2:offset=2 out.mp4 -y 这种只能有一种转场特效

xfade=transition=xxxxxxxx这个地方可以填几十种啊。

https://ffmpeg.org/ffmpeg-filters.html#xfade

transition

Set one of available transition effects:

‘custom’

‘fade’

‘wipeleft’

‘wiperight’

‘wipeup’

‘wipedown’

‘slideleft’

‘slideright’

‘slideup’

‘slidedown’

‘circlecrop’

‘rectcrop’

‘distance’

‘fadeblack’

‘fadewhite’

‘radial’

‘smoothleft’

‘smoothright’

‘smoothup’

‘smoothdown’

‘circleopen’

‘circleclose’

‘vertopen’

‘vertclose’

‘horzopen’

‘horzclose’

‘dissolve’

‘pixelize’

‘diagtl’

‘diagtr’

‘diagbl’

‘diagbr’

‘hlslice’

‘hrslice’

‘vuslice’

‘vdslice’

‘hblur’

‘fadegrays’

‘wipetl’

‘wipetr’

‘wipebl’

‘wipebr’

‘squeezeh’

‘squeezev’

FFmpeg 最强视频处理使用指南

FFmpeg 最强视频处理使用指南

由于工作原因，这几年接触到了一些视频的处理工作，大多数时候是简单的视频剪辑、剪切、合并、格式转换、转码等等这样的操作。很多时候要处理视频都很大，我的电脑配置也不高，5年前的老电脑了，碰到这种1-2个G的文件，都是我可以放松去喝茶喝散步的时候，那时候就开始想寻找一款不是非编的，专门处理视频的这种工具，好在功夫不负有心人，让我遇到了FFmpeg，使用起来也大概有3年左右的时间了，积累了一些心得，这里分享给大家，一是在回答很多问题的时候，提到了这个工具，有很多网友会私信问我如何使用，这里一个文章统一回复了，再者也为了自己做个总结，还能把知识点当成备份吧。

虽然这个文章是作为FFmpeg的使用指南，假定您是具有基础知识的阅读者，不过为了照顾部分朋友，我还是先从安装说起吧，争取快速简洁。

下载安装：

Download FFmpeg 这个是官网，打开这个官方网站下载，不过请注意！！不要点击绿色的那个DOWNLOAD，而是点下面的windows标识，要不然给你下载链接好了：FFmpeg Builds - Zeranoe

这样下载好后解压缩到D盘的某个目录下，比如D:\Ffmpeg ,然后请把这个目录添加到系统的path目录内.

这样的好处是在打开CMD控制台，在任何目录下，只要输入FFMPEG，都可以无障碍运行。

接下来是常用的指令和参数：

1.【切割MP3，按时间准确切割】ffmpeg -i F:\源.mp3 -ss 00:20:00 -to 02:30:05 F:\目标文件.mp3

2.【MTS-->MP4】ffmpeg -i F:\源.mts -b 4M -s 1280*720 F:\结果.mp4

说明：（-b 4m：码率是4M；-s 1280*720：这个是设定视频大小。这2个参数其实可以删掉）

3.【MP4-->WMV】:ffmpeg -i f:\视频.mp4 -b 4M f:\out.wmv

4.【MP4图像旋转】ffmpeg -i f:\o.mp4 -vf "transpose=1" f:\o2.mp4

说明：主要参数： -vf "transpose=1" ，这里等于1是顺时针90度旋转；如果用手机录制的时候录反了，则执行2次这个操作就正过来了

5.【MP4-->MP4改尺寸】ffmpeg -i G:\源.mp4 -b 4M -s 640*340 g:\OUT.mp4

6.【MP4-->MP4改尺寸加水印】ffmpeg -i G:\源.mp4 -vf "movie=logo.png [logo];[in][logo] overlay=10:20 [out]" -b 2M -s 640*340 g:\OUT.mp4

说明：1: -vf "movie=logo.png [logo];[in][logo] overlay=10:20 [out]" 这里面的是加水印的参数，logo.png是我自己做的PNG水印，大小300*100,10:20是水印的位置，为了方便，就把logo.png拷贝到FFMPEg的bin目录下(必须放，加路径就失败)，这样不用再加路径了 ;2: -b 2M 是用2M压缩率; 3: -s 640*340 意思是图像分辨率改为640*340

7.【快速剪切某段视频作为输出】ffmpeg -i H:\源.mpg -ss 0:0:0 -to 0:23:20 -c copy G:\OUT.MP4

说明：上面截取 H:\源.mpg 这个视频，从第0秒开始，到23分20秒，这样一段，保存到G:\out.mp4，注意参数必须是 -c copy ，这样执行起来特别快，也就不到半分钟就搞定。

8.【该编码为H265,让MP4瘦身2/3，1G的MP4可以压缩到300M】 ffmpeg -i 源.MP4 -vcodec libx265 -acodec copy F:\OUT.MP4

9.【WAV转换格式到amr】ffmpeg -i test.wav -acodec libamr_nb -ab 12.2k -ar 8000 -ac 1 wav2amr.amr

10.【提取视频中的声音保存成一个mp3】ffmpeg -i 源.mp4 输出.mp3

11.【要实现批量转换，可以直接用这个批处理文件】

for %%i in (*.mkv) do ffmpeg.exe -i "%%i" -vcodec copy -acodec copy "%%~ni.mp4"

12.【合并多个MP4为一个】

这个比较复杂，我在其他地方看到的是这样的:

ffmpeg -i INPUT1.MP4 -i INPUT2.MP4 -f FORMAT -acodec AUDIOCODEC -vcodec VIDEOCODEC -sameq OUTPUT.MP4

主要不同的地方就在-i 这里，有几个源文件，就用几个 -i ,但是这种方法我实验了很多次，都没成功(我猜测可能是文件或者目录带中文，但是cmd不能很好的识别)，所以我使用的是下面这种方法：

先创建一个文本文件filelist.txt

内容如下:(注意input1、2、3是你的文件的名字，都在该目录下)

file 'input1.mp4'

file 'input2.mp4'

file 'input3.mp4'

以上是这个文本文件的内容，保存后，在命令行执行

ffmpeg -f concat -i filelist.txt -c copy output.mp4

这样就完成了合并了。

13.【下载直播流】FFmpeg -i xxxxxxxxx.m3u8 -c copy out.mp4

这里需要注意，m3u8这个文件需要自己去获取，方法可以用开发者模式抓去即可。

ffmpeg高级命令行

1、知道了视频流地址如何保存出本地文件：

ffmpeg -i rtmp://122.202.129.136:1935/live/ch4 -map 0 d:\work\yyy.mp4

2、知道了流地址，播放视频文件：

ffplay -rtsp_transport tcp rtsp://192.168.201.133:554/stream1.sdp

3、提取视频中的音频文件：

ffmpeg -i h:\work\yyy.avi -map 0:a d:\work\yyy.mp3

ffmpeg -i rtmp://122.202.129.136:1935/live/ch4 -map 0:a d:\work\yyy.mp3

4、提起多媒体中的视频（不要音频）

ffmpeg -i rtmp://122.202.129.136:1935/live/ch4 -map 0:v d:\work\yyy.mp4

5、把音频的左右声道分别保存为两个文件：

ffmpeg -i d:\work\yyy.mp3 -map_channel 0.0.0 d:\work\ch1.mp3 -map_channel 0.0.1 d:\work\ch2.mp3

6、把视频的音视频同时分为两个文件保存：

ffmpeg -i h:\work\video.mp4 -map 0:v d:\work\video2.mp4 -map 0:a d:\work\video.mp3

7、把单纯的视频和单纯的音频合并为一个视频文件：

ffmpeg -i d:\work\out.mp4 -i d:\work\video.amr -map 0:v -map 1:a d:\work\strange.mp4

8、在视频的屏幕左上角加一个logo标志：

ffmpeg -i h:\work\video.mp4 -i h:\work\psu.png -filter_complex 'overlay' d:\work\video.mp4

9、输出视频的yuv数据：

ffmpeg -i d:\work\video.mp4 d:\work\hugefile.yuv

10、把视频的图像批量输出（(-r 1)一秒钟保存一张，缩放为640*480，名称为foo-001.jpeg, foo-002.jpeg......）：

ffmpeg -i h:\work\video.mp4 -r 1 -s 640x480 -f image2 d:\work\foo-%03d.jpeg

还可以添加更多参数

ffmpeg -i h:\work\video.mp4 -r 1 -ss 50 -vframes 3 -s 640x480 -f image2 d:\work\foo-%03d.jpeg

11、把一堆图像合成为一个视频：

ffmpeg -f image2 -framerate 25 -i d:\work\foo-%03d.jpeg -s 1280x720 h:\work\foo.avi

12、转换视频的分辨率：

ffmpeg -i D:\work\hisense1.mp4 -vcodec libx264 -s 640x480 -acodec aac -strict experimental -ar 44100 -ac 2 -b:a 96k D:\work\outputfile.mp4

13、直接将视频变为原来大小的一半：

ffmpeg -i D:\work\yyy2642.mp4 -vf scale=iw/2:ih/2 D:\work\yyy2642sm.mp4

14、裁剪视频中间的一段视频为一个单独视频：

ffmpeg -ss 00:00:30 -vsync 0 -t 00:00:30 -i D:\work\yyy2642.mp4 -vcodec libx264-acodec libfaac D:\work\outputfile.mp4

15、裁剪出视频屏幕正中间的一部分，宽度和高度都是原来视频的一半：

ffmpeg -i D:\work\yyy2642.mp4 -vf crop=iw/2:ih/2 D:\work\yyy2642sm.mp4

16、裁剪出视频屏幕任意一部分（注意参数）：

ffmpeg -i D:\work\yyy2642.mp4 -vf crop=iw/3:ih/3:100:100 D:\work\yyy2642sm.mp4

17、播放时自动检测视频周围的黑框（播放时，输出窗口可以看到检测出的crop），这个其实不是视频处理，只是播放效果：

ffplay D:\work\yyy2642.mp4 -vf cropdetect

18、在视频的四周增加一圈30个像素的粉红色边框：

ffmpeg -i D:\work\yyy2642sm.mp4 -vf pad=iw+60:ih+60:30:30:pink D:\work\pink.mp4

19、视频水平翻转：

ffmpeg -i D:\work\yyy2642.mp4 -vf hflip D:\work\outputfile.mp4

20、视频上下翻转：

ffmpeg -i D:\work\yyy2642.mp4 -vf vflip D:\work\outputfile.mp4

21、视频旋转：

ffmpeg -i D:\work\yyy2642.mp4 -vf transpose=2 D:\work\outputfile.mp4

22、视频模糊处理（注意参数），可以让视频变模糊：

ffmpeg -i D:\work\yyy2642.mp4 -vf boxblur=1:10:4:10 D:\work\outputfile.mp4

23、视频锐化处理，一定程度可以让视频变清晰：

ffmpeg -i D:\work\yyy2642.mp4 -vf unsharp=5:5:1.0:5:5:0.0 D:\work\outputfile.mp4

24、删除标志logo:

ffmpeg -i D:\work\outputfile.mp4 -vf delogo=10:10:256:256:0:0 D:\work\outputfile1.mp4

25、添加文字到视频上

ffmpeg -i D:\work\yyy2642.mp4 -vf drawtext="fontfile=arial.ttf:text='Happy Holidays':x=(w-tw)/2:y=(h-th)/2:fontcolor=green:fontsize=60" D:\work\outputfile.mp4

其中arial.ttf是从windows\fonts目录下拷贝过来的字体文件

26、添加上方的字符滚动显示（显示中文字符）：

ffmpeg -i D:\work\yyy2642.mp4 -vf drawtext="fontfile=ARIALUNI.ttf:text='程序明_Welcom':x=w-mod(t*50\,w):fontcolor=darkorange:fontsize=30" D:\work\outputfile.mp4

添加的文字显示在下方：

ffmpeg -i D:\work\yyy2642.mp4 -vf drawtext="fontfile=ARIALUNI.ttf:text=' 程序明':x=w-mod(t*50\,w):y=h-th:fontcolor=darkorange:fontsize=30"

27、视频右上角显示当前系统时间：

ffmpeg -i D:\work\yyy2642.mp4 -vf drawtext="fontfile=arial.ttf:x=w-tw:fontcolor=white:fontsize=30:text='%{localtime\:%H\\\:%M\\\:%S}'" D:\work\outputfile.mp4

28、视频播放时晃动：

ffplay -i D:\work\yyy2642.mp4 -vf crop=in_w/2:in_h/2:(in_w-out_w)/2+((in_w-out_w)/2)*sin(n/10):(in_h-out_h)/2+((in_h-out_h)/2)*sin(n/7)

29、播放时视频色彩不断变换：

ffplay -i D:\work\yyy2642.mp4 -vf hue="H=2*PI*t:s=sin(2*PI*t)+1"

30、彩色视频转变为黑白视频：

ffmpeg -i D:\work\yyy2642.mp4 -vf lutyuv="u=128:v=128" D:\work\outputfile.mp4

31、视频转码为原来的播放速度的两倍：

ffmpeg -i D:\work\yyy2642.mp4 -vf setpts=PTS/2 -af atempo=2 D:\work\outputfile.mp4

32、视频转为gif（参数指定了位置）:

ffmpeg -i D:\work\yyy2642.mp4 -ss 50 -t 10 -pix_fmt rgb24 -s 640x480 D:\work\jidu.gif

33、从视频里面截取几张图到一张图里（大图是2行3列）：

ffmpeg -i D:\work\yyy2642.mp4 -frames 1 -vf "select=not(mod(n\,300)),scale=320:240,tile=2x3" D:\work\out.png

34、两个文件左右合并（无敌了）：

ffmpeg.exe -i "D:\work\yyy264.mp4" -vf "[in] scale=iw/2:ih/2, pad=2*iw:ih [left]; movie=\'D:\\work\\yyy2642.mp4\', scale=iw/2:ih/2 [right];[left][right] overlay=main_w/2:0 [out]" -b:v 768k D:\work\output.mp4

35、两个文件上下合并（无敌了）：

ffmpeg.exe -i "D:\work\yyy264.mp4" -vf "[in] scale=iw/2:ih/2, pad=iw:2*ih [top]; movie=\'D:\\work\\yyy2642.mp4\', scale=iw/2:ih/2 [bottom];[top][bottom] overlay=0:main_h/2 [out]" -b:v 768k D:\work\output.mp4

36、文件重叠合并，把第二个文件的视频缩小为四分之一后，放到第一个视频的宽高八分之一画面处（更无敌）：

ffmpeg.exe -i "D:\work\yyy264.mp4" -vf "[in] scale=iw:ih, pad=iw:ih [top]; movie=\'D:\\work\\yyy2642.mp4\', scale=iw/4:ih/4 [bottom];[top][bottom] overlay=main_w/8:main_h/8 [out]" -b:v 768k D:\work\output.mp4

37、普通的按顺序合并两个视频：

ffmpeg -i D:\work\yyy264.mp4 -qscale 0 D:\work\inputfile_01.mpg

ffmpeg -i D:\work\yyy2642.mp4 -qscale 0 D:\work\inputfile_02.mpg

copy /b "D:\work\inputfile_01.mpg"+"D:\work\inputfile_02.mpg" "D:\work\inputfile_all.mpg"

ffmpeg -i D:\work\inputfile_all.mpg -qscale 0 D:\work\outputfile.mp4

38、音频的分割合并

把第一段音频分成两部分

ffmpeg.exe -ss 00:00:08.5 -vsync 0 -t 00:00:09 -i file1.mp3 file1end.mp3

ffmpeg.exe -ss 00:00:00 -vsync 0 -t 00:00:08 -i file1.mp3 file1New.mp3

把第一段音频的后半部分和第二段混音合并

ffmpeg -i file2.mp3 -i file1end.mp3 -filter_complex amix=inputs=2:duration=first:dropout_transition=0 file2forNew1.mp3

把第二段音频混音好的音频，分成前后两部分：

ffmpeg.exe -ss 00:00:00 -vsync 0 -t 00:00:04 -i file2forNew1.mp3 file2New.mp3

ffmpeg.exe -ss 00:00:04 -vsync 0 -t 00:00:05 -i file3.mp3 file2End.mp3

再把第二段的后半部分和第三段混音合并：

ffmpeg -i file3.mp3 -i file2End.mp3 -filter_complex amix=inputs=2:duration=first:dropout_transition=0 file3New.mp3

把新的三部分音频首尾连接连到一起：

ffmpeg -i file1New.mp3 -qscale 0 inputfile_01.mpg

ffmpeg -i file2New.mp3 -qscale 0 inputfile_02.mpg

copy /b "inputfile_01.mpg"+"inputfile_02.mpg" "inputfile_all.mpg"

ffmpeg -i file3New.mp3 -qscale 0 inputfile_05.mpg

copy /b "inputfile_all.mpg"+"inputfile_05.mpg" "inputfile_al2.mpg"

ffmpeg -i inputfile_al2.mpg -qscale 0 file5.mp4

ffmpeg -i file5.mp4 -map 0:a result.mp3

上面的所有命令都是笔者自己亲自测试使用的，其中有些命令行带有不少参数，参数需要根据实际情况修改

使用FFmpeg删除视频中的音频

很多人想要知道如何从录制的视频中删除音轨，比如马路噪音或者背景噪音。

删除音频最简单的方法是：只将视频复制到一个新的文件中，而不复制音频。这个方法之所以简单，是因为它无需将视频重新编码。下面是删除音频的命令行：

ffmpeg.exe -i videoWithAudio.mp4 -c:v copy -an videoWithoutAudio.mp4

使用-c:v copy命令将视频复制到videoWithoutAudio.mp4

-an告诉FFmpeg不要复制音频

上述方法非常适用于电影中只有一个音轨的情况。但是，如果电影中有3~4个音轨，而你只想删除第二个音轨，该如何操作？

如何通过FFmpeg删除某个特定音轨？

我们在下一部分将学习到。

使用FFmpeg删除特定音频

你可以使用FFmpeg中的map命令来删除特定音轨。

map命令的通用语法是：

-map input_file_index:stream_type_specifier:stream_index

然后，你可以通过-map 0:a:1（从0开始计数）从视频中选择第二个音轨。在上文的例子中，如果你的文件中有一个视频和两个音轨，那么你就可以使用-map 0:a:1只选择第二个音轨，并将它复制到你的最终输出文件中。

同样，-map 0是指选择第一个输入文件中的所有数据（包括音频和视频），所以你需要先选择所有数据，然后取消选择音频。

ffmpeg.exe -i videoWithAudio.mp4 -map 0 -map 0:a:1 -copy videoOutput.mp4

如果电影中有5个音轨，除了第一个，其他你都想选择。这个时候你可以使用反向的map命令（在map命令的参数前加负号）。使用-map -0:a:0 这一命令，FFmpeg在选择时就会忽略第一个音轨。反向的map非常强大！

实际上，我们已在前文学习了使用 -an命令从视频中删除音频。你可以通过如下方式，使用反向的map来达到相同的效果。

ffmpeg -i videoWithAudio.mp4 -map 0 -map -0:a videoWithoutAudio.mp4

使用FFmpeg添加音频

你已经删除了一个音轨，那么你很可能想要再添加一个，对吧？下面我们将学习如何使用FFmpeg向视频中添加音频。

在前文中你已经学习了map命令的使用，因此添加音频对你来说应该很容易。命令行如下所示：

ffmpeg \

-i video.mp4 \

-i audio.mp3 \

-c copy \

-map 0:v:0 \

-map 1:a:0 \

videoWithAudio.mp4

上面的命令行很容易理解。你所做的就是使用map命令将视频和音频分别从不同的文件中复制到同一个输出文件。

-map 0:v:0 选择了第0个输入文件（视频输入）的第0个轨道。

–map 1:a:0 选择了第一个输入文件（音频输入）的第0个轨道。

不用重新编码，-c copy同时复制音轨和视轨到输出文件。如果你想要重新编码，可以选择合适的音视频编解码器，配置相应的编码质量。

使用FFmpeg从视频中提取音频

使用FFmpeg从视频提取音频是另一个非常有用且常见的操作。无论是否重新编码音频，你都可以这么做。

让我们先来看看第一种场景：不重新编码，直接从媒体文件中提取音频并保存下来。

提取音频意味着要舍弃掉视频，对吧？使用-vn 命令就可以帮助我们轻松删除视频。-vn命令与删除音频的-an命令类似。

然后，你所要做的就是将音频从源文件复制到目标文件。使用-acodec copy命令即可完成操作，该命令告诉FFmpeg只复制音频而不对其进行重新编码。

ffmpeg -i videoWithAudio.mp4 -vn -acodec copy onlyAudio.aac

很简单，对不对？

现在让我们看下另一种情况：当你提取音频后想要重新对它进行编码。下面是如何使用FFmpeg从视频中提取音频，然后使用libmp3lame将音频编码为不同的质量，并将其存储为mp3文件。

ffmpeg.exe -i videoWithAudio.mp4 -vn -c:a libmp3lame -q:a 1 onlyAudio.mp3

-q:a表示质量（在LAME文档中定义[1]），质量分布范围为0~6，其中0表示高质量音频，6表示低质量音频。

使用FFmpeg从视频中替换音频

如何替换已包含音频的视频中的音轨？这将是我们今天最后研究的一种场景。

在上文我们已经讨论过，有两个步骤：

删除音频

添加替换音频

但有没有更快更好的方法？

有了FFmpeg，总能找到更好的方法！

请看下列命令行：

-map input_file_index:stream_type_specifier:stream_index.

所以，你可以使用-map 1:a:2来选择第二个输入文件中的第三个音轨，因为计数从0开始。

ffmpeg -i video_with_audio.mp4 -i newAudio.wav \

-map 0:0 \

-map 1:0 \

-c:v copy \

-c:a libmp3lame -q:a 1 \

-shortest \

video_with_newAudio.mp4

在上文的例子中，我们需要从一个文件中获取视频以及另一个文件中获取音频。而map命令非常便捷地完成了上述操作。我们从第一个输入文件（视频）中选择第0个轨道，并从第2个输入文件（音频）中选择第0个轨道。

然后我们原样复制视频并重新编码音频，再将它们一起放入新的文件中。如果你不想重新编码音频，你只需使用-a:c copy命令，那么音频就只被复制而不会重新编码。

-shortest命令用于确保当达到较短的输入文件（两个输入文件之一）长度时停止转换。如果这个功能在你的用例中无关紧要，那么你可以不使用这一命令。

FFmpeg 调整音视频播放速度

FFmpeg对音频、视频播放速度的调整的原理不一样。下面简单的说一下各自的原理及实现方式：

一、调整视频速率

调整视频速率的原理为：修改视频的pts，dts

实现：

ffmpeg -i input.mkv -an -filter:v "setpts=0.5*PTS" output.mkv

注意：视频调整的速度倍率范围为：[0.25, 4]

如果只调整视频的话最好把音频禁掉。

对视频进行加速时，如果不想丢帧，可以用-r 参数指定输出视频FPS，方法如下:

ffmpeg -i input.mkv -an -r 60 -filter:v "setpts=2.0*PTS" output.mkv

二、调整音频速率

调整视频速率的原理为：简单的方法是调整音频采样率，但是这种方法会改变音色，一般采用通过对原音进行重采样，差值等方法。

ffmpeg -i input.mkv -filter:a "atempo=2.0" -vn output.mkv

注意：倍率调整范围为[0.5, 2.0]

如果需要调整4倍可采用以下方法：

ffmpeg -i input.mkv -filter:a "atempo=2.0,atempo=2.0" -vn output.mkv

如果需要同时调整，可以采用如下的方式来实现：

ffmpeg -i input.mkv -filter_complex "[0:v]setpts=0.5*PTS[v];[0:a]atempo=2.0[a]" -map "[v]" -map "[a]" output.mkv

FFmpeg视频剪辑常用命令

常见命令:

视频局部裁剪：

-i input.mp4 -b:v 2048k -vf crop=828:462:0:665 -ss 22.30 -t 8.80 output.mp4

视频倒放：

-i input.mp4 -b:v 2048k -vf reverse output.mp4

视频翻转：

-i input.mp4 -b:v 2048k -vf hflip output.mp4

视频插入图片：

-i input.mp4 -b:v 2048k -strict -2 -vf "movie=myimage.png,scale=550:231,lut=a=val*1.0[mask0];[in][mask0] overlay=140:106:enable='between (t,0.0,8.8)'[out]" output.mp4

命令对比参考：

-i input.mp4 -b:v 2048k -strict -2 -vf “movie=图片名.png,scale=图片宽度:图片高度,lut=a=val*透明度[mask0];[in][mask0] overlay=图片X坐标:图片Y坐标:enable=‘between (t,图片显示的开始时间,图片显示的持续时长)’[out]” output.mp4

视频倍速：

-i input.mp4 -b:v 2048k -filter_complex "[0:v]setpts=0.5*PTS[v];[0:a]atempo=2[a]" -map "[v]" -map "[a]" output.mp4

主要参数说明：

设 rate 表示倍速， rate = 2.0; 则

setpts = 1.0/rate;

atempo = rate/1.0;

视频制作调色板(用于提高GIF清晰度)：

-i input.mp4 -b 2048k -r 10 -vf fps=15,scale=414:-1:flags=lanczos,palettegen -y 调色板.png

视频转GIF：

-i input.mp4 -i 调色板.png -r 10 -lavfi "fps=15,scale=414:-1:flags=lanczos[x];[x][1:v]paletteuse" -y output.gif

多张图片+音频转视频：

-threads 2 -y -r 60 -i input.mp3 -f image2 -framerate 5 -i imageGroupPath/image_%%d.png -t 8 -b:v 2048k output.mp4

主要参数说明：

-framerate 5 设置帧率为5；

imageGroupPath/image_%%d.png 自动读取imageGroupPath文件夹中，以image_1.png、image_2.png、image_3.png以此类推的所有图片；

视频+音频合成新视频：

-i input.mp3 -i input.mp4 -t 15 -b:v 2048k -y output.mp4

命令详解

-b:v 2048k

视频比特率2048 kbit/s，这是影响清晰度的参数之一

crop=828:462:0:665

局部裁剪，格式为crop=width:height:X:Y

-ss 5 -t 8.8

需要编辑的开始时间为第5秒，时长8.8秒

hflip

hflip表示水平翻转，vflip表示垂直翻转，reverse表示倒放

scale=414:-1

缩放，格式为scale=宽:高，-1默认为自动

-r 24

将输出文件的帧速率强制为 24 fps

用ffmpeg+nginx+海康威视网络摄像头rtsp在手机端和电脑端实现直播

首先海康威视摄像头，

它的rtsp数据流的地址为：rtsp://[username]:[password]@[ip]:[port]/[codec]/[channel]/[subtype]/av_stream

说明：

username: 用户名。例如admin。

password: 密码。例如12345。

ip: 为设备IP。例如 192.0.0.64。

port: 端口号默认为554，若为默认可不填写。

codec：有h264、MPEG-4、mpeg4这几种。

channel: 通道号，起始为1。例如通道1，则为ch1。

subtype: 码流类型，主码流为main，辅码流为sub。

主码流：rtsp://admin:123456@172.33.23.98:554/h264/ch1/main/av_stream

子码流：rtsp://admin:123456@172.33.23.98:554/h264/ch1/sub/av_stream

然后是nginx服务器，本人是在Linux主机上安装了nginx服务器，对于nginx服务器就不多介绍了。下面是详细的安装步骤，因为考虑的访问量会比较大，所以是用源码包安装的。

下载，地址是，http://nginx.org/en/download.html，下载的是稳定版本的。

下载之后的文件时：nginx-1.10.1.tar.gz，在Linux下通过，tar -cvf nginx-1.10.1.tar.gz 命令可以进行解归档，

为了增加对rtmp的支持，下载nginx-rtmp-module，地址：https://github.com/arut/nginx-rtmp-module#example-nginxconf。

将该文件解压之后放到/home/user，该目录是自己随意选择的，为了方便。

就可以进入nginx1.10.1的解归档之后文件夹，执行

./configure --prefix=/usr/local/nginx --add-module=/home/user/nginx-rtmp-module --with-http_ssl_module

完成之后执行：

make

make之后执行

make install

接着就是等待一般半个小时左右，安装完成之后进行配置文件的修改，

vi /etc/local/nginx/conf/nginx.conf

#user nobody;

worker_processes 1;

#error_log logs/error.log;

#error_log logs/error.log notice;

#error_log logs/error.log info;

#pid logs/nginx.pid;

events {

worker_connections 1024;

}

rtmp {

server {

listen 1935;

application myapp {

live on;

}

application hls {

live on;

hls on;

hls_path /tmp/hls;

}

http {

include mime.types;

default_type application/octet-stream;

#log_format main '$remote_addr - $remote_user [$time_local] "$request" '

# '$status $body_bytes_sent "$http_referer" '

# '"$http_user_agent" "$http_x_forwarded_for"';

#access_log logs/access.log main;

sendfile on;

#tcp_nopush on;

#keepalive_timeout 0;

keepalive_timeout 65;

#gzip on;

server {

listen 80;

server_name localhost;

#charset koi8-r;

#access_log logs/host.access.log main;

location / {

root html;

index index.html index.htm;

}

#error_page 404 /404.html;

# redirect server error pages to the static page /50x.html

error_page 500 502 503 504 /50x.html;

location = /50x.html {

root html;

}

# proxy the PHP scripts to Apache listening on 127.0.0.1:80

#location ~ \.php$ {

# proxy_pass http://127.0.0.1;

# pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000

#location ~ \.php$ {

# root html;

# fastcgi_pass 127.0.0.1:9000;

# fastcgi_index index.php;

# fastcgi_param SCRIPT_FILENAME /scripts$fastcgi_script_name;

# include fastcgi_params;

# deny access to .htaccess files, if Apache's document root

# concurs with nginx's one

#location ~ /\.ht {

# deny all;

}

# another virtual host using mix of IP-, name-, and port-based configuration

#server {

# listen 8000;

# listen somename:8080;

# server_name somename alias another.alias;

# location / {

# root html;

# index index.html index.htm;

# }

# HTTPS server

#server {

# listen 443 ssl;

# server_name localhost;

# ssl_certificate cert.pem;

# ssl_certificate_key cert.key;

# ssl_session_cache shared:SSL:1m;

# ssl_session_timeout 5m;

# ssl_ciphers HIGH:!aNULL:!MD5;

# ssl_prefer_server_ciphers on;

# location / {

# root html;

# index index.html index.htm;

# }

}

保存完配置文件之后，启动nginx服务

cd /usr/local/nginx/sbin

./nginx

启动时可能会遇到端口占用的问题，因为之前nginx已经启动了，所以先把进程停止

killall -9 nginx

然后在启动nginx就不会出错了。

至此，服务器端的nginx服务器就已经搭建好了。

接着就是ffmpeg，用于rtsp协议转换成rtmp协议，并且推流到nginx服务器

首先，下载ffmpeg安装包，http://www.ffmpeg.org/download.html，点击中间那个按钮直接下载。

解压，执行安装命令，./configure make make install 具体如下：

由于名字过于复杂mv ffmpeg-0.4.9-p20051120.tar.bz2 ffmpeg 改个名

配置安装路径：./configure --enable-shared --prefix=/usr/local/ffmpeg

然后 make

最后make install完成ffmpeg源码包的安装。

为了方便起见，我们可以将ffmpeg的安装地址加入到环境变量中，修改/etc/ld.so.conf文件，在末尾加入

/usr/local/ffmpeg/lib，然后就可以在任意目录下执行ffmpeg命令。

额外配置

1.为了能够成功将视频流推送到hls上，还需要对nginx.conf配置文件进行修改，在http中添加下面内容：

location /hls {

types {

application/vnd.apple.mpegurl m3u8;

video/mp2t ts;

}

root /tmp;

add_header Cache-Control no-cache;

}

2.由于延迟比较大，根据前辈们的经验，在nginx配置文件中，进行修改

application hls {

live on;

hls on;

hls_path /data/misc/hls;

hls_fragment 1s;

hls_playlist_length 3s;

} <pre name="code" class="html">

到这里准备工作就已经做好了，下面进入正题：

在Linux服务器上执行ffmpeg命令，实现转码以及推流

ffmpeg -i rtsp://admin:12345@172.33.23.98 -vcodec copy -acodec aac -ar 44100 -strict -2 -ac 1 -f flv -s 1280x720 -q 10 -f flv rtmp://172.16.97.29:1935/hls/test

手机端，在任意的浏览器，不是自带的，输入172.16.97.29:1935/hls/test.m3u8，此时我们就可以看到摄像头的监控画面。

FFmpeg下载m3u8视频

ffmpeg -i 'http://link.to.your/video.m3u8' test.mp4

ffmpeg.exe -i "https://v-blog.csdnimg.cn/asset/c096ba1166c72ea0bf849edb6c843b32/play_video/5f09992800031887a7699e3388734d2b.m3u8" -c copy -bsf:a aac_adtstoasc output.mp4

在这个命令中：

-i 表示输入文件，后面跟的就是M3U8链接地址。

-c copy 表示直接复制流而不重新编码，能加快处理速度并保持原始视频的质量。

-bsf:a aac_adtstoasc 用于修复音频流，以确保音频正确转换并与MP4容器兼容。

output.mp4 是输出文件的名称，可以将其更改成你喜欢的文件名。

通过FFMPEG 转发流

ffmpeg -i http://aplay.gztv.com/sec/jingji.m3u8 -f flv rtmp://112.74.17.122:1935/live/movie

ffmpeg -i rtsp://localhost/live -c copy -f flv rtmp://server/live/h264Stream

ffmpeg合并两路rtmp流并推送

ffmpeg实现两路流的覆盖

实现两路流的覆盖可以使用ffmpeg的overlay参数，将一路流覆盖到另外一路流之上。

overlay参数简介

overlay=x:y

这里x和y表示距离左上角的坐标偏移

例子

ffmpeg -i “rtmp://ip:port/firststream” -i “rtmp://ip:port/secondstream” -filter_complex overlay=20:16 -f flv “rtmp://ip:port/addstream”

将secondstream这路流覆盖到firststream这路流之上，secondstream的坐标位于左上角偏移20：16的位置，也就是x偏移20像素，y偏移16像素。

ffmpeg实现四路流的合并

这部分参考了ffmpeg官方的wikihttp://trac.ffmpeg.org/wiki/Create%20a%20mosaic%20out%20of%20several%20input%20videos#no1

命令

ffmpeg -i “rtmp://ip:port/onestream” -i “rtmp://ip:port/threestream” -i “rtmp://ip:port/fourstream” -i “rtmp://ip:port/twostream” -filter_complex “nullsrc=size=640x480 [base];[0:v] setpts=PTS-STARTPTS, scale=320x240 [upperleft]; [1:v] setpts=PTS-STARTPTS, scale=320x240 [upperright];[2:v] setpts=PTS-STARTPTS, scale=320x240 [lowerleft];[3:v] setpts=PTS-STARTPTS, scale=320x240 [lowerright];[base][upperleft] overlay=shortest=1 [tmp1];[tmp1][upperright] overlay=shortest=1:x=320 [tmp2]; [tmp2][lowerleft] overlay=shortest=1:y=240 [tmp3]; [tmp3][lowerright] overlay=shortest=1:x=320:y=240” -f flv “rtmp://ip:port/outstream”

整个命令特别复杂，但是仔细分析起来，确实还是比较清晰。

整体的逻辑是

ffmpeg -i 多路流 -filter_complex 合并参数 -f flv 合并后的一路流

核心部分就是合并参数。

参数简介

filter_complex

filter complex可以很好的解决我们视频流合并的问题，complex的简单原理如下：

filter complex参数

nullsrc=size=640x480 [base];[0:v] setpts=PTS-STARTPTS, scale=320x240 [upperleft]; [1:v] setpts=PTS-STARTPTS, scale=320x240 [upperright];[2:v] setpts=PTS-STARTPTS, scale=320x240 [lowerleft];[3:v] setpts=PTS-STARTPTS, scale=320x240 [lowerright];[base][upperleft] overlay=shortest=1 [tmp1];[tmp1][upperright] overlay=shortest=1:x=320 [tmp2]; [tmp2][lowerleft] overlay=shortest=1:y=240 [tmp3]; [tmp3][lowerright] overlay=shortest=1:x=320:y=240

整个参数可以分为两个部分，第一部分：

nullsrc=size=640x480 [base];[0:v] setpts=PTS-STARTPTS, scale=320x240 [upperleft]; [1:v] setpts=PTS-STARTPTS, scale=320x240 [upperright];[2:v] setpts=PTS-STARTPTS, scale=320x240 [lowerleft];[3:v] setpts=PTS-STARTPTS, scale=320x240 [lowerright];

这个部分主要是划分了基础层和上面的四个分区，对每个分区输入的流和分辨率、pts作何设置。

首先定义了基础的layer：nullsrc=size=640x480 [base]，输入是null。大小是640x480，名字是base。然后定义了之上的四个部分：

[0:v] setpts=PTS-STARTPTS, scale=320x240 [upperleft]

[0:v]告诉ffmpeg从第一个输入来获取流，设置pts，设置大小320x240，名字upperleft。

第二部分：

[base][upperleft] overlay=shortest=1 [tmp1];[tmp1][upperright] overlay=shortest=1:x=320 [tmp2]; [tmp2][lowerleft] overlay=shortest=1:y=240 [tmp3]; [tmp3][lowerright] overlay=shortest=1:x=320:y=240

主要是设置这四个部分在整个显示层上的分布。

[base][upperleft] overlay=shortest=1 [tmp1]

[upperleft]是第一部分定义好的输入流，overlay在[base]之上。shortest=1就是当输入停止的时候延迟1秒结束。坐标是默认[0,0]。tmp1是给这个部分取的名字，方便后续使用。

[tmp1][upperright] overlay=shortest=1:x=320 [tmp2];

[upperright]overlay在[tmp1]之上，坐标是[320，0]。这部分的名字是[tmp2]。

ffmpeg抖音去水印

利用ffmpeg命令行，实现需要的功能，具体可参看ffmpeg的帮助或手册

ffmpeg -i 123.mp4 -filter_complex "delogo=x=18:y=20:w=270:h=100:show=1:enable='between(t,0,5)'" 456.mp4

ffmpeg -i 123.mp4 -filter_complex "delogo=x=435:y=1160:w=270:h=100:show=1:enable='between(t,5,15)'" 456.mp4

ffmpeg 保存在线流

找来一个直播流URL，比如东森新闻 http://60.199.188.151/HLS/WG_ETTV-N/index.m3u8，试了一下，还不赖呢！

有时候，看到精彩的直播内容，想把某些片段保存到本地。无奈播放器不提供这样的功能。那么，开个小窗给FFmpeg吧，它可以搞定！

命令行如下：

ffmpeg -i http://60.199.188.151/HLS/WG_ETTV-N/index.m3u8 d:\cap.mp4

这条命令会持续不断地抓取网络视频流，然后写入d:\cap.mp4文件，直到你按下键盘上的“Q”键才停止。如果你就想录制一小段时间（比如60秒），可以在-i参数前加-t参数来控制，如下：

ffmpeg -t 60 -i http://60.199.188.151/HLS/WG_ETTV-N/index.m3u8 d:\cap.mp4

上面例子中的直播流是HTTP协议的。FFmpeg还支持其他什么协议吗？这也简单！在控制台输入ffmpeg -protocols便一目了然了。

不禁又一次暗暗佩服：FFmpeg Holy-High！

Ps. 有位同学提醒道，应该加上-c:v copy -c:a copy（另一种表达方式是-vcodec copy -acodec copy）来避免转码。吾深以为然！这对于实时采集的场景尤为重要！经测试，效果喜人，FFmpeg的CPU占用从之前的80%降到了1%！！

完整命令行如下：

ffmpeg -i http://60.199.188.151/HLS/WG_ETTV-N/index.m3u8 -c:v copy -c:a copy -bsf:a aac_adtstoasc d:\cap.mp4

ffmpeg转播视频

这很简单就完成的手动的直播推流，ffplay 拉流看效果了，

这种的话我直接就完成了推流到live552 服务器，再用ffmpeg 进行拉流转推倒 live553服务器上了

哦，对了， ffmpeg 拉流转发的命令是：

ffmpeg -i 拉流地址 -vcodec copy -acodec copy -f fmt flv -y 推流地址

-vcodec codec 强制使用codec编解码方式。如果用copy表示原始编解码数据必须被拷贝。

应该是代表拉流处理流数据中的视频的编码格式吧，可能类似于代码中的 utf-8, gbk这些编码格式吧

-acodec codec 使用codec编解码

应该是代表拉流处理流数据中的音频编码格式吧， copy代表复制，不更改编码格式

-f fmt 强迫采用格式fmt这个猜不到

-y应该是将流数据输出到位置

后来给我发了一个带推流码的直播地址

啊这，拉流地址呢？老大说让我把这个推流地址和推流码整合起来让 ffmpeg 可以进行推流，当时我也不太懂，还以为是从这个推流地址和一些参数也可以进行拉流的，这个带推流码的直播地址推流很简单，就是将推流码拼接到推流地址后面就可以了，当时我先是用obs 推流到552 服务器上，再ffmpeg 从552中进行拉流推倒这个有推流码的服务器上，但是到这个有推流码的地址去拉流看效果的时候就卡住了，

当时我还以为是直接从这个推流地址上进行拉流的，淦，弄了好久，不管这个推流地址和推流码怎么配合拼接都无法进行拉流，也不是无法拉流，有时候 fflpay 这个直播地址和推流码也是可以拉到的，按道理来说应该不行的，不知道怎么回事，但它确实可以拉到数据

FFMPEG 去除水印

通过ffmpeg 命令行实现需要的功能，具体实现可以参考帮助文件或相应手册

ffmpeg -i 4.mp4 -filter_complex "delogo=x=475:y=1060:w=230:h=200:show=1:enable='between(t,10,20)'" delogo.mp4

其中show=1 为显示录框便于定位 show=0 不显示

enable='between(t,10,20)' 表示时间断有效(表示从10秒到20秒有效)

FFmpeg编解码处理4-音频编码

6. 音频编码

编码使用 avcodec_send_frame() 和 avcodec_receive_packet() 两个函数。

音频编码的步骤：

[1] 初始化打开输出文件时构建编码器上下文

[2] 音频帧编码

[2.1] 将滤镜输出的音频帧写入音频 FIFO

[2.2] 按音频编码器中要求的音频帧尺寸从音频 FIFO 中取出音频帧

[2.3] 为音频帧生成 pts

[2.4] 将音频帧送入编码器，从编码器取出编码帧

[2.5] 更新编码帧流索引

[2.6] 将帧中时间参数按输出封装格式的时间基进行转换

6.1 打开视频编码器

完整源码在 open_output_file() 函数中，下面摘出关键部分：

// 3. 构建AVCodecContext

if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||

dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) // 音频流或视频流

{

// 3.1 查找编码器AVCodec，本例使用与解码器相同的编码器

AVCodec *encoder = NULL;

if ((dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) && (strcmp(v_enc_name, "copy") != 0))

{

encoder = avcodec_find_encoder_by_name(v_enc_name);

}

else if ((dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) && (strcmp(a_enc_name, "copy") != 0))

{

encoder = avcodec_find_encoder_by_name(a_enc_name);

}

else

{

encoder = avcodec_find_encoder(dec_ctx->codec_id);

}

if (!encoder)

{

av_log(NULL, AV_LOG_FATAL, "Necessary encoder not found\n");

return AVERROR_INVALIDDATA;

}

// 3.2 AVCodecContext初始化：分配结构体，使用AVCodec初始化AVCodecContext相应成员为默认值

AVCodecContext *enc_ctx = avcodec_alloc_context3(encoder);

if (!enc_ctx)

{

av_log(NULL, AV_LOG_FATAL, "Failed to allocate the encoder context\n");

return AVERROR(ENOMEM);

}

// 3.3 AVCodecContext初始化：配置图像/声音相关属性

/* In this example, we transcode to same properties (picture size,

* sample rate etc.). These properties can be changed for output

* streams easily using filters */

if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO)

{

enc_ctx->height = dec_ctx->height; // 图像高

enc_ctx->width = dec_ctx->width; // 图像宽

enc_ctx->sample_aspect_ratio = dec_ctx->sample_aspect_ratio; // 采样宽高比：像素宽/像素高

/* take first format from list of supported formats */

if (encoder->pix_fmts) // 编码器支持的像素格式列表

{

enc_ctx->pix_fmt = encoder->pix_fmts[0]; // 编码器采用所支持的第一种像素格式

}

else

{

enc_ctx->pix_fmt = dec_ctx->pix_fmt; // 编码器采用解码器的像素格式

}

/* video time_base can be set to whatever is handy and supported by encoder */

enc_ctx->time_base = av_inv_q(dec_ctx->framerate); // 时基：解码器帧率取倒数

enc_ctx->framerate = dec_ctx->framerate;

//enc_ctx->bit_rate = dec_ctx->bit_rate;

/* emit one intra frame every ten frames

* check frame pict_type before passing frame

* to encoder, if frame->pict_type is AV_PICTURE_TYPE_I

* then gop_size is ignored and the output of encoder

* will always be I frame irrespective to gop_size

//enc_ctx->gop_size = 10;

//enc_ctx->max_b_frames = 1;

}

else

{

enc_ctx->sample_rate = dec_ctx->sample_rate; // 采样率

enc_ctx->channel_layout = dec_ctx->channel_layout; // 声道布局

enc_ctx->channels = av_get_channel_layout_nb_channels(enc_ctx->channel_layout); // 声道数量

/* take first format from list of supported formats */

enc_ctx->sample_fmt = encoder->sample_fmts[0]; // 编码器采用所支持的第一种采样格式

enc_ctx->time_base = (AVRational){1, enc_ctx->sample_rate}; // 时基：编码器采样率取倒数

// enc_ctx->codec->capabilities |= AV_CODEC_CAP_VARIABLE_FRAME_SIZE; // 只读标志

// 初始化一个FIFO用于存储待编码的音频帧，初始化FIFO大小的1个采样点

// av_audio_fifo_alloc()第二个参数是声道数，第三个参数是单个声道的采样点数

// 采样格式及声道数在初始化FIFO时已设置，各处涉及FIFO大小的地方都是用的单个声道的采样点数

pp_audio_fifo[i] = av_audio_fifo_alloc(enc_ctx->sample_fmt, enc_ctx->channels, 1);

if (pp_audio_fifo == NULL)

{

av_log(NULL, AV_LOG_ERROR, "Could not allocate FIFO\n");

return AVERROR(ENOMEM);

}

if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)

{

enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

}

// 3.4 AVCodecContext初始化：使用AVCodec初始化AVCodecContext，初始化完成

/* Third parameter can be used to pass settings to encoder */

ret = avcodec_open2(enc_ctx, encoder, NULL);

if (ret < 0)

{

av_log(NULL, AV_LOG_ERROR, "Cannot open video encoder for stream #%u\n", i);

return ret;

}

// 3.5 设置输出流codecpar

ret = avcodec_parameters_from_context(out_stream->codecpar, enc_ctx);

if (ret < 0)

{

av_log(NULL, AV_LOG_ERROR, "Failed to copy encoder parameters to output stream #%u\n", i);

return ret;

}

// 3.6 保存输出流contex

pp_enc_ctx[i] = enc_ctx;

}

6.2 判断是否需要音频 FIFO

完整源码在 main() 函数中，下面摘出关键部分：

if (codec_type == AVMEDIA_TYPE_AUDIO) {

if (((stream.o_codec_ctx->codec->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE) == 0) &&

(stream.i_codec_ctx->frame_size != stream.o_codec_ctx->frame_size))

{

stream.aud_fifo = oafifo[stream_index];

ret = transcode_audio_with_afifo(&stream, &ipacket);

}

else

{

ret = transcode_audio(&stream, &ipacket);

}

解码过程中的音频帧尺寸：

AVCodecContext.frame_size 表示音频帧中每个声道包含的采样点数。当编码器 AV_CODEC_CAP_VARIABLE_FRAME_SIZE 标志有效时，音频帧尺寸是可变的，AVCodecContext.frame_size 值可能为 0；否则，解码器的 AVCodecContext.frame_size 等于解码帧中的 AVFrame.nb_samples。

编码过程中的音频帧尺寸：

上述代码中第一个判断条件是 "(stream.o_codec_ctx->codec->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE) == 0)", 第二个判断条件是 "(stream.i_codec_ctx->frame_size != stream.o_codec_ctx->frame_size)"。如果编码器不支持可变尺寸音频帧(第一个判断条件生效)，而原始音频帧的尺寸又和编码器帧尺寸不一样(第二个判断条件生效)，则需要引入音频帧 FIFO，以保证每次从 FIFO 中取出的音频帧尺寸和编码器帧尺寸一样。音频 FIFO 输出的音频帧不含时间戳信息，因此需要重新生成时间戳。

引入音频FIFO的原因：

如果编码器不支持可变长度帧，而编码器输入音频帧尺寸和编码器要求的音频帧尺寸不一样，就会编码失败。比如，AAC 音频格式转 MP2 音频格式，AAC 格式音频帧尺寸为 1024，而 MP2 音频编码器要求音频帧尺寸为 1152，编码会失败；再比如 AAC 格式转码 AAC 格式，某些 AAC 音频帧为 2048，而此时若 AAC 音频编码器要求音频帧尺寸为 1024，编码就会失败。解决这个问题的方法有两个，一是进行音频重采样，使音频帧转换为编码器支持的格式；另一个是引入音频 FIFO，一端写一端读，每次从读端取出编码器要求的帧尺寸即可。

AAC 音频帧尺寸可能是 1024，也可能是 2048，参考“FFmpeg关于nb_smples,frame_size以及profile的解释”

6.3 音频 FIFO 接口函数

本节代码参考 "https://github.com/FFmpeg/FFmpeg/blob/n4.1/doc/examples/transcode_aac.c" 实现

/**

* Initialize one input frame for writing to the output file.

* The frame will be exactly frame_size samples large.

* @param[out] frame Frame to be initialized

* @param output_codec_context Codec context of the output file

* @param frame_size Size of the frame

* @return Error code (0 if successful)

static int init_audio_output_frame(AVFrame **frame,

AVCodecContext *occtx,

int frame_size)

{

int error;

/* Create a new frame to store the audio samples. */

if (!(*frame = av_frame_alloc()))

{

fprintf(stderr, "Could not allocate output frame\n");

return AVERROR_EXIT;

}

/* Set the frame's parameters, especially its size and format.

* av_frame_get_buffer needs this to allocate memory for the

* audio samples of the frame.

* Default channel layouts based on the number of channels

* are assumed for simplicity. */

(*frame)->nb_samples = frame_size;

(*frame)->channel_layout = occtx->channel_layout;

(*frame)->format = occtx->sample_fmt;

(*frame)->sample_rate = occtx->sample_rate;

/* Allocate the samples of the created frame. This call will make

* sure that the audio frame can hold as many samples as specified. */

// 为AVFrame分配缓冲区，此函数会填充AVFrame.data和AVFrame.buf，若有需要，也会填充

// AVFrame.extended_data和AVFrame.extended_buf，对于planar格式音频，会为每个plane

// 分配一个缓冲区

if ((error = av_frame_get_buffer(*frame, 0)) < 0)

{

fprintf(stderr, "Could not allocate output frame samples (error '%s')\n",

av_err2str(error));

av_frame_free(frame);

return error;

}

return 0;

}

// FIFO中可读数据小于编码器帧尺寸，则继续往FIFO中写数据

static int write_frame_to_audio_fifo(AVAudioFifo *fifo,

uint8_t **new_data,

int new_size)

{

int ret = av_audio_fifo_realloc(fifo, av_audio_fifo_size(fifo) + new_size);

if (ret < 0)

{

fprintf(stderr, "Could not reallocate FIFO\n");

return ret;

}

/* Store the new samples in the FIFO buffer. */

ret = av_audio_fifo_write(fifo, (void **)new_data, new_size);

if (ret < new_size)

{

fprintf(stderr, "Could not write data to FIFO\n");

return AVERROR_EXIT;

}

return 0;

}

static int read_frame_from_audio_fifo(AVAudioFifo *fifo,

AVCodecContext *occtx,

AVFrame **frame)

{

AVFrame *output_frame;

// 如果FIFO中可读数据多于编码器帧大小，则只读取编码器帧大小的数据出来

// 否则将FIFO中数据读完。frame_size是帧中单个声道的采样点数

const int frame_size = FFMIN(av_audio_fifo_size(fifo), occtx->frame_size);

/* Initialize temporary storage for one output frame. */

// 分配AVFrame及AVFrame数据缓冲区

int ret = init_audio_output_frame(&output_frame, occtx, frame_size);

if (ret < 0)

{

return AVERROR_EXIT;

}

// 从FIFO从读取数据填充到output_frame->data中

ret = av_audio_fifo_read(fifo, (void **)output_frame->data, frame_size);

if (ret < frame_size)

{

fprintf(stderr, "Could not read data from FIFO\n");

av_frame_free(&output_frame);

return AVERROR_EXIT;

}

*frame = output_frame;

return ret;

}

6.4 编码音频帧

完整源码在 transcode_audio_with_afifo() 函数中，下面摘出关键部分：

// 2. 滤镜处理

ret = filtering_frame(sctx->flt_ctx, frame_dec, frame_flt);

if (ret == AVERROR_EOF) // 滤镜已冲洗

{

flt_finished = true;

av_log(NULL, AV_LOG_INFO, "filtering aframe EOF\n");

frame_flt = NULL;

}

else if (ret < 0)

{

av_log(NULL, AV_LOG_INFO, "filtering aframe error %d\n", ret);

goto end;

}

// 3. 使用音频fifo，从而保证每次送入编码器的音频帧尺寸满足编码器要求

// 3.1 将音频帧写入fifo，音频帧尺寸是解码格式中音频帧尺寸

if (!dec_finished)

{

uint8_t** new_data = frame_flt->extended_data; // 本帧中多个声道音频数据

int new_size = frame_flt->nb_samples; // 本帧中单个声道的采样点数

// FIFO中可读数据小于编码器帧尺寸，则继续往FIFO中写数据

ret = write_frame_to_audio_fifo(p_fifo, new_data, new_size);

if (ret < 0)

{

av_log(NULL, AV_LOG_INFO, "write aframe to fifo error\n");

goto end;

}

// 3.2 从fifo中取出音频帧，音频帧尺寸是编码格式中音频帧尺寸

// FIFO中可读数据大于编码器帧尺寸，则从FIFO中读走数据进行处理

while ((av_audio_fifo_size(p_fifo) >= enc_frame_size) || dec_finished)

{

bool flushing = dec_finished && (av_audio_fifo_size(p_fifo) == 0); // 已取空，刷洗编码器

if (frame_enc != NULL)

{

av_frame_free(&frame_enc);

}

if (!flushing)

{

// 从FIFO中读取数据，编码，写入输出文件

ret = read_frame_from_audio_fifo(p_fifo, sctx->o_codec_ctx, &frame_enc);

if (ret < 0)

{

av_log(NULL, AV_LOG_INFO, "read aframe from fifo error\n");

goto end;

}

// 4. fifo中读取的音频帧没有时间戳信息，重新生成pts

frame_enc->pts = s_pts;

s_pts += ret;

}

flush_encoder:

// 5. 编码

ret = av_encode_frame(sctx->o_codec_ctx, frame_enc, &opacket);

if (ret == AVERROR(EAGAIN)) // 需要获取新的frame喂给编码器

{

//av_log(NULL, AV_LOG_INFO, "encode aframe need more packet\n");

if (frame_enc != NULL)

{

av_frame_free(&frame_enc);

}

continue;

}

else if (ret == AVERROR_EOF)

{

av_log(NULL, AV_LOG_INFO, "encode aframe EOF\n");

enc_finished = true;

goto end;

}

// 5.1 更新编码帧中流序号，并进行时间基转换

// AVPacket.pts和AVPacket.dts的单位是AVStream.time_base，不同的封装格式其AVStream.time_base不同

// 所以输出文件中，每个packet需要根据输出封装格式重新计算pts和dts

opacket.stream_index = sctx->stream_idx;

av_packet_rescale_ts(&opacket, sctx->o_codec_ctx->time_base, sctx->o_stream->time_base);

av_log(NULL, AV_LOG_DEBUG, "Muxing frame\n");

// 6. 将编码后的packet写入输出媒体文件

ret = av_interleaved_write_frame(sctx->o_fmt_ctx, &opacket);

if (ret < 0)

{

av_log(NULL, AV_LOG_INFO, "write aframe error %d\n", ret);

goto end;

}

if (flushing)

{

goto flush_encoder;

}

FFmpeg编解码处理3-视频编码

基于 FFmpeg 4.1 版本。

5. 视频编码

编码使用 avcodec_send_frame() 和 avcodec_receive_packet() 两个函数。

视频编码的步骤：

[1] 初始化打开输出文件时构建编码器上下文

[2] 视频帧编码

[2.1] 设置帧类型 "frame->pict_type=AV_PICTURE_TYPE_NONE"，让编码器根据设定参数自行生成 I/B/P 帧类型

[2.2] 将原始帧送入编码器，从编码器取出编码帧

[2.3] 更新编码帧流索引

[2.4] 将帧中时间参数按输出封装格式的时间基进行转换

5.1 打开视频编码器

完整源码在 open_output_file() 函数中，下面摘出关键部分：

// 3. 构建AVCodecContext

if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||

dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) // 音频流或视频流

{

// 3.1 查找编码器AVCodec，本例使用与解码器相同的编码器

AVCodec *encoder = NULL;

if ((dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) && (strcmp(v_enc_name, "copy") != 0))

{

encoder = avcodec_find_encoder_by_name(v_enc_name);

}

else if ((dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) && (strcmp(a_enc_name, "copy") != 0))

{

encoder = avcodec_find_encoder_by_name(a_enc_name);

}

else

{

encoder = avcodec_find_encoder(dec_ctx->codec_id);

}

if (!encoder)

{

av_log(NULL, AV_LOG_FATAL, "Necessary encoder not found\n");

return AVERROR_INVALIDDATA;

}

// 3.2 AVCodecContext初始化：分配结构体，使用AVCodec初始化AVCodecContext相应成员为默认值

AVCodecContext *enc_ctx = avcodec_alloc_context3(encoder);

if (!enc_ctx)

{

av_log(NULL, AV_LOG_FATAL, "Failed to allocate the encoder context\n");

return AVERROR(ENOMEM);

}

// 3.3 AVCodecContext初始化：配置图像/声音相关属性

/* In this example, we transcode to same properties (picture size,

* sample rate etc.). These properties can be changed for output

* streams easily using filters */

if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO)

{

enc_ctx->height = dec_ctx->height; // 图像高

enc_ctx->width = dec_ctx->width; // 图像宽

enc_ctx->sample_aspect_ratio = dec_ctx->sample_aspect_ratio; // 采样宽高比：像素宽/像素高

/* take first format from list of supported formats */

if (encoder->pix_fmts) // 编码器支持的像素格式列表

{

enc_ctx->pix_fmt = encoder->pix_fmts[0]; // 编码器采用所支持的第一种像素格式

}

else

{

enc_ctx->pix_fmt = dec_ctx->pix_fmt; // 编码器采用解码器的像素格式

}

/* video time_base can be set to whatever is handy and supported by encoder */

enc_ctx->time_base = av_inv_q(dec_ctx->framerate); // 时基：解码器帧率取倒数

enc_ctx->framerate = dec_ctx->framerate;

//enc_ctx->bit_rate = dec_ctx->bit_rate;

/* emit one intra frame every ten frames

* check frame pict_type before passing frame

* to encoder, if frame->pict_type is AV_PICTURE_TYPE_I

* then gop_size is ignored and the output of encoder

* will always be I frame irrespective to gop_size

//enc_ctx->gop_size = 10;

//enc_ctx->max_b_frames = 1;

}

else

{

enc_ctx->sample_rate = dec_ctx->sample_rate; // 采样率

enc_ctx->channel_layout = dec_ctx->channel_layout; // 声道布局

enc_ctx->channels = av_get_channel_layout_nb_channels(enc_ctx->channel_layout); // 声道数量

/* take first format from list of supported formats */

enc_ctx->sample_fmt = encoder->sample_fmts[0]; // 编码器采用所支持的第一种采样格式

enc_ctx->time_base = (AVRational){1, enc_ctx->sample_rate}; // 时基：编码器采样率取倒数

// enc_ctx->codec->capabilities |= AV_CODEC_CAP_VARIABLE_FRAME_SIZE; // 只读标志

// 初始化一个FIFO用于存储待编码的音频帧，初始化FIFO大小的1个采样点

// av_audio_fifo_alloc()第二个参数是声道数，第三个参数是单个声道的采样点数

// 采样格式及声道数在初始化FIFO时已设置，各处涉及FIFO大小的地方都是用的单个声道的采样点数

pp_audio_fifo[i] = av_audio_fifo_alloc(enc_ctx->sample_fmt, enc_ctx->channels, 1);

if (pp_audio_fifo == NULL)

{

av_log(NULL, AV_LOG_ERROR, "Could not allocate FIFO\n");

return AVERROR(ENOMEM);

}

if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)

{

enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

}

// 3.4 AVCodecContext初始化：使用AVCodec初始化AVCodecContext，初始化完成

/* Third parameter can be used to pass settings to encoder */

ret = avcodec_open2(enc_ctx, encoder, NULL);

if (ret < 0)

{

av_log(NULL, AV_LOG_ERROR, "Cannot open video encoder for stream #%u\n", i);

return ret;

}

// 3.5 设置输出流codecpar

ret = avcodec_parameters_from_context(out_stream->codecpar, enc_ctx);

if (ret < 0)

{

av_log(NULL, AV_LOG_ERROR, "Failed to copy encoder parameters to output stream #%u\n", i);

return ret;

}

// 3.6 保存输出流contex

pp_enc_ctx[i] = enc_ctx;

}

5.2 编码视频帧

完整源码在 transcode_video() 函数中，下面摘出关键部分：

// 2. 滤镜处理

ret = filtering_frame(sctx->flt_ctx, frame_dec, frame_flt);

if (ret == AVERROR_EOF)

{

av_log(NULL, AV_LOG_INFO, "filtering vframe EOF\n");

flt_finished = true;

av_frame_free(&frame_flt); // flush encoder

}

else if (ret < 0)

{

av_log(NULL, AV_LOG_INFO, "filtering vframe error %d\n", ret);

goto end;

}

flush_encoder:

// 3. 编码

if (frame_flt != NULL)

{

// 3.1 设置帧类型。如果不设置，则使用输入流中的帧类型。

frame_flt->pict_type = AV_PICTURE_TYPE_NONE;

}

// 3.2 编码

ret = av_encode_frame(sctx->o_codec_ctx, frame_flt, &opacket);

if (ret == AVERROR(EAGAIN)) // 需要读取新的packet喂给编码器

{

//av_log(NULL, AV_LOG_INFO, "encode vframe need more packet\n");

goto end;

}

else if (ret == AVERROR_EOF)

{

av_log(NULL, AV_LOG_INFO, "encode vframe EOF\n");

enc_finished = true;

goto end;

}

else if (ret < 0)

{

av_log(NULL, AV_LOG_ERROR, "encode vframe error %d\n", ret);

goto end;

}

// 3.3 更新编码帧中流序号，并进行时间基转换

// AVPacket.pts和AVPacket.dts的单位是AVStream.time_base，不同的封装格式其AVStream.time_base不同

// 所以输出文件中，每个packet需要根据输出封装格式重新计算pts和dts

opacket.stream_index = sctx->stream_idx;

av_packet_rescale_ts(&opacket, sctx->o_codec_ctx->time_base, sctx->o_stream->time_base);

// 4. 将编码后的packet写入输出媒体文件

ret = av_interleaved_write_frame(sctx->o_fmt_ctx, &opacket);

av_packet_unref(&opacket);

5.3 视频编码中的 I/B/P 帧类型

做一个实验，修改 5.1.2 节 frame_flt->pict_type 值和 5.1.1 节 enc_ctx->gop_size 和 enc_ctx->max_b_frames，将编码后视频帧 I/B/P 类型打印出来，观察实验结果。

我们选一个很短的视频文件用于测试(右键另存为)：tnmil3.flv

迷龙

tnmil3.flv 重命名为 tnmil.flv

转码：tnmil.flv ==> tnmilo1.flv

命令：./transcode -i tnmil.flv -c:v copy -c:a copy tnmilo1.flv

tnmil.flv ==> tnmilo1.flv 不修改frame IBP类型，不设置编码器gop_size和max_b_frames

IBPBPBPBPBPBBBPBBBPBBBPBBPBBBPBBBPBBPBBBPBBBPBBBPBPBPBBPBBBPBBBPBPBBBPBBBPBPBBPBBBPPIBBP

tnmil.flv ==> tnmilo3.flv 将frame IBP类型设为NONE，将编码器gop_size设为10，max_b_frames设为1

IBPBPBPBPBPBBBPBBBPBBBPBBPBBBPBBBPBBPBBBPBBBPBBBPBPBPBBPBBBPBBBPBPBBBPBBBPBPBBPBBBPPIBBP

IBPBPBPBPPIBPBPBPBPPIBPBPBPBPPIBPBPBPBPPIBPBPBPBPPIBPBPBPBPPIBPBPBPBPPIBPBPBPBPPIBPPIBPP

tnmilo3.flv ==> tnmilo4.flv 不修改frame IBP类型，不设置编码器gop_size和max_b_frames

IBPBPBPBPPIBPBPBPBPPIBPBPBPBPPIBPBPBPBPPIBPBPBPBPPIBPBPBPBPPIBPBPBPBPPIBPBPBPBPPIBPPIBPP

tnmilo3.flv ==> tnmilo5.flv 将frame IBP类型设为NONE，不设置编码器gop_size(默认-1)和max_b_frames(默认0)

IBPBPBPBPPIBPBPBPBPPIBPBPBPBPPIBPBPBPBPPIBPBPBPBPPIBPBPBPBPPIBPBPBPBPPIBPBPBPBPPIBPPIBPP

IBPBPBPBPBBBPBPBPBBBPBBBPBBBPBBBPBBBPBBBPBBBPBBBPBBBPBBBPBBBPBBBPBBBPBBBPBBBPBPBBBPPIBBP

实验结论如下：将原始视频帧 frame 送入视频编码器后生成编码帧 packet，那么

[1] 手工设置每一帧 frame 的帧类型为 I/B/P，则编码后的 packet 的帧类型和 frame 中的一样。编码器是否设置 gop_size 和 max_b_frames 两个参数无影响。

[2] 将每一帧 frame 的帧类型设置为 NONE，如果未设置编码器的 gop_size(默认值 -1)和 max_b_frames (默认值 0)两个参数，则编码器自动选择合适参数来进行编码，生成帧类型。

[3] 将每一帧 frame 的帧类型设置为 NONE，如果设置了编码器的 gop_size 和 max_b_frames 两个参数，则编码器按照这两个参数来进行编码，生成帧类型。

FFmpeg时间戳详解

1. I 帧/P 帧/B 帧

I 帧：I 帧(Intra-coded picture, 帧内编码帧，常称为关键帧)包含一幅完整的图像信息，属于帧内编码图像，不含运动矢量，在解码时不需要参考其他帧图像。因此在 I 帧图像处可以切换频道，而不会导致图像丢失或无法解码。I 帧图像用于阻止误差的累积和扩散。在闭合式 GOP 中，每个 GOP 的第一个帧一定是 I 帧，且当前 GOP 的数据不会参考前后 GOP 的数据。

P 帧：P 帧(Predictive-coded picture, 预测编码图像帧)是帧间编码帧，利用之前的 I 帧或 P 帧进行预测编码。

B 帧：B 帧(Bi-directionally predicted picture, 双向预测编码图像帧)是帧间编码帧，利用之前和(或)之后的 I 帧或 P 帧进行双向预测编码。B 帧不可以作为参考帧。

B 帧具有更高的压缩率，但需要更多的缓冲时间以及更高的 CPU 占用率，因此 B 帧适合本地存储以及视频点播，而不适用对实时性要求较高的直播系统。

2. DTS 和 PTS

DTS(Decoding Time Stamp, 解码时间戳)，表示压缩帧的解码时间。

PTS(Presentation Time Stamp, 显示时间戳)，表示将压缩帧解码后得到的原始帧的显示时间。

音频中 DTS 和 PTS 是相同的。视频中由于 B 帧需要双向预测，B 帧依赖于其前和其后的帧，因此含 B 帧的视频解码顺序与显示顺序不同，即 DTS 与 PTS 不同。当然，不含 B 帧的视频，其 DTS 和 PTS 是相同的。下图以一个开放式 GOP 示意图为例，说明视频流的解码顺序和显示顺序

采集顺序指图像传感器采集原始信号得到图像帧的顺序。

编码顺序指编码器编码后图像帧的顺序。存储到磁盘的本地视频文件中图像帧的顺序与编码顺序相同。

传输顺序指编码后的流在网络中传输过程中图像帧的顺序。

解码顺序指解码器解码图像帧的顺序。

显示顺序指图像帧在显示器上显示的顺序。

采集顺序与显示顺序相同。编码顺序、传输顺序和解码顺序相同。

以图中“B[1]”帧为例进行说明，“B[1]”帧解码时需要参考“I[0]”帧和“P[3]”帧，因此“P[3]”帧必须比“B[1]”帧先解码。这就导致了解码顺序和显示顺序的不一致，后显示的帧需要先解码。

3. FFmpeg 中的时间基与时间戳

3.1 时间基与时间戳的概念

在 FFmpeg 中，时间基(time_base)是时间戳(timestamp)的单位，时间戳值乘以时间基，可以得到实际的时刻值(以秒等为单位)。例如，如果一个视频帧的 dts 是 40，pts 是 160，其 time_base 是 1/1000 秒，那么可以计算出此视频帧的解码时刻是 40 毫秒(40/1000)，显示时刻是 160 毫秒(160/1000)。FFmpeg 中时间戳(pts/dts)的类型是 int64_t 类型，把一个 time_base 看作一个时钟脉冲，则可把 dts/pts 看作时钟脉冲的计数。

3.2 三种时间基 tbr、tbn 和 tbc

不同的封装格式具有不同的时间基。在 FFmpeg 处理音视频过程中的不同阶段，也会采用不同的时间基。

FFmepg 中有三种时间基，命令行中 tbr、tbn 和 tbc 的打印值就是这三种时间基的倒数：

tbn：对应容器中的时间基。值是 AVStream.time_base 的倒数

tbc：对应编解码器中的时间基。值是 AVCodecContext.time_base 的倒数

tbr：从视频流中猜算得到，可能是帧率或场率(帧率的 2 倍)

测试文件下载(右键另存为)：tnmil3.flv

使用 ffprobe 探测媒体文件格式，如下：

think@opensuse> ffprobe tnmil3.flv

Input #0, flv, from 'tnmil3.flv':

Metadata:

encoder : Lavf58.20.100

Duration: 00:00:03.60, start: 0.017000, bitrate: 513 kb/s

Stream #0:0: Video: h264 (High), yuv420p(progressive), 784x480, 25 fps, 25 tbr, 1k tbn, 50 tbc

Stream #0:1: Audio: aac (LC), 44100 Hz, stereo, fltp, 128 kb/s

关于 tbr、tbn 和 tbc 的说明，原文如下，来自 FFmpeg 邮件列表：

There are three different time bases for time stamps in FFmpeg. The

values printed are actually reciprocals of these, i.e. 1/tbr, 1/tbn and

1/tbc.

tbn is the time base in AVStream that has come from the container, I

think. It is used for all AVStream time stamps.

tbc is the time base in AVCodecContext for the codec used for a

particular stream. It is used for all AVCodecContext and related time

stamps.

tbr is guessed from the video stream and is the value users want to see

when they look for the video frame rate, except sometimes it is twice

what one would expect because of field rate versus frame rate.

3.3 内部时间基 AV_TIME_BASE

除以上三种时间基外，FFmpeg 还有一个内部时间基 AV_TIME_BASE(以及分数形式的 AV_TIME_BASE_Q)

// Internal time base represented as integer

#define AV_TIME_BASE 1000000

// Internal time base represented as fractional value

#define AV_TIME_BASE_Q (AVRational){1, AV_TIME_BASE}

AV_TIME_BASE 及 AV_TIME_BASE_Q 用于 FFmpeg 内部函数处理，使用此时间基计算得到时间值表示的是微秒。

3.4 时间值形式转换

av_q2d()将时间从 AVRational 形式转换为 double 形式。AVRational 是分数类型，double 是双精度浮点数类型，转换的结果单位是秒。转换前后的值基于同一时间基，仅仅是数值的表现形式不同而已。

av_q2d()实现如下：

/**

* Convert an AVRational to a `double`.

* @param a AVRational to convert

* @return `a` in floating-point form

* @see av_d2q()

static inline double av_q2d(AVRational a){

return a.num / (double) a.den;

}

av_q2d()使用方法如下：

AVStream stream;

AVPacket packet;

packet 播放时刻值：timestamp(单位秒) = packet.pts × av_q2d(stream.time_base);

packet 播放时长值：duration(单位秒) = packet.duration × av_q2d(stream.time_base);

3.5 时间基转换函数

av_rescale_q()用于不同时间基的转换，用于将时间值从一种时间基转换为另一种时间基。

/**

* Rescale a 64-bit integer by 2 rational numbers.

* The operation is mathematically equivalent to `a × bq / cq`.

* This function is equivalent to av_rescale_q_rnd() with #AV_ROUND_NEAR_INF.

* @see av_rescale(), av_rescale_rnd(), av_rescale_q_rnd()

int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) av_const;

av_packet_rescale_ts()用于将 AVPacket 中各种时间值从一种时间基转换为另一种时间基。

/**

* Convert valid timing fields (timestamps / durations) in a packet from one

* timebase to another. Timestamps with unknown values (AV_NOPTS_VALUE) will be

* ignored.

* @param pkt packet on which the conversion will be performed

* @param tb_src source timebase, in which the timing fields in pkt are

* expressed

* @param tb_dst destination timebase, to which the timing fields will be

* converted

void av_packet_rescale_ts(AVPacket *pkt, AVRational tb_src, AVRational tb_dst);

3.6 转封装过程中的时间基转换

容器中的时间基(AVStream.time_base，3.2 节中的 tbn)定义如下：

typedef struct AVStream {

......

/**

* This is the fundamental unit of time (in seconds) in terms

* of which frame timestamps are represented.

* decoding: set by libavformat

* encoding: May be set by the caller before avformat_write_header() to

* provide a hint to the muxer about the desired timebase. In

* avformat_write_header(), the muxer will overwrite this field

* with the timebase that will actually be used for the timestamps

* written into the file (which may or may not be related to the

* user-provided one, depending on the format).

AVRational time_base;

......

}

AVStream.time_base 是 AVPacket 中 pts 和 dts 的时间单位，输入流与输出流中 time_base 按如下方式确定：

对于输入流：打开输入文件后，调用 avformat_find_stream_info()可获取到每个流中的 time_base

对于输出流：打开输出文件后，调用 avformat_write_header()可根据输出文件封装格式确定每个流的 time_base 并写入输出文件中

不同封装格式具有不同的时间基，在转封装(将一种封装格式转换为另一种封装格式)过程中，时间基转换相关代码如下：

av_read_frame(ifmt_ctx, &pkt);

pkt.pts = av_rescale_q_rnd(pkt.pts, in_stream->time_base, out_stream->time_base, AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);

pkt.dts = av_rescale_q_rnd(pkt.dts, in_stream->time_base, out_stream->time_base, AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);

pkt.duration = av_rescale_q(pkt.duration, in_stream->time_base, out_stream->time_base);

下面的代码具有和上面代码相同的效果：

// 从输入文件中读取 packet

av_read_frame(ifmt_ctx, &pkt);

// 将 packet 中的各时间值从输入流封装格式时间基转换到输出流封装格式时间基

av_packet_rescale_ts(&pkt, in_stream->time_base, out_stream->time_base);

这里流里的时间基in_stream->time_base和out_stream->time_base，是容器中的时间基，就是 3.2 节中的 tbn。

例如，flv 封装格式的 time_base 为{1,1000}，ts 封装格式的 time_base 为{1,90000}

我们编写程序将 flv 封装格式转换为 ts 封装格式，抓取原文件(flv)的前四帧显示时间戳：

think@opensuse> ffprobe -show_frames -select_streams v tnmil3.flv | grep pkt_pts

Input #0, flv, from 'tnmil3.flv':

Metadata:

encoder : Lavf58.20.100

Duration: 00:00:03.60, start: 0.017000, bitrate: 513 kb/s

Stream #0:0: Video: h264 (High), yuv420p(progressive), 784x480, 25 fps, 25 tbr, 1k tbn, 50 tbc

Stream #0:1: Audio: aac (LC), 44100 Hz, stereo, fltp, 128 kb/s

pkt_pts=80

pkt_pts_time=0.080000

pkt_pts=120

pkt_pts_time=0.120000

pkt_pts=160

pkt_pts_time=0.160000

pkt_pts=200

pkt_pts_time=0.200000

再抓取转换的文件(ts)的前四帧显示时间戳：

think@opensuse> ffprobe -show_frames -select_streams v tnmil3.ts | grep pkt_pts

Input #0, mpegts, from 'tnmil3.ts':

Duration: 00:00:03.58, start: 0.017000, bitrate: 619 kb/s

Program 1

Metadata:

service_name : Service01

service_provider: FFmpeg

Stream #0:0[0x100]: Video: h264 (High) ([27][0][0][0] / 0x001B), yuv420p(progressive), 784x480, 25 fps, 25 tbr, 90k tbn, 50 tbc

Stream #0:1[0x101]: Audio: aac (LC) ([15][0][0][0] / 0x000F), 44100 Hz, stereo, fltp, 127 kb/s

pkt_pts=7200

pkt_pts_time=0.080000

pkt_pts=10800

pkt_pts_time=0.120000

pkt_pts=14400

pkt_pts_time=0.160000

pkt_pts=18000

pkt_pts_time=0.200000

可以发现，对于同一个视频帧，它们时间基(tbn)不同因此时间戳(pkt_pts)也不同，但是计算出来的时刻值(pkt_pts_time)是相同的。

看第一帧的时间戳，计算关系：80×{1,1000} == 7200×{1,90000} == 0.080000

3.7 转码过程中的时间基转换

编解码器中的时间基(AVCodecContext.time_base，3.2 节中的 tbc)定义如下：

typedef struct AVCodecContext {

......

/**

* This is the fundamental unit of time (in seconds) in terms

* of which frame timestamps are represented. For fixed-fps content,

* timebase should be 1/framerate and timestamp increments should be

* identically 1.

* This often, but not always is the inverse of the frame rate or field rate

* for video. 1/time_base is not the average frame rate if the frame rate is not

* constant.

* Like containers, elementary streams also can store timestamps, 1/time_base

* is the unit in which these timestamps are specified.

* As example of such codec time base see ISO/IEC 14496-2:2001(E)

* vop_time_increment_resolution and fixed_vop_rate

* (fixed_vop_rate == 0 implies that it is different from the framerate)

* - encoding: MUST be set by user.

* - decoding: the use of this field for decoding is deprecated.

* Use framerate instead.

AVRational time_base;

......

}

上述注释指出，AVCodecContext.time_base 是帧率(视频帧)的倒数，每帧时间戳递增 1，那么 tbc 就等于帧率。编码过程中，应由用户设置好此参数。解码过程中，此参数已过时，建议直接使用帧率倒数用作时间基。

这里有一个问题：按照此处注释说明，帧率为 25 的视频流，tbc 理应为 25，但实际值却为 50，不知作何解释？是否 tbc 已经过时，不具参考意义？

根据注释中的建议，实际使用时，在视频解码过程中，我们不使用 AVCodecContext.time_base，而用帧率倒数作时间基，在视频编码过程中，我们将 AVCodecContext.time_base 设置为帧率的倒数。

3.7.1 视频流

视频按帧播放，所以解码后的原始视频帧时间基为 1/framerate。

视频解码过程中的时间基转换处理：

AVFormatContext *ifmt_ctx;

AVStream *in_stream;

AVCodecContext *dec_ctx;

AVPacket packet;

AVFrame *frame;

// 从输入文件中读取编码帧

av_read_frame(ifmt_ctx, &packet);

// 时间基转换

int raw_video_time_base = av_inv_q(dec_ctx->framerate);

av_packet_rescale_ts(packet, in_stream->time_base, raw_video_time_base);

// 解码

avcodec_send_packet(dec_ctx, packet)

avcodec_receive_frame(dec_ctx, frame);

视频编码过程中的时间基转换处理：

AVFormatContext *ofmt_ctx;

AVStream *out_stream;

AVCodecContext *dec_ctx;

AVCodecContext *enc_ctx;

AVPacket packet;

AVFrame *frame;

// 编码

avcodec_send_frame(enc_ctx, frame);

avcodec_receive_packet(enc_ctx, packet);

// 时间基转换

packet.stream_index = out_stream_idx;

enc_ctx->time_base = av_inv_q(dec_ctx->framerate);

av_packet_rescale_ts(&opacket, enc_ctx->time_base, out_stream->time_base);

// 将编码帧写入输出媒体文件

av_interleaved_write_frame(o_fmt_ctx, &packet);

3.7.2 音频流

音频按采样点播放，所以解码后的原始音频帧时间基为 1/sample_rate

音频解码过程中的时间基转换处理：

AVFormatContext *ifmt_ctx;

AVStream *in_stream;

AVCodecContext *dec_ctx;

AVPacket packet;

AVFrame *frame;

// 从输入文件中读取编码帧

av_read_frame(ifmt_ctx, &packet);

// 时间基转换

int raw_audio_time_base = av_inv_q(dec_ctx->sample_rate);

av_packet_rescale_ts(packet, in_stream->time_base, raw_audio_time_base);

// 解码

avcodec_send_packet(dec_ctx, packet)

avcodec_receive_frame(dec_ctx, frame);

音频编码过程中的时间基转换处理：

AVFormatContext *ofmt_ctx;

AVStream *out_stream;

AVCodecContext *dec_ctx;

AVCodecContext *enc_ctx;

AVPacket packet;

AVFrame *frame;

// 编码

avcodec_send_frame(enc_ctx, frame);

avcodec_receive_packet(enc_ctx, packet);

// 时间基转换

packet.stream_index = out_stream_idx;

enc_ctx->time_base = av_inv_q(dec_ctx->sample_rate);

av_packet_rescale_ts(&opacket, enc_ctx->time_base, out_stream->time_base);

// 将编码帧写入输出媒体文件

av_interleaved_write_frame(o_fmt_ctx, &packet);

4. 参考资料

[1]. What does the output of ffmpeg mean? tbr tbn tbc etc?

[2]. 视频编解码基础概念, https://www.cnblogs.com/leisure_chn/p/10285829.html

[3]. 对 ffmpeg 的时间戳的理解笔记, https://blog.csdn.net/topsluo/article/details/76239136

[4]. ffmpeg 中的时间戳与时间基, http://www.imooc.com/article/91381

[5]. ffmpeg 编解码中涉及到的 pts 详解, http://www.52ffmpeg.com/article/353.html

[6]. 音视频录入的 pts 和 dts 问题, https://blog.csdn.net/zhouyongku/article/details/38510747

5. 修改记录

2019-03-16 V1.0 初稿

2019-03-23 V1.1 增加 3.7 节

FFmpeg编解码处理2-编解码API详解

4. 编解码API详解

解码使用 avcodec_send_packet() 和 avcodec_receive_frame() 两个函数。

编码使用 avcodec_send_frame() 和 avcodec_receive_packet() 两个函数。

4.1 API定义

4.1.1 avcodec_send_packet()

/**

* Supply raw packet data as input to a decoder.

* Internally, this call will copy relevant AVCodecContext fields, which can

* influence decoding per-packet, and apply them when the packet is actually

* decoded. (For example AVCodecContext.skip_frame, which might direct the

* decoder to drop the frame contained by the packet sent with this function.)

* @warning The input buffer, avpkt->data must be AV_INPUT_BUFFER_PADDING_SIZE

* larger than the actual read bytes because some optimized bitstream

* readers read 32 or 64 bits at once and could read over the end.

* @warning Do not mix this API with the legacy API (like avcodec_decode_video2())

* on the same AVCodecContext. It will return unexpected results now

* or in future libavcodec versions.

* @note The AVCodecContext MUST have been opened with @ref avcodec_open2()

* before packets may be fed to the decoder.

* @param avctx codec context

* @param[in] avpkt The input AVPacket. Usually, this will be a single video

* frame, or several complete audio frames.

* Ownership of the packet remains with the caller, and the

* decoder will not write to the packet. The decoder may create

* a reference to the packet data (or copy it if the packet is

* not reference-counted).

* Unlike with older APIs, the packet is always fully consumed,

* and if it contains multiple frames (e.g. some audio codecs),

* will require you to call avcodec_receive_frame() multiple

* times afterwards before you can send a new packet.

* It can be NULL (or an AVPacket with data set to NULL and

* size set to 0); in this case, it is considered a flush

* packet, which signals the end of the stream. Sending the

* first flush packet will return success. Subsequent ones are

* unnecessary and will return AVERROR_EOF. If the decoder

* still has frames buffered, it will return them after sending

* a flush packet.

* @return 0 on success, otherwise negative error code:

* AVERROR(EAGAIN): input is not accepted in the current state - user

* must read output with avcodec_receive_frame() (once

* all output is read, the packet should be resent, and

* the call will not fail with EAGAIN).

* AVERROR_EOF: the decoder has been flushed, and no new packets can

* be sent to it (also returned if more than 1 flush

* packet is sent)

* AVERROR(EINVAL): codec not opened, it is an encoder, or requires flush

* AVERROR(ENOMEM): failed to add packet to internal queue, or similar

* other errors: legitimate decoding errors

int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt);

4.1.2 avcodec_receive_frame()

/**

* Return decoded output data from a decoder.

* @param avctx codec context

* @param frame This will be set to a reference-counted video or audio

* frame (depending on the decoder type) allocated by the

* decoder. Note that the function will always call

* av_frame_unref(frame) before doing anything else.

* @return

* 0: success, a frame was returned

* AVERROR(EAGAIN): output is not available in this state - user must try

* to send new input

* AVERROR_EOF: the decoder has been fully flushed, and there will be

* no more output frames

* AVERROR(EINVAL): codec not opened, or it is an encoder

* other negative values: legitimate decoding errors

int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame);

4.1.3 avcodec_send_frame()

/**

* Supply a raw video or audio frame to the encoder. Use avcodec_receive_packet()

* to retrieve buffered output packets.

* @param avctx codec context

* @param[in] frame AVFrame containing the raw audio or video frame to be encoded.

* Ownership of the frame remains with the caller, and the

* encoder will not write to the frame. The encoder may create

* a reference to the frame data (or copy it if the frame is

* not reference-counted).

* It can be NULL, in which case it is considered a flush

* packet. This signals the end of the stream. If the encoder

* still has packets buffered, it will return them after this

* call. Once flushing mode has been entered, additional flush

* packets are ignored, and sending frames will return

* AVERROR_EOF.

* For audio:

* If AV_CODEC_CAP_VARIABLE_FRAME_SIZE is set, then each frame

* can have any number of samples.

* If it is not set, frame->nb_samples must be equal to

* avctx->frame_size for all frames except the last.

* The final frame may be smaller than avctx->frame_size.

* @return 0 on success, otherwise negative error code:

* AVERROR(EAGAIN): input is not accepted in the current state - user

* must read output with avcodec_receive_packet() (once

* all output is read, the packet should be resent, and

* the call will not fail with EAGAIN).

* AVERROR_EOF: the encoder has been flushed, and no new frames can

* be sent to it

* AVERROR(EINVAL): codec not opened, refcounted_frames not set, it is a

* decoder, or requires flush

* AVERROR(ENOMEM): failed to add packet to internal queue, or similar

* other errors: legitimate decoding errors

int avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame);

4.1.4 avcodec_receive_packet()

/**

* Read encoded data from the encoder.

* @param avctx codec context

* @param avpkt This will be set to a reference-counted packet allocated by the

* encoder. Note that the function will always call

* av_frame_unref(frame) before doing anything else.

* @return 0 on success, otherwise negative error code:

* AVERROR(EAGAIN): output is not available in the current state - user

* must try to send input

* AVERROR_EOF: the encoder has been fully flushed, and there will be

* no more output packets

* AVERROR(EINVAL): codec not opened, or it is an encoder

* other errors: legitimate decoding errors

int avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt);

4.2 API使用说明

4.2.1 解码API使用详解

关于 avcodec_send_packet() 与 avcodec_receive_frame() 的使用说明：

[1] 按 dts 递增的顺序向解码器送入编码帧 packet，解码器按 pts 递增的顺序输出原始帧 frame，实际上解码器不关注输入 packe t的 dts(错值都没关系)，它只管依次处理收到的 packet，按需缓冲和解码

[2] avcodec_receive_frame() 输出 frame 时，会根据各种因素设置好 frame->best_effort_timestamp(文档明确说明)，实测 frame->pts 也会被设置(通常直接拷贝自对应的 packet.pts，文档未明确说明)用户应确保 avcodec_send_packet() 发送的 packet 具有正确的 pts，编码帧 packet 与原始帧 frame 间的对应关系通过 pts 确定

[3] avcodec_receive_frame() 输出 frame 时，frame->pkt_dts 拷贝自当前avcodec_send_packet() 发送的 packet 中的 dts，如果当前 packet 为 NULL(flush packet)，解码器进入 flush 模式，当前及剩余的 frame->pkt_dts 值总为 AV_NOPTS_VALUE。因为解码器中有缓存帧，当前输出的 frame 并不是由当前输入的 packet 解码得到的，所以这个 frame->pkt_dts 没什么实际意义，可以不必关注

[4] avcodec_send_packet() 发送第一个 NULL 会返回成功，后续的 NULL 会返回 AVERROR_EOF

[5] avcodec_send_packet() 多次发送 NULL 并不会导致解码器中缓存的帧丢失，使用 avcodec_flush_buffers() 可以立即丢掉解码器中缓存帧。因此播放完毕时应 avcodec_send_packet(NULL) 来取完缓存的帧，而 SEEK 操作或切换流时应调用 avcodec_flush_buffers() 来直接丢弃缓存帧

[6] 解码器通常的冲洗方法：调用一次 avcodec_send_packet(NULL)(返回成功)，然后不停调用 avcodec_receive_frame() 直到其返回 AVERROR_EOF，取出所有缓存帧，avcodec_receive_frame() 返回 AVERROR_EOF 这一次是没有有效数据的，仅仅获取到一个结束标志

4.2.2 编码API使用详解

关于 avcodec_send_frame() 与 avcodec_receive_packet() 的使用说明：

[1] 按 pts 递增的顺序向编码器送入原始帧 frame，编码器按 dts 递增的顺序输出编码帧 packet，实际上编码器关注输入 frame 的 pts 不关注其 dts，它只管依次处理收到的 frame，按需缓冲和编码

[2] avcodec_receive_packet() 输出 packet 时，会设置 packet.dts，从 0 开始，每次输出的 packet 的 dts 加 1，这是视频层的 dts，用户写输出前应将其转换为容器层的 dts

[3] avcodec_receive_packet() 输出 packet 时，packet.pts 拷贝自对应的 frame.pts，这是视频层的 pts，用户写输出前应将其转换为容器层的 pts

[4] avcodec_send_frame() 发送 NULL frame 时，编码器进入 flush 模式

[5] avcodec_send_frame() 发送第一个 NULL 会返回成功，后续的 NULL 会返回 AVERROR_EOF

[6] avcodec_send_frame() 多次发送 NULL 并不会导致编码器中缓存的帧丢失，使用 avcodec_flush_buffers() 可以立即丢掉编码器中缓存帧。因此编码完毕时应使用 avcodec_send_frame(NULL) 来取完缓存的帧，而SEEK操作或切换流时应调用 avcodec_flush_buffers() 来直接丢弃缓存帧

[7] 编码器通常的冲洗方法：调用一次 avcodec_send_frame(NULL)(返回成功)，然后不停调用 avcodec_receive_packet() 直到其返回 AVERROR_EOF，取出所有缓存帧，avcodec_receive_packet() 返回 AVERROR_EOF 这一次是没有有效数据的，仅仅获取到一个结束标志

[8] 对音频来说，如果 AV_CODEC_CAP_VARIABLE_FRAME_SIZE(在 AVCodecContext.codec.capabilities 变量中，只读)标志有效，表示编码器支持可变尺寸音频帧，送入编码器的音频帧可以包含任意数量的采样点。如果此标志无效，则每一个音频帧的采样点数目(frame->nb_samples)必须等于编码器设定的音频帧尺寸(avctx->frame_size)，最后一帧除外，最后一帧音频帧采样点数可以小于 avctx->frame_size

4.3 API使用例程

4.3.1 解码API例程

// retrun 0: got a frame success

// AVERROR(EAGAIN): need more packet

// AVERROR_EOF: end of file, decoder has been flushed

// <0: error

int av_decode_frame(AVCodecContext *dec_ctx, AVPacket *packet, bool *new_packet, AVFrame *frame)

{

int ret = AVERROR(EAGAIN);

while (1)

{

// 2. 从解码器接收frame

if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO)

{

// 2.1 一个视频packet含一个视频frame

// 解码器缓存一定数量的packet后，才有解码后的frame输出

// frame输出顺序是按pts的顺序，如IBBPBBP

// frame->pkt_pos变量是此frame对应的packet在视频文件中的偏移地址，值同pkt.pos

ret = avcodec_receive_frame(dec_ctx, frame);

if (ret >= 0)

{

if (frame->pts == AV_NOPTS_VALUE)

{

frame->pts = frame->best_effort_timestamp;

printf("set video pts %d\n", frame->pts);

}

else if (dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO)

{

// 2.2 一个音频packet含一至多个音频frame，每次avcodec_receive_frame()返回一个frame，此函数返回。

// 下次进来此函数，继续获取一个frame，直到avcodec_receive_frame()返回AVERROR(EAGAIN)，

// 表示解码器需要填入新的音频packet

ret = avcodec_receive_frame(dec_ctx, frame);

if (ret >= 0)

{

if (frame->pts == AV_NOPTS_VALUE)

{

frame->pts = frame->best_effort_timestamp;

printf("set audio pts %d\n", frame->pts);

}

if (ret >= 0) // 成功解码得到一个视频帧或一个音频帧，则返回

{

return ret;

}

else if (ret == AVERROR_EOF) // 解码器已冲洗，解码中所有帧已取出

{

avcodec_flush_buffers(dec_ctx);

return ret;

}

else if (ret == AVERROR(EAGAIN))// 解码器需要喂数据

{

if (!(*new_packet)) // 本函数中已向解码器喂过数据，因此需要从文件读取新数据

{

//av_log(NULL, AV_LOG_INFO, "decoder need more packet\n");

return ret;

}

else // 错误

{

av_log(NULL, AV_LOG_ERROR, "decoder error %d\n", ret);

return ret;

}

if (packet == NULL || (packet->data == NULL && packet->size == 0))

{

// 复位解码器内部状态/刷新内部缓冲区。当seek操作或切换流时应调用此函数。

avcodec_flush_buffers(dec_ctx);

}

// 1. 将packet发送给解码器

// 发送packet的顺序是按dts递增的顺序，如IPBBPBB

// pkt.pos变量可以标识当前packet在视频文件中的地址偏移

// 发送第一个 flush packet 会返回成功，后续的 flush packet 会返回AVERROR_EOF

ret = avcodec_send_packet(dec_ctx, packet);

*new_packet = false;

if (ret != 0)

{

av_log(NULL, AV_LOG_ERROR, "avcodec_send_packet() error, return %d\n", ret);

return ret;

}

return -1;

}

4.3.2 编码API例程

int av_encode_frame(AVCodecContext *enc_ctx, AVFrame *frame, AVPacket *packet)

{

int ret = -1;

// 第一次发送flush packet会返回成功，进入冲洗模式，可调用avcodec_receive_packet()

// 将编码器中缓存的帧(可能不止一个)取出来

// 后续再发送flush packet将返回AVERROR_EOF

ret = avcodec_send_frame(enc_ctx, frame);

if (ret == AVERROR_EOF)

{

//av_log(NULL, AV_LOG_INFO, "avcodec_send_frame() encoder flushed\n");

}

else if (ret == AVERROR(EAGAIN))

{

//av_log(NULL, AV_LOG_INFO, "avcodec_send_frame() need output read out\n");

}

else if (ret < 0)

{

//av_log(NULL, AV_LOG_INFO, "avcodec_send_frame() error %d\n", ret);

return ret;

}

ret = avcodec_receive_packet(enc_ctx, packet);

if (ret == AVERROR_EOF)

{

av_log(NULL, AV_LOG_INFO, "avcodec_recieve_packet() encoder flushed\n");

}

else if (ret == AVERROR(EAGAIN))

{

//av_log(NULL, AV_LOG_INFO, "avcodec_recieve_packet() need more input\n");

}

return ret;

}

FFmpeg编解码处理1-转码全流程简介

1. 转码全流程简介

看一下 FFmpeg 常规处理流程：

FFmpeg处理流程

大流程可以划分为输入、输出、转码、播放四大块。其中转码涉及比较多的处理环节，从图中可以看出，转码功能在整个功能图中占比很大。转码的核心功能在解码和编码两个部分，但在一个可用的示例程序中，编码解码与输入输出是难以分割的。解复用器为解码器提供输入，解码器会输出原始帧，对原始帧可进行各种复杂的滤镜处理，滤镜处理后的帧经编码器生成编码帧，多路流的编码帧经复用器输出到输出文件。

1.1 解复用

从输入文件中读取编码帧，判断流类型，根据流类型将编码帧送入视频解码器或音频解码器。

av_read_frame(ictx.fmt_ctx, &ipacket);

if (codec_type == AVMEDIA_TYPE_VIDEO) {

transcode_video(&stream, &ipacket);

} else if (codec_type == AVMEDIA_TYPE_AUDIO) {

transcode_audio(&stream, &ipacket);

}

else {

av_interleaved_write_frame(octx.fmt_ctx, &ipacket);

}

1.2 解码

将视音频编码帧解码生成原始帧。后文详述。

1.3 滤镜

FFmpeg 提供多种多样的滤镜，用来处理原始帧数据。

本例中，为每个音频流/视频流使用空滤镜，即滤镜图中将 buffer 滤镜和 buffersink 滤镜直接相连。目的是：通过视频 buffersink 滤镜将视频流输出像素格式转换为编码器采用的像素格式；通过音频 abuffersink 滤镜将音频流输出声道布局转换为编码器采用的声道布局。为下一步的编码操作作好准备。如果不使用这种方法，则需要处理图像格式转换和音频重采样，从而确保进入编码器的帧是编码器支持的格式。

当然，例程可扩展，可以很容易的在 buffer 滤镜和 buffersink 滤镜中间插入其他功能滤镜，实现丰富的视音频处理功能。

滤镜的使用方法不是本实验关注的重点。详细用法可参考 "FFmpeg原始帧处理-滤镜API用法”

1.4 编码

将原始视音频帧编码生成编码帧。后文详述。

1.5 复用

将编码帧按不同流类型交织写入输出文件。

av_interleaved_write_frame(octx.fmt_ctx, &ipacket);

2. 转码例程简介

转码功能复杂，示例程序很难写得简短，这几篇笔记共用同一份示例代码。在 shell 中运行如下命令下载例程源码：

svn checkout https://github.com/leichn/exercises/trunk/source/ffmpeg/ffmpeg_transcode

例程支持在命令行中指定视音频编码格式以及输出文件封装格式。如果编码格式指定为 "copy"，则输出流使用与输入流相同的编码格式。与 FFmpeg 命令不同的是，FFmpeg 命令指定编码器参数为 "copy" 时，将不会启动编解码过程，而仅启用转封装过程，整个过程很快执行完毕；本例程指定编码格式为 "copy" 时，则会使用相同的编码格式进行解码与编码，整个过程比较耗时。

例程验证方法：

./transcode -i input.flv -c:v mpeg2video -c:a mp2 output.ts

和如下命令效果大致一样：

ffmpeg -i input.flv -c:v mpeg2video -c:a mp2 output.ts

源代码文件说明：

Makefile

main.c 转复用转码功能

av_codec.c 编码解码功能

av_filter.c 滤镜处理

open_file.c 打开输入输出文件

转码的主流程主要在 main. c中 transcode_video()、transcode_audio() 和 transcode_audio_with_afifo() 三个函数中。当输入音频帧尺寸能被音频编码器接受时，使用 transcode_audio() 函数；否则，引入音频 FIFO，使每次从 FIFO 中取出的音频帧尺寸能被音频编码器接受，使用 transcode_audio_with_afifo() 函数实现此功能。这几个函数仅提供示意功能，演示音视频转码功能的实现方法，源码纠结、可读性差，暂无时间优化。

2.1 视频转码流程

视频转码函数 transcode_video()，其主要处理流程如下(已删除大量细节代码)：

static int transcode_video(const stream_ctx_t *sctx, AVPacket *ipacket)

{

AVFrame *frame_dec = av_frame_alloc();

AVFrame *frame_flt = av_frame_alloc();

AVPacket opacket;

// 一个视频packet只包含一个视频frame，但冲洗解码器时一个flush packet会取出

// 多个frame出来，每次循环取处理一个frame

while (1)

{

// 1. 时间基转换，解码

av_packet_rescale_ts(ipacket, sctx->i_stream->time_base, sctx->o_codec_ctx->time_base);

ret = av_decode_frame(sctx->i_codec_ctx, ipacket, &new_packet, frame_dec);

// 2. 滤镜处理

ret = filtering_frame(sctx->flt_ctx, frame_dec, frame_flt);

// 3. 编码

// 3.1 设置帧类型

frame_flt->pict_type = AV_PICTURE_TYPE_NONE;

// 3.2 编码

ret = av_encode_frame(sctx->o_codec_ctx, frame_flt, &opacket);

// 3.3 更新编码帧中流序号

opacket.stream_index = sctx->stream_idx;

// 3.4 时间基转换，AVPacket.pts和AVPacket.dts的单位是AVStream.time_base，不同的封装格式其

// AVStream.time_base不同所以输出文件中，每个packet需要根据输出封装格式重新计算pts和dts

av_packet_rescale_ts(&opacket, sctx->o_codec_ctx->time_base, sctx->o_stream->time_base);

// 4. 将编码后的packet写入输出媒体文件

ret = av_interleaved_write_frame(sctx->o_fmt_ctx, &opacket);

av_packet_unref(&opacket);

}

return ret;

}

2.2 音频转码流程

音频转码函数 transcode_audio()，其主要处理流程如下(已删除大量细节代码)：

static int transcode_audio_with_afifo(const stream_ctx_t *sctx, AVPacket *ipacket)

{

AVFrame *frame_dec = av_frame_alloc();

AVFrame *frame_flt = av_frame_alloc();

AVFrame *frame_enc = NULL;

AVPacket opacket;

int enc_frame_size = sctx->o_codec_ctx->frame_size;

AVAudioFifo* p_fifo = sctx->aud_fifo;

static int s_pts = 0;

while (1) // 处理一个packet，一个音频packet可能包含多个音频frame，循环每次处理一个frame

{

// 1. 时间基转换，解码

av_packet_rescale_ts(ipacket, sctx->i_stream->time_base, sctx->o_codec_ctx->time_base);

ret = av_decode_frame(sctx->i_codec_ctx, ipacket, &new_packet, frame_dec);

// 2. 滤镜处理

ret = filtering_frame(sctx->flt_ctx, frame_dec, frame_flt);

// 3. 使用音频fifo，从而保证每次送入编码器的音频帧尺寸满足编码器要求

// 3.1 将音频帧写入fifo，音频帧尺寸是解码格式中音频帧尺寸

if (!dec_finished)

{

uint8_t** new_data = frame_flt->extended_data; // 本帧中多个声道音频数据

int new_size = frame_flt->nb_samples; // 本帧中单个声道的采样点数

// FIFO中可读数据小于编码器帧尺寸，则继续往FIFO中写数据

ret = write_frame_to_audio_fifo(p_fifo, new_data, new_size);

}

// 3.2 从fifo中取出音频帧，音频帧尺寸是编码格式中音频帧尺寸

// FIFO中可读数据大于编码器帧尺寸，则从FIFO中读走数据进行处理

while ((av_audio_fifo_size(p_fifo) >= enc_frame_size) || dec_finished)

{

// 从FIFO中读取数据，编码，写入输出文件

ret = read_frame_from_audio_fifo(p_fifo, sctx->o_codec_ctx, &frame_enc);

// 4. fifo中读取的音频帧没有时间戳信息，重新生成pts

frame_enc->pts = s_pts;

s_pts += ret;

flush_encoder:

// 5. 编码

ret = av_encode_frame(sctx->o_codec_ctx, frame_enc, &opacket);

// 5.1 更新编码帧中流序号，并进行时间基转换

// AVPacket.pts和AVPacket.dts的单位是AVStream.time_base，不同的封装格式其AVStream.time_base不同

// 所以输出文件中，每个packet需要根据输出封装格式重新计算pts和dts

opacket.stream_index = sctx->stream_idx;

av_packet_rescale_ts(&opacket, sctx->o_codec_ctx->time_base, sctx->o_stream->time_base);

// 6. 将编码后的packet写入输出媒体文件

ret = av_interleaved_write_frame(sctx->o_fmt_ctx, &opacket);

}

if (finished)

{

break;

}

return ret;

}

2.3 转码过程中的时间戳处理

在封装格式处理例程中，不深入理解时间戳也没有关系。但在编解码处理例程中，时间戳处理是很重要的一个细节，必须要搞清楚。

容器(文件层)中的时间基(AVStream.time_base)与编解码器上下文(视频层)里的时间基(AVCodecContex.time_base)不一样，解码编码过程中需要进行时间基转换。

视频按帧进行播放，所以原始视频帧时间基为 1/framerate。视频解码前需要处理输入 AVPacket 中各时间参数，将输入容器中的时间基转换为 1/framerate 时间基；视频编码后再处理输出 AVPacket 中各时间参数，将 1/framerate 时间基转换为输出容器中的时间基。

音频按采样点进行播放，所以原始音频帧时间为 1/sample_rate。音频解码前需要处理输入 AVPacket 中各时间参数，将输入容器中的时间基转换为 1/sample_rate 时间基；音频编码后再处理输出 AVPacket 中各时间参数，将 1/sample_rate 时间基转换为输出容器中的时间基。如果引入音频 FIFO，从 FIFO 从读出的音频帧时间戳信息会丢失，需要使用 1/sample_rate 时间基重新为每一个音频帧生成 pts，然后再送入编码器。

解码前的时间基转换：

av_packet_rescale_ts(ipacket, sctx->i_stream->time_base, sctx->o_codec_ctx->time_base);

编码后的时间基转换：

av_packet_rescale_ts(&opacket, sctx->o_codec_ctx->time_base, sctx->o_stream->time_base);

关于时间基与时间戳的详细内容可参考 "FFmpeg时间戳详解"。编解码过程主要关注音视频帧的 pts，用户可不关注 dts，详细说明可参考 "FFmpeg编解码处理3-编解码API详解"。

3. 编译与验证

在 shell 中运行如下命令下载例程源码：

svn checkout https://github.com/leichn/exercises/trunk/source/ffmpeg/ffmpeg_transcode

在源码目录执行 make 命令，生成 transcode 可执行文件

下载测试文件(右键另存为)：tnmil2.flv

使用 ffprobe 看一下文件格式：

think@opensuse> ffprobe tnmil2.flv

Input #0, flv, from 'tnmil2.flv':

Metadata:

encoder : Lavf58.20.100

Duration: 00:00:13.68, start: 0.057000, bitrate: 474 kb/s

Stream #0:0: Video: h264 (High), yuv420p(progressive), 784x480, 25 fps, 25 tbr, 1k tbn, 50 tbc

Stream #0:1: Audio: aac (LC), 44100 Hz, stereo, fltp, 128 kb/s

使用输入文件中的编码格式和封装格式生成输出文件

./transcode -i tnmil2.flv -c:v copy -c:a copy tnmil2o.flv

指定编码格式和封装格式生成输出文件

./transcode -i tnmil2.flv -c:v mpeg2video -c:a mp2 tnmil2.ts

ffmpeg流程

FMpeg 实现视频解码、编码、转码

一、FFmpeg模块分类

打开FFmpeg源码，会发现有一系列libavxxx的模块，这些模块很好地划分了代码的结构和分工。

libavformat，format，格式封装

libavcodec，codec，编码、解码

libavutil，util，通用音视频工具，像素、IO、时间等工具

libavfilter，filter，过滤器，可以用作音视频特效处理

libavdevice，device，设备（摄像头、拾音器）

libswscale，scale，视频图像缩放，像素格式互换

libavresample，resample，重采样

libswresample，也是重采样，类似图像缩放

libpostproc，后期处理

二、FFmpeg核心结构体

AVFormatContext：解封装功能的结构体，包含文件名、音视频流、时长、比特率等信息；

AVCodecContext：编解码器上下文，编码和解码时必须用到的结构体，包含编解码器类型、视频宽高、音频通道数和采样率等信息；

AVCodec：存储编解码器信息的结构体；

AVStream：存储音频或视频流信息的结构体；

AVPacket：存储音频或视频编码数据；

AVFrame：存储音频或视频解码数据（原始数据）。

四、FFmpeg解码实现

解码实现的是将压缩域的视频数据解码为像素域的 YUV 数据。实现的过程，可以大致用如下图所示。

从图中可以看出，大致可以分为下面三个步骤：

首先要有待解码的压缩域的视频。
其次根据压缩域的压缩格式获得解码器。
最后解码器的输出即为像素域的 YUV 数据

五、FFmpeg编码实现

视频域 YUV 数据编码为压缩域的帧数据

从图中可以大致看出视频编码的流程:

首先要有未压缩的 YUV 原始数据。
其次要根据想要编码的格式选择特定的编码器。
最后编码器的输出即为编码后的视频帧。

六、FFmpeg转码实现

传统的编码转换程序工作原理图

封装的目的：

1. 是为了在一个文件流(Stream)中能同时存储视频流(Video Stream)、音频流(Audio Stream)、字幕(Subtitle)、附件(t)、数据(d)等内容。这正是“复用”的含义所在(分时复用)。

2. 是在网络环境下确保数据的可靠快速传输。

编码的目的：

是为了压缩媒体数据。有别于通用文件数据的压缩，在图像或音频压缩的时候，可以借助图像特性（如前后关联、相邻图块关联）或声音特性（听觉模型）进行压缩，可以达到比通用压缩技术更高的压缩比。

FFmepg中的sws_scale() 函数分析

FFmpeg中的 sws_scale() 函数主要是用来做视频像素格式和分辨率的转换，其优势在于：可以在同一个函数里实现：1.图像色彩空间转换， 2:分辨率缩放，3:前后图像滤波处理。不足之处在于：效率相对较低，不如libyuv或shader，其关联的函数主要有：

1.sws_getContext():

复制代码

struct SwsContext *sws_getContext(

int srcW, /* 输入图像的宽度 */

int srcH, /* 输入图像的宽度 */

enum AVPixelFormat srcFormat, /* 输入图像的像素格式 */

int dstW, /* 输出图像的宽度 */

int dstH, /* 输出图像的高度 */

enum AVPixelFormat dstFormat, /* 输出图像的像素格式 */

int flags,/* 选择缩放算法(只有当输入输出图像大小不同时有效),一般选择SWS_FAST_BILINEAR */

SwsFilter *srcFilter, /* 输入图像的滤波器信息, 若不需要传NULL */

SwsFilter *dstFilter, /* 输出图像的滤波器信息, 若不需要传NULL */

const double *param /* 特定缩放算法需要的参数(?)，默认为NULL */

);

复制代码

与其类似的函数还有： sws_getCachedContext ，区别在于： sws_getContext 可以用于多路码流转换，为每个不同的码流都指定一个不同的转换上下文，而 sws_getCachedContext 只能用于一路码流转换。

2.sws_freeContext

// 释放sws_scale

void sws_freeContext(struct SwsContext *swsContext);

真正用来做转换的函数则是： sws_scale() ，其函数定义如下：

int sws_scale(struct SwsContext *c, const uint8_t *const srcSlice[],

const int srcStride[], int srcSliceY, int srcSliceH,

uint8_t *const dst[], const int dstStride[]);

下面对其函数参数进行详细说明：

1.参数 SwsContext *c，转换格式的上下文。也就是 sws_getContext 函数返回的结果。

2.参数 const uint8_t *const srcSlice[], 输入图像的每个颜色通道的数据指针。其实就是解码后的AVFrame中的data[]数组。因为不同像素的存储格式不同，所以srcSlice[]维数

也有可能不同。

以YUV420P为例，它是planar格式，它的内存中的排布如下：

YYYYYYYY UUUU VVVV

使用FFmpeg解码后存储在AVFrame的data[]数组中时：

data[0]——-Y分量, Y1, Y2, Y3, Y4, Y5, Y6, Y7, Y8……

data[1]——-U分量, U1, U2, U3, U4……

data[2]——-V分量, V1, V2, V3, V4……

linesize[]数组中保存的是对应通道的数据宽度，

linesize[0]——-Y分量的宽度

linesize[1]——-U分量的宽度

linesize[2]——-V分量的宽度

而RGB24，它是packed格式，它在data[]数组中则只有一维，它在存储方式如下：

data[0]: R1, G1, B1, R2, G2, B2, R3, G3, B3, R4, G4, B4……

这里要特别注意，linesize[0]的值并不一定等于图片的宽度，有时候为了对齐各解码器的CPU，实际尺寸会大于图片的宽度，这点在我们编程时（比如OpengGL硬件转换/渲染）要特别注意，否则解码出来的图像会异常。

3.参数const int srcStride[]，输入图像的每个颜色通道的跨度。.也就是每个通道的行字节数，对应的是解码后的AVFrame中的linesize[]数组。根据它可以确立下一行的起始位置，不过stride和width不一定相同，这是因为：

a.由于数据帧存储的对齐，有可能会向每行后面增加一些填充字节这样 stride = width + N；

b.packet色彩空间下，每个像素几个通道数据混合在一起，例如RGB24，每个像素3字节连续存放，因此下一行的位置需要跳过3*width字节。

4.参数int srcSliceY, int srcSliceH,定义在输入图像上处理区域，srcSliceY是起始位置，srcSliceH是处理多少行。如果srcSliceY=0，srcSliceH=height，表示一次性处理完整个图像。这种设置是为了多线程并行，例如可以创建两个线程，第一个线程处理 [0, h/2-1]行，第二个线程处理 [h/2, h-1]行。并行处理加快速度。

5.参数uint8_t *const dst[], const int dstStride[]定义输出图像信息（输出的每个颜色通道数据指针，每个颜色通道行字节数）

代码示例：将解码后的数据转换成1280*720的RGBA8888 格式

1. 定义转换格式的上下文

复制代码

vctx = sws_getCachedContext(

vctx,

frame->width, // 源图像的宽度

frame->height, // 源图像的高度

(AVPixelFormat)frame->format,

outWidth,

outHeight,

AV_PIX_FMT_RGBA,

SWS_FAST_BILINEAR,

0, 0, 0

);

复制代码

2. 开始转换

复制代码

int outWidth = 1280;

int outHeight = 720;

char *rgb = new char[1920*1080*4];

uint8_t *data[AV_NUM_DATA_POINTERS] = {0};

data[0] = (uint8_t *)rgb;

int lines[AV_NUM_DATA_POINTERS] = {0};

lines[0] = outWidth * 4;

int h = sws_scale(vctx,

(const uint8_t **)frame->data,

frame->linesize,

frame->height,

data,

lines

);

利用ffmpeg+opencv实现画中画

需求：把两路视频合成一路，即一个画面同时显示两路视频，其中一路缩小成小视频叠在大视频上面，和电视机的画中画效果类似。

思路：用h264编码的视频举例，文件中存储的es流是h264，经过解码成yuv，yuv可以转换成rgb格式。把小视频的rgb复制到大视频需要被覆盖的位置上。将重新合成的rgb转换成yuv，利用ffmpeg 或 x264重新编码出新的视频即可。

方法：编解码还是利用ffmpeg 。 ffmpeg 解码两路视频，解码后都是yuv。利用ffmpeg· 的sws_getContext 函数改变小图的大小。之后利用opencv完成两个图片的合成（opencv这种高大上的库被我用成了这样····实在汗颜。其实此处的合并rgb可以自己写算法实现，本质是把小图的rgb复制到大图的对应位置上。）合成好后将rbg转成yuv格式，利用x264重新编码成h264 ，就看到了大视频左上角有个小视频了。

代码思路：

两个线程，各自解码，主视频的线程解码一帧后通知副视频的线程进行解码并转化图片大小，副视频的线程解码完成后通知主线程合成视频并编码。合成视频的时候用opencv很简单，直接把yuv转化成rgb，之后在主视频上设置敏感区，把小视频叠加上就行。

主副线程解码套路一样，ffmpeg的基本使用套路。把yuv转成opencv mat类型的rgb套路也一样，上副视频解码线程的代码进行说明。

全局变量：

cv::Mat littlergb,bigrgb;//大小视频的rgb

cv::Mat littleframe,bigframe;//大小视频的yuv

副视频解码线程内的代码：

while(av_read_frame(pInputFormatContext, &InPack) >=0)

{

len = avcodec_decode_video2(pInputCodecContext, &OutFrame, &nComplete, &InPack);//解码视频

if (nComplete>0)

{

if (GetMessage(&msg, NULL, 0, 0))

{

switch(msg.message)

{

case MY_MSG_DECODE:

sws_scale(m_pSwsContext,OutFrame.data,OutFrame.linesize, 0,OutFrame.height,dst->data,dst->linesize);//转换图片大小

memcpy(littleframe.data,dst->data[0], 640*480); //以下将ffmpeg的yuv数据存到opencv的mat类型中。即opencv存储的yuv数据

memcpy(littleframe.data+640*480,dst->data[1], 640*480/4);

memcpy(littleframe.data+640*480*5/4,dst->data[2], 640*480/4);

SetEvent(hEncodeEvent);

break;

}

av_free_packet(&InPack);

}

合并图片直接用opencv，代码如下：

cv::cvtColor(littleframe, littlergb,CV_YUV2BGR_I420);

cv::cvtColor(bigframe, bigrgb,CV_YUV2BGR_I420); //以上yuv转rgb

Mat roi(bigrgb,Rect(0,0,640,480));//大图上设置敏感区

littlergb.copyTo(roi); //把小图拷贝过去

Mat outframe;

cv::cvtColor(bigrgb, outframe,CV_BGR2YUV_I420); //rgb到yuv

这样就获得了合并后的图片的yuv。

之后进行编码即可。编码出来的视频就是画中画了。

点击打开链接

这个代码，缺了dll和lib还有头文件，空间不够传不上····

在MFC中使用SDL2.0（SDL窗口嵌入到MFC中）

第一步：新建MFC基于对话框的应用程序（此例工程命名为MFC_SDL），然后直接点击完成即可，如下图。

第二步：删除“TODO:在此放置对话框控件”。添加Picture Control和Button到对话框中，修改Button的名字为显示图片。

第三步：SDL相关头文件、lib库以及dll动态链接库的设置可以参考这篇文章：SDL2学习笔记1-环境搭建以及HelloSDL。

第四步：打开MFC_SDLDlg.cpp文件，在程序中添加头文件

#include <SDL.h>

第五步：双击Button控件，转到鼠标点击响应程序。添加程序。程序如下：

void CMFC_SDLDlg::OnBnClickedButton1()

{

// TODO: 在此添加控件通知处理程序代码

//The window we'll be rendering to

SDL_Window* gWindow = NULL;

//The surface contained by the window

SDL_Surface* gScreenSurface = NULL;

//The image we will load and show on the screen

SDL_Surface* gHelloWorld = NULL;

//首先初始化

if(SDL_Init(SDL_INIT_VIDEO)<0)

{

printf( "Window could not be created! SDL_Error: %s\n", SDL_GetError() );

return ;

}

//创建窗口

gWindow=SDL_CreateWindowFrom( (void *)( GetDlgItem(IDC_STATIC)->GetSafeHwnd() ) );

if(gWindow==NULL)

{

printf( "Window could not be created! SDL_Error: %s\n", SDL_GetError() );

return ;

}

//Use this function to get the SDL surface associated with the window.

//获取窗口对应的surface

gScreenSurface=SDL_GetWindowSurface(gWindow);

//加载图片

gHelloWorld = SDL_LoadBMP("Hello_World.bmp");//加载图片

if( gHelloWorld == NULL )

{

printf( "Unable to load image %s! SDL Error: %s\n", "Hello_World.bmp", SDL_GetError() );

return ;

}

//Use this function to perform a fast surface copy to a destination surface.

//surface的快速复制

// SDL_Surface* src ,const SDL_Rect* srcrect , SDL_Surface* dst , SDL_Rect* dstrect

SDL_BlitSurface( gHelloWorld , NULL , gScreenSurface , NULL);

SDL_UpdateWindowSurface(gWindow);//更新显示copy the window surface to the screen

}

第六步：运行程序，点击“显示图片”按钮，现象如下：

从程序中可以看出，要将SDL窗口嵌入到MFC中很简单，只要将SDL原来创建窗口的函数：

SDL_Window* gWindow = SDL_CreateWindow("SHOW BMP",SDL_WINDOWPOS_UNDEFINED,SDL_WINDOWPOS_UNDEFINED,SCREEN_WIDTH,SCREEN_HEIGHT,SDL_WINDOW_SHOWN);

改成下面的函数即可：

SDL_Window* gWindow=SDL_CreateWindowFrom( (void *)( GetDlgItem(IDC_STATIC)->GetSafeHwnd() ) );

其中，IDC_STATIC为PictureControl的ID

ffmpeg Android上播放器IjkPlayer

ffmpeg Android上播放器IjkPlayer

ffmpeg-4.0.2版本中ffplay播放器在vs2013下的编译

原文地址

相信很多想要学习播放器开发的小伙伴都知道ffplay，但是却不知道如何在vs2013下去编译，虽然网上已经有了一些教程，但是都不完整，或者ffmpeg的版本太老，所以就有了今天这篇文章。

好了，废话少说，直接上干货。

第一步下载ffmpeg源码，下载地址http://ffmpeg.org/download.html，具体界面如下：

第2步，下载ffmpeg的二进制版本，有些小伙伴可能会问为什么还要下载二进制，直接编译源代码不可以吗，当然可以，如果你不怕麻烦，你怎么都可以，但是我教你的方法是简单有效的方法，要不要学，嘿嘿。

输入如下网址：https://ffmpeg.zeranoe.com/builds/

界面如下：

然后下载win32下的Shared和Dev两个版本，就可以，win64同理，所以，我们这里以win32为例。下载完成后，按照下面的方式重新组织你的ffmpeg文件，具体如下：

在我这里有两个版本，x86代表32位，把所有的头文件放入include，lib和exe文件放入lib目录，bin目录你们可以不要。

第3步下载SDL库，我们这里也是用最新的版本SDL2-2.0.8，输入网址：http://www.libsdl.org/download-2.0.php

具体界面如下：

我们下载32位windows版本就可以，然后分别按照include和lib目录组织好自己的文件。

第4步，我们开始建立一个vs2013控制台工程，如下：

点击完成，如下：

好了，现在我们已经创建了一个vs2013控制台工程，但是现在没有任何文件，现在我们开始为它添加需要的文件，具体如下：

1）将ffmpeg-4.0.2\ffmpeg-4.0.2\fftools下的三个文件拷贝到自己的工程，三个文件如下：

cmdutils.h

cmdutils.c

ffplay.c

2) 将ffmpeg-4.0.2\ffmpeg-4.0.2\compat\avisynth\avs下的config.h文件拷贝到自己的工程

工程目录文件如下：

将所有文件添加到项目中，具体如下：

右键项目名称，添加-现有项，然后选择我们拷贝的4个源文件，效果如下：

3）配置我们的工程中的include目录，lib目录

include目录添加两个新项

D:\ffmpeg\x86\include

D:\SDL2-2.0.8\include

lib目录同样添加两个新项

D:\ffmpeg\x86\lib

D:\SDL2-2.0.8\lib\x86

然后配置依赖项，添加lib如下：

swscale.lib

swresample.lib

postproc.lib

avutil.lib

avformat.lib

avfilter.lib

avdevice.lib

avcodec.lib

SDL2.lib

SDL2main.lib

好了现在配置完成，下面，我们开始编译。

4）编译项目，错误具体如下：

只需要注释掉这行代码，就可以，同时也要注释掉另外两行代码，具体如下：

//#include "compat/va_copy.h"

//#include "libavresample/avresample.h"

//#include "libavutil/libm.h"

5）再次编译，具体如下：

处理方法：

注释掉print_program_info和print_all_libs_info内部的所有代码，具体如下：

6）再次编译，具体如下：

处理方法：

注释掉print_buildconf内部所有的代码，具体如下：

7）再次编译，具体如下：

处理方法：

在C++预处理其中，添加 _CRT_SECURE_NO_WARNINGS，具体如下：

8）再次编译，具体如下：

处理方法：

屏蔽SDL检测，具体如下：

将SDL检测改为否，就可以。

9）再次编译，具体如下：

处理方法：

在config.h中添加如下代码：

#define FFMPEG_DATADIR "D:\\ffmpeg-4.0.2\\ffmpeg-4.0.2"

注意：

D:\\ffmpeg-4.0.2\\ffmpeg-4.0.2是下面的源码目录，不是编译好的ffmpeg目录，目录内容具体如下：

10) 再次编译，具体如下：

处理方法：

在cmdutils.c中添加如下代码：

#define snprintf _snprintf

11）再次编译，具体如下：

到此，编译已经完成，然后只需要将相应的ffmpeg和SDL的相关DLL拷贝到exe所在目录即可，具体如下：

12）测试ffplay-vs.exe

首先打开cmd，并进入到ffplay-vs.exe所在目录，具体如下：

运行程序如下:

ffplay-vs.exe D:\d.mp4

运行效果如下：

到此，全部完成，是不是很简单，各位小伙伴，自己动手试试。

使用ffmpeg合并视频

使用ffmpeg合并视频

然后在视频文件所在目录下新建一个文件filelist.txt，内容如下：

file '1.mp4'

file '2.mp4'

file '3.mp4'

file '4.mp4'

file '5.mp4'

file '6.mp4'

file '7.mp4'

file '8.mp4'

file '9.mp4'

file '10.mp4'

file '11.mp4'

file '12.mp4'

file '13.mp4'

file '14.mp4'

file '15.mp4'

file '16.mp4'

在命令行执行如下命令：

ffmpeg -f concat -i filelist.txt -c copy output.mp4

然后，一个合并好的 output.mp4 文件就生成了！

ffmpeg合并视频的方法有三种。国内大多数仅介绍了其中之一。于是觉得有必要翻译一下。其实在ffmpeg的 FAQ文档中有比较详细的说明。

使用concat协议进行视频文件的合并
这种方式的适用场景是：视频容器是MPEG-1, MPEG-2 PS或DV等可以直接进行合并的。换句话说，其实可以直接用cat或者copy之类的命令来对视频直接进行合并。很多文章介绍了这种方法，但适用性却没有提及。这并不是一个通用的方法。典型的命令示例如下：
```
使用concat demuxer进行视频文件的合并
```
这种合并方式的适用场景是：当容器格式不支持文件层次的合并，而又不想（不需要）进行再编码的操作的时候。这种方式对源视频同样有同格式同性质的要求。其详细语法参见这里。典型的命令示例如下：
```
其中，Cam01.txt 为包含了输入文件的描述文件。
```

使用concat滤镜（filter）进行视频文件的合并：

当需要进行任意程度的重新编解码时，官方推荐使用的方法即是用concat滤镜来进行视频文件的合并处理。详细说明参见这里。典型命令示例如下：

这段命令目的是将三段双语格式的视频合并至最终的一段视频(output.mkv)。参数n=3说明待合成的视频有三段，v=1说明视频流为一，a=2说明音频流为二。 -map参数的详细说明可以从Filtergraph文档中找到。

FFMpeg无损合并视频的多种方法

http://blog.csdn.net/doublefi123/article/details/47276739

众所周知，从某些视频网站下载的视频是分段的。比如新浪视频每隔6分钟分段，俗称“6分钟诅咒”。

现在的任务是将这些视频片段合并起来，并且尽量无损。

方法一：FFmpeg concat 协议

对于 MPEG 格式的视频，可以直接连接：

ffmpeg -i "concat:input1.mpg|input2.mpg|input3.mpg" -c copy output.mpg

对于非 MPEG 格式容器，但是是 MPEG 编码器（H.264、DivX、XviD、MPEG4、MPEG2、AAC、MP2、MP3 等），可以包装进 TS 格式的容器再合并。在新浪视频，有很多视频使用 H.264 编码器，可以采用这个方法

ffmpeg -i input1.flv -c copy -bsf:v h264_mp4toannexb -f mpegts input1.ts
ffmpeg -i input2.flv -c copy -bsf:v h264_mp4toannexb -f mpegts input2.ts
ffmpeg -i input3.flv -c copy -bsf:v h264_mp4toannexb -f mpegts input3.ts
ffmpeg -i "concat:input1.ts|input2.ts|input3.ts" -c copy -bsf:a aac_adtstoasc -movflags +faststart output.mp4

保存 QuickTime/MP4 格式容器的时候，建议加上 -movflags +faststart。这样分享文件给别人的时候可以边下边看。

方法二：FFmpeg concat 分离器

这种方法成功率很高，也是最好的，但是需要 FFmpeg 1.1 以上版本。先创建一个文本文件filelist.txt：

file 'input1.mkv'
file 'input2.mkv'
file 'input3.mkv'

然后：

ffmpeg -f concat -i filelist.txt -c copy output.mkv

注意：使用 FFmpeg concat 分离器时，如果文件名有奇怪的字符，要在 filelist.txt 中转义。

方法三：Mencoder 连接文件并重建索引

这种方法只对很少的视频格式生效。幸运的是，新浪视频使用的 FLV 格式是可以这样连接的。对于没有使用 MPEG 编码器的视频（如 FLV1 编码器），可以尝试这种方法，或许能够成功。

mencoder -forceidx -of lavf -oac copy -ovc copy -o output.flv input1.flv input2.flv input3.flv

方法四：使用 FFmpeg concat 过滤器重新编码（有损）

语法有点复杂，但是其实不难。这个方法可以合并不同编码器的视频片段，也可以作为其他方法失效的后备措施。

ffmpeg -i input1.mp4 -i input2.webm -i input3.avi -filter_complex '[0:0] [0:1] [1:0] [1:1] [2:0] [2:1] concat=n=3:v=1:a=1 [v] [a]' -map '[v]' -map '[a]' <编码器选项> output.mkv

如你所见，上面的命令合并了三种不同格式的文件，FFmpeg concat 过滤器会重新编码它们。注意这是有损压缩。

[0:0] [0:1] [1:0] [1:1] [2:0] [2:1] 分别表示第一个输入文件的视频、音频、第二个输入文件的视频、音频、第三个输入文件的视频、音频。concat=n=3:v=1:a=1 表示有三个输入文件，输出一条视频流和一条音频流。[v] [a] 就是得到的视频流和音频流的名字，注意在 bash 等 shell 中需要用引号，防止通配符扩展。

提示

以上三种方法，在可能的情况下，最好使用第二种。第一种次之，第三种更次。第四种是后备方案，尽量避免。
规格不同的视频合并后可能会有无法预测的结果。
有些媒体需要先分离视频和音频，合并完成后再封装回去。
对于 Packed B-Frames 的视频，如果封装成 MKV 格式的时候提示 Can't write packet with unknown timestamp，尝试在 FFmpeg 命令的 ffmpeg 后面加上 -fflags +genpts

ffmpeg画中画效果

ffmpeg画中画效果

1. 画中画效果overlay滤镜

　overlay的使用语法：

　　　　ffmpeg -i input1 -i input2 -filter_complex overlay=x:y output

　　　　这里不使用-vf简单滤镜，而是使用-filter_complex复合滤镜，因为是有多个输入源。

　　　　但是如果通过链接标签，可以t结合movie视频源使用-vf滤镜，比如：ffmpeg -i input1 -vf movie=input2[logo];[in][logo]overlay=x:y output

2. 某个画面角落显示logo

　　左上角：ffmpeg -i pair.mp4 -i logo.png -filter_complex overlay pair1.mp4

　　右上角：ffmpeg -i pair.mp4 -i logo.png -filter_complex overlay=W-w pair2.mp4

　　左下角：ffmpeg -i pair.mp4 -i logo.png -filter_complex overlay=H-h pair3.mp4

　　右下角：ffmpeg -i pair.mp4 -i logo.png -filter_complex overlay=W-w:H-h pair4.mp4

3. 指定时刻显示logo(使用-itsoffset选项)

4.添加时间

　　ffmpeg -f lavfi -i testsrc -vf crop=61:52:224:94 -t 30 timer.ogg　　//30秒

　　ffmpeg -i test.mp4 -i timer.ogg -filter_complex overlay=451 output.mp4　　//451是test.mp4视频的宽512减去61得到的，效果是时间在视频的右上角显示

　　ffmpeg -i test.mp4 -vf movie=timer.ogg,scale=15:14[tm];[in][tm]overlay=248:371 output.pm4　　//将timer缩放到15:14，然后添加到视频test.mp4的宽248高371的位置，[in]是自带的输入标签，[tm]是自己打的标签

播放画中画

ffplay -i g:\output3.mp4 -vf "movie=output3.mp4,scale=100x50[subm];[in][subm]overlay=x=20:y=30:eof_action=1[out]" -x 640 -y 480

注意次要视频不能带路径

ffmpeg 制作gif

制作gif

结合前面讲到的截取和压缩，将输出文件的后缀改为gif就可以得到动态图

ffmpeg -ss 30 -t 5 -i input.mp4 -r 10 -vf scale=-1:144 -y output.gif

-r指定帧率，原始的帧率是25，降低帧率能减小gif图片的大小。

但是这种方式的效果很差，有一种粗糙的布料的感觉。原因在于gif限制只能包含256种颜色，而原始视频可能包含数以百万的颜色，ffmpeg默认会使用一种通用的调色板(palettep)，因此导致颜色失真。2015年，ffmpeg通过引入palettegen和paletteuse两个滤镜来改进这个问题，它通过扫描整个视频，输出一个最佳的调色板，然后再转换成gif的过程中应用这个调色板从而避免颜色失真。

下面的命令从input.mp4的第30秒开始截取5秒，生成高144像素的gif动态图：

palette="/tmp/palette.png"

filters="fps=10,scale=-1:144:flags=lanczos"

ffmpeg -ss 30 -t 5 -i input.mp4 -vf "$filters,palettegen" -y $palette

ffmpeg -ss 30 -t 5 -i input.mp4 -i $palette -filter_complex "$filters [x]; [x][1:v] paletteuse" -y output.gif

与前一个输出相比，质量提升了很多。

另一个有待研究的难题是如何控制输出gif的大小。在不影响画质的前提下，我们希望体积越小越好。比如网上有的gif图很清晰，却不超过1M。而一段500K的视频文件，使用上面的方法转成gif后输出的gif却有1.6M。

ffmpeg -ss 30 -t 5 -i 1621688550.mp4 -vf "fps=10,scale=-1:144:flags=lanczos,palettegen" -y palette.png

ffmpeg -ss 30 -t 5 -i 1621688550.mp4 -i palette.png -filter_complex "fps=10,scale=-1:144:flags=lanczos[x]; [x][1:v] paletteuse" -y output.gif

ffplay 命令行

ffplay命令-主要选项1

-x width 强制显示宽带。
-y height 强制显示高度。
-video_size size 帧尺寸设置显示帧存储(WxH格式)，仅适用于类似原始YUV等没有包含帧大小(WxH)的视频。

-pixel_format format 格式设置像素格式。

-fs 以全屏模式启动。

-an 禁用音频（不播放声音）

-vn 禁用视频（不播放视频）

-sn 禁用字幕（不显示字幕）

-ss pos 根据设置的秒进行定位拖动，注意时间单位：比如'55' 55 seconds, '12:03:45' ,12 hours, 03 minutes and 45 seconds, '23.189' 23.189 second

-t duration 设置播放视频/音频长度，时间单位如 -ss选项

ffplay -pixel_format yuv420p -video_size 320x240 -framerate 5 yuv420p_320x240.yuv

ffplay -x 720 test_1280x720.mp4 # width 强制显示宽带 720

ffplay -fs test_1280x720.mp4 # 以全屏模式启动。

ffplay -volume 1 -an test_1280x720.mp4 # 禁用音频（不播放声音）

ffplay -volume 1 -vn test_1280x720.mp4 # 禁用视频（不播放视频）

ffplay -volume 50 -ss '60' test_1280x720.mp4 # 60second 开始播放

ffplay命令-主要选项2

-bytes 按字节进行定位拖动（0=off 1=on -1=auto）。
-seek_interval interval 自定义左/右键定位拖动间隔（以秒为单位），默认值为10秒（代码没有看到实现）
-nodisp 关闭图形化显示窗口，视频将不显示
-noborder 无边框窗口
-volume vol 设置起始音量。音量范围[0 ~100]
-f fmt 强制使用设置的格式进行解析。比如-f s16le
-window_title title 设置窗口标题（默认为输入文件名）
-loop number 设置播放循环次数
-showmode mode 设置显示模式，可用的模式值：0 显示视频，1 显示音频波形，2 显示音频频谱。缺省为0，如果视频不存在则自动选择2
-vf filtergraph 设置视频滤镜
-af filtergraph 设置音频滤镜

ffplay -volume 10 -window_title hello test_1280x720.mp4

ffplay -volume 10 -window_title hello -showmode 1 test_1280x720.mp4 #-showmode mode 设置显示模式

ffplay命令-高级选项-1

-stats 打印多个回放统计信息，包括显示流持续时间，编解码器参数，流中的当前位置，以及音频/视频同步差值。默认情况下处于启用状态，要显式禁用它则需要指定-nostats。。
-fast 非标准化规范的多媒体兼容优化。
-genpts 生成pts。
-sync type 同步类型将主时钟设置为audio（type=audio），video（type=video）或external（type=ext），默认是audio为主时钟。
-ast audio_stream_specifier 指定音频流索引，比如-ast 3，播放流索引为3的音频流
-vst video_stream_specifier指定视频流索引，比如-vst 4，播放流索引为4的视频流
-sst subtitle_stream_specifier 指定字幕流索引，比如-sst 5，播放流索引为5的字幕流
-autoexit 视频播放完毕后退出。

ffplay -volume 5 -t 5 -autoexit test_1280x720.mp4 # -t 播放5秒 -autoexit 播放完毕自动退出

ffplay命令-高级选项-1

-exitonkeydown 键盘按下任何键退出播放
-exitonmousedown 鼠标按下任何键退出播放
-codec:media_specifier codec_name 强制使用设置的多媒体解码器，media_specifier可用值为a（音频）， v（视频）和s字幕。比如-codec:v h264_qsv 强制视频采用h264_qsv解码
-acodec codec_name 强制使用设置的音频解码器进行音频解码
-vcodec codec_name 强制使用设置的视频解码器进行视频解码
-scodec codec_name 强制使用设置的字幕解码器进行字幕解码
-autorotate 根据文件元数据自动旋转视频。值为0或1 ，默认为1。
-framedrop 如果视频不同步则丢弃视频帧。当主时钟非视频时钟时默认开启。若需禁用则使用 -noframedrop
-infbuf 不限制输入缓冲区大小。尽可能快地从输入中读取尽可能多的数据。播放实时流时默认启用，如果未及时读取数据，则可能会丢弃数据。此选项将不限制缓冲区的大小。若需禁用则使用-noinfbuf

ffplay -volume 5 -codec:v h264 test_1280x720.mp4 # -vcodec 强制使用设置的视频解码器进行视频解码

ffplay -volume 5 -vcodec h264 test_1280x720.mp4

ffplay命令播放

ffplay -window_title "test time" -ss 2 -t 10 -autoexit test.mp4

播放网络流

ffplay -window_title "rtmp stream" rtmp://202.69.69.180:443/webcast/bshdlive-pc

ffplay rtmp://r.ossrs.net/live/livestream

ffplay rtmp://58.200.131.2:1935/livetv/hunantv # 湖南卫视

强制解码器

ffplay -vcodec mpeg4 test.mp4 # mpeg4解码器

ffplay -vcodec h264 test.mp4 # h264解码器

禁用音频或视频

ffplay test.mp4 -an #禁用音频

ffplay test.mp4 -vn #禁用视频

播放YUV数据

ffplay -pixel_format yuv420p -video_size 320x240 -framerate 5 yuv420p_320x240.yuv

ffplay -pixel_format yuv420p -video_size 320x240 -framerate 25 yuv420p_320x240.yuv

-pixel_format 帧尺寸设置显示帧存储(WxH格式)

-video_size YUV数据的分辨率大小设置

-framerate 播放的帧速率

播放RGB数据

ffplay -pixel_format rgb24 -video_size 320x240 -i rgb24_320x240.rgb

ffplay -pixel_format rgb24 -video_size 320x240 -framerate 5 -i rgb24_320x240.rgb

播放PCM数据

ffplay -ar 48000 -ac 2 -f f32le 48000_2_f32le.pcm

-ar set audio sampling rate (in Hz) (from 0 to INT_MAX) (default 0)

-ac set number of audio channels (from 0 to INT_MAX) (default 0)

ffplay简单过滤器

ffplay -h filter=transpose

视频旋转

ffplay -i test.mp4 -vf transpose=1

ffplay -volume 5 -i test.mp4 -vf transpose=2

视频反转

ffplay -volume 5 test.mp4 -vf hflip

ffplay -volume 5 test.mp4 -vf vflip

视频旋转和反转

ffplay test.mp4 -vf hflip,transpose=1

音频变速播放

ffplay -i test.mp4 -af atempo=2

视频变速播放

ffplay -i test.mp4 -vf setpts=PTS/2

音视频同时变速

ffplay -i test.mp4 -vf setpts=PTS/2 -af atempo=2

ffplay 播放无声

建立批处理文件直接运行批处理文件

set SDL_AUDIODRIVER=directsound

ffplay -i g:\1621688550.mp4

ffmpeg中vf与filter_complex的区别

ffmpeg中vf与filter_complex有什么区别

当我们通过ffmpeg使用简单的滤镜的时候，可以通过-vf与-af来实现滤镜效果：

当我们在处理复杂的滤镜场景的是，就需要使用-filter_complex参数来实现复杂的特效场景：

其中 -lavfi 与 -filter_complex 效果是一样的

1. FFmpeg filter简介

FFmpeg filter提供了很多音视频特效处理的功能，比如视频缩放、截取、翻转、叠加等。

其中定义了很多的filter，例如以下常用的一些filter。

scale：视频/图像的缩放
overlay：视频/图像的叠加
crop：视频/图像的裁剪
trim：截取视频的片段
rotate：以任意角度旋转视频

支持的filter的列表可以通过以下命令获得。

ffmpeg -filters

以下是filter的一个简单的应用示例，对视频的宽和高减半。

ffmpeg -i input -vf scale=iw/2:ih/2 output

2. filter的使用方法

学习filter的使用，先需要了解一下filter的语法。
FFmpeg中filter包含三个层次，filter->filterchain->filtergraph。
具体参考下图：

说明：

第一层是 filter 的语法。
第二层是 filterchain的语法。
第三层是 filtergraph的语法。

filtergraph可以用文本形式表示，可以作为ffmpeg中的-filter/-vf/-af和-filter_complex选项以及ffplay中的-vf/-af和libavfilter/avfilter.h中定义的avfilter_graph_parse_ptr()函数的参数。

为了说明可能的情况，我们考虑下面的例子“把视频的上部分镜像到下半部分”。
处理流程如下：

使用split filter将输入流分割为两个流[main]和[temp]。
其中一个流[temp]通过crop filter把下半部分裁剪掉。
步骤2中的输出再经过vflip filter对视频进行和垂直翻转，输出[flip]。
把步骤3中输出[flip]叠加到[main]的下半部分。

可以用以下的命令来实现这个流程。

ffmpeg -i INPUT -vf "split [main][tmp]; [tmp] crop=iw:ih/2:0:0, vflip [flip]; [main][flip] overlay=0:H/2" OUTPUT

处理结果如下图所示。

使用':'字符分隔的一个“键=值”对列表。如下所示。

ffmpeg -i input -vf scale=w=iw/2:h=ih/2 output

2.使用':'字符分割的“值”的列表。在这种情况下，键按照声明的顺序被假定为选项名。例如，scale filter的前两个选项分别是w和h，当参数列表为“iw/2:ih/2”时，iw/2的值赋给w，ih/2的值赋给h。如下所示。

3.使用':' 字符分隔混合“值”和“键=值”对的列表。“值”必须位于“键=值”对之前，并遵循与前一点相同的约束顺序。之后的“键=值”对的顺序不受约束。如下所示

查询指定的filter

ffmpeg -h filter=filter_name

以下是rotate filter的使用方式

可以看出它支持slice threading。
Inputs下面定义的是输入。可以看出rotate filter有一个输入，格式为Video。
Outputs下面定义的是输出。可以看出rotate filter有有一个输出，格式为video。
AVOptions下面定义了支持的参数，后面有默认值描述。为了简化输入参数，对长的参数名提供一个简化的名称。比如rotate filter中，“angle”的简化名称是“a”。

代码调用的例子

头文件
extern "C" {
#include "libavutil/mem.h"
#include "libavfilter/avfiltergraph.h"
#include "libavfilter/buffersink.h"
#include "libavfilter/buffersrc.h"
#include "libavutil/avutil.h"
#include "libavutil/imgutils.h"
#include "libavdevice/avdevice.h"
};

注册过滤器
avfilter_register_all();
/*
对pSrcFrame画框，最终图像数据保存在pDestFrame
*/
void VideoDecodec::DrawRectangleToFrame(AVFrame* pSrcFrame, AVFrame* pDestFrame, int x, int y, int w, int h)
{
AVFilterGraph* pFilterGraph = avfilter_graph_alloc();
char szErrMsg[128] = { 0 };
char szArgs[512] = { 0 };
char szFilterDescr[256] = { 0 };
sprintf(szFilterDescr, "drawbox=x=%d:y=%d:w=%d:h=%d:color=yellow@1", x, y, w, h);
AVFilter* pBufferSrc = avfilter_get_by_name("buffer");
AVFilter* pBufferSink = avfilter_get_by_name("buffersink");
AVFilterInOut* pFilterOut = avfilter_inout_alloc();
AVFilterInOut* pFilterIn = avfilter_inout_alloc();
enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_NONE };
AVBufferSinkParams* pBufferSinkParams;

//最后的几个参数没有使用真实的视频格式参数
snprintf(szArgs, sizeof(szArgs), "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
pSrcFrame->width, pSrcFrame->height, pSrcFrame->format, 1, 1, 1, 1);

int ret = 0;
AVFilterContext* pBufferSinkContext = NULL;
AVFilterContext* pBufferSrcContext = NULL;
if ((ret = avfilter_graph_create_filter(&pBufferSrcContext, pBufferSrc, "in", szArgs, NULL, pFilterGraph)) < 0)
{
  sprintf(szErrMsg, "Cannot graph create filter, error:%s\n", av_err2str(ret));
  return;
}
pBufferSinkParams = av_buffersink_params_alloc();
pBufferSinkParams->pixel_fmts = pix_fmts;
if ((ret = avfilter_graph_create_filter(&pBufferSinkContext, pBufferSink, "out", NULL, pBufferSinkParams, pFilterGraph)) < 0)
{
  sprintf(szErrMsg, "Cannot graph create filter, error:%s\n", av_err2str(ret));
  return;
}

pFilterOut->name = av_strdup("in");
pFilterOut->filter_ctx = pBufferSrcContext;
pFilterOut->pad_idx = 0;
pFilterOut->next = NULL;

pFilterIn->name = av_strdup("out");
pFilterIn->filter_ctx = pBufferSinkContext;
pFilterIn->pad_idx = 0;
pFilterIn->next = NULL;

do
{
  if ((ret = avfilter_graph_parse_ptr(pFilterGraph, szFilterDescr, &pFilterIn, &pFilterOut, NULL)) < 0)
  {
   sprintf(szErrMsg, "Cannot graph parse ptr, error:%s\n", av_err2str(ret));
   break;
  }

  if ((ret = avfilter_graph_config(pFilterGraph, NULL)) < 0)
  {
   sprintf(szErrMsg, "Cannot graph config filter, error:%s\n", av_err2str(ret));
   break;
  }

  if ((ret = av_buffersrc_add_frame(pBufferSrcContext, pSrcFrame)) < 0)
  {
   sprintf(szErrMsg, "Cannot add frame from buffersrc, error:%s\n", av_err2str(ret));
   break;
  }
  //pDestFrame帧的长宽必须指定
  //图像格式转换之后，pSrcFrame中的data数据被置为NULL,pSrcFrame结构不可用
  if ((ret = av_buffersink_get_frame(pBufferSinkContext, pDestFrame)) < 0)
  {
   sprintf(szErrMsg, "Cannot get frame frome buffersink, error:%s\n", av_err2str(ret));
   break;
  }
} while (0);

avfilter_inout_free(&pFilterIn);
avfilter_inout_free(&pFilterOut);
av_free(pBufferSinkParams);
avfilter_graph_free(&pFilterGraph);
}

注意

1.调用avfilter_get_by_name("ffbuffersink")时在新版本3.4的ffmpeg要修改为avfilter_get_by_name("buffersink");否则返回指针为空，调用avfilter_graph_create_filter返回-12

ffmpeg学习十三：转码

转码指的是把一种音视频文件的格式（封装格式+编码格式）转换为另一种音视频文件的格式。其过程如图所示：

从图中可以得知，转码涉及了解封装，解编码，编码，再封装的过程。这个过程基本涵盖了之前文章的所有内容。对于一个视频文件而言，要把它转为另一种格式，意味着首先要改变它的封装格式，其次，视频文件可能包含多个流，比如视频流，音频流，字幕流等都需要重新编码。回顾之前的文章，我们单独分析了解封装，封装，编码音频，编码视频，解码视频的过程，唯独没有做解码音频的单独分析，但只要对解码视频比较了解，解码音频也很容易理解。因此，这篇文章分析的转码是之前所有文章的学习的知识的一次综合运用。

ffmpeg已经为我们提供了转码的例程，它是很好的学习教材。其路径为：doc/examples/transcoding.c

我下载的ffmpeg的版本是2.7版本，这个版本的这个例程能顺利编译，但是执行这个程序的时候，会报如下错误：

[libx264 @ 00021bb0]broken ffmpeg default settings detected

[libx264 @ 00021bb0]use an encoding preset (vpre)

解决方法：

参考ffmpeg x264编译与使用介绍这篇博客，

在avcodec_open函数之间增加如下几个AVCodecContext 的初始化：

/default settings for x264/

ctx->me_range = 16;

ctx->max_qdiff = 4;

ctx->qmin = 10;

ctx->qmax = 51;

ctx->qcompress = 0.6;

也就是在open_input_file和open_output_file函数的avcodec_open2函数之前，为AVCodecContext的实例做如上的附加配置，这样本人亲测可以解决这个问题。修改过的完整的代码如下：

#include <libavcodec/avcodec.h>

#include <libavformat/avformat.h>

#include <libavfilter/avfiltergraph.h>

#include <libavfilter/buffersink.h>

#include <libavfilter/buffersrc.h>

#include <libavutil/opt.h>

#include <libavutil/pixdesc.h>

static AVFormatContext *ifmt_ctx;

static AVFormatContext *ofmt_ctx;

typedef struct FilteringContext {

AVFilterContext *buffersink_ctx;

AVFilterContext *buffersrc_ctx;

AVFilterGraph *filter_graph;

} FilteringContext;

static FilteringContext *filter_ctx;

static int open_input_file(const char *filename)

{

int ret;

unsigned int i;

ifmt_ctx = NULL;

if ((ret = avformat_open_input(&ifmt_ctx, filename, NULL, NULL)) < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");

return ret;

}

if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");

return ret;

}

for (i = 0; i < ifmt_ctx->nb_streams; i++) {

AVStream *stream;

AVCodecContext *codec_ctx;

stream = ifmt_ctx->streams[i];

codec_ctx = stream->codec;

/* Reencode video & audio and remux subtitles etc. */

if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO

|| codec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {

/* Open decoder */

ret = avcodec_open2(codec_ctx,

avcodec_find_decoder(codec_ctx->codec_id), NULL);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Failed to open decoder for stream #%u\n", i);

return ret;

}

av_dump_format(ifmt_ctx, 0, filename, 0);

return 0;

}

static int open_output_file(const char *filename)

{

AVStream *out_stream;

AVStream *in_stream;

AVCodecContext *dec_ctx, *enc_ctx;

AVCodec *encoder;

int ret;

unsigned int i;

ofmt_ctx = NULL;

avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, filename);

if (!ofmt_ctx) {

av_log(NULL, AV_LOG_ERROR, "Could not create output context\n");

return AVERROR_UNKNOWN;

}

for (i = 0; i < ifmt_ctx->nb_streams; i++) {

out_stream = avformat_new_stream(ofmt_ctx, NULL);

if (!out_stream) {

av_log(NULL, AV_LOG_ERROR, "Failed allocating output stream\n");

return AVERROR_UNKNOWN;

}

in_stream = ifmt_ctx->streams[i];

dec_ctx = in_stream->codec;

enc_ctx = out_stream->codec;

if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO

|| dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {

/* in this example, we choose transcoding to same codec */

encoder = avcodec_find_encoder(dec_ctx->codec_id);

if (!encoder) {

av_log(NULL, AV_LOG_FATAL, "Necessary encoder not found\n");

return AVERROR_INVALIDDATA;

}

/* In this example, we transcode to same properties (picture size,

* sample rate etc.). These properties can be changed for output

* streams easily using filters */

if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {

enc_ctx->height = dec_ctx->height;

enc_ctx->width = dec_ctx->width;

enc_ctx->sample_aspect_ratio = dec_ctx->sample_aspect_ratio;

/* take first format from list of supported formats */

if (encoder->pix_fmts)

enc_ctx->pix_fmt = encoder->pix_fmts[0];

else

enc_ctx->pix_fmt = dec_ctx->pix_fmt;

/* video time_base can be set to whatever is handy and supported by encoder */

enc_ctx->time_base = dec_ctx->time_base;

} else {

enc_ctx->sample_rate = dec_ctx->sample_rate;

enc_ctx->channel_layout = dec_ctx->channel_layout;

enc_ctx->channels = av_get_channel_layout_nb_channels(enc_ctx->channel_layout);

/* take first format from list of supported formats */

enc_ctx->sample_fmt = encoder->sample_fmts[0];

enc_ctx->time_base = (AVRational){1, enc_ctx->sample_rate};

}

/* Third parameter can be used to pass settings to encoder */

ret = avcodec_open2(enc_ctx, encoder, NULL);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot open video encoder for stream #%u\n", i);

return ret;

}

} else if (dec_ctx->codec_type == AVMEDIA_TYPE_UNKNOWN) {

av_log(NULL, AV_LOG_FATAL, "Elementary stream #%d is of unknown type, cannot proceed\n", i);

return AVERROR_INVALIDDATA;

} else {

/* if this stream must be remuxed */

ret = avcodec_copy_context(ofmt_ctx->streams[i]->codec,

ifmt_ctx->streams[i]->codec);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Copying stream context failed\n");

return ret;

}

if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)

enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

}

av_dump_format(ofmt_ctx, 0, filename, 1);

if (!(ofmt_ctx->oformat->flags & AVFMT_NOFILE)) {

ret = avio_open(&ofmt_ctx->pb, filename, AVIO_FLAG_WRITE);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Could not open output file '%s'", filename);

return ret;

}

/* init muxer, write output file header */

ret = avformat_write_header(ofmt_ctx, NULL);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Error occurred when opening output file\n");

return ret;

}

return 0;

}

static int init_filter(FilteringContext* fctx, AVCodecContext *dec_ctx,

AVCodecContext *enc_ctx, const char *filter_spec)

{

char args[512];

int ret = 0;

AVFilter *buffersrc = NULL;

AVFilter *buffersink = NULL;

AVFilterContext *buffersrc_ctx = NULL;

AVFilterContext *buffersink_ctx = NULL;

AVFilterInOut *outputs = avfilter_inout_alloc();

AVFilterInOut *inputs = avfilter_inout_alloc();

AVFilterGraph *filter_graph = avfilter_graph_alloc();

if (!outputs || !inputs || !filter_graph) {

ret = AVERROR(ENOMEM);

goto end;

}

if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {

buffersrc = avfilter_get_by_name("buffer");

buffersink = avfilter_get_by_name("buffersink");

if (!buffersrc || !buffersink) {

av_log(NULL, AV_LOG_ERROR, "filtering source or sink element not found\n");

ret = AVERROR_UNKNOWN;

goto end;

}

snprintf(args, sizeof(args),

"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",

dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,

dec_ctx->time_base.num, dec_ctx->time_base.den,

dec_ctx->sample_aspect_ratio.num,

dec_ctx->sample_aspect_ratio.den);

ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",

args, NULL, filter_graph);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");

goto end;

}

ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",

NULL, NULL, filter_graph);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");

goto end;

}

ret = av_opt_set_bin(buffersink_ctx, "pix_fmts",

(uint8_t*)&enc_ctx->pix_fmt, sizeof(enc_ctx->pix_fmt),

AV_OPT_SEARCH_CHILDREN);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot set output pixel format\n");

goto end;

}

} else if (dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {

buffersrc = avfilter_get_by_name("abuffer");

buffersink = avfilter_get_by_name("abuffersink");

if (!buffersrc || !buffersink) {

av_log(NULL, AV_LOG_ERROR, "filtering source or sink element not found\n");

ret = AVERROR_UNKNOWN;

goto end;

}

if (!dec_ctx->channel_layout)

dec_ctx->channel_layout =

av_get_default_channel_layout(dec_ctx->channels);

snprintf(args, sizeof(args),

"time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%"PRIx64,

dec_ctx->time_base.num, dec_ctx->time_base.den, dec_ctx->sample_rate,

av_get_sample_fmt_name(dec_ctx->sample_fmt),

dec_ctx->channel_layout);

ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",

args, NULL, filter_graph);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer source\n");

goto end;

}

ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",

NULL, NULL, filter_graph);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer sink\n");

goto end;

}

ret = av_opt_set_bin(buffersink_ctx, "sample_fmts",

(uint8_t*)&enc_ctx->sample_fmt, sizeof(enc_ctx->sample_fmt),

AV_OPT_SEARCH_CHILDREN);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot set output sample format\n");

goto end;

}

ret = av_opt_set_bin(buffersink_ctx, "channel_layouts",

(uint8_t*)&enc_ctx->channel_layout,

sizeof(enc_ctx->channel_layout), AV_OPT_SEARCH_CHILDREN);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot set output channel layout\n");

goto end;

}

ret = av_opt_set_bin(buffersink_ctx, "sample_rates",

(uint8_t*)&enc_ctx->sample_rate, sizeof(enc_ctx->sample_rate),

AV_OPT_SEARCH_CHILDREN);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot set output sample rate\n");

goto end;

}

} else {

ret = AVERROR_UNKNOWN;

goto end;

}

/* Endpoints for the filter graph. */

outputs->name = av_strdup("in");

outputs->filter_ctx = buffersrc_ctx;

outputs->pad_idx = 0;

outputs->next = NULL;

inputs->name = av_strdup("out");

inputs->filter_ctx = buffersink_ctx;

inputs->pad_idx = 0;

inputs->next = NULL;

if (!outputs->name || !inputs->name) {

ret = AVERROR(ENOMEM);

goto end;

}

if ((ret = avfilter_graph_parse_ptr(filter_graph, filter_spec,

&inputs, &outputs, NULL)) < 0)

goto end;

if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)

goto end;

/* Fill FilteringContext */

fctx->buffersrc_ctx = buffersrc_ctx;

fctx->buffersink_ctx = buffersink_ctx;

fctx->filter_graph = filter_graph;

end:

avfilter_inout_free(&inputs);

avfilter_inout_free(&outputs);

return ret;

}

static int init_filters(void)

{

const char *filter_spec;

unsigned int i;

int ret;

filter_ctx = av_malloc_array(ifmt_ctx->nb_streams, sizeof(*filter_ctx));

if (!filter_ctx)

return AVERROR(ENOMEM);

for (i = 0; i < ifmt_ctx->nb_streams; i++) {

filter_ctx[i].buffersrc_ctx = NULL;

filter_ctx[i].buffersink_ctx = NULL;

filter_ctx[i].filter_graph = NULL;

if (!(ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO

|| ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO))

continue;

if (ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)

filter_spec = "null"; /* passthrough (dummy) filter for video */

else

filter_spec = "anull"; /* passthrough (dummy) filter for audio */

ret = init_filter(&filter_ctx[i], ifmt_ctx->streams[i]->codec,

ofmt_ctx->streams[i]->codec, filter_spec);

if (ret)

return ret;

}

return 0;

}

static int encode_write_frame(AVFrame *filt_frame, unsigned int stream_index, int *got_frame) {

int ret;

int got_frame_local;

AVPacket enc_pkt;

int (*enc_func)(AVCodecContext *, AVPacket *, const AVFrame *, int *) =

(ifmt_ctx->streams[stream_index]->codec->codec_type ==

AVMEDIA_TYPE_VIDEO) ? avcodec_encode_video2 : avcodec_encode_audio2;

if (!got_frame)

got_frame = &got_frame_local;

av_log(NULL, AV_LOG_INFO, "Encoding frame\n");

/* encode filtered frame */

enc_pkt.data = NULL;

enc_pkt.size = 0;

av_init_packet(&enc_pkt);

ret = enc_func(ofmt_ctx->streams[stream_index]->codec, &enc_pkt,

filt_frame, got_frame);

av_frame_free(&filt_frame);

if (ret < 0)

return ret;

if (!(*got_frame))

return 0;

/* prepare packet for muxing */

enc_pkt.stream_index = stream_index;

av_packet_rescale_ts(&enc_pkt,

ofmt_ctx->streams[stream_index]->codec->time_base,

ofmt_ctx->streams[stream_index]->time_base);

av_log(NULL, AV_LOG_DEBUG, "Muxing frame\n");

/* mux encoded frame */

ret = av_interleaved_write_frame(ofmt_ctx, &enc_pkt);

return ret;

}

static int filter_encode_write_frame(AVFrame *frame, unsigned int stream_index)

{

int ret;

AVFrame *filt_frame;

av_log(NULL, AV_LOG_INFO, "Pushing decoded frame to filters\n");

/* push the decoded frame into the filtergraph */

ret = av_buffersrc_add_frame_flags(filter_ctx[stream_index].buffersrc_ctx,

frame, 0);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Error while feeding the filtergraph\n");

return ret;

}

/* pull filtered frames from the filtergraph */

while (1) {

filt_frame = av_frame_alloc();

if (!filt_frame) {

ret = AVERROR(ENOMEM);

break;

}

av_log(NULL, AV_LOG_INFO, "Pulling filtered frame from filters\n");

ret = av_buffersink_get_frame(filter_ctx[stream_index].buffersink_ctx,

filt_frame);

if (ret < 0) {

/* if no more frames for output - returns AVERROR(EAGAIN)

* if flushed and no more frames for output - returns AVERROR_EOF

* rewrite retcode to 0 to show it as normal procedure completion

if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)

ret = 0;

av_frame_free(&filt_frame);

break;

}

filt_frame->pict_type = AV_PICTURE_TYPE_NONE;

ret = encode_write_frame(filt_frame, stream_index, NULL);

if (ret < 0)

break;

}

return ret;

}

static int flush_encoder(unsigned int stream_index)

{

int ret;

int got_frame;

if (!(ofmt_ctx->streams[stream_index]->codec->codec->capabilities &

AV_CODEC_CAP_DELAY))

return 0;

while (1) {

av_log(NULL, AV_LOG_INFO, "Flushing stream #%u encoder\n", stream_index);

ret = encode_write_frame(NULL, stream_index, &got_frame);

if (ret < 0)

break;

if (!got_frame)

return 0;

}

return ret;

}

int main(int argc, char **argv)

{

int ret;

AVPacket packet = { .data = NULL, .size = 0 };

AVFrame *frame = NULL;

enum AVMediaType type;

unsigned int stream_index;

unsigned int i;

int got_frame;

int (*dec_func)(AVCodecContext *, AVFrame *, int *, const AVPacket *);

if (argc != 3) {

av_log(NULL, AV_LOG_ERROR, "Usage: %s <input file> <output file>\n", argv[0]);

return 1;

}

av_register_all();

avfilter_register_all();

if ((ret = open_input_file(argv[1])) < 0)

goto end;

if ((ret = open_output_file(argv[2])) < 0)

goto end;

if ((ret = init_filters()) < 0)

goto end;

/* read all packets */

while (1) {

if ((ret = av_read_frame(ifmt_ctx, &packet)) < 0)

break;

stream_index = packet.stream_index;

type = ifmt_ctx->streams[packet.stream_index]->codec->codec_type;

av_log(NULL, AV_LOG_DEBUG, "Demuxer gave frame of stream_index %u\n",

stream_index);

if (filter_ctx[stream_index].filter_graph) {

av_log(NULL, AV_LOG_DEBUG, "Going to reencode&filter the frame\n");

frame = av_frame_alloc();

if (!frame) {

ret = AVERROR(ENOMEM);

break;

}

av_packet_rescale_ts(&packet,

ifmt_ctx->streams[stream_index]->time_base,

ifmt_ctx->streams[stream_index]->codec->time_base);

dec_func = (type == AVMEDIA_TYPE_VIDEO) ? avcodec_decode_video2 :

avcodec_decode_audio4;

ret = dec_func(ifmt_ctx->streams[stream_index]->codec, frame,

&got_frame, &packet);

if (ret < 0) {

av_frame_free(&frame);

av_log(NULL, AV_LOG_ERROR, "Decoding failed\n");

break;

}

if (got_frame) {

frame->pts = av_frame_get_best_effort_timestamp(frame);

ret = filter_encode_write_frame(frame, stream_index);

av_frame_free(&frame);

if (ret < 0)

goto end;

} else {

av_frame_free(&frame);

}

} else {

/* remux this frame without reencoding */

av_packet_rescale_ts(&packet,

ifmt_ctx->streams[stream_index]->time_base,

ofmt_ctx->streams[stream_index]->time_base);

ret = av_interleaved_write_frame(ofmt_ctx, &packet);

if (ret < 0)

goto end;

}

av_packet_unref(&packet);

}

/* flush filters and encoders */

for (i = 0; i < ifmt_ctx->nb_streams; i++) {

/* flush filter */

if (!filter_ctx[i].filter_graph)

continue;

ret = filter_encode_write_frame(NULL, i);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Flushing filter failed\n");

goto end;

}

/* flush encoder */

ret = flush_encoder(i);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Flushing encoder failed\n");

goto end;

}

av_write_trailer(ofmt_ctx);

end:

av_packet_unref(&packet);

av_frame_free(&frame);

for (i = 0; i < ifmt_ctx->nb_streams; i++) {

avcodec_close(ifmt_ctx->streams[i]->codec);

if (ofmt_ctx && ofmt_ctx->nb_streams > i && ofmt_ctx->streams[i] && ofmt_ctx->streams[i]->codec)

avcodec_close(ofmt_ctx->streams[i]->codec);

if (filter_ctx && filter_ctx[i].filter_graph)

avfilter_graph_free(&filter_ctx[i].filter_graph);

}

av_free(filter_ctx);

avformat_close_input(&ifmt_ctx);

if (ofmt_ctx && !(ofmt_ctx->oformat->flags & AVFMT_NOFILE))

avio_closep(&ofmt_ctx->pb);

avformat_free_context(ofmt_ctx);

if (ret < 0)

av_log(NULL, AV_LOG_ERROR, "Error occurred: %s\n", av_err2str(ret));

return ret ? 1 : 0;

}

转码的整个过程可用如下流程图来概述：

重要函数的简要介绍：

open_input_file()：打开输入文件，并初始化相关的结构体。

其中的avformat_open_input()函数可参考 ffmpeg学习五：avformat_open_input函数源码分析（以mp4文件为例）一文。avformat_find_stream_info()可参考ffmpeg学习七：avformat_find_stream_info函数源码分析一文。avcodec_open2()函数可参考 ffmpeg学习六：avcodec_open2函数源码分析一文。

open_output_file()：打开输出文件，并初始化相关的结构体。会写入格式相关的文件头部信息

init_filters()：初始化AVFilter相关的结构体。可参考ffmpeg学习十二：滤镜（实现视频缩放，裁剪，水印等）一文。

av_read_frame()：从输入文件中读取一个AVPacket。

avcodec_decode_video2()：解码一个视频AVPacket（存储H.264等压缩码流数据）为AVFrame（存储YUV等非压缩的像素数据）。

avcodec_decode_video4()：解码一个音频AVPacket（存储MP3等压缩码流数据）为AVFrame（存储PCM采样数据）。

filter_encode_write_frame()：首先会对AVFrame做滤镜处理，然后编码一个AVFrame，最后写入文件。

此外，音频编码可参考ffmpeg学习十：将pcm格式的音频编码为aac格式一文。

视频编码可参考ffmpeg学习八：软件生成yuv420p视频并将其编码为H264格式一文。

封装可参考 ffmpeg学习十一：封装音视频到同一个文件（muxing.c源码分析）一文。

解封装与解码可参考ffmpeg学习四：写第一个程序-视频解封装与解码一文。

ffmpeg学习十二：图像数据格式的转换与图像的缩放

一.实现图像数据格式转换与图像缩放的三个重要函数

ffmpeg实现图像数据格式的转换以及图片的缩放的功能，主要使用swscale.h中的三个函数：

sws_getContext()

sws_scale()

sws_freeContext()

这三个函数的定义如下：

1.sws_getContext() :

/**

* Allocate and return an SwsContext. You need it to perform

* scaling/conversion operations using sws_scale().

* @param srcW the width of the source image

* @param srcH the height of the source image

* @param srcFormat the source image format

* @param dstW the width of the destination image

* @param dstH the height of the destination image

* @param dstFormat the destination image format

* @param flags specify which algorithm and options to use for rescaling

* @param param extra parameters to tune the used scaler

* For SWS_BICUBIC param[0] and [1] tune the shape of the basis

* function, param[0] tunes f(1) and param[1] f麓(1)

* For SWS_GAUSS param[0] tunes the exponent and thus cutoff

* frequency

* For SWS_LANCZOS param[0] tunes the width of the window function

* @return a pointer to an allocated context, or NULL in case of error

* @note this function is to be removed after a saner alternative is

* written

struct SwsContext *sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat,

int dstW, int dstH, enum AVPixelFormat dstFormat,

int flags, SwsFilter *srcFilter,

SwsFilter *dstFilter, const double *param);

参数介绍

* @param srcW源图像的宽度

* @param srcH源图像的高度

* @param srcFormat源图像格式

* @param dstW目标图像的宽度

* @param dstH目标图像的高度

* @param dstFormat目标图像格式

* @后面三个参数一般都置为空

* @返回指向分配的上下文的指针，或在出错的情况下为NULL

* /

2.sws_scale()

/**

* Scale the image slice in srcSlice and put the resulting scaled

* slice in the image in dst. A slice is a sequence of consecutive

* rows in an image.

* Slices have to be provided in sequential order, either in

* top-bottom or bottom-top order. If slices are provided in

* non-sequential order the behavior of the function is undefined.

* @param c the scaling context previously created with

* sws_getContext()

* @param srcSlice the array containing the pointers to the planes of

* the source slice

* @param srcStride the array containing the strides for each plane of

* the source image

* @param srcSliceY the position in the source image of the slice to

* process, that is the number (counted starting from

* zero) in the image of the first row of the slice

* @param srcSliceH the height of the source slice, that is the number

* of rows in the slice

* @param dst the array containing the pointers to the planes of

* the destination image

* @param dstStride the array containing the strides for each plane of

* the destination image

* @return the height of the output slice

int sws_scale(struct SwsContext *c, const uint8_t *const srcSlice[],

const int srcStride[], int srcSliceY, int srcSliceH,

uint8_t *const dst[], const int dstStride[]);

参数介绍：

/* @param c sws_getContext（）返回的用于图像格式转换和图像缩放的上下文环境

* @param srcSlice 包含源图像数据的数组，它是一个包含多通道数据的二维数组，对于yuv而言，我们会用到 * @它的srcSlice [0],srcSlice [1],srcSlice [2]

* @param srcStride 步幅，可以理解为图像的行宽

* @param srcSliceY 开始处理的在原图像中的横坐标的位置，如果是从头开始，那么此处为0

* @param srcSliceH 开始处理的在原图像中的纵坐标的位置，如果是从头开始，那么此处为0

* @param dst 输出的图像数据

* @param dstStride 输出的图像数据的宽度

* @返回输出图像的高度

* /

3.sws_freeContext()

/**

* Free the swscaler context swsContext.

* If swsContext is NULL, then does nothing.

void sws_freeContext(struct SwsContext *swsContext);

参数介绍：

唯一的一个参数，就是 sws_getContext（）返回的用于图像格式转换和图像缩放的上下文环境

三个函数的关系

其中，我们可以把sws_getContext() 看成初始化函数，把sws_freeContext()看成结束函数。这两个函数分别再起始和结束的时候各执行一次即可。真正主要的函数是sws_scale()，它是图像数据格式转换与图像缩放的执行函数。

例程

ffmpeg中已经提供了一个例子，路径为doc/examples/scaling_video.c。

这个程序不长，全部贴出来：

#include <libavutil/imgutils.h>

#include <libavutil/parseutils.h>

#include <libswscale/swscale.h>

static void fill_yuv_image(uint8_t *data[4], int linesize[4],

int width, int height, int frame_index)

{

int x, y;

/* Y */

for (y = 0; y < height; y++)

for (x = 0; x < width; x++)

data[0][y * linesize[0] + x] = x + y + frame_index * 3;

/* Cb and Cr */

for (y = 0; y < height / 2; y++) {

for (x = 0; x < width / 2; x++) {

data[1][y * linesize[1] + x] = 128 + y + frame_index * 2;

data[2][y * linesize[2] + x] = 64 + x + frame_index * 5;

}

int main(int argc, char **argv)

{

uint8_t *src_data[4], *dst_data[4];

int src_linesize[4], dst_linesize[4];

int src_w = 320, src_h = 240, dst_w, dst_h;

enum AVPixelFormat src_pix_fmt = AV_PIX_FMT_YUV420P, dst_pix_fmt = AV_PIX_FMT_RGB24;

const char *dst_size = NULL;

const char *dst_filename = NULL;

FILE *dst_file;

int dst_bufsize;

struct SwsContext *sws_ctx;

int i, ret;

if (argc != 3) {

fprintf(stderr, "Usage: %s output_file output_size\n"

"API example program to show how to scale an image with libswscale.\n"

"This program generates a series of pictures, rescales them to the given "

"output_size and saves them to an output file named output_file\n."

"\n", argv[0]);

exit(1);

}

dst_filename = argv[1];

dst_size = argv[2];

if (av_parse_video_size(&dst_w, &dst_h, dst_size) < 0) {

fprintf(stderr,

"Invalid size '%s', must be in the form WxH or a valid size abbreviation\n",

dst_size);

exit(1);

}

dst_file = fopen(dst_filename, "wb");

if (!dst_file) {

fprintf(stderr, "Could not open destination file %s\n", dst_filename);

exit(1);

}

/* create scaling context */

sws_ctx = sws_getContext(src_w, src_h, src_pix_fmt,

dst_w, dst_h, dst_pix_fmt,

SWS_BILINEAR, NULL, NULL, NULL);

if (!sws_ctx) {

fprintf(stderr,

"Impossible to create scale context for the conversion "

"fmt:%s s:%dx%d -> fmt:%s s:%dx%d\n",

av_get_pix_fmt_name(src_pix_fmt), src_w, src_h,

av_get_pix_fmt_name(dst_pix_fmt), dst_w, dst_h);

ret = AVERROR(EINVAL);

goto end;

}

/* allocate source and destination image buffers */

if ((ret = av_image_alloc(src_data, src_linesize,

src_w, src_h, src_pix_fmt, 16)) < 0) {

fprintf(stderr, "Could not allocate source image\n");

goto end;

}

/* buffer is going to be written to rawvideo file, no alignment */

if ((ret = av_image_alloc(dst_data, dst_linesize,

dst_w, dst_h, dst_pix_fmt, 1)) < 0) {

fprintf(stderr, "Could not allocate destination image\n");

goto end;

}

dst_bufsize = ret;

for (i = 0; i < 100; i++) {

/* generate synthetic video */

fill_yuv_image(src_data, src_linesize, src_w, src_h, i);

/* convert to destination format */

sws_scale(sws_ctx, (const uint8_t * const*)src_data,

src_linesize, 0, src_h, dst_data, dst_linesize);

/* write scaled image to file */

fwrite(dst_data[0], 1, dst_bufsize, dst_file);

}

fprintf(stderr, "Scaling succeeded. Play the output file with the command:\n"

"ffplay -f rawvideo -pix_fmt %s -video_size %dx%d %s\n",

av_get_pix_fmt_name(dst_pix_fmt), dst_w, dst_h, dst_filename);

end:

fclose(dst_file);

av_freep(&src_data[0]);

av_freep(&dst_data[0]);

sws_freeContext(sws_ctx);

return ret < 0;

}

这个文件，能把yuv图像格式的数据转换为rgb格式。并按照指定的图像大小输出到文件。

过程分析如下：

1.首先使用av_parse_video_size（）函数获得命令行传入的图像的大小

2.打开输出文件

3.调用sws_getContext函数创建缩放与图像格式转换的上下文环境

4.调用av_image_alloc来分配读取源图像数组需要的内存

5.调用av_image_alloc来分配输出图像数组需要的内存

6.循环处理每一帧图像。调用fill_yuv_image获得原始图像后，使用sws_scale进行转换，然后fwrite写入到文件。

7.调用sws_freeContext结束图像的格式转换与缩放操作。

例程结果展示

编译后，执行：

./scaling_video hello.rgb 600x400

答应如下：

Scaling succeeded. Play the output file with the command:

ffplay -f rawvideo -pix_fmt rgb24 -video_size 600x400 hello.rgb

可见，该文件很友好的打印了怎么播放生成的视频文件。

播放的截图如下：

从而，实现了将图像格式由yuv转为rgb,并将其大小缩放到指定大小的过程。

ffmpeg学习十一：滤镜（实现视频缩放，裁剪，水印等）

这篇文章对使用滤镜进行视频缩放，裁剪水印等做简单介绍。

一.滤镜

滤镜可以实现多路视频的叠加，水印，缩放，裁剪等功能，ffmpeg提供了丰富的滤镜，可以使用ffmpeg -filters来查看：

Filters:

T.. = Timeline support

.S. = Slice threading

..C = Command support

A = Audio input/output

V = Video input/output

N = Dynamic number and/or type of input/output

| = Source or sink filter

T.. adelay A->A Delay one or more audio channels.

… aecho A->A Add echoing to the audio.

… aeval A->A Filter audio signal according to a specified expression.

T.. afade A->A Fade in/out input audio.

… aformat A->A Convert the input audio to one of the specified formats.

… ainterleave N->A Temporally interleave audio inputs.

… allpass A->A Apply a two-pole all-pass filter.

… amerge N->A Merge two or more audio streams into a single multi-channel stream.

… amix N->A Audio mixing.

… anull A->A Pass the source unchanged to the output.

T.. apad A->A Pad audio with silence.

… aperms A->A Set permissions for the output audio frame.

… aphaser A->A Add a phasing effect to the audio.

… aresample A->A Resample audio data.

… aselect A->N Select audio frames to pass in output.

… asendcmd A->A Send commands to filters.

… asetnsamples A->A Set the number of samples for each output audio frames.

… asetpts A->A Set PTS for the output audio frame.

… asetrate A->A Change the sample rate without altering the data.

… asettb A->A Set timebase for the audio output link.

… ashowinfo A->A Show textual information for each audio frame.

… asplit A->N Pass on the audio input to N audio outputs.

…..

这里只是列出其中一小部分，可见ffmpeg提供了非常丰富的滤镜。

滤镜的几个基本概念

Filter:代表单个filter

FilterPad:代表一个filter的输入或输出端口，每个filter都可以有多个输入和多个输出，只有输出pad的filter称为source,只有输入pad的filter称为sink

FilterLink：若一个filter的输出pad和另一个filter的输入pad名字相同，即认为两个filter之间建立了link

FilterChain:代表一串相互连接的filters，除了source和sink外，要求每个filter的输入输出pad都有对应的输出和输入pad

**FilterGraph:**FilterChain的集合

经典示例：

图中每一个节点就是一个Filter，每一个方括号所代表的就是FilterPad，可以看到split的输出pad中有一个叫tmp的，而crop的输入pad中也有一个tmp，由此在二者之间建立了link，当然input和output代表的就是source和sink，此外，图中有三条FilterChain，第一条由input和split组成，第二条由crop和vflip组成，第三条由overlay和output组成，整张图即是一个拥有三个FilterChain的FilterGraph。

使用libavfilter为视频添加滤镜

ffmpeg官网给出的filtering_video.c介绍了滤镜的用法，这个例子将一个视频文件解码成原始的一帧数据，然后再将这一帧数据使用滤镜惊醒缩放，缩小到78x24大小后，将像素中的点转换成字符，然后显示在终端中，效果如下：

这个程序结构非常清晰的介绍了滤镜的用法，但这种将视频中的像素转换为字符，然后显示在终端的做法并不能很直观的感受滤镜的作用，因此，我对这个程序做了简单的修改，将滤镜处理后的视频保存在文件中而不是显示在终端。下面为我修改过后，完整的程序，只有一个.c文件：

#define _XOPEN_SOURCE 600 /* for usleep */

#include <unistd.h>

#include <libavcodec/avcodec.h>

#include <libavformat/avformat.h>

#include <libavfilter/avfiltergraph.h>

#include <libavfilter/avcodec.h>

#include <libavfilter/buffersink.h>

#include <libavfilter/buffersrc.h>

#include <libavutil/opt.h>

/*缩放滤镜，以下命令将视频缩小一般,iw,ih指的是输入的视频宽和高，

*此外也可以直接使用数字知名缩放的大小，比如:scale=200:100

//const char *filter_descr = "scale=iw/2:ih/2";

/*裁剪滤镜，一下命令将视频的左上角的四分之一裁剪下来*/

//const char *filter_descr = "crop=iw/2:ih/2:0:0";

/*添加字符串水印*/

const char *filter_descr = "drawtext=fontfile=FreeSans.ttf:fontcolor=green:fontsize=30:text='Hello'";

static AVFormatContext *fmt_ctx;

static AVCodecContext *dec_ctx;

AVFilterContext *buffersink_ctx;

AVFilterContext *buffersrc_ctx;

AVFilterGraph *filter_graph;

static int video_stream_index = -1;

static int64_t last_pts = AV_NOPTS_VALUE;

static int open_input_file(const char *filename)

{

int ret;

AVCodec *dec;

if ((ret = avformat_open_input(&fmt_ctx, filename, NULL, NULL)) < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");

return ret;

}

if ((ret = avformat_find_stream_info(fmt_ctx, NULL)) < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");

return ret;

}

/* select the video stream */

ret = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &dec, 0);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot find a video stream in the input file\n");

return ret;

}

video_stream_index = ret;

dec_ctx = fmt_ctx->streams[video_stream_index]->codec;

av_opt_set_int(dec_ctx, "refcounted_frames", 1, 0);

/* init the video decoder */

if ((ret = avcodec_open2(dec_ctx, dec, NULL)) < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot open video decoder\n");

return ret;

}

return 0;

}

static int init_filters(const char *filters_descr)

{

char args[512];

int ret = 0;

AVFilter *buffersrc = avfilter_get_by_name("buffer");

AVFilter *buffersink = avfilter_get_by_name("buffersink");

AVFilterInOut *outputs = avfilter_inout_alloc();

AVFilterInOut *inputs = avfilter_inout_alloc();

AVRational time_base = fmt_ctx->streams[video_stream_index]->time_base;

enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE };

filter_graph = avfilter_graph_alloc();

if (!outputs || !inputs || !filter_graph) {

ret = AVERROR(ENOMEM);

goto end;

}

/* buffer video source: the decoded frames from the decoder will be inserted here. */

snprintf(args, sizeof(args),

"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",

dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,

time_base.num, time_base.den,

dec_ctx->sample_aspect_ratio.num, dec_ctx->sample_aspect_ratio.den);

ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",

args, NULL, filter_graph);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");

goto end;

}

/* buffer video sink: to terminate the filter chain. */

ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",

NULL, NULL, filter_graph);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");

goto end;

}

ret = av_opt_set_int_list(buffersink_ctx, "pix_fmts", pix_fmts,

AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Cannot set output pixel format\n");

goto end;

}

* Set the endpoints for the filter graph. The filter_graph will

* be linked to the graph described by filters_descr.

* The buffer source output must be connected to the input pad of

* the first filter described by filters_descr; since the first

* filter input label is not specified, it is set to "in" by

* default.

outputs->name = av_strdup("in");

outputs->filter_ctx = buffersrc_ctx;

outputs->pad_idx = 0;

outputs->next = NULL;

* The buffer sink input must be connected to the output pad of

* the last filter described by filters_descr; since the last

* filter output label is not specified, it is set to "out" by

* default.

inputs->name = av_strdup("out");

inputs->filter_ctx = buffersink_ctx;

inputs->pad_idx = 0;

inputs->next = NULL;

if ((ret = avfilter_graph_parse_ptr(filter_graph, filters_descr,

&inputs, &outputs, NULL)) < 0)

goto end;

if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)

goto end;

end:

avfilter_inout_free(&inputs);

avfilter_inout_free(&outputs);

return ret;

}

FILE * file_fd;

static void write_frame(const AVFrame *frame)

{

if(frame->format==AV_PIX_FMT_YUV420P){

printf("format is yuv420p\n");

}else{

printf("format is not yuv420p\n");

}

printf("frame widht=%d,frame height=%d\n",\

frame->width,frame->height);

fwrite(frame->data[0],1,frame->width*frame->height,file_fd);

fwrite(frame->data[1],1,frame->width/2*frame->height/2,file_fd);

fwrite(frame->data[2],1,frame->width/2*frame->height/2,file_fd);

}

int main(int argc, char **argv)

{

int ret;

AVPacket packet;

AVFrame *frame = av_frame_alloc();

AVFrame *filt_frame = av_frame_alloc();

int got_frame;

file_fd = fopen("hello.yuv","wb+");

if (!frame || !filt_frame) {

perror("Could not allocate frame");

exit(1);

}

if (argc != 2) {

fprintf(stderr, "Usage: %s file\n", argv[0]);

exit(1);

}

av_register_all();

avfilter_register_all();

if ((ret = open_input_file(argv[1])) < 0)

goto end;

if ((ret = init_filters(filter_descr)) < 0)

goto end;

/* read all packets */

while (1) {

if ((ret = av_read_frame(fmt_ctx, &packet)) < 0)

break;

if (packet.stream_index == video_stream_index) {

got_frame = 0;

ret = avcodec_decode_video2(dec_ctx, frame, &got_frame, &packet);

if (ret < 0) {

av_log(NULL, AV_LOG_ERROR, "Error decoding video\n");

break;

}

if (got_frame) {

frame->pts = av_frame_get_best_effort_timestamp(frame);

/* push the decoded frame into the filtergraph */

if (av_buffersrc_add_frame_flags(buffersrc_ctx, frame, AV_BUFFERSRC_FLAG_KEEP_REF) < 0) {

av_log(NULL, AV_LOG_ERROR, "Error while feeding the filtergraph\n");

break;

}

/* pull filtered frames from the filtergraph */

while (1) {

ret = av_buffersink_get_frame(buffersink_ctx, filt_frame);

if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)

break;

if (ret < 0)

goto end;

write_frame(filt_frame);

av_frame_unref(filt_frame);

}

av_frame_unref(frame);

}

av_free_packet(&packet);

}

end:

avfilter_graph_free(&filter_graph);

avcodec_close(dec_ctx);

avformat_close_input(&fmt_ctx);

av_frame_free(&frame);

av_frame_free(&filt_frame);

if (ret < 0 && ret != AVERROR_EOF) {

fprintf(stderr, "Error occurred: %s\n", av_err2str(ret));

exit(1);

}

fclose(file_fd);

exit(0);

}

文件编译参考前面的文章，便宜时会报错：No such filter: ‘drawtext’。这是因为我们没有是能这个滤镜。

解决办法：程序找不到 drawtext这个filter，一般是因为使用默认编译选项是该filter并未被编译进库里面，所以重新再编译ffmpeg，并且在执行”./configure ……”时加上“–enable-libfreetype”。这样就ok了。

完整的配置如下，我们之前已经使能了aac,h.264编解码器。

./configure --enable-libx264 --enable-gpl --enable-decoder=h264 --enable-encoder=libx264 --enable-shared --enable-static --disable-yasm -enable-nonfree --enable-libfdk-aac --enable-shared --enable-libfreetype --prefix=tmp

配置结束后执行make && make install安装即可。

编译后，执行实例如下：

./out.bin rain.mp4

然后再当前文件下会生成hello.yuv的视频文件，这是原始数据格式的视频，可以使用ffplay来播放：

ffplay -s 1280x640 hello.yuv

改程序会打印出视频的长和宽，这里的1280x640请使用打印出来的长和宽来代替。

三.缩放，裁剪，添加字符串水印

滤镜的用法基本就是如上程序给出的步骤，我们可以通过指定不同的描述字符串来实现不同的滤镜功能。下面的字符串将视频缩放为200x100大小，着我在程序里的注释中已经给出了。

原视频：

缩小为一半：

const char *filter_descr = “scale=iw/2:ih/2”;

缩小后现象不明显，就不贴图了。

如下命令将视频裁剪出中间的1/4。

const char *filter_descr = “crop=iw/2:ih/2:iw/4:ih/4”;

效果如下：

下面字符串给视频添加hello的字符串水印：
const char *filter_descr = “drawtext=fontfile=FreeSans.ttf:fontcolor=green:fontsize=30:text=’Hello’”;
效果如下：

更复杂的滤镜的使用，期待和大家一起学习。

ffmpeg学习十：封装音视频到同一个文件（muxing.c源码分析）

这一节学习怎么把音频流和视频按一定的格式封装成一个文件。ffmpeg所给的例子muxing.c很好的演示封装的过程，因此，这一节主要是学习muxing.c这个文件。

这个文件的路径为：doc/examples/muxing.c

首先感受下，运行结果如下：

直接执行./muxing xxx.xxx即可

这里插讲以下使用ffmpeg生成gif的命令：

当我们执行muxing可执行文件的时候,比如，执行./muxing hello.mp4，就会生成Mp4文件，我们可以将其转为gif格式的图片：

ffmpeg -i hello.mp4 -r 10 -t 1 hello.gif

-i:指定输入文件

-r:帧率，一秒钟10帧

-t:制定gif的时间长度，这里这制定1s钟。

main函数

muxing.c的main函数如下：

/**************************************************************/

/* media file output */

int main(int argc, char **argv)

{

OutputStream video_st = { 0 }, audio_st = { 0 };

const char *filename;

AVOutputFormat *fmt;

AVFormatContext *oc;

AVCodec *audio_codec, *video_codec;

int ret;

int have_video = 0, have_audio = 0;

int encode_video = 0, encode_audio = 0;

AVDictionary *opt = NULL;

int i;

/* Initialize libavcodec, and register all codecs and formats. */

av_register_all();

if (argc < 2) {

printf("usage: %s output_file\n"

"API example program to output a media file with libavformat.\n"

"This program generates a synthetic audio and video stream, encodes and\n"

"muxes them into a file named output_file.\n"

"The output format is automatically guessed according to the file extension.\n"

"Raw images can also be output by using '%%d' in the filename.\n"

"\n", argv[0]);

return 1;

}

filename = argv[1];

for (i = 2; i+1 < argc; i+=2) {

if (!strcmp(argv[i], "-flags") || !strcmp(argv[i], "-fflags"))

av_dict_set(&opt, argv[i]+1, argv[i+1], 0);

}

/* allocate the output media context */

avformat_alloc_output_context2(&oc, NULL, NULL, filename);

if (!oc) {

printf("Could not deduce output format from file extension: using MPEG.\n");

avformat_alloc_output_context2(&oc, NULL, "mpeg", filename);

}

if (!oc)

return 1;

fmt = oc->oformat;

/* Add the audio and video streams using the default format codecs

* and initialize the codecs. */

if (fmt->video_codec != AV_CODEC_ID_NONE) {

add_stream(&video_st, oc, &video_codec, fmt->video_codec);

have_video = 1;

encode_video = 1;

}

if (fmt->audio_codec != AV_CODEC_ID_NONE) {

add_stream(&audio_st, oc, &audio_codec, fmt->audio_codec);

have_audio = 1;

encode_audio = 1;

}

/* Now that all the parameters are set, we can open the audio and

* video codecs and allocate the necessary encode buffers. */

if (have_video)

open_video(oc, video_codec, &video_st, opt);

if (have_audio)

open_audio(oc, audio_codec, &audio_st, opt);

av_dump_format(oc, 0, filename, 1);

/* open the output file, if needed */

if (!(fmt->flags & AVFMT_NOFILE)) {

ret = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE);

if (ret < 0) {

fprintf(stderr, "Could not open '%s': %s\n", filename,

av_err2str(ret));

return 1;

}

/* Write the stream header, if any. */

ret = avformat_write_header(oc, &opt);

if (ret < 0) {

fprintf(stderr, "Error occurred when opening output file: %s\n",

av_err2str(ret));

return 1;

}

while (encode_video || encode_audio) {

/* select the stream to encode */

if (encode_video &&

(!encode_audio || av_compare_ts(video_st.next_pts, video_st.enc->time_base,

audio_st.next_pts, audio_st.enc->time_base) <= 0)) {

encode_video = !write_video_frame(oc, &video_st);

} else {

encode_audio = !write_audio_frame(oc, &audio_st);

}

/* Write the trailer, if any. The trailer must be written before you

* close the CodecContexts open when you wrote the header; otherwise

* av_write_trailer() may try to use memory that was freed on

* av_codec_close(). */

av_write_trailer(oc);

/* Close each codec. */

if (have_video)

close_stream(oc, &video_st);

if (have_audio)

close_stream(oc, &audio_st);

if (!(fmt->flags & AVFMT_NOFILE))

/* Close the output file. */

avio_closep(&oc->pb);

/* free the stream */

avformat_free_context(oc);

return 0;

}

我们可以梳理一下这个过程：

add_stream

接下来看看如何添加一个输出流的：

/* Add an output stream. */

static void add_stream(OutputStream *ost, AVFormatContext *oc,

AVCodec **codec,

enum AVCodecID codec_id)

{

AVCodecContext *c;

int i;

/* find the encoder */

*codec = avcodec_find_encoder(codec_id);

if (!(*codec)) {

fprintf(stderr, "Could not find encoder for '%s'\n",

avcodec_get_name(codec_id));

exit(1);

}

ost->st = avformat_new_stream(oc, NULL);

if (!ost->st) {

fprintf(stderr, "Could not allocate stream\n");

exit(1);

}

ost->st->id = oc->nb_streams-1;

c = avcodec_alloc_context3(*codec);

if (!c) {

fprintf(stderr, "Could not alloc an encoding context\n");

exit(1);

}

ost->enc = c;

switch ((*codec)->type) {

case AVMEDIA_TYPE_AUDIO:

c->sample_fmt = (*codec)->sample_fmts ?

(*codec)->sample_fmts[0] : AV_SAMPLE_FMT_FLTP;

c->bit_rate = 64000;

c->sample_rate = 44100;

if ((*codec)->supported_samplerates) {

c->sample_rate = (*codec)->supported_samplerates[0];

for (i = 0; (*codec)->supported_samplerates[i]; i++) {

if ((*codec)->supported_samplerates[i] == 44100)

c->sample_rate = 44100;

}

c->channels = av_get_channel_layout_nb_channels(c->channel_layout);

c->channel_layout = AV_CH_LAYOUT_STEREO;

if ((*codec)->channel_layouts) {

c->channel_layout = (*codec)->channel_layouts[0];

for (i = 0; (*codec)->channel_layouts[i]; i++) {

if ((*codec)->channel_layouts[i] == AV_CH_LAYOUT_STEREO)

c->channel_layout = AV_CH_LAYOUT_STEREO;

}

c->channels = av_get_channel_layout_nb_channels(c->channel_layout);

ost->st->time_base = (AVRational){ 1, c->sample_rate };

break;

case AVMEDIA_TYPE_VIDEO:

c->codec_id = codec_id;

c->bit_rate = 400000;

/* Resolution must be a multiple of two. */

c->width = 352;

c->height = 288;

/* timebase: This is the fundamental unit of time (in seconds) in terms

* of which frame timestamps are represented. For fixed-fps content,

* timebase should be 1/framerate and timestamp increments should be

* identical to 1. */

ost->st->time_base = (AVRational){ 1, STREAM_FRAME_RATE };

c->time_base = ost->st->time_base;

c->gop_size = 12; /* emit one intra frame every twelve frames at most */

c->pix_fmt = STREAM_PIX_FMT;

if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {

/* just for testing, we also add B-frames */

c->max_b_frames = 2;

}

if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {

/* Needed to avoid using macroblocks in which some coeffs overflow.

* This does not happen with normal video, it just happens here as

* the motion of the chroma plane does not match the luma plane. */

c->mb_decision = 2;

}

break;

default:

break;

}

/* Some formats want stream headers to be separate. */

if (oc->oformat->flags & AVFMT_GLOBALHEADER)

c->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

}

这个过程其实非常简单：

这个过程总结起来是这样的：创建一个编码器，创建一个新的流，设置编码器上下文环境的参数。

在这个函数中，音频编码器和视频编码器通过(*codec)->type来区分，然后音频和部分的参数设置必然不同，具体参数的设置，可以参考前面的文章。

open_video与open_audio

open_video

static void open_video(AVFormatContext *oc, AVCodec *codec, OutputStream *ost, AVDictionary *opt_arg)

{

int ret;

AVCodecContext *c = ost->enc;

AVDictionary *opt = NULL;

av_dict_copy(&opt, opt_arg, 0);

/* open the codec */

ret = avcodec_open2(c, codec, &opt);

av_dict_free(&opt);

if (ret < 0) {

fprintf(stderr, "Could not open video codec: %s\n", av_err2str(ret));

exit(1);

}

/* allocate and init a re-usable frame */

ost->frame = alloc_picture(c->pix_fmt, c->width, c->height);

if (!ost->frame) {

fprintf(stderr, "Could not allocate video frame\n");

exit(1);

}

/* If the output format is not YUV420P, then a temporary YUV420P

* picture is needed too. It is then converted to the required

* output format. */

ost->tmp_frame = NULL;

if (c->pix_fmt != AV_PIX_FMT_YUV420P) {

ost->tmp_frame = alloc_picture(AV_PIX_FMT_YUV420P, c->width, c->height);

if (!ost->tmp_frame) {

fprintf(stderr, "Could not allocate temporary picture\n");

exit(1);

}

/* copy the stream parameters to the muxer */

ret = avcodec_parameters_from_context(ost->st->codecpar, c);

if (ret < 0) {

fprintf(stderr, "Could not copy the stream parameters\n");

exit(1);

}

这个函数，主要还是使用avcodec_open2来打开编码器，然后分配AVFrame结构体，分配AVFrame结构体使用的是alloc_picture函数，这个函数如下：

/**************************************************************/

/* video output */

static AVFrame *alloc_picture(enum AVPixelFormat pix_fmt, int width, int height)

{

AVFrame *picture;

int ret;

picture = av_frame_alloc();

if (!picture)

return NULL;

picture->format = pix_fmt;

picture->width = width;

picture->height = height;

/* allocate the buffers for the frame data */

ret = av_frame_get_buffer(picture, 32);

if (ret < 0) {

fprintf(stderr, "Could not allocate frame data.\n");

exit(1);

}

return picture;

}

这个函数av_frame_alloc函数来真正分配一个AVFrame结构体，并设置AVFrame的并设置其格式，以及视频长和宽。并分配缓存。

open_audio

open_audio和open_video类似：

static void open_audio(AVFormatContext *oc, AVCodec *codec, OutputStream *ost, AVDictionary *opt_arg)

{

AVCodecContext *c;

int nb_samples;

int ret;

AVDictionary *opt = NULL;

c = ost->enc;

/* open it */

av_dict_copy(&opt, opt_arg, 0);

ret = avcodec_open2(c, codec, &opt);

av_dict_free(&opt);

if (ret < 0) {

fprintf(stderr, "Could not open audio codec: %s\n", av_err2str(ret));

exit(1);

}

/* init signal generator */

ost->t = 0;

ost->tincr = 2 * M_PI * 110.0 / c->sample_rate;

/* increment frequency by 110 Hz per second */

ost->tincr2 = 2 * M_PI * 110.0 / c->sample_rate / c->sample_rate;

if (c->codec->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)

nb_samples = 10000;

else

nb_samples = c->frame_size;

ost->frame = alloc_audio_frame(c->sample_fmt, c->channel_layout,

c->sample_rate, nb_samples);

ost->tmp_frame = alloc_audio_frame(AV_SAMPLE_FMT_S16, c->channel_layout,

c->sample_rate, nb_samples);

/* copy the stream parameters to the muxer */

ret = avcodec_parameters_from_context(ost->st->codecpar, c);

if (ret < 0) {

fprintf(stderr, "Could not copy the stream parameters\n");

exit(1);

}

/* create resampler context */

ost->swr_ctx = swr_alloc();

if (!ost->swr_ctx) {

fprintf(stderr, "Could not allocate resampler context\n");

exit(1);

}

/* set options */

av_opt_set_int (ost->swr_ctx, "in_channel_count", c->channels, 0);

av_opt_set_int (ost->swr_ctx, "in_sample_rate", c->sample_rate, 0);

av_opt_set_sample_fmt(ost->swr_ctx, "in_sample_fmt", AV_SAMPLE_FMT_S16, 0);

av_opt_set_int (ost->swr_ctx, "out_channel_count", c->channels, 0);

av_opt_set_int (ost->swr_ctx, "out_sample_rate", c->sample_rate, 0);

av_opt_set_sample_fmt(ost->swr_ctx, "out_sample_fmt", c->sample_fmt, 0);

/* initialize the resampling context */

if ((ret = swr_init(ost->swr_ctx)) < 0) {

fprintf(stderr, "Failed to initialize the resampling context\n");

exit(1);

}

也是打开一个编码器，并设置对应的参数。具体参数的设置请参看之前的文章。

write_video_frame和write_audio_frame

write_video_frame

该函数如下：

* encode one video frame and send it to the muxer

* return 1 when encoding is finished, 0 otherwise

static int write_video_frame(AVFormatContext *oc, OutputStream *ost)

{

int ret;

AVCodecContext *c;

AVFrame *frame;

int got_packet = 0;

AVPacket pkt = { 0 };

c = ost->enc;

frame = get_video_frame(ost);

av_init_packet(&pkt);

/* encode the image */

ret = avcodec_encode_video2(c, &pkt, frame, &got_packet);

if (ret < 0) {

fprintf(stderr, "Error encoding video frame: %s\n", av_err2str(ret));

exit(1);

}

if (got_packet) {

ret = write_frame(oc, &c->time_base, ost->st, &pkt);

} else {

ret = 0;

}

if (ret < 0) {

fprintf(stderr, "Error while writing video frame: %s\n", av_err2str(ret));

exit(1);

}

return (frame || got_packet) ? 0 : 1;

}

这个函数做三件事情：

1.获得一帧视频。使用get_video_frame函数。

2.压缩它。使用avcodec_encode_video2函数。

3.写入文件。使用write_frame函数。

get_video_frame如下：

static AVFrame *get_video_frame(OutputStream *ost)

{

AVCodecContext *c = ost->enc;

/* check if we want to generate more frames */

if (av_compare_ts(ost->next_pts, c->time_base,

STREAM_DURATION, (AVRational){ 1, 1 }) >= 0)

return NULL;

/* when we pass a frame to the encoder, it may keep a reference to it

* internally; make sure we do not overwrite it here */

if (av_frame_make_writable(ost->frame) < 0)

exit(1);

if (c->pix_fmt != AV_PIX_FMT_YUV420P) {

/* as we only generate a YUV420P picture, we must convert it

* to the codec pixel format if needed */

if (!ost->sws_ctx) {

ost->sws_ctx = sws_getContext(c->width, c->height,

AV_PIX_FMT_YUV420P,

c->width, c->height,

c->pix_fmt,

SCALE_FLAGS, NULL, NULL, NULL);

if (!ost->sws_ctx) {

fprintf(stderr,

"Could not initialize the conversion context\n");

exit(1);

}

fill_yuv_image(ost->tmp_frame, ost->next_pts, c->width, c->height);

sws_scale(ost->sws_ctx,

(const uint8_t * const *)ost->tmp_frame->data, ost->tmp_frame->linesize,

0, c->height, ost->frame->data, ost->frame->linesize);

} else {

fill_yuv_image(ost->frame, ost->next_pts, c->width, c->height);

}

ost->frame->pts = ost->next_pts++;

return ost->frame;

}

这个函数首先会检查pts,来判断要不要生成一帧图像。如果需要，就使用fill_yuv_image来生成一帧图像，生成图像结束后，更新pts,也就是ost->next_pts自增。

真正生成一帧数据是在fill_yuv_image函数中实现的：

/* Prepare a dummy image. */

static void fill_yuv_image(AVFrame *pict, int frame_index,

int width, int height)

{

int x, y, i;

i = frame_index;

/* Y */

for (y = 0; y < height; y++)

for (x = 0; x < width; x++)

pict->data[0][y * pict->linesize[0] + x] = x + y + i * 3;

/* Cb and Cr */

for (y = 0; y < height / 2; y++) {

for (x = 0; x < width / 2; x++) {

pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2;

pict->data[2][y * pict->linesize[2] + x] = 64 + x + i * 5;

}

这个函数我们在ffmpeg学习八：软件生成yuv420p视频并将其编码为H264格式一文中已经讲过了。

最后来看看写入文件的过程，也就是write_frame函数：

static int write_frame(AVFormatContext *fmt_ctx, const AVRational *time_base, AVStream *st, AVPacket *pkt)

{

/* rescale output packet timestamp values from codec to stream timebase */

av_packet_rescale_ts(pkt, *time_base, st->time_base);

pkt->stream_index = st->index;

/* Write the compressed frame to the media file. */

log_packet(fmt_ctx, pkt);

return av_interleaved_write_frame(fmt_ctx, pkt);

}

这个函数首先使用av_packet_rescale_ts来调整时间戳。av_packet_rescale_ts函数的作用为不同time_base度量之间的转换，这里是将AVCodecContext的time_base转换为AVStream中的time_base。av_interleaved_write_frame用来写入数据到文件。这个函数定义如下：

/**

* Write a packet to an output media file ensuring correct interleaving.

* This function will buffer the packets internally as needed to make sure the

* packets in the output file are properly interleaved in the order of

* increasing dts. Callers doing their own interleaving should call

* av_write_frame() instead of this function.

* Using this function instead of av_write_frame() can give muxers advance

* knowledge of future packets, improving e.g. the behaviour of the mp4

* muxer for VFR content in fragmenting mode.

* @param s media file handle

* @param pkt The packet containing the data to be written.

* <br>

* If the packet is reference-counted, this function will take

* ownership of this reference and unreference it later when it sees

* fit.

* The caller must not access the data through this reference after

* this function returns. If the packet is not reference-counted,

* libavformat will make a copy.

* <br>

* This parameter can be NULL (at any time, not just at the end), to

* flush the interleaving queues.

* <br>

* Packet's @ref AVPacket.stream_index "stream_index" field must be

* set to the index of the corresponding stream in @ref

* AVFormatContext.streams "s->streams".

* <br>

* The timestamps (@ref AVPacket.pts "pts", @ref AVPacket.dts "dts")

* must be set to correct values in the stream's timebase (unless the

* output format is flagged with the AVFMT_NOTIMESTAMPS flag, then

* they can be set to AV_NOPTS_VALUE).

* The dts for subsequent packets in one stream must be strictly

* increasing (unless the output format is flagged with the

* AVFMT_TS_NONSTRICT, then they merely have to be nondecreasing).

* @ref AVPacket.duration "duration") should also be set if known.

* @return 0 on success, a negative AVERROR on error. Libavformat will always

* take care of freeing the packet, even if this function fails.

* @see av_write_frame(), AVFormatContext.max_interleave_delta

int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt);

这个函数的作用是交互式的写入一Packet的数据到文件中。第一个参数是文件句柄，第二个参数是要写入的数据包。

write_video_frame

write_audio_frame和write_video_frame类似，其源码如下：

* encode one audio frame and send it to the muxer

* return 1 when encoding is finished, 0 otherwise

static int write_audio_frame(AVFormatContext *oc, OutputStream *ost)

{

AVCodecContext *c;

AVPacket pkt = { 0 }; // data and size must be 0;

AVFrame *frame;

int ret;

int got_packet;

int dst_nb_samples;

av_init_packet(&pkt);

c = ost->enc;

frame = get_audio_frame(ost);

if (frame) {

/* convert samples from native format to destination codec format, using the resampler */

/* compute destination number of samples */

dst_nb_samples = av_rescale_rnd(swr_get_delay(ost->swr_ctx, c->sample_rate) + frame->nb_samples,

c->sample_rate, c->sample_rate, AV_ROUND_UP);

av_assert0(dst_nb_samples == frame->nb_samples);

/* when we pass a frame to the encoder, it may keep a reference to it

* internally;

* make sure we do not overwrite it here

ret = av_frame_make_writable(ost->frame);

if (ret < 0)

exit(1);

/* convert to destination format */

ret = swr_convert(ost->swr_ctx,

ost->frame->data, dst_nb_samples,

(const uint8_t **)frame->data, frame->nb_samples);

if (ret < 0) {

fprintf(stderr, "Error while converting\n");

exit(1);

}

frame = ost->frame;

frame->pts = av_rescale_q(ost->samples_count, (AVRational){1, c->sample_rate}, c->time_base);

ost->samples_count += dst_nb_samples;

}

ret = avcodec_encode_audio2(c, &pkt, frame, &got_packet);

if (ret < 0) {

fprintf(stderr, "Error encoding audio frame: %s\n", av_err2str(ret));

exit(1);

}

if (got_packet) {

ret = write_frame(oc, &c->time_base, ost->st, &pkt);

if (ret < 0) {

fprintf(stderr, "Error while writing audio frame: %s\n",

av_err2str(ret));

exit(1);

}

return (frame || got_packet) ? 0 : 1;

}

至此，封装音视频到一个文件的过程就分析完了。其框架我们在一开始就以流程图的方式给出，只要结合这个流程图，看懂源码应该不是什么难事。

ffmpeg学习九：将pcm格式的音频编码为aac格式

上一节，我们使用alsa库编写了音频的采集和播放的程序。这一节，我们将在采集到的pcm格式的音频数据的基础上，进一步将其编码为aac格式。

音频编码概述

pcm是最原始的音频编码格式，这种编码是无损的。同时意味着存储这种数据的文件将会很庞大，因此必须进行压缩。pcm是音频的编码格式，它不是文件的封装格式，上一节我们录制的声音存储在一个.pcm为后缀的文件中，这只是我们愿意这么做而已，你完全可以不这么做，这没有关系。

aac既是一种文件的封装格式，又是音频的编码格式。一aac为封装格式的文件，以.aac为后缀。aac封装格式一般内部的音频数据编码格式也为aac。

音频编码和视频编码的流程基本一致，而视频编码我们在前面已经做过了。因此，关于程序的流程就没有太多需要废话的了。下面介绍几个音频相关的参数，这几个参数是编码器进行编码所必需的。

我们总共需要设置四个参数即可：

1.sample_rate

codecContext->sample_rate = frame->sample_rate;

sample_rate指的是采样率。也就是我们一秒钟采集多少次声音样本。

2.frame->channels

codecContext->channels = frame->channels;

frame->channels之的是通道的数目。音频一般有双通道或者单通道之分，一般都是双通道吧，我们的程序里面也是设置为双通道的。也就是frame->channels=2.

3.frame->format

codecContext->sample_fmt = frame->format;

frame->format指的是样本的格式。一个音频的样本一般用两个字节来描述，分为大小端。我们的程序中使用的是16bit的小端格式。

4.channel_layout

codecContext->channel_layout = AV_CH_LAYOUT_STEREO;

channel_layout 用来设置输出通道布局。这个参数不太理解！！！

程序概述

程序流程图如下：

程序

下面结合程序流程图和程序中的注释，来看程序：

//created by Jinwei Liu

#include <math.h>

#include <stdlib.h>

#include <libavutil/opt.h>

#include <libavcodec/avcodec.h>

#include <libavutil/channel_layout.h>

#include <libavutil/common.h>

#include <libavutil/imgutils.h>

#include <libavutil/mathematics.h>

#include <libavutil/samplefmt.h>

#include <libavutil/frame.h>

#include <libavformat/avformat.h>

#include <libswscale/swscale.h>

int main(int argc, char **argv){

AVFrame *frame;

AVCodec *codec = NULL;

AVPacket packet;

AVCodecContext *codecContext;

int readSize=0;

int ret=0,getPacket;

FILE * fileIn,*fileOut;

int frameCount=0;

/* register all the codecs */

av_register_all();

if(argc!=3){

fprintf(stdout,"usage:./a.out xxx.pcm xxx.aac\n");

return -1;

}

//1.我们需要读一帧一帧的数据，所以需要AVFrame结构

//读出的一帧数据保存在AVFrame中。

frame = av_frame_alloc();

frame->format = AV_SAMPLE_FMT_S16;

frame->nb_samples = 1024;

frame->sample_rate = 11025;

frame->channels = 2;

fileIn =fopen(argv[1],"r+");

frame->data[0] = av_malloc(1024*4);

//2.读出来的数据保存在AVPacket中，因此，我们还需要AVPacket结构体

//初始化packet

memset(&packet, 0, sizeof(AVPacket));

av_init_packet(&packet);

//3.读出来的数据，我们需要编码，因此需要编码器

//下面的函数找到h.264类型的编码器

/* find the mpeg1 video encoder */

codec = avcodec_find_encoder(AV_CODEC_ID_AAC);

if (!codec){

fprintf(stderr, "Codec not found\n");

exit(1);

}

//有了编码器，我们还需要编码器的上下文环境，用来控制编码的过程

codecContext = avcodec_alloc_context3(codec);//分配AVCodecContext实例

if (!codecContext){

fprintf(stderr, "Could not allocate video codec context\n");

return -1;

}

/* put sample parameters */

codecContext->sample_rate = frame->sample_rate;

codecContext->channels = frame->channels;

codecContext->sample_fmt = frame->format;

/* select other audio parameters supported by the encoder */

codecContext->channel_layout = AV_CH_LAYOUT_STEREO;

//准备好了编码器和编码器上下文环境，现在可以打开编码器了

//根据编码器上下文打开编码器

if (avcodec_open2(codecContext, codec, NULL) < 0){

fprintf(stderr, "Could not open codec\n");

return -1;

}

//4.准备输出文件

fileOut= fopen(argv[2],"w+");

//下面开始编码

while(1){

//读一帧数据出来

readSize = fread(frame->data[0],1,1024*4,fileIn);

if(readSize == 0){

fprintf(stdout,"end of file\n");

frameCount++;

break;

}

//初始化packet

av_init_packet(&packet);

/* encode the image */

frame->pts = frameCount;

ret = avcodec_encode_audio2(codecContext, &packet, frame, &getPacket); //将AVFrame中的像素信息编码为AVPacket中的码流

if (ret < 0) {

fprintf(stderr, "Error encoding frame\n");

goto out;

}

if (getPacket) {

frameCount++;

//获得一个完整的编码帧

printf("Write frame %3d (size=%5d)\n", frameCount, packet.size);

fwrite(packet.data, 1,packet.size, fileOut);

av_packet_unref(&packet);

}

/* flush buffer */

for ( getPacket= 1; getPacket; frameCount++){

frame->pts = frameCount;

ret = avcodec_encode_audio2(codecContext, &packet, NULL, &getPacket); //输出编码器中剩余的码流

if (ret < 0){

fprintf(stderr, "Error encoding frame\n");

goto out;

}

if (getPacket){

printf("flush buffer Write frame %3d (size=%5d)\n", frameCount, packet.size);

fwrite(packet.data, 1, packet.size, fileOut);

av_packet_unref(&packet);

}

} //for (got_output = 1; got_output; frameIdx++)

out:

fclose(fileIn);

fclose(fileOut);

av_frame_free(&frame);

avcodec_close(codecContext);

av_free(codecContext);

return 0;

}

实验

使能aac编码器

现在，我们还不能运行这个程序，因为我们在便宜ffmpeg工程的时候没有使能aac编码器，所以我们需要重新编译ffmpeg,是的aac编码器可用。

libfdk_aac：

官网关于使能aac的介绍

-enable-nonfree –enable-libfdk-aac

同时我们需要安装libfdk-aac库：

sudo apt-get install libfdk-aac-dev

然后我们需要重新配置和便宜ffmpeg工程：

1.执行

./configure --enable-libx264 --enable-gpl --enable-decoder=h264 --enable-encoder=libx264 --enable-shared --enable-static --disable-yasm --enable-nonfree --enable-libfdk-aac --enable-shared --prefix=tmp

2.make

3.make install

运行程序

有了aac编码器以后，再次运行这个程序，就可以将pcm格式的音频数据编码为aac格式了，例如，执行如下命令：

./out.bin recorder.pcm recorder.aac

使用ffplay recorder.aac即可听到声音。

附注

Makefile

VAR_INCLUDE := -I /home/mlinux/work/ffmpeg-2.7/ffmpeg-2.7.6/tmp/include

VAR_SHARED_LIB_DIR = -L /home/mlinux/work/ffmpeg-2.7/ffmpeg-2.7.6/tmp/lib

VAR_SHARED_LIBS = -l avcodec -l avformat -l avdevice -l avutil -l swresample -l avfilter -l swscale

out.bin:pcm_2_aac.o

gcc -o $@ $^ $(VAR_INCLUDE) $(VAR_SHARED_LIB_DIR) $(VAR_SHARED_LIBS)

%.o:%.c

gcc -c $< $(VAR_INCLUDE) $(VAR_SHARED_LIB_DIR) $(VAR_SHARED_LIBS)

clean:

rm -rf *.o *.bin

init.sh

export LD_LIBRARY_PATH=/home/mlinux/work/ffmpeg-2.7/ffmpeg-2.7.6/tmp/lib

看过前面文章的reader就应该知道，init.sh就是到处共享库的位置，让我们的可执行程序知道动态链接库的位置。

ffmpeg学习八：音频编码前奏-ubuntu下录音和播放

上一篇博客，我们把一个Yuv编码格式的视频文件编码为H264格式。那么接下来，自然要学习下音频编码了。在学习音频编码之前，我们先看看ubuntu下如何采集声音和播放声音。

录音

录制5秒钟的一段音频。

audio_recorder.c:

/*created by Jinwei Liu*/

#define ALSA_PCM_NEW_HW_PARAMS_API

#include <alsa/asoundlib.h>

int main(int argc,char **argv) {

long loops;

int rc;

int size;

snd_pcm_t *handle;

snd_pcm_hw_params_t *params;

unsigned int val;

int dir;

snd_pcm_uframes_t frames;

char *buffer;

FILE * fd_out;

if(argc!=2){

printf("usage:./a.out outfile\n");

}

/* Open PCM device for recording (capture). */

rc = snd_pcm_open(&handle, "default",

SND_PCM_STREAM_CAPTURE, 0);

if (rc < 0) {

fprintf(stderr,

"unable to open pcm device: %s\n",

snd_strerror(rc));

exit(1);

}

/* Allocate a hardware parameters object. */

snd_pcm_hw_params_alloca(&params);

/* Fill it in with default values. */

snd_pcm_hw_params_any(handle, params);

/* Set the desired hardware parameters. */

/* Interleaved mode */

snd_pcm_hw_params_set_access(handle, params,

SND_PCM_ACCESS_RW_INTERLEAVED);

/* Signed 16-bit little-endian format */

snd_pcm_hw_params_set_format(handle, params,

SND_PCM_FORMAT_S16_LE);

/* Two channels (stereo) */

snd_pcm_hw_params_set_channels(handle, params, 2);

/* 11025 bits/second sampling rate (CD quality) */

val = 11025;

snd_pcm_hw_params_set_rate_near(handle, params,

&val, &dir);

/* Set period size to 32 frames. */

//frames = 32;

// snd_pcm_hw_params_set_period_size_near(handle,

// params, &frames, &dir);

/* Write the parameters to the driver */

rc = snd_pcm_hw_params(handle, params);

if (rc < 0) {

fprintf(stderr,

"unable to set hw parameters: %s\n",

snd_strerror(rc));

exit(1);

}

/* Use a buffer large enough to hold one period */

snd_pcm_hw_params_get_period_size(params,

&frames, &dir);

size = frames * 4; /* 2 bytes/sample, 2 channels */

buffer = (char *) malloc(size);

/* We want to loop for 5 seconds */

snd_pcm_hw_params_get_period_time(params,

&val, &dir);

loops = 5000000 / val;

fd_out = fopen(argv[1],"w+");

while (loops > 0) {

loops--;

rc = snd_pcm_readi(handle, buffer, frames);

if (rc == -EPIPE) {

/* EPIPE means overrun */

fprintf(stderr, "overrun occurred\n");

snd_pcm_prepare(handle);

} else if (rc < 0) {

fprintf(stderr,

"error from read: %s\n",

snd_strerror(rc));

} else if (rc != (int)frames) {

fprintf(stderr, "short read, read %d frames\n", rc);

}

rc = fwrite(buffer,1, size,fd_out);

if (rc != size)

fprintf(stderr,

"short write: wrote %d bytes\n", rc);

}

fclose(fd_out);

snd_pcm_drain(handle);

snd_pcm_close(handle);

free(buffer);

return 0;

}

函数中已经有相关的注释了。录音可以认为有三部分组成：

第一：参数设置阶段。这一阶段需要设置波特率，帧率，通道数等。

第二：采集阶段。主要就是调用snd_pcm_readi都声音数据。

第三：保存阶段。把都出来的数据写入文件即可。

编译：

gcc -o recorder audio_recorder.c -lasound

运行：

./recorder audio.pcm

执行完成后生成audio.pcm文件。

播放原始音频数据

直接播放原始音频文件（注意，录制的参数和播放的参数要一致）

audio_palyer.c

/*created by Jinwei Liu*/

/* Use the newer ALSA API */

#define ALSA_PCM_NEW_HW_PARAMS_API

#include <alsa/asoundlib.h>

int main(int argc,char **argv) {

long loops;

int rc;

int size;

snd_pcm_t *handle;

snd_pcm_hw_params_t *params;

unsigned int val;

int dir;

snd_pcm_uframes_t frames;

char *buffer;

int fd;

/* Open PCM device for playback. */

rc = snd_pcm_open(&handle, "default",

SND_PCM_STREAM_PLAYBACK, 0);

if (rc < 0) {

fprintf(stderr,

"unable to open pcm device: %s\n",

snd_strerror(rc));

exit(1);

} else{

printf("open device sucess\n");

}

/* Allocate a hardware parameters object. */

snd_pcm_hw_params_alloca(&params);

/* Fill it in with default values. */

snd_pcm_hw_params_any(handle, params);

/* Set the desired hardware parameters. */

/* Interleaved mode */

snd_pcm_hw_params_set_access(handle, params,

SND_PCM_ACCESS_RW_INTERLEAVED);

/* Signed 16-bit little-endian format */

snd_pcm_hw_params_set_format(handle, params,

SND_PCM_FORMAT_S16_LE);

/* Two channels (stereo) */

snd_pcm_hw_params_set_channels(handle, params, 2);

/* 11025 bits/second sampling rate (CD quality) */

val = 11025;

snd_pcm_hw_params_set_rate_near(handle, params,

&val, &dir);

/* Set period size to 32 frames. */

// frames = 32;

// snd_pcm_hw_params_set_period_size_near(handle,

// params, &frames, &dir);

/* Write the parameters to the driver */

rc = snd_pcm_hw_params(handle, params);

if (rc < 0) {

fprintf(stderr,

"unable to set hw parameters: %s\n",

snd_strerror(rc));

exit(1);

}

/* Use a buffer large enough to hold one period */

snd_pcm_hw_params_get_period_size(params, &frames,

&dir);

printf("frames = %ld\n",frames);

size = frames * 4; /* 2 bytes/sample, 2 channels */

buffer = (char *) malloc(size);

/* We want to loop for 5 seconds */

snd_pcm_hw_params_get_period_time(params,

&val, &dir);

fd = open(argv[1],O_RDONLY);

if(fd<0){

printf("open error\n");

}

while (1) {

rc = read(fd, buffer, size);

if (rc == 0) {

fprintf(stderr, "end of file on input\n");

break;

} else if (rc != size) {

fprintf(stderr,

"short read: read %d bytes\n", rc);

}

while((rc = snd_pcm_writei(handle, buffer, frames)<0))

{

usleep(2000);

if (rc == -EPIPE)

{

/* EPIPE means underrun */

fprintf(stderr, "underrun occurred\n");

snd_pcm_prepare(handle);

}

else if (rc < 0)

{

fprintf(stderr,

"error from writei: %s\n",

snd_strerror(rc));

}

close(fd);

snd_pcm_drain(handle);

snd_pcm_close(handle);

free(buffer);

return 0;

}

函数中已经有相关的注释了。播放原始音频数据可以认为有三部分组成：

第一：参数设置阶段。这一阶段需要设置波特率，帧率，通道数等。

第二：读文件阶段。

第三：播放阶段。主要是snd_pcm_writei想pcm设备写入数据了。

编译：

gcc -o player audio_palyer.c -lasound

运行：

./player audio.pcm

播放的就是我们自己录制的音频数据，可以验证我们的录音程序是否正常。

播放wav格式的音频文件

这里要注意：wav是文件的格式,pcm是没有压缩的音频的编码格式。也就是说，一个是文件封装格式，一个是视频的编码格式，两个是有本质的区别的。在我们的例子中，wav文件的数据区，存储的正式pcm编码格式的音频数据。

头文件：palywav.h

#ifndef PLAY_WAV_H

#define PLAY_WAV_H

#include<stdio.h>

#include<stdlib.h>

#include <string.h>

#include "alsa/asoundlib.h"

struct WAV_HEADER

{

char rld[4]; //riff 标志符号

int rLen;

char wld[4]; //格式类型（wave）

char fld[4]; //"fmt"

int fLen; //sizeof(wave format matex)

short wFormatTag; //编码格式

short wChannels; //声道数

int nSamplesPersec ; //采样频率

int nAvgBitsPerSample;//WAVE文件采样大小

short wBlockAlign; //块对齐

short wBitsPerSample; //WAVE文件采样大小

char dld[4]; //”data“

int wSampleLength; //音频数据的大小

} ;

int set_pcm_play(char * filename);

#endif

源文件:playwav.c

#include "play_wav.h"

int set_pcm_play(char * filename)

{

int rc;

int ret;

int size;

snd_pcm_t* handle; //pcm文件句柄

snd_pcm_hw_params_t* params;//硬件参数结构体

unsigned int val;

int dir=0;

snd_pcm_uframes_t frames;

struct WAV_HEADER wav_header;

char *buffer;

int channels;

int frequency;

int bit;

int datablock;

int nread;

//unsigned char ch[100];

FILE *fp;

//首先打开wav文件

fp=fopen(filename,"rb");

if(fp==NULL)

{

perror("open file failed:\n");

exit(1);

}

//读取头部信息

nread=fread(&wav_header,1,sizeof(wav_header),fp);

printf("fread byte is:%d\n",nread);

//通过读取到的头部信息，初始化硬件参数

channels=wav_header.wChannels;

frequency=wav_header.nSamplesPersec;

bit=wav_header.wBitsPerSample;

datablock=wav_header.wBlockAlign;

//打开pcm设备

rc=snd_pcm_open(&handle, "default", SND_PCM_STREAM_PLAYBACK, 0);

if(rc<0)

{

perror("\nopen PCM device failed:");

exit(1);

}

//分配一个硬件参数结构体

snd_pcm_hw_params_alloca(&params);

if(rc<0)

{

perror("\nsnd_pcm_hw_params_alloca:");

exit(1);

}

//使用默认值初始化

rc=snd_pcm_hw_params_any(handle, params);

if(rc<0)

{

perror("\nsnd_pcm_hw_params_any:");

exit(1);

}

rc=snd_pcm_hw_params_set_access(handle, params, SND_PCM_ACCESS_RW_INTERLEAVED); //交错模式

if(rc<0)

{

perror("\nsed_pcm_hw_set_access:");

exit(1);

}

//选择音频数据格式。

switch(bit/8)

{

case 1:snd_pcm_hw_params_set_format(handle, params, SND_PCM_FORMAT_U8);

break ;

case 2:snd_pcm_hw_params_set_format(handle, params, SND_PCM_FORMAT_S16_LE);

break ;

case 3:snd_pcm_hw_params_set_format(handle, params, SND_PCM_FORMAT_S24_LE);

break ;

}

rc=snd_pcm_hw_params_set_channels(handle, params, channels); //设置通道数

if(rc<0)

{

perror("\nsnd_pcm_hw_params_set_channels:");

exit(1);

}

val = frequency;

rc=snd_pcm_hw_params_set_rate_near(handle, params, &val, &dir); //设置比特率

if(rc<0)

{

perror("\nsnd_pcm_hw_params_set_rate_near:");

exit(1);

}

//设置硬件参数

rc = snd_pcm_hw_params(handle, params);

if(rc<0)

{

perror("\nsnd_pcm_hw_params: ");

exit(1);

}

//获取帧率

rc=snd_pcm_hw_params_get_period_size(params, &frames, &dir);

if(rc<0)

{

perror("\nsnd_pcm_hw_params_get_period_size:");

exit(1);

}

//通过帧率计算缓冲区的大小

size = frames * datablock;

buffer =(char*)malloc(size);

fseek(fp,58,SEEK_SET); //定位到数据区

//一下的循环就是不断的从数据区读数据出来，然后写入pcm设备中，从而播放出来

while (1)

{

memset(buffer,0,sizeof(buffer));

ret = fread(buffer, 1, size, fp);

if(ret == 0)

{

printf("song write in completed\n");

break;

}

else if (ret != size)

{

}

while((ret = snd_pcm_writei(handle, buffer, frames)<0))

{

usleep(2000);

if (ret == -EPIPE)

{

/* EPIPE means underrun */

fprintf(stderr, "underrun occurred\n");

snd_pcm_prepare(handle);

}

else if (ret < 0)

{

fprintf(stderr,

"error from writei: %s\n",

snd_strerror(ret));

}

fclose(fp);

snd_pcm_drain(handle);

snd_pcm_close(handle);

free(buffer);

return 0;

}

int main(int argc,char **argv){

if(argc !=2){

printf("usage:./playwav xxx.wav");

return -1;

}

set_pcm_play(argv[1]);

return 0;

}

函数中已经有相关的注释了。播放wav可以认为有四部分组成：

第一：解析文件头。

第二：参数设置阶段。这一阶段需要通过解析文件头得到的信息，来设置波特率，帧率，通道数等。

第二：读音频数据阶段。

第三：播放阶段。主要是snd_pcm_writei想pcm设备写入数据了。

编译：

gcc play_wav.c -lasound

执行：

./a.out song.wav

ffmpeg学习七：软件生成yuv420p视频并将其编码为H264格式

通过前面对ffmpeg中常用的几个api的源码分析，从而对api有了更好的理解。之前已经做过视频的解码了，今天来尝试视频的编码。ffmpeg已经给我们提供了相应的可供参考的程序：doc/examples/decoding_encoding.c文件就是解码和编码的例程。仔细阅读它的代码后，我们可以按照自己的理解，写自己的视频编码程序。我们将会把一个yuv420p格式的文件，使用h264编码器进行编码。

生成yuv视频

yuv图像的格式，可以参考这篇博客：图文详解YUV420数据格式。

如果你读yuv格式有所了解，或者认真阅读了上面的博客，那么阅读下面的代码就非常容易了。它的功能就是生成一个有200帧的yuv视频。

//created by Jinwei Liu

#include <math.h>

#include <stdlib.h>

#include <libavutil/opt.h>

#include <libavcodec/avcodec.h>

#include <libavutil/channel_layout.h>

#include <libavutil/common.h>

#include <libavutil/imgutils.h>

#include <libavutil/mathematics.h>

#include <libavutil/samplefmt.h>

#include <libavformat/avformat.h>

#include <libswscale/swscale.h>

int main(int argc, char **argv)

{

AVFrame *frame;

int i,x,y;

/* register all the codecs */

av_register_all();

if(argc!=3)

printf("usage:./encodec.bin widht height\n");

frame = av_frame_alloc();

frame->width = atoi(argv[1]);

frame->height = atoi(argv[2]);

av_image_alloc(frame->data,frame->linesize,frame->width,frame->height,AV_PIX_FMT_YUV420P,32);

FILE * file_fd =fopen("soft.yuv","wb+");

for (i = 0; i < 200; i++) {

/* prepare a dummy image */

/* Y */

for (y = 0; y < frame->height; y++) {

for (x = 0; x < frame->width; x++) {

frame->data[0][y * frame->linesize[0] + x] = (x + y + i * 3)%256;

}

/* Cb and Cr */

for (y = 0; y < frame->height/2; y++) {

for (x = 0; x < frame->width/2; x++) {

frame->data[1][y * frame->linesize[1] + x] = (128 + y + i * 2)%256;

frame->data[2][y * frame->linesize[2] + x] = (64 + x + i * 5)%256;

}

fwrite(frame->data[0],1,frame->linesize[0]*frame->height,file_fd);

fwrite(frame->data[1],1,frame->linesize[1]*frame->height/2,file_fd);

fwrite(frame->data[2],1,frame->linesize[2]*frame->height/2,file_fd);

}

fclose(file_fd);

av_freep(frame->data);

av_free(frame);

return 0;

}

注意：这里标示一行图像宽度的时linesize，这个时候，播放会有问题。其生成的数据格式如下：

因此，我们要注意frame->width和frame->linesize的区别。使用linesize时，生成的数据有一些边界数据。不过这样的生成的yuv格式的数据也是可以播的，要注意使用的一帧图像的宽度位linesize，所以命令如下：

./encodec.bin 300 200

播放生成的yuv视频：

ffplay -f rawvideo -s 320x200 soft.yuv

将其转换为gif格式：

ffmpeg -f rawvideo -s 320x200 -i soft.yuv soft.gif

为什么时320而不是其他置呢？这个我也是通过打印frame->linesize[0]得知的，因为这个值时ffmpeg计算得出的，所以想知道这个值为什么是320的需要阅读相应的源码。

如果我们想得到没有无效数据的yuv视频，那就不要使用frame->linesize，而是直接使用frame->width。像下面这样：

for (i = 0; i < 200; i++) {

/* prepare a dummy image */

/* Y */

for (y = 0; y < frame->height; y++) {

for (x = 0; x < frame->width; x++) {

frame->data[0][y * frame->width + x] = (x + y + i * 3)%255;

}

/* Cb and Cr */

for (y = 0; y < frame->height/2; y++) {

for (x = 0; x < frame->width/2; x++) {

frame->data[1][y * frame->width/2 + x] = (y + y + i * 2)%255;

frame->data[2][y * frame->width/2 + x] = (x + x + i * 5)%255;

}

//以上就是软件生成一帧的yuv格式的图像。

fwrite(frame->data[0],1,frame->width*frame->height,file_fd);

fwrite(frame->data[1],1,frame->width*frame->height/4,file_fd);

fwrite(frame->data[2],1,frame->width*frame->height/4,file_fd);

//写入到文件，我们保存的格式为yuv420p而不是420sp。

}

以上程序，我们通篇使用的视频的宽度frame->width来表示，这样生成的yuv数据没有边界数据。

编译完成后执行可执行文件：

./encodec.bin 300 200

播放生成的yuv视频：

ffplay -f rawvideo -s 300x200 soft.yuv

将其转换为gif格式：

ffmpeg -f rawvideo -s 300x200 -i soft.yuv soft.gif

生成的gif如下：

接下来，我们把生成的这个Yuv视频编码成h.264格式（我们使用的yuv是使用frame->linesize来标示视频宽度的）。

yuv编码为h.264

程序如下，代码中已有详细注释。

//created by Jinwei Liu

#include <math.h>

#include <stdlib.h>

#include <libavutil/opt.h>

#include <libavcodec/avcodec.h>

#include <libavutil/channel_layout.h>

#include <libavutil/common.h>

#include <libavutil/imgutils.h>

#include <libavutil/mathematics.h>

#include <libavutil/samplefmt.h>

#include <libavutil/frame.h>

#include <libavformat/avformat.h>

#include <libswscale/swscale.h>

int main(int argc, char **argv)

{

AVFrame *frame;

AVCodec *codec = NULL;

AVPacket packet;

AVCodecContext *codecContext;

int readSize=0;

int ret=0,getPacket;

FILE * fileIn,*fileOut;

int frameCount=0;

/* register all the codecs */

av_register_all();

if(argc!=4){

fprintf(stdout,"usage:./encodec.bin xxx.yuv width height\n");

return -1;

}

//1.我们需要读一帧一帧的数据，所以需要AVFrame结构

//读出的一帧数据保存在AVFrame中。

frame = av_frame_alloc();

frame->width = atoi(argv[2]);

frame->height = atoi(argv[3]);

fprintf(stdout,"width=%d,height=%d\n",frame->width,frame->height);

frame->format = AV_PIX_FMT_YUV420P;

av_image_alloc(frame->data,frame->linesize,frame->width,frame->height,frame->format,32);

fileIn =fopen(argv[1],"r+");

//2.读出来的数据保存在AVPacket中，因此，我们还需要AVPacket结构体

//初始化packet

av_init_packet(&packet);

//3.读出来的数据，我们需要编码，因此需要编码器

//下面的函数找到h.264类型的编码器

/* find the mpeg1 video encoder */

codec = avcodec_find_encoder(AV_CODEC_ID_H264);

if (!codec) {

fprintf(stderr, "Codec not found\n");

exit(1);

}

//有了编码器，我们还需要编码器的上下文环境，用来控制编码的过程

codecContext = avcodec_alloc_context3(codec);//分配AVCodecContext实例

if (!codecContext)

{

fprintf(stderr, "Could not allocate video codec context\n");

return -1;

}

/* put sample parameters */

codecContext->bit_rate = 400000;

/* resolution must be a multiple of two */

codecContext->width = 300;

codecContext->height = 200;

/* frames per second */

codecContext->time_base = (AVRational){1,25};

/* emit one intra frame every ten frames

* check frame pict_type before passing frame

* to encoder, if frame->pict_type is AV_PICTURE_TYPE_I

* then gop_size is ignored and the output of encoder

* will always be I frame irrespective to gop_size

codecContext->gop_size = 10;

codecContext->max_b_frames = 1;

codecContext->pix_fmt = AV_PIX_FMT_YUV420P;

av_opt_set(codecContext->priv_data, "preset", "slow", 0);

//准备好了编码器和编码器上下文环境，现在可以打开编码器了

if (avcodec_open2(codecContext, codec, NULL) < 0) //根据编码器上下文打开编码器

{

fprintf(stderr, "Could not open codec\n");

return -1;

}

//4.准备输出文件

fileOut= fopen("test.h264","w+");

//下面开始编码

while(1){

//读一帧数据出来

readSize = fread(frame->data[0],1,frame->linesize[0]*frame->height,fileIn);

if(readSize == 0){

fprintf(stdout,"end of file\n");

frameCount++;

break;

}

readSize = fread(frame->data[1],1,frame->linesize[1]*frame->height/2,fileIn);

readSize = fread(frame->data[2],1,frame->linesize[2]*frame->height/2,fileIn);

//初始化packet

av_init_packet(&packet);

/* encode the image */

frame->pts = frameCount;

ret = avcodec_encode_video2(codecContext, &packet, frame, &getPacket); //将AVFrame中的像素信息编码为AVPacket中的码流

if (ret < 0)

{

fprintf(stderr, "Error encoding frame\n");

return -1;

}

if (getPacket)

{

frameCount++;

//获得一个完整的编码帧

printf("Write frame %3d (size=%5d)\n", frameCount, packet.size);

fwrite(packet.data, 1,packet.size, fileOut);

av_packet_unref(&packet);

}

/* flush buffer */

for ( getPacket= 1; getPacket; frameCount++)

{

fflush(stdout);

frame->pts = frameCount;

ret = avcodec_encode_video2(codecContext, &packet, NULL, &getPacket); //输出编码器中剩余的码流

if (ret < 0)

{

fprintf(stderr, "Error encoding frame\n");

return -1;

}

if (getPacket)

{

printf("Write frame %3d (size=%5d)\n", frameCount, packet.size);

fwrite(packet.data, 1, packet.size, fileOut);

av_packet_unref(&packet);

}

} //for (got_output = 1; got_output; frameIdx++)

fclose(fileIn);

fclose(fileOut);

av_frame_free(&frame);

avcodec_close(codecContext);

av_free(codecContext);

return 0;

}

编译代码后，执行发现，找不好解码器…什么情况呢？google了一下，原来ffmpeg支持h.264编码器需要相应库的支持，我的系统没有安装这个库，因此编译ffmpeg的时候，ffmpeg检测到没有这个库，所以就不会编译h.264相关的模块。

因此，我们需要安装libx264库，执行命令如下：

sudo apt-get install libx264-dev

安装好以后，需要重新编译ffmpeg库。

1.执行

./configure –enable-libx264 –enable-gpl –enable-decoder=h264 –enable-encoder=libx264 –enable-shared –enable-static –disable-yasm –enable-shared –prefix=tmp

2.make

3.make install

这样配置的ffmpeg就开始支持h264编解码器了。

然后重新编译我们代码，编译完成后使用案例如下：

首先进行编码：

./encodech264.bin soft.yuv 300 200

程序会生成test.h264文件，我们可以播放来看：

ffplay test.h264

ffmpeg学习六：avformat_find_stream_info函数解析

前面两篇文章分析avformat_open_input和avcodec_open2两个函数，我们所做的函数分析工作都是为了能够很好的理解前面一篇博客：ffmpeg学习四：写第一个程序-视频解码中所给的视频解码的程序。avformat_find_stream_info函数也是视频解码程序中必须要有的函数，因此这篇文章主要来分析这个函数。

一、功能简介

先看看avformat_find_stream_info函数的注释：

/**

* Read packets of a media file to get stream information. This

* is useful for file formats with no headers such as MPEG. This

* function also computes the real framerate in case of MPEG-2 repeat

* frame mode.

* The logical file position is not changed by this function;

* examined packets may be buffered for later processing.

* @param ic media file handle

* @param options If non-NULL, an ic.nb_streams long array of pointers to

* dictionaries, where i-th member contains options for

* codec corresponding to i-th stream.

* On return each dictionary will be filled with options that were not found.

* @return >=0 if OK, AVERROR_xxx on error

* @note this function isn't guaranteed to open all the codecs, so

* options being non-empty at return is a perfectly normal behavior.

* @todo Let the user decide somehow what information is needed so that

* we do not waste time getting stuff the user does not need.

int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options);

从注释来看，avformat_find_stream_info主要是读一些包（packets ），然后从中提取初流的信息。有一些文件格式没有头，比如说MPEG格式的，这个时候，这个函数就很有用，因为它可以从读取到的包中获得到流的信息。在MPEG-2重复帧模式的情况下，该函数还计算真实的帧率。

逻辑文件位置不被此函数更改; 读出来的包会被缓存起来供以后处理。

注释很好的解释了这个函数的功能。我们可以想象一下，既然这个函数的功能是更新流的信息，那么可以猜测它的作用就是更新AVStream这个结构体中的字段了。我们先浏览下这个结构体：

二、AVStream结构体解析

/**

* Stream structure.

* New fields can be added to the end with minor version bumps.

* Removal, reordering and changes to existing fields require a major

* version bump.

* sizeof(AVStream) must not be used outside libav*.

typedef struct AVStream {

int index; /**< stream index in AVFormatContext */

/**

* Format-specific stream ID.

* decoding: set by libavformat

* encoding: set by the user, replaced by libavformat if left unset

int id;

#if FF_API_LAVF_AVCTX

/**

* @deprecated use the codecpar struct instead

attribute_deprecated

AVCodecContext *codec;

#endif

void *priv_data;

#if FF_API_LAVF_FRAC

/**

* @deprecated this field is unused

attribute_deprecated

struct AVFrac pts;

#endif

/**

* This is the fundamental unit of time (in seconds) in terms

* of which frame timestamps are represented.

* decoding: set by libavformat

* encoding: May be set by the caller before avformat_write_header() to

* provide a hint to the muxer about the desired timebase. In

* avformat_write_header(), the muxer will overwrite this field

* with the timebase that will actually be used for the timestamps

* written into the file (which may or may not be related to the

* user-provided one, depending on the format).

AVRational time_base;

/**

* Decoding: pts of the first frame of the stream in presentation order, in stream time base.

* Only set this if you are absolutely 100% sure that the value you set

* it to really is the pts of the first frame.

* This may be undefined (AV_NOPTS_VALUE).

* @note The ASF header does NOT contain a correct start_time the ASF

* demuxer must NOT set this.

int64_t start_time;

/**

* Decoding: duration of the stream, in stream time base.

* If a source file does not specify a duration, but does specify

* a bitrate, this value will be estimated from bitrate and file size.

int64_t duration;

int64_t nb_frames; ///< number of frames in this stream if known or 0

int disposition; /**< AV_DISPOSITION_* bit field */

enum AVDiscard discard; ///< Selects which packets can be discarded at will and do not need to be demuxed.

/**

* sample aspect ratio (0 if unknown)

* - encoding: Set by user.

* - decoding: Set by libavformat.

AVRational sample_aspect_ratio;

AVDictionary *metadata;

/**

* Average framerate

* - demuxing: May be set by libavformat when creating the stream or in

* avformat_find_stream_info().

* - muxing: May be set by the caller before avformat_write_header().

AVRational avg_frame_rate;

/**

* For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet

* will contain the attached picture.

* decoding: set by libavformat, must not be modified by the caller.

* encoding: unused

AVPacket attached_pic;

/**

* An array of side data that applies to the whole stream (i.e. the

* container does not allow it to change between packets).

* There may be no overlap between the side data in this array and side data

* in the packets. I.e. a given side data is either exported by the muxer

* (demuxing) / set by the caller (muxing) in this array, then it never

* appears in the packets, or the side data is exported / sent through

* the packets (always in the first packet where the value becomes known or

* changes), then it does not appear in this array.

* - demuxing: Set by libavformat when the stream is created.

* - muxing: May be set by the caller before avformat_write_header().

* Freed by libavformat in avformat_free_context().

* @see av_format_inject_global_side_data()

AVPacketSideData *side_data;

/**

* The number of elements in the AVStream.side_data array.

int nb_side_data;

/**

* Flags for the user to detect events happening on the stream. Flags must

* be cleared by the user once the event has been handled.

* A combination of AVSTREAM_EVENT_FLAG_*.

int event_flags;

#define AVSTREAM_EVENT_FLAG_METADATA_UPDATED 0x0001 ///< The call resulted in updated metadata.

/*****************************************************************

* All fields below this line are not part of the public API. They

* may not be used outside of libavformat and can be changed and

* removed at will.

* New public fields should be added right above.

*****************************************************************

/**

* Stream information used internally by av_find_stream_info()

#define MAX_STD_TIMEBASES (30*12+30+3+6)

struct {

int64_t last_dts;

int64_t duration_gcd;

int duration_count;

int64_t rfps_duration_sum;

double (*duration_error)[2][MAX_STD_TIMEBASES];

int64_t codec_info_duration;

int64_t codec_info_duration_fields;

/**

* 0 -> decoder has not been searched for yet.

* >0 -> decoder found

* <0 -> decoder with codec_id == -found_decoder has not been found

int found_decoder;

int64_t last_duration;

/**

* Those are used for average framerate estimation.

int64_t fps_first_dts;

int fps_first_dts_idx;

int64_t fps_last_dts;

int fps_last_dts_idx;

} *info;

int pts_wrap_bits; /**< number of bits in pts (used for wrapping control) */

// Timestamp generation support:

/**

* Timestamp corresponding to the last dts sync point.

* Initialized when AVCodecParserContext.dts_sync_point >= 0 and

* a DTS is received from the underlying container. Otherwise set to

* AV_NOPTS_VALUE by default.

int64_t first_dts;

int64_t cur_dts;

int64_t last_IP_pts;

int last_IP_duration;

/**

* Number of packets to buffer for codec probing

int probe_packets;

/**

* Number of frames that have been demuxed during av_find_stream_info()

int codec_info_nb_frames;

/* av_read_frame() support */

enum AVStreamParseType need_parsing;

struct AVCodecParserContext *parser;

/**

* last packet in packet_buffer for this stream when muxing.

struct AVPacketList *last_in_packet_buffer;

AVProbeData probe_data;

#define MAX_REORDER_DELAY 16

int64_t pts_buffer[MAX_REORDER_DELAY+1];

AVIndexEntry *index_entries; /**< Only used if the format does not

support seeking natively. */

int nb_index_entries;

unsigned int index_entries_allocated_size;

/**

* Real base framerate of the stream.

* This is the lowest framerate with which all timestamps can be

* represented accurately (it is the least common multiple of all

* framerates in the stream). Note, this value is just a guess!

* For example, if the time base is 1/90000 and all frames have either

* approximately 3600 or 1800 timer ticks, then r_frame_rate will be 50/1.

* Code outside avformat should access this field using:

* av_stream_get/set_r_frame_rate(stream)

AVRational r_frame_rate;

/**

* Stream Identifier

* This is the MPEG-TS stream identifier +1

* 0 means unknown

int stream_identifier;

int64_t interleaver_chunk_size;

int64_t interleaver_chunk_duration;

/**

* stream probing state

* -1 -> probing finished

* 0 -> no probing requested

* rest -> perform probing with request_probe being the minimum score to accept.

* NOT PART OF PUBLIC API

int request_probe;

/**

* Indicates that everything up to the next keyframe

* should be discarded.

int skip_to_keyframe;

/**

* Number of samples to skip at the start of the frame decoded from the next packet.

int skip_samples;

/**

* If not 0, the number of samples that should be skipped from the start of

* the stream (the samples are removed from packets with pts==0, which also

* assumes negative timestamps do not happen).

* Intended for use with formats such as mp3 with ad-hoc gapless audio

* support.

int64_t start_skip_samples;

/**

* If not 0, the first audio sample that should be discarded from the stream.

* This is broken by design (needs global sample count), but can't be

* avoided for broken by design formats such as mp3 with ad-hoc gapless

* audio support.

int64_t first_discard_sample;

/**

* The sample after last sample that is intended to be discarded after

* first_discard_sample. Works on frame boundaries only. Used to prevent

* early EOF if the gapless info is broken (considered concatenated mp3s).

int64_t last_discard_sample;

/**

* Number of internally decoded frames, used internally in libavformat, do not access

* its lifetime differs from info which is why it is not in that structure.

int nb_decoded_frames;

/**

* Timestamp offset added to timestamps before muxing

* NOT PART OF PUBLIC API

int64_t mux_ts_offset;

/**

* Internal data to check for wrapping of the time stamp

int64_t pts_wrap_reference;

/**

* Options for behavior, when a wrap is detected.

* Defined by AV_PTS_WRAP_ values.

* If correction is enabled, there are two possibilities:

* If the first time stamp is near the wrap point, the wrap offset

* will be subtracted, which will create negative time stamps.

* Otherwise the offset will be added.

int pts_wrap_behavior;

/**

* Internal data to prevent doing update_initial_durations() twice

int update_initial_durations_done;

/**

* Internal data to generate dts from pts

int64_t pts_reorder_error[MAX_REORDER_DELAY+1];

uint8_t pts_reorder_error_count[MAX_REORDER_DELAY+1];

/**

* Internal data to analyze DTS and detect faulty mpeg streams

int64_t last_dts_for_order_check;

uint8_t dts_ordered;

uint8_t dts_misordered;

/**

* Internal data to inject global side data

int inject_global_side_data;

/**

* String containing paris of key and values describing recommended encoder configuration.

* Paris are separated by ','.

* Keys are separated from values by '='.

char *recommended_encoder_configuration;

/**

* display aspect ratio (0 if unknown)

* - encoding: unused

* - decoding: Set by libavformat to calculate sample_aspect_ratio internally

AVRational display_aspect_ratio;

struct FFFrac *priv_pts;

/**

* An opaque field for libavformat internal usage.

* Must not be accessed in any way by callers.

AVStreamInternal *internal;

* Codec parameters associated with this stream. Allocated and freed by

* libavformat in avformat_new_stream() and avformat_free_context()

* respectively.

* - demuxing: filled by libavformat on stream creation or in

* avformat_find_stream_info()

* - muxing: filled by the caller before avformat_write_header()

AVCodecParameters *codecpar;

} AVStream;

int index：该流的标示。

AVCodecContext *codec：该流的编解码器上下文。

AVRational time_base：时基。通过该值可以把PTS，DTS转化为真正的时间。FFMPEG其他结构体中也有这个字段，但是根据我的经验，只有AVStream中的time_base是可用的。PTS*time_base=真正的时间

start_time：流中第一个pts的时间。

nb_frames：这个流中的帧的数目。

AVRational avg_frame_rate;平均帧率。

int64_t duration：该流的时间长度

AVDictionary *metadata：元数据信息

AVPacket attached_pic：附带的图片。比如说一些MP3，AAC音频文件附带的专辑封面。

重要的数据结构框图如下：

下面来看这个函数的代码，源码在libavformat/utils.c文件中。

这个函数非常的长，我们分开来看.

三、函数源码分析

part 1 参数定义

int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)

{

int i, count = 0, ret = 0, j;

int64_t read_size;

AVStream *st;

AVCodecContext *avctx;

AVPacket pkt1, *pkt;

int64_t old_offset = avio_tell(ic->pb);

// new streams might appear, no options for those

int orig_nb_streams = ic->nb_streams;

int flush_codecs;

int64_t max_analyze_duration = ic->max_analyze_duration;

int64_t max_stream_analyze_duration;

int64_t max_subtitle_analyze_duration;

int64_t probesize = ic->probesize;

int eof_reached = 0;

flush_codecs = probesize > 0;

...

这里定义了一些参数：

probesize就是探测的大小，为了获得流的信息，这个函数会尝试的读一些包出来，然后分析这些数据，probesize限制了最大允许读出的数据的大小。

orig_nb_streams是这个文件中的流的数量。普通的电影会包含三个流：音频流，视频流和字幕流。

接着往下看。

part 2 设置max_stream_analyze_duration 等

max_stream_analyze_duration = max_analyze_duration;

max_subtitle_analyze_duration = max_analyze_duration;

if (!max_analyze_duration) {

max_stream_analyze_duration =

max_analyze_duration = 5*AV_TIME_BASE;

max_subtitle_analyze_duration = 30*AV_TIME_BASE;

if (!strcmp(ic->iformat->name, "flv"))

max_stream_analyze_duration = 90*AV_TIME_BASE;

if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))

max_stream_analyze_duration = 7*AV_TIME_BASE;

}

这里定义了最大分析时长的限制。max_stream_analyze_duration 等于max_analyze_duration 等于30倍的timebase。此外，如果文件格式为flv或者Mpeg，那么他们会有各自的最大分析时长的限制。

继续往下看：

part 3 第一次遍历流

for (i = 0; i < ic->nb_streams; i++) {

const AVCodec *codec;

AVDictionary *thread_opt = NULL;

st = ic->streams[i];

avctx = st->internal->avctx;

if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||

st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {

/* if (!st->time_base.num)

st->time_base = */

if (!avctx->time_base.num)

avctx->time_base = st->time_base;

}

/* check if the caller has overridden the codec id */

#if FF_API_LAVF_AVCTX

FF_DISABLE_DEPRECATION_WARNINGS

if (st->codec->codec_id != st->internal->orig_codec_id) {

st->codecpar->codec_id = st->codec->codec_id;

st->codecpar->codec_type = st->codec->codec_type;

st->internal->orig_codec_id = st->codec->codec_id;

}

FF_ENABLE_DEPRECATION_WARNINGS

#endif

// only for the split stuff

if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {

st->parser = av_parser_init(st->codecpar->codec_id);

if (st->parser) {

if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {

st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;

} else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {

st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;

}

} else if (st->need_parsing) {

av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "

"%s, packets or times may be invalid.\n",

avcodec_get_name(st->codecpar->codec_id));

}

if (st->codecpar->codec_id != st->internal->orig_codec_id)

st->internal->orig_codec_id = st->codecpar->codec_id;

ret = avcodec_parameters_to_context(avctx, st->codecpar);

if (ret < 0)

goto find_stream_info_err;

if (st->request_probe <= 0)

st->internal->avctx_inited = 1;

codec = find_probe_decoder(ic, st, st->codecpar->codec_id);

/* Force thread count to 1 since the H.264 decoder will not extract

* SPS and PPS to extradata during multi-threaded decoding. */

av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);

if (ic->codec_whitelist)

av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);

/* Ensure that subtitle_header is properly set. */

if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE

&& codec && !avctx->codec) {

if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)

av_log(ic, AV_LOG_WARNING,

"Failed to open codec in av_find_stream_info\n");

}

// Try to just open decoders, in case this is enough to get parameters.

if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {

if (codec && !avctx->codec)

if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)

av_log(ic, AV_LOG_WARNING,

"Failed to open codec in av_find_stream_info\n");

}

if (!options)

av_dict_free(&thread_opt);

}

这个函数有很多次遍历流的循环，这里是第一次。第一次循环做了如下事情：

1.获得编码器上下文环境avctx，设置avctx的time_base,code_id,codec_type,orig_codec_id。

2.如果解析器paser为空，那么会初始化解析器。

3.把解析器中的参数对应的拷贝到编解码器上下文环境中。调用的是avcodec_parameters_to_context函数，这个函数如下：

int avcodec_parameters_to_context(AVCodecContext *codec,

const AVCodecParameters *par)

{

codec->codec_type = par->codec_type;

codec->codec_id = par->codec_id;

codec->codec_tag = par->codec_tag;

codec->bit_rate = par->bit_rate;

codec->bits_per_coded_sample = par->bits_per_coded_sample;

codec->bits_per_raw_sample = par->bits_per_raw_sample;

codec->profile = par->profile;

codec->level = par->level;

switch (par->codec_type) {

case AVMEDIA_TYPE_VIDEO:

codec->pix_fmt = par->format;

codec->width = par->width;

codec->height = par->height;

codec->field_order = par->field_order;

codec->color_range = par->color_range;

codec->color_primaries = par->color_primaries;

codec->color_trc = par->color_trc;

codec->colorspace = par->color_space;

codec->chroma_sample_location = par->chroma_location;

codec->sample_aspect_ratio = par->sample_aspect_ratio;

codec->has_b_frames = par->video_delay;

break;

case AVMEDIA_TYPE_AUDIO:

codec->sample_fmt = par->format;

codec->channel_layout = par->channel_layout;

codec->channels = par->channels;

codec->sample_rate = par->sample_rate;

codec->block_align = par->block_align;

codec->frame_size = par->frame_size;

codec->delay =

codec->initial_padding = par->initial_padding;

codec->trailing_padding = par->trailing_padding;

codec->seek_preroll = par->seek_preroll;

break;

case AVMEDIA_TYPE_SUBTITLE:

codec->width = par->width;

codec->height = par->height;

break;

}

可见就是根据编码器类型做对应的参数的拷贝。

4根据编码器ID查找编码器.

这里调用的是find_probe_decoder函数，该函数也定义在libavformat/utils.c中。可以看一下查找编解码器的过程：

static const AVCodec *find_probe_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)

{

const AVCodec *codec;

#if CONFIG_H264_DECODER

/* Other parts of the code assume this decoder to be used for h264,

* so force it if possible. */

if (codec_id == AV_CODEC_ID_H264)

return avcodec_find_decoder_by_name("h264");

#endif

codec = find_decoder(s, st, codec_id);

if (!codec)

return NULL;

if (codec->capabilities & AV_CODEC_CAP_AVOID_PROBING) {

const AVCodec *probe_codec = NULL;

while (probe_codec = av_codec_next(probe_codec)) {

if (probe_codec->id == codec_id &&

av_codec_is_decoder(probe_codec) &&

!(probe_codec->capabilities & (AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_EXPERIMENTAL))) {

return probe_codec;

}

return codec;

}

调用find_decoder函数进一步查找：

static const AVCodec *find_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)

{

#if FF_API_LAVF_AVCTX

FF_DISABLE_DEPRECATION_WARNINGS

if (st->codec->codec)

return st->codec->codec;

FF_ENABLE_DEPRECATION_WARNINGS

#endif

switch (st->codecpar->codec_type) {

case AVMEDIA_TYPE_VIDEO:

if (s->video_codec) return s->video_codec;

break;

case AVMEDIA_TYPE_AUDIO:

if (s->audio_codec) return s->audio_codec;

break;

case AVMEDIA_TYPE_SUBTITLE:

if (s->subtitle_codec) return s->subtitle_codec;

break;

}

return avcodec_find_decoder(codec_id);

}

如果编码器已经存在就根据编码器类型返回对应的编解码器，否则就根据id进行查找。avcodec_find_decoder函数还是在utils.c文件中：

AVCodec *avcodec_find_decoder(enum AVCodecID id)

{

return find_encdec(id, 0);

}

find_encdec函数也是在utils.c文件中：

static AVCodec *find_encdec(enum AVCodecID id, int encoder)

{

AVCodec *p, *experimental = NULL;

p = first_avcodec;

id= remap_deprecated_codec_id(id);

while (p) {

if ((encoder ? av_codec_is_encoder(p) : av_codec_is_decoder(p)) &&

p->id == id) {

if (p->capabilities & AV_CODEC_CAP_EXPERIMENTAL && !experimental) {

experimental = p;

} else

return p;

}

p = p->next;

}

return experimental;

}

函数的功能就是遍历一个编解码器的链表，其首个结构是first_avcodec。编解码器链表是我们在av_register_all()函数中注册的。这个逐个匹配每一个编解码器的id，找到后返回对应的编解码器。

5.打开编解码器

打开使用的是avcodec_open2函数。这个函数我们在前一篇博客ffmpeg学习六：avcodec_open2函数源码分析一文中已经分析过了。

所以我们可以总结下第一次遍历所有的流所做的事情：初始化time_base,codec_id等参数，初始化解析器paser,然后对于每一个流，根据codec_id找对对应的编解码器，然后打开编解码器。也就是说，第一次遍历流，使得我们对于每一个流，都有一个编解码器可用。

part 4 第二次遍历流

for (i = 0; i < ic->nb_streams; i++) {

#if FF_API_R_FRAME_RATE

ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;

#endif

ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;

ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;

}

第二次遍历流是在编解码器已经打开之后，对于每一个流，设置了一些参数。last_dts 是最有的解码时间。fps_first_dts和fps_last_dts 用于帧率的计算。

part 5 死循环

接下来的这个死循环代码很长。我们回顾一下之前的工作，我们遍历了两次流，设置好了每个流需要的编解码器和计算帧率的参数，初始化了每个流的解析器paser。在介绍这个函数的功能的时候，我们说这个函数会尝试的读一些数据进来，并解析这些数据，从这些数据中进一步获得详细的流的信息。到目前为止我们并没有读任何数据进来，那么接下来，想必就是读数据进来并解码分析数据流了吧。

read_size = 0;

for (;;) {

int analyzed_all_streams;

if (ff_check_interrupt(&ic->interrupt_callback)) {

ret = AVERROR_EXIT;

av_log(ic, AV_LOG_DEBUG, "interrupted\n");

break;

}

/* check if one codec still needs to be handled */

for (i = 0; i < ic->nb_streams; i++) {

int fps_analyze_framecount = 20;

st = ic->streams[i];

if (!has_codec_parameters(st, NULL))

break;

/* If the timebase is coarse (like the usual millisecond precision

* of mkv), we need to analyze more frames to reliably arrive at

* the correct fps. */

if (av_q2d(st->time_base) > 0.0005)

fps_analyze_framecount *= 2;

if (!tb_unreliable(st->internal->avctx))

fps_analyze_framecount = 0;

if (ic->fps_probe_size >= 0)

fps_analyze_framecount = ic->fps_probe_size;

if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)

fps_analyze_framecount = 0;

/* variable fps and no guess at the real fps */

if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&

st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {

int count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?

st->info->codec_info_duration_fields/2 :

st->info->duration_count;

if (count < fps_analyze_framecount)

break;

}

if (st->parser && st->parser->parser->split &&

!st->internal->avctx->extradata)

break;

if (st->first_dts == AV_NOPTS_VALUE &&

!(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&

st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&

(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||

st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))

break;

}

analyzed_all_streams = 0;

if (i == ic->nb_streams) {

analyzed_all_streams = 1;

/* NOTE: If the format has no header, then we need to read some

* packets to get most of the streams, so we cannot stop here. */

if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {

/* If we found the info for all the codecs, we can stop. */

ret = count;

av_log(ic, AV_LOG_DEBUG, "All info found\n");

flush_codecs = 0;

break;

}

/* We did not get all the codec info, but we read too much data. */

if (read_size >= probesize) {

ret = count;

av_log(ic, AV_LOG_DEBUG,

"Probe buffer size limit of %"PRId64" bytes reached\n", probesize);

for (i = 0; i < ic->nb_streams; i++)

if (!ic->streams[i]->r_frame_rate.num &&

ic->streams[i]->info->duration_count <= 1 &&

ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&

strcmp(ic->iformat->name, "image2"))

av_log(ic, AV_LOG_WARNING,

"Stream #%d: not enough frames to estimate rate; "

"consider increasing probesize\n", i);

break;

}

/* NOTE: A new stream can be added there if no header in file

* (AVFMTCTX_NOHEADER). */

ret = read_frame_internal(ic, &pkt1);

if (ret == AVERROR(EAGAIN))

continue;

if (ret < 0) {

/* EOF or error*/

eof_reached = 1;

break;

}

pkt = &pkt1;

if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {

ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,

&ic->internal->packet_buffer_end, 0);

if (ret < 0)

goto find_stream_info_err;

}

st = ic->streams[pkt->stream_index];

if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))

read_size += pkt->size;

avctx = st->internal->avctx;

if (!st->internal->avctx_inited) {

ret = avcodec_parameters_to_context(avctx, st->codecpar);

if (ret < 0)

goto find_stream_info_err;

st->internal->avctx_inited = 1;

}

if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {

/* check for non-increasing dts */

if (st->info->fps_last_dts != AV_NOPTS_VALUE &&

st->info->fps_last_dts >= pkt->dts) {

av_log(ic, AV_LOG_DEBUG,

"Non-increasing DTS in stream %d: packet %d with DTS "

"%"PRId64", packet %d with DTS %"PRId64"\n",

st->index, st->info->fps_last_dts_idx,

st->info->fps_last_dts, st->codec_info_nb_frames,

pkt->dts);

st->info->fps_first_dts =

st->info->fps_last_dts = AV_NOPTS_VALUE;

}

/* Check for a discontinuity in dts. If the difference in dts

* is more than 1000 times the average packet duration in the

* sequence, we treat it as a discontinuity. */

if (st->info->fps_last_dts != AV_NOPTS_VALUE &&

st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&

(pkt->dts - st->info->fps_last_dts) / 1000 >

(st->info->fps_last_dts - st->info->fps_first_dts) /

(st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {

av_log(ic, AV_LOG_WARNING,

"DTS discontinuity in stream %d: packet %d with DTS "

"%"PRId64", packet %d with DTS %"PRId64"\n",

st->index, st->info->fps_last_dts_idx,

st->info->fps_last_dts, st->codec_info_nb_frames,

pkt->dts);

st->info->fps_first_dts =

st->info->fps_last_dts = AV_NOPTS_VALUE;

}

/* update stored dts values */

if (st->info->fps_first_dts == AV_NOPTS_VALUE) {

st->info->fps_first_dts = pkt->dts;

st->info->fps_first_dts_idx = st->codec_info_nb_frames;

}

st->info->fps_last_dts = pkt->dts;

st->info->fps_last_dts_idx = st->codec_info_nb_frames;

}

if (st->codec_info_nb_frames>1) {

int64_t t = 0;

int64_t limit;

if (st->time_base.den > 0)

t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);

if (st->avg_frame_rate.num > 0)

t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));

if ( t == 0

&& st->codec_info_nb_frames>30

&& st->info->fps_first_dts != AV_NOPTS_VALUE

&& st->info->fps_last_dts != AV_NOPTS_VALUE)

t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));

if (analyzed_all_streams) limit = max_analyze_duration;

else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;

else limit = max_stream_analyze_duration;

if (t >= limit) {

av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",

limit,

t, pkt->stream_index);

if (ic->flags & AVFMT_FLAG_NOBUFFER)

av_packet_unref(pkt);

break;

}

if (pkt->duration) {

if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {

st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);

} else

st->info->codec_info_duration += pkt->duration;

st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;

}

#if FF_API_R_FRAME_RATE

if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)

ff_rfps_add_frame(ic, st, pkt->dts);

#endif

if (st->parser && st->parser->parser->split && !avctx->extradata) {

int i = st->parser->parser->split(avctx, pkt->data, pkt->size);

if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {

avctx->extradata_size = i;

avctx->extradata = av_mallocz(avctx->extradata_size +

AV_INPUT_BUFFER_PADDING_SIZE);

if (!avctx->extradata)

return AVERROR(ENOMEM);

memcpy(avctx->extradata, pkt->data,

avctx->extradata_size);

}

/* If still no information, we try to open the codec and to

* decompress the frame. We try to avoid that in most cases as

* it takes longer and uses more memory. For MPEG-4, we need to

* decompress for QuickTime.

* If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at

* least one frame of codec data, this makes sure the codec initializes

* the channel configuration and does not only trust the values from

* the container. */

try_decode_frame(ic, st, pkt,

(options && i < orig_nb_streams) ? &options[i] : NULL);

if (ic->flags & AVFMT_FLAG_NOBUFFER)

av_packet_unref(pkt);

st->codec_info_nb_frames++;

count++;

}

这个死循环做了如下事情：

1.检查用户有没有请求中断。如果有中断请求，就调用中断回调方法，并且函数返回。

2.再一次遍历流，检查是不是还有编解码器需要进一步处理。这里会检查编解码器的各个参数，如果这些参数都就绪，那么就会返回了，也就没有必要再做进一步分析了。如果还有些编解码器的信息不全，那么这里会继续向下执行。

3.读一帧数据进来。使用read_frame_internal函数。这个函数很复杂，以后在分析。

4.把读出来的数据添加到缓冲区。使用的是add_to_pktbuf函数。然后更新读到的总的数据的大小：read_size += pkt->size;

5.再次更新编解码器上下文环境的参数。调用的是avcodec_parameters_to_context函数，这个函数我们已经分析过了。

6.检查dts的连续性。如果dts中的差异大于序列中平均分组持续时间的1000倍，我们将其视为不连续。

代码为：

if (st->info->fps_last_dts != AV_NOPTS_VALUE &&

st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&

(pkt->dts - st->info->fps_last_dts) / 1000 >

(st->info->fps_last_dts - st->info->fps_first_dts) /

(st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {

av_log(ic, AV_LOG_WARNING,

"DTS discontinuity in stream %d: packet %d with DTS "

"%"PRId64", packet %d with DTS %"PRId64"\n",

st->index, st->info->fps_last_dts_idx,

st->info->fps_last_dts, st->codec_info_nb_frames,

pkt->dts);

st->info->fps_first_dts =

st->info->fps_last_dts = AV_NOPTS_VALUE;

}

7.更新存储的dts的值。代码为：

if (st->info->fps_first_dts == AV_NOPTS_VALUE) {

st->info->fps_first_dts = pkt->dts;

st->info->fps_first_dts_idx = st->codec_info_nb_frames;

}

8.调用解析器的aplit方法。加入我们的解析器是h.264,那么这个解析器会像下面这样：

AVCodecParser ff_h264_parser = {

.codec_ids = { AV_CODEC_ID_H264 },

.priv_data_size = sizeof(H264ParseContext),

.parser_init = init,

.parser_parse = h264_parse,

.parser_close = h264_close,

.split = h264_split,

};

这个split方法暂时看不懂，以后再来解析。

9.如果这个时候，还是没有找到足够的信息，那么就会尝试解压一些数据出来并做分析。

首先看注释：

如果仍然没有信息，我们尝试打开编解码器并且解压缩帧。我们需要在大多数情况下尽量避免做这样的事情，因为很需要很多的时间，并使用更多的内存。对于MPEG-4，我们需要解压QuickTime。

如果设置AV_CODEC_CAP_CHANNEL_CONF，这将强制解码至少一帧编解码器数据，这确保编解码器初始化通道配置，并且不仅信任来自容器的值

尝试解压一帧的数据使用的是try_decode_frame函数。有些参数，如vidoe的pix_fmt是需要调用h264_decode_frame才可以获取其pix_fmt的。

总结下这个死循环做的工作：其中会检测是不是所有流的信息都已经完备，如果完备就返回，如果完备，就尝试的解压一帧的数据。并从中获取pix_fmt等必须通过解压一帧的数据才能获得的参数。

part 6 检查是否到达文件尾部

if (eof_reached) {

int stream_index;

for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {

st = ic->streams[stream_index];

avctx = st->internal->avctx;

if (!has_codec_parameters(st, NULL)) {

const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);

if (codec && !avctx->codec) {

if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : NULL) < 0)

av_log(ic, AV_LOG_WARNING,

"Failed to open codec in av_find_stream_info\n");

}

// EOF already reached while reading the stream above.

// So continue with reoordering DTS with whatever delay we have.

if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {

update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);

}

如果到了文件尾部，又会遍历一次流，检测其编解码器参数，如果其参数不完整，就会再次调用avcodec_open2来初始化编解码器的各个参数。

part 7 刷新解码器

if (flush_codecs) {

AVPacket empty_pkt = { 0 };

int err = 0;

av_init_packet(&empty_pkt);

for (i = 0; i < ic->nb_streams; i++) {

st = ic->streams[i];

/* flush the decoders */

if (st->info->found_decoder == 1) {

do {

err = try_decode_frame(ic, st, &empty_pkt,

(options && i < orig_nb_streams)

? &options[i] : NULL);

} while (err > 0 && !has_codec_parameters(st, NULL));

if (err < 0) {

av_log(ic, AV_LOG_INFO,

"decoding for stream %d failed\n", st->index);

}

有一些帧可能在缓存区中，需要把它们flush掉。

part 8 关闭可能可打开的编解码器

for (i = 0; i < ic->nb_streams; i++) {

st = ic->streams[i];

avcodec_close(st->internal->avctx);

}

再次遍历流，逐个调用avcodec_close方法来关闭流。

part 9 计算rfps

ff_rfps_calculate(ic);

part10 再次遍历流

for (i = 0; i < ic->nb_streams; i++) {

st = ic->streams[i];

avctx = st->internal->avctx;

if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {

if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {

uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);

if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)

avctx->codec_tag= tag;

}

/* estimate average framerate if not set by demuxer */

if (st->info->codec_info_duration_fields &&

!st->avg_frame_rate.num &&

st->info->codec_info_duration) {

int best_fps = 0;

double best_error = 0.01;

if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||

st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||

st->info->codec_info_duration < 0)

continue;

av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,

st->info->codec_info_duration_fields * (int64_t) st->time_base.den,

st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);

/* Round guessed framerate to a "standard" framerate if it's

* within 1% of the original estimate. */

for (j = 0; j < MAX_STD_TIMEBASES; j++) {

AVRational std_fps = { get_std_framerate(j), 12 * 1001 };

double error = fabs(av_q2d(st->avg_frame_rate) /

av_q2d(std_fps) - 1);

if (error < best_error) {

best_error = error;

best_fps = std_fps.num;

}

if (best_fps)

av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,

best_fps, 12 * 1001, INT_MAX);

}

if (!st->r_frame_rate.num) {

if ( avctx->time_base.den * (int64_t) st->time_base.num

<= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {

st->r_frame_rate.num = avctx->time_base.den;

st->r_frame_rate.den = avctx->time_base.num * avctx->ticks_per_frame;

} else {

st->r_frame_rate.num = st->time_base.den;

st->r_frame_rate.den = st->time_base.num;

}

if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {

AVRational hw_ratio = { avctx->height, avctx->width };

st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,

hw_ratio);

}

} else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {

if (!avctx->bits_per_coded_sample)

avctx->bits_per_coded_sample =

av_get_bits_per_sample(avctx->codec_id);

// set stream disposition based on audio service type

switch (avctx->audio_service_type) {

case AV_AUDIO_SERVICE_TYPE_EFFECTS:

st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;

break;

case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:

st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;

break;

case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:

st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;

break;

case AV_AUDIO_SERVICE_TYPE_COMMENTARY:

st->disposition = AV_DISPOSITION_COMMENT;

break;

case AV_AUDIO_SERVICE_TYPE_KARAOKE:

st->disposition = AV_DISPOSITION_KARAOKE;

break;

}

这个循环用来处理音频流和视频流。

对视频流而言，首先会获得原始数据的图像格式，然后据此找到对应的编解码器的tag。之后会计算平均帧率。

对音频流而言，基于音频流的服务类型初始化disposition。disposition的作用暂时不知。

part 11 计算时间相关的参数

if (probesize)

estimate_timings(ic, old_offset);

estimate_timings函数如下：

static void estimate_timings(AVFormatContext *ic, int64_t old_offset)

{

int64_t file_size;

/* get the file size, if possible */

if (ic->iformat->flags & AVFMT_NOFILE) {

file_size = 0;

} else {

file_size = avio_size(ic->pb);

file_size = FFMAX(0, file_size);

}

if ((!strcmp(ic->iformat->name, "mpeg") ||

!strcmp(ic->iformat->name, "mpegts")) &&

file_size && ic->pb->seekable) {

/* get accurate estimate from the PTSes */

estimate_timings_from_pts(ic, old_offset);

ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;

} else if (has_duration(ic)) {

/* at least one component has timings - we use them for all

* the components */

fill_all_stream_timings(ic);

ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;

} else {

/* less precise: use bitrate info */

estimate_timings_from_bit_rate(ic);

ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;

}

update_stream_timings(ic);

{

int i;

AVStream av_unused *st;

for (i = 0; i < ic->nb_streams; i++) {

st = ic->streams[i];

av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,

(double) st->start_time * av_q2d(st->time_base),

(double) st->duration * av_q2d(st->time_base));

}

av_log(ic, AV_LOG_TRACE,

"format: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",

(double) ic->start_time / AV_TIME_BASE,

(double) ic->duration / AV_TIME_BASE,

(int64_t)ic->bit_rate / 1000);

}

主要是调用update_stream_timings函数更新流的时间相关的参数，之后的代码块是打印日志。

update_stream_timings函数定义在libavfomat/utils.c中。

/**

* Estimate the stream timings from the one of each components.

* Also computes the global bitrate if possible.

static void update_stream_timings(AVFormatContext *ic)

{

int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;

int64_t duration, duration1, filesize;

int i;

AVStream *st;

AVProgram *p;

start_time = INT64_MAX;

start_time_text = INT64_MAX;

end_time = INT64_MIN;

end_time_text = INT64_MIN;

duration = INT64_MIN;

for (i = 0; i < ic->nb_streams; i++) {

st = ic->streams[i];

if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {

start_time1 = av_rescale_q(st->start_time, st->time_base,

AV_TIME_BASE_Q);

if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {

if (start_time1 < start_time_text)

start_time_text = start_time1;

} else

start_time = FFMIN(start_time, start_time1);

end_time1 = av_rescale_q_rnd(st->duration, st->time_base,

AV_TIME_BASE_Q,

AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);

if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {

end_time1 += start_time1;

if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA)

end_time_text = FFMAX(end_time_text, end_time1);

else

end_time = FFMAX(end_time, end_time1);

}

for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {

if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)

p->start_time = start_time1;

if (p->end_time < end_time1)

p->end_time = end_time1;

}

if (st->duration != AV_NOPTS_VALUE) {

duration1 = av_rescale_q(st->duration, st->time_base,

AV_TIME_BASE_Q);

duration = FFMAX(duration, duration1);

}

if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))

start_time = start_time_text;

else if (start_time > start_time_text)

av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);

if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - end_time < AV_TIME_BASE)) {

end_time = end_time_text;

} else if (end_time < end_time_text) {

av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);

}

if (start_time != INT64_MAX) {

ic->start_time = start_time;

if (end_time != INT64_MIN) {

if (ic->nb_programs > 1) {

for (i = 0; i < ic->nb_programs; i++) {

p = ic->programs[i];

if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)

duration = FFMAX(duration, p->end_time - p->start_time);

}

} else

duration = FFMAX(duration, end_time - start_time);

}

if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {

ic->duration = duration;

}

if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {

/* compute the bitrate */

double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /

(double) ic->duration;

if (bitrate >= 0 && bitrate <= INT64_MAX)

ic->bit_rate = bitrate;

}

时间相关的计算非常复杂，是在看不懂。这里还计算了波特率： bitrate = (double) filesize * 8.0 * AV_TIME_BASE / (double) ic->duration;

这里很好理解。filesize*8是这个文件的所有bit数。一字节=8bit。

然后比特率=bit数/时间。

这里时间为ic->duration/AV_TIME_BASE 。

part 12 更新数据

/* update the stream parameters from the internal codec contexts */

for (i = 0; i < ic->nb_streams; i++) {

st = ic->streams[i];

if (st->internal->avctx_inited) {

int orig_w = st->codecpar->width;

int orig_h = st->codecpar->height;

ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);

if (ret < 0)

goto find_stream_info_err;

// The decoder might reduce the video size by the lowres factor.

if (av_codec_get_lowres(st->internal->avctx) && orig_w) {

st->codecpar->width = orig_w;

st->codecpar->height = orig_h;

}

#if FF_API_LAVF_AVCTX

FF_DISABLE_DEPRECATION_WARNINGS

ret = avcodec_parameters_to_context(st->codec, st->codecpar);

if (ret < 0)

goto find_stream_info_err;

// The old API (AVStream.codec) "requires" the resolution to be adjusted

// by the lowres factor.

if (av_codec_get_lowres(st->internal->avctx) && st->internal->avctx->width) {

av_codec_set_lowres(st->codec, av_codec_get_lowres(st->internal->avctx));

st->codec->width = st->internal->avctx->width;

st->codec->height = st->internal->avctx->height;

}

if (st->codec->codec_tag != MKTAG('t','m','c','d')) {

st->codec->time_base = st->internal->avctx->time_base;

st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;

}

st->codec->framerate = st->avg_frame_rate;

if (st->internal->avctx->subtitle_header) {

st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);

if (!st->codec->subtitle_header)

goto find_stream_info_err;

st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;

memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,

st->codec->subtitle_header_size);

}

// Fields unavailable in AVCodecParameters

st->codec->coded_width = st->internal->avctx->coded_width;

st->codec->coded_height = st->internal->avctx->coded_height;

st->codec->properties = st->internal->avctx->properties;

FF_ENABLE_DEPRECATION_WARNINGS

#endif

st->internal->avctx_inited = 0;

最后就是更新各个结构的数据了。AVStream中的AVCodecContext结构体，以及AVStream中AVStreamInternal中的AVCodecContext结构体的数据要统一起来。AVStream中的AVCodecParameters和AVStream中AVStreamInternal中的AVCodecContext结构体的数据也要统一起来。以上主要就是跟新这几个结构体中的数据。

四、总结

最后总结一下吧：

avformat_open_input函数会读文件头，对mp4文件而言，它会解析所有的box。但它知识把读到的结果保存在对应的数据结构下。这个时候，AVStream中的很多字段都是空白的。

avformat_find_stream_info则检测这些重要字段，如果是空白的，就设法填充它们。因为我们解析文件头的时候，已经掌握了大量的信息，avformat_find_stream_info就是通过这些信息来填充自己的成员，当重要的成员都填充完毕后，该函数就返回了。这中情况下，该函数效率很高。但对于某些文件，单纯的从文件头中获取信息是不够的，比如vidoe的pix_fmt是需要调用h264_decode_frame才可以获取其pix_fmt的。因此，这个时候这个函数就会读一些数据进来，然后分析这些数据，并尝试解码这些数据，最终从中提取到所需要的信息。在所有的信息都已经获取到以后，avformat_find_stream_info函数会计算start_time，波特率等信息，其中时间相关的计算很复杂，没能看懂，以后再研究吧。计算结束后会更新相关结构体的数据成员。

虽然由于能力限制，没能够彻底搞懂这个函数的方方面面，但是，通过这次分析，更好的理解了这个函数的功能，对这个函数做的事情有了一定的了解。这也是这次分析的主要收获了，至于那些搞不懂的，只能留着以后慢慢研究了。

ffmpeg学习五：avcodec_open2函数源码分析

上一节我们尝试分析了avformat_open_input函数的源码，这个函数的虽然比较复杂，但是它基本是围绕着创建和初始化一些数据结构来展开的，比如，avformat_open_input函数会创建和初始化AVFormatContext，AVClass ，AVOption,URLContext,URLProtocol ,AVInputFormat ,AVStream等数据结构，这些数据结构的关系如下：

（这里的箭头是包含关系，不是继承关系）

那么，我们可以推测，同样作为Open系列的函数，avcodec_open2的使命也必然是构建和初始化一系列的数据结构，那么是不是这样呢？

avcodec_open2函数定义在libavcodec/aviocodec.h中:

/**

* Initialize the AVCodecContext to use the given AVCodec. Prior to using this

* function the context has to be allocated with avcodec_alloc_context3().

* The functions avcodec_find_decoder_by_name(), avcodec_find_encoder_by_name(),

* avcodec_find_decoder() and avcodec_find_encoder() provide an easy way for

* retrieving a codec.

* @warning This function is not thread safe!

* @note Always call this function before using decoding routines (such as

* @ref avcodec_receive_frame()).

* @code

* avcodec_register_all();

* av_dict_set(&opts, "b", "2.5M", 0);

* codec = avcodec_find_decoder(AV_CODEC_ID_H264);

* if (!codec)

* exit(1);

* context = avcodec_alloc_context3(codec);

* if (avcodec_open2(context, codec, opts) < 0)

* exit(1);

* @endcode

* @param avctx The context to initialize.

* @param codec The codec to open this context for. If a non-NULL codec has been

* previously passed to avcodec_alloc_context3() or

* for this context, then this parameter MUST be either NULL or

* equal to the previously passed codec.

* @param options A dictionary filled with AVCodecContext and codec-private options.

* On return this object will be filled with options that were not found.

* @return zero on success, a negative value on error

* @see avcodec_alloc_context3(), avcodec_find_decoder(), avcodec_find_encoder(),

* av_dict_set(), av_opt_find().

int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options);

从它的注释中我们可以得到如下信息：

1.使用所给的AVCodec结构体构造AVCodecContext结构体。

2.avcodec_find_decoder_by_name(), avcodec_find_encoder_by_name(),

* avcodec_find_decoder() and avcodec_find_encoder()，这几个函数提供了方便获取AVCodecContext实例的途径。

3.这个函数是线程不安全函数

4.在使用解码程序之前，必须调用此函数。

综上，avcodec_open2函数的核心人物是构造AVCodecContext结构体。

avcodec_open2函数在libavcodec/utils.c中实现：

int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)

{

int ret = 0;

AVDictionary *tmp = NULL;

const AVPixFmtDescriptor *pixdesc;

if (avcodec_is_open(avctx))

return 0;

if ((!codec && !avctx->codec)) {

av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2()\n");

return AVERROR(EINVAL);

}

if ((codec && avctx->codec && codec != avctx->codec)) {

av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "

"but %s passed to avcodec_open2()\n", avctx->codec->name, codec->name);

return AVERROR(EINVAL);

}

if (!codec)

codec = avctx->codec;

if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)

return AVERROR(EINVAL);

if (options)

av_dict_copy(&tmp, *options, 0);

ret = ff_lock_avcodec(avctx, codec);

if (ret < 0)

return ret;

avctx->internal = av_mallocz(sizeof(AVCodecInternal));

if (!avctx->internal) {

ret = AVERROR(ENOMEM);

goto end;

}

avctx->internal->pool = av_mallocz(sizeof(*avctx->internal->pool));

if (!avctx->internal->pool) {

ret = AVERROR(ENOMEM);

goto free_and_end;

}

avctx->internal->to_free = av_frame_alloc();

if (!avctx->internal->to_free) {

ret = AVERROR(ENOMEM);

goto free_and_end;

}

avctx->internal->buffer_frame = av_frame_alloc();

if (!avctx->internal->buffer_frame) {

ret = AVERROR(ENOMEM);

goto free_and_end;

}

avctx->internal->buffer_pkt = av_packet_alloc();

if (!avctx->internal->buffer_pkt) {

ret = AVERROR(ENOMEM);

goto free_and_end;

}

if (codec->priv_data_size > 0) {

if (!avctx->priv_data) {

avctx->priv_data = av_mallocz(codec->priv_data_size);

if (!avctx->priv_data) {

ret = AVERROR(ENOMEM);

goto end;

}

if (codec->priv_class) {

*(const AVClass **)avctx->priv_data = codec->priv_class;

av_opt_set_defaults(avctx->priv_data);

}

if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)

goto free_and_end;

} else {

avctx->priv_data = NULL;

}

if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)

goto free_and_end;

if (avctx->codec_whitelist && av_match_list(codec->name, avctx->codec_whitelist, ',') <= 0) {

av_log(avctx, AV_LOG_ERROR, "Codec (%s) not on whitelist \'%s\'\n", codec->name, avctx->codec_whitelist);

ret = AVERROR(EINVAL);

goto free_and_end;

}

// only call ff_set_dimensions() for non H.264/VP6F/DXV codecs so as not to overwrite previously setup dimensions

if (!(avctx->coded_width && avctx->coded_height && avctx->width && avctx->height &&

(avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_VP6F || avctx->codec_id == AV_CODEC_ID_DXV))) {

if (avctx->coded_width && avctx->coded_height)

ret = ff_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);

else if (avctx->width && avctx->height)

ret = ff_set_dimensions(avctx, avctx->width, avctx->height);

if (ret < 0)

goto free_and_end;

}

if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)

&& ( av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx) < 0

|| av_image_check_size(avctx->width, avctx->height, 0, avctx) < 0)) {

av_log(avctx, AV_LOG_WARNING, "Ignoring invalid width/height values\n");

ff_set_dimensions(avctx, 0, 0);

}

if (avctx->width > 0 && avctx->height > 0) {

if (av_image_check_sar(avctx->width, avctx->height,

avctx->sample_aspect_ratio) < 0) {

av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",

avctx->sample_aspect_ratio.num,

avctx->sample_aspect_ratio.den);

avctx->sample_aspect_ratio = (AVRational){ 0, 1 };

}

/* if the decoder init function was already called previously,

* free the already allocated subtitle_header before overwriting it */

if (av_codec_is_decoder(codec))

av_freep(&avctx->subtitle_header);

if (avctx->channels > FF_SANE_NB_CHANNELS) {

ret = AVERROR(EINVAL);

goto free_and_end;

}

avctx->codec = codec;

if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&

avctx->codec_id == AV_CODEC_ID_NONE) {

avctx->codec_type = codec->type;

avctx->codec_id = codec->id;

}

if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type

&& avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {

av_log(avctx, AV_LOG_ERROR, "Codec type or id mismatches\n");

ret = AVERROR(EINVAL);

goto free_and_end;

}

avctx->frame_number = 0;

avctx->codec_descriptor = avcodec_descriptor_get(avctx->codec_id);

if ((avctx->codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) &&

avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {

const char *codec_string = av_codec_is_encoder(codec) ? "encoder" : "decoder";

AVCodec *codec2;

av_log(avctx, AV_LOG_ERROR,

"The %s '%s' is experimental but experimental codecs are not enabled, "

"add '-strict %d' if you want to use it.\n",

codec_string, codec->name, FF_COMPLIANCE_EXPERIMENTAL);

codec2 = av_codec_is_encoder(codec) ? avcodec_find_encoder(codec->id) : avcodec_find_decoder(codec->id);

if (!(codec2->capabilities & AV_CODEC_CAP_EXPERIMENTAL))

av_log(avctx, AV_LOG_ERROR, "Alternatively use the non experimental %s '%s'.\n",

codec_string, codec2->name);

ret = AVERROR_EXPERIMENTAL;

goto free_and_end;

}

if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&

(!avctx->time_base.num || !avctx->time_base.den)) {

avctx->time_base.num = 1;

avctx->time_base.den = avctx->sample_rate;

}

if (!HAVE_THREADS)

av_log(avctx, AV_LOG_WARNING, "Warning: not compiled with thread support, using thread emulation\n");

if (CONFIG_FRAME_THREAD_ENCODER && av_codec_is_encoder(avctx->codec)) {

ff_unlock_avcodec(codec); //we will instantiate a few encoders thus kick the counter to prevent false detection of a problem

ret = ff_frame_thread_encoder_init(avctx, options ? *options : NULL);

ff_lock_avcodec(avctx, codec);

if (ret < 0)

goto free_and_end;

}

if (HAVE_THREADS

&& !(avctx->internal->frame_thread_encoder && (avctx->active_thread_type&FF_THREAD_FRAME))) {

ret = ff_thread_init(avctx);

if (ret < 0) {

goto free_and_end;

}

if (!HAVE_THREADS && !(codec->capabilities & AV_CODEC_CAP_AUTO_THREADS))

avctx->thread_count = 1;

if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {

av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",

avctx->codec->max_lowres);

avctx->lowres = avctx->codec->max_lowres;

}

#if FF_API_VISMV

if (avctx->debug_mv)

av_log(avctx, AV_LOG_WARNING, "The 'vismv' option is deprecated, "

"see the codecview filter instead.\n");

#endif

if (av_codec_is_encoder(avctx->codec)) {

int i;

#if FF_API_CODED_FRAME

FF_DISABLE_DEPRECATION_WARNINGS

avctx->coded_frame = av_frame_alloc();

if (!avctx->coded_frame) {

ret = AVERROR(ENOMEM);

goto free_and_end;

}

FF_ENABLE_DEPRECATION_WARNINGS

#endif

if (avctx->time_base.num <= 0 || avctx->time_base.den <= 0) {

av_log(avctx, AV_LOG_ERROR, "The encoder timebase is not set.\n");

ret = AVERROR(EINVAL);

goto free_and_end;

}

if (avctx->codec->sample_fmts) {

for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++) {

if (avctx->sample_fmt == avctx->codec->sample_fmts[i])

break;

if (avctx->channels == 1 &&

av_get_planar_sample_fmt(avctx->sample_fmt) ==

av_get_planar_sample_fmt(avctx->codec->sample_fmts[i])) {

avctx->sample_fmt = avctx->codec->sample_fmts[i];

break;

}

if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {

char buf[128];

snprintf(buf, sizeof(buf), "%d", avctx->sample_fmt);

av_log(avctx, AV_LOG_ERROR, "Specified sample format %s is invalid or not supported\n",

(char *)av_x_if_null(av_get_sample_fmt_name(avctx->sample_fmt), buf));

ret = AVERROR(EINVAL);

goto free_and_end;

}

if (avctx->codec->pix_fmts) {

for (i = 0; avctx->codec->pix_fmts[i] != AV_PIX_FMT_NONE; i++)

if (avctx->pix_fmt == avctx->codec->pix_fmts[i])

break;

if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_NONE

&& !((avctx->codec_id == AV_CODEC_ID_MJPEG || avctx->codec_id == AV_CODEC_ID_LJPEG)

&& avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL)) {

char buf[128];

snprintf(buf, sizeof(buf), "%d", avctx->pix_fmt);

av_log(avctx, AV_LOG_ERROR, "Specified pixel format %s is invalid or not supported\n",

(char *)av_x_if_null(av_get_pix_fmt_name(avctx->pix_fmt), buf));

ret = AVERROR(EINVAL);

goto free_and_end;

}

if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ420P ||

avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ411P ||

avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ422P ||

avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ440P ||

avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ444P)

avctx->color_range = AVCOL_RANGE_JPEG;

}

if (avctx->codec->supported_samplerates) {

for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)

if (avctx->sample_rate == avctx->codec->supported_samplerates[i])

break;

if (avctx->codec->supported_samplerates[i] == 0) {

av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",

avctx->sample_rate);

ret = AVERROR(EINVAL);

goto free_and_end;

}

if (avctx->sample_rate < 0) {

av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",

avctx->sample_rate);

ret = AVERROR(EINVAL);

goto free_and_end;

}

if (avctx->codec->channel_layouts) {

if (!avctx->channel_layout) {

av_log(avctx, AV_LOG_WARNING, "Channel layout not specified\n");

} else {

for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)

if (avctx->channel_layout == avctx->codec->channel_layouts[i])

break;

if (avctx->codec->channel_layouts[i] == 0) {

char buf[512];

av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);

av_log(avctx, AV_LOG_ERROR, "Specified channel layout '%s' is not supported\n", buf);

ret = AVERROR(EINVAL);

goto free_and_end;

}

if (avctx->channel_layout && avctx->channels) {

int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);

if (channels != avctx->channels) {

char buf[512];

av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);

av_log(avctx, AV_LOG_ERROR,

"Channel layout '%s' with %d channels does not match number of specified channels %d\n",

buf, channels, avctx->channels);

ret = AVERROR(EINVAL);

goto free_and_end;

}

} else if (avctx->channel_layout) {

avctx->channels = av_get_channel_layout_nb_channels(avctx->channel_layout);

}

if (avctx->channels < 0) {

av_log(avctx, AV_LOG_ERROR, "Specified number of channels %d is not supported\n",

avctx->channels);

ret = AVERROR(EINVAL);

goto free_and_end;

}

if(avctx->codec_type == AVMEDIA_TYPE_VIDEO) {

pixdesc = av_pix_fmt_desc_get(avctx->pix_fmt);

if ( avctx->bits_per_raw_sample < 0

|| (avctx->bits_per_raw_sample > 8 && pixdesc->comp[0].depth <= 8)) {

av_log(avctx, AV_LOG_WARNING, "Specified bit depth %d not possible with the specified pixel formats depth %d\n",

avctx->bits_per_raw_sample, pixdesc->comp[0].depth);

avctx->bits_per_raw_sample = pixdesc->comp[0].depth;

}

if (avctx->width <= 0 || avctx->height <= 0) {

av_log(avctx, AV_LOG_ERROR, "dimensions not set\n");

ret = AVERROR(EINVAL);

goto free_and_end;

}

if ( (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)

&& avctx->bit_rate>0 && avctx->bit_rate<1000) {

av_log(avctx, AV_LOG_WARNING, "Bitrate %"PRId64" is extremely low, maybe you mean %"PRId64"k\n", (int64_t)avctx->bit_rate, (int64_t)avctx->bit_rate);

}

if (!avctx->rc_initial_buffer_occupancy)

avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3 / 4;

if (avctx->ticks_per_frame && avctx->time_base.num &&

avctx->ticks_per_frame > INT_MAX / avctx->time_base.num) {

av_log(avctx, AV_LOG_ERROR,

"ticks_per_frame %d too large for the timebase %d/%d.",

avctx->ticks_per_frame,

avctx->time_base.num,

avctx->time_base.den);

goto free_and_end;

}

if (avctx->hw_frames_ctx) {

AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;

if (frames_ctx->format != avctx->pix_fmt) {

av_log(avctx, AV_LOG_ERROR,

"Mismatching AVCodecContext.pix_fmt and AVHWFramesContext.format\n");

ret = AVERROR(EINVAL);

goto free_and_end;

}

avctx->pts_correction_num_faulty_pts =

avctx->pts_correction_num_faulty_dts = 0;

avctx->pts_correction_last_pts =

avctx->pts_correction_last_dts = INT64_MIN;

if ( !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY

&& avctx->codec_descriptor->type == AVMEDIA_TYPE_VIDEO)

av_log(avctx, AV_LOG_WARNING,

"gray decoding requested but not enabled at configuration time\n");

if ( avctx->codec->init && (!(avctx->active_thread_type&FF_THREAD_FRAME)

|| avctx->internal->frame_thread_encoder)) {

ret = avctx->codec->init(avctx);

if (ret < 0) {

goto free_and_end;

}

ret=0;

#if FF_API_AUDIOENC_DELAY

if (av_codec_is_encoder(avctx->codec))

avctx->delay = avctx->initial_padding;

#endif

if (av_codec_is_decoder(avctx->codec)) {

if (!avctx->bit_rate)

avctx->bit_rate = get_bit_rate(avctx);

/* validate channel layout from the decoder */

if (avctx->channel_layout) {

int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);

if (!avctx->channels)

avctx->channels = channels;

else if (channels != avctx->channels) {

char buf[512];

av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);

av_log(avctx, AV_LOG_WARNING,

"Channel layout '%s' with %d channels does not match specified number of channels %d: "

"ignoring specified channel layout\n",

buf, channels, avctx->channels);

avctx->channel_layout = 0;

}

if (avctx->channels && avctx->channels < 0 ||

avctx->channels > FF_SANE_NB_CHANNELS) {

ret = AVERROR(EINVAL);

goto free_and_end;

}

if (avctx->sub_charenc) {

if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {

av_log(avctx, AV_LOG_ERROR, "Character encoding is only "

"supported with subtitles codecs\n");

ret = AVERROR(EINVAL);

goto free_and_end;

} else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {

av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "

"subtitles character encoding will be ignored\n",

avctx->codec_descriptor->name);

avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_DO_NOTHING;

} else {

/* input character encoding is set for a text based subtitle

* codec at this point */

if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_AUTOMATIC)

avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_PRE_DECODER;

if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_PRE_DECODER) {

#if CONFIG_ICONV

iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);

if (cd == (iconv_t)-1) {

ret = AVERROR(errno);

av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "

"with input character encoding \"%s\"\n", avctx->sub_charenc);

goto free_and_end;

}

iconv_close(cd);

#else

av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "

"conversion needs a libavcodec built with iconv support "

"for this codec\n");

ret = AVERROR(ENOSYS);

goto free_and_end;

#endif

}

#if FF_API_AVCTX_TIMEBASE

if (avctx->framerate.num > 0 && avctx->framerate.den > 0)

avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));

#endif

}

if (codec->priv_data_size > 0 && avctx->priv_data && codec->priv_class) {

av_assert0(*(const AVClass **)avctx->priv_data == codec->priv_class);

}

end:

ff_unlock_avcodec(codec);

if (options) {

av_dict_free(options);

*options = tmp;

}

return ret;

free_and_end:

if (avctx->codec &&

(avctx->codec->caps_internal & FF_CODEC_CAP_INIT_CLEANUP))

avctx->codec->close(avctx);

if (codec->priv_class && codec->priv_data_size)

av_opt_free(avctx->priv_data);

av_opt_free(avctx);

#if FF_API_CODED_FRAME

FF_DISABLE_DEPRECATION_WARNINGS

av_frame_free(&avctx->coded_frame);

FF_ENABLE_DEPRECATION_WARNINGS

#endif

av_dict_free(&tmp);

av_freep(&avctx->priv_data);

if (avctx->internal) {

av_packet_free(&avctx->internal->buffer_pkt);

av_frame_free(&avctx->internal->buffer_frame);

av_frame_free(&avctx->internal->to_free);

av_freep(&avctx->internal->pool);

}

av_freep(&avctx->internal);

avctx->codec = NULL;

goto end;

}

非常长的一个函数。

这个函数做了如下事情：

1.创建一系列数据结构。

AVCodecInternal，AVFrame to_*free，AVFrame *buffer_frame;AVPacket *buffer_pkt;void *priv_data;const AVClass *priv_class;

2.初始化这些数据结构。

额，只有两件事情，好像很简单的样子…

我们先理一理创建的这些数据结构之间的关系，看图：

（这里的箭头是包含关系，不是继承关系）

从图中可以看出，AVFormatContext是最底层的一个结构，我们无论做编码工作还是解码工作，通过AVFormatContext就能得到一切想要的信息（前提是所有的数据结构都已经初始化好了）。AVStream我们在上一节分析avformat_open_input函数的时候已经分析过，这个结构在avformat_open_input函数中已经初始化好了，我们创建的AVCodecContext一般需要挂到AVStreamInternal下面，也就是说，编解码器上下文环境是流的一部分。这个很好理解，对一个视频流而言，我们要解码它，需要一个解码器，它当然是视频流的一部分了。

这个函数如此的长，它肯定做了不少工作了，我们还是分开来慢慢看。

第一件事

第一件事是创建一系列数据结构，我们看看都创建了什么，是怎么创建的。

1-1判断编解码器是否打开

avcodec_open2一开始就调用avcodec_is_open函数判断编解码器是否打开，如果没有打开才能继续往下执行。avcodec_is_open函数定义在libavcodec/utils.c中：

int avcodec_is_open(AVCodecContext *s)

{

return !!s->internal;

}

判断编解码器有没有打开过原来就是判断它内部的internal字段是否为空。！！的功能是使得返回值要么是0，要么是1。

1-2把编码器挂到编解码器上下文环境下

其代码为：

if (!codec)

codec = avctx->codec;

1-3给AVCodecContext下对应的节点分配AVCodecInternal，FramePool，AVPacket，AVFrame等数据结构

分配的代码为：

avctx->internal = av_mallocz(sizeof(AVCodecInternal));

if (!avctx->internal) {

ret = AVERROR(ENOMEM);

goto end;

}

avctx->internal->pool = av_mallocz(sizeof(*avctx->internal->pool));

if (!avctx->internal->pool) {

ret = AVERROR(ENOMEM);

goto free_and_end;

}

avctx->internal->to_free = av_frame_alloc();

if (!avctx->internal->to_free) {

ret = AVERROR(ENOMEM);

goto free_and_end;

}

avctx->internal->buffer_frame = av_frame_alloc();

if (!avctx->internal->buffer_frame) {

ret = AVERROR(ENOMEM);

goto free_and_end;

}

avctx->internal->buffer_pkt = av_packet_alloc();

if (!avctx->internal->buffer_pkt) {

ret = AVERROR(ENOMEM);

goto free_and_end;

}

if (codec->priv_data_size > 0) {

if (!avctx->priv_data) {

avctx->priv_data = av_mallocz(codec->priv_data_size);

if (!avctx->priv_data) {

ret = AVERROR(ENOMEM);

goto end;

}

if (codec->priv_class) {

*(const AVClass **)avctx->priv_data = codec->priv_class;

av_opt_set_defaults(avctx->priv_data);

}

if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)

goto free_and_end;

} else {

avctx->priv_data = NULL;

}

数据结构至此就分配完了，接下来便是数据结构的初始化工作了。

第二件事

2-1检查编码器是不是在白名单中

2-2把编解码器挂载到上下文环境下

avctx->codec = codec;

2-3检查和重置编解码器类型

if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&

avctx->codec_id == AV_CODEC_ID_NONE) {

avctx->codec_type = codec->type;

avctx->codec_id = codec->id;

}

如果编解码器上下文类型或者ID类型没有设置，就用编解码器的类型和ID给它设置：

2-3设置编解码器上下文环境的帧的数量为0

avctx->frame_number = 0;

2-4设置编解码器的描述信息

avctx->codec_descriptor = avcodec_descriptor_get(avctx->codec_id);

avcodec_descriptor_get定义在libavcodec/codec_desc.c中：

const AVCodecDescriptor *avcodec_descriptor_get(enum AVCodecID id)

{

int i;

for (i = 0; i < FF_ARRAY_ELEMS(codec_descriptors); i++)

if (codec_descriptors[i].id == id)

return &codec_descriptors[i];

return NULL;

}

遍历一个数组，该数组也定义在codec_desc.c中：

static const AVCodecDescriptor codec_descriptors[] = {

/* video codecs */

{

.id = AV_CODEC_ID_MPEG1VIDEO,

.type = AVMEDIA_TYPE_VIDEO,

.name = "mpeg1video",

.long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),

.props = AV_CODEC_PROP_LOSSY | AV_CODEC_PROP_REORDER,

{

.id = AV_CODEC_ID_MPEG2VIDEO,

.type = AVMEDIA_TYPE_VIDEO,

.name = "mpeg2video",

.long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"),

.props = AV_CODEC_PROP_LOSSY | AV_CODEC_PROP_REORDER,

.profiles = NULL_IF_CONFIG_SMALL(ff_mpeg2_video_profiles),

。。。

好大一个数组，只列出一部分。

2-5设置音频流的时间戳

if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&

(!avctx->time_base.num || !avctx->time_base.den)) {

avctx->time_base.num = 1;

avctx->time_base.den = avctx->sample_rate;

}

之后的设置分为解码器部分和编码器部分。我们之前的例子一直都是以解码mp4文件为例，因此，此处我们也是只分析解码器的设置。

2-6设置波特率

if (!avctx->bit_rate)

avctx->bit_rate = get_bit_rate(avctx);

get_bit_rate函数定义在libavcodec/utils.c中：

static int64_t get_bit_rate(AVCodecContext *ctx)

{

int64_t bit_rate;

int bits_per_sample;

switch (ctx->codec_type) {

case AVMEDIA_TYPE_VIDEO:

case AVMEDIA_TYPE_DATA:

case AVMEDIA_TYPE_SUBTITLE:

case AVMEDIA_TYPE_ATTACHMENT:

bit_rate = ctx->bit_rate;

break;

case AVMEDIA_TYPE_AUDIO:

bits_per_sample = av_get_bits_per_sample(ctx->codec_id);

bit_rate = bits_per_sample ? ctx->sample_rate * (int64_t)ctx->channels * bits_per_sample : ctx->bit_rate;

break;

default:

bit_rate = 0;

break;

}

return bit_rate;

}

对于视频解码器，波特率就是AVCodecContext 下的bit_rate成员的值，音频解码器则会重新计算，这里不分析。

2-7验证通道布局

/* validate channel layout from the decoder */

if (avctx->channel_layout) {

int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);

if (!avctx->channels)

avctx->channels = channels;

else if (channels != avctx->channels) {

char buf[512];

av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);

av_log(avctx, AV_LOG_WARNING,

"Channel layout '%s' with %d channels does not match specified number of channels %d: "

"ignoring specified channel layout\n",

buf, channels, avctx->channels);

avctx->channel_layout = 0;

}

if (avctx->channels && avctx->channels < 0 ||

avctx->channels > FF_SANE_NB_CHANNELS) {

ret = AVERROR(EINVAL);

goto free_and_end;

}

2-8设置字幕文件的字符编码格式

if (avctx->sub_charenc) {

if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {

av_log(avctx, AV_LOG_ERROR, "Character encoding is only "

"supported with subtitles codecs\n");

ret = AVERROR(EINVAL);

goto free_and_end;

} else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {

av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "

"subtitles character encoding will be ignored\n",

avctx->codec_descriptor->name);

avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_DO_NOTHING;

} else {

/* input character encoding is set for a text based subtitle

* codec at this point */

if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_AUTOMATIC)

avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_PRE_DECODER;

if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_PRE_DECODER) {

#if CONFIG_ICONV

iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);

if (cd == (iconv_t)-1) {

ret = AVERROR(errno);

av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "

"with input character encoding \"%s\"\n", avctx->sub_charenc);

goto free_and_end;

}

iconv_close(cd);

#else

av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "

"conversion needs a libavcodec built with iconv support "

"for this codec\n");

ret = AVERROR(ENOSYS);

goto free_and_end;

#endif

}

设置结束，也不复杂哈？

ffmpeg学习四：avformat_open_input函数源码分析

上一节我们写了一个简单的程序，它可以把一个视频文件解码成多张图片。我们只是简单的使用的ffmepg提供的api来实现这一过程的，但对api具体的实现过程却一无所知，因此，从这篇博客看是，就逐步分析这些api的内部实现原理。这一节，主要分析avformat_open_input函数的具体实现。

avformat_open_input函数如下：

/**

* Open an input stream and read the header. The codecs are not opened.

* The stream must be closed with avformat_close_input().

* @param ps Pointer to user-supplied AVFormatContext (allocated by avformat_alloc_context).

* May be a pointer to NULL, in which case an AVFormatContext is allocated by this

* function and written into ps.

* Note that a user-supplied AVFormatContext will be freed on failure.

* @param url URL of the stream to open.

* @param fmt If non-NULL, this parameter forces a specific input format.

* Otherwise the format is autodetected.

* @param options A dictionary filled with AVFormatContext and demuxer-private options.

* On return this parameter will be destroyed and replaced with a dict containing

* options that were not found. May be NULL.

* @return 0 on success, a negative AVERROR on failure.

* @note If you want to use custom IO, preallocate the format context and set its pb field.

int avformat_open_input(AVFormatContext **ps, const char *filename,

AVInputFormat *fmt, AVDictionary **options)

{

AVFormatContext *s = *ps;

int i, ret = 0;

AVDictionary *tmp = NULL;

ID3v2ExtraMeta *id3v2_extra_meta = NULL;

if (!s && !(s = avformat_alloc_context()))

return AVERROR(ENOMEM);

if (!s->av_class) {

av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");

return AVERROR(EINVAL);

}

if (fmt)

s->iformat = fmt;

if (options)

av_dict_copy(&tmp, *options, 0);

if (s->pb) // must be before any goto fail

s->flags |= AVFMT_FLAG_CUSTOM_IO;

if ((ret = av_opt_set_dict(s, &tmp)) < 0)

goto fail;

if ((ret = init_input(s, filename, &tmp)) < 0)

goto fail;

s->probe_score = ret;

if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {

s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);

if (!s->protocol_whitelist) {

ret = AVERROR(ENOMEM);

goto fail;

}

if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {

s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);

if (!s->protocol_blacklist) {

ret = AVERROR(ENOMEM);

goto fail;

}

if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {

av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);

ret = AVERROR(EINVAL);

goto fail;

}

avio_skip(s->pb, s->skip_initial_bytes);

/* Check filename in case an image number is expected. */

if (s->iformat->flags & AVFMT_NEEDNUMBER) {

if (!av_filename_number_test(filename)) {

ret = AVERROR(EINVAL);

goto fail;

}

s->duration = s->start_time = AV_NOPTS_VALUE;

av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));

/* Allocate private data. */

if (s->iformat->priv_data_size > 0) {

if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {

ret = AVERROR(ENOMEM);

goto fail;

}

if (s->iformat->priv_class) {

*(const AVClass **) s->priv_data = s->iformat->priv_class;

av_opt_set_defaults(s->priv_data);

if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)

goto fail;

}

/* e.g. AVFMT_NOFILE formats will not have a AVIOContext */

if (s->pb)

ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, 0);

if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)

if ((ret = s->iformat->read_header(s)) < 0)//read header,reader mp4 box info

goto fail;

if (id3v2_extra_meta) {

if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||

!strcmp(s->iformat->name, "tta")) {

if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)

goto fail;

} else

av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");

}

ff_id3v2_free_extra_meta(&id3v2_extra_meta);

if ((ret = avformat_queue_attached_pictures(s)) < 0)

goto fail;

if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)

s->internal->data_offset = avio_tell(s->pb);

s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;

for (i = 0; i < s->nb_streams; i++)

s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;

if (options) {

av_dict_free(options);

*options = tmp;

}

*ps = s;

return 0;

fail:

ff_id3v2_free_extra_meta(&id3v2_extra_meta);

av_dict_free(&tmp);

if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))

avio_closep(&s->pb);

avformat_free_context(s);

*ps = NULL;

return ret;

}

结合注释，我们可以知道这个函数的作用是：打开一个输入流并且读它的头部信息，编解码器不会被打开，这个方法调用结束后，一定要调用avformat_close_input()关闭流。

使用要这个函数要注意一点：如果fmt参数非空，也就是人为的指定了一个AVInputFormat的实例，那么这个函数就不会再检测输入文件的格式了，相反，如果fmt为空，那么这个函数就会自动探测输入文件的格式等信息。

从源码来看，这个函数主要做了四件事：

1.分配一个AVFormatContext的实例。

2.调用init_input函数初始化输入流的信息。这里会初始化AVInputFormat。

3.根据上一步初始化好的AVInputFormat的类型，调用它的read_header方法，读取文件头。

该函数不管做的事情有多么复杂，它主要还是围绕着初始化下面一些数据结构来的：

这三件事说起来简单，具体分析起来相当复杂，我们一件一件来看：

第一件事情

分配一个AVFormatContext结构体。使用的是avformat_alloc_context函数，这个函数定义如下：

AVFormatContext *avformat_alloc_context(void)

{

AVFormatContext *ic;

ic = av_malloc(sizeof(AVFormatContext));

if (!ic) return ic;

avformat_get_context_defaults(ic);

ic->internal = av_mallocz(sizeof(*ic->internal));

if (!ic->internal) {

avformat_free_context(ic);

return NULL;

}

ic->internal->offset = AV_NOPTS_VALUE;

ic->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;

ic->internal->shortest_end = AV_NOPTS_VALUE;

return ic;

}

这个函数中调用av_malloc函数分配一块内容以后，使用avformat_get_context_defaults方法来做一些默认的初始化。之后给internal成员分配内存并做初始化工作。

avformat_get_context_defaults函数如下，看看它做了哪些初始化工作。

static void avformat_get_context_defaults(AVFormatContext *s)

{

memset(s, 0, sizeof(AVFormatContext));

s->av_class = &av_format_context_class;

s->io_open = io_open_default;

s->io_close = io_close_default;

av_opt_set_defaults(s);

}

这里做的初始化工作有：

1.av_class成员，指向一个av_format_context_class结构体，这个结构体如下：

static const AVClass av_format_context_class = {

.class_name = "AVFormatContext",

.item_name = format_to_name,

.option = avformat_options,

.version = LIBAVUTIL_VERSION_INT,

.child_next = format_child_next,

.child_class_next = format_child_class_next,

.category = AV_CLASS_CATEGORY_MUXER,

.get_category = get_category,

};

这个结构体的option选项赋值为avformat_options，其值如下：

static const AVOption avformat_options[] = {

{"avioflags", NULL, OFFSET(avio_flags), AV_OPT_TYPE_FLAGS, {.i64 = DEFAULT }, INT_MIN, INT_MAX, D|E, "avioflags"},

{"direct", "reduce buffering", 0, AV_OPT_TYPE_CONST, {.i64 = AVIO_FLAG_DIRECT }, INT_MIN, INT_MAX, D|E, "avioflags"},

{"probesize", "set probing size", OFFSET(probesize), AV_OPT_TYPE_INT64, {.i64 = 5000000 }, 32, INT64_MAX, D},

{"formatprobesize", "number of bytes to probe file format", OFFSET(format_probesize), AV_OPT_TYPE_INT, {.i64 = PROBE_BUF_MAX}, 0, INT_MAX-1, D},

{"packetsize", "set packet size", OFFSET(packet_size), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX, E},

内容非常多，这里只列出其中一些。

那么AVClass,AVOption有什么作用呢？

很多的Ffmpeg中的结构体都有AVClass成员，用来描述属主结构体。AVClass有一定会有一个AVOption成员，存放这个结构体需要的一些值，以键值对的形式存放，还有帮助信息等，这些字段都是可以修改的，而且ffmpeg提供了一系列专门用于操作AVOption的函数，这些函数定义在opt.h文件中：

int av_opt_set (void *obj, const char *name, const char *val, int search_flags);

const AVOption *av_opt_next(const void *obj, const AVOption *prev);

const AVOption *av_opt_find2(void *obj, const char *name, const char *unit,

...

这些函数的作用从名字上可以猜个大概，这里就不展开了。

接下来的av_opt_set_defaults(s)函数主要就是设置这些字段的：

void av_opt_set_defaults(void *s)

{

av_opt_set_defaults2(s, 0, 0);

}

void av_opt_set_defaults2(void *s, int mask, int flags)

{

const AVOption *opt = NULL;

while ((opt = av_opt_next(s, opt))) {

void *dst = ((uint8_t*)s) + opt->offset;

if ((opt->flags & mask) != flags)

continue;

if (opt->flags & AV_OPT_FLAG_READONLY)

continue;

switch (opt->type) {

case AV_OPT_TYPE_CONST:

/* Nothing to be done here */

break;

case AV_OPT_TYPE_BOOL:

case AV_OPT_TYPE_FLAGS:

case AV_OPT_TYPE_INT:

case AV_OPT_TYPE_INT64:

case AV_OPT_TYPE_DURATION:

case AV_OPT_TYPE_CHANNEL_LAYOUT:

case AV_OPT_TYPE_PIXEL_FMT:

case AV_OPT_TYPE_SAMPLE_FMT:

write_number(s, opt, dst, 1, 1, opt->default_val.i64);

break;

case AV_OPT_TYPE_DOUBLE:

case AV_OPT_TYPE_FLOAT: {

double val;

val = opt->default_val.dbl;

write_number(s, opt, dst, val, 1, 1);

}

break;

case AV_OPT_TYPE_RATIONAL: {

AVRational val;

val = av_d2q(opt->default_val.dbl, INT_MAX);

write_number(s, opt, dst, 1, val.den, val.num);

}

break;

case AV_OPT_TYPE_COLOR:

set_string_color(s, opt, opt->default_val.str, dst);

break;

case AV_OPT_TYPE_STRING:

set_string(s, opt, opt->default_val.str, dst);

break;

case AV_OPT_TYPE_IMAGE_SIZE:

set_string_image_size(s, opt, opt->default_val.str, dst);

break;

case AV_OPT_TYPE_VIDEO_RATE:

set_string_video_rate(s, opt, opt->default_val.str, dst);

break;

case AV_OPT_TYPE_BINARY:

set_string_binary(s, opt, opt->default_val.str, dst);

break;

case AV_OPT_TYPE_DICT:

/* Cannot set defaults for these types */

break;

default:

av_log(s, AV_LOG_DEBUG, "AVOption type %d of option %s not implemented yet\n",

opt->type, opt->name);

}

这里会遍历AVOption的每一个项，根据每一项的类型，写入一个默认的值。

也就是说，创建AVFormatContext结构体的主要工作是初始化它的internal和AVClass以及AVClass中的AVOption成员。还有就是给它的io_open赋值为io_open_default函数，io_close 赋值为io_close_default函数。

第二件事情

第二件事其实就是init_input函数做的事，这个函数定义如下：

/* Open input file and probe the format if necessary. */

static int init_input(AVFormatContext *s, const char *filename,

AVDictionary **options)

{

int ret;

AVProbeData pd = { filename, NULL, 0 };

int score = AVPROBE_SCORE_RETRY;

if (s->pb) {

s->flags |= AVFMT_FLAG_CUSTOM_IO;

if (!s->iformat)

return av_probe_input_buffer2(s->pb, &s->iformat, filename,

s, 0, s->format_probesize);

else if (s->iformat->flags & AVFMT_NOFILE)

av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "

"will be ignored with AVFMT_NOFILE format.\n");

return 0;

}

if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||

(!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))

return score;

if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)

return ret;

if (s->iformat)

return 0;

return av_probe_input_buffer2(s->pb, &s->iformat, filename,

s, 0, s->format_probesize);

}

从注释上来看，其作用是打开输入文件并且探测它的格式。

因此，这个函数做药做了两件事：

1.打开输入文件

2.探测输入文件的格式

打开输入文件使用的s->io_open，io_open是一个函数指针，着我们在分析第一件事情的时候已经说过了，它的值是io_open_default，看下这个函数，这个函数定义在libavformat/options.c文件中：

static int io_open_default(AVFormatContext *s, AVIOContext **pb,

const char *url, int flags, AVDictionary **options)

{

#if FF_API_OLD_OPEN_CALLBACKS

FF_DISABLE_DEPRECATION_WARNINGS

if (s->open_cb)

return s->open_cb(s, pb, url, flags, &s->interrupt_callback, options);

FF_ENABLE_DEPRECATION_WARNINGS

#endif

return ffio_open_whitelist(pb, url, flags, &s->interrupt_callback, options, s->protocol_whitelist, s->protocol_blacklist);

}

open_cb肯定为空的，我们没有设置过，因此这里会调用ffio_open_whitelist方法。

这个函数定义在Libavformat/aviobuf.c文件中：

int ffio_open_whitelist(AVIOContext **s, const char *filename, int flags,

const AVIOInterruptCB *int_cb, AVDictionary **options,

const char *whitelist, const char *blacklist

)

{

URLContext *h;

int err;

err = ffurl_open_whitelist(&h, filename, flags, int_cb, options, whitelist, blacklist, NULL);

if (err < 0)

return err;

err = ffio_fdopen(s, h);

if (err < 0) {

ffurl_close(h);

return err;

}

return 0;

}

这里首先调用ffurl_open_whitelist方法，这个方法定义在libavformat/avio.c中：

int ffurl_open_whitelist(URLContext **puc, const char *filename, int flags,

const AVIOInterruptCB *int_cb, AVDictionary **options,

const char *whitelist, const char* blacklist,

URLContext *parent)

{

AVDictionary *tmp_opts = NULL;

AVDictionaryEntry *e;

int ret = ffurl_alloc(puc, filename, flags, int_cb);

if (ret < 0)

return ret;

if (parent)

av_opt_copy(*puc, parent);

if (options &&

(ret = av_opt_set_dict(*puc, options)) < 0)

goto fail;

if (options && (*puc)->prot->priv_data_class &&

(ret = av_opt_set_dict((*puc)->priv_data, options)) < 0)

goto fail;

if (!options)

options = &tmp_opts;

av_assert0(!whitelist ||

!(e=av_dict_get(*options, "protocol_whitelist", NULL, 0)) ||

!strcmp(whitelist, e->value));

av_assert0(!blacklist ||

!(e=av_dict_get(*options, "protocol_blacklist", NULL, 0)) ||

!strcmp(blacklist, e->value));

if ((ret = av_dict_set(options, "protocol_whitelist", whitelist, 0)) < 0)

goto fail;

if ((ret = av_dict_set(options, "protocol_blacklist", blacklist, 0)) < 0)

goto fail;

if ((ret = av_opt_set_dict(*puc, options)) < 0)

goto fail;

ret = ffurl_connect(*puc, options);

if (!ret)

return 0;

fail:

ffurl_close(*puc);

*puc = NULL;

return ret;

}

这个函数首先会使用ffurl_alloc方法分配一个URLContext,这个函数也是定义在avio.c文件中：

int ffurl_alloc(URLContext **puc, const char *filename, int flags,

const AVIOInterruptCB *int_cb)

{

URLProtocol *p = NULL;

if (!first_protocol) {

av_log(NULL, AV_LOG_WARNING, "No URL Protocols are registered. "

"Missing call to av_register_all()?\n");

}

p = url_find_protocol(filename);

if (p)

return url_alloc_for_protocol(puc, p, filename, flags, int_cb);

*puc = NULL;

if (av_strstart(filename, "https:", NULL))

av_log(NULL, AV_LOG_WARNING, "https protocol not found, recompile FFmpeg with "

"openssl, gnutls,\n"

"or securetransport enabled.\n");

return AVERROR_PROTOCOL_NOT_FOUND;

}

这个函数会根据所给的文件名找到对应的协议。使用的是url_find_protocol函数，这个函数也是定义在avio.c文件：

static struct URLProtocol *url_find_protocol(const char *filename)

{

URLProtocol *up = NULL;

char proto_str[128], proto_nested[128], *ptr;

size_t proto_len = strspn(filename, URL_SCHEME_CHARS);

printf("proto_len=%ld\n",proto_len);

printf("name is %s\n",filename);

//hello.mp4

if (filename[proto_len] != ':' &&

(strncmp(filename, "subfile,", 8) || !strchr(filename + proto_len + 1, ':')) ||

is_dos_path(filename))

strcpy(proto_str, "file");

else

av_strlcpy(proto_str, filename,

FFMIN(proto_len + 1, sizeof(proto_str)));

//proto_str = file

printf("proto_str=%s\n",proto_str);

if ((ptr = strchr(proto_str, ',')))

*ptr = '\0';

av_strlcpy(proto_nested, proto_str, sizeof(proto_nested));

//proto_nested = proto_str = file

printf("proto_nested=%s\n",proto_nested);

if ((ptr = strchr(proto_nested, '+')))

*ptr = '\0';

while (up = ffurl_protocol_next(up)) {

printf("int while:::up->name %s\n",up->name);

if (!strcmp(proto_str, up->name))

break;

if (up->flags & URL_PROTOCOL_FLAG_NESTED_SCHEME &&

!strcmp(proto_nested, up->name))

break;

}

printf("up->name %s\n",up->name);

return up;

}

这里为了理解程序，我加了一些打印。如果我们传入的参数是一个xxx.mp4这样的本地文件，这个函数找到的协议是file协议，这个协议定义在libavformat/file.c文件中：

const URLProtocol ff_file_protocol = {

.name = "file",

.url_open = file_open,

.url_read = file_read,

.url_write = file_write,

.url_seek = file_seek,

.url_close = file_close,

.url_get_file_handle = file_get_handle,

.url_check = file_check,

.url_delete = file_delete,

.url_move = file_move,

.priv_data_size = sizeof(FileContext),

.priv_data_class = &file_class,

.url_open_dir = file_open_dir,

.url_read_dir = file_read_dir,

.url_close_dir = file_close_dir,

.default_whitelist = "file,crypto"

};

可见，这个协议定义了文件的操作方法，以后，我们打开和读写视频文件都会用到这里对应的方法。现在我们有了一个URLProtocol结构体的实例，它里面定义了对文件的操作函数。找到协议以后，要使用url_alloc_for_protocol函数来创建URLContext 的实例，并且做一堆的初始化工作。这个函数也是定义在avio.c文件中：

static int url_alloc_for_protocol(URLContext **puc, const URLProtocol *up,

const char *filename, int flags,

const AVIOInterruptCB *int_cb)

{

URLContext *uc;

int err;

#if CONFIG_NETWORK

if (up->flags & URL_PROTOCOL_FLAG_NETWORK && !ff_network_init())

return AVERROR(EIO);

#endif

if ((flags & AVIO_FLAG_READ) && !up->url_read) {

av_log(NULL, AV_LOG_ERROR,

"Impossible to open the '%s' protocol for reading\n", up->name);

return AVERROR(EIO);

}

if ((flags & AVIO_FLAG_WRITE) && !up->url_write) {

av_log(NULL, AV_LOG_ERROR,

"Impossible to open the '%s' protocol for writing\n", up->name);

return AVERROR(EIO);

}

uc = av_mallocz(sizeof(URLContext) + strlen(filename) + 1);

if (!uc) {

err = AVERROR(ENOMEM);

goto fail;

}

uc->av_class = &ffurl_context_class;

uc->filename = (char *)&uc[1];

strcpy(uc->filename, filename);

uc->prot = up;

uc->flags = flags;

uc->is_streamed = 0; /* default = not streamed */

uc->max_packet_size = 0; /* default: stream file */

if (up->priv_data_size) {

uc->priv_data = av_mallocz(up->priv_data_size);

if (!uc->priv_data) {

err = AVERROR(ENOMEM);

goto fail;

}

if (up->priv_data_class) {

int proto_len= strlen(up->name);

char *start = strchr(uc->filename, ',');

*(const AVClass **)uc->priv_data = up->priv_data_class;

av_opt_set_defaults(uc->priv_data);

if(!strncmp(up->name, uc->filename, proto_len) && uc->filename + proto_len == start){

int ret= 0;

char *p= start;

char sep= *++p;

char *key, *val;

p++;

if (strcmp(up->name, "subfile"))

ret = AVERROR(EINVAL);

while(ret >= 0 && (key= strchr(p, sep)) && p<key && (val = strchr(key+1, sep))){

*val= *key= 0;

if (strcmp(p, "start") && strcmp(p, "end")) {

ret = AVERROR_OPTION_NOT_FOUND;

} else

ret= av_opt_set(uc->priv_data, p, key+1, 0);

if (ret == AVERROR_OPTION_NOT_FOUND)

av_log(uc, AV_LOG_ERROR, "Key '%s' not found.\n", p);

*val= *key= sep;

p= val+1;

}

if(ret<0 || p!=key){

av_log(uc, AV_LOG_ERROR, "Error parsing options string %s\n", start);

av_freep(&uc->priv_data);

av_freep(&uc);

err = AVERROR(EINVAL);

goto fail;

}

memmove(start, key+1, strlen(key));

}

if (int_cb)

uc->interrupt_callback = *int_cb;

*puc = uc;

return 0;

fail:

*puc = NULL;

if (uc)

av_freep(&uc->priv_data);

av_freep(&uc);

#if CONFIG_NETWORK

if (up->flags & URL_PROTOCOL_FLAG_NETWORK)

ff_network_close();

#endif

return err;

}

这里创建了一个URLContext的实例，并且做了很多的初始化：

uc->av_class = &ffurl_context_class;

uc->filename = (char *)&uc[1];

strcpy(uc->filename, filename);

uc->prot = up;

uc->flags = flags;

uc->is_streamed = 0; /* default = not streamed */

uc->max_packet_size = 0; /* default: stream file */

结束以后，我们就有了URLContext的实例了，当然也有URLProtocol的实例，的它保存在uc->prot里面。

回到ffurl_open_whitelist函数，接下来，该函数会调用ffurl_connect函数，这个函数是要建立连接的意思，我们的文件是本地文件，应该会打开它。这个函数依旧定义在avio.c中：

int ffurl_connect(URLContext *uc, AVDictionary **options)

{

int err;

AVDictionary *tmp_opts = NULL;

AVDictionaryEntry *e;

...

err =

uc->prot->url_open2 ? uc->prot->url_open2(uc,

uc->filename,

uc->flags,

options) :

uc->prot->url_open(uc, uc->filename, uc->flags);

av_dict_set(options, "protocol_whitelist", NULL, 0);

av_dict_set(options, "protocol_blacklist", NULL, 0);

if (err)

return err;

uc->is_connected = 1;

/* We must be careful here as ffurl_seek() could be slow,

* for example for http */

if ((uc->flags & AVIO_FLAG_WRITE) || !strcmp(uc->prot->name, "file"))

if (!uc->is_streamed && ffurl_seek(uc, 0, SEEK_SET) < 0)

uc->is_streamed = 1;

return 0;

}

果然，这里出现了url_open函数的调用，那么对应的就会调用file_open函数，这个函数定义在libavformat/file.c中：

static int file_open(URLContext *h, const char *filename, int flags)

{

FileContext *c = h->priv_data;

int access;

int fd;

struct stat st;

av_strstart(filename, "file:", &filename);

if (flags & AVIO_FLAG_WRITE && flags & AVIO_FLAG_READ) {

access = O_CREAT | O_RDWR;

if (c->trunc)

access |= O_TRUNC;

} else if (flags & AVIO_FLAG_WRITE) {

access = O_CREAT | O_WRONLY;

if (c->trunc)

access |= O_TRUNC;

} else {

access = O_RDONLY;

}

#ifdef O_BINARY

access |= O_BINARY;

#endif

fd = avpriv_open(filename, access, 0666);

if (fd == -1)

return AVERROR(errno);

c->fd = fd;

h->is_streamed = !fstat(fd, &st) && S_ISFIFO(st.st_mode);

return 0;

}

这里参数检查以后，会调用avpriv_open函数，这个函数定义在libavutil/file_open.c中：

int avpriv_open(const char *filename, int flags, ...)

{

int fd;

unsigned int mode = 0;

va_list ap;

va_start(ap, flags);

if (flags & O_CREAT)

mode = va_arg(ap, unsigned int);

va_end(ap);

#ifdef O_CLOEXEC

flags |= O_CLOEXEC;

#endif

#ifdef O_NOINHERIT

flags |= O_NOINHERIT;

#endif

fd = open(filename, flags, mode);

#if HAVE_FCNTL

if (fd != -1) {

if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)

av_log(NULL, AV_LOG_DEBUG, "Failed to set close on exec\n");

}

#endif

return fd;

}

可以看到这里回归到了open这样的系统调用函数了，调用open打开文件后返回文件描述符，这个函数的任务就完成了。这个函数返回到file_open函数后，就把得到的文件描述符赋值给FileContext结构体的fd成员：

c->fd = fd;

之后函数继续返回，函数返回到avio.c中的ffio_open_whitelist函数，接下来调用ffio_fdopen函数，这个函数定义在libavformat下的aviobuf.c中：

int ffio_fdopen(AVIOContext **s, URLContext *h)

{

AVIOInternal *internal = NULL;

uint8_t *buffer = NULL;

int buffer_size, max_packet_size;

max_packet_size = h->max_packet_size;

if (max_packet_size) {

buffer_size = max_packet_size; /* no need to bufferize more than one packet */

} else {

buffer_size = IO_BUFFER_SIZE;

}

buffer = av_malloc(buffer_size);

if (!buffer)

return AVERROR(ENOMEM);

internal = av_mallocz(sizeof(*internal));

if (!internal)

goto fail;

internal->h = h;

*s = avio_alloc_context(buffer, buffer_size, h->flags & AVIO_FLAG_WRITE,

internal, io_read_packet, io_write_packet, io_seek);

if (!*s)

goto fail;

(*s)->protocol_whitelist = av_strdup(h->protocol_whitelist);

if (!(*s)->protocol_whitelist && h->protocol_whitelist) {

avio_closep(s);

goto fail;

}

(*s)->protocol_blacklist = av_strdup(h->protocol_blacklist);

if (!(*s)->protocol_blacklist && h->protocol_blacklist) {

avio_closep(s);

goto fail;

}

(*s)->direct = h->flags & AVIO_FLAG_DIRECT;

(*s)->seekable = h->is_streamed ? 0 : AVIO_SEEKABLE_NORMAL;

(*s)->max_packet_size = max_packet_size;

if(h->prot) {

(*s)->read_pause = io_read_pause;

(*s)->read_seek = io_read_seek;

}

(*s)->av_class = &ff_avio_class;

return 0;

fail:

av_freep(&internal);

av_freep(&buffer);

return AVERROR(ENOMEM);

}

这个函数还是做了很多的事情的：

1.分配一快buffer内存，其大小有这里定义：#define IO_BUFFER_SIZE 32768

buffer的大小本来取决于URLContext的max_packet_size，前面在url_alloc_for_protocol函数中初始化URLContext的时候将其初始化为0了，因此，这里分配的大小为32768。

2.分配一个AVIOContext结构体，这个结构体也很重要，分配完以后我们就有AVIOContext结构体的实例了，分配完成后做了一些初始化工作。

(*s)->direct = h->flags & AVIO_FLAG_DIRECT;

(*s)->seekable = h->is_streamed ? 0 : AVIO_SEEKABLE_NORMAL;

(*s)->max_packet_size = max_packet_size;

(*s)->av_class = &ff_avio_class;

这要注意seekable 是AVIO_SEEKABLE_NORMAL，因为is_streamed 为0,这在url_alloc_for_protocol函数中初始化URLContext的时候将其初始化。

这两件事情做完后函数一路返回，又来到了init_input函数中，是不是都快忘记了，这里就是本文分析的avformat_open_input函数做的第二件事情了。

init_input函数接下来调用av_probe_input_buffer2函数，探测输入的buffer,用来确定文件的格式。这里会创建给长重要的AVInputFormat结构体的实例。这个函数定义在libavformat/format.c中：

int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt,

const char *filename, void *logctx,

unsigned int offset, unsigned int max_probe_size)

{

AVProbeData pd = { filename ? filename : "" };

uint8_t *buf = NULL;

int ret = 0, probe_size, buf_offset = 0;

int score = 0;

int ret2;

if (!max_probe_size)

max_probe_size = PROBE_BUF_MAX;

else if (max_probe_size < PROBE_BUF_MIN) {

av_log(logctx, AV_LOG_ERROR,

"Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);

return AVERROR(EINVAL);

}

if (offset >= max_probe_size)

return AVERROR(EINVAL);

if (pb->av_class) {

uint8_t *mime_type_opt = NULL;

av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type_opt);

pd.mime_type = (const char *)mime_type_opt;

}

#if 0

if (!*fmt && pb->av_class && av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type) >= 0 && mime_type) {

if (!av_strcasecmp(mime_type, "audio/aacp")) {

*fmt = av_find_input_format("aac");

}

av_freep(&mime_type);

}

#endif

for (probe_size = PROBE_BUF_MIN; probe_size <= max_probe_size && !*fmt;

probe_size = FFMIN(probe_size << 1,

FFMAX(max_probe_size, probe_size + 1))) {

score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;

/* Read probe data. */

if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)

goto fail;

if ((ret = avio_read(pb, buf + buf_offset,

probe_size - buf_offset)) < 0) {

/* Fail if error was not end of file, otherwise, lower score. */

if (ret != AVERROR_EOF)

goto fail;

score = 0;

ret = 0; /* error was end of file, nothing read */

}

buf_offset += ret;

if (buf_offset < offset)

continue;

pd.buf_size = buf_offset - offset;

pd.buf = &buf[offset];

memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);

/* Guess file format. */

*fmt = av_probe_input_format2(&pd, 1, &score);

if (*fmt) {

/* This can only be true in the last iteration. */

if (score <= AVPROBE_SCORE_RETRY) {

av_log(logctx, AV_LOG_WARNING,

"Format %s detected only with low score of %d, "

"misdetection possible!\n", (*fmt)->name, score);

} else

av_log(logctx, AV_LOG_DEBUG,

"Format %s probed with size=%d and score=%d\n",

(*fmt)->name, probe_size, score);

#if 0

FILE *f = fopen("probestat.tmp", "ab");

fprintf(f, "probe_size:%d format:%s score:%d filename:%s\n", probe_size, (*fmt)->name, score, filename);

fclose(f);

#endif

}

if (!*fmt)

ret = AVERROR_INVALIDDATA;

fail:

/* Rewind. Reuse probe buffer to avoid seeking. */

ret2 = ffio_rewind_with_probe_data(pb, &buf, buf_offset);

if (ret >= 0)

ret = ret2;

av_freep(&pd.mime_type);

return ret < 0 ? ret : score;

}

这个函数做的事情就是探测文件的格式。它会不断的读文件，然后分析，知道确定了文件的格式位置。

这个函数的for循环每次读PROBE_BUF_MIN个字节的内容，其实就是2048了，然后调用av_probe_input_format2函数来猜测文件的格式：

这个函数也定义在format.c文件中：

AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)

{

int score_ret;

AVInputFormat *fmt = av_probe_input_format3(pd, is_opened, &score_ret);

if (score_ret > *score_max) {

*score_max = score_ret;

return fmt;

} else

return NULL;

}

这里调用av_probe_input_format3继续处理：

该函数还是在format.c中：

AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened,

int *score_ret)

{

AVProbeData lpd = *pd;

AVInputFormat *fmt1 = NULL, *fmt;

int score, nodat = 0, score_max = 0;

const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];

if (!lpd.buf)

lpd.buf = zerobuffer;

if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {

int id3len = ff_id3v2_tag_len(lpd.buf);

if (lpd.buf_size > id3len + 16) {

lpd.buf += id3len;

lpd.buf_size -= id3len;

} else if (id3len >= PROBE_BUF_MAX) {

nodat = 2;

} else

nodat = 1;

}

fmt = NULL;

while ((fmt1 = av_iformat_next(fmt1))) {

if (!is_opened == !(fmt1->flags & AVFMT_NOFILE) && strcmp(fmt1->name, "image2"))

continue;

score = 0;

if (fmt1->read_probe) {

score = fmt1->read_probe(&lpd);

if (score)

av_log(NULL, AV_LOG_TRACE, "Probing %s score:%d size:%d\n", fmt1->name, score, lpd.buf_size);

if (fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions)) {

if (nodat == 0) score = FFMAX(score, 1);

else if (nodat == 1) score = FFMAX(score, AVPROBE_SCORE_EXTENSION / 2 - 1);

else score = FFMAX(score, AVPROBE_SCORE_EXTENSION);

}

} else if (fmt1->extensions) {

if (av_match_ext(lpd.filename, fmt1->extensions))

score = AVPROBE_SCORE_EXTENSION;

}

if (av_match_name(lpd.mime_type, fmt1->mime_type))

score = FFMAX(score, AVPROBE_SCORE_MIME);

if (score > score_max) {

score_max = score;

fmt = fmt1;

} else if (score == score_max)

fmt = NULL;

}

if (nodat == 1)

score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);

*score_ret = score_max;

av_log(NULL, AV_LOG_TRACE, "format----- %s score:%d size:%d\n", fmt->name, score, lpd.buf_size);

return fmt;

}

这个函数会根据文件名的后缀，遍历AVInputFormat的全局链表，比如我们输入的xxx.mp4，那么匹配成功的必然是ff_mov_demuxer了，这个AVInputFormat 实例定义如下：

mp4文件格式解复用器：

AVInputFormat ff_mov_demuxer = {

.name = "mov,mp4,m4a,3gp,3g2,mj2",

.long_name = NULL_IF_CONFIG_SMALL("QuickTime / MOV"),

.priv_class = &mov_class,

.priv_data_size = sizeof(MOVContext),

.extensions = "mov,mp4,m4a,3gp,3g2,mj2",

.read_probe = mov_probe,

.read_header = mov_read_header,

.read_packet = mov_read_packet,

.read_close = mov_read_close,

.read_seek = mov_read_seek,

.flags = AVFMT_NO_BYTE_SEEK,

};

找到对应的AVInputFormat 的实例后，我们的AVFormatContext中的iformat成员就有内容了。至此，我们已经知道了文件的格式了，接下来需要做第三件事情了。

我们简单回顾下。第二件事情做完后，我们的AVFormatContext中的一下成员就被初始化了：

const AVClass *av_class;

struct AVInputFormat *iformat;

void *priv_data;

AVIOContext *pb;

第三件事情

第三件事情就是调用AVInputFormat的read_header方法来解析文件了。我们找到的AVInputFormat的是ff_mov_demuxer ，它的.read_header 初始化为 mov_read_header，这个函数定义在libavformat/mov.c文件中：

static int mov_read_header(AVFormatContext *s)

{

MOVContext *mov = s->priv_data;

AVIOContext *pb = s->pb;

int j, err;

MOVAtom atom = { AV_RL32("root") };//AV)RL32把字符串组合成int类型

int i;

if (mov->decryption_key_len != 0 && mov->decryption_key_len != AES_CTR_KEY_SIZE) {

av_log(s, AV_LOG_ERROR, "Invalid decryption key len %d expected %d\n",

mov->decryption_key_len, AES_CTR_KEY_SIZE);

return AVERROR(EINVAL);

}

mov->fc = s;

mov->trak_index = -1;

/* .mov and .mp4 aren't streamable anyway (only progressive download if moov is before mdat) */

if (pb->seekable)

atom.size = avio_size(pb);

else

atom.size = INT64_MAX;

/* check MOV header */

do {

if (mov->moov_retry)

avio_seek(pb, 0, SEEK_SET);

if ((err = mov_read_default(mov, pb, atom)) < 0) {

av_log(s, AV_LOG_ERROR, "error reading header\n");

mov_read_close(s);

return err;

}

} while (pb->seekable && !mov->found_moov && !mov->moov_retry++);

if (!mov->found_moov) {

av_log(s, AV_LOG_ERROR, "moov atom not found\n");

mov_read_close(s);

return AVERROR_INVALIDDATA;

}

av_log(mov->fc, AV_LOG_TRACE, "on_parse_exit_offset=%"PRId64"\n", avio_tell(pb));

if (pb->seekable) {

if (mov->nb_chapter_tracks > 0 && !mov->ignore_chapters)

mov_read_chapters(s);

for (i = 0; i < s->nb_streams; i++)

if (s->streams[i]->codecpar->codec_tag == AV_RL32("tmcd")) {

mov_read_timecode_track(s, s->streams[i]);

} else if (s->streams[i]->codecpar->codec_tag == AV_RL32("rtmd")) {

mov_read_rtmd_track(s, s->streams[i]);

}

/* copy timecode metadata from tmcd tracks to the related video streams */

for (i = 0; i < s->nb_streams; i++) {

AVStream *st = s->streams[i];

MOVStreamContext *sc = st->priv_data;

if (sc->timecode_track > 0) {

AVDictionaryEntry *tcr;

int tmcd_st_id = -1;

for (j = 0; j < s->nb_streams; j++)

if (s->streams[j]->id == sc->timecode_track)

tmcd_st_id = j;

if (tmcd_st_id < 0 || tmcd_st_id == i)

continue;

tcr = av_dict_get(s->streams[tmcd_st_id]->metadata, "timecode", NULL, 0);

if (tcr)

av_dict_set(&st->metadata, "timecode", tcr->value, 0);

}

export_orphan_timecode(s);

for (i = 0; i < s->nb_streams; i++) {

AVStream *st = s->streams[i];

MOVStreamContext *sc = st->priv_data;

fix_timescale(mov, sc);

if(st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->codec_id == AV_CODEC_ID_AAC) {

st->skip_samples = sc->start_pad;

}

if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && sc->nb_frames_for_fps > 0 && sc->duration_for_fps > 0)

av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,

sc->time_scale*(int64_t)sc->nb_frames_for_fps, sc->duration_for_fps, INT_MAX);

if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {

if (st->codecpar->width <= 0 || st->codecpar->height <= 0) {

st->codecpar->width = sc->width;

st->codecpar->height = sc->height;

}

if (st->codecpar->codec_id == AV_CODEC_ID_DVD_SUBTITLE) {

if ((err = mov_rewrite_dvd_sub_extradata(st)) < 0)

return err;

}

if (mov->handbrake_version &&

mov->handbrake_version <= 1000000*0 + 1000*10 + 2 && // 0.10.2

st->codecpar->codec_id == AV_CODEC_ID_MP3

) {

av_log(s, AV_LOG_VERBOSE, "Forcing full parsing for mp3 stream\n");

st->need_parsing = AVSTREAM_PARSE_FULL;

}

if (mov->trex_data) {

for (i = 0; i < s->nb_streams; i++) {

AVStream *st = s->streams[i];

MOVStreamContext *sc = st->priv_data;

if (st->duration > 0)

st->codecpar->bit_rate = sc->data_size * 8 * sc->time_scale / st->duration;

}

if (mov->use_mfra_for > 0) {

for (i = 0; i < s->nb_streams; i++) {

AVStream *st = s->streams[i];

MOVStreamContext *sc = st->priv_data;

if (sc->duration_for_fps > 0) {

st->codecpar->bit_rate = sc->data_size * 8 * sc->time_scale /

sc->duration_for_fps;

}

for (i = 0; i < mov->bitrates_count && i < s->nb_streams; i++) {

if (mov->bitrates[i]) {

s->streams[i]->codecpar->bit_rate = mov->bitrates[i];

}

ff_rfps_calculate(s);

for (i = 0; i < s->nb_streams; i++) {

AVStream *st = s->streams[i];

MOVStreamContext *sc = st->priv_data;

switch (st->codecpar->codec_type) {

case AVMEDIA_TYPE_AUDIO:

err = ff_replaygain_export(st, s->metadata);

if (err < 0) {

mov_read_close(s);

return err;

}

break;

case AVMEDIA_TYPE_VIDEO:

if (sc->display_matrix) {

AVPacketSideData *sd, *tmp;

tmp = av_realloc_array(st->side_data,

st->nb_side_data + 1, sizeof(*tmp));

if (!tmp)

return AVERROR(ENOMEM);

st->side_data = tmp;

st->nb_side_data++;

sd = &st->side_data[st->nb_side_data - 1];

sd->type = AV_PKT_DATA_DISPLAYMATRIX;

sd->size = sizeof(int32_t) * 9;

sd->data = (uint8_t*)sc->display_matrix;

sc->display_matrix = NULL;

}

break;

}

ff_configure_buffers_for_index(s, AV_TIME_BASE);

return 0;

}

要看懂这个函数的话，的先对mp4文件的格式有所了解（我这里以mp4文件为例）。这里就不展开分析Mp4文件的格式了，请大家自行了解。

mp4文件由一系列的box组成，如下图：

从图中可以看出来这些box是有层级关系的。每一个box它的头部的8个字节是固定的，前四个字节是这个box的大小，后四个字节是这个box的类型，也就是途中的fytp,moov之类的。这个信息在ffmpeg中使用MOVAtom来标示：

typedef struct MOVAtom {

uint32_t type;

int64_t size; /* total size (excluding the size and type fields) */

} MOVAtom;

这个函数的一开始，就够早了一个叫做root的MOVAtom ，并从它开始，遍历这些box,怎么遍历的呢？调用mov_read_default方法，这个方法中，又会递归的调用mov_read_default方法来解析它的子box，一次来推，最终解析所有的box。

接下来我们看看mov_read_default方法;

static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom)

{

int64_t total_size = 0;

MOVAtom a;

int i;

char mmmss[5];

if (c->atom_depth > 10) {

av_log(c->fc, AV_LOG_ERROR, "Atoms too deeply nested\n");

return AVERROR_INVALIDDATA;

}

c->atom_depth ++;

printf("mov_read_default\n");

printf("c->atom_depth=%d\n",c->atom_depth);

if (atom.size < 0)

atom.size = INT64_MAX;

printf("total_size=%ld\n",total_size);

printf("atom.size=%ld\n",atom.size);

printf("avio_feof(pb)=%d\n",avio_feof(pb));

while (total_size + 8 <= atom.size && !avio_feof(pb)) {

int (*parse)(MOVContext*, AVIOContext*, MOVAtom) = NULL;

a.size = atom.size;

a.type=0;

if (atom.size >= 8) {

a.size = avio_rb32(pb);

a.type = avio_rl32(pb);

if (a.type == MKTAG('f','r','e','e') &&

a.size >= 8 &&

c->moov_retry) {

uint8_t buf[8];

uint32_t *type = (uint32_t *)buf + 1;

if (avio_read(pb, buf, 8) != 8)

return AVERROR_INVALIDDATA;

avio_seek(pb, -8, SEEK_CUR);

if (*type == MKTAG('m','v','h','d') ||

*type == MKTAG('c','m','o','v')) {

av_log(c->fc, AV_LOG_ERROR, "Detected moov in a free atom.\n");

a.type = MKTAG('m','o','o','v');

}

if (atom.type != MKTAG('r','o','o','t') &&

atom.type != MKTAG('m','o','o','v'))

{

if (a.type == MKTAG('t','r','a','k') || a.type == MKTAG('m','d','a','t'))

{

av_log(c->fc, AV_LOG_ERROR, "Broken file, trak/mdat not at top-level\n");

avio_skip(pb, -8);

c->atom_depth --;

return 0;

}

total_size += 8;

if (a.size == 1 && total_size + 8 <= atom.size) { /* 64 bit extended size */

a.size = avio_rb64(pb) - 8;

total_size += 8;

}

av_log(c->fc, AV_LOG_TRACE, "type: %08x '%.4s' parent:'%.4s' sz: %"PRId64" %"PRId64" %"PRId64"\n",

a.type, (char*)&a.type, (char*)&atom.type, a.size, total_size, atom.size);

if (a.size == 0) {

a.size = atom.size - total_size + 8;

}

a.size -= 8;

if (a.size < 0)

break;

a.size = FFMIN(a.size, atom.size - total_size);

for (i = 0; mov_default_parse_table[i].type; i++)

if (mov_default_parse_table[i].type == a.type) {

parse = mov_default_parse_table[i].parse;

break;

}

// container is user data

if (!parse && (atom.type == MKTAG('u','d','t','a') ||

atom.type == MKTAG('i','l','s','t')))

parse = mov_read_udta_string;

if (!parse) { /* skip leaf atoms data */

avio_skip(pb, a.size);

} else {

int64_t start_pos = avio_tell(pb);

int64_t left;

int err = parse(c, pb, a);

if (err < 0) {

c->atom_depth --;

return err;

}

if (c->found_moov && c->found_mdat &&

((!pb->seekable || c->fc->flags & AVFMT_FLAG_IGNIDX) ||

start_pos + a.size == avio_size(pb))) {

if (!pb->seekable || c->fc->flags & AVFMT_FLAG_IGNIDX)

c->next_root_atom = start_pos + a.size;

c->atom_depth --;

return 0;

}

left = a.size - avio_tell(pb) + start_pos;

if (left > 0) /* skip garbage at atom end */

avio_skip(pb, left);

else if (left < 0) {

av_log(c->fc, AV_LOG_WARNING,

"overread end of atom '%.4s' by %"PRId64" bytes\n",

(char*)&a.type, -left);

avio_seek(pb, left, SEEK_CUR);

}

total_size += a.size;

mmmss[4]='\0';

printf("-------------while----------");

printf("total_size=%ld\n",total_size);

printf("a.size=%ld\n",a.size);

AV_WL32(mmmss,a.type);

printf("a.type=%s\n",mmmss);

}

为了更好的理解，我加了写打印。这个函数中，没找到一个box，读出它的类型以后，就会调用对应的parse方法。配型与parse方法通过一下数组来对应：

static const MOVParseTableEntry mov_default_parse_table[] = {

{ MKTAG('A','C','L','R'), mov_read_aclr },

{ MKTAG('A','P','R','G'), mov_read_avid },

{ MKTAG('A','A','L','P'), mov_read_avid },

{ MKTAG('A','R','E','S'), mov_read_ares },

{ MKTAG('a','v','s','s'), mov_read_avss },

{ MKTAG('c','h','p','l'), mov_read_chpl },

{ MKTAG('c','o','6','4'), mov_read_stco },

{ MKTAG('c','o','l','r'), mov_read_colr },

{ MKTAG('c','t','t','s'), mov_read_ctts }, /* composition time to sample */

{ MKTAG('d','i','n','f'), mov_read_default },

{ MKTAG('D','p','x','E'), mov_read_dpxe },

{ MKTAG('d','r','e','f'), mov_read_dref },

{ MKTAG('e','d','t','s'), mov_read_default },

{ MKTAG('e','l','s','t'), mov_read_elst },

{ MKTAG('e','n','d','a'), mov_read_enda },

{ MKTAG('f','i','e','l'), mov_read_fiel },

{ MKTAG('f','t','y','p'), mov_read_ftyp },

{ MKTAG('g','l','b','l'), mov_read_glbl },

{ MKTAG('h','d','l','r'), mov_read_hdlr },

{ MKTAG('i','l','s','t'), mov_read_ilst },

{ MKTAG('j','p','2','h'), mov_read_jp2h },

{ MKTAG('m','d','a','t'), mov_read_mdat },

{ MKTAG('m','d','h','d'), mov_read_mdhd },

{ MKTAG('m','d','i','a'), mov_read_default },

{ MKTAG('m','e','t','a'), mov_read_meta },

{ MKTAG('m','i','n','f'), mov_read_default },

{ MKTAG('m','o','o','f'), mov_read_moof },

{ MKTAG('m','o','o','v'), mov_read_moov },

{ MKTAG('m','v','e','x'), mov_read_default },

{ MKTAG('m','v','h','d'), mov_read_mvhd },

{ MKTAG('S','M','I',' '), mov_read_svq3 },

{ MKTAG('a','l','a','c'), mov_read_alac }, /* alac specific atom */

{ MKTAG('a','v','c','C'), mov_read_glbl },

{ MKTAG('p','a','s','p'), mov_read_pasp },

{ MKTAG('s','t','b','l'), mov_read_default },

{ MKTAG('s','t','c','o'), mov_read_stco },

{ MKTAG('s','t','p','s'), mov_read_stps },

{ MKTAG('s','t','r','f'), mov_read_strf },

{ MKTAG('s','t','s','c'), mov_read_stsc },

{ MKTAG('s','t','s','d'), mov_read_stsd }, /* sample description */

{ MKTAG('s','t','s','s'), mov_read_stss }, /* sync sample */

{ MKTAG('s','t','s','z'), mov_read_stsz }, /* sample size */

{ MKTAG('s','t','t','s'), mov_read_stts },

{ MKTAG('s','t','z','2'), mov_read_stsz }, /* compact sample size */

{ MKTAG('t','k','h','d'), mov_read_tkhd }, /* track header */

{ MKTAG('t','f','d','t'), mov_read_tfdt },

{ MKTAG('t','f','h','d'), mov_read_tfhd }, /* track fragment header */

{ MKTAG('t','r','a','k'), mov_read_trak },

{ MKTAG('t','r','a','f'), mov_read_default },

{ MKTAG('t','r','e','f'), mov_read_default },

{ MKTAG('t','m','c','d'), mov_read_tmcd },

{ MKTAG('c','h','a','p'), mov_read_chap },

{ MKTAG('t','r','e','x'), mov_read_trex },

{ MKTAG('t','r','u','n'), mov_read_trun },

{ MKTAG('u','d','t','a'), mov_read_default },

{ MKTAG('w','a','v','e'), mov_read_wave },

{ MKTAG('e','s','d','s'), mov_read_esds },

{ MKTAG('d','a','c','3'), mov_read_dac3 }, /* AC-3 info */

{ MKTAG('d','e','c','3'), mov_read_dec3 }, /* EAC-3 info */

{ MKTAG('w','i','d','e'), mov_read_wide }, /* place holder */

{ MKTAG('w','f','e','x'), mov_read_wfex },

{ MKTAG('c','m','o','v'), mov_read_cmov },

{ MKTAG('c','h','a','n'), mov_read_chan }, /* channel layout */

{ MKTAG('d','v','c','1'), mov_read_dvc1 },

{ MKTAG('s','b','g','p'), mov_read_sbgp },

{ MKTAG('h','v','c','C'), mov_read_glbl },

{ MKTAG('u','u','i','d'), mov_read_uuid },

{ MKTAG('C','i','n', 0x8e), mov_read_targa_y216 },

{ MKTAG('f','r','e','e'), mov_read_free },

{ MKTAG('-','-','-','-'), mov_read_custom },

{ 0, NULL }

};

以trak为例，其解析方法如下：

static int mov_read_trak(MOVContext *c, AVIOContext *pb, MOVAtom atom)

{

AVStream *st;

MOVStreamContext *sc;

int ret;

st = avformat_new_stream(c->fc, NULL);

if (!st) return AVERROR(ENOMEM);

st->id = c->fc->nb_streams;

sc = av_mallocz(sizeof(MOVStreamContext));

if (!sc) return AVERROR(ENOMEM);

st->priv_data = sc;

st->codec->codec_type = AVMEDIA_TYPE_DATA;

sc->ffindex = st->index;

if ((ret = mov_read_default(c, pb, atom)) < 0)

return ret;

/* sanity checks */

if (sc->chunk_count && (!sc->stts_count || !sc->stsc_count ||

(!sc->sample_size && !sc->sample_count))) {

av_log(c->fc, AV_LOG_ERROR, "stream %d, missing mandatory atoms, broken header\n",

st->index);

return 0;

}

fix_timescale(c, sc);

avpriv_set_pts_info(st, 64, 1, sc->time_scale);

mov_build_index(c, st);

if (sc->dref_id-1 < sc->drefs_count && sc->drefs[sc->dref_id-1].path) {

MOVDref *dref = &sc->drefs[sc->dref_id - 1];

if (c->enable_drefs) {

if (mov_open_dref(c, &sc->pb, c->fc->filename, dref,

&c->fc->interrupt_callback) < 0)

av_log(c->fc, AV_LOG_ERROR,

"stream %d, error opening alias: path='%s', dir='%s', "

"filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d\n",

st->index, dref->path, dref->dir, dref->filename,

dref->volume, dref->nlvl_from, dref->nlvl_to);

} else {

av_log(c->fc, AV_LOG_WARNING,

"Skipped opening external track: "

"stream %d, alias: path='%s', dir='%s', "

"filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d."

"Set enable_drefs to allow this.\n",

st->index, dref->path, dref->dir, dref->filename,

dref->volume, dref->nlvl_from, dref->nlvl_to);

}

} else {

sc->pb = c->fc->pb;

sc->pb_is_copied = 1;

}

if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {

if (!st->sample_aspect_ratio.num && st->codec->width && st->codec->height &&

sc->height && sc->width &&

(st->codec->width != sc->width || st->codec->height != sc->height)) {

st->sample_aspect_ratio = av_d2q(((double)st->codec->height * sc->width) /

((double)st->codec->width * sc->height), INT_MAX);

}

#if FF_API_R_FRAME_RATE

if (sc->stts_count == 1 || (sc->stts_count == 2 && sc->stts_data[1].count == 1))

av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,

sc->time_scale, sc->stts_data[0].duration, INT_MAX);

#endif

}

// done for ai5q, ai52, ai55, ai1q, ai12 and ai15.

if (!st->codec->extradata_size && st->codec->codec_id == AV_CODEC_ID_H264 &&

TAG_IS_AVCI(st->codec->codec_tag)) {

ret = ff_generate_avci_extradata(st);

if (ret < 0)

return ret;

}

switch (st->codec->codec_id) {

#if CONFIG_H261_DECODER

case AV_CODEC_ID_H261:

#endif

#if CONFIG_H263_DECODER

case AV_CODEC_ID_H263:

#endif

#if CONFIG_MPEG4_DECODER

case AV_CODEC_ID_MPEG4:

#endif

st->codec->width = 0; /* let decoder init width/height */

st->codec->height= 0;

break;

}

/* Do not need those anymore. */

av_freep(&sc->chunk_offsets);

av_freep(&sc->stsc_data);

av_freep(&sc->sample_sizes);

av_freep(&sc->keyframes);

av_freep(&sc->stts_data);

av_freep(&sc->stps_data);

av_freep(&sc->elst_data);

av_freep(&sc->rap_group);

return 0;

}

一开始，创建一个新流：

AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)

{

AVStream *st;

int i;

AVStream **streams;

if (s->nb_streams >= INT_MAX/sizeof(*streams))

return NULL;

streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));

if (!streams)

return NULL;

s->streams = streams;

st = av_mallocz(sizeof(AVStream));

if (!st)

return NULL;

if (!(st->info = av_mallocz(sizeof(*st->info)))) {

av_free(st);

return NULL;

}

st->info->last_dts = AV_NOPTS_VALUE;

#if FF_API_LAVF_AVCTX

FF_DISABLE_DEPRECATION_WARNINGS

st->codec = avcodec_alloc_context3(c);

if (!st->codec) {

av_free(st->info);

av_free(st);

return NULL;

}

FF_ENABLE_DEPRECATION_WARNINGS

#endif

st->internal = av_mallocz(sizeof(*st->internal));

if (!st->internal)

goto fail;

st->codecpar = avcodec_parameters_alloc();

if (!st->codecpar)

goto fail;

st->internal->avctx = avcodec_alloc_context3(NULL);

if (!st->internal->avctx)

goto fail;

if (s->iformat) {

#if FF_API_LAVF_AVCTX

FF_DISABLE_DEPRECATION_WARNINGS

/* no default bitrate if decoding */

st->codec->bit_rate = 0;

FF_ENABLE_DEPRECATION_WARNINGS

#endif

/* default pts setting is MPEG-like */

avpriv_set_pts_info(st, 33, 1, 90000);

/* we set the current DTS to 0 so that formats without any timestamps

* but durations get some timestamps, formats with some unknown

* timestamps have their first few packets buffered and the

* timestamps corrected before they are returned to the user */

st->cur_dts = RELATIVE_TS_BASE;

} else {

st->cur_dts = AV_NOPTS_VALUE;

}

st->index = s->nb_streams;

st->start_time = AV_NOPTS_VALUE;

st->duration = AV_NOPTS_VALUE;

st->first_dts = AV_NOPTS_VALUE;

st->probe_packets = MAX_PROBE_PACKETS;

st->pts_wrap_reference = AV_NOPTS_VALUE;

st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;

st->last_IP_pts = AV_NOPTS_VALUE;

st->last_dts_for_order_check = AV_NOPTS_VALUE;

for (i = 0; i < MAX_REORDER_DELAY + 1; i++)

st->pts_buffer[i] = AV_NOPTS_VALUE;

st->sample_aspect_ratio = (AVRational) { 0, 1 };

#if FF_API_R_FRAME_RATE

st->info->last_dts = AV_NOPTS_VALUE;

#endif

st->info->fps_first_dts = AV_NOPTS_VALUE;

st->info->fps_last_dts = AV_NOPTS_VALUE;

st->inject_global_side_data = s->internal->inject_global_side_data;

st->internal->need_context_update = 1;

s->streams[s->nb_streams++] = st;

return st;

fail:

free_stream(&st);

return NULL;

}

最后将创建好的新流添加到AVFormatContext中的streams成员，添加到最后一项，并且让nb_streams成员自增。

2.递归解析下一级的box

通过这种解析，可以看到我们获取到了流的信息。

trak包含了很多的子box，这些box描述了trak的功能。比如我们要获取这个流是视频流呢还是音频流呢？亦或者是不是字幕流呢就要通过解析hdlr这个子box来获取：

if ((ret = mov_read_default(c, pb, atom)) < 0)

return ret;

区分音频流还是视频流：

static int mov_read_hdlr(MOVContext *c, AVIOContext *pb, MOVAtom atom)

{

AVStream *st;

uint32_t type;

uint32_t av_unused ctype;

int64_t title_size;

char *title_str;

int ret;

if (c->fc->nb_streams < 1) // meta before first trak

return 0;

st = c->fc->streams[c->fc->nb_streams-1];

avio_r8(pb); /* version */

avio_rb24(pb); /* flags */

/* component type */

ctype = avio_rl32(pb);

type = avio_rl32(pb); /* component subtype */

av_log(c->fc, AV_LOG_TRACE, "ctype= %.4s (0x%08x)\n", (char*)&ctype, ctype);

av_log(c->fc, AV_LOG_TRACE, "stype= %.4s\n", (char*)&type);

if (type == MKTAG('v','i','d','e'))

st->codec->codec_type = AVMEDIA_TYPE_VIDEO;

else if (type == MKTAG('s','o','u','n'))

st->codec->codec_type = AVMEDIA_TYPE_AUDIO;

else if (type == MKTAG('m','1','a',' '))

st->codec->codec_id = AV_CODEC_ID_MP2;

else if ((type == MKTAG('s','u','b','p')) || (type == MKTAG('c','l','c','p')))

st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;

avio_rb32(pb); /* component manufacture */

avio_rb32(pb); /* component flags */

avio_rb32(pb); /* component flags mask */

title_size = atom.size - 24;

if (title_size > 0) {

title_str = av_malloc(title_size + 1); /* Add null terminator */

if (!title_str)

return AVERROR(ENOMEM);

ret = ffio_read_size(pb, title_str, title_size);

if (ret < 0) {

av_freep(&title_str);

return ret;

}

title_str[title_size] = 0;

if (title_str[0]) {

int off = (!c->isom && title_str[0] == title_size - 1);

av_dict_set(&st->metadata, "handler_name", title_str + off, 0);

}

av_freep(&title_str);

}

return 0;

}

其核心代码：

if (type == MKTAG('v','i','d','e'))

st->codec->codec_type = AVMEDIA_TYPE_VIDEO;

else if (type == MKTAG('s','o','u','n'))

st->codec->codec_type = AVMEDIA_TYPE_AUDIO;

else if (type == MKTAG('m','1','a',' '))

st->codec->codec_id = AV_CODEC_ID_MP2;

else if ((type == MKTAG('s','u','b','p')) || (type == MKTAG('c','l','c','p')))

st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;

如果hdlr的第16-20个字节的内容为vide,那么就是视频流，如果是soun,那么就是音频流，如说是subp或者clcp，那么就是字幕流。

我们不可能把所有box的解析都分析一遍，这里对box的解析就到这里，其他的请感兴趣的reader自行分析了。

ffmpeg学习三写第一个程序-视频解封装与解码

写第一个程序-视频解封装与解码

前面通过阅读《FFmpeg Basic》这本书，对ffmpeg工程和视频编解码的基本知识有了一定的理解，学习编程最重要的当然是动手实践了，所以这片博客，我将会完整记录自己第一次编写视频解码程序的过程。这个程序能将一个视频转换为一帧一帧的图片。这个程序参考了decoding_encoding.c文件，但使它们还是有很大的不同。

解码流程总结

流程图：

程序的步骤：

step 1:open file,get format info from file header

step 2:get stread info

step 3:find vido stream

step 4:find decoder

step 5:get one instance of AVCodecContext,decode need it.

step 6: open codec

step 7:read frame

step 8:save frame

代码中就是这样注释的，这里只是提取来，方便梳理逻辑。

step1-step3其实就是解复用。

step4-step7其实就是解编码

step8把得到的图像保存下来

下面来安具体的程序

编写程序

//created by Jinwei Liu

#include <math.h>

#include <libavutil/opt.h>

#include <libavcodec/avcodec.h>

#include <libavutil/channel_layout.h>

#include <libavutil/common.h>

#include <libavutil/imgutils.h>

#include <libavutil/mathematics.h>

#include <libavutil/samplefmt.h>

#include <libavformat/avformat.h>

#include <libswscale/swscale.h>

void saveFrame(AVFrame* pFrame, int width, int height, int iFrame,const char *outname)

{

FILE *pFile;

char szFilename[32];

int y;

// Open file

sprintf(szFilename, outname, iFrame);

pFile = fopen(szFilename, "wb");

if (pFile == NULL)

return;

// Write header

fprintf(pFile, "P6\n%d %d\n255\n", width, height);

// Write pixel data

for (y = 0; y < height; y++)

fwrite(pFrame->data[0] + y*pFrame->linesize[0], 1, width * 3, pFile);

// Close file

fclose(pFile);

}

static void video_decode_example(const char *outfilename, const char *filename)

{

AVFormatContext* pFormatCtx = NULL;

//step 1:open file,get format info from file header

if (avformat_open_input(&pFormatCtx, filename, NULL, NULL) != 0){

fprintf(stderr,"avformat_open_input");

return;

}

//step 2:get stread info

if (avformat_find_stream_info(pFormatCtx, NULL) < 0){

fprintf(stderr,"avformat_find_stream_info");

return;

}

//just output format info of input file

av_dump_format(pFormatCtx, 0, filename, 0);

int videoStream = -1;

//step 3:find vido stream

for (int i = 0; i < pFormatCtx->nb_streams; i++)

{

if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)

{

videoStream = i;

break;

}

if (videoStream == -1){

fprintf(stderr,"find video stream error");

return;

}

AVCodecContext* pCodecCtxOrg = NULL;

AVCodecContext* pCodecCtx = NULL;

AVCodec* pCodec = NULL;

pCodecCtxOrg = pFormatCtx->streams[videoStream]->codec; // codec context

//step 4:find decoder

pCodec = avcodec_find_decoder(pCodecCtxOrg->codec_id);

if (!pCodec){

fprintf(stderr,"avcodec_find_decoder error");

return;

}

//step 5:get one instance of AVCodecContext,decode need it.

pCodecCtx = avcodec_alloc_context3(pCodec);

if (avcodec_copy_context(pCodecCtx, pCodecCtxOrg) != 0){

fprintf(stderr,"avcodec_copy_context error");

return;

}

//step 6: open codec

if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0){

fprintf(stderr,"avcodec_open2 error");

return;

}

AVFrame* pFrame = NULL;

AVFrame* pFrameRGB = NULL;

pFrame = av_frame_alloc();

pFrameRGB = av_frame_alloc();

int numBytes = 0;

uint8_t* buffer = NULL;

numBytes = avpicture_get_size(AV_PIX_FMT_RGB24, pCodecCtx->width, pCodecCtx->height);

buffer = (uint8_t*)av_malloc(numBytes * sizeof(uint8_t));

avpicture_fill((AVPicture*)pFrameRGB, buffer, AV_PIX_FMT_RGB24, pCodecCtx->width, pCodecCtx->height);

struct SwsContext* sws_ctx = NULL;

sws_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt,

pCodecCtx->width, pCodecCtx->height, AV_PIX_FMT_RGB24, SWS_BILINEAR, NULL, NULL, NULL);

AVPacket packet;

int i = 0;

//step 7:read frame

while (av_read_frame(pFormatCtx, &packet) >= 0)

{

int frameFinished = 0;

avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &packet);

if (frameFinished)

{

sws_scale(sws_ctx, (uint8_t const * const *)pFrame->data, pFrame->linesize, 0,

pCodecCtx->height, pFrameRGB->data, pFrameRGB->linesize);

if (++i <= 5)

{

//step 8:save frame

saveFrame(pFrameRGB, pCodecCtx->width, pCodecCtx->height, i,outfilename);

}

//release resource

av_free_packet(&packet);

av_free(buffer);

av_frame_free(&pFrameRGB);

av_frame_free(&pFrame);

avcodec_close(pCodecCtx);

avcodec_close(pCodecCtxOrg);

avformat_close_input(&pFormatCtx);

}

int main(int argc, char **argv)

{

const char *output_type;

/* register all the codecs */

av_register_all();

if (argc < 2) {

printf("usage: %s input_file\n"

"example: ./decoding_mp4.bin hello.mp4",

argv[0]);

return 1;

}

video_decode_example("hello%02d.ppm", argv[1]);

return 0;

}

编译完成后， ./decoding_mp4.bin hello.mp4,就会生成一系列的hello%2d.ppm的图片。
大家不要被名字迷惑了，虽然这里的名字是解码mp4文件，而且我们一开始的目标也是解码mp4文件，但是它是可以解码其他格式的视频的，大家可以试试。

ffmpeg学习二

一.格式转换

格式转换是ffmpeg工具用的最多的地方了。我们可以使用-f选项，在输出文件之前指定输出文件的格式。

1-1媒体格式

1-1-1文件格式

媒体格式是能够存储音视频数据的特殊的文件类型。如果一个文件中存储了多个流，那么它就称之为容器。我们可以使用ffmpeg -formats命令来查看ffpmeg支持的媒体格式。

1-1-2媒体容器

媒体容器是一个特别封装过的文件，其特殊的格式用来存放多个流以及他们的元数据（metadata）。因为音视频可以被很多的算法进行编解码，那么，媒体容器则提供了简单的方法来将多个流存储在一个文件中。有些容器只能存储音频流，有些容器只能存储图像，但是大多数容器可以存储音频，视频，元数据，字幕等多个流。

如果容器发生了改变，但是编解码器保持不变，这种情况下我们可以使用-c copy或者-c:a copy 或者-c:v copy选项来标示：

ffmpeg -i input.avi -q 1 -c copy output.mov

1-2转码（Transcoding）和格式转换（conversion）

我不确定这个翻译恰不恰当…

Transcoding是使用mmpeg工具，利用输入文件到生成输出文件的过程，这个过程可能包含了格式的转换，也可能没有包含格式转换，知识同一种格式的视频中的一些数据发生了改变。

关于转码，还是看图吧：

1-3编解码器（codec）

codec这个名字来源于**co**der-**dec**oder，编解码器表示一个设备或者软件工具，使用特定的算法，对音频或者视频文件进行压缩或者解压缩的过程。ffmpeg已经定义了很多的编解码器，我们可以使用一下命令查看：

ffmpeg -codecs …显示所有的编解码器

ffmpeg -decoders …仅显示解码器

ffmpeg -encoders …仅显示编码器

在命令行中，我们可以使用-c or -codec选项来指定使用的编解码器，语法格式如下：

-codec[:stream_specifier] codec_name

输入文件和输出文件都可以指定编解码器。如果输出文件包含了多个流，那么每个流都可以指定编解码器，如果我们指定了输出文件的格式，但是没有指定编解码器，那么，ffmpeg就会使用默认的编解码器。

1-4覆盖同名输出文件

如果指定名字的输出文件已经存在，那么ffmpeg就会询问你的意见，你看一选择yes或者no来决定要不要覆盖同名文件。如果想避免这个过程，我们可以直接使用-y或者-n选项来指定要不要覆盖同名文件，比如：

ffmpeg -y -i input.avi output.mp4

这样，如果存在output.mp4文件，就会直接覆盖它。

1-5格式转换中使用的通用的选项

通用选项可以用于设备，容器，以及编解码器。

二.时间的操作

多媒体处理包括了改变输入文件的时长，设置一个延时，选择输入文件的一部分等。这些操作都可以介绍一个指定的时间，时间格式如下：

HH指小时，MM指分钟，SS或者S指的是秒，m指的是毫秒

2-1音视频文件的时长

使用-t选项可以指定音视频文件的时长。比如：

ffmpeg -i music.mp3 -t 180 music_3_minutes.mp3

这样就把music_3_minutes.mp3的时长改为了3分钟。

2-2设置帧数

通过设置帧数，自然而然的就设置了时长,可用的选项如下：

audio: -aframes number or -frames:a number

data: -dframes number or -frames:d number

video: -vframes number or -frames:v number

举例：

ffmpeg -i video.avi -vframes 15000 video_10_minutes.avi

2-3设置从起始位置开始的延迟

使用-ss选项，指定延迟的秒数即可，举例：

ffmpeg -i input.avi -ss 10 output.mp4

2-4提取指定文件的特定部份

通过组合使用-ss和-t，即可提取媒体文件的特定部分。-ss限定延时，-t限定时长，这样不就提取出从ss开始的时长为t的部分媒体数据了吗？

举例：

ffmpeg -i video.mpg -ss 240 -t 60 clip_5th_minute.mpg

2-5输入流之间的延迟

通常有两种情况，一种是一个流需要延迟输出，另一种是两个流都需要延迟输出。我们可以使用-itsoffset (input timestamp offset)来创建一个延迟，同时使用-map来选择指定的流。需要注意的是，AVI, FLV, MOV, MP4有着不同的数据头，-itsoffset选项对这几种格式不起作用。我们可以创建一个延迟的流，并把这个流保存到文件中，然后合并两个文件：

ffmpeg -i input.avi -ss 1 audio.mp3

ffmpeg -i input.avi -i audio.mp3 -map 0:v -map 1:a video.mp4

这样音视频就有了时差。

2-5-1一个输入文件

如果一个输入文件包含了音频流和视频流，并且这两个流不同步，音频流提前了1.5秒，那么我们可以把音频流延迟1.5秒：

ffmpeg -i input.mov -map 0:v -map 0:a -itsoffset 1.5 -c:a copy -c:v copy output.mov

2-5-2多个输入文件

如果输入文件有多个，加入我们想要延迟音频3秒钟，可以使用如下命令：

ffmpeg -i v.mpg -itsoffset 3 -i a.mp3 -map 0:v:0 -map 1:a:0 output.mp4

2-6限制处理时间

有时候，限制ffmpeg命令运行的时间是很重要的，这个时候我们可以使用-timelimit选项：

ffmpeg -i input.mpg -timelimit 600 output.mkv

这样，限制了这条命令执行的时间为10分钟。

2-7最短的流决定编码时间

如果想要让编码时间由时间最短的那个流来决定，那么可以使用-shortest选项。

举例：

ffmpeg -i video.avi -i audio.mp3 -shortest output.mp4

2-8时间戳和时间基准

为了设置多媒体容器的时间戳，我们可以使用-timestamp选项，改选项的值有如下几种：

时间戳的例子：

2010-12-24T12:00:00, 20101224t120000z, 20101224120000

2-9视频速度的修改

为了修改视频的播放速率，我们可以使用setpts视频过滤器。

比如，要把视频播放速度加快3倍：

ffplay -i input.mpg -vf setpts=PTS/3

2-10音频速率的修改

为了修改音频播放的速率，我们可以使用atempo[过滤器，比如，要把音频加快两倍，我们可以执行如下命令：

ffplay -i speech.mp3 -af atempo=2

2-11使用时间戳同步音视频

为了使用时间戳同步音频数据，我们可以使用asyncts音频过滤器。比如，为了使用时间戳同步音频数据，我们可以使用如下命令：

ffmpeg -i music.mpg -af asyncts=compensate=1 -f mpegts music.ts

三.元数据和字幕

3-1元数据

元数据通常在mp3文件中使用，播放器通常会显示歌曲的名字，作者，相册等信息。

3-2创建元数据

媒体文件中包含的元数据可以使用-metadata选项，后面跟key=value的方式来指定，比如我们想给一个media file指定元数据，那么可以使用如下命令：

ffmpeg -i input -metadata artist=FFmpeg -metadata title="Test 1" output

3-3保存或者装载元数据到/从文件中

我们可以输出一个媒体文件的原数组信息到一个文件，我们需要使用-f选项来制定ffmetadata格式为输出格式比如：

ffmpeg -i video.wmv -f ffmetadata data.txt

也可以从一个文件装载元数据,比如：

ffmpeg -i data.txt -i video1.avi video1.wmw

3-4删除元数据

为了删除元数据，我们可以使用-map_metadata选项。用法举例：

ffmpeg -i input.avi -map_metadata -1 output.mp4

3-5字幕

字幕大家都很熟悉吧，字幕一般存储在一个单独的文件中或者打包进视频文件中。

为了编码字幕到视频文件中，我们可以这样做：

ffmpeg -i video.avi -vf subtitles=titles.srt video.mp4

四.图片处理

4-1创建图片

通过截图创建：

ffmpeg -i input -ss t image.type

或者这样：

ffmpeg -i videoclip.avi -ss 01:23:45 image.jpg

4-2创建gif

ffmpeg -i promotion.swf -pix_fmt rgb24 promotion.gif

这条命令可以直接把promotion.swf视频生成gif图片。

4-3视频转为图片

ffmpeg -i clip.avi frame%d.jpg

4-4缩放，裁剪，填充图片

填充：

ffmpeg -f lavfi -i smptebars -vf pad=360:280:20:20:orange pad_smpte.jpg

裁剪：

ffmpeg -f lavfi -i rgbtestsrc -vf crop=150:150 crop_rgb.png

修改大小：

ffmpeg -f lavfi -i color=c=orange:s=cif orange_rect1.png

ffmpeg -f lavfi -i color=c=orange -s cif orange_rect2.png

4-5翻转，旋转，覆盖图片

和视频操作类似，就不啰嗦了。

翻转：

ffmpeg -i orange.jpg -vf hflip orange_hflip.jpg

ffmpeg -i orange.jpg -vf vflip orange_vflip.jpg

旋转：

ffmpeg -i image.png -vf transpose=1 image_rotated.png

覆盖：

ffmpeg -f lavfi -i rgbtestsrc -s 400x300 rgb.png

ffmpeg -f lavfi -i smptebars smpte.png

ffmpeg -i rgb.png -i smpte.png -filter_complex overlay=(W-w)/2:(H-h)/2 ^

rgb_smpte.png

4-6格式转换

命令个数如下：

ffmpeg -i image.type1 image.type2

举例：

ffmpeg -i illustration.png illustration.jpg

4-7使用图片来创建视频

一张图片创建视频

比如，使用一张图片来创建一个10秒钟的视频：

ffmpeg -loop 1 -i photo.jpg -t 10 photo.mp4

多张图片创建视频：

ffmpeg -f image2 -i img%d.jpg -r 25 video.mp4

这条命令指定输入文件的格式为image2格式，然后使用所有命名为img1.jpg,img3.jpg,img3.jpg…的图片来创建一个视频。-r来指定帧率。

五.麦克风和网络摄像头

5-1查看输入设备信息

我们可以使用如下的命令来列举出可用的麦克风和网络摄像头：

ffmpeg -list_devices 1 -f dshow -i dummy

效果如下：

数据显示了摄像头的名称为：”HP Webcam”，麦克风的名称为：”Microphone (Realtek High Defini”。

接下来，我们可以使用这两个名称做进一步操作。

5-2查看工作模式

摄像头一般有多个工作模式，我们可以使用-list_options来显示摄像头的工作模式，麦克风也是类似的，后面会讲到。

命令如下：

ffmpeg -list_options true -f dshow -i video="HP Webcam"

输出如下：

[dshow @ 021bd040] Pin "Capture"

[dshow @ 021bd040] min s=640x480 fps=15 max s=640x480 fps=30

[dshow @ 021bd040] min s=160x120 fps=15 max s=160x120 fps=30

[dshow @ 021bd040] min s=176x144 fps=15 max s=176x144 fps=30

[dshow @ 021bd040] min s=320x240 fps=15 max s=320x240 fps=30

[dshow @ 021bd040] min s=352x288 fps=15 max s=352x288 fps=30

video=HP Webcam: Immediate exit requested

ffmpeg -list_options true -f dshow -i video="HP Webcam"

5-3显示和录制摄像头数据

显示：

ffplay -f dshow -i video="HP Webcam"

ffmpeg -f dshow -i video="HP Webcam" -f sdl "webcam via ffmpeg"

第一条命令使用ffplay来显示摄像头数据，第二条使用SDL输出设备。

录制

ffmpeg -f dshow -i video="HP Webcam" webcam.avi

将录制的内容保存到avi文件中。

5-4使用两个摄像头

还是使用这个命令来查看：

ffmpeg -list_devices 1 -f dshow -i dummy

假如信息如下：

[dshow @ 01f7d000] DirectShow video devices

[dshow @ 01f7d000] "Sirius USB2.0 Camera"

[dshow @ 01f7d000] "HP Webcam"

[dshow @ 01f7d000] DirectShow audio devices

[dshow @ 01f7d000] "Microphone (Realtek High Defini"

然后使用下面的命令来显示两个视频：

ffmpeg -f dshow -i "video=Sirius USB2.0 Camera" -f dshow -video_size qvga ^

-i "video=HP Webcam" -filter_complex overlay -f sdl "2 webcams"

5-5录音并用扬声器显示

显示麦克风的工作模式：

ffmpeg -list_options 1 -f dshow -i "audio=Microphone (Realtek High Defini"

录音：

ffmpeg -f dshow -i audio="Microphone (Realtek High Defini" -t 60 mic.mp3

播放麦克风的声音：

ffplay -f dshow -i audio="Microphone (Realtek High Defini"

同时录音和录视频并保存到同一个文件：

ffmpeg -f dshow -i audio="Microphone (Realtek High Defini":^

video="HP Webcam" webcam_with_sound.avi

ffmpeg学习一

ffmpeg下载地址

ffprobe获得音视频文件信息

如:ffprobe 1.mp4

ffmpeg可以方便进行视频转码等

ffmpeg -i 1.mp4 1.avi

基本概念

一.波特率，帧率，和文件大小

1.1帧率

1-1-1帧率的基本概念

帧率，英文说就是frames per second（FPS or fps）,也就是每秒钟的帧数，完整的说就是每秒钟编码到视频文件中的帧数称之为帧率。帧率超过15HZ，人眼才能感觉到它是视频，小于15就会觉得这是在播放幻灯片…现在Android设备通常要求的是60Hz，也就是一秒钟播放60帧的画面，这样就会觉得视频非常的流畅。

帧率又分为两种模式，交错模式和持续模式。交错模式主要指各行扫描，也就是说一幅图片显示出来，分两次来显示，第一次显示奇数行，第二次显示偶数行。持续模式则是一行一行的从头到尾的显示。

1-1-2设置帧率

1-1-2-1 使用-r选项

为了设置帧率，我们需要在输出文件之前添加-r选项，格式如下：

ffmpeg -i input -r fps output

比如，我们想把一个avi格式的视频文件的帧率，从25Hz改为30Hz,我们可以这么做:

ffmpeg -i input.avi -r 30 output.mp4

1-1-2-2使用视频过滤器

除了-r选项，我们还可以使用视频过滤器来重置帧率，比如，要把一个输入文件的帧率改为25,我们可以使用如下命令：

ffmpeg -i clip.mpg -vf fps=fps=25 clip.webm

那么什么是视频过滤器呢？视频文件可以看做是一帧一帧的图片组成的，过滤器就是对使用一套规则，对着一组图片进行处理。把一个视频的帧率改为25，就意味着我们创建了一个规则，也就是1秒钟编码25帧图片到视频文件中去。对于两个视频文件，这必然意味着解码与编码的双重工作，也就是说修改了帧率，其实就是把源视频文件解码再重新编码。

1-2比特率

Bit rate,每秒钟处理的bit的数量。这个参数直接影响着音视频质量，比特率决定了编码的时候，1秒钟存储的bit数。

1-2-1设置比特率

比特率的设置使用-b选项。对于视频比特率和音频比特率，分别对应着-b:v和-b:a的格式来设置对应的比特率。比如，我们要设置一个视频文件的比特率，可以这样：

ffmpeg -i film.avi -b 1.5M film.mp4

这样会把视频流和音频流的比特率都设置为1.5M。

我们也可以分别设置视频流和音频流的比特率：

ffmpeg -i film.avi -b:v 1.5M -b:a 1M film.mp4

1-3文件大小的计算

视频文件的大小计算公式：

video_size = video_bitrate * time_in_seconds / 8

无压缩音频文件大小的计算公式：

audio_size = sampling_rate * bit_depth * channels * time_in_seconds / 8

压缩后音频文件大小的计算公式：

audio_size = bitrate * time_in_seconds / 8

对于一个包含音频和视频的文件，其大小为二者之和。

比如，我们有一段10分钟的视频文件，视频比特率为1500kbits,音频比特率为128kbits,那么整个文件的大小计算如下：

file_size = (video_bitrate + audio_bitrate) * time_in_seconds / 8

file_size = (1500 kbit/s + 128 kbits/s) * 600 s

file_size = 1628 kbit/s * 600 s

file_size = 976800 kb = 976800000 b / 8 = 122100000 B / 1024 = 119238.28125 KB

file_size = 119238.28125 KB / 1024 = 116.443634033203125 MB ≈ 116.44 MB

1 byte (B) = 8 bits (b)

1 kilobyte (kB or KB) = 1024 B

1 megabyte (MB) = 1024 KB, etc.

二.视频的缩放

2-1 使用-s选项

重新改变视频的大小，使用-s选项指定视频帧的大小：

ffmpeg -i input_file -s 320x240 output_file

2-2高级缩放

高级缩放使用的是scale视频过滤器。

使用格式如下：

scale=width:height[:interl={1|-1}]

比如，下面两个命令有相同的结果：

ffmpeg -i input.mpg -s 320x240 output.mp4

ffmpeg -i input.mpg -vf scale=320:240 output.mp4

-vf 就是（video filter），scale是这个视频过滤器的名字，ffmpeg工程中有很多的视频过滤器，后面还有很多…

2-3按比例缩放

缩小到一半：

ffmpeg -i input.mpg -vf scale=iw/2:ih/2 output.mp4

缩小到0.9倍大小：

ffmpeg -i input.mpg -vf scale=iw*0.9:ih*0.9 output.mp4

三.视频裁剪

3-1crop

视频裁剪又用到了另一个视频过滤器：crop

用法如下：

各个参数的意义：

举例：如果我们要分别裁剪视频的左三分之一，中间三分之一，右三分之一，可分别执行如下命令：

ffmpeg -i input -vf crop=iw/3:ih:0:0 output

ffmpeg -i input -vf crop=iw/3:ih:iw/3:0 output

ffmpeg -i input -vf crop=iw/3:ih:iw/3*2:0 output

3-2cropdetect

cropdetect过滤器用来自动裁剪视频的非黑色区域。有些视频上下或者左右会有黑色区域，如果我们想获得只包含有效数据（不包含黑色区域）的视频，那么，我们可以使用这个过滤器。

比如所，为了裁剪非黑区域，我们可以使用如下命令：

ffmpeg -i input.mpg -vf cropdetect=limit=0 output.mp4

limit用来限定颜色的值。这里的意思就是裁剪的区域的颜色值为黑色。从中我们可以看到我们可以给limit不同的赋值，来裁剪出非指定颜色的区域。

3-3裁剪时间

视频播放器通常有一个进度条，而且会显示播放的时间，大多数播放器一般会在鼠标扫过播放器的时候才会显示这些。那么，如果我们想要裁剪出时间，我们要怎么办呢？
ffmpeg有一个testsrc的视频源，这个视频包含了时间的显示：

那么我们想要裁剪出其中的时间，可以这样：

ffmpeg -f lavfi -i testsrc -vf crop=29:52:256:94 -t 10 timer1.mpg

crop可以有四种取值，分别对应不同的时间范围：

四.视频填充

视频填充使用的pad视频过滤器，这个过滤器用法如下：

各个参数的意义：

比如说，我们要个一个图片填充30个像素的粉红色边框，可以这样：

ffmpeg -i photo.jpg -vf pad=860:660:30:30:pink framed_photo.jpg

4-1填充4：3的视频为16：9

命令格式如下：

ffmpeg -i input -vf pad=ih*16/9:ih:(ow-iw)/2:0:color output

4-2填充16：9的视频为4：3

命令格式如下：

ffmpeg -i input -vf pad=iw:iw*3/4:0:(oh-ih)/2:color output

当然了，填充的视频不局限于4:3还是16:9，我们完全可以填充为任意比例的视频。

五.翻转和旋转视频

5-1水平翻转

水平翻转使用hflip视频过滤器。
用法举例：

ffplay -f lavfi -i testsrc -vf hflip

5-2垂直翻转

垂直翻转使用vflip视频过滤器。
用法举例：

ffplay -f lavfi -i rgbtestsrc -vf vflip

5-3旋转

旋转使用transpose视频过滤器。
transpose用法如下：

，你可以发现下面两个命令是等价的：

ffplay -f lavfi -i smptebars -vf transpose=0

ffplay -f lavfi -i smptebars -vf transpose=2,vflip

下面两个命令也是等价的：

ffplay -f lavfi -i smptebars -vf transpose=3

ffplay -f lavfi -i smptebars -vf transpose=1,vflip

六.模糊化、锐化和其他去噪

6-1模糊化

模糊化可提高特定噪声的图片的质量。ffmpeg提供了两种模糊化的视频过滤器：boxblur和smartblur。

用法举例：

ffmpeg -i input.mpg -vf boxblur=1.5:1 output.mp4

ffmpeg -i halftone.jpg -vf smartblur=5:0.8:0 blurred_halftone.png

6-2降低锐化

降低锐化可以使用unsharp视频过滤器。

用法举例：

ffmpeg -i input -vf unsharp output.mp4

ffmpeg -i input -vf unsharp=6:6:-2 output.mp4

6-3去噪

denoise3d可用于减少噪声。

用法举例：

ffmpeg -i input.mpg -vf mp=denoise3d output.webm

这一章目前一笔带过，reader可以自行阅读《FFmpeg Basic》这本书第八章

七.覆盖-图片中的图片

覆盖是非常常见的视频处理，比如有些视频会有时间显示，有些电视节目会显示频道的Logo等等。
覆盖
视频覆盖技术可以在后面的视频或者图片上覆盖一层前面的视频或者图片。ffmpeg提供了overlay视频过滤器实现覆盖。用法见下表：

用法格式如下：

ffmpeg -i input1 -i input2 -filter_complex overlay=x:y output

input1是后台视频，input2是前台视频。x,y是覆盖开始的左上角的位置。

注意，这里使用的是-filter_complex选项，而不是-vf选项。因为现在有两个输入源，以前的例子都是只有一个输入源。

7-1角落的logo

左上角的Logo:

ffmpeg -i pair.mp4 -i logo.png -filter_complex overlay pair1.mp4

右上角的logo:

ffmpeg -i pair.mp4 -i logo.png -filter_complex overlay=W-w pair2.mp4

右下角的logo:

ffmpeg -i pair.mp4 -i logo.png -filter_complex overlay=W-w:H-h pair3.mp4

左下角的Logo:

ffmpeg -i pair.mp4 -i logo.png -filter_complex overlay=0:H-h pair4.mp4

7-2特定时刻显示logo

比如，要在5秒后显示Logo:

ffmpeg -i video_with_timer.mp4 -itsoffset 5 -i logo.png ^

-filter_complex overlay timer_with_logo.mp4

7-3给视频添加时间

首先从testsrc视频源中裁剪出时间：

ffmpeg -f lavfi -i testsrc -vf crop=61:52:224:94 -t 30 timer.ogg

然后把它覆盖到另一个视频上：

ffmpeg -i start.mp4 -i timer.ogg -filter_complex overlay=451 startl.mp4

八.给视频添加文字

给视频添加文字使用drawtext视频过滤器。

8-1显示文字

如下例子：

ffplay -f lavfi -i color=c=white ^

-vf drawtext=fontfile=/Windows/Fonts/arial.ttf:text=Welcome

fontfile用来指定字体，text用来指定要显示的内容。

8-2指定位置

那么，要指定在具体的位置显示，该怎么指定位置呢？可以使用x,y来指定要显示的位置：

比如：

ffplay -f lavfi -i color=c=white -vf ^

drawtext="fontfile=arial.ttf:text='Good day':x=(w-tw)/2:y=(h-th)/2"

这要字体Good day就会显示在视频中间了。

8-3字体大小和颜色的设置

比如：

ffplay -f lavfi -i color=c=white -vf drawtext=^

"fontfile=arial.ttf:text='Happy Holidays':x=(w-tw)/2:y=(h-th)/2:^

fontcolor=green:fontsize=30"

也就是说我们可以使用fontcolor和green:fontsize分别指定文字的颜色和大小。

8-4动态文字

变量t代表视频当前的秒数。我们可以通过t来改变x,y，从而使得文字的位置动态的改变。

8-4-1水平方向的移动

举例：

ffmpeg -f lavfi -i color=c=#abcdef -vf drawtext=

"fontfile=arial.ttf:text='Dynamic RTL text':x=w-t*50:

fontcolor=darkorange:fontsize=30" output

这里，x=w-t*50,因此，x随着t的增大不断的减小，位置也不断的左移。

8-4-2垂直方向的移动

举例：

ffmpeg -i palms.avi -vf drawtext="fontfile=arial.ttf:textfile=Credits:

x=w/2:y=h-t*100:fontcolor=white:fontsize=30" clip.mp4

这里y=h-t*100,随着时间的增加，h不断减小，文字不断的上移。

ffmpeg实现图片+音频合成视频的开发

原文

一、需求

用户针对一个PPT的每一页图片，进行语音录制，输出多段音频文件，将用户每段音频和对应的PPT图片拼接起来，最后输出成一整段MP4视频，作为教学视频播放

二、方案选择

针对需求，最开始提出了几个主要的方案

方案	优点	缺点
方案一：直播推流录制	使用现成直播方案，上手成本小	业务逻辑要和直播业务切割隔离，重新弄一套，不合适，而且感觉杀鸡用牛刀
方案二：客户端处理图片、音频合成，视频拼接等多媒体操作	1、后端业务简单; 2、大多数视频处理类APP都是如此，方案成熟	1、前端要新嵌入七牛多媒体处理SDK，对包稳定性有影响 2、APP处理视频，可能比较耗费手机性能，如果APP受众用户是中老年用户，可能手机性能扛不住
方案三：服务端统一处理图片、音频合成，视频拼接等多媒体操作	1、客户端无需再嵌入SDK 2、对用户手机性能的要求降到最低	服务端交互逻辑变复杂，并且要处理耗时的多媒体合成任务

最终定了方案三，原因是该功能的受众是老年用户，手机性能可能很差，耗时的操作交给服务端来比较合适

三、方案执行

3.1 初版方案

查询了一下，对应图片+音频合成视频，这样的音画合成的操作，七牛并没有提供API~
所以只能服务端采用万能的多媒体处理工具：ffmpeg 了，整体方案如下

可以看到上述方案，有两个关键操作：

关键操作	描述	如何触发
音画合成	图片+音频合成视频	客户端接口触发，用户每录一段语音，则服务端立马调异步任务进行音画合成
视频mp4拼接	不同的视频片段拼接成一整段视频	客户端接口触发，用户点击预览或提交审核，服务端检查所有语音片段是否音画合成完毕，条件符合则进行视频mp4拼接

注意，七牛提供了视频mp4拼接的接口，但是经过实践，用ffmpeg进行本地视频mp4拼接没有任何问题，并且速度很快，所以这里所有操作都用本地 ffmpeg 来进行

ffmpeg 不具体介绍，详情可自行google：

官网：https://ffmpeg.org/

参数详解：https://zhuanlan.zhihu.com/p/31674583

具体ffmpeg的命令执行操作，第一版的执行如下：

关键操作	描述	ffmpeg操作和参考
音画合成	图片+音频合成视频	`ffmpeg -i 1976.aac -i mulan.jpg -acodec aac -strict -2 -vcodec libx264 -ar 22050 -ab 128k -ac 2 -pix_fmt yuvj420p -y conf_liutao_test1.mp4` 参考来源：https://blog.51cto.com/cjxkaka/1569109
视频mp4拼接	不同的视频片段拼接成一整段视频	如下

$ cat mylist.txt

file '/path/to/file1'

file '/path/to/file2'

file '/path/to/file3'

$ ffmpeg -f concat

-i mylist.txt

-c copy output

3.2 遇到的问题和优化

问题1. 音画合成的视频，在有些浏览器中无法拖动进度条

咨询了人森导师手哥，他给我介绍了一个工具：mediainfo，该工具可以查看视频详情，如音轨(Audio)和画面(Video)的时长，通过该工具可以看到通过第一版操作音画合成的视频，画面时长只有40ms，然而音轨时长却有7s，这里存在严重的不同步，因此在有些浏览器（safari）中并不能正常拖动进度条播放：

问题1的解决办法

参考：Combine one image + one audio file to make one video using FFmpeg

中"community wiki"的回答，使用如下ffmpeg命令可以正常生成Video_Duration和Audio_Duration接近的视频

ffmpeg -loop 1 -i xuanwu.jpg

-i 1.aac

-c:v libx264 -tune stillimage

-c:a aac -b:a 192k -pix_fmt yuvj420p

-shortest liutao_test_2.mp4

问题2：将不同的音画合成后的视频片段拼接起来后生成的最终课程录制视频，会有音画不同步的问题

现象是明明是第一个PPT的录音，画面已经翻到PPT第二页了，录音还在播放第一页PPT尾段的录制语音

原因：通过 mediainfo 查看最后生成的最终拼接视频，发现还是存在 Video_Duration和Audio_Duration 不一致的问题

应该是第一步音画合成的视频片段本身就有 Video_Duration和Audio_Duration 不完全一致，将他们拼接起来后，是音轨和画面轨道分别拼接，最后两条轴出现了不一致的问题。

因此，我们需要在第一步音画合成的时候做处理，让 Video_Duration和Audio_Duration 保持严格一致或尽量接近

问题2的解决办法

在音画合成后，多一步操作，对合成的视频片段，进行人为剪裁~让视频的 Video_Duration和Audio_Duration 保持一致：

ffmpeg -i input.mp4

-ss 00:00:00

-t 00:00:11.72

-acodec aac -vcodec h264

-strict -2 cut_output.mp4

如此生成的视频 Video_Duration和Audio_Duration 不会有太大差距。

问题3：安卓端的播放器，播放合成的课程视频，依然无法拖动视频的进度条

和安卓端同学沟通后，定位问题是视频缺少关键帧，需要为视频加入关键帧

问题3的解决办法

参考：https://codeday.me/bug/20180927/259812.html

在音画合成截断，就针对视频插入关键帧，关键命令：

ffmpeg -x264-params keyint=1:scenecut=0

上面的keyint=1表示每隔1帧插入设置一个关键帧

问题4：音画合成的速度特别慢，音画合成生成的文件也特别的大

首先观察现象，发现图片大小为 212k，音频 .aac 文件大小为 132k，生成的视频文件居然会是540k

怀疑是帧率问题，google了一下，ffmpeg指令如果不人为设定帧率，默认帧率为25，而我们音画合成的视频就是一张图片，并不需要太高的帧率，这个地方应该可以优化下

问题4的解决办法

参考：https://zhuanlan.zhihu.com/p/31674583

经过人为设置帧率为1，生成文件大小优化为356k

人为设置帧率为1的关键指令如下：

ffmpeg -r 1

同时，写了个小脚本，做了下实验验证，人为设置帧率，也大大降低了处理速度：

实验：对比使用 -r 2 设置帧率(fps) 来对静态图的mp4处理速度和大小进行优化

第一组：帧率使用默认值为25的处理：

Array

(

[command] => ffmpeg -loop 1 -i mulan.jpg -i 1_min.aac -c:v libx264 -c:a aac -b:a 64k -pix_fmt yuvj420p -shortest liutao_test_1min_64k.mp4

[spend] => 46401.793956757ms

)

第二组：帧率认为设定为2的处理（使用命令参数 -r 2 认为指定帧率为2）：

Array

(

[command] => ffmpeg -loop 1 -i mulan.jpg -i 1_min.aac -r 2 -c:v libx264 -c:a aac -b:a 64k -pix_fmt yuvj420p -shortest liutao_test_1min_64k_r2.mp4

[spend] => 21741.201877594ms

)

生成文件大小的对比

[med@qa liutao]$ du -ak liutao_test_1min_64k.mp4 liutao_test_1min_64k_r2.mp4

1404 liutao_test_1min_64k.mp4

548 liutao_test_1min_64k_r2.mp4

从上面的实验看起来，针对1分钟的音频，人为设置帧率为2使得处理耗时降低了至少50%，生成文件大小降低了近60%

问题5：音画合成后的视频，截断后又丢失了关键帧

音画合成后的视频，是带有关键帧信息的，为何截断后又丢失了关键帧？

经过仔细对比，发现音画合成和截断的命令，有着细微差距

1,音画合成：

ffmpeg -loop 1

-i mulan.jpg

-i 2191.aac

-r 1

-c:v libx264 -x264-params keyint=1:scenecut=0

-c:a aac

-b:a 32k -pix_fmt yuvj420p

-shortest

liutao_test_2191_mulan_r1_key1.mp4

2，截断：

ffmpeg -i output1.mp4

-ss 00:00:00

-t 00:00:06.80

-acodec aac

-vcodec h264

-strict -2 output1_cut.mp4

仔细观察上面两个命令，经过google，发现【-c:a】和【-acodec】是一个意思，表示音频编码方式，【-c:v】和【-vcodec】是一个意思，表示视频编码方式

这里两个指令的视频编码方式，一个指定的使用 libx264，一个使用h264, 怀疑是这里的不一致导致关键帧丢失

经过试验，发现猜测正确。

问题5的解决办法：

将音画合成和视频截断的音频解码方式统一为 libx264,就能保证截断后视频的关键帧不丢失：

1,音画合成：

ffmpeg -loop 1

-i mulan.jpg

-i 2191.aac

-r 1

-c:v libx264 -x264-params keyint=1:scenecut=0

-c:a aac

-b:a 32k -pix_fmt yuvj420p

-shortest

liutao_test_2191_mulan_r1_key1.mp4

2，截断：

ffmpeg -i output1.mp4

-ss 00:00:00

-t 00:00:06.80

-acodec aac

-vcodec libx264 -x264-params keyint=1:scenecut=0

-strict -2 output1_cut.mp4

3.3 最终的视频处理命令

三个步骤：

音画合成，图片+音频合成视频

ffmpeg -loop 1

-i mulan.jpg

-i 2191.aac

-r 1

-c:v libx264 -x264-params keyint=1:scenecut=0

-c:a aac

-b:a 32k

-pix_fmt yuvj420p

-shortest liutao_test_2191_mulan_r1_key1.mp4

该指令人为设置合成帧率为1，降低处理耗时和生成文件大小,
人为设置关键帧间隔为每间隔1帧设置一个，解决安卓RN播放无法拉动进度条的问题

对音画合成后的视频片段进行截断

ffmpeg

-ss 00:00:00

-t 00:00:20.096

-accurate_seek

-i liutao_test_pre_2191.mp4

-acodec aac

-vcodec libx264 -x264-params keyint=1:scenecut=0

-strict -2

liutao_test_final_2191.mp4

参考：我是CSDN博客链接
截断是为了保证音轨长度和画面轨道长度
尽量保持一致，杜绝拼接后的音画不同步问题

视频mp4拼接,不同的视频片段拼接成一整段视频

$ cat mylist.txt

file '/path/to/file1'

file '/path/to/file2'

file '/path/to/file3'

$ ffmpeg -f concat

-i mylist.txt

-c copy output

ffmpeg命令收集

截取指定时长的音频

ffmpeg -i input.mp3 -ss hh:mm:ss -t hh:mm:ss -acodec copy output.mp3

参数说明：

-ss : 指定从那裡开始

-t : 指定到那裡结束

-acodec copy : 编码格式和来源档桉相同（就是mp3）

这方法不只是MP3可以用，其他的许多格式也都适用，只是输出档桉的副档名就要跟着改一改了。

以下举个例子，如果我想把aa.mp3中的1分12秒到1分42秒的地方切出来，然后存成bb.mp3，指令如下

ffmpeg -i aa.mp3 -ss 00:01:12 -t 00:01:42 -acodec copy bb.mp3

ffmpeg -i VIDEO0018.avi -ss 00:01:12 -t 00:01:42 -f mp3 bb.mp3

硬压字幕参数

ffmpeg -i "imput.mp4" -lavfi "subtitles=subtitles.srt:force_style='Alignment=0,OutlineColour=&H100000000,BorderStyle=3,

Outline=1,Shadow=0,Fontsize=18,MarginL=5,MarginV=25'" -crf 1 -c:a copy "output.mp4"

01.Name 风格(Style)的名称. 区分大小写. 不能包含逗号.

02.Fontname 使用的字体名称, 区分大小写.

03.Fontsize 字体的字号

04.PrimaryColour 设置主要颜色, 为蓝-绿-红三色的十六进制代码相排列, BBGGRR. 为字幕填充颜色

05.SecondaryColour 设置次要颜色, 为蓝-绿-红三色的十六进制代码相排列, BBGGRR. 在卡拉OK效果中由次要颜色变为主要颜色.

06.OutlineColour 设置轮廓颜色, 为蓝-绿-红三色的十六进制代码相排列, BBGGRR.

07.BackColour 设置阴影颜色, 为蓝-绿-红三色的十六进制代码相排列, BBGGRR. ASS的这些字段还包含了alpha通道信息. (AABBGGRR), 注ASS

的颜色代码要在前面加上&H

08.Bold -1为粗体, 0为常规

09.Italic -1为斜体, 0为常规

10.Underline [-1 或者 0] 下划线

11.Strikeout [-1 或者 0] 中划线/删除线

12.ScaleX 修改文字的宽度. 为百分数

13.ScaleY 修改文字的高度. 为百分数

14.Spacing 文字间的额外间隙. 为像素数

15.Angle 按Z轴进行旋转的度数, 原点由alignment进行了定义. 可以为小数

16.BorderStyle 1=边框+阴影, 3=纯色背景. 当值为3时, 文字下方为轮廓颜色的背景, 最下方为阴影颜色背景.

17.Outline 当BorderStyle为1时, 该值定义文字轮廓宽度, 为像素数, 常见有0, 1, 2, 3, 4.

18.Shadow 当BorderStyle为1时, 该值定义阴影的深度, 为像素数, 常见有0, 1, 2, 3, 4.

19.Alignment 定义字幕的位置. 字幕在下方时, 1=左对齐, 2=居中, 3=右对齐. 1, 2, 3加上4后字幕出现在屏幕上方. 1, 2, 3加上8后字幕出现在屏幕中间. 例: 11=屏幕中间右对齐. Alignment对于ASS字幕而言, 字幕的位置与小键盘数字对应的位置相同.

20.MarginL 字幕可出现区域与左边缘的距离, 为像素数

21.MarginR 字幕可出现区域与右边缘的距离, 为像素数

22.MarginV 垂直距离

感谢分享，亲测成功。需要说明的是命令里面的引号逗号是错误的全角字符，说明作者也是抄来的没有自己运行过。我修改后可以运行的命令如下： ffmpeg -i "1.mp4" -lavfi "subtitles=1.srt:force_style='Alignment=0,OutlineColour=&H100000000,BorderStyle=3,

Outline=1,Shadow=0,Fontsize=18,MarginL=5,MarginV=25'" -crf 28 -c:a copy "output.mp4" 注意文件名如果是中文一般会报错，建议先记录一下原始文件名，然后改成1.mp4这样的文件名，处理完再改回原来文件名即可

转MP4有时会报错可保存为output.mkv

Alignment

参数效果

1 ↙屏幕下方左对齐 (Bottom Left)

2 屏幕下方居↓中↓ (Bottom Center)

3 屏幕下方右对齐 (Bottom Right)↘

5 ↖屏幕上间左对齐 (Top Left)

6 屏幕上间居↑中↑ (Top Center)

7 屏幕上间右对齐 (Top Right)↗

9 ←屏幕中间左对齐 (Middle Left)

10 屏幕中间居中 (Middle Center)

11 屏幕中间右对齐 (Middle Right)→

4 标题

8 居中

设置背景字幕背景透明

ffmpeg -i "VIDEO0018.avi" -lavfi "subtitles=1.srt:force_style='Alignment=2,PrimaryColour=&H00FFFF,OutlineColour=&HFF000000,BorderStyle=3,

Outline=1,Shadow=0,Fontsize=18,MarginL=5,MarginV=25'" -crf 28 -c:a copy "output.mkv"

颜色&HAABBGGRR

ABGR颜色设置

其中A为透明度FF为完全透明

添加时分秒

ffmpeg -i output.mkv -vf drawtext="fontfile=arial.ttf:x=w-tw:fontcolor=white:fontsize=30:text='%{localtime\:%H\\\:%M\\\:%S}'" output2.mkv

使用ffmpeg可以很轻松的把ass/vtt/lyric转换为srt文件

fmpeg -i a.ass b.srt

ffmpeg -i c.vtt d.srt

ffmpeg -i e.lyric f.srt

转换命令示例

wav 文件转 16k 16bits 位深的单声道pcm文件

ffmpeg -y -i 16k.wav -acodec pcm_s16le -f s16le -ac 1 -ar 16000 16k.pcm

44100 采样率单声道 16bts pcm 文件转 16000采样率 16bits 位深的单声道pcm文件

ffmpeg -y -f s16le -ac 1 -ar 44100 -i test44.pcm -acodec pcm_s16le -f s16le -ac 1 -ar 16000 16k.pcm

mp3 文件转 16K 16bits 位深的单声道 pcm文件

ffmpeg -y -i aidemo.mp3 -acodec pcm_s16le -f s16le -ac 1 -ar 16000 16k.pcm

// -acodec pcm_s16le pcm_s16le 16bits 编码器

// -f s16le 保存为16bits pcm格式

// -ac 1 单声道

// -ar 16000 16000采样率

正常输出如下：

Input #0, mp3, from 'aaa.mp3':

Metadata:

encoded_by : Lavf52.24.1

Duration: 00:02:33.05, start: 0.000000, bitrate: 128 kb/s

Stream #0:0: Audio: mp3, 44100 Hz, stereo, s16p, 128 kb/s

// 输入音频， MP3格式， 44100采样率，stereo-双声道， 16bits 编码

Output #0, s16le, to '16k.pcm':

Metadata:

encoded_by : Lavf52.24.1

encoder : Lavf57.71.100

Stream #0:0: Audio: pcm_s16le, 16000 Hz, mono, s16, 256 kb/s

// 输入音频， MP3格式， 16000采样率，mono-单声道， 16bits

// 256 kb/s = 32KB/s = 32B/ms

ffmpeg命令

ffmpeg {通用参数} {输入音频参数} {输出音频参数}

ffmpeg -y -i aidemo.mp3 -acodec pcm_s16le -f s16le -ac 1 -ar 16000 16k.pcm

通用参数： -y

输入音频mp3文件参数： -i aidemo.mp3

输出音频 16000采样率单声道 pcm 格式： -acodec pcm_s16le -f s16le -ac 1 -ar 16000 16k.pcm

示例：输入是 32000HZ的单声道 16bits pcm文件。查询下文的输入参数为 “ -f s16le -ac 1 -ar 32000 -i test32.pcm” 输出是 16000HZ的单声道 16bits pcm文件。查询下文的输出参数为 “-f s16le -ac 1 -ar 16000 16k.pcm” 常用参数选择 -y

合并如下：

ffmpeg -y -f s16le -ac 1 -ar 32000 -i test32.pcm -f s16le -ac 1 -ar 16000 16k.pcm

输入音频参数

wav、amr、 mp3及m4a格式都自带头部，含有采样率编码多声道等信息。而pcm为原始音频信息，没有类似头部。 wav（pcm编码）格式，仅仅在同样参数的pcm文件加了个几个字节的文件头。

输入 wav、amr、mp3及m4a 等格式：

-i test.wav # 或test.mp3 或者 test.amr

输入 pcm格式： pcm需要额外告知编码格式，采样率，单声道信息

-acodec pcm_s16le -f s16le -ac 1 -ar 16000 -i 8k.pcm

// 单声道 16000 采样率 16bits编码 pcm文件

// s16le s(signied)16(16bits)le(Little-Endian)

-acodec pcm_s16le：使用s16le进行编码

-f s16le 文件格式是s16le的pcm

-ac 1 ：单声道

-ar 16000 ： 16000采样率

输出音频参数

在原始采样率大于或者接近16000的时候，推荐使用16000的采样率。 8000的采样率会降低识别效果。输出wav和amr格式时，如果不指定输出编码器，ffmpeg会选取默认编码器。

输出pcm音频：

-f s16le -ac 1 -ar 16000 16k.pcm

// 单声道 16000 采样率 16bits编码 pcm文件

输出wav 音频：

-ac 1 -ar 16000 16k.wav

// 单声道 16000 采样率 16bits编码 pcm编码的wav文件

输出amr-nb 音频：

全称是：Adaptive Multi-Rate，自适应多速率，是一种音频编码文件格式，专用于有效地压缩语音频率。在带宽不是瓶颈的情况下，不建议选择这种格式，解压需要百度服务器额外的耗时 amr-nb格式只能选 8000采样率。bit rates越高音质越好，但是文件越大。 bit rates 4.75k, 5.15k, 5.9k, 6.7k, 7.4k, 7.95k, 10.2k or 12.2k

8000的采样率及有损压缩会降低识别效果。如果原始采样率大于16000，请使用 amr-wb格式。

-ac 1 -ar 8000 -ab 12.2k 8k-122.amr

// 8000 采样率 12.2 bitRates

输出 amr-wb 格式，采样率 16000。 bit rates越高音质越好，但是文件越大。 6600 8850 12650 14250 15850 18250 19850 23050 23850

-acodec amr_wb -ac 1 -ar 16000 -ab 23850 16k-23850.amr

输出m4a文件

m4a文件一般来源于微信小程序录音（见restapi文档中微信录音小程序的参数说明）。不建议其它格式转为m4a；推荐转为amr有损压缩格式调用restapi。

如果您一定要转为百度支持的m4a格式，见后文的m4a文件转码

常用参数

-y 覆盖同名文件

-v 日志输出基本如 -v ERROR -v quiet 等

查看音频格式ffprobe使用

查看语音合成生成的MP3格式信息：

ffprobe -v quiet -print_format json -show_streams aidemo.mp3

ffmpeg 视频无损拼接和一键拼接方法

首先，把要合并的视频按顺序写到files.txt里，例如

file '1.mp4'

file '2.mp4'

注意必须单引号

然后

ffmpeg -f concat -safe 0 -i files.txt -c copy output.mp4

即可

注意：这一行指令使用了-c copy，说明他只适用于视频切割产生的分段，被合并的视频必须是相同的参数！！如果你需要合并参数不同的视频，把-c copy去掉或者自己写压制参数，参考参数：-c:v libx264 -crf 23 -profile:v high -level 5 -c:a aac -b:a 240k

作为一个懒人，这么麻烦的步骤才不要一次一次手动操作呢，于是就有一个神器诞生了：一键合并

按顺序选中需要合并的文件，然后拖拽到那个程序窗口里就好了，选中的顺序决定合并后的顺序，然后同目录里就会有一个合并好的视频了

ffmpeg合并音频文件，以达到混音效果

ffmpeg合并音频文件，以达到混音效果，通改过ffmpeg命令行实现需要的功能，具体可参考ffmpeg帮助或相应的手册

ffmpeg -i 0.mp3 -i 00.mp3 -filter_complex amix=inputs=2:duration=first:dropout_transition=2 -f mp3 000.mp3

这样，就把0.mp3和00.mp3，合并成了000.mp3文件。

试听一下。

ffmpeg实现录屏+录音

#include "stdafx.h"

#ifdef __cplusplus

extern "C"

{

#endif

#include "libavcodec/avcodec.h"

#include "libavformat/avformat.h"

#include "libswscale/swscale.h"

#include "libavdevice/avdevice.h"

#include "libavutil/audio_fifo.h"

#pragma comment(lib, "avcodec.lib")

#pragma comment(lib, "avformat.lib")

#pragma comment(lib, "avutil.lib")

#pragma comment(lib, "avdevice.lib")

#pragma comment(lib, "avfilter.lib")

//#pragma comment(lib, "avfilter.lib")

//#pragma comment(lib, "postproc.lib")

//#pragma comment(lib, "swresample.lib")

#pragma comment(lib, "swscale.lib")

#ifdef __cplusplus

};

#endif

AVFormatContext *pFormatCtx_Video = NULL, *pFormatCtx_Audio = NULL, *pFormatCtx_Out = NULL;

AVCodecContext *pCodecCtx_Video;

AVCodec *pCodec_Video;

AVFifoBuffer *fifo_video = NULL;

AVAudioFifo *fifo_audio = NULL;

int VideoIndex, AudioIndex;

CRITICAL_SECTION AudioSection, VideoSection;

SwsContext *img_convert_ctx;

int frame_size = 0;

uint8_t *picture_buf = NULL, *frame_buf = NULL;

bool bCap = true;

DWORD WINAPI ScreenCapThreadProc( LPVOID lpParam );

DWORD WINAPI AudioCapThreadProc( LPVOID lpParam );

int OpenVideoCapture()

{

AVInputFormat *ifmt=av_find_input_format("gdigrab");

//这里可以加参数打开，例如可以指定采集帧率

AVDictionary *options = NULL;

av_dict_set(&options, "framerate", "15", NULL);

//av_dict_set(&options,"offset_x","20",0);

//The distance from the top edge of the screen or desktop

//av_dict_set(&options,"offset_y","40",0);

//Video frame size. The default is to capture the full screen

//av_dict_set(&options,"video_size","320x240",0);

if(avformat_open_input(&pFormatCtx_Video, "desktop", ifmt, &options)!=0)

{

printf("Couldn't open input stream.（无法打开视频输入流）\n");

return -1;

}

if(avformat_find_stream_info(pFormatCtx_Video,NULL)<0)

{

printf("Couldn't find stream information.（无法获取视频流信息）\n");

return -1;

}

if (pFormatCtx_Video->streams[0]->codec->codec_type != AVMEDIA_TYPE_VIDEO)

{

printf("Couldn't find video stream information.（无法获取视频流信息）\n");

return -1;

}

pCodecCtx_Video = pFormatCtx_Video->streams[0]->codec;

pCodec_Video = avcodec_find_decoder(pCodecCtx_Video->codec_id);

if(pCodec_Video == NULL)

{

printf("Codec not found.（没有找到解码器）\n");

return -1;

}

if(avcodec_open2(pCodecCtx_Video, pCodec_Video, NULL) < 0)

{

printf("Could not open codec.（无法打开解码器）\n");

return -1;

}

img_convert_ctx = sws_getContext(pCodecCtx_Video->width, pCodecCtx_Video->height, pCodecCtx_Video->pix_fmt,

pCodecCtx_Video->width, pCodecCtx_Video->height, PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);

frame_size = avpicture_get_size(pCodecCtx_Video->pix_fmt, pCodecCtx_Video->width, pCodecCtx_Video->height);

//申请30帧缓存

fifo_video = av_fifo_alloc(30 * avpicture_get_size(AV_PIX_FMT_YUV420P, pCodecCtx_Video->width, pCodecCtx_Video->height));

return 0;

}

static char *dup_wchar_to_utf8(wchar_t *w)

{

char *s = NULL;

int l = WideCharToMultiByte(CP_UTF8, 0, w, -1, 0, 0, 0, 0);

s = (char *) av_malloc(l);

if (s)

WideCharToMultiByte(CP_UTF8, 0, w, -1, s, l, 0, 0);

return s;

}

int OpenAudioCapture()

{

//查找输入方式

AVInputFormat *pAudioInputFmt = av_find_input_format("dshow");

//以Direct Show的方式打开设备，并将输入方式关联到格式上下文

char * psDevName = dup_wchar_to_utf8(L"audio=麦克风 (Realtek High Definition Au");

if (avformat_open_input(&pFormatCtx_Audio, psDevName, pAudioInputFmt,NULL) < 0)

{

printf("Couldn't open input stream.（无法打开音频输入流）\n");

return -1;

}

if(avformat_find_stream_info(pFormatCtx_Audio,NULL)<0)

return -1;

if(pFormatCtx_Audio->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO)

{

printf("Couldn't find video stream information.（无法获取音频流信息）\n");

return -1;

}

AVCodec *tmpCodec = avcodec_find_decoder(pFormatCtx_Audio->streams[0]->codec->codec_id);

if(0 > avcodec_open2(pFormatCtx_Audio->streams[0]->codec, tmpCodec, NULL))

{

printf("can not find or open audio decoder!\n");

}

return 0;

}

int OpenOutPut()

{

AVStream *pVideoStream = NULL, *pAudioStream = NULL;

const char *outFileName = "test.mp4";

avformat_alloc_output_context2(&pFormatCtx_Out, NULL, NULL, outFileName);

if (pFormatCtx_Video->streams[0]->codec->codec_type == AVMEDIA_TYPE_VIDEO)

{

AVCodecContext *videoCodecCtx;

VideoIndex = 0;

pVideoStream = avformat_new_stream(pFormatCtx_Out, NULL);

if (!pVideoStream)

{

printf("can not new stream for output!\n");

return -1;

}

//set codec context param

pVideoStream->codec->codec = avcodec_find_encoder(AV_CODEC_ID_MPEG4);

pVideoStream->codec->height = pFormatCtx_Video->streams[0]->codec->height;

pVideoStream->codec->width = pFormatCtx_Video->streams[0]->codec->width;

pVideoStream->codec->time_base = pFormatCtx_Video->streams[0]->codec->time_base;

pVideoStream->codec->sample_aspect_ratio = pFormatCtx_Video->streams[0]->codec->sample_aspect_ratio;

// take first format from list of supported formats

pVideoStream->codec->pix_fmt = pFormatCtx_Out->streams[VideoIndex]->codec->codec->pix_fmts[0];

//open encoder

if (!pVideoStream->codec->codec)

{

printf("can not find the encoder!\n");

return -1;

}

if (pFormatCtx_Out->oformat->flags & AVFMT_GLOBALHEADER)

pVideoStream->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;

if ((avcodec_open2(pVideoStream->codec, pVideoStream->codec->codec, NULL)) < 0)

{

printf("can not open the encoder\n");

return -1;

}

if(pFormatCtx_Audio->streams[0]->codec->codec_type == AVMEDIA_TYPE_AUDIO)

{

AVCodecContext *pOutputCodecCtx;

AudioIndex = 1;

pAudioStream = avformat_new_stream(pFormatCtx_Out, NULL);

pAudioStream->codec->codec = avcodec_find_encoder(pFormatCtx_Out->oformat->audio_codec);

pOutputCodecCtx = pAudioStream->codec;

pOutputCodecCtx->sample_rate = pFormatCtx_Audio->streams[0]->codec->sample_rate;

pOutputCodecCtx->channel_layout = pFormatCtx_Out->streams[0]->codec->channel_layout;

pOutputCodecCtx->channels = av_get_channel_layout_nb_channels(pAudioStream->codec->channel_layout);

if(pOutputCodecCtx->channel_layout == 0)

{

pOutputCodecCtx->channel_layout = AV_CH_LAYOUT_STEREO;

pOutputCodecCtx->channels = av_get_channel_layout_nb_channels(pOutputCodecCtx->channel_layout);

}

pOutputCodecCtx->sample_fmt = pAudioStream->codec->codec->sample_fmts[0];

AVRational time_base={1, pAudioStream->codec->sample_rate};

pAudioStream->time_base = time_base;

//audioCodecCtx->time_base = time_base;

pOutputCodecCtx->codec_tag = 0;

if (pFormatCtx_Out->oformat->flags & AVFMT_GLOBALHEADER)

pOutputCodecCtx->flags |= CODEC_FLAG_GLOBAL_HEADER;

if (avcodec_open2(pOutputCodecCtx, pOutputCodecCtx->codec, 0) < 0)

{

//编码器打开失败，退出程序

return -1;

}

if (!(pFormatCtx_Out->oformat->flags & AVFMT_NOFILE))

{

if(avio_open(&pFormatCtx_Out->pb, outFileName, AVIO_FLAG_WRITE) < 0)

{

printf("can not open output file handle!\n");

return -1;

}

if(avformat_write_header(pFormatCtx_Out, NULL) < 0)

{

printf("can not write the header of the output file!\n");

return -1;

}

return 0;

}

int _tmain(int argc, _TCHAR* argv[])

{

av_register_all();

avdevice_register_all();

if (OpenVideoCapture() < 0)

{

return -1;

}

if (OpenAudioCapture() < 0)

{

return -1;

}

if (OpenOutPut() < 0)

{

return -1;

}

InitializeCriticalSection(&VideoSection);

InitializeCriticalSection(&AudioSection);

AVFrame *picture = av_frame_alloc();

int size = avpicture_get_size(pFormatCtx_Out->streams[VideoIndex]->codec->pix_fmt,

pFormatCtx_Out->streams[VideoIndex]->codec->width, pFormatCtx_Out->streams[VideoIndex]->codec->height);

picture_buf = new uint8_t[size];

avpicture_fill((AVPicture *)picture, picture_buf,

pFormatCtx_Out->streams[VideoIndex]->codec->pix_fmt,

pFormatCtx_Out->streams[VideoIndex]->codec->width,

pFormatCtx_Out->streams[VideoIndex]->codec->height);

//star cap screen thread

CreateThread( NULL, 0, ScreenCapThreadProc, 0, 0, NULL);

//star cap audio thread

CreateThread( NULL, 0, AudioCapThreadProc, 0, 0, NULL);

int64_t cur_pts_v=0,cur_pts_a=0;

int VideoFrameIndex = 0, AudioFrameIndex = 0;

while(1)

{

if (_kbhit() != 0 && bCap)

{

bCap = false;

Sleep(2000);//简单的用sleep等待采集线程关闭

}

if (fifo_audio && fifo_video)

{

int sizeAudio = av_audio_fifo_size(fifo_audio);

int sizeVideo = av_fifo_size(fifo_video);

//缓存数据写完就结束循环

if (av_audio_fifo_size(fifo_audio) <= pFormatCtx_Out->streams[AudioIndex]->codec->frame_size &&

av_fifo_size(fifo_video) <= frame_size && !bCap)

{

break;

}

if(av_compare_ts(cur_pts_v, pFormatCtx_Out->streams[VideoIndex]->time_base,

cur_pts_a,pFormatCtx_Out->streams[AudioIndex]->time_base) <= 0)

{

//read data from fifo

if (av_fifo_size(fifo_video) < frame_size && !bCap)

{

cur_pts_v = 0x7fffffffffffffff;

}

if(av_fifo_size(fifo_video) >= size)

{

EnterCriticalSection(&VideoSection);

av_fifo_generic_read(fifo_video, picture_buf, size, NULL);

LeaveCriticalSection(&VideoSection);

avpicture_fill((AVPicture *)picture, picture_buf,

pFormatCtx_Out->streams[VideoIndex]->codec->pix_fmt,

pFormatCtx_Out->streams[VideoIndex]->codec->width,

pFormatCtx_Out->streams[VideoIndex]->codec->height);

//pts = n * (（1 / timbase）/ fps);

picture->pts = VideoFrameIndex * ((pFormatCtx_Video->streams[0]->time_base.den / pFormatCtx_Video->streams[0]->time_base.num) / 15);

int got_picture = 0;

AVPacket pkt;

av_init_packet(&pkt);

pkt.data = NULL;

pkt.size = 0;

int ret = avcodec_encode_video2(pFormatCtx_Out->streams[VideoIndex]->codec, &pkt, picture, &got_picture);

if(ret < 0)

{

//编码错误,不理会此帧

continue;

}

if (got_picture==1)

{

pkt.stream_index = VideoIndex;

pkt.pts = av_rescale_q_rnd(pkt.pts, pFormatCtx_Video->streams[0]->time_base,

pFormatCtx_Out->streams[VideoIndex]->time_base, (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));

pkt.dts = av_rescale_q_rnd(pkt.dts, pFormatCtx_Video->streams[0]->time_base,

pFormatCtx_Out->streams[VideoIndex]->time_base, (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));

pkt.duration = ((pFormatCtx_Out->streams[0]->time_base.den / pFormatCtx_Out->streams[0]->time_base.num) / 15);

cur_pts_v = pkt.pts;

ret = av_interleaved_write_frame(pFormatCtx_Out, &pkt);

//delete[] pkt.data;

av_free_packet(&pkt);

}

VideoFrameIndex++;

}

else

{

if (NULL == fifo_audio)

{

continue;//还未初始化fifo

}

if (av_audio_fifo_size(fifo_audio) < pFormatCtx_Out->streams[AudioIndex]->codec->frame_size && !bCap)

{

cur_pts_a = 0x7fffffffffffffff;

}

if(av_audio_fifo_size(fifo_audio) >=

(pFormatCtx_Out->streams[AudioIndex]->codec->frame_size > 0 ? pFormatCtx_Out->streams[AudioIndex]->codec->frame_size : 1024))

{

AVFrame *frame;

frame = av_frame_alloc();

frame->nb_samples = pFormatCtx_Out->streams[AudioIndex]->codec->frame_size>0 ? pFormatCtx_Out->streams[AudioIndex]->codec->frame_size: 1024;

frame->channel_layout = pFormatCtx_Out->streams[AudioIndex]->codec->channel_layout;

frame->format = pFormatCtx_Out->streams[AudioIndex]->codec->sample_fmt;

frame->sample_rate = pFormatCtx_Out->streams[AudioIndex]->codec->sample_rate;

av_frame_get_buffer(frame, 0);

EnterCriticalSection(&AudioSection);

av_audio_fifo_read(fifo_audio, (void **)frame->data,

(pFormatCtx_Out->streams[AudioIndex]->codec->frame_size > 0 ? pFormatCtx_Out->streams[AudioIndex]->codec->frame_size : 1024));

LeaveCriticalSection(&AudioSection);

if (pFormatCtx_Out->streams[0]->codec->sample_fmt != pFormatCtx_Audio->streams[AudioIndex]->codec->sample_fmt

|| pFormatCtx_Out->streams[0]->codec->channels != pFormatCtx_Audio->streams[AudioIndex]->codec->channels

|| pFormatCtx_Out->streams[0]->codec->sample_rate != pFormatCtx_Audio->streams[AudioIndex]->codec->sample_rate)

{

//如果输入和输出的音频格式不一样需要重采样，这里是一样的就没做

}

AVPacket pkt_out;

av_init_packet(&pkt_out);

int got_picture = -1;

pkt_out.data = NULL;

pkt_out.size = 0;

frame->pts = AudioFrameIndex * pFormatCtx_Out->streams[AudioIndex]->codec->frame_size;

if (avcodec_encode_audio2(pFormatCtx_Out->streams[AudioIndex]->codec, &pkt_out, frame, &got_picture) < 0)

{

printf("can not decoder a frame");

}

av_frame_free(&frame);

if (got_picture)

{

pkt_out.stream_index = AudioIndex;

pkt_out.pts = AudioFrameIndex * pFormatCtx_Out->streams[AudioIndex]->codec->frame_size;

pkt_out.dts = AudioFrameIndex * pFormatCtx_Out->streams[AudioIndex]->codec->frame_size;

pkt_out.duration = pFormatCtx_Out->streams[AudioIndex]->codec->frame_size;

cur_pts_a = pkt_out.pts;

int ret = av_interleaved_write_frame(pFormatCtx_Out, &pkt_out);

av_free_packet(&pkt_out);

}

AudioFrameIndex++;

}

delete[] picture_buf;

av_fifo_free(fifo_video);

av_audio_fifo_free(fifo_audio);

av_write_trailer(pFormatCtx_Out);

avio_close(pFormatCtx_Out->pb);

avformat_free_context(pFormatCtx_Out);

if (pFormatCtx_Video != NULL)

{

avformat_close_input(&pFormatCtx_Video);

pFormatCtx_Video = NULL;

}

if (pFormatCtx_Audio != NULL)

{

avformat_close_input(&pFormatCtx_Audio);

pFormatCtx_Audio = NULL;

}

return 0;

}

DWORD WINAPI ScreenCapThreadProc( LPVOID lpParam )

{

AVPacket packet;/* = (AVPacket *)av_malloc(sizeof(AVPacket))*/;

int got_picture;

AVFrame *pFrame;

pFrame=avcodec_alloc_frame();

AVFrame *picture = avcodec_alloc_frame();

int size = avpicture_get_size(pFormatCtx_Out->streams[VideoIndex]->codec->pix_fmt,

pFormatCtx_Out->streams[VideoIndex]->codec->width, pFormatCtx_Out->streams[VideoIndex]->codec->height);

//picture_buf = new uint8_t[size];

avpicture_fill((AVPicture *)picture, picture_buf,

pFormatCtx_Out->streams[VideoIndex]->codec->pix_fmt,

pFormatCtx_Out->streams[VideoIndex]->codec->width,

pFormatCtx_Out->streams[VideoIndex]->codec->height);

FILE *p = NULL;

p = fopen("proc_test.yuv", "wb+");

av_init_packet(&packet);

int height = pFormatCtx_Out->streams[VideoIndex]->codec->height;

int width = pFormatCtx_Out->streams[VideoIndex]->codec->width;

int y_size=height*width;

while(bCap)

{

packet.data = NULL;

packet.size = 0;

if (av_read_frame(pFormatCtx_Video, &packet) < 0)

{

continue;

}

if(packet.stream_index == 0)

{

if (avcodec_decode_video2(pCodecCtx_Video, pFrame, &got_picture, &packet) < 0)

{

printf("Decode Error.（解码错误）\n");

continue;

}

if (got_picture)

{

sws_scale(img_convert_ctx, (const uint8_t* const*)pFrame->data, pFrame->linesize, 0,

pFormatCtx_Out->streams[VideoIndex]->codec->height, picture->data, picture->linesize);

if (av_fifo_space(fifo_video) >= size)

{

EnterCriticalSection(&VideoSection);

av_fifo_generic_write(fifo_video, picture->data[0], y_size, NULL);

av_fifo_generic_write(fifo_video, picture->data[1], y_size/4, NULL);

av_fifo_generic_write(fifo_video, picture->data[2], y_size/4, NULL);

LeaveCriticalSection(&VideoSection);

}

av_free_packet(&packet);

//Sleep(50);

}

av_frame_free(&pFrame);

av_frame_free(&picture);

//delete[] picture_buf;

return 0;

}

DWORD WINAPI AudioCapThreadProc( LPVOID lpParam )

{

AVPacket pkt;

AVFrame *frame;

frame = av_frame_alloc();

int gotframe;

while(bCap)

{

pkt.data = NULL;

pkt.size = 0;

if(av_read_frame(pFormatCtx_Audio,&pkt) < 0)

{

continue;

}

if (avcodec_decode_audio4(pFormatCtx_Audio->streams[0]->codec, frame, &gotframe, &pkt) < 0)

{

av_frame_free(&frame);

printf("can not decoder a frame");

break;

}

av_free_packet(&pkt);

if (!gotframe)

{

continue;//没有获取到数据，继续下一次

}

if (NULL == fifo_audio)

{

fifo_audio = av_audio_fifo_alloc(pFormatCtx_Audio->streams[0]->codec->sample_fmt,

pFormatCtx_Audio->streams[0]->codec->channels, 30 * frame->nb_samples);

}

int buf_space = av_audio_fifo_space(fifo_audio);

if (av_audio_fifo_space(fifo_audio) >= frame->nb_samples)

{

EnterCriticalSection(&AudioSection);

av_audio_fifo_write(fifo_audio, (void **)frame->data, frame->nb_samples);

LeaveCriticalSection(&AudioSection);

}

av_frame_free(&frame);

return 0;

}

char * EnumAudioDevice()

{

UINT i = 0;

UINT uDevNum = waveInGetNumDevs();

for (;i<uDevNum;i++)

{

WAVEINCAPSW wic = {0};

waveInGetDevCapsW(i,&wic,sizeof(wic));

printf("%s\n",wic.szPname);

char * tmpStr = dup_wchar_to_utf8(wic.szPname);

return tmpStr;

}

FFMPEG学习【命令行】采集视频和音频

输入设备 dshow 的使用——视音频录制

打印 DirectShow 支持的设备列表（true 可用1替换）

ffmpeg -list_devices true -f dshow -i dummy

中文乱码查看

如果不熟悉ANSI转码UTF-8的话，还有一种更简单的方式查看设备的名称。即不使用FFmpeg查看系统DirectShow输入设备的名称，而使用Windows kit自带的工具graphedt.exe（或者网上下一个GraphStudioNext）查看输入名称。
选择【图像】->【插入过滤】，可以看到中文名称为“麦克风 (HD Webcam C310)”，注意中间括号前有空格。

视频录制

ffmpeg -f dshow -i video="Logitech HD Webcam C310" -vcodec libx264 e:\\001.mkv
//方式二:“-r 5”的意思是把帧率设置成5
ffmpeg -f dshow -i video="Logitech HD Webcam C310" -r 5 -vcodec libx264 -preset:v ultrafast -tune:v zerolatency e:\\MyDesktop.mkv

上面组合命令设置了x264参数和aac添加adst filter，
如果想提高x264编码速度可使用 -preset:v ultrafast -tune:v zerolatency 两个参数，
举个例子：
ffmpeg -f dshow -i video=”Logitech HD Webcam C310” -vcodec libx264 -preset:v ultrafast -tune:v zerolatency e:\004.mp4

录一段视频，按 q 键停止.

播放：

ffplay e:\\001.mkv

音频录制

//test1
ffmpeg -f dshow -i audio="麦克风 (HD Webcam C310)" -acodec aac e:\\temp.aac
//test2
ffmpeg -f dshow -i audio="麦克风 (HD Webcam C310)"  -ar 16000 -ac 1 lib.wav

视频生成图片

::1秒输出一张图片，从26秒开始，持续7秒::
ffmpeg -i toolba.mkv -r 1 -ss 00:00:26 -t 00:00:07 %03d.png
@echo off
setinput_dir=
echo %~d0
echo %cd%echo %input_path%/png/
for /r %input_path% %%i in (*.avi) do (
ffmpeg -i %%i -r 1 png/%%~ni_%%03d.png )
::ffmpeg -i bianyuehui.avi -r 10  %input_path%/png/%%03d.png
pause

批处理for循环逐一处理目录中的文件

图片生成录制

//1.截取视频某一秒图片ffmpeg -ss 00:02:06 -i 3.flv -f image2 -y test1.jpg//2.实时抓取图片ffmpeg -f dshow -rtbufsize 200M -i video="Logitech HD Webcam C310" -r 1 -f image2 image%03d.jpeg

音视频联合录制

//test1
ffmpeg -f dshow -i video="Logitech HD Webcam C310":audio="麦克风 (HD Webcam C310)" -s 640x360 -b:v 1000k -b:a 128k e:\\output.mkv
//test2
ffmpeg -f dshow -i video="Logitech HD Webcam C310":audio="麦克风 (HD Webcam C310)" -r 5 -vcodec libx264 -preset:v ultrafast -tune:v zerolatency -acodec libmp3lame e:\\002.mkv
//test3
ffmpeg -f dshow -i video="Logitech HD Webcam C310":audio="麦克风 (HD Webcam C310)" -pix_fmt yuv420p -ar 48000 -vcodec libx264 -crf 23 -preset veryslow -x264opts b-adapt=2:bframes=0:aq-strength=1:psy-rd=0.8,0 -vsync vfr -acodec aac -bsf:a aac_adtstoasc -f flv e:\\002.flv

实战

音视频实时采集输出

ffmpeg -f dshow -rtbufsize 200M -i video="Logitech HD Webcam C310":audio="麦克风 (HD Webcam C310)" -pix_fmt yuv420p -ar 48000 -vcodec libx264 -crf 23 -preset veryslow -x264opts b-adapt=2:bframes=0:aq-strength=1:psy-rd=0.8,0 -vsync vfr -acodec aac -bsf:a aac_adtstoasc -f flv e:\\002.flv

音视频和图片实时采集输出

ffmpeg -f dshow -rtbufsize 200M -i video="Logitech HD Webcam C310":audio="麦克风 (HD Webcam C310)" -pix_fmt yuv420p -ar 48000 -vcodec libx264 -crf 23 -preset veryslow -x264opts b-adapt=2:bframes=0:aq-strength=1:psy-rd=0.8,0 -vsync vfr -acodec aac -bsf:a aac_adtstoasc -f flv 3.flv -r 1 -f image2 image%03d.jpeg

音视频编辑

合成

音视频合成

ffmpeg -i a.wav  -i a.avi out.avi

音视频合成-延迟

ffmpeg.exe -i user_review.wav -i user_review.avi -filter_complex "adelay=3000|3000"  out.avi//-filter_complex "adelay=3000|3000"：对前面的ogg音频的两个声道都延迟3000毫秒 //参考：http://ffmpeg.org/ffmpeg-all.html#adelay

参考：ffmpeg音视频合成

多个视屏合成

/* 对于 avi 格式 */
@echo off
ffmpeg -i "concat:input1.avi|input2.avi" -c copy output.avi
paus

/*对于MP4等其他格式*/
//方法二：FFmpeg concat 分离器
//这种方法成功率很高，也是最好的，但是需要 FFmpeg 1.1 以上版本。先创建一个文本文件filelist.txt：
file 'input1.mkv'
file 'input2.mkv'
file 'input3.mkv'
//然后：
ffmpeg -f concat -i filelist.txt -c copy output.mkv
//注意：使用 FFmpeg concat 分离器时，如果文件名有奇怪的字符，要在 filelist.txt 中转义。

FFMpeg无损合并视频的多种方法
 FFMPEG使用参数详解

剪切

视频剪切

ffmpeg -i test.mp4 -ss 10 -t 15 -codec copy cut.mp4
//参数说明：
-i : source
-ss: start time
-t : duration

ffmpeg视频精准剪切

视频裁剪

/* crop：裁剪矩形尺寸，scale：缩放尺寸*/
ffmpeg -i input.mp4 -vf crop=w:h:x:y,scale=640:480 out.mp4

ffmpeg调整缩放裁剪视频的基础知识

获取音视频信息

自动获取音视频设备名称

@echo off&setlocal enabledelayedexpansion

::method 1: 固定设备名称
REM ::延时2秒
REM ::ping -n 1 127.0.0.1>nul
REM ffmpeg -f dshow -i audio="麦克风 (HD Webcam C310)"  -ar 16000 -ac 1 %1

REM ::del /f /s /q %1
REM ::del /f /s /q plot\\data\\img\\*.*

REM ::录制音视频图片
REM ::ffmpeg -f dshow -rtbufsize 200M -i video="Logitech HD Webcam C310":audio="麦克风 (HD Webcam C310)" -pix_fmt yuv420p -ar 48000 -vcodec libx264 -crf 23 -preset veryslow -x264opts b-adapt=2:bframes=0:aq-strength=1:psy-rd=0.8,0 -vsync vfr -acodec aac -bsf:a aac_adtstoasc -f flv %1  -r 1000 -f image2 plot\\data\\img\\image%%3d.jpg



::method 2: 自动获取设备名称
::ffmpeg默认输出utf-8
ffmpeg -list_devices true -f dshow -i dummy 2>temp_utf.txt

::utf-8 转 gbk,批处理不支持utf-8文件
iconv.exe -f utf-8 -t gbk temp_utf.txt >temp_gbk.txt
REM findstr /c:"dshow @ " temp_gbk.txt>e1.txt

set find_audio_name=0
for /f "delims=" %%i in (temp_gbk.txt) do (

   ::找到"DirectShow audio devices" 的下一行即为设备名
   echo %%i | findstr /c:"DirectShow audio devices" >nul 2>nul
   if !find_audio_name! equ 1 (
       echo %%i
       for /f tokens^=2^ delims^=^" %%a in ("%%i") do (
           echo "%%a" >out.txt
           goto end
       )
   )

   ::设置标志
   if !errorlevel! equ 0 (
       set find_audio_name=1
       echo find
   ) else (
       echo not find
   )
)

:end
for /f "delims=" %%a in (out.txt) do (
   echo %%a
   ffmpeg -f dshow -i audio=%%a  -ar 16000 -ac 1 %1    
)

::删除临时文件
del /f /s /q temp_utf.txt
del /f /s /q temp_gbk.txt
del /f /s /q out.txt

pause
参考：使用windows命令和iconv.exe批量转换文件编码

获取视频时长

ffprobe -loglevel quiet -print_format json -show_format -show_streams -i user_review.avi

python代码

#获取视频时长
def getLenTime(filename):
     command = ["ffprobe.exe","-loglevel","quiet","-print_format","json","-show_format","-show_streams","-i",filename]
     result = subprocess.Popen(command,shell=True,stdout = subprocess.PIPE, stderr = subprocess.STDOUT)
     out = result.stdout.read()
     #print(str(out))
     temp = str(out.decode('utf-8'))
     data = json.loads(temp)['format']['duration']
     return data

ffmpeg如何实现一个视频中加入烟花视频实现正片叠底效果

要使用ffmpeg实现在一个视频中加入烟花视频并实现正片叠底效果，可以使用blend滤镜。以下是具体步骤和示例命令：

准备主视频（main_video.mp4）和烟花视频（fireworks.mp4）。

使用以下命令将烟花视频叠加到主视频上，并应用正片叠底效果：

ffmpeg -i main_video.mp4 -i fireworks.mp4 -filter_complex "[1:v]colorkey=0x000000:0.5:0.2[ckout];[0:v][ckout]blend=all_mode=multiply[out]" -map "[out]" -map 0:a output.mp4

命令解释：

-i main_video.mp4：指定主视频文件。

-i fireworks.mp4：指定烟花视频文件。

-filter_complex：指定复杂滤镜操作。

[1:v]colorkey=0x000000:0.5:0.2[ckout]：对烟花视频应用colorkey滤镜，将黑色背景去除。0x000000表示黑色，0.5表示相似度阈值，0.2表示混合阈值。

[0:v][ckout]blend=all_mode=multiply[out]：将主视频和处理后的烟花视频使用blend滤镜进行正片叠底混合。all_mode=multiply表示使用正片叠底模式。

-map "[out]"：将混合后的视频流映射到输出文件。

-map 0:a：将主视频的音频流映射到输出文件。

output.mp4：指定输出文件名。

运行命令后，ffmpeg将处理视频并生成输出文件output.mp4，其中烟花视频将与主视频进行正片叠底混合。

请注意，为了获得最佳效果，烟花视频应该具有透明或黑色背景，以便在应用colorkey滤镜后能够正确去除背景。

你可以根据需要调整blend滤镜的参数和设置，以获得所需的正片叠底效果。例如，可以调整all_mode参数来尝试其他混合模式，如screen、overlay等，以达到不同的视觉效果

要在叠加烟花视频时指定其位置和大小，可以使用scale和overlay滤镜。以下是修改后的ffmpeg命令：

ffmpeg -i main_video.mp4 -i fireworks.mp4 -filter_complex "[1:v]colorkey=0x000000:0.5:0.2,scale=320:240[ckout];[0:v][ckout]overlay=x=50:y=50:shortest=1,blend=all_mode=multiply[out]" -map "[out]" -map 0:a output.mp4

命令解释：

-i main_video.mp4：指定主视频文件。

-i fireworks.mp4：指定烟花视频文件。

-filter_complex：指定复杂滤镜操作。

[1:v]colorkey=0x000000:0.5:0.2,scale=320:240[ckout]：对烟花视频应用colorkey滤镜，将黑色背景去除，并使用scale滤镜将烟花视频缩放到指定的宽度和高度（例如320x240）。

[0:v][ckout]overlay=x=50:y=50:shortest=1,blend=all_mode=multiply[out]：将主视频和处理后的烟花视频使用overlay滤镜进行叠加，并指定烟花视频的位置（例如x=50:y=50表示距离左上角50像素）。shortest=1表示以较短的视频长度为准。然后使用blend滤镜进行正片叠底混合。

-map "[out]"：将混合后的视频流映射到输出文件。

-map 0:a：将主视频的音频流映射到输出文件。

output.mp4：指定输出文件名。

在上述命令中，通过在overlay滤镜中指定x和y参数，你可以控制烟花视频在主视频中的位置。例如，x=50:y=50表示烟花视频将位于主视频的左上角，距离左边缘和上边缘各50像素。

同时，使用scale滤镜可以调整烟花视频的大小。例如，scale=320:240将烟花视频缩放到宽度为320像素，高度为240像素。你可以根据需要调整这些值。

请注意，overlay滤镜的位置参数是以像素为单位指定的，因此你需要根据主视频的分辨率来调整这些值，以达到所需的位置效果。

运行修改后的命令，ffmpeg将按照指定的位置和大小叠加烟花视频，并应用正片叠底效果，生成输出文件output.mp4。

ffmpeg命令行实现边推流边录制

1.基本原理

FFmpeg 是一个非常强大的多媒体处理工具。要实现边推流边录制，本质上是让 FFmpeg 同时执行两个操作：一个是将音视频数据推送到流媒体服务器，另一个是将相同的音视频数据保存为本地文件。

2.命令示例

假设你有一个本地的视频文件input.mp4，你想要将它推流到 RTMP 服务器（例如rtmp://server/live/stream），同时录制一份到本地的output.mp4文件。

以下是基本的命令格式：

ffmpeg -i input.mp4 -c:v copy -c:a copy -f flv rtmp://server/live/stream -c:v copy -c:a copy output.mp4

解释：

-i input.mp4：指定输入文件，这里是input.mp4，它是本地的视频源。

-c:v copy和-c:a copy：这两个参数用于复制视频和音频的编解码器设置。这样可以避免重新编码，节省 CPU 资源并且可以快速处理，因为只是简单地复制流。对于视频编码器使用-c:v（c代表编解码器，v代表视频），对于音频编码器使用-c:a。

-f flv：指定推流的格式为 FLV（Flash Video）。这是在推流到 RTMP 服务器时常用的格式。如果你的流媒体服务器支持其他格式，你可能需要更改这个参数。例如，对于一些支持 MPEG - TS 格式推流的服务器，你可以使用-f mpegts。

rtmp://server/live/stream：这是目标流媒体服务器的地址和流名称，你需要将server替换为实际的服务器 IP 或域名，stream替换为实际的流名称。

后面的-c:v copy -c:a copy output.mp4部分是用于将相同的视频和音频数据保存为本地的output.mp4文件。这里同样是复制视频和音频编解码器设置，output.mp4是输出文件名，你可以根据需要修改文件名和格式。

3.注意事项

权限问题：如果 FFmpeg 命令没有足够的权限写入本地文件（用于录制），可能会出现错误。在这种情况下，你可能需要以管理员权限（在 Linux 或 Unix 系统上使用sudo）运行命令或者调整文件系统权限。

网络和服务器问题：如果推流的服务器不可用或者网络连接不稳定，推流操作可能会失败。你需要确保服务器地址正确并且网络能够正常访问服务器。

格式兼容性：虽然命令中示例了 MP4 作为本地录制文件格式和 FLV 用于推流格式，但你可能需要根据实际情况选择格式。不同的流媒体服务器支持不同的推流格式，而且本地文件格式也可能需要根据你的播放设备等因素进行调整。例如，如果你想在一些较老的设备上播放录制文件，AVI 格式可能是一个更好的选择，不过这也可能需要重新编码。

上一篇：mpv命令行播放器

您现在的位置是：网站首页> 多媒体开发

FFMPEG系列知识集中地【视频加密】

1.1ffmpeg程序的使用

使用ffmpeg合并视频

使用concat协议进行视频文件的合并

使用concat滤镜（filter）进行视频文件的合并：

方法一：FFmpeg concat 协议

方法二：FFmpeg concat 分离器

方法三：Mencoder 连接文件并重建索引

方法四：使用 FFmpeg concat 过滤器重新编码（有损）

提示

ffmpeg画中画效果

ffplay命令-主要选项1

ffplay命令-主要选项2

ffplay命令-高级选项-1

ffplay命令-高级选项-1

ffplay命令播放

1. FFmpeg filter简介

2. filter的使用方法

一.实现图像数据格式转换与图像缩放的三个重要函数

三个函数的关系

例程

例程结果展示

main函数

add_stream

open_video与open_audio

open_video

open_audio

write_video_frame和write_audio_frame

write_video_frame

write_video_frame

程序

实验

实验

使能aac编码器

运行程序

附注

录音

播放原始音频数据

播放wav格式的音频文件

生成yuv视频

yuv编码为h.264

一、功能简介

二、AVStream结构体解析

三、函数源码分析

part 1 参数定义

part 2 设置max_stream_analyze_duration 等

part 3 第一次遍历流

part 4 第二次遍历流

part 5 死循环

part 6 检查是否到达文件尾部

part 7 刷新解码器

part 8 关闭可能可打开的编解码器

part 9 计算rfps

part10 再次遍历流

part 11 计算时间相关的参数

part 12 更新数据

四、总结

第一件事

1-1判断编解码器是否打开

1-2把编码器挂到编解码器上下文环境下

1-3给AVCodecContext下对应的节点分配AVCodecInternal，FramePool，AVPacket，AVFrame等数据结构

第二件事

2-1检查编码器是不是在白名单中

2-2把编解码器挂载到上下文环境下

2-3检查和重置编解码器类型

2-3设置编解码器上下文环境的帧的数量为0

2-4设置编解码器的描述信息

2-5设置音频流的时间戳

2-6设置波特率

2-7验证通道布局

2-8设置字幕文件的字符编码格式

第一件事情

第二件事情

第三件事情

写第一个程序-视频解封装与解码

解码流程总结

编写程序

一.格式转换

1-1媒体格式

3-3保存或者装载元数据到/从文件中