va/va_trace.c

   1
   2 /*
   3  * Copyright (c) 2009-2011 Intel Corporation. All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sub license, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the
  14  * next paragraph) shall be included in all copies or substantial portions
  15  * of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  20  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  21  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  22  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  23  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26 #define _GNU_SOURCE 1
  27 #include "sysdeps.h"
  28 #include "va.h"
  29 #include "va_enc_h264.h"
  30 #include "va_backend.h"
  31 #include "va_trace.h"
  32 #include "va_enc_h264.h"
  33 #include "va_enc_jpeg.h"
  34 #include "va_dec_jpeg.h"
  35 #include "va_dec_vp8.h"
  36 #include "va_dec_hevc.h"
  37 #include "va_vpp.h"
  38 #include <assert.h>
  39 #include <stdarg.h>
  40 #include <stdlib.h>
  41 #include <stdio.h>
  42 #include <string.h>
  43 #include <dlfcn.h>
  44 #include <unistd.h>
  45 #include <sys/types.h>
  46 #include <sys/stat.h>
  47 #include <unistd.h>
  48 #include <time.h>
  49 #include <errno.h>
  50
  51 /*
  52  * Env. to debug some issue, e.g. the decode/encode issue in a video conference scenerio:
  53  * .LIBVA_TRACE=log_file: general VA parameters saved into log_file
  54  * .LIBVA_TRACE_BUFDATA: dump all VA data buffer into log_file
  55  * .LIBVA_TRACE_CODEDBUF=coded_clip_file: save the coded clip into file coded_clip_file
  56  * .LIBVA_TRACE_SURFACE=yuv_file: save surface YUV into file yuv_file. Use file name to determine
  57  *                                decode/encode or jpeg surfaces
  58  * .LIBVA_TRACE_SURFACE_GEOMETRY=WIDTHxHEIGHT+XOFF+YOFF: only save part of surface context into file
  59  *                                due to storage bandwidth limitation
  60  */
  61
  62 /* global settings */
  63
  64 /* LIBVA_TRACE */
  65 int trace_flag = 0;
  66
  67 /* per context settings */
  68 struct trace_context {
  69     /* LIBVA_TRACE */
  70     FILE *trace_fp_log; /* save the log into a file */
  71     char *trace_log_fn; /* file name */
  72
  73     /* LIBVA_TRACE_CODEDBUF */
  74     FILE *trace_fp_codedbuf; /* save the encode result into a file */
  75     char *trace_codedbuf_fn; /* file name */
  76
  77     /* LIBVA_TRACE_SURFACE */
  78     FILE *trace_fp_surface; /* save the surface YUV into a file */
  79     char *trace_surface_fn; /* file name */
  80
  81     VAContextID  trace_context; /* current context */
  82
  83     VASurfaceID  trace_rendertarget; /* current render target */
  84     VAProfile trace_profile; /* current profile for buffers */
  85     VAEntrypoint trace_entrypoint; /* current entrypoint */
  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_surface_width; /* surface dumping geometry */
  92     unsigned int trace_surface_height;
  93     unsigned int trace_surface_xoff;
  94     unsigned int trace_surface_yoff;
  95
  96     unsigned int trace_frame_width; /* current frame width */
  97     unsigned int trace_frame_height; /* current frame height */
  98 };
  99
 100 #define TRACE_CTX(dpy) ((struct trace_context *)((VADisplayContextP)dpy)->vatrace)
 101
 102 #define DPY2TRACECTX(dpy)                               \
 103     struct trace_context *trace_ctx = TRACE_CTX(dpy);   \
 104                                                         \
 105     if (trace_ctx == NULL)                              \
 106         return;                                         \
 107
 108 #define TRACE_FUNCNAME(idx)    va_TraceMsg(trace_ctx, "==========%s\n", __func__);
 109
 110 /* Prototype declarations (functions defined in va.c) */
 111
 112 void va_errorMessage(const char *msg, ...);
 113 void va_infoMessage(const char *msg, ...);
 114
 115 int va_parseConfig(char *env, char *env_value);
 116
 117 VAStatus vaBufferInfo(
 118     VADisplay dpy,
 119     VAContextID context,        /* in */
 120     VABufferID buf_id,          /* in */
 121     VABufferType *type,         /* out */
 122     unsigned int *size,         /* out */
 123     unsigned int *num_elements  /* out */
 124     );
 125
 126 VAStatus vaLockSurface(VADisplay dpy,
 127                        VASurfaceID surface,
 128                        unsigned int *fourcc, /* following are output argument */
 129                        unsigned int *luma_stride,
 130                        unsigned int *chroma_u_stride,
 131                        unsigned int *chroma_v_stride,
 132                        unsigned int *luma_offset,
 133                        unsigned int *chroma_u_offset,
 134                        unsigned int *chroma_v_offset,
 135                        unsigned int *buffer_name,
 136                        void **buffer
 137                        );
 138
 139 VAStatus vaUnlockSurface(VADisplay dpy,
 140                          VASurfaceID surface
 141                          );
 142
 143 #define FILE_NAME_SUFFIX(env_value)                      \
 144 do {                                                    \
 145     int tmp = strnlen(env_value, sizeof(env_value));    \
 146     int left = sizeof(env_value) - tmp;                 \
 147                                                         \
 148     snprintf(env_value+tmp,                             \
 149              left,                                      \
 150              ".%04d.%08lx",                             \
 151              suffix,                                    \
 152              (unsigned long)trace_ctx);                 \
 153 } while (0)
 154
 155 void va_TraceInit(VADisplay dpy)
 156 {
 157     char env_value[1024];
 158     unsigned short suffix = 0xffff & ((unsigned int)time(NULL));
 159     int trace_index = 0;
 160     FILE *tmp;
 161     struct trace_context *trace_ctx = calloc(sizeof(struct trace_context), 1);
 162
 163     if (trace_ctx == NULL)
 164         return;
 165
 166     if (va_parseConfig("LIBVA_TRACE", &env_value[0]) == 0) {
 167         FILE_NAME_SUFFIX(env_value);
 168         trace_ctx->trace_log_fn = strdup(env_value);
 169
 170         tmp = fopen(env_value, "w");
 171         if (tmp) {
 172             trace_ctx->trace_fp_log = tmp;
 173             va_infoMessage("LIBVA_TRACE is on, save log into %s\n", trace_ctx->trace_log_fn);
 174             trace_flag = VA_TRACE_FLAG_LOG;
 175         } else
 176             va_errorMessage("Open file %s failed (%s)\n", env_value, strerror(errno));
 177     }
 178
 179     /* may re-get the global settings for multiple context */
 180     if ((trace_flag & VA_TRACE_FLAG_LOG) && (va_parseConfig("LIBVA_TRACE_BUFDATA", NULL) == 0)) {
 181         trace_flag |= VA_TRACE_FLAG_BUFDATA;
 182         va_infoMessage("LIBVA_TRACE_BUFDATA is on, dump buffer into log file\n");
 183     }
 184
 185     /* per-context setting */
 186     if (va_parseConfig("LIBVA_TRACE_CODEDBUF", &env_value[0]) == 0) {
 187         FILE_NAME_SUFFIX(env_value);
 188         trace_ctx->trace_codedbuf_fn = strdup(env_value);
 189         va_infoMessage("LIBVA_TRACE_CODEDBUF is on, save codedbuf into log file %s\n",
 190                        trace_ctx->trace_codedbuf_fn);
 191         trace_flag |= VA_TRACE_FLAG_CODEDBUF;
 192     }
 193
 194     if (va_parseConfig("LIBVA_TRACE_SURFACE", &env_value[0]) == 0) {
 195         FILE_NAME_SUFFIX(env_value);
 196         trace_ctx->trace_surface_fn = strdup(env_value);
 197
 198         va_infoMessage("LIBVA_TRACE_SURFACE is on, save surface into %s\n",
 199                        trace_ctx->trace_surface_fn);
 200
 201         /* for surface data dump, it is time-consume, and may
 202          * cause some side-effect, so only trace the needed surfaces
 203          * to trace encode surface, set the trace file name to sth like *enc*
 204          * to trace decode surface, set the trace file name to sth like *dec*
 205          * if no dec/enc in file name, set both
 206          */
 207         if (strstr(env_value, "dec"))
 208             trace_flag |= VA_TRACE_FLAG_SURFACE_DECODE;
 209         if (strstr(env_value, "enc"))
 210             trace_flag |= VA_TRACE_FLAG_SURFACE_ENCODE;
 211         if (strstr(env_value, "jpeg") || strstr(env_value, "jpg"))
 212             trace_flag |= VA_TRACE_FLAG_SURFACE_JPEG;
 213
 214         if (va_parseConfig("LIBVA_TRACE_SURFACE_GEOMETRY", &env_value[0]) == 0) {
 215             char *p = env_value, *q;
 216
 217             trace_ctx->trace_surface_width = strtod(p, &q);
 218             p = q+1; /* skip "x" */
 219             trace_ctx->trace_surface_height = strtod(p, &q);
 220             p = q+1; /* skip "+" */
 221             trace_ctx->trace_surface_xoff = strtod(p, &q);
 222             p = q+1; /* skip "+" */
 223             trace_ctx->trace_surface_yoff = strtod(p, &q);
 224
 225             va_infoMessage("LIBVA_TRACE_SURFACE_GEOMETRY is on, only dump surface %dx%d+%d+%d content\n",
 226                            trace_ctx->trace_surface_width,
 227                            trace_ctx->trace_surface_height,
 228                            trace_ctx->trace_surface_xoff,
 229                            trace_ctx->trace_surface_yoff);
 230         }
 231     }
 232
 233     ((VADisplayContextP)dpy)->vatrace = trace_ctx;
 234 }
 235
 236
 237 void va_TraceEnd(VADisplay dpy)
 238 {
 239     DPY2TRACECTX(dpy);
 240
 241     if (trace_ctx->trace_fp_log)
 242         fclose(trace_ctx->trace_fp_log);
 243
 244     if (trace_ctx->trace_fp_codedbuf)
 245         fclose(trace_ctx->trace_fp_codedbuf);
 246
 247     if (trace_ctx->trace_fp_surface)
 248         fclose(trace_ctx->trace_fp_surface);
 249
 250     if (trace_ctx->trace_log_fn)
 251         free(trace_ctx->trace_log_fn);
 252
 253     if (trace_ctx->trace_codedbuf_fn)
 254         free(trace_ctx->trace_codedbuf_fn);
 255
 256     if (trace_ctx->trace_surface_fn)
 257         free(trace_ctx->trace_surface_fn);
 258
 259     free(trace_ctx);
 260     ((VADisplayContextP)dpy)->vatrace = NULL;
 261 }
 262
 263 static void va_TraceMsg(struct trace_context *trace_ctx, const char *msg, ...)
 264 {
 265     va_list args;
 266
 267     if (!(trace_flag & VA_TRACE_FLAG_LOG))
 268         return;
 269
 270     if (msg)  {
 271         struct timeval tv;
 272
 273         if (gettimeofday(&tv, NULL) == 0)
 274             fprintf(trace_ctx->trace_fp_log, "[%04d.%06d] ",
 275                     (unsigned int)tv.tv_sec & 0xffff, (unsigned int)tv.tv_usec);
 276         va_start(args, msg);
 277         vfprintf(trace_ctx->trace_fp_log, msg, args);
 278         va_end(args);
 279     } else
 280         fflush(trace_ctx->trace_fp_log);
 281 }
 282
 283
 284 static void va_TraceSurface(VADisplay dpy)
 285 {
 286     unsigned int i, j;
 287     unsigned int fourcc; /* following are output argument */
 288     unsigned int luma_stride;
 289     unsigned int chroma_u_stride;
 290     unsigned int chroma_v_stride;
 291     unsigned int luma_offset;
 292     unsigned int chroma_u_offset;
 293     unsigned int chroma_v_offset;
 294     unsigned int buffer_name;
 295     void *buffer = NULL;
 296     unsigned char *Y_data, *UV_data, *tmp;
 297     VAStatus va_status;
 298     unsigned char check_sum = 0;
 299     DPY2TRACECTX(dpy);
 300
 301     if (!trace_ctx->trace_fp_surface)
 302         return;
 303
 304     va_TraceMsg(trace_ctx, "==========dump surface data in file %s\n", trace_ctx->trace_surface_fn);
 305
 306     va_TraceMsg(trace_ctx, NULL);
 307
 308     va_status = vaLockSurface(
 309         dpy,
 310         trace_ctx->trace_rendertarget,
 311         &fourcc,
 312         &luma_stride, &chroma_u_stride, &chroma_v_stride,
 313         &luma_offset, &chroma_u_offset, &chroma_v_offset,
 314         &buffer_name, &buffer);
 315
 316     if (va_status != VA_STATUS_SUCCESS) {
 317         va_TraceMsg(trace_ctx, "Error:vaLockSurface failed\n");
 318         return;
 319     }
 320
 321     va_TraceMsg(trace_ctx, "\tfourcc = 0x%08x\n", fourcc);
 322     va_TraceMsg(trace_ctx, "\twidth = %d\n", trace_ctx->trace_frame_width);
 323     va_TraceMsg(trace_ctx, "\theight = %d\n", trace_ctx->trace_frame_height);
 324     va_TraceMsg(trace_ctx, "\tluma_stride = %d\n", luma_stride);
 325     va_TraceMsg(trace_ctx, "\tchroma_u_stride = %d\n", chroma_u_stride);
 326     va_TraceMsg(trace_ctx, "\tchroma_v_stride = %d\n", chroma_v_stride);
 327     va_TraceMsg(trace_ctx, "\tluma_offset = %d\n", luma_offset);
 328     va_TraceMsg(trace_ctx, "\tchroma_u_offset = %d\n", chroma_u_offset);
 329     va_TraceMsg(trace_ctx, "\tchroma_v_offset = %d\n", chroma_v_offset);
 330
 331     if (buffer == NULL) {
 332         va_TraceMsg(trace_ctx, "Error:vaLockSurface return NULL buffer\n");
 333         va_TraceMsg(trace_ctx, NULL);
 334
 335         vaUnlockSurface(dpy, trace_ctx->trace_rendertarget);
 336         return;
 337     }
 338     va_TraceMsg(trace_ctx, "\tbuffer location = 0x%08x\n", buffer);
 339     va_TraceMsg(trace_ctx, NULL);
 340
 341     Y_data = (unsigned char*)buffer;
 342     UV_data = (unsigned char*)buffer + chroma_u_offset;
 343
 344     tmp = Y_data + luma_stride * trace_ctx->trace_surface_yoff;
 345     for (i=0; i<trace_ctx->trace_surface_height; i++) {
 346         fwrite(tmp + trace_ctx->trace_surface_xoff,
 347                trace_ctx->trace_surface_width,
 348                1, trace_ctx->trace_fp_surface);
 349
 350         tmp += luma_stride;
 351     }
 352     tmp = UV_data + chroma_u_stride * trace_ctx->trace_surface_yoff / 2;
 353     if (fourcc == VA_FOURCC_NV12) {
 354         for (i=0; i<trace_ctx->trace_surface_height/2; i++) {
 355             fwrite(tmp + trace_ctx->trace_surface_xoff,
 356                    trace_ctx->trace_surface_width,
 357                    1, trace_ctx->trace_fp_surface);
 358
 359             tmp += chroma_u_stride;
 360         }
 361     }
 362
 363     vaUnlockSurface(dpy, trace_ctx->trace_rendertarget);
 364
 365     va_TraceMsg(trace_ctx, NULL);
 366 }
 367
 368
 369 void va_TraceInitialize (
 370     VADisplay dpy,
 371     int *major_version,     /* out */
 372     int *minor_version      /* out */
 373 )
 374 {
 375     DPY2TRACECTX(dpy);
 376     TRACE_FUNCNAME(idx);
 377 }
 378
 379 void va_TraceTerminate (
 380     VADisplay dpy
 381 )
 382 {
 383     DPY2TRACECTX(dpy);
 384     TRACE_FUNCNAME(idx);
 385 }
 386
 387
 388 void va_TraceCreateConfig(
 389     VADisplay dpy,
 390     VAProfile profile,
 391     VAEntrypoint entrypoint,
 392     VAConfigAttrib *attrib_list,
 393     int num_attribs,
 394     VAConfigID *config_id /* out */
 395 )
 396 {
 397     int i;
 398     int encode, decode, jpeg;
 399     DPY2TRACECTX(dpy);
 400
 401     TRACE_FUNCNAME(idx);
 402
 403     va_TraceMsg(trace_ctx, "\tprofile = %d\n", profile);
 404     va_TraceMsg(trace_ctx, "\tentrypoint = %d\n", entrypoint);
 405     va_TraceMsg(trace_ctx, "\tnum_attribs = %d\n", num_attribs);
 406     if (attrib_list) {
 407         for (i = 0; i < num_attribs; i++) {
 408             va_TraceMsg(trace_ctx, "\t\tattrib_list[%d].type = 0x%08x\n", i, attrib_list[i].type);
 409             va_TraceMsg(trace_ctx, "\t\tattrib_list[%d].value = 0x%08x\n", i, attrib_list[i].value);
 410         }
 411     }
 412     va_TraceMsg(trace_ctx, NULL);
 413
 414     trace_ctx->trace_profile = profile;
 415     trace_ctx->trace_entrypoint = entrypoint;
 416
 417     /* avoid to create so many empty files */
 418     encode = (trace_ctx->trace_entrypoint == VAEntrypointEncSlice);
 419     decode = (trace_ctx->trace_entrypoint == VAEntrypointVLD);
 420     jpeg = (trace_ctx->trace_entrypoint == VAEntrypointEncPicture);
 421     if ((encode && (trace_flag & VA_TRACE_FLAG_SURFACE_ENCODE)) ||
 422         (decode && (trace_flag & VA_TRACE_FLAG_SURFACE_DECODE)) ||
 423         (jpeg && (trace_flag & VA_TRACE_FLAG_SURFACE_JPEG))) {
 424         FILE *tmp = fopen(trace_ctx->trace_surface_fn, "w");
 425
 426         if (tmp)
 427             trace_ctx->trace_fp_surface = tmp;
 428         else {
 429             va_errorMessage("Open file %s failed (%s)\n",
 430                             trace_ctx->trace_surface_fn,
 431                             strerror(errno));
 432             trace_ctx->trace_fp_surface = NULL;
 433             trace_flag &= ~(VA_TRACE_FLAG_SURFACE);
 434         }
 435     }
 436
 437     if (encode && (trace_flag & VA_TRACE_FLAG_CODEDBUF)) {
 438         FILE *tmp = fopen(trace_ctx->trace_codedbuf_fn, "w");
 439
 440         if (tmp)
 441             trace_ctx->trace_fp_codedbuf = tmp;
 442         else {
 443             va_errorMessage("Open file %s failed (%s)\n",
 444                             trace_ctx->trace_codedbuf_fn,
 445                             strerror(errno));
 446             trace_ctx->trace_fp_codedbuf = NULL;
 447             trace_flag &= ~VA_TRACE_FLAG_CODEDBUF;
 448         }
 449     }
 450 }
 451
 452 static void va_TraceSurfaceAttributes(
 453     struct trace_context *trace_ctx,
 454     VASurfaceAttrib    *attrib_list,
 455     unsigned int       *num_attribs
 456 )
 457 {
 458     int i, num;
 459     VASurfaceAttrib *p;
 460
 461     if (!attrib_list || !num_attribs)
 462         return;
 463
 464     p = attrib_list;
 465     num = *num_attribs;
 466     if (num > VASurfaceAttribCount)
 467         num = VASurfaceAttribCount;
 468
 469     for (i=0; i<num; i++) {
 470         int type = p->value.type;
 471
 472         va_TraceMsg(trace_ctx, "\tattrib_list[%i] =\n", i);
 473
 474         va_TraceMsg(trace_ctx, "\t\ttype = %d\n", p->type);
 475         va_TraceMsg(trace_ctx, "\t\tflags = %d\n", p->flags);
 476         va_TraceMsg(trace_ctx, "\t\tvalue.type = %d\n", type);
 477         switch (type) {
 478         case VAGenericValueTypeInteger:
 479             va_TraceMsg(trace_ctx, "\t\tvalue.value.i = 0x%08x\n", p->value.value.i);
 480             break;
 481         case VAGenericValueTypeFloat:
 482             va_TraceMsg(trace_ctx, "\t\tvalue.value.f = %f\n", p->value.value.f);
 483             break;
 484         case VAGenericValueTypePointer:
 485             va_TraceMsg(trace_ctx, "\t\tvalue.value.p = %p\n", p->value.value.p);
 486             if ((p->type == VASurfaceAttribExternalBufferDescriptor) && p->value.value.p) {
 487                 VASurfaceAttribExternalBuffers *tmp = (VASurfaceAttribExternalBuffers *) p->value.value.p;
 488                 int j;
 489
 490                 va_TraceMsg(trace_ctx, "\t\t--VASurfaceAttribExternalBufferDescriptor\n");
 491                 va_TraceMsg(trace_ctx, "\t\t  pixel_format=0x%08x\n", tmp->pixel_format);
 492                 va_TraceMsg(trace_ctx, "\t\t  width=%d\n", tmp->width);
 493                 va_TraceMsg(trace_ctx, "\t\t  height=%d\n", tmp->height);
 494                 va_TraceMsg(trace_ctx, "\t\t  data_size=%d\n", tmp->data_size);
 495                 va_TraceMsg(trace_ctx, "\t\t  num_planes=%d\n", tmp->num_planes);
 496                 va_TraceMsg(trace_ctx, "\t\t  pitches[4]=%d %d %d %d\n",
 497                             tmp->pitches[0], tmp->pitches[1], tmp->pitches[2], tmp->pitches[3]);
 498                 va_TraceMsg(trace_ctx, "\t\t  offsets[4]=%d %d %d %d\n",
 499                             tmp->offsets[0], tmp->offsets[1], tmp->offsets[2], tmp->offsets[3]);
 500                 va_TraceMsg(trace_ctx, "\t\t  flags=0x%08x\n", tmp->flags);
 501                 va_TraceMsg(trace_ctx, "\t\t  num_buffers=0x%08x\n", tmp->num_buffers);
 502                 va_TraceMsg(trace_ctx, "\t\t  buffers=%p\n", tmp->buffers);
 503                 for (j = 0; j < tmp->num_buffers; j++) {
 504                     va_TraceMsg(trace_ctx, "\t\t\tbuffers[%d]=%p\n", j, tmp->buffers[j]);
 505                 }
 506             }
 507             break;
 508         case VAGenericValueTypeFunc:
 509             va_TraceMsg(trace_ctx, "\t\tvalue.value.fn = %p\n", p->value.value.fn);
 510             break;
 511         default:
 512             break;
 513         }
 514
 515         p++;
 516     }
 517 }
 518
 519 void va_TraceCreateSurfaces(
 520     VADisplay dpy,
 521     int width,
 522     int height,
 523     int format,
 524     int num_surfaces,
 525     VASurfaceID *surfaces,    /* out */
 526     VASurfaceAttrib    *attrib_list,
 527     unsigned int        num_attribs
 528 )
 529 {
 530     int i;
 531     DPY2TRACECTX(dpy);
 532
 533     TRACE_FUNCNAME(idx);
 534
 535     va_TraceMsg(trace_ctx, "\twidth = %d\n", width);
 536     va_TraceMsg(trace_ctx, "\theight = %d\n", height);
 537     va_TraceMsg(trace_ctx, "\tformat = %d\n", format);
 538     va_TraceMsg(trace_ctx, "\tnum_surfaces = %d\n", num_surfaces);
 539
 540     if (surfaces) {
 541         for (i = 0; i < num_surfaces; i++)
 542             va_TraceMsg(trace_ctx, "\t\tsurfaces[%d] = 0x%08x\n", i, surfaces[i]);
 543     }
 544
 545     va_TraceSurfaceAttributes(trace_ctx, attrib_list, &num_attribs);
 546
 547     va_TraceMsg(trace_ctx, NULL);
 548 }
 549
 550
 551 void va_TraceDestroySurfaces(
 552     VADisplay dpy,
 553     VASurfaceID *surface_list,
 554     int num_surfaces
 555 )
 556 {
 557     int i;
 558     DPY2TRACECTX(dpy);
 559
 560     TRACE_FUNCNAME(idx);
 561
 562     if (surface_list) {
 563         for (i = 0; i < num_surfaces; i++)
 564             va_TraceMsg(trace_ctx, "\t\tsurfaces[%d] = 0x%08x\n", i, surface_list[i]);
 565     }
 566
 567     va_TraceMsg(trace_ctx, NULL);
 568 }
 569
 570
 571 void va_TraceCreateContext(
 572     VADisplay dpy,
 573     VAConfigID config_id,
 574     int picture_width,
 575     int picture_height,
 576     int flag,
 577     VASurfaceID *render_targets,
 578     int num_render_targets,
 579     VAContextID *context        /* out */
 580 )
 581 {
 582     int i;
 583     DPY2TRACECTX(dpy);
 584
 585     TRACE_FUNCNAME(idx);
 586
 587     va_TraceMsg(trace_ctx, "\tconfig = 0x%08x\n", config_id);
 588     va_TraceMsg(trace_ctx, "\twidth = %d\n", picture_width);
 589     va_TraceMsg(trace_ctx, "\theight = %d\n", picture_height);
 590     va_TraceMsg(trace_ctx, "\tflag = 0x%08x\n", flag);
 591     va_TraceMsg(trace_ctx, "\tnum_render_targets = %d\n", num_render_targets);
 592     if (render_targets) {
 593         for (i=0; i<num_render_targets; i++)
 594             va_TraceMsg(trace_ctx, "\t\trender_targets[%d] = 0x%08x\n", i, render_targets[i]);
 595     }
 596     if (context) {
 597         va_TraceMsg(trace_ctx, "\tcontext = 0x%08x\n", *context);
 598         trace_ctx->trace_context = *context;
 599     } else
 600         trace_ctx->trace_context = VA_INVALID_ID;
 601
 602     trace_ctx->trace_frame_no = 0;
 603     trace_ctx->trace_slice_no = 0;
 604
 605     trace_ctx->trace_frame_width = picture_width;
 606     trace_ctx->trace_frame_height = picture_height;
 607
 608     if (trace_ctx->trace_surface_width == 0)
 609         trace_ctx->trace_surface_width = picture_width;
 610     if (trace_ctx->trace_surface_height == 0)
 611         trace_ctx->trace_surface_height = picture_height;
 612 }
 613
 614
 615 static char * buffer_type_to_string(int type)
 616 {
 617     switch (type) {
 618     case VAPictureParameterBufferType: return "VAPictureParameterBufferType";
 619     case VAIQMatrixBufferType: return "VAIQMatrixBufferType";
 620     case VABitPlaneBufferType: return "VABitPlaneBufferType";
 621     case VASliceGroupMapBufferType: return "VASliceGroupMapBufferType";
 622     case VASliceParameterBufferType: return "VASliceParameterBufferType";
 623     case VASliceDataBufferType: return "VASliceDataBufferType";
 624     case VAProtectedSliceDataBufferType: return "VAProtectedSliceDataBufferType";
 625     case VAMacroblockParameterBufferType: return "VAMacroblockParameterBufferType";
 626     case VAResidualDataBufferType: return "VAResidualDataBufferType";
 627     case VADeblockingParameterBufferType: return "VADeblockingParameterBufferType";
 628     case VAImageBufferType: return "VAImageBufferType";
 629     case VAQMatrixBufferType: return "VAQMatrixBufferType";
 630     case VAHuffmanTableBufferType: return "VAHuffmanTableBufferType";
 631 /* Following are encode buffer types */
 632     case VAEncCodedBufferType: return "VAEncCodedBufferType";
 633     case VAEncSequenceParameterBufferType: return "VAEncSequenceParameterBufferType";
 634     case VAEncPictureParameterBufferType: return "VAEncPictureParameterBufferType";
 635     case VAEncSliceParameterBufferType: return "VAEncSliceParameterBufferType";
 636     case VAEncPackedHeaderParameterBufferType: return "VAEncPackedHeaderParameterBufferType";
 637     case VAEncPackedHeaderDataBufferType: return "VAEncPackedHeaderDataBufferType";
 638     case VAEncMiscParameterBufferType: return "VAEncMiscParameterBufferType";
 639     case VAEncMacroblockParameterBufferType: return "VAEncMacroblockParameterBufferType";
 640     case VAProcPipelineParameterBufferType: return "VAProcPipelineParameterBufferType";
 641     case VAProcFilterParameterBufferType: return "VAProcFilterParameterBufferType";
 642     default: return "UnknowBuffer";
 643     }
 644 }
 645
 646 void va_TraceCreateBuffer (
 647     VADisplay dpy,
 648     VAContextID context,        /* in */
 649     VABufferType type,          /* in */
 650     unsigned int size,          /* in */
 651     unsigned int num_elements,  /* in */
 652     void *data,                 /* in */
 653     VABufferID *buf_id          /* out */
 654 )
 655 {
 656     DPY2TRACECTX(dpy);
 657
 658     /* only trace CodedBuffer */
 659     if (type != VAEncCodedBufferType)
 660         return;
 661
 662     TRACE_FUNCNAME(idx);
 663     va_TraceMsg(trace_ctx, "\tbuf_type=%s\n", buffer_type_to_string(type));
 664     if (buf_id)
 665         va_TraceMsg(trace_ctx, "\tbuf_id=0x%x\n", *buf_id);
 666     va_TraceMsg(trace_ctx, "\tsize=%d\n", size);
 667     va_TraceMsg(trace_ctx, "\tnum_elements=%d\n", num_elements);
 668
 669     va_TraceMsg(trace_ctx, NULL);
 670 }
 671
 672 void va_TraceDestroyBuffer (
 673     VADisplay dpy,
 674     VABufferID buf_id    /* in */
 675 )
 676 {
 677     VABufferType type;
 678     unsigned int size;
 679     unsigned int num_elements;
 680
 681     VACodedBufferSegment *buf_list;
 682     int i = 0;
 683
 684     DPY2TRACECTX(dpy);
 685
 686     vaBufferInfo(dpy, trace_ctx->trace_context, buf_id, &type, &size, &num_elements);
 687
 688     /* only trace CodedBuffer */
 689     if (type != VAEncCodedBufferType)
 690         return;
 691
 692     TRACE_FUNCNAME(idx);
 693     va_TraceMsg(trace_ctx, "\tbuf_type=%s\n", buffer_type_to_string(type));
 694     va_TraceMsg(trace_ctx, "\tbuf_id=0x%x\n", buf_id);
 695     va_TraceMsg(trace_ctx, "\tsize=%d\n", size);
 696     va_TraceMsg(trace_ctx, "\tnum_elements=%d\n", num_elements);
 697
 698     va_TraceMsg(trace_ctx, NULL);
 699 }
 700
 701
 702 void va_TraceMapBuffer (
 703     VADisplay dpy,
 704     VABufferID buf_id,    /* in */
 705     void **pbuf           /* out */
 706 )
 707 {
 708     VABufferType type;
 709     unsigned int size;
 710     unsigned int num_elements;
 711
 712     VACodedBufferSegment *buf_list;
 713     int i = 0;
 714
 715     DPY2TRACECTX(dpy);
 716
 717     vaBufferInfo(dpy, trace_ctx->trace_context, buf_id, &type, &size, &num_elements);
 718
 719     /* only trace CodedBuffer */
 720     if (type != VAEncCodedBufferType)
 721         return;
 722
 723     TRACE_FUNCNAME(idx);
 724     va_TraceMsg(trace_ctx, "\tbuf_id=0x%x\n", buf_id);
 725     va_TraceMsg(trace_ctx, "\tbuf_type=%s\n", buffer_type_to_string(type));
 726     if ((pbuf == NULL) || (*pbuf == NULL))
 727         return;
 728
 729     buf_list = (VACodedBufferSegment *)(*pbuf);
 730     while (buf_list != NULL) {
 731         va_TraceMsg(trace_ctx, "\tCodedbuf[%d] =\n", i++);
 732
 733         va_TraceMsg(trace_ctx, "\t   size = %d\n", buf_list->size);
 734         va_TraceMsg(trace_ctx, "\t   bit_offset = %d\n", buf_list->bit_offset);
 735         va_TraceMsg(trace_ctx, "\t   status = 0x%08x\n", buf_list->status);
 736         va_TraceMsg(trace_ctx, "\t   reserved = 0x%08x\n", buf_list->reserved);
 737         va_TraceMsg(trace_ctx, "\t   buf = 0x%08x\n", buf_list->buf);
 738
 739         if (trace_ctx->trace_fp_codedbuf) {
 740             va_TraceMsg(trace_ctx, "\tDump the content to file\n");
 741             fwrite(buf_list->buf, buf_list->size, 1, trace_ctx->trace_fp_codedbuf);
 742         }
 743
 744         buf_list = buf_list->next;
 745     }
 746     va_TraceMsg(trace_ctx, NULL);
 747 }
 748
 749 static void va_TraceVABuffers(
 750     VADisplay dpy,
 751     VAContextID context,
 752     VABufferID buffer,
 753     VABufferType type,
 754     unsigned int size,
 755     unsigned int num_elements,
 756     void *pbuf
 757 )
 758 {
 759     unsigned int i;
 760     unsigned char *p = pbuf;
 761
 762     DPY2TRACECTX(dpy);
 763
 764     va_TraceMsg(trace_ctx, "--%s\n",  buffer_type_to_string(type));
 765
 766     if ((trace_flag & VA_TRACE_FLAG_BUFDATA) && trace_ctx->trace_fp_log) {
 767         for (i=0; i<size; i++) {
 768             unsigned char value =  p[i];
 769
 770             if (i==0)
 771                 fprintf(trace_ctx->trace_fp_log, "\t\t0x%04x:", i);
 772             else if ((i%16) == 0)
 773                 fprintf(trace_ctx->trace_fp_log, "\n\t\t0x%04x:", i);
 774
 775             fprintf(trace_ctx->trace_fp_log, " %02x", value);
 776         }
 777         fprintf(trace_ctx->trace_fp_log, "\n");
 778     }
 779
 780     va_TraceMsg(trace_ctx, NULL);
 781
 782     return;
 783 }
 784
 785
 786 static void va_TraceVAPictureParameterBufferMPEG2(
 787     VADisplay dpy,
 788     VAContextID context,
 789     VABufferID buffer,
 790     VABufferType type,
 791     unsigned int size,
 792     unsigned int num_elements,
 793     void *data)
 794 {
 795     VAPictureParameterBufferMPEG2 *p=(VAPictureParameterBufferMPEG2 *)data;
 796     DPY2TRACECTX(dpy);
 797
 798     va_TraceMsg(trace_ctx,"VAPictureParameterBufferMPEG2\n");
 799
 800     va_TraceMsg(trace_ctx,"\thorizontal size= %d\n", p->horizontal_size);
 801     va_TraceMsg(trace_ctx,"\tvertical size= %d\n", p->vertical_size);
 802     va_TraceMsg(trace_ctx,"\tforward reference picture= %d\n", p->forward_reference_picture);
 803     va_TraceMsg(trace_ctx,"\tbackward reference picture= %d\n", p->backward_reference_picture);
 804     va_TraceMsg(trace_ctx,"\tpicture coding type= %d\n", p->picture_coding_type);
 805     va_TraceMsg(trace_ctx,"\tf mode= %d\n", p->f_code);
 806
 807     va_TraceMsg(trace_ctx,"\tpicture coding extension = %d\n", p->picture_coding_extension.value);
 808     va_TraceMsg(trace_ctx,"\tintra_dc_precision= %d\n", p->picture_coding_extension.bits.intra_dc_precision);
 809     va_TraceMsg(trace_ctx,"\tpicture_structure= %d\n", p->picture_coding_extension.bits.picture_structure);
 810     va_TraceMsg(trace_ctx,"\ttop_field_first= %d\n", p->picture_coding_extension.bits.top_field_first);
 811     va_TraceMsg(trace_ctx,"\tframe_pred_frame_dct= %d\n", p->picture_coding_extension.bits.frame_pred_frame_dct);
 812     va_TraceMsg(trace_ctx,"\tconcealment_motion_vectors= %d\n", p->picture_coding_extension.bits.concealment_motion_vectors);
 813     va_TraceMsg(trace_ctx,"\tq_scale_type= %d\n", p->picture_coding_extension.bits.q_scale_type);
 814     va_TraceMsg(trace_ctx,"\tintra_vlc_format= %d\n", p->picture_coding_extension.bits.intra_vlc_format);
 815     va_TraceMsg(trace_ctx,"\talternate_scan= %d\n", p->picture_coding_extension.bits.alternate_scan);
 816     va_TraceMsg(trace_ctx,"\trepeat_first_field= %d\n", p->picture_coding_extension.bits.repeat_first_field);
 817     va_TraceMsg(trace_ctx,"\tprogressive_frame= %d\n", p->picture_coding_extension.bits.progressive_frame);
 818     va_TraceMsg(trace_ctx,"\tis_first_field= %d\n", p->picture_coding_extension.bits.is_first_field);
 819     va_TraceMsg(trace_ctx, NULL);
 820
 821     return;
 822 }
 823
 824
 825 static void va_TraceVAIQMatrixBufferMPEG2(
 826     VADisplay dpy,
 827     VAContextID context,
 828     VABufferID buffer,
 829     VABufferType type,
 830     unsigned int size,
 831     unsigned int num_elements,
 832     void *data)
 833 {
 834     VAIQMatrixBufferMPEG2 *p=(VAIQMatrixBufferMPEG2 *)data;
 835     DPY2TRACECTX(dpy);
 836
 837     va_TraceMsg(trace_ctx,"VAIQMatrixBufferMPEG2\n");
 838
 839     va_TraceMsg(trace_ctx,"\tload_intra_quantiser_matrix = %d\n", p->load_intra_quantiser_matrix);
 840     va_TraceMsg(trace_ctx,"\tload_non_intra_quantiser_matrix = %d\n", p->load_non_intra_quantiser_matrix);
 841     va_TraceMsg(trace_ctx,"\tload_chroma_intra_quantiser_matrix = %d\n", p->load_chroma_intra_quantiser_matrix);
 842     va_TraceMsg(trace_ctx,"\tload_chroma_non_intra_quantiser_matrix = %d\n", p->load_chroma_non_intra_quantiser_matrix);
 843     va_TraceMsg(trace_ctx,"\tintra_quantiser_matrix = %d\n", p->intra_quantiser_matrix);
 844     va_TraceMsg(trace_ctx,"\tnon_intra_quantiser_matrix = %d\n", p->non_intra_quantiser_matrix);
 845     va_TraceMsg(trace_ctx,"\tchroma_intra_quantiser_matrix = %d\n", p->chroma_intra_quantiser_matrix);
 846     va_TraceMsg(trace_ctx,"\tchroma_non_intra_quantiser_matrix = %d\n", p->chroma_non_intra_quantiser_matrix);
 847     va_TraceMsg(trace_ctx, NULL);
 848
 849     return;
 850 }
 851
 852
 853 static void va_TraceVASliceParameterBufferMPEG2(
 854     VADisplay dpy,
 855     VAContextID context,
 856     VABufferID buffer,
 857     VABufferType type,
 858     unsigned int size,
 859     unsigned int num_elements,
 860     void *data)
 861 {
 862     VASliceParameterBufferMPEG2 *p=(VASliceParameterBufferMPEG2 *)data;
 863
 864     DPY2TRACECTX(dpy);
 865
 866     trace_ctx->trace_slice_no++;
 867
 868     trace_ctx->trace_slice_size = p->slice_data_size;
 869
 870     va_TraceMsg(trace_ctx,"VASliceParameterBufferMPEG2\n");
 871
 872     va_TraceMsg(trace_ctx,"\tslice_data_size = %d\n", p->slice_data_size);
 873     va_TraceMsg(trace_ctx,"\tslice_data_offset = %d\n", p->slice_data_offset);
 874     va_TraceMsg(trace_ctx,"\tslice_data_flag = %d\n", p->slice_data_flag);
 875     va_TraceMsg(trace_ctx,"\tmacroblock_offset = %d\n", p->macroblock_offset);
 876     va_TraceMsg(trace_ctx,"\tslice_horizontal_position = %d\n", p->slice_horizontal_position);
 877     va_TraceMsg(trace_ctx,"\tslice_vertical_position = %d\n", p->slice_vertical_position);
 878     va_TraceMsg(trace_ctx,"\tquantiser_scale_code = %d\n", p->quantiser_scale_code);
 879     va_TraceMsg(trace_ctx,"\tintra_slice_flag = %d\n", p->intra_slice_flag);
 880     va_TraceMsg(trace_ctx, NULL);
 881
 882     return;
 883 }
 884
 885 static void va_TraceVAPictureParameterBufferJPEG(
 886     VADisplay dpy,
 887     VAContextID context,
 888     VABufferID buffer,
 889     VABufferType type,
 890     unsigned int size,
 891     unsigned int num_elements,
 892     void *data)
 893 {
 894     int i;
 895     VAPictureParameterBufferJPEGBaseline *p=(VAPictureParameterBufferJPEGBaseline *)data;
 896     DPY2TRACECTX(dpy);
 897
 898     va_TraceMsg(trace_ctx,"*VAPictureParameterBufferJPEG\n");
 899     va_TraceMsg(trace_ctx,"\tpicture_width = %u\n", p->picture_width);
 900     va_TraceMsg(trace_ctx,"\tpicture_height = %u\n", p->picture_height);
 901     va_TraceMsg(trace_ctx,"\tcomponents = \n");
 902     for (i = 0; i < p->num_components && i < 255; ++i) {
 903         va_TraceMsg(trace_ctx,"\t\t[%d] component_id = %u\n", i, p->components[i].component_id);
 904         va_TraceMsg(trace_ctx,"\t\t[%d] h_sampling_factor = %u\n", i, p->components[i].h_sampling_factor);
 905         va_TraceMsg(trace_ctx,"\t\t[%d] v_sampling_factor = %u\n", i, p->components[i].v_sampling_factor);
 906         va_TraceMsg(trace_ctx,"\t\t[%d] quantiser_table_selector = %u\n", i, p->components[i].quantiser_table_selector);
 907     }
 908 }
 909
 910 static void va_TraceVAIQMatrixBufferJPEG(
 911     VADisplay dpy,
 912     VAContextID context,
 913     VABufferID buffer,
 914     VABufferType type,
 915     unsigned int size,
 916     unsigned int num_elements,
 917     void *data)
 918 {
 919     int i, j;
 920     static char tmp[1024];
 921     VAIQMatrixBufferJPEGBaseline *p=(VAIQMatrixBufferJPEGBaseline *)data;
 922     DPY2TRACECTX(dpy);
 923     va_TraceMsg(trace_ctx,"*VAIQMatrixParameterBufferJPEG\n");
 924     va_TraceMsg(trace_ctx,"\tload_quantiser_table =\n");
 925     for (i = 0; i < 4; ++i) {
 926         va_TraceMsg(trace_ctx,"\t\t[%d] = %u\n", i, p->load_quantiser_table[i]);
 927     }
 928     va_TraceMsg(trace_ctx,"\tquantiser_table =\n");
 929     for (i = 0; i < 4; ++i) {
 930         memset(tmp, 0, sizeof tmp);
 931         for (j = 0; j < 64; ++j) {
 932             sprintf(tmp + strlen(tmp), "%u ", p->quantiser_table[i][j]);
 933         }
 934         va_TraceMsg(trace_ctx,"\t\t[%d] = %s\n", i, tmp);
 935     }
 936 }
 937
 938 static void va_TraceVASliceParameterBufferJPEG(
 939     VADisplay dpy,
 940     VAContextID context,
 941     VABufferID buffer,
 942     VABufferType type,
 943     unsigned int size,
 944     unsigned int num_elements,
 945     void *data)
 946 {
 947     int i;
 948     VASliceParameterBufferJPEGBaseline *p=(VASliceParameterBufferJPEGBaseline *)data;
 949     DPY2TRACECTX(dpy);
 950     va_TraceMsg(trace_ctx,"*VASliceParameterBufferJPEG\n");
 951     va_TraceMsg(trace_ctx,"\tslice_data_size = %u\n", p->slice_data_size);
 952     va_TraceMsg(trace_ctx,"\tslice_data_offset = %u\n", p->slice_data_offset);
 953     va_TraceMsg(trace_ctx,"\tslice_data_flag = %u\n", p->slice_data_flag);
 954     va_TraceMsg(trace_ctx,"\tslice_horizontal_position = %u\n", p->slice_horizontal_position);
 955     va_TraceMsg(trace_ctx,"\tslice_vertical_position = %u\n", p->slice_vertical_position);
 956     va_TraceMsg(trace_ctx,"\tcomponents = \n");
 957     for (i = 0; i < p->num_components && i < 4; ++i) {
 958         va_TraceMsg(trace_ctx,"\t\t[%d] component_selector = %u\n", i, p->components[i].component_selector);
 959         va_TraceMsg(trace_ctx,"\t\t[%d] dc_table_selector = %u\n", i, p->components[i].dc_table_selector);
 960         va_TraceMsg(trace_ctx,"\t\t[%d] ac_table_selector = %u\n", i, p->components[i].ac_table_selector);
 961     }
 962     va_TraceMsg(trace_ctx,"\trestart_interval = %u\n", p->restart_interval);
 963     va_TraceMsg(trace_ctx,"\tnum_mcus = %u\n", p->num_mcus);
 964 }
 965
 966 static void va_TraceVAHuffmanTableBufferJPEG(
 967     VADisplay dpy,
 968     VAContextID context,
 969     VABufferID buffer,
 970     VABufferType type,
 971     unsigned int size,
 972     unsigned int num_elements,
 973     void *data)
 974 {
 975     int i, j;
 976     static char tmp[1024];
 977     VAHuffmanTableBufferJPEGBaseline *p=(VAHuffmanTableBufferJPEGBaseline *)data;
 978     DPY2TRACECTX(dpy);
 979     va_TraceMsg(trace_ctx,"*VAHuffmanTableBufferJPEG\n");
 980
 981     for (i = 0; i < 2; ++i) {
 982         va_TraceMsg(trace_ctx,"\tload_huffman_table[%d] =%u\n", i, p->load_huffman_table[0]);
 983         va_TraceMsg(trace_ctx,"\thuffman_table[%d] =\n", i);
 984         memset(tmp, 0, sizeof tmp);
 985         for (j = 0; j < 16; ++j) {
 986             sprintf(tmp + strlen(tmp), "%u ", p->huffman_table[i].num_dc_codes[j]);
 987         }
 988         va_TraceMsg(trace_ctx,"\t\tnum_dc_codes =%s\n", tmp);
 989         memset(tmp, 0, sizeof tmp);
 990         for (j = 0; j < 12; ++j) {
 991             sprintf(tmp + strlen(tmp), "%u ", p->huffman_table[i].dc_values[j]);
 992         }
 993         va_TraceMsg(trace_ctx,"\t\tdc_values =%s\n", tmp);
 994         memset(tmp, 0, sizeof tmp);
 995         for (j = 0; j < 16; ++j) {
 996             sprintf(tmp + strlen(tmp), "%u ", p->huffman_table[i].num_ac_codes[j]);
 997         }
 998         va_TraceMsg(trace_ctx,"\t\tnum_dc_codes =%s\n", tmp);
 999         memset(tmp, 0, sizeof tmp);
1000         for (j = 0; j < 162; ++j) {
1001             sprintf(tmp + strlen(tmp), "%u ", p->huffman_table[i].ac_values[j]);
1002         }
1003         va_TraceMsg(trace_ctx,"\t\tnum_dc_codes =%s\n", tmp);
1004         memset(tmp, 0, sizeof tmp);
1005         for (j = 0; j < 2; ++j) {
1006             sprintf(tmp + strlen(tmp), "%u ", p->huffman_table[i].pad[j]);
1007         }
1008         va_TraceMsg(trace_ctx,"\t\tnum_dc_codes =%s\n", tmp);
1009     }
1010 }
1011
1012 static void va_TraceVAPictureParameterBufferMPEG4(
1013     VADisplay dpy,
1014     VAContextID context,
1015     VABufferID buffer,
1016     VABufferType type,
1017     unsigned int size,
1018     unsigned int num_elements,
1019     void *data)
1020 {
1021     int i;
1022     VAPictureParameterBufferMPEG4 *p=(VAPictureParameterBufferMPEG4 *)data;
1023
1024     DPY2TRACECTX(dpy);
1025
1026     va_TraceMsg(trace_ctx,"*VAPictureParameterBufferMPEG4\n");
1027     va_TraceMsg(trace_ctx,"\tvop_width = %d\n", p->vop_width);
1028     va_TraceMsg(trace_ctx,"\tvop_height = %d\n", p->vop_height);
1029     va_TraceMsg(trace_ctx,"\tforward_reference_picture = %d\n", p->forward_reference_picture);
1030     va_TraceMsg(trace_ctx,"\tbackward_reference_picture = %d\n", p->backward_reference_picture);
1031     va_TraceMsg(trace_ctx,"\tvol_fields value = %d\n", p->vol_fields.value);
1032     va_TraceMsg(trace_ctx,"\tshort_video_header= %d\n", p->vol_fields.bits.short_video_header);
1033     va_TraceMsg(trace_ctx,"\tchroma_format= %d\n", p->vol_fields.bits.chroma_format);
1034     va_TraceMsg(trace_ctx,"\tinterlaced= %d\n", p->vol_fields.bits.interlaced);
1035     va_TraceMsg(trace_ctx,"\tobmc_disable= %d\n", p->vol_fields.bits.obmc_disable);
1036     va_TraceMsg(trace_ctx,"\tsprite_enable= %d\n", p->vol_fields.bits.sprite_enable);
1037     va_TraceMsg(trace_ctx,"\tsprite_warping_accuracy= %d\n", p->vol_fields.bits.sprite_warping_accuracy);
1038     va_TraceMsg(trace_ctx,"\tquant_type= %d\n", p->vol_fields.bits.quant_type);
1039     va_TraceMsg(trace_ctx,"\tquarter_sample= %d\n", p->vol_fields.bits.quarter_sample);
1040     va_TraceMsg(trace_ctx,"\tdata_partitioned= %d\n", p->vol_fields.bits.data_partitioned);
1041     va_TraceMsg(trace_ctx,"\treversible_vlc= %d\n", p->vol_fields.bits.reversible_vlc);
1042     va_TraceMsg(trace_ctx,"\tresync_marker_disable= %d\n", p->vol_fields.bits.resync_marker_disable);
1043     va_TraceMsg(trace_ctx,"\tno_of_sprite_warping_points = %d\n", p->no_of_sprite_warping_points);
1044     va_TraceMsg(trace_ctx,"\tsprite_trajectory_du =");
1045     for(i=0;i<3;i++)
1046         va_TraceMsg(trace_ctx,"\t%d", p->sprite_trajectory_du[i]);
1047
1048     va_TraceMsg(trace_ctx,"\n");
1049     va_TraceMsg(trace_ctx,"\tsprite_trajectory_dv =");
1050     for(i=0;i<3;i++)
1051         va_TraceMsg(trace_ctx,"\t%d", p->sprite_trajectory_dv[i]);
1052     va_TraceMsg(trace_ctx,"\n");
1053     va_TraceMsg(trace_ctx,"\tvop_fields value = %d\n", p->vop_fields.value);
1054     va_TraceMsg(trace_ctx,"\tvop_coding_type= %d\n", p->vop_fields.bits.vop_coding_type);
1055     va_TraceMsg(trace_ctx,"\tbackward_reference_vop_coding_type= %d\n", p->vop_fields.bits.backward_reference_vop_coding_type);
1056     va_TraceMsg(trace_ctx,"\tvop_rounding_type= %d\n", p->vop_fields.bits.vop_rounding_type);
1057     va_TraceMsg(trace_ctx,"\tintra_dc_vlc_thr= %d\n", p->vop_fields.bits.intra_dc_vlc_thr);
1058     va_TraceMsg(trace_ctx,"\ttop_field_first= %d\n", p->vop_fields.bits.top_field_first);
1059     va_TraceMsg(trace_ctx,"\talternate_vertical_scan_flag= %d\n", p->vop_fields.bits.alternate_vertical_scan_flag);
1060     va_TraceMsg(trace_ctx,"\tvop_fcode_forward = %d\n", p->vop_fcode_forward);
1061     va_TraceMsg(trace_ctx,"\tvop_fcode_backward = %d\n", p->vop_fcode_backward);
1062     va_TraceMsg(trace_ctx,"\tnum_gobs_in_vop = %d\n", p->num_gobs_in_vop);
1063     va_TraceMsg(trace_ctx,"\tnum_macroblocks_in_gob = %d\n", p->num_macroblocks_in_gob);
1064     va_TraceMsg(trace_ctx,"\tTRB = %d\n", p->TRB);
1065     va_TraceMsg(trace_ctx,"\tTRD = %d\n", p->TRD);
1066     va_TraceMsg(trace_ctx, NULL);
1067
1068     return;
1069 }
1070
1071
1072 static void va_TraceVAIQMatrixBufferMPEG4(
1073     VADisplay dpy,
1074     VAContextID context,
1075     VABufferID buffer,
1076     VABufferType type,
1077     unsigned int size,
1078     unsigned int num_elements,
1079     void *data)
1080 {
1081     int i;
1082     VAIQMatrixBufferMPEG4 *p=(VAIQMatrixBufferMPEG4 *)data;
1083     DPY2TRACECTX(dpy);
1084
1085     va_TraceMsg(trace_ctx,"VAIQMatrixBufferMPEG4\n");
1086
1087     va_TraceMsg(trace_ctx,"\tload_intra_quant_mat = %d\n", p->load_intra_quant_mat);
1088     va_TraceMsg(trace_ctx,"\tload_non_intra_quant_mat = %d\n", p->load_non_intra_quant_mat);
1089     va_TraceMsg(trace_ctx,"\tintra_quant_mat =\n");
1090     for(i=0;i<64;i++)
1091         va_TraceMsg(trace_ctx,"\t\t%d\n", p->intra_quant_mat[i]);
1092
1093     va_TraceMsg(trace_ctx,"\tnon_intra_quant_mat =\n");
1094     for(i=0;i<64;i++)
1095         va_TraceMsg(trace_ctx,"\t\t%d\n", p->non_intra_quant_mat[i]);
1096     va_TraceMsg(trace_ctx, NULL);
1097
1098     return;
1099 }
1100
1101 static void va_TraceVAEncSequenceParameterBufferMPEG4(
1102     VADisplay dpy,
1103     VAContextID context,
1104     VABufferID buffer,
1105     VABufferType type,
1106     unsigned int size,
1107     unsigned int num_elements,
1108     void *data)
1109 {
1110     VAEncSequenceParameterBufferMPEG4 *p = (VAEncSequenceParameterBufferMPEG4 *)data;
1111     DPY2TRACECTX(dpy);
1112
1113     va_TraceMsg(trace_ctx, "\t--VAEncSequenceParameterBufferMPEG4\n");
1114
1115     va_TraceMsg(trace_ctx, "\tprofile_and_level_indication = %d\n", p->profile_and_level_indication);
1116     va_TraceMsg(trace_ctx, "\tintra_period = %d\n", p->intra_period);
1117     va_TraceMsg(trace_ctx, "\tvideo_object_layer_width = %d\n", p->video_object_layer_width);
1118     va_TraceMsg(trace_ctx, "\tvideo_object_layer_height = %d\n", p->video_object_layer_height);
1119     va_TraceMsg(trace_ctx, "\tvop_time_increment_resolution = %d\n", p->vop_time_increment_resolution);
1120     va_TraceMsg(trace_ctx, "\tfixed_vop_rate = %d\n", p->fixed_vop_rate);
1121     va_TraceMsg(trace_ctx, "\tfixed_vop_time_increment = %d\n", p->fixed_vop_time_increment);
1122     va_TraceMsg(trace_ctx, "\tbits_per_second = %d\n", p->bits_per_second);
1123     va_TraceMsg(trace_ctx, "\tframe_rate = %d\n", p->frame_rate);
1124     va_TraceMsg(trace_ctx, "\tinitial_qp = %d\n", p->initial_qp);
1125     va_TraceMsg(trace_ctx, "\tmin_qp = %d\n", p->min_qp);
1126     va_TraceMsg(trace_ctx, NULL);
1127
1128     return;
1129 }
1130
1131 static void va_TraceVAEncPictureParameterBufferMPEG4(
1132     VADisplay dpy,
1133     VAContextID context,
1134     VABufferID buffer,
1135     VABufferType type,
1136     unsigned int size,
1137     unsigned int num_elements,
1138     void *data)
1139 {
1140     VAEncPictureParameterBufferMPEG4 *p = (VAEncPictureParameterBufferMPEG4 *)data;
1141     DPY2TRACECTX(dpy);
1142
1143     va_TraceMsg(trace_ctx, "\t--VAEncPictureParameterBufferMPEG4\n");
1144     va_TraceMsg(trace_ctx, "\treference_picture = 0x%08x\n", p->reference_picture);
1145     va_TraceMsg(trace_ctx, "\treconstructed_picture = 0x%08x\n", p->reconstructed_picture);
1146     va_TraceMsg(trace_ctx, "\tcoded_buf = 0x%08x\n", p->coded_buf);
1147     va_TraceMsg(trace_ctx, "\tpicture_width = %d\n", p->picture_width);
1148     va_TraceMsg(trace_ctx, "\tpicture_height = %d\n", p->picture_height);
1149     va_TraceMsg(trace_ctx, "\tmodulo_time_base = %d\n", p->modulo_time_base);
1150     va_TraceMsg(trace_ctx, "\tvop_time_increment = %d\n", p->vop_time_increment);
1151     va_TraceMsg(trace_ctx, "\tpicture_type = %d\n", p->picture_type);
1152     va_TraceMsg(trace_ctx, NULL);
1153
1154     return;
1155 }
1156
1157
1158 static void va_TraceVASliceParameterBufferMPEG4(
1159     VADisplay dpy,
1160     VAContextID context,
1161     VABufferID buffer,
1162     VABufferType type,
1163     unsigned int size,
1164     unsigned int num_elements,
1165     void *data)
1166 {
1167     VASliceParameterBufferMPEG4 *p=(VASliceParameterBufferMPEG4 *)data;
1168
1169     DPY2TRACECTX(dpy);
1170
1171     trace_ctx->trace_slice_no++;
1172
1173     trace_ctx->trace_slice_size = p->slice_data_size;
1174
1175     va_TraceMsg(trace_ctx,"VASliceParameterBufferMPEG4\n");
1176
1177     va_TraceMsg(trace_ctx,"\tslice_data_size = %d\n", p->slice_data_size);
1178     va_TraceMsg(trace_ctx,"\tslice_data_offset = %d\n", p->slice_data_offset);
1179     va_TraceMsg(trace_ctx,"\tslice_data_flag = %d\n", p->slice_data_flag);
1180     va_TraceMsg(trace_ctx,"\tmacroblock_offset = %d\n", p->macroblock_offset);
1181     va_TraceMsg(trace_ctx,"\tmacroblock_number = %d\n", p->macroblock_number);
1182     va_TraceMsg(trace_ctx,"\tquant_scale = %d\n", p->quant_scale);
1183     va_TraceMsg(trace_ctx, NULL);
1184
1185     return;
1186 }
1187
1188
1189 static inline void va_TraceFlagIfNotZero(
1190     struct trace_context *trace_ctx,
1191     const char *name,   /* in */
1192     unsigned int flag   /* in */
1193 )
1194 {
1195     if (flag != 0) {
1196         va_TraceMsg(trace_ctx, "%s = %x\n", name, flag);
1197     }
1198 }
1199
1200
1201 static void va_TraceVAPictureParameterBufferHEVC(
1202     VADisplay dpy,
1203     VAContextID context,
1204     VABufferID buffer,
1205     VABufferType type,
1206     unsigned int size,
1207     unsigned int num_elements,
1208     void *data)
1209 {
1210     int i;
1211     VAPictureParameterBufferHEVC *p = (VAPictureParameterBufferHEVC*)data;
1212
1213     DPY2TRACECTX(dpy);
1214
1215     va_TraceMsg(trace_ctx, "VAPictureParameterBufferHEVC\n");
1216
1217     va_TraceMsg(trace_ctx, "\tCurrPic.picture_id = 0x%08x\n", p->CurrPic.picture_id);
1218     va_TraceMsg(trace_ctx, "\tCurrPic.frame_idx = %d\n", p->CurrPic.pic_order_cnt);
1219     va_TraceMsg(trace_ctx, "\tCurrPic.flags = %d\n", p->CurrPic.flags);
1220
1221     va_TraceMsg(trace_ctx, "\tReferenceFrames (TopFieldOrderCnt-BottomFieldOrderCnt-picture_id-frame_idx-flags:\n");
1222     for (i = 0; i < 15; i++)
1223     {
1224         if ((p->ReferenceFrames[i].picture_id != VA_INVALID_SURFACE) &&
1225             ((p->ReferenceFrames[i].flags & VA_PICTURE_HEVC_INVALID) == 0)) {
1226             va_TraceMsg(trace_ctx, "\t\t%08d-%08d-0x%08x\n",
1227                         p->ReferenceFrames[i].picture_id,
1228                         p->ReferenceFrames[i].pic_order_cnt,
1229                         p->ReferenceFrames[i].flags);
1230         } else
1231             va_TraceMsg(trace_ctx, "\t\tinv-inv-inv-inv-inv\n");
1232     }
1233     va_TraceMsg(trace_ctx, "\n");
1234
1235     va_TraceMsg(trace_ctx, "\tpic_width_in_luma_samples = %d\n", p->pic_width_in_luma_samples);
1236     va_TraceMsg(trace_ctx, "\tpic_height_in_luma_samples = %d\n", p->pic_height_in_luma_samples);
1237     va_TraceMsg(trace_ctx, "\tpic_fields = %d\n", p->pic_fields.value);
1238
1239     va_TraceMsg(trace_ctx, "\tchroma_format_idc = %d\n", p->pic_fields.bits.chroma_format_idc);
1240     va_TraceMsg(trace_ctx, "\tseparate_colour_plane_flag = %d\n", p->pic_fields.bits.separate_colour_plane_flag);
1241     va_TraceMsg(trace_ctx, "\tpcm_enabled_flag = %d\n", p->pic_fields.bits.pcm_enabled_flag);
1242     va_TraceMsg(trace_ctx, "\tscaling_list_enabled_flag = %d\n", p->pic_fields.bits.scaling_list_enabled_flag);
1243     va_TraceMsg(trace_ctx, "\ttransform_skip_enabled_flag = %d\n", p->pic_fields.bits.transform_skip_enabled_flag);
1244     va_TraceMsg(trace_ctx, "\tamp_enabled_flag = %d\n", p->pic_fields.bits.amp_enabled_flag);
1245     va_TraceMsg(trace_ctx, "\tstrong_intra_smoothing_enabled_flag = %d\n", p->pic_fields.bits.strong_intra_smoothing_enabled_flag);
1246     va_TraceMsg(trace_ctx, "\tsign_data_hiding_enabled_flag = %d\n", p->pic_fields.bits.sign_data_hiding_enabled_flag);
1247     va_TraceMsg(trace_ctx, "\tconstrained_intra_pred_flag = %d\n", p->pic_fields.bits.constrained_intra_pred_flag);
1248     va_TraceMsg(trace_ctx, "\tcu_qp_delta_enabled_flag = %d\n", p->pic_fields.bits.cu_qp_delta_enabled_flag);
1249     va_TraceMsg(trace_ctx, "\tweighted_pred_flag = %d\n", p->pic_fields.bits.weighted_pred_flag);
1250     va_TraceMsg(trace_ctx, "\tweighted_bipred_flag = %d\n", p->pic_fields.bits.weighted_bipred_flag);
1251     va_TraceMsg(trace_ctx, "\ttransquant_bypass_enabled_flag = %d\n", p->pic_fields.bits.transquant_bypass_enabled_flag);
1252     va_TraceMsg(trace_ctx, "\ttiles_enabled_flag = %d\n", p->pic_fields.bits.tiles_enabled_flag);
1253     va_TraceMsg(trace_ctx, "\tentropy_coding_sync_enabled_flag = %d\n", p->pic_fields.bits.entropy_coding_sync_enabled_flag);
1254     va_TraceMsg(trace_ctx, "\tpps_loop_filter_across_slices_enabled_flag = %d\n", p->pic_fields.bits.pps_loop_filter_across_slices_enabled_flag);
1255     va_TraceMsg(trace_ctx, "\tloop_filter_across_tiles_enabled_flag = %d\n", p->pic_fields.bits.loop_filter_across_tiles_enabled_flag);
1256     va_TraceMsg(trace_ctx, "\tpcm_loop_filter_disabled_flag = %d\n", p->pic_fields.bits.pcm_loop_filter_disabled_flag);
1257     va_TraceMsg(trace_ctx, "\tNoPicReorderingFlag = %d\n", p->pic_fields.bits.NoPicReorderingFlag);
1258     va_TraceMsg(trace_ctx, "\tNoBiPredFlag = %d\n", p->pic_fields.bits.NoBiPredFlag);
1259     va_TraceMsg(trace_ctx, "\tReservedBits = %d\n", p->pic_fields.bits.ReservedBits);
1260
1261     va_TraceMsg(trace_ctx, "\tsps_max_dec_pic_buffering_minus1 = %d\n", p->sps_max_dec_pic_buffering_minus1);
1262     va_TraceMsg(trace_ctx, "\tbit_depth_luma_minus8 = %d\n", p->bit_depth_luma_minus8);
1263     va_TraceMsg(trace_ctx, "\tbit_depth_chroma_minus8 = %d\n", p->bit_depth_chroma_minus8);
1264     va_TraceMsg(trace_ctx, "\tpcm_sample_bit_depth_luma_minus1 = %d\n", p->pcm_sample_bit_depth_luma_minus1);
1265     va_TraceMsg(trace_ctx, "\tpcm_sample_bit_depth_chroma_minus1 = %d\n", p->pcm_sample_bit_depth_chroma_minus1);
1266     va_TraceMsg(trace_ctx, "\tlog2_min_luma_coding_block_size_minus3 = %d\n", p->log2_min_luma_coding_block_size_minus3);
1267     va_TraceMsg(trace_ctx, "\tlog2_diff_max_min_luma_coding_block_size = %d\n", p->log2_diff_max_min_luma_coding_block_size);
1268     va_TraceMsg(trace_ctx, "\tlog2_min_transform_block_size_minus2 = %d\n", p->log2_min_transform_block_size_minus2);
1269     va_TraceMsg(trace_ctx, "\tlog2_diff_max_min_transform_block_size = %d\n", p->log2_diff_max_min_transform_block_size);
1270     va_TraceMsg(trace_ctx, "\tlog2_min_pcm_luma_coding_block_size_minus3 = %d\n", p->log2_min_pcm_luma_coding_block_size_minus3);
1271     va_TraceMsg(trace_ctx, "\tlog2_diff_max_min_pcm_luma_coding_block_size = %d\n", p->log2_diff_max_min_pcm_luma_coding_block_size);
1272     va_TraceMsg(trace_ctx, "\tmax_transform_hierarchy_depth_intra = %d\n", p->max_transform_hierarchy_depth_intra);
1273     va_TraceMsg(trace_ctx, "\tmax_transform_hierarchy_depth_inter = %d\n", p->max_transform_hierarchy_depth_inter);
1274     va_TraceMsg(trace_ctx, "\tinit_qp_minus26 = %d\n", p->init_qp_minus26);
1275     va_TraceMsg(trace_ctx, "\tdiff_cu_qp_delta_depth = %d\n", p->diff_cu_qp_delta_depth);
1276     va_TraceMsg(trace_ctx, "\tpps_cb_qp_offset = %d\n", p->pps_cb_qp_offset);
1277     va_TraceMsg(trace_ctx, "\tpps_cr_qp_offset = %d\n", p->pps_cr_qp_offset);
1278     va_TraceMsg(trace_ctx, "\tlog2_parallel_merge_level_minus2 = %d\n", p->log2_parallel_merge_level_minus2);
1279     va_TraceMsg(trace_ctx, "\tnum_tile_columns_minus1 = %d\n", p->num_tile_columns_minus1);
1280     va_TraceMsg(trace_ctx, "\tnum_tile_rows_minus1 = %d\n", p->num_tile_rows_minus1);
1281
1282     va_TraceMsg(trace_ctx, "\tcolumn_width_minus1[19]=\n");
1283     for (i = 0; i < 19; i++) {
1284         va_TraceMsg(trace_ctx, "\t%d", p->column_width_minus1[i]);
1285         if ((i + 1) % 8 == 0)
1286             va_TraceMsg(trace_ctx, "\n");
1287     }
1288     va_TraceMsg(trace_ctx, "\n");
1289     va_TraceMsg(trace_ctx, "\trow_height_minus1[21]=\n");
1290     for (i = 0; i < 21; i++) {
1291         va_TraceMsg(trace_ctx, "\t%d", p->row_height_minus1[i]);
1292         if ((i + 1) % 8 == 0)
1293             va_TraceMsg(trace_ctx, "\n");
1294     }
1295     va_TraceMsg(trace_ctx, "\n");
1296
1297     va_TraceMsg(trace_ctx, "\tslice_parsing_fields = %d\n", p->slice_parsing_fields.value);
1298     va_TraceMsg(trace_ctx, "\tlists_modification_present_flag = %d\n", p->slice_parsing_fields.bits.lists_modification_present_flag);
1299     va_TraceMsg(trace_ctx, "\tlong_term_ref_pics_present_flag = %d\n", p->slice_parsing_fields.bits.long_term_ref_pics_present_flag);
1300     va_TraceMsg(trace_ctx, "\tsps_temporal_mvp_enabled_flag = %d\n", p->slice_parsing_fields.bits.sps_temporal_mvp_enabled_flag);
1301     va_TraceMsg(trace_ctx, "\tcabac_init_present_flag = %d\n", p->slice_parsing_fields.bits.cabac_init_present_flag);
1302     va_TraceMsg(trace_ctx, "\toutput_flag_present_flag = %d\n", p->slice_parsing_fields.bits.output_flag_present_flag);
1303     va_TraceMsg(trace_ctx, "\tdependent_slice_segments_enabled_flag = %d\n", p->slice_parsing_fields.bits.dependent_slice_segments_enabled_flag);
1304     va_TraceMsg(trace_ctx, "\tpps_slice_chroma_qp_offsets_present_flag = %d\n", p->slice_parsing_fields.bits.pps_slice_chroma_qp_offsets_present_flag);
1305     va_TraceMsg(trace_ctx, "\tsample_adaptive_offset_enabled_flag = %d\n", p->slice_parsing_fields.bits.sample_adaptive_offset_enabled_flag);
1306     va_TraceMsg(trace_ctx, "\tdeblocking_filter_override_enabled_flag = %d\n", p->slice_parsing_fields.bits.deblocking_filter_override_enabled_flag);
1307     va_TraceMsg(trace_ctx, "\tpps_disable_deblocking_filter_flag = %d\n", p->slice_parsing_fields.bits.pps_disable_deblocking_filter_flag);
1308     va_TraceMsg(trace_ctx, "\tslice_segment_header_extension_present_flag = %d\n", p->slice_parsing_fields.bits.slice_segment_header_extension_present_flag);
1309     va_TraceMsg(trace_ctx, "\tRapPicFlag = %d\n", p->slice_parsing_fields.bits.RapPicFlag);
1310     va_TraceMsg(trace_ctx, "\tIdrPicFlag = %d\n", p->slice_parsing_fields.bits.IdrPicFlag);
1311     va_TraceMsg(trace_ctx, "\tIntraPicFlag = %d\n", p->slice_parsing_fields.bits.IntraPicFlag);
1312     va_TraceMsg(trace_ctx, "\tReservedBits = %d\n", p->slice_parsing_fields.bits.ReservedBits);
1313
1314     va_TraceMsg(trace_ctx, "\tlog2_max_pic_order_cnt_lsb_minus4 = %d\n", p->log2_max_pic_order_cnt_lsb_minus4);
1315     va_TraceMsg(trace_ctx, "\tnum_short_term_ref_pic_sets = %d\n", p->num_short_term_ref_pic_sets);
1316     va_TraceMsg(trace_ctx, "\tnum_long_term_ref_pic_sps = %d\n", p->num_long_term_ref_pic_sps);
1317     va_TraceMsg(trace_ctx, "\tnum_ref_idx_l0_default_active_minus1 = %d\n", p->num_ref_idx_l0_default_active_minus1);
1318     va_TraceMsg(trace_ctx, "\tnum_ref_idx_l1_default_active_minus1 = %d\n", p->num_ref_idx_l1_default_active_minus1);
1319     va_TraceMsg(trace_ctx, "\tpps_beta_offset_div2 = %d\n", p->pps_beta_offset_div2);
1320     va_TraceMsg(trace_ctx, "\tpps_tc_offset_div2 = %d\n", p->pps_tc_offset_div2);
1321     va_TraceMsg(trace_ctx, "\tnum_extra_slice_header_bits = %d\n", p->num_extra_slice_header_bits);
1322     va_TraceMsg(trace_ctx, "\tst_rps_bits = %d\n", p->st_rps_bits);
1323
1324     return;
1325 }
1326
1327 static void va_TraceVASliceParameterBufferHEVC(
1328     VADisplay dpy,
1329     VAContextID context,
1330     VABufferID buffer,
1331     VABufferType type,
1332     unsigned int size,
1333     unsigned int num_elements,
1334     void *data)
1335 {
1336     int i,j;
1337     VASliceParameterBufferHEVC* p = (VASliceParameterBufferHEVC*)data;
1338
1339     DPY2TRACECTX(dpy);
1340
1341     trace_ctx->trace_slice_no++;
1342     trace_ctx->trace_slice_size = p->slice_data_size;
1343
1344     va_TraceMsg(trace_ctx, "VASliceParameterBufferHEVC\n");
1345     va_TraceMsg(trace_ctx, "\tslice_data_size = %d\n", p->slice_data_size);
1346     va_TraceMsg(trace_ctx, "\tslice_data_offset = %d\n", p->slice_data_offset);
1347     va_TraceMsg(trace_ctx, "\tslice_data_flag = %d\n", p->slice_data_flag);
1348     va_TraceMsg(trace_ctx, "\tslice_data_byte_offset = %d\n", p->slice_data_byte_offset);
1349     va_TraceMsg(trace_ctx, "\tslice_segment_address = %d\n", p->slice_segment_address);
1350
1351     va_TraceMsg(trace_ctx, "\tRefPicList[2][15]=\n");
1352     for (i = 0; i < 2; i++) {
1353         for (j = 0; j < 15; j++) {
1354             va_TraceMsg(trace_ctx, "\t%d", p->RefPicList[i][j]);
1355             if ((i*8 + j + 1) % 8 == 0)
1356                 va_TraceMsg(trace_ctx, "\n");
1357         }
1358     }
1359     va_TraceMsg(trace_ctx, "\n");
1360
1361     va_TraceMsg(trace_ctx, "\tLongSliceFlags.value = %d\n", p->LongSliceFlags.value);
1362     va_TraceMsg(trace_ctx, "\tLongSliceFlags.fields.LastSliceOfPic = %d\n", p->LongSliceFlags.fields.LastSliceOfPic);
1363     va_TraceMsg(trace_ctx, "\tLongSliceFlags.fields.dependent_slice_segment_flag = %d\n", p->LongSliceFlags.fields.dependent_slice_segment_flag);
1364     va_TraceMsg(trace_ctx, "\tLongSliceFlags.fields.slice_type = %d\n", p->LongSliceFlags.fields.slice_type);
1365     va_TraceMsg(trace_ctx, "\tLongSliceFlags.fields.color_plane_id = %d\n", p->LongSliceFlags.fields.color_plane_id);
1366     va_TraceMsg(trace_ctx, "\tLongSliceFlags.fields.slice_sao_luma_flag = %d\n", p->LongSliceFlags.fields.slice_sao_luma_flag);
1367     va_TraceMsg(trace_ctx, "\tLongSliceFlags.fields.slice_sao_chroma_flag = %d\n", p->LongSliceFlags.fields.slice_sao_chroma_flag);
1368     va_TraceMsg(trace_ctx, "\tLongSliceFlags.fields.mvd_l1_zero_flag = %d\n", p->LongSliceFlags.fields.mvd_l1_zero_flag);
1369     va_TraceMsg(trace_ctx, "\tLongSliceFlags.fields.cabac_init_flag = %d\n", p->LongSliceFlags.fields.cabac_init_flag);
1370     va_TraceMsg(trace_ctx, "\tLongSliceFlags.fields.slice_temporal_mvp_enabled_flag = %d\n", p->LongSliceFlags.fields.slice_temporal_mvp_enabled_flag);
1371     va_TraceMsg(trace_ctx, "\tLongSliceFlags.fields.slice_deblocking_filter_disabled_flag = %d\n", p->LongSliceFlags.fields.slice_deblocking_filter_disabled_flag);
1372     va_TraceMsg(trace_ctx, "\tLongSliceFlags.fields.collocated_from_l0_flag = %d\n", p->LongSliceFlags.fields.collocated_from_l0_flag);
1373     va_TraceMsg(trace_ctx, "\tLongSliceFlags.fields.slice_loop_filter_across_slices_enabled_flag = %d\n", p->LongSliceFlags.fields.slice_loop_filter_across_slices_enabled_flag);
1374     va_TraceMsg(trace_ctx, "\tLongSliceFlags.fields.reserved = %d\n", p->LongSliceFlags.fields.reserved);
1375
1376     va_TraceMsg(trace_ctx, "\tcollocated_ref_idx = %d\n", p->collocated_ref_idx);
1377
1378     va_TraceMsg(trace_ctx, "\tslice_qp_delta = %d\n", p->slice_qp_delta);
1379     va_TraceMsg(trace_ctx, "\tslice_cb_qp_offset = %d\n", p->slice_cb_qp_offset);
1380     va_TraceMsg(trace_ctx, "\tslice_cr_qp_offset = %d\n", p->slice_cr_qp_offset);
1381     va_TraceMsg(trace_ctx, "\tslice_beta_offset_div2 = %d\n", p->slice_beta_offset_div2);
1382     va_TraceMsg(trace_ctx, "\tslice_tc_offset_div2 = %d\n", p->slice_tc_offset_div2);
1383     va_TraceMsg(trace_ctx, "\tluma_log2_weight_denom = %d\n", p->luma_log2_weight_denom);
1384     va_TraceMsg(trace_ctx, "\tdelta_chroma_log2_weight_denom = %d\n", p->delta_chroma_log2_weight_denom);
1385
1386     va_TraceMsg(trace_ctx, "\tnum_ref_idx_l0_active_minus1 = %d\n", p->num_ref_idx_l0_active_minus1);
1387     for (i = 0; i <=  p->num_ref_idx_l0_active_minus1; i++) {
1388         va_TraceMsg(trace_ctx, "\t%d ", p->delta_luma_weight_l0[i]);
1389         va_TraceMsg(trace_ctx, "\t%d ", p->luma_offset_l0[i]);
1390         va_TraceMsg(trace_ctx, "\t%d ", p->delta_chroma_weight_l0[i][0]);
1391         va_TraceMsg(trace_ctx, "\t%d ", p->delta_chroma_weight_l0[i][1]);
1392         va_TraceMsg(trace_ctx, "\t%d ", p->ChromaOffsetL0[i][0]);
1393         va_TraceMsg(trace_ctx, "\t%d ", p->ChromaOffsetL0[i][1]);
1394         va_TraceMsg(trace_ctx, "\n");
1395     }
1396
1397     va_TraceMsg(trace_ctx, "\tnum_ref_idx_l1_active_minus1 = %d\n", p->num_ref_idx_l1_active_minus1);
1398     for (i = 0; i <=  p->num_ref_idx_l1_active_minus1; i++) {
1399         va_TraceMsg(trace_ctx, "\t%d ", p->delta_luma_weight_l1[i]);
1400         va_TraceMsg(trace_ctx, "\t%d ", p->luma_offset_l1[i]);
1401         va_TraceMsg(trace_ctx, "\t%d ", p->delta_chroma_weight_l1[i][0]);
1402         va_TraceMsg(trace_ctx, "\t%d ", p->delta_chroma_weight_l1[i][1]);
1403         va_TraceMsg(trace_ctx, "\t%d ", p->ChromaOffsetL1[i][0]);
1404         va_TraceMsg(trace_ctx, "\t%d ", p->ChromaOffsetL1[i][1]);
1405         va_TraceMsg(trace_ctx, "\n");
1406     }
1407
1408     va_TraceMsg(trace_ctx, "\tfive_minus_max_num_merge_cand = %d\n", p->five_minus_max_num_merge_cand);
1409
1410     va_TraceMsg(trace_ctx, NULL);
1411 }
1412
1413 static void va_TraceVAIQMatrixBufferHEVC(
1414     VADisplay dpy,
1415     VAContextID context,
1416     VABufferID buffer,
1417     VABufferType type,
1418     unsigned int size,
1419     unsigned int num_elements,
1420     void *data
1421 )
1422 {
1423     int i, j;
1424     VAIQMatrixBufferHEVC* p = (VAIQMatrixBufferHEVC* )data;
1425
1426     DPY2TRACECTX(dpy);
1427
1428     va_TraceMsg(trace_ctx, "VAIQMatrixBufferHEVC\n");
1429
1430     va_TraceMsg(trace_ctx, "\tScalingList4x4[6][16]=\n");
1431     for (i = 0; i < 6; i++) {
1432         for (j = 0; j < 16; j++) {
1433             va_TraceMsg(trace_ctx, "\t%d\t", p->ScalingList4x4[i][j]);
1434             if ((j + 1) % 8 == 0)
1435                 va_TraceMsg(trace_ctx, "\n");
1436         }
1437     }
1438
1439     va_TraceMsg(trace_ctx, "\tScalingList8x8[6][64]=\n");
1440     for (i = 0; i < 6; i++) {
1441         for (j = 0; j < 64; j++) {
1442             va_TraceMsg(trace_ctx, "\t%d", p->ScalingList8x8[i][j]);
1443             if ((j + 1) % 8 == 0)
1444                 va_TraceMsg(trace_ctx, "\n");
1445         }
1446     }
1447
1448     va_TraceMsg(trace_ctx, "\tScalingList16x16[6][64]=\n");
1449     for (i = 0; i < 6; i++) {
1450         for (j = 0; j < 64; j++) {
1451             va_TraceMsg(trace_ctx, "\t%d", p->ScalingList16x16[i][j]);
1452             if ((j + 1) % 8 == 0)
1453                 va_TraceMsg(trace_ctx, "\n");
1454         }
1455     }
1456
1457     va_TraceMsg(trace_ctx, "\tScalingList32x32[2][64]=\n");
1458     for (i = 0; i < 2; i++) {
1459         for (j = 0; j < 64; j++) {
1460             va_TraceMsg(trace_ctx, "\t%d", p->ScalingList32x32[i][j]);
1461             if ((j + 1) % 8 == 0)
1462                 va_TraceMsg(trace_ctx, "\n");
1463         }
1464     }
1465
1466     va_TraceMsg(trace_ctx, "\tScalingListDC16x16[6]=\n");
1467     for (j = 0; j < 6; j++) {
1468         va_TraceMsg(trace_ctx, "\t%d", p->ScalingListDC16x16[j]);
1469     }
1470     va_TraceMsg(trace_ctx, "\tScalingListDC32x32[2]=\n");
1471     for (j = 0; j < 2; j++) {
1472         va_TraceMsg(trace_ctx, "\t%d", p->ScalingListDC32x32[j]);
1473     }
1474
1475     va_TraceMsg(trace_ctx, NULL);
1476 }
1477
1478 static void va_TraceVAPictureParameterBufferH264(
1479     VADisplay dpy,
1480     VAContextID context,
1481     VABufferID buffer,
1482     VABufferType type,
1483     unsigned int size,
1484     unsigned int num_elements,
1485     void *data)
1486 {
1487     int i;
1488     VAPictureParameterBufferH264 *p = (VAPictureParameterBufferH264*)data;
1489
1490     DPY2TRACECTX(dpy);
1491
1492     va_TraceMsg(trace_ctx, "\t--VAPictureParameterBufferH264\n");
1493
1494     va_TraceMsg(trace_ctx, "\tCurrPic.picture_id = 0x%08x\n", p->CurrPic.picture_id);
1495     va_TraceMsg(trace_ctx, "\tCurrPic.frame_idx = %d\n", p->CurrPic.frame_idx);
1496     va_TraceMsg(trace_ctx, "\tCurrPic.flags = %d\n", p->CurrPic.flags);
1497     va_TraceMsg(trace_ctx, "\tCurrPic.TopFieldOrderCnt = %d\n", p->CurrPic.TopFieldOrderCnt);
1498     va_TraceMsg(trace_ctx, "\tCurrPic.BottomFieldOrderCnt = %d\n", p->CurrPic.BottomFieldOrderCnt);
1499
1500     va_TraceMsg(trace_ctx, "\tReferenceFrames (TopFieldOrderCnt-BottomFieldOrderCnt-picture_id-frame_idx-flags:\n");
1501     for (i = 0; i < 16; i++)
1502     {
1503         if ((p->ReferenceFrames[i].picture_id != VA_INVALID_SURFACE) &&
1504             ((p->ReferenceFrames[i].flags & VA_PICTURE_H264_INVALID) == 0)) {
1505             va_TraceMsg(trace_ctx, "\t\t%08d-%08d-0x%08x-%08d-0x%08x\n",
1506                         p->ReferenceFrames[i].TopFieldOrderCnt,
1507                         p->ReferenceFrames[i].BottomFieldOrderCnt,
1508                         p->ReferenceFrames[i].picture_id,
1509                         p->ReferenceFrames[i].frame_idx,
1510                         p->ReferenceFrames[i].flags);
1511         } else
1512             break;
1513     }
1514     va_TraceMsg(trace_ctx, "\tpicture_width_in_mbs_minus1 = %d\n", p->picture_width_in_mbs_minus1);
1515     va_TraceMsg(trace_ctx, "\tpicture_height_in_mbs_minus1 = %d\n", p->picture_height_in_mbs_minus1);
1516     va_TraceMsg(trace_ctx, "\tbit_depth_luma_minus8 = %d\n", p->bit_depth_luma_minus8);
1517     va_TraceMsg(trace_ctx, "\tbit_depth_chroma_minus8 = %d\n", p->bit_depth_chroma_minus8);
1518     va_TraceMsg(trace_ctx, "\tnum_ref_frames = %d\n", p->num_ref_frames);
1519     va_TraceMsg(trace_ctx, "\tseq fields = %d\n", p->seq_fields.value);
1520     va_TraceMsg(trace_ctx, "\tchroma_format_idc = %d\n", p->seq_fields.bits.chroma_format_idc);
1521     va_TraceMsg(trace_ctx, "\tresidual_colour_transform_flag = %d\n", p->seq_fields.bits.residual_colour_transform_flag);
1522     va_TraceMsg(trace_ctx, "\tframe_mbs_only_flag = %d\n", p->seq_fields.bits.frame_mbs_only_flag);
1523     va_TraceMsg(trace_ctx, "\tmb_adaptive_frame_field_flag = %d\n", p->seq_fields.bits.mb_adaptive_frame_field_flag);
1524     va_TraceMsg(trace_ctx, "\tdirect_8x8_inference_flag = %d\n", p->seq_fields.bits.direct_8x8_inference_flag);
1525     va_TraceMsg(trace_ctx, "\tMinLumaBiPredSize8x8 = %d\n", p->seq_fields.bits.MinLumaBiPredSize8x8);
1526     va_TraceMsg(trace_ctx, "\tnum_slice_groups_minus1 = %d\n", p->num_slice_groups_minus1);
1527     va_TraceMsg(trace_ctx, "\tslice_group_map_type = %d\n", p->slice_group_map_type);
1528     va_TraceMsg(trace_ctx, "\tslice_group_change_rate_minus1 = %d\n", p->slice_group_change_rate_minus1);
1529     va_TraceMsg(trace_ctx, "\tpic_init_qp_minus26 = %d\n", p->pic_init_qp_minus26);
1530     va_TraceMsg(trace_ctx, "\tpic_init_qs_minus26 = %d\n", p->pic_init_qs_minus26);
1531     va_TraceMsg(trace_ctx, "\tchroma_qp_index_offset = %d\n", p->chroma_qp_index_offset);
1532     va_TraceMsg(trace_ctx, "\tsecond_chroma_qp_index_offset = %d\n", p->second_chroma_qp_index_offset);
1533     va_TraceMsg(trace_ctx, "\tpic_fields = 0x%03x\n", p->pic_fields.value);
1534     va_TraceFlagIfNotZero(trace_ctx, "\t\tentropy_coding_mode_flag", p->pic_fields.bits.entropy_coding_mode_flag);
1535     va_TraceFlagIfNotZero(trace_ctx, "\t\tweighted_pred_flag", p->pic_fields.bits.weighted_pred_flag);
1536     va_TraceFlagIfNotZero(trace_ctx, "\t\tweighted_bipred_idc", p->pic_fields.bits.weighted_bipred_idc);
1537     va_TraceFlagIfNotZero(trace_ctx, "\t\ttransform_8x8_mode_flag", p->pic_fields.bits.transform_8x8_mode_flag);
1538     va_TraceFlagIfNotZero(trace_ctx, "\t\tfield_pic_flag", p->pic_fields.bits.field_pic_flag);
1539     va_TraceFlagIfNotZero(trace_ctx, "\t\tconstrained_intra_pred_flag", p->pic_fields.bits.constrained_intra_pred_flag);
1540     va_TraceFlagIfNotZero(trace_ctx, "\t\tpic_order_present_flag", p->pic_fields.bits.pic_order_present_flag);
1541     va_TraceFlagIfNotZero(trace_ctx, "\t\tdeblocking_filter_control_present_flag", p->pic_fields.bits.deblocking_filter_control_present_flag);
1542     va_TraceFlagIfNotZero(trace_ctx, "\t\tredundant_pic_cnt_present_flag", p->pic_fields.bits.redundant_pic_cnt_present_flag);
1543     va_TraceFlagIfNotZero(trace_ctx, "\t\treference_pic_flag", p->pic_fields.bits.reference_pic_flag);
1544     va_TraceMsg(trace_ctx, "\tframe_num = %d\n", p->frame_num);
1545     va_TraceMsg(trace_ctx, NULL);
1546
1547     return;
1548 }
1549
1550 static void va_TraceVASliceParameterBufferH264(
1551     VADisplay dpy,
1552     VAContextID context,
1553     VABufferID buffer,
1554     VABufferType type,
1555     unsigned int size,
1556     unsigned int num_elements,
1557     void *data)
1558 {
1559     int i;
1560     VASliceParameterBufferH264* p = (VASliceParameterBufferH264*)data;
1561     DPY2TRACECTX(dpy);
1562
1563     trace_ctx->trace_slice_no++;
1564     trace_ctx->trace_slice_size = p->slice_data_size;
1565
1566     va_TraceMsg(trace_ctx, "\t--VASliceParameterBufferH264\n");
1567     va_TraceMsg(trace_ctx, "\tslice_data_size = %d\n", p->slice_data_size);
1568     va_TraceMsg(trace_ctx, "\tslice_data_offset = %d\n", p->slice_data_offset);
1569     va_TraceMsg(trace_ctx, "\tslice_data_flag = %d\n", p->slice_data_flag);
1570     va_TraceMsg(trace_ctx, "\tslice_data_bit_offset = %d\n", p->slice_data_bit_offset);
1571     va_TraceMsg(trace_ctx, "\tfirst_mb_in_slice = %d\n", p->first_mb_in_slice);
1572     va_TraceMsg(trace_ctx, "\tslice_type = %d\n", p->slice_type);
1573     va_TraceMsg(trace_ctx, "\tdirect_spatial_mv_pred_flag = %d\n", p->direct_spatial_mv_pred_flag);
1574     va_TraceMsg(trace_ctx, "\tnum_ref_idx_l0_active_minus1 = %d\n", p->num_ref_idx_l0_active_minus1);
1575     va_TraceMsg(trace_ctx, "\tnum_ref_idx_l1_active_minus1 = %d\n", p->num_ref_idx_l1_active_minus1);
1576     va_TraceMsg(trace_ctx, "\tcabac_init_idc = %d\n", p->cabac_init_idc);
1577     va_TraceMsg(trace_ctx, "\tslice_qp_delta = %d\n", p->slice_qp_delta);
1578     va_TraceMsg(trace_ctx, "\tdisable_deblocking_filter_idc = %d\n", p->disable_deblocking_filter_idc);
1579     va_TraceMsg(trace_ctx, "\tslice_alpha_c0_offset_div2 = %d\n", p->slice_alpha_c0_offset_div2);
1580     va_TraceMsg(trace_ctx, "\tslice_beta_offset_div2 = %d\n", p->slice_beta_offset_div2);
1581
1582     va_TraceMsg(trace_ctx, "\tRefPicList0 =\n");
1583     for (i = 0; i < 32; i++) {
1584         if ((p->RefPicList0[i].picture_id != VA_INVALID_SURFACE) &&
1585             ((p->RefPicList0[i].flags & VA_PICTURE_H264_INVALID) == 0))
1586         va_TraceMsg(trace_ctx, "%08d-%08d-0x%08x-%08d-0x%08x\n", p->RefPicList0[i].TopFieldOrderCnt, p->RefPicList0[i].BottomFieldOrderCnt, p->RefPicList0[i].picture_id, p->RefPicList0[i].frame_idx,  p->RefPicList0[i].flags);
1587         else
1588             break;
1589     }
1590     va_TraceMsg(trace_ctx, "\tRefPicList1 =\n");
1591     for (i = 0; i < 32; i++) {
1592         if ((p->RefPicList1[i].picture_id != VA_INVALID_SURFACE) &&
1593             ((p->RefPicList1[i].flags & VA_PICTURE_H264_INVALID) == 0))
1594             va_TraceMsg(trace_ctx, "%08d-%08d-0x%08x-%08d-0x%08x\n", p->RefPicList1[i].TopFieldOrderCnt, p->RefPicList1[i].BottomFieldOrderCnt, p->RefPicList1[i].picture_id, p->RefPicList1[i].frame_idx, p->RefPicList1[i].flags);
1595         else
1596             break;
1597     }
1598
1599     va_TraceMsg(trace_ctx, "\tluma_log2_weight_denom = %d\n", p->luma_log2_weight_denom);
1600     va_TraceMsg(trace_ctx, "\tchroma_log2_weight_denom = %d\n", p->chroma_log2_weight_denom);
1601     va_TraceMsg(trace_ctx, "\tluma_weight_l0_flag = %d\n", p->luma_weight_l0_flag);
1602
1603     for (i = 0; (i <= p->num_ref_idx_l0_active_minus1) && (i<32); i++) {
1604         va_TraceMsg(trace_ctx, "\t\t%d\t%d\n",
1605             p->luma_weight_l0[i],
1606             p->luma_offset_l0[i]);
1607     }
1608
1609
1610     va_TraceMsg(trace_ctx, "\tchroma_weight_l0_flag = %d\n", p->chroma_weight_l0_flag);
1611
1612     for (i = 0; (i <= p->num_ref_idx_l0_active_minus1) && (i<32); i++) {
1613         va_TraceMsg(trace_ctx, "\t\t%d\t%d\t%d\t%d\n",
1614             p->chroma_weight_l0[i][0],
1615             p->chroma_offset_l0[i][0],
1616             p->chroma_weight_l0[i][1],
1617             p->chroma_offset_l0[i][1]);
1618     }
1619
1620
1621     va_TraceMsg(trace_ctx, "\tluma_weight_l1_flag = %d\n", p->luma_weight_l1_flag);
1622
1623     for (i = 0; (i <=  p->num_ref_idx_l1_active_minus1) && (i<32); i++) {
1624         va_TraceMsg(trace_ctx, "\t\t%d\t%d\n",
1625             p->luma_weight_l1[i],
1626             p->luma_offset_l1[i]);
1627     }
1628
1629
1630     va_TraceMsg(trace_ctx, "\tchroma_weight_l1_flag = %d\n", p->chroma_weight_l1_flag);
1631
1632     for (i = 0; (i <= p->num_ref_idx_l1_active_minus1) && (i<32); i++) {
1633         va_TraceMsg(trace_ctx, "\t\t%d\t%d\t%d\t%d\n",
1634             p->chroma_weight_l1[i][0],
1635             p->chroma_offset_l1[i][0],
1636             p->chroma_weight_l1[i][1],
1637             p->chroma_offset_l1[i][1]);
1638
1639     }
1640     va_TraceMsg(trace_ctx, NULL);
1641 }
1642
1643 static void va_TraceVAIQMatrixBufferH264(
1644     VADisplay dpy,
1645     VAContextID context,
1646     VABufferID buffer,
1647     VABufferType type,
1648     unsigned int size,
1649     unsigned int num_elements,
1650     void *data
1651 )
1652 {
1653     int i, j;
1654     VAIQMatrixBufferH264* p = (VAIQMatrixBufferH264* )data;
1655
1656     DPY2TRACECTX(dpy);
1657
1658     va_TraceMsg(trace_ctx, "\t--VAIQMatrixBufferH264\n");
1659
1660     va_TraceMsg(trace_ctx, "\tScalingList4x4[6][16]=\n");
1661     for (i = 0; i < 6; i++) {
1662         for (j = 0; j < 16; j++) {
1663             if (trace_ctx->trace_fp_log) {
1664                 fprintf(trace_ctx->trace_fp_log, "\t%d", p->ScalingList4x4[i][j]);
1665                 if ((j + 1) % 8 == 0)
1666                     fprintf(trace_ctx->trace_fp_log, "\n");
1667             }
1668         }
1669     }
1670
1671     va_TraceMsg(trace_ctx, "\tScalingList8x8[2][64]=\n");
1672     for (i = 0; i < 2; i++) {
1673         for (j = 0; j < 64; j++) {
1674             if (trace_ctx->trace_fp_log) {
1675                 fprintf(trace_ctx->trace_fp_log,"\t%d", p->ScalingList8x8[i][j]);
1676                 if ((j + 1) % 8 == 0)
1677                     fprintf(trace_ctx->trace_fp_log, "\n");
1678             }
1679         }
1680     }
1681
1682     va_TraceMsg(trace_ctx, NULL);
1683 }
1684
1685
1686
1687 static void va_TraceVAEncSequenceParameterBufferH264(
1688     VADisplay dpy,
1689     VAContextID context,
1690     VABufferID buffer,
1691     VABufferType type,
1692     unsigned int size,
1693     unsigned int num_elements,
1694     void *data)
1695 {
1696     VAEncSequenceParameterBufferH264 *p = (VAEncSequenceParameterBufferH264 *)data;
1697     DPY2TRACECTX(dpy);
1698     unsigned int i;
1699
1700     va_TraceMsg(trace_ctx, "\t--VAEncSequenceParameterBufferH264\n");
1701
1702     va_TraceMsg(trace_ctx, "\tseq_parameter_set_id = %d\n", p->seq_parameter_set_id);
1703     va_TraceMsg(trace_ctx, "\tlevel_idc = %d\n", p->level_idc);
1704     va_TraceMsg(trace_ctx, "\tintra_period = %d\n", p->intra_period);
1705     va_TraceMsg(trace_ctx, "\tintra_idr_period = %d\n", p->intra_idr_period);
1706     va_TraceMsg(trace_ctx, "\tip_period = %d\n", p->ip_period);
1707     va_TraceMsg(trace_ctx, "\tbits_per_second = %d\n", p->bits_per_second);
1708     va_TraceMsg(trace_ctx, "\tmax_num_ref_frames = %d\n", p->max_num_ref_frames);
1709     va_TraceMsg(trace_ctx, "\tpicture_width_in_mbs = %d\n", p->picture_width_in_mbs);
1710     va_TraceMsg(trace_ctx, "\tpicture_height_in_mbs = %d\n", p->picture_height_in_mbs);
1711     va_TraceMsg(trace_ctx, "\tchroma_format_idc = %d\n", p->seq_fields.bits.chroma_format_idc);
1712     va_TraceMsg(trace_ctx, "\tframe_mbs_only_flag = %d\n", p->seq_fields.bits.frame_mbs_only_flag);
1713     va_TraceMsg(trace_ctx, "\tmb_adaptive_frame_field_flag = %d\n", p->seq_fields.bits.mb_adaptive_frame_field_flag);
1714     va_TraceMsg(trace_ctx, "\tseq_scaling_matrix_present_flag = %d\n", p->seq_fields.bits.seq_scaling_matrix_present_flag);
1715     va_TraceMsg(trace_ctx, "\tdirect_8x8_inference_flag = %d\n", p->seq_fields.bits.direct_8x8_inference_flag);
1716     va_TraceMsg(trace_ctx, "\tlog2_max_frame_num_minus4 = %d\n", p->seq_fields.bits.log2_max_frame_num_minus4);
1717     va_TraceMsg(trace_ctx, "\tpic_order_cnt_type = %d\n", p->seq_fields.bits.pic_order_cnt_type);
1718     va_TraceMsg(trace_ctx, "\tlog2_max_pic_order_cnt_lsb_minus4 = %d\n", p->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4);
1719     va_TraceMsg(trace_ctx, "\tdelta_pic_order_always_zero_flag = %d\n", p->seq_fields.bits.delta_pic_order_always_zero_flag);
1720     va_TraceMsg(trace_ctx, "\tbit_depth_luma_minus8 = %d\n", p->bit_depth_luma_minus8);
1721     va_TraceMsg(trace_ctx, "\tbit_depth_chroma_minus8 = %d\n", p->bit_depth_chroma_minus8);
1722     va_TraceMsg(trace_ctx, "\tnum_ref_frames_in_pic_order_cnt_cycle = %d\n", p->num_ref_frames_in_pic_order_cnt_cycle);
1723     va_TraceMsg(trace_ctx, "\toffset_for_non_ref_pic = %d\n", p->offset_for_non_ref_pic);
1724     va_TraceMsg(trace_ctx, "\toffset_for_top_to_bottom_field = %d\n", p->offset_for_top_to_bottom_field);
1725     for(i = 0; (i < p->max_num_ref_frames) && (i < 32); ++i)
1726         va_TraceMsg(trace_ctx, "\toffset_for_ref_frame[%d] = %d\n", i, p->offset_for_ref_frame[i]);
1727     va_TraceMsg(trace_ctx, "\tframe_cropping_flag = %d\n", p->frame_cropping_flag);
1728     va_TraceMsg(trace_ctx, "\tframe_crop_left_offset = %d\n", p->frame_crop_left_offset);
1729     va_TraceMsg(trace_ctx, "\tframe_crop_right_offset = %d\n", p->frame_crop_right_offset);
1730     va_TraceMsg(trace_ctx, "\tframe_crop_top_offset = %d\n", p->frame_crop_top_offset);
1731     va_TraceMsg(trace_ctx, "\tframe_crop_bottom_offset = %d\n", p->frame_crop_bottom_offset);
1732     va_TraceMsg(trace_ctx, "\tvui_parameters_present_flag = %d\n", p->vui_parameters_present_flag);
1733     va_TraceMsg(trace_ctx, "\taspect_ratio_info_present_flag = %d\n", p->vui_fields.bits.aspect_ratio_info_present_flag);
1734     va_TraceMsg(trace_ctx, "\ttiming_info_present_flag = %d\n", p->vui_fields.bits.timing_info_present_flag);
1735     va_TraceMsg(trace_ctx, "\tbitstream_restriction_flag = %d\n", p->vui_fields.bits.bitstream_restriction_flag);
1736     va_TraceMsg(trace_ctx, "\tlog2_max_mv_length_horizontal = %d\n", p->vui_fields.bits.log2_max_mv_length_horizontal);
1737     va_TraceMsg(trace_ctx, "\tlog2_max_mv_length_vertical = %d\n", p->vui_fields.bits.log2_max_mv_length_vertical);
1738     va_TraceMsg(trace_ctx, "\taspect_ratio_idc = %d\n", p->aspect_ratio_idc);
1739     va_TraceMsg(trace_ctx, "\tsar_width = %d\n", p->sar_width);
1740     va_TraceMsg(trace_ctx, "\tsar_height = %d\n", p->sar_height);
1741     va_TraceMsg(trace_ctx, "\tnum_units_in_tick = %d\n", p->num_units_in_tick);
1742     va_TraceMsg(trace_ctx, "\ttime_scale = %d\n", p->time_scale);
1743
1744     va_TraceMsg(trace_ctx, NULL);
1745
1746     return;
1747 }
1748
1749
1750 static void va_TraceVAEncPictureParameterBufferH264(
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     VAEncPictureParameterBufferH264 *p = (VAEncPictureParameterBufferH264 *)data;
1760     DPY2TRACECTX(dpy);
1761     int i;
1762
1763     va_TraceMsg(trace_ctx, "\t--VAEncPictureParameterBufferH264\n");
1764
1765     va_TraceMsg(trace_ctx, "\tCurrPic.picture_id = 0x%08x\n", p->CurrPic.picture_id);
1766     va_TraceMsg(trace_ctx, "\tCurrPic.frame_idx = %d\n", p->CurrPic.frame_idx);
1767     va_TraceMsg(trace_ctx, "\tCurrPic.flags = %d\n", p->CurrPic.flags);
1768     va_TraceMsg(trace_ctx, "\tCurrPic.TopFieldOrderCnt = %d\n", p->CurrPic.TopFieldOrderCnt);
1769     va_TraceMsg(trace_ctx, "\tCurrPic.BottomFieldOrderCnt = %d\n", p->CurrPic.BottomFieldOrderCnt);
1770     va_TraceMsg(trace_ctx, "\tReferenceFrames (TopFieldOrderCnt-BottomFieldOrderCnt-picture_id-frame_idx-flags):\n");
1771     for (i = 0; i < 16; i++)
1772     {
1773         if ((p->ReferenceFrames[i].picture_id != VA_INVALID_SURFACE) &&
1774             ((p->ReferenceFrames[i].flags & VA_PICTURE_H264_INVALID) == 0)) {
1775             va_TraceMsg(trace_ctx, "\t\t%08d-%08d-0x%08x-%08d-0x%08x\n",
1776                         p->ReferenceFrames[i].TopFieldOrderCnt,
1777                         p->ReferenceFrames[i].BottomFieldOrderCnt,
1778                         p->ReferenceFrames[i].picture_id,
1779                         p->ReferenceFrames[i].frame_idx,
1780                         p->ReferenceFrames[i].flags
1781                         );
1782         } else
1783             break;
1784     }
1785     va_TraceMsg(trace_ctx, "\tcoded_buf = %08x\n", p->coded_buf);
1786     va_TraceMsg(trace_ctx, "\tpic_parameter_set_id = %d\n", p->pic_parameter_set_id);
1787     va_TraceMsg(trace_ctx, "\tseq_parameter_set_id = %d\n", p->seq_parameter_set_id);
1788     va_TraceMsg(trace_ctx, "\tlast_picture = 0x%08x\n", p->last_picture);
1789     va_TraceMsg(trace_ctx, "\tframe_num = %d\n", p->frame_num);
1790     va_TraceMsg(trace_ctx, "\tpic_init_qp = %d\n", p->pic_init_qp);
1791     va_TraceMsg(trace_ctx, "\tnum_ref_idx_l0_active_minus1 = %d\n", p->num_ref_idx_l0_active_minus1);
1792     va_TraceMsg(trace_ctx, "\tnum_ref_idx_l1_active_minus1 = %d\n", p->num_ref_idx_l1_active_minus1);
1793     va_TraceMsg(trace_ctx, "\tchroma_qp_index_offset = %d\n", p->chroma_qp_index_offset);
1794     va_TraceMsg(trace_ctx, "\tsecond_chroma_qp_index_offset = %d\n", p->second_chroma_qp_index_offset);
1795     va_TraceMsg(trace_ctx, "\tpic_fields = 0x%03x\n", p->pic_fields.value);
1796     va_TraceMsg(trace_ctx, "\tidr_pic_flag = %d\n", p->pic_fields.bits.idr_pic_flag);
1797     va_TraceMsg(trace_ctx, "\treference_pic_flag = %d\n", p->pic_fields.bits.reference_pic_flag);
1798     va_TraceMsg(trace_ctx, "\tentropy_coding_mode_flag = %d\n", p->pic_fields.bits.entropy_coding_mode_flag);
1799     va_TraceMsg(trace_ctx, "\tweighted_pred_flag = %d\n", p->pic_fields.bits.weighted_pred_flag);
1800     va_TraceMsg(trace_ctx, "\tweighted_bipred_idc = %d\n", p->pic_fields.bits.weighted_bipred_idc);
1801     va_TraceMsg(trace_ctx, "\tconstrained_intra_pred_flag = %d\n", p->pic_fields.bits.constrained_intra_pred_flag);
1802     va_TraceMsg(trace_ctx, "\ttransform_8x8_mode_flag = %d\n", p->pic_fields.bits.transform_8x8_mode_flag);
1803     va_TraceMsg(trace_ctx, "\tdeblocking_filter_control_present_flag = %d\n", p->pic_fields.bits.deblocking_filter_control_present_flag);
1804     va_TraceMsg(trace_ctx, "\tredundant_pic_cnt_present_flag = %d\n", p->pic_fields.bits.redundant_pic_cnt_present_flag);
1805     va_TraceMsg(trace_ctx, "\tpic_order_present_flag = %d\n", p->pic_fields.bits.pic_order_present_flag);
1806     va_TraceMsg(trace_ctx, "\tpic_scaling_matrix_present_flag = %d\n", p->pic_fields.bits.pic_scaling_matrix_present_flag);
1807
1808     va_TraceMsg(trace_ctx, NULL);
1809
1810     return;
1811 }
1812
1813 static void va_TraceVAEncSliceParameterBuffer(
1814     VADisplay dpy,
1815     VAContextID context,
1816     VABufferID buffer,
1817     VABufferType type,
1818     unsigned int size,
1819     unsigned int num_elements,
1820     void *data)
1821 {
1822     VAEncSliceParameterBuffer* p = (VAEncSliceParameterBuffer*)data;
1823     DPY2TRACECTX(dpy);
1824
1825     va_TraceMsg(trace_ctx, "\t--VAEncSliceParameterBuffer\n");
1826
1827     va_TraceMsg(trace_ctx, "\tstart_row_number = %d\n", p->start_row_number);
1828     va_TraceMsg(trace_ctx, "\tslice_height = %d\n", p->slice_height);
1829     va_TraceMsg(trace_ctx, "\tslice_flags.is_intra = %d\n", p->slice_flags.bits.is_intra);
1830     va_TraceMsg(trace_ctx, "\tslice_flags.disable_deblocking_filter_idc = %d\n", p->slice_flags.bits.disable_deblocking_filter_idc);
1831     va_TraceMsg(trace_ctx, "\tslice_flags.uses_long_term_ref = %d\n", p->slice_flags.bits.uses_long_term_ref);
1832     va_TraceMsg(trace_ctx, "\tslice_flags.is_long_term_ref = %d\n", p->slice_flags.bits.is_long_term_ref);
1833     va_TraceMsg(trace_ctx, NULL);
1834
1835     return;
1836 }
1837
1838 static void va_TraceVAEncSliceParameterBufferH264(
1839     VADisplay dpy,
1840     VAContextID context,
1841     VABufferID buffer,
1842     VABufferType type,
1843     unsigned int size,
1844     unsigned int num_elements,
1845     void *data)
1846 {
1847     VAEncSliceParameterBufferH264* p = (VAEncSliceParameterBufferH264*)data;
1848     DPY2TRACECTX(dpy);
1849     int i;
1850
1851     if (!p)
1852         return;
1853
1854     va_TraceMsg(trace_ctx, "\t--VAEncSliceParameterBufferH264\n");
1855     va_TraceMsg(trace_ctx, "\tmacroblock_address = %d\n", p->macroblock_address);
1856     va_TraceMsg(trace_ctx, "\tnum_macroblocks = %d\n", p->num_macroblocks);
1857     va_TraceMsg(trace_ctx, "\tmacroblock_info = %08x\n", p->macroblock_info);
1858     va_TraceMsg(trace_ctx, "\tslice_type = %d\n", p->slice_type);
1859     va_TraceMsg(trace_ctx, "\tpic_parameter_set_id = %d\n", p->pic_parameter_set_id);
1860     va_TraceMsg(trace_ctx, "\tidr_pic_id = %d\n", p->idr_pic_id);
1861     va_TraceMsg(trace_ctx, "\tpic_order_cnt_lsb = %d\n", p->pic_order_cnt_lsb);
1862     va_TraceMsg(trace_ctx, "\tdelta_pic_order_cnt_bottom = %d\n", p->delta_pic_order_cnt_bottom);
1863     va_TraceMsg(trace_ctx, "\tdelta_pic_order_cnt[0] = %d\n", p->delta_pic_order_cnt[0]);
1864     va_TraceMsg(trace_ctx, "\tdelta_pic_order_cnt[1] = %d\n", p->delta_pic_order_cnt[1]);
1865     va_TraceMsg(trace_ctx, "\tdirect_spatial_mv_pred_flag = %d\n", p->direct_spatial_mv_pred_flag);
1866     va_TraceMsg(trace_ctx, "\tnum_ref_idx_active_override_flag = %d\n", p->num_ref_idx_active_override_flag);
1867     va_TraceMsg(trace_ctx, "\tnum_ref_idx_l1_active_minus1 = %d\n", p->num_ref_idx_l1_active_minus1);
1868     va_TraceMsg(trace_ctx, "\tslice_beta_offset_div2 = %d\n", p->slice_beta_offset_div2);
1869
1870     va_TraceMsg(trace_ctx, "\tRefPicList0 (TopFieldOrderCnt-BottomFieldOrderCnt-picture_id-frame_idx-flags):\n");
1871
1872
1873
1874     for (i = 0; i < 32; i++) {
1875         if ((p->RefPicList0[i].picture_id != VA_INVALID_SURFACE) &&
1876             ((p->RefPicList0[i].flags & VA_PICTURE_H264_INVALID) == 0))
1877             va_TraceMsg(trace_ctx, "\t\t%08d-%08d-0x%08x-%08d-0x%08x\n",
1878                         p->RefPicList0[i].TopFieldOrderCnt,
1879                         p->RefPicList0[i].BottomFieldOrderCnt,
1880                         p->RefPicList0[i].picture_id,
1881                         p->RefPicList0[i].frame_idx,
1882                         p->RefPicList0[i].flags);
1883         else
1884             break;
1885     }
1886
1887     va_TraceMsg(trace_ctx, "\tRefPicList1 (TopFieldOrderCnt-BottomFieldOrderCnt-picture_id-frame_idx-flags):\n");
1888     for (i = 0; i < 32; i++) {
1889         if ((p->RefPicList1[i].picture_id != VA_INVALID_SURFACE) &&
1890             ((p->RefPicList1[i].flags & VA_PICTURE_H264_INVALID) == 0))
1891             va_TraceMsg(trace_ctx, "\t\t%08d-%08d-0x%08x-%08d-0x%08d\n",
1892                         p->RefPicList1[i].TopFieldOrderCnt,
1893                         p->RefPicList1[i].BottomFieldOrderCnt,
1894                         p->RefPicList1[i].picture_id,
1895                         p->RefPicList1[i].frame_idx,
1896                         p->RefPicList1[i].flags
1897                         );
1898         else
1899             break;
1900     }
1901
1902     va_TraceMsg(trace_ctx, "\tluma_log2_weight_denom = %d\n", p->luma_log2_weight_denom);
1903     va_TraceMsg(trace_ctx, "\tchroma_log2_weight_denom = %d\n", p->chroma_log2_weight_denom);
1904     va_TraceMsg(trace_ctx, "\tluma_weight_l0_flag = %d\n", p->luma_weight_l0_flag);
1905     if (p->luma_weight_l0_flag) {
1906         for (i = 0; (i <= p->num_ref_idx_l0_active_minus1) && (i<32); i++) {
1907             va_TraceMsg(trace_ctx, "\t\t%d\t%d\n",
1908                         p->luma_weight_l0[i],
1909                         p->luma_offset_l0[i]);
1910         }
1911     }
1912
1913     va_TraceMsg(trace_ctx, "\tchroma_weight_l0_flag = %d\n", p->chroma_weight_l0_flag);
1914     if (p->chroma_weight_l0_flag) {
1915         for (i = 0; (i <= p->num_ref_idx_l0_active_minus1) && (i<32); i++) {
1916             va_TraceMsg(trace_ctx, "\t\t%d\t%d\t%d\t%d\n",
1917                         p->chroma_weight_l0[i][0],
1918                         p->chroma_offset_l0[i][0],
1919                         p->chroma_weight_l0[i][1],
1920                         p->chroma_offset_l0[i][1]);
1921         }
1922     }
1923
1924     va_TraceMsg(trace_ctx, "\tluma_weight_l1_flag = %d\n", p->luma_weight_l1_flag);
1925     if (p->luma_weight_l1_flag) {
1926         for (i = 0; (i <= p->num_ref_idx_l1_active_minus1) && (i<32); i++) {
1927             va_TraceMsg(trace_ctx, "\t\t%d\t\t%d\n",
1928                         p->luma_weight_l1[i],
1929                         p->luma_offset_l1[i]);
1930         }
1931     }
1932
1933     va_TraceMsg(trace_ctx, "\tchroma_weight_l1_flag = %d\n", p->chroma_weight_l1_flag);
1934     if (p->chroma_weight_l1_flag && p->num_ref_idx_l1_active_minus1 < 32) {
1935         for (i = 0; (i <= p->num_ref_idx_l1_active_minus1) && (i<32); i++) {
1936             va_TraceMsg(trace_ctx, "\t\t%d\t%d\t%d\t%d\n",
1937                         p->chroma_weight_l1[i][0],
1938                         p->chroma_offset_l1[i][0],
1939                         p->chroma_weight_l1[i][1],
1940                         p->chroma_offset_l1[i][1]);
1941         }
1942     }
1943     va_TraceMsg(trace_ctx, NULL);
1944
1945     va_TraceMsg(trace_ctx, "\tcabac_init_idc = %d\n", p->cabac_init_idc);
1946     va_TraceMsg(trace_ctx, "\tslice_qp_delta = %d\n", p->slice_qp_delta);
1947     va_TraceMsg(trace_ctx, "\tdisable_deblocking_filter_idc = %d\n", p->disable_deblocking_filter_idc);
1948     va_TraceMsg(trace_ctx, "\tslice_alpha_c0_offset_div2 = %d\n", p->slice_alpha_c0_offset_div2);
1949     va_TraceMsg(trace_ctx, "\tslice_beta_offset_div2 = %d\n", p->slice_beta_offset_div2);
1950     va_TraceMsg(trace_ctx, NULL);
1951
1952     return;
1953 }
1954
1955
1956 static void va_TraceVAEncPackedHeaderParameterBufferType(
1957     VADisplay dpy,
1958     VAContextID context,
1959     VABufferID buffer,
1960     VABufferType type,
1961     unsigned int size,
1962     unsigned int num_elements,
1963     void *data)
1964 {
1965     VAEncPackedHeaderParameterBuffer* p = (VAEncPackedHeaderParameterBuffer*)data;
1966     DPY2TRACECTX(dpy);
1967     int i;
1968
1969     if (!p)
1970         return;
1971     va_TraceMsg(trace_ctx, "\t--VAEncPackedHeaderParameterBuffer\n");
1972     va_TraceMsg(trace_ctx, "\ttype = 0x%08x\n", p->type);
1973     va_TraceMsg(trace_ctx, "\tbit_length = %d\n", p->bit_length);
1974     va_TraceMsg(trace_ctx, "\thas_emulation_bytes = %d\n", p->has_emulation_bytes);
1975     va_TraceMsg(trace_ctx, NULL);
1976
1977     return;
1978 }
1979
1980 static void va_TraceVAEncMiscParameterBuffer(
1981     VADisplay dpy,
1982     VAContextID context,
1983     VABufferID buffer,
1984     VABufferType type,
1985     unsigned int size,
1986     unsigned int num_elements,
1987     void *data)
1988 {
1989     VAEncMiscParameterBuffer* tmp = (VAEncMiscParameterBuffer*)data;
1990     DPY2TRACECTX(dpy);
1991
1992     switch (tmp->type) {
1993     case VAEncMiscParameterTypeFrameRate:
1994     {
1995         VAEncMiscParameterFrameRate *p = (VAEncMiscParameterFrameRate *)tmp->data;
1996         va_TraceMsg(trace_ctx, "\t--VAEncMiscParameterFrameRate\n");
1997         va_TraceMsg(trace_ctx, "\tframerate = %d\n", p->framerate);
1998
1999         break;
2000     }
2001     case VAEncMiscParameterTypeRateControl:
2002     {
2003         VAEncMiscParameterRateControl *p = (VAEncMiscParameterRateControl *)tmp->data;
2004
2005         va_TraceMsg(trace_ctx, "\t--VAEncMiscParameterRateControl\n");
2006         va_TraceMsg(trace_ctx, "\tbits_per_second = %d\n", p->bits_per_second);
2007         va_TraceMsg(trace_ctx, "\ttarget_percentage = %d\n", p->target_percentage);
2008         va_TraceMsg(trace_ctx, "\twindow_size = %d\n", p->window_size);
2009         va_TraceMsg(trace_ctx, "\tinitial_qp = %d\n", p->initial_qp);
2010         va_TraceMsg(trace_ctx, "\tmin_qp = %d\n", p->min_qp);
2011         va_TraceMsg(trace_ctx, "\tbasic_unit_size = %d\n", p->basic_unit_size);
2012         va_TraceMsg(trace_ctx, "\trc_flags.reset = %d \n", p->rc_flags.bits.reset);
2013         va_TraceMsg(trace_ctx, "\trc_flags.disable_frame_skip = %d\n", p->rc_flags.bits.disable_frame_skip);
2014         va_TraceMsg(trace_ctx, "\trc_flags.disable_bit_stuffing = %d\n", p->rc_flags.bits.disable_bit_stuffing);
2015         break;
2016     }
2017     case VAEncMiscParameterTypeMaxSliceSize:
2018     {
2019         VAEncMiscParameterMaxSliceSize *p = (VAEncMiscParameterMaxSliceSize *)tmp->data;
2020
2021         va_TraceMsg(trace_ctx, "\t--VAEncMiscParameterTypeMaxSliceSize\n");
2022         va_TraceMsg(trace_ctx, "\tmax_slice_size = %d\n", p->max_slice_size);
2023         break;
2024     }
2025     case VAEncMiscParameterTypeAIR:
2026     {
2027         VAEncMiscParameterAIR *p = (VAEncMiscParameterAIR *)tmp->data;
2028
2029         va_TraceMsg(trace_ctx, "\t--VAEncMiscParameterAIR\n");
2030         va_TraceMsg(trace_ctx, "\tair_num_mbs = %d\n", p->air_num_mbs);
2031         va_TraceMsg(trace_ctx, "\tair_threshold = %d\n", p->air_threshold);
2032         va_TraceMsg(trace_ctx, "\tair_auto = %d\n", p->air_auto);
2033         break;
2034     }
2035     case VAEncMiscParameterTypeHRD:
2036     {
2037         VAEncMiscParameterHRD *p = (VAEncMiscParameterHRD *)tmp->data;
2038
2039         va_TraceMsg(trace_ctx, "\t--VAEncMiscParameterHRD\n");
2040         va_TraceMsg(trace_ctx, "\tinitial_buffer_fullness = %d\n", p->initial_buffer_fullness);
2041         va_TraceMsg(trace_ctx, "\tbuffer_size = %d\n", p->buffer_size);
2042         break;
2043     }
2044     case VAEncMiscParameterTypeMaxFrameSize:
2045     {
2046         VAEncMiscParameterBufferMaxFrameSize *p = (VAEncMiscParameterBufferMaxFrameSize *)tmp->data;
2047
2048         va_TraceMsg(trace_ctx, "\t--VAEncMiscParameterTypeMaxFrameSize\n");
2049         va_TraceMsg(trace_ctx, "\tmax_frame_size = %d\n", p->max_frame_size);
2050         break;
2051     }
2052     default:
2053         va_TraceMsg(trace_ctx, "Unknown VAEncMiscParameterBuffer(type = %d):\n", tmp->type);
2054         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, data);
2055         break;
2056     }
2057     va_TraceMsg(trace_ctx, NULL);
2058
2059     return;
2060 }
2061
2062
2063 static void va_TraceVAPictureParameterBufferVC1(
2064     VADisplay dpy,
2065     VAContextID context,
2066     VABufferID buffer,
2067     VABufferType type,
2068     unsigned int size,
2069     unsigned int num_elements,
2070     void *data
2071 )
2072 {
2073     VAPictureParameterBufferVC1* p = (VAPictureParameterBufferVC1*)data;
2074     DPY2TRACECTX(dpy);
2075
2076     va_TraceMsg(trace_ctx, "\t--VAPictureParameterBufferVC1\n");
2077
2078     va_TraceMsg(trace_ctx, "\tforward_reference_picture = 0x%08x\n", p->forward_reference_picture);
2079     va_TraceMsg(trace_ctx, "\tbackward_reference_picture = 0x%08x\n", p->backward_reference_picture);
2080     va_TraceMsg(trace_ctx, "\tinloop_decoded_picture = 0x%08x\n", p->inloop_decoded_picture);
2081
2082     va_TraceMsg(trace_ctx, "\tpulldown = %d\n", p->sequence_fields.bits.pulldown);
2083     va_TraceMsg(trace_ctx, "\tinterlace = %d\n", p->sequence_fields.bits.interlace);
2084     va_TraceMsg(trace_ctx, "\ttfcntrflag = %d\n", p->sequence_fields.bits.tfcntrflag);
2085     va_TraceMsg(trace_ctx, "\tfinterpflag = %d\n", p->sequence_fields.bits.finterpflag);
2086     va_TraceMsg(trace_ctx, "\tpsf = %d\n", p->sequence_fields.bits.psf);
2087     va_TraceMsg(trace_ctx, "\tmultires = %d\n", p->sequence_fields.bits.multires);
2088     va_TraceMsg(trace_ctx, "\toverlap = %d\n", p->sequence_fields.bits.overlap);
2089     va_TraceMsg(trace_ctx, "\tsyncmarker = %d\n", p->sequence_fields.bits.syncmarker);
2090     va_TraceMsg(trace_ctx, "\trangered = %d\n", p->sequence_fields.bits.rangered);
2091     va_TraceMsg(trace_ctx, "\tmax_b_frames = %d\n", p->sequence_fields.bits.max_b_frames);
2092     va_TraceMsg(trace_ctx, "\tprofile = %d\n", p->sequence_fields.bits.profile);
2093     va_TraceMsg(trace_ctx, "\tcoded_width = %d\n", p->coded_width);
2094     va_TraceMsg(trace_ctx, "\tcoded_height = %d\n", p->coded_height);
2095     va_TraceMsg(trace_ctx, "\tclosed_entry = %d\n", p->entrypoint_fields.bits.closed_entry);
2096     va_TraceMsg(trace_ctx, "\tbroken_link = %d\n", p->entrypoint_fields.bits.broken_link);
2097     va_TraceMsg(trace_ctx, "\tclosed_entry = %d\n", p->entrypoint_fields.bits.closed_entry);
2098     va_TraceMsg(trace_ctx, "\tpanscan_flag = %d\n", p->entrypoint_fields.bits.panscan_flag);
2099     va_TraceMsg(trace_ctx, "\tloopfilter = %d\n", p->entrypoint_fields.bits.loopfilter);
2100     va_TraceMsg(trace_ctx, "\tconditional_overlap_flag = %d\n", p->conditional_overlap_flag);
2101     va_TraceMsg(trace_ctx, "\tfast_uvmc_flag = %d\n", p->fast_uvmc_flag);
2102     va_TraceMsg(trace_ctx, "\trange_mapping_luma_flag = %d\n", p->range_mapping_fields.bits.luma_flag);
2103     va_TraceMsg(trace_ctx, "\trange_mapping_luma = %d\n", p->range_mapping_fields.bits.luma);
2104     va_TraceMsg(trace_ctx, "\trange_mapping_chroma_flag = %d\n", p->range_mapping_fields.bits.chroma_flag);
2105     va_TraceMsg(trace_ctx, "\trange_mapping_chroma = %d\n", p->range_mapping_fields.bits.chroma);
2106     va_TraceMsg(trace_ctx, "\tb_picture_fraction = %d\n", p->b_picture_fraction);
2107     va_TraceMsg(trace_ctx, "\tcbp_table = %d\n", p->cbp_table);
2108     va_TraceMsg(trace_ctx, "\tmb_mode_table = %d\n", p->mb_mode_table);
2109     va_TraceMsg(trace_ctx, "\trange_reduction_frame = %d\n", p->range_reduction_frame);
2110     va_TraceMsg(trace_ctx, "\trounding_control = %d\n", p->rounding_control);
2111     va_TraceMsg(trace_ctx, "\tpost_processing = %d\n", p->post_processing);
2112     va_TraceMsg(trace_ctx, "\tpicture_resolution_index = %d\n", p->picture_resolution_index);
2113     va_TraceMsg(trace_ctx, "\tluma_scale = %d\n", p->luma_scale);
2114     va_TraceMsg(trace_ctx, "\tluma_shift = %d\n", p->luma_shift);
2115     va_TraceMsg(trace_ctx, "\tpicture_type = %d\n", p->picture_fields.bits.picture_type);
2116     va_TraceMsg(trace_ctx, "\tframe_coding_mode = %d\n", p->picture_fields.bits.frame_coding_mode);
2117     va_TraceMsg(trace_ctx, "\ttop_field_first = %d\n", p->picture_fields.bits.top_field_first);
2118     va_TraceMsg(trace_ctx, "\tis_first_field = %d\n", p->picture_fields.bits.is_first_field);
2119     va_TraceMsg(trace_ctx, "\tintensity_compensation = %d\n", p->picture_fields.bits.intensity_compensation);
2120     va_TraceMsg(trace_ctx, "\tmv_type_mb = %d\n", p->raw_coding.flags.mv_type_mb);
2121     va_TraceMsg(trace_ctx, "\tdirect_mb = %d\n", p->raw_coding.flags.direct_mb);
2122     va_TraceMsg(trace_ctx, "\tskip_mb = %d\n", p->raw_coding.flags.skip_mb);
2123     va_TraceMsg(trace_ctx, "\tfield_tx = %d\n", p->raw_coding.flags.field_tx);
2124     va_TraceMsg(trace_ctx, "\tforward_mb = %d\n", p->raw_coding.flags.forward_mb);
2125     va_TraceMsg(trace_ctx, "\tac_pred = %d\n", p->raw_coding.flags.ac_pred);
2126     va_TraceMsg(trace_ctx, "\toverflags = %d\n", p->raw_coding.flags.overflags);
2127     va_TraceMsg(trace_ctx, "\tbp_mv_type_mb = %d\n", p->bitplane_present.flags.bp_mv_type_mb);
2128     va_TraceMsg(trace_ctx, "\tbp_direct_mb = %d\n", p->bitplane_present.flags.bp_direct_mb);
2129     va_TraceMsg(trace_ctx, "\tbp_skip_mb = %d\n", p->bitplane_present.flags.bp_skip_mb);
2130     va_TraceMsg(trace_ctx, "\tbp_field_tx = %d\n", p->bitplane_present.flags.bp_field_tx);
2131     va_TraceMsg(trace_ctx, "\tbp_forward_mb = %d\n", p->bitplane_present.flags.bp_forward_mb);
2132     va_TraceMsg(trace_ctx, "\tbp_ac_pred = %d\n", p->bitplane_present.flags.bp_ac_pred);
2133     va_TraceMsg(trace_ctx, "\tbp_overflags = %d\n", p->bitplane_present.flags.bp_overflags);
2134     va_TraceMsg(trace_ctx, "\treference_distance_flag = %d\n", p->reference_fields.bits.reference_distance_flag);
2135     va_TraceMsg(trace_ctx, "\treference_distance = %d\n", p->reference_fields.bits.reference_distance);
2136     va_TraceMsg(trace_ctx, "\tnum_reference_pictures = %d\n", p->reference_fields.bits.num_reference_pictures);
2137     va_TraceMsg(trace_ctx, "\treference_field_pic_indicator = %d\n", p->reference_fields.bits.reference_field_pic_indicator);
2138     va_TraceMsg(trace_ctx, "\tmv_mode = %d\n", p->mv_fields.bits.mv_mode);
2139     va_TraceMsg(trace_ctx, "\tmv_mode2 = %d\n", p->mv_fields.bits.mv_mode2);
2140     va_TraceMsg(trace_ctx, "\tmv_table = %d\n", p->mv_fields.bits.mv_table);
2141     va_TraceMsg(trace_ctx, "\ttwo_mv_block_pattern_table = %d\n", p->mv_fields.bits.two_mv_block_pattern_table);
2142     va_TraceMsg(trace_ctx, "\tfour_mv_switch = %d\n", p->mv_fields.bits.four_mv_switch);
2143     va_TraceMsg(trace_ctx, "\tfour_mv_block_pattern_table = %d\n", p->mv_fields.bits.four_mv_block_pattern_table);
2144     va_TraceMsg(trace_ctx, "\textended_mv_flag = %d\n", p->mv_fields.bits.extended_mv_flag);
2145     va_TraceMsg(trace_ctx, "\textended_mv_range = %d\n", p->mv_fields.bits.extended_mv_range);
2146     va_TraceMsg(trace_ctx, "\textended_dmv_flag = %d\n", p->mv_fields.bits.extended_dmv_flag);
2147     va_TraceMsg(trace_ctx, "\textended_dmv_range = %d\n", p->mv_fields.bits.extended_dmv_range);
2148     va_TraceMsg(trace_ctx, "\tdquant = %d\n", p->pic_quantizer_fields.bits.dquant);
2149     va_TraceMsg(trace_ctx, "\tquantizer = %d\n", p->pic_quantizer_fields.bits.quantizer);
2150     va_TraceMsg(trace_ctx, "\thalf_qp = %d\n", p->pic_quantizer_fields.bits.half_qp);
2151     va_TraceMsg(trace_ctx, "\tpic_quantizer_scale = %d\n", p->pic_quantizer_fields.bits.pic_quantizer_scale);
2152     va_TraceMsg(trace_ctx, "\tpic_quantizer_type = %d\n", p->pic_quantizer_fields.bits.pic_quantizer_type);
2153     va_TraceMsg(trace_ctx, "\tdq_frame = %d\n", p->pic_quantizer_fields.bits.dq_frame);
2154     va_TraceMsg(trace_ctx, "\tdq_profile = %d\n", p->pic_quantizer_fields.bits.dq_profile);
2155     va_TraceMsg(trace_ctx, "\tdq_sb_edge = %d\n", p->pic_quantizer_fields.bits.dq_sb_edge);
2156     va_TraceMsg(trace_ctx, "\tdq_db_edge = %d\n", p->pic_quantizer_fields.bits.dq_db_edge);
2157     va_TraceMsg(trace_ctx, "\tdq_binary_level = %d\n", p->pic_quantizer_fields.bits.dq_binary_level);
2158     va_TraceMsg(trace_ctx, "\talt_pic_quantizer = %d\n", p->pic_quantizer_fields.bits.alt_pic_quantizer);
2159     va_TraceMsg(trace_ctx, "\tvariable_sized_transform_flag = %d\n", p->transform_fields.bits.variable_sized_transform_flag);
2160     va_TraceMsg(trace_ctx, "\tmb_level_transform_type_flag = %d\n", p->transform_fields.bits.mb_level_transform_type_flag);
2161     va_TraceMsg(trace_ctx, "\tframe_level_transform_type = %d\n", p->transform_fields.bits.frame_level_transform_type);
2162     va_TraceMsg(trace_ctx, "\ttransform_ac_codingset_idx1 = %d\n", p->transform_fields.bits.transform_ac_codingset_idx1);
2163     va_TraceMsg(trace_ctx, "\ttransform_ac_codingset_idx2 = %d\n", p->transform_fields.bits.transform_ac_codingset_idx2);
2164     va_TraceMsg(trace_ctx, "\tintra_transform_dc_table = %d\n", p->transform_fields.bits.intra_transform_dc_table);
2165     va_TraceMsg(trace_ctx, NULL);
2166 }
2167
2168 static void va_TraceVASliceParameterBufferVC1(
2169     VADisplay dpy,
2170     VAContextID context,
2171     VABufferID buffer,
2172     VABufferType type,
2173     unsigned int size,
2174     unsigned int num_elements,
2175     void* data
2176 )
2177 {
2178     VASliceParameterBufferVC1 *p = (VASliceParameterBufferVC1*)data;
2179     DPY2TRACECTX(dpy);
2180
2181     trace_ctx->trace_slice_no++;
2182     trace_ctx->trace_slice_size = p->slice_data_size;
2183
2184     va_TraceMsg(trace_ctx, "\t--VASliceParameterBufferVC1\n");
2185     va_TraceMsg(trace_ctx, "\tslice_data_size = %d\n", p->slice_data_size);
2186     va_TraceMsg(trace_ctx, "\tslice_data_offset = %d\n", p->slice_data_offset);
2187     va_TraceMsg(trace_ctx, "\tslice_data_flag = %d\n", p->slice_data_flag);
2188     va_TraceMsg(trace_ctx, "\tmacroblock_offset = %d\n", p->macroblock_offset);
2189     va_TraceMsg(trace_ctx, "\tslice_vertical_position = %d\n", p->slice_vertical_position);
2190     va_TraceMsg(trace_ctx, NULL);
2191 }
2192
2193 static void va_TraceVAPictureParameterBufferVP8(
2194     VADisplay dpy,
2195     VAContextID context,
2196     VABufferID buffer,
2197     VABufferType type,
2198     unsigned int size,
2199     unsigned int num_elements,
2200     void *data)
2201 {
2202     char tmp[1024];
2203     VAPictureParameterBufferVP8 *p = (VAPictureParameterBufferVP8 *)data;
2204     DPY2TRACECTX(dpy);
2205     int i,j;
2206
2207     va_TraceMsg(trace_ctx, "\t--VAPictureParameterBufferVP8\n");
2208
2209     va_TraceMsg(trace_ctx, "\tframe_width = %d\n", p->frame_width);
2210     va_TraceMsg(trace_ctx, "\tframe_height = %d\n", p->frame_height);
2211     va_TraceMsg(trace_ctx, "\tlast_ref_frame = %x\n", p->last_ref_frame);
2212     va_TraceMsg(trace_ctx, "\tgolden_ref_frame = %x\n", p->golden_ref_frame);
2213     va_TraceMsg(trace_ctx, "\talt_ref_frame = %x\n", p->alt_ref_frame);
2214     va_TraceMsg(trace_ctx, "\tout_of_loop_frame = %x\n", p->out_of_loop_frame);
2215
2216     va_TraceMsg(trace_ctx, "\tkey_frame = %d\n", p->pic_fields.bits.key_frame);
2217     va_TraceMsg(trace_ctx, "\tversion = %d\n", p->pic_fields.bits.version);
2218     va_TraceMsg(trace_ctx, "\tsegmentation_enabled = %d\n", p->pic_fields.bits.segmentation_enabled);
2219     va_TraceMsg(trace_ctx, "\tupdate_mb_segmentation_map = %d\n", p->pic_fields.bits.update_mb_segmentation_map);
2220     va_TraceMsg(trace_ctx, "\tupdate_segment_feature_data = %d\n", p->pic_fields.bits.update_segment_feature_data);
2221     va_TraceMsg(trace_ctx, "\tfilter_type = %d\n", p->pic_fields.bits.filter_type);
2222     va_TraceMsg(trace_ctx, "\tsharpness_level = %d\n", p->pic_fields.bits.sharpness_level);
2223     va_TraceMsg(trace_ctx, "\tloop_filter_adj_enable = %d\n", p->pic_fields.bits.loop_filter_adj_enable);
2224     va_TraceMsg(trace_ctx, "\tmode_ref_lf_delta_update = %d\n", p->pic_fields.bits.mode_ref_lf_delta_update);
2225     va_TraceMsg(trace_ctx, "\tsign_bias_golden = %d\n", p->pic_fields.bits.sign_bias_golden);
2226     va_TraceMsg(trace_ctx, "\tsign_bias_alternate = %d\n", p->pic_fields.bits.sign_bias_alternate);
2227     va_TraceMsg(trace_ctx, "\tmb_no_coeff_skip = %d\n", p->pic_fields.bits.mb_no_coeff_skip);
2228     va_TraceMsg(trace_ctx, "\tloop_filter_disable = %d\n", p->pic_fields.bits.loop_filter_disable);
2229
2230     va_TraceMsg(trace_ctx, "\tmb_segment_tree_probs: 0x%2x, 0x%2x, 0x%2x\n",
2231         p->mb_segment_tree_probs[0], p->mb_segment_tree_probs[1], p->mb_segment_tree_probs[2]);
2232
2233     va_TraceMsg(trace_ctx, "\tloop_filter_level: %d, %d, %d, %d\n",
2234         p->loop_filter_level[0], p->loop_filter_level[1], p->loop_filter_level[2], p->loop_filter_level[3]);
2235
2236     va_TraceMsg(trace_ctx, "\tloop_filter_deltas_ref_frame: %d, %d, %d, %d\n",
2237         p->loop_filter_deltas_ref_frame[0], p->loop_filter_deltas_ref_frame[1], p->loop_filter_deltas_ref_frame[2], p->loop_filter_deltas_ref_frame[3]);
2238
2239     va_TraceMsg(trace_ctx, "\tloop_filter_deltas_mode: %d, %d, %d, %d\n",
2240         p->loop_filter_deltas_mode[0], p->loop_filter_deltas_mode[1], p->loop_filter_deltas_mode[2], p->loop_filter_deltas_mode[3]);
2241
2242     va_TraceMsg(trace_ctx, "\tprob_skip_false = %2x\n", p->prob_skip_false);
2243     va_TraceMsg(trace_ctx, "\tprob_intra = %2x\n", p->prob_intra);
2244     va_TraceMsg(trace_ctx, "\tprob_last = %2x\n", p->prob_last);
2245     va_TraceMsg(trace_ctx, "\tprob_gf = %2x\n", p->prob_gf);
2246
2247     va_TraceMsg(trace_ctx, "\ty_mode_probs: 0x%2x, 0x%2x, 0x%2x, 0x%2x\n",
2248         p->y_mode_probs[0], p->y_mode_probs[1], p->y_mode_probs[2], p->y_mode_probs[3]);
2249
2250     va_TraceMsg(trace_ctx, "\tuv_mode_probs: 0x%2x, 0x%2x, 0x%2x\n",
2251         p->uv_mode_probs[0], p->uv_mode_probs[1], p->uv_mode_probs[2]);
2252
2253     va_TraceMsg(trace_ctx, "\tmv_probs[2][19]:\n");
2254     for(i = 0; i<2; ++i) {
2255         memset(tmp, 0, sizeof tmp);
2256         for (j=0; j<19; j++)
2257             sprintf(tmp + strlen(tmp), "%2x ", p->mv_probs[i][j]);
2258         va_TraceMsg(trace_ctx,"\t\t[%d] = %s\n", i, tmp);
2259     }
2260
2261     va_TraceMsg(trace_ctx, "\tbool_coder_ctx: range = %02x, value = %02x, count = %d\n",
2262         p->bool_coder_ctx.range, p->bool_coder_ctx.value, p->bool_coder_ctx.count);
2263
2264     va_TraceMsg(trace_ctx, NULL);
2265
2266     return;
2267 }
2268
2269 static void va_TraceVASliceParameterBufferVP8(
2270     VADisplay dpy,
2271     VAContextID context,
2272     VABufferID buffer,
2273     VABufferType type,
2274     unsigned int size,
2275     unsigned int num_elements,
2276     void *data)
2277 {
2278     VASliceParameterBufferVP8 *p = (VASliceParameterBufferVP8 *)data;
2279     DPY2TRACECTX(dpy);
2280     int i;
2281
2282     va_TraceMsg(trace_ctx, "\t--VASliceParameterBufferVP8\n");
2283
2284     va_TraceMsg(trace_ctx, "\tslice_data_size = %d\n", p->slice_data_size);
2285     va_TraceMsg(trace_ctx, "\tslice_data_offset = %d\n", p->slice_data_offset);
2286     va_TraceMsg(trace_ctx, "\tslice_data_flag = %d\n", p->slice_data_flag);
2287     va_TraceMsg(trace_ctx, "\tmacroblock_offset = %d\n", p->macroblock_offset);
2288     va_TraceMsg(trace_ctx, "\tnum_of_partitions = %d\n", p->num_of_partitions);
2289
2290     for(i = 0; i<9; ++i)
2291         va_TraceMsg(trace_ctx, "\tpartition_size[%d] = %d\n", i, p->partition_size[i]);
2292
2293     va_TraceMsg(trace_ctx, NULL);
2294
2295     return;
2296 }
2297
2298 static void va_TraceVAIQMatrixBufferVP8(
2299     VADisplay dpy,
2300     VAContextID context,
2301     VABufferID buffer,
2302     VABufferType type,
2303     unsigned int size,
2304     unsigned int num_elements,
2305     void *data)
2306 {
2307     char tmp[1024];
2308     VAIQMatrixBufferVP8 *p = (VAIQMatrixBufferVP8 *)data;
2309     DPY2TRACECTX(dpy);
2310     int i,j;
2311
2312     va_TraceMsg(trace_ctx, "\t--VAIQMatrixBufferVP8\n");
2313
2314     va_TraceMsg(trace_ctx, "\tquantization_index[4][6]=\n");
2315     for (i = 0; i < 4; i++) {
2316         memset(tmp, 0, sizeof tmp);
2317         for (j = 0; j < 6; j++)
2318             sprintf(tmp + strlen(tmp), "%4x, ", p->quantization_index[i][j]);
2319         va_TraceMsg(trace_ctx,"\t\t[%d] = %s\n", i, tmp);
2320     }
2321
2322     va_TraceMsg(trace_ctx, NULL);
2323
2324     return;
2325 }
2326 static void va_TraceVAProbabilityBufferVP8(
2327     VADisplay dpy,
2328     VAContextID context,
2329     VABufferID buffer,
2330     VABufferType type,
2331     unsigned int size,
2332     unsigned int num_elements,
2333     void *data)
2334 {
2335     char tmp[1024];
2336     VAProbabilityDataBufferVP8 *p = (VAProbabilityDataBufferVP8 *)data;
2337     DPY2TRACECTX(dpy);
2338     int i,j,k,l;
2339
2340     va_TraceMsg(trace_ctx, "\t--VAProbabilityDataBufferVP8\n");
2341
2342     for (i = 0; i < 4; i++)
2343         for (j = 0; j < 8; j++) {
2344             memset(tmp, 0, sizeof tmp);
2345             for (k=0; k<3; k++)
2346                 for (l=0; l<11; l++)
2347                     sprintf(tmp + strlen(tmp), "%2x, ", p->dct_coeff_probs[i][j][k][l]);
2348             va_TraceMsg(trace_ctx,"\t\t[%d, %d] = %s\n", i, j, tmp);
2349         }
2350
2351     va_TraceMsg(trace_ctx, NULL);
2352
2353     return;
2354 }
2355
2356 void va_TraceBeginPicture(
2357     VADisplay dpy,
2358     VAContextID context,
2359     VASurfaceID render_target
2360 )
2361 {
2362     DPY2TRACECTX(dpy);
2363
2364     TRACE_FUNCNAME(idx);
2365
2366     va_TraceMsg(trace_ctx, "\tcontext = 0x%08x\n", context);
2367     va_TraceMsg(trace_ctx, "\trender_targets = 0x%08x\n", render_target);
2368     va_TraceMsg(trace_ctx, "\tframe_count  = #%d\n", trace_ctx->trace_frame_no);
2369     va_TraceMsg(trace_ctx, NULL);
2370
2371     trace_ctx->trace_rendertarget = render_target; /* for surface data dump after vaEndPicture */
2372
2373     trace_ctx->trace_frame_no++;
2374     trace_ctx->trace_slice_no = 0;
2375 }
2376
2377 static void va_TraceMPEG2Buf(
2378     VADisplay dpy,
2379     VAContextID context,
2380     VABufferID buffer,
2381     VABufferType type,
2382     unsigned int size,
2383     unsigned int num_elements,
2384     void *pbuf
2385 )
2386 {
2387     switch (type) {
2388     case VAPictureParameterBufferType:
2389         va_TraceVAPictureParameterBufferMPEG2(dpy, context, buffer, type, size, num_elements, pbuf);
2390         break;
2391     case VAIQMatrixBufferType:
2392         va_TraceVAIQMatrixBufferMPEG2(dpy, context, buffer, type, size, num_elements, pbuf);
2393         break;
2394     case VABitPlaneBufferType:
2395         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2396         break;
2397     case VASliceGroupMapBufferType:
2398         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2399         break;
2400     case VASliceParameterBufferType:
2401         va_TraceVASliceParameterBufferMPEG2(dpy, context, buffer, type, size, num_elements, pbuf);
2402         break;
2403     case VASliceDataBufferType:
2404         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2405         break;
2406     case VAMacroblockParameterBufferType:
2407         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2408         break;
2409     case VAResidualDataBufferType:
2410         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2411         break;
2412     case VADeblockingParameterBufferType:
2413         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2414         break;
2415     case VAImageBufferType:
2416         break;
2417     case VAProtectedSliceDataBufferType:
2418         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2419         break;
2420     case VAEncCodedBufferType:
2421         break;
2422     case VAEncSequenceParameterBufferType:
2423         break;
2424     case VAEncPictureParameterBufferType:
2425         break;
2426     case VAEncSliceParameterBufferType:
2427         break;
2428     default:
2429         break;
2430     }
2431 }
2432
2433 static void va_TraceVAEncSequenceParameterBufferH263(
2434     VADisplay dpy,
2435     VAContextID context,
2436     VABufferID buffer,
2437     VABufferType type,
2438     unsigned int size,
2439     unsigned int num_elements,
2440     void *data)
2441 {
2442     VAEncSequenceParameterBufferH263 *p = (VAEncSequenceParameterBufferH263 *)data;
2443     DPY2TRACECTX(dpy);
2444
2445     va_TraceMsg(trace_ctx, "\t--VAEncSequenceParameterBufferH263\n");
2446
2447     va_TraceMsg(trace_ctx, "\tintra_period = %d\n", p->intra_period);
2448     va_TraceMsg(trace_ctx, "\tbits_per_second = %d\n", p->bits_per_second);
2449     va_TraceMsg(trace_ctx, "\tframe_rate = %d\n", p->frame_rate);
2450     va_TraceMsg(trace_ctx, "\tinitial_qp = %d\n", p->initial_qp);
2451     va_TraceMsg(trace_ctx, "\tmin_qp = %d\n", p->min_qp);
2452     va_TraceMsg(trace_ctx, NULL);
2453
2454     return;
2455 }
2456
2457
2458 static void va_TraceVAEncPictureParameterBufferH263(
2459     VADisplay dpy,
2460     VAContextID context,
2461     VABufferID buffer,
2462     VABufferType type,
2463     unsigned int size,
2464     unsigned int num_elements,
2465     void *data)
2466 {
2467     VAEncPictureParameterBufferH263 *p = (VAEncPictureParameterBufferH263 *)data;
2468     DPY2TRACECTX(dpy);
2469
2470     va_TraceMsg(trace_ctx, "\t--VAEncPictureParameterBufferH263\n");
2471     va_TraceMsg(trace_ctx, "\treference_picture = 0x%08x\n", p->reference_picture);
2472     va_TraceMsg(trace_ctx, "\treconstructed_picture = 0x%08x\n", p->reconstructed_picture);
2473     va_TraceMsg(trace_ctx, "\tcoded_buf = %08x\n", p->coded_buf);
2474     va_TraceMsg(trace_ctx, "\tpicture_width = %d\n", p->picture_width);
2475     va_TraceMsg(trace_ctx, "\tpicture_height = %d\n", p->picture_height);
2476     va_TraceMsg(trace_ctx, "\tpicture_type = 0x%08x\n", p->picture_type);
2477     va_TraceMsg(trace_ctx, NULL);
2478
2479     return;
2480 }
2481
2482 static void va_TraceVAEncPictureParameterBufferJPEG(
2483     VADisplay dpy,
2484     VAContextID context,
2485     VABufferID buffer,
2486     VABufferType type,
2487     unsigned int size,
2488     unsigned int num_elements,
2489     void *data)
2490 {
2491     VAEncPictureParameterBufferJPEG *p = (VAEncPictureParameterBufferJPEG *)data;
2492     int i;
2493
2494     DPY2TRACECTX(dpy);
2495
2496     va_TraceMsg(trace_ctx, "\t--VAEncPictureParameterBufferJPEG\n");
2497     va_TraceMsg(trace_ctx, "\treconstructed_picture = 0x%08x\n", p->reconstructed_picture);
2498     va_TraceMsg(trace_ctx, "\tcoded_buf = %08x\n", p->coded_buf);
2499     va_TraceMsg(trace_ctx, "\tpicture_width = %d\n", p->picture_width);
2500     va_TraceMsg(trace_ctx, "\tpicture_height = %d\n", p->picture_height);
2501     va_TraceMsg(trace_ctx, "\tpic_flags.bits.profile = %d\n", p->pic_flags.bits.profile);
2502     va_TraceMsg(trace_ctx, "\tpic_flags.bits.progressive = %d\n", p->pic_flags.bits.profile);
2503     va_TraceMsg(trace_ctx, "\tpic_flags.bits.huffman = %d\n", p->pic_flags.bits.huffman);
2504     va_TraceMsg(trace_ctx, "\tpic_flags.bits.interleaved = %d\n", p->pic_flags.bits.interleaved);
2505     va_TraceMsg(trace_ctx, "\tpic_flags.bits.differential = %d\n", p->pic_flags.bits.differential);
2506     va_TraceMsg(trace_ctx, "\tsample_bit_depth = %d\n", p->sample_bit_depth);
2507     va_TraceMsg(trace_ctx, "\tnum_scan = %d\n", p->num_scan);
2508     va_TraceMsg(trace_ctx, "\tnum_components = %d\n", p->num_components);
2509     for (i=0; i<p->num_components; i++)
2510         va_TraceMsg(trace_ctx, "\tcomponent_id[%d] = %d\n", i, p->component_id[i]);
2511
2512     if (p->quality > 0)
2513         va_TraceMsg(trace_ctx, "\tquality = %d\n", p->quality);
2514     else
2515         va_TraceMsg(trace_ctx, "\tquantiser_table_selector[] = %d %d %d %d\n",
2516                     p->quantiser_table_selector[0],
2517                     p->quantiser_table_selector[1],
2518                     p->quantiser_table_selector[2],
2519                     p->quantiser_table_selector[3]);
2520
2521     va_TraceMsg(trace_ctx, NULL);
2522
2523     return;
2524 }
2525
2526 static void va_TraceVAEncQMatrixBufferJPEG(
2527     VADisplay dpy,
2528     VAContextID context,
2529     VABufferID buffer,
2530     VABufferType type,
2531     unsigned int size,
2532     unsigned int num_elements,
2533     void *data)
2534 {
2535     VAQMatrixBufferJPEG *p = (VAQMatrixBufferJPEG *)data;
2536     DPY2TRACECTX(dpy);
2537
2538     va_TraceMsg(trace_ctx, "\t--VAQMatrixBufferJPEG\n");
2539     va_TraceMsg(trace_ctx, "\tload_lum_quantiser_matrix = %d", p->load_lum_quantiser_matrix);
2540     if (p->load_lum_quantiser_matrix) {
2541         int i;
2542         for (i = 0; i < 64; i++) {
2543             if ((i % 8) == 0)
2544                 va_TraceMsg(trace_ctx, "\n\t");
2545             va_TraceMsg(trace_ctx, "\t0x%02x", p->lum_quantiser_matrix[i]);
2546         }
2547         va_TraceMsg(trace_ctx, "\n");
2548     }
2549     va_TraceMsg(trace_ctx, "\tload_chroma_quantiser_matrix = %08x\n", p->load_chroma_quantiser_matrix);
2550     if (p->load_chroma_quantiser_matrix) {
2551         int i;
2552         for (i = 0; i < 64; i++) {
2553             if ((i % 8) == 0)
2554                 va_TraceMsg(trace_ctx, "\n\t");
2555             va_TraceMsg(trace_ctx, "\t0x%02x", p->chroma_quantiser_matrix[i]);
2556         }
2557         va_TraceMsg(trace_ctx, "\n");
2558     }
2559
2560     va_TraceMsg(trace_ctx, NULL);
2561
2562     return;
2563 }
2564
2565
2566 static void va_TraceVAEncSliceParameterBufferJPEG(
2567     VADisplay dpy,
2568     VAContextID context,
2569     VABufferID buffer,
2570     VABufferType type,
2571     unsigned int size,
2572     unsigned int num_elements,
2573     void *data)
2574 {
2575     VAEncSliceParameterBufferJPEG *p = (VAEncSliceParameterBufferJPEG *)data;
2576     int i;
2577
2578     DPY2TRACECTX(dpy);
2579
2580     va_TraceMsg(trace_ctx, "\t--VAEncSliceParameterBufferJPEG\n");
2581     va_TraceMsg(trace_ctx, "\trestart_interval = 0x%04x\n", p->restart_interval);
2582     va_TraceMsg(trace_ctx, "\tnum_components = 0x%08x\n", p->num_components);
2583     for (i=0; i<4; i++) {
2584         va_TraceMsg(trace_ctx, "\tcomponents[%i] =\n ");
2585         va_TraceMsg(trace_ctx, "\t\tcomponent_selector = %d\n", p->components[i].component_selector);
2586         va_TraceMsg(trace_ctx, "\t\tdc_table_selector = %d\n", p->components[i].dc_table_selector);
2587         va_TraceMsg(trace_ctx, "\t\tac_table_selector = %d\n", p->components[i].ac_table_selector);
2588     }
2589
2590     va_TraceMsg(trace_ctx, NULL);
2591
2592     return;
2593 }
2594
2595
2596 static void va_TraceH263Buf(
2597     VADisplay dpy,
2598     VAContextID context,
2599     VABufferID buffer,
2600     VABufferType type,
2601     unsigned int size,
2602     unsigned int num_elements,
2603     void *pbuf
2604 )
2605 {
2606     switch (type) {
2607     case VAPictureParameterBufferType:/* print MPEG4 buffer */
2608         va_TraceVAPictureParameterBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
2609         break;
2610     case VAIQMatrixBufferType:/* print MPEG4 buffer */
2611         va_TraceVAIQMatrixBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
2612         break;
2613     case VABitPlaneBufferType:/* print MPEG4 buffer */
2614         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2615         break;
2616     case VASliceGroupMapBufferType:
2617         break;
2618     case VASliceParameterBufferType:/* print MPEG4 buffer */
2619         va_TraceVASliceParameterBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
2620         break;
2621     case VASliceDataBufferType:
2622         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2623         break;
2624     case VAMacroblockParameterBufferType:
2625         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2626         break;
2627     case VAResidualDataBufferType:
2628         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2629         break;
2630     case VADeblockingParameterBufferType:
2631         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2632         break;
2633     case VAImageBufferType:
2634         break;
2635     case VAProtectedSliceDataBufferType:
2636         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2637         break;
2638     case VAEncCodedBufferType:
2639         break;
2640     case VAEncSequenceParameterBufferType:
2641         va_TraceVAEncSequenceParameterBufferH263(dpy, context, buffer, type, size, num_elements, pbuf);
2642         break;
2643     case VAEncPictureParameterBufferType:
2644         va_TraceVAEncPictureParameterBufferH263(dpy, context, buffer, type, size, num_elements, pbuf);
2645         break;
2646     case VAEncSliceParameterBufferType:
2647         va_TraceVAEncSliceParameterBuffer(dpy, context, buffer, type, size, num_elements, pbuf);
2648         break;
2649     case VAEncPackedHeaderParameterBufferType:
2650         va_TraceVAEncPackedHeaderParameterBufferType(dpy, context, buffer, type, size, num_elements, pbuf);
2651         break;
2652     default:
2653         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2654         break;
2655     }
2656 }
2657
2658
2659 static void va_TraceJPEGBuf(
2660     VADisplay dpy,
2661     VAContextID context,
2662     VABufferID buffer,
2663     VABufferType type,
2664     unsigned int size,
2665     unsigned int num_elements,
2666     void *pbuf
2667 )
2668 {
2669     switch (type) {
2670     case VABitPlaneBufferType:
2671     case VASliceGroupMapBufferType:
2672     case VASliceDataBufferType:
2673     case VAMacroblockParameterBufferType:
2674     case VAResidualDataBufferType:
2675     case VADeblockingParameterBufferType:
2676     case VAImageBufferType:
2677     case VAProtectedSliceDataBufferType:
2678     case VAEncCodedBufferType:
2679     case VAEncSequenceParameterBufferType:
2680         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2681         break;
2682     case VAEncSliceParameterBufferType:
2683         va_TraceVAEncSliceParameterBufferJPEG(dpy, context, buffer, type, size, num_elements, pbuf);
2684         break;
2685     case VAPictureParameterBufferType:
2686         va_TraceVAPictureParameterBufferJPEG(dpy, context, buffer, type, size, num_elements, pbuf);
2687         break;
2688     case VAIQMatrixBufferType:
2689         va_TraceVAIQMatrixBufferJPEG(dpy, context, buffer, type, size, num_elements, pbuf);
2690         break;
2691     case VASliceParameterBufferType:
2692         va_TraceVASliceParameterBufferJPEG(dpy, context, buffer, type, size, num_elements, pbuf);
2693         break;
2694     case VAHuffmanTableBufferType:
2695         va_TraceVAHuffmanTableBufferJPEG(dpy, context, buffer, type, size, num_elements, pbuf);
2696         break;
2697     case VAEncPictureParameterBufferType:
2698         va_TraceVAEncPictureParameterBufferJPEG(dpy, context, buffer, type, size, num_elements, pbuf);
2699         break;
2700     case VAQMatrixBufferType:
2701         va_TraceVAEncQMatrixBufferJPEG(dpy, context, buffer, type, size, num_elements, pbuf);
2702         break;
2703     default:
2704         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2705         break;
2706     }
2707 }
2708
2709 static void va_TraceMPEG4Buf(
2710     VADisplay dpy,
2711     VAContextID context,
2712     VABufferID buffer,
2713     VABufferType type,
2714     unsigned int size,
2715     unsigned int num_elements,
2716     void *pbuf
2717 )
2718 {
2719     switch (type) {
2720     case VAPictureParameterBufferType:
2721         va_TraceVAPictureParameterBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
2722         break;
2723     case VAIQMatrixBufferType:
2724         va_TraceVAIQMatrixBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
2725         break;
2726     case VABitPlaneBufferType:
2727         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2728         break;
2729     case VASliceGroupMapBufferType:
2730         break;
2731     case VASliceParameterBufferType:
2732         va_TraceVASliceParameterBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
2733         break;
2734     case VASliceDataBufferType:
2735         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2736         break;
2737     case VAMacroblockParameterBufferType:
2738         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2739         break;
2740     case VAResidualDataBufferType:
2741         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2742         break;
2743     case VADeblockingParameterBufferType:
2744         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2745         break;
2746     case VAImageBufferType:
2747         break;
2748     case VAProtectedSliceDataBufferType:
2749         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2750         break;
2751     case VAEncCodedBufferType:
2752         break;
2753     case VAEncSequenceParameterBufferType:
2754         va_TraceVAEncSequenceParameterBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
2755         break;
2756     case VAEncPictureParameterBufferType:
2757         va_TraceVAEncPictureParameterBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
2758         break;
2759     case VAEncSliceParameterBufferType:
2760         va_TraceVAEncSliceParameterBuffer(dpy, context, buffer, type, size, num_elements, pbuf);
2761         break;
2762     default:
2763         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2764         break;
2765     }
2766 }
2767
2768 static void va_TraceHEVCBuf(
2769     VADisplay dpy,
2770     VAContextID context,
2771     VABufferID buffer,
2772     VABufferType type,
2773     unsigned int size,
2774     unsigned int num_elements,
2775     void *pbuf
2776 )
2777 {
2778     DPY2TRACECTX(dpy);
2779
2780     switch (type) {
2781         case VAPictureParameterBufferType:
2782             va_TraceVAPictureParameterBufferHEVC(dpy, context, buffer, type, size, num_elements, pbuf);
2783             break;
2784         case VASliceParameterBufferType:
2785             va_TraceVASliceParameterBufferHEVC(dpy, context, buffer, type, size, num_elements, pbuf);
2786             break;
2787         case VAIQMatrixBufferType:
2788             va_TraceVAIQMatrixBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
2789             break;
2790         default:
2791             va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2792             break;
2793     }
2794 }
2795
2796 static void va_TraceH264Buf(
2797     VADisplay dpy,
2798     VAContextID context,
2799     VABufferID buffer,
2800     VABufferType type,
2801     unsigned int size,
2802     unsigned int num_elements,
2803     void *pbuf
2804 )
2805 {
2806     DPY2TRACECTX(dpy);
2807
2808     switch (type) {
2809     case VAPictureParameterBufferType:
2810         va_TraceVAPictureParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
2811         break;
2812     case VAIQMatrixBufferType:
2813         va_TraceVAIQMatrixBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
2814         break;
2815     case VABitPlaneBufferType:
2816         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2817         break;
2818     case VASliceGroupMapBufferType:
2819         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2820         break;
2821     case VASliceParameterBufferType:
2822         va_TraceVASliceParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
2823         break;
2824     case VASliceDataBufferType:
2825         va_TraceVABuffers(dpy, context, buffer, type, trace_ctx->trace_slice_size, num_elements, pbuf);
2826         break;
2827     case VAMacroblockParameterBufferType:
2828         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2829         break;
2830     case VAResidualDataBufferType:
2831         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2832         break;
2833     case VADeblockingParameterBufferType:
2834         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2835         break;
2836     case VAImageBufferType:
2837         break;
2838     case VAProtectedSliceDataBufferType:
2839         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2840         break;
2841     case VAEncCodedBufferType:
2842         break;
2843     case VAEncSequenceParameterBufferType:
2844         va_TraceVAEncSequenceParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
2845         break;
2846     case VAEncPictureParameterBufferType:
2847         va_TraceVAEncPictureParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
2848         break;
2849     case VAEncSliceParameterBufferType:
2850         if (size == sizeof(VAEncSliceParameterBuffer))
2851             va_TraceVAEncSliceParameterBuffer(dpy, context, buffer, type, size, num_elements, pbuf);
2852         else
2853             va_TraceVAEncSliceParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
2854         break;
2855     case VAEncPackedHeaderParameterBufferType:
2856         va_TraceVAEncPackedHeaderParameterBufferType(dpy, context, buffer, type, size, num_elements, pbuf);
2857         break;
2858
2859     case VAEncMiscParameterBufferType:
2860         va_TraceVAEncMiscParameterBuffer(dpy, context, buffer, type, size, num_elements, pbuf);
2861         break;
2862     default:
2863         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2864         break;
2865     }
2866 }
2867
2868 static void va_TraceVP8Buf(
2869     VADisplay dpy,
2870     VAContextID context,
2871     VABufferID buffer,
2872     VABufferType type,
2873     unsigned int size,
2874     unsigned int num_elements,
2875     void *pbuf
2876 )
2877 {
2878     DPY2TRACECTX(dpy);
2879
2880     switch (type) {
2881     case VAPictureParameterBufferType:
2882         va_TraceVAPictureParameterBufferVP8(dpy, context, buffer, type, size, num_elements, pbuf);
2883         break;
2884     case VAIQMatrixBufferType:
2885         va_TraceVAIQMatrixBufferVP8(dpy, context, buffer, type, size, num_elements, pbuf);
2886         break;
2887     case VABitPlaneBufferType:
2888         break;
2889     case VASliceGroupMapBufferType:
2890         break;
2891     case VASliceParameterBufferType:
2892         va_TraceVASliceParameterBufferVP8(dpy, context, buffer, type, size, num_elements, pbuf);
2893         break;
2894     case VASliceDataBufferType:
2895         break;
2896     case VAProbabilityBufferType:
2897         va_TraceVAProbabilityBufferVP8(dpy, context, buffer, type, size, num_elements, pbuf);
2898         break;
2899     case VAMacroblockParameterBufferType:
2900         break;
2901     case VAResidualDataBufferType:
2902         break;
2903     case VADeblockingParameterBufferType:
2904         break;
2905     case VAImageBufferType:
2906         break;
2907     case VAProtectedSliceDataBufferType:
2908         break;
2909     case VAEncCodedBufferType:
2910         break;
2911     case VAEncSequenceParameterBufferType:
2912         break;
2913     case VAEncPictureParameterBufferType:
2914         break;
2915     case VAEncSliceParameterBufferType:
2916         break;
2917     case VAEncPackedHeaderParameterBufferType:
2918         break;
2919     case VAEncMiscParameterBufferType:
2920         break;
2921     default:
2922         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2923         break;
2924     }
2925 }
2926
2927 static void va_TraceVC1Buf(
2928     VADisplay dpy,
2929     VAContextID context,
2930     VABufferID buffer,
2931     VABufferType type,
2932     unsigned int size,
2933     unsigned int num_elements,
2934     void *pbuf
2935 )
2936 {
2937     DPY2TRACECTX(dpy);
2938
2939     switch (type) {
2940     case VAPictureParameterBufferType:
2941         va_TraceVAPictureParameterBufferVC1(dpy, context, buffer, type, size, num_elements, pbuf);
2942         break;
2943     case VAIQMatrixBufferType:
2944         break;
2945     case VABitPlaneBufferType:
2946         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2947         break;
2948     case VASliceGroupMapBufferType:
2949         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2950         break;
2951     case VASliceParameterBufferType:
2952         va_TraceVASliceParameterBufferVC1(dpy, context, buffer, type, size, num_elements, pbuf);
2953         break;
2954     case VASliceDataBufferType:
2955         va_TraceVABuffers(dpy, context, buffer, type, trace_ctx->trace_slice_size, num_elements, pbuf);
2956         break;
2957     case VAMacroblockParameterBufferType:
2958         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2959         break;
2960     case VAResidualDataBufferType:
2961         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2962         break;
2963     case VADeblockingParameterBufferType:
2964         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2965         break;
2966     case VAImageBufferType:
2967         break;
2968     case VAProtectedSliceDataBufferType:
2969         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2970         break;
2971     case VAEncCodedBufferType:
2972         break;
2973     case VAEncSequenceParameterBufferType:
2974         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2975         break;
2976     case VAEncPictureParameterBufferType:
2977         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2978         break;
2979     case VAEncSliceParameterBufferType:
2980         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2981         break;
2982     default:
2983         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2984         break;
2985     }
2986 }
2987
2988 static void
2989 va_TraceProcFilterParameterBufferDeinterlacing(
2990     VADisplay dpy,
2991     VAContextID context,
2992     VAProcFilterParameterBufferBase *base
2993 )
2994 {
2995     VAProcFilterParameterBufferDeinterlacing *deint = (VAProcFilterParameterBufferDeinterlacing *)base;
2996
2997     DPY2TRACECTX(dpy);
2998
2999     va_TraceMsg(trace_ctx, "\t    type = %d\n", deint->type);
3000     va_TraceMsg(trace_ctx, "\t    algorithm = %d\n", deint->algorithm);
3001     va_TraceMsg(trace_ctx, "\t    flags = %d\n", deint->flags);
3002 }
3003
3004 static void
3005 va_TraceProcFilterParameterBufferColorBalance(
3006     VADisplay dpy,
3007     VAContextID context,
3008     VAProcFilterParameterBufferBase *base
3009 )
3010 {
3011     VAProcFilterParameterBufferColorBalance *color_balance = (VAProcFilterParameterBufferColorBalance *)base;
3012
3013     DPY2TRACECTX(dpy);
3014
3015     va_TraceMsg(trace_ctx, "\t    type = %d\n", color_balance->type);
3016     va_TraceMsg(trace_ctx, "\t    attrib = %d\n", color_balance->attrib);
3017     va_TraceMsg(trace_ctx, "\t    value = %f\n", color_balance->value);
3018 }
3019
3020 static void
3021 va_TraceProcFilterParameterBufferBase(
3022     VADisplay dpy,
3023     VAContextID context,
3024     VAProcFilterParameterBufferBase *base
3025 )
3026 {
3027     DPY2TRACECTX(dpy);
3028
3029     va_TraceMsg(trace_ctx, "\t    type = %d\n", base->type);
3030 }
3031
3032 static void
3033 va_TraceProcFilterParameterBuffer(
3034     VADisplay dpy,
3035     VAContextID context,
3036     VABufferID *filters,
3037     unsigned int num_filters
3038 )
3039 {
3040     VABufferType type;
3041     unsigned int size;
3042     unsigned int num_elements;
3043     VAProcFilterParameterBufferBase *base_filter = NULL;
3044     int i;
3045
3046     DPY2TRACECTX(dpy);
3047
3048     if (num_filters == 0 || filters == NULL) {
3049         va_TraceMsg(trace_ctx, "\t  num_filters = %d\n", num_filters);
3050         va_TraceMsg(trace_ctx, "\t  filters = %p\n", filters);
3051         return;
3052     }
3053
3054     va_TraceMsg(trace_ctx, "\t  num_filters = %d\n", num_filters);
3055
3056     /* get buffer type information */
3057     for (i = 0; i < num_filters; i++) {
3058         vaBufferInfo(dpy, context, filters[i], &type, &size, &num_elements);
3059
3060         if (type != VAProcFilterParameterBufferType) {
3061             va_TraceMsg(trace_ctx, "\t  filters[%d] = 0x%08x (INVALID)\n", i, filters[i]);
3062             return;
3063         } else {
3064             va_TraceMsg(trace_ctx, "\t  filters[%d] = 0x%08x\n", i, filters[i]);
3065         }
3066
3067         base_filter = NULL;
3068         vaMapBuffer(dpy, filters[i], (void **)&base_filter);
3069
3070         if (base_filter == NULL) {
3071             vaUnmapBuffer(dpy, filters[i]);
3072             return;
3073         }
3074
3075         switch (base_filter->type) {
3076         case VAProcFilterDeinterlacing:
3077             va_TraceProcFilterParameterBufferDeinterlacing(dpy,
3078                                                            context,
3079                                                            base_filter);
3080             break;
3081         case VAProcFilterColorBalance:
3082             va_TraceProcFilterParameterBufferColorBalance(dpy,
3083                                                           context,
3084                                                           base_filter);
3085             break;
3086         default:
3087             va_TraceProcFilterParameterBufferBase(dpy,
3088                                                   context,
3089                                                   base_filter);
3090             break;
3091         }
3092
3093         vaUnmapBuffer(dpy, filters[i]);
3094     }
3095 }
3096
3097 static void
3098 va_TraceVAProcPipelineParameterBuffer(
3099     VADisplay dpy,
3100     VAContextID context,
3101     VABufferID buffer,
3102     VABufferType type,
3103     unsigned int size,
3104     unsigned int num_elements,
3105     void *data
3106 )
3107 {
3108     VAProcPipelineParameterBuffer *p = (VAProcPipelineParameterBuffer *)data;
3109     int i;
3110
3111     DPY2TRACECTX(dpy);
3112
3113     va_TraceMsg(trace_ctx, "\t--VAProcPipelineParameterBuffer\n");
3114
3115     va_TraceMsg(trace_ctx, "\t  surface = 0x%08x\n", p->surface);
3116
3117     if (p->surface_region) {
3118         va_TraceMsg(trace_ctx, "\t  surface_region\n");
3119         va_TraceMsg(trace_ctx, "\t    x = %d\n", p->surface_region->x);
3120         va_TraceMsg(trace_ctx, "\t    y = %d\n", p->surface_region->y);
3121         va_TraceMsg(trace_ctx, "\t    width = %d\n", p->surface_region->width);
3122         va_TraceMsg(trace_ctx, "\t    height = %d\n", p->surface_region->height);
3123     } else {
3124         va_TraceMsg(trace_ctx, "\t  surface_region = (NULL)\n");
3125     }
3126
3127     va_TraceMsg(trace_ctx, "\t  surface_color_standard = %d\n", p->surface_color_standard);
3128
3129     if (p->output_region) {
3130         va_TraceMsg(trace_ctx, "\t  output_region\n");
3131         va_TraceMsg(trace_ctx, "\t    x = %d\n", p->output_region->x);
3132         va_TraceMsg(trace_ctx, "\t    y = %d\n", p->output_region->y);
3133         va_TraceMsg(trace_ctx, "\t    width = %d\n", p->output_region->width);
3134         va_TraceMsg(trace_ctx, "\t    height = %d\n", p->output_region->height);
3135     } else {
3136         va_TraceMsg(trace_ctx, "\t  output_region = (NULL)\n");
3137     }
3138
3139     va_TraceMsg(trace_ctx, "\t  output_background_color = 0x%08x\n", p->output_background_color);
3140     va_TraceMsg(trace_ctx, "\t  output_color_standard = %d\n", p->output_color_standard);
3141     va_TraceMsg(trace_ctx, "\t  pipeline_flags = 0x%08x\n", p->pipeline_flags);
3142     va_TraceMsg(trace_ctx, "\t  filter_flags = 0x%08x\n", p->filter_flags);
3143
3144     va_TraceProcFilterParameterBuffer(dpy, context, p->filters, p->num_filters);
3145
3146     va_TraceMsg(trace_ctx, "\t  num_forward_references = 0x%08x\n", p->num_forward_references);
3147
3148     if (p->num_forward_references) {
3149         va_TraceMsg(trace_ctx, "\t  forward_references\n");
3150
3151         if (p->forward_references) {
3152             /* only dump the first 5 forward references */
3153             for (i = 0; i < p->num_forward_references && i < 5; i++) {
3154                 va_TraceMsg(trace_ctx, "\t    forward_references[%d] = 0x%08x\n", i, p->forward_references[i]);
3155             }
3156         } else {
3157             for (i = 0; i < p->num_forward_references && i < 5; i++) {
3158                 va_TraceMsg(trace_ctx, "\t    forward_references[%d] = (NULL)\n", i);
3159             }
3160         }
3161     }
3162
3163     va_TraceMsg(trace_ctx, "\t  num_backward_references = 0x%08x\n", p->num_backward_references);
3164
3165     if (p->num_backward_references) {
3166         va_TraceMsg(trace_ctx, "\t  backward_references\n");
3167
3168         if (p->backward_references) {
3169             /* only dump the first 5 backward references */
3170             for (i = 0; i < p->num_backward_references && i < 5; i++) {
3171                 va_TraceMsg(trace_ctx, "\t    backward_references[%d] = 0x%08x\n", i, p->backward_references[i]);
3172             }
3173         } else {
3174             for (i = 0; i < p->num_backward_references && i < 5; i++) {
3175                 va_TraceMsg(trace_ctx, "\t    backward_references[%d] = (NULL)\n", i);
3176             }
3177         }
3178     }
3179
3180     /* FIXME: add other info later */
3181
3182     va_TraceMsg(trace_ctx, NULL);
3183 }
3184
3185 static void
3186 va_TraceNoneBuf(
3187     VADisplay dpy,
3188     VAContextID context,
3189     VABufferID buffer,
3190     VABufferType type,
3191     unsigned int size,
3192     unsigned int num_elements,
3193     void *pbuf
3194 )
3195 {
3196     DPY2TRACECTX(dpy);
3197
3198     switch (type) {
3199     case VAProcPipelineParameterBufferType:
3200         va_TraceVAProcPipelineParameterBuffer(dpy, context, buffer, type, size, num_elements, pbuf);
3201         break;
3202     default:
3203         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
3204         break;
3205     }
3206 }
3207
3208 void va_TraceRenderPicture(
3209     VADisplay dpy,
3210     VAContextID context,
3211     VABufferID *buffers,
3212     int num_buffers
3213 )
3214 {
3215     VABufferType type;
3216     unsigned int size;
3217     unsigned int num_elements;
3218     int i;
3219     DPY2TRACECTX(dpy);
3220
3221     TRACE_FUNCNAME(idx);
3222
3223     va_TraceMsg(trace_ctx, "\tcontext = 0x%08x\n", context);
3224     va_TraceMsg(trace_ctx, "\tnum_buffers = %d\n", num_buffers);
3225     if (buffers == NULL)
3226         return;
3227
3228     for (i = 0; i < num_buffers; i++) {
3229         unsigned char *pbuf = NULL;
3230         unsigned int j;
3231
3232         /* get buffer type information */
3233         vaBufferInfo(dpy, context, buffers[i], &type, &size, &num_elements);
3234
3235         va_TraceMsg(trace_ctx, "\t---------------------------\n");
3236         va_TraceMsg(trace_ctx, "\tbuffers[%d] = 0x%08x\n", i, buffers[i]);
3237         va_TraceMsg(trace_ctx, "\t  type = %s\n", buffer_type_to_string(type));
3238         va_TraceMsg(trace_ctx, "\t  size = %d\n", size);
3239         va_TraceMsg(trace_ctx, "\t  num_elements = %d\n", num_elements);
3240
3241         vaMapBuffer(dpy, buffers[i], (void **)&pbuf);
3242         if (pbuf == NULL)
3243             continue;
3244
3245         switch (trace_ctx->trace_profile) {
3246         case VAProfileMPEG2Simple:
3247         case VAProfileMPEG2Main:
3248             for (j=0; j<num_elements; j++) {
3249                 va_TraceMsg(trace_ctx, "\telement[%d] =\n", j);
3250                 va_TraceMPEG2Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
3251             }
3252             break;
3253         case VAProfileMPEG4Simple:
3254         case VAProfileMPEG4AdvancedSimple:
3255         case VAProfileMPEG4Main:
3256             for (j=0; j<num_elements; j++) {
3257                 va_TraceMsg(trace_ctx, "\telement[%d] =\n", j);
3258                 va_TraceMPEG4Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
3259             }
3260             break;
3261         case VAProfileH264Baseline:
3262         case VAProfileH264Main:
3263         case VAProfileH264High:
3264         case VAProfileH264ConstrainedBaseline:
3265             for (j=0; j<num_elements; j++) {
3266                 va_TraceMsg(trace_ctx, "\telement[%d] =\n", j);
3267
3268                 va_TraceH264Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
3269             }
3270             break;
3271         case VAProfileVC1Simple:
3272         case VAProfileVC1Main:
3273         case VAProfileVC1Advanced:
3274             for (j=0; j<num_elements; j++) {
3275                 va_TraceMsg(trace_ctx, "\telement[%d] =\n", j);
3276
3277                 va_TraceVC1Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
3278             }
3279             break;
3280         case VAProfileH263Baseline:
3281             for (j=0; j<num_elements; j++) {
3282                 va_TraceMsg(trace_ctx, "\telement[%d] =\n", j);
3283
3284                 va_TraceH263Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
3285             }
3286             break;
3287         case VAProfileJPEGBaseline:
3288             for (j=0; j<num_elements; j++) {
3289                 va_TraceMsg(trace_ctx, "\telement[%d] =\n", j);
3290
3291                 va_TraceJPEGBuf (dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
3292             }
3293             break;
3294
3295         case VAProfileNone:
3296             for (j=0; j<num_elements; j++) {
3297                 va_TraceMsg(trace_ctx, "\telement[%d] =\n", j);
3298
3299                 va_TraceNoneBuf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
3300             }
3301             break;
3302
3303         case VAProfileVP8Version0_3:
3304             for (j=0; j<num_elements; j++) {
3305                 va_TraceMsg(trace_ctx, "\telement[%d] =\n", j);
3306
3307                 va_TraceVP8Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
3308             }
3309             break;
3310
3311         case VAProfileHEVCMain:
3312         case VAProfileHEVCMain10:
3313             for (j=0; j<num_elements; j++) {
3314                 va_TraceMsg(trace_ctx, "\telement[%d] = ", j);
3315
3316                 va_TraceHEVCBuf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
3317             }
3318             break;
3319         default:
3320             break;
3321         }
3322
3323         vaUnmapBuffer(dpy, buffers[i]);
3324     }
3325
3326     va_TraceMsg(trace_ctx, NULL);
3327 }
3328
3329 void va_TraceEndPicture(
3330     VADisplay dpy,
3331     VAContextID context,
3332     int endpic_done
3333 )
3334 {
3335     int encode, decode, jpeg;
3336     DPY2TRACECTX(dpy);
3337
3338     TRACE_FUNCNAME(idx);
3339
3340     va_TraceMsg(trace_ctx, "\tcontext = 0x%08x\n", context);
3341     va_TraceMsg(trace_ctx, "\trender_targets = 0x%08x\n", trace_ctx->trace_rendertarget);
3342
3343     /* avoid to create so many empty files */
3344     encode = (trace_ctx->trace_entrypoint == VAEntrypointEncSlice);
3345     decode = (trace_ctx->trace_entrypoint == VAEntrypointVLD);
3346     jpeg = (trace_ctx->trace_entrypoint == VAEntrypointEncPicture);
3347
3348     /* trace encode source surface, can do it before HW completes rendering */
3349     if ((encode && (trace_flag & VA_TRACE_FLAG_SURFACE_ENCODE))||
3350         (jpeg && (trace_flag & VA_TRACE_FLAG_SURFACE_JPEG)))
3351         va_TraceSurface(dpy);
3352
3353     /* trace decoded surface, do it after HW completes rendering */
3354     if (decode && ((trace_flag & VA_TRACE_FLAG_SURFACE_DECODE))) {
3355         vaSyncSurface(dpy, trace_ctx->trace_rendertarget);
3356         va_TraceSurface(dpy);
3357     }
3358
3359     va_TraceMsg(trace_ctx, NULL);
3360 }
3361
3362
3363 void va_TraceSyncSurface(
3364     VADisplay dpy,
3365     VASurfaceID render_target
3366 )
3367 {
3368     DPY2TRACECTX(dpy);
3369
3370     TRACE_FUNCNAME(idx);
3371
3372     va_TraceMsg(trace_ctx, "\trender_target = 0x%08x\n", render_target);
3373     va_TraceMsg(trace_ctx, NULL);
3374 }
3375
3376 void va_TraceQuerySurfaceAttributes(
3377     VADisplay           dpy,
3378     VAConfigID          config,
3379     VASurfaceAttrib    *attrib_list,
3380     unsigned int       *num_attribs
3381 )
3382 {
3383     DPY2TRACECTX(dpy);
3384
3385     TRACE_FUNCNAME(idx);
3386     va_TraceMsg(trace_ctx, "\tconfig = 0x%08x\n", config);
3387     va_TraceSurfaceAttributes(trace_ctx, attrib_list, num_attribs);
3388
3389     va_TraceMsg(trace_ctx, NULL);
3390
3391 }
3392
3393
3394 void va_TraceQuerySurfaceStatus(
3395     VADisplay dpy,
3396     VASurfaceID render_target,
3397     VASurfaceStatus *status    /* out */
3398 )
3399 {
3400     DPY2TRACECTX(dpy);
3401
3402     TRACE_FUNCNAME(idx);
3403
3404     va_TraceMsg(trace_ctx, "\trender_target = 0x%08x\n", render_target);
3405     if (status)
3406         va_TraceMsg(trace_ctx, "\tstatus = 0x%08x\n", *status);
3407     va_TraceMsg(trace_ctx, NULL);
3408 }
3409
3410
3411 void va_TraceQuerySurfaceError(
3412     VADisplay dpy,
3413     VASurfaceID surface,
3414     VAStatus error_status,
3415     void **error_info       /*out*/
3416 )
3417 {
3418     DPY2TRACECTX(dpy);
3419
3420     TRACE_FUNCNAME(idx);
3421     va_TraceMsg(trace_ctx, "\tsurface = 0x%08x\n", surface);
3422     va_TraceMsg(trace_ctx, "\terror_status = 0x%08x\n", error_status);
3423     if (error_info && (error_status == VA_STATUS_ERROR_DECODING_ERROR)) {
3424         VASurfaceDecodeMBErrors *p = *error_info;
3425         while (p && (p->status != -1)) {
3426             va_TraceMsg(trace_ctx, "\t\tstatus = %d\n", p->status);
3427             va_TraceMsg(trace_ctx, "\t\tstart_mb = %d\n", p->start_mb);
3428             va_TraceMsg(trace_ctx, "\t\tend_mb = %d\n", p->end_mb);
3429             p++; /* next error record */
3430         }
3431     }
3432     va_TraceMsg(trace_ctx, NULL);
3433 }
3434
3435 void va_TraceMaxNumDisplayAttributes (
3436     VADisplay dpy,
3437     int number
3438 )
3439 {
3440     DPY2TRACECTX(dpy);
3441
3442     TRACE_FUNCNAME(idx);
3443
3444     va_TraceMsg(trace_ctx, "\tmax_display_attributes = %d\n", number);
3445     va_TraceMsg(trace_ctx, NULL);
3446 }
3447
3448 void va_TraceQueryDisplayAttributes (
3449     VADisplay dpy,
3450     VADisplayAttribute *attr_list,    /* out */
3451     int *num_attributes               /* out */
3452 )
3453 {
3454     int i;
3455
3456     DPY2TRACECTX(dpy);
3457
3458     if (attr_list == NULL || num_attributes == NULL)
3459         return;
3460
3461     va_TraceMsg(trace_ctx, "\tnum_attributes = %d\n", *num_attributes);
3462
3463     for (i=0; i<*num_attributes; i++) {
3464         va_TraceMsg(trace_ctx, "\tattr_list[%d] =\n");
3465         va_TraceMsg(trace_ctx, "\t  typ = 0x%08x\n", attr_list[i].type);
3466         va_TraceMsg(trace_ctx, "\t  min_value = %d\n", attr_list[i].min_value);
3467         va_TraceMsg(trace_ctx, "\t  max_value = %d\n", attr_list[i].max_value);
3468         va_TraceMsg(trace_ctx, "\t  value = %d\n", attr_list[i].value);
3469         va_TraceMsg(trace_ctx, "\t  flags = %d\n", attr_list[i].flags);
3470     }
3471     va_TraceMsg(trace_ctx, NULL);
3472 }
3473
3474
3475 static void va_TraceDisplayAttributes (
3476     VADisplay dpy,
3477     VADisplayAttribute *attr_list,
3478     int num_attributes
3479 )
3480 {
3481     int i;
3482
3483     DPY2TRACECTX(dpy);
3484
3485     va_TraceMsg(trace_ctx, "\tnum_attributes = %d\n", num_attributes);
3486     if (attr_list == NULL)
3487         return;
3488
3489     for (i=0; i<num_attributes; i++) {
3490         va_TraceMsg(trace_ctx, "\tattr_list[%d] =\n");
3491         va_TraceMsg(trace_ctx, "\t  typ = 0x%08x\n", attr_list[i].type);
3492         va_TraceMsg(trace_ctx, "\t  min_value = %d\n", attr_list[i].min_value);
3493         va_TraceMsg(trace_ctx, "\t  max_value = %d\n", attr_list[i].max_value);
3494         va_TraceMsg(trace_ctx, "\t  value = %d\n", attr_list[i].value);
3495         va_TraceMsg(trace_ctx, "\t  flags = %d\n", attr_list[i].flags);
3496     }
3497     va_TraceMsg(trace_ctx, NULL);
3498 }
3499
3500
3501 void va_TraceGetDisplayAttributes (
3502     VADisplay dpy,
3503     VADisplayAttribute *attr_list,
3504     int num_attributes
3505 )
3506 {
3507     DPY2TRACECTX(dpy);
3508
3509     TRACE_FUNCNAME(idx);
3510
3511     va_TraceDisplayAttributes (dpy, attr_list, num_attributes);
3512 }
3513
3514 void va_TraceSetDisplayAttributes (
3515     VADisplay dpy,
3516     VADisplayAttribute *attr_list,
3517     int num_attributes
3518 )
3519 {
3520     DPY2TRACECTX(dpy);
3521
3522     TRACE_FUNCNAME(idx);
3523
3524     va_TraceDisplayAttributes (dpy, attr_list, num_attributes);
3525 }
3526
3527
3528 void va_TracePutSurface (
3529     VADisplay dpy,
3530     VASurfaceID surface,
3531     void *draw, /* the target Drawable */
3532     short srcx,
3533     short srcy,
3534     unsigned short srcw,
3535     unsigned short srch,
3536     short destx,
3537     short desty,
3538     unsigned short destw,
3539     unsigned short desth,
3540     VARectangle *cliprects, /* client supplied clip list */
3541     unsigned int number_cliprects, /* number of clip rects in the clip list */
3542     unsigned int flags /* de-interlacing flags */
3543 )
3544 {
3545     DPY2TRACECTX(dpy);
3546
3547     TRACE_FUNCNAME(idx);
3548
3549     va_TraceMsg(trace_ctx, "\tsurface = 0x%08x\n", surface);
3550     va_TraceMsg(trace_ctx, "\tdraw = 0x%08x\n", draw);
3551     va_TraceMsg(trace_ctx, "\tsrcx = %d\n", srcx);
3552     va_TraceMsg(trace_ctx, "\tsrcy = %d\n", srcy);
3553     va_TraceMsg(trace_ctx, "\tsrcw = %d\n", srcw);
3554     va_TraceMsg(trace_ctx, "\tsrch = %d\n", srch);
3555     va_TraceMsg(trace_ctx, "\tdestx = %d\n", destx);
3556     va_TraceMsg(trace_ctx, "\tdesty = %d\n", desty);
3557     va_TraceMsg(trace_ctx, "\tdestw = %d\n", destw);
3558     va_TraceMsg(trace_ctx, "\tdesth = %d\n", desth);
3559     va_TraceMsg(trace_ctx, "\tcliprects = 0x%08x\n", cliprects);
3560     va_TraceMsg(trace_ctx, "\tnumber_cliprects = %d\n", number_cliprects);
3561     va_TraceMsg(trace_ctx, "\tflags = 0x%08x\n", flags);
3562     va_TraceMsg(trace_ctx, NULL);
3563 }