git.sesse.net Git - ffmpeg/blob - libavcodec/libdcadec.c

   1 /*
   2  * libdcadec decoder wrapper
   3  * Copyright (C) 2015 Hendrik Leppkes
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg 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  * FFmpeg 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 FFmpeg; 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     int downmix_warned;
  38 } DCADecContext;
  39
  40 static int dcadec_decode_frame(AVCodecContext *avctx, void *data,
  41                                int *got_frame_ptr, AVPacket *avpkt)
  42 {
  43     DCADecContext *s = avctx->priv_data;
  44     AVFrame *frame = data;
  45     struct dcadec_exss_info *exss;
  46     int ret, i, k;
  47     int **samples, nsamples, channel_mask, sample_rate, bits_per_sample, profile;
  48     uint32_t mrk;
  49     uint8_t *input = avpkt->data;
  50     int input_size = avpkt->size;
  51
  52     /* convert bytestream syntax to RAW BE format if required */
  53     if (input_size < 8) {
  54         av_log(avctx, AV_LOG_ERROR, "Input size too small\n");
  55         return AVERROR_INVALIDDATA;
  56     }
  57     mrk = AV_RB32(input);
  58     if (mrk != DCA_SYNCWORD_CORE_BE && mrk != DCA_SYNCWORD_SUBSTREAM) {
  59         s->buffer = av_fast_realloc(s->buffer, &s->buffer_size, avpkt->size + AV_INPUT_BUFFER_PADDING_SIZE);
  60         if (!s->buffer)
  61             return AVERROR(ENOMEM);
  62
  63         for (i = 0, ret = AVERROR_INVALIDDATA; i < input_size - 3 && ret < 0; i++)
  64             ret = avpriv_dca_convert_bitstream(input + i, input_size - i, s->buffer, s->buffer_size);
  65
  66         if (ret < 0)
  67             return ret;
  68
  69         input      = s->buffer;
  70         input_size = ret;
  71     }
  72
  73     if ((ret = dcadec_context_parse(s->ctx, input, input_size)) < 0) {
  74         av_log(avctx, AV_LOG_ERROR, "dcadec_context_parse() failed: %d (%s)\n", -ret, dcadec_strerror(ret));
  75         return AVERROR_EXTERNAL;
  76     }
  77     if ((ret = dcadec_context_filter(s->ctx, &samples, &nsamples, &channel_mask,
  78                                      &sample_rate, &bits_per_sample, &profile)) < 0) {
  79         av_log(avctx, AV_LOG_ERROR, "dcadec_context_filter() failed: %d (%s)\n", -ret, dcadec_strerror(ret));
  80         return AVERROR_EXTERNAL;
  81     } else if (ret > 0) {
  82         av_log(avctx, AV_LOG_WARNING, "dcadec_context_filter() warning: %d (%s)\n", ret, dcadec_strerror(ret));
  83     }
  84
  85     avctx->channels       = av_get_channel_layout_nb_channels(channel_mask);
  86     avctx->channel_layout = channel_mask;
  87     avctx->sample_rate    = sample_rate;
  88
  89     if (bits_per_sample == 16)
  90         avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
  91     else if (bits_per_sample > 16 && bits_per_sample <= 24)
  92         avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
  93     else {
  94         av_log(avctx, AV_LOG_ERROR, "Unsupported number of bits per sample: %d\n",
  95                bits_per_sample);
  96         return AVERROR(ENOSYS);
  97     }
  98
  99     avctx->bits_per_raw_sample = bits_per_sample;
 100
 101     switch (profile) {
 102     case DCADEC_PROFILE_DS:
 103         avctx->profile = FF_PROFILE_DTS;
 104         break;
 105     case DCADEC_PROFILE_DS_96_24:
 106         avctx->profile = FF_PROFILE_DTS_96_24;
 107         break;
 108     case DCADEC_PROFILE_DS_ES:
 109         avctx->profile = FF_PROFILE_DTS_ES;
 110         break;
 111     case DCADEC_PROFILE_HD_HRA:
 112         avctx->profile = FF_PROFILE_DTS_HD_HRA;
 113         break;
 114     case DCADEC_PROFILE_HD_MA:
 115         avctx->profile = FF_PROFILE_DTS_HD_MA;
 116         break;
 117     case DCADEC_PROFILE_EXPRESS:
 118         avctx->profile = FF_PROFILE_DTS_EXPRESS;
 119         break;
 120     case DCADEC_PROFILE_UNKNOWN:
 121     default:
 122         avctx->profile = FF_PROFILE_UNKNOWN;
 123         break;
 124     }
 125
 126     /* bitrate is only meaningful if there are no HD extensions, as they distort the bitrate */
 127     if (profile == DCADEC_PROFILE_DS || profile == DCADEC_PROFILE_DS_96_24 || profile == DCADEC_PROFILE_DS_ES) {
 128         struct dcadec_core_info *info = dcadec_context_get_core_info(s->ctx);
 129         avctx->bit_rate = info->bit_rate;
 130         dcadec_context_free_core_info(info);
 131     } else
 132         avctx->bit_rate = 0;
 133
 134     if (exss = dcadec_context_get_exss_info(s->ctx)) {
 135         enum AVMatrixEncoding matrix_encoding = AV_MATRIX_ENCODING_NONE;
 136
 137         if (!s->downmix_warned) {
 138             uint64_t layout = avctx->request_channel_layout;
 139
 140             if (((layout == AV_CH_LAYOUT_STEREO_DOWNMIX || layout == AV_CH_LAYOUT_STEREO) && !exss->embedded_stereo) ||
 141                 ( layout == AV_CH_LAYOUT_5POINT1 && !exss->embedded_6ch))
 142                 av_log(avctx, AV_LOG_WARNING, "%s downmix was requested but no custom coefficients are available, "
 143                                               "this may result in clipping\n",
 144                                               layout == AV_CH_LAYOUT_5POINT1 ? "5.1" : "Stereo");
 145             s->downmix_warned = 1;
 146         }
 147
 148         switch(exss->matrix_encoding) {
 149         case DCADEC_MATRIX_ENCODING_SURROUND:
 150             matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
 151             break;
 152         case DCADEC_MATRIX_ENCODING_HEADPHONE:
 153             matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
 154             break;
 155         }
 156         dcadec_context_free_exss_info(exss);
 157
 158         if (matrix_encoding != AV_MATRIX_ENCODING_NONE &&
 159             (ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
 160             return ret;
 161     }
 162
 163     frame->nb_samples = nsamples;
 164     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
 165         return ret;
 166
 167     for (i = 0; i < avctx->channels; i++) {
 168         if (frame->format == AV_SAMPLE_FMT_S16P) {
 169             int16_t *plane = (int16_t *)frame->extended_data[i];
 170             for (k = 0; k < nsamples; k++)
 171                 plane[k] = samples[i][k];
 172         } else {
 173             int32_t *plane = (int32_t *)frame->extended_data[i];
 174             int shift = 32 - bits_per_sample;
 175             for (k = 0; k < nsamples; k++)
 176                 plane[k] = samples[i][k] << shift;
 177         }
 178     }
 179
 180     *got_frame_ptr = 1;
 181
 182     return avpkt->size;
 183 }
 184
 185 static av_cold void dcadec_flush(AVCodecContext *avctx)
 186 {
 187     DCADecContext *s = avctx->priv_data;
 188     dcadec_context_clear(s->ctx);
 189 }
 190
 191 static av_cold int dcadec_close(AVCodecContext *avctx)
 192 {
 193     DCADecContext *s = avctx->priv_data;
 194
 195     dcadec_context_destroy(s->ctx);
 196     s->ctx = NULL;
 197
 198     av_freep(&s->buffer);
 199
 200     return 0;
 201 }
 202
 203 static av_cold int dcadec_init(AVCodecContext *avctx)
 204 {
 205     DCADecContext *s = avctx->priv_data;
 206     int flags = 0;
 207
 208     /* Affects only lossy DTS profiles. DTS-HD MA is always bitexact */
 209     if (avctx->flags & AV_CODEC_FLAG_BITEXACT)
 210         flags |= DCADEC_FLAG_CORE_BIT_EXACT;
 211
 212     if (avctx->request_channel_layout > 0 && avctx->request_channel_layout != AV_CH_LAYOUT_NATIVE) {
 213         switch (avctx->request_channel_layout) {
 214         case AV_CH_LAYOUT_STEREO:
 215         case AV_CH_LAYOUT_STEREO_DOWNMIX:
 216             /* libdcadec ignores the 2ch flag if used alone when no custom downmix coefficients
 217                are available, silently outputting a 5.1 downmix if possible instead.
 218                Using both the 2ch and 6ch flags together forces a 2ch downmix using default
 219                coefficients in such cases. This matches the behavior of the 6ch flag when used
 220                alone, where a 5.1 downmix is generated if possible, regardless of custom
 221                coefficients being available or not. */
 222             flags |= DCADEC_FLAG_KEEP_DMIX_2CH | DCADEC_FLAG_KEEP_DMIX_6CH;
 223             break;
 224         case AV_CH_LAYOUT_5POINT1:
 225             flags |= DCADEC_FLAG_KEEP_DMIX_6CH;
 226             break;
 227         default:
 228             av_log(avctx, AV_LOG_WARNING, "Invalid request_channel_layout\n");
 229             break;
 230         }
 231     }
 232
 233     s->ctx = dcadec_context_create(flags);
 234     if (!s->ctx)
 235         return AVERROR(ENOMEM);
 236
 237     avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
 238     avctx->bits_per_raw_sample = 24;
 239
 240     return 0;
 241 }
 242
 243 static const AVProfile profiles[] = {
 244     { FF_PROFILE_DTS,         "DTS"         },
 245     { FF_PROFILE_DTS_ES,      "DTS-ES"      },
 246     { FF_PROFILE_DTS_96_24,   "DTS 96/24"   },
 247     { FF_PROFILE_DTS_HD_HRA,  "DTS-HD HRA"  },
 248     { FF_PROFILE_DTS_HD_MA,   "DTS-HD MA"   },
 249     { FF_PROFILE_DTS_EXPRESS, "DTS Express" },
 250     { FF_PROFILE_UNKNOWN },
 251 };
 252
 253 AVCodec ff_libdcadec_decoder = {
 254     .name           = "libdcadec",
 255     .long_name      = NULL_IF_CONFIG_SMALL("dcadec DCA decoder"),
 256     .type           = AVMEDIA_TYPE_AUDIO,
 257     .id             = AV_CODEC_ID_DTS,
 258     .priv_data_size = sizeof(DCADecContext),
 259     .init           = dcadec_init,
 260     .decode         = dcadec_decode_frame,
 261     .close          = dcadec_close,
 262     .flush          = dcadec_flush,
 263     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
 264     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S32P, AV_SAMPLE_FMT_S16P,
 265                                                       AV_SAMPLE_FMT_NONE },
 266     .profiles       = NULL_IF_CONFIG_SMALL(profiles),
 267 };