← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/gstreamer0.10-ffmpeg/intrepid

« back to all changes in this revision

Viewing changes to gst-libs/ext/ffmpeg/libavcodec/sonic.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge
  • Date: 2006-04-01 16:13:43 UTC
  • mto: (1.2.2 lenny)
  • mto: This revision was merged to the branch mainline in revision 5.
  • Revision ID: james.westby@ubuntu.com-20060401161343-n621cgjlujio0otg
Tags: upstream-0.10.1
Import upstream version 0.10.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
gst-libs/ext/ffmpeg/libavcodec/sonic.c
14
14
 *
15
15
 * You should have received a copy of the GNU Lesser General Public
16
16
 * License along with this library; if not, write to the Free Software
17
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
18
 */
19
19
#include "avcodec.h"
20
20
#include "bitstream.h"
43
43
 
44
44
typedef struct SonicContext {
45
45
    int lossless, decorrelation;
46
 
    
 
46
 
47
47
    int num_taps, downsampling;
48
48
    double quantization;
49
 
    
 
49
 
50
50
    int channels, samplerate, block_align, frame_size;
51
51
 
52
52
    int *tap_quant;
64
64
    int *predictor_state[MAX_CHANNELS];
65
65
} SonicContext;
66
66
 
67
 
#define LATTICE_SHIFT   10
68
 
#define SAMPLE_SHIFT    4
69
 
#define LATTICE_FACTOR  (1 << LATTICE_SHIFT)
70
 
#define SAMPLE_FACTOR   (1 << SAMPLE_SHIFT)
 
67
#define LATTICE_SHIFT   10
 
68
#define SAMPLE_SHIFT    4
 
69
#define LATTICE_FACTOR  (1 << LATTICE_SHIFT)
 
70
#define SAMPLE_FACTOR   (1 << SAMPLE_SHIFT)
71
71
 
72
 
#define BASE_QUANT      0.6
73
 
#define RATE_VARIATION  3.0
 
72
#define BASE_QUANT      0.6
 
73
#define RATE_VARIATION  3.0
74
74
 
75
75
static inline int divide(int a, int b)
76
76
{
77
77
    if (a < 0)
78
 
        return -( (-a + b/2)/b );
 
78
        return -( (-a + b/2)/b );
79
79
    else
80
 
        return (a + b/2)/b;
 
80
        return (a + b/2)/b;
81
81
}
82
82
 
83
83
static inline int shift(int a,int b)
96
96
    int i;
97
97
 
98
98
    for (i = 0; i < entries; i++)
99
 
        set_se_golomb(pb, buf[i]);
 
99
        set_se_golomb(pb, buf[i]);
100
100
 
101
101
    return 1;
102
102
}
104
104
static inline int intlist_read(GetBitContext *gb, int *buf, int entries, int base_2_part)
105
105
{
106
106
    int i;
107
 
    
 
107
 
108
108
    for (i = 0; i < entries; i++)
109
 
        buf[i] = get_se_golomb(gb);
 
109
        buf[i] = get_se_golomb(gb);
110
110
 
111
111
    return 1;
112
112
}
118
118
static int bits_to_store(uint64_t x)
119
119
{
120
120
    int res = 0;
121
 
    
 
121
 
122
122
    while(x)
123
123
    {
124
 
        res++;
125
 
        x >>= 1;
 
124
        res++;
 
125
        x >>= 1;
126
126
    }
127
127
    return res;
128
128
}
132
132
    int i, bits;
133
133
 
134
134
    if (!max)
135
 
        return;
 
135
        return;
136
136
 
137
137
    bits = bits_to_store(max);
138
138
 
139
139
    for (i = 0; i < bits-1; i++)
140
 
        put_bits(pb, 1, value & (1 << i));
 
140
        put_bits(pb, 1, value & (1 << i));
141
141
 
142
142
    if ( (value | (1 << (bits-1))) <= max)
143
 
        put_bits(pb, 1, value & (1 << (bits-1)));
 
143
        put_bits(pb, 1, value & (1 << (bits-1)));
144
144
}
145
145
 
146
146
static unsigned int read_uint_max(GetBitContext *gb, int max)
147
147
{
148
148
    int i, bits, value = 0;
149
 
    
 
149
 
150
150
    if (!max)
151
 
        return 0;
 
151
        return 0;
152
152
 
153
153
    bits = bits_to_store(max);
154
154
 
155
155
    for (i = 0; i < bits-1; i++)
156
 
        if (get_bits1(gb))
157
 
            value += 1 << i;
 
156
        if (get_bits1(gb))
 
157
            value += 1 << i;
158
158
 
159
159
    if ( (value | (1<<(bits-1))) <= max)
160
 
        if (get_bits1(gb))
161
 
            value += 1 << (bits-1);
 
160
        if (get_bits1(gb))
 
161
            value += 1 << (bits-1);
162
162
 
163
163
    return value;
164
164
}
171
171
 
172
172
    copy = av_mallocz(4* entries);
173
173
    if (!copy)
174
 
        return -1;
175
 
    
 
174
        return -1;
 
175
 
176
176
    if (base_2_part)
177
177
    {
178
 
        int energy = 0;
179
 
        
180
 
        for (i = 0; i < entries; i++)
181
 
            energy += abs(buf[i]);
182
 
        
183
 
        low_bits = bits_to_store(energy / (entries * 2));
184
 
        if (low_bits > 15)
185
 
            low_bits = 15;
186
 
        
187
 
        put_bits(pb, 4, low_bits);
 
178
        int energy = 0;
 
179
 
 
180
        for (i = 0; i < entries; i++)
 
181
            energy += abs(buf[i]);
 
182
 
 
183
        low_bits = bits_to_store(energy / (entries * 2));
 
184
        if (low_bits > 15)
 
185
            low_bits = 15;
 
186
 
 
187
        put_bits(pb, 4, low_bits);
188
188
    }
189
 
    
 
189
 
190
190
    for (i = 0; i < entries; i++)
191
191
    {
192
 
        put_bits(pb, low_bits, abs(buf[i]));
193
 
        copy[i] = abs(buf[i]) >> low_bits;
194
 
        if (copy[i] > max)
195
 
            max = abs(copy[i]);
 
192
        put_bits(pb, low_bits, abs(buf[i]));
 
193
        copy[i] = abs(buf[i]) >> low_bits;
 
194
        if (copy[i] > max)
 
195
            max = abs(copy[i]);
196
196
    }
