tests/amdgpu/vcn_tests.c

   1 /*
   2  * Copyright 2017 Advanced Micro Devices, Inc.
   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 shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20  * OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22 */
  23
  24 #include <stdio.h>
  25 #include <string.h>
  26 #include <inttypes.h>
  27 #include <unistd.h>
  28
  29 #include "CUnit/Basic.h"
  30
  31 #include <unistd.h>
  32 #include "util_math.h"
  33
  34 #include "amdgpu_test.h"
  35 #include "amdgpu_drm.h"
  36 #include "amdgpu_internal.h"
  37 #include "decode_messages.h"
  38 #include "frame.h"
  39
  40 #define IB_SIZE         4096
  41 #define MAX_RESOURCES   16
  42
  43 #define DECODE_CMD_MSG_BUFFER                              0x00000000
  44 #define DECODE_CMD_DPB_BUFFER                              0x00000001
  45 #define DECODE_CMD_DECODING_TARGET_BUFFER                  0x00000002
  46 #define DECODE_CMD_FEEDBACK_BUFFER                         0x00000003
  47 #define DECODE_CMD_PROB_TBL_BUFFER                         0x00000004
  48 #define DECODE_CMD_SESSION_CONTEXT_BUFFER                  0x00000005
  49 #define DECODE_CMD_BITSTREAM_BUFFER                        0x00000100
  50 #define DECODE_CMD_IT_SCALING_TABLE_BUFFER                 0x00000204
  51 #define DECODE_CMD_CONTEXT_BUFFER                          0x00000206
  52
  53 #define DECODE_IB_PARAM_DECODE_BUFFER                      (0x00000001)
  54
  55 #define DECODE_CMDBUF_FLAGS_MSG_BUFFER                     (0x00000001)
  56 #define DECODE_CMDBUF_FLAGS_DPB_BUFFER                     (0x00000002)
  57 #define DECODE_CMDBUF_FLAGS_BITSTREAM_BUFFER               (0x00000004)
  58 #define DECODE_CMDBUF_FLAGS_DECODING_TARGET_BUFFER         (0x00000008)
  59 #define DECODE_CMDBUF_FLAGS_FEEDBACK_BUFFER                (0x00000010)
  60 #define DECODE_CMDBUF_FLAGS_IT_SCALING_BUFFER              (0x00000200)
  61 #define DECODE_CMDBUF_FLAGS_CONTEXT_BUFFER                 (0x00000800)
  62 #define DECODE_CMDBUF_FLAGS_PROB_TBL_BUFFER                (0x00001000)
  63 #define DECODE_CMDBUF_FLAGS_SESSION_CONTEXT_BUFFER         (0x00100000)
  64
  65 static bool vcn_dec_sw_ring = false;
  66 static bool vcn_unified_ring = false;
  67
  68 #define H264_NAL_TYPE_NON_IDR_SLICE 1
  69 #define H264_NAL_TYPE_DP_A_SLICE 2
  70 #define H264_NAL_TYPE_DP_B_SLICE 3
  71 #define H264_NAL_TYPE_DP_C_SLICE 0x4
  72 #define H264_NAL_TYPE_IDR_SLICE 0x5
  73 #define H264_NAL_TYPE_SEI 0x6
  74 #define H264_NAL_TYPE_SEQ_PARAM 0x7
  75 #define H264_NAL_TYPE_PIC_PARAM 0x8
  76 #define H264_NAL_TYPE_ACCESS_UNIT 0x9
  77 #define H264_NAL_TYPE_END_OF_SEQ 0xa
  78 #define H264_NAL_TYPE_END_OF_STREAM 0xb
  79 #define H264_NAL_TYPE_FILLER_DATA 0xc
  80 #define H264_NAL_TYPE_SEQ_EXTENSION 0xd
  81
  82 #define H264_START_CODE 0x000001
  83
  84 struct amdgpu_vcn_bo {
  85         amdgpu_bo_handle handle;
  86         amdgpu_va_handle va_handle;
  87         uint64_t addr;
  88         uint64_t size;
  89         uint8_t *ptr;
  90 };
  91
  92 typedef struct rvcn_decode_buffer_s {
  93         unsigned int valid_buf_flag;
  94         unsigned int msg_buffer_address_hi;
  95         unsigned int msg_buffer_address_lo;
  96         unsigned int dpb_buffer_address_hi;
  97         unsigned int dpb_buffer_address_lo;
  98         unsigned int target_buffer_address_hi;
  99         unsigned int target_buffer_address_lo;
 100         unsigned int session_contex_buffer_address_hi;
 101         unsigned int session_contex_buffer_address_lo;
 102         unsigned int bitstream_buffer_address_hi;
 103         unsigned int bitstream_buffer_address_lo;
 104         unsigned int context_buffer_address_hi;
 105         unsigned int context_buffer_address_lo;
 106         unsigned int feedback_buffer_address_hi;
 107         unsigned int feedback_buffer_address_lo;
 108         unsigned int luma_hist_buffer_address_hi;
 109         unsigned int luma_hist_buffer_address_lo;
 110         unsigned int prob_tbl_buffer_address_hi;
 111         unsigned int prob_tbl_buffer_address_lo;
 112         unsigned int sclr_coeff_buffer_address_hi;
 113         unsigned int sclr_coeff_buffer_address_lo;
 114         unsigned int it_sclr_table_buffer_address_hi;
 115         unsigned int it_sclr_table_buffer_address_lo;
 116         unsigned int sclr_target_buffer_address_hi;
 117         unsigned int sclr_target_buffer_address_lo;
 118         unsigned int cenc_size_info_buffer_address_hi;
 119         unsigned int cenc_size_info_buffer_address_lo;
 120         unsigned int mpeg2_pic_param_buffer_address_hi;
 121         unsigned int mpeg2_pic_param_buffer_address_lo;
 122         unsigned int mpeg2_mb_control_buffer_address_hi;
 123         unsigned int mpeg2_mb_control_buffer_address_lo;
 124         unsigned int mpeg2_idct_coeff_buffer_address_hi;
 125         unsigned int mpeg2_idct_coeff_buffer_address_lo;
 126 } rvcn_decode_buffer_t;
 127
 128 typedef struct rvcn_decode_ib_package_s {
 129         unsigned int package_size;
 130         unsigned int package_type;
 131 } rvcn_decode_ib_package_t;
 132
 133
 134 struct amdgpu_vcn_reg {
 135         uint32_t data0;
 136         uint32_t data1;
 137         uint32_t cmd;
 138         uint32_t nop;
 139         uint32_t cntl;
 140 };
 141
 142 typedef struct BufferInfo_t {
 143         uint32_t numOfBitsInBuffer;
 144         const uint8_t *decBuffer;
 145         uint8_t decData;
 146         uint32_t decBufferSize;
 147         const uint8_t *end;
 148 } bufferInfo;
 149
 150 typedef struct h264_decode_t {
 151         uint8_t profile;
 152         uint8_t level_idc;
 153         uint8_t nal_ref_idc;
 154         uint8_t nal_unit_type;
 155         uint32_t pic_width, pic_height;
 156         uint32_t slice_type;
 157 } h264_decode;
 158
 159 static amdgpu_device_handle device_handle;
 160 static uint32_t major_version;
 161 static uint32_t minor_version;
 162 static uint32_t family_id;
 163 static uint32_t chip_rev;
 164 static uint32_t chip_id;
 165 static uint32_t asic_id;
 166 static uint32_t chip_rev;
 167 static struct amdgpu_vcn_bo enc_buf;
 168 static struct amdgpu_vcn_bo cpb_buf;
 169 static uint32_t enc_task_id;
 170
 171 static amdgpu_context_handle context_handle;
 172 static amdgpu_bo_handle ib_handle;
 173 static amdgpu_va_handle ib_va_handle;
 174 static uint64_t ib_mc_address;
 175 static uint32_t *ib_cpu;
 176 static uint32_t *ib_checksum;
 177 static uint32_t *ib_size_in_dw;
 178
 179 static rvcn_decode_buffer_t *decode_buffer;
 180
 181 static amdgpu_bo_handle resources[MAX_RESOURCES];
 182 static unsigned num_resources;
 183
 184 static uint8_t vcn_reg_index;
 185 static struct amdgpu_vcn_reg reg[] = {
 186         {0x81c4, 0x81c5, 0x81c3, 0x81ff, 0x81c6},
 187         {0x504, 0x505, 0x503, 0x53f, 0x506},
 188         {0x10, 0x11, 0xf, 0x29, 0x26d},
 189 };
 190
 191 uint32_t gWidth, gHeight, gSliceType;
 192 static uint32_t vcn_ip_version_major;
 193 static uint32_t vcn_ip_version_minor;
 194 static void amdgpu_cs_vcn_dec_create(void);
 195 static void amdgpu_cs_vcn_dec_decode(void);
 196 static void amdgpu_cs_vcn_dec_destroy(void);
 197
 198 static void amdgpu_cs_vcn_enc_create(void);
 199 static void amdgpu_cs_vcn_enc_encode(void);
 200 static void amdgpu_cs_vcn_enc_destroy(void);
 201
 202 static void amdgpu_cs_sq_head(uint32_t *base, int *offset, bool enc);
 203 static void amdgpu_cs_sq_ib_tail(uint32_t *end);
 204 static void h264_check_0s (bufferInfo * bufInfo, int count);
 205 static int32_t h264_se (bufferInfo * bufInfo);
 206 static inline uint32_t bs_read_u1(bufferInfo *bufinfo);
 207 static inline int bs_eof(bufferInfo *bufinfo);
 208 static inline uint32_t bs_read_u(bufferInfo* bufinfo, int n);
 209 static inline uint32_t bs_read_ue(bufferInfo* bufinfo);
 210 static uint32_t remove_03 (uint8_t *bptr, uint32_t len);
 211 static void scaling_list (uint32_t ix, uint32_t sizeOfScalingList, bufferInfo *bufInfo);
 212 static void h264_parse_sequence_parameter_set (h264_decode * dec, bufferInfo *bufInfo);
 213 static void h264_slice_header (h264_decode *dec, bufferInfo *bufInfo);
 214 static uint8_t h264_parse_nal (h264_decode *dec, bufferInfo *bufInfo);
 215 static uint32_t h264_find_next_start_code (uint8_t *pBuf, uint32_t bufLen);
 216 static int verify_checksum(uint8_t *buffer, uint32_t buffer_size);
 217
 218 CU_TestInfo vcn_tests[] = {
 219
 220         { "VCN DEC create",  amdgpu_cs_vcn_dec_create },
 221         { "VCN DEC decode",  amdgpu_cs_vcn_dec_decode },
 222         { "VCN DEC destroy",  amdgpu_cs_vcn_dec_destroy },
 223
 224         { "VCN ENC create",  amdgpu_cs_vcn_enc_create },
 225         { "VCN ENC encode",  amdgpu_cs_vcn_enc_encode },
 226         { "VCN ENC destroy",  amdgpu_cs_vcn_enc_destroy },
 227         CU_TEST_INFO_NULL,
 228 };
 229
 230 CU_BOOL suite_vcn_tests_enable(void)
 231 {
 232         struct drm_amdgpu_info_hw_ip info;
 233         bool enc_ring, dec_ring;
 234         int r;
 235
 236         if (amdgpu_device_initialize(drm_amdgpu[0], &major_version,
 237                                    &minor_version, &device_handle))
 238                 return CU_FALSE;
 239
 240         family_id = device_handle->info.family_id;
 241         asic_id = device_handle->info.asic_id;
 242         chip_rev = device_handle->info.chip_rev;
 243         chip_id = device_handle->info.chip_external_rev;
 244
 245         r = amdgpu_query_hw_ip_info(device_handle, AMDGPU_HW_IP_VCN_ENC, 0, &info);
 246         if (!r) {
 247                 vcn_ip_version_major = info.hw_ip_version_major;
 248                 vcn_ip_version_minor = info.hw_ip_version_minor;
 249                 enc_ring = !!info.available_rings;
 250                 /* in vcn 4.0 it re-uses encoding queue as unified queue */
 251                 if (vcn_ip_version_major >= 4) {
 252                         vcn_unified_ring = true;
 253                         vcn_dec_sw_ring = true;
 254                         dec_ring = enc_ring;
 255                 } else {
 256                         r = amdgpu_query_hw_ip_info(device_handle, AMDGPU_HW_IP_VCN_DEC, 0, &info);
 257                         dec_ring = !!info.available_rings;
 258                 }
 259         }
 260
 261         if (amdgpu_device_deinitialize(device_handle))
 262                 return CU_FALSE;
 263
 264         if (r) {
 265                 printf("\n\nASIC query hw info failed\n");
 266                 return CU_FALSE;
 267         }
 268
 269         if (!(dec_ring || enc_ring) ||
 270             (family_id < AMDGPU_FAMILY_RV &&
 271              (family_id == AMDGPU_FAMILY_AI &&
 272               (chip_id - chip_rev) < 0x32))) {  /* Arcturus */
 273                 printf("\n\nThe ASIC NOT support VCN, suite disabled\n");
 274                 return CU_FALSE;
 275         }
 276
 277         if (!dec_ring) {
 278                 amdgpu_set_test_active("VCN Tests", "VCN DEC create", CU_FALSE);
 279                 amdgpu_set_test_active("VCN Tests", "VCN DEC decode", CU_FALSE);
 280                 amdgpu_set_test_active("VCN Tests", "VCN DEC destroy", CU_FALSE);
 281         }
 282
 283         if (family_id == AMDGPU_FAMILY_AI || !enc_ring) {
 284                 amdgpu_set_test_active("VCN Tests", "VCN ENC create", CU_FALSE);
 285                 amdgpu_set_test_active("VCN Tests", "VCN ENC encode", CU_FALSE);
 286                 amdgpu_set_test_active("VCN Tests", "VCN ENC destroy", CU_FALSE);
 287         }
 288
 289         if (vcn_ip_version_major == 1)
 290                 vcn_reg_index = 0;
 291         else if (vcn_ip_version_major == 2 && vcn_ip_version_minor == 0)
 292                 vcn_reg_index = 1;
 293         else if ((vcn_ip_version_major == 2 && vcn_ip_version_minor >= 5) ||
 294                                 vcn_ip_version_major == 3)
 295                 vcn_reg_index = 2;
 296
 297         return CU_TRUE;
 298 }
 299
 300 int suite_vcn_tests_init(void)
 301 {
 302         int r;
 303
 304         r = amdgpu_device_initialize(drm_amdgpu[0], &major_version,
 305                                      &minor_version, &device_handle);
 306         if (r)
 307                 return CUE_SINIT_FAILED;
 308
 309         family_id = device_handle->info.family_id;
 310
 311         r = amdgpu_cs_ctx_create(device_handle, &context_handle);
 312         if (r)
 313                 return CUE_SINIT_FAILED;
 314
 315         r = amdgpu_bo_alloc_and_map(device_handle, IB_SIZE, 4096,
 316                                     AMDGPU_GEM_DOMAIN_GTT, 0,
 317                                     &ib_handle, (void**)&ib_cpu,
 318                                     &ib_mc_address, &ib_va_handle);
 319         if (r)
 320                 return CUE_SINIT_FAILED;
 321
 322         return CUE_SUCCESS;
 323 }
 324
 325 int suite_vcn_tests_clean(void)
 326 {
 327         int r;
 328
 329         r = amdgpu_bo_unmap_and_free(ib_handle, ib_va_handle,
 330                              ib_mc_address, IB_SIZE);
 331         if (r)
 332                 return CUE_SCLEAN_FAILED;
 333
 334         r = amdgpu_cs_ctx_free(context_handle);
 335         if (r)
 336                 return CUE_SCLEAN_FAILED;
 337
 338         r = amdgpu_device_deinitialize(device_handle);
 339         if (r)
 340                 return CUE_SCLEAN_FAILED;
 341
 342         return CUE_SUCCESS;
 343 }
 344
 345 static void amdgpu_cs_sq_head(uint32_t *base, int *offset, bool enc)
 346 {
 347         /* signature */
 348         *(base + (*offset)++) = 0x00000010;
 349         *(base + (*offset)++) = 0x30000002;
 350         ib_checksum = base + (*offset)++;
 351         ib_size_in_dw = base + (*offset)++;
 352
 353         /* engine info */
 354         *(base + (*offset)++) = 0x00000010;
 355         *(base + (*offset)++) = 0x30000001;
 356         *(base + (*offset)++) = enc ? 2 : 3;
 357         *(base + (*offset)++) = 0x00000000;
 358 }
 359
 360 static void amdgpu_cs_sq_ib_tail(uint32_t *end)
 361 {
 362         uint32_t size_in_dw;
 363         uint32_t checksum = 0;
 364
 365         /* if the pointers are invalid, no need to process */
 366         if (ib_checksum == NULL || ib_size_in_dw == NULL)
 367                 return;
 368
 369         size_in_dw = end - ib_size_in_dw - 1;
 370         *ib_size_in_dw = size_in_dw;
 371         *(ib_size_in_dw + 4) = size_in_dw * sizeof(uint32_t);
 372
 373         for (int i = 0; i < size_in_dw; i++)
 374                 checksum += *(ib_checksum + 2 + i);
 375
 376         *ib_checksum = checksum;
 377
 378         ib_checksum = NULL;
 379         ib_size_in_dw = NULL;
 380 }
 381
 382 static int submit(unsigned ndw, unsigned ip)
 383 {
 384         struct amdgpu_cs_request ibs_request = {0};
 385         struct amdgpu_cs_ib_info ib_info = {0};
 386         struct amdgpu_cs_fence fence_status = {0};
 387         uint32_t expired;
 388         int r;
 389
 390         ib_info.ib_mc_address = ib_mc_address;
 391         ib_info.size = ndw;
 392
 393         ibs_request.ip_type = ip;
 394
 395         r = amdgpu_bo_list_create(device_handle, num_resources, resources,
 396                                   NULL, &ibs_request.resources);
 397         if (r)
 398                 return r;
 399
 400         ibs_request.number_of_ibs = 1;
 401         ibs_request.ibs = &ib_info;
 402         ibs_request.fence_info.handle = NULL;
 403
 404         r = amdgpu_cs_submit(context_handle, 0, &ibs_request, 1);
 405         if (r)
 406                 return r;
 407
 408         r = amdgpu_bo_list_destroy(ibs_request.resources);
 409         if (r)
 410                 return r;
 411
 412         fence_status.context = context_handle;
 413         fence_status.ip_type = ip;
 414         fence_status.fence = ibs_request.seq_no;
 415
 416         r = amdgpu_cs_query_fence_status(&fence_status,
 417                                          AMDGPU_TIMEOUT_INFINITE,
 418                                          0, &expired);
 419         if (r)
 420                 return r;
 421
 422         return 0;
 423 }
 424
 425 static void alloc_resource(struct amdgpu_vcn_bo *vcn_bo,
 426                         unsigned size, unsigned domain)
 427 {
 428         struct amdgpu_bo_alloc_request req = {0};
 429         amdgpu_bo_handle buf_handle;
 430         amdgpu_va_handle va_handle;
 431         uint64_t va = 0;
 432         int r;
 433
 434         req.alloc_size = ALIGN(size, 4096);
 435         req.preferred_heap = domain;
 436         r = amdgpu_bo_alloc(device_handle, &req, &buf_handle);
 437         CU_ASSERT_EQUAL(r, 0);
 438         r = amdgpu_va_range_alloc(device_handle,
 439                                   amdgpu_gpu_va_range_general,
 440                                   req.alloc_size, 1, 0, &va,
 441                                   &va_handle, 0);
 442         CU_ASSERT_EQUAL(r, 0);
 443         r = amdgpu_bo_va_op(buf_handle, 0, req.alloc_size, va, 0,
 444                             AMDGPU_VA_OP_MAP);
 445         CU_ASSERT_EQUAL(r, 0);
 446         vcn_bo->addr = va;
 447         vcn_bo->handle = buf_handle;
 448         vcn_bo->size = req.alloc_size;
 449         vcn_bo->va_handle = va_handle;
 450         r = amdgpu_bo_cpu_map(vcn_bo->handle, (void **)&vcn_bo->ptr);
 451         CU_ASSERT_EQUAL(r, 0);
 452         memset(vcn_bo->ptr, 0, size);
 453         r = amdgpu_bo_cpu_unmap(vcn_bo->handle);
 454         CU_ASSERT_EQUAL(r, 0);
 455 }
 456
 457 static void free_resource(struct amdgpu_vcn_bo *vcn_bo)
 458 {
 459         int r;
 460
 461         r = amdgpu_bo_va_op(vcn_bo->handle, 0, vcn_bo->size,
 462                             vcn_bo->addr, 0, AMDGPU_VA_OP_UNMAP);
 463         CU_ASSERT_EQUAL(r, 0);
 464
 465         r = amdgpu_va_range_free(vcn_bo->va_handle);
 466         CU_ASSERT_EQUAL(r, 0);
 467
 468         r = amdgpu_bo_free(vcn_bo->handle);
 469         CU_ASSERT_EQUAL(r, 0);
 470         memset(vcn_bo, 0, sizeof(*vcn_bo));
 471 }
 472
 473 static void vcn_dec_cmd(uint64_t addr, unsigned cmd, int *idx)
 474 {
 475         if (vcn_dec_sw_ring == false) {
 476                 ib_cpu[(*idx)++] = reg[vcn_reg_index].data0;
 477                 ib_cpu[(*idx)++] = addr;
 478                 ib_cpu[(*idx)++] = reg[vcn_reg_index].data1;
 479                 ib_cpu[(*idx)++] = addr >> 32;
 480                 ib_cpu[(*idx)++] = reg[vcn_reg_index].cmd;
 481                 ib_cpu[(*idx)++] = cmd << 1;
 482                 return;
 483         }
 484
 485         /* Support decode software ring message */
 486         if (!(*idx)) {
 487                 rvcn_decode_ib_package_t *ib_header;
 488
 489                 if (vcn_unified_ring)
 490                         amdgpu_cs_sq_head(ib_cpu, idx, false);
 491
 492                 ib_header = (rvcn_decode_ib_package_t *)&ib_cpu[*idx];
 493                 ib_header->package_size = sizeof(struct rvcn_decode_buffer_s) +
 494                         sizeof(struct rvcn_decode_ib_package_s);
 495
 496                 (*idx)++;
 497                 ib_header->package_type = (DECODE_IB_PARAM_DECODE_BUFFER);
 498                 (*idx)++;
 499
 500                 decode_buffer = (rvcn_decode_buffer_t *)&(ib_cpu[*idx]);
 501                 *idx += sizeof(struct rvcn_decode_buffer_s) / 4;
 502                 memset(decode_buffer, 0, sizeof(struct rvcn_decode_buffer_s));
 503         }
 504
 505         switch(cmd) {
 506                 case DECODE_CMD_MSG_BUFFER:
 507                         decode_buffer->valid_buf_flag |= DECODE_CMDBUF_FLAGS_MSG_BUFFER;
 508                         decode_buffer->msg_buffer_address_hi = (addr >> 32);
 509                         decode_buffer->msg_buffer_address_lo = (addr);
 510                 break;
 511                 case DECODE_CMD_DPB_BUFFER:
 512                         decode_buffer->valid_buf_flag |= (DECODE_CMDBUF_FLAGS_DPB_BUFFER);
 513                         decode_buffer->dpb_buffer_address_hi = (addr >> 32);
 514                         decode_buffer->dpb_buffer_address_lo = (addr);
 515                 break;
 516                 case DECODE_CMD_DECODING_TARGET_BUFFER:
 517                         decode_buffer->valid_buf_flag |= (DECODE_CMDBUF_FLAGS_DECODING_TARGET_BUFFER);
 518                         decode_buffer->target_buffer_address_hi = (addr >> 32);
 519                         decode_buffer->target_buffer_address_lo = (addr);
 520                 break;
 521                 case DECODE_CMD_FEEDBACK_BUFFER:
 522                         decode_buffer->valid_buf_flag |= (DECODE_CMDBUF_FLAGS_FEEDBACK_BUFFER);
 523                         decode_buffer->feedback_buffer_address_hi = (addr >> 32);
 524                         decode_buffer->feedback_buffer_address_lo = (addr);
 525                 break;
 526                 case DECODE_CMD_PROB_TBL_BUFFER:
 527                         decode_buffer->valid_buf_flag |= (DECODE_CMDBUF_FLAGS_PROB_TBL_BUFFER);
 528                         decode_buffer->prob_tbl_buffer_address_hi = (addr >> 32);
 529                         decode_buffer->prob_tbl_buffer_address_lo = (addr);
 530                 break;
 531                 case DECODE_CMD_SESSION_CONTEXT_BUFFER:
 532                         decode_buffer->valid_buf_flag |= (DECODE_CMDBUF_FLAGS_SESSION_CONTEXT_BUFFER);
 533                         decode_buffer->session_contex_buffer_address_hi = (addr >> 32);
 534                         decode_buffer->session_contex_buffer_address_lo = (addr);
 535                 break;
 536                 case DECODE_CMD_BITSTREAM_BUFFER:
 537                         decode_buffer->valid_buf_flag |= (DECODE_CMDBUF_FLAGS_BITSTREAM_BUFFER);
 538                         decode_buffer->bitstream_buffer_address_hi = (addr >> 32);
 539                         decode_buffer->bitstream_buffer_address_lo = (addr);
 540                 break;
 541                 case DECODE_CMD_IT_SCALING_TABLE_BUFFER:
 542                         decode_buffer->valid_buf_flag |= (DECODE_CMDBUF_FLAGS_IT_SCALING_BUFFER);
 543                         decode_buffer->it_sclr_table_buffer_address_hi = (addr >> 32);
 544                         decode_buffer->it_sclr_table_buffer_address_lo = (addr);
 545                 break;
 546                 case DECODE_CMD_CONTEXT_BUFFER:
 547                         decode_buffer->valid_buf_flag |= (DECODE_CMDBUF_FLAGS_CONTEXT_BUFFER);
 548                         decode_buffer->context_buffer_address_hi = (addr >> 32);
 549                         decode_buffer->context_buffer_address_lo = (addr);
 550                 break;
 551                 default:
 552                         printf("Not Support!\n");
 553         }
 554 }
 555
 556 static void amdgpu_cs_vcn_dec_create(void)
 557 {
 558         struct amdgpu_vcn_bo msg_buf;
 559         unsigned ip;
 560         int len, r;
 561
 562         num_resources  = 0;
 563         alloc_resource(&msg_buf, 4096, AMDGPU_GEM_DOMAIN_GTT);
 564         resources[num_resources++] = msg_buf.handle;
 565         resources[num_resources++] = ib_handle;
 566
 567         r = amdgpu_bo_cpu_map(msg_buf.handle, (void **)&msg_buf.ptr);
 568         CU_ASSERT_EQUAL(r, 0);
 569
 570         memset(msg_buf.ptr, 0, 4096);
 571         memcpy(msg_buf.ptr, vcn_dec_create_msg, sizeof(vcn_dec_create_msg));
 572
 573         len = 0;
 574         if (vcn_dec_sw_ring == true)
 575                 vcn_dec_cmd(msg_buf.addr, 0, &len);
 576         else {
 577                 ib_cpu[len++] = reg[vcn_reg_index].data0;
 578                 ib_cpu[len++] = msg_buf.addr;
 579                 ib_cpu[len++] = reg[vcn_reg_index].data1;
 580                 ib_cpu[len++] = msg_buf.addr >> 32;
 581                 ib_cpu[len++] = reg[vcn_reg_index].cmd;
 582                 ib_cpu[len++] = 0;
 583                 for (; len % 16; ) {
 584                         ib_cpu[len++] = reg[vcn_reg_index].nop;
 585                         ib_cpu[len++] = 0;
 586                 }
 587         }
 588
 589         if (vcn_unified_ring) {
 590                 amdgpu_cs_sq_ib_tail(ib_cpu + len);
 591                 ip = AMDGPU_HW_IP_VCN_ENC;
 592         } else
 593                 ip = AMDGPU_HW_IP_VCN_DEC;
 594
 595         r = submit(len, ip);
 596
 597         CU_ASSERT_EQUAL(r, 0);
 598
 599         free_resource(&msg_buf);
 600 }
 601
 602 static void amdgpu_cs_vcn_dec_decode(void)
 603 {
 604         const unsigned dpb_size = 15923584, dt_size = 737280;
 605         uint64_t msg_addr, fb_addr, bs_addr, dpb_addr, ctx_addr, dt_addr, it_addr, sum;
 606         struct amdgpu_vcn_bo dec_buf;
 607         int size, len, i, r;
 608         unsigned ip;
 609         uint8_t *dec;
 610
 611         size = 4*1024; /* msg */
 612         size += 4*1024; /* fb */
 613         size += 4096; /*it_scaling_table*/
 614         size += ALIGN(sizeof(uvd_bitstream), 4*1024);
 615         size += ALIGN(dpb_size, 4*1024);
 616         size += ALIGN(dt_size, 4*1024);
 617
 618         num_resources = 0;
 619         alloc_resource(&dec_buf, size, AMDGPU_GEM_DOMAIN_GTT);
 620         resources[num_resources++] = dec_buf.handle;
 621         resources[num_resources++] = ib_handle;
 622
 623         r = amdgpu_bo_cpu_map(dec_buf.handle, (void **)&dec_buf.ptr);
 624         dec = dec_buf.ptr;
 625
 626         CU_ASSERT_EQUAL(r, 0);
 627         memset(dec_buf.ptr, 0, size);
 628         memcpy(dec_buf.ptr, vcn_dec_decode_msg, sizeof(vcn_dec_decode_msg));
 629         memcpy(dec_buf.ptr + sizeof(vcn_dec_decode_msg),
 630                         avc_decode_msg, sizeof(avc_decode_msg));
 631
 632         dec += 4*1024;
 633         memcpy(dec, feedback_msg, sizeof(feedback_msg));
 634         dec += 4*1024;
 635         memcpy(dec, uvd_it_scaling_table, sizeof(uvd_it_scaling_table));
 636
 637         dec += 4*1024;
 638         memcpy(dec, uvd_bitstream, sizeof(uvd_bitstream));
 639
 640         dec += ALIGN(sizeof(uvd_bitstream), 4*1024);
 641
 642         dec += ALIGN(dpb_size, 4*1024);
 643
 644         msg_addr = dec_buf.addr;
 645         fb_addr = msg_addr + 4*1024;
 646         it_addr = fb_addr + 4*1024;
 647         bs_addr = it_addr + 4*1024;
 648         dpb_addr = ALIGN(bs_addr + sizeof(uvd_bitstream), 4*1024);
 649         ctx_addr = ALIGN(dpb_addr + 0x006B9400, 4*1024);
 650         dt_addr = ALIGN(dpb_addr + dpb_size, 4*1024);
 651
 652         len = 0;
 653         vcn_dec_cmd(msg_addr, 0x0, &len);
 654         vcn_dec_cmd(dpb_addr, 0x1, &len);
 655         vcn_dec_cmd(dt_addr, 0x2, &len);
 656         vcn_dec_cmd(fb_addr, 0x3, &len);
 657         vcn_dec_cmd(bs_addr, 0x100, &len);
 658         vcn_dec_cmd(it_addr, 0x204, &len);
 659         vcn_dec_cmd(ctx_addr, 0x206, &len);
 660
 661         if (vcn_dec_sw_ring == false) {
 662                 ib_cpu[len++] = reg[vcn_reg_index].cntl;
 663                 ib_cpu[len++] = 0x1;
 664                 for (; len % 16; ) {
 665                         ib_cpu[len++] = reg[vcn_reg_index].nop;
 666                         ib_cpu[len++] = 0;
 667                 }
 668         }
 669
 670         if (vcn_unified_ring) {
 671                 amdgpu_cs_sq_ib_tail(ib_cpu + len);
 672                 ip = AMDGPU_HW_IP_VCN_ENC;
 673         } else
 674                 ip = AMDGPU_HW_IP_VCN_DEC;
 675
 676         r = submit(len, ip);
 677         CU_ASSERT_EQUAL(r, 0);
 678
 679         for (i = 0, sum = 0; i < dt_size; ++i)
 680                 sum += dec[i];
 681
 682         CU_ASSERT_EQUAL(sum, SUM_DECODE);
 683
 684         free_resource(&dec_buf);
 685 }
 686
 687 static void amdgpu_cs_vcn_dec_destroy(void)
 688 {
 689         struct amdgpu_vcn_bo msg_buf;
 690         unsigned ip;
 691         int len, r;
 692
 693         num_resources = 0;
 694         alloc_resource(&msg_buf, 1024, AMDGPU_GEM_DOMAIN_GTT);
 695         resources[num_resources++] = msg_buf.handle;
 696         resources[num_resources++] = ib_handle;
 697
 698         r = amdgpu_bo_cpu_map(msg_buf.handle, (void **)&msg_buf.ptr);
 699         CU_ASSERT_EQUAL(r, 0);
 700
 701         memset(msg_buf.ptr, 0, 1024);
 702         memcpy(msg_buf.ptr, vcn_dec_destroy_msg, sizeof(vcn_dec_destroy_msg));
 703
 704         len = 0;
 705         if (vcn_dec_sw_ring == true)
 706                 vcn_dec_cmd(msg_buf.addr, 0, &len);
 707         else {
 708                 ib_cpu[len++] = reg[vcn_reg_index].data0;
 709                 ib_cpu[len++] = msg_buf.addr;
 710                 ib_cpu[len++] = reg[vcn_reg_index].data1;
 711                 ib_cpu[len++] = msg_buf.addr >> 32;
 712                 ib_cpu[len++] = reg[vcn_reg_index].cmd;
 713                 ib_cpu[len++] = 0;
 714                 for (; len % 16; ) {
 715                         ib_cpu[len++] = reg[vcn_reg_index].nop;
 716                         ib_cpu[len++] = 0;
 717                 }
 718         }
 719
 720         if (vcn_unified_ring) {
 721                 amdgpu_cs_sq_ib_tail(ib_cpu + len);
 722                 ip = AMDGPU_HW_IP_VCN_ENC;
 723         } else
 724                 ip = AMDGPU_HW_IP_VCN_DEC;
 725
 726         r = submit(len, ip);
 727         CU_ASSERT_EQUAL(r, 0);
 728
 729         free_resource(&msg_buf);
 730 }
 731
 732 static void amdgpu_cs_vcn_enc_create(void)
 733 {
 734         int len, r;
 735         uint32_t *p_task_size = NULL;
 736         uint32_t task_offset = 0, st_offset;
 737         uint32_t *st_size = NULL;
 738         unsigned width = 160, height = 128, buf_size;
 739         uint32_t fw_maj = 1, fw_min = 9;
 740
 741         if (vcn_ip_version_major == 2) {
 742                 fw_maj = 1;
 743                 fw_min = 1;
 744         } else if (vcn_ip_version_major == 3) {
 745                 fw_maj = 1;
 746                 fw_min = 0;
 747         }
 748
 749         gWidth = width;
 750         gHeight = height;
 751         buf_size = ALIGN(width, 256) * ALIGN(height, 32) * 3 / 2;
 752         enc_task_id = 1;
 753
 754         num_resources = 0;
 755         alloc_resource(&enc_buf, 128 * 1024, AMDGPU_GEM_DOMAIN_GTT);
 756         alloc_resource(&cpb_buf, buf_size * 2, AMDGPU_GEM_DOMAIN_GTT);
 757         resources[num_resources++] = enc_buf.handle;
 758         resources[num_resources++] = cpb_buf.handle;
 759         resources[num_resources++] = ib_handle;
 760
 761         r = amdgpu_bo_cpu_map(enc_buf.handle, (void**)&enc_buf.ptr);
 762         memset(enc_buf.ptr, 0, 128 * 1024);
 763         r = amdgpu_bo_cpu_unmap(enc_buf.handle);
 764
 765         r = amdgpu_bo_cpu_map(cpb_buf.handle, (void**)&enc_buf.ptr);
 766         memset(enc_buf.ptr, 0, buf_size * 2);
 767         r = amdgpu_bo_cpu_unmap(cpb_buf.handle);
 768
 769         len = 0;
 770
 771         if (vcn_unified_ring)
 772                 amdgpu_cs_sq_head(ib_cpu, &len, true);
 773
 774         /* session info */
 775         st_offset = len;
 776         st_size = &ib_cpu[len++];       /* size */
 777         ib_cpu[len++] = 0x00000001;     /* RENCODE_IB_PARAM_SESSION_INFO */
 778         ib_cpu[len++] = ((fw_maj << 16) | (fw_min << 0));
 779         ib_cpu[len++] = enc_buf.addr >> 32;
 780         ib_cpu[len++] = enc_buf.addr;
 781         ib_cpu[len++] = 1;      /* RENCODE_ENGINE_TYPE_ENCODE; */
 782         *st_size = (len - st_offset) * 4;
 783
 784         /* task info */
 785         task_offset = len;
 786         st_offset = len;
 787         st_size = &ib_cpu[len++];       /* size */
 788         ib_cpu[len++] = 0x00000002;     /* RENCODE_IB_PARAM_TASK_INFO */
 789         p_task_size = &ib_cpu[len++];
 790         ib_cpu[len++] = enc_task_id++;  /* task_id */
 791         ib_cpu[len++] = 0;      /* feedback */
 792         *st_size = (len - st_offset) * 4;
 793
 794         /* op init */
 795         st_offset = len;
 796         st_size = &ib_cpu[len++];       /* size */
 797         ib_cpu[len++] = 0x01000001;     /* RENCODE_IB_OP_INITIALIZE */
 798         *st_size = (len - st_offset) * 4;
 799
 800         /* session_init */
 801         st_offset = len;
 802         st_size = &ib_cpu[len++];       /* size */
 803         ib_cpu[len++] = 0x00000003;     /* RENCODE_IB_PARAM_SESSION_INIT */
 804         ib_cpu[len++] = 1;      /* RENCODE_ENCODE_STANDARD_H264 */
 805         ib_cpu[len++] = width;
 806         ib_cpu[len++] = height;
 807         ib_cpu[len++] = 0;
 808         ib_cpu[len++] = 0;
 809         ib_cpu[len++] = 0;      /* pre encode mode */
 810         ib_cpu[len++] = 0;      /* chroma enabled : false */
 811         *st_size = (len - st_offset) * 4;
 812
 813         /* slice control */
 814         st_offset = len;
 815         st_size = &ib_cpu[len++];       /* size */
 816         ib_cpu[len++] = 0x00200001;     /* RENCODE_H264_IB_PARAM_SLICE_CONTROL */
 817         ib_cpu[len++] = 0;      /* RENCODE_H264_SLICE_CONTROL_MODE_FIXED_MBS */
 818         ib_cpu[len++] = ALIGN(width, 16) / 16 * ALIGN(height, 16) / 16;
 819         *st_size = (len - st_offset) * 4;
 820
 821         /* enc spec misc */
 822         st_offset = len;
 823         st_size = &ib_cpu[len++];       /* size */
 824         ib_cpu[len++] = 0x00200002;     /* RENCODE_H264_IB_PARAM_SPEC_MISC */
 825         ib_cpu[len++] = 0;      /* constrained intra pred flag */
 826         ib_cpu[len++] = 0;      /* cabac enable */
 827         ib_cpu[len++] = 0;      /* cabac init idc */
 828         ib_cpu[len++] = 1;      /* half pel enabled */
 829         ib_cpu[len++] = 1;      /* quarter pel enabled */
 830         ib_cpu[len++] = 100;    /* BASELINE profile */
 831         ib_cpu[len++] = 11;     /* level */
 832         if (vcn_ip_version_major == 3) {
 833                 ib_cpu[len++] = 0;      /* b_picture_enabled */
 834                 ib_cpu[len++] = 0;      /* weighted_bipred_idc */
 835         }
 836         *st_size = (len - st_offset) * 4;
 837
 838         /* deblocking filter */
 839         st_offset = len;
 840         st_size = &ib_cpu[len++];       /* size */
 841         ib_cpu[len++] = 0x00200004;     /* RENCODE_H264_IB_PARAM_DEBLOCKING_FILTER */
 842         ib_cpu[len++] = 0;      /* disable deblocking filter idc */
 843         ib_cpu[len++] = 0;      /* alpha c0 offset */
 844         ib_cpu[len++] = 0;      /* tc offset */
 845         ib_cpu[len++] = 0;      /* cb offset */
 846         ib_cpu[len++] = 0;      /* cr offset */
 847         *st_size = (len - st_offset) * 4;
 848
 849         /* layer control */
 850         st_offset = len;
 851         st_size = &ib_cpu[len++];       /* size */
 852         ib_cpu[len++] = 0x00000004;     /* RENCODE_IB_PARAM_LAYER_CONTROL */
 853         ib_cpu[len++] = 1;      /* max temporal layer */
 854         ib_cpu[len++] = 1;      /* no of temporal layer */
 855         *st_size = (len - st_offset) * 4;
 856
 857         /* rc_session init */
 858         st_offset = len;
 859         st_size = &ib_cpu[len++];       /* size */
 860         ib_cpu[len++] = 0x00000006;     /* RENCODE_IB_PARAM_RATE_CONTROL_SESSION_INIT */
 861         ib_cpu[len++] = 0;      /* rate control */
 862         ib_cpu[len++] = 48;     /* vbv buffer level */
 863         *st_size = (len - st_offset) * 4;
 864
 865         /* quality params */
 866         st_offset = len;
 867         st_size = &ib_cpu[len++];       /* size */
 868         ib_cpu[len++] = 0x00000009;     /* RENCODE_IB_PARAM_QUALITY_PARAMS */
 869         ib_cpu[len++] = 0;      /* vbaq mode */
 870         ib_cpu[len++] = 0;      /* scene change sensitivity */
 871         ib_cpu[len++] = 0;      /* scene change min idr interval */
 872         ib_cpu[len++] = 0;
 873         if (vcn_ip_version_major == 3)
 874                 ib_cpu[len++] = 0;
 875         *st_size = (len - st_offset) * 4;
 876
 877         /* layer select */
 878         st_offset = len;
 879         st_size = &ib_cpu[len++];       /* size */
 880         ib_cpu[len++] = 0x00000005;     /* RENCODE_IB_PARAM_LAYER_SELECT */
 881         ib_cpu[len++] = 0;      /* temporal layer */
 882         *st_size = (len - st_offset) * 4;
 883
 884         /* rc layer init */
 885         st_offset = len;
 886         st_size = &ib_cpu[len++];       /* size */
 887         ib_cpu[len++] = 0x00000007;     /* RENCODE_IB_PARAM_RATE_CONTROL_LAYER_INIT */
 888         ib_cpu[len++] = 0;
 889         ib_cpu[len++] = 0;
 890         ib_cpu[len++] = 25;
 891         ib_cpu[len++] = 1;
 892         ib_cpu[len++] = 0x01312d00;
 893         ib_cpu[len++] = 0;
 894         ib_cpu[len++] = 0;
 895         ib_cpu[len++] = 0;
 896         *st_size = (len - st_offset) * 4;
 897
 898         /* layer select */
 899         st_offset = len;
 900         st_size = &ib_cpu[len++];       /* size */
 901         ib_cpu[len++] = 0x00000005;     /* RENCODE_IB_PARAM_LAYER_SELECT */
 902         ib_cpu[len++] = 0;      /* temporal layer */
 903         *st_size = (len - st_offset) * 4;
 904
 905         /* rc per pic */
 906         st_offset = len;
 907         st_size = &ib_cpu[len++];       /* size */
 908         ib_cpu[len++] = 0x00000008;     /* RENCODE_IB_PARAM_RATE_CONTROL_PER_PICTURE */
 909         ib_cpu[len++] = 20;
 910         ib_cpu[len++] = 0;
 911         ib_cpu[len++] = 51;
 912         ib_cpu[len++] = 0;
 913         ib_cpu[len++] = 1;
 914         ib_cpu[len++] = 0;
 915         ib_cpu[len++] = 1;
 916         *st_size = (len - st_offset) * 4;
 917
 918         /* op init rc */
 919         st_offset = len;
 920         st_size = &ib_cpu[len++];       /* size */
 921         ib_cpu[len++] = 0x01000004;     /* RENCODE_IB_OP_INIT_RC */
 922         *st_size = (len - st_offset) * 4;
 923
 924         /* op init rc vbv */
 925         st_offset = len;
 926         st_size = &ib_cpu[len++];       /* size */
 927         ib_cpu[len++] = 0x01000005;     /* RENCODE_IB_OP_INIT_RC_VBV_BUFFER_LEVEL */
 928         *st_size = (len - st_offset) * 4;
 929
 930         *p_task_size = (len - task_offset) * 4;
 931
 932         if (vcn_unified_ring)
 933                 amdgpu_cs_sq_ib_tail(ib_cpu + len);
 934
 935         r = submit(len, AMDGPU_HW_IP_VCN_ENC);
 936         CU_ASSERT_EQUAL(r, 0);
 937 }
 938
 939 static int32_t h264_se (bufferInfo * bufInfo)
 940 {
 941         uint32_t ret;
 942
 943         ret = bs_read_ue (bufInfo);
 944         if ((ret & 0x1) == 0) {
 945                 ret >>= 1;
 946                 int32_t temp = 0 - ret;
 947                 return temp;
 948         }
 949
 950         return (ret + 1) >> 1;
 951 }
 952
 953 static void h264_check_0s (bufferInfo * bufInfo, int count)
 954 {
 955         uint32_t val;
 956
 957         val = bs_read_u (bufInfo, count);
 958         if (val != 0) {
 959                 printf ("field error - %d bits should be 0 is %x\n", count, val);
 960         }
 961 }
 962
 963 static inline int bs_eof(bufferInfo * bufinfo)
 964 {
 965         if (bufinfo->decBuffer >= bufinfo->end)
 966                 return 1;
 967         else
 968                 return 0;
 969 }
 970
 971 static inline uint32_t bs_read_u1(bufferInfo *bufinfo)
 972 {
 973         uint32_t r = 0;
 974         uint32_t temp = 0;
 975
 976         bufinfo->numOfBitsInBuffer--;
 977         if (! bs_eof(bufinfo)) {
 978                 temp = (((bufinfo->decData)) >> bufinfo->numOfBitsInBuffer);
 979                 r = temp & 0x01;
 980         }
 981
 982         if (bufinfo->numOfBitsInBuffer == 0) {
 983                 bufinfo->decBuffer++;
 984                 bufinfo->decData = *bufinfo->decBuffer;
 985                 bufinfo->numOfBitsInBuffer = 8;
 986         }
 987
 988         return r;
 989 }
 990
 991 static inline uint32_t bs_read_u(bufferInfo* bufinfo, int n)
 992 {
 993         uint32_t r = 0;
 994         int i;
 995
 996         for (i = 0; i < n; i++) {
 997                 r |= ( bs_read_u1(bufinfo) << ( n - i - 1 ) );
 998         }
 999
1000         return r;
1001 }
1002
1003 static inline uint32_t bs_read_ue(bufferInfo* bufinfo)
1004 {
1005         int32_t r = 0;
1006         int i = 0;
1007
1008         while( (bs_read_u1(bufinfo) == 0) && (i < 32) && (!bs_eof(bufinfo))) {
1009                 i++;
1010         }
1011         r = bs_read_u(bufinfo, i);
1012         r += (1 << i) - 1;
1013         return r;
1014 }
1015
1016 static uint32_t remove_03 (uint8_t * bptr, uint32_t len)
1017 {
1018         uint32_t nal_len = 0;
1019         while (nal_len + 2 < len) {
1020                 if (bptr[0] == 0 && bptr[1] == 0 && bptr[2] == 3) {
1021                         bptr += 2;
1022                         nal_len += 2;
1023                         len--;
1024                         memmove (bptr, bptr + 1, len - nal_len);
1025                 } else {
1026                         bptr++;
1027                         nal_len++;
1028                 }
1029         }
1030         return len;
1031 }
1032
1033 static void scaling_list (uint32_t ix, uint32_t sizeOfScalingList, bufferInfo * bufInfo)
1034 {
1035         uint32_t lastScale = 8, nextScale = 8;
1036         uint32_t jx;
1037         int deltaScale;
1038
1039         for (jx = 0; jx < sizeOfScalingList; jx++) {
1040                 if (nextScale != 0) {
1041                         deltaScale = h264_se (bufInfo);
1042                         nextScale = (lastScale + deltaScale + 256) % 256;
1043                 }
1044                 if (nextScale == 0) {
1045                         lastScale = lastScale;
1046                 } else {
1047                         lastScale = nextScale;
1048                 }
1049         }
1050 }
1051
1052 static void h264_parse_sequence_parameter_set (h264_decode * dec, bufferInfo * bufInfo)
1053 {
1054         uint32_t temp;
1055
1056         dec->profile = bs_read_u (bufInfo, 8);
1057         bs_read_u (bufInfo, 1);         /* constaint_set0_flag */
1058         bs_read_u (bufInfo, 1);         /* constaint_set1_flag */
1059         bs_read_u (bufInfo, 1);         /* constaint_set2_flag */
1060         bs_read_u (bufInfo, 1);         /* constaint_set3_flag */
1061         bs_read_u (bufInfo, 1);         /* constaint_set4_flag */
1062         bs_read_u (bufInfo, 1);         /* constaint_set5_flag */
1063
1064
1065         h264_check_0s (bufInfo, 2);
1066         dec->level_idc = bs_read_u (bufInfo, 8);
1067         bs_read_ue (bufInfo);   /* SPS id*/
1068
1069         if (dec->profile == 100 || dec->profile == 110 ||
1070                 dec->profile == 122 || dec->profile == 144) {
1071                 uint32_t chroma_format_idc = bs_read_ue (bufInfo);
1072                 if (chroma_format_idc == 3) {
1073                         bs_read_u (bufInfo, 1); /* residual_colour_transform_flag */
1074                 }
1075                 bs_read_ue (bufInfo);   /* bit_depth_luma_minus8 */
1076                 bs_read_ue (bufInfo);   /* bit_depth_chroma_minus8 */
1077                 bs_read_u (bufInfo, 1); /* qpprime_y_zero_transform_bypass_flag */
1078                 uint32_t seq_scaling_matrix_present_flag = bs_read_u (bufInfo, 1);
1079
1080                 if (seq_scaling_matrix_present_flag) {
1081                         for (uint32_t ix = 0; ix < 8; ix++) {
1082                                 temp = bs_read_u (bufInfo, 1);
1083                                 if (temp) {
1084                                         scaling_list (ix, ix < 6 ? 16 : 64, bufInfo);
1085                                 }
1086                         }
1087                 }
1088         }
1089
1090         bs_read_ue (bufInfo);   /* log2_max_frame_num_minus4 */
1091         uint32_t pic_order_cnt_type = bs_read_ue (bufInfo);
1092
1093         if (pic_order_cnt_type == 0) {
1094                 bs_read_ue (bufInfo);   /* log2_max_pic_order_cnt_lsb_minus4 */
1095         } else if (pic_order_cnt_type == 1) {
1096                 bs_read_u (bufInfo, 1); /* delta_pic_order_always_zero_flag */
1097                 h264_se (bufInfo);      /* offset_for_non_ref_pic */
1098                 h264_se (bufInfo);      /* offset_for_top_to_bottom_field */
1099                 temp = bs_read_ue (bufInfo);
1100                 for (uint32_t ix = 0; ix < temp; ix++) {
1101                          h264_se (bufInfo);     /* offset_for_ref_frame[index] */
1102                 }
1103         }
1104         bs_read_ue (bufInfo);   /* num_ref_frames */
1105         bs_read_u (bufInfo, 1); /* gaps_in_frame_num_flag */
1106         uint32_t PicWidthInMbs = bs_read_ue (bufInfo) + 1;
1107
1108         dec->pic_width = PicWidthInMbs * 16;
1109         uint32_t PicHeightInMapUnits = bs_read_ue (bufInfo) + 1;
1110
1111         dec->pic_height = PicHeightInMapUnits * 16;
1112         uint32_t frame_mbs_only_flag = bs_read_u (bufInfo, 1);
1113         if (!frame_mbs_only_flag) {
1114                 bs_read_u (bufInfo, 1); /* mb_adaptive_frame_field_flag */
1115         }
1116         bs_read_u (bufInfo, 1); /* direct_8x8_inference_flag */
1117         temp = bs_read_u (bufInfo, 1);
1118         if (temp) {
1119                 bs_read_ue (bufInfo);   /* frame_crop_left_offset */
1120                 bs_read_ue (bufInfo);   /* frame_crop_right_offset */
1121                 bs_read_ue (bufInfo);   /* frame_crop_top_offset */
1122                 bs_read_ue (bufInfo);   /* frame_crop_bottom_offset */
1123         }
1124         temp = bs_read_u (bufInfo, 1);  /* VUI Parameters  */
1125 }
1126
1127 static void h264_slice_header (h264_decode * dec, bufferInfo * bufInfo)
1128 {
1129         uint32_t temp;
1130
1131         bs_read_ue (bufInfo);   /* first_mb_in_slice */
1132         temp = bs_read_ue (bufInfo);
1133         dec->slice_type = ((temp > 5) ? (temp - 5) : temp);
1134 }
1135
1136 static uint8_t h264_parse_nal (h264_decode * dec, bufferInfo * bufInfo)
1137 {
1138         uint8_t type = 0;
1139
1140         h264_check_0s (bufInfo, 1);
1141         dec->nal_ref_idc = bs_read_u (bufInfo, 2);
1142         dec->nal_unit_type = type = bs_read_u (bufInfo, 5);
1143         switch (type)
1144         {
1145         case H264_NAL_TYPE_NON_IDR_SLICE:
1146         case H264_NAL_TYPE_IDR_SLICE:
1147                 h264_slice_header (dec, bufInfo);
1148                 break;
1149         case H264_NAL_TYPE_SEQ_PARAM:
1150                 h264_parse_sequence_parameter_set (dec, bufInfo);
1151                 break;
1152         case H264_NAL_TYPE_PIC_PARAM:
1153         case H264_NAL_TYPE_SEI:
1154         case H264_NAL_TYPE_ACCESS_UNIT:
1155         case H264_NAL_TYPE_SEQ_EXTENSION:
1156                 /* NOP */
1157                 break;
1158         default:
1159                 printf ("Nal type unknown %d \n ", type);
1160                 break;
1161         }
1162         return type;
1163 }
1164
1165 static uint32_t h264_find_next_start_code (uint8_t * pBuf, uint32_t bufLen)
1166 {
1167         uint32_t val;
1168         uint32_t offset, startBytes;
1169
1170         offset = startBytes = 0;
1171         if (pBuf[0] == 0 && pBuf[1] == 0 && pBuf[2] == 0 && pBuf[3] == 1) {
1172                 pBuf += 4;
1173                 offset = 4;
1174                 startBytes = 1;
1175         } else if (pBuf[0] == 0 && pBuf[1] == 0 && pBuf[2] == 1) {
1176                 pBuf += 3;
1177                 offset = 3;
1178                 startBytes = 1;
1179         }
1180         val = 0xffffffff;
1181         while (offset < bufLen - 3) {
1182                 val <<= 8;
1183                 val |= *pBuf++;
1184                 offset++;
1185                 if (val == H264_START_CODE)
1186                         return offset - 4;
1187
1188                 if ((val & 0x00ffffff) == H264_START_CODE)
1189                         return offset - 3;
1190         }
1191         if (bufLen - offset <= 3 && startBytes == 0) {
1192                 startBytes = 0;
1193                 return 0;
1194         }
1195
1196         return offset;
1197 }
1198
1199 static int verify_checksum(uint8_t *buffer, uint32_t buffer_size)
1200 {
1201         uint32_t buffer_pos = 0;
1202         int done = 0;
1203         h264_decode dec;
1204
1205         memset(&dec, 0, sizeof(h264_decode));
1206         do {
1207                 uint32_t ret;
1208
1209                 ret = h264_find_next_start_code (buffer + buffer_pos,
1210                                  buffer_size - buffer_pos);
1211                 if (ret == 0) {
1212                         done = 1;
1213                         if (buffer_pos == 0) {
1214                                 fprintf (stderr,
1215                                  "couldn't find start code in buffer from 0\n");
1216                         }
1217                 } else {
1218                 /* have a complete NAL from buffer_pos to end */
1219                         if (ret > 3) {
1220                                 uint32_t nal_len;
1221                                 bufferInfo bufinfo;
1222
1223                                 nal_len = remove_03 (buffer + buffer_pos, ret);
1224                                 bufinfo.decBuffer = buffer + buffer_pos + (buffer[buffer_pos + 2] == 1 ? 3 : 4);
1225                                 bufinfo.decBufferSize = (nal_len - (buffer[buffer_pos + 2] == 1 ? 3 : 4)) * 8;
1226                                 bufinfo.end = buffer + buffer_pos + nal_len;
1227                                 bufinfo.numOfBitsInBuffer = 8;
1228                                 bufinfo.decData = *bufinfo.decBuffer;
1229                                 h264_parse_nal (&dec, &bufinfo);
1230                         }
1231                         buffer_pos += ret;      /*  buffer_pos points to next code */
1232                 }
1233         } while (done == 0);
1234
1235         if ((dec.pic_width == gWidth) &&
1236                 (dec.pic_height == gHeight) &&
1237                 (dec.slice_type == gSliceType))
1238             return 0;
1239         else
1240                 return -1;
1241 }
1242
1243 static void check_result(struct amdgpu_vcn_bo fb_buf, struct amdgpu_vcn_bo bs_buf, int frame_type)
1244 {
1245         uint32_t *fb_ptr;
1246         uint8_t *bs_ptr;
1247         uint32_t size;
1248         int r;
1249 /*      uint64_t s[3] = {0, 1121279001727, 1059312481445}; */
1250
1251         r = amdgpu_bo_cpu_map(fb_buf.handle, (void **)&fb_buf.ptr);
1252         CU_ASSERT_EQUAL(r, 0);
1253         fb_ptr = (uint32_t*)fb_buf.ptr;
1254         size = fb_ptr[6];
1255         r = amdgpu_bo_cpu_unmap(fb_buf.handle);
1256         CU_ASSERT_EQUAL(r, 0);
1257         r = amdgpu_bo_cpu_map(bs_buf.handle, (void **)&bs_buf.ptr);
1258         CU_ASSERT_EQUAL(r, 0);
1259
1260         bs_ptr = (uint8_t*)bs_buf.ptr;
1261         r = verify_checksum(bs_ptr, size);
1262         CU_ASSERT_EQUAL(r, 0);
1263         r = amdgpu_bo_cpu_unmap(bs_buf.handle);
1264
1265         CU_ASSERT_EQUAL(r, 0);
1266 }
1267
1268 static void amdgpu_cs_vcn_enc_encode_frame(int frame_type)
1269 {
1270         struct amdgpu_vcn_bo bs_buf, fb_buf, input_buf;
1271         int len, r, i;
1272         unsigned width = 160, height = 128, buf_size;
1273         uint32_t *p_task_size = NULL;
1274         uint32_t task_offset = 0, st_offset;
1275         uint32_t *st_size = NULL;
1276         uint32_t fw_maj = 1, fw_min = 9;
1277
1278         if (vcn_ip_version_major == 2) {
1279                 fw_maj = 1;
1280                 fw_min = 1;
1281         } else if (vcn_ip_version_major == 3) {
1282                 fw_maj = 1;
1283                 fw_min = 0;
1284         }
1285         gSliceType = frame_type;
1286         buf_size = ALIGN(width, 256) * ALIGN(height, 32) * 3 / 2;
1287
1288         num_resources = 0;
1289         alloc_resource(&bs_buf, 4096, AMDGPU_GEM_DOMAIN_GTT);
1290         alloc_resource(&fb_buf, 4096, AMDGPU_GEM_DOMAIN_GTT);
1291         alloc_resource(&input_buf, buf_size, AMDGPU_GEM_DOMAIN_GTT);
1292         resources[num_resources++] = enc_buf.handle;
1293         resources[num_resources++] = cpb_buf.handle;
1294         resources[num_resources++] = bs_buf.handle;
1295         resources[num_resources++] = fb_buf.handle;
1296         resources[num_resources++] = input_buf.handle;
1297         resources[num_resources++] = ib_handle;
1298
1299
1300         r = amdgpu_bo_cpu_map(bs_buf.handle, (void**)&bs_buf.ptr);
1301         memset(bs_buf.ptr, 0, 4096);
1302         r = amdgpu_bo_cpu_unmap(bs_buf.handle);
1303
1304         r = amdgpu_bo_cpu_map(fb_buf.handle, (void**)&fb_buf.ptr);
1305         memset(fb_buf.ptr, 0, 4096);
1306         r = amdgpu_bo_cpu_unmap(fb_buf.handle);
1307
1308         r = amdgpu_bo_cpu_map(input_buf.handle, (void **)&input_buf.ptr);
1309         CU_ASSERT_EQUAL(r, 0);
1310
1311         for (int i = 0; i < ALIGN(height, 32) * 3 / 2; i++)
1312                 memcpy(input_buf.ptr + i * ALIGN(width, 256), frame + i * width, width);
1313
1314         r = amdgpu_bo_cpu_unmap(input_buf.handle);
1315         CU_ASSERT_EQUAL(r, 0);
1316
1317         len = 0;
1318
1319         if (vcn_unified_ring)
1320                 amdgpu_cs_sq_head(ib_cpu, &len, true);
1321
1322         /* session info */
1323         st_offset = len;
1324         st_size = &ib_cpu[len++];       /* size */
1325         ib_cpu[len++] = 0x00000001;     /* RENCODE_IB_PARAM_SESSION_INFO */
1326         ib_cpu[len++] = ((fw_maj << 16) | (fw_min << 0));
1327         ib_cpu[len++] = enc_buf.addr >> 32;
1328         ib_cpu[len++] = enc_buf.addr;
1329         ib_cpu[len++] = 1;      /* RENCODE_ENGINE_TYPE_ENCODE */;
1330         *st_size = (len - st_offset) * 4;
1331
1332         /* task info */
1333         task_offset = len;
1334         st_offset = len;
1335         st_size = &ib_cpu[len++];       /* size */
1336         ib_cpu[len++] = 0x00000002;     /* RENCODE_IB_PARAM_TASK_INFO */
1337         p_task_size = &ib_cpu[len++];
1338         ib_cpu[len++] = enc_task_id++;  /* task_id */
1339         ib_cpu[len++] = 1;      /* feedback */
1340         *st_size = (len - st_offset) * 4;
1341
1342         if (frame_type == 2) {
1343                 /* sps */
1344                 st_offset = len;
1345                 st_size = &ib_cpu[len++];       /* size */
1346                 if(vcn_ip_version_major == 1)
1347                         ib_cpu[len++] = 0x00000020;     /* RENCODE_IB_PARAM_DIRECT_OUTPUT_NALU vcn 1 */
1348                 else
1349                         ib_cpu[len++] = 0x0000000a;     /* RENCODE_IB_PARAM_DIRECT_OUTPUT_NALU vcn 2,3 */
1350                 ib_cpu[len++] = 0x00000002;     /* RENCODE_DIRECT_OUTPUT_NALU_TYPE_SPS */
1351                 ib_cpu[len++] = 0x00000011;     /* sps len */
1352                 ib_cpu[len++] = 0x00000001;     /* start code */
1353                 ib_cpu[len++] = 0x6764440b;
1354                 ib_cpu[len++] = 0xac54c284;
1355                 ib_cpu[len++] = 0x68078442;
1356                 ib_cpu[len++] = 0x37000000;
1357                 *st_size = (len - st_offset) * 4;
1358
1359                 /* pps */
1360                 st_offset = len;
1361                 st_size = &ib_cpu[len++];       /* size */
1362                 if(vcn_ip_version_major == 1)
1363                         ib_cpu[len++] = 0x00000020;     /* RENCODE_IB_PARAM_DIRECT_OUTPUT_NALU vcn 1*/
1364                 else
1365                         ib_cpu[len++] = 0x0000000a;     /* RENCODE_IB_PARAM_DIRECT_OUTPUT_NALU vcn 2,3*/
1366                 ib_cpu[len++] = 0x00000003;     /* RENCODE_DIRECT_OUTPUT_NALU_TYPE_PPS */
1367                 ib_cpu[len++] = 0x00000008;     /* pps len */
1368                 ib_cpu[len++] = 0x00000001;     /* start code */
1369                 ib_cpu[len++] = 0x68ce3c80;
1370                 *st_size = (len - st_offset) * 4;
1371         }
1372
1373         /* slice header */
1374         st_offset = len;
1375         st_size = &ib_cpu[len++];       /* size */
1376         if(vcn_ip_version_major == 1)
1377                 ib_cpu[len++] = 0x0000000a; /* RENCODE_IB_PARAM_SLICE_HEADER vcn 1 */
1378         else
1379                 ib_cpu[len++] = 0x0000000b; /* RENCODE_IB_PARAM_SLICE_HEADER vcn 2,3 */
1380         if (frame_type == 2) {
1381                 ib_cpu[len++] = 0x65000000;
1382                 ib_cpu[len++] = 0x11040000;
1383         } else {
1384                 ib_cpu[len++] = 0x41000000;
1385                 ib_cpu[len++] = 0x34210000;
1386         }
1387         ib_cpu[len++] = 0xe0000000;
1388         for(i = 0; i < 13; i++)
1389                 ib_cpu[len++] = 0x00000000;
1390
1391         ib_cpu[len++] = 0x00000001;
1392         ib_cpu[len++] = 0x00000008;
1393         ib_cpu[len++] = 0x00020000;
1394         ib_cpu[len++] = 0x00000000;
1395         ib_cpu[len++] = 0x00000001;
1396         ib_cpu[len++] = 0x00000015;
1397         ib_cpu[len++] = 0x00020001;
1398         ib_cpu[len++] = 0x00000000;
1399         ib_cpu[len++] = 0x00000001;
1400         ib_cpu[len++] = 0x00000003;
1401         for(i = 0; i < 22; i++)
1402                 ib_cpu[len++] = 0x00000000;
1403
1404         *st_size = (len - st_offset) * 4;
1405
1406         /* encode params */
1407         st_offset = len;
1408         st_size = &ib_cpu[len++];       /* size */
1409         if(vcn_ip_version_major == 1)
1410                 ib_cpu[len++] = 0x0000000b;     /* RENCODE_IB_PARAM_ENCODE_PARAMS vcn 1*/
1411         else
1412                 ib_cpu[len++] = 0x0000000f;     /* RENCODE_IB_PARAM_ENCODE_PARAMS vcn 2,3*/
1413         ib_cpu[len++] = frame_type;
1414         ib_cpu[len++] = 0x0001f000;
1415         ib_cpu[len++] = input_buf.addr >> 32;
1416         ib_cpu[len++] = input_buf.addr;
1417         ib_cpu[len++] = (input_buf.addr + ALIGN(width, 256) * ALIGN(height, 32)) >> 32;
1418         ib_cpu[len++] = input_buf.addr + ALIGN(width, 256) * ALIGN(height, 32);
1419         ib_cpu[len++] = 0x00000100;
1420         ib_cpu[len++] = 0x00000080;
1421         ib_cpu[len++] = 0x00000000;
1422         ib_cpu[len++] = 0xffffffff;
1423         ib_cpu[len++] = 0x00000000;
1424         *st_size = (len - st_offset) * 4;
1425
1426         /* encode params h264 */
1427         st_offset = len;
1428         st_size = &ib_cpu[len++];       /* size */
1429         ib_cpu[len++] = 0x00200003;     /* RENCODE_H264_IB_PARAM_ENCODE_PARAMS */
1430         if (vcn_ip_version_major != 3) {
1431                 ib_cpu[len++] = 0x00000000;
1432                 ib_cpu[len++] = 0x00000000;
1433                 ib_cpu[len++] = 0x00000000;
1434                 ib_cpu[len++] = 0xffffffff;
1435         } else {
1436                 ib_cpu[len++] = 0x00000000;
1437                 ib_cpu[len++] = 0x00000000;
1438                 ib_cpu[len++] = 0x00000000;
1439                 ib_cpu[len++] = 0x00000000;
1440                 ib_cpu[len++] = 0x00000000;
1441                 ib_cpu[len++] = 0x00000000;
1442                 ib_cpu[len++] = 0x00000000;
1443                 ib_cpu[len++] = 0xffffffff;
1444                 ib_cpu[len++] = 0x00000000;
1445                 ib_cpu[len++] = 0x00000000;
1446                 ib_cpu[len++] = 0x00000000;
1447                 ib_cpu[len++] = 0x00000000;
1448                 ib_cpu[len++] = 0xffffffff;
1449                 ib_cpu[len++] = 0x00000000;
1450                 ib_cpu[len++] = 0x00000000;
1451                 ib_cpu[len++] = 0x00000000;
1452                 ib_cpu[len++] = 0x00000000;
1453         }
1454         *st_size = (len - st_offset) * 4;
1455
1456         /* encode context */
1457         st_offset = len;
1458         st_size = &ib_cpu[len++];       /* size */
1459         if(vcn_ip_version_major == 1)
1460                 ib_cpu[len++] = 0x0000000d;     /* ENCODE_CONTEXT_BUFFER  vcn 1 */
1461         else
1462                 ib_cpu[len++] = 0x00000011;     /* ENCODE_CONTEXT_BUFFER  vcn 2,3 */
1463         ib_cpu[len++] = cpb_buf.addr >> 32;
1464         ib_cpu[len++] = cpb_buf.addr;
1465         ib_cpu[len++] = 0x00000000;     /* swizzle mode */
1466         ib_cpu[len++] = 0x00000100;     /* luma pitch */
1467         ib_cpu[len++] = 0x00000100;     /* chroma pitch */
1468         ib_cpu[len++] = 0x00000003; /* no reconstructed picture */
1469         ib_cpu[len++] = 0x00000000;     /* reconstructed pic 1 luma offset */
1470         ib_cpu[len++] = ALIGN(width, 256) * ALIGN(height, 32);  /* pic1 chroma offset */
1471         ib_cpu[len++] = ALIGN(width, 256) * ALIGN(height, 32) * 3 / 2;  /* pic2 luma offset */
1472         ib_cpu[len++] = ALIGN(width, 256) * ALIGN(height, 32) * 5 / 2;  /* pic2 chroma offset */
1473
1474         for (int i = 0; i < 136; i++)
1475                 ib_cpu[len++] = 0x00000000;
1476         *st_size = (len - st_offset) * 4;
1477
1478         /* bitstream buffer */
1479         st_offset = len;
1480         st_size = &ib_cpu[len++];       /* size */
1481         if(vcn_ip_version_major == 1)
1482                 ib_cpu[len++] = 0x0000000e;     /* VIDEO_BITSTREAM_BUFFER vcn 1 */
1483         else
1484                 ib_cpu[len++] = 0x00000012;     /* VIDEO_BITSTREAM_BUFFER vcn 2,3 */
1485         ib_cpu[len++] = 0x00000000;     /* mode */
1486         ib_cpu[len++] = bs_buf.addr >> 32;
1487         ib_cpu[len++] = bs_buf.addr;
1488         ib_cpu[len++] = 0x0001f000;
1489         ib_cpu[len++] = 0x00000000;
1490         *st_size = (len - st_offset) * 4;
1491
1492         /* feedback */
1493         st_offset = len;
1494         st_size = &ib_cpu[len++];       /* size */
1495         if(vcn_ip_version_major == 1)
1496                 ib_cpu[len++] = 0x00000010;     /* FEEDBACK_BUFFER vcn 1 */
1497         else
1498                 ib_cpu[len++] = 0x00000015;     /* FEEDBACK_BUFFER vcn 2,3 */
1499         ib_cpu[len++] = 0x00000000;
1500         ib_cpu[len++] = fb_buf.addr >> 32;
1501         ib_cpu[len++] = fb_buf.addr;
1502         ib_cpu[len++] = 0x00000010;
1503         ib_cpu[len++] = 0x00000028;
1504         *st_size = (len - st_offset) * 4;
1505
1506         /* intra refresh */
1507         st_offset = len;
1508         st_size = &ib_cpu[len++];
1509         if(vcn_ip_version_major == 1)
1510                 ib_cpu[len++] = 0x0000000c;     /* INTRA_REFRESH vcn 1 */
1511         else
1512                 ib_cpu[len++] = 0x00000010;     /* INTRA_REFRESH vcn 2,3 */
1513         ib_cpu[len++] = 0x00000000;
1514         ib_cpu[len++] = 0x00000000;
1515         ib_cpu[len++] = 0x00000000;
1516         *st_size = (len - st_offset) * 4;
1517
1518         if(vcn_ip_version_major != 1) {
1519                 /* Input Format */
1520                 st_offset = len;
1521                 st_size = &ib_cpu[len++];
1522                 ib_cpu[len++] = 0x0000000c;
1523                 ib_cpu[len++] = 0x00000000;     /* RENCODE_COLOR_VOLUME_G22_BT709 */
1524                 ib_cpu[len++] = 0x00000000;
1525                 ib_cpu[len++] = 0x00000000;
1526                 ib_cpu[len++] = 0x00000000;
1527                 ib_cpu[len++] = 0x00000000;
1528                 ib_cpu[len++] = 0x00000000;     /* RENCODE_COLOR_BIT_DEPTH_8_BIT */
1529                 ib_cpu[len++] = 0x00000000;     /* RENCODE_COLOR_PACKING_FORMAT_NV12 */
1530                 *st_size = (len - st_offset) * 4;
1531
1532                 /* Output Format */
1533                 st_offset = len;
1534                 st_size = &ib_cpu[len++];
1535                 ib_cpu[len++] = 0x0000000d;
1536                 ib_cpu[len++] = 0x00000000;     /* RENCODE_COLOR_VOLUME_G22_BT709 */
1537                 ib_cpu[len++] = 0x00000000;
1538                 ib_cpu[len++] = 0x00000000;
1539                 ib_cpu[len++] = 0x00000000;     /* RENCODE_COLOR_BIT_DEPTH_8_BIT */
1540                 *st_size = (len - st_offset) * 4;
1541         }
1542         /* op_speed */
1543         st_offset = len;
1544         st_size = &ib_cpu[len++];
1545         ib_cpu[len++] = 0x01000006;     /* SPEED_ENCODING_MODE */
1546         *st_size = (len - st_offset) * 4;
1547
1548         /* op_enc */
1549         st_offset = len;
1550         st_size = &ib_cpu[len++];
1551         ib_cpu[len++] = 0x01000003;
1552         *st_size = (len - st_offset) * 4;
1553
1554         *p_task_size = (len - task_offset) * 4;
1555
1556         if (vcn_unified_ring)
1557                 amdgpu_cs_sq_ib_tail(ib_cpu + len);
1558
1559         r = submit(len, AMDGPU_HW_IP_VCN_ENC);
1560         CU_ASSERT_EQUAL(r, 0);
1561
1562         /* check result */
1563         check_result(fb_buf, bs_buf, frame_type);
1564
1565         free_resource(&fb_buf);
1566         free_resource(&bs_buf);
1567         free_resource(&input_buf);
1568 }
1569
1570 static void amdgpu_cs_vcn_enc_encode(void)
1571 {
1572         amdgpu_cs_vcn_enc_encode_frame(2);      /* IDR frame */
1573 }
1574
1575 static void amdgpu_cs_vcn_enc_destroy(void)
1576 {
1577         int len = 0, r;
1578         uint32_t *p_task_size = NULL;
1579         uint32_t task_offset = 0, st_offset;
1580         uint32_t *st_size = NULL;
1581         uint32_t fw_maj = 1, fw_min = 9;
1582
1583         if (vcn_ip_version_major == 2) {
1584                 fw_maj = 1;
1585                 fw_min = 1;
1586         } else if (vcn_ip_version_major == 3) {
1587                 fw_maj = 1;
1588                 fw_min = 0;
1589         }
1590
1591         num_resources = 0;
1592 /*      alloc_resource(&enc_buf, 128 * 1024, AMDGPU_GEM_DOMAIN_GTT); */
1593         resources[num_resources++] = enc_buf.handle;
1594         resources[num_resources++] = ib_handle;
1595
1596         if (vcn_unified_ring)
1597                 amdgpu_cs_sq_head(ib_cpu, &len, true);
1598
1599         /* session info */
1600         st_offset = len;
1601         st_size = &ib_cpu[len++];       /* size */
1602         ib_cpu[len++] = 0x00000001;     /* RENCODE_IB_PARAM_SESSION_INFO */
1603         ib_cpu[len++] = ((fw_maj << 16) | (fw_min << 0));
1604         ib_cpu[len++] = enc_buf.addr >> 32;
1605         ib_cpu[len++] = enc_buf.addr;
1606         ib_cpu[len++] = 1;      /* RENCODE_ENGINE_TYPE_ENCODE; */
1607         *st_size = (len - st_offset) * 4;
1608
1609         /* task info */
1610         task_offset = len;
1611         st_offset = len;
1612         st_size = &ib_cpu[len++];       /* size */
1613         ib_cpu[len++] = 0x00000002;     /* RENCODE_IB_PARAM_TASK_INFO */
1614         p_task_size = &ib_cpu[len++];
1615         ib_cpu[len++] = enc_task_id++;  /* task_id */
1616         ib_cpu[len++] = 0;      /* feedback */
1617         *st_size = (len - st_offset) * 4;
1618
1619         /*  op close */
1620         st_offset = len;
1621         st_size = &ib_cpu[len++];
1622         ib_cpu[len++] = 0x01000002;     /* RENCODE_IB_OP_CLOSE_SESSION */
1623         *st_size = (len - st_offset) * 4;
1624
1625         *p_task_size = (len - task_offset) * 4;
1626
1627         if (vcn_unified_ring)
1628                 amdgpu_cs_sq_ib_tail(ib_cpu + len);
1629
1630         r = submit(len, AMDGPU_HW_IP_VCN_ENC);
1631         CU_ASSERT_EQUAL(r, 0);
1632
1633         free_resource(&cpb_buf);
1634         free_resource(&enc_buf);
1635 }