Make logging callbacks library-safe

Move the logging callbacks into the display context, rather than
having them as global state.  Add user-context parameter as well so
that users can distinguish between callbacks in different instances.

The default behaviour does not change, and LIBVA_MESSAGING_LEVEL
continues to be respected in that case.

Since we're breaking API here, also rename vaMessageCallback to
VAMessageCallback to be consistent with all other types.

Signed-off-by: Mark Thompson <sw@jkqxz.net>

6 files changed, 115 insertions, 79 deletions

diff --git a/va/va.c b/va/va.c
index 6378127..ffc0e31 100644
--- a/va/va.c
+++ b/va/va.c
@@ -52,9 +52,9 @@
 #define DRIVER_EXTENSION	"_drv_video.so"
 
 #define ASSERT		assert
-#define CHECK_VTABLE(s, ctx, func) if (!va_checkVtable(ctx->vtable->va##func, #func)) s = VA_STATUS_ERROR_UNKNOWN;
-#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;
+#define CHECK_VTABLE(s, ctx, func) if (!va_checkVtable(dpy, ctx->vtable->va##func, #func)) s = VA_STATUS_ERROR_UNKNOWN;
+#define CHECK_MAXIMUM(s, ctx, var) if (!va_checkMaximum(dpy, ctx->max_##var, #var)) s = VA_STATUS_ERROR_UNKNOWN;
+#define CHECK_STRING(s, ctx, var) if (!va_checkString(dpy, ctx->str_##var, #var)) s = VA_STATUS_ERROR_UNKNOWN;
 
 /*
  * read a config "env" for libva.conf or from environment setting
@@ -114,8 +114,17 @@ int vaDisplayIsValid(VADisplay dpy)
     return pDisplayContext && (pDisplayContext->vadpy_magic == VA_DISPLAY_MAGIC) && pDisplayContext->vaIsValid(pDisplayContext);
 }
 
-static void default_log_error(const char *buffer)
+/*
+ * Global log level configured from the config file or environment, which sets
+ * whether default logging appears or not (always overridden by explicitly
+ * user-configured logging).
+ */
+static int default_log_level = 2;
+
+static void default_log_error(void *user_context, const char *buffer)
 {
+    if (default_log_level < 1)
+        return;
 # ifdef ANDROID
     ALOGE("%s", buffer);
 # else
@@ -123,8 +132,10 @@ static void default_log_error(const char *buffer)
 # endif
 }
 
-static void default_log_info(const char *buffer)
+static void default_log_info(void *user_context, const char *buffer)
 {
+    if (default_log_level < 2)
+        return;
 # ifdef ANDROID
     ALOGI("%s", buffer);
 # else
@@ -132,17 +143,24 @@ static void default_log_info(const char *buffer)
 # endif
 }
 
-static vaMessageCallback va_log_error = default_log_error;
-static vaMessageCallback va_log_info = default_log_info;
-
 /**
  * Set the callback for error messages, or NULL for no logging.
  * Returns the previous one, or NULL if it was disabled.
  */
-vaMessageCallback vaSetErrorCallback(vaMessageCallback callback)
+VAMessageCallback vaSetErrorCallback(VADisplay dpy, VAMessageCallback callback, void *user_context)
 {
-    vaMessageCallback old_callback = va_log_error;
-    va_log_error = callback;
+    VADisplayContextP dctx;
+    VAMessageCallback old_callback;
+
+    if (!vaDisplayIsValid(dpy))
+        return NULL;
+
+    dctx = (VADisplayContextP)dpy;
+    old_callback = dctx->error_callback;
+
+    dctx->error_callback = callback;
+    dctx->error_callback_user_context = user_context;
+
     return old_callback;
 }
 
@@ -150,39 +168,46 @@ vaMessageCallback vaSetErrorCallback(vaMessageCallback callback)
  * Set the callback for info messages, or NULL for no logging.
  * Returns the previous one, or NULL if it was disabled.
  */
