ffmpeg框架阅读笔记一:读取数据帧函数 int av_read_frame(AVFormatContext *s, AVPacket *pkt)

做音频播放，数据源从完整音频文件变成了网络拉取音频流到缓冲区，实现片段流的播放。分析av_read_frame过程，自定义获取数据源的功能。重点查找如何读入数据源。

首先分析函数av_read_frame。

[cpp] view plain copy
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
{
//包含AVPacket结构体的链表结点
AVPacketList *pktl;
int eof=0;
const int genpts= s->flags & AVFMT_FLAG_GENPTS;

for(;;){      pktl = s->packet_buffer;      if (pktl) {          AVPacket *next_pkt= &pktl->pkt;          if(genpts && next_pkt->dts != AV_NOPTS_VALUE){              int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;              while(pktl && next_pkt->pts == AV_NOPTS_VALUE){                  if(   pktl->pkt.stream_index == next_pkt->stream_index                     && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))                     && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame                      next_pkt->pts= pktl->pkt.dts;                  }                  pktl= pktl->next;              }              pktl = s->packet_buffer;          }          if(   next_pkt->pts != AV_NOPTS_VALUE             || next_pkt->dts == AV_NOPTS_VALUE             || !genpts || eof){              /* read packet from packet buffer, if there is data */              *pkt = *next_pkt;              s->packet_buffer = pktl->next;              av_free(pktl);              return 0;          }      }      if(genpts){          //这里读取数据           int ret= av_read_frame_internal(s, pkt);          if(ret<0){              if(pktl && ret != AVERROR(EAGAIN)){                  eof=1;                  continue;              }else                  return ret;          }          if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,                                         &s->packet_buffer_end)) < 0)              return AVERROR(ENOMEM);      }else{          assert(!s->packet_buffer);          return av_read_frame_internal(s, pkt);      }  }  

}
上面代码找到av_read_frame_internal函数。其他代码不加分析。看的也不是很懂。接下来是av_read_frame_internal。

