Subversion Repositories cheapmusic

<?php

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

// 2009-12-22 Adapted for mPDF 4.2

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

// 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.

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

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

// 2009-12-22 Adapted INB

// Functions calling functionname($x, $len = 0) were not working on PHP5.1.5 as pass by reference

// All edited to $len = 0; then call function.

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

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

class CGIFLZW

{

	var $MAX_LZW_BITS;

	var $Fresh, $CodeSize, $SetCodeSize, $MaxCode, $MaxCodeSize, $FirstCode, $OldCode;

	var $ClearCode, $EndCode, $Next, $Vals, $Stack, $sp, $Buf, $CurBit, $LastBit, $Done, $LastByte;

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

	// CONSTRUCTOR

	function CGIFLZW()

	{

		$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);

	}

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

	function deCompress($data, &$datLen)

	{

		$stLen  = strlen($data);

		$datLen = 0;

		$ret    = "";

		$dp = 0; 	// data pointer

		// INITIALIZATION

		$this->LZWCommandInit($data, $dp);

		while(($iIndex = $this->LZWCommand($data, $dp)) >= 0) {

			$ret .= chr($iIndex);

		}

		$datLen = $dp;

		if($iIndex != -2) {

			return false;

		}

		return $ret;

	}

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

	function LZWCommandInit(&$data, &$dp)

	{

			$this->SetCodeSize = ord($data[0]);

			$dp += 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->GetCodeInit($data, $dp);

			$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;

	}

	function LZWCommand(&$data, &$dp)

	{

		if($this->Fresh) {

			$this->Fresh = 0;

			do {

				$this->FirstCode = $this->GetCode($data, $dp);

				$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, $dp)) >= 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, $dp);

				$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;

				$Code = $this->OldCode;

			}

			while($Code >= $this->ClearCode) {

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

				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;

			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;

	}

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

	function GetCodeInit(&$data, &$dp)

	{

			$this->CurBit   = 0;

			$this->LastBit  = 0;

			$this->Done     = 0;

			$this->LastByte = 2;

			return 1;

	}

	function GetCode(&$data, &$dp)

	{

		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[$dp]);

			$dp += 1;

			if($Count) {

				for($i = 0; $i < $Count; $i++) {

					$this->Buf[2 + $i] = ord($data[$dp+$i]);

				}

				$dp += $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[intval($i / 8)] & (1 << ($i % 8))) != 0) << $j;

		}

		$this->CurBit += $this->CodeSize;

		return $iRet;

	}

}

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

class CGIFCOLORTABLE

{

	var $m_nColors;

	var $m_arColors;

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

	// CONSTRUCTOR

	function CGIFCOLORTABLE()

	{

		unSet($this->m_nColors);

		unSet($this->m_arColors);

	}

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

	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;

	}

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

	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;

	}

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

	function colorIndex($rgb)

	{

		$rgb  = intval($rgb) & 0xFFFFFF;

		$r1   = ($rgb & 0x0000FF);

		$g1   = ($rgb & 0x00FF00) >>  8;

		$b1   = ($rgb & 0xFF0000) >> 16;

		$idx  = -1;

		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

{

	var $m_lpVer;

	var $m_nWidth;

	var $m_nHeight;

	var $m_bGlobalClr;

	var $m_nColorRes;

	var $m_bSorted;

	var $m_nTableSize;

	var $m_nBgColor;

	var $m_nPixelRatio;

	var $m_colorTable;

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

	// CONSTRUCTOR

	function CGIFFILEHEADER()

	{

		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);

	}

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

	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(substr($lpData, 10, 1));

		$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(substr($lpData, 11, 1));

		$this->m_nPixelRatio = ord(substr($lpData, 12, 1));

		$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;

	}

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

	function w2i($str)

	{

		return ord(substr($str, 0, 1)) + (ord(substr($str, 1, 1)) << 8);

	}

}

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

class CGIFIMAGEHEADER

{

	var $m_nLeft;

	var $m_nTop;

	var $m_nWidth;

	var $m_nHeight;

	var $m_bLocalClr;

	var $m_bInterlace;

	var $m_bSorted;

	var $m_nTableSize;

	var $m_colorTable;

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

	// CONSTRUCTOR

	function CGIFIMAGEHEADER()

	{

		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);

	}

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

	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;

	}

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

	function w2i($str)

	{

		return ord(substr($str, 0, 1)) + (ord(substr($str, 1, 1)) << 8);

	}

}

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

class CGIFIMAGE

{

	var $m_disp;

	var $m_bUser;

	var $m_bTrans;

	var $m_nDelay;

	var $m_nTrans;

	var $m_lpComm;

	var $m_gih;

	var $m_data;

	var $m_lzw;

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

	function CGIFIMAGE()

	{

		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();

	}

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

	function load($data, &$datLen)

	{

		$datLen = 0;

		while(true) {

			$b = ord($data[0]);

			$data = substr($data, 1);

			$datLen++;

			switch($b) {

			case 0x21: // Extension

				$len = 0;

				if(!$this->skipExt($data, $len)) {

					return false;

				}

				$datLen += $len;

				break;

			case 0x2C: // Image

				// LOAD HEADER & COLOR TABLE

				$len = 0;

				if(!$this->m_gih->load($data, $len)) {

					return false;

				}

				$data = substr($data, $len);

				$datLen += $len;

				// ALLOC BUFFER

				$len = 0;

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

					return false;

				}

				$data = substr($data, $len);

				$datLen += $len;

				if($this->m_gih->m_bInterlace) {

					$this->deInterlace();

				}

				return true;

			case 0x3B: // EOF

			default:

				return false;

			}

		}

		return false;

	}

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

	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;

	}

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

	function w2i($str)

	{

		return ord(substr($str, 0, 1)) + (ord(substr($str, 1, 1)) << 8);

	}

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

	function deInterlace()

	{

		$data = $this->m_data;

		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

{

	var $m_gfh;

	var $m_lpData;

	var $m_img;

	var $m_bLoaded;

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

	// CONSTRUCTOR

	function CGIF()

	{

		$this->m_gfh     = new CGIFFILEHEADER();

		$this->m_img     = new CGIFIMAGE();

		$this->m_lpData  = "";

		$this->m_bLoaded = false;

	}

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

	function ClearData() {

		$this->m_lpData = '';

		unSet($this->m_img->m_data);

		unSet($this->m_img->m_lzw->Next);

		unSet($this->m_img->m_lzw->Vals);

		unSet($this->m_img->m_lzw->Stack);

		unSet($this->m_img->m_lzw->Buf);

	}

	function loadFile(&$data, $iIndex)

	{

		if($iIndex < 0) {

			return false;

		}

		$this->m_lpData = $data;

		// GET FILE HEADER

		$len = 0;

		if(!$this->m_gfh->load($this->m_lpData, $len)) {

			return false;

		}

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

		do {

			$imgLen = 0;

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

				return false;

			}

			$this->m_lpData = substr($this->m_lpData, $imgLen);

		}

		while($iIndex-- > 0);

		$this->m_bLoaded = true;

		return true;

	}

}

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

?>