source: proto/u16u8/u16u8.c @ 385

Last change on this file since 385 was 385, checked in by lindanl, 9 years ago

Optimization for ASCII streams

File size: 19.5 KB
Line 
1#include <stdio.h>
2#include <stdlib.h>
3#include <errno.h>
4#include <stdint.h>
5#include <string.h>
6#include <sys/types.h>
7#include <sys/stat.h>
8#include "lib/lib_simd.h"
9#define min(x,y) ((x) <(y) ?(x) :(y) )  \
10
11typedef SIMD_type BytePack;
12typedef SIMD_type BitBlock;
13
14
15#define BUFFER_PROFILING
16#define BUFFER_SIZE 10000
17#ifdef BUFFER_PROFILING
18#include "Profiling/BOM_Profiler.c"
19BOM_Table * transcode_timer;
20#endif
21
22/*===========================================================================*/
23/* UErrorCode */
24/* Extracted from ICU */
25/*===========================================================================*/
26
27typedef enum UErrorCode {
28
29    U_ZERO_ERROR              =  0,     /**< No error, no warning. */
30    U_TRUNCATED_CHAR_FOUND    = 11,     /**< Character conversion: Incomplete input sequence. */
31    U_ILLEGAL_CHAR_FOUND      = 12,     /**< Character conversion: Illegal input sequence/combination of input units. */
32} UErrorCode;
33
34typedef  uint16_t UChar;
35
36#define s2p_step(s0,s1,hi_mask,shift,p0,p1)  \
37{ \
38BitBlock t0,t1; \
39t0= simd_pack_16_hh(s0,s1) ; \
40t1= simd_pack_16_ll(s0,s1) ; \
41p0= simd_if(hi_mask,t0,simd_srli_16(t1,shift) ) ; \
42p1= simd_if(hi_mask,simd_slli_16(t0,shift) ,t1) ; \
43} \
44
45#define s2p_bytepack(s0,s1,s2,s3,s4,s5,s6,s7,p0,p1,p2,p3,p4,p5,p6,p7)  \
46{BitBlock bit00224466_0,bit00224466_1,bit00224466_2,bit00224466_3; \
47BitBlock bit11335577_0,bit11335577_1,bit11335577_2,bit11335577_3; \
48BitBlock bit00004444_0,bit22226666_0,bit00004444_1,bit22226666_1; \
49BitBlock bit11115555_0,bit33337777_0,bit11115555_1,bit33337777_1; \
50s2p_step(s0,s1,simd_himask_2,1,bit00224466_0,bit11335577_0)  \
51s2p_step(s2,s3,simd_himask_2,1,bit00224466_1,bit11335577_1)  \
52s2p_step(s4,s5,simd_himask_2,1,bit00224466_2,bit11335577_2)  \
53s2p_step(s6,s7,simd_himask_2,1,bit00224466_3,bit11335577_3)  \
54s2p_step(bit00224466_0,bit00224466_1,simd_himask_4,2,bit00004444_0,bit22226666_0)  \
55s2p_step(bit00224466_2,bit00224466_3,simd_himask_4,2,bit00004444_1,bit22226666_1)  \
56s2p_step(bit11335577_0,bit11335577_1,simd_himask_4,2,bit11115555_0,bit33337777_0)  \
57s2p_step(bit11335577_2,bit11335577_3,simd_himask_4,2,bit11115555_1,bit33337777_1)  \
58s2p_step(bit00004444_0,bit00004444_1,simd_himask_8,4,p0,p4)  \
59s2p_step(bit11115555_0,bit11115555_1,simd_himask_8,4,p1,p5)  \
60s2p_step(bit22226666_0,bit22226666_1,simd_himask_8,4,p2,p6)  \
61s2p_step(bit33337777_0,bit33337777_1,simd_himask_8,4,p3,p7)  \
62} \
63
64#define p2s_step(p0,p1,hi_mask,shift,s0,s1)  \
65{ \
66BitBlock t0,t1; \
67t0= simd_if(hi_mask,p0,simd_srli_16(p1,shift) ) ; \
68t1= simd_if(hi_mask,simd_slli_16(p0,shift) ,p1) ; \
69s0= simd_mergeh_8(t0,t1) ; \
70s1= simd_mergel_8(t0,t1) ; \
71} \
72
73#define p2s_bytemerge(p0,p1,p2,p3,p4,p5,p6,p7,s0,s1,s2,s3,s4,s5,s6,s7)  \
74{ \
75BitBlock bit00004444_0,bit22226666_0,bit00004444_1,bit22226666_1; \
76BitBlock bit11115555_0,bit33337777_0,bit11115555_1,bit33337777_1; \
77BitBlock bit00224466_0,bit00224466_1,bit00224466_2,bit00224466_3; \
78BitBlock bit11335577_0,bit11335577_1,bit11335577_2,bit11335577_3; \
79p2s_step(p0,p4,simd_himask_8,4,bit00004444_0,bit00004444_1)  \
80p2s_step(p1,p5,simd_himask_8,4,bit11115555_0,bit11115555_1)  \
81p2s_step(p2,p6,simd_himask_8,4,bit22226666_0,bit22226666_1)  \
82p2s_step(p3,p7,simd_himask_8,4,bit33337777_0,bit33337777_1)  \
83p2s_step(bit00004444_0,bit22226666_0,simd_himask_4,2,bit00224466_0,bit00224466_1)  \
84p2s_step(bit11115555_0,bit33337777_0,simd_himask_4,2,bit11335577_0,bit11335577_1)  \
85p2s_step(bit00004444_1,bit22226666_1,simd_himask_4,2,bit00224466_2,bit00224466_3)  \
86p2s_step(bit11115555_1,bit33337777_1,simd_himask_4,2,bit11335577_2,bit11335577_3)  \
87p2s_step(bit00224466_0,bit11335577_0,simd_himask_2,1,s0,s1)  \
88p2s_step(bit00224466_1,bit11335577_1,simd_himask_2,1,s2,s3)  \
89p2s_step(bit00224466_2,bit11335577_2,simd_himask_2,1,s4,s5)  \
90p2s_step(bit00224466_3,bit11335577_3,simd_himask_2,1,s6,s7)  \
91} \
92
93
94static inline void interleave4(BitBlock p0, BitBlock p1, BitBlock p2, BitBlock p3, 
95                               BitBlock& s0, BitBlock& s1, BitBlock& s2, BitBlock& s3);
96
97static inline void interleave4(BitBlock p0, BitBlock p1, BitBlock p2, BitBlock p3, 
98                               BitBlock& s0, BitBlock& s1, BitBlock& s2, BitBlock& s3){
99        BitBlock hpair0 = simd_mergel_1(p1, p0);
100        BitBlock hpair1 = simd_mergeh_1(p1, p0);
101        BitBlock lpair0 = simd_mergel_1(p3, p2);
102        BitBlock lpair1 = simd_mergeh_1(p3, p2);
103        s0 = simd_mergel_2(lpair0,hpair0);
104        s1 = simd_mergeh_2(lpair0,hpair0);
105        s2 = simd_mergel_2(lpair1,hpair1);
106        s3 = simd_mergeh_2(lpair1,hpair1);
107}
108
109
110
111
112#define do_right16_shifts(vec,rshift1,rshift2,rshift4,rshift8)  \
113{BitBlock s2; \
114vec= simd_sub_16(vec,simd_srli_16(simd_and(rshift1,vec) ,1) ) ; \
115s2= simd_and(rshift2,vec) ; \
116vec= simd_or(simd_srli_16(s2,2) ,simd_xor(vec,s2) ) ; \
117s2= simd_and(rshift4,vec) ; \
118vec= simd_or(simd_srli_16(s2,4) ,simd_xor(vec,s2) ) ; \
119s2= simd_and(rshift8,vec) ; \
120vec= simd_or(simd_srli_16(s2,8) ,simd_xor(vec,s2) ) ; \
121}
122
123static inline void bit_del_16(BitBlock &s, BitBlock delmask){
124        BitBlock del16_rshift1;
125        BitBlock del16_rshift2;
126        BitBlock del16_rshift4;
127        BitBlock del16_rshift8;
128       
129        BitBlock del16_trans2;
130        BitBlock del16_trans4;
131        BitBlock del16_trans8;
132        BitBlock shift_bits;
133       
134        del16_rshift1= simd_xor(simd_slli_16(delmask,1),simd_slli_16(delmask,2));
135        del16_rshift1= simd_xor(del16_rshift1,simd_slli_16(del16_rshift1,2));
136        del16_rshift1= simd_xor(del16_rshift1,simd_slli_16(del16_rshift1,4));
137        del16_rshift1= simd_xor(del16_rshift1,simd_slli_16(del16_rshift1,8));
138       
139        del16_trans2= simd_and(del16_rshift1,delmask);
140        del16_rshift2= simd_xor(simd_slli_16(del16_trans2,1),simd_slli_16(del16_trans2,2));
141        del16_rshift2= simd_xor(del16_rshift2,simd_slli_16(del16_rshift2,2));
142        del16_rshift2= simd_xor(del16_rshift2,simd_slli_16(del16_rshift2,4));
143        del16_rshift2= simd_xor(del16_rshift2,simd_slli_16(del16_rshift2,8));
144       
145        del16_trans4= simd_and(del16_rshift2,del16_trans2);
146        del16_rshift4= simd_xor(simd_slli_16(del16_trans4,1),simd_slli_16(del16_trans4,2));
147        del16_rshift4= simd_xor(del16_rshift4,simd_slli_16(del16_rshift4,2));
148        del16_rshift4= simd_xor(del16_rshift4,simd_slli_16(del16_rshift4,4));
149        del16_rshift4= simd_xor(del16_rshift4,simd_slli_16(del16_rshift4,8));
150       
151        del16_trans8= simd_and(del16_rshift4,del16_trans4);
152        del16_rshift8= simd_xor(simd_slli_16(del16_trans8,1),simd_slli_16(del16_trans8,2));
153        del16_rshift8= simd_xor(del16_rshift8,simd_slli_16(del16_rshift8,2));
154        del16_rshift8= simd_xor(del16_rshift8,simd_slli_16(del16_rshift8,4));
155        del16_rshift8= simd_xor(del16_rshift8,simd_slli_16(del16_rshift8,8));
156       
157        del16_rshift1= simd_andc(del16_rshift1,delmask);
158        del16_rshift2= simd_andc(del16_rshift2,delmask);
159        del16_rshift4= simd_andc(del16_rshift4,delmask);
160        del16_rshift8= simd_andc(del16_rshift8,delmask);
161       
162        del16_rshift2= simd_sub_16(del16_rshift2,simd_srli_16(simd_and(del16_rshift1,del16_rshift2),1));
163       
164        del16_rshift4= simd_sub_16(del16_rshift4,simd_srli_16(simd_and(del16_rshift1,del16_rshift4),1));
165        shift_bits= simd_and(del16_rshift2,del16_rshift4);
166        del16_rshift4= simd_or(simd_srli_16(shift_bits,2),simd_xor(del16_rshift4,shift_bits));
167       
168        del16_rshift8= simd_sub_16(del16_rshift8,simd_srli_16(simd_and(del16_rshift1,del16_rshift8),1));
169        shift_bits= simd_and(del16_rshift2,del16_rshift8);
170        del16_rshift8= simd_or(simd_srli_16(shift_bits,2),simd_xor(del16_rshift8,shift_bits)); 
171        shift_bits= simd_and(del16_rshift4,del16_rshift8);
172        del16_rshift8= simd_or(simd_srli_16(shift_bits,4),simd_xor(del16_rshift8,shift_bits));
173       
174        s = simd_andc(s, delmask);
175        do_right16_shifts (s, del16_rshift1, del16_rshift2, del16_rshift4,  del16_rshift8)
176
177}
178
179
180static inline void del_count(BitBlock delmask, short *u8_bytes_per_reg){
181
182BitBlock delcounts_2;
183BitBlock delcounts_4;
184BitBlock delcounts_8;
185BitBlock delcounts_16;
186
187delcounts_2 = simd_add_2_lh(delmask, delmask);
188delcounts_4 = simd_add_4_lh(delcounts_2, delcounts_2);
189delcounts_8 = simd_add_8_lh(delcounts_4, delcounts_4);
190delcounts_16 = simd_add_16_lh(delcounts_8, delcounts_8);
191sisd_store_aligned(simd_sub_16(simd_const_16(16), delcounts_16), (BytePack *) &u8_bytes_per_reg[0]);
192}
193
194#define double_int64_adc(x1, x2, y1, y2, rslt1, rslt2, carry) \
195  __asm__  ("sahf\n\t" \
196            "adc %[e1], %[z1]\n\t" \
197            "adc %[e2], %[z2]\n\t" \
198            "lahf\n\t" \
199         : [z1] "=r" (rslt1), [z2] "=r" (rslt2), [carry] "=a" (carry) \
200         : "[z1]" (x1), "[z2]" (x2), \
201           [e1] "r" (y1), [e2] "r" (y2), \
202           "[carry]" (carry) \
203         : "cc")
204
205static inline BitBlock adc128(BitBlock first, BitBlock second, int &carry)
206{
207  union {__m128i bitblock;
208         uint64_t int64[2];} rslt;
209
210  union {__m128i bitblock;
211         uint64_t int64[2];} x;
212
213  union {__m128i bitblock;
214         uint64_t int64[2];} y;
215
216  x.bitblock = first;
217  y.bitblock = second;
218
219  double_int64_adc(x.int64[0], x.int64[1], y.int64[0], y.int64[1], 
220                   rslt.int64[0], rslt.int64[1], carry);
221
222  return rslt.bitblock;
223}
224
225
226#define BLOCK_SIZE 128
227
228void u16u8(char ** targetbuf, const char * targetlimit, const UChar ** srcbuf, const UChar * srclimit, UErrorCode * err){
229
230        int carry1=0;
231        int carry0=0;
232        int carry2=0;
233        BitBlock hcarry;
234        BitBlock efghi_i;
235        BitBlock u8_2or3;
236        BitBlock Temp13;
237        BitBlock Temp12;
238        BitBlock Temp11;
239        BitBlock Temp10;
240        BitBlock Temp17;
241        BitBlock Temp16;
242        BitBlock Temp15;
243        BitBlock Temp14;
244        BitBlock Temp19;
245        BitBlock Temp18;
246        BitBlock Temp31;
247        BitBlock Temp30;
248        BitBlock Temp33;
249        BitBlock Temp32;
250        BitBlock Temp35;
251        BitBlock Temp34;
252        BitBlock Temp37;
253        BitBlock Temp36;
254        BitBlock above_0x7F;
255        BitBlock above_0x7FF;
256        BitBlock gcarry;
257        BitBlock efghi_h;
258        BitBlock efghi_g;
259        BitBlock efghi_f;
260        BitBlock efghi_e;
261        BitBlock AllOne = simd_const_1(1);
262        BitBlock AllZero = simd_const_1(0);
263        BitBlock Temp28;
264        BitBlock Temp29;
265        BitBlock Temp22;
266        BitBlock Temp23;
267        BitBlock Temp20;
268        BitBlock Temp21;
269        BitBlock Temp26;
270        BitBlock Temp27;
271        BitBlock Temp24;
272        BitBlock Temp25;
273        BitBlock Temp3;
274        BitBlock Temp2;
275        BitBlock Temp1;
276        BitBlock Temp7;
277        BitBlock Temp6;
278        BitBlock Temp5;
279        BitBlock Temp4;
280        BitBlock Temp9;
281        BitBlock Temp8;
282        BitBlock u16h[8];
283        BitBlock u8_last[8];
284        BitBlock u8_pre[8];
285        BitBlock u16l[8];
286        BitBlock u8_butlast[8];
287        struct __u16__{
288                BitBlock lsurrogate;
289                BitBlock surrogate;
290                BitBlock ASCII;
291                BitBlock hsurrogate;
292                BitBlock error;
293                BitBlock utf8_2;
294                BitBlock utf8_3;
295        };
296        struct __u16__ u16;
297       
298       
299        BytePack * U16;
300        BytePack U16h[8];
301        BytePack U16l[8];
302       
303        BitBlock doublepair[32];
304       
305        BitBlock endmask;
306       
307        BitBlock delmask[4];
308       
309        BitBlock U8[32];
310       
311        int target_bckup_steps = 0;
312        int pos = 0;
313       
314        int  units_read  = 0;
315       
316        bool error_found = false;
317        int err_pos;
318
319
320
321        do {
322
323                U16 = (BytePack *)(*srcbuf);
324                units_read = min(srclimit-(*srcbuf),BLOCK_SIZE);
325                if(units_read < BLOCK_SIZE){
326                        endmask = sisd_sll(simd_const_1(1),sisd_from_int(units_read));
327                //      ((uint16_t *) U16)[units_read/2] = 0;
328                }
329                else endmask = simd_const_1(0);
330                u16l[0] = simd_const_1(0);
331                for (int i=0; i< 8; i++){
332                        U16h[i] = simd_pack_16_ll(sisd_load_unaligned(&U16[i*2+1]),sisd_load_unaligned(&U16[i*2]));
333                        U16l[i] = simd_pack_16_hh(sisd_load_unaligned(&U16[i*2+1]),sisd_load_unaligned(&U16[i*2]));
334                        u16l[0] = simd_or(u16l[0], simd_and(U16l[i], simd_const_8(0x80)));
335                }
336                above_0x7F = simd_or(simd_or(simd_or(simd_or(U16h[0], U16h[1]), simd_or(U16h[2], U16h[3])),
337                                              simd_or(simd_or(U16h[4], U16h[5]), simd_or(U16h[6], U16h[7]))),u16l[0]);
338               
339                if(!bitblock_has_bit(above_0x7F)){
340                        for (int i=0; i< 8; i++){
341                                sisd_store_unaligned(U16l[i],(SIMD_type *) (*targetbuf));
342                                *targetbuf += 16;
343                        }               
344                        *targetbuf -= (BLOCK_SIZE-units_read);
345                }
346//              else if(!bit_block_hasbit(above_0x7FF)){
347//                     
348//
349//              }
350                else{
351
352                        s2p_bytepack(U16l[7], U16l[6], U16l[5], U16l[4], U16l[3], U16l[2], U16l[1], U16l[0],
353                        u16l[0], u16l[1], u16l[2], u16l[3], u16l[4], u16l[5], u16l[6], u16l[7]);
354
355                        s2p_bytepack(U16h[7], U16h[6], U16h[5], U16h[4], U16h[3], U16h[2], U16h[1], U16h[0],
356                        u16h[0], u16h[1], u16h[2], u16h[3], u16h[4], u16h[5], u16h[6], u16h[7]);
357                       
358                        Temp1 = simd_or(u16h[0],u16h[1]);
359                        Temp2 = simd_or(u16h[2],u16h[3]);
360                        Temp3 = simd_or(Temp1,Temp2);
361                        above_0x7FF = simd_or(Temp3,u16h[4]);
362                        Temp4 = simd_or(above_0x7FF,u16h[5]);
363                        Temp5 = simd_or(u16h[6],u16h[7]);
364                        Temp6 = simd_or(Temp4,Temp5);
365                        above_0x7F = simd_or(Temp6,u16l[0]);
366
367                        Temp7 = simd_and(u16h[0],u16h[1]);
368                        Temp8 = simd_andc(u16h[3],u16h[2]);
369                        Temp9 = simd_and(Temp7,Temp8);
370                        u16.surrogate = simd_and(Temp9,u16h[4]);
371                        u16.hsurrogate = simd_andc(u16.surrogate,u16h[5]);
372                        u16.lsurrogate = simd_and(u16.surrogate,u16h[5]);
373                        u16.utf8_3 = simd_andc(above_0x7FF,u16.surrogate);
374                        u16.utf8_2 = simd_andc(above_0x7F,above_0x7FF);
375                        u16.ASCII = simd_andc(AllOne,above_0x7F);
376                        Temp10 = adc128(u16.hsurrogate,u16.hsurrogate,carry0);
377                        u16.error = simd_xor(Temp10,u16.lsurrogate);
378                        efghi_i = simd_andc(AllOne,u16l[1]);
379                        efghi_h = simd_xor(u16l[0],u16l[1]);
380                        hcarry = simd_andc(u16l[0],efghi_h);
381                        efghi_g = simd_xor(u16h[7],hcarry);
382                        gcarry = simd_andc(u16h[7],efghi_g);
383                        efghi_f = simd_xor(u16h[6],gcarry);
384                        efghi_e = simd_andc(u16h[6],efghi_f);
385                        u8_last[0] = simd_andc(AllOne,u16.ASCII);
386                        u8_last[1] = simd_and(u16.ASCII,u16l[1]);
387                        Temp11 = simd_andc(u16l[2],u16.hsurrogate);
388                        Temp12 = simd_and(efghi_h,u16.hsurrogate);
389                        u8_last[2] = simd_or(Temp11,Temp12);
390                        Temp13 = simd_andc(u16l[3],u16.hsurrogate);
391                        Temp14 = simd_and(efghi_i,u16.hsurrogate);
392                        u8_last[3] = simd_or(Temp13,Temp14);
393                        Temp15 = simd_andc(u16l[4],u16.hsurrogate);
394                        Temp16 = simd_and(u16l[2],u16.hsurrogate);
395                        u8_last[4] = simd_or(Temp15,Temp16);
396                        Temp17 = simd_andc(u16l[5],u16.hsurrogate);
397                        Temp18 = simd_and(u16l[3],u16.hsurrogate);
398                        u8_last[5] = simd_or(Temp17,Temp18);
399                        Temp19 = simd_andc(u16l[6],u16.hsurrogate);
400                        Temp20 = simd_and(u16l[4],u16.hsurrogate);
401                        u8_last[6] = simd_or(Temp19,Temp20);
402                        Temp21 = simd_andc(u16l[7],u16.hsurrogate);
403                        Temp22 = simd_and(u16l[5],u16.hsurrogate);
404                        u8_last[7] = simd_or(Temp21,Temp22);
405                        u8_2or3 = simd_or(u16.utf8_2,u16.utf8_3);
406                        u8_butlast[0] = simd_andc(AllOne,u16.ASCII);
407                        u8_butlast[1] = simd_or(u16.utf8_2,u16.hsurrogate);
408                        Temp23 = simd_and(u16.utf8_3,u16h[4]);
409                        Temp24 = simd_or(u16.hsurrogate,Temp23);
410                        Temp25 = adc128(u16l[6],u16l[6],carry1);
411                        Temp26 = simd_and(u16.lsurrogate,Temp25);
412                        u8_butlast[2] = simd_or(Temp24,Temp26);
413                        Temp27 = simd_and(u8_2or3,u16h[5]);
414                        Temp28 = simd_or(u16.hsurrogate,Temp27);
415                        Temp29 = adc128(u16l[7],u16l[7],carry2);
416                        Temp30 = simd_and(u16.lsurrogate,Temp29);
417                        u8_butlast[3] = simd_or(Temp28,Temp30);
418                        Temp31 = simd_or(u16.hsurrogate,u16.ASCII);
419                        u8_butlast[4] = simd_andc(u16h[6],Temp31);
420                        Temp32 = simd_andc(u16h[7],Temp31);
421                        Temp33 = simd_and(efghi_e,u16.hsurrogate);
422                        u8_butlast[5] = simd_or(Temp32,Temp33);
423                        Temp34 = simd_andc(u16l[0],Temp31);
424                        Temp35 = simd_and(efghi_f,u16.hsurrogate);
425                        u8_butlast[6] = simd_or(Temp34,Temp35);
426                        Temp36 = simd_andc(u16l[1],Temp31);
427                        Temp37 = simd_and(efghi_g,u16.hsurrogate);
428                        u8_butlast[7] = simd_or(Temp36,Temp37);
429                        u8_pre[0] = simd_andc(above_0x7FF,u16.surrogate);
430                        u8_pre[1] = simd_andc(above_0x7FF,u16.surrogate);
431                        u8_pre[2] = simd_andc(above_0x7FF,u16.surrogate);
432                        u8_pre[3] = AllZero;
433                        u8_pre[4] = simd_and(u16.utf8_3,u16h[0]);
434                        u8_pre[5] = simd_and(u16.utf8_3,u16h[1]);
435                        u8_pre[6] = simd_and(u16.utf8_3,u16h[2]);
436                        u8_pre[7] = simd_and(u16.utf8_3,u16h[3]);
437                       
438                       
439//                      u16.error = simd_andc(u16.error,endmask);
440                        if (bitblock_has_bit(u16.error)) {
441                       
442                        err_pos = count_forward_zeroes(u16.error);
443                        error_found = true;
444                                if ((err_pos == units_read)) {
445                                        err_pos--;
446                                        *err = U_TRUNCATED_CHAR_FOUND;
447                                        (*srcbuf) += err_pos;
448                                }
449                                else {
450                                        if((((unsigned char *)U16h)[err_pos]< 0xDC) || (((unsigned char *)U16h)[err_pos] >= 0xE0))
451                                                err_pos--;
452                                        *err = U_ILLEGAL_CHAR_FOUND;
453                                        (*srcbuf) += err_pos;
454                                        if(err_pos<0){
455                                                target_bckup_steps = 2;
456                                                (*targetbuf) -= target_bckup_steps;
457                                                return;
458                                        }
459                                }
460                                endmask = sisd_sll(simd_const_1(1),sisd_from_int(err_pos));
461                        }
462                       
463                        for (int i=0; i< 8; i++){
464                                interleave4(simd_const_8(0), u8_pre[i], u8_butlast[i], u8_last[i],
465                                                        doublepair[i*4], doublepair[i*4+1], 
466                                                        doublepair[i*4+2], doublepair[i*4+3]);
467                        }
468                                interleave4(simd_const_1(1), simd_or(endmask, simd_not(u16.utf8_3)), 
469                                                        simd_or(endmask, u16.ASCII), endmask,
470                                                        delmask[0], delmask[1], delmask[2], delmask[3]);
471                       
472                       
473                        for (int i=0; i< 32; i=i+4){
474                                bit_del_16(doublepair[i],delmask[0]);
475                                bit_del_16(doublepair[i+1],delmask[1]);
476                                bit_del_16(doublepair[i+2],delmask[2]);
477                                bit_del_16(doublepair[i+3],delmask[3]);
478                        }
479
480                        short u8_bytes_per_reg[8];
481                       
482                        for (int i=0; i< 4; i++){
483                                p2s_bytemerge(doublepair[i],doublepair[4+i],doublepair[8+i],doublepair[12+i],doublepair[16+i],doublepair[20+i],doublepair[24+i],doublepair[28+i],
484                                                        U8[i*8+7],U8[i*8+6],U8[i*8+5],U8[i*8+4],U8[i*8+3],U8[i*8+2],U8[i*8+1],U8[i*8]);
485                                for(int k=0; k<8; k++) u8_bytes_per_reg[k] = 0;
486                                del_count(delmask[i],u8_bytes_per_reg);
487                               
488                                for(int j=0; j<8; j++){
489                                        sisd_store_unaligned(U8[i*8+j],(SIMD_type *) (*targetbuf));
490                                        *targetbuf += u8_bytes_per_reg[j];
491                                        if(*targetbuf>targetlimit)
492                                                printf("target buffer out of boundry!\n");
493                                }
494                        }
495                }
496        if(!error_found) (*srcbuf) += units_read;
497        } while ((units_read == BLOCK_SIZE) && !error_found);
498}
499
500
501
502
503int
504main(int argc, char * argv[]) {
505        char * infilename, * outfilename;       
506        FILE *infile, *outfile;
507        struct stat fileinfo;
508        const UChar * srcbuf;
509        const UChar * src_head;
510        const UChar * srclimit;
511        const char * targetlimit;
512        char * targetbuf;
513        char * target_head;
514        UErrorCode status;
515        int chars_read;
516        int buf_pos = 0;
517
518        if (argc < 2) {
519                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
520                exit(-1);
521        }
522
523        infilename = argv[1];
524        stat(infilename, &fileinfo);
525        infile = fopen(infilename, "rb");
526        if (!infile) {
527                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
528                exit(-1);
529        }
530       
531        if (argc < 3) outfile = stdout;
532        else {
533                outfilename = argv[2];
534                outfile = fopen(outfilename, "wb");
535                if (!outfile) {
536                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
537                        exit(-1);
538                }
539        }
540
541
542//      srcbuf = (UChar *) malloc(fileinfo.st_size+1);
543        srcbuf = (UChar *) malloc(BUFFER_SIZE+BLOCK_SIZE*2);
544        src_head = srcbuf;
545        if (!srcbuf) {
546              fprintf(stderr, "Error: buffer for %s of size %i cannot be created.\n", infilename, fileinfo.st_size+1);
547              exit(-1);
548        }
549
550        targetbuf = (char *) malloc(BUFFER_SIZE*2);
551        targetlimit = targetbuf + BUFFER_SIZE*2;
552        target_head = targetbuf;
553
554#ifdef BUFFER_PROFILING
555  transcode_timer = init_BOM_timer(BUFFER_SIZE);
556#endif
557
558        chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
559        srclimit = srcbuf + chars_read/2;
560
561        while(chars_read>0){
562//              printf("chars_read = %i\n",chars_read);
563#ifdef BUFFER_PROFILING
564start_BOM_interval(transcode_timer);
565#endif
566                u16u8(&targetbuf, targetlimit, &srcbuf, srclimit, &status);
567
568#ifdef BUFFER_PROFILING
569end_BOM_interval(transcode_timer);
570#endif
571                fwrite(target_head , 1 ,  targetbuf - target_head, outfile );
572
573                targetbuf = target_head;
574
575                if (status == U_ILLEGAL_CHAR_FOUND) {
576                        fprintf(stderr, "Illegal UTF-16 sequence at position %x in source.\n", buf_pos+chars_read-(srclimit-srcbuf)*2);
577                        printf("error at pos %i is %x%x\n",chars_read-(srclimit-srcbuf)*2,((char*)srcbuf)[chars_read-(srclimit-srcbuf)*2],((char*)srcbuf)[chars_read-(srclimit-srcbuf)*2]);
578                        exit(-1);
579                }
580                else if (status == U_TRUNCATED_CHAR_FOUND) {
581                        fprintf(stderr, "EOF with incomplete UTF-16 sequence at position %i in source.\n",buf_pos+chars_read-(srclimit-srcbuf)*2);
582                        exit(-1);
583                }
584                srcbuf = src_head;
585                buf_pos += chars_read;
586
587                chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE, infile);
588                srclimit = srcbuf + chars_read/2;
589        }
590#ifdef BUFFER_PROFILING
591  printf("transcode_timer!\n");
592  dump_BOM_table(transcode_timer);
593#endif
594        fclose(infile);
595        fclose(outfile);
596
597
598
599        return(0);
600}
Note: See TracBrowser for help on using the repository browser.