building x265 2.6, sqrt error (C2668) Visual Studio 2010

[FranceBB]

Hi,
I tried to compile x265 using Visual Studio 2010 Express on my Windows XP x86. Cmake and yasm are installed and working fine, it creates solutions but then fails to compile with two C2668 errors on encoder.cpp (encoder.vcxproj). 'sqrt' : ambiguous call to overloaded function.
I opened encoder.vcproj, encoder.cpp and checked line 578 and 661 involving sqrt.
The first one refers to setAnalysisDataAfterZScan in which I think that the compiler doesn't know how to convert this double:

double mv = sqrt(mv_x*mv_x + mv_y*mv_y);


int Encoder::setAnalysisDataAfterZScan(x265_analysis_data *analysis_data, Frame* curFrame)
{
int mbImageWidth, mbImageHeight;
mbImageWidth = (curFrame->m_fencPic->m_picWidth + 16 - 1) >> 4; //AVC block sizes
mbImageHeight = (curFrame->m_fencPic->m_picHeight + 16 - 1) >> 4;
if (analysis_data->sliceType == X265_TYPE_IDR || analysis_data->sliceType == X265_TYPE_I)
{
curFrame->m_analysisData.sliceType = X265_TYPE_I;
if (m_param->analysisReuseLevel < 7)
return -1;
curFrame->m_analysisData.numPartitions = m_param->num4x4Partitions;
int num16x16inCUWidth = m_param->maxCUSize >> 4;
uint32_t ctuAddr, offset, cuPos;
analysis_intra_data * intraData = (analysis_intra_data *)curFrame->m_analysisData.intraData;
analysis_intra_data * srcIntraData = (analysis_intra_data *)analysis_data->intraData;
for (int i = 0; i < mbImageHeight; i++)
{
for (int j = 0; j < mbImageWidth; j++)
{
int mbIndex = j + i * mbImageWidth;
ctuAddr = (j / num16x16inCUWidth + ((i / num16x16inCUWidth) * (mbImageWidth / num16x16inCUWidth)));
offset = ((i % num16x16inCUWidth) << 5) + ((j % num16x16inCUWidth) << 4);
if ((j % 4 >= 2) && m_param->maxCUSize == 64)
offset += (2 * 16);
if ((i % 4 >= 2) && m_param->maxCUSize == 64)
offset += (2 * 32);
cuPos = ctuAddr * curFrame->m_analysisData.numPartitions + offset;
memcpy(&(intraData)->depth[cuPos], &(srcIntraData)->depth[mbIndex * 16], 16);
memcpy(&(intraData)->chromaModes[cuPos], &(srcIntraData)->chromaModes[mbIndex * 16], 16);
memcpy(&(intraData)->partSizes[cuPos], &(srcIntraData)->partSizes[mbIndex * 16], 16);
memcpy(&(intraData)->partSizes[cuPos], &(srcIntraData)->partSizes[mbIndex * 16], 16);
}
}
memcpy(&(intraData)->modes, (srcIntraData)->modes, curFrame->m_analysisData.numPartitions * analysis_data->numCUsInFrame);
}
else
{
uint32_t numDir = analysis_data->sliceType == X265_TYPE_P ? 1 : 2;
if (m_param->analysisReuseLevel < 7)
return -1;
curFrame->m_analysisData.numPartitions = m_param->num4x4Partitions;
int num16x16inCUWidth = m_param->maxCUSize >> 4;
uint32_t ctuAddr, offset, cuPos;
analysis_inter_data * interData = (analysis_inter_data *)curFrame->m_analysisData.interData;
analysis_inter_data * srcInterData = (analysis_inter_data*)analysis_data->interData;
for (int i = 0; i < mbImageHeight; i++)
{
for (int j = 0; j < mbImageWidth; j++)
{
int mbIndex = j + i * mbImageWidth;
ctuAddr = (j / num16x16inCUWidth + ((i / num16x16inCUWidth) * (mbImageWidth / num16x16inCUWidth)));
offset = ((i % num16x16inCUWidth) << 5) + ((j % num16x16inCUWidth) << 4);
if ((j % 4 >= 2) && m_param->maxCUSize == 64)
offset += (2 * 16);
if ((i % 4 >= 2) && m_param->maxCUSize == 64)
offset += (2 * 32);
cuPos = ctuAddr * curFrame->m_analysisData.numPartitions + offset;
memcpy(&(interData)->depth[cuPos], &(srcInterData)->depth[mbIndex * 16], 16);
memcpy(&(interData)->modes[cuPos], &(srcInterData)->modes[mbIndex * 16], 16);

memcpy(&(interData)->partSize[cuPos], &(srcInterData)->partSize[mbIndex * 16], 16);

int bytes = curFrame->m_analysisData.numPartitions >> ((srcInterData)->depth[mbIndex * 16] * 2);
int cuCount = 1;
if (bytes < 16)
cuCount = 4;
for (int cuI = 0; cuI < cuCount; cuI++)
{
int numPU = nbPartsTable[(srcInterData)->partSize[mbIndex * 16 + cuI * bytes]];
for (int pu = 0; pu < numPU; pu++)
{
int cuOffset = cuI * bytes + pu;
(interData)->mergeFlag[cuPos + cuOffset] = (srcInterData)->mergeFlag[(mbIndex * 16) + cuOffset];

(interData)->interDir[cuPos + cuOffset] = (srcInterData)->interDir[(mbIndex * 16) + cuOffset];
for (uint32_t k = 0; k < numDir; k++)
{
(interData)->mvpIdx[k][cuPos + cuOffset] = (srcInterData)->mvpIdx[k][(mbIndex * 16) + cuOffset];
(interData)->refIdx[k][cuPos + cuOffset] = (srcInterData)->refIdx[k][(mbIndex * 16) + cuOffset];
memcpy(&(interData)->mv[k][cuPos + cuOffset], &(srcInterData)->mv[k][(mbIndex * 16) + cuOffset], sizeof(MV));
if (m_param->analysisReuseLevel == 7)
{
int mv_x = ((analysis_inter_data *)curFrame->m_analysisData.interData)->mv[k][(mbIndex * 16) + cuOffset].x;
int mv_y = ((analysis_inter_data *)curFrame->m_analysisData.interData)->mv[k][(mbIndex * 16) + cuOffset].y;
double mv = sqrt(mv_x*mv_x + mv_y*mv_y);
if (numPU == PU_2Nx2N && ((srcInterData)->depth[cuPos + cuOffset] == (m_param->maxCUSize >> 5)) && mv <= MVTHRESHOLD)
memset(&curFrame->m_analysisData.modeFlag[k][cuPos + cuOffset], 1, bytes);
}
}
}
}
}
}
}
return 0;
}



