GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/vaapi_encode.c Lines: 0 1306 0.0 %
Date: 2021-04-22 14:24:15 Branches: 0 830 0.0 %

Line Branch Exec Source
1
/*
2
 * This file is part of FFmpeg.
3
 *
4
 * FFmpeg is free software; you can redistribute it and/or
5
 * modify it under the terms of the GNU Lesser General Public
6
 * License as published by the Free Software Foundation; either
7
 * version 2.1 of the License, or (at your option) any later version.
8
 *
9
 * FFmpeg is distributed in the hope that it will be useful,
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12
 * Lesser General Public License for more details.
13
 *
14
 * You should have received a copy of the GNU Lesser General Public
15
 * License along with FFmpeg; if not, write to the Free Software
16
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
 */
18
19
#include <inttypes.h>
20
#include <string.h>
21
22
#include "libavutil/avassert.h"
23
#include "libavutil/common.h"
24
#include "libavutil/internal.h"
25
#include "libavutil/log.h"
26
#include "libavutil/pixdesc.h"
27
28
#include "vaapi_encode.h"
29
#include "encode.h"
30
#include "avcodec.h"
31
32
const AVCodecHWConfigInternal *const ff_vaapi_encode_hw_configs[] = {
33
    HW_CONFIG_ENCODER_FRAMES(VAAPI, VAAPI),
34
    NULL,
35
};
36
37
static const char * const picture_type_name[] = { "IDR", "I", "P", "B" };
38
39
static int vaapi_encode_make_packed_header(AVCodecContext *avctx,
40
                                           VAAPIEncodePicture *pic,
41
                                           int type, char *data, size_t bit_len)
42
{
43
    VAAPIEncodeContext *ctx = avctx->priv_data;
44
    VAStatus vas;
45
    VABufferID param_buffer, data_buffer;
46
    VABufferID *tmp;
47
    VAEncPackedHeaderParameterBuffer params = {
48
        .type = type,
49
        .bit_length = bit_len,
50
        .has_emulation_bytes = 1,
51
    };
52
53
    tmp = av_realloc_array(pic->param_buffers, sizeof(*tmp), pic->nb_param_buffers + 2);
54
    if (!tmp)
55
        return AVERROR(ENOMEM);
56
    pic->param_buffers = tmp;
57
58
    vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,
59
                         VAEncPackedHeaderParameterBufferType,
60
                         sizeof(params), 1, &params, &param_buffer);
61
    if (vas != VA_STATUS_SUCCESS) {
62
        av_log(avctx, AV_LOG_ERROR, "Failed to create parameter buffer "
63
               "for packed header (type %d): %d (%s).\n",
64
               type, vas, vaErrorStr(vas));
65
        return AVERROR(EIO);
66
    }
67
    pic->param_buffers[pic->nb_param_buffers++] = param_buffer;
68
69
    vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,
70
                         VAEncPackedHeaderDataBufferType,
71
                         (bit_len + 7) / 8, 1, data, &data_buffer);
72
    if (vas != VA_STATUS_SUCCESS) {
73
        av_log(avctx, AV_LOG_ERROR, "Failed to create data buffer "
74
               "for packed header (type %d): %d (%s).\n",
75
               type, vas, vaErrorStr(vas));
76
        return AVERROR(EIO);
77
    }
78
    pic->param_buffers[pic->nb_param_buffers++] = data_buffer;
79
80
    av_log(avctx, AV_LOG_DEBUG, "Packed header buffer (%d) is %#x/%#x "
81
           "(%zu bits).\n", type, param_buffer, data_buffer, bit_len);
82
    return 0;
83
}
84
85
static int vaapi_encode_make_param_buffer(AVCodecContext *avctx,
86
                                          VAAPIEncodePicture *pic,
87
                                          int type, char *data, size_t len)
88
{
89
    VAAPIEncodeContext *ctx = avctx->priv_data;
90
    VAStatus vas;
91
    VABufferID *tmp;
92
    VABufferID buffer;
93
94
    tmp = av_realloc_array(pic->param_buffers, sizeof(*tmp), pic->nb_param_buffers + 1);
95
    if (!tmp)
96
        return AVERROR(ENOMEM);
97
    pic->param_buffers = tmp;
98
99
    vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,
100
                         type, len, 1, data, &buffer);
101
    if (vas != VA_STATUS_SUCCESS) {
102
        av_log(avctx, AV_LOG_ERROR, "Failed to create parameter buffer "
103
               "(type %d): %d (%s).\n", type, vas, vaErrorStr(vas));
104
        return AVERROR(EIO);
105
    }
106
    pic->param_buffers[pic->nb_param_buffers++] = buffer;
107
108
    av_log(avctx, AV_LOG_DEBUG, "Param buffer (%d) is %#x.\n",
109
           type, buffer);
110
    return 0;
111
}
112
113
static int vaapi_encode_make_misc_param_buffer(AVCodecContext *avctx,
114
                                               VAAPIEncodePicture *pic,
115
                                               int type,
116
                                               const void *data, size_t len)
117
{
118
    // Construct the buffer on the stack - 1KB is much larger than any
119
    // current misc parameter buffer type (the largest is EncQuality at
120
    // 224 bytes).
121
    uint8_t buffer[1024];
122
    VAEncMiscParameterBuffer header = {
123
        .type = type,
124
    };
125
    size_t buffer_size = sizeof(header) + len;
126
    av_assert0(buffer_size <= sizeof(buffer));
127
128
    memcpy(buffer, &header, sizeof(header));
129
    memcpy(buffer + sizeof(header), data, len);
130
131
    return vaapi_encode_make_param_buffer(avctx, pic,
132
                                          VAEncMiscParameterBufferType,
133
                                          buffer, buffer_size);
134
}
135
136
static int vaapi_encode_wait(AVCodecContext *avctx,
137
                             VAAPIEncodePicture *pic)
138
{
139
    VAAPIEncodeContext *ctx = avctx->priv_data;
140
    VAStatus vas;
141
142
    av_assert0(pic->encode_issued);
143
144
    if (pic->encode_complete) {
145
        // Already waited for this picture.
146
        return 0;
147
    }
148
149
    av_log(avctx, AV_LOG_DEBUG, "Sync to pic %"PRId64"/%"PRId64" "
150
           "(input surface %#x).\n", pic->display_order,
151
           pic->encode_order, pic->input_surface);
152
153
    vas = vaSyncSurface(ctx->hwctx->display, pic->input_surface);
154
    if (vas != VA_STATUS_SUCCESS) {
155
        av_log(avctx, AV_LOG_ERROR, "Failed to sync to picture completion: "
156
               "%d (%s).\n", vas, vaErrorStr(vas));
157
        return AVERROR(EIO);
158
    }
159
160
    // Input is definitely finished with now.
161
    av_frame_free(&pic->input_image);
162
163
    pic->encode_complete = 1;
164
    return 0;
165
}
166
167
static int vaapi_encode_make_row_slice(AVCodecContext *avctx,
168
                                       VAAPIEncodePicture *pic)
169
{
170
    VAAPIEncodeContext *ctx = avctx->priv_data;
171
    VAAPIEncodeSlice *slice;
172
    int i, rounding;
173
174
    for (i = 0; i < pic->nb_slices; i++)
175
        pic->slices[i].row_size = ctx->slice_size;
176
177
    rounding = ctx->slice_block_rows - ctx->nb_slices * ctx->slice_size;
178
    if (rounding > 0) {
179
        // Place rounding error at top and bottom of frame.
180
        av_assert0(rounding < pic->nb_slices);
181
        // Some Intel drivers contain a bug where the encoder will fail
182
        // if the last slice is smaller than the one before it.  Since
183
        // that's straightforward to avoid here, just do so.
184
        if (rounding <= 2) {
185
            for (i = 0; i < rounding; i++)
186
                ++pic->slices[i].row_size;
187
        } else {
188
            for (i = 0; i < (rounding + 1) / 2; i++)
189
                ++pic->slices[pic->nb_slices - i - 1].row_size;
190
            for (i = 0; i < rounding / 2; i++)
191
                ++pic->slices[i].row_size;
192
        }
193
    } else if (rounding < 0) {
194
        // Remove rounding error from last slice only.
195
        av_assert0(rounding < ctx->slice_size);
196
        pic->slices[pic->nb_slices - 1].row_size += rounding;
197
    }
198
199
    for (i = 0; i < pic->nb_slices; i++) {
200
        slice = &pic->slices[i];
201
        slice->index = i;
202
        if (i == 0) {
203
            slice->row_start   = 0;
204
            slice->block_start = 0;
205
        } else {
206
            const VAAPIEncodeSlice *prev = &pic->slices[i - 1];
207
            slice->row_start   = prev->row_start   + prev->row_size;
208
            slice->block_start = prev->block_start + prev->block_size;
209
        }
210
        slice->block_size  = slice->row_size * ctx->slice_block_cols;
211
212
        av_log(avctx, AV_LOG_DEBUG, "Slice %d: %d-%d (%d rows), "
213
               "%d-%d (%d blocks).\n", i, slice->row_start,
214
               slice->row_start + slice->row_size - 1, slice->row_size,
215
               slice->block_start, slice->block_start + slice->block_size - 1,
216
               slice->block_size);
217
    }
218
219
    return 0;
220
}
221
222
static int vaapi_encode_make_tile_slice(AVCodecContext *avctx,
223
                                        VAAPIEncodePicture *pic)
224
{
225
    VAAPIEncodeContext *ctx = avctx->priv_data;
226
    VAAPIEncodeSlice *slice;
227
    int i, j, index;
228
229
    for (i = 0; i < ctx->tile_cols; i++) {
230
        for (j = 0; j < ctx->tile_rows; j++) {
231
            index        = j * ctx->tile_cols + i;
232
            slice        = &pic->slices[index];
233
            slice->index = index;
234
235
            pic->slices[index].block_start = ctx->col_bd[i] +
236
                                             ctx->row_bd[j] * ctx->slice_block_cols;
237
            pic->slices[index].block_size  = ctx->row_height[j] * ctx->col_width[i];
238
239
            av_log(avctx, AV_LOG_DEBUG, "Slice %2d: (%2d, %2d) start at: %4d "
240
               "width:%2d height:%2d (%d blocks).\n", index, ctx->col_bd[i],
241
               ctx->row_bd[j], slice->block_start, ctx->col_width[i],
242
               ctx->row_height[j], slice->block_size);
243
        }
244
    }
245
246
    return 0;
247
}
248
249
static int vaapi_encode_issue(AVCodecContext *avctx,
250
                              VAAPIEncodePicture *pic)
