FFmpeg: libavcodec/dpcm.c Source File

FFmpeg

[フレーム]

libavcodec

dpcm.c

Go to the documentation of this file.

1 /*

2 * Assorted DPCM codecs

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 */

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 */

40 #include "libavutil/intreadwrite.h"

41 #include "avcodec.h"

42 #include "bytestream.h"

43 #include "internal.h"

44 #include "mathops.h"

46 typedef struct DPCMContext {

47 int16_t square_array[256];

48 int sample[2]; ///< previous sample (for SOL_DPCM)

49 const int8_t *sol_table; ///< delta table for SOL_DPCM

50 } DPCMContext;

52 static const int16_t interplay_delta_table[] = {

53 0, 1, 2, 3, 4, 5, 6, 7,

54 8, 9, 10, 11, 12, 13, 14, 15,

55 16, 17, 18, 19, 20, 21, 22, 23,

56 24, 25, 26, 27, 28, 29, 30, 31,

57 32, 33, 34, 35, 36, 37, 38, 39,

58 40, 41, 42, 43, 47, 51, 56, 61,

59 66, 72, 79, 86, 94, 102, 112, 122,

60 133, 145, 158, 173, 189, 206, 225, 245,

61 267, 292, 318, 348, 379, 414, 452, 493,

62 538, 587, 640, 699, 763, 832, 908, 991,

63 1081, 1180, 1288, 1405, 1534, 1673, 1826, 1993,

64 2175, 2373, 2590, 2826, 3084, 3365, 3672, 4008,

65 4373, 4772, 5208, 5683, 6202, 6767, 7385, 8059,

66 8794, 9597, 10472, 11428, 12471, 13609, 14851, 16206,

67 17685, 19298, 21060, 22981, 25078, 27367, 29864, 32589,

68 -29973, -26728, -23186, -19322, -15105, -10503, -5481, -1,

69 1, 1, 5481, 10503, 15105, 19322, 23186, 26728,

70 29973, -32589, -29864, -27367, -25078, -22981, -21060, -19298,

71 -17685, -16206, -14851, -13609, -12471, -11428, -10472, -9597,

72 -8794, -8059, -7385, -6767, -6202, -5683, -5208, -4772,

73 -4373, -4008, -3672, -3365, -3084, -2826, -2590, -2373,

74 -2175, -1993, -1826, -1673, -1534, -1405, -1288, -1180,

75 -1081, -991, -908, -832, -763, -699, -640, -587,

76 -538, -493, -452, -414, -379, -348, -318, -292,

77 -267, -245, -225, -206, -189, -173, -158, -145,

78 -133, -122, -112, -102, -94, -86, -79, -72,

79 -66, -61, -56, -51, -47, -43, -42, -41,

80 -40, -39, -38, -37, -36, -35, -34, -33,

81 -32, -31, -30, -29, -28, -27, -26, -25,

82 -24, -23, -22, -21, -20, -19, -18, -17,

83 -16, -15, -14, -13, -12, -11, -10, -9,

84 -8, -7, -6, -5, -4, -3, -2, -1

86 };

88 static const int8_t sol_table_old[16] = {

89 0x0, 0x1, 0x2, 0x3, 0x6, 0xA, 0xF, 0x15,

90 -0x15, -0xF, -0xA, -0x6, -0x3, -0x2, -0x1, 0x0

91 };

93 static const int8_t sol_table_new[16] = {

94 0x0, 0x1, 0x2, 0x3, 0x6, 0xA, 0xF, 0x15,

95 0x0, -0x1, -0x2, -0x3, -0x6, -0xA, -0xF, -0x15

96 };

98 static const int16_t sol_table_16[128] = {

99 0x000, 0x008, 0x010, 0x020, 0x030, 0x040, 0x050, 0x060, 0x070, 0x080,

100 0x090, 0x0A0, 0x0B0, 0x0C0, 0x0D0, 0x0E0, 0x0F0, 0x100, 0x110, 0x120,

101 0x130, 0x140, 0x150, 0x160, 0x170, 0x180, 0x190, 0x1A0, 0x1B0, 0x1C0,

102 0x1D0, 0x1E0, 0x1F0, 0x200, 0x208, 0x210, 0x218, 0x220, 0x228, 0x230,

103 0x238, 0x240, 0x248, 0x250, 0x258, 0x260, 0x268, 0x270, 0x278, 0x280,

104 0x288, 0x290, 0x298, 0x2A0, 0x2A8, 0x2B0, 0x2B8, 0x2C0, 0x2C8, 0x2D0,

105 0x2D8, 0x2E0, 0x2E8, 0x2F0, 0x2F8, 0x300, 0x308, 0x310, 0x318, 0x320,

106 0x328, 0x330, 0x338, 0x340, 0x348, 0x350, 0x358, 0x360, 0x368, 0x370,

107 0x378, 0x380, 0x388, 0x390, 0x398, 0x3A0, 0x3A8, 0x3B0, 0x3B8, 0x3C0,

108 0x3C8, 0x3D0, 0x3D8, 0x3E0, 0x3E8, 0x3F0, 0x3F8, 0x400, 0x440, 0x480,

109 0x4C0, 0x500, 0x540, 0x580, 0x5C0, 0x600, 0x640, 0x680, 0x6C0, 0x700,

110 0x740, 0x780, 0x7C0, 0x800, 0x900, 0xA00, 0xB00, 0xC00, 0xD00, 0xE00,

111 0xF00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x3000, 0x4000

112 };