-vaMessageCallback vaSetInfoCallback(vaMessageCallback callback)
+VAMessageCallback vaSetInfoCallback(VADisplay dpy, VAMessageCallback callback, void *user_context)
 {
-    vaMessageCallback old_callback = va_log_info;
-    va_log_info = callback;
+    VADisplayContextP dctx;
+    VAMessageCallback old_callback;
+
+    if (!vaDisplayIsValid(dpy))
+        return NULL;
+
+    dctx = (VADisplayContextP)dpy;
+    old_callback = dctx->error_callback;
+
+    dctx->info_callback = callback;
+    dctx->info_callback_user_context = user_context;
+
     return old_callback;
 }
 
-void va_MessagingInit()
+static void va_MessagingInit()
 {
 #if ENABLE_VA_MESSAGING
     char env_value[1024];
+    int ret;
 
     if (va_parseConfig("LIBVA_MESSAGING_LEVEL", &env_value[0]) == 0) {
-        if (strcmp(env_value, "0") == 0) {
-            vaSetInfoCallback(NULL);
-            vaSetErrorCallback(NULL);
-        }
-
-        if (strcmp(env_value, "1") == 0) {
-            vaSetInfoCallback(NULL);
-        }
+        ret = sscanf(env_value, "%d", &default_log_level);
+        if (ret < 1 || default_log_level < 0 || default_log_level > 2)
+            default_log_level = 2;
     }
 #endif
 }
 
-void va_errorMessage(const char *msg, ...)
+void va_errorMessage(VADisplay dpy, const char *msg, ...)
 {
 #if ENABLE_VA_MESSAGING
+    VADisplayContextP dctx = (VADisplayContextP)dpy;
     char buf[512], *dynbuf;
     va_list args;
     int n, len;
 
-    if (va_log_error == NULL)
+    if (dctx->error_callback == NULL)
         return;
 
     va_start(args, msg);
@@ -197,22 +222,23 @@ void va_errorMessage(const char *msg, ...)
         n = vsnprintf(dynbuf, len + 1, msg, args);
         va_end(args);
         if (n == len)
-            va_log_error(dynbuf);
+            dctx->error_callback(dctx->error_callback_user_context, dynbuf);
         free(dynbuf);
     }
     else if (len > 0)
-        va_log_error(buf);
+        dctx->error_callback(dctx->error_callback_user_context, buf);
 #endif
 }
 
-void va_infoMessage(const char *msg, ...)
+void va_infoMessage(VADisplay dpy, const char *msg, ...)
 {
 #if ENABLE_VA_MESSAGING
+    VADisplayContextP dctx = (VADisplayContextP)dpy;
     char buf[512], *dynbuf;
     va_list args;
     int n, len;
 
-    if (va_log_info == NULL)
+    if (dctx->info_callback == NULL)
         return;
 
     va_start(args, msg);
@@ -227,11 +253,11 @@ void va_infoMessage(const char *msg, ...)
         n = vsnprintf(dynbuf, len + 1, msg, args);
         va_end(args);
         if (n == len)
-            va_log_info(dynbuf);
+            dctx->info_callback(dctx->info_callback_user_context, dynbuf);
         free(dynbuf);
     }
     else if (len > 0)
-        va_log_info(buf);
+        dctx->info_callback(dctx->info_callback_user_context, buf);
 #endif
 }
 
@@ -243,31 +269,34 @@ VADisplayContextP va_newDisplayContext(void)
 
     dctx->vadpy_magic = VA_DISPLAY_MAGIC;
 
+    dctx->error_callback = default_log_error;
+    dctx->info_callback  = default_log_info;
+
     return dctx;
 }
 
-static bool va_checkVtable(void *ptr, char *function)
+static bool va_checkVtable(VADisplay dpy, void *ptr, char *function)
 {
     if (!ptr) {
-        va_errorMessage("No valid vtable entry for va%s\n", function);
+        va_errorMessage(dpy, "No valid vtable entry for va%s\n", function);
         return false;
     }
     return true;
 }
 