251
{
252
    VAAPIEncodeContext *ctx = avctx->priv_data;
253
    VAAPIEncodeSlice *slice;
254
    VAStatus vas;
255
    int err, i;
256
    char data[MAX_PARAM_BUFFER_SIZE];
257
    size_t bit_len;
258
    av_unused AVFrameSideData *sd;
259
260
    av_log(avctx, AV_LOG_DEBUG, "Issuing encode for pic %"PRId64"/%"PRId64" "
261
           "as type %s.\n", pic->display_order, pic->encode_order,
262
           picture_type_name[pic->type]);
263
    if (pic->nb_refs == 0) {
264
        av_log(avctx, AV_LOG_DEBUG, "No reference pictures.\n");
265
    } else {
266
        av_log(avctx, AV_LOG_DEBUG, "Refers to:");
267
        for (i = 0; i < pic->nb_refs; i++) {
268
            av_log(avctx, AV_LOG_DEBUG, " %"PRId64"/%"PRId64,
269
                   pic->refs[i]->display_order, pic->refs[i]->encode_order);
270
        }
271
        av_log(avctx, AV_LOG_DEBUG, ".\n");
272
    }
273
274
    av_assert0(!pic->encode_issued);
275
    for (i = 0; i < pic->nb_refs; i++) {
276
        av_assert0(pic->refs[i]);
277
        av_assert0(pic->refs[i]->encode_issued);
278
    }
279
280
    av_log(avctx, AV_LOG_DEBUG, "Input surface is %#x.\n", pic->input_surface);
281
282
    pic->recon_image = av_frame_alloc();
283
    if (!pic->recon_image) {
284
        err = AVERROR(ENOMEM);
285
        goto fail;
286
    }
287
288
    err = av_hwframe_get_buffer(ctx->recon_frames_ref, pic->recon_image, 0);
289
    if (err < 0) {
290
        err = AVERROR(ENOMEM);
291
        goto fail;
292
    }
293
    pic->recon_surface = (VASurfaceID)(uintptr_t)pic->recon_image->data[3];
294
    av_log(avctx, AV_LOG_DEBUG, "Recon surface is %#x.\n", pic->recon_surface);
295
296
    pic->output_buffer_ref = av_buffer_pool_get(ctx->output_buffer_pool);
297
    if (!pic->output_buffer_ref) {
298
        err = AVERROR(ENOMEM);
299
        goto fail;
300
    }
301
    pic->output_buffer = (VABufferID)(uintptr_t)pic->output_buffer_ref->data;
302
    av_log(avctx, AV_LOG_DEBUG, "Output buffer is %#x.\n",
303
           pic->output_buffer);
304
305
    if (ctx->codec->picture_params_size > 0) {
306
        pic->codec_picture_params = av_malloc(ctx->codec->picture_params_size);
307
        if (!pic->codec_picture_params)
308
            goto fail;
309
        memcpy(pic->codec_picture_params, ctx->codec_picture_params,
310
               ctx->codec->picture_params_size);
311
    } else {
312
        av_assert0(!ctx->codec_picture_params);
313
    }
314
315
    pic->nb_param_buffers = 0;
316
317
    if (pic->type == PICTURE_TYPE_IDR && ctx->codec->init_sequence_params) {
318
        err = vaapi_encode_make_param_buffer(avctx, pic,
319
                                             VAEncSequenceParameterBufferType,
320
                                             ctx->codec_sequence_params,
321
                                             ctx->codec->sequence_params_size);
322
        if (err < 0)
323
            goto fail;
324
    }
325
326
    if (pic->type == PICTURE_TYPE_IDR) {
327
        for (i = 0; i < ctx->nb_global_params; i++) {
328
            err = vaapi_encode_make_misc_param_buffer(avctx, pic,
329
                                                      ctx->global_params_type[i],
330
                                                      ctx->global_params[i],
331
                                                      ctx->global_params_size[i]);
332
            if (err < 0)
333
                goto fail;
334
        }
335
    }
336
337
    if (ctx->codec->init_picture_params) {
338
        err = ctx->codec->init_picture_params(avctx, pic);
339
        if (err < 0) {
340
            av_log(avctx, AV_LOG_ERROR, "Failed to initialise picture "
341
                   "parameters: %d.\n", err);
342
            goto fail;
343
        }
344
        err = vaapi_encode_make_param_buffer(avctx, pic,
345
                                             VAEncPictureParameterBufferType,
346
                                             pic->codec_picture_params,
347
                                             ctx->codec->picture_params_size);
348
        if (err < 0)
349
            goto fail;
350
    }
351
352
    if (pic->type == PICTURE_TYPE_IDR) {
353
        if (ctx->va_packed_headers & VA_ENC_PACKED_HEADER_SEQUENCE &&
354
            ctx->codec->write_sequence_header) {
355
            bit_len = 8 * sizeof(data);
356
            err = ctx->codec->write_sequence_header(avctx, data, &bit_len);
357
            if (err < 0) {
358
                av_log(avctx, AV_LOG_ERROR, "Failed to write per-sequence "
359
                       "header: %d.\n", err);
360
                goto fail;
361
            }
362
            err = vaapi_encode_make_packed_header(avctx, pic,
363
                                                  ctx->codec->sequence_header_type,
364
                                                  data, bit_len);
365
            if (err < 0)
366
                goto fail;
367
        }
368
    }
369
370
    if (ctx->va_packed_headers & VA_ENC_PACKED_HEADER_PICTURE &&
371
        ctx->codec->write_picture_header) {
372
        bit_len = 8 * sizeof(data);
373
        err = ctx->codec->write_picture_header(avctx, pic, data, &bit_len);
374
        if (err < 0) {
375
            av_log(avctx, AV_LOG_ERROR, "Failed to write per-picture "
376
                   "header: %d.\n", err);
377
            goto fail;
378
        }
379
        err = vaapi_encode_make_packed_header(avctx, pic,
380
                                              ctx->codec->picture_header_type,
381
                                              data, bit_len);
382
        if (err < 0)
383
            goto fail;
384
    }
385
386
    if (ctx->codec->write_extra_buffer) {
387
        for (i = 0;; i++) {
388
            size_t len = sizeof(data);
389
            int type;
390
            err = ctx->codec->write_extra_buffer(avctx, pic, i, &type,
391
                                                 data, &len);
392
            if (err == AVERROR_EOF)
393
                break;
394
            if (err < 0) {
395
                av_log(avctx, AV_LOG_ERROR, "Failed to write extra "
396
                       "buffer %d: %d.\n", i, err);
397
                goto fail;
398
            }
399
400
            err = vaapi_encode_make_param_buffer(avctx, pic, type,
401
                                                 data, len);
402
            if (err < 0)
403
                goto fail;
404
        }
405
    }
406
407
    if (ctx->va_packed_headers & VA_ENC_PACKED_HEADER_MISC &&
408
        ctx->codec->write_extra_header) {
409
        for (i = 0;; i++) {
410
            int type;
411
            bit_len = 8 * sizeof(data);
412
            err = ctx->codec->write_extra_header(avctx, pic, i, &type,
413
                                                 data, &bit_len);
414
            if (err == AVERROR_EOF)
415
                break;
416
            if (err < 0) {
417
                av_log(avctx, AV_LOG_ERROR, "Failed to write extra "
418
                       "header %d: %d.\n", i, err);
419
                goto fail;
420
            }
421
422
            err = vaapi_encode_make_packed_header(avctx, pic, type,
423
                                                  data, bit_len);
424
            if (err < 0)
425
                goto fail;
426
        }
427
    }
428
429
    if (pic->nb_slices == 0)
430
        pic->nb_slices = ctx->nb_slices;
431
    if (pic->nb_slices > 0) {
432
        pic->slices = av_mallocz_array(pic->nb_slices, sizeof(*pic->slices));
433
        if (!pic->slices) {
434
            err = AVERROR(ENOMEM);
435
            goto fail;
436
        }
437
438
        if (ctx->tile_rows && ctx->tile_cols)
439
            vaapi_encode_make_tile_slice(avctx, pic);
440
        else
441
            vaapi_encode_make_row_slice(avctx, pic);
442
    }
443
444
    for (i = 0; i < pic->nb_slices; i++) {
445
        slice = &pic->slices[i];
446
447
        if (ctx->codec->slice_params_size > 0) {
448
            slice->codec_slice_params = av_mallocz(ctx->codec->slice_params_size);
449
            if (!slice->codec_slice_params) {
450
                err = AVERROR(ENOMEM);
451
                goto fail;
452
            }
453
        }
454
455
        if (ctx->codec->init_slice_params) {
456
            err = ctx->codec->init_slice_params(avctx, pic, slice);
457
            if (err < 0) {
458
                av_log(avctx, AV_LOG_ERROR, "Failed to initialise slice "
459
                       "parameters: %d.\n", err);
460
                goto fail;
461
            }
462
        }
463
464
        if (ctx->va_packed_headers & VA_ENC_PACKED_HEADER_SLICE &&
465
            ctx->codec->write_slice_header) {
466
            bit_len = 8 * sizeof(data);
467
            err = ctx->codec->write_slice_header(avctx, pic, slice,
468
                                                 data, &bit_len);
469
            if (err < 0) {
470
                av_log(avctx, AV_LOG_ERROR, "Failed to write per-slice "
471
                       "header: %d.\n", err);
472
                goto fail;
473
            }
474
            err = vaapi_encode_make_packed_header(avctx, pic,
475
                                                  ctx->codec->slice_header_type,
476
                                                  data, bit_len);
477
            if (err < 0)
478
                goto fail;
479
        }
480
481
        if (ctx->codec->init_slice_params) {
482
            err = vaapi_encode_make_param_buffer(avctx, pic,
483
                                                 VAEncSliceParameterBufferType,
484
                                                 slice->codec_slice_params,
485
                                                 ctx->codec->slice_params_size);
486
            if (err < 0)
487
                goto fail;
488
        }
489
    }
490
491
#if VA_CHECK_VERSION(1, 0, 0)
492
    sd = av_frame_get_side_data(pic->input_image,
493
                                AV_FRAME_DATA_REGIONS_OF_INTEREST);
494
    if (sd && ctx->roi_allowed) {
495
        const AVRegionOfInterest *roi;
496
        uint32_t roi_size;
497
        VAEncMiscParameterBufferROI param_roi;
498
        int nb_roi, i, v;
499
500
        roi = (const AVRegionOfInterest*)sd->data;
501
        roi_size = roi->self_size;
502
        av_assert0(roi_size && sd->size % roi_size == 0);
503
        nb_roi = sd->size / roi_size;
504
        if (nb_roi > ctx->roi_max_regions) {
505
            if (!ctx->roi_warned) {
506
                av_log(avctx, AV_LOG_WARNING, "More ROIs set than "
507
                       "supported by driver (%d > %d).\n",
508
                       nb_roi, ctx->roi_max_regions);
509
                ctx->roi_warned = 1;
510
            }
511
            nb_roi = ctx->roi_max_regions;
512
        }
513
514
        pic->roi = av_mallocz_array(nb_roi, sizeof(*pic->roi));
515
        if (!pic->roi) {
516
            err = AVERROR(ENOMEM);
517
            goto fail;
518
        }
519
        // For overlapping regions, the first in the array takes priority.
520
        for (i = 0; i < nb_roi; i++) {
521
            roi = (const AVRegionOfInterest*)(sd->data + roi_size * i);
522
523
            av_assert0(roi->qoffset.den != 0);
524
            v = roi->qoffset.num * ctx->roi_quant_range / roi->qoffset.den;
525
            av_log(avctx, AV_LOG_DEBUG, "ROI: (%d,%d)-(%d,%d) -> %+d.\n",
526
                   roi->top, roi->left, roi->bottom, roi->right, v);
527
528
            pic->roi[i] = (VAEncROI) {
529
                .roi_rectangle = {
530
                    .x      = roi->left,
531
                    .y      = roi->top,
532
                    .width  = roi->right  - roi->left,
533
                    .height = roi->bottom - roi->top,
534
                },
535
                .roi_value = av_clip_int8(v),
536
            };
537
        }
538
539
        param_roi = (VAEncMiscParameterBufferROI) {
540
            .num_roi      = nb_roi,
541
            .max_delta_qp = INT8_MAX,
542
            .min_delta_qp = INT8_MIN,
543
            .roi          = pic->roi,
544
            .roi_flags.bits.roi_value_is_qp_delta = 1,
545
        };
546
547
        err = vaapi_encode_make_misc_param_buffer(avctx, pic,
548
                                                  VAEncMiscParameterTypeROI,
549
                                                  &param_roi,
550
                                                  sizeof(param_roi));
551
        if (err < 0)
552
            goto fail;
553
    }
554
#endif
555
556
    vas = vaBeginPicture(ctx->hwctx->display, ctx->va_context,
557
                         pic->input_surface);
558
    if (vas != VA_STATUS_SUCCESS) {
559
        av_log(avctx, AV_LOG_ERROR, "Failed to begin picture encode issue: "
560
               "%d (%s).\n", vas, vaErrorStr(vas));
561
        err = AVERROR(EIO);
562
        goto fail_with_picture;
563
    }
564
565
    vas = vaRenderPicture(ctx->hwctx->display, ctx->va_context,
566
                          pic->param_buffers, pic->nb_param_buffers);
567
    if (vas != VA_STATUS_SUCCESS) {
568
        av_log(avctx, AV_LOG_ERROR, "Failed to upload encode parameters: "
569
               "%d (%s).\n", vas, vaErrorStr(vas));
570
        err = AVERROR(EIO);
571
        goto fail_with_picture;
572
    }
573
574
    vas = vaEndPicture(ctx->hwctx->display, ctx->va_context);
575
    if (vas != VA_STATUS_SUCCESS) {
576
        av_log(avctx, AV_LOG_ERROR, "Failed to end picture encode issue: "
577
               "%d (%s).\n", vas, vaErrorStr(vas));
578
        err = AVERROR(EIO);
579
        // vaRenderPicture() has been called here, so we should not destroy
580
        // the parameter buffers unless separate destruction is required.
581
        if (CONFIG_VAAPI_1 || ctx->hwctx->driver_quirks &
582
            AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS)
583
            goto fail;
584
        else
585
            goto fail_at_end;
586
    }
587
588
    if (CONFIG_VAAPI_1 || ctx->hwctx->driver_quirks &
589
        AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS) {
590
        for (i = 0; i < pic->nb_param_buffers; i++) {
591
            vas = vaDestroyBuffer(ctx->hwctx->display,
592
                                  pic->param_buffers[i]);
593
            if (vas != VA_STATUS_SUCCESS) {
594
                av_log(avctx, AV_LOG_ERROR, "Failed to destroy "
595
                       "param buffer %#x: %d (%s).\n",
596
                       pic->param_buffers[i], vas, vaErrorStr(vas));
597
                // And ignore.
598
            }
599
        }
600
    }
601
602
    pic->encode_issued = 1;
603
604
    return 0;
605
606
fail_with_picture:
607
    vaEndPicture(ctx->hwctx->display, ctx->va_context);
608
fail:
609
    for(i = 0; i < pic->nb_param_buffers; i++)
610
        vaDestroyBuffer(ctx->hwctx->display, pic->param_buffers[i]);
611
    if (pic->slices) {
612
        for (i = 0; i < pic->nb_slices; i++)
613
            av_freep(&pic->slices[i].codec_slice_params);
614
    }
615
fail_at_end:
616
    av_freep(&pic->codec_picture_params);
617
    av_freep(&pic->param_buffers);
618
    av_freep(&pic->slices);
619
    av_freep(&pic->roi);
620
    av_frame_free(&pic->recon_image);
621
    av_buffer_unref(&pic->output_buffer_ref);
622
    pic->output_buffer = VA_INVALID_ID;
623
    return err;
624
}
625
626
static int vaapi_encode_output(AVCodecContext *avctx,
627
                               VAAPIEncodePicture *pic, AVPacket *pkt)
628
{
629
    VAAPIEncodeContext *ctx = avctx->priv_data;
630
    VACodedBufferSegment *buf_list, *buf;
631
    VAStatus vas;
632
    int total_size = 0;
633
    uint8_t *ptr;
634
    int err;
635
636
    err = vaapi_encode_wait(avctx, pic);
637
    if (err < 0)
638
        return err;
639
640
    buf_list = NULL;
641
    vas = vaMapBuffer(ctx->hwctx->display, pic->output_buffer,
642
                      (void**)&buf_list);
643
    if (vas != VA_STATUS_SUCCESS) {
644
        av_log(avctx, AV_LOG_ERROR, "Failed to map output buffers: "
645
               "%d (%s).\n", vas, vaErrorStr(vas));
646
        err = AVERROR(EIO);
647
        goto fail;
648
    }
649
650
    for (buf = buf_list; buf; buf = buf->next)
651
        total_size += buf->size;
652
653
    err = ff_get_encode_buffer(avctx, pkt, total_size, 0);
654
    ptr = pkt->data;
655
656
    if (err < 0)
657
        goto fail_mapped;
658
659
    for (buf = buf_list; buf; buf = buf->next) {
660
        av_log(avctx, AV_LOG_DEBUG, "Output buffer: %u bytes "
661
               "(status %08x).\n", buf->size, buf->status);
662
663
        memcpy(ptr, buf->buf, buf->size);
664
        ptr += buf->size;
665
    }
666
667
    if (pic->type == PICTURE_TYPE_IDR)
668
        pkt->flags |= AV_PKT_FLAG_KEY;
669
670
    pkt->pts = pic->pts;
671
672
    vas = vaUnmapBuffer(ctx->hwctx->display, pic->output_buffer);
673
    if (vas != VA_STATUS_SUCCESS) {
674
        av_log(avctx, AV_LOG_ERROR, "Failed to unmap output buffers: "
675
               "%d (%s).\n", vas, vaErrorStr(vas));
676
        err = AVERROR(EIO);
677
        goto fail;
678
    }
679
680
    av_buffer_unref(&pic->output_buffer_ref);
681
    pic->output_buffer = VA_INVALID_ID;
682
683
    av_log(avctx, AV_LOG_DEBUG, "Output read for pic %"PRId64"/%"PRId64".\n",
684
           pic->display_order, pic->encode_order);
685
    return 0;
686
687
fail_mapped:
688
    vaUnmapBuffer(ctx->hwctx->display, pic->output_buffer);
689
fail:
690
    av_buffer_unref(&pic->output_buffer_ref);
691
    pic->output_buffer = VA_INVALID_ID;
692
    return err;
693
}
694
695
static int vaapi_encode_discard(AVCodecContext *avctx,
696
                                VAAPIEncodePicture *pic)
