CGIF

Complexity

Total Complexity

67

Size/Duplication

Total Lines	377
Duplicated Lines	0 %

Importance

Changes	4
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	ndword()	0	4	1
A	dword()	0	4	1
D	getPng()	0	97	18
A	loaded()	0	3	1
A	comment()	0	3	1
A	__construct()	0	6	1
A	height()	0	3	1
A	width()	0	3	1
A	getSize()	0	16	3
C	getGD_PixelPlotterVersion()	0	55	14
F	getBmp()	0	96	19
A	loadFile()	0	29	6

<?php
///////////////////////////////////////////////////////////////////////////////////////////////////
// GIF Util - (C) 2003 Yamasoft (S/C)
// http://www.yamasoft.com
// All Rights Reserved
// This file can be freely copied, distributed, modified, updated by anyone under the only
// condition to leave the original address (Yamasoft, http://www.yamasoft.com) and this header.
///////////////////////////////////////////////////////////////////////////////////////////////////
// <gif>  = gif_loadFile(filename, [index])
// <bool> = gif_getSize(<gif> or filename, &width, &height)
// <bool> = gif_outputAsPng(<gif>, filename, [bgColor])
// <bool> = gif_outputAsBmp(<gif>, filename, [bgcolor])
// <bool> = gif_outputAsJpeg(<gif>, filename, [bgcolor]) - use cjpeg if available otherwise uses GD
///////////////////////////////////////////////////////////////////////////////////////////////////
// Original code by Fabien Ezber
// Modified by James Heinrich <info@silisoftware.com> for use in phpThumb() - December 10, 2003
// * Added function gif_loadFileToGDimageResource() - this returns a GD image resource
// * Modified gif_outputAsJpeg() to check if it's running under Windows, or if cjpeg is not
//   available, in which case it will attempt to output JPEG using GD functions
// * added @ error-suppression to two lines where it checks: if ($this->m_img->m_bTrans)
//   otherwise warnings are generated if error_reporting == E_ALL
///////////////////////////////////////////////////////////////////////////////////////////////////

function gif_loadFile($lpszFileName, $iIndex = 0)
{
	$gif = new CGIF();
	if ($gif->loadFile($lpszFileName, $iIndex)) {
		return $gif;
	}
	return false;
}

///////////////////////////////////////////////////////////////////////////////////////////////////

// Added by James Heinrich <info@silisoftware.com> - December 10, 2003
function gif_loadFileToGDimageResource($gifFilename, $bgColor = -1)
{
	if ($gif = gif_loadFile($gifFilename)) {

		if (!phpthumb_functions::FunctionIsDisabled('set_time_limit')) {
			// shouldn't take nearly this long
			set_time_limit(120);
		}
		// general strategy: convert raw data to PNG then convert PNG data to GD image resource
		$PNGdata = $gif->getPng($bgColor);
		if ($img = @imagecreatefromstring($PNGdata)) {

It seems like $PNGdata can also be of type false; however, parameter $image of imagecreatefromstring() does only seem to accept string, maybe add an additional type check?

			// excellent - PNG image data successfully converted to GD image
			return $img;

		} elseif ($img = $gif->getGD_PixelPlotterVersion()) {

			// problem: imagecreatefromstring() didn't like the PNG image data.
			//   This has been known to happen in PHP v4.0.6
			// solution: take the raw image data and create a new GD image and plot
			//   pixel-by-pixel on the GD image. This is extremely slow, but it does
			//   work and a slow solution is better than no solution, right? :)
			return $img;

		}
	}
	return false;
}

///////////////////////////////////////////////////////////////////////////////////////////////////

function gif_outputAsBmp($gif, $lpszFileName, $bgColor = -1)
{
	if (!isset($gif) || (@get_class($gif) <> 'cgif') || !$gif->loaded() || ($lpszFileName == '')) {
		return false;
	}

	$fd = $gif->getBmp($bgColor);
	if (strlen($fd) <= 0) {
		return false;
	}

	if (!($fh = @fopen($lpszFileName, 'wb'))) {
		return false;
	}
	@fwrite($fh, $fd, strlen($fd));

It seems like you do not handle an error condition for fwrite(). This can introduce security issues, and is generally not recommended.

	@fflush($fh);

It seems like you do not handle an error condition for fflush(). This can introduce security issues, and is generally not recommended.

	@fclose($fh);

It seems like you do not handle an error condition for fclose(). This can introduce security issues, and is generally not recommended.

	return true;
}

///////////////////////////////////////////////////////////////////////////////////////////////////

function gif_outputAsPng($gif, $lpszFileName, $bgColor = -1)
{
	if (!isSet($gif) || (@get_class($gif) <> 'cgif') || !$gif->loaded() || ($lpszFileName == '')) {
		return false;
	}

	$fd = $gif->getPng($bgColor);
	if (strlen($fd) <= 0) {
		return false;
	}

	if (!($fh = @fopen($lpszFileName, 'wb'))) {
		return false;
	}
	@fwrite($fh, $fd, strlen($fd));

It seems like you do not handle an error condition for fwrite(). This can introduce security issues, and is generally not recommended.

	@fflush($fh);

It seems like you do not handle an error condition for fflush(). This can introduce security issues, and is generally not recommended.

	@fclose($fh);

It seems like you do not handle an error condition for fclose(). This can introduce security issues, and is generally not recommended.

	return true;
}

