src/i965_encoder.c

   1 /*
   2  * Copyright © 2010 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the
   6  * "Software"), to deal in the Software without restriction, including
   7  * without limitation the rights to use, copy, modify, merge, publish,
   8  * distribute, sub license, and/or sell copies of the Software, and to
   9  * permit persons to whom the Software is furnished to do so, subject to
  10  * the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the
  13  * next paragraph) shall be included in all copies or substantial portions
  14  * of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  19  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  20  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  21  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  22  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *    Zhou Chang <chang.zhou@intel.com>
  26  *
  27  */
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <assert.h>
  33
  34 #include "intel_batchbuffer.h"
  35 #include "intel_driver.h"
  36
  37 #include "i965_defines.h"
  38 #include "i965_drv_video.h"
  39 #include "i965_encoder.h"
  40 #include "gen6_vme.h"
  41 #include "gen6_mfc.h"
  42
  43 #include "i965_post_processing.h"
  44 #include "i965_encoder_api.h"
  45
  46 static struct intel_fraction
  47 reduce_fraction(struct intel_fraction f)
  48 {
  49     unsigned int a = f.num, b = f.den, c;
  50     while ((c = a % b)) {
  51         a = b;
  52         b = c;
  53     }
  54     return (struct intel_fraction) {
  55         f.num / b, f.den / b
  56     };
  57 }
  58
  59 static VAStatus
  60 clear_border(struct object_surface *obj_surface)
  61 {
  62     int width[3], height[3], hstride[3], vstride[3]; /* in byte */
  63     int planes;
  64     unsigned char* p;
  65     int i, j;
  66
  67     if (obj_surface->border_cleared)
  68         return VA_STATUS_SUCCESS;
  69
  70     if (obj_surface->fourcc == VA_FOURCC_NV12) {
  71         planes = 2;
  72         width[0] = width[1] = obj_surface->orig_width;
  73         height[0] = obj_surface->orig_height;
  74         height[1] = obj_surface->orig_height / 2;
  75         hstride[0] = hstride[1] = obj_surface->width;
  76         vstride[0] = obj_surface->height;
  77         vstride[1] = obj_surface->height / 2;
  78
  79     } else {
  80         /* todo add P010 */
  81         return VA_STATUS_SUCCESS;
  82     }
  83     drm_intel_gem_bo_map_gtt(obj_surface->bo);
  84
  85     p = (unsigned char*)obj_surface->bo->virtual;
  86     if (!p)
  87         return VA_STATUS_ERROR_INVALID_SURFACE;
  88
  89     for (i = 0; i < planes; i++) {
  90         int w = width[i];
  91         int h = height[i];
  92         int hs = hstride[i];
  93         int vs = vstride[i];
  94         /* right */
  95         for (j = 0; j < h; j++) {
  96             memset(p + w, 0, hs - w);
  97             p += hs;
  98         }
  99         /* bottom */
 100         for (/* nothing */; j < vs; j++) {
 101             memset(p, 0, hs);
 102             p += hs;
 103         }
 104
 105     }
 106     drm_intel_gem_bo_unmap_gtt(obj_surface->bo);
 107     obj_surface->border_cleared = true;
 108     return VA_STATUS_SUCCESS;
 109 }
 110
 111 static VAStatus
 112 intel_encoder_check_yuv_surface(VADriverContextP ctx,
 113                                 VAProfile profile,
 114                                 struct encode_state *encode_state,
 115                                 struct intel_encoder_context *encoder_context)
 116 {
 117     struct i965_driver_data *i965 = i965_driver_data(ctx);
 118     struct i965_surface src_surface, dst_surface;
 119     struct object_surface *obj_surface;
 120     VAStatus status;
 121     VARectangle rect;
 122     int format = VA_RT_FORMAT_YUV420;
 123     unsigned int fourcc = VA_FOURCC_NV12;
 124
 125     /* releae the temporary surface */
 126     if (encoder_context->is_tmp_id) {
 127         i965_DestroySurfaces(ctx, &encoder_context->input_yuv_surface, 1);
 128         encode_state->input_yuv_object = NULL;
 129     }
 130
 131     encoder_context->is_tmp_id = 0;
 132     obj_surface = SURFACE(encode_state->current_render_target);
 133     assert(obj_surface && obj_surface->bo);
 134
 135     if (!obj_surface || !obj_surface->bo)
 136         return VA_STATUS_ERROR_INVALID_PARAMETER;
 137
 138     if (VAProfileHEVCMain10 == profile &&
 139         obj_surface->fourcc != VA_FOURCC_P010)
 140         return VA_STATUS_ERROR_INVALID_PARAMETER;
 141
 142     if (obj_surface->fourcc == VA_FOURCC_NV12 ||
 143         (VAProfileHEVCMain10 == profile &&
 144          obj_surface->fourcc == VA_FOURCC_P010)) {
 145
 146         unsigned int tiling = 0, swizzle = 0;
 147         dri_bo_get_tiling(obj_surface->bo, &tiling, &swizzle);
 148
 149         if (tiling == I915_TILING_Y) {
 150             encoder_context->input_yuv_surface = encode_state->current_render_target;
 151             encode_state->input_yuv_object = obj_surface;
 152             return clear_border(obj_surface);
 153         }
 154     }
 155
 156     if (VAProfileHEVCMain10 == profile) {
 157         format = VA_RT_FORMAT_YUV420_10BPP;
 158         fourcc = VA_FOURCC_P010;
 159     }
 160
 161     rect.x = 0;
 162     rect.y = 0;
 163     rect.width = obj_surface->orig_width;
 164     rect.height = obj_surface->orig_height;
 165
 166     src_surface.base = (struct object_base *)obj_surface;
 167     src_surface.type = I965_SURFACE_TYPE_SURFACE;
 168     src_surface.flags = I965_SURFACE_FLAG_FRAME;
 169
 170     status = i965_CreateSurfaces(ctx,
 171                                  obj_surface->orig_width,
 172                                  obj_surface->orig_height,
 173                                  format,
 174                                  1,
 175                                  &encoder_context->input_yuv_surface);
 176     ASSERT_RET(status == VA_STATUS_SUCCESS, status);
 177
 178     obj_surface = SURFACE(encoder_context->input_yuv_surface);
 179     encode_state->input_yuv_object = obj_surface;
 180     assert(obj_surface);
 181     i965_check_alloc_surface_bo(ctx, obj_surface, 1, fourcc, SUBSAMPLE_YUV420);
 182
 183     dst_surface.base = (struct object_base *)obj_surface;
 184     dst_surface.type = I965_SURFACE_TYPE_SURFACE;
 185     dst_surface.flags = I965_SURFACE_FLAG_FRAME;
 186
 187     status = i965_image_processing(ctx,
 188                                    &src_surface,
 189                                    &rect,
 190                                    &dst_surface,
 191                                    &rect);
 192     assert(status == VA_STATUS_SUCCESS);
 193
 194     encoder_context->is_tmp_id = 1;
 195
 196     return clear_border(obj_surface);
 197 }
 198
 199
 200 static VAStatus
 201 intel_encoder_check_jpeg_yuv_surface(VADriverContextP ctx,
 202                                      VAProfile profile,
 203                                      struct encode_state *encode_state,
 204                                      struct intel_encoder_context *encoder_context)
 205 {
 206     struct i965_driver_data *i965 = i965_driver_data(ctx);
 207     struct i965_surface src_surface, dst_surface;
 208     struct object_surface *obj_surface;
 209     VAStatus status;
 210     VARectangle rect;
 211     int format = 0, fourcc = 0, subsample = 0;
 212
 213     /* releae the temporary surface */
 214     if (encoder_context->is_tmp_id) {
 215         i965_DestroySurfaces(ctx, &encoder_context->input_yuv_surface, 1);
 216         encode_state->input_yuv_object = NULL;
 217     }
 218
 219     encoder_context->is_tmp_id = 0;
 220     obj_surface = SURFACE(encode_state->current_render_target);
 221     assert(obj_surface && obj_surface->bo);
 222
 223     if (!obj_surface || !obj_surface->bo)
 224         return VA_STATUS_ERROR_INVALID_PARAMETER;
 225
 226     unsigned int tiling = 0, swizzle = 0;
 227
 228     dri_bo_get_tiling(obj_surface->bo, &tiling, &swizzle);
 229
 230     if (tiling == I915_TILING_Y) {
 231         if ((obj_surface->fourcc == VA_FOURCC_NV12)  || (obj_surface->fourcc == VA_FOURCC_UYVY) ||
 232             (obj_surface->fourcc == VA_FOURCC_YUY2)  || (obj_surface->fourcc == VA_FOURCC_Y800) ||
 233             (obj_surface->fourcc == VA_FOURCC_RGBA)  || (obj_surface->fourcc == VA_FOURCC_444P)) {
 234             encoder_context->input_yuv_surface = encode_state->current_render_target;
 235             encode_state->input_yuv_object = obj_surface;
 236             return VA_STATUS_SUCCESS;
 237         }
 238     }
 239
 240     rect.x = 0;
 241     rect.y = 0;
 242     rect.width = obj_surface->orig_width;
 243     rect.height = obj_surface->orig_height;
 244
 245     src_surface.base = (struct object_base *)obj_surface;
 246     src_surface.type = I965_SURFACE_TYPE_SURFACE;
 247     src_surface.flags = I965_SURFACE_FLAG_FRAME;
 248
 249     switch (obj_surface->fourcc) {
 250
 251     case VA_FOURCC_YUY2:
 252         fourcc = VA_FOURCC_YUY2;
 253         format = VA_RT_FORMAT_YUV422;
 254         subsample = SUBSAMPLE_YUV422H;
 255         break;
 256
 257     case VA_FOURCC_UYVY:
 258         fourcc = VA_FOURCC_UYVY;
 259         format = VA_RT_FORMAT_YUV422;
 260         subsample = SUBSAMPLE_YUV422H;
 261         break;
 262
 263     case VA_FOURCC_Y800:
 264         fourcc = VA_FOURCC_Y800;
 265         format = VA_RT_FORMAT_YUV400;
 266         subsample = SUBSAMPLE_YUV400;
 267         break;
 268
 269     case VA_FOURCC_444P:
 270         fourcc = VA_FOURCC_444P;
 271         format = VA_RT_FORMAT_YUV444;
 272         subsample = SUBSAMPLE_YUV444;
 273         break;
 274
 275     case VA_FOURCC_RGBA:
 276         fourcc = VA_FOURCC_RGBA;
 277         format = VA_RT_FORMAT_RGB32;
 278         subsample = SUBSAMPLE_RGBX;
 279         break;
 280
 281     default: //All other scenarios will have NV12 format
 282         fourcc = VA_FOURCC_NV12;
 283         format = VA_RT_FORMAT_YUV420;
 284         subsample = SUBSAMPLE_YUV420;
 285         break;
 286     }
 287
 288     status = i965_CreateSurfaces(ctx,
 289                                  obj_surface->orig_width,
 290                                  obj_surface->orig_height,
 291                                  format,
 292                                  1,
 293                                  &encoder_context->input_yuv_surface);
 294     assert(status == VA_STATUS_SUCCESS);
 295
 296     if (status != VA_STATUS_SUCCESS)
 297         return status;
 298
 299     obj_surface = SURFACE(encoder_context->input_yuv_surface);
 300     encode_state->input_yuv_object = obj_surface;
 301     assert(obj_surface);
 302     i965_check_alloc_surface_bo(ctx, obj_surface, 1, fourcc, subsample);
 303
 304     dst_surface.base = (struct object_base *)obj_surface;
 305     dst_surface.type = I965_SURFACE_TYPE_SURFACE;
 306     dst_surface.flags = I965_SURFACE_FLAG_FRAME;
 307
 308     //The Y800 format is expected to be tiled.
 309     //Linear Y800 is a corner case and needs code in the i965_image_processing.
 310     if (obj_surface->fourcc != VA_FOURCC_Y800) {
 311         status = i965_image_processing(ctx,
 312                                        &src_surface,
 313                                        &rect,
 314                                        &dst_surface,
 315                                        &rect);
 316         assert(status == VA_STATUS_SUCCESS);
 317     }
 318
 319     encoder_context->is_tmp_id = 1;
 320
 321     return VA_STATUS_SUCCESS;
 322 }
 323
 324 static VAStatus
 325 intel_encoder_check_brc_h264_sequence_parameter(VADriverContextP ctx,
 326                                                 struct encode_state *encode_state,
 327                                                 struct intel_encoder_context *encoder_context,
 328                                                 unsigned int *seq_bits_per_second)
 329 {
 330     VAEncSequenceParameterBufferH264 *seq_param = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
 331     struct intel_fraction framerate;
 332     unsigned short num_pframes_in_gop, num_bframes_in_gop;
 333
 334     if (!encoder_context->is_new_sequence)
 335         return VA_STATUS_SUCCESS;
 336
 337     assert(seq_param);
 338
 339     if (!seq_param->num_units_in_tick || !seq_param->time_scale) {
 340         framerate = (struct intel_fraction) {
 341             30, 1
 342         };
 343     } else {
 344         // for the highest layer
 345         framerate = (struct intel_fraction) {
 346             seq_param->time_scale, 2 * seq_param->num_units_in_tick
 347         };
 348     }
 349     framerate = reduce_fraction(framerate);
 350
 351     encoder_context->brc.num_iframes_in_gop = 1; // Always 1
 352
 353     if (seq_param->intra_period == 0) { // E.g. IDRPP... / IDR(PBB)... (no IDR/I any more)
 354         if (seq_param->ip_period == 0)
 355             goto error;
 356
 357         encoder_context->brc.gop_size = (framerate.num + framerate.den - 1) / framerate.den; // fake
 358         num_pframes_in_gop = (encoder_context->brc.gop_size +
 359                               seq_param->ip_period - 1) / seq_param->ip_period - 1;
 360     } else if (seq_param->intra_period == 1) { // E.g. IDRIII...
 361         encoder_context->brc.gop_size = 1;
 362         num_pframes_in_gop = 0;
 363     } else {
 364         if (seq_param->ip_period == 0)
 365             goto error;
 366
 367         encoder_context->brc.gop_size = seq_param->intra_period;
 368         num_pframes_in_gop = (encoder_context->brc.gop_size +
 369                               seq_param->ip_period - 1) / seq_param->ip_period - 1;
 370     }
 371
 372     num_bframes_in_gop = (encoder_context->brc.gop_size -
 373                           encoder_context->brc.num_iframes_in_gop - num_pframes_in_gop);
 374
 375     if (num_pframes_in_gop != encoder_context->brc.num_pframes_in_gop ||
 376         num_bframes_in_gop != encoder_context->brc.num_bframes_in_gop ||
 377         framerate.num != encoder_context->brc.framerate[encoder_context->layer.num_layers - 1].num ||
 378         framerate.den != encoder_context->brc.framerate[encoder_context->layer.num_layers - 1].den) {
 379         encoder_context->brc.num_pframes_in_gop = num_pframes_in_gop;
 380         encoder_context->brc.num_bframes_in_gop = num_bframes_in_gop;
 381         encoder_context->brc.framerate[encoder_context->layer.num_layers - 1] = framerate;
 382         encoder_context->brc.need_reset = 1;
 383     }
 384
 385     if (!encoder_context->brc.hrd_buffer_size ||
 386         !encoder_context->brc.hrd_initial_buffer_fullness) {
 387         encoder_context->brc.hrd_buffer_size = seq_param->bits_per_second << 1;
 388         encoder_context->brc.hrd_initial_buffer_fullness = seq_param->bits_per_second;
 389     }
 390
 391     *seq_bits_per_second = seq_param->bits_per_second;
 392
 393     return VA_STATUS_SUCCESS;
 394
 395 error:
 396     return VA_STATUS_ERROR_INVALID_PARAMETER;
 397 }
 398
 399 static VAStatus
 400 intel_encoder_check_brc_vp8_sequence_parameter(VADriverContextP ctx,
 401                                                struct encode_state *encode_state,
 402                                                struct intel_encoder_context *encoder_context,
 403                                                unsigned int *seq_bits_per_second)
 404 {
 405     VAEncSequenceParameterBufferVP8 *seq_param = (VAEncSequenceParameterBufferVP8 *)encode_state->seq_param_ext->buffer;
 406     unsigned int num_pframes_in_gop;
 407
 408     if (!encoder_context->is_new_sequence)
 409         return VA_STATUS_SUCCESS;
 410
 411     assert(seq_param);
 412
 413     encoder_context->brc.num_iframes_in_gop = 1;// Always 1
 414     encoder_context->brc.num_bframes_in_gop = 0;// No B frame
 415
 416     if (seq_param->intra_period == 0) {         // E.g. IPPP... (only one I frame in the stream)
 417         encoder_context->brc.gop_size = 30;     // fake
 418     } else {
 419         encoder_context->brc.gop_size = seq_param->intra_period;
 420     }
 421
 422     num_pframes_in_gop = encoder_context->brc.gop_size - 1;
 423
 424     if (!encoder_context->brc.framerate[encoder_context->layer.num_layers - 1].num) {
 425         // for the highest layer
 426         encoder_context->brc.framerate[encoder_context->layer.num_layers - 1] = (struct intel_fraction) {
 427             30, 1
 428         };
 429         encoder_context->brc.need_reset = 1;
 430     }
 431
 432     if (num_pframes_in_gop != encoder_context->brc.num_pframes_in_gop) {
 433         encoder_context->brc.num_pframes_in_gop = num_pframes_in_gop;
 434         encoder_context->brc.need_reset = 1;
 435     }
 436
 437     if (!encoder_context->brc.hrd_buffer_size ||
 438         !encoder_context->brc.hrd_initial_buffer_fullness) {
 439         encoder_context->brc.hrd_buffer_size = seq_param->bits_per_second << 1;
 440         encoder_context->brc.hrd_initial_buffer_fullness = seq_param->bits_per_second;
 441         encoder_context->brc.need_reset = 1;
 442     }
 443
 444     *seq_bits_per_second = seq_param->bits_per_second;
 445
 446     return VA_STATUS_SUCCESS;
 447 }
 448
 449 static VAStatus
 450 intel_encoder_check_brc_hevc_sequence_parameter(VADriverContextP ctx,
 451                                                 struct encode_state *encode_state,
 452                                                 struct intel_encoder_context *encoder_context,
 453                                                 unsigned int *seq_bits_per_second)
 454 {
 455     VAEncSequenceParameterBufferHEVC *seq_param = (VAEncSequenceParameterBufferHEVC*)encode_state->seq_param_ext->buffer;
 456     struct intel_fraction framerate;
 457     unsigned int gop_size, num_iframes_in_gop, num_pframes_in_gop, num_bframes_in_gop;
 458
 459     if (!encoder_context->is_new_sequence)
 460         return VA_STATUS_SUCCESS;
 461     if (!seq_param)
 462         return VA_STATUS_ERROR_INVALID_PARAMETER;
 463
 464     if (!seq_param->vui_time_scale || !seq_param->vui_num_units_in_tick)
 465         framerate = (struct intel_fraction) {
 466         30, 1
 467     };
 468     else
 469         framerate = (struct intel_fraction) {
 470         seq_param->vui_time_scale, seq_param->vui_num_units_in_tick
 471     };
 472     framerate = reduce_fraction(framerate);
 473
 474     num_iframes_in_gop = 1;
 475     if (seq_param->intra_period == 0) {
 476         gop_size = -1;
 477         num_pframes_in_gop = -1;
 478     } else if (seq_param->intra_period == 1) {
 479         gop_size = 1;
 480         num_pframes_in_gop = 0;
 481     } else {
 482         gop_size = seq_param->intra_period;
 483         num_pframes_in_gop = (seq_param->intra_period + seq_param->ip_period - 1) / seq_param->ip_period - 1;
 484     }
 485     num_bframes_in_gop = gop_size - num_iframes_in_gop - num_pframes_in_gop;
 486
 487     if (encoder_context->brc.framerate[0].num != framerate.num ||
 488         encoder_context->brc.framerate[0].den != framerate.den) {
 489         encoder_context->brc.framerate[0] = framerate;
 490         encoder_context->brc.need_reset = 1;
 491     }
 492
 493     if (encoder_context->brc.gop_size != gop_size ||
 494         encoder_context->brc.num_iframes_in_gop != num_iframes_in_gop ||
 495         encoder_context->brc.num_pframes_in_gop != num_pframes_in_gop ||
 496         encoder_context->brc.num_bframes_in_gop != num_bframes_in_gop) {
 497         encoder_context->brc.gop_size = gop_size;
 498         encoder_context->brc.num_iframes_in_gop = num_iframes_in_gop;
 499         encoder_context->brc.num_pframes_in_gop = num_pframes_in_gop;
 500         encoder_context->brc.num_bframes_in_gop = num_bframes_in_gop;
 501         encoder_context->brc.need_reset = 1;
 502     }
 503
 504     *seq_bits_per_second = seq_param->bits_per_second;
 505
 506     return VA_STATUS_SUCCESS;
 507 }
 508
 509 static VAStatus
 510 intel_encoder_check_brc_vp9_sequence_parameter(VADriverContextP ctx,
 511                                                struct encode_state *encode_state,
 512                                                struct intel_encoder_context *encoder_context,
 513                                                unsigned int *seq_bits_per_second)
 514 {
 515     VAEncSequenceParameterBufferVP9 *seq_param = (VAEncSequenceParameterBufferVP9*)encode_state->seq_param_ext->buffer;
 516     unsigned int gop_size;
 517
 518     if (!encoder_context->is_new_sequence)
 519         return VA_STATUS_SUCCESS;
 520     if (!seq_param)
 521         return VA_STATUS_ERROR_INVALID_PARAMETER;
 522
 523     if (seq_param->intra_period == 0)
 524         gop_size = -1; // Dummy value (infinity).
 525     else
 526         gop_size = seq_param->intra_period;
 527
 528     if (encoder_context->brc.gop_size != gop_size) {
 529         encoder_context->brc.gop_size = gop_size;
 530         encoder_context->brc.need_reset = 1;
 531     }
 532
 533     *seq_bits_per_second = seq_param->bits_per_second;
 534
 535     return VA_STATUS_SUCCESS;
 536 }
 537
 538 static VAStatus
 539 intel_encoder_check_brc_sequence_parameter(VADriverContextP ctx,
 540                                            struct encode_state *encode_state,
 541                                            struct intel_encoder_context *encoder_context,
 542                                            unsigned int *seq_bits_per_second)
 543 {
 544     *seq_bits_per_second = 0;
 545
 546     switch (encoder_context->codec) {
 547     case CODEC_H264:
 548     case CODEC_H264_MVC:
 549         return intel_encoder_check_brc_h264_sequence_parameter(ctx, encode_state, encoder_context, seq_bits_per_second);
 550
 551     case CODEC_VP8:
 552         return intel_encoder_check_brc_vp8_sequence_parameter(ctx, encode_state, encoder_context, seq_bits_per_second);
 553
 554     case CODEC_HEVC:
 555         return intel_encoder_check_brc_hevc_sequence_parameter(ctx, encode_state, encoder_context, seq_bits_per_second);
 556
 557     case CODEC_VP9:
 558         return intel_encoder_check_brc_vp9_sequence_parameter(ctx, encode_state, encoder_context, seq_bits_per_second);
 559
 560     default:
 561         // TODO: other codecs
 562         return VA_STATUS_SUCCESS;
 563     }
 564 }
 565
 566 static void
 567 intel_encoder_check_rate_control_parameter(VADriverContextP ctx,
 568                                            struct intel_encoder_context *encoder_context,
 569                                            VAEncMiscParameterRateControl *misc,
 570                                            int *hl_bitrate_updated)
 571 {
 572     int temporal_id = 0;
 573
 574     if (encoder_context->layer.num_layers >= 2)
 575         temporal_id = misc->rc_flags.bits.temporal_id;
 576
 577     if (temporal_id >= encoder_context->layer.num_layers)
 578         return;
 579
 580     if (misc->rc_flags.bits.reset)
 581         encoder_context->brc.need_reset = 1;
 582
 583     if (encoder_context->brc.bits_per_second[temporal_id] != misc->bits_per_second) {
 584         encoder_context->brc.bits_per_second[temporal_id] = misc->bits_per_second;
 585         encoder_context->brc.need_reset = 1;
 586     }
 587
 588     if (encoder_context->brc.mb_rate_control[temporal_id] != misc->rc_flags.bits.mb_rate_control) {
 589         encoder_context->brc.mb_rate_control[temporal_id] = misc->rc_flags.bits.mb_rate_control;
 590         encoder_context->brc.need_reset = 1;
 591     }
 592
 593     if (encoder_context->brc.target_percentage[temporal_id] != misc->target_percentage) {
 594         encoder_context->brc.target_percentage[temporal_id] = misc->target_percentage;
 595         encoder_context->brc.need_reset = 1;
 596     }
 597
 598     if (encoder_context->brc.window_size != misc->window_size ||
 599         encoder_context->brc.initial_qp  != misc->initial_qp ||
 600         encoder_context->brc.min_qp      != misc->min_qp) {
 601         encoder_context->brc.window_size = misc->window_size;
 602         encoder_context->brc.initial_qp  = misc->initial_qp;
 603         encoder_context->brc.min_qp      = misc->min_qp;
 604         encoder_context->brc.need_reset = 1;
 605     }
 606
 607     if (temporal_id == encoder_context->layer.num_layers - 1)
 608         *hl_bitrate_updated = 1;
 609 }
 610
 611 static void
 612 intel_encoder_check_hrd_parameter(VADriverContextP ctx,
 613                                   struct intel_encoder_context *encoder_context,
 614                                   VAEncMiscParameterHRD *misc)
 615 {
 616     if (encoder_context->brc.hrd_buffer_size != misc->buffer_size ||
 617         encoder_context->brc.hrd_initial_buffer_fullness != misc->initial_buffer_fullness) {
 618         encoder_context->brc.hrd_buffer_size = misc->buffer_size;
 619         encoder_context->brc.hrd_initial_buffer_fullness = misc->initial_buffer_fullness;
 620         encoder_context->brc.need_reset = 1;
 621     }
 622 }
 623
 624 static void
 625 intel_encoder_check_framerate_parameter(VADriverContextP ctx,
 626                                         struct intel_encoder_context *encoder_context,
 627                                         VAEncMiscParameterFrameRate *misc)
 628 {
 629     struct intel_fraction framerate;
 630     int temporal_id = 0;
 631
 632     if (encoder_context->layer.num_layers >= 2)
 633         temporal_id = misc->framerate_flags.bits.temporal_id;
 634
 635     if (temporal_id >= encoder_context->layer.num_layers)
 636         return;
 637
 638     if (misc->framerate & 0xffff0000)
 639         framerate = (struct intel_fraction) {
 640         misc->framerate & 0xffff, misc->framerate >> 16 & 0xffff
 641     };
 642     else
 643         framerate = (struct intel_fraction) {
 644         misc->framerate, 1
 645     };
 646     framerate = reduce_fraction(framerate);
 647
 648     if (encoder_context->brc.framerate[temporal_id].num != framerate.num ||
 649         encoder_context->brc.framerate[temporal_id].den != framerate.den) {
 650         encoder_context->brc.framerate[temporal_id] = framerate;
 651         encoder_context->brc.need_reset = 1;
 652     }
 653 }
 654
 655 static void
 656 intel_encoder_check_roi_parameter(VADriverContextP ctx,
 657                                   struct intel_encoder_context *encoder_context,
 658                                   VAEncMiscParameterBufferROI *misc)
 659 {
 660     int i = 0;
 661
 662     encoder_context->brc.num_roi = MIN(misc->num_roi, I965_MAX_NUM_ROI_REGIONS);
 663     encoder_context->brc.roi_max_delta_qp = misc->max_delta_qp;
 664     encoder_context->brc.roi_min_delta_qp = misc->min_delta_qp;
 665     encoder_context->brc.roi_value_is_qp_delta = 0;
 666
 667     if (encoder_context->rate_control_mode != VA_RC_CQP)
 668         encoder_context->brc.roi_value_is_qp_delta = misc->roi_flags.bits.roi_value_is_qp_delta;
 669
 670     for (i = 0; i <  encoder_context->brc.num_roi; i++) {
 671         encoder_context->brc.roi[i].left = misc->roi->roi_rectangle.x;
 672         encoder_context->brc.roi[i].right = encoder_context->brc.roi[i].left + misc->roi->roi_rectangle.width;
 673         encoder_context->brc.roi[i].top = misc->roi->roi_rectangle.y;
 674         encoder_context->brc.roi[i].bottom = encoder_context->brc.roi[i].top + misc->roi->roi_rectangle.height;
 675         encoder_context->brc.roi[i].value = misc->roi->roi_value;
 676     }
 677 }
 678
 679 static VAStatus
 680 intel_encoder_check_brc_parameter(VADriverContextP ctx,
 681                                   struct encode_state *encode_state,
 682                                   struct intel_encoder_context *encoder_context)
 683 {
 684     VAStatus ret;
 685     VAEncMiscParameterBuffer *misc_param;
 686     int i, j;
 687     int hl_bitrate_updated = 0; // Indicate whether the bitrate for the highest level is changed in misc parameters
 688     unsigned int seq_bits_per_second = 0;
 689
 690     if (!(encoder_context->rate_control_mode & (VA_RC_CBR | VA_RC_VBR)))
 691         return VA_STATUS_SUCCESS;
 692
 693     ret = intel_encoder_check_brc_sequence_parameter(ctx, encode_state, encoder_context, &seq_bits_per_second);
 694
 695     if (ret)
 696         return ret;
 697
 698     for (i = 0; i < ARRAY_ELEMS(encode_state->misc_param); i++) {
 699         for (j = 0; j < ARRAY_ELEMS(encode_state->misc_param[0]); j++) {
 700             if (!encode_state->misc_param[i][j] || !encode_state->misc_param[i][j]->buffer)
 701                 continue;
 702
 703             misc_param = (VAEncMiscParameterBuffer *)encode_state->misc_param[i][j]->buffer;
 704
 705             switch (misc_param->type) {
 706             case VAEncMiscParameterTypeFrameRate:
 707                 intel_encoder_check_framerate_parameter(ctx,
 708                                                         encoder_context,
 709                                                         (VAEncMiscParameterFrameRate *)misc_param->data);
 710                 break;
 711
 712             case VAEncMiscParameterTypeRateControl:
 713                 intel_encoder_check_rate_control_parameter(ctx,
 714                                                            encoder_context,
 715                                                            (VAEncMiscParameterRateControl *)misc_param->data,
 716                                                            &hl_bitrate_updated);
 717                 break;
 718
 719             case VAEncMiscParameterTypeHRD:
 720                 intel_encoder_check_hrd_parameter(ctx,
 721                                                   encoder_context,
 722                                                   (VAEncMiscParameterHRD *)misc_param->data);
 723                 break;
 724
 725             case VAEncMiscParameterTypeROI:
 726                 intel_encoder_check_roi_parameter(ctx,
 727                                                   encoder_context,
 728                                                   (VAEncMiscParameterBufferROI *)misc_param->data);
 729                 break;
 730
 731             default:
 732                 break;
 733             }
 734         }
 735     }
 736
 737     if (!hl_bitrate_updated && seq_bits_per_second &&
 738         encoder_context->brc.bits_per_second[encoder_context->layer.num_layers - 1] != seq_bits_per_second) {
 739
 740         encoder_context->brc.bits_per_second[encoder_context->layer.num_layers - 1] = seq_bits_per_second;
 741         encoder_context->brc.need_reset = 1;
 742
 743     }
 744
 745     return VA_STATUS_SUCCESS;
 746 }
 747
 748 static VAStatus
 749 intel_encoder_check_temporal_layer_structure(VADriverContextP ctx,
 750                                              struct encode_state *encode_state,
 751                                              struct intel_encoder_context *encoder_context)
 752 {
 753     VAEncMiscParameterBuffer* misc_param;
 754     VAEncMiscParameterTemporalLayerStructure *tls_paramter;
 755     unsigned int rate_control_mode = encoder_context->rate_control_mode;
 756     int i;
 757
 758     if (!encoder_context->is_new_sequence) {
 759         if (encoder_context->layer.num_layers > 1)
 760             encoder_context->layer.curr_frame_layer_id = encoder_context->layer.frame_layer_ids[(encoder_context->num_frames_in_sequence - 1) % encoder_context->layer.size_frame_layer_ids];
 761         else
 762             encoder_context->layer.curr_frame_layer_id = 0;
 763
 764         return VA_STATUS_SUCCESS;
 765     }
 766
 767     if (!(rate_control_mode & (VA_RC_CBR | VA_RC_VBR)))
 768         return VA_STATUS_SUCCESS;
 769
 770     if (!encode_state->misc_param[VAEncMiscParameterTypeTemporalLayerStructure][0] ||
 771         !encode_state->misc_param[VAEncMiscParameterTypeTemporalLayerStructure][0]->buffer)
 772         return VA_STATUS_SUCCESS;
 773
 774     misc_param = (VAEncMiscParameterBuffer*)encode_state->misc_param[VAEncMiscParameterTypeTemporalLayerStructure][0]->buffer;
 775     tls_paramter = (VAEncMiscParameterTemporalLayerStructure *)misc_param->data;
 776
 777     if (tls_paramter->number_of_layers <= 1)
 778         return VA_STATUS_SUCCESS;
 779
 780     if (tls_paramter->number_of_layers > MAX_TEMPORAL_LAYERS)
 781         return VA_STATUS_ERROR_INVALID_PARAMETER;
 782
 783     if (tls_paramter->periodicity > 32 || tls_paramter->periodicity <= 1)
 784         return VA_STATUS_ERROR_INVALID_PARAMETER;
 785
 786     for (i = 0; i < tls_paramter->number_of_layers; i++) {
 787         if (!encode_state->misc_param[VAEncMiscParameterTypeRateControl][i] ||
 788             !encode_state->misc_param[VAEncMiscParameterTypeRateControl][i]->buffer ||
 789             !encode_state->misc_param[VAEncMiscParameterTypeFrameRate][i] ||
 790             !encode_state->misc_param[VAEncMiscParameterTypeFrameRate][i]->buffer) {
 791
 792             return VA_STATUS_ERROR_INVALID_PARAMETER;
 793         }
 794     }
 795
 796     encoder_context->layer.size_frame_layer_ids = tls_paramter->periodicity;
 797     encoder_context->layer.num_layers = tls_paramter->number_of_layers;
 798
 799     for (i = 0; i < encoder_context->layer.size_frame_layer_ids; i++) {
 800         if (tls_paramter->layer_id[i] >= tls_paramter->number_of_layers)
 801             return VA_STATUS_ERROR_INVALID_PARAMETER;
 802
 803         encoder_context->layer.frame_layer_ids[i] = tls_paramter->layer_id[i];
 804     }
 805
 806     if (encoder_context->is_new_sequence)
 807         encoder_context->layer.curr_frame_layer_id = 0;
 808     else
 809         encoder_context->layer.curr_frame_layer_id = encoder_context->layer.frame_layer_ids[(encoder_context->num_frames_in_sequence - 1) % encoder_context->layer.size_frame_layer_ids];
 810
 811     return VA_STATUS_SUCCESS;
 812 }
 813
 814 static VAStatus
 815 intel_encoder_check_misc_parameter(VADriverContextP ctx,
 816                                    struct encode_state *encode_state,
 817                                    struct intel_encoder_context *encoder_context)
 818 {
 819     VAStatus ret = VA_STATUS_SUCCESS;
 820
 821     if (encode_state->misc_param[VAEncMiscParameterTypeQualityLevel][0] &&
 822         encode_state->misc_param[VAEncMiscParameterTypeQualityLevel][0]->buffer) {
 823         VAEncMiscParameterBuffer* pMiscParam = (VAEncMiscParameterBuffer*)encode_state->misc_param[VAEncMiscParameterTypeQualityLevel][0]->buffer;
 824         VAEncMiscParameterBufferQualityLevel* param_quality_level = (VAEncMiscParameterBufferQualityLevel*)pMiscParam->data;
 825         encoder_context->quality_level = param_quality_level->quality_level;
 826
 827         if (encoder_context->quality_level == 0)
 828             encoder_context->quality_level = ENCODER_DEFAULT_QUALITY;
 829         else if (encoder_context->quality_level > encoder_context->quality_range) {
 830             ret = VA_STATUS_ERROR_INVALID_PARAMETER;
 831             goto out;
 832         }
 833     }
 834
 835     ret = intel_encoder_check_temporal_layer_structure(ctx, encode_state, encoder_context);
 836
 837     if (ret)
 838         goto out;
 839
 840     ret = intel_encoder_check_brc_parameter(ctx, encode_state, encoder_context);
 841
 842 out:
 843     return ret;
 844 }
 845
 846 static VAStatus
 847 intel_encoder_check_avc_parameter(VADriverContextP ctx,
 848                                   struct encode_state *encode_state,
 849                                   struct intel_encoder_context *encoder_context)
 850 {
 851     struct i965_driver_data *i965 = i965_driver_data(ctx);
 852     struct object_surface *obj_surface;
 853     struct object_buffer *obj_buffer;
 854     VAEncPictureParameterBufferH264 *pic_param = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
 855     VAEncSequenceParameterBufferH264 *seq_param = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
 856     int i;
 857
 858     assert(!(pic_param->CurrPic.flags & VA_PICTURE_H264_INVALID));
 859
 860     if (pic_param->CurrPic.flags & VA_PICTURE_H264_INVALID)
 861         goto error;
 862
 863     obj_surface = SURFACE(pic_param->CurrPic.picture_id);
 864     assert(obj_surface); /* It is possible the store buffer isn't allocated yet */
 865
 866     if (!obj_surface)
 867         goto error;
 868
 869     encode_state->reconstructed_object = obj_surface;
 870     obj_buffer = BUFFER(pic_param->coded_buf);
 871     assert(obj_buffer && obj_buffer->buffer_store && obj_buffer->buffer_store->bo);
 872
 873     if (!obj_buffer || !obj_buffer->buffer_store || !obj_buffer->buffer_store->bo)
 874         goto error;
 875
 876     if (encode_state->num_slice_params_ext > encoder_context->max_slice_or_seg_num)
 877         goto error;
 878
 879     encode_state->coded_buf_object = obj_buffer;
 880
 881     for (i = 0; i < 16; i++) {
 882         if (pic_param->ReferenceFrames[i].flags & VA_PICTURE_H264_INVALID ||
 883             pic_param->ReferenceFrames[i].picture_id == VA_INVALID_SURFACE)
 884             break;
 885         else {
 886             obj_surface = SURFACE(pic_param->ReferenceFrames[i].picture_id);
 887             assert(obj_surface);
 888
 889             if (!obj_surface)
 890                 goto error;
 891
 892             if (obj_surface->bo)
 893                 encode_state->reference_objects[i] = obj_surface;
 894             else
 895                 encode_state->reference_objects[i] = NULL; /* FIXME: Warning or Error ??? */
 896         }
 897     }
 898
 899     for (; i < 16; i++)
 900         encode_state->reference_objects[i] = NULL;
 901
 902     /*
 903      * A sequence consists of an IDR unit, followed by zero or more non-IDR unit, but not including any
 904      * subsequent IDR unit, so idr_pic_flag can indicate the current frame is the start of a new
 905      * sequnce
 906      */
 907     encoder_context->is_new_sequence = (pic_param->pic_fields.bits.idr_pic_flag && seq_param);
 908
 909     if (encoder_context->is_new_sequence) {
 910         encoder_context->num_frames_in_sequence = 0;
 911         encoder_context->frame_width_in_pixel = seq_param->picture_width_in_mbs * 16;
 912         encoder_context->frame_height_in_pixel = seq_param->picture_height_in_mbs * 16;
 913     }
 914
 915     return VA_STATUS_SUCCESS;
 916
 917 error:
 918     return VA_STATUS_ERROR_INVALID_PARAMETER;
 919 }
 920
 921 static VAStatus
 922 intel_encoder_check_mpeg2_parameter(VADriverContextP ctx,
 923                                     struct encode_state *encode_state,
 924                                     struct intel_encoder_context *encoder_context)
 925 {
 926     struct i965_driver_data *i965 = i965_driver_data(ctx);
 927     VAEncPictureParameterBufferMPEG2 *pic_param = (VAEncPictureParameterBufferMPEG2 *)encode_state->pic_param_ext->buffer;
 928     struct object_surface *obj_surface;
 929     struct object_buffer *obj_buffer;
 930     int i = 0;
 931
 932     obj_surface = SURFACE(pic_param->reconstructed_picture);
 933     assert(obj_surface); /* It is possible the store buffer isn't allocated yet */
 934
 935     if (!obj_surface)
 936         goto error;
 937
 938     encode_state->reconstructed_object = obj_surface;
 939     obj_buffer = BUFFER(pic_param->coded_buf);
 940     assert(obj_buffer && obj_buffer->buffer_store && obj_buffer->buffer_store->bo);
 941
 942     if (!obj_buffer || !obj_buffer->buffer_store || !obj_buffer->buffer_store->bo)
 943         goto error;
 944
 945     encode_state->coded_buf_object = obj_buffer;
 946
 947     if (pic_param->picture_type == VAEncPictureTypeIntra) {
 948     } else if (pic_param->picture_type == VAEncPictureTypePredictive) {
 949         assert(pic_param->forward_reference_picture != VA_INVALID_SURFACE);
 950         obj_surface = SURFACE(pic_param->forward_reference_picture);
 951         assert(obj_surface && obj_surface->bo);
 952
 953         if (!obj_surface || !obj_surface->bo)
 954             goto error;
 955
 956         encode_state->reference_objects[i++] = obj_surface;
 957     } else if (pic_param->picture_type == VAEncPictureTypeBidirectional) {
 958         assert(pic_param->forward_reference_picture != VA_INVALID_SURFACE);
 959         obj_surface = SURFACE(pic_param->forward_reference_picture);
 960         assert(obj_surface && obj_surface->bo);
 961
 962         if (!obj_surface || !obj_surface->bo)
 963             goto error;
 964
 965         encode_state->reference_objects[i++] = obj_surface;
 966
 967         assert(pic_param->backward_reference_picture != VA_INVALID_SURFACE);
 968         obj_surface = SURFACE(pic_param->backward_reference_picture);
 969         assert(obj_surface && obj_surface->bo);
 970
 971         if (!obj_surface || !obj_surface->bo)
 972             goto error;
 973
 974         encode_state->reference_objects[i++] = obj_surface;
 975     } else
 976         goto error;
 977
 978     for (; i < 16; i++)
 979         encode_state->reference_objects[i] = NULL;
 980
 981     return VA_STATUS_SUCCESS;
 982
 983 error:
 984     return VA_STATUS_ERROR_INVALID_PARAMETER;
 985 }
 986
 987 static VAStatus
 988 intel_encoder_check_jpeg_parameter(VADriverContextP ctx,
 989                                    struct encode_state *encode_state,
 990                                    struct intel_encoder_context *encoder_context)
 991 {
 992     struct i965_driver_data *i965 = i965_driver_data(ctx);
 993     struct object_buffer *obj_buffer;
 994     VAEncPictureParameterBufferJPEG *pic_param = (VAEncPictureParameterBufferJPEG *)encode_state->pic_param_ext->buffer;
 995
 996
 997     assert(!(pic_param->pic_flags.bits.profile)); //Baseline profile is 0.
 998
 999     obj_buffer = BUFFER(pic_param->coded_buf);
1000     assert(obj_buffer && obj_buffer->buffer_store && obj_buffer->buffer_store->bo);
1001
1002     if (!obj_buffer || !obj_buffer->buffer_store || !obj_buffer->buffer_store->bo)
1003         goto error;
1004
1005     encode_state->coded_buf_object = obj_buffer;
1006
1007     return VA_STATUS_SUCCESS;
1008
1009 error:
1010     return VA_STATUS_ERROR_INVALID_PARAMETER;
1011 }
1012
1013 static VAStatus
1014 intel_encoder_check_vp8_parameter(VADriverContextP ctx,
1015                                   struct encode_state *encode_state,
1016                                   struct intel_encoder_context *encoder_context)
1017 {
1018     struct i965_driver_data *i965 = i965_driver_data(ctx);
1019     VAEncPictureParameterBufferVP8 *pic_param = (VAEncPictureParameterBufferVP8 *)encode_state->pic_param_ext->buffer;
1020     VAEncSequenceParameterBufferVP8 *seq_param = (VAEncSequenceParameterBufferVP8 *)encode_state->seq_param_ext->buffer;
1021     struct object_surface *obj_surface;
1022     struct object_buffer *obj_buffer;
1023     int i = 0;
1024     int is_key_frame = !pic_param->pic_flags.bits.frame_type;
1025
1026     obj_surface = SURFACE(pic_param->reconstructed_frame);
1027     assert(obj_surface); /* It is possible the store buffer isn't allocated yet */
1028
1029     if (!obj_surface)
1030         goto error;
1031
1032     encode_state->reconstructed_object = obj_surface;
1033     obj_buffer = BUFFER(pic_param->coded_buf);
1034     assert(obj_buffer && obj_buffer->buffer_store && obj_buffer->buffer_store->bo);
1035
1036     if (!obj_buffer || !obj_buffer->buffer_store || !obj_buffer->buffer_store->bo)
1037         goto error;
1038
1039     encode_state->coded_buf_object = obj_buffer;
1040
1041     if (!is_key_frame) {
1042         assert(pic_param->ref_last_frame != VA_INVALID_SURFACE);
1043         obj_surface = SURFACE(pic_param->ref_last_frame);
1044         assert(obj_surface && obj_surface->bo);
1045
1046         if (!obj_surface || !obj_surface->bo)
1047             goto error;
1048
1049         encode_state->reference_objects[i++] = obj_surface;
1050
1051         assert(pic_param->ref_gf_frame != VA_INVALID_SURFACE);
1052         obj_surface = SURFACE(pic_param->ref_gf_frame);
1053         assert(obj_surface && obj_surface->bo);
1054
1055         if (!obj_surface || !obj_surface->bo)
1056             goto error;
1057
1058         encode_state->reference_objects[i++] = obj_surface;
1059
1060         assert(pic_param->ref_arf_frame != VA_INVALID_SURFACE);
1061         obj_surface = SURFACE(pic_param->ref_arf_frame);
1062         assert(obj_surface && obj_surface->bo);
1063
1064         if (!obj_surface || !obj_surface->bo)
1065             goto error;
1066
1067         encode_state->reference_objects[i++] = obj_surface;
1068     }
1069
1070     for (; i < 16; i++)
1071         encode_state->reference_objects[i] = NULL;
1072
1073     encoder_context->is_new_sequence = (is_key_frame && seq_param);
1074
1075     if (encoder_context->is_new_sequence) {
1076         encoder_context->num_frames_in_sequence = 0;
1077         encoder_context->frame_width_in_pixel = seq_param->frame_width;
1078         encoder_context->frame_height_in_pixel = seq_param->frame_height;
1079     }
1080
1081     return VA_STATUS_SUCCESS;
1082
1083 error:
1084     return VA_STATUS_ERROR_INVALID_PARAMETER;
1085 }
1086
1087 static VAStatus
1088 intel_encoder_check_hevc_parameter(VADriverContextP ctx,
1089                                    struct encode_state *encode_state,
1090                                    struct intel_encoder_context *encoder_context)
1091 {
1092     struct i965_driver_data *i965 = i965_driver_data(ctx);
1093     struct object_surface *obj_surface;
1094     struct object_buffer *obj_buffer;
1095     VAEncPictureParameterBufferHEVC *pic_param = (VAEncPictureParameterBufferHEVC *)encode_state->pic_param_ext->buffer;
1096     VAEncSliceParameterBufferHEVC *slice_param;
1097     VAEncSequenceParameterBufferHEVC *seq_param;
1098     int i;
1099
1100     seq_param = NULL;
1101
1102     if (encode_state->seq_param_ext &&
1103         encode_state->seq_param_ext->buffer)
1104         seq_param = (VAEncSequenceParameterBufferHEVC *)(encode_state->seq_param_ext->buffer);
1105
1106     assert(!(pic_param->decoded_curr_pic.flags & VA_PICTURE_HEVC_INVALID));
1107
1108     if (pic_param->decoded_curr_pic.flags & VA_PICTURE_HEVC_INVALID)
1109         goto error;
1110
1111     obj_surface = SURFACE(pic_param->decoded_curr_pic.picture_id);
1112     assert(obj_surface); /* It is possible the store buffer isn't allocated yet */
1113
1114     if (!obj_surface)
1115         goto error;
1116
1117     encode_state->reconstructed_object = obj_surface;
1118     obj_buffer = BUFFER(pic_param->coded_buf);
1119     assert(obj_buffer && obj_buffer->buffer_store && obj_buffer->buffer_store->bo);
1120
1121     if (!obj_buffer || !obj_buffer->buffer_store || !obj_buffer->buffer_store->bo)
1122         goto error;
1123
1124     if (encode_state->num_slice_params_ext > encoder_context->max_slice_or_seg_num)
1125         goto error;
1126
1127     encode_state->coded_buf_object = obj_buffer;
1128
1129     for (i = 0; i < 15; i++) {
1130         if (pic_param->reference_frames[i].flags & VA_PICTURE_HEVC_INVALID ||
1131             pic_param->reference_frames[i].picture_id == VA_INVALID_SURFACE)
1132             break;
1133         else {
1134             obj_surface = SURFACE(pic_param->reference_frames[i].picture_id);
1135             assert(obj_surface);
1136
1137             if (!obj_surface)
1138                 goto error;
1139
1140             if (obj_surface->bo)
1141                 encode_state->reference_objects[i] = obj_surface;
1142             else
1143                 encode_state->reference_objects[i] = NULL; /* FIXME: Warning or Error ??? */
1144         }
1145     }
1146
1147     for (; i < 15; i++)
1148         encode_state->reference_objects[i] = NULL;
1149
1150     for (i = 0; i < encode_state->num_slice_params_ext; i++) {
1151         slice_param = (VAEncSliceParameterBufferHEVC *)encode_state->slice_params_ext[i]->buffer;
1152
1153         if (slice_param->slice_type != HEVC_SLICE_I &&
1154             slice_param->slice_type != HEVC_SLICE_P &&
1155             slice_param->slice_type != HEVC_SLICE_B)
1156             goto error;
1157
1158         /* TODO: add more check here */
1159     }
1160
1161     encoder_context->is_new_sequence = (pic_param->pic_fields.bits.idr_pic_flag && seq_param);
1162
1163     return VA_STATUS_SUCCESS;
1164
1165 error:
1166     return VA_STATUS_ERROR_INVALID_PARAMETER;
1167 }
1168
1169 static VAStatus
1170 intel_encoder_check_vp9_parameter(VADriverContextP ctx,
1171                                   struct encode_state *encode_state,
1172                                   struct intel_encoder_context *encoder_context)
1173 {
1174     struct i965_driver_data *i965 = i965_driver_data(ctx);
1175     VAEncPictureParameterBufferVP9 *pic_param;
1176     VAEncSequenceParameterBufferVP9 *seq_param;
1177     struct object_surface *obj_surface;
1178     struct object_buffer *obj_buffer;
1179     int i = 0;
1180     int is_key_frame = 0;
1181     int index;
1182
1183     if (encode_state->pic_param_ext == NULL ||
1184         encode_state->pic_param_ext->buffer == NULL)
1185         return VA_STATUS_ERROR_INVALID_PARAMETER;
1186
1187     seq_param = NULL;
1188     if (encode_state->seq_param_ext &&
1189         encode_state->seq_param_ext->buffer)
1190         seq_param = (VAEncSequenceParameterBufferVP9 *)(encode_state->seq_param_ext->buffer);
1191
1192     pic_param = (VAEncPictureParameterBufferVP9 *)encode_state->pic_param_ext->buffer;
1193
1194     obj_surface = SURFACE(pic_param->reconstructed_frame);
1195
1196     if (!obj_surface)
1197         goto error;
1198
1199     encode_state->reconstructed_object = obj_surface;
1200     obj_buffer = BUFFER(pic_param->coded_buf);
1201
1202     if (!obj_buffer || !obj_buffer->buffer_store || !obj_buffer->buffer_store->bo)
1203         goto error;
1204
1205     encode_state->coded_buf_object = obj_buffer;
1206
1207     is_key_frame = !pic_param->pic_flags.bits.frame_type;
1208     if (!is_key_frame && !pic_param->pic_flags.bits.intra_only) {
1209         /* slot 0 is for last reference frame */
1210         index = pic_param->ref_flags.bits.ref_last_idx;
1211         obj_surface = SURFACE(pic_param->reference_frames[index]);
1212         if (obj_surface && obj_surface->bo)
1213             encode_state->reference_objects[i++] = obj_surface;
1214         else
1215             encode_state->reference_objects[i++] = NULL;
1216
1217         /* slot 1 is for golden reference frame */
1218         index = pic_param->ref_flags.bits.ref_gf_idx;
1219         obj_surface = SURFACE(pic_param->reference_frames[index]);
1220         if (obj_surface && obj_surface->bo)
1221             encode_state->reference_objects[i++] = obj_surface;
1222         else
1223             encode_state->reference_objects[i++] = NULL;
1224
1225         /* slot 2 is alt reference frame */
1226         index = pic_param->ref_flags.bits.ref_arf_idx;
1227         obj_surface = SURFACE(pic_param->reference_frames[index]);
1228         if (obj_surface && obj_surface->bo)
1229             encode_state->reference_objects[i++] = obj_surface;
1230         else
1231             encode_state->reference_objects[i++] = NULL;
1232     }
1233
1234     for (; i < 16; i++)
1235         encode_state->reference_objects[i] = NULL;
1236
1237     encoder_context->is_new_sequence = (is_key_frame && seq_param);
1238
1239     return VA_STATUS_SUCCESS;
1240
1241 error:
1242     return VA_STATUS_ERROR_INVALID_PARAMETER;
1243 }
1244
1245
1246 static VAStatus
1247 intel_encoder_sanity_check_input(VADriverContextP ctx,
1248                                  VAProfile profile,
1249                                  struct encode_state *encode_state,
1250                                  struct intel_encoder_context *encoder_context)
1251 {
1252     VAStatus vaStatus;
1253
1254     switch (profile) {
1255     case VAProfileH264ConstrainedBaseline:
1256     case VAProfileH264Main:
1257     case VAProfileH264High:
1258     case VAProfileH264MultiviewHigh:
1259     case VAProfileH264StereoHigh: {
1260         vaStatus = intel_encoder_check_avc_parameter(ctx, encode_state, encoder_context);
1261         if (vaStatus != VA_STATUS_SUCCESS)
1262             goto out;
1263         vaStatus = intel_encoder_check_yuv_surface(ctx, profile, encode_state, encoder_context);
1264         break;
1265     }
1266
1267     case VAProfileMPEG2Simple:
1268     case VAProfileMPEG2Main: {
1269         vaStatus = intel_encoder_check_mpeg2_parameter(ctx, encode_state, encoder_context);
1270         if (vaStatus != VA_STATUS_SUCCESS)
1271             goto out;
1272         vaStatus = intel_encoder_check_yuv_surface(ctx, profile, encode_state, encoder_context);
1273         break;
1274     }
1275
1276     case VAProfileJPEGBaseline:  {
1277         vaStatus = intel_encoder_check_jpeg_parameter(ctx, encode_state, encoder_context);
1278         if (vaStatus != VA_STATUS_SUCCESS)
1279             goto out;
1280         vaStatus = intel_encoder_check_jpeg_yuv_surface(ctx, profile, encode_state, encoder_context);
1281         break;
1282     }
1283
1284     case VAProfileVP8Version0_3: {
1285         vaStatus = intel_encoder_check_vp8_parameter(ctx, encode_state, encoder_context);
1286         if (vaStatus != VA_STATUS_SUCCESS)
1287             goto out;
1288         vaStatus = intel_encoder_check_yuv_surface(ctx, profile, encode_state, encoder_context);
1289         break;
1290     }
1291
1292     case VAProfileHEVCMain:
1293     case VAProfileHEVCMain10:  {
1294         vaStatus = intel_encoder_check_hevc_parameter(ctx, encode_state, encoder_context);
1295         if (vaStatus != VA_STATUS_SUCCESS)
1296             goto out;
1297         vaStatus = intel_encoder_check_yuv_surface(ctx, profile, encode_state, encoder_context);
1298         break;
1299     }
1300
1301     case VAProfileVP9Profile0: {
1302         vaStatus = intel_encoder_check_vp9_parameter(ctx, encode_state, encoder_context);
1303         if (vaStatus != VA_STATUS_SUCCESS)
1304             goto out;
1305         vaStatus = intel_encoder_check_yuv_surface(ctx, profile, encode_state, encoder_context);
1306         break;
1307     }
1308     default:
1309         vaStatus = VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
1310         break;
1311     }
1312
1313     if (vaStatus == VA_STATUS_SUCCESS)
1314         vaStatus = intel_encoder_check_misc_parameter(ctx, encode_state, encoder_context);
1315
1316 out:
1317     return vaStatus;
1318 }
1319
1320 static VAStatus
1321 intel_encoder_end_picture(VADriverContextP ctx,
1322                           VAProfile profile,
1323                           union codec_state *codec_state,
1324                           struct hw_context *hw_context)
1325 {
1326     struct intel_encoder_context *encoder_context = (struct intel_encoder_context *)hw_context;
1327     struct encode_state *encode_state = &codec_state->encode;
1328     VAStatus vaStatus;
1329
1330     vaStatus = intel_encoder_sanity_check_input(ctx, profile, encode_state, encoder_context);
1331
1332     if (vaStatus != VA_STATUS_SUCCESS)
1333         return vaStatus;
1334
1335     encoder_context->mfc_brc_prepare(encode_state, encoder_context);
1336
1337     if ((encoder_context->vme_context && encoder_context->vme_pipeline)) {
1338         vaStatus = encoder_context->vme_pipeline(ctx, profile, encode_state, encoder_context);
1339         if (vaStatus != VA_STATUS_SUCCESS)
1340             return vaStatus;
1341     }
1342
1343     encoder_context->mfc_pipeline(ctx, profile, encode_state, encoder_context);
1344     encoder_context->num_frames_in_sequence++;
1345     encoder_context->brc.need_reset = 0;
1346     /*
1347      * ROI is only available for the current frame, see the comment
1348      * for VAEncROI in va.h
1349      */
1350     encoder_context->brc.num_roi = 0;
1351
1352     return VA_STATUS_SUCCESS;
1353 }
1354
1355 static void
1356 intel_encoder_context_destroy(void *hw_context)
1357 {
1358     struct intel_encoder_context *encoder_context = (struct intel_encoder_context *)hw_context;
1359
1360     encoder_context->mfc_context_destroy(encoder_context->mfc_context);
1361
1362     if (encoder_context->vme_context_destroy && encoder_context->vme_context)
1363         encoder_context->vme_context_destroy(encoder_context->vme_context);
1364
1365     if (encoder_context->enc_priv_state) {
1366         free(encoder_context->enc_priv_state);
1367         encoder_context->enc_priv_state = NULL;
1368     }
1369
1370     intel_batchbuffer_free(encoder_context->base.batch);
1371     free(encoder_context);
1372 }
1373
1374
1375 static VAStatus
1376 intel_encoder_get_status(VADriverContextP ctx, struct hw_context *hw_context, void *buffer)
1377 {
1378     struct intel_encoder_context *encoder_context = (struct intel_encoder_context *)hw_context;
1379     struct i965_coded_buffer_segment *coded_buffer_segment = (struct i965_coded_buffer_segment *)buffer;
1380
1381     if (encoder_context->get_status)
1382         return encoder_context->get_status(ctx, encoder_context, coded_buffer_segment);
1383
1384     return VA_STATUS_ERROR_UNIMPLEMENTED;
1385 }
1386
1387 typedef Bool(* hw_init_func)(VADriverContextP, struct intel_encoder_context *);
1388
1389 static struct hw_context *
1390 intel_enc_hw_context_init(VADriverContextP ctx,
1391                           struct object_config *obj_config,
1392                           hw_init_func vme_context_init,
1393                           hw_init_func mfc_context_init)
1394 {
1395     struct i965_driver_data *i965 = i965_driver_data(ctx);
1396     struct intel_driver_data *intel = intel_driver_data(ctx);
1397     struct intel_encoder_context *encoder_context = calloc(1, sizeof(struct intel_encoder_context));
1398     int i;
1399
1400     assert(encoder_context);
1401     encoder_context->base.destroy = intel_encoder_context_destroy;
1402     encoder_context->base.run = intel_encoder_end_picture;
1403     encoder_context->base.get_status = intel_encoder_get_status;
1404     encoder_context->base.batch = intel_batchbuffer_new(intel, I915_EXEC_RENDER, 0);
1405     encoder_context->input_yuv_surface = VA_INVALID_SURFACE;
1406     encoder_context->is_tmp_id = 0;
1407     encoder_context->low_power_mode = 0;
1408     encoder_context->rate_control_mode = VA_RC_NONE;
1409     encoder_context->quality_level = ENCODER_DEFAULT_QUALITY;
1410     encoder_context->quality_range = 1;
1411     encoder_context->layer.num_layers = 1;
1412     encoder_context->max_slice_or_seg_num = 1;
1413
1414     if (obj_config->entrypoint == VAEntrypointEncSliceLP)
1415         encoder_context->low_power_mode = 1;
1416
1417     switch (obj_config->profile) {
1418     case VAProfileMPEG2Simple:
1419     case VAProfileMPEG2Main:
1420         encoder_context->codec = CODEC_MPEG2;
1421         break;
1422
1423     case VAProfileH264ConstrainedBaseline:
1424     case VAProfileH264Main:
1425     case VAProfileH264High:
1426         encoder_context->codec = CODEC_H264;
1427
1428         if (obj_config->entrypoint == VAEntrypointEncSliceLP)
1429             encoder_context->quality_range = ENCODER_LP_QUALITY_RANGE;
1430         else if (IS_GEN9(i965->intel.device_info)) {
1431             encoder_context->quality_level = ENCODER_DEFAULT_QUALITY_AVC;
1432             encoder_context->quality_range = ENCODER_QUALITY_RANGE_AVC;
1433         } else
1434             encoder_context->quality_range = ENCODER_QUALITY_RANGE;
1435         break;
1436
1437     case VAProfileH264StereoHigh:
1438     case VAProfileH264MultiviewHigh:
1439         if (IS_GEN9(i965->intel.device_info)) {
1440             encoder_context->quality_level = ENCODER_DEFAULT_QUALITY_AVC;
1441             encoder_context->quality_range = ENCODER_QUALITY_RANGE_AVC;
1442         }
1443         encoder_context->codec = CODEC_H264_MVC;
1444         break;
1445
1446     case VAProfileJPEGBaseline:
1447         encoder_context->codec = CODEC_JPEG;
1448         break;
1449
1450     case VAProfileVP8Version0_3:
1451         encoder_context->codec = CODEC_VP8;
1452         encoder_context->quality_range = ENCODER_QUALITY_RANGE;
1453
1454         break;
1455
1456     case VAProfileHEVCMain:
1457     case VAProfileHEVCMain10:
1458         encoder_context->codec = CODEC_HEVC;
1459         break;
1460
1461     case VAProfileVP9Profile0:
1462         encoder_context->codec = CODEC_VP9;
1463         break;
1464
1465     default:
1466         /* Never get here */
1467         assert(0);
1468         break;
1469     }
1470
1471     for (i = 0; i < obj_config->num_attribs; i++) {
1472         if (obj_config->attrib_list[i].type == VAConfigAttribRateControl) {
1473             encoder_context->rate_control_mode = obj_config->attrib_list[i].value;
1474
1475             if (encoder_context->codec == CODEC_MPEG2 &&
1476                 encoder_context->rate_control_mode & VA_RC_CBR) {
1477                 WARN_ONCE("Don't support CBR for MPEG-2 encoding\n");
1478                 encoder_context->rate_control_mode &= ~VA_RC_CBR;
1479             }
1480         }
1481         if (obj_config->attrib_list[i].type == VAConfigAttribEncROI) {
1482             if (encoder_context->codec == CODEC_H264)
1483                 encoder_context->context_roi = 1;
1484         }
1485         if (obj_config->attrib_list[i].type == VAConfigAttribEncMaxSlices) {
1486             if (encoder_context->codec == CODEC_H264 ||
1487                 encoder_context->codec == CODEC_HEVC)
1488                 encoder_context->max_slice_or_seg_num = obj_config->attrib_list[i].value;
1489         }
1490     }
1491
1492     if (vme_context_init) {
1493         vme_context_init(ctx, encoder_context);
1494         assert(!encoder_context->vme_context ||
1495                (encoder_context->vme_context_destroy && encoder_context->vme_pipeline));
1496     }
1497
1498     mfc_context_init(ctx, encoder_context);
1499     assert(encoder_context->mfc_context);
1500     assert(encoder_context->mfc_context_destroy);
1501     assert(encoder_context->mfc_pipeline);
1502
1503     return (struct hw_context *)encoder_context;
1504 }
1505
1506 struct hw_context *
1507 gen6_enc_hw_context_init(VADriverContextP ctx, struct object_config *obj_config)
1508 {
1509     return intel_enc_hw_context_init(ctx, obj_config, gen6_vme_context_init, gen6_mfc_context_init);
1510 }
1511
1512 struct hw_context *
1513 gen7_enc_hw_context_init(VADriverContextP ctx, struct object_config *obj_config)
1514 {
1515
1516     return intel_enc_hw_context_init(ctx, obj_config, gen7_vme_context_init, gen7_mfc_context_init);
1517 }
1518
1519 struct hw_context *
1520 gen75_enc_hw_context_init(VADriverContextP ctx, struct object_config *obj_config)
1521 {
1522     return intel_enc_hw_context_init(ctx, obj_config, gen75_vme_context_init, gen75_mfc_context_init);
1523 }
1524
1525 struct hw_context *
1526 gen8_enc_hw_context_init(VADriverContextP ctx, struct object_config *obj_config)
1527 {
1528     return intel_enc_hw_context_init(ctx, obj_config, gen8_vme_context_init, gen8_mfc_context_init);
1529 }
1530
1531 struct hw_context *
1532 gen9_enc_hw_context_init(VADriverContextP ctx, struct object_config *obj_config)
1533 {
1534     return intel_enc_hw_context_init(ctx, obj_config, gen9_vme_context_init, gen9_mfc_context_init);
1535 }