u/Alfoser

Hello, I'm developing an audio codec, and currently stuck on one thing: which metric should I use for quality measurement?
For now I've been using gstPEAQ Basic model (because Advanced really sucks speed and correlation wise). I was thinking about ViSQOL, but their results also kinda suck, especially for lower bitrates like 64 kbps, where difference between 64 kbps OGG and my codec are really noticeable, and yet differentiate only around 0.1 MOS-LQO (gstPEAQ Basic makes difference big, around 2 ODG).
Any suggestions?

Hello, I'm developing an audio codec, and currently stuck on one thing: which metric should I use for quality measurement?
For now I've been using gstPEAQ Basic model (because Advanced really sucks speed and correlation wise). I was thinking about ViSQOL, but their results also kinda suck, especially for lower bitrates like 64 kbps, where difference between 64 kbps OGG and my codec are really noticeable, and yet differentiate only around 0.1 MOS-LQO (gstPEAQ Basic makes difference big, around 2 ODG).
Any suggestions?

Hi, I'm currently developing audio codec on WPT and stuck on one thing:
One wavelet is good for non-compressed audio, and other is good for compressed audio. And I can't use only one, if i use one that good for compressed audio, non-compressed would be worse and other way around.
So I ran some test and it found out, that it is because of frequency cutoff in compressed audio.
And so tried to find solution for detecting frequency cutoff, and anything other than FFT/STFT could not find. But I can't implement FFT/STFT, because it will kill speed in audio codec by a lot.
Any other way to detect frequency cutoff that is fast enough and doesn't require FFT/STFT?
I would be really grateful if anyone can help.

Hi, I'm currently developing an audio codec, and now stuck at 64 kbps trying to implement SBR-like system.
I haven't come up with anything else than just energy preservation of band after copying.
I read that we can mix the copied band with some amount of noise, but couldn't come up with good criteria for it.
I'm using WPT, so maybe some time-domain adaptation?
Anyway, I would be really grateful if anyone can help.

Hi, I'm currently developing my own audio compression algorithm, and now optimizing it. Long story short, I've run some tests, and rice decoding is kinda slow.
Can anyone suggest optimized version of it? I'd really appreciated it.

Hi, I'm currently developing audio codec based on WPT, and stuck on one thing: frequency response in my lifting scheme can't normally cutoff HF part.
Can anyone help me fix this? I'm thinking it's because update function has only 6 taps.
Thanks for any advice!

Code of My Lifting Wavelet

class DD64in {
protected:
    mutable std::vector<float> scratch_ext;
    mutable std::vector<float> tmp;


