LNXSDK/Kha/Sources/kha/audio2/ogg/vorbis/VorbisDecoder.hx

785 lines
26 KiB
Haxe
Raw Normal View History

2025-01-22 16:18:30 +01:00
package kha.audio2.ogg.vorbis;
import haxe.ds.Vector;
import haxe.io.Bytes;
import haxe.io.BytesOutput;
import haxe.io.Input;
import haxe.io.Output;
import kha.audio2.ogg.tools.MathTools;
import kha.audio2.ogg.tools.Mdct;
import kha.audio2.ogg.vorbis.data.Codebook;
import kha.audio2.ogg.vorbis.data.Floor.Floor1;
import kha.audio2.ogg.vorbis.data.Header;
import kha.audio2.ogg.vorbis.data.Mode;
import kha.audio2.ogg.vorbis.data.ProbedPage;
import kha.audio2.ogg.vorbis.data.ReaderError;
import kha.audio2.ogg.vorbis.VorbisDecodeState;
/**
* ...
* @author shohei909
*/
class VorbisDecoder
{
var previousWindow:Vector<Vector<Float>>; //var *[STB_VORBIS_MAX_CHANNELS];
var previousLength:Int;
var finalY:Vector<Array<Int>>; // [STB_VORBIS_MAX_CHANNELS];
// twiddle factors
var a:Vector<Vector<Float>>; // var * [2]
var b:Vector<Vector<Float>>; // var * [2]
var c:Vector<Vector<Float>>; // var * [2]
var window:Vector<Vector<Float>>; //var * [2];
var bitReverseData:Vector<Vector<Int>>; //uint16 * [2]
// decode buffer
var channelBuffers:Vector<Vector<Float>>; //var *[STB_VORBIS_MAX_CHANNELS];
var channelBufferStart:Int;
var channelBufferEnd:Int;
public var header(default, null):Header;
public var currentSample(default, null):Int;
public var totalSample(default, null):Null<Int>;
var decodeState:VorbisDecodeState;
function new(header:Header, decodeState:VorbisDecodeState) {
this.header = header;
this.decodeState = decodeState;
totalSample = null;
currentSample = 0;
//Channel
previousLength = 0;
channelBuffers = new Vector(header.channel);
previousWindow = new Vector(header.channel);
finalY = new Vector(header.channel);
for (i in 0...header.channel) {
channelBuffers[i] = VorbisTools.emptyFloatVector(header.blocksize1);
previousWindow[i] = VorbisTools.emptyFloatVector(Std.int(header.blocksize1 / 2));
finalY[i] = new Array();
}
a = new Vector(2);
b = new Vector(2);
c = new Vector(2);
window = new Vector(2);
bitReverseData = new Vector(2);
initBlocksize(0, header.blocksize0);
initBlocksize(1, header.blocksize1);
}
public static function start(input:Input) {
var decodeState = new VorbisDecodeState(input);
var header = Header.read(decodeState);
var decoder = new VorbisDecoder(header, decodeState);
decodeState.startFirstDecode();
decoder.pumpFirstFrame();
return decoder;
}
public function read(output:kha.arrays.Float32Array, samples:Int, channels:Int, sampleRate:Int, useFloat:Bool) {
if (sampleRate % header.sampleRate != 0) {
throw 'Unsupported sampleRate : can\'t convert ${header.sampleRate} to $sampleRate';
}
if (channels % header.channel != 0) {
throw 'Unsupported channels : can\'t convert ${header.channel} to $channels';
}
var sampleRepeat = Std.int(sampleRate / header.sampleRate);
var channelRepeat = Std.int(channels / header.channel);
var n = 0;
var len = Math.floor(samples / sampleRepeat);
if (totalSample != null && len > totalSample - currentSample) {
len = totalSample - currentSample;
}
var index = 0;
while (n < len) {
var k = channelBufferEnd - channelBufferStart;
if (k >= len - n) k = len - n;
for (j in channelBufferStart...(channelBufferStart + k)) {
for (sr in 0...sampleRepeat) {
for (i in 0...header.channel) {
for (cr in 0...channelRepeat) {
var value = channelBuffers[i][j];
if (value > 1) {
value = 1;
} else if (value < -1) {
value = -1;
}
if (useFloat) {
//output.writeFloat(value);
output[index] = value;
++index;
} else {
//output.writeInt16(Math.floor(value * 0x7FFF));
}
}
}
}
}
n += k;
channelBufferStart += k;
if (n == len || getFrameFloat() == 0) {
break;
}
}
for (j in n...len) {
for (sr in 0...sampleRepeat) {
for (i in 0...header.channel) {
for (cr in 0...channelRepeat) {
if (useFloat) {
//output.writeFloat(0);
output[index] = 0;
++index;
} else {
//output.writeInt16(0);
}
}
}
}
}
currentSample += len;
return len * sampleRepeat;
}
public function skipSamples(len:Int) {
var n = 0;
if (totalSample != null && len > totalSample - currentSample) {
len = totalSample - currentSample;
}
while (n < len) {
var k = channelBufferEnd - channelBufferStart;
if (k >= len - n) k = len - n;
n += k;
channelBufferStart += k;
if (n == len || getFrameFloat() == 0) {
break;
}
}
currentSample += len;
return len;
}
public function setupSampleNumber(seekFunc:Int->Void, inputLength:Int) {
if (totalSample == null) {
totalSample = decodeState.getSampleNumber(seekFunc, inputLength);
}
}
public function seek(seekFunc:Int->Void, inputLength:UInt, sampleNumber:Int) {
if (currentSample == sampleNumber) {
return;
}
// do we know the location of the last page?
if (totalSample == null) {
setupSampleNumber(seekFunc, inputLength);
if (totalSample == 0) {
throw new ReaderError(ReaderErrorType.CANT_FIND_LAST_PAGE);
}
}
if (sampleNumber < 0) {
sampleNumber = 0;
}
var p0 = decodeState.pFirst;
var p1 = decodeState.pLast;
if (sampleNumber >= p1.lastDecodedSample) {
sampleNumber = p1.lastDecodedSample - 1;
}
if (sampleNumber < p0.lastDecodedSample) {
seekFrameFromPage(seekFunc, p0.pageStart, 0, sampleNumber);
} else {
var attempts = 0;
while (p0.pageEnd < p1.pageStart) {
// copy these into local variables so we can tweak them
// if any are unknown
var startOffset:UInt = p0.pageEnd;
var endOffset:UInt = p1.afterPreviousPageStart; // an address known to seek to page p1
var startSample = p0.lastDecodedSample;
var endSample = p1.lastDecodedSample;
// currently there is no such tweaking logic needed/possible?
if (startSample == null || endSample == null) {
throw new ReaderError(SEEK_FAILED);
}
// now we want to lerp between these for the target samples...
// step 1: we need to bias towards the page start...
if (startOffset + 4000 < endOffset) {
endOffset -= 4000;
}
// now compute an interpolated search loc
var probe:UInt = startOffset + Math.floor((endOffset - startOffset) / (endSample - startSample) * (sampleNumber - startSample));
// next we need to bias towards binary search...
// code is a little wonky to allow for full 32-bit unsigned values
if (attempts >= 4) {
var probe2:UInt = startOffset + ((endOffset - startOffset) >> 1);
probe = if (attempts >= 8) {
probe2;
} else if (probe < probe2) {
probe + ((probe2 - probe) >>> 1);
} else {
probe2 + ((probe - probe2) >>> 1);
}
}
++attempts;
decodeState.setInputOffset(seekFunc, probe);
switch (decodeState.findPage(seekFunc, inputLength)) {
case NotFound:
throw new ReaderError(SEEK_FAILED);
case Found(_):
}
var q:ProbedPage = decodeState.analyzePage(seekFunc, header);
if (q == null) {
throw new ReaderError(SEEK_FAILED);
}
q.afterPreviousPageStart = probe;
// it's possible we've just found the last page again
if (q.pageStart == p1.pageStart) {
p1 = q;
continue;
}
if (sampleNumber < q.lastDecodedSample) {
p1 = q;
} else {
p0 = q;
}
}
if (p0.lastDecodedSample <= sampleNumber && sampleNumber < p1.lastDecodedSample) {
seekFrameFromPage(seekFunc, p1.pageStart, p0.lastDecodedSample, sampleNumber);
} else {
throw new ReaderError(SEEK_FAILED);
}
}
}
public function seekFrameFromPage(seekFunc:Int->Void, pageStart:Int, firstSample:Int, targetSample:Int) {
var frame = 0;
var frameStart:Int = firstSample;
// firstSample is the sample # of the first sample that doesn't
// overlap the previous page... note that this requires us to
// Partially_ discard the first packet! bleh.
decodeState.setInputOffset(seekFunc, pageStart);
decodeState.forcePageResync();
// frame start is where the previous packet's last decoded sample
// was, which corresponds to leftEnd... EXCEPT if the previous
// packet was long and this packet is short? Probably a bug here.
// now, we can start decoding frames... we'll only FAKE decode them,
// until we find the frame that contains our sample; then we'll rewind,
// and try again
var leftEnd = 0;
var leftStart = 0;
var prevState = null;
var lastState = null;
while (true) {
prevState = lastState;
lastState = decodeState.clone(seekFunc);
var initialResult = decodeInitial();
if (initialResult == null) {
lastState = prevState;
break;
}
leftStart = initialResult.left.start;
leftEnd = initialResult.left.end;
var start = if (frame == 0) {
leftEnd;
} else{
leftStart;
}
// the window starts at leftStart; the last valid sample we generate
// before the next frame's window start is rightStart-1
if (targetSample < frameStart + initialResult.right.start - start) {
break;
}
decodeState.flushPacket();
frameStart += initialResult.right.start - start;
++frame;
}
decodeState = lastState;
seekFunc(decodeState.inputPosition);
previousLength = 0;
pumpFirstFrame();
currentSample = frameStart;
skipSamples(targetSample - frameStart);
}
public function clone(seekFunc:Int->Void) {
var decoder = Type.createEmptyInstance(VorbisDecoder);
decoder.currentSample = currentSample;
decoder.totalSample = totalSample;
decoder.previousLength = previousLength;
decoder.channelBufferStart = channelBufferStart;
decoder.channelBufferEnd = channelBufferEnd;
// sharrow copy
decoder.a = a;
decoder.b = b;
decoder.c = c;
decoder.window = window;
decoder.bitReverseData = bitReverseData;
decoder.header = header;
// deep copy
decoder.decodeState = decodeState.clone(seekFunc);
decoder.channelBuffers = new Vector(header.channel);
decoder.previousWindow = new Vector(header.channel);
decoder.finalY = new Vector(header.channel);
for (i in 0...header.channel) {
decoder.channelBuffers[i] = VorbisTools.copyVector(channelBuffers[i]);
decoder.previousWindow[i] = VorbisTools.copyVector(previousWindow[i]);
decoder.finalY[i] = Lambda.array(finalY[i]);
}
return decoder;
}
public function ensurePosition(seekFunc:Int->Void) {
seekFunc(decodeState.inputPosition);
}
function getFrameFloat() {
var result = decodePacket();
if (result == null) {
channelBufferStart = channelBufferEnd = 0;
return 0;
}
var len = finishFrame(result);
channelBufferStart = result.left;
channelBufferEnd = result.left + len;
return len;
}
function pumpFirstFrame() {
finishFrame(decodePacket());
}
function finishFrame(r:DecodePacketResult):Int {
var len = r.len;
var right = r.right;
var left = r.left;
// we use right&left (the start of the right- and left-window sin()-regions)
// to determine how much to return, rather than inferring from the rules
// (same result, clearer code); 'left' indicates where our sin() window
// starts, therefore where the previous window's right edge starts, and
// therefore where to start mixing from the previous buffer. 'right'
// indicates where our sin() ending-window starts, therefore that's where
// we start saving, and where our returned-data ends.
// mixin from previous window
if (previousLength != 0) {
var n = previousLength;
var w = getWindow(n);
for (i in 0...header.channel) {
var cb = channelBuffers[i];
var pw = previousWindow[i];
for (j in 0...n) {
cb[left+j] = cb[left+j] * w[j] + pw[j] * w[n-1-j];
}
}
}
var prev = previousLength;
// last half of this data becomes previous window
previousLength = len - right;
// @OPTIMIZE: could avoid this copy by double-buffering the
// output (flipping previousWindow with channelBuffers), but
// then previousWindow would have to be 2x as large, and
// channelBuffers couldn't be temp mem (although they're NOT
// currently temp mem, they could be (unless we want to level
// performance by spreading out the computation))
for (i in 0...header.channel) {
var pw = previousWindow[i];
var cb = channelBuffers[i];
for (j in 0...(len - right)) {
pw[j] = cb[right + j];
}
}
if (prev == 0) {
// there was no previous packet, so this data isn't valid...
// this isn't entirely true, only the would-have-overlapped data
// isn't valid, but this seems to be what the spec requires
return 0;
}
// truncate a short frame
if (len < right) {
right = len;
}
return right - left;
}
function getWindow(len:Int)
{
len <<= 1;
return if (len == header.blocksize0) {
window[0];
} else if (len == header.blocksize1) {
window[1];
} else {
VorbisTools.assert(false);
null;
}
}
function initBlocksize(bs:Int, n:Int)
{
var n2 = n >> 1, n4 = n >> 2, n8 = n >> 3;
a[bs] = new Vector(n2);
b[bs] = new Vector(n2);
c[bs] = new Vector(n4);
window[bs] = new Vector(n2);
bitReverseData[bs] = new Vector(n8);
VorbisTools.computeTwiddleFactors(n, a[bs], b[bs], c[bs]);
VorbisTools.computeWindow(n, window[bs]);
VorbisTools.computeBitReverse(n, bitReverseData[bs]);
}
function inverseMdct(buffer:Vector<Float>, n:Int, blocktype:Bool) {
var bt = blocktype ? 1 : 0;
Mdct.inverseTransform(buffer, n, a[bt], b[bt], c[bt], bitReverseData[bt]);
}
function decodePacket():DecodePacketResult
{
var result = decodeInitial();
if (result == null) {
return null;
}
var rest = decodePacketRest(result);
return rest;
}
function decodeInitial():DecodeInitialResult
{
channelBufferStart = channelBufferEnd = 0;
do {
if (!decodeState.maybeStartPacket()) {
return null;
}
// check packet type
if (decodeState.readBits(1) != 0) {
while (VorbisTools.EOP != decodeState.readPacket()) {};
continue;
}
break;
} while (true);
var i = decodeState.readBits(MathTools.ilog(header.modes.length - 1));
if (i == VorbisTools.EOP || i >= header.modes.length) {
throw new ReaderError(ReaderErrorType.SEEK_FAILED);
}
var m = header.modes[i];
var n, prev, next;
if (m.blockflag) {
n = header.blocksize1;
prev = decodeState.readBits(1);
next = decodeState.readBits(1);
} else {
prev = next = 0;
n = header.blocksize0;
}
// WINDOWING
var windowCenter = n >> 1;
return {
mode : i,
left : if (m.blockflag && prev == 0) {
start : (n - header.blocksize0) >> 2,
end : (n + header.blocksize0) >> 2,
} else {
start : 0,
end : windowCenter,
},
right : if (m.blockflag && next == 0) {
start : (n * 3 - header.blocksize0) >> 2,
end : (n * 3 + header.blocksize0) >> 2,
} else {
start : windowCenter,
end : n,
},
}
}
function decodePacketRest(r:DecodeInitialResult):DecodePacketResult
{
var len = 0;
var m = header.modes[r.mode];
var zeroChannel = new Vector<Bool>(256);
var reallyZeroChannel = new Vector<Bool>(256);
// WINDOWING
var n = m.blockflag ? header.blocksize1 : header.blocksize0;
var map = header.mapping[m.mapping];
// FLOORS
var n2 = n >> 1;
VorbisTools.stbProf(1);
var rangeList = [256, 128, 86, 64];
var codebooks = header.codebooks;
for (i in 0...header.channel) {
var s = map.chan[i].mux;
zeroChannel[i] = false;
var floor = header.floorConfig[map.submapFloor[s]];
if (floor.type == 0) {
throw new ReaderError(INVALID_STREAM);
} else {
var g:Floor1 = floor.floor1;
if (decodeState.readBits(1) != 0) {
var fy = new Array<Int>();
var step2Flag = new Vector<Bool>(256);
var range = rangeList[g.floor1Multiplier-1];
var offset = 2;
fy = finalY[i];
fy[0] = decodeState.readBits(MathTools.ilog(range)-1);
fy[1] = decodeState.readBits(MathTools.ilog(range)-1);
for (j in 0...g.partitions) {
var pclass = g.partitionClassList[j];
var cdim = g.classDimensions[pclass];
var cbits = g.classSubclasses[pclass];
var csub = (1 << cbits) - 1;
var cval = 0;
if (cbits != 0) {
var c = codebooks[g.classMasterbooks[pclass]];
cval = decodeState.decode(c);
}
var books = g.subclassBooks[pclass];
for (k in 0...cdim) {
var book = books[cval & csub];
cval >>= cbits;
fy[offset++] = if (book >= 0) {
decodeState.decode(codebooks[book]);
} else {
0;
}
}
}
if (decodeState.validBits == VorbisDecodeState.INVALID_BITS) {
zeroChannel[i] = true;
continue;
}
step2Flag[0] = step2Flag[1] = true;
var naighbors = g.neighbors;
var xlist = g.xlist;
for (j in 2...g.values) {
var low = naighbors[j][0];
var high = naighbors[j][1];
var lowroom = VorbisTools.predictPoint(xlist[j], xlist[low], xlist[high], fy[low], fy[high]);
var val = fy[j];
var highroom = range - lowroom;
var room = if (highroom < lowroom){
highroom * 2;
}else{
lowroom * 2;
}
if (val != 0) {
step2Flag[low] = step2Flag[high] = true;
step2Flag[j] = true;
if (val >= room){
if (highroom > lowroom){
fy[j] = val - lowroom + lowroom;
}else{
fy[j] = lowroom - val + highroom - 1;
}
} else {
if (val & 1 != 0){
fy[j] = lowroom - ((val+1)>>1);
} else{
fy[j] = lowroom + (val>>1);
}
}
} else {
step2Flag[j] = false;
fy[j] = lowroom;
}
}
// defer final floor computation until _after_ residue
for (j in 0...g.values) {
if (!step2Flag[j]){
fy[j] = -1;
}
}
} else {
zeroChannel[i] = true;
}
// So we just defer everything else to later
// at this point we've decoded the floor into buffer
}
}
VorbisTools.stbProf(0);
// at this point we've decoded all floors
//if (alloc.allocBuffer) {
// assert(alloc.allocBufferLengthInBytes == tempOffset);
//}
// re-enable coupled channels if necessary
for (i in 0...header.channel) {
reallyZeroChannel[i] = zeroChannel[i];
}
for (i in 0...map.couplingSteps) {
if (!zeroChannel[map.chan[i].magnitude] || !zeroChannel[map.chan[i].angle]) {
zeroChannel[map.chan[i].magnitude] = zeroChannel[map.chan[i].angle] = false;
}
}
// RESIDUE DECODE
for (i in 0...map.submaps) {
var residueBuffers = new Vector<Vector<Float>>(header.channel);
var doNotDecode = new Vector<Bool>(256);
var ch = 0;
for (j in 0...header.channel) {
if (map.chan[j].mux == i) {
if (zeroChannel[j]) {
doNotDecode[ch] = true;
residueBuffers[ch] = null;
} else {
doNotDecode[ch] = false;
residueBuffers[ch] = channelBuffers[j];
}
++ch;
}
}
var r = map.submapResidue[i];
var residue = header.residueConfig[r];
residue.decode(decodeState,header, residueBuffers, ch, n2, doNotDecode, channelBuffers);
}
// INVERSE COUPLING
VorbisTools.stbProf(14);
var i = map.couplingSteps;
var n2 = n >> 1;
while (--i >= 0) {
var m = channelBuffers[map.chan[i].magnitude];
var a = channelBuffers[map.chan[i].angle];
for (j in 0...n2) {
var a2, m2;
if (m[j] > 0) {
if (a[j] > 0) {
m2 = m[j];
a2 = m[j] - a[j];
} else {
a2 = m[j];
m2 = m[j] + a[j];
}
} else {
if (a[j] > 0) {
m2 = m[j];
a2 = m[j] + a[j];
} else {
a2 = m[j];
m2 = m[j] - a[j];
}
}
m[j] = m2;
a[j] = a2;
}
}
// finish decoding the floors
VorbisTools.stbProf(15);
for (i in 0...header.channel) {
if (reallyZeroChannel[i]) {
for(j in 0...n2) {
channelBuffers[i][j] = 0;
}
} else {
map.doFloor(header.floorConfig, i, n, channelBuffers[i], finalY[i], null);
}
}
// INVERSE MDCT
VorbisTools.stbProf(16);
for (i in 0...header.channel) {
inverseMdct(channelBuffers[i], n, m.blockflag);
}
VorbisTools.stbProf(0);
// this shouldn't be necessary, unless we exited on an error
// and want to flush to get to the next packet
decodeState.flushPacket();
return decodeState.finishDecodePacket(previousLength, n, r);
}
}
typedef DecodePacketResult = {
var len : Int;
var left : Int;
var right : Int;
}
typedef DecodeInitialResult = {
var mode : Int;
var left : Range;
var right : Range;
}
private typedef Range = {
var start : Int;
var end : Int;
}