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; }