Namespace functions for multi-bitdepth builds so that libraries are self-contained.
--- a/common/param.cpp
+++ b/common/param.cpp
@@ -102,7 +102,7 @@ x265_param *x265_param_alloc()
 
 void x265_param_free(x265_param* p)
 {
-    x265_zone_free(p);
+    PARAM_NS::x265_zone_free(p);
 #ifdef SVT_HEVC
      x265_free(p->svtHevcParam);
 #endif
--- a/common/param.h
+++ b/common/param.h
@@ -55,6 +55,18 @@ int x265_param_apply_profile(x265_param *, const char *profile);
 int x265_param_parse(x265_param *p, const char *name, const char *value);
 int x265_scenecut_aware_qp_param_parse(x265_param* p, const char* name, const char* value);
 int x265_zone_param_parse(x265_param* p, const char* name, const char* value);
+void x265_free_analysis_data(x265_param *param, x265_analysis_data* analysis);
+void x265_alloc_analysis_data(x265_param *param, x265_analysis_data* analysis);
+void x265_picture_free(x265_picture *);
+x265_zone *x265_zone_alloc(int zoneCount, int isZoneFile);
+void x265_zone_free(x265_param *param);
+FILE* x265_csvlog_open(const x265_param *);
+void x265_csvlog_frame(const x265_param *, const x265_picture *);
+void x265_csvlog_encode(const x265_param*, const x265_stats *, int padx, int pady, int argc, char** argv);
+void x265_dither_image(x265_picture *, int picWidth, int picHeight, int16_t *errorBuf, int bitDepth);
+int x265_encoder_reconfig(x265_encoder *, x265_param *);
+x265_picture *x265_picture_alloc(void);
+void x265_picture_init(x265_param *param, x265_picture *pic);
 #define PARAM_NS X265_NS
 #endif
 }
--- a/common/threadpool.cpp
+++ b/common/threadpool.cpp
@@ -25,6 +25,7 @@
 #include "common.h"
 #include "threadpool.h"
 #include "threading.h"
+#include "param.h"
 
 #include <new>
 
@@ -314,7 +315,7 @@ ThreadPool* ThreadPool::allocThreadPools(x265_param* p, int& numPools, bool isTh
                    sprintf(nextCount, "%d", cpusPerNode[i]);
              strcat(poolString, nextCount);
          }
-         x265_param_parse(p, "pools", poolString);
+         PARAM_NS::x265_param_parse(p, "pools", poolString);
      }
 #endif
     if (p->numaPools && *p->numaPools)
--- a/encoder/api.cpp
+++ b/encoder/api.cpp
@@ -106,9 +106,9 @@ x265_encoder *x265_encoder_open(x265_param *p)
     if (p->rc.zoneCount || p->rc.zonefileCount)
     {
         int zoneCount = p->rc.zonefileCount ? p->rc.zonefileCount : p->rc.zoneCount;
-        param->rc.zones = x265_zone_alloc(zoneCount, !!p->rc.zonefileCount);
-        latestParam->rc.zones = x265_zone_alloc(zoneCount, !!p->rc.zonefileCount);
-        zoneParam->rc.zones = x265_zone_alloc(zoneCount, !!p->rc.zonefileCount);
+        param->rc.zones = PARAM_NS::x265_zone_alloc(zoneCount, !!p->rc.zonefileCount);
+        latestParam->rc.zones = PARAM_NS::x265_zone_alloc(zoneCount, !!p->rc.zonefileCount);
+        zoneParam->rc.zones = PARAM_NS::x265_zone_alloc(zoneCount, !!p->rc.zonefileCount);
     }
 
     x265_copy_params(param, p);
