summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorAustin Yuan <shengquan.yuan@gmail.com>2010-10-28 07:18:18 +0800
committerAustin Yuan <shengquan.yuan@gmail.com>2010-10-28 07:18:18 +0800
commit881b49c5f154ee6603eee4aebb8becae6097a4bd (patch)
tree0df6ffc997871a8675636c522ab47b35a2fe961c
parent6c372035373e531d2bb5608861adab3f6b2ff471 (diff)
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 <shengquan.yuan@gmail.com> Signed-off-by: Binglin Chen <binglin.chen@intel.com> Signed-off-by: Fei Jiang <fei.jiang@intel.com> Signed-off-by: Elaine Wang <elaine.wang@intel.com> Signed-off-by: Ren Zhaohan <zhaohan.ren@intel.com> Signed-off-by: Jerry Dong <jerry.dong@intel.com> Signed-off-by: Austin Yuan <shengquan.yuan@gmail.com>
Diffstat
-rw-r--r--Android.mk2
-rw-r--r--COPYING4
-rw-r--r--configure.ac6
-rw-r--r--dummy_drv_video/dummy_drv_video.c2
-rw-r--r--test/vainfo.c9
-rw-r--r--va/Android.mk1
-rw-r--r--va/Makefile.am2
-rw-r--r--va/android/va_android.cpp37
-rw-r--r--va/va.c135
-rw-r--r--va/va.h124
-rw-r--r--va/va_android.h4
-rw-r--r--va/va_trace.c1487
-rw-r--r--va/va_trace.h58
-rw-r--r--va/x11/va_x11.c34
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
@@ -2,17 +2,17 @@
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
diff --git a/configure.ac b/configure.ac
index ac54963..6debe95 100644
--- a/configure.ac
+++ b/configure.ac
@@ -4,17 +4,17 @@
# 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
@@ -26,13 +26,13 @@ m4_define([libva_minor_version], [31])
m4_define([libva_micro_version], [1])
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
# if any interface was removed since last public release, then set age to 0
m4_define([libva_lt_age], [0])
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
@@ -1055,13 +1055,13 @@ VAStatus dummy_PutSurface(
)
{
/* TODO */
Drawable drawable = (Drawable)draw;
(void)drawable;
-
+
return VA_STATUS_ERROR_UNKNOWN;
}
/*
* Query display attributes
* The caller must provide a "attr_list" array that can hold at
diff --git a/test/vainfo.c b/test/vainfo.c
index 33d6ea4..847e57e 100644
--- a/test/vainfo.c
+++ b/test/vainfo.c
@@ -19,13 +19,18 @@
* 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.
*/
+#ifndef ANDROID
#include <va/va_x11.h>
+#else
+#include "va/va_android.h"
+#define Display unsigned int
+#endif
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
@@ -84,13 +89,17 @@ int main(int argc, const char* argv[])
if (name)
name++;
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 : "");
return 1;
}
diff --git a/va/Android.mk b/va/Android.mk
index 848aa83..494f7c7 100644
--- a/va/Android.mk
+++ b/va/Android.mk
@@ -10,12 +10,13 @@ include $(CLEAR_VARS)
#LIBVA_MINOR_VERSION := 31
#LIBVA_MAJOR_VERSION := 0
LOCAL_SRC_FILES := \
va.c \
va_trace.c \
+ va_fool.c
LOCAL_CFLAGS += \
-DANDROID \
-DVA_DRIVERS_PATH="\"$(LIBVA_DRIVERS_PATH)\""
LOCAL_C_INCLUDES += \
diff --git a/va/Makefile.am b/va/Makefile.am
index 8451a38..685fb12 100644
--- a/va/Makefile.am
+++ b/va/Makefile.am
@@ -24,13 +24,13 @@ INCLUDES = \
$(LIBVA_CFLAGS) -I$(top_srcdir)/va/x11 \
-DVA_DRIVERS_PATH="\"$(LIBVA_DRIVERS_PATH)\""
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
libva_tpi_la_SOURCES = va_tpi.c
libva_tpi_ladir = $(libdir)
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
@@ -247,13 +247,13 @@ VADisplay vaGetDisplay (
pDisplayContext->pNext = pDisplayContexts;
pDisplayContext->pDriverContext = pDriverContext;
pDisplayContext->vaIsValid = va_DisplayContextIsValid;
pDisplayContext->vaDestroy = va_DisplayContextDestroy;
pDisplayContext->vaGetDriverName = va_DisplayContextGetDriverName;
pDisplayContexts = pDisplayContext;
- pDriverContext->dri_state = dri_state;
+ pDriverContext->dri_state = dri_state;
dpy = (VADisplay)pDisplayContext;
}
else
{
if (pDisplayContext)
free(pDisplayContext);
@@ -269,12 +269,39 @@ VADisplay vaGetDisplay (
#define CTX(dpy) (((VADisplayContextP)dpy)->pDriverContext)
#define CHECK_DISPLAY(dpy) if( !vaDisplayIsValid(dpy) ) { return VA_STATUS_ERROR_INVALID_DISPLAY; }
#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,
sp<ISurface> draw, /* Android Surface/Window */
short srcx,
short srcy,
@@ -288,13 +315,21 @@ VAStatus vaPutSurface (
unsigned int number_cliprects, /* number of clip rects in the clip list */
unsigned int flags /* de-interlacing flags */
)
{
VADriverContextP ctx;
+ if (fool_postp)
+ return VA_STATUS_SUCCESS;
+
CHECK_DISPLAY(dpy);
ctx = CTX(dpy);
+
+ VA_TRACE(va_TracePutSurface, dpy, surface, static_cast<void*>(&draw), srcx, srcy, srcw, srch,
+ destx, desty, destw, desth,
+ cliprects, number_cliprects, flags );
+
return ctx->vtable.vaPutSurface( ctx, surface, static_cast<void*>(&draw), srcx, srcy, srcw, srch,
destx, desty, destw, desth,
cliprects, number_cliprects, flags );
}
#endif
diff --git a/va/va.c b/va/va.c
index c0722ba..0320ed3 100644
--- a/va/va.c
+++ b/va/va.c
@@ -23,12 +23,13 @@
*/
#define _GNU_SOURCE 1
#include "va.h"
#include "va_backend.h"
#include "va_trace.h"
+#include "va_fool.h"
#include "config.h"
#include <assert.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
@@ -54,33 +55,81 @@
#define CHECK_MAXIMUM(s, ctx, var) if (!va_checkMaximum(ctx->max_##var, #var)) s = VA_STATUS_ERROR_UNKNOWN;
#define CHECK_STRING(s, ctx, var) if (!va_checkString(ctx->str_##var, #var)) s = VA_STATUS_ERROR_UNKNOWN;
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;
fprintf(stderr, "libva error: ");
va_start(args, msg);
vfprintf(stderr, msg, args);
va_end(args);
}
-static void va_infoMessage(const char *msg, ...)
+void va_infoMessage(const char *msg, ...)
{
va_list args;
fprintf(stderr, "libva: ");
va_start(args, msg);
vfprintf(stderr, msg, args);
@@ -337,13 +386,15 @@ VAStatus vaInitialize (
const char *driver_name_env = NULL;
char *driver_name = NULL;
VAStatus vaStatus;
CHECK_DISPLAY(dpy);
- va_TraceInit();
+ va_TraceInit(dpy);
+
+ va_FoolInit(dpy);
va_infoMessage("libva version %s\n", VA_VERSION_S);
driver_name_env = getenv("LIBVA_DRIVER_NAME");
if (driver_name_env && geteuid() == getuid())
{
@@ -394,13 +445,15 @@ VAStatus vaTerminate (
old_ctx->handle = NULL;
}
if (VA_STATUS_SUCCESS == vaStatus)
pDisplayContext->vaDestroy(pDisplayContext);
- va_TraceEnd();
+ va_TraceEnd(dpy);
+
+ va_FoolEnd(dpy);
return vaStatus;
}
/*
* vaQueryVendorString returns a pointer to a zero-terminated string
@@ -508,12 +561,13 @@ VAStatus vaCreateConfig (
{
VADriverContextP ctx;
CHECK_DISPLAY(dpy);
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 );
}
VAStatus vaDestroyConfig (
VADisplay dpy,
VAConfigID config_id
@@ -549,17 +603,21 @@ VAStatus vaCreateSurfaces (
int format,
int num_surfaces,
VASurfaceID *surfaces /* out */
)
{
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;
}
VAStatus vaDestroySurfaces (
VADisplay dpy,
VASurfaceID *surface_list,
@@ -616,12 +674,14 @@ VAStatus vaCreateBuffer (
)
{
VADriverContextP ctx;
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);
}
VAStatus vaBufferSetNumElements (
VADisplay dpy,
VABufferID buf_id, /* in */
@@ -640,27 +700,38 @@ VAStatus vaMapBuffer (
VADisplay dpy,
VABufferID buf_id, /* in */
void **pbuf /* out */
)
{
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 (
VADisplay dpy,
VABufferID buf_id /* in */
)
{
VADriverContextP ctx;
CHECK_DISPLAY(dpy);
ctx = CTX(dpy);
+ if (va_FoolUnmapBuffer(dpy, buf_id))
+ return VA_STATUS_SUCCESS;
return ctx->vtable.vaUnmapBuffer( ctx, buf_id );
}
VAStatus vaDestroyBuffer (
VADisplay dpy,
VABufferID buffer_id
@@ -696,13 +767,17 @@ VAStatus vaBeginPicture (
)
{
VADriverContextP ctx;
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 );
}
VAStatus vaRenderPicture (
VADisplay dpy,
VAContextID context,
@@ -711,13 +786,17 @@ VAStatus vaRenderPicture (
)
{
VADriverContextP ctx;
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 );
}
VAStatus vaEndPicture (
VADisplay dpy,
VAContextID context
@@ -725,26 +804,36 @@ VAStatus vaEndPicture (
{
VAStatus va_status;
VADriverContextP ctx;
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;
}
VAStatus vaSyncSurface (
VADisplay dpy,
VASurfaceID render_target
)
{
VADriverContextP ctx;
CHECK_DISPLAY(dpy);
ctx = CTX(dpy);
+ if (va_FoolSyncSurface( dpy, render_target))
+ return VA_STATUS_SUCCESS;
+
return ctx->vtable.vaSyncSurface( ctx, render_target );
}
VAStatus vaQuerySurfaceStatus (
VADisplay dpy,
VASurfaceID render_target,
@@ -950,12 +1039,14 @@ VAStatus vaQuerySubpictureFormats (
)
{
VADriverContextP ctx;
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);
}
/*
* Subpictures are created with an image associated.
*/
@@ -1093,16 +1184,22 @@ VAStatus vaDeassociateSubpicture (
/* Get maximum number of display attributes supported by the implementation */
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;
}
/*
* Query display attributes
* The caller must provide a "attr_list" array that can hold at
* least vaMaxNumDisplayAttributes() entries. The actual number of attributes
@@ -1115,13 +1212,20 @@ VAStatus vaQueryDisplayAttributes (
)
{
VADriverContextP ctx;
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;
+
}
/*
* Get display attributes
* This function returns the current attribute values in "attr_list".
* Only attributes returned with VA_DISPLAY_ATTRIB_GETTABLE set in the "flags" field
@@ -1134,13 +1238,19 @@ VAStatus vaGetDisplayAttributes (
)
{
VADriverContextP ctx;
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;
}
/*
* Set display attributes
* Only attributes returned with VA_DISPLAY_ATTRIB_SETTABLE set in the "flags" field
* from vaQueryDisplayAttributes() can be set. If the attribute is not settable or
@@ -1153,12 +1263,15 @@ VAStatus vaSetDisplayAttributes (
)
{
VADriverContextP ctx;
CHECK_DISPLAY(dpy);
ctx = CTX(dpy);
+ VA_TRACE(va_TraceSetDisplayAttributes, dpy, attr_list, num_attributes);
+
+
return ctx->vtable.vaSetDisplayAttributes ( ctx, attr_list, num_attributes );
}
VAStatus vaLockSurface(VADisplay dpy,
VASurfaceID surface,
unsigned int *fourcc, /* following are output argument */
diff --git a/va/va.h b/va/va.h
index 0f12dfb..7f24a85 100644
--- a/va/va.h
+++ b/va/va.h
@@ -125,25 +125,35 @@ typedef int VAStatus; /* Return status type from functions */
#define VA_STATUS_ERROR_FLAG_NOT_SUPPORTED 0x00000011
#define VA_STATUS_ERROR_INVALID_PARAMETER 0x00000012
#define VA_STATUS_ERROR_RESOLUTION_NOT_SUPPORTED 0x00000013
#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() */
#define VA_FRAME_PICTURE 0x00000000
#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
#define VA_SRC_BT709 0x00000020
#define VA_SRC_SMPTE_240 0x00000040
@@ -270,12 +280,13 @@ typedef struct _VAConfigAttrib {
#define VA_RT_FORMAT_PROTECTED 0x80000000
/* attribute value for VAConfigAttribRateControl */
#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
* profile/entrypoint pair, then set the value to the following
*/
#define VA_ATTRIB_NOT_SUPPORTED 0x80000000
@@ -499,14 +510,81 @@ typedef enum
VAEncCodedBufferType = 21,
VAEncSequenceParameterBufferType = 22,
VAEncPictureParameterBufferType = 23,
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
* the data for the entire slice, and the following flags will be used in the slice
* parameter to signal to the server for the possible cases.
* If a slice parameter buffer and slice data buffer pair is sent to the server with
@@ -1112,22 +1190,22 @@ typedef struct _VAEncSequenceParameterBufferH264
unsigned int initial_qp;
unsigned int min_qp;
unsigned int basic_unit_size;
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;
VASurfaceID reconstructed_picture;
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;
/****************************
* H.263 specific encode data structures
****************************/
@@ -1222,15 +1300,32 @@ 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;
/*
* Map data store of the buffer into the client's address space
@@ -1710,13 +1805,16 @@ typedef enum
typedef enum
{
VADisplayAttribBrightness = 0,
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
* hardware overlay, after PutSurface is called, the surface can not be
* re-used until after the subsequent PutSurface call. If this is the case
* then the value for this attribute will be set to 1 so that the client
@@ -1736,13 +1834,21 @@ typedef enum
VADisplayAttribBlueStretch = 10,
VADisplayAttribSkinColorCorrection = 11,
/*
* 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 */
#define VA_DISPLAY_ATTRIB_NOT_SUPPORTED 0x0000
#define VA_DISPLAY_ATTRIB_GETTABLE 0x0001
#define VA_DISPLAY_ATTRIB_SETTABLE 0x0002
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
@@ -16,14 +16,14 @@ VADisplay vaGetDisplay (
#ifdef __cplusplus
}
#endif
#ifdef __cplusplus
-#ifdef ANDROID
-#include <ui/ISurface.h>
+#ifdef ANDROID
+#include <surfaceflinger/ISurface.h>
using namespace android;
/*
* Output rendering
* Following is the rendering interface for Android system,
* to get the decode output surface to an ISurface object.
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
@@ -31,29 +31,93 @@
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <dlfcn.h>
#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <time.h>
+
+
+/*
+ * 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 */
VABufferType *type, /* out */
unsigned int *size, /* out */
unsigned int *num_elements /* out */
@@ -73,122 +137,352 @@ VAStatus vaLockSurface(VADisplay dpy,
);
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; i<buf_list->size; 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; i<trace_context[idx].trace_frame_height; i++) {
+ for (j=0; j<trace_context[idx].trace_frame_width; j++)
+ check_sum ^= tmp[j];
+
+ if (trace_context[idx].trace_fp_surface)
+ fwrite(tmp, trace_context[idx].trace_frame_width, 1, trace_context[idx].trace_fp_surface);
+
+ tmp = Y_data + i * luma_stride;
+ }
+
+ tmp = UV_data;
+ if (fourcc == VA_FOURCC_NV12) {
+ for (i=0; i<trace_context[idx].trace_frame_height/2; i++) {
+ for (j=0; j<trace_context[idx].trace_frame_width; j++)
+ check_sum ^= tmp[j];
+
+ if (trace_context[idx].trace_fp_surface)
+ fwrite(tmp, trace_context[idx].trace_frame_width, 1, trace_context[idx].trace_fp_surface);
+
+ tmp = UV_data + i * chroma_u_stride;
+ }
+ }
+
+ vaUnlockSurface(dpy, trace_context[idx].trace_rendertarget);
+
+ va_TraceMsg(idx, "\tchecksum = 0x%02x\n", check_sum & 0xff);
+}
+
void va_TraceCreateConfig(
VADisplay dpy,
VAProfile profile,
VAEntrypoint entrypoint,
VAConfigAttrib *attrib_list,
int num_attribs,
VAConfigID *config_id /* out */
- )
+)
{
int i;
+ DPY2INDEX(dpy);
+
+ TRACE_FUNCNAME(idx);
- va_TraceMsg("\tprofile = %d\n", profile);
- va_TraceMsg("\tentrypoint = %d\n", entrypoint);
- va_TraceMsg("\tnum_attribs = %d\n", num_attribs);
+ va_TraceMsg(idx, "\tprofile = %d\n", profile);
+ va_TraceMsg(idx, "\tentrypoint = %d\n", entrypoint);
+ va_TraceMsg(idx, "\tnum_attribs = %d\n", num_attribs);
for (i = 0; i < num_attribs; i++) {
- va_TraceMsg("\t\tattrib_list[%d].type = 0x%08x\n", i, attrib_list[i].type);
- va_TraceMsg("\t\tattrib_list[%d].value = 0x%08x\n", i, attrib_list[i].value);
+ va_TraceMsg(idx, "\t\tattrib_list[%d].type = 0x%08x\n", i, attrib_list[i].type);
+ va_TraceMsg(idx, "\t\tattrib_list[%d].value = 0x%08x\n", i, attrib_list[i].value);
}
- trace_profile = profile;
+ trace_context[idx].trace_profile = profile;
+ trace_context[idx].trace_entrypoint = entrypoint;
}
void va_TraceCreateSurface(
VADisplay dpy,
int width,
int height,
int format,
int num_surfaces,
VASurfaceID *surfaces /* out */
- )
+)
{
int i;
+ DPY2INDEX(dpy);
+
+ TRACE_FUNCNAME(idx);
- va_TraceMsg("\twidth = %d\n", width);
- va_TraceMsg("\theight = %d\n", height);
- va_TraceMsg("\tformat = %d\n", format);
- va_TraceMsg("\tnum_surfaces = %d\n", num_surfaces);
+ va_TraceMsg(idx, "\twidth = %d\n", width);
+ va_TraceMsg(idx, "\theight = %d\n", height);
+ va_TraceMsg(idx, "\tformat = %d\n", format);
+ va_TraceMsg(idx, "\tnum_surfaces = %d\n", num_surfaces);
for (i = 0; i < num_surfaces; i++)
- va_TraceMsg("\t\tsurfaces[%d] = 0x%08x\n", i, surfaces[i]);
+ va_TraceMsg(idx, "\t\tsurfaces[%d] = 0x%08x\n", i, surfaces[i]);
}
void va_TraceCreateContext(
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;
+ DPY2INDEX(dpy);
- va_TraceMsg("\twidth = %d\n", picture_width);
- va_TraceMsg("\theight = %d\n", picture_height);
- va_TraceMsg("\tflag = 0x%08x\n", flag);
- va_TraceMsg("\tnum_render_targets = %d\n", num_render_targets);
+ TRACE_FUNCNAME(idx);
+
+ va_TraceMsg(idx, "\twidth = %d\n", picture_width);
+ va_TraceMsg(idx, "\theight = %d\n", picture_height);
+ va_TraceMsg(idx, "\tflag = 0x%08x\n", flag);
+ va_TraceMsg(idx, "\tnum_render_targets = %d\n", num_render_targets);
for (i=0; i<num_render_targets; i++)
- va_TraceMsg("\t\trender_targets[%d] = 0x%08x\n", i, render_targets[i]);
- va_TraceMsg("\tcontext = 0x%08x\n", context);
+ va_TraceMsg(idx, "\t\trender_targets[%d] = 0x%08x\n", i, render_targets[i]);
+ va_TraceMsg(idx, "\tcontext = 0x%08x\n", *context);
- trace_frame = 0;
- trace_slice = 0;
+ trace_context[idx].trace_context = *context;
- trace_width = picture_width;
- trace_height = picture_height;
+ trace_context[idx].trace_frame_no = 0;
+ trace_context[idx].trace_slice_no = 0;
+
+ trace_context[idx].trace_frame_width = picture_width;
+ trace_context[idx].trace_frame_height = picture_height;
}
static char * buffer_type_to_string(int type)
{
switch (type) {
@@ -204,52 +498,106 @@ static char * buffer_type_to_string(int type)
case VADeblockingParameterBufferType: return "VADeblockingParameterBufferType";
case VAImageBufferType: return "VAImageBufferType";
case VAEncCodedBufferType: return "VAEncCodedBufferType";
case VAEncSequenceParameterBufferType: return "VAEncSequenceParameterBufferType";
case VAEncPictureParameterBufferType: return "VAEncPictureParameterBufferType";
case VAEncSliceParameterBufferType: return "VAEncSliceParameterBufferType";
+ case VAEncMiscParameterBufferType: return "VAEncMiscParameterBufferType";
default: return "UnknowBuffer";
}
}
+void va_TraceMapBuffer (
+ VADisplay dpy,
+ VABufferID buf_id, /* in */
+ void **pbuf /* out */
+)
+{
+ VABufferType type;
+ unsigned int size;
+ unsigned int num_elements;
+
+ VACodedBufferSegment *buf_list;
+ int i = 0;
+
+ DPY2INDEX(dpy);
+
+ vaBufferInfo(dpy, trace_context[idx].trace_context, buf_id, &type, &size, &num_elements);
+ /*
+ va_TraceMsg(idx, "\tbuf_id=0x%x\n", buf_id);
+ va_TraceMsg(idx, "\tbuf_type=%s\n", buffer_type_to_string(type));
+ va_TraceMsg(idx, "\tbuf_size=%s\n", size);
+ va_TraceMsg(idx, "\tbuf_elements=%s\n", &num_elements);
+ */
+
+ /* only trace CodedBuffer */
+ if (type != VAEncCodedBufferType)
+ return;
+
+ buf_list = (VACodedBufferSegment *)(*pbuf);
+ while (buf_list != NULL) {
+ va_TraceMsg(idx, "\tCodedbuf[%d] =\n", i++);
+
+ va_TraceMsg(idx, "\t size = %d\n", buf_list->size);
+ 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,
VABufferType type,
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; i<size; i++) {
- if ((i%16) == 0)
- va_TraceMsg("\n0x%08x:", i);
- va_TraceMsg(" %02x", p[i]);
+ unsigned char value = p[i];
+
+ if ((trace_buffer_data) && ((i%16) == 0))
+ va_TraceMsg(idx, "\n0x%08x:", i);
+
+ if (trace_buffer_data)
+ va_TraceMsg(idx, " %02x", value);
+
+ check_sum ^= value;
}
- va_TraceMsg("\n");
- return 0;
+ va_TraceMsg(idx, "\tchecksum = 0x%02x\n", check_sum & 0xff);
+
+ return;
}
static void va_TraceVAPictureParameterBufferMPEG2(
VADisplay dpy,
VAContextID context,
VABufferID buffer,
VABufferType type,
unsigned int size,
unsigned int num_elements,
void *data)
{
+ DPY2INDEX(dpy);
+
va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, data);
return;
}
@@ -259,12 +607,14 @@ static void va_TraceVAIQMatrixBufferMPEG2(
VABufferID buffer,
VABufferType type,
unsigned int size,
unsigned int num_elements,
void *data)
{
+ DPY2INDEX(dpy);
+
va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, data);
return;
}
@@ -274,12 +624,18 @@ static void va_TraceVASliceParameterBufferMPEG2(
VABufferID buffer,
VABufferType type,
unsigned int size,
unsigned int num_elements,
void *data)
{
+ DPY2INDEX(dpy);
+
+ trace_context[idx].trace_slice_no++;
+
+ /* todo: log TraceVASliceParameterBufferMPEG2 */
+ /* trace_context[idx].trace_slice_size = p->slice_data_size; */
va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, data);
return;
}
@@ -290,12 +646,14 @@ static void va_TraceVAPictureParameterBufferMPEG4(
VABufferID buffer,
VABufferType type,
unsigned int size,
unsigned int num_elements,
void *data)
{
+ DPY2INDEX(dpy);
+
va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, data);
return;
}
@@ -305,12 +663,15 @@ static void va_TraceVAIQMatrixBufferMPEG4(
VABufferID buffer,
VABufferType type,
unsigned int size,
unsigned int num_elements,
void *data)
{
+ DPY2INDEX(dpy);
+
+ /* todo: log VAIQMatrixBufferMPEG4 */
va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, data);
return;
}
@@ -320,12 +681,18 @@ static void va_TraceVASliceParameterBufferMPEG4(
VABufferID buffer,
VABufferType type,
unsigned int size,
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;
}
@@ -336,82 +703,65 @@ static void va_TraceVAPictureParameterBufferH264(
VABufferType type,
unsigned int size,
unsigned int num_elements,
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;
}
static void va_TraceVASliceParameterBufferH264(
VADisplay dpy,
@@ -421,99 +771,84 @@ static void va_TraceVASliceParameterBufferH264(
unsigned int size,
unsigned int num_elements,
void *data)
{
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");
}
}
static void va_TraceVAIQMatrixBufferH264(
VADisplay dpy,
VAContextID context,
@@ -521,215 +856,278 @@ static void va_TraceVAIQMatrixBufferH264(
VABufferType type,
unsigned int size,
unsigned int num_elements,
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,
VABufferID buffer,
VABufferType type,
unsigned int size,
unsigned int num_elements,
void *data
)
{
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(
VADisplay dpy,
VAContextID context,
VABufferID buffer,
@@ -737,36 +1135,42 @@ static void va_TraceVASliceParameterBufferVC1(
unsigned int size,
unsigned int num_elements,
void* data
)
{
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(
VADisplay dpy,
VAContextID context,
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(
VADisplay dpy,
VAContextID context,
VABufferID buffer,
@@ -781,31 +1185,36 @@ static void va_TraceMPEG2Buf(
va_TraceVAPictureParameterBufferMPEG2(dpy, context, buffer, type, size, num_elements, pbuf);
break;
case VAIQMatrixBufferType:
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;
case VAEncSequenceParameterBufferType:
break;
case VAEncPictureParameterBufferType:
@@ -813,12 +1222,14 @@ static void va_TraceMPEG2Buf(
case VAEncSliceParameterBufferType:
break;
case VAEncH264VUIBufferType:
break;
case VAEncH264SEIBufferType:
break;
+ default:
+ break;
}
}
static void va_TraceMPEG4Buf(
VADisplay dpy,
VAContextID context,
@@ -834,39 +1245,46 @@ static void va_TraceMPEG4Buf(
va_TraceVAPictureParameterBufferMPEG4(dpy, context, buffer, type, size, num_elements, pbuf);
break;
case VAIQMatrixBufferType:
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;
case VASliceParameterBufferType:
va_TraceVASliceParameterBufferMPEG4(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;
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;
case VAEncH264SEIBufferType:
break;
default:
@@ -882,51 +1300,66 @@ static void va_TraceH264Buf(
VABufferType type,
unsigned int size,
unsigned int num_elements,
void *pbuf
)
{
+ DPY2INDEX(dpy);
+
switch (type) {
case VAPictureParameterBufferType:
va_TraceVAPictureParameterBufferH264(dpy, context, buffer, type, size, num_elements, pbuf);
break;
case VAIQMatrixBufferType:
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;
case VAProtectedSliceDataBufferType:
va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
break;
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;
}
}
@@ -938,51 +1371,56 @@ static void va_TraceVC1Buf(
VABufferType type,
unsigned int size,
unsigned int num_elements,
void *pbuf
)
{
+ DPY2INDEX(dpy);
+
switch (type) {
case VAPictureParameterBufferType:
va_TraceVAPictureParameterBufferVC1(dpy, context, buffer, type, size, num_elements, pbuf);
break;
case VAIQMatrixBufferType:
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_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;
case VAProtectedSliceDataBufferType:
va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
break;
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;
}
}
@@ -994,50 +1432,80 @@ void va_TraceRenderPicture(
)
{
VABufferType type;
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; j<num_elements; j++) {
+ va_TraceMsg(idx, "\t element[%d] = ", j);
+ va_TraceMsg(idx, "\t------------------", j);
+ va_TraceMPEG2Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
+ }
break;
case VAProfileMPEG4Simple:
case VAProfileMPEG4AdvancedSimple:
case VAProfileMPEG4Main:
- va_TraceMPEG4Buf(dpy, context, buffers[i], type, size, num_elements, pbuf);
+ for (j=0; j<num_elements; j++) {
+ va_TraceMsg(idx, "\t element[%d] = ", j);
+ va_TraceMsg(idx, "\t------------------", j);
+ va_TraceMPEG4Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
+ }
break;
case VAProfileH264Baseline:
case VAProfileH264Main:
case VAProfileH264High:
- va_TraceH264Buf(dpy, context, buffers[i], type, size, num_elements, pbuf);
+ for (j=0; j<num_elements; j++) {
+ va_TraceMsg(idx, "\t element[%d] = ", j);
+ va_TraceMsg(idx, "\t------------------", j);
+
+ va_TraceH264Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
+ }
break;
case VAProfileVC1Simple:
case VAProfileVC1Main:
case VAProfileVC1Advanced:
- va_TraceVC1Buf(dpy, context, buffers[i], type, size, num_elements, pbuf);
+ for (j=0; j<num_elements; j++) {
+ va_TraceMsg(idx, "\t element[%d] = ", j);
+ va_TraceMsg(idx, "\t------------------", j);
+
+ va_TraceVC1Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
+ }
break;
case VAProfileH263Baseline:
+ for (j=0; j<num_elements; j++) {
+ va_TraceMsg(idx, "\t element[%d] = ", j);
+ va_TraceMsg(idx, "\t------------------", j);
+
+ va_TraceMPEG4Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
+ }
+ break;
+ default:
break;
}
vaUnmapBuffer(dpy, buffers[i]);
}
}
@@ -1045,83 +1513,152 @@ void va_TraceRenderPicture(
void va_TraceEndPicture(
VADisplay dpy,
VAContextID context
)
{
- 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;
- char *Y_data, *UV_data, *tmp;
-
- VAStatus va_status;
-
- va_TraceMsg("\tcontext = 0x%08x\n", context);
- va_TraceMsg("\t\trender_targets = 0x%08x\n", trace_rendertarget);
+ DPY2INDEX(dpy);
+
+ TRACE_FUNCNAME(idx);
- /* force the pipleline finish rendering */
- vaSyncSurface(dpy, trace_rendertarget);
+ va_TraceMsg(idx, "\tcontext = 0x%08x\n", context);
+ va_TraceMsg(idx, "\trender_targets = 0x%08x\n", trace_context[idx].trace_rendertarget);
- va_TraceMsg("***dump surface data***\n", trace_rendertarget);
- va_status = vaLockSurface(dpy, trace_rendertarget, &fourcc, &luma_stride, &chroma_u_stride, &chroma_v_stride,
- &luma_offset, &chroma_u_offset, &chroma_v_offset, &buffer_name, &buffer);
+ /* want to trace codedbuf, and it is encode */
+ if (trace_context[idx].trace_fp_codedbuf &&
+ ((trace_context[idx].trace_entrypoint == VAEntrypointEncSlice) ||
+ (trace_context[idx].trace_entrypoint == VAEntrypointEncPicture))) {
+ /* force the pipleline finish rendering */
+ vaSyncSurface(dpy, trace_context[idx].trace_rendertarget);
+ va_TraceCodedBuf(dpy);
+ }
- if (va_status != VA_STATUS_SUCCESS)
- return;
-
- va_TraceMsg("\tfourcc=0x%08x\n", fourcc);
- va_TraceMsg("\twidth=%d\n", trace_width);
- va_TraceMsg("\theight=%d\n", trace_height);
- va_TraceMsg("\tluma_stride=%d\n", luma_stride);
- va_TraceMsg("\tchroma_u_stride=%d\n", chroma_u_stride);
- va_TraceMsg("\tchroma_v_stride=%d\n", chroma_v_stride);
- va_TraceMsg("\tluma_offset=%d\n", luma_offset);
- va_TraceMsg("\tchroma_u_offset=%d\n", chroma_u_offset);
- va_TraceMsg("\tchroma_v_offset=%d\n", chroma_v_offset);
-
- if (!buffer) {
- vaUnlockSurface(dpy, trace_rendertarget);
- return;
+ /* trace decoded surface for decoding, or the source sourface for encoding */
+ if (trace_context[idx].trace_fp_surface) {
+ /* force the pipleline finish rendering */
+ vaSyncSurface(dpy, trace_context[idx].trace_rendertarget);
+
+ va_TraceSurface(dpy);
}
+}
- Y_data = buffer;
- UV_data = buffer + luma_offset;
- tmp = Y_data;
- va_TraceMsg("**Y data**\n");
- for (i=0; i<trace_height; i++) {
- for (j=0; j<trace_width; j++) {
- if ((j%16) == 0)
- va_TraceMsg("\n0x%08x:", j + i*trace_width);
- va_TraceMsg(" %02x", tmp[j]);
- }
+void va_TraceMaxNumDisplayAttributes (
+ VADisplay dpy,
+ int number
+)
+{
+ DPY2INDEX(dpy);
- va_TraceMsg("\n");
- tmp = Y_data + i * luma_stride;
+ TRACE_FUNCNAME(idx);
+
+ va_TraceMsg(idx, "\t>max_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; i<trace_height/2; i++) {
- for (j=0; j<trace_width; j++) {
- if ((j%16) == 0)
- va_TraceMsg("\n0x%08x:", j + i*trace_width);
- va_TraceMsg(" %02x", tmp[j]);
- }
- va_TraceMsg("\n");
- tmp = UV_data + i * chroma_u_stride;
- }
+static void va_TraceDisplayAttributes (
+ VADisplay dpy,
+ VADisplayAttribute *attr_list,
+ int num_attributes
+)
+{
+ 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);
}
+}
+
+
+void va_TraceGetDisplayAttributes (
+ VADisplay dpy,
+ VADisplayAttribute *attr_list,
+ int num_attributes
+)
+{
+ DPY2INDEX(dpy);
- vaUnlockSurface(dpy, trace_rendertarget);
+ TRACE_FUNCNAME(idx);
+
+ va_TraceDisplayAttributes (dpy, attr_list, num_attributes);
+}
+
+void va_TraceSetDisplayAttributes (
+ VADisplay dpy,
+ VADisplayAttribute *attr_list,
+ int num_attributes
+)
+{
+ DPY2INDEX(dpy);
+
+ TRACE_FUNCNAME(idx);
+
+ va_TraceDisplayAttributes (dpy, attr_list, num_attributes);
+}
+
+
+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 */
+)
+{
+ DPY2INDEX(dpy);
+
+ TRACE_FUNCNAME(idx);
+
+ va_TraceMsg(idx, "\tsurface = 0x%08x\n", surface);
+ va_TraceMsg(idx, "\tdraw = 0x%08x\n", draw);
+ va_TraceMsg(idx, "\tsrcx = %d\n", surface);
+ va_TraceMsg(idx, "\tsrcy = %d\n", surface);
+ va_TraceMsg(idx, "\tsrcw = %d\n", surface);
+ va_TraceMsg(idx, "\tsrch = %d\n", surface);
+ va_TraceMsg(idx, "\tdestx = %d\n", surface);
+ va_TraceMsg(idx, "\tdesty = %d\n", surface);
+ va_TraceMsg(idx, "\tdestw = %d\n", destw);
+ va_TraceMsg(idx, "\tdesth = %d\n", desth);
+ va_TraceMsg(idx, "\tcliprects = 0x%08x\n", cliprects);
+ va_TraceMsg(idx, "\tnumber_cliprects = %d\n", number_cliprects);
+ va_TraceMsg(idx, "\tflags = 0x%08x\n", flags);
}
diff --git a/va/va_trace.h b/va/va_trace.h
index 1c860e3..bb1238f 100644
--- a/va/va_trace.h
+++ b/va/va_trace.h
@@ -22,16 +22,16 @@
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef VA_TRACE_H
#define VA_TRACE_H
-void va_TraceInit(void);
-void va_TraceEnd(void);
+void va_TraceInit(VADisplay dpy);
+void va_TraceEnd(VADisplay dpy);
-void va_TraceMsg(const char *msg, ...);
+void va_TraceMsg(int idx, const char *msg, ...);
void va_TraceCreateConfig(
VADisplay dpy,
VAProfile profile,
VAEntrypoint entrypoint,
VAConfigAttrib *attrib_list,
@@ -56,12 +56,20 @@ void va_TraceCreateContext(
int flag,
VASurfaceID *render_targets,
int num_render_targets,
VAContextID *context /* out */
);
+
+void va_TraceMapBuffer (
+ VADisplay dpy,
+ VABufferID buf_id, /* in */
+ void **pbuf /* out */
+);
+
+
void va_TraceBeginPicture(
VADisplay dpy,
VAContextID context,
VASurfaceID render_target
);
@@ -74,7 +82,51 @@ void va_TraceRenderPicture(
void va_TraceEndPicture(
VADisplay dpy,
VAContextID context
);
+
+void va_TraceMaxNumDisplayAttributes (
+ VADisplay dpy,
+ int number
+);
+
+void va_TraceQueryDisplayAttributes (
+ VADisplay dpy,
+ VADisplayAttribute *attr_list, /* out */
+ int *num_attributes /* out */
+);
+
+void va_TraceGetDisplayAttributes (
+ VADisplay dpy,
+ VADisplayAttribute *attr_list,
+ int num_attributes
+);
+
+void va_TraceSetDisplayAttributes (
+ VADisplay dpy,
+ VADisplayAttribute *attr_list,
+ int num_attributes
+);
+
+/* extern function called by display side */
+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 */
+);
+
+
+
#endif /* VA_TRACE_H */
diff --git a/va/x11/va_x11.c b/va/x11/va_x11.c
index cbd2614..70cea30 100644
--- a/va/x11/va_x11.c
+++ b/va/x11/va_x11.c
@@ -228,12 +228,37 @@ VADisplay vaGetDisplay (
return dpy;
}
#define CTX(dpy) (((VADisplayContextP)dpy)->pDriverContext)
#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,
Drawable draw, /* X Drawable */
short srcx,
short srcy,
@@ -247,13 +272,20 @@ VAStatus vaPutSurface (
unsigned int number_cliprects, /* number of clip rects in the clip list */
unsigned int flags /* de-interlacing flags */
)
{
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 );
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-07 20:08:37 +0000