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/opt.h"
23 #include "libavutil/thread.h"
24 
25 #include "codec_internal.h"
26 #include "dcadec.h"
27 #include "dcahuff.h"
28 #include "dca_syncwords.h"
29 #include "profiles.h"
30 
31 #define MIN_PACKET_SIZE 16
32 #define MAX_PACKET_SIZE 0x104000
33 
34 int ff_dca_set_channel_layout(AVCodecContext *avctx, int *ch_remap, int dca_mask)
35 {
36  static const uint8_t dca2wav_norm[28] = {
37  2, 0, 1, 9, 10, 3, 8, 4, 5, 9, 10, 6, 7, 12,
38  13, 14, 3, 6, 7, 11, 12, 14, 16, 15, 17, 8, 4, 5,
39  };
40 
41  static const uint8_t dca2wav_wide[28] = {
42  2, 0, 1, 4, 5, 3, 8, 4, 5, 9, 10, 6, 7, 12,
43  13, 14, 3, 9, 10, 11, 12, 14, 16, 15, 17, 8, 4, 5,
44  };
45 
46  DCAContext *s = avctx->priv_data;
47 
48  int dca_ch, wav_ch, nchannels = 0;
49 
51  if (s->output_channel_order == CHANNEL_ORDER_CODED) {
52  for (dca_ch = 0; dca_ch < DCA_SPEAKER_COUNT; dca_ch++)
53  if (dca_mask & (1U << dca_ch))
54  ch_remap[nchannels++] = dca_ch;
56  avctx->ch_layout.nb_channels = nchannels;
57  } else {
58  int wav_mask = 0;
59  int wav_map[18];
60  const uint8_t *dca2wav;
61  if (dca_mask == DCA_SPEAKER_LAYOUT_7POINT0_WIDE ||
63  dca2wav = dca2wav_wide;
64  else
65  dca2wav = dca2wav_norm;
66  for (dca_ch = 0; dca_ch < 28; dca_ch++) {
67  if (dca_mask & (1 << dca_ch)) {
68  wav_ch = dca2wav[dca_ch];
69  if (!(wav_mask & (1 << wav_ch))) {
70  wav_map[wav_ch] = dca_ch;
71  wav_mask |= 1 << wav_ch;
72  }
73  }
74  }
75  for (wav_ch = 0; wav_ch < 18; wav_ch++)
76  if (wav_mask & (1 << wav_ch))
77  ch_remap[nchannels++] = wav_map[wav_ch];
78 
79  av_channel_layout_from_mask(&avctx->ch_layout, wav_mask);
80  }
81 
82  return nchannels;
83 }
84 
86  int *coeff_l, int nsamples, int ch_mask)
87 {
88  int pos, spkr, max_spkr = av_log2(ch_mask);
89  int *coeff_r = coeff_l + av_popcount(ch_mask);
90 
91  av_assert0(DCA_HAS_STEREO(ch_mask));
92 
93  // Scale left and right channels
94  pos = (ch_mask & DCA_SPEAKER_MASK_C);
95  dcadsp->dmix_scale(samples[DCA_SPEAKER_L], coeff_l[pos ], nsamples);
96  dcadsp->dmix_scale(samples[DCA_SPEAKER_R], coeff_r[pos + 1], nsamples);
97 
98  // Downmix remaining channels
99  for (spkr = 0; spkr <= max_spkr; spkr++) {
100  if (!(ch_mask & (1U << spkr)))
101  continue;
102 
103  if (*coeff_l && spkr != DCA_SPEAKER_L)
104  dcadsp->dmix_add(samples[DCA_SPEAKER_L], samples[spkr],
105  *coeff_l, nsamples);
106 
107  if (*coeff_r && spkr != DCA_SPEAKER_R)
108  dcadsp->dmix_add(samples[DCA_SPEAKER_R], samples[spkr],
109  *coeff_r, nsamples);
110 
111  coeff_l++;
112  coeff_r++;
113  }
114 }
115 
117  int *coeff_l, int nsamples, int ch_mask)
118 {
119  int pos, spkr, max_spkr = av_log2(ch_mask);
120  int *coeff_r = coeff_l + av_popcount(ch_mask);
121  const float scale = 1.0f / (1 << 15);
122 
123  av_assert0(DCA_HAS_STEREO(ch_mask));
124 
125  // Scale left and right channels
126  pos = (ch_mask & DCA_SPEAKER_MASK_C);
128  coeff_l[pos ] * scale, nsamples);
130  coeff_r[pos + 1] * scale, nsamples);
131 
132  // Downmix remaining channels
133  for (spkr = 0; spkr <= max_spkr; spkr++) {
134  if (!(ch_mask & (1U << spkr)))
135  continue;
136 
137  if (*coeff_l && spkr != DCA_SPEAKER_L)
139  *coeff_l * scale, nsamples);
140 
141  if (*coeff_r && spkr != DCA_SPEAKER_R)
143  *coeff_r * scale, nsamples);
144 
145  coeff_l++;
146  coeff_r++;
147  }
148 }
149 
151  int *got_frame_ptr, AVPacket *avpkt)
152 {
153  DCAContext *s = avctx->priv_data;
154  const uint8_t *input = avpkt->data;
155  int input_size = avpkt->size;
156  int i, ret, prev_packet = s->packet;
157  uint32_t mrk;
158 
159  if (input_size < MIN_PACKET_SIZE || input_size > MAX_PACKET_SIZE) {
160  av_log(avctx, AV_LOG_ERROR, "Invalid packet size\n");
161  return AVERROR_INVALIDDATA;
162  }
163 
164  // Convert input to BE format
165  mrk = AV_RB32(input);
166  if (mrk != DCA_SYNCWORD_CORE_BE && mrk != DCA_SYNCWORD_SUBSTREAM) {
167  av_fast_padded_malloc(&s->buffer, &s->buffer_size, input_size);
168  if (!s->buffer)
169  return AVERROR(ENOMEM);
170 
171  for (i = 0, ret = AVERROR_INVALIDDATA; i < input_size - MIN_PACKET_SIZE + 1 && ret < 0; i++)
172  ret = avpriv_dca_convert_bitstream(input + i, input_size - i, s->buffer, s->buffer_size);
173 
174  if (ret < 0) {
175  av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
176  return ret;
177  }
178 
179  input = s->buffer;
180  input_size = ret;
181  }
182 
183  s->packet = 0;
184 
185  // Parse backward compatible core sub-stream
187  int frame_size;
188 
189  if ((ret = ff_dca_core_parse(&s->core, input, input_size)) < 0)
190  return ret;
191 
192  s->packet |= DCA_PACKET_CORE;
193 
194  // EXXS data must be aligned on 4-byte boundary
195  frame_size = FFALIGN(s->core.frame_size, 4);
196  if (input_size - 4 > frame_size) {
197  input += frame_size;
198  input_size -= frame_size;
199  }
200  }
201 
202  if (!s->core_only) {
203  DCAExssAsset *asset = NULL;
204 
205  // Parse extension sub-stream (EXSS)
207  if ((ret = ff_dca_exss_parse(&s->exss, input, input_size)) < 0) {
208  if (avctx->err_recognition & AV_EF_EXPLODE)
209  return ret;
210  } else {
211  s->packet |= DCA_PACKET_EXSS;
212  asset = &s->exss.assets[0];
213  }
214  }
215 
216  // Parse XLL component in EXSS
217  if (asset && (asset->extension_mask & DCA_EXSS_XLL)) {
218  if ((ret = ff_dca_xll_parse(&s->xll, input, asset)) < 0) {
219  // Conceal XLL synchronization error
220  if (ret == AVERROR(EAGAIN)
221  && (prev_packet & DCA_PACKET_XLL)
222  && (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 FF_API_OLD_CHANNEL_LAYOUT
358  if (avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE)
359  s->output_channel_order = CHANNEL_ORDER_CODED;
360 
361  if (avctx->request_channel_layout & ~AV_CH_LAYOUT_NATIVE) {
362  av_channel_layout_uninit(&s->downmix_layout);
363  av_channel_layout_from_mask(&s->downmix_layout, avctx->request_channel_layout & ~AV_CH_LAYOUT_NATIVE);
364  }
366 #endif
367 
368  if (s->downmix_layout.nb_channels) {
371  s->request_channel_layout = DCA_SPEAKER_LAYOUT_STEREO;
373  s->request_channel_layout = DCA_SPEAKER_LAYOUT_5POINT0;
375  s->request_channel_layout = DCA_SPEAKER_LAYOUT_5POINT1;
376  else
377  av_log(avctx, AV_LOG_WARNING, "Invalid downmix layout\n");
378  }
379 
380  ff_thread_once(&init_static_once, dcadec_init_static);
381 
382  return 0;
383 }
384 
385 #define OFFSET(x) offsetof(DCAContext, x)
386 #define PARAM AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM
387 
388 static const AVOption dcadec_options[] = {
389  { "core_only", "Decode core only without extensions", OFFSET(core_only), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, PARAM },
390 
391  { "channel_order", "Order in which the channels are to be exported",
392  OFFSET(output_channel_order), AV_OPT_TYPE_INT,
393  { .i64 = CHANNEL_ORDER_DEFAULT }, 0, 1, PARAM, "channel_order" },
394  { "default", "normal libavcodec channel order", 0, AV_OPT_TYPE_CONST,
395  { .i64 = CHANNEL_ORDER_DEFAULT }, .flags = PARAM, "channel_order" },
396  { "coded", "order in which the channels are coded in the bitstream",
397  0, AV_OPT_TYPE_CONST, { .i64 = CHANNEL_ORDER_CODED }, .flags = PARAM, "channel_order" },
398 
399  { "downmix", "Request a specific channel layout from the decoder", OFFSET(downmix_layout),
400  AV_OPT_TYPE_CHLAYOUT, {.str = NULL}, .flags = PARAM },
401 
402  { NULL }
403 };
404 
405 static const AVClass dcadec_class = {
406  .class_name = "DCA decoder",
407  .item_name = av_default_item_name,
408  .option = dcadec_options,
409  .version = LIBAVUTIL_VERSION_INT,
410  .category = AV_CLASS_CATEGORY_DECODER,
411 };
412 
414  .p.name = "dca",
415  CODEC_LONG_NAME("DCA (DTS Coherent Acoustics)"),
416  .p.type = AVMEDIA_TYPE_AUDIO,
417  .p.id = AV_CODEC_ID_DTS,
418  .priv_data_size = sizeof(DCAContext),
419  .init = dcadec_init,
421  .close = dcadec_close,
422  .flush = dcadec_flush,
423  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
424  .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P,
426  .p.priv_class = &dcadec_class,
427  .p.profiles = NULL_IF_CONFIG_SMALL(ff_dca_profiles),
428  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
429 };
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:82
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:397
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:1163
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:369
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:2452
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1351
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
DCA_PACKET_LBR
#define DCA_PACKET_LBR
Definition: dcadec.h:42
AVPacket::data
uint8_t * data
Definition: packet.h:374
AVOption
AVOption.
Definition: opt.h:251
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:119
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:306
av_popcount
#define av_popcount
Definition: common.h:149
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:311
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:1169
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:2359
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:123
DCA_EXSS_XLL
@ DCA_EXSS_XLL
Definition: dca.h:179
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2059
ff_dca_profiles
const AVProfile ff_dca_profiles[]
Definition: profiles.c:38
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
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
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:116
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:184
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:150
ff_dca_lbr_init_tables
av_cold void ff_dca_lbr_init_tables(void)
Definition: dca_lbr.c:134
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:85
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:298
dcadec_options
static const AVOption dcadec_options[]
Definition: dcadec.c:388
s
#define s(width, name)
Definition: cbs_vp9.c:256
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:2202
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
FF_ENABLE_DEPRECATION_WARNINGS 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:391
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:363
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
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:264
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:34
ff_dca_lbr_filter_frame
int ff_dca_lbr_filter_frame(DCALbrDecoder *s, AVFrame *frame)
Definition: dca_lbr.c:1736
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:182
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:85
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:413
OFFSET
#define OFFSET(x)
Definition: dcadec.c:385
AV_OPT_TYPE_CHLAYOUT
@ AV_OPT_TYPE_CHLAYOUT
Definition: opt.h:245
DCA_PACKET_CORE
#define DCA_PACKET_CORE
Definition: dcadec.h:39
DCADSPContext
Definition: dcadsp.h:30
AVOnce
#define AVOnce
Definition: thread.h:181
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:109
CHANNEL_ORDER_CODED
@ CHANNEL_ORDER_CODED
Definition: aac.h:290
CHANNEL_ORDER_DEFAULT
@ CHANNEL_ORDER_DEFAULT
Definition: aac.h:289
DCA_SYNCWORD_CORE_BE
#define DCA_SYNCWORD_CORE_BE
Definition: dca_syncwords.h:22
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:375
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:115
ff_dca_core_parse
int ff_dca_core_parse(DCACoreDecoder *s, const uint8_t *data, int size)
Definition: dca_core.c:1811
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:301
codec_internal.h
PARAM
#define PARAM
Definition: dcadec.c:386
AV_CODEC_ID_DTS
@ AV_CODEC_ID_DTS
Definition: codec_id.h:439
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:24
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:932
ff_dca_core_init
av_cold int ff_dca_core_init(DCACoreDecoder *s)
Definition: dca_core.c:2426
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
DCAContext
Definition: dcadec.h:53
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
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:54
AV_CH_LAYOUT_NATIVE
#define AV_CH_LAYOUT_NATIVE
Channel mask value used for AVCodecContext.request_channel_layout to indicate that the user requests ...
Definition: channel_layout.h:202
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:49
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
ff_dca_lbr_init
av_cold int ff_dca_lbr_init(DCALbrDecoder *s)
Definition: dca_lbr.c:1822
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:1972
ff_dca_xll_filter_frame
int ff_dca_xll_filter_frame(DCAXllDecoder *s, AVFrame *frame)
Definition: dca_xll.c:1324
ff_dca_lbr_flush
av_cold void ff_dca_lbr_flush(DCALbrDecoder *s)
Definition: dca_lbr.c:1798
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:1844
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:1831
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:412
dcadec_class
static const AVClass dcadec_class
Definition: dcadec.c:405
U
#define U(x)
Definition: vpx_arith.h:37
AVCodecContext
main external API structure.
Definition: avcodec.h:398
channel_layout.h
MAX_PACKET_SIZE
#define MAX_PACKET_SIZE
Definition: dcadec.c:32
DCA_PACKET_MASK
#define DCA_PACKET_MASK
Definition: dcadec.h:43
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
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:632
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:81
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:31
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
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:1473
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:378
AV_CHANNEL_LAYOUT_5POINT1
#define AV_CHANNEL_LAYOUT_5POINT1
Definition: channel_layout.h:379
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
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:1478
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:2413