update ffmpeg

zhangmeng

2019-09-20 be9c1d1f659b0ff31f656424c478e83a4f7c53b5

 csrc/ffmpeg/format/FormatIn.cpp

@@ -29,11 +29,13 @@
   :ctx_(NULL)
   ,dec_ctx_(NULL)
   ,vs_idx_(-1)
   ,as_idx_(-1)
   ,hw_accl_(hw)
   ,io_ctx_(NULL)
   ,read_io_buff_(NULL)
   ,read_io_buff_size_(32768)
   ,handle_gb28181(NULL)
   ,fps_(25.0)
   {}

   FormatIn::~FormatIn()
@@ -100,7 +102,7 @@
      handle_gb28181 = new GB28181API;
      handle_gb28181->addCamera(fn);

        int ret = openWithCustomIO((void *)&handle_gb28181, handle_gb28181->readData, options);
        int ret = openWithCustomIO(handle_gb28181, handle_gb28181->readData, options);
        if(ret < 0){
            logIt("do openWithCustomIO failed:%d",ret);
        }
@@ -136,15 +138,25 @@
         return false;
      }

      logIt("there are %d stream", ctx_->nb_streams);

      for (int i = 0; i < ctx_->nb_streams; ++i)
      {
         switch(ctx_->streams[i]->codecpar->codec_type){
            case AVMEDIA_TYPE_VIDEO:
               vs_idx_ = i;
               break;
         auto type = ctx_->streams[i]->codecpar->codec_type;
         if (type == AVMEDIA_TYPE_VIDEO){
            vs_idx_ = i;

            default:
               break;
            auto in = ctx_->streams[i];
            if(in->r_frame_rate.num >=1 && in->r_frame_rate.den >= 1){
                   fps_ = av_q2d(in->r_frame_rate);
               }else if(in->avg_frame_rate.num >=1 && in->avg_frame_rate.den >= 1){
                   fps_ = av_q2d(in->avg_frame_rate);
               }
            logIt("video stream time base %d : %d", in->time_base.num, in->time_base.den);
         }
         if (type == AVMEDIA_TYPE_AUDIO){
            as_idx_ = i;
            logIt("audio stream time base %d : %d", ctx_->streams[i]->time_base.num, ctx_->streams[i]->time_base.den);
         }
      }
      return true;
@@ -250,43 +262,52 @@
      return true;
   }

   AVStream *FormatIn::getStream(int type){
      return ctx_->streams[vs_idx_];
   AVStream *FormatIn::getStream(int type/*=-1*/){
      if (type == -1){
         return ctx_->streams[vs_idx_];
      }

      if (type == ctx_->streams[vs_idx_]->codecpar->codec_type)
         return ctx_->streams[vs_idx_];
      if (type == ctx_->streams[as_idx_]->codecpar->codec_type)
         return ctx_->streams[as_idx_];

      return NULL;
   }

   AVCodecContext *FormatIn::getCodecContext(int type){
      return dec_ctx_;
   }
   
   bool FormatIn::readPacket(AVPacket &pkt_out, int stream_index){

      bool founded = false;
      while (!founded){
         const int ret = av_read_frame(ctx_, &pkt_out);
         if(ret < 0){
            // logIt("read frame from %s failed:%s",
            //       ctx_->filename,getAVErrorDesc(ret).c_str()); 
	
            return false;
         }
         if(pkt_out.stream_index == stream_index){
            founded = true;
         }else{
            av_free_packet(&pkt_out);
            av_init_packet(&pkt_out);
            pkt_out.data = NULL;
            pkt_out.size = 0;
         }
   bool FormatIn::isVideoPkt(AVPacket &pkt){
      if (pkt.stream_index == vs_idx_){
         return true;
      }
      pkt_out.stream_index = 0;
      return false;
   }

   bool FormatIn::isAudioPkt(AVPacket &pkt){
      if (pkt.stream_index == as_idx_){
         return true;
      }
      return false;
   }

   bool FormatIn::readPacket(AVPacket &pkt_out){

      const int ret = av_read_frame(ctx_, &pkt_out);
      if(ret < 0){
         return false;
      }
		
      return true;

   }

   bool FormatIn::readPacket(std::shared_ptr<CodedData> &data, int stream_index){
   bool FormatIn::readPacket(std::shared_ptr<CodedData> &data){

      AVPacket &pkt(data->getAVPacket());
      return readPacket(pkt, getStream()->index);
      return readPacket(pkt);
   }

   int FormatIn::decode(AVFrame* &frame, AVPacket &pkt){