197
197
 
198
198
    bits = av_mallocz(4* entries*max);
199
199
    if (!bits)
200
200
    {
201
 
//      av_free(copy);
202
 
        return -1;
 
201
//        av_free(copy);
 
202
        return -1;
203
203
    }
204
 
    
 
204
 
205
205
    for (i = 0; i <= max; i++)
206
206
    {
207
 
        for (j = 0; j < entries; j++)
208
 
            if (copy[j] >= i)
209
 
                bits[x++] = copy[j] > i;
 
207
        for (j = 0; j < entries; j++)
 
208
            if (copy[j] >= i)
 
209
                bits[x++] = copy[j] > i;
210
210
    }
211
211
 
212
212
    // store bitstream
213
213
    while (pos < x)
214
214
    {
215
 
        int steplet = step >> 8;
216
 
        
217
 
        if (pos + steplet > x)
218
 
            steplet = x - pos;
219
 
        
220
 
        for (i = 0; i < steplet; i++)
221
 
            if (bits[i+pos] != dominant)
222
 
                any = 1;
223
 
        
224
 
        put_bits(pb, 1, any);
225
 
        
226
 
        if (!any)
227
 
        {
228
 
            pos += steplet;
229
 
            step += step / ADAPT_LEVEL;
230
 
        }
231
 
        else
232
 
        {
233
 
            int interloper = 0;
234
 
            
235
 
            while (((pos + interloper) < x) && (bits[pos + interloper] == dominant))
236
 
                interloper++;
237
 
 
238
 
            // note change
239
 
            write_uint_max(pb, interloper, (step >> 8) - 1);    
240
 
            
241
 
            pos += interloper + 1;
242
 
            step -= step / ADAPT_LEVEL;
243
 
        }
244
 
        
245
 
        if (step < 256)
246
 
        {
247
 
            step = 65536 / step;
248
 
            dominant = !dominant;
249
 
        }
 
215
        int steplet = step >> 8;
 
216
 
 
217
        if (pos + steplet > x)
 
218
            steplet = x - pos;
 
219
 
 
220
        for (i = 0; i < steplet; i++)
 
221
            if (bits[i+pos] != dominant)
 
222
                any = 1;
 
223
 
 
224
        put_bits(pb, 1, any);
 
225
 
 
226
        if (!any)
 
227
        {
 
228
            pos += steplet;
 
229
            step += step / ADAPT_LEVEL;
 
230
        }
 
231
        else
 
232
        {
 
233
            int interloper = 0;
 
234
 
 
235
            while (((pos + interloper) < x) && (bits[pos + interloper] == dominant))
 
236
                interloper++;
 
237
 
 
238
            // note change
 
239
            write_uint_max(pb, interloper, (step >> 8) - 1);
 
240
 
 
241
            pos += interloper + 1;
 
242
            step -= step / ADAPT_LEVEL;
 
243
        }
 
244
 
 
245
        if (step < 256)
 
246
        {
 
247
            step = 65536 / step;
 
248
            dominant = !dominant;
 
249
        }
250
250
    }
251
 
    
 
251
 
252
252
    // store signs
253
253
    for (i = 0; i < entries; i++)
254
 
        if (buf[i])
255
 
            put_bits(pb, 1, buf[i] < 0);
 
254
        if (buf[i])
 
255
            put_bits(pb, 1, buf[i] < 0);
256
256
 
257
257
//    av_free(bits);
258
258
//    av_free(copy);
268
268
    int *bits = av_mallocz(4* entries);
269
269
 
270
270
    if (!bits)
271
 
        return -1;
272
 
    
 
271
        return -1;
 
272
 
273
273
    if (base_2_part)
274
274
    {
275
 
        low_bits = get_bits(gb, 4);
 
275
        low_bits = get_bits(gb, 4);
276
276
 
277
 
        if (low_bits)
278
 
            for (i = 0; i < entries; i++)
279
 
                buf[i] = get_bits(gb, low_bits);
 
277
        if (low_bits)
 
278
            for (i = 0; i < entries; i++)
 
279
                buf[i] = get_bits(gb, low_bits);
280
280
    }
281
281
 
282
282
//    av_log(NULL, AV_LOG_INFO, "entries: %d, low bits: %d\n", entries, low_bits);
283
283
 
284
284
    while (n_zeros < entries)
285
285
    {
286
 
        int steplet = step >> 8;
287
 
        
288
 
        if (!get_bits1(gb))
289
 
        {
290
 
            for (i = 0; i < steplet; i++)
291
 
                bits[x++] = dominant;
292
 
        
293
 
            if (!dominant)
294
 
                n_zeros += steplet;
295
 
            
296
 
            step += step / ADAPT_LEVEL;
297
 
        }
298
 
        else
299
 
        {
300
 
            int actual_run = read_uint_max(gb, steplet-1);
301
 
            
302
 
//          av_log(NULL, AV_LOG_INFO, "actual run: %d\n", actual_run);
303
 
            
304
 
            for (i = 0; i < actual_run; i++)
305
 
                bits[x++] = dominant;
306
 
            
307
 
            bits[x++] = !dominant;
308
 
            
309
 
            if (!dominant)
310
 
                n_zeros += actual_run;
311
 
            else
312
 
                n_zeros++;
313
 
        
314
 
            step -= step / ADAPT_LEVEL;
315
 
        }
316
 
        
317
 
        if (step < 256)
318
 
        {
319
 
            step = 65536 / step;
320
 
            dominant = !dominant;
321
 
        }
 
286
        int steplet = step >> 8;
 
287
 
 
288
        if (!get_bits1(gb))
 
289
        {
 
290
            for (i = 0; i < steplet; i++)
 
291
                bits[x++] = dominant;
 
292
 
 
293
            if (!dominant)
 
294
                n_zeros += steplet;
 
295
 
 
296
            step += step / ADAPT_LEVEL;
 
297
        }
 
298
        else
 
299
        {
 
300
            int actual_run = read_uint_max(gb, steplet-1);
 
301
 
 
302
//            av_log(NULL, AV_LOG_INFO, "actual run: %d\n", actual_run);
 
303
 
 
304
            for (i = 0; i < actual_run; i++)
 
305
                bits[x++] = dominant;
 
306
 
 
307
            bits[x++] = !dominant;
 
308
 
 
309
            if (!dominant)
 
310
                n_zeros += actual_run;
 
311
            else
 
312
                n_zeros++;
 
313
 
 
314
            step -= step / ADAPT_LEVEL;
 
315
        }
 
316
 
 
317
        if (step < 256)
 
318
        {
 
319
            step = 65536 / step;
 
320
            dominant = !dominant;
 
321
        }
322
322
    }
