Subversion Repositories Kolibri OS

 * Copyright (c) 2009-2011 Intel Corporation. All Rights Reserved.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the

 * "Software"), to deal in the Software without restriction, including

 * without limitation the rights to use, copy, modify, merge, publish,

 * distribute, sub license, and/or sell copies of the Software, and to

 * permit persons to whom the Software is furnished to do so, subject to

 * the following conditions:

 *

 * The above copyright notice and this permission notice (including the

 * next paragraph) shall be included in all copies or substantial portions

 * of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.

 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR

 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 */

#include "sysdeps.h"

#include "va.h"

#include "va_enc_h264.h"

#include "va_backend.h"

#include "va_trace.h"

#include "va_enc_h264.h"

#include "va_enc_jpeg.h"

#include "va_enc_vp8.h"

#include "va_dec_jpeg.h"

#include "va_dec_vp8.h"

#include "va_dec_vp9.h"

#include "va_dec_hevc.h"

#include "va_vpp.h"

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

 * Env. to debug some issue, e.g. the decode/encode issue in a video conference scenerio:

 * .LIBVA_TRACE=log_file: general VA parameters saved into log_file

 * .LIBVA_TRACE_BUFDATA: dump all VA data buffer into log_file

 * .LIBVA_TRACE_CODEDBUF=coded_clip_file: save the coded clip into file coded_clip_file

 * .LIBVA_TRACE_SURFACE=yuv_file: save surface YUV into file yuv_file. Use file name to determine

 *                                decode/encode or jpeg surfaces

 * .LIBVA_TRACE_SURFACE_GEOMETRY=WIDTHxHEIGHT+XOFF+YOFF: only save part of surface context into file

 *                                due to storage bandwidth limitation

 */

int trace_flag = 0;

struct trace_context {

    /* LIBVA_TRACE */

    FILE *trace_fp_log; /* save the log into a file */

    char *trace_log_fn; /* file name */

    FILE *trace_fp_codedbuf; /* save the encode result into a file */

    char *trace_codedbuf_fn; /* file name */

    FILE *trace_fp_surface; /* save the surface YUV into a file */

    char *trace_surface_fn; /* file name */

    VAProfile trace_profile; /* current profile for buffers */

    VAEntrypoint trace_entrypoint; /* current entrypoint */

    unsigned int trace_slice_no; /* current slice NO */

    unsigned int trace_slice_size; /* current slice buffer size */

    unsigned int trace_surface_height;

    unsigned int trace_surface_xoff;

    unsigned int trace_surface_yoff;

    unsigned int trace_frame_height; /* current frame height */

};

    struct trace_context *trace_ctx = TRACE_CTX(dpy);   \

                                                        \

    if (trace_ctx == NULL)                              \

        return;                                         \

void va_infoMessage(const char *msg, ...);

    VADisplay dpy,

    VAContextID context,        /* in */

    VABufferID buf_id,          /* in */

    VABufferType *type,         /* out */

    unsigned int *size,         /* out */

    unsigned int *num_elements  /* out */

    );

                       VASurfaceID surface,

                       unsigned int *fourcc, /* following are output argument */

                       unsigned int *luma_stride,

                       unsigned int *chroma_u_stride,

                       unsigned int *chroma_v_stride,

                       unsigned int *luma_offset,

                       unsigned int *chroma_u_offset,

                       unsigned int *chroma_v_offset,

                       unsigned int *buffer_name,

                       void **buffer

                       );

                         VASurfaceID surface

                         );

do {                                                    \

    int tmp = strnlen(env_value, sizeof(env_value));    \

    int left = sizeof(env_value) - tmp;                 \

                                                        \

    snprintf(env_value+tmp,                             \

             left,                                      \

             ".%04d.%08lx",                             \

             suffix,                                    \

             (unsigned long)trace_ctx);                 \

} while (0)

