1241 lines
33 KiB
Text
1241 lines
33 KiB
Text
|
/* JOrbis
|
||
|
|
* Copyright (C) 2000 ymnk, JCraft,Inc.
|
||
|
|
*
|
||
|
|
* Written by: 2000 ymnk<ymnk@jcraft.com>
|
||
|
|
*
|
||
|
|
* Many thanks to
|
||
|
|
* Monty <monty@xiph.org> and
|
||
|
|
* The XIPHOPHORUS Company http://www.xiph.org/ .
|
||
|
|
* JOrbis has been based on their awesome works, Vorbis codec.
|
||
|
|
*
|
||
|
|
* 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.
|
||
|
|
*/
|
||
|
|
|
||
|
|
package com.jcraft.jorbis;
|
||
|
|
|
||
|
|
import com.jcraft.jogg.*;
|
||
|
|
import java.io.InputStream;
|
||
|
|
|
||
|
|
public class VorbisFile{
|
||
|
|
static final int CHUNKSIZE=4096;
|
||
|
|
static final int SEEK_SET=0;
|
||
|
|
|
||
|
|
InputStream datasource;
|
||
|
|
boolean seekable=false;
|
||
|
|
long offset;
|
||
|
|
long end;
|
||
|
|
|
||
|
|
SyncState oy=new SyncState();
|
||
|
|
|
||
|
|
int links;
|
||
|
|
Comment[] vc;
|
||
|
|
Info[] vi;
|
||
|
|
|
||
|
|
long[] offsets;
|
||
|
|
long[] dataoffsets;
|
||
|
|
int[] serialnos;
|
||
|
|
long[] pcmlengths;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
// Decoding working state local storage
|
||
|
|
long pcm_offset;
|
||
|
|
boolean decode_ready=false;
|
||
|
|
int current_serialno;
|
||
|
|
int current_link;
|
||
|
|
|
||
|
|
float bittrack;
|
||
|
|
float samptrack;
|
||
|
|
|
||
|
|
StreamState os=new StreamState(); // take physical pages, weld into a logical
|
||
|
|
// stream of packets
|
||
|
|
DspState vd=new DspState(); // central working state for
|
||
|
|
// the packet->PCM decoder
|
||
|
|
Block vb=new Block(vd); // local working space for packet->PCM decode
|
||
|
|
|
||
|
|
//ov_callbacks callbacks;
|
||
|
|
|
||
|
|
public VorbisFile(String file) throws JOrbisException {
|
||
|
|
super();
|
||
|
|
InputStream is=null;
|
||
|
|
try{ is=new java.io.BufferedInputStream(new java.io.FileInputStream(file));}
|
||
|
|
catch(Exception e){
|
||
|
|
throw new JOrbisException("VorbisFile: "+e.toString());
|
||
|
|
}
|
||
|
|
int ret=open(is, null, 0);
|
||
|
|
if(ret==-1){
|
||
|
|
throw new JOrbisException("VorbisFile: open return -1");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public VorbisFile(InputStream is, byte[] initial, int ibytes)
|
||
|
|
throws JOrbisException {
|
||
|
|
super();
|
||
|
|
int ret=open(is, initial, ibytes);
|
||
|
|
if(ret==-1){
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
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){System.err.println(e);}
|
||
|
|
oy.wrote(bytes);
|
||
|
|
return bytes;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void seek_helper(int offst){
|
||
|
|
//callbacks.seek_func(datasource, offst, SEEK_SET);
|
||
|
|
fseek64_wrap(datasource, offst, SEEK_SET);
|
||
|
|
this.offset=offst;
|
||
|
|
oy.reset();
|
||
|
|
}
|
||
|
|
|
||
|
|
private int get_next_page(Page page, int boundary){
|
||
|
|
if(boundary>0) boundary+=offset;
|
||
|
|
while(true){
|
||
|
|
int more;
|
||
|
|
if(boundary>0 && offset>=boundary)return -1;
|
||
|
|
more=oy.pageseek(page);
|
||
|
|
if(more<0){offset-=more;}
|
||
|
|
else{
|
||
|
|
if(more==0){
|
||
|
|
if(boundary==0)return -1;
|
||
|
|
if(get_data()<=0)return -1;
|
||
|
|
}
|
||
|
|
else{
|
||
|
|
int ret=(int)offset; //!!!
|
||
|
|
offset+=more;
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private int get_prev_page(Page page){
|
||
|
|
int begin=(int)offset; //!!!
|
||
|
|
int ret;
|
||
|
|
int offst=-1;
|
||
|
|
while(offst==-1){
|
||
|
|
begin-=CHUNKSIZE;
|
||
|
|
seek_helper(begin);
|
||
|
|
while(offset<begin+CHUNKSIZE){
|
||
|
|
ret=get_next_page(page, begin+CHUNKSIZE-((int)offset));
|
||
|
|
if(ret==-1){ break; }
|
||
|
|
else{ offst=ret; }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
seek_helper((int)offset); //!!!
|
||
|
|
ret=get_next_page(page, CHUNKSIZE);
|
||
|
|
if(ret==-1){
|
||
|
|
System.err.println("Missed page fencepost at end of logical bitstream Exiting");
|
||
|
|
System.exit(1);
|
||
|
|
}
|
||
|
|
return offst;
|
||
|
|
}
|
||
|
|
|
||
|
|
void bisect_forward_serialno(int begin, int searched, int end, int currentno, int m){
|
||
|
|
int endsearched=end;
|
||
|
|
int next=end;
|
||
|
|
Page page=new Page();
|
||
|
|
int ret;
|
||
|
|
while(searched<endsearched){
|
||
|
|
int bisect;
|
||
|
|
if(endsearched-searched<CHUNKSIZE){
|
||
|
|
bisect=searched;
|
||
|
|
}
|
||
|
|
else{
|
||
|
|
bisect=(searched+endsearched)/2;
|
||
|
|
}
|
||
|
|
|
||
|
|
seek_helper(bisect);
|
||
|
|
ret=get_next_page(page, -1);
|
||
|
|
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(searched>=end || ret==-1){
|
||
|
|
links=m+1;
|
||
|
|
offsets=new long[m+2];
|
||
|
|
offsets[m+1]=searched;
|
||
|
|
}
|
||
|
|
else{
|
||
|
|
bisect_forward_serialno(next, (int)offset, end, page.serialno(), m+1);
|
||
|
|
}
|
||
|
|
offsets[m]=begin;
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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){
|
||
|
|
//System.err.println("fetch_headers");
|
||
|
|
Page og=new Page();
|
||
|
|
Packet op=new Packet();
|
||
|
|
int ret;
|
||
|
|
|
||
|
|
ret=get_next_page(og, CHUNKSIZE);
|
||
|
|
if(ret==-1){
|
||
|
|
System.err.println("Did not find initial header for bitstream.");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(serialno!=null)serialno[0]=og.serialno();
|
||
|
|
|
||
|
|
os.init(og.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);
|
||
|
|
while(i<3){
|
||
|
|
int result=os.packetout(op);
|
||
|
|
if(result==0)break;
|
||
|
|
if(result==-1){
|
||
|
|
System.err.println("Corrupt header in logical bitstream.");
|
||
|
|
//goto bail_header;
|
||
|
|
vi.clear();
|
||
|
|
vc.clear();
|
||
|
|
os.clear();
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
if(vi.synthesis_headerin(vc, op)!=0){
|
||
|
|
System.err.println("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, 1)<0){
|
||
|
|
System.err.println("Missing header in logical bitstream.");
|
||
|
|
//goto bail_header;
|
||
|
|
vi.clear();
|
||
|
|
vc.clear();
|
||
|
|
os.clear();
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
// bail_header:
|
||
|
|
// vorbis_info_clear(vi);
|
||
|
|
// vorbis_comment_clear(vc);
|
||
|
|
// ogg_stream_clear(&vf->os);
|
||
|
|
// return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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((int)offsets[i]); //!!!
|
||
|
|
if(fetch_headers(vi[i], vc[i], null)==-1){
|
||
|
|
System.err.println("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
|
||
|
|
{
|
||
|
|
int end=(int)offsets[i+1]; //!!!
|
||
|
|
seek_helper(end);
|
||
|
|
|
||
|
|
while(true){
|
||
|
|
ret=get_prev_page(og);
|
||
|
|
if(ret==-1){
|
||
|
|
// this should not be possible
|
||
|
|
System.err.println("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(decode_ready)System.exit(1);
|
||
|
|
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,end;
|
||
|
|
int ret;
|
||
|
|
int dataoffset;
|
||
|
|
Page og=new Page();
|
||
|
|
System.out.println("open_seekable");
|
||
|
|
// is this even vorbis...?
|
||
|
|
int[] foo=new int[1];
|
||
|
|
ret=fetch_headers(initial_i, initial_c, foo);
|
||
|
|
serialno=foo[0];
|
||
|
|
dataoffset=(int)offset; //!!
|
||
|
|
os.clear();
|
||
|
|
if(ret==-1)return(-1);
|
||
|
|
|
||
|
|
// we can seek, so set out learning all about this file
|
||
|
|
seekable=true;
|
||
|
|
//(callbacks.seek_func)(datasource, 0, SEEK_END);
|
||
|
|
fseek64_wrap(datasource, (int)offset, SEEK_SET);
|
||
|
|
//offset=end=(callbacks.tell_func)(datasource);
|
||
|
|
end=(int)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
|
||
|
|
bisect_forward_serialno(0,0,end+1,serialno,0);
|
||
|
|
}
|
||
|
|
else{
|
||
|
|
// Only one logical bitstream
|
||
|
|
bisect_forward_serialno(0,end,end+1,serialno,0);
|
||
|
|
}
|
||
|
|
prefetch_all_headers(initial_i, initial_c, dataoffset);
|
||
|
|
|
||
|
|
System.out.println("?");
|
||
|
|
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)==-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.f;
|
||
|
|
samptrack=0.f;
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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){
|
||
|
|
System.out.println("porcess_packet:"+ readp+" , decode_ready="+decode_ready);
|
||
|
|
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=(seekable?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(seekable){
|
||
|
|
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];
|
||
|
|
fetch_headers(vi[0], vc[0], foo);
|
||
|
|
current_serialno=foo[0];
|
||
|
|
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 fseek64_wrap(InputStream fis,
|
||
|
|
//int64_t off,
|
||
|
|
int off,
|
||
|
|
int whence){
|
||
|
|
|
||
|
|
if(!fis.markSupported()){ return -1; }
|
||
|
|
try{
|
||
|
|
try{if(whence==0){ fis.reset(); }}
|
||
|
|
catch(Exception ee){System.out.println(ee);}
|
||
|
|
fis.skip(off);
|
||
|
|
}
|
||
|
|
catch(Exception e){ System.out.println(e);
|
||
|
|
//return -1;
|
||
|
|
}
|
||
|
|
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(InputStream is, byte[] initial, int ibytes){
|
||
|
|
return open_callbacks(is, initial, ibytes//, callbacks
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
int open_callbacks(InputStream is, byte[] initial,
|
||
|
|
int ibytes//, callbacks callbacks
|
||
|
|
){
|
||
|
|
// int offset=callbacks.seek_func(f,0,SEEK_CUR);
|
||
|
|
int _offset=fseek64_wrap(is, (int)offset, SEEK_SET);
|
||
|
|
int ret;
|
||
|
|
// memset(vf,0,sizeof(OggVorbis_File));
|
||
|
|
datasource=is;
|
||
|
|
//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);
|
||
|
|
System.arraycopy(initial, 0, oy.data, index, ibytes);
|
||
|
|
oy.wrote(ibytes);
|
||
|
|
}
|
||
|
|
|
||
|
|
System.out.println("open_callbacks="+_offset);
|
||
|
|
// can we seek? Stevens suggests the seek test was portable
|
||
|
|
if(_offset!=-1){ ret=open_seekable(); }
|
||
|
|
else{ ret=open_nonseekable(); }
|
||
|
|
|
||
|
|
System.out.println("ret="+ret);
|
||
|
|
|
||
|
|
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 boolean seekable(){
|
||
|
|
return seekable;
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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(!seekable && 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.rint(bits/time_total(-1)));
|
||
|
|
}
|
||
|
|
else{
|
||
|
|
if(seekable){
|
||
|
|
// return the actual bitrate
|
||
|
|
return((int)Math.rint((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=(seekable?current_link:0);
|
||
|
|
if(samptrack==0)return(-1);
|
||
|
|
int ret=(int)(bittrack/samptrack*vi[_link].rate+.5);
|
||
|
|
bittrack=0.f;
|
||
|
|
samptrack=0.f;
|
||
|
|
return(ret);
|
||
|
|
}
|
||
|
|
|
||
|
|
public int serialnumber(int i){
|
||
|
|
if(i>=links)return(-1);
|
||
|
|
if(!seekable && 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){
|
||
|
|
System.out.println("raw_total: "+seekable);
|
||
|
|
if(!seekable || 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(!seekable || 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(!seekable || 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){
|
||
|
|
System.out.println("raw_seek: "+pos);
|
||
|
|
if(!seekable)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;
|
||
|
|
}
|
||
|
|
System.out.println("#1");
|
||
|
|
// clear out decoding machine state
|
||
|
|
pcm_offset=-1;
|
||
|
|
System.out.println("#2");
|
||
|
|
decode_clear();
|
||
|
|
System.out.println("#3");
|
||
|
|
// 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
|
||
|
|
System.out.println("#4");
|
||
|
|
switch(process_packet(1)){
|
||
|
|
case 0:
|
||
|
|
System.out.println("?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:
|
||
|
|
System.out.println("?-1");
|
||
|
|
// error! missing data or invalid bitstream structure
|
||
|
|
//goto seek_error;
|
||
|
|
pcm_offset=-1;
|
||
|
|
decode_clear();
|
||
|
|
return -1;
|
||
|
|
default:
|
||
|
|
System.out.println("?break");
|
||
|
|
// all OK
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
System.out.println("pcm_offset="+pcm_offset);
|
||
|
|
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(!seekable)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;
|
||
|
|
int end=(int)offsets[link+1];
|
||
|
|
int begin=(int)offsets[link];
|
||
|
|
int best=begin;
|
||
|
|
|
||
|
|
Page og=new Page();
|
||
|
|
while(begin<end){
|
||
|
|
int 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=(int)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[info(-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_total=pcm_total(-1);
|
||
|
|
float time_total=time_total(-1);
|
||
|
|
|
||
|
|
if(!seekable)return(-1); // don't dump machine if we can't seek
|
||
|
|
if(seconds<0 || seconds>time_total){
|
||
|
|
//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_total-=pcmlengths[link];
|
||
|
|
time_total-=time_total(link);
|
||
|
|
if(seconds>=time_total)break;
|
||
|
|
}
|
||
|
|
|
||
|
|
// enough information to convert time offset to pcm offset
|
||
|
|
{
|
||
|
|
long target=(long)(pcm_total+(seconds-time_total)*vi[link].rate);
|
||
|
|
return(pcm_seek(target));
|
||
|
|
}
|
||
|
|
|
||
|
|
//seek_error:
|
||
|
|
// dump machine so we're in a known state
|
||
|
|
//pcm_offset=-1;
|
||
|
|
//decode_clear();
|
||
|
|
//return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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_total=0;
|
||
|
|
float time_total=0.f;
|
||
|
|
|
||
|
|
if(seekable){
|
||
|
|
pcm_total=pcm_total(-1);
|
||
|
|
time_total=time_total(-1);
|
||
|
|
|
||
|
|
// which bitstream section does this time offset occur in?
|
||
|
|
for(link=links-1;link>=0;link--){
|
||
|
|
pcm_total-=pcmlengths[link];
|
||
|
|
time_total-=time_total(link);
|
||
|
|
if(pcm_offset>=pcm_total)break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return((float)time_total+(float)(pcm_offset-pcm_total)/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 info(int link){
|
||
|
|
if(seekable){
|
||
|
|
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 comment(int link){
|
||
|
|
if(seekable){
|
||
|
|
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 1;
|
||
|
|
// short pattern = 0xbabe;
|
||
|
|
// unsigned char *bytewise = (unsigned char *)&pattern;
|
||
|
|
// if (bytewise[0] == 0xba) return 1;
|
||
|
|
// assert(bytewise[0] == 0xbe);
|
||
|
|
// return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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
|
||
|
|
|
||
|
|
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[info(-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=info(-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.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;
|
||
|
|
for(int j=0;j<samples;j++) {
|
||
|
|
val=(int)(pcm[i][src+j]*32768. + 0.5);
|
||
|
|
if(val>32767)val=32767;
|
||
|
|
else if(val<-32768)val=-32768;
|
||
|
|
buffer[dest]=(byte)(val>>>8);
|
||
|
|
buffer[dest+1]=(byte)(val);
|
||
|
|
dest+=channels*2;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
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.5);
|
||
|
|
if(val>32767)val=32767;
|
||
|
|
else if(val<-32768)val=-32768;
|
||
|
|
buffer[dest]=(byte)((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.5);
|
||
|
|
if(val>32767)val=32767;
|
||
|
|
else if(val<-32768)val=-32768;
|
||
|
|
val+=off;
|
||
|
|
buffer[index++]=(byte)(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.5);
|
||
|
|
if(val>32767)val=32767;
|
||
|
|
else if(val<-32768)val=-32768;
|
||
|
|
val+=off;
|
||
|
|
buffer[index++]=(byte)val;
|
||
|
|
buffer[index++]=(byte)(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;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public int getLinks(){return links;}
|
||
|
|
public Info[] getInfo(){return vi;}
|
||
|
|
public Comment[] getComment(){return vc;}
|
||
|
|
|
||
|
|
public static void main(String[] arg){
|
||
|
|
try{
|
||
|
|
VorbisFile foo=new VorbisFile(arg[0]);
|
||
|
|
int links=foo.getLinks();
|
||
|
|
System.out.println("links="+links);
|
||
|
|
Comment[] comment=foo.getComment();
|
||
|
|
Info[] info=foo.getInfo();
|
||
|
|
for(int i=0; i<links; i++){
|
||
|
|
System.out.println(info[i]);
|
||
|
|
System.out.println(comment[i]);
|
||
|
|
}
|
||
|
|
System.out.println("raw_total: "+foo.raw_total(-1));
|
||
|
|
System.out.println("pcm_total: "+foo.pcm_total(-1));
|
||
|
|
System.out.println("time_total: "+foo.time_total(-1));
|
||
|
|
}
|
||
|
|
catch(Exception e){
|
||
|
|
System.err.println(e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|