GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/adpcmenc.c Lines: 410 436 94.0 %
Date: 2020-09-21 17:35:45 Branches: 252 288 87.5 %

Line Branch Exec Source
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
14
static av_cold int adpcm_encode_init(AVCodecContext *avctx)
62
{
63
14
    ADPCMEncodeContext *s = avctx->priv_data;
64
    uint8_t *extradata;
65
    int i;
66
67
14
    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
14
    if (avctx->trellis) {
73
        int frontier, max_paths;
74
75
5
        if ((unsigned)avctx->trellis > 16U) {
76
            av_log(avctx, AV_LOG_ERROR, "invalid trellis size\n");
77
            return AVERROR(EINVAL);
78
        }
79
80
5
        if (avctx->codec->id == AV_CODEC_ID_ADPCM_IMA_SSI ||
81
5
            avctx->codec->id == AV_CODEC_ID_ADPCM_IMA_APM ||
82
5
            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
5
        frontier  = 1 << avctx->trellis;
92
5
        max_paths =  frontier * FREEZE_INTERVAL;
93
5
        if (!FF_ALLOC_TYPED_ARRAY(s->paths,        max_paths)    ||
94
5
            !FF_ALLOC_TYPED_ARRAY(s->node_buf,     2 * frontier) ||
95
5
            !FF_ALLOC_TYPED_ARRAY(s->nodep_buf,    2 * frontier) ||
96
5
            !FF_ALLOC_TYPED_ARRAY(s->trellis_hash, 65536))
97
            return AVERROR(ENOMEM);
98
    }
99
100
14
    avctx->bits_per_coded_sample = av_get_bits_per_sample(avctx->codec->id);
101
102


14
    switch (avctx->codec->id) {
103
2
    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
2
        avctx->frame_size = (BLKSIZE - 4 * avctx->channels) * 8 /
107
2
                            (4 * avctx->channels) + 1;
108
        /* seems frame_size isn't taken into account...
109
           have to buffer the samples :-( */
110
2
        avctx->block_align = BLKSIZE;
111
2
        avctx->bits_per_coded_sample = 4;
112
2
        break;
113
2
    case AV_CODEC_ID_ADPCM_IMA_QT:
114
2
        avctx->frame_size  = 64;
115
2
        avctx->block_align = 34 * avctx->channels;
116
2
        break;
117
2
    case AV_CODEC_ID_ADPCM_MS:
118
        /* each 16 bits sample gives one nibble
119
           and we have 7 bytes per channel overhead */
120
2
        avctx->frame_size = (BLKSIZE - 7 * avctx->channels) * 2 / avctx->channels + 2;
121
2
        avctx->bits_per_coded_sample = 4;
122
2
        avctx->block_align    = BLKSIZE;
123
2
        if (!(avctx->extradata = av_malloc(32 + AV_INPUT_BUFFER_PADDING_SIZE)))
124
            return AVERROR(ENOMEM);
125
2
        avctx->extradata_size = 32;
126
2
        extradata = avctx->extradata;
127
2
        bytestream_put_le16(&extradata, avctx->frame_size);
128
2
        bytestream_put_le16(&extradata, 7); /* wNumCoef */
129
16
        for (i = 0; i < 7; i++) {
130
14
            bytestream_put_le16(&extradata, ff_adpcm_AdaptCoeff1[i] * 4);
131
14
            bytestream_put_le16(&extradata, ff_adpcm_AdaptCoeff2[i] * 4);
132
        }
133
2
        break;
134
3
    case AV_CODEC_ID_ADPCM_YAMAHA:
135
3
        avctx->frame_size  = BLKSIZE * 2 / avctx->channels;
136
3
        avctx->block_align = BLKSIZE;
137
3
        break;
138
2
    case AV_CODEC_ID_ADPCM_SWF:
139
2
        if (avctx->sample_rate != 11025 &&
140
2
            avctx->sample_rate != 22050 &&
141
2
            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
2
        avctx->frame_size = 512 * (avctx->sample_rate / 11025);
147
2
        break;
148
1
    case AV_CODEC_ID_ADPCM_IMA_SSI:
149
1
        avctx->frame_size = BLKSIZE * 2 / avctx->channels;
150
1
        avctx->block_align = BLKSIZE;
151
1
        break;
152
1
    case AV_CODEC_ID_ADPCM_IMA_APM:
153
1
        avctx->frame_size = BLKSIZE * 2 / avctx->channels;
154
1
        avctx->block_align = BLKSIZE;
155
156
1
        if (!(avctx->extradata = av_mallocz(28 + AV_INPUT_BUFFER_PADDING_SIZE)))
157
            return AVERROR(ENOMEM);
158
1
        avctx->extradata_size = 28;
159
1
        break;
160
1
    case AV_CODEC_ID_ADPCM_ARGO:
161
1
        avctx->frame_size = 32;
162
1
        avctx->block_align = 17 * avctx->channels;
163
1
        break;
164
    default:
165
        return AVERROR(EINVAL);
166
    }
167
168
14
    return 0;
169
}
170
171
14
static av_cold int adpcm_encode_close(AVCodecContext *avctx)
172
{
173
14
    ADPCMEncodeContext *s = avctx->priv_data;
174
14
    av_freep(&s->paths);
175
14
    av_freep(&s->node_buf);
176
14
    av_freep(&s->nodep_buf);
177
14
    av_freep(&s->trellis_hash);
178
179
14
    return 0;
180
}
181
182
183
1062572
static inline uint8_t adpcm_ima_compress_sample(ADPCMChannelStatus *c,
184
                                                int16_t sample)
185
{
186
1062572
    int delta  = sample - c->prev_sample;
187
1062572
    int nibble = FFMIN(7, abs(delta) * 4 /
188
1062572
                       ff_adpcm_step_table[c->step_index]) + (delta < 0) * 8;
189
1062572
    c->prev_sample += ((ff_adpcm_step_table[c->step_index] *
190
1062572
                        ff_adpcm_yamaha_difflookup[nibble]) / 8);
191
1062572
    c->prev_sample = av_clip_int16(c->prev_sample);
192
1062572
    c->step_index  = av_clip(c->step_index + ff_adpcm_index_table[nibble], 0, 88);
193
1062572
    return nibble;
194
}
195
196
1587680
static inline uint8_t adpcm_ima_qt_compress_sample(ADPCMChannelStatus *c,
197
                                                   int16_t sample)
198
{
199
1587680
    int delta  = sample - c->prev_sample;
200
1587680
    int diff, step = ff_adpcm_step_table[c->step_index];
201
1587680
    int nibble = 8*(delta < 0);
202
203
1587680
    delta= abs(delta);
204
1587680
    diff = delta + (step >> 3);
205
206
1587680
    if (delta >= step) {
207
435880
        nibble |= 4;
208
435880
        delta  -= step;
209
    }
210
1587680
    step >>= 1;
211
1587680
    if (delta >= step) {
212
760258
        nibble |= 2;
213
760258
        delta  -= step;
214
    }
215
1587680
    step >>= 1;
216
1587680
    if (delta >= step) {
217
770157
        nibble |= 1;
218
770157
        delta  -= step;
219
    }
220
1587680
    diff -= delta;
221
222
1587680
    if (nibble & 8)
223
789018
        c->prev_sample -= diff;
224
    else
225
798662
        c->prev_sample += diff;
226
227
1587680
    c->prev_sample = av_clip_int16(c->prev_sample);
228
1587680
    c->step_index  = av_clip(c->step_index + ff_adpcm_index_table[nibble], 0, 88);
229
230
1587680
    return nibble;
231
}
232
233
529240
static inline uint8_t adpcm_ms_compress_sample(ADPCMChannelStatus *c,
234
                                               int16_t sample)
235
{
236
    int predictor, nibble, bias;
237
238
529240
    predictor = (((c->sample1) * (c->coeff1)) +
239
529240
                (( c->sample2) * (c->coeff2))) / 64;
240
241
529240
    nibble = sample - predictor;
242
529240
    if (nibble >= 0)
243
265224
        bias =  c->idelta / 2;
244
    else
245
264016
        bias = -c->idelta / 2;
246
247
529240
    nibble = (nibble + bias) / c->idelta;
248
529240
    nibble = av_clip_intp2(nibble, 3) & 0x0F;
249
250
529240
    predictor += ((nibble & 0x08) ? (nibble - 0x10) : nibble) * c->idelta;
251
252
529240
    c->sample2 = c->sample1;
253
529240
    c->sample1 = av_clip_int16(predictor);
254
255
529240
    c->idelta = (ff_adpcm_AdaptationTable[nibble] * c->idelta) >> 8;
256
529240
    if (c->idelta < 16)
257
28193
        c->idelta = 16;
258
259
529240
    return nibble;
260
}
261
262
575488
static inline uint8_t adpcm_yamaha_compress_sample(ADPCMChannelStatus *c,
263
                                                   int16_t sample)
264
{
265
    int nibble, delta;
266
267
575488
    if (!c->step) {
268
3
        c->predictor = 0;
269
3
        c->step      = 127;
270
    }
271
272
575488
    delta = sample - c->predictor;
273
274
575488
    nibble = FFMIN(7, abs(delta) * 4 / c->step) + (delta < 0) * 8;
275
276
575488
    c->predictor += ((c->step * ff_adpcm_yamaha_difflookup[nibble]) / 8);
277
575488
    c->predictor = av_clip_int16(c->predictor);
278
575488
    c->step = (c->step * ff_adpcm_yamaha_indexscale[nibble]) >> 8;
279
575488
    c->step = av_clip(c->step, 127, 24576);
280
281
575488
    return nibble;
282
}
283
284
10094
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
10094
    ADPCMEncodeContext *s = avctx->priv_data;
290
10094
    const int frontier = 1 << avctx->trellis;
291
10094
    const int version  = avctx->codec->id;
292
10094
    TrellisPath *paths       = s->paths, *p;
293
10094
    TrellisNode *node_buf    = s->node_buf;
294
10094
    TrellisNode **nodep_buf  = s->nodep_buf;
295
10094
    TrellisNode **nodes      = nodep_buf; // nodes[] is always sorted by .ssd
296
10094
    TrellisNode **nodes_next = nodep_buf + frontier;
297
10094
    int pathn = 0, froze = -1, i, j, k, generation = 0;
298
10094
    uint8_t *hash = s->trellis_hash;
299
10094
    memset(hash, 0xff, 65536 * sizeof(*hash));
300
301
10094
    memset(nodep_buf, 0, 2 * frontier * sizeof(*nodep_buf));
302
10094
    nodes[0]          = node_buf + frontier;
303
10094
    nodes[0]->ssd     = 0;
304
10094
    nodes[0]->path    = 0;
305
10094
    nodes[0]->step    = c->step_index;
306
10094
    nodes[0]->sample1 = c->sample1;
307
10094
    nodes[0]->sample2 = c->sample2;
308

10094
    if (version == AV_CODEC_ID_ADPCM_IMA_WAV ||
309
1302
        version == AV_CODEC_ID_ADPCM_IMA_QT  ||
310
        version == AV_CODEC_ID_ADPCM_SWF)
311
9052
        nodes[0]->sample1 = c->prev_sample;
312
10094
    if (version == AV_CODEC_ID_ADPCM_MS)
313
524
        nodes[0]->step = c->idelta;
314
10094
    if (version == AV_CODEC_ID_ADPCM_YAMAHA) {
315
518
        if (c->step == 0) {
316
2
            nodes[0]->step    = 127;
317
2
            nodes[0]->sample1 = 0;
318
        } else {
319
516
            nodes[0]->step    = c->step;
320
516
            nodes[0]->sample1 = c->predictor;
321
        }
322
    }
323
324
2661618
    for (i = 0; i < n; i++) {
325
2651524
        TrellisNode *t = node_buf + frontier*(i&1);
326
        TrellisNode **u;
327
2651524
        int sample   = samples[i * stride];
328
2651524
        int heap_pos = 0;
329
2651524
        memset(nodes_next, 0, frontier * sizeof(TrellisNode*));
330

83552779
        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
80901255
            const int range = (j < frontier / 2) ? 1 : 0;
334
80901255
            const int step  = nodes[j]->step;
335
            int nidx;
336
80901255
            if (version == AV_CODEC_ID_ADPCM_MS) {
337
15997120
                const int predictor = ((nodes[j]->sample1 * c->coeff1) +
338
15997120
                                       (nodes[j]->sample2 * c->coeff2)) / 64;
339
15997120
                const int div  = (sample - predictor) / step;
340
15997120
                const int nmin = av_clip(div-range, -8, 6);
341
15997120
                const int nmax = av_clip(div+range, -7, 7);
342
48245314
                for (nidx = nmin; nidx <= nmax; nidx++) {
343
32248194
                    const int nibble = nidx & 0xf;
344
32248194
                    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



44471491
                    STORE_NODE(ms, FFMAX(16,
410
                               (ff_adpcm_AdaptationTable[nibble] * step) >> 8));
411
                }
412

64904135
            } else if (version == AV_CODEC_ID_ADPCM_IMA_WAV ||
413
32822107
                       version == AV_CODEC_ID_ADPCM_IMA_QT  ||
414
48302932
                       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





196413839
                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





67079772
                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
2651524
        u = nodes;
443
2651524
        nodes = nodes_next;
444
2651524
        nodes_next = u;
445
446
2651524
        generation++;
447
2651524
        if (generation == 255) {
448
7290
            memset(hash, 0xff, 65536 * sizeof(*hash));
449
7290
            generation = 0;
450
        }
451
452
        // prevent overflow
453
2651524
        if (nodes[0]->ssd > (1 << 28)) {
454

151896
            for (j = 1; j < frontier && nodes[j]; j++)
455
147051
                nodes[j]->ssd -= nodes[0]->ssd;
456
4845
            nodes[0]->ssd = 0;
457
        }
458
459
        // merge old paths to save memory
460
2651524
        if (i == froze + FREEZE_INTERVAL) {
461
15366
            p = &paths[nodes[0]->path];
462
1982214
            for (k = i; k > froze; k--) {
463
1966848
                dst[k] = p->nibble;
464
1966848
                p = &paths[p->prev];
465
            }
466
15366
            froze = i;
467
15366
            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
15366
            memset(nodes + 1, 0, (frontier - 1) * sizeof(TrellisNode*));
472
        }
473
    }
474
475
10094
    p = &paths[nodes[0]->path];
476
694770
    for (i = n - 1; i > froze; i--) {
477
684676
        dst[i] = p->nibble;
478
684676
        p = &paths[p->prev];
479
    }
480
481
10094
    c->predictor  = nodes[0]->sample1;
482
10094
    c->sample1    = nodes[0]->sample1;
483
10094
    c->sample2    = nodes[0]->sample2;
484
10094
    c->step_index = nodes[0]->step;
485
10094
    c->step       = nodes[0]->step;
486
10094
    c->idelta     = nodes[0]->step;
487
10094
}
488
489
16840928
static inline int adpcm_argo_compress_nibble(const ADPCMChannelStatus *cs, int16_t s,
490
                                             int shift, int flag)
491
{
492
    int nibble;
493
494
16840928
    if (flag)
495
8538976
        nibble = 4 * s - 8 * cs->sample1 + 4 * cs->sample2;
496
    else
497
8301952
        nibble = 4 * s - 4 * cs->sample1;
498
499
16840928
    return (nibble >> shift) & 0x0F;
500
}
501
502
526279
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
526279
    int64_t error = 0;
507
508
526279
    if (pb) {
509
16538
        put_bits(pb, 4, shift - 2);
510
16538
        put_bits(pb, 1, 0);
511
16538
        put_bits(pb, 1, !!flag);
512
16538
        put_bits(pb, 2, 0);
513
    }
514
515
17367207
    for (int n = 0; n < nsamples; n++) {
516
        /* Compress the nibble, then expand it to see how much precision we've lost. */
517
16840928
        int nibble = adpcm_argo_compress_nibble(cs, samples[n], shift, flag);
518
16840928
        int16_t sample = ff_adpcm_argo_expand_nibble(cs, nibble, shift, flag);
519
520
16840928
        error += abs(samples[n] - sample);
521
522
16840928
        if (pb)
523
529216
            put_bits(pb, 4, nibble);
524
    }
525
526
526279
    return error;
527
}
528
529
18903
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
18903
    ADPCMEncodeContext *c = avctx->priv_data;
537
    uint8_t *buf;
538
539
18903
    samples = (const int16_t *)frame->data[0];
540
18903
    samples_p = (int16_t **)frame->extended_data;
541
18903
    st = avctx->channels == 2;
542
543
18903
    if (avctx->codec_id == AV_CODEC_ID_ADPCM_SWF)
544
260
        pkt_size = (2 + avctx->channels * (22 + 4 * (frame->nb_samples - 1)) + 7) / 8;
545
18643
    else if (avctx->codec_id == AV_CODEC_ID_ADPCM_IMA_SSI ||
546
18384
             avctx->codec_id == AV_CODEC_ID_ADPCM_IMA_APM)
547
518
        pkt_size = (frame->nb_samples * avctx->channels) / 2;
548
    else
549
18125
        pkt_size = avctx->block_align;
550
18903
    if ((ret = ff_alloc_packet2(avctx, avpkt, pkt_size, 0)) < 0)
551
        return ret;
552
18903
    dst = avpkt->data;
553
554


18903
    switch(avctx->codec->id) {
555
522
    case AV_CODEC_ID_ADPCM_IMA_WAV:
556
    {
557
        int blocks, j;
558
559
522
        blocks = (frame->nb_samples - 1) / 8;
560
561
1566
        for (ch = 0; ch < avctx->channels; ch++) {
562
1044
            ADPCMChannelStatus *status = &c->status[ch];
563
1044
            status->prev_sample = samples_p[ch][0];
564
            /* status->step_index = 0;
565
               XXX: not sure how to init the state machine */
566
1044
            bytestream_put_le16(&dst, status->prev_sample);
567
1044
            *dst++ = status->step_index;
568
1044
            *dst++ = 0; /* unknown */
569
        }
570
571
        /* stereo: 4 bytes (8 samples) for left, 4 bytes for right */
572
522
        if (avctx->trellis > 0) {
573
261
            if (!FF_ALLOC_TYPED_ARRAY(buf, avctx->channels * blocks * 8))
574
                return AVERROR(ENOMEM);
575
783
            for (ch = 0; ch < avctx->channels; ch++) {
576
522
                adpcm_compress_trellis(avctx, &samples_p[ch][1],
577
522
                                       buf + ch * blocks * 8, &c->status[ch],
578
                                       blocks * 8, 1);
579
            }
580
33408
            for (i = 0; i < blocks; i++) {
581
99441
                for (ch = 0; ch < avctx->channels; ch++) {
582
66294
                    uint8_t *buf1 = buf + ch * blocks * 8 + i * 8;
583
331470
                    for (j = 0; j < 8; j += 2)
584
265176
                        *dst++ = buf1[j] | (buf1[j + 1] << 4);
585
                }
586
            }
587
261
            av_free(buf);
588
        } else {
589
33408
            for (i = 0; i < blocks; i++) {
590
99441
                for (ch = 0; ch < avctx->channels; ch++) {
591
66294
                    ADPCMChannelStatus *status = &c->status[ch];
592
66294
                    const int16_t *smp = &samples_p[ch][1 + i * 8];
593
331470
                    for (j = 0; j < 8; j += 2) {
594
265176
                        uint8_t v = adpcm_ima_compress_sample(status, smp[j    ]);
595
265176
                        v        |= adpcm_ima_compress_sample(status, smp[j + 1]) << 4;
596
265176
                        *dst++ = v;
597
                    }
598
                }
599
            }
600
        }
601
522
        break;
602
    }
603
8270
    case AV_CODEC_ID_ADPCM_IMA_QT:
604
    {
605
        PutBitContext pb;
606
8270
        init_put_bits(&pb, dst, pkt_size);
607
608
24810
        for (ch = 0; ch < avctx->channels; ch++) {
609
16540
            ADPCMChannelStatus *status = &c->status[ch];
610
16540
            put_bits(&pb, 9, (status->prev_sample & 0xFFFF) >> 7);
611
16540
            put_bits(&pb, 7,  status->step_index);
612
16540
            if (avctx->trellis > 0) {
613
                uint8_t buf[64];
614
8270
                adpcm_compress_trellis(avctx, &samples_p[ch][0], buf, status,
615
                                       64, 1);
616
537550
                for (i = 0; i < 64; i++)
617
529280
                    put_bits(&pb, 4, buf[i ^ 1]);
618
8270
                status->prev_sample = status->predictor;
619
            } else {
620
272910
                for (i = 0; i < 64; i += 2) {
621
                    int t1, t2;
622
264640
                    t1 = adpcm_ima_qt_compress_sample(status, samples_p[ch][i    ]);
623
264640
                    t2 = adpcm_ima_qt_compress_sample(status, samples_p[ch][i + 1]);
624
264640
                    put_bits(&pb, 4, t2);
625
264640
                    put_bits(&pb, 4, t1);
626
                }
627
            }
628
        }
629
630
8270
        flush_put_bits(&pb);
631
8270
        break;
632
    }
633
259
    case AV_CODEC_ID_ADPCM_IMA_SSI:
634
    {
635
        PutBitContext pb;
636
259
        init_put_bits(&pb, dst, pkt_size);
637
638
259
        av_assert0(avctx->trellis == 0);
639
640
264859
        for (i = 0; i < frame->nb_samples; i++) {
641
793800
            for (ch = 0; ch < avctx->channels; ch++) {
642
529200
                put_bits(&pb, 4, adpcm_ima_qt_compress_sample(c->status + ch, *samples++));
643
            }
644
        }
645
646
259
        flush_put_bits(&pb);
647
259
        break;
648
    }
649
260
    case AV_CODEC_ID_ADPCM_SWF:
650
    {
651
        PutBitContext pb;
652
260
        init_put_bits(&pb, dst, pkt_size);
653
654
260
        n = frame->nb_samples - 1;
655
656
        // store AdpcmCodeSize
657
260
        put_bits(&pb, 2, 2);    // set 4-bit flash adpcm format
658
659
        // init the encoder state
660
780
        for (i = 0; i < avctx->channels; i++) {
661
            // clip step so it fits 6 bits
662
520
            c->status[i].step_index = av_clip_uintp2(c->status[i].step_index, 6);
663
520
            put_sbits(&pb, 16, samples[i]);
664
520
            put_bits(&pb, 6, c->status[i].step_index);
665
520
            c->status[i].prev_sample = samples[i];
666
        }
667
668
260
        if (avctx->trellis > 0) {
669
130
            if (!(buf = av_malloc(2 * n)))
670
                return AVERROR(ENOMEM);
671
130
            adpcm_compress_trellis(avctx, samples + avctx->channels, buf,
672
                                   &c->status[0], n, avctx->channels);
673
130
            if (avctx->channels == 2)
674
130
                adpcm_compress_trellis(avctx, samples + avctx->channels + 1,
675
                                       buf + n, &c->status[1], n,
676
                                       avctx->channels);
677
266240
            for (i = 0; i < n; i++) {
678
266110
                put_bits(&pb, 4, buf[i]);
679
266110
                if (avctx->channels == 2)
680
266110
                    put_bits(&pb, 4, buf[n + i]);
681
            }
682
130
            av_free(buf);
683
        } else {
684
266240
            for (i = 1; i < frame->nb_samples; i++) {
685
266110
                put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[0],
686
266110
                         samples[avctx->channels * i]));
687
266110
                if (avctx->channels == 2)
688
266110
                    put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[1],
689
266110
                             samples[2 * i + 1]));
690
            }