[cpp] view plain copy
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
{
AVStream *st;
int len, ret, i;
//初始化pkt的各个成员
av_init_packet(pkt);

for(;;) {      /* select current input stream component */      //获得当前输入流      st = s->cur_st;      if (st) {          if (!st->need_parsing || !st->parser) {              /* no parsing needed: we just output the packet as is */              /* raw data support */              *pkt = st->cur_pkt;              st->cur_pkt.data= NULL;              st->cur_pkt.side_data_elems = 0;              st->cur_pkt.side_data = NULL;              compute_pkt_fields(s, st, NULL, pkt);              s->cur_st = NULL;              if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&                  (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {                  ff_reduce_index(s, st->index);                  av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);              }              break;          } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {              len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,                                     st->cur_ptr, st->cur_len,                                     st->cur_pkt.pts, st->cur_pkt.dts,                                     st->cur_pkt.pos);              st->cur_pkt.pts = AV_NOPTS_VALUE;              st->cur_pkt.dts = AV_NOPTS_VALUE;              /* increment read pointer */              st->cur_ptr += len;              st->cur_len -= len;              /* return packet if any */              if (pkt->size) {              got_packet:                  pkt->duration = 0;                  pkt->stream_index = st->index;                  pkt->pts = st->parser->pts;                  pkt->dts = st->parser->dts;                  pkt->pos = st->parser->pos;                  if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){                      s->cur_st = NULL;                      pkt->destruct= st->cur_pkt.destruct;                      st->cur_pkt.destruct= NULL;                      st->cur_pkt.data    = NULL;                      assert(st->cur_len == 0);                  }else{                  pkt->destruct = NULL;                  }                  compute_pkt_fields(s, st, st->parser, pkt);                  if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){                      int64_t pos= (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->pos : st->parser->frame_offset;                      ff_reduce_index(s, st->index);                      av_add_index_entry(st, pos, pkt->dts,                                         0, 0, AVINDEX_KEYFRAME);                  }                  break;              }          } else {              /* free packet */              av_free_packet(&st->cur_pkt);              s->cur_st = NULL;          }      } else { //当前输入流内容不存在 去数据源读取          AVPacket cur_pkt;          /* read next packet */          //读下一个数据包          ret = av_read_packet(s, &cur_pkt);          if (ret < 0) {              if (ret == AVERROR(EAGAIN))                  return ret;              /* return the last frames, if any */              for(i = 0; i < s->nb_streams; i++) {                  st = s->streams[i];                  if (st->parser && st->need_parsing) {                      av_parser_parse2(st->parser, st->codec,                                      &pkt->data, &pkt->size,                                      NULL, 0,                                      AV_NOPTS_VALUE, AV_NOPTS_VALUE,                                      AV_NOPTS_VALUE);                      if (pkt->size)                          goto got_packet;                  }              }              /* no more packets: really terminate parsing */              return ret;          }          st = s->streams[cur_pkt.stream_index];          st->cur_pkt= cur_pkt;          if(st->cur_pkt.pts != AV_NOPTS_VALUE &&             st->cur_pkt.dts != AV_NOPTS_VALUE &&             st->cur_pkt.pts < st->cur_pkt.dts){              av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",                  st->cur_pkt.stream_index,                  st->cur_pkt.pts,                  st->cur_pkt.dts,                  st->cur_pkt.size);  

// av_free_packet(&st->cur_pkt);
// return -1;
}

        if(s->debug & FF_FDEBUG_TS)              av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",                  st->cur_pkt.stream_index,                  st->cur_pkt.pts,                  st->cur_pkt.dts,                  st->cur_pkt.size,                  st->cur_pkt.duration,                  st->cur_pkt.flags);          s->cur_st = st;          st->cur_ptr = st->cur_pkt.data;          st->cur_len = st->cur_pkt.size;          if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {              st->parser = av_parser_init(st->codec->codec_id);              if (!st->parser) {                  /* no parser available: just output the raw packets */                  st->need_parsing = AVSTREAM_PARSE_NONE;              }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){                  st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;              }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){                  st->parser->flags |= PARSER_FLAG_ONCE;              }          }      }  }  if(s->debug & FF_FDEBUG_TS)      av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",          pkt->stream_index,          pkt->pts,          pkt->dts,          pkt->size,          pkt->duration,          pkt->flags);  return 0;  

}

