ffmpeg av_seek_frame

转载于：https://blog.youkuaiyun.com/xujaiwei/article/details/77651562

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;
}