53 { 0, 0, 0, { 0, 0, 0, 0}},
54 { 21, 26, 0, { 7, 10, 13, 17}},
55 { 25, 44, 7, { 10, 16, 22, 28}},
56 { 29, 70, 7, { 15, 26, 36, 44}},
57 { 33, 100, 7, { 20, 36, 52, 64}},
58 { 37, 134, 7, { 26, 48, 72, 88}},
59 { 41, 172, 7, { 36, 64, 96, 112}},
60 { 45, 196, 0, { 40, 72, 108, 130}},
61 { 49, 242, 0, { 48, 88, 132, 156}},
62 { 53, 292, 0, { 60, 110, 160, 192}},
63 { 57, 346, 0, { 72, 130, 192, 224}},
64 { 61, 404, 0, { 80, 150, 224, 264}},
65 { 65, 466, 0, { 96, 176, 260, 308}},
66 { 69, 532, 0, { 104, 198, 288, 352}},
67 { 73, 581, 3, { 120, 216, 320, 384}},
68 { 77, 655, 3, { 132, 240, 360, 432}},
69 { 81, 733, 3, { 144, 280, 408, 480}},
70 { 85, 815, 3, { 168, 308, 448, 532}},
71 { 89, 901, 3, { 180, 338, 504, 588}},
72 { 93, 991, 3, { 196, 364, 546, 650}},
73 { 97, 1085, 3, { 224, 416, 600, 700}},
74 {101, 1156, 4, { 224, 442, 644, 750}},
75 {105, 1258, 4, { 252, 476, 690, 816}},
76 {109, 1364, 4, { 270, 504, 750, 900}},
77 {113, 1474, 4, { 300, 560, 810, 960}},
78 {117, 1588, 4, { 312, 588, 870, 1050}},
79 {121, 1706, 4, { 336, 644, 952, 1110}},
80 {125, 1828, 4, { 360, 700, 1020, 1200}},
81 {129, 1921, 3, { 390, 728, 1050, 1260}},
82 {133, 2051, 3, { 420, 784, 1140, 1350}},
83 {137, 2185, 3, { 450, 812, 1200, 1440}},
84 {141, 2323, 3, { 480, 868, 1290, 1530}},
85 {145, 2465, 3, { 510, 924, 1350, 1620}},
86 {149, 2611, 3, { 540, 980, 1440, 1710}},
87 {153, 2761, 3, { 570, 1036, 1530, 1800}},
88 {157, 2876, 0, { 570, 1064, 1590, 1890}},
89 {161, 3034, 0, { 600, 1120, 1680, 1980}},
90 {165, 3196, 0, { 630, 1204, 1770, 2100}},
91 {169, 3362, 0, { 660, 1260, 1860, 2220}},
92 {173, 3532, 0, { 720, 1316, 1950, 2310}},
93 {177, 3706, 0, { 750, 1372, 2040, 2430}}
98 return qrspecCapacity[version].
words - qrspecCapacity[version].
ec[level];
103 return qrspecCapacity[version].
ec[level];
112 words = qrspecCapacity[i].
words - qrspecCapacity[i].
ec[level];
113 if(words >= size)
return i;
121 return qrspecCapacity[version].
width;
126 return qrspecCapacity[version].
remainder;
147 }
else if(version <= 26) {
165 }
else if(version <= 26) {
172 words = (1 << bits) - 1;
189 {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}},
190 {{ 1, 0}, { 1, 0}, { 1, 0}, { 1, 0}},
191 {{ 1, 0}, { 1, 0}, { 1, 0}, { 1, 0}},
192 {{ 1, 0}, { 1, 0}, { 2, 0}, { 2, 0}},
193 {{ 1, 0}, { 2, 0}, { 2, 0}, { 4, 0}},
194 {{ 1, 0}, { 2, 0}, { 2, 2}, { 2, 2}},
195 {{ 2, 0}, { 4, 0}, { 4, 0}, { 4, 0}},
196 {{ 2, 0}, { 4, 0}, { 2, 4}, { 4, 1}},
197 {{ 2, 0}, { 2, 2}, { 4, 2}, { 4, 2}},
198 {{ 2, 0}, { 3, 2}, { 4, 4}, { 4, 4}},
199 {{ 2, 2}, { 4, 1}, { 6, 2}, { 6, 2}},
200 {{ 4, 0}, { 1, 4}, { 4, 4}, { 3, 8}},
201 {{ 2, 2}, { 6, 2}, { 4, 6}, { 7, 4}},
202 {{ 4, 0}, { 8, 1}, { 8, 4}, {12, 4}},
203 {{ 3, 1}, { 4, 5}, {11, 5}, {11, 5}},
204 {{ 5, 1}, { 5, 5}, { 5, 7}, {11, 7}},
205 {{ 5, 1}, { 7, 3}, {15, 2}, { 3, 13}},
206 {{ 1, 5}, {10, 1}, { 1, 15}, { 2, 17}},
207 {{ 5, 1}, { 9, 4}, {17, 1}, { 2, 19}},
208 {{ 3, 4}, { 3, 11}, {17, 4}, { 9, 16}},
209 {{ 3, 5}, { 3, 13}, {15, 5}, {15, 10}},
210 {{ 4, 4}, {17, 0}, {17, 6}, {19, 6}},
211 {{ 2, 7}, {17, 0}, { 7, 16}, {34, 0}},
212 {{ 4, 5}, { 4, 14}, {11, 14}, {16, 14}},
213 {{ 6, 4}, { 6, 14}, {11, 16}, {30, 2}},
214 {{ 8, 4}, { 8, 13}, { 7, 22}, {22, 13}},
215 {{10, 2}, {19, 4}, {28, 6}, {33, 4}},
216 {{ 8, 4}, {22, 3}, { 8, 26}, {12, 28}},
217 {{ 3, 10}, { 3, 23}, { 4, 31}, {11, 31}},
218 {{ 7, 7}, {21, 7}, { 1, 37}, {19, 26}},
219 {{ 5, 10}, {19, 10}, {15, 25}, {23, 25}},
220 {{13, 3}, { 2, 29}, {42, 1}, {23, 28}},
221 {{17, 0}, {10, 23}, {10, 35}, {19, 35}},
222 {{17, 1}, {14, 21}, {29, 19}, {11, 46}},
223 {{13, 6}, {14, 23}, {44, 7}, {59, 1}},
224 {{12, 7}, {12, 26}, {39, 14}, {22, 41}},
225 {{ 6, 14}, { 6, 34}, {46, 10}, { 2, 64}},
226 {{17, 4}, {29, 14}, {49, 10}, {24, 46}},
227 {{ 4, 18}, {13, 32}, {48, 14}, {42, 32}},
228 {{20, 4}, {40, 7}, {43, 22}, {10, 67}},
229 {{19, 6}, {18, 31}, {34, 34}, {20, 61}},
246 spec[3] = spec[4] = 0;
249 spec[1] = data / (b1 + b2);
250 spec[2] = ecc / (b1 + b2);
252 spec[4] = spec[1] + 1;
269 { 0, 0}, {18, 0}, {22, 0}, {26, 0}, {30, 0},
270 {34, 0}, {22, 38}, {24, 42}, {26, 46}, {28, 50},
271 {30, 54}, {32, 58}, {34, 62}, {26, 46}, {26, 48},
272 {26, 50}, {30, 54}, {30, 56}, {30, 58}, {34, 62},
273 {28, 50}, {26, 50}, {30, 54}, {28, 54}, {32, 58},
274 {30, 58}, {34, 62}, {26, 50}, {30, 54}, {26, 52},
275 {30, 56}, {34, 60}, {30, 58}, {34, 62}, {30, 54},
276 {24, 50}, {28, 54}, {32, 58}, {26, 54}, {30, 58},
287 static const unsigned char finder[] = {
288 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
289 0xa1, 0xa0, 0xa0, 0xa0, 0xa1,
290 0xa1, 0xa0, 0xa1, 0xa0, 0xa1,
291 0xa1, 0xa0, 0xa0, 0xa0, 0xa1,
292 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
295 const unsigned char *s;
297 frame += (oy - 2) * width + ox - 2;
299 for(y = 0; y < 5; y++) {
300 for(x = 0; x < 5; x++) {
310 int d, w, x, y, cx, cy;
312 if(version < 2)
return;
318 w = (width - alignmentPattern[version][0]) / d + 2;
322 x = alignmentPattern[version][0];
323 y = alignmentPattern[version][0];
328 cx = alignmentPattern[version][0];
329 for(x = 1; x < w - 1; x++) {
335 cy = alignmentPattern[version][0];
336 for(y = 0; y < w-1; y++) {
337 cx = alignmentPattern[version][0];
338 for(x = 0; x < w-1; x++) {
355 0x07c94, 0x085bc, 0x09a99, 0x0a4d3, 0x0bbf6, 0x0c762, 0x0d847, 0x0e60d,
356 0x0f928, 0x10b78, 0x1145d, 0x12a17, 0x13532, 0x149a6, 0x15683, 0x168c9,
357 0x177ec, 0x18ec4, 0x191e1, 0x1afab, 0x1b08e, 0x1cc1a, 0x1d33f, 0x1ed75,
358 0x1f250, 0x209d5, 0x216f0, 0x228ba, 0x2379f, 0x24b0b, 0x2542e, 0x26a64,
375 {0x77c4, 0x72f3, 0x7daa, 0x789d, 0x662f, 0x6318, 0x6c41, 0x6976},
376 {0x5412, 0x5125, 0x5e7c, 0x5b4b, 0x45f9, 0x40ce, 0x4f97, 0x4aa0},
377 {0x355f, 0x3068, 0x3f31, 0x3a06, 0x24b4, 0x2183, 0x2eda, 0x2bed},
378 {0x1689, 0x13be, 0x1ce7, 0x19d0, 0x0762, 0x0255, 0x0d0c, 0x083b}
383 if(mask < 0 || mask > 7)
return 0;
400 static const unsigned char finder[] = {
401 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1,
402 0xc1, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc1,
403 0xc1, 0xc0, 0xc1, 0xc1, 0xc1, 0xc0, 0xc1,
404 0xc1, 0xc0, 0xc1, 0xc1, 0xc1, 0xc0, 0xc1,
405 0xc1, 0xc0, 0xc1, 0xc1, 0xc1, 0xc0, 0xc1,
406 0xc1, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc1,
407 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1,
410 const unsigned char *s;
412 frame += oy * width + ox;
414 for(y = 0; y < 7; y++) {
415 for(x = 0; x < 7; x++) {
426 unsigned char *frame, *p, *q;
429 unsigned int verinfo, v;
431 width = qrspecCapacity[version].
width;
432 frame = (
unsigned char *)
malloc((
size_t)(width * width));
433 if(frame == NULL)
return NULL;
435 memset(frame, 0, (
size_t)(width * width));
442 q = frame + width * (width - 7);
443 for(y = 0; y < 7; y++) {
450 memset(frame + width * 7, 0xc0, 8);
451 memset(frame + width * 8 - 8, 0xc0, 8);
452 memset(frame + width * (width - 8), 0xc0, 8);
454 memset(frame + width * 8, 0x84, 9);
455 memset(frame + width * 9 - 8, 0x84, 8);
457 for(y = 0; y < 8; y++) {
461 p = frame + width * (width - 7) + 8;
462 for(y = 0; y < 7; y++) {
467 p = frame + width * 6 + 8;
468 q = frame + width * 8 + 6;
469 for(x = 1; x < width-15; x++) {
482 p = frame + width * (width - 11);
484 for(x = 0; x < 6; x++) {
485 for(y = 0; y < 3; y++) {
486 p[width * y + x] = 0x88 | (v & 1);
491 p = frame + width - 11;
493 for(y = 0; y < 6; y++) {
494 for(x = 0; x < 3; x++) {
495 p[x] = 0x88 | (v & 1);
502 frame[width * (width - 8) + 8] = 0x81;
static const int alignmentPattern[QRSPEC_VERSION_MAX+1][2]
Positions of alignment patterns.
int QRspec_getDataLength(int version, QRecLevel level)
Return maximum data code length (bytes) for the version.
#define QRSPEC_VERSION_MAX
Maximum version (size) of QR-code symbol.
static const int lengthTableBits[4][3]
static const unsigned int versionPattern[QRSPEC_VERSION_MAX-6]
Version information pattern (BCH coded).
static const int eccTable[QRSPEC_VERSION_MAX+1][4][2]
Table of the error correction code (Reed-Solomon block) See Table 12-16 (pp.30-36), JIS X0510:2004.
unsigned int QRspec_getFormatInfo(int mask, QRecLevel level)
Return BCH encoded format information pattern.
QRecLevel
Level of error correction.
static void QRspec_putAlignmentPattern(int version, unsigned char *frame, int width)
static unsigned char * QRspec_createFrame(int version)
QRencodeMode
Encoding mode.
int QRspec_maximumWords(QRencodeMode mode, int version)
Return the maximum length for the mode and version.
int QRspec_lengthIndicator(QRencodeMode mode, int version)
Return the size of length indicator for the mode and version.
void QRspec_getEccSpec(int version, QRecLevel level, int spec[5])
Return an array of ECC specification.
int QRspec_getECCLength(int version, QRecLevel level)
Return maximum error correction code length (bytes) for the version.
int QRspec_getRemainder(int version)
Return the numer of remainder bits.
static const unsigned int formatInfo[4][8]
static void putFinderPattern(unsigned char *frame, int width, int ox, int oy)
Put a finder pattern.
static void QRspec_putAlignmentMarker(unsigned char *frame, int width, int ox, int oy)
Put an alignment marker.
unsigned char * QRspec_newFrame(int version)
Return a copy of initialized frame.
int QRspec_getMinimumVersion(int size, QRecLevel level)
Return a version number that satisfies the input code length.
unsigned int QRspec_getVersionPattern(int version)
Return BCH encoded version information pattern that is used for the symbol of version 7 or greater...
int QRspec_getWidth(int version)
Return the width of the symbol for the version.
static const QRspec_Capacity qrspecCapacity[QRSPEC_VERSION_MAX+1]
Table of the capacity of symbols See Table 1 (pp.13) and Table 12-16 (pp.30-36), JIS X0510:2004...