diff options
Diffstat (limited to 'src/libffmpeg/libavcodec/adpcm.c')
| -rw-r--r-- | src/libffmpeg/libavcodec/adpcm.c | 401 |
1 files changed, 324 insertions, 77 deletions
diff --git a/src/libffmpeg/libavcodec/adpcm.c b/src/libffmpeg/libavcodec/adpcm.c index ed3106aa0..796cd267c 100644 --- a/src/libffmpeg/libavcodec/adpcm.c +++ b/src/libffmpeg/libavcodec/adpcm.c @@ -203,49 +203,11 @@ static int adpcm_encode_close(AVCodecContext *avctx) static inline unsigned char adpcm_ima_compress_sample(ADPCMChannelStatus *c, short sample) { - int step_index; - unsigned char nibble; - - int sign = 0; /* sign bit of the nibble (MSB) */ - int delta, predicted_delta; - - delta = sample - c->prev_sample; - - if (delta < 0) { - sign = 1; - delta = -delta; - } - - step_index = c->step_index; - - /* nibble = 4 * delta / step_table[step_index]; */ - nibble = (delta << 2) / step_table[step_index]; - - if (nibble > 7) - nibble = 7; - - step_index += index_table[nibble]; - if (step_index < 0) - step_index = 0; - if (step_index > 88) - step_index = 88; - - /* what the decoder will find */ - predicted_delta = ((step_table[step_index] * nibble) / 4) + (step_table[step_index] / 8); - - if (sign) - c->prev_sample -= predicted_delta; - else - c->prev_sample += predicted_delta; - + int delta = sample - c->prev_sample; + int nibble = FFMIN(7, abs(delta)*4/step_table[c->step_index]) + (delta<0)*8; + c->prev_sample = c->prev_sample + ((step_table[c->step_index] * yamaha_difflookup[nibble]) / 8); CLAMP_TO_SHORT(c->prev_sample); - - - nibble += sign << 3; /* sign * 8 */ - - /* save back */ - c->step_index = step_index; - + c->step_index = clip(c->step_index + index_table[nibble], 0, 88); return nibble; } @@ -276,27 +238,194 @@ static inline unsigned char adpcm_ms_compress_sample(ADPCMChannelStatus *c, shor static inline unsigned char adpcm_yamaha_compress_sample(ADPCMChannelStatus *c, short sample) { - int i1 = 0, j1; + int nibble, delta; if(!c->step) { c->predictor = 0; c->step = 127; } - j1 = sample - c->predictor; - j1 = (j1 * 8) / c->step; - i1 = abs(j1) / 2; - if (i1 > 7) - i1 = 7; - if (j1 < 0) - i1 += 8; + delta = sample - c->predictor; + + nibble = FFMIN(7, abs(delta)*4/c->step) + (delta<0)*8; - c->predictor = c->predictor + ((c->step * yamaha_difflookup[i1]) / 8); + c->predictor = c->predictor + ((c->step * yamaha_difflookup[nibble]) / 8); CLAMP_TO_SHORT(c->predictor); - c->step = (c->step * yamaha_indexscale[i1]) >> 8; + c->step = (c->step * yamaha_indexscale[nibble]) >> 8; c->step = clip(c->step, 127, 24567); - return i1; + 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) + 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)) / 256; + const int div = (sample - predictor) / step; + const int nmin = clip(div-range, -8, 6); + const int nmax = 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;\ + CLAMP_TO_SHORT(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) { +#define LOOP_NODES(NAME, STEP_TABLE, STEP_INDEX)\ + const int predictor = nodes[j]->sample1;\ + const int div = (sample - predictor) * 4 / STEP_TABLE;\ + int nmin = clip(div-range, -7, 6);\ + int nmax = 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], clip(step + index_table[nibble], 0, 88)); + } else { //CODEC_ID_ADPCM_YAMAHA + LOOP_NODES(yamaha, step, 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, @@ -335,6 +464,24 @@ static int adpcm_encode_frame(AVCodecContext *avctx, } /* 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]) & 0x0F; *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels]) << 4) & 0xF0; @@ -394,6 +541,21 @@ static int adpcm_encode_frame(AVCodecContext *avctx, *dst++ = c->status[i].sample2 >> 8; } + 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; @@ -403,6 +565,20 @@ static int adpcm_encode_frame(AVCodecContext *avctx, 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; @@ -514,6 +690,34 @@ static inline short adpcm_ct_expand_nibble(ADPCMChannelStatus *c, char nibble) return (short)predictor; } +static inline short adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, char nibble, int size, int shift) +{ + int sign, delta, diff; + + sign = nibble & (1<<(size-1)); + delta = nibble & ((1<<(size-1))-1); + diff = delta << (7 + c->step + shift); + + if (sign) + c->predictor -= diff; + else + c->predictor += diff; + + /* clamp result */ + if (c->predictor > 16256) + c->predictor = 16256; + else if (c->predictor < -16384) + c->predictor = -16384; + + /* calculate new step */ + if (delta >= (2*size - 3) && c->step < 3) + c->step++; + else if (delta == 0 && c->step > 0) + c->step--; + + return (short) c->predictor; +} + static inline short adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, unsigned char nibble) { if(!c->step) { @@ -644,7 +848,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, samples = data; src = buf; - st = avctx->channels == 2; + st = avctx->channels == 2 ? 1 : 0; switch(avctx->codec->id) { case CODEC_ID_ADPCM_IMA_QT: @@ -666,8 +870,10 @@ static int adpcm_decode_frame(AVCodecContext *avctx, cs->step_index = (*src++) & 0x7F; - if (cs->step_index > 88) av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index); - if (cs->step_index > 88) cs->step_index = 88; + if (cs->step_index > 88){ + av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index); + cs->step_index = 88; + } cs->step = step_table[cs->step_index]; @@ -693,35 +899,32 @@ static int adpcm_decode_frame(AVCodecContext *avctx, if (avctx->block_align != 0 && buf_size > avctx->block_align) buf_size = avctx->block_align; +// samples_per_block= (block_align-4*chanels)*8 / (bits_per_sample * chanels) + 1; + for(i=0; i<avctx->channels; i++){ cs = &(c->status[i]); - cs->predictor = *src++; - cs->predictor |= (*src++) << 8; - if(cs->predictor & 0x8000) - cs->predictor -= 0x10000; - CLAMP_TO_SHORT(cs->predictor); + cs->predictor = (int16_t)(src[0] + (src[1]<<8)); + src+=2; // XXX: is this correct ??: *samples++ = cs->predictor; cs->step_index = *src++; - if (cs->step_index < 0) cs->step_index = 0; - if (cs->step_index > 88) cs->step_index = 88; - if (*src++) av_log(avctx, AV_LOG_ERROR, "unused byte should be null !!\n"); /* unused */ + if (cs->step_index > 88){ + av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index); + cs->step_index = 88; + } + if (*src++) av_log(avctx, AV_LOG_ERROR, "unused byte should be null but is %d!!\n", src[-1]); /* unused */ } - for(m=4; src < (buf + buf_size);) { - *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[0] & 0x0F, 3); - if (st) - *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[4] & 0x0F, 3); - *samples++ = adpcm_ima_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F, 3); - if (st) { - *samples++ = adpcm_ima_expand_nibble(&c->status[1], (src[4] >> 4) & 0x0F, 3); - if (!--m) { - m=4; - src+=4; - } + while(src < buf + buf_size){ + for(m=0; m<4; m++){ + for(i=0; i<=st; i++) + *samples++ = adpcm_ima_expand_nibble(&c->status[i], src[4*i] & 0x0F, 3); + for(i=0; i<=st; i++) + *samples++ = adpcm_ima_expand_nibble(&c->status[i], src[4*i] >> 4 , 3); + src++; } - src++; + src += 4*st; } break; case CODEC_ID_ADPCM_4XM: @@ -973,6 +1176,48 @@ static int adpcm_decode_frame(AVCodecContext *avctx, src++; } break; + case CODEC_ID_ADPCM_SBPRO_4: + case CODEC_ID_ADPCM_SBPRO_3: + case CODEC_ID_ADPCM_SBPRO_2: + if (!c->status[0].step_index) { + /* the first byte is a raw sample */ + *samples++ = 128 * (*src++ - 0x80); + if (st) + *samples++ = 128 * (*src++ - 0x80); + c->status[0].step_index = 1; + } + if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_4) { + while (src < buf + buf_size) { + *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], + (src[0] >> 4) & 0x0F, 4, 0); + *samples++ = adpcm_sbpro_expand_nibble(&c->status[st], + src[0] & 0x0F, 4, 0); + src++; + } + } else if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_3) { + while (src < buf + buf_size) { + *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], + (src[0] >> 5) & 0x07, 3, 0); + *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], + (src[0] >> 2) & 0x07, 3, 0); + *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], + src[0] & 0x03, 2, 0); + src++; + } + } else { + while (src < buf + buf_size) { + *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], + (src[0] >> 6) & 0x03, 2, 2); + *samples++ = adpcm_sbpro_expand_nibble(&c->status[st], + (src[0] >> 4) & 0x03, 2, 2); + *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], + (src[0] >> 2) & 0x03, 2, 2); + *samples++ = adpcm_sbpro_expand_nibble(&c->status[st], + src[0] & 0x03, 2, 2); + src++; + } + } + break; case CODEC_ID_ADPCM_SWF: { GetBitContext gb; @@ -1112,10 +1357,12 @@ ADPCM_CODEC(CODEC_ID_ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg); ADPCM_CODEC(CODEC_ID_ADPCM_MS, adpcm_ms); ADPCM_CODEC(CODEC_ID_ADPCM_4XM, adpcm_4xm); ADPCM_CODEC(CODEC_ID_ADPCM_XA, adpcm_xa); -ADPCM_CODEC(CODEC_ID_ADPCM_ADX, adpcm_adx); ADPCM_CODEC(CODEC_ID_ADPCM_EA, adpcm_ea); ADPCM_CODEC(CODEC_ID_ADPCM_CT, adpcm_ct); ADPCM_CODEC(CODEC_ID_ADPCM_SWF, adpcm_swf); ADPCM_CODEC(CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha); +ADPCM_CODEC(CODEC_ID_ADPCM_SBPRO_4, adpcm_sbpro_4); +ADPCM_CODEC(CODEC_ID_ADPCM_SBPRO_3, adpcm_sbpro_3); +ADPCM_CODEC(CODEC_ID_ADPCM_SBPRO_2, adpcm_sbpro_2); #undef ADPCM_CODEC |