git://git.nikiroo.be / nikiroo-utils.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
fix Base64 but breaks compat
[nikiroo-utils.git] / src / be / nikiroo / utils / streams / Base64.java
1 /*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 /*
18 * Changes (@author niki):
19 * - default charset -> UTF-8
20 */
21
22 package be.nikiroo.utils.streams;
23
24 import java.io.UnsupportedEncodingException;
25
26 /**
27 * Utilities for encoding and decoding the Base64 representation of
28 * binary data. See RFCs <a
29 * href="http://www.ietf.org/rfc/rfc2045.txt">2045</a> and <a
30 * href="http://www.ietf.org/rfc/rfc3548.txt">3548</a>.
31 */
32 class Base64 {
33 /**
34 * Default values for encoder/decoder flags.
35 */
36 public static final int DEFAULT = 0;
37
38 /**
39 * Encoder flag bit to omit the padding '=' characters at the end
40 * of the output (if any).
41 */
42 public static final int NO_PADDING = 1;
43
44 /**
45 * Encoder flag bit to omit all line terminators (i.e., the output
46 * will be on one long line).
47 */
48 public static final int NO_WRAP = 2;
49
50 /**
51 * Encoder flag bit to indicate lines should be terminated with a
52 * CRLF pair instead of just an LF. Has no effect if {@code
53 * NO_WRAP} is specified as well.
54 */
55 public static final int CRLF = 4;
56
57 /**
58 * Encoder/decoder flag bit to indicate using the "URL and
59 * filename safe" variant of Base64 (see RFC 3548 section 4) where
60 * {@code -} and {@code _} are used in place of {@code +} and
61 * {@code /}.
62 */
63 public static final int URL_SAFE = 8;
64
65 /**
66 * Flag to pass to {@link Base64OutputStream} to indicate that it
67 * should not close the output stream it is wrapping when it
68 * itself is closed.
69 */
70 public static final int NO_CLOSE = 16;
71
72 // --------------------------------------------------------
73 // shared code
74 // --------------------------------------------------------
75
76 /* package */ static abstract class Coder {
77 public byte[] output;
78 public int op;
79
80 /**
81 * Encode/decode another block of input data. this.output is
82 * provided by the caller, and must be big enough to hold all
83 * the coded data. On exit, this.opwill be set to the length
84 * of the coded data.
85 *
86 * @param finish true if this is the final call to process for
87 * this object. Will finalize the coder state and
88 * include any final bytes in the output.
89 *
90 * @return true if the input so far is good; false if some
91 * error has been detected in the input stream..
92 */
93 public abstract boolean process(byte[] input, int offset, int len, boolean finish);
94
95 /**
96 * @return the maximum number of bytes a call to process()
97 * could produce for the given number of input bytes. This may
98 * be an overestimate.
99 */
100 public abstract int maxOutputSize(int len);
101 }
102
103 // --------------------------------------------------------
104 // decoding
105 // --------------------------------------------------------
106
107 /**
108 * Decode the Base64-encoded data in input and return the data in
109 * a new byte array.
110 *
111 * <p>The padding '=' characters at the end are considered optional, but
112 * if any are present, there must be the correct number of them.
113 *
114 * @param str the input String to decode, which is converted to
115 * bytes using the default charset
116 * @param flags controls certain features of the decoded output.
117 * Pass {@code DEFAULT} to decode standard Base64.
118 *
119 * @throws IllegalArgumentException if the input contains
120 * incorrect padding
121 */
122 public static byte[] decode(String str, int flags) {
123 try{
124 return decode(str.getBytes("UTF-8"), flags);
125 } catch (UnsupportedEncodingException e) {
126 // All conforming JVM are expected to support UTF-8
127 return null;
128 }
129 }
130
131 /**
132 * Decode the Base64-encoded data in input and return the data in
133 * a new byte array.
134 *
135 * <p>The padding '=' characters at the end are considered optional, but
136 * if any are present, there must be the correct number of them.
137 *
138 * @param input the input array to decode
139 * @param flags controls certain features of the decoded output.
140 * Pass {@code DEFAULT} to decode standard Base64.
141 *
142 * @throws IllegalArgumentException if the input contains
143 * incorrect padding
144 */
145 public static byte[] decode(byte[] input, int flags) {
146 return decode(input, 0, input.length, flags);
147 }
148
149 /**
150 * Decode the Base64-encoded data in input and return the data in
151 * a new byte array.
152 *
153 * <p>The padding '=' characters at the end are considered optional, but
154 * if any are present, there must be the correct number of them.
155 *
156 * @param input the data to decode
157 * @param offset the position within the input array at which to start
158 * @param len the number of bytes of input to decode
159 * @param flags controls certain features of the decoded output.
160 * Pass {@code DEFAULT} to decode standard Base64.
161 *
162 * @throws IllegalArgumentException if the input contains
163 * incorrect padding
164 */
165 public static byte[] decode(byte[] input, int offset, int len, int flags) {
166 // Allocate space for the most data the input could represent.
167 // (It could contain less if it contains whitespace, etc.)
168 Decoder decoder = new Decoder(flags, new byte[len*3/4]);
169
170 if (!decoder.process(input, offset, len, true)) {
171 throw new IllegalArgumentException("bad base-64");
172 }
173
174 // Maybe we got lucky and allocated exactly enough output space.
175 if (decoder.op == decoder.output.length) {
176 return decoder.output;
177 }
178
179 // Need to shorten the array, so allocate a new one of the
180 // right size and copy.
181 byte[] temp = new byte[decoder.op];
182 System.arraycopy(decoder.output, 0, temp, 0, decoder.op);
183 return temp;
184 }
185
186 /* package */ static class Decoder extends Coder {
187 /**
188 * Lookup table for turning bytes into their position in the
189 * Base64 alphabet.
190 */
191 private static final int DECODE[] = {
192 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
193 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
194 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
195 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1,
196 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
197 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
198 -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
199 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
200 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
201 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
202 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
203 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
204 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
205 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
206 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
207 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
208 };
209
210 /**
211 * Decode lookup table for the "web safe" variant (RFC 3548
212 * sec. 4) where - and _ replace + and /.
213 */
214 private static final int DECODE_WEBSAFE[] = {
215 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
216 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
217 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1,
218 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1,
219 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
220 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63,
221 -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
222 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
223 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
224 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
225 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
226 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
227 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
228 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
229 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
230 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
231 };
232
233 /** Non-data values in the DECODE arrays. */
234 private static final int SKIP = -1;
235 private static final int EQUALS = -2;
236
237 /**
238 * States 0-3 are reading through the next input tuple.
239 * State 4 is having read one '=' and expecting exactly
240 * one more.
241 * State 5 is expecting no more data or padding characters
242 * in the input.
243 * State 6 is the error state; an error has been detected
244 * in the input and no future input can "fix" it.
245 */
246 private int state; // state number (0 to 6)
247 private int value;
248
249 final private int[] alphabet;
250
251 public Decoder(int flags, byte[] output) {
252 this.output = output;
253
254 alphabet = ((flags & URL_SAFE) == 0) ? DECODE : DECODE_WEBSAFE;
255 state = 0;
256 value = 0;
257 }
258
259 /**
260 * @return an overestimate for the number of bytes {@code
261 * len} bytes could decode to.
262 */
263 public int maxOutputSize(int len) {
264 return len * 3/4 + 10;
265 }
266
267 /**
268 * Decode another block of input data.
269 *
270 * @return true if the state machine is still healthy. false if
271 * bad base-64 data has been detected in the input stream.
272 */
273 public boolean process(byte[] input, int offset, int len, boolean finish) {
274 if (this.state == 6) return false;
275
276 int p = offset;
277 len += offset;
278
279 // Using local variables makes the decoder about 12%
280 // faster than if we manipulate the member variables in
281 // the loop. (Even alphabet makes a measurable
282 // difference, which is somewhat surprising to me since
283 // the member variable is final.)
284 int state = this.state;
285 int value = this.value;
286 int op = 0;
287 final byte[] output = this.output;
288 final int[] alphabet = this.alphabet;
289
290 while (p < len) {
291 // Try the fast path: we're starting a new tuple and the
292 // next four bytes of the input stream are all data
293 // bytes. This corresponds to going through states
294 // 0-1-2-3-0. We expect to use this method for most of
295 // the data.
296 //
297 // If any of the next four bytes of input are non-data
298 // (whitespace, etc.), value will end up negative. (All
299 // the non-data values in decode are small negative
300 // numbers, so shifting any of them up and or'ing them
301 // together will result in a value with its top bit set.)
302 //
303 // You can remove this whole block and the output should
304 // be the same, just slower.
305 if (state == 0) {
306 while (p+4 <= len &&
307 (value = ((alphabet[input[p] & 0xff] << 18) |
308 (alphabet[input[p+1] & 0xff] << 12) |
309 (alphabet[input[p+2] & 0xff] << 6) |
310 (alphabet[input[p+3] & 0xff]))) >= 0) {
311 output[op+2] = (byte) value;
312 output[op+1] = (byte) (value >> 8);
313 output[op] = (byte) (value >> 16);
314 op += 3;
315 p += 4;
316 }
317 if (p >= len) break;
318 }
319
320 // The fast path isn't available -- either we've read a
321 // partial tuple, or the next four input bytes aren't all
322 // data, or whatever. Fall back to the slower state
323 // machine implementation.
324
325 int d = alphabet[input[p++] & 0xff];
326
327 switch (state) {
328 case 0:
329 if (d >= 0) {
330 value = d;
331 ++state;
332 } else if (d != SKIP) {
333 this.state = 6;
334 return false;
335 }
336 break;
337
338 case 1:
339 if (d >= 0) {
340 value = (value << 6) | d;
341 ++state;
342 } else if (d != SKIP) {
343 this.state = 6;
344 return false;
345 }
346 break;
347
348 case 2:
349 if (d >= 0) {
350 value = (value << 6) | d;
351 ++state;
352 } else if (d == EQUALS) {
353 // Emit the last (partial) output tuple;
354 // expect exactly one more padding character.
355 output[op++] = (byte) (value >> 4);
356 state = 4;
357 } else if (d != SKIP) {
358 this.state = 6;
359 return false;
360 }
361 break;
362
363 case 3:
364 if (d >= 0) {
365 // Emit the output triple and return to state 0.
366 value = (value << 6) | d;
367 output[op+2] = (byte) value;
368 output[op+1] = (byte) (value >> 8);
369 output[op] = (byte) (value >> 16);
370 op += 3;
371 state = 0;
372 } else if (d == EQUALS) {
373 // Emit the last (partial) output tuple;
374 // expect no further data or padding characters.
375 output[op+1] = (byte) (value >> 2);
376 output[op] = (byte) (value >> 10);
377 op += 2;
378 state = 5;
379 } else if (d != SKIP) {
380 this.state = 6;
381 return false;
382 }
383 break;
384
385 case 4:
386 if (d == EQUALS) {
387 ++state;
388 } else if (d != SKIP) {
389 this.state = 6;
390 return false;
391 }
392 break;
393
394 case 5:
395 if (d != SKIP) {
396 this.state = 6;
397 return false;
398 }
399 break;
400 }
401 }
402
403 if (!finish) {
404 // We're out of input, but a future call could provide
405 // more.
406 this.state = state;
407 this.value = value;
408 this.op = op;
409 return true;
410 }
411
412 // Done reading input. Now figure out where we are left in
413 // the state machine and finish up.
414
415 switch (state) {
416 case 0:
417 // Output length is a multiple of three. Fine.
418 break;
419 case 1:
420 // Read one extra input byte, which isn't enough to
421 // make another output byte. Illegal.
422 this.state = 6;
423 return false;
424 case 2:
425 // Read two extra input bytes, enough to emit 1 more
426 // output byte. Fine.
427 output[op++] = (byte) (value >> 4);
428 break;
429 case 3:
430 // Read three extra input bytes, enough to emit 2 more
431 // output bytes. Fine.
432 output[op++] = (byte) (value >> 10);
433 output[op++] = (byte) (value >> 2);
434 break;
435 case 4:
436 // Read one padding '=' when we expected 2. Illegal.
437 this.state = 6;
438 return false;
439 case 5:
440 // Read all the padding '='s we expected and no more.
441 // Fine.
442 break;
443 }
444
445 this.state = state;
446 this.op = op;
447 return true;
448 }
449 }
450
451 // --------------------------------------------------------
452 // encoding
453 // --------------------------------------------------------
454
455 /**
456 * Base64-encode the given data and return a newly allocated
457 * String with the result.
458 *
459 * @param input the data to encode
460 * @param flags controls certain features of the encoded output.
461 * Passing {@code DEFAULT} results in output that
462 * adheres to RFC 2045.
463 */
464 public static String encodeToString(byte[] input, int flags) {
465 try {
466 return new String(encode(input, flags), "US-ASCII");
467 } catch (UnsupportedEncodingException e) {
468 // US-ASCII is guaranteed to be available.
469 throw new AssertionError(e);
470 }
471 }
472
473 /**
474 * Base64-encode the given data and return a newly allocated
475 * String with the result.
476 *
477 * @param input the data to encode
478 * @param offset the position within the input array at which to
479 * start
480 * @param len the number of bytes of input to encode
481 * @param flags controls certain features of the encoded output.
482 * Passing {@code DEFAULT} results in output that
483 * adheres to RFC 2045.
484 */
485 public static String encodeToString(byte[] input, int offset, int len, int flags) {
486 try {
487 return new String(encode(input, offset, len, flags), "US-ASCII");
488 } catch (UnsupportedEncodingException e) {
489 // US-ASCII is guaranteed to be available.
490 throw new AssertionError(e);
491 }
492 }
493
494 /**
495 * Base64-encode the given data and return a newly allocated
496 * byte[] with the result.
497 *
498 * @param input the data to encode
499 * @param flags controls certain features of the encoded output.
500 * Passing {@code DEFAULT} results in output that
501 * adheres to RFC 2045.
502 */
503 public static byte[] encode(byte[] input, int flags) {
504 return encode(input, 0, input.length, flags);
505 }
506
507 /**
508 * Base64-encode the given data and return a newly allocated
509 * byte[] with the result.
510 *
511 * @param input the data to encode
512 * @param offset the position within the input array at which to
513 * start
514 * @param len the number of bytes of input to encode
515 * @param flags controls certain features of the encoded output.
516 * Passing {@code DEFAULT} results in output that
517 * adheres to RFC 2045.
518 */
519 public static byte[] encode(byte[] input, int offset, int len, int flags) {
520 Encoder encoder = new Encoder(flags, null);
521
522 // Compute the exact length of the array we will produce.
523 int output_len = len / 3 * 4;
524
525 // Account for the tail of the data and the padding bytes, if any.
526 if (encoder.do_padding) {
527 if (len % 3 > 0) {
528 output_len += 4;
529 }
530 } else {
531 switch (len % 3) {
532 case 0: break;
533 case 1: output_len += 2; break;
534 case 2: output_len += 3; break;
535 }
536 }
537
538 // Account for the newlines, if any.
539 if (encoder.do_newline && len > 0) {
540 output_len += (((len-1) / (3 * Encoder.LINE_GROUPS)) + 1) *
541 (encoder.do_cr ? 2 : 1);
542 }
543
544 encoder.output = new byte[output_len];
545 encoder.process(input, offset, len, true);
546
547 assert encoder.op == output_len;
548
549 return encoder.output;
550 }
551
552 /* package */ static class Encoder extends Coder {
553 /**
554 * Emit a new line every this many output tuples. Corresponds to
555 * a 76-character line length (the maximum allowable according to
556 * <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045</a>).
557 */
558 public static final int LINE_GROUPS = 19;
559
560 /**
561 * Lookup table for turning Base64 alphabet positions (6 bits)
562 * into output bytes.
563 */
564 private static final byte ENCODE[] = {
565 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
566 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
567 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
568 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/',
569 };
570
571 /**
572 * Lookup table for turning Base64 alphabet positions (6 bits)
573 * into output bytes.
574 */
575 private static final byte ENCODE_WEBSAFE[] = {
576 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
577 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
578 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
579 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_',
580 };
581
582 final private byte[] tail;
583 /* package */ int tailLen;
584 private int count;
585
586 final public boolean do_padding;
587 final public boolean do_newline;
588 final public boolean do_cr;
589 final private byte[] alphabet;
590
591 public Encoder(int flags, byte[] output) {
592 this.output = output;
593
594 do_padding = (flags & NO_PADDING) == 0;
595 do_newline = (flags & NO_WRAP) == 0;
596 do_cr = (flags & CRLF) != 0;
597 alphabet = ((flags & URL_SAFE) == 0) ? ENCODE : ENCODE_WEBSAFE;
598
599 tail = new byte[2];
600 tailLen = 0;
601
602 count = do_newline ? LINE_GROUPS : -1;
603 }
604
605 /**
606 * @return an overestimate for the number of bytes {@code
607 * len} bytes could encode to.
608 */
609 public int maxOutputSize(int len) {
610 return len * 8/5 + 10;
611 }
612
613 public boolean process(byte[] input, int offset, int len, boolean finish) {
614 // Using local variables makes the encoder about 9% faster.
615 final byte[] alphabet = this.alphabet;
616 final byte[] output = this.output;
617 int op = 0;
618 int count = this.count;
619
620 int p = offset;
621 len += offset;
622 int v = -1;
623
624 // First we need to concatenate the tail of the previous call
625 // with any input bytes available now and see if we can empty
626 // the tail.
627
628 switch (tailLen) {
629 case 0:
630 // There was no tail.
631 break;
632
633 case 1:
634 if (p+2 <= len) {
635 // A 1-byte tail with at least 2 bytes of
636 // input available now.
637 v = ((tail[0] & 0xff) << 16) |
638 ((input[p++] & 0xff) << 8) |
639 (input[p++] & 0xff);
640 tailLen = 0;
641 };
642 break;
643
644 case 2:
645 if (p+1 <= len) {
646 // A 2-byte tail with at least 1 byte of input.
647 v = ((tail[0] & 0xff) << 16) |
648 ((tail[1] & 0xff) << 8) |
649 (input[p++] & 0xff);
650 tailLen = 0;
651 }
652 break;
653 }
654
655 if (v != -1) {
656 output[op++] = alphabet[(v >> 18) & 0x3f];
657 output[op++] = alphabet[(v >> 12) & 0x3f];
658 output[op++] = alphabet[(v >> 6) & 0x3f];
659 output[op++] = alphabet[v & 0x3f];
660 if (--count == 0) {
661 if (do_cr) output[op++] = '\r';
662 output[op++] = '\n';
663 count = LINE_GROUPS;
664 }
665 }
666
667 // At this point either there is no tail, or there are fewer
668 // than 3 bytes of input available.
669
670 // The main loop, turning 3 input bytes into 4 output bytes on
671 // each iteration.
672 while (p+3 <= len) {
673 v = ((input[p] & 0xff) << 16) |
674 ((input[p+1] & 0xff) << 8) |
675 (input[p+2] & 0xff);
676 output[op] = alphabet[(v >> 18) & 0x3f];
677 output[op+1] = alphabet[(v >> 12) & 0x3f];
678 output[op+2] = alphabet[(v >> 6) & 0x3f];
679 output[op+3] = alphabet[v & 0x3f];
680 p += 3;
681 op += 4;
682 if (--count == 0) {
683 if (do_cr) output[op++] = '\r';
684 output[op++] = '\n';
685 count = LINE_GROUPS;
686 }
687 }
688
689 if (finish) {
690 // Finish up the tail of the input. Note that we need to
691 // consume any bytes in tail before any bytes
692 // remaining in input; there should be at most two bytes
693 // total.
694
695 if (p-tailLen == len-1) {
696 int t = 0;
697 v = ((tailLen > 0 ? tail[t++] : input[p++]) & 0xff) << 4;
698 tailLen -= t;
699 output[op++] = alphabet[(v >> 6) & 0x3f];
700 output[op++] = alphabet[v & 0x3f];
701 if (do_padding) {
702 output[op++] = '=';
703 output[op++] = '=';
704 }
705 if (do_newline) {
706 if (do_cr) output[op++] = '\r';
707 output[op++] = '\n';
708 }
709 } else if (p-tailLen == len-2) {
710 int t = 0;
711 v = (((tailLen > 1 ? tail[t++] : input[p++]) & 0xff) << 10) |
712 (((tailLen > 0 ? tail[t++] : input[p++]) & 0xff) << 2);
713 tailLen -= t;
714 output[op++] = alphabet[(v >> 12) & 0x3f];
715 output[op++] = alphabet[(v >> 6) & 0x3f];
716 output[op++] = alphabet[v & 0x3f];
717 if (do_padding) {
718 output[op++] = '=';
719 }
720 if (do_newline) {
721 if (do_cr) output[op++] = '\r';
722 output[op++] = '\n';
723 }
724 } else if (do_newline && op > 0 && count != LINE_GROUPS) {
725 if (do_cr) output[op++] = '\r';
726 output[op++] = '\n';
727 }
728
729 assert tailLen == 0;
730 assert p == len;
731 } else {
732 // Save the leftovers in tail to be consumed on the next
733 // call to encodeInternal.
734
735 if (p == len-1) {
736 tail[tailLen++] = input[p];
737 } else if (p == len-2) {
738 tail[tailLen++] = input[p];
739 tail[tailLen++] = input[p+1];
740 }
741 }
742
743 this.op = op;
744 this.count = count;
745
746 return true;
747 }
748 }
749
750 private Base64() { } // don't instantiate
751 }
Small java utilities, mostly for personal use -- but feel free to have a look