public InputStream(InputStream in) 
{
            this( in, DECODE );
}

Constructs a Base64.InputStream in DECODE mode.

Parameters:

in - the java.io.InputStream from which to read data.

since: 1.3 -

 public InputStream(InputStream in,
    int options) 
{
            super( in );
            this.breakLines   = (options & DONT_BREAK_LINES) != DONT_BREAK_LINES;
            this.encode       = (options & ENCODE) == ENCODE;
            this.bufferLength = encode ? 4 : 3;
            this.buffer       = new byte[ bufferLength ];
            this.position     = -1;
            this.lineLength   = 0;
            this.options      = options; // Record for later, mostly to determine which alphabet to use
            this.alphabet     = getAlphabet(options);
            this.decodabet    = getDecodabet(options);
}

Constructs a Base64.InputStream in either ENCODE or DECODE mode.

Valid options:

  ENCODE or DECODE: Encode or Decode as data is read.
  DONT_BREAK_LINES: don't break lines at 76 characters
    (only meaningful when encoding)
    Note: Technically, this makes your encoding non-compliant.

Example: new Base64.InputStream( in, Base64.DECODE )

Parameters:

in - the java.io.InputStream from which to read data.

options - Specified options

Also see:

Base64#ENCODE
Base64#DECODE
Base64#DONT_BREAK_LINES
since: 2.0 -

 public int read() throws IOException 
{
            // Do we need to get data?
            if( position <  0 ) {
                if( encode ) {
                    byte[] b3 = new byte[3];
                    int numBinaryBytes = 0;
                    for( int i = 0; i <  3; i++ ) {
                        try {
                            int b = in.read();
                            // If end of stream, b is -1.
                            if( b  >= 0 ) {
                                b3[i] = (byte)b;
                                numBinaryBytes++;
                            }   // end if: not end of stream
                        }   // end try: read
                        catch( java.io.IOException e ) {
                            // Only a problem if we got no data at all.
                            if( i == 0 )
                                throw e;
                        }   // end catch
                    }   // end for: each needed input byte
                    if( numBinaryBytes  > 0 ) {
                        encode3to4( b3, 0, numBinaryBytes, buffer, 0, options );
                        position = 0;
                        numSigBytes = 4;
                    }   // end if: got data
                    else {
                        return -1;
                    }   // end else
                }   // end if: encoding
                // Else decoding
                else {
                    byte[] b4 = new byte[4];
                    int i = 0;
                    for( i = 0; i <  4; i++ ) {
                        // Read four "meaningful" bytes:
                        int b = 0;
                        do{ b = in.read(); }
                        while( b  >= 0 && decodabet[ b & 0x7f ] < = WHITE_SPACE_ENC );
                        if( b <  0 )
                            break; // Reads a -1 if end of stream
                        b4[i] = (byte)b;
                    }   // end for: each needed input byte
                    if( i == 4 ) {
                        numSigBytes = decode4to3( b4, 0, buffer, 0, options );
                        position = 0;
                    }   // end if: got four characters
                    else if( i == 0 ){
                        return -1;
                    }   // end else if: also padded correctly
                    else {
                        // Must have broken out from above.
                        throw new java.io.IOException( "Improperly padded Base64 input." );
                    }   // end
                }   // end else: decode
            }   // end else: get data
            // Got data?
            if( position  >= 0 ) {
                // End of relevant data?
                if( /*!encode &&*/ position  >= numSigBytes )
                    return -1;
                if( encode && breakLines && lineLength  >= MAX_LINE_LENGTH ) {
                    lineLength = 0;
                    return '\n';
                }   // end if
                else {
                    lineLength++;   // This isn't important when decoding
                    // but throwing an extra "if" seems
                    // just as wasteful.
                    int b = buffer[ position++ ];
                    if( position  >= bufferLength )
                        position = -1;
                    return b & 0xFF; // This is how you "cast" a byte that's
                    // intended to be unsigned.
                }   // end else
            }   // end if: position  >= 0
            // Else error
            else {
                // When JDK1.4 is more accepted, use an assertion here.
                throw new java.io.IOException( "Error in Base64 code reading stream." );
            }   // end else
}

Reads enough of the input stream to convert to/from Base64 and returns the next byte.

 public int read(byte[] dest,
    int off,
    int len) throws IOException 
{
            int i;
            int b;
            for( i = 0; i <  len; i++ ) {
                b = read();
                //if( b <  0 && i == 0 )
                //    return -1;
                if( b  >= 0 )
                    dest[off + i] = (byte)b;
                else if( i == 0 )
                    return -1;
                else
                    break; // Out of 'for' loop
            }   // end for: each byte read
            return i;
}

Calls #read() repeatedly until the end of stream is reached or len bytes are read. Returns number of bytes read into array or -1 if end of stream is encountered.