/// <summary>Decode an input stream into a bitmap.</summary>
/// <remarks>
/// Decode an input stream into a bitmap. If the input stream is null, or
/// cannot be used to decode a bitmap, the function returns null.
/// The stream's position will be where ever it was after the encoded data
/// was read.
/// </remarks>
/// <param name="is">
/// The input stream that holds the raw data to be decoded into a
/// bitmap.
/// </param>
/// <param name="outPadding">
/// If not null, return the padding rect for the bitmap if
/// it exists, otherwise set padding to [-1,-1,-1,-1]. If
/// no bitmap is returned (null) then padding is
/// unchanged.
/// </param>
/// <param name="opts">
/// null-ok; Options that control downsampling and whether the
/// image should be completely decoded, or just is size returned.
/// </param>
/// <returns>
/// The decoded bitmap, or null if the image data could not be
/// decoded, or, if opts is non-null, if opts requested only the
/// size be returned (in opts.outWidth and opts.outHeight)
/// </returns>
public static android.graphics.Bitmap decodeStream(java.io.InputStream @is, android.graphics.Rect
outPadding, android.graphics.BitmapFactory.Options opts)
{
// we don't throw in this case, thus allowing the caller to only check
// the cache, and not force the image to be decoded.
if (@is == null)
{
return null;
}
// we need mark/reset to work properly
if ([email protected]())
{
@is = new java.io.BufferedInputStream(@is, 16 * 1024);
}
// so we can call reset() if a given codec gives up after reading up to
// this many bytes. FIXME: need to find out from the codecs what this
// value should be.
@is.mark(1024);
android.graphics.Bitmap bm;
if (@is is android.content.res.AssetManager.AssetInputStream)
{
bm = nativeDecodeAsset(((android.content.res.AssetManager.AssetInputStream)@is).mAsset
, outPadding, opts);
}
else
{
// pass some temp storage down to the native code. 1024 is made up,
// but should be large enough to avoid too many small calls back
// into is.read(...) This number is not related to the value passed
// to mark(...) above.
byte[] tempStorage = null;
if (opts != null)
{
tempStorage = opts.inTempStorage;
}
if (tempStorage == null)
{
tempStorage = new byte[16 * 1024];
}
bm = nativeDecodeStream(@is, tempStorage, outPadding, opts);
}
if (bm == null && opts != null && opts.inBitmap != null)
{
throw new System.ArgumentException("Problem decoding into existing bitmap");
}
return finishDecode(bm, outPadding, opts);
}
/// <summary>Return the AudioFileFormat from the given InputStream.</summary>
/// <remarks>Return the AudioFileFormat from the given InputStream. Implementation.</remarks>
/// <param name="bitStream"></param>
/// <param name="baos"></param>
/// <param name="mediaLength"></param>
/// <returns>
/// an AudioInputStream object based on the audio file data contained
/// in the input stream.
/// </returns>
/// <exception>
/// UnsupportedAudioFileException
/// if the File does not point to
/// a valid audio file data recognized by the system.
/// </exception>
/// <exception>
/// IOException
/// if an I/O exception occurs.
/// </exception>
/// <exception cref="javax.sound.sampled.UnsupportedAudioFileException"></exception>
/// <exception cref="System.IO.IOException"></exception>
protected virtual javax.sound.sampled.AudioFileFormat getAudioFileFormat(java.io.InputStream
bitStream, java.io.ByteArrayOutputStream baos, int mediaLength)
{
javax.sound.sampled.AudioFormat format;
try
{
// If we can't read the format of this stream, we must restore stream to
// beginning so other providers can attempt to read the stream.
if (bitStream.markSupported())
{
// maximum number of bytes to determine the stream encoding:
// Size of 1st Ogg Packet (Speex header) = OGG_HEADERSIZE + SPEEX_HEADERSIZE + 1
// Size of 2nd Ogg Packet (Comment) = OGG_HEADERSIZE + comment_size + 1
// Size of 3rd Ogg Header (First data) = OGG_HEADERSIZE + number_of_frames
// where number_of_frames < 256 and comment_size < 256 (if within 1 frame)
bitStream.mark(3 * OGG_HEADERSIZE + SPEEX_HEADERSIZE + 256 + 256 + 2);
}
int mode = -1;
int sampleRate = 0;
int channels = 0;
int frameSize = javax.sound.sampled.AudioSystem.NOT_SPECIFIED;
float frameRate = javax.sound.sampled.AudioSystem.NOT_SPECIFIED;
byte[] header = new byte[128];
int segments = 0;
int bodybytes = 0;
java.io.DataInputStream dis = new java.io.DataInputStream(bitStream);
if (baos == null)
{
baos = new java.io.ByteArrayOutputStream(128);
}
int origchksum;
int chksum;
// read the OGG header
dis.readFully(header, 0, OGG_HEADERSIZE);
baos.write(header, 0, OGG_HEADERSIZE);
origchksum = readInt(header, 22);
header[22] = 0;
header[23] = 0;
header[24] = 0;
header[25] = 0;
chksum = org.xiph.speex.OggCrc.checksum(0, header, 0, OGG_HEADERSIZE);
// make sure its a OGG header
if (!OGGID.Equals(cspeex.StringUtil.getStringForBytes(header, 0, 4)))
{
throw new javax.sound.sampled.UnsupportedAudioFileException("missing ogg id!");
}
// how many segments are there?
segments = header[SEGOFFSET] & unchecked((int)(0xFF));
if (segments > 1)
{
throw new javax.sound.sampled.UnsupportedAudioFileException("Corrupt Speex Header: more than 1 segments"
);
}
dis.readFully(header, OGG_HEADERSIZE, segments);
baos.write(header, OGG_HEADERSIZE, segments);
chksum = org.xiph.speex.OggCrc.checksum(chksum, header, OGG_HEADERSIZE, segments);
// get the number of bytes in the segment
bodybytes = header[OGG_HEADERSIZE] & unchecked((int)(0xFF));
if (bodybytes != SPEEX_HEADERSIZE)
{
throw new javax.sound.sampled.UnsupportedAudioFileException("Corrupt Speex Header: size="
+ bodybytes);
}
// read the Speex header
dis.readFully(header, OGG_HEADERSIZE + 1, bodybytes);
baos.write(header, OGG_HEADERSIZE + 1, bodybytes);
chksum = org.xiph.speex.OggCrc.checksum(chksum, header, OGG_HEADERSIZE + 1, bodybytes
);
// make sure its a Speex header
if (!SPEEXID.Equals(cspeex.StringUtil.getStringForBytes(header, OGG_HEADERSIZE + 1,
8)))
{
throw new javax.sound.sampled.UnsupportedAudioFileException("Corrupt Speex Header: missing Speex ID"
);
}
mode = readInt(header, OGG_HEADERSIZE + 1 + 40);
sampleRate = readInt(header, OGG_HEADERSIZE + 1 + 36);
channels = readInt(header, OGG_HEADERSIZE + 1 + 48);
int nframes = readInt(header, OGG_HEADERSIZE + 1 + 64);
bool vbr = readInt(header, OGG_HEADERSIZE + 1 + 60) == 1;
// Checksum
if (chksum != origchksum)
{
throw new System.IO.IOException("Ogg CheckSums do not match");
}
// Calculate frameSize
if (!vbr)
{
}
// Frames size is a constant so:
// Read Comment Packet the Ogg Header of 1st data packet;
// the array table_segment repeats the frame size over and over.
// Calculate frameRate
if (mode >= 0 && mode <= 2 && nframes > 0)
{
frameRate = ((float)sampleRate) / ((mode == 0 ? 160f : (mode == 1 ? 320f : 640f))
* ((float)nframes));
}
format = new javax.sound.sampled.AudioFormat(org.xiph.speex.spi.SpeexEncoding.SPEEX
, (float)sampleRate, javax.sound.sampled.AudioSystem.NOT_SPECIFIED, channels, frameSize
, frameRate, false);
}
catch (javax.sound.sampled.UnsupportedAudioFileException e)
{
// reset the stream for other providers
if (bitStream.markSupported())
{
bitStream.reset();
}
// just rethrow this exception
throw;
}
catch (System.IO.IOException ioe)
{
// reset the stream for other providers
if (bitStream.markSupported())
{
bitStream.reset();
}
throw new javax.sound.sampled.UnsupportedAudioFileException(ioe.Message);
}
return new javax.sound.sampled.AudioFileFormat(org.xiph.speex.spi.SpeexFileFormatType
.SPEEX, format, javax.sound.sampled.AudioSystem.NOT_SPECIFIED);
}