va/va_trace.c

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