///////////////////////////////////////////////////////////////////////////////////////////////////

function gif_outputAsJpeg($gif, $lpszFileName, $bgColor = -1)
{
	// JPEG output that does not require cjpeg added by James Heinrich <info@silisoftware.com> - December 10, 2003
	if ((strtoupper(substr(PHP_OS, 0, 3)) != 'WIN') && (file_exists('/usr/local/bin/cjpeg') || shell_exec('which cjpeg'))) {

		if (gif_outputAsBmp($gif, $lpszFileName.'.bmp', $bgColor)) {
			exec('cjpeg '.$lpszFileName.'.bmp >'.$lpszFileName.' 2>/dev/null');
			@unlink($lpszFileName.'.bmp');

It seems like you do not handle an error condition for unlink(). This can introduce security issues, and is generally not recommended.

			if (@file_exists($lpszFileName)) {
				if (@filesize($lpszFileName) > 0) {
					return true;
				}

				@unlink($lpszFileName);
			}
		}

	} else {

		// either Windows, or cjpeg not found in path
		if ($img = @imagecreatefromstring($gif->getPng($bgColor))) {
			if (@imagejpeg($img, $lpszFileName)) {
				return true;
			}
		}

	}

	return false;
}

///////////////////////////////////////////////////////////////////////////////////////////////////

function gif_getSize($gif, &$width, &$height)
{
	if (isSet($gif) && (@get_class($gif) == 'cgif') && $gif->loaded()) {
		$width  = $gif->width();
		$height = $gif->height();
	} elseif (@file_exists($gif)) {
		$myGIF = new CGIF();
		if (!$myGIF->getSize($gif, $width, $height)) {
			return false;
		}
	} else {
		return false;
	}

	return true;
}

///////////////////////////////////////////////////////////////////////////////////////////////////

class CGIFLZW
{
	public $MAX_LZW_BITS;
	public $Fresh, $CodeSize, $SetCodeSize, $MaxCode, $MaxCodeSize, $FirstCode, $OldCode;
	public $ClearCode, $EndCode, $Next, $Vals, $Stack, $sp, $Buf, $CurBit, $LastBit, $Done, $LastByte;

	///////////////////////////////////////////////////////////////////////////

	// CONSTRUCTOR
	public function __construct()
	{
		$this->MAX_LZW_BITS = 12;
		unSet($this->Next);
		unSet($this->Vals);
		unSet($this->Stack);
		unSet($this->Buf);

		$this->Next  = range(0, (1 << $this->MAX_LZW_BITS)       - 1);
		$this->Vals  = range(0, (1 << $this->MAX_LZW_BITS)       - 1);
		$this->Stack = range(0, (1 << ($this->MAX_LZW_BITS + 1)) - 1);
		$this->Buf   = range(0, 279);
	}

	///////////////////////////////////////////////////////////////////////////

	public function deCompress($data, &$datLen)
	{
		$stLen  = strlen($data);
		$datLen = 0;
		$ret    = '';

		// INITIALIZATION
		$this->LZWCommand($data, true);

		while (($iIndex = $this->LZWCommand($data, false)) >= 0) {
			$ret .= chr($iIndex);
		}

		$datLen = $stLen - strlen($data);

		if ($iIndex != -2) {
			return false;
		}

		return $ret;
	}

	///////////////////////////////////////////////////////////////////////////

