FFMPEG解碼流程
正如原文評論所說，這個註釋貌似機翻，有點兒。。。。。請見諒。
另外轉了一篇過程分析之類的文章，供參考：http://blog.csdn.net/kaisuihu/article/details/8754915
本人也是初學，所以也就是湊合着看看。要說修改嘛。。等以後吧
原文鏈接：http://www.douban.com/note/228831821/
FFMPEG解碼流程：
1. 註冊所有容器格式和CODEC: av_register_all()
2. 打開文件: av_open_input_file()
3. 從文件中提取流信息: av_find_stream_info()
4. 窮舉所有的流，查找其中種類爲:CODEC_TYPE_VIDEO
5. 查找對應的解碼器: avcodec_find_decoder()
6. 打開編解碼器: avcodec_open()
7. 爲解碼幀分配內存: avcodec_alloc_frame()
8. 不停地從碼流中提取出幀數據: av_read_frame()
9. 判斷幀的類型，對於視頻幀調用: avcodec_decode_video()
10. 解碼完後，釋放解碼器: avcodec_close()
11. 關閉輸入文件: avformat_close_input_file()
主要數據結構：
基本概念:
編解碼器、數據幀、媒體流和容器是數字媒體處理系統的四個基本概念。
首先需要統一術語：
容器／文件（Conainer/File）：即特定格式的多媒體文件。
媒體流（Stream）：指時間軸上的一段連續數據，如一段聲音數據，一段視頻數據或一段字幕數據，可以是壓縮的，也可以是非壓縮的，壓縮的數據需要關聯特定的編解碼器。
數據幀／數據包（Frame/Packet）：通常，一個媒體流由大量的數據幀組成，對於壓縮數據，幀對應着編解碼器的最小處理單元。通常，分屬於不同媒體流的數據幀交錯複用於容器之中，參見交錯。
編解碼器：編解碼器以幀爲單位實現壓縮數據和原始數據之間的相互轉換。
在FFMPEG中，使用AVFormatContext、AVStream、AVCodecContext、AVCodec及AVPacket等結構來抽象這些基本要素，它們的關係如上圖所示：
AVCodecContext：
這是一個描述編解碼器上下文的數據結構，包含了衆多編解碼器需要的參數信息，如下列出了部分比較重要的域：
typedef struct AVCodecContext {
/ **
*一些編解碼器需要/可以像使用extradata Huffman表。
* MJPEG：Huffman表
* RV10其他標誌
* MPEG4：全球頭（也可以是在比特流或這裏）
*分配的內存應該是FF_INPUT_BUFFER_PADDING_SIZE字節較大
*，比extradata_size避免比特流器，如果它與讀prolems。
* extradata按字節的內容必須不依賴於架構或CPU的字節順序。
* - 編碼：設置/分配/釋放由libavcodec的。
* - 解碼：由用戶設置/分配/釋放。
* /
uint8_t *extradata;
int extradata_size;
/ **
*這是時間的基本單位，在條件（以秒爲單位）
*幀時間戳派代表出席了會議。對於固定fps的內容，
*基應該1/framerate和時間戳的增量應該
*相同的1。
* - 編碼：必須由用戶設置。
* - 解碼：libavcodec的設置。
* /
AVRational time_base;
/*視頻* /
/ **
*圖片寬度/高度。
* - 編碼：必須由用戶設置。
* - 解碼：libavcodec的設置。
*請注意：兼容性，它是可能的，而不是設置此
* coded_width/高解碼之前。
* /
int width, height;
......
/ *僅音頻* /
int sample_rate; ///< 每秒採樣
int channels; ///< 音頻通道數
/ **
*音頻採樣格式
* - 編碼：由用戶設置。
* - 解碼：libavcodec的設置。
* /
enum SampleFormat sample_fmt; ///< 樣本格式
/ *下面的數據不應該被初始化。* /
/ **
*每包樣品，初始化時調用“init”。
* /
int frame_size;
int frame_number; ///<音頻或視頻幀數量
char codec_name[32];
enum AVMediaType codec_type; /* 看到AVMEDIA_TYPE_xxx */
enum CodecID codec_id; /* see CODEC_ID_xxx */
/ **
*的fourcc（LSB在前，所以“的ABCD” - >（“D”<< 24）（“C”<< 16）（“B”<< 8）+“A”）。
*這是用來解決一些編碼錯誤。
*分路器應設置什麼是編解碼器用於識別領域中。
*如果有分路器等多個領域，在一個容器，然後選擇一個
*最大化使用的編解碼器有關的信息。
*如果在容器中的編解碼器標記字段然後32位大分路器應該
*重新映射到一個表或其他結構的32位編號。也可選擇新
* extra_codec_tag+大小可以添加，但必須證明這是一個明顯的優勢
*第一。
* - 編碼：由用戶設置，如果沒有則默認基礎上codec_id將使用。
* - 解碼：由用戶設置，將被轉換成在初始化libavcodec的大寫。
* /
unsigned int codec_tag;
......
/ **
*在解碼器的幀重排序緩衝區的大小。
*對於MPEG-2，這是IPB1或0低延時IP。
* - 編碼：libavcodec的設置。
* - 解碼：libavcodec的設置。
* /
int has_b_frames;
/ **
*每包的字節數，如果常量和已知或0
*用於一些WAV的音頻編解碼器。
* /
int block_align;
/ **
*從分路器位每個樣品/像素（huffyuv需要）。
* - 編碼：libavcodec的設置。
* - 解碼：由用戶設置。
* /
int bits_per_coded_sample;
.....
} AVCodecContext;
如果是單純使用libavcodec，這部分信息需要調用者進行初始化；如果是使用整個FFMPEG庫，這部分信息在調用avformat_open_input和avformat_find_stream_info的過程中根據文件的頭信息及媒體流內的頭部信息完成初始化。其中幾個主要域的釋義如下：
extradata/extradata_size：這個buffer中存放了解碼器可能會用到的額外信息，在av_read_frame中填充。一般來說，首先，某種具體格式的demuxer在讀取格式頭信息的時候會填充extradata，其次，如果demuxer沒有做這個事情，比如可能在頭部壓根兒就沒有相關的編解碼信息，則相應的parser會繼續從已經解複用出來的媒體流中繼續尋找。在沒有找到任何額外信息的情況下，這個buffer指針爲空。
time_base：
width/height：視頻的寬和高。
sample_rate/channels：音頻的採樣率和信道數目。
sample_fmt： 音頻的原始採樣格式。
codec_name/codec_type/codec_id/codec_tag：編解碼器的信息。
AVStrea
該結構體描述一個媒體流，定義如下：
typedef struct AVStream {
int index; /** <在AVFormatContext流的索引* /
int id; /**< 特定格式的流ID */
AVCodecContext *codec; /**< codec context */
/ **
*流的實時幀率基地。
*這是所有時間戳可以最低幀率
*準確代表（它是所有的最小公倍數
*流的幀率）。請注意，這個值只是一個猜測！
*例如，如果時間基數爲1/90000和所有幀
*約3600或1800計時器刻度，，然後r_frame_rate將是50/1。
* /
AVRational r_frame_rate;
/ **
*這是時間的基本單位，在條件（以秒爲單位）
*幀時間戳派代表出席了會議。對於固定fps的內容，
*時基應該是1/framerate的時間戳的增量應爲1。
* /
AVRational time_base;
......
/ **
*解碼流量的第一幀，在流量時-base分。
*如果你是絕對100％的把握，設定值
*它真的是第一幀點。
*這可能是未定義（AV_NOPTS_VALUE）的。
*@注意的業餘頭不弱者受制與正確的START_TIME的業餘
*分路器必須不設定此。
* /
int64_t start_time;
/ **
*解碼：時間流流時基。
*如果源文件中沒有指定的時間，但不指定
*比特率，這個值將被從碼率和文件大小的估計。
* /
int64_t duration;
#if LIBAVFORMAT_VERSION_INT < (53<<16)
char language[4]; /** ISO 639-2/B 3-letter language code (empty string if undefined) */
#endif
/* av_read_frame（）支持* /
enum AVStreamParseType need_parsing;
struct AVCodecParserContext *parser;
.....
/*函數av_seek_frame（）支持* /
AVIndexEntry *index_entries; / **<僅用於如果格式不notsupport尋求本身。* /
int nb_index_entries;
unsigned int index_entries_allocated_size;
int64_t nb_frames; ///< 在此流的幀，如果已知或0
......
//*平均幀率
AVRational avg_frame_rate;
......
} AVStream;
主要域的釋義如下，其中大部分域的值可以由avformat_open_input根據文件頭的信息確定，缺少的信息需要通過調用avformat_find_stream_info讀幀及軟解碼進一步獲取：
index/id：index對應流的索引，這個數字是自動生成的，根據index可以從AVFormatContext::streams表中索引到該流；而id則是流的標識，依賴於具體的容器格式。比如對於MPEG TS格式，id就是pid。
time_base：流的時間基準，是一個實數，該流中媒體數據的pts和dts都將以這個時間基準爲粒度。通常，使用av_rescale/av_rescale_q可以實現不同時間基準的轉換。
start_time：流的起始時間，以流的時間基準爲單位，通常是該流中第一個幀的pts。
duration：流的總時間，以流的時間基準爲單位。
need_parsing：對該流parsing過程的控制域。
nb_frames：流內的幀數目。
r_frame_rate/framerate/avg_frame_rate：幀率相關。
codec：指向該流對應的AVCodecContext結構，調用avformat_open_input時生成。
parser：指向該流對應的AVCodecParserContext結構，調用avformat_find_stream_info時生成。。
AVFormatContext
這個結構體描述了一個媒體文件或媒體流的構成和基本信息，定義如下：
typedef struct AVFormatContext {
const AVClass *av_class; /**<由avformat_alloc_context設置的。* /
/ *只能是iFormat的，或在同一時間oformat，不是兩個。* /
struct AVInputFormat *iformat;
struct AVOutputFormat *oformat;
void *priv_data;
ByteIOContext *pb;
unsigned int nb_streams;
AVStream *streams[MAX_STREAMS];
char filename[1024]; / **<輸入或輸出的文件名*/
/ *流信息* /
int64_t timestamp;
#if LIBAVFORMAT_VERSION_INT < (53<<16)
char title[512];
char author[512];
char copyright[512];
char comment[512];
char album[512];
int year; /**< ID3 year, 0 if none */
int track; /**< track number, 0 if none */
char genre[32]; /**< ID3 genre */
#endif
int ctx_flags; /** <格式特定的標誌，看到AVFMTCTX_xx* /
/*分處理的私人數據（不直接修改）。* /
/ **此緩衝區只需要當數據包已經被緩衝，但
不解碼，例如，在MPEG編解碼器的參數
流。 * /
struct AVPacketList *packet_buffer;
/ **解碼元件的第一幀的位置，在
AV_TIME_BASE分數秒。從來沒有設置這個值直接：
推導的AVStream值。 * /
int64_t start_time;
/ **解碼流的時間，在AV_TIME_BASE分數
秒。只設置這個值，如果你知道沒有個人流
工期，也不要設置任何他們。這是從推導
AVStream值如果沒有設置。
int64_t duration;
/ **解碼：總的文件大小，如果未知0* /
int64_t file_size;
/ **解碼：在比特/秒的總流率，如果不
可用。從來沒有直接設置它如果得到file_size和
時間是已知的如FFmpeg的自動計算。 * /
int bit_rate;
/* av_read_frame（）支持* /
AVStream *cur_st;
#if LIBAVFORMAT_VERSION_INT < (53<<16)
const uint8_t *cur_ptr_deprecated;
int cur_len_deprecated;
AVPacket cur_pkt_deprecated;
#endif
/* av_seek_frame() 支持 */
int64_t data_offset; /** 第一包抵消 */
int index_built;
int mux_rate;
unsigned int packet_size;
int preload;
int max_delay;
#define AVFMT_NOOUTPUTLOOP -1
#define AVFMT_INFINITEOUTPUTLOOP 0
/** 次循環輸出的格式支持它的數量 */
int loop_output;
int flags;
#define AVFMT_FLAG_GENPTS 0x0001 ///< 生成失蹤分，即使它需要解析未來框架。
#define AVFMT_FLAG_IGNIDX 0x0002 ///< 忽略指數。
#define AVFMT_FLAG_NONBLOCK 0x0004 ///<從輸入中讀取數據包時，不要阻止。
#define AVFMT_FLAG_IGNDTS 0x0008 ///< 忽略幀的DTS包含DTS與PTS
#define AVFMT_FLAG_NOFILLIN 0x0010 ///< 不要從任何其他值推斷值，只是返回存儲在容器中
#define AVFMT_FLAG_NOPARSE 0x0020 ///< 不要使用AVParsers，你還必須設置爲FILLIN幀代碼的工作，沒有解析AVFMT_FLAG_NOFILLIN - >無幀。也在尋求框架不能工作，如果找到幀邊界的解析已被禁用
#define AVFMT_FLAG_RTP_HINT 0x0040 ///< 暗示到輸出文件添加的RTP
int loop_input;
/**解碼：對探測數據的大小;編碼：未使用。* /
unsigned int probesize;
/ **
在此期間，輸入*最大時間（在AV_TIME_BASE單位）應
*進行分析在avformat_find_stream_info（）。
* /
int max_analyze_duration;
const uint8_t *key;
int keylen;
unsigned int nb_programs;
AVProgram **programs;
/ **
*強迫影片codec_id。
* Demuxing：由用戶設置。
* /
enum CodecID video_codec_id;
/ **
*強迫音頻codec_id。
* Demuxing：由用戶設置。
* /
enum CodecID audio_codec_id;
/ **
*強制的：字幕codec_id。
* Demuxing：由用戶設置。
* /
enum CodecID subtitle_codec_id;
/ **
*以字節爲單位的最高限額爲每個數據流的索引使用的內存。
*如果該指數超過此大小，條目將被丟棄
*需要保持一個較小的規模。這可能會導致較慢或更少
*準確的尋求（分路器）。
*分路器內存中的一個完整的指數是強制性的將忽略
*此。
*混流：未使用
* demuxing：由用戶設置* /
unsigned int max_index_size;
/ **
*以字節爲單位的最高限額使用幀緩衝內存
*從實時捕獲設備獲得。* /
unsigned int max_picture_buffer;
unsigned int nb_chapters;
AVChapter **chapters;
/ **
*標誌啓用調試。* /
int debug;
#define FF_FDEBUG_TS 0x0001
/ **
*原始數據包從分路器之前，解析和解碼。
*此緩衝區用於緩衝數據包，直到編解碼器可以
*確定，因爲不知道不能做解析
*編解碼器。* /
struct AVPacketList *raw_packet_buffer;
struct AVPacketList *raw_packet_buffer_end;
struct AVPacketList *packet_buffer_end;
AVMetadata *metadata;
/ **
*剩餘的大小可爲raw_packet_buffer，以字節爲單位。
*不屬於公共API* /
#define RAW_PACKET_BUFFER_SIZE 2500000
int raw_packet_buffer_remaining_size;
/ **
*在現實世界中的時間流的開始時間，以微秒
*自Unix紀元（1970年1月1日起00:00）。也就是說，pts= 0
在這個現實世界的時間*流被抓獲。
* - 編碼：由用戶設置。
* - 解碼：未使用。 * /
int64_t start_time_realtime;
} AVFormatContext;
這是FFMpeg中最爲基本的一個結構，是其他所有結構的根，是一個多媒體文件或流的根本抽象。其中:
nb_streams和streams所表示的AVStream結構指針數組包含了所有內嵌媒體流的描述；
iformat和oformat指向對應的demuxer和muxer指針；
pb則指向一個控制底層數據讀寫的ByteIOContext結構。
start_time和duration是從streams數組的各個AVStream中推斷出的多媒體文件的起始時間和長度，以微妙爲單位。
通常，這個結構由avformat_open_input在內部創建並以缺省值初始化部分成員。但是，如果調用者希望自己創建該結構，則需要顯式爲該結構的一些成員置缺省值——如果沒有缺省值的話，會導致之後的動作產生異常。以下成員需要被關注：
probesize
mux_rate
packet_size
flags
max_analyze_duration
key
max_index_size
max_picture_buffer
max_delay
AVPacket
AVPacket定義在avcodec.h中，如下：
typedef struct AVPacket {
/ **
AVStream->基time_base單位介紹時間戳的時間
*解壓縮包將被提交給用戶。
*可AV_NOPTS_VALUE如果沒有存儲在文件中。
*分必須大於或等於DTS作爲演示不能發生之前
*減壓，除非要查看十六進制轉儲。有些格式濫用
* DTS和PTS/ CTS的條款意味着不同的東西。如時間戳
*必須轉換爲真正的PTS / DTS之前，他們在AVPacket存儲。 * /
int64_t pts;
/ **
AVStream->基time_base單位時間的減壓時間戳記;
*包解壓。
*可AV_NOPTS_VALUE如果沒有存儲在文件中。 * /
int64_t dts;
uint8_t *data;
int size;
int stream_index;
int flags;
/ **
*這個包的時間AVStream->基time_base單位，如果未知。
*等於next_pts - 在呈現順序this_pts。* /
int duration;
void (*destruct)(struct AVPacket *);
void *priv;
int64_t pos; ///< 如果未知字節的位置，在流，-1
/ **
* AVStream->基time_base單位的時差，這點
*包從解碼器輸出的已融合在哪個點
*獨立的前一幀的情況下。也就是說，
*框架幾乎是一致的，沒有問題，如果解碼開始從
*第一幀或從這個關鍵幀。
* AV_NOPTS_VALUE如果不明。
*此字段是不是當前數據包的顯示時間。
*
*這一領域的目的是允許在流，沒有尋求
*在傳統意義上的關鍵幀。它所對應的
*恢復點SEI的H.264和match_time_delta在螺母。這也是
*必不可少的一些類型的字幕流，以確保所有
*後尋求正確顯示字幕。* /
int64_t convergence_duration;
} AVPacket;
FFMPEG使用AVPacket來暫存解複用之後、解碼之前的媒體數據（一個音/視頻幀、一個字幕包等）及附加信息（解碼時間戳、顯示時間戳、時長等）。其中：
dts表示解碼時間戳，pts表示顯示時間戳，它們的單位是所屬媒體流的時間基準。
stream_index給出所屬媒體流的索引；
data爲數據緩衝區指針，size爲長度；
duration爲數據的時長，也是以所屬媒體流的時間基準爲單位；
pos表示該數據在媒體流中的字節偏移量；
destruct爲用於釋放數據緩衝區的函數指針；
flags爲標誌域，其中，最低爲置1表示該數據是一個關鍵幀。
AVPacket結構本身只是個容器，它使用data成員引用實際的數據緩衝區。這個緩衝區通常是由av_new_packet創建的，但也可能由FFMPEG的API創建（如av_read_frame）。當某個AVPacket結構的數據緩衝區不再被使用時，要需要通過調用av_free_packet釋放。av_free_packet調用的是結構體本身的destruct函數，它的值有兩種情況：1)av_destruct_packet_nofree或0；2)av_destruct_packet，其中，情況1)僅僅是將data和size的值清0而已，情況2)纔會真正地釋放緩衝區。
FFMPEG內部使用AVPacket結構建立緩衝區裝載數據，同時提供destruct函數，如果FFMPEG打算自己維護緩衝區，則將destruct設爲av_destruct_packet_nofree，用戶調用av_free_packet清理緩衝區時並不能夠將其釋放；如果FFMPEG打算將該緩衝區徹底交給調用者，則將destruct設爲av_destruct_packet，表示它能夠被釋放。安全起見，如果用戶希望自由地使用一個FFMPEG內部創建的AVPacket結構，最好調用av_dup_packet進行緩衝區的克隆，將其轉化爲緩衝區能夠被釋放的AVPacket，以免對緩衝區的不當佔用造成異常錯誤。av_dup_packet會爲destruct指針爲av_destruct_packet_nofree的AVPacket新建一個緩衝區，然後將原緩衝區的數據拷貝至新緩衝區，置data的值爲新緩衝區的地址，同時設destruct指針爲av_destruct_packet。
時間信息
時間信息用於實現多媒體同步。
同步的目的在於展示多媒體信息時，能夠保持媒體對象之間固有的時間關係。同步有兩類，一類是流內同步，其主要任務是保證單個媒體流內的時間關係，以滿足感知要求，如按照規定的幀率播放一段視頻；另一類是流間同步，主要任務是保證不同媒體流之間的時間關係，如音頻和視頻之間的關係（lipsync）。
對於固定速率的媒體，如固定幀率的視頻或固定比特率的音頻，可以將時間信息（幀率或比特率）置於文件首部（header），如AVI的hdrl List、MP4的moov box，還有一種相對複雜的方案是將時間信息嵌入媒體流的內部，如MPEG TS和Real video，這種方案可以處理變速率的媒體，亦可有效避免同步過程中的時間漂移。
FFMPEG會爲每一個數據包打上時間標籤，以更有效地支持上層應用的同步機制。時間標籤有兩種，一種是DTS，稱爲解碼時間標籤，另一種是PTS，稱爲顯示時間標籤。對於聲音來說 ，這兩個時間標籤是相同的，但對於某些視頻編碼格式，由於採用了雙向預測技術，會造成DTS和PTS的不一致。
無雙向預測幀的情況：
圖像類型: I P P P P P P ... I P P
DTS: 0 1 2 3 4 5 6... 100 101 102
PTS: 0 1 2 3 4 5 6... 100 101 102
有雙向預測幀的情況：
圖像類型: I P B B P B B ... I P B
DTS: 0 1 2 3 4 5 6 ... 100 101 102
PTS: 0 3 1 2 6 4 5 ... 100 104 102
對於存在雙向預測幀的情況，通常要求解碼器對圖像重排序，以保證輸出的圖像順序爲顯示順序：
解碼器輸入：I P B B P B B
(DTS) 0 1 2 3 4 5 6
(PTS) 0 3 1 2 6 4 5
解碼器輸出：X I B B P B B P
(PTS) X 0 1 2 3 4 5 6
時間信息的獲取：
通過調用avformat_find_stream_info，多媒體應用可以從AVFormatContext對象中拿到媒體文件的時間信息：主要是總時間長度和開始時間，此外還有與時間信息相關的比特率和文件大小。其中時間信息的單位是AV_TIME_BASE：微秒。
typedef struct AVFormatContext {
/ **解碼元件的第一幀的位置，在
AV_TIME_BASE分數秒。從來沒有設置這個值直接：
推導的AVStream值。 * /
int64_t start_time;
/ **解碼流的時間，在AV_TIME_BASE分數秒。只設置這個值，如果你知道沒有個人流工期，也不要設置任何他們。這是從推導AVStream值如果沒有設置。 * /
int64_t duration;
/ **解碼：總的文件大小，如果未知=0* /
int64_t file_size;
/ **解碼：在比特/秒的總流率，如果不可用。從來沒有直接設置它如果得到file_size和時間是已知的如FFmpeg的自動計算。 * /
int bit_rate;
.....
} AVFormatContext;
以上4個成員變量都是隻讀的，基於FFMpeg的中間件需要將其封裝到某個接口中，如：
LONG GetDuratioin(IntfX*);
LONG GetStartTime(IntfX*);
LONG GetFileSize(IntfX*);
LONG GetBitRate(IntfX*);
APIs
avformat_open_input:
int avformat_open_input(AVFormatContext **ic_ptr, const char *filename, AVInputFormat *fmt, AVDictionary **options);
avformat_open_input完成兩個任務：
打開一個文件或URL，基於字節流的底層輸入模塊得到初始化。
解析多媒體文件或多媒體流的頭信息，創建AVFormatContext結構並填充其中的關鍵字段，依次爲各個原始流建立AVStream結構。
一個多媒體文件或多媒體流與其包含的原始流的關係如下：
多媒體文件/多媒體流 (movie.mkv)
原始流 1 (h.264 video)
原始流 2 (aac audio for Chinese)
原始流 3 (aac audio for english)
原始流 4 (Chinese Subtitle)
原始流 5 (English Subtitle)
...
關於輸入參數：
ic_ptr，這是一個指向指針的指針，用於返回avformat_open_input內部構造的一個AVFormatContext結構體。
filename，指定文件名。
fmt，用於顯式指定輸入文件的格式，如果設爲空則自動判斷其輸入格式。
options
這個函數通過解析多媒體文件或流的頭信息及其他輔助數據，能夠獲取足夠多的關於文件、流和編解碼器的信息，但由於任何一種多媒體格式提供的信息都是有限的，而且不同的多媒體內容製作軟件對頭信息的設置不盡相同，此外這些軟件在產生多媒體內容時難免會引入一些錯誤，因此這個函數並不保證能夠獲取所有需要的信息，在這種情況下，則需要考慮另一個函數：
avformat_find_stream_info:
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options);
這個函數主要用於獲取必要的編解碼器參數，設置到ic→streams[i]→codec中。
首先必須得到各媒體流對應編解碼器的類型和id，這是兩個定義在avutils.h和avcodec.h中的枚舉：
enum AVMediaType {
AVMEDIA_TYPE_UNKNOWN = -1,
AVMEDIA_TYPE_VIDEO,
AVMEDIA_TYPE_AUDIO,
AVMEDIA_TYPE_DATA,
AVMEDIA_TYPE_SUBTITLE,
AVMEDIA_TYPE_ATTACHMENT,
AVMEDIA_TYPE_NB
};
enum CodecID {
CODEC_ID_NONE,
/* video codecs */
CODEC_ID_MPEG1VIDEO,
CODEC_ID_MPEG2VIDEO, ///< preferred ID for MPEG-1/2 video decoding
CODEC_ID_MPEG2VIDEO_XVMC,
CODEC_ID_H261,
CODEC_ID_H263,
...
};
通常，如果某種媒體格式具備完備而正確的頭信息，調用avformat_open_input即可以得到這兩個參數，但若是因某種原因avformat_open_input無法獲取它們，這一任務將由avformat_find_stream_info完成。
其次還要獲取各媒體流對應編解碼器的時間基準。
此外，對於音頻編解碼器，還需要得到：
採樣率，
聲道數，
位寬，
幀長度（對於某些編解碼器是必要的），
對於視頻編解碼器，則是：
圖像大小，
色彩空間及格式，
av_read_frame
int av_read_frame(AVFormatContext *s, AVPacket *pkt);
這個函數用於從多媒體文件或多媒體流中讀取媒體數據，獲取的數據由AVPacket結構pkt來存放。對於音頻數據，如果是固定比特率，則pkt中裝載着一個或多個音頻幀；如果是可變比特率，則pkt中裝載有一個音頻幀。對於視頻數據，pkt中裝載有一個視頻幀。需要注意的是：再次調用本函數之前，必須使用av_free_packet釋放pkt所佔用的資源。
通過pkt→stream_index可以查到獲取的媒體數據的類型，從而將數據送交相應的解碼器進行後續處理。
av_seek_frame
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags);
這個函數通過改變媒體文件的讀寫指針來實現對媒體文件的隨機訪問，支持以下三種方式：
基於時間的隨機訪問：具體而言就是將媒體文件讀寫指針定位到某個給定的時間點上，則之後調用av_read_frame時能夠讀到時間標籤等於給定時間點的媒體數據，通常用於實現媒體播放器的快進、快退等功能。
基於文件偏移的隨機訪問：相當於普通文件的seek函數，timestamp也成爲文件的偏移量。
基於幀號的隨機訪問：timestamp爲要訪問的媒體數據的幀號。
關於參數：
s：是個AVFormatContext指針，就是avformat_open_input返回的那個結構。
stream_index：指定媒體流，如果是基於時間的隨機訪問，則第三個參數timestamp將以此媒體流的時間基準爲單位；如果設爲負數，則相當於不指定具體的媒體流，FFMPEG會按照特定的算法尋找缺省的媒體流，此時，timestamp的單位爲AV_TIME_BASE（微秒）。
timestamp：時間標籤，單位取決於其他參數。
flags：定位方式，AVSEEK_FLAG_BYTE表示基於字節偏移，AVSEEK_FLAG_FRAME表示基於幀號，其它表示基於時間。
av_close_input_file:
void av_close_input_file(AVFormatContext *s);
關閉一個媒體文件：釋放資源，關閉物理IO。
avcodec_find_decoder:
AVCodec *avcodec_find_decoder(enum CodecID id);
AVCodec *avcodec_find_decoder_by_name(const char *name);
根據給定的codec id或解碼器名稱從系統中搜尋並返回一個AVCodec結構的指針。
avcodec_open:
int avcodec_open(AVCodecContext *avctx, AVCodec *codec);
此函數根據輸入的AVCodec指針具體化AVCodecContext結構。在調用該函數之前，需要首先調用avcodec_alloc_context分配一個AVCodecContext結構，或調用avformat_open_input獲取媒體文件中對應媒體流的AVCodecContext結構；此外還需要通過avcodec_find_decoder獲取AVCodec結構。
這一函數還將初始化對應的解碼器。
avcodec_decode_video2
int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, AVPacket *avpkt);
解碼一個視頻幀。got_picture_ptr指示是否有解碼數據輸出。
輸入數據在AVPacket結構中，輸出數據在AVFrame結構中。AVFrame是定義在avcodec.h中的一個數據結構：
typedef struct AVFrame {
FF_COMMON_FRAME
} AVFrame;
FF_COMMON_FRAME定義了諸多數據域，大部分由FFMpeg內部使用，對於用戶來說，比較重要的主要包括：
#define FF_COMMON_FRAME \
......
uint8_t *data[4];\
int linesize[4];\
int key_frame;\
int pict_type;\
int64_t pts;\
int reference;\
......
FFMpeg內部以planar的方式存儲原始圖像數據，即將圖像像素分爲多個平面（R/G/B或Y/U/V），data數組內的指針分別指向四個像素平面的起始位置，linesize數組則存放各個存貯各個平面的緩衝區的行寬：
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++data[0]->#################################++++++++++++
++++++++++++###########picture data##########++++++++++++
........................
++++++++++++#################################++++++++++++
|<-------------------line_size[0]---------------------->|
此外，key_frame標識該圖像是否是關鍵幀；pict_type表示該圖像的編碼類型：I(1)/P(2)/B(3)……；pts是以time_base爲單位的時間標籤，對於部分解碼器如H.261、H.263和MPEG4，可以從頭信息中獲取；reference表示該圖像是否被用作參考。
avcodec_decode_audio4
int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt);
解碼一個音頻幀。輸入數據在AVPacket結構中，輸出數據在frame中，got_frame_ptr表示是否有數據輸出。
avcodec_close
int avcodec_close(AVCodecContext *avctx);
關閉解碼器，釋放avcodec_open中分配的資源。
測試程序
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/time.h>
#include "libavutil/avstring.h"
#include "libavformat/avformat.h"
#include "libavdevice/avdevice.h"
#include "libavcodec/opt.h"
#include "libswscale/swscale.h"
#define DECODED_AUDIO_BUFFER_SIZE 192000
struct options
{
int streamId;
int frames;
int nodec;
int bplay;
int thread_count;
int64_t lstart;
char finput[256];
char foutput1[256];
char foutput2[256];
};
int parse_options(struct options *opts, int argc, char** argv)
{
int optidx;
char *optstr;
if (argc < 2) return -1;
opts->streamId = -1;
opts->lstart = -1;
opts->frames = -1;
opts->foutput1[0] = 0;
opts->foutput2[0] = 0;
opts->nodec = 0;
opts->bplay = 0;
opts->thread_count = 0;
strcpy(opts->finput, argv[1]);
optidx = 2;
while (optidx < argc)
{
optstr = argv[optidx++];
if (*optstr++ != '-') return -1;
switch (*optstr++)
{
case 's': //< stream id
opts->streamId = atoi(optstr);
break;
case 'f': //< frames
opts->frames = atoi(optstr);
break;
case 'k': //< skipped
opts->lstart = atoll(optstr);
break;
case 'o': //< output
strcpy(opts->foutput1, optstr);
strcat(opts->foutput1, ".mpg");
strcpy(opts->foutput2, optstr);
strcat(opts->foutput2, ".raw");
break;
case 'n': //decoding and output options
if (strcmp("dec", optstr) == 0)
opts->nodec = 1;
break;
case 'p':
opts->bplay = 1;
break;
case 't':
opts->thread_count = atoi(optstr);
break;
default:
return -1;
}
}
return 0;
}
void show_help(char* program)
{
printf("簡單的FFMPEG測試方案\n");
printf("Usage: %s inputfile [-sstreamid [-fframes] [-kskipped] [-ooutput_filename(without extension)] [-p] [-tthread_count］\n",
program);
return;
}
static void log_callback(void* ptr, int level, const char* fmt, va_list vl)
{
vfprintf(stdout, fmt, vl);
}
/ *音頻渲染器的代碼（OSS）*/
#include <sys/ioctl.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/soundcard.h>
#define OSS_DEVICE "/dev/dsp0"
struct audio_dsp
{
int audio_fd;
int channels;
int format;
int speed;
};
int map_formats(enum SampleFormat format)
{
switch(format)
{
case SAMPLE_FMT_U8:
return AFMT_U8;
case SAMPLE_FMT_S16:
return AFMT_S16_LE;
default:
return AFMT_U8;
}
}
int set_audio(struct audio_dsp* dsp)
{
if (dsp->audio_fd == -1)
{
printf("無效的音頻DSP ID!\n");
return -1;
}
if (-1 == ioctl(dsp->audio_fd, SNDCTL_DSP_SETFMT, &dsp->format))
{
printf("無法設置DSP格式!\n");
return -1;
}
if (-1 == ioctl(dsp->audio_fd, SNDCTL_DSP_CHANNELS, &dsp->channels))
{
printf("無法設置DSP格式!\n");
return -1;
}
if (-1 == ioctl(dsp->audio_fd, SNDCTL_DSP_SPEED, &dsp->speed))
{
printf("無法設置DSP格式!\n");
return -1;
}
return 0;
}
int play_pcm(struct audio_dsp* dsp, unsigned char *buf, int size)
{
if (dsp->audio_fd == -1)
{
printf("無效的音頻DSP ID！\n");
return -1;
}
if (-1 == write(dsp->audio_fd, buf, size))
{
printf("音頻DSP無法寫入！\n");
return -1;
}
return 0;
}
/* 音頻渲染代碼結束 */
/* 視頻渲染代碼*/
#include <linux/fb.h>
#include <sys/mman.h>
#define FB_DEVICE "/dev/fb0"
enum pic_format
{
eYUV_420_Planer,
};
struct video_fb
{
int video_fd;
struct fb_var_screeninfo vinfo;
struct fb_fix_screeninfo finfo;
unsigned char *fbp;
AVFrame *frameRGB;
struct
{
int x;
int y;
} video_pos;
};
int open_video(struct video_fb *fb, int x, int y)
{
int screensize;
fb->video_fd = open(FB_DEVICE, O_WRONLY);
if (fb->video_fd == -1) return -1;
if (ioctl(fb->video_fd, FBIOGET_FSCREENINFO, &fb->finfo)) return -2;
if (ioctl(fb->video_fd, FBIOGET_VSCREENINFO, &fb->vinfo)) return -2;
printf("視頻設備：分解 %dx%d, %dbpp\n", fb->vinfo.xres, fb->vinfo.yres, fb->vinfo.bits_per_pixel);
screensize = fb->vinfo.xres * fb->vinfo.yres * fb->vinfo.bits_per_pixel / 8;
fb->fbp = (unsigned char *) mmap(0, screensize, PROT_READ|PROT_WRITE, MAP_SHARED, fb->video_fd, 0);
if (fb->fbp == -1) return -3;
if (x >= fb->vinfo.xres || y >= fb->vinfo.yres)
{
return -4;
}
else
{
fb->video_pos.x = x;
fb->video_pos.y = y;
}
fb->frameRGB = avcodec_alloc_frame();
if (!fb->frameRGB) return -5;
return 0;
}
#if 0
/* only 420P supported now */
int show_picture(struct video_fb *fb, AVFrame *frame, int width, int height, enum pic_format format)
{
struct SwsContext *sws;
int i;
unsigned char *dest;
unsigned char *src;
if (fb->video_fd == -1) return -1;
if ((fb->video_pos.x >= fb->vinfo.xres) || (fb->video_pos.y >= fb->vinfo.yres)) return -2;
if (fb->video_pos.x + width > fb->vinfo.xres)
{
width = fb->vinfo.xres - fb->video_pos.x;
}
if (fb->video_pos.y + height > fb->vinfo.yres)
{
height = fb->vinfo.yres - fb->video_pos.y;
}
if (format == PIX_FMT_YUV420P)
{
sws = sws_getContext(width, height, format, width, height, PIX_FMT_RGB32, SWS_FAST_BILINEAR, NULL, NULL, NULL);
if (sws == 0)
{
return -3;
}
if (sws_scale(sws, frame->data, frame->linesize, 0, height, fb->frameRGB->data, fb->frameRGB->linesize))
{
return -3;
}
dest = fb->fbp + (fb->video_pos.x+fb->vinfo.xoffset) * (fb->vinfo.bits_per_pixel/8) +(fb->video_pos.y+fb->vinfo.yoffset) * fb->finfo.line_length;
for (i = 0; i < height; i++)
{
memcpy(dest, src, width*4);
src += fb->frameRGB->linesize[0];
dest += fb->finfo.line_length;
}
}
return 0;
}
#endif
void close_video(struct video_fb *fb)
{
if (fb->video_fd != -1)
{
munmap(fb->fbp, fb->vinfo.xres * fb->vinfo.yres * fb->vinfo.bits_per_pixel / 8);
close(fb->video_fd);
fb->video_fd = -1;
}
}
/* 視頻渲染代碼結束 */
int main(int argc, char **argv)
{
AVFormatContext* pCtx = 0;
AVCodecContext *pCodecCtx = 0;
AVCodec *pCodec = 0;
AVPacket packet;
AVFrame *pFrame = 0;
FILE *fpo1 = NULL;
FILE *fpo2 = NULL;
int nframe;
int err;
int got_picture;
int picwidth, picheight, linesize;
unsigned char *pBuf;
int i;
int64_t timestamp;
struct options opt;
int usefo = 0;
struct audio_dsp dsp;
int dusecs;
float usecs1 = 0;
float usecs2 = 0;
struct timeval elapsed1, elapsed2;
int decoded = 0;
av_register_all();
av_log_set_callback(log_callback);
av_log_set_level(50);
if (parse_options(&opt, argc, argv) < 0 || (strlen(opt.finput) == 0))
{
show_help(argv[0]);
return 0;
}
err = avformat_open_input(&pCtx, opt.finput, 0, 0);
if (err < 0)
{
printf("\n->(avformat_open_input)\tERROR:\t%d\n", err);
goto fail;
}
err = avformat_find_stream_info(pCtx, 0);
if (err < 0)
{
printf("\n->(avformat_find_stream_info)\tERROR:\t%d\n", err);
goto fail;
}
if (opt.streamId < 0)
{
av_dump_format(pCtx, 0, pCtx->filename, 0);
goto fail;
}
else
{
printf("\n 額外的數據流 %d (%dB):", opt.streamId, pCtx->streams[opt.streamId]->codec->extradata_size);
for (i = 0; i < pCtx->streams[opt.streamId]->codec->extradata_size; i++)
{
if (i%16 == 0) printf("\n");
printf("%2x ", pCtx->streams[opt.streamId]->codec->extradata[i]);
}
}
/ *嘗試打開輸出文件*/
if (strlen(opt.foutput1) && strlen(opt.foutput2))
{
fpo1 = fopen(opt.foutput1, "wb");
fpo2 = fopen(opt.foutput2, "wb");
if (!fpo1 || !fpo2)
{
printf("\n->error 打開輸出文件\n");
goto fail;
}
usefo = 1;
}
else
{
usefo = 0;
}
if (opt.streamId >= pCtx->nb_streams)
{
printf("\n->StreamId\tERROR\n");
goto fail;
}
if (opt.lstart > 0)
{
err = av_seek_frame(pCtx, opt.streamId, opt.lstart, AVSEEK_FLAG_ANY);
if (err < 0)
{
printf("\n->(av_seek_frame)\tERROR:\t%d\n", err);
goto fail;
}
}
/ *解碼器的配置*/
if (!opt.nodec)
{
/* prepare codec */
pCodecCtx = pCtx->streams[opt.streamId]->codec;
if (opt.thread_count <= 16 && opt.thread_count > 0 )
{
pCodecCtx->thread_count = opt.thread_count;
pCodecCtx->thread_type = FF_THREAD_FRAME;
}
pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
if (!pCodec)
{
printf("\n->不能找到編解碼器!\n");
goto fail;
}
err = avcodec_open2(pCodecCtx, pCodec, 0);
if (err < 0)
{
printf("\n->(avcodec_open)\tERROR:\t%d\n", err);
goto fail;
}
pFrame = avcodec_alloc_frame();
/ *準備設備* /
if (opt.bplay)
{
/ *音頻設備* /
dsp.audio_fd = open(OSS_DEVICE, O_WRONLY);
if (dsp.audio_fd == -1)
{
printf("\n-> 無法打開音頻設備\n");
goto fail;
}
dsp.channels = pCodecCtx->channels;
dsp.speed = pCodecCtx->sample_rate;
dsp.format = map_formats(pCodecCtx->sample_fmt);
if (set_audio(&dsp) < 0)
{
printf("\n-> 不能設置音頻設備\n");
goto fail;
}
/ *視頻設備* /
}
}
nframe = 0;
while(nframe < opt.frames || opt.frames == -1)
{
gettimeofday(&elapsed1, NULL);
err = av_read_frame(pCtx, &packet);
if (err < 0)
{
printf("\n->(av_read_frame)\tERROR:\t%d\n", err);
break;
}
gettimeofday(&elapsed2, NULL);
dusecs = (elapsed2.tv_sec - elapsed1.tv_sec)*1000000 + (elapsed2.tv_usec - elapsed1.tv_usec);
usecs2 += dusecs;
timestamp = av_rescale_q(packet.dts, pCtx->streams[packet.stream_index]->time_base, (AVRational){1, AV_TIME_BASE});
printf("\nFrame No %5d stream#%d\tsize %6dB, timestamp:%6lld, dts:%6lld, pts:%6lld, ", nframe++, packet.stream_index, packet.size,
timestamp, packet.dts, packet.pts);
if (packet.stream_index == opt.streamId)
{
#if 0
for (i = 0; i < 16; /*packet.size;*/ i++)
{
if (i%16 == 0) printf("\n pktdata: ");
printf("%2x ", packet.data[i]);
}
printf("\n");
#endif
if (usefo)
{
fwrite(packet.data, packet.size, 1, fpo1);
fflush(fpo1);
}
if (pCtx->streams[opt.streamId]->codec->codec_type == AVMEDIA_TYPE_VIDEO && !opt.nodec)
{
picheight = pCtx->streams[opt.streamId]->codec->height;
picwidth = pCtx->streams[opt.streamId]->codec->width;
gettimeofday(&elapsed1, NULL);
avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, &packet);
decoded++;
gettimeofday(&elapsed2, NULL);
dusecs = (elapsed2.tv_sec - elapsed1.tv_sec)*1000000 + (elapsed2.tv_usec - elapsed1.tv_usec);
usecs1 += dusecs;
if (got_picture)
{
printf("[Video: type %d, ref %d, pts %lld, pkt_pts %lld, pkt_dts %lld]",
pFrame->pict_type, pFrame->reference, pFrame->pts, pFrame->pkt_pts, pFrame->pkt_dts);
if (pCtx->streams[opt.streamId]->codec->pix_fmt == PIX_FMT_YUV420P)
{
if (usefo)
{
linesize = pFrame->linesize[0];
pBuf = pFrame->data[0];
for (i = 0; i < picheight; i++)
{
fwrite(pBuf, picwidth, 1, fpo2);
pBuf += linesize;
}
linesize = pFrame->linesize[1];
pBuf = pFrame->data[1];
for (i = 0; i < picheight/2; i++)
{
fwrite(pBuf, picwidth/2, 1, fpo2);
pBuf += linesize;
}
linesize = pFrame->linesize[2];
pBuf = pFrame->data[2];
for (i = 0; i < picheight/2; i++)
{
fwrite(pBuf, picwidth/2, 1, fpo2);
pBuf += linesize;
}
fflush(fpo2);
}
if (opt.bplay)
{
/* show picture */
}
}
}
av_free_packet(&packet);
}
else if (pCtx->streams[opt.streamId]->codec->codec_type == AVMEDIA_TYPE_AUDIO && !opt.nodec)
{
int got;
gettimeofday(&elapsed1, NULL);
avcodec_decode_audio4(pCodecCtx, pFrame, &got, &packet);
decoded++;
gettimeofday(&elapsed2, NULL);
dusecs = (elapsed2.tv_sec - elapsed1.tv_sec)*1000000 + (elapsed2.tv_usec - elapsed1.tv_usec);
usecs1 += dusecs;
if (got)
{
printf("[Audio: %5dB raw data, decoding time: %d]", pFrame->linesize[0], dusecs);
if (usefo)
{
fwrite(pFrame->data[0], pFrame->linesize[0], 1, fpo2);
fflush(fpo2);
}
if (opt.bplay)
{
play_pcm(&dsp, pFrame->data[0], pFrame->linesize[0]);
}
}
}
}
}
if (!opt.nodec && pCodecCtx)
{
avcodec_close(pCodecCtx);
}
printf("\n%d 幀解析, average %.2f us per frame\n", nframe, usecs2/nframe);
printf("%d 幀解碼，平均 %.2f 我們每幀\n", decoded, usecs1/decoded);
fail:
if (pCtx)
{
avformat_close_input(&pCtx);
}
if (fpo1)
{
fclose(fpo1);
}
if (fpo2)
{
fclose(fpo2);
}
if (!pFrame)
{
av_free(pFrame);
}
if (!usefo && (dsp.audio_fd != -1))
{
close(dsp.audio_fd);
}
return 0;}