323
 
    
 
323
 
324
324
    // reconstruct unsigned values
325
325
    n_zeros = 0;
326
326
    for (i = 0; n_zeros < entries; i++)
327
327
    {
328
 
        while(1)
329
 
        {
330
 
            if (pos >= entries)
331
 
            {
332
 
                pos = 0;
333
 
                level += 1 << low_bits;
334
 
            }
335
 
            
336
 
            if (buf[pos] >= level)
337
 
                break;
338
 
            
339
 
            pos++;
340
 
        }
341
 
        
342
 
        if (bits[i])
343
 
            buf[pos] += 1 << low_bits;
344
 
        else
345
 
            n_zeros++;
346
 
        
347
 
        pos++;
 
328
        while(1)
 
329
        {
 
330
            if (pos >= entries)
 
331
            {
 
332
                pos = 0;
 
333
                level += 1 << low_bits;
 
334
            }
 
335
 
 
336
            if (buf[pos] >= level)
 
337
                break;
 
338
 
 
339
            pos++;
 
340
        }
 
341
 
 
342
        if (bits[i])
 
343
            buf[pos] += 1 << low_bits;
 
344
        else
 
345
            n_zeros++;
 
346
 
 
347
        pos++;
348
348
    }
349
349
//    av_free(bits);
350
 
    
 
350
 
351
351
    // read signs
352
352
    for (i = 0; i < entries; i++)
353
 
        if (buf[i] && get_bits1(gb))
354
 
            buf[i] = -buf[i];
 
353
        if (buf[i] && get_bits1(gb))
 
354
            buf[i] = -buf[i];
355
355
 
356
356
//    av_log(NULL, AV_LOG_INFO, "zeros: %d pos: %d\n", n_zeros, pos);
357
357
 
365
365
 
366
366
    for (i = order-2; i >= 0; i--)
367
367
    {
368
 
        int j, p, x = state[i];
 
368
        int j, p, x = state[i];
369
369
 
370
 
        for (j = 0, p = i+1; p < order; j++,p++)
371
 
        {
372
 
            int tmp = x + shift_down(k[j] * state[p], LATTICE_SHIFT);
373
 
            state[p] += shift_down(k[j]*x, LATTICE_SHIFT);
374
 
            x = tmp;
375
 
        }
 
370
        for (j = 0, p = i+1; p < order; j++,p++)
 
371
            {
 
372
            int tmp = x + shift_down(k[j] * state[p], LATTICE_SHIFT);
 
373
            state[p] += shift_down(k[j]*x, LATTICE_SHIFT);
 
374
            x = tmp;
 
375
        }
376
376
    }
377
377
}
378
378
 
382
382
 
383
383
#if 1
384
384
    int *k_ptr = &(k[order-2]),
385
 
        *state_ptr = &(state[order-2]);
 
385
        *state_ptr = &(state[order-2]);
386
386
    for (i = order-2; i >= 0; i--, k_ptr--, state_ptr--)
387
387
    {
388
 
        int k_value = *k_ptr, state_value = *state_ptr;
389
 
        x -= shift_down(k_value * state_value, LATTICE_SHIFT);
390
 
        state_ptr[1] = state_value + shift_down(k_value * x, LATTICE_SHIFT);
 
388
        int k_value = *k_ptr, state_value = *state_ptr;
 
389
        x -= shift_down(k_value * state_value, LATTICE_SHIFT);
 
390
        state_ptr[1] = state_value + shift_down(k_value * x, LATTICE_SHIFT);
391
391
    }
392
392
#else
393
393
    for (i = order-2; i >= 0; i--)
394
394
    {
395
 
        x -= shift_down(k[i] * state[i], LATTICE_SHIFT);
396
 
        state[i+1] = state[i] + shift_down(k[i] * x, LATTICE_SHIFT);
 
395
        x -= shift_down(k[i] * state[i], LATTICE_SHIFT);
 
396
        state[i+1] = state[i] + shift_down(k[i] * x, LATTICE_SHIFT);
397
397
    }
398
398
#endif
399
399
 
400
 
    // don't drift too far, to avoid overflows 
 
400
    // don't drift too far, to avoid overflows
401
401
    if (x >  (SAMPLE_FACTOR<<16)) x =  (SAMPLE_FACTOR<<16);
402
402
    if (x < -(SAMPLE_FACTOR<<16)) x = -(SAMPLE_FACTOR<<16);
403
403
 
411
411
// actual whitened result as it goes.
412
412
 
413
413
static void modified_levinson_durbin(int *window, int window_entries,
414
 
        int *out, int out_entries, int channels, int *tap_quant)
 
414
        int *out, int out_entries, int channels, int *tap_quant)
