GetYUV format is NV12

zhangmeng

2023-12-26 18a05d269516a5e33d8460291c2f93e73d95adce

 csrc/ffmpeg/format/FormatOut.cpp

@@ -10,6 +10,7 @@
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libavutil/opt.h>
#include <libavutil/intreadwrite.h>
}

#include "../log/log.hpp"
@@ -31,11 +32,18 @@
    ,record_(false)
    ,fps_(0.0f)
    ,format_name_("mp4")
    ,in_v_stream_(NULL)
    ,in_a_stream_(NULL)
    ,bsf_h264(NULL)
    ,bsf_hevc(NULL)
   {}

   FormatOut::~FormatOut()
   {
      clear();

        if (bsf_h264) av_bsf_free(&bsf_h264);
        if (bsf_hevc) av_bsf_free(&bsf_hevc);
   }

    void FormatOut::clear(){
@@ -99,8 +107,8 @@

        enc_ctx_->codec_id = AV_CODEC_ID_H264;
        enc_ctx_->codec_type = AVMEDIA_TYPE_VIDEO;
        enc_ctx_->height = (prop.height_ & 0x01) ? prop.height_-1 : prop.height_;
        enc_ctx_->width = (prop.width_ & 0x01) ? prop.width_ - 1 : prop.width_;
        enc_ctx_->height = prop.height_ & ~0x01;
        enc_ctx_->width = prop.width_ & ~0x01;

        enc_ctx_->sample_aspect_ratio = prop.sample_aspect_ratio_;
        
@@ -174,7 +182,7 @@
        av_opt_set(enc_ctx_->priv_data, "tune", "zerolatency", 0);
        av_opt_set(enc_ctx_->priv_data, "profile", "baseline", 0);
    
        int err =avcodec_open2(enc_ctx_, codec, NULL);
        int err = avcodec_open2(enc_ctx_, codec, NULL);
        if( err< 0)
        {
            logIt("can't open output codec: %s", getAVErrorDesc(err).c_str());
@@ -186,14 +194,11 @@
            return false;
        }
        ofmt->video_codec = codec_id;
        if(ofmt->flags & AVFMT_GLOBALHEADER)
        {
        if(ofmt->flags & AVFMT_GLOBALHEADER){
            enc_ctx_->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
        }


        return true;

   }
   
    AVStream *FormatOut::getStream(){
@@ -275,68 +280,89 @@
        return true;
    }

    bool FormatOut::copyCodecFromIn(std::vector<AVStream*> in){

        for (int i = 0; i < in.size(); i++){

            AVStream *in_stream = in[i];
            
            AVStream *out_stream = avformat_new_stream(ctx_, in_stream->codec->codec);
            if(!out_stream)
            {
                logIt("Failed allocating output stream.\n");
                return false;
            }

            //将输出流的编码信息复制到输入流
            auto ret = avcodec_copy_context(out_stream->codec, in_stream->codec);
            if(ret<0)
            {
                logIt("Failed to copy context from input to output stream codec context\n");
                return false;
            }

            if (in_stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO){
                v_idx_ = i;
                logIt("copy video from instream");

                out_stream->codecpar->codec_tag = out_stream->codec->codec_tag = 0;
            
                if(ctx_->oformat->flags & AVFMT_GLOBALHEADER)
                    out_stream->codec->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
            }
            if (in_stream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO){
                logIt("copy audio from instream");
                a_idx_ = i;
                
                out_stream->codecpar->codec_tag = out_stream->codec->codec_tag = 0;
            
                if(ctx_->oformat->flags & AVFMT_GLOBALHEADER)
                    out_stream->codec->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

            }
    bool FormatOut::addStream(AVStream *s){
        AVStream *in_stream = s;
        
        AVStream *out_stream = avformat_new_stream(ctx_, in_stream->codec->codec);
        if(!out_stream)
        {
            logIt("Failed allocating output stream.\n");
            return false;
        }

        in_streams_ = in;

        //将输出流的编码信息复制到输入流
        auto ret = avcodec_parameters_copy(out_stream->codecpar, in_stream->codecpar);
        if(ret<0)
        {
            logIt("Failed to copy context from input to output stream codec context\n");
            return false;
        }
        out_stream->codecpar->codec_tag = 0;
        
        if(ctx_->oformat->flags & AVFMT_GLOBALHEADER)
            out_stream->codec->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
        
        return true;
    }

    bool FormatOut::JustWriter(std::vector<AVStream*> in, const char *filename){
    bool FormatOut::copyCodecFromIn(AVStream *v, AVStream *a){
        if (v){
            v_idx_ = 0;
            in_v_stream_ = v;

            if (!addStream(v)){
                logIt("format out add video stream error");
                return false;
            }else{
                logIt("copy video from instream");
            }
        }
        if (a){
            a_idx_ = 1;
            in_a_stream_ = a;
            if (!addStream(a)){
                logIt("format out add audio stream error");
                return false;
            }else{
                logIt("copy audio from instream");
            }
        }
        return true;
    }

    bool FormatOut::JustWriter(AVStream *v, AVStream *a, const char *filename){
        if(ctx_){
            clear();
        }

        bool flag = open(NULL, format_name_.c_str());

        flag = copyCodecFromIn(in) && flag;
        flag = copyCodecFromIn(v, a) && flag;
        if(!flag){
            logIt("FormatOut JustWriter error from in");
            return false;
        }

        flag = openResource(filename, 2);
        

// h264 mp4toannexb
        if (v && v->codecpar->codec_id == AV_CODEC_ID_H264) {
            if (!bsf_h264){
                char p[100] = {0};
                char *sub = av_fourcc_make_string(p, v->codecpar->codec_tag);
                if (strcmp(sub, "avc1") == 0){
                    const AVBitStreamFilter *f = av_bsf_get_by_name("h264_mp4toannexb");
                    if (f){
                        if (av_bsf_alloc(f, &bsf_h264) >= 0){
                            if (avcodec_parameters_copy(bsf_h264->par_in, v->codecpar) >= 0){
                                if (av_bsf_init(bsf_h264) < 0) bsf_h264 = NULL;
                            }
                        }
                    }
                }
            }
        }
// h264 mp4toannexb

        if(flag){
            AVDictionary *avdic = NULL;
            char option_key[]="movflags";
@@ -345,7 +371,7 @@
            flag = writeHeader(&avdic);
            av_dict_free(&avdic);
        }
        

        return flag;
    }
    
@@ -391,34 +417,11 @@
    }

    void FormatOut::adjustPTS(AVPacket *pkt, const int64_t &frame_cnt){
        if (pkt->stream_index >= ctx_->nb_streams){
            logIt("adjustPTS pkt stream index too much");
            return;
        }
        
        if (pkt->pts == AV_NOPTS_VALUE && pkt->pts == AV_NOPTS_VALUE){
            int64_t time_stamp = frame_cnt;
        
            pkt->pos = -1;  
            pkt->stream_index = 0;
            //Write PTS
            AVRational time_base = getStream()->time_base;

            AVRational time_base_q = { 1, AV_TIME_BASE };
            //Duration between 2 frames (us)
            // int64_t calc_duration = (double)(AV_TIME_BASE)*(1 / fps_);  //内部时间戳
            int64_t calc_duration = (int64_t)(AV_TIME_BASE / fps_);  //内部时间戳
            //Parameters
            pkt->pts = av_rescale_q(time_stamp*calc_duration, time_base_q, time_base);
            pkt->dts = pkt->pts;
            pkt->duration = av_rescale_q(calc_duration, time_base_q, time_base); 
            return;
        }

        AVStream *in_stream,*out_stream;
        int out_idx = -1;
        for (auto i : in_streams_){
            if (i->index == pkt->stream_index){
        std::vector<AVStream*> in_streams{in_v_stream_, in_a_stream_};
        for (auto i : in_streams){
            if (i && (i->index == pkt->stream_index)){
                if (i->codecpar->codec_type == AVMEDIA_TYPE_VIDEO){
                    out_idx = v_idx_;
                    in_stream = i;
@@ -431,31 +434,41 @@
            }
        }
        if (out_idx == -1) return;

        out_stream = ctx_->streams[out_idx];
        pkt->stream_index = out_idx;

        int64_t time_stamp = frame_cnt;

        if (out_idx == v_idx_){
        
            pkt->pos = -1;  
            AVRational time_base = ctx_->streams[out_idx]->time_base;

            AVRational time_base_q = { 1, AV_TIME_BASE };
            int64_t calc_duration = (int64_t)(AV_TIME_BASE / fps_);  //内部时间戳
            pkt->pts = av_rescale_q(time_stamp*calc_duration, time_base_q, time_base);
            pkt->dts = pkt->pts;
            pkt->duration = av_rescale_q(calc_duration, time_base_q, time_base); 
            
        }else if (out_idx == a_idx_){

            pkt->duration = 1024;
            pkt->pts = pkt->dts = pkt->duration * time_stamp; 

        }
        // logIt("BEFORE in stream timebase %d:%d, out timebase %d:%d, 
        //         pts: %lld, dts: %lld, duration: %lld", 
        //     in_stream->time_base.num, in_stream->time_base.den,
        //     out_stream->time_base.num, out_stream->time_base.den,
        //     pkt->pts, pkt->dts, pkt->duration);

        //转换 PTS/DTS 时序
        pkt->pts = av_rescale_q_rnd(pkt->pts,in_stream->time_base,out_stream->time_base,(enum AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
        pkt->dts = av_rescale_q_rnd(pkt->dts, in_stream->time_base, out_stream->time_base, (enum AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));  
        pkt->duration = av_rescale_q(pkt->duration, in_stream->time_base, out_stream->time_base); 
        pkt->pos = -1;  

        // logIt("AFTER stream %d, pts: %lld, dts: %lld, duration: %lld", 
        // pkt->stream_index, pkt->pts, pkt->dts, pkt->duration);
    }

    bool FormatOut::writeFrame(AVPacket *pkt, const int64_t &frame_cnt,
                              bool interleaved/* = true*/){

        adjustPTS(pkt, frame_cnt);
        auto ret = writeFrame2(pkt, interleaved);
        auto ret = writeFrameInternal(pkt, interleaved);
        if (!ret){
            logIt("write to file failed, pkt.pts: %lld, dts: %lld, frame count: %d",
                    pkt->pts, pkt->dts, frame_cnt);
@@ -463,16 +476,16 @@
        return ret;
    }

    bool FormatOut::writeFrame2(AVPacket *pkt, bool interleaved){
        
    static bool write_frame(AVFormatContext *ctx, AVPacket *pkt, bool interleaved){

        int ret = 0;
        if(interleaved){
            ret = av_interleaved_write_frame(ctx_, pkt);
            ret = av_interleaved_write_frame(ctx, pkt);
        }else{
            // returns 1 if flushed and there is no more data to flush
            ret = av_write_frame(ctx_, pkt);
            ret = av_write_frame(ctx, pkt);
        }
    

        if(ret < -22 || ret == 0){
            return true;
        }
@@ -480,6 +493,47 @@
        return false;
    }

    bool FormatOut::writeFrameInternal(AVPacket *pkt, bool interleaved){

        AVBSFContext *bsf = NULL;

        if (in_v_stream_ && in_v_stream_->codecpar->codec_id == AV_CODEC_ID_HEVC) {
            if (pkt->size >= 5 &&
                AV_RB32(pkt->data) != 0x0000001 &&
                AV_RB24(pkt->data) != 0x000001 &&
                !bsf_hevc){

                const AVBitStreamFilter *f = av_bsf_get_by_name("hevc_mp4toannexb");
                if (f){
                    if (av_bsf_alloc(f, &bsf_hevc) >= 0){
                        if (avcodec_parameters_copy(bsf_hevc->par_in, in_v_stream_->codecpar) >= 0){
                            if (av_bsf_init(bsf_hevc) < 0) bsf_hevc = NULL;
                        }
                    }
                }
            }

            bsf = bsf_hevc;
            logIt("use hevc AVBitStreamFilter");
        }else {
            bsf = bsf_h264;
            logIt("use h264 AVBitStreamFilter");
        }

        if (bsf){
            if (av_bsf_send_packet(bsf, pkt) < 0){
                logIt("bsf send packet failed");
                return true;
            }
            if (av_bsf_receive_packet(bsf, pkt) < 0){
                logIt("bsf recv packet failed");
                return true;
            }
        }

        return write_frame(ctx_, pkt, interleaved);
    }

    bool FormatOut::writeTrailer(){
        const int ret = av_write_trailer(ctx_);
        if(ret != 0)