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 "va.h"
  28. #include "va_enc_h264.h"
  29. #include "va_backend.h"
  30. #include "va_trace.h"
  31. #include "va_enc_h264.h"
  32. #include "va_dec_jpeg.h"
  33. #include "va_dec_vp8.h"
  34. #include "va_vpp.h"
  35. #include <assert.h>
  36. #include <stdarg.h>
  37. #include <stdlib.h>
  38. #include <stdio.h>
  39. #include <string.h>
  40. #include <unistd.h>
  41. #include <sys/types.h>
  42. #include <sys/stat.h>
  43. #include <sys/time.h>
  44. #include <unistd.h>
  45. #include <errno.h>
  46.  
  47. /*
  48.  * Env. to debug some issue, e.g. the decode/encode issue in a video conference scenerio:
  49.  * .LIBVA_TRACE=log_file: general VA parameters saved into log_file
  50.  * .LIBVA_TRACE_BUFDATA: dump all VA data buffer into log_file
  51.  * .LIBVA_TRACE_CODEDBUF=coded_clip_file: save the coded clip into file coded_clip_file
  52.  * .LIBVA_TRACE_SURFACE=yuv_file: save surface YUV into file yuv_file. Use file name to determine
  53.  *                                decode/encode or jpeg surfaces
  54.  * .LIBVA_TRACE_SURFACE_GEOMETRY=WIDTHxHEIGHT+XOFF+YOFF: only save part of surface context into file
  55.  *                                due to storage bandwidth limitation
  56.  */
  57.  
  58. /* global settings */
  59.  
  60. /* LIBVA_TRACE */
  61. int trace_flag = 0;
  62.  
  63. /* per context settings */
  64. struct trace_context {
  65.     /* LIBVA_TRACE */
  66.     FILE *trace_fp_log; /* save the log into a file */
  67.     char *trace_log_fn; /* file name */
  68.  
  69.     /* LIBVA_TRACE_CODEDBUF */
  70.     FILE *trace_fp_codedbuf; /* save the encode result into a file */
  71.     char *trace_codedbuf_fn; /* file name */
  72.  
  73.     /* LIBVA_TRACE_SURFACE */
  74.     FILE *trace_fp_surface; /* save the surface YUV into a file */
  75.     char *trace_surface_fn; /* file name */
  76.  
  77.     VAContextID  trace_context; /* current context */
  78.  
  79.     VASurfaceID  trace_rendertarget; /* current render target */
  80.     VAProfile trace_profile; /* current profile for buffers */
  81.     VAEntrypoint trace_entrypoint; /* current entrypoint */
  82.  
  83.     unsigned int trace_frame_no; /* current frame NO */
  84.     unsigned int trace_slice_no; /* current slice NO */
  85.     unsigned int trace_slice_size; /* current slice buffer size */
  86.  
  87.     unsigned int trace_surface_width; /* surface dumping geometry */
  88.     unsigned int trace_surface_height;
  89.     unsigned int trace_surface_xoff;
  90.     unsigned int trace_surface_yoff;
  91.  
  92.     unsigned int trace_frame_width; /* current frame width */
  93.     unsigned int trace_frame_height; /* current frame height */
  94. };
  95.  
  96. #define TRACE_CTX(dpy) ((struct trace_context *)((VADisplayContextP)dpy)->vatrace)
  97.  
  98. #define DPY2TRACECTX(dpy)                               \
  99.     struct trace_context *trace_ctx = TRACE_CTX(dpy);   \
  100.                                                         \
  101.     if (trace_ctx == NULL)                              \
  102.         return;                                         \
  103.  
  104. #define TRACE_FUNCNAME(idx)    va_TraceMsg(trace_ctx, "==========%s\n", __func__);
  105.  
  106. /* Prototype declarations (functions defined in va.c) */
  107.  
  108. void va_errorMessage(const char *msg, ...);
  109. void va_infoMessage(const char *msg, ...);
  110.  
  111. int va_parseConfig(char *env, char *env_value);
  112.  
  113. VAStatus vaBufferInfo(
  114.     VADisplay dpy,
  115.     VAContextID context,        /* in */
  116.     VABufferID buf_id,          /* in */
  117.     VABufferType *type,         /* out */
  118.     unsigned int *size,         /* out */
  119.     unsigned int *num_elements  /* out */
  120.     );
  121.  
  122. VAStatus vaLockSurface(VADisplay dpy,
  123.                        VASurfaceID surface,
  124.                        unsigned int *fourcc, /* following are output argument */
  125.                        unsigned int *luma_stride,
  126.                        unsigned int *chroma_u_stride,
  127.                        unsigned int *chroma_v_stride,
  128.                        unsigned int *luma_offset,
  129.                        unsigned int *chroma_u_offset,
  130.                        unsigned int *chroma_v_offset,
  131.                        unsigned int *buffer_name,
  132.                        void **buffer
  133.                        );
  134.  
  135. VAStatus vaUnlockSurface(VADisplay dpy,
  136.                          VASurfaceID surface
  137.                          );
  138.  
  139. #define FILE_NAME_SUFFIX(env_value)                      \
  140. do {                                                    \
  141.     int tmp = strnlen(env_value, sizeof(env_value));    \
  142.     int left = sizeof(env_value) - tmp;                 \
  143.                                                         \
  144.     snprintf(env_value+tmp,                             \
  145.              left,                                      \
  146.              ".%04d.%08lx",                             \
  147.              suffix,                                    \
  148.              (unsigned long)trace_ctx);                 \
  149. } while (0)
  150.  
  151. void va_TraceInit(VADisplay dpy)
  152. {
  153.     char env_value[1024];
  154.     unsigned short suffix = 0xffff & ((unsigned int)time(NULL));
  155.     int trace_index = 0;
  156.     FILE *tmp;
  157.     struct trace_context *trace_ctx = calloc(sizeof(struct trace_context), 1);
  158.  
  159.     if (trace_ctx == NULL)
  160.         return;
  161.  
  162.     if (va_parseConfig("LIBVA_TRACE", &env_value[0]) == 0) {
  163.         FILE_NAME_SUFFIX(env_value);
  164.         trace_ctx->trace_log_fn = strdup(env_value);
  165.  
  166.         tmp = fopen(env_value, "w");
  167.         if (tmp) {
  168.             trace_ctx->trace_fp_log = tmp;
  169.             va_infoMessage("LIBVA_TRACE is on, save log into %s\n", trace_ctx->trace_log_fn);
  170.             trace_flag = VA_TRACE_FLAG_LOG;
  171.         } else
  172.             va_errorMessage("Open file %s failed (%s)\n", env_value, strerror(errno));
  173.     }
  174.  
  175.     /* may re-get the global settings for multiple context */
  176.     if ((trace_flag & VA_TRACE_FLAG_LOG) && (va_parseConfig("LIBVA_TRACE_BUFDATA", NULL) == 0)) {
  177.         trace_flag |= VA_TRACE_FLAG_BUFDATA;
  178.         va_infoMessage("LIBVA_TRACE_BUFDATA is on, dump buffer into log file\n");
  179.     }
  180.  
  181.     /* per-context setting */
  182.     if (va_parseConfig("LIBVA_TRACE_CODEDBUF", &env_value[0]) == 0) {
  183.         FILE_NAME_SUFFIX(env_value);
  184.         trace_ctx->trace_codedbuf_fn = strdup(env_value);
  185.         va_infoMessage("LIBVA_TRACE_CODEDBUF is on, save codedbuf into log file %s\n",
  186.                        trace_ctx->trace_codedbuf_fn);
  187.         trace_flag |= VA_TRACE_FLAG_CODEDBUF;
  188.     }
  189.  
  190.     if (va_parseConfig("LIBVA_TRACE_SURFACE", &env_value[0]) == 0) {
  191.         FILE_NAME_SUFFIX(env_value);
  192.         trace_ctx->trace_surface_fn = strdup(env_value);
  193.  
  194.         va_infoMessage("LIBVA_TRACE_SURFACE is on, save surface into %s\n",
  195.                        trace_ctx->trace_surface_fn);
  196.  
  197.         /* for surface data dump, it is time-consume, and may
  198.          * cause some side-effect, so only trace the needed surfaces
  199.          * to trace encode surface, set the trace file name to sth like *enc*
  200.          * to trace decode surface, set the trace file name to sth like *dec*
  201.          * if no dec/enc in file name, set both
  202.          */
  203.         if (strstr(env_value, "dec"))
  204.             trace_flag |= VA_TRACE_FLAG_SURFACE_DECODE;
  205.         if (strstr(env_value, "enc"))
  206.             trace_flag |= VA_TRACE_FLAG_SURFACE_ENCODE;
  207.         if (strstr(env_value, "jpeg") || strstr(env_value, "jpg"))
  208.             trace_flag |= VA_TRACE_FLAG_SURFACE_JPEG;
  209.  
  210.         if (va_parseConfig("LIBVA_TRACE_SURFACE_GEOMETRY", &env_value[0]) == 0) {
  211.             char *p = env_value, *q;
  212.  
  213.             trace_ctx->trace_surface_width = strtod(p, &q);
  214.             p = q+1; /* skip "x" */
  215.             trace_ctx->trace_surface_height = strtod(p, &q);
  216.             p = q+1; /* skip "+" */
  217.             trace_ctx->trace_surface_xoff = strtod(p, &q);
  218.             p = q+1; /* skip "+" */
  219.             trace_ctx->trace_surface_yoff = strtod(p, &q);
  220.  
  221.             va_infoMessage("LIBVA_TRACE_SURFACE_GEOMETRY is on, only dump surface %dx%d+%d+%d content\n",
  222.                            trace_ctx->trace_surface_width,
  223.                            trace_ctx->trace_surface_height,
  224.                            trace_ctx->trace_surface_xoff,
  225.                            trace_ctx->trace_surface_yoff);
  226.         }
  227.     }
  228.  
  229.     ((VADisplayContextP)dpy)->vatrace = trace_ctx;
  230. }
  231.  
  232.  
  233. void va_TraceEnd(VADisplay dpy)
  234. {
  235.     DPY2TRACECTX(dpy);
  236.  
  237.     if (trace_ctx->trace_fp_log)
  238.         fclose(trace_ctx->trace_fp_log);
  239.  
  240.     if (trace_ctx->trace_fp_codedbuf)
  241.         fclose(trace_ctx->trace_fp_codedbuf);
  242.  
  243.     if (trace_ctx->trace_fp_surface)
  244.         fclose(trace_ctx->trace_fp_surface);
  245.  
  246.     if (trace_ctx->trace_log_fn)
  247.         free(trace_ctx->trace_log_fn);
  248.  
  249.     if (trace_ctx->trace_codedbuf_fn)
  250.         free(trace_ctx->trace_codedbuf_fn);
  251.  
  252.     if (trace_ctx->trace_surface_fn)
  253.         free(trace_ctx->trace_surface_fn);
  254.  
  255.     free(trace_ctx);
  256.     ((VADisplayContextP)dpy)->vatrace = NULL;
  257. }
  258.  
  259.  
  260. void va_TraceMsg(struct trace_context *trace_ctx, const char *msg, ...)
  261. {
  262.     va_list args;
  263.  
  264.     if (!(trace_flag & VA_TRACE_FLAG_LOG))
  265.         return;
  266.  
  267.     if (msg)  {
  268.         struct timeval tv;
  269.  
  270.         if (gettimeofday(&tv, NULL) == 0)
  271.             fprintf(trace_ctx->trace_fp_log, "[%04d.%06d] ",
  272.                     (unsigned int)tv.tv_sec & 0xffff, (unsigned int)tv.tv_usec);
  273.         va_start(args, msg);
  274.         vfprintf(trace_ctx->trace_fp_log, msg, args);
  275.         va_end(args);
  276.     } else
  277.         fflush(trace_ctx->trace_fp_log);
  278. }
  279.  
  280.  
  281. void va_TraceSurface(VADisplay dpy)
  282. {
  283.     unsigned int i, j;
  284.     unsigned int fourcc; /* following are output argument */
  285.     unsigned int luma_stride;
  286.     unsigned int chroma_u_stride;
  287.     unsigned int chroma_v_stride;
  288.     unsigned int luma_offset;
  289.     unsigned int chroma_u_offset;
  290.     unsigned int chroma_v_offset;
  291.     unsigned int buffer_name;
  292.     void *buffer = NULL;
  293.     unsigned char *Y_data, *UV_data, *tmp;
  294.     VAStatus va_status;
  295.     unsigned char check_sum = 0;
  296.     DPY2TRACECTX(dpy);
  297.  
  298.     if (!trace_ctx->trace_fp_surface)
  299.         return;
  300.  
  301.     va_TraceMsg(trace_ctx, "==========dump surface data in file %s\n", trace_ctx->trace_surface_fn);
  302.  
  303.     va_TraceMsg(trace_ctx, NULL);
  304.  
  305.     va_status = vaLockSurface(
  306.         dpy,
  307.         trace_ctx->trace_rendertarget,
  308.         &fourcc,
  309.         &luma_stride, &chroma_u_stride, &chroma_v_stride,
  310.         &luma_offset, &chroma_u_offset, &chroma_v_offset,
  311.         &buffer_name, &buffer);
  312.  
  313.     if (va_status != VA_STATUS_SUCCESS) {
  314.         va_TraceMsg(trace_ctx, "Error:vaLockSurface failed\n");
  315.         return;
  316.     }
  317.  
  318.     va_TraceMsg(trace_ctx, "\tfourcc = 0x%08x\n", fourcc);
  319.     va_TraceMsg(trace_ctx, "\twidth = %d\n", trace_ctx->trace_frame_width);
  320.     va_TraceMsg(trace_ctx, "\theight = %d\n", trace_ctx->trace_frame_height);
  321.     va_TraceMsg(trace_ctx, "\tluma_stride = %d\n", luma_stride);
  322.     va_TraceMsg(trace_ctx, "\tchroma_u_stride = %d\n", chroma_u_stride);
  323.     va_TraceMsg(trace_ctx, "\tchroma_v_stride = %d\n", chroma_v_stride);
  324.     va_TraceMsg(trace_ctx, "\tluma_offset = %d\n", luma_offset);
  325.     va_TraceMsg(trace_ctx, "\tchroma_u_offset = %d\n", chroma_u_offset);
  326.     va_TraceMsg(trace_ctx, "\tchroma_v_offset = %d\n", chroma_v_offset);
  327.  
  328.     if (buffer == NULL) {
  329.         va_TraceMsg(trace_ctx, "Error:vaLockSurface return NULL buffer\n");
  330.         va_TraceMsg(trace_ctx, NULL);
  331.  
  332.         vaUnlockSurface(dpy, trace_ctx->trace_rendertarget);
  333.         return;
  334.     }
  335.     va_TraceMsg(trace_ctx, "\tbuffer location = 0x%08x\n", buffer);
  336.     va_TraceMsg(trace_ctx, NULL);
  337.  
  338.     Y_data = (unsigned char*)buffer;
  339.     UV_data = (unsigned char*)buffer + chroma_u_offset;
  340.  
  341.     tmp = Y_data + luma_stride * trace_ctx->trace_surface_yoff;
  342.     for (i=0; i<trace_ctx->trace_surface_height; i++) {
  343.         fwrite(tmp + trace_ctx->trace_surface_xoff,
  344.                trace_ctx->trace_surface_width,
  345.                1, trace_ctx->trace_fp_surface);
  346.  
  347.         tmp += luma_stride;
  348.     }
  349.     tmp = UV_data + chroma_u_stride * trace_ctx->trace_surface_yoff / 2;
  350.     if (fourcc == VA_FOURCC_NV12) {
  351.         for (i=0; i<trace_ctx->trace_surface_height/2; i++) {
  352.             fwrite(tmp + trace_ctx->trace_surface_xoff,
  353.                    trace_ctx->trace_surface_width,
  354.                    1, trace_ctx->trace_fp_surface);
  355.  
  356.             tmp += chroma_u_stride;
  357.         }
  358.     }
  359.  
  360.     vaUnlockSurface(dpy, trace_ctx->trace_rendertarget);
  361.  
  362.     va_TraceMsg(trace_ctx, NULL);
  363. }
  364.  
  365.  
  366. void va_TraceInitialize (
  367.     VADisplay dpy,
  368.     int *major_version,     /* out */
  369.     int *minor_version      /* out */
  370. )
  371. {
  372.     DPY2TRACECTX(dpy);
  373.     TRACE_FUNCNAME(idx);
  374. }
  375.  
  376. void va_TraceTerminate (
  377.     VADisplay dpy
  378. )
  379. {
  380.     DPY2TRACECTX(dpy);
  381.     TRACE_FUNCNAME(idx);
  382. }
  383.  
  384.  
  385. void va_TraceCreateConfig(
  386.     VADisplay dpy,
  387.     VAProfile profile,
  388.     VAEntrypoint entrypoint,
  389.     VAConfigAttrib *attrib_list,
  390.     int num_attribs,
  391.     VAConfigID *config_id /* out */
  392. )
  393. {
  394.     int i;
  395.     int encode, decode, jpeg;
  396.     DPY2TRACECTX(dpy);
  397.  
  398.     TRACE_FUNCNAME(idx);
  399.  
  400.     va_TraceMsg(trace_ctx, "\tprofile = %d\n", profile);
  401.     va_TraceMsg(trace_ctx, "\tentrypoint = %d\n", entrypoint);
  402.     va_TraceMsg(trace_ctx, "\tnum_attribs = %d\n", num_attribs);
  403.     if (attrib_list) {
  404.         for (i = 0; i < num_attribs; i++) {
  405.             va_TraceMsg(trace_ctx, "\t\tattrib_list[%d].type = 0x%08x\n", i, attrib_list[i].type);
  406.             va_TraceMsg(trace_ctx, "\t\tattrib_list[%d].value = 0x%08x\n", i, attrib_list[i].value);
  407.         }
  408.     }
  409.     va_TraceMsg(trace_ctx, NULL);
  410.  
  411.     trace_ctx->trace_profile = profile;
  412.     trace_ctx->trace_entrypoint = entrypoint;
  413.  
  414.     /* avoid to create so many empty files */
  415.     encode = (trace_ctx->trace_entrypoint == VAEntrypointEncSlice);
  416.     decode = (trace_ctx->trace_entrypoint == VAEntrypointVLD);
  417.     jpeg = (trace_ctx->trace_entrypoint == VAEntrypointEncPicture);
  418.     if ((encode && (trace_flag & VA_TRACE_FLAG_SURFACE_ENCODE)) ||
  419.         (decode && (trace_flag & VA_TRACE_FLAG_SURFACE_DECODE)) ||
  420.         (jpeg && (trace_flag & VA_TRACE_FLAG_SURFACE_JPEG))) {
  421.         FILE *tmp = fopen(trace_ctx->trace_surface_fn, "w");
  422.  
  423.         if (tmp)
  424.             trace_ctx->trace_fp_surface = tmp;
  425.         else {
  426.             va_errorMessage("Open file %s failed (%s)\n",
  427.                             trace_ctx->trace_surface_fn,
  428.                             strerror(errno));
  429.             trace_ctx->trace_fp_surface = NULL;
  430.             trace_flag &= ~(VA_TRACE_FLAG_SURFACE);
  431.         }
  432.     }
  433.  
  434.     if (encode && (trace_flag & VA_TRACE_FLAG_CODEDBUF)) {
  435.         FILE *tmp = fopen(trace_ctx->trace_codedbuf_fn, "w");
  436.  
  437.         if (tmp)
  438.             trace_ctx->trace_fp_codedbuf = tmp;
  439.         else {
  440.             va_errorMessage("Open file %s failed (%s)\n",
  441.                             trace_ctx->trace_codedbuf_fn,
  442.                             strerror(errno));
  443.             trace_ctx->trace_fp_codedbuf = NULL;
  444.             trace_flag &= ~VA_TRACE_FLAG_CODEDBUF;
  445.         }
  446.     }
  447. }
  448.  
  449. static void va_TraceSurfaceAttributes(
  450.     struct trace_context *trace_ctx,
  451.     VASurfaceAttrib    *attrib_list,
  452.     unsigned int       *num_attribs
  453. )
  454. {
  455.     int i, num;
  456.     VASurfaceAttrib *p;
  457.  
  458.     if (!attrib_list || !num_attribs)
  459.         return;
  460.  
  461.     p = attrib_list;
  462.     num = *num_attribs;
  463.     if (num > VASurfaceAttribCount)
  464.         num = VASurfaceAttribCount;
  465.  
  466.     for (i=0; i<num; i++) {
  467.         int type = p->value.type;
  468.  
  469.         va_TraceMsg(trace_ctx, "\tattrib_list[%i] =\n", i);
  470.  
  471.         va_TraceMsg(trace_ctx, "\t\ttype = %d\n", p->type);
  472.         va_TraceMsg(trace_ctx, "\t\tflags = %d\n", p->flags);
  473.         va_TraceMsg(trace_ctx, "\t\tvalue.type = %d\n", type);
  474.         switch (type) {
  475.         case VAGenericValueTypeInteger:
  476.             va_TraceMsg(trace_ctx, "\t\tvalue.value.i = 0x%08x\n", p->value.value.i);
  477.             break;
  478.         case VAGenericValueTypeFloat:
  479.             va_TraceMsg(trace_ctx, "\t\tvalue.value.f = %f\n", p->value.value.f);
  480.             break;
  481.         case VAGenericValueTypePointer:
  482.             va_TraceMsg(trace_ctx, "\t\tvalue.value.p = %p\n", p->value.value.p);
  483.             if ((p->type == VASurfaceAttribExternalBufferDescriptor) && p->value.value.p) {
  484.                 VASurfaceAttribExternalBuffers *tmp = (VASurfaceAttribExternalBuffers *) p->value.value.p;
  485.                 int j;
  486.  
  487.                 va_TraceMsg(trace_ctx, "\t\t--VASurfaceAttribExternalBufferDescriptor\n");
  488.                 va_TraceMsg(trace_ctx, "\t\t  pixel_format=0x%08x\n", tmp->pixel_format);
  489.                 va_TraceMsg(trace_ctx, "\t\t  width=%d\n", tmp->width);
  490.                 va_TraceMsg(trace_ctx, "\t\t  height=%d\n", tmp->height);
  491.                 va_TraceMsg(trace_ctx, "\t\t  data_size=%d\n", tmp->data_size);
  492.                 va_TraceMsg(trace_ctx, "\t\t  num_planes=%d\n", tmp->num_planes);
  493.                 va_TraceMsg(trace_ctx, "\t\t  pitches[4]=%d %d %d %d\n",
  494.                             tmp->pitches[0], tmp->pitches[1], tmp->pitches[2], tmp->pitches[3]);
  495.                 va_TraceMsg(trace_ctx, "\t\t  offsets[4]=%d %d %d %d\n",
  496.                             tmp->offsets[0], tmp->offsets[1], tmp->offsets[2], tmp->offsets[3]);
  497.                 va_TraceMsg(trace_ctx, "\t\t  flags=0x%08x\n", tmp->flags);
  498.                 va_TraceMsg(trace_ctx, "\t\t  num_buffers=0x%08x\n", tmp->num_buffers);
  499.                 va_TraceMsg(trace_ctx, "\t\t  buffers=%p\n", tmp->buffers);
  500.                 for (j = 0; j < tmp->num_buffers; j++) {
  501.                     va_TraceMsg(trace_ctx, "\t\t\tbuffers[%d]=%p\n", j, tmp->buffers[j]);
  502.                 }
  503.             }
  504.             break;
  505.         case VAGenericValueTypeFunc:
  506.             va_TraceMsg(trace_ctx, "\t\tvalue.value.fn = %p\n", p->value.value.fn);
  507.             break;
  508.         default:
  509.             break;
  510.         }
  511.  
  512.         p++;
  513.     }
  514. }
  515.  
  516. void va_TraceCreateSurfaces(
  517.     VADisplay dpy,
  518.     int width,
  519.     int height,
  520.     int format,
  521.     int num_surfaces,
  522.     VASurfaceID *surfaces,    /* out */
  523.     VASurfaceAttrib    *attrib_list,
  524.     unsigned int        num_attribs
  525. )
  526. {
  527.     int i;
  528.     DPY2TRACECTX(dpy);
  529.  
  530.     TRACE_FUNCNAME(idx);
  531.  
  532.     va_TraceMsg(trace_ctx, "\twidth = %d\n", width);
  533.     va_TraceMsg(trace_ctx, "\theight = %d\n", height);
  534.     va_TraceMsg(trace_ctx, "\tformat = %d\n", format);
  535.     va_TraceMsg(trace_ctx, "\tnum_surfaces = %d\n", num_surfaces);
  536.  
  537.     if (surfaces) {
  538.         for (i = 0; i < num_surfaces; i++)
  539.             va_TraceMsg(trace_ctx, "\t\tsurfaces[%d] = 0x%08x\n", i, surfaces[i]);
  540.     }
  541.  
  542.     va_TraceSurfaceAttributes(trace_ctx, attrib_list, &num_attribs);
  543.  
  544.     va_TraceMsg(trace_ctx, NULL);
  545. }
  546.  
  547.  
  548. void va_TraceDestroySurfaces(
  549.     VADisplay dpy,
  550.     VASurfaceID *surface_list,
  551.     int num_surfaces
  552. )
  553. {
  554.     int i;
  555.     DPY2TRACECTX(dpy);
  556.  
  557.     TRACE_FUNCNAME(idx);
  558.  
  559.     if (surface_list) {
  560.         for (i = 0; i < num_surfaces; i++)
  561.             va_TraceMsg(trace_ctx, "\t\tsurfaces[%d] = 0x%08x\n", i, surface_list[i]);
  562.     }
  563.  
  564.     va_TraceMsg(trace_ctx, NULL);
  565. }
  566.  
  567.  
  568. void va_TraceCreateContext(
  569.     VADisplay dpy,
  570.     VAConfigID config_id,
  571.     int picture_width,
  572.     int picture_height,
  573.     int flag,
  574.     VASurfaceID *render_targets,
  575.     int num_render_targets,
  576.     VAContextID *context        /* out */
  577. )
  578. {
  579.     int i;
  580.     DPY2TRACECTX(dpy);
  581.  
  582.     TRACE_FUNCNAME(idx);
  583.  
  584.     va_TraceMsg(trace_ctx, "\tconfig = 0x%08x\n", config_id);
  585.     va_TraceMsg(trace_ctx, "\twidth = %d\n", picture_width);
  586.     va_TraceMsg(trace_ctx, "\theight = %d\n", picture_height);
  587.     va_TraceMsg(trace_ctx, "\tflag = 0x%08x\n", flag);
  588.     va_TraceMsg(trace_ctx, "\tnum_render_targets = %d\n", num_render_targets);
  589.     if (render_targets) {
  590.         for (i=0; i<num_render_targets; i++)
  591.             va_TraceMsg(trace_ctx, "\t\trender_targets[%d] = 0x%08x\n", i, render_targets[i]);
  592.     }
  593.     if (context) {
  594.         va_TraceMsg(trace_ctx, "\tcontext = 0x%08x\n", *context);
  595.         trace_ctx->trace_context = *context;
  596.     } else
  597.         trace_ctx->trace_context = VA_INVALID_ID;
  598.  
  599.     trace_ctx->trace_frame_no = 0;
  600.     trace_ctx->trace_slice_no = 0;
  601.  
  602.     trace_ctx->trace_frame_width = picture_width;
  603.     trace_ctx->trace_frame_height = picture_height;
  604.  
  605.     if (trace_ctx->trace_surface_width == 0)
  606.         trace_ctx->trace_surface_width = picture_width;
  607.     if (trace_ctx->trace_surface_height == 0)
  608.         trace_ctx->trace_surface_height = picture_height;
  609. }
  610.  
  611.  
  612. static char * buffer_type_to_string(int type)
  613. {
  614.     switch (type) {
  615.     case VAPictureParameterBufferType: return "VAPictureParameterBufferType";
  616.     case VAIQMatrixBufferType: return "VAIQMatrixBufferType";
  617.     case VABitPlaneBufferType: return "VABitPlaneBufferType";
  618.     case VASliceGroupMapBufferType: return "VASliceGroupMapBufferType";
  619.     case VASliceParameterBufferType: return "VASliceParameterBufferType";
  620.     case VASliceDataBufferType: return "VASliceDataBufferType";
  621.     case VAProtectedSliceDataBufferType: return "VAProtectedSliceDataBufferType";
  622.     case VAMacroblockParameterBufferType: return "VAMacroblockParameterBufferType";
  623.     case VAResidualDataBufferType: return "VAResidualDataBufferType";
  624.     case VADeblockingParameterBufferType: return "VADeblockingParameterBufferType";
  625.     case VAImageBufferType: return "VAImageBufferType";
  626.     case VAQMatrixBufferType: return "VAQMatrixBufferType";
  627.     case VAHuffmanTableBufferType: return "VAHuffmanTableBufferType";
  628. /* Following are encode buffer types */
  629.     case VAEncCodedBufferType: return "VAEncCodedBufferType";
  630.     case VAEncSequenceParameterBufferType: return "VAEncSequenceParameterBufferType";
  631.     case VAEncPictureParameterBufferType: return "VAEncPictureParameterBufferType";
  632.     case VAEncSliceParameterBufferType: return "VAEncSliceParameterBufferType";
  633.     case VAEncPackedHeaderParameterBufferType: return "VAEncPackedHeaderParameterBufferType";
  634.     case VAEncPackedHeaderDataBufferType: return "VAEncPackedHeaderDataBufferType";
  635.     case VAEncMiscParameterBufferType: return "VAEncMiscParameterBufferType";
  636.     case VAEncMacroblockParameterBufferType: return "VAEncMacroblockParameterBufferType";
  637.     case VAProcPipelineParameterBufferType: return "VAProcPipelineParameterBufferType";
  638.     case VAProcFilterParameterBufferType: return "VAProcFilterParameterBufferType";
  639.     default: return "UnknowBuffer";
  640.     }
  641. }
  642.  
  643. void va_TraceCreateBuffer (
  644.     VADisplay dpy,
  645.     VAContextID context,        /* in */
  646.     VABufferType type,          /* in */
  647.     unsigned int size,          /* in */
  648.     unsigned int num_elements,  /* in */
  649.     void *data,                 /* in */
  650.     VABufferID *buf_id          /* out */
  651. )
  652. {
  653.     DPY2TRACECTX(dpy);
  654.  
  655.     /* only trace CodedBuffer */
  656.     if (type != VAEncCodedBufferType)
  657.         return;
  658.  
  659.     TRACE_FUNCNAME(idx);
  660.     va_TraceMsg(trace_ctx, "\tbuf_type=%s\n", buffer_type_to_string(type));
  661.     if (buf_id)
  662.         va_TraceMsg(trace_ctx, "\tbuf_id=0x%x\n", *buf_id);
  663.     va_TraceMsg(trace_ctx, "\tsize=%d\n", size);
  664.     va_TraceMsg(trace_ctx, "\tnum_elements=%d\n", num_elements);
  665.  
  666.     va_TraceMsg(trace_ctx, NULL);
  667. }
  668.  
  669. void va_TraceDestroyBuffer (
  670.     VADisplay dpy,
  671.     VABufferID buf_id    /* in */
  672. )
  673. {
  674.     VABufferType type;
  675.     unsigned int size;
  676.     unsigned int num_elements;
  677.  
  678.     VACodedBufferSegment *buf_list;
  679.     int i = 0;
  680.  
  681.     DPY2TRACECTX(dpy);
  682.  
  683.     vaBufferInfo(dpy, trace_ctx->trace_context, buf_id, &type, &size, &num_elements);
  684.  
  685.     /* only trace CodedBuffer */
  686.     if (type != VAEncCodedBufferType)
  687.         return;
  688.  
  689.     TRACE_FUNCNAME(idx);
  690.     va_TraceMsg(trace_ctx, "\tbuf_type=%s\n", buffer_type_to_string(type));
  691.     va_TraceMsg(trace_ctx, "\tbuf_id=0x%x\n", buf_id);
  692.     va_TraceMsg(trace_ctx, "\tsize=%d\n", size);
  693.     va_TraceMsg(trace_ctx, "\tnum_elements=%d\n", num_elements);
  694.  
  695.     va_TraceMsg(trace_ctx, NULL);
  696. }
  697.  
  698.  
  699. void va_TraceMapBuffer (
  700.     VADisplay dpy,
  701.     VABufferID buf_id,    /* in */
  702.     void **pbuf           /* out */
  703. )
  704. {
  705.     VABufferType type;
  706.     unsigned int size;
  707.     unsigned int num_elements;
  708.    
  709.     VACodedBufferSegment *buf_list;
  710.     int i = 0;
  711.    
  712.     DPY2TRACECTX(dpy);
  713.  
  714.     vaBufferInfo(dpy, trace_ctx->trace_context, buf_id, &type, &size, &num_elements);    
  715.    
  716.     /* only trace CodedBuffer */
  717.     if (type != VAEncCodedBufferType)
  718.         return;
  719.  
  720.     TRACE_FUNCNAME(idx);
  721.     va_TraceMsg(trace_ctx, "\tbuf_id=0x%x\n", buf_id);
  722.     va_TraceMsg(trace_ctx, "\tbuf_type=%s\n", buffer_type_to_string(type));
  723.     if ((pbuf == NULL) || (*pbuf == NULL))
  724.         return;
  725.    
  726.     buf_list = (VACodedBufferSegment *)(*pbuf);
  727.     while (buf_list != NULL) {
  728.         va_TraceMsg(trace_ctx, "\tCodedbuf[%d] =\n", i++);
  729.        
  730.         va_TraceMsg(trace_ctx, "\t   size = %d\n", buf_list->size);
  731.         va_TraceMsg(trace_ctx, "\t   bit_offset = %d\n", buf_list->bit_offset);
  732.         va_TraceMsg(trace_ctx, "\t   status = 0x%08x\n", buf_list->status);
  733.         va_TraceMsg(trace_ctx, "\t   reserved = 0x%08x\n", buf_list->reserved);
  734.         va_TraceMsg(trace_ctx, "\t   buf = 0x%08x\n", buf_list->buf);
  735.  
  736.         if (trace_ctx->trace_fp_codedbuf) {
  737.             va_TraceMsg(trace_ctx, "\tDump the content to file\n");
  738.             fwrite(buf_list->buf, buf_list->size, 1, trace_ctx->trace_fp_codedbuf);
  739.         }
  740.        
  741.         buf_list = buf_list->next;
  742.     }
  743.     va_TraceMsg(trace_ctx, NULL);
  744. }
  745.  
  746. static void va_TraceVABuffers(
  747.     VADisplay dpy,
  748.     VAContextID context,
  749.     VABufferID buffer,
  750.     VABufferType type,
  751.     unsigned int size,
  752.     unsigned int num_elements,
  753.     void *pbuf
  754. )
  755. {
  756.     unsigned int i;
  757.     unsigned char *p = pbuf;
  758.  
  759.     DPY2TRACECTX(dpy);
  760.    
  761.     va_TraceMsg(trace_ctx, "--%s\n",  buffer_type_to_string(type));
  762.  
  763.     if ((trace_flag & VA_TRACE_FLAG_BUFDATA) && trace_ctx->trace_fp_log) {
  764.         for (i=0; i<size; i++) {
  765.             unsigned char value =  p[i];
  766.  
  767.             if (i==0)
  768.                 fprintf(trace_ctx->trace_fp_log, "\t\t0x%04x:", i);
  769.             else if ((i%16) == 0)
  770.                 fprintf(trace_ctx->trace_fp_log, "\n\t\t0x%04x:", i);
  771.  
  772.             fprintf(trace_ctx->trace_fp_log, " %02x", value);
  773.         }
  774.         fprintf(trace_ctx->trace_fp_log, "\n");
  775.     }
  776.    
  777.     va_TraceMsg(trace_ctx, NULL);
  778.  
  779.     return;
  780. }
  781.  
  782.  
  783. static void va_TraceVAPictureParameterBufferMPEG2(
  784.     VADisplay dpy,
  785.     VAContextID context,
  786.     VABufferID buffer,
  787.     VABufferType type,
  788.     unsigned int size,
  789.     unsigned int num_elements,
  790.     void *data)
  791. {
  792.     VAPictureParameterBufferMPEG2 *p=(VAPictureParameterBufferMPEG2 *)data;
  793.     DPY2TRACECTX(dpy);
  794.  
  795.     va_TraceMsg(trace_ctx,"VAPictureParameterBufferMPEG2\n");
  796.  
  797.     va_TraceMsg(trace_ctx,"\thorizontal size= %d\n", p->horizontal_size);
  798.     va_TraceMsg(trace_ctx,"\tvertical size= %d\n", p->vertical_size);
  799.     va_TraceMsg(trace_ctx,"\tforward reference picture= %d\n", p->forward_reference_picture);
  800.     va_TraceMsg(trace_ctx,"\tbackward reference picture= %d\n", p->backward_reference_picture);
  801.     va_TraceMsg(trace_ctx,"\tpicture coding type= %d\n", p->picture_coding_type);
  802.     va_TraceMsg(trace_ctx,"\tf mode= %d\n", p->f_code);
  803.  
  804.     va_TraceMsg(trace_ctx,"\tpicture coding extension = %d\n", p->picture_coding_extension.value);
  805.     va_TraceMsg(trace_ctx,"\tintra_dc_precision= %d\n", p->picture_coding_extension.bits.intra_dc_precision);
  806.     va_TraceMsg(trace_ctx,"\tpicture_structure= %d\n", p->picture_coding_extension.bits.picture_structure);
  807.     va_TraceMsg(trace_ctx,"\ttop_field_first= %d\n", p->picture_coding_extension.bits.top_field_first);
  808.     va_TraceMsg(trace_ctx,"\tframe_pred_frame_dct= %d\n", p->picture_coding_extension.bits.frame_pred_frame_dct);
  809.     va_TraceMsg(trace_ctx,"\tconcealment_motion_vectors= %d\n", p->picture_coding_extension.bits.concealment_motion_vectors);
  810.     va_TraceMsg(trace_ctx,"\tq_scale_type= %d\n", p->picture_coding_extension.bits.q_scale_type);
  811.     va_TraceMsg(trace_ctx,"\tintra_vlc_format= %d\n", p->picture_coding_extension.bits.intra_vlc_format);
  812.     va_TraceMsg(trace_ctx,"\talternate_scan= %d\n", p->picture_coding_extension.bits.alternate_scan);
  813.     va_TraceMsg(trace_ctx,"\trepeat_first_field= %d\n", p->picture_coding_extension.bits.repeat_first_field);
  814.     va_TraceMsg(trace_ctx,"\tprogressive_frame= %d\n", p->picture_coding_extension.bits.progressive_frame);
  815.     va_TraceMsg(trace_ctx,"\tis_first_field= %d\n", p->picture_coding_extension.bits.is_first_field);
  816.     va_TraceMsg(trace_ctx, NULL);
  817.  
  818.     return;
  819. }
  820.  
  821.  
  822. static void va_TraceVAIQMatrixBufferMPEG2(
  823.     VADisplay dpy,
  824.     VAContextID context,
  825.     VABufferID buffer,
  826.     VABufferType type,
  827.     unsigned int size,
  828.     unsigned int num_elements,
  829.     void *data)
  830. {
  831.     VAIQMatrixBufferMPEG2 *p=(VAIQMatrixBufferMPEG2 *)data;
  832.     DPY2TRACECTX(dpy);
  833.  
  834.     va_TraceMsg(trace_ctx,"VAIQMatrixBufferMPEG2\n");
  835.  
  836.     va_TraceMsg(trace_ctx,"\tload_intra_quantiser_matrix = %d\n", p->load_intra_quantiser_matrix);
  837.     va_TraceMsg(trace_ctx,"\tload_non_intra_quantiser_matrix = %d\n", p->load_non_intra_quantiser_matrix);
  838.     va_TraceMsg(trace_ctx,"\tload_chroma_intra_quantiser_matrix = %d\n", p->load_chroma_intra_quantiser_matrix);
  839.     va_TraceMsg(trace_ctx,"\tload_chroma_non_intra_quantiser_matrix = %d\n", p->load_chroma_non_intra_quantiser_matrix);
  840.     va_TraceMsg(trace_ctx,"\tintra_quantiser_matrix = %d\n", p->intra_quantiser_matrix);
  841.     va_TraceMsg(trace_ctx,"\tnon_intra_quantiser_matrix = %d\n", p->non_intra_quantiser_matrix);
  842.     va_TraceMsg(trace_ctx,"\tchroma_intra_quantiser_matrix = %d\n", p->chroma_intra_quantiser_matrix);
  843.     va_TraceMsg(trace_ctx,"\tchroma_non_intra_quantiser_matrix = %d\n", p->chroma_non_intra_quantiser_matrix);
  844.     va_TraceMsg(trace_ctx, NULL);
  845.  
  846.     return;
  847. }
  848.  
  849.  
  850. static void va_TraceVASliceParameterBufferMPEG2(
  851.     VADisplay dpy,
  852.     VAContextID context,
  853.     VABufferID buffer,
  854.     VABufferType type,
  855.     unsigned int size,
  856.     unsigned int num_elements,
  857.     void *data)
  858. {
  859.     VASliceParameterBufferMPEG2 *p=(VASliceParameterBufferMPEG2 *)data;
  860.  
  861.     DPY2TRACECTX(dpy);
  862.  
  863.     trace_ctx->trace_slice_no++;
  864.    
  865.     trace_ctx->trace_slice_size = p->slice_data_size;
  866.  
  867.     va_TraceMsg(trace_ctx,"VASliceParameterBufferMPEG2\n");
  868.  
  869.     va_TraceMsg(trace_ctx,"\tslice_data_size = %d\n", p->slice_data_size);
  870.     va_TraceMsg(trace_ctx,"\tslice_data_offset = %d\n", p->slice_data_offset);
  871.     va_TraceMsg(trace_ctx,"\tslice_data_flag = %d\n", p->slice_data_flag);
  872.     va_TraceMsg(trace_ctx,"\tmacroblock_offset = %d\n", p->macroblock_offset);
  873.     va_TraceMsg(trace_ctx,"\tslice_horizontal_position = %d\n", p->slice_horizontal_position);
  874.     va_TraceMsg(trace_ctx,"\tslice_vertical_position = %d\n", p->slice_vertical_position);
  875.     va_TraceMsg(trace_ctx,"\tquantiser_scale_code = %d\n", p->quantiser_scale_code);
  876.     va_TraceMsg(trace_ctx,"\tintra_slice_flag = %d\n", p->intra_slice_flag);
  877.     va_TraceMsg(trace_ctx, NULL);
  878.  
  879.     return;
  880. }
  881.  
  882. static void va_TraceVAPictureParameterBufferJPEG(
  883.     VADisplay dpy,
  884.     VAContextID context,
  885.     VABufferID buffer,
  886.     VABufferType type,
  887.     unsigned int size,
  888.     unsigned int num_elements,
  889.     void *data)
  890. {
  891.     int i;
  892.     VAPictureParameterBufferJPEGBaseline *p=(VAPictureParameterBufferJPEGBaseline *)data;
  893.     DPY2TRACECTX(dpy);
  894.  
  895.     va_TraceMsg(trace_ctx,"*VAPictureParameterBufferJPEG\n");
  896.     va_TraceMsg(trace_ctx,"\tpicture_width = %u\n", p->picture_width);
  897.     va_TraceMsg(trace_ctx,"\tpicture_height = %u\n", p->picture_height);
  898.     va_TraceMsg(trace_ctx,"\tcomponents = \n");
  899.     for (i = 0; i < p->num_components && i < 255; ++i) {
  900.         va_TraceMsg(trace_ctx,"\t\t[%d] component_id = %u\n", i, p->components[i].component_id);
  901.         va_TraceMsg(trace_ctx,"\t\t[%d] h_sampling_factor = %u\n", i, p->components[i].h_sampling_factor);
  902.         va_TraceMsg(trace_ctx,"\t\t[%d] v_sampling_factor = %u\n", i, p->components[i].v_sampling_factor);
  903.         va_TraceMsg(trace_ctx,"\t\t[%d] quantiser_table_selector = %u\n", i, p->components[i].quantiser_table_selector);
  904.     }
  905. }
  906.  
  907. static void va_TraceVAIQMatrixBufferJPEG(
  908.     VADisplay dpy,
  909.     VAContextID context,
  910.     VABufferID buffer,
  911.     VABufferType type,
  912.     unsigned int size,
  913.     unsigned int num_elements,
  914.     void *data)
  915. {
  916.     int i, j;
  917.     static char tmp[1024];
  918.     VAIQMatrixBufferJPEGBaseline *p=(VAIQMatrixBufferJPEGBaseline *)data;
  919.     DPY2TRACECTX(dpy);
  920.     va_TraceMsg(trace_ctx,"*VAIQMatrixParameterBufferJPEG\n");
  921.     va_TraceMsg(trace_ctx,"\tload_quantiser_table =\n");
  922.     for (i = 0; i < 4; ++i) {
  923.         va_TraceMsg(trace_ctx,"\t\t[%d] = %u\n", i, p->load_quantiser_table[i]);
  924.     }
  925.     va_TraceMsg(trace_ctx,"\tquantiser_table =\n");
  926.     for (i = 0; i < 4; ++i) {
  927.         memset(tmp, 0, sizeof tmp);
  928.         for (j = 0; j < 64; ++j) {
  929.             sprintf(tmp + strlen(tmp), "%u ", p->quantiser_table[i][j]);
  930.         }
  931.         va_TraceMsg(trace_ctx,"\t\t[%d] = %s\n", i, tmp);
  932.     }
  933. }
  934.  
  935. static void va_TraceVASliceParameterBufferJPEG(
  936.     VADisplay dpy,
  937.     VAContextID context,
  938.     VABufferID buffer,
  939.     VABufferType type,
  940.     unsigned int size,
  941.     unsigned int num_elements,
  942.     void *data)
  943. {
  944.     int i;
  945.     VASliceParameterBufferJPEGBaseline *p=(VASliceParameterBufferJPEGBaseline *)data;
  946.     DPY2TRACECTX(dpy);
  947.     va_TraceMsg(trace_ctx,"*VASliceParameterBufferJPEG\n");
  948.     va_TraceMsg(trace_ctx,"\tslice_data_size = %u\n", p->slice_data_size);
  949.     va_TraceMsg(trace_ctx,"\tslice_data_offset = %u\n", p->slice_data_offset);
  950.     va_TraceMsg(trace_ctx,"\tslice_data_flag = %u\n", p->slice_data_flag);
  951.     va_TraceMsg(trace_ctx,"\tslice_horizontal_position = %u\n", p->slice_horizontal_position);
  952.     va_TraceMsg(trace_ctx,"\tslice_vertical_position = %u\n", p->slice_vertical_position);
  953.     va_TraceMsg(trace_ctx,"\tcomponents = \n");
  954.     for (i = 0; i < p->num_components && i < 4; ++i) {
  955.         va_TraceMsg(trace_ctx,"\t\t[%d] component_selector = %u\n", i, p->components[i].component_selector);
  956.         va_TraceMsg(trace_ctx,"\t\t[%d] dc_table_selector = %u\n", i, p->components[i].dc_table_selector);
  957.         va_TraceMsg(trace_ctx,"\t\t[%d] ac_table_selector = %u\n", i, p->components[i].ac_table_selector);
  958.     }
  959.     va_TraceMsg(trace_ctx,"\trestart_interval = %u\n", p->restart_interval);
  960.     va_TraceMsg(trace_ctx,"\tnum_mcus = %u\n", p->num_mcus);
  961. }
  962.  
  963. static void va_TraceVAHuffmanTableBufferJPEG(
  964.     VADisplay dpy,
  965.     VAContextID context,
  966.     VABufferID buffer,
  967.     VABufferType type,
  968.     unsigned int size,
  969.     unsigned int num_elements,
  970.     void *data)
  971. {
  972.     int i, j;
  973.     static char tmp[1024];
  974.     VAHuffmanTableBufferJPEGBaseline *p=(VAHuffmanTableBufferJPEGBaseline *)data;
  975.     DPY2TRACECTX(dpy);
  976.     va_TraceMsg(trace_ctx,"*VAHuffmanTableBufferJPEG\n");
  977.  
  978.     for (i = 0; i < 2; ++i) {
  979.         va_TraceMsg(trace_ctx,"\tload_huffman_table[%d] =%u\n", i, p->load_huffman_table[0]);
  980.         va_TraceMsg(trace_ctx,"\thuffman_table[%d] =\n", i);
  981.         memset(tmp, 0, sizeof tmp);
  982.         for (j = 0; j < 16; ++j) {
  983.             sprintf(tmp + strlen(tmp), "%u ", p->huffman_table[i].num_dc_codes[j]);
  984.         }
  985.         va_TraceMsg(trace_ctx,"\t\tnum_dc_codes =%s\n", tmp);
  986.         memset(tmp, 0, sizeof tmp);
  987.         for (j = 0; j < 12; ++j) {
  988.             sprintf(tmp + strlen(tmp), "%u ", p->huffman_table[i].dc_values[j]);
  989.         }
  990.         va_TraceMsg(trace_ctx,"\t\tdc_values =%s\n", tmp);
  991.         memset(tmp, 0, sizeof tmp);
  992.         for (j = 0; j < 16; ++j) {
  993.             sprintf(tmp + strlen(tmp), "%u ", p->huffman_table[i].num_ac_codes[j]);
  994.         }
  995.         va_TraceMsg(trace_ctx,"\t\tnum_dc_codes =%s\n", tmp);
  996.         memset(tmp, 0, sizeof tmp);
  997.         for (j = 0; j < 162; ++j) {
  998.             sprintf(tmp + strlen(tmp), "%u ", p->huffman_table[i].ac_values[j]);
  999.         }
  1000.         va_TraceMsg(trace_ctx,"\t\tnum_dc_codes =%s\n", tmp);
  1001.         memset(tmp, 0, sizeof tmp);
  1002.         for (j = 0; j < 2; ++j) {
  1003.             sprintf(tmp + strlen(tmp), "%u ", p->huffman_table[i].pad[j]);
  1004.         }
  1005.         va_TraceMsg(trace_ctx,"\t\tnum_dc_codes =%s\n", tmp);
  1006.     }
  1007. }
  1008.  
  1009. static void va_TraceVAPictureParameterBufferMPEG4(
  1010.     VADisplay dpy,
  1011.     VAContextID context,
  1012.     VABufferID buffer,
  1013.     VABufferType type,
  1014.     unsigned int size,
  1015.     unsigned int num_elements,
  1016.     void *data)
  1017. {
  1018.     int i;
  1019.     VAPictureParameterBufferMPEG4 *p=(VAPictureParameterBufferMPEG4 *)data;
  1020.    
  1021.     DPY2TRACECTX(dpy);
  1022.  
  1023.     va_TraceMsg(trace_ctx,"*VAPictureParameterBufferMPEG4\n");
  1024.     va_TraceMsg(trace_ctx,"\tvop_width = %d\n", p->vop_width);
  1025.     va_TraceMsg(trace_ctx,"\tvop_height = %d\n", p->vop_height);
  1026.     va_TraceMsg(trace_ctx,"\tforward_reference_picture = %d\n", p->forward_reference_picture);
  1027.     va_TraceMsg(trace_ctx,"\tbackward_reference_picture = %d\n", p->backward_reference_picture);
  1028.     va_TraceMsg(trace_ctx,"\tvol_fields value = %d\n", p->vol_fields.value);
  1029.     va_TraceMsg(trace_ctx,"\tshort_video_header= %d\n", p->vol_fields.bits.short_video_header);
  1030.     va_TraceMsg(trace_ctx,"\tchroma_format= %d\n", p->vol_fields.bits.chroma_format);
  1031.     va_TraceMsg(trace_ctx,"\tinterlaced= %d\n", p->vol_fields.bits.interlaced);
  1032.     va_TraceMsg(trace_ctx,"\tobmc_disable= %d\n", p->vol_fields.bits.obmc_disable);
  1033.     va_TraceMsg(trace_ctx,"\tsprite_enable= %d\n", p->vol_fields.bits.sprite_enable);
  1034.     va_TraceMsg(trace_ctx,"\tsprite_warping_accuracy= %d\n", p->vol_fields.bits.sprite_warping_accuracy);
  1035.     va_TraceMsg(trace_ctx,"\tquant_type= %d\n", p->vol_fields.bits.quant_type);
  1036.     va_TraceMsg(trace_ctx,"\tquarter_sample= %d\n", p->vol_fields.bits.quarter_sample);
  1037.     va_TraceMsg(trace_ctx,"\tdata_partitioned= %d\n", p->vol_fields.bits.data_partitioned);
  1038.     va_TraceMsg(trace_ctx,"\treversible_vlc= %d\n", p->vol_fields.bits.reversible_vlc);
  1039.     va_TraceMsg(trace_ctx,"\tresync_marker_disable= %d\n", p->vol_fields.bits.resync_marker_disable);
  1040.     va_TraceMsg(trace_ctx,"\tno_of_sprite_warping_points = %d\n", p->no_of_sprite_warping_points);
  1041.     va_TraceMsg(trace_ctx,"\tsprite_trajectory_du =");
  1042.     for(i=0;i<3;i++)
  1043.         va_TraceMsg(trace_ctx,"\t%d", p->sprite_trajectory_du[i]);
  1044.  
  1045.     va_TraceMsg(trace_ctx,"\n");
  1046.     va_TraceMsg(trace_ctx,"\tsprite_trajectory_dv =");
  1047.     for(i=0;i<3;i++)
  1048.         va_TraceMsg(trace_ctx,"\t%d", p->sprite_trajectory_dv[i]);
  1049.     va_TraceMsg(trace_ctx,"\n");
  1050.     va_TraceMsg(trace_ctx,"\tvop_fields value = %d\n", p->vop_fields.value);
  1051.     va_TraceMsg(trace_ctx,"\tvop_coding_type= %d\n", p->vop_fields.bits.vop_coding_type);
  1052.     va_TraceMsg(trace_ctx,"\tbackward_reference_vop_coding_type= %d\n", p->vop_fields.bits.backward_reference_vop_coding_type);
  1053.     va_TraceMsg(trace_ctx,"\tvop_rounding_type= %d\n", p->vop_fields.bits.vop_rounding_type);
  1054.     va_TraceMsg(trace_ctx,"\tintra_dc_vlc_thr= %d\n", p->vop_fields.bits.intra_dc_vlc_thr);
  1055.     va_TraceMsg(trace_ctx,"\ttop_field_first= %d\n", p->vop_fields.bits.top_field_first);
  1056.     va_TraceMsg(trace_ctx,"\talternate_vertical_scan_flag= %d\n", p->vop_fields.bits.alternate_vertical_scan_flag);
  1057.     va_TraceMsg(trace_ctx,"\tvop_fcode_forward = %d\n", p->vop_fcode_forward);
  1058.     va_TraceMsg(trace_ctx,"\tvop_fcode_backward = %d\n", p->vop_fcode_backward);
  1059.     va_TraceMsg(trace_ctx,"\tnum_gobs_in_vop = %d\n", p->num_gobs_in_vop);
  1060.     va_TraceMsg(trace_ctx,"\tnum_macroblocks_in_gob = %d\n", p->num_macroblocks_in_gob);
  1061.     va_TraceMsg(trace_ctx,"\tTRB = %d\n", p->TRB);
  1062.     va_TraceMsg(trace_ctx,"\tTRD = %d\n", p->TRD);
  1063.     va_TraceMsg(trace_ctx, NULL);
  1064.  
  1065.     return;
  1066. }
  1067.  
  1068.  
  1069. static void va_TraceVAIQMatrixBufferMPEG4(
  1070.     VADisplay dpy,
  1071.     VAContextID context,
  1072.     VABufferID buffer,
  1073.     VABufferType type,
  1074.     unsigned int size,
  1075.     unsigned int num_elements,
  1076.     void *data)
  1077. {
  1078.     int i;
  1079.     VAIQMatrixBufferMPEG4 *p=(VAIQMatrixBufferMPEG4 *)data;
  1080.     DPY2TRACECTX(dpy);
  1081.  
  1082.     va_TraceMsg(trace_ctx,"VAIQMatrixBufferMPEG4\n");
  1083.  
  1084.     va_TraceMsg(trace_ctx,"\tload_intra_quant_mat = %d\n", p->load_intra_quant_mat);
  1085.     va_TraceMsg(trace_ctx,"\tload_non_intra_quant_mat = %d\n", p->load_non_intra_quant_mat);
  1086.     va_TraceMsg(trace_ctx,"\tintra_quant_mat =\n");
  1087.     for(i=0;i<64;i++)
  1088.         va_TraceMsg(trace_ctx,"\t\t%d\n", p->intra_quant_mat[i]);
  1089.  
  1090.     va_TraceMsg(trace_ctx,"\tnon_intra_quant_mat =\n");
  1091.     for(i=0;i<64;i++)
  1092.         va_TraceMsg(trace_ctx,"\t\t%d\n", p->non_intra_quant_mat[i]);
  1093.     va_TraceMsg(trace_ctx, NULL);
  1094.  
  1095.     return;
  1096. }
  1097.  
  1098. static void va_TraceVAEncSequenceParameterBufferMPEG4(
  1099.     VADisplay dpy,
  1100.     VAContextID context,
  1101.     VABufferID buffer,
  1102.     VABufferType type,
  1103.     unsigned int size,
  1104.     unsigned int num_elements,
  1105.     void *data)
  1106. {
  1107.     VAEncSequenceParameterBufferMPEG4 *p = (VAEncSequenceParameterBufferMPEG4 *)data;
  1108.     DPY2TRACECTX(dpy);
  1109.    
  1110.     va_TraceMsg(trace_ctx, "\t--VAEncSequenceParameterBufferMPEG4\n");
  1111.    
  1112.     va_TraceMsg(trace_ctx, "\tprofile_and_level_indication = %d\n", p->profile_and_level_indication);
  1113.     va_TraceMsg(trace_ctx, "\tintra_period = %d\n", p->intra_period);
  1114.     va_TraceMsg(trace_ctx, "\tvideo_object_layer_width = %d\n", p->video_object_layer_width);
  1115.     va_TraceMsg(trace_ctx, "\tvideo_object_layer_height = %d\n", p->video_object_layer_height);
  1116.     va_TraceMsg(trace_ctx, "\tvop_time_increment_resolution = %d\n", p->vop_time_increment_resolution);
  1117.     va_TraceMsg(trace_ctx, "\tfixed_vop_rate = %d\n", p->fixed_vop_rate);
  1118.     va_TraceMsg(trace_ctx, "\tfixed_vop_time_increment = %d\n", p->fixed_vop_time_increment);
  1119.     va_TraceMsg(trace_ctx, "\tbits_per_second = %d\n", p->bits_per_second);
  1120.     va_TraceMsg(trace_ctx, "\tframe_rate = %d\n", p->frame_rate);
  1121.     va_TraceMsg(trace_ctx, "\tinitial_qp = %d\n", p->initial_qp);
  1122.     va_TraceMsg(trace_ctx, "\tmin_qp = %d\n", p->min_qp);
  1123.     va_TraceMsg(trace_ctx, NULL);
  1124.  
  1125.     return;
  1126. }
  1127.  
  1128. static void va_TraceVAEncPictureParameterBufferMPEG4(
  1129.     VADisplay dpy,
  1130.     VAContextID context,
  1131.     VABufferID buffer,
  1132.     VABufferType type,
  1133.     unsigned int size,
  1134.     unsigned int num_elements,
  1135.     void *data)
  1136. {
  1137.     VAEncPictureParameterBufferMPEG4 *p = (VAEncPictureParameterBufferMPEG4 *)data;
  1138.     DPY2TRACECTX(dpy);
  1139.    
  1140.     va_TraceMsg(trace_ctx, "\t--VAEncPictureParameterBufferMPEG4\n");
  1141.     va_TraceMsg(trace_ctx, "\treference_picture = 0x%08x\n", p->reference_picture);
  1142.     va_TraceMsg(trace_ctx, "\treconstructed_picture = 0x%08x\n", p->reconstructed_picture);
  1143.     va_TraceMsg(trace_ctx, "\tcoded_buf = 0x%08x\n", p->coded_buf);
  1144.     va_TraceMsg(trace_ctx, "\tpicture_width = %d\n", p->picture_width);
  1145.     va_TraceMsg(trace_ctx, "\tpicture_height = %d\n", p->picture_height);
  1146.     va_TraceMsg(trace_ctx, "\tmodulo_time_base = %d\n", p->modulo_time_base);
  1147.     va_TraceMsg(trace_ctx, "\tvop_time_increment = %d\n", p->vop_time_increment);
  1148.     va_TraceMsg(trace_ctx, "\tpicture_type = %d\n", p->picture_type);
  1149.     va_TraceMsg(trace_ctx, NULL);
  1150.  
  1151.     return;
  1152. }
  1153.  
  1154.  
  1155. static void va_TraceVASliceParameterBufferMPEG4(
  1156.     VADisplay dpy,
  1157.     VAContextID context,
  1158.     VABufferID buffer,
  1159.     VABufferType type,
  1160.     unsigned int size,
  1161.     unsigned int num_elements,
  1162.     void *data)
  1163. {
  1164.     VASliceParameterBufferMPEG4 *p=(VASliceParameterBufferMPEG4 *)data;
  1165.    
  1166.     DPY2TRACECTX(dpy);
  1167.  
  1168.     trace_ctx->trace_slice_no++;
  1169.  
  1170.     trace_ctx->trace_slice_size = p->slice_data_size;
  1171.  
  1172.     va_TraceMsg(trace_ctx,"VASliceParameterBufferMPEG4\n");
  1173.  
  1174.     va_TraceMsg(trace_ctx,"\tslice_data_size = %d\n", p->slice_data_size);
  1175.     va_TraceMsg(trace_ctx,"\tslice_data_offset = %d\n", p->slice_data_offset);
  1176.     va_TraceMsg(trace_ctx,"\tslice_data_flag = %d\n", p->slice_data_flag);
  1177.     va_TraceMsg(trace_ctx,"\tmacroblock_offset = %d\n", p->macroblock_offset);
  1178.     va_TraceMsg(trace_ctx,"\tmacroblock_number = %d\n", p->macroblock_number);
  1179.     va_TraceMsg(trace_ctx,"\tquant_scale = %d\n", p->quant_scale);
  1180.     va_TraceMsg(trace_ctx, NULL);
  1181.  
  1182.     return;
  1183. }
  1184.  
  1185.  
  1186. static inline void va_TraceFlagIfNotZero(
  1187.     struct trace_context *trace_ctx,
  1188.     const char *name,   /* in */
  1189.     unsigned int flag   /* in */
  1190. )
  1191. {
  1192.     if (flag != 0) {
  1193.         va_TraceMsg(trace_ctx, "%s = %x\n", name, flag);
  1194.     }
  1195. }
  1196.  
  1197.  
  1198. static void va_TraceVAPictureParameterBufferH264(
  1199.     VADisplay dpy,
  1200.     VAContextID context,
  1201.     VABufferID buffer,
  1202.     VABufferType type,
  1203.     unsigned int size,
  1204.     unsigned int num_elements,
  1205.     void *data)
  1206. {
  1207.     int i;
  1208.     VAPictureParameterBufferH264 *p = (VAPictureParameterBufferH264*)data;
  1209.    
  1210.     DPY2TRACECTX(dpy);
  1211.  
  1212.     va_TraceMsg(trace_ctx, "\t--VAPictureParameterBufferH264\n");
  1213.  
  1214.     va_TraceMsg(trace_ctx, "\tCurrPic.picture_id = 0x%08x\n", p->CurrPic.picture_id);
  1215.     va_TraceMsg(trace_ctx, "\tCurrPic.frame_idx = %d\n", p->CurrPic.frame_idx);
  1216.     va_TraceMsg(trace_ctx, "\tCurrPic.flags = %d\n", p->CurrPic.flags);
  1217.     va_TraceMsg(trace_ctx, "\tCurrPic.TopFieldOrderCnt = %d\n", p->CurrPic.TopFieldOrderCnt);
  1218.     va_TraceMsg(trace_ctx, "\tCurrPic.BottomFieldOrderCnt = %d\n", p->CurrPic.BottomFieldOrderCnt);
  1219.  
  1220.     va_TraceMsg(trace_ctx, "\tReferenceFrames (TopFieldOrderCnt-BottomFieldOrderCnt-picture_id-frame_idx-flags:\n");
  1221.     for (i = 0; i < 16; i++)
  1222.     {
  1223.         if ((p->ReferenceFrames[i].picture_id != VA_INVALID_SURFACE) &&
  1224.             ((p->ReferenceFrames[i].flags & VA_PICTURE_H264_INVALID) == 0)) {
  1225.             va_TraceMsg(trace_ctx, "\t\t%08d-%08d-0x%08x-%08d-0x%08x\n",
  1226.                         p->ReferenceFrames[i].TopFieldOrderCnt,
  1227.                         p->ReferenceFrames[i].BottomFieldOrderCnt,
  1228.                         p->ReferenceFrames[i].picture_id,
  1229.                         p->ReferenceFrames[i].frame_idx,
  1230.                         p->ReferenceFrames[i].flags);
  1231.         } else
  1232.             break;
  1233.     }
  1234.     va_TraceMsg(trace_ctx, "\tpicture_width_in_mbs_minus1 = %d\n", p->picture_width_in_mbs_minus1);
  1235.     va_TraceMsg(trace_ctx, "\tpicture_height_in_mbs_minus1 = %d\n", p->picture_height_in_mbs_minus1);
  1236.     va_TraceMsg(trace_ctx, "\tbit_depth_luma_minus8 = %d\n", p->bit_depth_luma_minus8);
  1237.     va_TraceMsg(trace_ctx, "\tbit_depth_chroma_minus8 = %d\n", p->bit_depth_chroma_minus8);
  1238.     va_TraceMsg(trace_ctx, "\tnum_ref_frames = %d\n", p->num_ref_frames);
  1239.     va_TraceMsg(trace_ctx, "\tseq fields = %d\n", p->seq_fields.value);
  1240.     va_TraceMsg(trace_ctx, "\tchroma_format_idc = %d\n", p->seq_fields.bits.chroma_format_idc);
  1241.     va_TraceMsg(trace_ctx, "\tresidual_colour_transform_flag = %d\n", p->seq_fields.bits.residual_colour_transform_flag);
  1242.     va_TraceMsg(trace_ctx, "\tframe_mbs_only_flag = %d\n", p->seq_fields.bits.frame_mbs_only_flag);
  1243.     va_TraceMsg(trace_ctx, "\tmb_adaptive_frame_field_flag = %d\n", p->seq_fields.bits.mb_adaptive_frame_field_flag);
  1244.     va_TraceMsg(trace_ctx, "\tdirect_8x8_inference_flag = %d\n", p->seq_fields.bits.direct_8x8_inference_flag);
  1245.     va_TraceMsg(trace_ctx, "\tMinLumaBiPredSize8x8 = %d\n", p->seq_fields.bits.MinLumaBiPredSize8x8);
  1246.     va_TraceMsg(trace_ctx, "\tnum_slice_groups_minus1 = %d\n", p->num_slice_groups_minus1);
  1247.     va_TraceMsg(trace_ctx, "\tslice_group_map_type = %d\n", p->slice_group_map_type);
  1248.     va_TraceMsg(trace_ctx, "\tslice_group_change_rate_minus1 = %d\n", p->slice_group_change_rate_minus1);
  1249.     va_TraceMsg(trace_ctx, "\tpic_init_qp_minus26 = %d\n", p->pic_init_qp_minus26);
  1250.     va_TraceMsg(trace_ctx, "\tpic_init_qs_minus26 = %d\n", p->pic_init_qs_minus26);
  1251.     va_TraceMsg(trace_ctx, "\tchroma_qp_index_offset = %d\n", p->chroma_qp_index_offset);
  1252.     va_TraceMsg(trace_ctx, "\tsecond_chroma_qp_index_offset = %d\n", p->second_chroma_qp_index_offset);
  1253.     va_TraceMsg(trace_ctx, "\tpic_fields = 0x%03x\n", p->pic_fields.value);
  1254.     va_TraceFlagIfNotZero(trace_ctx, "\t\tentropy_coding_mode_flag", p->pic_fields.bits.entropy_coding_mode_flag);
  1255.     va_TraceFlagIfNotZero(trace_ctx, "\t\tweighted_pred_flag", p->pic_fields.bits.weighted_pred_flag);
  1256.     va_TraceFlagIfNotZero(trace_ctx, "\t\tweighted_bipred_idc", p->pic_fields.bits.weighted_bipred_idc);
  1257.     va_TraceFlagIfNotZero(trace_ctx, "\t\ttransform_8x8_mode_flag", p->pic_fields.bits.transform_8x8_mode_flag);
  1258.     va_TraceFlagIfNotZero(trace_ctx, "\t\tfield_pic_flag", p->pic_fields.bits.field_pic_flag);
  1259.     va_TraceFlagIfNotZero(trace_ctx, "\t\tconstrained_intra_pred_flag", p->pic_fields.bits.constrained_intra_pred_flag);
  1260.     va_TraceFlagIfNotZero(trace_ctx, "\t\tpic_order_present_flag", p->pic_fields.bits.pic_order_present_flag);
  1261.     va_TraceFlagIfNotZero(trace_ctx, "\t\tdeblocking_filter_control_present_flag", p->pic_fields.bits.deblocking_filter_control_present_flag);
  1262.     va_TraceFlagIfNotZero(trace_ctx, "\t\tredundant_pic_cnt_present_flag", p->pic_fields.bits.redundant_pic_cnt_present_flag);
  1263.     va_TraceFlagIfNotZero(trace_ctx, "\t\treference_pic_flag", p->pic_fields.bits.reference_pic_flag);
  1264.     va_TraceMsg(trace_ctx, "\tframe_num = %d\n", p->frame_num);
  1265.     va_TraceMsg(trace_ctx, NULL);
  1266.  
  1267.     return;
  1268. }
  1269.  
  1270. static void va_TraceVASliceParameterBufferH264(
  1271.     VADisplay dpy,
  1272.     VAContextID context,
  1273.     VABufferID buffer,
  1274.     VABufferType type,
  1275.     unsigned int size,
  1276.     unsigned int num_elements,
  1277.     void *data)
  1278. {
  1279.     int i;
  1280.     VASliceParameterBufferH264* p = (VASliceParameterBufferH264*)data;
  1281.     DPY2TRACECTX(dpy);
  1282.  
  1283.     trace_ctx->trace_slice_no++;
  1284.     trace_ctx->trace_slice_size = p->slice_data_size;
  1285.  
  1286.     va_TraceMsg(trace_ctx, "\t--VASliceParameterBufferH264\n");
  1287.     va_TraceMsg(trace_ctx, "\tslice_data_size = %d\n", p->slice_data_size);
  1288.     va_TraceMsg(trace_ctx, "\tslice_data_offset = %d\n", p->slice_data_offset);
  1289.     va_TraceMsg(trace_ctx, "\tslice_data_flag = %d\n", p->slice_data_flag);
  1290.     va_TraceMsg(trace_ctx, "\tslice_data_bit_offset = %d\n", p->slice_data_bit_offset);
  1291.     va_TraceMsg(trace_ctx, "\tfirst_mb_in_slice = %d\n", p->first_mb_in_slice);
  1292.     va_TraceMsg(trace_ctx, "\tslice_type = %d\n", p->slice_type);
  1293.     va_TraceMsg(trace_ctx, "\tdirect_spatial_mv_pred_flag = %d\n", p->direct_spatial_mv_pred_flag);
  1294.     va_TraceMsg(trace_ctx, "\tnum_ref_idx_l0_active_minus1 = %d\n", p->num_ref_idx_l0_active_minus1);
  1295.     va_TraceMsg(trace_ctx, "\tnum_ref_idx_l1_active_minus1 = %d\n", p->num_ref_idx_l1_active_minus1);
  1296.     va_TraceMsg(trace_ctx, "\tcabac_init_idc = %d\n", p->cabac_init_idc);
  1297.     va_TraceMsg(trace_ctx, "\tslice_qp_delta = %d\n", p->slice_qp_delta);
  1298.     va_TraceMsg(trace_ctx, "\tdisable_deblocking_filter_idc = %d\n", p->disable_deblocking_filter_idc);
  1299.     va_TraceMsg(trace_ctx, "\tslice_alpha_c0_offset_div2 = %d\n", p->slice_alpha_c0_offset_div2);
  1300.     va_TraceMsg(trace_ctx, "\tslice_beta_offset_div2 = %d\n", p->slice_beta_offset_div2);
  1301.  
  1302.     va_TraceMsg(trace_ctx, "\tRefPicList0 =\n");
  1303.     for (i = 0; i < 32; i++) {
  1304.         if ((p->RefPicList0[i].picture_id != VA_INVALID_SURFACE) &&
  1305.             ((p->RefPicList0[i].flags & VA_PICTURE_H264_INVALID) == 0))
  1306.         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);
  1307.         else
  1308.             break;
  1309.     }
  1310.     va_TraceMsg(trace_ctx, "\tRefPicList1 =\n");
  1311.     for (i = 0; i < 32; i++) {
  1312.         if ((p->RefPicList1[i].picture_id != VA_INVALID_SURFACE) &&
  1313.             ((p->RefPicList1[i].flags & VA_PICTURE_H264_INVALID) == 0))
  1314.             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);
  1315.         else
  1316.             break;
  1317.     }
  1318.  
  1319.     va_TraceMsg(trace_ctx, "\tluma_log2_weight_denom = %d\n", p->luma_log2_weight_denom);
  1320.     va_TraceMsg(trace_ctx, "\tchroma_log2_weight_denom = %d\n", p->chroma_log2_weight_denom);
  1321.     va_TraceMsg(trace_ctx, "\tluma_weight_l0_flag = %d\n", p->luma_weight_l0_flag);
  1322.  
  1323.     for (i = 0; (i <= p->num_ref_idx_l0_active_minus1) && (i<32); i++) {
  1324.         va_TraceMsg(trace_ctx, "\t\t%d\t%d\n",
  1325.             p->luma_weight_l0[i],
  1326.             p->luma_offset_l0[i]);
  1327.     }
  1328.  
  1329.  
  1330.     va_TraceMsg(trace_ctx, "\tchroma_weight_l0_flag = %d\n", p->chroma_weight_l0_flag);
  1331.  
  1332.     for (i = 0; (i <= p->num_ref_idx_l0_active_minus1) && (i<32); i++) {
  1333.         va_TraceMsg(trace_ctx, "\t\t%d\t%d\t%d\t%d\n",
  1334.             p->chroma_weight_l0[i][0],
  1335.             p->chroma_offset_l0[i][0],
  1336.             p->chroma_weight_l0[i][1],
  1337.             p->chroma_offset_l0[i][1]);
  1338.     }
  1339.  
  1340.  
  1341.     va_TraceMsg(trace_ctx, "\tluma_weight_l1_flag = %d\n", p->luma_weight_l1_flag);
  1342.  
  1343.     for (i = 0; (i <=  p->num_ref_idx_l1_active_minus1) && (i<32); i++) {
  1344.         va_TraceMsg(trace_ctx, "\t\t%d\t%d\n",
  1345.             p->luma_weight_l1[i],
  1346.             p->luma_offset_l1[i]);
  1347.     }
  1348.  
  1349.  
  1350.     va_TraceMsg(trace_ctx, "\tchroma_weight_l1_flag = %d\n", p->chroma_weight_l1_flag);
  1351.  
  1352.     for (i = 0; (i <= p->num_ref_idx_l1_active_minus1) && (i<32); i++) {
  1353.         va_TraceMsg(trace_ctx, "\t\t%d\t%d\t%d\t%d\n",
  1354.             p->chroma_weight_l1[i][0],
  1355.             p->chroma_offset_l1[i][0],
  1356.             p->chroma_weight_l1[i][1],
  1357.             p->chroma_offset_l1[i][1]);
  1358.  
  1359.     }
  1360.     va_TraceMsg(trace_ctx, NULL);
  1361. }
  1362.  
  1363. static void va_TraceVAIQMatrixBufferH264(
  1364.     VADisplay dpy,
  1365.     VAContextID context,
  1366.     VABufferID buffer,
  1367.     VABufferType type,
  1368.     unsigned int size,
  1369.     unsigned int num_elements,
  1370.     void *data
  1371. )
  1372. {
  1373.     int i, j;
  1374.     VAIQMatrixBufferH264* p = (VAIQMatrixBufferH264* )data;
  1375.  
  1376.     DPY2TRACECTX(dpy);
  1377.  
  1378.     va_TraceMsg(trace_ctx, "\t--VAIQMatrixBufferH264\n");
  1379.  
  1380.     va_TraceMsg(trace_ctx, "\tScalingList4x4[6][16]=\n");
  1381.     for (i = 0; i < 6; i++) {
  1382.         for (j = 0; j < 16; j++) {
  1383.             if (trace_ctx->trace_fp_log) {
  1384.                 fprintf(trace_ctx->trace_fp_log, "\t%d", p->ScalingList4x4[i][j]);
  1385.                 if ((j + 1) % 8 == 0)
  1386.                     fprintf(trace_ctx->trace_fp_log, "\n");
  1387.             }
  1388.         }
  1389.     }
  1390.  
  1391.     va_TraceMsg(trace_ctx, "\tScalingList8x8[2][64]=\n");
  1392.     for (i = 0; i < 2; i++) {
  1393.         for (j = 0; j < 64; j++) {
  1394.             if (trace_ctx->trace_fp_log) {
  1395.                 fprintf(trace_ctx->trace_fp_log,"\t%d", p->ScalingList8x8[i][j]);
  1396.                 if ((j + 1) % 8 == 0)
  1397.                     fprintf(trace_ctx->trace_fp_log, "\n");
  1398.             }
  1399.         }
  1400.     }
  1401.  
  1402.     va_TraceMsg(trace_ctx, NULL);
  1403. }
  1404.  
  1405.  
  1406.  
  1407. static void va_TraceVAEncSequenceParameterBufferH264(
  1408.     VADisplay dpy,
  1409.     VAContextID context,
  1410.     VABufferID buffer,
  1411.     VABufferType type,
  1412.     unsigned int size,
  1413.     unsigned int num_elements,
  1414.     void *data)
  1415. {
  1416.     VAEncSequenceParameterBufferH264 *p = (VAEncSequenceParameterBufferH264 *)data;
  1417.     DPY2TRACECTX(dpy);
  1418.     unsigned int i;
  1419.  
  1420.     va_TraceMsg(trace_ctx, "\t--VAEncSequenceParameterBufferH264\n");
  1421.  
  1422.     va_TraceMsg(trace_ctx, "\tseq_parameter_set_id = %d\n", p->seq_parameter_set_id);
  1423.     va_TraceMsg(trace_ctx, "\tlevel_idc = %d\n", p->level_idc);
  1424.     va_TraceMsg(trace_ctx, "\tintra_period = %d\n", p->intra_period);
  1425.     va_TraceMsg(trace_ctx, "\tintra_idr_period = %d\n", p->intra_idr_period);
  1426.     va_TraceMsg(trace_ctx, "\tip_period = %d\n", p->ip_period);
  1427.     va_TraceMsg(trace_ctx, "\tbits_per_second = %d\n", p->bits_per_second);
  1428.     va_TraceMsg(trace_ctx, "\tmax_num_ref_frames = %d\n", p->max_num_ref_frames);
  1429.     va_TraceMsg(trace_ctx, "\tpicture_width_in_mbs = %d\n", p->picture_width_in_mbs);
  1430.     va_TraceMsg(trace_ctx, "\tpicture_height_in_mbs = %d\n", p->picture_height_in_mbs);
  1431.     va_TraceMsg(trace_ctx, "\tchroma_format_idc = %d\n", p->seq_fields.bits.chroma_format_idc);
  1432.     va_TraceMsg(trace_ctx, "\tframe_mbs_only_flag = %d\n", p->seq_fields.bits.frame_mbs_only_flag);
  1433.     va_TraceMsg(trace_ctx, "\tmb_adaptive_frame_field_flag = %d\n", p->seq_fields.bits.mb_adaptive_frame_field_flag);
  1434.     va_TraceMsg(trace_ctx, "\tseq_scaling_matrix_present_flag = %d\n", p->seq_fields.bits.seq_scaling_matrix_present_flag);
  1435.     va_TraceMsg(trace_ctx, "\tdirect_8x8_inference_flag = %d\n", p->seq_fields.bits.direct_8x8_inference_flag);
  1436.     va_TraceMsg(trace_ctx, "\tlog2_max_frame_num_minus4 = %d\n", p->seq_fields.bits.log2_max_frame_num_minus4);
  1437.     va_TraceMsg(trace_ctx, "\tpic_order_cnt_type = %d\n", p->seq_fields.bits.pic_order_cnt_type);
  1438.     va_TraceMsg(trace_ctx, "\tlog2_max_pic_order_cnt_lsb_minus4 = %d\n", p->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4);
  1439.     va_TraceMsg(trace_ctx, "\tdelta_pic_order_always_zero_flag = %d\n", p->seq_fields.bits.delta_pic_order_always_zero_flag);
  1440.     va_TraceMsg(trace_ctx, "\tbit_depth_luma_minus8 = %d\n", p->bit_depth_luma_minus8);
  1441.     va_TraceMsg(trace_ctx, "\tbit_depth_chroma_minus8 = %d\n", p->bit_depth_chroma_minus8);
  1442.     va_TraceMsg(trace_ctx, "\tnum_ref_frames_in_pic_order_cnt_cycle = %d\n", p->num_ref_frames_in_pic_order_cnt_cycle);
  1443.     va_TraceMsg(trace_ctx, "\toffset_for_non_ref_pic = %d\n", p->offset_for_non_ref_pic);
  1444.     va_TraceMsg(trace_ctx, "\toffset_for_top_to_bottom_field = %d\n", p->offset_for_top_to_bottom_field);
  1445.     for(i = 0; (i < p->max_num_ref_frames) && (i < 32); ++i)
  1446.         va_TraceMsg(trace_ctx, "\toffset_for_ref_frame[%d] = %d\n", i, p->offset_for_ref_frame[i]);
  1447.     va_TraceMsg(trace_ctx, "\tframe_cropping_flag = %d\n", p->frame_cropping_flag);
  1448.     va_TraceMsg(trace_ctx, "\tframe_crop_left_offset = %d\n", p->frame_crop_left_offset);
  1449.     va_TraceMsg(trace_ctx, "\tframe_crop_right_offset = %d\n", p->frame_crop_right_offset);
  1450.     va_TraceMsg(trace_ctx, "\tframe_crop_top_offset = %d\n", p->frame_crop_top_offset);
  1451.     va_TraceMsg(trace_ctx, "\tframe_crop_bottom_offset = %d\n", p->frame_crop_bottom_offset);
  1452.     va_TraceMsg(trace_ctx, "\tvui_parameters_present_flag = %d\n", p->vui_parameters_present_flag);
  1453.     va_TraceMsg(trace_ctx, "\taspect_ratio_info_present_flag = %d\n", p->vui_fields.bits.aspect_ratio_info_present_flag);
  1454.     va_TraceMsg(trace_ctx, "\ttiming_info_present_flag = %d\n", p->vui_fields.bits.timing_info_present_flag);
  1455.     va_TraceMsg(trace_ctx, "\tbitstream_restriction_flag = %d\n", p->vui_fields.bits.bitstream_restriction_flag);
  1456.     va_TraceMsg(trace_ctx, "\tlog2_max_mv_length_horizontal = %d\n", p->vui_fields.bits.log2_max_mv_length_horizontal);
  1457.     va_TraceMsg(trace_ctx, "\tlog2_max_mv_length_vertical = %d\n", p->vui_fields.bits.log2_max_mv_length_vertical);
  1458.     va_TraceMsg(trace_ctx, "\taspect_ratio_idc = %d\n", p->aspect_ratio_idc);
  1459.     va_TraceMsg(trace_ctx, "\tsar_width = %d\n", p->sar_width);
  1460.     va_TraceMsg(trace_ctx, "\tsar_height = %d\n", p->sar_height);
  1461.     va_TraceMsg(trace_ctx, "\tnum_units_in_tick = %d\n", p->num_units_in_tick);
  1462.     va_TraceMsg(trace_ctx, "\ttime_scale = %d\n", p->time_scale);
  1463.  
  1464.     va_TraceMsg(trace_ctx, NULL);
  1465.  
  1466.     return;
  1467. }
  1468.  
  1469.  
  1470. static void va_TraceVAEncPictureParameterBufferH264(
  1471.     VADisplay dpy,
  1472.     VAContextID context,
  1473.     VABufferID buffer,
  1474.     VABufferType type,
  1475.     unsigned int size,
  1476.     unsigned int num_elements,
  1477.     void *data)
  1478. {
  1479.     VAEncPictureParameterBufferH264 *p = (VAEncPictureParameterBufferH264 *)data;
  1480.     DPY2TRACECTX(dpy);
  1481.     int i;
  1482.  
  1483.     va_TraceMsg(trace_ctx, "\t--VAEncPictureParameterBufferH264\n");
  1484.  
  1485.     va_TraceMsg(trace_ctx, "\tCurrPic.picture_id = 0x%08x\n", p->CurrPic.picture_id);
  1486.     va_TraceMsg(trace_ctx, "\tCurrPic.frame_idx = %d\n", p->CurrPic.frame_idx);
  1487.     va_TraceMsg(trace_ctx, "\tCurrPic.flags = %d\n", p->CurrPic.flags);
  1488.     va_TraceMsg(trace_ctx, "\tCurrPic.TopFieldOrderCnt = %d\n", p->CurrPic.TopFieldOrderCnt);
  1489.     va_TraceMsg(trace_ctx, "\tCurrPic.BottomFieldOrderCnt = %d\n", p->CurrPic.BottomFieldOrderCnt);
  1490.     va_TraceMsg(trace_ctx, "\tReferenceFrames (TopFieldOrderCnt-BottomFieldOrderCnt-picture_id-frame_idx-flags):\n");
  1491.     for (i = 0; i < 16; i++)
  1492.     {
  1493.         if ((p->ReferenceFrames[i].picture_id != VA_INVALID_SURFACE) &&
  1494.             ((p->ReferenceFrames[i].flags & VA_PICTURE_H264_INVALID) == 0)) {
  1495.             va_TraceMsg(trace_ctx, "\t\t%08d-%08d-0x%08x-%08d-0x%08x\n",
  1496.                         p->ReferenceFrames[i].TopFieldOrderCnt,
  1497.                         p->ReferenceFrames[i].BottomFieldOrderCnt,
  1498.                         p->ReferenceFrames[i].picture_id,
  1499.                         p->ReferenceFrames[i].frame_idx,
  1500.                         p->ReferenceFrames[i].flags
  1501.                         );
  1502.         } else
  1503.             break;
  1504.     }
  1505.     va_TraceMsg(trace_ctx, "\tcoded_buf = %08x\n", p->coded_buf);
  1506.     va_TraceMsg(trace_ctx, "\tpic_parameter_set_id = %d\n", p->pic_parameter_set_id);
  1507.     va_TraceMsg(trace_ctx, "\tseq_parameter_set_id = %d\n", p->seq_parameter_set_id);
  1508.     va_TraceMsg(trace_ctx, "\tlast_picture = 0x%08x\n", p->last_picture);
  1509.     va_TraceMsg(trace_ctx, "\tframe_num = %d\n", p->frame_num);
  1510.     va_TraceMsg(trace_ctx, "\tpic_init_qp = %d\n", p->pic_init_qp);
  1511.     va_TraceMsg(trace_ctx, "\tnum_ref_idx_l0_active_minus1 = %d\n", p->num_ref_idx_l0_active_minus1);
  1512.     va_TraceMsg(trace_ctx, "\tnum_ref_idx_l1_active_minus1 = %d\n", p->num_ref_idx_l1_active_minus1);
  1513.     va_TraceMsg(trace_ctx, "\tchroma_qp_index_offset = %d\n", p->chroma_qp_index_offset);
  1514.     va_TraceMsg(trace_ctx, "\tsecond_chroma_qp_index_offset = %d\n", p->second_chroma_qp_index_offset);
  1515.     va_TraceMsg(trace_ctx, "\tpic_fields = 0x%03x\n", p->pic_fields.value);
  1516.     va_TraceMsg(trace_ctx, "\tidr_pic_flag = %d\n", p->pic_fields.bits.idr_pic_flag);
  1517.     va_TraceMsg(trace_ctx, "\treference_pic_flag = %d\n", p->pic_fields.bits.reference_pic_flag);
  1518.     va_TraceMsg(trace_ctx, "\tentropy_coding_mode_flag = %d\n", p->pic_fields.bits.entropy_coding_mode_flag);
  1519.     va_TraceMsg(trace_ctx, "\tweighted_pred_flag = %d\n", p->pic_fields.bits.weighted_pred_flag);
  1520.     va_TraceMsg(trace_ctx, "\tweighted_bipred_idc = %d\n", p->pic_fields.bits.weighted_bipred_idc);
  1521.     va_TraceMsg(trace_ctx, "\tconstrained_intra_pred_flag = %d\n", p->pic_fields.bits.constrained_intra_pred_flag);
  1522.     va_TraceMsg(trace_ctx, "\ttransform_8x8_mode_flag = %d\n", p->pic_fields.bits.transform_8x8_mode_flag);
  1523.     va_TraceMsg(trace_ctx, "\tdeblocking_filter_control_present_flag = %d\n", p->pic_fields.bits.deblocking_filter_control_present_flag);
  1524.     va_TraceMsg(trace_ctx, "\tredundant_pic_cnt_present_flag = %d\n", p->pic_fields.bits.redundant_pic_cnt_present_flag);
  1525.     va_TraceMsg(trace_ctx, "\tpic_order_present_flag = %d\n", p->pic_fields.bits.pic_order_present_flag);
  1526.     va_TraceMsg(trace_ctx, "\tpic_scaling_matrix_present_flag = %d\n", p->pic_fields.bits.pic_scaling_matrix_present_flag);
  1527.  
  1528.     va_TraceMsg(trace_ctx, NULL);
  1529.  
  1530.     return;
  1531. }
  1532.  
  1533. static void va_TraceVAEncSliceParameterBuffer(
  1534.     VADisplay dpy,
  1535.     VAContextID context,
  1536.     VABufferID buffer,
  1537.     VABufferType type,
  1538.     unsigned int size,
  1539.     unsigned int num_elements,
  1540.     void *data)
  1541. {
  1542.     VAEncSliceParameterBuffer* p = (VAEncSliceParameterBuffer*)data;
  1543.     DPY2TRACECTX(dpy);
  1544.    
  1545.     va_TraceMsg(trace_ctx, "\t--VAEncSliceParameterBuffer\n");
  1546.    
  1547.     va_TraceMsg(trace_ctx, "\tstart_row_number = %d\n", p->start_row_number);
  1548.     va_TraceMsg(trace_ctx, "\tslice_height = %d\n", p->slice_height);
  1549.     va_TraceMsg(trace_ctx, "\tslice_flags.is_intra = %d\n", p->slice_flags.bits.is_intra);
  1550.     va_TraceMsg(trace_ctx, "\tslice_flags.disable_deblocking_filter_idc = %d\n", p->slice_flags.bits.disable_deblocking_filter_idc);
  1551.     va_TraceMsg(trace_ctx, "\tslice_flags.uses_long_term_ref = %d\n", p->slice_flags.bits.uses_long_term_ref);
  1552.     va_TraceMsg(trace_ctx, "\tslice_flags.is_long_term_ref = %d\n", p->slice_flags.bits.is_long_term_ref);
  1553.     va_TraceMsg(trace_ctx, NULL);
  1554.  
  1555.     return;
  1556. }
  1557.  
  1558. static void va_TraceVAEncSliceParameterBufferH264(
  1559.     VADisplay dpy,
  1560.     VAContextID context,
  1561.     VABufferID buffer,
  1562.     VABufferType type,
  1563.     unsigned int size,
  1564.     unsigned int num_elements,
  1565.     void *data)
  1566. {
  1567.     VAEncSliceParameterBufferH264* p = (VAEncSliceParameterBufferH264*)data;
  1568.     DPY2TRACECTX(dpy);
  1569.     int i;
  1570.  
  1571.     if (!p)
  1572.         return;
  1573.    
  1574.     va_TraceMsg(trace_ctx, "\t--VAEncSliceParameterBufferH264\n");
  1575.     va_TraceMsg(trace_ctx, "\tmacroblock_address = %d\n", p->macroblock_address);
  1576.     va_TraceMsg(trace_ctx, "\tnum_macroblocks = %d\n", p->num_macroblocks);
  1577.     va_TraceMsg(trace_ctx, "\tmacroblock_info = %08x\n", p->macroblock_info);
  1578.     va_TraceMsg(trace_ctx, "\tslice_type = %d\n", p->slice_type);
  1579.     va_TraceMsg(trace_ctx, "\tpic_parameter_set_id = %d\n", p->pic_parameter_set_id);
  1580.     va_TraceMsg(trace_ctx, "\tidr_pic_id = %d\n", p->idr_pic_id);
  1581.     va_TraceMsg(trace_ctx, "\tpic_order_cnt_lsb = %d\n", p->pic_order_cnt_lsb);
  1582.     va_TraceMsg(trace_ctx, "\tdelta_pic_order_cnt_bottom = %d\n", p->delta_pic_order_cnt_bottom);
  1583.     va_TraceMsg(trace_ctx, "\tdelta_pic_order_cnt[0] = %d\n", p->delta_pic_order_cnt[0]);
  1584.     va_TraceMsg(trace_ctx, "\tdelta_pic_order_cnt[1] = %d\n", p->delta_pic_order_cnt[1]);
  1585.     va_TraceMsg(trace_ctx, "\tdirect_spatial_mv_pred_flag = %d\n", p->direct_spatial_mv_pred_flag);
  1586.     va_TraceMsg(trace_ctx, "\tnum_ref_idx_active_override_flag = %d\n", p->num_ref_idx_active_override_flag);
  1587.     va_TraceMsg(trace_ctx, "\tnum_ref_idx_l1_active_minus1 = %d\n", p->num_ref_idx_l1_active_minus1);
  1588.     va_TraceMsg(trace_ctx, "\tslice_beta_offset_div2 = %d\n", p->slice_beta_offset_div2);
  1589.  
  1590.     va_TraceMsg(trace_ctx, "\tRefPicList0 (TopFieldOrderCnt-BottomFieldOrderCnt-picture_id-frame_idx-flags):\n");
  1591.  
  1592.    
  1593.    
  1594.     for (i = 0; i < 32; i++) {
  1595.         if ((p->RefPicList0[i].picture_id != VA_INVALID_SURFACE) &&
  1596.             ((p->RefPicList0[i].flags & VA_PICTURE_H264_INVALID) == 0))
  1597.             va_TraceMsg(trace_ctx, "\t\t%08d-%08d-0x%08x-%08d-0x%08x\n",
  1598.                         p->RefPicList0[i].TopFieldOrderCnt,
  1599.                         p->RefPicList0[i].BottomFieldOrderCnt,
  1600.                         p->RefPicList0[i].picture_id,
  1601.                         p->RefPicList0[i].frame_idx,
  1602.                         p->RefPicList0[i].flags);
  1603.         else
  1604.             break;
  1605.     }
  1606.    
  1607.     va_TraceMsg(trace_ctx, "\tRefPicList1 (TopFieldOrderCnt-BottomFieldOrderCnt-picture_id-frame_idx-flags):\n");
  1608.     for (i = 0; i < 32; i++) {
  1609.         if ((p->RefPicList1[i].picture_id != VA_INVALID_SURFACE) &&
  1610.             ((p->RefPicList1[i].flags & VA_PICTURE_H264_INVALID) == 0))
  1611.             va_TraceMsg(trace_ctx, "\t\t%08d-%08d-0x%08x-%08d-0x%08d\n",
  1612.                         p->RefPicList1[i].TopFieldOrderCnt,
  1613.                         p->RefPicList1[i].BottomFieldOrderCnt,
  1614.                         p->RefPicList1[i].picture_id,
  1615.                         p->RefPicList1[i].frame_idx,
  1616.                         p->RefPicList1[i].flags
  1617.                         );
  1618.         else
  1619.             break;
  1620.     }
  1621.    
  1622.     va_TraceMsg(trace_ctx, "\tluma_log2_weight_denom = %d\n", p->luma_log2_weight_denom);
  1623.     va_TraceMsg(trace_ctx, "\tchroma_log2_weight_denom = %d\n", p->chroma_log2_weight_denom);
  1624.     va_TraceMsg(trace_ctx, "\tluma_weight_l0_flag = %d\n", p->luma_weight_l0_flag);
  1625.     if (p->luma_weight_l0_flag) {
  1626.         for (i = 0; (i <= p->num_ref_idx_l0_active_minus1) && (i<32); i++) {
  1627.             va_TraceMsg(trace_ctx, "\t\t%d\t%d\n",
  1628.                         p->luma_weight_l0[i],
  1629.                         p->luma_offset_l0[i]);
  1630.         }
  1631.     }
  1632.  
  1633.     va_TraceMsg(trace_ctx, "\tchroma_weight_l0_flag = %d\n", p->chroma_weight_l0_flag);
  1634.     if (p->chroma_weight_l0_flag) {
  1635.         for (i = 0; (i <= p->num_ref_idx_l0_active_minus1) && (i<32); i++) {
  1636.             va_TraceMsg(trace_ctx, "\t\t%d\t%d\t%d\t%d\n",
  1637.                         p->chroma_weight_l0[i][0],
  1638.                         p->chroma_offset_l0[i][0],
  1639.                         p->chroma_weight_l0[i][1],
  1640.                         p->chroma_offset_l0[i][1]);
  1641.         }
  1642.     }
  1643.  
  1644.     va_TraceMsg(trace_ctx, "\tluma_weight_l1_flag = %d\n", p->luma_weight_l1_flag);
  1645.     if (p->luma_weight_l1_flag) {
  1646.         for (i = 0; (i <= p->num_ref_idx_l1_active_minus1) && (i<32); i++) {
  1647.             va_TraceMsg(trace_ctx, "\t\t%d\t\t%d\n",
  1648.                         p->luma_weight_l1[i],
  1649.                         p->luma_offset_l1[i]);
  1650.         }
  1651.     }
  1652.  
  1653.     va_TraceMsg(trace_ctx, "\tchroma_weight_l1_flag = %d\n", p->chroma_weight_l1_flag);
  1654.     if (p->chroma_weight_l1_flag && p->num_ref_idx_l1_active_minus1 < 32) {
  1655.         for (i = 0; (i <= p->num_ref_idx_l1_active_minus1) && (i<32); i++) {
  1656.             va_TraceMsg(trace_ctx, "\t\t%d\t%d\t%d\t%d\n",
  1657.                         p->chroma_weight_l1[i][0],
  1658.                         p->chroma_offset_l1[i][0],
  1659.                         p->chroma_weight_l1[i][1],
  1660.                         p->chroma_offset_l1[i][1]);
  1661.         }
  1662.     }
  1663.     va_TraceMsg(trace_ctx, NULL);
  1664.  
  1665.     va_TraceMsg(trace_ctx, "\tcabac_init_idc = %d\n", p->cabac_init_idc);
  1666.     va_TraceMsg(trace_ctx, "\tslice_qp_delta = %d\n", p->slice_qp_delta);
  1667.     va_TraceMsg(trace_ctx, "\tdisable_deblocking_filter_idc = %d\n", p->disable_deblocking_filter_idc);
  1668.     va_TraceMsg(trace_ctx, "\tslice_alpha_c0_offset_div2 = %d\n", p->slice_alpha_c0_offset_div2);
  1669.     va_TraceMsg(trace_ctx, "\tslice_beta_offset_div2 = %d\n", p->slice_beta_offset_div2);
  1670.     va_TraceMsg(trace_ctx, NULL);
  1671.  
  1672.     return;
  1673. }
  1674.  
  1675.  
  1676. static void va_TraceVAEncPackedHeaderParameterBufferType(
  1677.     VADisplay dpy,
  1678.     VAContextID context,
  1679.     VABufferID buffer,
  1680.     VABufferType type,
  1681.     unsigned int size,
  1682.     unsigned int num_elements,
  1683.     void *data)
  1684. {
  1685.     VAEncPackedHeaderParameterBuffer* p = (VAEncPackedHeaderParameterBuffer*)data;
  1686.     DPY2TRACECTX(dpy);
  1687.     int i;
  1688.  
  1689.     if (!p)
  1690.         return;
  1691.     va_TraceMsg(trace_ctx, "\t--VAEncPackedHeaderParameterBuffer\n");
  1692.     va_TraceMsg(trace_ctx, "\ttype = 0x%08x\n", p->type);
  1693.     va_TraceMsg(trace_ctx, "\tbit_length = %d\n", p->bit_length);
  1694.     va_TraceMsg(trace_ctx, "\thas_emulation_bytes = %d\n", p->has_emulation_bytes);
  1695.     va_TraceMsg(trace_ctx, NULL);
  1696.  
  1697.     return;
  1698. }
  1699.  
  1700. static void va_TraceVAEncMiscParameterBuffer(
  1701.     VADisplay dpy,
  1702.     VAContextID context,
  1703.     VABufferID buffer,
  1704.     VABufferType type,
  1705.     unsigned int size,
  1706.     unsigned int num_elements,
  1707.     void *data)
  1708. {
  1709.     VAEncMiscParameterBuffer* tmp = (VAEncMiscParameterBuffer*)data;
  1710.     DPY2TRACECTX(dpy);
  1711.    
  1712.     switch (tmp->type) {
  1713.     case VAEncMiscParameterTypeFrameRate:
  1714.     {
  1715.         VAEncMiscParameterFrameRate *p = (VAEncMiscParameterFrameRate *)tmp->data;
  1716.         va_TraceMsg(trace_ctx, "\t--VAEncMiscParameterFrameRate\n");
  1717.         va_TraceMsg(trace_ctx, "\tframerate = %d\n", p->framerate);
  1718.        
  1719.         break;
  1720.     }
  1721.     case VAEncMiscParameterTypeRateControl:
  1722.     {
  1723.         VAEncMiscParameterRateControl *p = (VAEncMiscParameterRateControl *)tmp->data;
  1724.  
  1725.         va_TraceMsg(trace_ctx, "\t--VAEncMiscParameterRateControl\n");
  1726.         va_TraceMsg(trace_ctx, "\tbits_per_second = %d\n", p->bits_per_second);
  1727.         va_TraceMsg(trace_ctx, "\ttarget_percentage = %d\n", p->target_percentage);
  1728.         va_TraceMsg(trace_ctx, "\twindow_size = %d\n", p->window_size);
  1729.         va_TraceMsg(trace_ctx, "\tinitial_qp = %d\n", p->initial_qp);
  1730.         va_TraceMsg(trace_ctx, "\tmin_qp = %d\n", p->min_qp);
  1731.         va_TraceMsg(trace_ctx, "\tbasic_unit_size = %d\n", p->basic_unit_size);
  1732.         va_TraceMsg(trace_ctx, "\trc_flags.reset = %d \n", p->rc_flags.bits.reset);
  1733.         va_TraceMsg(trace_ctx, "\trc_flags.disable_frame_skip = %d\n", p->rc_flags.bits.disable_frame_skip);
  1734.         va_TraceMsg(trace_ctx, "\trc_flags.disable_bit_stuffing = %d\n", p->rc_flags.bits.disable_bit_stuffing);
  1735.         break;
  1736.     }
  1737.     case VAEncMiscParameterTypeMaxSliceSize:
  1738.     {
  1739.         VAEncMiscParameterMaxSliceSize *p = (VAEncMiscParameterMaxSliceSize *)tmp->data;
  1740.        
  1741.         va_TraceMsg(trace_ctx, "\t--VAEncMiscParameterTypeMaxSliceSize\n");
  1742.         va_TraceMsg(trace_ctx, "\tmax_slice_size = %d\n", p->max_slice_size);
  1743.         break;
  1744.     }
  1745.     case VAEncMiscParameterTypeAIR:
  1746.     {
  1747.         VAEncMiscParameterAIR *p = (VAEncMiscParameterAIR *)tmp->data;
  1748.        
  1749.         va_TraceMsg(trace_ctx, "\t--VAEncMiscParameterAIR\n");
  1750.         va_TraceMsg(trace_ctx, "\tair_num_mbs = %d\n", p->air_num_mbs);
  1751.         va_TraceMsg(trace_ctx, "\tair_threshold = %d\n", p->air_threshold);
  1752.         va_TraceMsg(trace_ctx, "\tair_auto = %d\n", p->air_auto);
  1753.         break;
  1754.     }
  1755.     case VAEncMiscParameterTypeHRD:
  1756.     {
  1757.         VAEncMiscParameterHRD *p = (VAEncMiscParameterHRD *)tmp->data;
  1758.  
  1759.         va_TraceMsg(trace_ctx, "\t--VAEncMiscParameterHRD\n");
  1760.         va_TraceMsg(trace_ctx, "\tinitial_buffer_fullness = %d\n", p->initial_buffer_fullness);
  1761.         va_TraceMsg(trace_ctx, "\tbuffer_size = %d\n", p->buffer_size);
  1762.         break;
  1763.     }
  1764.     case VAEncMiscParameterTypeMaxFrameSize:
  1765.     {
  1766.         VAEncMiscParameterBufferMaxFrameSize *p = (VAEncMiscParameterBufferMaxFrameSize *)tmp->data;
  1767.  
  1768.         va_TraceMsg(trace_ctx, "\t--VAEncMiscParameterTypeMaxFrameSize\n");
  1769.         va_TraceMsg(trace_ctx, "\tmax_frame_size = %d\n", p->max_frame_size);
  1770.         break;
  1771.     }
  1772.     default:
  1773.         va_TraceMsg(trace_ctx, "Unknown VAEncMiscParameterBuffer(type = %d):\n", tmp->type);
  1774.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, data);
  1775.         break;
  1776.     }
  1777.     va_TraceMsg(trace_ctx, NULL);
  1778.  
  1779.     return;
  1780. }
  1781.  
  1782.  
  1783. static void va_TraceVAPictureParameterBufferVC1(
  1784.     VADisplay dpy,
  1785.     VAContextID context,
  1786.     VABufferID buffer,
  1787.     VABufferType type,
  1788.     unsigned int size,
  1789.     unsigned int num_elements,
  1790.     void *data
  1791. )
  1792. {
  1793.     VAPictureParameterBufferVC1* p = (VAPictureParameterBufferVC1*)data;
  1794.     DPY2TRACECTX(dpy);
  1795.    
  1796.     va_TraceMsg(trace_ctx, "\t--VAPictureParameterBufferVC1\n");
  1797.    
  1798.     va_TraceMsg(trace_ctx, "\tforward_reference_picture = 0x%08x\n", p->forward_reference_picture);
  1799.     va_TraceMsg(trace_ctx, "\tbackward_reference_picture = 0x%08x\n", p->backward_reference_picture);
  1800.     va_TraceMsg(trace_ctx, "\tinloop_decoded_picture = 0x%08x\n", p->inloop_decoded_picture);
  1801.    
  1802.     va_TraceMsg(trace_ctx, "\tpulldown = %d\n", p->sequence_fields.bits.pulldown);
  1803.     va_TraceMsg(trace_ctx, "\tinterlace = %d\n", p->sequence_fields.bits.interlace);
  1804.     va_TraceMsg(trace_ctx, "\ttfcntrflag = %d\n", p->sequence_fields.bits.tfcntrflag);
  1805.     va_TraceMsg(trace_ctx, "\tfinterpflag = %d\n", p->sequence_fields.bits.finterpflag);
  1806.     va_TraceMsg(trace_ctx, "\tpsf = %d\n", p->sequence_fields.bits.psf);
  1807.     va_TraceMsg(trace_ctx, "\tmultires = %d\n", p->sequence_fields.bits.multires);
  1808.     va_TraceMsg(trace_ctx, "\toverlap = %d\n", p->sequence_fields.bits.overlap);
  1809.     va_TraceMsg(trace_ctx, "\tsyncmarker = %d\n", p->sequence_fields.bits.syncmarker);
  1810.     va_TraceMsg(trace_ctx, "\trangered = %d\n", p->sequence_fields.bits.rangered);
  1811.     va_TraceMsg(trace_ctx, "\tmax_b_frames = %d\n", p->sequence_fields.bits.max_b_frames);
  1812.     va_TraceMsg(trace_ctx, "\tprofile = %d\n", p->sequence_fields.bits.profile);
  1813.     va_TraceMsg(trace_ctx, "\tcoded_width = %d\n", p->coded_width);
  1814.     va_TraceMsg(trace_ctx, "\tcoded_height = %d\n", p->coded_height);
  1815.     va_TraceMsg(trace_ctx, "\tclosed_entry = %d\n", p->entrypoint_fields.bits.closed_entry);
  1816.     va_TraceMsg(trace_ctx, "\tbroken_link = %d\n", p->entrypoint_fields.bits.broken_link);
  1817.     va_TraceMsg(trace_ctx, "\tclosed_entry = %d\n", p->entrypoint_fields.bits.closed_entry);
  1818.     va_TraceMsg(trace_ctx, "\tpanscan_flag = %d\n", p->entrypoint_fields.bits.panscan_flag);
  1819.     va_TraceMsg(trace_ctx, "\tloopfilter = %d\n", p->entrypoint_fields.bits.loopfilter);
  1820.     va_TraceMsg(trace_ctx, "\tconditional_overlap_flag = %d\n", p->conditional_overlap_flag);
  1821.     va_TraceMsg(trace_ctx, "\tfast_uvmc_flag = %d\n", p->fast_uvmc_flag);
  1822.     va_TraceMsg(trace_ctx, "\trange_mapping_luma_flag = %d\n", p->range_mapping_fields.bits.luma_flag);
  1823.     va_TraceMsg(trace_ctx, "\trange_mapping_luma = %d\n", p->range_mapping_fields.bits.luma);
  1824.     va_TraceMsg(trace_ctx, "\trange_mapping_chroma_flag = %d\n", p->range_mapping_fields.bits.chroma_flag);
  1825.     va_TraceMsg(trace_ctx, "\trange_mapping_chroma = %d\n", p->range_mapping_fields.bits.chroma);
  1826.     va_TraceMsg(trace_ctx, "\tb_picture_fraction = %d\n", p->b_picture_fraction);
  1827.     va_TraceMsg(trace_ctx, "\tcbp_table = %d\n", p->cbp_table);
  1828.     va_TraceMsg(trace_ctx, "\tmb_mode_table = %d\n", p->mb_mode_table);
  1829.     va_TraceMsg(trace_ctx, "\trange_reduction_frame = %d\n", p->range_reduction_frame);
  1830.     va_TraceMsg(trace_ctx, "\trounding_control = %d\n", p->rounding_control);
  1831.     va_TraceMsg(trace_ctx, "\tpost_processing = %d\n", p->post_processing);
  1832.     va_TraceMsg(trace_ctx, "\tpicture_resolution_index = %d\n", p->picture_resolution_index);
  1833.     va_TraceMsg(trace_ctx, "\tluma_scale = %d\n", p->luma_scale);
  1834.     va_TraceMsg(trace_ctx, "\tluma_shift = %d\n", p->luma_shift);
  1835.     va_TraceMsg(trace_ctx, "\tpicture_type = %d\n", p->picture_fields.bits.picture_type);
  1836.     va_TraceMsg(trace_ctx, "\tframe_coding_mode = %d\n", p->picture_fields.bits.frame_coding_mode);
  1837.     va_TraceMsg(trace_ctx, "\ttop_field_first = %d\n", p->picture_fields.bits.top_field_first);
  1838.     va_TraceMsg(trace_ctx, "\tis_first_field = %d\n", p->picture_fields.bits.is_first_field);
  1839.     va_TraceMsg(trace_ctx, "\tintensity_compensation = %d\n", p->picture_fields.bits.intensity_compensation);
  1840.     va_TraceMsg(trace_ctx, "\tmv_type_mb = %d\n", p->raw_coding.flags.mv_type_mb);
  1841.     va_TraceMsg(trace_ctx, "\tdirect_mb = %d\n", p->raw_coding.flags.direct_mb);
  1842.     va_TraceMsg(trace_ctx, "\tskip_mb = %d\n", p->raw_coding.flags.skip_mb);
  1843.     va_TraceMsg(trace_ctx, "\tfield_tx = %d\n", p->raw_coding.flags.field_tx);
  1844.     va_TraceMsg(trace_ctx, "\tforward_mb = %d\n", p->raw_coding.flags.forward_mb);
  1845.     va_TraceMsg(trace_ctx, "\tac_pred = %d\n", p->raw_coding.flags.ac_pred);
  1846.     va_TraceMsg(trace_ctx, "\toverflags = %d\n", p->raw_coding.flags.overflags);
  1847.     va_TraceMsg(trace_ctx, "\tbp_mv_type_mb = %d\n", p->bitplane_present.flags.bp_mv_type_mb);
  1848.     va_TraceMsg(trace_ctx, "\tbp_direct_mb = %d\n", p->bitplane_present.flags.bp_direct_mb);
  1849.     va_TraceMsg(trace_ctx, "\tbp_skip_mb = %d\n", p->bitplane_present.flags.bp_skip_mb);
  1850.     va_TraceMsg(trace_ctx, "\tbp_field_tx = %d\n", p->bitplane_present.flags.bp_field_tx);
  1851.     va_TraceMsg(trace_ctx, "\tbp_forward_mb = %d\n", p->bitplane_present.flags.bp_forward_mb);
  1852.     va_TraceMsg(trace_ctx, "\tbp_ac_pred = %d\n", p->bitplane_present.flags.bp_ac_pred);
  1853.     va_TraceMsg(trace_ctx, "\tbp_overflags = %d\n", p->bitplane_present.flags.bp_overflags);
  1854.     va_TraceMsg(trace_ctx, "\treference_distance_flag = %d\n", p->reference_fields.bits.reference_distance_flag);
  1855.     va_TraceMsg(trace_ctx, "\treference_distance = %d\n", p->reference_fields.bits.reference_distance);
  1856.     va_TraceMsg(trace_ctx, "\tnum_reference_pictures = %d\n", p->reference_fields.bits.num_reference_pictures);
  1857.     va_TraceMsg(trace_ctx, "\treference_field_pic_indicator = %d\n", p->reference_fields.bits.reference_field_pic_indicator);
  1858.     va_TraceMsg(trace_ctx, "\tmv_mode = %d\n", p->mv_fields.bits.mv_mode);
  1859.     va_TraceMsg(trace_ctx, "\tmv_mode2 = %d\n", p->mv_fields.bits.mv_mode2);
  1860.     va_TraceMsg(trace_ctx, "\tmv_table = %d\n", p->mv_fields.bits.mv_table);
  1861.     va_TraceMsg(trace_ctx, "\ttwo_mv_block_pattern_table = %d\n", p->mv_fields.bits.two_mv_block_pattern_table);
  1862.     va_TraceMsg(trace_ctx, "\tfour_mv_switch = %d\n", p->mv_fields.bits.four_mv_switch);
  1863.     va_TraceMsg(trace_ctx, "\tfour_mv_block_pattern_table = %d\n", p->mv_fields.bits.four_mv_block_pattern_table);
  1864.     va_TraceMsg(trace_ctx, "\textended_mv_flag = %d\n", p->mv_fields.bits.extended_mv_flag);
  1865.     va_TraceMsg(trace_ctx, "\textended_mv_range = %d\n", p->mv_fields.bits.extended_mv_range);
  1866.     va_TraceMsg(trace_ctx, "\textended_dmv_flag = %d\n", p->mv_fields.bits.extended_dmv_flag);
  1867.     va_TraceMsg(trace_ctx, "\textended_dmv_range = %d\n", p->mv_fields.bits.extended_dmv_range);
  1868.     va_TraceMsg(trace_ctx, "\tdquant = %d\n", p->pic_quantizer_fields.bits.dquant);
  1869.     va_TraceMsg(trace_ctx, "\tquantizer = %d\n", p->pic_quantizer_fields.bits.quantizer);
  1870.     va_TraceMsg(trace_ctx, "\thalf_qp = %d\n", p->pic_quantizer_fields.bits.half_qp);
  1871.     va_TraceMsg(trace_ctx, "\tpic_quantizer_scale = %d\n", p->pic_quantizer_fields.bits.pic_quantizer_scale);
  1872.     va_TraceMsg(trace_ctx, "\tpic_quantizer_type = %d\n", p->pic_quantizer_fields.bits.pic_quantizer_type);
  1873.     va_TraceMsg(trace_ctx, "\tdq_frame = %d\n", p->pic_quantizer_fields.bits.dq_frame);
  1874.     va_TraceMsg(trace_ctx, "\tdq_profile = %d\n", p->pic_quantizer_fields.bits.dq_profile);
  1875.     va_TraceMsg(trace_ctx, "\tdq_sb_edge = %d\n", p->pic_quantizer_fields.bits.dq_sb_edge);
  1876.     va_TraceMsg(trace_ctx, "\tdq_db_edge = %d\n", p->pic_quantizer_fields.bits.dq_db_edge);
  1877.     va_TraceMsg(trace_ctx, "\tdq_binary_level = %d\n", p->pic_quantizer_fields.bits.dq_binary_level);
  1878.     va_TraceMsg(trace_ctx, "\talt_pic_quantizer = %d\n", p->pic_quantizer_fields.bits.alt_pic_quantizer);
  1879.     va_TraceMsg(trace_ctx, "\tvariable_sized_transform_flag = %d\n", p->transform_fields.bits.variable_sized_transform_flag);
  1880.     va_TraceMsg(trace_ctx, "\tmb_level_transform_type_flag = %d\n", p->transform_fields.bits.mb_level_transform_type_flag);
  1881.     va_TraceMsg(trace_ctx, "\tframe_level_transform_type = %d\n", p->transform_fields.bits.frame_level_transform_type);
  1882.     va_TraceMsg(trace_ctx, "\ttransform_ac_codingset_idx1 = %d\n", p->transform_fields.bits.transform_ac_codingset_idx1);
  1883.     va_TraceMsg(trace_ctx, "\ttransform_ac_codingset_idx2 = %d\n", p->transform_fields.bits.transform_ac_codingset_idx2);
  1884.     va_TraceMsg(trace_ctx, "\tintra_transform_dc_table = %d\n", p->transform_fields.bits.intra_transform_dc_table);
  1885.     va_TraceMsg(trace_ctx, NULL);
  1886. }
  1887.  
  1888. static void va_TraceVASliceParameterBufferVC1(
  1889.     VADisplay dpy,
  1890.     VAContextID context,
  1891.     VABufferID buffer,
  1892.     VABufferType type,
  1893.     unsigned int size,
  1894.     unsigned int num_elements,
  1895.     void* data
  1896. )
  1897. {
  1898.     VASliceParameterBufferVC1 *p = (VASliceParameterBufferVC1*)data;
  1899.     DPY2TRACECTX(dpy);
  1900.  
  1901.     trace_ctx->trace_slice_no++;
  1902.     trace_ctx->trace_slice_size = p->slice_data_size;
  1903.  
  1904.     va_TraceMsg(trace_ctx, "\t--VASliceParameterBufferVC1\n");
  1905.     va_TraceMsg(trace_ctx, "\tslice_data_size = %d\n", p->slice_data_size);
  1906.     va_TraceMsg(trace_ctx, "\tslice_data_offset = %d\n", p->slice_data_offset);
  1907.     va_TraceMsg(trace_ctx, "\tslice_data_flag = %d\n", p->slice_data_flag);
  1908.     va_TraceMsg(trace_ctx, "\tmacroblock_offset = %d\n", p->macroblock_offset);
  1909.     va_TraceMsg(trace_ctx, "\tslice_vertical_position = %d\n", p->slice_vertical_position);
  1910.     va_TraceMsg(trace_ctx, NULL);
  1911. }
  1912.  
  1913. static void va_TraceVAPictureParameterBufferVP8(
  1914.     VADisplay dpy,
  1915.     VAContextID context,
  1916.     VABufferID buffer,
  1917.     VABufferType type,
  1918.     unsigned int size,
  1919.     unsigned int num_elements,
  1920.     void *data)
  1921. {
  1922.     char tmp[1024];
  1923.     VAPictureParameterBufferVP8 *p = (VAPictureParameterBufferVP8 *)data;
  1924.     DPY2TRACECTX(dpy);
  1925.     int i,j;
  1926.  
  1927.     va_TraceMsg(trace_ctx, "\t--VAPictureParameterBufferVP8\n");
  1928.  
  1929.     va_TraceMsg(trace_ctx, "\tframe_width = %d\n", p->frame_width);
  1930.     va_TraceMsg(trace_ctx, "\tframe_height = %d\n", p->frame_height);
  1931.     va_TraceMsg(trace_ctx, "\tlast_ref_frame = %x\n", p->last_ref_frame);
  1932.     va_TraceMsg(trace_ctx, "\tgolden_ref_frame = %x\n", p->golden_ref_frame);
  1933.     va_TraceMsg(trace_ctx, "\talt_ref_frame = %x\n", p->alt_ref_frame);
  1934.     va_TraceMsg(trace_ctx, "\tout_of_loop_frame = %x\n", p->out_of_loop_frame);
  1935.  
  1936.     va_TraceMsg(trace_ctx, "\tkey_frame = %d\n", p->pic_fields.bits.key_frame);
  1937.     va_TraceMsg(trace_ctx, "\tversion = %d\n", p->pic_fields.bits.version);
  1938.     va_TraceMsg(trace_ctx, "\tsegmentation_enabled = %d\n", p->pic_fields.bits.segmentation_enabled);
  1939.     va_TraceMsg(trace_ctx, "\tupdate_mb_segmentation_map = %d\n", p->pic_fields.bits.update_mb_segmentation_map);
  1940.     va_TraceMsg(trace_ctx, "\tupdate_segment_feature_data = %d\n", p->pic_fields.bits.update_segment_feature_data);
  1941.     va_TraceMsg(trace_ctx, "\tfilter_type = %d\n", p->pic_fields.bits.filter_type);
  1942.     va_TraceMsg(trace_ctx, "\tsharpness_level = %d\n", p->pic_fields.bits.sharpness_level);
  1943.     va_TraceMsg(trace_ctx, "\tloop_filter_adj_enable = %d\n", p->pic_fields.bits.loop_filter_adj_enable);
  1944.     va_TraceMsg(trace_ctx, "\tmode_ref_lf_delta_update = %d\n", p->pic_fields.bits.mode_ref_lf_delta_update);
  1945.     va_TraceMsg(trace_ctx, "\tsign_bias_golden = %d\n", p->pic_fields.bits.sign_bias_golden);
  1946.     va_TraceMsg(trace_ctx, "\tsign_bias_alternate = %d\n", p->pic_fields.bits.sign_bias_alternate);
  1947.     va_TraceMsg(trace_ctx, "\tmb_no_coeff_skip = %d\n", p->pic_fields.bits.mb_no_coeff_skip);
  1948.     va_TraceMsg(trace_ctx, "\tloop_filter_disable = %d\n", p->pic_fields.bits.loop_filter_disable);
  1949.  
  1950.     va_TraceMsg(trace_ctx, "\tmb_segment_tree_probs: 0x%2x, 0x%2x, 0x%2x\n",
  1951.         p->mb_segment_tree_probs[0], p->mb_segment_tree_probs[1], p->mb_segment_tree_probs[2]);
  1952.  
  1953.     va_TraceMsg(trace_ctx, "\tloop_filter_level: %d, %d, %d, %d\n",
  1954.         p->loop_filter_level[0], p->loop_filter_level[1], p->loop_filter_level[2], p->loop_filter_level[3]);
  1955.  
  1956.     va_TraceMsg(trace_ctx, "\tloop_filter_deltas_ref_frame: %d, %d, %d, %d\n",
  1957.         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]);
  1958.  
  1959.     va_TraceMsg(trace_ctx, "\tloop_filter_deltas_mode: %d, %d, %d, %d\n",
  1960.         p->loop_filter_deltas_mode[0], p->loop_filter_deltas_mode[1], p->loop_filter_deltas_mode[2], p->loop_filter_deltas_mode[3]);
  1961.  
  1962.     va_TraceMsg(trace_ctx, "\tprob_skip_false = %2x\n", p->prob_skip_false);
  1963.     va_TraceMsg(trace_ctx, "\tprob_intra = %2x\n", p->prob_intra);
  1964.     va_TraceMsg(trace_ctx, "\tprob_last = %2x\n", p->prob_last);
  1965.     va_TraceMsg(trace_ctx, "\tprob_gf = %2x\n", p->prob_gf);
  1966.  
  1967.     va_TraceMsg(trace_ctx, "\ty_mode_probs: 0x%2x, 0x%2x, 0x%2x, 0x%2x\n",
  1968.         p->y_mode_probs[0], p->y_mode_probs[1], p->y_mode_probs[2], p->y_mode_probs[3]);
  1969.  
  1970.     va_TraceMsg(trace_ctx, "\tuv_mode_probs: 0x%2x, 0x%2x, 0x%2x\n",
  1971.         p->uv_mode_probs[0], p->uv_mode_probs[1], p->uv_mode_probs[2]);
  1972.  
  1973.     va_TraceMsg(trace_ctx, "\tmv_probs[2][19]:\n");
  1974.     for(i = 0; i<2; ++i) {
  1975.         memset(tmp, 0, sizeof tmp);
  1976.         for (j=0; j<19; j++)
  1977.             sprintf(tmp + strlen(tmp), "%2x ", p->mv_probs[i][j]);
  1978.         va_TraceMsg(trace_ctx,"\t\t[%d] = %s\n", i, tmp);
  1979.     }
  1980.  
  1981.     va_TraceMsg(trace_ctx, "\tbool_coder_ctx: range = %02x, value = %02x, count = %d\n",
  1982.         p->bool_coder_ctx.range, p->bool_coder_ctx.value, p->bool_coder_ctx.count);
  1983.  
  1984.     va_TraceMsg(trace_ctx, NULL);
  1985.  
  1986.     return;
  1987. }
  1988.  
  1989. static void va_TraceVASliceParameterBufferVP8(
  1990.     VADisplay dpy,
  1991.     VAContextID context,
  1992.     VABufferID buffer,
  1993.     VABufferType type,
  1994.     unsigned int size,
  1995.     unsigned int num_elements,
  1996.     void *data)
  1997. {
  1998.     VASliceParameterBufferVP8 *p = (VASliceParameterBufferVP8 *)data;
  1999.     DPY2TRACECTX(dpy);
  2000.     int i;
  2001.  
  2002.     va_TraceMsg(trace_ctx, "\t--VASliceParameterBufferVP8\n");
  2003.  
  2004.     va_TraceMsg(trace_ctx, "\tslice_data_size = %d\n", p->slice_data_size);
  2005.     va_TraceMsg(trace_ctx, "\tslice_data_offset = %d\n", p->slice_data_offset);
  2006.     va_TraceMsg(trace_ctx, "\tslice_data_flag = %d\n", p->slice_data_flag);
  2007.     va_TraceMsg(trace_ctx, "\tmacroblock_offset = %d\n", p->macroblock_offset);
  2008.     va_TraceMsg(trace_ctx, "\tnum_of_partitions = %d\n", p->num_of_partitions);
  2009.  
  2010.     for(i = 0; i<9; ++i)
  2011.         va_TraceMsg(trace_ctx, "\tpartition_size[%d] = %d\n", i, p->partition_size[i]);
  2012.  
  2013.     va_TraceMsg(trace_ctx, NULL);
  2014.  
  2015.     return;
  2016. }
  2017.  
  2018. static void va_TraceVAIQMatrixBufferVP8(
  2019.     VADisplay dpy,
  2020.     VAContextID context,
  2021.     VABufferID buffer,
  2022.     VABufferType type,
  2023.     unsigned int size,
  2024.     unsigned int num_elements,
  2025.     void *data)
  2026. {
  2027.     char tmp[1024];
  2028.     VAIQMatrixBufferVP8 *p = (VAIQMatrixBufferVP8 *)data;
  2029.     DPY2TRACECTX(dpy);
  2030.     int i,j;
  2031.  
  2032.     va_TraceMsg(trace_ctx, "\t--VAIQMatrixBufferVP8\n");
  2033.  
  2034.     va_TraceMsg(trace_ctx, "\tquantization_index[4][6]=\n");
  2035.     for (i = 0; i < 4; i++) {
  2036.         memset(tmp, 0, sizeof tmp);
  2037.         for (j = 0; j < 6; j++)
  2038.             sprintf(tmp + strlen(tmp), "%4x, ", p->quantization_index[i][j]);
  2039.         va_TraceMsg(trace_ctx,"\t\t[%d] = %s\n", i, tmp);
  2040.     }
  2041.  
  2042.     va_TraceMsg(trace_ctx, NULL);
  2043.  
  2044.     return;
  2045. }
  2046. static void va_TraceVAProbabilityBufferVP8(
  2047.     VADisplay dpy,
  2048.     VAContextID context,
  2049.     VABufferID buffer,
  2050.     VABufferType type,
  2051.     unsigned int size,
  2052.     unsigned int num_elements,
  2053.     void *data)
  2054. {
  2055.     char tmp[1024];
  2056.     VAProbabilityDataBufferVP8 *p = (VAProbabilityDataBufferVP8 *)data;
  2057.     DPY2TRACECTX(dpy);
  2058.     int i,j,k,l;
  2059.  
  2060.     va_TraceMsg(trace_ctx, "\t--VAProbabilityDataBufferVP8\n");
  2061.  
  2062.     for (i = 0; i < 4; i++)
  2063.         for (j = 0; j < 8; j++) {
  2064.             memset(tmp, 0, sizeof tmp);
  2065.             for (k=0; k<3; k++)
  2066.                 for (l=0; l<11; l++)
  2067.                     sprintf(tmp + strlen(tmp), "%2x, ", p->dct_coeff_probs[i][j][k][l]);
  2068.             va_TraceMsg(trace_ctx,"\t\t[%d, %d] = %s\n", i, j, tmp);
  2069.         }
  2070.  
  2071.     va_TraceMsg(trace_ctx, NULL);
  2072.  
  2073.     return;
  2074. }
  2075.  
  2076. void va_TraceBeginPicture(
  2077.     VADisplay dpy,
  2078.     VAContextID context,
  2079.     VASurfaceID render_target
  2080. )
  2081. {
  2082.     DPY2TRACECTX(dpy);
  2083.  
  2084.     TRACE_FUNCNAME(idx);
  2085.  
  2086.     va_TraceMsg(trace_ctx, "\tcontext = 0x%08x\n", context);
  2087.     va_TraceMsg(trace_ctx, "\trender_targets = 0x%08x\n", render_target);
  2088.     va_TraceMsg(trace_ctx, "\tframe_count  = #%d\n", trace_ctx->trace_frame_no);
  2089.     va_TraceMsg(trace_ctx, NULL);
  2090.  
  2091.     trace_ctx->trace_rendertarget = render_target; /* for surface data dump after vaEndPicture */
  2092.  
  2093.     trace_ctx->trace_frame_no++;
  2094.     trace_ctx->trace_slice_no = 0;
  2095. }
  2096.  
  2097. static void va_TraceMPEG2Buf(
  2098.     VADisplay dpy,
  2099.     VAContextID context,
  2100.     VABufferID buffer,
  2101.     VABufferType type,
  2102.     unsigned int size,
  2103.     unsigned int num_elements,
  2104.     void *pbuf
  2105. )
  2106. {
  2107.     switch (type) {
  2108.     case VAPictureParameterBufferType:
  2109.         va_TraceVAPictureParameterBufferMPEG2(dpy, context, buffer, type, size, num_elements, pbuf);
  2110.         break;
  2111.     case VAIQMatrixBufferType:
  2112.         va_TraceVAIQMatrixBufferMPEG2(dpy, context, buffer, type, size, num_elements, pbuf);
  2113.         break;
  2114.     case VABitPlaneBufferType:
  2115.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2116.         break;
  2117.     case VASliceGroupMapBufferType:
  2118.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2119.         break;
  2120.     case VASliceParameterBufferType:
  2121.         va_TraceVASliceParameterBufferMPEG2(dpy, context, buffer, type, size, num_elements, pbuf);
  2122.         break;
  2123.     case VASliceDataBufferType:
  2124.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2125.         break;
  2126.     case VAMacroblockParameterBufferType:
  2127.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2128.         break;
  2129.     case VAResidualDataBufferType:
  2130.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2131.         break;
  2132.     case VADeblockingParameterBufferType:
  2133.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2134.         break;
  2135.     case VAImageBufferType:
  2136.         break;
  2137.     case VAProtectedSliceDataBufferType:
  2138.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2139.         break;
  2140.     case VAEncCodedBufferType:
  2141.         break;
  2142.     case VAEncSequenceParameterBufferType:
  2143.         break;
  2144.     case VAEncPictureParameterBufferType:
  2145.         break;
  2146.     case VAEncSliceParameterBufferType:
  2147.         break;
  2148.     default:
  2149.         break;
  2150.     }
  2151. }
  2152.  
  2153. static void va_TraceVAEncSequenceParameterBufferH263(
  2154.     VADisplay dpy,
  2155.     VAContextID context,
  2156.     VABufferID buffer,
  2157.     VABufferType type,
  2158.     unsigned int size,
  2159.     unsigned int num_elements,
  2160.     void *data)
  2161. {
  2162.     VAEncSequenceParameterBufferH263 *p = (VAEncSequenceParameterBufferH263 *)data;
  2163.     DPY2TRACECTX(dpy);
  2164.    
  2165.     va_TraceMsg(trace_ctx, "\t--VAEncSequenceParameterBufferH263\n");
  2166.    
  2167.     va_TraceMsg(trace_ctx, "\tintra_period = %d\n", p->intra_period);
  2168.     va_TraceMsg(trace_ctx, "\tbits_per_second = %d\n", p->bits_per_second);
  2169.     va_TraceMsg(trace_ctx, "\tframe_rate = %d\n", p->frame_rate);
  2170.     va_TraceMsg(trace_ctx, "\tinitial_qp = %d\n", p->initial_qp);
  2171.     va_TraceMsg(trace_ctx, "\tmin_qp = %d\n", p->min_qp);
  2172.     va_TraceMsg(trace_ctx, NULL);
  2173.  
  2174.     return;
  2175. }
  2176.  
  2177.  
  2178. static void va_TraceVAEncPictureParameterBufferH263(
  2179.     VADisplay dpy,
  2180.     VAContextID context,
  2181.     VABufferID buffer,
  2182.     VABufferType type,
  2183.     unsigned int size,
  2184.     unsigned int num_elements,
  2185.     void *data)
  2186. {
  2187.     VAEncPictureParameterBufferH263 *p = (VAEncPictureParameterBufferH263 *)data;
  2188.     DPY2TRACECTX(dpy);
  2189.    
  2190.     va_TraceMsg(trace_ctx, "\t--VAEncPictureParameterBufferH263\n");
  2191.     va_TraceMsg(trace_ctx, "\treference_picture = 0x%08x\n", p->reference_picture);
  2192.     va_TraceMsg(trace_ctx, "\treconstructed_picture = 0x%08x\n", p->reconstructed_picture);
  2193.     va_TraceMsg(trace_ctx, "\tcoded_buf = %08x\n", p->coded_buf);
  2194.     va_TraceMsg(trace_ctx, "\tpicture_width = %d\n", p->picture_width);
  2195.     va_TraceMsg(trace_ctx, "\tpicture_height = %d\n", p->picture_height);
  2196.     va_TraceMsg(trace_ctx, "\tpicture_type = 0x%08x\n", p->picture_type);
  2197.     va_TraceMsg(trace_ctx, NULL);
  2198.  
  2199.     return;
  2200. }
  2201.  
  2202. static void va_TraceVAEncPictureParameterBufferJPEG(
  2203.     VADisplay dpy,
  2204.     VAContextID context,
  2205.     VABufferID buffer,
  2206.     VABufferType type,
  2207.     unsigned int size,
  2208.     unsigned int num_elements,
  2209.     void *data)
  2210. {
  2211.     VAEncPictureParameterBufferJPEG *p = (VAEncPictureParameterBufferJPEG *)data;
  2212.     int i;
  2213.    
  2214.     DPY2TRACECTX(dpy);
  2215.    
  2216.     va_TraceMsg(trace_ctx, "\t--VAEncPictureParameterBufferJPEG\n");
  2217.     va_TraceMsg(trace_ctx, "\treconstructed_picture = 0x%08x\n", p->reconstructed_picture);
  2218.     va_TraceMsg(trace_ctx, "\tcoded_buf = %08x\n", p->coded_buf);
  2219.     va_TraceMsg(trace_ctx, "\tpicture_width = %d\n", p->picture_width);
  2220.     va_TraceMsg(trace_ctx, "\tpicture_height = %d\n", p->picture_height);
  2221.  
  2222.     va_TraceMsg(trace_ctx, NULL);
  2223.  
  2224.     return;
  2225. }
  2226.  
  2227. static void va_TraceVAEncQMatrixBufferJPEG(
  2228.     VADisplay dpy,
  2229.     VAContextID context,
  2230.     VABufferID buffer,
  2231.     VABufferType type,
  2232.     unsigned int size,
  2233.     unsigned int num_elements,
  2234.     void *data)
  2235. {
  2236.     VAQMatrixBufferJPEG *p = (VAQMatrixBufferJPEG *)data;
  2237.     DPY2TRACECTX(dpy);
  2238.    
  2239.     va_TraceMsg(trace_ctx, "\t--VAQMatrixBufferJPEG\n");
  2240.     va_TraceMsg(trace_ctx, "\tload_lum_quantiser_matrix = %d", p->load_lum_quantiser_matrix);
  2241.     if (p->load_lum_quantiser_matrix) {
  2242.         int i;
  2243.         for (i = 0; i < 64; i++) {
  2244.             if ((i % 8) == 0)
  2245.                 va_TraceMsg(trace_ctx, "\n\t");
  2246.             va_TraceMsg(trace_ctx, "\t0x%02x", p->lum_quantiser_matrix[i]);
  2247.         }
  2248.         va_TraceMsg(trace_ctx, "\n");
  2249.     }
  2250.     va_TraceMsg(trace_ctx, "\tload_chroma_quantiser_matrix = %08x\n", p->load_chroma_quantiser_matrix);
  2251.     if (p->load_chroma_quantiser_matrix) {
  2252.         int i;
  2253.         for (i = 0; i < 64; i++) {
  2254.             if ((i % 8) == 0)
  2255.                 va_TraceMsg(trace_ctx, "\n\t");
  2256.             va_TraceMsg(trace_ctx, "\t0x%02x", p->chroma_quantiser_matrix[i]);
  2257.         }
  2258.         va_TraceMsg(trace_ctx, "\n");
  2259.     }
  2260.    
  2261.     va_TraceMsg(trace_ctx, NULL);
  2262.    
  2263.     return;
  2264. }
  2265.  
  2266. static void va_TraceH263Buf(
  2267.     VADisplay dpy,
  2268.     VAContextID context,
  2269.     VABufferID buffer,
  2270.     VABufferType type,
  2271.     unsigned int size,
  2272.     unsigned int num_elements,
  2273.     void *pbuf
  2274. )
  2275. {
  2276.     switch (type) {
  2277.     case VAPictureParameterBufferType:/* print MPEG4 buffer */
  2278.         va_TraceVAPictureParameterBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
  2279.         break;
  2280.     case VAIQMatrixBufferType:/* print MPEG4 buffer */
  2281.         va_TraceVAIQMatrixBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
  2282.         break;
  2283.     case VABitPlaneBufferType:/* print MPEG4 buffer */
  2284.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2285.         break;
  2286.     case VASliceGroupMapBufferType:
  2287.         break;
  2288.     case VASliceParameterBufferType:/* print MPEG4 buffer */
  2289.         va_TraceVASliceParameterBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
  2290.         break;
  2291.     case VASliceDataBufferType:
  2292.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2293.         break;
  2294.     case VAMacroblockParameterBufferType:
  2295.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2296.         break;
  2297.     case VAResidualDataBufferType:
  2298.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2299.         break;
  2300.     case VADeblockingParameterBufferType:
  2301.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2302.         break;
  2303.     case VAImageBufferType:
  2304.         break;
  2305.     case VAProtectedSliceDataBufferType:
  2306.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2307.         break;
  2308.     case VAEncCodedBufferType:
  2309.         break;
  2310.     case VAEncSequenceParameterBufferType:
  2311.         va_TraceVAEncSequenceParameterBufferH263(dpy, context, buffer, type, size, num_elements, pbuf);
  2312.         break;
  2313.     case VAEncPictureParameterBufferType:
  2314.         va_TraceVAEncPictureParameterBufferH263(dpy, context, buffer, type, size, num_elements, pbuf);
  2315.         break;
  2316.     case VAEncSliceParameterBufferType:
  2317.         va_TraceVAEncSliceParameterBuffer(dpy, context, buffer, type, size, num_elements, pbuf);
  2318.         break;
  2319.     case VAEncPackedHeaderParameterBufferType:
  2320.         va_TraceVAEncPackedHeaderParameterBufferType(dpy, context, buffer, type, size, num_elements, pbuf);
  2321.         break;
  2322.     default:
  2323.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2324.         break;
  2325.     }
  2326. }
  2327.  
  2328.  
  2329. static void va_TraceJPEGBuf(
  2330.     VADisplay dpy,
  2331.     VAContextID context,
  2332.     VABufferID buffer,
  2333.     VABufferType type,
  2334.     unsigned int size,
  2335.     unsigned int num_elements,
  2336.     void *pbuf
  2337. )
  2338. {
  2339.     switch (type) {
  2340.     case VABitPlaneBufferType:
  2341.     case VASliceGroupMapBufferType:
  2342.     case VASliceDataBufferType:
  2343.     case VAMacroblockParameterBufferType:
  2344.     case VAResidualDataBufferType:
  2345.     case VADeblockingParameterBufferType:
  2346.     case VAImageBufferType:
  2347.     case VAProtectedSliceDataBufferType:
  2348.     case VAEncCodedBufferType:
  2349.     case VAEncSequenceParameterBufferType:
  2350.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2351.         break;
  2352.     case VAEncSliceParameterBufferType:
  2353.         va_TraceVAEncPictureParameterBufferJPEG(dpy, context, buffer, type, size, num_elements, pbuf);
  2354.         break;
  2355.     case VAPictureParameterBufferType:
  2356.         va_TraceVAPictureParameterBufferJPEG(dpy, context, buffer, type, size, num_elements, pbuf);
  2357.         break;
  2358.     case VAIQMatrixBufferType:
  2359.         va_TraceVAIQMatrixBufferJPEG(dpy, context, buffer, type, size, num_elements, pbuf);
  2360.         break;
  2361.     case VASliceParameterBufferType:
  2362.         va_TraceVASliceParameterBufferJPEG(dpy, context, buffer, type, size, num_elements, pbuf);
  2363.         break;
  2364.     case VAHuffmanTableBufferType:
  2365.         va_TraceVAHuffmanTableBufferJPEG(dpy, context, buffer, type, size, num_elements, pbuf);
  2366.         break;
  2367.     case VAEncPictureParameterBufferType:
  2368.         va_TraceVAEncPictureParameterBufferJPEG(dpy, context, buffer, type, size, num_elements, pbuf);
  2369.         break;
  2370.     case VAQMatrixBufferType:
  2371.         va_TraceVAEncQMatrixBufferJPEG(dpy, context, buffer, type, size, num_elements, pbuf);
  2372.         break;
  2373.     default:
  2374.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2375.         break;
  2376.     }
  2377. }
  2378.  
  2379. static void va_TraceMPEG4Buf(
  2380.     VADisplay dpy,
  2381.     VAContextID context,
  2382.     VABufferID buffer,
  2383.     VABufferType type,
  2384.     unsigned int size,
  2385.     unsigned int num_elements,
  2386.     void *pbuf
  2387. )
  2388. {
  2389.     switch (type) {
  2390.     case VAPictureParameterBufferType:
  2391.         va_TraceVAPictureParameterBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
  2392.         break;
  2393.     case VAIQMatrixBufferType:
  2394.         va_TraceVAIQMatrixBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
  2395.         break;
  2396.     case VABitPlaneBufferType:
  2397.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2398.         break;
  2399.     case VASliceGroupMapBufferType:
  2400.         break;
  2401.     case VASliceParameterBufferType:
  2402.         va_TraceVASliceParameterBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
  2403.         break;
  2404.     case VASliceDataBufferType:
  2405.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2406.         break;
  2407.     case VAMacroblockParameterBufferType:
  2408.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2409.         break;
  2410.     case VAResidualDataBufferType:
  2411.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2412.         break;
  2413.     case VADeblockingParameterBufferType:
  2414.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2415.         break;
  2416.     case VAImageBufferType:
  2417.         break;
  2418.     case VAProtectedSliceDataBufferType:
  2419.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2420.         break;
  2421.     case VAEncCodedBufferType:
  2422.         break;
  2423.     case VAEncSequenceParameterBufferType:
  2424.         va_TraceVAEncSequenceParameterBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
  2425.         break;
  2426.     case VAEncPictureParameterBufferType:
  2427.         va_TraceVAEncPictureParameterBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
  2428.         break;
  2429.     case VAEncSliceParameterBufferType:
  2430.         va_TraceVAEncSliceParameterBuffer(dpy, context, buffer, type, size, num_elements, pbuf);
  2431.         break;
  2432.     default:
  2433.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2434.         break;
  2435.     }
  2436. }
  2437.  
  2438.  
  2439. static void va_TraceH264Buf(
  2440.     VADisplay dpy,
  2441.     VAContextID context,
  2442.     VABufferID buffer,
  2443.     VABufferType type,
  2444.     unsigned int size,
  2445.     unsigned int num_elements,
  2446.     void *pbuf
  2447. )
  2448. {
  2449.     DPY2TRACECTX(dpy);
  2450.    
  2451.     switch (type) {
  2452.     case VAPictureParameterBufferType:
  2453.         va_TraceVAPictureParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
  2454.         break;
  2455.     case VAIQMatrixBufferType:
  2456.         va_TraceVAIQMatrixBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
  2457.         break;
  2458.     case VABitPlaneBufferType:
  2459.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);        
  2460.         break;
  2461.     case VASliceGroupMapBufferType:
  2462.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2463.         break;
  2464.     case VASliceParameterBufferType:
  2465.         va_TraceVASliceParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
  2466.         break;
  2467.     case VASliceDataBufferType:
  2468.         va_TraceVABuffers(dpy, context, buffer, type, trace_ctx->trace_slice_size, num_elements, pbuf);
  2469.         break;
  2470.     case VAMacroblockParameterBufferType:
  2471.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);        
  2472.         break;
  2473.     case VAResidualDataBufferType:
  2474.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);        
  2475.         break;
  2476.     case VADeblockingParameterBufferType:
  2477.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2478.         break;
  2479.     case VAImageBufferType:
  2480.         break;
  2481.     case VAProtectedSliceDataBufferType:
  2482.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2483.         break;
  2484.     case VAEncCodedBufferType:
  2485.         break;
  2486.     case VAEncSequenceParameterBufferType:
  2487.         va_TraceVAEncSequenceParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
  2488.         break;
  2489.     case VAEncPictureParameterBufferType:
  2490.         va_TraceVAEncPictureParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
  2491.         break;
  2492.     case VAEncSliceParameterBufferType:
  2493.         if (size == sizeof(VAEncSliceParameterBuffer))
  2494.             va_TraceVAEncSliceParameterBuffer(dpy, context, buffer, type, size, num_elements, pbuf);
  2495.         else
  2496.             va_TraceVAEncSliceParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
  2497.         break;
  2498.     case VAEncPackedHeaderParameterBufferType:
  2499.         va_TraceVAEncPackedHeaderParameterBufferType(dpy, context, buffer, type, size, num_elements, pbuf);
  2500.         break;
  2501.        
  2502.     case VAEncMiscParameterBufferType:
  2503.         va_TraceVAEncMiscParameterBuffer(dpy, context, buffer, type, size, num_elements, pbuf);
  2504.         break;
  2505.     default:
  2506.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2507.         break;
  2508.     }
  2509. }
  2510.  
  2511. static void va_TraceVP8Buf(
  2512.     VADisplay dpy,
  2513.     VAContextID context,
  2514.     VABufferID buffer,
  2515.     VABufferType type,
  2516.     unsigned int size,
  2517.     unsigned int num_elements,
  2518.     void *pbuf
  2519. )
  2520. {
  2521.     DPY2TRACECTX(dpy);
  2522.  
  2523.     switch (type) {
  2524.     case VAPictureParameterBufferType:
  2525.         va_TraceVAPictureParameterBufferVP8(dpy, context, buffer, type, size, num_elements, pbuf);
  2526.         break;
  2527.     case VAIQMatrixBufferType:
  2528.         va_TraceVAIQMatrixBufferVP8(dpy, context, buffer, type, size, num_elements, pbuf);
  2529.         break;
  2530.     case VABitPlaneBufferType:
  2531.         break;
  2532.     case VASliceGroupMapBufferType:
  2533.         break;
  2534.     case VASliceParameterBufferType:
  2535.         va_TraceVASliceParameterBufferVP8(dpy, context, buffer, type, size, num_elements, pbuf);
  2536.         break;
  2537.     case VASliceDataBufferType:
  2538.         break;
  2539.     case VAProbabilityBufferType:
  2540.         va_TraceVAProbabilityBufferVP8(dpy, context, buffer, type, size, num_elements, pbuf);
  2541.         break;
  2542.     case VAMacroblockParameterBufferType:
  2543.         break;
  2544.     case VAResidualDataBufferType:
  2545.         break;
  2546.     case VADeblockingParameterBufferType:
  2547.         break;
  2548.     case VAImageBufferType:
  2549.         break;
  2550.     case VAProtectedSliceDataBufferType:
  2551.         break;
  2552.     case VAEncCodedBufferType:
  2553.         break;
  2554.     case VAEncSequenceParameterBufferType:
  2555.         break;
  2556.     case VAEncPictureParameterBufferType:
  2557.         break;
  2558.     case VAEncSliceParameterBufferType:
  2559.         break;
  2560.     case VAEncPackedHeaderParameterBufferType:
  2561.         break;
  2562.     case VAEncMiscParameterBufferType:
  2563.         break;
  2564.     default:
  2565.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2566.         break;
  2567.     }
  2568. }
  2569.  
  2570. static void va_TraceVC1Buf(
  2571.     VADisplay dpy,
  2572.     VAContextID context,
  2573.     VABufferID buffer,
  2574.     VABufferType type,
  2575.     unsigned int size,
  2576.     unsigned int num_elements,
  2577.     void *pbuf
  2578. )
  2579. {
  2580.     DPY2TRACECTX(dpy);
  2581.  
  2582.     switch (type) {
  2583.     case VAPictureParameterBufferType:
  2584.         va_TraceVAPictureParameterBufferVC1(dpy, context, buffer, type, size, num_elements, pbuf);
  2585.         break;
  2586.     case VAIQMatrixBufferType:
  2587.         break;
  2588.     case VABitPlaneBufferType:
  2589.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2590.         break;
  2591.     case VASliceGroupMapBufferType:
  2592.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2593.         break;
  2594.     case VASliceParameterBufferType:
  2595.         va_TraceVASliceParameterBufferVC1(dpy, context, buffer, type, size, num_elements, pbuf);
  2596.         break;
  2597.     case VASliceDataBufferType:
  2598.         va_TraceVABuffers(dpy, context, buffer, type, trace_ctx->trace_slice_size, num_elements, pbuf);
  2599.         break;
  2600.     case VAMacroblockParameterBufferType:
  2601.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2602.         break;
  2603.     case VAResidualDataBufferType:
  2604.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2605.         break;
  2606.     case VADeblockingParameterBufferType:
  2607.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2608.         break;
  2609.     case VAImageBufferType:
  2610.         break;
  2611.     case VAProtectedSliceDataBufferType:
  2612.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2613.         break;
  2614.     case VAEncCodedBufferType:
  2615.         break;
  2616.     case VAEncSequenceParameterBufferType:
  2617.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2618.         break;
  2619.     case VAEncPictureParameterBufferType:
  2620.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2621.         break;
  2622.     case VAEncSliceParameterBufferType:
  2623.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2624.         break;
  2625.     default:
  2626.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2627.         break;
  2628.     }
  2629. }
  2630.  
  2631. static void
  2632. va_TraceProcFilterParameterBufferDeinterlacing(
  2633.     VADisplay dpy,
  2634.     VAContextID context,
  2635.     VAProcFilterParameterBufferBase *base
  2636. )
  2637. {
  2638.     VAProcFilterParameterBufferDeinterlacing *deint = (VAProcFilterParameterBufferDeinterlacing *)base;
  2639.  
  2640.     DPY2TRACECTX(dpy);
  2641.  
  2642.     va_TraceMsg(trace_ctx, "\t    type = %d\n", deint->type);
  2643.     va_TraceMsg(trace_ctx, "\t    algorithm = %d\n", deint->algorithm);
  2644.     va_TraceMsg(trace_ctx, "\t    flags = %d\n", deint->flags);
  2645. }
  2646.  
  2647. static void
  2648. va_TraceProcFilterParameterBufferColorBalance(
  2649.     VADisplay dpy,
  2650.     VAContextID context,
  2651.     VAProcFilterParameterBufferBase *base
  2652. )
  2653. {
  2654.     VAProcFilterParameterBufferColorBalance *color_balance = (VAProcFilterParameterBufferColorBalance *)base;
  2655.  
  2656.     DPY2TRACECTX(dpy);
  2657.  
  2658.     va_TraceMsg(trace_ctx, "\t    type = %d\n", color_balance->type);
  2659.     va_TraceMsg(trace_ctx, "\t    attrib = %d\n", color_balance->attrib);
  2660.     va_TraceMsg(trace_ctx, "\t    value = %f\n", color_balance->value);
  2661. }
  2662.  
  2663. static void
  2664. va_TraceProcFilterParameterBufferBase(
  2665.     VADisplay dpy,
  2666.     VAContextID context,
  2667.     VAProcFilterParameterBufferBase *base
  2668. )
  2669. {
  2670.     DPY2TRACECTX(dpy);
  2671.  
  2672.     va_TraceMsg(trace_ctx, "\t    type = %d\n", base->type);
  2673. }
  2674.  
  2675. static void
  2676. va_TraceProcFilterParameterBuffer(
  2677.     VADisplay dpy,
  2678.     VAContextID context,
  2679.     VABufferID *filters,
  2680.     unsigned int num_filters
  2681. )
  2682. {
  2683.     VABufferType type;
  2684.     unsigned int size;
  2685.     unsigned int num_elements;
  2686.     VAProcFilterParameterBufferBase *base_filter = NULL;
  2687.     int i;
  2688.  
  2689.     DPY2TRACECTX(dpy);
  2690.  
  2691.     if (num_filters == 0 || filters == NULL) {
  2692.         va_TraceMsg(trace_ctx, "\t  num_filters = %d\n", num_filters);
  2693.         va_TraceMsg(trace_ctx, "\t  filters = %p\n", filters);
  2694.         return;
  2695.     }
  2696.  
  2697.     va_TraceMsg(trace_ctx, "\t  num_filters = %d\n", num_filters);
  2698.  
  2699.     /* get buffer type information */
  2700.     for (i = 0; i < num_filters; i++) {
  2701.         vaBufferInfo(dpy, context, filters[i], &type, &size, &num_elements);
  2702.  
  2703.         if (type != VAProcFilterParameterBufferType) {
  2704.             va_TraceMsg(trace_ctx, "\t  filters[%d] = 0x%08x (INVALID)\n", i, filters[i]);
  2705.             return;
  2706.         } else {
  2707.             va_TraceMsg(trace_ctx, "\t  filters[%d] = 0x%08x\n", i, filters[i]);
  2708.         }
  2709.  
  2710.         base_filter = NULL;
  2711.         vaMapBuffer(dpy, filters[i], (void **)&base_filter);
  2712.  
  2713.         if (base_filter == NULL) {
  2714.             vaUnmapBuffer(dpy, filters[i]);
  2715.             return;
  2716.         }
  2717.  
  2718.         switch (base_filter->type) {
  2719.         case VAProcFilterDeinterlacing:
  2720.             va_TraceProcFilterParameterBufferDeinterlacing(dpy,
  2721.                                                            context,
  2722.                                                            base_filter);
  2723.             break;
  2724.         case VAProcFilterColorBalance:
  2725.             va_TraceProcFilterParameterBufferColorBalance(dpy,
  2726.                                                           context,
  2727.                                                           base_filter);
  2728.             break;
  2729.         default:
  2730.             va_TraceProcFilterParameterBufferBase(dpy,
  2731.                                                   context,
  2732.                                                   base_filter);
  2733.             break;
  2734.         }
  2735.  
  2736.         vaUnmapBuffer(dpy, filters[i]);
  2737.     }
  2738. }
  2739.  
  2740. static void
  2741. va_TraceVAProcPipelineParameterBuffer(
  2742.     VADisplay dpy,
  2743.     VAContextID context,
  2744.     VABufferID buffer,
  2745.     VABufferType type,
  2746.     unsigned int size,
  2747.     unsigned int num_elements,
  2748.     void *data
  2749. )
  2750. {
  2751.     VAProcPipelineParameterBuffer *p = (VAProcPipelineParameterBuffer *)data;
  2752.     int i;
  2753.  
  2754.     DPY2TRACECTX(dpy);
  2755.  
  2756.     va_TraceMsg(trace_ctx, "\t--VAProcPipelineParameterBuffer\n");
  2757.  
  2758.     va_TraceMsg(trace_ctx, "\t  surface = 0x%08x\n", p->surface);
  2759.  
  2760.     if (p->surface_region) {
  2761.         va_TraceMsg(trace_ctx, "\t  surface_region\n");
  2762.         va_TraceMsg(trace_ctx, "\t    x = %d\n", p->surface_region->x);
  2763.         va_TraceMsg(trace_ctx, "\t    y = %d\n", p->surface_region->y);
  2764.         va_TraceMsg(trace_ctx, "\t    width = %d\n", p->surface_region->width);
  2765.         va_TraceMsg(trace_ctx, "\t    height = %d\n", p->surface_region->height);
  2766.     } else {
  2767.         va_TraceMsg(trace_ctx, "\t  surface_region = (NULL)\n");
  2768.     }
  2769.  
  2770.     va_TraceMsg(trace_ctx, "\t  surface_color_standard = %d\n", p->surface_color_standard);
  2771.  
  2772.     if (p->output_region) {
  2773.         va_TraceMsg(trace_ctx, "\t  output_region\n");
  2774.         va_TraceMsg(trace_ctx, "\t    x = %d\n", p->output_region->x);
  2775.         va_TraceMsg(trace_ctx, "\t    y = %d\n", p->output_region->y);
  2776.         va_TraceMsg(trace_ctx, "\t    width = %d\n", p->output_region->width);
  2777.         va_TraceMsg(trace_ctx, "\t    height = %d\n", p->output_region->height);
  2778.     } else {
  2779.         va_TraceMsg(trace_ctx, "\t  output_region = (NULL)\n");
  2780.     }
  2781.  
  2782.     va_TraceMsg(trace_ctx, "\t  output_background_color = 0x%08x\n", p->output_background_color);
  2783.     va_TraceMsg(trace_ctx, "\t  output_color_standard = %d\n", p->output_color_standard);
  2784.     va_TraceMsg(trace_ctx, "\t  pipeline_flags = 0x%08x\n", p->pipeline_flags);
  2785.     va_TraceMsg(trace_ctx, "\t  filter_flags = 0x%08x\n", p->filter_flags);
  2786.  
  2787.     va_TraceProcFilterParameterBuffer(dpy, context, p->filters, p->num_filters);
  2788.  
  2789.     va_TraceMsg(trace_ctx, "\t  num_forward_references = 0x%08x\n", p->num_forward_references);
  2790.  
  2791.     if (p->num_forward_references) {
  2792.         va_TraceMsg(trace_ctx, "\t  forward_references\n");
  2793.  
  2794.         if (p->forward_references) {
  2795.             /* only dump the first 5 forward references */
  2796.             for (i = 0; i < p->num_forward_references && i < 5; i++) {
  2797.                 va_TraceMsg(trace_ctx, "\t    forward_references[%d] = 0x%08x\n", i, p->forward_references[i]);
  2798.             }
  2799.         } else {
  2800.             for (i = 0; i < p->num_forward_references && i < 5; i++) {
  2801.                 va_TraceMsg(trace_ctx, "\t    forward_references[%d] = (NULL)\n", i);
  2802.             }
  2803.         }
  2804.     }
  2805.  
  2806.     va_TraceMsg(trace_ctx, "\t  num_backward_references = 0x%08x\n", p->num_backward_references);
  2807.  
  2808.     if (p->num_backward_references) {
  2809.         va_TraceMsg(trace_ctx, "\t  backward_references\n");
  2810.  
  2811.         if (p->backward_references) {
  2812.             /* only dump the first 5 backward references */
  2813.             for (i = 0; i < p->num_backward_references && i < 5; i++) {
  2814.                 va_TraceMsg(trace_ctx, "\t    backward_references[%d] = 0x%08x\n", i, p->backward_references[i]);
  2815.             }
  2816.         } else {
  2817.             for (i = 0; i < p->num_backward_references && i < 5; i++) {
  2818.                 va_TraceMsg(trace_ctx, "\t    backward_references[%d] = (NULL)\n", i);
  2819.             }
  2820.         }
  2821.     }
  2822.  
  2823.     /* FIXME: add other info later */
  2824.  
  2825.     va_TraceMsg(trace_ctx, NULL);
  2826. }
  2827.  
  2828. static void
  2829. va_TraceNoneBuf(
  2830.     VADisplay dpy,
  2831.     VAContextID context,
  2832.     VABufferID buffer,
  2833.     VABufferType type,
  2834.     unsigned int size,
  2835.     unsigned int num_elements,
  2836.     void *pbuf
  2837. )
  2838. {
  2839.     DPY2TRACECTX(dpy);
  2840.  
  2841.     switch (type) {
  2842.     case VAProcPipelineParameterBufferType:
  2843.         va_TraceVAProcPipelineParameterBuffer(dpy, context, buffer, type, size, num_elements, pbuf);
  2844.         break;
  2845.     default:
  2846.         va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
  2847.         break;
  2848.     }
  2849. }
  2850.  
  2851. void va_TraceRenderPicture(
  2852.     VADisplay dpy,
  2853.     VAContextID context,
  2854.     VABufferID *buffers,
  2855.     int num_buffers
  2856. )
  2857. {
  2858.     VABufferType type;
  2859.     unsigned int size;
  2860.     unsigned int num_elements;
  2861.     int i;
  2862.     DPY2TRACECTX(dpy);
  2863.  
  2864.     TRACE_FUNCNAME(idx);
  2865.    
  2866.     va_TraceMsg(trace_ctx, "\tcontext = 0x%08x\n", context);
  2867.     va_TraceMsg(trace_ctx, "\tnum_buffers = %d\n", num_buffers);
  2868.     if (buffers == NULL)
  2869.         return;
  2870.    
  2871.     for (i = 0; i < num_buffers; i++) {
  2872.         unsigned char *pbuf = NULL;
  2873.         unsigned int j;
  2874.        
  2875.         /* get buffer type information */
  2876.         vaBufferInfo(dpy, context, buffers[i], &type, &size, &num_elements);
  2877.  
  2878.         va_TraceMsg(trace_ctx, "\t---------------------------\n");
  2879.         va_TraceMsg(trace_ctx, "\tbuffers[%d] = 0x%08x\n", i, buffers[i]);
  2880.         va_TraceMsg(trace_ctx, "\t  type = %s\n", buffer_type_to_string(type));
  2881.         va_TraceMsg(trace_ctx, "\t  size = %d\n", size);
  2882.         va_TraceMsg(trace_ctx, "\t  num_elements = %d\n", num_elements);
  2883.  
  2884.         vaMapBuffer(dpy, buffers[i], (void **)&pbuf);
  2885.         if (pbuf == NULL)
  2886.             continue;
  2887.        
  2888.         switch (trace_ctx->trace_profile) {
  2889.         case VAProfileMPEG2Simple:
  2890.         case VAProfileMPEG2Main:
  2891.             for (j=0; j<num_elements; j++) {
  2892.                 va_TraceMsg(trace_ctx, "\telement[%d] =\n", j);
  2893.                 va_TraceMPEG2Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
  2894.             }
  2895.             break;
  2896.         case VAProfileMPEG4Simple:
  2897.         case VAProfileMPEG4AdvancedSimple:
  2898.         case VAProfileMPEG4Main:
  2899.             for (j=0; j<num_elements; j++) {
  2900.                 va_TraceMsg(trace_ctx, "\telement[%d] =\n", j);
  2901.                 va_TraceMPEG4Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
  2902.             }
  2903.             break;
  2904.         case VAProfileH264Baseline:
  2905.         case VAProfileH264Main:
  2906.         case VAProfileH264High:
  2907.         case VAProfileH264ConstrainedBaseline:
  2908.             for (j=0; j<num_elements; j++) {
  2909.                 va_TraceMsg(trace_ctx, "\telement[%d] =\n", j);
  2910.                
  2911.                 va_TraceH264Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
  2912.             }
  2913.             break;
  2914.         case VAProfileVC1Simple:
  2915.         case VAProfileVC1Main:
  2916.         case VAProfileVC1Advanced:
  2917.             for (j=0; j<num_elements; j++) {
  2918.                 va_TraceMsg(trace_ctx, "\telement[%d] =\n", j);
  2919.                
  2920.                 va_TraceVC1Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
  2921.             }
  2922.             break;
  2923.         case VAProfileH263Baseline:
  2924.             for (j=0; j<num_elements; j++) {
  2925.                 va_TraceMsg(trace_ctx, "\telement[%d] =\n", j);
  2926.                
  2927.                 va_TraceH263Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
  2928.             }
  2929.             break;
  2930.         case VAProfileJPEGBaseline:
  2931.             for (j=0; j<num_elements; j++) {
  2932.                 va_TraceMsg(trace_ctx, "\telement[%d] =\n", j);
  2933.                
  2934.                 va_TraceJPEGBuf (dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
  2935.             }
  2936.             break;
  2937.  
  2938.         case VAProfileNone:
  2939.             for (j=0; j<num_elements; j++) {
  2940.                 va_TraceMsg(trace_ctx, "\telement[%d] =\n", j);
  2941.  
  2942.                 va_TraceNoneBuf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
  2943.             }
  2944.             break;
  2945.  
  2946.         case VAProfileVP8Version0_3:
  2947.             for (j=0; j<num_elements; j++) {
  2948.                 va_TraceMsg(trace_ctx, "\telement[%d] =\n", j);
  2949.  
  2950.                 va_TraceVP8Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
  2951.             }
  2952.             break;
  2953.  
  2954.         default:
  2955.             break;
  2956.         }
  2957.  
  2958.         vaUnmapBuffer(dpy, buffers[i]);
  2959.     }
  2960.  
  2961.     va_TraceMsg(trace_ctx, NULL);
  2962. }
  2963.  
  2964. void va_TraceEndPicture(
  2965.     VADisplay dpy,
  2966.     VAContextID context,
  2967.     int endpic_done
  2968. )
  2969. {
  2970.     int encode, decode, jpeg;
  2971.     DPY2TRACECTX(dpy);
  2972.  
  2973.     TRACE_FUNCNAME(idx);
  2974.  
  2975.     va_TraceMsg(trace_ctx, "\tcontext = 0x%08x\n", context);
  2976.     va_TraceMsg(trace_ctx, "\trender_targets = 0x%08x\n", trace_ctx->trace_rendertarget);
  2977.  
  2978.     /* avoid to create so many empty files */
  2979.     encode = (trace_ctx->trace_entrypoint == VAEntrypointEncSlice);
  2980.     decode = (trace_ctx->trace_entrypoint == VAEntrypointVLD);
  2981.     jpeg = (trace_ctx->trace_entrypoint == VAEntrypointEncPicture);
  2982.  
  2983.     /* trace encode source surface, can do it before HW completes rendering */
  2984.     if ((encode && (trace_flag & VA_TRACE_FLAG_SURFACE_ENCODE))||
  2985.         (jpeg && (trace_flag & VA_TRACE_FLAG_SURFACE_JPEG)))
  2986.         va_TraceSurface(dpy);
  2987.    
  2988.     /* trace decoded surface, do it after HW completes rendering */
  2989.     if (decode && ((trace_flag & VA_TRACE_FLAG_SURFACE_DECODE))) {
  2990.         vaSyncSurface(dpy, trace_ctx->trace_rendertarget);
  2991.         va_TraceSurface(dpy);
  2992.     }
  2993.  
  2994.     va_TraceMsg(trace_ctx, NULL);
  2995. }
  2996.  
  2997.  
  2998. void va_TraceSyncSurface(
  2999.     VADisplay dpy,
  3000.     VASurfaceID render_target
  3001. )
  3002. {
  3003.     DPY2TRACECTX(dpy);
  3004.  
  3005.     TRACE_FUNCNAME(idx);
  3006.  
  3007.     va_TraceMsg(trace_ctx, "\trender_target = 0x%08x\n", render_target);
  3008.     va_TraceMsg(trace_ctx, NULL);
  3009. }
  3010.  
  3011. void va_TraceQuerySurfaceAttributes(
  3012.     VADisplay           dpy,
  3013.     VAConfigID          config,
  3014.     VASurfaceAttrib    *attrib_list,
  3015.     unsigned int       *num_attribs
  3016. )
  3017. {
  3018.     DPY2TRACECTX(dpy);
  3019.  
  3020.     TRACE_FUNCNAME(idx);
  3021.     va_TraceMsg(trace_ctx, "\tconfig = 0x%08x\n", config);
  3022.     va_TraceSurfaceAttributes(trace_ctx, attrib_list, num_attribs);
  3023.    
  3024.     va_TraceMsg(trace_ctx, NULL);
  3025.  
  3026. }
  3027.  
  3028.  
  3029. void va_TraceQuerySurfaceStatus(
  3030.     VADisplay dpy,
  3031.     VASurfaceID render_target,
  3032.     VASurfaceStatus *status    /* out */
  3033. )
  3034. {
  3035.     DPY2TRACECTX(dpy);
  3036.  
  3037.     TRACE_FUNCNAME(idx);
  3038.  
  3039.     va_TraceMsg(trace_ctx, "\trender_target = 0x%08x\n", render_target);
  3040.     if (status)
  3041.         va_TraceMsg(trace_ctx, "\tstatus = 0x%08x\n", *status);
  3042.     va_TraceMsg(trace_ctx, NULL);
  3043. }
  3044.  
  3045.  
  3046. void va_TraceQuerySurfaceError(
  3047.     VADisplay dpy,
  3048.     VASurfaceID surface,
  3049.     VAStatus error_status,
  3050.     void **error_info       /*out*/
  3051. )
  3052. {
  3053.     DPY2TRACECTX(dpy);
  3054.  
  3055.     TRACE_FUNCNAME(idx);
  3056.     va_TraceMsg(trace_ctx, "\tsurface = 0x%08x\n", surface);
  3057.     va_TraceMsg(trace_ctx, "\terror_status = 0x%08x\n", error_status);
  3058.     if (error_info && (error_status == VA_STATUS_ERROR_DECODING_ERROR)) {
  3059.         VASurfaceDecodeMBErrors *p = *error_info;
  3060.         while (p && (p->status != -1)) {
  3061.             va_TraceMsg(trace_ctx, "\t\tstatus = %d\n", p->status);
  3062.             va_TraceMsg(trace_ctx, "\t\tstart_mb = %d\n", p->start_mb);
  3063.             va_TraceMsg(trace_ctx, "\t\tend_mb = %d\n", p->end_mb);
  3064.             p++; /* next error record */
  3065.         }
  3066.     }
  3067.     va_TraceMsg(trace_ctx, NULL);
  3068. }
  3069.  
  3070. void va_TraceMaxNumDisplayAttributes (
  3071.     VADisplay dpy,
  3072.     int number
  3073. )
  3074. {
  3075.     DPY2TRACECTX(dpy);
  3076.  
  3077.     TRACE_FUNCNAME(idx);
  3078.    
  3079.     va_TraceMsg(trace_ctx, "\tmax_display_attributes = %d\n", number);
  3080.     va_TraceMsg(trace_ctx, NULL);
  3081. }
  3082.  
  3083. void va_TraceQueryDisplayAttributes (
  3084.     VADisplay dpy,
  3085.     VADisplayAttribute *attr_list,    /* out */
  3086.     int *num_attributes               /* out */
  3087. )
  3088. {
  3089.     int i;
  3090.    
  3091.     DPY2TRACECTX(dpy);
  3092.    
  3093.     if (attr_list == NULL || num_attributes == NULL)
  3094.         return;
  3095.  
  3096.     va_TraceMsg(trace_ctx, "\tnum_attributes = %d\n", *num_attributes);
  3097.    
  3098.     for (i=0; i<*num_attributes; i++) {
  3099.         va_TraceMsg(trace_ctx, "\tattr_list[%d] =\n");
  3100.         va_TraceMsg(trace_ctx, "\t  typ = 0x%08x\n", attr_list[i].type);
  3101.         va_TraceMsg(trace_ctx, "\t  min_value = %d\n", attr_list[i].min_value);
  3102.         va_TraceMsg(trace_ctx, "\t  max_value = %d\n", attr_list[i].max_value);
  3103.         va_TraceMsg(trace_ctx, "\t  value = %d\n", attr_list[i].value);
  3104.         va_TraceMsg(trace_ctx, "\t  flags = %d\n", attr_list[i].flags);
  3105.     }
  3106.     va_TraceMsg(trace_ctx, NULL);
  3107. }
  3108.  
  3109.  
  3110. static void va_TraceDisplayAttributes (
  3111.     VADisplay dpy,
  3112.     VADisplayAttribute *attr_list,
  3113.     int num_attributes
  3114. )
  3115. {
  3116.     int i;
  3117.    
  3118.     DPY2TRACECTX(dpy);
  3119.    
  3120.     va_TraceMsg(trace_ctx, "\tnum_attributes = %d\n", num_attributes);
  3121.     if (attr_list == NULL)
  3122.         return;
  3123.    
  3124.     for (i=0; i<num_attributes; i++) {
  3125.         va_TraceMsg(trace_ctx, "\tattr_list[%d] =\n");
  3126.         va_TraceMsg(trace_ctx, "\t  typ = 0x%08x\n", attr_list[i].type);
  3127.         va_TraceMsg(trace_ctx, "\t  min_value = %d\n", attr_list[i].min_value);
  3128.         va_TraceMsg(trace_ctx, "\t  max_value = %d\n", attr_list[i].max_value);
  3129.         va_TraceMsg(trace_ctx, "\t  value = %d\n", attr_list[i].value);
  3130.         va_TraceMsg(trace_ctx, "\t  flags = %d\n", attr_list[i].flags);
  3131.     }
  3132.     va_TraceMsg(trace_ctx, NULL);
  3133. }
  3134.  
  3135.  
  3136. void va_TraceGetDisplayAttributes (
  3137.     VADisplay dpy,
  3138.     VADisplayAttribute *attr_list,
  3139.     int num_attributes
  3140. )
  3141. {
  3142.     DPY2TRACECTX(dpy);
  3143.  
  3144.     TRACE_FUNCNAME(idx);
  3145.  
  3146.     va_TraceDisplayAttributes (dpy, attr_list, num_attributes);
  3147. }
  3148.  
  3149. void va_TraceSetDisplayAttributes (
  3150.     VADisplay dpy,
  3151.     VADisplayAttribute *attr_list,
  3152.     int num_attributes
  3153. )
  3154. {
  3155.     DPY2TRACECTX(dpy);
  3156.  
  3157.     TRACE_FUNCNAME(idx);
  3158.  
  3159.     va_TraceDisplayAttributes (dpy, attr_list, num_attributes);
  3160. }
  3161.  
  3162.  
  3163. void va_TracePutSurface (
  3164.     VADisplay dpy,
  3165.     VASurfaceID surface,
  3166.     void *draw, /* the target Drawable */
  3167.     short srcx,
  3168.     short srcy,
  3169.     unsigned short srcw,
  3170.     unsigned short srch,
  3171.     short destx,
  3172.     short desty,
  3173.     unsigned short destw,
  3174.     unsigned short desth,
  3175.     VARectangle *cliprects, /* client supplied clip list */
  3176.     unsigned int number_cliprects, /* number of clip rects in the clip list */
  3177.     unsigned int flags /* de-interlacing flags */
  3178. )
  3179. {
  3180.     DPY2TRACECTX(dpy);
  3181.  
  3182.     TRACE_FUNCNAME(idx);
  3183.    
  3184.     va_TraceMsg(trace_ctx, "\tsurface = 0x%08x\n", surface);
  3185.     va_TraceMsg(trace_ctx, "\tdraw = 0x%08x\n", draw);
  3186.     va_TraceMsg(trace_ctx, "\tsrcx = %d\n", srcx);
  3187.     va_TraceMsg(trace_ctx, "\tsrcy = %d\n", srcy);
  3188.     va_TraceMsg(trace_ctx, "\tsrcw = %d\n", srcw);
  3189.     va_TraceMsg(trace_ctx, "\tsrch = %d\n", srch);
  3190.     va_TraceMsg(trace_ctx, "\tdestx = %d\n", destx);
  3191.     va_TraceMsg(trace_ctx, "\tdesty = %d\n", desty);
  3192.     va_TraceMsg(trace_ctx, "\tdestw = %d\n", destw);
  3193.     va_TraceMsg(trace_ctx, "\tdesth = %d\n", desth);
  3194.     va_TraceMsg(trace_ctx, "\tcliprects = 0x%08x\n", cliprects);
  3195.     va_TraceMsg(trace_ctx, "\tnumber_cliprects = %d\n", number_cliprects);
  3196.     va_TraceMsg(trace_ctx, "\tflags = 0x%08x\n", flags);
  3197.     va_TraceMsg(trace_ctx, NULL);
  3198. }
  3199.