415
415
{
416
416
    int i;
417
417
    int *state = av_mallocz(4* window_entries);
418
 
    
 
418
 
419
419
    memcpy(state, window, 4* window_entries);
420
 
    
 
420
 
421
421
    for (i = 0; i < out_entries; i++)
422
422
    {
423
 
        int step = (i+1)*channels, k, j;
424
 
        double xx = 0.0, xy = 0.0;
 
423
        int step = (i+1)*channels, k, j;
 
424
        double xx = 0.0, xy = 0.0;
425
425
#if 1
426
 
        int *x_ptr = &(window[step]), *state_ptr = &(state[0]);
427
 
        j = window_entries - step;
428
 
        for (;j>=0;j--,x_ptr++,state_ptr++)
429
 
        {
430
 
            double x_value = *x_ptr, state_value = *state_ptr;
431
 
            xx += state_value*state_value;
432
 
            xy += x_value*state_value;
433
 
        }
 
426
        int *x_ptr = &(window[step]), *state_ptr = &(state[0]);
 
427
        j = window_entries - step;
 
428
        for (;j>=0;j--,x_ptr++,state_ptr++)
 
429
        {
 
430
            double x_value = *x_ptr, state_value = *state_ptr;
 
431
            xx += state_value*state_value;
 
432
            xy += x_value*state_value;
 
433
        }
434
434
#else
435
 
        for (j = 0; j <= (window_entries - step); j++);
436
 
        {
437
 
            double stepval = window[step+j], stateval = window[j];
438
 
//          xx += (double)window[j]*(double)window[j];
439
 
//          xy += (double)window[step+j]*(double)window[j];
440
 
            xx += stateval*stateval;
441
 
            xy += stepval*stateval;
442
 
        }
 
435
        for (j = 0; j <= (window_entries - step); j++);
 
436
        {
 
437
            double stepval = window[step+j], stateval = window[j];
 
438
//            xx += (double)window[j]*(double)window[j];
 
439
//            xy += (double)window[step+j]*(double)window[j];
 
440
            xx += stateval*stateval;
 
441
            xy += stepval*stateval;
 
442
        }
443
443
#endif
444
 
        if (xx == 0.0)
445
 
            k = 0;
446
 
        else
447
 
            k = (int)(floor(-xy/xx * (double)LATTICE_FACTOR / (double)(tap_quant[i]) + 0.5));
448
 
        
449
 
        if (k > (LATTICE_FACTOR/tap_quant[i]))
450
 
            k = LATTICE_FACTOR/tap_quant[i];
451
 
        if (-k > (LATTICE_FACTOR/tap_quant[i]))
452
 
            k = -(LATTICE_FACTOR/tap_quant[i]);
453
 
        
454
 
        out[i] = k;
455
 
        k *= tap_quant[i];
 
444
        if (xx == 0.0)
 
445
            k = 0;
 
446
        else
 
447
            k = (int)(floor(-xy/xx * (double)LATTICE_FACTOR / (double)(tap_quant[i]) + 0.5));
 
448
 
 
449
        if (k > (LATTICE_FACTOR/tap_quant[i]))
 
450
            k = LATTICE_FACTOR/tap_quant[i];
 
451
        if (-k > (LATTICE_FACTOR/tap_quant[i]))
 
452
            k = -(LATTICE_FACTOR/tap_quant[i]);
 
453
 
 
454
        out[i] = k;
 
455
        k *= tap_quant[i];
456
456
 
457
457
#if 1
458
 
        x_ptr = &(window[step]);
459
 
        state_ptr = &(state[0]);
460
 
        j = window_entries - step;
461
 
        for (;j>=0;j--,x_ptr++,state_ptr++)
462
 
        {
463
 
            int x_value = *x_ptr, state_value = *state_ptr;
464
 
            *x_ptr = x_value + shift_down(k*state_value,LATTICE_SHIFT);
465
 
            *state_ptr = state_value + shift_down(k*x_value, LATTICE_SHIFT);
466
 
        }
467
 
#else   
468
 
        for (j=0; j <= (window_entries - step); j++)
469
 
        {
470
 
            int stepval = window[step+j], stateval=state[j];
471
 
            window[step+j] += shift_down(k * stateval, LATTICE_SHIFT);
472
 
            state[j] += shift_down(k * stepval, LATTICE_SHIFT);
473
 
        }
 
458
        x_ptr = &(window[step]);
 
459
        state_ptr = &(state[0]);
 
460
        j = window_entries - step;
 
461
        for (;j>=0;j--,x_ptr++,state_ptr++)
 
462
        {
 
463
            int x_value = *x_ptr, state_value = *state_ptr;
 
464
            *x_ptr = x_value + shift_down(k*state_value,LATTICE_SHIFT);
 
465
            *state_ptr = state_value + shift_down(k*x_value, LATTICE_SHIFT);
 
466
        }
 
467
#else
 
468
        for (j=0; j <= (window_entries - step); j++)
 
469
        {
 
470
            int stepval = window[step+j], stateval=state[j];
 
471
            window[step+j] += shift_down(k * stateval, LATTICE_SHIFT);
 
472
            state[j] += shift_down(k * stepval, LATTICE_SHIFT);
 
473
        }
474
474
#endif
475
475
    }
476
 
    
 
476
 
477
477
    av_free(state);
478
478
}
479
479
 
486
486
{
487
487
    switch (samplerate)
488
488
    {
489
 
        case 44100: return 0;
490
 
        case 22050: return 1;
491
 
        case 11025: return 2;
492
 
        case 96000: return 3;
493
 
        case 48000: return 4;
494
 
        case 32000: return 5;
495
 
        case 24000: return 6;
496
 
        case 16000: return 7;
497
 
        case 8000: return 8;
 
489
        case 44100: return 0;
 
490
        case 22050: return 1;
 
491
        case 11025: return 2;
 
492
        case 96000: return 3;
 
493
        case 48000: return 4;
 
494
        case 32000: return 5;
 
495
        case 24000: return 6;
 
496
        case 16000: return 7;
 
497
        case 8000: return 8;
498
498
    }
499
499
    return -1;
500
500
}
507
507
 
508
508
    if (avctx->channels > MAX_CHANNELS)
509
509
    {
510
 
        av_log(avctx, AV_LOG_ERROR, "Only mono and stereo streams are supported by now\n");
 
510
        av_log(avctx, AV_LOG_ERROR, "Only mono and stereo streams are supported by now\n");
511
511
        return -1; /* only stereo or mono for now */
512
512
    }
513
513
 
514
514
    if (avctx->channels == 2)
515
 
        s->decorrelation = MID_SIDE;
 
515
        s->decorrelation = MID_SIDE;
516
516
 
517
517
    if (avctx->codec->id == CODEC_ID_SONIC_LS)
518
518
    {
519
 
        s->lossless = 1;
520
 
        s->num_taps = 32;
521
 
        s->downsampling = 1;
522
 
        s->quantization = 0.0;
 
519
        s->lossless = 1;
 
520
        s->num_taps = 32;
 
521
        s->downsampling = 1;
 
522
        s->quantization = 0.0;
523
523
    }
524
524
    else
525
525
    {
526
 
        s->num_taps = 128;
527
 
        s->downsampling = 2;
528
 
        s->quantization = 1.0;
 
526
        s->num_taps = 128;
 
527
        s->downsampling = 2;
 
528
        s->quantization = 1.0;
529
529
    }
530
530
 
531
531
    // max tap 2048
