src/chxj_qr_code.c

   1 /*
   2  * Copyright (C) 2005-2008 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
 709   magick_wand = NewMagickWand();
 710   black_wand = NewMagickWand();
 711
 712
 713   if (MagickSetSize(magick_wand, 24, 24) == MagickFalse)
 714     goto on_error;
 715
 716   if (MagickSetSize(black_wand, 24, 24) == MagickFalse)
 717     goto on_error;
 718
 719   if (MagickReadImageBlob(magick_wand, v_white_base_pic, sizeof(v_white_base_pic)) == MagickFalse)
 720     goto on_error;
 721
 722   if (MagickReadImageBlob(black_wand, v_black_pixel_pic, sizeof(v_black_pixel_pic)) == MagickFalse)
 723     goto on_error;
 724
 725   if (MagickSetImageUnits(magick_wand, PixelsPerInchResolution) == MagickFalse)
 726     goto on_error;
 727
 728   if (MagickSetImageUnits(black_wand, PixelsPerInchResolution) == MagickFalse)
 729     goto on_error;
 730
 731   if (MagickResizeImage(magick_wand, (module_count)+6, (module_count)+6 , LanczosFilter,0.0) == MagickFalse)
 732     goto on_error;
 733
 734   if (MagickSetImageResolution(magick_wand, 96,96) == MagickFalse)
 735     goto on_error;
 736
 737   if (MagickSetImageResolution(black_wand, 96,96) == MagickFalse)
 738     goto on_error;
 739
 740   if (MagickSetImageType(magick_wand, GrayscaleType) == MagickFalse)
 741     goto on_error;
 742
 743   if (MagickSetImageType(black_wand, GrayscaleType) == MagickFalse)
 744     goto on_error;
 745
 746
 747   for (yy=0; yy<module_count; yy++) {
 748     for (xx=0; xx<module_count; xx++) {
 749       if (module[yy][xx] == '1') {
 750         if (MagickCompositeImage(magick_wand, black_wand, CopyCompositeOp, xx+3,yy+3) == MagickFalse)
 751           goto on_error;
 752       }
 753     }
 754   }
 755
 756   if (qrcode->size <= 0) {
 757     status = MagickResizeImage(magick_wand, ((module_count)*4+6), ((module_count)*4+6) , LanczosFilter,0.0);
 758   }
 759   else {
 760     status = MagickResizeImage(magick_wand,
 761                                (module_count * qrcode->size + 6),
 762                                (module_count * qrcode->size + 6) ,
 763                                LanczosFilter,
 764                                0.0);
 765   }
 766   if (status == MagickFalse)
 767     goto on_error;
 768
 769   if (MagickSetImageFormat(magick_wand,"jpg") == MagickFalse)
 770     goto on_error;
 771
 772 #ifdef QR_CODE_DEBUG
 773   DBG(r,"convert to jpg");
 774 #endif
 775
 776   tmp = (unsigned char*)MagickGetImageBlob(magick_wand,img_len);
 777   *img = apr_palloc(r->pool, *img_len);
 778   memcpy(*img, tmp, *img_len);
 779
 780
 781   DestroyMagickWand(magick_wand);
 782   DestroyMagickWand(black_wand);
 783
 784
 785 #ifdef QR_CODE_DEBUG
 786   DBG(r, "end chxj_qr_code_handler()");
 787 #endif
 788
 789   return OK;
 790
 791 on_error:
 792   EXIT_MAGICK_ERROR();
 793   return HTTP_NOT_FOUND;
 794 }
 795
 796
 797
 798 static void
 799 chxj_qr_code(qr_code_t* qrcode, char* module[])
 800 {
 801   request_rec*      r     = qrcode->doc->r;
 802   unsigned char*    eccstr;
 803   int               ii;
 804   int               data_code_count;
 805   char*             real_data  = NULL;
 806   char*             decstr;
 807   char*             binstr;
 808   int               data_total_count;
 809   int               min_lost_point;
 810   int               min_mask_pattern;
 811   int               module_count = v_module_count_table[qrcode->version];
 812
 813 #ifdef QR_CODE_DEBUG
 814   DBG(r,"start chxj_qr_code()");
 815 #endif
 816   do {
 817     /*------------------------------------------------------------------------*/
 818     /* ¥â¡¼¥É»Ø¼¨»Ò¤ò¼èÆÀ¤·¤Þ¤¹                                               */
 819     /*------------------------------------------------------------------------*/
 820     binstr = apr_psprintf(r->pool, "%s", s_get_mode_spec(qrcode));
 821 #ifdef QR_CODE_DEBUG
 822     DBG(r,"s_get_mode_spec()");
 823 #endif
 824
 825     /*------------------------------------------------------------------------*/
 826     /* Ê¸»ú¿ô»Ø¼¨»Ò¤ò¼èÆÀ¤·¤Þ¤¹                                               */
 827     /*------------------------------------------------------------------------*/
 828     binstr = apr_pstrcat(r->pool, binstr,
 829                   s_get_char_bit_count(qrcode, strlen(qrcode->indata)), NULL);
 830 #ifdef QR_CODE_DEBUG
 831     DBG(r, "s_get_char_bit_count()[%s]", binstr);
 832 #endif
 833
 834     /*------------------------------------------------------------------------*/
 835     /* ¥Ç¡¼¥¿¥³¡¼¥É¿ô¤ò»»½Ð                                                   */
 836     /*------------------------------------------------------------------------*/
 837     data_code_count = v_data_code_count[qrcode->version][qrcode->level];
 838 #ifdef QR_CODE_DEBUG
 839     DBG(r,"data_code_count=[%d]", data_code_count);
 840 #endif
 841
 842     /*------------------------------------------------------------------------*/
 843     /* ¼Â¥Ç¡¼¥¿¤Î£²¿Ê²½                                                       */
 844     /*------------------------------------------------------------------------*/
 845     qrcode->mode_change = QR_NOT_CHANGE;
 846     switch(qrcode->mode) {
 847     case QR_NUM_MODE:
 848       real_data = s_data_to_bin_num(qrcode, data_code_count);
 849       break;
 850
 851     case QR_ALPHA_MODE:
 852       real_data = s_data_to_bin_alpha(qrcode, data_code_count);
 853       break;
 854
 855     case QR_8BIT_MODE:
 856       real_data = s_data_to_bin_8bit(qrcode,data_code_count);
 857       break;
 858
 859     case QR_KANJI_MODE:
 860       real_data = s_data_to_bin_kanji(qrcode,data_code_count);
 861       break;
 862
 863     default:
 864       qrcode->mode = QR_8BIT_MODE;
 865       qrcode->mode_change = QR_CHANGE;
 866       break;
 867     }
 868   }
 869   while(qrcode->mode_change == QR_CHANGE);
 870
 871   /*--------------------------------------------------------------------------*/
 872   /* ½ªÃ¼¥Ñ¥¿¡¼¥ó¤ÎÉÕ²Ã                                                       */
 873   /*--------------------------------------------------------------------------*/
 874   binstr = apr_pstrcat(r->pool, binstr, real_data, NULL);
 875 #ifdef QR_CODE_DEBUG
 876   DBG(r,"Before TERM BIT[%s]", binstr);
 877 #endif
 878   if ((size_t)(data_code_count * 8) > strlen(binstr)) {
 879     int binstr_len = strlen(binstr);
 880     for (ii=0; ii< (data_code_count * 8) - binstr_len && ii < 4; ii++) {
 881       binstr = apr_pstrcat(r->pool, binstr, "0", NULL);
 882     }
 883   }
 884 #ifdef QR_CODE_DEBUG
 885   DBG(r, "After TERM BIT[%s] len[%d]bit [%f]byte", binstr, strlen(binstr), (float)(((float)strlen(binstr))/8.0));
 886   DBG(r,"add term data");
 887 #endif
 888
 889   /*--------------------------------------------------------------------------*/
 890   /* 8bitÃ±°Ì¤Ë¤½¤í¤¨¤ë                                                       */
 891   /*--------------------------------------------------------------------------*/
 892   binstr = s_tidy_8bit_code(qrcode, binstr, data_code_count);
 893 #ifdef QR_CODE_DEBUG
 894   DBG(r,"After Tidy 8 BIT[%s]", binstr);
 895   DBG(r,"s_tidy_8bit_code()");
 896 #endif
 897
 898   /*--------------------------------------------------------------------------*/
 899   /* Ê¸»úÎó¤ò¥Ð¥¤¥Ê¥ê¤Ø                                                       */
 900   /*--------------------------------------------------------------------------*/
 901   decstr = s_str_to_bin(qrcode, binstr, data_code_count);
 902 #ifdef QR_CODE_DEBUG
 903   DBG(r,"s_str_to_bin()");
 904 #endif
 905
 906 #ifdef QR_CODE_DEBUG
 907   /*--------------------------------------------------------------------------*/
 908   /* DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG  */
 909   /*--------------------------------------------------------------------------*/
 910   do {
 911     char* rows = apr_psprintf(r->pool, " ");
 912     for (ii=0; ii<data_code_count; ii++) {
 913       rows = apr_pstrcat(r->pool, rows, apr_psprintf(r->pool, "[%02x]\n", (unsigned char)decstr[ii]), NULL);
 914     }
 915     DBG(r,"decstr[%s]", rows);
 916   }while(0);
 917 #endif
 918
 919
 920   /*--------------------------------------------------------------------------*/
 921   /* ECC¤ÎÄÉ²Ã                                                                */
 922   /* ½ÐÎÏ¤È¤·¤Æ¤Îeccstr¤Ï¡¢¥¤¥ó¥¿¥ê¡¼¥ÖºÑ¤ß¤Î¥Ç¡¼¥¿¤¬¥»¥Ã¥È¤µ¤ì¤Þ¤¹.          */
 923   /*--------------------------------------------------------------------------*/
 924   eccstr = apr_palloc(r->pool, module_count* module_count);
 925   data_total_count = chxj_calc_ecc(qrcode, (unsigned char*)decstr, eccstr);
 926 #ifdef QR_CODE_DEBUG
 927   DBG(r,"chxj_calc_ecc() total_count[%d]", data_total_count);
 928 #endif
 929
 930   /*--------------------------------------------------------------------------*/
 931   /* ºÇÅ¬¤Î¥Þ¥¹¥¯¤ò¼èÆÀ¤¹¤ë                                                   */
 932   /* Á´¤Æ¤Î¥Ñ¥¿¡¼¥ó¤ò»î¤·¡¢ºÇ¤â¼ºÅÀ¤Î¾¯¤Ê¤¤¥Þ¥¹¥¯¤òÁªÂò¤·¤Þ¤¹                 */
 933   /*--------------------------------------------------------------------------*/
 934   min_lost_point = -1;
 935   min_mask_pattern = -1;
 936   for (ii=0; ii<8; ii++) {
 937     int lost_point;
 938     s_init_modules(qrcode, ii, module);
 939     s_map_data(qrcode,  module, (unsigned char*)eccstr, data_total_count, ii);
 940     lost_point = s_calc_lost_point(qrcode, module);
 941
 942     if (min_mask_pattern == -1) {
 943       min_mask_pattern = ii;
 944       min_lost_point   = lost_point;
 945     }
 946     else {
 947       if (min_lost_point >= lost_point) {
 948         min_mask_pattern = ii;
 949         min_lost_point   = lost_point;
 950       }
 951     }
 952   }
 953
 954   /*--------------------------------------------------------------------------*/
 955   /* ºÇÅ¬¥Þ¥¹¥¯¤ÇºÆÅÙºî¤ê¤Ê¤ª¤·                                               */
 956   /*--------------------------------------------------------------------------*/
 957 #ifdef QR_CODE_DEBUG
 958   DBG(r, "selected mask[%d]", min_mask_pattern);
 959 #endif
 960
 961   s_init_modules(qrcode, min_mask_pattern, module);
 962   s_map_data(qrcode,
 963              module,
 964              (unsigned char*)eccstr,
 965              data_total_count,
 966              min_mask_pattern);
 967
 968
 969 #ifdef QR_CODE_DEBUG
 970   /*--------------------------------------------------------------------------*/
 971   /* DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG  */
 972   /*--------------------------------------------------------------------------*/
 973   do {
 974     int xx, yy;
 975     int module_count = v_module_count_table[qrcode->version];
 976     DBG(r,"loop to [%d]", module_count);
 977     for (yy=0; yy<module_count; yy++) {
 978       char *rows ;
 979
 980       rows = apr_psprintf(r->pool, " ");
 981
 982       for (xx=0; xx<module_count; xx++)
 983         rows = apr_pstrcat(r->pool, rows, "[", apr_psprintf(r->pool, "%c", module[yy][xx]), "]", NULL);
 984
 985       DBG(r,"%d:%s", yy,rows);
 986     }
 987   } while(0);
 988   /* DEBUG END */
 989 #endif
 990
 991 #ifdef QR_CODE_DEBUG
 992   DBG(r,"end chxj_qr_code()");
 993 #endif
 994 }
 995
 996 void
 997 chxj_qrcode_node_to_qrcode(qr_code_t* qrcode, Node* node)
 998 {
 999   request_rec* r;
1000   Doc*         doc;
1001   Node*        child;
1002
1003   r   = qrcode->r;
1004   doc = qrcode->doc;
1005
1006   for (child = qs_get_child_node(doc,node);
1007        child ;
1008        child = qs_get_next_node(doc,child)) {
1009
1010     char* name;
1011
1012     name = qs_get_node_name(doc,child);
1013
1014     if (strcasecmp("qrcode",name) == 0) {
1015
1016       qrcode->found       = QR_FOUND;
1017       qrcode->mode_change = QR_NOT_CHANGE;
1018       qrcode->version     = QR_VER_5;
1019       qrcode->level       = QR_LEVEL_L;
1020       qrcode->mode        = QR_8BIT_MODE;
1021       qrcode->size        = 0;
1022       qrcode->indata      = NULL;
1023       chxj_qrcode_node_to_qrcode(qrcode, child);
1024     }
1025     else
1026     if (strcasecmp("version", name) == 0) {
1027       int   ver;
1028       Node* cchild;
1029       char* value;
1030
1031       cchild = qs_get_child_node(doc, child);
1032
1033       if (cchild == NULL) {
1034         qrcode->version = QR_VER_1;
1035         continue;
1036       }
1037
1038       name = qs_get_node_name(doc, cchild);
1039       value = qs_get_node_value(doc, cchild);
1040       if (strcasecmp("TEXT", name) != 0) {
1041         qrcode->version = QR_VER_1;
1042         continue;
1043       }
1044       if (value == NULL || strlen(value) == 0) {
1045         qrcode->version = QR_VER_1;
1046         continue;
1047       }
1048
1049       if (chxj_chk_numeric(value)) {
1050         qrcode->version = QR_VER_1;
1051         continue;
1052       }
1053       ver = chxj_atoi(value);
1054       if (ver <= 0 || ver > 40) {
1055         qrcode->version = QR_VER_1;
1056         continue;
1057       }
1058
1059       qrcode->version = ver - 1;
1060     }
1061     else
1062     if (strcasecmp("level", name) == 0) {
1063       Node* cchild = qs_get_child_node(doc, child);
1064       char* value;
1065       if (cchild == NULL) {
1066         qrcode->level = QR_LEVEL_L;
1067         continue;
1068       }
1069       name  = qs_get_node_name(doc, cchild);
1070       value = qs_get_node_value(doc, cchild);
1071       if (strcasecmp("TEXT", name) != 0) {
1072         qrcode->level = QR_LEVEL_L;
1073         continue;
1074       }
1075
1076       if (value == NULL || strlen(value) == 0) {
1077         qrcode->level = QR_LEVEL_L;
1078         continue;
1079       }
1080
1081       if (strcasecmp("L", value) == 0) {
1082         qrcode->level = QR_LEVEL_L;
1083       }
1084       else
1085       if (strcasecmp("M", value) == 0) {
1086         qrcode->level = QR_LEVEL_M;
1087       }
1088       else
1089       if (strcasecmp("Q", value) == 0) {
1090         qrcode->level = QR_LEVEL_Q;
1091       }
1092       else
1093       if (strcasecmp("H", value) == 0) {
1094         qrcode->level = QR_LEVEL_H;
1095       }
1096       else
1097       {
1098         qrcode->level = QR_LEVEL_L;
1099       }
1100     }
1101     else
1102     if (strcasecmp("mode", name) == 0)
1103     {
1104       Node* cchild = qs_get_child_node(doc, child);
1105       char* value;
1106       if (cchild == NULL)
1107       {
1108         qrcode->mode = QR_NUM_MODE;
1109         continue;
1110       }
1111       name = qs_get_node_name(doc, cchild);
1112       value = qs_get_node_value(doc, cchild);
1113       if (strcasecmp("TEXT", name) != 0)
1114       {
1115         qrcode->level = QR_NUM_MODE;
1116         continue;
1117       }
1118       if (value == NULL || strlen(value) == 0)
1119       {
1120         qrcode->level = QR_NUM_MODE;
1121         continue;
1122       }
1123
1124       /*----------------------------------------------------------------------*/
1125       /* ¿ô»ú¥â¡¼¥É                                                           */
1126       /*----------------------------------------------------------------------*/
1127       if (strcasecmp("NUM", value) == 0)
1128       {
1129         qrcode->mode    = QR_NUM_MODE;
1130       }
1131       else
1132       /*----------------------------------------------------------------------*/
1133       /* ±Ñ¿ô»ú¥â¡¼¥É                                                         */
1134       /*----------------------------------------------------------------------*/
1135       if (strcasecmp("ALPHA", value) == 0)
1136       {
1137         qrcode->mode    = QR_ALPHA_MODE;
1138       }
1139       else
1140       /*----------------------------------------------------------------------*/
1141       /* 8¥Ó¥Ã¥È¥Ð¥¤¥È¥â¡¼¥É                                                  */
1142       /*----------------------------------------------------------------------*/
1143       if (strcasecmp("8BIT", value) == 0)
1144       {
1145         qrcode->mode    = QR_8BIT_MODE;
1146       }
1147       else
1148       /*----------------------------------------------------------------------*/
1149       /* ´Á»ú¥â¡¼¥É                                                           */
1150       /*----------------------------------------------------------------------*/
1151       if (strcasecmp("KANJI", value) == 0)
1152       {
1153         qrcode->mode    = QR_KANJI_MODE;
1154       }
1155       else
1156       {
1157         qrcode->mode    = QR_NUM_MODE;
1158       }
1159     }
1160     else
1161     if (strcasecmp("data", name) == 0)
1162     {
1163       /* TODO: ²þ¹Ô¤â²ÄÇ½¤Ê¤è¤¦¤Ë½¤Àµ¤¹¤ë */
1164       Node* cchild = qs_get_child_node(doc, child);
1165       char* value;
1166
1167       qrcode->indata = apr_palloc(r->pool, 1);
1168       qrcode->indata[0] = 0;
1169       if (cchild == NULL)
1170       {
1171         continue;
1172       }
1173       for (;cchild; cchild = cchild->next)
1174       {
1175         name = qs_get_node_name(doc, cchild);
1176         value = qs_get_node_value(doc, cchild);
1177         if (strcasecmp("TEXT", name) != 0)
1178         {
1179           continue;
1180         }
1181         if (strlen(qrcode->indata) > 0)
1182         {
1183           qrcode->indata = apr_pstrcat(r->pool, qrcode->indata, "\r\n", NULL);
1184         }
1185         qrcode->indata = apr_pstrcat(r->pool, qrcode->indata, value, NULL);
1186       }
1187     }
1188     else
1189     if (strcasecmp("size", name) == 0)
1190     {
1191       int size;
1192       char* value;
1193       Node* cchild = qs_get_child_node(doc, child);
1194
1195       if (cchild == NULL)
1196       {
1197         qrcode->size = 0;
1198         continue;
1199       }
1200       name = qs_get_node_name(doc, cchild);
1201       value = qs_get_node_value(doc, cchild);
1202       if (strcasecmp("TEXT", name) != 0)
1203       {
1204         qrcode->size = 0;
1205         continue;
1206       }
1207       if (value == NULL || strlen(value) == 0)
1208       {
1209         qrcode->size = 0;
1210         continue;
1211       }
1212       if (chxj_chk_numeric(value))
1213       {
1214         qrcode->size = 0;
1215         continue;
1216       }
1217
1218       size = chxj_atoi(value);
1219       if (size <= 0)
1220       {
1221         qrcode->size = 0;
1222         continue;
1223       }
1224       if (size > 20)
1225       {
1226         qrcode->size = 20;
1227         continue;
1228       }
1229       qrcode->size = size;
1230     }
1231   }
1232 #ifdef QR_CODE_DEBUG
1233   DBG(r,"qrcode->version[%d]", qrcode->version);
1234   DBG(r,"qrcode->level[%d]", qrcode->level);
1235   DBG(r,"qrcode->mode[%d]", qrcode->mode);
1236   DBG(r,"qrcode->indata[%s]", qrcode->indata);
1237 #endif
1238 }
1239
1240
1241 /**
1242  * ¥â¡¼¥É»Ø¼¨»Ò¤ò¼èÆÀ¤·¤Þ¤¹.
1243  */
1244 static char*
1245 s_get_mode_spec(qr_code_t *qrcode)
1246 {
1247   char* result = (char*)apr_palloc(qrcode->r->pool, 4+1);
1248
1249   memset(result, 0, 5);
1250   memcpy(result, v_mode_table[qrcode->mode], 4);
1251 #ifdef QR_CODE_DEBUG
1252   DBG(r,"Mode Spec[%s]", result);
1253 #endif
1254
1255   return result;
1256 }
1257
1258
1259 /**
1260  * Ê¸»ú¿ô»Ø¼¨»Ò¤ò¼èÆÀ¤·¤Þ¤¹.
1261  */
1262 static char*
1263 s_get_char_bit_count(qr_code_t* qrcode, int len)
1264 {
1265   int bit_count = v_char_count_table[qrcode->version][qrcode->mode];
1266   int ii,jj;
1267   char* tmp;
1268   char* result;
1269   int data_capacity   = v_capacity_table[qrcode->version*4+qrcode->level].size[qrcode->mode];
1270
1271   DBG(qrcode->r, "len [%d]", len);
1272   if (qrcode->mode == QR_KANJI_MODE && data_capacity * 2 < len) {
1273     len = data_capacity * 2;
1274   }
1275   else
1276   if (qrcode->mode != QR_KANJI_MODE && data_capacity < len) {
1277     len = data_capacity;
1278   }
1279
1280   if (qrcode->mode == QR_KANJI_MODE) {
1281     len /= 2;
1282   }
1283
1284   DBG(qrcode->r, "len [%d]", len);
1285
1286   tmp = (char*)apr_palloc(qrcode->r->pool, bit_count + 1);
1287   for (ii=0; ii<bit_count; ii++) {
1288     tmp[ii] = (len & 0x01) ? '1' : '0';
1289     len = len >> 1;
1290   }
1291
1292   tmp[bit_count] = '\0';
1293
1294   result = (char*)apr_palloc(qrcode->r->pool, bit_count+1);
1295   for (jj=0,ii=bit_count-1; ii>=0 && jj < bit_count; ii--, jj++) {
1296     result[ii] = tmp[jj];
1297   }
1298
1299   result[bit_count] = '\0';
1300
1301 #ifdef QR_CODE_DEBUG
1302   DBG(qrcode->r, "Character Count bit [%s]", result);
1303 #endif
1304
1305   return result;
1306 }
1307
1308 /**
1309  * ¿ô»ú¥â¡¼¥É
1310  * ÆþÎÏ¥Ç¡¼¥¿¤«¤é¡¢£²¿ÊÊ¸»úÎó¤ò¼èÆÀ¤·¤Þ¤¹.
1311  */
1312 static char*
1313 s_data_to_bin_num(qr_code_t* qrcode, int UNUSED(data_code_count))
1314 {
1315   int len = strlen(qrcode->indata);
1316   int setn;
1317   int modn;
1318   int ii;
1319   int jj;
1320   int kk;
1321   char* result;
1322   char  tmp[4];
1323   char  tmp_bit[11];
1324   int data_capacity   = v_capacity_table[qrcode->version*4+qrcode->level].size[qrcode->mode];
1325
1326   if (data_capacity < len) {
1327     DBG(qrcode->r, "input data is too long");
1328     len = data_capacity;
1329   }
1330   setn = len / 3;
1331   modn = len % 3;
1332
1333   if (chxj_chk_numeric(qrcode->indata) != 0) {
1334     qrcode->mode_change = QR_CHANGE;
1335     qrcode->mode        = QR_8BIT_MODE;
1336     return NULL;
1337   }
1338
1339   result = (char*)apr_palloc(qrcode->r->pool, setn*10 + ((modn == 1) ? 4 : (modn == 2) ? 7 : 0) + 1);
1340   kk = 0;
1341   for (ii=0; ii<len; ii++) {
1342     tmp[ii % 3] = qrcode->indata[ii];
1343     if ((ii % 3) == 2) {
1344       tmp[4] = 0;
1345       int n = atoi(tmp);
1346       for (jj=0; jj<10; jj++) {
1347         tmp_bit[jj] = (n & 0x01) ?  '1'  : '0';
1348         n = n >> 1;
1349       }
1350       tmp_bit[10] = 0;
1351       for (jj=10-1; jj>=0; jj--) {
1352         result[kk++] = tmp_bit[jj];
1353       }
1354     }
1355   }
1356
1357   if (modn != 0) {
1358     tmp[modn] = 0;
1359     int n = atoi(tmp);
1360     int bb = (modn == 1) ? 4 : 7;
1361
1362     for (jj=0; jj< bb; jj++) {
1363       tmp_bit[jj] = (n & 0x01) ?  '1'  : '0';
1364       n = n >> 1;
1365     }
1366
1367     tmp_bit[(modn == 1) ? 4 : 7] = 0;
1368
1369     for (jj=bb -1; jj>=0; jj--) {
1370       result[kk++] = tmp_bit[jj];
1371     }
1372   }
1373   result[kk] = 0;
1374   return result;
1375 }
1376
1377
1378 /**
1379  * ±Ñ¿ô»ú¥â¡¼¥É
1380  * ÆþÎÏ¥Ç¡¼¥¿¤«¤é¡¢£²¿ÊÊ¸»úÎó¤ò¼èÆÀ¤·¤Þ¤¹.
1381  */
1382 static char*
1383 s_data_to_bin_alpha(qr_code_t* qrcode, int UNUSED(data_code_count))
1384 {
1385   int len = strlen(qrcode->indata);
1386   int setn;
1387   int modn;
1388   int ii;
1389   int jj;
1390   int kk;
1391   char* result;
1392   char  tmp[2+1];
1393   char  tmp_bit[11+1];
1394   int data_capacity   = v_capacity_table[qrcode->version*4+qrcode->level].size[qrcode->mode];
1395
1396   if (data_capacity < len) {
1397     DBG(qrcode->r, "input data is too long");
1398     len = data_capacity;
1399   }
1400   setn = len / 2;
1401   modn = len % 2;
1402
1403   result = (char*)apr_palloc(qrcode->r->pool, setn*11 + ((modn == 1) ? 6 : 0) + 1);
1404
1405   kk = 0;
1406   for (ii=0; ii<len; ii++) {
1407     tmp[ii % 2] = qrcode->indata[ii];
1408     if ((ii % 2) == 1) {
1409       tmp[3] = 0;
1410       int n = s_char_to_num_alpha(qrcode,tmp[0])*45;
1411
1412       if (qrcode->mode_change == QR_CHANGE)
1413         return NULL;
1414
1415       n += s_char_to_num_alpha(qrcode,tmp[1]);
1416       if (qrcode->mode_change == QR_CHANGE)
1417         return NULL;
1418
1419       for (jj=0; jj<11; jj++) {
1420         tmp_bit[jj] = (n & 0x01) ?  '1'  : '0';
1421         n = n >> 1;
1422       }
1423
1424       tmp_bit[11] = 0;
1425
1426       for (jj=11-1; jj>=0; jj--)
1427         result[kk++] = tmp_bit[jj];
1428     }
1429   }
1430
1431   if (modn) {
1432
1433     tmp[modn] = 0;
1434     int n = s_char_to_num_alpha(qrcode,tmp[0]);
1435
1436     if (qrcode->mode_change == QR_CHANGE)
1437       return NULL;
1438
1439     for (jj=0; jj< 6; jj++) {
1440       tmp_bit[jj] = (n & 0x01) ?  '1'  : '0';
1441       n = n >> 1;
1442     }
1443
1444     tmp_bit[6] = 0;
1445
1446     for (jj=6-1; jj>=0; jj--)
1447       result[kk++] = tmp_bit[jj];
1448   }
1449   result[kk] = 0;
1450   return result;
1451 }
1452
1453
1454 /**
1455  * ±Ñ¿ô»ú¥â¡¼¥É¤ÎÊä½õ´Ø¿ô.
1456  * ±Ñ¿ô»ú¤«¤é¡¢¿ôÃÍ¤ËÊÑ´¹¤·¤Þ¤¹.
1457  */
1458 static int
1459 s_char_to_num_alpha(qr_code_t* qrcode, char src)
1460 {
1461   switch(src) {
1462   case '0': return 0;
1463   case '1': return 1;
1464   case '2': return 2;
1465   case '3': return 3;
1466   case '4': return 4;
1467   case '5': return 5;
1468   case '6': return 6;
1469   case '7': return 7;
1470   case '8': return 8;
1471   case '9': return 9;
1472   case 'A': return 10;
1473   case 'B': return 11;
1474   case 'C': return 12;
1475   case 'D': return 13;
1476   case 'E': return 14;
1477   case 'F': return 15;
1478   case 'G': return 16;
1479   case 'H': return 17;
1480   case 'I': return 18;
1481   case 'J': return 19;
1482   case 'K': return 20;
1483   case 'L': return 21;
1484   case 'M': return 22;
1485   case 'N': return 23;
1486   case 'O': return 24;
1487   case 'P': return 25;
1488   case 'Q': return 26;
1489   case 'R': return 27;
1490   case 'S': return 28;
1491   case 'T': return 29;
1492   case 'U': return 30;
1493   case 'V': return 31;
1494   case 'W': return 32;
1495   case 'X': return 33;
1496   case 'Y': return 34;
1497   case 'Z': return 35;
1498   case ' ':
1499     return 36;
1500   case '$':
1501     return 37;
1502   case '%':
1503     return 38;
1504   case '*':
1505     return 39;
1506   case '+':
1507     return 40;
1508   case '-':
1509     return 41;
1510   case '.':
1511     return 42;
1512   case '/':
1513     return 43;
1514   case ':':
1515     return 44;
1516   default:
1517     qrcode->mode_change = QR_CHANGE;
1518     qrcode->mode = QR_8BIT_MODE;
1519     return -1;
1520   }
1521 }
1522
1523 /**
1524  * 8bit¥Ð¥¤¥È¥â¡¼¥É
1525  * ÆþÎÏ¥Ç¡¼¥¿¤«¤é£²¿ÊÊ¸»úÎó¤ò¼èÆÀ¤·¤Þ¤¹.
1526  */
1527 static char*
1528 s_data_to_bin_8bit(qr_code_t* qrcode, int UNUSED(data_code_count))
1529 {
1530   int len = strlen(qrcode->indata);
1531   int ii;
1532   int jj;
1533   int kk;
1534   char* result;
1535   char  tmp_bit[8+1];
1536   int data_capacity   = v_capacity_table[qrcode->version*4+qrcode->level].size[qrcode->mode];
1537
1538   if (data_capacity < len) {
1539     DBG(qrcode->r, "input data is too long");
1540     len = data_capacity;
1541   }
1542
1543   result = (char*)apr_palloc(qrcode->r->pool, len*8 + 1);
1544
1545   kk = 0;
1546   for (ii=0; ii<len; ii++) {
1547     int n;
1548
1549     n = (int)qrcode->indata[ii];
1550     for (jj=0; jj<8; jj++) {
1551       tmp_bit[jj] = (n & 0x01) ? '1' : '0';
1552       n = n >> 1;
1553     }
1554
1555     tmp_bit[8] = 0;
1556
1557     for (jj=8-1; jj>=0; jj--)
1558       result[kk++] = tmp_bit[jj];
1559   }
1560   result[kk] = 0;
1561
1562 #ifdef QR_CODE_DEBUG
1563   DBG(qrcode->r, "input data --> 2bin result[%s] len:[%d]", result, strlen(result));
1564 #endif
1565
1566   return result;
1567 }
1568
1569 /**
1570  * Kanji mode.
1571  * A binary character string is acquired from input data.
1572  */
1573 static char*
1574 s_data_to_bin_kanji(qr_code_t* qrcode, int UNUSED(data_code_count))
1575 {
1576   int len = strlen(qrcode->indata);
1577   int ii;
1578   int jj;
1579   int kk;
1580   char* result;
1581   char  tmp_bit[13+1];
1582
1583   int data_capacity   = v_capacity_table[qrcode->version*4+qrcode->level].size[qrcode->mode];
1584
1585   if (data_capacity * 2 < len) {
1586     DBG(qrcode->r, "input data is too long");
1587     len = data_capacity * 2;
1588   }
1589
1590   if ((len % 2) != 0) {
1591     DBG(qrcode->r, "invalid data.");
1592     qrcode->mode_change = QR_CHANGE;
1593     qrcode->mode        = QR_8BIT_MODE;
1594     return NULL;
1595   }
1596
1597   result = (char*)apr_palloc(qrcode->r->pool, (len/2)*13 + 1);
1598   for (kk=0,ii=0; ii<len-1; ii++) {
1599     int c;
1600     int up_c;
1601     int dn_c;
1602     c = (qrcode->indata[ii+0] & 0xff)<< 8;
1603     c +=(qrcode->indata[ii+1] & 0xff);
1604
1605     if (c >= 0x8140 && c <= 0x9FFC) {
1606       c -= 0x8140;
1607       up_c = ((c >> 8) & 0xff) * 0xC0;
1608       dn_c = ( c       & 0xff);
1609       c  = up_c;
1610       c += dn_c;
1611     }
1612     else
1613     if (c >= 0xE040 && c <= 0xEBBF) {
1614       c -= 0xC140;
1615       up_c = ((c >> 8) & 0xff) * 0xC0;
1616       dn_c = ( c       & 0xff);
1617       c  = up_c;
1618       c += dn_c;
1619     }
1620     else {
1621       qrcode->mode_change = QR_CHANGE;
1622       qrcode->mode        = QR_8BIT_MODE;
1623       return NULL;
1624     }
1625
1626     memset(tmp_bit, 0, 13+1);
1627     for (jj=0; jj<13; jj++) {
1628       tmp_bit[jj] = (c & 0x01) ? '1' : '0';
1629       c = c >> 1;
1630     }
1631
1632     tmp_bit[13] = 0;
1633     for (jj=13-1; jj>=0; jj--)
1634       result[kk++] = tmp_bit[jj];
1635
1636     ii++;
1637   }
1638   result[kk] = 0;
1639
1640 #ifdef QR_CODE_DEBUG
1641   DBG(qrcode->r, "input data --> 2bin result[%s] len:[%d]", result, strlen(result));
1642 #endif
1643
1644   return result;
1645 }
1646
1647 /**
1648  * 8bitÄ¹¤Ë¤¢¤ï¤»¤Þ¤¹
1649  */
1650 static char*
1651 s_tidy_8bit_code(qr_code_t* qrcode, const char* indata, int data_code_count)
1652 {
1653   int len = strlen(indata);
1654   int ii;
1655   int n;
1656   int rest;
1657   char* tmp = NULL;
1658   char* result;
1659
1660 #ifdef QR_CODE_DEBUG
1661   DBG(qrcode->r, "len[%d] data_code_count * 8 [%d]", len, data_code_count * 8);
1662 #endif
1663
1664   assert (len <= data_code_count * 8);
1665   /* 8bit¤Ç³ä¤ì¤Ê¤¤¾ì¹ç¤Ï¡¢»Ä¤ê¤ò£°Ëä¤á¤·¡¢8¤Ç³ä¤ì¤ë¤è¤¦¤Ë¤¹¤ë */
1666   if (len % 8) {
1667     n = 8 - (len % 8);
1668     assert (len + n <= data_code_count * 8);
1669
1670     tmp = (char*)apr_palloc(qrcode->r->pool, n);
1671     for (ii=0; ii<n; ii++)
1672       tmp[ii] = '0';
1673
1674     tmp[ii] = 0;
1675   }
1676
1677   result = (char*)apr_palloc(qrcode->r->pool, data_code_count * 8 + 1);
1678   memset(result, 0, data_code_count * 8+ 1);
1679   memcpy(result, indata, len);
1680   if (len % 8)
1681     memcpy(&result[len], tmp, strlen(tmp));
1682
1683   len = strlen(result);
1684   rest = data_code_count - (len / 8);
1685   n = 0;
1686   while(rest>0) {
1687     for (ii=0; ii<8; ii++)
1688       result[len++] = v_pend_bit[n][ii];
1689
1690     n = (n == 0) ? 1 : 0;
1691     rest--;
1692   }
1693
1694 #ifdef QR_CODE_DEBUG
1695   DBG(qrcode->r, "tidy len[%d] data_code_count[%d]", strlen(result)/8, data_code_count);
1696 #endif
1697
1698   return result;
1699 }
1700
1701 /**
1702  * £²¿ÊÊ¸»úÎó¤ò¥Ð¥¤¥Ê¥ê¤ËÊÑ´¹¤·¤Þ¤¹.
1703  */
1704 static char*
1705 s_str_to_bin(qr_code_t* qrcode, char* indata, int data_code_count)
1706 {
1707   char* result ;
1708   int pos;
1709   int len ;
1710   int ii;
1711
1712   len = strlen(indata);
1713   result = (char*)apr_palloc(qrcode->r->pool, data_code_count);
1714   memset(result, 0, data_code_count);
1715
1716   pos = 0;
1717   for (ii=0; ii<len; ii++) {
1718     result[pos] = (result[pos] << 1) | (indata[ii] - '0');
1719     if ((ii % 8) == 7)
1720       pos ++;
1721   }
1722   return result;
1723 }
1724
1725 /**
1726  * ½ÐÎÏÎÎ°è¤ò½é´ü²½¤·¤Þ¤¹.
1727  * °ÌÃÖ¸¡½Ð¥Ñ¥¿¡¼¥ó¡¢°ÌÃÖ¤¢¤ï¤»¡¢¥¿¥¤¥ß¥ó¥°¡¢·Á¼°¾ðÊó¤òÀßÄê¤·¡¢
1728  * ¤½¤Î¤Û¤«¤Î¾ì½ê¤Ë¤Ï¡¢-1¤òÀßÄê¤·¤Þ¤¹.
1729  */
1730 static void
1731 s_init_modules(qr_code_t* qrcode, qr_mask_pattern_t pat, char* dst[])
1732 {
1733   int module_count = v_module_count_table[qrcode->version];
1734   int yy;
1735
1736 #ifdef QR_CODE_DEBUG
1737   DBG(qrcode->r, "start s_init_modules()");
1738
1739   DBG(qrcode->r, "module_count[%d]", module_count);
1740 #endif
1741
1742   for (yy=0; yy<module_count; yy++)
1743     memset(&dst[yy][0], -1, module_count+1);
1744
1745   s_setup_probe_position(qrcode, dst, 0, 0);
1746   s_setup_probe_position(qrcode, dst, 0, module_count - 7);
1747   s_setup_probe_position(qrcode, dst, module_count - 7, 0);
1748   s_setup_position_adjust(qrcode, dst);
1749   s_setup_timing_pattern(qrcode, dst);
1750   s_setup_type_info(qrcode,dst, pat);
1751   s_setup_version_info(qrcode, dst);
1752
1753 #ifdef QR_CODE_DEBUG
1754   DBG(qrcode->r, "end s_init_modules()");
1755 #endif
1756
1757 }
1758
1759 /*
1760  * °ÌÃÖ¸¡½Ð¥Ñ¥¿¡¼¥ó¤È¤Ä¤¤¤Ç¤ËÊ¬Î¥¥Ñ¥¿¡¼¥ó¤Î½ÐÎÏ
1761  */
1762 static void
1763 s_setup_probe_position(qr_code_t* qrcode, char* dst[], int pos_x, int pos_y)
1764 {
1765   int module_count = v_module_count_table[qrcode->version];
1766   int xx;
1767   int yy;
1768 #ifdef QR_CODE_DEBUG
1769   DBG(qrcode->r, "start s_setup_probe_position()");
1770   DBG(qrcode->r, "module_count[%d]", module_count);
1771 #endif
1772
1773   for (yy=-1; yy<=7; yy++) {
1774     for (xx=-1; xx<=7; xx++) {
1775       /* °ÌÃÖ¸¡½Ð¥Ñ¥¿¡¼¥ó */
1776       if ((yy==0 || yy == 6) && xx != -1 && xx != 7) {
1777         assert(yy+pos_y >= 0 && yy+pos_y < module_count);
1778         assert(xx+pos_x >= 0 && xx+pos_x < module_count);
1779         dst[yy+pos_y][xx+pos_x] = '1';
1780       }
1781       else
1782       if ((xx == 0 && yy != -1 && yy != 7)
1783       ||  (xx >= 2 && xx <= 4 && yy >=2 && yy <= 4)
1784       ||  (xx == 6 && yy != -1 && yy != 7)) {
1785         assert(yy+pos_y >= 0 && yy+pos_y < module_count);
1786         assert(xx+pos_x >= 0 && xx+pos_x < module_count);
1787         dst[yy+pos_y][xx+pos_x] = '1';
1788       }
1789       else {
1790         /* Ê¬Î¥¥Ñ¥¿¡¼¥ó */
1791         if ((yy == 7
1792         &&   yy + pos_y >= 0
1793         &&   yy + pos_y < module_count
1794         &&   xx + pos_x >= 0
1795         &&   xx + pos_x < module_count)
1796         ||  (yy == -1
1797         &&   yy + pos_y >= 0
1798         &&   yy + pos_y < module_count
1799         &&   xx + pos_x >= 0
1800         &&   xx + pos_x < module_count)
1801         ||  (xx == 7
1802         &&   xx + pos_x >= 0
1803         &&   xx + pos_x < module_count
1804         &&   yy + pos_y >= 0
1805         &&   yy + pos_y < module_count)
1806         ||  (xx == -1
1807         &&   xx + pos_x < module_count
1808         &&   xx + pos_x >= 0
1809         &&   yy + pos_y >= 0
1810         &&   yy + pos_y < module_count)) {
1811           assert(yy+pos_y >= 0 && yy+pos_y < module_count);
1812           assert(xx+pos_x >= 0 && xx+pos_x < module_count);
1813           dst[yy+pos_y][xx+pos_x] = '0';
1814         }
1815         else
1816         if (yy != -1 && yy != 7 && xx != -1 && xx != 7) {
1817           assert(yy+pos_y >= 0 && yy+pos_y < module_count);
1818           assert(xx+pos_x >= 0 && xx+pos_x < module_count);
1819           dst[yy+pos_y][xx+pos_x] = '0';
1820         }
1821       }
1822     }
1823   }
1824 #ifdef QR_CODE_DEBUG
1825   DBG(qrcode->r, "end s_setup_probe_position()");
1826 #endif
1827 }
1828 /*
1829  * ¥¿¥¤¥ß¥ó¥°¥Ñ¥¿¡¼¥ó
1830  */
1831 static void
1832 s_setup_timing_pattern(qr_code_t* qrcode, char* dst[])
1833 {
1834   int module_count = v_module_count_table[qrcode->version];
1835   int xx, yy;
1836 #ifdef QR_CODE_DEBUG
1837   DBG(qrcode->r, "start s_setup_timing_pattern()");
1838   DBG(qrcode->r, "module_count[%d]", module_count);
1839 #endif
1840
1841   yy=6;
1842   for (xx=8; xx < module_count-8; xx++) {
1843     if (dst[yy][xx] != -1)
1844       continue;
1845
1846     assert(yy >= 0 && yy < module_count);
1847     assert(xx >= 0 && xx < module_count);
1848
1849     dst[yy][xx] = (xx % 2 == 0) ? '1' : '0';
1850   }
1851
1852   xx=6;
1853   for (yy=8; yy < module_count-8; yy++) {
1854     if (dst[yy][xx] != -1)
1855       continue;
1856
1857     assert(yy >= 0 && yy < module_count);
1858     assert(xx >= 0 && xx < module_count);
1859
1860     dst[yy][xx] = (yy % 2 == 0) ? '1' : '0';
1861   }
1862
1863 #ifdef QR_CODE_DEBUG
1864   DBG(qrcode->r, "start s_setup_timing_pattern()");
1865 #endif
1866 }
1867
1868 /*
1869  * °ÌÃÖ¹ç¤ï¤»¥Ñ¥¿¡¼¥ó
1870  */
1871 static void
1872 s_setup_position_adjust(qr_code_t* qrcode, char* dst[])
1873 {
1874   int module_count = v_module_count_table[qrcode->version];
1875   int* pos_list = v_position_adjust_table[qrcode->version].position;
1876   int xx, yy;
1877   int mxx, myy;
1878   int dxx, dyy;
1879
1880 #ifdef QR_CODE_DEBUG
1881   DBG(qrcode->r, "start s_setup_position_adjust()");
1882 #endif
1883
1884   for (yy=0; yy<7; yy++) {
1885     for (xx=0; xx<7; xx++) {
1886       mxx = pos_list[xx];
1887       myy = pos_list[yy];
1888
1889       if (mxx == 0 || myy == 0)
1890         continue;
1891
1892       if (dst[myy][mxx] != -1)
1893         continue;
1894
1895       for (dyy = -2; dyy <= 2; dyy++) {
1896         for (dxx= -2; dxx <= 2; dxx++) {
1897           if (dyy == -2
1898           ||  dxx == -2
1899           ||  dyy == 2
1900           ||  dxx == 2
1901           ||  (dyy == 0 && dxx == 0)) {
1902             assert(myy+dyy >= 0);
1903             assert(myy+dyy < module_count);
1904             dst[myy+dyy][mxx+dxx] = '1';
1905           }
1906           else {
1907             assert(myy+dyy >= 0);
1908             assert(myy+dyy < module_count);
1909             dst[myy+dyy][mxx+dxx] = '0';
1910           }
1911         }
1912       }
1913     }
1914   }
1915
1916 #ifdef QR_CODE_DEBUG
1917   DBG(qrcode->r, "end s_setup_position_adjust()");
1918 #endif
1919 }
1920
1921 static void
1922 s_setup_type_info(qr_code_t* qrcode, char* dst[], qr_mask_pattern_t pat)
1923 {
1924   int module_count = v_module_count_table[qrcode->version];
1925   int typedata;
1926   int sdata;
1927   int gf;
1928   int gfmask;
1929   int xx;
1930   int yy;
1931
1932 #ifdef QR_CODE_DEBUG
1933   DBG(qrcode->r, "start s_setup_type_info()");
1934   DBG(qrcode->r, "module_count[%d]", module_count);
1935 #endif
1936
1937   /* ·Á¼°¾ðÊó¥Ç¡¼¥¿¤ÎÀ¸À® */
1938   switch(qrcode->level) {
1939   case QR_LEVEL_L: sdata = 0x01 << 3; break;
1940   case QR_LEVEL_M: sdata = 0x00 << 3; break;
1941   case QR_LEVEL_Q: sdata = 0x03 << 3; break;
1942   case QR_LEVEL_H: sdata = 0x02 << 3; break;
1943   default:
1944     sdata = 0;
1945     break;
1946   }
1947   sdata |= pat;
1948
1949   /* G(x)=x10+x8+x5+x4+x2+x+1 */
1950   gf = (0x01 << 10)
1951      | (0x01 << 8)
1952      | (0x01 << 5)
1953      | (0x01 << 4)
1954      | (0x01 << 2)
1955      | (0x01 << 1)
1956      | (0x01 << 0);
1957
1958   gfmask = (0x01 << 14) | (0x01 << 12) | (0x01 << 10)  | (0x01 << 4) | (0x01 << 1);
1959
1960
1961   typedata = sdata << 10;
1962   while (s_get_bit_count(typedata) - s_get_bit_count(gf) >= 0) {
1963     typedata ^= (gf << (s_get_bit_count(typedata) - s_get_bit_count(gf)));
1964   }
1965   typedata = (sdata << 10 | typedata);
1966
1967   typedata ^= gfmask;
1968
1969   for (yy=0; yy<6; yy++) {
1970     assert(yy >= 0 && yy < module_count);
1971     dst[yy][8] = (((typedata >> yy) & 0x01) == 1) ?  '1' : '0';
1972   }
1973
1974   for (; yy<8; yy++) {
1975     assert(yy + 1 >= 0 && yy + 1 < module_count);
1976     dst[yy+1][8] = (((typedata >> yy) & 0x01) == 1) ?  '1' : '0';
1977   }
1978
1979   for (; yy<15; yy++) {
1980     assert(module_count - 15 + yy >= 0 && module_count - 15 + yy < module_count);
1981     dst[module_count - 15 + yy][8] = (((typedata >> yy) & 0x01) == 1) ?  '1' : '0';
1982   }
1983
1984   for (xx = 0; xx < 8; xx++) {
1985     assert(module_count - xx -1 >= 0 && module_count - xx - 1 < module_count);
1986     dst[8][module_count - xx - 1] = (((typedata >> xx) & 0x01) == 1) ? '1' : '0';
1987   }
1988
1989   for (; xx<9; xx++) {
1990     assert(15 - xx >= 0 && 15 - xx < module_count);
1991     dst[8][15 - xx] = (((typedata >> xx) & 0x01) == 1) ? '1' : '0';
1992   }
1993
1994   for (; xx<15; xx++) {
1995     assert(15 - xx - 1 >= 0 && 15 - xx - 1 < module_count);
1996     dst[8][15 - xx - 1] = (((typedata >> xx) & 0x01) == 1) ? '1' : '0';
1997   }
1998
1999   assert(module_count - 8 >= 0 && module_count - 8 < module_count);
2000   dst[module_count - 8][8] = '1';
2001
2002 #ifdef QR_CODE_DEBUG
2003   DBG(qrcode->r, "start s_setup_type_info()");
2004 #endif
2005 }
2006
2007 static int
2008 s_get_bit_count(int data)
2009 {
2010   int count = 0;
2011
2012   while (data != 0) {
2013     count++;
2014     data >>= 1;
2015   }
2016
2017   return count;
2018 }
2019
2020
2021 static void
2022 s_setup_version_info(qr_code_t* qrcode, char* dst[])
2023 {
2024   char* bits = v_version_info_table[qrcode->version].bits;
2025   int module_count = v_module_count_table[qrcode->version];
2026   size_t xx;
2027   size_t yy;
2028
2029   if (bits == NULL) {
2030     /* ¥Ð¡¼¥¸¥ç¥ó£·°Ê¹ß¤Î¤ßÂÐ¾Ý */
2031     return;
2032   }
2033
2034   /* ±¦¾å¤Î·¿ÈÖ¾ðÊó¤ÎÇÛÃÖ */
2035   for (xx=0; xx<strlen(bits); xx++) {
2036     dst[(int)((double)xx/3.0)][(xx % 3) + module_count - 8 - 3] = bits[xx];
2037   }
2038
2039   /* º¸²¼¤Î·¿ÈÖ¾ðÊó¤ÎÇÛÃÖ */
2040   for (yy=0; yy<strlen(bits); yy++) {
2041     dst[(yy % 3) + module_count - 8 - 3][(int)((double)yy/3.0)] = bits[yy];
2042   }
2043 }
2044
2045 static void
2046 s_map_data(qr_code_t* qrcode,
2047            char* dst[],
2048            unsigned char* indata, int data_count,qr_mask_pattern_t pat)
2049 {
2050   int module_count = v_module_count_table[qrcode->version];
2051   int inc_yy_flag = -1;
2052
2053   int xx, yy;
2054   int ii;
2055   int in_pos;
2056   int now_bit;
2057   int mask;
2058
2059 #ifdef QR_CODE_DEBUG
2060   DBG(qrcode->r, "start s_map_data()");
2061   DBG(qrcode->r, "module_count[%d]", module_count);
2062   DBG(qrcode->r, "data_count[%d]", data_count);
2063 #endif
2064   in_pos = 0;
2065   now_bit = 7;
2066
2067   yy = module_count - 1;
2068
2069   for (xx = module_count - 1; xx > 0 ; xx -= 2) {
2070     if (xx == 6) {
2071       xx--;
2072     }
2073     do {
2074       for (ii=0; ii < 2; ii++) {
2075         if (dst[yy][xx - ii] != -1)
2076           /* ´û¤ËÇÛÃÖ¤µ¤ì¤Æ¤¤¤ë¾ì¹ç */
2077           continue;
2078
2079         if (in_pos < data_count) {
2080           assert(yy >= 0 && yy < module_count);
2081           assert(xx-ii >= 0 && xx-ii < module_count);
2082
2083           dst[yy][xx-ii] = (((indata[in_pos] >> now_bit) & 0x01) == 1) ? '1' : '0';
2084           mask = s_get_mask(pat, yy, xx - ii);
2085           if (mask == 1) {
2086             if (dst[yy][xx-ii] == '1') {
2087               dst[yy][xx-ii] = '0';
2088             }
2089             else {
2090               dst[yy][xx-ii] = '1';
2091             }
2092           }
2093         }
2094         if (--now_bit < 0) {
2095           in_pos++;
2096           now_bit = 7;
2097         }
2098
2099       }
2100       yy += inc_yy_flag;
2101     } while (yy >= 0 && yy < module_count) ;
2102
2103     yy -= inc_yy_flag;
2104     inc_yy_flag = -inc_yy_flag;
2105   }
2106
2107   /* ??? */
2108   for (yy=0; yy<module_count; yy++) {
2109     for (xx=0; xx<module_count; xx++) {
2110       if (dst[yy][xx] == -1) {
2111         dst[yy][xx] = '0';
2112         mask = s_get_mask(pat, yy, xx);
2113         if (mask == 1) {
2114           dst[yy][xx] = '1';
2115         }
2116       }
2117     }
2118   }
2119 #ifdef QR_CODE_DEBUG
2120   DBG(qrcode->r, "end s_map_data()");
2121 #endif
2122 }
2123
2124 static int
2125 s_get_mask(qr_mask_pattern_t pat, int yy, int xx)
2126 {
2127   switch (pat) {
2128   case QR_MASK_1: return ((yy + xx) % 2 == 0) ? 1 : 0;
2129   case QR_MASK_2: return (yy % 2 == 0) ? 1 : 0;
2130   case QR_MASK_3: return (xx % 3 == 0) ? 1 : 0;
2131   case QR_MASK_4: return ((yy + xx) % 3 == 0) ? 1 : 0;
2132   case QR_MASK_5: return (((yy / 2) + (xx / 3)) % 2 == 0) ? 1 : 0;
2133   case QR_MASK_6: return ((yy * xx) % 2 + (yy * xx) % 3 == 0) ? 1 : 0;
2134   case QR_MASK_7: return (((yy * xx) % 2 + (yy * xx) % 3) % 2 == 0) ? 1 : 0;
2135   case QR_MASK_8: return (((yy * xx) % 3 + (yy + xx) % 2) % 2 == 0) ? 1 : 0;
2136   default:
2137     return 0;
2138   }
2139 }
2140
2141
2142 static int
2143 s_calc_lost_point(qr_code_t* qrcode, char* dst[])
2144 {
2145   int point = 0;
2146
2147   /* Æ±¿§¤Î¹Ô¡¿Îó¤ÎÎÙÀÜ¥â¥¸¥å¡¼¥ë ¥â¥¸¥å¡¼¥ë¿ô=(5+i) 3+i  */
2148   point = s_count_same_module(qrcode->version,dst);
2149
2150   /* Æ±¿§¤Î¥â¥¸¥å¡¼¥ë¥Ö¥í¥Ã¥¯ ¥Ö¥í¥Ã¥¯¥µ¥¤¥º 2¡ß2 3  */
2151   point += s_count_same_block(qrcode->version, dst);
2152
2153   /* ¹Ô¡¿Îó¤Ë¤ª¤±¤ë1:1:3:1:1(°Å:ÌÀ:°Å:ÌÀ:°Å)¤Î¥Ñ¥¿¡¼¥ó */
2154   point += s_count_11311_pattern(qrcode->version, dst);
2155
2156   /* Á´ÂÎ¤ËÀê¤á¤ë°Å¥â¥¸¥å¡¼¥ë¤Î³ä¹ç 50¡Þ(5+k)%¡Á50¡Þ(5+(k+1))% 10¡ßk */
2157   point += s_count_dark_ratio(qrcode->version, dst);
2158
2159   return point;
2160 }
2161
2162 /*
2163  * Æ±¿§¤Î¹Ô¡¿Îó¤ÎÎÙÀÜ¥â¥¸¥å¡¼¥ë ¥â¥¸¥å¡¼¥ë¿ô=(5+i)
2164  * ¼ºÅÀ=3+i
2165  */
2166 static int
2167 s_count_same_module(qr_ver_t ver, char* dst[])
2168 {
2169   int module_count;
2170   int point;
2171   int xx, yy;
2172   int same_count;
2173   int prev_value;
2174
2175   module_count = v_module_count_table[ver];
2176   point        = 0;
2177   same_count   = 0;
2178   prev_value   = -1;
2179
2180   /* ²£Êý¸þ¤Ç¥Á¥§¥Ã¥¯ */
2181   for (yy=0; yy<module_count; yy++) {
2182     prev_value = -1;
2183     same_count = 0;
2184     for (xx=0; xx<module_count; xx++) {
2185       if (prev_value == (unsigned char)dst[yy][xx])
2186         same_count++;
2187       else
2188         same_count = 0;
2189
2190       if (same_count >= 5)
2191         point++;
2192
2193       prev_value = (unsigned char)dst[yy][xx];
2194     }
2195   }
2196
2197   /* ½ÄÊý¸þ¤Ç¥Á¥§¥Ã¥¯ */
2198   for (xx=0; xx<module_count; xx++) {
2199     prev_value = -1;
2200     same_count = 0;
2201
2202     for (yy=0; yy<module_count; yy++) {
2203       if (prev_value == (unsigned char)dst[yy][xx]) {
2204         same_count++;
2205       }
2206       else {
2207         same_count = 0;
2208       }
2209
2210       if (same_count >= 5)
2211         point++;
2212
2213       prev_value = (unsigned char)dst[yy][xx];
2214     }
2215   }
2216
2217   if (point > 0)
2218     point += 3;
2219
2220   return point;
2221 }
2222
2223 /*
2224  * Æ±¿§¤Î¥â¥¸¥å¡¼¥ë¥Ö¥í¥Ã¥¯ ¥Ö¥í¥Ã¥¯¥µ¥¤¥º 2¡ß2
2225  */
2226 static int
2227 s_count_same_block(qr_ver_t ver, char* dst[])
2228 {
2229   int module_count;
2230   int point;
2231   int count;
2232   int xx,yy;
2233
2234   module_count = v_module_count_table[ver];
2235
2236   point = 0;
2237   for (yy = 0; yy < module_count-1; yy++) {
2238     for (xx = 0; xx < module_count-1; xx++) {
2239       count = 0;
2240       if (dst[yy+0][xx+0] == '1') count++;
2241       if (dst[yy+0][xx+1] == '1') count++;
2242       if (dst[yy+1][xx+0] == '1') count++;
2243       if (dst[yy+1][xx+1] == '1') count++;
2244       if (count == 0 || count == 4) {
2245         point += 3;
2246       }
2247     }
2248   }
2249   return point;
2250 }
2251
2252 static int
2253 s_count_11311_pattern(qr_ver_t ver, char* dst[])
2254 {
2255   int module_count;
2256   int point;
2257   int xx,yy;
2258
2259   module_count = v_module_count_table[ver];
2260
2261   point = 0;
2262   /* ²£Êý¸þ¤Î¥Á¥§¥Ã¥¯ */
2263   for (yy = 0; yy < module_count; yy++) {
2264     for (xx = 0; xx < module_count-6; xx++) {
2265       if (dst[yy][xx+0] == '1'
2266       &&  dst[yy][xx+1] == '0'
2267       &&  dst[yy][xx+2] == '1'
2268       &&  dst[yy][xx+3] == '1'
2269       &&  dst[yy][xx+4] == '1'
2270       &&  dst[yy][xx+5] == '0'
2271       &&  dst[yy][xx+6] == '1') {
2272         point += 40;
2273       }
2274     }
2275   }
2276
2277   /* ½ÄÊý¸þ¤Î¥Á¥§¥Ã¥¯ */
2278   for (xx = 0; xx < module_count; xx++) {
2279     for (yy = 0; yy < module_count-6; yy++) {
2280       if (dst[yy+0][xx] == '1'
2281       &&  dst[yy+1][xx] == '0'
2282       &&  dst[yy+2][xx] == '1'
2283       &&  dst[yy+3][xx] == '1'
2284       &&  dst[yy+4][xx] == '1'
2285       &&  dst[yy+5][xx] == '0'
2286       &&  dst[yy+6][xx] == '1') {
2287         point += 40;
2288       }
2289     }
2290   }
2291
2292   return point;
2293 }
2294
2295
2296 /*
2297  * Á´ÂÎ¤ËÀê¤á¤ë°Å¥â¥¸¥å¡¼¥ë¤Î³ä¹ç 50¡Þ(5+k)%¡Á50¡Þ(5+(k+1))%
2298  */
2299 static int
2300 s_count_dark_ratio(qr_ver_t ver, char* dst[])
2301 {
2302   int module_count;
2303   int dark_count;
2304   int xx, yy;
2305   int ratio;
2306   int all_count;
2307
2308   module_count = v_module_count_table[ver];
2309   dark_count   = 0;
2310   all_count    = module_count * module_count;
2311
2312   /* Ã±¤Ë"°Å"¤ò¥«¥¦¥ó¥È¤¹¤ë */
2313   for (yy=0; yy<module_count; yy++) {
2314     for (xx=0; xx < module_count; xx++)
2315       if (dst[yy][xx] == '1')
2316         dark_count++;
2317   }
2318
2319   /* % ¤òµá¤á¡¢50¡ó¤«¤é¤Îº¹¤òµá¤á¤ë¡£ */
2320   ratio = (int)(((double)(dark_count) / (double)all_count)*100.0 - 50.0);
2321   ratio = abs(ratio);
2322
2323   /* 5%Ëè¤Ë10ÅÀ¸ºÅÀ¤Ê¤Î¤Ç¡¢¤Þ¤º5¤Ç³ä¤ë */
2324   ratio = ratio / 5;
2325   return ratio * 10;
2326 }
2327
2328
2329
2330 /*
2331  * vim:ts=2 et
2332  */