git.sesse.net Git - ffmpeg/blob - libavcodec/libx265.c

   1 /*
   2  * libx265 encoder
   3  *
   4  * Copyright (c) 2013-2014 Derek Buitenhuis
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 #if defined(_MSC_VER)
  24 #define X265_API_IMPORTS 1
  25 #endif
  26
  27 #include <x265.h>
  28 #include <float.h>
  29
  30 #include "libavutil/internal.h"
  31 #include "libavutil/common.h"
  32 #include "libavutil/opt.h"
  33 #include "libavutil/pixdesc.h"
  34 #include "avcodec.h"
  35 #include "internal.h"
  36 #include "packet_internal.h"
  37
  38 typedef struct libx265Context {
  39     const AVClass *class;
  40
  41     x265_encoder *encoder;
  42     x265_param   *params;
  43     const x265_api *api;
  44
  45     float crf;
  46     int   cqp;
  47     int   forced_idr;
  48     char *preset;
  49     char *tune;
  50     char *profile;
  51     AVDictionary *x265_opts;
  52
  53     /**
  54      * If the encoder does not support ROI then warn the first time we
  55      * encounter a frame with ROI side data.
  56      */
  57     int roi_warned;
  58 } libx265Context;
  59
  60 static int is_keyframe(NalUnitType naltype)
  61 {
  62     switch (naltype) {
  63     case NAL_UNIT_CODED_SLICE_BLA_W_LP:
  64     case NAL_UNIT_CODED_SLICE_BLA_W_RADL:
  65     case NAL_UNIT_CODED_SLICE_BLA_N_LP:
  66     case NAL_UNIT_CODED_SLICE_IDR_W_RADL:
  67     case NAL_UNIT_CODED_SLICE_IDR_N_LP:
  68     case NAL_UNIT_CODED_SLICE_CRA:
  69         return 1;
  70     default:
  71         return 0;
  72     }
  73 }
  74
  75 static av_cold int libx265_encode_close(AVCodecContext *avctx)
  76 {
  77     libx265Context *ctx = avctx->priv_data;
  78
  79     ctx->api->param_free(ctx->params);
  80
  81     if (ctx->encoder)
  82         ctx->api->encoder_close(ctx->encoder);
  83
  84     return 0;
  85 }
  86
  87 static av_cold int libx265_param_parse_float(AVCodecContext *avctx,
  88                                            const char *key, float value)
  89 {
  90     libx265Context *ctx = avctx->priv_data;
  91     char buf[256];
  92
  93     snprintf(buf, sizeof(buf), "%2.2f", value);
  94     if (ctx->api->param_parse(ctx->params, key, buf) == X265_PARAM_BAD_VALUE) {
  95         av_log(avctx, AV_LOG_ERROR, "Invalid value %2.2f for param \"%s\".\n", value, key);
  96         return AVERROR(EINVAL);
  97     }
  98
  99     return 0;
 100 }
 101
 102 static av_cold int libx265_param_parse_int(AVCodecContext *avctx,
 103                                            const char *key, int value)
 104 {
 105     libx265Context *ctx = avctx->priv_data;
 106     char buf[256];
 107
 108     snprintf(buf, sizeof(buf), "%d", value);
 109     if (ctx->api->param_parse(ctx->params, key, buf) == X265_PARAM_BAD_VALUE) {
 110         av_log(avctx, AV_LOG_ERROR, "Invalid value %d for param \"%s\".\n", value, key);
 111         return AVERROR(EINVAL);
 112     }
 113
 114     return 0;
 115 }
 116
 117 static av_cold int libx265_encode_init(AVCodecContext *avctx)
 118 {
 119     libx265Context *ctx = avctx->priv_data;
 120     AVCPBProperties *cpb_props = NULL;
 121     int ret;
 122
 123     ctx->api = x265_api_get(av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth);
 124     if (!ctx->api)
 125         ctx->api = x265_api_get(0);
 126
 127     ctx->params = ctx->api->param_alloc();
 128     if (!ctx->params) {
 129         av_log(avctx, AV_LOG_ERROR, "Could not allocate x265 param structure.\n");
 130         return AVERROR(ENOMEM);
 131     }
 132
 133     if (ctx->api->param_default_preset(ctx->params, ctx->preset, ctx->tune) < 0) {
 134         int i;
 135
 136         av_log(avctx, AV_LOG_ERROR, "Error setting preset/tune %s/%s.\n", ctx->preset, ctx->tune);
 137         av_log(avctx, AV_LOG_INFO, "Possible presets:");
 138         for (i = 0; x265_preset_names[i]; i++)
 139             av_log(avctx, AV_LOG_INFO, " %s", x265_preset_names[i]);
 140
 141         av_log(avctx, AV_LOG_INFO, "\n");
 142         av_log(avctx, AV_LOG_INFO, "Possible tunes:");
 143         for (i = 0; x265_tune_names[i]; i++)
 144             av_log(avctx, AV_LOG_INFO, " %s", x265_tune_names[i]);
 145
 146         av_log(avctx, AV_LOG_INFO, "\n");
 147
 148         return AVERROR(EINVAL);
 149     }
 150
 151     ctx->params->frameNumThreads = avctx->thread_count;
 152     if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
 153         ctx->params->fpsNum      = avctx->framerate.num;
 154         ctx->params->fpsDenom    = avctx->framerate.den;
 155     } else {
 156         ctx->params->fpsNum      = avctx->time_base.den;
 157         ctx->params->fpsDenom    = avctx->time_base.num * avctx->ticks_per_frame;
 158     }
 159     ctx->params->sourceWidth     = avctx->width;
 160     ctx->params->sourceHeight    = avctx->height;
 161     ctx->params->bEnablePsnr     = !!(avctx->flags & AV_CODEC_FLAG_PSNR);
 162     ctx->params->bOpenGOP        = !(avctx->flags & AV_CODEC_FLAG_CLOSED_GOP);
 163
 164     /* Tune the CTU size based on input resolution. */
 165     if (ctx->params->sourceWidth < 64 || ctx->params->sourceHeight < 64)
 166         ctx->params->maxCUSize = 32;
 167     if (ctx->params->sourceWidth < 32 || ctx->params->sourceHeight < 32)
 168         ctx->params->maxCUSize = 16;
 169     if (ctx->params->sourceWidth < 16 || ctx->params->sourceHeight < 16) {
 170         av_log(avctx, AV_LOG_ERROR, "Image size is too small (%dx%d).\n",
 171                ctx->params->sourceWidth, ctx->params->sourceHeight);
 172         return AVERROR(EINVAL);
 173     }
 174
 175
 176     ctx->params->vui.bEnableVideoSignalTypePresentFlag = 1;
 177
 178     ctx->params->vui.bEnableVideoFullRangeFlag = avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
 179                                                  avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
 180                                                  avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
 181                                                  avctx->color_range == AVCOL_RANGE_JPEG;
 182
 183     if ((avctx->color_primaries <= AVCOL_PRI_SMPTE432 &&
 184          avctx->color_primaries != AVCOL_PRI_UNSPECIFIED) ||
 185         (avctx->color_trc <= AVCOL_TRC_ARIB_STD_B67 &&
 186          avctx->color_trc != AVCOL_TRC_UNSPECIFIED) ||
 187         (avctx->colorspace <= AVCOL_SPC_ICTCP &&
 188          avctx->colorspace != AVCOL_SPC_UNSPECIFIED)) {
 189
 190         ctx->params->vui.bEnableColorDescriptionPresentFlag = 1;
 191
 192         // x265 validates the parameters internally
 193         ctx->params->vui.colorPrimaries          = avctx->color_primaries;
 194         ctx->params->vui.transferCharacteristics = avctx->color_trc;
 195 #if X265_BUILD >= 159
 196         if (avctx->color_trc == AVCOL_TRC_ARIB_STD_B67)
 197             ctx->params->preferredTransferCharacteristics = ctx->params->vui.transferCharacteristics;
 198 #endif
 199         ctx->params->vui.matrixCoeffs            = avctx->colorspace;
 200     }
 201
 202     if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0) {
 203         char sar[12];
 204         int sar_num, sar_den;
 205
 206         av_reduce(&sar_num, &sar_den,
 207                   avctx->sample_aspect_ratio.num,
 208                   avctx->sample_aspect_ratio.den, 65535);
 209         snprintf(sar, sizeof(sar), "%d:%d", sar_num, sar_den);
 210         if (ctx->api->param_parse(ctx->params, "sar", sar) == X265_PARAM_BAD_VALUE) {
 211             av_log(avctx, AV_LOG_ERROR, "Invalid SAR: %d:%d.\n", sar_num, sar_den);
 212             return AVERROR_INVALIDDATA;
 213         }
 214     }
 215
 216     switch (avctx->pix_fmt) {
 217     case AV_PIX_FMT_YUV420P:
 218     case AV_PIX_FMT_YUV420P10:
 219     case AV_PIX_FMT_YUV420P12:
 220         ctx->params->internalCsp = X265_CSP_I420;
 221         break;
 222     case AV_PIX_FMT_YUV422P:
 223     case AV_PIX_FMT_YUV422P10:
 224     case AV_PIX_FMT_YUV422P12:
 225         ctx->params->internalCsp = X265_CSP_I422;
 226         break;
 227     case AV_PIX_FMT_GBRP:
 228     case AV_PIX_FMT_GBRP10:
 229     case AV_PIX_FMT_GBRP12:
 230         ctx->params->vui.matrixCoeffs = AVCOL_SPC_RGB;
 231         ctx->params->vui.bEnableVideoSignalTypePresentFlag  = 1;
 232         ctx->params->vui.bEnableColorDescriptionPresentFlag = 1;
 233     case AV_PIX_FMT_YUV444P:
 234     case AV_PIX_FMT_YUV444P10:
 235     case AV_PIX_FMT_YUV444P12:
 236         ctx->params->internalCsp = X265_CSP_I444;
 237         break;
 238     case AV_PIX_FMT_GRAY8:
 239     case AV_PIX_FMT_GRAY10:
 240     case AV_PIX_FMT_GRAY12:
 241         if (ctx->api->api_build_number < 85) {
 242             av_log(avctx, AV_LOG_ERROR,
 243                    "libx265 version is %d, must be at least 85 for gray encoding.\n",
 244                    ctx->api->api_build_number);
 245             return AVERROR_INVALIDDATA;
 246         }
 247         ctx->params->internalCsp = X265_CSP_I400;
 248         break;
 249     }
 250
 251     if (ctx->crf >= 0) {
 252         char crf[6];
 253
 254         snprintf(crf, sizeof(crf), "%2.2f", ctx->crf);
 255         if (ctx->api->param_parse(ctx->params, "crf", crf) == X265_PARAM_BAD_VALUE) {
 256             av_log(avctx, AV_LOG_ERROR, "Invalid crf: %2.2f.\n", ctx->crf);
 257             return AVERROR(EINVAL);
 258         }
 259     } else if (avctx->bit_rate > 0) {
 260         ctx->params->rc.bitrate         = avctx->bit_rate / 1000;
 261         ctx->params->rc.rateControlMode = X265_RC_ABR;
 262     } else if (ctx->cqp >= 0) {
 263         ret = libx265_param_parse_int(avctx, "qp", ctx->cqp);
 264         if (ret < 0)
 265             return ret;
 266     }
 267
 268 #if X265_BUILD >= 89
 269     if (avctx->qmin >= 0) {
 270         ret = libx265_param_parse_int(avctx, "qpmin", avctx->qmin);
 271         if (ret < 0)
 272             return ret;
 273     }
 274     if (avctx->qmax >= 0) {
 275         ret = libx265_param_parse_int(avctx, "qpmax", avctx->qmax);
 276         if (ret < 0)
 277             return ret;
 278     }
 279 #endif
 280     if (avctx->max_qdiff >= 0) {
 281         ret = libx265_param_parse_int(avctx, "qpstep", avctx->max_qdiff);
 282         if (ret < 0)
 283             return ret;
 284     }
 285     if (avctx->qblur >= 0) {
 286         ret = libx265_param_parse_float(avctx, "qblur", avctx->qblur);
 287         if (ret < 0)
 288             return ret;
 289     }
 290     if (avctx->qcompress >= 0) {
 291         ret = libx265_param_parse_float(avctx, "qcomp", avctx->qcompress);
 292         if (ret < 0)
 293             return ret;
 294     }
 295     if (avctx->i_quant_factor >= 0) {
 296         ret = libx265_param_parse_float(avctx, "ipratio", avctx->i_quant_factor);
 297         if (ret < 0)
 298             return ret;
 299     }
 300     if (avctx->b_quant_factor >= 0) {
 301         ret = libx265_param_parse_float(avctx, "pbratio", avctx->b_quant_factor);
 302         if (ret < 0)
 303             return ret;
 304     }
 305
 306     ctx->params->rc.vbvBufferSize = avctx->rc_buffer_size / 1000;
 307     ctx->params->rc.vbvMaxBitrate = avctx->rc_max_rate    / 1000;
 308
 309     cpb_props = ff_add_cpb_side_data(avctx);
 310     if (!cpb_props)
 311         return AVERROR(ENOMEM);
 312     cpb_props->buffer_size = ctx->params->rc.vbvBufferSize * 1000;
 313     cpb_props->max_bitrate = ctx->params->rc.vbvMaxBitrate * 1000LL;
 314     cpb_props->avg_bitrate = ctx->params->rc.bitrate       * 1000LL;
 315
 316     if (!(avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER))
 317         ctx->params->bRepeatHeaders = 1;
 318
 319     if (avctx->gop_size >= 0) {
 320         ret = libx265_param_parse_int(avctx, "keyint", avctx->gop_size);
 321         if (ret < 0)
 322             return ret;
 323     }
 324     if (avctx->keyint_min > 0) {
 325         ret = libx265_param_parse_int(avctx, "min-keyint", avctx->keyint_min);
 326         if (ret < 0)
 327             return ret;
 328     }
 329     if (avctx->max_b_frames >= 0) {
 330         ret = libx265_param_parse_int(avctx, "bframes", avctx->max_b_frames);
 331         if (ret < 0)
 332             return ret;
 333     }
 334     if (avctx->refs >= 0) {
 335         ret = libx265_param_parse_int(avctx, "ref", avctx->refs);
 336         if (ret < 0)
 337             return ret;
 338     }
 339
 340     {
 341         AVDictionaryEntry *en = NULL;
 342         while ((en = av_dict_get(ctx->x265_opts, "", en, AV_DICT_IGNORE_SUFFIX))) {
 343             int parse_ret = ctx->api->param_parse(ctx->params, en->key, en->value);
 344
 345             switch (parse_ret) {
 346             case X265_PARAM_BAD_NAME:
 347                 av_log(avctx, AV_LOG_WARNING,
 348                       "Unknown option: %s.\n", en->key);
 349                 break;
 350             case X265_PARAM_BAD_VALUE:
 351                 av_log(avctx, AV_LOG_WARNING,
 352                       "Invalid value for %s: %s.\n", en->key, en->value);
 353                 break;
 354             default:
 355                 break;
 356             }
 357         }
 358     }
 359
 360     if (ctx->params->rc.vbvBufferSize && avctx->rc_initial_buffer_occupancy > 1000 &&
 361         ctx->params->rc.vbvBufferInit == 0.9) {
 362         ctx->params->rc.vbvBufferInit = (float)avctx->rc_initial_buffer_occupancy / 1000;
 363     }
 364
 365     if (ctx->profile) {
 366         if (ctx->api->param_apply_profile(ctx->params, ctx->profile) < 0) {
 367             int i;
 368             av_log(avctx, AV_LOG_ERROR, "Invalid or incompatible profile set: %s.\n", ctx->profile);
 369             av_log(avctx, AV_LOG_INFO, "Possible profiles:");
 370             for (i = 0; x265_profile_names[i]; i++)
 371                 av_log(avctx, AV_LOG_INFO, " %s", x265_profile_names[i]);
 372             av_log(avctx, AV_LOG_INFO, "\n");
 373             return AVERROR(EINVAL);
 374         }
 375     }
 376
 377     ctx->encoder = ctx->api->encoder_open(ctx->params);
 378     if (!ctx->encoder) {
 379         av_log(avctx, AV_LOG_ERROR, "Cannot open libx265 encoder.\n");
 380         libx265_encode_close(avctx);
 381         return AVERROR_INVALIDDATA;
 382     }
 383
 384     if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
 385         x265_nal *nal;
 386         int nnal;
 387
 388         avctx->extradata_size = ctx->api->encoder_headers(ctx->encoder, &nal, &nnal);
 389         if (avctx->extradata_size <= 0) {
 390             av_log(avctx, AV_LOG_ERROR, "Cannot encode headers.\n");
 391             libx265_encode_close(avctx);
 392             return AVERROR_INVALIDDATA;
 393         }
 394
 395         avctx->extradata = av_malloc(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
 396         if (!avctx->extradata) {
 397             av_log(avctx, AV_LOG_ERROR,
 398                    "Cannot allocate HEVC header of size %d.\n", avctx->extradata_size);
 399             libx265_encode_close(avctx);
 400             return AVERROR(ENOMEM);
 401         }
 402
 403         memcpy(avctx->extradata, nal[0].payload, avctx->extradata_size);
 404         memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
 405     }
 406
 407     return 0;
 408 }
 409
 410 static av_cold int libx265_encode_set_roi(libx265Context *ctx, const AVFrame *frame, x265_picture* pic)
 411 {
 412     AVFrameSideData *sd = av_frame_get_side_data(frame, AV_FRAME_DATA_REGIONS_OF_INTEREST);
 413     if (sd) {
 414         if (ctx->params->rc.aqMode == X265_AQ_NONE) {
 415             if (!ctx->roi_warned) {
 416                 ctx->roi_warned = 1;
 417                 av_log(ctx, AV_LOG_WARNING, "Adaptive quantization must be enabled to use ROI encoding, skipping ROI.\n");
 418             }
 419         } else {
 420             /* 8x8 block when qg-size is 8, 16*16 block otherwise. */
 421             int mb_size = (ctx->params->rc.qgSize == 8) ? 8 : 16;
 422             int mbx = (frame->width + mb_size - 1) / mb_size;
 423             int mby = (frame->height + mb_size - 1) / mb_size;
 424             int qp_range = 51 + 6 * (pic->bitDepth - 8);
 425             int nb_rois;
 426             const AVRegionOfInterest *roi;
 427             uint32_t roi_size;
 428             float *qoffsets;         /* will be freed after encode is called. */
 429
 430             roi = (const AVRegionOfInterest*)sd->data;
 431             roi_size = roi->self_size;
 432             if (!roi_size || sd->size % roi_size != 0) {
 433                 av_log(ctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.\n");
 434                 return AVERROR(EINVAL);
 435             }
 436             nb_rois = sd->size / roi_size;
 437
 438             qoffsets = av_mallocz_array(mbx * mby, sizeof(*qoffsets));
 439             if (!qoffsets)
 440                 return AVERROR(ENOMEM);
 441
 442             // This list must be iterated in reverse because the first
 443             // region in the list applies when regions overlap.
 444             for (int i = nb_rois - 1; i >= 0; i--) {
 445                 int startx, endx, starty, endy;
 446                 float qoffset;
 447
 448                 roi = (const AVRegionOfInterest*)(sd->data + roi_size * i);
 449
 450                 starty = FFMIN(mby, roi->top / mb_size);
 451                 endy   = FFMIN(mby, (roi->bottom + mb_size - 1)/ mb_size);
 452                 startx = FFMIN(mbx, roi->left / mb_size);
 453                 endx   = FFMIN(mbx, (roi->right + mb_size - 1)/ mb_size);
 454
 455                 if (roi->qoffset.den == 0) {
 456                     av_free(qoffsets);
 457                     av_log(ctx, AV_LOG_ERROR, "AVRegionOfInterest.qoffset.den must not be zero.\n");
 458                     return AVERROR(EINVAL);
 459                 }
 460                 qoffset = roi->qoffset.num * 1.0f / roi->qoffset.den;
 461                 qoffset = av_clipf(qoffset * qp_range, -qp_range, +qp_range);
 462
 463                 for (int y = starty; y < endy; y++)
 464                     for (int x = startx; x < endx; x++)
 465                         qoffsets[x + y*mbx] = qoffset;
 466             }
 467
 468             pic->quantOffsets = qoffsets;
 469         }
 470     }
 471     return 0;
 472 }
 473
 474 static int libx265_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
 475                                 const AVFrame *pic, int *got_packet)
 476 {
 477     libx265Context *ctx = avctx->priv_data;
 478     x265_picture x265pic;
 479     x265_picture x265pic_out = { 0 };
 480     x265_nal *nal;
 481     uint8_t *dst;
 482     int pict_type;
 483     int payload = 0;
 484     int nnal;
 485     int ret;
 486     int i;
 487
 488     ctx->api->picture_init(ctx->params, &x265pic);
 489
 490     if (pic) {
 491         for (i = 0; i < 3; i++) {
 492            x265pic.planes[i] = pic->data[i];
 493            x265pic.stride[i] = pic->linesize[i];
 494         }
 495
 496         x265pic.pts      = pic->pts;
 497         x265pic.bitDepth = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth;
 498
 499         x265pic.sliceType = pic->pict_type == AV_PICTURE_TYPE_I ?
 500                                               (ctx->forced_idr ? X265_TYPE_IDR : X265_TYPE_I) :
 501                             pic->pict_type == AV_PICTURE_TYPE_P ? X265_TYPE_P :
 502                             pic->pict_type == AV_PICTURE_TYPE_B ? X265_TYPE_B :
 503                             X265_TYPE_AUTO;
 504
 505         ret = libx265_encode_set_roi(ctx, pic, &x265pic);
 506         if (ret < 0)
 507             return ret;
 508
 509         if (pic->reordered_opaque) {
 510             x265pic.userData = av_malloc(sizeof(pic->reordered_opaque));
 511             if (!x265pic.userData) {
 512                 av_freep(&x265pic.quantOffsets);
 513                 return AVERROR(ENOMEM);
 514             }
 515
 516             memcpy(x265pic.userData, &pic->reordered_opaque, sizeof(pic->reordered_opaque));
 517         }
 518     }
 519
 520     ret = ctx->api->encoder_encode(ctx->encoder, &nal, &nnal,
 521                                    pic ? &x265pic : NULL, &x265pic_out);
 522
 523     av_freep(&x265pic.quantOffsets);
 524
 525     if (ret < 0)
 526         return AVERROR_EXTERNAL;
 527
 528     if (!nnal)
 529         return 0;
 530
 531     for (i = 0; i < nnal; i++)
 532         payload += nal[i].sizeBytes;
 533
 534     ret = ff_alloc_packet2(avctx, pkt, payload, payload);
 535     if (ret < 0) {
 536         av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
 537         return ret;
 538     }
 539     dst = pkt->data;
 540
 541     for (i = 0; i < nnal; i++) {
 542         memcpy(dst, nal[i].payload, nal[i].sizeBytes);
 543         dst += nal[i].sizeBytes;
 544
 545         if (is_keyframe(nal[i].type))
 546             pkt->flags |= AV_PKT_FLAG_KEY;
 547     }
 548
 549     pkt->pts = x265pic_out.pts;
 550     pkt->dts = x265pic_out.dts;
 551
 552     switch (x265pic_out.sliceType) {
 553     case X265_TYPE_IDR:
 554     case X265_TYPE_I:
 555         pict_type = AV_PICTURE_TYPE_I;
 556         break;
 557     case X265_TYPE_P:
 558         pict_type = AV_PICTURE_TYPE_P;
 559         break;
 560     case X265_TYPE_B:
 561     case X265_TYPE_BREF:
 562         pict_type = AV_PICTURE_TYPE_B;
 563         break;
 564     default:
 565         av_log(avctx, AV_LOG_ERROR, "Unknown picture type encountered.\n");
 566         return AVERROR_EXTERNAL;
 567     }
 568
 569 #if X265_BUILD >= 130
 570     if (x265pic_out.sliceType == X265_TYPE_B)
 571 #else
 572     if (x265pic_out.frameData.sliceType == 'b')
 573 #endif
 574         pkt->flags |= AV_PKT_FLAG_DISPOSABLE;
 575
 576     ff_side_data_set_encoder_stats(pkt, x265pic_out.frameData.qp * FF_QP2LAMBDA, NULL, 0, pict_type);
 577
 578     if (x265pic_out.userData) {
 579         memcpy(&avctx->reordered_opaque, x265pic_out.userData, sizeof(avctx->reordered_opaque));
 580         av_freep(&x265pic_out.userData);
 581     } else
 582         avctx->reordered_opaque = 0;
 583
 584     *got_packet = 1;
 585     return 0;
 586 }
 587
 588 static const enum AVPixelFormat x265_csp_eight[] = {
 589     AV_PIX_FMT_YUV420P,
 590     AV_PIX_FMT_YUVJ420P,
 591     AV_PIX_FMT_YUV422P,
 592     AV_PIX_FMT_YUVJ422P,
 593     AV_PIX_FMT_YUV444P,
 594     AV_PIX_FMT_YUVJ444P,
 595     AV_PIX_FMT_GBRP,
 596     AV_PIX_FMT_GRAY8,
 597     AV_PIX_FMT_NONE
 598 };
 599
 600 static const enum AVPixelFormat x265_csp_ten[] = {
 601     AV_PIX_FMT_YUV420P,
 602     AV_PIX_FMT_YUVJ420P,
 603     AV_PIX_FMT_YUV422P,
 604     AV_PIX_FMT_YUVJ422P,
 605     AV_PIX_FMT_YUV444P,
 606     AV_PIX_FMT_YUVJ444P,
 607     AV_PIX_FMT_GBRP,
 608     AV_PIX_FMT_YUV420P10,
 609     AV_PIX_FMT_YUV422P10,
 610     AV_PIX_FMT_YUV444P10,
 611     AV_PIX_FMT_GBRP10,
 612     AV_PIX_FMT_GRAY8,
 613     AV_PIX_FMT_GRAY10,
 614     AV_PIX_FMT_NONE
 615 };
 616
 617 static const enum AVPixelFormat x265_csp_twelve[] = {
 618     AV_PIX_FMT_YUV420P,
 619     AV_PIX_FMT_YUVJ420P,
 620     AV_PIX_FMT_YUV422P,
 621     AV_PIX_FMT_YUVJ422P,
 622     AV_PIX_FMT_YUV444P,
 623     AV_PIX_FMT_YUVJ444P,
 624     AV_PIX_FMT_GBRP,
 625     AV_PIX_FMT_YUV420P10,
 626     AV_PIX_FMT_YUV422P10,
 627     AV_PIX_FMT_YUV444P10,
 628     AV_PIX_FMT_GBRP10,
 629     AV_PIX_FMT_YUV420P12,
 630     AV_PIX_FMT_YUV422P12,
 631     AV_PIX_FMT_YUV444P12,
 632     AV_PIX_FMT_GBRP12,
 633     AV_PIX_FMT_GRAY8,
 634     AV_PIX_FMT_GRAY10,
 635     AV_PIX_FMT_GRAY12,
 636     AV_PIX_FMT_NONE
 637 };
 638
 639 static av_cold void libx265_encode_init_csp(AVCodec *codec)
 640 {
 641     if (x265_api_get(12))
 642         codec->pix_fmts = x265_csp_twelve;
 643     else if (x265_api_get(10))
 644         codec->pix_fmts = x265_csp_ten;
 645     else if (x265_api_get(8))
 646         codec->pix_fmts = x265_csp_eight;
 647 }
 648
 649 #define OFFSET(x) offsetof(libx265Context, x)
 650 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 651 static const AVOption options[] = {
 652     { "crf",         "set the x265 crf",                                                            OFFSET(crf),       AV_OPT_TYPE_FLOAT,  { .dbl = -1 }, -1, FLT_MAX, VE },
 653     { "qp",          "set the x265 qp",                                                             OFFSET(cqp),       AV_OPT_TYPE_INT,    { .i64 = -1 }, -1, INT_MAX, VE },
 654     { "forced-idr",  "if forcing keyframes, force them as IDR frames",                              OFFSET(forced_idr),AV_OPT_TYPE_BOOL,   { .i64 =  0 },  0,       1, VE },
 655     { "preset",      "set the x265 preset",                                                         OFFSET(preset),    AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
 656     { "tune",        "set the x265 tune parameter",                                                 OFFSET(tune),      AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
 657     { "profile",     "set the x265 profile",                                                        OFFSET(profile),   AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
 658     { "x265-params", "set the x265 configuration using a :-separated list of key=value parameters", OFFSET(x265_opts), AV_OPT_TYPE_DICT,   { 0 }, 0, 0, VE },
 659     { NULL }
 660 };
 661
 662 static const AVClass class = {
 663     .class_name = "libx265",
 664     .item_name  = av_default_item_name,
 665     .option     = options,
 666     .version    = LIBAVUTIL_VERSION_INT,
 667 };
 668
 669 static const AVCodecDefault x265_defaults[] = {
 670     { "b", "0" },
 671     { "bf", "-1" },
 672     { "g", "-1" },
 673     { "keyint_min", "-1" },
 674     { "refs", "-1" },
 675     { "qmin", "-1" },
 676     { "qmax", "-1" },
 677     { "qdiff", "-1" },
 678     { "qblur", "-1" },
 679     { "qcomp", "-1" },
 680     { "i_qfactor", "-1" },
 681     { "b_qfactor", "-1" },
 682     { NULL },
 683 };
 684
 685 AVCodec ff_libx265_encoder = {
 686     .name             = "libx265",
 687     .long_name        = NULL_IF_CONFIG_SMALL("libx265 H.265 / HEVC"),
 688     .type             = AVMEDIA_TYPE_VIDEO,
 689     .id               = AV_CODEC_ID_HEVC,
 690     .init             = libx265_encode_init,
 691     .init_static_data = libx265_encode_init_csp,
 692     .encode2          = libx265_encode_frame,
 693     .close            = libx265_encode_close,
 694     .priv_data_size   = sizeof(libx265Context),
 695     .priv_class       = &class,
 696     .defaults         = x265_defaults,
 697     .capabilities     = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_OTHER_THREADS |
 698                         AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
 699     .caps_internal    = FF_CODEC_CAP_AUTO_THREADS,
 700     .wrapper_name     = "libx265",
 701 };