FFmpeg
dstdec.c
Go to the documentation of this file.
1 /*
2  * Direct Stream Transfer (DST) decoder
3  * Copyright (c) 2014 Peter Ross <pross@xvid.org>
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 /**
23  * @file
24  * Direct Stream Transfer (DST) decoder
25  * ISO/IEC 14496-3 Part 3 Subpart 10: Technical description of lossless coding of oversampled audio
26  */
27 
28 #include "libavutil/avassert.h"
29 #include "libavutil/intreadwrite.h"
30 #include "internal.h"
31 #include "get_bits.h"
32 #include "avcodec.h"
33 #include "golomb.h"
34 #include "mathops.h"
35 #include "dsd.h"
36 
37 #define DST_MAX_CHANNELS 6
38 #define DST_MAX_ELEMENTS (2 * DST_MAX_CHANNELS)
39 
40 #define DSD_FS44(sample_rate) (sample_rate * 8LL / 44100)
41 
42 #define DST_SAMPLES_PER_FRAME(sample_rate) (588 * DSD_FS44(sample_rate))
43 
44 static const int8_t fsets_code_pred_coeff[3][3] = {
45  { -8 },
46  { -16, 8 },
47  { -9, -5, 6 },
48 };
49 
50 static const int8_t probs_code_pred_coeff[3][3] = {
51  { -8 },
52  { -16, 8 },
53  { -24, 24, -8 },
54 };
55 
56 typedef struct ArithCoder {
57  unsigned int a;
58  unsigned int c;
59 } ArithCoder;
60 
61 typedef struct Table {
62  unsigned int elements;
63  unsigned int length[DST_MAX_ELEMENTS];
65 } Table;
66 
67 typedef struct DSTContext {
68  AVClass *class;
69 
72  Table fsets, probs;
74  DECLARE_ALIGNED(16, int16_t, filter)[DST_MAX_ELEMENTS][16][256];
76 } DSTContext;
77 
79 {
80  DSTContext *s = avctx->priv_data;
81  int i;
82 
83  if (avctx->channels > DST_MAX_CHANNELS) {
84  avpriv_request_sample(avctx, "Channel count %d", avctx->channels);
85  return AVERROR_PATCHWELCOME;
86  }
87 
88  // the sample rate is only allowed to be 64,128,256 * 44100 by ISO/IEC 14496-3:2005(E)
89  // We are a bit more tolerant here, but this check is needed to bound the size and duration
90  if (avctx->sample_rate > 512 * 44100)
91  return AVERROR_INVALIDDATA;
92 
93 
94  if (DST_SAMPLES_PER_FRAME(avctx->sample_rate) & 7) {
95  return AVERROR_PATCHWELCOME;
96  }
97 
99 
100  for (i = 0; i < avctx->channels; i++)
101  memset(s->dsdctx[i].buf, 0x69, sizeof(s->dsdctx[i].buf));
102 
104 
105  return 0;
106 }
107 
108 static int read_map(GetBitContext *gb, Table *t, unsigned int map[DST_MAX_CHANNELS], int channels)
109 {
110  int ch;
111  t->elements = 1;
112  map[0] = 0;
113  if (!get_bits1(gb)) {
114  for (ch = 1; ch < channels; ch++) {
115  int bits = av_log2(t->elements) + 1;
116  map[ch] = get_bits(gb, bits);
117  if (map[ch] == t->elements) {
118  t->elements++;
119  if (t->elements >= DST_MAX_ELEMENTS)
120  return AVERROR_INVALIDDATA;
121  } else if (map[ch] > t->elements) {
122  return AVERROR_INVALIDDATA;
123  }
124  }
125  } else {
126  memset(map, 0, sizeof(*map) * DST_MAX_CHANNELS);
127  }
128  return 0;
129 }
130 
132 {
133  int v = get_ur_golomb_jpegls(gb, k, get_bits_left(gb), 0);
134  if (v && get_bits1(gb))
135  v = -v;
136  return v;
137 }
138 
139 static void read_uncoded_coeff(GetBitContext *gb, int *dst, unsigned int elements,
140  int coeff_bits, int is_signed, int offset)
141 {
142  int i;
143 
144  for (i = 0; i < elements; i++) {
145  dst[i] = (is_signed ? get_sbits(gb, coeff_bits) : get_bits(gb, coeff_bits)) + offset;
146  }
147 }
148 
149 static int read_table(GetBitContext *gb, Table *t, const int8_t code_pred_coeff[3][3],
150  int length_bits, int coeff_bits, int is_signed, int offset)
151 {
152  unsigned int i, j, k;
153  for (i = 0; i < t->elements; i++) {
154  t->length[i] = get_bits(gb, length_bits) + 1;
155  if (!get_bits1(gb)) {
156  read_uncoded_coeff(gb, t->coeff[i], t->length[i], coeff_bits, is_signed, offset);
157  } else {
158  int method = get_bits(gb, 2), lsb_size;
159  if (method == 3)
160  return AVERROR_INVALIDDATA;
161 
162  read_uncoded_coeff(gb, t->coeff[i], method + 1, coeff_bits, is_signed, offset);
163 
164  lsb_size = get_bits(gb, 3);
165  for (j = method + 1; j < t->length[i]; j++) {
166  int c, x = 0;
167  for (k = 0; k < method + 1; k++)
168  x += code_pred_coeff[method][k] * (unsigned)t->coeff[i][j - k - 1];
169  c = get_sr_golomb_dst(gb, lsb_size);
170  if (x >= 0)
171  c -= (x + 4) / 8;
172  else
173  c += (-x + 3) / 8;
174  if (!is_signed) {
175  if (c < offset || c >= offset + (1<<coeff_bits))
176  return AVERROR_INVALIDDATA;
177  }
178  t->coeff[i][j] = c;
179  }
180  }
181  }
182  return 0;
183 }
184 
185 static void ac_init(ArithCoder *ac, GetBitContext *gb)
186 {
187  ac->a = 4095;
188  ac->c = get_bits(gb, 12);
189 }
190 
191 static av_always_inline void ac_get(ArithCoder *ac, GetBitContext *gb, int p, int *e)
192 {
193  unsigned int k = (ac->a >> 8) | ((ac->a >> 7) & 1);
194  unsigned int q = k * p;
195  unsigned int a_q = ac->a - q;
196 
197  *e = ac->c < a_q;
198  if (*e) {
199  ac->a = a_q;
200  } else {
201  ac->a = q;
202  ac->c -= a_q;
203  }
204 
205  if (ac->a < 2048) {
206  int n = 11 - av_log2(ac->a);
207  ac->a <<= n;
208  ac->c = (ac->c << n) | get_bits(gb, n);
209  }
210 }
211 
213 {
214  return (ff_reverse[c & 127] >> 1) + 1;
215 }
216 
217 static void build_filter(int16_t table[DST_MAX_ELEMENTS][16][256], const Table *fsets)
218 {
219  int i, j, k, l;
220 
221  for (i = 0; i < fsets->elements; i++) {
222  int length = fsets->length[i];
223 
224  for (j = 0; j < 16; j++) {
225  int total = av_clip(length - j * 8, 0, 8);
226 
227  for (k = 0; k < 256; k++) {
228  int v = 0;
229 
230  for (l = 0; l < total; l++)
231  v += (((k >> l) & 1) * 2 - 1) * fsets->coeff[i][j * 8 + l];
232  table[i][j][k] = v;
233  }
234  }
235  }
236 }
237 
238 static int decode_frame(AVCodecContext *avctx, void *data,
239  int *got_frame_ptr, AVPacket *avpkt)
240 {
241  unsigned samples_per_frame = DST_SAMPLES_PER_FRAME(avctx->sample_rate);
242  unsigned map_ch_to_felem[DST_MAX_CHANNELS];
243  unsigned map_ch_to_pelem[DST_MAX_CHANNELS];
244  unsigned i, ch, same_map, dst_x_bit;
245  unsigned half_prob[DST_MAX_CHANNELS];
246  const int channels = avctx->channels;
247  DSTContext *s = avctx->priv_data;
248  GetBitContext *gb = &s->gb;
249  ArithCoder *ac = &s->ac;
250  AVFrame *frame = data;
251  uint8_t *dsd;
252  float *pcm;
253  int ret;
254 
255  if (avpkt->size <= 1)
256  return AVERROR_INVALIDDATA;
257 
258  frame->nb_samples = samples_per_frame / 8;
259  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
260  return ret;
261  dsd = frame->data[0];
262  pcm = (float *)frame->data[0];
263 
264  if ((ret = init_get_bits8(gb, avpkt->data, avpkt->size)) < 0)
265  return ret;
266 
267  if (!get_bits1(gb)) {
268  skip_bits1(gb);
269  if (get_bits(gb, 6))
270  return AVERROR_INVALIDDATA;
271  memcpy(frame->data[0], avpkt->data + 1, FFMIN(avpkt->size - 1, frame->nb_samples * channels));
272  goto dsd;
273  }
274 
275  /* Segmentation (10.4, 10.5, 10.6) */
276 
277  if (!get_bits1(gb)) {
278  avpriv_request_sample(avctx, "Not Same Segmentation");
279  return AVERROR_PATCHWELCOME;
280  }
281 
282  if (!get_bits1(gb)) {
283  avpriv_request_sample(avctx, "Not Same Segmentation For All Channels");
284  return AVERROR_PATCHWELCOME;
285  }
286 
287  if (!get_bits1(gb)) {
288  avpriv_request_sample(avctx, "Not End Of Channel Segmentation");
289  return AVERROR_PATCHWELCOME;
290  }
291 
292  /* Mapping (10.7, 10.8, 10.9) */
293 
294  same_map = get_bits1(gb);
295 
296  if ((ret = read_map(gb, &s->fsets, map_ch_to_felem, channels)) < 0)
297  return ret;
298 
299  if (same_map) {
300  s->probs.elements = s->fsets.elements;
301  memcpy(map_ch_to_pelem, map_ch_to_felem, sizeof(map_ch_to_felem));
302  } else {
303  avpriv_request_sample(avctx, "Not Same Mapping");
304  if ((ret = read_map(gb, &s->probs, map_ch_to_pelem, channels)) < 0)
305  return ret;
306  }
307 
308  /* Half Probability (10.10) */
309 
310  for (ch = 0; ch < channels; ch++)
311  half_prob[ch] = get_bits1(gb);
312 
313  /* Filter Coef Sets (10.12) */
314 
315  ret = read_table(gb, &s->fsets, fsets_code_pred_coeff, 7, 9, 1, 0);
316  if (ret < 0)
317  return ret;
318 
319  /* Probability Tables (10.13) */
320 
321  ret = read_table(gb, &s->probs, probs_code_pred_coeff, 6, 7, 0, 1);
322  if (ret < 0)
323  return ret;
324 
325  /* Arithmetic Coded Data (10.11) */
326 
327  if (get_bits1(gb))
328  return AVERROR_INVALIDDATA;
329  ac_init(ac, gb);
330 
331  build_filter(s->filter, &s->fsets);
332 
333  memset(s->status, 0xAA, sizeof(s->status));
334  memset(dsd, 0, frame->nb_samples * 4 * channels);
335 
336  ac_get(ac, gb, prob_dst_x_bit(s->fsets.coeff[0][0]), &dst_x_bit);
337 
338  for (i = 0; i < samples_per_frame; i++) {
339  for (ch = 0; ch < channels; ch++) {
340  const unsigned felem = map_ch_to_felem[ch];
341  int16_t (*filter)[256] = s->filter[felem];
342  uint8_t *status = s->status[ch];
343  int prob, residual, v;
344 
345 #define F(x) filter[(x)][status[(x)]]
346  const int16_t predict = F( 0) + F( 1) + F( 2) + F( 3) +
347  F( 4) + F( 5) + F( 6) + F( 7) +
348  F( 8) + F( 9) + F(10) + F(11) +
349  F(12) + F(13) + F(14) + F(15);
350 #undef F
351 
352  if (!half_prob[ch] || i >= s->fsets.length[felem]) {
353  unsigned pelem = map_ch_to_pelem[ch];
354  unsigned index = FFABS(predict) >> 3;
355  prob = s->probs.coeff[pelem][FFMIN(index, s->probs.length[pelem] - 1)];
356  } else {
357  prob = 128;
358  }
359 
360  ac_get(ac, gb, prob, &residual);
361  v = ((predict >> 15) ^ residual) & 1;
362  dsd[((i >> 3) * channels + ch) << 2] |= v << (7 - (i & 0x7 ));
363 
364  AV_WL64A(status + 8, (AV_RL64A(status + 8) << 1) | ((AV_RL64A(status) >> 63) & 1));
365  AV_WL64A(status, (AV_RL64A(status) << 1) | v);
366  }
367  }
368 
369 dsd:
370  for (i = 0; i < channels; i++) {
371  ff_dsd2pcm_translate(&s->dsdctx[i], frame->nb_samples, 0,
372  frame->data[0] + i * 4,
373  channels * 4, pcm + i, channels);
374  }
375 
376  *got_frame_ptr = 1;
377 
378  return avpkt->size;
379 }
380 
382  .name = "dst",
383  .long_name = NULL_IF_CONFIG_SMALL("DST (Digital Stream Transfer)"),
384  .type = AVMEDIA_TYPE_AUDIO,
385  .id = AV_CODEC_ID_DST,
386  .priv_data_size = sizeof(DSTContext),
387  .init = decode_init,
388  .decode = decode_frame,
389  .capabilities = AV_CODEC_CAP_DR1,
390  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
392 };
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static av_always_inline int get_sr_golomb_dst(GetBitContext *gb, unsigned int k)
Definition: dstdec.c:131
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
Definition: dstdec.c:61
unsigned int a
Definition: dstdec.c:57
#define DST_MAX_ELEMENTS
Definition: dstdec.c:38
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
const uint8_t ff_reverse[256]
Definition: reverse.c:23
#define avpriv_request_sample(...)
#define DST_MAX_CHANNELS
Definition: dstdec.c:37
int size
Definition: packet.h:364
int av_log2(unsigned v)
Definition: intmath.c:26
Table fsets
Definition: dstdec.c:72
static int get_ur_golomb_jpegls(GetBitContext *gb, int k, int limit, int esc_len)
read unsigned golomb rice code (jpegls).
Definition: golomb.h:430
av_cold void ff_init_dsd_data(void)
Definition: dsd.c:46
static int read_map(GetBitContext *gb, Table *t, unsigned int map[DST_MAX_CHANNELS], int channels)
Definition: dstdec.c:108
static av_always_inline void predict(PredictorState *ps, float *coef, int output_enable)
Definition: aacdec.c:174
AVCodec.
Definition: codec.h:190
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: dstdec.c:238
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1194
uint8_t
#define av_cold
Definition: attributes.h:88
void ff_dsd2pcm_translate(DSDContext *s, size_t samples, int lsbf, const uint8_t *src, ptrdiff_t src_stride, float *dst, ptrdiff_t dst_stride)
Definition: dsd.c:55
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
static const int8_t fsets_code_pred_coeff[3][3]
Definition: dstdec.c:44
static void ac_init(ArithCoder *ac, GetBitContext *gb)
Definition: dstdec.c:185
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:112
uint8_t * data
Definition: packet.h:363
Table probs
Definition: dstdec.c:72
bitstream reader API header.
channels
Definition: aptx.h:33
static const uint16_t table[]
Definition: prosumer.c:206
#define prob(name, subs,...)
Definition: cbs_vp9.c:373
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
static void read_uncoded_coeff(GetBitContext *gb, int *dst, unsigned int elements, int coeff_bits, int is_signed, int offset)
Definition: dstdec.c:139
int16_t filter[DST_MAX_ELEMENTS][16][256]
Definition: dstdec.c:74
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
#define AV_RL64A(p)
Definition: intreadwrite.h:554
simple assert() macros that are a bit more flexible than ISO C assert().
GLsizei GLsizei * length
Definition: opengl_enc.c:114
const char * name
Name of the codec implementation.
Definition: codec.h:197
uint8_t bits
Definition: vp3data.h:202
static av_cold int decode_init(AVCodecContext *avctx)
Definition: dstdec.c:78
static const int8_t probs_code_pred_coeff[3][3]
Definition: dstdec.c:50
#define FFMIN(a, b)
Definition: common.h:96
static const ElemCat * elements[ELEMENT_COUNT]
Definition: signature.h:566
ArithCoder ac
Definition: dstdec.c:71
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
Per-channel buffer.
Definition: dsd.h:42
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
unsigned int length[DST_MAX_ELEMENTS]
Definition: dstdec.c:63
AVCodec ff_dst_decoder
Definition: dstdec.c:381
if(ret)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
unsigned int c
Definition: dstdec.c:58
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
int sample_rate
samples per second
Definition: avcodec.h:1186
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
static uint8_t prob_dst_x_bit(int c)
Definition: dstdec.c:212
int coeff[DST_MAX_ELEMENTS][128]
Definition: dstdec.c:64
static av_always_inline void ac_get(ArithCoder *ac, GetBitContext *gb, int p, int *e)
Definition: dstdec.c:191
main external API structure.
Definition: avcodec.h:526
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1872
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
Describe the class of an AVClass context structure.
Definition: log.h:67
int index
Definition: gxfenc.c:89
they must not be accessed directly The fifo field contains the frames that are queued in the input for processing by the filter The status_in and status_out fields contains the queued status(EOF or error) of the link
const VDPAUPixFmtMap * map
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63)))#define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};static void cpy1(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, len);}static void cpy2(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 2 *len);}static void cpy4(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 4 *len);}static void cpy8(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;}void swri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len){int ch;int off=0;const int os=(out->planar?1:out->ch_count)*out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){int planes=in->planar?in->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){int planes=out->planar?out->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){int planes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
unsigned int elements
Definition: dstdec.c:62
uint8_t buf[FIFOSIZE]
Definition: dsd.h:43
common internal api header.
static void build_filter(int16_t table[DST_MAX_ELEMENTS][16][256], const Table *fsets)
Definition: dstdec.c:217
uint8_t status[DST_MAX_CHANNELS][16]
Definition: dstdec.c:73
#define DST_SAMPLES_PER_FRAME(sample_rate)
Definition: dstdec.c:42
DSDContext dsdctx[DST_MAX_CHANNELS]
Definition: dstdec.c:75
void * priv_data
Definition: avcodec.h:553
static int read_table(GetBitContext *gb, Table *t, const int8_t code_pred_coeff[3][3], int length_bits, int coeff_bits, int is_signed, int offset)
Definition: dstdec.c:149
int channels
number of audio channels
Definition: avcodec.h:1187
#define F(x)
static const double coeff[2][5]
Definition: vf_owdenoise.c:72
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:836
#define av_always_inline
Definition: attributes.h:45
GetBitContext * gb
Definition: mss12.h:53
exp golomb vlc stuff
This structure stores compressed data.
Definition: packet.h:340
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:374
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
int i
Definition: input.c:407
GetBitContext gb
Definition: dstdec.c:70
#define AV_WL64A(p, v)
Definition: intreadwrite.h:557