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 34int 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 85void 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 116void 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 150static 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 301static 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 312static 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 326static av_cold void dcadec_init_static(void) 327{ 328 ff_dca_lbr_init_tables(); 329 ff_dca_init_vlcs(); 330} 331 332static 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 357FF_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 } 365FF_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 388static 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 405static 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 413const 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