1/* 2 * Simple free lossless/lossy audio codec 3 * Copyright (c) 2004 Alex Beregszaszi 4 * 5 * This file is part of FFmpeg. 6 * 7 * FFmpeg is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * FFmpeg is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with FFmpeg; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 */ 21#include "avcodec.h" 22#include "get_bits.h" 23#include "golomb.h" 24 25/** 26 * @file 27 * Simple free lossless/lossy audio codec 28 * Based on Paul Francis Harrison's Bonk (http://www.logarithmic.net/pfh/bonk) 29 * Written and designed by Alex Beregszaszi 30 * 31 * TODO: 32 * - CABAC put/get_symbol 33 * - independent quantizer for channels 34 * - >2 channels support 35 * - more decorrelation types 36 * - more tap_quant tests 37 * - selectable intlist writers/readers (bonk-style, golomb, cabac) 38 */ 39 40#define MAX_CHANNELS 2 41 42#define MID_SIDE 0 43#define LEFT_SIDE 1 44#define RIGHT_SIDE 2 45 46typedef struct SonicContext { 47 int lossless, decorrelation; 48 49 int num_taps, downsampling; 50 double quantization; 51 52 int channels, samplerate, block_align, frame_size; 53 54 int *tap_quant; 55 int *int_samples; 56 int *coded_samples[MAX_CHANNELS]; 57 58 // for encoding 59 int *tail; 60 int tail_size; 61 int *window; 62 int window_size; 63 64 // for decoding 65 int *predictor_k; 66 int *predictor_state[MAX_CHANNELS]; 67} SonicContext; 68 69#define LATTICE_SHIFT 10 70#define SAMPLE_SHIFT 4 71#define LATTICE_FACTOR (1 << LATTICE_SHIFT) 72#define SAMPLE_FACTOR (1 << SAMPLE_SHIFT) 73 74#define BASE_QUANT 0.6 75#define RATE_VARIATION 3.0 76 77static inline int divide(int a, int b) 78{ 79 if (a < 0) 80 return -( (-a + b/2)/b ); 81 else 82 return (a + b/2)/b; 83} 84 85static inline int shift(int a,int b) 86{ 87 return (a+(1<<(b-1))) >> b; 88} 89 90static inline int shift_down(int a,int b) 91{ 92 return (a>>b)+((a<0)?1:0); 93} 94 95#if 1 96static inline int intlist_write(PutBitContext *pb, int *buf, int entries, int base_2_part) 97{ 98 int i; 99 100 for (i = 0; i < entries; i++) 101 set_se_golomb(pb, buf[i]); 102 103 return 1; 104} 105 106static inline int intlist_read(GetBitContext *gb, int *buf, int entries, int base_2_part) 107{ 108 int i; 109 110 for (i = 0; i < entries; i++) 111 buf[i] = get_se_golomb(gb); 112 113 return 1; 114} 115 116#else 117 118#define ADAPT_LEVEL 8 119 120static int bits_to_store(uint64_t x) 121{ 122 int res = 0; 123 124 while(x) 125 { 126 res++; 127 x >>= 1; 128 } 129 return res; 130} 131 132static void write_uint_max(PutBitContext *pb, unsigned int value, unsigned int max) 133{ 134 int i, bits; 135 136 if (!max) 137 return; 138 139 bits = bits_to_store(max); 140 141 for (i = 0; i < bits-1; i++) 142 put_bits(pb, 1, value & (1 << i)); 143 144 if ( (value | (1 << (bits-1))) <= max) 145 put_bits(pb, 1, value & (1 << (bits-1))); 146} 147 148static unsigned int read_uint_max(GetBitContext *gb, int max) 149{ 150 int i, bits, value = 0; 151 152 if (!max) 153 return 0; 154 155 bits = bits_to_store(max); 156 157 for (i = 0; i < bits-1; i++) 158 if (get_bits1(gb)) 159 value += 1 << i; 160 161 if ( (value | (1<<(bits-1))) <= max) 162 if (get_bits1(gb)) 163 value += 1 << (bits-1); 164 165 return value; 166} 167 168static int intlist_write(PutBitContext *pb, int *buf, int entries, int base_2_part) 169{ 170 int i, j, x = 0, low_bits = 0, max = 0; 171 int step = 256, pos = 0, dominant = 0, any = 0; 172 int *copy, *bits; 173 174 copy = av_mallocz(4* entries); 175 if (!copy) 176 return -1; 177 178 if (base_2_part) 179 { 180 int energy = 0; 181 182 for (i = 0; i < entries; i++) 183 energy += abs(buf[i]); 184 185 low_bits = bits_to_store(energy / (entries * 2)); 186 if (low_bits > 15) 187 low_bits = 15; 188 189 put_bits(pb, 4, low_bits); 190 } 191 192 for (i = 0; i < entries; i++) 193 { 194 put_bits(pb, low_bits, abs(buf[i])); 195 copy[i] = abs(buf[i]) >> low_bits; 196 if (copy[i] > max) 197 max = abs(copy[i]); 198 } 199 200 bits = av_mallocz(4* entries*max); 201 if (!bits) 202 { 203// av_free(copy); 204 return -1; 205 } 206 207 for (i = 0; i <= max; i++) 208 { 209 for (j = 0; j < entries; j++) 210 if (copy[j] >= i) 211 bits[x++] = copy[j] > i; 212 } 213 214 // store bitstream 215 while (pos < x) 216 { 217 int steplet = step >> 8; 218 219 if (pos + steplet > x) 220 steplet = x - pos; 221 222 for (i = 0; i < steplet; i++) 223 if (bits[i+pos] != dominant) 224 any = 1; 225 226 put_bits(pb, 1, any); 227 228 if (!any) 229 { 230 pos += steplet; 231 step += step / ADAPT_LEVEL; 232 } 233 else 234 { 235 int interloper = 0; 236 237 while (((pos + interloper) < x) && (bits[pos + interloper] == dominant)) 238 interloper++; 239 240 // note change 241 write_uint_max(pb, interloper, (step >> 8) - 1); 242 243 pos += interloper + 1; 244 step -= step / ADAPT_LEVEL; 245 } 246 247 if (step < 256) 248 { 249 step = 65536 / step; 250 dominant = !dominant; 251 } 252 } 253 254 // store signs 255 for (i = 0; i < entries; i++) 256 if (buf[i]) 257 put_bits(pb, 1, buf[i] < 0); 258 259// av_free(bits); 260// av_free(copy); 261 262 return 0; 263} 264 265static int intlist_read(GetBitContext *gb, int *buf, int entries, int base_2_part) 266{ 267 int i, low_bits = 0, x = 0; 268 int n_zeros = 0, step = 256, dominant = 0; 269 int pos = 0, level = 0; 270 int *bits = av_mallocz(4* entries); 271 272 if (!bits) 273 return -1; 274 275 if (base_2_part) 276 { 277 low_bits = get_bits(gb, 4); 278 279 if (low_bits) 280 for (i = 0; i < entries; i++) 281 buf[i] = get_bits(gb, low_bits); 282 } 283 284// av_log(NULL, AV_LOG_INFO, "entries: %d, low bits: %d\n", entries, low_bits); 285 286 while (n_zeros < entries) 287 { 288 int steplet = step >> 8; 289 290 if (!get_bits1(gb)) 291 { 292 for (i = 0; i < steplet; i++) 293 bits[x++] = dominant; 294 295 if (!dominant) 296 n_zeros += steplet; 297 298 step += step / ADAPT_LEVEL; 299 } 300 else 301 { 302 int actual_run = read_uint_max(gb, steplet-1); 303 304// av_log(NULL, AV_LOG_INFO, "actual run: %d\n", actual_run); 305 306 for (i = 0; i < actual_run; i++) 307 bits[x++] = dominant; 308 309 bits[x++] = !dominant; 310 311 if (!dominant) 312 n_zeros += actual_run; 313 else 314 n_zeros++; 315 316 step -= step / ADAPT_LEVEL; 317 } 318 319 if (step < 256) 320 { 321 step = 65536 / step; 322 dominant = !dominant; 323 } 324 } 325 326 // reconstruct unsigned values 327 n_zeros = 0; 328 for (i = 0; n_zeros < entries; i++) 329 { 330 while(1) 331 { 332 if (pos >= entries) 333 { 334 pos = 0; 335 level += 1 << low_bits; 336 } 337 338 if (buf[pos] >= level) 339 break; 340 341 pos++; 342 } 343 344 if (bits[i]) 345 buf[pos] += 1 << low_bits; 346 else 347 n_zeros++; 348 349 pos++; 350 } 351// av_free(bits); 352 353 // read signs 354 for (i = 0; i < entries; i++) 355 if (buf[i] && get_bits1(gb)) 356 buf[i] = -buf[i]; 357 358// av_log(NULL, AV_LOG_INFO, "zeros: %d pos: %d\n", n_zeros, pos); 359 360 return 0; 361} 362#endif 363 364static void predictor_init_state(int *k, int *state, int order) 365{ 366 int i; 367 368 for (i = order-2; i >= 0; i--) 369 { 370 int j, p, x = state[i]; 371 372 for (j = 0, p = i+1; p < order; j++,p++) 373 { 374 int tmp = x + shift_down(k[j] * state[p], LATTICE_SHIFT); 375 state[p] += shift_down(k[j]*x, LATTICE_SHIFT); 376 x = tmp; 377 } 378 } 379} 380 381static int predictor_calc_error(int *k, int *state, int order, int error) 382{ 383 int i, x = error - shift_down(k[order-1] * state[order-1], LATTICE_SHIFT); 384 385#if 1 386 int *k_ptr = &(k[order-2]), 387 *state_ptr = &(state[order-2]); 388 for (i = order-2; i >= 0; i--, k_ptr--, state_ptr--) 389 { 390 int k_value = *k_ptr, state_value = *state_ptr; 391 x -= shift_down(k_value * state_value, LATTICE_SHIFT); 392 state_ptr[1] = state_value + shift_down(k_value * x, LATTICE_SHIFT); 393 } 394#else 395 for (i = order-2; i >= 0; i--) 396 { 397 x -= shift_down(k[i] * state[i], LATTICE_SHIFT); 398 state[i+1] = state[i] + shift_down(k[i] * x, LATTICE_SHIFT); 399 } 400#endif 401 402 // don't drift too far, to avoid overflows 403 if (x > (SAMPLE_FACTOR<<16)) x = (SAMPLE_FACTOR<<16); 404 if (x < -(SAMPLE_FACTOR<<16)) x = -(SAMPLE_FACTOR<<16); 405 406 state[0] = x; 407 408 return x; 409} 410 411#if CONFIG_SONIC_ENCODER || CONFIG_SONIC_LS_ENCODER 412// Heavily modified Levinson-Durbin algorithm which 413// copes better with quantization, and calculates the 414// actual whitened result as it goes. 415 416static void modified_levinson_durbin(int *window, int window_entries, 417 int *out, int out_entries, int channels, int *tap_quant) 418{ 419 int i; 420 int *state = av_mallocz(4* window_entries); 421 422 memcpy(state, window, 4* window_entries); 423 424 for (i = 0; i < out_entries; i++) 425 { 426 int step = (i+1)*channels, k, j; 427 double xx = 0.0, xy = 0.0; 428#if 1 429 int *x_ptr = &(window[step]), *state_ptr = &(state[0]); 430 j = window_entries - step; 431 for (;j>=0;j--,x_ptr++,state_ptr++) 432 { 433 double x_value = *x_ptr, state_value = *state_ptr; 434 xx += state_value*state_value; 435 xy += x_value*state_value; 436 } 437#else 438 for (j = 0; j <= (window_entries - step); j++); 439 { 440 double stepval = window[step+j], stateval = window[j]; 441// xx += (double)window[j]*(double)window[j]; 442// xy += (double)window[step+j]*(double)window[j]; 443 xx += stateval*stateval; 444 xy += stepval*stateval; 445 } 446#endif 447 if (xx == 0.0) 448 k = 0; 449 else 450 k = (int)(floor(-xy/xx * (double)LATTICE_FACTOR / (double)(tap_quant[i]) + 0.5)); 451 452 if (k > (LATTICE_FACTOR/tap_quant[i])) 453 k = LATTICE_FACTOR/tap_quant[i]; 454 if (-k > (LATTICE_FACTOR/tap_quant[i])) 455 k = -(LATTICE_FACTOR/tap_quant[i]); 456 457 out[i] = k; 458 k *= tap_quant[i]; 459 460#if 1 461 x_ptr = &(window[step]); 462 state_ptr = &(state[0]); 463 j = window_entries - step; 464 for (;j>=0;j--,x_ptr++,state_ptr++) 465 { 466 int x_value = *x_ptr, state_value = *state_ptr; 467 *x_ptr = x_value + shift_down(k*state_value,LATTICE_SHIFT); 468 *state_ptr = state_value + shift_down(k*x_value, LATTICE_SHIFT); 469 } 470#else 471 for (j=0; j <= (window_entries - step); j++) 472 { 473 int stepval = window[step+j], stateval=state[j]; 474 window[step+j] += shift_down(k * stateval, LATTICE_SHIFT); 475 state[j] += shift_down(k * stepval, LATTICE_SHIFT); 476 } 477#endif 478 } 479 480 av_free(state); 481} 482 483static inline int code_samplerate(int samplerate) 484{ 485 switch (samplerate) 486 { 487 case 44100: return 0; 488 case 22050: return 1; 489 case 11025: return 2; 490 case 96000: return 3; 491 case 48000: return 4; 492 case 32000: return 5; 493 case 24000: return 6; 494 case 16000: return 7; 495 case 8000: return 8; 496 } 497 return -1; 498} 499 500static av_cold int sonic_encode_init(AVCodecContext *avctx) 501{ 502 SonicContext *s = avctx->priv_data; 503 PutBitContext pb; 504 int i, version = 0; 505 506 if (avctx->channels > MAX_CHANNELS) 507 { 508 av_log(avctx, AV_LOG_ERROR, "Only mono and stereo streams are supported by now\n"); 509 return -1; /* only stereo or mono for now */ 510 } 511 512 if (avctx->channels == 2) 513 s->decorrelation = MID_SIDE; 514 515 if (avctx->codec->id == CODEC_ID_SONIC_LS) 516 { 517 s->lossless = 1; 518 s->num_taps = 32; 519 s->downsampling = 1; 520 s->quantization = 0.0; 521 } 522 else 523 { 524 s->num_taps = 128; 525 s->downsampling = 2; 526 s->quantization = 1.0; 527 } 528 529 // max tap 2048 530 if ((s->num_taps < 32) || (s->num_taps > 1024) || 531 ((s->num_taps>>5)<<5 != s->num_taps)) 532 { 533 av_log(avctx, AV_LOG_ERROR, "Invalid number of taps\n"); 534 return -1; 535 } 536 537 // generate taps 538 s->tap_quant = av_mallocz(4* s->num_taps); 539 for (i = 0; i < s->num_taps; i++) 540 s->tap_quant[i] = (int)(sqrt(i+1)); 541 542 s->channels = avctx->channels; 543 s->samplerate = avctx->sample_rate; 544 545 s->block_align = (int)(2048.0*s->samplerate/44100)/s->downsampling; 546 s->frame_size = s->channels*s->block_align*s->downsampling; 547 548 s->tail = av_mallocz(4* s->num_taps*s->channels); 549 if (!s->tail) 550 return -1; 551 s->tail_size = s->num_taps*s->channels; 552 553 s->predictor_k = av_mallocz(4 * s->num_taps); 554 if (!s->predictor_k) 555 return -1; 556 557 for (i = 0; i < s->channels; i++) 558 { 559 s->coded_samples[i] = av_mallocz(4* s->block_align); 560 if (!s->coded_samples[i]) 561 return -1; 562 } 563 564 s->int_samples = av_mallocz(4* s->frame_size); 565 566 s->window_size = ((2*s->tail_size)+s->frame_size); 567 s->window = av_mallocz(4* s->window_size); 568 if (!s->window) 569 return -1; 570 571 avctx->extradata = av_mallocz(16); 572 if (!avctx->extradata) 573 return -1; 574 init_put_bits(&pb, avctx->extradata, 16*8); 575 576 put_bits(&pb, 2, version); // version 577 if (version == 1) 578 { 579 put_bits(&pb, 2, s->channels); 580 put_bits(&pb, 4, code_samplerate(s->samplerate)); 581 } 582 put_bits(&pb, 1, s->lossless); 583 if (!s->lossless) 584 put_bits(&pb, 3, SAMPLE_SHIFT); // XXX FIXME: sample precision 585 put_bits(&pb, 2, s->decorrelation); 586 put_bits(&pb, 2, s->downsampling); 587 put_bits(&pb, 5, (s->num_taps >> 5)-1); // 32..1024 588 put_bits(&pb, 1, 0); // XXX FIXME: no custom tap quant table 589 590 flush_put_bits(&pb); 591 avctx->extradata_size = put_bits_count(&pb)/8; 592 593 av_log(avctx, AV_LOG_INFO, "Sonic: ver: %d ls: %d dr: %d taps: %d block: %d frame: %d downsamp: %d\n", 594 version, s->lossless, s->decorrelation, s->num_taps, s->block_align, s->frame_size, s->downsampling); 595 596 avctx->coded_frame = avcodec_alloc_frame(); 597 if (!avctx->coded_frame) 598 return AVERROR(ENOMEM); 599 avctx->coded_frame->key_frame = 1; 600 avctx->frame_size = s->block_align*s->downsampling; 601 602 return 0; 603} 604 605static av_cold int sonic_encode_close(AVCodecContext *avctx) 606{ 607 SonicContext *s = avctx->priv_data; 608 int i; 609 610 av_freep(&avctx->coded_frame); 611 612 for (i = 0; i < s->channels; i++) 613 av_free(s->coded_samples[i]); 614 615 av_free(s->predictor_k); 616 av_free(s->tail); 617 av_free(s->tap_quant); 618 av_free(s->window); 619 av_free(s->int_samples); 620 621 return 0; 622} 623 624static int sonic_encode_frame(AVCodecContext *avctx, 625 uint8_t *buf, int buf_size, void *data) 626{ 627 SonicContext *s = avctx->priv_data; 628 PutBitContext pb; 629 int i, j, ch, quant = 0, x = 0; 630 short *samples = data; 631 632 init_put_bits(&pb, buf, buf_size*8); 633 634 // short -> internal 635 for (i = 0; i < s->frame_size; i++) 636 s->int_samples[i] = samples[i]; 637 638 if (!s->lossless) 639 for (i = 0; i < s->frame_size; i++) 640 s->int_samples[i] = s->int_samples[i] << SAMPLE_SHIFT; 641 642 switch(s->decorrelation) 643 { 644 case MID_SIDE: 645 for (i = 0; i < s->frame_size; i += s->channels) 646 { 647 s->int_samples[i] += s->int_samples[i+1]; 648 s->int_samples[i+1] -= shift(s->int_samples[i], 1); 649 } 650 break; 651 case LEFT_SIDE: 652 for (i = 0; i < s->frame_size; i += s->channels) 653 s->int_samples[i+1] -= s->int_samples[i]; 654 break; 655 case RIGHT_SIDE: 656 for (i = 0; i < s->frame_size; i += s->channels) 657 s->int_samples[i] -= s->int_samples[i+1]; 658 break; 659 } 660 661 memset(s->window, 0, 4* s->window_size); 662 663 for (i = 0; i < s->tail_size; i++) 664 s->window[x++] = s->tail[i]; 665 666 for (i = 0; i < s->frame_size; i++) 667 s->window[x++] = s->int_samples[i]; 668 669 for (i = 0; i < s->tail_size; i++) 670 s->window[x++] = 0; 671 672 for (i = 0; i < s->tail_size; i++) 673 s->tail[i] = s->int_samples[s->frame_size - s->tail_size + i]; 674 675 // generate taps 676 modified_levinson_durbin(s->window, s->window_size, 677 s->predictor_k, s->num_taps, s->channels, s->tap_quant); 678 if (intlist_write(&pb, s->predictor_k, s->num_taps, 0) < 0) 679 return -1; 680 681 for (ch = 0; ch < s->channels; ch++) 682 { 683 x = s->tail_size+ch; 684 for (i = 0; i < s->block_align; i++) 685 { 686 int sum = 0; 687 for (j = 0; j < s->downsampling; j++, x += s->channels) 688 sum += s->window[x]; 689 s->coded_samples[ch][i] = sum; 690 } 691 } 692 693 // simple rate control code 694 if (!s->lossless) 695 { 696 double energy1 = 0.0, energy2 = 0.0; 697 for (ch = 0; ch < s->channels; ch++) 698 { 699 for (i = 0; i < s->block_align; i++) 700 { 701 double sample = s->coded_samples[ch][i]; 702 energy2 += sample*sample; 703 energy1 += fabs(sample); 704 } 705 } 706 707 energy2 = sqrt(energy2/(s->channels*s->block_align)); 708 energy1 = sqrt(2.0)*energy1/(s->channels*s->block_align); 709 710 // increase bitrate when samples are like a gaussian distribution 711 // reduce bitrate when samples are like a two-tailed exponential distribution 712 713 if (energy2 > energy1) 714 energy2 += (energy2-energy1)*RATE_VARIATION; 715 716 quant = (int)(BASE_QUANT*s->quantization*energy2/SAMPLE_FACTOR); 717// av_log(avctx, AV_LOG_DEBUG, "quant: %d energy: %f / %f\n", quant, energy1, energy2); 718 719 if (quant < 1) 720 quant = 1; 721 if (quant > 65535) 722 quant = 65535; 723 724 set_ue_golomb(&pb, quant); 725 726 quant *= SAMPLE_FACTOR; 727 } 728 729 // write out coded samples 730 for (ch = 0; ch < s->channels; ch++) 731 { 732 if (!s->lossless) 733 for (i = 0; i < s->block_align; i++) 734 s->coded_samples[ch][i] = divide(s->coded_samples[ch][i], quant); 735 736 if (intlist_write(&pb, s->coded_samples[ch], s->block_align, 1) < 0) 737 return -1; 738 } 739 740// av_log(avctx, AV_LOG_DEBUG, "used bytes: %d\n", (put_bits_count(&pb)+7)/8); 741 742 flush_put_bits(&pb); 743 return (put_bits_count(&pb)+7)/8; 744} 745#endif /* CONFIG_SONIC_ENCODER || CONFIG_SONIC_LS_ENCODER */ 746 747#if CONFIG_SONIC_DECODER 748static const int samplerate_table[] = 749 { 44100, 22050, 11025, 96000, 48000, 32000, 24000, 16000, 8000 }; 750 751static av_cold int sonic_decode_init(AVCodecContext *avctx) 752{ 753 SonicContext *s = avctx->priv_data; 754 GetBitContext gb; 755 int i, version; 756 757 s->channels = avctx->channels; 758 s->samplerate = avctx->sample_rate; 759 760 if (!avctx->extradata) 761 { 762 av_log(avctx, AV_LOG_ERROR, "No mandatory headers present\n"); 763 return -1; 764 } 765 766 init_get_bits(&gb, avctx->extradata, avctx->extradata_size); 767 768 version = get_bits(&gb, 2); 769 if (version > 1) 770 { 771 av_log(avctx, AV_LOG_ERROR, "Unsupported Sonic version, please report\n"); 772 return -1; 773 } 774 775 if (version == 1) 776 { 777 s->channels = get_bits(&gb, 2); 778 s->samplerate = samplerate_table[get_bits(&gb, 4)]; 779 av_log(avctx, AV_LOG_INFO, "Sonicv2 chans: %d samprate: %d\n", 780 s->channels, s->samplerate); 781 } 782 783 if (s->channels > MAX_CHANNELS) 784 { 785 av_log(avctx, AV_LOG_ERROR, "Only mono and stereo streams are supported by now\n"); 786 return -1; 787 } 788 789 s->lossless = get_bits1(&gb); 790 if (!s->lossless) 791 skip_bits(&gb, 3); // XXX FIXME 792 s->decorrelation = get_bits(&gb, 2); 793 794 s->downsampling = get_bits(&gb, 2); 795 s->num_taps = (get_bits(&gb, 5)+1)<<5; 796 if (get_bits1(&gb)) // XXX FIXME 797 av_log(avctx, AV_LOG_INFO, "Custom quant table\n"); 798 799 s->block_align = (int)(2048.0*(s->samplerate/44100))/s->downsampling; 800 s->frame_size = s->channels*s->block_align*s->downsampling; 801// avctx->frame_size = s->block_align; 802 803 av_log(avctx, AV_LOG_INFO, "Sonic: ver: %d ls: %d dr: %d taps: %d block: %d frame: %d downsamp: %d\n", 804 version, s->lossless, s->decorrelation, s->num_taps, s->block_align, s->frame_size, s->downsampling); 805 806 // generate taps 807 s->tap_quant = av_mallocz(4* s->num_taps); 808 for (i = 0; i < s->num_taps; i++) 809 s->tap_quant[i] = (int)(sqrt(i+1)); 810 811 s->predictor_k = av_mallocz(4* s->num_taps); 812 813 for (i = 0; i < s->channels; i++) 814 { 815 s->predictor_state[i] = av_mallocz(4* s->num_taps); 816 if (!s->predictor_state[i]) 817 return -1; 818 } 819 820 for (i = 0; i < s->channels; i++) 821 { 822 s->coded_samples[i] = av_mallocz(4* s->block_align); 823 if (!s->coded_samples[i]) 824 return -1; 825 } 826 s->int_samples = av_mallocz(4* s->frame_size); 827 828 avctx->sample_fmt = SAMPLE_FMT_S16; 829 return 0; 830} 831 832static av_cold int sonic_decode_close(AVCodecContext *avctx) 833{ 834 SonicContext *s = avctx->priv_data; 835 int i; 836 837 av_free(s->int_samples); 838 av_free(s->tap_quant); 839 av_free(s->predictor_k); 840 841 for (i = 0; i < s->channels; i++) 842 { 843 av_free(s->predictor_state[i]); 844 av_free(s->coded_samples[i]); 845 } 846 847 return 0; 848} 849 850static int sonic_decode_frame(AVCodecContext *avctx, 851 void *data, int *data_size, 852 AVPacket *avpkt) 853{ 854 const uint8_t *buf = avpkt->data; 855 int buf_size = avpkt->size; 856 SonicContext *s = avctx->priv_data; 857 GetBitContext gb; 858 int i, quant, ch, j; 859 short *samples = data; 860 861 if (buf_size == 0) return 0; 862 863// av_log(NULL, AV_LOG_INFO, "buf_size: %d\n", buf_size); 864 865 init_get_bits(&gb, buf, buf_size*8); 866 867 intlist_read(&gb, s->predictor_k, s->num_taps, 0); 868 869 // dequantize 870 for (i = 0; i < s->num_taps; i++) 871 s->predictor_k[i] *= s->tap_quant[i]; 872 873 if (s->lossless) 874 quant = 1; 875 else 876 quant = get_ue_golomb(&gb) * SAMPLE_FACTOR; 877 878// av_log(NULL, AV_LOG_INFO, "quant: %d\n", quant); 879 880 for (ch = 0; ch < s->channels; ch++) 881 { 882 int x = ch; 883 884 predictor_init_state(s->predictor_k, s->predictor_state[ch], s->num_taps); 885 886 intlist_read(&gb, s->coded_samples[ch], s->block_align, 1); 887 888 for (i = 0; i < s->block_align; i++) 889 { 890 for (j = 0; j < s->downsampling - 1; j++) 891 { 892 s->int_samples[x] = predictor_calc_error(s->predictor_k, s->predictor_state[ch], s->num_taps, 0); 893 x += s->channels; 894 } 895 896 s->int_samples[x] = predictor_calc_error(s->predictor_k, s->predictor_state[ch], s->num_taps, s->coded_samples[ch][i] * quant); 897 x += s->channels; 898 } 899 900 for (i = 0; i < s->num_taps; i++) 901 s->predictor_state[ch][i] = s->int_samples[s->frame_size - s->channels + ch - i*s->channels]; 902 } 903 904 switch(s->decorrelation) 905 { 906 case MID_SIDE: 907 for (i = 0; i < s->frame_size; i += s->channels) 908 { 909 s->int_samples[i+1] += shift(s->int_samples[i], 1); 910 s->int_samples[i] -= s->int_samples[i+1]; 911 } 912 break; 913 case LEFT_SIDE: 914 for (i = 0; i < s->frame_size; i += s->channels) 915 s->int_samples[i+1] += s->int_samples[i]; 916 break; 917 case RIGHT_SIDE: 918 for (i = 0; i < s->frame_size; i += s->channels) 919 s->int_samples[i] += s->int_samples[i+1]; 920 break; 921 } 922 923 if (!s->lossless) 924 for (i = 0; i < s->frame_size; i++) 925 s->int_samples[i] = shift(s->int_samples[i], SAMPLE_SHIFT); 926 927 // internal -> short 928 for (i = 0; i < s->frame_size; i++) 929 samples[i] = av_clip_int16(s->int_samples[i]); 930 931 align_get_bits(&gb); 932 933 *data_size = s->frame_size * 2; 934 935 return (get_bits_count(&gb)+7)/8; 936} 937 938AVCodec sonic_decoder = { 939 "sonic", 940 AVMEDIA_TYPE_AUDIO, 941 CODEC_ID_SONIC, 942 sizeof(SonicContext), 943 sonic_decode_init, 944 NULL, 945 sonic_decode_close, 946 sonic_decode_frame, 947 .long_name = NULL_IF_CONFIG_SMALL("Sonic"), 948}; 949#endif /* CONFIG_SONIC_DECODER */ 950 951#if CONFIG_SONIC_ENCODER 952AVCodec sonic_encoder = { 953 "sonic", 954 AVMEDIA_TYPE_AUDIO, 955 CODEC_ID_SONIC, 956 sizeof(SonicContext), 957 sonic_encode_init, 958 sonic_encode_frame, 959 sonic_encode_close, 960 NULL, 961 .long_name = NULL_IF_CONFIG_SMALL("Sonic"), 962}; 963#endif 964 965#if CONFIG_SONIC_LS_ENCODER 966AVCodec sonic_ls_encoder = { 967 "sonicls", 968 AVMEDIA_TYPE_AUDIO, 969 CODEC_ID_SONIC_LS, 970 sizeof(SonicContext), 971 sonic_encode_init, 972 sonic_encode_frame, 973 sonic_encode_close, 974 NULL, 975 .long_name = NULL_IF_CONFIG_SMALL("Sonic lossless"), 976}; 977#endif 978