找到函数int av_read_packet(AVFormatContext *s, AVPacket *pkt)
[cpp] view plain copy
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
{
int ret, i;
AVStream *st;

for(;;){      AVPacketList *pktl = s->raw_packet_buffer;     //格式上下文存在原生的包数据      if (pktl) {          *pkt = pktl->pkt;          if(s->streams[pkt->stream_index]->request_probe <= 0){              s->raw_packet_buffer = pktl->next;              s->raw_packet_buffer_remaining_size += pkt->size;              av_free(pktl);              return 0;          }      }      av_init_packet(pkt);      //原生包数据不存在 通过AVInputFormat的read_packet函数指针成员来调用函数获取数据源      //AVInputFormat是不同格式数据的操作函数集合。在注册函数中初始化所有格式的该结构体变量。      ret= s->iformat->read_packet(s, pkt);      if (ret < 0) {          if (!pktl || ret == AVERROR(EAGAIN))              return ret;          for (i = 0; i < s->nb_streams; i++)              if(s->streams[i]->request_probe > 0)                  s->streams[i]->request_probe = -1;          continue;      }      if(!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))          av_packet_merge_side_data(pkt);      st= s->streams[pkt->stream_index];      switch(st->codec->codec_type){      case AVMEDIA_TYPE_VIDEO:          if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;          break;      case AVMEDIA_TYPE_AUDIO:          if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;          break;      case AVMEDIA_TYPE_SUBTITLE:          if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;          break;      }      if(!pktl && st->request_probe <= 0)          return ret;      add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);      s->raw_packet_buffer_remaining_size -= pkt->size;      if(st->request_probe>0){          AVProbeData *pd = &st->probe_data;          int end;          av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);          --st->probe_packets;          pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);          memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);          pd->buf_size += pkt->size;          memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);          end=    s->raw_packet_buffer_remaining_size <= 0               || st->probe_packets<=0;          if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){              int score= set_codec_from_probe_data(s, st, pd);              if(    (st->codec->codec_id != CODEC_ID_NONE && score > AVPROBE_SCORE_MAX/4)                  || end){                  pd->buf_size=0;                  av_freep(&pd->buf);                  st->request_probe= -1;                  if(st->codec->codec_id != CODEC_ID_NONE){                  av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);                  }else                      av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);              }          }      }  }  

}

分析AVInpuFormat结构体初始化过程
[cpp] view plain copy
AVInputFormat ff_flv_demuxer = {
“flv”,
NULL_IF_CONFIG_SMALL(“FLV format”),
sizeof(FLVContext),
flv_probe,
flv_read_header,
//读数据包的函数指针
flv_read_packet,
.read_seek = flv_read_seek,

if 0

.read_seek2 = flv_read_seek2,  

endif

.extensions = "flv",  .value = CODEC_ID_FLV1,  

};

分析flv_read_packet
[cpp] view plain copy
static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
{
FLVContext *flv = s->priv_data;
int ret, i, type, size, flags, is_audio;
int64_t next, pos;
int64_t dts, pts = AV_NOPTS_VALUE;
AVStream *st = NULL;

for(;;avio_skip(s->pb, 4)){ /* pkt size is repeated at end. skip it */
pos = avio_tell(s->pb);
type = avio_r8(s->pb);
size = avio_rb24(s->pb);
dts = avio_rb24(s->pb);
dts |= avio_r8(s->pb) << 24;
av_dlog(s, “type:%d, size:%d, dts:%”PRId64”\n”, type, size, dts);
if (url_feof(s->pb))
return AVERROR_EOF;
avio_skip(s->pb, 3); /* stream id, always 0 */
flags = 0;

if(size == 0)      continue;  next= size + avio_tell(s->pb);  if (type == FLV_TAG_TYPE_AUDIO) {      is_audio=1;      flags = avio_r8(s->pb);      size--;  } else if (type == FLV_TAG_TYPE_VIDEO) {      is_audio=0;      flags = avio_r8(s->pb);      size--;      if ((flags & 0xf0) == 0x50) /* video info / command frame */          goto skip;  } else {      if (type == FLV_TAG_TYPE_META && size > 13+1+4)          flv_read_metabody(s, next);      else /* skip packet */          av_log(s, AV_LOG_DEBUG, "skipping flv packet: type %d, size %d, flags %d\n", type, size, flags);  skip:      avio_seek(s->pb, next, SEEK_SET);      continue;  }  /* skip empty data packets */  if (!size)      continue;  /* now find stream */  for(i=0;i<s->nb_streams;i++) {      st = s->streams[i];      if (st->id == is_audio)          break;  }  if(i == s->nb_streams){      av_log(s, AV_LOG_ERROR, "invalid stream\n");      st= create_stream(s, is_audio);      s->ctx_flags &= ~AVFMTCTX_NOHEADER;  }  av_dlog(s, "%d %X %d \n", is_audio, flags, st->discard);  if(  (st->discard >= AVDISCARD_NONKEY && !((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY ||         is_audio))     ||(st->discard >= AVDISCARD_BIDIR  &&  ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_DISP_INTER && !is_audio))     || st->discard >= AVDISCARD_ALL     ){      avio_seek(s->pb, next, SEEK_SET);      continue;  }  if ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY)      av_add_index_entry(st, pos, dts, size, 0, AVINDEX_KEYFRAME);  break;  

}

// if not streamed and no duration from metadata then seek to end to find the duration from the timestamps  if(s->pb->seekable && (!s->duration || s->duration==AV_NOPTS_VALUE)){      int size;      const int64_t pos= avio_tell(s->pb);      const int64_t fsize= avio_size(s->pb);      avio_seek(s->pb, fsize-4, SEEK_SET);      size= avio_rb32(s->pb);      avio_seek(s->pb, fsize-3-size, SEEK_SET);      if(size == avio_rb24(s->pb) + 11){          uint32_t ts = avio_rb24(s->pb);          ts |= avio_r8(s->pb) << 24;          s->duration = ts * (int64_t)AV_TIME_BASE / 1000;      }      avio_seek(s->pb, pos, SEEK_SET);  }  if(is_audio){      if(!st->codec->channels || !st->codec->sample_rate || !st->codec->bits_per_coded_sample) {          st->codec->channels = (flags & FLV_AUDIO_CHANNEL_MASK) == FLV_STEREO ? 2 : 1;          st->codec->sample_rate = (44100 << ((flags & FLV_AUDIO_SAMPLERATE_MASK) >> FLV_AUDIO_SAMPLERATE_OFFSET) >> 3);          st->codec->bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8;      }      if(!st->codec->codec_id){          flv_set_audio_codec(s, st, flags & FLV_AUDIO_CODECID_MASK);      }  }else{      size -= flv_set_video_codec(s, st, flags & FLV_VIDEO_CODECID_MASK);  }  if (st->codec->codec_id == CODEC_ID_AAC ||      st->codec->codec_id == CODEC_ID_H264) {      int type = avio_r8(s->pb);      size--;      if (st->codec->codec_id == CODEC_ID_H264) {          int32_t cts = (avio_rb24(s->pb)+0xff800000)^0xff800000; // sign extension          pts = dts + cts;          if (cts < 0) { // dts are wrong              flv->wrong_dts = 1;              av_log(s, AV_LOG_WARNING, "negative cts, previous timestamps might be wrong\n");          }          if (flv->wrong_dts)              dts = AV_NOPTS_VALUE;      }      if (type == 0) {          if ((ret = flv_get_extradata(s, st, size)) < 0)              return ret;          if (st->codec->codec_id == CODEC_ID_AAC) {              MPEG4AudioConfig cfg;              ff_mpeg4audio_get_config(&cfg, st->codec->extradata,                                       st->codec->extradata_size);              st->codec->channels = cfg.channels;              if (cfg.ext_sample_rate)                  st->codec->sample_rate = cfg.ext_sample_rate;              else                  st->codec->sample_rate = cfg.sample_rate;              av_dlog(s, "mp4a config channels %d sample rate %d\n",                      st->codec->channels, st->codec->sample_rate);          }          ret = AVERROR(EAGAIN);          goto leave;      }  }  /* skip empty data packets */  if (!size) {      ret = AVERROR(EAGAIN);      goto leave;  }  

//从AVIOContext读取数据
ret= av_get_packet(s->pb, pkt, size);
if (ret < 0) {
return AVERROR(EIO);
}
/* note: we need to modify the packet size here to handle the last
packet */
pkt->size = ret;
pkt->dts = dts;
pkt->pts = pts == AV_NOPTS_VALUE ? dts : pts;
pkt->stream_index = st->index;

if (is_audio || ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY))      pkt->flags |= AV_PKT_FLAG_KEY;  

