int AudioController::filter(af_instance *af, mp_audio *data, int /*flags*/) {
auto ac = priv(af); auto d = ac->d;
d->af->delay = 0.0;
Q_ASSERT(d->mixer != nullptr);
if (d->dirty) {
if (d->dirty & Amp)
d->mixer->setAmp(d->amp);
if (d->dirty & Normalizer)
d->mixer->setNormalizer(d->normalizerActivated, d->normalizerOption);
if (d->dirty & ChMap)
d->mixer->setChannelLayoutMap(d->map);
if (d->dirty & Scale)
d->mixer->setScaler(d->tempoScalerActivated, d->scale);
d->dirty = 0;
}
const mp_audio *in = data;
if (d->resample) {
const int frames_delay = swr_get_delay(d->swr, data->rate);
const int frames = av_rescale_rnd(frames_delay + data->samples, d->resampled->rate, data->rate, AV_ROUND_UP);
mp_audio_realloc_min(d->resampled, frames);
d->af->delay = (double)frames/data->rate;
if ((d->resampled->samples = frames))
d->resampled->samples = swr_convert(d->swr, (uchar**)d->resampled->planes, d->resampled->samples, (const uchar**)data->planes, data->samples);
in = d->resampled;
}
d->mixer->apply(in);
*data = *d->af->data;
af->delay += d->mixer->delay();
return 0;
}
// Filter data through filter
static struct mp_audio *play(struct af_instance *af, struct mp_audio *data)
{
af_scaletempo_t *s = af->priv;
if (s->scale == 1.0) {
af->delay = 0;
return data;
}
mp_audio_realloc_min(af->data,
((int)(data->samples / s->frames_stride_scaled) + 1) * s->frames_stride);
int offset_in = fill_queue(af, data, 0);
int8_t *pout = af->data->planes[0];
while (s->bytes_queued >= s->bytes_queue) {
int ti;
float tf;
int bytes_off = 0;
// output stride
if (s->output_overlap) {
if (s->best_overlap_offset)
bytes_off = s->best_overlap_offset(s);
s->output_overlap(s, pout, bytes_off);
}
memcpy(pout + s->bytes_overlap,
s->buf_queue + bytes_off + s->bytes_overlap,
s->bytes_standing);
pout += s->bytes_stride;
// input stride
memcpy(s->buf_overlap,
s->buf_queue + bytes_off + s->bytes_stride,
s->bytes_overlap);
tf = s->frames_stride_scaled + s->frames_stride_error;
ti = (int)tf;
s->frames_stride_error = tf - ti;
s->bytes_to_slide = ti * s->bytes_per_frame;
offset_in += fill_queue(af, data, offset_in);
}
// This filter can have a negative delay when scale > 1:
// output corresponding to some length of input can be decided and written
// after receiving only a part of that input.
af->delay = (s->bytes_queued - s->bytes_to_slide) / s->scale
/ af->data->sstride / af->data->rate;
data->planes[0] = af->data->planes[0];
data->samples = (pout - (int8_t *)af->data->planes[0]) / af->data->sstride;
return data;
}
static struct mp_audio *play(struct af_instance *af, struct mp_audio *data)
{
struct af_resample *s = af->priv;
struct mp_audio *in = data;
struct mp_audio *out = af->data;
out->samples = avresample_available(s->avrctx) +
av_rescale_rnd(get_delay(s) + in->samples,
s->ctx.out_rate, s->ctx.in_rate, AV_ROUND_UP);
mp_audio_realloc_min(out, out->samples);
af->delay = get_delay(s) / (double)s->ctx.in_rate;
#if !USE_SET_CHANNEL_MAPPING
do_reorder(in, s->reorder_in);
#endif
if (out->samples) {
out->samples = avresample_convert(s->avrctx,
(uint8_t **) out->planes, out->samples * out->sstride, out->samples,
(uint8_t **) in->planes, in->samples * in->sstride, in->samples);
if (out->samples < 0)
return NULL; // error
}
*data = *out;
#if USE_SET_CHANNEL_MAPPING
if (needs_reorder(s->reorder_out, out->nch)) {
if (af_fmt_is_planar(out->format)) {
reorder_planes(data, s->reorder_out);
} else {
int out_size = out->samples * out->sstride;
if (talloc_get_size(s->reorder_buffer) < out_size)
s->reorder_buffer = talloc_realloc_size(s, s->reorder_buffer, out_size);
data->planes[0] = s->reorder_buffer;
int out_samples = avresample_convert(s->avrctx_out,
(uint8_t **) data->planes, out_size, out->samples,
(uint8_t **) out->planes, out_size, out->samples);
assert(out_samples == data->samples);
}
}
#else
do_reorder(data, s->reorder_out);
#endif
return data;
}
// Copy data from input frame to encode frame (because libavcodec wants a full
// AC3 frame for encoding, while filter input frames can be smaller or larger).
// Return true if the frame is complete.
static bool fill_buffer(struct af_instance *af)
{
af_ac3enc_t *s = af->priv;
af->delay = 0;
if (s->pending) {
if (!mp_audio_is_writeable(s->input))
assert(s->input->samples == 0); // we can't have sent a partial frame
mp_audio_realloc_min(s->input, s->in_samples);
int copy = MPMIN(s->in_samples - s->input->samples, s->pending->samples);
s->input->samples += copy;
mp_audio_copy(s->input, s->input->samples - copy, s->pending, 0, copy);
mp_audio_skip_samples(s->pending, copy);
}
update_delay(af);
return s->input->samples >= s->in_samples;
}
// Filter data through filter
static int filter(struct af_instance* af, struct mp_audio* data, int flags)
{
struct mp_audio* c = data; // Current working data
struct mp_audio* l = af->data; // Local data
af_channels_t* s = af->priv;
int i;
mp_audio_realloc_min(af->data, data->samples);
// Reset unused channels
memset(l->planes[0],0,mp_audio_psize(c) / c->nch * l->nch);
if(AF_OK == check_routes(af,c->nch,l->nch))
for(i=0;i<s->nr;i++)
copy(af, c->planes[0],l->planes[0],c->nch,s->route[i][FR],
l->nch,s->route[i][TO],mp_audio_psize(c),c->bps);
// Set output data
c->planes[0] = l->planes[0];
mp_audio_set_channels(c, &l->channels);
return 0;
}
// Filter data through filter
static int filter(struct af_instance* af, struct mp_audio* audio, int flags)
{
struct mp_audio *out = af->data;
af_ac3enc_t *s = af->priv;
int num_frames = (audio->samples + mp_audio_buffer_samples(s->pending))
/ s->in_samples;
int max_out_samples = s->out_samples * num_frames;
mp_audio_realloc_min(out, max_out_samples);
out->samples = 0;
while (audio->samples > 0) {
int ret;
int consumed_pending = 0;
struct mp_audio in_frame;
int pending = mp_audio_buffer_samples(s->pending);
if (pending == 0 && audio->samples >= s->in_samples) {
in_frame = *audio;
mp_audio_skip_samples(audio, s->in_samples);
} else {
if (pending > 0 && pending < s->in_samples) {
struct mp_audio tmp = *audio;
tmp.samples = MPMIN(tmp.samples, s->in_samples);
mp_audio_buffer_append(s->pending, &tmp);
mp_audio_skip_samples(audio, tmp.samples);
}
mp_audio_buffer_peek(s->pending, &in_frame);
if (in_frame.samples < s->in_samples)
break;
consumed_pending = s->in_samples;
}
in_frame.samples = s->in_samples;
AVFrame *frame = av_frame_alloc();
if (!frame) {
MP_FATAL(af, "Could not allocate memory \n");
return -1;
}
frame->nb_samples = s->in_samples;
frame->format = s->lavc_actx->sample_fmt;
frame->channel_layout = s->lavc_actx->channel_layout;
assert(in_frame.num_planes <= AV_NUM_DATA_POINTERS);
frame->extended_data = frame->data;
for (int n = 0; n < in_frame.num_planes; n++)
frame->data[n] = in_frame.planes[n];
frame->linesize[0] = s->in_samples * audio->sstride;
int ok;
ret = avcodec_encode_audio2(s->lavc_actx, &s->pkt, frame, &ok);
av_frame_free(&frame);
if (ret < 0 || !ok) {
MP_FATAL(af, "Encode failed.\n");
return -1;
}
mp_audio_buffer_skip(s->pending, consumed_pending);
MP_DBG(af, "avcodec_encode_audio got %d, pending %d.\n",
s->pkt.size, mp_audio_buffer_samples(s->pending));
int frame_size = s->pkt.size;
int header_len = 0;
char hdr[8];
if (s->cfg_add_iec61937_header && s->pkt.size > 5) {
int bsmod = s->pkt.data[5] & 0x7;
int len = frame_size;
frame_size = AC3_FRAME_SIZE * 2 * 2;
header_len = 8;
AV_WB16(hdr, 0xF872); // iec 61937 syncword 1
AV_WB16(hdr + 2, 0x4E1F); // iec 61937 syncword 2
hdr[4] = bsmod; // bsmod
hdr[5] = 0x01; // data-type ac3
AV_WB16(hdr + 6, len << 3); // number of bits in payload
}
size_t max_size = (max_out_samples - out->samples) * out->sstride;
if (frame_size > max_size)
abort();
char *buf = (char *)out->planes[0] + out->samples * out->sstride;
memcpy(buf, hdr, header_len);
memcpy(buf + header_len, s->pkt.data, s->pkt.size);
memset(buf + header_len + s->pkt.size, 0,
frame_size - (header_len + s->pkt.size));
out->samples += frame_size / out->sstride;
}
mp_audio_buffer_append(s->pending, audio);
*audio = *out;
return 0;
}
/* Filter data through filter
Two "tricks" are used to compensate the "color" of the KEMAR data:
1. The KEMAR data is refiltered to ensure that the front L, R channels
on the same side of the ear are equalized (especially in the high
frequencies).
2. A bass compensation is introduced to ensure that 0-200 Hz are not
damped (without any real 3D acoustical image, however).
*/
static struct mp_audio* play(struct af_instance *af, struct mp_audio *data)
{
af_hrtf_t *s = af->setup;
short *in = data->planes[0]; // Input audio data
short *out = NULL; // Output audio data
short *end = in + data->samples * data->nch; // Loop end
float common, left, right, diff, left_b, right_b;
const int dblen = s->dlbuflen, hlen = s->hrflen, blen = s->basslen;
mp_audio_realloc_min(af->data, data->samples);
if(s->print_flag) {
s->print_flag = 0;
switch (s->decode_mode) {
case HRTF_MIX_51:
mp_msg(MSGT_AFILTER, MSGL_INFO,
"[hrtf] Using HRTF to mix %s discrete surround into "
"L, R channels\n", s->matrix_mode ? "5+1" : "5");
break;
case HRTF_MIX_STEREO:
mp_msg(MSGT_AFILTER, MSGL_INFO,
"[hrtf] Using HRTF to mix stereo into "
"L, R channels\n");
break;
case HRTF_MIX_MATRIX2CH:
mp_msg(MSGT_AFILTER, MSGL_INFO,
"[hrtf] Using active matrix to decode 2 channel "
"input, HRTF to mix %s matrix surround into "
"L, R channels\n", "3/2");
break;
default:
mp_msg(MSGT_AFILTER, MSGL_WARN,
"[hrtf] bogus decode_mode: %d\n", s->decode_mode);
break;
}
if(s->matrix_mode)
mp_msg(MSGT_AFILTER, MSGL_INFO,
"[hrtf] Using active matrix to decode rear center "
"channel\n");
}
out = af->data->planes[0];
/* MPlayer's 5 channel layout (notation for the variable):
*
* 0: L (LF), 1: R (RF), 2: Ls (LR), 3: Rs (RR), 4: C (CF), matrix
* encoded: Cs (CR)
*
* or: L = left, C = center, R = right, F = front, R = rear
*
* Filter notation:
*
* CF
* OF AF
* Ear->
* OR AR
* CR
*
* or: C = center, A = same side, O = opposite, F = front, R = rear
*/
while(in < end) {
const int k = s->cyc_pos;
update_ch(s, in, k);
/* Simulate a 7.5 ms -20 dB echo of the center channel in the
front channels (like reflection from a room wall) - a kind of
psycho-acoustically "cheating" to focus the center front
channel, which is normally hard to be perceived as front */
s->lf[k] += CFECHOAMPL * s->cf[(k + CFECHODELAY) % s->dlbuflen];
s->rf[k] += CFECHOAMPL * s->cf[(k + CFECHODELAY) % s->dlbuflen];
switch (s->decode_mode) {
case HRTF_MIX_51:
case HRTF_MIX_MATRIX2CH:
/* Mixer filter matrix */
common = conv(dblen, hlen, s->cf, s->cf_ir, k + s->cf_o);
if(s->matrix_mode) {
/* In matrix decoding mode, the rear channel gain must be
renormalized, as there is an additional channel. */
matrix_decode(in, k, 2, 3, 0, s->dlbuflen,
s->lr_fwr, s->rr_fwr,
s->lrprr_fwr, s->lrmrr_fwr,
&(s->adapt_lr_gain), &(s->adapt_rr_gain),
&(s->adapt_lrprr_gain), &(s->adapt_lrmrr_gain),
s->lr, s->rr, NULL, NULL, s->cr);
common +=
conv(dblen, hlen, s->cr, s->cr_ir, k + s->cr_o) *
M1_76DB;
left =
( conv(dblen, hlen, s->lf, s->af_ir, k + s->af_o) +
conv(dblen, hlen, s->rf, s->of_ir, k + s->of_o) +
(conv(dblen, hlen, s->lr, s->ar_ir, k + s->ar_o) +
conv(dblen, hlen, s->rr, s->or_ir, k + s->or_o)) *
M1_76DB + common);
right =
( conv(dblen, hlen, s->rf, s->af_ir, k + s->af_o) +
conv(dblen, hlen, s->lf, s->of_ir, k + s->of_o) +
(conv(dblen, hlen, s->rr, s->ar_ir, k + s->ar_o) +
conv(dblen, hlen, s->lr, s->or_ir, k + s->or_o)) *
M1_76DB + common);
} else {
left =
( conv(dblen, hlen, s->lf, s->af_ir, k + s->af_o) +
conv(dblen, hlen, s->rf, s->of_ir, k + s->of_o) +
conv(dblen, hlen, s->lr, s->ar_ir, k + s->ar_o) +
conv(dblen, hlen, s->rr, s->or_ir, k + s->or_o) +
common);
right =
( conv(dblen, hlen, s->rf, s->af_ir, k + s->af_o) +
conv(dblen, hlen, s->lf, s->of_ir, k + s->of_o) +
conv(dblen, hlen, s->rr, s->ar_ir, k + s->ar_o) +
conv(dblen, hlen, s->lr, s->or_ir, k + s->or_o) +
common);
}
break;
case HRTF_MIX_STEREO:
left =
( conv(dblen, hlen, s->lf, s->af_ir, k + s->af_o) +
conv(dblen, hlen, s->rf, s->of_ir, k + s->of_o));
right =
( conv(dblen, hlen, s->rf, s->af_ir, k + s->af_o) +
conv(dblen, hlen, s->lf, s->of_ir, k + s->of_o));
break;
default:
/* make gcc happy */
left = 0.0;
right = 0.0;
break;
}
/* Bass compensation for the lower frequency cut of the HRTF. A
cross talk of the left and right channel is introduced to
match the directional characteristics of higher frequencies.
The bass will not have any real 3D perception, but that is
OK (note at 180 Hz, the wavelength is about 2 m, and any
spatial perception is impossible). */
left_b = conv(dblen, blen, s->ba_l, s->ba_ir, k);
right_b = conv(dblen, blen, s->ba_r, s->ba_ir, k);
left += (1 - BASSCROSS) * left_b + BASSCROSS * right_b;
right += (1 - BASSCROSS) * right_b + BASSCROSS * left_b;
/* Also mix the LFE channel (if available) */
if(data->nch >= 6) {
left += in[5] * M3_01DB;
right += in[5] * M3_01DB;
}
/* Amplitude renormalization. */
left *= AMPLNORM;
right *= AMPLNORM;
switch (s->decode_mode) {
case HRTF_MIX_51:
case HRTF_MIX_STEREO:
/* "Cheating": linear stereo expansion to amplify the 3D
perception. Note: Too much will destroy the acoustic space
and may even result in headaches. */
diff = STEXPAND2 * (left - right);
out[0] = av_clip_int16(left + diff);
out[1] = av_clip_int16(right - diff);
break;
case HRTF_MIX_MATRIX2CH:
/* Do attempt any stereo expansion with matrix encoded
sources. The L, R channels are already stereo expanded
by the steering, any further stereo expansion will sound
very unnatural. */
out[0] = av_clip_int16(left);
out[1] = av_clip_int16(right);
break;
}
/* Next sample... */
in = &in[data->nch];
out = &out[af->data->nch];
(s->cyc_pos)--;
if(s->cyc_pos < 0)
s->cyc_pos += dblen;
}
/* Set output data */
data->planes[0] = af->data->planes[0];
mp_audio_set_num_channels(data, 2);
return data;
}
// Filter data through filter
static int filter(struct af_instance* af, struct mp_audio* data, int flags){
af_surround_t* s = (af_surround_t*)af->priv;
const float* m = steering_matrix[0];
float* in = data->planes[0]; // Input audio data
float* out = NULL; // Output audio data
float* end = in + data->samples * data->nch;
int i = s->i; // Filter queue index
int ri = s->ri; // Read index for delay queue
int wi = s->wi; // Write index for delay queue
mp_audio_realloc_min(af->data, data->samples);
out = af->data->planes[0];
while(in < end){
/* Dominance:
abs(in[0]) abs(in[1]);
abs(in[0]+in[1]) abs(in[0]-in[1]);
10 * log( abs(in[0]) / (abs(in[1])|1) );
10 * log( abs(in[0]+in[1]) / (abs(in[0]-in[1])|1) ); */
/* About volume balancing...
Surround encoding does the following:
Lt=L+.707*C+.707*S, Rt=R+.707*C-.707*S
So S should be extracted as:
(Lt-Rt)
But we are splitting the S to two output channels, so we
must take 3dB off as we split it:
Ls=Rs=.707*(Lt-Rt)
Trouble is, Lt could be +1, Rt -1, so possibility that S will
overflow. So to avoid that, we cut L/R by 3dB (*.707), and S by
6dB (/2). This keeps the overall balance, but guarantees no
overflow. */
// Output front left and right
out[0] = m[0]*in[0] + m[1]*in[1];
out[1] = m[2]*in[0] + m[3]*in[1];
// Low-pass output @ 7kHz
FIR((&s->lq[i]), s->w, s->dl[wi]);
// Delay output by d ms
out[2] = s->dl[ri];
#ifdef SPLITREAR
// Low-pass output @ 7kHz
FIR((&s->rq[i]), s->w, s->dr[wi]);
// Delay output by d ms
out[3] = s->dr[ri];
#else
out[3] = -out[2];
#endif
// Update delay queues indexes
UPDATEQI(ri);
UPDATEQI(wi);
// Calculate and save surround in circular queue
#ifdef SPLITREAR
ADDQUE(i, s->rq, s->lq, m[6]*in[0]+m[7]*in[1], m[8]*in[0]+m[9]*in[1]);
#else
ADDQUE(i, s->lq, m[4]*in[0]+m[5]*in[1]);
#endif
// Next sample...
in = &in[data->nch];
out = &out[af->data->nch];
}
// Save indexes
s->i = i; s->ri = ri; s->wi = wi;
// Set output data
data->planes[0] = af->data->planes[0];
mp_audio_set_channels_old(data, af->data->nch);
return 0;
}
static int filter(struct af_instance *af, struct mp_audio *data, int flags)
{
struct priv *p = af->priv;
struct mp_audio *r = af->data;
bool eof = data->samples == 0 && (flags & AF_FILTER_FLAG_EOF);
AVFilterLink *l_in = p->in->outputs[0];
AVFrame *frame = av_frame_alloc();
frame->nb_samples = data->samples;
frame->format = l_in->format;
// Timebase is 1/sample_rate
frame->pts = p->samples_in;
frame->channel_layout = l_in->channel_layout;
frame->sample_rate = l_in->sample_rate;
#if LIBAVFILTER_VERSION_MICRO >= 100
// FFmpeg being a stupid POS
frame->channels = l_in->channels;
#endif
frame->extended_data = frame->data;
for (int n = 0; n < data->num_planes; n++)
frame->data[n] = data->planes[n];
frame->linesize[0] = frame->nb_samples * data->sstride;
if (av_buffersrc_add_frame(p->in, eof ? NULL : frame) < 0) {
av_frame_free(&frame);
return -1;
}
av_frame_free(&frame);
int64_t out_pts = AV_NOPTS_VALUE;
r->samples = 0;
for (;;) {
frame = av_frame_alloc();
if (av_buffersink_get_frame(p->out, frame) < 0) {
// Not an error situation - no more output buffers in queue.
av_frame_free(&frame);
break;
}
mp_audio_realloc_min(r, r->samples + frame->nb_samples);
for (int n = 0; n < r->num_planes; n++) {
memcpy((char *)r->planes[n] + r->samples * r->sstride,
frame->extended_data[n], frame->nb_samples * r->sstride);
}
r->samples += frame->nb_samples;
if (out_pts == AV_NOPTS_VALUE)
out_pts = frame->pts;
av_frame_free(&frame);
}
p->samples_in += data->samples;
if (out_pts != AV_NOPTS_VALUE) {
double in_time = p->samples_in / (double)data->rate;
double out_time = out_pts * av_q2d(p->timebase_out);
// Need pts past the last output sample.
out_time += r->samples / (double)r->rate;
af->delay = in_time - out_time;
}
*data = *r;
return 0;
}
