FFmpeg
dpcm.c
Go to the documentation of this file.
1 /*
2  * Assorted DPCM codecs
3  * Copyright (c) 2003 The FFmpeg project
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  * Assorted DPCM (differential pulse code modulation) audio codecs
25  * by Mike Melanson (melanson@pcisys.net)
26  * Xan DPCM decoder by Mario Brito (mbrito@student.dei.uc.pt)
27  * for more information on the specific data formats, visit:
28  * http://www.pcisys.net/~melanson/codecs/simpleaudio.html
29  * SOL DPCMs implemented by Konstantin Shishkov
30  *
31  * Note about using the Xan DPCM decoder: Xan DPCM is used in AVI files
32  * found in the Wing Commander IV computer game. These AVI files contain
33  * WAVEFORMAT headers which report the audio format as 0x01: raw PCM.
34  * Clearly incorrect. To detect Xan DPCM, you will probably have to
35  * special-case your AVI demuxer to use Xan DPCM if the file uses 'Xxan'
36  * (Xan video) for its video codec. Alternately, such AVI files also contain
37  * the fourcc 'Axan' in the 'auds' chunk of the AVI header.
38  */
39 
40 #include "libavutil/intreadwrite.h"
41 #include "avcodec.h"
42 #include "bytestream.h"
43 #include "internal.h"
44 #include "mathops.h"
45 
46 typedef struct DPCMContext {
47  int16_t array[256];
48  int sample[2]; ///< previous sample (for SOL_DPCM)
49  const int8_t *sol_table; ///< delta table for SOL_DPCM
50 } DPCMContext;
51 
52 static const int32_t derf_steps[96] = {
53  0, 1, 2, 3, 4, 5, 6, 7,
54  8, 9, 10, 11, 12, 13, 14, 16,
55  17, 19, 21, 23, 25, 28, 31, 34,
56  37, 41, 45, 50, 55, 60, 66, 73,
57  80, 88, 97, 107, 118, 130, 143, 157,
58  173, 190, 209, 230, 253, 279, 307, 337,
59  371, 408, 449, 494, 544, 598, 658, 724,
60  796, 876, 963, 1060, 1166, 1282, 1411, 1552,
61  1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327,
62  3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132,
63  7845, 8630, 9493, 10442, 11487, 12635, 13899, 15289,
64  16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767,
65 };
66 
67 static const int16_t interplay_delta_table[] = {
68  0, 1, 2, 3, 4, 5, 6, 7,
69  8, 9, 10, 11, 12, 13, 14, 15,
70  16, 17, 18, 19, 20, 21, 22, 23,
71  24, 25, 26, 27, 28, 29, 30, 31,
72  32, 33, 34, 35, 36, 37, 38, 39,
73  40, 41, 42, 43, 47, 51, 56, 61,
74  66, 72, 79, 86, 94, 102, 112, 122,
75  133, 145, 158, 173, 189, 206, 225, 245,
76  267, 292, 318, 348, 379, 414, 452, 493,
77  538, 587, 640, 699, 763, 832, 908, 991,
78  1081, 1180, 1288, 1405, 1534, 1673, 1826, 1993,
79  2175, 2373, 2590, 2826, 3084, 3365, 3672, 4008,
80  4373, 4772, 5208, 5683, 6202, 6767, 7385, 8059,
81  8794, 9597, 10472, 11428, 12471, 13609, 14851, 16206,
82  17685, 19298, 21060, 22981, 25078, 27367, 29864, 32589,
83  -29973, -26728, -23186, -19322, -15105, -10503, -5481, -1,
84  1, 1, 5481, 10503, 15105, 19322, 23186, 26728,
85  29973, -32589, -29864, -27367, -25078, -22981, -21060, -19298,
86  -17685, -16206, -14851, -13609, -12471, -11428, -10472, -9597,
87  -8794, -8059, -7385, -6767, -6202, -5683, -5208, -4772,
88  -4373, -4008, -3672, -3365, -3084, -2826, -2590, -2373,
89  -2175, -1993, -1826, -1673, -1534, -1405, -1288, -1180,
90  -1081, -991, -908, -832, -763, -699, -640, -587,
91  -538, -493, -452, -414, -379, -348, -318, -292,
92  -267, -245, -225, -206, -189, -173, -158, -145,
93  -133, -122, -112, -102, -94, -86, -79, -72,
94  -66, -61, -56, -51, -47, -43, -42, -41,
95  -40, -39, -38, -37, -36, -35, -34, -33,
96  -32, -31, -30, -29, -28, -27, -26, -25,
97  -24, -23, -22, -21, -20, -19, -18, -17,
98  -16, -15, -14, -13, -12, -11, -10, -9,
99  -8, -7, -6, -5, -4, -3, -2, -1
100 
101 };
102 
103 static const int8_t sol_table_old[16] = {
104  0x0, 0x1, 0x2, 0x3, 0x6, 0xA, 0xF, 0x15,
105  -0x15, -0xF, -0xA, -0x6, -0x3, -0x2, -0x1, 0x0
106 };
107 
108 static const int8_t sol_table_new[16] = {
109  0x0, 0x1, 0x2, 0x3, 0x6, 0xA, 0xF, 0x15,
110  0x0, -0x1, -0x2, -0x3, -0x6, -0xA, -0xF, -0x15
111 };
112 
113 static const int16_t sol_table_16[128] = {
114  0x000, 0x008, 0x010, 0x020, 0x030, 0x040, 0x050, 0x060, 0x070, 0x080,
115  0x090, 0x0A0, 0x0B0, 0x0C0, 0x0D0, 0x0E0, 0x0F0, 0x100, 0x110, 0x120,
116  0x130, 0x140, 0x150, 0x160, 0x170, 0x180, 0x190, 0x1A0, 0x1B0, 0x1C0,
117  0x1D0, 0x1E0, 0x1F0, 0x200, 0x208, 0x210, 0x218, 0x220, 0x228, 0x230,
118  0x238, 0x240, 0x248, 0x250, 0x258, 0x260, 0x268, 0x270, 0x278, 0x280,
119  0x288, 0x290, 0x298, 0x2A0, 0x2A8, 0x2B0, 0x2B8, 0x2C0, 0x2C8, 0x2D0,
120  0x2D8, 0x2E0, 0x2E8, 0x2F0, 0x2F8, 0x300, 0x308, 0x310, 0x318, 0x320,
121  0x328, 0x330, 0x338, 0x340, 0x348, 0x350, 0x358, 0x360, 0x368, 0x370,
122  0x378, 0x380, 0x388, 0x390, 0x398, 0x3A0, 0x3A8, 0x3B0, 0x3B8, 0x3C0,
123  0x3C8, 0x3D0, 0x3D8, 0x3E0, 0x3E8, 0x3F0, 0x3F8, 0x400, 0x440, 0x480,
124  0x4C0, 0x500, 0x540, 0x580, 0x5C0, 0x600, 0x640, 0x680, 0x6C0, 0x700,
125  0x740, 0x780, 0x7C0, 0x800, 0x900, 0xA00, 0xB00, 0xC00, 0xD00, 0xE00,
126  0xF00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x3000, 0x4000
127 };
128 
129 
131 {
132  DPCMContext *s = avctx->priv_data;
133  int i;
134 
135  if (avctx->channels < 1 || avctx->channels > 2) {
136  av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
137  return AVERROR(EINVAL);
138  }
139 
140  s->sample[0] = s->sample[1] = 0;
141 
142  switch(avctx->codec->id) {
143 
145  /* initialize square table */
146  for (i = 0; i < 128; i++) {
147  int16_t square = i * i;
148  s->array[i ] = square;
149  s->array[i + 128] = -square;
150  }
151  break;
152 
154  switch(avctx->codec_tag){
155  case 1:
157  s->sample[0] = s->sample[1] = 0x80;
158  break;
159  case 2:
161  s->sample[0] = s->sample[1] = 0x80;
162  break;
163  case 3:
164  break;
165  default:
166  av_log(avctx, AV_LOG_ERROR, "Unknown SOL subcodec\n");
167  return -1;
168  }
169  break;
170 
172  for (i = -128; i < 128; i++) {
173  int16_t square = i * i * 2;
174  s->array[i+128] = i < 0 ? -square: square;
175  }
176  break;
177 
179  int delta = 0;
180  int code = 64;
181  int step = 45;
182 
183  s->array[0] = 0;
184  for (i = 0; i < 127; i++) {
185  delta += (code >> 5);
186  code += step;
187  step += 2;
188 
189  s->array[i*2 + 1] = delta;
190  s->array[i*2 + 2] = -delta;
191  }
192  s->array[255] = delta + (code >> 5);
193  }
194  break;
195 
196  default:
197  break;
198  }
199 
200  if (avctx->codec->id == AV_CODEC_ID_SOL_DPCM && avctx->codec_tag != 3)
201  avctx->sample_fmt = AV_SAMPLE_FMT_U8;
202  else
203  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
204 
205  return 0;
206 }
207 
208 
209 static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
210  int *got_frame_ptr, AVPacket *avpkt)
211 {
212  int buf_size = avpkt->size;
213  DPCMContext *s = avctx->priv_data;
214  AVFrame *frame = data;
215  int out = 0, ret;
216  int predictor[2];
217  int ch = 0;
218  int stereo = avctx->channels - 1;
219  int16_t *output_samples, *samples_end;
220  GetByteContext gb;
221 
222  if (stereo && (buf_size & 1))
223  buf_size--;
224  bytestream2_init(&gb, avpkt->data, buf_size);
225 
226  /* calculate output size */
227  switch(avctx->codec->id) {
229  out = buf_size - 8;
230  break;
232  out = buf_size - 6 - avctx->channels;
233  break;
235  out = buf_size - 2 * avctx->channels;
236  break;
238  if (avctx->codec_tag != 3)
239  out = buf_size * 2;
240  else
241  out = buf_size;
242  break;
246  out = buf_size;
247  break;
248  }
249  if (out <= 0) {
250  av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
251  return AVERROR(EINVAL);
252  }
253  if (out % avctx->channels) {
254  av_log(avctx, AV_LOG_WARNING, "channels have differing number of samples\n");
255  }
256 
257  /* get output buffer */
258  frame->nb_samples = (out + avctx->channels - 1) / avctx->channels;
259  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
260  return ret;
261  output_samples = (int16_t *)frame->data[0];
262  samples_end = output_samples + out;
263 
264  switch(avctx->codec->id) {
265 
267  bytestream2_skipu(&gb, 6);
268 
269  if (stereo) {
270  predictor[1] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);
271  predictor[0] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);
272  } else {
273  predictor[0] = sign_extend(bytestream2_get_le16u(&gb), 16);
274  }
275 
276  /* decode the samples */
277  while (output_samples < samples_end) {
278  predictor[ch] += s->array[bytestream2_get_byteu(&gb)];
279  predictor[ch] = av_clip_int16(predictor[ch]);
280  *output_samples++ = predictor[ch];
281 
282  /* toggle channel */
283  ch ^= stereo;
284  }
285  break;
286 
288  bytestream2_skipu(&gb, 6); /* skip over the stream mask and stream length */
289 
290  for (ch = 0; ch < avctx->channels; ch++) {
291  predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);
292  *output_samples++ = predictor[ch];
293  }
294 
295  ch = 0;
296  while (output_samples < samples_end) {
297  predictor[ch] += interplay_delta_table[bytestream2_get_byteu(&gb)];
298  predictor[ch] = av_clip_int16(predictor[ch]);
299  *output_samples++ = predictor[ch];
300 
301  /* toggle channel */
302  ch ^= stereo;
303  }
304  break;
305 
307  {
308  int shift[2] = { 4, 4 };
309 
310  for (ch = 0; ch < avctx->channels; ch++)
311  predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);
312 
313  ch = 0;
314  while (output_samples < samples_end) {
315  int diff = bytestream2_get_byteu(&gb);
316  int n = diff & 3;
317 
318  if (n == 3)
319  shift[ch]++;
320  else
321  shift[ch] -= (2 * n);
322  diff = sign_extend((diff &~ 3) << 8, 16);
323 
324  /* saturate the shifter to 0..31 */
325  shift[ch] = av_clip_uintp2(shift[ch], 5);
326 
327  diff >>= shift[ch];
328  predictor[ch] += diff;
329 
330  predictor[ch] = av_clip_int16(predictor[ch]);
331  *output_samples++ = predictor[ch];
332 
333  /* toggle channel */
334  ch ^= stereo;
335  }
336  break;
337  }
339  if (avctx->codec_tag != 3) {
340  uint8_t *output_samples_u8 = frame->data[0],
341  *samples_end_u8 = output_samples_u8 + out;
342  while (output_samples_u8 < samples_end_u8) {
343  int n = bytestream2_get_byteu(&gb);
344 
345  s->sample[0] += s->sol_table[n >> 4];
346  s->sample[0] = av_clip_uint8(s->sample[0]);
347  *output_samples_u8++ = s->sample[0];
348 
349  s->sample[stereo] += s->sol_table[n & 0x0F];
350  s->sample[stereo] = av_clip_uint8(s->sample[stereo]);
351  *output_samples_u8++ = s->sample[stereo];
352  }
353  } else {
354  while (output_samples < samples_end) {
355  int n = bytestream2_get_byteu(&gb);
356  if (n & 0x80) s->sample[ch] -= sol_table_16[n & 0x7F];
357  else s->sample[ch] += sol_table_16[n & 0x7F];
358  s->sample[ch] = av_clip_int16(s->sample[ch]);
359  *output_samples++ = s->sample[ch];
360  /* toggle channel */
361  ch ^= stereo;
362  }
363  }
364  break;
365 
367  while (output_samples < samples_end) {
368  int8_t n = bytestream2_get_byteu(&gb);
369 
370  if (!(n & 1))
371  s->sample[ch] = 0;
372  s->sample[ch] += s->array[n + 128];
373  s->sample[ch] = av_clip_int16(s->sample[ch]);
374  *output_samples++ = s->sample[ch];
375  ch ^= stereo;
376  }
377  break;
378 
380  int idx = 0;
381 
382  while (output_samples < samples_end) {
383  uint8_t n = bytestream2_get_byteu(&gb);
384 
385  *output_samples++ = s->sample[idx] += (unsigned)s->array[n];
386  idx ^= 1;
387  }
388  }
389  break;
390 
391  case AV_CODEC_ID_DERF_DPCM: {
392  int idx = 0;
393 
394  while (output_samples < samples_end) {
395  uint8_t n = bytestream2_get_byteu(&gb);
396  int index = FFMIN(n & 0x7f, 95);
397 
398  s->sample[idx] += (n & 0x80 ? -1: 1) * derf_steps[index];
399  s->sample[idx] = av_clip_int16(s->sample[idx]);
400  *output_samples++ = s->sample[idx];
401  idx ^= stereo;
402  }
403  }
404  break;
405  }
406 
407  *got_frame_ptr = 1;
408 
409  return avpkt->size;
410 }
411 
412 #define DPCM_DECODER(id_, name_, long_name_) \
413 AVCodec ff_ ## name_ ## _decoder = { \
414  .name = #name_, \
415  .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
416  .type = AVMEDIA_TYPE_AUDIO, \
417  .id = id_, \
418  .priv_data_size = sizeof(DPCMContext), \
419  .init = dpcm_decode_init, \
420  .decode = dpcm_decode_frame, \
421  .capabilities = AV_CODEC_CAP_DR1, \
422 }
423 
424 DPCM_DECODER(AV_CODEC_ID_DERF_DPCM, derf_dpcm, "DPCM Xilam DERF");
425 DPCM_DECODER(AV_CODEC_ID_GREMLIN_DPCM, gremlin_dpcm, "DPCM Gremlin");
426 DPCM_DECODER(AV_CODEC_ID_INTERPLAY_DPCM, interplay_dpcm, "DPCM Interplay");
427 DPCM_DECODER(AV_CODEC_ID_ROQ_DPCM, roq_dpcm, "DPCM id RoQ");
428 DPCM_DECODER(AV_CODEC_ID_SDX2_DPCM, sdx2_dpcm, "DPCM Squareroot-Delta-Exact");
429 DPCM_DECODER(AV_CODEC_ID_SOL_DPCM, sol_dpcm, "DPCM Sol");
430 DPCM_DECODER(AV_CODEC_ID_XAN_DPCM, xan_dpcm, "DPCM Xan");
const struct AVCodec * codec
Definition: avcodec.h:540
static int shift(int a, int b)
Definition: sonic.c:82
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static const int8_t sol_table_old[16]
Definition: dpcm.c:103
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
int size
Definition: packet.h:364
const int8_t * sol_table
delta table for SOL_DPCM
Definition: dpcm.c:49
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1199
uint8_t
#define av_cold
Definition: attributes.h:88
AV_SAMPLE_FMT_U8
float delta
static const int16_t interplay_delta_table[]
Definition: dpcm.c:67
uint8_t * data
Definition: packet.h:363
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
Definition: bytestream.h:174
#define av_log(a,...)
enum AVCodecID id
Definition: codec.h:204
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
static const int8_t sol_table_new[16]
Definition: dpcm.c:108
static int dpcm_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: dpcm.c:209
static int square(int x)
Definition: roqvideoenc.c:113
#define FFMIN(a, b)
Definition: common.h:96
int16_t array[256]
Definition: dpcm.c:47
static const int32_t derf_steps[96]
Definition: dpcm.c:52
int32_t
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
#define s(width, name)
Definition: cbs_vp9.c:257
if(ret)
Libavcodec external API header.
static const int16_t sol_table_16[128]
Definition: dpcm.c:113
main external API structure.
Definition: avcodec.h:531
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> (&#39;D&#39;<<24) + (&#39;C&#39;<<16) + (&#39;B&#39;<<8) + &#39;A&#39;).
Definition: avcodec.h:556
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1879
int index
Definition: gxfenc.c:89
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:130
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 it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:328
#define DPCM_DECODER(id_, name_, long_name_)
Definition: dpcm.c:412
common internal api header.
signed 16 bits
Definition: samplefmt.h:61
static av_cold int dpcm_decode_init(AVCodecContext *avctx)
Definition: dpcm.c:130
void * priv_data
Definition: avcodec.h:558
static av_always_inline int diff(const uint32_t a, const uint32_t b)
int channels
number of audio channels
Definition: avcodec.h:1192
FILE * out
Definition: movenc.c:54
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
This structure stores compressed data.
Definition: packet.h:340
int sample[2]
previous sample (for SOL_DPCM)
Definition: dpcm.c:48
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:380
int i
Definition: input.c:407
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step