leave:
avio_skip(s->pb, 4);
return ret;
}

分析av_get_packet()
[cpp] view plain copy
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
{
//pkt分配空间并初始化
int ret= av_new_packet(pkt, size);

if(ret<0)      return ret;  pkt->pos= avio_tell(s);  //从io上下文读取数据  ret= avio_read(s, pkt->data, size);  if(ret<=0)      av_free_packet(pkt);  else      av_shrink_packet(pkt, ret);  return ret;  

}

分析avio_read
[cpp] view plain copy
int avio_read(AVIOContext *s, unsigned char *buf, int size)
{
int len, size1;

size1 = size;  while (size > 0) {      len = s->buf_end - s->buf_ptr;      if (len > size)          len = size;      if (len == 0) {          if(size > s->buffer_size && !s->update_checksum){              if(s->read_packet)                  //调用AVIOContext的成员  read_packet函数指针                  len = s->read_packet(s->opaque, buf, size);              if (len <= 0) {                  /* do not modify buffer if EOF reached so that a seek back can                 be done without rereading data */                  s->eof_reached = 1;                  if(len<0)                      s->error= len;                  break;              } else {                  s->pos += len;                  size -= len;                  buf += len;                  s->buf_ptr = s->buffer;                  s->buf_end = s->buffer/* + len*/;              }          }else{              fill_buffer(s);              len = s->buf_end - s->buf_ptr;              if (len == 0)                  break;          }      } else {          memcpy(buf, s->buf_ptr, len);          buf += len;          s->buf_ptr += len;          size -= len;      }  }  if (size1 == size) {      if (s->error)      return s->error;      if (url_feof(s))   return AVERROR_EOF;  }  return size1 - size;  

}

AVIOContext结构体需要由avformat_open_input来进行初始化。对于该函数打开媒体文件的分析，见收藏的一篇文章。目前根据需要要进行自定义的AVIOContext结构体变量的初始化。贴出ffmpeg初始化其的代码，参考进行自定义初始化。
[cpp] view plain copy
int ffio_fdopen(AVIOContext **s, URLContext *h)
{
uint8_t *buffer;
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);  *s = av_mallocz(sizeof(AVIOContext));  if(!*s) {      av_free(buffer);      return AVERROR(ENOMEM);  }  //初始化AVIOContext  if (ffio_init_context(*s, buffer, buffer_size,                    h->flags & AVIO_FLAG_WRITE, h,                    (void*)ffurl_read, (void*)ffurl_write, (void*)ffurl_seek) < 0) {      av_free(buffer);      av_freep(s);      return AVERROR(EIO);  }  

if FF_API_OLD_AVIO

(*s)->is_streamed = h->is_streamed;  

endif

(*s)->seekable = h->is_streamed ? 0 : AVIO_SEEKABLE_NORMAL;  (*s)->max_packet_size = max_packet_size;  if(h->prot) {      (*s)->read_pause = (int (*)(void *, int))h->prot->url_read_pause;      (*s)->read_seek  = (int64_t (*)(void *, int, int64_t, int))h->prot->url_read_seek;  }  return 0;  

}

int ffio_init_context(AVIOContext *s,
unsigned char *buffer,
int buffer_size,
int write_flag,
void *opaque,
int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
int64_t (*seek)(void *opaque, int64_t offset, int whence))
{
s->buffer = buffer;
s->buffer_size = buffer_size;
s->buf_ptr = buffer;
s->opaque = opaque;
url_resetbuf(s, write_flag ? AVIO_FLAG_WRITE : AVIO_FLAG_READ);
s->write_packet = write_packet;
s->read_packet = read_packet;
s->seek = seek;
s->pos = 0;
s->must_flush = 0;
s->eof_reached = 0;
s->error = 0;

if FF_API_OLD_AVIO

s->is_streamed = 0;  

endif

s->seekable = AVIO_SEEKABLE_NORMAL;  s->max_packet_size = 0;  s->update_checksum= NULL;  if(!read_packet && !write_flag){      s->pos = buffer_size;      s->buf_end = s->buffer + buffer_size;  }  s->read_pause = NULL;  s->read_seek  = NULL;  return 0;  

}
经过上述分析，需要根据项目需要自定义AVIOContext，设置数据源，设置各类回调函数。
网上找到一段探测网络流格式的方法，实现相似的功能。没有经过测试，先贴出来，后面进行测试。

[cpp] view plain copy

include “utils.h”

include

include

include

define BUF_SIZE 4096*500

int main(int argc, char** argv) {

init_queue(&recvqueue, 1024*500);

udpParam.argv = argv;
udpParam.queue = &recvqueue;
uint8_t *buf = av_mallocz(sizeof(uint8_t)*BUF_SIZE);

//UDP接收线程
pthread_t udp_recv_thread;
pthread_create(&udp_recv_thread, NULL, udp_ts_recv, &udpParam);
pthread_detach(udp_recv_thread);

av_register_all();

AVCodec *pVideoCodec, *pAudioCodec;
AVCodecContext *pVideoCodecCtx = NULL;
AVCodecContext *pAudioCodecCtx = NULL;
AVIOContext * pb = NULL;
AVInputFormat *piFmt = NULL;
AVFormatContext *pFmt = NULL;

//step1:申请一个AVIOContext
pb = avio_alloc_context(buf, BUF_SIZE, 0, NULL, read_data, NULL, NULL);
if (!pb) {
fprintf(stderr, “avio alloc failed!\n”);
return -1;
}
//step2:探测流格式
if (av_probe_input_buffer(pb, &piFmt, “”, NULL, 0, 0) < 0) {
fprintf(stderr, “probe failed!\n”);
return -1;
} else {
fprintf(stdout, “probe success!\n”);
fprintf(stdout, “format: %s[%s]\n”, piFmt->name, piFmt->long_name);
}

pFmt = avformat_alloc_context();
pFmt->pb = pb; //step3:这一步很关键
//step4:打开流
if (avformat_open_input(&pFmt, “”, piFmt, NULL) < 0) {
fprintf(stderr, “avformat open failed.\n”);
return -1;
} else {
fprintf(stdout, “open stream success!\n”);
}
//以下就和文件处理一致了
if (av_find_stream_info(pFmt) < 0) {
fprintf(stderr, “could not fine stream.\n”);
return -1;
}

av_dump_format(pFmt, 0, “”, 0);

int videoindex = -1;
int audioindex = -1;
for (int i = 0; i < pFmt->nb_streams; i++) {
if ( (pFmt->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
(videoindex < 0) ) {
videoindex = i;
}
if ( (pFmt->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO) &&
(audioindex < 0) ) {
audioindex = i;
}
}

if (videoindex < 0 || audioindex < 0) {
fprintf(stderr, “videoindex=%d, audioindex=%d\n”, videoindex, audioindex);
return -1;
}

AVStream *pVst,*pAst;
pVst = pFmt->streams[videoindex];
pAst = pFmt->streams[audioindex];

pVideoCodecCtx = pVst->codec;
pAudioCodecCtx = pAst->codec;

pVideoCodec = avcodec_find_decoder(pVideoCodecCtx->codec_id);
if (!pVideoCodec) {
fprintf(stderr, “could not find video decoder!\n”);
return -1;
}
if (avcodec_open(pVideoCodecCtx, pVideoCodec) < 0) {
fprintf(stderr, “could not open video codec!\n”);
return -1;
}

pAudioCodec = avcodec_find_decoder(pAudioCodecCtx->codec_id);
if (!pAudioCodec) {
fprintf(stderr, “could not find audio decoder!\n”);
return -1;
}
if (avcodec_open(pAudioCodecCtx, pAudioCodec) < 0) {
fprintf(stderr, “could not open audio codec!\n”);
return -1;
}

int got_picture;
uint8_t samples[AVCODEC_MAX_AUDIO_FRAME_SIZE*3/2];
AVFrame *pframe = avcodec_alloc_frame();
AVPacket pkt;
av_init_packet(&pkt);

while(1) {
if (av_read_frame(pFmt, &pkt) >= 0) {

if (pkt.stream_index == videoindex) {
fprintf(stdout, “pkt.size=%d,pkt.pts=%lld, pkt.data=0x%x.”, pkt.size, pkt.pts,(unsigned int)pkt.data);
avcodec_decode_video2(pVideoCodecCtx, pframe, &got_picture, &pkt);
if (got_picture) {
fprintf(stdout, “decode one video frame!\n”);
}
}else if (pkt.stream_index == audioindex) {
int frame_size = AVCODEC_MAX_AUDIO_FRAME_SIZE*3/2;
if (avcodec_decode_audio3(pAudioCodecCtx, (int16_t *)samples, &frame_size, &pkt) >= 0) {
fprintf(stdout, “decode one audio frame!\n”);
}
}
av_free_packet(&pkt);
}
}

av_free(buf);
av_free(pframe);
free_queue(&recvqueue);
return 0;
}
这段代码作者为windragon0419，在此表示感谢。
后面经过测试以后，记录下解决过程。