{

    char env_value[1024];

    unsigned short suffix = 0xffff & ((unsigned int)time(NULL));

    int trace_index = 0;

    FILE *tmp;

    struct trace_context *trace_ctx = calloc(sizeof(struct trace_context), 1);

        return;

        FILE_NAME_SUFFIX(env_value);

        trace_ctx->trace_log_fn = strdup(env_value);

        if (tmp) {

            trace_ctx->trace_fp_log = tmp;

            va_infoMessage("LIBVA_TRACE is on, save log into %s\n", trace_ctx->trace_log_fn);

            trace_flag = VA_TRACE_FLAG_LOG;

        } else

            va_errorMessage("Open file %s failed (%s)\n", env_value, strerror(errno));

    }

    if ((trace_flag & VA_TRACE_FLAG_LOG) && (va_parseConfig("LIBVA_TRACE_BUFDATA", NULL) == 0)) {

        trace_flag |= VA_TRACE_FLAG_BUFDATA;

        va_infoMessage("LIBVA_TRACE_BUFDATA is on, dump buffer into log file\n");

    }

    if (va_parseConfig("LIBVA_TRACE_CODEDBUF", &env_value[0]) == 0) {

        FILE_NAME_SUFFIX(env_value);

        trace_ctx->trace_codedbuf_fn = strdup(env_value);

        va_infoMessage("LIBVA_TRACE_CODEDBUF is on, save codedbuf into log file %s\n",

                       trace_ctx->trace_codedbuf_fn);

        trace_flag |= VA_TRACE_FLAG_CODEDBUF;

    }

        FILE_NAME_SUFFIX(env_value);

        trace_ctx->trace_surface_fn = strdup(env_value);

                       trace_ctx->trace_surface_fn);

         * cause some side-effect, so only trace the needed surfaces

         * to trace encode surface, set the trace file name to sth like *enc*

         * to trace decode surface, set the trace file name to sth like *dec*

         * if no dec/enc in file name, set both

         */

        if (strstr(env_value, "dec"))

            trace_flag |= VA_TRACE_FLAG_SURFACE_DECODE;

        if (strstr(env_value, "enc"))

            trace_flag |= VA_TRACE_FLAG_SURFACE_ENCODE;

        if (strstr(env_value, "jpeg") || strstr(env_value, "jpg"))

            trace_flag |= VA_TRACE_FLAG_SURFACE_JPEG;

            char *p = env_value, *q;

            p = q+1; /* skip "x" */

            trace_ctx->trace_surface_height = strtod(p, &q);

            p = q+1; /* skip "+" */

            trace_ctx->trace_surface_xoff = strtod(p, &q);

            p = q+1; /* skip "+" */

            trace_ctx->trace_surface_yoff = strtod(p, &q);

                           trace_ctx->trace_surface_width,

                           trace_ctx->trace_surface_height,

                           trace_ctx->trace_surface_xoff,

                           trace_ctx->trace_surface_yoff);

        }

    }

}

{

    DPY2TRACECTX(dpy);

        fclose(trace_ctx->trace_fp_log);

        fclose(trace_ctx->trace_fp_codedbuf);

        fclose(trace_ctx->trace_fp_surface);

        free(trace_ctx->trace_log_fn);

        free(trace_ctx->trace_codedbuf_fn);

        free(trace_ctx->trace_surface_fn);

    ((VADisplayContextP)dpy)->vatrace = NULL;

}

{

    va_list args;

        return;

        struct timeval tv;

            fprintf(trace_ctx->trace_fp_log, "[%04d.%06d] ",

                    (unsigned int)tv.tv_sec & 0xffff, (unsigned int)tv.tv_usec);

        va_start(args, msg);

        vfprintf(trace_ctx->trace_fp_log, msg, args);

        va_end(args);

    } else

        fflush(trace_ctx->trace_fp_log);

}

{

    unsigned int i, j;

    unsigned int fourcc; /* following are output argument */

    unsigned int luma_stride;

    unsigned int chroma_u_stride;

    unsigned int chroma_v_stride;

    unsigned int luma_offset;

    unsigned int chroma_u_offset;

    unsigned int chroma_v_offset;

    unsigned int buffer_name;

    void *buffer = NULL;

    unsigned char *Y_data, *UV_data, *tmp;

    VAStatus va_status;

    unsigned char check_sum = 0;

    DPY2TRACECTX(dpy);

        return;

        dpy,

        trace_ctx->trace_rendertarget,

        &fourcc,

        &luma_stride, &chroma_u_stride, &chroma_v_stride,

        &luma_offset, &chroma_u_offset, &chroma_v_offset,

        &buffer_name, &buffer);

        va_TraceMsg(trace_ctx, "Error:vaLockSurface failed\n");

        return;

    }

    va_TraceMsg(trace_ctx, "\twidth = %d\n", trace_ctx->trace_frame_width);

    va_TraceMsg(trace_ctx, "\theight = %d\n", trace_ctx->trace_frame_height);

    va_TraceMsg(trace_ctx, "\tluma_stride = %d\n", luma_stride);

    va_TraceMsg(trace_ctx, "\tchroma_u_stride = %d\n", chroma_u_stride);

    va_TraceMsg(trace_ctx, "\tchroma_v_stride = %d\n", chroma_v_stride);

    va_TraceMsg(trace_ctx, "\tluma_offset = %d\n", luma_offset);

    va_TraceMsg(trace_ctx, "\tchroma_u_offset = %d\n", chroma_u_offset);

    va_TraceMsg(trace_ctx, "\tchroma_v_offset = %d\n", chroma_v_offset);

        va_TraceMsg(trace_ctx, "Error:vaLockSurface return NULL buffer\n");

        va_TraceMsg(trace_ctx, NULL);

        return;

    }

    va_TraceMsg(trace_ctx, "\tbuffer location = 0x%08x\n", buffer);

    va_TraceMsg(trace_ctx, NULL);

    UV_data = (unsigned char*)buffer + chroma_u_offset;

    for (i=0; itrace_surface_height; i++) {

        fwrite(tmp + trace_ctx->trace_surface_xoff,

               trace_ctx->trace_surface_width,

               1, trace_ctx->trace_fp_surface);

    }

    tmp = UV_data + chroma_u_stride * trace_ctx->trace_surface_yoff / 2;

    if (fourcc == VA_FOURCC_NV12) {

        for (i=0; itrace_surface_height/2; i++) {

            fwrite(tmp + trace_ctx->trace_surface_xoff,

                   trace_ctx->trace_surface_width,

                   1, trace_ctx->trace_fp_surface);

        }

    }

}

    VADisplay dpy,

    int *major_version,     /* out */

    int *minor_version      /* out */

)

