CoCalc -- phpqrcode.php

GitHub Repository: freebsd/phabricator
Path: blob/master/externals/phpqrcode/phpqrcode.php
¹²²⁴⁰ views
1
<?php
2

3
/*
4
 * PHP QR Code encoder
5
 *
6
 * This file contains MERGED version of PHP QR Code library.
7
 * It was auto-generated from full version for your convenience.
8
 *
9
 * This merged version was configured to not requre any external files,
10
 * with disabled cache, error loging and weker but faster mask matching.
11
 * If you need tune it up please use non-merged version.
12
 *
13
 * For full version, documentation, examples of use please visit:
14
 *
15
 *    http://phpqrcode.sourceforge.net/
16
 *    https://sourceforge.net/projects/phpqrcode/
17
 *
18
 * PHP QR Code is distributed under LGPL 3
19
 * Copyright (C) 2010 Dominik Dzienia <deltalab at poczta dot fm>
20
 *
21
 * This library is free software; you can redistribute it and/or
22
 * modify it under the terms of the GNU Lesser General Public
23
 * License as published by the Free Software Foundation; either
24
 * version 3 of the License, or any later version.
25
 *
26
 * This library is distributed in the hope that it will be useful,
27
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
28
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
29
 * Lesser General Public License for more details.
30
 *
31
 * You should have received a copy of the GNU Lesser General Public
32
 * License along with this library; if not, write to the Free Software
33
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
34
 */
35
 
36
 
37

38
/*
39
 * Version: 1.1.4
40
 * Build: 2010100721
41
 */
42

43

44

45
//---- qrconst.php -----------------------------
46

47

48

49

50

51
/*
52
 * PHP QR Code encoder
53
 *
54
 * Common constants
55
 *
56
 * Based on libqrencode C library distributed under LGPL 2.1
57
 * Copyright (C) 2006, 2007, 2008, 2009 Kentaro Fukuchi <[email protected]>
58
 *
59
 * PHP QR Code is distributed under LGPL 3
60
 * Copyright (C) 2010 Dominik Dzienia <deltalab at poczta dot fm>
61
 *
62
 * This library is free software; you can redistribute it and/or
63
 * modify it under the terms of the GNU Lesser General Public
64
 * License as published by the Free Software Foundation; either
65
 * version 3 of the License, or any later version.
66
 *
67
 * This library is distributed in the hope that it will be useful,
68
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
69
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
70
 * Lesser General Public License for more details.
71
 *
72
 * You should have received a copy of the GNU Lesser General Public
73
 * License along with this library; if not, write to the Free Software
74
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
75
 */
76
 
77
	// Encoding modes
78
	 
79
	define('QR_MODE_NUL', -1);
80
	define('QR_MODE_NUM', 0);
81
	define('QR_MODE_AN', 1);
82
	define('QR_MODE_8', 2);
83
	define('QR_MODE_KANJI', 3);
84
	define('QR_MODE_STRUCTURE', 4);
85

86
	// Levels of error correction.
87

88
	define('QR_ECLEVEL_L', 0);
89
	define('QR_ECLEVEL_M', 1);
90
	define('QR_ECLEVEL_Q', 2);
91
	define('QR_ECLEVEL_H', 3);
92
	
93
	// Supported output formats
94
	
95
	define('QR_FORMAT_TEXT', 0);
96
	define('QR_FORMAT_PNG',  1);
97
	
98
	class qrstr {
99
		public static function set(&$srctab, $x, $y, $repl, $replLen = false) {
100
			$srctab[$y] = substr_replace($srctab[$y], ($replLen !== false)?substr($repl,0,$replLen):$repl, $x, ($replLen !== false)?$replLen:strlen($repl));
101
		}
102
	}	
103

104

105

106
//---- merged_config.php -----------------------------
107

108

109

110

111
/*
112
 * PHP QR Code encoder
113
 *
114
 * Config file, tuned-up for merged verion
115
 */
116
     
117
    define('QR_CACHEABLE', false);       // use cache - more disk reads but less CPU power, masks and format templates are stored there
118
    define('QR_CACHE_DIR', false);       // used when QR_CACHEABLE === true
119
    define('QR_LOG_DIR', false);         // default error logs dir   
120
    
121
    define('QR_FIND_BEST_MASK', true);                                                          // if true, estimates best mask (spec. default, but extremally slow; set to false to significant performance boost but (propably) worst quality code
122
    define('QR_FIND_FROM_RANDOM', 2);                                                       // if false, checks all masks available, otherwise value tells count of masks need to be checked, mask id are got randomly
123
    define('QR_DEFAULT_MASK', 2);                                                               // when QR_FIND_BEST_MASK === false
124
                                                  
125
    define('QR_PNG_MAXIMUM_SIZE',  1024);                                                       // maximum allowed png image width (in pixels), tune to make sure GD and PHP can handle such big images
126
                                                  
127

128

129

130
//---- qrtools.php -----------------------------
131

132

133

134

135
/*
136
 * PHP QR Code encoder
137
 *
138
 * Toolset, handy and debug utilites.
139
 *
140
 * PHP QR Code is distributed under LGPL 3
141
 * Copyright (C) 2010 Dominik Dzienia <deltalab at poczta dot fm>
142
 *
143
 * This library is free software; you can redistribute it and/or
144
 * modify it under the terms of the GNU Lesser General Public
145
 * License as published by the Free Software Foundation; either
146
 * version 3 of the License, or any later version.
147
 *
148
 * This library is distributed in the hope that it will be useful,
149
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
150
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
151
 * Lesser General Public License for more details.
152
 *
153
 * You should have received a copy of the GNU Lesser General Public
154
 * License along with this library; if not, write to the Free Software
155
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
156
 */
157

158
    class QRtools {
159
    
160
        //----------------------------------------------------------------------
161
        public static function binarize($frame)
162
        {
163
            $len = count($frame);
164
            foreach ($frame as &$frameLine) {
165
                
166
                for($i=0; $i<$len; $i++) {
167
                    $frameLine[$i] = (ord($frameLine[$i])&1)?'1':'0';
168
                }
169
            }
170
            
171
            return $frame;
172
        }
173
        
174
        //----------------------------------------------------------------------
175
        public static function tcpdfBarcodeArray($code, $mode = 'QR,L', $tcPdfVersion = '4.5.037')
176
        {
177
            $barcode_array = array();
178
            
179
            if (!is_array($mode))
180
                $mode = explode(',', $mode);
181
                
182
            $eccLevel = 'L';
183
                
184
            if (count($mode) > 1) {
185
                $eccLevel = $mode[1];
186
            }
187
                
188
            $qrTab = QRcode::text($code, false, $eccLevel);
189
            $size = count($qrTab);
190
                
191
            $barcode_array['num_rows'] = $size;
192
            $barcode_array['num_cols'] = $size;
193
            $barcode_array['bcode'] = array();
194
                
195
            foreach ($qrTab as $line) {
196
                $arrAdd = array();
197
                foreach(str_split($line) as $char)
198
                    $arrAdd[] = ($char=='1')?1:0;
199
                $barcode_array['bcode'][] = $arrAdd;
200
            }
201
                    
202
            return $barcode_array;
203
        }
204
        
205
        //----------------------------------------------------------------------
206
        public static function clearCache()
207
        {
208
            self::$frames = array();
209
        }
210
        
211
        //----------------------------------------------------------------------
212
        public static function buildCache()
213
        {
214
			QRtools::markTime('before_build_cache');
215
			
216
			$mask = new QRmask();
217
            for ($a=1; $a <= QRSPEC_VERSION_MAX; $a++) {
218
                $frame = QRspec::newFrame($a);
219
                if (QR_IMAGE) {
220
                    $fileName = QR_CACHE_DIR.'frame_'.$a.'.png';
221
                    QRimage::png(self::binarize($frame), $fileName, 1, 0);
222
                }
223
				
224
				$width = count($frame);
225
				$bitMask = array_fill(0, $width, array_fill(0, $width, 0));
226
				for ($maskNo=0; $maskNo<8; $maskNo++)
227
					$mask->makeMaskNo($maskNo, $width, $frame, $bitMask, true);
228
            }
229
			
230
			QRtools::markTime('after_build_cache');
231
        }
232

233
        //----------------------------------------------------------------------
234
        public static function log($outfile, $err)
235
        {
236
            if (QR_LOG_DIR !== false) {
237
                if ($err != '') {
238
                    if ($outfile !== false) {
239
                        file_put_contents(QR_LOG_DIR.basename($outfile).'-errors.txt', date('Y-m-d H:i:s').': '.$err, FILE_APPEND);
240
                    } else {
241
                        file_put_contents(QR_LOG_DIR.'errors.txt', date('Y-m-d H:i:s').': '.$err, FILE_APPEND);
242
                    }
243
                }    
244
            }
245
        }
246
        
247
        //----------------------------------------------------------------------
248
        public static function dumpMask($frame) 
249
        {
250
            $width = count($frame);
251
            for($y=0;$y<$width;$y++) {
252
                for($x=0;$x<$width;$x++) {
253
                    echo ord($frame[$y][$x]).',';
254
                }
255
            }
256
        }
257
        
258
        //----------------------------------------------------------------------
259
        public static function markTime($markerId)
260
        {
261
            list($usec, $sec) = explode(" ", microtime());
262
            $time = ((float)$usec + (float)$sec);
263
            
264
            if (!isset($GLOBALS['qr_time_bench']))
265
                $GLOBALS['qr_time_bench'] = array();
266
            
267
            $GLOBALS['qr_time_bench'][$markerId] = $time;
268
        }
269
        
270
        //----------------------------------------------------------------------
271
        public static function timeBenchmark()
272
        {
273
            self::markTime('finish');
274
        
275
            $lastTime = 0;
276
            $startTime = 0;
277
            $p = 0;
278

279
            echo '<table cellpadding="3" cellspacing="1">
280
                    <thead><tr style="border-bottom:1px solid silver"><td colspan="2" style="text-align:center">BENCHMARK</td></tr></thead>
281
                    <tbody>';
282

283
            foreach($GLOBALS['qr_time_bench'] as $markerId=>$thisTime) {
284
                if ($p > 0) {
285
                    echo '<tr><th style="text-align:right">till '.$markerId.': </th><td>'.number_format($thisTime-$lastTime, 6).'s</td></tr>';
286
                } else {
287
                    $startTime = $thisTime;
288
                }
289
                
290
                $p++;
291
                $lastTime = $thisTime;
292
            }
293
            
294
            echo '</tbody><tfoot>
295
                <tr style="border-top:2px solid black"><th style="text-align:right">TOTAL: </th><td>'.number_format($lastTime-$startTime, 6).'s</td></tr>
296
            </tfoot>
297
            </table>';
298
        }
299
        
300
    }
301
    
302
    //##########################################################################
303
    
304
    QRtools::markTime('start');
305
    
306

307

308

309
//---- qrspec.php -----------------------------
310

311

312

313

314
/*
315
 * PHP QR Code encoder
316
 *
317
 * QR Code specifications
318
 *
319
 * Based on libqrencode C library distributed under LGPL 2.1
320
 * Copyright (C) 2006, 2007, 2008, 2009 Kentaro Fukuchi <[email protected]>
321
 *
322
 * PHP QR Code is distributed under LGPL 3
323
 * Copyright (C) 2010 Dominik Dzienia <deltalab at poczta dot fm>
324
 *
325
 * The following data / specifications are taken from
326
 * "Two dimensional symbol -- QR-code -- Basic Specification" (JIS X0510:2004)
327
 *  or
328
 * "Automatic identification and data capture techniques -- 
329
 *  QR Code 2005 bar code symbology specification" (ISO/IEC 18004:2006)
330
 *
331
 * This library is free software; you can redistribute it and/or
332
 * modify it under the terms of the GNU Lesser General Public
333
 * License as published by the Free Software Foundation; either
334
 * version 3 of the License, or any later version.
335
 *
336
 * This library is distributed in the hope that it will be useful,
337
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
338
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
339
 * Lesser General Public License for more details.
340
 *
341
 * You should have received a copy of the GNU Lesser General Public
342
 * License along with this library; if not, write to the Free Software
343
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
344
 */
345
 
346
    define('QRSPEC_VERSION_MAX', 40);
347
    define('QRSPEC_WIDTH_MAX',   177);
348

349
    define('QRCAP_WIDTH',        0);
350
    define('QRCAP_WORDS',        1);
351
    define('QRCAP_REMINDER',     2);
352
    define('QRCAP_EC',           3);
353

