Ticket #8568: vuvuzela-fixes.2.patch

File vuvuzela-fixes.2.patch, 24.0 KB (added by JYA, 10 years ago)

Updated version for 0.23-fixes

  • mythtv/libs/libmythtv/NuppelVideoPlayer.cpp

     
    51415141    return false;
    51425142}
    51435143
     5144bool NuppelVideoPlayer::ToggleVuvuzela()
     5145{
     5146    bool ret = false;
     5147    if (audioOutput)
     5148        ret = audioOutput->ToggleVuvuzela();
     5149    if (decoder)
     5150        decoder->SetDisablePassThrough(ret);
     5151    return ret;
     5152}
     5153
    51445154void NuppelVideoPlayer::Zoom(ZoomDirection direction)
    51455155{
    51465156    if (videoOutput)
  • mythtv/libs/libmythtv/tv_play.h

     
    436436                                 const QStringList &actions);
    437437
    438438    void ToggleUpmix(PlayerContext*);
     439    void ToggleVuvuzela(PlayerContext*);
    439440    void ChangeAudioSync(PlayerContext*, int dir, bool allowEdit = true);
    440441    bool AudioSyncHandleAction(PlayerContext*, const QStringList &actions);
    441442
  • mythtv/libs/libmythtv/NuppelVideoPlayer.h

     
    166166    void ToggleAdjustFill(AdjustFillMode adjustfillMode = kAdjustFill_Toggle);
    167167    bool ToggleUpmix(void);
    168168    bool CanPassthrough(void);
     169    bool ToggleVuvuzela(void);
    169170
    170171    // Gets
    171172    QSize   GetVideoBufferSize(void) const    { return video_dim; }
  • mythtv/libs/libmythtv/tv_play.cpp

     
    45164516        ToggleTimeStretch(ctx);
    45174517    else if (has_action("TOGGLEUPMIX", actions))
    45184518        ToggleUpmix(ctx);
     4519    else if (has_action("TOGGLEVUVUZELA", actions))
     4520        ToggleVuvuzela(ctx);
    45194521    else if (has_action("TOGGLESLEEP", actions))
    45204522        ToggleSleepTimer(ctx);
    45214523    else if (has_action("TOGGLERECORD", actions) && islivetv)
     
    82868288        ctx->nvp->GetOSD()->SetSettingsText(text, 5);
    82878289}
    82888290
     8291void TV::ToggleVuvuzela(PlayerContext *ctx)
     8292{
     8293    if (!ctx->nvp || !ctx->nvp->HasAudioOut())
     8294        return;
     8295    QString text;
     8296    if (ctx->nvp->ToggleVuvuzela())
     8297        text = tr("Vuvuzela Filter On");
     8298    else
     8299        text = tr("Vuvuzela Filter Off");
     8300
     8301    if (ctx->nvp->GetOSD() && !browsemode)
     8302        ctx->nvp->GetOSD()->SetSettingsText(text, 5);
     8303}
     8304
    82898305// dir in 10ms jumps
    82908306void TV::ChangeAudioSync(PlayerContext *ctx, int dir, bool allowEdit)
    82918307{
     
    99499965        ToggleTimeStretch(actx);
    99509966    else if (action == "TOGGLEUPMIX")
    99519967        ToggleUpmix(actx);
     9968    else if (action == "TOGGLEVUVUZELA")
     9969        ToggleVuvuzela(actx);
    99529970    else if (action.left(13) == "ADJUSTSTRETCH")
    99539971    {
    99549972        bool floatRead;
     
    1032310341        new OSDGenericTree(treeMenu, tr("Adjust Audio Sync"), "TOGGLEAUDIOSYNC");
    1032410342    else if (category == "TOGGLEUPMIX")
    1032510343        new OSDGenericTree(treeMenu, tr("Toggle Audio Upmixer"), "TOGGLEUPMIX");
     10344    else if (category == "TOGGLEVUVUZELA")
     10345        new OSDGenericTree(treeMenu, tr("Toggle Vuvuzela Filter"), "TOGGLEVUVUZELA");
    1032610346    else if (category == "TIMESTRETCH")
    1032710347        FillMenuTimeStretch(ctx, treeMenu);
    1032810348    else if (category == "VIDEOSCAN")
  • mythtv/libs/libmythtv/tvosdmenuentry.cpp

     
    236236        "AUDIOSYNC",          1,  1,  1,  1, "Audio Sync"));
    237237    curMenuEntries.append(new TVOSDMenuEntry(
    238238        "TOGGLEUPMIX",        1,  1,  1,  1, "Toggle Upmixer"));
     239    if (gContext->GetNumSetting("AdvancedAudioSettings", false) &&
     240        gContext->GetNumSetting("VuvuzelaFilter", false))
     241    {
     242        curMenuEntries.append(new TVOSDMenuEntry(
     243            "TOGGLEVUVUZELA", 1,  1,  1,  1, "Toggle Vuvuzela Filter"));
     244    }
    239245    curMenuEntries.append(new TVOSDMenuEntry(
    240246        "TIMESTRETCH",        1,  1,  1,  1, "Time Stretch"));
    241247    curMenuEntries.append(new TVOSDMenuEntry(
  • mythtv/libs/libmyth/audiooutputbase.h

     
    1616
    1717// MythTV headers
    1818#include "audiooutput.h"
     19#include "audiooutpututil.h"
    1920#include "samplerate.h"
    2021#include "mythverbose.h"
    2122
     
    4445    virtual void SetStretchFactor(float factor);
    4546    virtual float GetStretchFactor(void) const;
    4647    virtual bool ToggleUpmix(void);
     48    virtual bool ToggleVuvuzela(void);
    4749
    4850    virtual void Reset(void);
    4951
     
    5759    virtual void SetTimecode(long long timecode);
    5860    virtual bool IsPaused(void) const { return audio_actually_paused; }
    5961    virtual void Pause(bool paused);
    60     virtual bool CanPassthrough(void) const { return !need_resampler; }
     62    virtual bool CanPassthrough(void) const { return !(need_resampler || vuvuzela); }
    6163
    6264    // Wait for all data to finish playing
    6365    virtual void Drain(void);
     
    231233    /** main audio buffer */
    232234    unsigned char audiobuffer[kAudioRingBufferSize];
    233235    uint memory_corruption_test4;
     236
     237    //Vuvuzela filter
     238    bool vuvuzela, last_vuvuzela;
     239    AudioOutputUtil::Notch *notch_instance;
    234240};
    235241
    236242#endif
  • mythtv/libs/libmyth/audiooutpututil.h

     
     1#ifndef AUDIOOUTPUTUTIL
     2#define AUDIOOUTPUTUTIL
     3
     4using namespace std;
     5
     6#define IIR_NUM_COEFFICIENTS    (3)     // Assumed biquads
     7
     8class AudioOutputUtil
     9{
     10 public:
     11   
     12    //Notch Filter / IRR transformation
     13    // Parameters
     14    typedef struct
     15    {
     16        uint N;
     17        uint num_biquads;
     18        float b[IIR_NUM_COEFFICIENTS];
     19        float a[IIR_NUM_COEFFICIENTS];
     20    } IIR_Parameters;
     21   
     22    // State information
     23    typedef struct
     24    {
     25        float a[IIR_NUM_COEFFICIENTS];
     26        float b[IIR_NUM_COEFFICIENTS];
     27        float x_mem[IIR_NUM_COEFFICIENTS];
     28        float y_mem[IIR_NUM_COEFFICIENTS];
     29    } IIR_State;
     30
     31    // Instance
     32    typedef struct
     33    {
     34        IIR_Parameters parameters;
     35        IIR_State state;
     36    } IIR;
     37
     38    // Parameters
     39    typedef struct
     40    {
     41        uint N;
     42        float frequency;        // Notch frequency
     43    } Notch_Parameters;
     44
     45    // State information
     46
     47    typedef struct
     48    {
     49        float pole_position;
     50        float frequency_offset;
     51        float a1s;
     52        float a2;
     53        float depth_factor;
     54    } Notch_State;
     55
     56    // Instance
     57    typedef struct
     58    {
     59        Notch_Parameters parameters;
     60        Notch_State state;
     61        IIR iir;
     62    } Notch;
     63
     64    static void notch_update(Notch &instance, float fs);
     65    static void notch_execute(Notch &instance, float *in, float *out);
     66};
     67
     68#endif
     69#ifndef AUDIOOUTPUTUTIL
     70#define AUDIOOUTPUTUTIL
     71
     72using namespace std;
     73
     74#define IIR_NUM_COEFFICIENTS    (3)     // Assumed biquads
     75
     76class AudioOutputUtil
     77{
     78 public:
     79   
     80    //Notch Filter / IRR transformation
     81    // Parameters
     82    typedef struct
     83    {
     84        uint N;
     85        uint num_biquads;
     86        float b[IIR_NUM_COEFFICIENTS];
     87        float a[IIR_NUM_COEFFICIENTS];
     88    } IIR_Parameters;
     89   
     90    // State information
     91    typedef struct
     92    {
     93        float a[IIR_NUM_COEFFICIENTS];
     94        float b[IIR_NUM_COEFFICIENTS];
     95        float x_mem[IIR_NUM_COEFFICIENTS];
     96        float y_mem[IIR_NUM_COEFFICIENTS];
     97    } IIR_State;
     98
     99    // Instance
     100    typedef struct
     101    {
     102        IIR_Parameters parameters;
     103        IIR_State state;
     104    } IIR;
     105
     106    // Parameters
     107    typedef struct
     108    {
     109        uint N;
     110        float frequency;        // Notch frequency
     111    } Notch_Parameters;
     112
     113    // State information
     114
     115    typedef struct
     116    {
     117        float pole_position;
     118        float frequency_offset;
     119        float a1s;
     120        float a2;
     121        float depth_factor;
     122    } Notch_State;
     123
     124    // Instance
     125    typedef struct
     126    {
     127        Notch_Parameters parameters;
     128        Notch_State state;
     129        IIR iir;
     130    } Notch;
     131
     132    static void notch_update(Notch &instance, float fs);
     133    static void notch_execute(Notch &instance, float *in, float *out);
     134};
     135
     136#endif
     137#ifndef AUDIOOUTPUTUTIL
     138#define AUDIOOUTPUTUTIL
     139
     140using namespace std;
     141
     142#define IIR_NUM_COEFFICIENTS    (3)     // Assumed biquads
     143
     144class AudioOutputUtil
     145{
     146 public:
     147   
     148    //Notch Filter / IRR transformation
     149    // Parameters
     150    typedef struct
     151    {
     152        uint N;
     153        uint num_biquads;
     154        float b[IIR_NUM_COEFFICIENTS];
     155        float a[IIR_NUM_COEFFICIENTS];
     156    } IIR_Parameters;
     157   
     158    // State information
     159    typedef struct
     160    {
     161        float a[IIR_NUM_COEFFICIENTS];
     162        float b[IIR_NUM_COEFFICIENTS];
     163        float x_mem[IIR_NUM_COEFFICIENTS];
     164        float y_mem[IIR_NUM_COEFFICIENTS];
     165    } IIR_State;
     166
     167    // Instance
     168    typedef struct
     169    {
     170        IIR_Parameters parameters;
     171        IIR_State state;
     172    } IIR;
     173
     174    // Parameters
     175    typedef struct
     176    {
     177        uint N;
     178        float frequency;        // Notch frequency
     179    } Notch_Parameters;
     180
     181    // State information
     182
     183    typedef struct
     184    {
     185        float pole_position;
     186        float frequency_offset;
     187        float a1s;
     188        float a2;
     189        float depth_factor;
     190    } Notch_State;
     191
     192    // Instance
     193    typedef struct
     194    {
     195        Notch_Parameters parameters;
     196        Notch_State state;
     197        IIR iir;
     198    } Notch;
     199
     200    static void notch_update(Notch &instance, float fs);
     201    static void notch_execute(Notch &instance, float *in, float *out);
     202};
     203
     204#endif
     205#ifndef AUDIOOUTPUTUTIL
     206#define AUDIOOUTPUTUTIL
     207
     208using namespace std;
     209
     210#define IIR_NUM_COEFFICIENTS    (3)     // Assumed biquads
     211
     212class AudioOutputUtil
     213{
     214 public:
     215 
     216    //Notch Filter / IRR transformation
     217    // Parameters
     218    typedef struct
     219    {
     220        uint N;
     221        uint num_biquads;
     222        float b[IIR_NUM_COEFFICIENTS];
     223        float a[IIR_NUM_COEFFICIENTS];
     224    } IIR_Parameters;
     225   
     226    // State information
     227    typedef struct
     228    {
     229        float a[IIR_NUM_COEFFICIENTS];
     230        float b[IIR_NUM_COEFFICIENTS];
     231        float x_mem[IIR_NUM_COEFFICIENTS];
     232        float y_mem[IIR_NUM_COEFFICIENTS];
     233    } IIR_State;
     234
     235    // Instance
     236    typedef struct
     237    {
     238        IIR_Parameters parameters;
     239        IIR_State state;
     240    } IIR;
     241
     242    // Parameters
     243    typedef struct
     244    {
     245        uint N;
     246        float frequency;        // Notch frequency
     247    } Notch_Parameters;
     248
     249    // State information
     250
     251    typedef struct
     252    {
     253        float pole_position;
     254        float frequency_offset;
     255        float a1s;
     256        float a2;
     257        float depth_factor;
     258    } Notch_State;
     259
     260    // Instance
     261    typedef struct
     262    {
     263        Notch_Parameters parameters;
     264        Notch_State state;
     265        IIR iir;
     266    } Notch;
     267
     268    static void notch_update(Notch &instance, float fs);
     269    static void notch_execute(Notch &instance, float *in, float *out);
     270};
     271
     272#endif
  • mythtv/libs/libmyth/audiooutputbase.cpp

    Property changes on: mythtv/libs/libmyth/audiooutpututil.h
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
    1313#include "compat.h"
    1414#include "audiooutputbase.h"
    1515#include "audiooutputdigitalencoder.h"
     16#include "audiooutpututil.h"
    1617#include "SoundTouch.h"
    1718#include "freesurround.h"
    1819
     
    7374    memory_corruption_test1(0xdeadbeef),
    7475    memory_corruption_test2(0xdeadbeef),
    7576    memory_corruption_test3(0xdeadbeef),
    76     memory_corruption_test4(0xdeadbeef)
     77    memory_corruption_test4(0xdeadbeef),
     78    vuvuzela(false),            last_vuvuzela(false),
     79    notch_instance(NULL)
    7780{
    7881    // The following are not bzero() because MS Windows doesn't like it.
    7982    memset(&src_data,          0, sizeof(SRC_DATA));
     
    197200    return (configured_audio_channels == 6);
    198201}
    199202
     203bool AudioOutputBase::ToggleVuvuzela(void)
     204{
     205    vuvuzela = !vuvuzela;
     206    const AudioSettings settings(audio_bits, source_audio_channels,
     207                                 audio_codec, source_audio_samplerate,
     208                                 audio_passthru);
     209    Reconfigure(settings);
    200210
     211    return vuvuzela;
     212}
     213
    201214void AudioOutputBase::Reconfigure(const AudioSettings &orig_settings)
    202215{
    203216    AudioSettings settings = orig_settings;
     
    229242        settings.samplerate == audio_samplerate && !need_resampler &&
    230243        settings.use_passthru == audio_passthru &&
    231244        lneeds_upmix == needs_upmix &&
     245        last_vuvuzela == vuvuzela &&
    232246        laudio_reenc == audio_reenc);
    233247    bool upmix_deps =
    234248        (lsource_audio_channels == source_audio_channels);
     
    247261        return;
    248262    }
    249263
     264    last_vuvuzela          = vuvuzela;
     265
    250266    KillAudio();
    251267
    252268    QMutexLocker lock1(&audio_buflock);
     
    264280    audio_codec = settings.codec;
    265281    audio_passthru = settings.use_passthru;
    266282    needs_upmix = lneeds_upmix;
     283    vuvuzela = last_vuvuzela;
    267284
    268285    if (audio_bits != 8 && audio_bits != 16)
    269286    {
     
    341358        need_resampler = true;
    342359    }
    343360
     361    if (vuvuzela)
     362    {
     363        VERBOSE(VB_AUDIO, LOC + "Vuvuzela filter enabled. Go Socceroos Go!");
     364        if (!notch_instance)
     365            notch_instance = new AudioOutputUtil::Notch;
     366    }
     367
    344368    if (audio_enc)
    345369    {
    346370        VERBOSE(VB_AUDIO, LOC + "Creating AC-3 Encoder");
     
    497521    needs_upmix = false;
    498522    audio_enc = false;
    499523
     524    if (notch_instance)
     525    {
     526        delete notch_instance;
     527        notch_instance = NULL;
     528    }
     529    vuvuzela = false;
     530
    500531    CloseDevice();
    501532
    502533    killAudioLock.unlock();
     
    844875    QMutexLocker lock1(&audio_buflock);
    845876
    846877    // resample input if necessary
    847     if (need_resampler && src_ctx)
     878    if ((need_resampler && src_ctx) || (vuvuzela && notch_instance))
    848879    {
    849880        // Convert to floats
    850881        short *buf_ptr = (short*)buffer;
     
    854885            src_in[sample] = (float)buf_ptr[sample] / (1.0 * 0x8000);
    855886        }
    856887 
    857         src_data.input_frames = samples;
    858         src_data.end_of_input = 0;
    859         int error = src_process(src_ctx, &src_data);
    860         if (error)
    861             VERBOSE(VB_IMPORTANT, LOC_ERR +
    862                     QString("Error occurred while resampling audio: %1")
    863                     .arg(src_strerror(error)));
    864         src_float_to_short_array(src_data.data_out, (short int*)tmp_buff,
    865                             (src_data.output_frames_gen*abps)/sizeof(short));
     888        if (vuvuzela && notch_instance)
     889        {
     890            notch_instance->parameters.N = numSamples;
    866891
    867         _AddSamples(tmp_buff, true, src_data.output_frames_gen, timecode);
     892            // Notch frequency
     893            notch_instance->parameters.frequency = 235.0f;
     894            AudioOutputUtil::notch_update (*notch_instance, (float)source_audio_samplerate);
     895            AudioOutputUtil::notch_execute (*notch_instance, src_in, src_out);
     896            notch_instance->parameters.frequency = 465.0f;  // 1st harmonic
     897            AudioOutputUtil::notch_update (*notch_instance, (float)source_audio_samplerate);
     898            AudioOutputUtil::notch_execute (*notch_instance, src_out, src_in);
     899        }
     900        if (need_resampler)
     901        {
     902            src_data.input_frames = samples;
     903            src_data.end_of_input = 0;
     904            int error = src_process(src_ctx, &src_data);
     905            if (error)
     906                VERBOSE(VB_IMPORTANT, LOC_ERR +
     907                        QString("Error occurred while resampling audio: %1")
     908                        .arg(src_strerror(error)));
     909            src_float_to_short_array(src_data.data_out, (short int*)tmp_buff,
     910                                (src_data.output_frames_gen*abps)/sizeof(short));
     911
     912            _AddSamples(tmp_buff, true, src_data.output_frames_gen, timecode);
     913        }
     914        else
     915        {
     916            src_float_to_short_array(src_in, (short int*)tmp_buff, numSamples);
     917            _AddSamples(tmp_buff, true, samples, timecode);
     918        }
    868919    }
    869920    else
    870921    {
  • mythtv/libs/libmyth/libmyth.pro

     
    3030HEADERS += audiopulseutil.h
    3131HEADERS += programinfo.h programlist.h programinfoupdater.h
    3232HEADERS += recordingtypes.h remoteutil.h
    33 HEADERS += rawsettingseditor.h
     33HEADERS += rawsettingseditor.h audiooutpututil.h
    3434
    3535# remove when everything is switched to mythui
    3636HEADERS += virtualkeyboard_qt.h
     
    5454SOURCES += audiopulseutil.cpp
    5555SOURCES += programinfo.cpp programlist.cpp programinfoupdater.cpp
    5656SOURCES += recordingtypes.cpp remoteutil.cpp
    57 SOURCES += rawsettingseditor.cpp
     57SOURCES += rawsettingseditor.cpp audiooutpututil.cpp
    5858
    5959# remove when everything is switched to mythui
    6060SOURCES += virtualkeyboard_qt.cpp
  • mythtv/libs/libmyth/audiooutput.h

     
    7272    virtual void bufferOutputData(bool y) = 0;
    7373    virtual int readOutputData(unsigned char *read_buffer, int max_length) = 0;
    7474    virtual bool ToggleUpmix(void) = 0;
     75    virtual bool ToggleVuvuzela(void) = 0;
    7576
    7677  protected:
    7778    void Error(const QString &msg);
  • mythtv/libs/libmyth/audiooutpututil.cpp

     
     1#include "dsputil.h"
     2#include "mythconfig.h"
     3#include "audiooutpututil.h"
     4
     5#define IIR_NUM_COEFFICIENTS    (3)     // Assumed biquads
     6
     7static void iir_update (AudioOutputUtil::IIR &instance)
     8{
     9        // Clear the filter state
     10    bzero(&instance.state.x_mem[0], IIR_NUM_COEFFICIENTS * sizeof(float));
     11    bzero(&instance.state.y_mem[0], IIR_NUM_COEFFICIENTS * sizeof(float));
     12   
     13    memcpy(&instance.state.b[0], &instance.parameters.b[0],
     14           IIR_NUM_COEFFICIENTS * sizeof(float));
     15    memcpy(&instance.state.a[0], &instance.parameters.a[0],
     16           IIR_NUM_COEFFICIENTS * sizeof(float));
     17}
     18
     19/* Notch filter (c) 2010 Hydrix & Jean-Yves Avenard */
     20/* www.hydrix.com */
     21
     22// Processes a single block of samples with a single IIR biquad stage
     23//    N                   M
     24//   SUM a(k+1) y(n-k) = SUM b(k+1) x(n-k)      for 1<=n<=length(x)
     25//   k=0                 k=0
     26// where N=length(a)-1 and M=length(b)-1.
     27// Vector s is the initial state of the system. The final state is also returned
     28// The state vector is a column vector whose length is equal to the
     29//      length of the longest coefficient vector minus one.
     30static void iir_biquad (float* x, float* y,
     31                        float* a, float* b,
     32                        float* x_mem, float* y_mem,
     33                        unsigned int N)
     34{
     35   // Direct Form I
     36   //               N+1               N+1
     37   //           y(n) = - SUM a(k) y(n-k) + SUM b(k) x(n-k)  for 0 <= n <length(x)
     38   //               k=1               k=0
     39    unsigned int n = 0;
     40    unsigned int k = 0;
     41    float y_n_minus_k = 0.0f;
     42    float x_n_minus_k = 0.0f;
     43    for (n = 0; n < N; n++)
     44    {
     45        y[n] = x[n] * b[0];
     46
     47        for (k = 1; k < IIR_NUM_COEFFICIENTS; k++)
     48        {
     49            signed int n_minus_k = n - k;
     50            if (n_minus_k >= 0)
     51            {
     52                x_n_minus_k = x[n_minus_k];
     53                y_n_minus_k = y[n_minus_k];
     54            }
     55            else
     56            {
     57                x_n_minus_k = x_mem[-n_minus_k-1];
     58                y_n_minus_k = y_mem[-n_minus_k-1];
     59            }
     60
     61            y[n] -= a[k] * y_n_minus_k;
     62            y[n] += b[k] * x_n_minus_k;
     63        }
     64    }
     65
     66        // Save input and output state, latest first
     67    unsigned int state_offset = N - 1;
     68    for (n=0; n < (IIR_NUM_COEFFICIENTS-1); n++)
     69    {
     70        x_mem[n] = x[state_offset];
     71        y_mem[n] = y[state_offset];
     72        state_offset--;
     73    }
     74}
     75
     76static void iir_execute(AudioOutputUtil::IIR &instance, float* x, float* y)
     77{
     78    iir_biquad(x, y,
     79               &instance.state.a[0], &instance.state.b[0],
     80               &instance.state.x_mem[0], &instance.state.y_mem[0],
     81               instance.parameters.N);
     82}
     83
     84// Notch filter
     85#define PI_FLOAT                    (3.14159265358979f)
     86
     87void AudioOutputUtil::notch_update (Notch &instance, float fs)
     88{
     89    instance.state.pole_position = 0.99f;
     90    instance.state.frequency_offset = 0.0f; // in normalised frequency (1.0 = fs)
     91    instance.state.a1s = -instance.state.pole_position;
     92    instance.state.a2 = -(instance.state.pole_position * instance.state.pole_position);
     93    instance.state.depth_factor = 1.0f;
     94
     95        // Calculate filter coefficients
     96        // Direct-form IIR
     97        // Ref: http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt and others
     98    float normalised_notch_frequency = (2.0f * instance.parameters.frequency / fs);
     99    normalised_notch_frequency += instance.state.frequency_offset;
     100    float frequency_factor = -2.0f * cosf(PI_FLOAT * normalised_notch_frequency);
     101    float a1 = frequency_factor * instance.state.a1s;
     102    float a2 = instance.state.a2;
     103    float b1 = frequency_factor * instance.state.depth_factor;
     104    float b2 = instance.state.depth_factor * instance.state.depth_factor;
     105    instance.iir.parameters.N = instance.parameters.N;
     106    instance.iir.parameters.a[0] = 1.0f;
     107    instance.iir.parameters.a[1] = -a1;
     108    instance.iir.parameters.a[2] = -a2;
     109    instance.iir.parameters.b[0] = 1.0f;
     110    instance.iir.parameters.b[1] = b1;
     111    instance.iir.parameters.b[2] = b2;
     112
     113        // Initialise the IIR stage
     114    iir_update(instance.iir);
     115}
     116
     117// Processes a single block of samples
     118void AudioOutputUtil::notch_execute (Notch &instance, float *in, float *out)
     119{
     120    // Apply the rejection filter
     121    iir_execute(instance.iir, in, out);
     122}
  • mythtv/programs/mythfrontend/globalsettings.cpp

    Property changes on: mythtv/libs/libmyth/audiooutpututil.cpp
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
    181181    return gc;
    182182}
    183183
     184static HostCheckBox *VuvuzelaFilter()
     185{
     186    HostCheckBox *gc = new HostCheckBox("VuvuzelaFilter");
     187    gc->setLabel(QObject::tr("Enable vuvuzela filter"));
     188    gc->setValue(false);
     189    gc->setHelpText(QObject::tr("With this option enabled, a dedicated vuvuzela "
     190                                "filter option will be accessible in the playback "
     191                                "menu"));
     192    return gc;
     193}
     194
    184195static HostCheckBox *MythControlsVolume()
    185196{
    186197    HostCheckBox *gc = new HostCheckBox("MythControlsVolume");
     
    34853496    settings2->addChild(srcqualityoverride);
    34863497    settings2->addChild(sub3);
    34873498   
     3499    group2->addChild(VuvuzelaFilter());
    34883500    group2->addChild(settings2);
    34893501    group2->addChild(AggressiveBuffer());
    34903502
  • mythtv/programs/mythtranscode/transcode.cpp

     
    222222        // Do nothing
    223223        return false;
    224224    }
     225    virtual bool ToggleVuvuzela(void)
     226    {
     227        // Do nothing
     228        return false;
     229    }
    225230
    226231    virtual void SetSWVolume(int new_volume, bool save)
    227232    {