Revision a7adcf29 libavcodec/vorbis.c
libavcodec/vorbis.c  

2  2 
* @file libavcodec/vorbis.c 
3  3 
* Common code for Vorbis I encoder and decoder 
4  4 
* @author Denes Balatoni ( dbalatoni programozo hu ) 
5  
5 
* 

6  6 
* This file is part of FFmpeg. 
7  7 
* 
8  8 
* FFmpeg is free software; you can redistribute it and/or 
...  ...  
35  35 
// x^(1/n) 
36  36 
unsigned int ff_vorbis_nth_root(unsigned int x, unsigned int n) 
37  37 
{ 
38 
unsigned int ret=0, i, j;


38 
unsigned int ret = 0, i, j;


39  39  
40  40 
do { 
41  41 
++ret; 
42 
for(i=0,j=ret;i<n1;i++)


43 
j*=ret;


44 
} while (j<=x);


42 
for (i = 0, j = ret; i < n  1; i++)


43 
j *= ret;


44 
} while (j <= x);


45  45  
46  46 
return ret  1; 
47  47 
} 
...  ...  
53  53 
// reasonable to check redundantly. 
54  54 
int ff_vorbis_len2vlc(uint8_t *bits, uint32_t *codes, uint_fast32_t num) 
55  55 
{ 
56 
uint_fast32_t exit_at_level[33]={404,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 

57 
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; 

56 
uint_fast32_t exit_at_level[33] = { 

57 
404, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 

58 
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; 

58  59  
59 
uint_fast8_t i,j; 

60 
uint_fast32_t code,p; 

60 
uint_fast8_t i, j;


61 
uint_fast32_t code, p;


61  62  
62  63 
#ifdef V_DEBUG 
63  64 
GetBitContext gb; 
64  65 
#endif 
65  66  
66 
for(p=0;(bits[p]==0) && (p<num);++p)


67 
for (p = 0; (bits[p] == 0) && (p < num); ++p)


67  68 
; 
68 
if (p==num) {


69 
if (p == num) {


69  70 
// av_log(vc>avccontext, AV_LOG_INFO, "An empty codebook. Heh?! \n"); 
70  71 
return 0; 
71  72 
} 
72  73  
73 
codes[p]=0;


74 
codes[p] = 0;


74  75 
if (bits[p] > 32) 
75  76 
return 1; 
76 
for(i=0;i<bits[p];++i)


77 
exit_at_level[i+1]=1<<i;


77 
for (i = 0; i < bits[p]; ++i)


78 
exit_at_level[i+1] = 1 << i;


78  79  
79  80 
#ifdef V_DEBUG 
80  81 
av_log(NULL, AV_LOG_INFO, " %d. of %d code len %d code %d  ", p, num, bits[p], codes[p]); 
81  82 
init_get_bits(&gb, (uint_fast8_t *)&codes[p], bits[p]); 
82 
for(i=0;i<bits[p];++i)


83 
for (i = 0; i < bits[p]; ++i)


83  84 
av_log(NULL, AV_LOG_INFO, "%s", get_bits1(&gb) ? "1" : "0"); 
84  85 
av_log(NULL, AV_LOG_INFO, "\n"); 
85  86 
#endif 
86  87  
87  88 
++p; 
88  89  
89 
for(;p<num;++p) {


90 
for (; p < num; ++p) {


90  91 
if (bits[p] > 32) 
91 
return 1; 

92 
if (bits[p]==0)


93 
continue; 

92 
return 1;


93 
if (bits[p] == 0)


94 
continue;


94  95 
// find corresponding exit(node which the tree can grow further from) 
95 
for(i=bits[p];i>0;i)


96 
for (i = bits[p]; i > 0; i)


96  97 
if (exit_at_level[i]) 
97  98 
break; 
98  99 
if (!i) // overspecified tree 
99 
return 1; 

100 
code=exit_at_level[i];


101 
exit_at_level[i]=0;


100 
return 1;


101 
code = exit_at_level[i];


102 
exit_at_level[i] = 0;


102  103 
// construct code (append 0s to end) and introduce new exits 
103 
for(j=i+1;j<=bits[p];++j)


104 
exit_at_level[j]=code+(1<<(j1));


105 
codes[p]=code;


104 
for (j = i + 1 ;j <= bits[p]; ++j)


105 
exit_at_level[j] = code + (1 << (j  1));


106 
codes[p] = code;


106  107  
107  108 
#ifdef V_DEBUG 
108  109 
av_log(NULL, AV_LOG_INFO, " %d. code len %d code %d  ", p, bits[p], codes[p]); 
109  110 
init_get_bits(&gb, (uint_fast8_t *)&codes[p], bits[p]); 
110 
for(i=0;i<bits[p];++i)


111 
for (i = 0; i < bits[p]; ++i)


111  112 
av_log(NULL, AV_LOG_INFO, "%s", get_bits1(&gb) ? "1" : "0"); 
112  113 
av_log(NULL, AV_LOG_INFO, "\n"); 
113  114 
#endif 
...  ...  
115  116 
} 
116  117  
117  118 
//no exits should be left (underspecified tree  ie. unused valid vlcs  not allowed by SPEC) 
118 
for (p=1; p<33; p++)


119 
for (p = 1; p < 33; p++)


119  120 
if (exit_at_level[p]) 
120  121 
return 1; 
121  122  
...  ...  
129  130 
list[1].sort = 1; 
130  131 
for (i = 2; i < values; i++) { 
131  132 
int j; 
132 
list[i].low = 0; 

133 
list[i].low = 0;


133  134 
list[i].high = 1; 
134  135 
list[i].sort = i; 
135  136 
for (j = 2; j < i; j++) { 
136  137 
int tmp = list[j].x; 
137  138 
if (tmp < list[i].x) { 
138  139 
if (tmp > list[list[i].low].x) 
139 
list[i].low = j;


140 
list[i].low = j;


140  141 
} else { 
141  142 
if (tmp < list[list[i].high].x) 
142  143 
list[i].high = j; 
...  ...  
157  158  
158  159 
static inline void render_line_unrolled(intptr_t x, intptr_t y, int x1, 
159  160 
intptr_t sy, int ady, int adx, 
160 
float * buf)


161 
float *buf) 

161  162 
{ 
162  163 
int err = adx; 
163 
x = x11;


164 
buf += x11;


164 
x = x1  1;


165 
buf += x1  1;


165  166 
while (++x < 0) { 
166  167 
err += ady; 
167  168 
if (err >= 0) { 
168  169 
err += ady  adx; 
169 
y += sy; 

170 
y += sy;


170  171 
buf[x++] = ff_vorbis_floor1_inverse_db_table[y]; 
171  172 
} 
172  173 
buf[x] = ff_vorbis_floor1_inverse_db_table[y]; 
...  ...  
178  179 
} 
179  180 
} 
180  181  
181 
static void render_line(int x0, int y0, int x1, int y1, float * buf)


182 
static void render_line(int x0, int y0, int x1, int y1, float *buf) 

182  183 
{ 
183 
int dy = y1  y0; 

184 
int dy = y1  y0;


184  185 
int adx = x1  x0; 
185  186 
int ady = FFABS(dy); 
186 
int sy = dy<0 ? 1 : 1;


187 
int sy = dy < 0 ? 1 : 1;


187  188 
buf[x0] = ff_vorbis_floor1_inverse_db_table[y0]; 
188 
if(ady*2<=adx) { // optimized common case


189 
if (ady*2 <= adx) { // optimized common case


189  190 
render_line_unrolled(x0, y0, x1, sy, ady, adx, buf); 
190  191 
} else { 
191  192 
int base = dy / adx; 
192 
int x = x0; 

193 
int y = y0; 

194 
int err = adx; 

193 
int x = x0;


194 
int y = y0;


195 
int err = adx;


195  196 
ady = FFABS(base) * adx; 
196  197 
while (++x < x1) { 
197  198 
y += base; 
198  199 
err += ady; 
199  200 
if (err >= 0) { 
200  201 
err = adx; 
201 
y += sy; 

202 
y += sy;


202  203 
} 
203  204 
buf[x] = ff_vorbis_floor1_inverse_db_table[y]; 
204  205 
} 
...  ...  
206  207 
} 
207  208  
208  209 
void ff_vorbis_floor1_render_list(vorbis_floor1_entry * list, int values, 
209 
uint_fast16_t * y_list, int * flag,


210 
int multiplier, float * out, int samples)


210 
uint_fast16_t *y_list, int *flag,


211 
int multiplier, float *out, int samples) 

211  212 
{ 
212  213 
int lx, ly, i; 
213  214 
lx = 0; 
Also available in: Unified diff