1 /*
2 * Copyright (C) 2016 foo86
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 #include "libavutil/opt.h"
22 #include "libavutil/channel_layout.h"
23 #include "libavutil/thread.h"
24
25 #include "codec_internal.h"
26 #include "dcadec.h"
27 #include "dcahuff.h"
28 #include "dca_syncwords.h"
29 #include "profiles.h"
30
31 #define MIN_PACKET_SIZE 16
32 #define MAX_PACKET_SIZE 0x104000
33
ff_dca_set_channel_layout(AVCodecContext *avctx, int *ch_remap, int dca_mask)34 int ff_dca_set_channel_layout(AVCodecContext *avctx, int *ch_remap, int dca_mask)
35 {
36 static const uint8_t dca2wav_norm[28] = {
37 2, 0, 1, 9, 10, 3, 8, 4, 5, 9, 10, 6, 7, 12,
38 13, 14, 3, 6, 7, 11, 12, 14, 16, 15, 17, 8, 4, 5,
39 };
40
41 static const uint8_t dca2wav_wide[28] = {
42 2, 0, 1, 4, 5, 3, 8, 4, 5, 9, 10, 6, 7, 12,
43 13, 14, 3, 9, 10, 11, 12, 14, 16, 15, 17, 8, 4, 5,
44 };
45
46 DCAContext *s = avctx->priv_data;
47
48 int dca_ch, wav_ch, nchannels = 0;
49
50 av_channel_layout_uninit(&avctx->ch_layout);
51 if (s->output_channel_order == CHANNEL_ORDER_CODED) {
52 for (dca_ch = 0; dca_ch < DCA_SPEAKER_COUNT; dca_ch++)
53 if (dca_mask & (1U << dca_ch))
54 ch_remap[nchannels++] = dca_ch;
55 avctx->ch_layout.order = AV_CHANNEL_ORDER_UNSPEC;
56 avctx->ch_layout.nb_channels = nchannels;
57 } else {
58 int wav_mask = 0;
59 int wav_map[18];
60 const uint8_t *dca2wav;
61 if (dca_mask == DCA_SPEAKER_LAYOUT_7POINT0_WIDE ||
62 dca_mask == DCA_SPEAKER_LAYOUT_7POINT1_WIDE)
63 dca2wav = dca2wav_wide;
64 else
65 dca2wav = dca2wav_norm;
66 for (dca_ch = 0; dca_ch < 28; dca_ch++) {
67 if (dca_mask & (1 << dca_ch)) {
68 wav_ch = dca2wav[dca_ch];
69 if (!(wav_mask & (1 << wav_ch))) {
70 wav_map[wav_ch] = dca_ch;
71 wav_mask |= 1 << wav_ch;
72 }
73 }
74 }
75 for (wav_ch = 0; wav_ch < 18; wav_ch++)
76 if (wav_mask & (1 << wav_ch))
77 ch_remap[nchannels++] = wav_map[wav_ch];
78
79 av_channel_layout_from_mask(&avctx->ch_layout, wav_mask);
80 }
81
82 return nchannels;
83 }
84
ff_dca_downmix_to_stereo_fixed(DCADSPContext *dcadsp, int32_t **samples, int *coeff_l, int nsamples, int ch_mask)85 void ff_dca_downmix_to_stereo_fixed(DCADSPContext *dcadsp, int32_t **samples,
86 int *coeff_l, int nsamples, int ch_mask)
87 {
88 int pos, spkr, max_spkr = av_log2(ch_mask);
89 int *coeff_r = coeff_l + av_popcount(ch_mask);
90
91 av_assert0(DCA_HAS_STEREO(ch_mask));
92
93 // Scale left and right channels
94 pos = (ch_mask & DCA_SPEAKER_MASK_C);
95 dcadsp->dmix_scale(samples[DCA_SPEAKER_L], coeff_l[pos ], nsamples);
96 dcadsp->dmix_scale(samples[DCA_SPEAKER_R], coeff_r[pos + 1], nsamples);
97
98 // Downmix remaining channels
99 for (spkr = 0; spkr <= max_spkr; spkr++) {
100 if (!(ch_mask & (1U << spkr)))
101 continue;
102
103 if (*coeff_l && spkr != DCA_SPEAKER_L)
104 dcadsp->dmix_add(samples[DCA_SPEAKER_L], samples[spkr],
105 *coeff_l, nsamples);
106
107 if (*coeff_r && spkr != DCA_SPEAKER_R)
108 dcadsp->dmix_add(samples[DCA_SPEAKER_R], samples[spkr],
109 *coeff_r, nsamples);
110
111 coeff_l++;
112 coeff_r++;
113 }
114 }
115
ff_dca_downmix_to_stereo_float(AVFloatDSPContext *fdsp, float **samples, int *coeff_l, int nsamples, int ch_mask)116 void ff_dca_downmix_to_stereo_float(AVFloatDSPContext *fdsp, float **samples,
117 int *coeff_l, int nsamples, int ch_mask)
118 {
119 int pos, spkr, max_spkr = av_log2(ch_mask);
120 int *coeff_r = coeff_l + av_popcount(ch_mask);
121 const float scale = 1.0f / (1 << 15);
122
123 av_assert0(DCA_HAS_STEREO(ch_mask));
124
125 // Scale left and right channels
126 pos = (ch_mask & DCA_SPEAKER_MASK_C);
127 fdsp->vector_fmul_scalar(samples[DCA_SPEAKER_L], samples[DCA_SPEAKER_L],
128 coeff_l[pos ] * scale, nsamples);
129 fdsp->vector_fmul_scalar(samples[DCA_SPEAKER_R], samples[DCA_SPEAKER_R],
130 coeff_r[pos + 1] * scale, nsamples);
131
132 // Downmix remaining channels
133 for (spkr = 0; spkr <= max_spkr; spkr++) {
134 if (!(ch_mask & (1U << spkr)))
135 continue;
136
137 if (*coeff_l && spkr != DCA_SPEAKER_L)
138 fdsp->vector_fmac_scalar(samples[DCA_SPEAKER_L], samples[spkr],
139 *coeff_l * scale, nsamples);
140
141 if (*coeff_r && spkr != DCA_SPEAKER_R)
142 fdsp->vector_fmac_scalar(samples[DCA_SPEAKER_R], samples[spkr],
143 *coeff_r * scale, nsamples);
144
145 coeff_l++;
146 coeff_r++;
147 }
148 }
149
dcadec_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)150 static int dcadec_decode_frame(AVCodecContext *avctx, AVFrame *frame,
151 int *got_frame_ptr, AVPacket *avpkt)
152 {
153 DCAContext *s = avctx->priv_data;
154 const uint8_t *input = avpkt->data;
155 int input_size = avpkt->size;
156 int i, ret, prev_packet = s->packet;
157 uint32_t mrk;
158
159 if (input_size < MIN_PACKET_SIZE || input_size > MAX_PACKET_SIZE) {
160 av_log(avctx, AV_LOG_ERROR, "Invalid packet size\n");
161 return AVERROR_INVALIDDATA;
162 }
163
164 // Convert input to BE format
165 mrk = AV_RB32(input);
166 if (mrk != DCA_SYNCWORD_CORE_BE && mrk != DCA_SYNCWORD_SUBSTREAM) {
167 av_fast_padded_malloc(&s->buffer, &s->buffer_size, input_size);
168 if (!s->buffer)
169 return AVERROR(ENOMEM);
170
171 for (i = 0, ret = AVERROR_INVALIDDATA; i < input_size - MIN_PACKET_SIZE + 1 && ret < 0; i++)
172 ret = avpriv_dca_convert_bitstream(input + i, input_size - i, s->buffer, s->buffer_size);
173
174 if (ret < 0) {
175 av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
176 return ret;
177 }
178
179 input = s->buffer;
180 input_size = ret;
181 }
182
183 s->packet = 0;
184
185 // Parse backward compatible core sub-stream
186 if (AV_RB32(input) == DCA_SYNCWORD_CORE_BE) {
187 int frame_size;
188
189 if ((ret = ff_dca_core_parse(&s->core, input, input_size)) < 0)
190 return ret;
191
192 s->packet |= DCA_PACKET_CORE;
193
194 // EXXS data must be aligned on 4-byte boundary
195 frame_size = FFALIGN(s->core.frame_size, 4);
196 if (input_size - 4 > frame_size) {
197 input += frame_size;
198 input_size -= frame_size;
199 }
200 }
201
202 if (!s->core_only) {
203 DCAExssAsset *asset = NULL;
204
205 // Parse extension sub-stream (EXSS)
206 if (AV_RB32(input) == DCA_SYNCWORD_SUBSTREAM) {
207 if ((ret = ff_dca_exss_parse(&s->exss, input, input_size)) < 0) {
208 if (avctx->err_recognition & AV_EF_EXPLODE)
209 return ret;
210 } else {
211 s->packet |= DCA_PACKET_EXSS;
212 asset = &s->exss.assets[0];
213 }
214 }
215
216 // Parse XLL component in EXSS
217 if (asset && (asset->extension_mask & DCA_EXSS_XLL)) {
218 if ((ret = ff_dca_xll_parse(&s->xll, input, asset)) < 0) {
219 // Conceal XLL synchronization error
220 if (ret == AVERROR(EAGAIN)
221 && (prev_packet & DCA_PACKET_XLL)
222 && (s->packet & DCA_PACKET_CORE))
223 s->packet |= DCA_PACKET_XLL | DCA_PACKET_RECOVERY;
224 else if (ret == AVERROR(ENOMEM) || (avctx->err_recognition & AV_EF_EXPLODE))
225 return ret;
226 } else {
227 s->packet |= DCA_PACKET_XLL;
228 }
229 }
230
231 // Parse LBR component in EXSS
232 if (asset && (asset->extension_mask & DCA_EXSS_LBR)) {
233 if ((ret = ff_dca_lbr_parse(&s->lbr, input, asset)) < 0) {
234 if (ret == AVERROR(ENOMEM) || (avctx->err_recognition & AV_EF_EXPLODE))
235 return ret;
236 } else {
237 s->packet |= DCA_PACKET_LBR;
238 }
239 }
240
241 // Parse core extensions in EXSS or backward compatible core sub-stream
242 if ((s->packet & DCA_PACKET_CORE)
243 && (ret = ff_dca_core_parse_exss(&s->core, input, asset)) < 0)
244 return ret;
245 }
246
247 // Filter the frame
248 if (s->packet & DCA_PACKET_LBR) {
249 if ((ret = ff_dca_lbr_filter_frame(&s->lbr, frame)) < 0)
250 return ret;
251 } else if (s->packet & DCA_PACKET_XLL) {
252 if (s->packet & DCA_PACKET_CORE) {
253 int x96_synth = -1;
254
255 // Enable X96 synthesis if needed
256 if (s->xll.chset[0].freq == 96000 && s->core.sample_rate == 48000)
257 x96_synth = 1;
258
259 if ((ret = ff_dca_core_filter_fixed(&s->core, x96_synth)) < 0)
260 return ret;
261
262 // Force lossy downmixed output on the first core frame filtered.
263 // This prevents audible clicks when seeking and is consistent with
264 // what reference decoder does when there are multiple channel sets.
265 if (!(prev_packet & DCA_PACKET_RESIDUAL) && s->xll.nreschsets > 0
266 && s->xll.nchsets > 1) {
267 av_log(avctx, AV_LOG_VERBOSE, "Forcing XLL recovery mode\n");
268 s->packet |= DCA_PACKET_RECOVERY;
269 }
270
271 // Set 'residual ok' flag for the next frame
272 s->packet |= DCA_PACKET_RESIDUAL;
273 }
274
275 if ((ret = ff_dca_xll_filter_frame(&s->xll, frame)) < 0) {
276 // Fall back to core unless hard error
277 if (!(s->packet & DCA_PACKET_CORE))
278 return ret;
279 if (ret != AVERROR_INVALIDDATA || (avctx->err_recognition & AV_EF_EXPLODE))
280 return ret;
281 if ((ret = ff_dca_core_filter_frame(&s->core, frame)) < 0)
282 return ret;
283 }
284 } else if (s->packet & DCA_PACKET_CORE) {
285 if ((ret = ff_dca_core_filter_frame(&s->core, frame)) < 0)
286 return ret;
287 if (s->core.filter_mode & DCA_FILTER_MODE_FIXED)
288 s->packet |= DCA_PACKET_RESIDUAL;
289 } else {
290 av_log(avctx, AV_LOG_ERROR, "No valid DCA sub-stream found\n");
291 if (s->core_only)
292 av_log(avctx, AV_LOG_WARNING, "Consider disabling 'core_only' option\n");
293 return AVERROR_INVALIDDATA;
294 }
295
296 *got_frame_ptr = 1;
297
298 return avpkt->size;
299 }
300
dcadec_flush(AVCodecContext *avctx)301 static av_cold void dcadec_flush(AVCodecContext *avctx)
302 {
303 DCAContext *s = avctx->priv_data;
304
305 ff_dca_core_flush(&s->core);
306 ff_dca_xll_flush(&s->xll);
307 ff_dca_lbr_flush(&s->lbr);
308
309 s->packet &= DCA_PACKET_MASK;
310 }
311
dcadec_close(AVCodecContext *avctx)312 static av_cold int dcadec_close(AVCodecContext *avctx)
313 {
314 DCAContext *s = avctx->priv_data;
315
316 ff_dca_core_close(&s->core);
317 ff_dca_xll_close(&s->xll);
318 ff_dca_lbr_close(&s->lbr);
319
320 av_freep(&s->buffer);
321 s->buffer_size = 0;
322
323 return 0;
324 }
325
dcadec_init_static(void)326 static av_cold void dcadec_init_static(void)
327 {
328 ff_dca_lbr_init_tables();
329 ff_dca_init_vlcs();
330 }
331
dcadec_init(AVCodecContext *avctx)332 static av_cold int dcadec_init(AVCodecContext *avctx)
333 {
334 static AVOnce init_static_once = AV_ONCE_INIT;
335 DCAContext *s = avctx->priv_data;
336
337 s->avctx = avctx;
338 s->core.avctx = avctx;
339 s->exss.avctx = avctx;
340 s->xll.avctx = avctx;
341 s->lbr.avctx = avctx;
342
343 if (ff_dca_core_init(&s->core) < 0)
344 return AVERROR(ENOMEM);
345
346 if (ff_dca_lbr_init(&s->lbr) < 0)
347 return AVERROR(ENOMEM);
348
349 ff_dcadsp_init(&s->dcadsp);
350 s->core.dcadsp = &s->dcadsp;
351 s->xll.dcadsp = &s->dcadsp;
352 s->lbr.dcadsp = &s->dcadsp;
353
354 s->crctab = av_crc_get_table(AV_CRC_16_CCITT);
355
356 #if FF_API_OLD_CHANNEL_LAYOUT
357 FF_DISABLE_DEPRECATION_WARNINGS
358 if (avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE)
359 s->output_channel_order = CHANNEL_ORDER_CODED;
360
361 if (avctx->request_channel_layout & ~AV_CH_LAYOUT_NATIVE) {
362 av_channel_layout_uninit(&s->downmix_layout);
363 av_channel_layout_from_mask(&s->downmix_layout, avctx->request_channel_layout & ~AV_CH_LAYOUT_NATIVE);
364 }
365 FF_ENABLE_DEPRECATION_WARNINGS
366 #endif
367
368 if (s->downmix_layout.nb_channels) {
369 if (!av_channel_layout_compare(&s->downmix_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO) ||
370 !av_channel_layout_compare(&s->downmix_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO_DOWNMIX))
371 s->request_channel_layout = DCA_SPEAKER_LAYOUT_STEREO;
372 else if (!av_channel_layout_compare(&s->downmix_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT0))
373 s->request_channel_layout = DCA_SPEAKER_LAYOUT_5POINT0;
374 else if (!av_channel_layout_compare(&s->downmix_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT1))
375 s->request_channel_layout = DCA_SPEAKER_LAYOUT_5POINT1;
376 else
377 av_log(avctx, AV_LOG_WARNING, "Invalid downmix layout\n");
378 }
379
380 ff_thread_once(&init_static_once, dcadec_init_static);
381
382 return 0;
383 }
384
385 #define OFFSET(x) offsetof(DCAContext, x)
386 #define PARAM AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM
387
388 static const AVOption dcadec_options[] = {
389 { "core_only", "Decode core only without extensions", OFFSET(core_only), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, PARAM },
390
391 { "channel_order", "Order in which the channels are to be exported",
392 OFFSET(output_channel_order), AV_OPT_TYPE_INT,
393 { .i64 = CHANNEL_ORDER_DEFAULT }, 0, 1, PARAM, "channel_order" },
394 { "default", "normal libavcodec channel order", 0, AV_OPT_TYPE_CONST,
395 { .i64 = CHANNEL_ORDER_DEFAULT }, .flags = PARAM, "channel_order" },
396 { "coded", "order in which the channels are coded in the bitstream",
397 0, AV_OPT_TYPE_CONST, { .i64 = CHANNEL_ORDER_CODED }, .flags = PARAM, "channel_order" },
398
399 { "downmix", "Request a specific channel layout from the decoder", OFFSET(downmix_layout),
400 AV_OPT_TYPE_CHLAYOUT, {.str = NULL}, .flags = PARAM },
401
402 { NULL }
403 };
404
405 static const AVClass dcadec_class = {
406 .class_name = "DCA decoder",
407 .item_name = av_default_item_name,
408 .option = dcadec_options,
409 .version = LIBAVUTIL_VERSION_INT,
410 .category = AV_CLASS_CATEGORY_DECODER,
411 };
412
413 const FFCodec ff_dca_decoder = {
414 .p.name = "dca",
415 .p.long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
416 .p.type = AVMEDIA_TYPE_AUDIO,
417 .p.id = AV_CODEC_ID_DTS,
418 .priv_data_size = sizeof(DCAContext),
419 .init = dcadec_init,
420 FF_CODEC_DECODE_CB(dcadec_decode_frame),
421 .close = dcadec_close,
422 .flush = dcadec_flush,
423 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
424 .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P,
425 AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE },
426 .p.priv_class = &dcadec_class,
427 .p.profiles = NULL_IF_CONFIG_SMALL(ff_dca_profiles),
428 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
429 };
430