av_seek_frame使用时需要使用四个参数
av_seek_frame(fmt_ctx, -1 , 20 * AV_TIME_BASE, AVSEEK_FLAG_ANY);
参数一: fmt_ctx为容器内容;
参数二: 流索引, stream_index
参数三: 将要定位处的时间戳
参数四: seek功能flag
容器即AVFormatContext, 其中包含了一些视频标准格式中对应的封装信息，例如stream个数，stream类型，AVCodec，字幕信息等；
stream_index，容器中包含了stream，有音频stream，视频stream，3D的电影有多个视频stream，subtitle stream等stream信息。
那么如果需要seek到对应的时间戳处需要考虑几个问题：
1. 得到AVFormatContext信息
2. 需要得到stream_index信息
3. 需要设定将要定位的时间戳信息
4. seek功能需要根据需求设置
结合上述四点，可以实现代码步骤如下：
av_register_all();
avformat_open_input
avformat_find_stream_info
open_codec_context
av_seek_frame
以上为简单的seek步骤，当然细节部分，还要有一些操作，例如avpackets相关的操作等
#include<libavutil/imgutils.h>//图片相关信息
#include<libavutil/samplefmt.h>//算缓冲区的
#include<libavutil/timestamp.h>//时间相关 主要用于调试/记录的
#include<libswscale/swscale.h>//视频像素数据格式转换
#include<libavformat/avformat.h>//封装格式处理
static AVFormatContext *fmt_ctx=NULL;
static AVCodecContext *video_dec_ctx=NULL,*audio_dec_ctx;
static AVStream *video_stream=NULL,*audio_stream=NULL;
static const char *src_filename=NULL;
static const char *video_dst_filename=NULL;
static const char *audio_dst_filename=NULL;
static FILE *video_dst_file=NULL;
static FILE *audio_dst_file=NULL;
static uin8_t *video_dst_data[4]=NULL;
static int video_dst_linesize[4];
static int video_dst_bufsize;
static int video_stream_idx=-1,audio_stream_idx=-1;
static AVPacket pkt;
static AVFrame *frame=NULL;
static int video_frame_count=0;
static int audio_frame_count=0;
static int open_codec_context(int *stream_idx,AVFormatContext *fmt_ctx,enum AVMediaType type)
{
int ret;
AVStream *st;
AVCodecContext *dec_ctx=NULL;
AVCodec *dec=NULL;
ret=av_find_best_stream(fmt_ctx,type,-1,-1,NULL,0);//找到文件的最佳流
if(ret<0){
fprintf(stderr,"Could not find %s stream in input file %s\n",
av_get_media_type_string(type),src_filename);//返回描述枚举的字符串
return ret;
}else{
*stream_idx=ret;
st=fmt_ctx->streams[*stream_idx];
dec_ctx=st->codec;//赋给全局变量
dec=avcodec_find_decoder(dec_ctx->codec_id);//找出解码器
if(!dec){
fprintf(stderr,"Failed to find %s codec\n",av_get_media_type_string(type));
return ret;
}
if((ret=avcodec_open2(dec_ctx,dec,NULL))<0){
fprintf(stderr,"Failed to open %s codec\n",av_get_media_type_string(type));
return ret;
}
}
return 0;
}
static int decode_packet(int *got_frame,int cached)
{
int ret=0;
int decode=pkt.size;
uint8_t *dst_data[4];
int dst_linesize[4];
if(pkt.stream_index==video_stream_idx){
//解码一帧
ret=avcodec_decode_video2(video_dec_ctx,frame,got_frame,&pkt);
if(ret<0){
fprintf(stderr,"Error decoding video frame\n");
return ret;
}
if(*got_frame){
printf("video_frame%s n:%d coded_n:%d pts :%s\n",cached?"(cached)":"",video_frame_count++,frame->codec_picture_number,av_ts2timestr(frame->pts,&video_dec_ctx->time_base));//图像编号以比特流顺序
av_image_copy(video_dst_data, video_dst_linesize, (const uint8_t **)(frame->data), frame->linesize, video_dec_ctx->pix_fmt, video_dec_ctx->width, video_dec_ctx->height);
/* write to rawvideo file */
fwrite(video_dst_data[0], 1, video_dst_bufsize, video_dst_file);
}
}else if(pkt.stream_index==audio_stream_idx){
ret = avcodec_decode_audio4(audio_dec_ctx, frame, got_frame, &pkt);
if (ret < 0) {
fprintf(stderr, "Error decoding audio frame\n");
return ret;
}
/* Some audio decoders decode only part of the packet, and have to be * called again with the remainder of the packet data.
* Sample: fate-suite/lossless-audio/luckynight-partial.shn
* * Also, some decoders might over-read the packet. */
decoded = FFMIN(ret, pkt.size);
if (*got_frame) {
size_t unpadded_linesize = frame->nb_samples * av_get_bytes_per_sample(frame->format);
printf("audio_frame%s n:%d nb_samples:%d pts:%s\n", cached ? "(cached)" : "", audio_frame_count++, frame->nb_samples,
av_ts2timestr(frame->pts, &audio_dec_ctx->time_base));
/* Write the raw audio data samples of the first plane. This works
* fine for packed formats (e.g. AV_SAMPLE_FMT_S16). However,
* most audio decoders output planar audio, which uses a separate * plane of audio samples for each channel (e.g. AV_SAMPLE_FMT_S16P).
* In other words, this code will write only the first audio channel
* in these cases.
* You should use libswresample or libavfilter to convert the fram * to packed data. */
fwrite(frame->extended_data[0], 1, unpadded_linesize, audio_dst_fil
}
}
return decoded;
}
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;
}
int main(int argc,char **argv)
{
int ret=0,got_frame;
if(argc!=4){
exit(1);
}
src_filenname=argv[1];
video_dst_filename=argv[2];
audio_dst_filename=argv[3];
av_register_all();
if(avformat_open_input(&fmt_ctx,src_filename,NULL,NULL)<0){
fprintf(stderr,"Could not open source file %s\n",src_filename);
exit(1);
}
if(avforamat_find_stream_info(fmt_ctx,NULL)<0){
fprintf(stderr,"Could not find stream information\n");
exit(1);
}
if(open_codec_context(&video_stream_idx,fmt_ctx,AVMEDIA_TYPE_VIDEO)>=0){
video_stream=fmt_ctx->streams[video_stream_idx];
video_dec_ctx=video_stream->codec;
video_dst_file=fopen(video_dst_filename,"wb");
if(!video_dst_file){
fprintf(stderr,"Could not open destination file %s\n",video_dst_filename);
ret=1;
goto end;
}
//分配的图像缓冲区 ret=av_image_alloc(video_dst_data,video_dst_linesize,video_dec_ctx->width,video_dec_ctx->height,video_dec_ctx->pix_fmt,1);
if(ret<0){
fprintf(stderr,"Could not allocate raw video buffer\n");
goto end;
}
video_dst_bufsize=ret;//返回的是图像缓冲区所需的字节大小
}
if (open_codec_context(&audio_stream_idx, fmt_ctx, AVMEDIA_TYPE_AUDIO) >= 0) {
audio_stream = fmt_ctx->streams[audio_stream_idx];
audio_dec_ctx = audio_stream->codec;
audio_dst_file = fopen(audio_dst_filename, "wb");
if (!audio_dst_file) {
fprintf(stderr, "Could not open destination file %s\n", video_dst_filename);
ret = 1;
goto end;
}
}
/* dump input information to stderr */
av_dump_format(fmt_ctx, 0, src_filename, 0);
if(!audio_stream&&!video_stream){
fprintf(stderr,"Could not find audio or video stream in the input ,aborting\n");
av_init_packet(&pkt);//初始化压缩的一帧
pkt.data=NULL;
pkt.size=0;
if(video_stream)
printf("Demuxing video from file %s into %s \n",src_filename,video_dst_filename);
if(audio_stream)
//这个最关键了 如果第二个参数是-1 则选择默认流 并将时间戳从AV_TIME_BASE单位自动转换成流特定的time_base;
av_seek_frame(fmt_ctx,-1,20*AV_TIME_BASE,AVSEEK_FLAG_ANY);
while(av_read_frame(fmt_ctx,&pkt)>=0){
AVPacket orig_pkt=pkt;
do{
ret=decode_packet(&got_frame,0);
if(ret<0)
break;
pkt.data+=ret;
pkt.size-=ret;
}while(pkt.size>0)
av_free_packet(&orig_pkt);
}
pkt.data=NULL;
pkt.size=0;
do{
decode_packet(&got_frame,1);
}while(got_frame);
printf("Demucing succeeded\n");
if (video_stream) {
printf("Play the output video file with the command:\n"
"ffplay -f rawvideo -pix_fmt %s -video_size %dx%d %s\n",
av_get_pix_fmt_name(video_dec_ctx->pix_fmt), video_dec_ctx->width, video_dec_ctx->height,video_dst_filename);
}
if (audio_stream) {
enum AVSampleFormat sfmt = audio_dec_ctx->sample_fmt;
int n_channels = audio_dec_ctx->channels;
const char *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 = 1;
}
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, audio_dec_ctx->sample_rate,audio_dst_filename);
}
end:
if (video_dec_ctx)
avcodec_close(video_dec_ctx);
if (audio_dec_ctx)
avcodec_close(audio_dec_ctx);
avformat_close_input(&fmt_ctx);
if (video_dst_file)
fclose(video_dst_file);
if (audio_dst_file)
fclose(audio_dst_file);
av_free(frame);
av_free(video_dst_data[0]);
return ret < 0;
}