{

    DPY2TRACECTX(dpy);

    TRACE_FUNCNAME(idx);

}

    VADisplay dpy

)

{

    DPY2TRACECTX(dpy);

    TRACE_FUNCNAME(idx);

}

    VADisplay dpy,

    VAProfile profile,

    VAEntrypoint entrypoint,

    VAConfigAttrib *attrib_list,

    int num_attribs,

    VAConfigID *config_id /* out */

)

{

    int i;

    int encode, decode, jpeg;

    DPY2TRACECTX(dpy);

    va_TraceMsg(trace_ctx, "\tentrypoint = %d\n", entrypoint);

    va_TraceMsg(trace_ctx, "\tnum_attribs = %d\n", num_attribs);

    if (attrib_list) {

        for (i = 0; i < num_attribs; i++) {

            va_TraceMsg(trace_ctx, "\t\tattrib_list[%d].type = 0x%08x\n", i, attrib_list[i].type);

            va_TraceMsg(trace_ctx, "\t\tattrib_list[%d].value = 0x%08x\n", i, attrib_list[i].value);

        }

    }

    va_TraceMsg(trace_ctx, NULL);

    trace_ctx->trace_entrypoint = entrypoint;

    encode = (trace_ctx->trace_entrypoint == VAEntrypointEncSlice);

    decode = (trace_ctx->trace_entrypoint == VAEntrypointVLD);

    jpeg = (trace_ctx->trace_entrypoint == VAEntrypointEncPicture);

    if ((encode && (trace_flag & VA_TRACE_FLAG_SURFACE_ENCODE)) ||

        (decode && (trace_flag & VA_TRACE_FLAG_SURFACE_DECODE)) ||

        (jpeg && (trace_flag & VA_TRACE_FLAG_SURFACE_JPEG))) {

        FILE *tmp = fopen(trace_ctx->trace_surface_fn, "w");

            trace_ctx->trace_fp_surface = tmp;

        else {

            va_errorMessage("Open file %s failed (%s)\n",

                            trace_ctx->trace_surface_fn,

                            strerror(errno));

            trace_ctx->trace_fp_surface = NULL;

            trace_flag &= ~(VA_TRACE_FLAG_SURFACE);

        }

    }

        FILE *tmp = fopen(trace_ctx->trace_codedbuf_fn, "w");

            trace_ctx->trace_fp_codedbuf = tmp;

        else {

            va_errorMessage("Open file %s failed (%s)\n",

                            trace_ctx->trace_codedbuf_fn,

                            strerror(errno));

            trace_ctx->trace_fp_codedbuf = NULL;

            trace_flag &= ~VA_TRACE_FLAG_CODEDBUF;

        }

    }

}

    struct trace_context *trace_ctx,

    VASurfaceAttrib    *attrib_list,

    unsigned int       *num_attribs

)

{

    int i, num;

    VASurfaceAttrib *p;

        return;

    num = *num_attribs;

    if (num > VASurfaceAttribCount)

        num = VASurfaceAttribCount;

        int type = p->value.type;

        va_TraceMsg(trace_ctx, "\t\tflags = %d\n", p->flags);

        va_TraceMsg(trace_ctx, "\t\tvalue.type = %d\n", type);

        switch (type) {

        case VAGenericValueTypeInteger:

            va_TraceMsg(trace_ctx, "\t\tvalue.value.i = 0x%08x\n", p->value.value.i);

            break;

        case VAGenericValueTypeFloat:

            va_TraceMsg(trace_ctx, "\t\tvalue.value.f = %f\n", p->value.value.f);

            break;

        case VAGenericValueTypePointer:

            va_TraceMsg(trace_ctx, "\t\tvalue.value.p = %p\n", p->value.value.p);

            if ((p->type == VASurfaceAttribExternalBufferDescriptor) && p->value.value.p) {

                VASurfaceAttribExternalBuffers *tmp = (VASurfaceAttribExternalBuffers *) p->value.value.p;

                int j;

                va_TraceMsg(trace_ctx, "\t\t  pixel_format=0x%08x\n", tmp->pixel_format);

                va_TraceMsg(trace_ctx, "\t\t  width=%d\n", tmp->width);

                va_TraceMsg(trace_ctx, "\t\t  height=%d\n", tmp->height);

                va_TraceMsg(trace_ctx, "\t\t  data_size=%d\n", tmp->data_size);

                va_TraceMsg(trace_ctx, "\t\t  num_planes=%d\n", tmp->num_planes);

                va_TraceMsg(trace_ctx, "\t\t  pitches[4]=%d %d %d %d\n",

                            tmp->pitches[0], tmp->pitches[1], tmp->pitches[2], tmp->pitches[3]);

                va_TraceMsg(trace_ctx, "\t\t  offsets[4]=%d %d %d %d\n",

                            tmp->offsets[0], tmp->offsets[1], tmp->offsets[2], tmp->offsets[3]);

                va_TraceMsg(trace_ctx, "\t\t  flags=0x%08x\n", tmp->flags);

                va_TraceMsg(trace_ctx, "\t\t  num_buffers=0x%08x\n", tmp->num_buffers);

                va_TraceMsg(trace_ctx, "\t\t  buffers=%p\n", tmp->buffers);

                for (j = 0; j < tmp->num_buffers; j++) {

                    va_TraceMsg(trace_ctx, "\t\t\tbuffers[%d]=%p\n", j, tmp->buffers[j]);

                }

            }

            break;

        case VAGenericValueTypeFunc:

            va_TraceMsg(trace_ctx, "\t\tvalue.value.fn = %p\n", p->value.value.fn);

            break;

        default:

            break;

        }

    }

}

    VADisplay dpy,

    int width,

    int height,

    int format,

    int num_surfaces,

    VASurfaceID *surfaces,    /* out */

    VASurfaceAttrib    *attrib_list,

    unsigned int        num_attribs

)

