2 * Copyright (c) 2001-2003 The FFmpeg Project
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)
8 * This file is part of FFmpeg.
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.
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.
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
27 #include "bytestream.h"
29 #include "adpcm_data.h"
35 * See ADPCM decoder reference documents for codec information.
38 typedef struct TrellisPath
{
43 typedef struct TrellisNode
{
51 typedef struct ADPCMEncodeContext
{
52 ADPCMChannelStatus status
[6];
54 TrellisNode
*node_buf
;
55 TrellisNode
**nodep_buf
;
56 uint8_t *trellis_hash
;
59 #define FREEZE_INTERVAL 128
61 static av_cold
int adpcm_encode_close(AVCodecContext
*avctx
);
63 static av_cold
int adpcm_encode_init(AVCodecContext
*avctx
)
65 ADPCMEncodeContext
*s
= avctx
->priv_data
;
68 int ret
= AVERROR(ENOMEM
);
70 if (avctx
->channels
> 2) {
71 av_log(avctx
, AV_LOG_ERROR
, "only stereo or mono is supported\n");
72 return AVERROR(EINVAL
);
75 if (avctx
->trellis
&& (unsigned)avctx
->trellis
> 16U) {
76 av_log(avctx
, AV_LOG_ERROR
, "invalid trellis size\n");
77 return AVERROR(EINVAL
);
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
);
93 avctx
->bits_per_coded_sample
= av_get_bits_per_sample(avctx
->codec
->id
);
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;
106 case AV_CODEC_ID_ADPCM_IMA_QT
:
107 avctx
->frame_size
= 64;
108 avctx
->block_align
= 34 * avctx
->channels
;
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
)))
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);
127 case AV_CODEC_ID_ADPCM_YAMAHA
:
128 avctx
->frame_size
= BLKSIZE
* 2 / avctx
->channels
;
129 avctx
->block_align
= BLKSIZE
;
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, "
137 ret
= AVERROR(EINVAL
);
140 avctx
->frame_size
= 512 * (avctx
->sample_rate
/ 11025);
143 ret
= AVERROR(EINVAL
);
149 adpcm_encode_close(avctx
);
153 static av_cold
int adpcm_encode_close(AVCodecContext
*avctx
)
155 ADPCMEncodeContext
*s
= avctx
->priv_data
;
157 av_freep(&s
->node_buf
);
158 av_freep(&s
->nodep_buf
);
159 av_freep(&s
->trellis_hash
);
165 static inline uint8_t adpcm_ima_compress_sample(ADPCMChannelStatus
*c
,
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);
178 static inline uint8_t adpcm_ima_qt_compress_sample(ADPCMChannelStatus
*c
,
181 int delta
= sample
- c
->prev_sample
;
182 int diff
, step
= ff_adpcm_step_table
[c
->step_index
];
183 int nibble
= 8*(delta
< 0);
186 diff
= delta
+ (step
>> 3);
205 c
->prev_sample
-= diff
;
207 c
->prev_sample
+= diff
;
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);
215 static inline uint8_t adpcm_ms_compress_sample(ADPCMChannelStatus
*c
,
218 int predictor
, nibble
, bias
;
220 predictor
= (((c
->sample1
) * (c
->coeff1
)) +
221 (( c
->sample2
) * (c
->coeff2
))) / 64;
223 nibble
= sample
- predictor
;
225 bias
= c
->idelta
/ 2;
227 bias
= -c
->idelta
/ 2;
229 nibble
= (nibble
+ bias
) / c
->idelta
;
230 nibble
= av_clip(nibble
, -8, 7) & 0x0F;
232 predictor
+= ((nibble
& 0x08) ? (nibble
- 0x10) : nibble
) * c
->idelta
;
234 c
->sample2
= c
->sample1
;
235 c
->sample1
= av_clip_int16(predictor
);
237 c
->idelta
= (ff_adpcm_AdaptationTable
[nibble
] * c
->idelta
) >> 8;
244 static inline uint8_t adpcm_yamaha_compress_sample(ADPCMChannelStatus
*c
,
254 delta
= sample
- c
->predictor
;
256 nibble
= FFMIN(7, abs(delta
) * 4 / c
->step
) + (delta
< 0) * 8;
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);
266 static void adpcm_compress_trellis(AVCodecContext
*avctx
,
267 const int16_t *samples
, uint8_t *dst
,
268 ADPCMChannelStatus
*c
, int n
, int stride
)
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
));
283 memset(nodep_buf
, 0, 2 * frontier
* sizeof(*nodep_buf
));
284 nodes
[0] = node_buf
+ frontier
;
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
) {
298 nodes
[0]->step
= 127;
299 nodes
[0]->sample1
= 0;
301 nodes
[0]->step
= c
->step
;
302 nodes
[0]->sample1
= c
->predictor
;
306 for (i
= 0; i
< n
; i
++) {
307 TrellisNode
*t
= node_buf
+ frontier
*(i
&1);
309 int sample
= samples
[i
* stride
];
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
;
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)\
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)\
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)\
356 if (heap_pos < frontier) {\
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)\
368 u = nodes_next[pos];\
370 av_assert1(pathn < FREEZE_INTERVAL << avctx->trellis);\
372 nodes_next[pos] = u;\
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. */\
384 int parent = (pos - 1) >> 1;\
385 if (nodes_next[parent]->ssd <= ssd)\
387 FFSWAP(TrellisNode*, nodes_next[parent], nodes_next[pos]);\
391 STORE_NODE(ms
, FFMAX(16,
392 (ff_adpcm_AdaptationTable
[nibble
] * step
) >> 8));
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);\
403 nmin--; /* distinguish -0 from +0 */\
406 for (nidx = nmin; nidx <= nmax; nidx++) {\
407 const int nibble = nidx < 0 ? 7 - nidx : nidx;\
408 int dec_sample = predictor +\
410 ff_adpcm_yamaha_difflookup[nibble]) / 8;\
411 STORE_NODE(NAME, STEP_INDEX);\
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,
429 if (generation
== 255) {
430 memset(hash
, 0xff, 65536 * sizeof(*hash
));
435 if (nodes
[0]->ssd
> (1 << 28)) {
436 for (j
= 1; j
< frontier
&& nodes
[j
]; j
++)
437 nodes
[j
]->ssd
-= nodes
[0]->ssd
;
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
--) {
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
*));
457 p
= &paths
[nodes
[0]->path
];
458 for (i
= n
- 1; i
> froze
; i
--) {
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
;
471 static int adpcm_encode_frame(AVCodecContext
*avctx
, AVPacket
*avpkt
,
472 const AVFrame
*frame
, int *got_packet_ptr
)
474 int n
, i
, ch
, st
, pkt_size
, ret
;
475 const int16_t *samples
;
478 ADPCMEncodeContext
*c
= avctx
->priv_data
;
481 samples
= (const int16_t *)frame
->data
[0];
482 samples_p
= (int16_t **)frame
->extended_data
;
483 st
= avctx
->channels
== 2;
485 if (avctx
->codec_id
== AV_CODEC_ID_ADPCM_SWF
)
486 pkt_size
= (2 + avctx
->channels
* (22 + 4 * (frame
->nb_samples
- 1)) + 7) / 8;
488 pkt_size
= avctx
->block_align
;
489 if ((ret
= ff_alloc_packet2(avctx
, avpkt
, pkt_size
)) < 0)
493 switch(avctx
->codec
->id
) {
494 case AV_CODEC_ID_ADPCM_IMA_WAV
:
498 blocks
= (frame
->nb_samples
- 1) / 8;
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 */
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
],
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);
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;
541 case AV_CODEC_ID_ADPCM_IMA_QT
:
544 init_put_bits(&pb
, dst
, pkt_size
* 8);
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) {
552 adpcm_compress_trellis(avctx
, &samples_p
[ch
][0], buf
, status
,
554 for (i
= 0; i
< 64; i
++)
555 put_bits(&pb
, 4, buf
[i
^ 1]);
556 status
->prev_sample
= status
->predictor
;
558 for (i
= 0; i
< 64; i
+= 2) {
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
);
571 case AV_CODEC_ID_ADPCM_SWF
:
574 init_put_bits(&pb
, dst
, pkt_size
* 8);
576 n
= frame
->nb_samples
- 1;
578 // store AdpcmCodeSize
579 put_bits(&pb
, 2, 2); // set 4-bit flash adpcm format
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
];
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
,
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
]);
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]));
616 case AV_CODEC_ID_ADPCM_MS
:
617 for (i
= 0; i
< avctx
->channels
; i
++) {
620 c
->status
[i
].coeff1
= ff_adpcm_AdaptCoeff1
[predictor
];
621 c
->status
[i
].coeff2
= ff_adpcm_AdaptCoeff2
[predictor
];
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
);
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
);
634 for (i
= 0; i
< avctx
->channels
; i
++)
635 bytestream_put_le16(&dst
, c
->status
[i
].sample2
);
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
,
643 for (i
= 0; i
< n
; i
+= 2)
644 *dst
++ = (buf
[i
] << 4) | buf
[i
+ 1];
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
];
655 for (i
= 7 * avctx
->channels
; i
< avctx
->block_align
; i
++) {
657 nibble
= adpcm_ms_compress_sample(&c
->status
[ 0], *samples
++) << 4;
658 nibble
|= adpcm_ms_compress_sample(&c
->status
[st
], *samples
++);
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
);
668 if (avctx
->channels
== 1) {
669 adpcm_compress_trellis(avctx
, samples
, buf
, &c
->status
[0], n
,
671 for (i
= 0; i
< n
; i
+= 2)
672 *dst
++ = buf
[i
] | (buf
[i
+ 1] << 4);
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);
683 for (n
*= avctx
->channels
; n
> 0; n
--) {
685 nibble
= adpcm_yamaha_compress_sample(&c
->status
[ 0], *samples
++);
686 nibble
|= adpcm_yamaha_compress_sample(&c
->status
[st
], *samples
++) << 4;
691 return AVERROR(EINVAL
);
694 avpkt
->size
= pkt_size
;
698 return AVERROR(ENOMEM
);
701 static const enum AVSampleFormat sample_fmts
[] = {
702 AV_SAMPLE_FMT_S16
, AV_SAMPLE_FMT_NONE
705 static const enum AVSampleFormat sample_fmts_p
[] = {
706 AV_SAMPLE_FMT_S16P
, AV_SAMPLE_FMT_NONE
709 #define ADPCM_ENCODER(id_, name_, sample_fmts_, long_name_) \
710 AVCodec ff_ ## name_ ## _encoder = { \
712 .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
713 .type = AVMEDIA_TYPE_AUDIO, \
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_, \
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");