532
532
    if ((s->num_taps < 32) || (s->num_taps > 1024) ||
533
 
        ((s->num_taps>>5)<<5 != s->num_taps))
 
533
        ((s->num_taps>>5)<<5 != s->num_taps))
534
534
    {
535
 
        av_log(avctx, AV_LOG_ERROR, "Invalid number of taps\n");
536
 
        return -1;
 
535
        av_log(avctx, AV_LOG_ERROR, "Invalid number of taps\n");
 
536
        return -1;
537
537
    }
538
538
 
539
539
    // generate taps
540
540
    s->tap_quant = av_mallocz(4* s->num_taps);
541
541
    for (i = 0; i < s->num_taps; i++)
542
 
        s->tap_quant[i] = (int)(sqrt(i+1));
 
542
        s->tap_quant[i] = (int)(sqrt(i+1));
543
543
 
544
544
    s->channels = avctx->channels;
545
545
    s->samplerate = avctx->sample_rate;
549
549
 
550
550
    s->tail = av_mallocz(4* s->num_taps*s->channels);
551
551
    if (!s->tail)
552
 
        return -1;
 
552
        return -1;
553
553
    s->tail_size = s->num_taps*s->channels;
554
554
 
555
555
    s->predictor_k = av_mallocz(4 * s->num_taps);
556
556
    if (!s->predictor_k)
557
 
        return -1;
 
557
        return -1;
558
558
 
559
559
    for (i = 0; i < s->channels; i++)
560
560
    {
561
 
        s->coded_samples[i] = av_mallocz(4* s->block_align);
562
 
        if (!s->coded_samples[i])
563
 
            return -1;
 
561
        s->coded_samples[i] = av_mallocz(4* s->block_align);
 
562
        if (!s->coded_samples[i])
 
563
            return -1;
564
564
    }
565
 
    
 
565
 
566
566
    s->int_samples = av_mallocz(4* s->frame_size);
567
567
 
568
568
    s->window_size = ((2*s->tail_size)+s->frame_size);
569
569
    s->window = av_mallocz(4* s->window_size);
570
570
    if (!s->window)
571
 
        return -1;
 
571
        return -1;
572
572
 
573
573
    avctx->extradata = av_mallocz(16);
574
574
    if (!avctx->extradata)
575
 
        return -1;
 
575
        return -1;
576
576
    init_put_bits(&pb, avctx->extradata, 16*8);
577
577
 
578
578
    put_bits(&pb, 2, version); // version
579
579
    if (version == 1)
580
580
    {
581
 
        put_bits(&pb, 2, s->channels);
582
 
        put_bits(&pb, 4, code_samplerate(s->samplerate));
 
581
        put_bits(&pb, 2, s->channels);
 
582
        put_bits(&pb, 4, code_samplerate(s->samplerate));
583
583
    }
584
584
    put_bits(&pb, 1, s->lossless);
585
585
    if (!s->lossless)
586
 
        put_bits(&pb, 3, SAMPLE_SHIFT); // XXX FIXME: sample precision
 
586
        put_bits(&pb, 3, SAMPLE_SHIFT); // XXX FIXME: sample precision
587
587
    put_bits(&pb, 2, s->decorrelation);
588
588
    put_bits(&pb, 2, s->downsampling);
589
589
    put_bits(&pb, 5, (s->num_taps >> 5)-1); // 32..1024
593
593
    avctx->extradata_size = put_bits_count(&pb)/8;
594
594
 
595
595
    av_log(avctx, AV_LOG_INFO, "Sonic: ver: %d ls: %d dr: %d taps: %d block: %d frame: %d downsamp: %d\n",
596
 
        version, s->lossless, s->decorrelation, s->num_taps, s->block_align, s->frame_size, s->downsampling);
 
596
        version, s->lossless, s->decorrelation, s->num_taps, s->block_align, s->frame_size, s->downsampling);
597
597
 
598
598
    avctx->coded_frame = avcodec_alloc_frame();
599
599
    if (!avctx->coded_frame)
600
 
        return -ENOMEM;
 
600
        return -ENOMEM;
601
601
    avctx->coded_frame->key_frame = 1;
602
602
    avctx->frame_size = s->block_align*s->downsampling;
603
603
 
612
612
    av_freep(&avctx->coded_frame);
613
613
 
614
614
    for (i = 0; i < s->channels; i++)
615
 
        av_free(s->coded_samples[i]);
 
615
        av_free(s->coded_samples[i]);
616
616
 
617
617
    av_free(s->predictor_k);
618
618
    av_free(s->tail);
624
624
}
625
625
 
626
626
static int sonic_encode_frame(AVCodecContext *avctx,
627
 
                            uint8_t *buf, int buf_size, void *data)
 
627
                            uint8_t *buf, int buf_size, void *data)