{

    int i;

    DPY2TRACECTX(dpy);

    va_TraceMsg(trace_ctx, "\theight = %d\n", height);

    va_TraceMsg(trace_ctx, "\tformat = %d\n", format);

    va_TraceMsg(trace_ctx, "\tnum_surfaces = %d\n", num_surfaces);

        for (i = 0; i < num_surfaces; i++)

            va_TraceMsg(trace_ctx, "\t\tsurfaces[%d] = 0x%08x\n", i, surfaces[i]);

    }

}

    VADisplay dpy,

    VASurfaceID *surface_list,

    int num_surfaces

)

{

    int i;

    DPY2TRACECTX(dpy);

        for (i = 0; i < num_surfaces; i++)

            va_TraceMsg(trace_ctx, "\t\tsurfaces[%d] = 0x%08x\n", i, surface_list[i]);

    }

}

    VADisplay dpy,

    VAConfigID config_id,

    int picture_width,

    int picture_height,

    int flag,

    VASurfaceID *render_targets,

    int num_render_targets,

    VAContextID *context        /* out */

)

{

    int i;

    DPY2TRACECTX(dpy);

    va_TraceMsg(trace_ctx, "\twidth = %d\n", picture_width);

    va_TraceMsg(trace_ctx, "\theight = %d\n", picture_height);

    va_TraceMsg(trace_ctx, "\tflag = 0x%08x\n", flag);

    va_TraceMsg(trace_ctx, "\tnum_render_targets = %d\n", num_render_targets);

    if (render_targets) {

        for (i=0; i

            va_TraceMsg(trace_ctx, "\t\trender_targets[%d] = 0x%08x\n", i, render_targets[i]);

    }

    if (context) {

        va_TraceMsg(trace_ctx, "\tcontext = 0x%08x\n", *context);

        trace_ctx->trace_context = *context;

    } else

        trace_ctx->trace_context = VA_INVALID_ID;

    trace_ctx->trace_slice_no = 0;

    trace_ctx->trace_frame_height = picture_height;

        trace_ctx->trace_surface_width = picture_width;

    if (trace_ctx->trace_surface_height == 0)

        trace_ctx->trace_surface_height = picture_height;

}

{

    switch (type) {

    case VAPictureParameterBufferType: return "VAPictureParameterBufferType";

    case VAIQMatrixBufferType: return "VAIQMatrixBufferType";

    case VABitPlaneBufferType: return "VABitPlaneBufferType";

    case VASliceGroupMapBufferType: return "VASliceGroupMapBufferType";

    case VASliceParameterBufferType: return "VASliceParameterBufferType";

    case VASliceDataBufferType: return "VASliceDataBufferType";

    case VAProtectedSliceDataBufferType: return "VAProtectedSliceDataBufferType";

    case VAMacroblockParameterBufferType: return "VAMacroblockParameterBufferType";

    case VAResidualDataBufferType: return "VAResidualDataBufferType";

    case VADeblockingParameterBufferType: return "VADeblockingParameterBufferType";

    case VAImageBufferType: return "VAImageBufferType";

    case VAQMatrixBufferType: return "VAQMatrixBufferType";

    case VAHuffmanTableBufferType: return "VAHuffmanTableBufferType";

/* Following are encode buffer types */

    case VAEncCodedBufferType: return "VAEncCodedBufferType";

    case VAEncSequenceParameterBufferType: return "VAEncSequenceParameterBufferType";

    case VAEncPictureParameterBufferType: return "VAEncPictureParameterBufferType";

    case VAEncSliceParameterBufferType: return "VAEncSliceParameterBufferType";

    case VAEncPackedHeaderParameterBufferType: return "VAEncPackedHeaderParameterBufferType";

    case VAEncPackedHeaderDataBufferType: return "VAEncPackedHeaderDataBufferType";

    case VAEncMiscParameterBufferType: return "VAEncMiscParameterBufferType";

    case VAEncMacroblockParameterBufferType: return "VAEncMacroblockParameterBufferType";

    case VAProcPipelineParameterBufferType: return "VAProcPipelineParameterBufferType";

    case VAProcFilterParameterBufferType: return "VAProcFilterParameterBufferType";

    default: return "UnknowBuffer";

    }

}

    VADisplay dpy,

    VAContextID context,	/* in */

    VABufferType type,		/* in */

    unsigned int size,		/* in */

    unsigned int num_elements,	/* in */

    void *data,			/* in */

    VABufferID *buf_id		/* out */

)

