va/va_trace.c

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