628
628
{
629
629
    SonicContext *s = avctx->priv_data;
630
630
    PutBitContext pb;
635
635
 
636
636
    // short -> internal
637
637
    for (i = 0; i < s->frame_size; i++)
638
 
        s->int_samples[i] = samples[i];
 
638
        s->int_samples[i] = samples[i];
639
639
 
640
640
    if (!s->lossless)
641
 
        for (i = 0; i < s->frame_size; i++)
642
 
            s->int_samples[i] = s->int_samples[i] << SAMPLE_SHIFT;
 
641
        for (i = 0; i < s->frame_size; i++)
 
642
            s->int_samples[i] = s->int_samples[i] << SAMPLE_SHIFT;
643
643
 
644
644
    switch(s->decorrelation)
645
645
    {
646
 
        case MID_SIDE:
647
 
            for (i = 0; i < s->frame_size; i += s->channels)
648
 
            {
649
 
                s->int_samples[i] += s->int_samples[i+1];
650
 
                s->int_samples[i+1] -= shift(s->int_samples[i], 1);
651
 
            }
652
 
            break;
653
 
        case LEFT_SIDE:
654
 
            for (i = 0; i < s->frame_size; i += s->channels)
655
 
                s->int_samples[i+1] -= s->int_samples[i];
656
 
            break;
657
 
        case RIGHT_SIDE:
658
 
            for (i = 0; i < s->frame_size; i += s->channels)
659
 
                s->int_samples[i] -= s->int_samples[i+1];
660
 
            break;
 
646
        case MID_SIDE:
 
647
            for (i = 0; i < s->frame_size; i += s->channels)
 
648
            {
 
649
                s->int_samples[i] += s->int_samples[i+1];
 
650
                s->int_samples[i+1] -= shift(s->int_samples[i], 1);
 
651
            }
 
652
            break;
 
653
        case LEFT_SIDE:
 
654
            for (i = 0; i < s->frame_size; i += s->channels)
 
655
                s->int_samples[i+1] -= s->int_samples[i];
 
656
            break;
 
657
        case RIGHT_SIDE:
 
658
            for (i = 0; i < s->frame_size; i += s->channels)
 
659
                s->int_samples[i] -= s->int_samples[i+1];
 
660
            break;
661
661
    }
662
662
 
663
663
    memset(s->window, 0, 4* s->window_size);
664
 
    
 
664
 
665
665
    for (i = 0; i < s->tail_size; i++)
666
 
        s->window[x++] = s->tail[i];
 
666
        s->window[x++] = s->tail[i];
667
667
 
668
668
    for (i = 0; i < s->frame_size; i++)
669
 
        s->window[x++] = s->int_samples[i];
670
 
    
671
 
    for (i = 0; i < s->tail_size; i++)
672
 
        s->window[x++] = 0;
673
 
 
674
 
    for (i = 0; i < s->tail_size; i++)
675
 
        s->tail[i] = s->int_samples[s->frame_size - s->tail_size + i];
 
669
        s->window[x++] = s->int_samples[i];
 
670
 
 
671
    for (i = 0; i < s->tail_size; i++)
 
672
        s->window[x++] = 0;
 
673
 
 
674
    for (i = 0; i < s->tail_size; i++)
 
675
        s->tail[i] = s->int_samples[s->frame_size - s->tail_size + i];
676
676
 
677
677
    // generate taps
678
678
    modified_levinson_durbin(s->window, s->window_size,
679
 
                s->predictor_k, s->num_taps, s->channels, s->tap_quant);
 
679
                s->predictor_k, s->num_taps, s->channels, s->tap_quant);
680
680
    if (intlist_write(&pb, s->predictor_k, s->num_taps, 0) < 0)
681
 
        return -1;
 
681
        return -1;
682
682
 
683
683
    for (ch = 0; ch < s->channels; ch++)
684
684
    {
685
 
        x = s->tail_size+ch;
686
 
        for (i = 0; i < s->block_align; i++)
687
 
        {
688
 
            int sum = 0;
689
 
            for (j = 0; j < s->downsampling; j++, x += s->channels)
690
 
                sum += s->window[x];
691
 
            s->coded_samples[ch][i] = sum;
692
 
        }
 
685
        x = s->tail_size+ch;
 
686
        for (i = 0; i < s->block_align; i++)
 
687
        {
 
688
            int sum = 0;
 
689
            for (j = 0; j < s->downsampling; j++, x += s->channels)
 
690
                sum += s->window[x];
 
691
            s->coded_samples[ch][i] = sum;
 
692
        }
693
693
    }
694
 
    
695
 
    // simple rate control code    
 
694
 
 
695
    // simple rate control code
696
696
    if (!s->lossless)
697
697
    {
698
 
        double energy1 = 0.0, energy2 = 0.0;
699
 
        for (ch = 0; ch < s->channels; ch++)
700
 
        {
701
 
            for (i = 0; i < s->block_align; i++)
702
 
            {
703
 
                double sample = s->coded_samples[ch][i];
704
 
                energy2 += sample*sample;
705
 
                energy1 += fabs(sample);
706
 
            }
707
 
        }
708
 
        
709
 
        energy2 = sqrt(energy2/(s->channels*s->block_align));
710
 
        energy1 = sqrt(2.0)*energy1/(s->channels*s->block_align);
711
 
        
712
 
        // increase bitrate when samples are like a gaussian distribution
713
 
        // reduce bitrate when samples are like a two-tailed exponential distribution
714
 
        
715
 
        if (energy2 > energy1)
716
 
            energy2 += (energy2-energy1)*RATE_VARIATION;
717
 
        
718
 
        quant = (int)(BASE_QUANT*s->quantization*energy2/SAMPLE_FACTOR);
719
 
//      av_log(avctx, AV_LOG_DEBUG, "quant: %d energy: %f / %f\n", quant, energy1, energy2);
720
 
 
721
 
        if (quant < 1)
722
 
            quant = 1;
723
 
        if (quant > 65535)
724
 
            quant = 65535;
725
 
        
726
 
        set_ue_golomb(&pb, quant);
727
 
        
728
 
        quant *= SAMPLE_FACTOR;
 
698
        double energy1 = 0.0, energy2 = 0.0;
 
699
        for (ch = 0; ch < s->channels; ch++)
 
700
        {
 
701
            for (i = 0; i < s->block_align; i++)
 
702
            {
 
703
                double sample = s->coded_samples[ch][i];
 
704
                energy2 += sample*sample;
 
705
                energy1 += fabs(sample);
 
706
            }
 
707
        }
 
708
 
 
709
        energy2 = sqrt(energy2/(s->channels*s->block_align));
 
710
        energy1 = sqrt(2.0)*energy1/(s->channels*s->block_align);
 
711
 
 
712
        // increase bitrate when samples are like a gaussian distribution
 
713
        // reduce bitrate when samples are like a two-tailed exponential distribution
 
714
 
 
715
        if (energy2 > energy1)
 
716
            energy2 += (energy2-energy1)*RATE_VARIATION;
 
717
 
 
718
        quant = (int)(BASE_QUANT*s->quantization*energy2/SAMPLE_FACTOR);
 
719
//        av_log(avctx, AV_LOG_DEBUG, "quant: %d energy: %f / %f\n", quant, energy1, energy2);
 
720
 
 
721
        if (quant < 1)
 
722
            quant = 1;
 
723
        if (quant > 65535)
 
724
            quant = 65535;
 
725
 
 
726
        set_ue_golomb(&pb, quant);
 
727
 
 
728
        quant *= SAMPLE_FACTOR;
729
729
    }
730
730
 
731
731
    // write out coded samples
732
732
    for (ch = 0; ch < s->channels; ch++)