{

    DPY2TRACECTX(dpy);

    if (type != VAEncCodedBufferType)

        return;

    va_TraceMsg(trace_ctx, "\tbuf_type=%s\n", buffer_type_to_string(type));

    if (buf_id)

        va_TraceMsg(trace_ctx, "\tbuf_id=0x%x\n", *buf_id);

    va_TraceMsg(trace_ctx, "\tsize=%u\n", size);

    va_TraceMsg(trace_ctx, "\tnum_elements=%u\n", num_elements);

}

    VADisplay dpy,

    VABufferID buf_id    /* in */

)

{

    VABufferType type;

    unsigned int size;

    unsigned int num_elements;

    int i = 0;

    if (type != VAEncCodedBufferType)

        return;

    va_TraceMsg(trace_ctx, "\tbuf_type=%s\n", buffer_type_to_string(type));

    va_TraceMsg(trace_ctx, "\tbuf_id=0x%x\n", buf_id);

    va_TraceMsg(trace_ctx, "\tsize=%u\n", size);

    va_TraceMsg(trace_ctx, "\tnum_elements=%u\n", num_elements);

}

{

    mem[0] = val;

    mem[1] = val>>8;

}

{

    mem[0] = val;

    mem[1] = val>>8;

    mem[2] = val>>16;

    mem[3] = val>>24;

}

{

    VACodedBufferSegment *buf_list;

    unsigned int frame_length = 0;

    char header[32];

        header[0] = 'D';

        header[1] = 'K';

        header[2] = 'I';

        header[3] = 'F';

        mem_put_le16(header+4,  0);                     /* version */

        mem_put_le16(header+6,  32);                    /* headersize */

        mem_put_le32(header+8,  0x30385056);            /* headersize */

        /* write width and height of the first rc_param to IVF file header */

        mem_put_le16(header+12, trace_ctx->trace_frame_width);  /* width */

        mem_put_le16(header+14, trace_ctx->trace_frame_height); /* height */

        mem_put_le32(header+16, 30);            /* rate */

        mem_put_le32(header+20, 1);                     /* scale */

        mem_put_le32(header+24, 0xffffffff);            /* length */

        mem_put_le32(header+28, 0);                     /* unused */

        fwrite(header, 1, 32, trace_ctx->trace_fp_codedbuf);

    }

    while (buf_list != NULL) {

        frame_length += buf_list->size;

        buf_list = (VACodedBufferSegment *) buf_list->next;

    }

    mem_put_le32(header, frame_length);

    mem_put_le32(header+4, trace_ctx->pts&0xFFFFFFFF);

    mem_put_le32(header+8, 0);

    fwrite(header, 1, 12, trace_ctx->trace_fp_codedbuf);

    trace_ctx->pts++;

}

    VADisplay dpy,

    VABufferID buf_id,    /* in */

    void **pbuf           /* out */

)

{

    VABufferType type;

    unsigned int size;

    unsigned int num_elements;

    int i = 0;

    if (type != VAEncCodedBufferType)

        return;

    va_TraceMsg(trace_ctx, "\tbuf_id=0x%x\n", buf_id);

    va_TraceMsg(trace_ctx, "\tbuf_type=%s\n", buffer_type_to_string(type));

    if ((pbuf == NULL) || (*pbuf == NULL))

        return;

        va_TraceMsg(trace_ctx, "\tAdd IVF header information\n");

        va_TraceCodedBufferIVFHeader(trace_ctx, pbuf);

    }

    while (buf_list != NULL) {

        va_TraceMsg(trace_ctx, "\tCodedbuf[%d] =\n", i++);

        va_TraceMsg(trace_ctx, "\t   bit_offset = %u\n", buf_list->bit_offset);

        va_TraceMsg(trace_ctx, "\t   status = 0x%08x\n", buf_list->status);

        va_TraceMsg(trace_ctx, "\t   reserved = 0x%08x\n", buf_list->reserved);

        va_TraceMsg(trace_ctx, "\t   buf = 0x%08x\n", buf_list->buf);

            va_TraceMsg(trace_ctx, "\tDump the content to file\n");

            fwrite(buf_list->buf, buf_list->size, 1, trace_ctx->trace_fp_codedbuf);

        }

    }

    va_TraceMsg(trace_ctx, NULL);

}

    VADisplay dpy,

    VAContextID context,

    VABufferID buffer,

    VABufferType type,

    unsigned int size,

    unsigned int num_elements,

    void *pbuf

)

{

    unsigned int i;

    unsigned char *p = pbuf;

        for (i=0; i

            unsigned char value =  p[i];

                fprintf(trace_ctx->trace_fp_log, "\t\t0x%04x:", i);

            else if ((i%16) == 0)

                fprintf(trace_ctx->trace_fp_log, "\n\t\t0x%04x:", i);

        }

        fprintf(trace_ctx->trace_fp_log, "\n");

    }

}

    VADisplay dpy,

    VAContextID context,

    VABufferID buffer,

    VABufferType type,

    unsigned int size,

    unsigned int num_elements,

    void *data)

