src/i965_decoder_utils.c

   1 /*
   2  * Copyright (C) 2006-2012 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 "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 #include "sysdeps.h"
  25
  26 #include <alloca.h>
  27
  28 #include "intel_batchbuffer.h"
  29 #include "i965_drv_video.h"
  30 #include "i965_decoder_utils.h"
  31 #include "i965_defines.h"
  32
  33 /* Set reference surface if backing store exists */
  34 static inline int
  35 set_ref_frame(
  36     struct i965_driver_data *i965,
  37     GenFrameStore           *ref_frame,
  38     VASurfaceID              va_surface,
  39     struct object_surface   *obj_surface
  40 )
  41 {
  42     if (va_surface == VA_INVALID_ID)
  43         return 0;
  44
  45     if (!obj_surface || !obj_surface->bo)
  46         return 0;
  47
  48     ref_frame->surface_id = va_surface;
  49     ref_frame->obj_surface = obj_surface;
  50     return 1;
  51 }
  52
  53 /* Check wether codec layer incorrectly fills in slice_vertical_position */
  54 int
  55 mpeg2_wa_slice_vertical_position(
  56     struct decode_state           *decode_state,
  57     VAPictureParameterBufferMPEG2 *pic_param
  58 )
  59 {
  60     unsigned int i, j, mb_height, vpos, last_vpos = 0;
  61
  62     /* Assume progressive sequence if we got a progressive frame */
  63     if (pic_param->picture_coding_extension.bits.progressive_frame)
  64         return 0;
  65
  66     /* Wait for a field coded picture */
  67     if (pic_param->picture_coding_extension.bits.picture_structure == MPEG_FRAME)
  68         return -1;
  69
  70     assert(decode_state && decode_state->slice_params);
  71
  72     mb_height = (pic_param->vertical_size + 31) / 32;
  73
  74     for (j = 0; j < decode_state->num_slice_params; j++) {
  75         struct buffer_store * const buffer_store =
  76             decode_state->slice_params[j];
  77
  78         for (i = 0; i < buffer_store->num_elements; i++) {
  79             VASliceParameterBufferMPEG2 * const slice_param =
  80                 ((VASliceParameterBufferMPEG2 *)buffer_store->buffer) + i;
  81
  82             vpos = slice_param->slice_vertical_position;
  83             if (vpos >= mb_height || vpos == last_vpos + 2) {
  84                 WARN_ONCE("codec layer incorrectly fills in MPEG-2 slice_vertical_position. Workaround applied\n");
  85                 return 1;
  86             }
  87             last_vpos = vpos;
  88         }
  89     }
  90     return 0;
  91 }
  92
  93 /* Build MPEG-2 reference frames array */
  94 void
  95 mpeg2_set_reference_surfaces(
  96     VADriverContextP               ctx,
  97     GenFrameStore                  ref_frames[MAX_GEN_REFERENCE_FRAMES],
  98     struct decode_state           *decode_state,
  99     VAPictureParameterBufferMPEG2 *pic_param
 100 )
 101 {
 102     struct i965_driver_data * const i965 = i965_driver_data(ctx);
 103     VASurfaceID va_surface;
 104     unsigned pic_structure, is_second_field, n = 0;
 105     struct object_surface *obj_surface;
 106
 107     pic_structure = pic_param->picture_coding_extension.bits.picture_structure;
 108     is_second_field = pic_structure != MPEG_FRAME &&
 109         !pic_param->picture_coding_extension.bits.is_first_field;
 110
 111     ref_frames[0].surface_id = VA_INVALID_ID;
 112     ref_frames[0].obj_surface = NULL;
 113
 114     /* Reference frames are indexed by frame store ID  (0:top, 1:bottom) */
 115     switch (pic_param->picture_coding_type) {
 116     case MPEG_P_PICTURE:
 117         if (is_second_field && pic_structure == MPEG_BOTTOM_FIELD) {
 118             va_surface = decode_state->current_render_target;
 119             obj_surface = decode_state->render_object;
 120             n += set_ref_frame(i965, &ref_frames[n], va_surface, obj_surface);
 121         }
 122         va_surface = pic_param->forward_reference_picture;
 123         obj_surface = decode_state->reference_objects[0];
 124         n += set_ref_frame(i965, &ref_frames[n], va_surface, obj_surface);
 125         break;
 126
 127     case MPEG_B_PICTURE:
 128         va_surface = pic_param->forward_reference_picture;
 129         obj_surface = decode_state->reference_objects[0];
 130         n += set_ref_frame(i965, &ref_frames[n], va_surface, obj_surface);
 131         va_surface = pic_param->backward_reference_picture;
 132         obj_surface = decode_state->reference_objects[1];
 133         n += set_ref_frame(i965, &ref_frames[n], va_surface, obj_surface);
 134         break;
 135     }
 136
 137     while (n != 2) {
 138         ref_frames[n].obj_surface = ref_frames[0].obj_surface;
 139         ref_frames[n++].surface_id = ref_frames[0].surface_id;
 140     }
 141
 142     if (pic_param->picture_coding_extension.bits.frame_pred_frame_dct)
 143         return;
 144
 145     ref_frames[2].surface_id = VA_INVALID_ID;
 146     ref_frames[2].obj_surface = NULL;
 147
 148     /* Bottom field pictures used as reference */
 149     switch (pic_param->picture_coding_type) {
 150     case MPEG_P_PICTURE:
 151         if (is_second_field && pic_structure == MPEG_TOP_FIELD) {
 152             va_surface = decode_state->current_render_target;
 153             obj_surface = decode_state->render_object;
 154             n += set_ref_frame(i965, &ref_frames[n], va_surface, obj_surface);
 155         }
 156         va_surface = pic_param->forward_reference_picture;
 157         obj_surface = decode_state->reference_objects[0];
 158         n += set_ref_frame(i965, &ref_frames[n], va_surface, obj_surface);
 159         break;
 160
 161     case MPEG_B_PICTURE:
 162         va_surface = pic_param->forward_reference_picture;
 163         obj_surface = decode_state->reference_objects[0];
 164         n += set_ref_frame(i965, &ref_frames[n], va_surface, obj_surface);
 165         va_surface = pic_param->backward_reference_picture;
 166         obj_surface = decode_state->reference_objects[1];
 167         n += set_ref_frame(i965, &ref_frames[n], va_surface, obj_surface);
 168         break;
 169     }
 170
 171     while (n != 4) {
 172         ref_frames[n].obj_surface = ref_frames[2].obj_surface;
 173         ref_frames[n++].surface_id = ref_frames[2].surface_id;
 174     }
 175 }
 176
 177 /* Ensure the supplied VA surface has valid storage for decoding the
 178    current picture */
 179 VAStatus
 180 avc_ensure_surface_bo(
 181     VADriverContextP                    ctx,
 182     struct decode_state                *decode_state,
 183     struct object_surface              *obj_surface,
 184     const VAPictureParameterBufferH264 *pic_param
 185 )
 186 {
 187     VAStatus va_status;
 188     uint32_t hw_fourcc, fourcc, subsample, chroma_format;
 189
 190     /* Validate chroma format */
 191     switch (pic_param->seq_fields.bits.chroma_format_idc) {
 192     case 0: // Grayscale
 193         fourcc = VA_FOURCC_Y800;
 194         subsample = SUBSAMPLE_YUV400;
 195         chroma_format = VA_RT_FORMAT_YUV400;
 196         break;
 197     case 1: // YUV 4:2:0
 198         fourcc = VA_FOURCC_NV12;
 199         subsample = SUBSAMPLE_YUV420;
 200         chroma_format = VA_RT_FORMAT_YUV420;
 201         break;
 202     default:
 203         return VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT;
 204     }
 205
 206     /* Determine the HW surface format, bound to VA config needs */
 207     if ((decode_state->base.chroma_formats & chroma_format) == chroma_format)
 208         hw_fourcc = fourcc;
 209     else {
 210         hw_fourcc = 0;
 211         switch (fourcc) {
 212         case VA_FOURCC_Y800: // Implement with an NV12 surface
 213             if (decode_state->base.chroma_formats & VA_RT_FORMAT_YUV420) {
 214                 hw_fourcc = VA_FOURCC_NV12;
 215                 subsample = SUBSAMPLE_YUV420;
 216             }
 217             break;
 218         }
 219     }
 220     if (!hw_fourcc)
 221         return VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT;
 222
 223     /* (Re-)allocate the underlying surface buffer store, if necessary */
 224     if (!obj_surface->bo || obj_surface->fourcc != hw_fourcc) {
 225         i965_destroy_surface_storage(obj_surface);
 226         va_status = i965_check_alloc_surface_bo(ctx, obj_surface, 1,
 227             hw_fourcc, subsample);
 228         if (va_status != VA_STATUS_SUCCESS)
 229             return va_status;
 230     }
 231
 232     /* Fake chroma components if grayscale is implemented on top of NV12 */
 233     if (fourcc == VA_FOURCC_Y800 && hw_fourcc == VA_FOURCC_NV12) {
 234         const uint32_t uv_offset = obj_surface->width * obj_surface->height;
 235         const uint32_t uv_size   = obj_surface->width * obj_surface->height / 2;
 236
 237         drm_intel_gem_bo_map_gtt(obj_surface->bo);
 238         memset(obj_surface->bo->virtual + uv_offset, 0x80, uv_size);
 239         drm_intel_gem_bo_unmap_gtt(obj_surface->bo);
 240     }
 241     return VA_STATUS_SUCCESS;
 242 }
 243
 244 /* Generate flat scaling matrices for H.264 decoding */
 245 void
 246 avc_gen_default_iq_matrix(VAIQMatrixBufferH264 *iq_matrix)
 247 {
 248     /* Flat_4x4_16 */
 249     memset(&iq_matrix->ScalingList4x4, 16, sizeof(iq_matrix->ScalingList4x4));
 250
 251     /* Flat_8x8_16 */
 252     memset(&iq_matrix->ScalingList8x8, 16, sizeof(iq_matrix->ScalingList8x8));
 253 }
 254
 255 /* Get first macroblock bit offset for BSD, minus EPB count (AVC) */
 256 /* XXX: slice_data_bit_offset does not account for EPB */
 257 unsigned int
 258 avc_get_first_mb_bit_offset(
 259     dri_bo                     *slice_data_bo,
 260     VASliceParameterBufferH264 *slice_param,
 261     unsigned int                mode_flag
 262 )
 263 {
 264     unsigned int slice_data_bit_offset = slice_param->slice_data_bit_offset;
 265
 266     if (mode_flag == ENTROPY_CABAC)
 267         slice_data_bit_offset = ALIGN(slice_data_bit_offset, 0x8);
 268     return slice_data_bit_offset;
 269 }
 270
 271 /* Get first macroblock bit offset for BSD, with EPB count (AVC) */
 272 /* XXX: slice_data_bit_offset does not account for EPB */
 273 unsigned int
 274 avc_get_first_mb_bit_offset_with_epb(
 275     dri_bo                     *slice_data_bo,
 276     VASliceParameterBufferH264 *slice_param,
 277     unsigned int                mode_flag
 278 )
 279 {
 280     unsigned int in_slice_data_bit_offset = slice_param->slice_data_bit_offset;
 281     unsigned int out_slice_data_bit_offset;
 282     unsigned int i, j, n, buf_size, data_size, header_size;
 283     uint8_t *buf;
 284     int ret;
 285
 286     header_size = slice_param->slice_data_bit_offset / 8;
 287     data_size   = slice_param->slice_data_size - slice_param->slice_data_offset;
 288     buf_size    = (header_size * 3 + 1) / 2; // Max possible header size (x1.5)
 289
 290     if (buf_size > data_size)
 291         buf_size = data_size;
 292
 293     buf = alloca(buf_size);
 294     ret = dri_bo_get_subdata(
 295         slice_data_bo, slice_param->slice_data_offset,
 296         buf_size, buf
 297     );
 298     assert(ret == 0);
 299
 300     for (i = 2, j = 2, n = 0; i < buf_size && j < header_size; i++, j++) {
 301         if (buf[i] == 0x03 && buf[i - 1] == 0x00 && buf[i - 2] == 0x00)
 302             i += 2, j++, n++;
 303     }
 304
 305     out_slice_data_bit_offset = in_slice_data_bit_offset + n * 8;
 306
 307     if (mode_flag == ENTROPY_CABAC)
 308         out_slice_data_bit_offset = ALIGN(out_slice_data_bit_offset, 0x8);
 309     return out_slice_data_bit_offset;
 310 }
 311
 312 static inline uint8_t
 313 get_ref_idx_state_1(const VAPictureH264 *va_pic, unsigned int frame_store_id)
 314 {
 315     const unsigned int is_long_term =
 316         !!(va_pic->flags & VA_PICTURE_H264_LONG_TERM_REFERENCE);
 317     const unsigned int is_top_field =
 318         !!(va_pic->flags & VA_PICTURE_H264_TOP_FIELD);
 319     const unsigned int is_bottom_field =
 320         !!(va_pic->flags & VA_PICTURE_H264_BOTTOM_FIELD);
 321
 322     return ((is_long_term                         << 6) |
 323             ((is_top_field ^ is_bottom_field ^ 1) << 5) |
 324             (frame_store_id                       << 1) |
 325             ((is_top_field ^ 1) & is_bottom_field));
 326 }
 327
 328 /* Fill in Reference List Entries (Gen5+: ILK, SNB, IVB) */
 329 void
 330 gen5_fill_avc_ref_idx_state(
 331     uint8_t             state[32],
 332     const VAPictureH264 ref_list[32],
 333     unsigned int        ref_list_count,
 334     const GenFrameStore frame_store[MAX_GEN_REFERENCE_FRAMES]
 335 )
 336 {
 337     unsigned int i, n, frame_idx;
 338     int found;
 339
 340     for (i = 0, n = 0; i < ref_list_count; i++) {
 341         const VAPictureH264 * const va_pic = &ref_list[i];
 342
 343         if (va_pic->flags & VA_PICTURE_H264_INVALID)
 344             continue;
 345
 346         found = 0;
 347         for (frame_idx = 0; frame_idx < MAX_GEN_REFERENCE_FRAMES; frame_idx++) {
 348             const GenFrameStore * const fs = &frame_store[frame_idx];
 349             if (fs->surface_id != VA_INVALID_ID &&
 350                 fs->surface_id == va_pic->picture_id) {
 351                 found = 1;
 352                 break;
 353             }
 354         }
 355
 356         if (found) {
 357             state[n++] = get_ref_idx_state_1(va_pic, frame_idx);
 358         } else {
 359             WARN_ONCE("Invalid Slice reference frame list !!!. It is not included in DPB \n");
 360         }
 361     }
 362
 363     for (; n < 32; n++)
 364         state[n] = 0xff;
 365 }
 366
 367 /* Emit Reference List Entries (Gen6+: SNB, IVB) */
 368 static void
 369 gen6_send_avc_ref_idx_state_1(
 370     struct intel_batchbuffer         *batch,
 371     unsigned int                      list,
 372     const VAPictureH264              *ref_list,
 373     unsigned int                      ref_list_count,
 374     const GenFrameStore               frame_store[MAX_GEN_REFERENCE_FRAMES]
 375 )
 376 {
 377     uint8_t ref_idx_state[32];
 378
 379     BEGIN_BCS_BATCH(batch, 10);
 380     OUT_BCS_BATCH(batch, MFX_AVC_REF_IDX_STATE | (10 - 2));
 381     OUT_BCS_BATCH(batch, list);
 382     gen5_fill_avc_ref_idx_state(
 383         ref_idx_state,
 384         ref_list, ref_list_count,
 385         frame_store
 386     );
 387     intel_batchbuffer_data(batch, ref_idx_state, sizeof(ref_idx_state));
 388     ADVANCE_BCS_BATCH(batch);
 389 }
 390
 391 void
 392 gen6_send_avc_ref_idx_state(
 393     struct intel_batchbuffer         *batch,
 394     const VASliceParameterBufferH264 *slice_param,
 395     const GenFrameStore               frame_store[MAX_GEN_REFERENCE_FRAMES]
 396 )
 397 {
 398     if (slice_param->slice_type == SLICE_TYPE_I ||
 399         slice_param->slice_type == SLICE_TYPE_SI)
 400         return;
 401
 402     /* RefPicList0 */
 403     gen6_send_avc_ref_idx_state_1(
 404         batch, 0,
 405         slice_param->RefPicList0, slice_param->num_ref_idx_l0_active_minus1 + 1,
 406         frame_store
 407     );
 408
 409     if (slice_param->slice_type != SLICE_TYPE_B)
 410         return;
 411
 412     /* RefPicList1 */
 413     gen6_send_avc_ref_idx_state_1(
 414         batch, 1,
 415         slice_param->RefPicList1, slice_param->num_ref_idx_l1_active_minus1 + 1,
 416         frame_store
 417     );
 418 }
 419
 420 void
 421 intel_update_avc_frame_store_index(VADriverContextP ctx,
 422                                    struct decode_state *decode_state,
 423                                    VAPictureParameterBufferH264 *pic_param,
 424                                    GenFrameStore frame_store[MAX_GEN_REFERENCE_FRAMES])
 425 {
 426     int i, j;
 427
 428     assert(MAX_GEN_REFERENCE_FRAMES == ARRAY_ELEMS(pic_param->ReferenceFrames));
 429
 430     for (i = 0; i < MAX_GEN_REFERENCE_FRAMES; i++) {
 431         int found = 0;
 432
 433         if (frame_store[i].surface_id == VA_INVALID_ID ||
 434             frame_store[i].obj_surface == NULL)
 435             continue;
 436
 437         assert(frame_store[i].frame_store_id != -1);
 438
 439         for (j = 0; j < MAX_GEN_REFERENCE_FRAMES; j++) {
 440             VAPictureH264 *ref_pic = &pic_param->ReferenceFrames[j];
 441             if (ref_pic->flags & VA_PICTURE_H264_INVALID)
 442                 continue;
 443
 444             if (frame_store[i].surface_id == ref_pic->picture_id) {
 445                 found = 1;
 446                 break;
 447             }
 448         }
 449
 450         /* remove it from the internal DPB */
 451         if (!found) {
 452             struct object_surface *obj_surface = frame_store[i].obj_surface;
 453
 454             obj_surface->flags &= ~SURFACE_REFERENCED;
 455
 456             if ((obj_surface->flags & SURFACE_ALL_MASK) == SURFACE_DISPLAYED) {
 457                 obj_surface->flags &= ~SURFACE_REF_DIS_MASK;
 458                 i965_destroy_surface_storage(obj_surface);
 459             }
 460
 461             frame_store[i].surface_id = VA_INVALID_ID;
 462             frame_store[i].frame_store_id = -1;
 463             frame_store[i].obj_surface = NULL;
 464         }
 465     }
 466
 467     for (i = 0; i < MAX_GEN_REFERENCE_FRAMES; i++) {
 468         VAPictureH264 *ref_pic = &pic_param->ReferenceFrames[i];
 469         int found = 0;
 470
 471         if (ref_pic->flags & VA_PICTURE_H264_INVALID ||
 472             ref_pic->picture_id == VA_INVALID_SURFACE ||
 473             decode_state->reference_objects[i] == NULL)
 474             continue;
 475
 476         for (j = 0; j < MAX_GEN_REFERENCE_FRAMES; j++) {
 477             if (frame_store[j].surface_id == ref_pic->picture_id) {
 478                 found = 1;
 479                 break;
 480             }
 481         }
 482
 483         /* add the new reference frame into the internal DPB */
 484         if (!found) {
 485             int frame_idx;
 486             int slot_found;
 487             struct object_surface *obj_surface = decode_state->reference_objects[i];
 488
 489             /*
 490              * Sometimes a dummy frame comes from the upper layer library, call i965_check_alloc_surface_bo()
 491              * to ake sure the store buffer is allocated for this reference frame
 492              */
 493             avc_ensure_surface_bo(ctx, decode_state, obj_surface, pic_param);
 494
 495             slot_found = 0;
 496             frame_idx = -1;
 497             /* Find a free frame store index */
 498             for (j = 0; j < MAX_GEN_REFERENCE_FRAMES; j++) {
 499                 if (frame_store[j].surface_id == VA_INVALID_ID ||
 500                     frame_store[j].obj_surface == NULL) {
 501                     frame_idx = j;
 502                     slot_found = 1;
 503                     break;
 504                 }
 505             }
 506
 507
 508             if (slot_found) {
 509                 frame_store[j].surface_id = ref_pic->picture_id;
 510                 frame_store[j].frame_store_id = frame_idx;
 511                 frame_store[j].obj_surface = obj_surface;
 512             } else {
 513                 WARN_ONCE("Not free slot for DPB reference list!!!\n");
 514             }
 515         }
 516     }
 517
 518 }
 519
 520 void
 521 intel_update_vc1_frame_store_index(VADriverContextP ctx,
 522                                    struct decode_state *decode_state,
 523                                    VAPictureParameterBufferVC1 *pic_param,
 524                                    GenFrameStore frame_store[MAX_GEN_REFERENCE_FRAMES])
 525 {
 526     struct object_surface *obj_surface;
 527     int i;
 528
 529     obj_surface = decode_state->reference_objects[0];
 530
 531     if (pic_param->forward_reference_picture == VA_INVALID_ID ||
 532         !obj_surface ||
 533         !obj_surface->bo) {
 534         frame_store[0].surface_id = VA_INVALID_ID;
 535         frame_store[0].obj_surface = NULL;
 536     } else {
 537         frame_store[0].surface_id = pic_param->forward_reference_picture;
 538         frame_store[0].obj_surface = obj_surface;
 539     }
 540
 541     obj_surface = decode_state->reference_objects[1];
 542
 543     if (pic_param->backward_reference_picture == VA_INVALID_ID ||
 544         !obj_surface ||
 545         !obj_surface->bo) {
 546         frame_store[1].surface_id = frame_store[0].surface_id;
 547         frame_store[1].obj_surface = frame_store[0].obj_surface;
 548     } else {
 549         frame_store[1].surface_id = pic_param->backward_reference_picture;
 550         frame_store[1].obj_surface = obj_surface;
 551     }
 552     for (i = 2; i < MAX_GEN_REFERENCE_FRAMES; i++) {
 553         frame_store[i].surface_id = frame_store[i % 2].surface_id;
 554         frame_store[i].obj_surface = frame_store[i % 2].obj_surface;
 555     }
 556
 557 }
 558
 559 void
 560 intel_update_vp8_frame_store_index(VADriverContextP ctx,
 561                                    struct decode_state *decode_state,
 562                                    VAPictureParameterBufferVP8 *pic_param,
 563                                    GenFrameStore frame_store[MAX_GEN_REFERENCE_FRAMES])
 564 {
 565     struct object_surface *obj_surface;
 566     int i;
 567
 568     obj_surface = decode_state->reference_objects[0];
 569
 570     if (pic_param->last_ref_frame == VA_INVALID_ID ||
 571         !obj_surface ||
 572         !obj_surface->bo) {
 573         frame_store[0].surface_id = VA_INVALID_ID;
 574         frame_store[0].obj_surface = NULL;
 575     } else {
 576         frame_store[0].surface_id = pic_param->last_ref_frame;
 577         frame_store[0].obj_surface = obj_surface;
 578     }
 579
 580     obj_surface = decode_state->reference_objects[1];
 581
 582     if (pic_param->golden_ref_frame == VA_INVALID_ID ||
 583         !obj_surface ||
 584         !obj_surface->bo) {
 585         frame_store[1].surface_id = frame_store[0].surface_id;
 586         frame_store[1].obj_surface = frame_store[0].obj_surface;
 587     } else {
 588         frame_store[1].surface_id = pic_param->golden_ref_frame;
 589         frame_store[1].obj_surface = obj_surface;
 590     }
 591
 592     obj_surface = decode_state->reference_objects[2];
 593
 594     if (pic_param->alt_ref_frame == VA_INVALID_ID ||
 595         !obj_surface ||
 596         !obj_surface->bo) {
 597         frame_store[2].surface_id = frame_store[0].surface_id;
 598         frame_store[2].obj_surface = frame_store[0].obj_surface;
 599     } else {
 600         frame_store[2].surface_id = pic_param->alt_ref_frame;
 601         frame_store[2].obj_surface = obj_surface;
 602     }
 603
 604     for (i = 3; i < MAX_GEN_REFERENCE_FRAMES; i++) {
 605         frame_store[i].surface_id = frame_store[i % 2].surface_id;
 606         frame_store[i].obj_surface = frame_store[i % 2].obj_surface;
 607     }
 608
 609 }
 610
 611 static VAStatus
 612 intel_decoder_check_avc_parameter(VADriverContextP ctx,
 613                                   VAProfile h264_profile,
 614                                   struct decode_state *decode_state)
 615 {
 616     struct i965_driver_data *i965 = i965_driver_data(ctx);
 617     VAPictureParameterBufferH264 *pic_param = (VAPictureParameterBufferH264 *)decode_state->pic_param->buffer;
 618     struct object_surface *obj_surface;
 619     int i;
 620
 621     assert(!(pic_param->CurrPic.flags & VA_PICTURE_H264_INVALID));
 622     assert(pic_param->CurrPic.picture_id != VA_INVALID_SURFACE);
 623
 624     if (pic_param->CurrPic.flags & VA_PICTURE_H264_INVALID ||
 625         pic_param->CurrPic.picture_id == VA_INVALID_SURFACE)
 626         goto error;
 627
 628     assert(pic_param->CurrPic.picture_id == decode_state->current_render_target);
 629
 630     if (pic_param->CurrPic.picture_id != decode_state->current_render_target)
 631         goto error;
 632
 633     if ((h264_profile != VAProfileH264Baseline)) {
 634        if (pic_param->num_slice_groups_minus1 ||
 635            pic_param->pic_fields.bits.redundant_pic_cnt_present_flag) {
 636            WARN_ONCE("Unsupported the FMO/ASO constraints!!!\n");
 637            goto error;
 638        }
 639     }
 640
 641     for (i = 0; i < 16; i++) {
 642         if (pic_param->ReferenceFrames[i].flags & VA_PICTURE_H264_INVALID ||
 643             pic_param->ReferenceFrames[i].picture_id == VA_INVALID_SURFACE)
 644             break;
 645         else {
 646             obj_surface = SURFACE(pic_param->ReferenceFrames[i].picture_id);
 647             assert(obj_surface);
 648
 649             if (!obj_surface)
 650                 goto error;
 651
 652             if (!obj_surface->bo) { /* a reference frame  without store buffer */
 653                 WARN_ONCE("Invalid reference frame!!!\n");
 654             }
 655
 656             decode_state->reference_objects[i] = obj_surface;
 657         }
 658     }
 659
 660     for ( ; i < 16; i++)
 661         decode_state->reference_objects[i] = NULL;
 662
 663     return VA_STATUS_SUCCESS;
 664
 665 error:
 666     return VA_STATUS_ERROR_INVALID_PARAMETER;
 667 }
 668
 669 static VAStatus
 670 intel_decoder_check_mpeg2_parameter(VADriverContextP ctx,
 671                                     struct decode_state *decode_state)
 672 {
 673     struct i965_driver_data *i965 = i965_driver_data(ctx);
 674     VAPictureParameterBufferMPEG2 *pic_param = (VAPictureParameterBufferMPEG2 *)decode_state->pic_param->buffer;
 675     struct object_surface *obj_surface;
 676     int i = 0;
 677
 678     if (pic_param->picture_coding_type == MPEG_I_PICTURE) {
 679     } else if (pic_param->picture_coding_type == MPEG_P_PICTURE) {
 680         obj_surface = SURFACE(pic_param->forward_reference_picture);
 681
 682         if (!obj_surface || !obj_surface->bo)
 683             decode_state->reference_objects[i++] = NULL;
 684         else
 685             decode_state->reference_objects[i++] = obj_surface;
 686     } else if (pic_param->picture_coding_type == MPEG_B_PICTURE) {
 687         obj_surface = SURFACE(pic_param->forward_reference_picture);
 688
 689         if (!obj_surface || !obj_surface->bo)
 690             decode_state->reference_objects[i++] = NULL;
 691         else
 692             decode_state->reference_objects[i++] = obj_surface;
 693
 694         obj_surface = SURFACE(pic_param->backward_reference_picture);
 695
 696         if (!obj_surface || !obj_surface->bo)
 697             decode_state->reference_objects[i++] = NULL;
 698         else
 699             decode_state->reference_objects[i++] = obj_surface;
 700     } else
 701         goto error;
 702
 703     for ( ; i < 16; i++)
 704         decode_state->reference_objects[i] = NULL;
 705
 706     return VA_STATUS_SUCCESS;
 707
 708 error:
 709     return VA_STATUS_ERROR_INVALID_PARAMETER;
 710 }
 711
 712 static VAStatus
 713 intel_decoder_check_vc1_parameter(VADriverContextP ctx,
 714                                   struct decode_state *decode_state)
 715 {
 716     struct i965_driver_data *i965 = i965_driver_data(ctx);
 717     VAPictureParameterBufferVC1 *pic_param = (VAPictureParameterBufferVC1 *)decode_state->pic_param->buffer;
 718     struct object_surface *obj_surface;
 719     int i = 0;
 720
 721     if (pic_param->sequence_fields.bits.interlace == 1 &&
 722         pic_param->picture_fields.bits.frame_coding_mode != 0) { /* frame-interlace or field-interlace */
 723         return VA_STATUS_ERROR_DECODING_ERROR;
 724     }
 725
 726     if (pic_param->picture_fields.bits.picture_type == 0 ||
 727         pic_param->picture_fields.bits.picture_type == 3) {
 728     } else if (pic_param->picture_fields.bits.picture_type == 1 ||
 729                pic_param->picture_fields.bits.picture_type == 4) {
 730         obj_surface = SURFACE(pic_param->forward_reference_picture);
 731
 732         if (!obj_surface || !obj_surface->bo)
 733             decode_state->reference_objects[i++] = NULL;
 734         else
 735             decode_state->reference_objects[i++] = obj_surface;
 736     } else if (pic_param->picture_fields.bits.picture_type == 2) {
 737         obj_surface = SURFACE(pic_param->forward_reference_picture);
 738
 739         if (!obj_surface || !obj_surface->bo)
 740             decode_state->reference_objects[i++] = NULL;
 741         else
 742             decode_state->reference_objects[i++] = obj_surface;
 743
 744         obj_surface = SURFACE(pic_param->backward_reference_picture);
 745
 746         if (!obj_surface || !obj_surface->bo)
 747             decode_state->reference_objects[i++] = NULL;
 748         else
 749             decode_state->reference_objects[i++] = obj_surface;
 750     } else
 751         goto error;
 752
 753     for ( ; i < 16; i++)
 754         decode_state->reference_objects[i] = NULL;
 755
 756     return VA_STATUS_SUCCESS;
 757
 758 error:
 759     return VA_STATUS_ERROR_INVALID_PARAMETER;
 760 }
 761
 762 static VAStatus
 763 intel_decoder_check_vp8_parameter(VADriverContextP ctx,
 764                                   struct decode_state *decode_state)
 765 {
 766     struct i965_driver_data *i965 = i965_driver_data(ctx);
 767     VAPictureParameterBufferVP8 *pic_param = (VAPictureParameterBufferVP8 *)decode_state->pic_param->buffer;
 768     struct object_surface *obj_surface;
 769     int i = 0;
 770
 771     if (pic_param->last_ref_frame != VA_INVALID_SURFACE) {
 772         obj_surface = SURFACE(pic_param->last_ref_frame);
 773
 774         if (obj_surface && obj_surface->bo)
 775             decode_state->reference_objects[i++] = obj_surface;
 776         else
 777             decode_state->reference_objects[i++] = NULL;
 778     }
 779
 780     if (pic_param->golden_ref_frame != VA_INVALID_SURFACE) {
 781         obj_surface = SURFACE(pic_param->golden_ref_frame);
 782
 783         if (obj_surface && obj_surface->bo)
 784             decode_state->reference_objects[i++] = obj_surface;
 785         else
 786             decode_state->reference_objects[i++] = NULL;
 787     }
 788
 789     if (pic_param->alt_ref_frame != VA_INVALID_SURFACE) {
 790         obj_surface = SURFACE(pic_param->alt_ref_frame);
 791
 792         if (obj_surface && obj_surface->bo)
 793             decode_state->reference_objects[i++] = obj_surface;
 794         else
 795             decode_state->reference_objects[i++] = NULL;
 796     }
 797
 798     for ( ; i < 16; i++)
 799         decode_state->reference_objects[i] = NULL;
 800
 801     return VA_STATUS_SUCCESS;
 802 }
 803
 804 VAStatus
 805 intel_decoder_sanity_check_input(VADriverContextP ctx,
 806                                  VAProfile profile,
 807                                  struct decode_state *decode_state)
 808 {
 809     struct i965_driver_data *i965 = i965_driver_data(ctx);
 810     struct object_surface *obj_surface;
 811     VAStatus vaStatus = VA_STATUS_ERROR_INVALID_PARAMETER;
 812
 813     if (decode_state->current_render_target == VA_INVALID_SURFACE)
 814         goto out;
 815
 816     obj_surface = SURFACE(decode_state->current_render_target);
 817
 818     if (!obj_surface)
 819         goto out;
 820
 821     decode_state->render_object = obj_surface;
 822
 823     switch (profile) {
 824     case VAProfileMPEG2Simple:
 825     case VAProfileMPEG2Main:
 826         vaStatus = intel_decoder_check_mpeg2_parameter(ctx, decode_state);
 827         break;
 828
 829     case VAProfileH264ConstrainedBaseline:
 830     case VAProfileH264Main:
 831     case VAProfileH264High:
 832         vaStatus = intel_decoder_check_avc_parameter(ctx, profile, decode_state);
 833         break;
 834
 835     case VAProfileVC1Simple:
 836     case VAProfileVC1Main:
 837     case VAProfileVC1Advanced:
 838         vaStatus = intel_decoder_check_vc1_parameter(ctx, decode_state);
 839         break;
 840
 841     case VAProfileJPEGBaseline:
 842         vaStatus = VA_STATUS_SUCCESS;
 843         break;
 844
 845     case VAProfileVP8Version0_3:
 846         vaStatus = intel_decoder_check_vp8_parameter(ctx, decode_state);
 847         break;
 848
 849     default:
 850         vaStatus = VA_STATUS_ERROR_INVALID_PARAMETER;
 851         break;
 852     }
 853
 854 out:
 855     return vaStatus;
 856 }
 857
 858 /*
 859  * Return the next slice paramter
 860  *
 861  * Input:
 862  *      slice_param: the current slice
 863  *      *group_idx & *element_idx the current slice position in slice groups
 864  * Output:
 865  *      Return the next slice parameter
 866  *      *group_idx & *element_idx the next slice position in slice groups,
 867  *      if the next slice is NULL, *group_idx & *element_idx will be ignored
 868  */
 869 VASliceParameterBufferMPEG2 *
 870 intel_mpeg2_find_next_slice(struct decode_state *decode_state,
 871                             VAPictureParameterBufferMPEG2 *pic_param,
 872                             VASliceParameterBufferMPEG2 *slice_param,
 873                             int *group_idx,
 874                             int *element_idx)
 875 {
 876     VASliceParameterBufferMPEG2 *next_slice_param;
 877     unsigned int width_in_mbs = ALIGN(pic_param->horizontal_size, 16) / 16;
 878     int j = *group_idx, i = *element_idx + 1;
 879
 880     for (; j < decode_state->num_slice_params; j++) {
 881         for (; i < decode_state->slice_params[j]->num_elements; i++) {
 882             next_slice_param = ((VASliceParameterBufferMPEG2 *)decode_state->slice_params[j]->buffer) + i;
 883
 884             if ((next_slice_param->slice_vertical_position * width_in_mbs + next_slice_param->slice_horizontal_position) >=
 885                 (slice_param->slice_vertical_position * width_in_mbs + slice_param->slice_horizontal_position)) {
 886                 *group_idx = j;
 887                 *element_idx = i;
 888
 889                 return next_slice_param;
 890             }
 891         }
 892
 893         i = 0;
 894     }
 895
 896     return NULL;
 897 }
 898
 899 /* Ensure the segmentation buffer is large enough for the supplied
 900    number of MBs, or re-allocate it */
 901 bool
 902 intel_ensure_vp8_segmentation_buffer(VADriverContextP ctx, GenBuffer *buf,
 903     unsigned int mb_width, unsigned int mb_height)
 904 {
 905     struct i965_driver_data * const i965 = i965_driver_data(ctx);
 906     /* The segmentation map is a 64-byte aligned linear buffer, with
 907        each cache line holding only 8 bits for 4 continuous MBs */
 908     const unsigned int buf_size = ((mb_width + 3) / 4) * 64 * mb_height;
 909
 910     if (buf->valid) {
 911         if (buf->bo && buf->bo->size >= buf_size)
 912             return true;
 913         drm_intel_bo_unreference(buf->bo);
 914         buf->valid = false;
 915     }
 916
 917     buf->bo = drm_intel_bo_alloc(i965->intel.bufmgr, "segmentation map",
 918         buf_size, 0x1000);
 919     buf->valid = buf->bo != NULL;
 920     return buf->valid;
 921 }