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_TraceCreateBuffer (
 623     VADisplay dpy,
 624     VAContextID context,        /* in */
 625     VABufferType type,          /* in */
 626     unsigned int size,          /* in */
 627     unsigned int num_elements,  /* in */
 628     void *data,                 /* in */
 629     VABufferID *buf_id          /* out */
 630 )
 631 {
 632     DPY2INDEX(dpy);
 633
 634     /* only trace CodedBuffer */
 635     if (type != VAEncCodedBufferType)
 636         return;
 637
 638     TRACE_FUNCNAME(idx);
 639     va_TraceMsg(idx, "\tbuf_type=%s\n", buffer_type_to_string(type));
 640     va_TraceMsg(idx, "\tbuf_id=0x%x\n", *buf_id);
 641     va_TraceMsg(idx, "\tsize=%d\n", size);
 642     va_TraceMsg(idx, "\tnum_elements=%d\n", num_elements);
 643
 644     va_TraceMsg(idx, NULL);
 645 }
 646
 647 void va_TraceDestroyBuffer (
 648     VADisplay dpy,
 649     VABufferID buf_id    /* in */
 650 )
 651 {
 652     VABufferType type;
 653     unsigned int size;
 654     unsigned int num_elements;
 655
 656     VACodedBufferSegment *buf_list;
 657     int i = 0;
 658
 659     DPY2INDEX(dpy);
 660
 661     vaBufferInfo(dpy, trace_context[idx].trace_context, buf_id, &type, &size, &num_elements);
 662
 663     /* only trace CodedBuffer */
 664     if (type != VAEncCodedBufferType)
 665         return;
 666
 667     TRACE_FUNCNAME(idx);
 668     va_TraceMsg(idx, "\tbuf_type=%s\n", buffer_type_to_string(type));
 669     va_TraceMsg(idx, "\tbuf_id=0x%x\n", buf_id);
 670     va_TraceMsg(idx, "\tsize=%d\n", size);
 671     va_TraceMsg(idx, "\tnum_elements=%d\n", num_elements);
 672
 673     va_TraceMsg(idx, NULL);
 674 }
 675
 676
 677 void va_TraceMapBuffer (
 678     VADisplay dpy,
 679     VABufferID buf_id,    /* in */
 680     void **pbuf           /* out */
 681 )
 682 {
 683     VABufferType type;
 684     unsigned int size;
 685     unsigned int num_elements;
 686
 687     VACodedBufferSegment *buf_list;
 688     int i = 0;
 689
 690     DPY2INDEX(dpy);
 691
 692     vaBufferInfo(dpy, trace_context[idx].trace_context, buf_id, &type, &size, &num_elements);
 693
 694     /* only trace CodedBuffer */
 695     if (type != VAEncCodedBufferType)
 696         return;
 697
 698     TRACE_FUNCNAME(idx);
 699     va_TraceMsg(idx, "\tbuf_id=0x%x\n", buf_id);
 700     va_TraceMsg(idx, "\tbuf_type=%s\n", buffer_type_to_string(type));
 701     buf_list = (VACodedBufferSegment *)(*pbuf);
 702     while (buf_list != NULL) {
 703         va_TraceMsg(idx, "\tCodedbuf[%d] =\n", i++);
 704
 705         va_TraceMsg(idx, "\t   size = %d\n", buf_list->size);
 706         va_TraceMsg(idx, "\t   bit_offset = %d\n", buf_list->bit_offset);
 707         va_TraceMsg(idx, "\t   status = 0x%08x\n", buf_list->status);
 708         va_TraceMsg(idx, "\t   reserved = 0x%08x\n", buf_list->reserved);
 709         va_TraceMsg(idx, "\t   buf = 0x%08x\n", buf_list->buf);
 710
 711         buf_list = buf_list->next;
 712     }
 713     va_TraceMsg(idx, NULL);
 714 }
 715
 716 static void va_TraceVABuffers(
 717     VADisplay dpy,
 718     VAContextID context,
 719     VABufferID buffer,
 720     VABufferType type,
 721     unsigned int size,
 722     unsigned int num_elements,
 723     void *pbuf
 724 )
 725 {
 726     unsigned int i;
 727     unsigned char *p = pbuf;
 728     unsigned char  check_sum = 0;
 729     DPY2INDEX(dpy);
 730
 731     va_TraceMsg(idx, "%s",  buffer_type_to_string(type));
 732
 733     for (i=0; i<size; i++) {
 734         unsigned char value =  p[i];
 735
 736         if ((trace_flag & VA_TRACE_FLAG_BUFDATA) && ((i%16) == 0))
 737             va_TraceMsg(idx, "\n\t0x%08x:", i);
 738
 739         if (trace_flag & VA_TRACE_FLAG_BUFDATA)
 740             va_TraceMsg(idx, " %02x", value);
 741
 742         check_sum ^= value;
 743     }
 744
 745     va_TraceMsg(idx, "\n\tchecksum = 0x%02x\n", check_sum & 0xff);
 746     va_TraceMsg(idx, NULL);
 747
 748     return;
 749 }
 750
 751
 752 static void va_TraceVAPictureParameterBufferMPEG2(
 753     VADisplay dpy,
 754     VAContextID context,
 755     VABufferID buffer,
 756     VABufferType type,
 757     unsigned int size,
 758     unsigned int num_elements,
 759     void *data)
 760 {
 761     VAPictureParameterBufferMPEG2 *p=(VAPictureParameterBufferMPEG2 *)data;
 762     DPY2INDEX(dpy);
 763
 764     va_TraceMsg(idx,"VAPictureParameterBufferMPEG2\n");
 765
 766     va_TraceMsg(idx,"\thorizontal size= %d\n", p->horizontal_size);
 767     va_TraceMsg(idx,"\tvertical size= %d\n", p->vertical_size);
 768     va_TraceMsg(idx,"\tforward reference picture= %d\n", p->forward_reference_picture);
 769     va_TraceMsg(idx,"\tbackward reference picture= %d\n", p->backward_reference_picture);
 770     va_TraceMsg(idx,"\tpicture coding type= %d\n", p->picture_coding_type);
 771     va_TraceMsg(idx,"\tf mode= %d\n", p->f_code);
 772
 773     va_TraceMsg(idx,"\tpicture coding extension = %d\n", p->picture_coding_extension.value);
 774     va_TraceMsg(idx,"\tintra_dc_precision= %d\n", p->picture_coding_extension.bits.intra_dc_precision);
 775     va_TraceMsg(idx,"\tpicture_structure= %d\n", p->picture_coding_extension.bits.picture_structure);
 776     va_TraceMsg(idx,"\ttop_field_first= %d\n", p->picture_coding_extension.bits.top_field_first);
 777     va_TraceMsg(idx,"\tframe_pred_frame_dct= %d\n", p->picture_coding_extension.bits.frame_pred_frame_dct);
 778     va_TraceMsg(idx,"\tconcealment_motion_vectors= %d\n", p->picture_coding_extension.bits.concealment_motion_vectors);
 779     va_TraceMsg(idx,"\tq_scale_type= %d\n", p->picture_coding_extension.bits.q_scale_type);
 780     va_TraceMsg(idx,"\tintra_vlc_format= %d\n", p->picture_coding_extension.bits.intra_vlc_format);
 781     va_TraceMsg(idx,"\talternate_scan= %d\n", p->picture_coding_extension.bits.alternate_scan);
 782     va_TraceMsg(idx,"\trepeat_first_field= %d\n", p->picture_coding_extension.bits.repeat_first_field);
 783     va_TraceMsg(idx,"\tprogressive_frame= %d\n", p->picture_coding_extension.bits.progressive_frame);
 784     va_TraceMsg(idx,"\tis_first_field= %d\n", p->picture_coding_extension.bits.is_first_field);
 785     va_TraceMsg(idx, NULL);
 786
 787     return;
 788 }
 789
 790
 791 static void va_TraceVAIQMatrixBufferMPEG2(
 792     VADisplay dpy,
 793     VAContextID context,
 794     VABufferID buffer,
 795     VABufferType type,
 796     unsigned int size,
 797     unsigned int num_elements,
 798     void *data)
 799 {
 800     VAIQMatrixBufferMPEG2 *p=(VAIQMatrixBufferMPEG2 *)data;
 801     DPY2INDEX(dpy);
 802
 803     va_TraceMsg(idx,"VAIQMatrixBufferMPEG2\n");
 804
 805     va_TraceMsg(idx,"\tload_intra_quantiser_matrix = %d\n", p->load_intra_quantiser_matrix);
 806     va_TraceMsg(idx,"\tload_non_intra_quantiser_matrix = %d\n", p->load_non_intra_quantiser_matrix);
 807     va_TraceMsg(idx,"\tload_chroma_intra_quantiser_matrix = %d\n", p->load_chroma_intra_quantiser_matrix);
 808     va_TraceMsg(idx,"\tload_chroma_non_intra_quantiser_matrix = %d\n", p->load_chroma_non_intra_quantiser_matrix);
 809     va_TraceMsg(idx,"\tintra_quantiser_matrix = %d\n", p->intra_quantiser_matrix);
 810     va_TraceMsg(idx,"\tnon_intra_quantiser_matrix = %d\n", p->non_intra_quantiser_matrix);
 811     va_TraceMsg(idx,"\tchroma_intra_quantiser_matrix = %d\n", p->chroma_intra_quantiser_matrix);
 812     va_TraceMsg(idx,"\tchroma_non_intra_quantiser_matrix = %d\n", p->chroma_non_intra_quantiser_matrix);
 813     va_TraceMsg(idx, NULL);
 814
 815     return;
 816 }
 817
 818
 819 static void va_TraceVASliceParameterBufferMPEG2(
 820     VADisplay dpy,
 821     VAContextID context,
 822     VABufferID buffer,
 823     VABufferType type,
 824     unsigned int size,
 825     unsigned int num_elements,
 826     void *data)
 827 {
 828     VASliceParameterBufferMPEG2 *p=(VASliceParameterBufferMPEG2 *)data;
 829
 830     DPY2INDEX(dpy);
 831
 832     trace_context[idx].trace_slice_no++;
 833
 834     trace_context[idx].trace_slice_size = p->slice_data_size;
 835
 836     va_TraceMsg(idx,"VASliceParameterBufferMPEG2\n");
 837
 838     va_TraceMsg(idx,"\tslice_data_size = %d\n", p->slice_data_size);
 839     va_TraceMsg(idx,"\tslice_data_offset = %d\n", p->slice_data_offset);
 840     va_TraceMsg(idx,"\tslice_data_flag = %d\n", p->slice_data_flag);
 841     va_TraceMsg(idx,"\tmacroblock_offset = %d\n", p->macroblock_offset);
 842     va_TraceMsg(idx,"\tslice_horizontal_position = %d\n", p->slice_horizontal_position);
 843     va_TraceMsg(idx,"\tslice_vertical_position = %d\n", p->slice_vertical_position);
 844     va_TraceMsg(idx,"\tquantiser_scale_code = %d\n", p->quantiser_scale_code);
 845     va_TraceMsg(idx,"\tintra_slice_flag = %d\n", p->intra_slice_flag);
 846     va_TraceMsg(idx, NULL);
 847
 848     return;
 849 }
 850
 851 static void va_TraceVAPictureParameterBufferJPEG(
 852     VADisplay dpy,
 853     VAContextID context,
 854     VABufferID buffer,
 855     VABufferType type,
 856     unsigned int size,
 857     unsigned int num_elements,
 858     void *data)
 859 {
 860     int i;
 861     VAPictureParameterBufferJPEGBaseline *p=(VAPictureParameterBufferJPEGBaseline *)data;
 862     DPY2INDEX(dpy);
 863
 864     va_TraceMsg(idx,"*VAPictureParameterBufferJPEG\n");
 865     va_TraceMsg(idx,"\tpicture_width = %u\n", p->picture_width);
 866     va_TraceMsg(idx,"\tpicture_height = %u\n", p->picture_height);
 867     va_TraceMsg(idx,"\tcomponents = \n");
 868     for (i = 0; i < p->num_components && i < 255; ++i) {
 869         va_TraceMsg(idx,"\t\t[%d] component_id = %u\n", i, p->components[i].component_id);
 870         va_TraceMsg(idx,"\t\t[%d] h_sampling_factor = %u\n", i, p->components[i].h_sampling_factor);
 871         va_TraceMsg(idx,"\t\t[%d] v_sampling_factor = %u\n", i, p->components[i].v_sampling_factor);
 872         va_TraceMsg(idx,"\t\t[%d] quantiser_table_selector = %u\n", i, p->components[i].quantiser_table_selector);
 873     }
 874 }
 875
 876 static void va_TraceVAIQMatrixBufferJPEG(
 877     VADisplay dpy,
 878     VAContextID context,
 879     VABufferID buffer,
 880     VABufferType type,
 881     unsigned int size,
 882     unsigned int num_elements,
 883     void *data)
 884 {
 885     int i, j;
 886     static char tmp[1024];
 887     VAIQMatrixBufferJPEGBaseline *p=(VAIQMatrixBufferJPEGBaseline *)data;
 888     DPY2INDEX(dpy);
 889     va_TraceMsg(idx,"*VAIQMatrixParameterBufferJPEG\n");
 890     va_TraceMsg(idx,"\tload_quantiser_table =\n");
 891     for (i = 0; i < 4; ++i) {
 892         va_TraceMsg(idx,"\t\t[%d] = %u\n", i, p->load_quantiser_table[i]);
 893     }
 894     va_TraceMsg(idx,"\tquantiser_table =\n");
 895     for (i = 0; i < 4; ++i) {
 896         memset(tmp, 0, sizeof tmp);
 897         for (j = 0; j < 64; ++j) {
 898             sprintf(tmp + strlen(tmp), "%u ", p->quantiser_table[i][j]);
 899         }
 900         va_TraceMsg(idx,"\t\t[%d] = %s\n", i, tmp);
 901     }
 902 }
 903
 904 static void va_TraceVASliceParameterBufferJPEG(
 905     VADisplay dpy,
 906     VAContextID context,
 907     VABufferID buffer,
 908     VABufferType type,
 909     unsigned int size,
 910     unsigned int num_elements,
 911     void *data)
 912 {
 913     int i;
 914     VASliceParameterBufferJPEGBaseline *p=(VASliceParameterBufferJPEGBaseline *)data;
 915     DPY2INDEX(dpy);
 916     va_TraceMsg(idx,"*VASliceParameterBufferJPEG\n");
 917     va_TraceMsg(idx,"\tslice_data_size = %u\n", p->slice_data_size);
 918     va_TraceMsg(idx,"\tslice_data_offset = %u\n", p->slice_data_offset);
 919     va_TraceMsg(idx,"\tslice_data_flag = %u\n", p->slice_data_flag);
 920     va_TraceMsg(idx,"\tslice_horizontal_position = %u\n", p->slice_horizontal_position);
 921     va_TraceMsg(idx,"\tslice_vertical_position = %u\n", p->slice_vertical_position);
 922     va_TraceMsg(idx,"\tcomponents = \n");
 923     for (i = 0; i < p->num_components && i < 4; ++i) {
 924         va_TraceMsg(idx,"\t\t[%d] component_selector = %u\n", i, p->components[i].component_selector);
 925         va_TraceMsg(idx,"\t\t[%d] dc_table_selector = %u\n", i, p->components[i].dc_table_selector);
 926         va_TraceMsg(idx,"\t\t[%d] ac_table_selector = %u\n", i, p->components[i].ac_table_selector);
 927     }
 928     va_TraceMsg(idx,"\trestart_interval = %u\n", p->restart_interval);
 929     va_TraceMsg(idx,"\tnum_mcus = %u\n", p->num_mcus);
 930 }
 931
 932 static void va_TraceVAHuffmanTableBufferJPEG(
 933     VADisplay dpy,
 934     VAContextID context,
 935     VABufferID buffer,
 936     VABufferType type,
 937     unsigned int size,
 938     unsigned int num_elements,
 939     void *data)
 940 {
 941     int i, j;
 942     static char tmp[1024];
 943     VAHuffmanTableBufferJPEGBaseline *p=(VAHuffmanTableBufferJPEGBaseline *)data;
 944     DPY2INDEX(dpy);
 945     va_TraceMsg(idx,"*VAHuffmanTableBufferJPEG\n");
 946
 947     for (i = 0; i < 2; ++i) {
 948         va_TraceMsg(idx,"\tload_huffman_table[%d] =%u\n", i, p->load_huffman_table[0]);
 949         va_TraceMsg(idx,"\thuffman_table[%d] =\n", i);
 950         memset(tmp, 0, sizeof tmp);
 951         for (j = 0; j < 16; ++j) {
 952             sprintf(tmp + strlen(tmp), "%u ", p->huffman_table[i].num_dc_codes[j]);
 953         }
 954         va_TraceMsg(idx,"\t\tnum_dc_codes =%s\n", tmp);
 955         memset(tmp, 0, sizeof tmp);
 956         for (j = 0; j < 12; ++j) {
 957             sprintf(tmp + strlen(tmp), "%u ", p->huffman_table[i].dc_values[j]);
 958         }
 959         va_TraceMsg(idx,"\t\tdc_values =%s\n", tmp);
 960         memset(tmp, 0, sizeof tmp);
 961         for (j = 0; j < 16; ++j) {
 962             sprintf(tmp + strlen(tmp), "%u ", p->huffman_table[i].num_ac_codes[j]);
 963         }
 964         va_TraceMsg(idx,"\t\tnum_dc_codes =%s\n", tmp);
 965         memset(tmp, 0, sizeof tmp);
 966         for (j = 0; j < 162; ++j) {
 967             sprintf(tmp + strlen(tmp), "%u ", p->huffman_table[i].ac_values[j]);
 968         }
 969         va_TraceMsg(idx,"\t\tnum_dc_codes =%s\n", tmp);
 970         memset(tmp, 0, sizeof tmp);
 971         for (j = 0; j < 2; ++j) {
 972             sprintf(tmp + strlen(tmp), "%u ", p->huffman_table[i].pad[j]);
 973         }
 974         va_TraceMsg(idx,"\t\tnum_dc_codes =%s\n", tmp);
 975     }
 976 }
 977
 978 static void va_TraceVAPictureParameterBufferMPEG4(
 979     VADisplay dpy,
 980     VAContextID context,
 981     VABufferID buffer,
 982     VABufferType type,
 983     unsigned int size,
 984     unsigned int num_elements,
 985     void *data)
 986 {
 987     int i;
 988     VAPictureParameterBufferMPEG4 *p=(VAPictureParameterBufferMPEG4 *)data;
 989
 990     DPY2INDEX(dpy);
 991
 992     va_TraceMsg(idx,"*VAPictureParameterBufferMPEG4\n");
 993     va_TraceMsg(idx,"\tvop_width = %d\n", p->vop_width);
 994     va_TraceMsg(idx,"\tvop_height = %d\n", p->vop_height);
 995     va_TraceMsg(idx,"\tforward_reference_picture = %d\n", p->forward_reference_picture);
 996     va_TraceMsg(idx,"\tbackward_reference_picture = %d\n", p->backward_reference_picture);
 997     va_TraceMsg(idx,"\tvol_fields value = %d\n", p->vol_fields.value);
 998     va_TraceMsg(idx,"\tshort_video_header= %d\n", p->vol_fields.bits.short_video_header);
 999     va_TraceMsg(idx,"\tchroma_format= %d\n", p->vol_fields.bits.chroma_format);
1000     va_TraceMsg(idx,"\tinterlaced= %d\n", p->vol_fields.bits.interlaced);
1001     va_TraceMsg(idx,"\tobmc_disable= %d\n", p->vol_fields.bits.obmc_disable);
1002     va_TraceMsg(idx,"\tsprite_enable= %d\n", p->vol_fields.bits.sprite_enable);
1003     va_TraceMsg(idx,"\tsprite_warping_accuracy= %d\n", p->vol_fields.bits.sprite_warping_accuracy);
1004     va_TraceMsg(idx,"\tquant_type= %d\n", p->vol_fields.bits.quant_type);
1005     va_TraceMsg(idx,"\tquarter_sample= %d\n", p->vol_fields.bits.quarter_sample);
1006     va_TraceMsg(idx,"\tdata_partitioned= %d\n", p->vol_fields.bits.data_partitioned);
1007     va_TraceMsg(idx,"\treversible_vlc= %d\n", p->vol_fields.bits.reversible_vlc);
1008     va_TraceMsg(idx,"\tresync_marker_disable= %d\n", p->vol_fields.bits.resync_marker_disable);
1009     va_TraceMsg(idx,"\tno_of_sprite_warping_points = %d\n", p->no_of_sprite_warping_points);
1010     va_TraceMsg(idx,"\tsprite_trajectory_du =");
1011     for(i=0;i<3;i++)
1012         va_TraceMsg(idx,"\t%d", p->sprite_trajectory_du[i]);
1013
1014     va_TraceMsg(idx,"\n");
1015     va_TraceMsg(idx,"\tsprite_trajectory_dv =");
1016     for(i=0;i<3;i++)
1017         va_TraceMsg(idx,"\t%d", p->sprite_trajectory_dv[i]);
1018     va_TraceMsg(idx,"\n");
1019     va_TraceMsg(idx,"\tvop_fields value = %d\n", p->vop_fields.value);
1020     va_TraceMsg(idx,"\tvop_coding_type= %d\n", p->vop_fields.bits.vop_coding_type);
1021     va_TraceMsg(idx,"\tbackward_reference_vop_coding_type= %d\n", p->vop_fields.bits.backward_reference_vop_coding_type);
1022     va_TraceMsg(idx,"\tvop_rounding_type= %d\n", p->vop_fields.bits.vop_rounding_type);
1023     va_TraceMsg(idx,"\tintra_dc_vlc_thr= %d\n", p->vop_fields.bits.intra_dc_vlc_thr);
1024     va_TraceMsg(idx,"\ttop_field_first= %d\n", p->vop_fields.bits.top_field_first);
1025     va_TraceMsg(idx,"\talternate_vertical_scan_flag= %d\n", p->vop_fields.bits.alternate_vertical_scan_flag);
1026     va_TraceMsg(idx,"\tvop_fcode_forward = %d\n", p->vop_fcode_forward);
1027     va_TraceMsg(idx,"\tvop_fcode_backward = %d\n", p->vop_fcode_backward);
1028     va_TraceMsg(idx,"\tnum_gobs_in_vop = %d\n", p->num_gobs_in_vop);
1029     va_TraceMsg(idx,"\tnum_macroblocks_in_gob = %d\n", p->num_macroblocks_in_gob);
1030     va_TraceMsg(idx,"\tTRB = %d\n", p->TRB);
1031     va_TraceMsg(idx,"\tTRD = %d\n", p->TRD);
1032     va_TraceMsg(idx, NULL);
1033
1034     return;
1035 }
1036
1037
1038 static void va_TraceVAIQMatrixBufferMPEG4(
1039     VADisplay dpy,
1040     VAContextID context,
1041     VABufferID buffer,
1042     VABufferType type,
1043     unsigned int size,
1044     unsigned int num_elements,
1045     void *data)
1046 {
1047     int i;
1048     VAIQMatrixBufferMPEG4 *p=(VAIQMatrixBufferMPEG4 *)data;
1049     DPY2INDEX(dpy);
1050
1051     va_TraceMsg(idx,"VAIQMatrixBufferMPEG4\n");
1052
1053     va_TraceMsg(idx,"\tload_intra_quant_mat = %d\n", p->load_intra_quant_mat);
1054     va_TraceMsg(idx,"\tload_non_intra_quant_mat = %d\n", p->load_non_intra_quant_mat);
1055     va_TraceMsg(idx,"\tintra_quant_mat =\n");
1056     for(i=0;i<64;i++)
1057         va_TraceMsg(idx,"\t\t%d\n", p->intra_quant_mat[i]);
1058
1059     va_TraceMsg(idx,"\tnon_intra_quant_mat =\n");
1060     for(i=0;i<64;i++)
1061         va_TraceMsg(idx,"\t\t%d\n", p->non_intra_quant_mat[i]);
1062     va_TraceMsg(idx, NULL);
1063
1064     return;
1065 }
1066
1067 static void va_TraceVAEncSequenceParameterBufferMPEG4(
1068     VADisplay dpy,
1069     VAContextID context,
1070     VABufferID buffer,
1071     VABufferType type,
1072     unsigned int size,
1073     unsigned int num_elements,
1074     void *data)
1075 {
1076     VAEncSequenceParameterBufferMPEG4 *p = (VAEncSequenceParameterBufferMPEG4 *)data;
1077     DPY2INDEX(dpy);
1078
1079     va_TraceMsg(idx, "VAEncSequenceParameterBufferMPEG4\n");
1080
1081     va_TraceMsg(idx, "\tprofile_and_level_indication = %d\n", p->profile_and_level_indication);
1082     va_TraceMsg(idx, "\tintra_period = %d\n", p->intra_period);
1083     va_TraceMsg(idx, "\tvideo_object_layer_width = %d\n", p->video_object_layer_width);
1084     va_TraceMsg(idx, "\tvideo_object_layer_height = %d\n", p->video_object_layer_height);
1085     va_TraceMsg(idx, "\tvop_time_increment_resolution = %d\n", p->vop_time_increment_resolution);
1086     va_TraceMsg(idx, "\tfixed_vop_rate = %d\n", p->fixed_vop_rate);
1087     va_TraceMsg(idx, "\tfixed_vop_time_increment = %d\n", p->fixed_vop_time_increment);
1088     va_TraceMsg(idx, "\tbits_per_second = %d\n", p->bits_per_second);
1089     va_TraceMsg(idx, "\tframe_rate = %d\n", p->frame_rate);
1090     va_TraceMsg(idx, "\tinitial_qp = %d\n", p->initial_qp);
1091     va_TraceMsg(idx, "\tmin_qp = %d\n", p->min_qp);
1092     va_TraceMsg(idx, NULL);
1093
1094     /* start a new sequce, coded log file can be truncated */
1095     trace_context[idx].trace_sequence_start = 1;
1096
1097     return;
1098 }
1099
1100 static void va_TraceVAEncPictureParameterBufferMPEG4(
1101     VADisplay dpy,
1102     VAContextID context,
1103     VABufferID buffer,
1104     VABufferType type,
1105     unsigned int size,
1106     unsigned int num_elements,
1107     void *data)
1108 {
1109     VAEncPictureParameterBufferMPEG4 *p = (VAEncPictureParameterBufferMPEG4 *)data;
1110     DPY2INDEX(dpy);
1111
1112     va_TraceMsg(idx, "VAEncPictureParameterBufferMPEG4\n");
1113     va_TraceMsg(idx, "\treference_picture = 0x%08x\n", p->reference_picture);
1114     va_TraceMsg(idx, "\treconstructed_picture = 0x%08x\n", p->reconstructed_picture);
1115     va_TraceMsg(idx, "\tcoded_buf = 0x%08x\n", p->coded_buf);
1116     va_TraceMsg(idx, "\tpicture_width = %d\n", p->picture_width);
1117     va_TraceMsg(idx, "\tpicture_height = %d\n", p->picture_height);
1118     va_TraceMsg(idx, "\tmodulo_time_base = %d\n", p->modulo_time_base);
1119     va_TraceMsg(idx, "\tvop_time_increment = %d\n", p->vop_time_increment);
1120     va_TraceMsg(idx, "\tpicture_type = %d\n", p->picture_type);
1121     va_TraceMsg(idx, NULL);
1122
1123     trace_context[idx].trace_codedbuf =  p->coded_buf;
1124
1125     return;
1126 }
1127
1128
1129 static void va_TraceVASliceParameterBufferMPEG4(
1130     VADisplay dpy,
1131     VAContextID context,
1132     VABufferID buffer,
1133     VABufferType type,
1134     unsigned int size,
1135     unsigned int num_elements,
1136     void *data)
1137 {
1138     VASliceParameterBufferMPEG4 *p=(VASliceParameterBufferMPEG4 *)data;
1139
1140     DPY2INDEX(dpy);
1141
1142     trace_context[idx].trace_slice_no++;
1143
1144     trace_context[idx].trace_slice_size = p->slice_data_size;
1145
1146     va_TraceMsg(idx,"VASliceParameterBufferMPEG4\n");
1147
1148     va_TraceMsg(idx,"\tslice_data_size = %d\n", p->slice_data_size);
1149     va_TraceMsg(idx,"\tslice_data_offset = %d\n", p->slice_data_offset);
1150     va_TraceMsg(idx,"\tslice_data_flag = %d\n", p->slice_data_flag);
1151     va_TraceMsg(idx,"\tmacroblock_offset = %d\n", p->macroblock_offset);
1152     va_TraceMsg(idx,"\tmacroblock_number = %d\n", p->macroblock_number);
1153     va_TraceMsg(idx,"\tquant_scale = %d\n", p->quant_scale);
1154     va_TraceMsg(idx, NULL);
1155
1156     return;
1157 }
1158
1159
1160 static inline void va_TraceFlagIfNotZero(
1161     int idx,            /* in */
1162     const char *name,   /* in */
1163     unsigned int flag   /* in */
1164 )
1165 {
1166     if (flag != 0) {
1167         va_TraceMsg(idx, "%s = %x\n", name, flag);
1168     }
1169 }
1170
1171
1172 static void va_TraceVAPictureParameterBufferH264(
1173     VADisplay dpy,
1174     VAContextID context,
1175     VABufferID buffer,
1176     VABufferType type,
1177     unsigned int size,
1178     unsigned int num_elements,
1179     void *data)
1180 {
1181     int i;
1182     VAPictureParameterBufferH264 *p = (VAPictureParameterBufferH264*)data;
1183
1184     DPY2INDEX(dpy);
1185
1186     va_TraceMsg(idx, "VAPictureParameterBufferH264\n");
1187
1188     va_TraceMsg(idx, "\tCurrPic.picture_id = 0x%08x\n", p->CurrPic.picture_id);
1189     va_TraceMsg(idx, "\tCurrPic.frame_idx = %d\n", p->CurrPic.frame_idx);
1190     va_TraceMsg(idx, "\tCurrPic.flags = %d\n", p->CurrPic.flags);
1191     va_TraceMsg(idx, "\tCurrPic.TopFieldOrderCnt = %d\n", p->CurrPic.TopFieldOrderCnt);
1192     va_TraceMsg(idx, "\tCurrPic.BottomFieldOrderCnt = %d\n", p->CurrPic.BottomFieldOrderCnt);
1193
1194     va_TraceMsg(idx, "\tReferenceFrames (TopFieldOrderCnt-BottomFieldOrderCnt-picture_id-frame_idx-flags:\n");
1195     for (i = 0; i < 16; i++)
1196     {
1197         if ((p->ReferenceFrames[i].picture_id != VA_INVALID_SURFACE) &&
1198             ((p->ReferenceFrames[i].flags & VA_PICTURE_H264_INVALID) == 0)) {
1199             va_TraceMsg(idx, "\t\t%08d-%08d-0x%08x-%08d-0x%08x\n",
1200                         p->ReferenceFrames[i].TopFieldOrderCnt,
1201                         p->ReferenceFrames[i].BottomFieldOrderCnt,
1202                         p->ReferenceFrames[i].picture_id,
1203                         p->ReferenceFrames[i].frame_idx,
1204                         p->ReferenceFrames[i].flags);
1205         } else
1206             va_TraceMsg(idx, "\t\tinv-inv-inv-inv-inv\n");
1207     }
1208     va_TraceMsg(idx, "\n");
1209
1210     va_TraceMsg(idx, "\tpicture_width_in_mbs_minus1 = %d\n", p->picture_width_in_mbs_minus1);
1211     va_TraceMsg(idx, "\tpicture_height_in_mbs_minus1 = %d\n", p->picture_height_in_mbs_minus1);
1212     va_TraceMsg(idx, "\tbit_depth_luma_minus8 = %d\n", p->bit_depth_luma_minus8);
1213     va_TraceMsg(idx, "\tbit_depth_chroma_minus8 = %d\n", p->bit_depth_chroma_minus8);
1214     va_TraceMsg(idx, "\tnum_ref_frames = %d\n", p->num_ref_frames);
1215     va_TraceMsg(idx, "\tseq fields = %d\n", p->seq_fields.value);
1216     va_TraceMsg(idx, "\tchroma_format_idc = %d\n", p->seq_fields.bits.chroma_format_idc);
1217     va_TraceMsg(idx, "\tresidual_colour_transform_flag = %d\n", p->seq_fields.bits.residual_colour_transform_flag);
1218     va_TraceMsg(idx, "\tframe_mbs_only_flag = %d\n", p->seq_fields.bits.frame_mbs_only_flag);
1219     va_TraceMsg(idx, "\tmb_adaptive_frame_field_flag = %d\n", p->seq_fields.bits.mb_adaptive_frame_field_flag);
1220     va_TraceMsg(idx, "\tdirect_8x8_inference_flag = %d\n", p->seq_fields.bits.direct_8x8_inference_flag);
1221     va_TraceMsg(idx, "\tMinLumaBiPredSize8x8 = %d\n", p->seq_fields.bits.MinLumaBiPredSize8x8);
1222     va_TraceMsg(idx, "\tnum_slice_groups_minus1 = %d\n", p->num_slice_groups_minus1);
1223     va_TraceMsg(idx, "\tslice_group_map_type = %d\n", p->slice_group_map_type);
1224     va_TraceMsg(idx, "\tslice_group_change_rate_minus1 = %d\n", p->slice_group_change_rate_minus1);
1225     va_TraceMsg(idx, "\tpic_init_qp_minus26 = %d\n", p->pic_init_qp_minus26);
1226     va_TraceMsg(idx, "\tpic_init_qs_minus26 = %d\n", p->pic_init_qs_minus26);
1227     va_TraceMsg(idx, "\tchroma_qp_index_offset = %d\n", p->chroma_qp_index_offset);
1228     va_TraceMsg(idx, "\tsecond_chroma_qp_index_offset = %d\n", p->second_chroma_qp_index_offset);
1229     va_TraceMsg(idx, "\tpic_fields = 0x%03x\n", p->pic_fields.value);
1230     va_TraceFlagIfNotZero(idx, "\t\tentropy_coding_mode_flag", p->pic_fields.bits.entropy_coding_mode_flag);
1231     va_TraceFlagIfNotZero(idx, "\t\tweighted_pred_flag", p->pic_fields.bits.weighted_pred_flag);
1232     va_TraceFlagIfNotZero(idx, "\t\tweighted_bipred_idc", p->pic_fields.bits.weighted_bipred_idc);
1233     va_TraceFlagIfNotZero(idx, "\t\ttransform_8x8_mode_flag", p->pic_fields.bits.transform_8x8_mode_flag);
1234     va_TraceFlagIfNotZero(idx, "\t\tfield_pic_flag", p->pic_fields.bits.field_pic_flag);
1235     va_TraceFlagIfNotZero(idx, "\t\tconstrained_intra_pred_flag", p->pic_fields.bits.constrained_intra_pred_flag);
1236     va_TraceFlagIfNotZero(idx, "\t\tpic_order_present_flag", p->pic_fields.bits.pic_order_present_flag);
1237     va_TraceFlagIfNotZero(idx, "\t\tdeblocking_filter_control_present_flag", p->pic_fields.bits.deblocking_filter_control_present_flag);
1238     va_TraceFlagIfNotZero(idx, "\t\tredundant_pic_cnt_present_flag", p->pic_fields.bits.redundant_pic_cnt_present_flag);
1239     va_TraceFlagIfNotZero(idx, "\t\treference_pic_flag", p->pic_fields.bits.reference_pic_flag);
1240     va_TraceMsg(idx, "\tframe_num = %d\n", p->frame_num);
1241     va_TraceMsg(idx, NULL);
1242
1243     return;
1244 }
1245
1246 static void va_TraceVASliceParameterBufferH264(
1247     VADisplay dpy,
1248     VAContextID context,
1249     VABufferID buffer,
1250     VABufferType type,
1251     unsigned int size,
1252     unsigned int num_elements,
1253     void *data)
1254 {
1255     int i;
1256     VASliceParameterBufferH264* p = (VASliceParameterBufferH264*)data;
1257     DPY2INDEX(dpy);
1258
1259     trace_context[idx].trace_slice_no++;
1260     trace_context[idx].trace_slice_size = p->slice_data_size;
1261
1262     va_TraceMsg(idx, "VASliceParameterBufferH264\n");
1263     va_TraceMsg(idx, "\tslice_data_size = %d\n", p->slice_data_size);
1264     va_TraceMsg(idx, "\tslice_data_offset = %d\n", p->slice_data_offset);
1265     va_TraceMsg(idx, "\tslice_data_flag = %d\n", p->slice_data_flag);
1266     va_TraceMsg(idx, "\tslice_data_bit_offset = %d\n", p->slice_data_bit_offset);
1267     va_TraceMsg(idx, "\tfirst_mb_in_slice = %d\n", p->first_mb_in_slice);
1268     va_TraceMsg(idx, "\tslice_type = %d\n", p->slice_type);
1269     va_TraceMsg(idx, "\tdirect_spatial_mv_pred_flag = %d\n", p->direct_spatial_mv_pred_flag);
1270     va_TraceMsg(idx, "\tnum_ref_idx_l0_active_minus1 = %d\n", p->num_ref_idx_l0_active_minus1);
1271     va_TraceMsg(idx, "\tnum_ref_idx_l1_active_minus1 = %d\n", p->num_ref_idx_l1_active_minus1);
1272     va_TraceMsg(idx, "\tcabac_init_idc = %d\n", p->cabac_init_idc);
1273     va_TraceMsg(idx, "\tslice_qp_delta = %d\n", p->slice_qp_delta);
1274     va_TraceMsg(idx, "\tdisable_deblocking_filter_idc = %d\n", p->disable_deblocking_filter_idc);
1275     va_TraceMsg(idx, "\tslice_alpha_c0_offset_div2 = %d\n", p->slice_alpha_c0_offset_div2);
1276     va_TraceMsg(idx, "\tslice_beta_offset_div2 = %d\n", p->slice_beta_offset_div2);
1277
1278     if (p->slice_type == 0 || p->slice_type == 1) {
1279         va_TraceMsg(idx, "\tRefPicList0 =");
1280         for (i = 0; (i < p->num_ref_idx_l0_active_minus1 + 1 && i < 32); i++) {
1281             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);
1282         }
1283         if (p->slice_type == 1) {
1284             va_TraceMsg(idx, "\tRefPicList1 =");
1285             for (i = 0; (i < p->num_ref_idx_l1_active_minus1 + 1 && i < 32); i++)
1286             {
1287                 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);
1288             }
1289         }
1290     }
1291
1292     va_TraceMsg(idx, "\tluma_log2_weight_denom = %d\n", p->luma_log2_weight_denom);
1293     va_TraceMsg(idx, "\tchroma_log2_weight_denom = %d\n", p->chroma_log2_weight_denom);
1294     va_TraceMsg(idx, "\tluma_weight_l0_flag = %d\n", p->luma_weight_l0_flag);
1295     if (p->luma_weight_l0_flag) {
1296         for (i = 0; i <=  p->num_ref_idx_l0_active_minus1; i++) {
1297             va_TraceMsg(idx, "\t%d ", p->luma_weight_l0[i]);
1298             va_TraceMsg(idx, "\t%d ", p->luma_offset_l0[i]);
1299         }
1300     }
1301
1302     va_TraceMsg(idx, "\tchroma_weight_l0_flag = %d\n", p->chroma_weight_l0_flag);
1303     if (p->chroma_weight_l0_flag) {
1304         for (i = 0; i <= p->num_ref_idx_l0_active_minus1; i++) {
1305             va_TraceMsg(idx, "\t\t%d ", p->chroma_weight_l0[i][0]);
1306             va_TraceMsg(idx, "\t\t%d ", p->chroma_offset_l0[i][0]);
1307             va_TraceMsg(idx, "\t\t%d ", p->chroma_weight_l0[i][1]);
1308             va_TraceMsg(idx, "\t\t%d ", p->chroma_offset_l0[i][1]);
1309         }
1310     }
1311
1312     va_TraceMsg(idx, "\tluma_weight_l1_flag = %d\n", p->luma_weight_l1_flag);
1313     if (p->luma_weight_l1_flag) {
1314         for (i = 0; i <=  p->num_ref_idx_l1_active_minus1; i++) {
1315             va_TraceMsg(idx, "\t\t%d ", p->luma_weight_l1[i]);
1316             va_TraceMsg(idx, "\t\t%d ", p->luma_offset_l1[i]);
1317         }
1318     }
1319
1320     va_TraceMsg(idx, "\tchroma_weight_l1_flag = %d\n", p->chroma_weight_l1_flag);
1321     if (p->chroma_weight_l1_flag) {
1322         for (i = 0; i <= p->num_ref_idx_l1_active_minus1; i++) {
1323             va_TraceMsg(idx, "\t\t%d ", p->chroma_weight_l1[i][0]);
1324             va_TraceMsg(idx, "\t\t%d ", p->chroma_offset_l1[i][0]);
1325             va_TraceMsg(idx, "\t\t%d ", p->chroma_weight_l1[i][1]);
1326             va_TraceMsg(idx, "\t\t%d ", p->chroma_offset_l1[i][1]);
1327         }
1328         va_TraceMsg(idx, "\n");
1329     }
1330     va_TraceMsg(idx, NULL);
1331 }
1332
1333 static void va_TraceVAIQMatrixBufferH264(
1334     VADisplay dpy,
1335     VAContextID context,
1336     VABufferID buffer,
1337     VABufferType type,
1338     unsigned int size,
1339     unsigned int num_elements,
1340     void *data
1341 )
1342 {
1343     int i, j;
1344     VAIQMatrixBufferH264* p = (VAIQMatrixBufferH264* )data;
1345
1346     DPY2INDEX(dpy);
1347
1348     va_TraceMsg(idx, "VAIQMatrixBufferH264\n");
1349
1350     va_TraceMsg(idx, "\tScalingList4x4[6][16]=\n");
1351     for (i = 0; i < 6; i++) {
1352         for (j = 0; j < 16; j++) {
1353             va_TraceMsg(idx, "\t%d\t", p->ScalingList4x4[i][j]);
1354             if ((j + 1) % 8 == 0)
1355                 va_TraceMsg(idx, "\n");
1356         }
1357     }
1358
1359     va_TraceMsg(idx, "\tScalingList8x8[2][64]=\n");
1360     for (i = 0; i < 2; i++) {
1361         for (j = 0; j < 64; j++) {
1362             va_TraceMsg(idx, "\t%d", p->ScalingList8x8[i][j]);
1363             if ((j + 1) % 8 == 0)
1364                 va_TraceMsg(idx, "\n");
1365         }
1366     }
1367
1368     va_TraceMsg(idx, NULL);
1369 }
1370
1371
1372
1373 static void va_TraceVAEncSequenceParameterBufferH264(
1374     VADisplay dpy,
1375     VAContextID context,
1376     VABufferID buffer,
1377     VABufferType type,
1378     unsigned int size,
1379     unsigned int num_elements,
1380     void *data)
1381 {
1382     VAEncSequenceParameterBufferH264 *p = (VAEncSequenceParameterBufferH264 *)data;
1383     DPY2INDEX(dpy);
1384     int i;
1385
1386     va_TraceMsg(idx, "VAEncSequenceParameterBufferH264\n");
1387
1388     va_TraceMsg(idx, "\tseq_parameter_set_id = %d\n", p->seq_parameter_set_id);
1389     va_TraceMsg(idx, "\tlevel_idc = %d\n", p->level_idc);
1390     va_TraceMsg(idx, "\tintra_period = %d\n", p->intra_period);
1391     va_TraceMsg(idx, "\tintra_idr_period = %d\n", p->intra_idr_period);
1392     va_TraceMsg(idx, "\tip_period = %d\n", p->ip_period);
1393     va_TraceMsg(idx, "\tbits_per_second = %d\n", p->bits_per_second);
1394     va_TraceMsg(idx, "\tmax_num_ref_frames = %d\n", p->max_num_ref_frames);
1395     va_TraceMsg(idx, "\tpicture_width_in_mbs = %d\n", p->picture_width_in_mbs);
1396     va_TraceMsg(idx, "\tpicture_height_in_mbs = %d\n", p->picture_height_in_mbs);
1397     va_TraceMsg(idx, "\tchroma_format_idc = %d\n", p->seq_fields.bits.chroma_format_idc);
1398     va_TraceMsg(idx, "\tframe_mbs_only_flag = %d\n", p->seq_fields.bits.frame_mbs_only_flag);
1399     va_TraceMsg(idx, "\tmb_adaptive_frame_field_flag = %d\n", p->seq_fields.bits.mb_adaptive_frame_field_flag);
1400     va_TraceMsg(idx, "\tseq_scaling_matrix_present_flag = %d\n", p->seq_fields.bits.seq_scaling_matrix_present_flag);
1401     va_TraceMsg(idx, "\tdirect_8x8_inference_flag = %d\n", p->seq_fields.bits.direct_8x8_inference_flag);
1402     va_TraceMsg(idx, "\tlog2_max_frame_num_minus4 = %d\n", p->seq_fields.bits.log2_max_frame_num_minus4);
1403     va_TraceMsg(idx, "\tpic_order_cnt_type = %d\n", p->seq_fields.bits.pic_order_cnt_type);
1404     va_TraceMsg(idx, "\tlog2_max_pic_order_cnt_lsb_minus4 = %d\n", p->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4);
1405     va_TraceMsg(idx, "\tdelta_pic_order_always_zero_flag = %d\n", p->seq_fields.bits.delta_pic_order_always_zero_flag);
1406     va_TraceMsg(idx, "\tbit_depth_luma_minus8 = %d\n", p->bit_depth_luma_minus8);
1407     va_TraceMsg(idx, "\tbit_depth_chroma_minus8 = %d\n", p->bit_depth_chroma_minus8);
1408     va_TraceMsg(idx, "\tnum_ref_frames_in_pic_order_cnt_cycle = %d\n", p->num_ref_frames_in_pic_order_cnt_cycle);
1409     va_TraceMsg(idx, "\toffset_for_non_ref_pic = %d\n", p->offset_for_non_ref_pic);
1410     va_TraceMsg(idx, "\toffset_for_top_to_bottom_field = %d\n", p->offset_for_top_to_bottom_field);
1411     for(i = 0; i< p->max_num_ref_frames; ++i)
1412         va_TraceMsg(idx, "\toffset_for_ref_frame[%d] = %d\n", i, p->offset_for_ref_frame[i]);
1413     va_TraceMsg(idx, "\tframe_cropping_flag = %d\n", p->frame_cropping_flag);
1414     va_TraceMsg(idx, "\tframe_crop_left_offset = %d\n", p->frame_crop_left_offset);
1415     va_TraceMsg(idx, "\tframe_crop_right_offset = %d\n", p->frame_crop_right_offset);
1416     va_TraceMsg(idx, "\tframe_crop_top_offset = %d\n", p->frame_crop_top_offset);
1417     va_TraceMsg(idx, "\tframe_crop_bottom_offset = %d\n", p->frame_crop_bottom_offset);
1418     va_TraceMsg(idx, "\tvui_parameters_present_flag = %d\n", p->vui_parameters_present_flag);
1419     va_TraceMsg(idx, "\taspect_ratio_info_present_flag = %d\n", p->vui_fields.bits.aspect_ratio_info_present_flag);
1420     va_TraceMsg(idx, "\ttiming_info_present_flag = %d\n", p->vui_fields.bits.timing_info_present_flag);
1421     va_TraceMsg(idx, "\tbitstream_restriction_flag = %d\n", p->vui_fields.bits.bitstream_restriction_flag);
1422     va_TraceMsg(idx, "\tlog2_max_mv_length_horizontal = %d\n", p->vui_fields.bits.log2_max_mv_length_horizontal);
1423     va_TraceMsg(idx, "\tlog2_max_mv_length_vertical = %d\n", p->vui_fields.bits.log2_max_mv_length_vertical);
1424     va_TraceMsg(idx, "\taspect_ratio_idc = %d\n", p->aspect_ratio_idc);
1425     va_TraceMsg(idx, "\tsar_width = %d\n", p->sar_width);
1426     va_TraceMsg(idx, "\tsar_height = %d\n", p->sar_height);
1427     va_TraceMsg(idx, "\tnum_units_in_tick = %d\n", p->num_units_in_tick);
1428     va_TraceMsg(idx, "\ttime_scale = %d\n", p->time_scale);
1429
1430     va_TraceMsg(idx, NULL);
1431
1432     /* start a new sequce, coded log file can be truncated */
1433     trace_context[idx].trace_sequence_start = 1;
1434
1435     return;
1436 }
1437
1438
1439 static void va_TraceVAEncPictureParameterBufferH264(
1440     VADisplay dpy,
1441     VAContextID context,
1442     VABufferID buffer,
1443     VABufferType type,
1444     unsigned int size,
1445     unsigned int num_elements,
1446     void *data)
1447 {
1448     VAEncPictureParameterBufferH264 *p = (VAEncPictureParameterBufferH264 *)data;
1449     DPY2INDEX(dpy);
1450     int i;
1451
1452     va_TraceMsg(idx, "VAEncPictureParameterBufferH264\n");
1453
1454     va_TraceMsg(idx, "\tCurrPic.picture_id = 0x%08x\n", p->CurrPic.picture_id);
1455     va_TraceMsg(idx, "\tCurrPic.frame_idx = %d\n", p->CurrPic.frame_idx);
1456     va_TraceMsg(idx, "\tCurrPic.flags = %d\n", p->CurrPic.flags);
1457     va_TraceMsg(idx, "\tCurrPic.TopFieldOrderCnt = %d\n", p->CurrPic.TopFieldOrderCnt);
1458     va_TraceMsg(idx, "\tCurrPic.BottomFieldOrderCnt = %d\n", p->CurrPic.BottomFieldOrderCnt);
1459     va_TraceMsg(idx, "\tReferenceFrames (TopFieldOrderCnt-BottomFieldOrderCnt-picture_id-frame_idx-flags):\n");
1460     for (i = 0; i < 16; i++)
1461     {
1462         if ((p->ReferenceFrames[i].picture_id != VA_INVALID_SURFACE) &&
1463             ((p->ReferenceFrames[i].flags & VA_PICTURE_H264_INVALID) == 0)) {
1464             va_TraceMsg(idx, "\t\t%08d-%08d-0x%08x-%08d-0x%08x\n",
1465                         p->ReferenceFrames[i].TopFieldOrderCnt,
1466                         p->ReferenceFrames[i].BottomFieldOrderCnt,
1467                         p->ReferenceFrames[i].picture_id,
1468                         p->ReferenceFrames[i].frame_idx,
1469                         p->ReferenceFrames[i].flags
1470                         );
1471         } else
1472             va_TraceMsg(idx, "\t\tinv-inv-inv-inv-inv\n");
1473     }
1474     va_TraceMsg(idx, "\tcoded_buf = %08x\n", p->coded_buf);
1475     va_TraceMsg(idx, "\tpic_parameter_set_id = %d\n", p->pic_parameter_set_id);
1476     va_TraceMsg(idx, "\tseq_parameter_set_id = %d\n", p->seq_parameter_set_id);
1477     va_TraceMsg(idx, "\tlast_picture = 0x%08x\n", p->last_picture);
1478     va_TraceMsg(idx, "\tframe_num = %d\n", p->frame_num);
1479     va_TraceMsg(idx, "\tpic_init_qp = %d\n", p->pic_init_qp);
1480     va_TraceMsg(idx, "\tnum_ref_idx_l0_active_minus1 = %d\n", p->num_ref_idx_l0_active_minus1);
1481     va_TraceMsg(idx, "\tnum_ref_idx_l1_active_minus1 = %d\n", p->num_ref_idx_l1_active_minus1);
1482     va_TraceMsg(idx, "\tchroma_qp_index_offset = %d\n", p->chroma_qp_index_offset);
1483     va_TraceMsg(idx, "\tsecond_chroma_qp_index_offset = %d\n", p->second_chroma_qp_index_offset);
1484     va_TraceMsg(idx, "\tpic_fields = 0x%03x\n", p->pic_fields.value);
1485     va_TraceMsg(idx, "\tidr_pic_flag = %d\n", p->pic_fields.bits.idr_pic_flag);
1486     va_TraceMsg(idx, "\treference_pic_flag = %d\n", p->pic_fields.bits.reference_pic_flag);
1487     va_TraceMsg(idx, "\tentropy_coding_mode_flag = %d\n", p->pic_fields.bits.entropy_coding_mode_flag);
1488     va_TraceMsg(idx, "\tweighted_pred_flag = %d\n", p->pic_fields.bits.weighted_pred_flag);
1489     va_TraceMsg(idx, "\tweighted_bipred_idc = %d\n", p->pic_fields.bits.weighted_bipred_idc);
1490     va_TraceMsg(idx, "\tconstrained_intra_pred_flag = %d\n", p->pic_fields.bits.constrained_intra_pred_flag);
1491     va_TraceMsg(idx, "\ttransform_8x8_mode_flag = %d\n", p->pic_fields.bits.transform_8x8_mode_flag);
1492     va_TraceMsg(idx, "\tdeblocking_filter_control_present_flag = %d\n", p->pic_fields.bits.deblocking_filter_control_present_flag);
1493     va_TraceMsg(idx, "\tredundant_pic_cnt_present_flag = %d\n", p->pic_fields.bits.redundant_pic_cnt_present_flag);
1494     va_TraceMsg(idx, "\tpic_order_present_flag = %d\n", p->pic_fields.bits.pic_order_present_flag);
1495     va_TraceMsg(idx, "\tpic_scaling_matrix_present_flag = %d\n", p->pic_fields.bits.pic_scaling_matrix_present_flag);
1496
1497     va_TraceMsg(idx, NULL);
1498
1499     trace_context[idx].trace_codedbuf =  p->coded_buf;
1500
1501     return;
1502 }
1503
1504 static void va_TraceVAEncSliceParameterBuffer(
1505     VADisplay dpy,
1506     VAContextID context,
1507     VABufferID buffer,
1508     VABufferType type,
1509     unsigned int size,
1510     unsigned int num_elements,
1511     void *data)
1512 {
1513     VAEncSliceParameterBuffer* p = (VAEncSliceParameterBuffer*)data;
1514     DPY2INDEX(dpy);
1515
1516     va_TraceMsg(idx, "VAEncSliceParameterBuffer\n");
1517
1518     va_TraceMsg(idx, "\tstart_row_number = %d\n", p->start_row_number);
1519     va_TraceMsg(idx, "\tslice_height = %d\n", p->slice_height);
1520     va_TraceMsg(idx, "\tslice_flags.is_intra = %d\n", p->slice_flags.bits.is_intra);
1521     va_TraceMsg(idx, "\tslice_flags.disable_deblocking_filter_idc = %d\n", p->slice_flags.bits.disable_deblocking_filter_idc);
1522     va_TraceMsg(idx, "\tslice_flags.uses_long_term_ref = %d\n", p->slice_flags.bits.uses_long_term_ref);
1523     va_TraceMsg(idx, "\tslice_flags.is_long_term_ref = %d\n", p->slice_flags.bits.is_long_term_ref);
1524     va_TraceMsg(idx, NULL);
1525
1526     return;
1527 }
1528
1529 static void va_TraceVAEncSliceParameterBufferH264(
1530     VADisplay dpy,
1531     VAContextID context,
1532     VABufferID buffer,
1533     VABufferType type,
1534     unsigned int size,
1535     unsigned int num_elements,
1536     void *data)
1537 {
1538     VAEncSliceParameterBufferH264* p = (VAEncSliceParameterBufferH264*)data;
1539     DPY2INDEX(dpy);
1540     int i;
1541
1542     if (!p)
1543         return;
1544     va_TraceMsg(idx, "VAEncSliceParameterBufferH264\n");
1545     va_TraceMsg(idx, "\tmacroblock_address = %d\n", p->macroblock_address);
1546     va_TraceMsg(idx, "\tnum_macroblocks = %d\n", p->num_macroblocks);
1547     va_TraceMsg(idx, "\tmacroblock_info = %08x\n", p->macroblock_info);
1548     va_TraceMsg(idx, "\tslice_type = %d\n", p->slice_type);
1549     va_TraceMsg(idx, "\tpic_parameter_set_id = %d\n", p->pic_parameter_set_id);
1550     va_TraceMsg(idx, "\tidr_pic_id = %d\n", p->idr_pic_id);
1551     va_TraceMsg(idx, "\tpic_order_cnt_lsb = %d\n", p->pic_order_cnt_lsb);
1552     va_TraceMsg(idx, "\tdelta_pic_order_cnt_bottom = %d\n", p->delta_pic_order_cnt_bottom);
1553     va_TraceMsg(idx, "\tdelta_pic_order_cnt[0] = %d\n", p->delta_pic_order_cnt[0]);
1554     va_TraceMsg(idx, "\tdelta_pic_order_cnt[1] = %d\n", p->delta_pic_order_cnt[1]);
1555     va_TraceMsg(idx, "\tdirect_spatial_mv_pred_flag = %d\n", p->direct_spatial_mv_pred_flag);
1556     va_TraceMsg(idx, "\tnum_ref_idx_active_override_flag = %d\n", p->num_ref_idx_active_override_flag);
1557     va_TraceMsg(idx, "\tnum_ref_idx_l1_active_minus1 = %d\n", p->num_ref_idx_l1_active_minus1);
1558     va_TraceMsg(idx, "\tslice_beta_offset_div2 = %d\n", p->slice_beta_offset_div2);
1559
1560     if (p->slice_type == 0 || p->slice_type == 1) {
1561         va_TraceMsg(idx, "\tRefPicList0 (TopFieldOrderCnt-BottomFieldOrderCnt-picture_id-frame_idx-flags):\n");
1562         for (i = 0; i < 32; i++) {
1563             if ((p->RefPicList0[i].picture_id != VA_INVALID_SURFACE) &&
1564                 ((p->RefPicList0[i].flags & VA_PICTURE_H264_INVALID) == 0))
1565                 va_TraceMsg(idx, "\t\t%08d-%08d-0x%08x-%08d-0x%08x\n",
1566                             p->RefPicList0[i].TopFieldOrderCnt,
1567                             p->RefPicList0[i].BottomFieldOrderCnt,
1568                             p->RefPicList0[i].picture_id,
1569                             p->RefPicList0[i].frame_idx,
1570                             p->RefPicList0[i].flags);
1571             else
1572                 break;
1573         }
1574     }
1575
1576     if (p->slice_type == 1) {
1577         va_TraceMsg(idx, "\tRefPicList1 (TopFieldOrderCnt-BottomFieldOrderCnt-picture_id-frame_idx-flags):\n");
1578         for (i = 0; i < 32; i++) {
1579             if ((p->RefPicList1[i].picture_id != VA_INVALID_SURFACE) &&
1580                 ((p->RefPicList1[i].flags & VA_PICTURE_H264_INVALID) == 0))
1581                 va_TraceMsg(idx, "\t\t%08d-%08d-0x%08x-%08d-0x%08d\n",
1582                             p->RefPicList1[i].TopFieldOrderCnt,
1583                             p->RefPicList1[i].BottomFieldOrderCnt,
1584                             p->RefPicList1[i].picture_id,
1585                             p->RefPicList1[i].frame_idx,
1586                             p->RefPicList1[i].flags
1587                             );
1588             else
1589                 break;
1590         }
1591     }
1592
1593     va_TraceMsg(idx, "\tluma_log2_weight_denom = %d\n", p->luma_log2_weight_denom);
1594     va_TraceMsg(idx, "\tchroma_log2_weight_denom = %d\n", p->chroma_log2_weight_denom);
1595     va_TraceMsg(idx, "\tluma_weight_l0_flag = %d\n", p->luma_weight_l0_flag);
1596     if (p->luma_weight_l0_flag && p->num_ref_idx_l0_active_minus1 < 32) {
1597         for (i = 0; i <=  p->num_ref_idx_l0_active_minus1; i++) {
1598             va_TraceMsg(idx, "\t%d ", p->luma_weight_l0[i]);
1599             va_TraceMsg(idx, "\t%d ", p->luma_offset_l0[i]);
1600         }
1601     }
1602
1603     va_TraceMsg(idx, "\tchroma_weight_l0_flag = %d\n", p->chroma_weight_l0_flag);
1604     if (p->chroma_weight_l0_flag && p->num_ref_idx_l0_active_minus1 < 32) {
1605         for (i = 0; i <= p->num_ref_idx_l0_active_minus1; i++) {
1606             va_TraceMsg(idx, "\t\t%d ", p->chroma_weight_l0[i][0]);
1607             va_TraceMsg(idx, "\t\t%d ", p->chroma_offset_l0[i][0]);
1608             va_TraceMsg(idx, "\t\t%d ", p->chroma_weight_l0[i][1]);
1609             va_TraceMsg(idx, "\t\t%d ", p->chroma_offset_l0[i][1]);
1610         }
1611     }
1612
1613     va_TraceMsg(idx, "\tluma_weight_l1_flag = %d\n", p->luma_weight_l1_flag);
1614     if (p->luma_weight_l1_flag && p->num_ref_idx_l1_active_minus1 < 32) {
1615         for (i = 0; i <=  p->num_ref_idx_l1_active_minus1; i++) {
1616             va_TraceMsg(idx, "\t\t%d ", p->luma_weight_l1[i]);
1617             va_TraceMsg(idx, "\t\t%d ", p->luma_offset_l1[i]);
1618         }
1619     }
1620
1621     va_TraceMsg(idx, "\tchroma_weight_l1_flag = %d\n", p->chroma_weight_l1_flag);
1622     if (p->chroma_weight_l1_flag && p->num_ref_idx_l1_active_minus1 < 32) {
1623         for (i = 0; i <= p->num_ref_idx_l1_active_minus1; i++) {
1624             va_TraceMsg(idx, "\t\t%d ", p->chroma_weight_l1[i][0]);
1625             va_TraceMsg(idx, "\t\t%d ", p->chroma_offset_l1[i][0]);
1626             va_TraceMsg(idx, "\t\t%d ", p->chroma_weight_l1[i][1]);
1627             va_TraceMsg(idx, "\t\t%d ", p->chroma_offset_l1[i][1]);
1628         }
1629         va_TraceMsg(idx, "\n");
1630     }
1631     va_TraceMsg(idx, NULL);
1632
1633     va_TraceMsg(idx, "\tcabac_init_idc = %d\n", p->cabac_init_idc);
1634     va_TraceMsg(idx, "\tslice_qp_delta = %d\n", p->slice_qp_delta);
1635     va_TraceMsg(idx, "\tdisable_deblocking_filter_idc = %d\n", p->disable_deblocking_filter_idc);
1636     va_TraceMsg(idx, "\tslice_alpha_c0_offset_div2 = %d\n", p->slice_alpha_c0_offset_div2);
1637     va_TraceMsg(idx, "\tslice_beta_offset_div2 = %d\n", p->slice_beta_offset_div2);
1638     va_TraceMsg(idx, NULL);
1639
1640     return;
1641 }
1642
1643
1644 static void va_TraceVAEncPackedHeaderParameterBufferType(
1645     VADisplay dpy,
1646     VAContextID context,
1647     VABufferID buffer,
1648     VABufferType type,
1649     unsigned int size,
1650     unsigned int num_elements,
1651     void *data)
1652 {
1653     VAEncPackedHeaderParameterBuffer* p = (VAEncPackedHeaderParameterBuffer*)data;
1654     DPY2INDEX(dpy);
1655     int i;
1656
1657     if (!p)
1658         return;
1659     va_TraceMsg(idx, "VAEncPackedHeaderParameterBuffer\n");
1660     va_TraceMsg(idx, "\ttype = 0x%08x\n", p->type);
1661     va_TraceMsg(idx, "\tbit_length = %d\n", p->bit_length);
1662     va_TraceMsg(idx, "\thas_emulation_bytes = %d\n", p->has_emulation_bytes);
1663     va_TraceMsg(idx, NULL);
1664
1665     return;
1666 }
1667
1668 static void va_TraceVAEncMiscParameterBuffer(
1669     VADisplay dpy,
1670     VAContextID context,
1671     VABufferID buffer,
1672     VABufferType type,
1673     unsigned int size,
1674     unsigned int num_elements,
1675     void *data)
1676 {
1677     VAEncMiscParameterBuffer* tmp = (VAEncMiscParameterBuffer*)data;
1678     DPY2INDEX(dpy);
1679
1680     switch (tmp->type) {
1681     case VAEncMiscParameterTypeFrameRate:
1682     {
1683         VAEncMiscParameterFrameRate *p = (VAEncMiscParameterFrameRate *)tmp->data;
1684         va_TraceMsg(idx, "VAEncMiscParameterFrameRate\n");
1685         va_TraceMsg(idx, "\tframerate = %d\n", p->framerate);
1686
1687         break;
1688     }
1689     case VAEncMiscParameterTypeRateControl:
1690     {
1691         VAEncMiscParameterRateControl *p = (VAEncMiscParameterRateControl *)tmp->data;
1692
1693         va_TraceMsg(idx, "VAEncMiscParameterRateControl\n");
1694         va_TraceMsg(idx, "\tbits_per_second = %d\n", p->bits_per_second);
1695         va_TraceMsg(idx, "\twindow_size = %d\n", p->window_size);
1696         va_TraceMsg(idx, "\tinitial_qp = %d\n", p->initial_qp);
1697         va_TraceMsg(idx, "\tmin_qp = %d\n", p->min_qp);
1698         va_TraceMsg(idx, "\tbasic_unit_size = %d\n", p->basic_unit_size);
1699         va_TraceMsg(idx, "\trc_flags.reset = %d \n", p->rc_flags.bits.reset);
1700         va_TraceMsg(idx, "\trc_flags.disable_frame_skip = %d\n", p->rc_flags.bits.disable_frame_skip);
1701         va_TraceMsg(idx, "\trc_flags.disable_bit_stuffing = %d\n", p->rc_flags.bits.disable_bit_stuffing);
1702         break;
1703     }
1704     case VAEncMiscParameterTypeMaxSliceSize:
1705     {
1706         VAEncMiscParameterMaxSliceSize *p = (VAEncMiscParameterMaxSliceSize *)tmp->data;
1707
1708         va_TraceMsg(idx, "VAEncMiscParameterTypeMaxSliceSize\n");
1709         va_TraceMsg(idx, "\tmax_slice_size = %d\n", p->max_slice_size);
1710         break;
1711     }
1712     case VAEncMiscParameterTypeAIR:
1713     {
1714         VAEncMiscParameterAIR *p = (VAEncMiscParameterAIR *)tmp->data;
1715
1716         va_TraceMsg(idx, "VAEncMiscParameterAIR\n");
1717         va_TraceMsg(idx, "\tair_num_mbs = %d\n", p->air_num_mbs);
1718         va_TraceMsg(idx, "\tair_threshold = %d\n", p->air_threshold);
1719         va_TraceMsg(idx, "\tair_auto = %d\n", p->air_auto);
1720         break;
1721     }
1722     case VAEncMiscParameterTypeHRD:
1723     {
1724         VAEncMiscParameterHRD *p = (VAEncMiscParameterHRD *)tmp->data;
1725
1726         va_TraceMsg(idx, "VAEncMiscParameterHRD\n");
1727         va_TraceMsg(idx, "\tinitial_buffer_fullness = %d\n", p->initial_buffer_fullness);
1728         va_TraceMsg(idx, "\tbuffer_size = %d\n", p->buffer_size);
1729         break;
1730     }
1731     default:
1732         va_TraceMsg(idx, "Unknown VAEncMiscParameterBuffer(type = %d):", tmp->type);
1733         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, data);
1734         break;
1735     }
1736     va_TraceMsg(idx, NULL);
1737
1738     return;
1739 }
1740
1741
1742 static void va_TraceVAPictureParameterBufferVC1(
1743     VADisplay dpy,
1744     VAContextID context,
1745     VABufferID buffer,
1746     VABufferType type,
1747     unsigned int size,
1748     unsigned int num_elements,
1749     void *data
1750 )
1751 {
1752     VAPictureParameterBufferVC1* p = (VAPictureParameterBufferVC1*)data;
1753     DPY2INDEX(dpy);
1754
1755     va_TraceMsg(idx, "VAPictureParameterBufferVC1\n");
1756
1757     va_TraceMsg(idx, "\tforward_reference_picture = 0x%08x\n", p->forward_reference_picture);
1758     va_TraceMsg(idx, "\tbackward_reference_picture = 0x%08x\n", p->backward_reference_picture);
1759     va_TraceMsg(idx, "\tinloop_decoded_picture = 0x%08x\n", p->inloop_decoded_picture);
1760
1761     va_TraceMsg(idx, "\tpulldown = %d\n", p->sequence_fields.bits.pulldown);
1762     va_TraceMsg(idx, "\tinterlace = %d\n", p->sequence_fields.bits.interlace);
1763     va_TraceMsg(idx, "\ttfcntrflag = %d\n", p->sequence_fields.bits.tfcntrflag);
1764     va_TraceMsg(idx, "\tfinterpflag = %d\n", p->sequence_fields.bits.finterpflag);
1765     va_TraceMsg(idx, "\tpsf = %d\n", p->sequence_fields.bits.psf);
1766     va_TraceMsg(idx, "\tmultires = %d\n", p->sequence_fields.bits.multires);
1767     va_TraceMsg(idx, "\toverlap = %d\n", p->sequence_fields.bits.overlap);
1768     va_TraceMsg(idx, "\tsyncmarker = %d\n", p->sequence_fields.bits.syncmarker);
1769     va_TraceMsg(idx, "\trangered = %d\n", p->sequence_fields.bits.rangered);
1770     va_TraceMsg(idx, "\tmax_b_frames = %d\n", p->sequence_fields.bits.max_b_frames);
1771     va_TraceMsg(idx, "\tprofile = %d\n", p->sequence_fields.bits.profile);
1772     va_TraceMsg(idx, "\tcoded_width = %d\n", p->coded_width);
1773     va_TraceMsg(idx, "\tcoded_height = %d\n", p->coded_height);
1774     va_TraceMsg(idx, "\tclosed_entry = %d\n", p->entrypoint_fields.bits.closed_entry);
1775     va_TraceMsg(idx, "\tbroken_link = %d\n", p->entrypoint_fields.bits.broken_link);
1776     va_TraceMsg(idx, "\tclosed_entry = %d\n", p->entrypoint_fields.bits.closed_entry);
1777     va_TraceMsg(idx, "\tpanscan_flag = %d\n", p->entrypoint_fields.bits.panscan_flag);
1778     va_TraceMsg(idx, "\tloopfilter = %d\n", p->entrypoint_fields.bits.loopfilter);
1779     va_TraceMsg(idx, "\tconditional_overlap_flag = %d\n", p->conditional_overlap_flag);
1780     va_TraceMsg(idx, "\tfast_uvmc_flag = %d\n", p->fast_uvmc_flag);
1781     va_TraceMsg(idx, "\trange_mapping_luma_flag = %d\n", p->range_mapping_fields.bits.luma_flag);
1782     va_TraceMsg(idx, "\trange_mapping_luma = %d\n", p->range_mapping_fields.bits.luma);
1783     va_TraceMsg(idx, "\trange_mapping_chroma_flag = %d\n", p->range_mapping_fields.bits.chroma_flag);
1784     va_TraceMsg(idx, "\trange_mapping_chroma = %d\n", p->range_mapping_fields.bits.chroma);
1785     va_TraceMsg(idx, "\tb_picture_fraction = %d\n", p->b_picture_fraction);
1786     va_TraceMsg(idx, "\tcbp_table = %d\n", p->cbp_table);
1787     va_TraceMsg(idx, "\tmb_mode_table = %d\n", p->mb_mode_table);
1788     va_TraceMsg(idx, "\trange_reduction_frame = %d\n", p->range_reduction_frame);
1789     va_TraceMsg(idx, "\trounding_control = %d\n", p->rounding_control);
1790     va_TraceMsg(idx, "\tpost_processing = %d\n", p->post_processing);
1791     va_TraceMsg(idx, "\tpicture_resolution_index = %d\n", p->picture_resolution_index);
1792     va_TraceMsg(idx, "\tluma_scale = %d\n", p->luma_scale);
1793     va_TraceMsg(idx, "\tluma_shift = %d\n", p->luma_shift);
1794     va_TraceMsg(idx, "\tpicture_type = %d\n", p->picture_fields.bits.picture_type);
1795     va_TraceMsg(idx, "\tframe_coding_mode = %d\n", p->picture_fields.bits.frame_coding_mode);
1796     va_TraceMsg(idx, "\ttop_field_first = %d\n", p->picture_fields.bits.top_field_first);
1797     va_TraceMsg(idx, "\tis_first_field = %d\n", p->picture_fields.bits.is_first_field);
1798     va_TraceMsg(idx, "\tintensity_compensation = %d\n", p->picture_fields.bits.intensity_compensation);
1799     va_TraceMsg(idx, "\tmv_type_mb = %d\n", p->raw_coding.flags.mv_type_mb);
1800     va_TraceMsg(idx, "\tdirect_mb = %d\n", p->raw_coding.flags.direct_mb);
1801     va_TraceMsg(idx, "\tskip_mb = %d\n", p->raw_coding.flags.skip_mb);
1802     va_TraceMsg(idx, "\tfield_tx = %d\n", p->raw_coding.flags.field_tx);
1803     va_TraceMsg(idx, "\tforward_mb = %d\n", p->raw_coding.flags.forward_mb);
1804     va_TraceMsg(idx, "\tac_pred = %d\n", p->raw_coding.flags.ac_pred);
1805     va_TraceMsg(idx, "\toverflags = %d\n", p->raw_coding.flags.overflags);
1806     va_TraceMsg(idx, "\tbp_mv_type_mb = %d\n", p->bitplane_present.flags.bp_mv_type_mb);
1807     va_TraceMsg(idx, "\tbp_direct_mb = %d\n", p->bitplane_present.flags.bp_direct_mb);
1808     va_TraceMsg(idx, "\tbp_skip_mb = %d\n", p->bitplane_present.flags.bp_skip_mb);
1809     va_TraceMsg(idx, "\tbp_field_tx = %d\n", p->bitplane_present.flags.bp_field_tx);
1810     va_TraceMsg(idx, "\tbp_forward_mb = %d\n", p->bitplane_present.flags.bp_forward_mb);
1811     va_TraceMsg(idx, "\tbp_ac_pred = %d\n", p->bitplane_present.flags.bp_ac_pred);
1812     va_TraceMsg(idx, "\tbp_overflags = %d\n", p->bitplane_present.flags.bp_overflags);
1813     va_TraceMsg(idx, "\treference_distance_flag = %d\n", p->reference_fields.bits.reference_distance_flag);
1814     va_TraceMsg(idx, "\treference_distance = %d\n", p->reference_fields.bits.reference_distance);
1815     va_TraceMsg(idx, "\tnum_reference_pictures = %d\n", p->reference_fields.bits.num_reference_pictures);
1816     va_TraceMsg(idx, "\treference_field_pic_indicator = %d\n", p->reference_fields.bits.reference_field_pic_indicator);
1817     va_TraceMsg(idx, "\tmv_mode = %d\n", p->mv_fields.bits.mv_mode);
1818     va_TraceMsg(idx, "\tmv_mode2 = %d\n", p->mv_fields.bits.mv_mode2);
1819     va_TraceMsg(idx, "\tmv_table = %d\n", p->mv_fields.bits.mv_table);
1820     va_TraceMsg(idx, "\ttwo_mv_block_pattern_table = %d\n", p->mv_fields.bits.two_mv_block_pattern_table);
1821     va_TraceMsg(idx, "\tfour_mv_switch = %d\n", p->mv_fields.bits.four_mv_switch);
1822     va_TraceMsg(idx, "\tfour_mv_block_pattern_table = %d\n", p->mv_fields.bits.four_mv_block_pattern_table);
1823     va_TraceMsg(idx, "\textended_mv_flag = %d\n", p->mv_fields.bits.extended_mv_flag);
1824     va_TraceMsg(idx, "\textended_mv_range = %d\n", p->mv_fields.bits.extended_mv_range);
1825     va_TraceMsg(idx, "\textended_dmv_flag = %d\n", p->mv_fields.bits.extended_dmv_flag);
1826     va_TraceMsg(idx, "\textended_dmv_range = %d\n", p->mv_fields.bits.extended_dmv_range);
1827     va_TraceMsg(idx, "\tdquant = %d\n", p->pic_quantizer_fields.bits.dquant);
1828     va_TraceMsg(idx, "\tquantizer = %d\n", p->pic_quantizer_fields.bits.quantizer);
1829     va_TraceMsg(idx, "\thalf_qp = %d\n", p->pic_quantizer_fields.bits.half_qp);
1830     va_TraceMsg(idx, "\tpic_quantizer_scale = %d\n", p->pic_quantizer_fields.bits.pic_quantizer_scale);
1831     va_TraceMsg(idx, "\tpic_quantizer_type = %d\n", p->pic_quantizer_fields.bits.pic_quantizer_type);
1832     va_TraceMsg(idx, "\tdq_frame = %d\n", p->pic_quantizer_fields.bits.dq_frame);
1833     va_TraceMsg(idx, "\tdq_profile = %d\n", p->pic_quantizer_fields.bits.dq_profile);
1834     va_TraceMsg(idx, "\tdq_sb_edge = %d\n", p->pic_quantizer_fields.bits.dq_sb_edge);
1835     va_TraceMsg(idx, "\tdq_db_edge = %d\n", p->pic_quantizer_fields.bits.dq_db_edge);
1836     va_TraceMsg(idx, "\tdq_binary_level = %d\n", p->pic_quantizer_fields.bits.dq_binary_level);
1837     va_TraceMsg(idx, "\talt_pic_quantizer = %d\n", p->pic_quantizer_fields.bits.alt_pic_quantizer);
1838     va_TraceMsg(idx, "\tvariable_sized_transform_flag = %d\n", p->transform_fields.bits.variable_sized_transform_flag);
1839     va_TraceMsg(idx, "\tmb_level_transform_type_flag = %d\n", p->transform_fields.bits.mb_level_transform_type_flag);
1840     va_TraceMsg(idx, "\tframe_level_transform_type = %d\n", p->transform_fields.bits.frame_level_transform_type);
1841     va_TraceMsg(idx, "\ttransform_ac_codingset_idx1 = %d\n", p->transform_fields.bits.transform_ac_codingset_idx1);
1842     va_TraceMsg(idx, "\ttransform_ac_codingset_idx2 = %d\n", p->transform_fields.bits.transform_ac_codingset_idx2);
1843     va_TraceMsg(idx, "\tintra_transform_dc_table = %d\n", p->transform_fields.bits.intra_transform_dc_table);
1844     va_TraceMsg(idx, NULL);
1845 }
1846
1847 static void va_TraceVASliceParameterBufferVC1(
1848     VADisplay dpy,
1849     VAContextID context,
1850     VABufferID buffer,
1851     VABufferType type,
1852     unsigned int size,
1853     unsigned int num_elements,
1854     void* data
1855 )
1856 {
1857     VASliceParameterBufferVC1 *p = (VASliceParameterBufferVC1*)data;
1858     DPY2INDEX(dpy);
1859
1860     trace_context[idx].trace_slice_no++;
1861     trace_context[idx].trace_slice_size = p->slice_data_size;
1862
1863     va_TraceMsg(idx, "VASliceParameterBufferVC1\n");
1864     va_TraceMsg(idx, "\tslice_data_size = %d\n", p->slice_data_size);
1865     va_TraceMsg(idx, "\tslice_data_offset = %d\n", p->slice_data_offset);
1866     va_TraceMsg(idx, "\tslice_data_flag = %d\n", p->slice_data_flag);
1867     va_TraceMsg(idx, "\tmacroblock_offset = %d\n", p->macroblock_offset);
1868     va_TraceMsg(idx, "\tslice_vertical_position = %d\n", p->slice_vertical_position);
1869     va_TraceMsg(idx, NULL);
1870 }
1871
1872 void va_TraceBeginPicture(
1873     VADisplay dpy,
1874     VAContextID context,
1875     VASurfaceID render_target
1876 )
1877 {
1878     DPY2INDEX(dpy);
1879
1880     TRACE_FUNCNAME(idx);
1881
1882     va_TraceMsg(idx, "\tcontext = 0x%08x\n", context);
1883     va_TraceMsg(idx, "\trender_targets = 0x%08x\n", render_target);
1884     va_TraceMsg(idx, "\tframe_count  = #%d\n", trace_context[idx].trace_frame_no);
1885     va_TraceMsg(idx, NULL);
1886
1887     trace_context[idx].trace_rendertarget = render_target; /* for surface data dump after vaEndPicture */
1888
1889     trace_context[idx].trace_frame_no++;
1890     trace_context[idx].trace_slice_no = 0;
1891 }
1892
1893 static void va_TraceMPEG2Buf(
1894     VADisplay dpy,
1895     VAContextID context,
1896     VABufferID buffer,
1897     VABufferType type,
1898     unsigned int size,
1899     unsigned int num_elements,
1900     void *pbuf
1901 )
1902 {
1903     switch (type) {
1904     case VAPictureParameterBufferType:
1905         va_TraceVAPictureParameterBufferMPEG2(dpy, context, buffer, type, size, num_elements, pbuf);
1906         break;
1907     case VAIQMatrixBufferType:
1908         va_TraceVAIQMatrixBufferMPEG2(dpy, context, buffer, type, size, num_elements, pbuf);
1909         break;
1910     case VABitPlaneBufferType:
1911         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1912         break;
1913     case VASliceGroupMapBufferType:
1914         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1915         break;
1916     case VASliceParameterBufferType:
1917         va_TraceVASliceParameterBufferMPEG2(dpy, context, buffer, type, size, num_elements, pbuf);
1918         break;
1919     case VASliceDataBufferType:
1920         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1921         break;
1922     case VAMacroblockParameterBufferType:
1923         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1924         break;
1925     case VAResidualDataBufferType:
1926         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1927         break;
1928     case VADeblockingParameterBufferType:
1929         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1930         break;
1931     case VAImageBufferType:
1932         break;
1933     case VAProtectedSliceDataBufferType:
1934         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
1935         break;
1936     case VAEncCodedBufferType:
1937         break;
1938     case VAEncSequenceParameterBufferType:
1939         break;
1940     case VAEncPictureParameterBufferType:
1941         break;
1942     case VAEncSliceParameterBufferType:
1943         break;
1944     default:
1945         break;
1946     }
1947 }
1948
1949 static void va_TraceVAEncSequenceParameterBufferH263(
1950     VADisplay dpy,
1951     VAContextID context,
1952     VABufferID buffer,
1953     VABufferType type,
1954     unsigned int size,
1955     unsigned int num_elements,
1956     void *data)
1957 {
1958     VAEncSequenceParameterBufferH263 *p = (VAEncSequenceParameterBufferH263 *)data;
1959     DPY2INDEX(dpy);
1960
1961     va_TraceMsg(idx, "VAEncSequenceParameterBufferH263\n");
1962
1963     va_TraceMsg(idx, "\tintra_period = %d\n", p->intra_period);
1964     va_TraceMsg(idx, "\tbits_per_second = %d\n", p->bits_per_second);
1965     va_TraceMsg(idx, "\tframe_rate = %d\n", p->frame_rate);
1966     va_TraceMsg(idx, "\tinitial_qp = %d\n", p->initial_qp);
1967     va_TraceMsg(idx, "\tmin_qp = %d\n", p->min_qp);
1968     va_TraceMsg(idx, NULL);
1969
1970     /* start a new sequce, coded log file can be truncated */
1971     trace_context[idx].trace_sequence_start = 1;
1972
1973     return;
1974 }
1975
1976
1977 static void va_TraceVAEncPictureParameterBufferH263(
1978     VADisplay dpy,
1979     VAContextID context,
1980     VABufferID buffer,
1981     VABufferType type,
1982     unsigned int size,
1983     unsigned int num_elements,
1984     void *data)
1985 {
1986     VAEncPictureParameterBufferH263 *p = (VAEncPictureParameterBufferH263 *)data;
1987     DPY2INDEX(dpy);
1988
1989     va_TraceMsg(idx, "VAEncPictureParameterBufferH263\n");
1990     va_TraceMsg(idx, "\treference_picture = 0x%08x\n", p->reference_picture);
1991     va_TraceMsg(idx, "\treconstructed_picture = 0x%08x\n", p->reconstructed_picture);
1992     va_TraceMsg(idx, "\tcoded_buf = %08x\n", p->coded_buf);
1993     va_TraceMsg(idx, "\tpicture_width = %d\n", p->picture_width);
1994     va_TraceMsg(idx, "\tpicture_height = %d\n", p->picture_height);
1995     va_TraceMsg(idx, "\tpicture_type = 0x%08x\n", p->picture_type);
1996     va_TraceMsg(idx, NULL);
1997
1998     trace_context[idx].trace_codedbuf =  p->coded_buf;
1999
2000     return;
2001 }
2002
2003 static void va_TraceVAEncPictureParameterBufferJPEG(
2004     VADisplay dpy,
2005     VAContextID context,
2006     VABufferID buffer,
2007     VABufferType type,
2008     unsigned int size,
2009     unsigned int num_elements,
2010     void *data)
2011 {
2012     VAEncPictureParameterBufferJPEG *p = (VAEncPictureParameterBufferJPEG *)data;
2013     DPY2INDEX(dpy);
2014
2015     va_TraceMsg(idx, "VAEncPictureParameterBufferJPEG\n");
2016     va_TraceMsg(idx, "\treconstructed_picture = 0x%08x\n", p->reconstructed_picture);
2017     va_TraceMsg(idx, "\tcoded_buf = %08x\n", p->coded_buf);
2018     va_TraceMsg(idx, "\tpicture_width = %d\n", p->picture_width);
2019     va_TraceMsg(idx, "\tpicture_height = %d\n", p->picture_height);
2020     va_TraceMsg(idx, NULL);
2021
2022     trace_context[idx].trace_codedbuf =  p->coded_buf;
2023
2024     return;
2025 }
2026
2027 static void va_TraceVAEncQMatrixBufferJPEG(
2028     VADisplay dpy,
2029     VAContextID context,
2030     VABufferID buffer,
2031     VABufferType type,
2032     unsigned int size,
2033     unsigned int num_elements,
2034     void *data)
2035 {
2036     VAQMatrixBufferJPEG *p = (VAQMatrixBufferJPEG *)data;
2037     DPY2INDEX(dpy);
2038
2039     va_TraceMsg(idx, "VAQMatrixBufferJPEG\n");
2040     va_TraceMsg(idx, "\tload_lum_quantiser_matrix = %d", p->load_lum_quantiser_matrix);
2041     if (p->load_lum_quantiser_matrix) {
2042         int i;
2043         for (i = 0; i < 64; i++) {
2044             if ((i % 8) == 0)
2045                 va_TraceMsg(idx, "\n\t");
2046             va_TraceMsg(idx, "\t0x%02x", p->lum_quantiser_matrix[i]);
2047         }
2048         va_TraceMsg(idx, "\n");
2049     }
2050     va_TraceMsg(idx, "\tload_chroma_quantiser_matrix = %08x\n", p->load_chroma_quantiser_matrix);
2051     if (p->load_chroma_quantiser_matrix) {
2052         int i;
2053         for (i = 0; i < 64; i++) {
2054             if ((i % 8) == 0)
2055                 va_TraceMsg(idx, "\n\t");
2056             va_TraceMsg(idx, "\t0x%02x", p->chroma_quantiser_matrix[i]);
2057         }
2058         va_TraceMsg(idx, "\n");
2059     }
2060
2061     va_TraceMsg(idx, NULL);
2062
2063     return;
2064 }
2065
2066 static void va_TraceH263Buf(
2067     VADisplay dpy,
2068     VAContextID context,
2069     VABufferID buffer,
2070     VABufferType type,
2071     unsigned int size,
2072     unsigned int num_elements,
2073     void *pbuf
2074 )
2075 {
2076     switch (type) {
2077     case VAPictureParameterBufferType:/* print MPEG4 buffer */
2078         va_TraceVAPictureParameterBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
2079         break;
2080     case VAIQMatrixBufferType:/* print MPEG4 buffer */
2081         va_TraceVAIQMatrixBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
2082         break;
2083     case VABitPlaneBufferType:/* print MPEG4 buffer */
2084         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2085         break;
2086     case VASliceGroupMapBufferType:
2087         break;
2088     case VASliceParameterBufferType:/* print MPEG4 buffer */
2089         va_TraceVASliceParameterBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
2090         break;
2091     case VASliceDataBufferType:
2092         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2093         break;
2094     case VAMacroblockParameterBufferType:
2095         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2096         break;
2097     case VAResidualDataBufferType:
2098         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2099         break;
2100     case VADeblockingParameterBufferType:
2101         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2102         break;
2103     case VAImageBufferType:
2104         break;
2105     case VAProtectedSliceDataBufferType:
2106         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2107         break;
2108     case VAEncCodedBufferType:
2109         break;
2110     case VAEncSequenceParameterBufferType:
2111         va_TraceVAEncSequenceParameterBufferH263(dpy, context, buffer, type, size, num_elements, pbuf);
2112         break;
2113     case VAEncPictureParameterBufferType:
2114         va_TraceVAEncPictureParameterBufferH263(dpy, context, buffer, type, size, num_elements, pbuf);
2115         break;
2116     case VAEncSliceParameterBufferType:
2117         va_TraceVAEncSliceParameterBuffer(dpy, context, buffer, type, size, num_elements, pbuf);
2118         break;
2119     case VAEncPackedHeaderParameterBufferType:
2120         va_TraceVAEncPackedHeaderParameterBufferType(dpy, context, buffer, type, size, num_elements, pbuf);
2121         break;
2122     default:
2123         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2124         break;
2125     }
2126 }
2127
2128
2129 static void va_TraceJPEGBuf(
2130     VADisplay dpy,
2131     VAContextID context,
2132     VABufferID buffer,
2133     VABufferType type,
2134     unsigned int size,
2135     unsigned int num_elements,
2136     void *pbuf
2137 )
2138 {
2139     switch (type) {
2140     case VABitPlaneBufferType:
2141     case VASliceGroupMapBufferType:
2142     case VASliceDataBufferType:
2143     case VAMacroblockParameterBufferType:
2144     case VAResidualDataBufferType:
2145     case VADeblockingParameterBufferType:
2146     case VAImageBufferType:
2147     case VAProtectedSliceDataBufferType:
2148     case VAEncCodedBufferType:
2149     case VAEncSequenceParameterBufferType:
2150     case VAEncSliceParameterBufferType:
2151         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2152         break;
2153     case VAPictureParameterBufferType:
2154         va_TraceVAPictureParameterBufferJPEG(dpy, context, buffer, type, size, num_elements, pbuf);
2155         break;
2156     case VAIQMatrixBufferType:
2157         va_TraceVAIQMatrixBufferJPEG(dpy, context, buffer, type, size, num_elements, pbuf);
2158         break;
2159     case VASliceParameterBufferType:
2160         va_TraceVASliceParameterBufferJPEG(dpy, context, buffer, type, size, num_elements, pbuf);
2161         break;
2162     case VAHuffmanTableBufferType:
2163         va_TraceVAHuffmanTableBufferJPEG(dpy, context, buffer, type, size, num_elements, pbuf);
2164         break;
2165     case VAEncPictureParameterBufferType:
2166         va_TraceVAEncPictureParameterBufferJPEG(dpy, context, buffer, type, size, num_elements, pbuf);
2167         break;
2168     case VAQMatrixBufferType:
2169         va_TraceVAEncQMatrixBufferJPEG(dpy, context, buffer, type, size, num_elements, pbuf);
2170         break;
2171     default:
2172         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2173         break;
2174     }
2175 }
2176
2177 static void va_TraceMPEG4Buf(
2178     VADisplay dpy,
2179     VAContextID context,
2180     VABufferID buffer,
2181     VABufferType type,
2182     unsigned int size,
2183     unsigned int num_elements,
2184     void *pbuf
2185 )
2186 {
2187     switch (type) {
2188     case VAPictureParameterBufferType:
2189         va_TraceVAPictureParameterBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
2190         break;
2191     case VAIQMatrixBufferType:
2192         va_TraceVAIQMatrixBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
2193         break;
2194     case VABitPlaneBufferType:
2195         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2196         break;
2197     case VASliceGroupMapBufferType:
2198         break;
2199     case VASliceParameterBufferType:
2200         va_TraceVASliceParameterBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
2201         break;
2202     case VASliceDataBufferType:
2203         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2204         break;
2205     case VAMacroblockParameterBufferType:
2206         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2207         break;
2208     case VAResidualDataBufferType:
2209         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2210         break;
2211     case VADeblockingParameterBufferType:
2212         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2213         break;
2214     case VAImageBufferType:
2215         break;
2216     case VAProtectedSliceDataBufferType:
2217         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2218         break;
2219     case VAEncCodedBufferType:
2220         break;
2221     case VAEncSequenceParameterBufferType:
2222         va_TraceVAEncSequenceParameterBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
2223         break;
2224     case VAEncPictureParameterBufferType:
2225         va_TraceVAEncPictureParameterBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
2226         break;
2227     case VAEncSliceParameterBufferType:
2228         va_TraceVAEncSliceParameterBuffer(dpy, context, buffer, type, size, num_elements, pbuf);
2229         break;
2230     default:
2231         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2232         break;
2233     }
2234 }
2235
2236
2237 static void va_TraceH264Buf(
2238     VADisplay dpy,
2239     VAContextID context,
2240     VABufferID buffer,
2241     VABufferType type,
2242     unsigned int size,
2243     unsigned int num_elements,
2244     void *pbuf
2245 )
2246 {
2247     DPY2INDEX(dpy);
2248
2249     switch (type) {
2250     case VAPictureParameterBufferType:
2251         va_TraceVAPictureParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
2252         break;
2253     case VAIQMatrixBufferType:
2254         va_TraceVAIQMatrixBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
2255         break;
2256     case VABitPlaneBufferType:
2257         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2258         break;
2259     case VASliceGroupMapBufferType:
2260         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2261         break;
2262     case VASliceParameterBufferType:
2263         va_TraceVASliceParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
2264         break;
2265     case VASliceDataBufferType:
2266         va_TraceVABuffers(dpy, context, buffer, type, trace_context[idx].trace_slice_size, num_elements, pbuf);
2267         break;
2268     case VAMacroblockParameterBufferType:
2269         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2270         break;
2271     case VAResidualDataBufferType:
2272         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2273         break;
2274     case VADeblockingParameterBufferType:
2275         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2276         break;
2277     case VAImageBufferType:
2278         break;
2279     case VAProtectedSliceDataBufferType:
2280         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2281         break;
2282     case VAEncCodedBufferType:
2283         break;
2284     case VAEncSequenceParameterBufferType:
2285         va_TraceVAEncSequenceParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
2286         break;
2287     case VAEncPictureParameterBufferType:
2288         va_TraceVAEncPictureParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
2289         break;
2290     case VAEncSliceParameterBufferType:
2291         if (size == sizeof(VAEncSliceParameterBuffer))
2292             va_TraceVAEncSliceParameterBuffer(dpy, context, buffer, type, size, num_elements, pbuf);
2293         else
2294             va_TraceVAEncSliceParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
2295         break;
2296     case VAEncPackedHeaderParameterBufferType:
2297         va_TraceVAEncPackedHeaderParameterBufferType(dpy, context, buffer, type, size, num_elements, pbuf);
2298         break;
2299
2300     case VAEncMiscParameterBufferType:
2301         va_TraceVAEncMiscParameterBuffer(dpy, context, buffer, type, size, num_elements, pbuf);
2302         break;
2303     default:
2304         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2305         break;
2306     }
2307 }
2308
2309
2310 static void va_TraceVC1Buf(
2311     VADisplay dpy,
2312     VAContextID context,
2313     VABufferID buffer,
2314     VABufferType type,
2315     unsigned int size,
2316     unsigned int num_elements,
2317     void *pbuf
2318 )
2319 {
2320     DPY2INDEX(dpy);
2321
2322     switch (type) {
2323     case VAPictureParameterBufferType:
2324         va_TraceVAPictureParameterBufferVC1(dpy, context, buffer, type, size, num_elements, pbuf);
2325         break;
2326     case VAIQMatrixBufferType:
2327         break;
2328     case VABitPlaneBufferType:
2329         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2330         break;
2331     case VASliceGroupMapBufferType:
2332         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2333         break;
2334     case VASliceParameterBufferType:
2335         va_TraceVASliceParameterBufferVC1(dpy, context, buffer, type, size, num_elements, pbuf);
2336         break;
2337     case VASliceDataBufferType:
2338         va_TraceVABuffers(dpy, context, buffer, type, trace_context[idx].trace_slice_size, num_elements, pbuf);
2339         break;
2340     case VAMacroblockParameterBufferType:
2341         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2342         break;
2343     case VAResidualDataBufferType:
2344         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2345         break;
2346     case VADeblockingParameterBufferType:
2347         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2348         break;
2349     case VAImageBufferType:
2350         break;
2351     case VAProtectedSliceDataBufferType:
2352         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2353         break;
2354     case VAEncCodedBufferType:
2355         break;
2356     case VAEncSequenceParameterBufferType:
2357         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2358         break;
2359     case VAEncPictureParameterBufferType:
2360         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2361         break;
2362     case VAEncSliceParameterBufferType:
2363         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2364         break;
2365     default:
2366         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
2367         break;
2368     }
2369 }
2370
2371 void va_TraceRenderPicture(
2372     VADisplay dpy,
2373     VAContextID context,
2374     VABufferID *buffers,
2375     int num_buffers
2376 )
2377 {
2378     VABufferType type;
2379     unsigned int size;
2380     unsigned int num_elements;
2381     int i;
2382     DPY2INDEX(dpy);
2383
2384     TRACE_FUNCNAME(idx);
2385
2386     va_TraceMsg(idx, "\tcontext = 0x%08x\n", context);
2387     va_TraceMsg(idx, "\tnum_buffers = %d\n", num_buffers);
2388     for (i = 0; i < num_buffers; i++) {
2389         unsigned char *pbuf;
2390         unsigned int j;
2391
2392         /* get buffer type information */
2393         vaBufferInfo(dpy, context, buffers[i], &type, &size, &num_elements);
2394
2395         va_TraceMsg(idx, "\t---------------------------\n");
2396         va_TraceMsg(idx, "\tbuffers[%d] = 0x%08x\n", i, buffers[i]);
2397         va_TraceMsg(idx, "\t  type = %s\n", buffer_type_to_string(type));
2398         va_TraceMsg(idx, "\t  size = %d\n", size);
2399         va_TraceMsg(idx, "\t  num_elements = %d\n", num_elements);
2400
2401         vaMapBuffer(dpy, buffers[i], (void **)&pbuf);
2402
2403         switch (trace_context[idx].trace_profile) {
2404         case VAProfileMPEG2Simple:
2405         case VAProfileMPEG2Main:
2406             for (j=0; j<num_elements; j++) {
2407                 va_TraceMsg(idx, "\telement[%d] = ", j);
2408                 va_TraceMPEG2Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
2409             }
2410             break;
2411         case VAProfileMPEG4Simple:
2412         case VAProfileMPEG4AdvancedSimple:
2413         case VAProfileMPEG4Main:
2414             for (j=0; j<num_elements; j++) {
2415                 va_TraceMsg(idx, "\telement[%d] = ", j);
2416                 va_TraceMPEG4Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
2417             }
2418             break;
2419         case VAProfileH264Baseline:
2420         case VAProfileH264Main:
2421         case VAProfileH264High:
2422         case VAProfileH264ConstrainedBaseline:
2423             for (j=0; j<num_elements; j++) {
2424                 va_TraceMsg(idx, "\telement[%d] = ", j);
2425
2426                 va_TraceH264Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
2427             }
2428             break;
2429         case VAProfileVC1Simple:
2430         case VAProfileVC1Main:
2431         case VAProfileVC1Advanced:
2432             for (j=0; j<num_elements; j++) {
2433                 va_TraceMsg(idx, "\telement[%d] = ", j);
2434
2435                 va_TraceVC1Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
2436             }
2437             break;
2438         case VAProfileH263Baseline:
2439             for (j=0; j<num_elements; j++) {
2440                 va_TraceMsg(idx, "\telement[%d] = ", j);
2441
2442                 va_TraceH263Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
2443             }
2444             break;
2445         case VAProfileJPEGBaseline:
2446             for (j=0; j<num_elements; j++) {
2447                 va_TraceMsg(idx, "\telement[%d] = ", j);
2448
2449                 va_TraceJPEGBuf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
2450             }
2451             break;
2452         default:
2453             break;
2454         }
2455
2456         vaUnmapBuffer(dpy, buffers[i]);
2457     }
2458
2459     va_TraceMsg(idx, NULL);
2460 }
2461
2462 void va_TraceEndPicture(
2463     VADisplay dpy,
2464     VAContextID context,
2465     int endpic_done
2466 )
2467 {
2468     int encode, decode, jpeg;
2469     DPY2INDEX(dpy);
2470
2471     TRACE_FUNCNAME(idx);
2472
2473     va_TraceMsg(idx, "\tcontext = 0x%08x\n", context);
2474     va_TraceMsg(idx, "\trender_targets = 0x%08x\n", trace_context[idx].trace_rendertarget);
2475
2476     /* avoid to create so many empty files */
2477     encode = (trace_context[idx].trace_entrypoint == VAEntrypointEncSlice);
2478     decode = (trace_context[idx].trace_entrypoint == VAEntrypointVLD);
2479     jpeg = (trace_context[idx].trace_entrypoint == VAEntrypointEncPicture);
2480
2481     /* trace encode source surface, can do it before HW completes rendering */
2482     if ((encode && (trace_flag & VA_TRACE_FLAG_SURFACE_ENCODE))||
2483             (jpeg && (trace_flag & VA_TRACE_FLAG_SURFACE_JPEG)))
2484         va_TraceSurface(dpy);
2485
2486     /* trace coded buffer, do it after HW completes rendering */
2487     if ((encode || jpeg) && (trace_flag & VA_TRACE_FLAG_CODEDBUF)) {
2488         vaSyncSurface(dpy, trace_context[idx].trace_rendertarget);
2489         va_TraceCodedBuf(dpy);
2490     }
2491
2492     /* trace decoded surface, do it after HW completes rendering */
2493     if (decode && ((trace_flag & VA_TRACE_FLAG_SURFACE_DECODE))) {
2494         vaSyncSurface(dpy, trace_context[idx].trace_rendertarget);
2495         va_TraceSurface(dpy);
2496     }
2497
2498     va_TraceMsg(idx, NULL);
2499 }
2500
2501
2502 void va_TraceSyncSurface(
2503     VADisplay dpy,
2504     VASurfaceID render_target
2505 )
2506 {
2507     DPY2INDEX(dpy);
2508
2509     TRACE_FUNCNAME(idx);
2510
2511     va_TraceMsg(idx, "\trender_target = 0x%08x\n", render_target);
2512     va_TraceMsg(idx, NULL);
2513 }
2514
2515
2516 void va_TraceQuerySurfaceStatus(
2517     VADisplay dpy,
2518     VASurfaceID render_target,
2519     VASurfaceStatus *status    /* out */
2520 )
2521 {
2522     DPY2INDEX(dpy);
2523
2524     TRACE_FUNCNAME(idx);
2525
2526     va_TraceMsg(idx, "\trender_target = 0x%08x\n", render_target);
2527     va_TraceMsg(idx, "\tstatus = 0x%08x\n", *status);
2528     va_TraceMsg(idx, NULL);
2529 }
2530
2531
2532 void va_TraceQuerySurfaceError(
2533     VADisplay dpy,
2534     VASurfaceID surface,
2535     VAStatus error_status,
2536     void **error_info       /*out*/
2537 )
2538 {
2539     DPY2INDEX(dpy);
2540
2541     TRACE_FUNCNAME(idx);
2542     va_TraceMsg(idx, "\tsurface = 0x%08x\n", surface);
2543     va_TraceMsg(idx, "\terror_status = 0x%08x\n", error_status);
2544     if (error_status == VA_STATUS_ERROR_DECODING_ERROR) {
2545         VASurfaceDecodeMBErrors *p = *error_info;
2546         while (p->status != -1) {
2547             va_TraceMsg(idx, "\t\tstatus = %d\n", p->status);
2548             va_TraceMsg(idx, "\t\tstart_mb = %d\n", p->start_mb);
2549             va_TraceMsg(idx, "\t\tend_mb = %d\n", p->end_mb);
2550             p++; /* next error record */
2551         }
2552     }
2553     va_TraceMsg(idx, NULL);
2554 }
2555
2556 void va_TraceMaxNumDisplayAttributes (
2557     VADisplay dpy,
2558     int number
2559 )
2560 {
2561     DPY2INDEX(dpy);
2562
2563     TRACE_FUNCNAME(idx);
2564
2565     va_TraceMsg(idx, "\tmax_display_attributes = %d\n", number);
2566     va_TraceMsg(idx, NULL);
2567 }
2568
2569 void va_TraceQueryDisplayAttributes (
2570     VADisplay dpy,
2571     VADisplayAttribute *attr_list,    /* out */
2572     int *num_attributes               /* out */
2573 )
2574 {
2575     int i;
2576
2577     DPY2INDEX(dpy);
2578
2579     va_TraceMsg(idx, "\tnum_attributes = %d\n", *num_attributes);
2580
2581     for (i=0; i<*num_attributes; i++) {
2582         va_TraceMsg(idx, "\tattr_list[%d] =\n");
2583         va_TraceMsg(idx, "\t  typ = 0x%08x\n", attr_list[i].type);
2584         va_TraceMsg(idx, "\t  min_value = %d\n", attr_list[i].min_value);
2585         va_TraceMsg(idx, "\t  max_value = %d\n", attr_list[i].max_value);
2586         va_TraceMsg(idx, "\t  value = %d\n", attr_list[i].value);
2587         va_TraceMsg(idx, "\t  flags = %d\n", attr_list[i].flags);
2588     }
2589     va_TraceMsg(idx, NULL);
2590 }
2591
2592
2593 static void va_TraceDisplayAttributes (
2594     VADisplay dpy,
2595     VADisplayAttribute *attr_list,
2596     int num_attributes
2597 )
2598 {
2599     int i;
2600
2601     DPY2INDEX(dpy);
2602
2603     va_TraceMsg(idx, "\tnum_attributes = %d\n", num_attributes);
2604     for (i=0; i<num_attributes; i++) {
2605         va_TraceMsg(idx, "\tattr_list[%d] =\n");
2606         va_TraceMsg(idx, "\t  typ = 0x%08x\n", attr_list[i].type);
2607         va_TraceMsg(idx, "\t  min_value = %d\n", attr_list[i].min_value);
2608         va_TraceMsg(idx, "\t  max_value = %d\n", attr_list[i].max_value);
2609         va_TraceMsg(idx, "\t  value = %d\n", attr_list[i].value);
2610         va_TraceMsg(idx, "\t  flags = %d\n", attr_list[i].flags);
2611     }
2612     va_TraceMsg(idx, NULL);
2613 }
2614
2615
2616 void va_TraceGetDisplayAttributes (
2617     VADisplay dpy,
2618     VADisplayAttribute *attr_list,
2619     int num_attributes
2620 )
2621 {
2622     DPY2INDEX(dpy);
2623
2624     TRACE_FUNCNAME(idx);
2625
2626     va_TraceDisplayAttributes (dpy, attr_list, num_attributes);
2627 }
2628
2629 void va_TraceSetDisplayAttributes (
2630     VADisplay dpy,
2631     VADisplayAttribute *attr_list,
2632     int num_attributes
2633 )
2634 {
2635     DPY2INDEX(dpy);
2636
2637     TRACE_FUNCNAME(idx);
2638
2639     va_TraceDisplayAttributes (dpy, attr_list, num_attributes);
2640 }
2641
2642
2643 void va_TracePutSurface (
2644     VADisplay dpy,
2645     VASurfaceID surface,
2646     void *draw, /* the target Drawable */
2647     short srcx,
2648     short srcy,
2649     unsigned short srcw,
2650     unsigned short srch,
2651     short destx,
2652     short desty,
2653     unsigned short destw,
2654     unsigned short desth,
2655     VARectangle *cliprects, /* client supplied clip list */
2656     unsigned int number_cliprects, /* number of clip rects in the clip list */
2657     unsigned int flags /* de-interlacing flags */
2658 )
2659 {
2660     DPY2INDEX(dpy);
2661
2662     TRACE_FUNCNAME(idx);
2663
2664     va_TraceMsg(idx, "\tsurface = 0x%08x\n", surface);
2665     va_TraceMsg(idx, "\tdraw = 0x%08x\n", draw);
2666     va_TraceMsg(idx, "\tsrcx = %d\n", srcx);
2667     va_TraceMsg(idx, "\tsrcy = %d\n", srcy);
2668     va_TraceMsg(idx, "\tsrcw = %d\n", srcw);
2669     va_TraceMsg(idx, "\tsrch = %d\n", srch);
2670     va_TraceMsg(idx, "\tdestx = %d\n", destx);
2671     va_TraceMsg(idx, "\tdesty = %d\n", desty);
2672     va_TraceMsg(idx, "\tdestw = %d\n", destw);
2673     va_TraceMsg(idx, "\tdesth = %d\n", desth);
2674     va_TraceMsg(idx, "\tcliprects = 0x%08x\n", cliprects);
2675     va_TraceMsg(idx, "\tnumber_cliprects = %d\n", number_cliprects);
2676     va_TraceMsg(idx, "\tflags = 0x%08x\n", flags);
2677     va_TraceMsg(idx, NULL);
2678 }