Nyaaori/rockbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
rockbox/songdbj/com/jcraft/jorbis/DspState.java
Michiel Van Der Kolk 9fee0ec4ca Songdb java version, source. only 1.5 compatible 
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@7101 a1c6a512-1295-4272-9138-f99709370657
2005-07-11 15:42:37 +00:00

459 lines
12 KiB
Java
Raw Blame History

/* 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;
public class DspState{
static final float M_PI=3.1415926539f;
static final int VI_TRANSFORMB=1;
static final int VI_WINDOWB=1;
int analysisp;
Info vi;
int modebits;
float[][] pcm;
//float[][] pcmret;
int pcm_storage;
int pcm_current;
int pcm_returned;
float[] multipliers;
int envelope_storage;
int envelope_current;
int eofflag;
int lW;
int W;
int nW;
int centerW;
long granulepos;
long sequence;
long glue_bits;
long time_bits;
long floor_bits;
long res_bits;
// local lookup storage
//!! Envelope ve=new Envelope(); // envelope
//float **window[2][2][2]; // block, leadin, leadout, type
float[][][][][] window; // block, leadin, leadout, type
//vorbis_look_transform **transform[2]; // block, type
Object[][] transform;
CodeBook[] fullbooks;
// backend lookups are tied to the mode, not the backend or naked mapping
Object[] mode;
// local storage, only used on the encoding side. This way the
// application does not need to worry about freeing some packets'
// memory and not others'; packet storage is always tracked.
// Cleared next call to a _dsp_ function
byte[] header;
byte[] header1;
byte[] header2;
public DspState(){
transform=new Object[2][];
window=new float[2][][][][];
window[0]=new float[2][][][];
window[0][0]=new float[2][][];
window[0][1]=new float[2][][];
window[0][0][0]=new float[2][];
window[0][0][1]=new float[2][];
window[0][1][0]=new float[2][];
window[0][1][1]=new float[2][];
window[1]=new float[2][][][];
window[1][0]=new float[2][][];
window[1][1]=new float[2][][];
window[1][0][0]=new float[2][];
window[1][0][1]=new float[2][];
window[1][1][0]=new float[2][];
window[1][1][1]=new float[2][];
}
private static int ilog2(int v){
int ret=0;
while(v>1){
ret++;
v>>>=1;
}
return(ret);
}
static float[] window(int type, int window, int left, int right){
float[] ret=new float[window];
switch(type){
case 0:
// The 'vorbis window' (window 0) is sin(sin(x)*sin(x)*2pi)
{
int leftbegin=window/4-left/2;
int rightbegin=window-window/4-right/2;
for(int i=0;i<left;i++){
float x=(float)((i+.5)/left*M_PI/2.);
x=(float)Math.sin(x);
x*=x;
x*=M_PI/2.;
x=(float)Math.sin(x);
ret[i+leftbegin]=x;
}
for(int i=leftbegin+left;i<rightbegin;i++){
ret[i]=1.f;
}
for(int i=0;i<right;i++){
float x=(float)((right-i-.5)/right*M_PI/2.);
x=(float)Math.sin(x);
x*=x;
x*=M_PI/2.;
x=(float)Math.sin(x);
ret[i+rightbegin]=x;
}
}
break;
default:
//free(ret);
return(null);
}
return(ret);
}
// Analysis side code, but directly related to blocking. Thus it's
// here and not in analysis.c (which is for analysis transforms only).
// The init is here because some of it is shared
int init(Info vi, boolean encp){
//System.err.println("DspState.init: vi="+vi+", encp="+encp);
//memset(v,0,sizeof(vorbis_dsp_state));
this.vi=vi;
modebits=ilog2(vi.modes);
transform[0]=new Object[VI_TRANSFORMB];
transform[1]=new Object[VI_TRANSFORMB];
// MDCT is tranform 0
transform[0][0]=new Mdct();
transform[1][0]=new Mdct();
((Mdct)transform[0][0]).init(vi.blocksizes[0]);
((Mdct)transform[1][0]).init(vi.blocksizes[1]);
window[0][0][0]=new float[VI_WINDOWB][];
window[0][0][1]=window[0][0][0];
window[0][1][0]=window[0][0][0];
window[0][1][1]=window[0][0][0];
window[1][0][0]=new float[VI_WINDOWB][];
window[1][0][1]=new float[VI_WINDOWB][];
window[1][1][0]=new float[VI_WINDOWB][];
window[1][1][1]=new float[VI_WINDOWB][];
for(int i=0;i<VI_WINDOWB;i++){
window[0][0][0][i]=
window(i,vi.blocksizes[0],vi.blocksizes[0]/2,vi.blocksizes[0]/2);
window[1][0][0][i]=
window(i,vi.blocksizes[1],vi.blocksizes[0]/2,vi.blocksizes[0]/2);
window[1][0][1][i]=
window(i,vi.blocksizes[1],vi.blocksizes[0]/2,vi.blocksizes[1]/2);
window[1][1][0][i]=
window(i,vi.blocksizes[1],vi.blocksizes[1]/2,vi.blocksizes[0]/2);
window[1][1][1][i]=
window(i,vi.blocksizes[1],vi.blocksizes[1]/2,vi.blocksizes[1]/2);
}
// if(encp){ // encode/decode differ here
// // finish the codebooks
// fullbooks=new CodeBook[vi.books];
// for(int i=0;i<vi.books;i++){
// fullbooks[i]=new CodeBook();
// fullbooks[i].init_encode(vi.book_param[i]);
// }
// analysisp=1;
// }
// else{
// finish the codebooks
fullbooks=new CodeBook[vi.books];
for(int i=0;i<vi.books;i++){
fullbooks[i]=new CodeBook();
fullbooks[i].init_decode(vi.book_param[i]);
}
// }
// initialize the storage vectors to a decent size greater than the
// minimum
pcm_storage=8192; // we'll assume later that we have
// a minimum of twice the blocksize of
// accumulated samples in analysis
pcm=new float[vi.channels][];
//pcmret=new float[vi.channels][];
{
for(int i=0;i<vi.channels;i++){
pcm[i]=new float[pcm_storage];
}
}
// all 1 (large block) or 0 (small block)
// explicitly set for the sake of clarity
lW=0; // previous window size
W=0; // current window size
// all vector indexes; multiples of samples_per_envelope_step
centerW=vi.blocksizes[1]/2;
pcm_current=centerW;
// initialize all the mapping/backend lookups
mode=new Object[vi.modes];
for(int i=0;i<vi.modes;i++){
int mapnum=vi.mode_param[i].mapping;
int maptype=vi.map_type[mapnum];
mode[i]=FuncMapping.mapping_P[maptype].look(this,vi.mode_param[i],
vi.map_param[mapnum]);
}
return(0);
}
public int synthesis_init(Info vi){
init(vi, false);
// Adjust centerW to allow an easier mechanism for determining output
pcm_returned=centerW;
centerW-= vi.blocksizes[W]/4+vi.blocksizes[lW]/4;
granulepos=-1;
sequence=-1;
return(0);
}
DspState(Info vi){
this();
init(vi, false);
// Adjust centerW to allow an easier mechanism for determining output
pcm_returned=centerW;
centerW-= vi.blocksizes[W]/4+vi.blocksizes[lW]/4;
granulepos=-1;
sequence=-1;
}
// Unike in analysis, the window is only partially applied for each
// block. The time domain envelope is not yet handled at the point of
// calling (as it relies on the previous block).
public int synthesis_blockin(Block vb){
// Shift out any PCM/multipliers that we returned previously
// centerW is currently the center of the last block added
if(centerW>vi.blocksizes[1]/2 && pcm_returned>8192){
// don't shift too much; we need to have a minimum PCM buffer of
// 1/2 long block
int shiftPCM=centerW-vi.blocksizes[1]/2;
shiftPCM=(pcm_returned<shiftPCM?pcm_returned:shiftPCM);
pcm_current-=shiftPCM;
centerW-=shiftPCM;
pcm_returned-=shiftPCM;
if(shiftPCM!=0){
for(int i=0;i<vi.channels;i++){
System.arraycopy(pcm[i], shiftPCM, pcm[i], 0, pcm_current);
}
}
}
lW=W;
W=vb.W;
nW=-1;
glue_bits+=vb.glue_bits;
time_bits+=vb.time_bits;
floor_bits+=vb.floor_bits;
res_bits+=vb.res_bits;
if(sequence+1 != vb.sequence)granulepos=-1; // out of sequence; lose count
sequence=vb.sequence;
{
int sizeW=vi.blocksizes[W];
int _centerW=centerW+vi.blocksizes[lW]/4+sizeW/4;
int beginW=_centerW-sizeW/2;
int endW=beginW+sizeW;
int beginSl=0;
int endSl=0;
// Do we have enough PCM/mult storage for the block?
if(endW>pcm_storage){
// expand the storage
pcm_storage=endW+vi.blocksizes[1];
for(int i=0;i<vi.channels;i++){
float[] foo=new float[pcm_storage];
System.arraycopy(pcm[i], 0, foo, 0, pcm[i].length);
pcm[i]=foo;
}
}
// overlap/add PCM
switch(W){
case 0:
beginSl=0;
endSl=vi.blocksizes[0]/2;
break;
case 1:
beginSl=vi.blocksizes[1]/4-vi.blocksizes[lW]/4;
endSl=beginSl+vi.blocksizes[lW]/2;
break;
}
for(int j=0;j<vi.channels;j++){
int _pcm=beginW;
// the overlap/add section
int i=0;
for(i=beginSl;i<endSl;i++){
pcm[j][_pcm+i]+=vb.pcm[j][i];
}
// the remaining section
for(;i<sizeW;i++){
pcm[j][_pcm+i]=vb.pcm[j][i];
}
}
// track the frame number... This is for convenience, but also
// making sure our last packet doesn't end with added padding. If
// the last packet is partial, the number of samples we'll have to
// return will be past the vb->granulepos.
//
// This is not foolproof! It will be confused if we begin
// decoding at the last page after a seek or hole. In that case,
// we don't have a starting point to judge where the last frame
// is. For this reason, vorbisfile will always try to make sure
// it reads the last two marked pages in proper sequence
if(granulepos==-1){
granulepos=vb.granulepos;
}
else{
granulepos+=(_centerW-centerW);
if(vb.granulepos!=-1 && granulepos!=vb.granulepos){
if(granulepos>vb.granulepos && vb.eofflag!=0){
// partial last frame. Strip the padding off
_centerW-=(granulepos-vb.granulepos);
}// else{ Shouldn't happen *unless* the bitstream is out of
// spec. Either way, believe the bitstream }
granulepos=vb.granulepos;
}
}
// Update, cleanup
centerW=_centerW;
pcm_current=endW;
if(vb.eofflag!=0)eofflag=1;
}
return(0);
}
// pcm==NULL indicates we just want the pending samples, no more
public int synthesis_pcmout(float[][][] _pcm, int[] index){
if(pcm_returned<centerW){
if(_pcm!=null){
for(int i=0;i<vi.channels;i++){
// pcmret[i]=pcm[i]+v.pcm_returned;
//!!!!!!!!
index[i]=pcm_returned;
}
_pcm[0]=pcm;
}
return(centerW-pcm_returned);
}
return(0);
}
public int synthesis_read(int bytes){
if(bytes!=0 && pcm_returned+bytes>centerW)return(-1);
pcm_returned+=bytes;
return(0);
}
public void clear(){
/*
if(window[0][0][0]!=0){
for(i=0;i<VI_WINDOWB;i++)
if(v->window[0][0][0][i])free(v->window[0][0][0][i]);
free(v->window[0][0][0]);
for(j=0;j<2;j++)
for(k=0;k<2;k++){
for(i=0;i<VI_WINDOWB;i++)
if(v->window[1][j][k][i])free(v->window[1][j][k][i]);
free(v->window[1][j][k]);
}
}
if(v->pcm){
for(i=0;i<vi->channels;i++)
if(v->pcm[i])free(v->pcm[i]);
free(v->pcm);
if(v->pcmret)free(v->pcmret);
}
if(v->multipliers)free(v->multipliers);
_ve_envelope_clear(&v->ve);
if(v->transform[0]){
mdct_clear(v->transform[0][0]);
free(v->transform[0][0]);
free(v->transform[0]);
}
if(v->transform[1]){
mdct_clear(v->transform[1][0]);
free(v->transform[1][0]);
free(v->transform[1]);
}
// free mode lookups; these are actually vorbis_look_mapping structs
if(vi){
for(i=0;i<vi->modes;i++){
int mapnum=vi->mode_param[i]->mapping;
int maptype=vi->map_type[mapnum];
_mapping_P[maptype]->free_look(v->mode[i]);
}
// free codebooks
for(i=0;i<vi->books;i++)
vorbis_book_clear(v->fullbooks+i);
}
if(v->mode)free(v->mode);
if(v->fullbooks)free(v->fullbooks);
// free header, header1, header2
if(v->header)free(v->header);
if(v->header1)free(v->header1);
if(v->header2)free(v->header2);
memset(v,0,sizeof(vorbis_dsp_state));
}
*/
}
}
Reference in a new issue View git blame Copy permalink