1 /*
2 * drivers/input/touchscreen/gsl_point_id.c
3 *
4 * Copyright (c) 2012 Shanghai Basewin
5 * Guan Yuwei<guanyuwei@basewin.com>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11
12 //#include "linux/module.h"
13 //#include <wdm.h>
14 /*
15 NTSTATUS
16 DriverEntry(
17 IN PDRIVER_OBJECT DriverObject,
18 IN PUNICODE_STRING RegistryPath
19 );
20
21 #ifdef ALLOC_PRAGMA
22 #pragma alloc_text(INIT, DriverEntry)
23 #endif
24
25 NTSTATUS
26 DllInitialize( IN PUNICODE_STRING pus )
27 {
28 DbgPrint("GSL_POINT_ID: DllInitialize(%S)\n", pus->Buffer );
29 return STATUS_SUCCESS;
30 }
31
32 NTSTATUS
33 DllUnload( )
34 {
35 DbgPrint("GSL_POINT_ID: DllUnload\n");
36 return STATUS_SUCCESS;
37 }
38 */
39 //#define GESTURE_ABLE 1
40 #define GESTURE_LICH 1
41
42 #define GSL_VERSION 0x20140421
43 #ifndef NULL
44 #define NULL ((void*)0)
45 #endif
46 #ifndef UINT
47 #define UINT unsigned int
48 #endif
49
50 #define POINT_MAX 10
51 #define PP_DEEP 10
52 #define PS_DEEP 10
53 #define PR_DEEP 10
54 #define POINT_DEEP (PP_DEEP + PS_DEEP + PR_DEEP)
55 #define PRESSURE_DEEP 8
56 #define CONFIG_LENGTH 512
57 #define TRUE 1
58 #define FALSE 0
59 #define FLAG_ABLE (0x4<<12)
60 #define FLAG_FILL (0x2<<12)
61 #define FLAG_KEY (0x1<<12)
62 #define FLAG_COOR (0x0fff0fff)
63 #define FLAG_COOR_EX (0xffff0fff)
64 #define FLAG_ID (0xf0000000)
65
66 struct gsl_touch_info
67 {
68 int x[10];
69 int y[10];
70 int id[10];
71 int finger_num;
72 };
73
74 typedef struct
75 {
76 unsigned int i;
77 unsigned int j;
78 unsigned int min;//distance min
79 unsigned int d[POINT_MAX][POINT_MAX];//distance;
80 }gsl_DISTANCE_TYPE;
81
82 typedef union
83 {
84 struct
85 {
86 unsigned y:12;
87 unsigned key:1;
88 unsigned fill:1;
89 unsigned able:1;
90 unsigned predict:1;
91 unsigned x:16;
92 }other;
93 struct
94 {
95 unsigned y:13;
96 unsigned rev_2:3;
97 unsigned x:16;
98 }dis;
99 unsigned int all;
100 }gsl_POINT_TYPE;
101
102 typedef union
103 {
104 struct
105 {
106 unsigned delay:8;
107 unsigned report:8;
108 unsigned rev_1:14;
109 unsigned able:1;
110 unsigned init:1;
111 }other;
112 unsigned int all;
113 }gsl_DELAY_TYPE;
114
115 typedef union
116 {
117 struct
118 {
119 unsigned rev_0:8;
120 unsigned rev_1:8;
121
122 unsigned rev_2:7;
123 unsigned ex:1;
124
125 unsigned interpolation:4;
126 unsigned rev_3:1;
127 unsigned only:1;
128 unsigned mask:1;
129 unsigned reset:1;
130 }other;
131 unsigned int all;
132 }gsl_STATE_TYPE;
133
134 typedef struct
135 {
136 unsigned int rate;
137 unsigned int dis;
138 gsl_POINT_TYPE coor;
139 }gsl_EDGE_TYPE;
140
141 typedef union
142 {
143 struct
144 {
145 short y;
146 short x;
147 }other;
148 unsigned int all;
149 }gsl_DECIMAL_TYPE;
150
151 typedef union
152 {
153 struct
154 {
155 unsigned over_report_mask:1;
156 unsigned opposite_x:1;
157 unsigned opposite_y:1;
158 unsigned opposite_xy:1;
159 unsigned line:1;
160 unsigned line_neg:1;
161 unsigned line_half:1;
162 unsigned middle_drv:1;
163
164 unsigned key_only_one:1;
165 unsigned key_line:1;
166 unsigned refe_rt:1;
167 unsigned refe_var:1;
168 unsigned base_median:1;
169 unsigned key_rt:1;
170 unsigned refe_reset:1;
171 unsigned sub_cross:1;
172
173 unsigned row_neg:1;
174 unsigned sub_line_coe:1;
175 unsigned sub_row_coe:1;
176 unsigned c2f_able:1;
177 unsigned thumb:1;
178 unsigned graph_h:1;
179 unsigned init_repeat:1;
180 unsigned near_reset_able:1;
181
182 unsigned emb_dead:1;
183 unsigned emb_point_mask:1;
184 unsigned interpolation:1;
185 unsigned sum2_able:1;
186 unsigned reduce_pin:1;
187 unsigned drv_order_ex:1;
188 unsigned id_over:1;
189 unsigned rev_1:1;
190 }other;
191 unsigned int all;
192 }gsl_FLAG_TYPE;
193
194 static gsl_POINT_TYPE point_array[POINT_DEEP][POINT_MAX];
195 static gsl_POINT_TYPE *point_pointer[PP_DEEP];
196 static gsl_POINT_TYPE *point_stretch[PS_DEEP];
197 static gsl_POINT_TYPE *point_report[PR_DEEP];
198 static gsl_POINT_TYPE point_now[POINT_MAX];
199 static gsl_DELAY_TYPE point_delay[POINT_MAX];
200 static int filter_deep[POINT_MAX];
201 static gsl_EDGE_TYPE point_edge;
202 static gsl_DECIMAL_TYPE point_decimal[POINT_MAX];
203
204 static unsigned int pressure_now[POINT_MAX];
205 static unsigned int pressure_array[PRESSURE_DEEP][POINT_MAX];
206 static unsigned int pressure_report[POINT_MAX];
207 static unsigned int *pressure_pointer[PRESSURE_DEEP];
208
209 #define pp point_pointer
210 #define ps point_stretch
211 #define pr point_report
212 #define point_predict pp[0]
213 #define pa pressure_pointer
214
215 static gsl_STATE_TYPE global_state;
216 static int inte_count;
217 static unsigned int csensor_count;
218 static unsigned int click_count[4];
219 static gsl_POINT_TYPE point_click[4];
220 static unsigned int double_click;
221 static int point_n;
222 static int point_num;
223 static int prev_num;
224 static int point_near;
225 static unsigned int point_shake;
226 static unsigned int reset_mask_send;
227 static unsigned int reset_mask_max;
228 static unsigned int reset_mask_count;
229 static gsl_FLAG_TYPE global_flag;
230 static unsigned int id_first_coe;
231 static unsigned int id_speed_coe;
232 static unsigned int id_static_coe;
233 static unsigned int average;
234 static unsigned int soft_average;
235 static unsigned int report_delay;
236 static unsigned int report_ahead;
237 static unsigned char median_dis[4];
238 static unsigned int shake_min;
239 static int match_y[2];
240 static int match_x[2];
241 static int ignore_y[2];
242 static int ignore_x[2];
243 static int screen_y_max;
244 static int screen_x_max;
245 static int point_num_max;
246 static unsigned int drv_num;
247 static unsigned int sen_num;
248 static unsigned int drv_num_nokey;
249 static unsigned int sen_num_nokey;
250 static unsigned int coordinate_correct_able;
251 static unsigned int coordinate_correct_coe_x[64];
252 static unsigned int coordinate_correct_coe_y[64];
253 static unsigned int edge_cut[4];
254 static unsigned int stretch_array[4*4*2];
255 static unsigned int shake_all_array[2*8];
256 static unsigned int reset_mask_dis;
257 static unsigned int reset_mask_type;
258 static unsigned int key_map_able;
259 static unsigned int key_range_array[8*3];
260 static int filter_able;
261 static unsigned int filter_coe[4];
262 static unsigned int multi_x_array[4],multi_y_array[4];
263 static unsigned int multi_group[4][64];
264 static int ps_coe[4][8],pr_coe[4][8];
265 static int point_repeat[2];
266 static int near_set[2];
267 static int diagonal;
268 // unsigned int key_dead_time ;
269 // unsigned int point_dead_time ;
270 // unsigned int point_dead_time2 ;
271 // unsigned int point_dead_distance ;
272 // unsigned int point_dead_distance2 ;
273 // unsigned int pressure_able;
274 // unsigned int pressure_save[POINT_MAX];
275 static unsigned int edge_first;
276 static unsigned int edge_first_coe;
277
278 static unsigned int point_corner;
279 //-------------------------------------------------
280 static unsigned int config_static[CONFIG_LENGTH];
281 //-------------------------------------------------
282 #ifdef GESTURE_ABLE
283
284 #define MAXSTACK 200
285 #define GesturePtNum 15
286 typedef union
287 {
288
289 struct
290 {
291 unsigned y:16;
292 unsigned x:12;
293 unsigned id:4;
294 } point_data;
295 unsigned int data_int;
296 }POINT_TYPE_DEFINE;
297
298 typedef struct
299 {
300 int top;
301 POINT_TYPE_DEFINE point_buff[MAXSTACK];
302 }TouchFinger;
303
304 static struct
305 {
306 int num[10];
307 int flag;
308 int position;
309 }vector_x_y[2];
310 static TouchFinger point_stack;
311 static int qushi_x[10];
312 static int qushi_y[10];
313 static int vector_change_x[MAXSTACK];
314 static int vector_change_y[MAXSTACK];
315 static int rate_weight[MAXSTACK];
316 static POINT_TYPE_DEFINE top,bottom,left,right;
317 static int Letter_width;
318 static int Letter_height;
319 static unsigned int max_x,min_x,max_y,min_y;
320 static char gesture_letter;
321 #endif
322 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
323 #ifdef GESTURE_LICH
324 #define GESTURE_BUF_SIZE 256
325 #define GESTURE_SIZE_REFE 255
326 #define GESTURE_SIZE_NUM 32
327 #define GESTURE_XY 0x1
328 #define GESTURE_DEAL 0x2
329 #define GESTURE_LRUD 0x4
330 #define GESTURE_ALL 0x7fffffff
331 typedef union
332 {
333 struct
334 {
335 unsigned y:12;
336 unsigned rev:4;
337 unsigned x:16;
338 }other;
339 unsigned int all;
340 }GESTURE_POINT_TYPE;
341 typedef struct
342 {
343 int coe;
344 int out;
345 unsigned int coor[GESTURE_SIZE_NUM/2];
346 }GESTURE_MODEL_TYPE;
347 //GESTURE_POINT_TYPE gesture_buf[GESTURE_BUF_SIZE];//gesture_buf
348 #define gesture_buf ((GESTURE_POINT_TYPE*)config_static)
349 #define gesture_standard ((GESTURE_POINT_TYPE*)(&config_static[GESTURE_BUF_SIZE]))
350 static int gesture_num,gesture_num_last;//gesture_num
351 static int gesture_dis_min;
352 static int gesture_deal;
353 static int gesture_last;
354 static int gesture_threshold[2];
355 static int x_scale;
356 static int y_scale;
357 static int double_down,double_up;
358 static const GESTURE_MODEL_TYPE * model_extern = NULL;
359 static int model_extern_len = 0;
360 static int GestureSqrt(int d);
361 static int GestureDistance(GESTURE_POINT_TYPE* d1,GESTURE_POINT_TYPE* d2,int sqrt_able);
362 static int GesturePush(GESTURE_POINT_TYPE* data);
363 static int GestureStretch(void);
364 static int GestureLength(void);
365 static int GestureDeal(void);
366 static int GestureModel(const GESTURE_MODEL_TYPE * model,int len,int threshold,int *out);
367 static int GestureMain(unsigned int data[],unsigned int pn);
368 static void GestureStandard(void);
369 static void GestureInit(void);
370 static void ChangeXY(void);
371 static int GestureLRUD(void);
372 static void GestureSet(unsigned int conf[]);
373 static const GESTURE_MODEL_TYPE model_default[]
374 ={
375 {0x10,'3',{
376 0x37170105,0x78580000,0xba990a03,0xedd92e14,0xb9d85347,0x7798655b,0x3657716b,0x1f156d74,
377 0x60406969,0xa2816f69,0xe3c28075,0xf9fbb899,0xc3e3e0d2,0x83a4f6ee,0x4262fffc,0x0021f7fd,}},
378 {0x10,'6',{
379 0xa2be0400,0x70881f10,0x4258402e,0x1d2e6c54,0x040ea084,0x0a01d6bc,0x381df9ec,0x7054fffd,
380 0xa88cfafe,0xdac2ddef,0xfff0b2cb,0xe2f78497,0xaac7747a,0x728e7472,0x3b56817b,0x0420968b,}},
381 {0x10,'7',{
382 0x12000001,0x37240000,0x5b490000,0x806e0000,0xa5930000,0xcab70000,0xefdc0300,0xf9fd1f0e,
383 0xe2ee3d30,0xc5d4564a,0xa7b76c61,0x8c9a8579,0x717e9f93,0x5863bbad,0x434cdbc9,0x3c3dffec,}},
384 {0x10,'8',{
385 0xdaff030c,0x8eb40000,0x41670c06,0x001c3116,0x431e5448,0x8f69635d,0xd1b58a6f,0xcedfd0af,
386 0x88acf5e6,0x3c62fffd,0x0718cdf1,0x341493aa,0x7a556d7d,0xc19e4f60,0xf9e51c3c,0xb5dc0005,}},
387 {0x10,'8',{
388 0x627d231e,0x2f49382c,0x03175a48,0x21098172,0x563c958c,0x856eb0a2,0x8f99dac4,0x5b76eee5,
389 0x243ffdf5,0x090ddbf4,0x2918acc2,0x4d3a8497,0x78636172,0xa38e4050,0xd0ba1f2e,0xffe7000f,}},
390 {0x10,'9',{
391 0xe8ff0715,0xb4ce0001,0x819a0500,0x4f68150c,0x1e362a1e,0x000c543c,0x270d7169,0x5b417273,
392 0x9076666d,0xbda74a5a,0xddcf1e36,0xc8d7321b,0xb4be634b,0xa4ac967d,0x959ccab0,0x898fffe4,}},
393 {0x10,'A',{
394 0xaeca000b,0x74900e02,0x41582d1b,0x182a5942,0x02099375,0x0600cfb1,0x2c15fcea,0x664af1fe,
395 0x957ec8dd,0xb5a894b0,0xc9bf5876,0xd7d31c3a,0xd4d75134,0xd3d38d6f,0xdbd4c9ab,0xffe9fce6,}},
396 {0x10,'A',{
397 0x8eab0102,0x56711307,0x2c3f3a25,0x0e1b6b51,0x0004a689,0x0e02ddc2,0x3e22fbf2,0x725be8fa,
398 0x9284b6d0,0xa69d7f9b,0xb3ae4562,0xb7b80b28,0xa7a6290c,0xb1aa6346,0xd0be947d,0xffe7bba7,}},
399 {0x10,'B',{
400 0x56591a00,0x474e4e35,0x343f8168,0x242cb59c,0x0f1be7ce,0x170ddbf4,0x3c25b4c4,0x6e549ca6,
401 0xa3889799,0xd8bd9d96,0xfcf1bea8,0xd3e9e4d4,0xa0baf6f0,0x6b85fcfa,0x3650fffd,0x001bfbff,}},
402 {0x10,'C',{
403 0xfaff2337,0xdaec0913,0xb0c50003,0x879c0500,0x5f720f09,0x3b4c271a,0x1d2b4534,0x08116a56,
404 0x0003937f,0x0a03bca8,0x2515ddce,0x4b38f2e8,0x7560fff9,0x9e89f7fd,0xc6b2e8f0,0xeed9d7df,}},
405 {0x10,'C',{
406 0xacbf0100,0x86990a04,0x64751b12,0x45533225,0x2b375141,0x17217160,0x080f9582,0x0103bba8,
407 0x0200e2cf,0x200ff9f1,0x4633fefc,0x6c59ffff,0x9380fcfd,0xb9a6f4f9,0xdccbe4ed,0xffeeceda,}},
408 {0x10,'C',{
409 0x57670a00,0x3a492116,0x222d3d2e,0x0f175e4d,0x0408816f,0x0001a693,0x0300cab8,0x0e07eddc,
410 0x2f1dfefb,0x5241f5fc,0x7362e2ec,0x8e80c9d6,0xa89bafbc,0xc3b594a1,0xe1d27e89,0xfff06673,}},
411 {0x10,'D',{
412 0x99b5858f,0x5f7c8883,0x28429c8f,0x010fc6ab,0x240cf4e1,0x5d41fefb,0x957af1fc,0xc1adcbe0,
413 0xd2cc92af,0xd3d25875,0xd7d71f3b,0xd7d71b02,0xd4d75538,0xd4d48f72,0xe1d9c9ac,0xffe6f4e6,}},
414 {0x10,'E',{
415 0x391c948f,0x73569595,0xad908a92,0xddc8677e,0xf1ee304d,0xc3dd0d1b,0x89a70002,0x536d1304,
416 0x233b3a25,0x08137053,0x0301aa8d,0x220edcc6,0x573af7ee,0x9174fffc,0xcaaef6ff,0xffe5dbeb,}},
417 {0x10,'G',{
418 0xaaca0000,0x698a0000,0x2a491106,0x000f4226,0x23067061,0x64437674,0xa3836874,0xdac04759,
419 0xfaec0b2a,0xfefb401f,0xffff8160,0xf5fdc0a1,0xc9e9eedf,0x89a9fff9,0x4869faff,0x0928e3f3,}},
420 {0x10,'G',{
421 0xeaff1421,0xb9d20308,0x88a00000,0x57700f05,0x2b3f2618,0x09174d37,0x00037f66,0x0d05af97,
422 0x2a1adac7,0x5940ede5,0x8b72f2f3,0xbca4e9ee,0xe4d2cbde,0xfbf09cb3,0xf5f8ceb5,0xe9f1ffe6,}},
423 {0x10,'H',{
424 0x03021300,0x06053a26,0x0b0a604d,0x0b0b8774,0x0a0bae9a,0x0506d4c1,0x0002fbe8,0x1104e0f0,
425 0x2e1ec3d1,0x503dadb5,0x7764a5a7,0x9e8aa1a2,0xc4b1a3a0,0xead8ada8,0xfff8d1bd,0xfffff8e4,}},
426 {0x10,'K',{
427 0x1d1a2000,0x171a6040,0x1114a080,0x060edfc0,0x1100e2ff,0x3420a8c5,0x6f4f8b95,0xaf8f8285,
428 0xefcf8683,0xe1fcb3a0,0xa0c1c2bb,0x6080c6c5,0x2c40c9c7,0x6c4cd8d1,0xac8ceadf,0xedccfef3,}},
429 {0x10,'K',{
430 0x22341900,0x15185436,0x0e119072,0x0c0cccae,0x0709f6ea,0x0a07b9d8,0x2918859e,0x5b406170,
431 0x90796658,0x627c8b7c,0x2a47a79a,0x110db8b1,0x4d2fbfbc,0x896bcac4,0xc3a6d9d1,0xffe1ede2,}},
432 {0x10,'L',{
433 0x3f4a0c00,0x35372c1c,0x2c314d3d,0x26296e5d,0x1b218e7e,0x1316af9f,0x0910cfc0,0x0004f1e0,
434 0x1605ffff,0x3727ffff,0x5848ffff,0x7a69fdff,0x9b8afcfd,0xbcabfcfc,0xddcdfafb,0xffeef9f9,}},
435 {0x10,'M',{
436 0x0900e0ff,0x2017a0c0,0x3a296381,0x4e442443,0x5a583010,0x6b5f6f4f,0x7471ae8f,0x7977eece,
437 0x8c80c5e5,0xa19886a5,0xbaad4766,0xd3c70a29,0xddda3516,0xe7e17555,0xf4f0b494,0xfffaf4d4,}},
438 {0x10,'N',{
439 0x0400e7ff,0x130bb8cf,0x281e89a1,0x38305a71,0x51452c43,0x675d1d13,0x68684e36,0x6b697f66,
440 0x726fb097,0x7875e0c8,0x907ee8f8,0xa79ebbd2,0xbfb38fa4,0xd1c95f77,0xe6da3148,0xfff20019,}},
441 {0x10,'O',{
442 0x2e3f311f,0x101e5c46,0x03088f76,0x0001c2a8,0x1e08e7da,0x4f35fdf4,0x8168fcff,0xb39beef5,
443 0xdac7cedf,0xf3e9a0b8,0xfef96d87,0xf9ff3c54,0xdaec1326,0xaac30108,0x77900100,0x465e1407,}},
444 {0x10,'O',{
445 0xd0e30213,0x9cb60000,0x68820c05,0x384f2416,0x17254c36,0x040c8066,0x0001b49a,0x1305e4ce,
446 0x442bfaf0,0x785efffe,0xab92f1f9,0xd3c1cfe3,0xf1e3a1b9,0xfffa6e88,0xf8ff3b54,0xd5e81024,}},
447 {0x10,'O',{
448 0x000f768a,0x0900455d,0x2b171e30,0x5a420611,0x8d740100,0xbca5170b,0xe3d23824,0xfcf2644c,
449 0xfaff977e,0xe3f0c4af,0xbdd2e6d7,0x8ea7faf2,0x5b74fefe,0x2e44e9f6,0x0a1bc2d6,0x02028fa9,}},
450 {0x10,'O',{
451 0x829c0900,0x4e682315,0x24384a34,0x08157c61,0x0002b598,0x0d03edd1,0x4326fffd,0x7a5feef8,
452 0xab93cfe0,0xd5c1a7bd,0xf4e67690,0xfbff3d5a,0xcfec1b26,0x96b31818,0x5e7a251d,0x28433b2f,}},
453 {0x10,'O',{
454 0x381e5e68,0x6e535156,0xa388504f,0xd8be5e56,0xf9ed876d,0xf9fcbaa1,0xd8ece5d2,0xa5c0f9f2,
455 0x708bfffd,0x3b55fbfe,0x1423d7ed,0x0006a4bf,0x09027089,0x26154157,0x50391e2e,0x7e670010,}},
456 {0x10,'O',{
457 0x8670020b,0xb8a01307,0xe3ce3423,0xf8f0664c,0xfffc9b81,0xf1faceb5,0xcee4f4e5,0x9ab4fffb,
458 0x657fffff,0x364ceaf8,0x1623c0d7,0x00098ea7,0x06015973,0x24122e41,0x4d380c1c,0x82670104,}},
459 {0x10,'S',{
460 0xb7cf0001,0x869e0301,0x556d0905,0x273e1f12,0x0311442c,0x2009665a,0x5138726b,0x826a7876,
461 0xb39b807b,0xdfcb998b,0xfff5bea7,0xdcf2ded0,0xadc6f1e8,0x7c94fbf7,0x4b63fffd,0x1932ffff,}},
462 {0x10,'S',{
463 0xcbde0200,0xa8ba1209,0x8597241a,0x6a753f2f,0x806c5751,0xa6935e5b,0xccb96662,0xf2e0746b,
464 0xfcff9482,0xe0f0b2a6,0xbdcfc2bb,0x97abd1c9,0x7385ddd7,0x4c60e8e3,0x273af4ee,0x0014fff9,}},
465 {0x10,'U',{
466 0x050d2209,0x0001573c,0x03008c71,0x1106bfa6,0x2f1bebda,0x604ae1f0,0x8873bccd,0xa59990a8,
467 0xbcb05f78,0xcdc72c46,0xd0d00911,0xc9cb3e24,0xc6c87359,0xc9c6a88d,0xd8d2ddc2,0xffe4fff6,}},
468 {0x10,'V',{
469 0x09000f00,0x1911301f,0x27205240,0x342d7563,0x413a9785,0x4f47b9a8,0x6057d9c9,0x7569f9ea,
470 0x9486f4ff,0xa99fd5e5,0xb8b0b4c5,0xc9c093a3,0xdbd17484,0xe9e35263,0xf5ef2f41,0xfff90b1d,}},
471 {0x10,'V',{
472 0x08001908,0x160f3b2b,0x251d5d4c,0x312b806f,0x3e37a392,0x4843c6b5,0x524de9d8,0x5b58f2fb,
473 0x6560cfe0,0x776dafbf,0x8a8090a0,0x9d947080,0xb4a85361,0xccc03745,0xe6d91d2a,0xfff2000e,}},
474 {0x10,'W',{
475 0x06001f00,0x110c5f3f,0x1c189f7f,0x2822debe,0x4131e3fd,0x554ba4c3,0x655c6484,0x786f2444,
476 0x847f2f0f,0x8a866f4f,0x928eae8f,0x9e99eece,0xbaacd0ee,0xd5c893b3,0xebe05373,0xfff61333,}},
477 {0x10,'W',{
478 0xf7ff2000,0xe4ed6040,0xd5dba181,0xbdcbe0c0,0xa0aad3f3,0x909892b3,0x848a5272,0x80811131,
479 0x777d3d1d,0x636d7e5e,0x535bbf9e,0x3c48fdde,0x272fc1e2,0x121a82a2,0x030a4161,0x00020021,}},
480 {0x10,'Y',{
481 0x16000b13,0x442d0303,0x4b48341b,0x61505e4b,0x91795c62,0xbca74551,0xe1d02637,0xfcf40c14,
482 0xe8f13922,0xdbe16951,0xd6d99a82,0xced3cbb2,0xb0c4f0e1,0x7f98fbf7,0x4e67fefd,0x1d36fdff,}},
483 {0x10,'Z',{
484 0x30160200,0x644a0403,0x997f0303,0xcdb30202,0xe7e80d00,0xc4d63622,0x9bb05c4a,0x73857f6c,
485 0x5061a893,0x293eccbb,0x0013f2dd,0x2d13fcfd,0x6248f6f8,0x967cf1f3,0xcbb1edef,0xffe5f1ec,}},
486 //--------------------------------------------------------------------------------------------
487 {0x10,0x1001,{
488 0x0003ecff,0x0502c6d9,0x0b099fb2,0x1410788c,0x221b5265,0x362b2f40,0x5341121d,0x7966020a,
489 0xa08d0100,0xc3b3170b,0xd9ce3a28,0xede25f4d,0xf4f28672,0xfaf6ac99,0xfffdd3c0,0xfffffae6,}},
490 {0x10,0x1002,{
491 0x1900847d,0x4c328785,0x7f658b88,0xb198898b,0xe3cb7f88,0xf8f24f68,0xecf81d35,0xbfd9010b,
492 0x90a61504,0x8186462d,0x7c7d7960,0x7f7bac93,0x8883dfc6,0xaf97fff4,0xdcc7eafa,0xffeec1d7,}},
493 {0x10,0x1003,{
494 0x7543141a,0xd7a82e17,0xf8f78f5c,0xc6e6e9bf,0x6497f8fa,0x1338b3db,0x03024f82,0x4a1c0620,
495 0xaf7c1001,0xf8da582b,0xeafebc8b,0x9acbfbe6,0x3868eeff,0x0a1892c4,0x2712305f,0x85520e11,}},
496 {0x10,0x1004,{
497 0x04003204,0x120b8e60,0x1714ebbd,0x2f27b8e6,0x43385b89,0x5b4c032d,0x6a666032,0x7770bc8e,
498 0x8c82b8e6,0x9b945c8a,0xaea2012d,0xbbb75d2f,0xc9c1ba8c,0xe3d5bce7,0xf1ea5f8d,0xfff50231,}},
499 {0x10,0x1005,{
500 0x1900020a,0x4d330400,0x7c65180a,0xa18f3f2b,0xb3ac7258,0xbcb8a58b,0xb0b9d7bf,0x8aa0fcec,
501 0x5971f2fd,0x414bc2db,0x433f8ea8,0x534a5d76,0x71613246,0x9d85101e,0xd0b60609,0xffea1409,}},
502 {0x10,0x1006,{
503 0xdeff0714,0x9abc0002,0x57790a02,0x1d373018,0x01076d4b,0x2f0f988a,0x72519c9c,0xb2948b9c,
504 0xa3bc576b,0x60815653,0x26417963,0x020eb191,0x2005e7d3,0x6442fbf4,0xa785fbff,0xebc9e7f3,}},
505 {0x10,0x1007,{
506 0xf6ff0600,0xe4ed140c,0xd5dd261d,0xc5cd362e,0xb3bc463e,0xa2aa574e,0x939a6860,0x83897970,
507 0x747c8a82,0x646c9c93,0x525baca4,0x434abdb4,0x333bcfc6,0x222addd5,0x121beee6,0x0009fff6,}},
508 {0x10,0x1008,{
509 0x09000900,0x19111b13,0x28202d24,0x39303d35,0x49424e45,0x5a515d56,0x6b626d65,0x7d747b74,
510 0x8e868b82,0x9d969c93,0xaca4aea5,0xbcb4bfb6,0xcac4d1c7,0xdbd2e1d9,0xece3f1e9,0xfff5fff8,}},
511 {0x10,0x1009,{
512 0x0a00faff,0x1d14edf4,0x2e25dce5,0x3e36cbd4,0x4e44bac2,0x5f57aab2,0x6f679aa2,0x7f778890,
513 0x8c85757e,0x9c94636b,0xaba3515a,0xbbb2414a,0xcbc33039,0xddd31f28,0xeee51119,0xfff7000a,}},
514 {0x10,0x100a,{
515 0xf4fffaff,0xe1eaeff6,0xd1d9dde6,0xc1cacdd5,0xb4bbbac3,0xa2aca8b0,0x929a99a1,0x83888791,
516 0x767d747d,0x666e636b,0x535c545e,0x444d424b,0x333d323a,0x242b212a,0x141c0f18,0x000a0008,}},
517 {0x10,0x100b,{
518 0x30000208,0x90600200,0xf1c11e0c,0xb5e64d3f,0x55855653,0x32245556,0x93625756,0xf1c3745e,
519 0xbaeaa997,0x598ab2b0,0x0f29aab1,0x7040a8a7,0xd1a0b8ae,0xd0f8ecd0,0x6f9ffcf5,0x0e3ffcff,}},
520 {0x10,0x100c,{
521 0x2600140c,0x66494226,0x827c8d66,0x6d80d8b4,0x284ffaf4,0x0a0ab9e0,0x411f8097,0x8e689182,
522 0xd6b47f94,0xf9f23960,0xd5f80012,0x91af270a,0x7e83734c,0x7e7dc19a,0xb490fae5,0xffdbe9fe,}},
523 {0x10,0x100d,{
524 0x768e0c00,0x465e2619,0x192f4635,0x0107745a,0x32178a85,0x674d858a,0x9b81747d,0xccb45c69,
525 0xf7e33b4d,0xebfd0d21,0xb6d00004,0x939e270d,0x888d5d42,0x83859378,0x7c80c9ae,0x6c75ffe4,}},
526 {0x10,0x100e,{
527 0xb3bd1000,0x9ea82d1e,0x87924a3b,0x6f7b6658,0x56628375,0x3e4a9e91,0x2934bcad,0x1720ddcd,
528 0x010bfced,0x2513ffff,0x4937fdff,0x6d5bf9fa,0x9280f4f7,0xb6a4f0f1,0xdac8eeef,0xffececed,}},
529 };
530 #endif
531 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
SortBubble(int t[],int size)532 static void SortBubble(int t[],int size)
533 {
534 int temp = 0;
535 int m,n;
536 for(m=0;m<size;m++)
537 {
538 for(n=m+1;n<size;n++)
539 {
540 temp = t[m];
541 if (temp>t[n])
542 {
543 t[m] = t[n];
544 t[n] = temp;
545 }
546 }
547 }
548 }
abs(int i)549 int abs(int i){
550 if(i<0)
551 return ~(--i);
552 return i;
553 }
Sqrt(int d)554 static int Sqrt(int d)
555 {
556 int ret = 0;
557 int i;
558 for(i=14;i>=0;i--)
559 {
560 if((ret + (0x1<<i))*(ret + (0x1<<i)) <= d)
561 ret |= (0x1<<i);
562 }
563 return ret;
564 }
565
PointCoor(void)566 static void PointCoor(void)
567 {
568 int i;
569 point_num &= 0xff;
570 for(i=0;i<point_num;i++)
571 {
572 if(global_state.other.ex)
573 point_now[i].all &= (FLAG_COOR_EX | FLAG_KEY | FLAG_ABLE);
574 else
575 point_now[i].all &= (FLAG_COOR | FLAG_KEY | FLAG_ABLE);
576 }
577 }
PointRepeat(void)578 static void PointRepeat(void)
579 {
580 int i,j;
581 int x,y;
582 int x_min,x_max,y_min,y_max;
583 int pn;
584 if(point_near)
585 point_near --;
586 if(prev_num > point_num)
587 point_near = 8;
588 if(point_repeat[0]==0 || point_repeat[1]==0)
589 {
590 if(point_near)
591 pn = 96;
592 else
593 pn = 32;
594 }
595 else
596 {
597 if(point_near)
598 pn = point_repeat[1];
599 else
600 pn = point_repeat[0];
601 }
602 for(i=0;i<POINT_MAX;i++)
603 {
604 if(point_now[i].all == 0)
605 continue;
606 if (point_now[i].other.key)
607 continue;
608 x_min = point_now[i].other.x - pn;
609 x_max = point_now[i].other.x + pn;
610 y_min = point_now[i].other.y - pn;
611 y_max = point_now[i].other.y + pn;
612 for(j=i+1;j<POINT_MAX;j++)
613 {
614 if(point_now[j].all == 0)
615 continue;
616 if (point_now[j].other.key)
617 continue;
618 x = point_now[j].other.x;
619 y = point_now[j].other.y;
620 if(x>x_min && x<x_max && y>y_min && y<y_max)
621 {
622 point_now[i].other.x =
623 (point_now[i].other.x +
624 point_now[j].other.x + 1) / 2;
625 point_now[i].other.y =
626 (point_now[i].other.y +
627 point_now[j].other.y + 1) / 2;
628 point_now[j].all = 0;
629 i--;
630 point_near = 8;
631 break;
632 }
633 }
634 }
635 }
636
PointPointer(void)637 static void PointPointer(void)
638 {
639 int i,pn;
640 point_n ++ ;
641 if(point_n >= PP_DEEP * PS_DEEP * PR_DEEP * PRESSURE_DEEP)
642 point_n = 0;
643 pn = point_n % PP_DEEP;
644 for(i=0;i<PP_DEEP;i++)
645 {
646 pp[i] = point_array[pn];
647 if(pn == 0)
648 pn = PP_DEEP - 1;
649 else
650 pn--;
651 }
652 pn = point_n % PS_DEEP;
653 for(i=0;i<PS_DEEP;i++)
654 {
655 ps[i] = point_array[pn+PP_DEEP];
656 if(pn == 0)
657 pn = PS_DEEP - 1;
658 else
659 pn--;
660 }
661 pn = point_n % PR_DEEP;
662 for(i=0;i<PR_DEEP;i++)
663 {
664 pr[i] = point_array[pn+PP_DEEP+PS_DEEP];
665 if(pn == 0)
666 pn = PR_DEEP - 1;
667 else
668 pn--;
669 }
670 pn = point_n % PRESSURE_DEEP;
671 for(i=0;i<PRESSURE_DEEP;i++)
672 {
673 pa[i] = pressure_array[pn];
674 if(pn == 0)
675 pn = PRESSURE_DEEP - 1;
676 else
677 pn--;
678 }
679 //------------------------------------------------------
680 pn = 0;
681 for(i=0;i<POINT_MAX;i++)
682 {
683 if(point_now[i].all)
684 point_now[pn++].all = point_now[i].all;
685 pp[0][i].all = 0;
686 ps[0][i].all = 0;
687 pr[0][i].all = 0;
688 }
689 point_num = pn;
690 for(i=pn;i<POINT_MAX;i++)
691 point_now[i].all = 0;
692 }
693
CCO(unsigned int x,unsigned int coe[],int k)694 static unsigned int CCO(unsigned int x,unsigned int coe[],int k)
695 {
696 if(k == 0)
697 {
698 if(x & 32)
699 return (x & ~31)+(31 - (coe[31-(x&31)] & 31));
700 else
701 return (x & ~31)+(coe[x&31] & 31);
702 }
703 if(k == 1)
704 {
705 if(x & 64)
706 return (x & ~63)+(63 - (coe[63-(x&63)] & 63));
707 else
708 return (x & ~63)+(coe[x&63] & 63);
709 }
710 if(k == 2)
711 {
712 return (x & ~63)+(coe[x&63] & 63);
713 }
714 return 0;
715 }
716
CoordinateCorrect(void)717 static void CoordinateCorrect(void)
718 {
719 typedef struct
720 {
721 unsigned int range;
722 unsigned int group;
723 }MULTI_TYPE;
724 #ifdef LINE_MULTI_SIZE
725 #define LINE_SIZE LINE_MULTI_SIZE
726 #else
727 #define LINE_SIZE 4
728 #endif
729 int i,j;
730 unsigned int *px[LINE_SIZE+1],*py[LINE_SIZE+1];
731 MULTI_TYPE multi_x[LINE_SIZE],multi_y[LINE_SIZE];
732 unsigned int edge_size = 64;
733 int kx,ky;
734 if((coordinate_correct_able&0xf) == 0)
735 return;
736 kx = (coordinate_correct_able>>4)&0xf;
737 ky = (coordinate_correct_able>>8)&0xf;
738 px[0] = coordinate_correct_coe_x;
739 py[0] = coordinate_correct_coe_y;
740 for(i=0;i<LINE_SIZE;i++)
741 {
742 px[i+1] = NULL;
743 py[i+1] = NULL;
744 }
745 if(kx == 3 || ky == 3)
746 {
747 i=0;
748 if(((coordinate_correct_able>>4)&0xf) == 3)
749 px[1] = multi_group[i++];
750 if(((coordinate_correct_able>>8)&0xf) == 3)
751 py[1] = multi_group[i++];
752 }
753 else
754 {
755 for(i=0;i<LINE_SIZE;i++)
756 {
757 multi_x[i].range = multi_x_array[i] & 0xffff;
758 multi_x[i].group = multi_x_array[i] >> 16;
759 multi_y[i].range = multi_y_array[i] & 0xffff;
760 multi_y[i].group = multi_y_array[i] >> 16;
761 }
762 j=1;
763 for(i=0;i<LINE_SIZE;i++)
764 if(multi_x[i].range && multi_x[i].group<LINE_SIZE)
765 px[j++] = multi_group[multi_x[i].group];
766 j=1;
767 for(i=0;i<LINE_SIZE;i++)
768 if(multi_y[i].range && multi_y[i].group<LINE_SIZE)
769 py[j++] = multi_group[multi_y[i].group];
770 }
771 for(i=0;i<(int)point_num && i<POINT_MAX;i++)
772 {
773 if(point_now[i].all==0)
774 break;
775 if (point_now[i].other.key != 0)
776 continue;
777 if (point_now[i].other.x >= edge_size &&
778 point_now[i].other.x <= drv_num_nokey * 64 - edge_size)
779 {
780 if(kx == 3)
781 {
782 if (point_now[i].other.x & 64)
783 point_now[i].other.x = CCO(point_now[i].other.x, px[0], 2);
784 else
785 point_now[i].other.x = CCO(point_now[i].other.x, px[1], 2);
786 }
787 else
788 {
789 for(j=0;j<LINE_SIZE+1;j++)
790 {
791 if (!(j >= LINE_SIZE ||
792 px[j + 1] == NULL ||
793 multi_x[j].range == 0 ||
794 point_now[i].other.x < multi_x[j].range))
795 continue;
796 point_now[i].other.x = CCO(point_now[i].other.x, px[j], kx);
797 break;
798 }
799 }
800 }
801 if (point_now[i].other.y >= edge_size &&
802 point_now[i].other.y <= sen_num_nokey * 64 - edge_size)
803 {
804 if(ky == 3)
805 {
806 if (point_now[i].other.y & 64)
807 point_now[i].other.y = CCO(point_now[i].other.y, py[0], 2);
808 else
809 point_now[i].other.y = CCO(point_now[i].other.y, py[1], 2);
810 }
811 else
812 {
813 for(j=0;j<LINE_SIZE+1;j++)
814 {
815 if (!(j >= LINE_SIZE ||
816 py[j + 1] == NULL ||
817 multi_y[j].range == 0 ||
818 point_now[i].other.y < multi_y[j].range))
819 continue;
820 point_now[i].other.y = CCO(point_now[i].other.y, py[j], ky);
821 break;
822 }
823 }
824 }
825 }
826 #undef LINE_SIZE
827 }
828
PointPredictOne(unsigned int n)829 static void PointPredictOne(unsigned int n)
830 {
831 pp[0][n].all = pp[1][n].all & FLAG_COOR;
832 pp[0][n].other.predict = 0;
833 }
834
PointPredictTwo(unsigned int n)835 static void PointPredictTwo(unsigned int n)
836 {
837 unsigned int t;
838 pp[0][n].all = 0;
839 t = pp[1][n].other.x * 2;
840 if (t > pp[2][n].other.x)
841 t -= pp[2][n].other.x;
842 else
843 t = 0;
844 if(t > 0xffff)
845 pp[0][n].other.x = 0xffff;
846 else
847 pp[0][n].other.x = t;
848 t = pp[1][n].other.y * 2;
849 if (t > pp[2][n].other.y)
850 t -= pp[2][n].other.y;
851 else
852 t = 0;
853 if(t > 0xfff)
854 pp[0][n].other.y = 0xfff;
855 else
856 pp[0][n].other.y = t;
857 pp[0][n].other.predict = 1;
858 }
859
PointPredictThree(unsigned int n)860 static void PointPredictThree(unsigned int n)
861 {
862 unsigned int t,t2;
863 pp[0][n].all = 0;
864 t = pp[1][n].other.x * 5 + pp[3][n].other.x;
865 t2 = pp[2][n].other.x * 4;
866 if(t > t2)
867 t -= t2;
868 else
869 t = 0;
870 t /= 2;
871 if(t > 0xffff)
872 pp[0][n].other.x = 0xffff;
873 else
874 pp[0][n].other.x = t;
875 t = pp[1][n].other.y * 5 + pp[3][n].other.y;
876 t2 = pp[2][n].other.y * 4;
877 if(t > t2)
878 t -= t2;
879 else
880 t = 0;
881 t /= 2;
882 if(t > 0xfff)
883 pp[0][n].other.y = 0xfff;
884 else
885 pp[0][n].other.y = t;
886 pp[0][n].other.predict = 1;
887 }
888
PointPredict(void)889 static void PointPredict(void)
890 {
891 int i;
892 for(i=0;i<POINT_MAX;i++)
893 {
894 if(pp[1][i].all != 0)
895 {
896 if (global_state.other.interpolation
897 || pp[2][i].all == 0
898 || pp[2][i].other.fill != 0
899 || pp[3][i].other.fill != 0
900 || pp[1][i].other.key != 0
901 || global_state.other.only)
902 {
903 PointPredictOne(i);
904 }
905 else if(pp[2][i].all != 0)
906 {
907 if(pp[3][i].all != 0)
908 PointPredictThree(i);
909 else
910 PointPredictTwo(i);
911 }
912 pp[0][i].all |= FLAG_FILL;
913 pa[0][i] = pa[1][i];
914 }
915 else
916 pp[0][i].all = 0x0fff0fff;
917 if (pp[1][i].other.key)
918 pp[0][i].all |= FLAG_KEY;
919 }
920 }
921
PointDistance(gsl_POINT_TYPE * p1,gsl_POINT_TYPE * p2)922 static unsigned int PointDistance(gsl_POINT_TYPE *p1,gsl_POINT_TYPE *p2)
923 {
924 int a,b,ret;
925 a = p1->dis.x;
926 b = p2->dis.x;
927 ret = (a-b)*(a-b);
928 a = p1->dis.y;
929 b = p2->dis.y;
930 ret += (a-b)*(a-b);
931 return ret;
932 }
933
DistanceInit(gsl_DISTANCE_TYPE * p)934 static void DistanceInit(gsl_DISTANCE_TYPE *p)
935 {
936 int i;
937 unsigned int *p_int = &(p->d[0][0]);
938 for(i=0;i<POINT_MAX*POINT_MAX;i++)
939 *p_int++ = 0x7fffffff;
940 }
941
DistanceMin(gsl_DISTANCE_TYPE * p)942 static int DistanceMin(gsl_DISTANCE_TYPE *p)
943 {
944 int i,j;
945 p->min = 0x7fffffff;
946 for(j=0;j<POINT_MAX;j++)
947 {
948 for(i=0;i<POINT_MAX;i++)
949 {
950 if(p->d[j][i] < p->min)
951 {
952 p->i = i;
953 p->j = j;
954 p->min = p->d[j][i];
955 }
956 }
957 }
958 if(p->min == 0x7fffffff)
959 return 0;
960 return 1;
961 }
962
DistanceIgnore(gsl_DISTANCE_TYPE * p)963 static void DistanceIgnore(gsl_DISTANCE_TYPE *p)
964 {
965 int i,j;
966 for(i=0;i<POINT_MAX;i++)
967 p->d[p->j][i] = 0x7fffffff;
968 for(j=0;j<POINT_MAX;j++)
969 p->d[j][p->i] = 0x7fffffff;
970 }
971
SpeedGet(int d)972 static int SpeedGet(int d)
973 {
974 int i;
975 for(i=8;i>0;i--)
976 {
977 if(d > 0x100<<i)
978 break;
979 }
980 return i;
981 }
982
PointId(void)983 static void PointId(void)
984 {
985 int i,j;
986 gsl_DISTANCE_TYPE distance;
987 unsigned int id_speed[POINT_MAX];
988 DistanceInit(&distance);
989 for(i=0;i<POINT_MAX;i++)
990 {
991 if (pp[0][i].other.predict == 0 || pp[1][i].other.fill != 0)
992 id_speed[i] = id_first_coe;
993 else
994 id_speed[i] = SpeedGet( PointDistance(&pp[1][i],&pp[0][i]) );
995 }
996 for(i=0;i<POINT_MAX;i++)
997 {
998 if(pp[0][i].all == FLAG_COOR)
999 continue;
1000 for(j=0;j<point_num && j<POINT_MAX;j++)
1001 {
1002 distance.d[j][i] = PointDistance(&point_now[j],&pp[0][i]);
1003 }
1004 }
1005 if(point_num == 0)
1006 return;
1007 if (global_state.other.only)
1008 {
1009 //do
1010 {
1011 if(DistanceMin(&distance))
1012 {
1013 if (pp[1][0].all != 0 &&
1014 pp[1][0].other.key !=
1015 point_now[distance.j].other.key)
1016 {
1017 DistanceIgnore(&distance);
1018 return;
1019 //continue;
1020 }
1021 pp[0][0].all = point_now[distance.j].all;
1022 }
1023 else
1024 pp[0][0].all = point_now[0].all;
1025 for(i=0;i<POINT_MAX;i++)
1026 point_now[i].all = 0;
1027 }
1028 //while(0);
1029 point_num = 1;
1030 }
1031 else
1032 {
1033 for (j=0;j<point_num && j<POINT_MAX;j++)
1034 {
1035 if (DistanceMin(&distance) == 0)
1036 break;
1037 if (distance.min >= (id_static_coe +
1038 id_speed[distance.i] * id_speed_coe) /**average/(soft_average+1)*/)
1039 {
1040 //point_now[distance.j].id = 0xf;//new id
1041 continue;
1042 }
1043 pp[0][distance.i].all = point_now[distance.j].all;
1044 pa[0][distance.i] = pressure_now[distance.j];
1045 point_now[distance.j].all = 0;
1046 DistanceIgnore(&distance);
1047 }
1048 }
1049 }
1050
ClearLenPP(int i)1051 static int ClearLenPP(int i)
1052 {
1053 int n;
1054 for(n=0;n<PP_DEEP;n++)
1055 {
1056 if(pp[n][i].all)
1057 break;
1058 }
1059 return n;
1060 }
PointNewId(void)1061 static void PointNewId(void)
1062 {
1063 int id,j;
1064 for(j=0;j<POINT_MAX;j++)
1065 if((pp[0][j].all & FLAG_COOR) == FLAG_COOR)
1066 pp[0][j].all = 0;
1067 for(j=0;j<POINT_MAX;j++)
1068 {
1069 if(point_now[j].all != 0)
1070 {
1071 if (point_now[j].other.able)
1072 continue;
1073 for(id=1;id<=POINT_MAX;id++)
1074 {
1075 if(ClearLenPP(id-1) > (int)(1+1))
1076 {
1077 pp[0][id-1].all = point_now[j].all;
1078 pa[0][id-1] = pressure_now[j];
1079 point_now[j].all = 0;
1080 break;
1081 }
1082 }
1083 }
1084 }
1085 }
1086
PointOrder(void)1087 static void PointOrder(void)
1088 {
1089 int i;
1090 for(i=0;i<POINT_MAX;i++)
1091 {
1092 if (pp[0][i].other.fill == 0)
1093 continue;
1094 if (pp[1][i].all == 0 || pp[1][i].other.fill != 0 || filter_able == 0 || filter_able == 1)
1095 {
1096 pp[0][i].all = 0;
1097 pressure_now[i] = 0;
1098 }
1099 }
1100 }
1101
PointCross(void)1102 static void PointCross(void)
1103 {
1104 unsigned int i,j;
1105 unsigned int t;
1106 for(j=0;j<POINT_MAX;j++)
1107 {
1108 for(i=j+1;i<POINT_MAX;i++)
1109 {
1110 if(pp[0][i].all == 0 || pp[0][j].all == 0
1111 || pp[1][i].all == 0 || pp[1][j].all == 0)
1112 continue;
1113 if (((pp[0][j].other.x < pp[0][i].other.x && pp[1][j].other.x > pp[1][i].other.x)
1114 || (pp[0][j].other.x > pp[0][i].other.x && pp[1][j].other.x < pp[1][i].other.x))
1115 && ((pp[0][j].other.y < pp[0][i].other.y && pp[1][j].other.y > pp[1][i].other.y)
1116 || (pp[0][j].other.y > pp[0][i].other.y && pp[1][j].other.y < pp[1][i].other.y)))
1117 {
1118 t = pp[0][i].other.x;
1119 pp[0][i].other.x = pp[0][j].other.x;
1120 pp[0][j].other.x = t;
1121 t = pp[0][i].other.y;
1122 pp[0][i].other.y = pp[0][j].other.y;
1123 pp[0][j].other.y = t;
1124 }
1125 }
1126 }
1127 }
1128
GetPointNum(gsl_POINT_TYPE * pt)1129 static void GetPointNum(gsl_POINT_TYPE *pt)
1130 {
1131 int i;
1132 point_num = 0;
1133 for(i=0;i<POINT_MAX;i++)
1134 if(pt[i].all != 0)
1135 point_num++;
1136 }
1137
PointDelay(void)1138 static void PointDelay(void)
1139 {
1140 int i,j;
1141 for(i=0;i<POINT_MAX;i++)
1142 {
1143 if(report_delay == 0)
1144 {//
1145 point_delay[i].all = 0;
1146 if(pp[0][i].all)
1147 point_delay[i].other.able = 1;
1148 continue;
1149 }
1150 if (pp[0][i].all != 0 &&
1151 point_delay[i].other.init == 0 &&
1152 point_delay[i].other.able == 0)
1153 {
1154 if(point_num == 0)
1155 continue;
1156 point_delay[i].other.delay = (report_delay >> 3 *
1157 ((point_num>10 ? 10 : point_num) - 1)) & 0x7;
1158 point_delay[i].other.report = (report_ahead >> 3 *
1159 ((point_num>10 ? 10 : point_num) - 1)) & 0x7;
1160 if (point_delay[i].other.report > point_delay[i].other.delay)
1161 point_delay[i].other.report = point_delay[i].other.delay;
1162 point_delay[i].other.init = 1;
1163 }
1164 if(pp[0][i].all == 0)
1165 {
1166 point_delay[i].other.init = 0;
1167 }
1168 if (point_delay[i].other.able == 0 && point_delay[i].other.init != 0)
1169 {
1170 for (j = 0; j <= (int)point_delay[i].other.delay; j++)
1171 if (pp[j][i].all == 0 ||
1172 pp[j][i].other.fill != 0 ||
1173 pp[j][i].other.able != 0)
1174 break;
1175 if (j <= (int)point_delay[i].other.delay)
1176 continue;
1177 point_delay[i].other.able = 1;
1178 }
1179 if (pp[point_delay[i].other.report][i].all == 0)
1180 {
1181 point_delay[i].other.able = 0;
1182 continue;
1183 }
1184 if (point_delay[i].other.able == 0)
1185 continue;
1186 if (point_delay[i].other.report)
1187 {
1188 if (PointDistance(&pp[point_delay[i].other.report][i],
1189 &pp[point_delay[i].other.report - 1][i]) < 3 * 3)
1190 point_delay[i].other.report--;
1191 }
1192 }
1193 }
1194
FilterOne(int i,int * ps_c,int * pr_c,int denominator)1195 static void FilterOne(int i,int *ps_c,int *pr_c,int denominator)
1196 {
1197 int j;
1198 int x=0,y=0;
1199 pr[0][i].all = ps[0][i].all;
1200 if(pr[0][i].all == 0)
1201 return;
1202 if(denominator <= 0)
1203 return;
1204 for(j=0;j<8;j++)
1205 {
1206 x += (int)pr[j][i].other.x * (int)pr_c[j] +
1207 (int)ps[j][i].other.x * (int)ps_c[j];
1208 y += (int)pr[j][i].other.y * (int)pr_c[j] +
1209 (int)ps[j][i].other.y * (int)ps_c[j];
1210 }
1211 x = (x + denominator/2) / denominator;
1212 y = (y + denominator/2) / denominator;
1213 if(x < 0)
1214 x = 0;
1215 if(x > 0xffff)
1216 x = 0xffff;
1217 if(y < 0)
1218 y = 0;
1219 if(y > 0xfff)
1220 y = 0xfff;
1221 pr[0][i].other.x = x;
1222 pr[0][i].other.y = y;
1223 }
1224
FilterSpeed(int i)1225 static unsigned int FilterSpeed(int i)
1226 {
1227 return (Sqrt(PointDistance(&ps[0][i], &ps[1][i])) +
1228 Sqrt(PointDistance(&ps[1][i], &ps[2][i])))/2;
1229 }
1230
MedianSpeedOver(int id,int deep)1231 static int MedianSpeedOver(int id,int deep)
1232 {
1233 int i;
1234 unsigned int dis;
1235 int speed_over = 0;
1236 deep = deep/2 - 1;
1237 if(deep < 0 || deep > 3)
1238 return TRUE;
1239 dis = median_dis[deep] * median_dis[deep];
1240 for(i=0;i<=deep && i<POINT_DEEP;i++)
1241 {
1242 if(PointDistance(&ps[i][id],&ps[i+1][id]) > dis)
1243 speed_over ++;
1244 }
1245 if(speed_over >= 2)
1246 return TRUE;
1247 return FALSE;
1248 }
1249
PointMedian(void)1250 static void PointMedian(void)
1251 {
1252 int i,j;
1253 int deep;
1254 int buf_x[PS_DEEP],buf_y[PS_DEEP];
1255 for(i=0;i<POINT_MAX;i++)
1256 {
1257 if(filter_deep[i] < 3)
1258 deep = 3;
1259 else
1260 deep = filter_deep[i] + 2;
1261 if(deep >= PS_DEEP)
1262 deep = PS_DEEP-1;
1263 deep |= 1;
1264 for(;deep>=3;deep-=2)
1265 {
1266 if(MedianSpeedOver(i,deep))
1267 continue;
1268 for(j=0;j<deep;j++)
1269 {
1270 buf_x[j] = ps[j][i].other.x;
1271 buf_y[j] = ps[j][i].other.y;
1272 }
1273 SortBubble(buf_x,deep);
1274 SortBubble(buf_y,deep);
1275 pr[0][i].other.x = buf_x[deep / 2];
1276 pr[0][i].other.y = buf_y[deep / 2];
1277 }
1278 filter_deep[i] = deep;
1279 }
1280 }
PointFilter(void)1281 static void PointFilter(void)
1282 {
1283 int i,j;
1284 int speed_now;
1285 int filter_speed[6];
1286 int ps_c[8];
1287 int pr_c[8];
1288 for(i=0;i<POINT_MAX;i++)
1289 {
1290 pr[0][i].all = ps[0][i].all;
1291 }
1292 for(i=0;i<POINT_MAX;i++)
1293 {
1294 if(pr[0][i].all!=0 && pr[1][i].all == 0)
1295 {
1296 for(j=1;j<PR_DEEP;j++)
1297 pr[j][i].all = ps[0][i].all;
1298 for(j=1;j<PS_DEEP;j++)
1299 ps[j][i].all = ps[0][i].all;
1300 }
1301 }
1302 if(filter_able >=0 && filter_able <= 1)
1303 return;
1304 if(filter_able > 1)
1305 {
1306 for(i=0;i<8;i++)
1307 {
1308 ps_c[i] = (filter_coe[i/4] >> ((i%4)*8)) & 0xff;
1309 pr_c[i] = (filter_coe[i/4+2] >> ((i%4)*8)) & 0xff;
1310 if(ps_c[i] >= 0x80)
1311 ps_c[i] |= 0xffffff00;
1312 if(pr_c[i] >= 0x80)
1313 pr_c[i] |= 0xffffff00;
1314 }
1315 for(i=0;i<POINT_MAX;i++)
1316 {
1317 FilterOne(i,ps_c,pr_c,filter_able);
1318 }
1319 }
1320 else if(filter_able == -1)
1321 {
1322 PointMedian();
1323 }
1324 else if(filter_able < 0)
1325 {
1326 for(i=0;i<4;i++)
1327 filter_speed[i+1] = median_dis[i];
1328 filter_speed[0] = median_dis[0] * 2 - median_dis[1];
1329 filter_speed[5] = median_dis[3] /2;
1330 for(i=0;i<POINT_MAX;i++)
1331 {
1332 if(pr[0][i].all == 0)
1333 {
1334 filter_deep[i] = 0;
1335 continue;
1336 }
1337 speed_now = FilterSpeed(i);
1338 if (filter_deep[i] > 0 &&
1339 speed_now > filter_speed[filter_deep[i]+1 - 2])
1340 filter_deep[i] --;
1341 else if(filter_deep[i] < 3 &&
1342 speed_now < filter_speed[filter_deep[i]+1 + 2])
1343 filter_deep[i] ++;
1344
1345 FilterOne(i,ps_coe[filter_deep[i]],
1346 pr_coe[filter_deep[i]],0-filter_able);
1347 }
1348 }
1349 }
KeyMap(int * drv,int * sen)1350 static unsigned int KeyMap(int *drv,int *sen)
1351 {
1352 typedef struct
1353 {
1354 unsigned int up_down,left_right;
1355 unsigned int coor;
1356 }KEY_TYPE_RANGE;
1357 KEY_TYPE_RANGE *key_range = (KEY_TYPE_RANGE * )key_range_array;
1358 int i;
1359 for(i=0;i<8;i++)
1360 {
1361 if ((unsigned int)*drv >= (key_range[i].up_down >> 16)
1362 && (unsigned int)*drv <= (key_range[i].up_down & 0xffff)
1363 && (unsigned int)*sen >= (key_range[i].left_right >> 16)
1364 && (unsigned int)*sen <= (key_range[i].left_right & 0xffff))
1365 {
1366 *sen = key_range[i].coor >> 16;
1367 *drv = key_range[i].coor & 0xffff;
1368 return key_range[i].coor;
1369 }
1370 }
1371 return 0;
1372 }
1373
ScreenResolution(gsl_POINT_TYPE * p)1374 static unsigned int ScreenResolution(gsl_POINT_TYPE *p)
1375 {
1376 int x,y;
1377 x = p->other.x;
1378 y = p->other.y;
1379 if (p->other.key == FALSE)
1380 {
1381 y = ((y - match_y[1]) * match_y[0] + 2048)/4096;
1382 x = ((x - match_x[1]) * match_x[0] + 2048)/4096 ;
1383 }
1384 y = y * (int)screen_y_max / ((int)sen_num_nokey * 64);
1385 x = x * (int)screen_x_max / ((int)drv_num_nokey * 64);
1386 if (p->other.key == FALSE)
1387 {
1388 if((ignore_y[0]!=0 || ignore_y[1]!=0))
1389 {
1390 if(y < ignore_y[0])
1391 return 0;
1392 if(ignore_y[1] <= screen_y_max/2 && y > screen_y_max - ignore_y[1])
1393 return 0;
1394 if(ignore_y[1] >= screen_y_max/2 && y > ignore_y[1])
1395 return 0;
1396 }
1397 if(ignore_x[0]!=0 || ignore_x[1]!=0)
1398 {
1399 if(x < ignore_x[0])
1400 return 0;
1401 if(ignore_x[1] <= screen_y_max/2 && x > screen_x_max - ignore_x[1])
1402 return 0;
1403 if(ignore_x[1] >= screen_y_max/2 && x > ignore_x[1])
1404 return 0;
1405 }
1406 if(y <= (int)edge_cut[2])
1407 y = (int)edge_cut[2] + 1;
1408 if(y >= screen_y_max - (int)edge_cut[3])
1409 y = screen_y_max - (int)edge_cut[3] - 1;
1410 if(x <= (int)edge_cut[0])
1411 x = (int)edge_cut[0] + 1;
1412 if(x >= screen_x_max - (int)edge_cut[1])
1413 x = screen_x_max - (int)edge_cut[1] - 1;
1414 if (global_flag.other.opposite_x)
1415 y = screen_y_max - y;
1416 if (global_flag.other.opposite_y)
1417 x = screen_x_max - x;
1418 if (global_flag.other.opposite_xy)
1419 {
1420 y ^= x;
1421 x ^= y;
1422 y ^= x;
1423 }
1424 }
1425 else
1426 {
1427 if(y < 0)
1428 y = 0;
1429 if(x < 0)
1430 x = 0;
1431 if((key_map_able & 0x1) != FALSE && KeyMap(&x,&y) == 0)
1432 return 0;
1433 }
1434 return ((y<<16) & 0x0fff0000) + (x & 0x0000ffff);
1435 }
1436
PointReport(struct gsl_touch_info * cinfo)1437 static void PointReport(struct gsl_touch_info *cinfo)
1438 {
1439 int i;
1440 unsigned int data[POINT_MAX];
1441 int num = 0;
1442 if (point_num > point_num_max && global_flag.other.over_report_mask != 0)
1443 {
1444 point_num = 0;
1445 cinfo->finger_num = 0;
1446 return;
1447 }
1448 for(i=0;i<POINT_MAX;i++)
1449 data[i] = 0;
1450 num = 0;
1451 if (global_flag.other.id_over)
1452 {
1453 for(i=0;i<POINT_MAX && num<point_num_max;i++)
1454 {
1455 if (point_delay[i].other.able == 0)
1456 continue;
1457 if (point_delay[i].other.report >= PR_DEEP - 1)
1458 continue;
1459 if (pr[point_delay[i].other.report + 1][i].other.able == 0)
1460 continue;
1461 if (pr[point_delay[i].other.report][i].all)
1462 {
1463 pr[point_delay[i].other.report][i].other.able = 1;
1464 data[i] = ScreenResolution(&pr[point_delay[i].other.report][i]);
1465 if(data[i])
1466 {
1467 data[i] |= (i+1)<<28;
1468 num++;
1469 }
1470 }
1471 }
1472 for(i=0;i<POINT_MAX && num<point_num_max;i++)
1473 {
1474 if (point_delay[i].other.able == 0)
1475 continue;
1476 if (point_delay[i].other.report >= PR_DEEP)
1477 continue;
1478 if (pr[point_delay[i].other.report][i].all == 0)
1479 continue;
1480 if (pr[point_delay[i].other.report][i].other.able == 0)
1481 {
1482 pr[point_delay[i].other.report][i].other.able = 1;
1483 data[i] = ScreenResolution(&pr[point_delay[i].other.report][i]);
1484 if(data[i])
1485 {
1486 data[i] |= (i+1)<<28;
1487 num++;
1488 }
1489 }
1490 }
1491 }
1492 else
1493 {
1494 num=0;
1495 for(i=0;i<point_num_max;i++)
1496 {
1497 if (point_delay[i].other.able == 0)
1498 continue;
1499 if (point_delay[i].other.report >= PR_DEEP)
1500 continue;
1501 data[num] = ScreenResolution(&pr[point_delay[i].other.report][i]);
1502 if(data[num])
1503 data[num++] |= (i+1)<<28;
1504 }
1505 }
1506 num = 0;
1507 for(i=0;i<POINT_MAX;i++)
1508 {
1509 if(data[i] == 0)
1510 continue;
1511 point_now[num].all = data[i];
1512 cinfo->x[num] = (data[i] >> 16) & 0xfff;
1513 cinfo->y[num] = data[i] & 0xfff;
1514 cinfo->id[num] = data[i] >> 28;
1515 pressure_now[num] = pressure_report[i];
1516 num++;
1517 }
1518 point_num = num;
1519 cinfo->finger_num = num;
1520 }
1521
1522
1523
PointEdge(void)1524 static void PointEdge(void)
1525 {
1526 typedef struct
1527 {
1528 int range;
1529 int coe;
1530 }STRETCH_TYPE;
1531 typedef struct
1532 {
1533 STRETCH_TYPE up[4];
1534 STRETCH_TYPE down[4];
1535 STRETCH_TYPE left[4];
1536 STRETCH_TYPE right[4];
1537 }STRETCH_TYPE_ALL;
1538 STRETCH_TYPE_ALL *stretch;
1539 int i,id;
1540 int data[2];
1541 int x,y;
1542 int sac[4*4*2];
1543 if(screen_x_max == 0 || screen_y_max == 0)
1544 return;
1545 id = 0;
1546 for(i=0;i<4*4*2;i++)
1547 {
1548 sac[i] = stretch_array[i];
1549 if(sac[i])
1550 id++;
1551 }
1552 if(id == 0)
1553 return;
1554 stretch = (STRETCH_TYPE_ALL *)sac;
1555 for(i=0;i<4;i++)
1556 {
1557 if(stretch->right[i].range > screen_y_max * 64 / 128
1558 || stretch->down [i].range > screen_x_max * 64 / 128)
1559 {
1560 for(i=0;i<4;i++)
1561 {
1562 if(stretch->up[i].range)
1563 stretch->up[i].range =
1564 stretch->up[i].range *
1565 drv_num_nokey * 64 / screen_x_max;
1566 if(stretch->down[i].range)
1567 stretch->down[i].range =
1568 (screen_x_max -
1569 stretch->down[i].range) *
1570 drv_num_nokey * 64 / screen_x_max;
1571 if(stretch->left[i].range)
1572 stretch->left[i].range =
1573 stretch->left[i].range *
1574 sen_num_nokey * 64 / screen_y_max;
1575 if(stretch->right[i].range)
1576 stretch->right[i].range =
1577 (screen_y_max -
1578 stretch->right[i].range) *
1579 sen_num_nokey * 64 / screen_y_max;
1580 }
1581 break;
1582 }
1583 }
1584 for(id=0;id<POINT_MAX;id++)
1585 {
1586 if (point_now[id].all == 0 || point_now[id].other.key != 0)
1587 continue;
1588 x = point_now[id].other.x;
1589 y = point_now[id].other.y;
1590
1591 data[0] = 0;
1592 data[1] = y;
1593 for(i=0;i<4;i++)
1594 {
1595 if(stretch->left[i].range == 0)
1596 break;
1597 if(data[1] < stretch->left[i].range)
1598 {
1599 data[0] += (stretch->left[i].range - data[1]) *
1600 stretch->left[i].coe/128;
1601 data[1] = stretch->left[i].range;
1602 }
1603 }
1604 y = data[1] - data[0];
1605 if(y <= 0)
1606 y = 1;
1607 if(y >= (int)sen_num_nokey*64)
1608 y = sen_num_nokey*64 - 1;
1609
1610 data[0] = 0;
1611 data[1] = sen_num_nokey * 64 - y;
1612 for(i=0;i<4;i++)
1613 {
1614 if(stretch->right[i].range == 0)
1615 break;
1616 if(data[1] < stretch->right[i].range)
1617 {
1618 data[0] += (stretch->right[i].range - data[1]) *
1619 stretch->right[i].coe/128;
1620 data[1] = stretch->right[i].range;
1621 }
1622 }
1623 y = sen_num_nokey * 64 - (data[1] - data[0]);
1624 if(y <= 0)
1625 y = 1;
1626 if(y >= (int)sen_num_nokey*64)
1627 y = sen_num_nokey*64 - 1;
1628
1629 data[0] = 0;
1630 data[1] = x;
1631 for(i=0;i<4;i++)
1632 {
1633 if(stretch->up[i].range == 0)
1634 break;
1635 if(data[1] < stretch->up[i].range)
1636 {
1637 data[0] += (stretch->up[i].range - data[1]) *
1638 stretch->up[i].coe/128;
1639 data[1] = stretch->up[i].range;
1640 }
1641 }
1642 x = data[1] - data[0];
1643 if(x <= 0)
1644 x = 1;
1645 if(x >= (int)drv_num_nokey*64)
1646 x = drv_num_nokey*64 - 1;
1647
1648 data[0] = 0;
1649 data[1] = drv_num_nokey * 64 - x;
1650 for(i=0;i<4;i++)
1651 {
1652 if(stretch->down[i].range == 0)
1653 break;
1654 if(data[1] < stretch->down[i].range)
1655 {
1656 data[0] += (stretch->down[i].range - data[1]) *
1657 stretch->down[i].coe/128;
1658 data[1] = stretch->down[i].range;
1659 }
1660 }
1661 x = drv_num_nokey * 64 - (data[1] - data[0]);
1662 if(x <= 0)
1663 x = 1;
1664 if(x >= (int)drv_num_nokey*64)
1665 x = drv_num_nokey*64 - 1;
1666
1667 point_now[id].other.x = x;
1668 point_now[id].other.y = y;
1669 }
1670 }
1671
PointStretch(void)1672 static void PointStretch(void)
1673 {
1674 static int save_dr[POINT_MAX],save_dn[POINT_MAX];
1675 typedef struct
1676 {
1677 int dis;
1678 int coe;
1679 }SHAKE_TYPE;
1680 SHAKE_TYPE * shake_all = (SHAKE_TYPE *) shake_all_array;
1681 int i,j;
1682 int dn;
1683 int dr;
1684 int dc[9],ds[9];
1685 int len = 8;
1686 unsigned int temp;
1687 for(i=0;i<POINT_MAX;i++)
1688 {
1689 ps[0][i].all = pp[0][i].all;
1690 }
1691 for(i=0;i<POINT_MAX;i++)
1692 {
1693 if (pp[0][i].all == 0 || pp[0][i].other.key)
1694 {
1695 point_shake &= ~(0x1<<i);
1696 if(i == 0)
1697 point_edge.rate = 0;
1698 continue;
1699 }
1700 if(i == 0)
1701 {
1702 if(edge_first!=0 && ps[1][i].all == 0)
1703 {
1704 point_edge.coor.all = ps[0][i].all;
1705 if (point_edge.coor.other.x < (unsigned int)((edge_first >> 24) & 0xff))
1706 point_edge.coor.other.x = ((edge_first >> 24) & 0xff);
1707 if (point_edge.coor.other.x > drv_num_nokey * 64 - ((edge_first >> 16) & 0xff))
1708 point_edge.coor.other.x = drv_num_nokey * 64 - ((edge_first >> 16) & 0xff);
1709 if (point_edge.coor.other.y < (unsigned int)((edge_first >> 8) & 0xff))
1710 point_edge.coor.other.y = ((edge_first >> 8) & 0xff);
1711 if (point_edge.coor.other.y > sen_num_nokey * 64 - ((edge_first >> 0) & 0xff))
1712 point_edge.coor.other.y = sen_num_nokey * 64 - ((edge_first >> 0) & 0xff);
1713 if(point_edge.coor.all != ps[0][i].all)
1714 {
1715 point_edge.dis = PointDistance(&ps[0][i],&point_edge.coor);
1716 if(point_edge.dis)
1717 point_edge.rate = 0x1000;
1718 }
1719 }
1720 if(point_edge.rate!=0 && point_edge.dis!=0)
1721 {
1722 temp = PointDistance(&ps[0][i],&point_edge.coor);
1723 if(temp >= point_edge.dis * edge_first_coe / 0x80)
1724 {
1725 point_edge.rate = 0;
1726 }
1727 else if(temp > point_edge.dis)
1728 {
1729 temp = (point_edge.dis * edge_first_coe / 0x80 - temp) *
1730 0x1000 / point_edge.dis;
1731 if(temp < point_edge.rate)
1732 point_edge.rate = temp;
1733 }
1734 ps[0][i].other.x = point_edge.coor.other.x +
1735 (ps[0][i].other.x - point_edge.coor.other.x) *
1736 (0x1000 - point_edge.rate) / 0x1000;
1737 ps[0][i].other.y = point_edge.coor.other.y +
1738 (ps[0][i].other.y - point_edge.coor.other.y) *
1739 (0x1000 - point_edge.rate) / 0x1000;
1740 }
1741 }
1742 if(ps[1][i].all == 0)
1743 {
1744 continue;
1745 }
1746 else if((point_shake & (0x1<<i)) == 0)
1747 {
1748 if(PointDistance(&ps[0][i],&ps[1][i]) < (unsigned int)shake_min)
1749 {
1750 ps[0][i].all = ps[1][i].all;
1751 continue;
1752 }
1753 else
1754 point_shake |= (0x1<<i);
1755 }
1756 }
1757 for(i=0;i<len;i++)
1758 {
1759 if(shake_all[i].dis == 0)
1760 {
1761 len=i;
1762 break;
1763 }
1764 }
1765 if(len == 1)
1766 {
1767 ds[0] = shake_all[0].dis;
1768 dc[0] = (shake_all[0].coe*100+64)/128;
1769 for(i=0;i<POINT_MAX;i++)
1770 {
1771 if(ps[1][i].all == 0)
1772 {
1773 for(j=1;j<PS_DEEP;j++)
1774 ps[j][i].all = ps[0][i].all;
1775 continue;
1776 }
1777 if((point_shake & (0x1<<i)) == 0)
1778 continue;
1779 dn = PointDistance(&pp[0][i],&ps[1][i]);
1780 dn = Sqrt(dn);
1781 dr = dn>ds[0] ? dn-ds[0] : 0;
1782 temp = ps[0][i].all;
1783 if(dn == 0 || dr == 0)
1784 {
1785 ps[0][i].other.x = ps[1][i].other.x;
1786 ps[0][i].other.y = ps[1][i].other.y;
1787 }
1788 else
1789 {
1790 ps[0][i].other.x = (int)ps[1][i].other.x +
1791 ((int)pp[0][i].other.x -
1792 (int)ps[1][i].other.x) * dr / dn;
1793 ps[0][i].other.y = (int)ps[1][i].other.y +
1794 ((int)pp[0][i].other.y -
1795 (int)ps[1][i].other.y) * dr / dn;
1796 }
1797 if(dc[0] > 0)
1798 {
1799 if(ps[0][i].all == ps[1][i].all && temp != ps[0][i].all)
1800 {
1801 ps[0][i].all = temp;
1802 point_decimal[i].other.x +=
1803 (short)ps[0][i].other.x -
1804 (short)ps[1][i].other.x;
1805 point_decimal[i].other.y +=
1806 (short)ps[0][i].other.y -
1807 (short)ps[1][i].other.y;
1808 ps[0][i].other.x = ps[1][i].other.x;
1809 ps[0][i].other.y = ps[1][i].other.y;
1810 if (point_decimal[i].other.x > dc[0] && ps[1][i].other.x < 0xffff)
1811 {
1812 ps[0][i].other.x += 1;
1813 point_decimal[i].other.x = 0;
1814 }
1815 if (point_decimal[i].other.x < -dc[0] && ps[1][i].other.x > 0)
1816 {
1817 ps[0][i].other.x -= 1;
1818 point_decimal[i].other.x = 0;
1819 }
1820 if (point_decimal[i].other.y > dc[0] && ps[1][i].other.y < 0xffff)
1821 {
1822 ps[0][i].other.y += 1;
1823 point_decimal[i].other.y = 0;
1824 }
1825 if (point_decimal[i].other.y < -dc[0] && ps[1][i].other.y > 0)
1826 {
1827 ps[0][i].other.y -= 1;
1828 point_decimal[i].other.y = 0;
1829 }
1830 }
1831 else
1832 {
1833 point_decimal[i].other.x = 0;
1834 point_decimal[i].other.y = 0;
1835 }
1836 }
1837 }
1838
1839 }
1840 else if(len >= 2)
1841 {
1842 for(i=0;i<8 && i<len;i++)
1843 {
1844 ds[i+1] = shake_all[i].dis;
1845 dc[i+1] = shake_all[i].coe;//;ds[i+1] * shake_all[i].coe;
1846 }
1847 if(shake_all[0].coe >= 128 || shake_all[0].coe <= shake_all[1].coe)
1848 {
1849 ds[0] = ds[1];
1850 dc[0] = dc[1];
1851 }
1852 else
1853 {
1854 ds[0] = ds[1] + (128 - shake_all[0].coe) *
1855 (ds[1]-ds[2])/(shake_all[0].coe - shake_all[1].coe);
1856 dc[0] = 128;
1857 }
1858 for(i=0;i<POINT_MAX;i++)
1859 {
1860 if(ps[1][i].all == 0)
1861 {
1862 for(j=1;j<PS_DEEP;j++)
1863 ps[j][i].all = ps[0][i].all;
1864 save_dr[i] = 128;
1865 save_dn[i] = 0;
1866 continue;
1867 }
1868 if((point_shake & (0x1<<i)) == 0)
1869 continue;
1870 dn = PointDistance(&pp[0][i],&ps[1][i]);
1871 dn = Sqrt(dn);
1872 if(dn >= ds[0])
1873 {
1874 continue;
1875 }
1876 if(dn < save_dn[i])
1877 {
1878 dr = save_dr[i];
1879 save_dn[i] = dn;
1880 ps[0][i].other.x = (int)ps[1][i].other.x +
1881 (((int)pp[0][i].other.x -
1882 (int)ps[1][i].other.x) * dr) / 128;
1883 ps[0][i].other.y = (int)ps[1][i].other.y +
1884 (((int)pp[0][i].other.y -
1885 (int)ps[1][i].other.y) * dr) / 128;
1886 continue;
1887 }
1888 for(j=0;j<=len;j++)
1889 {
1890 if(j == len || dn == 0)
1891 {
1892 ps[0][i].other.x = ps[1][i].other.x;
1893 ps[0][i].other.y = ps[1][i].other.y;
1894 break;
1895 }
1896 else if(ds[j] > dn && dn >=ds[j+1])
1897 {
1898 dr = dc[j+1] + ((dn - ds[j+1]) * (dc[j] - dc[j+1])) / (ds[j] - ds[j+1]);
1899 save_dr[i] = dr;
1900 save_dn[i] = dn;
1901 // ps[0][i].x = (int)ps[1][i].x + ((int)pp[0][i].x - (int)ps[1][i].x) * dr / dn / 128;
1902 // ps[0][i].y = (int)ps[1][i].y + ((int)pp[0][i].y - (int)ps[1][i].y) * dr / dn / 128;
1903 ps[0][i].other.x = (int)ps[1][i].other.x +
1904 (((int)pp[0][i].other.x -
1905 (int)ps[1][i].other.x) * dr + 64) / 128;
1906 ps[0][i].other.y = (int)ps[1][i].other.y +
1907 (((int)pp[0][i].other.y -
1908 (int)ps[1][i].other.y) * dr + 64) / 128;
1909 break;
1910 }
1911 }
1912 }
1913 }
1914 else
1915 {
1916 return;
1917 }
1918 }
1919
ResetMask(void)1920 static void ResetMask(void)
1921 {
1922 if (reset_mask_send)
1923 {
1924 reset_mask_send = 0;
1925 }
1926 if (global_state.other.mask)
1927 return;
1928 if (reset_mask_dis ==0 || reset_mask_type == 0)
1929 return;
1930 if (reset_mask_max == 0xfffffff1)
1931 {
1932 if (point_num == 0)
1933 reset_mask_max = 0xf0000000 + 1;
1934 return;
1935 }
1936 if (reset_mask_max > 0xf0000000)
1937 {
1938 reset_mask_max --;
1939 if (reset_mask_max == 0xf0000000)
1940 {
1941 reset_mask_send = reset_mask_type;
1942 global_state.other.mask = 1;
1943 }
1944 return;
1945 }
1946 if (point_num > 1 || pp[0][0].all == 0)
1947 {
1948 reset_mask_count = 0;
1949 reset_mask_max = 0;
1950 reset_mask_count = 0;
1951 return;
1952 }
1953 reset_mask_count ++;
1954 if (reset_mask_max == 0)
1955 reset_mask_max = pp[0][0].all;
1956 else
1957 if (PointDistance((gsl_POINT_TYPE*)(&reset_mask_max),pp[0]) >
1958 (((unsigned int)reset_mask_dis) & 0xffffff) &&
1959 reset_mask_count > (((unsigned int)reset_mask_dis) >> 24))
1960 reset_mask_max = 0xfffffff1;
1961 }
1962
ConfigCoorMulti(int data[])1963 static int ConfigCoorMulti(int data[])
1964 {
1965 int i,j;
1966 int n = 0;
1967 for(i=0;i<4;i++)
1968 {
1969 if(data[247+i]!=0)
1970 {
1971 if((data[247+i]&63)==0 && (data[247+i]>>16)<4)
1972 n++;
1973 else
1974 return FALSE;
1975 }
1976 if(data[251+i]!=0)
1977 {
1978 if((data[251+i]&63)==0 && (data[251+i]>>16)<4)
1979 n++;
1980 else
1981 return FALSE;
1982 }
1983 }
1984 if(n == 0 || n > 4)
1985 return FALSE;
1986 for(j=0;j<n;j++)
1987 {
1988 for(i=0;i<64;i++)
1989 {
1990 if(data[256+j*64+i] >= 64)
1991 return FALSE;
1992 if(i)
1993 {
1994 if(data[256+j*64+i] < data[256+j*64+i-1])
1995 return FALSE;
1996 }
1997 }
1998 }
1999 return TRUE;
2000 }
2001
ConfigFilter(unsigned int data[])2002 static int ConfigFilter(unsigned int data[])
2003 {
2004 int i;
2005 unsigned int ps_c[8];
2006 unsigned int pr_c[8];
2007 unsigned int sum = 0;
2008 //if(data[242]>1 && (data[255]>=0 && data[255]<=256))
2009 if (data[242]>1 && (data[255] <= 256))
2010 {
2011 for(i=0;i<8;i++)
2012 {
2013 ps_c[i] = (data[243+i/4] >> ((i%4)*8)) & 0xff;
2014 pr_c[i] = (data[243+i/4+2] >> ((i%4)*8)) & 0xff;
2015 if(ps_c[i] >= 0x80)
2016 ps_c[i] |= 0xffffff00;
2017 if(pr_c[i] >= 0x80)
2018 pr_c[i] |= 0xffffff00;
2019 sum += ps_c[i];
2020 sum += pr_c[i];
2021 }
2022 if(sum == data[242] || sum + data[242] == 0)
2023 return TRUE;
2024 }
2025 return FALSE;
2026 }
2027
ConfigKeyMap(int data[])2028 static int ConfigKeyMap(int data[])
2029 {
2030 int i;
2031 if(data[217] != 1)
2032 return FALSE;
2033 for(i=0;i<8;i++)
2034 {
2035 if(data[218+2] == 0)
2036 return FALSE;
2037 if((data[218+i*3+0]>>16) > (data[218+i*3+0]&0xffff))
2038 return FALSE;
2039 if((data[218+i*3+1]>>16) > (data[218+i*3+1]&0xffff))
2040 return FALSE;
2041 }
2042 return TRUE;
2043 }
2044
DiagonalDistance(gsl_POINT_TYPE * p,int type)2045 static int DiagonalDistance(gsl_POINT_TYPE *p,int type)
2046 {
2047 int divisor,square;
2048 divisor = ((int)sen_num_nokey * (int)sen_num_nokey +
2049 (int)drv_num_nokey * (int)drv_num_nokey)/16;
2050 if(divisor == 0)
2051 divisor = 1;
2052 if(type == 0)
2053 square = ((int)sen_num_nokey*(int)(p->other.x) -
2054 (int)drv_num_nokey*(int)(p->other.y)) / 4;
2055 else
2056 square = ((int)sen_num_nokey*(int)(p->other.x) +
2057 (int)drv_num_nokey*(int)(p->other.y) -
2058 (int)sen_num_nokey*(int)drv_num_nokey * 64) / 4;
2059 return square * square / divisor;
2060 }
2061
DiagonalCompress(gsl_POINT_TYPE * p,int type,int dis,int dis_max)2062 static void DiagonalCompress(gsl_POINT_TYPE *p,int type,int dis,int dis_max)
2063 {
2064 int x,y;
2065 int tx,ty;
2066 int cp_ceof;
2067 if(dis_max == 0)
2068 return;
2069 if(dis > dis_max)
2070 cp_ceof = (dis - dis_max)*128/(3*dis_max) + 128;
2071 else
2072 cp_ceof = 128;
2073 if(cp_ceof > 256)
2074 cp_ceof = 256;
2075 x = p->other.x;
2076 y = p->other.y;
2077 if(type)
2078 y = (int)sen_num_nokey*64 - y;
2079 x *= (int)sen_num_nokey;
2080 y *= (int)drv_num_nokey;
2081 tx = x;
2082 ty = y;
2083 x = ((tx+ty)+(tx-ty)*cp_ceof/256)/2;
2084 y = ((tx+ty)+(ty-tx)*cp_ceof/256)/2;
2085 x /= (int)sen_num_nokey;
2086 y /= (int)drv_num_nokey;
2087 if(type)
2088 y = sen_num_nokey*64 - y;
2089 if(x < 1)
2090 x = 1;
2091 if(y < 1)
2092 y = 1;
2093 if(x >= (int)drv_num_nokey*64)
2094 x = drv_num_nokey*64 - 1;
2095 if(y >= (int)sen_num_nokey*64)
2096 y = (int)sen_num_nokey*64 - 1;
2097 p->other.x = x;
2098 p->other.y = y;
2099 }
2100
PointDiagonal(void)2101 static void PointDiagonal(void)
2102 {
2103 int i;
2104 int diagonal_size;
2105 int dis;
2106 unsigned int diagonal_start;
2107 if(diagonal == 0)
2108 return;
2109 diagonal_size = diagonal * diagonal;
2110 diagonal_start = diagonal * 3/2;
2111 for(i=0;i<POINT_MAX;i++)
2112 {
2113 if (ps[0][i].all == 0 || ps[0][i].other.key != 0)
2114 {
2115 point_corner &= ~(0x3<<i*2);
2116 continue;
2117 }
2118 else if((point_corner & (0x3<<i*2)) == 0)
2119 {
2120 if ((ps[0][i].other.x <= diagonal_start &&
2121 ps[0][i].other.y <= diagonal_start) ||
2122 (ps[0][i].other.x >= drv_num_nokey * 64 - diagonal_start &&
2123 ps[0][i].other.y >= sen_num_nokey * 64 - diagonal_start))
2124 point_corner |= 0x2<<i*2;
2125 else if ((ps[0][i].other.x <= diagonal_start &&
2126 ps[0][i].other.y >= sen_num_nokey * 64 - diagonal_start) ||
2127 (ps[0][i].other.x >= drv_num_nokey * 64 - diagonal_start &&
2128 ps[0][i].other.y <= diagonal_start))
2129 point_corner |= 0x3<<i*2;
2130 else
2131 point_corner |= 0x1<<i*2;
2132 }
2133 if(point_corner & (0x2<<i*2))
2134 {
2135 dis = DiagonalDistance(&(ps[0][i]),point_corner & (0x1<<i*2));
2136 if(dis <= diagonal_size*4)
2137 {
2138 DiagonalCompress(&(ps[0][i]),point_corner & (0x1<<i*2),dis,diagonal_size);
2139 }
2140 else if(dis > diagonal_size*4)
2141 {
2142 point_corner &= ~(0x3<<i*2);
2143 point_corner |= 0x1<<i*2;
2144 }
2145 }
2146 }
2147 }
2148
PressureSave(void)2149 static void PressureSave(void)
2150 {
2151 int i;
2152 if((point_num & 0x1000)==0)
2153 {
2154 return;
2155 }
2156 for(i=0;i<POINT_MAX;i++)
2157 {
2158 pressure_now[i] = point_now[i].all >> 28;
2159 point_now[i].all &= ~(0xf<<28);
2160 }
2161 }
2162
PointPressure(void)2163 static void PointPressure(void)
2164 {
2165 int i,j;
2166 for(i=0;i<POINT_MAX;i++)
2167 {
2168 if(pa[0][i]!=0 && pa[1][i]==0)
2169 {
2170 pressure_report[i] = pa[0][i]*5;
2171 for(j=1;j<PRESSURE_DEEP;j++)
2172 pa[j][i] = pa[0][i];
2173 continue;
2174 }
2175 j = (pressure_report[i]+1)/2 + pa[0][i] +
2176 pa[1][i] + (pa[2][i]+1)/2 - pressure_report[i];
2177 if(j >= 2)
2178 j -= 2;
2179 else if(j <= -2)
2180 j += 2;
2181 else
2182 j = 0;
2183 pressure_report[i] = pressure_report[i]+j;
2184 }
2185 }
2186
gsl_ReportPressure(unsigned int * p)2187 void gsl_ReportPressure(unsigned int *p)
2188 {
2189 int i;
2190 for(i=0;i<POINT_MAX;i++)
2191 {
2192 if(i < point_num)
2193 {
2194 if(pressure_now[i] == 0)
2195 p[i] = 0;
2196 else if(pressure_now[i] <= 7)
2197 p[i] = 1;
2198 else if(pressure_now[i] > 63+7)
2199 p[i] = 63;
2200 else
2201 p[i] = pressure_now[i] - 7;
2202 }
2203 else
2204 p[i] = 0;
2205 }
2206 }
2207 //EXPORT_SYMBOL(gsl_ReportPressure);
2208
gsl_TouchNear(void)2209 int gsl_TouchNear(void)
2210 {
2211 return 0;
2212 }
2213 //EXPORT_SYMBOL(gsl_TouchNear);
2214
DoubleClick(void)2215 static void DoubleClick(void)
2216 {
2217 int i;
2218 unsigned int width[3];
2219 double_click = 0;
2220 // printk("sileadinc DoubleClick c = %08x , %08x\n",csensor_count,pp[0][0].all);
2221 if (point_num >= 2 || (point_num == 1 && pp[0][0].all == 0) || pp[0][0].other.key)
2222 {
2223 // printk("sileadinc DoubleClick return\n");
2224 for(i=0;i<sizeof(click_count)/sizeof(click_count[0]);i++)
2225 click_count[i] = 0;
2226 return;
2227 }
2228 if(point_num!=0 && prev_num==0)
2229 {
2230 for(i=sizeof(click_count)/sizeof(click_count[0])-1;i>0;i--)
2231 click_count[i] = click_count[i-1];
2232 click_count[0] = csensor_count;
2233 for(i=sizeof(point_click)/sizeof(point_click[0])-1;i>1;i--)
2234 point_click[i].all = point_click[i-2].all;
2235 point_click[0].all = pp[0][0].all;
2236 point_click[1].all = pp[0][0].all;
2237 }
2238 if(point_num!=0 && prev_num!=0)
2239 {
2240 if(PointDistance(&point_click[1],&pp[0][0]) > PointDistance(&point_click[1],&point_click[0]))
2241 point_click[0].all = pp[0][0].all;
2242 }
2243 if(point_num==0 && prev_num!=0)
2244 {
2245 // printk("sileadinc DoubleClick point_click %08x %08x %08x %08x\n",point_click[0],point_click[1],point_click[2],point_click[3]);
2246 for(i=sizeof(click_count)/sizeof(click_count[0])-1;i>0;i--)
2247 click_count[i] = click_count[i-1];
2248 click_count[0] = csensor_count;
2249 for(i=0;i<sizeof(click_count)/sizeof(click_count[0])-1;i++)
2250 width[i] = (click_count[i] - click_count[i+1]) & 0xffff;
2251 if(!(width[0]>=double_down*average && width[2]>=double_down*average && width[1]<=double_up*average))
2252 {
2253 // printk("sileadinc DoubleClick width %08x %08x %08x\n",width[0],width[1],width[2]);
2254 return;
2255 }
2256 if(PointDistance(&point_click[0],&point_click[1]) > 64*64
2257 || PointDistance(&point_click[2],&point_click[3]) > 64*64
2258 || PointDistance(&point_click[1],&point_click[3]) > 128*128)
2259 {
2260 // printk("sileadinc DoubleClick distance %08x %08x %08x\n",
2261 // PointDistance(&point_click[0],&point_click[1]),
2262 // PointDistance(&point_click[2],&point_click[3]),
2263 // PointDistance(&point_click[1],&point_click[3]));
2264 return;
2265 }
2266 for(i=0;i<sizeof(click_count)/sizeof(click_count[0]);i++)
2267 click_count[i] = 0;//?point_click
2268 double_click = '*';
2269 // printk("sileadinc DoubleClick succeed double_click=%c\n",double_click);
2270 }
2271 }
2272
gsl_id_reg_init(int flag)2273 static void gsl_id_reg_init(int flag)
2274 {
2275 int i,j;
2276 for(j=0;j<POINT_DEEP;j++)
2277 for(i=0;i<POINT_MAX;i++)
2278 point_array[j][i].all = 0;
2279 for(j=0;j<PRESSURE_DEEP;j++)
2280 for(i=0;i<POINT_MAX;i++)
2281 pressure_array[j][i] = 0;
2282 for(i=0;i<POINT_MAX;i++)
2283 {
2284 point_delay[i].all = 0;
2285 filter_deep[i] = 0;
2286 point_decimal[i].all = 0;
2287 }
2288 point_edge.rate = 0;
2289 point_n = 0;
2290 if(flag)
2291 point_num = 0;
2292 prev_num = 0;
2293 point_shake = 0;
2294 reset_mask_send = 0;
2295 reset_mask_max = 0;
2296 reset_mask_count = 0;
2297 point_near = 0;
2298 point_corner = 0;
2299 global_state.all = 0;
2300 double_click = 0;
2301 inte_count = 0;
2302 csensor_count = 0;
2303 #ifdef GESTURE_LICH
2304 GestureInit();
2305 #endif
2306 }
2307
DataCheck(void)2308 static int DataCheck(void)
2309 {
2310 if(drv_num==0 || drv_num_nokey==0 || sen_num==0 || sen_num_nokey==0)
2311 return 0;
2312 if(screen_x_max==0 || screen_y_max==0)
2313 return 0;
2314 return 1;
2315 }
2316
gsl_DataInit(unsigned int * conf_in)2317 void gsl_DataInit(unsigned int * conf_in)
2318 {
2319 int i, j;
2320 unsigned int *conf;
2321 int len;
2322 gsl_id_reg_init(1);
2323 conf = config_static;
2324 coordinate_correct_able = 0;
2325 for(i=0;i<32;i++)
2326 {
2327 coordinate_correct_coe_x[i] = i;
2328 coordinate_correct_coe_y[i] = i;
2329 }
2330 id_first_coe = 8;
2331 id_speed_coe = 128*128;
2332 id_static_coe = 64*64;
2333 average = 3+1;
2334 soft_average = 3;
2335 report_delay=0;
2336 report_ahead = 0x9249249;
2337 for(i=0;i<4;i++)
2338 median_dis[i]=0;
2339 shake_min = 0*0;
2340 for(i=0;i<2;i++)
2341 {
2342 match_y[i]=0;
2343 match_x[i]=0;
2344 ignore_y[i]=0;
2345 ignore_x[i]=0;
2346 }
2347 match_y[0]=4096;
2348 match_x[0]=4096;
2349 screen_y_max = 480;
2350 screen_x_max = 800;
2351 point_num_max=10;
2352 drv_num = 16;
2353 sen_num = 10;
2354 drv_num_nokey = 16;
2355 sen_num_nokey = 10;
2356 for(i=0;i<4;i++)
2357 edge_cut[i] = 0;
2358 for(i=0;i<32;i++)
2359 stretch_array[i] = 0;
2360 for(i=0;i<16;i++)
2361 shake_all_array[i] = 0;
2362 reset_mask_dis = 0;
2363 reset_mask_type=0;
2364 diagonal = 0;
2365 key_map_able = 0;
2366 for(i=0;i<8*3;i++)
2367 key_range_array[i] = 0;
2368 filter_able = 0;
2369 filter_coe[0] = ( 0<<6*4)+( 0<<6*3)+( 0<<6*2)+(40<<6*1)+(24<<6*0);
2370 filter_coe[1] = ( 0<<6*4)+( 0<<6*3)+(16<<6*2)+(24<<6*1)+(24<<6*0);
2371 filter_coe[2] = ( 0<<6*4)+(16<<6*3)+(24<<6*2)+(16<<6*1)+( 8<<6*0);
2372 filter_coe[3] = ( 6<<6*4)+(16<<6*3)+(24<<6*2)+(12<<6*1)+( 6<<6*0);
2373 for(i=0;i<4;i++)
2374 {
2375 multi_x_array[i]=0;
2376 multi_y_array[i]=0;
2377 }
2378 point_repeat[0] = 32;
2379 point_repeat[1] = 96;
2380 edge_first = 0;
2381 edge_first_coe = 0x80;
2382 //----------------------------------------------
2383 if(conf_in == NULL)
2384 {
2385 return;
2386 }
2387 if(conf_in[0] <= 0xfff)
2388 {
2389 if(ConfigCoorMulti((int*)conf_in))
2390 len = 512;
2391 else if(ConfigFilter(conf_in))
2392 len = 256;
2393 else if (ConfigKeyMap((int*)conf_in))
2394 len = 241;
2395 else
2396 len = 215;
2397 }
2398 else if(conf_in[1] <= CONFIG_LENGTH)
2399 len = conf_in[1];
2400 else
2401 len = CONFIG_LENGTH;
2402 for(i=0;i<len;i++)
2403 conf[i] = conf_in[i];
2404 for(;i<CONFIG_LENGTH;i++)
2405 conf[i] = 0;
2406 if(conf_in[0] <= 0xfff)
2407 {
2408 coordinate_correct_able = conf[0];
2409 drv_num = conf[1];
2410 sen_num = conf[2];
2411 drv_num_nokey = conf[3];
2412 sen_num_nokey = conf[4];
2413 id_first_coe = conf[5];
2414 id_speed_coe = conf[6];
2415 id_static_coe = conf[7];
2416 average = conf[8];
2417 soft_average = conf[9];
2418
2419 report_delay = conf[13];
2420 shake_min = conf[14];
2421 screen_y_max = conf[15];
2422 screen_x_max = conf[16];
2423 point_num_max = conf[17];
2424 global_flag.all = conf[18];
2425 for(i=0;i<4;i++)
2426 median_dis[i] = (unsigned char)conf[19+i];
2427 for(i=0;i<2;i++)
2428 {
2429 match_y[i] = conf[23+i];
2430 match_x[i] = conf[25+i];
2431 ignore_y[i] = conf[27+i];
2432 ignore_x[i] = conf[29+i];
2433 }
2434 for(i=0;i<64;i++)
2435 {
2436 coordinate_correct_coe_x[i] = conf[31+i];
2437 coordinate_correct_coe_y[i] = conf[95+i];
2438 }
2439 for(i=0;i<4;i++)
2440 edge_cut[i] = conf[159+i];
2441 for(i=0;i<32;i++)
2442 stretch_array[i] = conf[163+i];
2443 for(i=0;i<16;i++)
2444 shake_all_array[i] = conf[195+i];
2445 reset_mask_dis = conf[213];
2446 reset_mask_type = conf[214];
2447 key_map_able = conf[217];
2448 for(i=0;i<8*3;i++)
2449 key_range_array[i] = conf[218+i];
2450 filter_able = conf[242];
2451 for(i=0;i<4;i++)
2452 filter_coe[i] = conf[243+i];
2453 for(i=0;i<4;i++)
2454 multi_x_array[i] = conf[247+i];
2455 for(i=0;i<4;i++)
2456 multi_y_array[i] = conf[251+i];
2457 diagonal = conf[255];
2458 for(i=0;i<4;i++)
2459 for(j=0;j<64;j++)
2460 multi_group[i][j] = conf[256+64*i+j];
2461 for(i=0;i<4;i++)
2462 {
2463 for(j=0;j<8;j++)
2464 {
2465 ps_coe[i][j] = conf[256 + 64*3 + 8*i+j];
2466 pr_coe[i][j] = conf[256 + 64*3 + 8*i+j + 32];
2467 }
2468 }
2469 //-----------------------
2470 near_set[0] = 0;
2471 near_set[1] = 0;
2472 }
2473 else
2474 {
2475 global_flag.all = conf[0x10];
2476 point_num_max = conf[0x11];
2477 drv_num = conf[0x12]&0xffff;
2478 sen_num = conf[0x12]>>16;
2479 drv_num_nokey = conf[0x13]&0xffff;
2480 sen_num_nokey = conf[0x13]>>16;
2481 screen_x_max = conf[0x14]&0xffff;
2482 screen_y_max = conf[0x14]>>16;
2483 average = conf[0x15];
2484 reset_mask_dis = conf[0x16];
2485 reset_mask_type = conf[0x17];
2486 point_repeat[0] = conf[0x18]>>16;
2487 point_repeat[1] = conf[0x18]&0xffff;
2488 //conf[0x19~0x1f]
2489 near_set[0] = conf[0x19]>>16;
2490 near_set[1] = conf[0x19]&0xffff;
2491 diagonal = conf[0x1a];
2492 //-------------------------
2493
2494 id_first_coe = conf[0x20];
2495 id_speed_coe = conf[0x21];
2496 id_static_coe = conf[0x22];
2497 match_y[0] = conf[0x23]>>16;
2498 match_y[1] = conf[0x23]&0xffff;
2499 match_x[0] = conf[0x24]>>16;
2500 match_x[1] = conf[0x24]&0xffff;
2501 ignore_y[0] = conf[0x25]>>16;
2502 ignore_y[1] = conf[0x25]&0xffff;
2503 ignore_x[0] = conf[0x26]>>16;
2504 ignore_x[1] = conf[0x26]&0xffff;
2505 edge_cut[0] = (conf[0x27]>>24) & 0xff;
2506 edge_cut[1] = (conf[0x27]>>16) & 0xff;
2507 edge_cut[2] = (conf[0x27]>> 8) & 0xff;
2508 edge_cut[3] = (conf[0x27]>> 0) & 0xff;
2509 report_delay = conf[0x28];
2510 shake_min = conf[0x29];
2511 for(i=0;i<16;i++)
2512 {
2513 stretch_array[i*2+0] = conf[0x2a+i] & 0xffff;
2514 stretch_array[i*2+1] = conf[0x2a+i] >> 16;
2515 }
2516 for(i=0;i<8;i++)
2517 {
2518 shake_all_array[i*2+0] = conf[0x3a+i] & 0xffff;
2519 shake_all_array[i*2+1] = conf[0x3a+i] >> 16;
2520 }
2521 report_ahead = conf[0x42];
2522 // key_dead_time = conf[0x43];
2523 // point_dead_time = conf[0x44];
2524 // point_dead_time2 = conf[0x45];
2525 // point_dead_distance = conf[0x46];
2526 // point_dead_distance2 = conf[0x47];
2527 edge_first = conf[0x48];
2528 edge_first_coe = conf[0x49];
2529 //goto_test
2530
2531 key_map_able = conf[0x60];
2532 for(i=0;i<8*3;i++)
2533 key_range_array[i] = conf[0x61+i];
2534
2535 coordinate_correct_able = conf[0x100];
2536 for(i=0;i<4;i++)
2537 {
2538 multi_x_array[i] = conf[0x101+i];
2539 multi_y_array[i] = conf[0x105+i];
2540 }
2541 for(i=0;i<64;i++)
2542 {
2543 coordinate_correct_coe_x[i] = (conf[0x109+i/4]>>(i%4*8)) & 0xff;
2544 coordinate_correct_coe_y[i] = (conf[0x109+64/4+i/4]>>(i%4*8)) & 0xff;
2545 }
2546 for(i=0;i<4;i++)
2547 {
2548 for(j=0;j<64;j++)
2549 multi_group[i][j] = (conf[0x109+64/4*2+(64*i+j)/4]>>((64*i+j)%4*8)) & 0xff;
2550 }
2551
2552 filter_able = conf[0x180];
2553 for(i=0;i<4;i++)
2554 filter_coe[i] = conf[0x181+i];
2555 for(i=0;i<4;i++)
2556 median_dis[i] = (unsigned char)conf[0x185+i];
2557 for(i=0;i<4;i++)
2558 {
2559 for(j=0;j<8;j++)
2560 {
2561 ps_coe[i][j] = conf[0x189 + 8*i+j];
2562 pr_coe[i][j] = conf[0x189 + 8*i+j + 32];
2563 }
2564 }
2565 #ifdef GESTURE_LICH
2566 GestureSet(&conf[0x189 + 64]);
2567 #endif
2568 }
2569 //---------------------------------------------
2570 if(average == 0)
2571 average = 4;
2572 for(i=0;i<8;i++)
2573 {
2574 if(shake_all_array[i*2] & 0x8000)
2575 shake_all_array[i*2] = shake_all_array[i*2] & ~0x8000;
2576 else
2577 shake_all_array[i*2] = Sqrt(shake_all_array[i*2]);
2578 }
2579 for(i=0;i<2;i++)
2580 {
2581 if(match_x[i] & 0x8000)
2582 match_x[i] |= 0xffff0000;
2583 if(match_y[i] & 0x8000)
2584 match_y[i] |= 0xffff0000;
2585 if(ignore_x[i] & 0x8000)
2586 ignore_x[i] |= 0xffff0000;
2587 if(ignore_y[i] & 0x8000)
2588 ignore_y[i] |= 0xffff0000;
2589 }
2590 for(i=0;i<CONFIG_LENGTH;i++)
2591 config_static[i] = 0;
2592 }
2593 //EXPORT_SYMBOL(gsl_DataInit);
2594
gsl_version_id(void)2595 unsigned int gsl_version_id(void)
2596 {
2597 return GSL_VERSION;
2598 }
2599 //EXPORT_SYMBOL(gsl_version_id);
2600
gsl_mask_tiaoping(void)2601 unsigned int gsl_mask_tiaoping(void)
2602 {
2603 return reset_mask_send;
2604 }
2605 //EXPORT_SYMBOL(gsl_mask_tiaoping);
2606
2607
GetFlag(void)2608 static void GetFlag(void)
2609 {
2610 int i = 0;
2611 int num_save;
2612 if(((point_num & 0x100)!=0) ||
2613 ((point_num & 0x200) != 0 &&
2614 global_state.other.reset == 1))
2615 {
2616 gsl_id_reg_init(0);
2617 }
2618 if((point_num & 0x300) == 0)
2619 {
2620 global_state.other.reset = 1;
2621 }
2622 if(point_num & 0x400)
2623 global_state.other.only = 1;
2624 else
2625 global_state.other.only = 0;
2626 if(point_num & 0x2000)
2627 global_state.other.interpolation = 0xf;
2628 else if (global_state.other.interpolation)
2629 global_state.other.interpolation--;
2630 if(point_num & 0x4000)
2631 global_state.other.ex = 1;
2632 else
2633 global_state.other.ex = 0;
2634 inte_count ++;
2635 csensor_count = ((unsigned int)point_num)>>16;
2636 num_save = point_num & 0xff;
2637 if(num_save > POINT_MAX)
2638 num_save = POINT_MAX;
2639 for(i=0;i<POINT_MAX;i++)
2640 {
2641 if(i >= num_save)
2642 point_now[i].all = 0;
2643 }
2644 point_num = (point_num & (~0xff)) + num_save;
2645 }
2646
gsl_alg_id_main(struct gsl_touch_info * cinfo)2647 void gsl_alg_id_main(struct gsl_touch_info *cinfo)
2648 {
2649 int i;
2650 point_num = cinfo->finger_num;
2651 for(i=0;i<POINT_MAX;i++)
2652 {
2653 point_now[i].all = (cinfo->id[i]<<28) |
2654 (cinfo->x[i]<<16) | cinfo->y[i];
2655 }
2656
2657 GetFlag();
2658 if(DataCheck() == 0)
2659 {
2660 point_num = 0;
2661 cinfo->finger_num = 0;
2662 return;
2663 }
2664 PressureSave();
2665 PointCoor();
2666 CoordinateCorrect();
2667 PointEdge();
2668 PointRepeat();
2669 GetPointNum(point_now);
2670 PointPointer();
2671 PointPredict();
2672 PointId();
2673 PointNewId();
2674 PointOrder();
2675 PointCross();
2676 GetPointNum(pp[0]);
2677 DoubleClick();
2678 prev_num = point_num;
2679 ResetMask();
2680 PointStretch();
2681 PointDiagonal();
2682 PointFilter();
2683 GetPointNum(pr[0]);
2684 #ifdef GESTURE_LICH
2685 GestureMain(&(pr[0][0].all),point_num);
2686 #endif
2687 PointDelay();
2688 PointPressure();
2689 PointReport(cinfo);
2690 }
2691 //EXPORT_SYMBOL(gsl_alg_id_main);
2692
2693
2694 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2695 #ifdef GESTURE_LICH
2696
gsl_obtain_gesture(void)2697 int gsl_obtain_gesture(void)
2698 {
2699 return GestureDeal();
2700 }
2701 //EXPORT_SYMBOL(gsl_obtain_gesture);
2702
GestureMain(unsigned int data_coor[],unsigned int num)2703 static int GestureMain(unsigned int data_coor[],unsigned int num)
2704 {
2705 gesture_deal = FALSE;
2706 if(gesture_dis_min == 0)
2707 return FALSE;
2708 if(num == 0)
2709 {
2710 if(gesture_num == 0)
2711 return FALSE;
2712 if(gesture_num <= 8)
2713 {
2714 GestureInit();
2715 return FALSE;
2716 }
2717 gesture_deal = GESTURE_ALL;
2718 return TRUE;
2719 }
2720 else if(gesture_num < 0)
2721 {
2722 return FALSE;
2723 }
2724 else if(num == 1 && data_coor[0] != 0)
2725 {
2726 GesturePush((GESTURE_POINT_TYPE*) data_coor);
2727 return FALSE;
2728 }
2729 else// if(num > 1)
2730 {
2731 gesture_num = -1;
2732 return FALSE;
2733 }
2734 // return TRUE;
2735 }
2736
GestureSqrt(int d)2737 static int GestureSqrt(int d)
2738 {
2739 int ret = 0;
2740 int i;
2741 for(i=14;i>=0;i--)
2742 {
2743 if((ret + (0x1<<i))*(ret + (0x1<<i)) <= d)
2744 ret |= (0x1<<i);
2745 }
2746 return ret;
2747 }
2748
GestureDistance(GESTURE_POINT_TYPE * d1,GESTURE_POINT_TYPE * d2,int sqrt_able)2749 static int GestureDistance(GESTURE_POINT_TYPE* d1,GESTURE_POINT_TYPE* d2,int sqrt_able)
2750 {
2751 if(sqrt_able)
2752 return GestureSqrt((d1->other.x - d2->other.x) *
2753 (d1->other.x - d2->other.x) +
2754 (d1->other.y - d2->other.y) *
2755 (d1->other.y - d2->other.y));
2756 else
2757 return (d1->other.x - d2->other.x) *
2758 (d1->other.x - d2->other.x) +
2759 (d1->other.y - d2->other.y) *
2760 (d1->other.y - d2->other.y);
2761 }
2762
GesturePush(GESTURE_POINT_TYPE * data)2763 static int GesturePush(GESTURE_POINT_TYPE* data)
2764 {
2765 if(gesture_num >= GESTURE_BUF_SIZE)
2766 return FALSE;
2767 if(gesture_num == 0)
2768 {
2769 gesture_buf[gesture_num ++].all = data->all & 0xffff0fff;
2770 return TRUE;
2771 }
2772 if(GestureDistance(data,&gesture_buf[gesture_num-1],TRUE) <= gesture_dis_min)
2773 return FALSE;
2774 gesture_buf[gesture_num ++].all = data->all & 0xffff0fff;
2775 return TRUE;
2776 }
2777
GestureInit(void)2778 static void GestureInit(void)
2779 {
2780 gesture_num_last = gesture_num;
2781 gesture_num = 0;
2782 gesture_deal = FALSE;
2783 if(gesture_dis_min < 0 || gesture_dis_min > 64)
2784 gesture_dis_min = 2;
2785 }
2786
GestureStretch(void)2787 static int GestureStretch(void)
2788 {
2789 unsigned int x_max=0,x_min=0xffff,y_max=0,y_min=0xffff;
2790 int i;
2791 // if(gesture_num <= GESTURE_SIZE_NUM/2)
2792 // return FALSE;
2793 if(gesture_num >= GESTURE_BUF_SIZE)
2794 return FALSE;
2795 for(i=0;i<gesture_num;i++)
2796 {
2797 if(gesture_buf[i].other.x > x_max)
2798 x_max = gesture_buf[i].other.x;
2799 if (gesture_buf[i].other.x < x_min)
2800 x_min = gesture_buf[i].other.x;
2801 if (gesture_buf[i].other.y > y_max)
2802 y_max = gesture_buf[i].other.y;
2803 if (gesture_buf[i].other.y < y_min)
2804 y_min = gesture_buf[i].other.y;
2805 }
2806 if(x_max < x_min+64*2 || y_max < y_min+64*3)
2807 return FALSE;
2808 for(i=0;i<gesture_num;i++)
2809 {
2810 gesture_buf[i].other.x = (gesture_buf[i].other.x - x_min) *
2811 GESTURE_SIZE_REFE / (x_max - x_min);
2812 gesture_buf[i].other.y = (gesture_buf[i].other.y - y_min) *
2813 GESTURE_SIZE_REFE / (y_max - y_min);
2814 }
2815 return TRUE;
2816 }
2817
GestureLength(void)2818 static int GestureLength(void)
2819 {
2820 int i;
2821 int len = 0;
2822 for(i=1;i<gesture_num;i++)
2823 {
2824 len += GestureDistance(&gesture_buf[i],&gesture_buf[i-1],TRUE);
2825 }
2826 return len;
2827 }
2828
GestureStandard(void)2829 static void GestureStandard(void)
2830 {
2831 int i,n,t;
2832 int len_now = 0;
2833 int len_his = 0;
2834 int len_total = GestureLength();
2835 gesture_standard[0].all = gesture_buf[0].all&0x0fffffff;
2836 gesture_standard[GESTURE_SIZE_NUM - 1].all =
2837 gesture_buf[gesture_num -1].all&0x0fffffff;
2838 for(i=1,n=0;i<GESTURE_SIZE_NUM-1;i++)
2839 {
2840 while(++n<gesture_num)
2841 {
2842 len_now = GestureDistance(&gesture_buf[n],&gesture_buf[n-1],TRUE);
2843 len_his += len_now;
2844 if(len_his*(GESTURE_SIZE_NUM-1) >= len_total*i)
2845 break;
2846 }
2847 if(n >= gesture_num || len_now == 0)
2848 break;
2849 gesture_standard[i].all = 0;
2850 t = (int)gesture_buf[n - 1].other.x
2851 + ((int)gesture_buf[n].other.x - (int)gesture_buf[n - 1].other.x)
2852 * ((int)len_total*i/(GESTURE_SIZE_NUM-1) - (int)len_his + (int)len_now)
2853 / (int)len_now
2854 ;
2855 if(t < 0)
2856 t = 0;
2857 gesture_standard[i].other.x = t;
2858 t = (int)gesture_buf[n - 1].other.y
2859 + ((int)gesture_buf[n].other.y - (int)gesture_buf[n - 1].other.y)
2860 * ((int)len_total*i/(GESTURE_SIZE_NUM-1) - (int)len_his + (int)len_now)
2861 / (int)len_now
2862 ;
2863 if(t < 0)
2864 t = 0;
2865 gesture_standard[i].other.y = t;
2866 n--;
2867 len_his -= len_now;
2868 }
2869 }
2870
GestureModel(const GESTURE_MODEL_TYPE * model,int len,int threshold,int * out)2871 static int GestureModel(const GESTURE_MODEL_TYPE * model,int len,int threshold,int *out)
2872 {
2873 int offset[] = {-2,-1,0,1,2};
2874 int ret_offset;
2875 int i,j,k,n;
2876 int min,min_n;
2877 GESTURE_POINT_TYPE model_coor;
2878 if(model == NULL || threshold <= 0)
2879 {
2880 *out = 0x7fffffff;
2881 return 0x7fffffff;
2882 }
2883 min=0x7fffffff;
2884 min_n = 0;
2885 for(j=0;j<len;j++)
2886 {
2887 for(k=0;k<sizeof(offset)/sizeof(offset[0]);k++)
2888 {
2889 n = 0;
2890 ret_offset = 0;
2891 for(i=0;i<GESTURE_SIZE_NUM;i++)
2892 {
2893 if(i+offset[k] < 0 || i+offset[k] >= GESTURE_SIZE_NUM)
2894 continue;
2895 if((i&1)==0)
2896 model_coor.all = model[j].coor[i/2] & 0x00ff00ff;
2897 else
2898 model_coor.all = (model[j].coor[i/2]>>8) & 0x00ff00ff;
2899 ret_offset += GestureDistance(&gesture_standard[i+offset[k]],&model_coor,FALSE);
2900 n ++;
2901 }
2902 if(n == 0)
2903 continue;
2904 ret_offset = ret_offset / n * model[j].coe / 0x10;//coe <0x3fff
2905 if(ret_offset < min)
2906 {
2907 min_n = j;
2908 min = ret_offset;
2909 }
2910 }
2911 }
2912 if(min < threshold)
2913 *out = model[min_n].out;
2914 else
2915 *out = 0x7fffffff;
2916 return min;
2917 }
2918
ChangeXY(void)2919 static void ChangeXY(void)
2920 {
2921 int i;
2922 for(i=0;i<gesture_num && i<GESTURE_BUF_SIZE;i++)
2923 gesture_buf[i].all = ((gesture_buf[i].all & 0xfff) << 16) +
2924 ((gesture_buf[i].all>>16) & 0xffff);
2925 }
2926
GestureSet(unsigned int conf[])2927 static void GestureSet(unsigned int conf[])
2928 {
2929 if(conf == NULL)
2930 return;
2931 //if(conf[0] >= 0 && conf[0] <= 64)
2932 if (conf[0] <= 64)
2933 gesture_dis_min = conf[0];
2934 else
2935 gesture_dis_min = 0;
2936 if(conf[1] != 0)
2937 gesture_threshold[0] = conf[1];
2938 else
2939 gesture_threshold[0] = 0xfff;
2940 gesture_threshold[1] = conf[2];
2941 x_scale = (conf[3]==0) ? 4 : conf[3];
2942 y_scale = (conf[4]==0) ? 4 : conf[4];
2943 if(conf[5] == 0)
2944 {
2945 double_down = 2;
2946 double_up = 30;
2947 }
2948 else
2949 {
2950 double_down = conf[5] & 0xffff;
2951 double_up = conf[5] >> 16;
2952 }
2953 }
2954
GestureDeal(void)2955 static int GestureDeal(void)
2956 {
2957 int i;
2958 int gesture_out[2];
2959 int gesture_val[2];
2960
2961 //while(1)
2962 for (;;)
2963 {
2964 gesture_last = double_click;
2965 if(gesture_last)
2966 break;
2967 if(gesture_deal & GESTURE_XY)
2968 {
2969 gesture_deal &= ~GESTURE_XY;
2970 ChangeXY();
2971 }
2972 if((gesture_deal & GESTURE_DEAL) == 0)
2973 return FALSE;
2974 gesture_deal &= ~GESTURE_DEAL;
2975 gesture_last = GestureLRUD();
2976 if(gesture_last)
2977 break;
2978 if(GestureStretch() == FALSE)
2979 break;
2980 GestureStandard();
2981 gesture_val[0] = GestureModel(model_default,
2982 sizeof(model_default)/sizeof(model_default[0]),
2983 gesture_threshold[0],&gesture_out[0]);
2984 gesture_val[1] = GestureModel(model_extern,
2985 model_extern_len,gesture_threshold[1],&gesture_out[1]);
2986 gesture_last = 0x7fffffff;
2987 for(i=0;i<2;i++)
2988 {
2989 if(gesture_val[i] <= gesture_last)
2990 {
2991 // gesture_value = gesture_val[i];
2992 gesture_last = gesture_out[i];
2993 }
2994 }
2995 break;
2996 }
2997 GestureInit();
2998 return gesture_last;
2999 }
3000
gsl_GestureExtern(const GESTURE_MODEL_TYPE * model,int len)3001 void gsl_GestureExtern(const GESTURE_MODEL_TYPE *model,int len)
3002 {
3003 model_extern = model;
3004 model_extern_len = len;
3005 }
3006 //EXPORT_SYMBOL(gsl_GestureExtern);
3007
GestureLRUD(void)3008 static int GestureLRUD(void)
3009 {
3010 int x1=0,y1=0,x2=0,y2=0,i=0;
3011 int flag3=0;
3012 int middle_x;
3013 int middle_y;
3014 int min_scale=5;
3015 // printk("flag3,gesture_deal=%x\n",gesture_deal);
3016 if(gesture_deal & GESTURE_XY)
3017 {
3018 gesture_deal &= ~GESTURE_XY;
3019 ChangeXY();
3020 // printk("flag3,ChangeXY_GestureLRUD,gesture_deal=%x\n",gesture_deal);
3021 }
3022 if((gesture_deal & GESTURE_LRUD) == 0)
3023 return FALSE;
3024 gesture_deal &= ~GESTURE_LRUD;
3025 // int screen_x_max=0,screen_y_max=0;
3026 x1 = gesture_buf[0].other.x;//480
3027 y1 = gesture_buf[0].other.y;//800
3028 x2 = gesture_buf[gesture_num - 1].other.x;
3029 y2 = gesture_buf[gesture_num - 1].other.y;
3030 // if(!x1&&!y1&&!x2&&!y2)
3031 // return '6';
3032 middle_x =( x1 + x2)/2;
3033 middle_y = (y1 + y2)/2;
3034 for(i=1;i<gesture_num;i++)
3035 {
3036 if (abs(gesture_buf[i].other.x - middle_x)<(int)sen_num_nokey * 64 / x_scale)//screen_y_max/8)//30
3037 flag3|=0x1;
3038 else
3039 flag3|=0x2;
3040 if (abs(gesture_buf[i].other.y - middle_y)<(int)drv_num_nokey * 64 / y_scale)//screen_x_max/8)//25
3041 flag3|=(0x1<<4);
3042 else
3043 flag3|=(0x2<<4);
3044 if ((int)gesture_buf[i].other.x - (int)gesture_buf[i - 1].other.x>min_scale)
3045 flag3|=(0x1<<8);
3046 else if ((int)gesture_buf[i].other.x - (int)gesture_buf[i - 1].other.x<-min_scale)
3047 flag3|=(0x2<<8);
3048 if ((int)gesture_buf[i].other.y - (int)gesture_buf[i - 1].other.y>min_scale)
3049 flag3|=(0x1<<12);
3050 else if ((int)gesture_buf[i].other.y - (int)gesture_buf[i - 1].other.y<-min_scale)
3051 flag3|=(0x2<<12);
3052 }
3053 // printk("flag3_____flag3=%x,x_scale=%d,y_scale=%d\n",flag3,x_scale,y_scale);
3054 // if(flag3&&!point_num)
3055 // {
3056 // printk("flag3,x1=%d,y1=%d,x2=%d,y2=%d,screen_x_max=%d,screen_y_max=%d\n",x1,y1,x2,y2,screen_x_max,screen_y_max);
3057 // printk("flag3====== %x,x1-x2=%d,x2-x1=%d,y1-y2=%d,y2-y1=%d\n",flag3,x1-x2,x2-x1,y1-y2,y2-y1);
3058 // }
3059 // if(!point_num)
3060 // if(1)
3061 {
3062 if((flag3==0x2031||flag3==0x2131||flag3==0x2231||flag3==0x2331))//&&(y2-y1>screen_x_max/3))
3063 return 0xa1fc;//up(a1,fc)
3064 else if((flag3==0x1031||flag3==0x1131||flag3==0x1231||flag3==0x1331))//&&(y1-y2>screen_x_max/3))
3065 return 0xa1fd;//down
3066 else if((flag3==0x213||flag3==0x1213||flag3==0x2213||flag3==0x2213))//&&(x2-x1>screen_y_max/3))
3067 return 0xa1fb;//left
3068 else if((flag3==0x113||flag3==0x1113||flag3==0x2113||flag3==0x3113))//&&(x1-x2>screen_y_max/3))
3069 return 0xa1fa;//right
3070 // if(abs(x2-x1)<64*4&&abs(y2-y1)<64*6)
3071 // return (int)'5';
3072 }
3073 return FALSE;
3074 }
3075
gsl_GestureBuffer(unsigned int ** buf)3076 unsigned int gsl_GestureBuffer(unsigned int **buf)
3077 {
3078 int i;
3079 if(gesture_num_last >= GESTURE_BUF_SIZE)
3080 gesture_num_last = GESTURE_BUF_SIZE - 1;
3081 for(i=0;i<gesture_num_last;i++)
3082 {
3083 gesture_buf[i].all = ScreenResolution((gsl_POINT_TYPE*)(&gesture_buf[i].all));
3084 }
3085 *buf = &(gesture_buf[0].all);
3086 return gesture_num_last;
3087 }
3088 //EXPORT_SYMBOL(gsl_GestureBuffer);
3089 #endif
3090 /*
3091 // The DLL must have an entry point, but it is never called.
3092 //
3093 NTSTATUS
3094 DriverEntry(
3095 IN PDRIVER_OBJECT DriverObject,
3096 IN PUNICODE_STRING RegistryPath
3097 )
3098 {
3099 return STATUS_SUCCESS;
3100 }*/
3101