-static bool va_checkMaximum(int value, char *variable)
+static bool va_checkMaximum(VADisplay dpy, int value, char *variable)
 {
     if (!value) {
-        va_errorMessage("Failed to define max_%s in init\n", variable);
+        va_errorMessage(dpy, "Failed to define max_%s in init\n", variable);
         return false;
     }
     return true;
 }
 
-static bool va_checkString(const char* value, char *variable)
+static bool va_checkString(VADisplay dpy, const char* value, char *variable)
 {
     if (!value) {
-        va_errorMessage("Failed to define str_%s in init\n", variable);
+        va_errorMessage(dpy, "Failed to define str_%s in init\n", variable);
         return false;
     }
     return true;
@@ -309,9 +338,9 @@ static VAStatus va_openDriver(VADisplay dpy, char *driver_name)
                                              strlen(driver_name) +
                                              strlen(DRIVER_EXTENSION) + 2 );
         if (!driver_path) {
-            va_errorMessage("%s L%d Out of memory!n",
-                                __FUNCTION__, __LINE__);
-            free(search_path);    
+            va_errorMessage(dpy, "%s L%d Out of memory!n",
+                            __FUNCTION__, __LINE__);
+            free(search_path);
             return VA_STATUS_ERROR_ALLOCATION_FAILED;
         }
 
@@ -320,7 +349,7 @@ static VAStatus va_openDriver(VADisplay dpy, char *driver_name)
         strncat( driver_path, driver_name, strlen(driver_name) );
         strncat( driver_path, DRIVER_EXTENSION, strlen(DRIVER_EXTENSION) );
         
-        va_infoMessage("Trying to open %s\n", driver_path);
+        va_infoMessage(dpy, "Trying to open %s\n", driver_path);
 #ifndef ANDROID
         handle = dlopen( driver_path, RTLD_NOW | RTLD_GLOBAL | RTLD_NODELETE );
 #else