691
        }
692
260
        flush_put_bits(&pb);
693
260
        break;
694
    }
695
524
    case AV_CODEC_ID_ADPCM_MS:
696
1572
        for (i = 0; i < avctx->channels; i++) {
697
1048
            int predictor = 0;
698
1048
            *dst++ = predictor;
699
1048
            c->status[i].coeff1 = ff_adpcm_AdaptCoeff1[predictor];
700
1048
            c->status[i].coeff2 = ff_adpcm_AdaptCoeff2[predictor];
701
        }
702
1572
        for (i = 0; i < avctx->channels; i++) {
703
1048
            if (c->status[i].idelta < 16)
704
4
                c->status[i].idelta = 16;
705
1048
            bytestream_put_le16(&dst, c->status[i].idelta);
706
        }
707
1572
        for (i = 0; i < avctx->channels; i++)
708
1048
            c->status[i].sample2= *samples++;
709
1572
        for (i = 0; i < avctx->channels; i++) {
710
1048
            c->status[i].sample1 = *samples++;
711
1048
            bytestream_put_le16(&dst, c->status[i].sample1);
712
        }
713
1572
        for (i = 0; i < avctx->channels; i++)
714
1048
            bytestream_put_le16(&dst, c->status[i].sample2);
715
716
524
        if (avctx->trellis > 0) {
717
262
            n = avctx->block_align - 7 * avctx->channels;
718
262
            if (!(buf = av_malloc(2 * n)))
719
                return AVERROR(ENOMEM);
720
262
            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
262
                adpcm_compress_trellis(avctx, samples,     buf,
727
                                       &c->status[0], n, avctx->channels);
728
262
                adpcm_compress_trellis(avctx, samples + 1, buf + n,
729
                                       &c->status[1], n, avctx->channels);
730
264882
                for (i = 0; i < n; i++)
731
264620
                    *dst++ = (buf[i] << 4) | buf[n + i];
732
            }
