| /* |
| * libdcadec decoder wrapper |
| * Copyright (C) 2015 Hendrik Leppkes |
| * |
| * This file is part of FFmpeg. |
| * |
| * FFmpeg is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * FFmpeg is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with FFmpeg; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| */ |
| |
| #include <libdcadec/dca_context.h> |
| |
| #include "libavutil/channel_layout.h" |
| #include "libavutil/common.h" |
| #include "libavutil/opt.h" |
| |
| #include "avcodec.h" |
| #include "dca.h" |
| #include "dca_syncwords.h" |
| #include "internal.h" |
| |
| typedef struct DCADecContext { |
| struct dcadec_context *ctx; |
| uint8_t *buffer; |
| int buffer_size; |
| int downmix_warned; |
| } DCADecContext; |
| |
| static int dcadec_decode_frame(AVCodecContext *avctx, void *data, |
| int *got_frame_ptr, AVPacket *avpkt) |
| { |
| DCADecContext *s = avctx->priv_data; |
| AVFrame *frame = data; |
| av_unused struct dcadec_exss_info *exss; |
| int ret, i, k; |
| int **samples, nsamples, channel_mask, sample_rate, bits_per_sample, profile; |
| uint32_t mrk; |
| uint8_t *input = avpkt->data; |
| int input_size = avpkt->size; |
| |
| /* convert bytestream syntax to RAW BE format if required */ |
| if (input_size < 8) { |
| av_log(avctx, AV_LOG_ERROR, "Input size too small\n"); |
| return AVERROR_INVALIDDATA; |
| } |
| mrk = AV_RB32(input); |
| if (mrk != DCA_SYNCWORD_CORE_BE && mrk != DCA_SYNCWORD_SUBSTREAM) { |
| s->buffer = av_fast_realloc(s->buffer, &s->buffer_size, avpkt->size + AV_INPUT_BUFFER_PADDING_SIZE); |
| if (!s->buffer) |
| return AVERROR(ENOMEM); |
| |
| for (i = 0, ret = AVERROR_INVALIDDATA; i < input_size - 3 && ret < 0; i++) |
| ret = avpriv_dca_convert_bitstream(input + i, input_size - i, s->buffer, s->buffer_size); |
| |
| if (ret < 0) |
| return ret; |
| |
| input = s->buffer; |
| input_size = ret; |
| } |
| |
| if ((ret = dcadec_context_parse(s->ctx, input, input_size)) < 0) { |
| av_log(avctx, AV_LOG_ERROR, "dcadec_context_parse() failed: %d (%s)\n", -ret, dcadec_strerror(ret)); |
| return AVERROR_EXTERNAL; |
| } |
| if ((ret = dcadec_context_filter(s->ctx, &samples, &nsamples, &channel_mask, |
| &sample_rate, &bits_per_sample, &profile)) < 0) { |
| av_log(avctx, AV_LOG_ERROR, "dcadec_context_filter() failed: %d (%s)\n", -ret, dcadec_strerror(ret)); |
| return AVERROR_EXTERNAL; |
| } |
| |
| avctx->channels = av_get_channel_layout_nb_channels(channel_mask); |
| avctx->channel_layout = channel_mask; |
| avctx->sample_rate = sample_rate; |
| |
| if (bits_per_sample == 16) |
| avctx->sample_fmt = AV_SAMPLE_FMT_S16P; |
| else if (bits_per_sample > 16 && bits_per_sample <= 24) |
| avctx->sample_fmt = AV_SAMPLE_FMT_S32P; |
| else { |
| av_log(avctx, AV_LOG_ERROR, "Unsupported number of bits per sample: %d\n", |
| bits_per_sample); |
| return AVERROR(ENOSYS); |
| } |
| |
| avctx->bits_per_raw_sample = bits_per_sample; |
| |
| switch (profile) { |
| case DCADEC_PROFILE_DS: |
| avctx->profile = FF_PROFILE_DTS; |
| break; |
| case DCADEC_PROFILE_DS_96_24: |
| avctx->profile = FF_PROFILE_DTS_96_24; |
| break; |
| case DCADEC_PROFILE_DS_ES: |
| avctx->profile = FF_PROFILE_DTS_ES; |
| break; |
| case DCADEC_PROFILE_HD_HRA: |
| avctx->profile = FF_PROFILE_DTS_HD_HRA; |
| break; |
| case DCADEC_PROFILE_HD_MA: |
| avctx->profile = FF_PROFILE_DTS_HD_MA; |
| break; |
| case DCADEC_PROFILE_EXPRESS: |
| avctx->profile = FF_PROFILE_DTS_EXPRESS; |
| break; |
| case DCADEC_PROFILE_UNKNOWN: |
| default: |
| avctx->profile = FF_PROFILE_UNKNOWN; |
| break; |
| } |
| |
| /* bitrate is only meaningful if there are no HD extensions, as they distort the bitrate */ |
| if (profile == DCADEC_PROFILE_DS || profile == DCADEC_PROFILE_DS_96_24 || profile == DCADEC_PROFILE_DS_ES) { |
| struct dcadec_core_info *info = dcadec_context_get_core_info(s->ctx); |
| avctx->bit_rate = info->bit_rate; |
| dcadec_context_free_core_info(info); |
| } else |
| avctx->bit_rate = 0; |
| |
| #if HAVE_STRUCT_DCADEC_EXSS_INFO_MATRIX_ENCODING |
| if (exss = dcadec_context_get_exss_info(s->ctx)) { |
| enum AVMatrixEncoding matrix_encoding = AV_MATRIX_ENCODING_NONE; |
| |
| if (!s->downmix_warned) { |
| uint64_t layout = avctx->request_channel_layout; |
| |
| if (((layout == AV_CH_LAYOUT_STEREO_DOWNMIX || layout == AV_CH_LAYOUT_STEREO) && !exss->embedded_stereo) || |
| ( layout == AV_CH_LAYOUT_5POINT1 && !exss->embedded_6ch)) |
| av_log(avctx, AV_LOG_WARNING, "%s downmix was requested but no custom coefficients are available, " |
| "this may result in clipping\n", |
| layout == AV_CH_LAYOUT_5POINT1 ? "5.1" : "Stereo"); |
| s->downmix_warned = 1; |
| } |
| |
| switch(exss->matrix_encoding) { |
| case DCADEC_MATRIX_ENCODING_SURROUND: |
| matrix_encoding = AV_MATRIX_ENCODING_DOLBY; |
| break; |
| case DCADEC_MATRIX_ENCODING_HEADPHONE: |
| matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE; |
| break; |
| } |
| dcadec_context_free_exss_info(exss); |
| |
| if (matrix_encoding != AV_MATRIX_ENCODING_NONE && |
| (ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0) |
| return ret; |
| } |
| #endif |
| |
| frame->nb_samples = nsamples; |
| if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) |
| return ret; |
| |
| for (i = 0; i < avctx->channels; i++) { |
| if (frame->format == AV_SAMPLE_FMT_S16P) { |
| int16_t *plane = (int16_t *)frame->extended_data[i]; |
| for (k = 0; k < nsamples; k++) |
| plane[k] = samples[i][k]; |
| } else { |
| int32_t *plane = (int32_t *)frame->extended_data[i]; |
| int shift = 32 - bits_per_sample; |
| for (k = 0; k < nsamples; k++) |
| plane[k] = samples[i][k] << shift; |
| } |
| } |
| |
| *got_frame_ptr = 1; |
| |
| return avpkt->size; |
| } |
| |
| static av_cold void dcadec_flush(AVCodecContext *avctx) |
| { |
| DCADecContext *s = avctx->priv_data; |
| dcadec_context_clear(s->ctx); |
| } |
| |
| static av_cold int dcadec_close(AVCodecContext *avctx) |
| { |
| DCADecContext *s = avctx->priv_data; |
| |
| dcadec_context_destroy(s->ctx); |
| s->ctx = NULL; |
| |
| av_freep(&s->buffer); |
| |
| return 0; |
| } |
| |
| static av_cold int dcadec_init(AVCodecContext *avctx) |
| { |
| DCADecContext *s = avctx->priv_data; |
| int flags = 0; |
| |
| /* Affects only lossy DTS profiles. DTS-HD MA is always bitexact */ |
| if (avctx->flags & AV_CODEC_FLAG_BITEXACT) |
| flags |= DCADEC_FLAG_CORE_BIT_EXACT; |
| |
| if (avctx->request_channel_layout > 0 && avctx->request_channel_layout != AV_CH_LAYOUT_NATIVE) { |
| switch (avctx->request_channel_layout) { |
| case AV_CH_LAYOUT_STEREO: |
| case AV_CH_LAYOUT_STEREO_DOWNMIX: |
| /* libdcadec ignores the 2ch flag if used alone when no custom downmix coefficients |
| are available, silently outputting a 5.1 downmix if possible instead. |
| Using both the 2ch and 6ch flags together forces a 2ch downmix using default |
| coefficients in such cases. This matches the behavior of the 6ch flag when used |
| alone, where a 5.1 downmix is generated if possible, regardless of custom |
| coefficients being available or not. */ |
| flags |= DCADEC_FLAG_KEEP_DMIX_2CH | DCADEC_FLAG_KEEP_DMIX_6CH; |
| break; |
| case AV_CH_LAYOUT_5POINT1: |
| flags |= DCADEC_FLAG_KEEP_DMIX_6CH; |
| break; |
| default: |
| av_log(avctx, AV_LOG_WARNING, "Invalid request_channel_layout\n"); |
| break; |
| } |
| } |
| |
| s->ctx = dcadec_context_create(flags); |
| if (!s->ctx) |
| return AVERROR(ENOMEM); |
| |
| avctx->sample_fmt = AV_SAMPLE_FMT_S32P; |
| avctx->bits_per_raw_sample = 24; |
| |
| return 0; |
| } |
| |
| static const AVProfile profiles[] = { |
| { FF_PROFILE_DTS, "DTS" }, |
| { FF_PROFILE_DTS_ES, "DTS-ES" }, |
| { FF_PROFILE_DTS_96_24, "DTS 96/24" }, |
| { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" }, |
| { FF_PROFILE_DTS_HD_MA, "DTS-HD MA" }, |
| { FF_PROFILE_DTS_EXPRESS, "DTS Express" }, |
| { FF_PROFILE_UNKNOWN }, |
| }; |
| |
| AVCodec ff_libdcadec_decoder = { |
| .name = "libdcadec", |
| .long_name = NULL_IF_CONFIG_SMALL("dcadec DCA decoder"), |
| .type = AVMEDIA_TYPE_AUDIO, |
| .id = AV_CODEC_ID_DTS, |
| .priv_data_size = sizeof(DCADecContext), |
| .init = dcadec_init, |
| .decode = dcadec_decode_frame, |
| .close = dcadec_close, |
| .flush = dcadec_flush, |
| .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF, |
| .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S32P, AV_SAMPLE_FMT_S16P, |
| AV_SAMPLE_FMT_NONE }, |
| .profiles = NULL_IF_CONFIG_SMALL(profiles), |
| }; |