zenilib: zenilib/jni/external/libvorbis/lib/floor0.c Source File

zenilib 0.5.3.0

- Main Page
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
floor0.c
Go to the documentation of this file.
1 /********************************************************************
2 * *
3 * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
4 * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
5 * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
6 * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
7 * *
8 * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009 *
9 * by the Xiph.Org Foundation http://www.xiph.org/ *
10 * *
11 ********************************************************************
12
13 function: floor backend 0 implementation
14 last mod: $Id: floor0.c 17558 2010-10-22 00:24:41Z tterribe $
15
16 ********************************************************************/
17
18 #include <stdlib.h>
19 #include <string.h>
20 #include <math.h>
21 #include <ogg/ogg.h>
22 #include "vorbis/codec.h"
23 #include "codec_internal.h"
24 #include "registry.h"
25 #include "lpc.h"
26 #include "lsp.h"
27 #include "codebook.h"
28 #include "scales.h"
29 #include "misc.h"
30 #include "os.h"
31
32 #include "misc.h"
33 #include <stdio.h>
34
35 typedef struct {
36 int ln;
37 int m;
38 int **linearmap;
39 int n[2];
40
41 vorbis_info_floor0 *vi;
42
43 long bits;
44 long frames;
45 } vorbis_look_floor0;
46
47
48 /***********************************************/
49
50 static void floor0_free_info(vorbis_info_floor *i){
51 vorbis_info_floor0 *info=(vorbis_info_floor0 *)i;
52 if(info){
53 memset(info,0,sizeof(*info));
54 _ogg_free(info);
55 }
56 }
57
58 static void floor0_free_look(vorbis_look_floor *i){
59 vorbis_look_floor0 *look=(vorbis_look_floor0 *)i;
60 if(look){
61
62 if(look->linearmap){
63
64 if(look->linearmap[0])_ogg_free(look->linearmap[0]);
65 if(look->linearmap[1])_ogg_free(look->linearmap[1]);
66
67 _ogg_free(look->linearmap);
68 }
69 memset(look,0,sizeof(*look));
70 _ogg_free(look);
71 }
72 }
73
74 static vorbis_info_floor *floor0_unpack (vorbis_info *vi,oggpack_buffer *opb){
75 codec_setup_info *ci=vi->codec_setup;
76 int j;
77
78 vorbis_info_floor0 *info=_ogg_malloc(sizeof(*info));
79 info->order=oggpack_read(opb,8);
80 info->rate=oggpack_read(opb,16);
81 info->barkmap=oggpack_read(opb,16);
82 info->ampbits=oggpack_read(opb,6);
83 info->ampdB=oggpack_read(opb,8);
84 info->numbooks=oggpack_read(opb,4)+1;
85
86 if(info->order<1)goto err_out;
87 if(info->rate<1)goto err_out;
88 if(info->barkmap<1)goto err_out;
89 if(info->numbooks<1)goto err_out;
90
91 for(j=0;j<info->numbooks;j++){
92 info->books[j]=oggpack_read(opb,8);
93 if(info->books[j]<0 || info->books[j]>=ci->books)goto err_out;
94 if(ci->book_param[info->books[j]]->maptype==0)goto err_out;
95 if(ci->book_param[info->books[j]]->dim<1)goto err_out;
96 }
97 return(info);
98
99 err_out:
100 floor0_free_info(info);
101 return(NULL);
102 }
103
104 /* initialize Bark scale and normalization lookups. We could do this
105 with static tables, but Vorbis allows a number of possible
106 combinations, so it's best to do it computationally.
107
108 The below is authoritative in terms of defining scale mapping.
109 Note that the scale depends on the sampling rate as well as the
110 linear block and mapping sizes */
111
112 static void floor0_map_lazy_init(vorbis_block *vb,
113 vorbis_info_floor *infoX,
114 vorbis_look_floor0 *look){
115 if(!look->linearmap[vb->W]){
116 vorbis_dsp_state *vd=vb->vd;
117 vorbis_info *vi=vd->vi;
118 codec_setup_info *ci=vi->codec_setup;
119 vorbis_info_floor0 *info=(vorbis_info_floor0 *)infoX;
120 int W=vb->W;
121 int n=ci->blocksizes[W]/2,j;
122
123 /* we choose a scaling constant so that:
124 floor(bark(rate/2-1)*C)=mapped-1
125 floor(bark(rate/2)*C)=mapped */
126 float scale=look->ln/toBARK(info->rate/2.f);
127
128 /* the mapping from a linear scale to a smaller bark scale is
129 straightforward. We do *not* make sure that the linear mapping
130 does not skip bark-scale bins; the decoder simply skips them and
131 the encoder may do what it wishes in filling them. They're
132 necessary in some mapping combinations to keep the scale spacing
133 accurate */
134 look->linearmap[W]=_ogg_malloc((n+1)*sizeof(**look->linearmap));
135 for(j=0;j<n;j++){
136 int val=floor( toBARK((info->rate/2.f)/n*j)
137 *scale); /* bark numbers represent band edges */
138 if(val>=look->ln)val=look->ln-1; /* guard against the approximation */
139 look->linearmap[W][j]=val;
140 }
141 look->linearmap[W][j]=-1;
142 look->n[W]=n;
143 }
144 }
145
146 static vorbis_look_floor *floor0_look(vorbis_dsp_state *vd,
147 vorbis_info_floor *i){
148 vorbis_info_floor0 *info=(vorbis_info_floor0 *)i;
149 vorbis_look_floor0 *look=_ogg_calloc(1,sizeof(*look));
150 look->m=info->order;
151 look->ln=info->barkmap;
152 look->vi=info;
153
154 look->linearmap=_ogg_calloc(2,sizeof(*look->linearmap));
155
156 return look;
157 }
158
159 static void *floor0_inverse1(vorbis_block *vb,vorbis_look_floor *i){
160 vorbis_look_floor0 *look=(vorbis_look_floor0 *)i;
161 vorbis_info_floor0 *info=look->vi;
162 int j,k;
163
164 int ampraw=oggpack_read(&vb->opb,info->ampbits);
165 if(ampraw>0){ /* also handles the -1 out of data case */
166 long maxval=(1<<info->ampbits)-1;
167 float amp=(float)ampraw/maxval*info->ampdB;
168 int booknum=oggpack_read(&vb->opb,_ilog(info->numbooks));
169
170 if(booknum!=-1 && booknum<info->numbooks){ /* be paranoid */
171 codec_setup_info *ci=vb->vd->vi->codec_setup;
172 codebook *b=ci->fullbooks+info->books[booknum];
173 float last=0.f;
174
175 /* the additional b->dim is a guard against any possible stack
176 smash; b->dim is provably more than we can overflow the
177 vector */
178 float *lsp=_vorbis_block_alloc(vb,sizeof(*lsp)*(look->m+b->dim+1));
179
180 for(j=0;j<look->m;j+=b->dim)
181 if(vorbis_book_decodev_set(b,lsp+j,&vb->opb,b->dim)==-1)goto eop;
182 for(j=0;j<look->m;){
183 for(k=0;k<b->dim;k++,j++)lsp[j]+=last;
184 last=lsp[j-1];
185 }
186
187 lsp[look->m]=amp;
188 return(lsp);
189 }
190 }
191 eop:
192 return(NULL);
193 }
194
195 static int floor0_inverse2(vorbis_block *vb,vorbis_look_floor *i,
196 void *memo,float *out){
197 vorbis_look_floor0 *look=(vorbis_look_floor0 *)i;
198 vorbis_info_floor0 *info=look->vi;
199
200 floor0_map_lazy_init(vb,info,look);
201
202 if(memo){
203 float *lsp=(float *)memo;
204 float amp=lsp[look->m];
205
206 /* take the coefficients back to a spectral envelope curve */
207 vorbis_lsp_to_curve(out,
208 look->linearmap[vb->W],
209 look->n[vb->W],
210 look->ln,
211 lsp,look->m,amp,(float)info->ampdB);
212 return(1);
213 }
214 memset(out,0,sizeof(*out)*look->n[vb->W]);
215 return(0);
216 }
217
218 /* export hooks */
219 const vorbis_func_floor floor0_exportbundle={
220 NULL,&floor0_unpack,&floor0_look,&floor0_free_info,
221 &floor0_free_look,&floor0_inverse1,&floor0_inverse2
222 };
vorbis_info_floor0::numbooks
int numbooks
Definition: backends.h:49
val
GLuint const GLfloat * val
Definition: glew.h:2715
floor0_map_lazy_init
static void floor0_map_lazy_init(vorbis_block *vb, vorbis_info_floor *infoX, vorbis_look_floor0 *look)
Definition: floor0.c:112
codebook::dim
long dim
Definition: codebook.h:59
vorbis_block::opb
oggpack_buffer opb
Definition: codec.h:91
misc.h
static_codebook::dim
long dim
Definition: codebook.h:37
NULL
#define NULL
Definition: ftobjs.h:61
codec_setup_info::book_param
static_codebook * book_param[256]
Definition: codec_internal.h:120
vorbis_info_floor
void vorbis_info_floor
Definition: codec_internal.h:54
floor0_unpack
static vorbis_info_floor * floor0_unpack(vorbis_info *vi, oggpack_buffer *opb)
Definition: floor0.c:74
codebook.h
k
int32_t k
Definition: e_log.c:102
codec_setup_info::books
int books
Definition: codec_internal.h:110
n
GLclampd n
Definition: glew.h:7287
vorbis_block::vd
vorbis_dsp_state * vd
Definition: codec.h:102
j
int32_t j
Definition: e_log.c:102
memset
#define memset
Definition: SDL_malloc.c:633
_ogg_free
#define _ogg_free
Definition: os_types.h:25
codec.h
vorbis_info_floor0::barkmap
long barkmap
Definition: backends.h:44
codec_internal.h
vorbis_block::W
long W
Definition: codec.h:94
floor0_free_look
static void floor0_free_look(vorbis_look_floor *i)
Definition: floor0.c:58
bits
#define bits
Definition: infblock.c:15
vorbis_info_floor0::books
int books[16]
Definition: backends.h:50
ogg.h
vorbis_dsp_state::vi
vorbis_info * vi
Definition: codec.h:61
lpc.h
vorbis_info::codec_setup
void * codec_setup
Definition: codec.h:53
vorbis_lsp_to_curve
void vorbis_lsp_to_curve(float *curve, int *map, int n, int ln, float *lsp, int m, float amp, float ampoffset)
Definition: lsp.c:248
vorbis_look_floor
void vorbis_look_floor
Definition: codec_internal.h:42
scales.h
codec_setup_info::blocksizes
long blocksizes[2]
Definition: codec_internal.h:99
toBARK
#define toBARK(n)
Definition: scales.h:79
os.h
floor0_exportbundle
const vorbis_func_floor floor0_exportbundle
Definition: floor0.c:219
codebook
Definition: codebook.h:58
oggpack_buffer
Definition: ogg.h:32
_ilog
int _ilog(unsigned int v)
Definition: sharedbook.c:29
floor
double floor(double x)
Definition: s_floor.c:40
vorbis_block
Definition: codec.h:88
vorbis_info_floor0::rate
long rate
Definition: backends.h:43
vorbis_info_floor0::ampdB
int ampdB
Definition: backends.h:47
scale
GLenum GLenum GLenum GLenum GLenum scale
Definition: glew.h:12632
static_codebook::maptype
int maptype
Definition: codebook.h:42
vi
XVisualInfo * vi
Definition: glewinfo_tail.c:221
_ogg_calloc
#define _ogg_calloc
Definition: os_types.h:23
floor0_look
static vorbis_look_floor * floor0_look(vorbis_dsp_state *vd, vorbis_info_floor *i)
Definition: floor0.c:146
codec_setup_info
Definition: codec_internal.h:94
String.h
b
GLdouble GLdouble GLdouble b
Definition: glew.h:8383
codec_setup_info::fullbooks
codebook * fullbooks
Definition: codec_internal.h:121
vorbis_func_floor
Definition: backends.h:30
floor0_inverse2
static int floor0_inverse2(vorbis_block *vb, vorbis_look_floor *i, void *memo, float *out)
Definition: floor0.c:195
i
int i
Definition: pngrutil.c:1377
floor0_inverse1
static void * floor0_inverse1(vorbis_block *vb, vorbis_look_floor *i)
Definition: floor0.c:159
vorbis_info_floor0::ampbits
int ampbits
Definition: backends.h:46
oggpack_read
long oggpack_read(oggpack_buffer *b, int bits)
Definition: bitwise.c:371
floor0_free_info
static void floor0_free_info(vorbis_info_floor *i)
Definition: floor0.c:50
vorbis_book_decodev_set
long vorbis_book_decodev_set(codebook *book, float *a, oggpack_buffer *b, int n)
Definition: codebook.c:434
vorbis_info_floor0::order
int order
Definition: backends.h:42
m
#define m(i, j)
_vorbis_block_alloc
void * _vorbis_block_alloc(vorbis_block *vb, long bytes)
Definition: block.c:113
lsp.h
registry.h
vorbis_info
Definition: codec.h:28
vorbis_info_floor0
Definition: backends.h:41
_ogg_malloc
#define _ogg_malloc
Definition: os_types.h:22
vorbis_dsp_state
Definition: codec.h:59