/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d J B I G I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ReadJBIGImage() reads a JBIG image file and returns it. It
% allocates the memory necessary for the new Image structure and returns a
% pointer to the new image.
%
% The format of the ReadJBIGImage method is:
%
% Image *ReadJBIGImage(const ImageInfo *image_info,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_info: the image info.
%
% o exception: return any errors or warnings in this structure.
%
*/
static Image *ReadJBIGImage(const ImageInfo *image_info,
ExceptionInfo *exception)
{
Image
*image;
IndexPacket
index;
long
length,
y;
MagickBooleanType
status;
register IndexPacket
*indexes;
register long
x;
register PixelPacket
*q;
register unsigned char
*p;
ssize_t
count;
struct jbg_dec_state
jbig_info;
unsigned char
bit,
*buffer,
byte;
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AllocateImage(image_info);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
image=DestroyImageList(image);
return((Image *) NULL);
}
/*
Initialize JBIG toolkit.
*/
jbg_dec_init(&jbig_info);
jbg_dec_maxsize(&jbig_info,(unsigned long) image->columns,(unsigned long)
image->rows);
image->columns=jbg_dec_getwidth(&jbig_info);
image->rows=jbg_dec_getheight(&jbig_info);
image->depth=8;
image->storage_class=PseudoClass;
image->colors=2;
/*
Read JBIG file.
*/
buffer=(unsigned char *) AcquireQuantumMemory(MagickMaxBufferSize,
sizeof(*buffer));
if (buffer == (unsigned char *) NULL)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
status=JBG_EAGAIN;
do
{
length=(long) ReadBlob(image,MagickMaxBufferSize,buffer);
if (length == 0)
break;
p=buffer;
count=0;
while ((length > 0) && ((status == JBG_EAGAIN) || (status == JBG_EOK)))
{
size_t
count;
status=jbg_dec_in(&jbig_info,p,length,&count);
p+=count;
length-=(long) count;
}
} while ((status == JBG_EAGAIN) || (status == JBG_EOK));
/*
Create colormap.
*/
image->columns=jbg_dec_getwidth(&jbig_info);
image->rows=jbg_dec_getheight(&jbig_info);
if (AllocateImageColormap(image,2) == MagickFalse)
{
buffer=(unsigned char *) RelinquishMagickMemory(buffer);
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
}
image->colormap[0].red=0;
image->colormap[0].green=0;
image->colormap[0].blue=0;
image->colormap[1].red=QuantumRange;
image->colormap[1].green=QuantumRange;
image->colormap[1].blue=QuantumRange;
image->x_resolution=300;
image->y_resolution=300;
if (image_info->ping != MagickFalse)
{
(void) CloseBlob(image);
return(GetFirstImageInList(image));
}
/*
Convert X bitmap image to pixel packets.
*/
if (SetImageExtent(image,0,0) == MagickFalse)
{
InheritException(exception,&image->exception);
return(DestroyImageList(image));
}
p=jbg_dec_getimage(&jbig_info,0);
for (y=0; y < (long) image->rows; y++)
{
q=SetImagePixels(image,0,y,image->columns,1);
if (q == (PixelPacket *) NULL)
break;
indexes=GetIndexes(image);
bit=0;
byte=0;
for (x=0; x < (long) image->columns; x++)
{
if (bit == 0)
byte=(*p++);
index=(byte & 0x80) ? 0 : 1;
bit++;
byte<<=1;
if (bit == 8)
bit=0;
indexes[x]=index;
*q++=image->colormap[(long) index];
}
if (SyncImagePixels(image) == MagickFalse)
break;
if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&
(QuantumTick(y,image->rows) != MagickFalse))
{
status=image->progress_monitor(LoadImageTag,y,image->rows,
image->client_data);
if (status == MagickFalse)
break;
}
}
/*
Free scale resource.
*/
jbg_dec_free(&jbig_info);
buffer=(unsigned char *) RelinquishMagickMemory(buffer);
(void) CloseBlob(image);
return(GetFirstImageInList(image));
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d J B I G I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ReadJBIGImage() reads a JBIG image file and returns it. It
% allocates the memory necessary for the new Image structure and returns a
% pointer to the new image.
%
% The format of the ReadJBIGImage method is:
%
% Image *ReadJBIGImage(const ImageInfo *image_info,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_info: the image info.
%
% o exception: return any errors or warnings in this structure.
%
*/
static Image *ReadJBIGImage(const ImageInfo *image_info,
ExceptionInfo *exception)
{
Image
*image;
MagickStatusType
status;
Quantum
index;
register ssize_t
x;
register Quantum
*q;
register unsigned char
*p;
ssize_t
length,
y;
struct jbg_dec_state
jbig_info;
unsigned char
bit,
*buffer,
byte;
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AcquireImage(image_info,exception);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
image=DestroyImageList(image);
return((Image *) NULL);
}
/*
Initialize JBIG toolkit.
*/
jbg_dec_init(&jbig_info);
jbg_dec_maxsize(&jbig_info,(unsigned long) image->columns,(unsigned long)
image->rows);
image->columns=jbg_dec_getwidth(&jbig_info);
image->rows=jbg_dec_getheight(&jbig_info);
image->depth=8;
image->storage_class=PseudoClass;
image->colors=2;
/*
Read JBIG file.
*/
buffer=(unsigned char *) AcquireQuantumMemory(MagickMaxBufferExtent,
sizeof(*buffer));
if (buffer == (unsigned char *) NULL)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
status=JBG_EAGAIN;
do
{
length=(ssize_t) ReadBlob(image,MagickMaxBufferExtent,buffer);
if (length == 0)
break;
p=buffer;
while ((length > 0) && ((status == JBG_EAGAIN) || (status == JBG_EOK)))
{
size_t
count;
status=jbg_dec_in(&jbig_info,p,length,&count);
p+=count;
length-=(ssize_t) count;
}
} while ((status == JBG_EAGAIN) || (status == JBG_EOK));
/*
Create colormap.
*/
image->columns=jbg_dec_getwidth(&jbig_info);
image->rows=jbg_dec_getheight(&jbig_info);
image->compression=JBIG2Compression;
if (AcquireImageColormap(image,2,exception) == MagickFalse)
{
buffer=(unsigned char *) RelinquishMagickMemory(buffer);
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
}
image->colormap[0].red=0;
image->colormap[0].green=0;
image->colormap[0].blue=0;
image->colormap[1].red=QuantumRange;
image->colormap[1].green=QuantumRange;
image->colormap[1].blue=QuantumRange;
image->resolution.x=300;
image->resolution.y=300;
if (image_info->ping != MagickFalse)
{
(void) CloseBlob(image);
return(GetFirstImageInList(image));
}
/*
Convert X bitmap image to pixel packets.
*/
p=jbg_dec_getimage(&jbig_info,0);
for (y=0; y < (ssize_t) image->rows; y++)
{
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (Quantum *) NULL)
break;
bit=0;
byte=0;
for (x=0; x < (ssize_t) image->columns; x++)
{
if (bit == 0)
byte=(*p++);
index=(byte & 0x80) ? 0 : 1;
bit++;
byte<<=1;
if (bit == 8)
bit=0;
SetPixelIndex(image,index,q);
SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
image->rows);
if (status == MagickFalse)
break;
}
/*
Free scale resource.
*/
jbg_dec_free(&jbig_info);
buffer=(unsigned char *) RelinquishMagickMemory(buffer);
(void) CloseBlob(image);
return(GetFirstImageInList(image));
}
int main(int argc, char** argv)
{
QTextCodec::setCodecForLocale(QTextCodec::codecForName("latin1"));
AppliArgs args(QStringList() << "~help,h" << "~version,v" << "output=1,o");
QTextStream out(stdout), err(stderr);
unsigned long int length;
struct jbg_dec_state sd;
unsigned char *buffer;
QString hw("%1 %2\n");
QByteArray data;
bool argsErr;
QFile input;
// Parse arguments
argsErr = !args.parse(argc, argv, 1);
if (argsErr || args.isOptionSet("help")) {
args.printErrors(err);
out << QString(_("Usage: %1 [options] <JBIG file>")).arg(args.
applicationName()) << endl;
out << _("Available options:") << endl;
out << _(" --help, -h Print this help message") << endl;
out << _(" --output, -o Select the output file") << endl;
out << _(" --version, -v Print the version information") <<
endl;
return argsErr ? 1 : 0;
} else if (args.isOptionSet("version")) {
out << _("(C) jbgtopbm, 2007 by Aurélien Croc") << endl;
out << _("This project is under the GNU General Public Licence "
"version 2") << endl;
out << _("More information => http://splix.ap2c.org") << endl << endl;
return 0;
}
// Open the input and the output file
input.setFileName(args.parameter(0));
if (!input.open(QIODevice::ReadOnly)) {
err << _("Error: cannot open file ") << args.parameter(0) << endl;
return -1;
}
data = input.readAll();
buffer = (unsigned char *)data.data();
length = data.length();
if (args.isOptionSet("output"))
output.setFileName(args.optionArg("output", 0));
else
output.setFileName("/dev/stdout");
if (!output.open(QIODevice::WriteOnly)) {
err << _("Error: cannot open file ") << output.fileName() << endl;
return -1;
}
// Decompress the image
jbg_dec_init(&sd);
while (length) {
unsigned long size;
int res;
size = *(unsigned long*)buffer;
printf("Taille=%lu\n", size);
buffer += sizeof(size);
length -= sizeof(size);
res = jbg_dec_in(&sd, buffer, size, NULL);
if (res == JBG_EOK) {
out << _("Processed.") << endl;
break;
} else if (res != JBG_EAGAIN) {
err << _("JBG not ok ") << res << endl;
break;
}
length -= size;
buffer += size;
}
// Store the image
output.write("P4\n");
output.write("# Image created by jbgtopbm, (C) 2007 by Aurélien Croc "
"(AP²C)\n");
hw = hw.arg(jbg_dec_getwidth(&sd)).arg(jbg_dec_getheight(&sd));
output.write(hw.toAscii());
output.write((const char *)jbg_dec_getimage(&sd, 0), jbg_dec_getsize(&sd));
output.close();
return 0;
}
/**
* Analyse contract and respond
*
* Attempts to parse the supplied file as JBIG
*
* \param to_analyse The contract to analyse
* \param ccr The contract completion report to populate
* \returns 0 on sucess, -1 on error
*/
int analyse_contract(contract_t to_analyse, contract_completion_report_t ccr)
{
struct jbg_dec_state sd;
unsigned char data[JHEAD_SIZE];
int status;
size_t cnt;
const char *path = contract_get_path(to_analyse);
jbg_dec_init(&sd);
FILE *file = fopen(path, "r");
if (file == NULL)
{
warning_log("analyse_contract: Could not open file");
return 0;
}
/* Read header and check for valid JBIG */
int size = 0;
size = fread(&data, BYTE, JHEAD_SIZE, file);
status = jbg_dec_in(&sd, data, JHEAD_SIZE, &cnt);
if (status >= JBG_EINVAL && status <= (JBG_EINVAL | 14))
{
debug_log("Not a valid JBIG file");
jbg_dec_free(&sd);
return 0;
}
/* Read in the whole JBIG */
int bytes_read;
while ((bytes_read = fread(&data, BYTE, BYTE, file)))
{
size += bytes_read;
status = jbg_dec_in(&sd, data, BYTE, &cnt);
if (status == JBG_EOK)
{ /* Found end of file */
break;
} else if (status != JBG_EAGAIN)
{ /* Error value returned */
debug_log("Error reading JBIG: %s", jbg_strerror(status));
jbg_dec_free(&sd);
return 0;
} else if (size == 104857600)
{ /* Only read upto 100MB */
debug_log("Read 100MB, couldnt find end of JBIG");
jbg_dec_free(&sd);
return 0;
}
}
fclose(file);
/* Process loaded JBIG */
gchar *hxw = g_strdup_printf("%ldx%ld", jbg_dec_getwidth(&sd), jbg_dec_getheight(&sd));
gchar *planes = g_strdup_printf("%d plane(s)", jbg_dec_getplanes(&sd));
gchar *bytes = g_strdup_printf("%dB", size);
gchar *data_str = g_strdup_printf("%s, %s, %s", bytes, hxw, planes);
g_free(hxw);
g_free(planes);
g_free(bytes);
/* Fill in report and result data, identifying blocks if possible */
long long int offset = contract_get_absolute_offset(to_analyse);
int contig = contract_is_contiguous(to_analyse);
result_t result = result_init(NULL, 0);
populate_result_with_length(result, "JBIG", data_str, 100, offset, size, contig);
contract_completion_report_add_result(ccr, result);
result_close(result);
g_free(data_str);
return 0;
}