Projekt

Obecné

Profil

Stáhnout (16.4 KB) Statistiky
| Větev: | Tag: | Revize:

freenetis-github/application/vendors/mpdf/classes/gif.php @ 31ca0a32

31ca0a32 Michal Kliment
<?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;
}

}

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

?>