	public function LZWCommand(&$data, $bInit)
	{
		if ($bInit) {
			$this->SetCodeSize = ord($data[0]);
			$data = substr($data, 1);

			$this->CodeSize    = $this->SetCodeSize + 1;
			$this->ClearCode   = 1 << $this->SetCodeSize;
			$this->EndCode     = $this->ClearCode + 1;
			$this->MaxCode     = $this->ClearCode + 2;
			$this->MaxCodeSize = $this->ClearCode << 1;

			$this->GetCode($data, $bInit);

			$this->Fresh = 1;
			for ($i = 0; $i < $this->ClearCode; $i++) {
				$this->Next[$i] = 0;
				$this->Vals[$i] = $i;
			}

			for (; $i < (1 << $this->MAX_LZW_BITS); $i++) {
				$this->Next[$i] = 0;
				$this->Vals[$i] = 0;
			}

			$this->sp = 0;
			return 1;
		}

		if ($this->Fresh) {
			$this->Fresh = 0;
			do {
				$this->FirstCode = $this->GetCode($data, $bInit);
				$this->OldCode   = $this->FirstCode;
			}
			while ($this->FirstCode == $this->ClearCode);

			return $this->FirstCode;
		}

		if ($this->sp > 0) {
			$this->sp--;
			return $this->Stack[$this->sp];
		}

		while (($Code = $this->GetCode($data, $bInit)) >= 0) {
			if ($Code == $this->ClearCode) {
				for ($i = 0; $i < $this->ClearCode; $i++) {
					$this->Next[$i] = 0;
					$this->Vals[$i] = $i;
				}

				for (; $i < (1 << $this->MAX_LZW_BITS); $i++) {
					$this->Next[$i] = 0;
					$this->Vals[$i] = 0;
				}

				$this->CodeSize    = $this->SetCodeSize + 1;
				$this->MaxCodeSize = $this->ClearCode << 1;
				$this->MaxCode     = $this->ClearCode + 2;
				$this->sp          = 0;
				$this->FirstCode   = $this->GetCode($data, $bInit);
				$this->OldCode     = $this->FirstCode;

				return $this->FirstCode;
			}

			if ($Code == $this->EndCode) {
				return -2;
			}

			$InCode = $Code;
			if ($Code >= $this->MaxCode) {
				$this->Stack[$this->sp] = $this->FirstCode;
				$this->sp++;
				$Code = $this->OldCode;
			}

			while ($Code >= $this->ClearCode) {
				$this->Stack[$this->sp] = $this->Vals[$Code];
				$this->sp++;

				if ($Code == $this->Next[$Code]) // Circular table entry, big GIF Error!
					return -1;

				$Code = $this->Next[$Code];
			}

			$this->FirstCode = $this->Vals[$Code];
			$this->Stack[$this->sp] = $this->FirstCode;
			$this->sp++;

			if (($Code = $this->MaxCode) < (1 << $this->MAX_LZW_BITS)) {
				$this->Next[$Code] = $this->OldCode;
				$this->Vals[$Code] = $this->FirstCode;
				$this->MaxCode++;

				if (($this->MaxCode >= $this->MaxCodeSize) && ($this->MaxCodeSize < (1 << $this->MAX_LZW_BITS))) {
					$this->MaxCodeSize *= 2;
					$this->CodeSize++;
				}
			}

			$this->OldCode = $InCode;
			if ($this->sp > 0) {
				$this->sp--;
				return $this->Stack[$this->sp];
			}
		}

		return $Code;
	}

	///////////////////////////////////////////////////////////////////////////

