avformat/id3v2: Check against max compression ratio before allocation
[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 "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 FF_API_CODED_FRAME
570 FF_DISABLE_DEPRECATION_WARNINGS
571     avctx->coded_frame->pict_type = pict_type;
572 FF_ENABLE_DEPRECATION_WARNINGS
573 #endif
574
575 #if X265_BUILD >= 130
576     if (x265pic_out.sliceType == X265_TYPE_B)
577 #else
578     if (x265pic_out.frameData.sliceType == 'b')
579 #endif
580         pkt->flags |= AV_PKT_FLAG_DISPOSABLE;
581
582     ff_side_data_set_encoder_stats(pkt, x265pic_out.frameData.qp * FF_QP2LAMBDA, NULL, 0, pict_type);
583
584     if (x265pic_out.userData) {
585         memcpy(&avctx->reordered_opaque, x265pic_out.userData, sizeof(avctx->reordered_opaque));
586         av_freep(&x265pic_out.userData);
587     } else
588         avctx->reordered_opaque = 0;
589
590     *got_packet = 1;
591     return 0;
592 }
593
594 static const enum AVPixelFormat x265_csp_eight[] = {
595     AV_PIX_FMT_YUV420P,
596     AV_PIX_FMT_YUVJ420P,
597     AV_PIX_FMT_YUV422P,
598     AV_PIX_FMT_YUVJ422P,
599     AV_PIX_FMT_YUV444P,
600     AV_PIX_FMT_YUVJ444P,
601     AV_PIX_FMT_GBRP,
602     AV_PIX_FMT_GRAY8,
603     AV_PIX_FMT_NONE
604 };
605
606 static const enum AVPixelFormat x265_csp_ten[] = {
607     AV_PIX_FMT_YUV420P,
608     AV_PIX_FMT_YUVJ420P,
609     AV_PIX_FMT_YUV422P,
610     AV_PIX_FMT_YUVJ422P,
611     AV_PIX_FMT_YUV444P,
612     AV_PIX_FMT_YUVJ444P,
613     AV_PIX_FMT_GBRP,
614     AV_PIX_FMT_YUV420P10,
615     AV_PIX_FMT_YUV422P10,
616     AV_PIX_FMT_YUV444P10,
617     AV_PIX_FMT_GBRP10,
618     AV_PIX_FMT_GRAY8,
619     AV_PIX_FMT_GRAY10,
620     AV_PIX_FMT_NONE
621 };
622
623 static const enum AVPixelFormat x265_csp_twelve[] = {
624     AV_PIX_FMT_YUV420P,
625     AV_PIX_FMT_YUVJ420P,
626     AV_PIX_FMT_YUV422P,
627     AV_PIX_FMT_YUVJ422P,
628     AV_PIX_FMT_YUV444P,
629     AV_PIX_FMT_YUVJ444P,
630     AV_PIX_FMT_GBRP,
631     AV_PIX_FMT_YUV420P10,
632     AV_PIX_FMT_YUV422P10,
633     AV_PIX_FMT_YUV444P10,
634     AV_PIX_FMT_GBRP10,
635     AV_PIX_FMT_YUV420P12,
636     AV_PIX_FMT_YUV422P12,
637     AV_PIX_FMT_YUV444P12,
638     AV_PIX_FMT_GBRP12,
639     AV_PIX_FMT_GRAY8,
640     AV_PIX_FMT_GRAY10,
641     AV_PIX_FMT_GRAY12,
642     AV_PIX_FMT_NONE
643 };
644
645 static av_cold void libx265_encode_init_csp(AVCodec *codec)
646 {
647     if (x265_api_get(12))
648         codec->pix_fmts = x265_csp_twelve;
649     else if (x265_api_get(10))
650         codec->pix_fmts = x265_csp_ten;
651     else if (x265_api_get(8))
652         codec->pix_fmts = x265_csp_eight;
653 }
654
655 #define OFFSET(x) offsetof(libx265Context, x)
656 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
657 static const AVOption options[] = {
658     { "crf",         "set the x265 crf",                                                            OFFSET(crf),       AV_OPT_TYPE_FLOAT,  { .dbl = -1 }, -1, FLT_MAX, VE },
659     { "qp",          "set the x265 qp",                                                             OFFSET(cqp),       AV_OPT_TYPE_INT,    { .i64 = -1 }, -1, INT_MAX, VE },
660     { "forced-idr",  "if forcing keyframes, force them as IDR frames",                              OFFSET(forced_idr),AV_OPT_TYPE_BOOL,   { .i64 =  0 },  0,       1, VE },
661     { "preset",      "set the x265 preset",                                                         OFFSET(preset),    AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
662     { "tune",        "set the x265 tune parameter",                                                 OFFSET(tune),      AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
663     { "profile",     "set the x265 profile",                                                        OFFSET(profile),   AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
664     { "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 },
665     { NULL }
666 };
667
668 static const AVClass class = {
669     .class_name = "libx265",
670     .item_name  = av_default_item_name,
671     .option     = options,
672     .version    = LIBAVUTIL_VERSION_INT,
673 };
674
675 static const AVCodecDefault x265_defaults[] = {
676     { "b", "0" },
677     { "bf", "-1" },
678     { "g", "-1" },
679     { "keyint_min", "-1" },
680     { "refs", "-1" },
681     { "qmin", "-1" },
682     { "qmax", "-1" },
683     { "qdiff", "-1" },
684     { "qblur", "-1" },
685     { "qcomp", "-1" },
686     { "i_qfactor", "-1" },
687     { "b_qfactor", "-1" },
688     { NULL },
689 };
690
691 AVCodec ff_libx265_encoder = {
692     .name             = "libx265",
693     .long_name        = NULL_IF_CONFIG_SMALL("libx265 H.265 / HEVC"),
694     .type             = AVMEDIA_TYPE_VIDEO,
695     .id               = AV_CODEC_ID_HEVC,
696     .init             = libx265_encode_init,
697     .init_static_data = libx265_encode_init_csp,
698     .encode2          = libx265_encode_frame,
699     .close            = libx265_encode_close,
700     .priv_data_size   = sizeof(libx265Context),
701     .priv_class       = &class,
702     .defaults         = x265_defaults,
703     .capabilities     = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS |
704                         AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
705     .wrapper_name     = "libx265",
706 };