RepoMirrors/mpv
1
0
Fork 0
mirror of https://github.com/mpv-player/mpv synced 2025-04-09 19:22:05 +00:00
Code Issues Releases Wiki Activity

af_scaletempo: uncrustify

Browse Source 
Also do some cosmetic changes, like merging definition and
initialization of local variables.

Remove an annoying debug mp_msg() from af_open(). It just printed the
command line parameters; if this is really needed, it could be added
to af.c instead (similar as to what vf.c does).
This commit is contained in:
wm4 2013-11-09 23:21:37 +01:00
parent 142d5c985e
commit 0ff863c179
1 changed files with 385 additions and 401 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

248
audio/filter/af_scaletempo.c
View File

@ -55,21 +55,22 @@ typedef struct af_scaletempo_s
int bytes_queue;
int bytes_queued;
int bytes_to_slide;
int8_t* buf_queue;
int8_t *buf_queue;
// overlap
int samples_overlap;
int samples_standing;
int bytes_overlap;
int bytes_standing;
void* buf_overlap;
void* table_blend;
void (*output_overlap)(struct af_scaletempo_s* s, void* out_buf, int bytes_off);
void *buf_overlap;
void *table_blend;
void (*output_overlap)(struct af_scaletempo_s *s, void *out_buf,
int bytes_off);
// best overlap
int frames_search;
int num_channels;
void* buf_pre_corr;
void* table_window;
int (*best_overlap_offset)(struct af_scaletempo_s* s);
void *buf_pre_corr;
void *table_window;
int (*best_overlap_offset)(struct af_scaletempo_s *s);
// command line
float scale_nominal;
float ms_stride;
@ -80,18 +81,16 @@ typedef struct af_scaletempo_s
short speed_pitch;
} af_scaletempo_t;
static int fill_queue(struct af_instance* af, struct mp_audio* data, int offset)
static int fill_queue(struct af_instance *af, struct mp_audio *data, int offset)
{
af_scaletempo_t* s = af->priv;
af_scaletempo_t *s = af->priv;
int bytes_in = data->len - offset;
int offset_unchanged = offset;
if (s->bytes_to_slide > 0) {
if (s->bytes_to_slide < s->bytes_queued) {
int bytes_move = s->bytes_queued - s->bytes_to_slide;
memmove(s->buf_queue,
s->buf_queue + s->bytes_to_slide,
bytes_move);
memmove(s->buf_queue, s->buf_queue + s->bytes_to_slide, bytes_move);
s->bytes_to_slide = 0;
s->bytes_queued = bytes_move;
} else {
@ -109,8 +108,7 @@ static int fill_queue(struct af_instance* af, struct mp_audio* data, int offset)
int bytes_copy = MPMIN(s->bytes_queue - s->bytes_queued, bytes_in);
assert(bytes_copy >= 0);
memcpy(s->buf_queue + s->bytes_queued,
(int8_t*)data->audio + offset,
bytes_copy);
(int8_t *)data->audio + offset, bytes_copy);
s->bytes_queued += bytes_copy;
offset += bytes_copy;
}
@ -118,31 +116,27 @@ static int fill_queue(struct af_instance* af, struct mp_audio* data, int offset)
return offset - offset_unchanged;
}
#define UNROLL_PADDING (4*4)
#define UNROLL_PADDING (4 * 4)
static int best_overlap_offset_float(af_scaletempo_t* s)
static int best_overlap_offset_float(af_scaletempo_t *s)
{
float *pw, *po, *ppc, *search_start;
float best_corr = INT_MIN;
int best_off = 0;
int i, off;
pw = s->table_window;
po = s->buf_overlap;
float *pw = s->table_window;
float *po = s->buf_overlap;
po += s->num_channels;
ppc = s->buf_pre_corr;
for (i=s->num_channels; i<s->samples_overlap; i++) {
*ppc++ = *pw++ * *po++;
}
float *ppc = s->buf_pre_corr;
for (int i = s->num_channels; i < s->samples_overlap; i++)
*ppc++ = *pw++ **po++;
search_start = (float*)s->buf_queue + s->num_channels;
for (off=0; off<s->frames_search; off++) {
float *search_start = (float *)s->buf_queue + s->num_channels;
for (int off = 0; off < s->frames_search; off++) {
float corr = 0;
float* ps = search_start;
float *ps = search_start;
ppc = s->buf_pre_corr;
for (i=s->num_channels; i<s->samples_overlap; i++) {
corr += *ppc++ * *ps++;
}
for (int i = s->num_channels; i < s->samples_overlap; i++)
corr += *ppc++ **ps++;
if (corr > best_corr) {
best_corr = corr;
best_off = off;
@ -153,36 +147,31 @@ static int best_overlap_offset_float(af_scaletempo_t* s)
return best_off * 4 * s->num_channels;
}
static int best_overlap_offset_s16(af_scaletempo_t* s)
static int best_overlap_offset_s16(af_scaletempo_t *s)
{
int32_t *pw, *ppc;
int16_t *po, *search_start;
int64_t best_corr = INT64_MIN;
int best_off = 0;
int off;
long i;
pw = s->table_window;
po = s->buf_overlap;
int32_t *pw = s->table_window;
int16_t *po = s->buf_overlap;
po += s->num_channels;
ppc = s->buf_pre_corr;
for (i=s->num_channels; i<s->samples_overlap; i++) {
*ppc++ = ( *pw++ * *po++ ) >> 15;
}
int32_t *ppc = s->buf_pre_corr;
for (long i = s->num_channels; i < s->samples_overlap; i++)
*ppc++ = (*pw++ **po++) >> 15;
search_start = (int16_t*)s->buf_queue + s->num_channels;
for (off=0; off<s->frames_search; off++) {
int16_t *search_start = (int16_t *)s->buf_queue + s->num_channels;
for (int off = 0; off < s->frames_search; off++) {
int64_t corr = 0;
int16_t* ps = search_start;
int16_t *ps = search_start;
ppc = s->buf_pre_corr;
ppc += s->samples_overlap - s->num_channels;
ps += s->samples_overlap - s->num_channels;
i = -(s->samples_overlap - s->num_channels);
long i = -(s->samples_overlap - s->num_channels);
do {
corr += ppc[i+0] * ps[i+0];
corr += ppc[i+1] * ps[i+1];
corr += ppc[i+2] * ps[i+2];
corr += ppc[i+3] * ps[i+3];
corr += ppc[i + 0] * ps[i + 0];
corr += ppc[i + 1] * ps[i + 1];
corr += ppc[i + 2] * ps[i + 2];
corr += ppc[i + 3] * ps[i + 3];
i += 4;
} while (i < 0);
if (corr > best_corr) {
@ -195,38 +184,36 @@ static int best_overlap_offset_s16(af_scaletempo_t* s)
return best_off * 2 * s->num_channels;
}
static void output_overlap_float(af_scaletempo_t* s, void* buf_out,
static void output_overlap_float(af_scaletempo_t *s, void *buf_out,
int bytes_off)
{
float* pout = buf_out;
float* pb = s->table_blend;
float* po = s->buf_overlap;
float* pin = (float*)(s->buf_queue + bytes_off);
int i;
for (i=0; i<s->samples_overlap; i++) {
*pout++ = *po - *pb++ * ( *po - *pin++ ); po++;
float *pout = buf_out;
float *pb = s->table_blend;
float *po = s->buf_overlap;
float *pin = (float *)(s->buf_queue + bytes_off);
for (int i = 0; i < s->samples_overlap; i++) {
*pout++ = *po - *pb++ *(*po - *pin++);
po++;
}
}
static void output_overlap_s16(af_scaletempo_t* s, void* buf_out,
static void output_overlap_s16(af_scaletempo_t *s, void *buf_out,
int bytes_off)
{
int16_t* pout = buf_out;
int32_t* pb = s->table_blend;
int16_t* po = s->buf_overlap;
int16_t* pin = (int16_t*)(s->buf_queue + bytes_off);
int i;
for (i=0; i<s->samples_overlap; i++) {
*pout++ = *po - ( ( *pb++ * ( *po - *pin++ ) ) >> 16 ); po++;
int16_t *pout = buf_out;
int32_t *pb = s->table_blend;
int16_t *po = s->buf_overlap;
int16_t *pin = (int16_t *)(s->buf_queue + bytes_off);
for (int i = 0; i < s->samples_overlap; i++) {
*pout++ = *po - ((*pb++ *(*po - *pin++)) >> 16);
po++;
}
}
// Filter data through filter
static struct mp_audio* play(struct af_instance* af, struct mp_audio* data)
static struct mp_audio *play(struct af_instance *af, struct mp_audio *data)
{
af_scaletempo_t* s = af->priv;
int offset_in;
int max_bytes_out;
int8_t* pout;
af_scaletempo_t *s = af->priv;
if (s->scale == 1.0) {
af->delay = 0;
@ -234,20 +221,23 @@ static struct mp_audio* play(struct af_instance* af, struct mp_audio* data)
}
// RESIZE_LOCAL_BUFFER - can't use macro
max_bytes_out = ((int)(data->len / s->bytes_stride_scaled) + 1) * s->bytes_stride;
int max_bytes_out = ((int)(data->len / s->bytes_stride_scaled) + 1)
* s->bytes_stride;
if (max_bytes_out > af->data->len) {
mp_msg(MSGT_AFILTER, MSGL_V, "[libaf] Reallocating memory in module %s, "
"old len = %i, new len = %i\n",af->info->name,af->data->len,max_bytes_out);
"old len = %i, new len = %i\n", af->info->name,
af->data->len, max_bytes_out);
af->data->audio = realloc(af->data->audio, max_bytes_out);
if (!af->data->audio) {
mp_msg(MSGT_AFILTER, MSGL_FATAL, "[libaf] Could not allocate memory\n");
mp_msg(MSGT_AFILTER, MSGL_FATAL,
"[libaf] Could not allocate memory\n");
return NULL;
}
af->data->len = max_bytes_out;
}
offset_in = fill_queue(af, data, 0);
pout = af->data->audio;
int offset_in = fill_queue(af, data, 0);
int8_t *pout = af->data->audio;
while (s->bytes_queued >= s->bytes_queue) {
int ti;
float tf;
@ -287,18 +277,15 @@ static struct mp_audio* play(struct af_instance* af, struct mp_audio* data)
}
// Initialization and runtime control
static int control(struct af_instance* af, int cmd, void* arg)
static int control(struct af_instance *af, int cmd, void *arg)
{
af_scaletempo_t* s = af->priv;
switch(cmd){
case AF_CONTROL_REINIT:{
struct mp_audio* data = (struct mp_audio*)arg;
af_scaletempo_t *s = af->priv;
switch (cmd) {
case AF_CONTROL_REINIT: {
struct mp_audio *data = (struct mp_audio *)arg;
float srate = data->rate / 1000;
int nch = data->nch;
int bps;
int use_int = 0;
int frames_stride, frames_overlap;
int i, j;
mp_msg(MSGT_AFILTER, MSGL_V,
"[scaletempo] %.3f speed * %.3f scale_nominal = %.3f\n",
@ -319,9 +306,9 @@ static int control(struct af_instance* af, int cmd, void* arg)
} else {
mp_audio_set_format(af->data, AF_FORMAT_FLOAT_NE);
}
bps = af->data->bps;
int bps = af->data->bps;
frames_stride = srate * s->ms_stride;
int frames_stride = srate * s->ms_stride;
s->bytes_stride = frames_stride * bps * nch;
s->bytes_stride_scaled = s->scale * s->bytes_stride;
s->frames_stride_scaled = s->scale * frames_stride;
@ -329,7 +316,7 @@ static int control(struct af_instance* af, int cmd, void* arg)
af->mul = (double)s->bytes_stride / s->bytes_stride_scaled;
af->delay = 0;
frames_overlap = frames_stride * s->percent_overlap;
int frames_overlap = frames_stride * s->percent_overlap;
if (frames_overlap <= 0) {
s->bytes_standing = s->bytes_stride;
s->samples_standing = s->bytes_standing / bps;
@ -342,72 +329,71 @@ static int control(struct af_instance* af, int cmd, void* arg)
s->samples_standing = s->bytes_standing / bps;
s->buf_overlap = realloc(s->buf_overlap, s->bytes_overlap);
s->table_blend = realloc(s->table_blend, s->bytes_overlap * 4);
if(!s->buf_overlap || !s->table_blend) {
if (!s->buf_overlap || !s->table_blend) {
mp_msg(MSGT_AFILTER, MSGL_FATAL, "[scaletempo] Out of memory\n");
return AF_ERROR;
}
memset(s->buf_overlap, 0, s->bytes_overlap);
if (use_int) {
int32_t* pb = s->table_blend;
int32_t *pb = s->table_blend;
int64_t blend = 0;
for (i=0; i<frames_overlap; i++) {
for (int i = 0; i < frames_overlap; i++) {
int32_t v = blend / frames_overlap;
for (j=0; j<nch; j++) {
for (int j = 0; j < nch; j++)
*pb++ = v;
}
blend += 65536; // 2^16
}
s->output_overlap = output_overlap_s16;
} else {
float* pb = s->table_blend;
for (i=0; i<frames_overlap; i++) {
float *pb = s->table_blend;
for (int i = 0; i < frames_overlap; i++) {
float v = i / (float)frames_overlap;
for (j=0; j<nch; j++) {
for (int j = 0; j < nch; j++)
*pb++ = v;
}
}
s->output_overlap = output_overlap_float;
}
}
s->frames_search = (frames_overlap > 1) ? srate * s->ms_search : 0;
if (s->frames_search <= 0) {
if (s->frames_search <= 0)
s->best_overlap_offset = NULL;
} else {
else {
if (use_int) {
int64_t t = frames_overlap;
int32_t n = 8589934588LL / (t * t); // 4 * (2^31 - 1) / t^2
int32_t* pw;
s->buf_pre_corr = realloc(s->buf_pre_corr, s->bytes_overlap * 2 + UNROLL_PADDING);
s->table_window = realloc(s->table_window, s->bytes_overlap * 2 - nch * bps * 2);
if(!s->buf_pre_corr || !s->table_window) {
s->buf_pre_corr = realloc(s->buf_pre_corr,
s->bytes_overlap * 2 + UNROLL_PADDING);
s->table_window = realloc(s->table_window,
s->bytes_overlap * 2 - nch * bps * 2);
if (!s->buf_pre_corr || !s->table_window) {
mp_msg(MSGT_AFILTER, MSGL_FATAL, "[scaletempo] Out of memory\n");
return AF_ERROR;
}
memset((char *)s->buf_pre_corr + s->bytes_overlap * 2, 0, UNROLL_PADDING);
pw = s->table_window;
for (i=1; i<frames_overlap; i++) {
int32_t v = ( i * (t - i) * n ) >> 15;
for (j=0; j<nch; j++) {
memset((char *)s->buf_pre_corr + s->bytes_overlap * 2, 0,
UNROLL_PADDING);
int32_t *pw = s->table_window;
for (int i = 1; i < frames_overlap; i++) {
int32_t v = (i * (t - i) * n) >> 15;
for (int j = 0; j < nch; j++)
*pw++ = v;
}
}
s->best_overlap_offset = best_overlap_offset_s16;
} else {
float* pw;
s->buf_pre_corr = realloc(s->buf_pre_corr, s->bytes_overlap);
s->table_window = realloc(s->table_window, s->bytes_overlap - nch * bps);
if(!s->buf_pre_corr || !s->table_window) {
mp_msg(MSGT_AFILTER, MSGL_FATAL, "[scaletempo] Out of memory\n");
s->table_window = realloc(s->table_window,
s->bytes_overlap - nch * bps);
if (!s->buf_pre_corr || !s->table_window) {
mp_msg(MSGT_AFILTER, MSGL_FATAL,
"[scaletempo] Out of memory\n");
return AF_ERROR;
}
pw = s->table_window;
for (i=1; i<frames_overlap; i++) {
float *pw = s->table_window;
for (int i = 1; i < frames_overlap; i++) {
float v = i * (frames_overlap - i);
for (j=0; j<nch; j++) {
for (int j = 0; j < nch; j++)
*pw++ = v;
}
}
s->best_overlap_offset = best_overlap_offset_float;
}
}
@ -418,7 +404,7 @@ static int control(struct af_instance* af, int cmd, void* arg)
s->bytes_queue
= (s->frames_search + frames_stride + frames_overlap) * bps * nch;
s->buf_queue = realloc(s->buf_queue, s->bytes_queue + UNROLL_PADDING);
if(!s->buf_queue) {
if (!s->buf_queue) {
mp_msg(MSGT_AFILTER, MSGL_FATAL, "[scaletempo] Out of memory\n");
return AF_ERROR;
}
@ -426,7 +412,7 @@ static int control(struct af_instance* af, int cmd, void* arg)
s->bytes_queued = 0;
s->bytes_to_slide = 0;
mp_msg (MSGT_AFILTER, MSGL_DBG2, "[scaletempo] "
mp_msg(MSGT_AFILTER, MSGL_DBG2, "[scaletempo] "
"%.2f stride_in, %i stride_out, %i standing, "
"%i overlap, %i search, %i queue, %s mode\n",
s->frames_stride_scaled,
@ -435,15 +421,14 @@ static int control(struct af_instance* af, int cmd, void* arg)
(int)(s->bytes_overlap / nch / bps),
s->frames_search,
(int)(s->bytes_queue / nch / bps),
(use_int?"s16":"float"));
(use_int ? "s16" : "float"));
return af_test_output(af, (struct mp_audio*)arg);
return af_test_output(af, (struct mp_audio *)arg);
}
case AF_CONTROL_PLAYBACK_SPEED | AF_CONTROL_SET:{
case AF_CONTROL_PLAYBACK_SPEED | AF_CONTROL_SET: {
if (s->speed_tempo) {
if (s->speed_pitch) {
if (s->speed_pitch)
break;
}
s->speed = *(double *)arg;
s->scale = s->speed * s->scale_nominal;
} else {
@ -455,22 +440,22 @@ static int control(struct af_instance* af, int cmd, void* arg)
}
return AF_OK;
}
case AF_CONTROL_SCALETEMPO_AMOUNT | AF_CONTROL_SET:{
s->scale = *(float*)arg;
case AF_CONTROL_SCALETEMPO_AMOUNT | AF_CONTROL_SET: {
s->scale = *(float *)arg;
s->scale = s->speed * s->scale_nominal;
return AF_OK;
}
case AF_CONTROL_SCALETEMPO_AMOUNT | AF_CONTROL_GET:
*(float*)arg = s->scale;
*(float *)arg = s->scale;
return AF_OK;
}
return AF_UNKNOWN;
}
// Deallocate memory
static void uninit(struct af_instance* af)
static void uninit(struct af_instance *af)
{
af_scaletempo_t* s = af->priv;
af_scaletempo_t *s = af->priv;
free(af->data->audio);
free(af->data);
free(s->buf_queue);
@ -484,23 +469,22 @@ static void uninit(struct af_instance* af)
#define SCALE_PITCH 2
// Allocate memory and set function pointers
static int af_open(struct af_instance* af){
static int af_open(struct af_instance *af)
{
af_scaletempo_t *s = af->priv;
af->control = control;
af->uninit = uninit;
af->play = play;
af->mul = 1;
af->data = calloc(1,sizeof(struct mp_audio));
if(af->data == NULL)
af->data = calloc(1, sizeof(struct mp_audio));
if (af->data == NULL)
return AF_ERROR;
s->speed_tempo = !!(s->speed_opt & SCALE_TEMPO);
s->speed_pitch = !!(s->speed_opt & SCALE_PITCH);
s->scale = s->speed * s->scale_nominal;
mp_msg(MSGT_AFILTER, MSGL_DBG2, "[scaletempo] %6.3f scale, %6.2f stride, %6.2f overlap, %6.2f search, speed = %s\n", s->scale_nominal, s->ms_stride, s->percent_overlap, s->ms_search, (s->speed_tempo?(s->speed_pitch?"tempo and speed":"tempo"):(s->speed_pitch?"pitch":"none")));
return AF_OK;
}