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