697
{
698
    vaapi_encode_wait(avctx, pic);
699
700
    if (pic->output_buffer_ref) {
701
        av_log(avctx, AV_LOG_DEBUG, "Discard output for pic "
702
               "%"PRId64"/%"PRId64".\n",
703
               pic->display_order, pic->encode_order);
704
705
        av_buffer_unref(&pic->output_buffer_ref);
706
        pic->output_buffer = VA_INVALID_ID;
707
    }
708
709
    return 0;
710
}
711
712
static VAAPIEncodePicture *vaapi_encode_alloc(AVCodecContext *avctx)
713
{
714
    VAAPIEncodeContext *ctx = avctx->priv_data;
715
    VAAPIEncodePicture *pic;
716
717
    pic = av_mallocz(sizeof(*pic));
718
    if (!pic)
719
        return NULL;
720
721
    if (ctx->codec->picture_priv_data_size > 0) {
722
        pic->priv_data = av_mallocz(ctx->codec->picture_priv_data_size);
723
        if (!pic->priv_data) {
724
            av_freep(&pic);
725
            return NULL;
726
        }
727
    }
728
729
    pic->input_surface = VA_INVALID_ID;
730
    pic->recon_surface = VA_INVALID_ID;
731
    pic->output_buffer = VA_INVALID_ID;
732
733
    return pic;
734
}
735
736
static int vaapi_encode_free(AVCodecContext *avctx,
737
                             VAAPIEncodePicture *pic)
738
{
739
    int i;
740
741
    if (pic->encode_issued)
742
        vaapi_encode_discard(avctx, pic);
743
744
    if (pic->slices) {
745
        for (i = 0; i < pic->nb_slices; i++)
746
            av_freep(&pic->slices[i].codec_slice_params);
747
    }
748
    av_freep(&pic->codec_picture_params);
749
750
    av_frame_free(&pic->input_image);
751
    av_frame_free(&pic->recon_image);
752
753
    av_freep(&pic->param_buffers);
754
    av_freep(&pic->slices);
755
    // Output buffer should already be destroyed.
756
    av_assert0(pic->output_buffer == VA_INVALID_ID);
757
758
    av_freep(&pic->priv_data);
759
    av_freep(&pic->codec_picture_params);
760
    av_freep(&pic->roi);
761
762
    av_free(pic);
763
764
    return 0;
765
}
766
767
static void vaapi_encode_add_ref(AVCodecContext *avctx,
768
                                 VAAPIEncodePicture *pic,
769
                                 VAAPIEncodePicture *target,
770
                                 int is_ref, int in_dpb, int prev)
771
{
772
    int refs = 0;
773
774
    if (is_ref) {
775
        av_assert0(pic != target);
776
        av_assert0(pic->nb_refs < MAX_PICTURE_REFERENCES);
777
        pic->refs[pic->nb_refs++] = target;
778
        ++refs;
779
    }
780
781
    if (in_dpb) {
782
        av_assert0(pic->nb_dpb_pics < MAX_DPB_SIZE);
783
        pic->dpb[pic->nb_dpb_pics++] = target;
784
        ++refs;
785
    }
786
787
    if (prev) {
788
        av_assert0(!pic->prev);
789
        pic->prev = target;
790
        ++refs;
791
    }
792
793
    target->ref_count[0] += refs;
794
    target->ref_count[1] += refs;
795
}
796
797
static void vaapi_encode_remove_refs(AVCodecContext *avctx,
798
                                     VAAPIEncodePicture *pic,
799
                                     int level)
800
{
801
    int i;
802
803
    if (pic->ref_removed[level])
804
        return;
805
806
    for (i = 0; i < pic->nb_refs; i++) {
807
        av_assert0(pic->refs[i]);
808
        --pic->refs[i]->ref_count[level];
809
        av_assert0(pic->refs[i]->ref_count[level] >= 0);
810
    }
811
812
    for (i = 0; i < pic->nb_dpb_pics; i++) {
813
        av_assert0(pic->dpb[i]);
814
        --pic->dpb[i]->ref_count[level];
815
        av_assert0(pic->dpb[i]->ref_count[level] >= 0);
816
    }
817
818
    av_assert0(pic->prev || pic->type == PICTURE_TYPE_IDR);
819
    if (pic->prev) {
820
        --pic->prev->ref_count[level];
821
        av_assert0(pic->prev->ref_count[level] >= 0);
822
    }
823
824
    pic->ref_removed[level] = 1;
825
}
826
827
static void vaapi_encode_set_b_pictures(AVCodecContext *avctx,
828
                                        VAAPIEncodePicture *start,
829
                                        VAAPIEncodePicture *end,
830
                                        VAAPIEncodePicture *prev,
831
                                        int current_depth,
832
                                        VAAPIEncodePicture **last)
833
{
834
    VAAPIEncodeContext *ctx = avctx->priv_data;
835
    VAAPIEncodePicture *pic, *next, *ref;
836
    int i, len;
837
838
    av_assert0(start && end && start != end && start->next != end);
839
840
    // If we are at the maximum depth then encode all pictures as
841
    // non-referenced B-pictures.  Also do this if there is exactly one
842
    // picture left, since there will be nothing to reference it.
843
    if (current_depth == ctx->max_b_depth || start->next->next == end) {
844
        for (pic = start->next; pic; pic = pic->next) {
845
            if (pic == end)
846
                break;
847
            pic->type    = PICTURE_TYPE_B;
848
            pic->b_depth = current_depth;
849
850
            vaapi_encode_add_ref(avctx, pic, start, 1, 1, 0);
851
            vaapi_encode_add_ref(avctx, pic, end,   1, 1, 0);
852
            vaapi_encode_add_ref(avctx, pic, prev,  0, 0, 1);
853
854
            for (ref = end->refs[1]; ref; ref = ref->refs[1])
855
                vaapi_encode_add_ref(avctx, pic, ref, 0, 1, 0);
856
        }
857
        *last = prev;
858
859
    } else {
860
        // Split the current list at the midpoint with a referenced
861
        // B-picture, then descend into each side separately.
862
        len = 0;
863
        for (pic = start->next; pic != end; pic = pic->next)
864
            ++len;
865
        for (pic = start->next, i = 1; 2 * i < len; pic = pic->next, i++);
866
867
        pic->type    = PICTURE_TYPE_B;
868
        pic->b_depth = current_depth;
869
870
        pic->is_reference = 1;
871
872
        vaapi_encode_add_ref(avctx, pic, pic,   0, 1, 0);
873
        vaapi_encode_add_ref(avctx, pic, start, 1, 1, 0);
874
        vaapi_encode_add_ref(avctx, pic, end,   1, 1, 0);
875
        vaapi_encode_add_ref(avctx, pic, prev,  0, 0, 1);
876
877
        for (ref = end->refs[1]; ref; ref = ref->refs[1])
878
            vaapi_encode_add_ref(avctx, pic, ref, 0, 1, 0);
879
880
        if (i > 1)
881
            vaapi_encode_set_b_pictures(avctx, start, pic, pic,
882
                                        current_depth + 1, &next);
883
        else
884
            next = pic;
885
886
        vaapi_encode_set_b_pictures(avctx, pic, end, next,
887
                                    current_depth + 1, last);
888
    }
889
}
890
891
static int vaapi_encode_pick_next(AVCodecContext *avctx,
892
                                  VAAPIEncodePicture **pic_out)
893
{
894
    VAAPIEncodeContext *ctx = avctx->priv_data;
895
    VAAPIEncodePicture *pic = NULL, *next, *start;
896
    int i, b_counter, closed_gop_end;
897
898
    // If there are any B-frames already queued, the next one to encode
899
    // is the earliest not-yet-issued frame for which all references are
900
    // available.
901
    for (pic = ctx->pic_start; pic; pic = pic->next) {
902
        if (pic->encode_issued)
903
            continue;
904
        if (pic->type != PICTURE_TYPE_B)
905
            continue;
906
        for (i = 0; i < pic->nb_refs; i++) {
907
            if (!pic->refs[i]->encode_issued)
908
                break;
909
        }
910
        if (i == pic->nb_refs)
911
            break;
912
    }
913
914
    if (pic) {
915
        av_log(avctx, AV_LOG_DEBUG, "Pick B-picture at depth %d to "
916
               "encode next.\n", pic->b_depth);
917
        *pic_out = pic;
918
        return 0;
919
    }
920
921
    // Find the B-per-Pth available picture to become the next picture
922
    // on the top layer.
923
    start = NULL;
924
    b_counter = 0;
925
    closed_gop_end = ctx->closed_gop ||
926
                     ctx->idr_counter == ctx->gop_per_idr;
927
    for (pic = ctx->pic_start; pic; pic = next) {
928
        next = pic->next;
929
        if (pic->encode_issued) {
930
            start = pic;
931
            continue;
932
        }
933
        // If the next available picture is force-IDR, encode it to start
934
        // a new GOP immediately.
935
        if (pic->force_idr)
936
            break;
937
        if (b_counter == ctx->b_per_p)
938
            break;
939
        // If this picture ends a closed GOP or starts a new GOP then it
940
        // needs to be in the top layer.
941
        if (ctx->gop_counter + b_counter + closed_gop_end >= ctx->gop_size)
942
            break;
943
        // If the picture after this one is force-IDR, we need to encode
944
        // this one in the top layer.
945
        if (next && next->force_idr)
946
            break;
947
        ++b_counter;
948
    }
949
950
    // At the end of the stream the last picture must be in the top layer.
951
    if (!pic && ctx->end_of_stream) {
952
        --b_counter;
953
        pic = ctx->pic_end;
954
        if (pic->encode_issued)
955
            return AVERROR_EOF;
956
    }
957
958
    if (!pic) {
959
        av_log(avctx, AV_LOG_DEBUG, "Pick nothing to encode next - "
960
               "need more input for reference pictures.\n");
961
        return AVERROR(EAGAIN);
962
    }
963
    if (ctx->input_order <= ctx->decode_delay && !ctx->end_of_stream) {
964
        av_log(avctx, AV_LOG_DEBUG, "Pick nothing to encode next - "
965
               "need more input for timestamps.\n");
966
        return AVERROR(EAGAIN);
967
    }
968
969
    if (pic->force_idr) {
970
        av_log(avctx, AV_LOG_DEBUG, "Pick forced IDR-picture to "
971
               "encode next.\n");
972
        pic->type = PICTURE_TYPE_IDR;
973
        ctx->idr_counter = 1;
974
        ctx->gop_counter = 1;
975
976
    } else if (ctx->gop_counter + b_counter >= ctx->gop_size) {
977
        if (ctx->idr_counter == ctx->gop_per_idr) {
978
            av_log(avctx, AV_LOG_DEBUG, "Pick new-GOP IDR-picture to "
979
                   "encode next.\n");
980
            pic->type = PICTURE_TYPE_IDR;
981
            ctx->idr_counter = 1;
982
        } else {
983
            av_log(avctx, AV_LOG_DEBUG, "Pick new-GOP I-picture to "
984
                   "encode next.\n");
985
            pic->type = PICTURE_TYPE_I;
986
            ++ctx->idr_counter;
987
        }
988
        ctx->gop_counter = 1;
989
990
    } else {
991
        if (ctx->gop_counter + b_counter + closed_gop_end == ctx->gop_size) {
992
            av_log(avctx, AV_LOG_DEBUG, "Pick group-end P-picture to "
993
                   "encode next.\n");
994
        } else {
995
            av_log(avctx, AV_LOG_DEBUG, "Pick normal P-picture to "
996
                   "encode next.\n");
997
        }
998
        pic->type = PICTURE_TYPE_P;
999
        av_assert0(start);
1000
        ctx->gop_counter += 1 + b_counter;
1001
    }
1002
    pic->is_reference = 1;
1003
    *pic_out = pic;
1004
1005
    vaapi_encode_add_ref(avctx, pic, pic, 0, 1, 0);
1006
    if (pic->type != PICTURE_TYPE_IDR) {
1007
        vaapi_encode_add_ref(avctx, pic, start,
1008
                             pic->type == PICTURE_TYPE_P,
1009
                             b_counter > 0, 0);
1010
        vaapi_encode_add_ref(avctx, pic, ctx->next_prev, 0, 0, 1);
1011
    }
1012
    if (ctx->next_prev)
1013
        --ctx->next_prev->ref_count[0];
1014
1015
    if (b_counter > 0) {
1016
        vaapi_encode_set_b_pictures(avctx, start, pic, pic, 1,
1017
                                    &ctx->next_prev);
1018
    } else {
1019
        ctx->next_prev = pic;
1020
    }
1021
    ++ctx->next_prev->ref_count[0];
1022
    return 0;
1023
}
1024
1025
static int vaapi_encode_clear_old(AVCodecContext *avctx)
1026
{
1027
    VAAPIEncodeContext *ctx = avctx->priv_data;
1028
    VAAPIEncodePicture *pic, *prev, *next;
1029
1030
    av_assert0(ctx->pic_start);
1031
1032
    // Remove direct references once each picture is complete.
1033
    for (pic = ctx->pic_start; pic; pic = pic->next) {
1034
        if (pic->encode_complete && pic->next)
1035
            vaapi_encode_remove_refs(avctx, pic, 0);
1036
    }
1037
1038
    // Remove indirect references once a picture has no direct references.
1039
    for (pic = ctx->pic_start; pic; pic = pic->next) {
1040
        if (pic->encode_complete && pic->ref_count[0] == 0)
1041
            vaapi_encode_remove_refs(avctx, pic, 1);
1042
    }
1043
1044
    // Clear out all complete pictures with no remaining references.
1045
    prev = NULL;
1046
    for (pic = ctx->pic_start; pic; pic = next) {
1047
        next = pic->next;
1048
        if (pic->encode_complete && pic->ref_count[1] == 0) {
1049
            av_assert0(pic->ref_removed[0] && pic->ref_removed[1]);
1050
            if (prev)
1051
                prev->next = next;
1052
            else
1053
                ctx->pic_start = next;
1054
            vaapi_encode_free(avctx, pic);
1055
        } else {
1056
            prev = pic;
1057
        }
1058
    }
1059
1060
    return 0;
1061
}
1062
1063
static int vaapi_encode_check_frame(AVCodecContext *avctx,
1064
                                    const AVFrame *frame)
