362 lines
9.4 KiB
Java
362 lines
9.4 KiB
Java
|
/* -*-mode:java; c-basic-offset:2; indent-tabs-mode:nil -*- */
|
||
|
|
/* 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.*;
|
||
|
|
|
||
|
|
class Mapping0 extends FuncMapping {
|
||
|
|
static int seq = 0;
|
||
|
|
|
||
|
|
void free_info(Object imap) {
|
||
|
|
};
|
||
|
|
|
||
|
|
void free_look(Object imap) {
|
||
|
|
}
|
||
|
|
|
||
|
|
Object look(DspState vd, InfoMode vm, Object m) {
|
||
|
|
// System.err.println("Mapping0.look");
|
||
|
|
Info vi = vd.vi;
|
||
|
|
LookMapping0 look = new LookMapping0();
|
||
|
|
InfoMapping0 info = look.map = (InfoMapping0) m;
|
||
|
|
look.mode = vm;
|
||
|
|
|
||
|
|
look.time_look = new Object[info.submaps];
|
||
|
|
look.floor_look = new Object[info.submaps];
|
||
|
|
look.residue_look = new Object[info.submaps];
|
||
|
|
|
||
|
|
look.time_func = new FuncTime[info.submaps];
|
||
|
|
look.floor_func = new FuncFloor[info.submaps];
|
||
|
|
look.residue_func = new FuncResidue[info.submaps];
|
||
|
|
|
||
|
|
for (int i = 0; i < info.submaps; i++) {
|
||
|
|
int timenum = info.timesubmap[i];
|
||
|
|
int floornum = info.floorsubmap[i];
|
||
|
|
int resnum = info.residuesubmap[i];
|
||
|
|
|
||
|
|
look.time_func[i] = FuncTime.time_P[vi.time_type[timenum]];
|
||
|
|
look.time_look[i] = look.time_func[i].look(vd, vm, vi.time_param[timenum]);
|
||
|
|
look.floor_func[i] = FuncFloor.floor_P[vi.floor_type[floornum]];
|
||
|
|
look.floor_look[i] = look.floor_func[i].look(vd, vm, vi.floor_param[floornum]);
|
||
|
|
look.residue_func[i] = FuncResidue.residue_P[vi.residue_type[resnum]];
|
||
|
|
look.residue_look[i] = look.residue_func[i].look(vd, vm, vi.residue_param[resnum]);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
if (vi.psys != 0 && vd.analysisp != 0) {
|
||
|
|
// ??
|
||
|
|
}
|
||
|
|
|
||
|
|
look.ch = vi.channels;
|
||
|
|
|
||
|
|
return (look);
|
||
|
|
}
|
||
|
|
|
||
|
|
void pack(Info vi, Object imap, Buffer opb) {
|
||
|
|
InfoMapping0 info = (InfoMapping0) imap;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* another 'we meant to do it this way' hack... up to beta 4, we packed 4 binary
|
||
|
|
* zeros here to signify one submapping in use. We now redefine that to mean
|
||
|
|
* four bitflags that indicate use of deeper features; bit0:submappings,
|
||
|
|
* bit1:coupling, bit2,3:reserved. This is backward compatable with all actual
|
||
|
|
* uses of the beta code.
|
||
|
|
*/
|
||
|
|
|
||
|
|
if (info.submaps > 1) {
|
||
|
|
opb.write(1, 1);
|
||
|
|
opb.write(info.submaps - 1, 4);
|
||
|
|
} else {
|
||
|
|
opb.write(0, 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (info.coupling_steps > 0) {
|
||
|
|
opb.write(1, 1);
|
||
|
|
opb.write(info.coupling_steps - 1, 8);
|
||
|
|
for (int i = 0; i < info.coupling_steps; i++) {
|
||
|
|
opb.write(info.coupling_mag[i], Util.ilog2(vi.channels));
|
||
|
|
opb.write(info.coupling_ang[i], Util.ilog2(vi.channels));
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
opb.write(0, 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
opb.write(0, 2); /* 2,3:reserved */
|
||
|
|
|
||
|
|
/* we don't write the channel submappings if we only have one... */
|
||
|
|
if (info.submaps > 1) {
|
||
|
|
for (int i = 0; i < vi.channels; i++)
|
||
|
|
opb.write(info.chmuxlist[i], 4);
|
||
|
|
}
|
||
|
|
for (int i = 0; i < info.submaps; i++) {
|
||
|
|
opb.write(info.timesubmap[i], 8);
|
||
|
|
opb.write(info.floorsubmap[i], 8);
|
||
|
|
opb.write(info.residuesubmap[i], 8);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// also responsible for range checking
|
||
|
|
Object unpack(Info vi, Buffer opb) {
|
||
|
|
InfoMapping0 info = new InfoMapping0();
|
||
|
|
|
||
|
|
if (opb.read(1) != 0) {
|
||
|
|
info.submaps = opb.read(4) + 1;
|
||
|
|
} else {
|
||
|
|
info.submaps = 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (opb.read(1) != 0) {
|
||
|
|
info.coupling_steps = opb.read(8) + 1;
|
||
|
|
|
||
|
|
for (int i = 0; i < info.coupling_steps; i++) {
|
||
|
|
int testM = info.coupling_mag[i] = opb.read(Util.ilog2(vi.channels));
|
||
|
|
int testA = info.coupling_ang[i] = opb.read(Util.ilog2(vi.channels));
|
||
|
|
|
||
|
|
if (testM < 0 || testA < 0 || testM == testA || testM >= vi.channels || testA >= vi.channels) {
|
||
|
|
// goto err_out;
|
||
|
|
info.free();
|
||
|
|
return (null);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (opb.read(2) > 0) { /* 2,3:reserved */
|
||
|
|
info.free();
|
||
|
|
return (null);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (info.submaps > 1) {
|
||
|
|
for (int i = 0; i < vi.channels; i++) {
|
||
|
|
info.chmuxlist[i] = opb.read(4);
|
||
|
|
if (info.chmuxlist[i] >= info.submaps) {
|
||
|
|
info.free();
|
||
|
|
return (null);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int i = 0; i < info.submaps; i++) {
|
||
|
|
info.timesubmap[i] = opb.read(8);
|
||
|
|
if (info.timesubmap[i] >= vi.times) {
|
||
|
|
info.free();
|
||
|
|
return (null);
|
||
|
|
}
|
||
|
|
info.floorsubmap[i] = opb.read(8);
|
||
|
|
if (info.floorsubmap[i] >= vi.floors) {
|
||
|
|
info.free();
|
||
|
|
return (null);
|
||
|
|
}
|
||
|
|
info.residuesubmap[i] = opb.read(8);
|
||
|
|
if (info.residuesubmap[i] >= vi.residues) {
|
||
|
|
info.free();
|
||
|
|
return (null);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return info;
|
||
|
|
}
|
||
|
|
|
||
|
|
float[][] pcmbundle = null;
|
||
|
|
int[] zerobundle = null;
|
||
|
|
int[] nonzero = null;
|
||
|
|
Object[] floormemo = null;
|
||
|
|
|
||
|
|
synchronized int inverse(Block vb, Object l) {
|
||
|
|
DspState vd = vb.vd;
|
||
|
|
Info vi = vd.vi;
|
||
|
|
LookMapping0 look = (LookMapping0) l;
|
||
|
|
InfoMapping0 info = look.map;
|
||
|
|
InfoMode mode = look.mode;
|
||
|
|
int n = vb.pcmend = vi.blocksizes[vb.W];
|
||
|
|
|
||
|
|
float[] window = vd.window[vb.W][vb.lW][vb.nW][mode.windowtype];
|
||
|
|
if (pcmbundle == null || pcmbundle.length < vi.channels) {
|
||
|
|
pcmbundle = new float[vi.channels][];
|
||
|
|
nonzero = new int[vi.channels];
|
||
|
|
zerobundle = new int[vi.channels];
|
||
|
|
floormemo = new Object[vi.channels];
|
||
|
|
}
|
||
|
|
|
||
|
|
// time domain information decode (note that applying the
|
||
|
|
// information would have to happen later; we'll probably add a
|
||
|
|
// function entry to the harness for that later
|
||
|
|
// NOT IMPLEMENTED
|
||
|
|
|
||
|
|
// recover the spectral envelope; store it in the PCM vector for now
|
||
|
|
for (int i = 0; i < vi.channels; i++) {
|
||
|
|
float[] pcm = vb.pcm[i];
|
||
|
|
int submap = info.chmuxlist[i];
|
||
|
|
|
||
|
|
floormemo[i] = look.floor_func[submap].inverse1(vb, look.floor_look[submap], floormemo[i]);
|
||
|
|
if (floormemo[i] != null) {
|
||
|
|
nonzero[i] = 1;
|
||
|
|
} else {
|
||
|
|
nonzero[i] = 0;
|
||
|
|
}
|
||
|
|
for (int j = 0; j < n / 2; j++) {
|
||
|
|
pcm[j] = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int i = 0; i < info.coupling_steps; i++) {
|
||
|
|
if (nonzero[info.coupling_mag[i]] != 0 || nonzero[info.coupling_ang[i]] != 0) {
|
||
|
|
nonzero[info.coupling_mag[i]] = 1;
|
||
|
|
nonzero[info.coupling_ang[i]] = 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// recover the residue, apply directly to the spectral envelope
|
||
|
|
|
||
|
|
for (int i = 0; i < info.submaps; i++) {
|
||
|
|
int ch_in_bundle = 0;
|
||
|
|
for (int j = 0; j < vi.channels; j++) {
|
||
|
|
if (info.chmuxlist[j] == i) {
|
||
|
|
if (nonzero[j] != 0) {
|
||
|
|
zerobundle[ch_in_bundle] = 1;
|
||
|
|
} else {
|
||
|
|
zerobundle[ch_in_bundle] = 0;
|
||
|
|
}
|
||
|
|
pcmbundle[ch_in_bundle++] = vb.pcm[j];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
look.residue_func[i].inverse(vb, look.residue_look[i], pcmbundle, zerobundle, ch_in_bundle);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int i = info.coupling_steps - 1; i >= 0; i--) {
|
||
|
|
float[] pcmM = vb.pcm[info.coupling_mag[i]];
|
||
|
|
float[] pcmA = vb.pcm[info.coupling_ang[i]];
|
||
|
|
|
||
|
|
for (int j = 0; j < n / 2; j++) {
|
||
|
|
float mag = pcmM[j];
|
||
|
|
float ang = pcmA[j];
|
||
|
|
|
||
|
|
if (mag > 0) {
|
||
|
|
if (ang > 0) {
|
||
|
|
pcmM[j] = mag;
|
||
|
|
pcmA[j] = mag - ang;
|
||
|
|
} else {
|
||
|
|
pcmA[j] = mag;
|
||
|
|
pcmM[j] = mag + ang;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (ang > 0) {
|
||
|
|
pcmM[j] = mag;
|
||
|
|
pcmA[j] = mag + ang;
|
||
|
|
} else {
|
||
|
|
pcmA[j] = mag;
|
||
|
|
pcmM[j] = mag - ang;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// /* compute and apply spectral envelope */
|
||
|
|
|
||
|
|
for (int i = 0; i < vi.channels; i++) {
|
||
|
|
float[] pcm = vb.pcm[i];
|
||
|
|
int submap = info.chmuxlist[i];
|
||
|
|
look.floor_func[submap].inverse2(vb, look.floor_look[submap], floormemo[i], pcm);
|
||
|
|
}
|
||
|
|
|
||
|
|
// transform the PCM data; takes PCM vector, vb; modifies PCM vector
|
||
|
|
// only MDCT right now....
|
||
|
|
|
||
|
|
for (int i = 0; i < vi.channels; i++) {
|
||
|
|
float[] pcm = vb.pcm[i];
|
||
|
|
// _analysis_output("out",seq+i,pcm,n/2,0,0);
|
||
|
|
((Mdct) vd.transform[vb.W][0]).backward(pcm, pcm);
|
||
|
|
}
|
||
|
|
|
||
|
|
// now apply the decoded pre-window time information
|
||
|
|
// NOT IMPLEMENTED
|
||
|
|
|
||
|
|
// window the data
|
||
|
|
for (int i = 0; i < vi.channels; i++) {
|
||
|
|
float[] pcm = vb.pcm[i];
|
||
|
|
if (nonzero[i] != 0) {
|
||
|
|
for (int j = 0; j < n; j++) {
|
||
|
|
pcm[j] *= window[j];
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
for (int j = 0; j < n; j++) {
|
||
|
|
pcm[j] = 0.f;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// now apply the decoded post-window time information
|
||
|
|
// NOT IMPLEMENTED
|
||
|
|
// all done!
|
||
|
|
return (0);
|
||
|
|
}
|
||
|
|
|
||
|
|
class InfoMapping0 {
|
||
|
|
int submaps; // <= 16
|
||
|
|
int[] chmuxlist = new int[256]; // up to 256 channels in a Vorbis stream
|
||
|
|
|
||
|
|
int[] timesubmap = new int[16]; // [mux]
|
||
|
|
int[] floorsubmap = new int[16]; // [mux] submap to floors
|
||
|
|
int[] residuesubmap = new int[16];// [mux] submap to residue
|
||
|
|
int[] psysubmap = new int[16]; // [mux]; encode only
|
||
|
|
|
||
|
|
int coupling_steps;
|
||
|
|
int[] coupling_mag = new int[256];
|
||
|
|
int[] coupling_ang = new int[256];
|
||
|
|
|
||
|
|
void free() {
|
||
|
|
chmuxlist = null;
|
||
|
|
timesubmap = null;
|
||
|
|
floorsubmap = null;
|
||
|
|
residuesubmap = null;
|
||
|
|
psysubmap = null;
|
||
|
|
|
||
|
|
coupling_mag = null;
|
||
|
|
coupling_ang = null;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
class LookMapping0 {
|
||
|
|
InfoMode mode;
|
||
|
|
InfoMapping0 map;
|
||
|
|
Object[] time_look;
|
||
|
|
Object[] floor_look;
|
||
|
|
Object[] floor_state;
|
||
|
|
Object[] residue_look;
|
||
|
|
PsyLook[] psy_look;
|
||
|
|
|
||
|
|
FuncTime[] time_func;
|
||
|
|
FuncFloor[] floor_func;
|
||
|
|
FuncResidue[] residue_func;
|
||
|
|
|
||
|
|
int ch;
|
||
|
|
float[][] decay;
|
||
|
|
int lastframe; // if a different mode is called, we need to
|
||
|
|
// invalidate decay and floor state
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|