113

114

115 static av_cold int dpcm_decode_init(AVCodecContext *avctx)

116 {

117 DPCMContext *s = avctx->priv_data;

118 int i;

119

120 if (avctx->channels < 1 || avctx->channels > 2) {

121 av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");

122 return AVERROR(EINVAL);

123 }

124

125 s->sample[0] = s->sample[1] = 0;

126

127 switch(avctx->codec->id) {

128

129 case AV_CODEC_ID_ROQ_DPCM:

130 /* initialize square table */

131 for (i = 0; i < 128; i++) {

132 int16_t square = i * i;

133 s->square_array[i ] = square;

134 s->square_array[i + 128] = -square;

135 }

136 break;

137

138 case AV_CODEC_ID_SOL_DPCM:

139 switch(avctx->codec_tag){

140 case 1:

141 s->sol_table = sol_table_old;

142 s->sample[0] = s->sample[1] = 0x80;

143 break;

144 case 2:

145 s->sol_table = sol_table_new;

146 s->sample[0] = s->sample[1] = 0x80;

147 break;

148 case 3:

149 break;

150 default:

151 av_log(avctx, AV_LOG_ERROR, "Unknown SOL subcodec\n");

152 return -1;

153 }

154 break;

155

156 case AV_CODEC_ID_SDX2_DPCM:

157 for (i = -128; i < 128; i++) {

158 int16_t square = i * i * 2;

159 s->square_array[i+128] = i < 0 ? -square: square;

160 }

161 break;

162

163 default:

164 break;

165 }

166

167 if (avctx->codec->id == AV_CODEC_ID_SOL_DPCM && avctx->codec_tag != 3)

168 avctx->sample_fmt = AV_SAMPLE_FMT_U8;

169 else

170 avctx->sample_fmt = AV_SAMPLE_FMT_S16;

171

172 return 0;

173 }

174

175

176 static int dpcm_decode_frame(AVCodecContext *avctx, void *data,

177 int *got_frame_ptr, AVPacket *avpkt)

178 {

179 int buf_size = avpkt->size;

180 DPCMContext *s = avctx->priv_data;

181 AVFrame *frame = data;

182 int out = 0, ret;

183 int predictor[2];

184 int ch = 0;

185 int stereo = avctx->channels - 1;

186 int16_t *output_samples, *samples_end;

187 GetByteContext gb;

188

189 if (stereo && (buf_size & 1))

190 buf_size--;

191 bytestream2_init(&gb, avpkt->data, buf_size);

192

193 /* calculate output size */

194 switch(avctx->codec->id) {

195 case AV_CODEC_ID_ROQ_DPCM:

196 out = buf_size - 8;

197 break;

198 case AV_CODEC_ID_INTERPLAY_DPCM:

199 out = buf_size - 6 - avctx->channels;

200 break;

201 case AV_CODEC_ID_XAN_DPCM:

202 out = buf_size - 2 * avctx->channels;

203 break;

204 case AV_CODEC_ID_SOL_DPCM:

205 if (avctx->codec_tag != 3)

206 out = buf_size * 2;

207 else

208 out = buf_size;

209 break;

210 case AV_CODEC_ID_SDX2_DPCM:

211 out = buf_size;

212 break;

213 }

214 if (out <= 0) {

215 av_log(avctx, AV_LOG_ERROR, "packet is too small\n");

216 return AVERROR(EINVAL);

217 }

218 if (out % avctx->channels) {

219 av_log(avctx, AV_LOG_WARNING, "channels have differing number of samples\n");

220 }

221

222 /* get output buffer */

223 frame->nb_samples = (out + avctx->channels - 1) / avctx->channels;

224 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)

225 return ret;

226 output_samples = (int16_t *)frame->data[0];

227 samples_end = output_samples + out;

228