	public function GetCode(&$data, $bInit)
	{
		if ($bInit) {
			$this->CurBit   = 0;
			$this->LastBit  = 0;
			$this->Done     = 0;
			$this->LastByte = 2;
			return 1;
		}

		if (($this->CurBit + $this->CodeSize) >= $this->LastBit) {
			if ($this->Done) {
				if ($this->CurBit >= $this->LastBit) {
					// Ran off the end of my bits
					return 0;
				}
				return -1;
			}

			$this->Buf[0] = $this->Buf[$this->LastByte - 2];
			$this->Buf[1] = $this->Buf[$this->LastByte - 1];

			$Count = ord($data[0]);
			$data  = substr($data, 1);

			if ($Count) {
				for ($i = 0; $i < $Count; $i++) {
					$this->Buf[2 + $i] = ord($data[$i]);
				}
				$data = substr($data, $Count);
			} else {
				$this->Done = 1;
			}

			$this->LastByte = 2 + $Count;
			$this->CurBit   = ($this->CurBit - $this->LastBit) + 16;
			$this->LastBit  = (2 + $Count) << 3;
		}

		$iRet = 0;
		for ($i = $this->CurBit, $j = 0; $j < $this->CodeSize; $i++, $j++) {
			$iRet |= (($this->Buf[ (int) ($i / 8) ] & (1 << ($i % 8))) != 0) << $j;
		}

		$this->CurBit += $this->CodeSize;
		return $iRet;
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////

class CGIFCOLORTABLE
{
	public $m_nColors;
	public $m_arColors;

	///////////////////////////////////////////////////////////////////////////

	// CONSTRUCTOR
	public function __construct()
	{
		unSet($this->m_nColors);
		unSet($this->m_arColors);
	}

	///////////////////////////////////////////////////////////////////////////

	public function load($lpData, $num)
	{
		$this->m_nColors  = 0;
		$this->m_arColors = array();

		for ($i = 0; $i < $num; $i++) {
			$rgb = substr($lpData, $i * 3, 3);
			if (strlen($rgb) < 3) {
				return false;
			}

			$this->m_arColors[] = (ord($rgb[2]) << 16) + (ord($rgb[1]) << 8) + ord($rgb[0]);
			$this->m_nColors++;
		}

		return true;
	}

	///////////////////////////////////////////////////////////////////////////

	public function toString()
	{
		$ret = '';

		for ($i = 0; $i < $this->m_nColors; $i++) {
			$ret .=
				chr($this->m_arColors[ $i] & 0x000000FF)       . // R
				chr(($this->m_arColors[$i] & 0x0000FF00) >>  8) . // G
				chr(($this->m_arColors[$i] & 0x00FF0000) >> 16);  // B
		}

		return $ret;
	}

	///////////////////////////////////////////////////////////////////////////

	public function toRGBQuad()
	{
		$ret = '';

		for ($i = 0; $i < $this->m_nColors; $i++) {
			$ret .=
				chr(($this->m_arColors[$i] & 0x00FF0000) >> 16) . // B
				chr(($this->m_arColors[$i] & 0x0000FF00) >>  8) . // G
				chr($this->m_arColors[ $i] & 0x000000FF)       . // R
				"\x00";
		}

		return $ret;
	}

	///////////////////////////////////////////////////////////////////////////

	public function colorIndex($rgb)
	{
		$rgb = (int) $rgb & 0xFFFFFF;
		$r1  = ($rgb & 0x0000FF);
		$g1  = ($rgb & 0x00FF00) >>  8;
		$b1  = ($rgb & 0xFF0000) >> 16;
		$idx = -1;
		$dif = 0;

		for ($i = 0; $i < $this->m_nColors; $i++) {
			$r2 = ($this->m_arColors[$i] & 0x000000FF);
			$g2 = ($this->m_arColors[$i] & 0x0000FF00) >>  8;
			$b2 = ($this->m_arColors[$i] & 0x00FF0000) >> 16;
			$d  = abs($r2 - $r1) + abs($g2 - $g1) + abs($b2 - $b1);

			if (($idx == -1) || ($d < $dif)) {
				$idx = $i;
				$dif = $d;
			}
		}

		return $idx;
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////

class CGIFFILEHEADER
{
	public $m_lpVer;
	public $m_nWidth;
	public $m_nHeight;
	public $m_bGlobalClr;
	public $m_nColorRes;
	public $m_bSorted;
	public $m_nTableSize;
	public $m_nBgColor;
	public $m_nPixelRatio;
	public $m_colorTable;

	///////////////////////////////////////////////////////////////////////////

	// CONSTRUCTOR
	public function __construct()
	{
		unSet($this->m_lpVer);
		unSet($this->m_nWidth);
		unSet($this->m_nHeight);
		unSet($this->m_bGlobalClr);
		unSet($this->m_nColorRes);
		unSet($this->m_bSorted);
		unSet($this->m_nTableSize);
		unSet($this->m_nBgColor);
		unSet($this->m_nPixelRatio);
		unSet($this->m_colorTable);
	}

	///////////////////////////////////////////////////////////////////////////

	public function load($lpData, &$hdrLen)
	{
		$hdrLen = 0;

		$this->m_lpVer = substr($lpData, 0, 6);
		if (($this->m_lpVer <> 'GIF87a') && ($this->m_lpVer <> 'GIF89a')) {
			return false;
		}

		$this->m_nWidth  = $this->w2i(substr($lpData, 6, 2));
		$this->m_nHeight = $this->w2i(substr($lpData, 8, 2));
		if (!$this->m_nWidth || !$this->m_nHeight) {
			return false;
		}

		$b = ord($lpData[ 10 ]);
		$this->m_bGlobalClr  = ($b & 0x80) ? true : false;
		$this->m_nColorRes   = ($b & 0x70) >> 4;
		$this->m_bSorted     = ($b & 0x08) ? true : false;
		$this->m_nTableSize  = 2 << ($b & 0x07);
		$this->m_nBgColor    = ord($lpData[ 11 ]);
		$this->m_nPixelRatio = ord($lpData[ 12 ]);
		$hdrLen = 13;

		if ($this->m_bGlobalClr) {
			$this->m_colorTable = new CGIFCOLORTABLE();
			if (!$this->m_colorTable->load(substr($lpData, $hdrLen), $this->m_nTableSize)) {
				return false;
			}
			$hdrLen += 3 * $this->m_nTableSize;
		}

		return true;
	}

	///////////////////////////////////////////////////////////////////////////

	public function w2i($str)
	{
		return ord($str[ 0 ]) + (ord($str[ 1 ]) << 8);
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////

class CGIFIMAGEHEADER
{
	public $m_nLeft;
	public $m_nTop;
	public $m_nWidth;
	public $m_nHeight;
	public $m_bLocalClr;
	public $m_bInterlace;
	public $m_bSorted;
	public $m_nTableSize;
	public $m_colorTable;

	///////////////////////////////////////////////////////////////////////////

	// CONSTRUCTOR
	public function __construct()
	{
		unSet($this->m_nLeft);
		unSet($this->m_nTop);
		unSet($this->m_nWidth);
		unSet($this->m_nHeight);
		unSet($this->m_bLocalClr);
		unSet($this->m_bInterlace);
		unSet($this->m_bSorted);
		unSet($this->m_nTableSize);
		unSet($this->m_colorTable);
	}

	///////////////////////////////////////////////////////////////////////////

	public function load($lpData, &$hdrLen)
	{
		$hdrLen = 0;

		$this->m_nLeft   = $this->w2i(substr($lpData, 0, 2));
		$this->m_nTop    = $this->w2i(substr($lpData, 2, 2));
		$this->m_nWidth  = $this->w2i(substr($lpData, 4, 2));
		$this->m_nHeight = $this->w2i(substr($lpData, 6, 2));

		if (!$this->m_nWidth || !$this->m_nHeight) {
			return false;
		}

		$b = ord($lpData[8]);
		$this->m_bLocalClr  = ($b & 0x80) ? true : false;
		$this->m_bInterlace = ($b & 0x40) ? true : false;
		$this->m_bSorted    = ($b & 0x20) ? true : false;
		$this->m_nTableSize = 2 << ($b & 0x07);
		$hdrLen = 9;

		if ($this->m_bLocalClr) {
			$this->m_colorTable = new CGIFCOLORTABLE();
			if (!$this->m_colorTable->load(substr($lpData, $hdrLen), $this->m_nTableSize)) {
				return false;
			}
			$hdrLen += 3 * $this->m_nTableSize;
		}

		return true;
	}

	///////////////////////////////////////////////////////////////////////////

	public function w2i($str)
	{
		return ord($str[ 0 ]) + (ord($str[ 1 ]) << 8);
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////

class CGIFIMAGE
{
	public $m_disp;
	public $m_bUser;
	public $m_bTrans;
	public $m_nDelay;
	public $m_nTrans;
	public $m_lpComm;
	public $m_gih;
	public $m_data;
	public $m_lzw;

	///////////////////////////////////////////////////////////////////////////

	public function __construct()
	{
		unSet($this->m_disp);
		unSet($this->m_bUser);
		unSet($this->m_bTrans);
		unSet($this->m_nDelay);
		unSet($this->m_nTrans);
		unSet($this->m_lpComm);
		unSet($this->m_data);
		$this->m_gih = new CGIFIMAGEHEADER();
		$this->m_lzw = new CGIFLZW();
	}

	///////////////////////////////////////////////////////////////////////////

	public function load($data, &$datLen)
	{
		$datLen = 0;

		while (true) {
			$b = ord($data[0]);
			$data = substr($data, 1);
			$datLen++;

			switch($b) {
			case 0x21: // Extension
				if (!$this->skipExt($data, $len = 0)) {

$len = 0 cannot be passed to CGIFIMAGE::skipExt() as the parameter $extLen expects a reference.

					return false;
				}
				$datLen += $len;
				break;

			case 0x2C: // Image
				// LOAD HEADER & COLOR TABLE
				if (!$this->m_gih->load($data, $len = 0)) {

$len = 0 cannot be passed to CGIFIMAGEHEADER::load() as the parameter $hdrLen expects a reference.

					return false;
				}
				$data = substr($data, $len);
				$datLen += $len;

				// ALLOC BUFFER
				if (!($this->m_data = $this->m_lzw->deCompress($data, $len = 0))) {

$len = 0 cannot be passed to CGIFLZW::deCompress() as the parameter $datLen expects a reference.

					return false;
				}
				$data = substr($data, $len);

The assignment to $data is dead and can be removed.

				$datLen += $len;

				if ($this->m_gih->m_bInterlace) {
					$this->deInterlace();
				}
				return true;

			case 0x3B: // EOF
			default:
				return false;
			}
		}
		return false;
	}

	///////////////////////////////////////////////////////////////////////////

	public function skipExt(&$data, &$extLen)
	{
		$extLen = 0;

		$b = ord($data[0]);
		$data = substr($data, 1);
		$extLen++;

		switch($b) {
		case 0xF9: // Graphic Control
			$b = ord($data[1]);
			$this->m_disp   = ($b & 0x1C) >> 2;
			$this->m_bUser  = ($b & 0x02) ? true : false;
			$this->m_bTrans = ($b & 0x01) ? true : false;
			$this->m_nDelay = $this->w2i(substr($data, 2, 2));
			$this->m_nTrans = ord($data[4]);
			break;

		case 0xFE: // Comment
			$this->m_lpComm = substr($data, 1, ord($data[0]));
			break;

		case 0x01: // Plain text
			break;

		case 0xFF: // Application
			break;
		}

		// SKIP DEFAULT AS DEFS MAY CHANGE
		$b = ord($data[0]);
		$data = substr($data, 1);
		$extLen++;
		while ($b > 0) {
			$data = substr($data, $b);
			$extLen += $b;
			$b    = ord($data[0]);
			$data = substr($data, 1);
			$extLen++;
		}
		return true;
	}

	///////////////////////////////////////////////////////////////////////////

	public function w2i($str)
	{
		return ord($str[ 0 ]) + (ord($str[ 1 ]) << 8);
	}

	///////////////////////////////////////////////////////////////////////////

	public function deInterlace()
	{
		$data = $this->m_data;
		$s = 0;
		$y = 0;

		for ($i = 0; $i < 4; $i++) {
			switch($i) {
			case 0:
				$s = 8;
				$y = 0;
				break;

			case 1:
				$s = 8;
				$y = 4;
				break;

			case 2:
				$s = 4;
				$y = 2;
				break;

			case 3:
				$s = 2;
				$y = 1;
				break;
			}

			for (; $y < $this->m_gih->m_nHeight; $y += $s) {
				$lne = substr($this->m_data, 0, $this->m_gih->m_nWidth);
				$this->m_data = substr($this->m_data, $this->m_gih->m_nWidth);

				$data =
					substr($data, 0, $y * $this->m_gih->m_nWidth) .
					$lne .
					substr($data, ($y + 1) * $this->m_gih->m_nWidth);
			}
		}

		$this->m_data = $data;
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////

class CGIF
{
	public $m_gfh;
	public $m_lpData;
	public $m_img;
	public $m_bLoaded;

	///////////////////////////////////////////////////////////////////////////

	// CONSTRUCTOR
	public function __construct()
	{
		$this->m_gfh     = new CGIFFILEHEADER();
		$this->m_img     = new CGIFIMAGE();
		$this->m_lpData  = '';
		$this->m_bLoaded = false;
	}

	///////////////////////////////////////////////////////////////////////////

	public function loadFile($lpszFileName, $iIndex)
	{
		if ($iIndex < 0) {
			return false;
		}

		// READ FILE
		if (!($fh = @fopen($lpszFileName, 'rb'))) {
			return false;
		}
		$this->m_lpData = @fread($fh, @filesize($lpszFileName));
		fclose($fh);

		// GET FILE HEADER
		if (!$this->m_gfh->load($this->m_lpData, $len = 0)) {

$len = 0 cannot be passed to CGIFFILEHEADER::load() as the parameter $hdrLen expects a reference.

			return false;
		}
		$this->m_lpData = substr($this->m_lpData, $len);

		do {
			if (!$this->m_img->load($this->m_lpData, $imgLen = 0)) {

$imgLen = 0 cannot be passed to CGIFIMAGE::load() as the parameter $datLen expects a reference.

				return false;
			}
			$this->m_lpData = substr($this->m_lpData, $imgLen);
		}
		while ($iIndex-- > 0);

		$this->m_bLoaded = true;
		return true;
	}

	///////////////////////////////////////////////////////////////////////////

	public function getSize($lpszFileName, &$width, &$height)
	{
		if (!($fh = @fopen($lpszFileName, 'rb'))) {
			return false;
		}
		$data = @fread($fh, @filesize($lpszFileName));
		@fclose($fh);

It seems like you do not handle an error condition for fclose(). This can introduce security issues, and is generally not recommended.

		$gfh = new CGIFFILEHEADER();
		if (!$gfh->load($data, $len = 0)) {

$len = 0 cannot be passed to CGIFFILEHEADER::load() as the parameter $hdrLen expects a reference.

			return false;
		}

		$width  = $gfh->m_nWidth;
		$height = $gfh->m_nHeight;
		return true;
	}

	///////////////////////////////////////////////////////////////////////////

	public function getBmp($bgColor)
	{
		$out = '';

		if (!$this->m_bLoaded) {
			return false;
		}

		// PREPARE COLOR TABLE (RGBQUADs)
		if ($this->m_img->m_gih->m_bLocalClr) {
			$nColors = $this->m_img->m_gih->m_nTableSize;
			$rgbq    = $this->m_img->m_gih->m_colorTable->toRGBQuad();
			if ($bgColor != -1) {
				$bgColor = $this->m_img->m_gih->m_colorTable->colorIndex($bgColor);
			}
		} elseif ($this->m_gfh->m_bGlobalClr) {
			$nColors = $this->m_gfh->m_nTableSize;
			$rgbq    = $this->m_gfh->m_colorTable->toRGBQuad();
			if ($bgColor != -1) {
				$bgColor = $this->m_gfh->m_colorTable->colorIndex($bgColor);
			}
		} else {
			$nColors =  0;
			$rgbq    = '';
			$bgColor = -1;
		}

		// PREPARE BITMAP BITS
		$data = $this->m_img->m_data;
		$nPxl = ($this->m_gfh->m_nHeight - 1) * $this->m_gfh->m_nWidth;
		$bmp  = '';
		$nPad = ($this->m_gfh->m_nWidth % 4) ? 4 - ($this->m_gfh->m_nWidth % 4) : 0;
		for ($y = 0; $y < $this->m_gfh->m_nHeight; $y++) {
			for ($x = 0; $x < $this->m_gfh->m_nWidth; $x++, $nPxl++) {
				if (
					($x >= $this->m_img->m_gih->m_nLeft) &&
					($y >= $this->m_img->m_gih->m_nTop) &&
					($x <  ($this->m_img->m_gih->m_nLeft + $this->m_img->m_gih->m_nWidth)) &&
					($y <  ($this->m_img->m_gih->m_nTop  + $this->m_img->m_gih->m_nHeight))) {
					// PART OF IMAGE
					if (@$this->m_img->m_bTrans && (ord($data[$nPxl]) == $this->m_img->m_nTrans)) {
						// TRANSPARENT -> BACKGROUND
						if ($bgColor == -1) {
							$bmp .= chr($this->m_gfh->m_nBgColor);
						} else {
							$bmp .= chr($bgColor);
						}
					} else {
						$bmp .= $data[$nPxl];
					}
				} else {
					// BACKGROUND
					if ($bgColor == -1) {
						$bmp .= chr($this->m_gfh->m_nBgColor);
					} else {
						$bmp .= chr($bgColor);
					}
				}
			}
			$nPxl -= $this->m_gfh->m_nWidth << 1;

			// ADD PADDING
			for ($x = 0; $x < $nPad; $x++) {
				$bmp .= "\x00";
			}
		}

		// BITMAPFILEHEADER
		$out .= 'BM';
		$out .= $this->dword(14 + 40 + ($nColors << 2) + strlen($bmp));
		$out .= "\x00\x00";
		$out .= "\x00\x00";
		$out .= $this->dword(14 + 40 + ($nColors << 2));

		// BITMAPINFOHEADER
		$out .= $this->dword(40);
		$out .= $this->dword($this->m_gfh->m_nWidth);
		$out .= $this->dword($this->m_gfh->m_nHeight);
		$out .= "\x01\x00";
		$out .= "\x08\x00";
		$out .= "\x00\x00\x00\x00";
		$out .= "\x00\x00\x00\x00";
		$out .= "\x12\x0B\x00\x00";
		$out .= "\x12\x0B\x00\x00";
		$out .= $this->dword($nColors % 256);
		$out .= "\x00\x00\x00\x00";

		// COLOR TABLE
		if ($nColors > 0) {
			$out .= $rgbq;
		}

		// DATA
		$out .= $bmp;

		return $out;
	}

	///////////////////////////////////////////////////////////////////////////

	public function getPng($bgColor)
	{
		$out = '';

		if (!$this->m_bLoaded) {
			return false;
		}

		// PREPARE COLOR TABLE (RGBQUADs)
		if ($this->m_img->m_gih->m_bLocalClr) {
			$nColors = $this->m_img->m_gih->m_nTableSize;
			$pal     = $this->m_img->m_gih->m_colorTable->toString();
			if ($bgColor != -1) {
				$bgColor = $this->m_img->m_gih->m_colorTable->colorIndex($bgColor);
			}
		} elseif ($this->m_gfh->m_bGlobalClr) {
			$nColors = $this->m_gfh->m_nTableSize;
			$pal     = $this->m_gfh->m_colorTable->toString();
			if ($bgColor != -1) {
				$bgColor = $this->m_gfh->m_colorTable->colorIndex($bgColor);
			}
		} else {
			$nColors =  0;
			$pal     = '';
			$bgColor = -1;
		}

		// PREPARE BITMAP BITS
		$data = $this->m_img->m_data;
		$nPxl = 0;
		$bmp  = '';
		for ($y = 0; $y < $this->m_gfh->m_nHeight; $y++) {
			$bmp .= "\x00";
			for ($x = 0; $x < $this->m_gfh->m_nWidth; $x++, $nPxl++) {
				if (
					($x >= $this->m_img->m_gih->m_nLeft) &&
					($y >= $this->m_img->m_gih->m_nTop) &&
					($x <  ($this->m_img->m_gih->m_nLeft + $this->m_img->m_gih->m_nWidth)) &&
					($y <  ($this->m_img->m_gih->m_nTop  + $this->m_img->m_gih->m_nHeight))) {
					// PART OF IMAGE
					$bmp .= $data[$nPxl];
				} else {
					// BACKGROUND
					if ($bgColor == -1) {
						$bmp .= chr($this->m_gfh->m_nBgColor);
					} else {
						$bmp .= chr($bgColor);
					}
				}
			}
		}
		$bmp = gzcompress($bmp, 9);

		///////////////////////////////////////////////////////////////////////
		// SIGNATURE
		$out .= "\x89\x50\x4E\x47\x0D\x0A\x1A\x0A";
		///////////////////////////////////////////////////////////////////////
		// HEADER
		$out .= "\x00\x00\x00\x0D";
		$tmp  = 'IHDR';
		$tmp .= $this->ndword($this->m_gfh->m_nWidth);
		$tmp .= $this->ndword($this->m_gfh->m_nHeight);
		$tmp .= "\x08\x03\x00\x00\x00";
		$out .= $tmp;
		$out .= $this->ndword(crc32($tmp));
		///////////////////////////////////////////////////////////////////////
		// PALETTE
		if ($nColors > 0) {
			$out .= $this->ndword($nColors * 3);
			$tmp  = 'PLTE';
			$tmp .= $pal;
			$out .= $tmp;
			$out .= $this->ndword(crc32($tmp));
		}
		///////////////////////////////////////////////////////////////////////
		// TRANSPARENCY
		if (@$this->m_img->m_bTrans && ($nColors > 0)) {
			$out .= $this->ndword($nColors);
			$tmp  = 'tRNS';
			for ($i = 0; $i < $nColors; $i++) {
				$tmp .= ($i == $this->m_img->m_nTrans) ? "\x00" : "\xFF";
			}
			$out .= $tmp;
			$out .= $this->ndword(crc32($tmp));
		}
		///////////////////////////////////////////////////////////////////////
		// DATA BITS
		$out .= $this->ndword(strlen($bmp));
		$tmp  = 'IDAT';
		$tmp .= $bmp;
		$out .= $tmp;
		$out .= $this->ndword(crc32($tmp));
		///////////////////////////////////////////////////////////////////////
		// END OF FILE
		$out .= "\x00\x00\x00\x00IEND\xAE\x42\x60\x82";

		return $out;
	}

	///////////////////////////////////////////////////////////////////////////

	// Added by James Heinrich <info@silisoftware.com> - January 5, 2003

	// Takes raw image data and plots it pixel-by-pixel on a new GD image and returns that
	// It's extremely slow, but the only solution when imagecreatefromstring() fails
	public function getGD_PixelPlotterVersion()
	{
		if (!$this->m_bLoaded) {
			return false;
		}

		// PREPARE COLOR TABLE (RGBQUADs)
		if ($this->m_img->m_gih->m_bLocalClr) {
			$pal = $this->m_img->m_gih->m_colorTable->toString();
		} elseif ($this->m_gfh->m_bGlobalClr) {
			$pal = $this->m_gfh->m_colorTable->toString();
		} else {
			die('No color table available in getGD_PixelPlotterVersion()');

Using exit here is not recommended.

		}

		$PlottingIMG = imagecreate($this->m_gfh->m_nWidth, $this->m_gfh->m_nHeight);
		$NumColorsInPal = floor(strlen($pal) / 3);
		$ThisImageColor = array();
		for ($i = 0; $i < $NumColorsInPal; $i++) {
			$ThisImageColor[$i] = imagecolorallocate(
									$PlottingIMG,

It seems like $PlottingIMG can also be of type false; however, parameter $image of imagecolorallocate() does only seem to accept resource, maybe add an additional type check?

									ord($pal{($i * 3) + 0}),
									ord($pal{($i * 3) + 1}),
									ord($pal{($i * 3) + 2}));
		}

		// PREPARE BITMAP BITS
		$data = $this->m_img->m_data;
		$nPxl = ($this->m_gfh->m_nHeight - 1) * $this->m_gfh->m_nWidth;
		for ($y = 0; $y < $this->m_gfh->m_nHeight; $y++) {
			if (!phpthumb_functions::FunctionIsDisabled('set_time_limit')) {
				set_time_limit(30);
			}
			for ($x = 0; $x < $this->m_gfh->m_nWidth; $x++, $nPxl++) {
				if (
					($x >= $this->m_img->m_gih->m_nLeft) &&
					($y >= $this->m_img->m_gih->m_nTop) &&
					($x <  ($this->m_img->m_gih->m_nLeft + $this->m_img->m_gih->m_nWidth)) &&
					($y <  ($this->m_img->m_gih->m_nTop  + $this->m_img->m_gih->m_nHeight))) {
					// PART OF IMAGE
					if (@$this->m_img->m_bTrans && (ord($data[$nPxl]) == $this->m_img->m_nTrans)) {
						imagesetpixel($PlottingIMG, $x, $this->m_gfh->m_nHeight - $y - 1, $ThisImageColor[$this->m_gfh->m_nBgColor]);

It seems like $PlottingIMG can also be of type false; however, parameter $image of imagesetpixel() does only seem to accept resource, maybe add an additional type check?

					} else {
						imagesetpixel($PlottingIMG, $x, $this->m_gfh->m_nHeight - $y - 1, $ThisImageColor[ord($data[$nPxl])]);
					}
				} else {
					// BACKGROUND
					imagesetpixel($PlottingIMG, $x, $this->m_gfh->m_nHeight - $y - 1, $ThisImageColor[$this->m_gfh->m_nBgColor]);
				}
			}
			$nPxl -= $this->m_gfh->m_nWidth << 1;

		}

		return $PlottingIMG;
	}

	///////////////////////////////////////////////////////////////////////////

	public function dword($val)
	{
		$val = (int) $val;
		return chr($val & 0xFF).chr(($val & 0xFF00) >> 8).chr(($val & 0xFF0000) >> 16).chr(($val & 0xFF000000) >> 24);
	}

	///////////////////////////////////////////////////////////////////////////

	public function ndword($val)
	{
		$val = (int) $val;
		return chr(($val & 0xFF000000) >> 24).chr(($val & 0xFF0000) >> 16).chr(($val & 0xFF00) >> 8).chr($val & 0xFF);
	}

	///////////////////////////////////////////////////////////////////////////

	public function width()
	{
		return $this->m_gfh->m_nWidth;
	}

	///////////////////////////////////////////////////////////////////////////

	public function height()
	{
		return $this->m_gfh->m_nHeight;
	}

	///////////////////////////////////////////////////////////////////////////

	public function comment()
	{
		return $this->m_img->m_lpComm;
	}

	///////////////////////////////////////////////////////////////////////////

	public function loaded()
	{
		return $this->m_bLoaded;
	}
}