src/gallium/state_trackers/va/picture.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2010 Thomas Balling Sørensen & Orasanu Lucian.
   4  * Copyright 2014 Advanced Micro Devices, Inc.
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the
   9  * "Software"), to deal in the Software without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sub license, and/or sell copies of the Software, and to
  12  * permit persons to whom the Software is furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the
  16  * next paragraph) shall be included in all copies or substantial portions
  17  * of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  22  * IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR
  23  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  24  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  25  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  *
  27  **************************************************************************/
  28
  29 #include "pipe/p_video_codec.h"
  30
  31 #include "util/u_handle_table.h"
  32 #include "util/u_video.h"
  33
  34 #include "vl/vl_vlc.h"
  35 #include "vl/vl_winsys.h"
  36
  37 #include "va_private.h"
  38
  39 VAStatus
  40 vlVaBeginPicture(VADriverContextP ctx, VAContextID context_id, VASurfaceID render_target)
  41 {
  42    vlVaDriver *drv;
  43    vlVaContext *context;
  44    vlVaSurface *surf;
  45
  46    if (!ctx)
  47       return VA_STATUS_ERROR_INVALID_CONTEXT;
  48
  49    drv = VL_VA_DRIVER(ctx);
  50    if (!drv)
  51       return VA_STATUS_ERROR_INVALID_CONTEXT;
  52
  53    mtx_lock(&drv->mutex);
  54    context = handle_table_get(drv->htab, context_id);
  55    if (!context) {
  56       pipe_mutex_unlock(drv->mutex);
  57       return VA_STATUS_ERROR_INVALID_CONTEXT;
  58    }
  59
  60    surf = handle_table_get(drv->htab, render_target);
  61    pipe_mutex_unlock(drv->mutex);
  62    if (!surf || !surf->buffer)
  63       return VA_STATUS_ERROR_INVALID_SURFACE;
  64
  65    context->target_id = render_target;
  66    surf->ctx = context_id;
  67    context->target = surf->buffer;
  68
  69    if (!context->decoder) {
  70
  71       /* VPP */
  72       if (context->templat.profile == PIPE_VIDEO_PROFILE_UNKNOWN &&
  73           context->target->buffer_format != PIPE_FORMAT_B8G8R8A8_UNORM &&
  74           context->target->buffer_format != PIPE_FORMAT_R8G8B8A8_UNORM &&
  75           context->target->buffer_format != PIPE_FORMAT_B8G8R8X8_UNORM &&
  76           context->target->buffer_format != PIPE_FORMAT_R8G8B8X8_UNORM &&
  77           context->target->buffer_format != PIPE_FORMAT_NV12)
  78          return VA_STATUS_ERROR_UNIMPLEMENTED;
  79
  80       return VA_STATUS_SUCCESS;
  81    }
  82
  83    if (context->decoder->entrypoint != PIPE_VIDEO_ENTRYPOINT_ENCODE)
  84       context->needs_begin_frame = true;
  85
  86    return VA_STATUS_SUCCESS;
  87 }
  88
  89 void
  90 vlVaGetReferenceFrame(vlVaDriver *drv, VASurfaceID surface_id,
  91                       struct pipe_video_buffer **ref_frame)
  92 {
  93    vlVaSurface *surf = handle_table_get(drv->htab, surface_id);
  94    if (surf)
  95       *ref_frame = surf->buffer;
  96    else
  97       *ref_frame = NULL;
  98 }
  99
 100 static void
 101 getEncParamPreset(vlVaContext *context)
 102 {
 103    //motion estimation preset
 104    context->desc.h264enc.motion_est.motion_est_quarter_pixel = 0x00000001;
 105    context->desc.h264enc.motion_est.lsmvert = 0x00000002;
 106    context->desc.h264enc.motion_est.enc_disable_sub_mode = 0x00000078;
 107    context->desc.h264enc.motion_est.enc_en_ime_overw_dis_subm = 0x00000001;
 108    context->desc.h264enc.motion_est.enc_ime_overw_dis_subm_no = 0x00000001;
 109    context->desc.h264enc.motion_est.enc_ime2_search_range_x = 0x00000004;
 110    context->desc.h264enc.motion_est.enc_ime2_search_range_y = 0x00000004;
 111
 112    //pic control preset
 113    context->desc.h264enc.pic_ctrl.enc_cabac_enable = 0x00000001;
 114    context->desc.h264enc.pic_ctrl.enc_constraint_set_flags = 0x00000040;
 115
 116    //rate control
 117    context->desc.h264enc.rate_ctrl.vbv_buffer_size = 20000000;
 118    context->desc.h264enc.rate_ctrl.vbv_buf_lv = 48;
 119    context->desc.h264enc.rate_ctrl.fill_data_enable = 1;
 120    context->desc.h264enc.rate_ctrl.enforce_hrd = 1;
 121    context->desc.h264enc.enable_vui = false;
 122    if (context->desc.h264enc.rate_ctrl.frame_rate_num == 0 ||
 123        context->desc.h264enc.rate_ctrl.frame_rate_den == 0) {
 124          context->desc.h264enc.rate_ctrl.frame_rate_num = 30;
 125          context->desc.h264enc.rate_ctrl.frame_rate_den = 1;
 126    }
 127    context->desc.h264enc.rate_ctrl.target_bits_picture =
 128       context->desc.h264enc.rate_ctrl.target_bitrate *
 129       ((float)context->desc.h264enc.rate_ctrl.frame_rate_den /
 130       context->desc.h264enc.rate_ctrl.frame_rate_num);
 131    context->desc.h264enc.rate_ctrl.peak_bits_picture_integer =
 132       context->desc.h264enc.rate_ctrl.peak_bitrate *
 133       ((float)context->desc.h264enc.rate_ctrl.frame_rate_den /
 134       context->desc.h264enc.rate_ctrl.frame_rate_num);
 135
 136    context->desc.h264enc.rate_ctrl.peak_bits_picture_fraction = 0;
 137    context->desc.h264enc.ref_pic_mode = 0x00000201;
 138 }
 139
 140 static VAStatus
 141 handlePictureParameterBuffer(vlVaDriver *drv, vlVaContext *context, vlVaBuffer *buf)
 142 {
 143    VAStatus vaStatus = VA_STATUS_SUCCESS;
 144
 145    switch (u_reduce_video_profile(context->templat.profile)) {
 146    case PIPE_VIDEO_FORMAT_MPEG12:
 147       vlVaHandlePictureParameterBufferMPEG12(drv, context, buf);
 148       break;
 149
 150    case PIPE_VIDEO_FORMAT_MPEG4_AVC:
 151       vlVaHandlePictureParameterBufferH264(drv, context, buf);
 152       break;
 153
 154    case PIPE_VIDEO_FORMAT_VC1:
 155       vlVaHandlePictureParameterBufferVC1(drv, context, buf);
 156       break;
 157
 158    case PIPE_VIDEO_FORMAT_MPEG4:
 159       vlVaHandlePictureParameterBufferMPEG4(drv, context, buf);
 160       break;
 161
 162   case PIPE_VIDEO_FORMAT_HEVC:
 163       vlVaHandlePictureParameterBufferHEVC(drv, context, buf);
 164       break;
 165
 166    default:
 167       break;
 168    }
 169
 170    /* Create the decoder once max_references is known. */
 171    if (!context->decoder) {
 172       if (!context->target)
 173          return VA_STATUS_ERROR_INVALID_CONTEXT;
 174
 175       if (context->templat.max_references == 0)
 176          return VA_STATUS_ERROR_INVALID_BUFFER;
 177
 178       if (u_reduce_video_profile(context->templat.profile) ==
 179           PIPE_VIDEO_FORMAT_MPEG4_AVC)
 180          context->templat.level = u_get_h264_level(context->templat.width,
 181             context->templat.height, &context->templat.max_references);
 182
 183       context->decoder = drv->pipe->create_video_codec(drv->pipe,
 184          &context->templat);
 185
 186       if (!context->decoder)
 187          return VA_STATUS_ERROR_ALLOCATION_FAILED;
 188
 189       context->needs_begin_frame = true;
 190    }
 191
 192    return vaStatus;
 193 }
 194
 195 static void
 196 handleIQMatrixBuffer(vlVaContext *context, vlVaBuffer *buf)
 197 {
 198    switch (u_reduce_video_profile(context->templat.profile)) {
 199    case PIPE_VIDEO_FORMAT_MPEG12:
 200       vlVaHandleIQMatrixBufferMPEG12(context, buf);
 201       break;
 202
 203    case PIPE_VIDEO_FORMAT_MPEG4_AVC:
 204       vlVaHandleIQMatrixBufferH264(context, buf);
 205       break;
 206
 207    case PIPE_VIDEO_FORMAT_MPEG4:
 208       vlVaHandleIQMatrixBufferMPEG4(context, buf);
 209       break;
 210
 211    case PIPE_VIDEO_FORMAT_HEVC:
 212       vlVaHandleIQMatrixBufferHEVC(context, buf);
 213       break;
 214
 215    default:
 216       break;
 217    }
 218 }
 219
 220 static void
 221 handleSliceParameterBuffer(vlVaContext *context, vlVaBuffer *buf)
 222 {
 223    switch (u_reduce_video_profile(context->templat.profile)) {
 224    case PIPE_VIDEO_FORMAT_MPEG12:
 225       vlVaHandleSliceParameterBufferMPEG12(context, buf);
 226       break;
 227
 228    case PIPE_VIDEO_FORMAT_VC1:
 229       vlVaHandleSliceParameterBufferVC1(context, buf);
 230       break;
 231
 232    case PIPE_VIDEO_FORMAT_MPEG4_AVC:
 233       vlVaHandleSliceParameterBufferH264(context, buf);
 234       break;
 235
 236    case PIPE_VIDEO_FORMAT_MPEG4:
 237       vlVaHandleSliceParameterBufferMPEG4(context, buf);
 238       break;
 239
 240    case PIPE_VIDEO_FORMAT_HEVC:
 241       vlVaHandleSliceParameterBufferHEVC(context, buf);
 242       break;
 243
 244    default:
 245       break;
 246    }
 247 }
 248
 249 static unsigned int
 250 bufHasStartcode(vlVaBuffer *buf, unsigned int code, unsigned int bits)
 251 {
 252    struct vl_vlc vlc = {0};
 253    int i;
 254
 255    /* search the first 64 bytes for a startcode */
 256    vl_vlc_init(&vlc, 1, (const void * const*)&buf->data, &buf->size);
 257    for (i = 0; i < 64 && vl_vlc_bits_left(&vlc) >= bits; ++i) {
 258       if (vl_vlc_peekbits(&vlc, bits) == code)
 259          return 1;
 260       vl_vlc_eatbits(&vlc, 8);
 261       vl_vlc_fillbits(&vlc);
 262    }
 263
 264    return 0;
 265 }
 266
 267 static void
 268 handleVASliceDataBufferType(vlVaContext *context, vlVaBuffer *buf)
 269 {
 270    enum pipe_video_format format;
 271    unsigned num_buffers = 0;
 272    void * const *buffers[2];
 273    unsigned sizes[2];
 274    static const uint8_t start_code_h264[] = { 0x00, 0x00, 0x01 };
 275    static const uint8_t start_code_h265[] = { 0x00, 0x00, 0x01 };
 276    static const uint8_t start_code_vc1[] = { 0x00, 0x00, 0x01, 0x0d };
 277
 278    format = u_reduce_video_profile(context->templat.profile);
 279    switch (format) {
 280    case PIPE_VIDEO_FORMAT_MPEG4_AVC:
 281       if (bufHasStartcode(buf, 0x000001, 24))
 282          break;
 283
 284       buffers[num_buffers] = (void *const)&start_code_h264;
 285       sizes[num_buffers++] = sizeof(start_code_h264);
 286       break;
 287    case PIPE_VIDEO_FORMAT_HEVC:
 288       if (bufHasStartcode(buf, 0x000001, 24))
 289          break;
 290
 291       buffers[num_buffers] = (void *const)&start_code_h265;
 292       sizes[num_buffers++] = sizeof(start_code_h265);
 293       break;
 294    case PIPE_VIDEO_FORMAT_VC1:
 295       if (bufHasStartcode(buf, 0x0000010d, 32) ||
 296           bufHasStartcode(buf, 0x0000010c, 32) ||
 297           bufHasStartcode(buf, 0x0000010b, 32))
 298          break;
 299
 300       if (context->decoder->profile == PIPE_VIDEO_PROFILE_VC1_ADVANCED) {
 301          buffers[num_buffers] = (void *const)&start_code_vc1;
 302          sizes[num_buffers++] = sizeof(start_code_vc1);
 303       }
 304       break;
 305    case PIPE_VIDEO_FORMAT_MPEG4:
 306       if (bufHasStartcode(buf, 0x000001, 24))
 307          break;
 308
 309       vlVaDecoderFixMPEG4Startcode(context);
 310       buffers[num_buffers] = (void *)context->mpeg4.start_code;
 311       sizes[num_buffers++] = context->mpeg4.start_code_size;
 312    default:
 313       break;
 314    }
 315
 316    buffers[num_buffers] = buf->data;
 317    sizes[num_buffers] = buf->size;
 318    ++num_buffers;
 319
 320    if (context->needs_begin_frame) {
 321       context->decoder->begin_frame(context->decoder, context->target,
 322          &context->desc.base);
 323       context->needs_begin_frame = false;
 324    }
 325    context->decoder->decode_bitstream(context->decoder, context->target, &context->desc.base,
 326       num_buffers, (const void * const*)buffers, sizes);
 327 }
 328
 329 static VAStatus
 330 handleVAEncMiscParameterTypeRateControl(vlVaContext *context, VAEncMiscParameterBuffer *misc)
 331 {
 332    VAEncMiscParameterRateControl *rc = (VAEncMiscParameterRateControl *)misc->data;
 333    if (context->desc.h264enc.rate_ctrl.rate_ctrl_method ==
 334        PIPE_H264_ENC_RATE_CONTROL_METHOD_CONSTANT)
 335       context->desc.h264enc.rate_ctrl.target_bitrate = rc->bits_per_second;
 336    else
 337       context->desc.h264enc.rate_ctrl.target_bitrate = rc->bits_per_second * (rc->target_percentage / 100.0);
 338    context->desc.h264enc.rate_ctrl.peak_bitrate = rc->bits_per_second;
 339    if (context->desc.h264enc.rate_ctrl.target_bitrate < 2000000)
 340       context->desc.h264enc.rate_ctrl.vbv_buffer_size = MIN2((context->desc.h264enc.rate_ctrl.target_bitrate * 2.75), 2000000);
 341    else
 342       context->desc.h264enc.rate_ctrl.vbv_buffer_size = context->desc.h264enc.rate_ctrl.target_bitrate;
 343
 344    return VA_STATUS_SUCCESS;
 345 }
 346
 347 static VAStatus
 348 handleVAEncMiscParameterTypeFrameRate(vlVaContext *context, VAEncMiscParameterBuffer *misc)
 349 {
 350    VAEncMiscParameterFrameRate *fr = (VAEncMiscParameterFrameRate *)misc->data;
 351    if (fr->framerate & 0xffff0000) {
 352       context->desc.h264enc.rate_ctrl.frame_rate_num = fr->framerate       & 0xffff;
 353       context->desc.h264enc.rate_ctrl.frame_rate_den = fr->framerate >> 16 & 0xffff;
 354    } else {
 355       context->desc.h264enc.rate_ctrl.frame_rate_num = fr->framerate;
 356       context->desc.h264enc.rate_ctrl.frame_rate_den = 1;
 357    }
 358    return VA_STATUS_SUCCESS;
 359 }
 360
 361 static VAStatus
 362 handleVAEncSequenceParameterBufferType(vlVaDriver *drv, vlVaContext *context, vlVaBuffer *buf)
 363 {
 364    VAEncSequenceParameterBufferH264 *h264 = (VAEncSequenceParameterBufferH264 *)buf->data;
 365    if (!context->decoder) {
 366       context->templat.max_references = h264->max_num_ref_frames;
 367       context->templat.level = h264->level_idc;
 368       context->decoder = drv->pipe->create_video_codec(drv->pipe, &context->templat);
 369       if (!context->decoder)
 370          return VA_STATUS_ERROR_ALLOCATION_FAILED;
 371    }
 372
 373    context->gop_coeff = ((1024 + h264->intra_idr_period - 1) / h264->intra_idr_period + 1) / 2 * 2;
 374    if (context->gop_coeff > VL_VA_ENC_GOP_COEFF)
 375       context->gop_coeff = VL_VA_ENC_GOP_COEFF;
 376    context->desc.h264enc.gop_size = h264->intra_idr_period * context->gop_coeff;
 377    context->desc.h264enc.rate_ctrl.frame_rate_num = h264->time_scale / 2;
 378    context->desc.h264enc.rate_ctrl.frame_rate_den = h264->num_units_in_tick;
 379    return VA_STATUS_SUCCESS;
 380 }
 381
 382 static VAStatus
 383 handleVAEncMiscParameterBufferType(vlVaContext *context, vlVaBuffer *buf)
 384 {
 385    VAStatus vaStatus = VA_STATUS_SUCCESS;
 386    VAEncMiscParameterBuffer *misc;
 387    misc = buf->data;
 388
 389    switch (misc->type) {
 390    case VAEncMiscParameterTypeRateControl:
 391       vaStatus = handleVAEncMiscParameterTypeRateControl(context, misc);
 392       break;
 393
 394    case VAEncMiscParameterTypeFrameRate:
 395       vaStatus = handleVAEncMiscParameterTypeFrameRate(context, misc);
 396       break;
 397
 398    default:
 399       break;
 400    }
 401
 402    return vaStatus;
 403 }
 404
 405 static VAStatus
 406 handleVAEncPictureParameterBufferType(vlVaDriver *drv, vlVaContext *context, vlVaBuffer *buf)
 407 {
 408    VAEncPictureParameterBufferH264 *h264;
 409    vlVaBuffer *coded_buf;
 410
 411    h264 = buf->data;
 412    context->desc.h264enc.frame_num = h264->frame_num;
 413    context->desc.h264enc.not_referenced = false;
 414    context->desc.h264enc.is_idr = (h264->pic_fields.bits.idr_pic_flag == 1);
 415    context->desc.h264enc.pic_order_cnt = h264->CurrPic.TopFieldOrderCnt;
 416    if (context->desc.h264enc.gop_cnt == 0)
 417       context->desc.h264enc.i_remain = context->gop_coeff;
 418    else if (context->desc.h264enc.frame_num == 1)
 419       context->desc.h264enc.i_remain--;
 420
 421    context->desc.h264enc.p_remain = context->desc.h264enc.gop_size - context->desc.h264enc.gop_cnt - context->desc.h264enc.i_remain;
 422
 423    coded_buf = handle_table_get(drv->htab, h264->coded_buf);
 424    if (!coded_buf->derived_surface.resource)
 425       coded_buf->derived_surface.resource = pipe_buffer_create(drv->pipe->screen, PIPE_BIND_VERTEX_BUFFER,
 426                                             PIPE_USAGE_STREAM, coded_buf->size);
 427    context->coded_buf = coded_buf;
 428
 429    context->desc.h264enc.frame_idx[h264->CurrPic.picture_id] = h264->frame_num;
 430    if (context->desc.h264enc.is_idr)
 431       context->desc.h264enc.picture_type = PIPE_H264_ENC_PICTURE_TYPE_IDR;
 432    else
 433       context->desc.h264enc.picture_type = PIPE_H264_ENC_PICTURE_TYPE_P;
 434
 435    context->desc.h264enc.quant_i_frames = h264->pic_init_qp;
 436    context->desc.h264enc.quant_b_frames = h264->pic_init_qp;
 437    context->desc.h264enc.quant_p_frames = h264->pic_init_qp;
 438    context->desc.h264enc.gop_cnt++;
 439    if (context->desc.h264enc.gop_cnt == context->desc.h264enc.gop_size)
 440       context->desc.h264enc.gop_cnt = 0;
 441
 442    return VA_STATUS_SUCCESS;
 443 }
 444
 445 static VAStatus
 446 handleVAEncSliceParameterBufferType(vlVaDriver *drv, vlVaContext *context, vlVaBuffer *buf)
 447 {
 448    VAEncSliceParameterBufferH264 *h264;
 449
 450    h264 = buf->data;
 451    context->desc.h264enc.ref_idx_l0 = VA_INVALID_ID;
 452    context->desc.h264enc.ref_idx_l1 = VA_INVALID_ID;
 453
 454    for (int i = 0; i < 32; i++) {
 455       if (h264->RefPicList0[i].picture_id != VA_INVALID_ID) {
 456          if (context->desc.h264enc.ref_idx_l0 == VA_INVALID_ID)
 457             context->desc.h264enc.ref_idx_l0 = context->desc.h264enc.frame_idx[h264->RefPicList0[i].picture_id];
 458       }
 459       if (h264->RefPicList1[i].picture_id != VA_INVALID_ID && h264->slice_type == 1) {
 460          if (context->desc.h264enc.ref_idx_l1 == VA_INVALID_ID)
 461             context->desc.h264enc.ref_idx_l1 = context->desc.h264enc.frame_idx[h264->RefPicList1[i].picture_id];
 462       }
 463    }
 464
 465    if (h264->slice_type == 1)
 466       context->desc.h264enc.picture_type = PIPE_H264_ENC_PICTURE_TYPE_B;
 467    else if (h264->slice_type == 0)
 468       context->desc.h264enc.picture_type = PIPE_H264_ENC_PICTURE_TYPE_P;
 469    else if (h264->slice_type == 2) {
 470       if (context->desc.h264enc.is_idr){
 471          context->desc.h264enc.picture_type = PIPE_H264_ENC_PICTURE_TYPE_IDR;
 472          context->desc.h264enc.idr_pic_id++;
 473            } else
 474          context->desc.h264enc.picture_type = PIPE_H264_ENC_PICTURE_TYPE_I;
 475    } else
 476       context->desc.h264enc.picture_type = PIPE_H264_ENC_PICTURE_TYPE_SKIP;
 477
 478    return VA_STATUS_SUCCESS;
 479 }
 480
 481 VAStatus
 482 vlVaRenderPicture(VADriverContextP ctx, VAContextID context_id, VABufferID *buffers, int num_buffers)
 483 {
 484    vlVaDriver *drv;
 485    vlVaContext *context;
 486    VAStatus vaStatus = VA_STATUS_SUCCESS;
 487
 488    unsigned i;
 489
 490    if (!ctx)
 491       return VA_STATUS_ERROR_INVALID_CONTEXT;
 492
 493    drv = VL_VA_DRIVER(ctx);
 494    if (!drv)
 495       return VA_STATUS_ERROR_INVALID_CONTEXT;
 496
 497    mtx_lock(&drv->mutex);
 498    context = handle_table_get(drv->htab, context_id);
 499    if (!context) {
 500       pipe_mutex_unlock(drv->mutex);
 501       return VA_STATUS_ERROR_INVALID_CONTEXT;
 502    }
 503
 504    for (i = 0; i < num_buffers; ++i) {
 505       vlVaBuffer *buf = handle_table_get(drv->htab, buffers[i]);
 506       if (!buf) {
 507          pipe_mutex_unlock(drv->mutex);
 508          return VA_STATUS_ERROR_INVALID_BUFFER;
 509       }
 510
 511       switch (buf->type) {
 512       case VAPictureParameterBufferType:
 513          vaStatus = handlePictureParameterBuffer(drv, context, buf);
 514          break;
 515
 516       case VAIQMatrixBufferType:
 517          handleIQMatrixBuffer(context, buf);
 518          break;
 519
 520       case VASliceParameterBufferType:
 521          handleSliceParameterBuffer(context, buf);
 522          break;
 523
 524       case VASliceDataBufferType:
 525          handleVASliceDataBufferType(context, buf);
 526          break;
 527       case VAProcPipelineParameterBufferType:
 528          vaStatus = vlVaHandleVAProcPipelineParameterBufferType(drv, context, buf);
 529          break;
 530
 531       case VAEncSequenceParameterBufferType:
 532          vaStatus = handleVAEncSequenceParameterBufferType(drv, context, buf);
 533          break;
 534
 535       case VAEncMiscParameterBufferType:
 536          vaStatus = handleVAEncMiscParameterBufferType(context, buf);
 537          break;
 538
 539       case VAEncPictureParameterBufferType:
 540          vaStatus = handleVAEncPictureParameterBufferType(drv, context, buf);
 541          break;
 542
 543       case VAEncSliceParameterBufferType:
 544          vaStatus = handleVAEncSliceParameterBufferType(drv, context, buf);
 545          break;
 546
 547       default:
 548          break;
 549       }
 550    }
 551    pipe_mutex_unlock(drv->mutex);
 552
 553    return vaStatus;
 554 }
 555
 556 VAStatus
 557 vlVaEndPicture(VADriverContextP ctx, VAContextID context_id)
 558 {
 559    vlVaDriver *drv;
 560    vlVaContext *context;
 561    vlVaBuffer *coded_buf;
 562    vlVaSurface *surf;
 563    void *feedback;
 564
 565    if (!ctx)
 566       return VA_STATUS_ERROR_INVALID_CONTEXT;
 567
 568    drv = VL_VA_DRIVER(ctx);
 569    if (!drv)
 570       return VA_STATUS_ERROR_INVALID_CONTEXT;
 571
 572    mtx_lock(&drv->mutex);
 573    context = handle_table_get(drv->htab, context_id);
 574    pipe_mutex_unlock(drv->mutex);
 575    if (!context)
 576       return VA_STATUS_ERROR_INVALID_CONTEXT;
 577
 578    if (!context->decoder) {
 579       if (context->templat.profile != PIPE_VIDEO_PROFILE_UNKNOWN)
 580          return VA_STATUS_ERROR_INVALID_CONTEXT;
 581
 582       /* VPP */
 583       return VA_STATUS_SUCCESS;
 584    }
 585
 586    mtx_lock(&drv->mutex);
 587    surf = handle_table_get(drv->htab, context->target_id);
 588    context->mpeg4.frame_num++;
 589
 590    if (context->decoder->entrypoint == PIPE_VIDEO_ENTRYPOINT_ENCODE) {
 591       coded_buf = context->coded_buf;
 592       getEncParamPreset(context);
 593       context->desc.h264enc.frame_num_cnt++;
 594       context->decoder->begin_frame(context->decoder, context->target, &context->desc.base);
 595       context->decoder->encode_bitstream(context->decoder, context->target,
 596                                          coded_buf->derived_surface.resource, &feedback);
 597       surf->feedback = feedback;
 598       surf->coded_buf = coded_buf;
 599    }
 600
 601    context->decoder->end_frame(context->decoder, context->target, &context->desc.base);
 602    if (context->decoder->entrypoint == PIPE_VIDEO_ENTRYPOINT_ENCODE) {
 603       int idr_period = context->desc.h264enc.gop_size / context->gop_coeff;
 604       int p_remain_in_idr = idr_period - context->desc.h264enc.frame_num;
 605       surf->frame_num_cnt = context->desc.h264enc.frame_num_cnt;
 606       surf->force_flushed = false;
 607       if (context->first_single_submitted) {
 608          context->decoder->flush(context->decoder);
 609          context->first_single_submitted = false;
 610          surf->force_flushed = true;
 611       }
 612       if (p_remain_in_idr == 1) {
 613          if ((context->desc.h264enc.frame_num_cnt % 2) != 0) {
 614             context->decoder->flush(context->decoder);
 615             context->first_single_submitted = true;
 616          }
 617          else
 618             context->first_single_submitted = false;
 619          surf->force_flushed = true;
 620       }
 621    }
 622    pipe_mutex_unlock(drv->mutex);
 623    return VA_STATUS_SUCCESS;
 624 }