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