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