36 #define FREQUENCY_DOMAIN 1 93 int len,
i, channel_id = 0;
96 if (sscanf(*arg,
"%7[A-Z]%n", buf, &len)) {
100 for (i = 32; i > 0; i >>= 1) {
101 if (layout >= 1LL << i) {
106 if (channel_id >= 64 || layout0 != 1LL << channel_id)
108 *rchannel = channel_id;
128 for (i = 0; i < 64; i++) {
132 while ((arg =
av_strtok(p,
"|", &tokenizer))) {
173 const float *
const ir = td->
ir[jobnr];
179 const float *
src = (
const float *)in->
data[0];
180 float *dst = (
float *)
out->data[0];
181 const int in_channels = in->
channels;
183 const uint32_t modulo = (uint32_t)buffer_length - 1;
190 for (l = 0; l < in_channels; l++) {
195 const float *temp_ir = ir;
198 for (l = 0; l < in_channels; l++) {
199 *(buffer[l] + wr) = src[l];
202 for (l = 0; l < in_channels; l++) {
203 const float *
const bptr = buffer[l];
211 read = (wr - *(delay + l) - (ir_len - 1) +
buffer_length) & modulo;
213 if (read + ir_len < buffer_length) {
214 memcpy(temp_src, bptr + read, ir_len *
sizeof(*temp_src));
216 int len =
FFMIN(air_len - (read % ir_len), buffer_length - read);
218 memcpy(temp_src, bptr + read, len *
sizeof(*temp_src));
219 memcpy(temp_src + len, bptr, (air_len - len) *
sizeof(*temp_src));
226 if (fabsf(dst[0]) > 1)
231 wr = (wr + 1) & modulo;
250 const float *
src = (
const float *)in->
data[0];
251 float *dst = (
float *)
out->data[0];
252 const int in_channels = in->
channels;
254 const uint32_t modulo = (uint32_t)buffer_length - 1;
260 const float fft_scale = 1.0f / s->
n_fft;
269 for (j = 0; j < n_read; j++) {
270 dst[2 * j] = ringbuffer[wr];
271 ringbuffer[wr] = 0.0;
272 wr = (wr + 1) & modulo;
279 memset(fft_acc, 0,
sizeof(
FFTComplex) * n_fft);
281 for (i = 0; i < in_channels; i++) {
284 dst[2 * j] += src[i + j * in_channels] * s->
gain_lfe;
290 hrtf_offset = hrtf +
offset;
292 memset(fft_in, 0,
sizeof(
FFTComplex) * n_fft);
295 fft_in[j].
re = src[j * in_channels +
i];
300 for (j = 0; j <
n_fft; j++) {
302 const float re = fft_in[j].
re;
303 const float im = fft_in[j].
im;
305 fft_acc[j].
re += re * hcomplex->
re - im * hcomplex->
im;
306 fft_acc[j].
im += re * hcomplex->
im + im * hcomplex->
re;
314 dst[2 * j] += fft_acc[j].
re * fft_scale;
317 for (j = 0; j < ir_len - 1; j++) {
318 int write_pos = (wr + j) & modulo;
320 *(ringbuffer + write_pos) += fft_acc[in->
nb_samples + j].
re * fft_scale;
323 for (i = 0; i <
out->nb_samples; i++) {
324 if (fabsf(dst[0]) > 1) {
344 if (ir_len > max_ir_len) {
357 int n_clippings[2] = { 0 };
381 if (n_clippings[0] + n_clippings[1] > 0) {
383 n_clippings[0] + n_clippings[1], out->
nb_samples * 2);
396 float gain_lin =
expf((s->
gain - 3 * nb_input_channels) / 20 *
M_LN10);
401 float *data_ir_l =
NULL;
402 float *data_ir_r =
NULL;
412 fft_in_l =
av_calloc(n_fft,
sizeof(*fft_in_l));
413 fft_in_r =
av_calloc(n_fft,
sizeof(*fft_in_r));
414 if (!fft_in_l || !fft_in_r) {
474 data_hrtf_l =
av_calloc(n_fft,
sizeof(*data_hrtf_l) * nb_irs);
475 data_hrtf_r =
av_calloc(n_fft,
sizeof(*data_hrtf_r) * nb_irs);
476 if (!data_hrtf_r || !data_hrtf_l) {
496 for (j = 0; j < inlink->
channels; j++) {
511 for (j = 0; j <
len; j++) {
512 data_ir_l[offset + j] = ptr[len * 2 - j * 2 - 2] * gain_lin;
513 data_ir_r[offset + j] = ptr[len * 2 - j * 2 - 1] * gain_lin;
516 memset(fft_in_l, 0, n_fft *
sizeof(*fft_in_l));
517 memset(fft_in_r, 0, n_fft *
sizeof(*fft_in_r));
519 offset = idx *
n_fft;
520 for (j = 0; j <
len; j++) {
521 fft_in_l[delay_l + j].
re = ptr[j * 2 ] * gain_lin;
522 fft_in_r[delay_r + j].
re = ptr[j * 2 + 1] * gain_lin;
527 memcpy(data_hrtf_l + offset, fft_in_l, n_fft *
sizeof(*fft_in_l));
530 memcpy(data_hrtf_r + offset, fft_in_r, n_fft *
sizeof(*fft_in_r));
535 for (k = 0; k < N / 2; k++) {
538 for (j = 0; j < inlink->
channels; j++) {
554 for (j = 0; j <
len; j++) {
555 data_ir_l[offset + j] = ptr[len * N - j * N - N + I ] * gain_lin;
556 data_ir_r[offset + j] = ptr[len * N - j * N - N + I + 1] * gain_lin;
559 memset(fft_in_l, 0, n_fft *
sizeof(*fft_in_l));
560 memset(fft_in_r, 0, n_fft *
sizeof(*fft_in_r));
562 offset = idx *
n_fft;
563 for (j = 0; j <
len; j++) {
564 fft_in_l[delay_l + j].
re = ptr[j * N + I ] * gain_lin;
565 fft_in_r[delay_r + j].
re = ptr[j * N + I + 1] * gain_lin;
570 memcpy(data_hrtf_l + offset, fft_in_l, n_fft *
sizeof(*fft_in_l));
573 memcpy(data_hrtf_r + offset, fft_in_r, n_fft *
sizeof(*fft_in_r));
582 memcpy(s->
data_ir[0], data_ir_l,
sizeof(
float) * nb_irs * s->
air_len);
583 memcpy(s->
data_ir[1], data_ir_r,
sizeof(
float) * nb_irs * s->
air_len);
844 #define OFFSET(x) offsetof(HeadphoneContext, x) 845 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM 874 .description =
NULL_IF_CONFIG_SMALL(
"Apply headphone binaural spatialization with HRTFs in additional streams."),
876 .priv_class = &headphone_class,
float(* scalarproduct_float)(const float *v1, const float *v2, int len)
Calculate the scalar product of two vectors of floats.
static int config_output(AVFilterLink *outlink)
This structure describes decoded (raw) audio or video data.
av_cold void av_fft_end(FFTContext *s)
static int convert_coeffs(AVFilterContext *ctx, AVFilterLink *inlink)
#define AV_LOG_WARNING
Something somehow does not look correct.
#define FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, filter)
Forward the status on an output link to all input links.
Main libavfilter public API header.
#define AVFILTER_FLAG_DYNAMIC_INPUTS
The number of the filter inputs is not determined just by AVFilter.inputs.
void av_fft_permute(FFTContext *s, FFTComplex *z)
Do the permutation needed BEFORE calling ff_fft_calc().
#define AV_CH_LAYOUT_STEREO
struct AVFilterChannelLayouts * in_channel_layouts
void ff_inlink_request_frame(AVFilterLink *link)
Mark that a frame is wanted on the link.
static int ff_outlink_frame_wanted(AVFilterLink *link)
Test if a frame is wanted on an output link.
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
static int activate(AVFilterContext *ctx)
const char * name
Pad name.
uint64_t av_get_channel_layout(const char *name)
Return a channel layout id that matches name, or 0 if no match is found.
AVFilterLink ** inputs
array of pointers to input links
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
static int parse_channel_name(HeadphoneContext *s, int x, char **arg, int *rchannel, char *buf)
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
#define AV_CH_LOW_FREQUENCY
#define AVERROR_EOF
End of file.
static int config_input(AVFilterLink *inlink)
A filter pad used for either input or output.
A link between two filters.
AVFilterPad * input_pads
array of input pads
#define i(width, name, range_min, range_max)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
void * priv
private data for use by the filter
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
static void parse_map(AVFilterContext *ctx)
static const AVFilterPad outputs[]
struct AVFilterChannelLayouts * out_channel_layouts
FFTContext * av_fft_init(int nbits, int inverse)
Set up a complex FFT.
static const uint8_t offset[127][2]
static av_cold void uninit(AVFilterContext *ctx)
AVFILTER_DEFINE_CLASS(headphone)
char * av_asprintf(const char *fmt,...)
static int headphone_convolute(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
FFTComplex * data_hrtf[2]
int channels
number of audio channels, only used for audio.
audio channel layout utility functions
int ff_inlink_queued_samples(AVFilterLink *link)
const char AVS_Value args
static int query_formats(AVFilterContext *ctx)
AVFilterContext * src
source filter
static const AVFilterPad inputs[]
static const AVOption headphone_options[]
A list of supported channel layouts.
static int headphone_frame(HeadphoneContext *s, AVFrame *in, AVFilterLink *outlink)
char * av_strdup(const char *s)
Duplicate a string.
Used for passing data between threads.
int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max, AVFrame **rframe)
Take samples from the link's FIFO and update the link's stats.
Describe the class of an AVClass context structure.
int ff_outlink_get_status(AVFilterLink *link)
Get the status on an output link.
const char * name
Filter name.
FFTComplex * temp_afft[2]
AVFilterLink ** outputs
array of pointers to output links
enum MovChannelLayoutTag * layouts
#define FF_FILTER_FORWARD_STATUS(inlink, outlink)
Acknowledge the status on an input link and forward it to an output link.
static av_cold int init(AVFilterContext *ctx)
#define flags(name, subs,...)
AVFilterInternal * internal
An opaque struct for libavfilter internal use.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
struct HeadphoneContext::headphone_inputs * in
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok()...
uint64_t av_channel_layout_extract_channel(uint64_t channel_layout, int index)
Get the channel with the given index in channel_layout.
uint64_t channel_layout
channel layout of current buffer (see libavutil/channel_layout.h)
int channels
Number of channels.
avfilter_execute_func * execute
AVFilterContext * dst
dest filter
static int headphone_fast_convolute(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static int check_ir(AVFilterLink *inlink, int input_number)
uint8_t ** extended_data
pointers to the data planes/channels.
void av_fft_calc(FFTContext *s, FFTComplex *z)
Do a complex FFT with the parameters defined in av_fft_init().
int nb_samples
number of audio samples (per channel) described by this frame
static int ff_insert_inpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new input pad for the filter.