445 lines
11 KiB
C#
445 lines
11 KiB
C#
|
/* 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 csogg;
|
||
|
|
using csvorbis;
|
||
|
|
|
||
|
|
namespace csvorbis
|
||
|
|
{
|
||
|
|
public class DspState
|
||
|
|
{
|
||
|
|
static float M_PI=3.1415926539f;
|
||
|
|
static int VI_TRANSFORMB=1;
|
||
|
|
static int VI_WINDOWB=1;
|
||
|
|
|
||
|
|
internal int analysisp;
|
||
|
|
internal Info vi;
|
||
|
|
internal 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;
|
||
|
|
public 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
|
||
|
|
internal float[][][][][] wnd; // block, leadin, leadout, type
|
||
|
|
//vorbis_look_transform **transform[2]; // block, type
|
||
|
|
internal Object[][] transform;
|
||
|
|
internal CodeBook[] fullbooks;
|
||
|
|
// backend lookups are tied to the mode, not the backend or naked mapping
|
||
|
|
internal 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][];
|
||
|
|
wnd=new float[2][][][][];
|
||
|
|
wnd[0]=new float[2][][][];
|
||
|
|
wnd[0][0]=new float[2][][];
|
||
|
|
wnd[0][1]=new float[2][][];
|
||
|
|
wnd[0][0][0]=new float[2][];
|
||
|
|
wnd[0][0][1]=new float[2][];
|
||
|
|
wnd[0][1][0]=new float[2][];
|
||
|
|
wnd[0][1][1]=new float[2][];
|
||
|
|
wnd[1]=new float[2][][][];
|
||
|
|
wnd[1][0]=new float[2][][];
|
||
|
|
wnd[1][1]=new float[2][][];
|
||
|
|
wnd[1][0][0]=new float[2][];
|
||
|
|
wnd[1][0][1]=new float[2][];
|
||
|
|
wnd[1][1][0]=new float[2][];
|
||
|
|
wnd[1][1][1]=new float[2][];
|
||
|
|
}
|
||
|
|
|
||
|
|
private static int ilog2(int v)
|
||
|
|
{
|
||
|
|
int ret=0;
|
||
|
|
while(v>1)
|
||
|
|
{
|
||
|
|
ret++;
|
||
|
|
v = (int)((uint)v >> 1);
|
||
|
|
}
|
||
|
|
return(ret);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static float[] window(int type, int wnd, int left, int right)
|
||
|
|
{
|
||
|
|
float[] ret=new float[wnd];
|
||
|
|
switch(type)
|
||
|
|
{
|
||
|
|
case 0:
|
||
|
|
// The 'vorbis window' (window 0) is sin(sin(x)*sin(x)*2pi)
|
||
|
|
{
|
||
|
|
int leftbegin=wnd/4-left/2;
|
||
|
|
int rightbegin=wnd-wnd/4-right/2;
|
||
|
|
|
||
|
|
for(int i=0;i<left;i++)
|
||
|
|
{
|
||
|
|
float x=(float)((i+.5)/left*M_PI/2.0);
|
||
|
|
x=(float)Math.Sin(x);
|
||
|
|
x*=x;
|
||
|
|
x*=(float)(M_PI/2.0);
|
||
|
|
x=(float)Math.Sin(x);
|
||
|
|
ret[i+leftbegin]=x;
|
||
|
|
}
|
||
|
|
|
||
|
|
for(int i=leftbegin+left;i<rightbegin;i++)
|
||
|
|
{
|
||
|
|
ret[i]=1.0f;
|
||
|
|
}
|
||
|
|
|
||
|
|
for(int i=0;i<right;i++)
|
||
|
|
{
|
||
|
|
float x=(float)((right-i-.5)/right*M_PI/2.0);
|
||
|
|
x=(float)Math.Sin(x);
|
||
|
|
x*=x;
|
||
|
|
x*=(float)(M_PI/2.0);
|
||
|
|
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, bool 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]);
|
||
|
|
|
||
|
|
wnd[0][0][0]=new float[VI_WINDOWB][];
|
||
|
|
wnd[0][0][1]=wnd[0][0][0];
|
||
|
|
wnd[0][1][0]=wnd[0][0][0];
|
||
|
|
wnd[0][1][1]=wnd[0][0][0];
|
||
|
|
wnd[1][0][0]=new float[VI_WINDOWB][];
|
||
|
|
wnd[1][0][1]=new float[VI_WINDOWB][];
|
||
|
|
wnd[1][1][0]=new float[VI_WINDOWB][];
|
||
|
|
wnd[1][1][1]=new float[VI_WINDOWB][];
|
||
|
|
|
||
|
|
for(int i=0;i<VI_WINDOWB;i++)
|
||
|
|
{
|
||
|
|
wnd[0][0][0][i]=
|
||
|
|
window(i,vi.blocksizes[0],vi.blocksizes[0]/2,vi.blocksizes[0]/2);
|
||
|
|
wnd[1][0][0][i]=
|
||
|
|
window(i,vi.blocksizes[1],vi.blocksizes[0]/2,vi.blocksizes[0]/2);
|
||
|
|
wnd[1][0][1][i]=
|
||
|
|
window(i,vi.blocksizes[1],vi.blocksizes[0]/2,vi.blocksizes[1]/2);
|
||
|
|
wnd[1][1][0][i]=
|
||
|
|
window(i,vi.blocksizes[1],vi.blocksizes[1]/2,vi.blocksizes[0]/2);
|
||
|
|
wnd[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++)
|
||
|
|
{
|
||
|
|
Array.Copy(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];
|
||
|
|
Array.Copy(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 = _centerW - (int)(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()
|
||
|
|
{
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|