// ConvertEndian()
void bfstream::ConvertEndian( unsigned long &value ) {
switch( endian_mode ) {
case ENDIAN_INTEL:
#ifndef WIN32
ReverseEndian( value );
#endif
break;
case ENDIAN_MOTOROLA:
#ifdef WIN32
ReverseEndian( value );
#endif
}
}
void GflSHA256::Final(void)
{
BYTE cZero = 0x00;
BYTE cOne = 0x80;
DWORD dwHNumBits = ReverseEndian(m_dwHNumBits);
DWORD dwLNumBits = ReverseEndian(m_dwLNumBits);
Load(&cOne, 1);
while(m_nNumChr != SHA256_BUFFER_SIZE - 8) Load(&cZero, 1);
Load((BYTE *)&dwHNumBits, 4);
Load((BYTE *)&dwLNumBits, 4);
}
void* LoadPCMWav(const char* file, PCMWAVFmt* pFmt) {
FILE* fd;
void* pWav = NULL;
if (!(fd = fopen(file, "rb"))) {
pFmt->ret = -1;
return NULL;
}
if (_load_pcmwavfmt(fd,pFmt)) {
CloseFile(fd);
pFmt->ret = -2;
return NULL;
}
//check the wavefile length
int iLen;
if ((fseek(fd, 0, SEEK_END)!=0) || ((iLen = ftell(fd))<0) || (fseek(fd, 44L, SEEK_SET)!=0) ) {
CloseFile(fd);
pFmt->ret = -3;
return NULL;
}
iLen -= 44;
int wavlen = pFmt->sample_byte*pFmt->sample_count*pFmt->sample_channel;
if (iLen != wavlen)
{
CloseFile(fd);
pFmt->ret = -4;
return NULL;
}
u32 stFrame = (pFmt->start != PCMClock(-1)) ? PCMClock2Frame(pFmt->start, pFmt->sample_rate) : 0;
u32 enFrame = (pFmt->end != PCMClock(-1)) ? PCMClock2Frame(pFmt->end , pFmt->sample_rate) : pFmt->sample_count;
enFrame = MIN(enFrame, pFmt->sample_count);
stFrame = MIN(stFrame, enFrame);
u32 npad = enFrame - stFrame;
if ( npad <= 0 )
{
CloseFile(fd);
pFmt->ret = -5;
return NULL;
}
int vecSize = pFmt->sample_byte*pFmt->sample_channel;
int offset = stFrame * vecSize;
pWav = (void*)memalign(128, npad*vecSize);
u32 readlen = ReadFile(fd, pWav, npad*vecSize, offset);
if (readlen != npad*vecSize)
{
CloseFile(fd);
free(pWav);
pFmt->ret = -6;
return NULL;
}
if (pFmt->sample_format != SAMP_ENDIAN)
{
ReverseEndian(pWav, pFmt->sample_byte, pFmt->sample_count*pFmt->sample_channel);
}
pFmt->sample_format = SAMP_ENDIAN;
pFmt->sample_count = npad;
pFmt->ret = 0;
return pWav;
}
void CObject::ToBigEndian(char *pData, unsigned int length)
{
if (!IsLittleEndian()) {
return;
}
ReverseEndian(pData, length);
}
void GflSHA256::Generate(void)
{
int i;
DWORD W[SHA256_WORK];
DWORD Hash[SHA256_WORK + SHA256_HASH];
for(i = 0; i < SHA256_BLOCK; i++) W[i] = ReverseEndian(m_aBlock[i]);
for(i = SHA256_BLOCK; i < SHA256_WORK; i++) W[i] = s1(W[i - 2]) + W[i - 7] + s0(W[i - 15]) + W[i - 16];
for(i = 0; i < SHA256_HASH; i++) Hash[SHA256_WORK + i] = m_dwH[i];
DWORD *pHash = &Hash[SHA256_WORK];
DWORD dwT1, dwT2;
for(i = 0; i < SHA256_WORK; i++){
pHash--;
dwT1 = pHash[8] + S1(pHash[5]) + Ch(pHash[5], pHash[6], pHash[7]) + c_dwK[i] + W[i];
dwT2 = S0(pHash[1]) + Maj(pHash[1], pHash[2], pHash[3]);
pHash[0] = dwT1 + dwT2;
pHash[4] += dwT1;
}
for(i = 0; i < SHA256_HASH; i++) m_dwH[i] += pHash[i];
}