{

    VAPictureParameterBufferMPEG2 *p=(VAPictureParameterBufferMPEG2 *)data;

    DPY2TRACECTX(dpy);

    va_TraceMsg(trace_ctx,"\tvertical size= %d\n", p->vertical_size);

    va_TraceMsg(trace_ctx,"\tforward reference picture= %d\n", p->forward_reference_picture);

    va_TraceMsg(trace_ctx,"\tbackward reference picture= %d\n", p->backward_reference_picture);

    va_TraceMsg(trace_ctx,"\tpicture coding type= %d\n", p->picture_coding_type);

    va_TraceMsg(trace_ctx,"\tf mode= %d\n", p->f_code);

    va_TraceMsg(trace_ctx,"\tintra_dc_precision= %d\n", p->picture_coding_extension.bits.intra_dc_precision);

    va_TraceMsg(trace_ctx,"\tpicture_structure= %d\n", p->picture_coding_extension.bits.picture_structure);

    va_TraceMsg(trace_ctx,"\ttop_field_first= %d\n", p->picture_coding_extension.bits.top_field_first);

    va_TraceMsg(trace_ctx,"\tframe_pred_frame_dct= %d\n", p->picture_coding_extension.bits.frame_pred_frame_dct);

    va_TraceMsg(trace_ctx,"\tconcealment_motion_vectors= %d\n", p->picture_coding_extension.bits.concealment_motion_vectors);

    va_TraceMsg(trace_ctx,"\tq_scale_type= %d\n", p->picture_coding_extension.bits.q_scale_type);

    va_TraceMsg(trace_ctx,"\tintra_vlc_format= %d\n", p->picture_coding_extension.bits.intra_vlc_format);

    va_TraceMsg(trace_ctx,"\talternate_scan= %d\n", p->picture_coding_extension.bits.alternate_scan);

    va_TraceMsg(trace_ctx,"\trepeat_first_field= %d\n", p->picture_coding_extension.bits.repeat_first_field);

    va_TraceMsg(trace_ctx,"\tprogressive_frame= %d\n", p->picture_coding_extension.bits.progressive_frame);

    va_TraceMsg(trace_ctx,"\tis_first_field= %d\n", p->picture_coding_extension.bits.is_first_field);

    va_TraceMsg(trace_ctx, NULL);

}

    VADisplay dpy,

    VAContextID context,

    VABufferID buffer,

    VABufferType type,

    unsigned int size,

    unsigned int num_elements,

    void *data)

{

    VAIQMatrixBufferMPEG2 *p=(VAIQMatrixBufferMPEG2 *)data;

    DPY2TRACECTX(dpy);

    va_TraceMsg(trace_ctx,"\tload_non_intra_quantiser_matrix = %d\n", p->load_non_intra_quantiser_matrix);

    va_TraceMsg(trace_ctx,"\tload_chroma_intra_quantiser_matrix = %d\n", p->load_chroma_intra_quantiser_matrix);

    va_TraceMsg(trace_ctx,"\tload_chroma_non_intra_quantiser_matrix = %d\n", p->load_chroma_non_intra_quantiser_matrix);

    va_TraceMsg(trace_ctx,"\tintra_quantiser_matrix = %d\n", p->intra_quantiser_matrix);

    va_TraceMsg(trace_ctx,"\tnon_intra_quantiser_matrix = %d\n", p->non_intra_quantiser_matrix);

    va_TraceMsg(trace_ctx,"\tchroma_intra_quantiser_matrix = %d\n", p->chroma_intra_quantiser_matrix);

    va_TraceMsg(trace_ctx,"\tchroma_non_intra_quantiser_matrix = %d\n", p->chroma_non_intra_quantiser_matrix);

    va_TraceMsg(trace_ctx, NULL);

}

    VADisplay dpy,

    VAContextID context,

    VABufferID buffer,

    VABufferType type,

    unsigned int size,

    unsigned int num_elements,

    void *data)

{

    VASliceParameterBufferMPEG2 *p=(VASliceParameterBufferMPEG2 *)data;

    va_TraceMsg(trace_ctx,"\tslice_data_offset = %d\n", p->slice_data_offset);

    va_TraceMsg(trace_ctx,"\tslice_data_flag = %d\n", p->slice_data_flag);

    va_TraceMsg(trace_ctx,"\tmacroblock_offset = %d\n", p->macroblock_offset);

    va_TraceMsg(trace_ctx,"\tslice_horizontal_position = %d\n", p->slice_horizontal_position);

    va_TraceMsg(trace_ctx,"\tslice_vertical_position = %d\n", p->slice_vertical_position);

    va_TraceMsg(trace_ctx,"\tquantiser_scale_code = %d\n", p->quantiser_scale_code);

    va_TraceMsg(trace_ctx,"\tintra_slice_flag = %d\n", p->intra_slice_flag);

    va_TraceMsg(trace_ctx, NULL);

}

    VADisplay dpy,

    VAContextID context,

    VABufferID buffer,

    VABufferType type,

    unsigned int size,

    unsigned int num_elements,

    void *data)