229 switch(avctx->codec->id) {

230

231 case AV_CODEC_ID_ROQ_DPCM:

232 bytestream2_skipu(&gb, 6);

233

234 if (stereo) {

235 predictor[1] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);

236 predictor[0] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);

237 } else {

238 predictor[0] = sign_extend(bytestream2_get_le16u(&gb), 16);

239 }

240

241 /* decode the samples */

242 while (output_samples < samples_end) {

243 predictor[ch] += s->square_array[bytestream2_get_byteu(&gb)];

244 predictor[ch] = av_clip_int16(predictor[ch]);

245 *output_samples++ = predictor[ch];

246

247 /* toggle channel */

248 ch ^= stereo;

249 }

250 break;

251

252 case AV_CODEC_ID_INTERPLAY_DPCM:

253 bytestream2_skipu(&gb, 6); /* skip over the stream mask and stream length */

254

255 for (ch = 0; ch < avctx->channels; ch++) {

256 predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);

257 *output_samples++ = predictor[ch];

258 }

259

260 ch = 0;

261 while (output_samples < samples_end) {

262 predictor[ch] += interplay_delta_table[bytestream2_get_byteu(&gb)];

263 predictor[ch] = av_clip_int16(predictor[ch]);

264 *output_samples++ = predictor[ch];

265

266 /* toggle channel */

267 ch ^= stereo;

268 }

269 break;

270

271 case AV_CODEC_ID_XAN_DPCM:

272 {

273 int shift[2] = { 4, 4 };

274

275 for (ch = 0; ch < avctx->channels; ch++)

276 predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);

277

278 ch = 0;

279 while (output_samples < samples_end) {

280 int diff = bytestream2_get_byteu(&gb);

281 int n = diff & 3;

282

283 if (n == 3)

284 shift[ch]++;

285 else

286 shift[ch] -= (2 * n);

287 diff = sign_extend((diff &~ 3) << 8, 16);

288

289 /* saturate the shifter to a lower limit of 0 */

290 if (shift[ch] < 0)

291 shift[ch] = 0;

292

293 diff >>= shift[ch];

294 predictor[ch] += diff;

295

296 predictor[ch] = av_clip_int16(predictor[ch]);

297 *output_samples++ = predictor[ch];

298

299 /* toggle channel */

300 ch ^= stereo;

301 }

302 break;

303 }

304 case AV_CODEC_ID_SOL_DPCM:

305 if (avctx->codec_tag != 3) {

306 uint8_t *output_samples_u8 = frame->data[0],

307 *samples_end_u8 = output_samples_u8 + out;

308 while (output_samples_u8 < samples_end_u8) {

309 int n = bytestream2_get_byteu(&gb);

310

311 s->sample[0] += s->sol_table[n >> 4];

312 s->sample[0] = av_clip_uint8(s->sample[0]);

313 *output_samples_u8++ = s->sample[0];

314

315 s->sample[stereo] += s->sol_table[n & 0x0F];

316 s->sample[stereo] = av_clip_uint8(s->sample[stereo]);

317 *output_samples_u8++ = s->sample[stereo];

318 }

319 } else {

320 while (output_samples < samples_end) {

321 int n = bytestream2_get_byteu(&gb);

322 if (n & 0x80) s->sample[ch] -= sol_table_16[n & 0x7F];

323 else s->sample[ch] += sol_table_16[n & 0x7F];

324 s->sample[ch] = av_clip_int16(s->sample[ch]);

325 *output_samples++ = s->sample[ch];

326 /* toggle channel */

327 ch ^= stereo;

328 }

329 }

330 break;

331

332 case AV_CODEC_ID_SDX2_DPCM:

333 while (output_samples < samples_end) {

334 int8_t n = bytestream2_get_byteu(&gb);

335

336 if (!(n & 1))

337 s->sample[ch] = 0;

338 s->sample[ch] += s->square_array[n + 128];

339 s->sample[ch] = av_clip_int16(s->sample[ch]);

340 *output_samples++ = s->sample[ch];

341 ch ^= stereo;

342 }

343 break;

344 }

345

346 *got_frame_ptr = 1;

347

348 return avpkt->size;

349 }

350

351 #define DPCM_DECODER(id_, name_, long_name_) \

352 AVCodec ff_ ## name_ ## _decoder = { \

353 .name = #name_, \

354 .long_name = NULL_IF_CONFIG_SMALL(long_name_), \

355 .type = AVMEDIA_TYPE_AUDIO, \

356 .id = id_, \

357 .priv_data_size = sizeof(DPCMContext), \

358 .init = dpcm_decode_init, \

359 .decode = dpcm_decode_frame, \

360 .capabilities = AV_CODEC_CAP_DR1, \