1065
{
1066
    VAAPIEncodeContext *ctx = avctx->priv_data;
1067
1068
    if ((frame->crop_top  || frame->crop_bottom ||
1069
         frame->crop_left || frame->crop_right) && !ctx->crop_warned) {
1070
        av_log(avctx, AV_LOG_WARNING, "Cropping information on input "
1071
               "frames ignored due to lack of API support.\n");
1072
        ctx->crop_warned = 1;
1073
    }
1074
1075
    if (!ctx->roi_allowed) {
1076
        AVFrameSideData *sd =
1077
            av_frame_get_side_data(frame, AV_FRAME_DATA_REGIONS_OF_INTEREST);
1078
1079
        if (sd && !ctx->roi_warned) {
1080
            av_log(avctx, AV_LOG_WARNING, "ROI side data on input "
1081
                   "frames ignored due to lack of driver support.\n");
1082
            ctx->roi_warned = 1;
1083
        }
1084
    }
1085
1086
    return 0;
1087
}
1088
1089
static int vaapi_encode_send_frame(AVCodecContext *avctx, AVFrame *frame)
1090
{
1091
    VAAPIEncodeContext *ctx = avctx->priv_data;
1092
    VAAPIEncodePicture *pic;
1093
    int err;
1094
1095
    if (frame) {
1096
        av_log(avctx, AV_LOG_DEBUG, "Input frame: %ux%u (%"PRId64").\n",
1097
               frame->width, frame->height, frame->pts);
1098
1099
        err = vaapi_encode_check_frame(avctx, frame);
1100
        if (err < 0)
1101
            return err;
1102
1103
        pic = vaapi_encode_alloc(avctx);
1104
        if (!pic)
1105
            return AVERROR(ENOMEM);
1106
1107
        pic->input_image = av_frame_alloc();
1108
        if (!pic->input_image) {
1109
            err = AVERROR(ENOMEM);
1110
            goto fail;
1111
        }
1112
1113
        if (ctx->input_order == 0 || frame->pict_type == AV_PICTURE_TYPE_I)
1114
            pic->force_idr = 1;
1115
1116
        pic->input_surface = (VASurfaceID)(uintptr_t)frame->data[3];
1117
        pic->pts = frame->pts;
1118
1119
        av_frame_move_ref(pic->input_image, frame);
1120
1121
        if (ctx->input_order == 0)
1122
            ctx->first_pts = pic->pts;
1123
        if (ctx->input_order == ctx->decode_delay)
1124
            ctx->dts_pts_diff = pic->pts - ctx->first_pts;
1125
        if (ctx->output_delay > 0)
1126
            ctx->ts_ring[ctx->input_order % (3 * ctx->output_delay)] = pic->pts;
1127
1128
        pic->display_order = ctx->input_order;
1129
        ++ctx->input_order;
1130
1131
        if (ctx->pic_start) {
1132
            ctx->pic_end->next = pic;
1133
            ctx->pic_end       = pic;
1134
        } else {
1135
            ctx->pic_start     = pic;
1136
            ctx->pic_end       = pic;
1137
        }
1138
1139
    } else {
1140
        ctx->end_of_stream = 1;
1141
1142
        // Fix timestamps if we hit end-of-stream before the initial decode
1143
        // delay has elapsed.
1144
        if (ctx->input_order < ctx->decode_delay)
1145
            ctx->dts_pts_diff = ctx->pic_end->pts - ctx->first_pts;
1146
    }
1147
1148
    return 0;
1149
1150
fail:
1151
    vaapi_encode_free(avctx, pic);
1152
    return err;
1153
}
1154
1155
int ff_vaapi_encode_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
1156
{
1157
    VAAPIEncodeContext *ctx = avctx->priv_data;
1158
    VAAPIEncodePicture *pic;
1159
    AVFrame *frame = ctx->frame;
1160
    int err;
1161
1162
    err = ff_encode_get_frame(avctx, frame);
1163
    if (err < 0 && err != AVERROR_EOF)
1164
        return err;
1165
1166
    if (err == AVERROR_EOF)
1167
        frame = NULL;
1168
1169
    err = vaapi_encode_send_frame(avctx, frame);
1170
    if (err < 0)
1171
        return err;
1172
1173
    if (!ctx->pic_start) {
1174
        if (ctx->end_of_stream)
1175
            return AVERROR_EOF;
1176
        else
1177
            return AVERROR(EAGAIN);
1178
    }
1179
1180
    pic = NULL;
1181
    err = vaapi_encode_pick_next(avctx, &pic);
1182
    if (err < 0)
1183
        return err;
1184
    av_assert0(pic);
1185
1186
    pic->encode_order = ctx->encode_order++;
1187
1188
    err = vaapi_encode_issue(avctx, pic);
1189
    if (err < 0) {
1190
        av_log(avctx, AV_LOG_ERROR, "Encode failed: %d.\n", err);
1191
        return err;
1192
    }
1193
1194
    err = vaapi_encode_output(avctx, pic, pkt);
1195
    if (err < 0) {
1196
        av_log(avctx, AV_LOG_ERROR, "Output failed: %d.\n", err);
1197
        return err;
1198
    }
1199
1200
    if (ctx->output_delay == 0) {
1201
        pkt->dts = pkt->pts;
1202
    } else if (pic->encode_order < ctx->decode_delay) {
1203
        if (ctx->ts_ring[pic->encode_order] < INT64_MIN + ctx->dts_pts_diff)
1204
            pkt->dts = INT64_MIN;
1205
        else
1206
            pkt->dts = ctx->ts_ring[pic->encode_order] - ctx->dts_pts_diff;
1207
    } else {
1208
        pkt->dts = ctx->ts_ring[(pic->encode_order - ctx->decode_delay) %
1209
                                (3 * ctx->output_delay)];
1210
    }
1211
    av_log(avctx, AV_LOG_DEBUG, "Output packet: pts %"PRId64" dts %"PRId64".\n",
1212
           pkt->pts, pkt->dts);
1213
1214
    ctx->output_order = pic->encode_order;
1215
    vaapi_encode_clear_old(avctx);
1216
1217
    return 0;
1218
}
1219
1220
1221
static av_cold void vaapi_encode_add_global_param(AVCodecContext *avctx, int type,
1222
                                                  void *buffer, size_t size)
