1 /********************************************************************
2 * *
3 * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. *
4 * *
5 * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
6 * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
7 * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
8 * *
9 * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 *
10 * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ *
11 * *
12 ********************************************************************
13
14 function: residue backend 0, 1 and 2 implementation
15
16 ********************************************************************/
17
18 #include <stdlib.h>
19 #include <string.h>
20 #include <math.h>
21 #include "ogg.h"
22 #include "ivorbiscodec.h"
23 #include "codec_internal.h"
24 #include "registry.h"
25 #include "codebook.h"
26 #include "misc.h"
27 #include "os.h"
28 #include "block.h"
29
30 typedef struct {
31 vorbis_info_residue0 *info;
32 int map;
33
34 int parts;
35 int stages;
36 codebook *fullbooks;
37 codebook *phrasebook;
38 codebook ***partbooks;
39
40 int partvals;
41 int **decodemap;
42
43 } vorbis_look_residue0;
44
res0_free_info(vorbis_info_residue * i)45 void res0_free_info(vorbis_info_residue *i){
46 vorbis_info_residue0 *info=(vorbis_info_residue0 *)i;
47 if(info){
48 memset(info,0,sizeof(*info));
49 _ogg_free(info);
50 }
51 }
52
res0_free_look(vorbis_look_residue * i)53 void res0_free_look(vorbis_look_residue *i){
54 int j;
55 if(i){
56
57 vorbis_look_residue0 *look=(vorbis_look_residue0 *)i;
58
59 for(j=0;j<look->parts;j++)
60 if(look->partbooks[j])_ogg_free(look->partbooks[j]);
61 _ogg_free(look->partbooks);
62 for(j=0;j<look->partvals;j++)
63 _ogg_free(look->decodemap[j]);
64 _ogg_free(look->decodemap);
65
66 memset(look,0,sizeof(*look));
67 _ogg_free(look);
68 }
69 }
70
ilog(unsigned int v)71 static int ilog(unsigned int v){
72 int ret=0;
73 while(v){
74 ret++;
75 v>>=1;
76 }
77 return(ret);
78 }
79
icount(unsigned int v)80 static int icount(unsigned int v){
81 int ret=0;
82 while(v){
83 ret+=v&1;
84 v>>=1;
85 }
86 return(ret);
87 }
88
89 /* vorbis_info is for range checking */
res0_unpack(vorbis_info * vi,oggpack_buffer * opb)90 vorbis_info_residue *res0_unpack(vorbis_info *vi,oggpack_buffer *opb){
91 int j,acc=0;
92 vorbis_info_residue0 *info=(vorbis_info_residue0 *)_ogg_calloc(1,sizeof(*info));
93 codec_setup_info *ci=(codec_setup_info *)vi->codec_setup;
94
95 info->begin=oggpack_read(opb,24);
96 info->end=oggpack_read(opb,24);
97 info->grouping=oggpack_read(opb,24)+1;
98 info->partitions=oggpack_read(opb,6)+1;
99 info->groupbook=oggpack_read(opb,8);
100
101 for(j=0;j<info->partitions;j++){
102 int cascade=oggpack_read(opb,3);
103 if(oggpack_read(opb,1))
104 cascade|=(oggpack_read(opb,5)<<3);
105 info->secondstages[j]=cascade;
106
107 acc+=icount(cascade);
108 }
109 for(j=0;j<acc;j++)
110 info->booklist[j]=oggpack_read(opb,8);
111
112 if(info->groupbook>=ci->books)goto errout;
113 for(j=0;j<acc;j++)
114 if(info->booklist[j]>=ci->books)goto errout;
115
116 return(info);
117 errout:
118 res0_free_info(info);
119 return(NULL);
120 }
121
res0_look(vorbis_dsp_state * vd,vorbis_info_mode * vm,vorbis_info_residue * vr)122 vorbis_look_residue *res0_look(vorbis_dsp_state *vd,vorbis_info_mode *vm,
123 vorbis_info_residue *vr){
124 vorbis_info_residue0 *info=(vorbis_info_residue0 *)vr;
125 vorbis_look_residue0 *look=(vorbis_look_residue0 *)_ogg_calloc(1,sizeof(*look));
126 codec_setup_info *ci=(codec_setup_info *)vd->vi->codec_setup;
127
128 int j,k,acc=0;
129 int dim;
130 int maxstage=0;
131 look->info=info;
132 look->map=vm->mapping;
133
134 look->parts=info->partitions;
135 look->fullbooks=ci->fullbooks;
136 look->phrasebook=ci->fullbooks+info->groupbook;
137 dim=look->phrasebook->dim;
138
139 look->partbooks=(codebook ***)_ogg_calloc(look->parts,sizeof(*look->partbooks));
140
141 for(j=0;j<look->parts;j++){
142 int stages=ilog(info->secondstages[j]);
143 if(stages){
144 if(stages>maxstage)maxstage=stages;
145 look->partbooks[j]=(codebook **)_ogg_calloc(stages,sizeof(*look->partbooks[j]));
146 for(k=0;k<stages;k++)
147 if(info->secondstages[j]&(1<<k)){
148 look->partbooks[j][k]=ci->fullbooks+info->booklist[acc++];
149 #ifdef TRAIN_RES
150 look->training_data[k][j]=calloc(look->partbooks[j][k]->entries,
151 sizeof(***look->training_data));
152 #endif
153 }
154 }
155 }
156
157 look->partvals=look->parts;
158 for(j=1;j<dim;j++)look->partvals*=look->parts;
159 look->stages=maxstage;
160 look->decodemap=(int **)_ogg_malloc(look->partvals*sizeof(*look->decodemap));
161 for(j=0;j<look->partvals;j++){
162 long val=j;
163 long mult=look->partvals/look->parts;
164 look->decodemap[j]=(int *)_ogg_malloc(dim*sizeof(*look->decodemap[j]));
165 for(k=0;k<dim;k++){
166 long deco=val/mult;
167 val-=deco*mult;
168 mult/=look->parts;
169 look->decodemap[j][k]=deco;
170 }
171 }
172
173 return(look);
174 }
175
176
177 /* a truncated packet here just means 'stop working'; it's not an error */
_01inverse(vorbis_block * vb,vorbis_look_residue * vl,ogg_int32_t ** in,int ch,long (* decodepart)(codebook *,ogg_int32_t *,oggpack_buffer *,int,int))178 static int _01inverse(vorbis_block *vb,vorbis_look_residue *vl,
179 ogg_int32_t **in,int ch,
180 long (*decodepart)(codebook *, ogg_int32_t *,
181 oggpack_buffer *,int,int)){
182
183 long i,j,k,l,s;
184 vorbis_look_residue0 *look=(vorbis_look_residue0 *)vl;
185 vorbis_info_residue0 *info=look->info;
186
187 /* move all this setup out later */
188 int samples_per_partition=info->grouping;
189 int partitions_per_word=look->phrasebook->dim;
190 int max=vb->pcmend>>1;
191 int end=(info->end<max?info->end:max);
192 int n=end-info->begin;
193
194 if(n>0){
195 int partvals=n/samples_per_partition;
196 int partwords=(partvals+partitions_per_word-1)/partitions_per_word;
197 int ***partword=(int ***)alloca(ch*sizeof(*partword));
198
199 for(j=0;j<ch;j++)
200 partword[j]=(int **)_vorbis_block_alloc(vb,partwords*sizeof(*partword[j]));
201
202 for(s=0;s<look->stages;s++){
203
204 /* each loop decodes on partition codeword containing
205 partitions_pre_word partitions */
206 for(i=0,l=0;i<partvals;l++){
207 if(s==0){
208 /* fetch the partition word for each channel */
209 for(j=0;j<ch;j++){
210 int temp=vorbis_book_decode(look->phrasebook,&vb->opb);
211 if(temp==-1)goto eopbreak;
212 partword[j][l]=look->decodemap[temp];
213 if(partword[j][l]==NULL)goto errout;
214 }
215 }
216
217 /* now we decode residual values for the partitions */
218 for(k=0;k<partitions_per_word && i<partvals;k++,i++)
219 for(j=0;j<ch;j++){
220 long offset=info->begin+i*samples_per_partition;
221 if(info->secondstages[partword[j][l][k]]&(1<<s)){
222 codebook *stagebook=look->partbooks[partword[j][l][k]][s];
223 if(stagebook){
224 if(decodepart(stagebook,in[j]+offset,&vb->opb,
225 samples_per_partition,-8)==-1)goto eopbreak;
226 }
227 }
228 }
229 }
230 }
231 }
232 errout:
233 eopbreak:
234 return(0);
235 }
236
res0_inverse(vorbis_block * vb,vorbis_look_residue * vl,ogg_int32_t ** in,int * nonzero,int ch)237 int res0_inverse(vorbis_block *vb,vorbis_look_residue *vl,
238 ogg_int32_t **in,int *nonzero,int ch){
239 int i,used=0;
240 for(i=0;i<ch;i++)
241 if(nonzero[i])
242 in[used++]=in[i];
243 if(used)
244 return(_01inverse(vb,vl,in,used,vorbis_book_decodevs_add));
245 else
246 return(0);
247 }
248
res1_inverse(vorbis_block * vb,vorbis_look_residue * vl,ogg_int32_t ** in,int * nonzero,int ch)249 int res1_inverse(vorbis_block *vb,vorbis_look_residue *vl,
250 ogg_int32_t **in,int *nonzero,int ch){
251 int i,used=0;
252 for(i=0;i<ch;i++)
253 if(nonzero[i])
254 in[used++]=in[i];
255 if(used)
256 return(_01inverse(vb,vl,in,used,vorbis_book_decodev_add));
257 else
258 return(0);
259 }
260
261 /* duplicate code here as speed is somewhat more important */
res2_inverse(vorbis_block * vb,vorbis_look_residue * vl,ogg_int32_t ** in,int * nonzero,int ch)262 int res2_inverse(vorbis_block *vb,vorbis_look_residue *vl,
263 ogg_int32_t **in,int *nonzero,int ch){
264 long i,k,l,s;
265 vorbis_look_residue0 *look=(vorbis_look_residue0 *)vl;
266 vorbis_info_residue0 *info=look->info;
267
268 /* move all this setup out later */
269 int samples_per_partition=info->grouping;
270 int partitions_per_word=look->phrasebook->dim;
271 int max=(vb->pcmend*ch)>>1;
272 int end=(info->end<max?info->end:max);
273 int n=end-info->begin;
274
275 if(n>0){
276
277 int partvals=n/samples_per_partition;
278 int partwords=(partvals+partitions_per_word-1)/partitions_per_word;
279 int **partword=(int **)_vorbis_block_alloc(vb,partwords*sizeof(*partword));
280 int beginoff=info->begin/ch;
281
282 for(i=0;i<ch;i++)if(nonzero[i])break;
283 if(i==ch)return(0); /* no nonzero vectors */
284
285 samples_per_partition/=ch;
286
287 for(s=0;s<look->stages;s++){
288 for(i=0,l=0;i<partvals;l++){
289
290 if(s==0){
291 /* fetch the partition word */
292 int temp=vorbis_book_decode(look->phrasebook,&vb->opb);
293 if(temp==-1)goto eopbreak;
294 partword[l]=look->decodemap[temp];
295 if(partword[l]==NULL)goto errout;
296 }
297
298 /* now we decode residual values for the partitions */
299 for(k=0;k<partitions_per_word && i<partvals;k++,i++)
300 if(info->secondstages[partword[l][k]]&(1<<s)){
301 codebook *stagebook=look->partbooks[partword[l][k]][s];
302
303 if(stagebook){
304 if(vorbis_book_decodevv_add(stagebook,in,
305 i*samples_per_partition+beginoff,ch,
306 &vb->opb,
307 samples_per_partition,-8)==-1)
308 goto eopbreak;
309 }
310 }
311 }
312 }
313 }
314 errout:
315 eopbreak:
316 return(0);
317 }
318
319
320 vorbis_func_residue residue0_exportbundle={
321 &res0_unpack,
322 &res0_look,
323 &res0_free_info,
324 &res0_free_look,
325 &res0_inverse
326 };
327
328 vorbis_func_residue residue1_exportbundle={
329 &res0_unpack,
330 &res0_look,
331 &res0_free_info,
332 &res0_free_look,
333 &res1_inverse
334 };
335
336 vorbis_func_residue residue2_exportbundle={
337 &res0_unpack,
338 &res0_look,
339 &res0_free_info,
340 &res0_free_look,
341 &res2_inverse
342 };
343