733
262
            av_free(buf);
734
        } else {
735
264882
            for (i = 7 * avctx->channels; i < avctx->block_align; i++) {
736
                int nibble;
737
264620
                nibble  = adpcm_ms_compress_sample(&c->status[ 0], *samples++) << 4;
738
264620
                nibble |= adpcm_ms_compress_sample(&c->status[st], *samples++);
739
264620
                *dst++  = nibble;
740
            }
741
        }
742
524
        break;
743
540
    case AV_CODEC_ID_ADPCM_YAMAHA:
744
540
        n = frame->nb_samples / 2;
745
540
        if (avctx->trellis > 0) {
746
259
            if (!(buf = av_malloc(2 * n * 2)))
747
                return AVERROR(ENOMEM);
748
259
            n *= 2;
749
259
            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
259
                adpcm_compress_trellis(avctx, samples,     buf,
756
                                       &c->status[0], n, avctx->channels);
757
259
                adpcm_compress_trellis(avctx, samples + 1, buf + n,
758
                                       &c->status[1], n, avctx->channels);
759
265475
                for (i = 0; i < n; i++)
760
265216
                    *dst++ = buf[i] | (buf[n + i] << 4);
761
            }
762
259
            av_free(buf);
763
        } else
764
288025
            for (n *= avctx->channels; n > 0; n--) {
765
                int nibble;
766
287744
                nibble  = adpcm_yamaha_compress_sample(&c->status[ 0], *samples++);
767
287744
                nibble |= adpcm_yamaha_compress_sample(&c->status[st], *samples++) << 4;
768
287744
                *dst++  = nibble;
769
            }
