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