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