1223
{
1224
    VAAPIEncodeContext *ctx = avctx->priv_data;
1225
1226
    av_assert0(ctx->nb_global_params < MAX_GLOBAL_PARAMS);
1227
1228
    ctx->global_params_type[ctx->nb_global_params] = type;
1229
    ctx->global_params     [ctx->nb_global_params] = buffer;
1230
    ctx->global_params_size[ctx->nb_global_params] = size;
1231
1232
    ++ctx->nb_global_params;
1233
}
1234
1235
typedef struct VAAPIEncodeRTFormat {
1236
    const char *name;
1237
    unsigned int value;
1238
    int depth;
1239
    int nb_components;
1240
    int log2_chroma_w;
1241
    int log2_chroma_h;
1242
} VAAPIEncodeRTFormat;
1243
1244
static const VAAPIEncodeRTFormat vaapi_encode_rt_formats[] = {
1245
    { "YUV400",    VA_RT_FORMAT_YUV400,        8, 1,      },
1246
    { "YUV420",    VA_RT_FORMAT_YUV420,        8, 3, 1, 1 },
1247
    { "YUV422",    VA_RT_FORMAT_YUV422,        8, 3, 1, 0 },
1248
#if VA_CHECK_VERSION(1, 2, 0)
1249
    { "YUV422_10", VA_RT_FORMAT_YUV422_10,    10, 3, 1, 0 },
1250
#endif
1251
    { "YUV444",    VA_RT_FORMAT_YUV444,        8, 3, 0, 0 },
1252
    { "YUV411",    VA_RT_FORMAT_YUV411,        8, 3, 2, 0 },
1253
#if VA_CHECK_VERSION(0, 38, 1)
1254
    { "YUV420_10", VA_RT_FORMAT_YUV420_10BPP, 10, 3, 1, 1 },
1255
#endif
1256
};
1257
1258
static const VAEntrypoint vaapi_encode_entrypoints_normal[] = {
1259
    VAEntrypointEncSlice,
1260
    VAEntrypointEncPicture,
1261
#if VA_CHECK_VERSION(0, 39, 2)
1262
    VAEntrypointEncSliceLP,
1263
#endif
1264
    0
1265
};
1266
#if VA_CHECK_VERSION(0, 39, 2)
1267
static const VAEntrypoint vaapi_encode_entrypoints_low_power[] = {
1268
    VAEntrypointEncSliceLP,
1269
    0
1270
};
1271
#endif
1272
1273
static av_cold int vaapi_encode_profile_entrypoint(AVCodecContext *avctx)
1274
{
1275
    VAAPIEncodeContext      *ctx = avctx->priv_data;
1276
    VAProfile    *va_profiles    = NULL;
1277
    VAEntrypoint *va_entrypoints = NULL;
1278
    VAStatus vas;
1279
    const VAEntrypoint *usable_entrypoints;
1280
    const VAAPIEncodeProfile *profile;
1281
    const AVPixFmtDescriptor *desc;
1282
    VAConfigAttrib rt_format_attr;
1283
    const VAAPIEncodeRTFormat *rt_format;
1284
    const char *profile_string, *entrypoint_string;
1285
    int i, j, n, depth, err;
1286
1287
1288
    if (ctx->low_power) {
1289
#if VA_CHECK_VERSION(0, 39, 2)
1290
        usable_entrypoints = vaapi_encode_entrypoints_low_power;
1291
#else
1292
        av_log(avctx, AV_LOG_ERROR, "Low-power encoding is not "
1293
               "supported with this VAAPI version.\n");
1294
        return AVERROR(EINVAL);
1295
#endif
1296
    } else {
1297
        usable_entrypoints = vaapi_encode_entrypoints_normal;
1298
    }
1299
1300
    desc = av_pix_fmt_desc_get(ctx->input_frames->sw_format);
1301
    if (!desc) {
1302
        av_log(avctx, AV_LOG_ERROR, "Invalid input pixfmt (%d).\n",
1303
               ctx->input_frames->sw_format);
1304
        return AVERROR(EINVAL);
1305
    }
1306
    depth = desc->comp[0].depth;
1307
    for (i = 1; i < desc->nb_components; i++) {
1308
        if (desc->comp[i].depth != depth) {
1309
            av_log(avctx, AV_LOG_ERROR, "Invalid input pixfmt (%s).\n",
1310
                   desc->name);
1311
            return AVERROR(EINVAL);
1312
        }
1313
    }
1314
    av_log(avctx, AV_LOG_VERBOSE, "Input surface format is %s.\n",
1315
           desc->name);
1316
1317
    n = vaMaxNumProfiles(ctx->hwctx->display);
1318
    va_profiles = av_malloc_array(n, sizeof(VAProfile));
1319
    if (!va_profiles) {
1320
        err = AVERROR(ENOMEM);
1321
        goto fail;
1322
    }
1323
    vas = vaQueryConfigProfiles(ctx->hwctx->display, va_profiles, &n);
1324
    if (vas != VA_STATUS_SUCCESS) {
1325
        av_log(avctx, AV_LOG_ERROR, "Failed to query profiles: %d (%s).\n",
1326
               vas, vaErrorStr(vas));
1327
        err = AVERROR_EXTERNAL;
1328
        goto fail;
1329
    }
1330
1331
    av_assert0(ctx->codec->profiles);
1332
    for (i = 0; (ctx->codec->profiles[i].av_profile !=
1333
                 FF_PROFILE_UNKNOWN); i++) {
1334
        profile = &ctx->codec->profiles[i];
1335
        if (depth               != profile->depth ||
1336
            desc->nb_components != profile->nb_components)
1337
            continue;
1338
        if (desc->nb_components > 1 &&
1339
            (desc->log2_chroma_w != profile->log2_chroma_w ||
1340
             desc->log2_chroma_h != profile->log2_chroma_h))
1341
            continue;
1342
        if (avctx->profile != profile->av_profile &&
1343
            avctx->profile != FF_PROFILE_UNKNOWN)
1344
            continue;
1345
1346
#if VA_CHECK_VERSION(1, 0, 0)
1347
        profile_string = vaProfileStr(profile->va_profile);
1348
#else
1349
        profile_string = "(no profile names)";
1350
#endif
1351
1352
        for (j = 0; j < n; j++) {
1353
            if (va_profiles[j] == profile->va_profile)
1354
                break;
1355
        }
1356
        if (j >= n) {
1357
            av_log(avctx, AV_LOG_VERBOSE, "Compatible profile %s (%d) "
1358
                   "is not supported by driver.\n", profile_string,
1359
                   profile->va_profile);
1360
            continue;
1361
        }
1362
1363
        ctx->profile = profile;
1364
        break;
1365
    }
1366
    if (!ctx->profile) {
1367
        av_log(avctx, AV_LOG_ERROR, "No usable encoding profile found.\n");
1368
        err = AVERROR(ENOSYS);
1369
        goto fail;
1370
    }
1371
1372
    avctx->profile  = profile->av_profile;
1373
    ctx->va_profile = profile->va_profile;
1374
    av_log(avctx, AV_LOG_VERBOSE, "Using VAAPI profile %s (%d).\n",
1375
           profile_string, ctx->va_profile);
1376
1377
    n = vaMaxNumEntrypoints(ctx->hwctx->display);
1378
    va_entrypoints = av_malloc_array(n, sizeof(VAEntrypoint));
1379
    if (!va_entrypoints) {
1380
        err = AVERROR(ENOMEM);
1381
        goto fail;
1382
    }
1383
    vas = vaQueryConfigEntrypoints(ctx->hwctx->display, ctx->va_profile,
1384
                                   va_entrypoints, &n);
1385
    if (vas != VA_STATUS_SUCCESS) {
1386
        av_log(avctx, AV_LOG_ERROR, "Failed to query entrypoints for "
1387
               "profile %s (%d): %d (%s).\n", profile_string,
1388
               ctx->va_profile, vas, vaErrorStr(vas));
1389
        err = AVERROR_EXTERNAL;
1390
        goto fail;
1391
    }
1392
1393
    for (i = 0; i < n; i++) {
1394
        for (j = 0; usable_entrypoints[j]; j++) {
1395
            if (va_entrypoints[i] == usable_entrypoints[j])
1396
                break;
1397
        }
1398
        if (usable_entrypoints[j])
1399
            break;
1400
    }
1401
    if (i >= n) {
1402
        av_log(avctx, AV_LOG_ERROR, "No usable encoding entrypoint found "
1403
               "for profile %s (%d).\n", profile_string, ctx->va_profile);
1404
        err = AVERROR(ENOSYS);
1405
        goto fail;
1406
    }
1407
1408
    ctx->va_entrypoint = va_entrypoints[i];
1409
#if VA_CHECK_VERSION(1, 0, 0)
1410
    entrypoint_string = vaEntrypointStr(ctx->va_entrypoint);
1411
#else
1412
    entrypoint_string = "(no entrypoint names)";
1413
#endif
1414
    av_log(avctx, AV_LOG_VERBOSE, "Using VAAPI entrypoint %s (%d).\n",
1415
           entrypoint_string, ctx->va_entrypoint);
1416
1417
    for (i = 0; i < FF_ARRAY_ELEMS(vaapi_encode_rt_formats); i++) {
1418
        rt_format = &vaapi_encode_rt_formats[i];
1419
        if (rt_format->depth         == depth &&
1420
            rt_format->nb_components == profile->nb_components &&
1421
            rt_format->log2_chroma_w == profile->log2_chroma_w &&
1422
            rt_format->log2_chroma_h == profile->log2_chroma_h)
1423
            break;
1424
    }
1425
    if (i >= FF_ARRAY_ELEMS(vaapi_encode_rt_formats)) {
1426
        av_log(avctx, AV_LOG_ERROR, "No usable render target format "
1427
               "found for profile %s (%d) entrypoint %s (%d).\n",
1428
               profile_string, ctx->va_profile,
1429
               entrypoint_string, ctx->va_entrypoint);
1430
        err = AVERROR(ENOSYS);
1431
        goto fail;
1432
    }
1433
1434
    rt_format_attr = (VAConfigAttrib) { VAConfigAttribRTFormat };
1435
    vas = vaGetConfigAttributes(ctx->hwctx->display,
1436
                                ctx->va_profile, ctx->va_entrypoint,
1437
                                &rt_format_attr, 1);
1438
    if (vas != VA_STATUS_SUCCESS) {
1439
        av_log(avctx, AV_LOG_ERROR, "Failed to query RT format "
1440
               "config attribute: %d (%s).\n", vas, vaErrorStr(vas));
1441
        err = AVERROR_EXTERNAL;
1442
        goto fail;
1443
    }
1444
1445
    if (rt_format_attr.value == VA_ATTRIB_NOT_SUPPORTED) {
1446
        av_log(avctx, AV_LOG_VERBOSE, "RT format config attribute not "
1447
               "supported by driver: assuming surface RT format %s "
1448
               "is valid.\n", rt_format->name);
1449
    } else if (!(rt_format_attr.value & rt_format->value)) {
1450
        av_log(avctx, AV_LOG_ERROR, "Surface RT format %s not supported "
1451
               "by driver for encoding profile %s (%d) entrypoint %s (%d).\n",
1452
               rt_format->name, profile_string, ctx->va_profile,
1453
               entrypoint_string, ctx->va_entrypoint);
1454
        err = AVERROR(ENOSYS);
1455
        goto fail;
1456
    } else {
1457
        av_log(avctx, AV_LOG_VERBOSE, "Using VAAPI render target "
1458
               "format %s (%#x).\n", rt_format->name, rt_format->value);
1459
        ctx->config_attributes[ctx->nb_config_attributes++] =
1460
            (VAConfigAttrib) {
1461
            .type  = VAConfigAttribRTFormat,
1462
            .value = rt_format->value,
1463
        };
1464
    }
1465
1466
    err = 0;
1467
fail:
1468
    av_freep(&va_profiles);
1469
    av_freep(&va_entrypoints);
1470
    return err;
1471
}
1472
1473
static const VAAPIEncodeRCMode vaapi_encode_rc_modes[] = {
1474
    //                                  Bitrate   Quality
1475
    //                                     | Maxrate | HRD/VBV
1476
    { 0 }, //                              |    |    |    |
1477
    { RC_MODE_CQP,  "CQP",  1, VA_RC_CQP,  0,   0,   1,   0 },
1478
    { RC_MODE_CBR,  "CBR",  1, VA_RC_CBR,  1,   0,   0,   1 },
1479
    { RC_MODE_VBR,  "VBR",  1, VA_RC_VBR,  1,   1,   0,   1 },
1480
#if VA_CHECK_VERSION(1, 1, 0)
1481
    { RC_MODE_ICQ,  "ICQ",  1, VA_RC_ICQ,  0,   0,   1,   0 },
1482
#else
1483
    { RC_MODE_ICQ,  "ICQ",  0 },
1484
#endif
1485
#if VA_CHECK_VERSION(1, 3, 0)
1486
    { RC_MODE_QVBR, "QVBR", 1, VA_RC_QVBR, 1,   1,   1,   1 },
1487
    { RC_MODE_AVBR, "AVBR", 0, VA_RC_AVBR, 1,   0,   0,   0 },
1488
#else
1489
    { RC_MODE_QVBR, "QVBR", 0 },
1490
    { RC_MODE_AVBR, "AVBR", 0 },
1491
#endif
1492
};
1493
1494
static av_cold int vaapi_encode_init_rate_control(AVCodecContext *avctx)
1495
{
1496
    VAAPIEncodeContext *ctx = avctx->priv_data;
1497
    uint32_t supported_va_rc_modes;
1498
    const VAAPIEncodeRCMode *rc_mode;
1499
    int64_t rc_bits_per_second;
1500
    int     rc_target_percentage;
1501
    int     rc_window_size;
1502
    int     rc_quality;
1503
    int64_t hrd_buffer_size;
1504
    int64_t hrd_initial_buffer_fullness;
1505
    int fr_num, fr_den;
1506
    VAConfigAttrib rc_attr = { VAConfigAttribRateControl };
1507
    VAStatus vas;
1508
    char supported_rc_modes_string[64];
1509
1510
    vas = vaGetConfigAttributes(ctx->hwctx->display,
1511
                                ctx->va_profile, ctx->va_entrypoint,
1512
                                &rc_attr, 1);
1513
    if (vas != VA_STATUS_SUCCESS) {
1514
        av_log(avctx, AV_LOG_ERROR, "Failed to query rate control "
1515
               "config attribute: %d (%s).\n", vas, vaErrorStr(vas));
1516
        return AVERROR_EXTERNAL;
1517
    }
1518
    if (rc_attr.value == VA_ATTRIB_NOT_SUPPORTED) {
1519
        av_log(avctx, AV_LOG_VERBOSE, "Driver does not report any "
1520
               "supported rate control modes: assuming CQP only.\n");
1521
        supported_va_rc_modes = VA_RC_CQP;
1522
        strcpy(supported_rc_modes_string, "unknown");
1523
    } else {
1524
        char *str = supported_rc_modes_string;
1525
        size_t len = sizeof(supported_rc_modes_string);
1526
        int i, first = 1, res;
1527
1528
        supported_va_rc_modes = rc_attr.value;
1529
        for (i = 0; i < FF_ARRAY_ELEMS(vaapi_encode_rc_modes); i++) {
1530
            rc_mode = &vaapi_encode_rc_modes[i];
1531
            if (supported_va_rc_modes & rc_mode->va_mode) {
1532
                res = snprintf(str, len, "%s%s",
1533
                               first ? "" : ", ", rc_mode->name);
1534
                first = 0;
1535
                if (res < 0) {
1536
                    *str = 0;
1537
                    break;
1538
                }
1539
                len -= res;
1540
                str += res;
1541
                if (len == 0)
1542
                    break;
1543
            }
1544
        }
1545
1546
        av_log(avctx, AV_LOG_DEBUG, "Driver supports RC modes %s.\n",
1547
               supported_rc_modes_string);
1548
    }
1549
1550
    // Rate control mode selection:
1551
    // * If the user has set a mode explicitly with the rc_mode option,
1552
    //   use it and fail if it is not available.
1553
    // * If an explicit QP option has been set, use CQP.
1554
    // * If the codec is CQ-only, use CQP.
1555
    // * If the QSCALE avcodec option is set, use CQP.
1556
    // * If bitrate and quality are both set, try QVBR.
1557
    // * If quality is set, try ICQ, then CQP.
1558
    // * If bitrate and maxrate are set and have the same value, try CBR.
1559
    // * If a bitrate is set, try AVBR, then VBR, then CBR.
1560
    // * If no bitrate is set, try ICQ, then CQP.
1561
1562
#define TRY_RC_MODE(mode, fail) do { \
1563
        rc_mode = &vaapi_encode_rc_modes[mode]; \
1564
        if (!(rc_mode->va_mode & supported_va_rc_modes)) { \
1565
            if (fail) { \
1566
                av_log(avctx, AV_LOG_ERROR, "Driver does not support %s " \
1567
                       "RC mode (supported modes: %s).\n", rc_mode->name, \
1568
                       supported_rc_modes_string); \
1569
                return AVERROR(EINVAL); \
1570
            } \
1571
            av_log(avctx, AV_LOG_DEBUG, "Driver does not support %s " \
1572
                   "RC mode.\n", rc_mode->name); \
1573
            rc_mode = NULL; \
1574
        } else { \
1575
            goto rc_mode_found; \
1576
        } \
1577
    } while (0)
1578
1579
    if (ctx->explicit_rc_mode)
1580
        TRY_RC_MODE(ctx->explicit_rc_mode, 1);
1581
1582
    if (ctx->explicit_qp)
1583
        TRY_RC_MODE(RC_MODE_CQP, 1);
1584
1585
    if (ctx->codec->flags & FLAG_CONSTANT_QUALITY_ONLY)
1586
        TRY_RC_MODE(RC_MODE_CQP, 1);
1587
1588
    if (avctx->flags & AV_CODEC_FLAG_QSCALE)
1589
        TRY_RC_MODE(RC_MODE_CQP, 1);
1590
1591
    if (avctx->bit_rate > 0 && avctx->global_quality > 0)
1592
        TRY_RC_MODE(RC_MODE_QVBR, 0);
1593
1594
    if (avctx->global_quality > 0) {
1595
        TRY_RC_MODE(RC_MODE_ICQ, 0);
1596
        TRY_RC_MODE(RC_MODE_CQP, 0);
1597
    }
1598
1599
    if (avctx->bit_rate > 0 && avctx->rc_max_rate == avctx->bit_rate)
1600
        TRY_RC_MODE(RC_MODE_CBR, 0);
1601
1602
    if (avctx->bit_rate > 0) {
1603
        TRY_RC_MODE(RC_MODE_AVBR, 0);
1604
        TRY_RC_MODE(RC_MODE_VBR, 0);
1605
        TRY_RC_MODE(RC_MODE_CBR, 0);
1606
    } else {
1607
        TRY_RC_MODE(RC_MODE_ICQ, 0);
1608
        TRY_RC_MODE(RC_MODE_CQP, 0);
1609
    }
1610
1611
    av_log(avctx, AV_LOG_ERROR, "Driver does not support any "
1612
           "RC mode compatible with selected options "
1613
           "(supported modes: %s).\n", supported_rc_modes_string);
1614
    return AVERROR(EINVAL);
1615
1616
rc_mode_found:
1617
    if (rc_mode->bitrate) {
1618
        if (avctx->bit_rate <= 0) {
1619
            av_log(avctx, AV_LOG_ERROR, "Bitrate must be set for %s "
1620
                   "RC mode.\n", rc_mode->name);
1621
            return AVERROR(EINVAL);
1622
        }
1623
1624
        if (rc_mode->mode == RC_MODE_AVBR) {
1625
            // For maximum confusion AVBR is hacked into the existing API
1626
            // by overloading some of the fields with completely different
1627
            // meanings.
1628
1629
            // Target percentage does not apply in AVBR mode.
1630
            rc_bits_per_second = avctx->bit_rate;
1631
1632
            // Accuracy tolerance range for meeting the specified target
1633
            // bitrate.  It's very unclear how this is actually intended
1634
            // to work - since we do want to get the specified bitrate,
1635
            // set the accuracy to 100% for now.
1636
            rc_target_percentage = 100;
1637
1638
            // Convergence period in frames.  The GOP size reflects the
1639
            // user's intended block size for cutting, so reusing that
1640
            // as the convergence period seems a reasonable default.
1641
            rc_window_size = avctx->gop_size > 0 ? avctx->gop_size : 60;
1642
1643
        } else if (rc_mode->maxrate) {
1644
            if (avctx->rc_max_rate > 0) {
1645
                if (avctx->rc_max_rate < avctx->bit_rate) {
1646
                    av_log(avctx, AV_LOG_ERROR, "Invalid bitrate settings: "
1647
                           "bitrate (%"PRId64") must not be greater than "
1648
                           "maxrate (%"PRId64").\n", avctx->bit_rate,
1649
                           avctx->rc_max_rate);
1650
                    return AVERROR(EINVAL);
1651
                }
1652
                rc_bits_per_second   = avctx->rc_max_rate;
1653
                rc_target_percentage = (avctx->bit_rate * 100) /
1654
                                       avctx->rc_max_rate;
1655
            } else {
1656
                // We only have a target bitrate, but this mode requires
1657
                // that a maximum rate be supplied as well.  Since the
1658
                // user does not want this to be a constraint, arbitrarily
1659
                // pick a maximum rate of double the target rate.
1660
                rc_bits_per_second   = 2 * avctx->bit_rate;
1661
                rc_target_percentage = 50;
1662
            }
1663
        } else {
1664
            if (avctx->rc_max_rate > avctx->bit_rate) {
1665
                av_log(avctx, AV_LOG_WARNING, "Max bitrate is ignored "
1666
                       "in %s RC mode.\n", rc_mode->name);
1667
            }
1668
            rc_bits_per_second   = avctx->bit_rate;
1669
            rc_target_percentage = 100;
1670
        }
1671
    } else {
1672
        rc_bits_per_second   = 0;
1673
        rc_target_percentage = 100;
1674
    }
