AstralTransRocketries/ClassiCube
1
0
Fork 0
mirror of https://github.com/ClassiCube/ClassiCube.git synced 2025-09-15 02:25:32 -04:00
Code Issues Packages Projects Releases Wiki Activity

fix style of field names in vorbis.c

Browse Source
This commit is contained in:
UnknownShadow200 2020-08-26 17:33:19 +10:00
parent 2d116128b2
commit 22a3c0d0b4
2 changed files with 176 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Formats.c
View File

@ -876,7 +876,7 @@ static cc_result Dat_ReadFieldData(struct Stream* stream, struct JFieldDesc* fie
return 0; return 0;
} }
static cc_int32 Dat_I32(struct JFieldDesc* field) { static int Dat_I32(struct JFieldDesc* field) {
if (field->Type != JFIELD_I32) Logger_Abort("Field type must be Int32"); if (field->Type != JFIELD_I32) Logger_Abort("Field type must be Int32");
return field->Value.I32; return field->Value.I32;
} }

350
src/Vorbis.c
View File

@ -213,20 +213,20 @@ static float float32_unpack(struct VorbisState* ctx) {
*#########################################################################################################################*/ *#########################################################################################################################*/
#define CODEBOOK_SYNC 0x564342 #define CODEBOOK_SYNC 0x564342
struct Codebook { struct Codebook {
cc_uint32 Dimensions, Entries, TotalCodewords; cc_uint32 dimensions, entries, totalCodewords;
cc_uint32* Codewords; cc_uint32* codewords;
cc_uint32* Values; cc_uint32* values;
cc_uint32 NumCodewords[33]; /* number of codewords of bit length i */ cc_uint32 numCodewords[33]; /* number of codewords of bit length i */
/* vector quantisation values */ /* vector quantisation values */
float MinValue, DeltaValue; float minValue, deltaValue;
cc_uint32 SequenceP, LookupType, LookupValues; cc_uint32 sequenceP, lookupType, lookupValues;
cc_uint16* Multiplicands; cc_uint16* multiplicands;
}; };
static void Codebook_Free(struct Codebook* c) { static void Codebook_Free(struct Codebook* c) {
Mem_Free(c->Codewords); Mem_Free(c->codewords);
Mem_Free(c->Values); Mem_Free(c->values);
Mem_Free(c->Multiplicands); Mem_Free(c->multiplicands);
} }
static cc_uint32 Codebook_Pow(cc_uint32 base, cc_uint32 exp) { static cc_uint32 Codebook_Pow(cc_uint32 base, cc_uint32 exp) {
@ -262,23 +262,23 @@ static cc_bool Codebook_CalcCodewords(struct Codebook* c, cc_uint8* len) {
int offset; int offset;
int len_offsets[33]; int len_offsets[33];
c->Codewords = (cc_uint32*)Mem_Alloc(c->TotalCodewords, 4, "codewords"); c->codewords = (cc_uint32*)Mem_Alloc(c->totalCodewords, 4, "codewords");
c->Values = (cc_uint32*)Mem_Alloc(c->TotalCodewords, 4, "values"); c->values = (cc_uint32*)Mem_Alloc(c->totalCodewords, 4, "values");
/* Codeword entries are ordered by length */ /* Codeword entries are ordered by length */
offset = 0; offset = 0;
for (i = 0; i < Array_Elems(len_offsets); i++) { for (i = 0; i < Array_Elems(len_offsets); i++) {
len_offsets[i] = offset; len_offsets[i] = offset;
offset += c->NumCodewords[i]; offset += c->numCodewords[i];
} }
/* add codeword 0 to tree */ /* add codeword 0 to tree */
for (i = 0; i < c->Entries; i++) { for (i = 0; i < c->entries; i++) {
if (!len[i]) continue; if (!len[i]) continue;
offset = len_offsets[len[i]]; offset = len_offsets[len[i]];
c->Codewords[offset] = 0; c->codewords[offset] = 0;
c->Values[offset] = i; c->values[offset] = i;
len_offsets[len[i]]++; len_offsets[len[i]]++;
break; break;
@ -290,7 +290,7 @@ static cc_bool Codebook_CalcCodewords(struct Codebook* c, cc_uint8* len) {
} }
i++; /* first codeword was already handled */ i++; /* first codeword was already handled */
for (; i < c->Entries; i++) { for (; i < c->entries; i++) {
root = len[i]; root = len[i];
if (!root) continue; if (!root) continue;
offset = len_offsets[len[i]]; offset = len_offsets[len[i]];
@ -302,8 +302,8 @@ static cc_bool Codebook_CalcCodewords(struct Codebook* c, cc_uint8* len) {
codeword = next_codewords[root]; codeword = next_codewords[root];
next_codewords[root] = 0; next_codewords[root] = 0;
c->Codewords[offset] = codeword; c->codewords[offset] = codeword;
c->Values[offset] = i; c->values[offset] = i;
for (depth = len[i]; depth > root; depth--) { for (depth = len[i]; depth > root; depth--) {
next_codewords[depth] = codeword + (1U << (32 - depth)); next_codewords[depth] = codeword + (1U << (32 - depth));
@ -325,19 +325,19 @@ static cc_result Codebook_DecodeSetup(struct VorbisState* ctx, struct Codebook*
sync = Vorbis_ReadBits(ctx, 24); sync = Vorbis_ReadBits(ctx, 24);
if (sync != CODEBOOK_SYNC) return VORBIS_ERR_CODEBOOK_SYNC; if (sync != CODEBOOK_SYNC) return VORBIS_ERR_CODEBOOK_SYNC;
c->Dimensions = Vorbis_ReadBits(ctx, 16); c->dimensions = Vorbis_ReadBits(ctx, 16);
c->Entries = Vorbis_ReadBits(ctx, 24); c->entries = Vorbis_ReadBits(ctx, 24);
codewordLens = (cc_uint8*)Mem_Alloc(c->Entries, 1, "raw codeword lens"); codewordLens = (cc_uint8*)Mem_Alloc(c->entries, 1, "raw codeword lens");
for (i = 0; i < Array_Elems(c->NumCodewords); i++) { for (i = 0; i < Array_Elems(c->numCodewords); i++) {
c->NumCodewords[i] = 0; c->numCodewords[i] = 0;
} }
/* ordered entries flag */ /* ordered entries flag */
if (!Vorbis_ReadBit(ctx)) { if (!Vorbis_ReadBit(ctx)) {
sparse = Vorbis_ReadBit(ctx); sparse = Vorbis_ReadBit(ctx);
entry = 0; entry = 0;
for (i = 0; i < c->Entries; i++) { for (i = 0; i < c->entries; i++) {
/* sparse trees may not have all entries */ /* sparse trees may not have all entries */
if (sparse && !Vorbis_ReadBit(ctx)){ if (sparse && !Vorbis_ReadBit(ctx)){
codewordLens[i] = 0; codewordLens[i] = 0;
@ -346,67 +346,67 @@ static cc_result Codebook_DecodeSetup(struct VorbisState* ctx, struct Codebook*
len = Vorbis_ReadBits(ctx, 5) + 1; len = Vorbis_ReadBits(ctx, 5) + 1;
codewordLens[i] = len; codewordLens[i] = len;
c->NumCodewords[len]++; c->numCodewords[len]++;
entry++; entry++;
} }
} else { } else {
len = Vorbis_ReadBits(ctx, 5) + 1; len = Vorbis_ReadBits(ctx, 5) + 1;
for (entry = 0; entry < c->Entries;) { for (entry = 0; entry < c->entries;) {
runBits = iLog(c->Entries - entry); runBits = iLog(c->entries - entry);
runLen = Vorbis_ReadBits(ctx, runBits); runLen = Vorbis_ReadBits(ctx, runBits);
/* handle corrupted ogg files */ /* handle corrupted ogg files */
if (entry + runLen > c->Entries) return VORBIS_ERR_CODEBOOK_ENTRY; if (entry + runLen > c->entries) return VORBIS_ERR_CODEBOOK_ENTRY;
for (i = 0; i < runLen; i++) { codewordLens[entry++] = len; } for (i = 0; i < runLen; i++) { codewordLens[entry++] = len; }
c->NumCodewords[len++] = runLen; c->numCodewords[len++] = runLen;
} }
} }
c->TotalCodewords = entry; c->totalCodewords = entry;
Codebook_CalcCodewords(c, codewordLens); Codebook_CalcCodewords(c, codewordLens);
Mem_Free(codewordLens); Mem_Free(codewordLens);
c->LookupType = Vorbis_ReadBits(ctx, 4); c->lookupType = Vorbis_ReadBits(ctx, 4);
c->Multiplicands = NULL; c->multiplicands = NULL;
if (c->LookupType == 0) return 0; if (c->lookupType == 0) return 0;
if (c->LookupType > 2) return VORBIS_ERR_CODEBOOK_LOOKUP; if (c->lookupType > 2) return VORBIS_ERR_CODEBOOK_LOOKUP;
c->MinValue = float32_unpack(ctx); c->minValue = float32_unpack(ctx);
c->DeltaValue = float32_unpack(ctx); c->deltaValue = float32_unpack(ctx);
valueBits = Vorbis_ReadBits(ctx, 4) + 1; valueBits = Vorbis_ReadBits(ctx, 4) + 1;
c->SequenceP = Vorbis_ReadBit(ctx); c->sequenceP = Vorbis_ReadBit(ctx);
if (c->LookupType == 1) { if (c->lookupType == 1) {
lookupValues = Codebook_Lookup1Values(c->Entries, c->Dimensions); lookupValues = Codebook_Lookup1Values(c->entries, c->dimensions);
} else { } else {
lookupValues = c->Entries * c->Dimensions; lookupValues = c->entries * c->dimensions;
} }
c->LookupValues = lookupValues; c->lookupValues = lookupValues;
c->Multiplicands = (cc_uint16*)Mem_Alloc(lookupValues, 2, "multiplicands"); c->multiplicands = (cc_uint16*)Mem_Alloc(lookupValues, 2, "multiplicands");
for (i = 0; i < lookupValues; i++) { for (i = 0; i < lookupValues; i++) {
c->Multiplicands[i] = Vorbis_ReadBits(ctx, valueBits); c->multiplicands[i] = Vorbis_ReadBits(ctx, valueBits);
} }
return 0; return 0;
} }
static cc_uint32 Codebook_DecodeScalar(struct VorbisState* ctx, struct Codebook* c) { static cc_uint32 Codebook_DecodeScalar(struct VorbisState* ctx, struct Codebook* c) {
cc_uint32 codeword = 0, shift = 31, depth, i; cc_uint32 codeword = 0, shift = 31, depth, i;
cc_uint32* codewords = c->Codewords; cc_uint32* codewords = c->codewords;
cc_uint32* values = c->Values; cc_uint32* values = c->values;
/* TODO: This is so massively slow */ /* TODO: This is so massively slow */
for (depth = 1; depth <= 32; depth++, shift--) { for (depth = 1; depth <= 32; depth++, shift--) {
codeword |= Vorbis_ReadBit(ctx) << shift; codeword |= Vorbis_ReadBit(ctx) << shift;
for (i = 0; i < c->NumCodewords[depth]; i++) { for (i = 0; i < c->numCodewords[depth]; i++) {
if (codeword != codewords[i]) continue; if (codeword != codewords[i]) continue;
return values[i]; return values[i];
} }
codewords += c->NumCodewords[depth]; codewords += c->numCodewords[depth];
values += c->NumCodewords[depth]; values += c->numCodewords[depth];
} }
Logger_Abort("Invalid huffman code"); Logger_Abort("Invalid huffman code");
return -1; return -1;
@ -417,23 +417,23 @@ static void Codebook_DecodeVectors(struct VorbisState* ctx, struct Codebook* c,
float last = 0.0f, value; float last = 0.0f, value;
cc_uint32 i, offset; cc_uint32 i, offset;
if (c->LookupType == 1) { if (c->lookupType == 1) {
cc_uint32 indexDivisor = 1; cc_uint32 indexDivisor = 1;
for (i = 0; i < c->Dimensions; i++, v += step) { for (i = 0; i < c->dimensions; i++, v += step) {
offset = (lookupOffset / indexDivisor) % c->LookupValues; offset = (lookupOffset / indexDivisor) % c->lookupValues;
value = c->Multiplicands[offset] * c->DeltaValue + c->MinValue + last; value = c->multiplicands[offset] * c->deltaValue + c->minValue + last;
*v += value; *v += value;
if (c->SequenceP) last = value; if (c->sequenceP) last = value;
indexDivisor *= c->LookupValues; indexDivisor *= c->lookupValues;
} }
} else if (c->LookupType == 2) { } else if (c->lookupType == 2) {
offset = lookupOffset * c->Dimensions; offset = lookupOffset * c->dimensions;
for (i = 0; i < c->Dimensions; i++, offset++, v += step) { for (i = 0; i < c->dimensions; i++, offset++, v += step) {
value = c->Multiplicands[offset] * c->DeltaValue + c->MinValue + last; value = c->multiplicands[offset] * c->deltaValue + c->minValue + last;
*v += value; *v += value;
if (c->SequenceP) last = value; if (c->sequenceP) last = value;
} }
} else { } else {
Logger_Abort("Invalid huffman code"); Logger_Abort("Invalid huffman code");
@ -447,15 +447,15 @@ static void Codebook_DecodeVectors(struct VorbisState* ctx, struct Codebook* c,
#define FLOOR_MAX_CLASSES 16 #define FLOOR_MAX_CLASSES 16
#define FLOOR_MAX_VALUES (FLOOR_MAX_PARTITIONS * 8 + 2) #define FLOOR_MAX_VALUES (FLOOR_MAX_PARTITIONS * 8 + 2)
struct Floor { struct Floor {
cc_uint8 Partitions, Multiplier; cc_int32 Range, Values; cc_uint8 partitions, multiplier; cc_int32 range, values;
cc_uint8 PartitionClasses[FLOOR_MAX_PARTITIONS]; cc_uint8 partitionClasses[FLOOR_MAX_PARTITIONS];
cc_uint8 ClassDimensions[FLOOR_MAX_CLASSES]; cc_uint8 classDimensions[FLOOR_MAX_CLASSES];
cc_uint8 ClassSubClasses[FLOOR_MAX_CLASSES]; cc_uint8 classSubClasses[FLOOR_MAX_CLASSES];
cc_uint8 ClassMasterbooks[FLOOR_MAX_CLASSES]; cc_uint8 classMasterbooks[FLOOR_MAX_CLASSES];
cc_int16 SubclassBooks[FLOOR_MAX_CLASSES][8]; cc_int16 subclassBooks[FLOOR_MAX_CLASSES][8];
cc_int16 XList[FLOOR_MAX_VALUES]; cc_int16 xList[FLOOR_MAX_VALUES];
cc_uint16 ListOrder[FLOOR_MAX_VALUES]; cc_uint16 listOrder[FLOOR_MAX_VALUES];
cc_int32 YList[VORBIS_MAX_CHANS][FLOOR_MAX_VALUES]; cc_int32 yList[VORBIS_MAX_CHANS][FLOOR_MAX_VALUES];
}; };
static const float floor1_inverse_dB_table[256] = { static const float floor1_inverse_dB_table[256] = {
@ -521,46 +521,46 @@ static cc_result Floor_DecodeSetup(struct VorbisState* ctx, struct Floor* f) {
int rangeBits, classNum; int rangeBits, classNum;
cc_int16 xlist_sorted[FLOOR_MAX_VALUES]; cc_int16 xlist_sorted[FLOOR_MAX_VALUES];
f->Partitions = Vorbis_ReadBits(ctx, 5); f->partitions = Vorbis_ReadBits(ctx, 5);
maxClass = -1; maxClass = -1;
for (i = 0; i < f->Partitions; i++) { for (i = 0; i < f->partitions; i++) {
f->PartitionClasses[i] = Vorbis_ReadBits(ctx, 4); f->partitionClasses[i] = Vorbis_ReadBits(ctx, 4);
maxClass = max(maxClass, f->PartitionClasses[i]); maxClass = max(maxClass, f->partitionClasses[i]);
} }
for (i = 0; i <= maxClass; i++) { for (i = 0; i <= maxClass; i++) {
f->ClassDimensions[i] = Vorbis_ReadBits(ctx, 3) + 1; f->classDimensions[i] = Vorbis_ReadBits(ctx, 3) + 1;
f->ClassSubClasses[i] = Vorbis_ReadBits(ctx, 2); f->classSubClasses[i] = Vorbis_ReadBits(ctx, 2);
if (f->ClassSubClasses[i]) { if (f->classSubClasses[i]) {
f->ClassMasterbooks[i] = Vorbis_ReadBits(ctx, 8); f->classMasterbooks[i] = Vorbis_ReadBits(ctx, 8);
} }
for (j = 0; j < (1 << f->ClassSubClasses[i]); j++) { for (j = 0; j < (1 << f->classSubClasses[i]); j++) {
f->SubclassBooks[i][j] = (cc_int16)Vorbis_ReadBits(ctx, 8) - 1; f->subclassBooks[i][j] = (cc_int16)Vorbis_ReadBits(ctx, 8) - 1;
} }
} }
f->Multiplier = Vorbis_ReadBits(ctx, 2) + 1; f->multiplier = Vorbis_ReadBits(ctx, 2) + 1;
f->Range = ranges[f->Multiplier - 1]; f->range = ranges[f->multiplier - 1];
rangeBits = Vorbis_ReadBits(ctx, 4); rangeBits = Vorbis_ReadBits(ctx, 4);
f->XList[0] = 0; f->xList[0] = 0;
f->XList[1] = 1 << rangeBits; f->xList[1] = 1 << rangeBits;
for (i = 0, idx = 2; i < f->Partitions; i++) { for (i = 0, idx = 2; i < f->partitions; i++) {
classNum = f->PartitionClasses[i]; classNum = f->partitionClasses[i];
for (j = 0; j < f->ClassDimensions[classNum]; j++) { for (j = 0; j < f->classDimensions[classNum]; j++) {
f->XList[idx++] = Vorbis_ReadBits(ctx, rangeBits); f->xList[idx++] = Vorbis_ReadBits(ctx, rangeBits);
} }
} }
f->Values = idx; f->values = idx;
/* sort X list for curve computation later */ /* sort X list for curve computation later */
Mem_Copy(xlist_sorted, f->XList, idx * 2); Mem_Copy(xlist_sorted, f->xList, idx * 2);
for (i = 0; i < idx; i++) { f->ListOrder[i] = i; } for (i = 0; i < idx; i++) { f->listOrder[i] = i; }
tmp_xlist = xlist_sorted; tmp_xlist = xlist_sorted;
tmp_order = f->ListOrder; tmp_order = f->listOrder;
Floor_SortXList(0, idx - 1); Floor_SortXList(0, idx - 1);
return 0; return 0;
} }
@ -574,26 +574,26 @@ static cc_bool Floor_DecodeFrame(struct VorbisState* ctx, struct Floor* f, int c
/* does this frame have any energy */ /* does this frame have any energy */
if (!Vorbis_ReadBit(ctx)) return false; if (!Vorbis_ReadBit(ctx)) return false;
yList = f->YList[ch]; yList = f->yList[ch];
rangeBits = iLog(f->Range - 1); rangeBits = iLog(f->range - 1);
yList[0] = Vorbis_ReadBits(ctx, rangeBits); yList[0] = Vorbis_ReadBits(ctx, rangeBits);
yList[1] = Vorbis_ReadBits(ctx, rangeBits); yList[1] = Vorbis_ReadBits(ctx, rangeBits);
for (i = 0, idx = 2; i < f->Partitions; i++) { for (i = 0, idx = 2; i < f->partitions; i++) {
klass = f->PartitionClasses[i]; klass = f->partitionClasses[i];
cdim = f->ClassDimensions[klass]; cdim = f->classDimensions[klass];
cbits = f->ClassSubClasses[klass]; cbits = f->classSubClasses[klass];
csub = (1 << cbits) - 1; csub = (1 << cbits) - 1;
cval = 0; cval = 0;
if (cbits) { if (cbits) {
bookNum = f->ClassMasterbooks[klass]; bookNum = f->classMasterbooks[klass];
cval = Codebook_DecodeScalar(ctx, &ctx->codebooks[bookNum]); cval = Codebook_DecodeScalar(ctx, &ctx->codebooks[bookNum]);
} }
for (j = 0; j < cdim; j++) { for (j = 0; j < cdim; j++) {
bookNum = f->SubclassBooks[klass][cval & csub]; bookNum = f->subclassBooks[klass][cval & csub];
cval >>= cbits; cval >>= cbits;
if (bookNum >= 0) { if (bookNum >= 0) {
@ -679,7 +679,7 @@ static void Floor_Synthesis(struct VorbisState* ctx, struct Floor* f, int ch) {
float value; float value;
/* amplitude value synthesis */ /* amplitude value synthesis */
yList = f->YList[ch]; yList = f->yList[ch];
data = ctx->curOutput[ch]; data = ctx->curOutput[ch];
Step2[0] = true; Step2[0] = true;
@ -687,14 +687,14 @@ static void Floor_Synthesis(struct VorbisState* ctx, struct Floor* f, int ch) {
YFinal[0] = yList[0]; YFinal[0] = yList[0];
YFinal[1] = yList[1]; YFinal[1] = yList[1];
for (i = 2; i < f->Values; i++) { for (i = 2; i < f->values; i++) {
lo_offset = low_neighbor(f->XList, i); lo_offset = low_neighbor(f->xList, i);
hi_offset = high_neighbor(f->XList, i); hi_offset = high_neighbor(f->xList, i);
predicted = Floor_RenderPoint(f->XList[lo_offset], YFinal[lo_offset], predicted = Floor_RenderPoint(f->xList[lo_offset], YFinal[lo_offset],
f->XList[hi_offset], YFinal[hi_offset], f->XList[i]); f->xList[hi_offset], YFinal[hi_offset], f->xList[i]);
val = yList[i]; val = yList[i];
highroom = f->Range - predicted; highroom = f->range - predicted;
lowroom = predicted; lowroom = predicted;
if (highroom < lowroom) { if (highroom < lowroom) {
@ -728,14 +728,14 @@ static void Floor_Synthesis(struct VorbisState* ctx, struct Floor* f, int ch) {
} }
/* curve synthesis */ /* curve synthesis */
lx = 0; ly = YFinal[f->ListOrder[0]] * f->Multiplier; lx = 0; ly = YFinal[f->listOrder[0]] * f->multiplier;
hx = 0; hy = ly; hx = 0; hy = ly;
for (rawI = 1; rawI < f->Values; rawI++) { for (rawI = 1; rawI < f->values; rawI++) {
i = f->ListOrder[rawI]; i = f->listOrder[rawI];
if (!Step2[i]) continue; if (!Step2[i]) continue;
hx = f->XList[i]; hy = YFinal[i] * f->Multiplier; hx = f->xList[i]; hy = YFinal[i] * f->multiplier;
if (lx < hx) { if (lx < hx) {
Floor_RenderLine(lx, ly, min(hx, ctx->dataSize), hy, data); Floor_RenderLine(lx, ly, min(hx, ctx->dataSize), hy, data);
} }
@ -757,37 +757,37 @@ static void Floor_Synthesis(struct VorbisState* ctx, struct Floor* f, int ch) {
*#########################################################################################################################*/ *#########################################################################################################################*/
#define RESIDUE_MAX_CLASSIFICATIONS 65 #define RESIDUE_MAX_CLASSIFICATIONS 65
struct Residue { struct Residue {
cc_uint8 Type, Classifications, Classbook; cc_uint8 type, classifications, classbook;
cc_uint32 Begin, End, PartitionSize; cc_uint32 begin, end, partitionSize;
cc_uint8 Cascade[RESIDUE_MAX_CLASSIFICATIONS]; cc_uint8 cascade[RESIDUE_MAX_CLASSIFICATIONS];
cc_int16 Books[RESIDUE_MAX_CLASSIFICATIONS][8]; cc_int16 books[RESIDUE_MAX_CLASSIFICATIONS][8];
}; };
static cc_result Residue_DecodeSetup(struct VorbisState* ctx, struct Residue* r, int type) { static cc_result Residue_DecodeSetup(struct VorbisState* ctx, struct Residue* r, int type) {
cc_int16 codebook; cc_int16 codebook;
int i, j; int i, j;
r->Type = (cc_uint8)type; r->type = (cc_uint8)type;
r->Begin = Vorbis_ReadBits(ctx, 24); r->begin = Vorbis_ReadBits(ctx, 24);
r->End = Vorbis_ReadBits(ctx, 24); r->end = Vorbis_ReadBits(ctx, 24);
r->PartitionSize = Vorbis_ReadBits(ctx, 24) + 1; r->partitionSize = Vorbis_ReadBits(ctx, 24) + 1;
r->Classifications = Vorbis_ReadBits(ctx, 6) + 1; r->classifications = Vorbis_ReadBits(ctx, 6) + 1;
r->Classbook = Vorbis_ReadBits(ctx, 8); r->classbook = Vorbis_ReadBits(ctx, 8);
for (i = 0; i < r->Classifications; i++) { for (i = 0; i < r->classifications; i++) {
r->Cascade[i] = Vorbis_ReadBits(ctx, 3); r->cascade[i] = Vorbis_ReadBits(ctx, 3);
if (!Vorbis_ReadBit(ctx)) continue; if (!Vorbis_ReadBit(ctx)) continue;
r->Cascade[i] |= Vorbis_ReadBits(ctx, 5) << 3; r->cascade[i] |= Vorbis_ReadBits(ctx, 5) << 3;
} }
for (i = 0; i < r->Classifications; i++) { for (i = 0; i < r->classifications; i++) {
for (j = 0; j < 8; j++) { for (j = 0; j < 8; j++) {
codebook = -1; codebook = -1;
if (r->Cascade[i] & (1 << j)) { if (r->cascade[i] & (1 << j)) {
codebook = Vorbis_ReadBits(ctx, 8); codebook = Vorbis_ReadBits(ctx, 8);
} }
r->Books[i][j] = codebook; r->books[i][j] = codebook;
} }
} }
return 0; return 0;
@ -813,13 +813,13 @@ static void Residue_DecodeCore(struct VorbisState* ctx, struct Residue* r, cc_ui
cc_int16 book; cc_int16 book;
/* per spec, ensure decoded bounds are actually in size */ /* per spec, ensure decoded bounds are actually in size */
residueBeg = min(r->Begin, size); residueBeg = min(r->begin, size);
residueEnd = min(r->End, size); residueEnd = min(r->end, size);
classbook = &ctx->codebooks[r->Classbook]; classbook = &ctx->codebooks[r->classbook];
classwordsPerCodeword = classbook->Dimensions; classwordsPerCodeword = classbook->dimensions;
nToRead = residueEnd - residueBeg; nToRead = residueEnd - residueBeg;
partitionsToRead = nToRead / r->PartitionSize; partitionsToRead = nToRead / r->partitionSize;
/* first half of temp array is used by residue type 2 for storing temp interleaved data */ /* first half of temp array is used by residue type 2 for storing temp interleaved data */
classifications_raw = ((cc_uint8*)ctx->temp) + (ctx->dataSize * ctx->channels * 5); classifications_raw = ((cc_uint8*)ctx->temp) + (ctx->dataSize * ctx->channels * 5);
@ -840,8 +840,8 @@ static void Residue_DecodeCore(struct VorbisState* ctx, struct Residue* r, cc_ui
temp = Codebook_DecodeScalar(ctx, classbook); temp = Codebook_DecodeScalar(ctx, classbook);
for (i = classwordsPerCodeword - 1; i >= 0; i--) { for (i = classwordsPerCodeword - 1; i >= 0; i--) {
classifications[j][i + partitionCount] = temp % r->Classifications; classifications[j][i + partitionCount] = temp % r->classifications;
temp /= r->Classifications; temp /= r->classifications;
} }
} }
} }
@ -851,21 +851,21 @@ static void Residue_DecodeCore(struct VorbisState* ctx, struct Residue* r, cc_ui
if (doNotDecode[j]) continue; if (doNotDecode[j]) continue;
klass = classifications[j][partitionCount]; klass = classifications[j][partitionCount];
book = r->Books[klass][pass]; book = r->books[klass][pass];
if (book < 0) continue; if (book < 0) continue;
offset = residueBeg + partitionCount * r->PartitionSize; offset = residueBeg + partitionCount * r->partitionSize;
v = data[j] + offset; v = data[j] + offset;
c = &ctx->codebooks[book]; c = &ctx->codebooks[book];
if (r->Type == 0) { if (r->type == 0) {
int step = r->PartitionSize / c->Dimensions; int step = r->partitionSize / c->dimensions;
for (k = 0; k < step; k++) { for (k = 0; k < step; k++) {
Codebook_DecodeVectors(ctx, c, v, step); v++; Codebook_DecodeVectors(ctx, c, v, step); v++;
} }
} else { } else {
for (k = 0; k < r->PartitionSize; k += c->Dimensions) { for (k = 0; k < r->partitionSize; k += c->dimensions) {
Codebook_DecodeVectors(ctx, c, v, 1); v += c->Dimensions; Codebook_DecodeVectors(ctx, c, v, 1); v += c->dimensions;
} }
} }
} }
@ -881,7 +881,7 @@ static void Residue_DecodeFrame(struct VorbisState* ctx, struct Residue* r, int
cc_bool decodeAny; cc_bool decodeAny;
int i, j; int i, j;
if (r->Type == 2) { if (r->type == 2) {
decodeAny = false; decodeAny = false;
/* type 2 decodes all channel vectors, if at least 1 channel to decode */ /* type 2 decodes all channel vectors, if at least 1 channel to decode */
@ -915,12 +915,12 @@ static void Residue_DecodeFrame(struct VorbisState* ctx, struct Residue* r, int
#define MAPPING_MAX_COUPLINGS 256 #define MAPPING_MAX_COUPLINGS 256
#define MAPPING_MAX_SUBMAPS 15 #define MAPPING_MAX_SUBMAPS 15
struct Mapping { struct Mapping {
cc_uint8 CouplingSteps, Submaps; cc_uint8 couplingSteps, submaps;
cc_uint8 Mux[VORBIS_MAX_CHANS]; cc_uint8 mux[VORBIS_MAX_CHANS];
cc_uint8 FloorIdx[MAPPING_MAX_SUBMAPS]; cc_uint8 floorIdx[MAPPING_MAX_SUBMAPS];
cc_uint8 ResidueIdx[MAPPING_MAX_SUBMAPS]; cc_uint8 residueIdx[MAPPING_MAX_SUBMAPS];
cc_uint8 Magnitude[MAPPING_MAX_COUPLINGS]; cc_uint8 magnitude[MAPPING_MAX_COUPLINGS];
cc_uint8 Angle[MAPPING_MAX_COUPLINGS]; cc_uint8 angle[MAPPING_MAX_COUPLINGS];
}; };
static cc_result Mapping_DecodeSetup(struct VorbisState* ctx, struct Mapping* m) { static cc_result Mapping_DecodeSetup(struct VorbisState* ctx, struct Mapping* m) {
@ -939,31 +939,31 @@ static cc_result Mapping_DecodeSetup(struct VorbisState* ctx, struct Mapping* m)
couplingBits = iLog(ctx->channels - 1); couplingBits = iLog(ctx->channels - 1);
for (i = 0; i < couplingSteps; i++) { for (i = 0; i < couplingSteps; i++) {
m->Magnitude[i] = Vorbis_ReadBits(ctx, couplingBits); m->magnitude[i] = Vorbis_ReadBits(ctx, couplingBits);
m->Angle[i] = Vorbis_ReadBits(ctx, couplingBits); m->angle[i] = Vorbis_ReadBits(ctx, couplingBits);
if (m->Magnitude[i] == m->Angle[i]) return VORBIS_ERR_MAPPING_CHANS; if (m->magnitude[i] == m->angle[i]) return VORBIS_ERR_MAPPING_CHANS;
} }
} }
reserved = Vorbis_ReadBits(ctx, 2); reserved = Vorbis_ReadBits(ctx, 2);
if (reserved != 0) return VORBIS_ERR_MAPPING_RESERVED; if (reserved != 0) return VORBIS_ERR_MAPPING_RESERVED;
m->Submaps = submaps; m->submaps = submaps;
m->CouplingSteps = couplingSteps; m->couplingSteps = couplingSteps;
if (submaps > 1) { if (submaps > 1) {
for (i = 0; i < ctx->channels; i++) { for (i = 0; i < ctx->channels; i++) {
m->Mux[i] = Vorbis_ReadBits(ctx, 4); m->mux[i] = Vorbis_ReadBits(ctx, 4);
} }
} else { } else {
for (i = 0; i < ctx->channels; i++) { for (i = 0; i < ctx->channels; i++) {
m->Mux[i] = 0; m->mux[i] = 0;
} }
} }
for (i = 0; i < submaps; i++) { for (i = 0; i < submaps; i++) {
Vorbis_ReadBits(ctx, 8); /* time value */ Vorbis_ReadBits(ctx, 8); /* time value */
m->FloorIdx[i] = Vorbis_ReadBits(ctx, 8); m->floorIdx[i] = Vorbis_ReadBits(ctx, 8);
m->ResidueIdx[i] = Vorbis_ReadBits(ctx, 8); m->residueIdx[i] = Vorbis_ReadBits(ctx, 8);
} }
return 0; return 0;
} }
@ -1112,17 +1112,17 @@ void imdct_calc(float* in, float* out, struct imdct_state* state) {
/*########################################################################################################################* /*########################################################################################################################*
*-----------------------------------------------------Vorbis setup--------------------------------------------------------* *-----------------------------------------------------Vorbis setup--------------------------------------------------------*
*#########################################################################################################################*/ *#########################################################################################################################*/
struct Mode { cc_uint8 BlockSizeFlag, MappingIdx; }; struct Mode { cc_uint8 blockSizeFlag, mappingIdx; };
static cc_result Mode_DecodeSetup(struct VorbisState* ctx, struct Mode* m) { static cc_result Mode_DecodeSetup(struct VorbisState* ctx, struct Mode* m) {
int windowType, transformType; int windowType, transformType;
m->BlockSizeFlag = Vorbis_ReadBit(ctx); m->blockSizeFlag = Vorbis_ReadBit(ctx);
windowType = Vorbis_ReadBits(ctx, 16); windowType = Vorbis_ReadBits(ctx, 16);
if (windowType != 0) return VORBIS_ERR_MODE_WINDOW; if (windowType != 0) return VORBIS_ERR_MODE_WINDOW;
transformType = Vorbis_ReadBits(ctx, 16); transformType = Vorbis_ReadBits(ctx, 16);
if (transformType != 0) return VORBIS_ERR_MODE_TRANSFORM; if (transformType != 0) return VORBIS_ERR_MODE_TRANSFORM;
m->MappingIdx = Vorbis_ReadBits(ctx, 8); m->mappingIdx = Vorbis_ReadBits(ctx, 8);
return 0; return 0;
} }
@ -1372,13 +1372,13 @@ cc_result Vorbis_DecodeFrame(struct VorbisState* ctx) {
modeIdx = Vorbis_ReadBits(ctx, ctx->modeNumBits); modeIdx = Vorbis_ReadBits(ctx, ctx->modeNumBits);
mode = &ctx->modes[modeIdx]; mode = &ctx->modes[modeIdx];
mapping = &ctx->mappings[mode->MappingIdx]; mapping = &ctx->mappings[mode->mappingIdx];
/* decode window shape */ /* decode window shape */
ctx->curBlockSize = ctx->blockSizes[mode->BlockSizeFlag]; ctx->curBlockSize = ctx->blockSizes[mode->blockSizeFlag];
ctx->dataSize = ctx->curBlockSize / 2; ctx->dataSize = ctx->curBlockSize / 2;
/* long window lapping flags - we don't care about them though */ /* long window lapping flags - we don't care about them though */
if (mode->BlockSizeFlag) { Vorbis_ReadBits(ctx, 2); } /* TODO: do we just SkipBits here */ if (mode->blockSizeFlag) { Vorbis_ReadBits(ctx, 2); } /* TODO: do we just SkipBits here */
/* swap prev and cur outputs around */ /* swap prev and cur outputs around */
tmp = ctx->values[1]; ctx->values[1] = ctx->values[0]; ctx->values[0] = tmp; tmp = ctx->values[1]; ctx->values[1] = ctx->values[0]; ctx->values[0] = tmp;
@ -1391,16 +1391,16 @@ cc_result Vorbis_DecodeFrame(struct VorbisState* ctx) {
/* decode floor */ /* decode floor */
for (i = 0; i < ctx->channels; i++) { for (i = 0; i < ctx->channels; i++) {
submap = mapping->Mux[i]; submap = mapping->mux[i];
floorIdx = mapping->FloorIdx[submap]; floorIdx = mapping->floorIdx[submap];
hasFloor[i] = Floor_DecodeFrame(ctx, &ctx->floors[floorIdx], i); hasFloor[i] = Floor_DecodeFrame(ctx, &ctx->floors[floorIdx], i);
hasResidue[i] = hasFloor[i]; hasResidue[i] = hasFloor[i];
} }
/* non-zero vector propogate */ /* non-zero vector propogate */
for (i = 0; i < mapping->CouplingSteps; i++) { for (i = 0; i < mapping->couplingSteps; i++) {
magChannel = mapping->Magnitude[i]; magChannel = mapping->magnitude[i];
angChannel = mapping->Angle[i]; angChannel = mapping->angle[i];
if (hasResidue[magChannel] || hasResidue[angChannel]) { if (hasResidue[magChannel] || hasResidue[angChannel]) {
hasResidue[magChannel] = true; hasResidue[angChannel] = true; hasResidue[magChannel] = true; hasResidue[angChannel] = true;
@ -1408,25 +1408,25 @@ cc_result Vorbis_DecodeFrame(struct VorbisState* ctx) {
} }
/* decode residue */ /* decode residue */
for (i = 0; i < mapping->Submaps; i++) { for (i = 0; i < mapping->submaps; i++) {
ch = 0; ch = 0;
/* map residue data to actual channel data */ /* map residue data to actual channel data */
for (j = 0; j < ctx->channels; j++) { for (j = 0; j < ctx->channels; j++) {
if (mapping->Mux[j] != i) continue; if (mapping->mux[j] != i) continue;
doNotDecode[ch] = !hasResidue[j]; doNotDecode[ch] = !hasResidue[j];
data[ch] = ctx->curOutput[j]; data[ch] = ctx->curOutput[j];
ch++; ch++;
} }
residueIdx = mapping->FloorIdx[i]; residueIdx = mapping->floorIdx[i];
Residue_DecodeFrame(ctx, &ctx->residues[residueIdx], ch, doNotDecode, data); Residue_DecodeFrame(ctx, &ctx->residues[residueIdx], ch, doNotDecode, data);
} }
/* inverse coupling */ /* inverse coupling */
for (i = mapping->CouplingSteps - 1; i >= 0; i--) { for (i = mapping->couplingSteps - 1; i >= 0; i--) {
magValues = ctx->curOutput[mapping->Magnitude[i]]; magValues = ctx->curOutput[mapping->magnitude[i]];
angValues = ctx->curOutput[mapping->Angle[i]]; angValues = ctx->curOutput[mapping->angle[i]];
for (j = 0; j < ctx->dataSize; j++) { for (j = 0; j < ctx->dataSize; j++) {
m = magValues[j]; a = angValues[j]; m = magValues[j]; a = angValues[j];
@ -1451,8 +1451,8 @@ cc_result Vorbis_DecodeFrame(struct VorbisState* ctx) {
for (i = 0; i < ctx->channels; i++) { for (i = 0; i < ctx->channels; i++) {
if (!hasFloor[i]) continue; if (!hasFloor[i]) continue;
submap = mapping->Mux[i]; submap = mapping->mux[i];
floorIdx = mapping->FloorIdx[submap]; floorIdx = mapping->floorIdx[submap];
Floor_Synthesis(ctx, &ctx->floors[floorIdx], i); Floor_Synthesis(ctx, &ctx->floors[floorIdx], i);
} }
@ -1464,7 +1464,7 @@ cc_result Vorbis_DecodeFrame(struct VorbisState* ctx) {
/* TODO: Do we actually need to zero data here (residue type 2 maybe) */ /* TODO: Do we actually need to zero data here (residue type 2 maybe) */
Mem_Set(tmp, 0, ctx->curBlockSize * sizeof(float)); Mem_Set(tmp, 0, ctx->curBlockSize * sizeof(float));
} else { } else {
imdct_calc(tmp, tmp, &ctx->imdct[mode->BlockSizeFlag]); imdct_calc(tmp, tmp, &ctx->imdct[mode->blockSizeFlag]);
/* defer windowing until output */ /* defer windowing until output */
} }
} }