354
    class QRspec {
355
    
356
        public static $capacity = array(
357
            array(  0,    0, 0, array(   0,    0,    0,    0)),
358
            array( 21,   26, 0, array(   7,   10,   13,   17)), // 1
359
            array( 25,   44, 7, array(  10,   16,   22,   28)),
360
            array( 29,   70, 7, array(  15,   26,   36,   44)),
361
            array( 33,  100, 7, array(  20,   36,   52,   64)),
362
            array( 37,  134, 7, array(  26,   48,   72,   88)), // 5
363
            array( 41,  172, 7, array(  36,   64,   96,  112)),
364
            array( 45,  196, 0, array(  40,   72,  108,  130)),
365
            array( 49,  242, 0, array(  48,   88,  132,  156)),
366
            array( 53,  292, 0, array(  60,  110,  160,  192)),
367
            array( 57,  346, 0, array(  72,  130,  192,  224)), //10
368
            array( 61,  404, 0, array(  80,  150,  224,  264)),
369
            array( 65,  466, 0, array(  96,  176,  260,  308)),
370
            array( 69,  532, 0, array( 104,  198,  288,  352)),
371
            array( 73,  581, 3, array( 120,  216,  320,  384)),
372
            array( 77,  655, 3, array( 132,  240,  360,  432)), //15
373
            array( 81,  733, 3, array( 144,  280,  408,  480)),
374
            array( 85,  815, 3, array( 168,  308,  448,  532)),
375
            array( 89,  901, 3, array( 180,  338,  504,  588)),
376
            array( 93,  991, 3, array( 196,  364,  546,  650)),
377
            array( 97, 1085, 3, array( 224,  416,  600,  700)), //20
378
            array(101, 1156, 4, array( 224,  442,  644,  750)),
379
            array(105, 1258, 4, array( 252,  476,  690,  816)),
380
            array(109, 1364, 4, array( 270,  504,  750,  900)),
381
            array(113, 1474, 4, array( 300,  560,  810,  960)),
382
            array(117, 1588, 4, array( 312,  588,  870, 1050)), //25
383
            array(121, 1706, 4, array( 336,  644,  952, 1110)),
384
            array(125, 1828, 4, array( 360,  700, 1020, 1200)),
385
            array(129, 1921, 3, array( 390,  728, 1050, 1260)),
386
            array(133, 2051, 3, array( 420,  784, 1140, 1350)),
387
            array(137, 2185, 3, array( 450,  812, 1200, 1440)), //30
388
            array(141, 2323, 3, array( 480,  868, 1290, 1530)),
389
            array(145, 2465, 3, array( 510,  924, 1350, 1620)),
390
            array(149, 2611, 3, array( 540,  980, 1440, 1710)),
391
            array(153, 2761, 3, array( 570, 1036, 1530, 1800)),
392
            array(157, 2876, 0, array( 570, 1064, 1590, 1890)), //35
393
            array(161, 3034, 0, array( 600, 1120, 1680, 1980)),
394
            array(165, 3196, 0, array( 630, 1204, 1770, 2100)),
395
            array(169, 3362, 0, array( 660, 1260, 1860, 2220)),
396
            array(173, 3532, 0, array( 720, 1316, 1950, 2310)),
397
            array(177, 3706, 0, array( 750, 1372, 2040, 2430)) //40
398
        );
399
        
400
        //----------------------------------------------------------------------
401
        public static function getDataLength($version, $level)
402
        {
403
            return self::$capacity[$version][QRCAP_WORDS] - self::$capacity[$version][QRCAP_EC][$level];
404
        }
405
        
406
        //----------------------------------------------------------------------
407
        public static function getECCLength($version, $level)
408
        {
409
            return self::$capacity[$version][QRCAP_EC][$level];
410
        }
411
        
412
        //----------------------------------------------------------------------
413
        public static function getWidth($version)
414
        {
415
            return self::$capacity[$version][QRCAP_WIDTH];
416
        }
417
        
418
        //----------------------------------------------------------------------
419
        public static function getRemainder($version)
420
        {
421
            return self::$capacity[$version][QRCAP_REMINDER];
422
        }
423
        
424
        //----------------------------------------------------------------------
425
        public static function getMinimumVersion($size, $level)
426
        {
427

428
            for($i=1; $i<= QRSPEC_VERSION_MAX; $i++) {
429
                $words  = self::$capacity[$i][QRCAP_WORDS] - self::$capacity[$i][QRCAP_EC][$level];
430
                if($words >= $size) 
431
                    return $i;
432
            }
433

434
            return -1;
435
        }
436
    
437
        //######################################################################
438
        
439
        public static $lengthTableBits = array(
440
            array(10, 12, 14),
441
            array( 9, 11, 13),
442
            array( 8, 16, 16),
443
            array( 8, 10, 12)
444
        );
445
        
446
        //----------------------------------------------------------------------
447
        public static function lengthIndicator($mode, $version)
448
        {
449
            if ($mode == QR_MODE_STRUCTURE)
450
                return 0;
451
                
452
            if ($version <= 9) {
453
                $l = 0;
454
            } else if ($version <= 26) {
455
                $l = 1;
456
            } else {
457
                $l = 2;
458
            }
459

460
            return self::$lengthTableBits[$mode][$l];
461
        }
462
        
463
        //----------------------------------------------------------------------
464
        public static function maximumWords($mode, $version)
465
        {
466
            if($mode == QR_MODE_STRUCTURE) 
467
                return 3;
468
                
469
            if($version <= 9) {
470
                $l = 0;
471
            } else if($version <= 26) {
472
                $l = 1;
473
            } else {
474
                $l = 2;
475
            }
476

477
            $bits = self::$lengthTableBits[$mode][$l];
478
            $words = (1 << $bits) - 1;
479
            
480
            if($mode == QR_MODE_KANJI) {
481
                $words *= 2; // the number of bytes is required
482
            }
483

484
            return $words;
485
        }
486

487
        // Error correction code -----------------------------------------------
488
        // Table of the error correction code (Reed-Solomon block)
489
        // See Table 12-16 (pp.30-36), JIS X0510:2004.
490

491
        public static $eccTable = array(
492
            array(array( 0,  0), array( 0,  0), array( 0,  0), array( 0,  0)),
493
            array(array( 1,  0), array( 1,  0), array( 1,  0), array( 1,  0)), // 1
494
            array(array( 1,  0), array( 1,  0), array( 1,  0), array( 1,  0)),
495
            array(array( 1,  0), array( 1,  0), array( 2,  0), array( 2,  0)),
496
            array(array( 1,  0), array( 2,  0), array( 2,  0), array( 4,  0)),
497
            array(array( 1,  0), array( 2,  0), array( 2,  2), array( 2,  2)), // 5
498
            array(array( 2,  0), array( 4,  0), array( 4,  0), array( 4,  0)),
499
            array(array( 2,  0), array( 4,  0), array( 2,  4), array( 4,  1)),
500
            array(array( 2,  0), array( 2,  2), array( 4,  2), array( 4,  2)),
501
            array(array( 2,  0), array( 3,  2), array( 4,  4), array( 4,  4)),
502
            array(array( 2,  2), array( 4,  1), array( 6,  2), array( 6,  2)), //10
503
            array(array( 4,  0), array( 1,  4), array( 4,  4), array( 3,  8)),
504
            array(array( 2,  2), array( 6,  2), array( 4,  6), array( 7,  4)),
505
            array(array( 4,  0), array( 8,  1), array( 8,  4), array(12,  4)),
506
            array(array( 3,  1), array( 4,  5), array(11,  5), array(11,  5)),
507
            array(array( 5,  1), array( 5,  5), array( 5,  7), array(11,  7)), //15
508
            array(array( 5,  1), array( 7,  3), array(15,  2), array( 3, 13)),
509
            array(array( 1,  5), array(10,  1), array( 1, 15), array( 2, 17)),
510
            array(array( 5,  1), array( 9,  4), array(17,  1), array( 2, 19)),
511
            array(array( 3,  4), array( 3, 11), array(17,  4), array( 9, 16)),
512
            array(array( 3,  5), array( 3, 13), array(15,  5), array(15, 10)), //20
513
            array(array( 4,  4), array(17,  0), array(17,  6), array(19,  6)),
514
            array(array( 2,  7), array(17,  0), array( 7, 16), array(34,  0)),
515
            array(array( 4,  5), array( 4, 14), array(11, 14), array(16, 14)),
516
            array(array( 6,  4), array( 6, 14), array(11, 16), array(30,  2)),
517
            array(array( 8,  4), array( 8, 13), array( 7, 22), array(22, 13)), //25
518
            array(array(10,  2), array(19,  4), array(28,  6), array(33,  4)),
519
            array(array( 8,  4), array(22,  3), array( 8, 26), array(12, 28)),
520
            array(array( 3, 10), array( 3, 23), array( 4, 31), array(11, 31)),
521
            array(array( 7,  7), array(21,  7), array( 1, 37), array(19, 26)),
522
            array(array( 5, 10), array(19, 10), array(15, 25), array(23, 25)), //30
523
            array(array(13,  3), array( 2, 29), array(42,  1), array(23, 28)),
524
            array(array(17,  0), array(10, 23), array(10, 35), array(19, 35)),
525
            array(array(17,  1), array(14, 21), array(29, 19), array(11, 46)),
526
            array(array(13,  6), array(14, 23), array(44,  7), array(59,  1)),
527
            array(array(12,  7), array(12, 26), array(39, 14), array(22, 41)), //35
528
            array(array( 6, 14), array( 6, 34), array(46, 10), array( 2, 64)),
529
            array(array(17,  4), array(29, 14), array(49, 10), array(24, 46)),
530
            array(array( 4, 18), array(13, 32), array(48, 14), array(42, 32)),
531
            array(array(20,  4), array(40,  7), array(43, 22), array(10, 67)),
532
            array(array(19,  6), array(18, 31), array(34, 34), array(20, 61)),//40
533
        );                                                                       
534

535
        //----------------------------------------------------------------------
536
        // CACHEABLE!!!
537
        
538
        public static function getEccSpec($version, $level, array &$spec)
539
        {
540
            if (count($spec) < 5) {
541
                $spec = array(0,0,0,0,0);
542
            }
543

544
            $b1   = self::$eccTable[$version][$level][0];
545
            $b2   = self::$eccTable[$version][$level][1];
546
            $data = self::getDataLength($version, $level);
547
            $ecc  = self::getECCLength($version, $level);
548

549
            if($b2 == 0) {
550
                $spec[0] = $b1;
551
                $spec[1] = (int)($data / $b1);
552
                $spec[2] = (int)($ecc / $b1);
553
                $spec[3] = 0; 
554
                $spec[4] = 0;
555
            } else {
556
                $spec[0] = $b1;
557
                $spec[1] = (int)($data / ($b1 + $b2));
558
                $spec[2] = (int)($ecc  / ($b1 + $b2));
559
                $spec[3] = $b2;
560
                $spec[4] = $spec[1] + 1;
561
            }
562
        }
563

564
        // Alignment pattern ---------------------------------------------------
565

566
        // Positions of alignment patterns.
567
        // This array includes only the second and the third position of the 
568
        // alignment patterns. Rest of them can be calculated from the distance 
569
        // between them.
570
         
571
        // See Table 1 in Appendix E (pp.71) of JIS X0510:2004.
572
         
573
        public static $alignmentPattern = array(      
574
            array( 0,  0),
575
            array( 0,  0), array(18,  0), array(22,  0), array(26,  0), array(30,  0), // 1- 5
576
            array(34,  0), array(22, 38), array(24, 42), array(26, 46), array(28, 50), // 6-10
577
            array(30, 54), array(32, 58), array(34, 62), array(26, 46), array(26, 48), //11-15
578
            array(26, 50), array(30, 54), array(30, 56), array(30, 58), array(34, 62), //16-20
579
            array(28, 50), array(26, 50), array(30, 54), array(28, 54), array(32, 58), //21-25
580
            array(30, 58), array(34, 62), array(26, 50), array(30, 54), array(26, 52), //26-30
581
            array(30, 56), array(34, 60), array(30, 58), array(34, 62), array(30, 54), //31-35
582
            array(24, 50), array(28, 54), array(32, 58), array(26, 54), array(30, 58), //35-40
583
        );                                                                                  
584

585
        
586
        /** --------------------------------------------------------------------
587
         * Put an alignment marker.
588
         * @param frame
589
         * @param width
590
         * @param ox,oy center coordinate of the pattern
591
         */
592
        public static function putAlignmentMarker(array &$frame, $ox, $oy)
593
        {
594
            $finder = array(
595
                "\xa1\xa1\xa1\xa1\xa1",
596
                "\xa1\xa0\xa0\xa0\xa1",
597
                "\xa1\xa0\xa1\xa0\xa1",
598
                "\xa1\xa0\xa0\xa0\xa1",
599
                "\xa1\xa1\xa1\xa1\xa1"
600
            );                        
601
            
602
            $yStart = $oy-2;         
603
            $xStart = $ox-2;
604
            
605
            for($y=0; $y<5; $y++) {
606
                QRstr::set($frame, $xStart, $yStart+$y, $finder[$y]);
607
            }
608
        }
609

610
        //----------------------------------------------------------------------
611
        public static function putAlignmentPattern($version, &$frame, $width)
612
        {
613
            if($version < 2)
614
                return;
615

616
            $d = self::$alignmentPattern[$version][1] - self::$alignmentPattern[$version][0];
617
            if($d < 0) {
618
                $w = 2;
619
            } else {
620
                $w = (int)(($width - self::$alignmentPattern[$version][0]) / $d + 2);
621
            }
622

623
            if($w * $w - 3 == 1) {
624
                $x = self::$alignmentPattern[$version][0];
625
                $y = self::$alignmentPattern[$version][0];
626
                self::putAlignmentMarker($frame, $x, $y);
627
                return;
628
            }
629

630
            $cx = self::$alignmentPattern[$version][0];
631
            for($x=1; $x<$w - 1; $x++) {
632
                self::putAlignmentMarker($frame, 6, $cx);
633
                self::putAlignmentMarker($frame, $cx,  6);
634
                $cx += $d;
635
            }
636

637
            $cy = self::$alignmentPattern[$version][0];
638
            for($y=0; $y<$w-1; $y++) {
639
                $cx = self::$alignmentPattern[$version][0];
640
                for($x=0; $x<$w-1; $x++) {
641
                    self::putAlignmentMarker($frame, $cx, $cy);
642
                    $cx += $d;
643
                }
644
                $cy += $d;
645
            }
646
        }
647

648
        // Version information pattern -----------------------------------------
649

650
		// Version information pattern (BCH coded).
651
        // See Table 1 in Appendix D (pp.68) of JIS X0510:2004.
652
        
653
		// size: [QRSPEC_VERSION_MAX - 6]
654
		
655
        public static $versionPattern = array(
656
            0x07c94, 0x085bc, 0x09a99, 0x0a4d3, 0x0bbf6, 0x0c762, 0x0d847, 0x0e60d,
657
            0x0f928, 0x10b78, 0x1145d, 0x12a17, 0x13532, 0x149a6, 0x15683, 0x168c9,
658
            0x177ec, 0x18ec4, 0x191e1, 0x1afab, 0x1b08e, 0x1cc1a, 0x1d33f, 0x1ed75,
659
            0x1f250, 0x209d5, 0x216f0, 0x228ba, 0x2379f, 0x24b0b, 0x2542e, 0x26a64,
660
            0x27541, 0x28c69
661
        );
662

663
        //----------------------------------------------------------------------
664
        public static function getVersionPattern($version)
665
        {
666
            if($version < 7 || $version > QRSPEC_VERSION_MAX)
667
                return 0;
668

669
            return self::$versionPattern[$version -7];
670
        }
671

672
        // Format information --------------------------------------------------
673
        // See calcFormatInfo in tests/test_qrspec.c (orginal qrencode c lib)
674
        
675
        public static $formatInfo = array(
676
            array(0x77c4, 0x72f3, 0x7daa, 0x789d, 0x662f, 0x6318, 0x6c41, 0x6976),
677
            array(0x5412, 0x5125, 0x5e7c, 0x5b4b, 0x45f9, 0x40ce, 0x4f97, 0x4aa0),
678
            array(0x355f, 0x3068, 0x3f31, 0x3a06, 0x24b4, 0x2183, 0x2eda, 0x2bed),
679
            array(0x1689, 0x13be, 0x1ce7, 0x19d0, 0x0762, 0x0255, 0x0d0c, 0x083b)
680
        );
681

682
        public static function getFormatInfo($mask, $level)
683
        {
684
            if($mask < 0 || $mask > 7)
685
                return 0;
686
                
687
            if($level < 0 || $level > 3)
688
                return 0;                
689

690
            return self::$formatInfo[$level][$mask];
691
        }
692

693
        // Frame ---------------------------------------------------------------
694
        // Cache of initial frames.
695
         
696
        public static $frames = array();
697

698
        /** --------------------------------------------------------------------
699
         * Put a finder pattern.
700
         * @param frame
701
         * @param width
702
         * @param ox,oy upper-left coordinate of the pattern
703
         */
704
        public static function putFinderPattern(&$frame, $ox, $oy)
705
        {
706
            $finder = array(
707
                "\xc1\xc1\xc1\xc1\xc1\xc1\xc1",
708
                "\xc1\xc0\xc0\xc0\xc0\xc0\xc1",
709
                "\xc1\xc0\xc1\xc1\xc1\xc0\xc1",
710
                "\xc1\xc0\xc1\xc1\xc1\xc0\xc1",
711
                "\xc1\xc0\xc1\xc1\xc1\xc0\xc1",
712
                "\xc1\xc0\xc0\xc0\xc0\xc0\xc1",
713
                "\xc1\xc1\xc1\xc1\xc1\xc1\xc1"
714
            );                            
715
            
716
            for($y=0; $y<7; $y++) {
717
                QRstr::set($frame, $ox, $oy+$y, $finder[$y]);
718
            }
719
        }
720

721
        //----------------------------------------------------------------------
722
        public static function createFrame($version)
723
        {
724
            $width = self::$capacity[$version][QRCAP_WIDTH];
725
            $frameLine = str_repeat ("\0", $width);
726
            $frame = array_fill(0, $width, $frameLine);
727

728
            // Finder pattern
729
            self::putFinderPattern($frame, 0, 0);
730
            self::putFinderPattern($frame, $width - 7, 0);
731
            self::putFinderPattern($frame, 0, $width - 7);
732
            
733
            // Separator
734
            $yOffset = $width - 7;
735
            
736
            for($y=0; $y<7; $y++) {
737
                $frame[$y][7] = "\xc0";
738
                $frame[$y][$width - 8] = "\xc0";
739
                $frame[$yOffset][7] = "\xc0";
740
                $yOffset++;
741
            }
742
            
743
            $setPattern = str_repeat("\xc0", 8);
744
            
745
            QRstr::set($frame, 0, 7, $setPattern);
746
            QRstr::set($frame, $width-8, 7, $setPattern);
747
            QRstr::set($frame, 0, $width - 8, $setPattern);
748
        
749
            // Format info
750
            $setPattern = str_repeat("\x84", 9);
751
            QRstr::set($frame, 0, 8, $setPattern);
752
            QRstr::set($frame, $width - 8, 8, $setPattern, 8);
753
            
754
            $yOffset = $width - 8;
755

756
            for($y=0; $y<8; $y++,$yOffset++) {
757
                $frame[$y][8] = "\x84";
758
                $frame[$yOffset][8] = "\x84";
759
            }
760

761
            // Timing pattern  
762
            
763
            for($i=1; $i<$width-15; $i++) {
764
                $frame[6][7+$i] = chr(0x90 | ($i & 1));
765
                $frame[7+$i][6] = chr(0x90 | ($i & 1));
766
            }
767
            
768
            // Alignment pattern  
769
            self::putAlignmentPattern($version, $frame, $width);
770
            
771
            // Version information 
772
            if($version >= 7) {
773
                $vinf = self::getVersionPattern($version);
774

775
                $v = $vinf;
776
                
777
                for($x=0; $x<6; $x++) {
778
                    for($y=0; $y<3; $y++) {
779
                        $frame[($width - 11)+$y][$x] = chr(0x88 | ($v & 1));
780
                        $v = $v >> 1;
781
                    }
782
                }
783

784
                $v = $vinf;
785
                for($y=0; $y<6; $y++) {
786
                    for($x=0; $x<3; $x++) {
787
                        $frame[$y][$x+($width - 11)] = chr(0x88 | ($v & 1));
788
                        $v = $v >> 1;
789
                    }
790
                }
791
            }
792
    
793
            // and a little bit...  
794
            $frame[$width - 8][8] = "\x81";
795
            
796
            return $frame;
797
        }
798

799
        //----------------------------------------------------------------------
800
        public static function debug($frame, $binary_mode = false)
801
        {
802
            if ($binary_mode) {
803
            
804
                    foreach ($frame as &$frameLine) {
805
                        $frameLine = join('<span class="m">&nbsp;&nbsp;</span>', explode('0', $frameLine));
806
                        $frameLine = join('&#9608;&#9608;', explode('1', $frameLine));
807
                    }
808
                    
809
                    ?>
810
                <style>
811
                    .m { background-color: white; }
812
                </style>
813
                <?php
814
                    echo '<pre><tt><br/ ><br/ ><br/ >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;';
815
                    echo join("<br/ >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;", $frame);
816
                    echo '</tt></pre><br/ ><br/ ><br/ ><br/ ><br/ ><br/ >';
817
            
818
            } else {
819
            
820
                foreach ($frame as &$frameLine) {
821
                    $frameLine = join('<span class="m">&nbsp;</span>',  explode("\xc0", $frameLine));
822
                    $frameLine = join('<span class="m">&#9618;</span>', explode("\xc1", $frameLine));
823
                    $frameLine = join('<span class="p">&nbsp;</span>',  explode("\xa0", $frameLine));
824
                    $frameLine = join('<span class="p">&#9618;</span>', explode("\xa1", $frameLine));
825
                    $frameLine = join('<span class="s">&#9671;</span>', explode("\x84", $frameLine)); //format 0
826
                    $frameLine = join('<span class="s">&#9670;</span>', explode("\x85", $frameLine)); //format 1
827
                    $frameLine = join('<span class="x">&#9762;</span>', explode("\x81", $frameLine)); //special bit
828
                    $frameLine = join('<span class="c">&nbsp;</span>',  explode("\x90", $frameLine)); //clock 0
829
                    $frameLine = join('<span class="c">&#9719;</span>', explode("\x91", $frameLine)); //clock 1
830
                    $frameLine = join('<span class="f">&nbsp;</span>',  explode("\x88", $frameLine)); //version
831
                    $frameLine = join('<span class="f">&#9618;</span>', explode("\x89", $frameLine)); //version
832
                    $frameLine = join('&#9830;', explode("\x01", $frameLine));
833
                    $frameLine = join('&#8901;', explode("\0", $frameLine));
834
                }
835
                
836
                ?>
837
                <style>
838
                    .p { background-color: yellow; }
839
                    .m { background-color: #00FF00; }
840
                    .s { background-color: #FF0000; }
841
                    .c { background-color: aqua; }
842
                    .x { background-color: pink; }
843
                    .f { background-color: gold; }
844
                </style>
845
                <?php
846
                echo "<pre><tt>";
847
                echo join("<br/ >", $frame);
848
                echo "</tt></pre>";
849
            
850
            }
851
        }
852

853
        //----------------------------------------------------------------------
854
        public static function serial($frame)
855
        {
856
            return gzcompress(join("\n", $frame), 9);
857
        }
858
        
859
        //----------------------------------------------------------------------
860
        public static function unserial($code)
861
        {
862
            return explode("\n", gzuncompress($code));
863
        }
864
        
865
        //----------------------------------------------------------------------
866
        public static function newFrame($version)
867
        {
868
            if($version < 1 || $version > QRSPEC_VERSION_MAX) 
869
                return null;
870

871
            if(!isset(self::$frames[$version])) {
872
                
873
                $fileName = QR_CACHE_DIR.'frame_'.$version.'.dat';
874
                
875
                if (QR_CACHEABLE) {
876
                    if (file_exists($fileName)) {
877
                        self::$frames[$version] = self::unserial(file_get_contents($fileName));
878
                    } else {
879
                        self::$frames[$version] = self::createFrame($version);
880
                        file_put_contents($fileName, self::serial(self::$frames[$version]));
881
                    }
882
                } else {
883
                    self::$frames[$version] = self::createFrame($version);
884
                }
885
            }
886
            
887
            if(is_null(self::$frames[$version]))
888
                return null;
889

890
            return self::$frames[$version];
891
        }
892

893
        //----------------------------------------------------------------------
894
        public static function rsBlockNum($spec)     { return $spec[0] + $spec[3]; }
895
        public static function rsBlockNum1($spec)    { return $spec[0]; }
896
        public static function rsDataCodes1($spec)   { return $spec[1]; }
897
        public static function rsEccCodes1($spec)    { return $spec[2]; }
898
        public static function rsBlockNum2($spec)    { return $spec[3]; }
899
        public static function rsDataCodes2($spec)   { return $spec[4]; }
900
        public static function rsEccCodes2($spec)    { return $spec[2]; }
901
        public static function rsDataLength($spec)   { return ($spec[0] * $spec[1]) + ($spec[3] * $spec[4]);    }
902
        public static function rsEccLength($spec)    { return ($spec[0] + $spec[3]) * $spec[2]; }
903
        
904
    }
905

906

907

908
//---- qrimage.php -----------------------------
909

910

911

912

913
/*
914
 * PHP QR Code encoder
915
 *
916
 * Image output of code using GD2
917
 *
918
 * PHP QR Code is distributed under LGPL 3
919
 * Copyright (C) 2010 Dominik Dzienia <deltalab at poczta dot fm>
920
 *
921
 * This library is free software; you can redistribute it and/or
922
 * modify it under the terms of the GNU Lesser General Public
923
 * License as published by the Free Software Foundation; either
924
 * version 3 of the License, or any later version.
925
 *
926
 * This library is distributed in the hope that it will be useful,
927
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
928
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
929
 * Lesser General Public License for more details.
930
 *
931
 * You should have received a copy of the GNU Lesser General Public
932
 * License along with this library; if not, write to the Free Software
933
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
934
 */
935
 
936
    define('QR_IMAGE', true);
937

938
    class QRimage {
939
    
940
        //----------------------------------------------------------------------
941
        public static function png($frame, $filename = false, $pixelPerPoint = 4, $outerFrame = 4,$saveandprint=FALSE) 
942
        {
943
            $image = self::image($frame, $pixelPerPoint, $outerFrame);
944
            
945
            if ($filename === false) {
946
                Header("Content-type: image/png");
947
                ImagePng($image);
948
            } else {
949
                if($saveandprint===TRUE){
950
                    ImagePng($image, $filename);
951
                    header("Content-type: image/png");
952
                    ImagePng($image);
953
                }else{
954
                    ImagePng($image, $filename);
955
                }
956
            }
957
            
958
            ImageDestroy($image);
959
        }
960
    
961
        //----------------------------------------------------------------------
962
        public static function jpg($frame, $filename = false, $pixelPerPoint = 8, $outerFrame = 4, $q = 85) 
963
        {
964
            $image = self::image($frame, $pixelPerPoint, $outerFrame);
965
            
966
            if ($filename === false) {
967
                Header("Content-type: image/jpeg");
968
                ImageJpeg($image, null, $q);
969
            } else {
970
                ImageJpeg($image, $filename, $q);            
971
            }
972
            
973
            ImageDestroy($image);
974
        }
975
    
976
        //----------------------------------------------------------------------
977
        private static function image($frame, $pixelPerPoint = 4, $outerFrame = 4) 
978
        {
979
            $h = count($frame);
980
            $w = strlen($frame[0]);
981
            
982
            $imgW = $w + 2*$outerFrame;
983
            $imgH = $h + 2*$outerFrame;
984
            
985
            $base_image =ImageCreate($imgW, $imgH);
986
            
987
            $col[0] = ImageColorAllocate($base_image,255,255,255);
988
            $col[1] = ImageColorAllocate($base_image,0,0,0);
989

990
            imagefill($base_image, 0, 0, $col[0]);
991

992
            for($y=0; $y<$h; $y++) {
993
                for($x=0; $x<$w; $x++) {
994
                    if ($frame[$y][$x] == '1') {
995
                        ImageSetPixel($base_image,$x+$outerFrame,$y+$outerFrame,$col[1]); 
996
                    }
997
                }
998
            }
999
            
1000
            $target_image =ImageCreate($imgW * $pixelPerPoint, $imgH * $pixelPerPoint);
1001
            ImageCopyResized($target_image, $base_image, 0, 0, 0, 0, $imgW * $pixelPerPoint, $imgH * $pixelPerPoint, $imgW, $imgH);
1002
            ImageDestroy($base_image);
1003
            
1004
            return $target_image;
1005
        }
1006
    }
1007

1008

1009

1010
//---- qrinput.php -----------------------------
1011

1012

1013

1014

1015
/*
1016
 * PHP QR Code encoder
1017
 *
1018
 * Input encoding class
1019
 *
1020
 * Based on libqrencode C library distributed under LGPL 2.1
1021
 * Copyright (C) 2006, 2007, 2008, 2009 Kentaro Fukuchi <[email protected]>
1022
 *
1023
 * PHP QR Code is distributed under LGPL 3
1024
 * Copyright (C) 2010 Dominik Dzienia <deltalab at poczta dot fm>
1025
 *
1026
 * This library is free software; you can redistribute it and/or
1027
 * modify it under the terms of the GNU Lesser General Public
1028
 * License as published by the Free Software Foundation; either
1029
 * version 3 of the License, or any later version.
1030
 *
1031
 * This library is distributed in the hope that it will be useful,
1032
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1033
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1034
 * Lesser General Public License for more details.
1035
 *
1036
 * You should have received a copy of the GNU Lesser General Public
1037
 * License along with this library; if not, write to the Free Software
1038
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
1039
 */
1040
 
1041
    define('STRUCTURE_HEADER_BITS',  20);
1042
    define('MAX_STRUCTURED_SYMBOLS', 16);
1043

1044
    class QRinputItem {
1045
    
1046
        public $mode;
1047
        public $size;
1048
        public $data;
1049
        public $bstream;
1050

1051
        public function __construct($mode, $size, $data, $bstream = null) 
1052
        {
1053
            $setData = array_slice($data, 0, $size);
1054
            
1055
            if (count($setData) < $size) {
1056
                $setData = array_merge($setData, array_fill(0,$size-count($setData),0));
1057
            }
1058
        
1059
            if(!QRinput::check($mode, $size, $setData)) {
1060
                throw new Exception('Error m:'.$mode.',s:'.$size.',d:'.join(',',$setData));
1061
                return null;
1062
            }
1063
            
1064
            $this->mode = $mode;
1065
            $this->size = $size;
1066
            $this->data = $setData;
1067
            $this->bstream = $bstream;
1068
        }
1069
        
1070
        //----------------------------------------------------------------------
1071
        public function encodeModeNum($version)
1072
        {
1073
            try {
1074
            
1075
                $words = (int)($this->size / 3);
1076
                $bs = new QRbitstream();
1077
                
1078
                $val = 0x1;
1079
                $bs->appendNum(4, $val);
1080
                $bs->appendNum(QRspec::lengthIndicator(QR_MODE_NUM, $version), $this->size);
1081

1082
                for($i=0; $i<$words; $i++) {
1083
                    $val  = (ord($this->data[$i*3  ]) - ord('0')) * 100;
1084
                    $val += (ord($this->data[$i*3+1]) - ord('0')) * 10;
1085
                    $val += (ord($this->data[$i*3+2]) - ord('0'));
1086
                    $bs->appendNum(10, $val);
1087
                }
1088

1089
                if($this->size - $words * 3 == 1) {
1090
                    $val = ord($this->data[$words*3]) - ord('0');
1091
                    $bs->appendNum(4, $val);
1092
                } else if($this->size - $words * 3 == 2) {
1093
                    $val  = (ord($this->data[$words*3  ]) - ord('0')) * 10;
1094
                    $val += (ord($this->data[$words*3+1]) - ord('0'));
1095
                    $bs->appendNum(7, $val);
1096
                }
1097

1098
                $this->bstream = $bs;
1099
                return 0;
1100
                
1101
            } catch (Exception $e) {
1102
                return -1;
1103
            }
1104
        }
1105
        
1106
        //----------------------------------------------------------------------
1107
        public function encodeModeAn($version)
1108
        {
1109
            try {
1110
                $words = (int)($this->size / 2);
1111
                $bs = new QRbitstream();
1112
                
1113
                $bs->appendNum(4, 0x02);
1114
                $bs->appendNum(QRspec::lengthIndicator(QR_MODE_AN, $version), $this->size);
1115

1116
                for($i=0; $i<$words; $i++) {
1117
                    $val  = (int)QRinput::lookAnTable(ord($this->data[$i*2  ])) * 45;
1118
                    $val += (int)QRinput::lookAnTable(ord($this->data[$i*2+1]));
1119

1120
                    $bs->appendNum(11, $val);
1121
                }
1122

1123
                if($this->size & 1) {
1124
                    $val = QRinput::lookAnTable(ord($this->data[$words * 2]));
1125
                    $bs->appendNum(6, $val);
1126
                }
1127
        
1128
                $this->bstream = $bs;
1129
                return 0;
1130
            
1131
            } catch (Exception $e) {
1132
                return -1;
1133
            }
1134
        }
1135
        
1136
        //----------------------------------------------------------------------
1137
        public function encodeMode8($version)
1138
        {
1139
            try {
1140
                $bs = new QRbitstream();
1141

1142
                $bs->appendNum(4, 0x4);
1143
                $bs->appendNum(QRspec::lengthIndicator(QR_MODE_8, $version), $this->size);
1144

1145
                for($i=0; $i<$this->size; $i++) {
1146
                    $bs->appendNum(8, ord($this->data[$i]));
1147
                }
1148

1149
                $this->bstream = $bs;
1150
                return 0;
1151
            
1152
            } catch (Exception $e) {
1153
                return -1;
1154
            }
1155
        }
1156
        
1157
        //----------------------------------------------------------------------
1158
        public function encodeModeKanji($version)
1159
        {
1160
            try {
1161

1162
                $bs = new QRbitrtream();
1163
                
1164
                $bs->appendNum(4, 0x8);
1165
                $bs->appendNum(QRspec::lengthIndicator(QR_MODE_KANJI, $version), (int)($this->size / 2));
1166

1167
                for($i=0; $i<$this->size; $i+=2) {
1168
                    $val = (ord($this->data[$i]) << 8) | ord($this->data[$i+1]);
1169
                    if($val <= 0x9ffc) {
1170
                        $val -= 0x8140;
1171
                    } else {
1172
                        $val -= 0xc140;
1173
                    }
1174
                    
1175
                    $h = ($val >> 8) * 0xc0;
1176
                    $val = ($val & 0xff) + $h;
1177

1178
                    $bs->appendNum(13, $val);
1179
                }
1180

1181
                $this->bstream = $bs;
1182
                return 0;
1183
            
1184
            } catch (Exception $e) {
1185
                return -1;
1186
            }
1187
        }
1188

1189
        //----------------------------------------------------------------------
1190
        public function encodeModeStructure()
1191
        {
1192
            try {
1193
                $bs =  new QRbitstream();
1194
                
1195
                $bs->appendNum(4, 0x03);
1196
                $bs->appendNum(4, ord($this->data[1]) - 1);
1197
                $bs->appendNum(4, ord($this->data[0]) - 1);
1198
                $bs->appendNum(8, ord($this->data[2]));
1199

1200
                $this->bstream = $bs;
1201
                return 0;
1202
            
1203
            } catch (Exception $e) {
1204
                return -1;
1205
            }
1206
        }
1207
        
1208
        //----------------------------------------------------------------------
1209
        public function estimateBitStreamSizeOfEntry($version)
1210
        {
1211
            $bits = 0;
1212

1213
            if($version == 0) 
1214
                $version = 1;
1215

1216
            switch($this->mode) {
1217
                case QR_MODE_NUM:        $bits = QRinput::estimateBitsModeNum($this->size);    break;
1218
                case QR_MODE_AN:        $bits = QRinput::estimateBitsModeAn($this->size);    break;
1219
                case QR_MODE_8:            $bits = QRinput::estimateBitsMode8($this->size);    break;
1220
                case QR_MODE_KANJI:        $bits = QRinput::estimateBitsModeKanji($this->size);break;
1221
                case QR_MODE_STRUCTURE:    return STRUCTURE_HEADER_BITS;            
1222
                default:
1223
                    return 0;
1224
            }
1225

1226
            $l = QRspec::lengthIndicator($this->mode, $version);
1227
            $m = 1 << $l;
1228
            $num = (int)(($this->size + $m - 1) / $m);
1229

1230
            $bits += $num * (4 + $l);
1231

1232
            return $bits;
1233
        }
1234
        
1235
        //----------------------------------------------------------------------
1236
        public function encodeBitStream($version)
1237
        {
1238
            try {
1239
            
1240
                unset($this->bstream);
1241
                $words = QRspec::maximumWords($this->mode, $version);
1242
                
1243
                if($this->size > $words) {
1244
                
1245
                    $st1 = new QRinputItem($this->mode, $words, $this->data);
1246
                    $st2 = new QRinputItem($this->mode, $this->size - $words, array_slice($this->data, $words));
1247

1248
                    $st1->encodeBitStream($version);
1249
                    $st2->encodeBitStream($version);
1250
                    
1251
                    $this->bstream = new QRbitstream();
1252
                    $this->bstream->append($st1->bstream);
1253
                    $this->bstream->append($st2->bstream);
1254
                    
1255
                    unset($st1);
1256
                    unset($st2);
1257
                    
1258
                } else {
1259
                    
1260
                    $ret = 0;
1261
                    
1262
                    switch($this->mode) {
1263
                        case QR_MODE_NUM:        $ret = $this->encodeModeNum($version);    break;
1264
                        case QR_MODE_AN:        $ret = $this->encodeModeAn($version);    break;
1265
                        case QR_MODE_8:            $ret = $this->encodeMode8($version);    break;
1266
                        case QR_MODE_KANJI:        $ret = $this->encodeModeKanji($version);break;
1267
                        case QR_MODE_STRUCTURE:    $ret = $this->encodeModeStructure();    break;
1268
                        
1269
                        default:
1270
                            break;
1271
                    }
1272
                    
1273
                    if($ret < 0)
1274
                        return -1;
1275
                }
1276

1277
                return $this->bstream->size();
1278
            
1279
            } catch (Exception $e) {
1280
                return -1;
1281
            }
1282
        }
1283
    };
1284
    
1285
    //##########################################################################
1286

1287
    class QRinput {
1288

1289
        public $items;
1290
        
1291
        private $version;
1292
        private $level;
1293
        
1294
        //----------------------------------------------------------------------
1295
        public function __construct($version = 0, $level = QR_ECLEVEL_L)
1296
        {
1297
            if ($version < 0 || $version > QRSPEC_VERSION_MAX || $level > QR_ECLEVEL_H) {
1298
                throw new Exception('Invalid version no');
1299
                return NULL;
1300
            }
1301
            
1302
            $this->version = $version;
1303
            $this->level = $level;
1304
        }
1305
        
1306
        //----------------------------------------------------------------------
1307
        public function getVersion()
1308
        {
1309
            return $this->version;
1310
        }
1311
        
1312
        //----------------------------------------------------------------------
1313
        public function setVersion($version)
1314
        {
1315
            if($version < 0 || $version > QRSPEC_VERSION_MAX) {
1316
                throw new Exception('Invalid version no');
1317
                return -1;
1318
            }
1319

1320
            $this->version = $version;
1321

1322
            return 0;
1323
        }
1324
        
1325
        //----------------------------------------------------------------------
1326
        public function getErrorCorrectionLevel()
1327
        {
1328
            return $this->level;
1329
        }
1330

1331
        //----------------------------------------------------------------------
1332
        public function setErrorCorrectionLevel($level)
1333
        {
1334
            if($level > QR_ECLEVEL_H) {
1335
                throw new Exception('Invalid ECLEVEL');
1336
                return -1;
1337
            }
1338

1339
            $this->level = $level;
1340

1341
            return 0;
1342
        }
1343
        
1344
        //----------------------------------------------------------------------
1345
        public function appendEntry(QRinputItem $entry)
1346
        {
1347
            $this->items[] = $entry;
1348
        }
1349
        
1350
        //----------------------------------------------------------------------
1351
        public function append($mode, $size, $data)
1352
        {
1353
            try {
1354
                $entry = new QRinputItem($mode, $size, $data);
1355
                $this->items[] = $entry;
1356
                return 0;
1357
            } catch (Exception $e) {
1358
                return -1;
1359
            }
1360
        }
1361
        
1362
        //----------------------------------------------------------------------
1363
        
1364
        public function insertStructuredAppendHeader($size, $index, $parity)
1365
        {
1366
            if( $size > MAX_STRUCTURED_SYMBOLS ) {
1367
                throw new Exception('insertStructuredAppendHeader wrong size');
1368
            }
1369
            
1370
            if( $index <= 0 || $index > MAX_STRUCTURED_SYMBOLS ) {
1371
                throw new Exception('insertStructuredAppendHeader wrong index');
1372
            }
1373

1374
            $buf = array($size, $index, $parity);
1375
            
1376
            try {
1377
                $entry = new QRinputItem(QR_MODE_STRUCTURE, 3, buf);
1378
                array_unshift($this->items, $entry);
1379
                return 0;
1380
            } catch (Exception $e) {
1381
                return -1;
1382
            }
1383
        }
1384

1385
        //----------------------------------------------------------------------
1386
        public function calcParity()
1387
        {
1388
            $parity = 0;
1389
            
1390
            foreach($this->items as $item) {
1391
                if($item->mode != QR_MODE_STRUCTURE) {
1392
                    for($i=$item->size-1; $i>=0; $i--) {
1393
                        $parity ^= $item->data[$i];
1394
                    }
1395
                }
1396
            }
1397

1398
            return $parity;
1399
        }
1400
        
1401
        //----------------------------------------------------------------------
1402
        public static function checkModeNum($size, $data)
1403
        {
1404
            for($i=0; $i<$size; $i++) {
1405
                if((ord($data[$i]) < ord('0')) || (ord($data[$i]) > ord('9'))){
1406
                    return false;
1407
                }
1408
            }
1409

1410
            return true;
1411
        }
1412

1413
        //----------------------------------------------------------------------
1414
        public static function estimateBitsModeNum($size)
1415
        {
1416
            $w = (int)$size / 3;
1417
            $bits = $w * 10;
1418
            
1419
            switch($size - $w * 3) {
1420
                case 1:
1421
                    $bits += 4;
1422
                    break;
1423
                case 2:
1424
                    $bits += 7;
1425
                    break;
1426
                default:
1427
                    break;
1428
            }
1429

1430
            return $bits;
1431
        }
1432
        
1433
        //----------------------------------------------------------------------
1434
        public static $anTable = array(
1435
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1436
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1437
            36, -1, -1, -1, 37, 38, -1, -1, -1, -1, 39, 40, -1, 41, 42, 43,
1438
             0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 44, -1, -1, -1, -1, -1,
1439
            -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1440
            25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1,
1441
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1442
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
1443
        );
1444
        
1445
        //----------------------------------------------------------------------
1446
        public static function lookAnTable($c)
1447
        {
1448
            return (($c > 127)?-1:self::$anTable[$c]);
1449
        }
1450
        
1451
        //----------------------------------------------------------------------
1452
        public static function checkModeAn($size, $data)
1453
        {
1454
            for($i=0; $i<$size; $i++) {
1455
                if (self::lookAnTable(ord($data[$i])) == -1) {
1456
                    return false;
1457
                }
1458
            }
1459

1460
            return true;
1461
        }
1462
        
1463
        //----------------------------------------------------------------------
1464
        public static function estimateBitsModeAn($size)
1465
        {
1466
            $w = (int)($size / 2);
1467
            $bits = $w * 11;
1468
            
1469
            if($size & 1) {
1470
                $bits += 6;
1471
            }
1472

1473
            return $bits;
1474
        }
1475
    
1476
        //----------------------------------------------------------------------
1477
        public static function estimateBitsMode8($size)
1478
        {
1479
            return $size * 8;
1480
        }
1481
        
1482
        //----------------------------------------------------------------------
1483
        public function estimateBitsModeKanji($size)
1484
        {
1485
            return (int)(($size / 2) * 13);
1486
        }
1487
        
1488
        //----------------------------------------------------------------------
1489
        public static function checkModeKanji($size, $data)
1490
        {
1491
            if($size & 1)
1492
                return false;
1493

1494
            for($i=0; $i<$size; $i+=2) {
1495
                $val = (ord($data[$i]) << 8) | ord($data[$i+1]);
1496
                if( $val < 0x8140 
1497
                || ($val > 0x9ffc && $val < 0xe040) 
1498
                || $val > 0xebbf) {
1499
                    return false;
1500
                }
1501
            }
1502

1503
            return true;
1504
        }
1505

1506
        /***********************************************************************
1507
         * Validation
1508
         **********************************************************************/
1509

1510
        public static function check($mode, $size, $data)
1511
        {
1512
            if($size <= 0) 
1513
                return false;
1514

1515
            switch($mode) {
1516
                case QR_MODE_NUM:       return self::checkModeNum($size, $data);   break;
1517
                case QR_MODE_AN:        return self::checkModeAn($size, $data);    break;
1518
                case QR_MODE_KANJI:     return self::checkModeKanji($size, $data); break;
1519
                case QR_MODE_8:         return true; break;
1520
                case QR_MODE_STRUCTURE: return true; break;
1521
                
1522
                default:
1523
                    break;
1524
            }
1525

1526
            return false;
1527
        }
1528
        
1529
        
1530
        //----------------------------------------------------------------------
1531
        public function estimateBitStreamSize($version)
1532
        {
1533
            $bits = 0;
1534

1535
            foreach($this->items as $item) {
1536
                $bits += $item->estimateBitStreamSizeOfEntry($version);
1537
            }
1538

1539
            return $bits;
1540
        }
1541
        
1542
        //----------------------------------------------------------------------
1543
        public function estimateVersion()
1544
        {
1545
            $version = 0;
1546
            $prev = 0;
1547
            do {
1548
                $prev = $version;
1549
                $bits = $this->estimateBitStreamSize($prev);
1550
                $version = QRspec::getMinimumVersion((int)(($bits + 7) / 8), $this->level);
1551
                if ($version < 0) {
1552
                    return -1;
1553
                }
1554
            } while ($version > $prev);
1555

1556
            return $version;
1557
        }
1558
        
1559
        //----------------------------------------------------------------------
1560
        public static function lengthOfCode($mode, $version, $bits)
1561
        {
1562
            $payload = $bits - 4 - QRspec::lengthIndicator($mode, $version);
1563
            switch($mode) {
1564
                case QR_MODE_NUM:
1565
                    $chunks = (int)($payload / 10);
1566
                    $remain = $payload - $chunks * 10;
1567
                    $size = $chunks * 3;
1568
                    if($remain >= 7) {
1569
                        $size += 2;
1570
                    } else if($remain >= 4) {
1571
                        $size += 1;
1572
                    }
1573
                    break;
1574
                case QR_MODE_AN:
1575
                    $chunks = (int)($payload / 11);
1576
                    $remain = $payload - $chunks * 11;
1577
                    $size = $chunks * 2;
1578
                    if($remain >= 6) 
1579
                        $size++;
1580
                    break;
1581
                case QR_MODE_8:
1582
                    $size = (int)($payload / 8);
1583
                    break;
1584
                case QR_MODE_KANJI:
1585
                    $size = (int)(($payload / 13) * 2);
1586
                    break;
1587
                case QR_MODE_STRUCTURE:
1588
                    $size = (int)($payload / 8);
1589
                    break;
1590
                default:
1591
                    $size = 0;
1592
                    break;
1593
            }
1594
            
1595
            $maxsize = QRspec::maximumWords($mode, $version);
1596
            if($size < 0) $size = 0;
1597
            if($size > $maxsize) $size = $maxsize;
1598

1599
            return $size;
1600
        }
1601
        
1602
        //----------------------------------------------------------------------
1603
        public function createBitStream()
1604
        {
1605
            $total = 0;
1606

1607
            foreach($this->items as $item) {
1608
                $bits = $item->encodeBitStream($this->version);
1609
                
1610
                if($bits < 0) 
1611
                    return -1;
1612
                    
1613
                $total += $bits;
1614
            }
1615

1616
            return $total;
1617
        }
1618
        
1619
        //----------------------------------------------------------------------
1620
        public function convertData()
1621
        {
1622
            $ver = $this->estimateVersion();
1623
            if($ver > $this->getVersion()) {
1624
                $this->setVersion($ver);
1625
            }
1626

1627
            for(;;) {
1628
                $bits = $this->createBitStream();
1629
                
1630
                if($bits < 0) 
1631
                    return -1;
1632
                    
1633
                $ver = QRspec::getMinimumVersion((int)(($bits + 7) / 8), $this->level);
1634
                if($ver < 0) {
1635
                    throw new Exception('WRONG VERSION');
1636
                    return -1;
1637
                } else if($ver > $this->getVersion()) {
1638
                    $this->setVersion($ver);
1639
                } else {
1640
                    break;
1641
                }
1642
            }
1643

1644
            return 0;
1645
        }
1646
        
1647
        //----------------------------------------------------------------------
1648
        public function appendPaddingBit(&$bstream)
1649
        {
1650
            $bits = $bstream->size();
1651
            $maxwords = QRspec::getDataLength($this->version, $this->level);
1652
            $maxbits = $maxwords * 8;
1653

1654
            if ($maxbits == $bits) {
1655
                return 0;
1656
            }
1657

1658
            if ($maxbits - $bits < 5) {
1659
                return $bstream->appendNum($maxbits - $bits, 0);
1660
            }
1661

1662
            $bits += 4;
1663
            $words = (int)(($bits + 7) / 8);
1664

1665
            $padding = new QRbitstream();
1666
            $ret = $padding->appendNum($words * 8 - $bits + 4, 0);
1667
            
1668
            if($ret < 0) 
1669
                return $ret;
1670

1671
            $padlen = $maxwords - $words;
1672
            
1673
            if($padlen > 0) {
1674
                
1675
                $padbuf = array();
1676
                for($i=0; $i<$padlen; $i++) {
1677
                    $padbuf[$i] = ($i&1)?0x11:0xec;
1678
                }
1679
                
1680
                $ret = $padding->appendBytes($padlen, $padbuf);
1681
                
1682
                if($ret < 0)
1683
                    return $ret;
1684
                
1685
            }
1686

1687
            $ret = $bstream->append($padding);
1688
            
1689
            return $ret;
1690
        }
1691

1692
        //----------------------------------------------------------------------
1693
        public function mergeBitStream()
1694
        {
1695
            if($this->convertData() < 0) {
1696
                return null;
1697
            }
1698

1699
            $bstream = new QRbitstream();
1700
            
1701
            foreach($this->items as $item) {
1702
                $ret = $bstream->append($item->bstream);
1703
                if($ret < 0) {
1704
                    return null;
1705
                }
1706
            }
1707

1708
            return $bstream;
1709
        }
1710

1711
        //----------------------------------------------------------------------
1712
        public function getBitStream()
1713
        {
1714

1715
            $bstream = $this->mergeBitStream();
1716
            
1717
            if($bstream == null) {
1718
                return null;
1719
            }
1720
            
1721
            $ret = $this->appendPaddingBit($bstream);
1722
            if($ret < 0) {
1723
                return null;
1724
            }
1725

1726
            return $bstream;
1727
        }
1728
        
1729
        //----------------------------------------------------------------------
1730
        public function getByteStream()
1731
        {
1732
            $bstream = $this->getBitStream();
1733
            if($bstream == null) {
1734
                return null;
1735
            }
1736
            
1737
            return $bstream->toByte();
1738
        }
1739
    }
1740
        
1741
        
1742
    
1743

1744

1745

1746
//---- qrbitstream.php -----------------------------
1747

1748

1749

1750

1751
/*
1752
 * PHP QR Code encoder
1753
 *
1754
 * Bitstream class
1755
 *
1756
 * Based on libqrencode C library distributed under LGPL 2.1
1757
 * Copyright (C) 2006, 2007, 2008, 2009 Kentaro Fukuchi <[email protected]>
1758
 *
1759
 * PHP QR Code is distributed under LGPL 3
1760
 * Copyright (C) 2010 Dominik Dzienia <deltalab at poczta dot fm>
1761
 *
1762
 * This library is free software; you can redistribute it and/or
1763
 * modify it under the terms of the GNU Lesser General Public
1764
 * License as published by the Free Software Foundation; either
1765
 * version 3 of the License, or any later version.
1766
 *
1767
 * This library is distributed in the hope that it will be useful,
1768
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1769
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1770
 * Lesser General Public License for more details.
1771
 *
1772
 * You should have received a copy of the GNU Lesser General Public
1773
 * License along with this library; if not, write to the Free Software
1774
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
1775
 */
1776
     
1777
    class QRbitstream {
1778
    
1779
        public $data = array();
1780
        
1781
        //----------------------------------------------------------------------
1782
        public function size()
1783
        {
1784
            return count($this->data);
1785
        }
1786
        
1787
        //----------------------------------------------------------------------
1788
        public function allocate($setLength)
1789
        {
1790
            $this->data = array_fill(0, $setLength, 0);
1791
            return 0;
1792
        }
1793
    
1794
        //----------------------------------------------------------------------
1795
        public static function newFromNum($bits, $num)
1796
        {
1797
            $bstream = new QRbitstream();
1798
            $bstream->allocate($bits);
1799
            
1800
            $mask = 1 << ($bits - 1);
1801
            for($i=0; $i<$bits; $i++) {
1802
                if($num & $mask) {
1803
                    $bstream->data[$i] = 1;
1804
                } else {
1805
                    $bstream->data[$i] = 0;
1806
                }
1807
                $mask = $mask >> 1;
1808
            }
1809

1810
            return $bstream;
1811
        }
1812
        
1813
        //----------------------------------------------------------------------
1814
        public static function newFromBytes($size, $data)
1815
        {
1816
            $bstream = new QRbitstream();
1817
            $bstream->allocate($size * 8);
1818
            $p=0;
1819

1820
            for($i=0; $i<$size; $i++) {
1821
                $mask = 0x80;
1822
                for($j=0; $j<8; $j++) {
1823
                    if($data[$i] & $mask) {
1824
                        $bstream->data[$p] = 1;
1825
                    } else {
1826
                        $bstream->data[$p] = 0;
1827
                    }
1828
                    $p++;
1829
                    $mask = $mask >> 1;
1830
                }
1831
            }
1832

1833
            return $bstream;
1834
        }
1835
        
1836
        //----------------------------------------------------------------------
1837
        public function append(QRbitstream $arg)
1838
        {
1839
            if (is_null($arg)) {
1840
                return -1;
1841
            }
1842
            
1843
            if($arg->size() == 0) {
1844
                return 0;
1845
            }
1846
            
1847
            if($this->size() == 0) {
1848
                $this->data = $arg->data;
1849
                return 0;
1850
            }
1851
            
1852
            $this->data = array_values(array_merge($this->data, $arg->data));
1853

1854
            return 0;
1855
        }
1856
        
1857
        //----------------------------------------------------------------------
1858
        public function appendNum($bits, $num)
1859
        {
1860
            if ($bits == 0) 
1861
                return 0;
1862

1863
            $b = QRbitstream::newFromNum($bits, $num);
1864
            
1865
            if(is_null($b))
1866
                return -1;
1867

1868
            $ret = $this->append($b);
1869
            unset($b);
1870

1871
            return $ret;
1872
        }
1873

1874
        //----------------------------------------------------------------------
1875
        public function appendBytes($size, $data)
1876
        {
1877
            if ($size == 0) 
1878
                return 0;
1879

1880
            $b = QRbitstream::newFromBytes($size, $data);
1881
            
1882
            if(is_null($b))
1883
                return -1;
1884

1885
            $ret = $this->append($b);
1886
            unset($b);
1887

1888
            return $ret;
1889
        }
1890
        
1891
        //----------------------------------------------------------------------
1892
        public function toByte()
1893
        {
1894
        
1895
            $size = $this->size();
1896

1897
            if($size == 0) {
1898
                return array();
1899
            }
1900
            
1901
            $data = array_fill(0, (int)(($size + 7) / 8), 0);
1902
            $bytes = (int)($size / 8);
1903

1904
            $p = 0;
1905
            
1906
            for($i=0; $i<$bytes; $i++) {
1907
                $v = 0;
1908
                for($j=0; $j<8; $j++) {
1909
                    $v = $v << 1;
1910
                    $v |= $this->data[$p];
1911
                    $p++;
1912
                }
1913
                $data[$i] = $v;
1914
            }
1915
            
1916
            if($size & 7) {
1917
                $v = 0;
1918
                for($j=0; $j<($size & 7); $j++) {
1919
                    $v = $v << 1;
1920
                    $v |= $this->data[$p];
1921
                    $p++;
1922
                }
1923
                $data[$bytes] = $v;
1924
            }
1925

1926
            return $data;
1927
        }
1928

1929
    }
1930

1931

1932

1933

1934
//---- qrsplit.php -----------------------------
1935

1936

1937

1938

1939
/*
1940
 * PHP QR Code encoder
1941
 *
1942
 * Input splitting classes
1943
 *
1944
 * Based on libqrencode C library distributed under LGPL 2.1
1945
 * Copyright (C) 2006, 2007, 2008, 2009 Kentaro Fukuchi <[email protected]>
1946
 *
1947
 * PHP QR Code is distributed under LGPL 3
1948
 * Copyright (C) 2010 Dominik Dzienia <deltalab at poczta dot fm>
1949
 *
1950
 * The following data / specifications are taken from
1951
 * "Two dimensional symbol -- QR-code -- Basic Specification" (JIS X0510:2004)
1952
 *  or
1953
 * "Automatic identification and data capture techniques -- 
1954
 *  QR Code 2005 bar code symbology specification" (ISO/IEC 18004:2006)
1955
 *
1956
 * This library is free software; you can redistribute it and/or
1957
 * modify it under the terms of the GNU Lesser General Public
1958
 * License as published by the Free Software Foundation; either
1959
 * version 3 of the License, or any later version.
1960
 *
1961
 * This library is distributed in the hope that it will be useful,
1962
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1963
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1964
 * Lesser General Public License for more details.
1965
 *
1966
 * You should have received a copy of the GNU Lesser General Public
1967
 * License along with this library; if not, write to the Free Software
1968
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
1969
 */
1970
    class QRsplit {
1971

1972
        public $dataStr = '';
1973
        public $input;
1974
        public $modeHint;
1975

1976
        //----------------------------------------------------------------------
1977
        public function __construct($dataStr, $input, $modeHint) 
1978
        {
1979
            $this->dataStr  = $dataStr;
1980
            $this->input    = $input;
1981
            $this->modeHint = $modeHint;
1982
        }
1983
        
1984
        //----------------------------------------------------------------------
1985
        public static function isdigitat($str, $pos)
1986
        {    
1987
            if ($pos >= strlen($str))
1988
                return false;
1989
            
1990
            return ((ord($str[$pos]) >= ord('0'))&&(ord($str[$pos]) <= ord('9')));
1991
        }
1992
        
1993
        //----------------------------------------------------------------------
1994
        public static function isalnumat($str, $pos)
1995
        {
1996
            if ($pos >= strlen($str))
1997
                return false;
1998
                
1999
            return (QRinput::lookAnTable(ord($str[$pos])) >= 0);
2000
        }
2001

2002
        //----------------------------------------------------------------------
2003
        public function identifyMode($pos)
2004
        {
2005
            if ($pos >= strlen($this->dataStr)) 
2006
                return QR_MODE_NUL;
2007
                
2008
            $c = $this->dataStr[$pos];
2009
            
2010
            if(self::isdigitat($this->dataStr, $pos)) {
2011
                return QR_MODE_NUM;
2012
            } else if(self::isalnumat($this->dataStr, $pos)) {
2013
                return QR_MODE_AN;
2014
            } else if($this->modeHint == QR_MODE_KANJI) {
2015
            
2016
                if ($pos+1 < strlen($this->dataStr)) 
2017
                {
2018
                    $d = $this->dataStr[$pos+1];
2019
                    $word = (ord($c) << 8) | ord($d);
2020
                    if(($word >= 0x8140 && $word <= 0x9ffc) || ($word >= 0xe040 && $word <= 0xebbf)) {
2021
                        return QR_MODE_KANJI;
2022
                    }
2023
                }
2024
            }
2025

2026
            return QR_MODE_8;
2027
        } 
2028
        
2029
        //----------------------------------------------------------------------
2030
        public function eatNum()
2031
        {
2032
            $ln = QRspec::lengthIndicator(QR_MODE_NUM, $this->input->getVersion());
2033

2034
            $p = 0;
2035
            while(self::isdigitat($this->dataStr, $p)) {
2036
                $p++;
2037
            }
2038
            
2039
            $run = $p;
2040
            $mode = $this->identifyMode($p);
2041
            
2042
            if($mode == QR_MODE_8) {
2043
                $dif = QRinput::estimateBitsModeNum($run) + 4 + $ln
2044
                     + QRinput::estimateBitsMode8(1)         // + 4 + l8
2045
                     - QRinput::estimateBitsMode8($run + 1); // - 4 - l8
2046
                if($dif > 0) {
2047
                    return $this->eat8();
2048
                }
2049
            }
2050
            if($mode == QR_MODE_AN) {
2051
                $dif = QRinput::estimateBitsModeNum($run) + 4 + $ln
2052
                     + QRinput::estimateBitsModeAn(1)        // + 4 + la
2053
                     - QRinput::estimateBitsModeAn($run + 1);// - 4 - la
2054
                if($dif > 0) {
2055
                    return $this->eatAn();
2056
                }
2057
            }
2058
            
2059
            $ret = $this->input->append(QR_MODE_NUM, $run, str_split($this->dataStr));
2060
            if($ret < 0)
2061
                return -1;
2062

2063
            return $run;
2064
        }
2065
        
2066
        //----------------------------------------------------------------------
2067
        public function eatAn()
2068
        {
2069
            $la = QRspec::lengthIndicator(QR_MODE_AN,  $this->input->getVersion());
2070
            $ln = QRspec::lengthIndicator(QR_MODE_NUM, $this->input->getVersion());
2071

2072
            $p = 0;
2073
            
2074
            while(self::isalnumat($this->dataStr, $p)) {
2075
                if(self::isdigitat($this->dataStr, $p)) {
2076
                    $q = $p;
2077
                    while(self::isdigitat($this->dataStr, $q)) {
2078
                        $q++;
2079
                    }
2080
                    
2081
                    $dif = QRinput::estimateBitsModeAn($p) // + 4 + la
2082
                         + QRinput::estimateBitsModeNum($q - $p) + 4 + $ln
2083
                         - QRinput::estimateBitsModeAn($q); // - 4 - la
2084
                         
2085
                    if($dif < 0) {
2086
                        break;
2087
                    } else {
2088
                        $p = $q;
2089
                    }
2090
                } else {
2091
                    $p++;
2092
                }
2093
            }
2094

2095
            $run = $p;
2096

2097
            if(!self::isalnumat($this->dataStr, $p)) {
2098
                $dif = QRinput::estimateBitsModeAn($run) + 4 + $la
2099
                     + QRinput::estimateBitsMode8(1) // + 4 + l8
2100
                      - QRinput::estimateBitsMode8($run + 1); // - 4 - l8
2101
                if($dif > 0) {
2102
                    return $this->eat8();
2103
                }
2104
            }
2105

2106
            $ret = $this->input->append(QR_MODE_AN, $run, str_split($this->dataStr));
2107
            if($ret < 0)
2108
                return -1;
2109

2110
            return $run;
2111
        }
2112
        
2113
        //----------------------------------------------------------------------
2114
        public function eatKanji()
2115
        {
2116
            $p = 0;
2117
            
2118
            while($this->identifyMode($p) == QR_MODE_KANJI) {
2119
                $p += 2;
2120
            }
2121
            
2122
            $ret = $this->input->append(QR_MODE_KANJI, $p, str_split($this->dataStr));
2123
            if($ret < 0)
2124
                return -1;
2125

2126
            return $run;
2127
        }
2128

2129
        //----------------------------------------------------------------------
2130
        public function eat8()
2131
        {
2132
            $la = QRspec::lengthIndicator(QR_MODE_AN, $this->input->getVersion());
2133
            $ln = QRspec::lengthIndicator(QR_MODE_NUM, $this->input->getVersion());
2134

2135
            $p = 1;
2136
            $dataStrLen = strlen($this->dataStr);
2137
            
2138
            while($p < $dataStrLen) {
2139
                
2140
                $mode = $this->identifyMode($p);
2141
                if($mode == QR_MODE_KANJI) {
2142
                    break;
2143
                }
2144
                if($mode == QR_MODE_NUM) {
2145
                    $q = $p;
2146
                    while(self::isdigitat($this->dataStr, $q)) {
2147
                        $q++;
2148
                    }
2149
                    $dif = QRinput::estimateBitsMode8($p) // + 4 + l8
2150
                         + QRinput::estimateBitsModeNum($q - $p) + 4 + $ln
2151
                         - QRinput::estimateBitsMode8($q); // - 4 - l8
2152
                    if($dif < 0) {
2153
                        break;
2154
                    } else {
2155
                        $p = $q;
2156
                    }
2157
                } else if($mode == QR_MODE_AN) {
2158
                    $q = $p;
2159
                    while(self::isalnumat($this->dataStr, $q)) {
2160
                        $q++;
2161
                    }
2162
                    $dif = QRinput::estimateBitsMode8($p)  // + 4 + l8
2163
                         + QRinput::estimateBitsModeAn($q - $p) + 4 + $la
2164
                         - QRinput::estimateBitsMode8($q); // - 4 - l8
2165
                    if($dif < 0) {
2166
                        break;
2167
                    } else {
2168
                        $p = $q;
2169
                    }
2170
                } else {
2171
                    $p++;
2172
                }
2173
            }
2174

2175
            $run = $p;
2176
            $ret = $this->input->append(QR_MODE_8, $run, str_split($this->dataStr));
2177
            
2178
            if($ret < 0)
2179
                return -1;
2180

2181
            return $run;
2182
        }
2183

2184
        //----------------------------------------------------------------------
2185
        public function splitString()
2186
        {
2187
            while (strlen($this->dataStr) > 0)
2188
            {
2189
                if($this->dataStr == '')
2190
                    return 0;
2191

2192
                $mode = $this->identifyMode(0);
2193
                
2194
                switch ($mode) {
2195
                    case QR_MODE_NUM: $length = $this->eatNum(); break;
2196
                    case QR_MODE_AN:  $length = $this->eatAn(); break;
2197
                    case QR_MODE_KANJI:
2198
                        if ($hint == QR_MODE_KANJI)
2199
                                $length = $this->eatKanji();
2200
                        else    $length = $this->eat8();
2201
                        break;
2202
                    default: $length = $this->eat8(); break;
2203
                
2204
                }
2205

2206
                if($length == 0) return 0;
2207
                if($length < 0)  return -1;
2208
                
2209
                $this->dataStr = substr($this->dataStr, $length);
2210
            }
2211
        }
2212

2213
        //----------------------------------------------------------------------
2214
        public function toUpper()
2215
        {
2216
            $stringLen = strlen($this->dataStr);
2217
            $p = 0;
2218
            
2219
            while ($p<$stringLen) {
2220
                $mode = self::identifyMode(substr($this->dataStr, $p), $this->modeHint);
2221
                if($mode == QR_MODE_KANJI) {
2222
                    $p += 2;
2223
                } else {
2224
                    if (ord($this->dataStr[$p]) >= ord('a') && ord($this->dataStr[$p]) <= ord('z')) {
2225
                        $this->dataStr[$p] = chr(ord($this->dataStr[$p]) - 32);
2226
                    }
2227
                    $p++;
2228
                }
2229
            }
2230

2231
            return $this->dataStr;
2232
        }
2233

2234
        //----------------------------------------------------------------------
2235
        public static function splitStringToQRinput($string, QRinput $input, $modeHint, $casesensitive = true)
2236
        {
2237
            if(is_null($string) || $string == '\0' || $string == '') {
2238
                throw new Exception('empty string!!!');
2239
            }
2240

2241
            $split = new QRsplit($string, $input, $modeHint);
2242
            
2243
            if(!$casesensitive)
2244
                $split->toUpper();
2245
                
2246
            return $split->splitString();
2247
        }
2248
    }
2249

2250

2251

2252
//---- qrrscode.php -----------------------------
2253

2254

2255

2256

2257
/*
2258
 * PHP QR Code encoder
2259
 *
2260
 * Reed-Solomon error correction support
2261
 * 
2262
 * Copyright (C) 2002, 2003, 2004, 2006 Phil Karn, KA9Q
2263
 * (libfec is released under the GNU Lesser General Public License.)
2264
 *
2265
 * Based on libqrencode C library distributed under LGPL 2.1
2266
 * Copyright (C) 2006, 2007, 2008, 2009 Kentaro Fukuchi <[email protected]>
2267
 *
2268
 * PHP QR Code is distributed under LGPL 3
2269
 * Copyright (C) 2010 Dominik Dzienia <deltalab at poczta dot fm>
2270
 *
2271
 * This library is free software; you can redistribute it and/or
2272
 * modify it under the terms of the GNU Lesser General Public
2273
 * License as published by the Free Software Foundation; either
2274
 * version 3 of the License, or any later version.
2275
 *
2276
 * This library is distributed in the hope that it will be useful,
2277
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
2278
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
2279
 * Lesser General Public License for more details.
2280
 *
2281
 * You should have received a copy of the GNU Lesser General Public
2282
 * License along with this library; if not, write to the Free Software
2283
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
2284
 */
2285
 
2286
    class QRrsItem {
2287
    
2288
        public $mm;                  // Bits per symbol 
2289
        public $nn;                  // Symbols per block (= (1<<mm)-1) 
2290
        public $alpha_to = array();  // log lookup table 
2291
        public $index_of = array();  // Antilog lookup table 
2292
        public $genpoly = array();   // Generator polynomial 
2293
        public $nroots;              // Number of generator roots = number of parity symbols 
2294
        public $fcr;                 // First consecutive root, index form 
2295
        public $prim;                // Primitive element, index form 
2296
        public $iprim;               // prim-th root of 1, index form 
2297
        public $pad;                 // Padding bytes in shortened block 
2298
        public $gfpoly;
2299
    
2300
        //----------------------------------------------------------------------
2301
        public function modnn($x)
2302
        {
2303
            while ($x >= $this->nn) {
2304
                $x -= $this->nn;
2305
                $x = ($x >> $this->mm) + ($x & $this->nn);
2306
            }
2307
            
2308
            return $x;
2309
        }
2310
        
2311
        //----------------------------------------------------------------------
2312
        public static function init_rs_char($symsize, $gfpoly, $fcr, $prim, $nroots, $pad)
2313
        {
2314
            // Common code for intializing a Reed-Solomon control block (char or int symbols)
2315
            // Copyright 2004 Phil Karn, KA9Q
2316
            // May be used under the terms of the GNU Lesser General Public License (LGPL)
2317

2318
            $rs = null;
2319
            
2320
            // Check parameter ranges
2321
            if($symsize < 0 || $symsize > 8)                     return $rs;
2322
            if($fcr < 0 || $fcr >= (1<<$symsize))                return $rs;
2323
            if($prim <= 0 || $prim >= (1<<$symsize))             return $rs;
2324
            if($nroots < 0 || $nroots >= (1<<$symsize))          return $rs; // Can't have more roots than symbol values!
2325
            if($pad < 0 || $pad >= ((1<<$symsize) -1 - $nroots)) return $rs; // Too much padding
2326

2327
            $rs = new QRrsItem();
2328
            $rs->mm = $symsize;
2329
            $rs->nn = (1<<$symsize)-1;
2330
            $rs->pad = $pad;
2331

2332
            $rs->alpha_to = array_fill(0, $rs->nn+1, 0);
2333
            $rs->index_of = array_fill(0, $rs->nn+1, 0);
2334
          
2335
            // PHP style macro replacement ;)
2336
            $NN =& $rs->nn;
2337
            $A0 =& $NN;
2338
            
2339
            // Generate Galois field lookup tables
2340
            $rs->index_of[0] = $A0; // log(zero) = -inf
2341
            $rs->alpha_to[$A0] = 0; // alpha**-inf = 0
2342
            $sr = 1;
2343
          
2344
            for($i=0; $i<$rs->nn; $i++) {
2345
                $rs->index_of[$sr] = $i;
2346
                $rs->alpha_to[$i] = $sr;
2347
                $sr <<= 1;
2348
                if($sr & (1<<$symsize)) {
2349
                    $sr ^= $gfpoly;
2350
                }
2351
                $sr &= $rs->nn;
2352
            }
2353
            
2354
            if($sr != 1){
2355
                // field generator polynomial is not primitive!
2356
                $rs = NULL;
2357
                return $rs;
2358
            }
2359

2360
            /* Form RS code generator polynomial from its roots */
2361
            $rs->genpoly = array_fill(0, $nroots+1, 0);
2362
        
2363
            $rs->fcr = $fcr;
2364
            $rs->prim = $prim;
2365
            $rs->nroots = $nroots;
2366
            $rs->gfpoly = $gfpoly;
2367

2368
            /* Find prim-th root of 1, used in decoding */
2369
            for($iprim=1;($iprim % $prim) != 0;$iprim += $rs->nn)
2370
            ; // intentional empty-body loop!
2371
            
2372
            $rs->iprim = (int)($iprim / $prim);
2373
            $rs->genpoly[0] = 1;
2374
            
2375
            for ($i = 0,$root=$fcr*$prim; $i < $nroots; $i++, $root += $prim) {
2376
                $rs->genpoly[$i+1] = 1;
2377

2378
                // Multiply rs->genpoly[] by  @**(root + x)
2379
                for ($j = $i; $j > 0; $j--) {
2380
                    if ($rs->genpoly[$j] != 0) {
2381
                        $rs->genpoly[$j] = $rs->genpoly[$j-1] ^ $rs->alpha_to[$rs->modnn($rs->index_of[$rs->genpoly[$j]] + $root)];
2382
                    } else {
2383
                        $rs->genpoly[$j] = $rs->genpoly[$j-1];
2384
                    }
2385
                }
2386
                // rs->genpoly[0] can never be zero
2387
                $rs->genpoly[0] = $rs->alpha_to[$rs->modnn($rs->index_of[$rs->genpoly[0]] + $root)];
2388
            }
2389
            
2390
            // convert rs->genpoly[] to index form for quicker encoding
2391
            for ($i = 0; $i <= $nroots; $i++)
2392
                $rs->genpoly[$i] = $rs->index_of[$rs->genpoly[$i]];
2393

2394
            return $rs;
2395
        }
2396
        
2397
        //----------------------------------------------------------------------
2398
        public function encode_rs_char($data, &$parity)
2399
        {
2400
            $MM       =& $this->mm;
2401
            $NN       =& $this->nn;
2402
            $ALPHA_TO =& $this->alpha_to;
2403
            $INDEX_OF =& $this->index_of;
2404
            $GENPOLY  =& $this->genpoly;
2405
            $NROOTS   =& $this->nroots;
2406
            $FCR      =& $this->fcr;
2407
            $PRIM     =& $this->prim;
2408
            $IPRIM    =& $this->iprim;
2409
            $PAD      =& $this->pad;
2410
            $A0       =& $NN;
2411

2412
            $parity = array_fill(0, $NROOTS, 0);
2413

2414
            for($i=0; $i< ($NN-$NROOTS-$PAD); $i++) {
2415
                
2416
                $feedback = $INDEX_OF[$data[$i] ^ $parity[0]];
2417
                if($feedback != $A0) {      
2418
                    // feedback term is non-zero
2419
            
2420
                    // This line is unnecessary when GENPOLY[NROOTS] is unity, as it must
2421
                    // always be for the polynomials constructed by init_rs()
2422
                    $feedback = $this->modnn($NN - $GENPOLY[$NROOTS] + $feedback);
2423
            
2424
                    for($j=1;$j<$NROOTS;$j++) {
2425
                        $parity[$j] ^= $ALPHA_TO[$this->modnn($feedback + $GENPOLY[$NROOTS-$j])];
2426
                    }
2427
                }
2428
                
2429
                // Shift 
2430
                array_shift($parity);
2431
                if($feedback != $A0) {
2432
                    array_push($parity, $ALPHA_TO[$this->modnn($feedback + $GENPOLY[0])]);
2433
                } else {
2434
                    array_push($parity, 0);
2435
                }
2436
            }
2437
        }
2438
    }
2439
    
2440
    //##########################################################################
2441
    
2442
    class QRrs {
2443
    
2444
        public static $items = array();
2445
        
2446
        //----------------------------------------------------------------------
2447
        public static function init_rs($symsize, $gfpoly, $fcr, $prim, $nroots, $pad)
2448
        {
2449
            foreach(self::$items as $rs) {
2450
                if($rs->pad != $pad)       continue;
2451
                if($rs->nroots != $nroots) continue;
2452
                if($rs->mm != $symsize)    continue;
2453
                if($rs->gfpoly != $gfpoly) continue;
2454
                if($rs->fcr != $fcr)       continue;
2455
                if($rs->prim != $prim)     continue;
2456

2457
                return $rs;
2458
            }
2459

2460
            $rs = QRrsItem::init_rs_char($symsize, $gfpoly, $fcr, $prim, $nroots, $pad);
2461
            array_unshift(self::$items, $rs);
2462

2463
            return $rs;
2464
        }
2465
    }
2466

2467

2468

2469
//---- qrmask.php -----------------------------
2470

2471

2472

2473

2474
/*
2475
 * PHP QR Code encoder
2476
 *
2477
 * Masking
2478
 *
2479
 * Based on libqrencode C library distributed under LGPL 2.1
2480
 * Copyright (C) 2006, 2007, 2008, 2009 Kentaro Fukuchi <[email protected]>
2481
 *
2482
 * PHP QR Code is distributed under LGPL 3
2483
 * Copyright (C) 2010 Dominik Dzienia <deltalab at poczta dot fm>
2484
 *
2485
 * This library is free software; you can redistribute it and/or
2486
 * modify it under the terms of the GNU Lesser General Public
2487
 * License as published by the Free Software Foundation; either
2488
 * version 3 of the License, or any later version.
2489
 *
2490
 * This library is distributed in the hope that it will be useful,
2491
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
2492
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
2493
 * Lesser General Public License for more details.
2494
 *
2495
 * You should have received a copy of the GNU Lesser General Public
2496
 * License along with this library; if not, write to the Free Software
2497
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
2498
 */
2499
 
2500
	define('N1', 3);
2501
	define('N2', 3);
2502
	define('N3', 40);
2503
	define('N4', 10);
2504

2505
	class QRmask {
2506
	
2507
		public $runLength = array();
2508
		
2509
		//----------------------------------------------------------------------
2510
		public function __construct() 
2511
        {
2512
            $this->runLength = array_fill(0, QRSPEC_WIDTH_MAX + 1, 0);
2513
        }
2514
        
2515
        //----------------------------------------------------------------------
2516
        public function writeFormatInformation($width, &$frame, $mask, $level)
2517
        {
2518
            $blacks = 0;
2519
            $format =  QRspec::getFormatInfo($mask, $level);
2520

2521
            for($i=0; $i<8; $i++) {
2522
                if($format & 1) {
2523
                    $blacks += 2;
2524
                    $v = 0x85;
2525
                } else {
2526
                    $v = 0x84;
2527
                }
2528
                
2529
                $frame[8][$width - 1 - $i] = chr($v);
2530
                if($i < 6) {
2531
                    $frame[$i][8] = chr($v);
2532
                } else {
2533
                    $frame[$i + 1][8] = chr($v);
2534
                }
2535
                $format = $format >> 1;
2536
            }
2537
            
2538
            for($i=0; $i<7; $i++) {
2539
                if($format & 1) {
2540
                    $blacks += 2;
2541
                    $v = 0x85;
2542
                } else {
2543
                    $v = 0x84;
2544
                }
2545
                
2546
                $frame[$width - 7 + $i][8] = chr($v);
2547
                if($i == 0) {
2548
                    $frame[8][7] = chr($v);
2549
                } else {
2550
                    $frame[8][6 - $i] = chr($v);
2551
                }
2552
                
2553
                $format = $format >> 1;
2554
            }
2555

2556
            return $blacks;
2557
        }
2558
        
2559
        //----------------------------------------------------------------------
2560
        public function mask0($x, $y) { return ($x+$y)&1;                       }
2561
        public function mask1($x, $y) { return ($y&1);                          }
2562
        public function mask2($x, $y) { return ($x%3);                          }
2563
        public function mask3($x, $y) { return ($x+$y)%3;                       }
2564
        public function mask4($x, $y) { return (((int)($y/2))+((int)($x/3)))&1; }
2565
        public function mask5($x, $y) { return (($x*$y)&1)+($x*$y)%3;           }
2566
        public function mask6($x, $y) { return ((($x*$y)&1)+($x*$y)%3)&1;       }
2567
        public function mask7($x, $y) { return ((($x*$y)%3)+(($x+$y)&1))&1;     }
2568
        
2569
        //----------------------------------------------------------------------
2570
        private function generateMaskNo($maskNo, $width, $frame)
2571
        {
2572
            $bitMask = array_fill(0, $width, array_fill(0, $width, 0));
2573
            
2574
            for($y=0; $y<$width; $y++) {
2575
                for($x=0; $x<$width; $x++) {
2576
                    if(ord($frame[$y][$x]) & 0x80) {
2577
                        $bitMask[$y][$x] = 0;
2578
                    } else {
2579
                        $maskFunc = call_user_func(array($this, 'mask'.$maskNo), $x, $y);
2580
                        $bitMask[$y][$x] = ($maskFunc == 0)?1:0;
2581
                    }
2582
                    
2583
                }
2584
            }
2585
            
2586
            return $bitMask;
2587
        }
2588
        
2589
        //----------------------------------------------------------------------
2590
        public static function serial($bitFrame)
2591
        {
2592
            $codeArr = array();
2593
            
2594
            foreach ($bitFrame as $line)
2595
                $codeArr[] = join('', $line);
2596
                
2597
            return gzcompress(join("\n", $codeArr), 9);
2598
        }
2599
        
2600
        //----------------------------------------------------------------------
2601
        public static function unserial($code)
2602
        {
2603
            $codeArr = array();
2604
            
2605
            $codeLines = explode("\n", gzuncompress($code));
2606
            foreach ($codeLines as $line)
2607
                $codeArr[] = str_split($line);
2608
            
2609
            return $codeArr;
2610
        }
2611
        
2612
        //----------------------------------------------------------------------
2613
        public function makeMaskNo($maskNo, $width, $s, &$d, $maskGenOnly = false) 
2614
        {
2615
            $b = 0;
2616
            $bitMask = array();
2617
            
2618
            $fileName = QR_CACHE_DIR.'mask_'.$maskNo.DIRECTORY_SEPARATOR.'mask_'.$width.'_'.$maskNo.'.dat';
2619

2620
            if (QR_CACHEABLE) {
2621
                if (file_exists($fileName)) {
2622
                    $bitMask = self::unserial(file_get_contents($fileName));
2623
                } else {
2624
                    $bitMask = $this->generateMaskNo($maskNo, $width, $s, $d);
2625
                    if (!file_exists(QR_CACHE_DIR.'mask_'.$maskNo))
2626
                        mkdir(QR_CACHE_DIR.'mask_'.$maskNo);
2627
                    file_put_contents($fileName, self::serial($bitMask));
2628
                }
2629
            } else {
2630
                $bitMask = $this->generateMaskNo($maskNo, $width, $s, $d);
2631
            }
2632

2633
            if ($maskGenOnly)
2634
                return;
2635
                
2636
            $d = $s;
2637

2638
            for($y=0; $y<$width; $y++) {
2639
                for($x=0; $x<$width; $x++) {
2640
                    if($bitMask[$y][$x] == 1) {
2641
                        $d[$y][$x] = chr(ord($s[$y][$x]) ^ (int)$bitMask[$y][$x]);
2642
                    }
2643
                    $b += (int)(ord($d[$y][$x]) & 1);
2644
                }
2645
            }
2646

2647
            return $b;
2648
        }
2649
        
2650
        //----------------------------------------------------------------------
2651
        public function makeMask($width, $frame, $maskNo, $level)
2652
        {
2653
            $masked = array_fill(0, $width, str_repeat("\0", $width));
2654
            $this->makeMaskNo($maskNo, $width, $frame, $masked);
2655
            $this->writeFormatInformation($width, $masked, $maskNo, $level);
2656
       
2657
            return $masked;
2658
        }
2659
        
2660
        //----------------------------------------------------------------------
2661
        public function calcN1N3($length)
2662
        {
2663
            $demerit = 0;
2664

2665
            for($i=0; $i<$length; $i++) {
2666
                
2667
                if($this->runLength[$i] >= 5) {
2668
                    $demerit += (N1 + ($this->runLength[$i] - 5));
2669
                }
2670
                if($i & 1) {
2671
                    if(($i >= 3) && ($i < ($length-2)) && ($this->runLength[$i] % 3 == 0)) {
2672
                        $fact = (int)($this->runLength[$i] / 3);
2673
                        if(($this->runLength[$i-2] == $fact) &&
2674
                           ($this->runLength[$i-1] == $fact) &&
2675
                           ($this->runLength[$i+1] == $fact) &&
2676
                           ($this->runLength[$i+2] == $fact)) {
2677
                            if(($this->runLength[$i-3] < 0) || ($this->runLength[$i-3] >= (4 * $fact))) {
2678
                                $demerit += N3;
2679
                            } else if((($i+3) >= $length) || ($this->runLength[$i+3] >= (4 * $fact))) {
2680
                                $demerit += N3;
2681
                            }
2682
                        }
2683
                    }
2684
                }
2685
            }
2686
            return $demerit;
2687
        }
2688
        
2689
        //----------------------------------------------------------------------
2690
        public function evaluateSymbol($width, $frame)
2691
        {
2692
            $head = 0;
2693
            $demerit = 0;
2694

2695
            for($y=0; $y<$width; $y++) {
2696
                $head = 0;
2697
                $this->runLength[0] = 1;
2698
                
2699
                $frameY = $frame[$y];
2700
                
2701
                if ($y>0)
2702
                    $frameYM = $frame[$y-1];
2703
                
2704
                for($x=0; $x<$width; $x++) {
2705
                    if(($x > 0) && ($y > 0)) {
2706
                        $b22 = ord($frameY[$x]) & ord($frameY[$x-1]) & ord($frameYM[$x]) & ord($frameYM[$x-1]);
2707
                        $w22 = ord($frameY[$x]) | ord($frameY[$x-1]) | ord($frameYM[$x]) | ord($frameYM[$x-1]);
2708
                        
2709
                        if(($b22 | ($w22 ^ 1))&1) {                                                                     
2710
                            $demerit += N2;
2711
                        }
2712
                    }
2713
                    if(($x == 0) && (ord($frameY[$x]) & 1)) {
2714
                        $this->runLength[0] = -1;
2715
                        $head = 1;
2716
                        $this->runLength[$head] = 1;
2717
                    } else if($x > 0) {
2718
                        if((ord($frameY[$x]) ^ ord($frameY[$x-1])) & 1) {
2719
                            $head++;
2720
                            $this->runLength[$head] = 1;
2721
                        } else {
2722
                            $this->runLength[$head]++;
2723
                        }
2724
                    }
2725
                }
2726
    
2727
                $demerit += $this->calcN1N3($head+1);
2728
            }
2729

2730
            for($x=0; $x<$width; $x++) {
2731
                $head = 0;
2732
                $this->runLength[0] = 1;
2733
                
2734
                for($y=0; $y<$width; $y++) {
2735
                    if($y == 0 && (ord($frame[$y][$x]) & 1)) {
2736
                        $this->runLength[0] = -1;
2737
                        $head = 1;
2738
                        $this->runLength[$head] = 1;
2739
                    } else if($y > 0) {
2740
                        if((ord($frame[$y][$x]) ^ ord($frame[$y-1][$x])) & 1) {
2741
                            $head++;
2742
                            $this->runLength[$head] = 1;
2743
                        } else {
2744
                            $this->runLength[$head]++;
2745
                        }
2746
                    }
2747
                }
2748
            
2749
                $demerit += $this->calcN1N3($head+1);
2750
            }
2751

2752
            return $demerit;
2753
        }
2754
        
2755
        
2756
        //----------------------------------------------------------------------
2757
        public function mask($width, $frame, $level)
2758
        {
2759
            $minDemerit = PHP_INT_MAX;
2760
            $bestMaskNum = 0;
2761
            $bestMask = array();
2762
            
2763
            $checked_masks = array(0,1,2,3,4,5,6,7);
2764
            
2765
            if (QR_FIND_FROM_RANDOM !== false) {
2766
            
2767
                $howManuOut = 8-(QR_FIND_FROM_RANDOM % 9);
2768
                for ($i = 0; $i <  $howManuOut; $i++) {
2769
                    $remPos = rand (0, count($checked_masks)-1);
2770
                    unset($checked_masks[$remPos]);
2771
                    $checked_masks = array_values($checked_masks);
2772
                }
2773
            
2774
            }
2775
            
2776
            $bestMask = $frame;
2777
             
2778
            foreach($checked_masks as $i) {
2779
                $mask = array_fill(0, $width, str_repeat("\0", $width));
2780

2781
                $demerit = 0;
2782
                $blacks = 0;
2783
                $blacks  = $this->makeMaskNo($i, $width, $frame, $mask);
2784
                $blacks += $this->writeFormatInformation($width, $mask, $i, $level);
2785
                $blacks  = (int)(100 * $blacks / ($width * $width));
2786
                $demerit = (int)((int)(abs($blacks - 50) / 5) * N4);
2787
                $demerit += $this->evaluateSymbol($width, $mask);
2788
                
2789
                if($demerit < $minDemerit) {
2790
                    $minDemerit = $demerit;
2791
                    $bestMask = $mask;
2792
                    $bestMaskNum = $i;
2793
                }
2794
            }
2795
            
2796
            return $bestMask;
2797
        }
2798
        
2799
        //----------------------------------------------------------------------
2800
    }
2801

2802

2803

2804

2805
//---- qrencode.php -----------------------------
2806

2807

2808

2809

2810
/*
2811
 * PHP QR Code encoder
2812
 *
2813
 * Main encoder classes.
2814
 *
2815
 * Based on libqrencode C library distributed under LGPL 2.1
2816
 * Copyright (C) 2006, 2007, 2008, 2009 Kentaro Fukuchi <[email protected]>
2817
 *
2818
 * PHP QR Code is distributed under LGPL 3
2819
 * Copyright (C) 2010 Dominik Dzienia <deltalab at poczta dot fm>
2820
 *
2821
 * This library is free software; you can redistribute it and/or
2822
 * modify it under the terms of the GNU Lesser General Public
2823
 * License as published by the Free Software Foundation; either
2824
 * version 3 of the License, or any later version.
2825
 *
2826
 * This library is distributed in the hope that it will be useful,
2827
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
2828
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
2829
 * Lesser General Public License for more details.
2830
 *
2831
 * You should have received a copy of the GNU Lesser General Public
2832
 * License along with this library; if not, write to the Free Software
2833
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
2834
 */
2835
 
2836
    class QRrsblock {
2837
        public $dataLength;
2838
        public $data = array();
2839
        public $eccLength;
2840
        public $ecc = array();
2841
        
2842
        public function __construct($dl, $data, $el, &$ecc, QRrsItem $rs)
2843
        {
2844
            $rs->encode_rs_char($data, $ecc);
2845
        
2846
            $this->dataLength = $dl;
2847
            $this->data = $data;
2848
            $this->eccLength = $el;
2849
            $this->ecc = $ecc;
2850
        }
2851
    };
2852
    
2853
    //##########################################################################
2854

2855
    class QRrawcode {
2856
        public $version;
2857
        public $datacode = array();
2858
        public $ecccode = array();
2859
        public $blocks;
2860
        public $rsblocks = array(); //of RSblock
2861
        public $count;
2862
        public $dataLength;
2863
        public $eccLength;
2864
        public $b1;
2865
        
2866
        //----------------------------------------------------------------------
2867
        public function __construct(QRinput $input)
2868
        {
2869
            $spec = array(0,0,0,0,0);
2870
            
2871
            $this->datacode = $input->getByteStream();
2872
            if(is_null($this->datacode)) {
2873
                throw new Exception('null imput string');
2874
            }
2875

2876
            QRspec::getEccSpec($input->getVersion(), $input->getErrorCorrectionLevel(), $spec);
2877

2878
            $this->version = $input->getVersion();
2879
            $this->b1 = QRspec::rsBlockNum1($spec);
2880
            $this->dataLength = QRspec::rsDataLength($spec);
2881
            $this->eccLength = QRspec::rsEccLength($spec);
2882
            $this->ecccode = array_fill(0, $this->eccLength, 0);
2883
            $this->blocks = QRspec::rsBlockNum($spec);
2884
            
2885
            $ret = $this->init($spec);
2886
            if($ret < 0) {
2887
                throw new Exception('block alloc error');
2888
                return null;
2889
            }
2890

2891
            $this->count = 0;
2892
        }
2893
        
2894
        //----------------------------------------------------------------------
2895
        public function init(array $spec)
2896
        {
2897
            $dl = QRspec::rsDataCodes1($spec);
2898
            $el = QRspec::rsEccCodes1($spec);
2899
            $rs = QRrs::init_rs(8, 0x11d, 0, 1, $el, 255 - $dl - $el);
2900
            
2901

2902
            $blockNo = 0;
2903
            $dataPos = 0;
2904
            $eccPos = 0;
2905
            for($i=0; $i<QRspec::rsBlockNum1($spec); $i++) {
2906
                $ecc = array_slice($this->ecccode,$eccPos);
2907
                $this->rsblocks[$blockNo] = new QRrsblock($dl, array_slice($this->datacode, $dataPos), $el,  $ecc, $rs);
2908
                $this->ecccode = array_merge(array_slice($this->ecccode,0, $eccPos), $ecc);
2909
                
2910
                $dataPos += $dl;
2911
                $eccPos += $el;
2912
                $blockNo++;
2913
            }
2914

2915
            if(QRspec::rsBlockNum2($spec) == 0)
2916
                return 0;
2917

2918
            $dl = QRspec::rsDataCodes2($spec);
2919
            $el = QRspec::rsEccCodes2($spec);
2920
            $rs = QRrs::init_rs(8, 0x11d, 0, 1, $el, 255 - $dl - $el);
2921
            
2922
            if($rs == NULL) return -1;
2923
            
2924
            for($i=0; $i<QRspec::rsBlockNum2($spec); $i++) {
2925
                $ecc = array_slice($this->ecccode,$eccPos);
2926
                $this->rsblocks[$blockNo] = new QRrsblock($dl, array_slice($this->datacode, $dataPos), $el, $ecc, $rs);
2927
                $this->ecccode = array_merge(array_slice($this->ecccode,0, $eccPos), $ecc);
2928
                
2929
                $dataPos += $dl;
2930
                $eccPos += $el;
2931
                $blockNo++;
2932
            }
2933

2934
            return 0;
2935
        }
2936
        
2937
        //----------------------------------------------------------------------
2938
        public function getCode()
2939
        {
2940
            $ret = null;
2941

2942
            if($this->count < $this->dataLength) {
2943
                $row = $this->count % $this->blocks;
2944
                $col = $this->count / $this->blocks;
2945
                if($col >= $this->rsblocks[0]->dataLength) {
2946
                    $row += $this->b1;
2947
                }
2948
                $ret = $this->rsblocks[$row]->data[$col];
2949
            } else if($this->count < $this->dataLength + $this->eccLength) {
2950
                $row = ($this->count - $this->dataLength) % $this->blocks;
2951
                $col = ($this->count - $this->dataLength) / $this->blocks;
2952
                $ret = $this->rsblocks[$row]->ecc[$col];
2953
            } else {
2954
                return 0;
2955
            }
2956
            $this->count++;
2957
            
2958
            return $ret;
2959
        }
2960
    }
2961

2962
    //##########################################################################
2963
    
2964
    class QRcode {
2965
    
2966
        public $version;
2967
        public $width;
2968
        public $data; 
2969
        
2970
        //----------------------------------------------------------------------
2971
        public function encodeMask(QRinput $input, $mask)
2972
        {
2973
            if($input->getVersion() < 0 || $input->getVersion() > QRSPEC_VERSION_MAX) {
2974
                throw new Exception('wrong version');
2975
            }
2976
            if($input->getErrorCorrectionLevel() > QR_ECLEVEL_H) {
2977
                throw new Exception('wrong level');
2978
            }
2979

2980
            $raw = new QRrawcode($input);
2981
            
2982
            QRtools::markTime('after_raw');
2983
            
2984
            $version = $raw->version;
2985
            $width = QRspec::getWidth($version);
2986
            $frame = QRspec::newFrame($version);
2987
            
2988
            $filler = new FrameFiller($width, $frame);
2989
            if(is_null($filler)) {
2990
                return NULL;
2991
            }
2992

2993
            // inteleaved data and ecc codes
2994
            for($i=0; $i<$raw->dataLength + $raw->eccLength; $i++) {
2995
                $code = $raw->getCode();
2996
                $bit = 0x80;
2997
                for($j=0; $j<8; $j++) {
2998
                    $addr = $filler->next();
2999
                    $filler->setFrameAt($addr, 0x02 | (($bit & $code) != 0));
3000
                    $bit = $bit >> 1;
3001
                }
3002
            }
3003
            
3004
            QRtools::markTime('after_filler');
3005
            
3006
            unset($raw);
3007
            
3008
            // remainder bits
3009
            $j = QRspec::getRemainder($version);
3010
            for($i=0; $i<$j; $i++) {
3011
                $addr = $filler->next();
3012
                $filler->setFrameAt($addr, 0x02);
3013
            }
3014
            
3015
            $frame = $filler->frame;
3016
            unset($filler);
3017
            
3018
            
3019
            // masking
3020
            $maskObj = new QRmask();
3021
            if($mask < 0) {
3022
            
3023
                if (QR_FIND_BEST_MASK) {
3024
                    $masked = $maskObj->mask($width, $frame, $input->getErrorCorrectionLevel());
3025
                } else {
3026
                    $masked = $maskObj->makeMask($width, $frame, (intval(QR_DEFAULT_MASK) % 8), $input->getErrorCorrectionLevel());
3027
                }
3028
            } else {
3029
                $masked = $maskObj->makeMask($width, $frame, $mask, $input->getErrorCorrectionLevel());
3030
            }
3031
            
3032
            if($masked == NULL) {
3033
                return NULL;
3034
            }
3035
            
3036
            QRtools::markTime('after_mask');
3037
            
3038
            $this->version = $version;
3039
            $this->width = $width;
3040
            $this->data = $masked;
3041
            
3042
            return $this;
3043
        }
3044
    
3045
        //----------------------------------------------------------------------
3046
        public function encodeInput(QRinput $input)
3047
        {
3048
            return $this->encodeMask($input, -1);
3049
        }
3050
        
3051
        //----------------------------------------------------------------------
3052
        public function encodeString8bit($string, $version, $level)
3053
        {
3054
            if(string == NULL) {
3055
                throw new Exception('empty string!');
3056
                return NULL;
3057
            }
3058

3059
            $input = new QRinput($version, $level);
3060
            if($input == NULL) return NULL;
3061

3062
            $ret = $input->append($input, QR_MODE_8, strlen($string), str_split($string));
3063
            if($ret < 0) {
3064
                unset($input);
3065
                return NULL;
3066
            }
3067
            return $this->encodeInput($input);
3068
        }
3069

3070
        //----------------------------------------------------------------------
3071
        public function encodeString($string, $version, $level, $hint, $casesensitive)
3072
        {
3073

3074
            if($hint != QR_MODE_8 && $hint != QR_MODE_KANJI) {
3075
                throw new Exception('bad hint');
3076
                return NULL;
3077
            }
3078

3079
            $input = new QRinput($version, $level);
3080
            if($input == NULL) return NULL;
3081

3082
            $ret = QRsplit::splitStringToQRinput($string, $input, $hint, $casesensitive);
3083
            if($ret < 0) {
3084
                return NULL;
3085
            }
3086

3087
            return $this->encodeInput($input);
3088
        }
3089
        
3090
        //----------------------------------------------------------------------
3091
        public static function png($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4, $saveandprint=false) 
3092
        {
3093
            $enc = QRencode::factory($level, $size, $margin);
3094
            return $enc->encodePNG($text, $outfile, $saveandprint=false);
3095
        }
3096

3097
        //----------------------------------------------------------------------
3098
        public static function text($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4) 
3099
        {
3100
            $enc = QRencode::factory($level, $size, $margin);
3101
            return $enc->encode($text, $outfile);
3102
        }
3103

3104
        //----------------------------------------------------------------------
3105
        public static function raw($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4) 
3106
        {
3107
            $enc = QRencode::factory($level, $size, $margin);
3108
            return $enc->encodeRAW($text, $outfile);
3109
        }
3110
    }
3111
    
3112
    //##########################################################################
3113
    
3114
    class FrameFiller {
3115
    
3116
        public $width;
3117
        public $frame;
3118
        public $x;
3119
        public $y;
3120
        public $dir;
3121
        public $bit;
3122
        
3123
        //----------------------------------------------------------------------
3124
        public function __construct($width, &$frame)
3125
        {
3126
            $this->width = $width;
3127
            $this->frame = $frame;
3128
            $this->x = $width - 1;
3129
            $this->y = $width - 1;
3130
            $this->dir = -1;
3131
            $this->bit = -1;
3132
        }
3133
        
3134
        //----------------------------------------------------------------------
3135
        public function setFrameAt($at, $val)
3136
        {
3137
            $this->frame[$at['y']][$at['x']] = chr($val);
3138
        }
3139
        
3140
        //----------------------------------------------------------------------
3141
        public function getFrameAt($at)
3142
        {
3143
            return ord($this->frame[$at['y']][$at['x']]);
3144
        }
3145
        
3146
        //----------------------------------------------------------------------
3147
        public function next()
3148
        {
3149
            do {
3150
            
3151
                if($this->bit == -1) {
3152
                    $this->bit = 0;
3153
                    return array('x'=>$this->x, 'y'=>$this->y);
3154
                }
3155

3156
                $x = $this->x;
3157
                $y = $this->y;
3158
                $w = $this->width;
3159

3160
                if($this->bit == 0) {
3161
                    $x--;
3162
                    $this->bit++;
3163
                } else {
3164
                    $x++;
3165
                    $y += $this->dir;
3166
                    $this->bit--;
3167
                }
3168

3169
                if($this->dir < 0) {
3170
                    if($y < 0) {
3171
                        $y = 0;
3172
                        $x -= 2;
3173
                        $this->dir = 1;
3174
                        if($x == 6) {
3175
                            $x--;
3176
                            $y = 9;
3177
                        }
3178
                    }
3179
                } else {
3180
                    if($y == $w) {
3181
                        $y = $w - 1;
3182
                        $x -= 2;
3183
                        $this->dir = -1;
3184
                        if($x == 6) {
3185
                            $x--;
3186
                            $y -= 8;
3187
                        }
3188
                    }
3189
                }
3190
                if($x < 0 || $y < 0) return null;
3191

3192
                $this->x = $x;
3193
                $this->y = $y;
3194

3195
            } while(ord($this->frame[$y][$x]) & 0x80);
3196
                        
3197
            return array('x'=>$x, 'y'=>$y);
3198
        }
3199
        
3200
    } ;
3201
    
3202
    //##########################################################################    
3203
    
3204
    class QRencode {
3205
    
3206
        public $casesensitive = true;
3207
        public $eightbit = false;
3208
        
3209
        public $version = 0;
3210
        public $size = 3;
3211
        public $margin = 4;
3212
        
3213
        public $structured = 0; // not supported yet
3214
        
3215
        public $level = QR_ECLEVEL_L;
3216
        public $hint = QR_MODE_8;
3217
        
3218
        //----------------------------------------------------------------------
3219
        public static function factory($level = QR_ECLEVEL_L, $size = 3, $margin = 4)
3220
        {
3221
            $enc = new QRencode();
3222
            $enc->size = $size;
3223
            $enc->margin = $margin;
3224
            
3225
            switch ($level.'') {
3226
                case '0':
3227
                case '1':
3228
                case '2':
3229
                case '3':
3230
                        $enc->level = $level;
3231
                    break;
3232
                case 'l':
3233
                case 'L':
3234
                        $enc->level = QR_ECLEVEL_L;
3235
                    break;
3236
                case 'm':
3237
                case 'M':
3238
                        $enc->level = QR_ECLEVEL_M;
3239
                    break;
3240
                case 'q':
3241
                case 'Q':
3242
                        $enc->level = QR_ECLEVEL_Q;
3243
                    break;
3244
                case 'h':
3245
                case 'H':
3246
                        $enc->level = QR_ECLEVEL_H;
3247
                    break;
3248
            }
3249
            
3250
            return $enc;
3251
        }
3252
        
3253
        //----------------------------------------------------------------------
3254
        public function encodeRAW($intext, $outfile = false) 
3255
        {
3256
            $code = new QRcode();
3257

3258
            if($this->eightbit) {
3259
                $code->encodeString8bit($intext, $this->version, $this->level);
3260
            } else {
3261
                $code->encodeString($intext, $this->version, $this->level, $this->hint, $this->casesensitive);
3262
            }
3263
            
3264
            return $code->data;
3265
        }
3266

3267
        //----------------------------------------------------------------------
3268
        public function encode($intext, $outfile = false) 
3269
        {
3270
            $code = new QRcode();
3271

3272
            if($this->eightbit) {
3273
                $code->encodeString8bit($intext, $this->version, $this->level);
3274
            } else {
3275
                $code->encodeString($intext, $this->version, $this->level, $this->hint, $this->casesensitive);
3276
            }
3277
            
3278
            QRtools::markTime('after_encode');
3279
            
3280
            if ($outfile!== false) {
3281
                file_put_contents($outfile, join("\n", QRtools::binarize($code->data)));
3282
            } else {
3283
                return QRtools::binarize($code->data);
3284
            }
3285
        }
3286
        
3287
        //----------------------------------------------------------------------
3288
        public function encodePNG($intext, $outfile = false,$saveandprint=false) 
3289
        {
3290
            try {
3291
            
3292
                ob_start();
3293
                $tab = $this->encode($intext);
3294
                $err = ob_get_contents();
3295
                ob_end_clean();
3296
                
3297
                if ($err != '')
3298
                    QRtools::log($outfile, $err);
3299
                
3300
                $maxSize = (int)(QR_PNG_MAXIMUM_SIZE / (count($tab)+2*$this->margin));
3301
                
3302
                QRimage::png($tab, $outfile, min(max(1, $this->size), $maxSize), $this->margin,$saveandprint);
3303
            
3304
            } catch (Exception $e) {
3305
            
3306
                QRtools::log($outfile, $e->getMessage());
3307
            
3308
            }
3309
        }
3310
    }
3311

3312

3313

3314
Product

Resources

Company