1675
1676
    if (rc_mode->quality) {
1677
        if (ctx->explicit_qp) {
1678
            rc_quality = ctx->explicit_qp;
1679
        } else if (avctx->global_quality > 0) {
1680
            rc_quality = avctx->global_quality;
1681
        } else {
1682
            rc_quality = ctx->codec->default_quality;
1683
            av_log(avctx, AV_LOG_WARNING, "No quality level set; "
1684
                   "using default (%d).\n", rc_quality);
1685
        }
1686
    } else {
1687
        rc_quality = 0;
1688
    }
1689
1690
    if (rc_mode->hrd) {
1691
        if (avctx->rc_buffer_size)
1692
            hrd_buffer_size = avctx->rc_buffer_size;
1693
        else if (avctx->rc_max_rate > 0)
1694
            hrd_buffer_size = avctx->rc_max_rate;
1695
        else
1696
            hrd_buffer_size = avctx->bit_rate;
1697
        if (avctx->rc_initial_buffer_occupancy) {
1698
            if (avctx->rc_initial_buffer_occupancy > hrd_buffer_size) {
1699
                av_log(avctx, AV_LOG_ERROR, "Invalid RC buffer settings: "
1700
                       "must have initial buffer size (%d) <= "
1701
                       "buffer size (%"PRId64").\n",
1702
                       avctx->rc_initial_buffer_occupancy, hrd_buffer_size);
1703
                return AVERROR(EINVAL);
1704
            }
1705
            hrd_initial_buffer_fullness = avctx->rc_initial_buffer_occupancy;
1706
        } else {
1707
            hrd_initial_buffer_fullness = hrd_buffer_size * 3 / 4;
1708
        }
1709
1710
        rc_window_size = (hrd_buffer_size * 1000) / rc_bits_per_second;
1711
    } else {
1712
        if (avctx->rc_buffer_size || avctx->rc_initial_buffer_occupancy) {
1713
            av_log(avctx, AV_LOG_WARNING, "Buffering settings are ignored "
1714
                   "in %s RC mode.\n", rc_mode->name);
1715
        }
1716
1717
        hrd_buffer_size             = 0;
1718
        hrd_initial_buffer_fullness = 0;
1719
1720
        if (rc_mode->mode != RC_MODE_AVBR) {
1721
            // Already set (with completely different meaning) for AVBR.
1722
            rc_window_size = 1000;
1723
        }
1724
    }
1725
1726
    if (rc_bits_per_second          > UINT32_MAX ||
1727
        hrd_buffer_size             > UINT32_MAX ||
1728
        hrd_initial_buffer_fullness > UINT32_MAX) {
1729
        av_log(avctx, AV_LOG_ERROR, "RC parameters of 2^32 or "
1730
               "greater are not supported by VAAPI.\n");
1731
        return AVERROR(EINVAL);
1732
    }
1733
1734
    ctx->rc_mode     = rc_mode;
1735
    ctx->rc_quality  = rc_quality;
1736
    ctx->va_rc_mode  = rc_mode->va_mode;
1737
    ctx->va_bit_rate = rc_bits_per_second;
1738
1739
    av_log(avctx, AV_LOG_VERBOSE, "RC mode: %s.\n", rc_mode->name);
1740
    if (rc_attr.value == VA_ATTRIB_NOT_SUPPORTED) {
1741
        // This driver does not want the RC mode attribute to be set.
1742
    } else {
1743
        ctx->config_attributes[ctx->nb_config_attributes++] =
1744
            (VAConfigAttrib) {
1745
            .type  = VAConfigAttribRateControl,
1746
            .value = ctx->va_rc_mode,
1747
        };
1748
    }
1749
1750
    if (rc_mode->quality)
1751
        av_log(avctx, AV_LOG_VERBOSE, "RC quality: %d.\n", rc_quality);
1752
1753
    if (rc_mode->va_mode != VA_RC_CQP) {
1754
        if (rc_mode->mode == RC_MODE_AVBR) {
1755
            av_log(avctx, AV_LOG_VERBOSE, "RC target: %"PRId64" bps "
1756
                   "converging in %d frames with %d%% accuracy.\n",
1757
                   rc_bits_per_second, rc_window_size,
1758
                   rc_target_percentage);
1759
        } else if (rc_mode->bitrate) {
1760
            av_log(avctx, AV_LOG_VERBOSE, "RC target: %d%% of "
1761
                   "%"PRId64" bps over %d ms.\n", rc_target_percentage,
1762
                   rc_bits_per_second, rc_window_size);
1763
        }
1764
1765
        ctx->rc_params = (VAEncMiscParameterRateControl) {
1766
            .bits_per_second    = rc_bits_per_second,
1767
            .target_percentage  = rc_target_percentage,
1768
            .window_size        = rc_window_size,
1769
            .initial_qp         = 0,
1770
            .min_qp             = (avctx->qmin > 0 ? avctx->qmin : 0),
1771
            .basic_unit_size    = 0,
1772
#if VA_CHECK_VERSION(1, 1, 0)
1773
            .ICQ_quality_factor = av_clip(rc_quality, 1, 51),
1774
            .max_qp             = (avctx->qmax > 0 ? avctx->qmax : 0),
1775
#endif
1776
#if VA_CHECK_VERSION(1, 3, 0)
1777
            .quality_factor     = rc_quality,
1778
#endif
1779
        };
1780
        vaapi_encode_add_global_param(avctx,
1781
                                      VAEncMiscParameterTypeRateControl,
1782
                                      &ctx->rc_params,
1783
                                      sizeof(ctx->rc_params));
1784
    }
1785
1786
    if (rc_mode->hrd) {
1787
        av_log(avctx, AV_LOG_VERBOSE, "RC buffer: %"PRId64" bits, "
1788
               "initial fullness %"PRId64" bits.\n",
1789
               hrd_buffer_size, hrd_initial_buffer_fullness);
1790
1791
        ctx->hrd_params = (VAEncMiscParameterHRD) {
1792
            .initial_buffer_fullness = hrd_initial_buffer_fullness,
1793
            .buffer_size             = hrd_buffer_size,
1794
        };
1795
        vaapi_encode_add_global_param(avctx,
1796
                                      VAEncMiscParameterTypeHRD,
1797
                                      &ctx->hrd_params,
1798
                                      sizeof(ctx->hrd_params));
1799
    }
1800
1801
    if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
1802
        av_reduce(&fr_num, &fr_den,
1803
                  avctx->framerate.num, avctx->framerate.den, 65535);
1804
    else
1805
        av_reduce(&fr_num, &fr_den,
1806
                  avctx->time_base.den, avctx->time_base.num, 65535);
1807
1808
    av_log(avctx, AV_LOG_VERBOSE, "RC framerate: %d/%d (%.2f fps).\n",
1809
           fr_num, fr_den, (double)fr_num / fr_den);
1810
1811
    ctx->fr_params = (VAEncMiscParameterFrameRate) {
1812
        .framerate = (unsigned int)fr_den << 16 | fr_num,
1813
    };
1814
#if VA_CHECK_VERSION(0, 40, 0)
1815
    vaapi_encode_add_global_param(avctx,
1816
                                  VAEncMiscParameterTypeFrameRate,
1817
                                  &ctx->fr_params,
1818
                                  sizeof(ctx->fr_params));
1819
#endif
1820
1821
    return 0;
1822
}
1823
1824
static av_cold int vaapi_encode_init_gop_structure(AVCodecContext *avctx)
1825
{
1826
    VAAPIEncodeContext *ctx = avctx->priv_data;
1827
    VAStatus vas;
1828
    VAConfigAttrib attr = { VAConfigAttribEncMaxRefFrames };
1829
    uint32_t ref_l0, ref_l1;
1830
1831
    vas = vaGetConfigAttributes(ctx->hwctx->display,
1832
                                ctx->va_profile,
1833
                                ctx->va_entrypoint,
1834
                                &attr, 1);
1835
    if (vas != VA_STATUS_SUCCESS) {
1836
        av_log(avctx, AV_LOG_ERROR, "Failed to query reference frames "
1837
               "attribute: %d (%s).\n", vas, vaErrorStr(vas));
1838
        return AVERROR_EXTERNAL;
1839
    }
1840
1841
    if (attr.value == VA_ATTRIB_NOT_SUPPORTED) {
1842
        ref_l0 = ref_l1 = 0;
1843
    } else {
1844
        ref_l0 = attr.value       & 0xffff;
1845
        ref_l1 = attr.value >> 16 & 0xffff;
1846
    }
1847
1848
    if (ctx->codec->flags & FLAG_INTRA_ONLY ||
1849
        avctx->gop_size <= 1) {
1850
        av_log(avctx, AV_LOG_VERBOSE, "Using intra frames only.\n");
1851
        ctx->gop_size = 1;
1852
    } else if (ref_l0 < 1) {
1853
        av_log(avctx, AV_LOG_ERROR, "Driver does not support any "
1854
               "reference frames.\n");
1855
        return AVERROR(EINVAL);
1856
    } else if (!(ctx->codec->flags & FLAG_B_PICTURES) ||
1857
               ref_l1 < 1 || avctx->max_b_frames < 1) {
1858
        av_log(avctx, AV_LOG_VERBOSE, "Using intra and P-frames "
1859
               "(supported references: %d / %d).\n", ref_l0, ref_l1);
1860
        ctx->gop_size = avctx->gop_size;
1861
        ctx->p_per_i  = INT_MAX;
1862
        ctx->b_per_p  = 0;
1863
    } else {
1864
        av_log(avctx, AV_LOG_VERBOSE, "Using intra, P- and B-frames "
1865
               "(supported references: %d / %d).\n", ref_l0, ref_l1);
1866
        ctx->gop_size = avctx->gop_size;
1867
        ctx->p_per_i  = INT_MAX;
1868
        ctx->b_per_p  = avctx->max_b_frames;
1869
        if (ctx->codec->flags & FLAG_B_PICTURE_REFERENCES) {
1870
            ctx->max_b_depth = FFMIN(ctx->desired_b_depth,
1871
                                     av_log2(ctx->b_per_p) + 1);
1872
        } else {
1873
            ctx->max_b_depth = 1;
1874
        }
1875
    }
1876
1877
    if (ctx->codec->flags & FLAG_NON_IDR_KEY_PICTURES) {
1878
        ctx->closed_gop  = !!(avctx->flags & AV_CODEC_FLAG_CLOSED_GOP);
1879
        ctx->gop_per_idr = ctx->idr_interval + 1;
1880
    } else {
1881
        ctx->closed_gop  = 1;
1882
        ctx->gop_per_idr = 1;
1883
    }
1884
1885
    return 0;
1886
}
1887
1888
static av_cold int vaapi_encode_init_row_slice_structure(AVCodecContext *avctx,
1889
                                                         uint32_t slice_structure)
1890
{
1891
    VAAPIEncodeContext *ctx = avctx->priv_data;
1892
    int req_slices;
1893
1894
    // For fixed-size slices currently we only support whole rows, making
1895
    // rectangular slices.  This could be extended to arbitrary runs of
1896
    // blocks, but since slices tend to be a conformance requirement and
1897
    // most cases (such as broadcast or bluray) want rectangular slices
1898
    // only it would need to be gated behind another option.
1899
    if (avctx->slices > ctx->slice_block_rows) {
1900
        av_log(avctx, AV_LOG_WARNING, "Not enough rows to use "
1901
               "configured number of slices (%d < %d); using "
1902
               "maximum.\n", ctx->slice_block_rows, avctx->slices);
1903
        req_slices = ctx->slice_block_rows;
1904
    } else {
1905
        req_slices = avctx->slices;
1906
    }
1907
    if (slice_structure & VA_ENC_SLICE_STRUCTURE_ARBITRARY_ROWS ||
1908
        slice_structure & VA_ENC_SLICE_STRUCTURE_ARBITRARY_MACROBLOCKS) {
1909
        ctx->nb_slices  = req_slices;
1910
        ctx->slice_size = ctx->slice_block_rows / ctx->nb_slices;
1911
    } else if (slice_structure & VA_ENC_SLICE_STRUCTURE_POWER_OF_TWO_ROWS) {
1912
        int k;
1913
        for (k = 1;; k *= 2) {
1914
            if (2 * k * (req_slices - 1) + 1 >= ctx->slice_block_rows)
1915
                break;
1916
        }
1917
        ctx->nb_slices  = (ctx->slice_block_rows + k - 1) / k;
1918
        ctx->slice_size = k;
1919
#if VA_CHECK_VERSION(1, 0, 0)
1920
    } else if (slice_structure & VA_ENC_SLICE_STRUCTURE_EQUAL_ROWS) {
1921
        ctx->nb_slices  = ctx->slice_block_rows;
1922
        ctx->slice_size = 1;
1923
#endif
1924
    } else {
1925
        av_log(avctx, AV_LOG_ERROR, "Driver does not support any usable "
1926
               "slice structure modes (%#x).\n", slice_structure);
1927
        return AVERROR(EINVAL);
1928
    }
1929
1930
    return 0;
1931
}
1932
1933
static av_cold int vaapi_encode_init_tile_slice_structure(AVCodecContext *avctx,
1934
                                                          uint32_t slice_structure)