770
540
        break;
771
259
    case AV_CODEC_ID_ADPCM_IMA_APM:
772
    {
773
        PutBitContext pb;
774
259
        init_put_bits(&pb, dst, pkt_size);
775
776
259
        av_assert0(avctx->trellis == 0);
777
778
132559
        for (n = frame->nb_samples / 2; n > 0; n--) {
779
396900
            for (ch = 0; ch < avctx->channels; ch++) {
780
264600
                put_bits(&pb, 4, adpcm_ima_qt_compress_sample(c->status + ch, *samples++));
781
264600
                put_bits(&pb, 4, adpcm_ima_qt_compress_sample(c->status + ch, samples[st]));
782
            }
783
132300
            samples += avctx->channels;
784
        }
785
786
259
        flush_put_bits(&pb);
787
259
        break;
788
    }
789
8269
    case AV_CODEC_ID_ADPCM_ARGO:
790
    {
791
        PutBitContext pb;
792
8269
        init_put_bits(&pb, dst, pkt_size);
793
794
8269
        av_assert0(frame->nb_samples == 32);
795
796
24807
        for (ch = 0; ch < avctx->channels; ch++) {
797
16538
            int64_t error  = INT64_MAX, tmperr = INT64_MAX;
798
16538
            int     shift  = 2, flag = 0;
799
16538
            int     saved1 = c->status[ch].sample1;
800
16538
            int     saved2 = c->status[ch].sample2;
801
802
            /* Find the optimal coefficients, bail early if we find a perfect result. */
803

271531
            for (int s = 2; s < 18 && tmperr != 0; s++) {
804

764734
                for (int f = 0; f < 2 && tmperr != 0; f++) {
805
509741
                    c->status[ch].sample1 = saved1;
806
509741
                    c->status[ch].sample2 = saved2;
807
509741
                    tmperr = adpcm_argo_compress_block(c->status + ch, NULL, samples_p[ch],
808
                                                       frame->nb_samples, s, f);
809
509741
                    if (tmperr < error) {
810
75397
                        shift = s;
811
75397
                        flag  = f;
812
75397
                        error = tmperr;
813
                    }
814
                }
815
            }
816
817
            /* Now actually do the encode. */
818
16538
            c->status[ch].sample1 = saved1;
819
16538
            c->status[ch].sample2 = saved2;
820
16538
            adpcm_argo_compress_block(c->status + ch, &pb, samples_p[ch],
821
                                      frame->nb_samples, shift, flag);
822
        }
823
824
8269
        flush_put_bits(&pb);
825
8269
        break;
826
    }
827
    default:
828
        return AVERROR(EINVAL);
829
    }
830
831
18903
    avpkt->size = pkt_size;
832
18903
    *got_packet_ptr = 1;
833
18903
    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");