mirror of
https://github.com/vgmstream/vgmstream.git
synced 2024-12-21 10:55:53 +01:00
1168 lines
40 KiB
C
1168 lines
40 KiB
C
#include "../vgmstream.h"
|
|
#ifdef VGM_USE_VORBIS
|
|
#include "wwise_vorbis_utils.h"
|
|
|
|
#define WWISE_VORBIS_USE_PRECOMPILED_WVC 1 /* if enabled vgmstream weights ~150kb more but doesn't need external .wvc packets */
|
|
|
|
#if WWISE_VORBIS_USE_PRECOMPILED_WVC
|
|
#include "wwise_vorbis_data.h"
|
|
#endif
|
|
|
|
|
|
/* **************************************************************************** */
|
|
/* DEFS */
|
|
/* **************************************************************************** */
|
|
|
|
/* A internal struct to pass around and simulate a bitstream.
|
|
* Mainly to keep code cleaner and somewhat closer to ww2ogg */
|
|
typedef struct {
|
|
uint8_t * buf; /* buffer to read/write*/
|
|
size_t bufsize; /* max size of the buffer */
|
|
off_t b_off; /* current offset in bits inside the buffer */
|
|
} ww_stream;
|
|
|
|
static int generate_vorbis_packet(ww_stream * ow, ww_stream * iw, STREAMFILE *streamFile, off_t offset, vorbis_codec_data * data, int big_endian);
|
|
static int generate_vorbis_setup(ww_stream * ow, ww_stream * iw, vorbis_codec_data * data, int channels, size_t packet_size, STREAMFILE *streamFile);
|
|
|
|
static int codebook_library_copy(ww_stream * ow, ww_stream * iw);
|
|
static int codebook_library_rebuild(ww_stream * ow, ww_stream * iw, size_t cb_size, STREAMFILE *streamFile);
|
|
static int codebook_library_rebuild_by_id(ww_stream * ow, uint32_t codebook_id, wwise_setup_type setup_type, STREAMFILE *streamFile);
|
|
static int tremor_ilog(unsigned int v);
|
|
static unsigned int tremor_book_maptype1_quantvals(unsigned int entries, unsigned int dimensions);
|
|
|
|
static int load_wvc(uint8_t * ibuf, size_t ibufsize, uint32_t codebook_id, wwise_setup_type setup_type, STREAMFILE *streamFile);
|
|
static int load_wvc_file(uint8_t * buf, size_t bufsize, uint32_t codebook_id, STREAMFILE *streamFile);
|
|
static int load_wvc_array(uint8_t * buf, size_t bufsize, uint32_t codebook_id, wwise_setup_type setup_type);
|
|
|
|
static int r_bits(ww_stream * iw, int num_bits, uint32_t * value);
|
|
static int w_bits(ww_stream * ow, int num_bits, uint32_t value);
|
|
|
|
|
|
/* **************************************************************************** */
|
|
/* EXTERNAL API */
|
|
/* **************************************************************************** */
|
|
|
|
/* loads info from a wwise packet header */
|
|
int wwise_vorbis_get_header(STREAMFILE *streamFile, off_t offset, wwise_header_type header_type, int * granulepos, size_t * packet_size, int big_endian) {
|
|
int32_t (*read_32bit)(off_t,STREAMFILE*) = big_endian ? read_32bitBE : read_32bitLE;
|
|
int16_t (*read_16bit)(off_t,STREAMFILE*) = big_endian ? read_16bitBE : read_16bitLE;
|
|
|
|
/* packet size doesn't include header size */
|
|
switch(header_type) {
|
|
case TYPE_8: /* size 4+4 */
|
|
*packet_size = (uint32_t)read_32bit(offset, streamFile);
|
|
*granulepos = read_32bit(offset+4, streamFile);
|
|
return 8;
|
|
|
|
case TYPE_6: /* size 4+2 */
|
|
*packet_size = (uint16_t)read_16bit(offset, streamFile);
|
|
*granulepos = read_32bit(offset+2, streamFile);
|
|
return 6;
|
|
|
|
case TYPE_2: /* size 2 */
|
|
*packet_size = (uint16_t)read_16bit(offset, streamFile);
|
|
*granulepos = 0; /* granule is an arbitrary unit so we could use offset instead; libvorbis has no actually need it actually */
|
|
return 2;
|
|
break;
|
|
default: /* ? */
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* Transforms a Wwise data packet into a real Vorbis one (depending on config) */
|
|
int wwise_vorbis_rebuild_packet(uint8_t * obuf, size_t obufsize, STREAMFILE *streamFile, off_t offset, vorbis_codec_data * data, int big_endian) {
|
|
ww_stream ow, iw;
|
|
int rc, granulepos;
|
|
size_t header_size, packet_size;
|
|
|
|
size_t ibufsize = 0x8000; /* arbitrary max size of a setup packet */
|
|
uint8_t ibuf[0x8000]; /* Wwise setup packet buffer */
|
|
if (obufsize < ibufsize) goto fail; /* arbitrary expected min */
|
|
|
|
header_size = wwise_vorbis_get_header(streamFile, offset, data->header_type, &granulepos, &packet_size, big_endian);
|
|
if (!header_size || packet_size > obufsize) goto fail;
|
|
|
|
/* load Wwise data into internal buffer */
|
|
if (read_streamfile(ibuf,offset+header_size,packet_size, streamFile)!=packet_size)
|
|
goto fail;
|
|
|
|
/* prepare helper structs */
|
|
ow.buf = obuf;
|
|
ow.bufsize = obufsize;
|
|
ow.b_off = 0 ;
|
|
|
|
iw.buf = ibuf;
|
|
iw.bufsize = ibufsize;
|
|
iw.b_off = 0;
|
|
|
|
rc = generate_vorbis_packet(&ow,&iw, streamFile,offset, data, big_endian);
|
|
if (!rc) goto fail;
|
|
|
|
if (ow.b_off % 8 != 0) {
|
|
VGM_LOG("Wwise Vorbis: didn't write exactly audio packet: 0x%lx + %li bits\n", ow.b_off / 8, ow.b_off % 8);
|
|
goto fail;
|
|
}
|
|
|
|
|
|
return ow.b_off / 8;
|
|
fail:
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* Transforms a Wwise setup packet into a real Vorbis one (depending on config). */
|
|
int wwise_vorbis_rebuild_setup(uint8_t * obuf, size_t obufsize, STREAMFILE *streamFile, off_t offset, vorbis_codec_data * data, int big_endian, int channels) {
|
|
ww_stream ow, iw;
|
|
int rc, granulepos;
|
|
size_t header_size, packet_size;
|
|
|
|
size_t ibufsize = 0x8000; /* arbitrary max size of a setup packet */
|
|
uint8_t ibuf[0x8000]; /* Wwise setup packet buffer */
|
|
if (obufsize < ibufsize) goto fail; /* arbitrary expected min */
|
|
|
|
/* read Wwise packet header */
|
|
header_size = wwise_vorbis_get_header(streamFile, offset, data->header_type, &granulepos, &packet_size, big_endian);
|
|
if (!header_size || packet_size > ibufsize) goto fail;
|
|
|
|
/* load Wwise setup into internal buffer */
|
|
if (read_streamfile(ibuf,offset+header_size,packet_size, streamFile)!=packet_size)
|
|
goto fail;
|
|
|
|
/* prepare helper structs */
|
|
ow.buf = obuf;
|
|
ow.bufsize = obufsize;
|
|
ow.b_off = 0;
|
|
|
|
iw.buf = ibuf;
|
|
iw.bufsize = ibufsize;
|
|
iw.b_off = 0;
|
|
|
|
rc = generate_vorbis_setup(&ow,&iw, data, channels, packet_size, streamFile);
|
|
if (!rc) goto fail;
|
|
|
|
if (ow.b_off % 8 != 0) {
|
|
VGM_LOG("Wwise Vorbis: didn't write exactly setup packet: 0x%lx + %li bits\n", ow.b_off / 8, ow.b_off % 8);
|
|
goto fail;
|
|
}
|
|
|
|
|
|
return ow.b_off / 8;
|
|
fail:
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* **************************************************************************** */
|
|
/* INTERNAL WW2OGG STUFF */
|
|
/* **************************************************************************** */
|
|
/* The following code was mostly converted from hcs's ww2ogg.
|
|
* Could be simplified but roughly tries to preserve the structure in case fixes have to be backported.
|
|
*
|
|
* Some validations are ommited (ex. read/write), as incorrect data should be rejected by libvorbis.
|
|
* To avoid GCC complaining all values are init to 0, and some that do need it are init again, for clarity.
|
|
* Reads/writes unsigned ints as most are bit values less than 32 and with no sign meaning.
|
|
*/
|
|
|
|
/* Copy packet as-is or rebuild first byte if mod_packets is used.
|
|
* (ref: https://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-720004.3) */
|
|
static int generate_vorbis_packet(ww_stream * ow, ww_stream * iw, STREAMFILE *streamFile, off_t offset, vorbis_codec_data * data, int big_endian) {
|
|
int i,granule;
|
|
size_t header_size, packet_size, data_size;
|
|
|
|
header_size = wwise_vorbis_get_header(streamFile,offset, data->header_type, &granule, &packet_size, big_endian);
|
|
if (!header_size || packet_size > iw->bufsize) goto fail;
|
|
|
|
data_size = get_streamfile_size(streamFile);//todo get external data_size
|
|
|
|
if (offset + header_size + packet_size > data_size) {
|
|
VGM_LOG("Wwise Vorbis: page header truncated\n");
|
|
goto fail;
|
|
}
|
|
|
|
/* this may happen in the first packet; maybe it's for the encoder delay but doesn't seem to affect libvorbis */
|
|
//VGM_ASSERT(granule < 0, "Wwise Vorbis: negative granule %i @ 0x%lx\n", granule, offset);
|
|
|
|
|
|
if (data->packet_type == MODIFIED) {
|
|
/* rebuild first bits of packet type and window info (for the i-MDCT) */
|
|
uint32_t packet_type = 0, mode_number = 0, remainder = 0;
|
|
|
|
if (!data->mode_blockflag) { /* config error */
|
|
VGM_LOG("Wwise Vorbis: didn't load mode_blockflag\n");
|
|
goto fail;
|
|
}
|
|
|
|
/* audio packet type */
|
|
packet_type = 0;
|
|
w_bits(ow, 1, packet_type);
|
|
|
|
/* collect this packet mode from the first byte */
|
|
r_bits(iw, data->mode_bits,&mode_number); /* max 6b */
|
|
w_bits(ow, data->mode_bits, mode_number);
|
|
r_bits(iw, 8-data->mode_bits,&remainder);
|
|
|
|
/* adjust window info */
|
|
if (data->mode_blockflag[mode_number]) {
|
|
/* long window: peek at next frame to find flags */
|
|
off_t next_offset = offset + header_size + packet_size;
|
|
uint32_t next_blockflag = 0, prev_window_type = 0, next_window_type = 0;
|
|
|
|
next_blockflag = 0;
|
|
/* check if more data / not eof */
|
|
if (next_offset + header_size <= data_size) {
|
|
size_t next_header_size, next_packet_size;
|
|
int next_granule;
|
|
|
|
next_header_size = wwise_vorbis_get_header(streamFile,next_offset, data->header_type, &next_granule, &next_packet_size, big_endian);
|
|
if (!next_header_size) goto fail;
|
|
|
|
if (next_packet_size > 0) {
|
|
/* get next first byte to read next_mode_number */
|
|
uint32_t next_mode_number;
|
|
uint8_t nbuf[1];
|
|
ww_stream nw;
|
|
nw.buf = nbuf;
|
|
nw.bufsize = 1;
|
|
nw.b_off = 0;
|
|
|
|
if (read_streamfile(nw.buf, next_offset + next_header_size, nw.bufsize, streamFile) != nw.bufsize)
|
|
goto fail;
|
|
|
|
r_bits(&nw, data->mode_bits,&next_mode_number); /* max 6b */
|
|
|
|
next_blockflag = data->mode_blockflag[next_mode_number];
|
|
}
|
|
}
|
|
|
|
prev_window_type = data->prev_blockflag;
|
|
w_bits(ow, 1, prev_window_type);
|
|
|
|
next_window_type = next_blockflag;
|
|
w_bits(ow, 1, next_window_type);
|
|
}
|
|
|
|
data->prev_blockflag = data->mode_blockflag[mode_number]; /* save for next packet */
|
|
|
|
w_bits(ow, 8-data->mode_bits, remainder); /* this *isn't* byte aligned (ex. could be 10 bits written) */
|
|
}
|
|
else {
|
|
/* normal packets: first byte unchanged */
|
|
uint32_t c = 0;
|
|
|
|
r_bits(iw, 8, &c);
|
|
w_bits(ow, 8, c);
|
|
}
|
|
|
|
|
|
/* remainder of packet (not byte-aligned when using mod_packets) */
|
|
for (i = 1; i < packet_size; i++) {
|
|
uint32_t c = 0;
|
|
|
|
r_bits(iw, 8, &c);
|
|
w_bits(ow, 8, c);
|
|
}
|
|
|
|
/* remove trailing garbage bits */
|
|
if (ow->b_off % 8 != 0) {
|
|
uint32_t padding = 0;
|
|
int padding_bits = 8 - (ow->b_off % 8);
|
|
|
|
w_bits(ow, padding_bits, padding);
|
|
}
|
|
|
|
|
|
return 1;
|
|
fail:
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* Rebuild a Wwise setup (simplified with removed stuff), recreating all six setup parts.
|
|
* (ref: https://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-650004.2.4) */
|
|
static int generate_vorbis_setup(ww_stream * ow, ww_stream * iw, vorbis_codec_data * data, int channels, size_t packet_size, STREAMFILE *streamFile) {
|
|
int i,j,k;
|
|
uint32_t codebook_count = 0, floor_count = 0, residue_count = 0;
|
|
uint32_t codebook_count_less1 = 0;
|
|
uint32_t time_count_less1 = 0, dummy_time_value = 0;
|
|
|
|
|
|
/* packet header */
|
|
put_8bit(ow->buf+0x00, 0x05); /* packet_type (setup) */
|
|
memcpy (ow->buf+0x01, "vorbis", 6); /* id */
|
|
ow->b_off += (1+6) * 8; /* bit offset of output (Vorbis) setup, after fake type + id */
|
|
|
|
|
|
/* Codebooks */
|
|
r_bits(iw, 8,&codebook_count_less1);
|
|
w_bits(ow, 8, codebook_count_less1);
|
|
codebook_count = codebook_count_less1 + 1;
|
|
|
|
if (data->setup_type == FULL_SETUP) {
|
|
/* rebuild Wwise codebooks: untouched */
|
|
for (i = 0; i < codebook_count; i++) {
|
|
if(!codebook_library_copy(ow, iw)) goto fail;
|
|
}
|
|
}
|
|
else if (data->setup_type == INLINE_CODEBOOKS) {
|
|
/* rebuild Wwise codebooks: inline in simplified format */
|
|
for (i = 0; i < codebook_count; i++) {
|
|
if(!codebook_library_rebuild(ow, iw, 0, streamFile)) goto fail;
|
|
}
|
|
}
|
|
else {
|
|
/* rebuild Wwise codebooks: external (referenced by id) in simplified format */
|
|
for (i = 0; i < codebook_count; i++) {
|
|
int rc;
|
|
uint32_t codebook_id = 0;
|
|
|
|
r_bits(iw, 10,&codebook_id);
|
|
|
|
rc = codebook_library_rebuild_by_id(ow, codebook_id, data->setup_type, streamFile);
|
|
if (!rc) goto fail;
|
|
}
|
|
}
|
|
|
|
|
|
/* Time domain transforms */
|
|
time_count_less1 = 0;
|
|
w_bits(ow, 6, time_count_less1);
|
|
dummy_time_value = 0;
|
|
w_bits(ow, 16, dummy_time_value);
|
|
|
|
|
|
if (data->setup_type == FULL_SETUP) {
|
|
/* rest of setup is untouched, copy bits */
|
|
uint32_t bitly = 0;
|
|
uint32_t total_bits_read = iw->b_off;
|
|
uint32_t setup_packet_size_bits = packet_size*8;
|
|
|
|
while (total_bits_read < setup_packet_size_bits) {
|
|
r_bits(iw, 1,&bitly);
|
|
w_bits(ow, 1, bitly);
|
|
total_bits_read = iw->b_off;
|
|
}
|
|
}
|
|
else {
|
|
/* rest of setup is altered, reconstruct */
|
|
uint32_t floor_count_less1 = 0, floor1_multiplier_less1 = 0, rangebits = 0;
|
|
uint32_t residue_count_less1 = 0;
|
|
uint32_t mapping_count_less1 = 0, mapping_count = 0;
|
|
uint32_t mode_count_less1 = 0, mode_count = 0;
|
|
|
|
|
|
/* Floors */
|
|
r_bits(iw, 6,&floor_count_less1);
|
|
w_bits(ow, 6, floor_count_less1);
|
|
floor_count = floor_count_less1 + 1;
|
|
|
|
for (i = 0; i < floor_count; i++) {
|
|
uint32_t floor_type = 0, floor1_partitions = 0;
|
|
uint32_t maximum_class = 0;
|
|
uint32_t floor1_partition_class_list[32]; /* max 5b */
|
|
uint32_t floor1_class_dimensions_list[16+1]; /* max 4b+1 */
|
|
|
|
// Always floor type 1
|
|
floor_type = 1;
|
|
w_bits(ow, 16, floor_type);
|
|
|
|
r_bits(iw, 5,&floor1_partitions);
|
|
w_bits(ow, 5, floor1_partitions);
|
|
|
|
memset(floor1_partition_class_list, 0, sizeof(uint32_t)*32);
|
|
|
|
maximum_class = 0;
|
|
for (j = 0; j < floor1_partitions; j++) {
|
|
uint32_t floor1_partition_class = 0;
|
|
|
|
r_bits(iw, 4,&floor1_partition_class);
|
|
w_bits(ow, 4, floor1_partition_class);
|
|
|
|
floor1_partition_class_list[j] = floor1_partition_class;
|
|
|
|
if (floor1_partition_class > maximum_class)
|
|
maximum_class = floor1_partition_class;
|
|
}
|
|
|
|
memset(floor1_class_dimensions_list, 0, sizeof(uint32_t)*(16+1));
|
|
|
|
for (j = 0; j <= maximum_class; j++) {
|
|
uint32_t class_dimensions_less1 = 0, class_subclasses = 0;
|
|
|
|
r_bits(iw, 3,&class_dimensions_less1);
|
|
w_bits(ow, 3, class_dimensions_less1);
|
|
|
|
floor1_class_dimensions_list[j] = class_dimensions_less1 + 1;
|
|
|
|
r_bits(iw, 2,&class_subclasses);
|
|
w_bits(ow, 2, class_subclasses);
|
|
|
|
if (0 != class_subclasses) {
|
|
uint32_t masterbook = 0;
|
|
|
|
r_bits(iw, 8,&masterbook);
|
|
w_bits(ow, 8, masterbook);
|
|
|
|
if (masterbook >= codebook_count) {
|
|
VGM_LOG("Wwise Vorbis: invalid floor1 masterbook\n");
|
|
goto fail;
|
|
}
|
|
}
|
|
|
|
for (k = 0; k < (1U<<class_subclasses); k++) {
|
|
uint32_t subclass_book_plus1 = 0;
|
|
int subclass_book = 0; /* this MUST be int */
|
|
|
|
r_bits(iw, 8,&subclass_book_plus1);
|
|
w_bits(ow, 8, subclass_book_plus1);
|
|
|
|
subclass_book = subclass_book_plus1 - 1;
|
|
if (subclass_book >= 0 && subclass_book >= codebook_count) {
|
|
VGM_LOG("Wwise Vorbis: invalid floor1 subclass book\n");
|
|
goto fail;
|
|
}
|
|
}
|
|
}
|
|
|
|
r_bits(iw, 2,&floor1_multiplier_less1);
|
|
w_bits(ow, 2, floor1_multiplier_less1);
|
|
|
|
r_bits(iw, 4,&rangebits);
|
|
w_bits(ow, 4, rangebits);
|
|
|
|
for (j = 0; j < floor1_partitions; j++) {
|
|
uint32_t current_class_number = 0;
|
|
|
|
current_class_number = floor1_partition_class_list[j];
|
|
for (k = 0; k < floor1_class_dimensions_list[current_class_number]; k++) {
|
|
uint32_t X = 0; /* max 4b (15) */
|
|
|
|
r_bits(iw, rangebits,&X);
|
|
w_bits(ow, rangebits, X);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* Residues */
|
|
r_bits(iw, 6,&residue_count_less1);
|
|
w_bits(ow, 6, residue_count_less1);
|
|
residue_count = residue_count_less1 + 1;
|
|
|
|
for (i = 0; i < residue_count; i++) {
|
|
uint32_t residue_type = 0, residue_classifications = 0;
|
|
uint32_t residue_begin = 0, residue_end = 0, residue_partition_size_less1 = 0, residue_classifications_less1 = 0, residue_classbook = 0;
|
|
uint32_t residue_cascade[64+1]; /* 6b +1 */
|
|
|
|
r_bits(iw, 2,&residue_type);
|
|
w_bits(ow, 16, residue_type); /* 2b to 16b */
|
|
|
|
if (residue_type > 2) {
|
|
VGM_LOG("Wwise Vorbis: invalid residue type\n");
|
|
goto fail;
|
|
}
|
|
|
|
r_bits(iw, 24,&residue_begin);
|
|
w_bits(ow, 24, residue_begin);
|
|
r_bits(iw, 24,&residue_end);
|
|
w_bits(ow, 24, residue_end);
|
|
r_bits(iw, 24,&residue_partition_size_less1);
|
|
w_bits(ow, 24, residue_partition_size_less1);
|
|
r_bits(iw, 6,&residue_classifications_less1);
|
|
w_bits(ow, 6, residue_classifications_less1);
|
|
r_bits(iw, 8,&residue_classbook);
|
|
w_bits(ow, 8, residue_classbook);
|
|
residue_classifications = residue_classifications_less1 + 1;
|
|
|
|
if (residue_classbook >= codebook_count) {
|
|
VGM_LOG("Wwise Vorbis: invalid residue classbook\n");
|
|
goto fail;
|
|
}
|
|
|
|
memset(residue_cascade, 0, sizeof(uint32_t)*(64+1));
|
|
|
|
for (j = 0; j < residue_classifications; j++) {
|
|
uint32_t high_bits = 0, low_bits = 0, bitflag = 0;
|
|
|
|
high_bits = 0;
|
|
|
|
r_bits(iw, 3,&low_bits);
|
|
w_bits(ow, 3, low_bits);
|
|
|
|
r_bits(iw, 1,&bitflag);
|
|
w_bits(ow, 1, bitflag);
|
|
if (bitflag) {
|
|
r_bits(iw, 5,&high_bits);
|
|
w_bits(ow, 5, high_bits);
|
|
}
|
|
|
|
residue_cascade[j] = high_bits * 8 + low_bits;
|
|
}
|
|
|
|
for (j = 0; j < residue_classifications; j++) {
|
|
for (k = 0; k < 8; k++) {
|
|
if (residue_cascade[j] & (1 << k)) {
|
|
uint32_t residue_book = 0;
|
|
|
|
r_bits(iw, 8,&residue_book);
|
|
w_bits(ow, 8, residue_book);
|
|
|
|
if (residue_book >= codebook_count) {
|
|
VGM_LOG("Wwise Vorbis: invalid residue book\n");
|
|
goto fail;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* Mappings */
|
|
r_bits(iw, 6,&mapping_count_less1);
|
|
w_bits(ow, 6, mapping_count_less1);
|
|
mapping_count = mapping_count_less1 + 1;
|
|
|
|
for (i = 0; i < mapping_count; i++) {
|
|
uint32_t mapping_type = 0, submaps_flag = 0, submaps = 0, square_polar_flag = 0;
|
|
uint32_t mapping_reserved = 0;
|
|
|
|
// always mapping type 0, the only one
|
|
mapping_type = 0;
|
|
w_bits(ow, 16, mapping_type);
|
|
|
|
r_bits(iw, 1,&submaps_flag);
|
|
w_bits(ow, 1, submaps_flag);
|
|
|
|
submaps = 1;
|
|
if (submaps_flag) {
|
|
uint32_t submaps_less1 = 0;
|
|
|
|
r_bits(iw, 4,&submaps_less1);
|
|
w_bits(ow, 4, submaps_less1);
|
|
submaps = submaps_less1 + 1;
|
|
}
|
|
|
|
r_bits(iw, 1,&square_polar_flag);
|
|
w_bits(ow, 1, square_polar_flag);
|
|
|
|
if (square_polar_flag) {
|
|
uint32_t coupling_steps_less1 = 0, coupling_steps = 0;
|
|
|
|
r_bits(iw, 8,&coupling_steps_less1);
|
|
w_bits(ow, 8, coupling_steps_less1);
|
|
coupling_steps = coupling_steps_less1 + 1;
|
|
|
|
for (j = 0; j < coupling_steps; j++) {
|
|
uint32_t magnitude = 0, angle = 0;
|
|
int magnitude_bits = tremor_ilog(channels-1);
|
|
int angle_bits = tremor_ilog(channels-1);
|
|
|
|
r_bits(iw, magnitude_bits,&magnitude);
|
|
w_bits(ow, magnitude_bits, magnitude);
|
|
r_bits(iw, angle_bits,&angle);
|
|
w_bits(ow, angle_bits, angle);
|
|
|
|
if (angle == magnitude || magnitude >= channels || angle >= channels) {
|
|
VGM_LOG("Wwise Vorbis: invalid coupling (angle=%i, mag=%i, ch=%i)\n", angle, magnitude,channels);
|
|
goto fail;
|
|
}
|
|
}
|
|
}
|
|
|
|
// a rare reserved field not removed by Ak!
|
|
r_bits(iw, 2,&mapping_reserved);
|
|
w_bits(ow, 2, mapping_reserved);
|
|
if (0 != mapping_reserved) {
|
|
VGM_LOG("Wwise Vorbis: mapping reserved field nonzero\n");
|
|
goto fail;
|
|
}
|
|
|
|
if (submaps > 1) {
|
|
for (j = 0; j < channels; j++) {
|
|
uint32_t mapping_mux = 0;
|
|
|
|
r_bits(iw, 4,&mapping_mux);
|
|
w_bits(ow, 4, mapping_mux);
|
|
if (mapping_mux >= submaps) {
|
|
VGM_LOG("Wwise Vorbis: mapping_mux >= submaps\n");
|
|
goto fail;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (j = 0; j < submaps; j++) {
|
|
uint32_t time_config = 0, floor_number = 0, residue_number = 0;
|
|
|
|
// Another! Unused time domain transform configuration placeholder!
|
|
r_bits(iw, 8,&time_config);
|
|
w_bits(ow, 8, time_config);
|
|
|
|
r_bits(iw, 8,&floor_number);
|
|
w_bits(ow, 8, floor_number);
|
|
if (floor_number >= floor_count) {
|
|
VGM_LOG("Wwise Vorbis: invalid floor mapping\n");
|
|
goto fail;
|
|
}
|
|
|
|
r_bits(iw, 8,&residue_number);
|
|
w_bits(ow, 8, residue_number);
|
|
if (residue_number >= residue_count) {
|
|
VGM_LOG("Wwise Vorbis: invalid residue mapping\n");
|
|
goto fail;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* Modes */
|
|
r_bits(iw, 6,&mode_count_less1);
|
|
w_bits(ow, 6, mode_count_less1);
|
|
mode_count = mode_count_less1 + 1;
|
|
|
|
memset(data->mode_blockflag, 0, sizeof(uint8_t)*(64+1)); /* up to max mode_count */
|
|
data->mode_bits = tremor_ilog(mode_count-1); /* for mod_packets */
|
|
|
|
for (i = 0; i < mode_count; i++) {
|
|
uint32_t block_flag = 0, windowtype = 0, transformtype = 0, mapping = 0;
|
|
|
|
r_bits(iw, 1,&block_flag);
|
|
w_bits(ow, 1, block_flag);
|
|
|
|
data->mode_blockflag[i] = (block_flag != 0); /* for mod_packets */
|
|
|
|
windowtype = 0;
|
|
transformtype = 0;
|
|
w_bits(ow, 16, windowtype);
|
|
w_bits(ow, 16, transformtype);
|
|
|
|
r_bits(iw, 8,&mapping);
|
|
w_bits(ow, 8, mapping);
|
|
if (mapping >= mapping_count) {
|
|
VGM_LOG("Wwise Vorbis: invalid mode mapping\n");
|
|
goto fail;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* end flag */
|
|
{
|
|
uint32_t framing = 0;
|
|
|
|
framing = 1;
|
|
w_bits(ow, 1, framing);
|
|
}
|
|
|
|
/* remove trailing garbage bits */
|
|
if (ow->b_off % 8 != 0) {
|
|
uint32_t padding = 0;
|
|
int padding_bits = 8 - (ow->b_off % 8);
|
|
|
|
w_bits(ow, padding_bits, padding);
|
|
}
|
|
|
|
|
|
return 1;
|
|
fail:
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* copies Vorbis codebooks (untouched, but size uncertain) */
|
|
static int codebook_library_copy(ww_stream * ow, ww_stream * iw) {
|
|
int i;
|
|
uint32_t id = 0, dimensions = 0, entries = 0;
|
|
uint32_t ordered = 0, lookup_type = 0;
|
|
|
|
r_bits(iw, 24,&id);
|
|
w_bits(ow, 24, id);
|
|
r_bits(iw, 16,&dimensions);
|
|
w_bits(ow, 16, dimensions);
|
|
r_bits(iw, 24,&entries);
|
|
w_bits(ow, 24, entries);
|
|
|
|
if (0x564342 != id) { /* "VCB" */
|
|
VGM_LOG("Wwise Vorbis: invalid codebook identifier\n");
|
|
goto fail;
|
|
}
|
|
|
|
/* codeword lengths */
|
|
r_bits(iw, 1,&ordered);
|
|
w_bits(ow, 1, ordered);
|
|
if (ordered) {
|
|
uint32_t initial_length = 0, current_entry = 0;
|
|
|
|
r_bits(iw, 5,&initial_length);
|
|
w_bits(ow, 5, initial_length);
|
|
|
|
current_entry = 0;
|
|
while (current_entry < entries) {
|
|
uint32_t number = 0;
|
|
int number_bits = tremor_ilog(entries-current_entry);
|
|
|
|
r_bits(iw, number_bits,&number);
|
|
w_bits(ow, number_bits, number);
|
|
current_entry += number;
|
|
}
|
|
if (current_entry > entries) {
|
|
VGM_LOG("Wwise Vorbis: current_entry out of range\n");
|
|
goto fail;
|
|
}
|
|
}
|
|
else {
|
|
uint32_t sparse = 0;
|
|
|
|
r_bits(iw, 1,&sparse);
|
|
w_bits(ow, 1, sparse);
|
|
|
|
for (i = 0; i < entries; i++) {
|
|
uint32_t present_bool = 0;
|
|
|
|
present_bool = 1;
|
|
if (sparse) {
|
|
uint32_t present = 0;
|
|
|
|
r_bits(iw, 1,&present);
|
|
w_bits(ow, 1, present);
|
|
|
|
present_bool = (0 != present);
|
|
}
|
|
|
|
if (present_bool) {
|
|
uint32_t codeword_length = 0;
|
|
|
|
r_bits(iw, 5,&codeword_length);
|
|
w_bits(ow, 5, codeword_length);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* lookup table */
|
|
r_bits(iw, 4,&lookup_type);
|
|
w_bits(ow, 4, lookup_type);
|
|
|
|
if (0 == lookup_type) {
|
|
//VGM_LOG("Wwise Vorbis: no lookup table\n");
|
|
}
|
|
else if (1 == lookup_type) {
|
|
//VGM_LOG("Wwise Vorbis: lookup type 1\n");
|
|
uint32_t quantvals = 0, min = 0, max = 0;
|
|
uint32_t value_length = 0, sequence_flag = 0;
|
|
|
|
r_bits(iw, 32,&min);
|
|
w_bits(ow, 32, min);
|
|
r_bits(iw, 32,&max);
|
|
w_bits(ow, 32, max);
|
|
r_bits(iw, 4,&value_length);
|
|
w_bits(ow, 4, value_length);
|
|
r_bits(iw, 1,&sequence_flag);
|
|
w_bits(ow, 1, sequence_flag);
|
|
|
|
quantvals = tremor_book_maptype1_quantvals(entries, dimensions);
|
|
for (i = 0; i < quantvals; i++) {
|
|
uint32_t val = 0, val_bits = 0;
|
|
val_bits = value_length+1;
|
|
|
|
r_bits(iw, val_bits,&val);
|
|
w_bits(ow, val_bits, val);
|
|
}
|
|
}
|
|
else if (2 == lookup_type) {
|
|
VGM_LOG("Wwise Vorbis: didn't expect lookup type 2\n");
|
|
goto fail;
|
|
}
|
|
else {
|
|
VGM_LOG("Wwise Vorbis: invalid lookup type\n");
|
|
goto fail;
|
|
}
|
|
|
|
|
|
return 1;
|
|
fail:
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* rebuilds a Wwise codebook into a Vorbis codebook */
|
|
static int codebook_library_rebuild(ww_stream * ow, ww_stream * iw, size_t cb_size, STREAMFILE *streamFile) {
|
|
int i;
|
|
uint32_t id = 0, dimensions = 0, entries = 0;
|
|
uint32_t ordered = 0, lookup_type = 0;
|
|
|
|
id = 0x564342; /* "VCB" */
|
|
|
|
w_bits(ow, 24, id);
|
|
r_bits(iw, 4,&dimensions);
|
|
w_bits(ow, 16, dimensions); /* 4 to 16 */
|
|
r_bits(iw, 14,&entries);
|
|
w_bits(ow, 24, entries); /* 14 to 24*/
|
|
|
|
/* codeword lengths */
|
|
r_bits(iw, 1,&ordered);
|
|
w_bits(ow, 1, ordered);
|
|
if (ordered) {
|
|
uint32_t initial_length = 0, current_entry = 0;
|
|
|
|
r_bits(iw, 5,&initial_length);
|
|
w_bits(ow, 5, initial_length);
|
|
|
|
current_entry = 0;
|
|
while (current_entry < entries) {
|
|
uint32_t number = 0;
|
|
int number_bits = tremor_ilog(entries-current_entry);
|
|
|
|
r_bits(iw, number_bits,&number);
|
|
w_bits(ow, number_bits, number);
|
|
current_entry += number;
|
|
}
|
|
if (current_entry > entries) {
|
|
VGM_LOG("Wwise Vorbis: current_entry out of range\n");
|
|
goto fail;
|
|
}
|
|
}
|
|
else {
|
|
uint32_t codeword_length_length = 0, sparse = 0;
|
|
|
|
r_bits(iw, 3,&codeword_length_length);
|
|
r_bits(iw, 1,&sparse);
|
|
w_bits(ow, 1, sparse);
|
|
|
|
if (0 == codeword_length_length || 5 < codeword_length_length) {
|
|
VGM_LOG("Wwise Vorbis: nonsense codeword length\n");
|
|
goto fail;
|
|
}
|
|
|
|
for (i = 0; i < entries; i++) {
|
|
uint32_t present_bool = 0;
|
|
|
|
present_bool = 1;
|
|
if (sparse) {
|
|
uint32_t present = 0;
|
|
|
|
r_bits(iw, 1,&present);
|
|
w_bits(ow, 1, present);
|
|
|
|
present_bool = (0 != present);
|
|
}
|
|
|
|
if (present_bool) {
|
|
uint32_t codeword_length = 0;
|
|
|
|
r_bits(iw, codeword_length_length,&codeword_length);
|
|
w_bits(ow, 5, codeword_length); /* max 7 (3b) to 5 */
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* lookup table */
|
|
r_bits(iw, 1,&lookup_type);
|
|
w_bits(ow, 4, lookup_type); /* 1 to 4 */
|
|
|
|
if (0 == lookup_type) {
|
|
//VGM_LOG("Wwise Vorbis: no lookup table\n");
|
|
}
|
|
else if (1 == lookup_type) {
|
|
//VGM_LOG("Wwise Vorbis: lookup type 1\n");
|
|
uint32_t quantvals = 0, min = 0, max = 0;
|
|
uint32_t value_length = 0, sequence_flag = 0;
|
|
|
|
r_bits(iw, 32,&min);
|
|
w_bits(ow, 32, min);
|
|
r_bits(iw, 32,&max);
|
|
w_bits(ow, 32, max);
|
|
r_bits(iw, 4,&value_length);
|
|
w_bits(ow, 4, value_length);
|
|
r_bits(iw, 1,&sequence_flag);
|
|
w_bits(ow, 1, sequence_flag);
|
|
|
|
quantvals = tremor_book_maptype1_quantvals(entries, dimensions);
|
|
for (i = 0; i < quantvals; i++) {
|
|
uint32_t val = 0, val_bits = 0;
|
|
val_bits = value_length+1;
|
|
|
|
r_bits(iw, val_bits,&val);
|
|
w_bits(ow, val_bits, val);
|
|
}
|
|
}
|
|
else if (2 == lookup_type) {
|
|
VGM_LOG("Wwise Vorbis: didn't expect lookup type 2\n");
|
|
goto fail;
|
|
}
|
|
else {
|
|
VGM_LOG("Wwise Vorbis: invalid lookup type\n");
|
|
goto fail;
|
|
}
|
|
|
|
|
|
/* check that we used exactly all bytes */
|
|
/* note: if all bits are used in the last byte there will be one extra 0 byte */
|
|
if ( 0 != cb_size && iw->b_off/8+1 != cb_size ) {
|
|
VGM_LOG("Wwise Vorbis: codebook size mistach (expected 0x%x, wrote 0x%lx)\n", cb_size, iw->b_off/8+1);
|
|
goto fail;
|
|
}
|
|
|
|
return 1;
|
|
fail:
|
|
return 0;
|
|
}
|
|
|
|
/* rebuilds an external Wwise codebook referenced by id to a Vorbis codebook */
|
|
static int codebook_library_rebuild_by_id(ww_stream * ow, uint32_t codebook_id, wwise_setup_type setup_type, STREAMFILE *streamFile) {
|
|
size_t ibufsize = 0x8000; /* arbitrary max size of a codebook */
|
|
uint8_t ibuf[0x8000]; /* Wwise codebook buffer */
|
|
size_t cb_size;
|
|
ww_stream iw;
|
|
|
|
cb_size = load_wvc(ibuf,ibufsize, codebook_id, setup_type, streamFile);
|
|
if (cb_size == 0) goto fail;
|
|
|
|
iw.buf = ibuf;
|
|
iw.bufsize = ibufsize;
|
|
iw.b_off = 0;
|
|
|
|
return codebook_library_rebuild(ow, &iw, cb_size, streamFile);
|
|
fail:
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* fixed-point ilog from Xiph's Tremor */
|
|
static int tremor_ilog(unsigned int v) {
|
|
int ret=0;
|
|
while(v){
|
|
ret++;
|
|
v>>=1;
|
|
}
|
|
return(ret);
|
|
}
|
|
/* quantvals-something from Xiph's Tremor */
|
|
static unsigned int tremor_book_maptype1_quantvals(unsigned int entries, unsigned int dimensions) {
|
|
/* get us a starting hint, we'll polish it below */
|
|
int bits=tremor_ilog(entries);
|
|
int vals=entries>>((bits-1)*(dimensions-1)/dimensions);
|
|
|
|
while(1){
|
|
unsigned long acc=1;
|
|
unsigned long acc1=1;
|
|
unsigned int i;
|
|
for(i=0;i<dimensions;i++){
|
|
acc*=vals;
|
|
acc1*=vals+1;
|
|
}
|
|
if(acc<=entries && acc1>entries){
|
|
return(vals);
|
|
}else{
|
|
if(acc>entries){
|
|
vals--;
|
|
}else{
|
|
vals++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* **************************************************************************** */
|
|
/* INTERNAL UTILS */
|
|
/* **************************************************************************** */
|
|
|
|
/* loads an external Wwise Vorbis Codebooks file (wvc) referenced by ID and returns size */
|
|
static int load_wvc(uint8_t * ibuf, size_t ibufsize, uint32_t codebook_id, wwise_setup_type setup_type, STREAMFILE *streamFile) {
|
|
size_t bytes;
|
|
|
|
/* try to load from external file (ignoring type, just use file if found) */
|
|
bytes = load_wvc_file(ibuf, ibufsize, codebook_id, streamFile);
|
|
if (bytes)
|
|
return bytes;
|
|
|
|
/* try to locate from the precompiled list */
|
|
bytes = load_wvc_array(ibuf, ibufsize, codebook_id, setup_type);
|
|
if (bytes)
|
|
return bytes;
|
|
|
|
/* not found */
|
|
VGM_LOG("Wwise Vorbis: codebook_id %04x not found\n", codebook_id);
|
|
return 0;
|
|
}
|
|
|
|
static int load_wvc_file(uint8_t * buf, size_t bufsize, uint32_t codebook_id, STREAMFILE *streamFile) {
|
|
STREAMFILE * streamFileWvc = NULL;
|
|
size_t wvc_size = 0;
|
|
|
|
{
|
|
char setupname[PATH_LIMIT];
|
|
char pathname[PATH_LIMIT];
|
|
char *path;
|
|
|
|
/* read "(dir/).wvc" */
|
|
streamFile->get_name(streamFile,pathname,sizeof(pathname));
|
|
path = strrchr(pathname,DIR_SEPARATOR);
|
|
if (path)
|
|
*(path+1) = '\0';
|
|
else
|
|
pathname[0] = '\0';
|
|
|
|
snprintf(setupname,PATH_LIMIT,"%s.wvc", pathname);
|
|
streamFileWvc = streamFile->open(streamFile,setupname,STREAMFILE_DEFAULT_BUFFER_SIZE);
|
|
if (!streamFileWvc) goto fail;
|
|
|
|
wvc_size = streamFileWvc->get_size(streamFileWvc);
|
|
}
|
|
|
|
/* find codebook and copy to buffer */
|
|
{
|
|
off_t table_start, codebook_offset;
|
|
size_t codebook_size;
|
|
int codebook_count;
|
|
|
|
/* at the end of the WVC is an offset table, and we need to find codebook id (number) offset */
|
|
table_start = read_32bitLE(wvc_size - 4, streamFileWvc); /* last offset */
|
|
codebook_count = ((wvc_size - table_start) / 4) - 1;
|
|
if (table_start > wvc_size || codebook_id >= codebook_count) goto fail;
|
|
|
|
codebook_offset = read_32bitLE(table_start + codebook_id*4, streamFileWvc);
|
|
codebook_size = read_32bitLE(table_start + codebook_id*4 + 4, streamFileWvc) - codebook_offset;
|
|
if (codebook_size > bufsize) goto fail;
|
|
|
|
if (read_streamfile(buf, codebook_offset, codebook_size, streamFileWvc) != codebook_size)
|
|
goto fail;
|
|
streamFileWvc->close(streamFileWvc);
|
|
|
|
return codebook_size;
|
|
}
|
|
|
|
|
|
fail:
|
|
if (streamFileWvc) streamFileWvc->close(streamFileWvc);
|
|
return 0;
|
|
}
|
|
|
|
static int load_wvc_array(uint8_t * buf, size_t bufsize, uint32_t codebook_id, wwise_setup_type setup_type) {
|
|
#if WWISE_VORBIS_USE_PRECOMPILED_WVC
|
|
|
|
/* get pointer to array */
|
|
{
|
|
int i, list_length;
|
|
const wvc_info * wvc_list;
|
|
|
|
switch (setup_type) {
|
|
case EXTERNAL_CODEBOOKS:
|
|
wvc_list = wvc_list_standard;
|
|
list_length = sizeof(wvc_list_standard) / sizeof(wvc_info);
|
|
break;
|
|
case AOTUV603_CODEBOOKS:
|
|
wvc_list = wvc_list_aotuv603;
|
|
list_length = sizeof(wvc_list_standard) / sizeof(wvc_info);
|
|
break;
|
|
default:
|
|
goto fail;
|
|
}
|
|
|
|
for (i=0; i < list_length; i++) {
|
|
if (wvc_list[i].id == codebook_id) {
|
|
if (wvc_list[i].size > bufsize) goto fail;
|
|
/* found: copy data as-is */
|
|
memcpy(buf,wvc_list[i].codebook, wvc_list[i].size);
|
|
return wvc_list[i].size;
|
|
}
|
|
}
|
|
}
|
|
|
|
// this can be used if the lists contained a 1:1 dump of the codebook files
|
|
#if 0
|
|
if (wvc == NULL) goto fail;
|
|
/* find codebook and copy to buffer */
|
|
{
|
|
off_t table_start, codebook_offset;
|
|
size_t codebook_size;
|
|
int codebook_count;
|
|
|
|
/* at the end of the WVC is an offset table, and we need to find codebook id (number) offset */
|
|
table_start = get_32bitLE(wvc + wvc_size - 4); /* last offset */
|
|
codebook_count = ((wvc_size - table_start) / 4) - 1;
|
|
if (codebook_id >= codebook_count) goto fail;
|
|
|
|
codebook_offset = get_32bitLE(wvc + table_start + codebook_id*4);
|
|
codebook_size = get_32bitLE(wvc + table_start + codebook_id*4 + 4) - codebook_offset;
|
|
if (codebook_size > bufsize) goto fail;
|
|
|
|
memcpy(buf, wvc+codebook_offset, codebook_size);
|
|
|
|
return codebook_size;
|
|
}
|
|
#endif
|
|
|
|
fail:
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
/* ********************************************* */
|
|
|
|
/* Read bits (max 32) from buf and update the bit offset. Vorbis packs values in LSB order and byte by byte.
|
|
* (ex. from 2 bytes 00100111 00000001 we can could read 4b=0111 and 6b=010010, 6b=remainder (second value is split into the 2nd byte) */
|
|
static int r_bits(ww_stream * iw, int num_bits, uint32_t * value) {
|
|
off_t off, pos;
|
|
int i, bit_buf, bit_val;
|
|
if (num_bits == 0) return 1;
|
|
if (num_bits > 32 || num_bits < 0 || iw->b_off + num_bits > iw->bufsize*8) goto fail;
|
|
|
|
*value = 0; /* set all bits to 0 */
|
|
off = iw->b_off / 8; /* byte offset */
|
|
pos = iw->b_off % 8; /* bit sub-offset */
|
|
for (i = 0; i < num_bits; i++) {
|
|
bit_buf = (1U << pos) & 0xFF; /* bit check for buf */
|
|
bit_val = (1U << i); /* bit to set in value */
|
|
|
|
if (iw->buf[off] & bit_buf) /* is bit in buf set? */
|
|
*value |= bit_val; /* set bit */
|
|
|
|
pos++; /* new byte starts */
|
|
if (pos%8 == 0) {
|
|
pos = 0;
|
|
off++;
|
|
}
|
|
}
|
|
|
|
iw->b_off += num_bits;
|
|
return 1;
|
|
fail:
|
|
return 0;
|
|
}
|
|
|
|
/* Write bits (max 32) to buf and update the bit offset. Vorbis packs values in LSB order and byte by byte.
|
|
* (ex. writing 1101011010 from b_off 2 we get 01101011 00001101 (value split, and 11 in the first byte skipped)*/
|
|
static int w_bits(ww_stream * ow, int num_bits, uint32_t value) {
|
|
off_t off, pos;
|
|
int i, bit_val, bit_buf;
|
|
if (num_bits == 0) return 1;
|
|
if (num_bits > 32 || num_bits < 0 || ow->b_off + num_bits > ow->bufsize*8) goto fail;
|
|
|
|
|
|
off = ow->b_off / 8; /* byte offset */
|
|
pos = ow->b_off % 8; /* bit sub-offset */
|
|
for (i = 0; i < num_bits; i++) {
|
|
bit_val = (1U << i); /* bit check for value */
|
|
bit_buf = (1U << pos) & 0xFF; /* bit to set in buf */
|
|
|
|
if (value & bit_val) /* is bit in val set? */
|
|
ow->buf[off] |= bit_buf; /* set bit */
|
|
else
|
|
ow->buf[off] &= ~bit_buf; /* unset bit */
|
|
|
|
pos++; /* new byte starts */
|
|
if (pos%8 == 0) {
|
|
pos = 0;
|
|
off++;
|
|
}
|
|
}
|
|
|
|
ow->b_off += num_bits;
|
|
return 1;
|
|
fail:
|
|
return 0;
|
|
}
|
|
|
|
#endif
|