RepoMirrors/mpv
1
0
Fork 0
mirror of https://github.com/mpv-player/mpv synced 2025-05-05 01:30:42 +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

138
audio/filter/af_scaletempo.c
View File

@ -63,7 +63,8 @@ typedef struct af_scaletempo_s
int bytes_standing; int bytes_standing;
void *buf_overlap; void *buf_overlap;
void *table_blend; void *table_blend;
void (*output_overlap)(struct af_scaletempo_s* s, void* out_buf, int bytes_off); void (*output_overlap)(struct af_scaletempo_s *s, void *out_buf,
int bytes_off);
// best overlap // best overlap
int frames_search; int frames_search;
int num_channels; int num_channels;
@ -89,9 +90,7 @@ static int fill_queue(struct af_instance* af, struct mp_audio* data, int offset)
if (s->bytes_to_slide > 0) { if (s->bytes_to_slide > 0) {
if (s->bytes_to_slide < s->bytes_queued) { if (s->bytes_to_slide < s->bytes_queued) {
int bytes_move = s->bytes_queued - s->bytes_to_slide; int bytes_move = s->bytes_queued - s->bytes_to_slide;
memmove(s->buf_queue, memmove(s->buf_queue, s->buf_queue + s->bytes_to_slide, bytes_move);
s->buf_queue + s->bytes_to_slide,
bytes_move);
s->bytes_to_slide = 0; s->bytes_to_slide = 0;
s->bytes_queued = bytes_move; s->bytes_queued = bytes_move;
} else { } 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); int bytes_copy = MPMIN(s->bytes_queue - s->bytes_queued, bytes_in);
assert(bytes_copy >= 0); assert(bytes_copy >= 0);
memcpy(s->buf_queue + s->bytes_queued, memcpy(s->buf_queue + s->bytes_queued,
(int8_t*)data->audio + offset, (int8_t *)data->audio + offset, bytes_copy);
bytes_copy);
s->bytes_queued += bytes_copy; s->bytes_queued += bytes_copy;
offset += bytes_copy; offset += bytes_copy;
} }
@ -122,27 +120,23 @@ static int fill_queue(struct af_instance* af, struct mp_audio* data, int offset)
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; float best_corr = INT_MIN;
int best_off = 0; int best_off = 0;
int i, off;
pw = s->table_window; float *pw = s->table_window;
po = s->buf_overlap; float *po = s->buf_overlap;
po += s->num_channels; po += s->num_channels;
ppc = s->buf_pre_corr; float *ppc = s->buf_pre_corr;
for (i=s->num_channels; i<s->samples_overlap; i++) { for (int i = s->num_channels; i < s->samples_overlap; i++)
*ppc++ = *pw++ **po++; *ppc++ = *pw++ **po++;
}
search_start = (float*)s->buf_queue + s->num_channels; float *search_start = (float *)s->buf_queue + s->num_channels;
for (off=0; off<s->frames_search; off++) { for (int off = 0; off < s->frames_search; off++) {
float corr = 0; float corr = 0;
float *ps = search_start; float *ps = search_start;
ppc = s->buf_pre_corr; ppc = s->buf_pre_corr;
for (i=s->num_channels; i<s->samples_overlap; i++) { for (int i = s->num_channels; i < s->samples_overlap; i++)
corr += *ppc++ **ps++; corr += *ppc++ **ps++;
}
if (corr > best_corr) { if (corr > best_corr) {
best_corr = corr; best_corr = corr;
best_off = off; best_off = off;
@ -155,29 +149,24 @@ static int best_overlap_offset_float(af_scaletempo_t* s)
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; int64_t best_corr = INT64_MIN;
int best_off = 0; int best_off = 0;
int off;
long i;
pw = s->table_window; int32_t *pw = s->table_window;
po = s->buf_overlap; int16_t *po = s->buf_overlap;
po += s->num_channels; po += s->num_channels;
ppc = s->buf_pre_corr; int32_t *ppc = s->buf_pre_corr;
for (i=s->num_channels; i<s->samples_overlap; i++) { for (long i = s->num_channels; i < s->samples_overlap; i++)
*ppc++ = (*pw++ **po++) >> 15; *ppc++ = (*pw++ **po++) >> 15;
}
search_start = (int16_t*)s->buf_queue + s->num_channels; int16_t *search_start = (int16_t *)s->buf_queue + s->num_channels;
for (off=0; off<s->frames_search; off++) { for (int off = 0; off < s->frames_search; off++) {
int64_t corr = 0; int64_t corr = 0;
int16_t *ps = search_start; int16_t *ps = search_start;
ppc = s->buf_pre_corr; ppc = s->buf_pre_corr;
ppc += s->samples_overlap - s->num_channels; ppc += s->samples_overlap - s->num_channels;
ps += 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 { do {
corr += ppc[i + 0] * ps[i + 0]; corr += ppc[i + 0] * ps[i + 0];
corr += ppc[i + 1] * ps[i + 1]; corr += ppc[i + 1] * ps[i + 1];
@ -202,11 +191,12 @@ static void output_overlap_float(af_scaletempo_t* s, void* buf_out,
float *pb = s->table_blend; float *pb = s->table_blend;
float *po = s->buf_overlap; float *po = s->buf_overlap;
float *pin = (float *)(s->buf_queue + bytes_off); float *pin = (float *)(s->buf_queue + bytes_off);
int i; for (int i = 0; i < s->samples_overlap; i++) {
for (i=0; i<s->samples_overlap; i++) { *pout++ = *po - *pb++ *(*po - *pin++);
*pout++ = *po - *pb++ * ( *po - *pin++ ); po++; 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) int bytes_off)
{ {
@ -214,9 +204,9 @@ static void output_overlap_s16(af_scaletempo_t* s, void* buf_out,
int32_t *pb = s->table_blend; int32_t *pb = s->table_blend;
int16_t *po = s->buf_overlap; int16_t *po = s->buf_overlap;
int16_t *pin = (int16_t *)(s->buf_queue + bytes_off); int16_t *pin = (int16_t *)(s->buf_queue + bytes_off);
int i; for (int i = 0; i < s->samples_overlap; i++) {
for (i=0; i<s->samples_overlap; i++) { *pout++ = *po - ((*pb++ *(*po - *pin++)) >> 16);
*pout++ = *po - ( ( *pb++ * ( *po - *pin++ ) ) >> 16 ); po++; po++;
} }
} }
@ -224,9 +214,6 @@ static void output_overlap_s16(af_scaletempo_t* s, void* buf_out,
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; af_scaletempo_t *s = af->priv;
int offset_in;
int max_bytes_out;
int8_t* pout;
if (s->scale == 1.0) { if (s->scale == 1.0) {
af->delay = 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 // 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) { if (max_bytes_out > af->data->len) {
mp_msg(MSGT_AFILTER, MSGL_V, "[libaf] Reallocating memory in module %s, " 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); af->data->audio = realloc(af->data->audio, max_bytes_out);
if (!af->data->audio) { 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; return NULL;
} }
af->data->len = max_bytes_out; af->data->len = max_bytes_out;
} }
offset_in = fill_queue(af, data, 0); int offset_in = fill_queue(af, data, 0);
pout = af->data->audio; int8_t *pout = af->data->audio;
while (s->bytes_queued >= s->bytes_queue) { while (s->bytes_queued >= s->bytes_queue) {
int ti; int ti;
float tf; float tf;
@ -295,10 +285,7 @@ static int control(struct af_instance* af, int cmd, void* arg)
struct mp_audio *data = (struct mp_audio *)arg; struct mp_audio *data = (struct mp_audio *)arg;
float srate = data->rate / 1000; float srate = data->rate / 1000;
int nch = data->nch; int nch = data->nch;
int bps;
int use_int = 0; int use_int = 0;
int frames_stride, frames_overlap;
int i, j;
mp_msg(MSGT_AFILTER, MSGL_V, mp_msg(MSGT_AFILTER, MSGL_V,
"[scaletempo] %.3f speed * %.3f scale_nominal = %.3f\n", "[scaletempo] %.3f speed * %.3f scale_nominal = %.3f\n",
@ -319,9 +306,9 @@ static int control(struct af_instance* af, int cmd, void* arg)
} else { } else {
mp_audio_set_format(af->data, AF_FORMAT_FLOAT_NE); 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 = frames_stride * bps * nch;
s->bytes_stride_scaled = s->scale * s->bytes_stride; s->bytes_stride_scaled = s->scale * s->bytes_stride;
s->frames_stride_scaled = s->scale * frames_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->mul = (double)s->bytes_stride / s->bytes_stride_scaled;
af->delay = 0; af->delay = 0;
frames_overlap = frames_stride * s->percent_overlap; int frames_overlap = frames_stride * s->percent_overlap;
if (frames_overlap <= 0) { if (frames_overlap <= 0) {
s->bytes_standing = s->bytes_stride; s->bytes_standing = s->bytes_stride;
s->samples_standing = s->bytes_standing / bps; s->samples_standing = s->bytes_standing / bps;
@ -350,64 +337,63 @@ static int control(struct af_instance* af, int cmd, void* arg)
if (use_int) { if (use_int) {
int32_t *pb = s->table_blend; int32_t *pb = s->table_blend;
int64_t blend = 0; 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; int32_t v = blend / frames_overlap;
for (j=0; j<nch; j++) { for (int j = 0; j < nch; j++)
*pb++ = v; *pb++ = v;
}
blend += 65536; // 2^16 blend += 65536; // 2^16
} }
s->output_overlap = output_overlap_s16; s->output_overlap = output_overlap_s16;
} else { } else {
float *pb = s->table_blend; float *pb = s->table_blend;
for (i=0; i<frames_overlap; i++) { for (int i = 0; i < frames_overlap; i++) {
float v = i / (float)frames_overlap; float v = i / (float)frames_overlap;
for (j=0; j<nch; j++) { for (int j = 0; j < nch; j++)
*pb++ = v; *pb++ = v;
} }
}
s->output_overlap = output_overlap_float; s->output_overlap = output_overlap_float;
} }
} }
s->frames_search = (frames_overlap > 1) ? srate * s->ms_search : 0; 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; s->best_overlap_offset = NULL;
} else { else {
if (use_int) { if (use_int) {
int64_t t = frames_overlap; int64_t t = frames_overlap;
int32_t n = 8589934588LL / (t * t); // 4 * (2^31 - 1) / t^2 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->buf_pre_corr = realloc(s->buf_pre_corr, s->bytes_overlap * 2 + UNROLL_PADDING); s->bytes_overlap * 2 + UNROLL_PADDING);
s->table_window = realloc(s->table_window, s->bytes_overlap * 2 - nch * bps * 2); s->table_window = realloc(s->table_window,
s->bytes_overlap * 2 - nch * bps * 2);
if (!s->buf_pre_corr || !s->table_window) { if (!s->buf_pre_corr || !s->table_window) {
mp_msg(MSGT_AFILTER, MSGL_FATAL, "[scaletempo] Out of memory\n"); mp_msg(MSGT_AFILTER, MSGL_FATAL, "[scaletempo] Out of memory\n");
return AF_ERROR; return AF_ERROR;
} }
memset((char *)s->buf_pre_corr + s->bytes_overlap * 2, 0, UNROLL_PADDING); memset((char *)s->buf_pre_corr + s->bytes_overlap * 2, 0,
pw = s->table_window; UNROLL_PADDING);
for (i=1; i<frames_overlap; i++) { int32_t *pw = s->table_window;
for (int i = 1; i < frames_overlap; i++) {
int32_t v = (i * (t - i) * n) >> 15; int32_t v = (i * (t - i) * n) >> 15;
for (j=0; j<nch; j++) { for (int j = 0; j < nch; j++)
*pw++ = v; *pw++ = v;
} }
}
s->best_overlap_offset = best_overlap_offset_s16; s->best_overlap_offset = best_overlap_offset_s16;
} else { } else {
float* pw;
s->buf_pre_corr = realloc(s->buf_pre_corr, s->bytes_overlap); s->buf_pre_corr = realloc(s->buf_pre_corr, s->bytes_overlap);
s->table_window = realloc(s->table_window, s->bytes_overlap - nch * bps); s->table_window = realloc(s->table_window,
s->bytes_overlap - nch * bps);
if (!s->buf_pre_corr || !s->table_window) { if (!s->buf_pre_corr || !s->table_window) {
mp_msg(MSGT_AFILTER, MSGL_FATAL, "[scaletempo] Out of memory\n"); mp_msg(MSGT_AFILTER, MSGL_FATAL,
"[scaletempo] Out of memory\n");
return AF_ERROR; return AF_ERROR;
} }
pw = s->table_window; float *pw = s->table_window;
for (i=1; i<frames_overlap; i++) { for (int i = 1; i < frames_overlap; i++) {
float v = 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; *pw++ = v;
} }
}
s->best_overlap_offset = best_overlap_offset_float; s->best_overlap_offset = best_overlap_offset_float;
} }
} }
@ -441,9 +427,8 @@ static int control(struct af_instance* af, int cmd, void* arg)
} }
case AF_CONTROL_PLAYBACK_SPEED | AF_CONTROL_SET: { case AF_CONTROL_PLAYBACK_SPEED | AF_CONTROL_SET: {
if (s->speed_tempo) { if (s->speed_tempo) {
if (s->speed_pitch) { if (s->speed_pitch)
break; break;
}
s->speed = *(double *)arg; s->speed = *(double *)arg;
s->scale = s->speed * s->scale_nominal; s->scale = s->speed * s->scale_nominal;
} else { } else {
@ -484,7 +469,8 @@ static void uninit(struct af_instance* af)
#define SCALE_PITCH 2 #define SCALE_PITCH 2
// Allocate memory and set function pointers // 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_scaletempo_t *s = af->priv;
af->control = control; af->control = control;
@ -499,8 +485,6 @@ static int af_open(struct af_instance* af){
s->speed_pitch = !!(s->speed_opt & SCALE_PITCH); s->speed_pitch = !!(s->speed_opt & SCALE_PITCH);
s->scale = s->speed * s->scale_nominal; 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; return AF_OK;
} }