@@ -329,7 +358,7 @@ static VAStatus va_openDriver(VADisplay dpy, char *driver_name)
         if (!handle) {
             /* Don't give errors for non-existing files */
             if (0 == access( driver_path, F_OK))
-                va_errorMessage("dlopen of %s failed: %s\n", driver_path, dlerror());
+                va_errorMessage(dpy, "dlopen of %s failed: %s\n", driver_path, dlerror());
         } else {
             VADriverInit init_func = NULL;
             char init_func_s[256];
@@ -349,14 +378,14 @@ static VAStatus va_openDriver(VADisplay dpy, char *driver_name)
                                          compatible_versions[i].minor)) {
                     init_func = (VADriverInit)dlsym(handle, init_func_s);
                     if (init_func) {
-                        va_infoMessage("Found init function %s\n", init_func_s);
+                        va_infoMessage(dpy, "Found init function %s\n", init_func_s);
                         break;
                     }
                 }
             }
 
             if (compatible_versions[i].major < 0) {
-                va_errorMessage("%s has no function %s\n",
+                va_errorMessage(dpy, "%s has no function %s\n",
                                 driver_path, init_func_s);
                 dlclose(handle);
             } else {
@@ -433,7 +462,7 @@ static VAStatus va_openDriver(VADisplay dpy, char *driver_name)
                     CHECK_VTABLE(vaStatus, ctx, SetDisplayAttributes);
                 }
                 if (VA_STATUS_SUCCESS != vaStatus) {
-                    va_errorMessage("%s init failed\n", driver_path);
+                    va_errorMessage(dpy, "%s init failed\n", driver_path);
                     dlclose(handle);
                 }
                 if (VA_STATUS_SUCCESS == vaStatus)
@@ -550,13 +579,13 @@ VAStatus vaSetDriverName(
 
     if (geteuid() != getuid()) {
         vaStatus = VA_STATUS_ERROR_OPERATION_FAILED;
-        va_errorMessage("no permission to vaSetDriverName\n");
+        va_errorMessage(dpy, "no permission to vaSetDriverName\n");
         return vaStatus;
     }
 
     if (strlen(driver_name) == 0 || strlen(driver_name) >=256) {
         vaStatus = VA_STATUS_ERROR_INVALID_PARAMETER;
-        va_errorMessage("vaSetDriverName returns %s\n",
+        va_errorMessage(dpy, "vaSetDriverName returns %s\n",
                          vaErrorStr(vaStatus));
         return vaStatus;
     }
@@ -573,7 +602,7 @@ VAStatus vaSetDriverName(
 
     if (!found) {
         vaStatus = VA_STATUS_ERROR_INVALID_PARAMETER;
-        va_errorMessage("vaSetDriverName returns %s. Incorrect parameter\n",
+        va_errorMessage(dpy, "vaSetDriverName returns %s. Incorrect parameter\n",
                          vaErrorStr(vaStatus));
         return vaStatus;
     }
@@ -582,7 +611,7 @@ VAStatus vaSetDriverName(
 
     if (!override_driver_name) {
         vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
-        va_errorMessage("vaSetDriverName returns %s. Out of Memory\n",
+        va_errorMessage(dpy, "vaSetDriverName returns %s. Out of Memory\n",
                          vaErrorStr(vaStatus));
         return vaStatus;
     }
@@ -612,12 +641,12 @@ VAStatus vaInitialize (
 
     va_MessagingInit();
 
-    va_infoMessage("VA-API version %s\n", VA_VERSION_S);
+    va_infoMessage(dpy, "VA-API version %s\n", VA_VERSION_S);
 
     vaStatus = va_getDriverName(dpy, &driver_name);
 
     if (!ctx->override_driver_name) {
-        va_infoMessage("va_getDriverName() returns %d\n", vaStatus);
+        va_infoMessage(dpy, "va_getDriverName() returns %d\n", vaStatus);
 
         driver_name_env = getenv("LIBVA_DRIVER_NAME");
     } else if (vaStatus == VA_STATUS_SUCCESS) {
@@ -627,11 +656,11 @@ VAStatus vaInitialize (
         driver_name = strdup(ctx->override_driver_name);
         if (!driver_name) {
             vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
-            va_errorMessage("vaInitialize() failed with %s, out of memory\n",
+            va_errorMessage(dpy, "vaInitialize() failed with %s, out of memory\n",
                         vaErrorStr(vaStatus));
             return vaStatus;
         }
-        va_infoMessage("User requested driver '%s'\n", driver_name);
+        va_infoMessage(dpy, "User requested driver '%s'\n", driver_name);
     }
 
     if (driver_name_env && (geteuid() == getuid())) {
@@ -641,17 +670,17 @@ VAStatus vaInitialize (
         
         driver_name = strdup(driver_name_env);
         vaStatus = VA_STATUS_SUCCESS;
-        va_infoMessage("User requested driver '%s'\n", driver_name);
+        va_infoMessage(dpy, "User requested driver '%s'\n", driver_name);
     }
 
     if ((VA_STATUS_SUCCESS == vaStatus) && (driver_name != NULL)) {
         vaStatus = va_openDriver(dpy, driver_name);
-        va_infoMessage("va_openDriver() returns %d\n", vaStatus);
+        va_infoMessage(dpy, "va_openDriver() returns %d\n", vaStatus);
 
         *major_version = VA_MAJOR_VERSION;
         *minor_version = VA_MINOR_VERSION;
     } else
-        va_errorMessage("va_getDriverName() failed with %s,driver_name=%s\n",
+        va_errorMessage(dpy, "va_getDriverName() failed with %s,driver_name=%s\n",
                         vaErrorStr(vaStatus), driver_name);
 
     if (driver_name)
diff --git a/va/va.h b/va/va.h
index 258b80f..9404c35 100644
--- a/va/va.h
+++ b/va/va.h
@@ -241,19 +241,19 @@ typedef struct _VAMotionVector {
 } VAMotionVector;
 
 /** Type of a message callback, used for both error and info log. */
-typedef void (*vaMessageCallback)(const char *message);
+typedef void (*VAMessageCallback)(void *user_context, const char *message);
 
 /**
  * Set the callback for error messages, or NULL for no logging.
  * Returns the previous one, or NULL if it was disabled.
  */
-vaMessageCallback vaSetErrorCallback(vaMessageCallback);
+VAMessageCallback vaSetErrorCallback(VADisplay dpy, VAMessageCallback callback, void *user_context);
 
 /**
  * Set the callback for info messages, or NULL for no logging.
  * Returns the previous one, or NULL if it was disabled.
  */
-vaMessageCallback vaSetInfoCallback(vaMessageCallback);
+VAMessageCallback vaSetInfoCallback(VADisplay dpy, VAMessageCallback callback, void *user_context);
 
 /**
  * Initialization:
diff --git a/va/va_backend.h b/va/va_backend.h
index 7ab52d2..4600d79 100644
--- a/va/va_backend.h
+++ b/va/va_backend.h
@@ -553,6 +553,11 @@ struct VADisplayContext
     void *opaque; /* opaque for display extensions (e.g. GLX) */
     void *vatrace; /* opaque for VA trace context */
     void *vafool; /* opaque for VA fool context */
+
+    VAMessageCallback error_callback;
+    void *error_callback_user_context;
+    VAMessageCallback info_callback;
+    void *info_callback_user_context;
 };
 
 typedef VAStatus (*VADriverInit) (
diff --git a/va/va_fool.c b/va/va_fool.c
index 0907f75..f74a0ef 100644
--- a/va/va_fool.c
+++ b/va/va_fool.c
@@ -115,23 +115,23 @@ void va_FoolInit(VADisplay dpy)
     
     if (va_parseConfig("LIBVA_FOOL_POSTP", NULL) == 0) {
         fool_postp = 1;
-        va_infoMessage("LIBVA_FOOL_POSTP is on, dummy vaPutSurface\n");
+        va_infoMessage(dpy, "LIBVA_FOOL_POSTP is on, dummy vaPutSurface\n");
     }
     
     if (va_parseConfig("LIBVA_FOOL_DECODE", NULL) == 0) {
         fool_codec  |= VA_FOOL_FLAG_DECODE;
-        va_infoMessage("LIBVA_FOOL_DECODE is on, dummy decode\n");
+        va_infoMessage(dpy, "LIBVA_FOOL_DECODE is on, dummy decode\n");
     }
     if (va_parseConfig("LIBVA_FOOL_ENCODE", &env_value[0]) == 0) {
         fool_codec  |= VA_FOOL_FLAG_ENCODE;
         fool_ctx->fn_enc = strdup(env_value);
-        va_infoMessage("LIBVA_FOOL_ENCODE is on, load encode data from file with patten %s\n",
+        va_infoMessage(dpy, "LIBVA_FOOL_ENCODE is on, load encode data from file with patten %s\n",
                        fool_ctx->fn_enc);
     }
     if (va_parseConfig("LIBVA_FOOL_JPEG", &env_value[0]) == 0) {
         fool_codec  |= VA_FOOL_FLAG_JPEG;
         fool_ctx->fn_jpg = strdup(env_value);
-        va_infoMessage("LIBVA_FOOL_JPEG is on, load encode data from file with patten %s\n",
+        va_infoMessage(dpy, "LIBVA_FOOL_JPEG is on, load encode data from file with patten %s\n",
                        fool_ctx->fn_jpg);
     }
     
@@ -200,9 +200,9 @@ int va_FoolCreateConfig(
             fool_ctx->enabled = 1;
     }
     if (fool_ctx->enabled)
-        va_infoMessage("FOOL is enabled for this context\n");
+        va_infoMessage(dpy, "FOOL is enabled for this context\n");
     else
-        va_infoMessage("FOOL is not enabled for this context\n");
+        va_infoMessage(dpy, "FOOL is not enabled for this context\n");
 
     
     return 0; /* continue */
diff --git a/va/va_internal.h b/va/va_internal.h
index b51c1e5..c666159 100644
--- a/va/va_internal.h
+++ b/va/va_internal.h
@@ -28,8 +28,8 @@
 #define CTX(dpy) (((VADisplayContextP)dpy)->pDriverContext)
 #define CHECK_DISPLAY(dpy) if( !vaDisplayIsValid(dpy) ) { return VA_STATUS_ERROR_INVALID_DISPLAY; }
 
-void va_errorMessage(const char *msg, ...);
-void va_infoMessage(const char *msg, ...);
+void va_errorMessage(VADisplay dpy, const char *msg, ...);
+void va_infoMessage(VADisplay dpy, const char *msg, ...);
 
 int  va_parseConfig(char *env, char *env_value);
 
diff --git a/va/va_trace.c b/va/va_trace.c
index 886708f..ff1769a 100755
--- a/va/va_trace.c
+++ b/va/va_trace.c
@@ -162,6 +162,7 @@ struct va_trace {
 
     pthread_mutex_t resource_mutex;
     pthread_mutex_t context_mutex;
+    VADisplay dpy;
 };
 
 #define LOCK_RESOURCE(pva_trace)                                    \
@@ -392,7 +393,7 @@ static void add_trace_buf_info(
     }
 
     if(i >= MAX_TRACE_BUF_INFO_HASH_LEVEL)
-        va_errorMessage("Add buf info failed\n");
+        va_errorMessage(pva_trace->dpy, "Add buf info failed\n");
 
     UNLOCK_RESOURCE(pva_trace);
 }
@@ -581,7 +582,7 @@ static int open_tracing_log_file(
     int new_fn_flag = 0;
 
     if(plog_file->used && plog_file->thread_id != thd_id) {
-        va_errorMessage("Try to open a busy log file occupied by other thread\n");
+        va_errorMessage(pva_trace->dpy, "Try to open a busy log file occupied by other thread\n");
 
         return -1;
     }
@@ -757,7 +758,7 @@ void va_TraceInit(VADisplay dpy)
     if ((trace_flag & VA_TRACE_FLAG_LOG) && (va_parseConfig("LIBVA_TRACE_BUFDATA", NULL) == 0)) {
         trace_flag |= VA_TRACE_FLAG_BUFDATA;
 
-        va_infoMessage("LIBVA_TRACE_BUFDATA is on, dump buffer into log file\n");
+        va_infoMessage(dpy, "LIBVA_TRACE_BUFDATA is on, dump buffer into log file\n");
     }
 
     /* per-context setting */
@@ -793,7 +794,7 @@ void va_TraceInit(VADisplay dpy)
             p = q+1; /* skip "+" */
             trace_ctx->trace_surface_yoff = strtod(p, &q);
 
-            va_infoMessage("LIBVA_TRACE_SURFACE_GEOMETRY is on, only dump surface %dx%d+%d+%d content\n",
+            va_infoMessage(dpy, "LIBVA_TRACE_SURFACE_GEOMETRY is on, only dump surface %dx%d+%d+%d content\n",
                            trace_ctx->trace_surface_width,
                            trace_ctx->trace_surface_height,
                            trace_ctx->trace_surface_xoff,
@@ -808,6 +809,7 @@ void va_TraceInit(VADisplay dpy)
     pva_trace->ptra_ctx[MAX_TRACE_CTX_NUM] = trace_ctx;
 
     ((VADisplayContextP)dpy)->vatrace = (void *)pva_trace;
+    pva_trace->dpy = dpy;
 
     if(!trace_flag)
         va_TraceEnd(dpy);
@@ -1291,7 +1293,7 @@ void va_TraceCreateContext(
     if(!context
         || *context == VA_INVALID_ID
         || !pva_trace) {
-        va_errorMessage("Invalid context id 0x%08x\n",
+        va_errorMessage(dpy, "Invalid context id 0x%08x\n",
                 context == NULL ? 0 : (int)*context);
         return;
     }
@@ -1300,7 +1302,7 @@ void va_TraceCreateContext(
 
     tra_ctx_id = get_free_ctx_idx(pva_trace, *context);
     if(tra_ctx_id >= MAX_TRACE_CTX_NUM) {
-        va_errorMessage("Can't get trace context for ctx 0x%08x\n",
+        va_errorMessage(dpy, "Can't get trace context for ctx 0x%08x\n",
                 *context);
         
         goto FAIL;
@@ -1308,7 +1310,7 @@ void va_TraceCreateContext(
 
     trace_ctx = calloc(sizeof(struct trace_context), 1);
     if(trace_ctx == NULL) {
-        va_errorMessage("Allocate trace context failed for ctx 0x%08x\n",
+        va_errorMessage(dpy, "Allocate trace context failed for ctx 0x%08x\n",
                 *context);
         
         goto FAIL;
@@ -1316,7 +1318,7 @@ void va_TraceCreateContext(
 
     i = get_valid_config_idx(pva_trace, config_id);
     if(i >= MAX_TRACE_CTX_NUM) {
-        va_errorMessage("Can't get trace config id for ctx 0x%08x cfg %x\n",
+        va_errorMessage(dpy, "Can't get trace config id for ctx 0x%08x cfg %x\n",
                 *context, config_id);
 
         goto FAIL;
@@ -1327,13 +1329,13 @@ void va_TraceCreateContext(
     if(trace_flag & VA_TRACE_FLAG_LOG) {
         trace_ctx->plog_file = start_tracing2log_file(pva_trace);
         if(!trace_ctx->plog_file) {
-            va_errorMessage("Can't get trace log file for ctx 0x%08x\n",
+            va_errorMessage(dpy, "Can't get trace log file for ctx 0x%08x\n",
                     *context);
 
             goto FAIL;
         }
         else
-            va_infoMessage("Save context 0x%08x into log file %s\n", *context,
+            va_infoMessage(dpy, "Save context 0x%08x into log file %s\n", *context,
                 trace_ctx->plog_file->fn_log);
 
         trace_ctx->plog_file_list[0] = trace_ctx->plog_file;
@@ -1373,7 +1375,7 @@ void va_TraceCreateContext(
         (decode && (trace_flag & VA_TRACE_FLAG_SURFACE_DECODE)) ||
         (jpeg && (trace_flag & VA_TRACE_FLAG_SURFACE_JPEG))) {
         if(open_tracing_specil_file(pva_trace, trace_ctx, 1) < 0) {
-            va_errorMessage("Open surface fail failed for ctx 0x%08x\n", *context);
+            va_errorMessage(dpy, "Open surface fail failed for ctx 0x%08x\n", *context);
 
             trace_flag &= ~(VA_TRACE_FLAG_SURFACE);
         }
@@ -1381,7 +1383,7 @@ void va_TraceCreateContext(
 
     if (encode && (trace_flag & VA_TRACE_FLAG_CODEDBUF)) {
         if(open_tracing_specil_file(pva_trace, trace_ctx, 0) < 0) {
-            va_errorMessage("Open codedbuf fail failed for ctx 0x%08x\n", *context);
+            va_errorMessage(dpy, "Open codedbuf fail failed for ctx 0x%08x\n", *context);
 
             trace_flag &= ~(VA_TRACE_FLAG_CODEDBUF);
         }