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 "libavutil/mem_internal.h"
31 #include "internal.h"
32 #include "get_bits.h"
33 #include "avcodec.h"
34 #include "golomb.h"
35 #include "mathops.h"
36 #include "dsd.h"
37 
38 #define DST_MAX_CHANNELS 6
39 #define DST_MAX_ELEMENTS (2 * DST_MAX_CHANNELS)
40 
41 #define DSD_FS44(sample_rate) (sample_rate * 8LL / 44100)
42 
43 #define DST_SAMPLES_PER_FRAME(sample_rate) (588 * DSD_FS44(sample_rate))
44 
45 static const int8_t fsets_code_pred_coeff[3][3] = {
46  { -8 },
47  { -16, 8 },
48  { -9, -5, 6 },
49 };
50 
51 static const int8_t probs_code_pred_coeff[3][3] = {
52  { -8 },
53  { -16, 8 },
54  { -24, 24, -8 },
55 };
56 
57 typedef struct ArithCoder {
58  unsigned int a;
59  unsigned int c;
60 } ArithCoder;
61 
62 typedef struct Table {
63  unsigned int elements;
64  unsigned int length[DST_MAX_ELEMENTS];
66 } Table;
67 
68 typedef struct DSTContext {
69  AVClass *class;
70 
73  Table fsets, probs;
75  DECLARE_ALIGNED(16, int16_t, filter)[DST_MAX_ELEMENTS][16][256];
77 } DSTContext;
78 
80 {
81  DSTContext *s = avctx->priv_data;
82  int i;
83 
84  if (avctx->channels > DST_MAX_CHANNELS) {
85  avpriv_request_sample(avctx, "Channel count %d", avctx->channels);
86  return AVERROR_PATCHWELCOME;
87  }
88 
89  // the sample rate is only allowed to be 64,128,256 * 44100 by ISO/IEC 14496-3:2005(E)
90  // We are a bit more tolerant here, but this check is needed to bound the size and duration
91  if (avctx->sample_rate > 512 * 44100)
92  return AVERROR_INVALIDDATA;
93 
94 
95  if (DST_SAMPLES_PER_FRAME(avctx->sample_rate) & 7) {
96  return AVERROR_PATCHWELCOME;
97  }
98 
100 
101  for (i = 0; i < avctx->channels; i++)
102  memset(s->dsdctx[i].buf, 0x69, sizeof(s->dsdctx[i].buf));
103 
105 
106  return 0;
107 }
108 
109 static int read_map(GetBitContext *gb, Table *t, unsigned int map[DST_MAX_CHANNELS], int channels)
110 {
111  int ch;
112  t->elements = 1;
113  map[0] = 0;
114  if (!get_bits1(gb)) {
115  for (ch = 1; ch < channels; ch++) {
116  int bits = av_log2(t->elements) + 1;
117  map[ch] = get_bits(gb, bits);
118  if (map[ch] == t->elements) {
119  t->elements++;
120  if (t->elements >= DST_MAX_ELEMENTS)
121  return AVERROR_INVALIDDATA;
122  } else if (map[ch] > t->elements) {
123  return AVERROR_INVALIDDATA;
124  }
125  }
126  } else {
127  memset(map, 0, sizeof(*map) * DST_MAX_CHANNELS);
128  }
129  return 0;
130 }
131 
133 {
134  int v = get_ur_golomb_jpegls(gb, k, get_bits_left(gb), 0);
135  if (v && get_bits1(gb))
136  v = -v;
137  return v;
138 }
139 
140 static void read_uncoded_coeff(GetBitContext *gb, int *dst, unsigned int elements,
141  int coeff_bits, int is_signed, int offset)
142 {
143  int i;
144 
145  for (i = 0; i < elements; i++) {
146  dst[i] = (is_signed ? get_sbits(gb, coeff_bits) : get_bits(gb, coeff_bits)) + offset;
147  }
148 }
149 
150 static int read_table(GetBitContext *gb, Table *t, const int8_t code_pred_coeff[3][3],
151  int length_bits, int coeff_bits, int is_signed, int offset)
152 {
153  unsigned int i, j, k;
154  for (i = 0; i < t->elements; i++) {
155  t->length[i] = get_bits(gb, length_bits) + 1;
156  if (!get_bits1(gb)) {
157  read_uncoded_coeff(gb, t->coeff[i], t->length[i], coeff_bits, is_signed, offset);
158  } else {
159  int method = get_bits(gb, 2), lsb_size;
160  if (method == 3)
161  return AVERROR_INVALIDDATA;
162 
163  read_uncoded_coeff(gb, t->coeff[i], method + 1, coeff_bits, is_signed, offset);
164 
165  lsb_size = get_bits(gb, 3);
166  for (j = method + 1; j < t->length[i]; j++) {
167  int c, x = 0;
168  for (k = 0; k < method + 1; k++)
169  x += code_pred_coeff[method][k] * (unsigned)t->coeff[i][j - k - 1];
170  c = get_sr_golomb_dst(gb, lsb_size);
171  if (x >= 0)
172  c -= (x + 4) / 8;
173  else
174  c += (-x + 3) / 8;
175  if (!is_signed) {
176  if (c < offset || c >= offset + (1<<coeff_bits))
177  return AVERROR_INVALIDDATA;
178  }
179  t->coeff[i][j] = c;
180  }
181  }
182  }
183  return 0;
184 }
185 
186 static void ac_init(ArithCoder *ac, GetBitContext *gb)
187 {
188  ac->a = 4095;
189  ac->c = get_bits(gb, 12);
190 }
191 
192 static av_always_inline void ac_get(ArithCoder *ac, GetBitContext *gb, int p, int *e)
193 {
194  unsigned int k = (ac->a >> 8) | ((ac->a >> 7) & 1);
195  unsigned int q = k * p;
196  unsigned int a_q = ac->a - q;
197 
198  *e = ac->c < a_q;
199  if (*e) {
200  ac->a = a_q;
201  } else {
202  ac->a = q;
203  ac->c -= a_q;
204  }
205 
206  if (ac->a < 2048) {
207  int n = 11 - av_log2(ac->a);
208  ac->a <<= n;
209  ac->c = (ac->c << n) | get_bits(gb, n);
210  }
211 }
212 
214 {
215  return (ff_reverse[c & 127] >> 1) + 1;
216 }
217 
218 static void build_filter(int16_t table[DST_MAX_ELEMENTS][16][256], const Table *fsets)
219 {
220  int i, j, k, l;
221 
222  for (i = 0; i < fsets->elements; i++) {
223  int length = fsets->length[i];
224 
225  for (j = 0; j < 16; j++) {
226  int total = av_clip(length - j * 8, 0, 8);
227 
228  for (k = 0; k < 256; k++) {
229  int v = 0;
230 
231  for (l = 0; l < total; l++)
232  v += (((k >> l) & 1) * 2 - 1) * fsets->coeff[i][j * 8 + l];
233  table[i][j][k] = v;
234  }
235  }
236  }
237 }
238 
239 static int decode_frame(AVCodecContext *avctx, void *data,
240  int *got_frame_ptr, AVPacket *avpkt)
241 {
242  unsigned samples_per_frame = DST_SAMPLES_PER_FRAME(avctx->sample_rate);
243  unsigned map_ch_to_felem[DST_MAX_CHANNELS];
244  unsigned map_ch_to_pelem[DST_MAX_CHANNELS];
245  unsigned i, ch, same_map, dst_x_bit;
246  unsigned half_prob[DST_MAX_CHANNELS];
247  const int channels = avctx->channels;
248  DSTContext *s = avctx->priv_data;
249  GetBitContext *gb = &s->gb;
250  ArithCoder *ac = &s->ac;
251  AVFrame *frame = data;
252  uint8_t *dsd;
253  float *pcm;
254  int ret;
255 
256  if (avpkt->size <= 1)
257  return AVERROR_INVALIDDATA;
258 
259  frame->nb_samples = samples_per_frame / 8;
260  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
261  return ret;
262  dsd = frame->data[0];
263  pcm = (float *)frame->data[0];
264 
265  if ((ret = init_get_bits8(gb, avpkt->data, avpkt->size)) < 0)
266  return ret;
267 
268  if (!get_bits1(gb)) {
269  skip_bits1(gb);
270  if (get_bits(gb, 6))
271  return AVERROR_INVALIDDATA;
272  memcpy(frame->data[0], avpkt->data + 1, FFMIN(avpkt->size - 1, frame->nb_samples * channels));
273  goto dsd;
274  }
275 
276  /* Segmentation (10.4, 10.5, 10.6) */
277 
278  if (!get_bits1(gb)) {
279  avpriv_request_sample(avctx, "Not Same Segmentation");
280  return AVERROR_PATCHWELCOME;
281  }
282 
283  if (!get_bits1(gb)) {
284  avpriv_request_sample(avctx, "Not Same Segmentation For All Channels");
285  return AVERROR_PATCHWELCOME;
286  }
287 
288  if (!get_bits1(gb)) {
289  avpriv_request_sample(avctx, "Not End Of Channel Segmentation");
290  return AVERROR_PATCHWELCOME;
291  }
292 
293  /* Mapping (10.7, 10.8, 10.9) */
294 
295  same_map = get_bits1(gb);
296 
297  if ((ret = read_map(gb, &s->fsets, map_ch_to_felem, channels)) < 0)
298  return ret;
299 
300  if (same_map) {
301  s->probs.elements = s->fsets.elements;
302  memcpy(map_ch_to_pelem, map_ch_to_felem, sizeof(map_ch_to_felem));
303  } else {
304  avpriv_request_sample(avctx, "Not Same Mapping");
305  if ((ret = read_map(gb, &s->probs, map_ch_to_pelem, channels)) < 0)
306  return ret;
307  }
308 
309  /* Half Probability (10.10) */
310 
311  for (ch = 0; ch < channels; ch++)
312  half_prob[ch] = get_bits1(gb);
313 
314  /* Filter Coef Sets (10.12) */
315 
316  ret = read_table(gb, &s->fsets, fsets_code_pred_coeff, 7, 9, 1, 0);
317  if (ret < 0)
318  return ret;
319 
320  /* Probability Tables (10.13) */
321 
322  ret = read_table(gb, &s->probs, probs_code_pred_coeff, 6, 7, 0, 1);
323  if (ret < 0)
324  return ret;
325 
326  /* Arithmetic Coded Data (10.11) */
327 
328  if (get_bits1(gb))
329  return AVERROR_INVALIDDATA;
330  ac_init(ac, gb);
331 
332  build_filter(s->filter, &s->fsets);
333 
334  memset(s->status, 0xAA, sizeof(s->status));
335  memset(dsd, 0, frame->nb_samples * 4 * channels);
336 
337  ac_get(ac, gb, prob_dst_x_bit(s->fsets.coeff[0][0]), &dst_x_bit);
338 
339  for (i = 0; i < samples_per_frame; i++) {
340  for (ch = 0; ch < channels; ch++) {
341  const unsigned felem = map_ch_to_felem[ch];
342  int16_t (*filter)[256] = s->filter[felem];
343  uint8_t *status = s->status[ch];
344  int prob, residual, v;
345 
346 #define F(x) filter[(x)][status[(x)]]
347  const int16_t predict = F( 0) + F( 1) + F( 2) + F( 3) +
348  F( 4) + F( 5) + F( 6) + F( 7) +
349  F( 8) + F( 9) + F(10) + F(11) +
350  F(12) + F(13) + F(14) + F(15);
351 #undef F
352 
353  if (!half_prob[ch] || i >= s->fsets.length[felem]) {
354  unsigned pelem = map_ch_to_pelem[ch];
355  unsigned index = FFABS(predict) >> 3;
356  prob = s->probs.coeff[pelem][FFMIN(index, s->probs.length[pelem] - 1)];
357  } else {
358  prob = 128;
359  }
360 
361  ac_get(ac, gb, prob, &residual);
362  v = ((predict >> 15) ^ residual) & 1;
363  dsd[((i >> 3) * channels + ch) << 2] |= v << (7 - (i & 0x7 ));
364 
365  AV_WL64A(status + 8, (AV_RL64A(status + 8) << 1) | ((AV_RL64A(status) >> 63) & 1));
366  AV_WL64A(status, (AV_RL64A(status) << 1) | v);
367  }
368  }
369 
370 dsd:
371  for (i = 0; i < channels; i++) {
372  ff_dsd2pcm_translate(&s->dsdctx[i], frame->nb_samples, 0,
373  frame->data[0] + i * 4,
374  channels * 4, pcm + i, channels);
375  }
376 
377  *got_frame_ptr = 1;
378 
379  return avpkt->size;
380 }
381 
383  .name = "dst",
384  .long_name = NULL_IF_CONFIG_SMALL("DST (Digital Stream Transfer)"),
385  .type = AVMEDIA_TYPE_AUDIO,
386  .id = AV_CODEC_ID_DST,
387  .priv_data_size = sizeof(DSTContext),
388  .init = decode_init,
389  .decode = decode_frame,
390  .capabilities = AV_CODEC_CAP_DR1,
391  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
393  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
394 };
#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:132
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
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:62
unsigned int a
Definition: dstdec.c:58
#define DST_MAX_ELEMENTS
Definition: dstdec.c:39
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:38
int size
Definition: packet.h:364
int av_log2(unsigned v)
Definition: intmath.c:26
Table fsets
Definition: dstdec.c:73
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:47
static int read_map(GetBitContext *gb, Table *t, unsigned int map[DST_MAX_CHANNELS], int channels)
Definition: dstdec.c:109
static av_always_inline void predict(PredictorState *ps, float *coef, int output_enable)
Definition: aacdec.c:179
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:239
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:40
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1199
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:53
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:45
static void ac_init(ArithCoder *ac, GetBitContext *gb)
Definition: dstdec.c:186
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:117
uint8_t * data
Definition: packet.h:363
Table probs
Definition: dstdec.c:73
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:140
int16_t filter[DST_MAX_ELEMENTS][16][256]
Definition: dstdec.c:75
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:115
#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:141
static av_cold int decode_init(AVCodecContext *avctx)
Definition: dstdec.c:79
static const int8_t probs_code_pred_coeff[3][3]
Definition: dstdec.c:51
#define FFMIN(a, b)
Definition: common.h:96
static const ElemCat * elements[ELEMENT_COUNT]
Definition: signature.h:566
ArithCoder ac
Definition: dstdec.c:72
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:64
AVCodec ff_dst_decoder
Definition: dstdec.c:382
if(ret)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
unsigned int c
Definition: dstdec.c:59
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
int sample_rate
samples per second
Definition: avcodec.h:1191
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:213
int coeff[DST_MAX_ELEMENTS][128]
Definition: dstdec.c:65
static av_always_inline void ac_get(ArithCoder *ac, GetBitContext *gb, int p, int *e)
Definition: dstdec.c:192
main external API structure.
Definition: avcodec.h:531
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1876
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 * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:328
unsigned int elements
Definition: dstdec.c:63
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:218
uint8_t status[DST_MAX_CHANNELS][16]
Definition: dstdec.c:74
#define DST_SAMPLES_PER_FRAME(sample_rate)
Definition: dstdec.c:43
DSDContext dsdctx[DST_MAX_CHANNELS]
Definition: dstdec.c:76
void * priv_data
Definition: avcodec.h:558
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:150
int channels
number of audio channels
Definition: avcodec.h:1192
#define F(x)
static const double coeff[2][5]
Definition: vf_owdenoise.c:73
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:940
#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:380
#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:71
#define AV_WL64A(p, v)
Definition: intreadwrite.h:557