1 /*
2 * TTA (The Lossless True Audio) encoder
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #define BITSTREAM_WRITER_LE
22 #include "ttadata.h"
23 #include "ttaencdsp.h"
24 #include "avcodec.h"
25 #include "codec_internal.h"
26 #include "encode.h"
27 #include "put_bits.h"
28 #include "internal.h"
29 #include "libavutil/crc.h"
30
31 typedef struct TTAEncContext {
32 const AVCRC *crc_table;
33 int bps;
34 TTAChannel *ch_ctx;
35 TTAEncDSPContext dsp;
36 } TTAEncContext;
37
tta_encode_init(AVCodecContext * avctx)38 static av_cold int tta_encode_init(AVCodecContext *avctx)
39 {
40 TTAEncContext *s = avctx->priv_data;
41
42 s->crc_table = av_crc_get_table(AV_CRC_32_IEEE_LE);
43
44 switch (avctx->sample_fmt) {
45 case AV_SAMPLE_FMT_U8:
46 avctx->bits_per_raw_sample = 8;
47 break;
48 case AV_SAMPLE_FMT_S16:
49 avctx->bits_per_raw_sample = 16;
50 break;
51 case AV_SAMPLE_FMT_S32:
52 if (avctx->bits_per_raw_sample > 24)
53 av_log(avctx, AV_LOG_WARNING, "encoding as 24 bits-per-sample\n");
54 avctx->bits_per_raw_sample = 24;
55 }
56
57 s->bps = avctx->bits_per_raw_sample >> 3;
58 avctx->frame_size = 256 * avctx->sample_rate / 245;
59
60 s->ch_ctx = av_malloc_array(avctx->ch_layout.nb_channels, sizeof(*s->ch_ctx));
61 if (!s->ch_ctx)
62 return AVERROR(ENOMEM);
63
64 ff_ttaencdsp_init(&s->dsp);
65
66 return 0;
67 }
68
get_sample(const AVFrame * frame,int sample,enum AVSampleFormat format)69 static int32_t get_sample(const AVFrame *frame, int sample,
70 enum AVSampleFormat format)
71 {
72 int32_t ret;
73
74 if (format == AV_SAMPLE_FMT_U8) {
75 ret = frame->data[0][sample] - 0x80;
76 } else if (format == AV_SAMPLE_FMT_S16) {
77 const int16_t *ptr = (const int16_t *)frame->data[0];
78 ret = ptr[sample];
79 } else {
80 const int32_t *ptr = (const int32_t *)frame->data[0];
81 ret = ptr[sample] >> 8;
82 }
83
84 return ret;
85 }
86
tta_encode_frame(AVCodecContext * avctx,AVPacket * avpkt,const AVFrame * frame,int * got_packet_ptr)87 static int tta_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
88 const AVFrame *frame, int *got_packet_ptr)
89 {
90 TTAEncContext *s = avctx->priv_data;
91 PutBitContext pb;
92 int ret, i, out_bytes, cur_chan, res, samples;
93 int64_t pkt_size = frame->nb_samples * 2LL * avctx->ch_layout.nb_channels * s->bps;
94
95 pkt_alloc:
96 cur_chan = 0, res = 0, samples = 0;
97 if ((ret = ff_alloc_packet(avctx, avpkt, pkt_size)) < 0)
98 return ret;
99 init_put_bits(&pb, avpkt->data, avpkt->size);
100
101 // init per channel states
102 for (i = 0; i < avctx->ch_layout.nb_channels; i++) {
103 s->ch_ctx[i].predictor = 0;
104 ff_tta_filter_init(&s->ch_ctx[i].filter, ff_tta_filter_configs[s->bps - 1]);
105 ff_tta_rice_init(&s->ch_ctx[i].rice, 10, 10);
106 }
107
108 for (i = 0; i < frame->nb_samples * avctx->ch_layout.nb_channels; i++) {
109 TTAChannel *c = &s->ch_ctx[cur_chan];
110 TTAFilter *filter = &c->filter;
111 TTARice *rice = &c->rice;
112 uint32_t k, unary, outval;
113 int32_t value, temp;
114
115 value = get_sample(frame, samples++, avctx->sample_fmt);
116
117 if (avctx->ch_layout.nb_channels > 1) {
118 if (cur_chan < avctx->ch_layout.nb_channels - 1)
119 value = res = get_sample(frame, samples, avctx->sample_fmt) - value;
120 else
121 value -= res / 2;
122 }
123
124 temp = value;
125 #define PRED(x, k) (int32_t)((((uint64_t)(x) << (k)) - (x)) >> (k))
126 switch (s->bps) {
127 case 1: value -= PRED(c->predictor, 4); break;
128 case 2:
129 case 3: value -= PRED(c->predictor, 5); break;
130 }
131 c->predictor = temp;
132
133 s->dsp.filter_process(filter->qm, filter->dx, filter->dl, &filter->error, &value,
134 filter->shift, filter->round);
135 outval = (value > 0) ? (value << 1) - 1: -value << 1;
136
137 k = rice->k0;
138
139 rice->sum0 += outval - (rice->sum0 >> 4);
140 if (rice->k0 > 0 && rice->sum0 < ff_tta_shift_16[rice->k0])
141 rice->k0--;
142 else if (rice->sum0 > ff_tta_shift_16[rice->k0 + 1])
143 rice->k0++;
144
145 if (outval >= ff_tta_shift_1[k]) {
146 outval -= ff_tta_shift_1[k];
147 k = rice->k1;
148
149 rice->sum1 += outval - (rice->sum1 >> 4);
150 if (rice->k1 > 0 && rice->sum1 < ff_tta_shift_16[rice->k1])
151 rice->k1--;
152 else if (rice->sum1 > ff_tta_shift_16[rice->k1 + 1])
153 rice->k1++;
154
155 unary = 1 + (outval >> k);
156 if (unary + 100LL > put_bits_left(&pb)) {
157 if (pkt_size < INT_MAX/2) {
158 pkt_size *= 2;
159 av_packet_unref(avpkt);
160 goto pkt_alloc;
161 } else
162 return AVERROR(ENOMEM);
163 }
164 do {
165 if (unary > 31) {
166 put_bits(&pb, 31, 0x7FFFFFFF);
167 unary -= 31;
168 } else {
169 put_bits(&pb, unary, (1U << unary) - 1);
170 unary = 0;
171 }
172 } while (unary);
173 }
174
175 put_bits(&pb, 1, 0);
176
177 if (k)
178 put_bits(&pb, k, outval & (ff_tta_shift_1[k] - 1));
179
180 if (cur_chan < avctx->ch_layout.nb_channels - 1)
181 cur_chan++;
182 else
183 cur_chan = 0;
184 }
185
186 flush_put_bits(&pb);
187 out_bytes = put_bytes_output(&pb);
188 put_bits32(&pb, av_crc(s->crc_table, UINT32_MAX, avpkt->data, out_bytes) ^ UINT32_MAX);
189 flush_put_bits(&pb);
190
191 avpkt->pts = frame->pts;
192 avpkt->size = out_bytes + 4;
193 avpkt->duration = ff_samples_to_time_base(avctx, frame->nb_samples);
194 *got_packet_ptr = 1;
195 return 0;
196 }
197
tta_encode_close(AVCodecContext * avctx)198 static av_cold int tta_encode_close(AVCodecContext *avctx)
199 {
200 TTAEncContext *s = avctx->priv_data;
201 av_freep(&s->ch_ctx);
202 return 0;
203 }
204
205 const FFCodec ff_tta_encoder = {
206 .p.name = "tta",
207 .p.long_name = NULL_IF_CONFIG_SMALL("TTA (True Audio)"),
208 .p.type = AVMEDIA_TYPE_AUDIO,
209 .p.id = AV_CODEC_ID_TTA,
210 .priv_data_size = sizeof(TTAEncContext),
211 .init = tta_encode_init,
212 .close = tta_encode_close,
213 FF_CODEC_ENCODE_CB(tta_encode_frame),
214 .p.capabilities = AV_CODEC_CAP_SMALL_LAST_FRAME,
215 .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_U8,
216 AV_SAMPLE_FMT_S16,
217 AV_SAMPLE_FMT_S32,
218 AV_SAMPLE_FMT_NONE },
219 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
220 };
221