From 881b49c5f154ee6603eee4aebb8becae6097a4bd Mon Sep 17 00:00:00 2001 From: Austin Yuan Date: Thu, 28 Oct 2010 07:18:18 +0800 Subject: libva-1.0.6 1) Refinement for VA_TRACE, new LIBVA_FOOL, see the description in va_trace.c/va_fool.c 2) vaPutSurface flag VA_ENABLE_BLEND to blend the surface with a color 3) libva.spec for RPM package 4) Update VAAPI for dynamic bit rate control/AIR/maximum slice size ctrl 5) Added VA_STATUS_ERROR_DECODING/ENCODING_ERROR to report decode/encode error 6) Add config.h/va_vesion.h for Android 7) Update "vainfo.c" for Android Signed-off-by: Austin Yuan Signed-off-by: Binglin Chen Signed-off-by: Fei Jiang Signed-off-by: Elaine Wang Signed-off-by: Ren Zhaohan Signed-off-by: Jerry Dong Signed-off-by: Austin Yuan --- Android.mk | 2 + COPYING | 4 +- configure.ac | 6 +- dummy_drv_video/dummy_drv_video.c | 2 +- test/vainfo.c | 9 + va/Android.mk | 1 + va/Makefile.am | 2 +- va/android/va_android.cpp | 37 +- va/va.c | 135 +++- va/va.h | 124 +++- va/va_android.h | 4 +- va/va_trace.c | 1487 +++++++++++++++++++++++++------------ va/va_trace.h | 58 +- va/x11/va_x11.c | 34 +- 14 files changed, 1396 insertions(+), 509 deletions(-) diff --git a/Android.mk b/Android.mk index 5e7744e..ba71130 100644 --- a/Android.mk +++ b/Android.mk @@ -1,5 +1,7 @@ # Recursive call sub-folder Android.mk # +# include $(call all-subdir-makefiles) LOCAL_PATH := $(my-dir) include $(LOCAL_PATH)/va/Android.mk + diff --git a/COPYING b/COPYING index 765e825..900e775 100644 --- a/COPYING +++ b/COPYING @@ -5,11 +5,11 @@ 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. diff --git a/configure.ac b/configure.ac index ac54963..6debe95 100644 --- a/configure.ac +++ b/configure.ac @@ -7,11 +7,11 @@ # 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. @@ -29,7 +29,7 @@ m4_define([libva_version], [libva_major_version.libva_minor_version.libva_micro_version]) # if the library source code has changed, increment revision -m4_define([libva_lt_revision], [5]) +m4_define([libva_lt_revision], [6]) # if any interface was added/removed/changed, then inc current, reset revision m4_define([libva_lt_current], [1]) # if any interface was added since last public release, then increment age diff --git a/dummy_drv_video/dummy_drv_video.c b/dummy_drv_video/dummy_drv_video.c index 90eb9c6..1a78b3f 100644 --- a/dummy_drv_video/dummy_drv_video.c +++ b/dummy_drv_video/dummy_drv_video.c @@ -1058,7 +1058,7 @@ VAStatus dummy_PutSurface( Drawable drawable = (Drawable)draw; (void)drawable; - + return VA_STATUS_ERROR_UNKNOWN; } diff --git a/test/vainfo.c b/test/vainfo.c index 33d6ea4..847e57e 100644 --- a/test/vainfo.c +++ b/test/vainfo.c @@ -22,7 +22,12 @@ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +#ifndef ANDROID #include +#else +#include "va/va_android.h" +#define Display unsigned int +#endif #include #include @@ -87,7 +92,11 @@ int main(int argc, const char* argv[]) else name = argv[0]; +#ifndef ANDROID dpy = XOpenDisplay(":0.0"); +#else + dpy = (Display*)malloc(sizeof(Display)); +#endif if (NULL == dpy) { fprintf(stderr, "%s: Error, can't open display: '%s'\n", name, display ? display : ""); diff --git a/va/Android.mk b/va/Android.mk index 848aa83..494f7c7 100644 --- a/va/Android.mk +++ b/va/Android.mk @@ -13,6 +13,7 @@ include $(CLEAR_VARS) LOCAL_SRC_FILES := \ va.c \ va_trace.c \ + va_fool.c LOCAL_CFLAGS += \ -DANDROID \ diff --git a/va/Makefile.am b/va/Makefile.am index 8451a38..685fb12 100644 --- a/va/Makefile.am +++ b/va/Makefile.am @@ -27,7 +27,7 @@ INCLUDES = \ LDADD = \ $(LIBVA_LT_LDFLAGS) -libva_la_SOURCES = va.c va_trace.c +libva_la_SOURCES = va.c va_trace.c va_fool.c libva_ladir = $(libdir) libva_la_LDFLAGS = $(LDADD) -no-undefined libva_la_LIBADD = $(LIBVA_LIBS) -ldl diff --git a/va/android/va_android.cpp b/va/android/va_android.cpp index 4eb90a2..b4727aa 100644 --- a/va/android/va_android.cpp +++ b/va/android/va_android.cpp @@ -250,7 +250,7 @@ VADisplay vaGetDisplay ( pDisplayContext->vaDestroy = va_DisplayContextDestroy; pDisplayContext->vaGetDriverName = va_DisplayContextGetDriverName; pDisplayContexts = pDisplayContext; - pDriverContext->dri_state = dri_state; + pDriverContext->dri_state = dri_state; dpy = (VADisplay)pDisplayContext; } else @@ -272,6 +272,33 @@ VADisplay vaGetDisplay ( #ifdef ANDROID +extern "C" { + extern int fool_postp; /* do nothing for vaPutSurface if set */ + extern int trace_flag; /* trace vaPutSurface parameters */ + + void va_TracePutSurface ( + VADisplay dpy, + VASurfaceID surface, + void *draw, /* the target Drawable */ + short srcx, + short srcy, + unsigned short srcw, + unsigned short srch, + short destx, + short desty, + unsigned short destw, + unsigned short desth, + VARectangle *cliprects, /* client supplied clip list */ + unsigned int number_cliprects, /* number of clip rects in the clip list */ + unsigned int flags /* de-interlacing flags */ + ); +} + +#define VA_TRACE(trace_func,...) \ + if (trace_flag) { \ + trace_func(__VA_ARGS__); \ + } + VAStatus vaPutSurface ( VADisplay dpy, VASurfaceID surface, @@ -291,8 +318,16 @@ VAStatus vaPutSurface ( { VADriverContextP ctx; + if (fool_postp) + return VA_STATUS_SUCCESS; + CHECK_DISPLAY(dpy); ctx = CTX(dpy); + + VA_TRACE(va_TracePutSurface, dpy, surface, static_cast(&draw), srcx, srcy, srcw, srch, + destx, desty, destw, desth, + cliprects, number_cliprects, flags ); + return ctx->vtable.vaPutSurface( ctx, surface, static_cast(&draw), srcx, srcy, srcw, srch, destx, desty, destw, desth, cliprects, number_cliprects, flags ); diff --git a/va/va.c b/va/va.c index c0722ba..0320ed3 100644 --- a/va/va.c +++ b/va/va.c @@ -26,6 +26,7 @@ #include "va.h" #include "va_backend.h" #include "va_trace.h" +#include "va_fool.h" #include "config.h" #include @@ -57,17 +58,65 @@ extern int trace_flag; #define VA_TRACE(trace_func,...) \ if (trace_flag) { \ - va_TraceMsg("========%s========\n", __func__); \ trace_func(__VA_ARGS__); \ } +/* + * read a config "env" for libva.conf or from environment setting + * liva.conf has higher priority + * return 0: the "env" is set, and the value is copied into env_value + * 1: the env is not set + */ +int va_parseConfig(char *env, char *env_value) +{ + char *token, *value, *saveptr; + char oneline[1024]; + FILE *fp=NULL; + + + if (env == NULL) + return 1; + + fp = fopen("/etc/libva.conf", "r"); + while (fp && (fgets(oneline, 1024, fp) != NULL)) { + if (strlen(oneline) == 1) + continue; + token = strtok_r(oneline, "=\n", &saveptr); + value = strtok_r(NULL, "=\n", &saveptr); + + if (NULL == token || NULL == value) + continue; + + if (strcmp(token, env) == 0) { + if (env_value) + strncpy(env_value,value, 1024); + + fclose(fp); + + return 0; + } + } + if (fp) + fclose(fp); + + /* no setting in config file, use env setting */ + if (getenv(env)) { + if (env_value) + strncpy(env_value, getenv(env), 1024); + + return 0; + } + + return 1; +} + int vaDisplayIsValid(VADisplay dpy) { VADisplayContextP pDisplayContext = (VADisplayContextP)dpy; return pDisplayContext && (pDisplayContext->vadpy_magic == VA_DISPLAY_MAGIC) && pDisplayContext->vaIsValid(pDisplayContext); } -static void va_errorMessage(const char *msg, ...) +void va_errorMessage(const char *msg, ...) { va_list args; @@ -77,7 +126,7 @@ static void va_errorMessage(const char *msg, ...) va_end(args); } -static void va_infoMessage(const char *msg, ...) +void va_infoMessage(const char *msg, ...) { va_list args; @@ -340,7 +389,9 @@ VAStatus vaInitialize ( CHECK_DISPLAY(dpy); - va_TraceInit(); + va_TraceInit(dpy); + + va_FoolInit(dpy); va_infoMessage("libva version %s\n", VA_VERSION_S); @@ -397,7 +448,9 @@ VAStatus vaTerminate ( if (VA_STATUS_SUCCESS == vaStatus) pDisplayContext->vaDestroy(pDisplayContext); - va_TraceEnd(); + va_TraceEnd(dpy); + + va_FoolEnd(dpy); return vaStatus; } @@ -511,6 +564,7 @@ VAStatus vaCreateConfig ( ctx = CTX(dpy); VA_TRACE(va_TraceCreateConfig, dpy, profile, entrypoint, attrib_list, num_attribs, config_id); + va_FoolCreateConfig(dpy, profile, entrypoint, attrib_list, num_attribs, config_id); return ctx->vtable.vaCreateConfig ( ctx, profile, entrypoint, attrib_list, num_attribs, config_id ); } @@ -552,11 +606,15 @@ VAStatus vaCreateSurfaces ( ) { VADriverContextP ctx; + VAStatus ret; CHECK_DISPLAY(dpy); ctx = CTX(dpy); VA_TRACE(va_TraceCreateSurface, dpy, width, height, format, num_surfaces, surfaces); - return ctx->vtable.vaCreateSurfaces( ctx, width, height, format, num_surfaces, surfaces ); + + ret = ctx->vtable.vaCreateSurfaces( ctx, width, height, format, num_surfaces, surfaces ); + va_FoolCreateSurfaces(dpy, width, height, format, num_surfaces, surfaces); + return ret; } @@ -619,6 +677,8 @@ VAStatus vaCreateBuffer ( CHECK_DISPLAY(dpy); ctx = CTX(dpy); + if (va_FoolCreateBuffer(dpy, context, type, size, num_elements, data, buf_id)) + return VA_STATUS_SUCCESS; return ctx->vtable.vaCreateBuffer( ctx, context, type, size, num_elements, data, buf_id); } @@ -643,10 +703,19 @@ VAStatus vaMapBuffer ( ) { VADriverContextP ctx; + VAStatus va_status; + CHECK_DISPLAY(dpy); ctx = CTX(dpy); + + if (va_FoolMapBuffer(dpy, buf_id, pbuf)) + return VA_STATUS_SUCCESS; + va_status = ctx->vtable.vaMapBuffer( ctx, buf_id, pbuf ); - return ctx->vtable.vaMapBuffer( ctx, buf_id, pbuf ); + if (va_status == VA_STATUS_SUCCESS) + VA_TRACE(va_TraceMapBuffer, dpy, buf_id, pbuf); + + return va_status; } VAStatus vaUnmapBuffer ( @@ -658,6 +727,8 @@ VAStatus vaUnmapBuffer ( CHECK_DISPLAY(dpy); ctx = CTX(dpy); + if (va_FoolUnmapBuffer(dpy, buf_id)) + return VA_STATUS_SUCCESS; return ctx->vtable.vaUnmapBuffer( ctx, buf_id ); } @@ -699,7 +770,11 @@ VAStatus vaBeginPicture ( CHECK_DISPLAY(dpy); ctx = CTX(dpy); - VA_TRACE(va_TraceBeginPicture, ctx, context, render_target); + VA_TRACE(va_TraceBeginPicture, dpy, context, render_target); + + if (va_FoolBeginPicture(dpy, context, render_target)) + return VA_STATUS_SUCCESS; + return ctx->vtable.vaBeginPicture( ctx, context, render_target ); } @@ -714,7 +789,11 @@ VAStatus vaRenderPicture ( CHECK_DISPLAY(dpy); ctx = CTX(dpy); + if (va_FoolRenderPicture(dpy, context, buffers, num_buffers)) + return VA_STATUS_SUCCESS; + VA_TRACE(va_TraceRenderPicture, dpy, context, buffers, num_buffers); + return ctx->vtable.vaRenderPicture( ctx, context, buffers, num_buffers ); } @@ -728,8 +807,15 @@ VAStatus vaEndPicture ( CHECK_DISPLAY(dpy); ctx = CTX(dpy); + if (va_FoolEndPicture(dpy, context)) { + VA_TRACE(va_TraceEndPicture, dpy, context); + return VA_STATUS_SUCCESS; + } + va_status = ctx->vtable.vaEndPicture( ctx, context ); + VA_TRACE(va_TraceEndPicture, dpy, context); + return va_status; } @@ -742,6 +828,9 @@ VAStatus vaSyncSurface ( CHECK_DISPLAY(dpy); ctx = CTX(dpy); + if (va_FoolSyncSurface( dpy, render_target)) + return VA_STATUS_SUCCESS; + return ctx->vtable.vaSyncSurface( ctx, render_target ); } @@ -953,6 +1042,8 @@ VAStatus vaQuerySubpictureFormats ( CHECK_DISPLAY(dpy); ctx = CTX(dpy); + if (va_FoolQuerySubpictureFormats(dpy, format_list, flags, num_formats)) + return VA_STATUS_SUCCESS; return ctx->vtable.vaQuerySubpictureFormats ( ctx, format_list, flags, num_formats); } @@ -1096,10 +1187,16 @@ int vaMaxNumDisplayAttributes ( VADisplay dpy ) { + int tmp; + if( !vaDisplayIsValid(dpy) ) return 0; - return CTX(dpy)->max_display_attributes; + tmp = CTX(dpy)->max_display_attributes; + + VA_TRACE(va_TraceMaxNumDisplayAttributes, dpy, tmp); + + return tmp; } /* @@ -1118,7 +1215,14 @@ VAStatus vaQueryDisplayAttributes ( CHECK_DISPLAY(dpy); ctx = CTX(dpy); - return ctx->vtable.vaQueryDisplayAttributes ( ctx, attr_list, num_attributes ); + VAStatus va_status; + + va_status = ctx->vtable.vaQueryDisplayAttributes ( ctx, attr_list, num_attributes ); + + VA_TRACE(va_TraceQueryDisplayAttributes, dpy, attr_list, num_attributes); + + return va_status; + } /* @@ -1137,7 +1241,13 @@ VAStatus vaGetDisplayAttributes ( CHECK_DISPLAY(dpy); ctx = CTX(dpy); - return ctx->vtable.vaGetDisplayAttributes ( ctx, attr_list, num_attributes ); + VAStatus va_status; + + va_status = ctx->vtable.vaGetDisplayAttributes ( ctx, attr_list, num_attributes ); + + VA_TRACE(va_TraceGetDisplayAttributes, dpy, attr_list, num_attributes); + + return va_status; } /* @@ -1156,6 +1266,9 @@ VAStatus vaSetDisplayAttributes ( CHECK_DISPLAY(dpy); ctx = CTX(dpy); + VA_TRACE(va_TraceSetDisplayAttributes, dpy, attr_list, num_attributes); + + return ctx->vtable.vaSetDisplayAttributes ( ctx, attr_list, num_attributes ); } diff --git a/va/va.h b/va/va.h index 0f12dfb..7f24a85 100644 --- a/va/va.h +++ b/va/va.h @@ -128,6 +128,8 @@ typedef int VAStatus; /* Return status type from functions */ #define VA_STATUS_ERROR_UNIMPLEMENTED 0x00000014 #define VA_STATUS_ERROR_SURFACE_IN_DISPLAYING 0x00000015 #define VA_STATUS_ERROR_INVALID_IMAGE_FORMAT 0x00000016 +#define VA_STATUS_ERROR_DECODING_ERROR 0x00000017 +#define VA_STATUS_ERROR_ENCODING_ERROR 0x00000018 #define VA_STATUS_ERROR_UNKNOWN 0xFFFFFFFF /* De-interlacing flags for vaPutSurface() */ @@ -135,12 +137,20 @@ typedef int VAStatus; /* Return status type from functions */ #define VA_TOP_FIELD 0x00000001 #define VA_BOTTOM_FIELD 0x00000002 +/* + * Enabled the positioning/cropping/blending feature: + * 1, specify the video playback position in the isurface + * 2, specify the cropping info for video playback + * 3, encoded video will blend with background color + */ +#define VA_ENABLE_BLEND 0x00000004 /* video area blend with the constant color */ + /* * Clears the drawable with background color. * for hardware overlay based implementation this flag * can be used to turn off the overlay */ -#define VA_CLEAR_DRAWABLE 0x00000008 +#define VA_CLEAR_DRAWABLE 0x00000008 /* Color space conversion flags for vaPutSurface() */ #define VA_SRC_BT601 0x00000010 @@ -273,6 +283,7 @@ typedef struct _VAConfigAttrib { #define VA_RC_NONE 0x00000001 #define VA_RC_CBR 0x00000002 #define VA_RC_VBR 0x00000004 +#define VA_RC_VCM 0x00000008 /* video conference mode */ /* * if an attribute is not applicable for a given @@ -502,8 +513,75 @@ typedef enum VAEncSliceParameterBufferType = 24, VAEncH264VUIBufferType = 25, VAEncH264SEIBufferType = 26, + VAEncMiscParameterBufferType = 27, + VABufferTypeMax = 0xff } VABufferType; +typedef enum +{ + VAEncMiscParameterTypeFrameRate = 0, + VAEncMiscParameterTypeRateControl = 1, + VAEncMiscParameterTypeMaxSliceSize = 2, + VAEncMiscParameterTypeAIR = 3, +} VAEncMiscParameterType; + +/* + * For application, e.g. set a new bitrate + * VABufferID buf_id; + * VAEncMiscParameterBuffer *misc_param; + * VAEncMiscParameterRateControl *misc_rate_ctrl; + * + * vaCreateBuffer(dpy, context, VAEncMiscParameterBufferType, + * sizeof(VAEncMiscParameterBuffer) + sizeof(VAEncMiscParameterRateControl), + * 1, NULL, &buf_id); + * + * vaMapBuffer(dpy,buf_id,(void **)&misc_param); + * misc_param->type = VAEncMiscParameterTypeRateControl; + * misc_rate_ctrl= (VAEncMiscParameterRateControl *)misc_param->data; + * misc_rate_ctrl->bits_per_second = 6400000; + * vaUnmapBuffer(dpy, buf_id); + * vaRenderPicture(dpy, context, &buf_id, 1); + */ +typedef struct _VAEncMiscParameterBuffer +{ + VAEncMiscParameterType type; + unsigned int data[0]; +} VAEncMiscParameterBuffer; + +typedef struct _VAEncMiscParameterRateControl +{ + unsigned int bits_per_second; /* this is the maximum bit-rate to be constrained by the rate control implementation */ + unsigned int target_percentage; /* this is the bit-rate the rate control is targeting, as a percentage of the maximum bit-rate */ + /* for example if target_percentage is 95 then the rate control will target a bit-rate that is */ + /* 95% of the maximum bit-rate */ + unsigned int window_size; /* windows size in milliseconds. For example if this is set to 500, then the rate control will guarantee the */ + /* target bit-rate over a 500 ms window */ + unsigned int initial_qp; /* initial QP at I frames */ + unsigned int min_qp; +} VAEncMiscParameterRateControl; + +typedef struct _VAEncMiscParameterFrameRate +{ + unsigned int framerate; +} VAEncMiscParameterFrameRate; + +/* + * Allow a maximum slice size to be specified (in bits). + * The encoder will attempt to make sure that individual slices do not exceed this size + * Or to signal applicate if the slice size exceed this size, see "status" of VACodedBufferSegment + */ +typedef struct _VAEncMiscParameterMaxSliceSize +{ + unsigned int max_slice_size; +} VAEncMiscParameterMaxSliceSize; + +typedef struct _VAEncMiscParameterAIR +{ + unsigned int air_num_mbs; + unsigned int air_threshold; + unsigned int air_auto; /* if set to 1 then hardware auto-tune the AIR threshold */ +} VAEncMiscParameterAIR; + /* * There will be cases where the bitstream buffer will not have enough room to hold @@ -1115,6 +1193,8 @@ typedef struct _VAEncSequenceParameterBufferH264 unsigned char vui_flag; } VAEncSequenceParameterBufferH264; +#define H264_LAST_PICTURE_EOSEQ 0x01 /* the last picture in the sequence */ +#define H264_LAST_PICTURE_EOSTREAM 0x02 /* the last picture in the stream */ typedef struct _VAEncPictureParameterBufferH264 { VASurfaceID reference_picture; @@ -1122,9 +1202,7 @@ typedef struct _VAEncPictureParameterBufferH264 VABufferID coded_buf; unsigned short picture_width; unsigned short picture_height; - unsigned char last_picture; /* if set to 1 it indicates the last picture in the sequence - * if set to 2 it indicates the last picture of the stream - */ + unsigned char last_picture; } VAEncPictureParameterBufferH264; /**************************** @@ -1225,9 +1303,26 @@ VAStatus vaBufferSetNumElements ( /* * device independent data structure for codedbuffer */ -typedef struct _VACodedBufferSegment { - unsigned int size; /* size of the data buffer in the coded buffer segment, in bytes */ - unsigned int bit_offset;/* bit offset into the data buffer where valid bitstream data begins */ + +/* + * FICTURE_AVE_QP(bit7-0): The average Qp value used during this frame + * LARGE_SLICE(bit8):At least one slice in the current frame was large + * enough for the encoder to attempt to limit its size. + * SLICE_OVERFLOW(bit9): At least one slice in the current frame has + * exceeded the maximum slice size specified. + */ +#define VA_CODED_BUF_STATUS_PICTURE_AVE_QP_MASK 0xff +#define VA_CODED_BUF_STATUS_LARGE_SLICE_MASK 0x100 +#define VA_CODED_BUF_STATUS_SLICE_OVERFLOW_MASK 0x200 + +/* + * device independent data structure for codedbuffer + */ +typedef struct _VACodedBufferSegment { + unsigned int size;/* size of the data buffer in the coded buffer segment, in bytes */ + unsigned int bit_offset; /* bit offset into the data buffer where valid bitstream data begins */ + unsigned int status; /* status set by the driver on the coded buffer*/ + unsigned int reserved; /* for future use */ void *buf; /* pointer to the beginning of the data buffer in the coded buffer segment */ void *next; /* pointer to the next VACodedBufferSegment */ } VACodedBufferSegment; @@ -1713,7 +1808,10 @@ typedef enum VADisplayAttribContrast = 1, VADisplayAttribHue = 2, VADisplayAttribSaturation = 3, - /* client can specifiy a background color for the target window */ + /* client can specifiy a background color for the target window + * the new feature of video conference, + * the uncovered area of the surface is filled by this color + * also it will blend with the decoded video color*/ VADisplayAttribBackgroundColor = 4, /* * this is a gettable only attribute. For some implementations that use the @@ -1739,7 +1837,15 @@ typedef enum * For type VADisplayAttribCSCMatrix, "value" field is a pointer to the color * conversion matrix. Each element in the matrix is float-point */ - VADisplayAttribCSCMatrix = 12 + VADisplayAttribCSCMatrix = 12, + /* specify the constant color used to blend with video surface + * Cd = Cv*Cc*Ac + Cb *(1 - Ac) C means the constant RGB + * d: the final color to overwrite into the frame buffer + * v: decoded video after color conversion, + * c: video color specified by VADisplayAttribBlendColor + * b: background color of the drawable + */ + VADisplayAttribBlendColor = 13, } VADisplayAttribType; /* flags for VADisplayAttribute */ diff --git a/va/va_android.h b/va/va_android.h index 08844f4..7b98949 100644 --- a/va/va_android.h +++ b/va/va_android.h @@ -19,8 +19,8 @@ VADisplay vaGetDisplay ( #endif #ifdef __cplusplus -#ifdef ANDROID -#include +#ifdef ANDROID +#include using namespace android; /* diff --git a/va/va_trace.c b/va/va_trace.c index 4ec9195..d289383 100644 --- a/va/va_trace.c +++ b/va/va_trace.c @@ -34,23 +34,87 @@ #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 VA buffer data into log_file (if not set, just calculate a checksum) + * .LIBVA_TRACE_CODEDBUF=coded_clip_file: save the coded clip into file coded_clip_file + * .LIBVA_TRACE_SURFACE=decoded_yuv_file: save the decoded YUV file decoded_yuv_file + * .LIBVA_TRACE_LOGSIZE=numeric number: truncate the log_file or coded_clip_file, or decoded_yuv_file + * when the size is bigger than the number + */ + +/* global settings */ + +/* LIBVA_TRACE */ unsigned int trace_flag = 0; -static const char *trace_file = 0; -static FILE *trace_fp = 0; +/* LIBVA_TRACE_LOGSIZE */ +static unsigned int trace_logsize = 0xffffffff; /* truncate the log when the size is bigger than it */ + +/* LIBVA_TRACE_BUFDATA */ +static unsigned int trace_buffer_data; /* dump buffer data or not */ + +#define TRACE_CONTEXT_MAX 4 +/* per context settings */ +static struct _trace_context { + VADisplay dpy; /* should use context as the key */ + + /* LIBVA_TRACE */ + FILE *trace_fp_log; /* save the log into a file */ + char trace_log_fn[1024]; /* file name */ + + /* LIBVA_TRACE_CODEDBUF */ + FILE *trace_fp_codedbuf; /* save the encode result into a file */ + char trace_codedbuf_fn[1024]; /* file name */ + + /* LIBVA_TRACE_SURFACE */ + FILE *trace_fp_surface; /* save the surface YUV into a file */ + char trace_surface_fn[1024]; /* file name */ + + VAContextID trace_context; /* current context */ + + VASurfaceID trace_rendertarget; /* current render target */ + VAProfile trace_profile; /* current profile for buffers */ + VAEntrypoint trace_entrypoint; /* current entrypoint */ + VABufferID trace_codedbuf; + + unsigned int trace_frame_no; /* current frame NO */ + unsigned int trace_slice_no; /* current slice NO */ + unsigned int trace_slice_size; /* current slice buffer size */ + + unsigned int trace_frame_width; /* current frame width */ + unsigned int trace_frame_height; /* current frame height */ + unsigned int trace_sequence_start; /* get a new sequence for encoding or not */ +} trace_context[TRACE_CONTEXT_MAX] = { {0} }; /* trace five context at the same time */ + +#define DPY2INDEX(dpy) \ + int idx; \ + \ + for (idx = 0; idx < TRACE_CONTEXT_MAX; idx++) \ + if (trace_context[idx].dpy == dpy) \ + break; \ + \ + if (idx == TRACE_CONTEXT_MAX) \ + return; + +#define TRACE_FUNCNAME(idx) va_TraceMsg(idx, "==========%s\n", __func__); -static VASurfaceID trace_rendertarget; /* current render target */ -static VAProfile trace_profile; /* current entrypoint for buffers */ +/* Prototype declarations (functions defined in va.c) */ -static unsigned int trace_frame; -static unsigned int trace_slice; +void va_errorMessage(const char *msg, ...); +void va_infoMessage(const char *msg, ...); -static unsigned int trace_width; -static unsigned int trace_height; +int va_parseConfig(char *env, char *env_value); -/* Prototypes (functions defined in va.c) */ -VAStatus vaBufferInfo ( +VAStatus vaBufferInfo( VADisplay dpy, VAContextID context, /* in */ VABufferID buf_id, /* in */ @@ -76,45 +140,263 @@ VAStatus vaUnlockSurface(VADisplay dpy, VASurfaceID surface ); -void va_TraceInit(void) + +void va_TraceInit(VADisplay dpy) { - trace_file = (const char *)getenv("LIBVA_TRACE"); - if (trace_file) { - trace_fp = fopen(trace_file, "w"); - if (trace_fp) - trace_flag = 1; + char env_value[1024]; + unsigned int suffix = 0xffff & ((unsigned int)time(NULL)); + int trace_index = 0; + FILE *tmp; + + for (trace_index = 0; trace_index < TRACE_CONTEXT_MAX; trace_index++) + if (trace_context[trace_index].dpy == 0) + break; + + if (trace_index == TRACE_CONTEXT_MAX) + return; + + if (va_parseConfig("LIBVA_TRACE", &env_value[0]) == 0) { + trace_flag = 1; + + sprintf(env_value+strlen(env_value), ".%d.%d", trace_index, suffix); + + tmp = fopen(env_value, "w"); + if (tmp) { + trace_context[trace_index].trace_fp_log = tmp; + strcpy(trace_context[trace_index].trace_log_fn, env_value); + } else { + trace_context[trace_index].trace_fp_log = stderr; + strcpy(trace_context[trace_index].trace_codedbuf_fn, "/dev/stderr"); + } + va_infoMessage("LIBVA_TRACE is on, save log into %s\n", trace_context[trace_index].trace_log_fn); + } + + if (trace_flag == 0) + return; + + /* may re-get the global settings for multiple context */ + if (va_parseConfig("LIBVA_TRACE_LOGSIZE", &env_value[0]) == 0) { + trace_logsize = atoi(env_value); + va_infoMessage("LIBVA_TRACE_LOGSIZE is on, size is %d\n", trace_logsize); + } + + + if (va_parseConfig("LIBVA_TRACE_BUFDATA", NULL) == 0) { + trace_buffer_data = 1; /* dump buffer data */ + va_infoMessage("LIBVA_TRACE_BUFDATA is on, dump buffer into log file\n"); + } + + + /* per-context setting */ + if (va_parseConfig("LIBVA_TRACE_CODEDBUF", &env_value[0]) == 0) { + sprintf(env_value+strlen(env_value), ".%d.%d", trace_index, suffix); + + tmp = fopen(env_value, "w"); + + if (tmp) { + trace_context[trace_index].trace_fp_codedbuf = tmp; + strcpy(trace_context[trace_index].trace_codedbuf_fn, env_value); + } else { + trace_context[trace_index].trace_fp_codedbuf = stderr; + strcpy(trace_context[trace_index].trace_codedbuf_fn, "/dev/stderr"); + } + + va_infoMessage("LIBVA_TRACE_CODEDBUF is on, save coded clip into %s\n", trace_context[trace_index].trace_codedbuf_fn); + } + + if (va_parseConfig("LIBVA_TRACE_SURFACE", &env_value[0]) == 0) { + sprintf(env_value+strlen(env_value), ".%d.%d", trace_index, suffix); + + tmp = fopen(env_value, "w"); + + if (tmp) { + trace_context[trace_index].trace_fp_surface = tmp; + strcpy(trace_context[trace_index].trace_surface_fn, env_value); + } else { + trace_context[trace_index].trace_fp_surface = stderr; + strcpy(trace_context[trace_index].trace_surface_fn, "/dev/stderr"); + } + + va_infoMessage("LIBVA_TRACE_SURFACE is on, save coded clip into %s\n", trace_context[trace_index].trace_surface_fn); } + + trace_context[trace_index].dpy = dpy; } -void va_TraceEnd(void) + +void va_TraceEnd(VADisplay dpy) { - if (trace_file && trace_fp) { - fclose(trace_fp); + DPY2INDEX(dpy); + + if (trace_context[idx].trace_fp_log && (trace_context[idx].trace_fp_log != stderr)) + fclose(trace_context[idx].trace_fp_log); + + if (trace_context[idx].trace_fp_codedbuf && (trace_context[idx].trace_fp_codedbuf != stderr)) + fclose(trace_context[idx].trace_fp_codedbuf); + + if (trace_context[idx].trace_fp_surface && (trace_context[idx].trace_fp_surface != stderr)) + fclose(trace_context[idx].trace_fp_surface); + + memset(&trace_context[idx], sizeof(struct _trace_context), 0); +} - trace_file = NULL; - trace_fp = NULL; +static unsigned int file_size(FILE *fp) +{ + struct stat buf; - trace_flag = 0; + fstat(fileno(fp), &buf); - trace_width = 0; - trace_height = 0; - } + return buf.st_size; } -void va_TraceMsg(const char *msg, ...) + +static void truncate_file(FILE *fp) +{ + ftruncate(fileno(fp), 0); + rewind(fp); +} + +void va_TraceMsg(int idx, const char *msg, ...) { va_list args; + + if (file_size(trace_context[idx].trace_fp_log) >= trace_logsize) + truncate_file(trace_context[idx].trace_fp_log); if (msg) { va_start(args, msg); - vfprintf(trace_fp, msg, args); + vfprintf(trace_context[idx].trace_fp_log, msg, args); va_end(args); - } else { - fflush(trace_fp); + } else + fflush(trace_context[idx].trace_fp_log); +} + +void va_TraceCodedBuf(VADisplay dpy) +{ + VACodedBufferSegment *buf_list = NULL; + VAStatus va_status; + unsigned char check_sum = 0; + DPY2INDEX(dpy); + + /* can only truncate at a sequence boudary */ + if (((file_size(trace_context[idx].trace_fp_log) >= trace_logsize)) + && trace_context[idx].trace_sequence_start) { + va_TraceMsg(idx, "==========truncate file %s\n", trace_context[idx].trace_codedbuf_fn); + truncate_file(trace_context[idx].trace_fp_log); } + + + trace_context[idx].trace_sequence_start = 0; /* only truncate coded file when meet next new sequence */ + + va_status = vaMapBuffer(dpy, trace_context[idx].trace_codedbuf, (void **)(&buf_list)); + if (va_status != VA_STATUS_SUCCESS) + return; + + va_TraceMsg(idx, "==========dump codedbuf into file %s\n", trace_context[idx].trace_codedbuf_fn); + + while (buf_list != NULL) { + unsigned int i; + + va_TraceMsg(idx, "\tsize = %d\n", buf_list->size); + if (trace_context[idx].trace_fp_log) + fwrite(buf_list->buf, buf_list->size, 1, trace_context[idx].trace_fp_codedbuf); + + for (i=0; isize; i++) + check_sum ^= *((unsigned char *)buf_list->buf + i); + + buf_list = buf_list->next; + } + vaUnmapBuffer(dpy,trace_context[idx].trace_codedbuf); + + va_TraceMsg(idx, "\tchecksum = 0x%02x\n", check_sum); } +void va_TraceSurface(VADisplay dpy) +{ + 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; + DPY2INDEX(dpy); + + va_TraceMsg(idx, "==========dump surface data in file %s\n", trace_context[idx].trace_surface_fn); + + if ((file_size(trace_context[idx].trace_fp_surface) >= trace_logsize)) { + va_TraceMsg(idx, "==========truncate file %s\n", trace_context[idx].trace_surface_fn); + truncate_file(trace_context[idx].trace_fp_surface); + } + + va_status = vaLockSurface(dpy, trace_context[idx].trace_rendertarget, &fourcc, + &luma_stride, &chroma_u_stride, &chroma_v_stride, + &luma_offset, &chroma_u_offset, &chroma_v_offset, + &buffer_name, &buffer); + + if (va_status != VA_STATUS_SUCCESS) { + va_TraceMsg(idx, "Error:vaLockSurface failed\n"); + + return; + } + + va_TraceMsg(idx, "\tfourcc = 0x%08x\n", fourcc); + va_TraceMsg(idx, "\twidth = %d\n", trace_context[idx].trace_frame_width); + va_TraceMsg(idx, "\theight = %d\n", trace_context[idx].trace_frame_height); + va_TraceMsg(idx, "\tluma_stride = %d\n", luma_stride); + va_TraceMsg(idx, "\tchroma_u_stride = %d\n", chroma_u_stride); + va_TraceMsg(idx, "\tchroma_v_stride = %d\n", chroma_v_stride); + va_TraceMsg(idx, "\tluma_offset = %d\n", luma_offset); + va_TraceMsg(idx, "\tchroma_u_offset = %d\n", chroma_u_offset); + va_TraceMsg(idx, "\tchroma_v_offset = %d\n", chroma_v_offset); + + if (*(unsigned int *)buffer == 0) { + va_TraceMsg(idx, "Error:vaLockSurface return NULL buffer\n"); + + vaUnlockSurface(dpy, trace_context[idx].trace_rendertarget); + return; + } + va_TraceMsg(idx, "\tbuffer location = 0x%08x\n", buffer); + + Y_data = buffer; + UV_data = buffer + chroma_u_offset; + + tmp = Y_data; + for (i=0; isize); + va_TraceMsg(idx, "\t bit_offset = %d\n", buf_list->bit_offset); + va_TraceMsg(idx, "\t status = 0x%08x\n", buf_list->status); + va_TraceMsg(idx, "\t reserved = 0x%08x\n", buf_list->reserved); + va_TraceMsg(idx, "\t buf = 0x%08x\n", buf_list->buf); + + buf_list = buf_list->next; + } + + +} -static int va_TraceVABuffers( +static void va_TraceVABuffers( VADisplay dpy, VAContextID context, VABufferID buffer, @@ -220,21 +557,30 @@ static int va_TraceVABuffers( unsigned int size, unsigned int num_elements, void *pbuf - ) +) { - int i; + unsigned int i; unsigned char *p = pbuf; - unsigned int *pi = (unsigned int *)pbuf; + unsigned char check_sum = 0; + DPY2INDEX(dpy); + + va_TraceMsg(idx, "%s\n", buffer_type_to_string(type)); - va_TraceMsg("***Buffer Data***"); for (i=0; islice_data_size; */ va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, data); return; @@ -293,6 +649,8 @@ static void va_TraceVAPictureParameterBufferMPEG4( unsigned int num_elements, void *data) { + DPY2INDEX(dpy); + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, data); return; @@ -308,6 +666,9 @@ static void va_TraceVAIQMatrixBufferMPEG4( unsigned int num_elements, void *data) { + DPY2INDEX(dpy); + + /* todo: log VAIQMatrixBufferMPEG4 */ va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, data); return; @@ -323,6 +684,12 @@ static void va_TraceVASliceParameterBufferMPEG4( unsigned int num_elements, void *data) { + DPY2INDEX(dpy); + + trace_context[idx].trace_slice_no++; + + /* todo: log VASliceParameterBufferMPEG4 */ + /* trace_context[idx].trace_slice_size = p->slice_data_size; */ va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, data); return; @@ -339,76 +706,59 @@ static void va_TraceVAPictureParameterBufferH264( void *data) { int i; - + DPY2INDEX(dpy); + VAPictureParameterBufferH264 *p = (VAPictureParameterBufferH264*)data; - va_TraceMsg ("==========H264PicParameterBuffer============\n"); - -#if 0 - if (p->num_ref_frames > 4) - { - int num = 0; - for (i = 15; i >= 0; i--) - { - if (p->ReferenceFrames[i].flags != VA_PICTURE_H264_INVALID) - { - num++; - } - if (num > 4) - { - p->ReferenceFrames[i].flags = VA_PICTURE_H264_INVALID; - } - } - p->num_ref_frames = 4; - } -#endif - -#if 1 - va_TraceMsg("picture id: %d\n", p->CurrPic.picture_id); - va_TraceMsg("frame idx: %d\n", p->CurrPic.frame_idx); - va_TraceMsg("picture flags: %d\n", p->CurrPic.flags); - va_TraceMsg("top field order count: %d\n", p->CurrPic.TopFieldOrderCnt); - va_TraceMsg("bottom field order count: %d\n", p->CurrPic.BottomFieldOrderCnt); + va_TraceMsg(idx, "VAPictureParameterBufferH264\n"); + va_TraceMsg(idx, "\tCurrPic.picture_id = %d\n", p->CurrPic.picture_id); + va_TraceMsg(idx, "\tCurrPic.frame_idx = %d\n", p->CurrPic.frame_idx); + va_TraceMsg(idx, "\tCurrPic.flags = %d\n", p->CurrPic.flags); + va_TraceMsg(idx, "\tCurrPic.TopFieldOrderCnt = %d\n", p->CurrPic.TopFieldOrderCnt); + va_TraceMsg(idx, "\tCurrPic.BottomFieldOrderCnt = %d\n", p->CurrPic.BottomFieldOrderCnt); - va_TraceMsg("Reference frames: \n"); + va_TraceMsg(idx, "\tReferenceFrames (TopFieldOrderCnt-BottomFieldOrderCnt-picture_id-frame_idx:\n"); for (i = 0; i < 16; i++) { - if (p->ReferenceFrames[i].flags != VA_PICTURE_H264_INVALID) - { - //va_TraceMsg("%d-%d; ", p->ReferenceFrames[i].TopFieldOrderCnt, p->ReferenceFrames[i].BottomFieldOrderCnt); - va_TraceMsg("%d-%d-%d-%d; ", p->ReferenceFrames[i].TopFieldOrderCnt, p->ReferenceFrames[i].BottomFieldOrderCnt, p->ReferenceFrames[i].picture_id, p->ReferenceFrames[i].frame_idx); - } + if (p->ReferenceFrames[i].flags != VA_PICTURE_H264_INVALID) { + va_TraceMsg(idx, "\t\t%d-%d-%d-%d\n", + p->ReferenceFrames[i].TopFieldOrderCnt, + p->ReferenceFrames[i].BottomFieldOrderCnt, + p->ReferenceFrames[i].picture_id, + p->ReferenceFrames[i].frame_idx); + } else + va_TraceMsg(idx, "\t\t%inv-%inv-%inv-%inv\n"); } - va_TraceMsg("\n"); -#endif - va_TraceMsg("picture_width_in_mbs_minus1: %d\n", p->picture_width_in_mbs_minus1); - va_TraceMsg("picture_height_in_mbs_minus1: %d\n", p->picture_height_in_mbs_minus1); - va_TraceMsg("bit_depth_luma_minus8: %d\n", p->bit_depth_luma_minus8); - va_TraceMsg("bit_depth_chroma_minus8: %d\n", p->bit_depth_chroma_minus8); - va_TraceMsg("num_ref_frames: %d\n", p->num_ref_frames); - va_TraceMsg("seq fields: %d\n", p->seq_fields.value); - va_TraceMsg("\t chroma_format_idc: %d\n", p->seq_fields.bits.chroma_format_idc); - va_TraceMsg("\t residual_colour_transform_flag: %d\n", p->seq_fields.bits.residual_colour_transform_flag); - va_TraceMsg("\t frame_mbs_only_flag: %d\n", p->seq_fields.bits.frame_mbs_only_flag); - va_TraceMsg("\t mb_adaptive_frame_field_flag: %d\n", p->seq_fields.bits.mb_adaptive_frame_field_flag); - va_TraceMsg("\t direct_8x8_inference_flag: %d\n", p->seq_fields.bits.direct_8x8_inference_flag); - va_TraceMsg("\t MinLumaBiPredSize8x8: %d\n", p->seq_fields.bits.MinLumaBiPredSize8x8); - va_TraceMsg("num_slice_groups_minus1: %d\n", p->num_slice_groups_minus1); - va_TraceMsg("slice_group_map_type: %d\n", p->slice_group_map_type); - va_TraceMsg("slice_group_change_rate_minus1: %d\n", p->slice_group_change_rate_minus1); - va_TraceMsg("pic_init_qp_minus26: %d\n", p->pic_init_qp_minus26); - va_TraceMsg("pic_init_qs_minus26: %d\n", p->pic_init_qs_minus26); - va_TraceMsg("chroma_qp_index_offset: %d\n", p->chroma_qp_index_offset); - va_TraceMsg("second_chroma_qp_index_offset: %d\n", p->second_chroma_qp_index_offset); - va_TraceMsg("pic_fields: %d\n", p->pic_fields.value); - va_TraceMsg("\t entropy_coding_mode_flag: %d\n", p->pic_fields.bits.entropy_coding_mode_flag); - va_TraceMsg("\t weighted_pred_flag: %d\n", p->pic_fields.bits.weighted_pred_flag); - va_TraceMsg("\t weighted_bipred_idc: %d\n", p->pic_fields.bits.weighted_bipred_idc); - va_TraceMsg("\t transform_8x8_mode_flag: %d\n", p->pic_fields.bits.transform_8x8_mode_flag); - va_TraceMsg("\t field_pic_flag: %d\n", p->pic_fields.bits.field_pic_flag); - va_TraceMsg("\t constrained_intra_pred_flag: %d\n", p->pic_fields.bits.constrained_intra_pred_flag); - va_TraceMsg("frame_num: %d\n", p->frame_num); + va_TraceMsg(idx, "\n"); + + va_TraceMsg(idx, "\tpicture_width_in_mbs_minus1 = %d\n", p->picture_width_in_mbs_minus1); + va_TraceMsg(idx, "\tpicture_height_in_mbs_minus1 = %d\n", p->picture_height_in_mbs_minus1); + va_TraceMsg(idx, "\tbit_depth_luma_minus8 = %d\n", p->bit_depth_luma_minus8); + va_TraceMsg(idx, "\tbit_depth_chroma_minus8 = %d\n", p->bit_depth_chroma_minus8); + va_TraceMsg(idx, "\tnum_ref_frames = %d\n", p->num_ref_frames); + va_TraceMsg(idx, "\tseq fields = %d\n", p->seq_fields.value); + va_TraceMsg(idx, "\tchroma_format_idc = %d\n", p->seq_fields.bits.chroma_format_idc); + va_TraceMsg(idx, "\tresidual_colour_transform_flag = %d\n", p->seq_fields.bits.residual_colour_transform_flag); + va_TraceMsg(idx, "\tframe_mbs_only_flag = %d\n", p->seq_fields.bits.frame_mbs_only_flag); + va_TraceMsg(idx, "\tmb_adaptive_frame_field_flag = %d\n", p->seq_fields.bits.mb_adaptive_frame_field_flag); + va_TraceMsg(idx, "\tdirect_8x8_inference_flag = %d\n", p->seq_fields.bits.direct_8x8_inference_flag); + va_TraceMsg(idx, "\tMinLumaBiPredSize8x8 = %d\n", p->seq_fields.bits.MinLumaBiPredSize8x8); + va_TraceMsg(idx, "\tnum_slice_groups_minus1 = %d\n", p->num_slice_groups_minus1); + va_TraceMsg(idx, "\tslice_group_map_type = %d\n", p->slice_group_map_type); + va_TraceMsg(idx, "\tslice_group_change_rate_minus1 = %d\n", p->slice_group_change_rate_minus1); + va_TraceMsg(idx, "\tpic_init_qp_minus26 = %d\n", p->pic_init_qp_minus26); + va_TraceMsg(idx, "\tpic_init_qs_minus26 = %d\n", p->pic_init_qs_minus26); + va_TraceMsg(idx, "\tchroma_qp_index_offset = %d\n", p->chroma_qp_index_offset); + va_TraceMsg(idx, "\tsecond_chroma_qp_index_offset = %d\n", p->second_chroma_qp_index_offset); + va_TraceMsg(idx, "\tpic_fields = %d\n", p->pic_fields.value); + va_TraceMsg(idx, "\tentropy_coding_mode_flag = %d\n", p->pic_fields.bits.entropy_coding_mode_flag); + va_TraceMsg(idx, "\tweighted_pred_flag = %d\n", p->pic_fields.bits.weighted_pred_flag); + va_TraceMsg(idx, "\tweighted_bipred_idc = %d\n", p->pic_fields.bits.weighted_bipred_idc); + va_TraceMsg(idx, "\ttransform_8x8_mode_flag = %d\n", p->pic_fields.bits.transform_8x8_mode_flag); + va_TraceMsg(idx, "\tfield_pic_flag = %d\n", p->pic_fields.bits.field_pic_flag); + va_TraceMsg(idx, "\tconstrained_intra_pred_flag = %d\n", p->pic_fields.bits.constrained_intra_pred_flag); + va_TraceMsg(idx, "\tframe_num = %d\n", p->frame_num); return; } @@ -424,93 +774,78 @@ static void va_TraceVASliceParameterBufferH264( { int i; VASliceParameterBufferH264* p = (VASliceParameterBufferH264*)data; - - va_TraceMsg ("========== SLICE HEADER ============.\n"); - va_TraceMsg("slice_data_size: %d\n", p->slice_data_size); - va_TraceMsg("slice_data_offset: %d\n", p->slice_data_offset); - va_TraceMsg("slice_data_flag: %d\n", p->slice_data_flag); - va_TraceMsg("slice_data_bit_offset: %d\n", p->slice_data_bit_offset); - va_TraceMsg("first_mb_in_slice: %d\n", p->first_mb_in_slice); - va_TraceMsg("slice_type: %d\n", p->slice_type); - va_TraceMsg("direct_spatial_mv_pred_flag: %d\n", p->direct_spatial_mv_pred_flag); - va_TraceMsg("num_ref_idx_l0_active_minus1: %d\n", p->num_ref_idx_l0_active_minus1); - va_TraceMsg("num_ref_idx_l1_active_minus1: %d\n", p->num_ref_idx_l1_active_minus1); - va_TraceMsg("cabac_init_idc: %d\n", p->cabac_init_idc); - va_TraceMsg("slice_qp_delta: %d\n", p->slice_qp_delta); - va_TraceMsg("disable_deblocking_filter_idc: %d\n", p->disable_deblocking_filter_idc); - va_TraceMsg("slice_alpha_c0_offset_div2: %d\n", p->slice_alpha_c0_offset_div2); - va_TraceMsg("slice_beta_offset_div2: %d\n", p->slice_beta_offset_div2); - -#if 1 - if (p->slice_type == 0 || p->slice_type == 1) - { - va_TraceMsg("RefPicList0:\n"); - for (i = 0; i < p->num_ref_idx_l0_active_minus1 + 1; i++) - { - //va_TraceMsg("%d-%d; ", p->RefPicList0[i].TopFieldOrderCnt, p->RefPicList0[i].BottomFieldOrderCnt); - va_TraceMsg("%d-%d-%d-%d; ", p->RefPicList0[i].TopFieldOrderCnt, p->RefPicList0[i].BottomFieldOrderCnt, p->RefPicList0[i].picture_id, p->RefPicList0[i].frame_idx); + DPY2INDEX(dpy); + + trace_context[idx].trace_slice_no++; + trace_context[idx].trace_slice_size = p->slice_data_size; + + va_TraceMsg(idx, "VASliceParameterBufferH264\n"); + va_TraceMsg(idx, "\tslice_data_size = %d\n", p->slice_data_size); + va_TraceMsg(idx, "\tslice_data_offset = %d\n", p->slice_data_offset); + va_TraceMsg(idx, "\tslice_data_flag = %d\n", p->slice_data_flag); + va_TraceMsg(idx, "\tslice_data_bit_offset = %d\n", p->slice_data_bit_offset); + va_TraceMsg(idx, "\tfirst_mb_in_slice = %d\n", p->first_mb_in_slice); + va_TraceMsg(idx, "\tslice_type = %d\n", p->slice_type); + va_TraceMsg(idx, "\tdirect_spatial_mv_pred_flag = %d\n", p->direct_spatial_mv_pred_flag); + va_TraceMsg(idx, "\tnum_ref_idx_l0_active_minus1 = %d\n", p->num_ref_idx_l0_active_minus1); + va_TraceMsg(idx, "\tnum_ref_idx_l1_active_minus1 = %d\n", p->num_ref_idx_l1_active_minus1); + va_TraceMsg(idx, "\tcabac_init_idc = %d\n", p->cabac_init_idc); + va_TraceMsg(idx, "\tslice_qp_delta = %d\n", p->slice_qp_delta); + va_TraceMsg(idx, "\tdisable_deblocking_filter_idc = %d\n", p->disable_deblocking_filter_idc); + va_TraceMsg(idx, "\tslice_alpha_c0_offset_div2 = %d\n", p->slice_alpha_c0_offset_div2); + va_TraceMsg(idx, "\tslice_beta_offset_div2 = %d\n", p->slice_beta_offset_div2); + + if (p->slice_type == 0 || p->slice_type == 1) { + va_TraceMsg(idx, "\tRefPicList0 ="); + for (i = 0; i < p->num_ref_idx_l0_active_minus1 + 1; i++) { + va_TraceMsg(idx, "%d-%d-%d-%d\n", p->RefPicList0[i].TopFieldOrderCnt, p->RefPicList0[i].BottomFieldOrderCnt, p->RefPicList0[i].picture_id, p->RefPicList0[i].frame_idx); } - va_TraceMsg("\n"); - if (p->slice_type == 1) - { - va_TraceMsg("RefPicList1:\n"); + if (p->slice_type == 1) { + va_TraceMsg(idx, "\tRefPicList1 ="); for (i = 0; i < p->num_ref_idx_l1_active_minus1 + 1; i++) { - //va_TraceMsg("%d-%d; ", p->RefPicList1[i].TopFieldOrderCnt, p->RefPicList1[i].BottomFieldOrderCnt); - va_TraceMsg("%d-%d-%d-%d; ", p->RefPicList1[i].TopFieldOrderCnt, p->RefPicList1[i].BottomFieldOrderCnt, p->RefPicList1[i].picture_id, p->RefPicList1[i].frame_idx); + va_TraceMsg(idx, "%d-%d-%d-%d\n", p->RefPicList1[i].TopFieldOrderCnt, p->RefPicList1[i].BottomFieldOrderCnt, p->RefPicList1[i].picture_id, p->RefPicList1[i].frame_idx); } } - va_TraceMsg("\n"); } -#endif - - va_TraceMsg("luma_log2_weight_denom: %d\n", p->luma_log2_weight_denom); - va_TraceMsg("chroma_log2_weight_denom: %d\n", p->chroma_log2_weight_denom); - va_TraceMsg("luma_weight_l0_flag: %d\n", p->luma_weight_l0_flag); - if (p->luma_weight_l0_flag) - { - for (i = 0; i <= p->num_ref_idx_l0_active_minus1; i++) - { - va_TraceMsg("%d ", p->luma_weight_l0[i]); - va_TraceMsg("%d ", p->luma_offset_l0[i]); + + va_TraceMsg(idx, "\tluma_log2_weight_denom = %d\n", p->luma_log2_weight_denom); + va_TraceMsg(idx, "\tchroma_log2_weight_denom = %d\n", p->chroma_log2_weight_denom); + va_TraceMsg(idx, "\tluma_weight_l0_flag = %d\n", p->luma_weight_l0_flag); + if (p->luma_weight_l0_flag) { + for (i = 0; i <= p->num_ref_idx_l0_active_minus1; i++) { + va_TraceMsg(idx, "\t%d ", p->luma_weight_l0[i]); + va_TraceMsg(idx, "\t%d ", p->luma_offset_l0[i]); } - va_TraceMsg("\n"); } - - va_TraceMsg("chroma_weight_l0_flag: %d\n", p->chroma_weight_l0_flag); - if (p->chroma_weight_l0_flag) - { - for (i = 0; i <= p->num_ref_idx_l0_active_minus1; i++) - { - va_TraceMsg("%d ", p->chroma_weight_l0[i][0]); - va_TraceMsg("%d ", p->chroma_offset_l0[i][0]); - va_TraceMsg("%d ", p->chroma_weight_l0[i][1]); - va_TraceMsg("%d ", p->chroma_offset_l0[i][1]); + va_TraceMsg(idx, "\tchroma_weight_l0_flag = %d\n", p->chroma_weight_l0_flag); + if (p->chroma_weight_l0_flag) { + for (i = 0; i <= p->num_ref_idx_l0_active_minus1; i++) { + va_TraceMsg(idx, "\t\t%d ", p->chroma_weight_l0[i][0]); + va_TraceMsg(idx, "\t\t%d ", p->chroma_offset_l0[i][0]); + va_TraceMsg(idx, "\t\t%d ", p->chroma_weight_l0[i][1]); + va_TraceMsg(idx, "\t\t%d ", p->chroma_offset_l0[i][1]); } - va_TraceMsg("\n"); } - va_TraceMsg("luma_weight_l1_flag: %d\n", p->luma_weight_l1_flag); - if (p->luma_weight_l1_flag) - { - for (i = 0; i <= p->num_ref_idx_l1_active_minus1; i++) - { - va_TraceMsg("%d ", p->luma_weight_l1[i]); - va_TraceMsg("%d ", p->luma_offset_l1[i]); + + va_TraceMsg(idx, "\tluma_weight_l1_flag = %d\n", p->luma_weight_l1_flag); + if (p->luma_weight_l1_flag) { + for (i = 0; i <= p->num_ref_idx_l1_active_minus1; i++) { + va_TraceMsg(idx, "\t\t%d ", p->luma_weight_l1[i]); + va_TraceMsg(idx, "\t\t%d ", p->luma_offset_l1[i]); } - va_TraceMsg("\n"); } - va_TraceMsg("chroma_weight_l1_flag: %d\n", p->chroma_weight_l1_flag); - if (p->chroma_weight_l1_flag) - { - for (i = 0; i <= p->num_ref_idx_l1_active_minus1; i++) - { - va_TraceMsg("%d ", p->chroma_weight_l1[i][0]); - va_TraceMsg("%d ", p->chroma_offset_l1[i][0]); - va_TraceMsg("%d ", p->chroma_weight_l1[i][1]); - va_TraceMsg("%d ", p->chroma_offset_l1[i][1]); + + va_TraceMsg(idx, "\tchroma_weight_l1_flag = %d\n", p->chroma_weight_l1_flag); + if (p->chroma_weight_l1_flag) { + for (i = 0; i <= p->num_ref_idx_l1_active_minus1; i++) { + va_TraceMsg(idx, "\t\t%d ", p->chroma_weight_l1[i][0]); + va_TraceMsg(idx, "\t\t%d ", p->chroma_offset_l1[i][0]); + va_TraceMsg(idx, "\t\t%d ", p->chroma_weight_l1[i][1]); + va_TraceMsg(idx, "\t\t%d ", p->chroma_offset_l1[i][1]); } - va_TraceMsg("\n"); + va_TraceMsg(idx, "\n"); } } @@ -524,30 +859,171 @@ static void va_TraceVAIQMatrixBufferH264( void *data ) { - va_TraceMsg("========== IQMatrix ============.\n"); VAIQMatrixBufferH264* p = (VAIQMatrixBufferH264* )data; int i, j; - for (i = 0; i < 6; i++) - { - for (j = 0; j < 16; j++) - { - va_TraceMsg("%d\t", p->ScalingList4x4[i][j]); + DPY2INDEX(dpy); + + va_TraceMsg(idx, "VAIQMatrixBufferH264\n"); + + va_TraceMsg(idx, "\tScalingList4x4[6][16]=\n"); + for (i = 0; i < 6; i++) { + for (j = 0; j < 16; j++) { + va_TraceMsg(idx, "\t%d\t", p->ScalingList4x4[i][j]); if ((j + 1) % 8 == 0) - va_TraceMsg("\n"); + va_TraceMsg(idx, "\n"); } } - for (i = 0; i < 2; i++) - { - for (j = 0; j < 64; j++) - { - va_TraceMsg("%d\t", p->ScalingList8x8[i][j]); + va_TraceMsg(idx, "\tScalingList8x8[2][64]=\n"); + for (i = 0; i < 2; i++) { + for (j = 0; j < 64; j++) { + va_TraceMsg(idx, "\t%d", p->ScalingList8x8[i][j]); if ((j + 1) % 8 == 0) - va_TraceMsg("\n"); + va_TraceMsg(idx, "\n"); } } } +static void va_TraceVAEncSequenceParameterBufferH264( + VADisplay dpy, + VAContextID context, + VABufferID buffer, + VABufferType type, + unsigned int size, + unsigned int num_elements, + void *data) +{ + VAEncSequenceParameterBufferH264 *p = (VAEncSequenceParameterBufferH264 *)data; + DPY2INDEX(dpy); + + va_TraceMsg(idx, "VAEncSequenceParameterBufferH264\n"); + + va_TraceMsg(idx, "\tseq_parameter_set_id = %d\n", p->seq_parameter_set_id); + va_TraceMsg(idx, "\tlevel_idc = %d\n", p->level_idc); + va_TraceMsg(idx, "\tintra_period = %d\n", p->intra_period); + va_TraceMsg(idx, "\tintra_idr_period = %d\n", p->intra_idr_period); + va_TraceMsg(idx, "\tpicture_width_in_mbs = %d\n", p->picture_width_in_mbs); + va_TraceMsg(idx, "\tpicture_height_in_mbs = %d\n", p->picture_height_in_mbs); + va_TraceMsg(idx, "\tbits_per_second = %d\n", p->bits_per_second); + va_TraceMsg(idx, "\tframe_rate = %d\n", p->frame_rate); + va_TraceMsg(idx, "\tinitial_qp = %d\n", p->initial_qp); + va_TraceMsg(idx, "\tmin_qp = %d\n", p->min_qp); + va_TraceMsg(idx, "\tbasic_unit_size = %d\n", p->basic_unit_size); + va_TraceMsg(idx, "\tvui_flag = %d\n", p->vui_flag); + + /* start a new sequce, coded log file can be truncated */ + trace_context[idx].trace_sequence_start = 1; + + return; +} + +static void va_TraceVAEncPictureParameterBufferH264( + VADisplay dpy, + VAContextID context, + VABufferID buffer, + VABufferType type, + unsigned int size, + unsigned int num_elements, + void *data) +{ + VAEncPictureParameterBufferH264 *p = (VAEncPictureParameterBufferH264 *)data; + DPY2INDEX(dpy); + + va_TraceMsg(idx, "VAEncSequenceParameterBufferH264\n"); + va_TraceMsg(idx, "\treference_picture = 0x%08x\n", p->reference_picture); + va_TraceMsg(idx, "\treconstructed_picture = 0x%08x\n", p->reconstructed_picture); + va_TraceMsg(idx, "\tcoded_buf = %08x\n", p->coded_buf); + va_TraceMsg(idx, "\tpicture_width = %d\n", p->picture_width); + va_TraceMsg(idx, "\tpicture_height = %d\n", p->picture_height); + va_TraceMsg(idx, "\tlast_picture = 0x%08x\n", p->last_picture); + + trace_context[idx].trace_codedbuf = p->coded_buf; + + return; +} + + +static void va_TraceVAEncSliceParameterBuffer( + VADisplay dpy, + VAContextID context, + VABufferID buffer, + VABufferType type, + unsigned int size, + unsigned int num_elements, + void *data) +{ + VAEncSliceParameterBuffer* p = (VAEncSliceParameterBuffer*)data; + DPY2INDEX(dpy); + + va_TraceMsg(idx, "VAEncSliceParameterBuffer\n"); + + va_TraceMsg(idx, "\tstart_row_number = %d\n", p->start_row_number); + va_TraceMsg(idx, "\tslice_height = %d\n", p->slice_height); + va_TraceMsg(idx, "\tslice_flags.is_intra = %d\n", p->slice_flags.bits.is_intra); + va_TraceMsg(idx, "\tslice_flags.disable_deblocking_filter_idc = %d\n", p->slice_flags.bits.disable_deblocking_filter_idc); + + return; +} + +static void va_TraceVAEncMiscParameterBuffer( + VADisplay dpy, + VAContextID context, + VABufferID buffer, + VABufferType type, + unsigned int size, + unsigned int num_elements, + void *data) +{ + VAEncMiscParameterBuffer* tmp = (VAEncMiscParameterBuffer*)data; + DPY2INDEX(dpy); + + switch (tmp->type) { + case VAEncMiscParameterTypeFrameRate: + { + VAEncMiscParameterFrameRate *p = (VAEncMiscParameterFrameRate *)tmp->data; + va_TraceMsg(idx, "VAEncMiscParameterFrameRate\n"); + va_TraceMsg(idx, "\tframerate = %d\n", p->framerate); + + break; + } + case VAEncMiscParameterTypeRateControl: + { + VAEncMiscParameterRateControl *p = (VAEncMiscParameterRateControl *)tmp->data; + + va_TraceMsg(idx, "VAEncMiscParameterRateControl\n"); + va_TraceMsg(idx, "\tbits_per_second = %d\n", p->bits_per_second); + va_TraceMsg(idx, "\twindow_size = %d\n", p->window_size); + va_TraceMsg(idx, "\tinitial_qp = %d\n", p->initial_qp); + va_TraceMsg(idx, "\tmin_qp = %d\n", p->min_qp); + break; + } + case VAEncMiscParameterTypeMaxSliceSize: + { + VAEncMiscParameterMaxSliceSize *p = (VAEncMiscParameterMaxSliceSize *)tmp->data; + + va_TraceMsg(idx, "VAEncMiscParameterTypeMaxSliceSize\n"); + va_TraceMsg(idx, "\tmax_slice_size = %d\n", p->max_slice_size); + break; + } + case VAEncMiscParameterTypeAIR: + { + VAEncMiscParameterAIR *p = (VAEncMiscParameterAIR *)tmp->data; + + va_TraceMsg(idx, "VAEncMiscParameterAIR\n"); + va_TraceMsg(idx, "\tair_num_mbs = %d\n", p->air_num_mbs); + va_TraceMsg(idx, "\tair_threshold = %d\n", p->air_threshold); + va_TraceMsg(idx, "\tair_auto = %d\n", p->air_auto); + break; + } + default: + va_TraceMsg(idx, "invalid VAEncMiscParameterBuffer type = %d\n", tmp->type); + break; + } + + return; +} + + static void va_TraceVAPictureParameterBufferVC1( VADisplay dpy, VAContextID context, @@ -559,174 +1035,96 @@ static void va_TraceVAPictureParameterBufferVC1( ) { VAPictureParameterBufferVC1* p = (VAPictureParameterBufferVC1*)data; - - va_TraceMsg("\tforward_reference_picture = 0x%08x\n", p->forward_reference_picture); - va_TraceMsg("\tbackward_reference_picture = 0x%08x\n", p->backward_reference_picture); - va_TraceMsg("\tinloop_decoded_picture = 0x%08x\n", p->inloop_decoded_picture); - - va_TraceMsg("\tpulldown = %d\n", p->sequence_fields.bits.pulldown); - va_TraceMsg("\tinterlace = %d\n", p->sequence_fields.bits.interlace); - va_TraceMsg("\ttfcntrflag = %d\n", p->sequence_fields.bits.tfcntrflag); - va_TraceMsg("\tfinterpflag = %d\n", p->sequence_fields.bits.finterpflag); - va_TraceMsg("\tpsf = %d.\n", - p->sequence_fields.bits.psf); - va_TraceMsg("\tmultires = %d.\n", - p->sequence_fields.bits.multires); - va_TraceMsg("\toverlap = %d.\n", - p->sequence_fields.bits.overlap); - va_TraceMsg("\tsyncmarker = %d.\n", - p->sequence_fields.bits.syncmarker); - va_TraceMsg("\trangered = %d.\n", - p->sequence_fields.bits.rangered); - va_TraceMsg("\tmax_b_frames = %d.\n", - p->sequence_fields.bits.max_b_frames); - va_TraceMsg("\tcoded_width = %d.\n", - p->coded_width); - va_TraceMsg("\tcoded_height = %d.\n", - p->coded_height); - va_TraceMsg("\tclosed_entry = %d.\n", - p->entrypoint_fields.bits.closed_entry); - va_TraceMsg("\tbroken_link = %d.\n", - p->entrypoint_fields.bits.broken_link); - va_TraceMsg("\tclosed_entry = %d.\n", - p->entrypoint_fields.bits.closed_entry); - va_TraceMsg("\tpanscan_flag = %d.\n", - p->entrypoint_fields.bits.panscan_flag); - va_TraceMsg("\tloopfilter = %d.\n", - p->entrypoint_fields.bits.loopfilter); - va_TraceMsg("\tconditional_overlap_flag = %d.\n", - p->conditional_overlap_flag); - va_TraceMsg("\tfast_uvmc_flag = %d.\n", - p->fast_uvmc_flag); - va_TraceMsg("\trange_mapping_luma_flag = %d.\n", - p->range_mapping_fields.bits.luma_flag); - va_TraceMsg("\trange_mapping_luma = %d.\n", - p->range_mapping_fields.bits.luma); - va_TraceMsg("\trange_mapping_chroma_flag = %d.\n", - p->range_mapping_fields.bits.chroma_flag); - va_TraceMsg("\trange_mapping_chroma = %d.\n", - p->range_mapping_fields.bits.chroma); - va_TraceMsg("\tb_picture_fraction = %d.\n", - p->b_picture_fraction); - va_TraceMsg("\tcbp_table = %d.\n", - p->cbp_table); - va_TraceMsg("\tmb_mode_table = %d.\n", - p->mb_mode_table); - va_TraceMsg("\trange_reduction_frame = %d.\n", - p->range_reduction_frame); - va_TraceMsg("\trounding_control = %d.\n", - p->rounding_control); - va_TraceMsg("\tpost_processing = %d.\n", - p->post_processing); - va_TraceMsg("\tpicture_resolution_index = %d.\n", - p->picture_resolution_index); - va_TraceMsg("\tluma_scale = %d.\n", - p->luma_scale); - va_TraceMsg("\tluma_shift = %d.\n", - p->luma_shift); - va_TraceMsg("\tpicture_type = %d.\n", - p->picture_fields.bits.picture_type); - va_TraceMsg("\tframe_coding_mode = %d.\n", - p->picture_fields.bits.frame_coding_mode); - va_TraceMsg("\ttop_field_first = %d.\n", - p->picture_fields.bits.top_field_first); - va_TraceMsg("\tis_first_field = %d.\n", - p->picture_fields.bits.is_first_field); - va_TraceMsg("\tintensity_compensation = %d.\n", - p->picture_fields.bits.intensity_compensation); - va_TraceMsg(" ---------------------------------\n"); - va_TraceMsg("\tmv_type_mb = %d.\n", - p->raw_coding.flags.mv_type_mb); - va_TraceMsg("\tdirect_mb = %d.\n", - p->raw_coding.flags.direct_mb); - va_TraceMsg("\tskip_mb = %d.\n", - p->raw_coding.flags.skip_mb); - va_TraceMsg("\tfield_tx = %d.\n", - p->raw_coding.flags.field_tx); - va_TraceMsg("\tforward_mb = %d.\n", - p->raw_coding.flags.forward_mb); - va_TraceMsg("\tac_pred = %d.\n", - p->raw_coding.flags.ac_pred); - va_TraceMsg("\toverflags = %d.\n", - p->raw_coding.flags.overflags); - va_TraceMsg(" ---------------------------------\n"); - va_TraceMsg("\tbp_mv_type_mb = %d.\n", - p->bitplane_present.flags.bp_mv_type_mb); - va_TraceMsg("\tbp_direct_mb = %d.\n", - p->bitplane_present.flags.bp_direct_mb); - va_TraceMsg("\tbp_skip_mb = %d.\n", - p->bitplane_present.flags.bp_skip_mb); - va_TraceMsg("\tbp_field_tx = %d.\n", - p->bitplane_present.flags.bp_field_tx); - va_TraceMsg("\tbp_forward_mb = %d.\n", - p->bitplane_present.flags.bp_forward_mb); - va_TraceMsg("\tbp_ac_pred = %d.\n", - p->bitplane_present.flags.bp_ac_pred); - va_TraceMsg("\tbp_overflags = %d.\n", - p->bitplane_present.flags.bp_overflags); - va_TraceMsg(" ---------------------------------\n"); - va_TraceMsg("\treference_distance_flag = %d.\n", - p->reference_fields.bits.reference_distance_flag); - va_TraceMsg("\treference_distance = %d.\n", - p->reference_fields.bits.reference_distance); - va_TraceMsg("\tnum_reference_pictures = %d.\n", - p->reference_fields.bits.num_reference_pictures); - va_TraceMsg("\treference_field_pic_indicator = %d.\n", - p->reference_fields.bits.reference_field_pic_indicator); - va_TraceMsg("\tmv_mode = %d.\n", - p->mv_fields.bits.mv_mode); - va_TraceMsg("\tmv_mode2 = %d.\n", - p->mv_fields.bits.mv_mode2); - va_TraceMsg("\tmv_table = %d.\n", - p->mv_fields.bits.mv_table); - va_TraceMsg("\ttwo_mv_block_pattern_table = %d.\n", - p->mv_fields.bits.two_mv_block_pattern_table); - va_TraceMsg("\tfour_mv_switch = %d.\n", - p->mv_fields.bits.four_mv_switch); - va_TraceMsg("\tfour_mv_block_pattern_table = %d.\n", - p->mv_fields.bits.four_mv_block_pattern_table); - va_TraceMsg("\textended_mv_flag = %d.\n", - p->mv_fields.bits.extended_mv_flag); - va_TraceMsg("\textended_mv_range = %d.\n", - p->mv_fields.bits.extended_mv_range); - va_TraceMsg("\textended_dmv_flag = %d.\n", - p->mv_fields.bits.extended_dmv_flag); - va_TraceMsg("\textended_dmv_range = %d.\n", - p->mv_fields.bits.extended_dmv_range); - va_TraceMsg("\tdquant = %d.\n", - p->pic_quantizer_fields.bits.dquant); - va_TraceMsg("\tquantizer = %d.\n", - p->pic_quantizer_fields.bits.quantizer); - va_TraceMsg("\thalf_qp = %d.\n", - p->pic_quantizer_fields.bits.half_qp); - va_TraceMsg("\tpic_quantizer_scale = %d.\n", - p->pic_quantizer_fields.bits.pic_quantizer_scale); - va_TraceMsg("\tpic_quantizer_type = %d.\n", - p->pic_quantizer_fields.bits.pic_quantizer_type); - va_TraceMsg("\tdq_frame = %d.\n", - p->pic_quantizer_fields.bits.dq_frame); - va_TraceMsg("\tdq_profile = %d.\n", - p->pic_quantizer_fields.bits.dq_profile); - va_TraceMsg("\tdq_sb_edge = %d.\n", - p->pic_quantizer_fields.bits.dq_sb_edge); - va_TraceMsg("\tdq_db_edge = %d.\n", - p->pic_quantizer_fields.bits.dq_db_edge); - va_TraceMsg("\tdq_binary_level = %d.\n", - p->pic_quantizer_fields.bits.dq_binary_level); - va_TraceMsg("\talt_pic_quantizer = %d.\n", - p->pic_quantizer_fields.bits.alt_pic_quantizer); - va_TraceMsg("\tvariable_sized_transform_flag = %d.\n", - p->transform_fields.bits.variable_sized_transform_flag); - va_TraceMsg("\tmb_level_transform_type_flag = %d.\n", - p->transform_fields.bits.mb_level_transform_type_flag); - va_TraceMsg("\tframe_level_transform_type = %d.\n", - p->transform_fields.bits.frame_level_transform_type); - va_TraceMsg("\ttransform_ac_codingset_idx1 = %d.\n", - p->transform_fields.bits.transform_ac_codingset_idx1); - va_TraceMsg("\ttransform_ac_codingset_idx2 = %d.\n", - p->transform_fields.bits.transform_ac_codingset_idx2); - va_TraceMsg("\tintra_transform_dc_table = %d.\n", - p->transform_fields.bits.intra_transform_dc_table); + DPY2INDEX(dpy); + + va_TraceMsg(idx, "VAPictureParameterBufferVC1\n"); + + va_TraceMsg(idx, "\tforward_reference_picture = 0x%08x\n", p->forward_reference_picture); + va_TraceMsg(idx, "\tbackward_reference_picture = 0x%08x\n", p->backward_reference_picture); + va_TraceMsg(idx, "\tinloop_decoded_picture = 0x%08x\n", p->inloop_decoded_picture); + + va_TraceMsg(idx, "\tpulldown = %d\n", p->sequence_fields.bits.pulldown); + va_TraceMsg(idx, "\tinterlace = %d\n", p->sequence_fields.bits.interlace); + va_TraceMsg(idx, "\ttfcntrflag = %d\n", p->sequence_fields.bits.tfcntrflag); + va_TraceMsg(idx, "\tfinterpflag = %d\n", p->sequence_fields.bits.finterpflag); + va_TraceMsg(idx, "\tpsf = %d\n", p->sequence_fields.bits.psf); + va_TraceMsg(idx, "\tmultires = %d\n", p->sequence_fields.bits.multires); + va_TraceMsg(idx, "\toverlap = %d\n", p->sequence_fields.bits.overlap); + va_TraceMsg(idx, "\tsyncmarker = %d\n", p->sequence_fields.bits.syncmarker); + va_TraceMsg(idx, "\trangered = %d\n", p->sequence_fields.bits.rangered); + va_TraceMsg(idx, "\tmax_b_frames = %d\n", p->sequence_fields.bits.max_b_frames); + va_TraceMsg(idx, "\tcoded_width = %d\n", p->coded_width); + va_TraceMsg(idx, "\tcoded_height = %d\n", p->coded_height); + va_TraceMsg(idx, "\tclosed_entry = %d\n", p->entrypoint_fields.bits.closed_entry); + va_TraceMsg(idx, "\tbroken_link = %d\n", p->entrypoint_fields.bits.broken_link); + va_TraceMsg(idx, "\tclosed_entry = %d\n", p->entrypoint_fields.bits.closed_entry); + va_TraceMsg(idx, "\tpanscan_flag = %d\n", p->entrypoint_fields.bits.panscan_flag); + va_TraceMsg(idx, "\tloopfilter = %d\n", p->entrypoint_fields.bits.loopfilter); + va_TraceMsg(idx, "\tconditional_overlap_flag = %d\n", p->conditional_overlap_flag); + va_TraceMsg(idx, "\tfast_uvmc_flag = %d\n", p->fast_uvmc_flag); + va_TraceMsg(idx, "\trange_mapping_luma_flag = %d\n", p->range_mapping_fields.bits.luma_flag); + va_TraceMsg(idx, "\trange_mapping_luma = %d\n", p->range_mapping_fields.bits.luma); + va_TraceMsg(idx, "\trange_mapping_chroma_flag = %d\n", p->range_mapping_fields.bits.chroma_flag); + va_TraceMsg(idx, "\trange_mapping_chroma = %d\n", p->range_mapping_fields.bits.chroma); + va_TraceMsg(idx, "\tb_picture_fraction = %d\n", p->b_picture_fraction); + va_TraceMsg(idx, "\tcbp_table = %d\n", p->cbp_table); + va_TraceMsg(idx, "\tmb_mode_table = %d\n", p->mb_mode_table); + va_TraceMsg(idx, "\trange_reduction_frame = %d\n", p->range_reduction_frame); + va_TraceMsg(idx, "\trounding_control = %d\n", p->rounding_control); + va_TraceMsg(idx, "\tpost_processing = %d\n", p->post_processing); + va_TraceMsg(idx, "\tpicture_resolution_index = %d\n", p->picture_resolution_index); + va_TraceMsg(idx, "\tluma_scale = %d\n", p->luma_scale); + va_TraceMsg(idx, "\tluma_shift = %d\n", p->luma_shift); + va_TraceMsg(idx, "\tpicture_type = %d\n", p->picture_fields.bits.picture_type); + va_TraceMsg(idx, "\tframe_coding_mode = %d\n", p->picture_fields.bits.frame_coding_mode); + va_TraceMsg(idx, "\ttop_field_first = %d\n", p->picture_fields.bits.top_field_first); + va_TraceMsg(idx, "\tis_first_field = %d\n", p->picture_fields.bits.is_first_field); + va_TraceMsg(idx, "\tintensity_compensation = %d\n", p->picture_fields.bits.intensity_compensation); + va_TraceMsg(idx, "\tmv_type_mb = %d\n", p->raw_coding.flags.mv_type_mb); + va_TraceMsg(idx, "\tdirect_mb = %d\n", p->raw_coding.flags.direct_mb); + va_TraceMsg(idx, "\tskip_mb = %d\n", p->raw_coding.flags.skip_mb); + va_TraceMsg(idx, "\tfield_tx = %d\n", p->raw_coding.flags.field_tx); + va_TraceMsg(idx, "\tforward_mb = %d\n", p->raw_coding.flags.forward_mb); + va_TraceMsg(idx, "\tac_pred = %d\n", p->raw_coding.flags.ac_pred); + va_TraceMsg(idx, "\toverflags = %d\n", p->raw_coding.flags.overflags); + va_TraceMsg(idx, "\tbp_mv_type_mb = %d\n", p->bitplane_present.flags.bp_mv_type_mb); + va_TraceMsg(idx, "\tbp_direct_mb = %d\n", p->bitplane_present.flags.bp_direct_mb); + va_TraceMsg(idx, "\tbp_skip_mb = %d\n", p->bitplane_present.flags.bp_skip_mb); + va_TraceMsg(idx, "\tbp_field_tx = %d\n", p->bitplane_present.flags.bp_field_tx); + va_TraceMsg(idx, "\tbp_forward_mb = %d\n", p->bitplane_present.flags.bp_forward_mb); + va_TraceMsg(idx, "\tbp_ac_pred = %d\n", p->bitplane_present.flags.bp_ac_pred); + va_TraceMsg(idx, "\tbp_overflags = %d\n", p->bitplane_present.flags.bp_overflags); + va_TraceMsg(idx, "\treference_distance_flag = %d\n", p->reference_fields.bits.reference_distance_flag); + va_TraceMsg(idx, "\treference_distance = %d\n", p->reference_fields.bits.reference_distance); + va_TraceMsg(idx, "\tnum_reference_pictures = %d\n", p->reference_fields.bits.num_reference_pictures); + va_TraceMsg(idx, "\treference_field_pic_indicator = %d\n", p->reference_fields.bits.reference_field_pic_indicator); + va_TraceMsg(idx, "\tmv_mode = %d\n", p->mv_fields.bits.mv_mode); + va_TraceMsg(idx, "\tmv_mode2 = %d\n", p->mv_fields.bits.mv_mode2); + va_TraceMsg(idx, "\tmv_table = %d\n", p->mv_fields.bits.mv_table); + va_TraceMsg(idx, "\ttwo_mv_block_pattern_table = %d\n", p->mv_fields.bits.two_mv_block_pattern_table); + va_TraceMsg(idx, "\tfour_mv_switch = %d\n", p->mv_fields.bits.four_mv_switch); + va_TraceMsg(idx, "\tfour_mv_block_pattern_table = %d\n", p->mv_fields.bits.four_mv_block_pattern_table); + va_TraceMsg(idx, "\textended_mv_flag = %d\n", p->mv_fields.bits.extended_mv_flag); + va_TraceMsg(idx, "\textended_mv_range = %d\n", p->mv_fields.bits.extended_mv_range); + va_TraceMsg(idx, "\textended_dmv_flag = %d\n", p->mv_fields.bits.extended_dmv_flag); + va_TraceMsg(idx, "\textended_dmv_range = %d\n", p->mv_fields.bits.extended_dmv_range); + va_TraceMsg(idx, "\tdquant = %d\n", p->pic_quantizer_fields.bits.dquant); + va_TraceMsg(idx, "\tquantizer = %d\n", p->pic_quantizer_fields.bits.quantizer); + va_TraceMsg(idx, "\thalf_qp = %d\n", p->pic_quantizer_fields.bits.half_qp); + va_TraceMsg(idx, "\tpic_quantizer_scale = %d\n", p->pic_quantizer_fields.bits.pic_quantizer_scale); + va_TraceMsg(idx, "\tpic_quantizer_type = %d\n", p->pic_quantizer_fields.bits.pic_quantizer_type); + va_TraceMsg(idx, "\tdq_frame = %d\n", p->pic_quantizer_fields.bits.dq_frame); + va_TraceMsg(idx, "\tdq_profile = %d\n", p->pic_quantizer_fields.bits.dq_profile); + va_TraceMsg(idx, "\tdq_sb_edge = %d\n", p->pic_quantizer_fields.bits.dq_sb_edge); + va_TraceMsg(idx, "\tdq_db_edge = %d\n", p->pic_quantizer_fields.bits.dq_db_edge); + va_TraceMsg(idx, "\tdq_binary_level = %d\n", p->pic_quantizer_fields.bits.dq_binary_level); + va_TraceMsg(idx, "\talt_pic_quantizer = %d\n", p->pic_quantizer_fields.bits.alt_pic_quantizer); + va_TraceMsg(idx, "\tvariable_sized_transform_flag = %d\n", p->transform_fields.bits.variable_sized_transform_flag); + va_TraceMsg(idx, "\tmb_level_transform_type_flag = %d\n", p->transform_fields.bits.mb_level_transform_type_flag); + va_TraceMsg(idx, "\tframe_level_transform_type = %d\n", p->transform_fields.bits.frame_level_transform_type); + va_TraceMsg(idx, "\ttransform_ac_codingset_idx1 = %d\n", p->transform_fields.bits.transform_ac_codingset_idx1); + va_TraceMsg(idx, "\ttransform_ac_codingset_idx2 = %d\n", p->transform_fields.bits.transform_ac_codingset_idx2); + va_TraceMsg(idx, "\tintra_transform_dc_table = %d\n", p->transform_fields.bits.intra_transform_dc_table); } static void va_TraceVASliceParameterBufferVC1( @@ -740,13 +1138,17 @@ static void va_TraceVASliceParameterBufferVC1( ) { VASliceParameterBufferVC1 *p = (VASliceParameterBufferVC1*)data; + DPY2INDEX(dpy); + + trace_context[idx].trace_slice_no++; + trace_context[idx].trace_slice_size = p->slice_data_size; - va_TraceMsg ("========== SLICE NUMBER ==========\n"); - va_TraceMsg (" slice_data_size = %d\n", p->slice_data_size); - va_TraceMsg (" slice_data_offset = %d\n", p->slice_data_offset); - va_TraceMsg (" slice_data_flag = %d\n", p->slice_data_flag); - va_TraceMsg (" macroblock_offset = %d\n", p->macroblock_offset); - va_TraceMsg (" slice_vertical_position = %d\n", p->slice_vertical_position); + va_TraceMsg(idx, "VASliceParameterBufferVC1\n"); + va_TraceMsg(idx, "\tslice_data_size = %d\n", p->slice_data_size); + va_TraceMsg(idx, "\tslice_data_offset = %d\n", p->slice_data_offset); + va_TraceMsg(idx, "\tslice_data_flag = %d\n", p->slice_data_flag); + va_TraceMsg(idx, "\tmacroblock_offset = %d\n", p->macroblock_offset); + va_TraceMsg(idx, "\tslice_vertical_position = %d\n", p->slice_vertical_position); } void va_TraceBeginPicture( @@ -755,15 +1157,17 @@ void va_TraceBeginPicture( VASurfaceID render_target ) { - int i; + DPY2INDEX(dpy); - va_TraceMsg("\tcontext = 0x%08x\n", context); - va_TraceMsg("\t\trender_targets = 0x%08x\n", render_target); + TRACE_FUNCNAME(idx); + + va_TraceMsg(idx, "\tcontext = 0x%08x\n", context); + va_TraceMsg(idx, "\trender_targets = 0x%08x\n", render_target); - trace_rendertarget = render_target; /* for surface data dump after vaEndPicture */ + trace_context[idx].trace_rendertarget = render_target; /* for surface data dump after vaEndPicture */ - trace_frame++; - trace_slice = 0; + trace_context[idx].trace_frame_no++; + trace_context[idx].trace_slice_no = 0; } static void va_TraceMPEG2Buf( @@ -784,25 +1188,30 @@ static void va_TraceMPEG2Buf( va_TraceVAIQMatrixBufferMPEG2(dpy, context, buffer, type, size, num_elements, pbuf); break; case VABitPlaneBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VASliceGroupMapBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VASliceParameterBufferType: - trace_slice++; va_TraceVASliceParameterBufferMPEG2(dpy, context, buffer, type, size, num_elements, pbuf); break; case VASliceDataBufferType: va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VAMacroblockParameterBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VAResidualDataBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VADeblockingParameterBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VAImageBufferType: break; case VAProtectedSliceDataBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VAEncCodedBufferType: break; @@ -816,6 +1225,8 @@ static void va_TraceMPEG2Buf( break; case VAEncH264SEIBufferType: break; + default: + break; } } @@ -837,6 +1248,7 @@ static void va_TraceMPEG4Buf( va_TraceVAIQMatrixBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf); break; case VABitPlaneBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VASliceGroupMapBufferType: break; @@ -847,10 +1259,13 @@ static void va_TraceMPEG4Buf( va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VAMacroblockParameterBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VAResidualDataBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VADeblockingParameterBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VAImageBufferType: break; @@ -860,10 +1275,13 @@ static void va_TraceMPEG4Buf( case VAEncCodedBufferType: break; case VAEncSequenceParameterBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VAEncPictureParameterBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VAEncSliceParameterBufferType: + va_TraceVAEncSliceParameterBuffer(dpy, context, buffer, type, size, num_elements, pbuf); break; case VAEncH264VUIBufferType: break; @@ -885,6 +1303,8 @@ static void va_TraceH264Buf( void *pbuf ) { + DPY2INDEX(dpy); + switch (type) { case VAPictureParameterBufferType: va_TraceVAPictureParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf); @@ -893,20 +1313,25 @@ static void va_TraceH264Buf( va_TraceVAIQMatrixBufferH264(dpy, context, buffer, type, size, num_elements, pbuf); break; case VABitPlaneBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VASliceGroupMapBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VASliceParameterBufferType: va_TraceVASliceParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf); break; case VASliceDataBufferType: - va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); + va_TraceVABuffers(dpy, context, buffer, type, trace_context[idx].trace_slice_size, num_elements, pbuf); break; case VAMacroblockParameterBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VAResidualDataBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VADeblockingParameterBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VAImageBufferType: break; @@ -916,14 +1341,22 @@ static void va_TraceH264Buf( case VAEncCodedBufferType: break; case VAEncSequenceParameterBufferType: + va_TraceVAEncSequenceParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf); break; case VAEncPictureParameterBufferType: + va_TraceVAEncPictureParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf); break; case VAEncSliceParameterBufferType: + va_TraceVAEncSliceParameterBuffer(dpy, context, buffer, type, size, num_elements, pbuf); break; case VAEncH264VUIBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VAEncH264SEIBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); + break; + case VAEncMiscParameterBufferType: + va_TraceVAEncMiscParameterBuffer(dpy, context, buffer, type, size, num_elements, pbuf); break; default: break; @@ -941,6 +1374,8 @@ static void va_TraceVC1Buf( void *pbuf ) { + DPY2INDEX(dpy); + switch (type) { case VAPictureParameterBufferType: va_TraceVAPictureParameterBufferVC1(dpy, context, buffer, type, size, num_elements, pbuf); @@ -951,18 +1386,22 @@ static void va_TraceVC1Buf( va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VASliceGroupMapBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VASliceParameterBufferType: va_TraceVASliceParameterBufferVC1(dpy, context, buffer, type, size, num_elements, pbuf); break; case VASliceDataBufferType: - va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); + va_TraceVABuffers(dpy, context, buffer, type, trace_context[idx].trace_slice_size, num_elements, pbuf); break; case VAMacroblockParameterBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VAResidualDataBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VADeblockingParameterBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VAImageBufferType: break; @@ -972,14 +1411,13 @@ static void va_TraceVC1Buf( case VAEncCodedBufferType: break; case VAEncSequenceParameterBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VAEncPictureParameterBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; case VAEncSliceParameterBufferType: - break; - case VAEncH264VUIBufferType: - break; - case VAEncH264SEIBufferType: + va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf); break; default: break; @@ -997,44 +1435,74 @@ void va_TraceRenderPicture( unsigned int size; unsigned int num_elements; int i; + DPY2INDEX(dpy); - va_TraceMsg("\tcontext = 0x%08x\n", context); - va_TraceMsg("\tnum_buffers = %d\n", num_buffers); + TRACE_FUNCNAME(idx); + + va_TraceMsg(idx, "\tcontext = 0x%08x\n", context); + va_TraceMsg(idx, "\tnum_buffers = %d\n", num_buffers); for (i = 0; i < num_buffers; i++) { void *pbuf; - + unsigned int j; + /* get buffer type information */ vaBufferInfo(dpy, context, buffers[i], &type, &size, &num_elements); - - va_TraceMsg("\t\tbuffers[%d] = 0x%08x\n", i, buffers[i]); - va_TraceMsg("\t\t\ttype = %s\n", buffer_type_to_string(type)); - va_TraceMsg("\t\t\tsize = %d\n", size); - va_TraceMsg("\t\t\tnum_elements = %d\n", num_elements); + va_TraceMsg(idx, "\t---------------------------\n"); + va_TraceMsg(idx, "\tbuffers[%d] = 0x%08x\n", i, buffers[i]); + va_TraceMsg(idx, "\t type = %s\n", buffer_type_to_string(type)); + va_TraceMsg(idx, "\t size = %d\n", size); + va_TraceMsg(idx, "\t num_elements = %d\n", num_elements); vaMapBuffer(dpy, buffers[i], &pbuf); - switch (trace_profile) { + switch (trace_context[idx].trace_profile) { case VAProfileMPEG2Simple: case VAProfileMPEG2Main: - va_TraceMPEG2Buf(dpy, context, buffers[i], type, size, num_elements, pbuf); + for (j=0; jmax_display_attributes = %d\n", number); +} + +void va_TraceQueryDisplayAttributes ( + VADisplay dpy, + VADisplayAttribute *attr_list, /* out */ + int *num_attributes /* out */ +) +{ + int i; + + DPY2INDEX(dpy); + + va_TraceMsg(idx, "\tnum_attributes = %d\n", *num_attributes); + + for (i=0; i<*num_attributes; i++) { + va_TraceMsg(idx, "\tattr_list[%d] =\n"); + va_TraceMsg(idx, "\t typ = 0x%08x\n", attr_list[i].type); + va_TraceMsg(idx, "\t min_value = %d\n", attr_list[i].min_value); + va_TraceMsg(idx, "\t max_value = %d\n", attr_list[i].max_value); + va_TraceMsg(idx, "\t value = %d\n", attr_list[i].value); + va_TraceMsg(idx, "\t flags = %d\n", attr_list[i].flags); } +} - tmp = UV_data; - if (fourcc == VA_FOURCC_NV12) { - va_TraceMsg("**UV data**\n"); - - for (i=0; ipDriverContext) #define CHECK_DISPLAY(dpy) if( !vaDisplayIsValid(dpy) ) { return VA_STATUS_ERROR_INVALID_DISPLAY; } +extern int fool_postp; /* do nothing for vaPutSurface if set */ +extern int trace_flag; /* trace vaPutSurface parameters */ +#define VA_TRACE(trace_func,...) \ + if (trace_flag) { \ + trace_func(__VA_ARGS__); \ + } + +void va_TracePutSurface ( + VADisplay dpy, + VASurfaceID surface, + void *draw, /* the target Drawable */ + short srcx, + short srcy, + unsigned short srcw, + unsigned short srch, + short destx, + short desty, + unsigned short destw, + unsigned short desth, + VARectangle *cliprects, /* client supplied clip list */ + unsigned int number_cliprects, /* number of clip rects in the clip list */ + unsigned int flags /* de-interlacing flags */ +); + + VAStatus vaPutSurface ( VADisplay dpy, VASurfaceID surface, @@ -250,9 +275,16 @@ VAStatus vaPutSurface ( { VADriverContextP ctx; + if (fool_postp) + return VA_STATUS_SUCCESS; + CHECK_DISPLAY(dpy); ctx = CTX(dpy); - + + VA_TRACE(va_TracePutSurface, dpy, surface, (void *)draw, srcx, srcy, srcw, srch, + destx, desty, destw, desth, + cliprects, number_cliprects, flags ); + return ctx->vtable.vaPutSurface( ctx, surface, (void *)draw, srcx, srcy, srcw, srch, destx, desty, destw, desth, cliprects, number_cliprects, flags ); -- cgit v1.2.3