1 /********************************************************************
3 * THIS FILE IS PART OF THE Ogg Vorbis SOFTWARE CODEC SOURCE CODE. *
4 * USE, DISTRIBUTION AND REPRODUCTION OF THIS SOURCE IS GOVERNED BY *
5 * THE GNU PUBLIC LICENSE 2, WHICH IS INCLUDED WITH THIS SOURCE. *
6 * PLEASE READ THESE TERMS DISTRIBUTING. *
8 * THE OggSQUISH SOURCE CODE IS (C) COPYRIGHT 1994-2000 *
9 * by Monty <monty@xiph.org> and The XIPHOPHORUS Company *
10 * http://www.xiph.org/ *
12 ********************************************************************
14 function: residue backend 0 implementation
15 last mod: $Id: res0.c,v 1.8 2000/02/23 11:22:46 xiphmont Exp $
17 ********************************************************************/
19 /* Slow, slow, slow, simpleminded and did I mention it was slow? The
20 encode/decode loops are coded for clarity and performance is not
21 yet even a nagging little idea lurking in the shadows. Oh and BTW,
28 #include "vorbis/codec.h"
32 #include "bookinternal.h"
36 vorbis_info_residue0 *info;
41 codebook ***partbooks;
46 } vorbis_look_residue0;
48 void free_info(vorbis_info_residue *i){
50 memset(i,0,sizeof(vorbis_info_residue0));
55 void free_look(vorbis_look_residue *i){
58 vorbis_look_residue0 *look=(vorbis_look_residue0 *)i;
59 for(j=0;j<look->parts;j++)
60 if(look->partbooks[j])free(look->partbooks[j]);
61 free(look->partbooks);
62 for(j=0;j<look->partvals;j++)
63 free(look->decodemap[j]);
64 free(look->decodemap);
65 if(look->partstages)free(look->partstages);
66 memset(i,0,sizeof(vorbis_look_residue0));
71 void pack(vorbis_info_residue *vr,oggpack_buffer *opb){
72 vorbis_info_residue0 *info=(vorbis_info_residue0 *)vr;
74 _oggpack_write(opb,info->begin,24);
75 _oggpack_write(opb,info->end,24);
77 _oggpack_write(opb,info->grouping-1,24); /* residue vectors to group and
78 code with a partitioned book */
79 _oggpack_write(opb,info->partitions-1,6); /* possible partition choices */
80 _oggpack_write(opb,info->groupbook,8); /* group huffman book */
81 for(j=0;j<info->partitions;j++){
82 _oggpack_write(opb,info->secondstages[j],4); /* zero *is* a valid choice */
83 acc+=info->secondstages[j];
86 _oggpack_write(opb,info->booklist[j],8);
90 /* vorbis_info is for range checking */
91 vorbis_info_residue *unpack(vorbis_info *vi,oggpack_buffer *opb){
93 vorbis_info_residue0 *info=calloc(1,sizeof(vorbis_info_residue0));
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 for(j=0;j<info->partitions;j++)
101 acc+=info->secondstages[j]=_oggpack_read(opb,4);
103 info->booklist[j]=_oggpack_read(opb,8);
105 if(info->groupbook>=vi->books)goto errout;
107 if(info->booklist[j]>=vi->books)goto errout;
115 vorbis_look_residue *look (vorbis_dsp_state *vd,vorbis_info_mode *vm,
116 vorbis_info_residue *vr){
117 vorbis_info_residue0 *info=(vorbis_info_residue0 *)vr;
118 vorbis_look_residue0 *look=calloc(1,sizeof(vorbis_look_residue0));
123 look->parts=info->partitions;
124 look->phrasebook=vd->fullbooks+info->groupbook;
125 dim=look->phrasebook->dim;
127 look->partbooks=calloc(look->parts,sizeof(codebook **));
128 look->partstages=calloc(look->parts,sizeof(int));
130 for(j=0;j<look->parts;j++){
131 int stages=info->secondstages[j];
133 look->partbooks[j]=malloc(stages*sizeof(codebook *));
134 for(k=0;k<stages;k++)
135 look->partbooks[j][k]=vd->fullbooks+info->booklist[acc++];
137 look->partstages[j]=stages;
140 look->partvals=pow(look->parts,dim);
141 look->decodemap=malloc(look->partvals*sizeof(int *));
142 for(j=0;j<look->partvals;j++){
144 long mult=look->partvals/look->parts;
145 look->decodemap[j]=malloc(dim*sizeof(int));
150 look->decodemap[j][k]=deco;
157 /* returns the distance error from encoding with this book set */
158 static double _testpart(double *vec,int n, int stages, codebook **books){
161 double *work=alloca(n*sizeof(double)),acc=0.;
162 memcpy(work,vec,n*sizeof(double));
165 /* a mild hack. We want partitions with samples values under
166 fabs(.5) to be fully zeroed; if this case is met, we return an
167 error of -1 (which cannot be beaten). If the samples values
168 don't meet this criteria, return the real error */
170 if(fabs(vec[i])>.5)break;
173 /* real (squared) error */
178 for(j=0;j<stages;j++){
180 for(i=0;i<n;i+=books[j]->dim)
181 acc+=vorbis_book_vE(books[j],work+i);
188 static int _testhack(double *vec,int n){
193 acc+=todB(fabs(vec[i]));
196 max=(fabs(vec[i])>max?fabs(vec[i]):max);
199 if(max<2.5 && acc<1.5)return(1);
204 static int _encodepart(oggpack_buffer *opb,double *vec, int n,
205 int stages, codebook **books){
208 double *work=alloca(n*sizeof(double));
209 memcpy(work,vec,n*sizeof(double));
211 for(j=0;j<stages;j++)
212 for(i=0;i<n;i+=books[j]->dim)
213 bits+=vorbis_book_encodevE(books[j],work+i,opb);
218 static int _decodepart(oggpack_buffer *opb,double *work,double *vec, int n,
219 int stages, codebook **books){
222 memset(work,0,n*sizeof(double));
223 for(j=0;j<stages;j++)
224 for(i=0;i<n;i+=books[j]->dim)
225 vorbis_book_decodev(books[j],work+i,opb);
233 int forward(vorbis_block *vb,vorbis_look_residue *vl,
236 vorbis_look_residue0 *look=(vorbis_look_residue0 *)vl;
237 vorbis_info_residue0 *info=look->info;
239 /* move all this setup out later */
240 int samples_per_partition=info->grouping;
241 int possible_partitions=info->partitions;
242 int partitions_per_word=look->phrasebook->dim;
243 int n=info->end-info->begin;
244 long phrasebits=0,resbitsT=0;
245 long *resbits=alloca(sizeof(long)*possible_partitions);
246 long *resvals=alloca(sizeof(long)*possible_partitions);
248 int partvals=n/samples_per_partition;
249 int partwords=(partvals+partitions_per_word-1)/partitions_per_word;
250 long **partword=_vorbis_block_alloc(vb,ch*sizeof(long *));
251 partvals=partwords*partitions_per_word;
253 /* we find/encode the patition type for each partition of each
254 channel. We'll go back and do the interleaved encoding in a
255 bit. For now, clarity */
257 if(ch)_analysis_output("a_res",vb->sequence,in[0],n);
258 memset(resbits,0,sizeof(long)*possible_partitions);
259 memset(resvals,0,sizeof(long)*possible_partitions);
262 partword[i]=_vorbis_block_alloc(vb,n/samples_per_partition*sizeof(long));
263 memset(partword[i],0,n/samples_per_partition*sizeof(long));
266 for(i=info->begin,l=0;i<info->end;i+=samples_per_partition,l++){
269 /* find the best encoding for the partition using each possible
270 book. Use the book that had lowest error (we arrange the
271 books to make optimal choice very obvious and not even think
273 partword[j][l]=_testhack(in[j]+i,samples_per_partition);
276 double best=_testpart(in[j]+i,samples_per_partition,
277 look->partstages[0],look->partbooks[0]);
278 for(k=1;k<info->partitions;k++){
279 double this=_testpart(in[j]+i,samples_per_partition,
280 look->partstages[k],look->partbooks[k]);
290 /* we code the partition words for each channel, then the residual
291 words for a partition per channel until we've written all the
292 partitions for that partition word. Then write the next parition
295 for(i=info->begin,l=0;i<info->end;){
296 /* first we encode a partition codeword for each channel */
298 long val=partword[j][l];
299 for(k=1;k<partitions_per_word;k++)
300 val= val*possible_partitions+partword[j][l+k];
301 phrasebits+=vorbis_book_encode(look->phrasebook,val,&vb->opb);
303 /* now we encode interleaved residual values for the partitions */
304 for(k=0;k<partitions_per_word;k++,l++,i+=samples_per_partition)
306 resbits[partword[j][l]]+=
307 _encodepart(&vb->opb,in[j]+i,samples_per_partition,
308 look->partstages[partword[j][l]],
309 look->partbooks[partword[j][l]]);
310 resvals[partword[j][l]]+=samples_per_partition;
315 for(i=0;i<possible_partitions;i++)resbitsT+=resbits[i];
316 fprintf(stderr,"Encoded %ld res vectors in %ld phrasing and %ld res bits\n\t",
317 ch*(info->end-info->begin),phrasebits,resbitsT);
318 for(i=0;i<possible_partitions;i++)
319 fprintf(stderr,"%ld(%ld):%ld ",i,resvals[i],resbits[i]);
320 fprintf(stderr,"\n");
325 int inverse(vorbis_block *vb,vorbis_look_residue *vl,double **in,int ch){
327 vorbis_look_residue0 *look=(vorbis_look_residue0 *)vl;
328 vorbis_info_residue0 *info=look->info;
330 /* move all this setup out later */
331 int samples_per_partition=info->grouping;
332 int partitions_per_word=look->phrasebook->dim;
333 int n=info->end-info->begin;
335 int partvals=n/samples_per_partition;
336 int partwords=(partvals+partitions_per_word-1)/partitions_per_word;
337 int **partword=alloca(ch*sizeof(long *));
338 double *work=alloca(sizeof(double)*samples_per_partition);
339 partvals=partwords*partitions_per_word;
341 for(i=info->begin,l=0;i<info->end;){
342 /* fetch the partition word for each channel */
344 partword[j]=look->decodemap[vorbis_book_decode(look->phrasebook,
347 /* now we decode interleaved residual values for the partitions */
348 for(k=0;k<partitions_per_word;k++,l++,i+=samples_per_partition)
350 int part=partword[j][k];
351 _decodepart(&vb->opb,work,in[j]+i,samples_per_partition,
352 look->partstages[part],
353 look->partbooks[part]);
357 if(ch)_analysis_output("s_res",vb->sequence,in[0],n);
362 vorbis_func_residue residue0_exportbundle={