void init(uint64_t offset = 0, uint64_t * psymoffset = 0)
{
if ( ((idda.kvec.size()!=0) && (idda.kvec[idda.kvec.size()-1] != 0)) )
{
if ( offset >= idda.kvec[idda.kvec.size()-1] )
{
fileptr = idda.data.size();
blockptr = 0;
}
else
{
::libmaus::huffman::FileBlockOffset const FBO = idda.findKBlock(offset);
fileptr = FBO.fileptr;
blockptr = FBO.blockptr;
offset = FBO.offset;
/* open file and seek to block */
openNewFile();
/* decode block in question */
bool const blockok = decodeBlock();
assert ( blockok );
assert ( static_cast<int64_t>(offset) < (pe-pc) );
/* symbol offset of block (sum over elements of previous blocks) */
uint64_t symoffset = idda.data[FBO.fileptr].getValueCnt(FBO.blockptr);
/* decode symbols up to offset in block */
for ( uint64_t i = 0; i < offset; ++i )
symoffset += decode();
/* store prefix sum if pointer is given */
if ( psymoffset )
*psymoffset = symoffset;
}
}
}
/* peek at next symbol without advancing decode pointer */
uint64_t peek()
{
if ( pc == pe )
decodeBlock();
assert ( pc != pe );
return *pc;
}
/* decode next symbol */
uint64_t decode()
{
if ( pc == pe )
decodeBlock();
assert ( pc != pe );
return *(pc++);
}
bool decode(uint64_t & v)
{
while ( pc == pe )
{
bool const ok = decodeBlock();
if ( ! ok )
return false;
}
v = *(pc++);
return true;
}
int SIMD_PB_VL::decode(T* des, const char* src, uint32_t decodeNum) {
int decodeLen = 0;
for (int i = 0; i < decodeNum; i += m_blockSize) {
if (i + m_blockSize > decodeNum) {
decodeLen += VarByte::decode<T>(des + i, src + decodeLen, decodeNum
- i);
} else {
decodeLen += decodeBlock(des + i, src + decodeLen);
}
}
return decodeLen;
}
int SIMD_Group_PFD_2::decodeAlign(T* des, const char* src, uint32_t decodeNum) {
if (decodeNum == 0)
return 0;
uint32_t numBlk = decodeNum / m_blockSize;
const uint32_t *srcInt = (const uint32_t*)src;
uint32_t blkHeaderOffset = srcInt[0];
const char *srcNorm = src + 4;
const char *srcBlkHeader = srcNorm + blkHeaderOffset;
uint32_t allBlockHeaderBytes = *(const uint32_t*)srcBlkHeader;
assert(allBlockHeaderBytes == sizeof(uint32_t) * numBlk);
srcBlkHeader += 4;
const char *srcExp = srcBlkHeader + allBlockHeaderBytes;
uint32_t expBytes = decodeExp(srcExp);
m_exp8Pos = m_exp8Arr;
m_exp16Pos = m_exp16Arr;
m_exp32Pos = m_exp32Arr;
uint32_t normLen = 0;
const uint32_t *srcBlkHeaderUInt = (const uint32_t *)srcBlkHeader;
for (uint32_t i=0; i<decodeNum; i += m_blockSize) {
uint32_t header = *srcBlkHeaderUInt++;
normLen += decodeBlock(des + i, srcNorm + normLen, header);
}
assert(srcNorm + normLen + 4 == srcBlkHeader);
if (m_exp8Num > 0) {
assert(m_exp8Pos - m_exp8Arr == m_exp8Num);
delete []m_exp8Arr;
m_exp8Arr = NULL;
m_exp8Pos = NULL;
}
if (m_exp16Num > 0) {
assert(m_exp16Pos - m_exp16Arr == m_exp16Num);
delete []m_exp16Arr;
m_exp16Arr = NULL;
m_exp16Pos = NULL;
}
if (m_exp32Num > 0) {
assert(m_exp32Pos - m_exp32Arr == m_exp32Num);
delete []m_exp32Arr;
m_exp32Arr = NULL;
m_exp32Pos = NULL;
}
return srcExp + expBytes - src;
}
void init(uint64_t const offset)
{
FBO = index.lookup(offset);
if ( FBO.file < index.Vfn.size() )
{
openFile();
decodeBlock();
uint64_t v;
while ( FBO.offset )
{
bool const ok = decode(v);
assert ( ok );
FBO.offset--;
}
}
}
int main( int argc, char **argv )
{
settings * ptHuffTodo = 0;
int verbose;
int i;
int nBlocks = 0;
ptHuffTodo = parseOptions( argc, argv );
if( ptHuffTodo == 0 )
return 1;
verbose = ptHuffTodo->nVerbose;
if( verbose == 1 )
printf("\n(D: begin ...)");
if( ptHuffTodo->nEncode )
{
InitializeHuffNodeArray( GlobalHuffCodes.ptCharFreq, verbose );
while( readEncoded( verbose ) == 0 )
{
if( GlobalHuffCodes.nReadChars == 0 && nBlocks == 0)
{
fprintf(stderr,"\nError: No data to encode.");
break;
}
if( makeHuffman( verbose ) == 0 )
{
fprintf(stderr,"\nError: Huffman-coding error");
break;
}
if( verbose )
printHuffTree();
if( ptHuffTodo->nWords )
{
printf("Pairs:");
for( i = 0; i < CHARS; i++)
printHuffCode(i);
}
if( ptHuffTodo->nCode )
{
printf("\nData:\n");
for( i = 0; i < GlobalHuffCodes.nReadChars ; i++)
{
if( printJustHuffCode(indexOf(GlobalHuffCodes.psReadChars[i])) != 0 )
return 1;
printf(" ");
}
printf("\n");
}
resetHuffNodeArray(GlobalHuffCodes.ptCharFreq);
nBlocks ++;
}
if( nBlocks == 0 || nBlocks != 0 && GlobalHuffCodes.nReadChars != 0 ) //ugly fix
return 1;
}
if( ptHuffTodo->nDecode )
{
InitializeHuffNodeArray( GlobalHuffCodes.ptCharFreq, verbose );
InitializeHuffNodeArrayForMidleNodes( GlobalHuffCodes.ptNotLeafs, verbose );
resetRootNode();
if( verbose == 1 )
printf("\n(D: Decode)");
while( decodeBlock( verbose ) == 0 )
{
if( verbose == 1 )
printf("\n(D: Next block)");
InitializeHuffNodeArrayForMidleNodes( GlobalHuffCodes.ptNotLeafs, verbose );
resetHuffNodeArray(GlobalHuffCodes.ptCharFreq);
resetRootNode();
nBlocks ++;
}
if( nBlocks == 0 || nBlocks != 0 && GlobalHuffCodes.nReadChars != 0 ) //ugly fix
return 1;
}
return 0;
}
void initKV(uint64_t kvtarget, ::libmaus::huffman::KvInitResult & result)
{
result = ::libmaus::huffman::KvInitResult();
if (
(
(idda.kvec.size()!=0)
&&
(idda.kvec[idda.kvec.size()-1] != 0)
)
)
{
if (
kvtarget >=
idda.kvec[idda.kvec.size()-1] + idda.vvec[idda.vvec.size()-1]
)
{
fileptr = idda.data.size();
blockptr = 0;
result.koffset = idda.kvec[idda.kvec.size()-1];
result.voffset = idda.vvec[idda.vvec.size()-1];
result.kvoffset = result.koffset + result.voffset;
result.kvtarget = 0;
}
else
{
::libmaus::huffman::FileBlockOffset const FBO = idda.findKVBlock(kvtarget);
fileptr = FBO.fileptr;
blockptr = FBO.blockptr;
/* open file and seek to block */
openNewFile();
/* decode block in question */
bool const blockok = decodeBlock();
assert ( blockok );
/* key/symbol offset of block (sum over elements of previous blocks) */
uint64_t kvoffset = idda.data[FBO.fileptr].getKeyValueCnt(FBO.blockptr);
uint64_t voffset = idda.data[FBO.fileptr].getValueCnt(FBO.blockptr);
uint64_t koffset = idda.data[FBO.fileptr].getKeyCnt(FBO.blockptr);
assert ( kvtarget >= kvoffset );
kvtarget -= kvoffset;
// std::cerr << "fileptr=" << fileptr << " blockptr=" << blockptr << " kvtarget=" << kvtarget << std::endl;
while ( kvtarget >= peek() + 1 )
{
uint64_t const gi = decode();
kvoffset += (gi+1);
kvtarget -= (gi+1);
voffset += gi;
koffset += 1;
}
if ( koffset + 1 == getN() && kvtarget >= peek() )
{
uint64_t const gi = decode();
kvoffset += gi;
kvtarget -= gi;
voffset += gi;
koffset += 0;
}
else
{
assert ( pc != pe );
assert ( kvtarget <= peek() );
assert ( kvtarget <= *pc );
*pc -= kvtarget;
}
result.koffset = koffset;
result.voffset = voffset;
result.kvoffset = kvoffset;
result.kvtarget = kvtarget;
}
}
}
void GFourierWaveProcessor::doit(GWave& signal)
{
for(unsigned short chan = 0; chan < signal.channels(); chan++)
{
// Denoise the signal. Here is an ascii-art representation of how the blocks align.
// Suppose the signal is 4 blocks long (n=4). i will iterate from 0 to 4.
// _________ _________ _________ _________
// 0 A B C D E
// 1 A B C D E
// 2 A B C D E
// 3 A B C D E
// 4 A B C D E
GWaveIterator itSignalIn(signal);
GWaveIterator itSignalOut(signal);
size_t n = itSignalIn.remaining() / m_blockSize;
if((m_blockSize * n) < itSignalIn.remaining())
n++;
for(size_t i = 0; i <= n; i++)
{
// Encode block D (which also covers the latter-half of C and the first-half of E)
if(i != n)
{
encodeBlock(itSignalIn, m_pBufD, chan);
struct ComplexNumber* pSrc = m_pBufD;
struct ComplexNumber* pDest = m_pBufC + m_blockSize / 2;
for(size_t j = 0; j < m_blockSize / 2; j++)
*(pDest++) = *(pSrc++);
pDest = m_pBufE;
for(size_t j = 0; j < m_blockSize / 2; j++)
*(pDest++) = *(pSrc++);
// Blocks C and D are fully-encoded, so we can bring them to the Fourier domain now
if(i != 0)
GFourier::fft(m_blockSize, m_pBufC, true);
GFourier::fft(m_blockSize, m_pBufD, true);
}
// Process the blocks that are ready-to-go
if(i != 0)
{
// Denoise blocks B and C
process(m_pBufB);
GFourier::fft(m_blockSize, m_pBufB, false);
if(i != n)
{
process(m_pBufC);
GFourier::fft(m_blockSize, m_pBufC, false);
}
// Interpolate A, B, and C to produce the final B
interpolate(i == 1 ? NULL : m_pBufA, m_pBufB, i == n ? NULL : m_pBufC, m_blockSize / 2);
decodeBlock(itSignalOut, chan);
}
// Shift A<-C, B<-D, C<-E
struct ComplexNumber* pTemp = m_pBufA;
m_pBufA = m_pBufC;
m_pBufC = m_pBufE;
m_pBufE = pTemp;
pTemp = m_pBufB;
m_pBufB = m_pBufD;
m_pBufD = pTemp;
}
GAssert(itSignalOut.remaining() == 0);
}
}