733
733
    {
734
 
        if (!s->lossless)
735
 
            for (i = 0; i < s->block_align; i++)
736
 
                s->coded_samples[ch][i] = divide(s->coded_samples[ch][i], quant);
 
734
        if (!s->lossless)
 
735
            for (i = 0; i < s->block_align; i++)
 
736
                s->coded_samples[ch][i] = divide(s->coded_samples[ch][i], quant);
737
737
 
738
 
        if (intlist_write(&pb, s->coded_samples[ch], s->block_align, 1) < 0)
739
 
            return -1;
 
738
        if (intlist_write(&pb, s->coded_samples[ch], s->block_align, 1) < 0)
 
739
            return -1;
740
740
    }
741
741
 
742
742
//    av_log(avctx, AV_LOG_DEBUG, "used bytes: %d\n", (put_bits_count(&pb)+7)/8);
751
751
    SonicContext *s = avctx->priv_data;
752
752
    GetBitContext gb;
753
753
    int i, version;
754
 
    
 
754
 
755
755
    s->channels = avctx->channels;
756
756
    s->samplerate = avctx->sample_rate;
757
 
    
 
757
 
758
758
    if (!avctx->extradata)
759
759
    {
760
 
        av_log(avctx, AV_LOG_ERROR, "No mandatory headers present\n");
761
 
        return -1;
 
760
        av_log(avctx, AV_LOG_ERROR, "No mandatory headers present\n");
 
761
        return -1;
762
762
    }
763
 
    
 
763
 
764
764
    init_get_bits(&gb, avctx->extradata, avctx->extradata_size);
765
 
    
 
765
 
766
766
    version = get_bits(&gb, 2);
767
767
    if (version > 1)
768
768
    {
769
 
        av_log(avctx, AV_LOG_ERROR, "Unsupported Sonic version, please report\n");
770
 
        return -1;
 
769
        av_log(avctx, AV_LOG_ERROR, "Unsupported Sonic version, please report\n");
 
770
        return -1;
771
771
    }
772
772
 
773
773
    if (version == 1)
774
774
    {
775
 
        s->channels = get_bits(&gb, 2);
776
 
        s->samplerate = samplerate_table[get_bits(&gb, 4)];
777
 
        av_log(avctx, AV_LOG_INFO, "Sonicv2 chans: %d samprate: %d\n",
778
 
            s->channels, s->samplerate);
 
775
        s->channels = get_bits(&gb, 2);
 
776
        s->samplerate = samplerate_table[get_bits(&gb, 4)];
 
777
        av_log(avctx, AV_LOG_INFO, "Sonicv2 chans: %d samprate: %d\n",
 
778
            s->channels, s->samplerate);
779
779
    }
780
780
 
781
781
    if (s->channels > MAX_CHANNELS)
782
782
    {
783
 
        av_log(avctx, AV_LOG_ERROR, "Only mono and stereo streams are supported by now\n");
784
 
        return -1;
 
783
        av_log(avctx, AV_LOG_ERROR, "Only mono and stereo streams are supported by now\n");
 
784
        return -1;
785
785
    }
786
786
 
787
787
    s->lossless = get_bits1(&gb);
788
788
    if (!s->lossless)
789
 
        skip_bits(&gb, 3); // XXX FIXME
 
789
        skip_bits(&gb, 3); // XXX FIXME
790
790
    s->decorrelation = get_bits(&gb, 2);
791
791
 
792
792
    s->downsampling = get_bits(&gb, 2);
793
793
    s->num_taps = (get_bits(&gb, 5)+1)<<5;
794
794
    if (get_bits1(&gb)) // XXX FIXME
795
 
        av_log(avctx, AV_LOG_INFO, "Custom quant table\n");
796
 
    
 
795
        av_log(avctx, AV_LOG_INFO, "Custom quant table\n");
 
796
 
797
797
    s->block_align = (int)(2048.0*(s->samplerate/44100))/s->downsampling;
798
798
    s->frame_size = s->channels*s->block_align*s->downsampling;
799
799
//    avctx->frame_size = s->block_align;
800
800
 
801
801
    av_log(avctx, AV_LOG_INFO, "Sonic: ver: %d ls: %d dr: %d taps: %d block: %d frame: %d downsamp: %d\n",
802
 
        version, s->lossless, s->decorrelation, s->num_taps, s->block_align, s->frame_size, s->downsampling);
 
802
        version, s->lossless, s->decorrelation, s->num_taps, s->block_align, s->frame_size, s->downsampling);
803
803
 
804
804
    // generate taps
805
805
    s->tap_quant = av_mallocz(4* s->num_taps);
806
806
    for (i = 0; i < s->num_taps; i++)
807
 
        s->tap_quant[i] = (int)(sqrt(i+1));
808
 
    
 
807
        s->tap_quant[i] = (int)(sqrt(i+1));
 
808
 
809
809
    s->predictor_k = av_mallocz(4* s->num_taps);
810
 
    
 
810
 
811
811
    for (i = 0; i < s->channels; i++)
812
812
    {
813
 
        s->predictor_state[i] = av_mallocz(4* s->num_taps);
814
 
        if (!s->predictor_state[i])
815
 
            return -1;
 
813
        s->predictor_state[i] = av_mallocz(4* s->num_taps);
 
814
        if (!s->predictor_state[i])
 
815
            return -1;
816
816
    }
817
817
 
818
818
    for (i = 0; i < s->channels; i++)
819
819
    {
820
 
        s->coded_samples[i] = av_mallocz(4* s->block_align);
821
 
        if (!s->coded_samples[i])
822
 
            return -1;
 
820
        s->coded_samples[i] = av_mallocz(4* s->block_align);
 
821
        if (!s->coded_samples[i])
 
822
            return -1;
823
823
    }
824
824
    s->int_samples = av_mallocz(4* s->frame_size);
825
825
 
830
830
{
831
831
    SonicContext *s = avctx->priv_data;
832
832
    int i;
833
 
    
 
833
 
834
834
    av_free(s->int_samples);
835
835
    av_free(s->tap_quant);
836
836
    av_free(s->predictor_k);
837
 
    
 
837
 
838
838
    for (i = 0; i < s->channels; i++)
839
839
    {
840
 
        av_free(s->predictor_state[i]);
841
 
        av_free(s->coded_samples[i]);
 
840
        av_free(s->predictor_state[i]);
 
841
        av_free(s->coded_samples[i]);
842
842
    }
843
 
    
 
843
 
844
844
    return 0;
845
845
}
846
846
 