@@ -214,7 +214,7 @@ x265_encoder *x265_encoder_open(x265_param *p)
     /* Try to open CSV file handle */
     if (encoder->m_param->csvfn)
     {
-        encoder->m_param->csvfpt = x265_csvlog_open(encoder->m_param);
+        encoder->m_param->csvfpt = PARAM_NS::x265_csvlog_open(encoder->m_param);
         if (!encoder->m_param->csvfpt)
         {
             x265_log(encoder->m_param, X265_LOG_ERROR, "Unable to open CSV log file <%s>, aborting\n", encoder->m_param->csvfn);
@@ -319,7 +319,7 @@ int x265_encoder_reconfig(x265_encoder* enc, x265_param* param_in)
     if (encoder->m_latestParam->rc.zoneCount || encoder->m_latestParam->rc.zonefileCount)
     {
         int zoneCount = encoder->m_latestParam->rc.zonefileCount ? encoder->m_latestParam->rc.zonefileCount : encoder->m_latestParam->rc.zoneCount;
-        save.rc.zones = x265_zone_alloc(zoneCount, !!encoder->m_latestParam->rc.zonefileCount);
+        save.rc.zones = PARAM_NS::x265_zone_alloc(zoneCount, !!encoder->m_latestParam->rc.zonefileCount);
     }
     x265_copy_params(&save, encoder->m_latestParam);
     int ret = encoder->reconfigureParam(encoder->m_latestParam, param_in);
@@ -604,7 +604,7 @@ fail:
     if (numEncoded && encoder->m_param->csvLogLevel && encoder->m_outputCount >= encoder->m_latestParam->chunkStart)
     {
         for (int layer = 0; layer < encoder->m_param->numLayers; layer++)
-            x265_csvlog_frame(encoder->m_param, pic_out[layer]);
+            PARAM_NS::x265_csvlog_frame(encoder->m_param, pic_out[layer]);
     }
 
     if (numEncoded < 0)
@@ -646,7 +646,7 @@ void x265_vmaf_encoder_log(x265_encoder* enc, int argc, char **argv, x265_param
         encoder->fetchStats(&stats, sizeof(stats));
         int padx = encoder->m_sps.conformanceWindow.rightOffset;
         int pady = encoder->m_sps.conformanceWindow.bottomOffset;
-        x265_csvlog_encode(encoder->m_param, &stats, padx, pady, argc, argv);
+        PARAM_NS::x265_csvlog_encode(encoder->m_param, &stats, padx, pady, argc, argv);
     }
 }
 #endif
@@ -662,7 +662,7 @@ void x265_encoder_log(x265_encoder* enc, int argc, char **argv)
         for (int layer = 0; layer < encoder->m_param->numLayers; layer++)
         {
             encoder->fetchStats(stats, sizeof(stats[layer]), layer);
-            x265_csvlog_encode(encoder->m_param, &stats[0], padx, pady, argc, argv);
+            PARAM_NS::x265_csvlog_encode(encoder->m_param, &stats[0], padx, pady, argc, argv);
         }
     }
 }
@@ -884,7 +884,7 @@ void x265_alloc_analysis_data(x265_param *param, x265_analysis_data* analysis)
     return;
 
 fail:
-    x265_free_analysis_data(param, analysis);
+    PARAM_NS::x265_free_analysis_data(param, analysis);
 }
 
 void x265_free_analysis_data(x265_param *param, x265_analysis_data* analysis)
