vendor/mpdf/mpdf/classes/gif.php

   1 <?php
   2
   3 ///////////////////////////////////////////////////////////////////////////////////////////////////
   4 // 2009-12-22 Adapted for mPDF 4.2
   5 ///////////////////////////////////////////////////////////////////////////////////////////////////
   6 // GIF Util - (C) 2003 Yamasoft (S/C)
   7 // http://www.yamasoft.com
   8 // All Rights Reserved
   9 // This file can be freely copied, distributed, modified, updated by anyone under the only
  10 // condition to leave the original address (Yamasoft, http://www.yamasoft.com) and this header.
  11 ///////////////////////////////////////////////////////////////////////////////////////////////////
  12 ///////////////////////////////////////////////////////////////////////////////////////////////////
  13 // 2009-12-22 Adapted INB
  14 // Functions calling functionname($x, $len = 0) were not working on PHP5.1.5 as pass by reference
  15 // All edited to $len = 0; then call function.
  16 ///////////////////////////////////////////////////////////////////////////////////////////////////
  17 ///////////////////////////////////////////////////////////////////////////////////////////////////
  18
  19 class CGIFLZW
  20 {
  21
  22         var $MAX_LZW_BITS;
  23
  24         var $Fresh, $CodeSize, $SetCodeSize, $MaxCode, $MaxCodeSize, $FirstCode, $OldCode;
  25
  26         var $ClearCode, $EndCode, $Next, $Vals, $Stack, $sp, $Buf, $CurBit, $LastBit, $Done, $LastByte;
  27
  28         public function __construct()
  29         {
  30                 $this->MAX_LZW_BITS = 12;
  31                 unSet($this->Next);
  32                 unSet($this->Vals);
  33                 unSet($this->Stack);
  34                 unSet($this->Buf);
  35
  36                 $this->Next = range(0, (1 << $this->MAX_LZW_BITS) - 1);
  37                 $this->Vals = range(0, (1 << $this->MAX_LZW_BITS) - 1);
  38                 $this->Stack = range(0, (1 << ($this->MAX_LZW_BITS + 1)) - 1);
  39                 $this->Buf = range(0, 279);
  40         }
  41
  42         function deCompress($data, &$datLen)
  43         {
  44                 $stLen = strlen($data);
  45                 $datLen = 0;
  46                 $ret = "";
  47                 $dp = 0;  // data pointer
  48                 // INITIALIZATION
  49                 $this->LZWCommandInit($data, $dp);
  50
  51                 while (($iIndex = $this->LZWCommand($data, $dp)) >= 0) {
  52                         $ret .= chr($iIndex);
  53                 }
  54
  55                 $datLen = $dp;
  56
  57                 if ($iIndex != -2) {
  58                         return false;
  59                 }
  60
  61                 return $ret;
  62         }
  63
  64         function LZWCommandInit(&$data, &$dp)
  65         {
  66                 $this->SetCodeSize = ord($data[0]);
  67                 $dp += 1;
  68
  69                 $this->CodeSize = $this->SetCodeSize + 1;
  70                 $this->ClearCode = 1 << $this->SetCodeSize;
  71                 $this->EndCode = $this->ClearCode + 1;
  72                 $this->MaxCode = $this->ClearCode + 2;
  73                 $this->MaxCodeSize = $this->ClearCode << 1;
  74
  75                 $this->GetCodeInit($data, $dp);
  76
  77                 $this->Fresh = 1;
  78                 for ($i = 0; $i < $this->ClearCode; $i++) {
  79                         $this->Next[$i] = 0;
  80                         $this->Vals[$i] = $i;
  81                 }
  82
  83                 for (; $i < (1 << $this->MAX_LZW_BITS); $i++) {
  84                         $this->Next[$i] = 0;
  85                         $this->Vals[$i] = 0;
  86                 }
  87
  88                 $this->sp = 0;
  89                 return 1;
  90         }
  91
  92         function LZWCommand(&$data, &$dp)
  93         {
  94                 if ($this->Fresh) {
  95                         $this->Fresh = 0;
  96                         do {
  97                                 $this->FirstCode = $this->GetCode($data, $dp);
  98                                 $this->OldCode = $this->FirstCode;
  99                         } while ($this->FirstCode == $this->ClearCode);
 100
 101                         return $this->FirstCode;
 102                 }
 103
 104                 if ($this->sp > 0) {
 105                         $this->sp--;
 106                         return $this->Stack[$this->sp];
 107                 }
 108
 109                 while (($Code = $this->GetCode($data, $dp)) >= 0) {
 110                         if ($Code == $this->ClearCode) {
 111                                 for ($i = 0; $i < $this->ClearCode; $i++) {
 112                                         $this->Next[$i] = 0;
 113                                         $this->Vals[$i] = $i;
 114                                 }
 115
 116                                 for (; $i < (1 << $this->MAX_LZW_BITS); $i++) {
 117                                         $this->Next[$i] = 0;
 118                                         $this->Vals[$i] = 0;
 119                                 }
 120
 121                                 $this->CodeSize = $this->SetCodeSize + 1;
 122                                 $this->MaxCodeSize = $this->ClearCode << 1;
 123                                 $this->MaxCode = $this->ClearCode + 2;
 124                                 $this->sp = 0;
 125                                 $this->FirstCode = $this->GetCode($data, $dp);
 126                                 $this->OldCode = $this->FirstCode;
 127
 128                                 return $this->FirstCode;
 129                         }
 130
 131                         if ($Code == $this->EndCode) {
 132                                 return -2;
 133                         }
 134
 135                         $InCode = $Code;
 136                         if ($Code >= $this->MaxCode) {
 137                                 $this->Stack[$this->sp++] = $this->FirstCode;
 138                                 $Code = $this->OldCode;
 139                         }
 140
 141                         while ($Code >= $this->ClearCode) {
 142                                 $this->Stack[$this->sp++] = $this->Vals[$Code];
 143
 144                                 if ($Code == $this->Next[$Code]) // Circular table entry, big GIF Error!
 145                                         return -1;
 146
 147                                 $Code = $this->Next[$Code];
 148                         }
 149
 150                         $this->FirstCode = $this->Vals[$Code];
 151                         $this->Stack[$this->sp++] = $this->FirstCode;
 152
 153                         if (($Code = $this->MaxCode) < (1 << $this->MAX_LZW_BITS)) {
 154                                 $this->Next[$Code] = $this->OldCode;
 155                                 $this->Vals[$Code] = $this->FirstCode;
 156                                 $this->MaxCode++;
 157
 158                                 if (($this->MaxCode >= $this->MaxCodeSize) && ($this->MaxCodeSize < (1 << $this->MAX_LZW_BITS))) {
 159                                         $this->MaxCodeSize *= 2;
 160                                         $this->CodeSize++;
 161                                 }
 162                         }
 163
 164                         $this->OldCode = $InCode;
 165                         if ($this->sp > 0) {
 166                                 $this->sp--;
 167                                 return $this->Stack[$this->sp];
 168                         }
 169                 }
 170
 171                 return $Code;
 172         }
 173
 174         function GetCodeInit(&$data, &$dp)
 175         {
 176                 $this->CurBit = 0;
 177                 $this->LastBit = 0;
 178                 $this->Done = 0;
 179                 $this->LastByte = 2;
 180                 return 1;
 181         }
 182
 183         function GetCode(&$data, &$dp)
 184         {
 185                 if (($this->CurBit + $this->CodeSize) >= $this->LastBit) {
 186                         if ($this->Done) {
 187                                 if ($this->CurBit >= $this->LastBit) {
 188                                         // Ran off the end of my bits
 189                                         return 0;
 190                                 }
 191                                 return -1;
 192                         }
 193
 194                         $this->Buf[0] = $this->Buf[$this->LastByte - 2];
 195                         $this->Buf[1] = $this->Buf[$this->LastByte - 1];
 196
 197                         $Count = ord($data[$dp]);
 198                         $dp += 1;
 199
 200                         if ($Count) {
 201                                 for ($i = 0; $i < $Count; $i++) {
 202                                         $this->Buf[2 + $i] = ord($data[$dp + $i]);
 203                                 }
 204                                 $dp += $Count;
 205                         } else {
 206                                 $this->Done = 1;
 207                         }
 208
 209                         $this->LastByte = 2 + $Count;
 210                         $this->CurBit = ($this->CurBit - $this->LastBit) + 16;
 211                         $this->LastBit = (2 + $Count) << 3;
 212                 }
 213
 214                 $iRet = 0;
 215                 for ($i = $this->CurBit, $j = 0; $j < $this->CodeSize; $i++, $j++) {
 216                         $iRet |= (($this->Buf[intval($i / 8)] & (1 << ($i % 8))) != 0) << $j;
 217                 }
 218
 219                 $this->CurBit += $this->CodeSize;
 220                 return $iRet;
 221         }
 222
 223 }
 224
 225 class CGIFCOLORTABLE
 226 {
 227
 228         var $m_nColors;
 229
 230         var $m_arColors;
 231
 232         public function __construct()
 233         {
 234                 unSet($this->m_nColors);
 235                 unSet($this->m_arColors);
 236         }
 237
 238         function load($lpData, $num)
 239         {
 240                 $this->m_nColors = 0;
 241                 $this->m_arColors = array();
 242
 243                 for ($i = 0; $i < $num; $i++) {
 244                         $rgb = substr($lpData, $i * 3, 3);
 245                         if (strlen($rgb) < 3) {
 246                                 return false;
 247                         }
 248
 249                         $this->m_arColors[] = (ord($rgb[2]) << 16) + (ord($rgb[1]) << 8) + ord($rgb[0]);
 250                         $this->m_nColors++;
 251                 }
 252
 253                 return true;
 254         }
 255
 256         function toString()
 257         {
 258                 $ret = "";
 259
 260                 for ($i = 0; $i < $this->m_nColors; $i++) {
 261                         $ret .=
 262                                 chr(($this->m_arColors[$i] & 0x000000FF)) . // R
 263                                 chr(($this->m_arColors[$i] & 0x0000FF00) >> 8) . // G
 264                                 chr(($this->m_arColors[$i] & 0x00FF0000) >> 16);  // B
 265                 }
 266
 267                 return $ret;
 268         }
 269
 270         function colorIndex($rgb)
 271         {
 272                 $rgb = intval($rgb) & 0xFFFFFF;
 273                 $r1 = ($rgb & 0x0000FF);
 274                 $g1 = ($rgb & 0x00FF00) >> 8;
 275                 $b1 = ($rgb & 0xFF0000) >> 16;
 276                 $idx = -1;
 277
 278                 for ($i = 0; $i < $this->m_nColors; $i++) {
 279                         $r2 = ($this->m_arColors[$i] & 0x000000FF);
 280                         $g2 = ($this->m_arColors[$i] & 0x0000FF00) >> 8;
 281                         $b2 = ($this->m_arColors[$i] & 0x00FF0000) >> 16;
 282                         $d = abs($r2 - $r1) + abs($g2 - $g1) + abs($b2 - $b1);
 283
 284                         if (($idx == -1) || ($d < $dif)) {
 285                                 $idx = $i;
 286                                 $dif = $d;
 287                         }
 288                 }
 289
 290                 return $idx;
 291         }
 292
 293 }
 294
 295 class CGIFFILEHEADER
 296 {
 297
 298         var $m_lpVer;
 299
 300         var $m_nWidth;
 301
 302         var $m_nHeight;
 303
 304         var $m_bGlobalClr;
 305
 306         var $m_nColorRes;
 307
 308         var $m_bSorted;
 309
 310         var $m_nTableSize;
 311
 312         var $m_nBgColor;
 313
 314         var $m_nPixelRatio;
 315
 316         var $m_colorTable;
 317
 318         public function __construct()
 319         {
 320                 unSet($this->m_lpVer);
 321                 unSet($this->m_nWidth);
 322                 unSet($this->m_nHeight);
 323                 unSet($this->m_bGlobalClr);
 324                 unSet($this->m_nColorRes);
 325                 unSet($this->m_bSorted);
 326                 unSet($this->m_nTableSize);
 327                 unSet($this->m_nBgColor);
 328                 unSet($this->m_nPixelRatio);
 329                 unSet($this->m_colorTable);
 330         }
 331
 332         function load($lpData, &$hdrLen)
 333         {
 334                 $hdrLen = 0;
 335
 336                 $this->m_lpVer = substr($lpData, 0, 6);
 337                 if (($this->m_lpVer <> "GIF87a") && ($this->m_lpVer <> "GIF89a")) {
 338                         return false;
 339                 }
 340
 341                 $this->m_nWidth = $this->w2i(substr($lpData, 6, 2));
 342                 $this->m_nHeight = $this->w2i(substr($lpData, 8, 2));
 343                 if (!$this->m_nWidth || !$this->m_nHeight) {
 344                         return false;
 345                 }
 346
 347                 $b = ord(substr($lpData, 10, 1));
 348                 $this->m_bGlobalClr = ($b & 0x80) ? true : false;
 349                 $this->m_nColorRes = ($b & 0x70) >> 4;
 350                 $this->m_bSorted = ($b & 0x08) ? true : false;
 351                 $this->m_nTableSize = 2 << ($b & 0x07);
 352                 $this->m_nBgColor = ord(substr($lpData, 11, 1));
 353                 $this->m_nPixelRatio = ord(substr($lpData, 12, 1));
 354                 $hdrLen = 13;
 355
 356                 if ($this->m_bGlobalClr) {
 357                         $this->m_colorTable = new CGIFCOLORTABLE();
 358                         if (!$this->m_colorTable->load(substr($lpData, $hdrLen), $this->m_nTableSize)) {
 359                                 return false;
 360                         }
 361                         $hdrLen += 3 * $this->m_nTableSize;
 362                 }
 363
 364                 return true;
 365         }
 366
 367         function w2i($str)
 368         {
 369                 return ord(substr($str, 0, 1)) + (ord(substr($str, 1, 1)) << 8);
 370         }
 371
 372 }
 373
 374 class CGIFIMAGEHEADER
 375 {
 376
 377         var $m_nLeft;
 378
 379         var $m_nTop;
 380
 381         var $m_nWidth;
 382
 383         var $m_nHeight;
 384
 385         var $m_bLocalClr;
 386
 387         var $m_bInterlace;
 388
 389         var $m_bSorted;
 390
 391         var $m_nTableSize;
 392
 393         var $m_colorTable;
 394
 395         public function __construct()
 396         {
 397                 unSet($this->m_nLeft);
 398                 unSet($this->m_nTop);
 399                 unSet($this->m_nWidth);
 400                 unSet($this->m_nHeight);
 401                 unSet($this->m_bLocalClr);
 402                 unSet($this->m_bInterlace);
 403                 unSet($this->m_bSorted);
 404                 unSet($this->m_nTableSize);
 405                 unSet($this->m_colorTable);
 406         }
 407
 408         function load($lpData, &$hdrLen)
 409         {
 410                 $hdrLen = 0;
 411
 412                 $this->m_nLeft = $this->w2i(substr($lpData, 0, 2));
 413                 $this->m_nTop = $this->w2i(substr($lpData, 2, 2));
 414                 $this->m_nWidth = $this->w2i(substr($lpData, 4, 2));
 415                 $this->m_nHeight = $this->w2i(substr($lpData, 6, 2));
 416
 417                 if (!$this->m_nWidth || !$this->m_nHeight) {
 418                         return false;
 419                 }
 420
 421                 $b = ord($lpData{8});
 422                 $this->m_bLocalClr = ($b & 0x80) ? true : false;
 423                 $this->m_bInterlace = ($b & 0x40) ? true : false;
 424                 $this->m_bSorted = ($b & 0x20) ? true : false;
 425                 $this->m_nTableSize = 2 << ($b & 0x07);
 426                 $hdrLen = 9;
 427
 428                 if ($this->m_bLocalClr) {
 429                         $this->m_colorTable = new CGIFCOLORTABLE();
 430                         if (!$this->m_colorTable->load(substr($lpData, $hdrLen), $this->m_nTableSize)) {
 431                                 return false;
 432                         }
 433                         $hdrLen += 3 * $this->m_nTableSize;
 434                 }
 435
 436                 return true;
 437         }
 438
 439         function w2i($str)
 440         {
 441                 return ord(substr($str, 0, 1)) + (ord(substr($str, 1, 1)) << 8);
 442         }
 443
 444 }
 445
 446 class CGIFIMAGE
 447 {
 448
 449         var $m_disp;
 450
 451         var $m_bUser;
 452
 453         var $m_bTrans;
 454
 455         var $m_nDelay;
 456
 457         var $m_nTrans;
 458
 459         var $m_lpComm;
 460
 461         var $m_gih;
 462
 463         var $m_data;
 464
 465         var $m_lzw;
 466
 467         public function __construct()
 468         {
 469                 unSet($this->m_disp);
 470                 unSet($this->m_bUser);
 471                 unSet($this->m_bTrans);
 472                 unSet($this->m_nDelay);
 473                 unSet($this->m_nTrans);
 474                 unSet($this->m_lpComm);
 475                 unSet($this->m_data);
 476                 $this->m_gih = new CGIFIMAGEHEADER();
 477                 $this->m_lzw = new CGIFLZW();
 478         }
 479
 480         function load($data, &$datLen)
 481         {
 482                 $datLen = 0;
 483
 484                 while (true) {
 485                         $b = ord($data[0]);
 486                         $data = substr($data, 1);
 487                         $datLen++;
 488
 489                         switch ($b) {
 490                                 case 0x21: // Extension
 491                                         $len = 0;
 492                                         if (!$this->skipExt($data, $len)) {
 493                                                 return false;
 494                                         }
 495                                         $datLen += $len;
 496                                         break;
 497
 498                                 case 0x2C: // Image
 499                                         // LOAD HEADER & COLOR TABLE
 500                                         $len = 0;
 501                                         if (!$this->m_gih->load($data, $len)) {
 502                                                 return false;
 503                                         }
 504                                         $data = substr($data, $len);
 505                                         $datLen += $len;
 506
 507                                         // ALLOC BUFFER
 508                                         $len = 0;
 509
 510                                         if (!($this->m_data = $this->m_lzw->deCompress($data, $len))) {
 511                                                 return false;
 512                                         }
 513
 514                                         $data = substr($data, $len);
 515                                         $datLen += $len;
 516
 517                                         if ($this->m_gih->m_bInterlace) {
 518                                                 $this->deInterlace();
 519                                         }
 520
 521                                         return true;
 522
 523                                 case 0x3B: // EOF
 524                                 default:
 525                                         return false;
 526                         }
 527                 }
 528                 return false;
 529         }
 530
 531         function skipExt(&$data, &$extLen)
 532         {
 533                 $extLen = 0;
 534
 535                 $b = ord($data[0]);
 536                 $data = substr($data, 1);
 537                 $extLen++;
 538
 539                 switch ($b) {
 540                         case 0xF9: // Graphic Control
 541                                 $b = ord($data[1]);
 542                                 $this->m_disp = ($b & 0x1C) >> 2;
 543                                 $this->m_bUser = ($b & 0x02) ? true : false;
 544                                 $this->m_bTrans = ($b & 0x01) ? true : false;
 545                                 $this->m_nDelay = $this->w2i(substr($data, 2, 2));
 546                                 $this->m_nTrans = ord($data[4]);
 547                                 break;
 548
 549                         case 0xFE: // Comment
 550                                 $this->m_lpComm = substr($data, 1, ord($data[0]));
 551                                 break;
 552
 553                         case 0x01: // Plain text
 554                                 break;
 555
 556                         case 0xFF: // Application
 557                                 break;
 558                 }
 559
 560                 // SKIP DEFAULT AS DEFS MAY CHANGE
 561                 $b = ord($data[0]);
 562                 $data = substr($data, 1);
 563                 $extLen++;
 564                 while ($b > 0) {
 565                         $data = substr($data, $b);
 566                         $extLen += $b;
 567                         $b = ord($data[0]);
 568                         $data = substr($data, 1);
 569                         $extLen++;
 570                 }
 571                 return true;
 572         }
 573
 574         function w2i($str)
 575         {
 576                 return ord(substr($str, 0, 1)) + (ord(substr($str, 1, 1)) << 8);
 577         }
 578
 579         function deInterlace()
 580         {
 581                 $data = $this->m_data;
 582
 583                 for ($i = 0; $i < 4; $i++) {
 584                         switch ($i) {
 585                                 case 0:
 586                                         $s = 8;
 587                                         $y = 0;
 588                                         break;
 589
 590                                 case 1:
 591                                         $s = 8;
 592                                         $y = 4;
 593                                         break;
 594
 595                                 case 2:
 596                                         $s = 4;
 597                                         $y = 2;
 598                                         break;
 599
 600                                 case 3:
 601                                         $s = 2;
 602                                         $y = 1;
 603                                         break;
 604                         }
 605
 606                         for (; $y < $this->m_gih->m_nHeight; $y += $s) {
 607                                 $lne = substr($this->m_data, 0, $this->m_gih->m_nWidth);
 608                                 $this->m_data = substr($this->m_data, $this->m_gih->m_nWidth);
 609
 610                                 $data = substr($data, 0, $y * $this->m_gih->m_nWidth) .
 611                                         $lne .
 612                                         substr($data, ($y + 1) * $this->m_gih->m_nWidth);
 613                         }
 614                 }
 615
 616                 $this->m_data = $data;
 617         }
 618
 619 }
 620
 621 class CGIF
 622 {
 623
 624         var $m_gfh;
 625
 626         var $m_lpData;
 627
 628         var $m_img;
 629
 630         var $m_bLoaded;
 631
 632         public function __construct()
 633         {
 634                 $this->m_gfh = new CGIFFILEHEADER();
 635                 $this->m_img = new CGIFIMAGE();
 636                 $this->m_lpData = "";
 637                 $this->m_bLoaded = false;
 638         }
 639
 640         function ClearData()
 641         {
 642                 $this->m_lpData = '';
 643                 unSet($this->m_img->m_data);
 644                 unSet($this->m_img->m_lzw->Next);
 645                 unSet($this->m_img->m_lzw->Vals);
 646                 unSet($this->m_img->m_lzw->Stack);
 647                 unSet($this->m_img->m_lzw->Buf);
 648         }
 649
 650         function loadFile(&$data, $iIndex)
 651         {
 652                 if ($iIndex < 0) {
 653                         return false;
 654                 }
 655                 $this->m_lpData = $data;
 656
 657                 // GET FILE HEADER
 658                 $len = 0;
 659                 if (!$this->m_gfh->load($this->m_lpData, $len)) {
 660                         return false;
 661                 }
 662
 663                 $this->m_lpData = substr($this->m_lpData, $len);
 664
 665                 do {
 666                         $imgLen = 0;
 667                         if (!$this->m_img->load($this->m_lpData, $imgLen)) {
 668                                 return false;
 669                         }
 670                         $this->m_lpData = substr($this->m_lpData, $imgLen);
 671                 } while ($iIndex-- > 0);
 672
 673                 $this->m_bLoaded = true;
 674                 return true;
 675         }
 676
 677 }