The second one refers to setAnalysisData in which I think that the compiler doesn't know how to convert this double:

double mv = sqrt(mv_x*mv_x + mv_y*mv_y);


int Encoder::setAnalysisData(x265_analysis_data *analysis_data, int poc, uint32_t cuBytes)
{
uint32_t widthInCU = (m_param->sourceWidth + m_param->maxCUSize - 1) >> m_param->maxLog2CUSize;
uint32_t heightInCU = (m_param->sourceHeight + m_param->maxCUSize - 1) >> m_param->maxLog2CUSize;

Frame* curFrame = m_dpb->m_picList.getPOC(poc);
if (curFrame != NULL)
{
curFrame->m_analysisData = (*analysis_data);
curFrame->m_analysisData.numCUsInFrame = widthInCU * heightInCU;
curFrame->m_analysisData.numPartitions = m_param->num4x4Partitions;
allocAnalysis(&curFrame->m_analysisData);
if (m_param->maxCUSize == 16)
{
if (analysis_data->sliceType == X265_TYPE_IDR || analysis_data->sliceType == X265_TYPE_I)
{
curFrame->m_analysisData.sliceType = X265_TYPE_I;
if (m_param->analysisReuseLevel < 2)
return -1;

curFrame->m_analysisData.numPartitions = m_param->num4x4Partitions;
size_t count = 0;
analysis_intra_data * currIntraData = (analysis_intra_data *)curFrame->m_analysisData.intraData;
analysis_intra_data * intraData = (analysis_intra_data *)analysis_data->intraData;
for (uint32_t d = 0; d < cuBytes; d++)
{
int bytes = curFrame->m_analysisData.numPartitions >> ((intraData)->depth[d] * 2);
memset(&(currIntraData)->depth[count], (intraData)->depth[d], bytes);
memset(&(currIntraData)->chromaModes[count], (intraData)->chromaModes[d], bytes);
memset(&(currIntraData)->partSizes[count], (intraData)->partSizes[d], bytes);
memset(&(currIntraData)->partSizes[count], (intraData)->partSizes[d], bytes);
count += bytes;
}
memcpy(&(currIntraData)->modes, (intraData)->modes, curFrame->m_analysisData.numPartitions * analysis_data->numCUsInFrame);
}
else
{
uint32_t numDir = analysis_data->sliceType == X265_TYPE_P ? 1 : 2;
if (m_param->analysisReuseLevel < 2)
return -1;

curFrame->m_analysisData.numPartitions = m_param->num4x4Partitions;
size_t count = 0;
analysis_inter_data * currInterData = (analysis_inter_data *)curFrame->m_analysisData.interData;
analysis_inter_data * interData = (analysis_inter_data *)analysis_data->interData;
for (uint32_t d = 0; d < cuBytes; d++)
{
int bytes = curFrame->m_analysisData.numPartitions >> ((interData)->depth[d] * 2);
memset(&(currInterData)->depth[count], (interData)->depth[d], bytes);
memset(&(currInterData)->modes[count], (interData)->modes[d], bytes);
memcpy(&(currInterData)->sadCost[count], &((analysis_inter_data*)analysis_data->interData)->sadCost[d], bytes);
if (m_param->analysisReuseLevel > 4)
{
memset(&(currInterData)->partSize[count], (interData)->partSize[d], bytes);
int numPU = nbPartsTable[(currInterData)->partSize[d]];
for (int pu = 0; pu < numPU; pu++, d++)
{
(currInterData)->mergeFlag[count + pu] = (interData)->mergeFlag[d];
if (m_param->analysisReuseLevel >= 7)
{
(currInterData)->interDir[count + pu] = (interData)->interDir[d];
for (uint32_t i = 0; i < numDir; i++)
{
(currInterData)->mvpIdx[i][count + pu] = (interData)->mvpIdx[i][d];
(currInterData)->refIdx[i][count + pu] = (interData)->refIdx[i][d];
memcpy(&(currInterData)->mv[i][count + pu], &(interData)->mv[i][d], sizeof(MV));
if (m_param->analysisReuseLevel == 7)
{
int mv_x = ((analysis_inter_data *)curFrame->m_analysisData.interData)->mv[i][count + pu].x;
int mv_y = ((analysis_inter_data *)curFrame->m_analysisData.interData)->mv[i][count + pu].y;
double mv = sqrt(mv_x*mv_x + mv_y*mv_y);
if (numPU == PU_2Nx2N && m_param->num4x4Partitions <= 16 && mv <= MVTHRESHOLD)
memset(&curFrame->m_analysisData.modeFlag[i][count + pu], 1, bytes);
}
}
}
}
}
count += bytes;
}
}
}
else
setAnalysisDataAfterZScan(analysis_data, curFrame);

curFrame->m_copyMVType.trigger();
return 0;
}
return -1;
}


