va/va_trace.c

   1 /*
   2  * Copyright (c) 2009 Intel Corporation. All Rights Reserved.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the
   6  * "Software"), to deal in the Software without restriction, including
   7  * without limitation the rights to use, copy, modify, merge, publish,
   8  * distribute, sub license, and/or sell copies of the Software, and to
   9  * permit persons to whom the Software is furnished to do so, subject to
  10  * the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the
  13  * next paragraph) shall be included in all copies or substantial portions
  14  * of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  19  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  20  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  21  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  22  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 #define _GNU_SOURCE 1
  26 #include "va.h"
  27 #include "va_backend.h"
  28
  29 #include <assert.h>
  30 #include <stdarg.h>
  31 #include <stdlib.h>
  32 #include <stdio.h>
  33 #include <string.h>
  34 #include <dlfcn.h>
  35 #include <unistd.h>
  36
  37 unsigned int trace_flag = 0;
  38
  39 static const char *trace_file = 0;
  40 static FILE *trace_fp = 0;
  41
  42 static VASurfaceID  trace_rendertarget; /* current render target */
  43 static VAProfile trace_profile; /* current entrypoint for buffers */
  44
  45 static unsigned int trace_frame;
  46 static unsigned int trace_slice;
  47
  48 static unsigned int trace_width;
  49 static unsigned int trace_height;
  50
  51 int va_TraceInit(void)
  52 {
  53     trace_file = (const char *)getenv("LIBVA_TRACE");
  54     if (trace_file) {
  55         trace_fp = fopen(trace_file, "w");
  56         if (trace_fp)
  57             trace_flag = 1;
  58     }
  59 }
  60
  61 int va_TraceEnd(void)
  62 {
  63     if (trace_file && trace_fp) {
  64         fclose(trace_fp);
  65
  66         trace_file = NULL;
  67         trace_fp = NULL;
  68
  69         trace_flag = 0;
  70
  71         trace_width = 0;
  72         trace_height = 0;
  73     }
  74 }
  75
  76 int va_TraceMsg(const char *msg, ...)
  77 {
  78     va_list args;
  79
  80     if (msg)  {
  81         va_start(args, msg);
  82         vfprintf(trace_fp, msg, args);
  83         va_end(args);
  84     } else  {
  85         fflush(trace_fp);
  86     }
  87 }
  88
  89
  90 int va_TraceCreateConfig(
  91     VADisplay dpy,
  92     VAProfile profile,
  93     VAEntrypoint entrypoint,
  94     VAConfigAttrib *attrib_list,
  95     int num_attribs,
  96     VAConfigID *config_id /* out */
  97                          )
  98 {
  99     int i;
 100
 101     va_TraceMsg("\tprofile = %d\n", profile);
 102     va_TraceMsg("\tentrypoint = %d\n", entrypoint);
 103     va_TraceMsg("\tnum_attribs = %d\n", num_attribs);
 104     for (i = 0; i < num_attribs; i++) {
 105         va_TraceMsg("\t\tattrib_list[%d].type = 0x%08x\n", i, attrib_list[i].type);
 106         va_TraceMsg("\t\tattrib_list[%d].value = 0x%08x\n", i, attrib_list[i].value);
 107     }
 108
 109     trace_profile = profile;
 110 }
 111
 112
 113 int va_TraceCreateSurface(
 114     VADisplay dpy,
 115     int width,
 116     int height,
 117     int format,
 118     int num_surfaces,
 119     VASurfaceID *surfaces       /* out */
 120                           )
 121 {
 122     int i;
 123
 124     va_TraceMsg("\twidth = %d\n", width);
 125     va_TraceMsg("\theight = %d\n", height);
 126     va_TraceMsg("\tformat = %d\n", format);
 127     va_TraceMsg("\tnum_surfaces = %d\n", num_surfaces);
 128
 129     for (i = 0; i < num_surfaces; i++)
 130         va_TraceMsg("\t\tsurfaces[%d] = 0x%08x\n", i, surfaces[i]);
 131 }
 132
 133
 134 int va_TraceCreateContext(
 135     VADisplay dpy,
 136     VAConfigID config_id,
 137     int picture_width,
 138     int picture_height,
 139     int flag,
 140     VASurfaceID *render_targets,
 141     int num_render_targets,
 142     VAContextID *context                /* out */
 143                           )
 144 {
 145     int i;
 146
 147     va_TraceMsg("\twidth = %d\n", picture_width);
 148     va_TraceMsg("\theight = %d\n", picture_height);
 149     va_TraceMsg("\tflag = 0x%08x\n", flag);
 150     va_TraceMsg("\tnum_render_targets = %d\n", num_render_targets);
 151     for (i=0; i<num_render_targets; i++)
 152         va_TraceMsg("\t\trender_targets[%d] = 0x%08x\n", i, render_targets[i]);
 153     va_TraceMsg("\tcontext = 0x%08x\n", context);
 154
 155
 156     trace_frame = 0;
 157     trace_slice = 0;
 158
 159     trace_width = picture_width;
 160     trace_height = picture_height;
 161 }
 162
 163
 164 static char * buffer_type_to_string(int type)
 165 {
 166     switch (type) {
 167     case VAPictureParameterBufferType: return "VAPictureParameterBufferType";
 168     case VAIQMatrixBufferType: return "VAIQMatrixBufferType";
 169     case VABitPlaneBufferType: return "VABitPlaneBufferType";
 170     case VASliceGroupMapBufferType: return "VASliceGroupMapBufferType";
 171     case VASliceParameterBufferType: return "VASliceParameterBufferType";
 172     case VASliceDataBufferType: return "VASliceDataBufferType";
 173     case VAProtectedSliceDataBufferType: return "VAProtectedSliceDataBufferType";
 174     case VAMacroblockParameterBufferType: return "VAMacroblockParameterBufferType";
 175     case VAResidualDataBufferType: return "VAResidualDataBufferType";
 176     case VADeblockingParameterBufferType: return "VADeblockingParameterBufferType";
 177     case VAImageBufferType: return "VAImageBufferType";
 178     case VAEncCodedBufferType: return "VAEncCodedBufferType";
 179     case VAEncSequenceParameterBufferType: return "VAEncSequenceParameterBufferType";
 180     case VAEncPictureParameterBufferType: return "VAEncPictureParameterBufferType";
 181     case VAEncSliceParameterBufferType: return "VAEncSliceParameterBufferType";
 182     default: return "UnknowBuffer";
 183     }
 184 }
 185
 186
 187 static int va_TraceVABuffers(
 188     VADisplay dpy,
 189     VAContextID context,
 190     VABufferID buffer,
 191     VABufferType type,
 192     unsigned int size,
 193     unsigned int num_elements,
 194     void *pbuf
 195                              )
 196 {
 197     int i;
 198     char *p = pbuf;
 199     unsigned int *pi = (unsigned int *)pbuf;
 200
 201     va_TraceMsg("***Buffer Data***");
 202     for (i=0; i<size; i++) {
 203         if ((i%16) == 0)
 204             va_TraceMsg("\n0x%08x:", i);
 205         va_TraceMsg("%08x ", p[i]);
 206     }
 207
 208     va_TraceMsg("\n");
 209     return 0;
 210 }
 211
 212
 213 static void va_TraceVAPictureParameterBufferMPEG2(
 214     VADisplay dpy,
 215     VAContextID context,
 216     VABufferID buffer,
 217     VABufferType type,
 218     unsigned int size,
 219     unsigned int num_elements,
 220     void *data)
 221 {
 222     va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, data);
 223
 224     return;
 225 }
 226
 227
 228 static void va_TraceVAIQMatrixBufferMPEG2(
 229     VADisplay dpy,
 230     VAContextID context,
 231     VABufferID buffer,
 232     VABufferType type,
 233     unsigned int size,
 234     unsigned int num_elements,
 235     void *data)
 236 {
 237     va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, data);
 238
 239     return;
 240 }
 241
 242
 243 static void va_TraceVASliceParameterBufferMPEG2(
 244     VADisplay dpy,
 245     VAContextID context,
 246     VABufferID buffer,
 247     VABufferType type,
 248     unsigned int size,
 249     unsigned int num_elements,
 250     void *data)
 251 {
 252     va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, data);
 253
 254     return;
 255 }
 256
 257
 258
 259 static void va_TraceVAPictureParameterBufferMPEG4(
 260     VADisplay dpy,
 261     VAContextID context,
 262     VABufferID buffer,
 263     VABufferType type,
 264     unsigned int size,
 265     unsigned int num_elements,
 266     void *data)
 267 {
 268     va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, data);
 269
 270     return;
 271 }
 272
 273
 274 static void va_TraceVAIQMatrixBufferMPEG4(
 275     VADisplay dpy,
 276     VAContextID context,
 277     VABufferID buffer,
 278     VABufferType type,
 279     unsigned int size,
 280     unsigned int num_elements,
 281     void *data)
 282 {
 283     va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, data);
 284
 285     return;
 286 }
 287
 288
 289 static void va_TraceVASliceParameterBufferMPEG4(
 290     VADisplay dpy,
 291     VAContextID context,
 292     VABufferID buffer,
 293     VABufferType type,
 294     unsigned int size,
 295     unsigned int num_elements,
 296     void *data)
 297 {
 298     va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, data);
 299
 300     return;
 301 }
 302
 303
 304 static void va_TraceVAPictureParameterBufferH264(
 305     VADisplay dpy,
 306     VAContextID context,
 307     VABufferID buffer,
 308     VABufferType type,
 309     unsigned int size,
 310     unsigned int num_elements,
 311     void *data)
 312 {
 313     int i;
 314
 315     VAPictureParameterBufferH264 *p = (VAPictureParameterBufferH264*)data;
 316
 317     va_TraceMsg  ("==========H264PicParameterBuffer============\n");
 318
 319 #if 0
 320     if (p->num_ref_frames > 4)
 321     {
 322         int num = 0;
 323         for (i = 15; i >= 0; i--)
 324         {
 325             if (p->ReferenceFrames[i].flags != VA_PICTURE_H264_INVALID)
 326             {
 327                 num++;
 328             }
 329             if (num > 4)
 330             {
 331                 p->ReferenceFrames[i].flags = VA_PICTURE_H264_INVALID;
 332             }
 333         }
 334         p->num_ref_frames  = 4;
 335     }
 336 #endif
 337
 338 #if 1
 339     va_TraceMsg("picture id: %d\n", p->CurrPic.picture_id);
 340     va_TraceMsg("frame idx: %d\n", p->CurrPic.frame_idx);
 341     va_TraceMsg("picture flags: %d\n", p->CurrPic.flags);
 342     va_TraceMsg("top field order count: %d\n", p->CurrPic.TopFieldOrderCnt);
 343     va_TraceMsg("bottom field order count: %d\n", p->CurrPic.BottomFieldOrderCnt);
 344
 345
 346     va_TraceMsg("Reference frames: \n");
 347     for (i = 0; i < 16; i++)
 348     {
 349         if (p->ReferenceFrames[i].flags != VA_PICTURE_H264_INVALID)
 350         {
 351             //va_TraceMsg("%d-%d; ", p->ReferenceFrames[i].TopFieldOrderCnt, p->ReferenceFrames[i].BottomFieldOrderCnt);
 352             va_TraceMsg("%d-%d-%d-%d; ", p->ReferenceFrames[i].TopFieldOrderCnt, p->ReferenceFrames[i].BottomFieldOrderCnt, p->ReferenceFrames[i].picture_id, p->ReferenceFrames[i].frame_idx);
 353         }
 354     }
 355     va_TraceMsg("\n");
 356 #endif
 357     va_TraceMsg("picture_width_in_mbs_minus1: %d\n", p->picture_width_in_mbs_minus1);
 358     va_TraceMsg("picture_height_in_mbs_minus1: %d\n", p->picture_height_in_mbs_minus1);
 359     va_TraceMsg("bit_depth_luma_minus8: %d\n", p->bit_depth_luma_minus8);
 360     va_TraceMsg("bit_depth_chroma_minus8: %d\n", p->bit_depth_chroma_minus8);
 361     va_TraceMsg("num_ref_frames: %d\n", p->num_ref_frames);
 362     va_TraceMsg("seq fields: %d\n", p->seq_fields.value);
 363     va_TraceMsg("\t chroma_format_idc: %d\n", p->seq_fields.bits.chroma_format_idc);
 364     va_TraceMsg("\t residual_colour_transform_flag: %d\n", p->seq_fields.bits.residual_colour_transform_flag);
 365     va_TraceMsg("\t frame_mbs_only_flag: %d\n", p->seq_fields.bits.frame_mbs_only_flag);
 366     va_TraceMsg("\t mb_adaptive_frame_field_flag: %d\n", p->seq_fields.bits.mb_adaptive_frame_field_flag);
 367     va_TraceMsg("\t direct_8x8_inference_flag: %d\n", p->seq_fields.bits.direct_8x8_inference_flag);
 368     va_TraceMsg("\t MinLumaBiPredSize8x8: %d\n", p->seq_fields.bits.MinLumaBiPredSize8x8);
 369     va_TraceMsg("num_slice_groups_minus1: %d\n", p->num_slice_groups_minus1);
 370     va_TraceMsg("slice_group_map_type: %d\n", p->slice_group_map_type);
 371     va_TraceMsg("slice_group_change_rate_minus1: %d\n", p->slice_group_change_rate_minus1);
 372     va_TraceMsg("pic_init_qp_minus26: %d\n", p->pic_init_qp_minus26);
 373     va_TraceMsg("pic_init_qs_minus26: %d\n", p->pic_init_qs_minus26);
 374     va_TraceMsg("chroma_qp_index_offset: %d\n", p->chroma_qp_index_offset);
 375     va_TraceMsg("second_chroma_qp_index_offset: %d\n", p->second_chroma_qp_index_offset);
 376     va_TraceMsg("pic_fields: %d\n", p->pic_fields.value);
 377     va_TraceMsg("\t entropy_coding_mode_flag: %d\n", p->pic_fields.bits.entropy_coding_mode_flag);
 378     va_TraceMsg("\t weighted_pred_flag: %d\n", p->pic_fields.bits.weighted_pred_flag);
 379     va_TraceMsg("\t weighted_bipred_idc: %d\n", p->pic_fields.bits.weighted_bipred_idc);
 380     va_TraceMsg("\t transform_8x8_mode_flag: %d\n", p->pic_fields.bits.transform_8x8_mode_flag);
 381     va_TraceMsg("\t field_pic_flag: %d\n", p->pic_fields.bits.field_pic_flag);
 382     va_TraceMsg("\t constrained_intra_pred_flag: %d\n", p->pic_fields.bits.constrained_intra_pred_flag);
 383     va_TraceMsg("frame_num: %d\n", p->frame_num);
 384
 385     return;
 386 }
 387
 388 static void va_TraceVASliceParameterBufferH264(
 389     VADisplay dpy,
 390     VAContextID context,
 391     VABufferID buffer,
 392     VABufferType type,
 393     unsigned int size,
 394     unsigned int num_elements,
 395     void *data)
 396 {
 397     int i;
 398     VASliceParameterBufferH264* p = (VASliceParameterBufferH264*)data;
 399
 400     va_TraceMsg  ("========== SLICE HEADER ============.\n");
 401     va_TraceMsg("slice_data_size: %d\n", p->slice_data_size);
 402     va_TraceMsg("slice_data_offset: %d\n", p->slice_data_offset);
 403     va_TraceMsg("slice_data_flag: %d\n", p->slice_data_flag);
 404     va_TraceMsg("slice_data_bit_offset: %d\n", p->slice_data_bit_offset);
 405     va_TraceMsg("first_mb_in_slice: %d\n", p->first_mb_in_slice);
 406     va_TraceMsg("slice_type: %d\n", p->slice_type);
 407     va_TraceMsg("direct_spatial_mv_pred_flag: %d\n", p->direct_spatial_mv_pred_flag);
 408     va_TraceMsg("num_ref_idx_l0_active_minus1: %d\n", p->num_ref_idx_l0_active_minus1);
 409     va_TraceMsg("num_ref_idx_l1_active_minus1: %d\n", p->num_ref_idx_l1_active_minus1);
 410     va_TraceMsg("cabac_init_idc: %d\n", p->cabac_init_idc);
 411     va_TraceMsg("slice_qp_delta: %d\n", p->slice_qp_delta);
 412     va_TraceMsg("disable_deblocking_filter_idc: %d\n", p->disable_deblocking_filter_idc);
 413     va_TraceMsg("slice_alpha_c0_offset_div2: %d\n", p->slice_alpha_c0_offset_div2);
 414     va_TraceMsg("slice_beta_offset_div2: %d\n", p->slice_beta_offset_div2);
 415
 416 #if 1
 417     if (p->slice_type == 0 || p->slice_type == 1)
 418     {
 419         va_TraceMsg("RefPicList0:\n");
 420         for (i = 0; i < p->num_ref_idx_l0_active_minus1 + 1; i++)
 421         {
 422             //va_TraceMsg("%d-%d; ", p->RefPicList0[i].TopFieldOrderCnt, p->RefPicList0[i].BottomFieldOrderCnt);
 423             va_TraceMsg("%d-%d-%d-%d; ", p->RefPicList0[i].TopFieldOrderCnt, p->RefPicList0[i].BottomFieldOrderCnt, p->RefPicList0[i].picture_id, p->RefPicList0[i].frame_idx);
 424         }
 425         va_TraceMsg("\n");
 426         if (p->slice_type == 1)
 427         {
 428             va_TraceMsg("RefPicList1:\n");
 429             for (i = 0; i < p->num_ref_idx_l1_active_minus1 + 1; i++)
 430             {
 431                 //va_TraceMsg("%d-%d; ", p->RefPicList1[i].TopFieldOrderCnt, p->RefPicList1[i].BottomFieldOrderCnt);
 432                 va_TraceMsg("%d-%d-%d-%d; ", p->RefPicList1[i].TopFieldOrderCnt, p->RefPicList1[i].BottomFieldOrderCnt, p->RefPicList1[i].picture_id, p->RefPicList1[i].frame_idx);
 433             }
 434         }
 435         va_TraceMsg("\n");
 436     }
 437 #endif
 438
 439     va_TraceMsg("luma_log2_weight_denom: %d\n", p->luma_log2_weight_denom);
 440     va_TraceMsg("chroma_log2_weight_denom: %d\n", p->chroma_log2_weight_denom);
 441     va_TraceMsg("luma_weight_l0_flag: %d\n", p->luma_weight_l0_flag);
 442     if (p->luma_weight_l0_flag)
 443     {
 444         for (i = 0; i <=  p->num_ref_idx_l0_active_minus1; i++)
 445         {
 446             va_TraceMsg("%d ", p->luma_weight_l0[i]);
 447             va_TraceMsg("%d ", p->luma_offset_l0[i]);
 448         }
 449         va_TraceMsg("\n");
 450     }
 451
 452
 453     va_TraceMsg("chroma_weight_l0_flag: %d\n", p->chroma_weight_l0_flag);
 454     if (p->chroma_weight_l0_flag)
 455     {
 456         for (i = 0; i <= p->num_ref_idx_l0_active_minus1; i++)
 457         {
 458             va_TraceMsg("%d ", p->chroma_weight_l0[i][0]);
 459             va_TraceMsg("%d ", p->chroma_offset_l0[i][0]);
 460             va_TraceMsg("%d ", p->chroma_weight_l0[i][1]);
 461             va_TraceMsg("%d ", p->chroma_offset_l0[i][1]);
 462         }
 463         va_TraceMsg("\n");
 464     }
 465     va_TraceMsg("luma_weight_l1_flag: %d\n", p->luma_weight_l1_flag);
 466     if (p->luma_weight_l1_flag)
 467     {
 468         for (i = 0; i <=  p->num_ref_idx_l1_active_minus1; i++)
 469         {
 470             va_TraceMsg("%d ", p->luma_weight_l1[i]);
 471             va_TraceMsg("%d ", p->luma_offset_l1[i]);
 472         }
 473         va_TraceMsg("\n");
 474     }
 475     va_TraceMsg("chroma_weight_l1_flag: %d\n", p->chroma_weight_l1_flag);
 476     if (p->chroma_weight_l1_flag)
 477     {
 478         for (i = 0; i <= p->num_ref_idx_l1_active_minus1; i++)
 479         {
 480             va_TraceMsg("%d ", p->chroma_weight_l1[i][0]);
 481             va_TraceMsg("%d ", p->chroma_offset_l1[i][0]);
 482             va_TraceMsg("%d ", p->chroma_weight_l1[i][1]);
 483             va_TraceMsg("%d ", p->chroma_offset_l1[i][1]);
 484         }
 485         va_TraceMsg("\n");
 486     }
 487 }
 488
 489 static void va_TraceVAIQMatrixBufferH264(
 490     VADisplay dpy,
 491     VAContextID context,
 492     VABufferID buffer,
 493     VABufferType type,
 494     unsigned int size,
 495     unsigned int num_elements,
 496     void *data
 497 )
 498 {
 499     va_TraceMsg("========== IQMatrix ============.\n");
 500     VAIQMatrixBufferH264* p = (VAIQMatrixBufferH264* )data;
 501     int i, j;
 502     for (i = 0; i < 6; i++)
 503     {
 504         for (j = 0; j < 16; j++)
 505         {
 506             va_TraceMsg("%d\t", p->ScalingList4x4[i][j]);
 507             if ((j + 1) % 8 == 0)
 508                 va_TraceMsg("\n");
 509         }
 510     }
 511
 512     for (i = 0; i < 2; i++)
 513     {
 514         for (j = 0; j < 64; j++)
 515         {
 516             va_TraceMsg("%d\t", p->ScalingList8x8[i][j]);
 517             if ((j + 1) % 8 == 0)
 518                 va_TraceMsg("\n");
 519         }
 520     }
 521 }
 522
 523 static void va_TraceVAPictureParameterBufferVC1(
 524     VADisplay dpy,
 525     VAContextID context,
 526     VABufferID buffer,
 527     VABufferType type,
 528     unsigned int size,
 529     unsigned int num_elements,
 530     void *data
 531 )
 532 {
 533     VAPictureParameterBufferVC1* p = (VAPictureParameterBufferVC1*)data;
 534
 535     va_TraceMsg("\tforward_reference_picture = 0x%08x\n", p->forward_reference_picture);
 536     va_TraceMsg("\tbackward_reference_picture = 0x%08x\n", p->backward_reference_picture);
 537     va_TraceMsg("\tinloop_decoded_picture = 0x%08x\n", p->inloop_decoded_picture);
 538
 539     va_TraceMsg("\tpulldown = %d\n", p->sequence_fields.bits.pulldown);
 540     va_TraceMsg("\tinterlace = %d\n", p->sequence_fields.bits.interlace);
 541     va_TraceMsg("\ttfcntrflag = %d\n", p->sequence_fields.bits.tfcntrflag);
 542     va_TraceMsg("\tfinterpflag = %d\n", p->sequence_fields.bits.finterpflag);
 543     va_TraceMsg("\tpsf                           = %d.\n",
 544                 p->sequence_fields.bits.psf);
 545     va_TraceMsg("\tmultires                      = %d.\n",
 546                 p->sequence_fields.bits.multires);
 547     va_TraceMsg("\toverlap                       = %d.\n",
 548                 p->sequence_fields.bits.overlap);
 549     va_TraceMsg("\tsyncmarker                    = %d.\n",
 550                 p->sequence_fields.bits.syncmarker);
 551     va_TraceMsg("\trangered                      = %d.\n",
 552                 p->sequence_fields.bits.rangered);
 553     va_TraceMsg("\tmax_b_frames                  = %d.\n",
 554                 p->sequence_fields.bits.max_b_frames);
 555     va_TraceMsg("\tcoded_width                   = %d.\n",
 556                 p->coded_width);
 557     va_TraceMsg("\tcoded_height                  = %d.\n",
 558                 p->coded_height);
 559     va_TraceMsg("\tclosed_entry                  = %d.\n",
 560                 p->entrypoint_fields.bits.closed_entry);
 561     va_TraceMsg("\tbroken_link                   = %d.\n",
 562                 p->entrypoint_fields.bits.broken_link);
 563     va_TraceMsg("\tclosed_entry                  = %d.\n",
 564                 p->entrypoint_fields.bits.closed_entry);
 565     va_TraceMsg("\tpanscan_flag                  = %d.\n",
 566                 p->entrypoint_fields.bits.panscan_flag);
 567     va_TraceMsg("\tloopfilter                    = %d.\n",
 568                 p->entrypoint_fields.bits.loopfilter);
 569     va_TraceMsg("\tconditional_overlap_flag      = %d.\n",
 570                 p->conditional_overlap_flag);
 571     va_TraceMsg("\tfast_uvmc_flag                = %d.\n",
 572                 p->fast_uvmc_flag);
 573     va_TraceMsg("\trange_mapping_luma_flag       = %d.\n",
 574                 p->range_mapping_fields.bits.luma_flag);
 575     va_TraceMsg("\trange_mapping_luma            = %d.\n",
 576                 p->range_mapping_fields.bits.luma);
 577     va_TraceMsg("\trange_mapping_chroma_flag     = %d.\n",
 578                 p->range_mapping_fields.bits.chroma_flag);
 579     va_TraceMsg("\trange_mapping_chroma          = %d.\n",
 580                 p->range_mapping_fields.bits.chroma);
 581     va_TraceMsg("\tb_picture_fraction            = %d.\n",
 582                 p->b_picture_fraction);
 583     va_TraceMsg("\tcbp_table                     = %d.\n",
 584                 p->cbp_table);
 585     va_TraceMsg("\tmb_mode_table                 = %d.\n",
 586                 p->mb_mode_table);
 587     va_TraceMsg("\trange_reduction_frame         = %d.\n",
 588                 p->range_reduction_frame);
 589     va_TraceMsg("\trounding_control              = %d.\n",
 590                 p->rounding_control);
 591     va_TraceMsg("\tpost_processing               = %d.\n",
 592                 p->post_processing);
 593     va_TraceMsg("\tpicture_resolution_index      = %d.\n",
 594                 p->picture_resolution_index);
 595     va_TraceMsg("\tluma_scale                    = %d.\n",
 596                 p->luma_scale);
 597     va_TraceMsg("\tluma_shift                    = %d.\n",
 598                 p->luma_shift);
 599     va_TraceMsg("\tpicture_type                  = %d.\n",
 600                 p->picture_fields.bits.picture_type);
 601     va_TraceMsg("\tframe_coding_mode             = %d.\n",
 602                 p->picture_fields.bits.frame_coding_mode);
 603     va_TraceMsg("\ttop_field_first               = %d.\n",
 604                 p->picture_fields.bits.top_field_first);
 605     va_TraceMsg("\tis_first_field                = %d.\n",
 606                 p->picture_fields.bits.is_first_field);
 607     va_TraceMsg("\tintensity_compensation        = %d.\n",
 608                 p->picture_fields.bits.intensity_compensation);
 609     va_TraceMsg("  ---------------------------------\n");
 610     va_TraceMsg("\tmv_type_mb                    = %d.\n",
 611                 p->raw_coding.flags.mv_type_mb);
 612     va_TraceMsg("\tdirect_mb                     = %d.\n",
 613                 p->raw_coding.flags.direct_mb);
 614     va_TraceMsg("\tskip_mb                       = %d.\n",
 615                 p->raw_coding.flags.skip_mb);
 616     va_TraceMsg("\tfield_tx                      = %d.\n",
 617                 p->raw_coding.flags.field_tx);
 618     va_TraceMsg("\tforward_mb                    = %d.\n",
 619                 p->raw_coding.flags.forward_mb);
 620     va_TraceMsg("\tac_pred                       = %d.\n",
 621                 p->raw_coding.flags.ac_pred);
 622     va_TraceMsg("\toverflags                     = %d.\n",
 623                 p->raw_coding.flags.overflags);
 624     va_TraceMsg("  ---------------------------------\n");
 625     va_TraceMsg("\tbp_mv_type_mb                 = %d.\n",
 626                 p->bitplane_present.flags.bp_mv_type_mb);
 627     va_TraceMsg("\tbp_direct_mb                  = %d.\n",
 628                 p->bitplane_present.flags.bp_direct_mb);
 629     va_TraceMsg("\tbp_skip_mb                    = %d.\n",
 630                 p->bitplane_present.flags.bp_skip_mb);
 631     va_TraceMsg("\tbp_field_tx                   = %d.\n",
 632                 p->bitplane_present.flags.bp_field_tx);
 633     va_TraceMsg("\tbp_forward_mb                 = %d.\n",
 634                 p->bitplane_present.flags.bp_forward_mb);
 635     va_TraceMsg("\tbp_ac_pred                    = %d.\n",
 636                 p->bitplane_present.flags.bp_ac_pred);
 637     va_TraceMsg("\tbp_overflags                  = %d.\n",
 638                 p->bitplane_present.flags.bp_overflags);
 639     va_TraceMsg("  ---------------------------------\n");
 640     va_TraceMsg("\treference_distance_flag       = %d.\n",
 641                 p->reference_fields.bits.reference_distance_flag);
 642     va_TraceMsg("\treference_distance            = %d.\n",
 643                 p->reference_fields.bits.reference_distance);
 644     va_TraceMsg("\tnum_reference_pictures        = %d.\n",
 645                 p->reference_fields.bits.num_reference_pictures);
 646     va_TraceMsg("\treference_field_pic_indicator = %d.\n",
 647                 p->reference_fields.bits.reference_field_pic_indicator);
 648     va_TraceMsg("\tmv_mode                       = %d.\n",
 649                 p->mv_fields.bits.mv_mode);
 650     va_TraceMsg("\tmv_mode2                      = %d.\n",
 651                 p->mv_fields.bits.mv_mode2);
 652     va_TraceMsg("\tmv_table                      = %d.\n",
 653                 p->mv_fields.bits.mv_table);
 654     va_TraceMsg("\ttwo_mv_block_pattern_table    = %d.\n",
 655                 p->mv_fields.bits.two_mv_block_pattern_table);
 656     va_TraceMsg("\tfour_mv_switch                = %d.\n",
 657                 p->mv_fields.bits.four_mv_switch);
 658     va_TraceMsg("\tfour_mv_block_pattern_table   = %d.\n",
 659                 p->mv_fields.bits.four_mv_block_pattern_table);
 660     va_TraceMsg("\textended_mv_flag              = %d.\n",
 661                 p->mv_fields.bits.extended_mv_flag);
 662     va_TraceMsg("\textended_mv_range             = %d.\n",
 663                 p->mv_fields.bits.extended_mv_range);
 664     va_TraceMsg("\textended_dmv_flag             = %d.\n",
 665                 p->mv_fields.bits.extended_dmv_flag);
 666     va_TraceMsg("\textended_dmv_range            = %d.\n",
 667                 p->mv_fields.bits.extended_dmv_range);
 668     va_TraceMsg("\tdquant                        = %d.\n",
 669                 p->pic_quantizer_fields.bits.dquant);
 670     va_TraceMsg("\tquantizer                     = %d.\n",
 671                 p->pic_quantizer_fields.bits.quantizer);
 672     va_TraceMsg("\thalf_qp                       = %d.\n",
 673                 p->pic_quantizer_fields.bits.half_qp);
 674     va_TraceMsg("\tpic_quantizer_scale           = %d.\n",
 675                 p->pic_quantizer_fields.bits.pic_quantizer_scale);
 676     va_TraceMsg("\tpic_quantizer_type            = %d.\n",
 677                 p->pic_quantizer_fields.bits.pic_quantizer_type);
 678     va_TraceMsg("\tdq_frame                      = %d.\n",
 679                 p->pic_quantizer_fields.bits.dq_frame);
 680     va_TraceMsg("\tdq_profile                    = %d.\n",
 681                 p->pic_quantizer_fields.bits.dq_profile);
 682     va_TraceMsg("\tdq_sb_edge                    = %d.\n",
 683                 p->pic_quantizer_fields.bits.dq_sb_edge);
 684     va_TraceMsg("\tdq_db_edge                    = %d.\n",
 685                 p->pic_quantizer_fields.bits.dq_db_edge);
 686     va_TraceMsg("\tdq_binary_level               = %d.\n",
 687                 p->pic_quantizer_fields.bits.dq_binary_level);
 688     va_TraceMsg("\talt_pic_quantizer             = %d.\n",
 689                 p->pic_quantizer_fields.bits.alt_pic_quantizer);
 690     va_TraceMsg("\tvariable_sized_transform_flag = %d.\n",
 691                 p->transform_fields.bits.variable_sized_transform_flag);
 692     va_TraceMsg("\tmb_level_transform_type_flag  = %d.\n",
 693                 p->transform_fields.bits.mb_level_transform_type_flag);
 694     va_TraceMsg("\tframe_level_transform_type    = %d.\n",
 695                 p->transform_fields.bits.frame_level_transform_type);
 696     va_TraceMsg("\ttransform_ac_codingset_idx1   = %d.\n",
 697                 p->transform_fields.bits.transform_ac_codingset_idx1);
 698     va_TraceMsg("\ttransform_ac_codingset_idx2   = %d.\n",
 699                 p->transform_fields.bits.transform_ac_codingset_idx2);
 700     va_TraceMsg("\tintra_transform_dc_table      = %d.\n",
 701                 p->transform_fields.bits.intra_transform_dc_table);
 702 }
 703
 704 static void va_TraceVASliceParameterBufferVC1(
 705     VADisplay dpy,
 706     VAContextID context,
 707     VABufferID buffer,
 708     VABufferType type,
 709     unsigned int size,
 710     unsigned int num_elements,
 711     void* data
 712 )
 713 {
 714     VASliceParameterBufferVC1 *p = (VASliceParameterBufferVC1*)data;
 715
 716     va_TraceMsg ("========== SLICE NUMBER ==========\n");
 717     va_TraceMsg ("    slice_data_size               = %d\n", p->slice_data_size);
 718     va_TraceMsg ("    slice_data_offset             = %d\n", p->slice_data_offset);
 719     va_TraceMsg ("    slice_data_flag               = %d\n", p->slice_data_flag);
 720     va_TraceMsg ("    macroblock_offset             = %d\n", p->macroblock_offset);
 721     va_TraceMsg ("    slice_vertical_position       = %d\n", p->slice_vertical_position);
 722 }
 723
 724 int va_TraceBeginPicture(
 725     VADisplay dpy,
 726     VAContextID context,
 727     VASurfaceID render_target
 728 )
 729 {
 730     int i;
 731
 732     va_TraceMsg("\tcontext = 0x%08x\n", context);
 733     va_TraceMsg("\t\trender_targets = 0x%08x\n", render_target);
 734
 735     trace_rendertarget = render_target; /* for surface data dump after vaEndPicture */
 736
 737     trace_frame++;
 738     trace_slice = 0;
 739 }
 740
 741 VAStatus vaBufferInfo (
 742     VADisplay dpy,
 743     VAContextID context,        /* in */
 744     VABufferID buf_id,          /* in */
 745     VABufferType *type,         /* out */
 746     unsigned int *size,         /* out */
 747     unsigned int *num_elements  /* out */
 748 );
 749
 750 static int va_TraceMPEG2Buf(
 751     VADisplay dpy,
 752     VAContextID context,
 753     VABufferID buffer,
 754     VABufferType type,
 755     unsigned int size,
 756     unsigned int num_elements,
 757     void *pbuf
 758 )
 759 {
 760     switch (type) {
 761     case VAPictureParameterBufferType:
 762         va_TraceVAPictureParameterBufferMPEG2(dpy, context, buffer, type, size, num_elements, pbuf);
 763         break;
 764     case VAIQMatrixBufferType:
 765         va_TraceVAIQMatrixBufferMPEG2(dpy, context, buffer, type, size, num_elements, pbuf);
 766         break;
 767     case VABitPlaneBufferType:
 768         break;
 769     case VASliceGroupMapBufferType:
 770         break;
 771     case VASliceParameterBufferType:
 772         trace_slice++;
 773         va_TraceVASliceParameterBufferMPEG2(dpy, context, buffer, type, size, num_elements, pbuf);
 774         break;
 775     case VASliceDataBufferType:
 776         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
 777         break;
 778     case VAMacroblockParameterBufferType:
 779         break;
 780     case VAResidualDataBufferType:
 781         break;
 782     case VADeblockingParameterBufferType:
 783         break;
 784     case VAImageBufferType:
 785         break;
 786     case VAProtectedSliceDataBufferType:
 787         break;
 788     case VAEncCodedBufferType:
 789         break;
 790     case VAEncSequenceParameterBufferType:
 791         break;
 792     case VAEncPictureParameterBufferType:
 793         break;
 794     case VAEncSliceParameterBufferType:
 795         break;
 796     case VAEncH264VUIBufferType:
 797         break;
 798     case VAEncH264SEIBufferType:
 799         break;
 800     }
 801
 802     return 0;
 803 }
 804
 805
 806 static int va_TraceMPEG4Buf(
 807     VADisplay dpy,
 808     VAContextID context,
 809     VABufferID buffer,
 810     VABufferType type,
 811     unsigned int size,
 812     unsigned int num_elements,
 813     void *pbuf
 814 )
 815 {
 816     switch (type) {
 817     case VAPictureParameterBufferType:
 818         va_TraceVAPictureParameterBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
 819         break;
 820     case VAIQMatrixBufferType:
 821         va_TraceVAIQMatrixBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
 822         break;
 823     case VABitPlaneBufferType:
 824         break;
 825     case VASliceGroupMapBufferType:
 826         break;
 827     case VASliceParameterBufferType:
 828         va_TraceVASliceParameterBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
 829         break;
 830     case VASliceDataBufferType:
 831         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
 832         break;
 833     case VAMacroblockParameterBufferType:
 834         break;
 835     case VAResidualDataBufferType:
 836         break;
 837     case VADeblockingParameterBufferType:
 838         break;
 839     case VAImageBufferType:
 840         break;
 841     case VAProtectedSliceDataBufferType:
 842         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
 843         break;
 844     case VAEncCodedBufferType:
 845         break;
 846     case VAEncSequenceParameterBufferType:
 847         break;
 848     case VAEncPictureParameterBufferType:
 849         break;
 850     case VAEncSliceParameterBufferType:
 851         break;
 852     case VAEncH264VUIBufferType:
 853         break;
 854     case VAEncH264SEIBufferType:
 855         break;
 856     default:
 857         break;
 858     }
 859
 860
 861     return 0;
 862 }
 863
 864
 865 static int va_TraceH264Buf(
 866     VADisplay dpy,
 867     VAContextID context,
 868     VABufferID buffer,
 869     VABufferType type,
 870     unsigned int size,
 871     unsigned int num_elements,
 872     void *pbuf
 873 )
 874 {
 875     switch (type) {
 876     case VAPictureParameterBufferType:
 877         va_TraceVAPictureParameterBufferMPEG2(dpy, context, buffer, type, size, num_elements, pbuf);
 878         break;
 879     case VAIQMatrixBufferType:
 880         va_TraceVAIQMatrixBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
 881         break;
 882     case VABitPlaneBufferType:
 883         break;
 884     case VASliceGroupMapBufferType:
 885         break;
 886     case VASliceParameterBufferType:
 887         va_TraceVASliceParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
 888         break;
 889     case VASliceDataBufferType:
 890         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
 891         break;
 892     case VAMacroblockParameterBufferType:
 893         break;
 894     case VAResidualDataBufferType:
 895         break;
 896     case VADeblockingParameterBufferType:
 897         break;
 898     case VAImageBufferType:
 899         break;
 900     case VAProtectedSliceDataBufferType:
 901         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
 902         break;
 903     case VAEncCodedBufferType:
 904         break;
 905     case VAEncSequenceParameterBufferType:
 906         break;
 907     case VAEncPictureParameterBufferType:
 908         break;
 909     case VAEncSliceParameterBufferType:
 910         break;
 911     case VAEncH264VUIBufferType:
 912         break;
 913     case VAEncH264SEIBufferType:
 914         break;
 915     default:
 916         break;
 917     }
 918
 919
 920     return 0;
 921 }
 922
 923
 924 static int va_TraceVC1Buf(
 925     VADisplay dpy,
 926     VAContextID context,
 927     VABufferID buffer,
 928     VABufferType type,
 929     unsigned int size,
 930     unsigned int num_elements,
 931     void *pbuf
 932 )
 933 {
 934     switch (type) {
 935     case VAPictureParameterBufferType:
 936         va_TraceVAPictureParameterBufferVC1(dpy, context, buffer, type, size, num_elements, pbuf);
 937         break;
 938     case VAIQMatrixBufferType:
 939         break;
 940     case VABitPlaneBufferType:
 941         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
 942         break;
 943     case VASliceGroupMapBufferType:
 944         break;
 945     case VASliceParameterBufferType:
 946         va_TraceVASliceParameterBufferVC1(dpy, context, buffer, type, size, num_elements, pbuf);
 947         break;
 948     case VASliceDataBufferType:
 949         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
 950         break;
 951     case VAMacroblockParameterBufferType:
 952         break;
 953     case VAResidualDataBufferType:
 954         break;
 955     case VADeblockingParameterBufferType:
 956         break;
 957     case VAImageBufferType:
 958         break;
 959     case VAProtectedSliceDataBufferType:
 960         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
 961         break;
 962     case VAEncCodedBufferType:
 963         break;
 964     case VAEncSequenceParameterBufferType:
 965         break;
 966     case VAEncPictureParameterBufferType:
 967         break;
 968     case VAEncSliceParameterBufferType:
 969         break;
 970     case VAEncH264VUIBufferType:
 971         break;
 972     case VAEncH264SEIBufferType:
 973         break;
 974     default:
 975         break;
 976     }
 977
 978     return 0;
 979 }
 980
 981 int va_TraceRenderPicture(
 982     VADisplay dpy,
 983     VAContextID context,
 984     VABufferID *buffers,
 985     int num_buffers
 986 )
 987 {
 988     VABufferType type;
 989     unsigned int size;
 990     unsigned int num_elements;
 991     int i;
 992
 993     va_TraceMsg("\tcontext = 0x%08x\n", context);
 994     va_TraceMsg("\tnum_buffers = %d\n", num_buffers);
 995     for (i = 0; i < num_buffers; i++) {
 996         void *pbuf;
 997
 998         /* get buffer type information */
 999         vaBufferInfo(dpy, context, buffers[i], &type, &size, &num_elements);
1000
1001         va_TraceMsg("\t\tbuffers[%d] = 0x%08x\n", i, buffers[i]);
1002         va_TraceMsg("\t\t\ttype = %s\n", buffer_type_to_string(type));
1003         va_TraceMsg("\t\t\tsize = %d\n", size);
1004         va_TraceMsg("\t\t\tnum_elements = %d\n", num_elements);
1005
1006
1007         vaMapBuffer(dpy, buffers[i], &pbuf);
1008
1009         switch (trace_profile) {
1010         case VAProfileMPEG2Simple:
1011         case VAProfileMPEG2Main:
1012             va_TraceMPEG2Buf(dpy, context, buffers[i], type, size, num_elements, pbuf);
1013             break;
1014         case VAProfileMPEG4Simple:
1015         case VAProfileMPEG4AdvancedSimple:
1016         case VAProfileMPEG4Main:
1017             va_TraceMPEG4Buf(dpy, context, buffers[i], type, size, num_elements, pbuf);
1018             break;
1019         case VAProfileH264Baseline:
1020         case VAProfileH264Main:
1021         case VAProfileH264High:
1022             va_TraceH264Buf(dpy, context, buffers[i], type, size, num_elements, pbuf);
1023             break;
1024         case VAProfileVC1Simple:
1025         case VAProfileVC1Main:
1026         case VAProfileVC1Advanced:
1027             va_TraceVC1Buf(dpy, context, buffers[i], type, size, num_elements, pbuf);
1028             break;
1029         case VAProfileH263Baseline:
1030             break;
1031         }
1032
1033         vaUnmapBuffer(dpy, buffers[i]);
1034     }
1035 }
1036
1037
1038 int va_TraceEndPicture(
1039     VADisplay dpy,
1040     VAContextID context
1041 )
1042 {
1043     int i, j;
1044     unsigned int fourcc; /* following are output argument */
1045     unsigned int luma_stride;
1046     unsigned int chroma_u_stride;
1047     unsigned int chroma_v_stride;
1048     unsigned int luma_offset;
1049     unsigned int chroma_u_offset;
1050     unsigned int chroma_v_offset;
1051     void *buffer;
1052     char *Y_data, *UV_data, *tmp;
1053
1054     VAStatus va_status;
1055
1056     va_TraceMsg("\tcontext = 0x%08x\n", context);
1057     va_TraceMsg("\t\trender_targets = 0x%08x\n", trace_rendertarget);
1058
1059     /* force the pipleline finish rendering */
1060     vaSyncSurface(dpy, trace_rendertarget);
1061
1062     va_TraceMsg("***dump surface data***\n", trace_rendertarget);
1063
1064     va_status = vaCopySurfaceToBuffer(dpy, trace_rendertarget, &fourcc, &luma_stride, &chroma_u_stride, &chroma_v_stride,
1065                                       &luma_offset, &chroma_u_offset, &chroma_v_offset, &buffer);
1066
1067     if (va_status != VA_STATUS_SUCCESS)
1068         return va_status;
1069
1070     va_TraceMsg("\tfourcc=0x%08x\n", fourcc);
1071     va_TraceMsg("\twidth=%d\n", trace_width);
1072     va_TraceMsg("\theight=%d\n", trace_height);
1073     va_TraceMsg("\tluma_stride=%d\n", luma_stride);
1074     va_TraceMsg("\tchroma_u_stride=%d\n", chroma_u_stride);
1075     va_TraceMsg("\tchroma_v_stride=%d\n", chroma_v_stride);
1076     va_TraceMsg("\tluma_offset=%d\n", luma_offset);
1077     va_TraceMsg("\tchroma_u_offset=%d\n", chroma_u_offset);
1078     va_TraceMsg("\tchroma_v_offset=%d\n", chroma_v_offset);
1079
1080     va_TraceMsg("**Y data**\n");
1081
1082     Y_data = buffer;
1083     UV_data = buffer + luma_offset;
1084
1085     tmp = Y_data;
1086
1087     for (i=0; i<trace_height; i++) {
1088         for (j=0; j<trace_width; j++) {
1089             if ((j%16) == 0)
1090                 va_TraceMsg("\n0x%08x:", j + i*trace_width);
1091             va_TraceMsg("%08x ", tmp[j]);
1092         }
1093
1094         va_TraceMsg("\n");
1095         tmp = Y_data + i * luma_stride;
1096     }
1097
1098     tmp = UV_data;
1099     if (fourcc == VA_FOURCC_NV12) {
1100         va_TraceMsg("**UV data**\n");
1101
1102         for (i=0; i<trace_height/2; i++) {
1103             for (j=0; j<trace_width; j++) {
1104                 if ((j%16) == 0)
1105                     va_TraceMsg("\n0x%08x:", j + i*trace_width);
1106                 va_TraceMsg("%08x ", tmp[j]);
1107             }
1108
1109             va_TraceMsg("\n");
1110             tmp = UV_data + i * chroma_u_stride;
1111         }
1112     }
1113     free((void *)buffer);
1114 }