src/chxj_qr_code.c

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