h264 mp4

zhangmeng

2020-10-09 d64868c215e35088bfeda67aeb04db0800bf2844

h264 mp4

 csrc/common/gpu/info.cpp

@@ -412,6 +412,27 @@

    return -1;
}

bool satisfy(const int index, const int need, const int reserved){
    nvGpuInfo_t gpu_info;

    int ret = get_gpu_info(&gpu_info);
    if(!ret){
        if (gpu_info.device_count == 0) return -1;

        for(int i = 0; i < gpu_info.device_count; i++){
            if (i == index){
                int mem_free = (gpu_info.devices[i].memory_free >> 20) - reserved - need;
                if(mem_free > 0){
                    return true;
                }
            }
        }
    }

    return false;
}

int test(void)
{
    nvGpuInfo_t gpu_buf;

 csrc/common/gpu/info.h

@@ -4,6 +4,7 @@
namespace gpu{
    int getGPU(const int need);
    int getGPUPrior(const int need, const int reserved, const int lastChoice);
    bool satisfy(const int index, const int need, const int reserved);
}

#endif

 csrc/ffmpeg/format/FormatIn.cpp

@@ -2,6 +2,8 @@

#include <stdexcept>
#include <unistd.h>
#include <stdlib.h>
#include <time.h>

extern "C"{
#include <libavformat/avformat.h>
@@ -198,6 +200,16 @@
        return ctx_->streams[vs_idx_]->codecpar->codec_id == AV_CODEC_ID_HEVC;
    }

    const bool FormatIn::isAVC1()const{
        if (IsHEVC()) return false;

        char p[100] = {0};
        char *sub = av_fourcc_make_string(p, ctx_->streams[vs_idx_]->codecpar->codec_tag);
        const int ret = strcmp(sub, "avc1");
        if (ret == 0) return true;
        return false;
    }

    bool FormatIn::openCodec(AVDictionary **options){
        if (vs_idx_ == -1) return false;

@@ -211,14 +223,32 @@

        int idle_gpu = -1;

        srand((unsigned)time(NULL));

constexpr int need = 350; // M
constexpr int reserved = 512; // M

        for (int i = 0; i < 2; ++i)
        {
            if(hw_accl_){
                idle_gpu = gpu::getGPUPrior(350, 896, 0);
                // idle_gpu = gpu::getGPU(300);

                // 设置gpu index
                if (prop_->gpu_index_ > -1){
                    idle_gpu = prop_->gpu_index_;
                    if (!gpu::satisfy(prop_->gpu_index_, need, reserved)){
                        hw_accl_ = false;
                        continue;
                }
                    idle_gpu = prop_->gpu_index_;
                }else{
                    idle_gpu = gpu::getGPUPrior(need, reserved, 0);
                    // idle_gpu = gpu::getGPU(300);
                    usleep(2000000 + rand()%3000000);
                    if (!gpu::satisfy(idle_gpu, need, reserved)){
                        hw_accl_ = false;
                        continue;
                    }
                }

                if(idle_gpu < 0){
                    logIt("NO GPU RESOURCE TO DECODE");
                    hw_accl_ = false;

 csrc/ffmpeg/format/FormatIn.hpp

@@ -51,6 +51,7 @@
        AVFormatContext *getFromatContext(){return ctx_;}
        const double getFPS()const{return fps_;}
        const bool IsHEVC()const;
        const bool isAVC1()const;
    private:
         AVFormatContext     *ctx_;
         AVCodecContext         *dec_ctx_;

 csrc/ffmpeg/format/FormatOut.cpp

@@ -33,11 +33,16 @@
    ,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(){
@@ -350,6 +355,22 @@
            av_dict_free(&avdic);
        }
        
        if (v){
            if (v->codecpar->codec_id == AV_CODEC_ID_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;
                            }
                        }
                    }
                }
            }
        }
        return flag;
    }
    
@@ -456,6 +477,19 @@

    bool FormatOut::writeFrame2(AVPacket *pkt, bool interleaved){
        
        // h264_mp4toanatax
        if (bsf_h264){
            if (av_bsf_send_packet(bsf_h264, pkt) < 0){
                logIt("bsf_h264 send packet failed");
                return true;
            }
            if (av_bsf_receive_packet(bsf_h264, pkt) < 0){
                logIt("bsf_h264 recv packet failed");
                return true;
            }
        }

        //
        int ret = 0;
        if(interleaved){
            ret = av_interleaved_write_frame(ctx_, pkt);

 csrc/ffmpeg/format/FormatOut.hpp

@@ -11,6 +11,7 @@
struct AVFrame;
struct AVPacket;
struct AVDictionary;
struct AVBSFContext;

namespace ffwrapper{
    class VideoProp;
@@ -72,6 +73,7 @@
        double                     fps_;
        std::string             format_name_;

        AVBSFContext               *bsf_h264, *bsf_hevc;
        // rec
        AVStream                  *in_v_stream_;
        AVStream                  *in_a_stream_;