| backends.h |
this is exposed up here because we need it for static modes.
Lookups for each backend aren't exposed because there's no reason
to do so |
5151 |
| bitrate.h |
encode side bitrate tracking |
1963 |
| books |
|
|
| codebook.h |
This structure encapsulates huffman and VQ style encoding books; it
doesn't do anything specific to either.
valuelist/quantlist are nonNULL (and q_* significant) only if
there's entry->value mapping to be done.
If encode-side mapping must be done (and thus the entry needs to be
hunted), the auxiliary encode pointer will point to a decision
tree. This is true of both VQ and huffman, but is mostly useful
with VQ.
|
4958 |
| codec_internal.h |
this is a pointer into local storage |
5392 |
| envelope.h |
a bit less than short block |
2116 |
| highlevel.h |
bitrate management below all settable |
1840 |
| lookup.h |
|
1249 |
| lookup_data.h |
|
10036 |
| lpc.h |
simple linear scale LPC code |
1174 |
| lsp.h |
|
1182 |
| masking.h |
more detailed ATH; the bass if flat to save stressing the floor
overly for only a bin or two of savings. |
39455 |
| mdct.h |
#define MDCT_INTEGERIZED <- be warned there could be some hurt left here |
1955 |
| misc.h |
|
1988 |
| modes |
|
|
| os.h |
_V_IFDEFJAIL_H_ |
5176 |
| psy.h |
psychoacoustic setup ******************************************* |
4628 |
| registry.h |
|
1247 |
| scales.h |
MS Visual Studio doesn't have C99 inline keyword. |
2761 |
| smallft.h |
|
1218 |
| vorbis_analysis.c |
decides between modes, dispatches to the appropriate mapping. |
3088 |
| vorbis_bitrate.c |
compute bitrate tracking setup |
8478 |
| vorbis_block.c |
pcm accumulator examples (not exhaustive):
<-------------- lW ---------------->
<--------------- W ---------------->
: .....|..... _______________ |
: .''' | '''_--- | |\ |
:.....''' |_____--- '''......| | \_______|
:.................|__________________|_______|__|______|
|<------ Sl ------>| > Sr < |endW
|beginSl |endSl | |endSr
|beginW |endlW |beginSr
|< lW >|
<--------------- W ---------------->
| | .. ______________ |
| | ' `/ | ---_ |
|___.'___/`. | ---_____|
|_______|__|_______|_________________|
| >|Sl|< |<------ Sr ----->|endW
| | |endSl |beginSr |endSr
|beginW | |endlW
mult[0] |beginSl mult[n]
<-------------- lW ----------------->
|<--W-->|
: .............. ___ | |
: .''' |`/ \ | |
:.....''' |/`....\|...|
:.........................|___|___|___|
|Sl |Sr |endW
| | |endSr
| |beginSr
| |endSl
|beginSl
|beginW
|
30592 |
| vorbis_codebook.c |
packs the given codebook into the bitstream ************************* |
13408 |
| vorbis_envelope.c |
not random |
10672 |
| vorbis_floor0.c |
/
static void floor0_free_info(vorbis_info_floor *i){
vorbis_info_floor0 *info=(vorbis_info_floor0 *)i;
if(info){
memset(info,0,sizeof(*info));
_ogg_free(info);
}
}
static void floor0_free_look(vorbis_look_floor *i){
vorbis_look_floor0 *look=(vorbis_look_floor0 *)i;
if(look){
if(look->linearmap){
if(look->linearmap[0])_ogg_free(look->linearmap[0]);
if(look->linearmap[1])_ogg_free(look->linearmap[1]);
_ogg_free(look->linearmap);
}
memset(look,0,sizeof(*look));
_ogg_free(look);
}
}
static vorbis_info_floor *floor0_unpack (vorbis_info *vi,oggpack_buffer *opb){
codec_setup_info *ci=vi->codec_setup;
int j;
vorbis_info_floor0 *info=_ogg_malloc(sizeof(*info));
info->order=oggpack_read(opb,8);
info->rate=oggpack_read(opb,16);
info->barkmap=oggpack_read(opb,16);
info->ampbits=oggpack_read(opb,6);
info->ampdB=oggpack_read(opb,8);
info->numbooks=oggpack_read(opb,4)+1;
if(info->order<1)goto err_out;
if(info->rate<1)goto err_out;
if(info->barkmap<1)goto err_out;
if(info->numbooks<1)goto err_out;
for(j=0;j<info->numbooks;j++){
info->books[j]=oggpack_read(opb,8);
if(info->books[j]<0 || info->books[j]>=ci->books)goto err_out;
if(ci->book_param[info->books[j]]->maptype==0)goto err_out;
if(ci->book_param[info->books[j]]->dim<1)goto err_out;
}
return(info);
err_out:
floor0_free_info(info);
return(NULL);
}
/* initialize Bark scale and normalization lookups. We could do this
with static tables, but Vorbis allows a number of possible
combinations, so it's best to do it computationally.
The below is authoritative in terms of defining scale mapping.
Note that the scale depends on the sampling rate as well as the
linear block and mapping sizes |
6889 |
| vorbis_floor1.c |
floor 1 fixed at -140dB to 0dB range |
30922 |
| vorbis_info.c |
general handling of the header and the vorbis_info structure (and
substructures) |
19866 |
| vorbis_lookup.c |
interpolated lookup based cos function, domain 0 to PI only |
3246 |
| vorbis_lpc.c |
Some of these routines (autocorrelator, LPC coefficient estimator)
are derived from code written by Jutta Degener and Carsten Bormann;
thus we include their copyright below. The entirety of this file
is freely redistributable on the condition that both of these
copyright notices are preserved without modification. |
4486 |
| vorbis_lsp.c |
Note that the lpc-lsp conversion finds the roots of polynomial with
an iterative root polisher (CACM algorithm 283). It *is* possible
to confuse this algorithm into not converging; that should only
happen with absurdly closely spaced roots (very sharp peaks in the
LPC f response) which in turn should be impossible in our use of
the code. If this *does* happen anyway, it's a bug in the floor
finder; find the cause of the confusion (probably a single bin
spike or accidental near-float-limit resolution problems) and
correct it. |
12599 |
| vorbis_mapping0.c |
simplistic, wasteful way of doing this (unique lookup for each
mode/submapping); there should be a central repository for
identical lookups. That will require minor work, so I'm putting it
off as low priority.
Why a lookup for each backend in a given mode? Because the
blocksize is set by the mode, and low backend lookups may require
parameters from other areas of the mode/mapping |
28765 |
| vorbis_mdct.c |
this can also be run as an integer transform by uncommenting a
define in mdct.h; the integerization is a first pass and although
it's likely stable for Vorbis, the dynamic range is constrained and
roundoff isn't done (so it's noisy). Consider it functional, but
only a starting point. There's no point on a machine with an FPU |
15493 |
| vorbis_psy.c |
we add back in the ATH to avoid low level curves falling off to
-infinity and unnecessarily cutting off high level curves in the
curve limiting (last step). |
35900 |
| vorbis_registry.c |
seems like major overkill now; the backend numbers will grow into
the infrastructure soon enough |
1772 |
| vorbis_res0.c |
Slow, slow, slow, simpleminded and did I mention it was slow? The
encode/decode loops are coded for clarity and performance is not
yet even a nagging little idea lurking in the shadows. Oh and BTW,
it's slow. |
24915 |
| vorbis_sharedbook.c |
pack/unpack helpers ***************************************** |
17806 |
| vorbis_smallft.c |
FFT implementation from OggSquish, minus cosine transforms,
minus all but radix 2/4 case. In Vorbis we only need this
cut-down version.
To do more than just power-of-two sized vectors, see the full
version I wrote for NetLib.
Note that the packing is a little strange; rather than the FFT r/i
packing following R_0, I_n, R_1, I_1, R_2, I_2 ... R_n-1, I_n-1,
it follows R_0, R_1, I_1, R_2, I_2 ... R_n-1, I_n-1, I_n like the
FORTRAN version
|
22185 |
| vorbis_synthesis.c |
first things first. Make sure decode is ready |
5180 |
| vorbis_window.c |
|
128646 |
| vorbisenc.c |
careful with this; it's using static array sizing to make managing
all the modes a little less annoying. If we use a residue backend
with > 12 partition types, or a different division of iteration,
this needs to be updated. |
39310 |
| window.h |
|
1086 |