* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "avcodec.h"
-#include "bitstream.h"
+#include "get_bits.h"
+#include "put_bits.h"
#include "bytestream.h"
/**
- * @file libavcodec/adpcm.c
+ * @file
* ADPCM codecs.
* First version by Francois Revol (revol@free.fr)
* Fringe ADPCM codecs (e.g., DK3, DK4, Westwood)
768, 614, 512, 409, 307, 230, 230, 230
};
+/** Divided by 4 to fit in 8-bit integers */
static const uint8_t AdaptCoeff1[] = {
64, 128, 0, 48, 60, 115, 98
};
+/** Divided by 4 to fit in 8-bit integers */
static const int8_t AdaptCoeff2[] = {
0, -64, 0, 16, 0, -52, -58
};
int idelta;
} ADPCMChannelStatus;
+typedef struct TrellisPath {
+ int nibble;
+ int prev;
+} TrellisPath;
+
+typedef struct TrellisNode {
+ uint32_t ssd;
+ int path;
+ int sample1;
+ int sample2;
+ int step;
+} TrellisNode;
+
typedef struct ADPCMContext {
ADPCMChannelStatus status[6];
+ TrellisPath *paths;
+ TrellisNode *node_buf;
+ TrellisNode **nodep_buf;
+ uint8_t *trellis_hash;
} ADPCMContext;
+#define FREEZE_INTERVAL 128
+
/* XXX: implement encoding */
#if CONFIG_ENCODERS
-static int adpcm_encode_init(AVCodecContext *avctx)
+static av_cold int adpcm_encode_init(AVCodecContext *avctx)
{
+ ADPCMContext *s = avctx->priv_data;
+ uint8_t *extradata;
+ int i;
if (avctx->channels > 2)
return -1; /* only stereo or mono =) */
return -1;
}
+ if (avctx->trellis) {
+ int frontier = 1 << avctx->trellis;
+ int max_paths = frontier * FREEZE_INTERVAL;
+ FF_ALLOC_OR_GOTO(avctx, s->paths, max_paths * sizeof(*s->paths), error);
+ FF_ALLOC_OR_GOTO(avctx, s->node_buf, 2 * frontier * sizeof(*s->node_buf), error);
+ FF_ALLOC_OR_GOTO(avctx, s->nodep_buf, 2 * frontier * sizeof(*s->nodep_buf), error);
+ FF_ALLOC_OR_GOTO(avctx, s->trellis_hash, 65536 * sizeof(*s->trellis_hash), error);
+ }
+
switch(avctx->codec->id) {
case CODEC_ID_ADPCM_IMA_WAV:
avctx->frame_size = (BLKSIZE - 4 * avctx->channels) * 8 / (4 * avctx->channels) + 1; /* each 16 bits sample gives one nibble */
avctx->frame_size = (BLKSIZE - 7 * avctx->channels) * 2 / avctx->channels + 2; /* each 16 bits sample gives one nibble */
/* and we have 7 bytes per channel overhead */
avctx->block_align = BLKSIZE;
+ avctx->extradata_size = 32;
+ extradata = avctx->extradata = av_malloc(avctx->extradata_size);
+ if (!extradata)
+ return AVERROR(ENOMEM);
+ bytestream_put_le16(&extradata, avctx->frame_size);
+ bytestream_put_le16(&extradata, 7); /* wNumCoef */
+ for (i = 0; i < 7; i++) {
+ bytestream_put_le16(&extradata, AdaptCoeff1[i] * 4);
+ bytestream_put_le16(&extradata, AdaptCoeff2[i] * 4);
+ }
break;
case CODEC_ID_ADPCM_YAMAHA:
avctx->frame_size = BLKSIZE * avctx->channels;
avctx->sample_rate != 22050 &&
avctx->sample_rate != 44100) {
av_log(avctx, AV_LOG_ERROR, "Sample rate must be 11025, 22050 or 44100\n");
- return -1;
+ goto error;
}
avctx->frame_size = 512 * (avctx->sample_rate / 11025);
break;
default:
- return -1;
- break;
+ goto error;
}
avctx->coded_frame= avcodec_alloc_frame();
avctx->coded_frame->key_frame= 1;
return 0;
+error:
+ av_freep(&s->paths);
+ av_freep(&s->node_buf);
+ av_freep(&s->nodep_buf);
+ av_freep(&s->trellis_hash);
+ return -1;
}
-static int adpcm_encode_close(AVCodecContext *avctx)
+static av_cold int adpcm_encode_close(AVCodecContext *avctx)
{
+ ADPCMContext *s = avctx->priv_data;
av_freep(&avctx->coded_frame);
+ av_freep(&s->paths);
+ av_freep(&s->node_buf);
+ av_freep(&s->nodep_buf);
+ av_freep(&s->trellis_hash);
return 0;
}
return nibble;
}
-typedef struct TrellisPath {
- int nibble;
- int prev;
-} TrellisPath;
-
-typedef struct TrellisNode {
- uint32_t ssd;
- int path;
- int sample1;
- int sample2;
- int step;
-} TrellisNode;
-
static void adpcm_compress_trellis(AVCodecContext *avctx, const short *samples,
uint8_t *dst, ADPCMChannelStatus *c, int n)
{
-#define FREEZE_INTERVAL 128
//FIXME 6% faster if frontier is a compile-time constant
+ ADPCMContext *s = avctx->priv_data;
const int frontier = 1 << avctx->trellis;
const int stride = avctx->channels;
const int version = avctx->codec->id;
- const int max_paths = frontier*FREEZE_INTERVAL;
- TrellisPath paths[max_paths], *p;
- TrellisNode node_buf[2][frontier];
- TrellisNode *nodep_buf[2][frontier];
- TrellisNode **nodes = nodep_buf[0]; // nodes[] is always sorted by .ssd
- TrellisNode **nodes_next = nodep_buf[1];
- int pathn = 0, froze = -1, i, j, k;
-
- assert(!(max_paths&(max_paths-1)));
-
- memset(nodep_buf, 0, sizeof(nodep_buf));
- nodes[0] = &node_buf[1][0];
+ TrellisPath *paths = s->paths, *p;
+ TrellisNode *node_buf = s->node_buf;
+ TrellisNode **nodep_buf = s->nodep_buf;
+ TrellisNode **nodes = nodep_buf; // nodes[] is always sorted by .ssd
+ TrellisNode **nodes_next = nodep_buf + frontier;
+ int pathn = 0, froze = -1, i, j, k, generation = 0;
+ uint8_t *hash = s->trellis_hash;
+ memset(hash, 0xff, 65536 * sizeof(*hash));
+
+ memset(nodep_buf, 0, 2 * frontier * sizeof(*nodep_buf));
+ nodes[0] = node_buf + frontier;
nodes[0]->ssd = 0;
nodes[0]->path = 0;
nodes[0]->step = c->step_index;
}
for(i=0; i<n; i++) {
- TrellisNode *t = node_buf[i&1];
+ TrellisNode *t = node_buf + frontier*(i&1);
TrellisNode **u;
int sample = samples[i*stride];
+ int heap_pos = 0;
memset(nodes_next, 0, frontier*sizeof(TrellisNode*));
for(j=0; j<frontier && nodes[j]; j++) {
- // higher j have higher ssd already, so they're unlikely to use a suboptimal next sample too
+ // higher j have higher ssd already, so they're likely to yield a suboptimal next sample too
const int range = (j < frontier/2) ? 1 : 0;
const int step = nodes[j]->step;
int nidx;
#define STORE_NODE(NAME, STEP_INDEX)\
int d;\
uint32_t ssd;\
+ int pos;\
+ TrellisNode *u;\
+ uint8_t *h;\
dec_sample = av_clip_int16(dec_sample);\
d = sample - dec_sample;\
ssd = nodes[j]->ssd + d*d;\
- if(nodes_next[frontier-1] && ssd >= nodes_next[frontier-1]->ssd)\
- continue;\
+ /* Check for wraparound, skip such samples completely. \
+ * Note, changing ssd to a 64 bit variable would be \
+ * simpler, avoiding this check, but it's slower on \
+ * x86 32 bit at the moment. */\
+ if (ssd < nodes[j]->ssd)\
+ goto next_##NAME;\
/* Collapse any two states with the same previous sample value. \
* One could also distinguish states by step and by 2nd to last
- * sample, but the effects of that are negligible. */\
- for(k=0; k<frontier && nodes_next[k]; k++) {\
- if(dec_sample == nodes_next[k]->sample1) {\
- assert(ssd >= nodes_next[k]->ssd);\
+ * sample, but the effects of that are negligible.
+ * Since nodes in the previous generation are iterated
+ * through a heap, they're roughly ordered from better to
+ * worse, but not strictly ordered. Therefore, an earlier
+ * node with the same sample value is better in most cases
+ * (and thus the current is skipped), but not strictly
+ * in all cases. Only skipping samples where ssd >=
+ * ssd of the earlier node with the same sample gives
+ * slightly worse quality, though, for some reason. */ \
+ h = &hash[(uint16_t) dec_sample];\
+ if (*h == generation)\
+ goto next_##NAME;\
+ if (heap_pos < frontier) {\
+ pos = heap_pos++;\
+ } else {\
+ /* Try to replace one of the leaf nodes with the new \
+ * one, but try a different slot each time. */\
+ pos = (frontier >> 1) + (heap_pos & ((frontier >> 1) - 1));\
+ if (ssd > nodes_next[pos]->ssd)\
goto next_##NAME;\
- }\
+ heap_pos++;\
+ }\
+ *h = generation;\
+ u = nodes_next[pos];\
+ if(!u) {\
+ assert(pathn < FREEZE_INTERVAL<<avctx->trellis);\
+ u = t++;\
+ nodes_next[pos] = u;\
+ u->path = pathn++;\
}\
- for(k=0; k<frontier; k++) {\
- if(!nodes_next[k] || ssd < nodes_next[k]->ssd) {\
- TrellisNode *u = nodes_next[frontier-1];\
- if(!u) {\
- assert(pathn < max_paths);\
- u = t++;\
- u->path = pathn++;\
- }\
- u->ssd = ssd;\
- u->step = STEP_INDEX;\
- u->sample2 = nodes[j]->sample1;\
- u->sample1 = dec_sample;\
- paths[u->path].nibble = nibble;\
- paths[u->path].prev = nodes[j]->path;\
- memmove(&nodes_next[k+1], &nodes_next[k], (frontier-k-1)*sizeof(TrellisNode*));\
- nodes_next[k] = u;\
+ u->ssd = ssd;\
+ u->step = STEP_INDEX;\
+ u->sample2 = nodes[j]->sample1;\
+ u->sample1 = dec_sample;\
+ paths[u->path].nibble = nibble;\
+ paths[u->path].prev = nodes[j]->path;\
+ /* Sift the newly inserted node up in the heap to \
+ * restore the heap property. */\
+ while (pos > 0) {\
+ int parent = (pos - 1) >> 1;\
+ if (nodes_next[parent]->ssd <= ssd)\
break;\
- }\
+ FFSWAP(TrellisNode*, nodes_next[parent], nodes_next[pos]);\
+ pos = parent;\
}\
next_##NAME:;
STORE_NODE(ms, FFMAX(16, (AdaptationTable[nibble] * step) >> 8));
nodes = nodes_next;
nodes_next = u;
+ generation++;
+ if (generation == 255) {
+ memset(hash, 0xff, 65536 * sizeof(*hash));
+ generation = 0;
+ }
+
// prevent overflow
if(nodes[0]->ssd > (1<<28)) {
for(j=1; j<frontier && nodes[j]; j++)
short *samples;
unsigned char *dst;
ADPCMContext *c = avctx->priv_data;
+ uint8_t *buf;
dst = frame;
samples = (short *)data;
/* stereo: 4 bytes (8 samples) for left, 4 bytes for right, 4 bytes left, ... */
if(avctx->trellis > 0) {
- uint8_t buf[2][n*8];
- adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n*8);
+ FF_ALLOC_OR_GOTO(avctx, buf, 2*n*8, error);
+ adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n*8);
if(avctx->channels == 2)
- adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n*8);
+ adpcm_compress_trellis(avctx, samples+1, buf + n*8, &c->status[1], n*8);
for(i=0; i<n; i++) {
- *dst++ = buf[0][8*i+0] | (buf[0][8*i+1] << 4);
- *dst++ = buf[0][8*i+2] | (buf[0][8*i+3] << 4);
- *dst++ = buf[0][8*i+4] | (buf[0][8*i+5] << 4);
- *dst++ = buf[0][8*i+6] | (buf[0][8*i+7] << 4);
+ *dst++ = buf[8*i+0] | (buf[8*i+1] << 4);
+ *dst++ = buf[8*i+2] | (buf[8*i+3] << 4);
+ *dst++ = buf[8*i+4] | (buf[8*i+5] << 4);
+ *dst++ = buf[8*i+6] | (buf[8*i+7] << 4);
if (avctx->channels == 2) {
- *dst++ = buf[1][8*i+0] | (buf[1][8*i+1] << 4);
- *dst++ = buf[1][8*i+2] | (buf[1][8*i+3] << 4);
- *dst++ = buf[1][8*i+4] | (buf[1][8*i+5] << 4);
- *dst++ = buf[1][8*i+6] | (buf[1][8*i+7] << 4);
+ uint8_t *buf1 = buf + n*8;
+ *dst++ = buf1[8*i+0] | (buf1[8*i+1] << 4);
+ *dst++ = buf1[8*i+2] | (buf1[8*i+3] << 4);
+ *dst++ = buf1[8*i+4] | (buf1[8*i+5] << 4);
+ *dst++ = buf1[8*i+6] | (buf1[8*i+7] << 4);
}
}
+ av_free(buf);
} else
for (; n>0; n--) {
*dst = adpcm_ima_compress_sample(&c->status[0], samples[0]);
}
}
+ flush_put_bits(&pb);
dst += put_bits_count(&pb)>>3;
break;
}
}
if(avctx->trellis > 0) {
- uint8_t buf[2][n];
- adpcm_compress_trellis(avctx, samples+2, buf[0], &c->status[0], n);
+ FF_ALLOC_OR_GOTO(avctx, buf, 2*n, error);
+ adpcm_compress_trellis(avctx, samples+2, buf, &c->status[0], n);
if (avctx->channels == 2)
- adpcm_compress_trellis(avctx, samples+3, buf[1], &c->status[1], n);
+ adpcm_compress_trellis(avctx, samples+3, buf+n, &c->status[1], n);
for(i=0; i<n; i++) {
- put_bits(&pb, 4, buf[0][i]);
+ put_bits(&pb, 4, buf[i]);
if (avctx->channels == 2)
- put_bits(&pb, 4, buf[1][i]);
+ put_bits(&pb, 4, buf[n+i]);
}
+ av_free(buf);
} else {
for (i=1; i<avctx->frame_size; i++) {
put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels*i]));
if(avctx->trellis > 0) {
int n = avctx->block_align - 7*avctx->channels;
- uint8_t buf[2][n];
+ FF_ALLOC_OR_GOTO(avctx, buf, 2*n, error);
if(avctx->channels == 1) {
- n *= 2;
- adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
+ adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n);
for(i=0; i<n; i+=2)
- *dst++ = (buf[0][i] << 4) | buf[0][i+1];
+ *dst++ = (buf[i] << 4) | buf[i+1];
} else {
- adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
- adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n);
+ adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n);
+ adpcm_compress_trellis(avctx, samples+1, buf+n, &c->status[1], n);
for(i=0; i<n; i++)
- *dst++ = (buf[0][i] << 4) | buf[1][i];
+ *dst++ = (buf[i] << 4) | buf[n+i];
}
+ av_free(buf);
} else
for(i=7*avctx->channels; i<avctx->block_align; i++) {
int nibble;
case CODEC_ID_ADPCM_YAMAHA:
n = avctx->frame_size / 2;
if(avctx->trellis > 0) {
- uint8_t buf[2][n*2];
+ FF_ALLOC_OR_GOTO(avctx, buf, 2*n*2, error);
n *= 2;
if(avctx->channels == 1) {
- adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
+ adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n);
for(i=0; i<n; i+=2)
- *dst++ = buf[0][i] | (buf[0][i+1] << 4);
+ *dst++ = buf[i] | (buf[i+1] << 4);
} else {
- adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
- adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n);
+ adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n);
+ adpcm_compress_trellis(avctx, samples+1, buf+n, &c->status[1], n);
for(i=0; i<n; i++)
- *dst++ = buf[0][i] | (buf[1][i] << 4);
+ *dst++ = buf[i] | (buf[n+i] << 4);
}
+ av_free(buf);
} else
- for (; n>0; n--) {
- for(i = 0; i < avctx->channels; i++) {
+ for (n *= avctx->channels; n>0; n--) {
int nibble;
- nibble = adpcm_yamaha_compress_sample(&c->status[i], samples[i]);
- nibble |= adpcm_yamaha_compress_sample(&c->status[i], samples[i+avctx->channels]) << 4;
+ nibble = adpcm_yamaha_compress_sample(&c->status[ 0], *samples++);
+ nibble |= adpcm_yamaha_compress_sample(&c->status[st], *samples++) << 4;
*dst++ = nibble;
}
- samples += 2 * avctx->channels;
- }
break;
default:
+ error:
return -1;
}
return dst - frame;
case CODEC_ID_ADPCM_CT:
c->status[0].step = c->status[1].step = 511;
break;
+ case CODEC_ID_ADPCM_IMA_WAV:
+ if (avctx->bits_per_coded_sample != 4) {
+ av_log(avctx, AV_LOG_ERROR, "Only 4-bit ADPCM IMA WAV files are supported\n");
+ return -1;
+ }
+ break;
case CODEC_ID_ADPCM_IMA_WS:
if (avctx->extradata && avctx->extradata_size == 2 * 4) {
c->status[0].predictor = AV_RL32(avctx->extradata);
default:
break;
}
- avctx->sample_fmt = SAMPLE_FMT_S16;
+ avctx->sample_fmt = AV_SAMPLE_FMT_S16;
return 0;
}
static int adpcm_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
- const uint8_t *buf, int buf_size)
+ AVPacket *avpkt)
{
+ const uint8_t *buf = avpkt->data;
+ int buf_size = avpkt->size;
ADPCMContext *c = avctx->priv_data;
ADPCMChannelStatus *cs;
int n, m, channel, i;
}
break;
case CODEC_ID_ADPCM_EA:
- samples_in_chunk = AV_RL32(src);
- if (samples_in_chunk >= ((buf_size - 12) * 2)) {
+ if (buf_size < 4 || AV_RL32(src) >= ((buf_size - 12) * 2)) {
src += buf_size;
break;
}
+ samples_in_chunk = AV_RL32(src);
src += 4;
current_left_sample = (int16_t)bytestream_get_le16(&src);
previous_left_sample = (int16_t)bytestream_get_le16(&src);
*samples++ = (unsigned short)current_right_sample;
}
}
+
+ if (src - buf == buf_size - 2)
+ src += 2; // Skip terminating 0x0000
+
break;
case CODEC_ID_ADPCM_EA_MAXIS_XA:
for(channel = 0; channel < avctx->channels; channel++) {
unsigned int channel;
uint16_t *samplesC;
const uint8_t *srcC;
+ const uint8_t *src_end = buf + buf_size;
samples_in_chunk = (big_endian ? bytestream_get_be32(&src)
: bytestream_get_le32(&src)) / 28;
}
for (channel=0; channel<avctx->channels; channel++) {
- srcC = src + (avctx->channels-channel) * 4;
- srcC += (big_endian ? bytestream_get_be32(&src)
- : bytestream_get_le32(&src));
+ int32_t offset = (big_endian ? bytestream_get_be32(&src)
+ : bytestream_get_le32(&src))
+ + (avctx->channels-channel-1) * 4;
+
+ if ((offset < 0) || (offset >= src_end - src - 4)) break;
+ srcC = src + offset;
samplesC = samples + channel;
if (avctx->codec->id == CODEC_ID_ADPCM_EA_R1) {
for (count1=0; count1<samples_in_chunk; count1++) {
if (*srcC == 0xEE) { /* only seen in R2 and R3 */
srcC++;
+ if (srcC > src_end - 30*2) break;
current_sample = (int16_t)bytestream_get_be16(&srcC);
previous_sample = (int16_t)bytestream_get_be16(&srcC);
coeff2 = ea_adpcm_table[(*srcC>>4) + 4];
shift = (*srcC++ & 0x0F) + 8;
+ if (srcC > src_end - 14) break;
for (count2=0; count2<28; count2++) {
if (count2 & 1)
next_sample = (int32_t)((*srcC++ & 0x0F) << 28) >> shift;
#if CONFIG_ENCODERS
#define ADPCM_ENCODER(id,name,long_name_) \
-AVCodec name ## _encoder = { \
+AVCodec ff_ ## name ## _encoder = { \
#name, \
- CODEC_TYPE_AUDIO, \
+ AVMEDIA_TYPE_AUDIO, \
id, \
sizeof(ADPCMContext), \
adpcm_encode_init, \
adpcm_encode_frame, \
adpcm_encode_close, \
NULL, \
- .sample_fmts = (enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE}, \
+ .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, \
.long_name = NULL_IF_CONFIG_SMALL(long_name_), \
};
#else
#if CONFIG_DECODERS
#define ADPCM_DECODER(id,name,long_name_) \
-AVCodec name ## _decoder = { \
+AVCodec ff_ ## name ## _decoder = { \
#name, \
- CODEC_TYPE_AUDIO, \
+ AVMEDIA_TYPE_AUDIO, \
id, \
sizeof(ADPCMContext), \
adpcm_decode_init, \
ADPCM_ENCODER(id,name,long_name_) ADPCM_DECODER(id,name,long_name_)
/* Note: Do not forget to add new entries to the Makefile as well. */
-ADPCM_DECODER(CODEC_ID_ADPCM_4XM, adpcm_4xm, "4X Movie ADPCM");
-ADPCM_DECODER(CODEC_ID_ADPCM_CT, adpcm_ct, "Creative Technology ADPCM");
-ADPCM_DECODER(CODEC_ID_ADPCM_EA, adpcm_ea, "Electronic Arts ADPCM");
-ADPCM_DECODER(CODEC_ID_ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa, "Electronic Arts Maxis CDROM XA ADPCM");
-ADPCM_DECODER(CODEC_ID_ADPCM_EA_R1, adpcm_ea_r1, "Electronic Arts R1 ADPCM");
-ADPCM_DECODER(CODEC_ID_ADPCM_EA_R2, adpcm_ea_r2, "Electronic Arts R2 ADPCM");
-ADPCM_DECODER(CODEC_ID_ADPCM_EA_R3, adpcm_ea_r3, "Electronic Arts R3 ADPCM");
-ADPCM_DECODER(CODEC_ID_ADPCM_EA_XAS, adpcm_ea_xas, "Electronic Arts XAS ADPCM");
-ADPCM_DECODER(CODEC_ID_ADPCM_IMA_AMV, adpcm_ima_amv, "IMA AMV ADPCM");
-ADPCM_DECODER(CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3, "IMA Duck DK3 ADPCM");
-ADPCM_DECODER(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4, "IMA Duck DK4 ADPCM");
-ADPCM_DECODER(CODEC_ID_ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs, "IMA Electronic Arts EACS ADPCM");
-ADPCM_DECODER(CODEC_ID_ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead, "IMA Electronic Arts SEAD ADPCM");
-ADPCM_DECODER(CODEC_ID_ADPCM_IMA_ISS, adpcm_ima_iss, "IMA Funcom ISS ADPCM");
-ADPCM_CODEC (CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt, "IMA QuickTime ADPCM");
-ADPCM_DECODER(CODEC_ID_ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg, "IMA Loki SDL MJPEG ADPCM");
-ADPCM_CODEC (CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav, "IMA Wav ADPCM");
-ADPCM_DECODER(CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws, "IMA Westwood ADPCM");
-ADPCM_CODEC (CODEC_ID_ADPCM_MS, adpcm_ms, "Microsoft ADPCM");
-ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_2, adpcm_sbpro_2, "Sound Blaster Pro 2-bit ADPCM");
-ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_3, adpcm_sbpro_3, "Sound Blaster Pro 2.6-bit ADPCM");
-ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_4, adpcm_sbpro_4, "Sound Blaster Pro 4-bit ADPCM");
-ADPCM_CODEC (CODEC_ID_ADPCM_SWF, adpcm_swf, "Shockwave Flash ADPCM");
-ADPCM_DECODER(CODEC_ID_ADPCM_THP, adpcm_thp, "Nintendo Gamecube THP ADPCM");
-ADPCM_DECODER(CODEC_ID_ADPCM_XA, adpcm_xa, "CDROM XA ADPCM");
-ADPCM_CODEC (CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha, "Yamaha ADPCM");
+ADPCM_DECODER(CODEC_ID_ADPCM_4XM, adpcm_4xm, "ADPCM 4X Movie");
+ADPCM_DECODER(CODEC_ID_ADPCM_CT, adpcm_ct, "ADPCM Creative Technology");
+ADPCM_DECODER(CODEC_ID_ADPCM_EA, adpcm_ea, "ADPCM Electronic Arts");
+ADPCM_DECODER(CODEC_ID_ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa, "ADPCM Electronic Arts Maxis CDROM XA");
+ADPCM_DECODER(CODEC_ID_ADPCM_EA_R1, adpcm_ea_r1, "ADPCM Electronic Arts R1");
+ADPCM_DECODER(CODEC_ID_ADPCM_EA_R2, adpcm_ea_r2, "ADPCM Electronic Arts R2");
+ADPCM_DECODER(CODEC_ID_ADPCM_EA_R3, adpcm_ea_r3, "ADPCM Electronic Arts R3");
+ADPCM_DECODER(CODEC_ID_ADPCM_EA_XAS, adpcm_ea_xas, "ADPCM Electronic Arts XAS");
+ADPCM_DECODER(CODEC_ID_ADPCM_IMA_AMV, adpcm_ima_amv, "ADPCM IMA AMV");
+ADPCM_DECODER(CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3, "ADPCM IMA Duck DK3");
+ADPCM_DECODER(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4, "ADPCM IMA Duck DK4");
+ADPCM_DECODER(CODEC_ID_ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs, "ADPCM IMA Electronic Arts EACS");
+ADPCM_DECODER(CODEC_ID_ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead, "ADPCM IMA Electronic Arts SEAD");
+ADPCM_DECODER(CODEC_ID_ADPCM_IMA_ISS, adpcm_ima_iss, "ADPCM IMA Funcom ISS");
+ADPCM_CODEC (CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt, "ADPCM IMA QuickTime");
+ADPCM_DECODER(CODEC_ID_ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg, "ADPCM IMA Loki SDL MJPEG");
+ADPCM_CODEC (CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav, "ADPCM IMA WAV");
+ADPCM_DECODER(CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws, "ADPCM IMA Westwood");
+ADPCM_CODEC (CODEC_ID_ADPCM_MS, adpcm_ms, "ADPCM Microsoft");
+ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_2, adpcm_sbpro_2, "ADPCM Sound Blaster Pro 2-bit");
+ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_3, adpcm_sbpro_3, "ADPCM Sound Blaster Pro 2.6-bit");
+ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_4, adpcm_sbpro_4, "ADPCM Sound Blaster Pro 4-bit");
+ADPCM_CODEC (CODEC_ID_ADPCM_SWF, adpcm_swf, "ADPCM Shockwave Flash");
+ADPCM_DECODER(CODEC_ID_ADPCM_THP, adpcm_thp, "ADPCM Nintendo Gamecube THP");
+ADPCM_DECODER(CODEC_ID_ADPCM_XA, adpcm_xa, "ADPCM CDROM XA");
+ADPCM_CODEC (CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha, "ADPCM Yamaha");