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; }