如何采用ffmpeg自己构造流写mp4或者 flv文件

蔚落 2022-09-15 11:48 290阅读 0赞

ffmpeg写视频文件的时候，关于时间基的设置，这个是ffmpeg内部设置的，我们在创建流的时候是无法设置，一般`avformat_write_header(m_outfmtContext, &dict);`后时间基就会覆盖掉以前设置的时间基，替换为ffmpeg默认的时间基准，一般flv是1k，mp4是16k。  
我们在v\_interleaved\_write\_frame(m\_outfmtContext, &pkt);之前要转换pts的。或者自己根据视频文件时间基从新生成pts和dts.

代码引用了工程中的一部分，关键是要看如何自己构造一个输出流参数，不依赖输入流的流参数：

#ifndef FFMPEGFILEWRITER_H
    #define FFMPEGFILEWRITER_H
    #include "videoutils.h"
    #include "writer.h"
    
    extern "C" { 
    #include "libavformat/avformat.h"
    #include "libavformat/avio.h"
    }
    #define ONE 1
    
    namespace flow { 
    class FFmpegFilewriter : public Writer, public FFmCommon { 
    public:
      using FFmpegFilewriterPtr = std::shared_ptr<FFmpegFilewriter>;
    
      explicit FFmpegFilewriter(int taskId);
      ~FFmpegFilewriter() override = default;
    
      static FFmpegFilewriterPtr create(int taskId) { 
        return std::make_shared<FFmpegFilewriter>(taskId);
      }
    
      virtual int watchNum() final {  return ONE; }
      virtual bool registed() final {  return true; }
    
    protected:
      bool openImpl() final;
      bool closeImpl() final;
      bool write(JobPkgPtr &pktPtr) final;
    
    private:
      bool initOutPutStream();
      bool openOutPutStream();
      bool deinitOutPutStream();
    
    private:
      AVFormatContext *m_outfmtContext{ };
      AVOutputFormat *m_outFmt{ };
      AVStream *m_stream{ };
    
      int64_t m_pktIdx{ 0};
      int64_t m_lastTimeStamp{ 0};
    };
    using FFmpegFilewriterPtr = std::shared_ptr<FFmpegFilewriter>;
    } // namespace flow
    #endif // FFMPEGFILEWRITER_H

