FFmpeg
dcadec.c
Go to the documentation of this file.
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/mem.h"
22 #include "libavutil/opt.h"
24 #include "libavutil/thread.h"
25 
26 #include "codec_internal.h"
27 #include "dcadec.h"
28 #include "dcahuff.h"
29 #include "dca_syncwords.h"
30 #include "profiles.h"
31 
32 #define MIN_PACKET_SIZE 16
33 #define MAX_PACKET_SIZE 0x104000
34 
35 int ff_dca_set_channel_layout(AVCodecContext *avctx, int *ch_remap, int dca_mask)
36 {
37  static const uint8_t dca2wav_norm[28] = {
38  2, 0, 1, 9, 10, 3, 8, 4, 5, 9, 10, 6, 7, 12,
39  13, 14, 3, 6, 7, 11, 12, 14, 16, 15, 17, 8, 4, 5,
40  };
41 
42  static const uint8_t dca2wav_wide[28] = {
43  2, 0, 1, 4, 5, 3, 8, 4, 5, 9, 10, 6, 7, 12,
44  13, 14, 3, 9, 10, 11, 12, 14, 16, 15, 17, 8, 4, 5,
45  };
46 
47  DCAContext *s = avctx->priv_data;
48 
49  int dca_ch, wav_ch, nchannels = 0;
50 
52  if (s->output_channel_order == CHANNEL_ORDER_CODED) {
53  for (dca_ch = 0; dca_ch < DCA_SPEAKER_COUNT; dca_ch++)
54  if (dca_mask & (1U << dca_ch))
55  ch_remap[nchannels++] = dca_ch;
57  avctx->ch_layout.nb_channels = nchannels;
58  } else {
59  int wav_mask = 0;
60  int wav_map[18];
61  const uint8_t *dca2wav;
62  if (dca_mask == DCA_SPEAKER_LAYOUT_7POINT0_WIDE ||
64  dca2wav = dca2wav_wide;
65  else
66  dca2wav = dca2wav_norm;
67  for (dca_ch = 0; dca_ch < 28; dca_ch++) {
68  if (dca_mask & (1 << dca_ch)) {
69  wav_ch = dca2wav[dca_ch];
70  if (!(wav_mask & (1 << wav_ch))) {
71  wav_map[wav_ch] = dca_ch;
72  wav_mask |= 1 << wav_ch;
73  }
74  }
75  }
76  for (wav_ch = 0; wav_ch < 18; wav_ch++)
77  if (wav_mask & (1 << wav_ch))
78  ch_remap[nchannels++] = wav_map[wav_ch];
79 
80  av_channel_layout_from_mask(&avctx->ch_layout, wav_mask);
81  }
82 
83  return nchannels;
84 }
85 
87  int *coeff_l, int nsamples, int ch_mask)
88 {
89  int pos, spkr, max_spkr = av_log2(ch_mask);
90  int *coeff_r = coeff_l + av_popcount(ch_mask);
91 
92  av_assert0(DCA_HAS_STEREO(ch_mask));
93 
94  // Scale left and right channels
95  pos = (ch_mask & DCA_SPEAKER_MASK_C);
96  dcadsp->dmix_scale(samples[DCA_SPEAKER_L], coeff_l[pos ], nsamples);
97  dcadsp->dmix_scale(samples[DCA_SPEAKER_R], coeff_r[pos + 1], nsamples);
98 
99  // Downmix remaining channels
100  for (spkr = 0; spkr <= max_spkr; spkr++) {
101  if (!(ch_mask & (1U << spkr)))
102  continue;
103 
104  if (*coeff_l && spkr != DCA_SPEAKER_L)
105  dcadsp->dmix_add(samples[DCA_SPEAKER_L], samples[spkr],
106  *coeff_l, nsamples);
107 
108  if (*coeff_r && spkr != DCA_SPEAKER_R)
109  dcadsp->dmix_add(samples[DCA_SPEAKER_R], samples[spkr],
110  *coeff_r, nsamples);
111 
112  coeff_l++;
113  coeff_r++;
114  }
115 }
116 
118  int *coeff_l, int nsamples, int ch_mask)
119 {
120  int pos, spkr, max_spkr = av_log2(ch_mask);
121  int *coeff_r = coeff_l + av_popcount(ch_mask);
122  const float scale = 1.0f / (1 << 15);
123 
124  av_assert0(DCA_HAS_STEREO(ch_mask));
125 
126  // Scale left and right channels
127  pos = (ch_mask & DCA_SPEAKER_MASK_C);
129  coeff_l[pos ] * scale, nsamples);
131  coeff_r[pos + 1] * scale, nsamples);
132 
133  // Downmix remaining channels
134  for (spkr = 0; spkr <= max_spkr; spkr++) {
135  if (!(ch_mask & (1U << spkr)))
136  continue;
137 
138  if (*coeff_l && spkr != DCA_SPEAKER_L)
140  *coeff_l * scale, nsamples);
141 
142  if (*coeff_r && spkr != DCA_SPEAKER_R)
144  *coeff_r * scale, nsamples);
145 
146  coeff_l++;
147  coeff_r++;
148  }
149 }
150 
152  int *got_frame_ptr, AVPacket *avpkt)
153 {
154  DCAContext *s = avctx->priv_data;
155  const uint8_t *input = avpkt->data;
156  int input_size = avpkt->size;
157  int i, ret, prev_packet = s->packet;
158  uint32_t mrk;
159 
160  if (input_size < MIN_PACKET_SIZE || input_size > MAX_PACKET_SIZE) {
161  av_log(avctx, AV_LOG_ERROR, "Invalid packet size\n");
162  return AVERROR_INVALIDDATA;
163  }
164 
165  // Convert input to BE format
166  mrk = AV_RB32(input);
167  if (mrk != DCA_SYNCWORD_CORE_BE && mrk != DCA_SYNCWORD_SUBSTREAM) {
168  av_fast_padded_malloc(&s->buffer, &s->buffer_size, input_size);
169  if (!s->buffer)
170  return AVERROR(ENOMEM);
171 
172  for (i = 0, ret = AVERROR_INVALIDDATA; i < input_size - MIN_PACKET_SIZE + 1 && ret < 0; i++)
173  ret = avpriv_dca_convert_bitstream(input + i, input_size - i, s->buffer, s->buffer_size);
174 
175  if (ret < 0) {
176  av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
177  return ret;
178  }
179 
180  input = s->buffer;
181  input_size = ret;
182  }
183 
184  s->packet = 0;
185 
186  // Parse backward compatible core sub-stream
188  int frame_size;
189 
190  if ((ret = ff_dca_core_parse(&s->core, input, input_size)) < 0)
191  return ret;
192 
193  s->packet |= DCA_PACKET_CORE;
194 
195  // EXXS data must be aligned on 4-byte boundary
196  frame_size = FFALIGN(s->core.frame_size, 4);
197  if (input_size - 4 > frame_size) {
198  input += frame_size;
199  input_size -= frame_size;
200  }
201  }
202 
203  if (!s->core_only) {
204  DCAExssAsset *asset = NULL;
205 
206  // Parse extension sub-stream (EXSS)
208  if ((ret = ff_dca_exss_parse(&s->exss, input, input_size)) < 0) {
209  if (avctx->err_recognition & AV_EF_EXPLODE)
210  return ret;
211  } else {
212  s->packet |= DCA_PACKET_EXSS;
213  asset = &s->exss.assets[0];
214  }
215  }
216 
217  // Parse XLL component in EXSS
218  if (asset && (asset->extension_mask & DCA_EXSS_XLL)) {
219  if ((ret = ff_dca_xll_parse(&s->xll, input, asset)) < 0) {
220  // Conceal XLL synchronization error
221  if (ret == AVERROR(EAGAIN)) {
222  if ((prev_packet & DCA_PACKET_XLL) && (s->packet & DCA_PACKET_CORE))
223  s->packet |= DCA_PACKET_XLL | DCA_PACKET_RECOVERY;
224  } else if (ret == AVERROR(ENOMEM) || (avctx->err_recognition & AV_EF_EXPLODE))
225  return ret;
226  } else {
227  s->packet |= DCA_PACKET_XLL;
228  }
229  }
230 
231  // Parse LBR component in EXSS
232  if (asset && (asset->extension_mask & DCA_EXSS_LBR)) {
233  if ((ret = ff_dca_lbr_parse(&s->lbr, input, asset)) < 0) {
234  if (ret == AVERROR(ENOMEM) || (avctx->err_recognition & AV_EF_EXPLODE))
235  return ret;
236  } else {
237  s->packet |= DCA_PACKET_LBR;
238  }
239  }
240 
241  // Parse core extensions in EXSS or backward compatible core sub-stream
242  if ((s->packet & DCA_PACKET_CORE)
243  && (ret = ff_dca_core_parse_exss(&s->core, input, asset)) < 0)
244  return ret;
245  }
246 
247  // Filter the frame
248  if (s->packet & DCA_PACKET_LBR) {
249  if ((ret = ff_dca_lbr_filter_frame(&s->lbr, frame)) < 0)
250  return ret;
251  } else if (s->packet & DCA_PACKET_XLL) {
252  if (s->packet & DCA_PACKET_CORE) {
253  int x96_synth = -1;
254 
255  // Enable X96 synthesis if needed
256  if (s->xll.chset[0].freq == 96000 && s->core.sample_rate == 48000)
257  x96_synth = 1;
258 
259  if ((ret = ff_dca_core_filter_fixed(&s->core, x96_synth)) < 0)
260  return ret;
261 
262  // Force lossy downmixed output on the first core frame filtered.
263  // This prevents audible clicks when seeking and is consistent with
264  // what reference decoder does when there are multiple channel sets.
265  if (!(prev_packet & DCA_PACKET_RESIDUAL) && s->xll.nreschsets > 0
266  && s->xll.nchsets > 1) {
267  av_log(avctx, AV_LOG_VERBOSE, "Forcing XLL recovery mode\n");
268  s->packet |= DCA_PACKET_RECOVERY;
269  }
270 
271  // Set 'residual ok' flag for the next frame
272  s->packet |= DCA_PACKET_RESIDUAL;
273  }
274 
275  if ((ret = ff_dca_xll_filter_frame(&s->xll, frame)) < 0) {
276  // Fall back to core unless hard error
277  if (!(s->packet & DCA_PACKET_CORE))
278  return ret;
280  return ret;
281  if ((ret = ff_dca_core_filter_frame(&s->core, frame)) < 0)
282  return ret;
283  }
284  } else if (s->packet & DCA_PACKET_CORE) {
285  if ((ret = ff_dca_core_filter_frame(&s->core, frame)) < 0)
286  return ret;
287  if (s->core.filter_mode & DCA_FILTER_MODE_FIXED)
288  s->packet |= DCA_PACKET_RESIDUAL;
289  } else {
290  av_log(avctx, AV_LOG_ERROR, "No valid DCA sub-stream found\n");
291  if (s->core_only)
292  av_log(avctx, AV_LOG_WARNING, "Consider disabling 'core_only' option\n");
293  return AVERROR_INVALIDDATA;
294  }
295 
296  *got_frame_ptr = 1;
297 
298  return avpkt->size;
299 }
300 
302 {
303  DCAContext *s = avctx->priv_data;
304 
305  ff_dca_core_flush(&s->core);
306  ff_dca_xll_flush(&s->xll);
307  ff_dca_lbr_flush(&s->lbr);
308 
309  s->packet &= DCA_PACKET_MASK;
310 }
311 
313 {
314  DCAContext *s = avctx->priv_data;
315 
316  ff_dca_core_close(&s->core);
317  ff_dca_xll_close(&s->xll);
318  ff_dca_lbr_close(&s->lbr);
319 
320  av_freep(&s->buffer);
321  s->buffer_size = 0;
322 
323  return 0;
324 }
325 
326 static av_cold void dcadec_init_static(void)
327 {
330 }
331 
333 {
334  static AVOnce init_static_once = AV_ONCE_INIT;
335  DCAContext *s = avctx->priv_data;
336 
337  s->avctx = avctx;
338  s->core.avctx = avctx;
339  s->exss.avctx = avctx;
340  s->xll.avctx = avctx;
341  s->lbr.avctx = avctx;
342 
343  if (ff_dca_core_init(&s->core) < 0)
344  return AVERROR(ENOMEM);
345 
346  if (ff_dca_lbr_init(&s->lbr) < 0)
347  return AVERROR(ENOMEM);
348 
349  ff_dcadsp_init(&s->dcadsp);
350  s->core.dcadsp = &s->dcadsp;
351  s->xll.dcadsp = &s->dcadsp;
352  s->lbr.dcadsp = &s->dcadsp;
353 
355 
356  if (s->downmix_layout.nb_channels) {
359  s->request_channel_layout = DCA_SPEAKER_LAYOUT_STEREO;
362  } else if (!av_channel_layout_compare(&s->downmix_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT0)) {
363  s->request_channel_layout = DCA_SPEAKER_LAYOUT_5POINT0;
366  } else if (!av_channel_layout_compare(&s->downmix_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT1)) {
367  s->request_channel_layout = DCA_SPEAKER_LAYOUT_5POINT1;
370  }
371  else
372  av_log(avctx, AV_LOG_WARNING, "Invalid downmix layout\n");
373  }
374 
375  ff_thread_once(&init_static_once, dcadec_init_static);
376 
377  return 0;
378 }
379 
380 #define OFFSET(x) offsetof(DCAContext, x)
381 #define PARAM AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM
382 
383 static const AVOption dcadec_options[] = {
384  { "core_only", "Decode core only without extensions", OFFSET(core_only), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, PARAM },
385 
386  { "channel_order", "Order in which the channels are to be exported",
387  OFFSET(output_channel_order), AV_OPT_TYPE_INT,
388  { .i64 = CHANNEL_ORDER_DEFAULT }, 0, 1, PARAM, .unit = "channel_order" },
389  { "default", "normal libavcodec channel order", 0, AV_OPT_TYPE_CONST,
390  { .i64 = CHANNEL_ORDER_DEFAULT }, .flags = PARAM, .unit = "channel_order" },
391  { "coded", "order in which the channels are coded in the bitstream",
392  0, AV_OPT_TYPE_CONST, { .i64 = CHANNEL_ORDER_CODED }, .flags = PARAM, .unit = "channel_order" },
393 
394  { "downmix", "Request a specific channel layout from the decoder", OFFSET(downmix_layout),
395  AV_OPT_TYPE_CHLAYOUT, {.str = NULL}, .flags = PARAM },
396 
397  { NULL }
398 };
399 
400 static const AVClass dcadec_class = {
401  .class_name = "DCA decoder",
402  .item_name = av_default_item_name,
403  .option = dcadec_options,
404  .version = LIBAVUTIL_VERSION_INT,
405  .category = AV_CLASS_CATEGORY_DECODER,
406 };
407 
409  .p.name = "dca",
410  CODEC_LONG_NAME("DCA (DTS Coherent Acoustics)"),
411  .p.type = AVMEDIA_TYPE_AUDIO,
412  .p.id = AV_CODEC_ID_DTS,
413  .priv_data_size = sizeof(DCAContext),
414  .init = dcadec_init,
416  .close = dcadec_close,
417  .flush = dcadec_flush,
418  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
419  .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P,
421  .p.priv_class = &dcadec_class,
422  .p.profiles = NULL_IF_CONFIG_SMALL(ff_dca_profiles),
423  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
424 };
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
dcadec_close
static av_cold int dcadec_close(AVCodecContext *avctx)
Definition: dcadec.c:312
AV_CHANNEL_LAYOUT_STEREO_DOWNMIX
#define AV_CHANNEL_LAYOUT_STEREO_DOWNMIX
Definition: channel_layout.h:413
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
ff_dca_xll_parse
int ff_dca_xll_parse(DCAXllDecoder *s, const uint8_t *data, DCAExssAsset *asset)
Definition: dca_xll.c:1181
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AV_CLASS_CATEGORY_DECODER
@ AV_CLASS_CATEGORY_DECODER
Definition: log.h:35
AV_CHANNEL_LAYOUT_STEREO
#define AV_CHANNEL_LAYOUT_STEREO
Definition: channel_layout.h:379
DCA_SPEAKER_LAYOUT_5POINT0
#define DCA_SPEAKER_LAYOUT_5POINT0
Definition: dca.h:128
thread.h
ff_dca_core_close
av_cold void ff_dca_core_close(DCACoreDecoder *s)
Definition: dca_core.c:2437
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1420
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
DCA_PACKET_LBR
#define DCA_PACKET_LBR
Definition: dcadec.h:42
AVPacket::data
uint8_t * data
Definition: packet.h:524
AVOption
AVOption.
Definition: opt.h:357
AV_SAMPLE_FMT_S32P
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:65
DCA_SPEAKER_LAYOUT_STEREO
#define DCA_SPEAKER_LAYOUT_STEREO
Definition: dca.h:122
FFCodec
Definition: codec_internal.h:126
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:308
av_popcount
#define av_popcount
Definition: common.h:153
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
DCA_PACKET_XLL
#define DCA_PACKET_XLL
Definition: dcadec.h:41
DCA_FILTER_MODE_FIXED
#define DCA_FILTER_MODE_FIXED
Definition: dca_core.h:55
ff_dca_lbr_parse
int ff_dca_lbr_parse(DCALbrDecoder *s, const uint8_t *data, DCAExssAsset *asset)
Definition: dca_lbr.c:1170
dcadec_init
static av_cold int dcadec_init(AVCodecContext *avctx)
Definition: dcadec.c:332
DCAExssAsset
Definition: dca_exss.h:29
DCA_PACKET_RECOVERY
#define DCA_PACKET_RECOVERY
Sync error recovery flag.
Definition: dcadec.h:45
ff_dca_core_filter_frame
int ff_dca_core_filter_frame(DCACoreDecoder *s, AVFrame *frame)
Definition: dca_core.c:2344
avpriv_dca_convert_bitstream
int avpriv_dca_convert_bitstream(const uint8_t *src, int src_size, uint8_t *dst, int max_size)
Convert bitstream to one representation based on sync marker.
Definition: dca.c:49
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
DCA_EXSS_XLL
@ DCA_EXSS_XLL
Definition: dca.h:179
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1065
ff_dca_profiles
const AVProfile ff_dca_profiles[]
Definition: profiles.c:39
dcadec_flush
static av_cold void dcadec_flush(AVCodecContext *avctx)
Definition: dcadec.c:301
DCA_SPEAKER_MASK_C
@ DCA_SPEAKER_MASK_C
Definition: dca.h:91
DCA_SPEAKER_LAYOUT_7POINT1_WIDE
#define DCA_SPEAKER_LAYOUT_7POINT1_WIDE
Definition: dca.h:131
ff_dca_downmix_to_stereo_float
void ff_dca_downmix_to_stereo_float(AVFloatDSPContext *fdsp, float **samples, int *coeff_l, int nsamples, int ch_mask)
Definition: dcadec.c:117
dcadec_init_static
static av_cold void dcadec_init_static(void)
Definition: dcadec.c:326
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
dcadec_decode_frame
static int dcadec_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: dcadec.c:151
ff_dca_lbr_init_tables
av_cold void ff_dca_lbr_init_tables(void)
Definition: dca_lbr.c:135
ff_dca_downmix_to_stereo_fixed
void ff_dca_downmix_to_stereo_fixed(DCADSPContext *dcadsp, int32_t **samples, int *coeff_l, int nsamples, int ch_mask)
Definition: dcadec.c:86
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:286
dcadec_options
static const AVOption dcadec_options[]
Definition: dcadec.c:383
s
#define s(width, name)
Definition: cbs_vp9.c:198
DCA_SPEAKER_LAYOUT_7POINT0_WIDE
#define DCA_SPEAKER_LAYOUT_7POINT0_WIDE
Definition: dca.h:130
DCA_SPEAKER_LAYOUT_5POINT1
#define DCA_SPEAKER_LAYOUT_5POINT1
Definition: dca.h:129
frame_size
int frame_size
Definition: mxfenc.c:2423
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition: channel_layout.h:112
av_channel_layout_from_mask
int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask)
Initialize a native channel layout from a bitmask indicating which channels are present.
Definition: channel_layout.c:243
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
DCADSPContext::dmix_scale
void(* dmix_scale)(int32_t *dst, int scale, ptrdiff_t len)
Definition: dcadsp.h:82
dcadec.h
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
dca_syncwords.h
ff_dca_set_channel_layout
int ff_dca_set_channel_layout(AVCodecContext *avctx, int *ch_remap, int dca_mask)
Definition: dcadec.c:35
ff_dca_lbr_filter_frame
int ff_dca_lbr_filter_frame(DCALbrDecoder *s, AVFrame *frame)
Definition: dca_lbr.c:1737
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
DCA_HAS_STEREO
#define DCA_HAS_STEREO(mask)
Definition: dca.h:133
NULL
#define NULL
Definition: coverity.c:32
AVFloatDSPContext::vector_fmul_scalar
void(* vector_fmul_scalar)(float *dst, const float *src, float mul, int len)
Multiply a vector of floats by a scalar float.
Definition: float_dsp.h:83
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
profiles.h
ff_dca_init_vlcs
av_cold void ff_dca_init_vlcs(void)
Definition: dcahuff.c:789
ff_dca_decoder
const FFCodec ff_dca_decoder
Definition: dcadec.c:408
OFFSET
#define OFFSET(x)
Definition: dcadec.c:380
AV_OPT_TYPE_CHLAYOUT
@ AV_OPT_TYPE_CHLAYOUT
Definition: opt.h:262
DCA_PACKET_CORE
#define DCA_PACKET_CORE
Definition: dcadec.h:39
DCADSPContext
Definition: dcadsp.h:30
AVOnce
#define AVOnce
Definition: thread.h:202
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:106
DCA_SYNCWORD_CORE_BE
#define DCA_SYNCWORD_CORE_BE
Definition: dca_syncwords.h:22
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
dcahuff.h
AVPacket::size
int size
Definition: packet.h:525
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
ff_dca_core_parse
int ff_dca_core_parse(DCACoreDecoder *s, const uint8_t *data, int size)
Definition: dca_core.c:1796
ff_dcadsp_init
av_cold void ff_dcadsp_init(DCADSPContext *s)
Definition: dcadsp.c:461
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:303
codec_internal.h
PARAM
#define PARAM
Definition: dcadec.c:381
AV_CODEC_ID_DTS
@ AV_CODEC_ID_DTS
Definition: codec_id.h:444
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
AVFloatDSPContext
Definition: float_dsp.h:22
DCA_PACKET_RESIDUAL
#define DCA_PACKET_RESIDUAL
Core valid for residual decoding.
Definition: dcadec.h:46
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
DCA_SPEAKER_R
@ DCA_SPEAKER_R
Definition: dca.h:78
input
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input
Definition: filter_design.txt:172
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:64
av_channel_layout_compare
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
Definition: channel_layout.c:800
ff_dca_core_init
av_cold int ff_dca_core_init(DCACoreDecoder *s)
Definition: dca_core.c:2411
DCADSPContext::dmix_add
void(* dmix_add)(int32_t *dst, const int32_t *src, int coeff, ptrdiff_t len)
Definition: dcadsp.h:80
ff_dca_exss_parse
int ff_dca_exss_parse(DCAExssParser *s, const uint8_t *data, int size)
Definition: dca_exss.c:378
CHANNEL_ORDER_CODED
@ CHANNEL_ORDER_CODED
Definition: aacdec.h:59
DCAContext
Definition: dcadec.h:53
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AV_CRC_16_CCITT
@ AV_CRC_16_CCITT
Definition: crc.h:51
AVFloatDSPContext::vector_fmac_scalar
void(* vector_fmac_scalar)(float *dst, const float *src, float mul, int len)
Multiply a vector of floats by a scalar float and add to destination vector.
Definition: float_dsp.h:52
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
av_fast_padded_malloc
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:52
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
ff_dca_lbr_init
av_cold int ff_dca_lbr_init(DCALbrDecoder *s)
Definition: dca_lbr.c:1823
DCA_SYNCWORD_SUBSTREAM
#define DCA_SYNCWORD_SUBSTREAM
Definition: dca_syncwords.h:32
ff_dca_core_filter_fixed
int ff_dca_core_filter_fixed(DCACoreDecoder *s, int x96_synth)
Definition: dca_core.c:1957
ff_dca_xll_filter_frame
int ff_dca_xll_filter_frame(DCAXllDecoder *s, AVFrame *frame)
Definition: dca_xll.c:1342
ff_dca_lbr_flush
av_cold void ff_dca_lbr_flush(DCALbrDecoder *s)
Definition: dca_lbr.c:1799
ret
ret
Definition: filter_design.txt:187
ff_dca_core_parse_exss
int ff_dca_core_parse_exss(DCACoreDecoder *s, const uint8_t *data, DCAExssAsset *asset)
Definition: dca_core.c:1829
DCA_PACKET_EXSS
#define DCA_PACKET_EXSS
Definition: dcadec.h:40
ff_dca_lbr_close
av_cold void ff_dca_lbr_close(DCALbrDecoder *s)
Definition: dca_lbr.c:1832
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
pos
unsigned int pos
Definition: spdifenc.c:414
CHANNEL_ORDER_DEFAULT
@ CHANNEL_ORDER_DEFAULT
Definition: aacdec.h:58
dcadec_class
static const AVClass dcadec_class
Definition: dcadec.c:400
U
#define U(x)
Definition: vpx_arith.h:37
AVCodecContext
main external API structure.
Definition: avcodec.h:445
channel_layout.h
MAX_PACKET_SIZE
#define MAX_PACKET_SIZE
Definition: dcadec.c:33
DCA_PACKET_MASK
#define DCA_PACKET_MASK
Definition: dcadec.h:43
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:245
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:433
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
mem.h
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:291
DCAExssAsset::extension_mask
int extension_mask
Coding components used in asset.
Definition: dca_exss.h:45
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
MIN_PACKET_SIZE
#define MIN_PACKET_SIZE
Definition: dcadec.c:32
AVPacket
This structure stores compressed data.
Definition: packet.h:501
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:261
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
ff_dca_xll_flush
av_cold void ff_dca_xll_flush(DCAXllDecoder *s)
Definition: dca_xll.c:1498
int32_t
int32_t
Definition: audioconvert.c:56
DCA_SPEAKER_COUNT
@ DCA_SPEAKER_COUNT
Definition: dca.h:87
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
DCA_SPEAKER_L
@ DCA_SPEAKER_L
Definition: dca.h:78
AV_CHANNEL_LAYOUT_5POINT0
#define AV_CHANNEL_LAYOUT_5POINT0
Definition: channel_layout.h:388
AV_CHANNEL_LAYOUT_5POINT1
#define AV_CHANNEL_LAYOUT_5POINT1
Definition: channel_layout.h:389
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:254
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
ff_dca_xll_close
av_cold void ff_dca_xll_close(DCAXllDecoder *s)
Definition: dca_xll.c:1503
DCA_EXSS_LBR
@ DCA_EXSS_LBR
Definition: dca.h:178
ff_dca_core_flush
av_cold void ff_dca_core_flush(DCACoreDecoder *s)
Definition: dca_core.c:2398