| @@ -0,0 +1,205 @@ |
| | 1 | /* |
| | 2 | * libdcadec decoder wrapper |
| | 3 | * Copyright (C) 2015 Hendrik Leppkes |
| | 4 | * |
| | 5 | * This file is part of Libav. |
| | 6 | * |
| | 7 | * Libav 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. |
| | 11 | * |
| | 12 | * Libav 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. |
| | 16 | * |
| | 17 | * You should have received a copy of the GNU Lesser General Public |
| | 18 | * License along with Libav; if not, write to the Free Software |
| | 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| | 20 | */ |
| | 21 | |
| | 22 | #include <libdcadec/dca_context.h> |
| | 23 | |
| | 24 | #include "libavutil/channel_layout.h" |
| | 25 | #include "libavutil/common.h" |
| | 26 | #include "libavutil/opt.h" |
| | 27 | |
| | 28 | #include "avcodec.h" |
| | 29 | #include "dca.h" |
| | 30 | #include "dca_syncwords.h" |
| | 31 | #include "internal.h" |
| | 32 | |
| | 33 | typedef struct DCADecContext { |
| | 34 | struct dcadec_context *ctx; |
| | 35 | uint8_t *buffer; |
| | 36 | int buffer_size; |
| | 37 | } DCADecContext; |
| | 38 | |
| | 39 | static int dcadec_decode_frame(AVCodecContext *avctx, void *data, |
| | 40 | int *got_frame_ptr, AVPacket *avpkt) |
| | 41 | { |
| | 42 | DCADecContext *s = avctx->priv_data; |
| | 43 | AVFrame *frame = data; |
| | 44 | int ret, i, k; |
| | 45 | int **samples, nsamples, channel_mask, sample_rate, bits_per_sample, profile; |
| | 46 | uint32_t mrk; |
| | 47 | uint8_t *input = avpkt->data; |
| | 48 | int input_size = avpkt->size; |
| | 49 | |
| | 50 | /* convert bytestream syntax to RAW BE format if required */ |
| | 51 | if (input_size < 8) { |
| | 52 | av_log(avctx, AV_LOG_ERROR, "Input size too small\n"); |
| | 53 | return AVERROR_INVALIDDATA; |
| | 54 | } |
| | 55 | mrk = AV_RB32(input); |
| | 56 | if (mrk != DCA_SYNCWORD_CORE_BE && mrk != DCA_SYNCWORD_SUBSTREAM) { |
| | 57 | s->buffer = av_fast_realloc(s->buffer, &s->buffer_size, avpkt->size + FF_INPUT_BUFFER_PADDING_SIZE); |
| | 58 | if (!s->buffer) |
| | 59 | return AVERROR(ENOMEM); |
| | 60 | |
| | 61 | if ((ret = ff_dca_convert_bitstream(avpkt->data, avpkt->size, s->buffer, s->buffer_size)) < 0) |
| | 62 | return ret; |
| | 63 | |
| | 64 | input = s->buffer; |
| | 65 | input_size = ret; |
| | 66 | } |
| | 67 | |
| | 68 | if ((ret = dcadec_context_parse(s->ctx, input, input_size)) < 0) { |
| | 69 | av_log(avctx, AV_LOG_ERROR, "dcadec_context_parse() failed: %d (%s)\n", -ret, dcadec_strerror(ret)); |
| | 70 | return AVERROR_UNKNOWN; |
| | 71 | } |
| | 72 | if ((ret = dcadec_context_filter(s->ctx, &samples, &nsamples, &channel_mask, |
| | 73 | &sample_rate, &bits_per_sample, &profile)) < 0) { |
| | 74 | av_log(avctx, AV_LOG_ERROR, "dcadec_context_filter() failed: %d (%s)\n", -ret, dcadec_strerror(ret)); |
| | 75 | return AVERROR_UNKNOWN; |
| | 76 | } |
| | 77 | |
| | 78 | avctx->channels = av_get_channel_layout_nb_channels(channel_mask); |
| | 79 | avctx->channel_layout = channel_mask; |
| | 80 | avctx->sample_rate = sample_rate; |
| | 81 | |
| | 82 | if (bits_per_sample == 16) |
| | 83 | avctx->sample_fmt = AV_SAMPLE_FMT_S16P; |
| | 84 | else if (bits_per_sample <= 24) |
| | 85 | avctx->sample_fmt = AV_SAMPLE_FMT_S32P; |
| | 86 | else { |
| | 87 | av_log(avctx, AV_LOG_ERROR, "Unsupported number of bits per sample: %d\n", |
| | 88 | bits_per_sample); |
| | 89 | return AVERROR(ENOSYS); |
| | 90 | } |
| | 91 | |
| | 92 | avctx->bits_per_raw_sample = bits_per_sample; |
| | 93 | |
| | 94 | switch (profile) { |
| | 95 | case DCADEC_PROFILE_DS: |
| | 96 | avctx->profile = FF_PROFILE_DTS; |
| | 97 | break; |
| | 98 | case DCADEC_PROFILE_DS_96_24: |
| | 99 | avctx->profile = FF_PROFILE_DTS_96_24; |
| | 100 | break; |
| | 101 | case DCADEC_PROFILE_DS_ES: |
| | 102 | avctx->profile = FF_PROFILE_DTS_ES; |
| | 103 | break; |
| | 104 | case DCADEC_PROFILE_HD_HRA: |
| | 105 | avctx->profile = FF_PROFILE_DTS_HD_HRA; |
| | 106 | break; |
| | 107 | case DCADEC_PROFILE_HD_MA: |
| | 108 | avctx->profile = FF_PROFILE_DTS_HD_MA; |
| | 109 | break; |
| | 110 | case DCADEC_PROFILE_EXPRESS: |
| | 111 | avctx->profile = FF_PROFILE_DTS_EXPRESS; |
| | 112 | break; |
| | 113 | case DCADEC_PROFILE_UNKNOWN: |
| | 114 | default: |
| | 115 | avctx->profile = FF_PROFILE_UNKNOWN; |
| | 116 | break; |
| | 117 | } |
| | 118 | |
| | 119 | /* bitrate is only meaningful if there are no HD extensions, as they distort the bitrate */ |
| | 120 | if (profile == DCADEC_PROFILE_DS || profile == DCADEC_PROFILE_DS_96_24 || profile == DCADEC_PROFILE_DS_ES) { |
| | 121 | struct dcadec_core_info *info = dcadec_context_get_core_info(s->ctx); |
| | 122 | avctx->bit_rate = info->bit_rate; |
| | 123 | dcadec_context_free_core_info(info); |
| | 124 | } else |
| | 125 | avctx->bit_rate = 0; |
| | 126 | |
| | 127 | frame->nb_samples = nsamples; |
| | 128 | if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) |
| | 129 | return ret; |
| | 130 | |
| | 131 | for (i = 0; i < avctx->channels; i++) { |
| | 132 | if (frame->format == AV_SAMPLE_FMT_S16P) { |
| | 133 | int16_t *plane = (int16_t *)frame->extended_data[i]; |
| | 134 | for (k = 0; k < nsamples; k++) |
| | 135 | plane[k] = samples[i][k]; |
| | 136 | } else { |
| | 137 | int32_t *plane = (int32_t *)frame->extended_data[i]; |
| | 138 | int shift = 32 - bits_per_sample; |
| | 139 | for (k = 0; k < nsamples; k++) |
| | 140 | plane[k] = samples[i][k] << shift; |
| | 141 | } |
| | 142 | } |
| | 143 | |
| | 144 | *got_frame_ptr = 1; |
| | 145 | |
| | 146 | return avpkt->size; |
| | 147 | } |
| | 148 | |
| | 149 | static av_cold void dcadec_flush(AVCodecContext *avctx) |
| | 150 | { |
| | 151 | DCADecContext *s = avctx->priv_data; |
| | 152 | dcadec_context_clear(s->ctx); |
| | 153 | } |
| | 154 | |
| | 155 | static av_cold int dcadec_close(AVCodecContext *avctx) |
| | 156 | { |
| | 157 | DCADecContext *s = avctx->priv_data; |
| | 158 | |
| | 159 | dcadec_context_destroy(s->ctx); |
| | 160 | s->ctx = NULL; |
| | 161 | |
| | 162 | av_freep(&s->buffer); |
| | 163 | |
| | 164 | return 0; |
| | 165 | } |
| | 166 | |
| | 167 | static av_cold int dcadec_init(AVCodecContext *avctx) |
| | 168 | { |
| | 169 | DCADecContext *s = avctx->priv_data; |
| | 170 | |
| | 171 | s->ctx = dcadec_context_create(0); |
| | 172 | if (!s->ctx) |
| | 173 | return AVERROR(ENOMEM); |
| | 174 | |
| | 175 | avctx->sample_fmt = AV_SAMPLE_FMT_S32P; |
| | 176 | avctx->bits_per_raw_sample = 24; |
| | 177 | |
| | 178 | return 0; |
| | 179 | } |
| | 180 | |
| | 181 | static const AVProfile profiles[] = { |
| | 182 | { FF_PROFILE_DTS, "DTS" }, |
| | 183 | { FF_PROFILE_DTS_ES, "DTS-ES" }, |
| | 184 | { FF_PROFILE_DTS_96_24, "DTS 96/24" }, |
| | 185 | { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" }, |
| | 186 | { FF_PROFILE_DTS_HD_MA, "DTS-HD MA" }, |
| | 187 | { FF_PROFILE_DTS_EXPRESS, "DTS Express" }, |
| | 188 | { FF_PROFILE_UNKNOWN }, |
| | 189 | }; |
| | 190 | |
| | 191 | AVCodec ff_libdcadec_decoder = { |
| | 192 | .name = "libdcadec", |
| | 193 | .long_name = NULL_IF_CONFIG_SMALL("dcadec DCA decoder"), |
| | 194 | .type = AVMEDIA_TYPE_AUDIO, |
| | 195 | .id = AV_CODEC_ID_DTS, |
| | 196 | .priv_data_size = sizeof(DCADecContext), |
| | 197 | .init = dcadec_init, |
| | 198 | .decode = dcadec_decode_frame, |
| | 199 | .close = dcadec_close, |
| | 200 | .flush = dcadec_flush, |
| | 201 | .capabilities = CODEC_CAP_DR1 | CODEC_CAP_CHANNEL_CONF, |
| | 202 | .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S32P, AV_SAMPLE_FMT_S16P, |
| | 203 | AV_SAMPLE_FMT_NONE }, |
| | 204 | .profiles = NULL_IF_CONFIG_SMALL(profiles), |
| | 205 | }; |