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

}

///////////////////////////////////////////////////////////////////////////////////////////////////
?>