source: trunk/lib_ir/u8u16/src/u8u16.cpp @ 4051

Last change on this file since 4051 was 4051, checked in by linmengl, 5 years ago

add pure ir p2s, get the same performance on SSE2 now

File size: 35.7 KB
Line 
1#include <stdio.h>
2#include <stdlib.h>
3#include <errno.h>
4#include <string.h>
5#include <sys/types.h>
6#include <sys/stat.h>
7
8#include <simd-lib/bitblock.hpp>
9#include <simd-lib/carryQ.hpp>
10#include <simd-lib/pabloSupport.hpp>
11
12#include <simd-lib/s2p.h>
13#include <simd-lib/p2s.h>
14
15#define minimum(x,y) ((x) <(y) ?(x) :(y) )
16#include <iostream>
17using namespace std;
18
19#include <simd-lib/perflib/perfsec.h>
20
21// Profiling
22#if (defined(BUFFER_PROFILING) || defined(PAPI))
23  #include "../lib/perflib/perfsec.h"
24#endif
25
26#ifdef BUFFER_PROFILING
27    BOM_Table * transcode_timer;
28#elif PAPI
29                #define PAPI_EVENTS_COUNT 2
30                int PAPI_EVENTS[PAPI_EVENTS_COUNT] = {PAPI_TOT_CYC, PAPI_BR_MSP};
31    CC * transcode_timer;
32#else
33    void * transcode_timer;
34#endif
35
36
37/*===========================================================================*/
38/* UErrorCode */
39/* Extracted from ICU */
40/*===========================================================================*/
41
42typedef enum UErrorCode {
43
44    U_ZERO_ERROR              =  0,     /**< No error, no warning. */
45    U_TRUNCATED_CHAR_FOUND    = 11,     /**< Character conversion: Incomplete input sequence. */
46    U_ILLEGAL_CHAR_FOUND      = 12,     /**< Character conversion: Illegal input sequence/combination of input units. */
47} UErrorCode;
48
49typedef  uint16_t UChar;
50
51
52#define do_right8_shifts(vec, rshift1, rshift2, rshift4) \
53do { BitBlock s2; \
54  vec = simd<8>::sub(vec, simd<16>::srli<1>(simd_and(rshift1, vec))); \
55  s2 = simd_and(rshift2, vec);\
56  vec = simd_or(simd<16>::srli<2>(s2), simd_xor(vec, s2));\
57  s2 = simd_and(rshift4, vec);\
58  vec = simd_or(simd<16>::srli<4>(s2), simd_xor(vec, s2));\
59} while(0)
60
61static inline void del_info_8(BitBlock &del8_rshift1, BitBlock &del8_rshift2, BitBlock &del8_rshift4, BitBlock delmask){
62        BitBlock del8_trans2;
63        BitBlock del8_trans4;
64        BitBlock shift_bits;
65
66        del8_rshift1 = simd_xor(simd<8>::slli<1>(delmask), simd<8>::slli<2>(delmask));
67        del8_rshift1 = simd_xor(del8_rshift1, simd<8>::slli<2>(del8_rshift1));
68        del8_rshift1 = simd_xor(del8_rshift1, simd<8>::slli<4>(del8_rshift1));
69        /* Transition to even delcount: odd delcount to left, this one deleted. */
70        del8_trans2 = simd_and(del8_rshift1, delmask);
71        /* Odd number of transition positions to left. */
72        del8_rshift2 = simd_xor(simd<8>::slli<1>(del8_trans2), simd<8>::slli<2>(del8_trans2));
73        del8_rshift2 = simd_xor(del8_rshift2, simd<8>::slli<2>(del8_rshift2));
74        del8_rshift2 = simd_xor(del8_rshift2, simd<8>::slli<4>(del8_rshift2));
75        /* Transition positions: odd |del2count| to left, this one a transition to even. */
76        del8_trans4 = simd_and(del8_rshift2, del8_trans2);
77        del8_rshift4 = simd_xor(simd<8>::slli<1>(del8_trans4), simd<8>::slli<2>(del8_trans4));
78        del8_rshift4 = simd_xor(del8_rshift4, simd<8>::slli<2>(del8_rshift4));
79        del8_rshift4 = simd_xor(del8_rshift4, simd<8>::slli<4>(del8_rshift4));
80        /* Only move bits that are not deleted. */
81        del8_rshift1 = simd_andc(del8_rshift1, delmask);
82        del8_rshift2 = simd_andc(del8_rshift2, delmask);
83        del8_rshift4 = simd_andc(del8_rshift4, delmask);
84        /* Update |del8_rshift2| to apply after |del8_rshift1|. */
85        del8_rshift2 = simd<8>::sub(del8_rshift2, simd<16>::srli<1>(simd_and(del8_rshift1, del8_rshift2)));
86        /* Update |del8_rshift4| to apply after |del8_rshift2| and |del8_rshift1|. */
87        del8_rshift4 = simd<8>::sub(del8_rshift4, simd<16>::srli<1>(simd_and(del8_rshift1, del8_rshift4)));
88        shift_bits = simd_and(del8_rshift2, del8_rshift4);
89        del8_rshift4 = simd_or(simd<16>::srli<2>(shift_bits), simd_xor(del8_rshift4, shift_bits));
90}
91
92
93static inline void del_count(BitBlock delmask, BitBlock & u16_units_per_reg){
94
95        BitBlock delcounts_8 = simd<8>::popcount(delmask);
96        u16_units_per_reg = simd<8>::sub(simd<8>::constant<8>(), delcounts_8);
97}
98
99
100#define BUFFER_SIZE (BLOCK_SIZE * 100)
101
102  struct U8_bits {
103  BitBlock bit_0;
104  BitBlock bit_1;
105  BitBlock bit_2;
106  BitBlock bit_3;
107  BitBlock bit_4;
108  BitBlock bit_5;
109  BitBlock bit_6;
110  BitBlock bit_7;
111};
112
113  struct U16hi {
114  BitBlock bit_0;
115  BitBlock bit_1;
116  BitBlock bit_2;
117  BitBlock bit_3;
118  BitBlock bit_4;
119  BitBlock bit_5;
120  BitBlock bit_6;
121  BitBlock bit_7;
122};
123
124  struct U16lo {
125  BitBlock bit_0;
126  BitBlock bit_1;
127  BitBlock bit_2;
128  BitBlock bit_3;
129  BitBlock bit_4;
130  BitBlock bit_5;
131  BitBlock bit_6;
132  BitBlock bit_7;
133};
134
135  struct U8 {
136  BitBlock unibyte;
137  BitBlock prefix;
138  BitBlock prefix2;
139  BitBlock prefix3;
140  BitBlock prefix4;
141  BitBlock suffix;
142  BitBlock scope22;
143  BitBlock scope32;
144  BitBlock scope33;
145  BitBlock scope42;
146  BitBlock scope43;
147  BitBlock scope44;
148  BitBlock surrogate;
149  BitBlock xE0_scope;
150  BitBlock xED_scope;
151  BitBlock xF0_scope;
152  BitBlock xF4_scope;
153  BitBlock xEF_scope;
154  BitBlock error;
155  BitBlock delmask;
156};
157
158  struct Utf8_to_utf16 {
159  Utf8_to_utf16() {
160 }
161  IDISA_INLINE void do_block(U8_bits & u8_bits, U8 & u8, U16hi & u16hi, U16lo & u16lo) {
162                BitBlock temp1, temp2, error_mask, u8anyscope, temp3, temp4, temp5, temp6;
163                BitBlock badprefix2, adv_bit3, adv_bit4, adv_bit5, adv_bit6, adv_bit7;
164                BitBlock u8lastscope, u8lastbyte, temp7, temp8, xE0, temp9, temp10, temp11;
165                BitBlock xED, xA0_xBF, x80_x9F, adv_bit2, advadv_bit4, advadv_bit5;
166                BitBlock advadv_bit6, advadv_bit7, temp12, temp13, badprefix4, xF0, temp14;
167                BitBlock temp15, xF4, x90_xBF, x80_x8F, s43lo1, s43lo0, s43borrow1, s43hi7;
168                BitBlock s43borrow2, s43hi6;
169
170                BitBlock tempvar0, tempvar1, tempvar2, tempvar3;
171
172
173        u8.unibyte = simd_not(u8_bits.bit_0);
174        u8.prefix = simd_and(u8_bits.bit_0, u8_bits.bit_1);
175        u8.prefix2 = simd_andc(u8.prefix, u8_bits.bit_2);
176        temp1 = simd_andc(u8_bits.bit_2, u8_bits.bit_3);
177        u8.prefix3 = simd_and(u8.prefix, temp1);
178        temp2 = simd_and(u8_bits.bit_2, u8_bits.bit_3);
179        u8.prefix4 = simd_and(u8.prefix, temp2);
180        u8.suffix = simd_andc(u8_bits.bit_0, u8_bits.bit_1);
181        u8.delmask = simd<1>::constant<0>();
182        error_mask = simd<1>::constant<0>();
183        u8anyscope = simd<1>::constant<0>();
184        if ((bitblock::any(u8_bits.bit_0) || carryQ.CarryTest(0, 20))) {
185          temp3 = simd_or(u8_bits.bit_2, u8_bits.bit_3);
186          temp4 = simd_andc(u8.prefix, temp3);
187          temp5 = simd_or(u8_bits.bit_4, u8_bits.bit_5);
188          temp6 = simd_or(temp5, u8_bits.bit_6);
189          badprefix2 = simd_andc(temp4, temp6);
190          error_mask = badprefix2;
191          carryQ.cq[0] = carryout2carry(pablo_blk_Advance(u8.prefix2, carryQ.get_carry_in(0), u8.scope22));
192          carryQ.cq[1] = carryout2carry(pablo_blk_Advance(u8_bits.bit_3, carryQ.get_carry_in(1), adv_bit3));
193          carryQ.cq[2] = carryout2carry(pablo_blk_Advance(u8_bits.bit_4, carryQ.get_carry_in(2), adv_bit4));
194          carryQ.cq[3] = carryout2carry(pablo_blk_Advance(u8_bits.bit_5, carryQ.get_carry_in(3), adv_bit5));
195          carryQ.cq[4] = carryout2carry(pablo_blk_Advance(u8_bits.bit_6, carryQ.get_carry_in(4), adv_bit6));
196          carryQ.cq[5] = carryout2carry(pablo_blk_Advance(u8_bits.bit_7, carryQ.get_carry_in(5), adv_bit7));
197          u8lastscope = u8.scope22;
198          u8anyscope = u8.scope22;
199          u8lastbyte = simd_or(u8.unibyte, u8lastscope);
200          u8.delmask = u8.prefix;
201          if ((bitblock::any(simd_or(u8.prefix3, u8.prefix4)) || carryQ.CarryTest(6, 14))) {
202            temp7 = simd_or(u8_bits.bit_6, u8_bits.bit_7);
203            temp8 = simd_or(temp5, temp7);
204            xE0 = simd_andc(u8.prefix3, temp8);
205            temp9 = simd_and(u8_bits.bit_4, u8_bits.bit_5);
206            temp10 = simd_andc(u8_bits.bit_7, u8_bits.bit_6);
207            temp11 = simd_and(temp9, temp10);
208            xED = simd_and(u8.prefix3, temp11);
209            xA0_xBF = simd_and(u8.suffix, u8_bits.bit_2);
210            x80_x9F = simd_andc(u8.suffix, u8_bits.bit_2);
211            carryQ.cq[6] = carryout2carry(pablo_blk_Advance(xE0, carryQ.get_carry_in(6), tempvar0));
212            error_mask = simd_or(error_mask, simd_and(tempvar0, x80_x9F));
213            carryQ.cq[7] = carryout2carry(pablo_blk_Advance(xED, carryQ.get_carry_in(7), tempvar1));
214            error_mask = simd_or(error_mask, simd_and(tempvar1, xA0_xBF));
215            carryQ.cq[8] = carryout2carry(pablo_blk_Advance(u8.prefix3, carryQ.get_carry_in(8), u8.scope32));
216            carryQ.cq[9] = carryout2carry(pablo_blk_Advance(u8.scope32, carryQ.get_carry_in(9), u8.scope33));
217            carryQ.cq[10] = carryout2carry(pablo_blk_Advance(u8_bits.bit_2, carryQ.get_carry_in(10), adv_bit2));
218            carryQ.cq[11] = carryout2carry(pablo_blk_Advance(adv_bit4, carryQ.get_carry_in(11), advadv_bit4));
219            carryQ.cq[12] = carryout2carry(pablo_blk_Advance(adv_bit5, carryQ.get_carry_in(12), advadv_bit5));
220            carryQ.cq[13] = carryout2carry(pablo_blk_Advance(adv_bit6, carryQ.get_carry_in(13), advadv_bit6));
221            carryQ.cq[14] = carryout2carry(pablo_blk_Advance(adv_bit7, carryQ.get_carry_in(14), advadv_bit7));
222            u8lastscope = simd_or(u8lastscope, u8.scope33);
223            u8anyscope = simd_or(u8lastscope, u8.scope32);
224            u8lastbyte = simd_or(u8.unibyte, u8lastscope);
225            u8.delmask = simd_or(u8.delmask, u8.scope32);
226            if ((bitblock::any(u8.prefix4) || carryQ.CarryTest(15, 5))) {
227              temp12 = simd_and(u8_bits.bit_5, temp7);
228              temp13 = simd_or(u8_bits.bit_4, temp12);
229              badprefix4 = simd_and(u8.prefix4, temp13);
230              error_mask = simd_or(error_mask, badprefix4);
231              xF0 = simd_andc(u8.prefix4, temp8);
232              temp14 = simd_andc(u8_bits.bit_5, u8_bits.bit_4);
233              temp15 = simd_andc(temp14, temp7);
234              xF4 = simd_and(u8.prefix4, temp15);
235              x90_xBF = simd_and(u8.suffix, temp3);
236              x80_x8F = simd_andc(u8.suffix, temp3);
237              carryQ.cq[15] = carryout2carry(pablo_blk_Advance(xF0, carryQ.get_carry_in(15), tempvar2));
238              error_mask = simd_or(error_mask, simd_and(tempvar2, x80_x8F));
239              carryQ.cq[16] = carryout2carry(pablo_blk_Advance(xF4, carryQ.get_carry_in(16), tempvar3));
240              error_mask = simd_or(error_mask, simd_and(tempvar3, x90_xBF));
241              carryQ.cq[17] = carryout2carry(pablo_blk_Advance(u8.prefix4, carryQ.get_carry_in(17), u8.scope42));
242              carryQ.cq[18] = carryout2carry(pablo_blk_Advance(u8.scope42, carryQ.get_carry_in(18), u8.scope43));
243              carryQ.cq[19] = carryout2carry(pablo_blk_Advance(u8.scope43, carryQ.get_carry_in(19), u8.scope44));
244              u8.surrogate = simd_or(u8.scope43, u8.scope44);
245              u8lastscope = simd_or(u8lastscope, u8.scope44);
246              u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
247              u8lastbyte = simd_or(u8.unibyte, u8lastscope);
248              u8.delmask = simd_or(u8.delmask, u8.scope42);
249              u16lo.bit_1 = simd_or(simd_and(u8.unibyte, u8_bits.bit_1), simd_and(u8lastscope, adv_bit7));
250              u16lo.bit_0 = simd_and(u8lastscope, adv_bit6);
251              u16hi.bit_5 = simd_and(u8lastscope, adv_bit3);
252              u16hi.bit_6 = simd_and(u8lastscope, adv_bit4);
253              u16hi.bit_7 = simd_and(u8lastscope, adv_bit5);
254              u16hi.bit_0 = simd_or(simd_and(u8.scope33, advadv_bit4), u8.surrogate);
255              u16hi.bit_1 = simd_or(simd_and(u8.scope33, advadv_bit5), u8.surrogate);
256              u16hi.bit_2 = simd_and(u8.scope33, advadv_bit6);
257              u16hi.bit_3 = simd_or(simd_and(u8.scope33, advadv_bit7), u8.surrogate);
258              u16hi.bit_4 = simd_or(simd_and(u8.scope33, adv_bit2), u8.surrogate);
259              u16hi.bit_5 = simd_or(simd_and(u8lastscope, adv_bit3), u8.scope44);
260              s43lo1 = simd_not(adv_bit3);
261              u16lo.bit_1 = simd_or(u16lo.bit_1, simd_and(u8.scope43, s43lo1));
262              s43lo0 = simd_xor(adv_bit2, s43lo1);
263              u16lo.bit_0 = simd_or(u16lo.bit_0, simd_and(u8.scope43, s43lo0));
264              s43borrow1 = simd_andc(s43lo1, adv_bit2);
265              s43hi7 = simd_xor(advadv_bit7, s43borrow1);
266              s43borrow2 = simd_andc(s43borrow1, advadv_bit7);
267              s43hi6 = simd_xor(advadv_bit6, s43borrow2);
268              u16hi.bit_7 = simd_or(simd_and(u8lastscope, adv_bit5), simd_and(u8.scope43, s43hi7));
269              u16hi.bit_6 = simd_or(simd_and(u8lastscope, adv_bit4), simd_and(u8.scope43, s43hi6));
270              u16lo.bit_2 = simd_or(simd_and(u8lastbyte, u8_bits.bit_2), simd_and(u8.scope43, adv_bit4));
271              u16lo.bit_3 = simd_or(simd_and(u8lastbyte, u8_bits.bit_3), simd_and(u8.scope43, adv_bit5));
272              u16lo.bit_4 = simd_or(simd_and(u8lastbyte, u8_bits.bit_4), simd_and(u8.scope43, adv_bit6));
273              u16lo.bit_5 = simd_or(simd_and(u8lastbyte, u8_bits.bit_5), simd_and(u8.scope43, adv_bit7));
274              u16lo.bit_6 = simd_or(simd_and(u8lastbyte, u8_bits.bit_6), simd_and(u8.scope43, u8_bits.bit_2));
275              u16lo.bit_7 = simd_or(simd_and(u8lastbyte, u8_bits.bit_7), simd_and(u8.scope43, u8_bits.bit_3));
276            }
277            else {
278              u8.scope42 = simd<1>::constant<0>();
279              u8.scope43 = simd<1>::constant<0>();
280              u8.scope44 = simd<1>::constant<0>();
281              u16hi.bit_0 = simd_and(u8.scope33, advadv_bit4);
282              u16hi.bit_1 = simd_and(u8.scope33, advadv_bit5);
283              u16hi.bit_2 = simd_and(u8.scope33, advadv_bit6);
284              u16hi.bit_3 = simd_and(u8.scope33, advadv_bit7);
285              u16hi.bit_4 = simd_and(u8.scope33, adv_bit2);
286              u16hi.bit_5 = simd_and(u8lastscope, adv_bit3);
287              u16hi.bit_6 = simd_and(u8lastscope, adv_bit4);
288              u16hi.bit_7 = simd_and(u8lastscope, adv_bit5);
289              u16lo.bit_2 = simd_and(u8lastbyte, u8_bits.bit_2);
290              u16lo.bit_3 = simd_and(u8lastbyte, u8_bits.bit_3);
291              u16lo.bit_4 = simd_and(u8lastbyte, u8_bits.bit_4);
292              u16lo.bit_5 = simd_and(u8lastbyte, u8_bits.bit_5);
293              u16lo.bit_6 = simd_and(u8lastbyte, u8_bits.bit_6);
294              u16lo.bit_7 = simd_and(u8lastbyte, u8_bits.bit_7);
295              u16lo.bit_1 = simd_or(simd_and(u8.unibyte, u8_bits.bit_1), simd_and(u8lastscope, adv_bit7));
296              u16lo.bit_0 = simd_and(u8lastscope, adv_bit6);
297              carryQ.CarryDequeueEnqueue(15, 5);
298            }
299          }
300          else {
301            u8.scope32 = simd<1>::constant<0>();
302            u8.scope33 = simd<1>::constant<0>();
303            u8.scope42 = simd<1>::constant<0>();
304            u8.scope43 = simd<1>::constant<0>();
305            u8.scope44 = simd<1>::constant<0>();
306            u16hi.bit_0 = simd<1>::constant<0>();
307            u16hi.bit_1 = simd<1>::constant<0>();
308            u16hi.bit_2 = simd<1>::constant<0>();
309            u16hi.bit_3 = simd<1>::constant<0>();
310            u16hi.bit_4 = simd<1>::constant<0>();
311            u16hi.bit_5 = simd_and(u8lastscope, adv_bit3);
312            u16hi.bit_6 = simd_and(u8lastscope, adv_bit4);
313            u16hi.bit_7 = simd_and(u8lastscope, adv_bit5);
314            u16lo.bit_2 = simd_and(u8lastbyte, u8_bits.bit_2);
315            u16lo.bit_3 = simd_and(u8lastbyte, u8_bits.bit_3);
316            u16lo.bit_4 = simd_and(u8lastbyte, u8_bits.bit_4);
317            u16lo.bit_5 = simd_and(u8lastbyte, u8_bits.bit_5);
318            u16lo.bit_6 = simd_and(u8lastbyte, u8_bits.bit_6);
319            u16lo.bit_7 = simd_and(u8lastbyte, u8_bits.bit_7);
320            u16lo.bit_1 = simd_or(simd_and(u8.unibyte, u8_bits.bit_1), simd_and(u8lastscope, adv_bit7));
321            u16lo.bit_0 = simd_and(u8lastscope, adv_bit6);
322            carryQ.CarryDequeueEnqueue(6, 14);
323          }
324        }
325        else {
326          u8.scope22 = simd<1>::constant<0>();
327          u8.scope32 = simd<1>::constant<0>();
328          u8.scope33 = simd<1>::constant<0>();
329          u8.scope42 = simd<1>::constant<0>();
330          u8.scope43 = simd<1>::constant<0>();
331          u8.scope44 = simd<1>::constant<0>();
332          u16hi.bit_0 = simd<1>::constant<0>();
333          u16hi.bit_1 = simd<1>::constant<0>();
334          u16hi.bit_2 = simd<1>::constant<0>();
335          u16hi.bit_3 = simd<1>::constant<0>();
336          u16hi.bit_4 = simd<1>::constant<0>();
337          u16hi.bit_5 = simd<1>::constant<0>();
338          u16hi.bit_6 = simd<1>::constant<0>();
339          u16hi.bit_7 = simd<1>::constant<0>();
340          u16lo.bit_2 = u8_bits.bit_2;
341          u16lo.bit_3 = u8_bits.bit_3;
342          u16lo.bit_4 = u8_bits.bit_4;
343          u16lo.bit_5 = u8_bits.bit_5;
344          u16lo.bit_6 = u8_bits.bit_6;
345          u16lo.bit_7 = u8_bits.bit_7;
346          u16lo.bit_1 = u8_bits.bit_1;
347          u16lo.bit_0 = simd<1>::constant<0>();
348          carryQ.CarryDequeueEnqueue(0, 20);
349        }
350        error_mask = simd_or(error_mask, simd_xor(u8anyscope, u8.suffix));
351        u8.error = error_mask;
352        carryQ.CarryQ_Adjust(20);
353  }
354  IDISA_INLINE void clear() {
355 }
356  void do_final_block(U8_bits & u8_bits, U8 & u8, U16hi & u16hi, U16lo & u16lo, BitBlock EOF_mask) {
357                BitBlock temp1, temp2, error_mask, u8anyscope, temp3, temp4, temp5, temp6;
358                BitBlock badprefix2, adv_bit3, adv_bit4, adv_bit5, adv_bit6, adv_bit7;
359                BitBlock u8lastscope, u8lastbyte, temp7, temp8, xE0, temp9, temp10, temp11;
360                BitBlock xED, xA0_xBF, x80_x9F, adv_bit2, advadv_bit4, advadv_bit5;
361                BitBlock advadv_bit6, advadv_bit7, temp12, temp13, badprefix4, xF0, temp14;
362                BitBlock temp15, xF4, x90_xBF, x80_x8F, s43lo1, s43lo0, s43borrow1, s43hi7;
363                BitBlock s43borrow2, s43hi6;
364
365                BitBlock tempvar0, tempvar1, tempvar2, tempvar3;
366
367
368        u8.unibyte = simd_not(u8_bits.bit_0);
369        u8.prefix = simd_and(u8_bits.bit_0, u8_bits.bit_1);
370        u8.prefix2 = simd_andc(u8.prefix, u8_bits.bit_2);
371        temp1 = simd_andc(u8_bits.bit_2, u8_bits.bit_3);
372        u8.prefix3 = simd_and(u8.prefix, temp1);
373        temp2 = simd_and(u8_bits.bit_2, u8_bits.bit_3);
374        u8.prefix4 = simd_and(u8.prefix, temp2);
375        u8.suffix = simd_andc(u8_bits.bit_0, u8_bits.bit_1);
376        u8.delmask = simd<1>::constant<0>();
377        error_mask = simd<1>::constant<0>();
378        u8anyscope = simd<1>::constant<0>();
379        if ((bitblock::any(u8_bits.bit_0) || carryQ.CarryTest(0, 20))) {
380          temp3 = simd_or(u8_bits.bit_2, u8_bits.bit_3);
381          temp4 = simd_andc(u8.prefix, temp3);
382          temp5 = simd_or(u8_bits.bit_4, u8_bits.bit_5);
383          temp6 = simd_or(temp5, u8_bits.bit_6);
384          badprefix2 = simd_andc(temp4, temp6);
385          error_mask = badprefix2;
386          carryQ.cq[0] = carryout2carry(pablo_blk_Advance(u8.prefix2, carryQ.get_carry_in(0), u8.scope22));
387          carryQ.cq[1] = carryout2carry(pablo_blk_Advance(u8_bits.bit_3, carryQ.get_carry_in(1), adv_bit3));
388          carryQ.cq[2] = carryout2carry(pablo_blk_Advance(u8_bits.bit_4, carryQ.get_carry_in(2), adv_bit4));
389          carryQ.cq[3] = carryout2carry(pablo_blk_Advance(u8_bits.bit_5, carryQ.get_carry_in(3), adv_bit5));
390          carryQ.cq[4] = carryout2carry(pablo_blk_Advance(u8_bits.bit_6, carryQ.get_carry_in(4), adv_bit6));
391          carryQ.cq[5] = carryout2carry(pablo_blk_Advance(u8_bits.bit_7, carryQ.get_carry_in(5), adv_bit7));
392          u8lastscope = u8.scope22;
393          u8anyscope = u8.scope22;
394          u8lastbyte = simd_or(u8.unibyte, u8lastscope);
395          u8.delmask = u8.prefix;
396          if ((bitblock::any(simd_or(u8.prefix3, u8.prefix4)) || carryQ.CarryTest(6, 14))) {
397            temp7 = simd_or(u8_bits.bit_6, u8_bits.bit_7);
398            temp8 = simd_or(temp5, temp7);
399            xE0 = simd_andc(u8.prefix3, temp8);
400            temp9 = simd_and(u8_bits.bit_4, u8_bits.bit_5);
401            temp10 = simd_andc(u8_bits.bit_7, u8_bits.bit_6);
402            temp11 = simd_and(temp9, temp10);
403            xED = simd_and(u8.prefix3, temp11);
404            xA0_xBF = simd_and(u8.suffix, u8_bits.bit_2);
405            x80_x9F = simd_andc(u8.suffix, u8_bits.bit_2);
406            carryQ.cq[6] = carryout2carry(pablo_blk_Advance(xE0, carryQ.get_carry_in(6), tempvar0));
407            error_mask = simd_or(error_mask, simd_and(tempvar0, x80_x9F));
408            carryQ.cq[7] = carryout2carry(pablo_blk_Advance(xED, carryQ.get_carry_in(7), tempvar1));
409            error_mask = simd_or(error_mask, simd_and(tempvar1, xA0_xBF));
410            carryQ.cq[8] = carryout2carry(pablo_blk_Advance(u8.prefix3, carryQ.get_carry_in(8), u8.scope32));
411            carryQ.cq[9] = carryout2carry(pablo_blk_Advance(u8.scope32, carryQ.get_carry_in(9), u8.scope33));
412            carryQ.cq[10] = carryout2carry(pablo_blk_Advance(u8_bits.bit_2, carryQ.get_carry_in(10), adv_bit2));
413            carryQ.cq[11] = carryout2carry(pablo_blk_Advance(adv_bit4, carryQ.get_carry_in(11), advadv_bit4));
414            carryQ.cq[12] = carryout2carry(pablo_blk_Advance(adv_bit5, carryQ.get_carry_in(12), advadv_bit5));
415            carryQ.cq[13] = carryout2carry(pablo_blk_Advance(adv_bit6, carryQ.get_carry_in(13), advadv_bit6));
416            carryQ.cq[14] = carryout2carry(pablo_blk_Advance(adv_bit7, carryQ.get_carry_in(14), advadv_bit7));
417            u8lastscope = simd_or(u8lastscope, u8.scope33);
418            u8anyscope = simd_or(u8lastscope, u8.scope32);
419            u8lastbyte = simd_or(u8.unibyte, u8lastscope);
420            u8.delmask = simd_or(u8.delmask, u8.scope32);
421            if ((bitblock::any(u8.prefix4) || carryQ.CarryTest(15, 5))) {
422              temp12 = simd_and(u8_bits.bit_5, temp7);
423              temp13 = simd_or(u8_bits.bit_4, temp12);
424              badprefix4 = simd_and(u8.prefix4, temp13);
425              error_mask = simd_or(error_mask, badprefix4);
426              xF0 = simd_andc(u8.prefix4, temp8);
427              temp14 = simd_andc(u8_bits.bit_5, u8_bits.bit_4);
428              temp15 = simd_andc(temp14, temp7);
429              xF4 = simd_and(u8.prefix4, temp15);
430              x90_xBF = simd_and(u8.suffix, temp3);
431              x80_x8F = simd_andc(u8.suffix, temp3);
432              carryQ.cq[15] = carryout2carry(pablo_blk_Advance(xF0, carryQ.get_carry_in(15), tempvar2));
433              error_mask = simd_or(error_mask, simd_and(tempvar2, x80_x8F));
434              carryQ.cq[16] = carryout2carry(pablo_blk_Advance(xF4, carryQ.get_carry_in(16), tempvar3));
435              error_mask = simd_or(error_mask, simd_and(tempvar3, x90_xBF));
436              carryQ.cq[17] = carryout2carry(pablo_blk_Advance(u8.prefix4, carryQ.get_carry_in(17), u8.scope42));
437              carryQ.cq[18] = carryout2carry(pablo_blk_Advance(u8.scope42, carryQ.get_carry_in(18), u8.scope43));
438              carryQ.cq[19] = carryout2carry(pablo_blk_Advance(u8.scope43, carryQ.get_carry_in(19), u8.scope44));
439              u8.surrogate = simd_or(u8.scope43, u8.scope44);
440              u8lastscope = simd_or(u8lastscope, u8.scope44);
441              u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
442              u8lastbyte = simd_or(u8.unibyte, u8lastscope);
443              u8.delmask = simd_or(u8.delmask, u8.scope42);
444              u16lo.bit_1 = simd_or(simd_and(u8.unibyte, u8_bits.bit_1), simd_and(u8lastscope, adv_bit7));
445              u16lo.bit_0 = simd_and(u8lastscope, adv_bit6);
446              u16hi.bit_5 = simd_and(u8lastscope, adv_bit3);
447              u16hi.bit_6 = simd_and(u8lastscope, adv_bit4);
448              u16hi.bit_7 = simd_and(u8lastscope, adv_bit5);
449              u16hi.bit_0 = simd_or(simd_and(u8.scope33, advadv_bit4), u8.surrogate);
450              u16hi.bit_1 = simd_or(simd_and(u8.scope33, advadv_bit5), u8.surrogate);
451              u16hi.bit_2 = simd_and(u8.scope33, advadv_bit6);
452              u16hi.bit_3 = simd_or(simd_and(u8.scope33, advadv_bit7), u8.surrogate);
453              u16hi.bit_4 = simd_or(simd_and(u8.scope33, adv_bit2), u8.surrogate);
454              u16hi.bit_5 = simd_or(simd_and(u8lastscope, adv_bit3), u8.scope44);
455              s43lo1 = simd_not(adv_bit3);
456              u16lo.bit_1 = simd_or(u16lo.bit_1, simd_and(u8.scope43, s43lo1));
457              s43lo0 = simd_xor(adv_bit2, s43lo1);
458              u16lo.bit_0 = simd_or(u16lo.bit_0, simd_and(u8.scope43, s43lo0));
459              s43borrow1 = simd_andc(s43lo1, adv_bit2);
460              s43hi7 = simd_xor(advadv_bit7, s43borrow1);
461              s43borrow2 = simd_andc(s43borrow1, advadv_bit7);
462              s43hi6 = simd_xor(advadv_bit6, s43borrow2);
463              u16hi.bit_7 = simd_or(simd_and(u8lastscope, adv_bit5), simd_and(u8.scope43, s43hi7));
464              u16hi.bit_6 = simd_or(simd_and(u8lastscope, adv_bit4), simd_and(u8.scope43, s43hi6));
465              u16lo.bit_2 = simd_or(simd_and(u8lastbyte, u8_bits.bit_2), simd_and(u8.scope43, adv_bit4));
466              u16lo.bit_3 = simd_or(simd_and(u8lastbyte, u8_bits.bit_3), simd_and(u8.scope43, adv_bit5));
467              u16lo.bit_4 = simd_or(simd_and(u8lastbyte, u8_bits.bit_4), simd_and(u8.scope43, adv_bit6));
468              u16lo.bit_5 = simd_or(simd_and(u8lastbyte, u8_bits.bit_5), simd_and(u8.scope43, adv_bit7));
469              u16lo.bit_6 = simd_or(simd_and(u8lastbyte, u8_bits.bit_6), simd_and(u8.scope43, u8_bits.bit_2));
470              u16lo.bit_7 = simd_or(simd_and(u8lastbyte, u8_bits.bit_7), simd_and(u8.scope43, u8_bits.bit_3));
471            }
472            else {
473              u8.scope42 = simd<1>::constant<0>();
474              u8.scope43 = simd<1>::constant<0>();
475              u8.scope44 = simd<1>::constant<0>();
476              u16hi.bit_0 = simd_and(u8.scope33, advadv_bit4);
477              u16hi.bit_1 = simd_and(u8.scope33, advadv_bit5);
478              u16hi.bit_2 = simd_and(u8.scope33, advadv_bit6);
479              u16hi.bit_3 = simd_and(u8.scope33, advadv_bit7);
480              u16hi.bit_4 = simd_and(u8.scope33, adv_bit2);
481              u16hi.bit_5 = simd_and(u8lastscope, adv_bit3);
482              u16hi.bit_6 = simd_and(u8lastscope, adv_bit4);
483              u16hi.bit_7 = simd_and(u8lastscope, adv_bit5);
484              u16lo.bit_2 = simd_and(u8lastbyte, u8_bits.bit_2);
485              u16lo.bit_3 = simd_and(u8lastbyte, u8_bits.bit_3);
486              u16lo.bit_4 = simd_and(u8lastbyte, u8_bits.bit_4);
487              u16lo.bit_5 = simd_and(u8lastbyte, u8_bits.bit_5);
488              u16lo.bit_6 = simd_and(u8lastbyte, u8_bits.bit_6);
489              u16lo.bit_7 = simd_and(u8lastbyte, u8_bits.bit_7);
490              u16lo.bit_1 = simd_or(simd_and(u8.unibyte, u8_bits.bit_1), simd_and(u8lastscope, adv_bit7));
491              u16lo.bit_0 = simd_and(u8lastscope, adv_bit6);
492              carryQ.CarryDequeueEnqueue(15, 5);
493            }
494          }
495          else {
496            u8.scope32 = simd<1>::constant<0>();
497            u8.scope33 = simd<1>::constant<0>();
498            u8.scope42 = simd<1>::constant<0>();
499            u8.scope43 = simd<1>::constant<0>();
500            u8.scope44 = simd<1>::constant<0>();
501            u16hi.bit_0 = simd<1>::constant<0>();
502            u16hi.bit_1 = simd<1>::constant<0>();
503            u16hi.bit_2 = simd<1>::constant<0>();
504            u16hi.bit_3 = simd<1>::constant<0>();
505            u16hi.bit_4 = simd<1>::constant<0>();
506            u16hi.bit_5 = simd_and(u8lastscope, adv_bit3);
507            u16hi.bit_6 = simd_and(u8lastscope, adv_bit4);
508            u16hi.bit_7 = simd_and(u8lastscope, adv_bit5);
509            u16lo.bit_2 = simd_and(u8lastbyte, u8_bits.bit_2);
510            u16lo.bit_3 = simd_and(u8lastbyte, u8_bits.bit_3);
511            u16lo.bit_4 = simd_and(u8lastbyte, u8_bits.bit_4);
512            u16lo.bit_5 = simd_and(u8lastbyte, u8_bits.bit_5);
513            u16lo.bit_6 = simd_and(u8lastbyte, u8_bits.bit_6);
514            u16lo.bit_7 = simd_and(u8lastbyte, u8_bits.bit_7);
515            u16lo.bit_1 = simd_or(simd_and(u8.unibyte, u8_bits.bit_1), simd_and(u8lastscope, adv_bit7));
516            u16lo.bit_0 = simd_and(u8lastscope, adv_bit6);
517            carryQ.CarryDequeueEnqueue(6, 14);
518          }
519        }
520        else {
521          u8.scope22 = simd<1>::constant<0>();
522          u8.scope32 = simd<1>::constant<0>();
523          u8.scope33 = simd<1>::constant<0>();
524          u8.scope42 = simd<1>::constant<0>();
525          u8.scope43 = simd<1>::constant<0>();
526          u8.scope44 = simd<1>::constant<0>();
527          u16hi.bit_0 = simd<1>::constant<0>();
528          u16hi.bit_1 = simd<1>::constant<0>();
529          u16hi.bit_2 = simd<1>::constant<0>();
530          u16hi.bit_3 = simd<1>::constant<0>();
531          u16hi.bit_4 = simd<1>::constant<0>();
532          u16hi.bit_5 = simd<1>::constant<0>();
533          u16hi.bit_6 = simd<1>::constant<0>();
534          u16hi.bit_7 = simd<1>::constant<0>();
535          u16lo.bit_2 = u8_bits.bit_2;
536          u16lo.bit_3 = u8_bits.bit_3;
537          u16lo.bit_4 = u8_bits.bit_4;
538          u16lo.bit_5 = u8_bits.bit_5;
539          u16lo.bit_6 = u8_bits.bit_6;
540          u16lo.bit_7 = u8_bits.bit_7;
541          u16lo.bit_1 = u8_bits.bit_1;
542          u16lo.bit_0 = simd<1>::constant<0>();
543          carryQ.CarryDequeueEnqueue(0, 20);
544        }
545        error_mask = simd_or(error_mask, simd_xor(u8anyscope, u8.suffix));
546        u8.error = error_mask;
547  }
548  CarryArray<20, 0> carryQ;
549  };
550
551
552
553void u8u16(UChar ** targetbuf, const UChar * targetlimit, char ** srcbuf, const char * srclimit, UErrorCode * err){
554
555    struct U8_bits u8_bits;
556
557  struct U16hi u16hi;
558
559  struct U16lo u16lo;
560
561  struct U8 u8;
562
563
564
565
566
567  BytePack U8s[8];
568  BytePack U16h[8];
569  BytePack U16l[8];
570  BytePack U16s[16];
571
572  BitBlock EOF_mask = simd<1>::constant<1>();
573
574
575  int pos = 0;
576
577  bool error_found = false;
578  int err_pos;
579
580    Utf8_to_utf16 utf8_to_utf16;
581
582
583
584    while (((*srcbuf) < srclimit) || utf8_to_utf16.carryQ.CarryTest(0, 20) ){
585
586      int u8advance = minimum(srclimit-(*srcbuf),BLOCK_SIZE);
587
588      if(u8advance < BLOCK_SIZE){
589        EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-u8advance));
590
591      }
592      else
593        EOF_mask = simd<1>::constant<1>();
594
595      BytePack * U8pack = (BytePack *) (*srcbuf);
596      U8s[0] = bitblock::load_unaligned(&U8pack[0]);
597      U8s[1] = bitblock::load_unaligned(&U8pack[1]);
598      U8s[2] = bitblock::load_unaligned(&U8pack[2]);
599      U8s[3] = bitblock::load_unaligned(&U8pack[3]);
600      U8s[4] = bitblock::load_unaligned(&U8pack[4]);
601      U8s[5] = bitblock::load_unaligned(&U8pack[5]);
602      U8s[6] = bitblock::load_unaligned(&U8pack[6]);
603      U8s[7] = bitblock::load_unaligned(&U8pack[7]);
604
605      s2p(U8s[0], U8s[1], U8s[2], U8s[3], U8s[4], U8s[5], U8s[6], U8s[7],
606          u8_bits.bit_0, u8_bits.bit_1, u8_bits.bit_2, u8_bits.bit_3, u8_bits.bit_4, u8_bits.bit_5, u8_bits.bit_6, u8_bits.bit_7);
607
608        u8_bits.bit_0 = simd_and(u8_bits.bit_0, EOF_mask);
609        u8_bits.bit_1 = simd_and(u8_bits.bit_1, EOF_mask);
610        u8_bits.bit_2 = simd_and(u8_bits.bit_2, EOF_mask);
611        u8_bits.bit_3 = simd_and(u8_bits.bit_3, EOF_mask);
612        u8_bits.bit_4 = simd_and(u8_bits.bit_4, EOF_mask);
613        u8_bits.bit_5 = simd_and(u8_bits.bit_5, EOF_mask);
614        u8_bits.bit_6 = simd_and(u8_bits.bit_6, EOF_mask);
615        u8_bits.bit_7 = simd_and(u8_bits.bit_7, EOF_mask);
616
617
618  utf8_to_utf16.do_block(u8_bits, u8, u16hi, u16lo);
619
620      u8.delmask |= ~EOF_mask;
621      error_found = bitblock::any(u8.error);
622      if (error_found) {
623        int errpos = count_forward_zeroes(u8.error);
624        if (errpos >= u8advance) {
625          *err = U_TRUNCATED_CHAR_FOUND;
626        }
627        else *err = U_ILLEGAL_CHAR_FOUND;
628        BitBlock cutoff_mask = bitblock::sll(simd<1>::constant<1>(), convert(errpos));
629        BitBlock errbit = simd_andc(u8.error, bitblock::slli<1>(cutoff_mask));
630        u8advance = errpos;
631        if (bitblock::any(simd_and(u8.scope44, errbit))) {
632          u8advance -= 3;
633          /* May have already first of a surrogate pair to targetbuf. */
634          if (u8advance == -3) *targetbuf -= 1;
635        }
636        else if (bitblock::any(simd_and(u8.scope43, errbit))) {
637          u8advance -= 2;
638        }
639        else if (bitblock::any(simd_and(u8.scope33, errbit))) {
640          u8advance -= 2;
641        }
642        else if (bitblock::any(simd_and(simd_or(u8.scope22, simd_or(u8.scope32, u8.scope42)), errbit))) {
643          u8advance -= 1;
644        }
645        if (u8advance <= 0) {
646          (*srcbuf) += u8advance;
647          return;
648        }
649        u8.delmask |= bitblock::sll(simd<1>::constant<1>(), convert(u8advance));
650//      fprintf(stderr, "errpos = %i, u8advance = %i\n", errpos, u8advance);
651      }
652
653
654      if (bitblock::any(u8.delmask)) {
655              BitBlock shift1, shift2, shift4;
656              del_info_8(shift1, shift2, shift4, u8.delmask);
657              do_right8_shifts(u16lo.bit_0, shift1, shift2, shift4);
658              do_right8_shifts(u16lo.bit_1, shift1, shift2, shift4);
659              do_right8_shifts(u16lo.bit_2, shift1, shift2, shift4);
660              do_right8_shifts(u16lo.bit_3, shift1, shift2, shift4);
661              do_right8_shifts(u16lo.bit_4, shift1, shift2, shift4);
662              do_right8_shifts(u16lo.bit_5, shift1, shift2, shift4);
663              do_right8_shifts(u16lo.bit_6, shift1, shift2, shift4);
664              do_right8_shifts(u16lo.bit_7, shift1, shift2, shift4);
665              if (bitblock::any(u8.scope33 | u8.surrogate)) {
666                      do_right8_shifts(u16hi.bit_0, shift1, shift2, shift4);
667                      do_right8_shifts(u16hi.bit_1, shift1, shift2, shift4);
668                      do_right8_shifts(u16hi.bit_2, shift1, shift2, shift4);
669                      do_right8_shifts(u16hi.bit_3, shift1, shift2, shift4);
670                      do_right8_shifts(u16hi.bit_4, shift1, shift2, shift4);
671              }
672              do_right8_shifts(u16hi.bit_5, shift1, shift2, shift4);
673              do_right8_shifts(u16hi.bit_6, shift1, shift2, shift4);
674              do_right8_shifts(u16hi.bit_7, shift1, shift2, shift4);
675      }
676
677      union {BitBlock i128; uint8_t i8[16];} u16_units_per_reg;
678
679      p2s(u16lo.bit_0,u16lo.bit_1,u16lo.bit_2,u16lo.bit_3,u16lo.bit_4,u16lo.bit_5,u16lo.bit_6,u16lo.bit_7,
680                        U16l[0], U16l[1],U16l[2] ,U16l[3] ,U16l[4] ,U16l[5] ,U16l[6] ,U16l[7]);
681      p2s(u16hi.bit_0,u16hi.bit_1,u16hi.bit_2,u16hi.bit_3,u16hi.bit_4,u16hi.bit_5,u16hi.bit_6,u16hi.bit_7,
682                        U16h[0], U16h[1],U16h[2] ,U16h[3] ,U16h[4] ,U16h[5] ,U16h[6] ,U16h[7]);
683      for (int i=0; i<8; i++) {
684        U16s[2*i] = esimd<8>::mergel(U16l[i], U16h[i]);
685        U16s[2*i+1] = esimd<8>::mergeh(U16l[i], U16h[i]);
686      }
687
688      for(int k=0; k<16; k++) u16_units_per_reg.i8[k] = 0;
689      del_count(u8.delmask,u16_units_per_reg.i128);
690
691      for(int j=0; j<16; j++){
692        bitblock::store_unaligned(U16s[j], (BitBlock *) (*targetbuf));
693        *targetbuf += u16_units_per_reg.i8[j];
694      }
695
696      (*srcbuf) += u8advance;
697
698      if (error_found) return;
699    }
700    *err = U_ZERO_ERROR;
701}
702
703
704void do_process(FILE *infile, FILE *outfile) {
705
706  int buf_pos = 0;
707  int bytes_available = 0;
708  int excess_bytes, i;
709  char srcbuf[BUFFER_SIZE+BLOCK_SIZE];
710  char * srclimit;
711  UChar targetbuf[BUFFER_SIZE+BLOCK_SIZE];
712  UChar * targetlimit;
713  UChar * targetbuf_start;
714  UChar * targetbuf_ptr=targetbuf;
715  char * srcbuf_ptr=srcbuf;
716  UErrorCode status;
717
718  bytes_available = fread((void *)srcbuf, sizeof(char), BUFFER_SIZE, infile);
719  srclimit = srcbuf + bytes_available;
720  targetbuf_start = targetbuf;
721
722  while(bytes_available>0){
723
724    PERF_SEC_START(transcode_timer);
725
726    srcbuf_ptr=srcbuf;
727    targetbuf_ptr=targetbuf;
728
729    u8u16(&targetbuf_ptr, targetlimit, &srcbuf_ptr, srclimit, &status);
730    excess_bytes = (int) (srclimit - srcbuf_ptr);
731    buf_pos += bytes_available - excess_bytes;
732
733    PERF_SEC_END(transcode_timer, bytes_available - excess_bytes);
734
735
736    fwrite(targetbuf_start , sizeof(UChar) ,  targetbuf_ptr - targetbuf_start, outfile );
737
738    if (status == U_ILLEGAL_CHAR_FOUND) {
739            fclose(infile);
740            fclose(outfile);
741            fprintf(stderr, "Illegal UTF-8 sequence at position %lu in source.\n", (unsigned long) buf_pos);
742            exit(-1);
743    }
744    else if (status == U_TRUNCATED_CHAR_FOUND) {
745        for (i = 0; i < excess_bytes; i++) {
746          srcbuf[i] = srcbuf_ptr[i];
747        }
748        bytes_available = fread((void *) &(srcbuf[excess_bytes]), sizeof(char), BUFFER_SIZE-excess_bytes, infile);
749        if (bytes_available == 0) {
750            fclose(infile);
751            fclose(outfile);
752            fprintf(stderr, "EOF with incomplete UTF-8 sequence at position %lu in source.\n", (unsigned long) buf_pos);
753            exit(-1);
754        }
755        bytes_available += excess_bytes;
756        srclimit = srcbuf + bytes_available;
757    }
758    else {
759      bytes_available = fread((void *)srcbuf, sizeof(char), BUFFER_SIZE, infile);
760      srclimit = srcbuf + bytes_available;
761    }
762  }
763}
764
765
766
767int
768main(int argc, char * argv[]) {
769        char * infilename, * outfilename;
770        FILE *infile, *outfile;
771
772        if (argc < 2) {
773                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
774                exit(-1);
775        }
776
777        infilename = argv[1];
778        infile = fopen(infilename, "rb");
779        if (!infile) {
780                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
781                exit(-1);
782        }
783
784        if (argc < 3) outfile = stdout;
785        else {
786                outfilename = argv[2];
787                outfile = fopen(outfilename, "wb");
788                if (!outfile) {
789                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
790                        exit(-1);
791                }
792        }
793
794
795        PERF_SEC_INIT(transcode_timer);
796
797        do_process(infile, outfile);
798
799        PERF_SEC_DUMP(transcode_timer);
800
801        PERF_SEC_DESTROY(transcode_timer);
802
803        fclose(infile);
804        fclose(outfile);
805        return(0);
806}
Note: See TracBrowser for help on using the repository browser.