avcodec/cavsdec: Propagate error codes inside decode_mb_i()
[ffmpeg.git] / libavcodec / dcadec.c
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
24 #include "dcadec.h"
25 #include "dcahuff.h"
26 #include "dca_syncwords.h"
27 #include "profiles.h"
28
29 #define MIN_PACKET_SIZE     16
30 #define MAX_PACKET_SIZE     0x104000
31
32 int ff_dca_set_channel_layout(AVCodecContext *avctx, int *ch_remap, int dca_mask)
33 {
34     static const uint8_t dca2wav_norm[28] = {
35          2,  0, 1, 9, 10,  3,  8,  4,  5,  9, 10, 6, 7, 12,
36         13, 14, 3, 6,  7, 11, 12, 14, 16, 15, 17, 8, 4,  5,
37     };
38
39     static const uint8_t dca2wav_wide[28] = {
40          2,  0, 1, 4,  5,  3,  8,  4,  5,  9, 10, 6, 7, 12,
41         13, 14, 3, 9, 10, 11, 12, 14, 16, 15, 17, 8, 4,  5,
42     };
43
44     int dca_ch, wav_ch, nchannels = 0;
45
46     if (avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE) {
47         for (dca_ch = 0; dca_ch < DCA_SPEAKER_COUNT; dca_ch++)
48             if (dca_mask & (1U << dca_ch))
49                 ch_remap[nchannels++] = dca_ch;
50         avctx->channel_layout = dca_mask;
51     } else {
52         int wav_mask = 0;
53         int wav_map[18];
54         const uint8_t *dca2wav;
55         if (dca_mask == DCA_SPEAKER_LAYOUT_7POINT0_WIDE ||
56             dca_mask == DCA_SPEAKER_LAYOUT_7POINT1_WIDE)
57             dca2wav = dca2wav_wide;
58         else
59             dca2wav = dca2wav_norm;
60         for (dca_ch = 0; dca_ch < 28; dca_ch++) {
61             if (dca_mask & (1 << dca_ch)) {
62                 wav_ch = dca2wav[dca_ch];
63                 if (!(wav_mask & (1 << wav_ch))) {
64                     wav_map[wav_ch] = dca_ch;
65                     wav_mask |= 1 << wav_ch;
66                 }
67             }
68         }
69         for (wav_ch = 0; wav_ch < 18; wav_ch++)
70             if (wav_mask & (1 << wav_ch))
71                 ch_remap[nchannels++] = wav_map[wav_ch];
72         avctx->channel_layout = wav_mask;
73     }
74
75     avctx->channels = nchannels;
76     return nchannels;
77 }
78
79 void ff_dca_downmix_to_stereo_fixed(DCADSPContext *dcadsp, int32_t **samples,
80                                     int *coeff_l, int nsamples, int ch_mask)
81 {
82     int pos, spkr, max_spkr = av_log2(ch_mask);
83     int *coeff_r = coeff_l + av_popcount(ch_mask);
84
85     av_assert0(DCA_HAS_STEREO(ch_mask));
86
87     // Scale left and right channels
88     pos = (ch_mask & DCA_SPEAKER_MASK_C);
89     dcadsp->dmix_scale(samples[DCA_SPEAKER_L], coeff_l[pos    ], nsamples);
90     dcadsp->dmix_scale(samples[DCA_SPEAKER_R], coeff_r[pos + 1], nsamples);
91
92     // Downmix remaining channels
93     for (spkr = 0; spkr <= max_spkr; spkr++) {
94         if (!(ch_mask & (1U << spkr)))
95             continue;
96
97         if (*coeff_l && spkr != DCA_SPEAKER_L)
98             dcadsp->dmix_add(samples[DCA_SPEAKER_L], samples[spkr],
99                              *coeff_l, nsamples);
100
101         if (*coeff_r && spkr != DCA_SPEAKER_R)
102             dcadsp->dmix_add(samples[DCA_SPEAKER_R], samples[spkr],
103                              *coeff_r, nsamples);
104
105         coeff_l++;
106         coeff_r++;
107     }
108 }
109
110 void ff_dca_downmix_to_stereo_float(AVFloatDSPContext *fdsp, float **samples,
111                                     int *coeff_l, int nsamples, int ch_mask)
112 {
113     int pos, spkr, max_spkr = av_log2(ch_mask);
114     int *coeff_r = coeff_l + av_popcount(ch_mask);
115     const float scale = 1.0f / (1 << 15);
116
117     av_assert0(DCA_HAS_STEREO(ch_mask));
118
119     // Scale left and right channels
120     pos = (ch_mask & DCA_SPEAKER_MASK_C);
121     fdsp->vector_fmul_scalar(samples[DCA_SPEAKER_L], samples[DCA_SPEAKER_L],
122                              coeff_l[pos    ] * scale, nsamples);
123     fdsp->vector_fmul_scalar(samples[DCA_SPEAKER_R], samples[DCA_SPEAKER_R],
124                              coeff_r[pos + 1] * scale, nsamples);
125
126     // Downmix remaining channels
127     for (spkr = 0; spkr <= max_spkr; spkr++) {
128         if (!(ch_mask & (1U << spkr)))
129             continue;
130
131         if (*coeff_l && spkr != DCA_SPEAKER_L)
132             fdsp->vector_fmac_scalar(samples[DCA_SPEAKER_L], samples[spkr],
133                                      *coeff_l * scale, nsamples);
134
135         if (*coeff_r && spkr != DCA_SPEAKER_R)
136             fdsp->vector_fmac_scalar(samples[DCA_SPEAKER_R], samples[spkr],
137                                      *coeff_r * scale, nsamples);
138
139         coeff_l++;
140         coeff_r++;
141     }
142 }
143
144 static int dcadec_decode_frame(AVCodecContext *avctx, void *data,
145                                int *got_frame_ptr, AVPacket *avpkt)
146 {
147     DCAContext *s = avctx->priv_data;
148     AVFrame *frame = data;
149     uint8_t *input = avpkt->data;
150     int input_size = avpkt->size;
151     int i, ret, prev_packet = s->packet;
152     uint32_t mrk;
153
154     if (input_size < MIN_PACKET_SIZE || input_size > MAX_PACKET_SIZE) {
155         av_log(avctx, AV_LOG_ERROR, "Invalid packet size\n");
156         return AVERROR_INVALIDDATA;
157     }
158
159     // Convert input to BE format
160     mrk = AV_RB32(input);
161     if (mrk != DCA_SYNCWORD_CORE_BE && mrk != DCA_SYNCWORD_SUBSTREAM) {
162         av_fast_padded_malloc(&s->buffer, &s->buffer_size, input_size);
163         if (!s->buffer)
164             return AVERROR(ENOMEM);
165
166         for (i = 0, ret = AVERROR_INVALIDDATA; i < input_size - MIN_PACKET_SIZE + 1 && ret < 0; i++)
167             ret = avpriv_dca_convert_bitstream(input + i, input_size - i, s->buffer, s->buffer_size);
168
169         if (ret < 0) {
170             av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
171             return ret;
172         }
173
174         input      = s->buffer;
175         input_size = ret;
176     }
177
178     s->packet = 0;
179
180     // Parse backward compatible core sub-stream
181     if (AV_RB32(input) == DCA_SYNCWORD_CORE_BE) {
182         int frame_size;
183
184         if ((ret = ff_dca_core_parse(&s->core, input, input_size)) < 0)
185             return ret;
186
187         s->packet |= DCA_PACKET_CORE;
188
189         // EXXS data must be aligned on 4-byte boundary
190         frame_size = FFALIGN(s->core.frame_size, 4);
191         if (input_size - 4 > frame_size) {
192             input      += frame_size;
193             input_size -= frame_size;
194         }
195     }
196
197     if (!s->core_only) {
198         DCAExssAsset *asset = NULL;
199
200         // Parse extension sub-stream (EXSS)
201         if (AV_RB32(input) == DCA_SYNCWORD_SUBSTREAM) {
202             if ((ret = ff_dca_exss_parse(&s->exss, input, input_size)) < 0) {
203                 if (avctx->err_recognition & AV_EF_EXPLODE)
204                     return ret;
205             } else {
206                 s->packet |= DCA_PACKET_EXSS;
207                 asset = &s->exss.assets[0];
208             }
209         }
210
211         // Parse XLL component in EXSS
212         if (asset && (asset->extension_mask & DCA_EXSS_XLL)) {
213             if ((ret = ff_dca_xll_parse(&s->xll, input, asset)) < 0) {
214                 // Conceal XLL synchronization error
215                 if (ret == AVERROR(EAGAIN)
216                     && (prev_packet & DCA_PACKET_XLL)
217                     && (s->packet & DCA_PACKET_CORE))
218                     s->packet |= DCA_PACKET_XLL | DCA_PACKET_RECOVERY;
219                 else if (ret == AVERROR(ENOMEM) || (avctx->err_recognition & AV_EF_EXPLODE))
220                     return ret;
221             } else {
222                 s->packet |= DCA_PACKET_XLL;
223             }
224         }
225
226         // Parse LBR component in EXSS
227         if (asset && (asset->extension_mask & DCA_EXSS_LBR)) {
228             if ((ret = ff_dca_lbr_parse(&s->lbr, input, asset)) < 0) {
229                 if (ret == AVERROR(ENOMEM) || (avctx->err_recognition & AV_EF_EXPLODE))
230                     return ret;
231             } else {
232                 s->packet |= DCA_PACKET_LBR;
233             }
234         }
235
236         // Parse core extensions in EXSS or backward compatible core sub-stream
237         if ((s->packet & DCA_PACKET_CORE)
238             && (ret = ff_dca_core_parse_exss(&s->core, input, asset)) < 0)
239             return ret;
240     }
241
242     // Filter the frame
243     if (s->packet & DCA_PACKET_LBR) {
244         if ((ret = ff_dca_lbr_filter_frame(&s->lbr, frame)) < 0)
245             return ret;
246     } else if (s->packet & DCA_PACKET_XLL) {
247         if (s->packet & DCA_PACKET_CORE) {
248             int x96_synth = -1;
249
250             // Enable X96 synthesis if needed
251             if (s->xll.chset[0].freq == 96000 && s->core.sample_rate == 48000)
252                 x96_synth = 1;
253
254             if ((ret = ff_dca_core_filter_fixed(&s->core, x96_synth)) < 0)
255                 return ret;
256
257             // Force lossy downmixed output on the first core frame filtered.
258             // This prevents audible clicks when seeking and is consistent with
259             // what reference decoder does when there are multiple channel sets.
260             if (!(prev_packet & DCA_PACKET_RESIDUAL) && s->xll.nreschsets > 0
261                 && s->xll.nchsets > 1) {
262                 av_log(avctx, AV_LOG_VERBOSE, "Forcing XLL recovery mode\n");
263                 s->packet |= DCA_PACKET_RECOVERY;
264             }
265
266             // Set 'residual ok' flag for the next frame
267             s->packet |= DCA_PACKET_RESIDUAL;
268         }
269
270         if ((ret = ff_dca_xll_filter_frame(&s->xll, frame)) < 0) {
271             // Fall back to core unless hard error
272             if (!(s->packet & DCA_PACKET_CORE))
273                 return ret;
274             if (ret != AVERROR_INVALIDDATA || (avctx->err_recognition & AV_EF_EXPLODE))
275                 return ret;
276             if ((ret = ff_dca_core_filter_frame(&s->core, frame)) < 0)
277                 return ret;
278         }
279     } else if (s->packet & DCA_PACKET_CORE) {
280         if ((ret = ff_dca_core_filter_frame(&s->core, frame)) < 0)
281             return ret;
282         if (s->core.filter_mode & DCA_FILTER_MODE_FIXED)
283             s->packet |= DCA_PACKET_RESIDUAL;
284     } else {
285         av_log(avctx, AV_LOG_ERROR, "No valid DCA sub-stream found\n");
286         if (s->core_only)
287             av_log(avctx, AV_LOG_WARNING, "Consider disabling 'core_only' option\n");
288         return AVERROR_INVALIDDATA;
289     }
290
291     *got_frame_ptr = 1;
292
293     return avpkt->size;
294 }
295
296 static av_cold void dcadec_flush(AVCodecContext *avctx)
297 {
298     DCAContext *s = avctx->priv_data;
299
300     ff_dca_core_flush(&s->core);
301     ff_dca_xll_flush(&s->xll);
302     ff_dca_lbr_flush(&s->lbr);
303
304     s->packet &= DCA_PACKET_MASK;
305 }
306
307 static av_cold int dcadec_close(AVCodecContext *avctx)
308 {
309     DCAContext *s = avctx->priv_data;
310
311     ff_dca_core_close(&s->core);
312     ff_dca_xll_close(&s->xll);
313     ff_dca_lbr_close(&s->lbr);
314
315     av_freep(&s->buffer);
316     s->buffer_size = 0;
317
318     return 0;
319 }
320
321 static av_cold int dcadec_init(AVCodecContext *avctx)
322 {
323     DCAContext *s = avctx->priv_data;
324
325     s->avctx = avctx;
326     s->core.avctx = avctx;
327     s->exss.avctx = avctx;
328     s->xll.avctx = avctx;
329     s->lbr.avctx = avctx;
330
331     ff_dca_init_vlcs();
332
333     if (ff_dca_core_init(&s->core) < 0)
334         return AVERROR(ENOMEM);
335
336     if (ff_dca_lbr_init(&s->lbr) < 0)
337         return AVERROR(ENOMEM);
338
339     ff_dcadsp_init(&s->dcadsp);
340     s->core.dcadsp = &s->dcadsp;
341     s->xll.dcadsp = &s->dcadsp;
342     s->lbr.dcadsp = &s->dcadsp;
343
344     s->crctab = av_crc_get_table(AV_CRC_16_CCITT);
345
346     switch (avctx->request_channel_layout & ~AV_CH_LAYOUT_NATIVE) {
347     case 0:
348         s->request_channel_layout = 0;
349         break;
350     case AV_CH_LAYOUT_STEREO:
351     case AV_CH_LAYOUT_STEREO_DOWNMIX:
352         s->request_channel_layout = DCA_SPEAKER_LAYOUT_STEREO;
353         break;
354     case AV_CH_LAYOUT_5POINT0:
355         s->request_channel_layout = DCA_SPEAKER_LAYOUT_5POINT0;
356         break;
357     case AV_CH_LAYOUT_5POINT1:
358         s->request_channel_layout = DCA_SPEAKER_LAYOUT_5POINT1;
359         break;
360     default:
361         av_log(avctx, AV_LOG_WARNING, "Invalid request_channel_layout\n");
362         break;
363     }
364
365     return 0;
366 }
367
368 #define OFFSET(x) offsetof(DCAContext, x)
369 #define PARAM AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM
370
371 static const AVOption dcadec_options[] = {
372     { "core_only", "Decode core only without extensions", OFFSET(core_only), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, PARAM },
373     { NULL }
374 };
375
376 static const AVClass dcadec_class = {
377     .class_name = "DCA decoder",
378     .item_name  = av_default_item_name,
379     .option     = dcadec_options,
380     .version    = LIBAVUTIL_VERSION_INT,
381     .category   = AV_CLASS_CATEGORY_DECODER,
382 };
383
384 AVCodec ff_dca_decoder = {
385     .name           = "dca",
386     .long_name      = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
387     .type           = AVMEDIA_TYPE_AUDIO,
388     .id             = AV_CODEC_ID_DTS,
389     .priv_data_size = sizeof(DCAContext),
390     .init           = dcadec_init,
391     .decode         = dcadec_decode_frame,
392     .close          = dcadec_close,
393     .flush          = dcadec_flush,
394     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
395     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P,
396                                                       AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE },
397     .priv_class     = &dcadec_class,
398     .profiles       = NULL_IF_CONFIG_SMALL(ff_dca_profiles),
399     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
400 };