| 1 | /* |
| 2 | * Copyright (c) 2001-2003 The FFmpeg Project |
| 3 | * |
| 4 | * first version by Francois Revol (revol@free.fr) |
| 5 | * fringe ADPCM codecs (e.g., DK3, DK4, Westwood) |
| 6 | * by Mike Melanson (melanson@pcisys.net) |
| 7 | * |
| 8 | * This file is part of FFmpeg. |
| 9 | * |
| 10 | * FFmpeg is free software; you can redistribute it and/or |
| 11 | * modify it under the terms of the GNU Lesser General Public |
| 12 | * License as published by the Free Software Foundation; either |
| 13 | * version 2.1 of the License, or (at your option) any later version. |
| 14 | * |
| 15 | * FFmpeg is distributed in the hope that it will be useful, |
| 16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 18 | * Lesser General Public License for more details. |
| 19 | * |
| 20 | * You should have received a copy of the GNU Lesser General Public |
| 21 | * License along with FFmpeg; if not, write to the Free Software |
| 22 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| 23 | */ |
| 24 | |
| 25 | #include "avcodec.h" |
| 26 | #include "put_bits.h" |
| 27 | #include "bytestream.h" |
| 28 | #include "adpcm.h" |
| 29 | #include "adpcm_data.h" |
| 30 | #include "internal.h" |
| 31 | |
| 32 | /** |
| 33 | * @file |
| 34 | * ADPCM encoders |
| 35 | * See ADPCM decoder reference documents for codec information. |
| 36 | */ |
| 37 | |
| 38 | typedef struct TrellisPath { |
| 39 | int nibble; |
| 40 | int prev; |
| 41 | } TrellisPath; |
| 42 | |
| 43 | typedef struct TrellisNode { |
| 44 | uint32_t ssd; |
| 45 | int path; |
| 46 | int sample1; |
| 47 | int sample2; |
| 48 | int step; |
| 49 | } TrellisNode; |
| 50 | |
| 51 | typedef struct ADPCMEncodeContext { |
| 52 | ADPCMChannelStatus status[6]; |
| 53 | TrellisPath *paths; |
| 54 | TrellisNode *node_buf; |
| 55 | TrellisNode **nodep_buf; |
| 56 | uint8_t *trellis_hash; |
| 57 | } ADPCMEncodeContext; |
| 58 | |
| 59 | #define FREEZE_INTERVAL 128 |
| 60 | |
| 61 | static av_cold int adpcm_encode_close(AVCodecContext *avctx); |
| 62 | |
| 63 | static av_cold int adpcm_encode_init(AVCodecContext *avctx) |
| 64 | { |
| 65 | ADPCMEncodeContext *s = avctx->priv_data; |
| 66 | uint8_t *extradata; |
| 67 | int i; |
| 68 | int ret = AVERROR(ENOMEM); |
| 69 | |
| 70 | if (avctx->channels > 2) { |
| 71 | av_log(avctx, AV_LOG_ERROR, "only stereo or mono is supported\n"); |
| 72 | return AVERROR(EINVAL); |
| 73 | } |
| 74 | |
| 75 | if (avctx->trellis && (unsigned)avctx->trellis > 16U) { |
| 76 | av_log(avctx, AV_LOG_ERROR, "invalid trellis size\n"); |
| 77 | return AVERROR(EINVAL); |
| 78 | } |
| 79 | |
| 80 | if (avctx->trellis) { |
| 81 | int frontier = 1 << avctx->trellis; |
| 82 | int max_paths = frontier * FREEZE_INTERVAL; |
| 83 | FF_ALLOC_OR_GOTO(avctx, s->paths, |
| 84 | max_paths * sizeof(*s->paths), error); |
| 85 | FF_ALLOC_OR_GOTO(avctx, s->node_buf, |
| 86 | 2 * frontier * sizeof(*s->node_buf), error); |
| 87 | FF_ALLOC_OR_GOTO(avctx, s->nodep_buf, |
| 88 | 2 * frontier * sizeof(*s->nodep_buf), error); |
| 89 | FF_ALLOC_OR_GOTO(avctx, s->trellis_hash, |
| 90 | 65536 * sizeof(*s->trellis_hash), error); |
| 91 | } |
| 92 | |
| 93 | avctx->bits_per_coded_sample = av_get_bits_per_sample(avctx->codec->id); |
| 94 | |
| 95 | switch (avctx->codec->id) { |
| 96 | case AV_CODEC_ID_ADPCM_IMA_WAV: |
| 97 | /* each 16 bits sample gives one nibble |
| 98 | and we have 4 bytes per channel overhead */ |
| 99 | avctx->frame_size = (BLKSIZE - 4 * avctx->channels) * 8 / |
| 100 | (4 * avctx->channels) + 1; |
| 101 | /* seems frame_size isn't taken into account... |
| 102 | have to buffer the samples :-( */ |
| 103 | avctx->block_align = BLKSIZE; |
| 104 | avctx->bits_per_coded_sample = 4; |
| 105 | break; |
| 106 | case AV_CODEC_ID_ADPCM_IMA_QT: |
| 107 | avctx->frame_size = 64; |
| 108 | avctx->block_align = 34 * avctx->channels; |
| 109 | break; |
| 110 | case AV_CODEC_ID_ADPCM_MS: |
| 111 | /* each 16 bits sample gives one nibble |
| 112 | and we have 7 bytes per channel overhead */ |
| 113 | avctx->frame_size = (BLKSIZE - 7 * avctx->channels) * 2 / avctx->channels + 2; |
| 114 | avctx->bits_per_coded_sample = 4; |
| 115 | avctx->block_align = BLKSIZE; |
| 116 | if (!(avctx->extradata = av_malloc(32 + FF_INPUT_BUFFER_PADDING_SIZE))) |
| 117 | goto error; |
| 118 | avctx->extradata_size = 32; |
| 119 | extradata = avctx->extradata; |
| 120 | bytestream_put_le16(&extradata, avctx->frame_size); |
| 121 | bytestream_put_le16(&extradata, 7); /* wNumCoef */ |
| 122 | for (i = 0; i < 7; i++) { |
| 123 | bytestream_put_le16(&extradata, ff_adpcm_AdaptCoeff1[i] * 4); |
| 124 | bytestream_put_le16(&extradata, ff_adpcm_AdaptCoeff2[i] * 4); |
| 125 | } |
| 126 | break; |
| 127 | case AV_CODEC_ID_ADPCM_YAMAHA: |
| 128 | avctx->frame_size = BLKSIZE * 2 / avctx->channels; |
| 129 | avctx->block_align = BLKSIZE; |
| 130 | break; |
| 131 | case AV_CODEC_ID_ADPCM_SWF: |
| 132 | if (avctx->sample_rate != 11025 && |
| 133 | avctx->sample_rate != 22050 && |
| 134 | avctx->sample_rate != 44100) { |
| 135 | av_log(avctx, AV_LOG_ERROR, "Sample rate must be 11025, " |
| 136 | "22050 or 44100\n"); |
| 137 | ret = AVERROR(EINVAL); |
| 138 | goto error; |
| 139 | } |
| 140 | avctx->frame_size = 512 * (avctx->sample_rate / 11025); |
| 141 | break; |
| 142 | default: |
| 143 | ret = AVERROR(EINVAL); |
| 144 | goto error; |
| 145 | } |
| 146 | |
| 147 | return 0; |
| 148 | error: |
| 149 | adpcm_encode_close(avctx); |
| 150 | return ret; |
| 151 | } |
| 152 | |
| 153 | static av_cold int adpcm_encode_close(AVCodecContext *avctx) |
| 154 | { |
| 155 | ADPCMEncodeContext *s = avctx->priv_data; |
| 156 | av_freep(&s->paths); |
| 157 | av_freep(&s->node_buf); |
| 158 | av_freep(&s->nodep_buf); |
| 159 | av_freep(&s->trellis_hash); |
| 160 | |
| 161 | return 0; |
| 162 | } |
| 163 | |
| 164 | |
| 165 | static inline uint8_t adpcm_ima_compress_sample(ADPCMChannelStatus *c, |
| 166 | int16_t sample) |
| 167 | { |
| 168 | int delta = sample - c->prev_sample; |
| 169 | int nibble = FFMIN(7, abs(delta) * 4 / |
| 170 | ff_adpcm_step_table[c->step_index]) + (delta < 0) * 8; |
| 171 | c->prev_sample += ((ff_adpcm_step_table[c->step_index] * |
| 172 | ff_adpcm_yamaha_difflookup[nibble]) / 8); |
| 173 | c->prev_sample = av_clip_int16(c->prev_sample); |
| 174 | c->step_index = av_clip(c->step_index + ff_adpcm_index_table[nibble], 0, 88); |
| 175 | return nibble; |
| 176 | } |
| 177 | |
| 178 | static inline uint8_t adpcm_ima_qt_compress_sample(ADPCMChannelStatus *c, |
| 179 | int16_t sample) |
| 180 | { |
| 181 | int delta = sample - c->prev_sample; |
| 182 | int diff, step = ff_adpcm_step_table[c->step_index]; |
| 183 | int nibble = 8*(delta < 0); |
| 184 | |
| 185 | delta= abs(delta); |
| 186 | diff = delta + (step >> 3); |
| 187 | |
| 188 | if (delta >= step) { |
| 189 | nibble |= 4; |
| 190 | delta -= step; |
| 191 | } |
| 192 | step >>= 1; |
| 193 | if (delta >= step) { |
| 194 | nibble |= 2; |
| 195 | delta -= step; |
| 196 | } |
| 197 | step >>= 1; |
| 198 | if (delta >= step) { |
| 199 | nibble |= 1; |
| 200 | delta -= step; |
| 201 | } |
| 202 | diff -= delta; |
| 203 | |
| 204 | if (nibble & 8) |
| 205 | c->prev_sample -= diff; |
| 206 | else |
| 207 | c->prev_sample += diff; |
| 208 | |
| 209 | c->prev_sample = av_clip_int16(c->prev_sample); |
| 210 | c->step_index = av_clip(c->step_index + ff_adpcm_index_table[nibble], 0, 88); |
| 211 | |
| 212 | return nibble; |
| 213 | } |
| 214 | |
| 215 | static inline uint8_t adpcm_ms_compress_sample(ADPCMChannelStatus *c, |
| 216 | int16_t sample) |
| 217 | { |
| 218 | int predictor, nibble, bias; |
| 219 | |
| 220 | predictor = (((c->sample1) * (c->coeff1)) + |
| 221 | (( c->sample2) * (c->coeff2))) / 64; |
| 222 | |
| 223 | nibble = sample - predictor; |
| 224 | if (nibble >= 0) |
| 225 | bias = c->idelta / 2; |
| 226 | else |
| 227 | bias = -c->idelta / 2; |
| 228 | |
| 229 | nibble = (nibble + bias) / c->idelta; |
| 230 | nibble = av_clip(nibble, -8, 7) & 0x0F; |
| 231 | |
| 232 | predictor += ((nibble & 0x08) ? (nibble - 0x10) : nibble) * c->idelta; |
| 233 | |
| 234 | c->sample2 = c->sample1; |
| 235 | c->sample1 = av_clip_int16(predictor); |
| 236 | |
| 237 | c->idelta = (ff_adpcm_AdaptationTable[nibble] * c->idelta) >> 8; |
| 238 | if (c->idelta < 16) |
| 239 | c->idelta = 16; |
| 240 | |
| 241 | return nibble; |
| 242 | } |
| 243 | |
| 244 | static inline uint8_t adpcm_yamaha_compress_sample(ADPCMChannelStatus *c, |
| 245 | int16_t sample) |
| 246 | { |
| 247 | int nibble, delta; |
| 248 | |
| 249 | if (!c->step) { |
| 250 | c->predictor = 0; |
| 251 | c->step = 127; |
| 252 | } |
| 253 | |
| 254 | delta = sample - c->predictor; |
| 255 | |
| 256 | nibble = FFMIN(7, abs(delta) * 4 / c->step) + (delta < 0) * 8; |
| 257 | |
| 258 | c->predictor += ((c->step * ff_adpcm_yamaha_difflookup[nibble]) / 8); |
| 259 | c->predictor = av_clip_int16(c->predictor); |
| 260 | c->step = (c->step * ff_adpcm_yamaha_indexscale[nibble]) >> 8; |
| 261 | c->step = av_clip(c->step, 127, 24567); |
| 262 | |
| 263 | return nibble; |
| 264 | } |
| 265 | |
| 266 | static void adpcm_compress_trellis(AVCodecContext *avctx, |
| 267 | const int16_t *samples, uint8_t *dst, |
| 268 | ADPCMChannelStatus *c, int n, int stride) |
| 269 | { |
| 270 | //FIXME 6% faster if frontier is a compile-time constant |
| 271 | ADPCMEncodeContext *s = avctx->priv_data; |
| 272 | const int frontier = 1 << avctx->trellis; |
| 273 | const int version = avctx->codec->id; |
| 274 | TrellisPath *paths = s->paths, *p; |
| 275 | TrellisNode *node_buf = s->node_buf; |
| 276 | TrellisNode **nodep_buf = s->nodep_buf; |
| 277 | TrellisNode **nodes = nodep_buf; // nodes[] is always sorted by .ssd |
| 278 | TrellisNode **nodes_next = nodep_buf + frontier; |
| 279 | int pathn = 0, froze = -1, i, j, k, generation = 0; |
| 280 | uint8_t *hash = s->trellis_hash; |
| 281 | memset(hash, 0xff, 65536 * sizeof(*hash)); |
| 282 | |
| 283 | memset(nodep_buf, 0, 2 * frontier * sizeof(*nodep_buf)); |
| 284 | nodes[0] = node_buf + frontier; |
| 285 | nodes[0]->ssd = 0; |
| 286 | nodes[0]->path = 0; |
| 287 | nodes[0]->step = c->step_index; |
| 288 | nodes[0]->sample1 = c->sample1; |
| 289 | nodes[0]->sample2 = c->sample2; |
| 290 | if (version == AV_CODEC_ID_ADPCM_IMA_WAV || |
| 291 | version == AV_CODEC_ID_ADPCM_IMA_QT || |
| 292 | version == AV_CODEC_ID_ADPCM_SWF) |
| 293 | nodes[0]->sample1 = c->prev_sample; |
| 294 | if (version == AV_CODEC_ID_ADPCM_MS) |
| 295 | nodes[0]->step = c->idelta; |
| 296 | if (version == AV_CODEC_ID_ADPCM_YAMAHA) { |
| 297 | if (c->step == 0) { |
| 298 | nodes[0]->step = 127; |
| 299 | nodes[0]->sample1 = 0; |
| 300 | } else { |
| 301 | nodes[0]->step = c->step; |
| 302 | nodes[0]->sample1 = c->predictor; |
| 303 | } |
| 304 | } |
| 305 | |
| 306 | for (i = 0; i < n; i++) { |
| 307 | TrellisNode *t = node_buf + frontier*(i&1); |
| 308 | TrellisNode **u; |
| 309 | int sample = samples[i * stride]; |
| 310 | int heap_pos = 0; |
| 311 | memset(nodes_next, 0, frontier * sizeof(TrellisNode*)); |
| 312 | for (j = 0; j < frontier && nodes[j]; j++) { |
| 313 | // higher j have higher ssd already, so they're likely |
| 314 | // to yield a suboptimal next sample too |
| 315 | const int range = (j < frontier / 2) ? 1 : 0; |
| 316 | const int step = nodes[j]->step; |
| 317 | int nidx; |
| 318 | if (version == AV_CODEC_ID_ADPCM_MS) { |
| 319 | const int predictor = ((nodes[j]->sample1 * c->coeff1) + |
| 320 | (nodes[j]->sample2 * c->coeff2)) / 64; |
| 321 | const int div = (sample - predictor) / step; |
| 322 | const int nmin = av_clip(div-range, -8, 6); |
| 323 | const int nmax = av_clip(div+range, -7, 7); |
| 324 | for (nidx = nmin; nidx <= nmax; nidx++) { |
| 325 | const int nibble = nidx & 0xf; |
| 326 | int dec_sample = predictor + nidx * step; |
| 327 | #define STORE_NODE(NAME, STEP_INDEX)\ |
| 328 | int d;\ |
| 329 | uint32_t ssd;\ |
| 330 | int pos;\ |
| 331 | TrellisNode *u;\ |
| 332 | uint8_t *h;\ |
| 333 | dec_sample = av_clip_int16(dec_sample);\ |
| 334 | d = sample - dec_sample;\ |
| 335 | ssd = nodes[j]->ssd + d*(unsigned)d;\ |
| 336 | /* Check for wraparound, skip such samples completely. \ |
| 337 | * Note, changing ssd to a 64 bit variable would be \ |
| 338 | * simpler, avoiding this check, but it's slower on \ |
| 339 | * x86 32 bit at the moment. */\ |
| 340 | if (ssd < nodes[j]->ssd)\ |
| 341 | goto next_##NAME;\ |
| 342 | /* Collapse any two states with the same previous sample value. \ |
| 343 | * One could also distinguish states by step and by 2nd to last |
| 344 | * sample, but the effects of that are negligible. |
| 345 | * Since nodes in the previous generation are iterated |
| 346 | * through a heap, they're roughly ordered from better to |
| 347 | * worse, but not strictly ordered. Therefore, an earlier |
| 348 | * node with the same sample value is better in most cases |
| 349 | * (and thus the current is skipped), but not strictly |
| 350 | * in all cases. Only skipping samples where ssd >= |
| 351 | * ssd of the earlier node with the same sample gives |
| 352 | * slightly worse quality, though, for some reason. */ \ |
| 353 | h = &hash[(uint16_t) dec_sample];\ |
| 354 | if (*h == generation)\ |
| 355 | goto next_##NAME;\ |
| 356 | if (heap_pos < frontier) {\ |
| 357 | pos = heap_pos++;\ |
| 358 | } else {\ |
| 359 | /* Try to replace one of the leaf nodes with the new \ |
| 360 | * one, but try a different slot each time. */\ |
| 361 | pos = (frontier >> 1) +\ |
| 362 | (heap_pos & ((frontier >> 1) - 1));\ |
| 363 | if (ssd > nodes_next[pos]->ssd)\ |
| 364 | goto next_##NAME;\ |
| 365 | heap_pos++;\ |
| 366 | }\ |
| 367 | *h = generation;\ |
| 368 | u = nodes_next[pos];\ |
| 369 | if (!u) {\ |
| 370 | av_assert1(pathn < FREEZE_INTERVAL << avctx->trellis);\ |
| 371 | u = t++;\ |
| 372 | nodes_next[pos] = u;\ |
| 373 | u->path = pathn++;\ |
| 374 | }\ |
| 375 | u->ssd = ssd;\ |
| 376 | u->step = STEP_INDEX;\ |
| 377 | u->sample2 = nodes[j]->sample1;\ |
| 378 | u->sample1 = dec_sample;\ |
| 379 | paths[u->path].nibble = nibble;\ |
| 380 | paths[u->path].prev = nodes[j]->path;\ |
| 381 | /* Sift the newly inserted node up in the heap to \ |
| 382 | * restore the heap property. */\ |
| 383 | while (pos > 0) {\ |
| 384 | int parent = (pos - 1) >> 1;\ |
| 385 | if (nodes_next[parent]->ssd <= ssd)\ |
| 386 | break;\ |
| 387 | FFSWAP(TrellisNode*, nodes_next[parent], nodes_next[pos]);\ |
| 388 | pos = parent;\ |
| 389 | }\ |
| 390 | next_##NAME:; |
| 391 | STORE_NODE(ms, FFMAX(16, |
| 392 | (ff_adpcm_AdaptationTable[nibble] * step) >> 8)); |
| 393 | } |
| 394 | } else if (version == AV_CODEC_ID_ADPCM_IMA_WAV || |
| 395 | version == AV_CODEC_ID_ADPCM_IMA_QT || |
| 396 | version == AV_CODEC_ID_ADPCM_SWF) { |
| 397 | #define LOOP_NODES(NAME, STEP_TABLE, STEP_INDEX)\ |
| 398 | const int predictor = nodes[j]->sample1;\ |
| 399 | const int div = (sample - predictor) * 4 / STEP_TABLE;\ |
| 400 | int nmin = av_clip(div - range, -7, 6);\ |
| 401 | int nmax = av_clip(div + range, -6, 7);\ |
| 402 | if (nmin <= 0)\ |
| 403 | nmin--; /* distinguish -0 from +0 */\ |
| 404 | if (nmax < 0)\ |
| 405 | nmax--;\ |
| 406 | for (nidx = nmin; nidx <= nmax; nidx++) {\ |
| 407 | const int nibble = nidx < 0 ? 7 - nidx : nidx;\ |
| 408 | int dec_sample = predictor +\ |
| 409 | (STEP_TABLE *\ |
| 410 | ff_adpcm_yamaha_difflookup[nibble]) / 8;\ |
| 411 | STORE_NODE(NAME, STEP_INDEX);\ |
| 412 | } |
| 413 | LOOP_NODES(ima, ff_adpcm_step_table[step], |
| 414 | av_clip(step + ff_adpcm_index_table[nibble], 0, 88)); |
| 415 | } else { //AV_CODEC_ID_ADPCM_YAMAHA |
| 416 | LOOP_NODES(yamaha, step, |
| 417 | av_clip((step * ff_adpcm_yamaha_indexscale[nibble]) >> 8, |
| 418 | 127, 24567)); |
| 419 | #undef LOOP_NODES |
| 420 | #undef STORE_NODE |
| 421 | } |
| 422 | } |
| 423 | |
| 424 | u = nodes; |
| 425 | nodes = nodes_next; |
| 426 | nodes_next = u; |
| 427 | |
| 428 | generation++; |
| 429 | if (generation == 255) { |
| 430 | memset(hash, 0xff, 65536 * sizeof(*hash)); |
| 431 | generation = 0; |
| 432 | } |
| 433 | |
| 434 | // prevent overflow |
| 435 | if (nodes[0]->ssd > (1 << 28)) { |
| 436 | for (j = 1; j < frontier && nodes[j]; j++) |
| 437 | nodes[j]->ssd -= nodes[0]->ssd; |
| 438 | nodes[0]->ssd = 0; |
| 439 | } |
| 440 | |
| 441 | // merge old paths to save memory |
| 442 | if (i == froze + FREEZE_INTERVAL) { |
| 443 | p = &paths[nodes[0]->path]; |
| 444 | for (k = i; k > froze; k--) { |
| 445 | dst[k] = p->nibble; |
| 446 | p = &paths[p->prev]; |
| 447 | } |
| 448 | froze = i; |
| 449 | pathn = 0; |
| 450 | // other nodes might use paths that don't coincide with the frozen one. |
| 451 | // checking which nodes do so is too slow, so just kill them all. |
| 452 | // this also slightly improves quality, but I don't know why. |
| 453 | memset(nodes + 1, 0, (frontier - 1) * sizeof(TrellisNode*)); |
| 454 | } |
| 455 | } |
| 456 | |
| 457 | p = &paths[nodes[0]->path]; |
| 458 | for (i = n - 1; i > froze; i--) { |
| 459 | dst[i] = p->nibble; |
| 460 | p = &paths[p->prev]; |
| 461 | } |
| 462 | |
| 463 | c->predictor = nodes[0]->sample1; |
| 464 | c->sample1 = nodes[0]->sample1; |
| 465 | c->sample2 = nodes[0]->sample2; |
| 466 | c->step_index = nodes[0]->step; |
| 467 | c->step = nodes[0]->step; |
| 468 | c->idelta = nodes[0]->step; |
| 469 | } |
| 470 | |
| 471 | static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, |
| 472 | const AVFrame *frame, int *got_packet_ptr) |
| 473 | { |
| 474 | int n, i, ch, st, pkt_size, ret; |
| 475 | const int16_t *samples; |
| 476 | int16_t **samples_p; |
| 477 | uint8_t *dst; |
| 478 | ADPCMEncodeContext *c = avctx->priv_data; |
| 479 | uint8_t *buf; |
| 480 | |
| 481 | samples = (const int16_t *)frame->data[0]; |
| 482 | samples_p = (int16_t **)frame->extended_data; |
| 483 | st = avctx->channels == 2; |
| 484 | |
| 485 | if (avctx->codec_id == AV_CODEC_ID_ADPCM_SWF) |
| 486 | pkt_size = (2 + avctx->channels * (22 + 4 * (frame->nb_samples - 1)) + 7) / 8; |
| 487 | else |
| 488 | pkt_size = avctx->block_align; |
| 489 | if ((ret = ff_alloc_packet2(avctx, avpkt, pkt_size)) < 0) |
| 490 | return ret; |
| 491 | dst = avpkt->data; |
| 492 | |
| 493 | switch(avctx->codec->id) { |
| 494 | case AV_CODEC_ID_ADPCM_IMA_WAV: |
| 495 | { |
| 496 | int blocks, j; |
| 497 | |
| 498 | blocks = (frame->nb_samples - 1) / 8; |
| 499 | |
| 500 | for (ch = 0; ch < avctx->channels; ch++) { |
| 501 | ADPCMChannelStatus *status = &c->status[ch]; |
| 502 | status->prev_sample = samples_p[ch][0]; |
| 503 | /* status->step_index = 0; |
| 504 | XXX: not sure how to init the state machine */ |
| 505 | bytestream_put_le16(&dst, status->prev_sample); |
| 506 | *dst++ = status->step_index; |
| 507 | *dst++ = 0; /* unknown */ |
| 508 | } |
| 509 | |
| 510 | /* stereo: 4 bytes (8 samples) for left, 4 bytes for right */ |
| 511 | if (avctx->trellis > 0) { |
| 512 | FF_ALLOC_ARRAY_OR_GOTO(avctx, buf, avctx->channels, blocks * 8, error); |
| 513 | for (ch = 0; ch < avctx->channels; ch++) { |
| 514 | adpcm_compress_trellis(avctx, &samples_p[ch][1], |
| 515 | buf + ch * blocks * 8, &c->status[ch], |
| 516 | blocks * 8, 1); |
| 517 | } |
| 518 | for (i = 0; i < blocks; i++) { |
| 519 | for (ch = 0; ch < avctx->channels; ch++) { |
| 520 | uint8_t *buf1 = buf + ch * blocks * 8 + i * 8; |
| 521 | for (j = 0; j < 8; j += 2) |
| 522 | *dst++ = buf1[j] | (buf1[j + 1] << 4); |
| 523 | } |
| 524 | } |
| 525 | av_free(buf); |
| 526 | } else { |
| 527 | for (i = 0; i < blocks; i++) { |
| 528 | for (ch = 0; ch < avctx->channels; ch++) { |
| 529 | ADPCMChannelStatus *status = &c->status[ch]; |
| 530 | const int16_t *smp = &samples_p[ch][1 + i * 8]; |
| 531 | for (j = 0; j < 8; j += 2) { |
| 532 | uint8_t v = adpcm_ima_compress_sample(status, smp[j ]); |
| 533 | v |= adpcm_ima_compress_sample(status, smp[j + 1]) << 4; |
| 534 | *dst++ = v; |
| 535 | } |
| 536 | } |
| 537 | } |
| 538 | } |
| 539 | break; |
| 540 | } |
| 541 | case AV_CODEC_ID_ADPCM_IMA_QT: |
| 542 | { |
| 543 | PutBitContext pb; |
| 544 | init_put_bits(&pb, dst, pkt_size * 8); |
| 545 | |
| 546 | for (ch = 0; ch < avctx->channels; ch++) { |
| 547 | ADPCMChannelStatus *status = &c->status[ch]; |
| 548 | put_bits(&pb, 9, (status->prev_sample & 0xFFFF) >> 7); |
| 549 | put_bits(&pb, 7, status->step_index); |
| 550 | if (avctx->trellis > 0) { |
| 551 | uint8_t buf[64]; |
| 552 | adpcm_compress_trellis(avctx, &samples_p[ch][0], buf, status, |
| 553 | 64, 1); |
| 554 | for (i = 0; i < 64; i++) |
| 555 | put_bits(&pb, 4, buf[i ^ 1]); |
| 556 | status->prev_sample = status->predictor; |
| 557 | } else { |
| 558 | for (i = 0; i < 64; i += 2) { |
| 559 | int t1, t2; |
| 560 | t1 = adpcm_ima_qt_compress_sample(status, samples_p[ch][i ]); |
| 561 | t2 = adpcm_ima_qt_compress_sample(status, samples_p[ch][i + 1]); |
| 562 | put_bits(&pb, 4, t2); |
| 563 | put_bits(&pb, 4, t1); |
| 564 | } |
| 565 | } |
| 566 | } |
| 567 | |
| 568 | flush_put_bits(&pb); |
| 569 | break; |
| 570 | } |
| 571 | case AV_CODEC_ID_ADPCM_SWF: |
| 572 | { |
| 573 | PutBitContext pb; |
| 574 | init_put_bits(&pb, dst, pkt_size * 8); |
| 575 | |
| 576 | n = frame->nb_samples - 1; |
| 577 | |
| 578 | // store AdpcmCodeSize |
| 579 | put_bits(&pb, 2, 2); // set 4-bit flash adpcm format |
| 580 | |
| 581 | // init the encoder state |
| 582 | for (i = 0; i < avctx->channels; i++) { |
| 583 | // clip step so it fits 6 bits |
| 584 | c->status[i].step_index = av_clip(c->status[i].step_index, 0, 63); |
| 585 | put_sbits(&pb, 16, samples[i]); |
| 586 | put_bits(&pb, 6, c->status[i].step_index); |
| 587 | c->status[i].prev_sample = samples[i]; |
| 588 | } |
| 589 | |
| 590 | if (avctx->trellis > 0) { |
| 591 | FF_ALLOC_OR_GOTO(avctx, buf, 2 * n, error); |
| 592 | adpcm_compress_trellis(avctx, samples + avctx->channels, buf, |
| 593 | &c->status[0], n, avctx->channels); |
| 594 | if (avctx->channels == 2) |
| 595 | adpcm_compress_trellis(avctx, samples + avctx->channels + 1, |
| 596 | buf + n, &c->status[1], n, |
| 597 | avctx->channels); |
| 598 | for (i = 0; i < n; i++) { |
| 599 | put_bits(&pb, 4, buf[i]); |
| 600 | if (avctx->channels == 2) |
| 601 | put_bits(&pb, 4, buf[n + i]); |
| 602 | } |
| 603 | av_free(buf); |
| 604 | } else { |
| 605 | for (i = 1; i < frame->nb_samples; i++) { |
| 606 | put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[0], |
| 607 | samples[avctx->channels * i])); |
| 608 | if (avctx->channels == 2) |
| 609 | put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[1], |
| 610 | samples[2 * i + 1])); |
| 611 | } |
| 612 | } |
| 613 | flush_put_bits(&pb); |
| 614 | break; |
| 615 | } |
| 616 | case AV_CODEC_ID_ADPCM_MS: |
| 617 | for (i = 0; i < avctx->channels; i++) { |
| 618 | int predictor = 0; |
| 619 | *dst++ = predictor; |
| 620 | c->status[i].coeff1 = ff_adpcm_AdaptCoeff1[predictor]; |
| 621 | c->status[i].coeff2 = ff_adpcm_AdaptCoeff2[predictor]; |
| 622 | } |
| 623 | for (i = 0; i < avctx->channels; i++) { |
| 624 | if (c->status[i].idelta < 16) |
| 625 | c->status[i].idelta = 16; |
| 626 | bytestream_put_le16(&dst, c->status[i].idelta); |
| 627 | } |
| 628 | for (i = 0; i < avctx->channels; i++) |
| 629 | c->status[i].sample2= *samples++; |
| 630 | for (i = 0; i < avctx->channels; i++) { |
| 631 | c->status[i].sample1 = *samples++; |
| 632 | bytestream_put_le16(&dst, c->status[i].sample1); |
| 633 | } |
| 634 | for (i = 0; i < avctx->channels; i++) |
| 635 | bytestream_put_le16(&dst, c->status[i].sample2); |
| 636 | |
| 637 | if (avctx->trellis > 0) { |
| 638 | n = avctx->block_align - 7 * avctx->channels; |
| 639 | FF_ALLOC_OR_GOTO(avctx, buf, 2 * n, error); |
| 640 | if (avctx->channels == 1) { |
| 641 | adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n, |
| 642 | avctx->channels); |
| 643 | for (i = 0; i < n; i += 2) |
| 644 | *dst++ = (buf[i] << 4) | buf[i + 1]; |
| 645 | } else { |
| 646 | adpcm_compress_trellis(avctx, samples, buf, |
| 647 | &c->status[0], n, avctx->channels); |
| 648 | adpcm_compress_trellis(avctx, samples + 1, buf + n, |
| 649 | &c->status[1], n, avctx->channels); |
| 650 | for (i = 0; i < n; i++) |
| 651 | *dst++ = (buf[i] << 4) | buf[n + i]; |
| 652 | } |
| 653 | av_free(buf); |
| 654 | } else { |
| 655 | for (i = 7 * avctx->channels; i < avctx->block_align; i++) { |
| 656 | int nibble; |
| 657 | nibble = adpcm_ms_compress_sample(&c->status[ 0], *samples++) << 4; |
| 658 | nibble |= adpcm_ms_compress_sample(&c->status[st], *samples++); |
| 659 | *dst++ = nibble; |
| 660 | } |
| 661 | } |
| 662 | break; |
| 663 | case AV_CODEC_ID_ADPCM_YAMAHA: |
| 664 | n = frame->nb_samples / 2; |
| 665 | if (avctx->trellis > 0) { |
| 666 | FF_ALLOC_OR_GOTO(avctx, buf, 2 * n * 2, error); |
| 667 | n *= 2; |
| 668 | if (avctx->channels == 1) { |
| 669 | adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n, |
| 670 | avctx->channels); |
| 671 | for (i = 0; i < n; i += 2) |
| 672 | *dst++ = buf[i] | (buf[i + 1] << 4); |
| 673 | } else { |
| 674 | adpcm_compress_trellis(avctx, samples, buf, |
| 675 | &c->status[0], n, avctx->channels); |
| 676 | adpcm_compress_trellis(avctx, samples + 1, buf + n, |
| 677 | &c->status[1], n, avctx->channels); |
| 678 | for (i = 0; i < n; i++) |
| 679 | *dst++ = buf[i] | (buf[n + i] << 4); |
| 680 | } |
| 681 | av_free(buf); |
| 682 | } else |
| 683 | for (n *= avctx->channels; n > 0; n--) { |
| 684 | int nibble; |
| 685 | nibble = adpcm_yamaha_compress_sample(&c->status[ 0], *samples++); |
| 686 | nibble |= adpcm_yamaha_compress_sample(&c->status[st], *samples++) << 4; |
| 687 | *dst++ = nibble; |
| 688 | } |
| 689 | break; |
| 690 | default: |
| 691 | return AVERROR(EINVAL); |
| 692 | } |
| 693 | |
| 694 | avpkt->size = pkt_size; |
| 695 | *got_packet_ptr = 1; |
| 696 | return 0; |
| 697 | error: |
| 698 | return AVERROR(ENOMEM); |
| 699 | } |
| 700 | |
| 701 | static const enum AVSampleFormat sample_fmts[] = { |
| 702 | AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE |
| 703 | }; |
| 704 | |
| 705 | static const enum AVSampleFormat sample_fmts_p[] = { |
| 706 | AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_NONE |
| 707 | }; |
| 708 | |
| 709 | #define ADPCM_ENCODER(id_, name_, sample_fmts_, long_name_) \ |
| 710 | AVCodec ff_ ## name_ ## _encoder = { \ |
| 711 | .name = #name_, \ |
| 712 | .long_name = NULL_IF_CONFIG_SMALL(long_name_), \ |
| 713 | .type = AVMEDIA_TYPE_AUDIO, \ |
| 714 | .id = id_, \ |
| 715 | .priv_data_size = sizeof(ADPCMEncodeContext), \ |
| 716 | .init = adpcm_encode_init, \ |
| 717 | .encode2 = adpcm_encode_frame, \ |
| 718 | .close = adpcm_encode_close, \ |
| 719 | .sample_fmts = sample_fmts_, \ |
| 720 | } |
| 721 | |
| 722 | ADPCM_ENCODER(AV_CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt, sample_fmts_p, "ADPCM IMA QuickTime"); |
| 723 | ADPCM_ENCODER(AV_CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav, sample_fmts_p, "ADPCM IMA WAV"); |
| 724 | ADPCM_ENCODER(AV_CODEC_ID_ADPCM_MS, adpcm_ms, sample_fmts, "ADPCM Microsoft"); |
| 725 | ADPCM_ENCODER(AV_CODEC_ID_ADPCM_SWF, adpcm_swf, sample_fmts, "ADPCM Shockwave Flash"); |
| 726 | ADPCM_ENCODER(AV_CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha, sample_fmts, "ADPCM Yamaha"); |