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