--- a/encoder/encoder.cpp
+++ b/encoder/encoder.cpp
@@ -217,8 +217,8 @@ void Encoder::create()
         {
             m_dupBuffer[i] = (AdaptiveFrameDuplication*)x265_malloc(sizeof(AdaptiveFrameDuplication));
             m_dupBuffer[i]->dupPic = NULL;
-            m_dupBuffer[i]->dupPic = x265_picture_alloc();
-            x265_picture_init(p, m_dupBuffer[i]->dupPic);
+            m_dupBuffer[i]->dupPic = PARAM_NS::x265_picture_alloc();
+            PARAM_NS::x265_picture_init(p, m_dupBuffer[i]->dupPic);
             m_dupBuffer[i]->dupPlane = NULL;
             m_dupBuffer[i]->dupPlane = X265_MALLOC(char, framesize);
             m_dupBuffer[i]->dupPic->planes[0] = m_dupBuffer[i]->dupPlane;
@@ -774,7 +774,7 @@ int Encoder::setAnalysisData(x265_analysis_data *analysis_data, int poc, uint32_
         curFrame->m_analysisData = (*analysis_data);
         curFrame->m_analysisData.numCUsInFrame = widthInCU * heightInCU;
         curFrame->m_analysisData.numPartitions = m_param->num4x4Partitions;
-        x265_alloc_analysis_data(m_param, &curFrame->m_analysisData);
+        PARAM_NS::x265_alloc_analysis_data(m_param, &curFrame->m_analysisData);
         if (m_param->maxCUSize == 16)
         {
             if (analysis_data->sliceType == X265_TYPE_IDR || analysis_data->sliceType == X265_TYPE_I)
@@ -881,7 +881,7 @@ void Encoder::destroy()
         for (uint32_t i = 0; i < DUP_BUFFER; i++)
         {
             X265_FREE(m_dupBuffer[i]->dupPlane);
-            x265_picture_free(m_dupBuffer[i]->dupPic);
+            PARAM_NS::x265_picture_free(m_dupBuffer[i]->dupPic);
             X265_FREE(m_dupBuffer[i]);
         }
 
@@ -1491,7 +1491,7 @@ int Encoder::encode(const x265_picture* pic_in, x265_picture** pic_out)
     if (*m_exportedPic)
     {
         if (!m_param->bUseAnalysisFile && m_param->analysisSave)
-            x265_free_analysis_data(m_param, &m_exportedPic[0]->m_analysisData);
+            PARAM_NS::x265_free_analysis_data(m_param, &m_exportedPic[0]->m_analysisData);
 
         for (int i = 0; i < m_param->numLayers; i++)
         {
@@ -1973,7 +1973,7 @@ int Encoder::encode(const x265_picture* pic_in, x265_picture** pic_out)
 
                 /* Free up inputPic->analysisData since it has already been used */
                 if ((m_param->analysisLoad && !m_param->analysisSave) || ((m_param->bAnalysisType == AVC_INFO) && slice->m_sliceType != I_SLICE))
-                    x265_free_analysis_data(m_param, &outFrame->m_analysisData);
+                    PARAM_NS::x265_free_analysis_data(m_param, &outFrame->m_analysisData);
                 if (pic_out[sLayer])
                 {
                     PicYuv* recpic = outFrame->m_reconPic[0];
@@ -2052,7 +2052,7 @@ int Encoder::encode(const x265_picture* pic_in, x265_picture** pic_out)
                         writeAnalysisFile(&pic_out[sLayer]->analysisData, *outFrame->m_encData);
                         pic_out[sLayer]->analysisData.saveParam = pic_out[sLayer]->analysisData.saveParam;
                         if (m_param->bUseAnalysisFile)
-                            x265_free_analysis_data(m_param, &pic_out[sLayer]->analysisData);
+                            PARAM_NS::x265_free_analysis_data(m_param, &pic_out[sLayer]->analysisData);
                     }
                 }
                 if (m_param->rc.bStatWrite && (m_param->analysisMultiPassRefine || m_param->analysisMultiPassDistortion))
@@ -2067,7 +2067,7 @@ int Encoder::encode(const x265_picture* pic_in, x265_picture** pic_out)
                     writeAnalysisFileRefine(&outFrame->m_analysisData, *outFrame->m_encData);
                 }
                 if (m_param->analysisMultiPassRefine || m_param->analysisMultiPassDistortion)
-                    x265_free_analysis_data(m_param, &outFrame->m_analysisData);
+                    PARAM_NS::x265_free_analysis_data(m_param, &outFrame->m_analysisData);
                 if (m_param->internalCsp == X265_CSP_I400)
                 {
                     if (slice->m_sliceType == P_SLICE)
@@ -2250,7 +2250,7 @@ int Encoder::encode(const x265_picture* pic_in, x265_picture** pic_out)
                 uint32_t heightInCU = (m_param->sourceHeight + m_param->maxCUSize - 1) >> m_param->maxLog2CUSize;
                 frameEnc[0]->m_analysisData.numCUsInFrame = widthInCU * heightInCU;
                 frameEnc[0]->m_analysisData.numPartitions = m_param->num4x4Partitions;
-                x265_alloc_analysis_data(m_param, &frameEnc[0]->m_analysisData);
+                PARAM_NS::x265_alloc_analysis_data(m_param, &frameEnc[0]->m_analysisData);
                 frameEnc[0]->m_analysisData.poc = frameEnc[0]->m_poc;
                 if (m_param->rc.bStatRead)
                     readAnalysisFile(&frameEnc[0]->m_analysisData, frameEnc[0]->m_poc, frameEnc[0]->m_lowres.sliceType);
@@ -2261,7 +2261,7 @@ int Encoder::encode(const x265_picture* pic_in, x265_picture** pic_out)
                 for (int i = 0; i < m_param->rc.zonefileCount; i++)
                 {
                     if (m_param->rc.zones[i].startFrame == frameEnc[0]->m_poc)
-                        x265_encoder_reconfig(this, m_param->rc.zones[i].zoneParam);
+                        PARAM_NS::x265_encoder_reconfig(this, m_param->rc.zones[i].zoneParam);
                 }
             }
 
@@ -2408,7 +2408,7 @@ int Encoder::encode(const x265_picture* pic_in, x265_picture** pic_out)
                 analysis->numCUsInFrame  = numCUsInFrame;
                 analysis->numCuInHeight = heightInCU;
                 analysis->numPartitions  = m_param->num4x4Partitions;
-                x265_alloc_analysis_data(m_param, analysis);
+                PARAM_NS::x265_alloc_analysis_data(m_param, analysis);
             }
             if (m_param->bEnableTemporalSubLayers > 2)
             {
@@ -4711,7 +4711,7 @@ void Encoder::readAnalysisFile(x265_analysis_data* analysis, int curPoc, const x
         else if (fread(val, size, readSize, fileOffset) != readSize)\
     {\
         x265_log(NULL, X265_LOG_ERROR, "Error reading analysis data\n");\
-        x265_free_analysis_data(m_param, analysis);\
+        PARAM_NS::x265_free_analysis_data(m_param, analysis);\
         m_aborted = true;\
         return;\
     }\
@@ -4747,7 +4747,7 @@ void Encoder::readAnalysisFile(x265_analysis_data* analysis, int curPoc, const x
         if (poc != curPoc || feof(m_analysisFileIn))
         {
             x265_log(NULL, X265_LOG_WARNING, "Error reading analysis data: Cannot find POC %d\n", curPoc);
-            x265_free_analysis_data(m_param, analysis);
+            PARAM_NS::x265_free_analysis_data(m_param, analysis);
             return;
         }
     }
@@ -4781,7 +4781,7 @@ void Encoder::readAnalysisFile(x265_analysis_data* analysis, int curPoc, const x
     if (m_param->scaleFactor)
         analysis->numPartitions *= factor;
     /* Memory is allocated for inter and intra analysis data based on the slicetype */
-    x265_alloc_analysis_data(m_param, analysis);
+    PARAM_NS::x265_alloc_analysis_data(m_param, analysis);
 
     if (m_param->ctuDistortionRefine == CTU_DISTORTION_INTERNAL)
     {
@@ -5034,7 +5034,7 @@ void Encoder::readAnalysisFile(x265_analysis_data* analysis, int curPoc, const x
     else if (fread(val, size, readSize, fileOffset) != readSize)\
     {\
         x265_log(NULL, X265_LOG_ERROR, "Error reading analysis data\n");\
-        x265_free_analysis_data(m_param, analysis);\
+        PARAM_NS::x265_free_analysis_data(m_param, analysis);\
         m_aborted = true;\
         return;\
     }\
@@ -5071,7 +5071,7 @@ void Encoder::readAnalysisFile(x265_analysis_data* analysis, int curPoc, const x
         if (poc != curPoc || feof(m_analysisFileIn))
         {
             x265_log(NULL, X265_LOG_WARNING, "Error reading analysis data: Cannot find POC %d\n", curPoc);
-            x265_free_analysis_data(m_param, analysis);
+            PARAM_NS::x265_free_analysis_data(m_param, analysis);
             return;
         }
     }
@@ -5102,7 +5102,7 @@ void Encoder::readAnalysisFile(x265_analysis_data* analysis, int curPoc, const x
     analysis->numCuInHeight = cuLoc.heightInCU;
 
     /* Memory is allocated for inter and intra analysis data based on the slicetype */
-    x265_alloc_analysis_data(m_param, analysis);
+    PARAM_NS::x265_alloc_analysis_data(m_param, analysis);
 
     if (m_param->ctuDistortionRefine == CTU_DISTORTION_INTERNAL)
     {
@@ -5717,7 +5717,7 @@ void Encoder::readAnalysisFile(x265_analysis_data* analysis, int curPoc, int sli
     if (fread(val, size, readSize, fileOffset) != readSize)\
     {\
     x265_log(NULL, X265_LOG_ERROR, "Error reading analysis 2 pass data\n"); \
-    x265_alloc_analysis_data(m_param, analysis); \
+    PARAM_NS::x265_alloc_analysis_data(m_param, analysis); \
     m_aborted = true; \
     return; \
 }\
@@ -5731,7 +5731,7 @@ void Encoder::readAnalysisFile(x265_analysis_data* analysis, int curPoc, int sli
     if (poc != curPoc || feof(m_analysisFileIn))
     {
         x265_log(NULL, X265_LOG_WARNING, "Error reading analysis 2 pass data: Cannot find POC %d\n", curPoc);
-        x265_free_analysis_data(m_param, analysis);
+        PARAM_NS::x265_free_analysis_data(m_param, analysis);
         return;
     }
     /* Now arrived at the right frame, read the record */
@@ -5838,7 +5838,7 @@ void Encoder::writeAnalysisFile(x265_analysis_data* analysis, FrameData &curEncD
     if (fwrite(val, size, writeSize, fileOffset) < writeSize)\
     {\
         x265_log(NULL, X265_LOG_ERROR, "Error writing analysis data\n");\
-        x265_free_analysis_data(m_param, analysis);\
+        PARAM_NS::x265_free_analysis_data(m_param, analysis);\
         m_aborted = true;\
         return;\
     }\
@@ -6060,7 +6060,7 @@ void Encoder::writeAnalysisFileRefine(x265_analysis_data* analysis, FrameData &c
     if (fwrite(val, size, writeSize, fileOffset) < writeSize)\
     {\
     x265_log(NULL, X265_LOG_ERROR, "Error writing analysis 2 pass data\n"); \
-    x265_free_analysis_data(m_param, analysis); \
+    PARAM_NS::x265_free_analysis_data(m_param, analysis); \
     m_aborted = true; \
     return; \
 }\