    void decompose_block(float* __restrict data, size_t N) const {
        if (N < 2) return;


        const size_t even_len = (N + 1) >> 1;
        const size_t odd_len  = N >> 1;


        if (tmp.size() < N)
            tmp.resize(N);


        float* __restrict even = tmp.data();
        float* __restrict odd  = tmp.data() + even_len;


        for (size_t i = 0; i < even_len; ++i)
            even[i] = data[i << 1];


        for (size_t i = 0; i < odd_len; ++i)
            odd[i] = data[(i << 1) + 1];


        if (scratch_ext.size() < even_len + 16)
            scratch_ext.resize(even_len + 16);


        float* __restrict pe = scratch_ext.data() + 8;


        std::memcpy(pe, even, even_len * sizeof(float));


        pe[-1] = even[0];
        pe[-2] = even[1];
        pe[-3] = even[2];
        pe[-4] = even[3];
        pe[-5] = even[4];
        pe[-6] = even[5];
        pe[-7] = even[6];
        pe[-8] = even[7];


        pe[even_len]     = even[even_len - 1];
        pe[even_len + 1] = even[even_len - 2];
        pe[even_len + 2] = even[even_len - 3];
        pe[even_len + 3] = even[even_len - 4];
        pe[even_len + 4] = even[even_len - 5];
        pe[even_len + 5] = even[even_len - 6];
        pe[even_len + 6] = even[even_len - 7];
        pe[even_len + 7] = even[even_len - 8];


        constexpr float C0 = -0.0000063926f;  
        constexpr float C1 =  0.0001106411f;   
        constexpr float C2 = -0.0009153038f;   
        constexpr float C3 =  0.0048477203f;   
        constexpr float C4 = -0.0186983496f;   
        constexpr float C5 =  0.0575909168f;   
        constexpr float C6 = -0.1599747688f;   
        constexpr float C7 =  0.6170455217f;   


        for (size_t i = 0; i < odd_len; ++i) {
            float* __restrict p = pe + i;


            float pred =
                C0 * (p[-7] + p[8]) +
                C1 * (p[-6] + p[7]) +
                C2 * (p[-5] + p[6]) +
                C3 * (p[-4] + p[5]) +
                C4 * (p[-3] + p[4]) +
                C5 * (p[-2] + p[3]) +
                C6 * (p[-1] + p[2]) +
                C7 * (p[0]  + p[1]);


            odd[i] -= pred;
        }


        float* __restrict pd = scratch_ext.data() + 3;


        std::memcpy(pd, odd, odd_len * sizeof(float));


        pd[-1] = odd[0];
        pd[-2] = odd[1];
        pd[-3] = odd[2];


        pd[odd_len]     = odd[odd_len - 1];
        pd[odd_len + 1] = odd[odd_len - 2];
        pd[odd_len + 2] = odd[odd_len - 3];


        constexpr float INV64 = 1.0f / 64.0f;


        for (size_t i = 0; i < even_len; ++i) {
            float* __restrict p = pd + i;


            float upd =
                ((p[-3] + p[2])
                 - 6.0f  * (p[-2] + p[1])
                 + 21.0f * (p[-1] + p[0])) * INV64;


            even[i] += upd;
        }


        std::memcpy(data, even, even_len * sizeof(float));
        std::memcpy(data + even_len, odd, odd_len * sizeof(float));
    }


public:
    std::vector<float>& wpt_decompose(std::vector<float>& signal, int level) {
        const size_t N = signal.size();
        float* __restrict data = signal.data();


        for (int L = 0; L < level; ++L) {
            size_t step = N >> L;
            for (size_t offset = 0; offset < N; offset += step)
                decompose_block(data + offset, step);
        }
        return signal;
    }
};class DD64in {
protected:
    mutable std::vector<float> scratch_ext;
    mutable std::vector<float> tmp;


    void decompose_block(float* __restrict data, size_t N) const {
        if (N < 2) return;


        const size_t even_len = (N + 1) >> 1;
        const size_t odd_len  = N >> 1;


        if (tmp.size() < N)
            tmp.resize(N);


        float* __restrict even = tmp.data();
        float* __restrict odd  = tmp.data() + even_len;


        for (size_t i = 0; i < even_len; ++i)
            even[i] = data[i << 1];


        for (size_t i = 0; i < odd_len; ++i)
            odd[i] = data[(i << 1) + 1];


        if (scratch_ext.size() < even_len + 16)
            scratch_ext.resize(even_len + 16);


        float* __restrict pe = scratch_ext.data() + 8;


        std::memcpy(pe, even, even_len * sizeof(float));


        pe[-1] = even[0];
        pe[-2] = even[1];
        pe[-3] = even[2];
        pe[-4] = even[3];
        pe[-5] = even[4];
        pe[-6] = even[5];
        pe[-7] = even[6];
        pe[-8] = even[7];


        pe[even_len]     = even[even_len - 1];
        pe[even_len + 1] = even[even_len - 2];
        pe[even_len + 2] = even[even_len - 3];
        pe[even_len + 3] = even[even_len - 4];
        pe[even_len + 4] = even[even_len - 5];
        pe[even_len + 5] = even[even_len - 6];
        pe[even_len + 6] = even[even_len - 7];
        pe[even_len + 7] = even[even_len - 8];


        constexpr float C0 = -0.0000063926f;  
        constexpr float C1 =  0.0001106411f;   
        constexpr float C2 = -0.0009153038f;   
        constexpr float C3 =  0.0048477203f;   
        constexpr float C4 = -0.0186983496f;   
        constexpr float C5 =  0.0575909168f;   
        constexpr float C6 = -0.1599747688f;   
        constexpr float C7 =  0.6170455217f;   


        for (size_t i = 0; i < odd_len; ++i) {
            float* __restrict p = pe + i;


            float pred =
                C0 * (p[-7] + p[8]) +
                C1 * (p[-6] + p[7]) +
                C2 * (p[-5] + p[6]) +
                C3 * (p[-4] + p[5]) +
                C4 * (p[-3] + p[4]) +
                C5 * (p[-2] + p[3]) +
                C6 * (p[-1] + p[2]) +
                C7 * (p[0]  + p[1]);


            odd[i] -= pred;
        }


        float* __restrict pd = scratch_ext.data() + 3;


        std::memcpy(pd, odd, odd_len * sizeof(float));


        pd[-1] = odd[0];
        pd[-2] = odd[1];
        pd[-3] = odd[2];


        pd[odd_len]     = odd[odd_len - 1];
        pd[odd_len + 1] = odd[odd_len - 2];
        pd[odd_len + 2] = odd[odd_len - 3];


        constexpr float INV64 = 1.0f / 64.0f;


        for (size_t i = 0; i < even_len; ++i) {
            float* __restrict p = pd + i;


            float upd =
                ((p[-3] + p[2])
                 - 6.0f  * (p[-2] + p[1])
                 + 21.0f * (p[-1] + p[0])) * INV64;


            even[i] += upd;
        }


        std::memcpy(data, even, even_len * sizeof(float));
        std::memcpy(data + even_len, odd, odd_len * sizeof(float));
    }


public:
    std::vector<float>& wpt_decompose(std::vector<float>& signal, int level) {
        const size_t N = signal.size();
        float* __restrict data = signal.data();


        for (int L = 0; L < level; ++L) {
            size_t step = N >> L;
            for (size_t offset = 0; offset < N; offset += step)
                decompose_block(data + offset, step);
        }
        return signal;
    }
};

Hi, I'm currently developing my own audio codec, and I want to implement it in ffmpeg. My codec is written on C++, it has function for compression and decompossion. Is there any guidelines for this?
I'd appreciate any help.

I'm currently developing audio codec using Wavelets, and stuck on one thing — measuring quality. I know about PEAQ, but it is shitty when trying to measure wide stereo scene with many transients, and also post/pre-echo, and also brick-wall/glass effect, not that I have last one, and many other artifacts. You get the picture.

Is there any better tech to measure quality of encoding?

Sorry for bad English