#include "ffmpegfilewriter.h"
    #include "xlog/xlog.h"
    
    namespace flow { 
    FFmpegFilewriter::FFmpegFilewriter(int taskId)
        : Writer("FFmpegFilewriter", taskId) { }
    
    bool FFmpegFilewriter::write(JobPkgPtr &pktPtr) { 
      auto rawPtr = std::static_pointer_cast<JobPktRawVideoData>(pktPtr);
      AVPacket pkt{ };
      pkt.data = rawPtr->data.data.data();
      pkt.size = int(rawPtr->data.data.size());
      pkt.pts = m_lastTimeStamp + 40;
      pkt.dts = m_lastTimeStamp + 40;
      m_lastTimeStamp = pkt.pts;
      // pkt.pts = rawPtr->reserved;
      // pkt.dts = rawPtr->reserved;
      LOG_INFO("pts={}", pkt.pts);
    //-------------------添加代码转换时间基pts
    
    //---------for mp4-----------------
      { 
        AVRational time_base = { 1, 1000};
        AVRational time_base_q = m_stream->time_base;
        pkt.pts = av_rescale_q(pkt.pts, time_base, time_base_q);
        pkt.dts = pkt.pts;
        pkt.duration = 3600;
        // LOG_INFO("pts={}", pkt.pts);
      }
      //--------- end -----------------
    //---------------------------
      auto nRet = av_interleaved_write_frame(m_outfmtContext, &pkt);
      if (nRet < 0) { 
        printErrMsg(nRet, "av_interleaved_write_frame");
        return false;
      }
      return true;
    }
    
    bool FFmpegFilewriter::openImpl() { 
      bool bRet = false;
      if (initOutPutStream() && openOutPutStream())
        bRet = true;
    
      return bRet;
    }
    
    bool FFmpegFilewriter::closeImpl() { 
      av_write_trailer(m_outfmtContext);
      deinitOutPutStream();
      return true;
    }
    
    bool FFmpegFilewriter::initOutPutStream() { 
      bool bRet = false;
      int nRet = -1;
      do { 
        auto pos = m_fileName.rfind('.');
        if (pos != std::string::npos) { 
          m_fileName.replace(m_fileName.begin() + pos, m_fileName.end(), ".flv");
          LOG_INFO("output file name:{}", m_fileName);
        }
    
        m_outFmt = av_guess_format(nullptr, m_fileName.c_str(), nullptr);
        if (!m_outFmt) { 
          LOG_INFO("output format not found : {}", m_fileName);
          break;
        }
        nRet = avformat_alloc_output_context2(&m_outfmtContext, m_outFmt, nullptr,
                                              nullptr);
        if (nRet < 0) { 
          printErrMsg(nRet, "avformat_alloc_output_context2");
          break;
        }
    
        m_stream = avformat_new_stream(m_outfmtContext, nullptr);
        if (!m_stream) { 
          LOG_INFO("could not new stream...");
          break;
        }
    
        auto paramPtr = std::static_pointer_cast<WriterConfig>(m_taskConfigPtr);
        AVCodecParameters codecParams;
        codecParams.codec_id = codeIdTrans(paramPtr->codecId);
        codecParams.format = pixfmtTrans(paramPtr->pixFmt);
        codecParams.width = paramPtr->width;
        codecParams.height = paramPtr->height;
        codecParams.codec_type = AVMEDIA_TYPE_VIDEO;
        codecParams.codec_tag = 0; // important must set
    
        codecParams.profile = 100;
        codecParams.level = 42;
        codecParams.bit_rate = 400 * 1000;
        codecParams.sample_aspect_ratio = { 1, 1};
        codecParams.extradata = nullptr;
        codecParams.extradata_size = 0;
    
        nRet = avcodec_parameters_copy(m_stream->codecpar, &codecParams);
        if (nRet < 0) { 
          printErrMsg(nRet, "avcodec_parameters_copy");
          break;
        }
    
        // AVCodec *codec = avcodec_find_encoder(codecParams.codec_id);
        // if (!codec) { 
        // break;
        // }
    
        // auto c = m_stream->codec;
        // avcodec_get_context_defaults3(c, codec);
        // c->codec_id = codeIdTrans(paramPtr->codecId);
        // c->codec_tag = 0;
        // c->pix_fmt = pixfmtTrans(paramPtr->pixFmt);
        // c->time_base = {1, 25};
        // c->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
        // c->width = paramPtr->width;
        // c->height = paramPtr->height;
    
    //这里对m_stream的设置没有作用，在avformat_write_header（）时会覆盖所有的信息
        // m_stream->time_base.den = 1000; // {1, 1000 /*AV_TIME_BASE*/};
        // m_stream->time_base.num = 1;
        // m_stream->duration = 40;
        m_stream->start_time = 0;
        // m_stream->r_frame_rate.den = 1;
        // m_stream->r_frame_rate.num = 25;
        // m_stream->sample_aspect_ratio = {1, 1};
    
        bRet = true;
      } while (false);
    
      if (!bRet) { 
        deinitOutPutStream();
        LOG_INFO("initOutPutStream {} failed!!!", m_fileName);
        return bRet;
      }
      LOG_INFO("initOutPutStream {} success!!!", m_fileName);
      return bRet;
    }
    
    bool FFmpegFilewriter::openOutPutStream() { 
      int nRet = -1;
      bool bRet = false;
      do { 
        // m_outfmtContext->flags |= AV_CODEC_FLAG2_LOCAL_HEADER; //???
        m_outfmtContext->start_time = 0;
        m_outfmtContext->duration = 40;
    
        nRet = avio_open2(&m_outfmtContext->pb, m_fileName.c_str(), AVIO_FLAG_WRITE,
                          nullptr, nullptr);
        if (nRet < 0) { 
          printErrMsg(nRet, "avio_open2");
          break;
        }
    
        av_dump_format(m_outfmtContext, 0, m_fileName.c_str(), 1);
    
        AVDictionary *dict = nullptr;
        // av_dict_set(&dict, "movflags", "faststart", 0);
        // av_dict_set(&dict, "movflags", "separate_moof", 0);
        // av_dict_set(&dict, "movflags", "frag_keyframe+empty_moov", 0);
        av_dict_set_int(&dict, "flush_packets", 1, 0);
    
        nRet = avformat_write_header(m_outfmtContext, &dict);
        if (nRet < 0) { 
          printErrMsg(nRet, "avformat_write_header");
          break;
        }
        av_dict_free(&dict);
        av_dump_format(m_outfmtContext, 0, m_fileName.c_str(), 1);
        bRet = true;
      } while (false);
    
      if (!bRet) { 
        deinitOutPutStream();
        LOG_INFO("openOutPutStream {} failed!!!", m_fileName);
        return bRet;
      }
      LOG_INFO("openOutPutStream {} success!!!", m_fileName);
      return bRet;
    }
    
    bool FFmpegFilewriter::deinitOutPutStream() { 
      if (m_outfmtContext) { 
        if (m_outfmtContext->pb)
          avio_close(m_outfmtContext->pb);
    
        avformat_free_context(m_outfmtContext);
        m_outfmtContext = nullptr;
      }
      LOG_INFO("deinitOutPutStream {} !!!", m_fileName);
      return true;
    }
    
    } // namespace flow