847
847
static int sonic_decode_frame(AVCodecContext *avctx,
848
 
                            void *data, int *data_size,
849
 
                            uint8_t *buf, int buf_size)
 
848
                            void *data, int *data_size,
 
849
                            uint8_t *buf, int buf_size)
850
850
{
851
851
    SonicContext *s = avctx->priv_data;
852
852
    GetBitContext gb;
856
856
    if (buf_size == 0) return 0;
857
857
 
858
858
//    av_log(NULL, AV_LOG_INFO, "buf_size: %d\n", buf_size);
859
 
    
 
859
 
860
860
    init_get_bits(&gb, buf, buf_size*8);
861
 
    
 
861
 
862
862
    intlist_read(&gb, s->predictor_k, s->num_taps, 0);
863
863
 
864
864
    // dequantize
865
865
    for (i = 0; i < s->num_taps; i++)
866
 
        s->predictor_k[i] *= s->tap_quant[i];
 
866
        s->predictor_k[i] *= s->tap_quant[i];
867
867
 
868
868
    if (s->lossless)
869
 
        quant = 1;
 
869
        quant = 1;
870
870
    else
871
 
        quant = get_ue_golomb(&gb) * SAMPLE_FACTOR;
 
871
        quant = get_ue_golomb(&gb) * SAMPLE_FACTOR;
872
872
 
873
873
//    av_log(NULL, AV_LOG_INFO, "quant: %d\n", quant);
874
874
 
875
875
    for (ch = 0; ch < s->channels; ch++)
876
876
    {
877
 
        int x = ch;
878
 
 
879
 
        predictor_init_state(s->predictor_k, s->predictor_state[ch], s->num_taps);
880
 
        
881
 
        intlist_read(&gb, s->coded_samples[ch], s->block_align, 1);
882
 
 
883
 
        for (i = 0; i < s->block_align; i++)
884
 
        {
885
 
            for (j = 0; j < s->downsampling - 1; j++)
886
 
            {
887
 
                s->int_samples[x] = predictor_calc_error(s->predictor_k, s->predictor_state[ch], s->num_taps, 0);
888
 
                x += s->channels;
889
 
            }
890
 
            
891
 
            s->int_samples[x] = predictor_calc_error(s->predictor_k, s->predictor_state[ch], s->num_taps, s->coded_samples[ch][i] * quant);
892
 
            x += s->channels;
893
 
        }
894
 
 
895
 
        for (i = 0; i < s->num_taps; i++)
896
 
            s->predictor_state[ch][i] = s->int_samples[s->frame_size - s->channels + ch - i*s->channels];
 
877
        int x = ch;
 
878
 
 
879
        predictor_init_state(s->predictor_k, s->predictor_state[ch], s->num_taps);
 
880
 
 
881
        intlist_read(&gb, s->coded_samples[ch], s->block_align, 1);
 
882
 
 
883
        for (i = 0; i < s->block_align; i++)
 
884
        {
 
885
            for (j = 0; j < s->downsampling - 1; j++)
 
886
            {
 
887
                s->int_samples[x] = predictor_calc_error(s->predictor_k, s->predictor_state[ch], s->num_taps, 0);
 
888
                x += s->channels;
 
889
            }
 
890
 
 
891
            s->int_samples[x] = predictor_calc_error(s->predictor_k, s->predictor_state[ch], s->num_taps, s->coded_samples[ch][i] * quant);
 
892
            x += s->channels;
 
893
        }
 
894
 
 
895
        for (i = 0; i < s->num_taps; i++)
 
896
            s->predictor_state[ch][i] = s->int_samples[s->frame_size - s->channels + ch - i*s->channels];
897
897
    }
898
 
    
 
898
 
899
899
    switch(s->decorrelation)
900
900
    {
901
 
        case MID_SIDE:
902
 
            for (i = 0; i < s->frame_size; i += s->channels)
903
 
            {
904
 
                s->int_samples[i+1] += shift(s->int_samples[i], 1);
905
 
                s->int_samples[i] -= s->int_samples[i+1];
906
 
            }
907
 
            break;
908
 
        case LEFT_SIDE:
909
 
            for (i = 0; i < s->frame_size; i += s->channels)
910
 
                s->int_samples[i+1] += s->int_samples[i];
911
 
            break;
912
 
        case RIGHT_SIDE:
913
 
            for (i = 0; i < s->frame_size; i += s->channels)
914
 
                s->int_samples[i] += s->int_samples[i+1];
915
 
            break;
 
901
        case MID_SIDE:
 
902
            for (i = 0; i < s->frame_size; i += s->channels)
 
903
            {
 
904
                s->int_samples[i+1] += shift(s->int_samples[i], 1);
 
905
                s->int_samples[i] -= s->int_samples[i+1];
 
906
            }
 
907
            break;
 
908
        case LEFT_SIDE:
 
909
            for (i = 0; i < s->frame_size; i += s->channels)
 
910
                s->int_samples[i+1] += s->int_samples[i];
 
911
            break;
 
912
        case RIGHT_SIDE:
 
913
            for (i = 0; i < s->frame_size; i += s->channels)
 
914
                s->int_samples[i] += s->int_samples[i+1];
 
915
            break;
916
916
    }
917
917
 
918
918
    if (!s->lossless)
919
 
        for (i = 0; i < s->frame_size; i++)
920
 
            s->int_samples[i] = shift(s->int_samples[i], SAMPLE_SHIFT);
 
919
        for (i = 0; i < s->frame_size; i++)
 
920
            s->int_samples[i] = shift(s->int_samples[i], SAMPLE_SHIFT);
921
921
 
922
922
    // internal -> short
923
923
    for (i = 0; i < s->frame_size; i++)
924
924
    {
925
 
        if (s->int_samples[i] > 32767)
926
 
            samples[i] = 32767;
927
 
        else if (s->int_samples[i] < -32768)
928
 
            samples[i] = -32768;
929
 
        else
930
 
            samples[i] = s->int_samples[i];
 
925
        if (s->int_samples[i] > 32767)
 
926
            samples[i] = 32767;
 
927
        else if (s->int_samples[i] < -32768)
 
928
            samples[i] = -32768;
 
929
        else
 
930
            samples[i] = s->int_samples[i];
931
931
    }
932
932
 
933
933
    align_get_bits(&gb);