Add namespace prefix to globals

Add "va_" prefix to trace_flag, fool_codec and fool_postp to avoid
polluting the global namespace.

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

6 files changed, 43 insertions, 43 deletions

diff --git a/va/android/va_android.cpp b/va/android/va_android.cpp
index 31b4453..ab54684 100644
--- a/va/android/va_android.cpp
+++ b/va/android/va_android.cpp
@@ -166,8 +166,8 @@ VADisplay vaGetDisplay (
 
 
 extern "C"  {
-    extern int fool_postp; /* do nothing for vaPutSurface if set */
-    extern int trace_flag; /* trace vaPutSurface parameters */
+    extern int va_fool_postp; /* do nothing for vaPutSurface if set */
+    extern int va_trace_flag; /* trace vaPutSurface parameters */
 
     void va_TracePutSurface (
         VADisplay dpy,
diff --git a/va/va_fool.c b/va/va_fool.c
index f74a0ef..5218404 100644
--- a/va/va_fool.c
+++ b/va/va_fool.c
@@ -62,14 +62,14 @@
 
 
 /* global settings */
-int fool_codec = 0;
-int fool_postp  = 0;
+int va_fool_codec = 0;
+int va_fool_postp  = 0;
 
 #define FOOL_BUFID_MAGIC   0x12345600
 #define FOOL_BUFID_MASK    0xffffff00
 
 struct fool_context {
-    int enabled; /* fool_codec is global, and it is for concurent encode/decode */
+    int enabled; /* va_fool_codec is global, and it is for concurent encode/decode */
     char *fn_enc;/* file pattern with codedbuf content for encode */
     char *segbuf_enc; /* the segment buffer of coded buffer, load frome fn_enc */
     int file_count;
@@ -114,22 +114,22 @@ void va_FoolInit(VADisplay dpy)
         return;
     
     if (va_parseConfig("LIBVA_FOOL_POSTP", NULL) == 0) {
-        fool_postp = 1;
+        va_fool_postp = 1;
         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_fool_codec  |= VA_FOOL_FLAG_DECODE;
         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;
+        va_fool_codec  |= VA_FOOL_FLAG_ENCODE;
         fool_ctx->fn_enc = strdup(env_value);
         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;
+        va_fool_codec  |= VA_FOOL_FLAG_JPEG;
         fool_ctx->fn_jpg = strdup(env_value);
         va_infoMessage(dpy, "LIBVA_FOOL_JPEG is on, load encode data from file with patten %s\n",
                        fool_ctx->fn_jpg);
@@ -177,15 +177,15 @@ int va_FoolCreateConfig(
     fool_ctx->entrypoint = entrypoint;
     
     /*
-     * check fool_codec to align with current context
-     * e.g. fool_codec = decode then for encode, the
+     * check va_fool_codec to align with current context
+     * e.g. va_fool_codec = decode then for encode, the
      * vaBegin/vaRender/vaEnd also run into fool path
      * which is not desired
      */
-    if (((fool_codec & VA_FOOL_FLAG_DECODE) && (entrypoint == VAEntrypointVLD)) ||
-        ((fool_codec & VA_FOOL_FLAG_JPEG) && (entrypoint == VAEntrypointEncPicture)))
+    if (((va_fool_codec & VA_FOOL_FLAG_DECODE) && (entrypoint == VAEntrypointVLD)) ||
+        ((va_fool_codec & VA_FOOL_FLAG_JPEG) && (entrypoint == VAEntrypointEncPicture)))
         fool_ctx->enabled = 1;
-    else if ((fool_codec & VA_FOOL_FLAG_ENCODE) && (entrypoint == VAEntrypointEncSlice)) {
+    else if ((va_fool_codec & VA_FOOL_FLAG_ENCODE) && (entrypoint == VAEntrypointEncSlice)) {
         /* H264 is desired */
         if (((profile == VAProfileH264Baseline ||
               profile == VAProfileH264Main ||
diff --git a/va/va_fool.h b/va/va_fool.h
index 6f4f917..23b0fc0 100644
--- a/va/va_fool.h
+++ b/va/va_fool.h
@@ -32,15 +32,15 @@
 extern "C" {
 #endif
 
-extern int fool_codec;
-extern int fool_postp;
+extern int va_fool_codec;
+extern int va_fool_postp;
 
 #define VA_FOOL_FLAG_DECODE  0x1
 #define VA_FOOL_FLAG_ENCODE  0x2
 #define VA_FOOL_FLAG_JPEG    0x4
 
 #define VA_FOOL_FUNC(fool_func,...)            \
-    if (fool_codec) {                          \
+    if (va_fool_codec) {                       \
         if (fool_func(__VA_ARGS__))            \
             return VA_STATUS_SUCCESS;          \
     }
diff --git a/va/va_trace.c b/va/va_trace.c
index 873b297..78d920a 100755
--- a/va/va_trace.c
+++ b/va/va_trace.c
@@ -67,7 +67,7 @@
 /* global settings */
 
 /* LIBVA_TRACE */
-int trace_flag = 0;
+int va_trace_flag = 0;
 
 #define MAX_TRACE_CTX_NUM   64
 #define TRACE_CTX_ID_MASK      (MAX_TRACE_CTX_NUM - 1)
@@ -745,7 +745,7 @@ void va_TraceInit(VADisplay dpy)
         trace_ctx->plog_file = start_tracing2log_file(pva_trace);
         if(trace_ctx->plog_file) {
             trace_ctx->plog_file_list[0] = trace_ctx->plog_file;
-            trace_flag = VA_TRACE_FLAG_LOG;
+            va_trace_flag = VA_TRACE_FLAG_LOG;
 
             va_infoMessage("LIBVA_TRACE is on, save log into %s\n",
                 trace_ctx->plog_file->fn_log);
@@ -755,8 +755,8 @@ void va_TraceInit(VADisplay dpy)
     }
 
     /* may re-get the global settings for multiple context */
-    if ((trace_flag & VA_TRACE_FLAG_LOG) && (va_parseConfig("LIBVA_TRACE_BUFDATA", NULL) == 0)) {
-        trace_flag |= VA_TRACE_FLAG_BUFDATA;
+    if ((va_trace_flag & VA_TRACE_FLAG_LOG) && (va_parseConfig("LIBVA_TRACE_BUFDATA", NULL) == 0)) {
+        va_trace_flag |= VA_TRACE_FLAG_BUFDATA;
 
         va_infoMessage(dpy, "LIBVA_TRACE_BUFDATA is on, dump buffer into log file\n");
     }
@@ -764,7 +764,7 @@ void va_TraceInit(VADisplay dpy)
     /* per-context setting */
     if (va_parseConfig("LIBVA_TRACE_CODEDBUF", &env_value[0]) == 0) {
         pva_trace->fn_codedbuf_env = strdup(env_value);
-        trace_flag |= VA_TRACE_FLAG_CODEDBUF;
+        va_trace_flag |= VA_TRACE_FLAG_CODEDBUF;
     }
 
     if (va_parseConfig("LIBVA_TRACE_SURFACE", &env_value[0]) == 0) {
@@ -777,11 +777,11 @@ void va_TraceInit(VADisplay dpy)
          * if no dec/enc in file name, set both
          */
         if (strstr(env_value, "dec"))
-            trace_flag |= VA_TRACE_FLAG_SURFACE_DECODE;
+            va_trace_flag |= VA_TRACE_FLAG_SURFACE_DECODE;
         if (strstr(env_value, "enc"))
-            trace_flag |= VA_TRACE_FLAG_SURFACE_ENCODE;
+            va_trace_flag |= VA_TRACE_FLAG_SURFACE_ENCODE;
         if (strstr(env_value, "jpeg") || strstr(env_value, "jpg"))
-            trace_flag |= VA_TRACE_FLAG_SURFACE_JPEG;
+            va_trace_flag |= VA_TRACE_FLAG_SURFACE_JPEG;
 
         if (va_parseConfig("LIBVA_TRACE_SURFACE_GEOMETRY", &env_value[0]) == 0) {
             char *p = env_value, *q;
@@ -811,7 +811,7 @@ void va_TraceInit(VADisplay dpy)
     ((VADisplayContextP)dpy)->vatrace = (void *)pva_trace;
     pva_trace->dpy = dpy;
 
-    if(!trace_flag)
+    if(!va_trace_flag)
         va_TraceEnd(dpy);
 }
 
@@ -889,7 +889,7 @@ static void va_TraceVPrint(struct trace_context *trace_ctx, const char *msg, va_
 {
     FILE *fp = NULL;
 
-    if (!(trace_flag & VA_TRACE_FLAG_LOG)
+    if (!(va_trace_flag & VA_TRACE_FLAG_LOG)
         || !trace_ctx->plog_file)
         return;
 
@@ -1326,7 +1326,7 @@ void va_TraceCreateContext(
     trace_ctx->trace_profile = pva_trace->config_info[i].trace_profile;
     trace_ctx->trace_entrypoint = pva_trace->config_info[i].trace_entrypoint;
 
-    if(trace_flag & VA_TRACE_FLAG_LOG) {
+    if(va_trace_flag & VA_TRACE_FLAG_LOG) {
         trace_ctx->plog_file = start_tracing2log_file(pva_trace);
         if(!trace_ctx->plog_file) {
             va_errorMessage(dpy, "Can't get trace log file for ctx 0x%08x\n",
@@ -1343,7 +1343,7 @@ void va_TraceCreateContext(
 
     trace_ctx->trace_context = *context;
     TRACE_FUNCNAME(idx);
-    va_TraceMsg(trace_ctx, "\tcontext = 0x%08x trace_flag 0x%x\n", *context, trace_flag);
+    va_TraceMsg(trace_ctx, "\tcontext = 0x%08x va_trace_flag 0x%x\n", *context, va_trace_flag);
     va_TraceMsg(trace_ctx, "\tprofile = %d entrypoint = %d\n", trace_ctx->trace_profile,
         trace_ctx->trace_entrypoint);
     va_TraceMsg(trace_ctx, "\tconfig = 0x%08x\n", config_id);
@@ -1371,21 +1371,21 @@ void va_TraceCreateContext(
     encode = (trace_ctx->trace_entrypoint == VAEntrypointEncSlice);
     decode = (trace_ctx->trace_entrypoint == VAEntrypointVLD);
     jpeg = (trace_ctx->trace_entrypoint == VAEntrypointEncPicture);
-    if ((encode && (trace_flag & VA_TRACE_FLAG_SURFACE_ENCODE)) ||
-        (decode && (trace_flag & VA_TRACE_FLAG_SURFACE_DECODE)) ||
-        (jpeg && (trace_flag & VA_TRACE_FLAG_SURFACE_JPEG))) {
+    if ((encode && (va_trace_flag & VA_TRACE_FLAG_SURFACE_ENCODE)) ||
+        (decode && (va_trace_flag & VA_TRACE_FLAG_SURFACE_DECODE)) ||
+        (jpeg && (va_trace_flag & VA_TRACE_FLAG_SURFACE_JPEG))) {
         if(open_tracing_specil_file(pva_trace, trace_ctx, 1) < 0) {
             va_errorMessage(dpy, "Open surface fail failed for ctx 0x%08x\n", *context);
 
-            trace_flag &= ~(VA_TRACE_FLAG_SURFACE);
+            va_trace_flag &= ~(VA_TRACE_FLAG_SURFACE);
         }
     }
 
-    if (encode && (trace_flag & VA_TRACE_FLAG_CODEDBUF)) {
+    if (encode && (va_trace_flag & VA_TRACE_FLAG_CODEDBUF)) {
         if(open_tracing_specil_file(pva_trace, trace_ctx, 0) < 0) {
             va_errorMessage(dpy, "Open codedbuf fail failed for ctx 0x%08x\n", *context);
 
-            trace_flag &= ~(VA_TRACE_FLAG_CODEDBUF);
+            va_trace_flag &= ~(VA_TRACE_FLAG_CODEDBUF);
         }
     }
 
@@ -1658,7 +1658,7 @@ static void va_TraceVABuffers(
     if(trace_ctx->plog_file)
         fp = trace_ctx->plog_file->fp_log;
 
-    if ((trace_flag & VA_TRACE_FLAG_BUFDATA) && fp) {
+    if ((va_trace_flag & VA_TRACE_FLAG_BUFDATA) && fp) {
         for (i=0; i<size; i++) {
             unsigned char value =  p[i];
 
@@ -4886,12 +4886,12 @@ void va_TraceEndPicture(
     jpeg = (trace_ctx->trace_entrypoint == VAEntrypointEncPicture);
 
     /* trace encode source surface, can do it before HW completes rendering */
-    if ((encode && (trace_flag & VA_TRACE_FLAG_SURFACE_ENCODE))||
-        (jpeg && (trace_flag & VA_TRACE_FLAG_SURFACE_JPEG)))
+    if ((encode && (va_trace_flag & VA_TRACE_FLAG_SURFACE_ENCODE))||
+        (jpeg && (va_trace_flag & VA_TRACE_FLAG_SURFACE_JPEG)))
         va_TraceSurface(dpy, context);
     
     /* trace decoded surface, do it after HW completes rendering */
-    if (decode && ((trace_flag & VA_TRACE_FLAG_SURFACE_DECODE))) {
+    if (decode && ((va_trace_flag & VA_TRACE_FLAG_SURFACE_DECODE))) {
         vaSyncSurface(dpy, trace_ctx->trace_rendertarget);
         va_TraceSurface(dpy, context);
     }
diff --git a/va/va_trace.h b/va/va_trace.h
index 5b320c6..3b0d4a2 100644
--- a/va/va_trace.h
+++ b/va/va_trace.h
@@ -29,7 +29,7 @@
 extern "C" {
 #endif
 
-extern int trace_flag;
+extern int va_trace_flag;
 
 #define VA_TRACE_FLAG_LOG             0x1
 #define VA_TRACE_FLAG_BUFDATA         0x2
@@ -42,11 +42,11 @@ extern int trace_flag;
                                        VA_TRACE_FLAG_SURFACE_JPEG)
 
 #define VA_TRACE_LOG(trace_func,...)            \
-    if (trace_flag & VA_TRACE_FLAG_LOG) {       \
+    if (va_trace_flag & VA_TRACE_FLAG_LOG) {    \
         trace_func(__VA_ARGS__);                \
     }
 #define VA_TRACE_ALL(trace_func,...)            \
-    if (trace_flag) {                           \
+    if (va_trace_flag) {                        \
         trace_func(__VA_ARGS__);                \
     }
 
diff --git a/va/x11/va_x11.c b/va/x11/va_x11.c
index b5fe6e9..fa41cab 100644
--- a/va/x11/va_x11.c
+++ b/va/x11/va_x11.c
@@ -232,7 +232,7 @@ VAStatus vaPutSurface (
 {
   VADriverContextP ctx;
 
-  if (fool_postp)
+  if (va_fool_postp)
       return VA_STATUS_SUCCESS;
 
   CHECK_DISPLAY(dpy);