一：H264解码处理
（一）解码步骤
1.引入解码头文件
#include <libavcodec/avcodec.h>
2.常用数据结构
AVCodec编码器结构体： 所使用的编码器类型，（H264/H265，音频/视频）
AVCodecContext编码器上下文： 串联各个API，形成API链条，每个API都需要我们把上下文作为参数传入该API。内部也保存了编解码器信息，可以供其调用
AVFrame解码后的帧： 未压缩的帧（未编码）
3.结构体内存的分配和释放
4.解码步骤
avcodec_find_decoder通过id查找解码器，当然也可以通过名字by_name查找到编解码器（如下面的编码）;两种方式各有好处
avcodec_decode_video2编解码一般使用外部编解码库，比如libx264
（二）编程实战（YUV视频流转RGB图像）
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <libavutil/log.h>
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libswscale/swscale.h> //ibswscale是一个主要用于处理图片像素数据的类库。可以完成图片像素格式的转换，图片的拉伸等工作
#define WORD uint16_t
#define DWORD uint32_t
#define LONG int32_t
//https://www.cnblogs.com/lzlsky/archive/2012/08/16/2641698.html
typedef struct tagBITMAPFILEHEADER {
WORD bfType; //位图类别，根据不同的操作,系统而不同，在Windows中，此字段的值总为‘BM’
DWORD bfSize; //BMP图像文件的大小
WORD bfReserved1; //保留，为0
WORD bfReserved2; //保留，为0
DWORD bfOffBits; //BMP图像数据的地址
} BITMAPFILEHEADER, *PBITMAPFILEHEADER;
typedef struct tagBITMAPINFOHEADER {
DWORD biSize; //包含的是这个结构体的大小（包括颜色表）
LONG biWidth; //是图片的长
LONG biHeight; //是图片的宽
WORD biPlanes; //是目标绘图设备包含的层数，必须设置为1
WORD biBitCount; //是图像的位数，例如24位，8位等
DWORD biCompression; //压缩方式，0表示不压缩，1表示RLE8压缩，2表示RLE4压缩，3表示每个像素值由指定的掩码决定
DWORD biSizeImage; //BMP图像数据大小，必须是4的倍数，图像数据大小不是4的倍数时用0填充补足
LONG biXPelsPerMeter;//水平分辨率，单位像素/m
LONG biYPelsPerMeter;//垂直分辨率，单位像素/m
DWORD biClrUsed; //BMP图像使用的颜色，0表示使用全部颜色，对于256色位图来说，此值为100h=256
DWORD biClrImportant; //重要的颜色数，此值为0时所有颜色都重要，对于使用调色板的BMP图像来说，当显卡不能够显示所有颜色时，此值将辅助驱动程序显示颜色
} BITMAPINFOHEADER, *PBITMAPINFOHEADER;
void saveBMP(struct SwsContext* img_convert_cxt,AVFrame* frame,char* filename){
//1.先进行转换，YUV420=>RGB24
int w = frame->width;
int h = frame->height;
int numBytes = avpicture_get_size(AV_PIX_FMT_RGB24,w,h); //计算字节数量
uint8_t* buffer = (uint8_t*)av_malloc(numBytes*sizeof(uint8_t)); //分配空间
AVFrame* pFrameRGB = av_frame_alloc();
//avpicture_fill函数将ptr指向的数据填充到picture内，但并没有拷贝，只是将picture结构内的data指针指向了ptr的数据。
avpicture_fill((AVPicture*)pFrameRGB,buffer,AV_PIX_FMT_RGB24,w,h);
//真正用来做转换的函数:https://www.cnblogs.com/yongdaimi/p/10715830.html
sws_scale(img_convert_cxt,frame->data,frame->linesize, //当前处理区域的每个通道数据指针，每个通道行字节数
0,h, //参数int srcSliceY, int srcSliceH,定义在输入图像上处理区域，srcSliceY是起始位置，srcSliceH是处理多少行。如果srcSliceY=0，srcSliceH=height，表示一次性处理完整个图像。
pFrameRGB->data,pFrameRGB->linesize); //定义输出图像信息（输出的每个通道数据指针，每个通道行字节数）
//上面将数据转换完成，下面初始化结构体，写入BMP图片数据，到文件中去
//---构造BITMAPINFOHEADER信息首部（第二部分，先有文件头，再有信息头，再之后是数据）
BITMAPINFOHEADER header;
header.biSize = sizeof(BITMAPINFOHEADER);
header.biWidth = w;
/*
如果该值是一个正数，说明Btimap是Bottom up DIB，起始点是左下角，也就是从图像的最下面一行扫描，位图数组中得到的第一行数据实际是图形的最下面的一行。图像是倒向的；
如果该值是一个负数，则说明图像是TopDown DIB，起始点是左上角，图像从最上面一行扫描，图像正向的。
大多数的BMP文件都是倒向的位图，也就是时，高度值是一个正数。（注：当高度值是一个负数时（正向图像），图像将不能被压缩（也就是说biCompression成员将不能是BI_RLE8或BI_RLE4）
*/
header.biHeight = h*(-1); //biHeight字段的正负号指定DIB图像的绘制方向,负数表示为正向，不被压缩
header.biPlanes = 1; //必须为1
header.biBitCount = 24; //RBG位深24
header.biCompression = 0; //不压缩
header.biSizeImage = 0; //其中 biSizeImage 如果不为 0 这代表位图中实际的像素数据字节数;同时如果为0,位图像素数据的字节数也可以通过 biWidth biHeight biBitCount 计算得到。
header.biXPelsPerMeter = 0; //设置分辨率 像素/米
header.biYPelsPerMeter = 0;
header.biClrUsed = 0; //使用全部颜色
header.biClrImportant = 0; //全都重要
//---BITMAPFILEHEADER文件头（第一部分）
BITMAPFILEHEADER bmpFileHeader;
bmpFileHeader.bfType = 0x4d42; //"BM"
bmpFileHeader.bfSize = sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+numBytes;
bmpFileHeader.bfReserved1 = 0;
bmpFileHeader.bfReserved2 = 0;
bmpFileHeader.bfOffBits = sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER);
FILE* fp = fopen(filename,"wb");
//由于linux上4字节对齐，而信息头大小为54字节，第一部分14字节，第二部分40字节，所以会将第一部分补齐为16自己，直接用sizeof，打开图片时就会遇到premature end-of-file encountered错误
//下面的方式可以防止对齐，避免对齐导致出错
fwrite(&bmpFileHeader,8,1,fp); //先把bfType、bfSize、bfReserved1写入
fwrite(&bmpFileHeader.bfReserved2,sizeof(bmpFileHeader.bfReserved2),1,fp);
fwrite(&bmpFileHeader.bfOffBits,sizeof(bmpFileHeader.bfOffBits),1,fp);
fwrite(&header,sizeof(BITMAPINFOHEADER),1,fp);
//-----------进行色彩矫正，RGB-->GBR才能变为原本的色彩
for(int i=0;i<numBytes-3;i+=3){
uint8_t temp = pFrameRGB->data[0][i];
pFrameRGB->data[0][i] = pFrameRGB->data[0][i+1];
pFrameRGB->data[0][i+1] = temp;
temp = pFrameRGB->data[0][i+1];
pFrameRGB->data[0][i+1] = pFrameRGB->data[0][i+2];
pFrameRGB->data[0][i+2] = temp;
}
fwrite(pFrameRGB->data[0],1,numBytes,fp); //对于RGB只需要一个数组，YUV需要3个
fclose(fp);
//释放资源
av_freep(&pFrameRGB[0]);
av_freep(pFrameRGB);
}
int decode_write_frame(const char* out_filename,AVCodecContext* avctx,struct SwsContext* img_convert_cxt,
AVFrame* frame,int* frame_count,AVPacket* packet,int last){
int len,got_frame;
char buf[1024];
//进行解码操作-----------------
//作用是解码一帧视频数据。输入一个压缩编码的结构体AVPacket，输出一个解码后的结构体AVFrame。
len = avcodec_decode_video2(avctx,frame,&got_frame,packet); //got_frame该值为0表明没有图像可以解码，否则表明有图像可以解码；
if(len<0){
av_log(NULL,AV_LOG_ERROR,"Fail to decode video frame %d\n",*frame_count);
return len;
}
if(got_frame){ //一个包中可能有1个或者多个帧,一般视频包中包含1帧;这里我们只获取1帧，进行处理，其他的依旧保留在packet结构体中，后面进行修改
if(last)
av_log(NULL,AV_LOG_INFO,"----Get last frame"); //一般最后一帧可能会做特殊处理
av_log(NULL,AV_LOG_INFO,"Get frame count %3d,Saving frame %3d\n",got_frame,*frame_count);
snprintf(buf,sizeof(buf),"%s-%d.bmp",out_filename,*frame_count); //图像命名
//保存图像
saveBMP(img_convert_cxt,frame,buf);
(*frame_count)++;
}
//avcodec_decode_video2只获取了包中的一帧，然而包中可能还有其他帧，所以这里进行处理，进行结构体数据修改
if(packet->data){
packet->size -= len; //大小减去1帧大小
packet->data += len; //数据下移，跳过已经处理的数据
}
return 0;
}
void decode_video(char* in_filename,char* out_filename){
int ret,cnt=500; //cnt长视频输出数量
AVFormatContext* fmt_cxt = NULL;
AVCodec* codec = NULL;
AVCodecContext* c = NULL;
struct SwsContext* img_convert_cxt = NULL; //图像处理上下文
int stream_idx;
AVStream* st = NULL;
int frameCnt = 0; //记录解码的帧数量
AVFrame* frame = NULL;
AVPacket packet;
ret = avformat_open_input(&fmt_cxt,in_filename,NULL,NULL);
if(ret<0){
av_log(NULL,AV_LOG_ERROR,"Can`t open input file:%s\n",in_filename);
return;
}
ret = avformat_find_stream_info(fmt_cxt,0); //获取输入流的详细信息
if(ret<0){
av_log(NULL,AV_LOG_ERROR,"Could not find stream information\n");
goto __AVFORMAT;
}
//媒体文件句柄 / 流类型 / 请求的流编号(-1则自动去找) / 相关流索引号（比如音频对应的视频流索引号），不指定则-1 / 如果非空，则返回所选流的解码器（指针获取） / flag当前未定义
ret = av_find_best_stream(fmt_cxt,AVMEDIA_TYPE_VIDEO,-1,-1,NULL,0);
if(ret<0){
av_log(NULL,AV_LOG_ERROR,"Can`t find the best stream\n");
goto __AVFORMAT;
}
//获取流并打印流的信息
stream_idx = ret;
st = fmt_cxt->streams[stream_idx];
av_dump_format(fmt_cxt,stream_idx,in_filename,0);
//查找解码器-----------------
codec = avcodec_find_decoder(st->codecpar->codec_id); //根据id查找解码器，id信息存放在输入文件视频流中
if(!codec){
av_log(NULL,AV_LOG_ERROR,"Can`t find the decoder[%s] for input file:%s\n",av_get_media_type_string(AVMEDIA_TYPE_VIDEO),in_filename);
goto __AVFORMAT;
}
//打开解码器之前，先分配上下文内存-----------------
c = avcodec_alloc_context3(NULL);
if(!c){
av_log(NULL,AV_LOG_ERROR,"Failed to copy %s codec parameters to decoder context\n",av_get_media_type_string(AVMEDIA_TYPE_VIDEO));
goto __AVFORMAT;
}
//将解码器的参数进行设置：将输入流的参数直接拷贝即可-----------------
ret = avcodec_parameters_to_context(c,st->codecpar);
if(ret<0){
av_log(NULL,AV_LOG_ERROR,"Cannot initialize the conversion context\n");
goto __ACCODEC;
}
//创建图片转换上下文（在上面参数拷贝后面）-----------------
//源图像宽、高、像素格式;目标图像宽、高、像素格式;以及图像拉伸使用的算法
img_convert_cxt = sws_getContext(c->width,c->height,c->pix_fmt,
c->width,c->height,AV_PIX_FMT_BGR24,
SWS_BICUBIC,NULL,NULL,NULL); //后面为源、目的图像过滤器，和参数
if(img_convert_cxt==NULL){
av_log(NULL,AV_LOG_ERROR,"Can`t open the codec\n");
goto __ACCODEC;
}
//打开解码器-----------------
ret = avcodec_open2(c,codec,NULL);
if(ret<0){
av_log(NULL,AV_LOG_ERROR,"Can`t open the codec\n");
goto __SWSCXT;
}
frame = av_frame_alloc();
if(!frame){
av_log(NULL,AV_LOG_ERROR,"Can`t alloc the frame for video\n");
goto __SWSCXT;
}
//开始读取数据
av_init_packet(&packet); //初始化数据包
while(av_read_frame(fmt_cxt,&packet)>=0&&(--cnt)>=0){
if(packet.stream_index == stream_idx){
if(decode_write_frame(out_filename,c,img_convert_cxt,
frame,&frameCnt,&packet,0)<0){
av_log(NULL,AV_LOG_ERROR,"Failed to decode frame in decode_write_frame\n");
goto __PACKET;
}
av_packet_unref(&packet); //注意：减少引用不会释放空间，因为本函数还在引用这个packet结构体;
//所以我们在解码函数中剩余的其他帧数据，还是保留在packet中的，后面根据av_read_frame继续向内部添加数据
}
}
//处理packet中剩余的帧
packet.data = NULL;
packet.size = 0;
decode_write_frame(out_filename,c,img_convert_cxt,
frame,&frameCnt,&packet,1);
//下面开始处理在堆上创建的内存空间
__PACKET:
av_frame_free(&frame);
av_packet_unref(&packet); //减少引用，使得自己释放空间
__SWSCXT:
sws_freeContext(img_convert_cxt);
__ACCODEC:
avcodec_free_context(&c);
__AVFORMAT:
avformat_close_input(&fmt_cxt);
return;
}
int main(int argc,char* argv[]){
av_register_all();
av_log_set_level(AV_LOG_DEBUG);
if(argc < 3){
av_log(NULL,AV_LOG_ERROR,"The Count of Parameter must be than 2\n");
return -1;
}
decode_video(argv[1],argv[2]);
return 0;
}
View Code
gcc 02_ffmpeg_dec.c -o fd -I /usr/local/ffmpeg/include/ -L /usr/local/ffmpeg/lib/ -lavutil -lavformat -lavcodec -lavdevice -lswscale
./fd gfxm.mp4 gfxm
二：H264编码处理
（一）编码流程
avcodec_open2在解码和编码过程不同（在设置参数上）：
解码：因为输入文件中输入流本身已经设置好了参数，解码时只需要把这些参数拷贝即可，不需要手动设置
编码：需要我们手动设置，比如分辨率...
#include <stdio.h>
#include <libavutil/log.h>
#include <libavcodec/avcodec.h>
#include <libavdevice/avdevice.h>
#include <libavformat/avformat.h>
#define V_WIDTH 640
#define V_HEIGHT 480
AVFormatContext* open_dev(){
char* devicename = "/dev/video0"; //设备文件描述符
char errors[1024];
int ret;
AVFormatContext* fmt_ctx=NULL; //格式上下文获取-----av_read_frame获取packet
AVDictionary* options=NULL;
AVInputFormat *iformat=NULL;
AVPacket packet; //包结构
//获取输入(采集）格式
iformat = av_find_input_format("video4linux2"); //驱动，用来录制视频
//设置参数 ffmpeg -f video4linux2 -pixel_format yuyv422 -video_size 640*480 -framerate 15 -i /dev/video0 out.yuv
av_dict_set(&options,"video_size","640*480",0);
av_dict_set(&options,"framerate","30",0);
av_dict_set(&options,"pixel_format","yuyv422",0);
//打开输入设备
ret = avformat_open_input(&fmt_ctx,devicename,iformat,&options); //----打开输入设备，初始化格式上下文和选项
if(ret<0){
av_strerror(ret,errors,1024);
av_log(NULL,AV_LOG_ERROR,"Failed to open video device,[%d]%s\n",ret,errors);
return NULL;
}
av_log(NULL,AV_LOG_INFO,"Success to open video device\n");
return fmt_ctx;
}
//作用：编码，将yuv420转H264
AVCodecContext* open_encoder(int width,int height){
//------1.打开编码器
AVCodec* codec = avcodec_find_encoder_by_name("libx264");
if(!codec){
av_log(NULL,AV_LOG_ERROR,"Failed to open video encoder\n");
return NULL;
}
//------2.创建上下文
AVCodecContext* codec_ctx = avcodec_alloc_context3(codec);
if(!codec_ctx){
av_log(NULL,AV_LOG_ERROR,"Failed to open video encoder context\n");
return NULL;
}
//------3.设置上下文参数
//SPS/PPS
codec_ctx->profile = FF_PROFILE_H264_HIGH_444; //main分支*别编码
codec_ctx->level = 50; //表示level级别是5.0;支持最大分辨率2560×1920
//分辨率
codec_ctx->width = width; //设置分辨率--宽度
codec_ctx->height = height; //设置分辨率--高度
//GOP
codec_ctx->gop_size = 250; //设置GOP个数，根据业务处理;
codec_ctx->keyint_min = 25; //（option）如果GOP过大，我们就在中间多设置几个I帧，使得避免卡顿。这里表示在一组GOP中，最小插入I帧的间隔
//B帧(增加压缩比，降低码率)
codec_ctx->has_b_frames = 1; //（option）标志是否允许存在B帧
codec_ctx->max_b_frames = 3; //（option）设置中间连续B帧的最大个数
//参考帧（越大，还原性越好，但是压缩慢）
codec_ctx->refs = 3; //（option）设置参考帧最大数量，缓冲队列
//要进行编码的数据的原始数据格式（输入的原始数据）
codec_ctx->pix_fmt = AV_PIX_FMT_YUV420P; //注意：我们如果不进行转换yuyv422为yuv420的话，这里直接设置为AV_PIX_FMT_YUYV422P即可
//设置码率
codec_ctx->bit_rate = 600000; //设置平均码率600kpbs（根据业务）
//设置帧率
codec_ctx->time_base = (AVRational){1,25}; //时间基，为帧率的倒数;帧与帧之间的间隔
codec_ctx->framerate = (AVRational){25,1}; //帧率，每秒25帧
if(codec->id==AV_CODEC_ID_H264) //如果是h264,则可以使用预先设置好的h264参数集，压缩速度slow慢，保证质量
av_opt_set(codec_ctx->priv_data,"preset","slow",0);
//------4.打开编码器
if(avcodec_open2(codec_ctx,codec,NULL)<0){
av_log(NULL,AV_LOG_ERROR,"Failed to open libx264 context\n");
avcodec_free_context(&codec_ctx);
return NULL;
}
return codec_ctx;
}
static AVFrame* initFrame(int width,int height){
int ret;
AVFrame* frame = av_frame_alloc(); //分配frame空间，但是数据真正被存放在buffer中
if(!frame){
av_log(NULL,AV_LOG_ERROR,"Failed to create frame\n");
return NULL;
}
//主要是设置分辨率，用来分配空间
frame->width = width;
frame->height = height;
frame->format = AV_PIX_FMT_YUV420P;
ret = av_frame_get_buffer(frame,32); //第二个参数是对齐，对于音频，我们直接设置0,视频中必须为32位对齐
if(ret<0){ //内存分配出错
av_log(NULL,AV_LOG_ERROR,"Failed to alloc frame buffer\n");
av_frame_free(&frame);
return NULL;
}
return frame;
}
//开始进行编码操作
static void encode(AVCodecContext* enc_ctx,AVFrame* frame,AVPacket* newpkt,FILE* encfp){
int len=0,got_output;
int ret = avcodec_encode_video2(enc_ctx,newpkt,frame,&got_output); //传入上下文，输出packet，输入frame，got_output表示是否产生avpacket，不是每一个frame对应一个packet，而是可能存在多个frame对应一个packet
if(ret<0){
av_log(NULL,AV_LOG_ERROR,"avcodec_encode_video2 error! [%d] %s\n",ret,av_err2str(ret));
return;
}
if(got_output){
len = fwrite(newpkt->data,1,newpkt->size,encfp);
fflush(encfp);
if(len!=newpkt->size){
av_log(NULL,AV_LOG_WARNING,"Warning,newpkt size:%d not equal writen size:%d\n",len,newpkt->size);
}else{
av_log(NULL,AV_LOG_INFO,"Success write newpkt to file\n");
}
}
av_packet_unref(newpkt); //注意:不同于avcodec_receive_packet，我们这里需要手动处理newpkt空间，负责会出现Provided packet is too small问题
}
void rec_video(){
char errors[1024];
int ret,count=0,len,i,j,y_idx,u_idx,v_idx,base_h,base=0;
AVFormatContext* fmt_ctx = NULL;
AVCodecContext* enc_ctx = NULL;
AVFrame* fmt = NULL;
AVPacket packet;
//打开文件，存放转换为yuv420的数据
FILE* fp = fopen("./video.yuv","wb");
if(fp==NULL){
av_log(NULL,AV_LOG_ERROR,"Failed to open out file\n");
goto fail;
}
//打开文件，存放编码后数据（其实上面没必要存在）
FILE* encfp = fopen("./video.h264","wb");
if(encfp==NULL){
av_log(NULL,AV_LOG_ERROR,"Failed to open out H264 file\n");
goto fail;
}
//打开摄像头设备的上下文格式
fmt_ctx = open_dev();
if(!fmt_ctx)
goto fail;
//打开编码上下文
enc_ctx = open_encoder(V_WIDTH,V_HEIGHT);
if(!enc_ctx)
goto fail;
//创建AVFrame
AVFrame* frame = initFrame(V_WIDTH,V_HEIGHT);
//创建AVPacket
AVPacket* newpkt = av_packet_alloc();
if(!newpkt){
av_log(NULL,AV_LOG_ERROR,"Failed to alloc avpacket\n");
goto fail;
}
//开始从设备中读取数据
while((ret=av_read_frame(fmt_ctx,&packet))==0&&count++<100){
av_log(NULL,AV_LOG_INFO,"Packet size:%d(%p),cout:%d\n",packet.size,packet.data,count);
//------先将YUYV422数据转YUV420数据（重点）
//序列为YU YV YU YV，一个yuv422帧的长度 width * height * 2 个字节
//丢弃偶数行 u v
//先存放Y数据
memset(frame->data[0],0,V_WIDTH*V_HEIGHT*sizeof(char));
for(i=0,y_idx=0;i<2*V_HEIGHT*V_WIDTH;i+=2){
frame->data[0][y_idx++]=packet.data[i];
}
//再获取U、V数据
memset(frame->data[1],0,V_WIDTH*V_HEIGHT*sizeof(char)/4);
memset(frame->data[2],0,V_WIDTH*V_HEIGHT*sizeof(char)/4);
for(i=0,u_idx=0,v_idx=0;i<V_HEIGHT;i+=2){ //丢弃偶数行,注意：i<V_HEIGHT*2,总数据量是Y+UV,可以达到V_HEIGHT*2行
base_h = i*2*V_WIDTH; //获取奇数行开头数据位置
for(j=0;j<V_WIDTH*2;j+=4){ //遍历这一行数据,每隔4个为1组 y u y v
frame->data[1][u_idx++] = packet.data[base_h+j+1]; //获取U数据
frame->data[2][v_idx++] = packet.data[base_h+j+3]; //获取V数据
}
}
//写入yuv420数据
fwrite(frame->data[0],1,V_WIDTH*V_HEIGHT,fp);
fwrite(frame->data[1],1,V_WIDTH*V_HEIGHT/4,fp);
fwrite(frame->data[2],1,V_WIDTH*V_HEIGHT/4,fp);
//开始编码
frame->pts = base++; //重点：对帧的pts进行顺序累加;不能设置随机值;H264要求编码的帧的pts是连续的值
encode(enc_ctx,frame,newpkt,encfp);
//释放空间
av_packet_unref(&packet);
}
encode(enc_ctx,NULL,newpkt,encfp); //告诉编码器编码结束，将后面剩余的数据全部写入即可
fail:
if(fp)
fclose(fp);
if(encfp)
fclose(encfp);
if(frame)
av_frame_free(&frame);
if(newpkt)
av_packet_free(&newpkt);
//关闭设备、释放上下文空间
if(enc_ctx)
avcodec_free_context(&enc_ctx);
avformat_close_input(&fmt_ctx);
return ;
}
int main(int argc,char* argv)
{
av_register_all();
av_log_set_level(AV_LOG_DEBUG);
//注册所有的设备，包括我们需要的音频设备
avdevice_register_all();
rec_video();
return 0;
}
View Code
gcc 01_ffmpeg_enc.c -o fe -I /usr/local/ffmpeg/include/ -L /usr/local/ffmpeg/lib/ -lavutil -lavformat -lavcodec -lavdevice
三：AAC解码处理
解码方式同上面的H264解码，不同的是解码函数：
/*@param avctx编解码器上下文
*@param [out] frame用于存储解码音频样本的AVFrame
*@param [out] got_frame_ptr如果没有帧可以解码则为零，否则为非零
*@param [in] avpkt包含输入缓冲区的输入AVPacket
*@return 如果在解码期间发生错误，则返回否定错误代码，否则返回从输入AVPacket消耗的字节数。
*/
int avcodec_decode_audio4 ( AVCodecContext * avctx, AVFrame * frame, int * got_frame_ptr, const AVPacket * avpkt )
（一）获取AAC数据
ffmpeg -i out.mp4 -acodec copy -vn out.aac
一个AAC原始帧包含一段时间内1024个采样及相关数据!!
AAC:
音频帧的播放时间=一个AAC帧对应的采样样本的个数/采样频率(单位为s)
一帧 1024个 sample。采样率 Samplerate 44100Hz，每秒44100个sample, 所以根据公式 音频帧的播放时间=一个AAC帧对应的采样样本的个数/采样频率
当前AAC一帧的播放时间是= 1024*1000/44100= 22.32ms(单位为ms)
MP3:
mp3 每帧均为1152个字节， 则：
frame_duration = 1152 * 1000 / sample_rate
例如：sample_rate = 44100HZ时，计算出的时长为26.122ms，这就是经常听到的mp3每帧播放时间固定为26ms的由来。
（二）编程实战（AAC解码为PCM数据）
#include <stdio.h>
#include <libavutil/log.h>
#include <libavformat/avformat.h>
#include <libswresample/swresample.h>
#define MAX_AUDIO_FRAME_SIZE 192000
SwrContext* getSwrCxt(AVCodecContext* c,uint8_t** dst,int* dst_size,int* ret){
SwrContext* swr_cxt = NULL;
//------开始设置解码转换参数
uint64_t out_channel_layout = AV_CH_LAYOUT_STEREO; //输入数据的通道布局，是双声道
int out_nb_samples = 1024; //采样个数
enum AVSampleFormat sample_fmt = AV_SAMPLE_FMT_S16;
int out_sample_rate = 44100;
int out_channels = av_get_channel_layout_nb_channels(out_channel_layout);
*dst_size = av_samples_get_buffer_size(NULL,out_channels,out_nb_samples,sample_fmt,1); //这是每次采样的数据 = 通道数×每个通道采样（每帧）×格式
*dst = (uint8_t*)av_malloc(MAX_AUDIO_FRAME_SIZE*2); //最大开辟的空间
if(*dst==NULL){
av_log(NULL,AV_LOG_ERROR,"Can`t alloc dst memory!\n");
*ret = -3;
return NULL;
}
int64_t in_channel_layout = av_get_default_channel_layout(c->channels);
//----------创建重采样的上下文
swr_cxt = swr_alloc_set_opts(NULL, //设置已经创建好的上下文，如果没有，则为NULL
out_channel_layout, //设置输出目标的通道布局（双声道，立体声，...,方位增宽)
sample_fmt, //设置输出目标的采样格式，设置为32位浮点型
out_sample_rate, //设置输出目标的采样率
in_channel_layout, //输入数据的通道布局，是双声道
c->sample_fmt, //输入数据的采样格式为s16le
c->sample_rate, //输入的采样率
0, //日志级别
NULL); //日志上下文
if(!swr_cxt){
av_log(NULL,AV_LOG_ERROR,"Failed to set swr context\n");
*ret = -1;
return NULL;
}
//----------初始化上下文
if(swr_init(swr_cxt)<0){
av_log(NULL,AV_LOG_ERROR,"Failed to initial swr context\n");
*ret = -2;
return NULL;
}
return swr_cxt;
}
void dec_audio(char* in_filename,char* out_filename){
int ret,stream_idx,cnt=1;
int got_aac;
FILE* fp = NULL;
AVFormatContext* fmt_ctx=NULL;
AVCodec* codec = NULL;
AVCodecContext* c = NULL;
SwrContext* swr_cxt = NULL;
AVPacket* packet; //包结构
AVFrame* frame;
uint8_t* dst;
int dst_size;
ret = avformat_open_input(&fmt_ctx,in_filename,NULL,NULL);
if(ret<0){
av_log(NULL,AV_LOG_ERROR,"Can`t open input file:%s\n",in_filename);
return;
}
ret = avformat_find_stream_info(fmt_ctx,0); //获取输入流的详细信息
if(ret<0){
av_log(NULL,AV_LOG_ERROR,"Can`t find stream information!\n");
goto __AVFORMAT;
}
//媒体文件句柄 / 流类型 / 请求的流编号(-1则自动去找) / 相关流索引号（比如音频对应的视频流索引号），不指定则-1 / 如果非空，则返回所选流的解码器（指针获取） / flag当前未定义
ret = av_find_best_stream(fmt_ctx,AVMEDIA_TYPE_AUDIO,-1,-1,NULL,0);
if(ret<0){
av_log(NULL,AV_LOG_ERROR,"Can`t find the best stream!\n");
goto __AVFORMAT;
}
stream_idx = ret;
c = fmt_ctx->streams[stream_idx]->codec; //获取输入流的编解码上下文
codec = avcodec_find_decoder(c->codec_id); //获取输入流对应的解码器
if(!codec){
av_log(NULL,AV_LOG_ERROR,"Can`t find the decoder!\n");
goto __AVFORMAT;
}
//打开解码器
ret = avcodec_open2(c,codec,NULL);
if(ret<0){
av_log(NULL,AV_LOG_ERROR,"Can`t open avcodec!\n");
goto __AVFORMAT;
}
swr_cxt = getSwrCxt(c,&dst,&dst_size,&ret);
if(!swr_cxt){
if(ret==-2)
goto __SWRCXT;
goto __AVFORMAT;
}
packet = av_packet_alloc();
if(!packet){
av_log(NULL,AV_LOG_ERROR,"Can`t alloc packet!\n");
goto __SWRCXT;
}
av_init_packet(packet);
frame = av_frame_alloc();
if(!frame){
av_log(NULL,AV_LOG_ERROR,"Can`t alloc packet!\n");
goto __PACKET;
}
//打开文件
fp = fopen(out_filename,"wb");
if(fp==NULL){
av_log(NULL,AV_LOG_ERROR,"Failed to open out file\n");
goto __FRAME;
}
//开始从设备中读取数据
while(av_read_frame(fmt_ctx,packet)>=0){
if(packet->stream_index == stream_idx){
av_log(NULL,AV_LOG_INFO,"decode %d aac frame to pcm\n",cnt++);
//开始解码aac数据为pcm
ret = avcodec_decode_audio4(c,frame,&got_aac,packet);
if(ret<0){
av_log(NULL,AV_LOG_ERROR,"Failed to open out file\n");
goto fail;
}
//转码
if(got_aac>0){
swr_convert(swr_cxt, //上下文
&dst, //输出数组（双指针）
MAX_AUDIO_FRAME_SIZE, //每个通道的采样数
(const uint8_t**)frame->data, //输入数据，来自与packet.data，要改造格式
frame->nb_samples); //输入的通道采样数
fwrite(dst,1,dst_size,fp);
}
got_aac = 0;
}
//释放空间
av_free_packet(packet);
}
//----------释放空间
fail:
fclose(fp);
__FRAME:
av_frame_free(&frame);
__PACKET:
av_free_packet(packet);
__SWRCXT:
av_freep(&dst);
swr_free(&swr_cxt);
__AVFORMAT:
//关闭设备、释放上下文空间
avformat_close_input(&fmt_ctx);
return ;
}
int main(int argc,char* argv[])
{
av_register_all();
av_log_set_level(AV_LOG_DEBUG);
if(argc<=2){
av_log(NULL,AV_LOG_ERROR,"The Count of Parameter must be than 2\n");
return -1;
}
dec_audio(argv[1],argv[2]);
return 0;
}
View Code
gcc -o fad 04_ffmpeg_aac_dec.c -I /usr/local/ffmpeg/include/ -L /usr/local/ffmpeg/lib/ -lavutil -lavformat -lavcodec -lavdevice -lswresample
./fad out.aac out.pcm
ffplay out.pcm -ar 44100 -ac 2 -f s16le
四：AAC编码处理
（一）编程实战（PCM转AAC数据）
ffmpeg -i out.aac -ar 48000 -ac 2 -f f32le 48000_2_f32le.pcm
#include <libavutil/log.h>
#include <libavcodec/avcodec.h>
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){ // 通过AV_SAMPLE_FMT_NONE作为结束符
av_log(NULL,AV_LOG_INFO,"codec[%s] support sample fromat: %s\n",codec->name,av_get_sample_fmt_name(*p));
if(*p==sample_fmt)
return 1;
p++;
}
return 0;
}
static int check_sample_rate(const AVCodec* codec,const int sample_rate){
const int* p = codec->supported_samplerates;
while(*p!=0){ // 0作为退出条件，比如libfdk-aacenc.c的aac_sample_rates
av_log(NULL,AV_LOG_INFO,"codec[%s] support sample rate: %dhz\n",codec->name,*p);
if(*p==sample_rate)
return 1;
p++;
}
return 0;
}
static int check_sample_channel_layout(const AVCodec* codec,const uint64_t channel_layout){
const uint64_t* p = codec->channel_layouts;
if(!p){ // 不是每个codec都给出支持的channel_layout
av_log(NULL,AV_LOG_ERROR,"codec[%s] not set channel layout\n",codec->name);
return 1;
}
while(*p!=0){ // 0作为退出条件，比如libfdk-aacenc.c的aac_channel_layout
av_log(NULL,AV_LOG_INFO,"codec[%s] support channel layout: %d\n",codec->name,*p);
if(*p==channel_layout)
return 1;
p++;
}
return 0;
}
static int check_codec(AVCodec* codec,AVCodecContext* codec_ctx){
//检查格式
if(!check_sample_fmt(codec,codec_ctx->sample_fmt)){
av_log(NULL,AV_LOG_ERROR,"codec[%s] not support sample fromat: %d\n",codec->name,
av_get_sample_fmt_name(codec_ctx->sample_fmt));
return 0;
}
//检查比特率
if(!check_sample_rate(codec,codec_ctx->sample_rate)){
av_log(NULL,AV_LOG_ERROR,"codec[%s] not support sample rate: %dhz\n",codec->name,codec_ctx->sample_rate);
return 0;
}
//检查通道布局
if(!check_sample_channel_layout(codec,codec_ctx->channel_layout)){
av_log(NULL,AV_LOG_ERROR,"codec[%s] not support channel layout: %d\n",codec->name,codec_ctx->channel_layout);
return 0;
}
//打印所有配置
av_log(NULL,AV_LOG_INFO,"\n\ncodec[%s] encode config\n",codec->name);
av_log(NULL,AV_LOG_INFO,"bit_rate:%ldkbps\n",codec_ctx->bit_rate/1024);
av_log(NULL,AV_LOG_INFO,"sample_rate:%d\n",codec_ctx->sample_rate);
av_log(NULL,AV_LOG_INFO,"sample_fmt:%s\n",av_get_sample_fmt_name(codec_ctx->sample_fmt));
av_log(NULL,AV_LOG_INFO,"channels:%d\n",codec_ctx->channels);
av_log(NULL,AV_LOG_INFO,"aac frame_size:%d\n\n",codec_ctx->frame_size);
return 1;
}
AVCodecContext* getCodeCtx(int* ret){
//---------1.打开编码器
enum AVCodecID codec_id = AV_CODEC_ID_AAC;
AVCodec* codec = avcodec_find_encoder(codec_id);
//AVCodec* codec = avcodec_find_encoder_by_name("libfdk_aac"); //内部要求的采样大小就是是s16le------重点
if(!codec){
av_log(NULL,AV_LOG_ERROR,"Codec not found\n");
*ret = -1;
return NULL;
}
//---------2.创建上下文
AVCodecContext* codec_ctx = avcodec_alloc_context3(codec);
if(!codec_ctx){
av_log(NULL,AV_LOG_ERROR,"Codec can`t alloc context\n");
*ret = -1;
return NULL;
}
//------------------设置上下文参数
codec_ctx->codec_type = AVMEDIA_TYPE_AUDIO; //设置编码类型，音频编码，还可以设置编码器id codec_id等等
codec_ctx->sample_fmt = AV_SAMPLE_FMT_FLTP; //设置采样格式---------（该字段是被固定了），上面说到，libfdk_aac处理16位，所以设置为16位。所以我们一般是将其他格式进行重采样为16位
codec_ctx->channel_layout = AV_CH_LAYOUT_STEREO; //设置通道布局,双通道
codec_ctx->channels = av_get_channel_layout_nb_channels(codec_ctx->channel_layout); //设置通道数（其实和上面一样）
codec_ctx->sample_rate = 48000; //设置采样率
codec_ctx->profile = FF_PROFILE_AAC_LOW; //设置AAC编码格式，如果设置了这个字段，就不需要设置下面的比特率了
codec_ctx->bit_rate = 128*1024; //设置比特率，128k;对于每个编码方式，都有最低编码码率。AAC_LC:128k AAC HE:64k AAC HE V2:32k
//---------------检查是否支持采样格式信息
if(!check_codec(codec,codec_ctx)){
av_log(NULL,AV_LOG_ERROR,"Codec can`t pass check\n");
*ret = -2;
return codec_ctx;
}
//---------3.打开编码器
if(avcodec_open2(codec_ctx,codec,NULL)<0){
av_log(NULL,AV_LOG_ERROR,"Codec can`t be open\n");
*ret = -2;
return codec_ctx;
}
//输出一下aac每次采样点个数（1024）
av_log(NULL,AV_LOG_INFO,"aac frame_size:%d\n",codec_ctx->frame_size); //frame_size---每帧单个通道的采样点！！！！！！！！！！
*ret = 0;
return codec_ctx;
}
AVFrame* initFrame(AVCodecContext* codec_ctx){
AVFrame* frame = av_frame_alloc(); //分配frame空间，但是数据真正被存放在buffer中
if(!frame){
av_log(NULL,AV_LOG_ERROR,"Failed to create frame\n");
return NULL;
}
//配置3要素，才能为buffer分配空间
frame->nb_samples = codec_ctx->frame_size; //每帧数据中，单通道采样数，和前面重采样配置一样
frame->format = codec_ctx->sample_fmt; //采样大小
frame->channel_layout = codec_ctx->channel_layout; //通道布局
av_frame_get_buffer(frame,0); //第二个参数是对齐
if(!frame->data[0]){
av_log(NULL,AV_LOG_ERROR,"Failed to create frame buffer\n");
return NULL;
}
return frame;
}
void f32le_convert_to_fltp(float* f32le,float* fltp,int nb_samples){
float* fltp_l = fltp; //左通道
float* fltp_r = fltp+nb_samples; //右通道
for(int i=0;i<nb_samples;i++){
fltp_l[i] = f32le[i*2];
fltp_r[i] = f32le[i*2+1];
}
}
static void get_adts_header(AVCodecContext *ctx, uint8_t *adts_header, int aac_length)
{
uint8_t freq_idx = 0; //0: 96000 Hz 3: 48000 Hz 4: 44100 Hz
switch (ctx->sample_rate) {
case 96000: freq_idx = 0; break;
case 88200: freq_idx = 1; break;
case 64000: freq_idx = 2; break;
case 48000: freq_idx = 3; break;
case 44100: freq_idx = 4; break;
case 32000: freq_idx = 5; break;
case 24000: freq_idx = 6; break;
case 22050: freq_idx = 7; break;
case 16000: freq_idx = 8; break;
case 12000: freq_idx = 9; break;
case 11025: freq_idx = 10; break;
case 8000: freq_idx = 11; break;
case 7350: freq_idx = 12; break;
default: freq_idx = 4; break;
}
uint8_t chanCfg = ctx->channels;
uint32_t frame_length = aac_length + 7;
adts_header[0] = 0xFF;
adts_header[1] = 0xF1;
adts_header[2] = ((ctx->profile) << 6) + (freq_idx << 2) + (chanCfg >> 2);
adts_header[3] = (((chanCfg & 3) << 6) + (frame_length >> 11));
adts_header[4] = ((frame_length & 0x7FF) >> 3);
adts_header[5] = (((frame_length & 7) << 5) + 0x1F);
adts_header[6] = 0xFC;
}
static int encode(AVCodecContext* codec_ctx,AVFrame* frame,AVPacket* pkt,FILE* out_fp){
int ret,len;
//--------进行编码
ret = avcodec_send_frame(codec_ctx,frame);
if(ret<0){
av_log(NULL,AV_LOG_ERROR,"Error sending the frame to the encoder\n");
return -1;
}
// 编码和解码都是一样的，都是send 1次，然后receive多次, 直到AVERROR(EAGAIN)或者AVERROR_EOF
while(ret >= 0){
ret = avcodec_receive_packet(codec_ctx,pkt); //获取编码后的数据放入packet中
if(ret<0){
if(ret==AVERROR(EAGAIN)||ret==AVERROR_EOF){ //读完数据
return 0;
}else{ //编码器出错
av_log(NULL,AV_LOG_ERROR,"avcodec_receive_packet error! [%d] %s\n",ret,av_err2str(ret));
return -1;
}
}
uint8_t aac_header[7];
get_adts_header(codec_ctx,aac_header,pkt->size);
len = fwrite(aac_header,1,7,out_fp);
fflush(out_fp);
if(len!=7){
av_log(NULL,AV_LOG_WARNING,"Warning,ADTS header write error!\n");
}
len = fwrite(pkt->data,1,pkt->size,out_fp);
fflush(out_fp);
if(len!=pkt->size){
av_log(NULL,AV_LOG_WARNING,"Warning,newpkt size:%d not equal writen size:%d\n",len,pkt->size);
}else{
av_log(NULL,AV_LOG_INFO,"Success write newpkt to file\n");
}
}
return -1;
}
void enc_audio2(char* in_filename,char* out_filename){
const char* in_pcm_file = in_filename; // 输入PCM文件
const char* out_aac_file = out_filename; // 输出的AAC文件
int ret;
// 2.分配内存
AVCodecContext *codec_ctx = getCodeCtx(&ret);
// 5.打开输入和输出文件
FILE *infile = fopen(in_pcm_file, "rb");
if (!infile) {
fprintf(stderr, "Could not open %s\n", in_pcm_file);
exit(1);
}
FILE *outfile = fopen(out_aac_file, "wb");
if (!outfile) {
fprintf(stderr, "Could not open %s\n", out_aac_file);
exit(1);
}
// 6.分配packet
AVPacket *pkt = av_packet_alloc();
if (!pkt) {
fprintf(stderr, "could not allocate the packet\n");
exit(1);
}
// 7.分配frame
AVFrame *frame = av_frame_alloc();
if (!frame) {
fprintf(stderr, "Could not allocate audio frame\n");
exit(1);
}
/* 每次送多少数据给编码器由：
* (1)frame_size(每帧单个通道的采样点数);
* (2)sample_fmt(采样点格式);
* (3)channel_layout(通道布局情况);
* 3要素决定
*/
frame->nb_samples = codec_ctx->frame_size;
frame->format = codec_ctx->sample_fmt;
frame->channel_layout = codec_ctx->channel_layout;
frame->channels = av_get_channel_layout_nb_channels(frame->channel_layout);
printf("frame nb_samples:%d\n", frame->nb_samples);
printf("frame sample_fmt:%d\n", frame->format);
printf("frame channel_layout:%lu\n\n", frame->channel_layout);
// 8.为frame分配buffer
ret = av_frame_get_buffer(frame, 0);
if (ret < 0) {
fprintf(stderr, "Could not allocate audio data buffers\n");
exit(1);
}
// 9.循环读取数据
// 计算出每一帧的数据 单个采样点的字节 * 通道数目 * 每帧采样点数量
int frame_bytes = av_get_bytes_per_sample(frame->format) \
* frame->channels \
* frame->nb_samples;
printf("frame_bytes %d\n", frame_bytes);
uint8_t *pcm_buf = (uint8_t *)malloc(frame_bytes);
if(!pcm_buf) {
printf("pcm_buf malloc failed\n");
return 1;
}
uint8_t *pcm_temp_buf = (uint8_t *)malloc(frame_bytes);
if(!pcm_temp_buf) {
printf("pcm_temp_buf malloc failed\n");
return 1;
}
int64_t pts = 0;
printf("start enode\n");
for (;;) {
memset(pcm_buf, 0, frame_bytes);
size_t read_bytes = fread(pcm_buf, 1, frame_bytes, infile);
if(read_bytes <= 0) {
printf("read file finish\n");
break;
}
// 10.确保该frame可写, 如果编码器内部保持了内存参考计数，则需要重新拷贝一个备份 目的是新写入的数据和编码器保存的数据不能产生冲突
ret = av_frame_make_writable(frame);
if(ret != 0)
printf("av_frame_make_writable failed, ret = %d\n", ret);
// 11.填充音频帧
if(AV_SAMPLE_FMT_S16 == frame->format) {
// 将读取到的PCM数据填充到frame去，但要注意格式的匹配, 是planar还是packed都要区分清楚
ret = av_samples_fill_arrays(frame->data, frame->linesize,
pcm_buf, frame->channels,
frame->nb_samples, frame->format, 0);
} else {
// 将读取到的PCM数据填充到frame去，但要注意格式的匹配, 是planar还是packed都要区分清楚
// 将本地的f32le packed模式的数据转为float palanar
memset(pcm_temp_buf, 0, frame_bytes);
f32le_convert_to_fltp((float *)pcm_buf, (float *)pcm_temp_buf, frame->nb_samples);
ret = av_samples_fill_arrays(frame->data, frame->linesize,
pcm_temp_buf, frame->channels,
frame->nb_samples, frame->format, 0);
}
// 12.编码
pts += frame->nb_samples;
frame->pts = pts; // 使用采样率作为pts的单位，具体换算成秒 pts*1/采样率
ret = encode(codec_ctx, frame, pkt, outfile);
if(ret < 0) {
printf("encode failed\n");
break;
}
}
// 13.冲刷编码器
encode(codec_ctx, NULL, pkt, outfile);
// 14.关闭文件
fclose(infile);
fclose(outfile);
// 15.释放内存
if(pcm_buf) {
free(pcm_buf);
}
if (pcm_temp_buf) {
free(pcm_temp_buf);
}
av_frame_free(&frame);
av_packet_free(&pkt);
avcodec_free_context(&codec_ctx);
printf("main finish, please enter Enter and exit\n");
return 0;
}
void enc_audio(char* in_filename,char* out_filename){
int ret,len;
int64_t pts = 0;
int frame_bytes;
uint8_t* pcm_buf,* pcm_temp_buf; //存放pcm数据
FILE* in_fp,* out_fp;
AVCodecContext* c = NULL;
AVPacket* pkt = NULL;
AVFrame* frame = NULL;
c = getCodeCtx(&ret);
if(ret<0){
if(ret==-2)
goto __CODECCTX;
return;
}
pkt = av_packet_alloc();
if(!pkt){
av_log(NULL,AV_LOG_ERROR,"Can`t alloc memory for packet\n");
goto __CODECCTX;
}
frame = initFrame(c);
if(!frame){
av_log(NULL,AV_LOG_ERROR,"Can`t alloc memory for frame\n");
goto __PACKET;
}
//-------开始从pcm文件中读取数据
//获取每一帧的数据大小 !!!!
//单个采样点所需字节×通道数×每帧下单通道采样点数量
frame_bytes = av_get_bytes_per_sample(frame->format)*frame->channels*frame->nb_samples;
av_log(NULL,AV_LOG_INFO,"frame_bytes:%d\n",frame_bytes);
pcm_buf = (uint8_t*)malloc(frame_bytes);
if(!pcm_buf){
av_log(NULL,AV_LOG_ERROR,"Can`t alloc memory for pcm_buf\n");
goto __FRAME;
}
pcm_temp_buf = (uint8_t*)malloc(frame_bytes);
if(!pcm_temp_buf){
av_log(NULL,AV_LOG_ERROR,"Can`t alloc memory for pcm_temp_buf\n");
goto __PCMBUF;
}
in_fp = fopen(in_filename,"rb");
if(!in_fp){
av_log(NULL,AV_LOG_ERROR,"Can`t open file:%s\n",in_filename);
goto __PCMTEMPBUF;
}
out_fp = fopen(out_filename,"wb");
if(!out_fp){
av_log(NULL,AV_LOG_ERROR,"Can`t open file:%s\n",out_filename);
goto __INFILE;
}
av_log(NULL,AV_LOG_INFO,"\nStart encode\n");
while(1){
memset(pcm_buf,0,frame_bytes); //初始化空间，开始读取文件
len = fread(pcm_buf,1,frame_bytes,in_fp);
if(len<=0){
av_log(NULL,AV_LOG_WARNING,"read file finsih\n");
break;
}
//----------确保frame可写, 如果编码器内部保持了内存参考计数，则需要重新拷贝一个备份 目的是新写入的数据和编码器保存的数据不能产生冲突
ret = av_frame_make_writable(frame);
if(ret!=0){
av_log(NULL,AV_LOG_WARNING,"av_frame_make_writable failed, ret = %d\n", ret);
}
//----------开始填充音频帧
// 将读取到的PCM数据填充到frame去，但要注意格式的匹配, 是planar还是packed都要区分清楚
/*
AV_SAMPLE_FMT_S16格式，也就是两个声道交替存储，每个样点2个字节。
而FFmpeg默认的AAC编码器不支持这种格式的编码，
只支持AV_SAMPLE_FMT_FLTP，这种格式是按平面存储，样点是float类型，
所谓平面也就是每个声道单独存储，比如左声道存储到data[0]中，右声道存储到data[1]中。
*/
//ffmpeg只能提取packed格式的PCM数据，在编码时候如果输入要为fltp则需要进行转换
//flt格式：ffmpeg -i buweishui.aac -ar 48000 -ac 2 -f f32le 48000_2_f32le.pcm
//s16格式：ffmpeg -i buweishui.aac -ar 48000 -ac 2 -f s16le 48000_2_s16le.pcm
//然而我们设置的frame格式就是AV_SAMPLE_FMT_FLTP格式，所以需要对其进行转换
memset(pcm_temp_buf,0,frame_bytes);
f32le_convert_to_fltp((float *)pcm_buf, (float *)pcm_temp_buf,frame->nb_samples);
ret = av_samples_fill_arrays(frame->data,frame->linesize,
pcm_temp_buf,
frame->channels,frame->nb_samples,frame->format,0); // 将读取到的PCM数据填充到frame去，但要注意格式的匹配, 是planar还是packed都要区分清楚
//----------开始编码
pts += frame->nb_samples;
frame->pts = pts; //重点：对帧的pts进行顺序累加;不能设置随机值;要求编码的帧的pts是连续的值
ret = encode(c,frame,pkt,out_fp);
if(ret<0){
av_log(NULL,AV_LOG_WARNING,"encode error!\n");
break;
}
}
//--------冲刷编码器
encode(c,NULL,pkt,out_fp);
__FINSIH:
fclose(out_fp);
__INFILE:
fclose(in_fp);
__PCMTEMPBUF:
if(pcm_temp_buf)
free(pcm_temp_buf);
__PCMBUF:
if(pcm_buf)
free(pcm_buf);
__FRAME:
av_frame_free(&frame);
__PACKET:
av_packet_free(&pkt);
__CODECCTX:
avcodec_free_context(&c);
}
int main(int argc, char* argv[])
{
av_log_set_level(AV_LOG_DEBUG);
if(argc<=2){
av_log(NULL,AV_LOG_ERROR,"The Count of Parameter must be than 2\n");
return -1;
}
enc_audio(argv[1],argv[2]);
return 0;
}
View Code
gcc 03_ffmpeg_aac_enc.c -o fae -I /usr/local/ffmpeg/include/ -L /usr/local/ffmpeg/lib/ -lavutil -lavformat -lavcodec -lavdevice -lswscale -lswresample
./fae 48000_2_f32le.pcm out3.aac
对于格式转换最好使用swr_convert函数
