src/chxj_qr_code.c

   1 /*
   2  * Copyright (C) 2005-2009 Atsushi Konno All rights reserved.
   3  * Copyright (C) 2005 QSDN,Inc. All rights reserved.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17 #include <unistd.h>
  18 #include <assert.h>
  19 #include "apr_strings.h"
  20 #include "httpd.h"
  21 #include "http_protocol.h"
  22 #include "http_log.h"
  23
  24 #include "chxj_str_util.h"
  25 #include "chxj_qr_code.h"
  26 #include "chxj_calc_ecc.h"
  27 #include "mod_chxj.h"
  28 #include "chxj_specified_device.h"
  29 #include "qs_malloc.h"
  30 #include "qs_log.h"
  31 #include "qs_parse_file.h"
  32
  33 #include <wand/magick_wand.h>
  34
  35 /*
  36 #define QR_CODE_DEBUG
  37 */
  38 #define EXIT_MAGICK_ERROR() \
  39           do { \
  40              char *description; \
  41              ExceptionType severity; \
  42              description=MagickGetException(magick_wand,&severity); \
  43              ap_log_rerror(APLOG_MARK,APLOG_DEBUG, 0, r,"%s %s %d %s\n",__FILE__,(__func__),__LINE__,description); \
  44              description=(char *) MagickRelinquishMemory(description); \
  45              DestroyMagickWand(magick_wand); \
  46           }while(0)
  47
  48 /*----------------------------------------------------------------------------*/
  49 /* ¥â¡¼¥É»Ø¼¨»Ò¥Æ¡¼¥Ö¥ë                                                       */
  50 /*----------------------------------------------------------------------------*/
  51 static char* v_mode_table[] = {
  52 /* ¿ô»ú          */  "0001",
  53 /* ±Ñ¿ô»ú        */  "0010",
  54 /* 8¥Ó¥Ã¥È¥Ð¥¤¥È */  "0100",
  55 /* ´Á»ú          */  "1000",
  56 /* ECI           */  "0111",
  57 /* FNC1 1        */  "0101",
  58 /* FNC1 2        */  "1001",
  59 /* ¹½Â¤ÅªÏ¢ÀÜ    */  "0011",
  60 /* ½ªÃ¼¥Ñ¥¿¡¼¥ó  */  "0000",
  61 /* Í½Ìó          */  "0110",
  62 /* Í½Ìó          */  "1010",
  63 /* Í½Ìó          */  "1011",
  64 /* Í½Ìó          */  "1100",
  65 /* Í½Ìó          */  "1101",
  66 /* Í½Ìó          */  "1110",
  67 /* Í½Ìó          */  "1111",
  68 };
  69
  70 /*----------------------------------------------------------------------------*/
  71 /* Ê¸»ú¿ô»Ø¼¨»Ò¤Î¥Ó¥Ã¥È¿ô                                                     */
  72 /*----------------------------------------------------------------------------*/
  73 static char v_char_count_table[][4] = {
  74 /* ¥Ð¡¼¥¸¥ç¥ó *//* Ê¸»ú¿ô»Ø¼¨»Ò¤Î¥Ó¥Ã¥È¿ô */
  75 /*  1         */  { 10, 9, 8, 8, },
  76 /*  2         */  { 10, 9, 8, 8, },
  77 /*  3         */  { 10, 9, 8, 8, },
  78 /*  4         */  { 10, 9, 8, 8, },
  79 /*  5         */  { 10, 9, 8, 8, },
  80 /*  6         */  { 10, 9, 8, 8, },
  81 /*  7         */  { 10, 9, 8, 8, },
  82 /*  8         */  { 10, 9, 8, 8, },
  83 /*  9         */  { 10, 9, 8, 8, },
  84 /* 10         */  { 12,11,16,10, },
  85 /* 11         */  { 12,11,16,10, },
  86 /* 12         */  { 12,11,16,10, },
  87 /* 13         */  { 12,11,16,10, },
  88 /* 14         */  { 12,11,16,10, },
  89 /* 15         */  { 12,11,16,10, },
  90 /* 16         */  { 12,11,16,10, },
  91 /* 17         */  { 12,11,16,10, },
  92 /* 18         */  { 12,11,16,10, },
  93 /* 19         */  { 12,11,16,10, },
  94 /* 20         */  { 12,11,16,10, },
  95 /* 21         */  { 12,11,16,10, },
  96 /* 22         */  { 12,11,16,10, },
  97 /* 23         */  { 12,11,16,10, },
  98 /* 24         */  { 12,11,16,10, },
  99 /* 25         */  { 12,11,16,10, },
 100 /* 26         */  { 12,11,16,10, },
 101 /* 27         */  { 14,13,16,12, },
 102 /* 28         */  { 14,13,16,12, },
 103 /* 29         */  { 14,13,16,12, },
 104 /* 30         */  { 14,13,16,12, },
 105 /* 31         */  { 14,13,16,12, },
 106 /* 32         */  { 14,13,16,12, },
 107 /* 33         */  { 14,13,16,12, },
 108 /* 34         */  { 14,13,16,12, },
 109 /* 35         */  { 14,13,16,12, },
 110 /* 36         */  { 14,13,16,12, },
 111 /* 37         */  { 14,13,16,12, },
 112 /* 38         */  { 14,13,16,12, },
 113 /* 39         */  { 14,13,16,12, },
 114 /* 40         */  { 14,13,16,12, },
 115 };
 116 static int v_data_code_count[][4] = {
 117 /* ¥Ð¡¼¥¸¥ç¥ó *//* ¥Ç¡¼¥¿¥³¡¼¥É¿ô */
 118                 /*  L,    M,   Q,   H, */
 119 /* 1          */  {19,   16,  13,   9,},
 120 /* 2          */  {34,   28,  22,  16,},
 121 /* 3          */  {55,   44,  34,  26,},
 122 /* 4          */  {80,   64,  48,  36,},
 123 /* 5          */  {108,  86,  62,  46,},
 124 /* 6          */  {136, 108,  76,  60,},
 125 /* 7          */  {156, 124,  88,  66,},
 126 /* 8          */  {194, 154, 110,  86,},
 127 /* 9          */  {232, 182, 132, 100,},
 128 /* 10         */  {274, 216, 154, 122,},
 129 /* 11         */  {324, 254, 180, 140,},
 130 /* 12         */  {370, 290, 206, 158,},
 131 /* 13         */  {428, 334, 244, 180,},
 132 /* 14         */  {461, 365, 261, 197,},
 133 /* 15         */  {523, 415, 295, 223,},
 134 /* 16         */  {589, 453, 325, 253,},
 135 /* 17         */  {647, 507, 367, 283,},
 136 /* 18         */  {721, 563, 397, 313,},
 137 /* 19         */  {795, 627, 445, 341,},
 138 /* 20         */  {861, 669, 485, 385,},
 139 /* 21         */  {932, 714, 512, 406,},
 140 /* 22         */  {1006,782, 568, 442,},
 141 /* 23         */  {1094,860, 614, 464,},
 142 /* 24         */  {1174,914, 664, 514,},
 143 /* 25         */  {1276,1000,718, 538,},
 144 /* 26         */  {1370,1062,754, 596,},
 145 /* 27         */  {1468,1128,808, 628,},
 146 /* 28         */  {1531,1193,871, 661,},
 147 /* 29         */  {1631,1267,911, 701,},
 148 /* 30         */  {1735,1373,985, 745,},
 149 /* 31         */  {1843,1455,1033,793,},
 150 /* 32         */  {1955,1541,1115,845,},
 151 /* 33         */  {2071,1631,1171,901,},
 152 /* 34         */  {2191,1725,1231,961,},
 153 /* 35         */  {2306,1812,1286,986,},
 154 /* 36         */  {2434,1914,1354,1054,},
 155 /* 37         */  {2566,1992,1426,1096,},
 156 /* 38         */  {2702,2102,1502,1142,},
 157 /* 39         */  {2812,2216,1582,1222,},
 158 /* 40         */  {2956,2334,1666,1276,},
 159 };
 160
 161 /*----------------------------------------------------------------------------*/
 162 /* ¤¢¤Þ¤Ã¤¿¾ì¹ç¤ÎÉÕ²Ã¥Ó¥Ã¥È                                                   */
 163 /*----------------------------------------------------------------------------*/
 164 static char* v_pend_bit[]  = {
 165   "11101100",
 166   "00010001",
 167 };
 168
 169 /*----------------------------------------------------------------------------*/
 170 /* ¥â¥¸¥å¡¼¥ë¿ô                                                               */
 171 /*----------------------------------------------------------------------------*/
 172 static int v_module_count_table[] = {
 173   21, 25, 29, 33, 37, 41, 45, 49,
 174   53, 57, 61, 65, 69, 73, 77, 81,
 175   85, 89, 93, 97, 101, 105, 109, 113,
 176   117, 121, 125, 129, 133, 137, 141, 145,
 177   149, 153, 157, 161, 165, 169, 173, 177,
 178 };
 179 /*----------------------------------------------------------------------------*/
 180 /* °ÌÃÖ¤¢¤ï¤»¥Ñ¥¿¡¼¥ó¤Î°ÌÃÖ                                                   */
 181 /*----------------------------------------------------------------------------*/
 182 typedef struct _qr_position_pattern_t {
 183   int count;
 184   int position[7];
 185 } qr_position_pattern_t;
 186
 187 static qr_position_pattern_t v_position_adjust_table[] = {
 188   { 0, {0,0,0,0,0,0,0,},},
 189   { 1, {6,18,0,0,0,0,0,},},
 190   { 1, {6,22,0,0,0,0,0,},},
 191   { 1, {6,26,0,0,0,0,0,},},
 192   { 1, {6,30,0,0,0,0,0,},},
 193   { 1, {6,34,0,0,0,0,0,},},
 194   { 6, {6,22,38,0,0,0,0,},},
 195   { 6, {6,24,42,0,0,0,0,},},
 196   { 6, {6,26,46,0,0,0,0,},},
 197   { 6, {6,28,50,0,0,0,0,},},
 198   { 6, {6,30,54,0,0,0,0,},},
 199   { 6, {6,32,58,0,0,0,0,},},
 200   { 6, {6,34,62,0,0,0,0,},},
 201   {13, {6,26,46,66,0,0,0,},},
 202   {13, {6,26,48,70,0,0,0,},},
 203   {13, {6,26,50,74,0,0,0,},},
 204   {13, {6,30,54,78,0,0,0,},},
 205   {13, {6,30,56,82,0,0,0,},},
 206   {13, {6,30,58,86,0,0,0,},},
 207   {13, {6,34,62,90,0,0,0,},},
 208   {22, {6,28,50,72,94,0,0,},},
 209   {22, {6,26,50,74,98,0,0,},},
 210   {22, {6,30,54,78,102,0,0,},},
 211   {22, {6,28,54,80,106,0,0,},},
 212   {22, {6,32,58,84,110,0,0,},},
 213   {22, {6,30,58,86,114,0,0,},},
 214   {22, {6,34,62,90,118,0,0,},},
 215   {33, {6,26,50,74,98,122,0,},},
 216   {33, {6,30,54,78,102,126,0,},},
 217   {33, {6,26,52,78,104,130,0,},},
 218   {33, {6,30,56,82,108,134,0,},},
 219   {33, {6,34,60,86,112,138,0,},},
 220   {33, {6,30,58,86,114,142,0,},},
 221   {33, {6,34,62,90,118,146,0,},},
 222   {46, {6,30,54,78,102,126,150,},},
 223   {46, {6,24,50,76,102,128,154,},},
 224   {46, {6,28,54,80,106,132,158,},},
 225   {46, {6,32,58,84,110,136,162,},},
 226   {46, {6,26,54,82,110,138,166,},},
 227   {46, {6,30,58,86,114,142,170,},},
 228 };
 229
 230 /*----------------------------------------------------------------------------*/
 231 /* ¥Þ¥¹¥¯ÄêµÁ                                                                 */
 232 /*----------------------------------------------------------------------------*/
 233 typedef enum _qr_mask_pattern_t {
 234   QR_MASK_1 = 0,
 235   QR_MASK_2,
 236   QR_MASK_3,
 237   QR_MASK_4,
 238   QR_MASK_5,
 239   QR_MASK_6,
 240   QR_MASK_7,
 241   QR_MASK_8,
 242 }
 243 qr_mask_pattern_t;
 244
 245 /*----------------------------------------------------------------------------*/
 246 /* Çò¤¤²èÁü(PNG)                                                              */
 247 /*----------------------------------------------------------------------------*/
 248 static unsigned char v_white_base_pic[] = {
 249   0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
 250   0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
 251   0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18,
 252   0x08, 0x02, 0x00, 0x00, 0x00, 0x6f, 0x15, 0xaa,
 253   0xaf, 0x00, 0x00, 0x00, 0x09, 0x70, 0x48, 0x59,
 254   0x73, 0x00, 0x00, 0x0b, 0x12, 0x00, 0x00, 0x0b,
 255   0x12, 0x01, 0xd2, 0xdd, 0x7e, 0xfc, 0x00, 0x00,
 256   0x00, 0x07, 0x74, 0x49, 0x4d, 0x45, 0x07, 0xd5,
 257   0x04, 0x04, 0x17, 0x13, 0x07, 0x12, 0x27, 0x77,
 258   0x6f, 0x00, 0x00, 0x00, 0x22, 0x49, 0x44, 0x41,
 259   0x54, 0x78, 0x9c, 0x63, 0xfc, 0xff, 0xff, 0x3f,
 260   0x03, 0x35, 0x00, 0x13, 0x55, 0x4c, 0x19, 0x35,
 261   0x68, 0xd4, 0xa0, 0x51, 0x83, 0x46, 0x0d, 0x1a,
 262   0x35, 0x68, 0xd4, 0x20, 0x8a, 0x00, 0x00, 0x19,
 263   0xd1, 0x03, 0x2d, 0xc6, 0xa1, 0x61, 0x7f, 0x00,
 264   0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae,
 265   0x42, 0x60, 0x82, 0x0a
 266 };
 267 /*----------------------------------------------------------------------------*/
 268 /* ¹õ¤¤²èÁü(PNG)                                                              */
 269 /*----------------------------------------------------------------------------*/
 270 static unsigned char v_black_pixel_pic[] = {
 271   0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
 272   0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
 273   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
 274   0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0x15, 0xc4,
 275   0x89, 0x00, 0x00, 0x00, 0x01, 0x73, 0x52, 0x47,
 276   0x42, 0x00, 0xae, 0xce, 0x1c, 0xe9, 0x00, 0x00,
 277   0x00, 0x04, 0x67, 0x41, 0x4d, 0x41, 0x00, 0x00,
 278   0xb1, 0x8f, 0x0b, 0xfc, 0x61, 0x05, 0x00, 0x00,
 279   0x00, 0x20, 0x63, 0x48, 0x52, 0x4d, 0x00, 0x00,
 280   0x7a, 0x26, 0x00, 0x00, 0x80, 0x84, 0x00, 0x00,
 281   0xfa, 0x00, 0x00, 0x00, 0x80, 0xe8, 0x00, 0x00,
 282   0x75, 0x30, 0x00, 0x00, 0xea, 0x60, 0x00, 0x00,
 283   0x3a, 0x98, 0x00, 0x00, 0x17, 0x70, 0x9c, 0xba,
 284   0x51, 0x3c, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x44,
 285   0x41, 0x54, 0x18, 0x57, 0x63, 0x60, 0x60, 0x60,
 286   0xf8, 0x0f, 0x00, 0x01, 0x04, 0x01, 0x00, 0x70,
 287   0x20, 0x65, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x49,
 288   0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
 289 };
 290 /*----------------------------------------------------------------------------*/
 291 /* ·¿ÈÖ¾ðÊó                                                                   */
 292 /*----------------------------------------------------------------------------*/
 293 typedef struct _qr_version_info_t {
 294   qr_ver_t version;
 295   char* bits;
 296 } qr_version_info_t;
 297
 298 static qr_version_info_t v_version_info_table[] = {
 299   {QR_VER_1, NULL,},
 300   {QR_VER_2, NULL,},
 301   {QR_VER_3, NULL,},
 302   {QR_VER_4, NULL,},
 303   {QR_VER_5, NULL,},
 304   {QR_VER_6, NULL,},
 305   {QR_VER_7, "000111110010010100",},
 306   {QR_VER_8, "001000010110111100",},
 307   {QR_VER_9, "001001101010011001",},
 308   {QR_VER_10,"001010010011010011",},
 309   {QR_VER_11,"001011101111110110",},
 310   {QR_VER_12,"001100011101100010",},
 311   {QR_VER_13,"001101100001000111",},
 312   {QR_VER_14,"001110011000001101",},
 313   {QR_VER_15,"001111100100101000",},
 314   {QR_VER_16,"010000101101111000",},
 315   {QR_VER_17,"010001010001011101",},
 316   {QR_VER_18,"010010101000010111",},
 317   {QR_VER_19,"010011010100110010",},
 318   {QR_VER_20,"010100100110100110",},
 319   {QR_VER_21,"010101011010000011",},
 320   {QR_VER_22,"010110100011001001",},
 321   {QR_VER_23,"010111011111101100",},
 322   {QR_VER_24,"011000111011000100",},
 323   {QR_VER_25,"011001000111100001",},
 324   {QR_VER_26,"011010111110101011",},
 325   {QR_VER_27,"011011000010001110",},
 326   {QR_VER_28,"011100110000011010",},
 327   {QR_VER_29,"011101001100111111",},
 328   {QR_VER_30,"011110110101110101",},
 329   {QR_VER_31,"011111001001010000",},
 330   {QR_VER_32,"100000100111010101",},
 331   {QR_VER_33,"100001011011110000",},
 332   {QR_VER_34,"100010100010111010",},
 333   {QR_VER_35,"100011011110011111",},
 334   {QR_VER_36,"100100101100001011",},
 335   {QR_VER_37,"100101010000101110",},
 336   {QR_VER_38,"100110101001100100",},
 337   {QR_VER_39,"100111010101000001",},
 338   {QR_VER_40,"101000110001101001",},
 339 };
 340
 341 /**
 342  * ¥Ç¡¼¥¿ÍÆÎÌ¤Î¥Æ¡¼¥Ö¥ë
 343  */
 344 /*----------------------------------------------------------------------------*/
 345 /* ¥Ð¡¼¥¸¥ç¥óÊÌ¡¢¥ì¥Ù¥ëÊÌ¡¢¥â¡¼¥ÉÊÌ¥Ç¡¼¥¿ÍÆÎÌ                                 */
 346 /*----------------------------------------------------------------------------*/
 347 typedef struct _qr_capacity_t {
 348   qr_ver_t    version; /* ¾éÄ¹¾ðÊó */
 349   qr_level_t  level;   /* ¾éÄ¹¾ðÊó */
 350   int size[4];
 351 } qr_capacity_t;
 352
 353 static qr_capacity_t v_capacity_table[] = {
 354   {QR_VER_1, QR_LEVEL_L, {  41,  25,  17,  10, },},
 355   {QR_VER_1, QR_LEVEL_M, {  34,  20,  14,   8, },},
 356   {QR_VER_1, QR_LEVEL_Q, {  27,  16,  11,   7, },},
 357   {QR_VER_1, QR_LEVEL_H, {  17,  10,   7,   4, },},
 358
 359   {QR_VER_2, QR_LEVEL_L, {  77,  47,  32,  20, },},
 360   {QR_VER_2, QR_LEVEL_M, {  63,  38,  26,  16, },},
 361   {QR_VER_2, QR_LEVEL_Q, {  48,  29,  20,  12, },},
 362   {QR_VER_2, QR_LEVEL_H, {  34,  20,  14,   8, },},
 363
 364   {QR_VER_3, QR_LEVEL_L, { 127,  77,  53,  32, },},
 365   {QR_VER_3, QR_LEVEL_M, { 101,  61,  42,  26, },},
 366   {QR_VER_3, QR_LEVEL_Q, {  77,  47,  32,  20, },},
 367   {QR_VER_3, QR_LEVEL_H, {  58,  35,  24,  15, },},
 368
 369   {QR_VER_4, QR_LEVEL_L, { 187, 114,  78,  48, },},
 370   {QR_VER_4, QR_LEVEL_M, { 149,  90,  62,  38, },},
 371   {QR_VER_4, QR_LEVEL_Q, { 111,  67,  46,  28, },},
 372   {QR_VER_4, QR_LEVEL_H, {  82,  50,  34,  21, },},
 373
 374   {QR_VER_5, QR_LEVEL_L, { 255, 154, 106,  65, },},
 375   {QR_VER_5, QR_LEVEL_M, { 202, 122,  84,  52, },},
 376   {QR_VER_5, QR_LEVEL_Q, { 144,  87,  60,  37, },},
 377   {QR_VER_5, QR_LEVEL_H, { 106,  64,  44,  27, },},
 378
 379   {QR_VER_6, QR_LEVEL_L, { 322, 195, 134,  82, },},
 380   {QR_VER_6, QR_LEVEL_M, { 255, 154, 106,  65, },},
 381   {QR_VER_6, QR_LEVEL_Q, { 178, 108,  74,  45, },},
 382   {QR_VER_6, QR_LEVEL_H, { 139,  84,  58,  36, },},
 383
 384   {QR_VER_7, QR_LEVEL_L, { 370, 224, 154,  95, },},
 385   {QR_VER_7, QR_LEVEL_M, { 293, 178, 122,  75, },},
 386   {QR_VER_7, QR_LEVEL_Q, { 207, 125,  86,  53, },},
 387   {QR_VER_7, QR_LEVEL_H, { 154,  93,  64,  39, },},
 388
 389   {QR_VER_8, QR_LEVEL_L, { 461, 279, 192, 118, },},
 390   {QR_VER_8, QR_LEVEL_M, { 365, 221, 152,  93, },},
 391   {QR_VER_8, QR_LEVEL_Q, { 259, 157, 108,  66, },},
 392   {QR_VER_8, QR_LEVEL_H, { 202, 122,  84,  52, },},
 393
 394   {QR_VER_9, QR_LEVEL_L, { 552, 335, 230, 141, },},
 395   {QR_VER_9, QR_LEVEL_M, { 432, 262, 180, 111, },},
 396   {QR_VER_9, QR_LEVEL_Q, { 312, 189, 130,  80, },},
 397   {QR_VER_9, QR_LEVEL_H, { 235, 143,  98,  60, },},
 398
 399   {QR_VER_10, QR_LEVEL_L, { 652, 395, 271, 167, },},
 400   {QR_VER_10, QR_LEVEL_M, { 513, 311, 213, 131, },},
 401   {QR_VER_10, QR_LEVEL_Q, { 364, 221, 151,  93, },},
 402   {QR_VER_10, QR_LEVEL_H, { 288, 174, 119,  74, },},
 403
 404   {QR_VER_11, QR_LEVEL_L, { 772, 468, 321, 198, },},
 405   {QR_VER_11, QR_LEVEL_M, { 604, 366, 251, 155, },},
 406   {QR_VER_11, QR_LEVEL_Q, { 427, 259, 177, 109, },},
 407   {QR_VER_11, QR_LEVEL_H, { 331, 200, 137,  85, },},
 408
 409   {QR_VER_12, QR_LEVEL_L, { 883, 535, 367, 226, },},
 410   {QR_VER_12, QR_LEVEL_M, { 691, 419, 287, 177, },},
 411   {QR_VER_12, QR_LEVEL_Q, { 489, 296, 203, 125, },},
 412   {QR_VER_12, QR_LEVEL_H, { 374, 227, 155,  96, },},
 413
 414   {QR_VER_13, QR_LEVEL_L, {1022, 619, 425, 262, },},
 415   {QR_VER_13, QR_LEVEL_M, { 796, 483, 331, 204, },},
 416   {QR_VER_13, QR_LEVEL_Q, { 580, 352, 241, 149, },},
 417   {QR_VER_13, QR_LEVEL_H, { 427, 259, 177, 109, },},
 418
 419   {QR_VER_14, QR_LEVEL_L, {1101, 667, 458, 282, },},
 420   {QR_VER_14, QR_LEVEL_M, { 871, 528, 362, 223, },},
 421   {QR_VER_14, QR_LEVEL_Q, { 621, 376, 258, 159, },},
 422   {QR_VER_14, QR_LEVEL_H, { 468, 283, 194, 120, },},
 423
 424   {QR_VER_15, QR_LEVEL_L, {1250, 758, 520, 320, },},
 425   {QR_VER_15, QR_LEVEL_M, { 991, 600, 412, 254, },},
 426   {QR_VER_15, QR_LEVEL_Q, { 703, 426, 292, 180, },},
 427   {QR_VER_15, QR_LEVEL_H, { 530, 321, 220, 136, },},
 428
 429   {QR_VER_16, QR_LEVEL_L, {1408, 854, 586, 361, },},
 430   {QR_VER_16, QR_LEVEL_M, {1082, 656, 450, 277, },},
 431   {QR_VER_16, QR_LEVEL_Q, { 775, 470, 322, 198, },},
 432   {QR_VER_16, QR_LEVEL_H, { 602, 365, 250, 154, },},
 433
 434   {QR_VER_17, QR_LEVEL_L, {1548, 938, 644, 397, },},
 435   {QR_VER_17, QR_LEVEL_M, {1212, 734, 504, 310, },},
 436   {QR_VER_17, QR_LEVEL_Q, { 876, 531, 364, 224, },},
 437   {QR_VER_17, QR_LEVEL_H, { 674, 408, 280, 173, },},
 438
 439   {QR_VER_18, QR_LEVEL_L, {1725,1046, 718, 442, },},
 440   {QR_VER_18, QR_LEVEL_M, {1346, 816, 560, 345, },},
 441   {QR_VER_18, QR_LEVEL_Q, { 948, 574, 394, 243, },},
 442   {QR_VER_18, QR_LEVEL_H, { 746, 452, 310, 191, },},
 443
 444   {QR_VER_19, QR_LEVEL_L, {1903,1153, 792, 488, },},
 445   {QR_VER_19, QR_LEVEL_M, {1500, 909, 624, 384, },},
 446   {QR_VER_19, QR_LEVEL_Q, {1063, 644, 442, 272, },},
 447   {QR_VER_19, QR_LEVEL_H, { 813, 493, 338, 208, },},
 448
 449   {QR_VER_20, QR_LEVEL_L, {2061,1249, 858, 528, },},
 450   {QR_VER_20, QR_LEVEL_M, {1600, 970, 666, 410, },},
 451   {QR_VER_20, QR_LEVEL_Q, {1159, 702, 482, 297, },},
 452   {QR_VER_20, QR_LEVEL_H, { 919, 557, 382, 235, },},
 453
 454   {QR_VER_21, QR_LEVEL_L, {2232,1352, 929, 572, },},
 455   {QR_VER_21, QR_LEVEL_M, {1708,1035, 711, 438, },},
 456   {QR_VER_21, QR_LEVEL_Q, {1224, 742, 509, 314, },},
 457   {QR_VER_21, QR_LEVEL_H, { 969, 587, 403, 248, },},
 458
 459   {QR_VER_22, QR_LEVEL_L, {2409,1460,1003, 618, },},
 460   {QR_VER_22, QR_LEVEL_M, {1872,1134, 779, 480, },},
 461   {QR_VER_22, QR_LEVEL_Q, {1358, 823, 565, 348, },},
 462   {QR_VER_22, QR_LEVEL_H, {1056, 640, 439, 270, },},
 463
 464   {QR_VER_23, QR_LEVEL_L, {2620,1588,1091, 672, },},
 465   {QR_VER_23, QR_LEVEL_M, {2059,1248, 857, 528, },},
 466   {QR_VER_23, QR_LEVEL_Q, {1468, 890, 611, 376, },},
 467   {QR_VER_23, QR_LEVEL_H, {1108, 672, 461, 284, },},
 468
 469   {QR_VER_24, QR_LEVEL_L, {2812,1704,1171, 721, },},
 470   {QR_VER_24, QR_LEVEL_M, {2188,1326, 911, 561, },},
 471   {QR_VER_24, QR_LEVEL_Q, {1588, 963, 661, 407, },},
 472   {QR_VER_24, QR_LEVEL_H, {1228, 744, 511, 315, },},
 473
 474   {QR_VER_25, QR_LEVEL_L, {3057,1853,1273, 784, },},
 475   {QR_VER_25, QR_LEVEL_M, {2395,1451, 997, 614, },},
 476   {QR_VER_25, QR_LEVEL_Q, {1718,1041, 715, 440, },},
 477   {QR_VER_25, QR_LEVEL_H, {1286, 779, 535, 330, },},
 478
 479   {QR_VER_26, QR_LEVEL_L, {3283,1990,1367, 842, },},
 480   {QR_VER_26, QR_LEVEL_M, {2544,1542,1059, 652, },},
 481   {QR_VER_26, QR_LEVEL_Q, {1804,1094, 751, 462, },},
 482   {QR_VER_26, QR_LEVEL_H, {1425, 864, 593, 365, },},
 483
 484   {QR_VER_27, QR_LEVEL_L, {3517,2132,1465, 902, },},
 485   {QR_VER_27, QR_LEVEL_M, {2701,1637,1125, 692, },},
 486   {QR_VER_27, QR_LEVEL_Q, {1933,1172, 805, 496, },},
 487   {QR_VER_27, QR_LEVEL_H, {1501, 910, 625, 385, },},
 488
 489   {QR_VER_28, QR_LEVEL_L, {3669,2223,1528, 940, },},
 490   {QR_VER_28, QR_LEVEL_M, {2857,1732,1190, 732, },},
 491   {QR_VER_28, QR_LEVEL_Q, {2085,1263, 868, 534, },},
 492   {QR_VER_28, QR_LEVEL_H, {1581, 958, 658, 405, },},
 493
 494   {QR_VER_29, QR_LEVEL_L, {3909,2369,1628,1002, },},
 495   {QR_VER_29, QR_LEVEL_M, {3035,1839,1264, 778, },},
 496   {QR_VER_29, QR_LEVEL_Q, {2181,1322, 908, 559, },},
 497   {QR_VER_29, QR_LEVEL_H, {1677,1016, 698, 430, },},
 498
 499   {QR_VER_30, QR_LEVEL_L, {4158,2520,1732,1066, },},
 500   {QR_VER_30, QR_LEVEL_M, {3289,1994,1370, 843, },},
 501   {QR_VER_30, QR_LEVEL_Q, {2358,1429, 982, 604, },},
 502   {QR_VER_30, QR_LEVEL_H, {1782,1080, 742, 457, },},
 503
 504   {QR_VER_31, QR_LEVEL_L, {4417,2677,1840,1132, },},
 505   {QR_VER_31, QR_LEVEL_M, {3486,2113,1452, 894, },},
 506   {QR_VER_31, QR_LEVEL_Q, {2473,1499,1030, 634, },},
 507   {QR_VER_31, QR_LEVEL_H, {1897,1150, 790, 486, },},
 508
 509   {QR_VER_32, QR_LEVEL_L, {4686,2840,1952,1201, },},
 510   {QR_VER_32, QR_LEVEL_M, {3693,2238,1538, 947, },},
 511   {QR_VER_32, QR_LEVEL_Q, {2670,1618,1112, 684, },},
 512   {QR_VER_32, QR_LEVEL_H, {2022,1226, 842, 518, },},
 513
 514   {QR_VER_33, QR_LEVEL_L, {4965,3009,2068,1273, },},
 515   {QR_VER_33, QR_LEVEL_M, {3909,2369,1628,1002, },},
 516   {QR_VER_33, QR_LEVEL_Q, {2805,1700,1168, 719, },},
 517   {QR_VER_33, QR_LEVEL_H, {2157,1307, 898, 553, },},
 518
 519   {QR_VER_34, QR_LEVEL_L, {5253,3183,2188,1347, },},
 520   {QR_VER_34, QR_LEVEL_M, {4134,2506,1722,1060, },},
 521   {QR_VER_34, QR_LEVEL_Q, {2949,1787,1228, 756, },},
 522   {QR_VER_34, QR_LEVEL_H, {2301,1394, 958, 590, },},
 523
 524   {QR_VER_35, QR_LEVEL_L, {5529,3351,2303,1417, },},
 525   {QR_VER_35, QR_LEVEL_M, {4343,2632,1809,1113, },},
 526   {QR_VER_35, QR_LEVEL_Q, {3081,1867,1283, 790, },},
 527   {QR_VER_35, QR_LEVEL_H, {2361,1431, 983, 605, },},
 528
 529   {QR_VER_36, QR_LEVEL_L, {5836,3537,2431,1496, },},
 530   {QR_VER_36, QR_LEVEL_M, {4588,2780,1911,1176, },},
 531   {QR_VER_36, QR_LEVEL_Q, {3244,1966,1351, 832, },},
 532   {QR_VER_36, QR_LEVEL_H, {2524,1530,1051, 647, },},
 533
 534   {QR_VER_37, QR_LEVEL_L, {6153,3729,2563,1577, },},
 535   {QR_VER_37, QR_LEVEL_M, {4775,2894,1989,1224, },},
 536   {QR_VER_37, QR_LEVEL_Q, {3417,2071,1423, 876, },},
 537   {QR_VER_37, QR_LEVEL_H, {2625,1591,1093, 673, },},
 538
 539   {QR_VER_38, QR_LEVEL_L, {6479,3927,2699,1661, },},
 540   {QR_VER_38, QR_LEVEL_M, {5039,3054,2099,1292, },},
 541   {QR_VER_38, QR_LEVEL_Q, {3599,2181,1499, 923, },},
 542   {QR_VER_38, QR_LEVEL_H, {2735,1658,1139, 701, },},
 543
 544   {QR_VER_39, QR_LEVEL_L, {6743,4087,2809,1729, },},
 545   {QR_VER_39, QR_LEVEL_M, {5313,3220,2213,1362, },},
 546   {QR_VER_39, QR_LEVEL_Q, {3791,2298,1579, 972, },},
 547   {QR_VER_39, QR_LEVEL_H, {2927,1774,1219, 750, },},
 548
 549   {QR_VER_40, QR_LEVEL_L, {7089,4296,2953,1817, },},
 550   {QR_VER_40, QR_LEVEL_M, {5596,3391,2331,1435, },},
 551   {QR_VER_40, QR_LEVEL_Q, {3993,2420,1663,1024, },},
 552   {QR_VER_40, QR_LEVEL_H, {3057,1852,1273, 784, },},
 553 };
 554
 555
 556 static char   *s_get_mode_spec       (qr_code_t *qrcode);
 557 static char   *s_get_char_bit_count  (qr_code_t *qrcode, int len);
 558 static char   *s_data_to_bin_num     (qr_code_t *qrcode, int data_code_count);
 559 static char   *s_data_to_bin_alpha   (qr_code_t *qrcode, int data_code_count);
 560 static int    s_char_to_num_alpha    (qr_code_t *qrcode, char src);
 561 static char   *s_data_to_bin_8bit    (qr_code_t *qrcode, int data_code_count);
 562 static char   *s_data_to_bin_kanji   (qr_code_t *qrcode, int data_code_count);
 563 static char   *s_tidy_8bit_code      (qr_code_t *qrcode, const char *indata, int data_code_count);
 564 static char   *s_str_to_bin          (qr_code_t *qrcode, char *indata, int data_code_count);
 565 static void   s_init_modules         (qr_code_t *qrcode, qr_mask_pattern_t pat, char *module[]);
 566 static void   s_setup_probe_position (qr_code_t *qrcode, char *dst[], int pos_x, int pos_y);
 567 static void   s_setup_timing_pattern (qr_code_t *qrcode, char *dst[]);
 568 static void   s_setup_position_adjust(qr_code_t *qrcode, char *dst[]);
 569 static void   s_setup_type_info      (qr_code_t *qrcode, char *dst[], qr_mask_pattern_t pat);
 570 static void   s_setup_version_info   (qr_code_t *qrcode, char *dst[]);
 571 static void   s_map_data             (qr_code_t *qrcode, char *dst[], unsigned char *indata,
 572                 int data_count, qr_mask_pattern_t pat);
 573 static int    s_get_mask            (qr_mask_pattern_t pat, int yy, int xx);
 574 static int    s_get_bit_count       (int data);
 575 static int    s_calc_lost_point     (qr_code_t *qrcode, char *dst[]);
 576 static int    s_count_same_module   (qr_ver_t ver, char* dst[]);
 577 static int    s_count_same_block    (qr_ver_t ver, char* dst[]);
 578 static int    s_count_11311_pattern (qr_ver_t ver, char* dst[]);
 579 static int    s_count_dark_ratio    (qr_ver_t ver, char* dst[]);
 580
 581 static void   chxj_qr_code          (qr_code_t *qrcode, char *module[]);
 582
 583 int
 584 chxj_qr_code_handler(request_rec *r)
 585 {
 586   int                sts;
 587   size_t             len;
 588   qr_code_t          qrcode;
 589   Doc                doc;
 590   char               *img;
 591   Node               *root;
 592   mod_chxj_config    *conf;
 593
 594   DBG(r,"start chxj_qr_code_handler()");
 595
 596   if (strcasecmp(r->handler, "chxj-qrcode")) {
 597     DBG(r, "end chxj_qr_code_handler()");
 598     return DECLINED;
 599   }
 600
 601   /*--------------------------------------------------------------------------*/
 602   /* ¤â¤·¡¢¥¤¥á¡¼¥¸ÊÑ´¹¥Ï¥ó¥É¥éÃæ¤Ç¤¢¤ì¤Ð¡¢¤³¤³¤Ç¤Ï½èÍý¤·¤Ê¤¤                 */
 603   /*--------------------------------------------------------------------------*/
 604   conf = chxj_get_module_config(r->per_dir_config, &chxj_module);
 605   if (!conf || conf->image == CHXJ_IMG_ON)
 606     return DECLINED;
 607
 608   memset(&doc, 0, sizeof(Doc));
 609   memset(&qrcode, 0, sizeof(qr_code_t));
 610
 611   doc.r           = r;
 612   doc.parse_mode  = PARSE_MODE_CHTML;
 613   qrcode.doc      = &doc;
 614   qrcode.r        = r;
 615
 616   qs_init_malloc(&doc);
 617   root = qs_parse_file(&doc, r->filename);
 618   qrcode.found = QR_NOT_FOUND;
 619   chxj_qrcode_node_to_qrcode(&qrcode, root);
 620
 621   if (qrcode.found == QR_NOT_FOUND)
 622     return HTTP_NOT_FOUND;
 623
 624   qs_all_free(&doc,QX_LOGMARK);
 625
 626   sts = chxj_qrcode_create_image_data(&qrcode, &img, &len);
 627   if (sts != OK)
 628     return sts;
 629
 630   chxj_set_content_type(r, "image/jpg");
 631
 632   ap_rwrite((void *)img, len, r);
 633
 634   return OK;
 635 }
 636
 637
 638 char *
 639 chxj_qr_code_blob_handler(request_rec *r, const char *indata, size_t *len)
 640 {
 641   int                sts;
 642   qr_code_t          qrcode;
 643   Doc                doc;
 644   char               *img;
 645   Node               *root;
 646
 647   DBG(r, "start chxj_qr_code_blob_handler()");
 648
 649   memset(&doc, 0, sizeof(Doc));
 650   memset(&qrcode, 0, sizeof(qr_code_t));
 651
 652   doc.r           = r;
 653   doc.parse_mode  = PARSE_MODE_CHTML;
 654   qrcode.doc      = &doc;
 655   qrcode.r        = r;
 656
 657   qs_init_malloc(&doc);
 658   root = qs_parse_string(&doc, indata, *len);
 659   qrcode.found = QR_NOT_FOUND;
 660   chxj_qrcode_node_to_qrcode(&qrcode, root);
 661   qs_all_free(&doc,QX_LOGMARK);
 662
 663   if (qrcode.found == QR_NOT_FOUND)
 664     return NULL;
 665
 666   sts = chxj_qrcode_create_image_data(&qrcode, &img, len);
 667   if (sts != OK) {
 668     DBG(r, "end chxj_qr_code_blob_handler()");
 669     return NULL;
 670   }
 671
 672   chxj_set_content_type(r, "image/jpg");
 673
 674   DBG(r, "end chxj_qr_code_blob_handler()");
 675
 676   return img;
 677 }
 678
 679
 680 int
 681 chxj_qrcode_create_image_data(
 682   qr_code_t   *qrcode,
 683   char        **img,
 684   apr_size_t  *img_len)
 685 {
 686   int                xx, yy;
 687   int                module_count;
 688   MagickBooleanType  status;
 689   request_rec        *r = qrcode->r;
 690   MagickWand         *magick_wand;
 691   MagickWand         *black_wand;
 692   unsigned char      *tmp;
 693   char               **module;
 694
 695 #ifdef QR_CODE_DEBUG
 696   DBG(r,"start s_create_image_file()");
 697 #endif
 698
 699   module_count  = v_module_count_table[qrcode->version];
 700   module = (char **)apr_palloc(r->pool, sizeof(char*)*(module_count+1));
 701   for (yy=0; yy<module_count; yy++) {
 702     module[yy] = (char*)apr_palloc(r->pool, module_count+1);
 703     memset(module[yy], -1, module_count+1);
 704   }
 705
 706   chxj_qr_code(qrcode,  module);
 707
 708   magick_wand = NewMagickWand();
 709   black_wand = NewMagickWand();
 710
 711
 712   if (MagickSetSize(magick_wand, 24, 24) == MagickFalse)
 713     goto on_error;
 714
 715   if (MagickSetSize(black_wand, 24, 24) == MagickFalse)
 716     goto on_error;
 717
 718   if (MagickReadImageBlob(magick_wand, v_white_base_pic, sizeof(v_white_base_pic)) == MagickFalse)
 719     goto on_error;
 720
 721   if (MagickReadImageBlob(black_wand, v_black_pixel_pic, sizeof(v_black_pixel_pic)) == MagickFalse)
 722     goto on_error;
 723
 724   if (MagickSetImageUnits(magick_wand, PixelsPerInchResolution) == MagickFalse)
 725     goto on_error;
 726
 727   if (MagickSetImageUnits(black_wand, PixelsPerInchResolution) == MagickFalse)
 728     goto on_error;
 729
 730   if (MagickResizeImage(magick_wand, (module_count)+6, (module_count)+6 , LanczosFilter,0.0) == MagickFalse)
 731     goto on_error;
 732
 733   if (MagickSetImageResolution(magick_wand, 96,96) == MagickFalse)
 734     goto on_error;
 735
 736   if (MagickSetImageResolution(black_wand, 96,96) == MagickFalse)
 737     goto on_error;
 738
 739   if (MagickSetImageType(magick_wand, GrayscaleType) == MagickFalse)
 740     goto on_error;
 741
 742   if (MagickSetImageType(black_wand, GrayscaleType) == MagickFalse)
 743     goto on_error;
 744
 745
 746   for (yy=0; yy<module_count; yy++) {
 747     for (xx=0; xx<module_count; xx++) {
 748       if (module[yy][xx] == '1') {
 749         if (MagickCompositeImage(magick_wand, black_wand, CopyCompositeOp, xx+3,yy+3) == MagickFalse)
 750           goto on_error;
 751       }
 752     }
 753   }
 754
 755   if (qrcode->size <= 0) {
 756     status = MagickResizeImage(magick_wand, ((module_count)*4+6), ((module_count)*4+6) , LanczosFilter,0.0);
 757   }
 758   else {
 759     status = MagickResizeImage(magick_wand,
 760                                (module_count * qrcode->size + 6),
 761                                (module_count * qrcode->size + 6) ,
 762                                LanczosFilter,
 763                                0.0);
 764   }
 765   if (status == MagickFalse)
 766     goto on_error;
 767
 768   if (MagickSetImageFormat(magick_wand,"jpg") == MagickFalse)
 769     goto on_error;
 770
 771 #ifdef QR_CODE_DEBUG
 772   DBG(r,"convert to jpg");
 773 #endif
 774
 775   tmp = (unsigned char*)MagickGetImageBlob(magick_wand,img_len);
 776   *img = apr_palloc(r->pool, *img_len);
 777   memcpy(*img, tmp, *img_len);
 778
 779
 780   DestroyMagickWand(magick_wand);
 781   DestroyMagickWand(black_wand);
 782
 783
 784 #ifdef QR_CODE_DEBUG
 785   DBG(r, "end chxj_qr_code_handler()");
 786 #endif
 787
 788   return OK;
 789
 790 on_error:
 791   EXIT_MAGICK_ERROR();
 792   return HTTP_NOT_FOUND;
 793 }
 794
 795
 796
 797 static void
 798 chxj_qr_code(qr_code_t *qrcode, char *module[])
 799 {
 800   request_rec       *r     = qrcode->doc->r;
 801   unsigned char     *eccstr;
 802   int               ii;
 803   int               data_code_count;
 804   char              *real_data  = NULL;
 805   char              *decstr;
 806   char              *binstr;
 807   int               data_total_count;
 808   int               min_lost_point;
 809   int               min_mask_pattern;
 810   int               module_count = v_module_count_table[qrcode->version];
 811
 812 #ifdef QR_CODE_DEBUG
 813   DBG(r,"start chxj_qr_code()");
 814 #endif
 815   do {
 816     /*------------------------------------------------------------------------*/
 817     /* ¥â¡¼¥É»Ø¼¨»Ò¤ò¼èÆÀ¤·¤Þ¤¹                                               */
 818     /*------------------------------------------------------------------------*/
 819     binstr = apr_psprintf(r->pool, "%s", s_get_mode_spec(qrcode));
 820 #ifdef QR_CODE_DEBUG
 821     DBG(r,"s_get_mode_spec()");
 822 #endif
 823
 824     /*------------------------------------------------------------------------*/
 825     /* Ê¸»ú¿ô»Ø¼¨»Ò¤ò¼èÆÀ¤·¤Þ¤¹                                               */
 826     /*------------------------------------------------------------------------*/
 827     binstr = apr_pstrcat(r->pool, binstr,
 828                   s_get_char_bit_count(qrcode, strlen(qrcode->indata)), NULL);
 829 #ifdef QR_CODE_DEBUG
 830     DBG(r, "s_get_char_bit_count()[%s]", binstr);
 831 #endif
 832
 833     /*------------------------------------------------------------------------*/
 834     /* ¥Ç¡¼¥¿¥³¡¼¥É¿ô¤ò»»½Ð                                                   */
 835     /*------------------------------------------------------------------------*/
 836     data_code_count = v_data_code_count[qrcode->version][qrcode->level];
 837 #ifdef QR_CODE_DEBUG
 838     DBG(r,"data_code_count=[%d]", data_code_count);
 839 #endif
 840
 841     /*------------------------------------------------------------------------*/
 842     /* ¼Â¥Ç¡¼¥¿¤Î£²¿Ê²½                                                       */
 843     /*------------------------------------------------------------------------*/
 844     qrcode->mode_change = QR_NOT_CHANGE;
 845     switch(qrcode->mode) {
 846     case QR_NUM_MODE:
 847       real_data = s_data_to_bin_num(qrcode, data_code_count);
 848       break;
 849
 850     case QR_ALPHA_MODE:
 851       real_data = s_data_to_bin_alpha(qrcode, data_code_count);
 852       break;
 853
 854     case QR_8BIT_MODE:
 855       real_data = s_data_to_bin_8bit(qrcode,data_code_count);
 856       break;
 857
 858     case QR_KANJI_MODE:
 859       real_data = s_data_to_bin_kanji(qrcode,data_code_count);
 860       break;
 861
 862     default:
 863       qrcode->mode = QR_8BIT_MODE;
 864       qrcode->mode_change = QR_CHANGE;
 865       break;
 866     }
 867   }
 868   while(qrcode->mode_change == QR_CHANGE);
 869
 870   /*--------------------------------------------------------------------------*/
 871   /* ½ªÃ¼¥Ñ¥¿¡¼¥ó¤ÎÉÕ²Ã                                                       */
 872   /*--------------------------------------------------------------------------*/
 873   binstr = apr_pstrcat(r->pool, binstr, real_data, NULL);
 874 #ifdef QR_CODE_DEBUG
 875   DBG(r,"Before TERM BIT[%s]", binstr);
 876 #endif
 877   if ((size_t)(data_code_count * 8) > strlen(binstr)) {
 878     int binstr_len = strlen(binstr);
 879     for (ii=0; ii< (data_code_count * 8) - binstr_len && ii < 4; ii++) {
 880       binstr = apr_pstrcat(r->pool, binstr, "0", NULL);
 881     }
 882   }
 883 #ifdef QR_CODE_DEBUG
 884   DBG(r, "After TERM BIT[%s] len[%d]bit [%f]byte", binstr, strlen(binstr), (float)(((float)strlen(binstr))/8.0));
 885   DBG(r,"add term data");
 886 #endif
 887
 888   /*--------------------------------------------------------------------------*/
 889   /* 8bitÃ±°Ì¤Ë¤½¤í¤¨¤ë                                                       */
 890   /*--------------------------------------------------------------------------*/
 891   binstr = s_tidy_8bit_code(qrcode, binstr, data_code_count);
 892 #ifdef QR_CODE_DEBUG
 893   DBG(r,"After Tidy 8 BIT[%s]", binstr);
 894   DBG(r,"s_tidy_8bit_code()");
 895 #endif
 896
 897   /*--------------------------------------------------------------------------*/
 898   /* Ê¸»úÎó¤ò¥Ð¥¤¥Ê¥ê¤Ø                                                       */
 899   /*--------------------------------------------------------------------------*/
 900   decstr = s_str_to_bin(qrcode, binstr, data_code_count);
 901 #ifdef QR_CODE_DEBUG
 902   DBG(r,"s_str_to_bin()");
 903 #endif
 904
 905 #ifdef QR_CODE_DEBUG
 906   /*--------------------------------------------------------------------------*/
 907   /* DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG  */
 908   /*--------------------------------------------------------------------------*/
 909   do {
 910     char* rows = apr_psprintf(r->pool, " ");
 911     for (ii=0; ii<data_code_count; ii++) {
 912       rows = apr_pstrcat(r->pool, rows, apr_psprintf(r->pool, "[%02x]\n", (unsigned char)decstr[ii]), NULL);
 913     }
 914     DBG(r,"decstr[%s]", rows);
 915   }while(0);
 916 #endif
 917
 918
 919   /*--------------------------------------------------------------------------*/
 920   /* ECC¤ÎÄÉ²Ã                                                                */
 921   /* ½ÐÎÏ¤È¤·¤Æ¤Îeccstr¤Ï¡¢¥¤¥ó¥¿¥ê¡¼¥ÖºÑ¤ß¤Î¥Ç¡¼¥¿¤¬¥»¥Ã¥È¤µ¤ì¤Þ¤¹.          */
 922   /*--------------------------------------------------------------------------*/
 923   eccstr = apr_palloc(r->pool, module_count* module_count);
 924   data_total_count = chxj_calc_ecc(qrcode, (unsigned char*)decstr, eccstr);
 925 #ifdef QR_CODE_DEBUG
 926   DBG(r,"chxj_calc_ecc() total_count[%d]", data_total_count);
 927 #endif
 928
 929   /*--------------------------------------------------------------------------*/
 930   /* ºÇÅ¬¤Î¥Þ¥¹¥¯¤ò¼èÆÀ¤¹¤ë                                                   */
 931   /* Á´¤Æ¤Î¥Ñ¥¿¡¼¥ó¤ò»î¤·¡¢ºÇ¤â¼ºÅÀ¤Î¾¯¤Ê¤¤¥Þ¥¹¥¯¤òÁªÂò¤·¤Þ¤¹                 */
 932   /*--------------------------------------------------------------------------*/
 933   min_lost_point = -1;
 934   min_mask_pattern = -1;
 935   for (ii=0; ii<8; ii++) {
 936     int lost_point;
 937     s_init_modules(qrcode, ii, module);
 938     s_map_data(qrcode,  module, (unsigned char*)eccstr, data_total_count, ii);
 939     lost_point = s_calc_lost_point(qrcode, module);
 940
 941     if (min_mask_pattern == -1) {
 942       min_mask_pattern = ii;
 943       min_lost_point   = lost_point;
 944     }
 945     else {
 946       if (min_lost_point >= lost_point) {
 947         min_mask_pattern = ii;
 948         min_lost_point   = lost_point;
 949       }
 950     }
 951   }
 952
 953   /*--------------------------------------------------------------------------*/
 954   /* ºÇÅ¬¥Þ¥¹¥¯¤ÇºÆÅÙºî¤ê¤Ê¤ª¤·                                               */
 955   /*--------------------------------------------------------------------------*/
 956 #ifdef QR_CODE_DEBUG
 957   DBG(r, "selected mask[%d]", min_mask_pattern);
 958 #endif
 959
 960   s_init_modules(qrcode, min_mask_pattern, module);
 961   s_map_data(qrcode,
 962              module,
 963              (unsigned char*)eccstr,
 964              data_total_count,
 965              min_mask_pattern);
 966
 967
 968 #ifdef QR_CODE_DEBUG
 969   /*--------------------------------------------------------------------------*/
 970   /* DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG  */
 971   /*--------------------------------------------------------------------------*/
 972   do {
 973     int xx, yy;
 974     int module_count = v_module_count_table[qrcode->version];
 975     DBG(r,"loop to [%d]", module_count);
 976     for (yy=0; yy<module_count; yy++) {
 977       char *rows ;
 978
 979       rows = apr_psprintf(r->pool, " ");
 980
 981       for (xx=0; xx<module_count; xx++)
 982         rows = apr_pstrcat(r->pool, rows, "[", apr_psprintf(r->pool, "%c", module[yy][xx]), "]", NULL);
 983
 984       DBG(r,"%d:%s", yy,rows);
 985     }
 986   } while(0);
 987   /* DEBUG END */
 988 #endif
 989
 990 #ifdef QR_CODE_DEBUG
 991   DBG(r,"end chxj_qr_code()");
 992 #endif
 993 }
 994
 995 void
 996 chxj_qrcode_node_to_qrcode(qr_code_t *qrcode, Node *node)
 997 {
 998   request_rec  *r;
 999   Doc          *doc;
1000   Node         *child;
1001
1002   r   = qrcode->r;
1003   doc = qrcode->doc;
1004
1005   for (child = qs_get_child_node(doc,node);
1006        child ;
1007        child = qs_get_next_node(doc,child)) {
1008     char *name = qs_get_node_name(doc,child);
1009
1010     if (strcasecmp("qrcode",name) == 0) {
1011
1012       qrcode->found       = QR_FOUND;
1013       qrcode->mode_change = QR_NOT_CHANGE;
1014       qrcode->version     = QR_VER_5;
1015       qrcode->level       = QR_LEVEL_L;
1016       qrcode->mode        = QR_8BIT_MODE;
1017       qrcode->size        = 0;
1018       qrcode->indata      = NULL;
1019       chxj_qrcode_node_to_qrcode(qrcode, child);
1020     }
1021     else
1022     if (strcasecmp("version", name) == 0) {
1023       int   ver;
1024       Node  *cchild;
1025       char  *value;
1026
1027       cchild = qs_get_child_node(doc, child);
1028
1029       if (cchild == NULL) {
1030         qrcode->version = QR_VER_1;
1031         continue;
1032       }
1033
1034       name = qs_get_node_name(doc, cchild);
1035       value = qs_get_node_value(doc, cchild);
1036       if (strcasecmp("TEXT", name) != 0) {
1037         qrcode->version = QR_VER_1;
1038         continue;
1039       }
1040       if (value == NULL || strlen(value) == 0) {
1041         qrcode->version = QR_VER_1;
1042         continue;
1043       }
1044
1045       if (chxj_chk_numeric(value)) {
1046         qrcode->version = QR_VER_1;
1047         continue;
1048       }
1049       ver = chxj_atoi(value);
1050       if (ver <= 0 || ver > 40) {
1051         qrcode->version = QR_VER_1;
1052         continue;
1053       }
1054
1055       qrcode->version = ver - 1;
1056     }
1057     else
1058     if (strcasecmp("level", name) == 0) {
1059       Node *cchild = qs_get_child_node(doc, child);
1060       char *value;
1061       if (cchild == NULL) {
1062         qrcode->level = QR_LEVEL_L;
1063         continue;
1064       }
1065       name  = qs_get_node_name(doc, cchild);
1066       value = qs_get_node_value(doc, cchild);
1067       if (strcasecmp("TEXT", name) != 0) {
1068         qrcode->level = QR_LEVEL_L;
1069         continue;
1070       }
1071
1072       if (value == NULL || strlen(value) == 0) {
1073         qrcode->level = QR_LEVEL_L;
1074         continue;
1075       }
1076
1077       if (strcasecmp("L", value) == 0) {
1078         qrcode->level = QR_LEVEL_L;
1079       }
1080       else
1081       if (strcasecmp("M", value) == 0) {
1082         qrcode->level = QR_LEVEL_M;
1083       }
1084       else
1085       if (strcasecmp("Q", value) == 0) {
1086         qrcode->level = QR_LEVEL_Q;
1087       }
1088       else
1089       if (strcasecmp("H", value) == 0) {
1090         qrcode->level = QR_LEVEL_H;
1091       }
1092       else
1093       {
1094         qrcode->level = QR_LEVEL_L;
1095       }
1096     }
1097     else
1098     if (strcasecmp("mode", name) == 0)
1099     {
1100       Node *cchild = qs_get_child_node(doc, child);
1101       char *value;
1102       if (cchild == NULL)
1103       {
1104         qrcode->mode = QR_NUM_MODE;
1105         continue;
1106       }
1107       name = qs_get_node_name(doc, cchild);
1108       value = qs_get_node_value(doc, cchild);
1109       if (strcasecmp("TEXT", name) != 0)
1110       {
1111         qrcode->level = QR_NUM_MODE;
1112         continue;
1113       }
1114       if (value == NULL || strlen(value) == 0)
1115       {
1116         qrcode->level = QR_NUM_MODE;
1117         continue;
1118       }
1119
1120       /*----------------------------------------------------------------------*/
1121       /* ¿ô»ú¥â¡¼¥É                                                           */
1122       /*----------------------------------------------------------------------*/
1123       if (strcasecmp("NUM", value) == 0)
1124       {
1125         qrcode->mode    = QR_NUM_MODE;
1126       }
1127       else
1128       /*----------------------------------------------------------------------*/
1129       /* ±Ñ¿ô»ú¥â¡¼¥É                                                         */
1130       /*----------------------------------------------------------------------*/
1131       if (strcasecmp("ALPHA", value) == 0)
1132       {
1133         qrcode->mode    = QR_ALPHA_MODE;
1134       }
1135       else
1136       /*----------------------------------------------------------------------*/
1137       /* 8¥Ó¥Ã¥È¥Ð¥¤¥È¥â¡¼¥É                                                  */
1138       /*----------------------------------------------------------------------*/
1139       if (strcasecmp("8BIT", value) == 0)
1140       {
1141         qrcode->mode    = QR_8BIT_MODE;
1142       }
1143       else
1144       /*----------------------------------------------------------------------*/
1145       /* ´Á»ú¥â¡¼¥É                                                           */
1146       /*----------------------------------------------------------------------*/
1147       if (strcasecmp("KANJI", value) == 0)
1148       {
1149         qrcode->mode    = QR_KANJI_MODE;
1150       }
1151       else
1152       {
1153         qrcode->mode    = QR_NUM_MODE;
1154       }
1155     }
1156     else
1157     if (strcasecmp("data", name) == 0)
1158     {
1159       /* TODO: ²þ¹Ô¤â²ÄÇ½¤Ê¤è¤¦¤Ë½¤Àµ¤¹¤ë */
1160       Node *cchild = qs_get_child_node(doc, child);
1161       char *value;
1162
1163       qrcode->indata = apr_palloc(r->pool, 1);
1164       qrcode->indata[0] = 0;
1165       if (cchild == NULL)
1166       {
1167         continue;
1168       }
1169       for (;cchild; cchild = cchild->next)
1170       {
1171         name = qs_get_node_name(doc, cchild);
1172         value = qs_get_node_value(doc, cchild);
1173         if (strcasecmp("TEXT", name) != 0)
1174         {
1175           continue;
1176         }
1177         if (strlen(qrcode->indata) > 0)
1178         {
1179           qrcode->indata = apr_pstrcat(r->pool, qrcode->indata, "\r\n", NULL);
1180         }
1181         qrcode->indata = apr_pstrcat(r->pool, qrcode->indata, value, NULL);
1182       }
1183     }
1184     else
1185     if (strcasecmp("size", name) == 0)
1186     {
1187       int size;
1188       char *value;
1189       Node *cchild = qs_get_child_node(doc, child);
1190
1191       if (cchild == NULL)
1192       {
1193         qrcode->size = 0;
1194         continue;
1195       }
1196       name = qs_get_node_name(doc, cchild);
1197       value = qs_get_node_value(doc, cchild);
1198       if (strcasecmp("TEXT", name) != 0)
1199       {
1200         qrcode->size = 0;
1201         continue;
1202       }
1203       if (value == NULL || strlen(value) == 0)
1204       {
1205         qrcode->size = 0;
1206         continue;
1207       }
1208       if (chxj_chk_numeric(value))
1209       {
1210         qrcode->size = 0;
1211         continue;
1212       }
1213
1214       size = chxj_atoi(value);
1215       if (size <= 0)
1216       {
1217         qrcode->size = 0;
1218         continue;
1219       }
1220       if (size > 20)
1221       {
1222         qrcode->size = 20;
1223         continue;
1224       }
1225       qrcode->size = size;
1226     }
1227   }
1228 #ifdef QR_CODE_DEBUG
1229   DBG(r,"qrcode->version[%d]", qrcode->version);
1230   DBG(r,"qrcode->level[%d]", qrcode->level);
1231   DBG(r,"qrcode->mode[%d]", qrcode->mode);
1232   DBG(r,"qrcode->indata[%s]", qrcode->indata);
1233 #endif
1234 }
1235
1236
1237 /**
1238  * ¥â¡¼¥É»Ø¼¨»Ò¤ò¼èÆÀ¤·¤Þ¤¹.
1239  */
1240 static char *
1241 s_get_mode_spec(qr_code_t *qrcode)
1242 {
1243   char *result = (char*)apr_palloc(qrcode->r->pool, 4+1);
1244
1245   memset(result, 0, 5);
1246   memcpy(result, v_mode_table[qrcode->mode], 4);
1247 #ifdef QR_CODE_DEBUG
1248   DBG(r,"Mode Spec[%s]", result);
1249 #endif
1250
1251   return result;
1252 }
1253
1254
1255 /**
1256  * Ê¸»ú¿ô»Ø¼¨»Ò¤ò¼èÆÀ¤·¤Þ¤¹.
1257  */
1258 static char *
1259 s_get_char_bit_count(qr_code_t *qrcode, int len)
1260 {
1261   int bit_count = v_char_count_table[qrcode->version][qrcode->mode];
1262   int ii,jj;
1263   char *tmp;
1264   char *result;
1265   int data_capacity   = v_capacity_table[qrcode->version*4+qrcode->level].size[qrcode->mode];
1266
1267   DBG(qrcode->r, "len [%d]", len);
1268   if (qrcode->mode == QR_KANJI_MODE && data_capacity * 2 < len) {
1269     len = data_capacity * 2;
1270   }
1271   else
1272   if (qrcode->mode != QR_KANJI_MODE && data_capacity < len) {
1273     len = data_capacity;
1274   }
1275
1276   if (qrcode->mode == QR_KANJI_MODE) {
1277     len /= 2;
1278   }
1279
1280   DBG(qrcode->r, "len [%d]", len);
1281
1282   tmp = (char *)apr_palloc(qrcode->r->pool, bit_count + 1);
1283   for (ii=0; ii<bit_count; ii++) {
1284     tmp[ii] = (len & 0x01) ? '1' : '0';
1285     len = len >> 1;
1286   }
1287
1288   tmp[bit_count] = '\0';
1289
1290   result = (char *)apr_palloc(qrcode->r->pool, bit_count+1);
1291   for (jj=0,ii=bit_count-1; ii>=0 && jj < bit_count; ii--, jj++) {
1292     result[ii] = tmp[jj];
1293   }
1294
1295   result[bit_count] = '\0';
1296
1297 #ifdef QR_CODE_DEBUG
1298   DBG(qrcode->r, "Character Count bit [%s]", result);
1299 #endif
1300
1301   return result;
1302 }
1303
1304 /**
1305  * ¿ô»ú¥â¡¼¥É
1306  * ÆþÎÏ¥Ç¡¼¥¿¤«¤é¡¢£²¿ÊÊ¸»úÎó¤ò¼èÆÀ¤·¤Þ¤¹.
1307  */
1308 static char *
1309 s_data_to_bin_num(qr_code_t *qrcode, int UNUSED(data_code_count))
1310 {
1311   int len = strlen(qrcode->indata);
1312   int setn;
1313   int modn;
1314   int ii;
1315   int jj;
1316   int kk;
1317   char  *result;
1318   char  tmp[4];
1319   char  tmp_bit[11];
1320   int data_capacity   = v_capacity_table[qrcode->version*4+qrcode->level].size[qrcode->mode];
1321
1322   if (data_capacity < len) {
1323     DBG(qrcode->r, "input data is too long");
1324     len = data_capacity;
1325   }
1326   setn = len / 3;
1327   modn = len % 3;
1328
1329   if (chxj_chk_numeric(qrcode->indata) != 0) {
1330     qrcode->mode_change = QR_CHANGE;
1331     qrcode->mode        = QR_8BIT_MODE;
1332     return NULL;
1333   }
1334
1335   result = (char*)apr_palloc(qrcode->r->pool, setn*10 + ((modn == 1) ? 4 : (modn == 2) ? 7 : 0) + 1);
1336   kk = 0;
1337   for (ii=0; ii<len; ii++) {
1338     tmp[ii % 3] = qrcode->indata[ii];
1339     if ((ii % 3) == 2) {
1340       tmp[4] = 0;
1341       int n = atoi(tmp);
1342       for (jj=0; jj<10; jj++) {
1343         tmp_bit[jj] = (n & 0x01) ?  '1'  : '0';
1344         n = n >> 1;
1345       }
1346       tmp_bit[10] = 0;
1347       for (jj=10-1; jj>=0; jj--) {
1348         result[kk++] = tmp_bit[jj];
1349       }
1350     }
1351   }
1352
1353   if (modn != 0) {
1354     tmp[modn] = 0;
1355     int n = atoi(tmp);
1356     int bb = (modn == 1) ? 4 : 7;
1357
1358     for (jj=0; jj< bb; jj++) {
1359       tmp_bit[jj] = (n & 0x01) ?  '1'  : '0';
1360       n = n >> 1;
1361     }
1362
1363     tmp_bit[(modn == 1) ? 4 : 7] = 0;
1364
1365     for (jj=bb -1; jj>=0; jj--) {
1366       result[kk++] = tmp_bit[jj];
1367     }
1368   }
1369   result[kk] = 0;
1370   return result;
1371 }
1372
1373
1374 /**
1375  * ±Ñ¿ô»ú¥â¡¼¥É
1376  * ÆþÎÏ¥Ç¡¼¥¿¤«¤é¡¢£²¿ÊÊ¸»úÎó¤ò¼èÆÀ¤·¤Þ¤¹.
1377  */
1378 static char *
1379 s_data_to_bin_alpha(qr_code_t *qrcode, int UNUSED(data_code_count))
1380 {
1381   int len = strlen(qrcode->indata);
1382   int setn;
1383   int modn;
1384   int ii;
1385   int jj;
1386   int kk;
1387   char  *result;
1388   char  tmp[2+1];
1389   char  tmp_bit[11+1];
1390   int data_capacity   = v_capacity_table[qrcode->version*4+qrcode->level].size[qrcode->mode];
1391
1392   if (data_capacity < len) {
1393     DBG(qrcode->r, "input data is too long");
1394     len = data_capacity;
1395   }
1396   setn = len / 2;
1397   modn = len % 2;
1398
1399   result = (char *)apr_palloc(qrcode->r->pool, setn*11 + ((modn == 1) ? 6 : 0) + 1);
1400
1401   kk = 0;
1402   for (ii=0; ii<len; ii++) {
1403     tmp[ii % 2] = qrcode->indata[ii];
1404     if ((ii % 2) == 1) {
1405       tmp[3] = 0;
1406       int n = s_char_to_num_alpha(qrcode,tmp[0])*45;
1407
1408       if (qrcode->mode_change == QR_CHANGE)
1409         return NULL;
1410
1411       n += s_char_to_num_alpha(qrcode,tmp[1]);
1412       if (qrcode->mode_change == QR_CHANGE)
1413         return NULL;
1414
1415       for (jj=0; jj<11; jj++) {
1416         tmp_bit[jj] = (n & 0x01) ?  '1'  : '0';
1417         n = n >> 1;
1418       }
1419
1420       tmp_bit[11] = 0;
1421
1422       for (jj=11-1; jj>=0; jj--)
1423         result[kk++] = tmp_bit[jj];
1424     }
1425   }
1426
1427   if (modn) {
1428
1429     tmp[modn] = 0;
1430     int n = s_char_to_num_alpha(qrcode,tmp[0]);
1431
1432     if (qrcode->mode_change == QR_CHANGE)
1433       return NULL;
1434
1435     for (jj=0; jj< 6; jj++) {
1436       tmp_bit[jj] = (n & 0x01) ?  '1'  : '0';
1437       n = n >> 1;
1438     }
1439
1440     tmp_bit[6] = 0;
1441
1442     for (jj=6-1; jj>=0; jj--)
1443       result[kk++] = tmp_bit[jj];
1444   }
1445   result[kk] = 0;
1446   return result;
1447 }
1448
1449
1450 /**
1451  * ±Ñ¿ô»ú¥â¡¼¥É¤ÎÊä½õ´Ø¿ô.
1452  * ±Ñ¿ô»ú¤«¤é¡¢¿ôÃÍ¤ËÊÑ´¹¤·¤Þ¤¹.
1453  */
1454 static int
1455 s_char_to_num_alpha(qr_code_t *qrcode, char src)
1456 {
1457   switch(src) {
1458   case '0': return 0;
1459   case '1': return 1;
1460   case '2': return 2;
1461   case '3': return 3;
1462   case '4': return 4;
1463   case '5': return 5;
1464   case '6': return 6;
1465   case '7': return 7;
1466   case '8': return 8;
1467   case '9': return 9;
1468   case 'A': return 10;
1469   case 'B': return 11;
1470   case 'C': return 12;
1471   case 'D': return 13;
1472   case 'E': return 14;
1473   case 'F': return 15;
1474   case 'G': return 16;
1475   case 'H': return 17;
1476   case 'I': return 18;
1477   case 'J': return 19;
1478   case 'K': return 20;
1479   case 'L': return 21;
1480   case 'M': return 22;
1481   case 'N': return 23;
1482   case 'O': return 24;
1483   case 'P': return 25;
1484   case 'Q': return 26;
1485   case 'R': return 27;
1486   case 'S': return 28;
1487   case 'T': return 29;
1488   case 'U': return 30;
1489   case 'V': return 31;
1490   case 'W': return 32;
1491   case 'X': return 33;
1492   case 'Y': return 34;
1493   case 'Z': return 35;
1494   case ' ':
1495     return 36;
1496   case '$':
1497     return 37;
1498   case '%':
1499     return 38;
1500   case '*':
1501     return 39;
1502   case '+':
1503     return 40;
1504   case '-':
1505     return 41;
1506   case '.':
1507     return 42;
1508   case '/':
1509     return 43;
1510   case ':':
1511     return 44;
1512   default:
1513     qrcode->mode_change = QR_CHANGE;
1514     qrcode->mode = QR_8BIT_MODE;
1515     return -1;
1516   }
1517 }
1518
1519 /**
1520  * 8bit¥Ð¥¤¥È¥â¡¼¥É
1521  * ÆþÎÏ¥Ç¡¼¥¿¤«¤é£²¿ÊÊ¸»úÎó¤ò¼èÆÀ¤·¤Þ¤¹.
1522  */
1523 static char *
1524 s_data_to_bin_8bit(qr_code_t *qrcode, int UNUSED(data_code_count))
1525 {
1526   int len = strlen(qrcode->indata);
1527   int ii;
1528   int jj;
1529   int kk;
1530   char  *result;
1531   char  tmp_bit[8+1];
1532   int data_capacity   = v_capacity_table[qrcode->version*4+qrcode->level].size[qrcode->mode];
1533
1534   if (data_capacity < len) {
1535     DBG(qrcode->r, "input data is too long");
1536     len = data_capacity;
1537   }
1538
1539   result = (char*)apr_palloc(qrcode->r->pool, len*8 + 1);
1540
1541   kk = 0;
1542   for (ii=0; ii<len; ii++) {
1543     int n;
1544
1545     n = (int)qrcode->indata[ii];
1546     for (jj=0; jj<8; jj++) {
1547       tmp_bit[jj] = (n & 0x01) ? '1' : '0';
1548       n = n >> 1;
1549     }
1550
1551     tmp_bit[8] = 0;
1552
1553     for (jj=8-1; jj>=0; jj--)
1554       result[kk++] = tmp_bit[jj];
1555   }
1556   result[kk] = 0;
1557
1558 #ifdef QR_CODE_DEBUG
1559   DBG(qrcode->r, "input data --> 2bin result[%s] len:[%d]", result, strlen(result));
1560 #endif
1561
1562   return result;
1563 }
1564
1565 /**
1566  * Kanji mode.
1567  * A binary character string is acquired from input data.
1568  */
1569 static char *
1570 s_data_to_bin_kanji(qr_code_t *qrcode, int UNUSED(data_code_count))
1571 {
1572   int len = strlen(qrcode->indata);
1573   int ii;
1574   int jj;
1575   int kk;
1576   char  *result;
1577   char  tmp_bit[13+1];
1578
1579   int data_capacity   = v_capacity_table[qrcode->version*4+qrcode->level].size[qrcode->mode];
1580
1581   if (data_capacity * 2 < len) {
1582     DBG(qrcode->r, "input data is too long");
1583     len = data_capacity * 2;
1584   }
1585
1586   if ((len % 2) != 0) {
1587     DBG(qrcode->r, "invalid data.");
1588     qrcode->mode_change = QR_CHANGE;
1589     qrcode->mode        = QR_8BIT_MODE;
1590     return NULL;
1591   }
1592
1593   result = (char*)apr_palloc(qrcode->r->pool, (len/2)*13 + 1);
1594   for (kk=0,ii=0; ii<len-1; ii++) {
1595     int c;
1596     int up_c;
1597     int dn_c;
1598     c = (qrcode->indata[ii+0] & 0xff)<< 8;
1599     c +=(qrcode->indata[ii+1] & 0xff);
1600
1601     if (c >= 0x8140 && c <= 0x9FFC) {
1602       c -= 0x8140;
1603       up_c = ((c >> 8) & 0xff) * 0xC0;
1604       dn_c = ( c       & 0xff);
1605       c  = up_c;
1606       c += dn_c;
1607     }
1608     else
1609     if (c >= 0xE040 && c <= 0xEBBF) {
1610       c -= 0xC140;
1611       up_c = ((c >> 8) & 0xff) * 0xC0;
1612       dn_c = ( c       & 0xff);
1613       c  = up_c;
1614       c += dn_c;
1615     }
1616     else {
1617       qrcode->mode_change = QR_CHANGE;
1618       qrcode->mode        = QR_8BIT_MODE;
1619       return NULL;
1620     }
1621
1622     memset(tmp_bit, 0, 13+1);
1623     for (jj=0; jj<13; jj++) {
1624       tmp_bit[jj] = (c & 0x01) ? '1' : '0';
1625       c = c >> 1;
1626     }
1627
1628     tmp_bit[13] = 0;
1629     for (jj=13-1; jj>=0; jj--)
1630       result[kk++] = tmp_bit[jj];
1631
1632     ii++;
1633   }
1634   result[kk] = 0;
1635
1636 #ifdef QR_CODE_DEBUG
1637   DBG(qrcode->r, "input data --> 2bin result[%s] len:[%d]", result, strlen(result));
1638 #endif
1639
1640   return result;
1641 }
1642
1643 /**
1644  * 8bitÄ¹¤Ë¤¢¤ï¤»¤Þ¤¹
1645  */
1646 static char *
1647 s_tidy_8bit_code(qr_code_t *qrcode, const char *indata, int data_code_count)
1648 {
1649   int len = strlen(indata);
1650   int ii;
1651   int n;
1652   int rest;
1653   char *tmp = NULL;
1654   char *result;
1655
1656 #ifdef QR_CODE_DEBUG
1657   DBG(qrcode->r, "len[%d] data_code_count * 8 [%d]", len, data_code_count * 8);
1658 #endif
1659
1660   assert (len <= data_code_count * 8);
1661   /* 8bit¤Ç³ä¤ì¤Ê¤¤¾ì¹ç¤Ï¡¢»Ä¤ê¤ò£°Ëä¤á¤·¡¢8¤Ç³ä¤ì¤ë¤è¤¦¤Ë¤¹¤ë */
1662   if (len % 8) {
1663     n = 8 - (len % 8);
1664     assert (len + n <= data_code_count * 8);
1665
1666     tmp = (char*)apr_palloc(qrcode->r->pool, n);
1667     for (ii=0; ii<n; ii++)
1668       tmp[ii] = '0';
1669
1670     tmp[ii] = 0;
1671   }
1672
1673   result = (char*)apr_palloc(qrcode->r->pool, data_code_count * 8 + 1);
1674   memset(result, 0, data_code_count * 8+ 1);
1675   memcpy(result, indata, len);
1676   if (len % 8)
1677     memcpy(&result[len], tmp, strlen(tmp));
1678
1679   len = strlen(result);
1680   rest = data_code_count - (len / 8);
1681   n = 0;
1682   while(rest>0) {
1683     for (ii=0; ii<8; ii++)
1684       result[len++] = v_pend_bit[n][ii];
1685
1686     n = (n == 0) ? 1 : 0;
1687     rest--;
1688   }
1689
1690 #ifdef QR_CODE_DEBUG
1691   DBG(qrcode->r, "tidy len[%d] data_code_count[%d]", strlen(result)/8, data_code_count);
1692 #endif
1693
1694   return result;
1695 }
1696
1697 /**
1698  * £²¿ÊÊ¸»úÎó¤ò¥Ð¥¤¥Ê¥ê¤ËÊÑ´¹¤·¤Þ¤¹.
1699  */
1700 static char *
1701 s_str_to_bin(qr_code_t *qrcode, char *indata, int data_code_count)
1702 {
1703   char *result;
1704   int pos;
1705   int len ;
1706   int ii;
1707
1708   len = strlen(indata);
1709   result = (char *)apr_palloc(qrcode->r->pool, data_code_count);
1710   memset(result, 0, data_code_count);
1711
1712   pos = 0;
1713   for (ii=0; ii<len; ii++) {
1714     result[pos] = (result[pos] << 1) | (indata[ii] - '0');
1715     if ((ii % 8) == 7)
1716       pos ++;
1717   }
1718   return result;
1719 }
1720
1721 /**
1722  * ½ÐÎÏÎÎ°è¤ò½é´ü²½¤·¤Þ¤¹.
1723  * °ÌÃÖ¸¡½Ð¥Ñ¥¿¡¼¥ó¡¢°ÌÃÖ¤¢¤ï¤»¡¢¥¿¥¤¥ß¥ó¥°¡¢·Á¼°¾ðÊó¤òÀßÄê¤·¡¢
1724  * ¤½¤Î¤Û¤«¤Î¾ì½ê¤Ë¤Ï¡¢-1¤òÀßÄê¤·¤Þ¤¹.
1725  */
1726 static void
1727 s_init_modules(qr_code_t *qrcode, qr_mask_pattern_t pat, char *dst[])
1728 {
1729   int module_count = v_module_count_table[qrcode->version];
1730   int yy;
1731
1732 #ifdef QR_CODE_DEBUG
1733   DBG(qrcode->r, "start s_init_modules()");
1734
1735   DBG(qrcode->r, "module_count[%d]", module_count);
1736 #endif
1737
1738   for (yy=0; yy<module_count; yy++)
1739     memset(&dst[yy][0], -1, module_count+1);
1740
1741   s_setup_probe_position(qrcode, dst, 0, 0);
1742   s_setup_probe_position(qrcode, dst, 0, module_count - 7);
1743   s_setup_probe_position(qrcode, dst, module_count - 7, 0);
1744   s_setup_position_adjust(qrcode, dst);
1745   s_setup_timing_pattern(qrcode, dst);
1746   s_setup_type_info(qrcode,dst, pat);
1747   s_setup_version_info(qrcode, dst);
1748
1749 #ifdef QR_CODE_DEBUG
1750   DBG(qrcode->r, "end s_init_modules()");
1751 #endif
1752
1753 }
1754
1755 /*
1756  * °ÌÃÖ¸¡½Ð¥Ñ¥¿¡¼¥ó¤È¤Ä¤¤¤Ç¤ËÊ¬Î¥¥Ñ¥¿¡¼¥ó¤Î½ÐÎÏ
1757  */
1758 static void
1759 s_setup_probe_position(qr_code_t *qrcode, char *dst[], int pos_x, int pos_y)
1760 {
1761   int module_count = v_module_count_table[qrcode->version];
1762   int xx;
1763   int yy;
1764 #ifdef QR_CODE_DEBUG
1765   DBG(qrcode->r, "start s_setup_probe_position()");
1766   DBG(qrcode->r, "module_count[%d]", module_count);
1767 #endif
1768
1769   for (yy=-1; yy<=7; yy++) {
1770     for (xx=-1; xx<=7; xx++) {
1771       /* °ÌÃÖ¸¡½Ð¥Ñ¥¿¡¼¥ó */
1772       if ((yy==0 || yy == 6) && xx != -1 && xx != 7) {
1773         assert(yy+pos_y >= 0 && yy+pos_y < module_count);
1774         assert(xx+pos_x >= 0 && xx+pos_x < module_count);
1775         dst[yy+pos_y][xx+pos_x] = '1';
1776       }
1777       else
1778       if ((xx == 0 && yy != -1 && yy != 7)
1779       ||  (xx >= 2 && xx <= 4 && yy >=2 && yy <= 4)
1780       ||  (xx == 6 && yy != -1 && yy != 7)) {
1781         assert(yy+pos_y >= 0 && yy+pos_y < module_count);
1782         assert(xx+pos_x >= 0 && xx+pos_x < module_count);
1783         dst[yy+pos_y][xx+pos_x] = '1';
1784       }
1785       else {
1786         /* Ê¬Î¥¥Ñ¥¿¡¼¥ó */
1787         if ((yy == 7
1788         &&   yy + pos_y >= 0
1789         &&   yy + pos_y < module_count
1790         &&   xx + pos_x >= 0
1791         &&   xx + pos_x < module_count)
1792         ||  (yy == -1
1793         &&   yy + pos_y >= 0
1794         &&   yy + pos_y < module_count
1795         &&   xx + pos_x >= 0
1796         &&   xx + pos_x < module_count)
1797         ||  (xx == 7
1798         &&   xx + pos_x >= 0
1799         &&   xx + pos_x < module_count
1800         &&   yy + pos_y >= 0
1801         &&   yy + pos_y < module_count)
1802         ||  (xx == -1
1803         &&   xx + pos_x < module_count
1804         &&   xx + pos_x >= 0
1805         &&   yy + pos_y >= 0
1806         &&   yy + pos_y < module_count)) {
1807           assert(yy+pos_y >= 0 && yy+pos_y < module_count);
1808           assert(xx+pos_x >= 0 && xx+pos_x < module_count);
1809           dst[yy+pos_y][xx+pos_x] = '0';
1810         }
1811         else
1812         if (yy != -1 && yy != 7 && xx != -1 && xx != 7) {
1813           assert(yy+pos_y >= 0 && yy+pos_y < module_count);
1814           assert(xx+pos_x >= 0 && xx+pos_x < module_count);
1815           dst[yy+pos_y][xx+pos_x] = '0';
1816         }
1817       }
1818     }
1819   }
1820 #ifdef QR_CODE_DEBUG
1821   DBG(qrcode->r, "end s_setup_probe_position()");
1822 #endif
1823 }
1824 /*
1825  * ¥¿¥¤¥ß¥ó¥°¥Ñ¥¿¡¼¥ó
1826  */
1827 static void
1828 s_setup_timing_pattern(qr_code_t *qrcode, char *dst[])
1829 {
1830   int module_count = v_module_count_table[qrcode->version];
1831   int xx, yy;
1832 #ifdef QR_CODE_DEBUG
1833   DBG(qrcode->r, "start s_setup_timing_pattern()");
1834   DBG(qrcode->r, "module_count[%d]", module_count);
1835 #endif
1836
1837   yy=6;
1838   for (xx=8; xx < module_count-8; xx++) {
1839     if (dst[yy][xx] != -1)
1840       continue;
1841
1842     assert(yy >= 0 && yy < module_count);
1843     assert(xx >= 0 && xx < module_count);
1844
1845     dst[yy][xx] = (xx % 2 == 0) ? '1' : '0';
1846   }
1847
1848   xx=6;
1849   for (yy=8; yy < module_count-8; yy++) {
1850     if (dst[yy][xx] != -1)
1851       continue;
1852
1853     assert(yy >= 0 && yy < module_count);
1854     assert(xx >= 0 && xx < module_count);
1855
1856     dst[yy][xx] = (yy % 2 == 0) ? '1' : '0';
1857   }
1858
1859 #ifdef QR_CODE_DEBUG
1860   DBG(qrcode->r, "start s_setup_timing_pattern()");
1861 #endif
1862 }
1863
1864 /*
1865  * °ÌÃÖ¹ç¤ï¤»¥Ñ¥¿¡¼¥ó
1866  */
1867 static void
1868 s_setup_position_adjust(qr_code_t *qrcode, char *dst[])
1869 {
1870   int module_count = v_module_count_table[qrcode->version];
1871   int *pos_list = v_position_adjust_table[qrcode->version].position;
1872   int xx, yy;
1873   int mxx, myy;
1874   int dxx, dyy;
1875
1876 #ifdef QR_CODE_DEBUG
1877   DBG(qrcode->r, "start s_setup_position_adjust()");
1878 #endif
1879
1880   for (yy=0; yy<7; yy++) {
1881     for (xx=0; xx<7; xx++) {
1882       mxx = pos_list[xx];
1883       myy = pos_list[yy];
1884
1885       if (mxx == 0 || myy == 0)
1886         continue;
1887
1888       if (dst[myy][mxx] != -1)
1889         continue;
1890
1891       for (dyy = -2; dyy <= 2; dyy++) {
1892         for (dxx= -2; dxx <= 2; dxx++) {
1893           if (dyy == -2
1894           ||  dxx == -2
1895           ||  dyy == 2
1896           ||  dxx == 2
1897           ||  (dyy == 0 && dxx == 0)) {
1898             assert(myy+dyy >= 0);
1899             assert(myy+dyy < module_count);
1900             dst[myy+dyy][mxx+dxx] = '1';
1901           }
1902           else {
1903             assert(myy+dyy >= 0);
1904             assert(myy+dyy < module_count);
1905             dst[myy+dyy][mxx+dxx] = '0';
1906           }
1907         }
1908       }
1909     }
1910   }
1911
1912 #ifdef QR_CODE_DEBUG
1913   DBG(qrcode->r, "end s_setup_position_adjust()");
1914 #endif
1915 }
1916
1917 static void
1918 s_setup_type_info(qr_code_t *qrcode, char *dst[], qr_mask_pattern_t pat)
1919 {
1920   int module_count = v_module_count_table[qrcode->version];
1921   int typedata;
1922   int sdata;
1923   int gf;
1924   int gfmask;
1925   int xx;
1926   int yy;
1927
1928 #ifdef QR_CODE_DEBUG
1929   DBG(qrcode->r, "start s_setup_type_info()");
1930   DBG(qrcode->r, "module_count[%d]", module_count);
1931 #endif
1932
1933   /* ·Á¼°¾ðÊó¥Ç¡¼¥¿¤ÎÀ¸À® */
1934   switch(qrcode->level) {
1935   case QR_LEVEL_L: sdata = 0x01 << 3; break;
1936   case QR_LEVEL_M: sdata = 0x00 << 3; break;
1937   case QR_LEVEL_Q: sdata = 0x03 << 3; break;
1938   case QR_LEVEL_H: sdata = 0x02 << 3; break;
1939   default:
1940     sdata = 0;
1941     break;
1942   }
1943   sdata |= pat;
1944
1945   /* G(x)=x10+x8+x5+x4+x2+x+1 */
1946   gf = (0x01 << 10)
1947      | (0x01 << 8)
1948      | (0x01 << 5)
1949      | (0x01 << 4)
1950      | (0x01 << 2)
1951      | (0x01 << 1)
1952      | (0x01 << 0);
1953
1954   gfmask = (0x01 << 14) | (0x01 << 12) | (0x01 << 10)  | (0x01 << 4) | (0x01 << 1);
1955
1956
1957   typedata = sdata << 10;
1958   while (s_get_bit_count(typedata) - s_get_bit_count(gf) >= 0) {
1959     typedata ^= (gf << (s_get_bit_count(typedata) - s_get_bit_count(gf)));
1960   }
1961   typedata = (sdata << 10 | typedata);
1962
1963   typedata ^= gfmask;
1964
1965   for (yy=0; yy<6; yy++) {
1966     assert(yy >= 0 && yy < module_count);
1967     dst[yy][8] = (((typedata >> yy) & 0x01) == 1) ?  '1' : '0';
1968   }
1969
1970   for (; yy<8; yy++) {
1971     assert(yy + 1 >= 0 && yy + 1 < module_count);
1972     dst[yy+1][8] = (((typedata >> yy) & 0x01) == 1) ?  '1' : '0';
1973   }
1974
1975   for (; yy<15; yy++) {
1976     assert(module_count - 15 + yy >= 0 && module_count - 15 + yy < module_count);
1977     dst[module_count - 15 + yy][8] = (((typedata >> yy) & 0x01) == 1) ?  '1' : '0';
1978   }
1979
1980   for (xx = 0; xx < 8; xx++) {
1981     assert(module_count - xx -1 >= 0 && module_count - xx - 1 < module_count);
1982     dst[8][module_count - xx - 1] = (((typedata >> xx) & 0x01) == 1) ? '1' : '0';
1983   }
1984
1985   for (; xx<9; xx++) {
1986     assert(15 - xx >= 0 && 15 - xx < module_count);
1987     dst[8][15 - xx] = (((typedata >> xx) & 0x01) == 1) ? '1' : '0';
1988   }
1989
1990   for (; xx<15; xx++) {
1991     assert(15 - xx - 1 >= 0 && 15 - xx - 1 < module_count);
1992     dst[8][15 - xx - 1] = (((typedata >> xx) & 0x01) == 1) ? '1' : '0';
1993   }
1994
1995   assert(module_count - 8 >= 0 && module_count - 8 < module_count);
1996   dst[module_count - 8][8] = '1';
1997
1998 #ifdef QR_CODE_DEBUG
1999   DBG(qrcode->r, "start s_setup_type_info()");
2000 #endif
2001 }
2002
2003 static int
2004 s_get_bit_count(int data)
2005 {
2006   int count = 0;
2007
2008   while (data != 0) {
2009     count++;
2010     data >>= 1;
2011   }
2012
2013   return count;
2014 }
2015
2016
2017 static void
2018 s_setup_version_info(qr_code_t *qrcode, char *dst[])
2019 {
2020   char *bits = v_version_info_table[qrcode->version].bits;
2021   int module_count = v_module_count_table[qrcode->version];
2022   size_t xx;
2023   size_t yy;
2024
2025   if (bits == NULL) {
2026     /* ¥Ð¡¼¥¸¥ç¥ó£·°Ê¹ß¤Î¤ßÂÐ¾Ý */
2027     return;
2028   }
2029
2030   /* ±¦¾å¤Î·¿ÈÖ¾ðÊó¤ÎÇÛÃÖ */
2031   for (xx=0; xx<strlen(bits); xx++) {
2032     dst[(int)((double)xx/3.0)][(xx % 3) + module_count - 8 - 3] = bits[xx];
2033   }
2034
2035   /* º¸²¼¤Î·¿ÈÖ¾ðÊó¤ÎÇÛÃÖ */
2036   for (yy=0; yy<strlen(bits); yy++) {
2037     dst[(yy % 3) + module_count - 8 - 3][(int)((double)yy/3.0)] = bits[yy];
2038   }
2039 }
2040
2041 static void
2042 s_map_data(qr_code_t     *qrcode,
2043            char          *dst[],
2044            unsigned char *indata, int data_count,qr_mask_pattern_t pat)
2045 {
2046   int module_count = v_module_count_table[qrcode->version];
2047   int inc_yy_flag = -1;
2048
2049   int xx, yy;
2050   int ii;
2051   int in_pos;
2052   int now_bit;
2053   int mask;
2054
2055 #ifdef QR_CODE_DEBUG
2056   DBG(qrcode->r, "start s_map_data()");
2057   DBG(qrcode->r, "module_count[%d]", module_count);
2058   DBG(qrcode->r, "data_count[%d]", data_count);
2059 #endif
2060   in_pos = 0;
2061   now_bit = 7;
2062
2063   yy = module_count - 1;
2064
2065   for (xx = module_count - 1; xx > 0 ; xx -= 2) {
2066     if (xx == 6) {
2067       xx--;
2068     }
2069     do {
2070       for (ii=0; ii < 2; ii++) {
2071         if (dst[yy][xx - ii] != -1)
2072           /* ´û¤ËÇÛÃÖ¤µ¤ì¤Æ¤¤¤ë¾ì¹ç */
2073           continue;
2074
2075         if (in_pos < data_count) {
2076           assert(yy >= 0 && yy < module_count);
2077           assert(xx-ii >= 0 && xx-ii < module_count);
2078
2079           dst[yy][xx-ii] = (((indata[in_pos] >> now_bit) & 0x01) == 1) ? '1' : '0';
2080           mask = s_get_mask(pat, yy, xx - ii);
2081           if (mask == 1) {
2082             if (dst[yy][xx-ii] == '1') {
2083               dst[yy][xx-ii] = '0';
2084             }
2085             else {
2086               dst[yy][xx-ii] = '1';
2087             }
2088           }
2089         }
2090         if (--now_bit < 0) {
2091           in_pos++;
2092           now_bit = 7;
2093         }
2094
2095       }
2096       yy += inc_yy_flag;
2097     } while (yy >= 0 && yy < module_count) ;
2098
2099     yy -= inc_yy_flag;
2100     inc_yy_flag = -inc_yy_flag;
2101   }
2102
2103   /* ??? */
2104   for (yy=0; yy<module_count; yy++) {
2105     for (xx=0; xx<module_count; xx++) {
2106       if (dst[yy][xx] == -1) {
2107         dst[yy][xx] = '0';
2108         mask = s_get_mask(pat, yy, xx);
2109         if (mask == 1) {
2110           dst[yy][xx] = '1';
2111         }
2112       }
2113     }
2114   }
2115 #ifdef QR_CODE_DEBUG
2116   DBG(qrcode->r, "end s_map_data()");
2117 #endif
2118 }
2119
2120 static int
2121 s_get_mask(qr_mask_pattern_t pat, int yy, int xx)
2122 {
2123   switch (pat) {
2124   case QR_MASK_1: return ((yy + xx) % 2 == 0) ? 1 : 0;
2125   case QR_MASK_2: return (yy % 2 == 0) ? 1 : 0;
2126   case QR_MASK_3: return (xx % 3 == 0) ? 1 : 0;
2127   case QR_MASK_4: return ((yy + xx) % 3 == 0) ? 1 : 0;
2128   case QR_MASK_5: return (((yy / 2) + (xx / 3)) % 2 == 0) ? 1 : 0;
2129   case QR_MASK_6: return ((yy * xx) % 2 + (yy * xx) % 3 == 0) ? 1 : 0;
2130   case QR_MASK_7: return (((yy * xx) % 2 + (yy * xx) % 3) % 2 == 0) ? 1 : 0;
2131   case QR_MASK_8: return (((yy * xx) % 3 + (yy + xx) % 2) % 2 == 0) ? 1 : 0;
2132   default:
2133     return 0;
2134   }
2135 }
2136
2137
2138 static int
2139 s_calc_lost_point(qr_code_t *qrcode, char *dst[])
2140 {
2141   int point = 0;
2142
2143   /* Æ±¿§¤Î¹Ô¡¿Îó¤ÎÎÙÀÜ¥â¥¸¥å¡¼¥ë ¥â¥¸¥å¡¼¥ë¿ô=(5+i) 3+i  */
2144   point = s_count_same_module(qrcode->version,dst);
2145
2146   /* Æ±¿§¤Î¥â¥¸¥å¡¼¥ë¥Ö¥í¥Ã¥¯ ¥Ö¥í¥Ã¥¯¥µ¥¤¥º 2¡ß2 3  */
2147   point += s_count_same_block(qrcode->version, dst);
2148
2149   /* ¹Ô¡¿Îó¤Ë¤ª¤±¤ë1:1:3:1:1(°Å:ÌÀ:°Å:ÌÀ:°Å)¤Î¥Ñ¥¿¡¼¥ó */
2150   point += s_count_11311_pattern(qrcode->version, dst);
2151
2152   /* Á´ÂÎ¤ËÀê¤á¤ë°Å¥â¥¸¥å¡¼¥ë¤Î³ä¹ç 50¡Þ(5+k)%¡Á50¡Þ(5+(k+1))% 10¡ßk */
2153   point += s_count_dark_ratio(qrcode->version, dst);
2154
2155   return point;
2156 }
2157
2158 /*
2159  * Æ±¿§¤Î¹Ô¡¿Îó¤ÎÎÙÀÜ¥â¥¸¥å¡¼¥ë ¥â¥¸¥å¡¼¥ë¿ô=(5+i)
2160  * ¼ºÅÀ=3+i
2161  */
2162 static int
2163 s_count_same_module(qr_ver_t ver, char *dst[])
2164 {
2165   int module_count;
2166   int point;
2167   int xx, yy;
2168   int same_count;
2169   int prev_value;
2170
2171   module_count = v_module_count_table[ver];
2172   point        = 0;
2173   same_count   = 0;
2174   prev_value   = -1;
2175
2176   /* ²£Êý¸þ¤Ç¥Á¥§¥Ã¥¯ */
2177   for (yy=0; yy<module_count; yy++) {
2178     prev_value = -1;
2179     same_count = 0;
2180     for (xx=0; xx<module_count; xx++) {
2181       if (prev_value == (unsigned char)dst[yy][xx])
2182         same_count++;
2183       else
2184         same_count = 0;
2185
2186       if (same_count >= 5)
2187         point++;
2188
2189       prev_value = (unsigned char)dst[yy][xx];
2190     }
2191   }
2192
2193   /* ½ÄÊý¸þ¤Ç¥Á¥§¥Ã¥¯ */
2194   for (xx=0; xx<module_count; xx++) {
2195     prev_value = -1;
2196     same_count = 0;
2197
2198     for (yy=0; yy<module_count; yy++) {
2199       if (prev_value == (unsigned char)dst[yy][xx]) {
2200         same_count++;
2201       }
2202       else {
2203         same_count = 0;
2204       }
2205
2206       if (same_count >= 5)
2207         point++;
2208
2209       prev_value = (unsigned char)dst[yy][xx];
2210     }
2211   }
2212
2213   if (point > 0)
2214     point += 3;
2215
2216   return point;
2217 }
2218
2219 /*
2220  * Æ±¿§¤Î¥â¥¸¥å¡¼¥ë¥Ö¥í¥Ã¥¯ ¥Ö¥í¥Ã¥¯¥µ¥¤¥º 2¡ß2
2221  */
2222 static int
2223 s_count_same_block(qr_ver_t ver, char *dst[])
2224 {
2225   int module_count;
2226   int point;
2227   int count;
2228   int xx,yy;
2229
2230   module_count = v_module_count_table[ver];
2231
2232   point = 0;
2233   for (yy = 0; yy < module_count-1; yy++) {
2234     for (xx = 0; xx < module_count-1; xx++) {
2235       count = 0;
2236       if (dst[yy+0][xx+0] == '1') count++;
2237       if (dst[yy+0][xx+1] == '1') count++;
2238       if (dst[yy+1][xx+0] == '1') count++;
2239       if (dst[yy+1][xx+1] == '1') count++;
2240       if (count == 0 || count == 4) {
2241         point += 3;
2242       }
2243     }
2244   }
2245   return point;
2246 }
2247
2248 static int
2249 s_count_11311_pattern(qr_ver_t ver, char *dst[])
2250 {
2251   int module_count;
2252   int point;
2253   int xx,yy;
2254
2255   module_count = v_module_count_table[ver];
2256
2257   point = 0;
2258   /* ²£Êý¸þ¤Î¥Á¥§¥Ã¥¯ */
2259   for (yy = 0; yy < module_count; yy++) {
2260     for (xx = 0; xx < module_count-6; xx++) {
2261       if (dst[yy][xx+0] == '1'
2262       &&  dst[yy][xx+1] == '0'
2263       &&  dst[yy][xx+2] == '1'
2264       &&  dst[yy][xx+3] == '1'
2265       &&  dst[yy][xx+4] == '1'
2266       &&  dst[yy][xx+5] == '0'
2267       &&  dst[yy][xx+6] == '1') {
2268         point += 40;
2269       }
2270     }
2271   }
2272
2273   /* ½ÄÊý¸þ¤Î¥Á¥§¥Ã¥¯ */
2274   for (xx = 0; xx < module_count; xx++) {
2275     for (yy = 0; yy < module_count-6; yy++) {
2276       if (dst[yy+0][xx] == '1'
2277       &&  dst[yy+1][xx] == '0'
2278       &&  dst[yy+2][xx] == '1'
2279       &&  dst[yy+3][xx] == '1'
2280       &&  dst[yy+4][xx] == '1'
2281       &&  dst[yy+5][xx] == '0'
2282       &&  dst[yy+6][xx] == '1') {
2283         point += 40;
2284       }
2285     }
2286   }
2287
2288   return point;
2289 }
2290
2291
2292 /*
2293  * Á´ÂÎ¤ËÀê¤á¤ë°Å¥â¥¸¥å¡¼¥ë¤Î³ä¹ç 50¡Þ(5+k)%¡Á50¡Þ(5+(k+1))%
2294  */
2295 static int
2296 s_count_dark_ratio(qr_ver_t ver, char *dst[])
2297 {
2298   int module_count;
2299   int dark_count;
2300   int xx, yy;
2301   int ratio;
2302   int all_count;
2303
2304   module_count = v_module_count_table[ver];
2305   dark_count   = 0;
2306   all_count    = module_count * module_count;
2307
2308   /* Ã±¤Ë"°Å"¤ò¥«¥¦¥ó¥È¤¹¤ë */
2309   for (yy=0; yy<module_count; yy++) {
2310     for (xx=0; xx < module_count; xx++)
2311       if (dst[yy][xx] == '1')
2312         dark_count++;
2313   }
2314
2315   /* % ¤òµá¤á¡¢50¡ó¤«¤é¤Îº¹¤òµá¤á¤ë¡£ */
2316   ratio = (int)(((double)(dark_count) / (double)all_count)*100.0 - 50.0);
2317   ratio = abs(ratio);
2318
2319   /* 5%Ëè¤Ë10ÅÀ¸ºÅÀ¤Ê¤Î¤Ç¡¢¤Þ¤º5¤Ç³ä¤ë */
2320   ratio = ratio / 5;
2321   return ratio * 10;
2322 }
2323
2324
2325
2326 /*
2327  * vim:ts=2 et
2328  */