/*!
\brief Closes a wan (dialup, vpn...) adapter.
\param lpWanAdapter the pointer to the wan adapter to close.
WanPacketCloseAdapter closes the given adapter and frees the associated WAN_ADAPTER structure
*/
BOOLEAN WanPacketCloseAdapter(PWAN_ADAPTER pWanAdapter)
{
if (pWanAdapter->pIRTC->Stop() != NMERR_SUCCESS)
OutputDebugString("WanPacketCloseAdapter: Severe error, IRTC::Stop failed\n");
if (pWanAdapter->pIRTC->Disconnect() != NMERR_SUCCESS)
OutputDebugString("WanPacketCloseAdapter: Severe error, IRTC::Disconnect failed\n");
if (pWanAdapter->pIRTC->Release() != NMERR_SUCCESS)
OutputDebugString("WanPacketCloseAdapter: Severe error, IRTC::Release failed\n");
Sleep(0); //Just a stupid hack to make all the stuff work. I don't why it's necessary.
//setting a NULL filter will actually deallocate the in-use filter
WanPacketSetBpfFilter(pWanAdapter, NULL, 0);
//setting a zero-sized buffer will deallocate any in-use ring buffer
WanPacketSetBufferSize(pWanAdapter, 0);
CloseHandle(pWanAdapter->hReadEvent);
//destroy the BLOB used to capture
DestroyBlob(pWanAdapter->hCaptureBlob);
DeleteCriticalSection(&pWanAdapter->CriticalSection);
//deallocate the extended memory, if any.
if (pWanAdapter->MemEx.size > 0)
GlobalFree(pWanAdapter->MemEx.buffer);
GlobalFree(pWanAdapter);
//uninitialize COM
CoUninitialize();
return TRUE;
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ S y n c N e x t I m a g e I n L i s t %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% SyncNextImageInList() returns the next image in the list after the blob
% referenced is synchronized with the current image.
%
% The format of the SyncNextImageInList method is:
%
% Image *SyncNextImageInList(const Image *images)
%
% A description of each parameter follows:
%
% o images: the image list.
%
*/
MagickExport Image *SyncNextImageInList(const Image *images)
{
if (images == (Image *) NULL)
return((Image *) NULL);
assert(images->signature == MagickSignature);
if (images->next == (Image *) NULL)
return((Image *) NULL);
if (images->blob != images->next->blob)
{
DestroyBlob(images->next);
images->next->blob=ReferenceBlob(images->blob);
}
images->next->endian=images->endian;
return(images->next);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% W r i t e I m a g e s %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% WriteImages() writes an image sequence into one or more files. While
% WriteImage() can write an image sequence, it is limited to writing
% the sequence into a single file using a format which supports multiple
% frames. WriteImages(), however, does not have this limitation, instead it
% generates multiple output files if necessary (or when requested). When
% ImageInfo's adjoin flag is set to MagickFalse, the file name is expected
% to include a printf-style formatting string for the frame number (e.g.
% "image%02d.png").
%
% The format of the WriteImages method is:
%
% MagickBooleanType WriteImages(const ImageInfo *image_info,Image *images,
% const char *filename,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_info: the image info.
%
% o images: the image list.
%
% o filename: the image filename.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport MagickBooleanType WriteImages(const ImageInfo *image_info,
Image *images,const char *filename,ExceptionInfo *exception)
{
#define WriteImageTag "Write/Image"
BlobInfo
*blob;
ExceptionInfo
*sans_exception;
ImageInfo
*write_info;
MagickBooleanType
proceed;
MagickOffsetType
i;
MagickProgressMonitor
progress_monitor;
MagickSizeType
number_images;
MagickStatusType
status;
register Image
*p;
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(images != (Image *) NULL);
assert(images->signature == MagickSignature);
if (images->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
assert(exception != (ExceptionInfo *) NULL);
write_info=CloneImageInfo(image_info);
images=GetFirstImageInList(images);
blob=CloneBlobInfo(images->blob); /* thread specific I/O handler */
DestroyBlob(images);
images->blob=blob;
if (filename != (const char *) NULL)
for (p=images; p != (Image *) NULL; p=GetNextImageInList(p))
(void) CopyMagickString(p->filename,filename,MaxTextExtent);
(void) CopyMagickString(write_info->filename,images->filename,MaxTextExtent);
if (*write_info->magick == '\0')
(void) CopyMagickString(write_info->magick,images->magick,MaxTextExtent);
sans_exception=AcquireExceptionInfo();
(void) SetImageInfo(write_info,(unsigned int) GetImageListLength(images),
sans_exception);
sans_exception=DestroyExceptionInfo(sans_exception);
p=images;
for ( ; GetNextImageInList(p) != (Image *) NULL; p=GetNextImageInList(p))
if (p->scene >= GetNextImageInList(p)->scene)
{
register ssize_t
i;
/*
Generate consistent scene numbers.
*/
i=(ssize_t) images->scene;
for (p=images; p != (Image *) NULL; p=GetNextImageInList(p))
p->scene=(size_t) i++;
break;
}
/*
Write images.
*/
status=MagickTrue;
progress_monitor=(MagickProgressMonitor) NULL;
i=0;
number_images=GetImageListLength(images);
for (p=images; p != (Image *) NULL; p=GetNextImageInList(p))
{
if (number_images != 1)
progress_monitor=SetImageProgressMonitor(p,(MagickProgressMonitor) NULL,
p->client_data);
status&=WriteImage(write_info,p,exception);
if (number_images != 1)
(void) SetImageProgressMonitor(p,progress_monitor,p->client_data);
if (write_info->adjoin != MagickFalse)
break;
if (number_images != 1)
{
proceed=SetImageProgress(p,WriteImageTag,i++,number_images);
if (proceed == MagickFalse)
break;
}
}
write_info=DestroyImageInfo(write_info);
return(status != 0 ? MagickTrue : MagickFalse);
}
/*!
\brief Opens the wan (dialup, vpn...) adapter.
\return If the function succeeds, the return value is the pointer to a properly initialized WAN_ADAPTER structure,
otherwise the return value is NULL.
*/
PWAN_ADAPTER WanPacketOpenAdapter()
{
PWAN_ADAPTER pWanAdapter = NULL;
PBLOB_TABLE pBlobTable = NULL;
HBLOB hFilterBlob = NULL;
HRESULT hResult;
DWORD i;
if ( g_hModule == NULL)
{
g_hModule = LoadLibrary("npp\\ndisnpp.dll");
}
if ( g_hModule == NULL)
{
return NULL;
}
hResult = CoInitialize(NULL);
//
// if the calling thread has already initialized COM with a
// different threading model, we have this error
// however, we are able to support another threading model,
// so we try to initialize COM with another threading model.
// This new call should succeed with S_FALSE.
//
if (hResult == RPC_E_CHANGED_MODE)
{
hResult = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
//MULTITHREADED threading is only supported on Windows 2000
if (hResult == RPC_E_CHANGED_MODE && IsWindows2000())
{
hResult = CoInitializeEx(NULL, COINIT_MULTITHREADED);
}
}
if (hResult != S_OK && hResult != S_FALSE)
return NULL;
pWanAdapter = (PWAN_ADAPTER)GlobalAlloc(GPTR, sizeof (WAN_ADAPTER));
if ( pWanAdapter == NULL )
goto error;
memset(pWanAdapter, 0, sizeof(WAN_ADAPTER));
if ( CreateBlob(&hFilterBlob) != NMERR_SUCCESS )
{
goto error;
}
if ( SetBoolInBlob(hFilterBlob, OWNER_NPP, CATEGORY_CONFIG, TAG_INTERFACE_REALTIME_CAPTURE, TRUE) != NMERR_SUCCESS )
{
DestroyBlob( hFilterBlob);
goto error;
}
if ( SetBoolInBlob(hFilterBlob, OWNER_NPP, CATEGORY_LOCATION, TAG_RAS, TRUE) != NMERR_SUCCESS )
{
DestroyBlob( hFilterBlob);
goto error;
}
if ( GetNPPBlobTable(hFilterBlob, &pBlobTable) != NMERR_SUCCESS )
{
DestroyBlob( hFilterBlob);
goto error;
}
DestroyBlob (hFilterBlob);
if ( pBlobTable->dwNumBlobs == 0 || pBlobTable->dwNumBlobs > 1)
{
///fixme.....
for ( i = 0 ; i < pBlobTable->dwNumBlobs ; i++ )
DestroyBlob(pBlobTable->hBlobs[i]);
GlobalFree(pBlobTable);
goto error;
}
pWanAdapter->hCaptureBlob = pBlobTable->hBlobs[0];
GlobalFree(pBlobTable);
InitializeCriticalSection(&pWanAdapter->CriticalSection);
pWanAdapter->hReadEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if ( pWanAdapter->hReadEvent == NULL )
goto error;
pWanAdapter->MemEx.buffer = (PUCHAR)GlobalAlloc(GPTR, DEFAULT_MEM_EX_SIZE);
if (pWanAdapter->MemEx.buffer == NULL)
goto error;
pWanAdapter->MemEx.size = DEFAULT_MEM_EX_SIZE;
pWanAdapter->Tme.active = TME_NONE_ACTIVE;
if (CreateNPPInterface(pWanAdapter->hCaptureBlob, IID_IRTC, (void**) &pWanAdapter->pIRTC) == NMERR_SUCCESS && pWanAdapter->pIRTC != NULL)
{
//create OK
if (pWanAdapter->pIRTC->Connect(pWanAdapter->hCaptureBlob, NULL, WanPacketReceiverCallback, (LPVOID)pWanAdapter , NULL) == NMERR_SUCCESS)
{
//connect OK
if (pWanAdapter->pIRTC->Start() == NMERR_SUCCESS)
{
return pWanAdapter;
}
else
{
pWanAdapter->pIRTC->Disconnect();
pWanAdapter->pIRTC->Release();
goto error;
}
}
else
{
pWanAdapter->pIRTC->Release();
goto error;
}
}
else
{
goto error;
}
//awfully never reached
// return NULL;
error:
if (pWanAdapter != NULL)
{
if (pWanAdapter->hReadEvent != NULL)
CloseHandle(pWanAdapter->hReadEvent);
DeleteCriticalSection(&pWanAdapter->CriticalSection);
if (pWanAdapter->hCaptureBlob)
DestroyBlob(pWanAdapter->hCaptureBlob);
GlobalFree(pWanAdapter);
}
CoUninitialize();
return NULL;
}
/*!
\brief Tries to open the wan (dialup, vpn...) adapter, and immediately closes it.
\return TRUE on success.
*/
BOOLEAN WanPacketTestAdapter()
{
PBLOB_TABLE pBlobTable = NULL;
HBLOB hFilterBlob = NULL;
BOOLEAN retVal;
DWORD i;
HRESULT hResult;
if ( g_hModule == NULL)
{
g_hModule = LoadLibrary("npp\\ndisnpp.dll");
}
if ( g_hModule == NULL)
{
return FALSE;
}
hResult = CoInitialize(NULL);
//
// if the calling thread has already initialized COM with a
// different threading model, we have this error
// however, we are able to support another threading model,
// so we try to initialize COM with another threading model.
// This new call should succeed with S_FALSE.
//
if (hResult == RPC_E_CHANGED_MODE)
{
hResult = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
//MULTITHREADED threading is only supported on Windows 2000
if (hResult == RPC_E_CHANGED_MODE && IsWindows2000())
{
hResult = CoInitializeEx(NULL, COINIT_MULTITHREADED);
}
}
if (hResult != S_OK && hResult != S_FALSE)
return FALSE;
if ( CreateBlob(&hFilterBlob) != NMERR_SUCCESS )
{
CoUninitialize();
return FALSE;
}
if ( SetBoolInBlob(hFilterBlob, OWNER_NPP, CATEGORY_CONFIG, TAG_INTERFACE_REALTIME_CAPTURE, TRUE) != NMERR_SUCCESS )
{
DestroyBlob( hFilterBlob);
CoUninitialize();
return FALSE;
}
if ( SetBoolInBlob(hFilterBlob, OWNER_NPP, CATEGORY_LOCATION, TAG_RAS, TRUE) != NMERR_SUCCESS )
{
DestroyBlob( hFilterBlob);
CoUninitialize();
return FALSE;
}
if ( GetNPPBlobTable(hFilterBlob, &pBlobTable) != NMERR_SUCCESS )
{
DestroyBlob( hFilterBlob);
CoUninitialize();
return FALSE;
}
DestroyBlob (hFilterBlob);
if (pBlobTable->dwNumBlobs == 1)
retVal = TRUE;
else
retVal = FALSE;
for ( i = 0 ; i < pBlobTable->dwNumBlobs ; i++ )
DestroyBlob(pBlobTable->hBlobs[i]);
GlobalFree(pBlobTable);
CoUninitialize();
return retVal;
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d I C O N I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ReadICONImage() reads a Microsoft icon 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 ReadICONImage method is:
%
% Image *ReadICONImage(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 *ReadICONImage(const ImageInfo *image_info,
ExceptionInfo *exception)
{
IconFile
icon_file;
IconInfo
icon_info;
Image
*image;
MagickBooleanType
status;
register IndexPacket
*indexes;
register ssize_t
i,
x;
register PixelPacket
*q;
register unsigned char
*p;
size_t
bit,
byte,
bytes_per_line,
one,
scanline_pad;
ssize_t
count,
offset,
y;
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
(void) LogMagickEvent(CoderEvent,GetMagickModule(),"%s",image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AcquireImage(image_info);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
image=DestroyImageList(image);
return((Image *) NULL);
}
icon_file.reserved=(short) ReadBlobLSBShort(image);
icon_file.resource_type=(short) ReadBlobLSBShort(image);
icon_file.count=(short) ReadBlobLSBShort(image);
if ((icon_file.reserved != 0) ||
((icon_file.resource_type != 1) && (icon_file.resource_type != 2)) ||
(icon_file.count > MaxIcons))
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
for (i=0; i < icon_file.count; i++)
{
icon_file.directory[i].width=(unsigned char) ReadBlobByte(image);
icon_file.directory[i].height=(unsigned char) ReadBlobByte(image);
icon_file.directory[i].colors=(unsigned char) ReadBlobByte(image);
icon_file.directory[i].reserved=(unsigned char) ReadBlobByte(image);
icon_file.directory[i].planes=(unsigned short) ReadBlobLSBShort(image);
icon_file.directory[i].bits_per_pixel=(unsigned short)
ReadBlobLSBShort(image);
icon_file.directory[i].size=ReadBlobLSBLong(image);
icon_file.directory[i].offset=ReadBlobLSBLong(image);
}
one=1;
for (i=0; i < icon_file.count; i++)
{
/*
Verify Icon identifier.
*/
offset=(ssize_t) SeekBlob(image,(MagickOffsetType)
icon_file.directory[i].offset,SEEK_SET);
if (offset < 0)
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
icon_info.size=ReadBlobLSBLong(image);
icon_info.width=(unsigned char) ((int) ReadBlobLSBLong(image));
icon_info.height=(unsigned char) ((int) ReadBlobLSBLong(image)/2);
icon_info.planes=ReadBlobLSBShort(image);
icon_info.bits_per_pixel=ReadBlobLSBShort(image);
if ((icon_info.planes == 18505) && (icon_info.bits_per_pixel == 21060))
{
Image
*icon_image;
ImageInfo
*read_info;
size_t
length;
unsigned char
*png;
/*
Icon image encoded as a compressed PNG image.
*/
length=icon_file.directory[i].size;
png=(unsigned char *) AcquireQuantumMemory(length+16,sizeof(*png));
if (png == (unsigned char *) NULL)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
(void) CopyMagickMemory(png,"\211PNG\r\n\032\n\000\000\000\015",12);
png[12]=(unsigned char) icon_info.planes;
png[13]=(unsigned char) (icon_info.planes >> 8);
png[14]=(unsigned char) icon_info.bits_per_pixel;
png[15]=(unsigned char) (icon_info.bits_per_pixel >> 8);
count=ReadBlob(image,length-16,png+16);
if (count != (ssize_t) (length-16))
{
png=(unsigned char *) RelinquishMagickMemory(png);
ThrowReaderException(CorruptImageError,
"InsufficientImageDataInFile");
}
read_info=CloneImageInfo(image_info);
(void) CopyMagickString(read_info->magick,"PNG",MaxTextExtent);
icon_image=BlobToImage(read_info,png,length+16,exception);
read_info=DestroyImageInfo(read_info);
png=(unsigned char *) RelinquishMagickMemory(png);
if (icon_image == (Image *) NULL)
{
image=DestroyImageList(image);
return((Image *) NULL);
}
DestroyBlob(icon_image);
icon_image->blob=ReferenceBlob(image->blob);
ReplaceImageInList(&image,icon_image);
}
else
{
if (icon_info.bits_per_pixel > 32)
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% W r i t e I m a g e s %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% WriteImages() writes an image sequence.
%
% The format of the WriteImages method is:
%
% MagickBooleanType WriteImages(const ImageInfo *image_info,Image *images,
% const char *filename,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_info: the image info.
%
% o images: the image list.
%
% o filename: the image filename.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport MagickBooleanType WriteImages(const ImageInfo *image_info,
Image *images,const char *filename,ExceptionInfo *exception)
{
BlobInfo
*blob;
ExceptionInfo
*sans_exception;
ImageInfo
*write_info;
MagickStatusType
status;
register Image
*p;
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(images != (Image *) NULL);
assert(images->signature == MagickSignature);
if (images->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
assert(exception != (ExceptionInfo *) NULL);
write_info=CloneImageInfo(image_info);
images=GetFirstImageInList(images);
blob=CloneBlobInfo(images->blob); /* thread specific I/O handler */
DestroyBlob(images);
images->blob=blob;
if (filename != (const char *) NULL)
for (p=images; p != (Image *) NULL; p=GetNextImageInList(p))
(void) CopyMagickString(p->filename,filename,MaxTextExtent);
(void) CopyMagickString(write_info->filename,images->filename,MaxTextExtent);
if (*write_info->magick == '\0')
(void) CopyMagickString(write_info->magick,images->magick,MaxTextExtent);
sans_exception=AcquireExceptionInfo();
(void) SetImageInfo(write_info,MagickTrue,sans_exception);
sans_exception=DestroyExceptionInfo(sans_exception);
p=images;
for ( ; GetNextImageInList(p) != (Image *) NULL; p=GetNextImageInList(p))
if (p->scene >= GetNextImageInList(p)->scene)
{
register long
i;
/*
Generate consistent scene numbers.
*/
i=(long) images->scene;
for (p=images; p != (Image *) NULL; p=GetNextImageInList(p))
p->scene=(unsigned long) i++;
break;
}
/*
Write images.
*/
status=MagickTrue;
for (p=images; p != (Image *) NULL; p=GetNextImageInList(p))
{
status&=WriteImage(write_info,p);
GetImageException(p,exception);
if (write_info->adjoin != MagickFalse)
break;
}
write_info=DestroyImageInfo(write_info);
return(status != 0 ? MagickTrue : MagickFalse);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% W r i t e E P T I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% WriteEPTImage() writes an image in the Encapsulated Postscript format
% with a TIFF preview.
%
% The format of the WriteEPTImage method is:
%
% MagickBooleanType WriteEPTImage(const ImageInfo *image_info,Image *image)
%
% A description of each parameter follows.
%
% o image_info: the image info.
%
% o image: The image.
%
*/
static MagickBooleanType WriteEPTImage(const ImageInfo *image_info,Image *image)
{
EPTInfo
ept_info;
Image
*write_image;
ImageInfo
*write_info;
MagickBooleanType
status;
/*
Write EPT image.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
if (status == MagickFalse)
return(status);
write_image=CloneImage(image,0,0,MagickTrue,&image->exception);
if (write_image == (Image *) NULL)
return(MagickFalse);
DestroyBlob(write_image);
write_image->blob=CloneBlobInfo((BlobInfo *) NULL);
write_info=CloneImageInfo(image_info);
(void) CopyMagickString(write_info->magick,"EPS",MaxTextExtent);
if (LocaleCompare(image_info->magick,"EPT2") == 0)
(void) CopyMagickString(write_info->magick,"EPS2",MaxTextExtent);
if (LocaleCompare(image_info->magick,"EPT3") == 0)
(void) CopyMagickString(write_info->magick,"EPS3",MaxTextExtent);
(void) ResetMagickMemory(&ept_info,0,sizeof(ept_info));
ept_info.magick=0xc6d3d0c5ul;
ept_info.postscript=(unsigned char *) ImageToBlob(write_info,write_image,
&ept_info.postscript_length,&image->exception);
write_image=DestroyImage(write_image);
write_info=DestroyImageInfo(write_info);
if (ept_info.postscript == (void *) NULL)
return(MagickFalse);
write_image=CloneImage(image,0,0,MagickTrue,&image->exception);
if (write_image == (Image *) NULL)
return(MagickFalse);
DestroyBlob(write_image);
write_image->blob=CloneBlobInfo((BlobInfo *) NULL);
write_info=CloneImageInfo(image_info);
(void) CopyMagickString(write_info->magick,"TIFF",MaxTextExtent);
(void) FormatMagickString(write_info->filename,MaxTextExtent,"tiff:%.1024s",
write_info->filename);
(void) TransformImage(&write_image,(char *) NULL,"512x512>");
if ((write_image->storage_class == DirectClass) ||
(write_image->colors > 256))
{
QuantizeInfo
quantize_info;
/*
EPT preview requires that the image is colormapped.
*/
GetQuantizeInfo(&quantize_info);
quantize_info.dither=IsPaletteImage(write_image,&image->exception) ==
MagickFalse ? MagickTrue : MagickFalse;
(void) QuantizeImage(&quantize_info,write_image);
}
write_image->compression=NoCompression;
ept_info.tiff=(unsigned char *) ImageToBlob(write_info,write_image,
&ept_info.tiff_length,&image->exception);
write_image=DestroyImage(write_image);
write_info=DestroyImageInfo(write_info);
if (ept_info.tiff == (void *) NULL)
{
ept_info.postscript=(unsigned char *) RelinquishMagickMemory(
ept_info.postscript);
return(MagickFalse);
}
/*
Write EPT image.
*/
(void) WriteBlobLSBLong(image,ept_info.magick);
(void) WriteBlobLSBLong(image,30);
(void) WriteBlobLSBLong(image,(unsigned long) ept_info.postscript_length);
(void) WriteBlobLSBLong(image,0);
(void) WriteBlobLSBLong(image,0);
(void) WriteBlobLSBLong(image,(unsigned long) ept_info.postscript_length+30);
(void) WriteBlobLSBLong(image,(unsigned long) ept_info.tiff_length);
(void) WriteBlobLSBShort(image,0xffff);
(void) WriteBlob(image,ept_info.postscript_length,ept_info.postscript);
(void) WriteBlob(image,ept_info.tiff_length,ept_info.tiff);
/*
Relinquish resources.
*/
ept_info.postscript=(unsigned char *) RelinquishMagickMemory(
ept_info.postscript);
ept_info.tiff=(unsigned char *) RelinquishMagickMemory(ept_info.tiff);
(void) CloseBlob(image);
return(MagickTrue);
}
