/* csvorbis
* Copyright (C) 2000 ymnk, JCraft,Inc.
*
* Written by: 2000 ymnk<ymnk@jcraft.com>
* Ported to C# from JOrbis by: Mark Crichton <crichton@gimp.org>
*
* Thanks go to the JOrbis team, for licencing the code under the
* LGPL, making my job a lot easier.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public License
* as published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
using System;
using System.IO;
using csogg;
namespace csvorbis
{
public class VorbisFile
{
static int CHUNKSIZE=8500;
static int SEEK_SET=0;
static int SEEK_CUR=1;
static int SEEK_END=2;
static int OV_FALSE=-1;
static int OV_EOF=-2;
static int OV_HOLE=-3;
static int OV_EREAD=-128;
static int OV_EFAULT=-129;
static int OV_EIMPL=-130;
static int OV_EINVAL=-131;
static int OV_ENOTVORBIS=-132;
static int OV_EBADHEADER=-133;
static int OV_EVERSION=-134;
static int OV_ENOTAUDIO=-135;
static int OV_EBADPACKET=-136;
static int OV_EBADLINK=-137;
static int OV_ENOSEEK=-138;
FileStream datasource;
bool skable=false;
long offset;
long end;
SyncState oy=new SyncState();
int links;
long[] offsets;
long[] dataoffsets;
int[] serialnos;
long[] pcmlengths;
Info[] vi;
Comment[] vc;
// Decoding working state local storage
long pcm_offset;
bool decode_ready=false;
int current_serialno;
int current_link;
float bittrack;
float samptrack;
StreamState os;
DspState vd;
Block vb;
private VorbisFile()
{
os=new StreamState(); // take physical pages, weld into a logical
// stream of packets
vd=new DspState(); // central working state for
// the packet->PCM decoder
vb=new Block(vd); // local working space for packet->PCM decode
}
public VorbisFile(String file) : this()
{
FileStream inst=null;
try{ inst=new FileStream(file, FileMode.Open, FileAccess.Read);}
catch(Exception e)
{
throw new csorbisException("VorbisFile: "+e.Message);
}
int ret=open(inst, null, 0);
if(ret==-1)
{
throw new csorbisException("VorbisFile: open return -1");
}
}
public VorbisFile(FileStream inst, byte[] initial, int ibytes) : this()
{
int ret=open(inst, initial, ibytes);
}
private int get_data()
{
int index=oy.buffer(CHUNKSIZE);
byte[] buffer=oy.data;
// int bytes=callbacks.read_func(buffer, index, 1, CHUNKSIZE, datasource);
int bytes=0;
try
{
bytes=datasource.Read(buffer, index, CHUNKSIZE);
}
catch(Exception e)
{
Console.Error.WriteLine(e.Message);
return OV_EREAD;
}
oy.wrote(bytes);
if(bytes==-1)
{
bytes=0;
}
return bytes;
}
private void seek_helper(long offst)
{
//callbacks.seek_func(datasource, offst, SEEK_SET);
fseek(datasource, offst, SEEK_SET);
this.offset=offst;
oy.reset();
}
private int get_next_page(Page page, long boundary)
{
if(boundary>0) boundary+=offset;
while(true)
{
int more;
if(boundary>0 && offset>=boundary)return OV_FALSE;
more=oy.pageseek(page);
if(more<0){offset-=more;}
else
{
if(more==0)
{
if(boundary==0)return OV_FALSE;
// if(get_data()<=0)return -1;
int ret=get_data();
if(ret==0) return OV_EOF;
if(ret<0) return OV_EREAD;
}
else
{
int ret=(int)offset; //!!!
offset+=more;
return ret;
}
}
}
}
private int get_prev_page(Page page)
{
long begin=offset; //!!!
int ret;
int offst=-1;
while(offst==-1)
{
begin-=CHUNKSIZE;
if(begin<0)
begin=0;
seek_helper(begin);
while(offset<begin+CHUNKSIZE)
{
ret=get_next_page(page, begin+CHUNKSIZE-offset);
if(ret==OV_EREAD){ return OV_EREAD; }
if(ret<0){ break; }
else{ offst=ret; }
}
}
seek_helper(offst); //!!!
ret=get_next_page(page, CHUNKSIZE);
if(ret<0)
{
//System.err.println("Missed page fencepost at end of logical bitstream Exiting");
//System.exit(1);
return OV_EFAULT;
}
return offst;
}
int bisect_forward_serialno(long begin, long searched, long end, int currentno, int m)
{
long endsearched=end;
long next=end;
Page page=new Page();
int ret;
while(searched<endsearched)
{
long bisect;
if(endsearched-searched<CHUNKSIZE)
{
bisect=searched;
}
else
{
bisect=(searched+endsearched)/2;
}
seek_helper(bisect);
ret=get_next_page(page, -1);
if(ret==OV_EREAD) return OV_EREAD;
if(ret<0 || page.serialno()!=currentno)
{
endsearched=bisect;
if(ret>=0)next=ret;
}
else
{
searched=ret+page.header_len+page.body_len;
}
}
seek_helper(next);
ret=get_next_page(page, -1);
if(ret==OV_EREAD) return OV_EREAD;
if(searched>=end || ret==-1)
{
links=m+1;
offsets=new long[m+2];
offsets[m+1]=searched;
}
else
{
ret=bisect_forward_serialno(next, offset, end, page.serialno(), m+1);
if(ret==OV_EREAD)return OV_EREAD;
}
offsets[m]=begin;
return 0;
}
// uses the local ogg_stream storage in vf; this is important for
// non-streaming input sources
int fetch_headers(Info vi, Comment vc, int[] serialno, Page og_ptr)
{
//System.err.println("fetch_headers");
Page og=new Page();
Packet op=new Packet();
int ret;
if(og_ptr==null)
{
ret=get_next_page(og, CHUNKSIZE);
if(ret==OV_EREAD)return OV_EREAD;
if(ret<0) return OV_ENOTVORBIS;
og_ptr=og;
}
if(serialno!=null)serialno[0]=og_ptr.serialno();
os.init(og_ptr.serialno());
// extract the initial header from the first page and verify that the
// Ogg bitstream is in fact Vorbis data
vi.init();
vc.init();
int i=0;
while(i<3)
{
os.pagein(og_ptr);
while(i<3)
{
int result=os.packetout(op);
if(result==0)break;
if(result==-1)
{
Console.Error.WriteLine("Corrupt header in logical bitstream.");
//goto bail_header;
vi.clear();
vc.clear();
os.clear();
return -1;
}
if(vi.synthesis_headerin(vc, op)!=0)
{
Console.Error.WriteLine("Illegal header in logical bitstream.");
//goto bail_header;
vi.clear();
vc.clear();
os.clear();
return -1;
}
i++;
}
if(i<3)
if(get_next_page(og_ptr, 1)<0)
{
Console.Error.WriteLine("Missing header in logical bitstream.");
//goto bail_header;
vi.clear();
vc.clear();
os.clear();
return -1;
}
}
return 0;
}
// last step of the OggVorbis_File initialization; get all the
// vorbis_info structs and PCM positions. Only called by the seekable
// initialization (local stream storage is hacked slightly; pay
// attention to how that's done)
void prefetch_all_headers(Info first_i,Comment first_c, int dataoffset)
{
Page og=new Page();
int ret;
vi=new Info[links];
vc=new Comment[links];
dataoffsets=new long[links];
pcmlengths=new long[links];
serialnos=new int[links];
for(int i=0;i<links;i++)
{
if(first_i!=null && first_c!=null && i==0)
{
// we already grabbed the initial header earlier. This just
// saves the waste of grabbing it again
// !!!!!!!!!!!!!
vi[i]=first_i;
//memcpy(vf->vi+i,first_i,sizeof(vorbis_info));
vc[i]=first_c;
//memcpy(vf->vc+i,first_c,sizeof(vorbis_comment));
dataoffsets[i]=dataoffset;
}
else
{
// seek to the location of the initial header
seek_helper(offsets[i]); //!!!
if(fetch_headers(vi[i], vc[i], null, null)==-1)
{
Console.Error.WriteLine("Error opening logical bitstream #"+(i+1)+"\n");
dataoffsets[i]=-1;
}
else
{
dataoffsets[i]=offset;
os.clear();
}
}
// get the serial number and PCM length of this link. To do this,
// get the last page of the stream
long end=offsets[i+1]; //!!!
seek_helper(end);
while(true)
{
ret=get_prev_page(og);
if(ret==-1)
{
// this should not be possible
Console.Error.WriteLine("Could not find last page of logical "+
"bitstream #"+(i)+"\n");
vi[i].clear();
vc[i].clear();
break;
}
if(og.granulepos()!=-1)
{
serialnos[i]=og.serialno();
pcmlengths[i]=og.granulepos();
break;
}
}
}
}
int make_decode_ready()
{
#if NET_2_1
if(decode_ready) throw new Exception ("make_decode_ready: 1");
#else
if(decode_ready)Environment.Exit(1);
#endif
vd.synthesis_init(vi[0]);
vb.init(vd);
decode_ready=true;
return(0);
}
int open_seekable()
{
Info initial_i=new Info();
Comment initial_c=new Comment();
int serialno;
long end;
int ret;
int dataoffset;
Page og=new Page();
// is this even vorbis...?
int[] foo=new int[1];
ret=fetch_headers(initial_i, initial_c, foo, null);
serialno=foo[0];
dataoffset=(int)offset; //!!
os.clear();
if(ret==-1)return(-1);
// we can seek, so set out learning all about this file
skable=true;
//(callbacks.seek_func)(datasource, 0, SEEK_END);
fseek(datasource, 0, SEEK_END);
//offset=end=(callbacks.tell_func)(datasource);
offset=ftell(datasource);
end=offset;
// We get the offset for the last page of the physical bitstream.
// Most OggVorbis files will contain a single logical bitstream
end=get_prev_page(og);
// moer than one logical bitstream?
if(og.serialno()!=serialno)
{
// Chained bitstream. Bisect-search each logical bitstream
// section. Do so based on serial number only
if(bisect_forward_serialno(0,0,end+1,serialno,0)<0)
{
clear();
return OV_EREAD;
}
}
else
{
// Only one logical bitstream
if(bisect_forward_serialno(0,end,end+1,serialno,0)<0)
{
clear();
return OV_EREAD;
}
}
prefetch_all_headers(initial_i, initial_c, dataoffset);
return(raw_seek(0));
}
int open_nonseekable()
{
//System.err.println("open_nonseekable");
// we cannot seek. Set up a 'single' (current) logical bitstream entry
links=1;
vi=new Info[links]; vi[0]=new Info(); // ??
vc=new Comment[links]; vc[0]=new Comment(); // ?? bug?
// Try to fetch the headers, maintaining all the storage
int[]foo=new int[1];
if(fetch_headers(vi[0], vc[0], foo, null)==-1)return(-1);
current_serialno=foo[0];
make_decode_ready();
return 0;
}
// clear out the current logical bitstream decoder
void decode_clear()
{
os.clear();
vd.clear();
vb.clear();
decode_ready=false;
bittrack=0.0f;
samptrack=0.0f;
}
// fetch and process a packet. Handles the case where we're at a
// bitstream boundary and dumps the decoding machine. If the decoding
// machine is unloaded, it loads it. It also keeps pcm_offset up to
// date (seek and read both use this. seek uses a special hack with
// readp).
//
// return: -1) hole in the data (lost packet)
// 0) need more date (only if readp==0)/eof
// 1) got a packet
int process_packet(int readp)
{
Page og=new Page();
// handle one packet. Try to fetch it from current stream state
// extract packets from page
while(true)
{
// process a packet if we can. If the machine isn't loaded,
// neither is a page
if(decode_ready)
{
Packet op=new Packet();
int result=os.packetout(op);
long granulepos;
// if(result==-1)return(-1); // hole in the data. For now, swallow
// and go. We'll need to add a real
// error code in a bit.
if(result>0)
{
// got a packet. process it
granulepos=op.granulepos;
if(vb.synthesis(op)==0)
{ // lazy check for lazy
// header handling. The
// header packets aren't
// audio, so if/when we
// submit them,
// vorbis_synthesis will
// reject them
// suck in the synthesis data and track bitrate
{
int oldsamples=vd.synthesis_pcmout(null, null);
vd.synthesis_blockin(vb);
samptrack+=vd.synthesis_pcmout(null, null)-oldsamples;
bittrack+=op.bytes*8;
}
// update the pcm offset.
if(granulepos!=-1 && op.e_o_s==0)
{
int link=(skable?current_link:0);
int samples;
// this packet has a pcm_offset on it (the last packet
// completed on a page carries the offset) After processing
// (above), we know the pcm position of the *last* sample
// ready to be returned. Find the offset of the *first*
//
// As an aside, this trick is inaccurate if we begin
// reading anew right at the last page; the end-of-stream
// granulepos declares the last frame in the stream, and the
// last packet of the last page may be a partial frame.
// So, we need a previous granulepos from an in-sequence page
// to have a reference point. Thus the !op.e_o_s clause above
samples=vd.synthesis_pcmout(null, null);
granulepos-=samples;
for(int i=0;i<link;i++)
{
granulepos+=pcmlengths[i];
}
pcm_offset=granulepos;
}
return(1);
}
}
}
if(readp==0)return(0);
if(get_next_page(og,-1)<0)return(0); // eof. leave unitialized
// bitrate tracking; add the header's bytes here, the body bytes
// are done by packet above
bittrack+=og.header_len*8;
// has our decoding just traversed a bitstream boundary?
if(decode_ready)
{
if(current_serialno!=og.serialno())
{
decode_clear();
}
}
// Do we need to load a new machine before submitting the page?
// This is different in the seekable and non-seekable cases.
//
// In the seekable case, we already have all the header
// information loaded and cached; we just initialize the machine
// with it and continue on our merry way.
//
// In the non-seekable (streaming) case, we'll only be at a
// boundary if we just left the previous logical bitstream and
// we're now nominally at the header of the next bitstream
if(!decode_ready)
{
int i;
if(skable)
{
current_serialno=og.serialno();
// match the serialno to bitstream section. We use this rather than
// offset positions to avoid problems near logical bitstream
// boundaries
for(i=0;i<links;i++)
{
if(serialnos[i]==current_serialno)break;
}
if(i==links)return(-1); // sign of a bogus stream. error out,
// leave machine uninitialized
current_link=i;
os.init(current_serialno);
os.reset();
}
else
{
// we're streaming
// fetch the three header packets, build the info struct
int[] foo = new int[1];
int ret=fetch_headers(vi[0], vc[0], foo, og);
current_serialno=foo[0];
if(ret!=0)return ret;
current_link++;
i=0;
}
make_decode_ready();
}
os.pagein(og);
}
}
//The helpers are over; it's all toplevel interface from here on out
// clear out the OggVorbis_File struct
int clear()
{
vb.clear();
vd.clear();
os.clear();
if(vi!=null && links!=0)
{
for(int i=0;i<links;i++)
{
vi[i].clear();
vc[i].clear();
}
vi=null;
vc=null;
}
if(dataoffsets!=null)dataoffsets=null;
if(pcmlengths!=null)pcmlengths=null;
if(serialnos!=null)serialnos=null;
if(offsets!=null)offsets=null;
oy.clear();
//if(datasource!=null)(vf->callbacks.close_func)(vf->datasource);
//memset(vf,0,sizeof(OggVorbis_File));
return(0);
}
static int fseek(FileStream fis,
//int64_t off,
long off,
int whence)
{
if(fis.CanSeek == true)
{
try
{
if(whence==SEEK_SET)
{
fis.Seek(off, 0);
}
else if(whence==SEEK_END)
{
fis.Seek(fis.Length - off, 0);
}
else
{
Console.Error.WriteLine("seek: "+whence+" is not supported");
}
}
catch(Exception e)
{
Console.Error.WriteLine(e.Message);
}
return 0;
}
try
{
if(whence==0){ fis.Seek(0, 0); }
fis.Seek(off, 0);
}
catch(Exception e)
{
Console.Error.WriteLine(e.Message);
return -1;
}
return 0;
}
static long ftell(FileStream fis)
{
try
{
if(fis.CanSeek == true)
{
return (fis.Position);
}
}
catch(Exception e)
{
Console.Error.WriteLine(e.Message);
}
return 0;
}
// inspects the OggVorbis file and finds/documents all the logical
// bitstreams contained in it. Tries to be tolerant of logical
// bitstream sections that are truncated/woogie.
//
// return: -1) error
// 0) OK
int open(FileStream iis, byte[] initial, int ibytes)
{
return open_callbacks(iis, initial, ibytes);
}
int open_callbacks(FileStream iis, byte[] initial, int ibytes)
{
int ret;
datasource=iis;
//callbacks = _callbacks;
// init the framing state
oy.init();
// perhaps some data was previously read into a buffer for testing
// against other stream types. Allow initialization from this
// previously read data (as we may be reading from a non-seekable
// stream)
if(initial!=null)
{
int index=oy.buffer(ibytes);
Array.Copy(initial, 0, oy.data, index, ibytes);
oy.wrote(ibytes);
}
// can we seek? Stevens suggests the seek test was portable
if(iis.CanSeek == true){ ret=open_seekable(); }
else{ ret=open_nonseekable(); }
if(ret!=0)
{
datasource=null;
clear();
}
return(ret);
}
// How many logical bitstreams in this physical bitstream?
public int streams()
{
return links;
}
// Is the FILE * associated with vf seekable?
public bool seekable()
{
return skable;
}
// returns the bitrate for a given logical bitstream or the entire
// physical bitstream. If the file is open for random access, it will
// find the *actual* average bitrate. If the file is streaming, it
// returns the nominal bitrate (if set) else the average of the
// upper/lower bounds (if set) else -1 (unset).
//
// If you want the actual bitrate field settings, get them from the
// vorbis_info structs
public int bitrate(int i)
{
if(i>=links)return(-1);
if(!skable && i!=0)return(bitrate(0));
if(i<0)
{
long bits=0;
for(int j=0;j<links;j++)
{
bits+=(offsets[j+1]-dataoffsets[j])*8;
}
return((int)Math.Round(bits/time_total(-1)));
}
else
{
if(skable)
{
// return the actual bitrate
return((int)Math.Round((offsets[i+1]-dataoffsets[i])*8/time_total(i)));
}
else
{
// return nominal if set
if(vi[i].bitrate_nominal>0)
{
return vi[i].bitrate_nominal;
}
else
{
if(vi[i].bitrate_upper>0)
{
if(vi[i].bitrate_lower>0)
{
return (vi[i].bitrate_upper+vi[i].bitrate_lower)/2;
}
else
{
return vi[i].bitrate_upper;
}
}
return(-1);
}
}
}
}
// returns the actual bitrate since last call. returns -1 if no
// additional data to offer since last call (or at beginning of stream)
public int bitrate_instant()
{
int _link=(skable?current_link:0);
if(samptrack==0)return(-1);
int ret=(int)(bittrack/samptrack*vi[_link].rate+.5);
bittrack=0.0f;
samptrack=0.0f;
return(ret);
}
public int serialnumber(int i)
{
if(i>=links)return(-1);
if(!skable && i>=0)return(serialnumber(-1));
if(i<0)
{
return(current_serialno);
}
else
{
return(serialnos[i]);
}
}
// returns: total raw (compressed) length of content if i==-1
// raw (compressed) length of that logical bitstream for i==0 to n
// -1 if the stream is not seekable (we can't know the length)
public long raw_total(int i)
{
if(!skable || i>=links)return(-1);
if(i<0)
{
long acc=0; // bug?
for(int j=0;j<links;j++)
{
acc+=raw_total(j);
}
return(acc);
}
else
{
return(offsets[i+1]-offsets[i]);
}
}
// returns: total PCM length (samples) of content if i==-1
// PCM length (samples) of that logical bitstream for i==0 to n
// -1 if the stream is not seekable (we can't know the length)
public long pcm_total(int i)
{
if(!skable || i>=links)return(-1);
if(i<0)
{
long acc=0;
for(int j=0;j<links;j++)
{
acc+=pcm_total(j);
}
return(acc);
}
else
{
return(pcmlengths[i]);
}
}
// returns: total seconds of content if i==-1
// seconds in that logical bitstream for i==0 to n
// -1 if the stream is not seekable (we can't know the length)
public float time_total(int i)
{
if(!skable || i>=links)return(-1);
if(i<0)
{
float acc=0;
for(int j=0;j<links;j++)
{
acc+=time_total(j);
}
return(acc);
}
else
{
return((float)(pcmlengths[i])/vi[i].rate);
}
}
// seek to an offset relative to the *compressed* data. This also
// immediately sucks in and decodes pages to update the PCM cursor. It
// will cross a logical bitstream boundary, but only if it can't get
// any packets out of the tail of the bitstream we seek to (so no
// surprises).
//
// returns zero on success, nonzero on failure
public int raw_seek(int pos)
{
if(!skable)return(-1); // don't dump machine if we can't seek
if(pos<0 || pos>offsets[links])
{
//goto seek_error;
pcm_offset=-1;
decode_clear();
return -1;
}
// clear out decoding machine state
pcm_offset=-1;
decode_clear();
// seek
seek_helper(pos);
// we need to make sure the pcm_offset is set. We use the
// _fetch_packet helper to process one packet with readp set, then
// call it until it returns '0' with readp not set (the last packet
// from a page has the 'granulepos' field set, and that's how the
// helper updates the offset
switch(process_packet(1))
{
case 0:
// oh, eof. There are no packets remaining. Set the pcm offset to
// the end of file
pcm_offset=pcm_total(-1);
return(0);
case -1:
// error! missing data or invalid bitstream structure
//goto seek_error;
pcm_offset=-1;
decode_clear();
return -1;
default:
// all OK
break;
}
while(true)
{
switch(process_packet(0))
{
case 0:
// the offset is set. If it's a bogus bitstream with no offset
// information, it's not but that's not our fault. We still run
// gracefully, we're just missing the offset
return(0);
case -1:
// error! missing data or invalid bitstream structure
//goto seek_error;
pcm_offset=-1;
decode_clear();
return -1;
default:
// continue processing packets
break;
}
}
// seek_error:
// dump the machine so we're in a known state
//pcm_offset=-1;
//decode_clear();
return -1;
}
// seek to a sample offset relative to the decompressed pcm stream
// returns zero on success, nonzero on failure
public int pcm_seek(long pos)
{
int link=-1;
long total=pcm_total(-1);
if(!skable)return(-1); // don't dump machine if we can't seek
if(pos<0 || pos>total)
{
//goto seek_error;
pcm_offset=-1;
decode_clear();
return -1;
}
// which bitstream section does this pcm offset occur in?
for(link=links-1;link>=0;link--)
{
total-=pcmlengths[link];
if(pos>=total)break;
}
// search within the logical bitstream for the page with the highest
// pcm_pos preceeding (or equal to) pos. There is a danger here;
// missing pages or incorrect frame number information in the
// bitstream could make our task impossible. Account for that (it
// would be an error condition)
{
long target=pos-total;
long end=offsets[link+1];
long begin=offsets[link];
int best=(int)begin;
Page og=new Page();
while(begin<end)
{
long bisect;
int ret;
if(end-begin<CHUNKSIZE)
{
bisect=begin;
}
else
{
bisect=(end+begin)/2;
}
seek_helper(bisect);
ret=get_next_page(og,end-bisect);
if(ret==-1)
{
end=bisect;
}
else
{
long granulepos=og.granulepos();
if(granulepos<target)
{
best=ret; // raw offset of packet with granulepos
begin=offset; // raw offset of next packet
}
else
{
end=bisect;
}
}
}
// found our page. seek to it (call raw_seek).
if(raw_seek(best)!=0)
{
//goto seek_error;
pcm_offset=-1;
decode_clear();
return -1;
}
}
// verify result
if(pcm_offset>=pos)
{
//goto seek_error;
pcm_offset=-1;
decode_clear();
return -1;
}
if(pos>pcm_total(-1))
{
//goto seek_error;
pcm_offset=-1;
decode_clear();
return -1;
}
// discard samples until we reach the desired position. Crossing a
// logical bitstream boundary with abandon is OK.
while(pcm_offset<pos)
{
float[][] pcm;
int target=(int)(pos-pcm_offset);
float[][][] _pcm=new float[1][][];
int[] _index=new int[getInfo(-1).channels];
int samples=vd.synthesis_pcmout(_pcm, _index);
pcm=_pcm[0];
if(samples>target)samples=target;
vd.synthesis_read(samples);
pcm_offset+=samples;
if(samples<target)
if(process_packet(1)==0)
{
pcm_offset=pcm_total(-1); // eof
}
}
return 0;
// seek_error:
// dump machine so we're in a known state
//pcm_offset=-1;
//decode_clear();
//return -1;
}
// seek to a playback time relative to the decompressed pcm stream
// returns zero on success, nonzero on failure
public int time_seek(float seconds)
{
// translate time to PCM position and call pcm_seek
int link=-1;
long pcm_tot=pcm_total(-1);
float time_tot=time_total(-1);
if(!skable)return(-1); // don't dump machine if we can't seek
if(seconds<0 || seconds>time_tot)
{
//goto seek_error;
pcm_offset=-1;
decode_clear();
return -1;
}
// which bitstream section does this time offset occur in?
for(link=links-1;link>=0;link--)
{
pcm_tot-=pcmlengths[link];
time_tot-=time_total(link);
if(seconds>=time_tot)break;
}
// enough information to convert time offset to pcm offset
{
long target=(long)(pcm_tot+(seconds-time_tot)*vi[link].rate);
return(pcm_seek(target));
}
}
// tell the current stream offset cursor. Note that seek followed by
// tell will likely not give the set offset due to caching
public long raw_tell()
{
return(offset);
}
// return PCM offset (sample) of next PCM sample to be read
public long pcm_tell()
{
return(pcm_offset);
}
// return time offset (seconds) of next PCM sample to be read
public float time_tell()
{
// translate time to PCM position and call pcm_seek
int link=-1;
long pcm_tot=0;
float time_tot=0.0f;
if(skable)
{
pcm_tot=pcm_total(-1);
time_tot=time_total(-1);
// which bitstream section does this time offset occur in?
for(link=links-1;link>=0;link--)
{
pcm_tot-=pcmlengths[link];
time_tot-=time_total(link);
if(pcm_offset>=pcm_tot)break;
}
}
return((float)time_tot+(float)(pcm_offset-pcm_tot)/vi[link].rate);
}
// link: -1) return the vorbis_info struct for the bitstream section
// currently being decoded
// 0-n) to request information for a specific bitstream section
//
// In the case of a non-seekable bitstream, any call returns the
// current bitstream. NULL in the case that the machine is not
// initialized
public Info getInfo(int link)
{
if(skable)
{
if(link<0)
{
if(decode_ready)
{
return vi[current_link];
}
else
{
return null;
}
}
else
{
if(link>=links)
{
return null;
}
else
{
return vi[link];
}
}
}
else
{
if(decode_ready)
{
return vi[0];
}
else
{
return null;
}
}
}
public Comment getComment(int link)
{
if(skable)
{
if(link<0)
{
if(decode_ready){ return vc[current_link]; }
else{ return null; }
}
else
{
if(link>=links){ return null;}
else{ return vc[link]; }
}
}
else
{
if(decode_ready){ return vc[0]; }
else{ return null; }
}
}
int host_is_big_endian()
{
return 0;
//the above isn't really right...
}
// up to this point, everything could more or less hide the multiple
// logical bitstream nature of chaining from the toplevel application
// if the toplevel application didn't particularly care. However, at
// the point that we actually read audio back, the multiple-section
// nature must surface: Multiple bitstream sections do not necessarily
// have to have the same number of channels or sampling rate.
//
// read returns the sequential logical bitstream number currently
// being decoded along with the PCM data in order that the toplevel
// application can take action on channel/sample rate changes. This
// number will be incremented even for streamed (non-seekable) streams
// (for seekable streams, it represents the actual logical bitstream
// index within the physical bitstream. Note that the accessor
// functions above are aware of this dichotomy).
//
// input values: buffer) a buffer to hold packed PCM data for return
// length) the byte length requested to be placed into buffer
// bigendianp) should the data be packed LSB first (0) or
// MSB first (1)
// word) word size for output. currently 1 (byte) or
// 2 (16 bit short)
//
// return values: -1) error/hole in data
// 0) EOF
// n) number of bytes of PCM actually returned. The
// below works on a packet-by-packet basis, so the
// return length is not related to the 'length' passed
// in, just guaranteed to fit.
//
// *section) set to the logical bitstream number
public int read(byte[] buffer,int length,
int bigendianp, int word, int sgned, int[] bitstream)
{
int host_endian = host_is_big_endian();
int index=0;
while(true)
{
if(decode_ready)
{
float[][] pcm;
float[][][] _pcm=new float[1][][];
int[] _index=new int[getInfo(-1).channels];
int samples=vd.synthesis_pcmout(_pcm, _index);
pcm=_pcm[0];
if(samples!=0)
{
// yay! proceed to pack data into the byte buffer
int channels=getInfo(-1).channels;
int bytespersample=word * channels;
if(samples>length/bytespersample)samples=length/bytespersample;
// a tight loop to pack each size
{
int val;
if(word==1)
{
int off=(sgned!=0?0:128);
for(int j=0;j<samples;j++)
{
for(int i=0;i<channels;i++)
{
val=(int)(pcm[i][_index[i]+j]*128.0 + 0.5);
if(val>127)val=127;
else if(val<-128)val=-128;
buffer[index++]=(byte)(val+off);
}
}
}
else
{
int off=(sgned!=0?0:32768);
if(host_endian==bigendianp)
{
if(sgned!=0)
{
for(int i=0;i<channels;i++)
{ // It's faster in this order
int src=_index[i];
int dest=i*2;
for(int j=0;j<samples;j++)
{
val=(int)(pcm[i][src+j]*32767.0);
if(val>32767)val=32767;
else if(val<-32768)val=-32768;
buffer[dest]=(byte)(val);
buffer[dest+1]=(byte)((uint)val >> 8);
dest+=bytespersample;
}
}
}
else
{
for(int i=0;i<channels;i++)
{
float[] src=pcm[i];
int dest=i;
for(int j=0;j<samples;j++)
{
val=(int)(src[j]*32768.0 + 0.5);
if(val>32767)val=32767;
else if(val<-32768)val=-32768;
buffer[dest]=(byte)((uint)(val+off) >> 8);
buffer[dest+1]=(byte)(val+off);
dest+=channels*2;
}
}
}
}
else if(bigendianp!=0)
{
for(int j=0;j<samples;j++)
{
for(int i=0;i<channels;i++)
{
val=(int)(pcm[i][j]*32768.0 + 0.5);
if(val>32767)val=32767;
else if(val<-32768)val=-32768;
val+=off;
buffer[index++]=(byte)((uint)val >> 8);
buffer[index++]=(byte)val;
}
}
}
else
{
//int val;
for(int j=0;j<samples;j++)
{
for(int i=0;i<channels;i++)
{
val=(int)(pcm[i][j]*32768.0 + 0.5);
if(val>32767)val=32767;
else if(val<-32768)val=-32768;
val+=off;
buffer[index++]=(byte)val;
buffer[index++]=(byte)((uint)val >> 8);
}
}
}
}
}
vd.synthesis_read(samples);
pcm_offset+=samples;
if(bitstream!=null)bitstream[0]=current_link;
return(samples*bytespersample);
}
}
// suck in another packet
switch(process_packet(1))
{
case 0:
return(0);
case -1:
return -1;
default:
break;
}
}
return -1;
}
public Info[] getInfo(){return vi;}
public Comment[] getComment(){return vc;}
}
}