Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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