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