falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
Browse Source

adpcm: convert VLAs to malloc/free 

Originally committed as revision 23819 to svn://svn.ffmpeg.org/ffmpeg/trunk
tags/n0.8
Måns Rullgård 15 years ago
parent
9577838f2f
commit
07ece20c69
1 changed files with 83 additions and 57 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +83
    -57
      libavcodec/adpcm.c

+ 83
- 57
libavcodec/adpcm.c View File

@@ -145,15 +145,34 @@ typedef struct ADPCMChannelStatus {
int idelta; int idelta;
} ADPCMChannelStatus; } 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 { typedef struct ADPCMContext {
ADPCMChannelStatus status[6]; ADPCMChannelStatus status[6];
TrellisPath *paths;
TrellisNode *node_buf;
TrellisNode **nodep_buf;
} ADPCMContext; } ADPCMContext;


#define FREEZE_INTERVAL 128

/* XXX: implement encoding */ /* XXX: implement encoding */


#if CONFIG_ENCODERS #if CONFIG_ENCODERS
static av_cold int adpcm_encode_init(AVCodecContext *avctx) static av_cold int adpcm_encode_init(AVCodecContext *avctx)
{ {
ADPCMContext *s = avctx->priv_data;
uint8_t *extradata; uint8_t *extradata;
int i; int i;
if (avctx->channels > 2) if (avctx->channels > 2)
@@ -164,6 +183,14 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx)
return -1; 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);
}

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 */ avctx->frame_size = (BLKSIZE - 4 * avctx->channels) * 8 / (4 * avctx->channels) + 1; /* each 16 bits sample gives one nibble */
@@ -199,23 +226,32 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx)
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");
return -1;
goto error;
} }
avctx->frame_size = 512 * (avctx->sample_rate / 11025); avctx->frame_size = 512 * (avctx->sample_rate / 11025);
break; break;
default: default:
return -1;
goto error;
} }


avctx->coded_frame= avcodec_alloc_frame(); avctx->coded_frame= avcodec_alloc_frame();
avctx->coded_frame->key_frame= 1; avctx->coded_frame->key_frame= 1;


return 0; return 0;
error:
av_freep(&s->paths);
av_freep(&s->node_buf);
av_freep(&s->nodep_buf);
return -1;
} }


static av_cold 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(&avctx->coded_frame);
av_freep(&s->paths);
av_freep(&s->node_buf);
av_freep(&s->nodep_buf);


return 0; return 0;
} }
@@ -276,39 +312,23 @@ static inline unsigned char adpcm_yamaha_compress_sample(ADPCMChannelStatus *c,
return nibble; 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, static void adpcm_compress_trellis(AVCodecContext *avctx, const short *samples,
uint8_t *dst, ADPCMChannelStatus *c, int n) uint8_t *dst, ADPCMChannelStatus *c, int n)
{ {
#define FREEZE_INTERVAL 128
//FIXME 6% faster if frontier is a compile-time constant //FIXME 6% faster if frontier is a compile-time constant
ADPCMContext *s = avctx->priv_data;
const int frontier = 1 << avctx->trellis; const int frontier = 1 << avctx->trellis;
const int stride = avctx->channels; const int stride = avctx->channels;
const int version = avctx->codec->id; 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];
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; 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];
memset(nodep_buf, 0, 2 * frontier * sizeof(*nodep_buf));
nodes[0] = node_buf + frontier;
nodes[0]->ssd = 0; nodes[0]->ssd = 0;
nodes[0]->path = 0; nodes[0]->path = 0;
nodes[0]->step = c->step_index; nodes[0]->step = c->step_index;
@@ -329,7 +349,7 @@ static void adpcm_compress_trellis(AVCodecContext *avctx, const short *samples,
} }


for(i=0; i<n; i++) { for(i=0; i<n; i++) {
TrellisNode *t = node_buf[i&1];
TrellisNode *t = node_buf + frontier*(i&1);
TrellisNode **u; TrellisNode **u;
int sample = samples[i*stride]; int sample = samples[i*stride];
memset(nodes_next, 0, frontier*sizeof(TrellisNode*)); memset(nodes_next, 0, frontier*sizeof(TrellisNode*));
@@ -367,7 +387,7 @@ static void adpcm_compress_trellis(AVCodecContext *avctx, const short *samples,
if(!nodes_next[k] || ssd < nodes_next[k]->ssd) {\ if(!nodes_next[k] || ssd < nodes_next[k]->ssd) {\
TrellisNode *u = nodes_next[frontier-1];\ TrellisNode *u = nodes_next[frontier-1];\
if(!u) {\ if(!u) {\
assert(pathn < max_paths);\
assert(pathn < FREEZE_INTERVAL<<avctx->trellis);\
u = t++;\ u = t++;\
u->path = pathn++;\ u->path = pathn++;\
}\ }\
@@ -454,6 +474,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx,
short *samples; short *samples;
unsigned char *dst; unsigned char *dst;
ADPCMContext *c = avctx->priv_data; ADPCMContext *c = avctx->priv_data;
uint8_t *buf;


dst = frame; dst = frame;
samples = (short *)data; samples = (short *)data;
@@ -480,22 +501,24 @@ static int adpcm_encode_frame(AVCodecContext *avctx,


/* 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) {
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) 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++) { 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) { 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 } 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]);
@@ -578,15 +601,16 @@ static int adpcm_encode_frame(AVCodecContext *avctx,
} }


if(avctx->trellis > 0) { 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) 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++) { for(i=0; i<n; i++) {
put_bits(&pb, 4, buf[0][i]);
put_bits(&pb, 4, buf[i]);
if (avctx->channels == 2) if (avctx->channels == 2)
put_bits(&pb, 4, buf[1][i]);
put_bits(&pb, 4, buf[n+i]);
} }
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]));
@@ -625,18 +649,18 @@ static int adpcm_encode_frame(AVCodecContext *avctx,


if(avctx->trellis > 0) { if(avctx->trellis > 0) {
int n = avctx->block_align - 7*avctx->channels; 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) { 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) for(i=0; i<n; i+=2)
*dst++ = (buf[0][i] << 4) | buf[0][i+1];
*dst++ = (buf[i] << 4) | buf[i+1];
} else { } 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++) 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 } 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;
@@ -648,18 +672,19 @@ static int adpcm_encode_frame(AVCodecContext *avctx,
case CODEC_ID_ADPCM_YAMAHA: case CODEC_ID_ADPCM_YAMAHA:
n = avctx->frame_size / 2; n = avctx->frame_size / 2;
if(avctx->trellis > 0) { if(avctx->trellis > 0) {
uint8_t buf[2][n*2];
FF_ALLOC_OR_GOTO(avctx, buf, 2*n*2, error);
n *= 2; n *= 2;
if(avctx->channels == 1) { 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) for(i=0; i<n; i+=2)
*dst++ = buf[0][i] | (buf[0][i+1] << 4);
*dst++ = buf[i] | (buf[i+1] << 4);
} else { } 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++) 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 } else
for (n *= avctx->channels; n>0; n--) { for (n *= avctx->channels; n>0; n--) {
int nibble; int nibble;
@@ -669,6 +694,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx,
} }
break; break;
default: default:
error:
return -1; return -1;
} }
return dst - frame; return dst - frame;


Write Preview
Loading…
Cancel
Save