1935
{
1936
    VAAPIEncodeContext *ctx = avctx->priv_data;
1937
    int i, req_tiles;
1938
1939
    if (!(slice_structure & VA_ENC_SLICE_STRUCTURE_ARBITRARY_MACROBLOCKS ||
1940
         (slice_structure & VA_ENC_SLICE_STRUCTURE_ARBITRARY_ROWS &&
1941
          ctx->tile_cols == 1))) {
1942
        av_log(avctx, AV_LOG_ERROR, "Supported slice structure (%#x) doesn't work for "
1943
               "current tile requirement.\n", slice_structure);
1944
        return AVERROR(EINVAL);
1945
    }
1946
1947
    if (ctx->tile_rows > ctx->slice_block_rows ||
1948
        ctx->tile_cols > ctx->slice_block_cols) {
1949
        av_log(avctx, AV_LOG_WARNING, "Not enough block rows/cols (%d x %d) "
1950
               "for configured number of tile (%d x %d); ",
1951
               ctx->slice_block_rows, ctx->slice_block_cols,
1952
               ctx->tile_rows, ctx->tile_cols);
1953
        ctx->tile_rows = ctx->tile_rows > ctx->slice_block_rows ?
1954
                                          ctx->slice_block_rows : ctx->tile_rows;
1955
        ctx->tile_cols = ctx->tile_cols > ctx->slice_block_cols ?
1956
                                          ctx->slice_block_cols : ctx->tile_cols;
1957
        av_log(avctx, AV_LOG_WARNING, "using allowed maximum (%d x %d).\n",
1958
               ctx->tile_rows, ctx->tile_cols);
1959
    }
1960
1961
    req_tiles = ctx->tile_rows * ctx->tile_cols;
1962
1963
    // Tile slice is not allowed to cross the boundary of a tile due to
1964
    // the constraints of media-driver. Currently we support one slice
1965
    // per tile. This could be extended to multiple slices per tile.
1966
    if (avctx->slices != req_tiles)
1967
        av_log(avctx, AV_LOG_WARNING, "The number of requested slices "
1968
               "mismatches with configured number of tile (%d != %d); "
1969
               "using requested tile number for slice.\n",
1970
               avctx->slices, req_tiles);
1971
1972
    ctx->nb_slices = req_tiles;
1973
1974
    // Default in uniform spacing
1975
    // 6-3, 6-5
1976
    for (i = 0; i < ctx->tile_cols; i++) {
1977
        ctx->col_width[i] = ( i + 1 ) * ctx->slice_block_cols / ctx->tile_cols -
1978
                                    i * ctx->slice_block_cols / ctx->tile_cols;
1979
        ctx->col_bd[i + 1]  = ctx->col_bd[i] + ctx->col_width[i];
1980
    }
1981
    // 6-4, 6-6
1982
    for (i = 0; i < ctx->tile_rows; i++) {
1983
        ctx->row_height[i] = ( i + 1 ) * ctx->slice_block_rows / ctx->tile_rows -
1984
                                     i * ctx->slice_block_rows / ctx->tile_rows;
1985
        ctx->row_bd[i + 1] = ctx->row_bd[i] + ctx->row_height[i];
1986
    }
1987
1988
    av_log(avctx, AV_LOG_VERBOSE, "Encoding pictures with %d x %d tile.\n",
1989
           ctx->tile_rows, ctx->tile_cols);
1990
1991
    return 0;
1992
}
1993
1994
static av_cold int vaapi_encode_init_slice_structure(AVCodecContext *avctx)
1995
{
1996
    VAAPIEncodeContext *ctx = avctx->priv_data;
1997
    VAConfigAttrib attr[3] = { { VAConfigAttribEncMaxSlices },
1998
                               { VAConfigAttribEncSliceStructure },
1999
#if VA_CHECK_VERSION(1, 1, 0)
2000
                               { VAConfigAttribEncTileSupport },
2001
#endif
2002
                             };
2003
    VAStatus vas;
2004
    uint32_t max_slices, slice_structure;
2005
    int ret;
2006
2007
    if (!(ctx->codec->flags & FLAG_SLICE_CONTROL)) {
2008
        if (avctx->slices > 0) {
2009
            av_log(avctx, AV_LOG_WARNING, "Multiple slices were requested "
2010
                   "but this codec does not support controlling slices.\n");
2011
        }
2012
        return 0;
2013
    }
2014
2015
    ctx->slice_block_rows = (avctx->height + ctx->slice_block_height - 1) /
2016
                             ctx->slice_block_height;
2017
    ctx->slice_block_cols = (avctx->width  + ctx->slice_block_width  - 1) /
2018
                             ctx->slice_block_width;
2019
2020
    if (avctx->slices <= 1 && !ctx->tile_rows && !ctx->tile_cols) {
2021
        ctx->nb_slices  = 1;
2022
        ctx->slice_size = ctx->slice_block_rows;
2023
        return 0;
2024
    }
2025
2026
    vas = vaGetConfigAttributes(ctx->hwctx->display,
2027
                                ctx->va_profile,
2028
                                ctx->va_entrypoint,
2029
                                attr, FF_ARRAY_ELEMS(attr));
2030
    if (vas != VA_STATUS_SUCCESS) {
2031
        av_log(avctx, AV_LOG_ERROR, "Failed to query slice "
2032
               "attributes: %d (%s).\n", vas, vaErrorStr(vas));
2033
        return AVERROR_EXTERNAL;
2034
    }
2035
    max_slices      = attr[0].value;
2036
    slice_structure = attr[1].value;
2037
    if (max_slices      == VA_ATTRIB_NOT_SUPPORTED ||
2038
        slice_structure == VA_ATTRIB_NOT_SUPPORTED) {
2039
        av_log(avctx, AV_LOG_ERROR, "Driver does not support encoding "
2040
               "pictures as multiple slices.\n.");
2041
        return AVERROR(EINVAL);
2042
    }
2043
2044
    if (ctx->tile_rows && ctx->tile_cols) {
2045
#if VA_CHECK_VERSION(1, 1, 0)
2046
        uint32_t tile_support = attr[2].value;
2047
        if (tile_support == VA_ATTRIB_NOT_SUPPORTED) {
2048
            av_log(avctx, AV_LOG_ERROR, "Driver does not support encoding "
2049
                   "pictures as multiple tiles.\n.");
2050
            return AVERROR(EINVAL);
2051
        }
2052
#else
2053
        av_log(avctx, AV_LOG_ERROR, "Tile encoding option is "
2054
            "not supported with this VAAPI version.\n");
2055
        return AVERROR(EINVAL);
2056
#endif
2057
    }
2058
2059
    if (ctx->tile_rows && ctx->tile_cols)
2060
        ret = vaapi_encode_init_tile_slice_structure(avctx, slice_structure);
2061
    else
2062
        ret = vaapi_encode_init_row_slice_structure(avctx, slice_structure);
2063
    if (ret < 0)
2064
        return ret;
2065
2066
    if (ctx->nb_slices > avctx->slices) {
2067
        av_log(avctx, AV_LOG_WARNING, "Slice count rounded up to "
2068
               "%d (from %d) due to driver constraints on slice "
2069
               "structure.\n", ctx->nb_slices, avctx->slices);
2070
    }
2071
    if (ctx->nb_slices > max_slices) {
2072
        av_log(avctx, AV_LOG_ERROR, "Driver does not support "
2073
               "encoding with %d slices (max %"PRIu32").\n",
2074
               ctx->nb_slices, max_slices);
2075
        return AVERROR(EINVAL);
2076
    }
2077
2078
    av_log(avctx, AV_LOG_VERBOSE, "Encoding pictures with %d slices.\n",
2079
           ctx->nb_slices);
2080
    return 0;
2081
}
2082
2083
static av_cold int vaapi_encode_init_packed_headers(AVCodecContext *avctx)
2084
{
2085
    VAAPIEncodeContext *ctx = avctx->priv_data;
2086
    VAStatus vas;
2087
    VAConfigAttrib attr = { VAConfigAttribEncPackedHeaders };
2088
2089
    vas = vaGetConfigAttributes(ctx->hwctx->display,
2090
                                ctx->va_profile,
2091
                                ctx->va_entrypoint,
2092
                                &attr, 1);
2093
    if (vas != VA_STATUS_SUCCESS) {
2094
        av_log(avctx, AV_LOG_ERROR, "Failed to query packed headers "
2095
               "attribute: %d (%s).\n", vas, vaErrorStr(vas));
2096
        return AVERROR_EXTERNAL;
2097
    }
2098
2099
    if (attr.value == VA_ATTRIB_NOT_SUPPORTED) {
2100
        if (ctx->desired_packed_headers) {
2101
            av_log(avctx, AV_LOG_WARNING, "Driver does not support any "
2102
                   "packed headers (wanted %#x).\n",
2103
                   ctx->desired_packed_headers);
2104
        } else {
2105
            av_log(avctx, AV_LOG_VERBOSE, "Driver does not support any "
2106
                   "packed headers (none wanted).\n");
2107
        }
2108
        ctx->va_packed_headers = 0;
2109
    } else {
2110
        if (ctx->desired_packed_headers & ~attr.value) {
2111
            av_log(avctx, AV_LOG_WARNING, "Driver does not support some "
2112
                   "wanted packed headers (wanted %#x, found %#x).\n",
2113
                   ctx->desired_packed_headers, attr.value);
2114
        } else {
2115
            av_log(avctx, AV_LOG_VERBOSE, "All wanted packed headers "
2116
                   "available (wanted %#x, found %#x).\n",
2117
                   ctx->desired_packed_headers, attr.value);
2118
        }
2119
        ctx->va_packed_headers = ctx->desired_packed_headers & attr.value;
2120
    }
2121
2122
    if (ctx->va_packed_headers) {
2123
        ctx->config_attributes[ctx->nb_config_attributes++] =
2124
            (VAConfigAttrib) {
2125
            .type  = VAConfigAttribEncPackedHeaders,
2126
            .value = ctx->va_packed_headers,
2127
        };
2128
    }
2129
2130
    if ( (ctx->desired_packed_headers & VA_ENC_PACKED_HEADER_SEQUENCE) &&
2131
        !(ctx->va_packed_headers      & VA_ENC_PACKED_HEADER_SEQUENCE) &&
2132
         (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)) {
2133
        av_log(avctx, AV_LOG_WARNING, "Driver does not support packed "
2134
               "sequence headers, but a global header is requested.\n");
2135
        av_log(avctx, AV_LOG_WARNING, "No global header will be written: "
2136
               "this may result in a stream which is not usable for some "
2137
               "purposes (e.g. not muxable to some containers).\n");
2138
    }
2139
2140
    return 0;
2141
}
2142
2143
static av_cold int vaapi_encode_init_quality(AVCodecContext *avctx)
2144
{
2145
#if VA_CHECK_VERSION(0, 36, 0)
2146
    VAAPIEncodeContext *ctx = avctx->priv_data;
2147
    VAStatus vas;
2148
    VAConfigAttrib attr = { VAConfigAttribEncQualityRange };
2149
    int quality = avctx->compression_level;
2150
2151
    vas = vaGetConfigAttributes(ctx->hwctx->display,
2152
                                ctx->va_profile,
2153
                                ctx->va_entrypoint,
2154
                                &attr, 1);
2155
    if (vas != VA_STATUS_SUCCESS) {
2156
        av_log(avctx, AV_LOG_ERROR, "Failed to query quality "
2157
               "config attribute: %d (%s).\n", vas, vaErrorStr(vas));
2158
        return AVERROR_EXTERNAL;
2159
    }
2160
2161
    if (attr.value == VA_ATTRIB_NOT_SUPPORTED) {
2162
        if (quality != 0) {
2163
            av_log(avctx, AV_LOG_WARNING, "Quality attribute is not "
2164
                   "supported: will use default quality level.\n");
2165
        }
2166
    } else {
2167
        if (quality > attr.value) {
2168
            av_log(avctx, AV_LOG_WARNING, "Invalid quality level: "
2169
                   "valid range is 0-%d, using %d.\n",
2170
                   attr.value, attr.value);
2171
            quality = attr.value;
2172
        }
2173
2174
        ctx->quality_params = (VAEncMiscParameterBufferQualityLevel) {
2175
            .quality_level = quality,
2176
        };
2177
        vaapi_encode_add_global_param(avctx,
2178
                                      VAEncMiscParameterTypeQualityLevel,
2179
                                      &ctx->quality_params,
2180
                                      sizeof(ctx->quality_params));
2181
    }
2182
#else
2183
    av_log(avctx, AV_LOG_WARNING, "The encode quality option is "
2184
           "not supported with this VAAPI version.\n");
2185
#endif
2186
2187
    return 0;
2188
}
2189
2190
static av_cold int vaapi_encode_init_roi(AVCodecContext *avctx)
2191
{
2192
#if VA_CHECK_VERSION(1, 0, 0)
2193
    VAAPIEncodeContext *ctx = avctx->priv_data;
2194
    VAStatus vas;
2195
    VAConfigAttrib attr = { VAConfigAttribEncROI };
2196
2197
    vas = vaGetConfigAttributes(ctx->hwctx->display,
2198
                                ctx->va_profile,
2199
                                ctx->va_entrypoint,
2200
                                &attr, 1);
2201
    if (vas != VA_STATUS_SUCCESS) {
2202
        av_log(avctx, AV_LOG_ERROR, "Failed to query ROI "
2203
               "config attribute: %d (%s).\n", vas, vaErrorStr(vas));
2204
        return AVERROR_EXTERNAL;
2205
    }
2206
2207
    if (attr.value == VA_ATTRIB_NOT_SUPPORTED) {
2208
        ctx->roi_allowed = 0;
2209
    } else {
2210
        VAConfigAttribValEncROI roi = {
2211
            .value = attr.value,
2212
        };
2213
2214
        ctx->roi_max_regions = roi.bits.num_roi_regions;
2215
        ctx->roi_allowed = ctx->roi_max_regions > 0 &&
2216
            (ctx->va_rc_mode == VA_RC_CQP ||
2217
             roi.bits.roi_rc_qp_delta_support);
2218
    }
2219
#endif
2220
    return 0;
2221
}
2222
2223
static void vaapi_encode_free_output_buffer(void *opaque,
2224
                                            uint8_t *data)
