-} ADPCMContext;
-
-/* XXX: implement encoding */
-
-#ifdef CONFIG_ENCODERS
-static int adpcm_encode_init(AVCodecContext *avctx)
-{
- if (avctx->channels > 2)
- return -1; /* only stereo or mono =) */
-
- if(avctx->trellis && (unsigned)avctx->trellis > 16U){
- av_log(avctx, AV_LOG_ERROR, "invalid trellis size\n");
- return -1;
- }
-
- 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 */
- /* and we have 4 bytes per channel overhead */
- avctx->block_align = BLKSIZE;
- /* seems frame_size isn't taken into account... have to buffer the samples :-( */
- break;
- case CODEC_ID_ADPCM_IMA_QT:
- avctx->frame_size = 64;
- avctx->block_align = 34 * avctx->channels;
- break;
- case CODEC_ID_ADPCM_MS:
- 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;
- break;
- case CODEC_ID_ADPCM_YAMAHA:
- avctx->frame_size = BLKSIZE * avctx->channels;
- avctx->block_align = BLKSIZE;
- break;
- case CODEC_ID_ADPCM_SWF:
- if (avctx->sample_rate != 11025 &&
- 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;
- }
- avctx->frame_size = 512 * (avctx->sample_rate / 11025);
- break;
- default:
- return -1;
- break;
- }
-
- avctx->coded_frame= avcodec_alloc_frame();
- avctx->coded_frame->key_frame= 1;
-
- return 0;
-}
-
-static int adpcm_encode_close(AVCodecContext *avctx)
-{
- av_freep(&avctx->coded_frame);
-
- return 0;
-}
-
-
-static inline unsigned char adpcm_ima_compress_sample(ADPCMChannelStatus *c, short sample)
-{
- int delta = sample - c->prev_sample;
- int nibble = FFMIN(7, abs(delta)*4/step_table[c->step_index]) + (delta<0)*8;
- c->prev_sample += ((step_table[c->step_index] * yamaha_difflookup[nibble]) / 8);
- c->prev_sample = av_clip_int16(c->prev_sample);
- c->step_index = av_clip(c->step_index + index_table[nibble], 0, 88);
- return nibble;
-}
-
-static inline unsigned char adpcm_ms_compress_sample(ADPCMChannelStatus *c, short sample)
-{
- int predictor, nibble, bias;
-
- predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64;
-
- nibble= sample - predictor;
- if(nibble>=0) bias= c->idelta/2;
- else bias=-c->idelta/2;
-
- nibble= (nibble + bias) / c->idelta;
- nibble= av_clip(nibble, -8, 7)&0x0F;
-
- predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
-
- c->sample2 = c->sample1;
- c->sample1 = av_clip_int16(predictor);
-
- c->idelta = (AdaptationTable[(int)nibble] * c->idelta) >> 8;
- if (c->idelta < 16) c->idelta = 16;
-
- return nibble;
-}
-
-static inline unsigned char adpcm_yamaha_compress_sample(ADPCMChannelStatus *c, short sample)
-{
- int nibble, delta;
-
- if(!c->step) {
- c->predictor = 0;
- c->step = 127;
- }
-
- delta = sample - c->predictor;
-
- nibble = FFMIN(7, abs(delta)*4/c->step) + (delta<0)*8;
-
- c->predictor += ((c->step * yamaha_difflookup[nibble]) / 8);
- c->predictor = av_clip_int16(c->predictor);
- c->step = (c->step * yamaha_indexscale[nibble]) >> 8;
- c->step = av_clip(c->step, 127, 24567);
-
- 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
- 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];
- nodes[0]->ssd = 0;
- nodes[0]->path = 0;
- nodes[0]->step = c->step_index;
- nodes[0]->sample1 = c->sample1;
- nodes[0]->sample2 = c->sample2;
- if((version == CODEC_ID_ADPCM_IMA_WAV) || (version == CODEC_ID_ADPCM_IMA_QT) || (version == CODEC_ID_ADPCM_SWF))
- nodes[0]->sample1 = c->prev_sample;
- if(version == CODEC_ID_ADPCM_MS)
- nodes[0]->step = c->idelta;
- if(version == CODEC_ID_ADPCM_YAMAHA) {
- if(c->step == 0) {
- nodes[0]->step = 127;
- nodes[0]->sample1 = 0;
- } else {
- nodes[0]->step = c->step;
- nodes[0]->sample1 = c->predictor;
- }
- }
-
- for(i=0; i<n; i++) {
- TrellisNode *t = node_buf[i&1];
- TrellisNode **u;
- int sample = samples[i*stride];
- 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
- const int range = (j < frontier/2) ? 1 : 0;
- const int step = nodes[j]->step;
- int nidx;
- if(version == CODEC_ID_ADPCM_MS) {
- const int predictor = ((nodes[j]->sample1 * c->coeff1) + (nodes[j]->sample2 * c->coeff2)) / 64;
- const int div = (sample - predictor) / step;
- const int nmin = av_clip(div-range, -8, 6);
- const int nmax = av_clip(div+range, -7, 7);
- for(nidx=nmin; nidx<=nmax; nidx++) {
- const int nibble = nidx & 0xf;
- int dec_sample = predictor + nidx * step;
-#define STORE_NODE(NAME, STEP_INDEX)\
- int d;\
- uint32_t ssd;\
- 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;\
- /* 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);\
- goto next_##NAME;\
- }\
- }\
- 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;\
- break;\
- }\
- }\
- next_##NAME:;
- STORE_NODE(ms, FFMAX(16, (AdaptationTable[nibble] * step) >> 8));
- }
- } else if((version == CODEC_ID_ADPCM_IMA_WAV)|| (version == CODEC_ID_ADPCM_IMA_QT)|| (version == CODEC_ID_ADPCM_SWF)) {
-#define LOOP_NODES(NAME, STEP_TABLE, STEP_INDEX)\
- const int predictor = nodes[j]->sample1;\
- const int div = (sample - predictor) * 4 / STEP_TABLE;\
- int nmin = av_clip(div-range, -7, 6);\
- int nmax = av_clip(div+range, -6, 7);\
- if(nmin<=0) nmin--; /* distinguish -0 from +0 */\
- if(nmax<0) nmax--;\
- for(nidx=nmin; nidx<=nmax; nidx++) {\
- const int nibble = nidx<0 ? 7-nidx : nidx;\
- int dec_sample = predictor + (STEP_TABLE * yamaha_difflookup[nibble]) / 8;\
- STORE_NODE(NAME, STEP_INDEX);\
- }
- LOOP_NODES(ima, step_table[step], av_clip(step + index_table[nibble], 0, 88));
- } else { //CODEC_ID_ADPCM_YAMAHA
- LOOP_NODES(yamaha, step, av_clip((step * yamaha_indexscale[nibble]) >> 8, 127, 24567));
-#undef LOOP_NODES
-#undef STORE_NODE
- }
- }
-
- u = nodes;
- nodes = nodes_next;
- nodes_next = u;
-
- // prevent overflow
- if(nodes[0]->ssd > (1<<28)) {
- for(j=1; j<frontier && nodes[j]; j++)
- nodes[j]->ssd -= nodes[0]->ssd;
- nodes[0]->ssd = 0;
- }
-
- // merge old paths to save memory
- if(i == froze + FREEZE_INTERVAL) {
- p = &paths[nodes[0]->path];
- for(k=i; k>froze; k--) {
- dst[k] = p->nibble;
- p = &paths[p->prev];
- }
- froze = i;
- pathn = 0;
- // other nodes might use paths that don't coincide with the frozen one.
- // checking which nodes do so is too slow, so just kill them all.
- // this also slightly improves quality, but I don't know why.
- memset(nodes+1, 0, (frontier-1)*sizeof(TrellisNode*));
- }
- }
-
- p = &paths[nodes[0]->path];
- for(i=n-1; i>froze; i--) {
- dst[i] = p->nibble;
- p = &paths[p->prev];
- }
-
- c->predictor = nodes[0]->sample1;
- c->sample1 = nodes[0]->sample1;
- c->sample2 = nodes[0]->sample2;
- c->step_index = nodes[0]->step;
- c->step = nodes[0]->step;
- c->idelta = nodes[0]->step;
-}
-
-static int adpcm_encode_frame(AVCodecContext *avctx,
- unsigned char *frame, int buf_size, void *data)
-{
- int n, i, st;
- short *samples;
- unsigned char *dst;
- ADPCMContext *c = avctx->priv_data;
-
- dst = frame;
- samples = (short *)data;
- st= avctx->channels == 2;
-/* n = (BLKSIZE - 4 * avctx->channels) / (2 * 8 * avctx->channels); */
-
- switch(avctx->codec->id) {
- case CODEC_ID_ADPCM_IMA_WAV:
- n = avctx->frame_size / 8;
- c->status[0].prev_sample = (signed short)samples[0]; /* XXX */
-/* c->status[0].step_index = 0; *//* XXX: not sure how to init the state machine */
- bytestream_put_le16(&dst, c->status[0].prev_sample);
- *dst++ = (unsigned char)c->status[0].step_index;
- *dst++ = 0; /* unknown */
- samples++;
- if (avctx->channels == 2) {
- c->status[1].prev_sample = (signed short)samples[0];
-/* c->status[1].step_index = 0; */
- bytestream_put_le16(&dst, c->status[1].prev_sample);
- *dst++ = (unsigned char)c->status[1].step_index;
- *dst++ = 0;
- samples++;
- }
-
- /* 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);
- if(avctx->channels == 2)
- adpcm_compress_trellis(avctx, samples+1, buf[1], &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);
- 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);
- }
- }
- } else
- for (; n>0; n--) {
- *dst = adpcm_ima_compress_sample(&c->status[0], samples[0]);
- *dst |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels]) << 4;
- dst++;
- *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 2]);
- *dst |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 3]) << 4;
- dst++;
- *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 4]);
- *dst |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 5]) << 4;
- dst++;
- *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 6]);
- *dst |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 7]) << 4;
- dst++;
- /* right channel */
- if (avctx->channels == 2) {
- *dst = adpcm_ima_compress_sample(&c->status[1], samples[1]);
- *dst |= adpcm_ima_compress_sample(&c->status[1], samples[3]) << 4;
- dst++;
- *dst = adpcm_ima_compress_sample(&c->status[1], samples[5]);
- *dst |= adpcm_ima_compress_sample(&c->status[1], samples[7]) << 4;
- dst++;
- *dst = adpcm_ima_compress_sample(&c->status[1], samples[9]);
- *dst |= adpcm_ima_compress_sample(&c->status[1], samples[11]) << 4;
- dst++;
- *dst = adpcm_ima_compress_sample(&c->status[1], samples[13]);
- *dst |= adpcm_ima_compress_sample(&c->status[1], samples[15]) << 4;
- dst++;
- }
- samples += 8 * avctx->channels;
- }
- break;
- case CODEC_ID_ADPCM_IMA_QT:
- {
- int ch, i;
- PutBitContext pb;
- init_put_bits(&pb, dst, buf_size*8);
-
- for(ch=0; ch<avctx->channels; ch++){
- put_bits(&pb, 9, (c->status[ch].prev_sample + 0x10000) >> 7);
- put_bits(&pb, 7, c->status[ch].step_index);
- if(avctx->trellis > 0) {
- uint8_t buf[64];
- adpcm_compress_trellis(avctx, samples+ch, buf, &c->status[ch], 64);
- for(i=0; i<64; i++)
- put_bits(&pb, 4, buf[i^1]);
- c->status[ch].prev_sample = c->status[ch].predictor & ~0x7F;
- } else {
- for (i=0; i<64; i+=2){
- int t1, t2;
- t1 = adpcm_ima_compress_sample(&c->status[ch], samples[avctx->channels*(i+0)+ch]);
- t2 = adpcm_ima_compress_sample(&c->status[ch], samples[avctx->channels*(i+1)+ch]);
- put_bits(&pb, 4, t2);
- put_bits(&pb, 4, t1);
- }
- c->status[ch].prev_sample &= ~0x7F;
- }
- }
-
- dst += put_bits_count(&pb)>>3;
- break;
- }
- case CODEC_ID_ADPCM_SWF:
- {
- int i;
- PutBitContext pb;
- init_put_bits(&pb, dst, buf_size*8);
-
- n = avctx->frame_size-1;
-
- //Store AdpcmCodeSize
- put_bits(&pb, 2, 2); //Set 4bits flash adpcm format
-
- //Init the encoder state
- for(i=0; i<avctx->channels; i++){
- c->status[i].step_index = av_clip(c->status[i].step_index, 0, 63); // clip step so it fits 6 bits
- put_sbits(&pb, 16, samples[i]);
- put_bits(&pb, 6, c->status[i].step_index);
- c->status[i].prev_sample = (signed short)samples[i];
- }
-
- if(avctx->trellis > 0) {
- uint8_t buf[2][n];
- adpcm_compress_trellis(avctx, samples+2, buf[0], &c->status[0], n);
- if (avctx->channels == 2)
- adpcm_compress_trellis(avctx, samples+3, buf[1], &c->status[1], n);
- for(i=0; i<n; i++) {
- put_bits(&pb, 4, buf[0][i]);
- if (avctx->channels == 2)
- put_bits(&pb, 4, buf[1][i]);
- }
- } 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->channels == 2)
- put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[1], samples[2*i+1]));
- }
- }
- flush_put_bits(&pb);
- dst += put_bits_count(&pb)>>3;
- break;
- }
- case CODEC_ID_ADPCM_MS:
- for(i=0; i<avctx->channels; i++){
- int predictor=0;
-
- *dst++ = predictor;
- c->status[i].coeff1 = AdaptCoeff1[predictor];
- c->status[i].coeff2 = AdaptCoeff2[predictor];
- }
- for(i=0; i<avctx->channels; i++){
- if (c->status[i].idelta < 16)
- c->status[i].idelta = 16;
-
- bytestream_put_le16(&dst, c->status[i].idelta);
- }
- for(i=0; i<avctx->channels; i++){
- c->status[i].sample2= *samples++;
- }
- for(i=0; i<avctx->channels; i++){
- c->status[i].sample1= *samples++;
-
- bytestream_put_le16(&dst, c->status[i].sample1);
- }
- for(i=0; i<avctx->channels; i++)
- bytestream_put_le16(&dst, c->status[i].sample2);
-
- if(avctx->trellis > 0) {
- int n = avctx->block_align - 7*avctx->channels;
- uint8_t buf[2][n];
- if(avctx->channels == 1) {
- n *= 2;
- adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
- for(i=0; i<n; i+=2)
- *dst++ = (buf[0][i] << 4) | buf[0][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);
- for(i=0; i<n; i++)
- *dst++ = (buf[0][i] << 4) | buf[1][i];
- }
- } else
- for(i=7*avctx->channels; i<avctx->block_align; i++) {
- int nibble;
- nibble = adpcm_ms_compress_sample(&c->status[ 0], *samples++)<<4;
- nibble|= adpcm_ms_compress_sample(&c->status[st], *samples++);
- *dst++ = nibble;
- }
- break;
- case CODEC_ID_ADPCM_YAMAHA:
- n = avctx->frame_size / 2;
- if(avctx->trellis > 0) {
- uint8_t buf[2][n*2];
- n *= 2;
- if(avctx->channels == 1) {
- adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
- for(i=0; i<n; i+=2)
- *dst++ = buf[0][i] | (buf[0][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);
- for(i=0; i<n; i++)
- *dst++ = buf[0][i] | (buf[1][i] << 4);
- }
- } else
- for (; n>0; n--) {
- for(i = 0; i < avctx->channels; i++) {
- 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;
- *dst++ = nibble;
- }
- samples += 2 * avctx->channels;
- }
- break;
- default:
- return -1;
- }
- return dst - frame;
-}
-#endif //CONFIG_ENCODERS