{

    int i;

    VAPictureParameterBufferJPEGBaseline *p=(VAPictureParameterBufferJPEGBaseline *)data;

    DPY2TRACECTX(dpy);

    va_TraceMsg(trace_ctx,"\tpicture_width = %u\n", p->picture_width);

    va_TraceMsg(trace_ctx,"\tpicture_height = %u\n", p->picture_height);

    va_TraceMsg(trace_ctx,"\tcomponents = \n");

    for (i = 0; i < p->num_components && i < 255; ++i) {

        va_TraceMsg(trace_ctx,"\t\t[%d] component_id = %u\n", i, p->components[i].component_id);

        va_TraceMsg(trace_ctx,"\t\t[%d] h_sampling_factor = %u\n", i, p->components[i].h_sampling_factor);

        va_TraceMsg(trace_ctx,"\t\t[%d] v_sampling_factor = %u\n", i, p->components[i].v_sampling_factor);

        va_TraceMsg(trace_ctx,"\t\t[%d] quantiser_table_selector = %u\n", i, p->components[i].quantiser_table_selector);

    }

}

    VADisplay dpy,

    VAContextID context,

    VABufferID buffer,

    VABufferType type,

    unsigned int size,

    unsigned int num_elements,

    void *data)

{

    int i, j;

    static char tmp[1024];

    VAIQMatrixBufferJPEGBaseline *p=(VAIQMatrixBufferJPEGBaseline *)data;

    DPY2TRACECTX(dpy);

    va_TraceMsg(trace_ctx,"*VAIQMatrixParameterBufferJPEG\n");

    va_TraceMsg(trace_ctx,"\tload_quantiser_table =\n");

    for (i = 0; i < 4; ++i) {

        va_TraceMsg(trace_ctx,"\t\t[%d] = %u\n", i, p->load_quantiser_table[i]);

    }

    va_TraceMsg(trace_ctx,"\tquantiser_table =\n");

    for (i = 0; i < 4; ++i) {

        memset(tmp, 0, sizeof tmp);

        for (j = 0; j < 64; ++j) {

            sprintf(tmp + strlen(tmp), "%u ", p->quantiser_table[i][j]);

        }

        va_TraceMsg(trace_ctx,"\t\t[%d] = %s\n", i, tmp);

    }

}

    VADisplay dpy,

    VAContextID context,

    VABufferID buffer,

    VABufferType type,

    unsigned int size,

    unsigned int num_elements,

    void *data)

{

    int i;

    VASliceParameterBufferJPEGBaseline *p=(VASliceParameterBufferJPEGBaseline *)data;

    DPY2TRACECTX(dpy);

    va_TraceMsg(trace_ctx,"*VASliceParameterBufferJPEG\n");

    va_TraceMsg(trace_ctx,"\tslice_data_size = %u\n", p->slice_data_size);

    va_TraceMsg(trace_ctx,"\tslice_data_offset = %u\n", p->slice_data_offset);

    va_TraceMsg(trace_ctx,"\tslice_data_flag = %u\n", p->slice_data_flag);

    va_TraceMsg(trace_ctx,"\tslice_horizontal_position = %u\n", p->slice_horizontal_position);

    va_TraceMsg(trace_ctx,"\tslice_vertical_position = %u\n", p->slice_vertical_position);

    va_TraceMsg(trace_ctx,"\tcomponents = \n");

    for (i = 0; i < p->num_components && i < 4; ++i) {

        va_TraceMsg(trace_ctx,"\t\t[%d] component_selector = %u\n", i, p->components[i].component_selector);

        va_TraceMsg(trace_ctx,"\t\t[%d] dc_table_selector = %u\n", i, p->components[i].dc_table_selector);

        va_TraceMsg(trace_ctx,"\t\t[%d] ac_table_selector = %u\n", i, p->components[i].ac_table_selector);

    }

    va_TraceMsg(trace_ctx,"\trestart_interval = %u\n", p->restart_interval);

    va_TraceMsg(trace_ctx,"\tnum_mcus = %u\n", p->num_mcus);

}

    VADisplay dpy,

    VAContextID context,

    VABufferID buffer,

    VABufferType type,

    unsigned int size,

    unsigned int num_elements,

    void *data)

{

    int i, j;

    static char tmp[1024];

    VAHuffmanTableBufferJPEGBaseline *p=(VAHuffmanTableBufferJPEGBaseline *)data;

    DPY2TRACECTX(dpy);

    va_TraceMsg(trace_ctx,"*VAHuffmanTableBufferJPEG\n");

        va_TraceMsg(trace_ctx,"\tload_huffman_table[%d] =%u\n", i, p->load_huffman_table[0]);

        va_TraceMsg(trace_ctx,"\thuffman_table[%d] =\n", i);

        memset(tmp, 0, sizeof tmp);

        for (j = 0; j < 16; ++j) {

            sprintf(tmp + strlen(tmp), "%u ", p->huffman_table[i].num_dc_codes[j]);

        }

        va_TraceMsg(trace_ctx,"\t\tnum_dc_codes =%s\n", tmp);

        memset(tmp, 0, sizeof tmp);

        for (j = 0; j < 12; ++j) {

            sprintf(tmp + strlen(tmp), "%u ", p->huffman_table[i].dc_values[j]);

        }

        va_TraceMsg(trace_ctx,"\t\tdc_values =%s\n", tmp);

        memset(tmp, 0, sizeof tmp);

        for (j = 0; j < 16; ++j) {

            sprintf(tmp + strlen(tmp), "%u ", p->huffman_table[i].num_ac_codes[j]);

        }

        va_TraceMsg(trace_ctx,"\t\tnum_ac_codes =%s\n", tmp);

        memset(tmp, 0, sizeof tmp);

        for (j = 0; j < 162; ++j) {

            sprintf(tmp + strlen(tmp), "%u ", p->huffman_table[i].ac_values[j]);

        }

        va_TraceMsg(trace_ctx,"\t\tac_values =%s\n", tmp);

        memset(tmp, 0, sizeof tmp);

        for (j = 0; j < 2; ++j) {

            sprintf(tmp + strlen(tmp), "%u ", p->huffman_table[i].pad[j]);

        }

        va_TraceMsg(trace_ctx,"\t\tpad =%s\n", tmp);

    }

}

    VADisplay dpy,

    VAContextID context,

    VABufferID buffer,

    VABufferType type,

    unsigned int size,

    unsigned int num_elements,

    void *data)

