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