361 }

362

363 DPCM_DECODER(AV_CODEC_ID_INTERPLAY_DPCM, interplay_dpcm, "DPCM Interplay");

364 DPCM_DECODER(AV_CODEC_ID_ROQ_DPCM, roq_dpcm, "DPCM id RoQ");

365 DPCM_DECODER(AV_CODEC_ID_SDX2_DPCM, sdx2_dpcm, "DPCM Squareroot-Delta-Exact");

366 DPCM_DECODER(AV_CODEC_ID_SOL_DPCM, sol_dpcm, "DPCM Sol");

367 DPCM_DECODER(AV_CODEC_ID_XAN_DPCM, xan_dpcm, "DPCM Xan");

AVCodecContext::codec

const struct AVCodec * codec

Definition: avcodec.h:1541

GetByteContext

Definition: bytestream.h:33

const char * s

Definition: avisynth_c.h:631

shift

static int shift(int a, int b)

Definition: sonic.c:82

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:181

data

ptrdiff_t const GLvoid * data

Definition: opengl_enc.c:101

sol_table_old

static const int8_t sol_table_old[16]

Definition: dpcm.c:88

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:182

AVPacket::size

int size

Definition: avcodec.h:1468

DPCMContext::sol_table

const int8_t * sol_table

delta table for SOL_DPCM

Definition: dpcm.c:49

bytestream2_init

static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)

Definition: bytestream.h:133

AV_CODEC_ID_ROQ_DPCM

Definition: avcodec.h:411

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:2295

uint8_t

Definition: audio_convert.c:194

av_cold

#define av_cold

Definition: attributes.h:82

AV_SAMPLE_FMT_U8

Definition: audio_convert.c:194

interplay_delta_table

static const int16_t interplay_delta_table[]

Definition: dpcm.c:52

frame

static AVFrame * frame

Definition: demuxing_decoding.c:53

AVPacket::data

uint8_t * data

Definition: avcodec.h:1467

bytestream2_skipu

static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)

Definition: bytestream.h:170

AV_CODEC_ID_INTERPLAY_DPCM

Definition: avcodec.h:412

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

predictor

static void predictor(uint8_t *src, int size)

Definition: exr.c:222

AVCodec::id

enum AVCodecID id

Definition: avcodec.h:3406

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

sol_table_new

static const int8_t sol_table_new[16]

Definition: dpcm.c:93

AV_CODEC_ID_SOL_DPCM

Definition: avcodec.h:414

AVERROR

#define AVERROR(e)

Definition: error.h:43

dpcm_decode_frame

static int dpcm_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)

Definition: dpcm.c:176

square

static int square(int x)

Definition: roqvideoenc.c:113

bytestream.h

DPCMContext

Definition: dpcm.c:46

intreadwrite.h

mathops.h

int n

Definition: avisynth_c.h:547

out

FILE * out

Definition: movenc-test.c:54

avcodec.h

Libavcodec external API header.

sol_table_16

static const int16_t sol_table_16[128]

Definition: dpcm.c:98

AVCodecContext

main external API structure.

Definition: avcodec.h:1532

ff_get_buffer

int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)

Get a buffer for a frame.

Definition: utils.c:894

AVCodecContext::codec_tag

unsigned int codec_tag

fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').

Definition: avcodec.h:1564

sign_extend

static av_const int sign_extend(int val, unsigned bits)

Definition: mathops.h:138

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:192

DPCM_DECODER

#define DPCM_DECODER(id_, name_, long_name_)

Definition: dpcm.c:351

DPCMContext::square_array

int16_t square_array[256]

Definition: dpcm.c:47

internal.h

common internal api header.

if(ret< 0)

Definition: vf_mcdeint.c:282

AV_CODEC_ID_SDX2_DPCM

Definition: avcodec.h:416

AV_SAMPLE_FMT_S16

signed 16 bits

Definition: samplefmt.h:62

dpcm_decode_init

static av_cold int dpcm_decode_init(AVCodecContext *avctx)

Definition: dpcm.c:115

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:1574

diff

static av_always_inline int diff(const uint32_t a, const uint32_t b)

Definition: vf_palettegen.c:136

AVCodecContext::channels

int channels

number of audio channels

Definition: avcodec.h:2288

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1444

DPCMContext::sample

int sample[2]

previous sample (for SOL_DPCM)

Definition: dpcm.c:48

AVFrame::nb_samples

int nb_samples

number of audio samples (per channel) described by this frame

Definition: frame.h:235

AV_CODEC_ID_XAN_DPCM

Definition: avcodec.h:413

Generated on Mon Feb 15 2016 15:20:37 for FFmpeg by doxygen 1.8.6