{

    int i;

    VAPictureParameterBufferMPEG4 *p=(VAPictureParameterBufferMPEG4 *)data;

    va_TraceMsg(trace_ctx,"\tvop_width = %d\n", p->vop_width);

    va_TraceMsg(trace_ctx,"\tvop_height = %d\n", p->vop_height);

    va_TraceMsg(trace_ctx,"\tforward_reference_picture = %d\n", p->forward_reference_picture);

    va_TraceMsg(trace_ctx,"\tbackward_reference_picture = %d\n", p->backward_reference_picture);

    va_TraceMsg(trace_ctx,"\tvol_fields value = %d\n", p->vol_fields.value);

    va_TraceMsg(trace_ctx,"\tshort_video_header= %d\n", p->vol_fields.bits.short_video_header);

    va_TraceMsg(trace_ctx,"\tchroma_format= %d\n", p->vol_fields.bits.chroma_format);

    va_TraceMsg(trace_ctx,"\tinterlaced= %d\n", p->vol_fields.bits.interlaced);

    va_TraceMsg(trace_ctx,"\tobmc_disable= %d\n", p->vol_fields.bits.obmc_disable);

    va_TraceMsg(trace_ctx,"\tsprite_enable= %d\n", p->vol_fields.bits.sprite_enable);

    va_TraceMsg(trace_ctx,"\tsprite_warping_accuracy= %d\n", p->vol_fields.bits.sprite_warping_accuracy);

    va_TraceMsg(trace_ctx,"\tquant_type= %d\n", p->vol_fields.bits.quant_type);

    va_TraceMsg(trace_ctx,"\tquarter_sample= %d\n", p->vol_fields.bits.quarter_sample);

    va_TraceMsg(trace_ctx,"\tdata_partitioned= %d\n", p->vol_fields.bits.data_partitioned);

    va_TraceMsg(trace_ctx,"\treversible_vlc= %d\n", p->vol_fields.bits.reversible_vlc);

    va_TraceMsg(trace_ctx,"\tresync_marker_disable= %d\n", p->vol_fields.bits.resync_marker_disable);

    va_TraceMsg(trace_ctx,"\tno_of_sprite_warping_points = %d\n", p->no_of_sprite_warping_points);

    va_TraceMsg(trace_ctx,"\tsprite_trajectory_du =");

    for(i=0;i<3;i++)

        va_TraceMsg(trace_ctx,"\t%d", p->sprite_trajectory_du[i]);

    va_TraceMsg(trace_ctx,"\tsprite_trajectory_dv =");

    for(i=0;i<3;i++)

        va_TraceMsg(trace_ctx,"\t%d", p->sprite_trajectory_dv[i]);

    va_TraceMsg(trace_ctx,"\n");

    va_TraceMsg(trace_ctx,"\tvop_fields value = %d\n", p->vop_fields.value);

    va_TraceMsg(trace_ctx,"\tvop_coding_type= %d\n", p->vop_fields.bits.vop_coding_type);

    va_TraceMsg(trace_ctx,"\tbackward_reference_vop_coding_type= %d\n", p->vop_fields.bits.backward_reference_vop_coding_type);

    va_TraceMsg(trace_ctx,"\tvop_rounding_type= %d\n", p->vop_fields.bits.vop_rounding_type);

    va_TraceMsg(trace_ctx,"\tintra_dc_vlc_thr= %d\n", p->vop_fields.bits.intra_dc_vlc_thr);

    va_TraceMsg(trace_ctx,"\ttop_field_first= %d\n", p->vop_fields.bits.top_field_first);

    va_TraceMsg(trace_ctx,"\talternate_vertical_scan_flag= %d\n", p->vop_fields.bits.alternate_vertical_scan_flag);

    va_TraceMsg(trace_ctx,"\tvop_fcode_forward = %d\n", p->vop_fcode_forward);

    va_TraceMsg(trace_ctx,"\tvop_fcode_backward = %d\n", p->vop_fcode_backward);

    va_TraceMsg(trace_ctx,"\tnum_gobs_in_vop = %d\n", p->num_gobs_in_vop);

    va_TraceMsg(trace_ctx,"\tnum_macroblocks_in_gob = %d\n", p->num_macroblocks_in_gob);

    va_TraceMsg(trace_ctx,"\tTRB = %d\n", p->TRB);

    va_TraceMsg(trace_ctx,"\tTRD = %d\n", p->TRD);

    va_TraceMsg(trace_ctx, NULL);