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

   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/log.h"
  25 #include "libavutil/pixdesc.h"
  26
  27 #include "vaapi_encode.h"
  28 #include "avcodec.h"
  29
  30 static const char * const picture_type_name[] = { "IDR", "I", "P", "B" };
  31
  32 static int vaapi_encode_make_packed_header(AVCodecContext *avctx,
  33                                            VAAPIEncodePicture *pic,
  34                                            int type, char *data, size_t bit_len)
  35 {
  36     VAAPIEncodeContext *ctx = avctx->priv_data;
  37     VAStatus vas;
  38     VABufferID param_buffer, data_buffer;
  39     VABufferID *tmp;
  40     VAEncPackedHeaderParameterBuffer params = {
  41         .type = type,
  42         .bit_length = bit_len,
  43         .has_emulation_bytes = 1,
  44     };
  45
  46     tmp = av_realloc_array(pic->param_buffers, sizeof(*tmp), pic->nb_param_buffers + 2);
  47     if (!tmp)
  48         return AVERROR(ENOMEM);
  49     pic->param_buffers = tmp;
  50
  51     vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,
  52                          VAEncPackedHeaderParameterBufferType,
  53                          sizeof(params), 1, &params, &param_buffer);
  54     if (vas != VA_STATUS_SUCCESS) {
  55         av_log(avctx, AV_LOG_ERROR, "Failed to create parameter buffer "
  56                "for packed header (type %d): %d (%s).\n",
  57                type, vas, vaErrorStr(vas));
  58         return AVERROR(EIO);
  59     }
  60     pic->param_buffers[pic->nb_param_buffers++] = param_buffer;
  61
  62     vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,
  63                          VAEncPackedHeaderDataBufferType,
  64                          (bit_len + 7) / 8, 1, data, &data_buffer);
  65     if (vas != VA_STATUS_SUCCESS) {
  66         av_log(avctx, AV_LOG_ERROR, "Failed to create data buffer "
  67                "for packed header (type %d): %d (%s).\n",
  68                type, vas, vaErrorStr(vas));
  69         return AVERROR(EIO);
  70     }
  71     pic->param_buffers[pic->nb_param_buffers++] = data_buffer;
  72
  73     av_log(avctx, AV_LOG_DEBUG, "Packed header buffer (%d) is %#x/%#x "
  74            "(%zu bits).\n", type, param_buffer, data_buffer, bit_len);
  75     return 0;
  76 }
  77
  78 static int vaapi_encode_make_param_buffer(AVCodecContext *avctx,
  79                                           VAAPIEncodePicture *pic,
  80                                           int type, char *data, size_t len)
  81 {
  82     VAAPIEncodeContext *ctx = avctx->priv_data;
  83     VAStatus vas;
  84     VABufferID *tmp;
  85     VABufferID buffer;
  86
  87     tmp = av_realloc_array(pic->param_buffers, sizeof(*tmp), pic->nb_param_buffers + 1);
  88     if (!tmp)
  89         return AVERROR(ENOMEM);
  90     pic->param_buffers = tmp;
  91
  92     vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,
  93                          type, len, 1, data, &buffer);
  94     if (vas != VA_STATUS_SUCCESS) {
  95         av_log(avctx, AV_LOG_ERROR, "Failed to create parameter buffer "
  96                "(type %d): %d (%s).\n", type, vas, vaErrorStr(vas));
  97         return AVERROR(EIO);
  98     }
  99     pic->param_buffers[pic->nb_param_buffers++] = buffer;
 100
 101     av_log(avctx, AV_LOG_DEBUG, "Param buffer (%d) is %#x.\n",
 102            type, buffer);
 103     return 0;
 104 }
 105
 106 static int vaapi_encode_wait(AVCodecContext *avctx,
 107                              VAAPIEncodePicture *pic)
 108 {
 109     VAAPIEncodeContext *ctx = avctx->priv_data;
 110     VAStatus vas;
 111
 112     av_assert0(pic->encode_issued);
 113
 114     if (pic->encode_complete) {
 115         // Already waited for this picture.
 116         return 0;
 117     }
 118
 119     av_log(avctx, AV_LOG_DEBUG, "Sync to pic %"PRId64"/%"PRId64" "
 120            "(input surface %#x).\n", pic->display_order,
 121            pic->encode_order, pic->input_surface);
 122
 123     vas = vaSyncSurface(ctx->hwctx->display, pic->input_surface);
 124     if (vas != VA_STATUS_SUCCESS) {
 125         av_log(avctx, AV_LOG_ERROR, "Failed to sync to picture completion: "
 126                "%d (%s).\n", vas, vaErrorStr(vas));
 127         return AVERROR(EIO);
 128     }
 129
 130     // Input is definitely finished with now.
 131     av_frame_free(&pic->input_image);
 132
 133     pic->encode_complete = 1;
 134     return 0;
 135 }
 136
 137 static int vaapi_encode_issue(AVCodecContext *avctx,
 138                               VAAPIEncodePicture *pic)
 139 {
 140     VAAPIEncodeContext *ctx = avctx->priv_data;
 141     VAAPIEncodeSlice *slice;
 142     VAStatus vas;
 143     int err, i;
 144     char data[MAX_PARAM_BUFFER_SIZE];
 145     size_t bit_len;
 146
 147     av_log(avctx, AV_LOG_DEBUG, "Issuing encode for pic %"PRId64"/%"PRId64" "
 148            "as type %s.\n", pic->display_order, pic->encode_order,
 149            picture_type_name[pic->type]);
 150     if (pic->nb_refs == 0) {
 151         av_log(avctx, AV_LOG_DEBUG, "No reference pictures.\n");
 152     } else {
 153         av_log(avctx, AV_LOG_DEBUG, "Refers to:");
 154         for (i = 0; i < pic->nb_refs; i++) {
 155             av_log(avctx, AV_LOG_DEBUG, " %"PRId64"/%"PRId64,
 156                    pic->refs[i]->display_order, pic->refs[i]->encode_order);
 157         }
 158         av_log(avctx, AV_LOG_DEBUG, ".\n");
 159     }
 160
 161     av_assert0(!pic->encode_issued);
 162     for (i = 0; i < pic->nb_refs; i++) {
 163         av_assert0(pic->refs[i]);
 164         av_assert0(pic->refs[i]->encode_issued);
 165     }
 166
 167     av_log(avctx, AV_LOG_DEBUG, "Input surface is %#x.\n", pic->input_surface);
 168
 169     pic->recon_image = av_frame_alloc();
 170     if (!pic->recon_image) {
 171         err = AVERROR(ENOMEM);
 172         goto fail;
 173     }
 174
 175     err = av_hwframe_get_buffer(ctx->recon_frames_ref, pic->recon_image, 0);
 176     if (err < 0) {
 177         err = AVERROR(ENOMEM);
 178         goto fail;
 179     }
 180     pic->recon_surface = (VASurfaceID)(uintptr_t)pic->recon_image->data[3];
 181     av_log(avctx, AV_LOG_DEBUG, "Recon surface is %#x.\n", pic->recon_surface);
 182
 183     pic->output_buffer_ref = av_buffer_pool_get(ctx->output_buffer_pool);
 184     if (!pic->output_buffer_ref) {
 185         err = AVERROR(ENOMEM);
 186         goto fail;
 187     }
 188     pic->output_buffer = (VABufferID)(uintptr_t)pic->output_buffer_ref->data;
 189     av_log(avctx, AV_LOG_DEBUG, "Output buffer is %#x.\n",
 190            pic->output_buffer);
 191
 192     if (ctx->codec->picture_params_size > 0) {
 193         pic->codec_picture_params = av_malloc(ctx->codec->picture_params_size);
 194         if (!pic->codec_picture_params)
 195             goto fail;
 196         memcpy(pic->codec_picture_params, ctx->codec_picture_params,
 197                ctx->codec->picture_params_size);
 198     } else {
 199         av_assert0(!ctx->codec_picture_params);
 200     }
 201
 202     pic->nb_param_buffers = 0;
 203
 204     if (pic->type == PICTURE_TYPE_IDR && ctx->codec->init_sequence_params) {
 205         err = vaapi_encode_make_param_buffer(avctx, pic,
 206                                              VAEncSequenceParameterBufferType,
 207                                              ctx->codec_sequence_params,
 208                                              ctx->codec->sequence_params_size);
 209         if (err < 0)
 210             goto fail;
 211     }
 212
 213     if (pic->type == PICTURE_TYPE_IDR) {
 214         for (i = 0; i < ctx->nb_global_params; i++) {
 215             err = vaapi_encode_make_param_buffer(avctx, pic,
 216                                                  VAEncMiscParameterBufferType,
 217                                                  (char*)ctx->global_params[i],
 218                                                  ctx->global_params_size[i]);
 219             if (err < 0)
 220                 goto fail;
 221         }
 222     }
 223
 224     if (ctx->codec->init_picture_params) {
 225         err = ctx->codec->init_picture_params(avctx, pic);
 226         if (err < 0) {
 227             av_log(avctx, AV_LOG_ERROR, "Failed to initialise picture "
 228                    "parameters: %d.\n", err);
 229             goto fail;
 230         }
 231         err = vaapi_encode_make_param_buffer(avctx, pic,
 232                                              VAEncPictureParameterBufferType,
 233                                              pic->codec_picture_params,
 234                                              ctx->codec->picture_params_size);
 235         if (err < 0)
 236             goto fail;
 237     }
 238
 239     if (pic->type == PICTURE_TYPE_IDR) {
 240         if (ctx->va_packed_headers & VA_ENC_PACKED_HEADER_SEQUENCE &&
 241             ctx->codec->write_sequence_header) {
 242             bit_len = 8 * sizeof(data);
 243             err = ctx->codec->write_sequence_header(avctx, data, &bit_len);
 244             if (err < 0) {
 245                 av_log(avctx, AV_LOG_ERROR, "Failed to write per-sequence "
 246                        "header: %d.\n", err);
 247                 goto fail;
 248             }
 249             err = vaapi_encode_make_packed_header(avctx, pic,
 250                                                   ctx->codec->sequence_header_type,
 251                                                   data, bit_len);
 252             if (err < 0)
 253                 goto fail;
 254         }
 255     }
 256
 257     if (ctx->va_packed_headers & VA_ENC_PACKED_HEADER_PICTURE &&
 258         ctx->codec->write_picture_header) {
 259         bit_len = 8 * sizeof(data);
 260         err = ctx->codec->write_picture_header(avctx, pic, data, &bit_len);
 261         if (err < 0) {
 262             av_log(avctx, AV_LOG_ERROR, "Failed to write per-picture "
 263                    "header: %d.\n", err);
 264             goto fail;
 265         }
 266         err = vaapi_encode_make_packed_header(avctx, pic,
 267                                               ctx->codec->picture_header_type,
 268                                               data, bit_len);
 269         if (err < 0)
 270             goto fail;
 271     }
 272
 273     if (ctx->codec->write_extra_buffer) {
 274         for (i = 0;; i++) {
 275             size_t len = sizeof(data);
 276             int type;
 277             err = ctx->codec->write_extra_buffer(avctx, pic, i, &type,
 278                                                  data, &len);
 279             if (err == AVERROR_EOF)
 280                 break;
 281             if (err < 0) {
 282                 av_log(avctx, AV_LOG_ERROR, "Failed to write extra "
 283                        "buffer %d: %d.\n", i, err);
 284                 goto fail;
 285             }
 286
 287             err = vaapi_encode_make_param_buffer(avctx, pic, type,
 288                                                  data, len);
 289             if (err < 0)
 290                 goto fail;
 291         }
 292     }
 293
 294     if (ctx->va_packed_headers & VA_ENC_PACKED_HEADER_MISC &&
 295         ctx->codec->write_extra_header) {
 296         for (i = 0;; i++) {
 297             int type;
 298             bit_len = 8 * sizeof(data);
 299             err = ctx->codec->write_extra_header(avctx, pic, i, &type,
 300                                                  data, &bit_len);
 301             if (err == AVERROR_EOF)
 302                 break;
 303             if (err < 0) {
 304                 av_log(avctx, AV_LOG_ERROR, "Failed to write extra "
 305                        "header %d: %d.\n", i, err);
 306                 goto fail;
 307             }
 308
 309             err = vaapi_encode_make_packed_header(avctx, pic, type,
 310                                                   data, bit_len);
 311             if (err < 0)
 312                 goto fail;
 313         }
 314     }
 315
 316     if (pic->nb_slices == 0)
 317         pic->nb_slices = ctx->nb_slices;
 318     if (pic->nb_slices > 0) {
 319         int rounding;
 320
 321         pic->slices = av_mallocz_array(pic->nb_slices, sizeof(*pic->slices));
 322         if (!pic->slices) {
 323             err = AVERROR(ENOMEM);
 324             goto fail;
 325         }
 326
 327         for (i = 0; i < pic->nb_slices; i++)
 328             pic->slices[i].row_size = ctx->slice_size;
 329
 330         rounding = ctx->slice_block_rows - ctx->nb_slices * ctx->slice_size;
 331         if (rounding > 0) {
 332             // Place rounding error at top and bottom of frame.
 333             av_assert0(rounding < pic->nb_slices);
 334             // Some Intel drivers contain a bug where the encoder will fail
 335             // if the last slice is smaller than the one before it.  Since
 336             // that's straightforward to avoid here, just do so.
 337             if (rounding <= 2) {
 338                 for (i = 0; i < rounding; i++)
 339                     ++pic->slices[i].row_size;
 340             } else {
 341                 for (i = 0; i < (rounding + 1) / 2; i++)
 342                     ++pic->slices[pic->nb_slices - i - 1].row_size;
 343                 for (i = 0; i < rounding / 2; i++)
 344                     ++pic->slices[i].row_size;
 345             }
 346         } else if (rounding < 0) {
 347             // Remove rounding error from last slice only.
 348             av_assert0(rounding < ctx->slice_size);
 349             pic->slices[pic->nb_slices - 1].row_size += rounding;
 350         }
 351     }
 352     for (i = 0; i < pic->nb_slices; i++) {
 353         slice = &pic->slices[i];
 354         slice->index = i;
 355         if (i == 0) {
 356             slice->row_start   = 0;
 357             slice->block_start = 0;
 358         } else {
 359             const VAAPIEncodeSlice *prev = &pic->slices[i - 1];
 360             slice->row_start   = prev->row_start   + prev->row_size;
 361             slice->block_start = prev->block_start + prev->block_size;
 362         }
 363         slice->block_size  = slice->row_size * ctx->slice_block_cols;
 364
 365         av_log(avctx, AV_LOG_DEBUG, "Slice %d: %d-%d (%d rows), "
 366                "%d-%d (%d blocks).\n", i, slice->row_start,
 367                slice->row_start + slice->row_size - 1, slice->row_size,
 368                slice->block_start, slice->block_start + slice->block_size - 1,
 369                slice->block_size);
 370
 371         if (ctx->codec->slice_params_size > 0) {
 372             slice->codec_slice_params = av_mallocz(ctx->codec->slice_params_size);
 373             if (!slice->codec_slice_params) {
 374                 err = AVERROR(ENOMEM);
 375                 goto fail;
 376             }
 377         }
 378
 379         if (ctx->codec->init_slice_params) {
 380             err = ctx->codec->init_slice_params(avctx, pic, slice);
 381             if (err < 0) {
 382                 av_log(avctx, AV_LOG_ERROR, "Failed to initialise slice "
 383                        "parameters: %d.\n", err);
 384                 goto fail;
 385             }
 386         }
 387
 388         if (ctx->va_packed_headers & VA_ENC_PACKED_HEADER_SLICE &&
 389             ctx->codec->write_slice_header) {
 390             bit_len = 8 * sizeof(data);
 391             err = ctx->codec->write_slice_header(avctx, pic, slice,
 392                                                  data, &bit_len);
 393             if (err < 0) {
 394                 av_log(avctx, AV_LOG_ERROR, "Failed to write per-slice "
 395                        "header: %d.\n", err);
 396                 goto fail;
 397             }
 398             err = vaapi_encode_make_packed_header(avctx, pic,
 399                                                   ctx->codec->slice_header_type,
 400                                                   data, bit_len);
 401             if (err < 0)
 402                 goto fail;
 403         }
 404
 405         if (ctx->codec->init_slice_params) {
 406             err = vaapi_encode_make_param_buffer(avctx, pic,
 407                                                  VAEncSliceParameterBufferType,
 408                                                  slice->codec_slice_params,
 409                                                  ctx->codec->slice_params_size);
 410             if (err < 0)
 411                 goto fail;
 412         }
 413     }
 414
 415     vas = vaBeginPicture(ctx->hwctx->display, ctx->va_context,
 416                          pic->input_surface);
 417     if (vas != VA_STATUS_SUCCESS) {
 418         av_log(avctx, AV_LOG_ERROR, "Failed to begin picture encode issue: "
 419                "%d (%s).\n", vas, vaErrorStr(vas));
 420         err = AVERROR(EIO);
 421         goto fail_with_picture;
 422     }
 423
 424     vas = vaRenderPicture(ctx->hwctx->display, ctx->va_context,
 425                           pic->param_buffers, pic->nb_param_buffers);
 426     if (vas != VA_STATUS_SUCCESS) {
 427         av_log(avctx, AV_LOG_ERROR, "Failed to upload encode parameters: "
 428                "%d (%s).\n", vas, vaErrorStr(vas));
 429         err = AVERROR(EIO);
 430         goto fail_with_picture;
 431     }
 432
 433     vas = vaEndPicture(ctx->hwctx->display, ctx->va_context);
 434     if (vas != VA_STATUS_SUCCESS) {
 435         av_log(avctx, AV_LOG_ERROR, "Failed to end picture encode issue: "
 436                "%d (%s).\n", vas, vaErrorStr(vas));
 437         err = AVERROR(EIO);
 438         // vaRenderPicture() has been called here, so we should not destroy
 439         // the parameter buffers unless separate destruction is required.
 440         if (CONFIG_VAAPI_1 || ctx->hwctx->driver_quirks &
 441             AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS)
 442             goto fail;
 443         else
 444             goto fail_at_end;
 445     }
 446
 447     if (CONFIG_VAAPI_1 || ctx->hwctx->driver_quirks &
 448         AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS) {
 449         for (i = 0; i < pic->nb_param_buffers; i++) {
 450             vas = vaDestroyBuffer(ctx->hwctx->display,
 451                                   pic->param_buffers[i]);
 452             if (vas != VA_STATUS_SUCCESS) {
 453                 av_log(avctx, AV_LOG_ERROR, "Failed to destroy "
 454                        "param buffer %#x: %d (%s).\n",
 455                        pic->param_buffers[i], vas, vaErrorStr(vas));
 456                 // And ignore.
 457             }
 458         }
 459     }
 460
 461     pic->encode_issued = 1;
 462
 463     return 0;
 464
 465 fail_with_picture:
 466     vaEndPicture(ctx->hwctx->display, ctx->va_context);
 467 fail:
 468     for(i = 0; i < pic->nb_param_buffers; i++)
 469         vaDestroyBuffer(ctx->hwctx->display, pic->param_buffers[i]);
 470     for (i = 0; i < pic->nb_slices; i++) {
 471         if (pic->slices) {
 472             av_freep(&pic->slices[i].priv_data);
 473             av_freep(&pic->slices[i].codec_slice_params);
 474         }
 475     }
 476 fail_at_end:
 477     av_freep(&pic->codec_picture_params);
 478     av_freep(&pic->param_buffers);
 479     av_freep(&pic->slices);
 480     av_frame_free(&pic->recon_image);
 481     av_buffer_unref(&pic->output_buffer_ref);
 482     pic->output_buffer = VA_INVALID_ID;
 483     return err;
 484 }
 485
 486 static int vaapi_encode_output(AVCodecContext *avctx,
 487                                VAAPIEncodePicture *pic, AVPacket *pkt)
 488 {
 489     VAAPIEncodeContext *ctx = avctx->priv_data;
 490     VACodedBufferSegment *buf_list, *buf;
 491     VAStatus vas;
 492     int err;
 493
 494     err = vaapi_encode_wait(avctx, pic);
 495     if (err < 0)
 496         return err;
 497
 498     buf_list = NULL;
 499     vas = vaMapBuffer(ctx->hwctx->display, pic->output_buffer,
 500                       (void**)&buf_list);
 501     if (vas != VA_STATUS_SUCCESS) {
 502         av_log(avctx, AV_LOG_ERROR, "Failed to map output buffers: "
 503                "%d (%s).\n", vas, vaErrorStr(vas));
 504         err = AVERROR(EIO);
 505         goto fail;
 506     }
 507
 508     for (buf = buf_list; buf; buf = buf->next) {
 509         av_log(avctx, AV_LOG_DEBUG, "Output buffer: %u bytes "
 510                "(status %08x).\n", buf->size, buf->status);
 511
 512         err = av_new_packet(pkt, buf->size);
 513         if (err < 0)
 514             goto fail_mapped;
 515
 516         memcpy(pkt->data, buf->buf, buf->size);
 517     }
 518
 519     if (pic->type == PICTURE_TYPE_IDR)
 520         pkt->flags |= AV_PKT_FLAG_KEY;
 521
 522     pkt->pts = pic->pts;
 523
 524     vas = vaUnmapBuffer(ctx->hwctx->display, pic->output_buffer);
 525     if (vas != VA_STATUS_SUCCESS) {
 526         av_log(avctx, AV_LOG_ERROR, "Failed to unmap output buffers: "
 527                "%d (%s).\n", vas, vaErrorStr(vas));
 528         err = AVERROR(EIO);
 529         goto fail;
 530     }
 531
 532     av_buffer_unref(&pic->output_buffer_ref);
 533     pic->output_buffer = VA_INVALID_ID;
 534
 535     av_log(avctx, AV_LOG_DEBUG, "Output read for pic %"PRId64"/%"PRId64".\n",
 536            pic->display_order, pic->encode_order);
 537     return 0;
 538
 539 fail_mapped:
 540     vaUnmapBuffer(ctx->hwctx->display, pic->output_buffer);
 541 fail:
 542     av_buffer_unref(&pic->output_buffer_ref);
 543     pic->output_buffer = VA_INVALID_ID;
 544     return err;
 545 }
 546
 547 static int vaapi_encode_discard(AVCodecContext *avctx,
 548                                 VAAPIEncodePicture *pic)
 549 {
 550     vaapi_encode_wait(avctx, pic);
 551
 552     if (pic->output_buffer_ref) {
 553         av_log(avctx, AV_LOG_DEBUG, "Discard output for pic "
 554                "%"PRId64"/%"PRId64".\n",
 555                pic->display_order, pic->encode_order);
 556
 557         av_buffer_unref(&pic->output_buffer_ref);
 558         pic->output_buffer = VA_INVALID_ID;
 559     }
 560
 561     return 0;
 562 }
 563
 564 static VAAPIEncodePicture *vaapi_encode_alloc(AVCodecContext *avctx)
 565 {
 566     VAAPIEncodeContext *ctx = avctx->priv_data;
 567     VAAPIEncodePicture *pic;
 568
 569     pic = av_mallocz(sizeof(*pic));
 570     if (!pic)
 571         return NULL;
 572
 573     if (ctx->codec->picture_priv_data_size > 0) {
 574         pic->priv_data = av_mallocz(ctx->codec->picture_priv_data_size);
 575         if (!pic->priv_data) {
 576             av_freep(&pic);
 577             return NULL;
 578         }
 579     }
 580
 581     pic->input_surface = VA_INVALID_ID;
 582     pic->recon_surface = VA_INVALID_ID;
 583     pic->output_buffer = VA_INVALID_ID;
 584
 585     return pic;
 586 }
 587
 588 static int vaapi_encode_free(AVCodecContext *avctx,
 589                              VAAPIEncodePicture *pic)
 590 {
 591     int i;
 592
 593     if (pic->encode_issued)
 594         vaapi_encode_discard(avctx, pic);
 595
 596     for (i = 0; i < pic->nb_slices; i++) {
 597         if (pic->slices) {
 598             av_freep(&pic->slices[i].priv_data);
 599             av_freep(&pic->slices[i].codec_slice_params);
 600         }
 601     }
 602     av_freep(&pic->codec_picture_params);
 603
 604     av_frame_free(&pic->input_image);
 605     av_frame_free(&pic->recon_image);
 606
 607     av_freep(&pic->param_buffers);
 608     av_freep(&pic->slices);
 609     // Output buffer should already be destroyed.
 610     av_assert0(pic->output_buffer == VA_INVALID_ID);
 611
 612     av_freep(&pic->priv_data);
 613     av_freep(&pic->codec_picture_params);
 614
 615     av_free(pic);
 616
 617     return 0;
 618 }
 619
 620 static void vaapi_encode_add_ref(AVCodecContext *avctx,
 621                                  VAAPIEncodePicture *pic,
 622                                  VAAPIEncodePicture *target,
 623                                  int is_ref, int in_dpb, int prev)
 624 {
 625     int refs = 0;
 626
 627     if (is_ref) {
 628         av_assert0(pic != target);
 629         av_assert0(pic->nb_refs < MAX_PICTURE_REFERENCES);
 630         pic->refs[pic->nb_refs++] = target;
 631         ++refs;
 632     }
 633
 634     if (in_dpb) {
 635         av_assert0(pic->nb_dpb_pics < MAX_DPB_SIZE);
 636         pic->dpb[pic->nb_dpb_pics++] = target;
 637         ++refs;
 638     }
 639
 640     if (prev) {
 641         av_assert0(!pic->prev);
 642         pic->prev = target;
 643         ++refs;
 644     }
 645
 646     target->ref_count[0] += refs;
 647     target->ref_count[1] += refs;
 648 }
 649
 650 static void vaapi_encode_remove_refs(AVCodecContext *avctx,
 651                                      VAAPIEncodePicture *pic,
 652                                      int level)
 653 {
 654     int i;
 655
 656     if (pic->ref_removed[level])
 657         return;
 658
 659     for (i = 0; i < pic->nb_refs; i++) {
 660         av_assert0(pic->refs[i]);
 661         --pic->refs[i]->ref_count[level];
 662         av_assert0(pic->refs[i]->ref_count[level] >= 0);
 663     }
 664
 665     for (i = 0; i < pic->nb_dpb_pics; i++) {
 666         av_assert0(pic->dpb[i]);
 667         --pic->dpb[i]->ref_count[level];
 668         av_assert0(pic->dpb[i]->ref_count[level] >= 0);
 669     }
 670
 671     av_assert0(pic->prev || pic->type == PICTURE_TYPE_IDR);
 672     if (pic->prev) {
 673         --pic->prev->ref_count[level];
 674         av_assert0(pic->prev->ref_count[level] >= 0);
 675     }
 676
 677     pic->ref_removed[level] = 1;
 678 }
 679
 680 static void vaapi_encode_set_b_pictures(AVCodecContext *avctx,
 681                                         VAAPIEncodePicture *start,
 682                                         VAAPIEncodePicture *end,
 683                                         VAAPIEncodePicture *prev,
 684                                         int current_depth,
 685                                         VAAPIEncodePicture **last)
 686 {
 687     VAAPIEncodeContext *ctx = avctx->priv_data;
 688     VAAPIEncodePicture *pic, *next, *ref;
 689     int i, len;
 690
 691     av_assert0(start && end && start != end && start->next != end);
 692
 693     // If we are at the maximum depth then encode all pictures as
 694     // non-referenced B-pictures.  Also do this if there is exactly one
 695     // picture left, since there will be nothing to reference it.
 696     if (current_depth == ctx->max_b_depth || start->next->next == end) {
 697         for (pic = start->next; pic; pic = pic->next) {
 698             if (pic == end)
 699                 break;
 700             pic->type    = PICTURE_TYPE_B;
 701             pic->b_depth = current_depth;
 702
 703             vaapi_encode_add_ref(avctx, pic, start, 1, 1, 0);
 704             vaapi_encode_add_ref(avctx, pic, end,   1, 1, 0);
 705             vaapi_encode_add_ref(avctx, pic, prev,  0, 0, 1);
 706
 707             for (ref = end->refs[1]; ref; ref = ref->refs[1])
 708                 vaapi_encode_add_ref(avctx, pic, ref, 0, 1, 0);
 709         }
 710         *last = prev;
 711
 712     } else {
 713         // Split the current list at the midpoint with a referenced
 714         // B-picture, then descend into each side separately.
 715         len = 0;
 716         for (pic = start->next; pic != end; pic = pic->next)
 717             ++len;
 718         for (pic = start->next, i = 1; 2 * i < len; pic = pic->next, i++);
 719
 720         pic->type    = PICTURE_TYPE_B;
 721         pic->b_depth = current_depth;
 722
 723         pic->is_reference = 1;
 724
 725         vaapi_encode_add_ref(avctx, pic, pic,   0, 1, 0);
 726         vaapi_encode_add_ref(avctx, pic, start, 1, 1, 0);
 727         vaapi_encode_add_ref(avctx, pic, end,   1, 1, 0);
 728         vaapi_encode_add_ref(avctx, pic, prev,  0, 0, 1);
 729
 730         for (ref = end->refs[1]; ref; ref = ref->refs[1])
 731             vaapi_encode_add_ref(avctx, pic, ref, 0, 1, 0);
 732
 733         if (i > 1)
 734             vaapi_encode_set_b_pictures(avctx, start, pic, pic,
 735                                         current_depth + 1, &next);
 736         else
 737             next = pic;
 738
 739         vaapi_encode_set_b_pictures(avctx, pic, end, next,
 740                                     current_depth + 1, last);
 741     }
 742 }
 743
 744 static int vaapi_encode_pick_next(AVCodecContext *avctx,
 745                                   VAAPIEncodePicture **pic_out)
 746 {
 747     VAAPIEncodeContext *ctx = avctx->priv_data;
 748     VAAPIEncodePicture *pic = NULL, *next, *start;
 749     int i, b_counter, closed_gop_end;
 750
 751     // If there are any B-frames already queued, the next one to encode
 752     // is the earliest not-yet-issued frame for which all references are
 753     // available.
 754     for (pic = ctx->pic_start; pic; pic = pic->next) {
 755         if (pic->encode_issued)
 756             continue;
 757         if (pic->type != PICTURE_TYPE_B)
 758             continue;
 759         for (i = 0; i < pic->nb_refs; i++) {
 760             if (!pic->refs[i]->encode_issued)
 761                 break;
 762         }
 763         if (i == pic->nb_refs)
 764             break;
 765     }
 766
 767     if (pic) {
 768         av_log(avctx, AV_LOG_DEBUG, "Pick B-picture at depth %d to "
 769                "encode next.\n", pic->b_depth);
 770         *pic_out = pic;
 771         return 0;
 772     }
 773
 774     // Find the B-per-Pth available picture to become the next picture
 775     // on the top layer.
 776     start = NULL;
 777     b_counter = 0;
 778     closed_gop_end = ctx->closed_gop ||
 779                      ctx->idr_counter == ctx->gop_per_idr;
 780     for (pic = ctx->pic_start; pic; pic = next) {
 781         next = pic->next;
 782         if (pic->encode_issued) {
 783             start = pic;
 784             continue;
 785         }
 786         // If the next available picture is force-IDR, encode it to start
 787         // a new GOP immediately.
 788         if (pic->force_idr)
 789             break;
 790         if (b_counter == ctx->b_per_p)
 791             break;
 792         // If this picture ends a closed GOP or starts a new GOP then it
 793         // needs to be in the top layer.
 794         if (ctx->gop_counter + b_counter + closed_gop_end >= ctx->gop_size)
 795             break;
 796         // If the picture after this one is force-IDR, we need to encode
 797         // this one in the top layer.
 798         if (next && next->force_idr)
 799             break;
 800         ++b_counter;
 801     }
 802
 803     // At the end of the stream the last picture must be in the top layer.
 804     if (!pic && ctx->end_of_stream) {
 805         --b_counter;
 806         pic = ctx->pic_end;
 807         if (pic->encode_issued)
 808             return AVERROR_EOF;
 809     }
 810
 811     if (!pic) {
 812         av_log(avctx, AV_LOG_DEBUG, "Pick nothing to encode next - "
 813                "need more input for reference pictures.\n");
 814         return AVERROR(EAGAIN);
 815     }
 816     if (ctx->input_order <= ctx->decode_delay && !ctx->end_of_stream) {
 817         av_log(avctx, AV_LOG_DEBUG, "Pick nothing to encode next - "
 818                "need more input for timestamps.\n");
 819         return AVERROR(EAGAIN);
 820     }
 821
 822     if (pic->force_idr) {
 823         av_log(avctx, AV_LOG_DEBUG, "Pick forced IDR-picture to "
 824                "encode next.\n");
 825         pic->type = PICTURE_TYPE_IDR;
 826         ctx->idr_counter = 1;
 827         ctx->gop_counter = 1;
 828
 829     } else if (ctx->gop_counter + b_counter >= ctx->gop_size) {
 830         if (ctx->idr_counter == ctx->gop_per_idr) {
 831             av_log(avctx, AV_LOG_DEBUG, "Pick new-GOP IDR-picture to "
 832                    "encode next.\n");
 833             pic->type = PICTURE_TYPE_IDR;
 834             ctx->idr_counter = 1;
 835         } else {
 836             av_log(avctx, AV_LOG_DEBUG, "Pick new-GOP I-picture to "
 837                    "encode next.\n");
 838             pic->type = PICTURE_TYPE_I;
 839             ++ctx->idr_counter;
 840         }
 841         ctx->gop_counter = 1;
 842
 843     } else {
 844         if (ctx->gop_counter + b_counter + closed_gop_end == ctx->gop_size) {
 845             av_log(avctx, AV_LOG_DEBUG, "Pick group-end P-picture to "
 846                    "encode next.\n");
 847         } else {
 848             av_log(avctx, AV_LOG_DEBUG, "Pick normal P-picture to "
 849                    "encode next.\n");
 850         }
 851         pic->type = PICTURE_TYPE_P;
 852         av_assert0(start);
 853         ctx->gop_counter += 1 + b_counter;
 854     }
 855     pic->is_reference = 1;
 856     *pic_out = pic;
 857
 858     vaapi_encode_add_ref(avctx, pic, pic, 0, 1, 0);
 859     if (pic->type != PICTURE_TYPE_IDR) {
 860         vaapi_encode_add_ref(avctx, pic, start,
 861                              pic->type == PICTURE_TYPE_P,
 862                              b_counter > 0, 0);
 863         vaapi_encode_add_ref(avctx, pic, ctx->next_prev, 0, 0, 1);
 864     }
 865     if (ctx->next_prev)
 866         --ctx->next_prev->ref_count[0];
 867
 868     if (b_counter > 0) {
 869         vaapi_encode_set_b_pictures(avctx, start, pic, pic, 1,
 870                                     &ctx->next_prev);
 871     } else {
 872         ctx->next_prev = pic;
 873     }
 874     ++ctx->next_prev->ref_count[0];
 875     return 0;
 876 }
 877
 878 static int vaapi_encode_clear_old(AVCodecContext *avctx)
 879 {
 880     VAAPIEncodeContext *ctx = avctx->priv_data;
 881     VAAPIEncodePicture *pic, *prev, *next;
 882
 883     av_assert0(ctx->pic_start);
 884
 885     // Remove direct references once each picture is complete.
 886     for (pic = ctx->pic_start; pic; pic = pic->next) {
 887         if (pic->encode_complete && pic->next)
 888             vaapi_encode_remove_refs(avctx, pic, 0);
 889     }
 890
 891     // Remove indirect references once a picture has no direct references.
 892     for (pic = ctx->pic_start; pic; pic = pic->next) {
 893         if (pic->encode_complete && pic->ref_count[0] == 0)
 894             vaapi_encode_remove_refs(avctx, pic, 1);
 895     }
 896
 897     // Clear out all complete pictures with no remaining references.
 898     prev = NULL;
 899     for (pic = ctx->pic_start; pic; pic = next) {
 900         next = pic->next;
 901         if (pic->encode_complete && pic->ref_count[1] == 0) {
 902             av_assert0(pic->ref_removed[0] && pic->ref_removed[1]);
 903             if (prev)
 904                 prev->next = next;
 905             else
 906                 ctx->pic_start = next;
 907             vaapi_encode_free(avctx, pic);
 908         } else {
 909             prev = pic;
 910         }
 911     }
 912
 913     return 0;
 914 }
 915
 916 int ff_vaapi_encode_send_frame(AVCodecContext *avctx, const AVFrame *frame)
 917 {
 918     VAAPIEncodeContext *ctx = avctx->priv_data;
 919     VAAPIEncodePicture *pic;
 920     int err;
 921
 922     if (frame) {
 923         av_log(avctx, AV_LOG_DEBUG, "Input frame: %ux%u (%"PRId64").\n",
 924                frame->width, frame->height, frame->pts);
 925
 926         pic = vaapi_encode_alloc(avctx);
 927         if (!pic)
 928             return AVERROR(ENOMEM);
 929
 930         pic->input_image = av_frame_alloc();
 931         if (!pic->input_image) {
 932             err = AVERROR(ENOMEM);
 933             goto fail;
 934         }
 935         err = av_frame_ref(pic->input_image, frame);
 936         if (err < 0)
 937             goto fail;
 938
 939         if (ctx->input_order == 0)
 940             pic->force_idr = 1;
 941
 942         pic->input_surface = (VASurfaceID)(uintptr_t)frame->data[3];
 943         pic->pts = frame->pts;
 944
 945         if (ctx->input_order == 0)
 946             ctx->first_pts = pic->pts;
 947         if (ctx->input_order == ctx->decode_delay)
 948             ctx->dts_pts_diff = pic->pts - ctx->first_pts;
 949         if (ctx->output_delay > 0)
 950             ctx->ts_ring[ctx->input_order % (3 * ctx->output_delay)] = pic->pts;
 951
 952         pic->display_order = ctx->input_order;
 953         ++ctx->input_order;
 954
 955         if (ctx->pic_start) {
 956             ctx->pic_end->next = pic;
 957             ctx->pic_end       = pic;
 958         } else {
 959             ctx->pic_start     = pic;
 960             ctx->pic_end       = pic;
 961         }
 962
 963     } else {
 964         ctx->end_of_stream = 1;
 965
 966         // Fix timestamps if we hit end-of-stream before the initial decode
 967         // delay has elapsed.
 968         if (ctx->input_order < ctx->decode_delay)
 969             ctx->dts_pts_diff = ctx->pic_end->pts - ctx->first_pts;
 970     }
 971
 972     return 0;
 973
 974 fail:
 975     return err;
 976 }
 977
 978 int ff_vaapi_encode_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
 979 {
 980     VAAPIEncodeContext *ctx = avctx->priv_data;
 981     VAAPIEncodePicture *pic;
 982     int err;
 983
 984     if (!ctx->pic_start) {
 985         if (ctx->end_of_stream)
 986             return AVERROR_EOF;
 987         else
 988             return AVERROR(EAGAIN);
 989     }
 990
 991     pic = NULL;
 992     err = vaapi_encode_pick_next(avctx, &pic);
 993     if (err < 0)
 994         return err;
 995     av_assert0(pic);
 996
 997     pic->encode_order = ctx->encode_order++;
 998
 999     err = vaapi_encode_issue(avctx, pic);
1000     if (err < 0) {
1001         av_log(avctx, AV_LOG_ERROR, "Encode failed: %d.\n", err);
1002         return err;
1003     }
1004
1005     err = vaapi_encode_output(avctx, pic, pkt);
1006     if (err < 0) {
1007         av_log(avctx, AV_LOG_ERROR, "Output failed: %d.\n", err);
1008         return err;
1009     }
1010
1011     if (ctx->output_delay == 0) {
1012         pkt->dts = pkt->pts;
1013     } else if (pic->encode_order < ctx->decode_delay) {
1014         if (ctx->ts_ring[pic->encode_order] < INT64_MIN + ctx->dts_pts_diff)
1015             pkt->dts = INT64_MIN;
1016         else
1017             pkt->dts = ctx->ts_ring[pic->encode_order] - ctx->dts_pts_diff;
1018     } else {
1019         pkt->dts = ctx->ts_ring[(pic->encode_order - ctx->decode_delay) %
1020                                 (3 * ctx->output_delay)];
1021     }
1022     av_log(avctx, AV_LOG_DEBUG, "Output packet: pts %"PRId64" dts %"PRId64".\n",
1023            pkt->pts, pkt->dts);
1024
1025     ctx->output_order = pic->encode_order;
1026     vaapi_encode_clear_old(avctx);
1027
1028     return 0;
1029 }
1030
1031 int ff_vaapi_encode2(AVCodecContext *avctx, AVPacket *pkt,
1032                      const AVFrame *input_image, int *got_packet)
1033 {
1034     return AVERROR(ENOSYS);
1035 }
1036
1037 static av_cold void vaapi_encode_add_global_param(AVCodecContext *avctx,
1038                                                   VAEncMiscParameterBuffer *buffer,
1039                                                   size_t size)
1040 {
1041     VAAPIEncodeContext *ctx = avctx->priv_data;
1042
1043     av_assert0(ctx->nb_global_params < MAX_GLOBAL_PARAMS);
1044
1045     ctx->global_params     [ctx->nb_global_params] = buffer;
1046     ctx->global_params_size[ctx->nb_global_params] = size;
1047
1048     ++ctx->nb_global_params;
1049 }
1050
1051 typedef struct VAAPIEncodeRTFormat {
1052     const char *name;
1053     unsigned int value;
1054     int depth;
1055     int nb_components;
1056     int log2_chroma_w;
1057     int log2_chroma_h;
1058 } VAAPIEncodeRTFormat;
1059
1060 static const VAAPIEncodeRTFormat vaapi_encode_rt_formats[] = {
1061     { "YUV400",    VA_RT_FORMAT_YUV400,        8, 1,      },
1062     { "YUV420",    VA_RT_FORMAT_YUV420,        8, 3, 1, 1 },
1063     { "YUV422",    VA_RT_FORMAT_YUV422,        8, 3, 1, 0 },
1064     { "YUV444",    VA_RT_FORMAT_YUV444,        8, 3, 0, 0 },
1065     { "YUV411",    VA_RT_FORMAT_YUV411,        8, 3, 2, 0 },
1066 #if VA_CHECK_VERSION(0, 38, 1)
1067     { "YUV420_10", VA_RT_FORMAT_YUV420_10BPP, 10, 3, 1, 1 },
1068 #endif
1069 };
1070
1071 static const VAEntrypoint vaapi_encode_entrypoints_normal[] = {
1072     VAEntrypointEncSlice,
1073     VAEntrypointEncPicture,
1074 #if VA_CHECK_VERSION(0, 39, 2)
1075     VAEntrypointEncSliceLP,
1076 #endif
1077     0
1078 };
1079 #if VA_CHECK_VERSION(0, 39, 2)
1080 static const VAEntrypoint vaapi_encode_entrypoints_low_power[] = {
1081     VAEntrypointEncSliceLP,
1082     0
1083 };
1084 #endif
1085
1086 static av_cold int vaapi_encode_profile_entrypoint(AVCodecContext *avctx)
1087 {
1088     VAAPIEncodeContext      *ctx = avctx->priv_data;
1089     VAProfile    *va_profiles    = NULL;
1090     VAEntrypoint *va_entrypoints = NULL;
1091     VAStatus vas;
1092     const VAEntrypoint *usable_entrypoints;
1093     const VAAPIEncodeProfile *profile;
1094     const AVPixFmtDescriptor *desc;
1095     VAConfigAttrib rt_format_attr;
1096     const VAAPIEncodeRTFormat *rt_format;
1097     const char *profile_string, *entrypoint_string;
1098     int i, j, n, depth, err;
1099
1100
1101     if (ctx->low_power) {
1102 #if VA_CHECK_VERSION(0, 39, 2)
1103         usable_entrypoints = vaapi_encode_entrypoints_low_power;
1104 #else
1105         av_log(avctx, AV_LOG_ERROR, "Low-power encoding is not "
1106                "supported with this VAAPI version.\n");
1107         return AVERROR(EINVAL);
1108 #endif
1109     } else {
1110         usable_entrypoints = vaapi_encode_entrypoints_normal;
1111     }
1112
1113     desc = av_pix_fmt_desc_get(ctx->input_frames->sw_format);
1114     if (!desc) {
1115         av_log(avctx, AV_LOG_ERROR, "Invalid input pixfmt (%d).\n",
1116                ctx->input_frames->sw_format);
1117         return AVERROR(EINVAL);
1118     }
1119     depth = desc->comp[0].depth;
1120     for (i = 1; i < desc->nb_components; i++) {
1121         if (desc->comp[i].depth != depth) {
1122             av_log(avctx, AV_LOG_ERROR, "Invalid input pixfmt (%s).\n",
1123                    desc->name);
1124             return AVERROR(EINVAL);
1125         }
1126     }
1127     av_log(avctx, AV_LOG_VERBOSE, "Input surface format is %s.\n",
1128            desc->name);
1129
1130     n = vaMaxNumProfiles(ctx->hwctx->display);
1131     va_profiles = av_malloc_array(n, sizeof(VAProfile));
1132     if (!va_profiles) {
1133         err = AVERROR(ENOMEM);
1134         goto fail;
1135     }
1136     vas = vaQueryConfigProfiles(ctx->hwctx->display, va_profiles, &n);
1137     if (vas != VA_STATUS_SUCCESS) {
1138         av_log(avctx, AV_LOG_ERROR, "Failed to query profiles: %d (%s).\n",
1139                vas, vaErrorStr(vas));
1140         err = AVERROR_EXTERNAL;
1141         goto fail;
1142     }
1143
1144     av_assert0(ctx->codec->profiles);
1145     for (i = 0; (ctx->codec->profiles[i].av_profile !=
1146                  FF_PROFILE_UNKNOWN); i++) {
1147         profile = &ctx->codec->profiles[i];
1148         if (depth               != profile->depth ||
1149             desc->nb_components != profile->nb_components)
1150             continue;
1151         if (desc->nb_components > 1 &&
1152             (desc->log2_chroma_w != profile->log2_chroma_w ||
1153              desc->log2_chroma_h != profile->log2_chroma_h))
1154             continue;
1155         if (avctx->profile != profile->av_profile &&
1156             avctx->profile != FF_PROFILE_UNKNOWN)
1157             continue;
1158
1159 #if VA_CHECK_VERSION(1, 0, 0)
1160         profile_string = vaProfileStr(profile->va_profile);
1161 #else
1162         profile_string = "(no profile names)";
1163 #endif
1164
1165         for (j = 0; j < n; j++) {
1166             if (va_profiles[j] == profile->va_profile)
1167                 break;
1168         }
1169         if (j >= n) {
1170             av_log(avctx, AV_LOG_VERBOSE, "Compatible profile %s (%d) "
1171                    "is not supported by driver.\n", profile_string,
1172                    profile->va_profile);
1173             continue;
1174         }
1175
1176         ctx->profile = profile;
1177         break;
1178     }
1179     if (!ctx->profile) {
1180         av_log(avctx, AV_LOG_ERROR, "No usable encoding profile found.\n");
1181         err = AVERROR(ENOSYS);
1182         goto fail;
1183     }
1184
1185     avctx->profile  = profile->av_profile;
1186     ctx->va_profile = profile->va_profile;
1187     av_log(avctx, AV_LOG_VERBOSE, "Using VAAPI profile %s (%d).\n",
1188            profile_string, ctx->va_profile);
1189
1190     n = vaMaxNumEntrypoints(ctx->hwctx->display);
1191     va_entrypoints = av_malloc_array(n, sizeof(VAEntrypoint));
1192     if (!va_entrypoints) {
1193         err = AVERROR(ENOMEM);
1194         goto fail;
1195     }
1196     vas = vaQueryConfigEntrypoints(ctx->hwctx->display, ctx->va_profile,
1197                                    va_entrypoints, &n);
1198     if (vas != VA_STATUS_SUCCESS) {
1199         av_log(avctx, AV_LOG_ERROR, "Failed to query entrypoints for "
1200                "profile %s (%d): %d (%s).\n", profile_string,
1201                ctx->va_profile, vas, vaErrorStr(vas));
1202         err = AVERROR_EXTERNAL;
1203         goto fail;
1204     }
1205
1206     for (i = 0; i < n; i++) {
1207         for (j = 0; usable_entrypoints[j]; j++) {
1208             if (va_entrypoints[i] == usable_entrypoints[j])
1209                 break;
1210         }
1211         if (usable_entrypoints[j])
1212             break;
1213     }
1214     if (i >= n) {
1215         av_log(avctx, AV_LOG_ERROR, "No usable encoding entrypoint found "
1216                "for profile %s (%d).\n", profile_string, ctx->va_profile);
1217         err = AVERROR(ENOSYS);
1218         goto fail;
1219     }
1220
1221     ctx->va_entrypoint = va_entrypoints[i];
1222 #if VA_CHECK_VERSION(1, 0, 0)
1223     entrypoint_string = vaEntrypointStr(ctx->va_entrypoint);
1224 #else
1225     entrypoint_string = "(no entrypoint names)";
1226 #endif
1227     av_log(avctx, AV_LOG_VERBOSE, "Using VAAPI entrypoint %s (%d).\n",
1228            entrypoint_string, ctx->va_entrypoint);
1229
1230     for (i = 0; i < FF_ARRAY_ELEMS(vaapi_encode_rt_formats); i++) {
1231         rt_format = &vaapi_encode_rt_formats[i];
1232         if (rt_format->depth         == depth &&
1233             rt_format->nb_components == profile->nb_components &&
1234             rt_format->log2_chroma_w == profile->log2_chroma_w &&
1235             rt_format->log2_chroma_h == profile->log2_chroma_h)
1236             break;
1237     }
1238     if (i >= FF_ARRAY_ELEMS(vaapi_encode_rt_formats)) {
1239         av_log(avctx, AV_LOG_ERROR, "No usable render target format "
1240                "found for profile %s (%d) entrypoint %s (%d).\n",
1241                profile_string, ctx->va_profile,
1242                entrypoint_string, ctx->va_entrypoint);
1243         err = AVERROR(ENOSYS);
1244         goto fail;
1245     }
1246
1247     rt_format_attr = (VAConfigAttrib) { VAConfigAttribRTFormat };
1248     vas = vaGetConfigAttributes(ctx->hwctx->display,
1249                                 ctx->va_profile, ctx->va_entrypoint,
1250                                 &rt_format_attr, 1);
1251     if (vas != VA_STATUS_SUCCESS) {
1252         av_log(avctx, AV_LOG_ERROR, "Failed to query RT format "
1253                "config attribute: %d (%s).\n", vas, vaErrorStr(vas));
1254         err = AVERROR_EXTERNAL;
1255         goto fail;
1256     }
1257
1258     if (rt_format_attr.value == VA_ATTRIB_NOT_SUPPORTED) {
1259         av_log(avctx, AV_LOG_VERBOSE, "RT format config attribute not "
1260                "supported by driver: assuming surface RT format %s "
1261                "is valid.\n", rt_format->name);
1262     } else if (!(rt_format_attr.value & rt_format->value)) {
1263         av_log(avctx, AV_LOG_ERROR, "Surface RT format %s not supported "
1264                "by driver for encoding profile %s (%d) entrypoint %s (%d).\n",
1265                rt_format->name, profile_string, ctx->va_profile,
1266                entrypoint_string, ctx->va_entrypoint);
1267         err = AVERROR(ENOSYS);
1268         goto fail;
1269     } else {
1270         av_log(avctx, AV_LOG_VERBOSE, "Using VAAPI render target "
1271                "format %s (%#x).\n", rt_format->name, rt_format->value);
1272         ctx->config_attributes[ctx->nb_config_attributes++] =
1273             (VAConfigAttrib) {
1274             .type  = VAConfigAttribRTFormat,
1275             .value = rt_format->value,
1276         };
1277     }
1278
1279     err = 0;
1280 fail:
1281     av_freep(&va_profiles);
1282     av_freep(&va_entrypoints);
1283     return err;
1284 }
1285
1286 static av_cold int vaapi_encode_init_rate_control(AVCodecContext *avctx)
1287 {
1288     VAAPIEncodeContext *ctx = avctx->priv_data;
1289     int64_t rc_bits_per_second;
1290     int     rc_target_percentage;
1291     int     rc_window_size;
1292     int64_t hrd_buffer_size;
1293     int64_t hrd_initial_buffer_fullness;
1294     int fr_num, fr_den;
1295     VAConfigAttrib rc_attr = { VAConfigAttribRateControl };
1296     VAStatus vas;
1297
1298     vas = vaGetConfigAttributes(ctx->hwctx->display,
1299                                 ctx->va_profile, ctx->va_entrypoint,
1300                                 &rc_attr, 1);
1301     if (vas != VA_STATUS_SUCCESS) {
1302         av_log(avctx, AV_LOG_ERROR, "Failed to query rate control "
1303                "config attribute: %d (%s).\n", vas, vaErrorStr(vas));
1304         return AVERROR_EXTERNAL;
1305     }
1306
1307     if (rc_attr.value == VA_ATTRIB_NOT_SUPPORTED) {
1308         av_log(avctx, AV_LOG_VERBOSE, "Driver does not report any "
1309                "supported rate control modes: assuming constant-quality.\n");
1310         ctx->va_rc_mode = VA_RC_CQP;
1311         return 0;
1312     }
1313     if (ctx->codec->flags & FLAG_CONSTANT_QUALITY_ONLY ||
1314         avctx->flags & AV_CODEC_FLAG_QSCALE ||
1315         avctx->bit_rate <= 0) {
1316         if (rc_attr.value & VA_RC_CQP) {
1317             av_log(avctx, AV_LOG_VERBOSE, "Using constant-quality mode.\n");
1318             ctx->va_rc_mode = VA_RC_CQP;
1319             if (avctx->bit_rate > 0 || avctx->rc_max_rate > 0) {
1320                 av_log(avctx, AV_LOG_WARNING, "Bitrate target parameters "
1321                        "ignored in constant-quality mode.\n");
1322             }
1323             return 0;
1324         } else {
1325             av_log(avctx, AV_LOG_ERROR, "Driver does not support "
1326                    "constant-quality mode (%#x).\n", rc_attr.value);
1327             return AVERROR(EINVAL);
1328         }
1329     }
1330
1331     if (!(rc_attr.value & (VA_RC_CBR | VA_RC_VBR))) {
1332         av_log(avctx, AV_LOG_ERROR, "Driver does not support any "
1333                "bitrate-targetted rate control modes.\n");
1334         return AVERROR(EINVAL);
1335     }
1336
1337     if (avctx->rc_buffer_size)
1338         hrd_buffer_size = avctx->rc_buffer_size;
1339     else if (avctx->rc_max_rate > 0)
1340         hrd_buffer_size = avctx->rc_max_rate;
1341     else
1342         hrd_buffer_size = avctx->bit_rate;
1343     if (avctx->rc_initial_buffer_occupancy) {
1344         if (avctx->rc_initial_buffer_occupancy > hrd_buffer_size) {
1345             av_log(avctx, AV_LOG_ERROR, "Invalid RC buffer settings: "
1346                    "must have initial buffer size (%d) < "
1347                    "buffer size (%"PRId64").\n",
1348                    avctx->rc_initial_buffer_occupancy, hrd_buffer_size);
1349             return AVERROR(EINVAL);
1350         }
1351         hrd_initial_buffer_fullness = avctx->rc_initial_buffer_occupancy;
1352     } else {
1353         hrd_initial_buffer_fullness = hrd_buffer_size * 3 / 4;
1354     }
1355
1356     if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
1357         av_log(avctx, AV_LOG_ERROR, "Invalid bitrate settings: must have "
1358                "bitrate (%"PRId64") <= maxrate (%"PRId64").\n",
1359                avctx->bit_rate, avctx->rc_max_rate);
1360         return AVERROR(EINVAL);
1361     }
1362
1363     if (avctx->rc_max_rate > avctx->bit_rate) {
1364         if (!(rc_attr.value & VA_RC_VBR)) {
1365             av_log(avctx, AV_LOG_WARNING, "Driver does not support "
1366                    "VBR mode (%#x), using CBR mode instead.\n",
1367                    rc_attr.value);
1368             ctx->va_rc_mode = VA_RC_CBR;
1369
1370             rc_bits_per_second   = avctx->bit_rate;
1371             rc_target_percentage = 100;
1372         } else {
1373             ctx->va_rc_mode = VA_RC_VBR;
1374
1375             rc_bits_per_second   = avctx->rc_max_rate;
1376             rc_target_percentage = (avctx->bit_rate * 100) /
1377                                    avctx->rc_max_rate;
1378         }
1379
1380     } else if (avctx->rc_max_rate == avctx->bit_rate) {
1381         if (!(rc_attr.value & VA_RC_CBR)) {
1382             av_log(avctx, AV_LOG_WARNING, "Driver does not support "
1383                    "CBR mode (%#x), using VBR mode instead.\n",
1384                    rc_attr.value);
1385             ctx->va_rc_mode = VA_RC_VBR;
1386         } else {
1387             ctx->va_rc_mode = VA_RC_CBR;
1388         }
1389
1390         rc_bits_per_second   = avctx->bit_rate;
1391         rc_target_percentage = 100;
1392
1393     } else {
1394         if (rc_attr.value & VA_RC_VBR) {
1395             ctx->va_rc_mode = VA_RC_VBR;
1396
1397             // We only have a target bitrate, but VAAPI requires that a
1398             // maximum rate be supplied as well.  Since the user has
1399             // offered no particular constraint, arbitrarily pick a
1400             // maximum rate of double the target rate.
1401             rc_bits_per_second   = 2 * avctx->bit_rate;
1402             rc_target_percentage = 50;
1403         } else {
1404             ctx->va_rc_mode = VA_RC_CBR;
1405
1406             rc_bits_per_second   = avctx->bit_rate;
1407             rc_target_percentage = 100;
1408         }
1409     }
1410
1411     rc_window_size = (hrd_buffer_size * 1000) / rc_bits_per_second;
1412
1413     av_log(avctx, AV_LOG_VERBOSE, "RC mode: %s, %d%% of %"PRId64" bps "
1414            "over %d ms.\n", ctx->va_rc_mode == VA_RC_VBR ? "VBR" : "CBR",
1415            rc_target_percentage, rc_bits_per_second, rc_window_size);
1416     av_log(avctx, AV_LOG_VERBOSE, "RC buffer: %"PRId64" bits, "
1417            "initial fullness %"PRId64" bits.\n",
1418            hrd_buffer_size, hrd_initial_buffer_fullness);
1419
1420     if (rc_bits_per_second          > UINT32_MAX ||
1421         hrd_buffer_size             > UINT32_MAX ||
1422         hrd_initial_buffer_fullness > UINT32_MAX) {
1423         av_log(avctx, AV_LOG_ERROR, "RC parameters of 2^32 or "
1424                "greater are not supported by VAAPI.\n");
1425         return AVERROR(EINVAL);
1426     }
1427
1428     ctx->va_bit_rate = rc_bits_per_second;
1429
1430     ctx->config_attributes[ctx->nb_config_attributes++] =
1431         (VAConfigAttrib) {
1432         .type  = VAConfigAttribRateControl,
1433         .value = ctx->va_rc_mode,
1434     };
1435
1436     ctx->rc_params.misc.type = VAEncMiscParameterTypeRateControl;
1437     ctx->rc_params.rc = (VAEncMiscParameterRateControl) {
1438         .bits_per_second   = rc_bits_per_second,
1439         .target_percentage = rc_target_percentage,
1440         .window_size       = rc_window_size,
1441         .initial_qp        = 0,
1442         .min_qp            = (avctx->qmin > 0 ? avctx->qmin : 0),
1443         .basic_unit_size   = 0,
1444 #if VA_CHECK_VERSION(1, 1, 0)
1445         .max_qp            = (avctx->qmax > 0 ? avctx->qmax : 0),
1446 #endif
1447     };
1448     vaapi_encode_add_global_param(avctx, &ctx->rc_params.misc,
1449                                   sizeof(ctx->rc_params));
1450
1451     ctx->hrd_params.misc.type = VAEncMiscParameterTypeHRD;
1452     ctx->hrd_params.hrd = (VAEncMiscParameterHRD) {
1453         .initial_buffer_fullness = hrd_initial_buffer_fullness,
1454         .buffer_size             = hrd_buffer_size,
1455     };
1456     vaapi_encode_add_global_param(avctx, &ctx->hrd_params.misc,
1457                                   sizeof(ctx->hrd_params));
1458
1459     if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
1460         av_reduce(&fr_num, &fr_den,
1461                   avctx->framerate.num, avctx->framerate.den, 65535);
1462     else
1463         av_reduce(&fr_num, &fr_den,
1464                   avctx->time_base.den, avctx->time_base.num, 65535);
1465
1466     ctx->fr_params.misc.type = VAEncMiscParameterTypeFrameRate;
1467     ctx->fr_params.fr.framerate = (unsigned int)fr_den << 16 | fr_num;
1468
1469 #if VA_CHECK_VERSION(0, 40, 0)
1470     vaapi_encode_add_global_param(avctx, &ctx->fr_params.misc,
1471                                   sizeof(ctx->fr_params));
1472 #endif
1473
1474     return 0;
1475 }
1476
1477 static av_cold int vaapi_encode_init_gop_structure(AVCodecContext *avctx)
1478 {
1479     VAAPIEncodeContext *ctx = avctx->priv_data;
1480     VAStatus vas;
1481     VAConfigAttrib attr = { VAConfigAttribEncMaxRefFrames };
1482     uint32_t ref_l0, ref_l1;
1483
1484     vas = vaGetConfigAttributes(ctx->hwctx->display,
1485                                 ctx->va_profile,
1486                                 ctx->va_entrypoint,
1487                                 &attr, 1);
1488     if (vas != VA_STATUS_SUCCESS) {
1489         av_log(avctx, AV_LOG_ERROR, "Failed to query reference frames "
1490                "attribute: %d (%s).\n", vas, vaErrorStr(vas));
1491         return AVERROR_EXTERNAL;
1492     }
1493
1494     if (attr.value == VA_ATTRIB_NOT_SUPPORTED) {
1495         ref_l0 = ref_l1 = 0;
1496     } else {
1497         ref_l0 = attr.value       & 0xffff;
1498         ref_l1 = attr.value >> 16 & 0xffff;
1499     }
1500
1501     if (ctx->codec->flags & FLAG_INTRA_ONLY ||
1502         avctx->gop_size <= 1) {
1503         av_log(avctx, AV_LOG_VERBOSE, "Using intra frames only.\n");
1504         ctx->gop_size = 1;
1505     } else if (ref_l0 < 1) {
1506         av_log(avctx, AV_LOG_ERROR, "Driver does not support any "
1507                "reference frames.\n");
1508         return AVERROR(EINVAL);
1509     } else if (!(ctx->codec->flags & FLAG_B_PICTURES) ||
1510                ref_l1 < 1 || avctx->max_b_frames < 1) {
1511         av_log(avctx, AV_LOG_VERBOSE, "Using intra and P-frames "
1512                "(supported references: %d / %d).\n", ref_l0, ref_l1);
1513         ctx->gop_size = avctx->gop_size;
1514         ctx->p_per_i  = INT_MAX;
1515         ctx->b_per_p  = 0;
1516     } else {
1517         av_log(avctx, AV_LOG_VERBOSE, "Using intra, P- and B-frames "
1518                "(supported references: %d / %d).\n", ref_l0, ref_l1);
1519         ctx->gop_size = avctx->gop_size;
1520         ctx->p_per_i  = INT_MAX;
1521         ctx->b_per_p  = avctx->max_b_frames;
1522         if (ctx->codec->flags & FLAG_B_PICTURE_REFERENCES) {
1523             ctx->max_b_depth = FFMIN(ctx->desired_b_depth,
1524                                      av_log2(ctx->b_per_p) + 1);
1525         } else {
1526             ctx->max_b_depth = 1;
1527         }
1528     }
1529
1530     if (ctx->codec->flags & FLAG_NON_IDR_KEY_PICTURES) {
1531         ctx->closed_gop  = !!(avctx->flags & AV_CODEC_FLAG_CLOSED_GOP);
1532         ctx->gop_per_idr = ctx->idr_interval + 1;
1533     } else {
1534         ctx->closed_gop  = 1;
1535         ctx->gop_per_idr = 1;
1536     }
1537
1538     return 0;
1539 }
1540
1541 static av_cold int vaapi_encode_init_slice_structure(AVCodecContext *avctx)
1542 {
1543     VAAPIEncodeContext *ctx = avctx->priv_data;
1544     VAConfigAttrib attr[2] = { { VAConfigAttribEncMaxSlices },
1545                                { VAConfigAttribEncSliceStructure } };
1546     VAStatus vas;
1547     uint32_t max_slices, slice_structure;
1548     int req_slices;
1549
1550     if (!(ctx->codec->flags & FLAG_SLICE_CONTROL)) {
1551         if (avctx->slices > 0) {
1552             av_log(avctx, AV_LOG_WARNING, "Multiple slices were requested "
1553                    "but this codec does not support controlling slices.\n");
1554         }
1555         return 0;
1556     }
1557
1558     ctx->slice_block_rows = (avctx->height + ctx->slice_block_height - 1) /
1559                              ctx->slice_block_height;
1560     ctx->slice_block_cols = (avctx->width  + ctx->slice_block_width  - 1) /
1561                              ctx->slice_block_width;
1562
1563     if (avctx->slices <= 1) {
1564         ctx->nb_slices  = 1;
1565         ctx->slice_size = ctx->slice_block_rows;
1566         return 0;
1567     }
1568
1569     vas = vaGetConfigAttributes(ctx->hwctx->display,
1570                                 ctx->va_profile,
1571                                 ctx->va_entrypoint,
1572                                 attr, FF_ARRAY_ELEMS(attr));
1573     if (vas != VA_STATUS_SUCCESS) {
1574         av_log(avctx, AV_LOG_ERROR, "Failed to query slice "
1575                "attributes: %d (%s).\n", vas, vaErrorStr(vas));
1576         return AVERROR_EXTERNAL;
1577     }
1578     max_slices      = attr[0].value;
1579     slice_structure = attr[1].value;
1580     if (max_slices      == VA_ATTRIB_NOT_SUPPORTED ||
1581         slice_structure == VA_ATTRIB_NOT_SUPPORTED) {
1582         av_log(avctx, AV_LOG_ERROR, "Driver does not support encoding "
1583                "pictures as multiple slices.\n.");
1584         return AVERROR(EINVAL);
1585     }
1586
1587     // For fixed-size slices currently we only support whole rows, making
1588     // rectangular slices.  This could be extended to arbitrary runs of
1589     // blocks, but since slices tend to be a conformance requirement and
1590     // most cases (such as broadcast or bluray) want rectangular slices
1591     // only it would need to be gated behind another option.
1592     if (avctx->slices > ctx->slice_block_rows) {
1593         av_log(avctx, AV_LOG_WARNING, "Not enough rows to use "
1594                "configured number of slices (%d < %d); using "
1595                "maximum.\n", ctx->slice_block_rows, avctx->slices);
1596         req_slices = ctx->slice_block_rows;
1597     } else {
1598         req_slices = avctx->slices;
1599     }
1600     if (slice_structure & VA_ENC_SLICE_STRUCTURE_ARBITRARY_ROWS ||
1601         slice_structure & VA_ENC_SLICE_STRUCTURE_ARBITRARY_MACROBLOCKS) {
1602         ctx->nb_slices  = req_slices;
1603         ctx->slice_size = ctx->slice_block_rows / ctx->nb_slices;
1604     } else if (slice_structure & VA_ENC_SLICE_STRUCTURE_POWER_OF_TWO_ROWS) {
1605         int k;
1606         for (k = 1;; k *= 2) {
1607             if (2 * k * (req_slices - 1) + 1 >= ctx->slice_block_rows)
1608                 break;
1609         }
1610         ctx->nb_slices  = (ctx->slice_block_rows + k - 1) / k;
1611         ctx->slice_size = k;
1612 #if VA_CHECK_VERSION(1, 0, 0)
1613     } else if (slice_structure & VA_ENC_SLICE_STRUCTURE_EQUAL_ROWS) {
1614         ctx->nb_slices  = ctx->slice_block_rows;
1615         ctx->slice_size = 1;
1616 #endif
1617     } else {
1618         av_log(avctx, AV_LOG_ERROR, "Driver does not support any usable "
1619                "slice structure modes (%#x).\n", slice_structure);
1620         return AVERROR(EINVAL);
1621     }
1622
1623     if (ctx->nb_slices > avctx->slices) {
1624         av_log(avctx, AV_LOG_WARNING, "Slice count rounded up to "
1625                "%d (from %d) due to driver constraints on slice "
1626                "structure.\n", ctx->nb_slices, avctx->slices);
1627     }
1628     if (ctx->nb_slices > max_slices) {
1629         av_log(avctx, AV_LOG_ERROR, "Driver does not support "
1630                "encoding with %d slices (max %"PRIu32").\n",
1631                ctx->nb_slices, max_slices);
1632         return AVERROR(EINVAL);
1633     }
1634
1635     av_log(avctx, AV_LOG_VERBOSE, "Encoding pictures with %d slices "
1636            "(default size %d block rows).\n",
1637            ctx->nb_slices, ctx->slice_size);
1638     return 0;
1639 }
1640
1641 static av_cold int vaapi_encode_init_packed_headers(AVCodecContext *avctx)
1642 {
1643     VAAPIEncodeContext *ctx = avctx->priv_data;
1644     VAStatus vas;
1645     VAConfigAttrib attr = { VAConfigAttribEncPackedHeaders };
1646
1647     vas = vaGetConfigAttributes(ctx->hwctx->display,
1648                                 ctx->va_profile,
1649                                 ctx->va_entrypoint,
1650                                 &attr, 1);
1651     if (vas != VA_STATUS_SUCCESS) {
1652         av_log(avctx, AV_LOG_ERROR, "Failed to query packed headers "
1653                "attribute: %d (%s).\n", vas, vaErrorStr(vas));
1654         return AVERROR_EXTERNAL;
1655     }
1656
1657     if (attr.value == VA_ATTRIB_NOT_SUPPORTED) {
1658         if (ctx->desired_packed_headers) {
1659             av_log(avctx, AV_LOG_WARNING, "Driver does not support any "
1660                    "packed headers (wanted %#x).\n",
1661                    ctx->desired_packed_headers);
1662         } else {
1663             av_log(avctx, AV_LOG_VERBOSE, "Driver does not support any "
1664                    "packed headers (none wanted).\n");
1665         }
1666         ctx->va_packed_headers = 0;
1667     } else {
1668         if (ctx->desired_packed_headers & ~attr.value) {
1669             av_log(avctx, AV_LOG_WARNING, "Driver does not support some "
1670                    "wanted packed headers (wanted %#x, found %#x).\n",
1671                    ctx->desired_packed_headers, attr.value);
1672         } else {
1673             av_log(avctx, AV_LOG_VERBOSE, "All wanted packed headers "
1674                    "available (wanted %#x, found %#x).\n",
1675                    ctx->desired_packed_headers, attr.value);
1676         }
1677         ctx->va_packed_headers = ctx->desired_packed_headers & attr.value;
1678     }
1679
1680     if (ctx->va_packed_headers) {
1681         ctx->config_attributes[ctx->nb_config_attributes++] =
1682             (VAConfigAttrib) {
1683             .type  = VAConfigAttribEncPackedHeaders,
1684             .value = ctx->va_packed_headers,
1685         };
1686     }
1687
1688     if ( (ctx->desired_packed_headers & VA_ENC_PACKED_HEADER_SEQUENCE) &&
1689         !(ctx->va_packed_headers      & VA_ENC_PACKED_HEADER_SEQUENCE) &&
1690          (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)) {
1691         av_log(avctx, AV_LOG_WARNING, "Driver does not support packed "
1692                "sequence headers, but a global header is requested.\n");
1693         av_log(avctx, AV_LOG_WARNING, "No global header will be written: "
1694                "this may result in a stream which is not usable for some "
1695                "purposes (e.g. not muxable to some containers).\n");
1696     }
1697
1698     return 0;
1699 }
1700
1701 static av_cold int vaapi_encode_init_quality(AVCodecContext *avctx)
1702 {
1703 #if VA_CHECK_VERSION(0, 36, 0)
1704     VAAPIEncodeContext *ctx = avctx->priv_data;
1705     VAStatus vas;
1706     VAConfigAttrib attr = { VAConfigAttribEncQualityRange };
1707     int quality = avctx->compression_level;
1708
1709     vas = vaGetConfigAttributes(ctx->hwctx->display,
1710                                 ctx->va_profile,
1711                                 ctx->va_entrypoint,
1712                                 &attr, 1);
1713     if (vas != VA_STATUS_SUCCESS) {
1714         av_log(avctx, AV_LOG_ERROR, "Failed to query quality "
1715                "config attribute: %d (%s).\n", vas, vaErrorStr(vas));
1716         return AVERROR_EXTERNAL;
1717     }
1718
1719     if (attr.value == VA_ATTRIB_NOT_SUPPORTED) {
1720         if (quality != 0) {
1721             av_log(avctx, AV_LOG_WARNING, "Quality attribute is not "
1722                    "supported: will use default quality level.\n");
1723         }
1724     } else {
1725         if (quality > attr.value) {
1726             av_log(avctx, AV_LOG_WARNING, "Invalid quality level: "
1727                    "valid range is 0-%d, using %d.\n",
1728                    attr.value, attr.value);
1729             quality = attr.value;
1730         }
1731
1732         ctx->quality_params.misc.type = VAEncMiscParameterTypeQualityLevel;
1733         ctx->quality_params.quality.quality_level = quality;
1734
1735         vaapi_encode_add_global_param(avctx, &ctx->quality_params.misc,
1736                                       sizeof(ctx->quality_params));
1737     }
1738 #else
1739     av_log(avctx, AV_LOG_WARNING, "The encode quality option is "
1740            "not supported with this VAAPI version.\n");
1741 #endif
1742
1743     return 0;
1744 }
1745
1746 static void vaapi_encode_free_output_buffer(void *opaque,
1747                                             uint8_t *data)
1748 {
1749     AVCodecContext   *avctx = opaque;
1750     VAAPIEncodeContext *ctx = avctx->priv_data;
1751     VABufferID buffer_id;
1752
1753     buffer_id = (VABufferID)(uintptr_t)data;
1754
1755     vaDestroyBuffer(ctx->hwctx->display, buffer_id);
1756
1757     av_log(avctx, AV_LOG_DEBUG, "Freed output buffer %#x\n", buffer_id);
1758 }
1759
1760 static AVBufferRef *vaapi_encode_alloc_output_buffer(void *opaque,
1761                                                      int size)
1762 {
1763     AVCodecContext   *avctx = opaque;
1764     VAAPIEncodeContext *ctx = avctx->priv_data;
1765     VABufferID buffer_id;
1766     VAStatus vas;
1767     AVBufferRef *ref;
1768
1769     // The output buffer size is fixed, so it needs to be large enough
1770     // to hold the largest possible compressed frame.  We assume here
1771     // that the uncompressed frame plus some header data is an upper
1772     // bound on that.
1773     vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,
1774                          VAEncCodedBufferType,
1775                          3 * ctx->surface_width * ctx->surface_height +
1776                          (1 << 16), 1, 0, &buffer_id);
1777     if (vas != VA_STATUS_SUCCESS) {
1778         av_log(avctx, AV_LOG_ERROR, "Failed to create bitstream "
1779                "output buffer: %d (%s).\n", vas, vaErrorStr(vas));
1780         return NULL;
1781     }
1782
1783     av_log(avctx, AV_LOG_DEBUG, "Allocated output buffer %#x\n", buffer_id);
1784
1785     ref = av_buffer_create((uint8_t*)(uintptr_t)buffer_id,
1786                            sizeof(buffer_id),
1787                            &vaapi_encode_free_output_buffer,
1788                            avctx, AV_BUFFER_FLAG_READONLY);
1789     if (!ref) {
1790         vaDestroyBuffer(ctx->hwctx->display, buffer_id);
1791         return NULL;
1792     }
1793
1794     return ref;
1795 }
1796
1797 static av_cold int vaapi_encode_create_recon_frames(AVCodecContext *avctx)
1798 {
1799     VAAPIEncodeContext *ctx = avctx->priv_data;
1800     AVVAAPIHWConfig *hwconfig = NULL;
1801     AVHWFramesConstraints *constraints = NULL;
1802     enum AVPixelFormat recon_format;
1803     int err, i;
1804
1805     hwconfig = av_hwdevice_hwconfig_alloc(ctx->device_ref);
1806     if (!hwconfig) {
1807         err = AVERROR(ENOMEM);
1808         goto fail;
1809     }
1810     hwconfig->config_id = ctx->va_config;
1811
1812     constraints = av_hwdevice_get_hwframe_constraints(ctx->device_ref,
1813                                                       hwconfig);
1814     if (!constraints) {
1815         err = AVERROR(ENOMEM);
1816         goto fail;
1817     }
1818
1819     // Probably we can use the input surface format as the surface format
1820     // of the reconstructed frames.  If not, we just pick the first (only?)
1821     // format in the valid list and hope that it all works.
1822     recon_format = AV_PIX_FMT_NONE;
1823     if (constraints->valid_sw_formats) {
1824         for (i = 0; constraints->valid_sw_formats[i] != AV_PIX_FMT_NONE; i++) {
1825             if (ctx->input_frames->sw_format ==
1826                 constraints->valid_sw_formats[i]) {
1827                 recon_format = ctx->input_frames->sw_format;
1828                 break;
1829             }
1830         }
1831         if (recon_format == AV_PIX_FMT_NONE) {
1832             // No match.  Just use the first in the supported list and
1833             // hope for the best.
1834             recon_format = constraints->valid_sw_formats[0];
1835         }
1836     } else {
1837         // No idea what to use; copy input format.
1838         recon_format = ctx->input_frames->sw_format;
1839     }
1840     av_log(avctx, AV_LOG_DEBUG, "Using %s as format of "
1841            "reconstructed frames.\n", av_get_pix_fmt_name(recon_format));
1842
1843     if (ctx->surface_width  < constraints->min_width  ||
1844         ctx->surface_height < constraints->min_height ||
1845         ctx->surface_width  > constraints->max_width ||
1846         ctx->surface_height > constraints->max_height) {
1847         av_log(avctx, AV_LOG_ERROR, "Hardware does not support encoding at "
1848                "size %dx%d (constraints: width %d-%d height %d-%d).\n",
1849                ctx->surface_width, ctx->surface_height,
1850                constraints->min_width,  constraints->max_width,
1851                constraints->min_height, constraints->max_height);
1852         err = AVERROR(EINVAL);
1853         goto fail;
1854     }
1855
1856     av_freep(&hwconfig);
1857     av_hwframe_constraints_free(&constraints);
1858
1859     ctx->recon_frames_ref = av_hwframe_ctx_alloc(ctx->device_ref);
1860     if (!ctx->recon_frames_ref) {
1861         err = AVERROR(ENOMEM);
1862         goto fail;
1863     }
1864     ctx->recon_frames = (AVHWFramesContext*)ctx->recon_frames_ref->data;
1865
1866     ctx->recon_frames->format    = AV_PIX_FMT_VAAPI;
1867     ctx->recon_frames->sw_format = recon_format;
1868     ctx->recon_frames->width     = ctx->surface_width;
1869     ctx->recon_frames->height    = ctx->surface_height;
1870
1871     err = av_hwframe_ctx_init(ctx->recon_frames_ref);
1872     if (err < 0) {
1873         av_log(avctx, AV_LOG_ERROR, "Failed to initialise reconstructed "
1874                "frame context: %d.\n", err);
1875         goto fail;
1876     }
1877
1878     err = 0;
1879   fail:
1880     av_freep(&hwconfig);
1881     av_hwframe_constraints_free(&constraints);
1882     return err;
1883 }
1884
1885 av_cold int ff_vaapi_encode_init(AVCodecContext *avctx)
1886 {
1887     VAAPIEncodeContext *ctx = avctx->priv_data;
1888     AVVAAPIFramesContext *recon_hwctx = NULL;
1889     VAStatus vas;
1890     int err;
1891
1892     if (!avctx->hw_frames_ctx) {
1893         av_log(avctx, AV_LOG_ERROR, "A hardware frames reference is "
1894                "required to associate the encoding device.\n");
1895         return AVERROR(EINVAL);
1896     }
1897
1898     ctx->va_config  = VA_INVALID_ID;
1899     ctx->va_context = VA_INVALID_ID;
1900
1901     ctx->input_frames_ref = av_buffer_ref(avctx->hw_frames_ctx);
1902     if (!ctx->input_frames_ref) {
1903         err = AVERROR(ENOMEM);
1904         goto fail;
1905     }
1906     ctx->input_frames = (AVHWFramesContext*)ctx->input_frames_ref->data;
1907
1908     ctx->device_ref = av_buffer_ref(ctx->input_frames->device_ref);
1909     if (!ctx->device_ref) {
1910         err = AVERROR(ENOMEM);
1911         goto fail;
1912     }
1913     ctx->device = (AVHWDeviceContext*)ctx->device_ref->data;
1914     ctx->hwctx = ctx->device->hwctx;
1915
1916     err = vaapi_encode_profile_entrypoint(avctx);
1917     if (err < 0)
1918         goto fail;
1919
1920     err = vaapi_encode_init_rate_control(avctx);
1921     if (err < 0)
1922         goto fail;
1923
1924     err = vaapi_encode_init_gop_structure(avctx);
1925     if (err < 0)
1926         goto fail;
1927
1928     err = vaapi_encode_init_slice_structure(avctx);
1929     if (err < 0)
1930         goto fail;
1931
1932     err = vaapi_encode_init_packed_headers(avctx);
1933     if (err < 0)
1934         goto fail;
1935
1936     if (avctx->compression_level >= 0) {
1937         err = vaapi_encode_init_quality(avctx);
1938         if (err < 0)
1939             goto fail;
1940     }
1941
1942     vas = vaCreateConfig(ctx->hwctx->display,
1943                          ctx->va_profile, ctx->va_entrypoint,
1944                          ctx->config_attributes, ctx->nb_config_attributes,
1945                          &ctx->va_config);
1946     if (vas != VA_STATUS_SUCCESS) {
1947         av_log(avctx, AV_LOG_ERROR, "Failed to create encode pipeline "
1948                "configuration: %d (%s).\n", vas, vaErrorStr(vas));
1949         err = AVERROR(EIO);
1950         goto fail;
1951     }
1952
1953     err = vaapi_encode_create_recon_frames(avctx);
1954     if (err < 0)
1955         goto fail;
1956
1957     recon_hwctx = ctx->recon_frames->hwctx;
1958     vas = vaCreateContext(ctx->hwctx->display, ctx->va_config,
1959                           ctx->surface_width, ctx->surface_height,
1960                           VA_PROGRESSIVE,
1961                           recon_hwctx->surface_ids,
1962                           recon_hwctx->nb_surfaces,
1963                           &ctx->va_context);
1964     if (vas != VA_STATUS_SUCCESS) {
1965         av_log(avctx, AV_LOG_ERROR, "Failed to create encode pipeline "
1966                "context: %d (%s).\n", vas, vaErrorStr(vas));
1967         err = AVERROR(EIO);
1968         goto fail;
1969     }
1970
1971     ctx->output_buffer_pool =
1972         av_buffer_pool_init2(sizeof(VABufferID), avctx,
1973                              &vaapi_encode_alloc_output_buffer, NULL);
1974     if (!ctx->output_buffer_pool) {
1975         err = AVERROR(ENOMEM);
1976         goto fail;
1977     }
1978
1979     if (ctx->codec->configure) {
1980         err = ctx->codec->configure(avctx);
1981         if (err < 0)
1982             goto fail;
1983     }
1984
1985     ctx->output_delay = ctx->b_per_p;
1986     ctx->decode_delay = ctx->max_b_depth;
1987
1988     if (ctx->codec->sequence_params_size > 0) {
1989         ctx->codec_sequence_params =
1990             av_mallocz(ctx->codec->sequence_params_size);
1991         if (!ctx->codec_sequence_params) {
1992             err = AVERROR(ENOMEM);
1993             goto fail;
1994         }
1995     }
1996     if (ctx->codec->picture_params_size > 0) {
1997         ctx->codec_picture_params =
1998             av_mallocz(ctx->codec->picture_params_size);
1999         if (!ctx->codec_picture_params) {
2000             err = AVERROR(ENOMEM);
2001             goto fail;
2002         }
2003     }
2004
2005     if (ctx->codec->init_sequence_params) {
2006         err = ctx->codec->init_sequence_params(avctx);
2007         if (err < 0) {
2008             av_log(avctx, AV_LOG_ERROR, "Codec sequence initialisation "
2009                    "failed: %d.\n", err);
2010             goto fail;
2011         }
2012     }
2013
2014     if (ctx->va_packed_headers & VA_ENC_PACKED_HEADER_SEQUENCE &&
2015         ctx->codec->write_sequence_header &&
2016         avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
2017         char data[MAX_PARAM_BUFFER_SIZE];
2018         size_t bit_len = 8 * sizeof(data);
2019
2020         err = ctx->codec->write_sequence_header(avctx, data, &bit_len);
2021         if (err < 0) {
2022             av_log(avctx, AV_LOG_ERROR, "Failed to write sequence header "
2023                    "for extradata: %d.\n", err);
2024             goto fail;
2025         } else {
2026             avctx->extradata_size = (bit_len + 7) / 8;
2027             avctx->extradata = av_mallocz(avctx->extradata_size +
2028                                           AV_INPUT_BUFFER_PADDING_SIZE);
2029             if (!avctx->extradata) {
2030                 err = AVERROR(ENOMEM);
2031                 goto fail;
2032             }
2033             memcpy(avctx->extradata, data, avctx->extradata_size);
2034         }
2035     }
2036
2037     return 0;
2038
2039 fail:
2040     ff_vaapi_encode_close(avctx);
2041     return err;
2042 }
2043
2044 av_cold int ff_vaapi_encode_close(AVCodecContext *avctx)
2045 {
2046     VAAPIEncodeContext *ctx = avctx->priv_data;
2047     VAAPIEncodePicture *pic, *next;
2048
2049     for (pic = ctx->pic_start; pic; pic = next) {
2050         next = pic->next;
2051         vaapi_encode_free(avctx, pic);
2052     }
2053
2054     av_buffer_pool_uninit(&ctx->output_buffer_pool);
2055
2056     if (ctx->va_context != VA_INVALID_ID) {
2057         vaDestroyContext(ctx->hwctx->display, ctx->va_context);
2058         ctx->va_context = VA_INVALID_ID;
2059     }
2060
2061     if (ctx->va_config != VA_INVALID_ID) {
2062         vaDestroyConfig(ctx->hwctx->display, ctx->va_config);
2063         ctx->va_config = VA_INVALID_ID;
2064     }
2065
2066     av_freep(&ctx->codec_sequence_params);
2067     av_freep(&ctx->codec_picture_params);
2068
2069     av_buffer_unref(&ctx->recon_frames_ref);
2070     av_buffer_unref(&ctx->input_frames_ref);
2071     av_buffer_unref(&ctx->device_ref);
2072
2073     return 0;
2074 }