/******************************************************************************
Put an extension block (see GIF manual) into a GIF file.
Warning: This function is only useful for Extension blocks that have at
most one subblock. Extensions with more than one subblock need to use the
EGifPutExtension{Leader,Block,Trailer} functions instead.
******************************************************************************/
int
EGifPutExtension(GifFileType *GifFile,
const int ExtCode,
const int ExtLen,
const void *Extension) {
GifByteType Buf[3];
GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
if (!IS_WRITEABLE(Private)) {
/* This file was NOT open for writing: */
GifFile->Error = E_GIF_ERR_NOT_WRITEABLE;
return GIF_ERROR;
}
if (ExtCode == 0)
InternalWrite(GifFile, (GifByteType *)&ExtLen, 1);
else {
Buf[0] = EXTENSION_INTRODUCER;
Buf[1] = ExtCode; /* Extension Label */
Buf[2] = ExtLen; /* Extension length */
InternalWrite(GifFile, Buf, 3);
}
InternalWrite(GifFile, Extension, ExtLen);
Buf[0] = 0;
InternalWrite(GifFile, Buf, 1);
return GIF_OK;
}
//----------------------------------------------------------------------------
void Write(Real x, Real y, Real z, unsigned int color,
const char *text, int count, FONT_ALIGN mode)
{
if (!mInitialized)
return;
auto& renderer = Renderer::GetInstance();
if (renderer.GetRendererOptions()->r_noText)
return;
//
if (count < 0)
count = GetTextLength(text);
if (mode == FONT_ALIGN_CENTER)
{
Real w = GetTextWidth(text, count);
x -= w / 2;
}
else if (mode == FONT_ALIGN_RIGHT)
{
Real w = GetTextWidth(text, count);
x -= w;
}
mColor = color;
renderer.UpdateObjectConstantsBuffer(&mObjectConstants);
InternalWrite(Round(x), Round(y), z, text, count);
}
/******************************************************************************
Put extension block data (see GIF manual) into a GIF file.
******************************************************************************/
int
EGifPutExtensionBlock(GifFileType *GifFile,
const int ExtLen,
const void *Extension)
{
GifByteType Buf;
GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
if (!IS_WRITEABLE(Private)) {
/* This file was NOT open for writing: */
GifFile->Error = E_GIF_ERR_NOT_WRITEABLE;
return GIF_ERROR;
}
Buf = ExtLen;
InternalWrite(GifFile, &Buf, 1);
InternalWrite(GifFile, Extension, ExtLen);
return GIF_OK;
}
/******************************************************************************
This routine should be called last, to close the GIF file.
******************************************************************************/
int
EGifCloseFile(GifFileType *GifFile)
{
GifByteType Buf;
GifFilePrivateType *Private;
FILE *File;
if (GifFile == NULL)
return GIF_ERROR;
Private = (GifFilePrivateType *) GifFile->Private;
if (Private == NULL)
return GIF_ERROR;
if (!IS_WRITEABLE(Private)) {
/* This file was NOT open for writing: */
GifFile->Error = E_GIF_ERR_NOT_WRITEABLE;
return GIF_ERROR;
}
File = Private->File;
Buf = TERMINATOR_INTRODUCER;
InternalWrite(GifFile, &Buf, 1);
if (GifFile->Image.ColorMap) {
GifFreeMapObject(GifFile->Image.ColorMap);
GifFile->Image.ColorMap = NULL;
}
if (GifFile->SColorMap) {
GifFreeMapObject(GifFile->SColorMap);
GifFile->SColorMap = NULL;
}
if (Private) {
if (Private->HashTable) {
free((char *) Private->HashTable);
}
free((char *) Private);
}
if (File && fclose(File) != 0) {
GifFile->Error = E_GIF_ERR_CLOSE_FAILED;
return GIF_ERROR;
}
/*
* Without the #ifndef, we get spurious warnings because Coverity mistakenly
* thinks the GIF structure is freed on an error return.
*/
#ifndef __COVERITY__
free(GifFile);
#endif /* __COVERITY__ */
return GIF_OK;
}
/******************************************************************************
Put 2 bytes (a word) into the given file in little-endian order:
******************************************************************************/
static int
EGifPutWord(int Word, GifFileType *GifFile)
{
unsigned char c[2];
c[0] = LOBYTE(Word);
c[1] = HIBYTE(Word);
if (InternalWrite(GifFile, c, 2) == 2)
return GIF_OK;
else
return GIF_ERROR;
}
/******************************************************************************
This routine should be called last, to close the GIF file.
******************************************************************************/
int
EGifCloseFile(GifFileType *GifFile, int *ErrorCode)
{
GifByteType Buf;
GifFilePrivateType *Private;
FILE *File;
if (GifFile == NULL)
return GIF_ERROR;
Private = (GifFilePrivateType *) GifFile->Private;
if (Private == NULL)
return GIF_ERROR;
if (!IS_WRITEABLE(Private)) {
/* This file was NOT open for writing: */
if (ErrorCode != NULL)
*ErrorCode = E_GIF_ERR_NOT_WRITEABLE;
free(GifFile);
return GIF_ERROR;
}
File = Private->File;
Buf = TERMINATOR_INTRODUCER;
InternalWrite(GifFile, &Buf, 1);
if (GifFile->Image.ColorMap) {
GifFreeMapObject(GifFile->Image.ColorMap);
GifFile->Image.ColorMap = NULL;
}
if (GifFile->SColorMap) {
GifFreeMapObject(GifFile->SColorMap);
GifFile->SColorMap = NULL;
}
if (Private) {
if (Private->HashTable) {
free((char *) Private->HashTable);
}
free((char *) Private);
}
if (File && fclose(File) != 0) {
if (ErrorCode != NULL)
*ErrorCode = E_GIF_ERR_CLOSE_FAILED;
free(GifFile);
return GIF_ERROR;
}
free(GifFile);
if (ErrorCode != NULL)
*ErrorCode = E_GIF_SUCCEEDED;
return GIF_OK;
}
/******************************************************************************
Continue to put the image code in compressed form. This routine should be
called with blocks of code as read via DGifGetCode/DGifGetCodeNext. If
given buffer pointer is NULL, empty block is written to mark end of code.
******************************************************************************/
int
EGifPutCodeNext(GifFileType *GifFile, const GifByteType *CodeBlock)
{
GifByteType Buf;
GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
if (CodeBlock != NULL) {
if ((unsigned)InternalWrite(GifFile, CodeBlock, CodeBlock[0] + 1)
!= (unsigned)(CodeBlock[0] + 1)) {
GifFile->Error = E_GIF_ERR_WRITE_FAILED;
return GIF_ERROR;
}
} else {
Buf = 0;
if (InternalWrite(GifFile, &Buf, 1) != 1) {
GifFile->Error = E_GIF_ERR_WRITE_FAILED;
return GIF_ERROR;
}
Private->PixelCount = 0; /* And local info. indicate image read. */
}
return GIF_OK;
}
/******************************************************************************
Put a terminating block (see GIF manual) into a GIF file.
******************************************************************************/
int
EGifPutExtensionTrailer(GifFileType *GifFile) {
GifByteType Buf;
GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
if (!IS_WRITEABLE(Private)) {
/* This file was NOT open for writing: */
GifFile->Error = E_GIF_ERR_NOT_WRITEABLE;
return GIF_ERROR;
}
/* Write the block terminator */
Buf = 0;
InternalWrite(GifFile, &Buf, 1);
return GIF_OK;
}
/******************************************************************************
Begin an extension block (see GIF manual). More
extensions can be dumped using EGifPutExtensionBlock until
EGifPutExtensionTrailer is invoked.
******************************************************************************/
int
EGifPutExtensionLeader(GifFileType *GifFile, const int ExtCode)
{
GifByteType Buf[3];
GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
if (!IS_WRITEABLE(Private)) {
/* This file was NOT open for writing: */
GifFile->Error = E_GIF_ERR_NOT_WRITEABLE;
return GIF_ERROR;
}
Buf[0] = EXTENSION_INTRODUCER;
Buf[1] = ExtCode;
InternalWrite(GifFile, Buf, 2);
return GIF_OK;
}
/******************************************************************************
Setup the LZ compression for this image:
******************************************************************************/
static int
EGifSetupCompress(GifFileType *GifFile)
{
int BitsPerPixel;
GifByteType Buf;
GifFilePrivateType *Private = (GifFilePrivateType *) GifFile->Private;
/* Test and see what color map to use, and from it # bits per pixel: */
if (GifFile->Image.ColorMap)
BitsPerPixel = GifFile->Image.ColorMap->BitsPerPixel;
else if (GifFile->SColorMap)
BitsPerPixel = GifFile->SColorMap->BitsPerPixel;
else {
GifFile->Error = E_GIF_ERR_NO_COLOR_MAP;
return GIF_ERROR;
}
Buf = BitsPerPixel = (BitsPerPixel < 2 ? 2 : BitsPerPixel);
InternalWrite(GifFile, &Buf, 1); /* Write the Code size to file. */
Private->Buf[0] = 0; /* Nothing was output yet. */
Private->BitsPerPixel = BitsPerPixel;
Private->ClearCode = (1 << BitsPerPixel);
Private->EOFCode = Private->ClearCode + 1;
Private->RunningCode = Private->EOFCode + 1;
Private->RunningBits = BitsPerPixel + 1; /* Number of bits per code. */
Private->MaxCode1 = 1 << Private->RunningBits; /* Max. code + 1. */
Private->CrntCode = FIRST_CODE; /* Signal that this is first one! */
Private->CrntShiftState = 0; /* No information in CrntShiftDWord. */
Private->CrntShiftDWord = 0;
/* Clear hash table and send Clear to make sure the decoder do the same. */
_ClearHashTable(Private->HashTable);
if (EGifCompressOutput(GifFile, Private->ClearCode) == GIF_ERROR) {
GifFile->Error = E_GIF_ERR_DISK_IS_FULL;
return GIF_ERROR;
}
return GIF_OK;
}
/******************************************************************************
This routine should be called before any attempt to dump an image - any
call to any of the pixel dump routines.
******************************************************************************/
int
EGifPutImageDesc(GifFileType *GifFile,
const int Left,
const int Top,
const int Width,
const int Height,
const bool Interlace,
const ColorMapObject *ColorMap)
{
GifByteType Buf[3];
GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
if (Private->FileState & FILE_STATE_IMAGE &&
Private->PixelCount > 0xffff0000UL) {
/* If already has active image descriptor - something is wrong! */
GifFile->Error = E_GIF_ERR_HAS_IMAG_DSCR;
return GIF_ERROR;
}
if (!IS_WRITEABLE(Private)) {
/* This file was NOT open for writing: */
GifFile->Error = E_GIF_ERR_NOT_WRITEABLE;
return GIF_ERROR;
}
GifFile->Image.Left = Left;
GifFile->Image.Top = Top;
GifFile->Image.Width = Width;
GifFile->Image.Height = Height;
GifFile->Image.Interlace = Interlace;
if (ColorMap) {
if (GifFile->Image.ColorMap != NULL) {
GifFreeMapObject(GifFile->Image.ColorMap);
GifFile->Image.ColorMap = NULL;
}
GifFile->Image.ColorMap = GifMakeMapObject(ColorMap->ColorCount,
ColorMap->Colors);
if (GifFile->Image.ColorMap == NULL) {
GifFile->Error = E_GIF_ERR_NOT_ENOUGH_MEM;
return GIF_ERROR;
}
} else {
GifFile->Image.ColorMap = NULL;
}
/* Put the image descriptor into the file: */
Buf[0] = DESCRIPTOR_INTRODUCER; /* Image separator character. */
InternalWrite(GifFile, Buf, 1);
(void)EGifPutWord(Left, GifFile);
(void)EGifPutWord(Top, GifFile);
(void)EGifPutWord(Width, GifFile);
(void)EGifPutWord(Height, GifFile);
Buf[0] = (ColorMap ? 0x80 : 0x00) |
(Interlace ? 0x40 : 0x00) |
(ColorMap ? ColorMap->BitsPerPixel - 1 : 0);
InternalWrite(GifFile, Buf, 1);
/* If we have Global color map - dump it also: */
if (ColorMap != NULL) {
int i;
for (i = 0; i < ColorMap->ColorCount; i++) {
/* Put the ColorMap out also: */
Buf[0] = ColorMap->Colors[i].Red;
Buf[1] = ColorMap->Colors[i].Green;
Buf[2] = ColorMap->Colors[i].Blue;
if (InternalWrite(GifFile, Buf, 3) != 3) {
GifFile->Error = E_GIF_ERR_WRITE_FAILED;
return GIF_ERROR;
}
}
}
if (GifFile->SColorMap == NULL && GifFile->Image.ColorMap == NULL) {
GifFile->Error = E_GIF_ERR_NO_COLOR_MAP;
return GIF_ERROR;
}
/* Mark this file as has screen descriptor: */
Private->FileState |= FILE_STATE_IMAGE;
Private->PixelCount = (long)Width *(long)Height;
/* Reset compress algorithm parameters. */
(void)EGifSetupCompress(GifFile);
return GIF_OK;
}
/******************************************************************************
This routine should be called before any other EGif calls, immediately
following the GIF file opening.
******************************************************************************/
int
EGifPutScreenDesc(GifFileType *GifFile,
const int Width,
const int Height,
const int ColorRes,
const int BackGround,
const ColorMapObject *ColorMap)
{
GifByteType Buf[3];
GifFilePrivateType *Private = (GifFilePrivateType *) GifFile->Private;
const char *write_version;
if (Private->FileState & FILE_STATE_SCREEN) {
/* If already has screen descriptor - something is wrong! */
GifFile->Error = E_GIF_ERR_HAS_SCRN_DSCR;
return GIF_ERROR;
}
if (!IS_WRITEABLE(Private)) {
/* This file was NOT open for writing: */
GifFile->Error = E_GIF_ERR_NOT_WRITEABLE;
return GIF_ERROR;
}
write_version = EGifGetGifVersion(GifFile);
/* First write the version prefix into the file. */
if ((unsigned int)InternalWrite(GifFile, (unsigned char *)write_version,
strlen(write_version)) != strlen(write_version)) {
GifFile->Error = E_GIF_ERR_WRITE_FAILED;
return GIF_ERROR;
}
GifFile->SWidth = Width;
GifFile->SHeight = Height;
GifFile->SColorResolution = ColorRes;
GifFile->SBackGroundColor = BackGround;
if (ColorMap) {
GifFile->SColorMap = GifMakeMapObject(ColorMap->ColorCount,
ColorMap->Colors);
if (GifFile->SColorMap == NULL) {
GifFile->Error = E_GIF_ERR_NOT_ENOUGH_MEM;
return GIF_ERROR;
}
} else
GifFile->SColorMap = NULL;
/*
* Put the logical screen descriptor into the file:
*/
/* Logical Screen Descriptor: Dimensions */
(void)EGifPutWord(Width, GifFile);
(void)EGifPutWord(Height, GifFile);
/* Logical Screen Descriptor: Packed Fields */
/* Note: We have actual size of the color table default to the largest
* possible size (7+1 == 8 bits) because the decoder can use it to decide
* how to display the files.
*/
Buf[0] = (ColorMap ? 0x80 : 0x00) | /* Yes/no global colormap */
((ColorRes - 1) << 4) | /* Bits allocated to each primary color */
(ColorMap ? ColorMap->BitsPerPixel - 1 : 0x07 ); /* Actual size of the
color table. */
if (ColorMap != NULL && ColorMap->SortFlag)
Buf[0] |= 0x08;
Buf[1] = BackGround; /* Index into the ColorTable for background color */
Buf[2] = GifFile->AspectByte; /* Pixel Aspect Ratio */
InternalWrite(GifFile, Buf, 3);
/* If we have Global color map - dump it also: */
if (ColorMap != NULL) {
int i;
for (i = 0; i < ColorMap->ColorCount; i++) {
/* Put the ColorMap out also: */
Buf[0] = ColorMap->Colors[i].Red;
Buf[1] = ColorMap->Colors[i].Green;
Buf[2] = ColorMap->Colors[i].Blue;
if (InternalWrite(GifFile, Buf, 3) != 3) {
GifFile->Error = E_GIF_ERR_WRITE_FAILED;
return GIF_ERROR;
}
}
}
/* Mark this file as has screen descriptor, and no pixel written yet: */
Private->FileState |= FILE_STATE_SCREEN;
return GIF_OK;
}
void CommandBuffer::Write(const char* in, size_t len, size_t offset) {
InternalWrite(writerOffset + offset, in, len);
}
