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