2225
{
2226
    AVCodecContext   *avctx = opaque;
2227
    VAAPIEncodeContext *ctx = avctx->priv_data;
2228
    VABufferID buffer_id;
2229
2230
    buffer_id = (VABufferID)(uintptr_t)data;
2231
2232
    vaDestroyBuffer(ctx->hwctx->display, buffer_id);
2233
2234
    av_log(avctx, AV_LOG_DEBUG, "Freed output buffer %#x\n", buffer_id);
2235
}
2236
2237
static AVBufferRef *vaapi_encode_alloc_output_buffer(void *opaque,
2238
                                                     buffer_size_t size)
2239
{
2240
    AVCodecContext   *avctx = opaque;
2241
    VAAPIEncodeContext *ctx = avctx->priv_data;
2242
    VABufferID buffer_id;
2243
    VAStatus vas;
2244
    AVBufferRef *ref;
2245
2246
    // The output buffer size is fixed, so it needs to be large enough
2247
    // to hold the largest possible compressed frame.  We assume here
2248
    // that the uncompressed frame plus some header data is an upper
2249
    // bound on that.
2250
    vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,
2251
                         VAEncCodedBufferType,
2252
                         3 * ctx->surface_width * ctx->surface_height +
2253
                         (1 << 16), 1, 0, &buffer_id);
2254
    if (vas != VA_STATUS_SUCCESS) {
2255
        av_log(avctx, AV_LOG_ERROR, "Failed to create bitstream "
2256
               "output buffer: %d (%s).\n", vas, vaErrorStr(vas));
2257
        return NULL;
2258
    }
2259
2260
    av_log(avctx, AV_LOG_DEBUG, "Allocated output buffer %#x\n", buffer_id);
2261
2262
    ref = av_buffer_create((uint8_t*)(uintptr_t)buffer_id,
2263
                           sizeof(buffer_id),
2264
                           &vaapi_encode_free_output_buffer,
2265
                           avctx, AV_BUFFER_FLAG_READONLY);
2266
    if (!ref) {
2267
        vaDestroyBuffer(ctx->hwctx->display, buffer_id);
2268
        return NULL;
2269
    }
2270
2271
    return ref;
2272
}
2273
2274
static av_cold int vaapi_encode_create_recon_frames(AVCodecContext *avctx)
2275
{
2276
    VAAPIEncodeContext *ctx = avctx->priv_data;
2277
    AVVAAPIHWConfig *hwconfig = NULL;
2278
    AVHWFramesConstraints *constraints = NULL;
2279
    enum AVPixelFormat recon_format;
2280
    int err, i;
2281
2282
    hwconfig = av_hwdevice_hwconfig_alloc(ctx->device_ref);
2283
    if (!hwconfig) {
2284
        err = AVERROR(ENOMEM);
2285
        goto fail;
2286
    }
2287
    hwconfig->config_id = ctx->va_config;
2288
2289
    constraints = av_hwdevice_get_hwframe_constraints(ctx->device_ref,
2290
                                                      hwconfig);
2291
    if (!constraints) {
2292
        err = AVERROR(ENOMEM);
2293
        goto fail;
2294
    }
2295
2296
    // Probably we can use the input surface format as the surface format
2297
    // of the reconstructed frames.  If not, we just pick the first (only?)
2298
    // format in the valid list and hope that it all works.
2299
    recon_format = AV_PIX_FMT_NONE;
2300
    if (constraints->valid_sw_formats) {
2301
        for (i = 0; constraints->valid_sw_formats[i] != AV_PIX_FMT_NONE; i++) {
2302
            if (ctx->input_frames->sw_format ==
2303
                constraints->valid_sw_formats[i]) {
2304
                recon_format = ctx->input_frames->sw_format;
2305
                break;
2306
            }
2307
        }
2308
        if (recon_format == AV_PIX_FMT_NONE) {
2309
            // No match.  Just use the first in the supported list and
2310
            // hope for the best.
2311
            recon_format = constraints->valid_sw_formats[0];
2312
        }
2313
    } else {
2314
        // No idea what to use; copy input format.
2315
        recon_format = ctx->input_frames->sw_format;
2316
    }
2317
    av_log(avctx, AV_LOG_DEBUG, "Using %s as format of "
2318
           "reconstructed frames.\n", av_get_pix_fmt_name(recon_format));
2319
2320
    if (ctx->surface_width  < constraints->min_width  ||
2321
        ctx->surface_height < constraints->min_height ||
2322
        ctx->surface_width  > constraints->max_width ||
2323
        ctx->surface_height > constraints->max_height) {
2324
        av_log(avctx, AV_LOG_ERROR, "Hardware does not support encoding at "
2325
               "size %dx%d (constraints: width %d-%d height %d-%d).\n",
2326
               ctx->surface_width, ctx->surface_height,
2327
               constraints->min_width,  constraints->max_width,
2328
               constraints->min_height, constraints->max_height);
2329
        err = AVERROR(EINVAL);
2330
        goto fail;
2331
    }
2332
2333
    av_freep(&hwconfig);
2334
    av_hwframe_constraints_free(&constraints);
2335
2336
    ctx->recon_frames_ref = av_hwframe_ctx_alloc(ctx->device_ref);
2337
    if (!ctx->recon_frames_ref) {
2338
        err = AVERROR(ENOMEM);
2339
        goto fail;
2340
    }
2341
    ctx->recon_frames = (AVHWFramesContext*)ctx->recon_frames_ref->data;
2342
2343
    ctx->recon_frames->format    = AV_PIX_FMT_VAAPI;
2344
    ctx->recon_frames->sw_format = recon_format;
2345
    ctx->recon_frames->width     = ctx->surface_width;
2346
    ctx->recon_frames->height    = ctx->surface_height;
2347
2348
    err = av_hwframe_ctx_init(ctx->recon_frames_ref);
2349
    if (err < 0) {
2350
        av_log(avctx, AV_LOG_ERROR, "Failed to initialise reconstructed "
2351
               "frame context: %d.\n", err);
2352
        goto fail;
2353
    }
2354
2355
    err = 0;
2356
  fail:
2357
    av_freep(&hwconfig);
2358
    av_hwframe_constraints_free(&constraints);
2359
    return err;
2360
}
2361
2362
av_cold int ff_vaapi_encode_init(AVCodecContext *avctx)
2363
{
2364
    VAAPIEncodeContext *ctx = avctx->priv_data;
2365
    AVVAAPIFramesContext *recon_hwctx = NULL;
2366
    VAStatus vas;
2367
    int err;
2368
2369
    ctx->frame = av_frame_alloc();
2370
    if (!ctx->frame) {
2371
        return AVERROR(ENOMEM);
2372
    }
2373
2374
    if (!avctx->hw_frames_ctx) {
2375
        av_log(avctx, AV_LOG_ERROR, "A hardware frames reference is "
2376
               "required to associate the encoding device.\n");
2377
        return AVERROR(EINVAL);
2378
    }
2379
2380
    ctx->va_config  = VA_INVALID_ID;
2381
    ctx->va_context = VA_INVALID_ID;
2382
2383
    ctx->input_frames_ref = av_buffer_ref(avctx->hw_frames_ctx);
2384
    if (!ctx->input_frames_ref) {
2385
        err = AVERROR(ENOMEM);
2386
        goto fail;
2387
    }
2388
    ctx->input_frames = (AVHWFramesContext*)ctx->input_frames_ref->data;
2389
2390
    ctx->device_ref = av_buffer_ref(ctx->input_frames->device_ref);
2391
    if (!ctx->device_ref) {
2392
        err = AVERROR(ENOMEM);
2393
        goto fail;
2394
    }
2395
    ctx->device = (AVHWDeviceContext*)ctx->device_ref->data;
2396
    ctx->hwctx = ctx->device->hwctx;
2397
2398
    err = vaapi_encode_profile_entrypoint(avctx);
2399
    if (err < 0)
2400
        goto fail;
2401
2402
    err = vaapi_encode_init_rate_control(avctx);
2403
    if (err < 0)
2404
        goto fail;
2405
2406
    err = vaapi_encode_init_gop_structure(avctx);
2407
    if (err < 0)
2408
        goto fail;
2409
2410
    err = vaapi_encode_init_slice_structure(avctx);
2411
    if (err < 0)
2412
        goto fail;
2413
2414
    err = vaapi_encode_init_packed_headers(avctx);
2415
    if (err < 0)
2416
        goto fail;
2417
2418
    err = vaapi_encode_init_roi(avctx);
2419
    if (err < 0)
2420
        goto fail;
2421
2422
    if (avctx->compression_level >= 0) {
2423
        err = vaapi_encode_init_quality(avctx);
2424
        if (err < 0)
2425
            goto fail;
2426
    }
2427
2428
    vas = vaCreateConfig(ctx->hwctx->display,
2429
                         ctx->va_profile, ctx->va_entrypoint,
2430
                         ctx->config_attributes, ctx->nb_config_attributes,
2431
                         &ctx->va_config);
2432
    if (vas != VA_STATUS_SUCCESS) {
2433
        av_log(avctx, AV_LOG_ERROR, "Failed to create encode pipeline "
2434
               "configuration: %d (%s).\n", vas, vaErrorStr(vas));
2435
        err = AVERROR(EIO);
2436
        goto fail;
2437
    }
2438
2439
    err = vaapi_encode_create_recon_frames(avctx);
2440
    if (err < 0)
2441
        goto fail;
2442
2443
    recon_hwctx = ctx->recon_frames->hwctx;
2444
    vas = vaCreateContext(ctx->hwctx->display, ctx->va_config,
2445
                          ctx->surface_width, ctx->surface_height,
2446
                          VA_PROGRESSIVE,
2447
                          recon_hwctx->surface_ids,
2448
                          recon_hwctx->nb_surfaces,
2449
                          &ctx->va_context);
2450
    if (vas != VA_STATUS_SUCCESS) {
2451
        av_log(avctx, AV_LOG_ERROR, "Failed to create encode pipeline "
2452
               "context: %d (%s).\n", vas, vaErrorStr(vas));
2453
        err = AVERROR(EIO);
2454
        goto fail;
2455
    }
2456
2457
    ctx->output_buffer_pool =
2458
        av_buffer_pool_init2(sizeof(VABufferID), avctx,
2459
                             &vaapi_encode_alloc_output_buffer, NULL);
2460
    if (!ctx->output_buffer_pool) {
2461
        err = AVERROR(ENOMEM);
2462
        goto fail;
2463
    }
2464
2465
    if (ctx->codec->configure) {
2466
        err = ctx->codec->configure(avctx);
2467
        if (err < 0)
2468
            goto fail;
2469
    }
2470
2471
    ctx->output_delay = ctx->b_per_p;
2472
    ctx->decode_delay = ctx->max_b_depth;
2473
2474
    if (ctx->codec->sequence_params_size > 0) {
2475
        ctx->codec_sequence_params =
2476
            av_mallocz(ctx->codec->sequence_params_size);
2477
        if (!ctx->codec_sequence_params) {
2478
            err = AVERROR(ENOMEM);
2479
            goto fail;
2480
        }
2481
    }
2482
    if (ctx->codec->picture_params_size > 0) {
2483
        ctx->codec_picture_params =
2484
            av_mallocz(ctx->codec->picture_params_size);
2485
        if (!ctx->codec_picture_params) {
2486
            err = AVERROR(ENOMEM);
2487
            goto fail;
2488
        }
2489
    }
2490
2491
    if (ctx->codec->init_sequence_params) {
2492
        err = ctx->codec->init_sequence_params(avctx);
2493
        if (err < 0) {
2494
            av_log(avctx, AV_LOG_ERROR, "Codec sequence initialisation "
2495
                   "failed: %d.\n", err);
2496
            goto fail;
2497
        }
2498
    }
2499
2500
    if (ctx->va_packed_headers & VA_ENC_PACKED_HEADER_SEQUENCE &&
2501
        ctx->codec->write_sequence_header &&
2502
        avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
2503
        char data[MAX_PARAM_BUFFER_SIZE];
2504
        size_t bit_len = 8 * sizeof(data);
2505
2506
        err = ctx->codec->write_sequence_header(avctx, data, &bit_len);
2507
        if (err < 0) {
2508
            av_log(avctx, AV_LOG_ERROR, "Failed to write sequence header "
2509
                   "for extradata: %d.\n", err);
2510
            goto fail;
2511
        } else {
2512
            avctx->extradata_size = (bit_len + 7) / 8;
2513
            avctx->extradata = av_mallocz(avctx->extradata_size +
2514
                                          AV_INPUT_BUFFER_PADDING_SIZE);
2515
            if (!avctx->extradata) {
2516
                err = AVERROR(ENOMEM);
2517
                goto fail;
2518
            }
2519
            memcpy(avctx->extradata, data, avctx->extradata_size);
2520
        }
2521
    }
2522
2523
    return 0;
2524
2525
fail:
2526
    return err;
2527
}
2528
2529
av_cold int ff_vaapi_encode_close(AVCodecContext *avctx)
2530
{
2531
    VAAPIEncodeContext *ctx = avctx->priv_data;
2532
    VAAPIEncodePicture *pic, *next;
2533
2534
    for (pic = ctx->pic_start; pic; pic = next) {
2535
        next = pic->next;
2536
        vaapi_encode_free(avctx, pic);
2537
    }
2538
2539
    av_buffer_pool_uninit(&ctx->output_buffer_pool);
2540
2541
    if (ctx->va_context != VA_INVALID_ID) {
2542
        vaDestroyContext(ctx->hwctx->display, ctx->va_context);
2543
        ctx->va_context = VA_INVALID_ID;
2544
    }
2545
2546
    if (ctx->va_config != VA_INVALID_ID) {
2547
        vaDestroyConfig(ctx->hwctx->display, ctx->va_config);
2548
        ctx->va_config = VA_INVALID_ID;
2549
    }
2550
2551
    av_frame_free(&ctx->frame);
2552
2553
    av_freep(&ctx->codec_sequence_params);
2554
    av_freep(&ctx->codec_picture_params);
2555
2556
    av_buffer_unref(&ctx->recon_frames_ref);
2557
    av_buffer_unref(&ctx->input_frames_ref);
2558
    av_buffer_unref(&ctx->device_ref);
2559
2560
    return 0;
2561
}