/// \brief Constructor for the AcceleratorDevice class.
/// \param logger The application logger.
AcceleratorDevice::AcceleratorDevice(log4cpp::Category* logger) {
logger_ = logger;
InitializePlatform();
InitializeDevices();
InitializeContexts();
}
bool RunJPEGCompressor(JPEGCompressor *self,FILE *output)
{
uint32_t shifts=
(self->eobshift-1)|
(self->zeroshift-1<<3)|
(self->eobshift-1<<6)|
(self->acmagnitudeshift-1<<9)|
(self->acremaindershift-1<<12)|
(self->acsignshift-1<<15)|
(self->dcmagnitudeshift-1<<18)|
(self->dcremaindershift-1<<21)|
(self->dcsignshift-1<<24);
fputc((shifts>>24)&0xff,output);
fputc((shifts>>16)&0xff,output);
fputc((shifts>>8)&0xff,output);
fputc(shifts&0xff,output);
InitializeRangeEncoder(&self->encoder,STDIOWriteFunction,output);
// Parse the JPEG structure. If this is the first bundle,
// we have to first find the start marker.
int parseres=ParseJPEGMetadata(&self->jpeg,self->start,self->end-self->start);
if(parseres==JPEGMetadataParsingFailed) return false;
if(parseres==JPEGMetadataFoundEndOfImage) return false;
// TODO: Do sanity and conformance checks here.
size_t totallength=self->end-self->start;
size_t metadatalength=self->jpeg.bytesparsed;
if(metadatalength>=0x1000000) return false;
// Write metadata length.
for(int i=23;i>=0;i--)
{
WriteBit(&self->encoder,(metadatalength>>i)&1,0x800);
}
// Write metadata.
for(int i=0;i<metadatalength;i++)
for(int j=7;j>=0;j--)
{
WriteBit(&self->encoder,(self->start[i]>>j)&1,0x800);
}
// Initialize bitstream reader and Huffman lookup tables
// to read JPEG data.
InitializeBitStreamReader(&self->bitstream,self->start+self->jpeg.bytesparsed,
totallength-metadatalength);
for(int i=0;i<4;i++)
{
if(self->jpeg.huffmandefined[0][i])
{
InitializeHuffmanTable(&self->dctables[i]);
for(int j=0;j<256;j++)
{
if(self->jpeg.huffmantables[0][i].codes[j].length)
AddHuffmanCode(&self->dctables[i],
self->jpeg.huffmantables[0][i].codes[j].code,
self->jpeg.huffmantables[0][i].codes[j].length,j);
}
}
if(self->jpeg.huffmandefined[1][i])
{
InitializeHuffmanTable(&self->actables[i]);
for(int j=0;j<256;j++)
{
if(self->jpeg.huffmantables[1][i].codes[j].length)
AddHuffmanCode(&self->actables[i],
self->jpeg.huffmantables[1][i].codes[j].code,
self->jpeg.huffmantables[1][i].codes[j].length,j);
}
}
}
// Reset JPEG predictors.
memset(self->predicted,0,sizeof(self->predicted));
// Allocate memory for a few rows of data, for neighbour blocks.
JPEGBlock *rows[4][3]={NULL};
for(int i=0;i<self->jpeg.numscancomponents;i++)
for(int j=0;j<3;j++)
{
rows[i][j]=malloc(self->jpeg.horizontalmcus*
self->jpeg.scancomponents[i].component->horizontalfactor*
sizeof(JPEGBlock));
if(!rows[i][j]) return false; //JPEGOutOfMemoryError;
}
// Initialize arithmetic encoder contexts.
InitializeContexts(&self->eobbins[0][0][0],sizeof(self->eobbins));
InitializeContexts(&self->zerobins[0][0][0][0],sizeof(self->zerobins));
InitializeContexts(&self->pivotbins[0][0][0][0],sizeof(self->pivotbins));
InitializeContexts(&self->acmagnitudebins[0][0][0][0][0],sizeof(self->acmagnitudebins));
InitializeContexts(&self->acremainderbins[0][0][0][0],sizeof(self->acremainderbins));
InitializeContexts(&self->acsignbins[0][0][0][0],sizeof(self->acsignbins));
InitializeContexts(&self->dcmagnitudebins[0][0][0],sizeof(self->dcmagnitudebins));
InitializeContexts(&self->dcremainderbins[0][0][0],sizeof(self->dcremainderbins));
InitializeContexts(&self->dcsignbins[0][0][0][0],sizeof(self->dcsignbins));
int restartcounter=0;
int restartindex=0;
for(int row=0;row<self->jpeg.verticalmcus;row++)
for(int col=0;col<self->jpeg.horizontalmcus;col++)
{
if(self->jpeg.restartinterval&&restartcounter==self->jpeg.restartinterval)
{
if(!FlushAndSkipRestartMarker(&self->bitstream,restartindex)) return false;
restartindex=(restartindex+1)&7;
restartcounter=0;
memset(self->predicted,0,sizeof(self->predicted));
}
restartcounter++;
for(int comp=0;comp<self->jpeg.numscancomponents;comp++)
{
int hblocks=self->jpeg.scancomponents[comp].component->horizontalfactor;
int vblocks=self->jpeg.scancomponents[comp].component->verticalfactor;
JPEGQuantizationTable *quantization=self->jpeg.scancomponents[comp].component->quantizationtable;
for(int mcu_y=0;mcu_y<vblocks;mcu_y++)
for(int mcu_x=0;mcu_x<hblocks;mcu_x++)
{
int x=col*hblocks+mcu_x;
int y=row*vblocks+mcu_y;
JPEGBlock *current=&rows[comp][y%3][x];
JPEGBlock *west;
if(x==0) west=NULL;
else west=&rows[comp][y%3][x-1];
JPEGBlock *north;
if(y==0) north=NULL;
else north=&rows[comp][(y-1)%3][x];
if(!ReadBlock(self,current,comp)) return false;
//fprintf(stderr,"%d,%d,%d: ",x,y,comp);
//for(int i=0;i<64;i++) fprintf(stderr,"%d ",current->c[i]);
//fprintf(stderr,"\n");
CompressBlock(self,comp,current,north,west,quantization);
}
}
}
// Kludge in a closing block, if possible.
if(self->bitstream.pos!=self->end-2) return false;
if(self->bitstream.pos[0]!=0xff) return false;
if(self->bitstream.pos[1]!=0xd9) return false;
metadatalength=2;
// Write metadata length.
for(int i=23;i>=0;i--)
{
WriteBit(&self->encoder,(metadatalength>>i)&1,0x800);
}
// Write metadata.
for(int i=0;i<metadatalength;i++)
for(int j=7;j>=0;j--)
{
WriteBit(&self->encoder,(self->bitstream.pos[i]>>j)&1,0x800);
}
FinishRangeEncoder(&self->encoder);
for(int i=0;i<4;i++)
for(int j=0;j<3;j++)
free(rows[i][j]);
return true;
}
