git.sesse.net Git - ffmpeg/blob - libavcodec/adpcmenc.c

   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_init(AVCodecContext *avctx)
  62 {
  63     ADPCMEncodeContext *s = avctx->priv_data;
  64     uint8_t *extradata;
  65     int i;
  66
  67     if (avctx->channels > 2) {
  68         av_log(avctx, AV_LOG_ERROR, "only stereo or mono is supported\n");
  69         return AVERROR(EINVAL);
  70     }
  71
  72     if (avctx->trellis) {
  73         int frontier, max_paths;
  74
  75         if ((unsigned)avctx->trellis > 16U) {
  76             av_log(avctx, AV_LOG_ERROR, "invalid trellis size\n");
  77             return AVERROR(EINVAL);
  78         }
  79
  80         if (avctx->codec->id == AV_CODEC_ID_ADPCM_IMA_SSI ||
  81             avctx->codec->id == AV_CODEC_ID_ADPCM_IMA_APM ||
  82             avctx->codec->id == AV_CODEC_ID_ADPCM_ARGO) {
  83             /*
  84              * The current trellis implementation doesn't work for extended
  85              * runs of samples without periodic resets. Disallow it.
  86              */
  87             av_log(avctx, AV_LOG_ERROR, "trellis not supported\n");
  88             return AVERROR_PATCHWELCOME;
  89         }
  90
  91         frontier  = 1 << avctx->trellis;
  92         max_paths =  frontier * FREEZE_INTERVAL;
  93         if (!FF_ALLOC_TYPED_ARRAY(s->paths,        max_paths)    ||
  94             !FF_ALLOC_TYPED_ARRAY(s->node_buf,     2 * frontier) ||
  95             !FF_ALLOC_TYPED_ARRAY(s->nodep_buf,    2 * frontier) ||
  96             !FF_ALLOC_TYPED_ARRAY(s->trellis_hash, 65536))
  97             return AVERROR(ENOMEM);
  98     }
  99
 100     avctx->bits_per_coded_sample = av_get_bits_per_sample(avctx->codec->id);
 101
 102     switch (avctx->codec->id) {
 103     case AV_CODEC_ID_ADPCM_IMA_WAV:
 104         /* each 16 bits sample gives one nibble
 105            and we have 4 bytes per channel overhead */
 106         avctx->frame_size = (BLKSIZE - 4 * avctx->channels) * 8 /
 107                             (4 * avctx->channels) + 1;
 108         /* seems frame_size isn't taken into account...
 109            have to buffer the samples :-( */
 110         avctx->block_align = BLKSIZE;
 111         avctx->bits_per_coded_sample = 4;
 112         break;
 113     case AV_CODEC_ID_ADPCM_IMA_QT:
 114         avctx->frame_size  = 64;
 115         avctx->block_align = 34 * avctx->channels;
 116         break;
 117     case AV_CODEC_ID_ADPCM_MS:
 118         /* each 16 bits sample gives one nibble
 119            and we have 7 bytes per channel overhead */
 120         avctx->frame_size = (BLKSIZE - 7 * avctx->channels) * 2 / avctx->channels + 2;
 121         avctx->bits_per_coded_sample = 4;
 122         avctx->block_align    = BLKSIZE;
 123         if (!(avctx->extradata = av_malloc(32 + AV_INPUT_BUFFER_PADDING_SIZE)))
 124             return AVERROR(ENOMEM);
 125         avctx->extradata_size = 32;
 126         extradata = avctx->extradata;
 127         bytestream_put_le16(&extradata, avctx->frame_size);
 128         bytestream_put_le16(&extradata, 7); /* wNumCoef */
 129         for (i = 0; i < 7; i++) {
 130             bytestream_put_le16(&extradata, ff_adpcm_AdaptCoeff1[i] * 4);
 131             bytestream_put_le16(&extradata, ff_adpcm_AdaptCoeff2[i] * 4);
 132         }
 133         break;
 134     case AV_CODEC_ID_ADPCM_YAMAHA:
 135         avctx->frame_size  = BLKSIZE * 2 / avctx->channels;
 136         avctx->block_align = BLKSIZE;
 137         break;
 138     case AV_CODEC_ID_ADPCM_SWF:
 139         if (avctx->sample_rate != 11025 &&
 140             avctx->sample_rate != 22050 &&
 141             avctx->sample_rate != 44100) {
 142             av_log(avctx, AV_LOG_ERROR, "Sample rate must be 11025, "
 143                    "22050 or 44100\n");
 144             return AVERROR(EINVAL);
 145         }
 146         avctx->frame_size = 512 * (avctx->sample_rate / 11025);
 147         break;
 148     case AV_CODEC_ID_ADPCM_IMA_SSI:
 149         avctx->frame_size = BLKSIZE * 2 / avctx->channels;
 150         avctx->block_align = BLKSIZE;
 151         break;
 152     case AV_CODEC_ID_ADPCM_IMA_APM:
 153         avctx->frame_size = BLKSIZE * 2 / avctx->channels;
 154         avctx->block_align = BLKSIZE;
 155
 156         if (!(avctx->extradata = av_mallocz(28 + AV_INPUT_BUFFER_PADDING_SIZE)))
 157             return AVERROR(ENOMEM);
 158         avctx->extradata_size = 28;
 159         break;
 160     case AV_CODEC_ID_ADPCM_ARGO:
 161         avctx->frame_size = 32;
 162         avctx->block_align = 17 * avctx->channels;
 163         break;
 164     default:
 165         return AVERROR(EINVAL);
 166     }
 167
 168     return 0;
 169 }
 170
 171 static av_cold int adpcm_encode_close(AVCodecContext *avctx)
 172 {
 173     ADPCMEncodeContext *s = avctx->priv_data;
 174     av_freep(&s->paths);
 175     av_freep(&s->node_buf);
 176     av_freep(&s->nodep_buf);
 177     av_freep(&s->trellis_hash);
 178
 179     return 0;
 180 }
 181
 182
 183 static inline uint8_t adpcm_ima_compress_sample(ADPCMChannelStatus *c,
 184                                                 int16_t sample)
 185 {
 186     int delta  = sample - c->prev_sample;
 187     int nibble = FFMIN(7, abs(delta) * 4 /
 188                        ff_adpcm_step_table[c->step_index]) + (delta < 0) * 8;
 189     c->prev_sample += ((ff_adpcm_step_table[c->step_index] *
 190                         ff_adpcm_yamaha_difflookup[nibble]) / 8);
 191     c->prev_sample = av_clip_int16(c->prev_sample);
 192     c->step_index  = av_clip(c->step_index + ff_adpcm_index_table[nibble], 0, 88);
 193     return nibble;
 194 }
 195
 196 static inline uint8_t adpcm_ima_qt_compress_sample(ADPCMChannelStatus *c,
 197                                                    int16_t sample)
 198 {
 199     int delta  = sample - c->prev_sample;
 200     int diff, step = ff_adpcm_step_table[c->step_index];
 201     int nibble = 8*(delta < 0);
 202
 203     delta= abs(delta);
 204     diff = delta + (step >> 3);
 205
 206     if (delta >= step) {
 207         nibble |= 4;
 208         delta  -= step;
 209     }
 210     step >>= 1;
 211     if (delta >= step) {
 212         nibble |= 2;
 213         delta  -= step;
 214     }
 215     step >>= 1;
 216     if (delta >= step) {
 217         nibble |= 1;
 218         delta  -= step;
 219     }
 220     diff -= delta;
 221
 222     if (nibble & 8)
 223         c->prev_sample -= diff;
 224     else
 225         c->prev_sample += diff;
 226
 227     c->prev_sample = av_clip_int16(c->prev_sample);
 228     c->step_index  = av_clip(c->step_index + ff_adpcm_index_table[nibble], 0, 88);
 229
 230     return nibble;
 231 }
 232
 233 static inline uint8_t adpcm_ms_compress_sample(ADPCMChannelStatus *c,
 234                                                int16_t sample)
 235 {
 236     int predictor, nibble, bias;
 237
 238     predictor = (((c->sample1) * (c->coeff1)) +
 239                 (( c->sample2) * (c->coeff2))) / 64;
 240
 241     nibble = sample - predictor;
 242     if (nibble >= 0)
 243         bias =  c->idelta / 2;
 244     else
 245         bias = -c->idelta / 2;
 246
 247     nibble = (nibble + bias) / c->idelta;
 248     nibble = av_clip_intp2(nibble, 3) & 0x0F;
 249
 250     predictor += ((nibble & 0x08) ? (nibble - 0x10) : nibble) * c->idelta;
 251
 252     c->sample2 = c->sample1;
 253     c->sample1 = av_clip_int16(predictor);
 254
 255     c->idelta = (ff_adpcm_AdaptationTable[nibble] * c->idelta) >> 8;
 256     if (c->idelta < 16)
 257         c->idelta = 16;
 258
 259     return nibble;
 260 }
 261
 262 static inline uint8_t adpcm_yamaha_compress_sample(ADPCMChannelStatus *c,
 263                                                    int16_t sample)
 264 {
 265     int nibble, delta;
 266
 267     if (!c->step) {
 268         c->predictor = 0;
 269         c->step      = 127;
 270     }
 271
 272     delta = sample - c->predictor;
 273
 274     nibble = FFMIN(7, abs(delta) * 4 / c->step) + (delta < 0) * 8;
 275
 276     c->predictor += ((c->step * ff_adpcm_yamaha_difflookup[nibble]) / 8);
 277     c->predictor = av_clip_int16(c->predictor);
 278     c->step = (c->step * ff_adpcm_yamaha_indexscale[nibble]) >> 8;
 279     c->step = av_clip(c->step, 127, 24576);
 280
 281     return nibble;
 282 }
 283
 284 static void adpcm_compress_trellis(AVCodecContext *avctx,
 285                                    const int16_t *samples, uint8_t *dst,
 286                                    ADPCMChannelStatus *c, int n, int stride)
 287 {
 288     //FIXME 6% faster if frontier is a compile-time constant
 289     ADPCMEncodeContext *s = avctx->priv_data;
 290     const int frontier = 1 << avctx->trellis;
 291     const int version  = avctx->codec->id;
 292     TrellisPath *paths       = s->paths, *p;
 293     TrellisNode *node_buf    = s->node_buf;
 294     TrellisNode **nodep_buf  = s->nodep_buf;
 295     TrellisNode **nodes      = nodep_buf; // nodes[] is always sorted by .ssd
 296     TrellisNode **nodes_next = nodep_buf + frontier;
 297     int pathn = 0, froze = -1, i, j, k, generation = 0;
 298     uint8_t *hash = s->trellis_hash;
 299     memset(hash, 0xff, 65536 * sizeof(*hash));
 300
 301     memset(nodep_buf, 0, 2 * frontier * sizeof(*nodep_buf));
 302     nodes[0]          = node_buf + frontier;
 303     nodes[0]->ssd     = 0;
 304     nodes[0]->path    = 0;
 305     nodes[0]->step    = c->step_index;
 306     nodes[0]->sample1 = c->sample1;
 307     nodes[0]->sample2 = c->sample2;
 308     if (version == AV_CODEC_ID_ADPCM_IMA_WAV ||
 309         version == AV_CODEC_ID_ADPCM_IMA_QT  ||
 310         version == AV_CODEC_ID_ADPCM_SWF)
 311         nodes[0]->sample1 = c->prev_sample;
 312     if (version == AV_CODEC_ID_ADPCM_MS)
 313         nodes[0]->step = c->idelta;
 314     if (version == AV_CODEC_ID_ADPCM_YAMAHA) {
 315         if (c->step == 0) {
 316             nodes[0]->step    = 127;
 317             nodes[0]->sample1 = 0;
 318         } else {
 319             nodes[0]->step    = c->step;
 320             nodes[0]->sample1 = c->predictor;
 321         }
 322     }
 323
 324     for (i = 0; i < n; i++) {
 325         TrellisNode *t = node_buf + frontier*(i&1);
 326         TrellisNode **u;
 327         int sample   = samples[i * stride];
 328         int heap_pos = 0;
 329         memset(nodes_next, 0, frontier * sizeof(TrellisNode*));
 330         for (j = 0; j < frontier && nodes[j]; j++) {
 331             // higher j have higher ssd already, so they're likely
 332             // to yield a suboptimal next sample too
 333             const int range = (j < frontier / 2) ? 1 : 0;
 334             const int step  = nodes[j]->step;
 335             int nidx;
 336             if (version == AV_CODEC_ID_ADPCM_MS) {
 337                 const int predictor = ((nodes[j]->sample1 * c->coeff1) +
 338                                        (nodes[j]->sample2 * c->coeff2)) / 64;
 339                 const int div  = (sample - predictor) / step;
 340                 const int nmin = av_clip(div-range, -8, 6);
 341                 const int nmax = av_clip(div+range, -7, 7);
 342                 for (nidx = nmin; nidx <= nmax; nidx++) {
 343                     const int nibble = nidx & 0xf;
 344                     int dec_sample   = predictor + nidx * step;
 345 #define STORE_NODE(NAME, STEP_INDEX)\
 346                     int d;\
 347                     uint32_t ssd;\
 348                     int pos;\
 349                     TrellisNode *u;\
 350                     uint8_t *h;\
 351                     dec_sample = av_clip_int16(dec_sample);\
 352                     d = sample - dec_sample;\
 353                     ssd = nodes[j]->ssd + d*(unsigned)d;\
 354                     /* Check for wraparound, skip such samples completely. \
 355                      * Note, changing ssd to a 64 bit variable would be \
 356                      * simpler, avoiding this check, but it's slower on \
 357                      * x86 32 bit at the moment. */\
 358                     if (ssd < nodes[j]->ssd)\
 359                         goto next_##NAME;\
 360                     /* Collapse any two states with the same previous sample value. \
 361                      * One could also distinguish states by step and by 2nd to last
 362                      * sample, but the effects of that are negligible.
 363                      * Since nodes in the previous generation are iterated
 364                      * through a heap, they're roughly ordered from better to
 365                      * worse, but not strictly ordered. Therefore, an earlier
 366                      * node with the same sample value is better in most cases
 367                      * (and thus the current is skipped), but not strictly
 368                      * in all cases. Only skipping samples where ssd >=
 369                      * ssd of the earlier node with the same sample gives
 370                      * slightly worse quality, though, for some reason. */ \
 371                     h = &hash[(uint16_t) dec_sample];\
 372                     if (*h == generation)\
 373                         goto next_##NAME;\
 374                     if (heap_pos < frontier) {\
 375                         pos = heap_pos++;\
 376                     } else {\
 377                         /* Try to replace one of the leaf nodes with the new \
 378                          * one, but try a different slot each time. */\
 379                         pos = (frontier >> 1) +\
 380                               (heap_pos & ((frontier >> 1) - 1));\
 381                         if (ssd > nodes_next[pos]->ssd)\
 382                             goto next_##NAME;\
 383                         heap_pos++;\
 384                     }\
 385                     *h = generation;\
 386                     u  = nodes_next[pos];\
 387                     if (!u) {\
 388                         av_assert1(pathn < FREEZE_INTERVAL << avctx->trellis);\
 389                         u = t++;\
 390                         nodes_next[pos] = u;\
 391                         u->path = pathn++;\
 392                     }\
 393                     u->ssd  = ssd;\
 394                     u->step = STEP_INDEX;\
 395                     u->sample2 = nodes[j]->sample1;\
 396                     u->sample1 = dec_sample;\
 397                     paths[u->path].nibble = nibble;\
 398                     paths[u->path].prev   = nodes[j]->path;\
 399                     /* Sift the newly inserted node up in the heap to \
 400                      * restore the heap property. */\
 401                     while (pos > 0) {\
 402                         int parent = (pos - 1) >> 1;\
 403                         if (nodes_next[parent]->ssd <= ssd)\
 404                             break;\
 405                         FFSWAP(TrellisNode*, nodes_next[parent], nodes_next[pos]);\
 406                         pos = parent;\
 407                     }\
 408                     next_##NAME:;
 409                     STORE_NODE(ms, FFMAX(16,
 410                                (ff_adpcm_AdaptationTable[nibble] * step) >> 8));
 411                 }
 412             } else if (version == AV_CODEC_ID_ADPCM_IMA_WAV ||
 413                        version == AV_CODEC_ID_ADPCM_IMA_QT  ||
 414                        version == AV_CODEC_ID_ADPCM_SWF) {
 415 #define LOOP_NODES(NAME, STEP_TABLE, STEP_INDEX)\
 416                 const int predictor = nodes[j]->sample1;\
 417                 const int div = (sample - predictor) * 4 / STEP_TABLE;\
 418                 int nmin = av_clip(div - range, -7, 6);\
 419                 int nmax = av_clip(div + range, -6, 7);\
 420                 if (nmin <= 0)\
 421                     nmin--; /* distinguish -0 from +0 */\
 422                 if (nmax < 0)\
 423                     nmax--;\
 424                 for (nidx = nmin; nidx <= nmax; nidx++) {\
 425                     const int nibble = nidx < 0 ? 7 - nidx : nidx;\
 426                     int dec_sample = predictor +\
 427                                     (STEP_TABLE *\
 428                                      ff_adpcm_yamaha_difflookup[nibble]) / 8;\
 429                     STORE_NODE(NAME, STEP_INDEX);\
 430                 }
 431                 LOOP_NODES(ima, ff_adpcm_step_table[step],
 432                            av_clip(step + ff_adpcm_index_table[nibble], 0, 88));
 433             } else { //AV_CODEC_ID_ADPCM_YAMAHA
 434                 LOOP_NODES(yamaha, step,
 435                            av_clip((step * ff_adpcm_yamaha_indexscale[nibble]) >> 8,
 436                                    127, 24576));
 437 #undef LOOP_NODES
 438 #undef STORE_NODE
 439             }
 440         }
 441
 442         u = nodes;
 443         nodes = nodes_next;
 444         nodes_next = u;
 445
 446         generation++;
 447         if (generation == 255) {
 448             memset(hash, 0xff, 65536 * sizeof(*hash));
 449             generation = 0;
 450         }
 451
 452         // prevent overflow
 453         if (nodes[0]->ssd > (1 << 28)) {
 454             for (j = 1; j < frontier && nodes[j]; j++)
 455                 nodes[j]->ssd -= nodes[0]->ssd;
 456             nodes[0]->ssd = 0;
 457         }
 458
 459         // merge old paths to save memory
 460         if (i == froze + FREEZE_INTERVAL) {
 461             p = &paths[nodes[0]->path];
 462             for (k = i; k > froze; k--) {
 463                 dst[k] = p->nibble;
 464                 p = &paths[p->prev];
 465             }
 466             froze = i;
 467             pathn = 0;
 468             // other nodes might use paths that don't coincide with the frozen one.
 469             // checking which nodes do so is too slow, so just kill them all.
 470             // this also slightly improves quality, but I don't know why.
 471             memset(nodes + 1, 0, (frontier - 1) * sizeof(TrellisNode*));
 472         }
 473     }
 474
 475     p = &paths[nodes[0]->path];
 476     for (i = n - 1; i > froze; i--) {
 477         dst[i] = p->nibble;
 478         p = &paths[p->prev];
 479     }
 480
 481     c->predictor  = nodes[0]->sample1;
 482     c->sample1    = nodes[0]->sample1;
 483     c->sample2    = nodes[0]->sample2;
 484     c->step_index = nodes[0]->step;
 485     c->step       = nodes[0]->step;
 486     c->idelta     = nodes[0]->step;
 487 }
 488
 489 static inline int adpcm_argo_compress_nibble(const ADPCMChannelStatus *cs, int16_t s,
 490                                              int shift, int flag)
 491 {
 492     int nibble;
 493
 494     if (flag)
 495         nibble = 4 * s - 8 * cs->sample1 + 4 * cs->sample2;
 496     else
 497         nibble = 4 * s - 4 * cs->sample1;
 498
 499     return (nibble >> shift) & 0x0F;
 500 }
 501
 502 static int64_t adpcm_argo_compress_block(ADPCMChannelStatus *cs, PutBitContext *pb,
 503                                          const int16_t *samples, int nsamples,
 504                                          int shift, int flag)
 505 {
 506     int64_t error = 0;
 507
 508     if (pb) {
 509         put_bits(pb, 4, shift - 2);
 510         put_bits(pb, 1, 0);
 511         put_bits(pb, 1, !!flag);
 512         put_bits(pb, 2, 0);
 513     }
 514
 515     for (int n = 0; n < nsamples; n++) {
 516         /* Compress the nibble, then expand it to see how much precision we've lost. */
 517         int nibble = adpcm_argo_compress_nibble(cs, samples[n], shift, flag);
 518         int16_t sample = ff_adpcm_argo_expand_nibble(cs, nibble, shift, flag);
 519
 520         error += abs(samples[n] - sample);
 521
 522         if (pb)
 523             put_bits(pb, 4, nibble);
 524     }
 525
 526     return error;
 527 }
 528
 529 static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
 530                               const AVFrame *frame, int *got_packet_ptr)
 531 {
 532     int n, i, ch, st, pkt_size, ret;
 533     const int16_t *samples;
 534     int16_t **samples_p;
 535     uint8_t *dst;
 536     ADPCMEncodeContext *c = avctx->priv_data;
 537     uint8_t *buf;
 538
 539     samples = (const int16_t *)frame->data[0];
 540     samples_p = (int16_t **)frame->extended_data;
 541     st = avctx->channels == 2;
 542
 543     if (avctx->codec_id == AV_CODEC_ID_ADPCM_SWF)
 544         pkt_size = (2 + avctx->channels * (22 + 4 * (frame->nb_samples - 1)) + 7) / 8;
 545     else if (avctx->codec_id == AV_CODEC_ID_ADPCM_IMA_SSI ||
 546              avctx->codec_id == AV_CODEC_ID_ADPCM_IMA_APM)
 547         pkt_size = (frame->nb_samples * avctx->channels) / 2;
 548     else
 549         pkt_size = avctx->block_align;
 550     if ((ret = ff_alloc_packet2(avctx, avpkt, pkt_size, 0)) < 0)
 551         return ret;
 552     dst = avpkt->data;
 553
 554     switch(avctx->codec->id) {
 555     case AV_CODEC_ID_ADPCM_IMA_WAV:
 556     {
 557         int blocks, j;
 558
 559         blocks = (frame->nb_samples - 1) / 8;
 560
 561         for (ch = 0; ch < avctx->channels; ch++) {
 562             ADPCMChannelStatus *status = &c->status[ch];
 563             status->prev_sample = samples_p[ch][0];
 564             /* status->step_index = 0;
 565                XXX: not sure how to init the state machine */
 566             bytestream_put_le16(&dst, status->prev_sample);
 567             *dst++ = status->step_index;
 568             *dst++ = 0; /* unknown */
 569         }
 570
 571         /* stereo: 4 bytes (8 samples) for left, 4 bytes for right */
 572         if (avctx->trellis > 0) {
 573             if (!FF_ALLOC_TYPED_ARRAY(buf, avctx->channels * blocks * 8))
 574                 return AVERROR(ENOMEM);
 575             for (ch = 0; ch < avctx->channels; ch++) {
 576                 adpcm_compress_trellis(avctx, &samples_p[ch][1],
 577                                        buf + ch * blocks * 8, &c->status[ch],
 578                                        blocks * 8, 1);
 579             }
 580             for (i = 0; i < blocks; i++) {
 581                 for (ch = 0; ch < avctx->channels; ch++) {
 582                     uint8_t *buf1 = buf + ch * blocks * 8 + i * 8;
 583                     for (j = 0; j < 8; j += 2)
 584                         *dst++ = buf1[j] | (buf1[j + 1] << 4);
 585                 }
 586             }
 587             av_free(buf);
 588         } else {
 589             for (i = 0; i < blocks; i++) {
 590                 for (ch = 0; ch < avctx->channels; ch++) {
 591                     ADPCMChannelStatus *status = &c->status[ch];
 592                     const int16_t *smp = &samples_p[ch][1 + i * 8];
 593                     for (j = 0; j < 8; j += 2) {
 594                         uint8_t v = adpcm_ima_compress_sample(status, smp[j    ]);
 595                         v        |= adpcm_ima_compress_sample(status, smp[j + 1]) << 4;
 596                         *dst++ = v;
 597                     }
 598                 }
 599             }
 600         }
 601         break;
 602     }
 603     case AV_CODEC_ID_ADPCM_IMA_QT:
 604     {
 605         PutBitContext pb;
 606         init_put_bits(&pb, dst, pkt_size);
 607
 608         for (ch = 0; ch < avctx->channels; ch++) {
 609             ADPCMChannelStatus *status = &c->status[ch];
 610             put_bits(&pb, 9, (status->prev_sample & 0xFFFF) >> 7);
 611             put_bits(&pb, 7,  status->step_index);
 612             if (avctx->trellis > 0) {
 613                 uint8_t buf[64];
 614                 adpcm_compress_trellis(avctx, &samples_p[ch][0], buf, status,
 615                                        64, 1);
 616                 for (i = 0; i < 64; i++)
 617                     put_bits(&pb, 4, buf[i ^ 1]);
 618                 status->prev_sample = status->predictor;
 619             } else {
 620                 for (i = 0; i < 64; i += 2) {
 621                     int t1, t2;
 622                     t1 = adpcm_ima_qt_compress_sample(status, samples_p[ch][i    ]);
 623                     t2 = adpcm_ima_qt_compress_sample(status, samples_p[ch][i + 1]);
 624                     put_bits(&pb, 4, t2);
 625                     put_bits(&pb, 4, t1);
 626                 }
 627             }
 628         }
 629
 630         flush_put_bits(&pb);
 631         break;
 632     }
 633     case AV_CODEC_ID_ADPCM_IMA_SSI:
 634     {
 635         PutBitContext pb;
 636         init_put_bits(&pb, dst, pkt_size);
 637
 638         av_assert0(avctx->trellis == 0);
 639
 640         for (i = 0; i < frame->nb_samples; i++) {
 641             for (ch = 0; ch < avctx->channels; ch++) {
 642                 put_bits(&pb, 4, adpcm_ima_qt_compress_sample(c->status + ch, *samples++));
 643             }
 644         }
 645
 646         flush_put_bits(&pb);
 647         break;
 648     }
 649     case AV_CODEC_ID_ADPCM_SWF:
 650     {
 651         PutBitContext pb;
 652         init_put_bits(&pb, dst, pkt_size);
 653
 654         n = frame->nb_samples - 1;
 655
 656         // store AdpcmCodeSize
 657         put_bits(&pb, 2, 2);    // set 4-bit flash adpcm format
 658
 659         // init the encoder state
 660         for (i = 0; i < avctx->channels; i++) {
 661             // clip step so it fits 6 bits
 662             c->status[i].step_index = av_clip_uintp2(c->status[i].step_index, 6);
 663             put_sbits(&pb, 16, samples[i]);
 664             put_bits(&pb, 6, c->status[i].step_index);
 665             c->status[i].prev_sample = samples[i];
 666         }
 667
 668         if (avctx->trellis > 0) {
 669             if (!(buf = av_malloc(2 * n)))
 670                 return AVERROR(ENOMEM);
 671             adpcm_compress_trellis(avctx, samples + avctx->channels, buf,
 672                                    &c->status[0], n, avctx->channels);
 673             if (avctx->channels == 2)
 674                 adpcm_compress_trellis(avctx, samples + avctx->channels + 1,
 675                                        buf + n, &c->status[1], n,
 676                                        avctx->channels);
 677             for (i = 0; i < n; i++) {
 678                 put_bits(&pb, 4, buf[i]);
 679                 if (avctx->channels == 2)
 680                     put_bits(&pb, 4, buf[n + i]);
 681             }
 682             av_free(buf);
 683         } else {
 684             for (i = 1; i < frame->nb_samples; i++) {
 685                 put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[0],
 686                          samples[avctx->channels * i]));
 687                 if (avctx->channels == 2)
 688                     put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[1],
 689                              samples[2 * i + 1]));
 690             }
 691         }
 692         flush_put_bits(&pb);
 693         break;
 694     }
 695     case AV_CODEC_ID_ADPCM_MS:
 696         for (i = 0; i < avctx->channels; i++) {
 697             int predictor = 0;
 698             *dst++ = predictor;
 699             c->status[i].coeff1 = ff_adpcm_AdaptCoeff1[predictor];
 700             c->status[i].coeff2 = ff_adpcm_AdaptCoeff2[predictor];
 701         }
 702         for (i = 0; i < avctx->channels; i++) {
 703             if (c->status[i].idelta < 16)
 704                 c->status[i].idelta = 16;
 705             bytestream_put_le16(&dst, c->status[i].idelta);
 706         }
 707         for (i = 0; i < avctx->channels; i++)
 708             c->status[i].sample2= *samples++;
 709         for (i = 0; i < avctx->channels; i++) {
 710             c->status[i].sample1 = *samples++;
 711             bytestream_put_le16(&dst, c->status[i].sample1);
 712         }
 713         for (i = 0; i < avctx->channels; i++)
 714             bytestream_put_le16(&dst, c->status[i].sample2);
 715
 716         if (avctx->trellis > 0) {
 717             n = avctx->block_align - 7 * avctx->channels;
 718             if (!(buf = av_malloc(2 * n)))
 719                 return AVERROR(ENOMEM);
 720             if (avctx->channels == 1) {
 721                 adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n,
 722                                        avctx->channels);
 723                 for (i = 0; i < n; i += 2)
 724                     *dst++ = (buf[i] << 4) | buf[i + 1];
 725             } else {
 726                 adpcm_compress_trellis(avctx, samples,     buf,
 727                                        &c->status[0], n, avctx->channels);
 728                 adpcm_compress_trellis(avctx, samples + 1, buf + n,
 729                                        &c->status[1], n, avctx->channels);
 730                 for (i = 0; i < n; i++)
 731                     *dst++ = (buf[i] << 4) | buf[n + i];
 732             }
 733             av_free(buf);
 734         } else {
 735             for (i = 7 * avctx->channels; i < avctx->block_align; i++) {
 736                 int nibble;
 737                 nibble  = adpcm_ms_compress_sample(&c->status[ 0], *samples++) << 4;
 738                 nibble |= adpcm_ms_compress_sample(&c->status[st], *samples++);
 739                 *dst++  = nibble;
 740             }
 741         }
 742         break;
 743     case AV_CODEC_ID_ADPCM_YAMAHA:
 744         n = frame->nb_samples / 2;
 745         if (avctx->trellis > 0) {
 746             if (!(buf = av_malloc(2 * n * 2)))
 747                 return AVERROR(ENOMEM);
 748             n *= 2;
 749             if (avctx->channels == 1) {
 750                 adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n,
 751                                        avctx->channels);
 752                 for (i = 0; i < n; i += 2)
 753                     *dst++ = buf[i] | (buf[i + 1] << 4);
 754             } else {
 755                 adpcm_compress_trellis(avctx, samples,     buf,
 756                                        &c->status[0], n, avctx->channels);
 757                 adpcm_compress_trellis(avctx, samples + 1, buf + n,
 758                                        &c->status[1], n, avctx->channels);
 759                 for (i = 0; i < n; i++)
 760                     *dst++ = buf[i] | (buf[n + i] << 4);
 761             }
 762             av_free(buf);
 763         } else
 764             for (n *= avctx->channels; n > 0; n--) {
 765                 int nibble;
 766                 nibble  = adpcm_yamaha_compress_sample(&c->status[ 0], *samples++);
 767                 nibble |= adpcm_yamaha_compress_sample(&c->status[st], *samples++) << 4;
 768                 *dst++  = nibble;
 769             }
 770         break;
 771     case AV_CODEC_ID_ADPCM_IMA_APM:
 772     {
 773         PutBitContext pb;
 774         init_put_bits(&pb, dst, pkt_size);
 775
 776         av_assert0(avctx->trellis == 0);
 777
 778         for (n = frame->nb_samples / 2; n > 0; n--) {
 779             for (ch = 0; ch < avctx->channels; ch++) {
 780                 put_bits(&pb, 4, adpcm_ima_qt_compress_sample(c->status + ch, *samples++));
 781                 put_bits(&pb, 4, adpcm_ima_qt_compress_sample(c->status + ch, samples[st]));
 782             }
 783             samples += avctx->channels;
 784         }
 785
 786         flush_put_bits(&pb);
 787         break;
 788     }
 789     case AV_CODEC_ID_ADPCM_ARGO:
 790     {
 791         PutBitContext pb;
 792         init_put_bits(&pb, dst, pkt_size);
 793
 794         av_assert0(frame->nb_samples == 32);
 795
 796         for (ch = 0; ch < avctx->channels; ch++) {
 797             int64_t error  = INT64_MAX, tmperr = INT64_MAX;
 798             int     shift  = 2, flag = 0;
 799             int     saved1 = c->status[ch].sample1;
 800             int     saved2 = c->status[ch].sample2;
 801
 802             /* Find the optimal coefficients, bail early if we find a perfect result. */
 803             for (int s = 2; s < 18 && tmperr != 0; s++) {
 804                 for (int f = 0; f < 2 && tmperr != 0; f++) {
 805                     c->status[ch].sample1 = saved1;
 806                     c->status[ch].sample2 = saved2;
 807                     tmperr = adpcm_argo_compress_block(c->status + ch, NULL, samples_p[ch],
 808                                                        frame->nb_samples, s, f);
 809                     if (tmperr < error) {
 810                         shift = s;
 811                         flag  = f;
 812                         error = tmperr;
 813                     }
 814                 }
 815             }
 816
 817             /* Now actually do the encode. */
 818             c->status[ch].sample1 = saved1;
 819             c->status[ch].sample2 = saved2;
 820             adpcm_argo_compress_block(c->status + ch, &pb, samples_p[ch],
 821                                       frame->nb_samples, shift, flag);
 822         }
 823
 824         flush_put_bits(&pb);
 825         break;
 826     }
 827     default:
 828         return AVERROR(EINVAL);
 829     }
 830
 831     avpkt->size = pkt_size;
 832     *got_packet_ptr = 1;
 833     return 0;
 834 }
 835
 836 static const enum AVSampleFormat sample_fmts[] = {
 837     AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE
 838 };
 839
 840 static const enum AVSampleFormat sample_fmts_p[] = {
 841     AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_NONE
 842 };
 843
 844 #define ADPCM_ENCODER(id_, name_, sample_fmts_, capabilities_, long_name_) \
 845 AVCodec ff_ ## name_ ## _encoder = {                                       \
 846     .name           = #name_,                                              \
 847     .long_name      = NULL_IF_CONFIG_SMALL(long_name_),                    \
 848     .type           = AVMEDIA_TYPE_AUDIO,                                  \
 849     .id             = id_,                                                 \
 850     .priv_data_size = sizeof(ADPCMEncodeContext),                          \
 851     .init           = adpcm_encode_init,                                   \
 852     .encode2        = adpcm_encode_frame,                                  \
 853     .close          = adpcm_encode_close,                                  \
 854     .sample_fmts    = sample_fmts_,                                        \
 855     .capabilities   = capabilities_,                                       \
 856     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,                           \
 857 }
 858
 859 ADPCM_ENCODER(AV_CODEC_ID_ADPCM_ARGO,    adpcm_argo,    sample_fmts_p, 0,                             "ADPCM Argonaut Games");
 860 ADPCM_ENCODER(AV_CODEC_ID_ADPCM_IMA_APM, adpcm_ima_apm, sample_fmts,   AV_CODEC_CAP_SMALL_LAST_FRAME, "ADPCM IMA Ubisoft APM");
 861 ADPCM_ENCODER(AV_CODEC_ID_ADPCM_IMA_QT,  adpcm_ima_qt,  sample_fmts_p, 0,                             "ADPCM IMA QuickTime");
 862 ADPCM_ENCODER(AV_CODEC_ID_ADPCM_IMA_SSI, adpcm_ima_ssi, sample_fmts,   AV_CODEC_CAP_SMALL_LAST_FRAME, "ADPCM IMA Simon & Schuster Interactive");
 863 ADPCM_ENCODER(AV_CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav, sample_fmts_p, 0,                             "ADPCM IMA WAV");
 864 ADPCM_ENCODER(AV_CODEC_ID_ADPCM_MS,      adpcm_ms,      sample_fmts,   0,                             "ADPCM Microsoft");
 865 ADPCM_ENCODER(AV_CODEC_ID_ADPCM_SWF,     adpcm_swf,     sample_fmts,   0,                             "ADPCM Shockwave Flash");
 866 ADPCM_ENCODER(AV_CODEC_ID_ADPCM_YAMAHA,  adpcm_yamaha,  sample_fmts,   0,                             "ADPCM Yamaha");