WebSVN – cheapmusic – /www/seopanel/libs/mpdf/classes/gif.php

<?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;
        }

}

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

?>
Subversion Repositories cheapmusic

(root)/www/seopanel/libs/mpdf/classes/gif.php – Rev 103
