va/va_trace.c

   1 /*
   2  * Copyright (c) 2009-2011 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 #include "va_trace.h"
  29
  30 #include <assert.h>
  31 #include <stdarg.h>
  32 #include <stdlib.h>
  33 #include <stdio.h>
  34 #include <string.h>
  35 #include <dlfcn.h>
  36 #include <unistd.h>
  37 #include <sys/types.h>
  38 #include <sys/stat.h>
  39 #include <unistd.h>
  40 #include <time.h>
  41
  42
  43 /*
  44  * Env. to debug some issue, e.g. the decode/encode issue in a video conference scenerio:
  45  * .LIBVA_TRACE=log_file: general VA parameters saved into log_file
  46  * .LIBVA_TRACE_BUFDATA: dump VA buffer data into log_file (if not set, just calculate a checksum)
  47  * .LIBVA_TRACE_CODEDBUF=coded_clip_file: save the coded clip into file coded_clip_file
  48  * .LIBVA_TRACE_SURFACE=decoded_yuv_file: save the decoded YUV file decoded_yuv_file
  49  * .LIBVA_TRACE_LOGSIZE=numeric number: truncate the log_file or coded_clip_file, or decoded_yuv_file
  50  *                                      when the size is bigger than the number
  51  */
  52
  53
  54 /* global settings */
  55
  56 /* LIBVA_TRACE */
  57 unsigned int trace_flag = 0;
  58
  59 /* LIBVA_TRACE_LOGSIZE */
  60 static unsigned int trace_logsize = 0xffffffff; /* truncate the log when the size is bigger than it */
  61
  62 /* LIBVA_TRACE_BUFDATA */
  63 static unsigned int trace_buffer_data; /* dump buffer data or not */
  64
  65 #define TRACE_CONTEXT_MAX 4
  66 /* per context settings */
  67 static struct _trace_context {
  68     VADisplay dpy; /* should use context as the key */
  69
  70     /* LIBVA_TRACE */
  71     FILE *trace_fp_log; /* save the log into a file */
  72     char trace_log_fn[1024]; /* file name */
  73
  74     /* LIBVA_TRACE_CODEDBUF */
  75     FILE *trace_fp_codedbuf; /* save the encode result into a file */
  76     char trace_codedbuf_fn[1024]; /* file name */
  77
  78     /* LIBVA_TRACE_SURFACE */
  79     FILE *trace_fp_surface; /* save the surface YUV into a file */
  80     char trace_surface_fn[1024]; /* file name */
  81
  82     VAContextID  trace_context; /* current context */
  83
  84     VASurfaceID  trace_rendertarget; /* current render target */
  85     VAProfile trace_profile; /* current profile for buffers */
  86     VAEntrypoint trace_entrypoint; /* current entrypoint */
  87     VABufferID trace_codedbuf;
  88
  89     unsigned int trace_frame_no; /* current frame NO */
  90     unsigned int trace_slice_no; /* current slice NO */
  91     unsigned int trace_slice_size; /* current slice buffer size */
  92
  93     unsigned int trace_frame_width; /* current frame width */
  94     unsigned int trace_frame_height; /* current frame height */
  95     unsigned int trace_sequence_start; /* get a new sequence for encoding or not */
  96 } trace_context[TRACE_CONTEXT_MAX] = { {0} }; /* trace five context at the same time */
  97
  98 #define DPY2INDEX(dpy)                                  \
  99     int idx;                                            \
 100                                                         \
 101     for (idx = 0; idx < TRACE_CONTEXT_MAX; idx++)       \
 102         if (trace_context[idx].dpy == dpy)              \
 103             break;                                      \
 104                                                         \
 105     if (idx == TRACE_CONTEXT_MAX)                       \
 106         return;
 107
 108 #define TRACE_FUNCNAME(idx)    va_TraceMsg(idx, "==========%s\n", __func__);
 109
 110 /* Prototype declarations (functions defined in va.c) */
 111
 112 void va_errorMessage(const char *msg, ...);
 113 void va_infoMessage(const char *msg, ...);
 114
 115 int va_parseConfig(char *env, char *env_value);
 116
 117 VAStatus vaBufferInfo(
 118     VADisplay dpy,
 119     VAContextID context,        /* in */
 120     VABufferID buf_id,          /* in */
 121     VABufferType *type,         /* out */
 122     unsigned int *size,         /* out */
 123     unsigned int *num_elements  /* out */
 124     );
 125
 126 VAStatus vaLockSurface(VADisplay dpy,
 127                        VASurfaceID surface,
 128                        unsigned int *fourcc, /* following are output argument */
 129                        unsigned int *luma_stride,
 130                        unsigned int *chroma_u_stride,
 131                        unsigned int *chroma_v_stride,
 132                        unsigned int *luma_offset,
 133                        unsigned int *chroma_u_offset,
 134                        unsigned int *chroma_v_offset,
 135                        unsigned int *buffer_name,
 136                        void **buffer
 137                        );
 138
 139 VAStatus vaUnlockSurface(VADisplay dpy,
 140                          VASurfaceID surface
 141                          );
 142
 143
 144 void va_TraceInit(VADisplay dpy)
 145 {
 146     char env_value[1024];
 147     unsigned int suffix = 0xffff & ((unsigned int)time(NULL));
 148     int trace_index = 0;
 149     FILE *tmp;
 150
 151     for (trace_index = 0; trace_index < TRACE_CONTEXT_MAX; trace_index++)
 152         if (trace_context[trace_index].dpy == 0)
 153             break;
 154
 155     if (trace_index == TRACE_CONTEXT_MAX)
 156         return;
 157
 158     if (va_parseConfig("LIBVA_TRACE", &env_value[0]) == 0) {
 159         trace_flag = 1;
 160
 161         /*Check if there is still room for suffix .%d.%d*/
 162     if (strnlen(env_value, 1024) < (1024 - 8))
 163         snprintf(env_value+strnlen(env_value, 1024),
 164                  (1025 - 8 - strnlen(env_value, 1024)),
 165                  ".%d.%d", trace_index, suffix);
 166
 167         tmp = fopen(env_value, "w");
 168         if (tmp) {
 169             trace_context[trace_index].trace_fp_log = tmp;
 170             strcpy(trace_context[trace_index].trace_log_fn, env_value);
 171         } else {
 172             trace_context[trace_index].trace_fp_log = stderr;
 173             strcpy(trace_context[trace_index].trace_codedbuf_fn, "/dev/stderr");
 174         }
 175         va_infoMessage("LIBVA_TRACE is on, save log into %s\n", trace_context[trace_index].trace_log_fn);
 176     }
 177
 178     if (trace_flag == 0)
 179         return;
 180
 181     /* may re-get the global settings for multiple context */
 182     if (va_parseConfig("LIBVA_TRACE_LOGSIZE", &env_value[0]) == 0) {
 183         trace_logsize = atoi(env_value);
 184         va_infoMessage("LIBVA_TRACE_LOGSIZE is on, size is %d\n", trace_logsize);
 185     }
 186
 187
 188     if (va_parseConfig("LIBVA_TRACE_BUFDATA", NULL) == 0) {
 189         trace_buffer_data = 1; /* dump buffer data */
 190         va_infoMessage("LIBVA_TRACE_BUFDATA is on, dump buffer into log file\n");
 191     }
 192
 193
 194     /* per-context setting */
 195     if (va_parseConfig("LIBVA_TRACE_CODEDBUF", &env_value[0]) == 0) {
 196         if (strnlen(env_value, 1024) < (1024 - 8))
 197             snprintf(env_value+strnlen(env_value, 1024),
 198                      (1025 - 8 - strnlen(env_value, 1024)),
 199                      ".%d.%d", trace_index, suffix);
 200
 201         tmp = fopen(env_value, "w");
 202
 203         if (tmp) {
 204             trace_context[trace_index].trace_fp_codedbuf = tmp;
 205             strcpy(trace_context[trace_index].trace_codedbuf_fn, env_value);
 206         } else {
 207             trace_context[trace_index].trace_fp_codedbuf = stderr;
 208             strcpy(trace_context[trace_index].trace_codedbuf_fn, "/dev/stderr");
 209         }
 210
 211         va_infoMessage("LIBVA_TRACE_CODEDBUF is on, save coded clip into %s\n", trace_context[trace_index].trace_codedbuf_fn);
 212     }
 213
 214     if (va_parseConfig("LIBVA_TRACE_SURFACE", &env_value[0]) == 0) {
 215         sprintf(env_value+strnlen(env_value, 1024), ".%d.%d", trace_index, suffix);
 216
 217         tmp = fopen(env_value, "w");
 218
 219         if (tmp) {
 220             trace_context[trace_index].trace_fp_surface = tmp;
 221             strcpy(trace_context[trace_index].trace_surface_fn, env_value);
 222         } else {
 223             trace_context[trace_index].trace_fp_surface = stderr;
 224             strcpy(trace_context[trace_index].trace_surface_fn, "/dev/stderr");
 225         }
 226
 227         va_infoMessage("LIBVA_TRACE_SURFACE is on, save coded clip into %s\n", trace_context[trace_index].trace_surface_fn);
 228     }
 229
 230     trace_context[trace_index].dpy = dpy;
 231 }
 232
 233
 234 void va_TraceEnd(VADisplay dpy)
 235 {
 236     DPY2INDEX(dpy);
 237
 238     if (trace_context[idx].trace_fp_log && (trace_context[idx].trace_fp_log != stderr))
 239         fclose(trace_context[idx].trace_fp_log);
 240
 241     if (trace_context[idx].trace_fp_codedbuf && (trace_context[idx].trace_fp_codedbuf != stderr))
 242         fclose(trace_context[idx].trace_fp_codedbuf);
 243
 244     if (trace_context[idx].trace_fp_surface && (trace_context[idx].trace_fp_surface != stderr))
 245         fclose(trace_context[idx].trace_fp_surface);
 246
 247     memset(&trace_context[idx], sizeof(struct _trace_context), 0);
 248 }
 249
 250
 251 static unsigned int file_size(FILE *fp)
 252 {
 253     struct stat buf;
 254
 255     fstat(fileno(fp), &buf);
 256
 257     return buf.st_size;
 258 }
 259
 260
 261 static void truncate_file(FILE *fp)
 262 {
 263     ftruncate(fileno(fp), 0);
 264     rewind(fp);
 265 }
 266
 267 void va_TraceMsg(int idx, const char *msg, ...)
 268 {
 269     va_list args;
 270
 271     if (file_size(trace_context[idx].trace_fp_log) >= trace_logsize)
 272         truncate_file(trace_context[idx].trace_fp_log);
 273
 274     if (msg)  {
 275         va_start(args, msg);
 276         vfprintf(trace_context[idx].trace_fp_log, msg, args);
 277         va_end(args);
 278     } else
 279         fflush(trace_context[idx].trace_fp_log);
 280 }
 281
 282 void va_TraceCodedBuf(VADisplay dpy)
 283 {
 284     VACodedBufferSegment *buf_list = NULL;
 285     VAStatus va_status;
 286     unsigned char check_sum = 0;
 287     DPY2INDEX(dpy);
 288
 289     /* can only truncate at a sequence boudary */
 290     if (((file_size(trace_context[idx].trace_fp_log) >= trace_logsize))
 291         && trace_context[idx].trace_sequence_start) {
 292         va_TraceMsg(idx, "==========truncate file %s\n", trace_context[idx].trace_codedbuf_fn);
 293         truncate_file(trace_context[idx].trace_fp_log);
 294     }
 295
 296
 297     trace_context[idx].trace_sequence_start = 0; /* only truncate coded file when meet next new sequence */
 298
 299     va_status = vaMapBuffer(dpy, trace_context[idx].trace_codedbuf, (void **)(&buf_list));
 300     if (va_status != VA_STATUS_SUCCESS)
 301         return;
 302
 303     va_TraceMsg(idx, "==========dump codedbuf into file %s\n", trace_context[idx].trace_codedbuf_fn);
 304
 305     while (buf_list != NULL) {
 306         unsigned int i;
 307
 308         va_TraceMsg(idx, "\tsize = %d\n", buf_list->size);
 309         if (trace_context[idx].trace_fp_log)
 310             fwrite(buf_list->buf, buf_list->size, 1, trace_context[idx].trace_fp_codedbuf);
 311
 312         for (i=0; i<buf_list->size; i++)
 313             check_sum ^= *((unsigned char *)buf_list->buf + i);
 314
 315         buf_list = buf_list->next;
 316     }
 317     vaUnmapBuffer(dpy,trace_context[idx].trace_codedbuf);
 318
 319     va_TraceMsg(idx, "\tchecksum = 0x%02x\n", check_sum);
 320     va_TraceMsg(idx, NULL);
 321 }
 322
 323
 324 void va_TraceSurface(VADisplay dpy)
 325 {
 326     unsigned int i, j;
 327     unsigned int fourcc; /* following are output argument */
 328     unsigned int luma_stride;
 329     unsigned int chroma_u_stride;
 330     unsigned int chroma_v_stride;
 331     unsigned int luma_offset;
 332     unsigned int chroma_u_offset;
 333     unsigned int chroma_v_offset;
 334     unsigned int buffer_name;
 335     void *buffer = NULL;
 336     unsigned char *Y_data, *UV_data, *tmp;
 337     VAStatus va_status;
 338     unsigned char check_sum = 0;
 339     DPY2INDEX(dpy);
 340
 341     va_TraceMsg(idx, "==========dump surface data in file %s\n", trace_context[idx].trace_surface_fn);
 342
 343     if ((file_size(trace_context[idx].trace_fp_surface) >= trace_logsize)) {
 344         va_TraceMsg(idx, "==========truncate file %s\n", trace_context[idx].trace_surface_fn);
 345         truncate_file(trace_context[idx].trace_fp_surface);
 346     }
 347     va_TraceMsg(idx, NULL);
 348
 349     va_status = vaLockSurface(
 350         dpy,
 351         trace_context[idx].trace_rendertarget,
 352         &fourcc,
 353         &luma_stride, &chroma_u_stride, &chroma_v_stride,
 354         &luma_offset, &chroma_u_offset, &chroma_v_offset,
 355         &buffer_name, &buffer);
 356
 357     if (va_status != VA_STATUS_SUCCESS) {
 358         va_TraceMsg(idx, "Error:vaLockSurface failed\n");
 359         return;
 360     }
 361
 362     va_TraceMsg(idx, "\tfourcc = 0x%08x\n", fourcc);
 363     va_TraceMsg(idx, "\twidth = %d\n", trace_context[idx].trace_frame_width);
 364     va_TraceMsg(idx, "\theight = %d\n", trace_context[idx].trace_frame_height);
 365     va_TraceMsg(idx, "\tluma_stride = %d\n", luma_stride);
 366     va_TraceMsg(idx, "\tchroma_u_stride = %d\n", chroma_u_stride);
 367     va_TraceMsg(idx, "\tchroma_v_stride = %d\n", chroma_v_stride);
 368     va_TraceMsg(idx, "\tluma_offset = %d\n", luma_offset);
 369     va_TraceMsg(idx, "\tchroma_u_offset = %d\n", chroma_u_offset);
 370     va_TraceMsg(idx, "\tchroma_v_offset = %d\n", chroma_v_offset);
 371
 372     if (buffer == NULL) {
 373         va_TraceMsg(idx, "Error:vaLockSurface return NULL buffer\n");
 374         va_TraceMsg(idx, NULL);
 375
 376         vaUnlockSurface(dpy, trace_context[idx].trace_rendertarget);
 377         return;
 378     }
 379     va_TraceMsg(idx, "\tbuffer location = 0x%08x\n", buffer);
 380     va_TraceMsg(idx, NULL);
 381
 382     Y_data = (unsigned char*)buffer;
 383     UV_data = (unsigned char*)buffer + chroma_u_offset;
 384
 385     tmp = Y_data;
 386     for (i=0; i<trace_context[idx].trace_frame_height; i++) {
 387         for (j=0; j<trace_context[idx].trace_frame_width; j++)
 388             check_sum ^= tmp[j];
 389
 390         if (trace_context[idx].trace_fp_surface)
 391             fwrite(tmp, trace_context[idx].trace_frame_width, 1, trace_context[idx].trace_fp_surface);
 392
 393         tmp = Y_data + i * luma_stride;
 394     }
 395
 396     tmp = UV_data;
 397     if (fourcc == VA_FOURCC_NV12) {
 398         for (i=0; i<trace_context[idx].trace_frame_height/2; i++) {
 399             for (j=0; j<trace_context[idx].trace_frame_width; j++)
 400                 check_sum ^= tmp[j];
 401
 402             if (trace_context[idx].trace_fp_surface)
 403                 fwrite(tmp, trace_context[idx].trace_frame_width, 1, trace_context[idx].trace_fp_surface);
 404
 405             tmp = UV_data + i * chroma_u_stride;
 406         }
 407     }
 408
 409     vaUnlockSurface(dpy, trace_context[idx].trace_rendertarget);
 410
 411     va_TraceMsg(idx, "\tchecksum = 0x%02x\n", check_sum & 0xff);
 412     va_TraceMsg(idx, NULL);
 413 }
 414
 415
 416 void va_TraceInitialize (
 417     VADisplay dpy,
 418     int *major_version,     /* out */
 419     int *minor_version      /* out */
 420 )
 421 {
 422     DPY2INDEX(dpy);
 423     TRACE_FUNCNAME(idx);
 424 }
 425
 426 void va_TraceTerminate (
 427     VADisplay dpy
 428 )
 429 {
 430     DPY2INDEX(dpy);
 431     TRACE_FUNCNAME(idx);
 432 }
 433
 434
 435 void va_TraceCreateConfig(
 436     VADisplay dpy,
 437     VAProfile profile,
 438     VAEntrypoint entrypoint,
 439     VAConfigAttrib *attrib_list,
 440     int num_attribs,
 441     VAConfigID *config_id /* out */
 442 )
 443 {
 444     int i;
 445     DPY2INDEX(dpy);
 446
 447     TRACE_FUNCNAME(idx);
 448
 449     va_TraceMsg(idx, "\tprofile = %d\n", profile);
 450     va_TraceMsg(idx, "\tentrypoint = %d\n", entrypoint);
 451     va_TraceMsg(idx, "\tnum_attribs = %d\n", num_attribs);
 452     for (i = 0; i < num_attribs; i++) {
 453         va_TraceMsg(idx, "\t\tattrib_list[%d].type = 0x%08x\n", i, attrib_list[i].type);
 454         va_TraceMsg(idx, "\t\tattrib_list[%d].value = 0x%08x\n", i, attrib_list[i].value);
 455     }
 456     va_TraceMsg(idx, NULL);
 457
 458     trace_context[idx].trace_profile = profile;
 459     trace_context[idx].trace_entrypoint = entrypoint;
 460 }
 461
 462
 463 void va_TraceCreateSurface(
 464     VADisplay dpy,
 465     int width,
 466     int height,
 467     int format,
 468     int num_surfaces,
 469     VASurfaceID *surfaces    /* out */
 470 )
 471 {
 472     int i;
 473     DPY2INDEX(dpy);
 474
 475     TRACE_FUNCNAME(idx);
 476
 477     va_TraceMsg(idx, "\twidth = %d\n", width);
 478     va_TraceMsg(idx, "\theight = %d\n", height);
 479     va_TraceMsg(idx, "\tformat = %d\n", format);
 480     va_TraceMsg(idx, "\tnum_surfaces = %d\n", num_surfaces);
 481
 482     for (i = 0; i < num_surfaces; i++)
 483         va_TraceMsg(idx, "\t\tsurfaces[%d] = 0x%08x\n", i, surfaces[i]);
 484
 485     va_TraceMsg(idx, NULL);
 486 }
 487
 488
 489 void va_TraceCreateContext(
 490     VADisplay dpy,
 491     VAConfigID config_id,
 492     int picture_width,
 493     int picture_height,
 494     int flag,
 495     VASurfaceID *render_targets,
 496     int num_render_targets,
 497     VAContextID *context        /* out */
 498 )
 499 {
 500     int i;
 501     DPY2INDEX(dpy);
 502
 503     TRACE_FUNCNAME(idx);
 504
 505     va_TraceMsg(idx, "\twidth = %d\n", picture_width);
 506     va_TraceMsg(idx, "\theight = %d\n", picture_height);
 507     va_TraceMsg(idx, "\tflag = 0x%08x\n", flag);
 508     va_TraceMsg(idx, "\tnum_render_targets = %d\n", num_render_targets);
 509     for (i=0; i<num_render_targets; i++)
 510         va_TraceMsg(idx, "\t\trender_targets[%d] = 0x%08x\n", i, render_targets[i]);
 511     va_TraceMsg(idx, "\tcontext = 0x%08x\n", *context);
 512     va_TraceMsg(idx, NULL);
 513
 514     trace_context[idx].trace_context = *context;
 515
 516     trace_context[idx].trace_frame_no = 0;
 517     trace_context[idx].trace_slice_no = 0;
 518
 519     trace_context[idx].trace_frame_width = picture_width;
 520     trace_context[idx].trace_frame_height = picture_height;
 521 }
 522
 523
 524 static char * buffer_type_to_string(int type)
 525 {
 526     switch (type) {
 527     case VAPictureParameterBufferType: return "VAPictureParameterBufferType";
 528     case VAIQMatrixBufferType: return "VAIQMatrixBufferType";
 529     case VABitPlaneBufferType: return "VABitPlaneBufferType";
 530     case VASliceGroupMapBufferType: return "VASliceGroupMapBufferType";
 531     case VASliceParameterBufferType: return "VASliceParameterBufferType";
 532     case VASliceDataBufferType: return "VASliceDataBufferType";
 533     case VAProtectedSliceDataBufferType: return "VAProtectedSliceDataBufferType";
 534     case VAMacroblockParameterBufferType: return "VAMacroblockParameterBufferType";
 535     case VAResidualDataBufferType: return "VAResidualDataBufferType";
 536     case VADeblockingParameterBufferType: return "VADeblockingParameterBufferType";
 537     case VAImageBufferType: return "VAImageBufferType";
 538     case VAEncCodedBufferType: return "VAEncCodedBufferType";
 539     case VAEncSequenceParameterBufferType: return "VAEncSequenceParameterBufferType";
 540     case VAEncPictureParameterBufferType: return "VAEncPictureParameterBufferType";
 541     case VAEncSliceParameterBufferType: return "VAEncSliceParameterBufferType";
 542     case VAEncMiscParameterBufferType: return "VAEncMiscParameterBufferType";
 543     default: return "UnknowBuffer";
 544     }
 545 }
 546
 547 void va_TraceMapBuffer (
 548     VADisplay dpy,
 549     VABufferID buf_id,    /* in */
 550     void **pbuf           /* out */
 551 )
 552 {
 553     VABufferType type;
 554     unsigned int size;
 555     unsigned int num_elements;
 556
 557     VACodedBufferSegment *buf_list;
 558     int i = 0;
 559
 560     DPY2INDEX(dpy);
 561
 562     vaBufferInfo(dpy, trace_context[idx].trace_context, buf_id, &type, &size, &num_elements);
 563     /*
 564       va_TraceMsg(idx, "\tbuf_id=0x%x\n", buf_id);
 565       va_TraceMsg(idx, "\tbuf_type=%s\n", buffer_type_to_string(type));
 566       va_TraceMsg(idx, "\tbuf_size=%s\n", size);
 567       va_TraceMsg(idx, "\tbuf_elements=%s\n", &num_elements);
 568     */
 569
 570     /* only trace CodedBuffer */
 571     if (type != VAEncCodedBufferType)
 572         return;
 573
 574     buf_list = (VACodedBufferSegment *)(*pbuf);
 575     while (buf_list != NULL) {
 576         va_TraceMsg(idx, "\tCodedbuf[%d] =\n", i++);
 577
 578         va_TraceMsg(idx, "\t   size = %d\n", buf_list->size);
 579         va_TraceMsg(idx, "\t   bit_offset = %d\n", buf_list->bit_offset);
 580         va_TraceMsg(idx, "\t   status = 0x%08x\n", buf_list->status);
 581         va_TraceMsg(idx, "\t   reserved = 0x%08x\n", buf_list->reserved);
 582         va_TraceMsg(idx, "\t   buf = 0x%08x\n", buf_list->buf);
 583
 584         buf_list = buf_list->next;
 585     }
 586     va_TraceMsg(idx, NULL);
 587 }
 588
 589 static void va_TraceVABuffers(
 590     VADisplay dpy,
 591     VAContextID context,
 592     VABufferID buffer,
 593     VABufferType type,
 594     unsigned int size,
 595     unsigned int num_elements,
 596     void *pbuf
 597 )
 598 {
 599     unsigned int i;
 600     unsigned char *p = pbuf;
 601     unsigned char  check_sum = 0;
 602     DPY2INDEX(dpy);
 603
 604     va_TraceMsg(idx, "%s\n",  buffer_type_to_string(type));
 605
 606     for (i=0; i<size; i++) {
 607         unsigned char value =  p[i];
 608
 609         if ((trace_buffer_data) && ((i%16) == 0))
 610             va_TraceMsg(idx, "\n0x%08x:", i);
 611
 612         if (trace_buffer_data)
 613             va_TraceMsg(idx, " %02x", value);
 614
 615         check_sum ^= value;
 616     }
 617
 618     va_TraceMsg(idx, "\tchecksum = 0x%02x\n", check_sum & 0xff);
 619     va_TraceMsg(idx, NULL);
 620
 621     return;
 622 }
 623
 624
 625 static void va_TraceVAPictureParameterBufferMPEG2(
 626     VADisplay dpy,
 627     VAContextID context,
 628     VABufferID buffer,
 629     VABufferType type,
 630     unsigned int size,
 631     unsigned int num_elements,
 632     void *data)
 633 {
 634     VAPictureParameterBufferMPEG2 *p=(VAPictureParameterBufferMPEG2 *)data;
 635     DPY2INDEX(dpy);
 636
 637     va_TraceMsg(idx,"VAPictureParameterBufferH264\n");
 638
 639     va_TraceMsg(idx,"\thorizontal size= %d\n", p->horizontal_size);
 640     va_TraceMsg(idx,"\tvertical size= %d\n", p->vertical_size);
 641     va_TraceMsg(idx,"\tforward reference picture= %d\n", p->forward_reference_picture);
 642     va_TraceMsg(idx,"\tbackward reference picture= %d\n", p->backward_reference_picture);
 643     va_TraceMsg(idx,"\tpicture coding type= %d\n", p->picture_coding_type);
 644     va_TraceMsg(idx,"\tf mode= %d\n", p->f_code);
 645
 646     va_TraceMsg(idx,"\tpicture coding extension = %d\n", p->picture_coding_extension.value);
 647     va_TraceMsg(idx,"\tintra_dc_precision= %d\n", p->picture_coding_extension.bits.intra_dc_precision);
 648     va_TraceMsg(idx,"\tpicture_structure= %d\n", p->picture_coding_extension.bits.picture_structure);
 649     va_TraceMsg(idx,"\ttop_field_first= %d\n", p->picture_coding_extension.bits.top_field_first);
 650     va_TraceMsg(idx,"\tframe_pred_frame_dct= %d\n", p->picture_coding_extension.bits.frame_pred_frame_dct);
 651     va_TraceMsg(idx,"\tconcealment_motion_vectors= %d\n", p->picture_coding_extension.bits.concealment_motion_vectors);
 652     va_TraceMsg(idx,"\tq_scale_type= %d\n", p->picture_coding_extension.bits.q_scale_type);
 653     va_TraceMsg(idx,"\tintra_vlc_format= %d\n", p->picture_coding_extension.bits.intra_vlc_format);
 654     va_TraceMsg(idx,"\talternate_scan= %d\n", p->picture_coding_extension.bits.alternate_scan);
 655     va_TraceMsg(idx,"\trepeat_first_field= %d\n", p->picture_coding_extension.bits.repeat_first_field);
 656     va_TraceMsg(idx,"\tprogressive_frame= %d\n", p->picture_coding_extension.bits.progressive_frame);
 657     va_TraceMsg(idx,"\tis_first_field= %d\n", p->picture_coding_extension.bits.is_first_field);
 658     va_TraceMsg(idx, NULL);
 659
 660     return;
 661 }
 662
 663
 664 static void va_TraceVAIQMatrixBufferMPEG2(
 665     VADisplay dpy,
 666     VAContextID context,
 667     VABufferID buffer,
 668     VABufferType type,
 669     unsigned int size,
 670     unsigned int num_elements,
 671     void *data)
 672 {
 673     VAIQMatrixBufferMPEG2 *p=(VAIQMatrixBufferMPEG2 *)data;
 674     DPY2INDEX(dpy);
 675
 676     va_TraceMsg(idx,"VAIQMatrixBufferMPEG2\n");
 677
 678     va_TraceMsg(idx,"\tload_intra_quantiser_matrix = %d\n", p->load_intra_quantiser_matrix);
 679     va_TraceMsg(idx,"\tload_non_intra_quantiser_matrix = %d\n", p->load_non_intra_quantiser_matrix);
 680     va_TraceMsg(idx,"\tload_chroma_intra_quantiser_matrix = %d\n", p->load_chroma_intra_quantiser_matrix);
 681     va_TraceMsg(idx,"\tload_chroma_non_intra_quantiser_matrix = %d\n", p->load_chroma_non_intra_quantiser_matrix);
 682     va_TraceMsg(idx,"\tintra_quantiser_matrix = %d\n", p->intra_quantiser_matrix);
 683     va_TraceMsg(idx,"\tnon_intra_quantiser_matrix = %d\n", p->non_intra_quantiser_matrix);
 684     va_TraceMsg(idx,"\tchroma_intra_quantiser_matrix = %d\n", p->chroma_intra_quantiser_matrix);
 685     va_TraceMsg(idx,"\tchroma_non_intra_quantiser_matrix = %d\n", p->chroma_non_intra_quantiser_matrix);
 686     va_TraceMsg(idx, NULL);
 687
 688     return;
 689 }
 690
 691
 692 static void va_TraceVASliceParameterBufferMPEG2(
 693     VADisplay dpy,
 694     VAContextID context,
 695     VABufferID buffer,
 696     VABufferType type,
 697     unsigned int size,
 698     unsigned int num_elements,
 699     void *data)
 700 {
 701     VASliceParameterBufferMPEG2 *p=(VASliceParameterBufferMPEG2 *)data;
 702
 703     DPY2INDEX(dpy);
 704
 705     trace_context[idx].trace_slice_no++;
 706
 707     trace_context[idx].trace_slice_size = p->slice_data_size;
 708
 709     va_TraceMsg(idx,"VASliceParameterBufferMPEG2\n");
 710
 711     va_TraceMsg(idx,"\tslice_data_size = %d\n", p->slice_data_size);
 712     va_TraceMsg(idx,"\tslice_data_offset = %d\n", p->slice_data_offset);
 713     va_TraceMsg(idx,"\tslice_data_flag = %d\n", p->slice_data_flag);
 714     va_TraceMsg(idx,"\tmacroblock_offset = %d\n", p->macroblock_offset);
 715     va_TraceMsg(idx,"\tslice_horizontal_position = %d\n", p->slice_horizontal_position);
 716     va_TraceMsg(idx,"\tslice_vertical_position = %d\n", p->slice_vertical_position);
 717     va_TraceMsg(idx,"\tquantiser_scale_code = %d\n", p->quantiser_scale_code);
 718     va_TraceMsg(idx,"\tintra_slice_flag = %d\n", p->intra_slice_flag);
 719     va_TraceMsg(idx, NULL);
 720
 721     return;
 722 }
 723
 724
 725 static void va_TraceVAPictureParameterBufferMPEG4(
 726     VADisplay dpy,
 727     VAContextID context,
 728     VABufferID buffer,
 729     VABufferType type,
 730     unsigned int size,
 731     unsigned int num_elements,
 732     void *data)
 733 {
 734     int i;
 735     VAPictureParameterBufferMPEG4 *p=(VAPictureParameterBufferMPEG4 *)data;
 736
 737     DPY2INDEX(dpy);
 738
 739     va_TraceMsg(idx,"*VAPictureParameterBufferMPEG4\n");
 740     va_TraceMsg(idx,"\tvop_width = %d\n", p->vop_width);
 741     va_TraceMsg(idx,"\tvop_height = %d\n", p->vop_height);
 742     va_TraceMsg(idx,"\tforward_reference_picture = %d\n", p->forward_reference_picture);
 743     va_TraceMsg(idx,"\tbackward_reference_picture = %d\n", p->backward_reference_picture);
 744     va_TraceMsg(idx,"\tvol_fields value = %d\n", p->vol_fields.value);
 745     va_TraceMsg(idx,"\tshort_video_header= %d\n", p->vol_fields.bits.short_video_header);
 746     va_TraceMsg(idx,"\tchroma_format= %d\n", p->vol_fields.bits.chroma_format);
 747     va_TraceMsg(idx,"\tinterlaced= %d\n", p->vol_fields.bits.interlaced);
 748     va_TraceMsg(idx,"\tobmc_disable= %d\n", p->vol_fields.bits.obmc_disable);
 749     va_TraceMsg(idx,"\tsprite_enable= %d\n", p->vol_fields.bits.sprite_enable);
 750     va_TraceMsg(idx,"\tsprite_warping_accuracy= %d\n", p->vol_fields.bits.sprite_warping_accuracy);
 751     va_TraceMsg(idx,"\tquant_type= %d\n", p->vol_fields.bits.quant_type);
 752     va_TraceMsg(idx,"\tquarter_sample= %d\n", p->vol_fields.bits.quarter_sample);
 753     va_TraceMsg(idx,"\tdata_partitioned= %d\n", p->vol_fields.bits.data_partitioned);
 754     va_TraceMsg(idx,"\treversible_vlc= %d\n", p->vol_fields.bits.reversible_vlc);
 755     va_TraceMsg(idx,"\tresync_marker_disable= %d\n", p->vol_fields.bits.resync_marker_disable);
 756     va_TraceMsg(idx,"\tno_of_sprite_warping_points = %d\n", p->no_of_sprite_warping_points);
 757     va_TraceMsg(idx,"\tsprite_trajectory_du =");
 758     for(i=0;i<3;i++)
 759         va_TraceMsg(idx,"\t%d", p->sprite_trajectory_du[i]);
 760
 761     va_TraceMsg(idx,"\n");
 762     va_TraceMsg(idx,"\tsprite_trajectory_dv =");
 763     for(i=0;i<3;i++)
 764         va_TraceMsg(idx,"\t%d", p->sprite_trajectory_dv[i]);
 765     va_TraceMsg(idx,"\n");
 766     va_TraceMsg(idx,"\tvop_fields value = %d\n", p->vop_fields.value);
 767     va_TraceMsg(idx,"\tvop_coding_type= %d\n", p->vop_fields.bits.vop_coding_type);
 768     va_TraceMsg(idx,"\tbackward_reference_vop_coding_type= %d\n", p->vop_fields.bits.backward_reference_vop_coding_type);
 769     va_TraceMsg(idx,"\tvop_rounding_type= %d\n", p->vop_fields.bits.vop_rounding_type);
 770     va_TraceMsg(idx,"\tintra_dc_vlc_thr= %d\n", p->vop_fields.bits.intra_dc_vlc_thr);
 771     va_TraceMsg(idx,"\ttop_field_first= %d\n", p->vop_fields.bits.top_field_first);
 772     va_TraceMsg(idx,"\talternate_vertical_scan_flag= %d\n", p->vop_fields.bits.alternate_vertical_scan_flag);
 773     va_TraceMsg(idx,"\tvop_fcode_forward = %d\n", p->vop_fcode_forward);
 774     va_TraceMsg(idx,"\tvop_fcode_backward = %d\n", p->vop_fcode_backward);
 775     va_TraceMsg(idx,"\tnum_gobs_in_vop = %d\n", p->num_gobs_in_vop);
 776     va_TraceMsg(idx,"\tnum_macroblocks_in_gob = %d\n", p->num_macroblocks_in_gob);
 777     va_TraceMsg(idx,"\tTRB = %d\n", p->TRB);
 778     va_TraceMsg(idx,"\tTRD = %d\n", p->TRD);
 779     va_TraceMsg(idx, NULL);
 780
 781     return;
 782 }
 783
 784
 785 static void va_TraceVAIQMatrixBufferMPEG4(
 786     VADisplay dpy,
 787     VAContextID context,
 788     VABufferID buffer,
 789     VABufferType type,
 790     unsigned int size,
 791     unsigned int num_elements,
 792     void *data)
 793 {
 794     int i;
 795     VAIQMatrixBufferMPEG4 *p=(VAIQMatrixBufferMPEG4 *)data;
 796     DPY2INDEX(dpy);
 797
 798     va_TraceMsg(idx,"VAIQMatrixBufferMPEG4\n");
 799
 800     va_TraceMsg(idx,"\tload_intra_quant_mat = %d\n", p->load_intra_quant_mat);
 801     va_TraceMsg(idx,"\tload_non_intra_quant_mat = %d\n", p->load_non_intra_quant_mat);
 802     va_TraceMsg(idx,"\tintra_quant_mat =\n");
 803     for(i=0;i<64;i++)
 804         va_TraceMsg(idx,"\t\t%d\n", p->intra_quant_mat[i]);
 805
 806     va_TraceMsg(idx,"\tnon_intra_quant_mat =\n");
 807     for(i=0;i<64;i++)
 808         va_TraceMsg(idx,"\t\t%d\n", p->non_intra_quant_mat[i]);
 809     va_TraceMsg(idx, NULL);
 810
 811     return;
 812 }
 813
 814
 815 static void va_TraceVASliceParameterBufferMPEG4(
 816     VADisplay dpy,
 817     VAContextID context,
 818     VABufferID buffer,
 819     VABufferType type,
 820     unsigned int size,
 821     unsigned int num_elements,
 822     void *data)
 823 {
 824     VASliceParameterBufferMPEG4 *p=(VASliceParameterBufferMPEG4 *)data;
 825
 826     DPY2INDEX(dpy);
 827
 828     trace_context[idx].trace_slice_no++;
 829
 830     trace_context[idx].trace_slice_size = p->slice_data_size;
 831
 832     va_TraceMsg(idx,"VASliceParameterBufferMPEG4\n");
 833
 834     va_TraceMsg(idx,"\tslice_data_size = %d\n", p->slice_data_size);
 835     va_TraceMsg(idx,"\tslice_data_offset = %d\n", p->slice_data_offset);
 836     va_TraceMsg(idx,"\tslice_data_flag = %d\n", p->slice_data_flag);
 837     va_TraceMsg(idx,"\tmacroblock_offset = %d\n", p->macroblock_offset);
 838     va_TraceMsg(idx,"\tmacroblock_number = %d\n", p->macroblock_number);
 839     va_TraceMsg(idx,"\tquant_scale = %d\n", p->quant_scale);
 840     va_TraceMsg(idx, NULL);
 841
 842     return;
 843 }
 844
 845
 846 static inline void va_TraceFlagIfNotZero(
 847     int idx,            /* in */
 848     const char *name,   /* in */
 849     unsigned int flag   /* in */
 850 )
 851 {
 852     if (flag != 0) {
 853         va_TraceMsg(idx, "%s = %x\n", name, flag);
 854     }
 855 }
 856
 857
 858 static void va_TraceVAPictureParameterBufferH264(
 859     VADisplay dpy,
 860     VAContextID context,
 861     VABufferID buffer,
 862     VABufferType type,
 863     unsigned int size,
 864     unsigned int num_elements,
 865     void *data)
 866 {
 867     int i;
 868     VAPictureParameterBufferH264 *p = (VAPictureParameterBufferH264*)data;
 869
 870     DPY2INDEX(dpy);
 871
 872     va_TraceMsg(idx, "VAPictureParameterBufferH264\n");
 873
 874     va_TraceMsg(idx, "\tCurrPic.picture_id = 0x%08x\n", p->CurrPic.picture_id);
 875     va_TraceMsg(idx, "\tCurrPic.frame_idx = %d\n", p->CurrPic.frame_idx);
 876     va_TraceMsg(idx, "\tCurrPic.flags = %d\n", p->CurrPic.flags);
 877     va_TraceMsg(idx, "\tCurrPic.TopFieldOrderCnt = %d\n", p->CurrPic.TopFieldOrderCnt);
 878     va_TraceMsg(idx, "\tCurrPic.BottomFieldOrderCnt = %d\n", p->CurrPic.BottomFieldOrderCnt);
 879
 880     va_TraceMsg(idx, "\tReferenceFrames (TopFieldOrderCnt-BottomFieldOrderCnt-picture_id-frame_idx:\n");
 881     for (i = 0; i < 16; i++)
 882     {
 883         if (p->ReferenceFrames[i].flags != VA_PICTURE_H264_INVALID) {
 884             va_TraceMsg(idx, "\t\t%d-%d-0x%08x-%d\n",
 885                         p->ReferenceFrames[i].TopFieldOrderCnt,
 886                         p->ReferenceFrames[i].BottomFieldOrderCnt,
 887                         p->ReferenceFrames[i].picture_id,
 888                         p->ReferenceFrames[i].frame_idx);
 889         } else
 890             va_TraceMsg(idx, "\t\tinv-inv-inv-inv\n");
 891     }
 892     va_TraceMsg(idx, "\n");
 893
 894     va_TraceMsg(idx, "\tpicture_width_in_mbs_minus1 = %d\n", p->picture_width_in_mbs_minus1);
 895     va_TraceMsg(idx, "\tpicture_height_in_mbs_minus1 = %d\n", p->picture_height_in_mbs_minus1);
 896     va_TraceMsg(idx, "\tbit_depth_luma_minus8 = %d\n", p->bit_depth_luma_minus8);
 897     va_TraceMsg(idx, "\tbit_depth_chroma_minus8 = %d\n", p->bit_depth_chroma_minus8);
 898     va_TraceMsg(idx, "\tnum_ref_frames = %d\n", p->num_ref_frames);
 899     va_TraceMsg(idx, "\tseq fields = %d\n", p->seq_fields.value);
 900     va_TraceMsg(idx, "\tchroma_format_idc = %d\n", p->seq_fields.bits.chroma_format_idc);
 901     va_TraceMsg(idx, "\tresidual_colour_transform_flag = %d\n", p->seq_fields.bits.residual_colour_transform_flag);
 902     va_TraceMsg(idx, "\tframe_mbs_only_flag = %d\n", p->seq_fields.bits.frame_mbs_only_flag);
 903     va_TraceMsg(idx, "\tmb_adaptive_frame_field_flag = %d\n", p->seq_fields.bits.mb_adaptive_frame_field_flag);
 904     va_TraceMsg(idx, "\tdirect_8x8_inference_flag = %d\n", p->seq_fields.bits.direct_8x8_inference_flag);
 905     va_TraceMsg(idx, "\tMinLumaBiPredSize8x8 = %d\n", p->seq_fields.bits.MinLumaBiPredSize8x8);
 906     va_TraceMsg(idx, "\tnum_slice_groups_minus1 = %d\n", p->num_slice_groups_minus1);
 907     va_TraceMsg(idx, "\tslice_group_map_type = %d\n", p->slice_group_map_type);
 908     va_TraceMsg(idx, "\tslice_group_change_rate_minus1 = %d\n", p->slice_group_change_rate_minus1);
 909     va_TraceMsg(idx, "\tpic_init_qp_minus26 = %d\n", p->pic_init_qp_minus26);
 910     va_TraceMsg(idx, "\tpic_init_qs_minus26 = %d\n", p->pic_init_qs_minus26);
 911     va_TraceMsg(idx, "\tchroma_qp_index_offset = %d\n", p->chroma_qp_index_offset);
 912     va_TraceMsg(idx, "\tsecond_chroma_qp_index_offset = %d\n", p->second_chroma_qp_index_offset);
 913     va_TraceMsg(idx, "\tpic_fields = 0x%03x\n", p->pic_fields.value);
 914     va_TraceFlagIfNotZero(idx, "\t\tentropy_coding_mode_flag", p->pic_fields.bits.entropy_coding_mode_flag);
 915     va_TraceFlagIfNotZero(idx, "\t\tweighted_pred_flag", p->pic_fields.bits.weighted_pred_flag);
 916     va_TraceFlagIfNotZero(idx, "\t\tweighted_bipred_idc", p->pic_fields.bits.weighted_bipred_idc);
 917     va_TraceFlagIfNotZero(idx, "\t\ttransform_8x8_mode_flag", p->pic_fields.bits.transform_8x8_mode_flag);
 918     va_TraceFlagIfNotZero(idx, "\t\tfield_pic_flag", p->pic_fields.bits.field_pic_flag);
 919     va_TraceFlagIfNotZero(idx, "\t\tconstrained_intra_pred_flag", p->pic_fields.bits.constrained_intra_pred_flag);
 920     va_TraceFlagIfNotZero(idx, "\t\tpic_order_present_flag", p->pic_fields.bits.pic_order_present_flag);
 921     va_TraceFlagIfNotZero(idx, "\t\tdeblocking_filter_control_present_flag", p->pic_fields.bits.deblocking_filter_control_present_flag);
 922     va_TraceFlagIfNotZero(idx, "\t\tredundant_pic_cnt_present_flag", p->pic_fields.bits.redundant_pic_cnt_present_flag);
 923     va_TraceFlagIfNotZero(idx, "\t\treference_pic_flag", p->pic_fields.bits.reference_pic_flag);
 924     va_TraceMsg(idx, "\tframe_num = %d\n", p->frame_num);
 925     va_TraceMsg(idx, NULL);
 926
 927     return;
 928 }
 929
 930 static void va_TraceVASliceParameterBufferH264(
 931     VADisplay dpy,
 932     VAContextID context,
 933     VABufferID buffer,
 934     VABufferType type,
 935     unsigned int size,
 936     unsigned int num_elements,
 937     void *data)
 938 {
 939     int i;
 940     VASliceParameterBufferH264* p = (VASliceParameterBufferH264*)data;
 941     DPY2INDEX(dpy);
 942
 943     trace_context[idx].trace_slice_no++;
 944     trace_context[idx].trace_slice_size = p->slice_data_size;
 945
 946     va_TraceMsg(idx, "VASliceParameterBufferH264\n");
 947     va_TraceMsg(idx, "\tslice_data_size = %d\n", p->slice_data_size);
 948     va_TraceMsg(idx, "\tslice_data_offset = %d\n", p->slice_data_offset);
 949     va_TraceMsg(idx, "\tslice_data_flag = %d\n", p->slice_data_flag);
 950     va_TraceMsg(idx, "\tslice_data_bit_offset = %d\n", p->slice_data_bit_offset);
 951     va_TraceMsg(idx, "\tfirst_mb_in_slice = %d\n", p->first_mb_in_slice);
 952     va_TraceMsg(idx, "\tslice_type = %d\n", p->slice_type);
 953     va_TraceMsg(idx, "\tdirect_spatial_mv_pred_flag = %d\n", p->direct_spatial_mv_pred_flag);
 954     va_TraceMsg(idx, "\tnum_ref_idx_l0_active_minus1 = %d\n", p->num_ref_idx_l0_active_minus1);
 955     va_TraceMsg(idx, "\tnum_ref_idx_l1_active_minus1 = %d\n", p->num_ref_idx_l1_active_minus1);
 956     va_TraceMsg(idx, "\tcabac_init_idc = %d\n", p->cabac_init_idc);
 957     va_TraceMsg(idx, "\tslice_qp_delta = %d\n", p->slice_qp_delta);
 958     va_TraceMsg(idx, "\tdisable_deblocking_filter_idc = %d\n", p->disable_deblocking_filter_idc);
 959     va_TraceMsg(idx, "\tslice_alpha_c0_offset_div2 = %d\n", p->slice_alpha_c0_offset_div2);
 960     va_TraceMsg(idx, "\tslice_beta_offset_div2 = %d\n", p->slice_beta_offset_div2);
 961
 962     if (p->slice_type == 0 || p->slice_type == 1) {
 963         va_TraceMsg(idx, "\tRefPicList0 =");
 964         for (i = 0; i < p->num_ref_idx_l0_active_minus1 + 1; i++) {
 965             va_TraceMsg(idx, "%d-%d-0x%08x-%d\n", p->RefPicList0[i].TopFieldOrderCnt, p->RefPicList0[i].BottomFieldOrderCnt, p->RefPicList0[i].picture_id, p->RefPicList0[i].frame_idx);
 966         }
 967         if (p->slice_type == 1) {
 968             va_TraceMsg(idx, "\tRefPicList1 =");
 969             for (i = 0; i < p->num_ref_idx_l1_active_minus1 + 1; i++)
 970             {
 971                 va_TraceMsg(idx, "%d-%d-0x%08x-%d\n", p->RefPicList1[i].TopFieldOrderCnt, p->RefPicList1[i].BottomFieldOrderCnt, p->RefPicList1[i].picture_id, p->RefPicList1[i].frame_idx);
 972             }
 973         }
 974     }
 975
 976     va_TraceMsg(idx, "\tluma_log2_weight_denom = %d\n", p->luma_log2_weight_denom);
 977     va_TraceMsg(idx, "\tchroma_log2_weight_denom = %d\n", p->chroma_log2_weight_denom);
 978     va_TraceMsg(idx, "\tluma_weight_l0_flag = %d\n", p->luma_weight_l0_flag);
 979     if (p->luma_weight_l0_flag) {
 980         for (i = 0; i <=  p->num_ref_idx_l0_active_minus1; i++) {
 981             va_TraceMsg(idx, "\t%d ", p->luma_weight_l0[i]);
 982             va_TraceMsg(idx, "\t%d ", p->luma_offset_l0[i]);
 983         }
 984     }
 985
 986     va_TraceMsg(idx, "\tchroma_weight_l0_flag = %d\n", p->chroma_weight_l0_flag);
 987     if (p->chroma_weight_l0_flag) {
 988         for (i = 0; i <= p->num_ref_idx_l0_active_minus1; i++) {
 989             va_TraceMsg(idx, "\t\t%d ", p->chroma_weight_l0[i][0]);
 990             va_TraceMsg(idx, "\t\t%d ", p->chroma_offset_l0[i][0]);
 991             va_TraceMsg(idx, "\t\t%d ", p->chroma_weight_l0[i][1]);
 992             va_TraceMsg(idx, "\t\t%d ", p->chroma_offset_l0[i][1]);
 993         }
 994     }
 995
 996     va_TraceMsg(idx, "\tluma_weight_l1_flag = %d\n", p->luma_weight_l1_flag);
 997     if (p->luma_weight_l1_flag) {
 998         for (i = 0; i <=  p->num_ref_idx_l1_active_minus1; i++) {
 999             va_TraceMsg(idx, "\t\t%d ", p->luma_weight_l1[i]);
1000             va_TraceMsg(idx, "\t\t%d ", p->luma_offset_l1[i]);
1001         }
1002     }
1003
1004     va_TraceMsg(idx, "\tchroma_weight_l1_flag = %d\n", p->chroma_weight_l1_flag);
1005     if (p->chroma_weight_l1_flag) {
1006         for (i = 0; i <= p->num_ref_idx_l1_active_minus1; i++) {
1007             va_TraceMsg(idx, "\t\t%d ", p->chroma_weight_l1[i][0]);
1008             va_TraceMsg(idx, "\t\t%d ", p->chroma_offset_l1[i][0]);
1009             va_TraceMsg(idx, "\t\t%d ", p->chroma_weight_l1[i][1]);
1010             va_TraceMsg(idx, "\t\t%d ", p->chroma_offset_l1[i][1]);
1011         }
1012         va_TraceMsg(idx, "\n");
1013     }
1014     va_TraceMsg(idx, NULL);
1015 }
1016
1017 static void va_TraceVAIQMatrixBufferH264(
1018     VADisplay dpy,
1019     VAContextID context,
1020     VABufferID buffer,
1021     VABufferType type,
1022     unsigned int size,
1023     unsigned int num_elements,
1024     void *data
1025 )
1026 {
1027     int i, j;
1028     VAIQMatrixBufferH264* p = (VAIQMatrixBufferH264* )data;
1029
1030     DPY2INDEX(dpy);
1031
1032     va_TraceMsg(idx, "VAIQMatrixBufferH264\n");
1033
1034     va_TraceMsg(idx, "\tScalingList4x4[6][16]=\n");
1035     for (i = 0; i < 6; i++) {
1036         for (j = 0; j < 16; j++) {
1037             va_TraceMsg(idx, "\t%d\t", p->ScalingList4x4[i][j]);
1038             if ((j + 1) % 8 == 0)
1039                 va_TraceMsg(idx, "\n");
1040         }
1041     }
1042
1043     va_TraceMsg(idx, "\tScalingList8x8[2][64]=\n");
1044     for (i = 0; i < 2; i++) {
1045         for (j = 0; j < 64; j++) {
1046             va_TraceMsg(idx, "\t%d", p->ScalingList8x8[i][j]);
1047             if ((j + 1) % 8 == 0)
1048                 va_TraceMsg(idx, "\n");
1049         }
1050     }
1051
1052     va_TraceMsg(idx, NULL);
1053 }
1054
1055 static void va_TraceVAEncSequenceParameterBufferH264(
1056     VADisplay dpy,
1057     VAContextID context,
1058     VABufferID buffer,
1059     VABufferType type,
1060     unsigned int size,
1061     unsigned int num_elements,
1062     void *data)
1063 {
1064     VAEncSequenceParameterBufferH264 *p = (VAEncSequenceParameterBufferH264 *)data;
1065     DPY2INDEX(dpy);
1066
1067     va_TraceMsg(idx, "VAEncSequenceParameterBufferH264\n");
1068
1069     va_TraceMsg(idx, "\tseq_parameter_set_id = %d\n", p->seq_parameter_set_id);
1070     va_TraceMsg(idx, "\tlevel_idc = %d\n", p->level_idc);
1071     va_TraceMsg(idx, "\tintra_period = %d\n", p->intra_period);
1072     va_TraceMsg(idx, "\tintra_idr_period = %d\n", p->intra_idr_period);
1073     va_TraceMsg(idx, "\tmax_num_ref_frames = %d\n", p->max_num_ref_frames);
1074     va_TraceMsg(idx, "\tpicture_width_in_mbs = %d\n", p->picture_width_in_mbs);
1075     va_TraceMsg(idx, "\tpicture_height_in_mbs = %d\n", p->picture_height_in_mbs);
1076     va_TraceMsg(idx, "\tbits_per_second = %d\n", p->bits_per_second);
1077     va_TraceMsg(idx, "\tframe_rate = %d\n", p->frame_rate);
1078     va_TraceMsg(idx, "\tinitial_qp = %d\n", p->initial_qp);
1079     va_TraceMsg(idx, "\tmin_qp = %d\n", p->min_qp);
1080     va_TraceMsg(idx, "\tbasic_unit_size = %d\n", p->basic_unit_size);
1081     va_TraceMsg(idx, "\tvui_flag = %d\n", p->vui_flag);
1082     va_TraceMsg(idx, NULL);
1083
1084     /* start a new sequce, coded log file can be truncated */
1085     trace_context[idx].trace_sequence_start = 1;
1086
1087     return;
1088 }
1089
1090 static void va_TraceVAEncPictureParameterBufferH264(
1091     VADisplay dpy,
1092     VAContextID context,
1093     VABufferID buffer,
1094     VABufferType type,
1095     unsigned int size,
1096     unsigned int num_elements,
1097     void *data)
1098 {
1099     VAEncPictureParameterBufferH264 *p = (VAEncPictureParameterBufferH264 *)data;
1100     DPY2INDEX(dpy);
1101
1102     va_TraceMsg(idx, "VAEncPictureParameterBufferH264\n");
1103     va_TraceMsg(idx, "\treference_picture = 0x%08x\n", p->reference_picture);
1104     va_TraceMsg(idx, "\treconstructed_picture = 0x%08x\n", p->reconstructed_picture);
1105     va_TraceMsg(idx, "\tcoded_buf = %08x\n", p->coded_buf);
1106     va_TraceMsg(idx, "\tpicture_width = %d\n", p->picture_width);
1107     va_TraceMsg(idx, "\tpicture_height = %d\n", p->picture_height);
1108     va_TraceMsg(idx, "\tlast_picture = 0x%08x\n", p->last_picture);
1109     va_TraceMsg(idx, NULL);
1110
1111     trace_context[idx].trace_codedbuf =  p->coded_buf;
1112
1113     return;
1114 }
1115
1116
1117 static void va_TraceVAEncSliceParameterBuffer(
1118     VADisplay dpy,
1119     VAContextID context,
1120     VABufferID buffer,
1121     VABufferType type,
1122     unsigned int size,
1123     unsigned int num_elements,
1124     void *data)
1125 {
1126     VAEncSliceParameterBuffer* p = (VAEncSliceParameterBuffer*)data;
1127     DPY2INDEX(dpy);
1128
1129     va_TraceMsg(idx, "VAEncSliceParameterBuffer\n");
1130
1131     va_TraceMsg(idx, "\tstart_row_number = %d\n", p->start_row_number);
1132     va_TraceMsg(idx, "\tslice_height = %d\n", p->slice_height);
1133     va_TraceMsg(idx, "\tslice_flags.is_intra = %d\n", p->slice_flags.bits.is_intra);
1134     va_TraceMsg(idx, "\tslice_flags.disable_deblocking_filter_idc = %d\n", p->slice_flags.bits.disable_deblocking_filter_idc);
1135     va_TraceMsg(idx, "\tslice_flags.uses_long_term_ref = %d\n", p->slice_flags.bits.uses_long_term_ref);
1136     va_TraceMsg(idx, "\tslice_flags.is_long_term_ref = %d\n", p->slice_flags.bits.is_long_term_ref);
1137     va_TraceMsg(idx, NULL);
1138
1139     return;
1140 }
1141
1142 static void va_TraceVAEncMiscParameterBuffer(
1143     VADisplay dpy,
1144     VAContextID context,
1145     VABufferID buffer,
1146     VABufferType type,
1147     unsigned int size,
1148     unsigned int num_elements,
1149     void *data)
1150 {
1151     VAEncMiscParameterBuffer* tmp = (VAEncMiscParameterBuffer*)data;
1152     DPY2INDEX(dpy);
1153
1154     switch (tmp->type) {
1155     case VAEncMiscParameterTypeFrameRate:
1156     {
1157         VAEncMiscParameterFrameRate *p = (VAEncMiscParameterFrameRate *)tmp->data;
1158         va_TraceMsg(idx, "VAEncMiscParameterFrameRate\n");
1159         va_TraceMsg(idx, "\tframerate = %d\n", p->framerate);
1160
1161         break;
1162     }
1163     case VAEncMiscParameterTypeRateControl:
1164     {
1165         VAEncMiscParameterRateControl *p = (VAEncMiscParameterRateControl *)tmp->data;
1166
1167         va_TraceMsg(idx, "VAEncMiscParameterRateControl\n");
1168         va_TraceMsg(idx, "\tbits_per_second = %d\n", p->bits_per_second);
1169         va_TraceMsg(idx, "\twindow_size = %d\n", p->window_size);
1170         va_TraceMsg(idx, "\tinitial_qp = %d\n", p->initial_qp);
1171         va_TraceMsg(idx, "\tmin_qp = %d\n", p->min_qp);
1172         break;
1173     }
1174     case VAEncMiscParameterTypeMaxSliceSize:
1175     {
1176         VAEncMiscParameterMaxSliceSize *p = (VAEncMiscParameterMaxSliceSize *)tmp->data;
1177
1178         va_TraceMsg(idx, "VAEncMiscParameterTypeMaxSliceSize\n");
1179         va_TraceMsg(idx, "\tmax_slice_size = %d\n", p->max_slice_size);
1180         break;
1181     }
1182     case VAEncMiscParameterTypeAIR:
1183     {
1184         VAEncMiscParameterAIR *p = (VAEncMiscParameterAIR *)tmp->data;
1185
1186         va_TraceMsg(idx, "VAEncMiscParameterAIR\n");
1187         va_TraceMsg(idx, "\tair_num_mbs = %d\n", p->air_num_mbs);
1188         va_TraceMsg(idx, "\tair_threshold = %d\n", p->air_threshold);
1189         va_TraceMsg(idx, "\tair_auto = %d\n", p->air_auto);
1190         break;
1191     }
1192     default:
1193         va_TraceMsg(idx, "invalid VAEncMiscParameterBuffer type = %d\n", tmp->type);
1194         break;
1195     }
1196     va_TraceMsg(idx, NULL);
1197
1198     return;
1199 }
1200
1201
1202 static void va_TraceVAPictureParameterBufferVC1(
1203     VADisplay dpy,
1204     VAContextID context,
1205     VABufferID buffer,
1206     VABufferType type,
1207     unsigned int size,
1208     unsigned int num_elements,
1209     void *data
1210 )
1211 {
1212     VAPictureParameterBufferVC1* p = (VAPictureParameterBufferVC1*)data;
1213     DPY2INDEX(dpy);
1214
1215     va_TraceMsg(idx, "VAPictureParameterBufferVC1\n");
1216
1217     va_TraceMsg(idx, "\tforward_reference_picture = 0x%08x\n", p->forward_reference_picture);
1218     va_TraceMsg(idx, "\tbackward_reference_picture = 0x%08x\n", p->backward_reference_picture);
1219     va_TraceMsg(idx, "\tinloop_decoded_picture = 0x%08x\n", p->inloop_decoded_picture);
1220
1221     va_TraceMsg(idx, "\tpulldown = %d\n", p->sequence_fields.bits.pulldown);
1222     va_TraceMsg(idx, "\tinterlace = %d\n", p->sequence_fields.bits.interlace);
1223     va_TraceMsg(idx, "\ttfcntrflag = %d\n", p->sequence_fields.bits.tfcntrflag);
1224     va_TraceMsg(idx, "\tfinterpflag = %d\n", p->sequence_fields.bits.finterpflag);
1225     va_TraceMsg(idx, "\tpsf = %d\n", p->sequence_fields.bits.psf);
1226     va_TraceMsg(idx, "\tmultires = %d\n", p->sequence_fields.bits.multires);
1227     va_TraceMsg(idx, "\toverlap = %d\n", p->sequence_fields.bits.overlap);
1228     va_TraceMsg(idx, "\tsyncmarker = %d\n", p->sequence_fields.bits.syncmarker);
1229     va_TraceMsg(idx, "\trangered = %d\n", p->sequence_fields.bits.rangered);
1230     va_TraceMsg(idx, "\tmax_b_frames = %d\n", p->sequence_fields.bits.max_b_frames);
1231     va_TraceMsg(idx, "\tprofile = %d\n", p->sequence_fields.bits.profile);
1232     va_TraceMsg(idx, "\tcoded_width = %d\n", p->coded_width);
1233     va_TraceMsg(idx, "\tcoded_height = %d\n", p->coded_height);
1234     va_TraceMsg(idx, "\tclosed_entry = %d\n", p->entrypoint_fields.bits.closed_entry);
1235     va_TraceMsg(idx, "\tbroken_link = %d\n", p->entrypoint_fields.bits.broken_link);
1236     va_TraceMsg(idx, "\tclosed_entry = %d\n", p->entrypoint_fields.bits.closed_entry);
1237     va_TraceMsg(idx, "\tpanscan_flag = %d\n", p->entrypoint_fields.bits.panscan_flag);
1238     va_TraceMsg(idx, "\tloopfilter = %d\n", p->entrypoint_fields.bits.loopfilter);
1239     va_TraceMsg(idx, "\tconditional_overlap_flag = %d\n", p->conditional_overlap_flag);
1240     va_TraceMsg(idx, "\tfast_uvmc_flag = %d\n", p->fast_uvmc_flag);
1241     va_TraceMsg(idx, "\trange_mapping_luma_flag = %d\n", p->range_mapping_fields.bits.luma_flag);
1242     va_TraceMsg(idx, "\trange_mapping_luma = %d\n", p->range_mapping_fields.bits.luma);
1243     va_TraceMsg(idx, "\trange_mapping_chroma_flag = %d\n", p->range_mapping_fields.bits.chroma_flag);
1244     va_TraceMsg(idx, "\trange_mapping_chroma = %d\n", p->range_mapping_fields.bits.chroma);
1245     va_TraceMsg(idx, "\tb_picture_fraction = %d\n", p->b_picture_fraction);
1246     va_TraceMsg(idx, "\tcbp_table = %d\n", p->cbp_table);
1247     va_TraceMsg(idx, "\tmb_mode_table = %d\n", p->mb_mode_table);
1248     va_TraceMsg(idx, "\trange_reduction_frame = %d\n", p->range_reduction_frame);
1249     va_TraceMsg(idx, "\trounding_control = %d\n", p->rounding_control);
1250     va_TraceMsg(idx, "\tpost_processing = %d\n", p->post_processing);
1251     va_TraceMsg(idx, "\tpicture_resolution_index = %d\n", p->picture_resolution_index);
1252     va_TraceMsg(idx, "\tluma_scale = %d\n", p->luma_scale);
1253     va_TraceMsg(idx, "\tluma_shift = %d\n", p->luma_shift);
1254     va_TraceMsg(idx, "\tpicture_type = %d\n", p->picture_fields.bits.picture_type);
1255     va_TraceMsg(idx, "\tframe_coding_mode = %d\n", p->picture_fields.bits.frame_coding_mode);
1256     va_TraceMsg(idx, "\ttop_field_first = %d\n", p->picture_fields.bits.top_field_first);
1257     va_TraceMsg(idx, "\tis_first_field = %d\n", p->picture_fields.bits.is_first_field);
1258     va_TraceMsg(idx, "\tintensity_compensation = %d\n", p->picture_fields.bits.intensity_compensation);
1259     va_TraceMsg(idx, "\tmv_type_mb = %d\n", p->raw_coding.flags.mv_type_mb);
1260     va_TraceMsg(idx, "\tdirect_mb = %d\n", p->raw_coding.flags.direct_mb);
1261     va_TraceMsg(idx, "\tskip_mb = %d\n", p->raw_coding.flags.skip_mb);
1262     va_TraceMsg(idx, "\tfield_tx = %d\n", p->raw_coding.flags.field_tx);
1263     va_TraceMsg(idx, "\tforward_mb = %d\n", p->raw_coding.flags.forward_mb);
1264     va_TraceMsg(idx, "\tac_pred = %d\n", p->raw_coding.flags.ac_pred);
1265     va_TraceMsg(idx, "\toverflags = %d\n", p->raw_coding.flags.overflags);
1266     va_TraceMsg(idx, "\tbp_mv_type_mb = %d\n", p->bitplane_present.flags.bp_mv_type_mb);
1267     va_TraceMsg(idx, "\tbp_direct_mb = %d\n", p->bitplane_present.flags.bp_direct_mb);
1268     va_TraceMsg(idx, "\tbp_skip_mb = %d\n", p->bitplane_present.flags.bp_skip_mb);
1269     va_TraceMsg(idx, "\tbp_field_tx = %d\n", p->bitplane_present.flags.bp_field_tx);
1270     va_TraceMsg(idx, "\tbp_forward_mb = %d\n", p->bitplane_present.flags.bp_forward_mb);
1271     va_TraceMsg(idx, "\tbp_ac_pred = %d\n", p->bitplane_present.flags.bp_ac_pred);
1272     va_TraceMsg(idx, "\tbp_overflags = %d\n", p->bitplane_present.flags.bp_overflags);
1273     va_TraceMsg(idx, "\treference_distance_flag = %d\n", p->reference_fields.bits.reference_distance_flag);
1274     va_TraceMsg(idx, "\treference_distance = %d\n", p->reference_fields.bits.reference_distance);
1275     va_TraceMsg(idx, "\tnum_reference_pictures = %d\n", p->reference_fields.bits.num_reference_pictures);
1276     va_TraceMsg(idx, "\treference_field_pic_indicator = %d\n", p->reference_fields.bits.reference_field_pic_indicator);
1277     va_TraceMsg(idx, "\tmv_mode = %d\n", p->mv_fields.bits.mv_mode);
1278     va_TraceMsg(idx, "\tmv_mode2 = %d\n", p->mv_fields.bits.mv_mode2);
1279     va_TraceMsg(idx, "\tmv_table = %d\n", p->mv_fields.bits.mv_table);
1280     va_TraceMsg(idx, "\ttwo_mv_block_pattern_table = %d\n", p->mv_fields.bits.two_mv_block_pattern_table);
1281     va_TraceMsg(idx, "\tfour_mv_switch = %d\n", p->mv_fields.bits.four_mv_switch);
1282     va_TraceMsg(idx, "\tfour_mv_block_pattern_table = %d\n", p->mv_fields.bits.four_mv_block_pattern_table);
1283     va_TraceMsg(idx, "\textended_mv_flag = %d\n", p->mv_fields.bits.extended_mv_flag);
1284     va_TraceMsg(idx, "\textended_mv_range = %d\n", p->mv_fields.bits.extended_mv_range);
1285     va_TraceMsg(idx, "\textended_dmv_flag = %d\n", p->mv_fields.bits.extended_dmv_flag);
1286     va_TraceMsg(idx, "\textended_dmv_range = %d\n", p->mv_fields.bits.extended_dmv_range);
1287     va_TraceMsg(idx, "\tdquant = %d\n", p->pic_quantizer_fields.bits.dquant);
1288     va_TraceMsg(idx, "\tquantizer = %d\n", p->pic_quantizer_fields.bits.quantizer);
1289     va_TraceMsg(idx, "\thalf_qp = %d\n", p->pic_quantizer_fields.bits.half_qp);
1290     va_TraceMsg(idx, "\tpic_quantizer_scale = %d\n", p->pic_quantizer_fields.bits.pic_quantizer_scale);
1291     va_TraceMsg(idx, "\tpic_quantizer_type = %d\n", p->pic_quantizer_fields.bits.pic_quantizer_type);
1292     va_TraceMsg(idx, "\tdq_frame = %d\n", p->pic_quantizer_fields.bits.dq_frame);
1293     va_TraceMsg(idx, "\tdq_profile = %d\n", p->pic_quantizer_fields.bits.dq_profile);
1294     va_TraceMsg(idx, "\tdq_sb_edge = %d\n", p->pic_quantizer_fields.bits.dq_sb_edge);
1295     va_TraceMsg(idx, "\tdq_db_edge = %d\n", p->pic_quantizer_fields.bits.dq_db_edge);
1296     va_TraceMsg(idx, "\tdq_binary_level = %d\n", p->pic_quantizer_fields.bits.dq_binary_level);
1297     va_TraceMsg(idx, "\talt_pic_quantizer = %d\n", p->pic_quantizer_fields.bits.alt_pic_quantizer);
1298     va_TraceMsg(idx, "\tvariable_sized_transform_flag = %d\n", p->transform_fields.bits.variable_sized_transform_flag);
1299     va_TraceMsg(idx, "\tmb_level_transform_type_flag = %d\n", p->transform_fields.bits.mb_level_transform_type_flag);
1300     va_TraceMsg(idx, "\tframe_level_transform_type = %d\n", p->transform_fields.bits.frame_level_transform_type);
1301     va_TraceMsg(idx, "\ttransform_ac_codingset_idx1 = %d\n", p->transform_fields.bits.transform_ac_codingset_idx1);
1302     va_TraceMsg(idx, "\ttransform_ac_codingset_idx2 = %d\n", p->transform_fields.bits.transform_ac_codingset_idx2);
1303     va_TraceMsg(idx, "\tintra_transform_dc_table = %d\n", p->transform_fields.bits.intra_transform_dc_table);
1304     va_TraceMsg(idx, NULL);
1305 }
1306
1307 static void va_TraceVASliceParameterBufferVC1(
1308     VADisplay dpy,
1309     VAContextID context,
1310     VABufferID buffer,
1311     VABufferType type,
1312     unsigned int size,
1313     unsigned int num_elements,
1314     void* data
1315 )
1316 {
1317     VASliceParameterBufferVC1 *p = (VASliceParameterBufferVC1*)data;
1318     DPY2INDEX(dpy);
1319
1320     trace_context[idx].trace_slice_no++;
1321     trace_context[idx].trace_slice_size = p->slice_data_size;
1322
1323     va_TraceMsg(idx, "VASliceParameterBufferVC1\n");
1324     va_TraceMsg(idx, "\tslice_data_size = %d\n", p->slice_data_size);
1325     va_TraceMsg(idx, "\tslice_data_offset = %d\n", p->slice_data_offset);
1326     va_TraceMsg(idx, "\tslice_data_flag = %d\n", p->slice_data_flag);
1327     va_TraceMsg(idx, "\tmacroblock_offset = %d\n", p->macroblock_offset);
1328     va_TraceMsg(idx, "\tslice_vertical_position = %d\n", p->slice_vertical_position);
1329     va_TraceMsg(idx, NULL);
1330 }
1331
1332 void va_TraceBeginPicture(
1333     VADisplay dpy,
1334     VAContextID context,
1335     VASurfaceID render_target
1336 )
1337 {
1338     DPY2INDEX(dpy);
1339
1340     TRACE_FUNCNAME(idx);
1341
1342     va_TraceMsg(idx, "\tcontext = 0x%08x\n", context);
1343     va_TraceMsg(idx, "\trender_targets = 0x%08x\n", render_target);
1344     va_TraceMsg(idx, "\tframe_count  = #%d\n", trace_context[idx].trace_frame_no);
1345     va_TraceMsg(idx, NULL);
1346
1347     trace_context[idx].trace_rendertarget = render_target; /* for surface data dump after vaEndPicture */
1348
1349     trace_context[idx].trace_frame_no++;
1350     trace_context[idx].trace_slice_no = 0;
1351 }
1352
1353 static void va_TraceMPEG2Buf(
1354     VADisplay dpy,
1355     VAContextID context,
1356     VABufferID buffer,
1357     VABufferType type,
1358     unsigned int size,
1359     unsigned int num_elements,
1360     void *pbuf
1361 )
1362 {
1363     switch (type) {
1364     case VAPictureParameterBufferType:
1365         va_TraceVAPictureParameterBufferMPEG2(dpy, context, buffer, type, size, num_elements, pbuf);
1366         break;
1367     case VAIQMatrixBufferType:
1368         va_TraceVAIQMatrixBufferMPEG2(dpy, context, buffer, type, size, num_elements, pbuf);
1369         break;
1370     case VABitPlaneBufferType:
1371         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1372         break;
1373     case VASliceGroupMapBufferType:
1374         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1375         break;
1376     case VASliceParameterBufferType:
1377         va_TraceVASliceParameterBufferMPEG2(dpy, context, buffer, type, size, num_elements, pbuf);
1378         break;
1379     case VASliceDataBufferType:
1380         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1381         break;
1382     case VAMacroblockParameterBufferType:
1383         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1384         break;
1385     case VAResidualDataBufferType:
1386         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1387         break;
1388     case VADeblockingParameterBufferType:
1389         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1390         break;
1391     case VAImageBufferType:
1392         break;
1393     case VAProtectedSliceDataBufferType:
1394         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1395         break;
1396     case VAEncCodedBufferType:
1397         break;
1398     case VAEncSequenceParameterBufferType:
1399         break;
1400     case VAEncPictureParameterBufferType:
1401         break;
1402     case VAEncSliceParameterBufferType:
1403         break;
1404     case VAEncH264VUIBufferType:
1405         break;
1406     case VAEncH264SEIBufferType:
1407         break;
1408     default:
1409         break;
1410     }
1411 }
1412
1413 static void va_TraceMPEG4Buf(
1414     VADisplay dpy,
1415     VAContextID context,
1416     VABufferID buffer,
1417     VABufferType type,
1418     unsigned int size,
1419     unsigned int num_elements,
1420     void *pbuf
1421 )
1422 {
1423     switch (type) {
1424     case VAPictureParameterBufferType:
1425         va_TraceVAPictureParameterBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
1426         break;
1427     case VAIQMatrixBufferType:
1428         va_TraceVAIQMatrixBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
1429         break;
1430     case VABitPlaneBufferType:
1431         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1432         break;
1433     case VASliceGroupMapBufferType:
1434         break;
1435     case VASliceParameterBufferType:
1436         va_TraceVASliceParameterBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
1437         break;
1438     case VASliceDataBufferType:
1439         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1440         break;
1441     case VAMacroblockParameterBufferType:
1442         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1443         break;
1444     case VAResidualDataBufferType:
1445         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1446         break;
1447     case VADeblockingParameterBufferType:
1448         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1449         break;
1450     case VAImageBufferType:
1451         break;
1452     case VAProtectedSliceDataBufferType:
1453         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1454         break;
1455     case VAEncCodedBufferType:
1456         break;
1457     case VAEncSequenceParameterBufferType:
1458         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1459         break;
1460     case VAEncPictureParameterBufferType:
1461         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1462         break;
1463     case VAEncSliceParameterBufferType:
1464         va_TraceVAEncSliceParameterBuffer(dpy, context, buffer, type, size, num_elements, pbuf);
1465         break;
1466     case VAEncH264VUIBufferType:
1467         break;
1468     case VAEncH264SEIBufferType:
1469         break;
1470     default:
1471         break;
1472     }
1473 }
1474
1475
1476 static void va_TraceH264Buf(
1477     VADisplay dpy,
1478     VAContextID context,
1479     VABufferID buffer,
1480     VABufferType type,
1481     unsigned int size,
1482     unsigned int num_elements,
1483     void *pbuf
1484 )
1485 {
1486     DPY2INDEX(dpy);
1487
1488     switch (type) {
1489     case VAPictureParameterBufferType:
1490         va_TraceVAPictureParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
1491         break;
1492     case VAIQMatrixBufferType:
1493         va_TraceVAIQMatrixBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
1494         break;
1495     case VABitPlaneBufferType:
1496         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1497         break;
1498     case VASliceGroupMapBufferType:
1499         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1500         break;
1501     case VASliceParameterBufferType:
1502         va_TraceVASliceParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
1503         break;
1504     case VASliceDataBufferType:
1505         va_TraceVABuffers(dpy, context, buffer, type, trace_context[idx].trace_slice_size, num_elements, pbuf);
1506         break;
1507     case VAMacroblockParameterBufferType:
1508         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1509         break;
1510     case VAResidualDataBufferType:
1511         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1512         break;
1513     case VADeblockingParameterBufferType:
1514         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1515         break;
1516     case VAImageBufferType:
1517         break;
1518     case VAProtectedSliceDataBufferType:
1519         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1520         break;
1521     case VAEncCodedBufferType:
1522         break;
1523     case VAEncSequenceParameterBufferType:
1524         va_TraceVAEncSequenceParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
1525         break;
1526     case VAEncPictureParameterBufferType:
1527         va_TraceVAEncPictureParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
1528         break;
1529     case VAEncSliceParameterBufferType:
1530         va_TraceVAEncSliceParameterBuffer(dpy, context, buffer, type, size, num_elements, pbuf);
1531         break;
1532     case VAEncH264VUIBufferType:
1533         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1534         break;
1535     case VAEncH264SEIBufferType:
1536         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1537         break;
1538     case VAEncMiscParameterBufferType:
1539         va_TraceVAEncMiscParameterBuffer(dpy, context, buffer, type, size, num_elements, pbuf);
1540         break;
1541     default:
1542         break;
1543     }
1544 }
1545
1546
1547 static void va_TraceVC1Buf(
1548     VADisplay dpy,
1549     VAContextID context,
1550     VABufferID buffer,
1551     VABufferType type,
1552     unsigned int size,
1553     unsigned int num_elements,
1554     void *pbuf
1555 )
1556 {
1557     DPY2INDEX(dpy);
1558
1559     switch (type) {
1560     case VAPictureParameterBufferType:
1561         va_TraceVAPictureParameterBufferVC1(dpy, context, buffer, type, size, num_elements, pbuf);
1562         break;
1563     case VAIQMatrixBufferType:
1564         break;
1565     case VABitPlaneBufferType:
1566         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1567         break;
1568     case VASliceGroupMapBufferType:
1569         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1570         break;
1571     case VASliceParameterBufferType:
1572         va_TraceVASliceParameterBufferVC1(dpy, context, buffer, type, size, num_elements, pbuf);
1573         break;
1574     case VASliceDataBufferType:
1575         va_TraceVABuffers(dpy, context, buffer, type, trace_context[idx].trace_slice_size, num_elements, pbuf);
1576         break;
1577     case VAMacroblockParameterBufferType:
1578         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1579         break;
1580     case VAResidualDataBufferType:
1581         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1582         break;
1583     case VADeblockingParameterBufferType:
1584         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1585         break;
1586     case VAImageBufferType:
1587         break;
1588     case VAProtectedSliceDataBufferType:
1589         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1590         break;
1591     case VAEncCodedBufferType:
1592         break;
1593     case VAEncSequenceParameterBufferType:
1594         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1595         break;
1596     case VAEncPictureParameterBufferType:
1597         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1598         break;
1599     case VAEncSliceParameterBufferType:
1600         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1601         break;
1602     default:
1603         break;
1604     }
1605 }
1606
1607 void va_TraceRenderPicture(
1608     VADisplay dpy,
1609     VAContextID context,
1610     VABufferID *buffers,
1611     int num_buffers
1612 )
1613 {
1614     VABufferType type;
1615     unsigned int size;
1616     unsigned int num_elements;
1617     int i;
1618     DPY2INDEX(dpy);
1619
1620     TRACE_FUNCNAME(idx);
1621
1622     va_TraceMsg(idx, "\tcontext = 0x%08x\n", context);
1623     va_TraceMsg(idx, "\tnum_buffers = %d\n", num_buffers);
1624     for (i = 0; i < num_buffers; i++) {
1625         void *pbuf;
1626         unsigned int j;
1627
1628         /* get buffer type information */
1629         vaBufferInfo(dpy, context, buffers[i], &type, &size, &num_elements);
1630
1631         va_TraceMsg(idx, "\t---------------------------\n");
1632         va_TraceMsg(idx, "\tbuffers[%d] = 0x%08x\n", i, buffers[i]);
1633         va_TraceMsg(idx, "\t  type = %s\n", buffer_type_to_string(type));
1634         va_TraceMsg(idx, "\t  size = %d\n", size);
1635         va_TraceMsg(idx, "\t  num_elements = %d\n", num_elements);
1636
1637         vaMapBuffer(dpy, buffers[i], &pbuf);
1638
1639         switch (trace_context[idx].trace_profile) {
1640         case VAProfileMPEG2Simple:
1641         case VAProfileMPEG2Main:
1642             for (j=0; j<num_elements; j++) {
1643                 va_TraceMsg(idx, "\t------------------", j);
1644                 va_TraceMsg(idx, "\telement[%d] = ", j);
1645                 va_TraceMPEG2Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
1646             }
1647             break;
1648         case VAProfileMPEG4Simple:
1649         case VAProfileMPEG4AdvancedSimple:
1650         case VAProfileMPEG4Main:
1651             for (j=0; j<num_elements; j++) {
1652                 va_TraceMsg(idx, "\t------------------", j);
1653                 va_TraceMsg(idx, "\telement[%d] = ", j);
1654                 va_TraceMPEG4Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
1655             }
1656             break;
1657         case VAProfileH264Baseline:
1658         case VAProfileH264Main:
1659         case VAProfileH264High:
1660         case VAProfileH264ConstrainedBaseline:
1661             for (j=0; j<num_elements; j++) {
1662                 va_TraceMsg(idx, "\t---------------------------\n", j);
1663                 va_TraceMsg(idx, "\telement[%d] = ", j);
1664
1665                 va_TraceH264Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
1666             }
1667             break;
1668         case VAProfileVC1Simple:
1669         case VAProfileVC1Main:
1670         case VAProfileVC1Advanced:
1671             for (j=0; j<num_elements; j++) {
1672                 va_TraceMsg(idx, "\t---------------------------\n", j);
1673                 va_TraceMsg(idx, "\telement[%d] = ", j);
1674
1675                 va_TraceVC1Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
1676             }
1677             break;
1678         case VAProfileH263Baseline:
1679             for (j=0; j<num_elements; j++) {
1680                 va_TraceMsg(idx, "\t---------------------------\n", j);
1681                 va_TraceMsg(idx, "\telement[%d] = ", j);
1682
1683                 va_TraceMPEG4Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
1684             }
1685             break;
1686         default:
1687             break;
1688         }
1689
1690         vaUnmapBuffer(dpy, buffers[i]);
1691     }
1692
1693     va_TraceMsg(idx, NULL);
1694 }
1695
1696
1697 void va_TraceEndPicture(
1698     VADisplay dpy,
1699     VAContextID context
1700 )
1701 {
1702     DPY2INDEX(dpy);
1703
1704     TRACE_FUNCNAME(idx);
1705
1706     va_TraceMsg(idx, "\tcontext = 0x%08x\n", context);
1707     va_TraceMsg(idx, "\trender_targets = 0x%08x\n", trace_context[idx].trace_rendertarget);
1708
1709     /* want to trace codedbuf, and it is encode */
1710     if (trace_context[idx].trace_fp_codedbuf &&
1711         ((trace_context[idx].trace_entrypoint == VAEntrypointEncSlice) ||
1712          (trace_context[idx].trace_entrypoint == VAEntrypointEncPicture))) {
1713         /* force the pipleline finish rendering */
1714         vaSyncSurface(dpy, trace_context[idx].trace_rendertarget);
1715         va_TraceCodedBuf(dpy);
1716     }
1717
1718     /* trace decoded surface for decoding, or the source sourface for encoding */
1719     if (trace_context[idx].trace_fp_surface) {
1720         /* force the pipleline finish rendering */
1721         vaSyncSurface(dpy, trace_context[idx].trace_rendertarget);
1722
1723         va_TraceSurface(dpy);
1724     }
1725
1726     va_TraceMsg(idx, NULL);
1727 }
1728
1729 void va_TraceSyncSurface(
1730     VADisplay dpy,
1731     VASurfaceID render_target
1732 )
1733 {
1734     DPY2INDEX(dpy);
1735
1736     TRACE_FUNCNAME(idx);
1737
1738     va_TraceMsg(idx, "\trender_target = 0x%08x\n", render_target);
1739     va_TraceMsg(idx, NULL);
1740 }
1741
1742
1743 void va_TraceQuerySurfaceStatus(
1744     VADisplay dpy,
1745     VASurfaceID render_target,
1746     VASurfaceStatus *status    /* out */
1747 )
1748 {
1749     DPY2INDEX(dpy);
1750
1751     TRACE_FUNCNAME(idx);
1752
1753     va_TraceMsg(idx, "\trender_target = 0x%08x\n", render_target);
1754     va_TraceMsg(idx, "\tstatus = 0x%08x\n", *status);
1755     va_TraceMsg(idx, NULL);
1756 }
1757
1758
1759 void va_TraceQuerySurfaceError(
1760     VADisplay dpy,
1761     VASurfaceID surface,
1762     VAStatus error_status,
1763     void **error_info       /*out*/
1764 )
1765 {
1766     DPY2INDEX(dpy);
1767
1768     TRACE_FUNCNAME(idx);
1769     va_TraceMsg(idx, "\tsurface = 0x%08x\n", surface);
1770     va_TraceMsg(idx, "\terror_status = 0x%08x\n", error_status);
1771     if (error_status == VA_STATUS_ERROR_DECODING_ERROR) {
1772         VASurfaceDecodeMBErrors *p = *error_info;
1773         while (p->status != -1) {
1774             va_TraceMsg(idx, "\t\tstatus = %d\n", p->status);
1775             va_TraceMsg(idx, "\t\tstart_mb = %d\n", p->start_mb);
1776             va_TraceMsg(idx, "\t\tend_mb = %d\n", p->end_mb);
1777             p++; /* next error record */
1778         }
1779     }
1780     va_TraceMsg(idx, NULL);
1781 }
1782
1783 void va_TraceMaxNumDisplayAttributes (
1784     VADisplay dpy,
1785     int number
1786 )
1787 {
1788     DPY2INDEX(dpy);
1789
1790     TRACE_FUNCNAME(idx);
1791
1792     va_TraceMsg(idx, "\tmax_display_attributes = %d\n", number);
1793     va_TraceMsg(idx, NULL);
1794 }
1795
1796 void va_TraceQueryDisplayAttributes (
1797     VADisplay dpy,
1798     VADisplayAttribute *attr_list,    /* out */
1799     int *num_attributes               /* out */
1800 )
1801 {
1802     int i;
1803
1804     DPY2INDEX(dpy);
1805
1806     va_TraceMsg(idx, "\tnum_attributes = %d\n", *num_attributes);
1807
1808     for (i=0; i<*num_attributes; i++) {
1809         va_TraceMsg(idx, "\tattr_list[%d] =\n");
1810         va_TraceMsg(idx, "\t  typ = 0x%08x\n", attr_list[i].type);
1811         va_TraceMsg(idx, "\t  min_value = %d\n", attr_list[i].min_value);
1812         va_TraceMsg(idx, "\t  max_value = %d\n", attr_list[i].max_value);
1813         va_TraceMsg(idx, "\t  value = %d\n", attr_list[i].value);
1814         va_TraceMsg(idx, "\t  flags = %d\n", attr_list[i].flags);
1815     }
1816     va_TraceMsg(idx, NULL);
1817 }
1818
1819
1820 static void va_TraceDisplayAttributes (
1821     VADisplay dpy,
1822     VADisplayAttribute *attr_list,
1823     int num_attributes
1824 )
1825 {
1826     int i;
1827
1828     DPY2INDEX(dpy);
1829
1830     va_TraceMsg(idx, "\tnum_attributes = %d\n", num_attributes);
1831     for (i=0; i<num_attributes; i++) {
1832         va_TraceMsg(idx, "\tattr_list[%d] =\n");
1833         va_TraceMsg(idx, "\t  typ = 0x%08x\n", attr_list[i].type);
1834         va_TraceMsg(idx, "\t  min_value = %d\n", attr_list[i].min_value);
1835         va_TraceMsg(idx, "\t  max_value = %d\n", attr_list[i].max_value);
1836         va_TraceMsg(idx, "\t  value = %d\n", attr_list[i].value);
1837         va_TraceMsg(idx, "\t  flags = %d\n", attr_list[i].flags);
1838     }
1839     va_TraceMsg(idx, NULL);
1840 }
1841
1842
1843 void va_TraceGetDisplayAttributes (
1844     VADisplay dpy,
1845     VADisplayAttribute *attr_list,
1846     int num_attributes
1847 )
1848 {
1849     DPY2INDEX(dpy);
1850
1851     TRACE_FUNCNAME(idx);
1852
1853     va_TraceDisplayAttributes (dpy, attr_list, num_attributes);
1854 }
1855
1856 void va_TraceSetDisplayAttributes (
1857     VADisplay dpy,
1858     VADisplayAttribute *attr_list,
1859     int num_attributes
1860 )
1861 {
1862     DPY2INDEX(dpy);
1863
1864     TRACE_FUNCNAME(idx);
1865
1866     va_TraceDisplayAttributes (dpy, attr_list, num_attributes);
1867 }
1868
1869
1870 void va_TracePutSurface (
1871     VADisplay dpy,
1872     VASurfaceID surface,
1873     void *draw, /* the target Drawable */
1874     short srcx,
1875     short srcy,
1876     unsigned short srcw,
1877     unsigned short srch,
1878     short destx,
1879     short desty,
1880     unsigned short destw,
1881     unsigned short desth,
1882     VARectangle *cliprects, /* client supplied clip list */
1883     unsigned int number_cliprects, /* number of clip rects in the clip list */
1884     unsigned int flags /* de-interlacing flags */
1885 )
1886 {
1887     DPY2INDEX(dpy);
1888
1889     TRACE_FUNCNAME(idx);
1890
1891     va_TraceMsg(idx, "\tsurface = 0x%08x\n", surface);
1892     va_TraceMsg(idx, "\tdraw = 0x%08x\n", draw);
1893     va_TraceMsg(idx, "\tsrcx = %d\n", srcx);
1894     va_TraceMsg(idx, "\tsrcy = %d\n", srcy);
1895     va_TraceMsg(idx, "\tsrcw = %d\n", srcw);
1896     va_TraceMsg(idx, "\tsrch = %d\n", srch);
1897     va_TraceMsg(idx, "\tdestx = %d\n", destx);
1898     va_TraceMsg(idx, "\tdesty = %d\n", desty);
1899     va_TraceMsg(idx, "\tdestw = %d\n", destw);
1900     va_TraceMsg(idx, "\tdesth = %d\n", desth);
1901     va_TraceMsg(idx, "\tcliprects = 0x%08x\n", cliprects);
1902     va_TraceMsg(idx, "\tnumber_cliprects = %d\n", number_cliprects);
1903     va_TraceMsg(idx, "\tflags = 0x%08x\n", flags);
1904     va_TraceMsg(idx, NULL);
1905 }