static void destructor(void *arg)
{
struct videnc_state *st = arg;
if (st->x265)
x265_encoder_close(st->x265);
if (st->param)
x265_param_free(st->param);
}
static av_cold int libx265_encode_close(AVCodecContext *avctx)
{
libx265Context *ctx = avctx->priv_data;
av_frame_free(&avctx->coded_frame);
x265_param_free(ctx->params);
if (ctx->encoder)
x265_encoder_close(ctx->encoder);
return 0;
}
void Video_Encoder_H265::release()
{
if(_x265_param)
{
x265_param_free(_x265_param);
}
if(_x265_picture)
{
x265_picture_free(_x265_picture);
}
if(_x265_encoder)
{
x265_encoder_close(_x265_encoder);
}
x265_cleanup() ;
}
void encx265Close(hb_work_object_t *w)
{
hb_work_private_t *pv = w->private_data;
if (pv->delayed_chapters != NULL)
{
struct chapter_s *item;
while ((item = hb_list_item(pv->delayed_chapters, 0)) != NULL)
{
hb_list_rem(pv->delayed_chapters, item);
free(item);
}
hb_list_close(&pv->delayed_chapters);
}
x265_param_free(pv->param);
x265_encoder_close(pv->x265);
free(pv);
w->private_data = NULL;
}
bool Video_Encoder_H265::init(Video_Encoder::NALU_CB *cb, const Encoder_Param ¶m)
{
//alloc & set param
_x265_param = x265_param_alloc();
if(_x265_param == NULL)
{
printf("x265_param_alloc error~\n");
return false;
}
// x265_param_default(_x265_param);
/* x265_preset_names[] = { "ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow", "placebo", 0 };
x265_tune_names[] = { "psnr", "ssim", "grain", "zerolatency", "fastdecode", 0 };*/
int rc = x265_param_default_preset(_x265_param, x265_preset_names[4], x265_tune_names[3]);
if(rc != 0)
{
//error...
printf("x265_param_default_preset error~\n");
return false;
}
/*x265_profile_names[] = { "main", "main10", "mainstillpicture", 0 };*/
rc = x265_param_apply_profile(_x265_param, x265_profile_names[0]);
if(rc != 0)
{
//error...
printf("x265_param_apply_profile error~\n");
return false;
}
_x265_param->sourceHeight = param.height;
_x265_param->sourceWidth = param.width;
/*The output of the encoder is a series of NAL packets, which are always returned concatenated in consecutive memory.
* HEVC streams have SPS and PPS and VPS headers which describe how the following packets are to be decoded.
* If you specified --repeat-headers then those headers will be output with every keyframe.
* Otherwise you must explicitly query those headers using:int x265_encoder_headers(x265_encoder *, x265_nal **pp_nal, uint32_t *pi_nal);*/
_x265_param->bRepeatHeaders = 1;
_x265_param->internalCsp = X265_CSP_I420;
_x265_param->fpsNum = param.fps;
_x265_param->fpsDenom = 1;
// x265_param_parse(_x265_param, const char *name, const char *value);
/*******
x265_encoder_parameters() may be used to get a copy of the param structure from the encoder after it has been opened,
in order to see the changes made to the parameters for auto-detection and other reasons.
x265_encoder_reconfig() may be used to reconfigure encoder parameters mid-encode:
*********/
// rc = x265_encoder_reconfig(_x265_encoder, _x265_param);
_x265_picture = x265_picture_alloc();
if(_x265_picture == NULL)
{
if(_x265_param)
{
x265_param_free(_x265_param);
}
printf("x265_picture_alloc error~\n");
return false;
}
x265_picture_init(_x265_param, _x265_picture);
//Analysis Buffers
// rc = x265_alloc_analysis_data(_x265_picture);
// if(rc == 0)
// {
// //error...
// }
// x265_free_analysis_data(_x265_picture);
//
_x265_encoder = x265_encoder_open(_x265_param);
if(_x265_encoder == NULL)
{
if(_x265_param)
{
x265_param_free(_x265_param);
}
if(_x265_picture)
{
x265_picture_free(_x265_picture);
}
printf("x265_encoder_open error~\n");
return false;
}
_callback = cb;
gettimeofday(&_tv_start, NULL);
return true;
}
static HEVCEncoderContext *x265_open(const HEVCEncodeParams *params)
{
HEVCEncoderContext *s;
x265_param *p;
int preset_index;
const char *preset;
s = malloc(sizeof(HEVCEncoderContext));
memset(s, 0, sizeof(*s));
if (params->bit_depth != x265_max_bit_depth) {
fprintf(stderr, "x265 is compiled to support only %d bit depth. Use the '-b %d' option to force the bit depth.\n",
x265_max_bit_depth, x265_max_bit_depth);
return NULL;
}
if (params->chroma_format == BPG_FORMAT_GRAY) {
fprintf(stderr, "x265 does not support monochrome (or alpha) data yet. Plase use the jctvc encoder.\n");
return NULL;
}
p = x265_param_alloc();
preset_index = params->compress_level; /* 9 is placebo */
preset = x265_preset_names[preset_index];
if (params->verbose)
printf("Using x265 preset: %s\n", preset);
x265_param_default_preset(p, preset, "ssim");
p->bRepeatHeaders = 1;
p->decodedPictureHashSEI = params->sei_decoded_picture_hash;
p->sourceWidth = params->width;
p->sourceHeight = params->height;
switch(params->chroma_format) {
case BPG_FORMAT_GRAY:
p->internalCsp = X265_CSP_I400;
break;
case BPG_FORMAT_420:
p->internalCsp = X265_CSP_I420;
break;
case BPG_FORMAT_422:
p->internalCsp = X265_CSP_I422;
break;
case BPG_FORMAT_444:
p->internalCsp = X265_CSP_I444;
break;
default:
abort();
}
if (params->intra_only) {
p->keyframeMax = 1; /* only I frames */
p->totalFrames = 1;
} else {
p->keyframeMax = 250;
p->totalFrames = 0;
p->maxNumReferences = 1;
p->bframes = 0;
}
p->bEnableRectInter = 1;
p->bEnableAMP = 1; /* cannot use 0 due to header restriction */
p->internalBitDepth = params->bit_depth;
p->bEmitInfoSEI = 0;
if (params->verbose)
p->logLevel = X265_LOG_INFO;
else
p->logLevel = X265_LOG_NONE;
/* dummy frame rate */
p->fpsNum = 25;
p->fpsDenom = 1;
p->rc.rateControlMode = X265_RC_CQP;
/* XXX: why do we need this offset to match the JCTVC quality ? */
if (params->bit_depth == 10)
p->rc.qp = params->qp + 7;
else
p->rc.qp = params->qp + 1;
p->bLossless = params->lossless;
s->enc = x265_encoder_open(p);
s->pic = x265_picture_alloc();
x265_picture_init(p, s->pic);
s->pic->colorSpace = p->internalCsp;
x265_param_free(p);
return s;
}