vbv hanging issue; multiple slices

[Former user]

mParam->sourceWidth = 1920; 
mParam->sourceHeight = 1080;
mParam->maxSlices = 10; 
mParam->rc.vbvMaxBitrate = 512; 
mParam->rc.vbvBufferSize = 512;

preset: veryfast, tune : zerolatency.

x265lib version: 2.9

[Aruna Matheswaran]

We are not able to reproduce this issue in version 2.9. Can you share the entire command line and if possible the source file?

[dengzikun]

#include "swh265encoderinterface.h"
#include <memory>

#include "x265.h"


using namespace std;

namespace std {
template<>
struct default_delete<x265_encoder> {
    void operator()(x265_encoder *p) {
        x265_encoder_close(p);
    }
};

template<>
struct default_delete<x265_picture>{
    void operator()(x265_picture *p){
        x265_picture_free(p);
    }
};

template<>
struct default_delete<x265_param>{
    void operator()(x265_param *p){
        x265_param_free(p);
    }
};
}


class Encoder{
public:
    Encoder(SWH265EncoderInit *init){
        mApi = x265_api_get(8);
        const char *c1 = x265_preset_names[init->preset];
        const char *c2 = x265_tune_names[init->tune];

        mParam.reset(mApi->param_alloc());
        mInputFrame.reset(mApi->picture_alloc());

        mApi->param_default_preset(mParam.get(), x265_preset_names[init->preset], x265_tune_names[init->tune]);
        SetContext(init);
        mEncoder.reset(mApi->encoder_open(mParam.get()));

        mApi->picture_init(mParam.get(), mInputFrame.get());
    }

    ~Encoder(){
        mEncoder = nullptr;
        mParam = nullptr;
        mInputFrame = nullptr;
        mApi->cleanup();
    }



    int Encode(SWH265EncoderInput *input){

        for(int i = 0; i < 3; ++i){
            mInputFrame->planes[i] = input->plane[i];
            mInputFrame->stride[i] = input->stride[i];
        }

        mInputFrame->sliceType = input->insertKeyFrame ? X265_TYPE_IDR : X265_TYPE_AUTO;

        x265_nal *nals;
        uint32_t nalCount;
        x265_picture dummyOutput;

        int ret = mApi->encoder_encode(mEncoder.get(), &nals, &nalCount, mInputFrame.get(), &dummyOutput);
        if (ret == 1) {

            SWH265EncoderOutput output;

            output.stream = nals->payload;
            if (dummyOutput.sliceType == X265_TYPE_IDR) {
                output.isKeyFrame = true;
            }

            int size = 0;

            for (int i = 0; i < nalCount; ++i) {
                size += nals->sizeBytes;
                ++nals;
            }

            output.bytesOfStream = size;

            mCallback(&output, mUserData);
        }
        return ret;
    }

    int ReConfig(SWH265EncoderInit *init){
        mApi->param_default_preset(mParam.get(), x265_preset_names[init->preset], x265_tune_names[init->tune]);
        SetContext(init);
        return mApi->encoder_reconfig(mEncoder.get(), mParam.get());
    }

private:
    void SetContext(SWH265EncoderInit *init){

        mCallback = init->callback;
        mUserData = init->userData;

        mParam->bAllowNonConformance = 1;

        mParam->sourceWidth = init->width;
        mParam->sourceHeight = init->height;
        if(init->colorSpace == SWH265EncoderColorSpace::SWH265_CSP_I420){
            mParam->internalCsp = X265_CSP_I420;
        }
        mParam->fpsNum = init->fpsNum;
        mParam->fpsDenom = init->fpsDenom;
        mParam->keyframeMax = init->keyFrameInterval;
        mParam->bAnnexB = 1;
        mParam->bRepeatHeaders = 1;
        mParam->maxSlices = init->maxSlices;


        mParam->rc.vbvMaxBitrate = init->bitrate;
        mParam->rc.vbvBufferSize = init->bitrate;

        mParam->logLevel = X265_LOG_FULL;
    }

private:
    const x265_api *mApi;
    std::unique_ptr<x265_encoder> mEncoder;
    std::unique_ptr<x265_param> mParam;
    std::unique_ptr<x265_picture> mInputFrame;

    SWH265EncoderOutputCallback *mCallback;
    void *mUserData;

    int64_t mPts = 0;
};



HSWH265ENCODER SWH265EncoderCreate(SWH265EncoderInit *init){
    return reinterpret_cast<HSWH265ENCODER>(new Encoder(init));
}

void SWH265EncoderDestroy(HSWH265ENCODER hEncoder){
    delete reinterpret_cast<Encoder*>(hEncoder);
}

int SWH265EncoderEncode(HSWH265ENCODER hEncoder, SWH265EncoderInput *input){
    return reinterpret_cast<Encoder*>(hEncoder)->Encode(input);
}

// bitrate: kbps
int SWH265EncoderReconfig(HSWH265ENCODER hEncoder, SWH265EncoderInit *init){
    return reinterpret_cast<Encoder*>(hEncoder)->ReConfig(init);
}


typedef struct {
        SWH265EncoderPreset preset;
        SWH265EncoderTune   tune;
        SWH265EncoderColorSpace colorSpace;
        unsigned int width;
        unsigned int height;
        unsigned int bitrate; // Kbps
        unsigned int fpsNum;
        unsigned int fpsDenom;
        unsigned int maxSlices;
        unsigned int keyFrameInterval;

        SWH265EncoderOutputCallback *callback;
        void *userData;
    } SWH265EncoderInit;


SWH265EncoderInit init;
    init.preset = SWH265EncoderPreset::swh265_veryfast;
    init.tune = SWH265EncoderTune::swh265_zerolatency;
    init.colorSpace = SWH265_CSP_I420;
    init.keyFrameInterval = 500;
    init.width = 1920;
    init.height = 1080;
    init.bitrate = 256;
    init.fpsDenom = 1;
    init.fpsNum = 30;
    init.maxSlices = 10;
    init.userData = this;

It works well, if init.maxSlices = 1.