Chiebot-Mirror
/
FFmpeg
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

adpcmenc: cosmetics: pretty-printing

Browse Source 
Signed-off-by: Justin Ruggles <justin.ruggles@gmail.com>
pull/2/head
Chris Berov 14 years ago committed by Justin Ruggles
parent 541d083a40
commit dc6d043050
1 changed files with 264 additions and 229 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 171
      libavcodec/adpcmenc.c

171
libavcodec/adpcmenc.c
Unescape View File

@ -74,28 +74,37 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx)
if (avctx->trellis) { if (avctx->trellis) {
int frontier = 1 << avctx->trellis; int frontier = 1 << avctx->trellis;
int max_paths = frontier * FREEZE_INTERVAL; 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->paths,
FF_ALLOC_OR_GOTO(avctx, s->node_buf, 2 * frontier * sizeof(*s->node_buf), error); max_paths * sizeof(*s->paths), error);
FF_ALLOC_OR_GOTO(avctx, s->nodep_buf, 2 * frontier * sizeof(*s->nodep_buf), error); FF_ALLOC_OR_GOTO(avctx, s->node_buf,
FF_ALLOC_OR_GOTO(avctx, s->trellis_hash, 65536 * sizeof(*s->trellis_hash), error); 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);
} }
avctx->bits_per_coded_sample = av_get_bits_per_sample(avctx->codec->id); avctx->bits_per_coded_sample = av_get_bits_per_sample(avctx->codec->id);
switch (avctx->codec->id) { switch (avctx->codec->id) {
case CODEC_ID_ADPCM_IMA_WAV: 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 */ /* each 16 bits sample gives one nibble
/* and we have 4 bytes per channel overhead */ and we have 4 bytes per channel overhead */
avctx->frame_size = (BLKSIZE - 4 * avctx->channels) * 8 /
(4 * avctx->channels) + 1;
/* seems frame_size isn't taken into account...
have to buffer the samples :-( */
avctx->block_align = BLKSIZE; avctx->block_align = BLKSIZE;
/* seems frame_size isn't taken into account... have to buffer the samples :-( */
break; break;
case CODEC_ID_ADPCM_IMA_QT: case CODEC_ID_ADPCM_IMA_QT:
avctx->frame_size = 64; avctx->frame_size = 64;
avctx->block_align = 34 * avctx->channels; avctx->block_align = 34 * avctx->channels;
break; break;
case CODEC_ID_ADPCM_MS: case CODEC_ID_ADPCM_MS:
avctx->frame_size = (BLKSIZE - 7 * avctx->channels) * 2 / avctx->channels + 2; /* each 16 bits sample gives one nibble */ /* each 16 bits sample gives one nibble
/* and we have 7 bytes per channel overhead */ and we have 7 bytes per channel overhead */
avctx->frame_size = (BLKSIZE - 7 * avctx->channels) * 2 /
avctx->channels + 2;
avctx->block_align = BLKSIZE; avctx->block_align = BLKSIZE;
avctx->extradata_size = 32; avctx->extradata_size = 32;
extradata = avctx->extradata = av_malloc(avctx->extradata_size); extradata = avctx->extradata = av_malloc(avctx->extradata_size);
@ -116,7 +125,8 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx)
if (avctx->sample_rate != 11025 && if (avctx->sample_rate != 11025 &&
avctx->sample_rate != 22050 && avctx->sample_rate != 22050 &&
avctx->sample_rate != 44100) { avctx->sample_rate != 44100) {
av_log(avctx, AV_LOG_ERROR, "Sample rate must be 11025, 22050 or 44100\n"); av_log(avctx, AV_LOG_ERROR, "Sample rate must be 11025, "
"22050 or 44100\n");
goto error; goto error;
} }
avctx->frame_size = 512 * (avctx->sample_rate / 11025); avctx->frame_size = 512 * (avctx->sample_rate / 11025);
@ -150,17 +160,21 @@ static av_cold int adpcm_encode_close(AVCodecContext *avctx)
} }
static inline unsigned char adpcm_ima_compress_sample(ADPCMChannelStatus *c, short sample) static inline unsigned char adpcm_ima_compress_sample(ADPCMChannelStatus *c,
short sample)
{ {
int delta = sample - c->prev_sample; int delta = sample - c->prev_sample;
int nibble = FFMIN(7, abs(delta)*4/ff_adpcm_step_table[c->step_index]) + (delta<0)*8; int nibble = FFMIN(7, abs(delta) * 4 /
c->prev_sample += ((ff_adpcm_step_table[c->step_index] * ff_adpcm_yamaha_difflookup[nibble]) / 8); ff_adpcm_step_table[c->step_index]) + (delta < 0) * 8;
c->prev_sample += ((ff_adpcm_step_table[c->step_index] *
ff_adpcm_yamaha_difflookup[nibble]) / 8);
c->prev_sample = av_clip_int16(c->prev_sample); c->prev_sample = av_clip_int16(c->prev_sample);
c->step_index = av_clip(c->step_index + ff_adpcm_index_table[nibble], 0, 88); c->step_index = av_clip(c->step_index + ff_adpcm_index_table[nibble], 0, 88);
return nibble; return nibble;
} }
static inline unsigned char adpcm_ima_qt_compress_sample(ADPCMChannelStatus *c, short sample) static inline unsigned char adpcm_ima_qt_compress_sample(ADPCMChannelStatus *c,
short sample)
{ {
int delta = sample - c->prev_sample; int delta = sample - c->prev_sample;
int mask, step = ff_adpcm_step_table[c->step_index]; int mask, step = ff_adpcm_step_table[c->step_index];
@ -193,31 +207,37 @@ static inline unsigned char adpcm_ima_qt_compress_sample(ADPCMChannelStatus *c,
return nibble; return nibble;
} }
static inline unsigned char adpcm_ms_compress_sample(ADPCMChannelStatus *c, short sample) static inline unsigned char adpcm_ms_compress_sample(ADPCMChannelStatus *c,
short sample)
{ {
int predictor, nibble, bias; int predictor, nibble, bias;
predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64; predictor = (((c->sample1) * (c->coeff1)) +
(( c->sample2) * (c->coeff2))) / 64;
nibble = sample - predictor; nibble = sample - predictor;
if(nibble>=0) bias= c->idelta/2; if (nibble >= 0)
else bias=-c->idelta/2; bias = c->idelta / 2;
else
bias = -c->idelta / 2;
nibble = (nibble + bias) / c->idelta; nibble = (nibble + bias) / c->idelta;
nibble = av_clip(nibble, -8, 7) & 0x0F; nibble = av_clip(nibble, -8, 7) & 0x0F;
predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta; predictor += (signed)((nibble & 0x08) ? (nibble - 0x10) : nibble) * c->idelta;
c->sample2 = c->sample1; c->sample2 = c->sample1;
c->sample1 = av_clip_int16(predictor); c->sample1 = av_clip_int16(predictor);
c->idelta = (ff_adpcm_AdaptationTable[(int)nibble] * c->idelta) >> 8; c->idelta = (ff_adpcm_AdaptationTable[(int)nibble] * c->idelta) >> 8;
if (c->idelta < 16) c->idelta = 16; if (c->idelta < 16)
c->idelta = 16;
return nibble; return nibble;
} }
static inline unsigned char adpcm_yamaha_compress_sample(ADPCMChannelStatus *c, short sample) static inline unsigned char adpcm_yamaha_compress_sample(ADPCMChannelStatus *c,
short sample)
{ {
int nibble, delta; int nibble, delta;
@ -262,7 +282,9 @@ static void adpcm_compress_trellis(AVCodecContext *avctx, const short *samples,
nodes[0]->step = c->step_index; nodes[0]->step = c->step_index;
nodes[0]->sample1 = c->sample1; nodes[0]->sample1 = c->sample1;
nodes[0]->sample2 = c->sample2; nodes[0]->sample2 = c->sample2;
if((version == CODEC_ID_ADPCM_IMA_WAV) || (version == CODEC_ID_ADPCM_IMA_QT) || (version == CODEC_ID_ADPCM_SWF)) if (version == CODEC_ID_ADPCM_IMA_WAV ||
version == CODEC_ID_ADPCM_IMA_QT ||
version == CODEC_ID_ADPCM_SWF)
nodes[0]->sample1 = c->prev_sample; nodes[0]->sample1 = c->prev_sample;
if (version == CODEC_ID_ADPCM_MS) if (version == CODEC_ID_ADPCM_MS)
nodes[0]->step = c->idelta; nodes[0]->step = c->idelta;
@ -283,12 +305,14 @@ static void adpcm_compress_trellis(AVCodecContext *avctx, const short *samples,
int heap_pos = 0; int heap_pos = 0;
memset(nodes_next, 0, frontier * sizeof(TrellisNode*)); memset(nodes_next, 0, frontier * sizeof(TrellisNode*));
for (j = 0; j < frontier && nodes[j]; j++) { for (j = 0; j < frontier && nodes[j]; j++) {
// higher j have higher ssd already, so they're likely to yield 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 range = (j < frontier / 2) ? 1 : 0;
const int step = nodes[j]->step; const int step = nodes[j]->step;
int nidx; int nidx;
if (version == CODEC_ID_ADPCM_MS) { if (version == CODEC_ID_ADPCM_MS) {
const int predictor = ((nodes[j]->sample1 * c->coeff1) + (nodes[j]->sample2 * c->coeff2)) / 64; const int predictor = ((nodes[j]->sample1 * c->coeff1) +
(nodes[j]->sample2 * c->coeff2)) / 64;
const int div = (sample - predictor) / step; const int div = (sample - predictor) / step;
const int nmin = av_clip(div-range, -8, 6); const int nmin = av_clip(div-range, -8, 6);
const int nmax = av_clip(div+range, -7, 7); const int nmax = av_clip(div+range, -7, 7);
@ -329,7 +353,8 @@ static void adpcm_compress_trellis(AVCodecContext *avctx, const short *samples,
} else {\ } else {\
/* Try to replace one of the leaf nodes with the new \ /* Try to replace one of the leaf nodes with the new \
* one, but try a different slot each time. */\ * one, but try a different slot each time. */\
pos = (frontier >> 1) + (heap_pos & ((frontier >> 1) - 1));\ pos = (frontier >> 1) +\
(heap_pos & ((frontier >> 1) - 1));\
if (ssd > nodes_next[pos]->ssd)\ if (ssd > nodes_next[pos]->ssd)\
goto next_##NAME;\ goto next_##NAME;\
heap_pos++;\ heap_pos++;\
@ -358,24 +383,34 @@ static void adpcm_compress_trellis(AVCodecContext *avctx, const short *samples,
pos = parent;\ pos = parent;\
}\ }\
next_##NAME:; next_##NAME:;
STORE_NODE(ms, FFMAX(16, (ff_adpcm_AdaptationTable[nibble] * step) >> 8)); STORE_NODE(ms, FFMAX(16,
(ff_adpcm_AdaptationTable[nibble] * step) >> 8));
} }
} else if((version == CODEC_ID_ADPCM_IMA_WAV)|| (version == CODEC_ID_ADPCM_IMA_QT)|| (version == CODEC_ID_ADPCM_SWF)) { } 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)\ #define LOOP_NODES(NAME, STEP_TABLE, STEP_INDEX)\
const int predictor = nodes[j]->sample1;\ const int predictor = nodes[j]->sample1;\
const int div = (sample - predictor) * 4 / STEP_TABLE;\ const int div = (sample - predictor) * 4 / STEP_TABLE;\
int nmin = av_clip(div - range, -7, 6);\ int nmin = av_clip(div - range, -7, 6);\
int nmax = av_clip(div + range, -6, 7);\ int nmax = av_clip(div + range, -6, 7);\
if(nmin<=0) nmin--; /* distinguish -0 from +0 */\ if (nmin <= 0)\
if(nmax<0) nmax--;\ nmin--; /* distinguish -0 from +0 */\
if (nmax < 0)\
nmax--;\
for (nidx = nmin; nidx <= nmax; nidx++) {\ for (nidx = nmin; nidx <= nmax; nidx++) {\
const int nibble = nidx < 0 ? 7 - nidx : nidx;\ const int nibble = nidx < 0 ? 7 - nidx : nidx;\
int dec_sample = predictor + (STEP_TABLE * ff_adpcm_yamaha_difflookup[nibble]) / 8;\ int dec_sample = predictor +\
(STEP_TABLE *\
ff_adpcm_yamaha_difflookup[nibble]) / 8;\
STORE_NODE(NAME, STEP_INDEX);\ STORE_NODE(NAME, STEP_INDEX);\
} }
LOOP_NODES(ima, ff_adpcm_step_table[step], av_clip(step + ff_adpcm_index_table[nibble], 0, 88)); LOOP_NODES(ima, ff_adpcm_step_table[step],
av_clip(step + ff_adpcm_index_table[nibble], 0, 88));
} else { //CODEC_ID_ADPCM_YAMAHA } else { //CODEC_ID_ADPCM_YAMAHA
LOOP_NODES(yamaha, step, av_clip((step * ff_adpcm_yamaha_indexscale[nibble]) >> 8, 127, 24567)); LOOP_NODES(yamaha, step,
av_clip((step * ff_adpcm_yamaha_indexscale[nibble]) >> 8,
127, 24567));
#undef LOOP_NODES #undef LOOP_NODES
#undef STORE_NODE #undef STORE_NODE
} }
@ -446,7 +481,8 @@ static int adpcm_encode_frame(AVCodecContext *avctx,
case CODEC_ID_ADPCM_IMA_WAV: case CODEC_ID_ADPCM_IMA_WAV:
n = avctx->frame_size / 8; n = avctx->frame_size / 8;
c->status[0].prev_sample = (signed short)samples[0]; /* XXX */ 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 */ /* c->status[0].step_index = 0;
XXX: not sure how to init the state machine */
bytestream_put_le16(&dst, c->status[0].prev_sample); bytestream_put_le16(&dst, c->status[0].prev_sample);
*dst++ = (unsigned char)c->status[0].step_index; *dst++ = (unsigned char)c->status[0].step_index;
*dst++ = 0; /* unknown */ *dst++ = 0; /* unknown */
@ -460,12 +496,14 @@ static int adpcm_encode_frame(AVCodecContext *avctx,
samples++; samples++;
} }
/* stereo: 4 bytes (8 samples) for left, 4 bytes for right, 4 bytes left, ... */ /* stereo: 4 bytes (8 samples) for left,
4 bytes for right, 4 bytes left, ... */
if (avctx->trellis > 0) { if (avctx->trellis > 0) {
FF_ALLOC_OR_GOTO(avctx, buf, 2 * n * 8, error); FF_ALLOC_OR_GOTO(avctx, buf, 2 * n * 8, error);
adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n * 8); adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n * 8);
if (avctx->channels == 2) if (avctx->channels == 2)
adpcm_compress_trellis(avctx, samples+1, buf + n*8, &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++) { for (i = 0; i < n; i++) {
*dst++ = buf[8 * i + 0] | (buf[8 * i + 1] << 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 + 2] | (buf[8 * i + 3] << 4);
@ -480,37 +518,30 @@ static int adpcm_encode_frame(AVCodecContext *avctx,
} }
} }
av_free(buf); av_free(buf);
} else } else {
for (; n > 0; n--) { for (; n > 0; n--) {
*dst = adpcm_ima_compress_sample(&c->status[0], samples[0]); *dst = adpcm_ima_compress_sample(&c->status[0], samples[0]);
*dst |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels]) << 4; *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 * 2]);
*dst |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 3]) << 4; *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 * 4]);
*dst |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 5]) << 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 * 6]);
*dst |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 7]) << 4; *dst++ |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 7]) << 4;
dst++;
/* right channel */ /* right channel */
if (avctx->channels == 2) { if (avctx->channels == 2) {
*dst = adpcm_ima_compress_sample(&c->status[1], samples[1 ]); *dst = adpcm_ima_compress_sample(&c->status[1], samples[1 ]);
*dst |= adpcm_ima_compress_sample(&c->status[1], samples[3]) << 4; *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[5 ]);
*dst |= adpcm_ima_compress_sample(&c->status[1], samples[7]) << 4; *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[9 ]);
*dst |= adpcm_ima_compress_sample(&c->status[1], samples[11]) << 4; *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[13]);
*dst |= adpcm_ima_compress_sample(&c->status[1], samples[15]) << 4; *dst++ |= adpcm_ima_compress_sample(&c->status[1], samples[15]) << 4;
dst++;
} }
samples += 8 * avctx->channels; samples += 8 * avctx->channels;
} }
}
break; break;
case CODEC_ID_ADPCM_IMA_QT: case CODEC_ID_ADPCM_IMA_QT:
{ {
@ -529,8 +560,10 @@ static int adpcm_encode_frame(AVCodecContext *avctx,
} else { } else {
for (i = 0; i < 64; i += 2) { for (i = 0; i < 64; i += 2) {
int t1, t2; int t1, t2;
t1 = adpcm_ima_qt_compress_sample(&c->status[ch], samples[avctx->channels*(i+0)+ch]); t1 = adpcm_ima_qt_compress_sample(&c->status[ch],
t2 = adpcm_ima_qt_compress_sample(&c->status[ch], samples[avctx->channels*(i+1)+ch]); samples[avctx->channels * (i + 0) + ch]);
t2 = adpcm_ima_qt_compress_sample(&c->status[ch],
samples[avctx->channels * (i + 1) + ch]);
put_bits(&pb, 4, t2); put_bits(&pb, 4, t2);
put_bits(&pb, 4, t1); put_bits(&pb, 4, t1);
} }
@ -549,12 +582,13 @@ static int adpcm_encode_frame(AVCodecContext *avctx,
n = avctx->frame_size - 1; n = avctx->frame_size - 1;
//Store AdpcmCodeSize // store AdpcmCodeSize
put_bits(&pb, 2, 2); //Set 4bits flash adpcm format put_bits(&pb, 2, 2); // set 4-bit flash adpcm format
//Init the encoder state // init the encoder state
for (i = 0; i < avctx->channels; i++) { 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 // clip step so it fits 6 bits
c->status[i].step_index = av_clip(c->status[i].step_index, 0, 63);
put_sbits(&pb, 16, samples[i]); put_sbits(&pb, 16, samples[i]);
put_bits(&pb, 6, c->status[i].step_index); put_bits(&pb, 6, c->status[i].step_index);
c->status[i].prev_sample = (signed short)samples[i]; c->status[i].prev_sample = (signed short)samples[i];
@ -564,7 +598,8 @@ static int adpcm_encode_frame(AVCodecContext *avctx,
FF_ALLOC_OR_GOTO(avctx, buf, 2 * n, error); FF_ALLOC_OR_GOTO(avctx, buf, 2 * n, error);
adpcm_compress_trellis(avctx, samples + 2, buf, &c->status[0], n); adpcm_compress_trellis(avctx, samples + 2, buf, &c->status[0], n);
if (avctx->channels == 2) if (avctx->channels == 2)
adpcm_compress_trellis(avctx, samples+3, buf+n, &c->status[1], n); adpcm_compress_trellis(avctx, samples + 3, buf + n,
&c->status[1], n);
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
put_bits(&pb, 4, buf[i]); put_bits(&pb, 4, buf[i]);
if (avctx->channels == 2) if (avctx->channels == 2)
@ -573,9 +608,11 @@ static int adpcm_encode_frame(AVCodecContext *avctx,
av_free(buf); av_free(buf);
} else { } else {
for (i = 1; i < avctx->frame_size; i++) { for (i = 1; i < avctx->frame_size; i++) {
put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels*i])); put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[0],
samples[avctx->channels * i]));
if (avctx->channels == 2) if (avctx->channels == 2)
put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[1], samples[2*i+1])); put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[1],
samples[2 * i + 1]));
} }
} }
flush_put_bits(&pb); flush_put_bits(&pb);
@ -585,7 +622,6 @@ static int adpcm_encode_frame(AVCodecContext *avctx,
case CODEC_ID_ADPCM_MS: case CODEC_ID_ADPCM_MS:
for (i = 0; i < avctx->channels; i++) { for (i = 0; i < avctx->channels; i++) {
int predictor = 0; int predictor = 0;
*dst++ = predictor; *dst++ = predictor;
c->status[i].coeff1 = ff_adpcm_AdaptCoeff1[predictor]; c->status[i].coeff1 = ff_adpcm_AdaptCoeff1[predictor];
c->status[i].coeff2 = ff_adpcm_AdaptCoeff2[predictor]; c->status[i].coeff2 = ff_adpcm_AdaptCoeff2[predictor];
@ -593,15 +629,12 @@ static int adpcm_encode_frame(AVCodecContext *avctx,
for (i = 0; i < avctx->channels; i++) { for (i = 0; i < avctx->channels; i++) {
if (c->status[i].idelta < 16) if (c->status[i].idelta < 16)
c->status[i].idelta = 16; c->status[i].idelta = 16;
bytestream_put_le16(&dst, c->status[i].idelta); bytestream_put_le16(&dst, c->status[i].idelta);
} }
for(i=0; i<avctx->channels; i++){ for (i = 0; i < avctx->channels; i++)
c->status[i].sample2= *samples++; c->status[i].sample2= *samples++;
}
for (i = 0; i < avctx->channels; i++) { for (i = 0; i < avctx->channels; i++) {
c->status[i].sample1 = *samples++; c->status[i].sample1 = *samples++;
bytestream_put_le16(&dst, c->status[i].sample1); bytestream_put_le16(&dst, c->status[i].sample1);
} }
for (i = 0; i < avctx->channels; i++) for (i = 0; i < avctx->channels; i++)
@ -621,13 +654,14 @@ static int adpcm_encode_frame(AVCodecContext *avctx,
*dst++ = (buf[i] << 4) | buf[n + i]; *dst++ = (buf[i] << 4) | buf[n + i];
} }
av_free(buf); av_free(buf);
} else } else {
for (i = 7 * avctx->channels; i < avctx->block_align; i++) { for (i = 7 * avctx->channels; i < avctx->block_align; i++) {
int nibble; int nibble;
nibble = adpcm_ms_compress_sample(&c->status[ 0], *samples++) << 4; nibble = adpcm_ms_compress_sample(&c->status[ 0], *samples++) << 4;
nibble |= adpcm_ms_compress_sample(&c->status[st], *samples++); nibble |= adpcm_ms_compress_sample(&c->status[st], *samples++);
*dst++ = nibble; *dst++ = nibble;
} }
}
break; break;
case CODEC_ID_ADPCM_YAMAHA: case CODEC_ID_ADPCM_YAMAHA:
n = avctx->frame_size / 2; n = avctx->frame_size / 2;
@ -670,7 +704,8 @@ AVCodec ff_ ## name_ ## _encoder = { \
.init = adpcm_encode_init, \ .init = adpcm_encode_init, \
.encode = adpcm_encode_frame, \ .encode = adpcm_encode_frame, \
.close = adpcm_encode_close, \ .close = adpcm_encode_close, \
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, \ .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16, \
AV_SAMPLE_FMT_NONE}, \
.long_name = NULL_IF_CONFIG_SMALL(long_name_), \ .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
} }

Write Preview
Loading…
Cancel
Save