Подтвердить что ты не робот

Фильтр нижних частот iphone

Я пытаюсь реализовать фильтр нижних частот для приложения iphone, где я записываю звук, а затем он слегка воспроизводится, как голос идет из другой комнаты.

Я рассмотрел различные варианты записи и манипуляции аудио и нашел это немного запутанным... обработка цифрового сигнала не является сильной стороной. Я в основном смотрел OpenAL и внутри EFX-библиотеки есть фильтр, который специально делает то, что мне нужно, но EFX не включен в iPhone. Есть ли способ воспроизвести это поведение с помощью OpenAL для iPhone? Есть ли еще один вариант, например, аудиоустройства, которые могут обеспечить решение?

Спасибо за помощь

EDIT:

Итак, после ответа Тома и ссылок, я придумал то, что, по моему мнению, является правильной реализацией. Тем не менее, я не получаю эффект приглушения вообще, а просто уменьшение объема. Здесь (суммированный) код, который у меня есть:

Файл записывается с использованием AVAudioRecorder и следующих настроек:

[recordSetting setValue :[NSNumber numberWithInt:kAudioFormatLinearPCM] forKey:AVFormatIDKey];
[recordSetting setValue:[NSNumber numberWithFloat:44100] forKey:AVSampleRateKey];
[recordSetting setValue:[NSNumber numberWithInt: 1] forKey:AVNumberOfChannelsKey];

[recordSetting setValue :[NSNumber numberWithInt:16] forKey:AVLinearPCMBitDepthKey];
[recordSetting setValue :[NSNumber numberWithBool:NO] forKey:AVLinearPCMIsBigEndianKey];
[recordSetting setValue :[NSNumber numberWithBool:NO] forKey:AVLinearPCMIsFloatKey];

Затем я читаю в файле и преобразую его с помощью кода ниже:

// Read in the file using AudioFileOpenURL
AudioFileID fileID = [self openAudioFile:filePath];

// find out how big the actual audio data is
UInt32 fileSize = [self audioFileSize:fileID];

// allocate the memory to hold the file
SInt16 * outData = (SInt16 *)malloc(fileSize); 

// Read in the file to outData
OSStatus result = noErr;
result = AudioFileReadBytes(fileID, false, 0, &fileSize, outData);

// close off the file
AudioFileClose(fileID);

// Allocate memory to hold the transformed values
SInt16 * transformData = (SInt16 *)malloc(fileSize);

// Start the transform - Need to set alpha to 0.15 or below to have a noticeable affect
float alpha = 1;         

// Code as per Tom example
transformData[0] = outData[0];

for(int sample = 1; sample < fileSize / sizeof(SInt16); sample ++) 
{
     transformData[sample] = transformData[sample - 1] + alpha * (outData[sample] - transformData[sample - 1]);
}

// Add the data to OpenAL buffer
NSUInteger bufferID;
// grab a buffer ID from openAL
alGenBuffers(1, &bufferID);

// Add the audio data into the new buffer
alBufferData(bufferID,AL_FORMAT_MONO16,transformData,fileSize,44100);

Итак, после этого я затем запускаю его через OpenAL с использованием стандартного метода (я не думаю, что это повлияло на мои результаты, поэтому я не буду включать его здесь.)

Я проследил результаты, как до, так и после преобразования, и они кажутся мне верными, то есть значения перед изменением положительно и отрицательно, как я ожидал бы, и цикл for определенно сглаживает эти значения. Но, как я уже упоминал ранее, я вижу (что мне кажется) сокращение объема, поэтому я могу увеличить коэффициент усиления и отменить то, что я только что сделал.

Кажется, что я должен работать над неправильными значениями. Любые предложения о том, что я делаю неправильно здесь?

4b9b3361

Ответ 1

Ответ Tom - это следующий рекурсивный фильтр:

y[n] = (1 - a)*y[n-1] + a*x[n]

H(z) = Y(z)/X(z) = a / (1 - (1 - a)*1/z)

Я построю это в Python/pylab для a = 0.25, a = 0.50 и a = 0.75:

from pylab import *

def H(a, z):
    return a / (1 - (1 - a) / z)

w = r_[0:1000]*pi/1000
z = exp(1j*w)
H1 = H(0.25, z)
H2 = H(0.50, z)
H3 = H(0.75, z)
plot(w, abs(H1), 'r') # red
plot(w, abs(H2), 'g') # green
plot(w, abs(H3), 'b') # blue

alt text

Pi radians/sample - частота Найквиста, которая составляет половину частоты дискретизации.

Если этот простой фильтр неадекватен, попробуйте фильтр Butterworth второго порядка:

# 2nd order filter:
# y[n] = -a[1]*y[n-1] - a[2]*y[n-2] + b[0]*x[n] + b[1]*x[n-1] + b[2]*x[n-2]

import scipy.signal as signal

# 2nd order Butterworth filter coefficients b,a
# 3dB cutoff = 2000 Hz
fc = 2000.0/44100
b, a = signal.butter(2, 2*fc)

# b = [ 0.01681915,  0.0336383 ,  0.01681915]
# a = [ 1.        , -1.60109239,  0.66836899]

# approximately:
# y[n] = 1.60109*y[n-1] - 0.66837*y[n-2] + 
#        0.01682*x[n] + 0.03364*x[n-1] + 0.01682*x[n-2]

# transfer function
def H(b,a,z):
    num = b[0] + b[1]/z + b[2]/(z**2)
    den = a[0] + a[1]/z + a[2]/(z**2)
    return num/den

H4 = H(b, a, z)
plot(w, abs(H4))
# show the corner frequency
plot(2*pi*fc, sqrt(2)/2, 'ro')  
xlabel('radians')

alt text

Оценить тестовый сигнал при частоте среза 3dB fc=2000:

fc = 2000.0/44100
b, a = signal.butter(2, 2*fc)

# test signal at corner frequency (signed 16-bit)
N = int(5/fc)  # sample for 5 cycles
x = int16(32767 * cos(2*pi*fc*r_[0:N]))

# signed 16-bit output
yout = zeros(size(x), dtype=int16)

# temp floats
y  = 0.0    
y1 = 0.0
y2 = 0.0

# filter the input
for n in r_[0:N]:
    y = (-a[1] * y1 + 
         -a[2] * y2 + 
          b[0] * x[n]   + 
          b[1] * x[n-1] + 
          b[2] * x[n-2])
    # convert to int16 and saturate
    if y > 32767.0:    yout[n] = 32767
    elif y < -32768.0: yout[n] = -32768
    else:              yout[n] = int16(y)
    # shift the variables
    y2 = y1
    y1 = y

# plots
plot(x,'r')       # input in red
plot(yout,'g')    # output in green
# show that this is the 3dB point
plot(sqrt(2)/2 * 32768 * ones(N),'b-')
xlabel('samples')

alt text

Ответ 2

Я не очень разбираюсь в цифровой обработке сигналов, но считаю, что вы можете приблизить фильтр нижних частот, используя линейную интерполяцию. См. конец эту статью в Википедии для информации.

Вот фрагмент кода, который может дать вам идею. alpha - коэффициент фильтра. Уменьшение значения альфа увеличит эффект приглушения, IIRC.


output_samples[0] = input_samples[0];

for(int sample = 1; sample < num_samples; sample ++) {
  output_samples[sample] = output_samples[sample - 1] + 
    alpha * (input_samples[sample] - output_samples[sample - 1]);
}

EDIT: Я думаю, что альфа обычно находится между 0 и 1 здесь.