2 * Simple free lossless/lossy audio codec
3 * Copyright (c) 2004 Alex Beregszaszi
5 * This file is part of FFmpeg.
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.
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.
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
28 * Simple free lossless/lossy audio codec
29 * Based on Paul Francis Harrison's Bonk (http://www.logarithmic.net/pfh/bonk)
30 * Written and designed by Alex Beregszaszi
33 * - CABAC put/get_symbol
34 * - independent quantizer for channels
35 * - >2 channels support
36 * - more decorrelation types
37 * - more tap_quant tests
38 * - selectable intlist writers/readers (bonk-style, golomb, cabac)
41 #define MAX_CHANNELS 2
47 typedef struct SonicContext {
49 int lossless, decorrelation;
51 int num_taps, downsampling;
54 int channels, samplerate, block_align, frame_size;
58 int *coded_samples[MAX_CHANNELS];
68 int *predictor_state[MAX_CHANNELS];
71 #define LATTICE_SHIFT 10
72 #define SAMPLE_SHIFT 4
73 #define LATTICE_FACTOR (1 << LATTICE_SHIFT)
74 #define SAMPLE_FACTOR (1 << SAMPLE_SHIFT)
76 #define BASE_QUANT 0.6
77 #define RATE_VARIATION 3.0
79 static inline int divide(int a, int b)
82 return -( (-a + b/2)/b );
87 static inline int shift(int a,int b)
89 return (a+(1<<(b-1))) >> b;
92 static inline int shift_down(int a,int b)
94 return (a>>b)+((a<0)?1:0);
98 static inline int intlist_write(PutBitContext *pb, int *buf, int entries, int base_2_part)
102 for (i = 0; i < entries; i++)
103 set_se_golomb(pb, buf[i]);
108 static inline int intlist_read(GetBitContext *gb, int *buf, int entries, int base_2_part)
112 for (i = 0; i < entries; i++)
113 buf[i] = get_se_golomb(gb);
120 #define ADAPT_LEVEL 8
122 static int bits_to_store(uint64_t x)
134 static void write_uint_max(PutBitContext *pb, unsigned int value, unsigned int max)
141 bits = bits_to_store(max);
143 for (i = 0; i < bits-1; i++)
144 put_bits(pb, 1, value & (1 << i));
146 if ( (value | (1 << (bits-1))) <= max)
147 put_bits(pb, 1, value & (1 << (bits-1)));
150 static unsigned int read_uint_max(GetBitContext *gb, int max)
152 int i, bits, value = 0;
157 bits = bits_to_store(max);
159 for (i = 0; i < bits-1; i++)
163 if ( (value | (1<<(bits-1))) <= max)
165 value += 1 << (bits-1);
170 static int intlist_write(PutBitContext *pb, int *buf, int entries, int base_2_part)
172 int i, j, x = 0, low_bits = 0, max = 0;
173 int step = 256, pos = 0, dominant = 0, any = 0;
176 copy = av_mallocz(4* entries);
184 for (i = 0; i < entries; i++)
185 energy += abs(buf[i]);
187 low_bits = bits_to_store(energy / (entries * 2));
191 put_bits(pb, 4, low_bits);
194 for (i = 0; i < entries; i++)
196 put_bits(pb, low_bits, abs(buf[i]));
197 copy[i] = abs(buf[i]) >> low_bits;
202 bits = av_mallocz(4* entries*max);
209 for (i = 0; i <= max; i++)
211 for (j = 0; j < entries; j++)
213 bits[x++] = copy[j] > i;
219 int steplet = step >> 8;
221 if (pos + steplet > x)
224 for (i = 0; i < steplet; i++)
225 if (bits[i+pos] != dominant)
228 put_bits(pb, 1, any);
233 step += step / ADAPT_LEVEL;
239 while (((pos + interloper) < x) && (bits[pos + interloper] == dominant))
243 write_uint_max(pb, interloper, (step >> 8) - 1);
245 pos += interloper + 1;
246 step -= step / ADAPT_LEVEL;
252 dominant = !dominant;
257 for (i = 0; i < entries; i++)
259 put_bits(pb, 1, buf[i] < 0);
267 static int intlist_read(GetBitContext *gb, int *buf, int entries, int base_2_part)
269 int i, low_bits = 0, x = 0;
270 int n_zeros = 0, step = 256, dominant = 0;
271 int pos = 0, level = 0;
272 int *bits = av_mallocz(4* entries);
279 low_bits = get_bits(gb, 4);
282 for (i = 0; i < entries; i++)
283 buf[i] = get_bits(gb, low_bits);
286 // av_log(NULL, AV_LOG_INFO, "entries: %d, low bits: %d\n", entries, low_bits);
288 while (n_zeros < entries)
290 int steplet = step >> 8;
294 for (i = 0; i < steplet; i++)
295 bits[x++] = dominant;
300 step += step / ADAPT_LEVEL;
304 int actual_run = read_uint_max(gb, steplet-1);
306 // av_log(NULL, AV_LOG_INFO, "actual run: %d\n", actual_run);
308 for (i = 0; i < actual_run; i++)
309 bits[x++] = dominant;
311 bits[x++] = !dominant;
314 n_zeros += actual_run;
318 step -= step / ADAPT_LEVEL;
324 dominant = !dominant;
328 // reconstruct unsigned values
330 for (i = 0; n_zeros < entries; i++)
337 level += 1 << low_bits;
340 if (buf[pos] >= level)
347 buf[pos] += 1 << low_bits;
356 for (i = 0; i < entries; i++)
357 if (buf[i] && get_bits1(gb))
360 // av_log(NULL, AV_LOG_INFO, "zeros: %d pos: %d\n", n_zeros, pos);
366 static void predictor_init_state(int *k, int *state, int order)
370 for (i = order-2; i >= 0; i--)
372 int j, p, x = state[i];
374 for (j = 0, p = i+1; p < order; j++,p++)
376 int tmp = x + shift_down(k[j] * state[p], LATTICE_SHIFT);
377 state[p] += shift_down(k[j]*x, LATTICE_SHIFT);
383 static int predictor_calc_error(int *k, int *state, int order, int error)
385 int i, x = error - shift_down(k[order-1] * state[order-1], LATTICE_SHIFT);
388 int *k_ptr = &(k[order-2]),
389 *state_ptr = &(state[order-2]);
390 for (i = order-2; i >= 0; i--, k_ptr--, state_ptr--)
392 int k_value = *k_ptr, state_value = *state_ptr;
393 x -= shift_down(k_value * state_value, LATTICE_SHIFT);
394 state_ptr[1] = state_value + shift_down(k_value * x, LATTICE_SHIFT);
397 for (i = order-2; i >= 0; i--)
399 x -= shift_down(k[i] * state[i], LATTICE_SHIFT);
400 state[i+1] = state[i] + shift_down(k[i] * x, LATTICE_SHIFT);
404 // don't drift too far, to avoid overflows
405 if (x > (SAMPLE_FACTOR<<16)) x = (SAMPLE_FACTOR<<16);
406 if (x < -(SAMPLE_FACTOR<<16)) x = -(SAMPLE_FACTOR<<16);
413 #if CONFIG_SONIC_ENCODER || CONFIG_SONIC_LS_ENCODER
414 // Heavily modified Levinson-Durbin algorithm which
415 // copes better with quantization, and calculates the
416 // actual whitened result as it goes.
418 static void modified_levinson_durbin(int *window, int window_entries,
419 int *out, int out_entries, int channels, int *tap_quant)
422 int *state = av_mallocz(4* window_entries);
424 memcpy(state, window, 4* window_entries);
426 for (i = 0; i < out_entries; i++)
428 int step = (i+1)*channels, k, j;
429 double xx = 0.0, xy = 0.0;
431 int *x_ptr = &(window[step]), *state_ptr = &(state[0]);
432 j = window_entries - step;
433 for (;j>=0;j--,x_ptr++,state_ptr++)
435 double x_value = *x_ptr, state_value = *state_ptr;
436 xx += state_value*state_value;
437 xy += x_value*state_value;
440 for (j = 0; j <= (window_entries - step); j++);
442 double stepval = window[step+j], stateval = window[j];
443 // xx += (double)window[j]*(double)window[j];
444 // xy += (double)window[step+j]*(double)window[j];
445 xx += stateval*stateval;
446 xy += stepval*stateval;
452 k = (int)(floor(-xy/xx * (double)LATTICE_FACTOR / (double)(tap_quant[i]) + 0.5));
454 if (k > (LATTICE_FACTOR/tap_quant[i]))
455 k = LATTICE_FACTOR/tap_quant[i];
456 if (-k > (LATTICE_FACTOR/tap_quant[i]))
457 k = -(LATTICE_FACTOR/tap_quant[i]);
463 x_ptr = &(window[step]);
464 state_ptr = &(state[0]);
465 j = window_entries - step;
466 for (;j>=0;j--,x_ptr++,state_ptr++)
468 int x_value = *x_ptr, state_value = *state_ptr;
469 *x_ptr = x_value + shift_down(k*state_value,LATTICE_SHIFT);
470 *state_ptr = state_value + shift_down(k*x_value, LATTICE_SHIFT);
473 for (j=0; j <= (window_entries - step); j++)
475 int stepval = window[step+j], stateval=state[j];
476 window[step+j] += shift_down(k * stateval, LATTICE_SHIFT);
477 state[j] += shift_down(k * stepval, LATTICE_SHIFT);
485 static inline int code_samplerate(int samplerate)
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;
502 static av_cold int sonic_encode_init(AVCodecContext *avctx)
504 SonicContext *s = avctx->priv_data;
508 if (avctx->channels > MAX_CHANNELS)
510 av_log(avctx, AV_LOG_ERROR, "Only mono and stereo streams are supported by now\n");
511 return -1; /* only stereo or mono for now */
514 if (avctx->channels == 2)
515 s->decorrelation = MID_SIDE;
517 if (avctx->codec->id == AV_CODEC_ID_SONIC_LS)
522 s->quantization = 0.0;
528 s->quantization = 1.0;
532 if ((s->num_taps < 32) || (s->num_taps > 1024) ||
533 ((s->num_taps>>5)<<5 != s->num_taps))
535 av_log(avctx, AV_LOG_ERROR, "Invalid number of taps\n");
540 s->tap_quant = av_mallocz(4* s->num_taps);
541 for (i = 0; i < s->num_taps; i++)
542 s->tap_quant[i] = (int)(sqrt(i+1));
544 s->channels = avctx->channels;
545 s->samplerate = avctx->sample_rate;
547 s->block_align = (int)(2048.0*s->samplerate/44100)/s->downsampling;
548 s->frame_size = s->channels*s->block_align*s->downsampling;
550 s->tail_size = s->num_taps*s->channels;
551 s->tail = av_mallocz(4 * s->tail_size);
555 s->predictor_k = av_mallocz(4 * s->num_taps);
559 for (i = 0; i < s->channels; i++)
561 s->coded_samples[i] = av_mallocz(4* s->block_align);
562 if (!s->coded_samples[i])
566 s->int_samples = av_mallocz(4* s->frame_size);
568 s->window_size = ((2*s->tail_size)+s->frame_size);
569 s->window = av_mallocz(4* s->window_size);
573 avctx->extradata = av_mallocz(16);
574 if (!avctx->extradata)
576 init_put_bits(&pb, avctx->extradata, 16*8);
578 put_bits(&pb, 2, version); // version
581 put_bits(&pb, 2, s->channels);
582 put_bits(&pb, 4, code_samplerate(s->samplerate));
584 put_bits(&pb, 1, s->lossless);
586 put_bits(&pb, 3, SAMPLE_SHIFT); // XXX FIXME: sample precision
587 put_bits(&pb, 2, s->decorrelation);
588 put_bits(&pb, 2, s->downsampling);
589 put_bits(&pb, 5, (s->num_taps >> 5)-1); // 32..1024
590 put_bits(&pb, 1, 0); // XXX FIXME: no custom tap quant table
593 avctx->extradata_size = put_bits_count(&pb)/8;
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);
598 avctx->coded_frame = avcodec_alloc_frame();
599 if (!avctx->coded_frame)
600 return AVERROR(ENOMEM);
601 avctx->coded_frame->key_frame = 1;
602 avctx->frame_size = s->block_align*s->downsampling;
607 static av_cold int sonic_encode_close(AVCodecContext *avctx)
609 SonicContext *s = avctx->priv_data;
612 av_freep(&avctx->coded_frame);
614 for (i = 0; i < s->channels; i++)
615 av_free(s->coded_samples[i]);
617 av_free(s->predictor_k);
619 av_free(s->tap_quant);
621 av_free(s->int_samples);
626 static int sonic_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
627 const AVFrame *frame, int *got_packet_ptr)
629 SonicContext *s = avctx->priv_data;
631 int i, j, ch, quant = 0, x = 0;
633 const short *samples = (const int16_t*)frame->data[0];
635 if ((ret = ff_alloc_packet2(avctx, avpkt, s->frame_size * 5 + 1000)))
638 init_put_bits(&pb, avpkt->data, avpkt->size);
641 for (i = 0; i < s->frame_size; i++)
642 s->int_samples[i] = samples[i];
645 for (i = 0; i < s->frame_size; i++)
646 s->int_samples[i] = s->int_samples[i] << SAMPLE_SHIFT;
648 switch(s->decorrelation)
651 for (i = 0; i < s->frame_size; i += s->channels)
653 s->int_samples[i] += s->int_samples[i+1];
654 s->int_samples[i+1] -= shift(s->int_samples[i], 1);
658 for (i = 0; i < s->frame_size; i += s->channels)
659 s->int_samples[i+1] -= s->int_samples[i];
662 for (i = 0; i < s->frame_size; i += s->channels)
663 s->int_samples[i] -= s->int_samples[i+1];
667 memset(s->window, 0, 4* s->window_size);
669 for (i = 0; i < s->tail_size; i++)
670 s->window[x++] = s->tail[i];
672 for (i = 0; i < s->frame_size; i++)
673 s->window[x++] = s->int_samples[i];
675 for (i = 0; i < s->tail_size; i++)
678 for (i = 0; i < s->tail_size; i++)
679 s->tail[i] = s->int_samples[s->frame_size - s->tail_size + i];
682 modified_levinson_durbin(s->window, s->window_size,
683 s->predictor_k, s->num_taps, s->channels, s->tap_quant);
684 if (intlist_write(&pb, s->predictor_k, s->num_taps, 0) < 0)
687 for (ch = 0; ch < s->channels; ch++)
690 for (i = 0; i < s->block_align; i++)
693 for (j = 0; j < s->downsampling; j++, x += s->channels)
695 s->coded_samples[ch][i] = sum;
699 // simple rate control code
702 double energy1 = 0.0, energy2 = 0.0;
703 for (ch = 0; ch < s->channels; ch++)
705 for (i = 0; i < s->block_align; i++)
707 double sample = s->coded_samples[ch][i];
708 energy2 += sample*sample;
709 energy1 += fabs(sample);
713 energy2 = sqrt(energy2/(s->channels*s->block_align));
714 energy1 = sqrt(2.0)*energy1/(s->channels*s->block_align);
716 // increase bitrate when samples are like a gaussian distribution
717 // reduce bitrate when samples are like a two-tailed exponential distribution
719 if (energy2 > energy1)
720 energy2 += (energy2-energy1)*RATE_VARIATION;
722 quant = (int)(BASE_QUANT*s->quantization*energy2/SAMPLE_FACTOR);
723 // av_log(avctx, AV_LOG_DEBUG, "quant: %d energy: %f / %f\n", quant, energy1, energy2);
730 set_ue_golomb(&pb, quant);
732 quant *= SAMPLE_FACTOR;
735 // write out coded samples
736 for (ch = 0; ch < s->channels; ch++)
739 for (i = 0; i < s->block_align; i++)
740 s->coded_samples[ch][i] = divide(s->coded_samples[ch][i], quant);
742 if (intlist_write(&pb, s->coded_samples[ch], s->block_align, 1) < 0)
746 // av_log(avctx, AV_LOG_DEBUG, "used bytes: %d\n", (put_bits_count(&pb)+7)/8);
749 avpkt->size = (put_bits_count(&pb)+7)/8;
753 #endif /* CONFIG_SONIC_ENCODER || CONFIG_SONIC_LS_ENCODER */
755 #if CONFIG_SONIC_DECODER
756 static const int samplerate_table[] =
757 { 44100, 22050, 11025, 96000, 48000, 32000, 24000, 16000, 8000 };
759 static av_cold int sonic_decode_init(AVCodecContext *avctx)
761 SonicContext *s = avctx->priv_data;
765 s->channels = avctx->channels;
766 s->samplerate = avctx->sample_rate;
768 avcodec_get_frame_defaults(&s->frame);
769 avctx->coded_frame = &s->frame;
771 if (!avctx->extradata)
773 av_log(avctx, AV_LOG_ERROR, "No mandatory headers present\n");
777 init_get_bits(&gb, avctx->extradata, avctx->extradata_size);
779 version = get_bits(&gb, 2);
782 av_log(avctx, AV_LOG_ERROR, "Unsupported Sonic version, please report\n");
788 s->channels = get_bits(&gb, 2);
789 s->samplerate = samplerate_table[get_bits(&gb, 4)];
790 av_log(avctx, AV_LOG_INFO, "Sonicv2 chans: %d samprate: %d\n",
791 s->channels, s->samplerate);
794 if (s->channels > MAX_CHANNELS)
796 av_log(avctx, AV_LOG_ERROR, "Only mono and stereo streams are supported by now\n");
800 s->lossless = get_bits1(&gb);
802 skip_bits(&gb, 3); // XXX FIXME
803 s->decorrelation = get_bits(&gb, 2);
805 s->downsampling = get_bits(&gb, 2);
806 if (!s->downsampling) {
807 av_log(avctx, AV_LOG_ERROR, "invalid downsampling value\n");
808 return AVERROR_INVALIDDATA;
811 s->num_taps = (get_bits(&gb, 5)+1)<<5;
812 if (get_bits1(&gb)) // XXX FIXME
813 av_log(avctx, AV_LOG_INFO, "Custom quant table\n");
815 s->block_align = (int)(2048.0*s->samplerate/44100)/s->downsampling;
816 s->frame_size = s->channels*s->block_align*s->downsampling;
817 // avctx->frame_size = s->block_align;
819 av_log(avctx, AV_LOG_INFO, "Sonic: ver: %d ls: %d dr: %d taps: %d block: %d frame: %d downsamp: %d\n",
820 version, s->lossless, s->decorrelation, s->num_taps, s->block_align, s->frame_size, s->downsampling);
823 s->tap_quant = av_mallocz(4* s->num_taps);
824 for (i = 0; i < s->num_taps; i++)
825 s->tap_quant[i] = (int)(sqrt(i+1));
827 s->predictor_k = av_mallocz(4* s->num_taps);
829 for (i = 0; i < s->channels; i++)
831 s->predictor_state[i] = av_mallocz(4* s->num_taps);
832 if (!s->predictor_state[i])
836 for (i = 0; i < s->channels; i++)
838 s->coded_samples[i] = av_mallocz(4* s->block_align);
839 if (!s->coded_samples[i])
842 s->int_samples = av_mallocz(4* s->frame_size);
844 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
848 static av_cold int sonic_decode_close(AVCodecContext *avctx)
850 SonicContext *s = avctx->priv_data;
853 av_free(s->int_samples);
854 av_free(s->tap_quant);
855 av_free(s->predictor_k);
857 for (i = 0; i < s->channels; i++)
859 av_free(s->predictor_state[i]);
860 av_free(s->coded_samples[i]);
866 static int sonic_decode_frame(AVCodecContext *avctx,
867 void *data, int *got_frame_ptr,
870 const uint8_t *buf = avpkt->data;
871 int buf_size = avpkt->size;
872 SonicContext *s = avctx->priv_data;
874 int i, quant, ch, j, ret;
877 if (buf_size == 0) return 0;
879 s->frame.nb_samples = s->frame_size;
880 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
881 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
884 samples = (int16_t *)s->frame.data[0];
886 // av_log(NULL, AV_LOG_INFO, "buf_size: %d\n", buf_size);
888 init_get_bits(&gb, buf, buf_size*8);
890 intlist_read(&gb, s->predictor_k, s->num_taps, 0);
893 for (i = 0; i < s->num_taps; i++)
894 s->predictor_k[i] *= s->tap_quant[i];
899 quant = get_ue_golomb(&gb) * SAMPLE_FACTOR;
901 // av_log(NULL, AV_LOG_INFO, "quant: %d\n", quant);
903 for (ch = 0; ch < s->channels; ch++)
907 predictor_init_state(s->predictor_k, s->predictor_state[ch], s->num_taps);
909 intlist_read(&gb, s->coded_samples[ch], s->block_align, 1);
911 for (i = 0; i < s->block_align; i++)
913 for (j = 0; j < s->downsampling - 1; j++)
915 s->int_samples[x] = predictor_calc_error(s->predictor_k, s->predictor_state[ch], s->num_taps, 0);
919 s->int_samples[x] = predictor_calc_error(s->predictor_k, s->predictor_state[ch], s->num_taps, s->coded_samples[ch][i] * quant);
923 for (i = 0; i < s->num_taps; i++)
924 s->predictor_state[ch][i] = s->int_samples[s->frame_size - s->channels + ch - i*s->channels];
927 switch(s->decorrelation)
930 for (i = 0; i < s->frame_size; i += s->channels)
932 s->int_samples[i+1] += shift(s->int_samples[i], 1);
933 s->int_samples[i] -= s->int_samples[i+1];
937 for (i = 0; i < s->frame_size; i += s->channels)
938 s->int_samples[i+1] += s->int_samples[i];
941 for (i = 0; i < s->frame_size; i += s->channels)
942 s->int_samples[i] += s->int_samples[i+1];
947 for (i = 0; i < s->frame_size; i++)
948 s->int_samples[i] = shift(s->int_samples[i], SAMPLE_SHIFT);
951 for (i = 0; i < s->frame_size; i++)
952 samples[i] = av_clip_int16(s->int_samples[i]);
957 *(AVFrame*)data = s->frame;
959 return (get_bits_count(&gb)+7)/8;
962 AVCodec ff_sonic_decoder = {
964 .type = AVMEDIA_TYPE_AUDIO,
965 .id = AV_CODEC_ID_SONIC,
966 .priv_data_size = sizeof(SonicContext),
967 .init = sonic_decode_init,
968 .close = sonic_decode_close,
969 .decode = sonic_decode_frame,
970 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_EXPERIMENTAL,
971 .long_name = NULL_IF_CONFIG_SMALL("Sonic"),
973 #endif /* CONFIG_SONIC_DECODER */
975 #if CONFIG_SONIC_ENCODER
976 AVCodec ff_sonic_encoder = {
978 .type = AVMEDIA_TYPE_AUDIO,
979 .id = AV_CODEC_ID_SONIC,
980 .priv_data_size = sizeof(SonicContext),
981 .init = sonic_encode_init,
982 .encode2 = sonic_encode_frame,
983 .capabilities = CODEC_CAP_EXPERIMENTAL,
984 .close = sonic_encode_close,
985 .long_name = NULL_IF_CONFIG_SMALL("Sonic"),
989 #if CONFIG_SONIC_LS_ENCODER
990 AVCodec ff_sonic_ls_encoder = {
992 .type = AVMEDIA_TYPE_AUDIO,
993 .id = AV_CODEC_ID_SONIC_LS,
994 .priv_data_size = sizeof(SonicContext),
995 .init = sonic_encode_init,
996 .encode2 = sonic_encode_frame,
997 .capabilities = CODEC_CAP_EXPERIMENTAL,
998 .close = sonic_encode_close,
999 .long_name = NULL_IF_CONFIG_SMALL("Sonic lossless"),