Cmake output: https://pastebin.com/d8aMN3er

build-all.bat output: https://pastebin.com/WKZz2KgC


Thank you in advance.

[Ma]

You can try this patch:
diff -r b0d89eaaebcf source/encoder/encoder.cpp
--- a/source/encoder/encoder.cpp Wed Nov 29 08:52:18 2017 +0530
+++ b/source/encoder/encoder.cpp Thu Nov 30 02:42:43 2017 +0100
@@ -575,7 +575,7 @@
{
int mv_x = ((analysis_inter_data *)curFrame->m_analysisData.interData)->mv[k][(mbIndex * 16) + cuOffset].x;
int mv_y = ((analysis_inter_data *)curFrame->m_analysisData.interData)->mv[k][(mbIndex * 16) + cuOffset].y;
- double mv = sqrt(mv_x*mv_x + mv_y*mv_y);
+ double mv = sqrt((double)(mv_x*mv_x + mv_y*mv_y));
if (numPU == PU_2Nx2N && ((srcInterData)->depth[cuPos + cuOffset] == (m_param->maxCUSize >> 5)) && mv <= MVTHRESHOLD)
memset(&curFrame->m_analysisData.modeFlag[k][cuPos + cuOffset], 1, bytes);
}
@@ -658,7 +658,7 @@
{
int mv_x = ((analysis_inter_data *)curFrame->m_analysisData.interData)->mv[i][count + pu].x;
int mv_y = ((analysis_inter_data *)curFrame->m_analysisData.interData)->mv[i][count + pu].y;
- double mv = sqrt(mv_x*mv_x + mv_y*mv_y);
+ double mv = sqrt((double)(mv_x*mv_x + mv_y*mv_y));
if (numPU == PU_2Nx2N && m_param->num4x4Partitions <= 16 && mv <= MVTHRESHOLD)
memset(&curFrame->m_analysisData.modeFlag[i][count + pu], 1, bytes);
}

[Groucho2004]

In newer compilers this function is overloaded (accepts several variable types).

Cast the int arguments to double such as this:

double mv = sqrt((double)(mv_x*mv_x + mv_y*mv_y));


Edit: Ma beat me to it.

[FranceBB]

Build succeeded, thank you both. :D