@scrypted/libav 1.0.169 → 1.0.171

package/opus/dnn/nndsp.c

@@ -1,416 +0,0 @@
-/* Copyright (c) 2023 Amazon
-   Written by Jan Buethe */
-/*
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions
-   are met:
-
-   - Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-
-   - Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
-   OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-
-#include "nndsp.h"
-#include "arch.h"
-#include "nnet.h"
-#include "os_support.h"
-#include "pitch.h"
-
-#include <math.h>
-
-#ifndef M_PI
-#define M_PI 3.141592653589793f
-#endif
-
-#define KERNEL_INDEX(i_out_channels, i_in_channels, i_kernel) ((((i_out_channels) * in_channels) + (i_in_channels)) * kernel_size + (i_kernel))
-
-void init_adaconv_state(AdaConvState *hAdaConv)
-{
-    OPUS_CLEAR(hAdaConv, 1);
-}
-
-void init_adacomb_state(AdaCombState *hAdaComb)
-{
-    OPUS_CLEAR(hAdaComb, 1);
-}
-
-void init_adashape_state(AdaShapeState *hAdaShape)
-{
-    OPUS_CLEAR(hAdaShape, 1);
-}
-
-void compute_overlap_window(float *window, int overlap_size)
-{
-    int i_sample;
-    for (i_sample=0; i_sample < overlap_size; i_sample++)
-    {
-        window[i_sample] = 0.5f + 0.5f * cos(M_PI * (i_sample + 0.5f) / overlap_size);
-    }
-}
-
-#ifdef DEBUG_NNDSP
-void print_float_vector(const char* name, const float *vec, int length)
-{
-    for (int i = 0; i < length; i ++)
-    {
-        printf("%s[%d]: %f\n", name, i, vec[i]);
-    }
-}
-#endif
-
-static void scale_kernel(
-    float *kernel,
-    int in_channels,
-    int out_channels,
-    int kernel_size,
-    float *gain
-)
-/* normalizes (p-norm) kernel over input channel and kernel dimension */
-{
-    float norm;
-    int i_in_channels, i_out_channels, i_kernel;
-
-    for (i_out_channels = 0; i_out_channels < out_channels; i_out_channels++)
-    {
-        norm = 0;
-        for (i_in_channels = 0; i_in_channels < in_channels; i_in_channels ++)
-        {
-            for (i_kernel = 0; i_kernel < kernel_size; i_kernel++)
-            {
-                norm += kernel[KERNEL_INDEX(i_out_channels, i_in_channels, i_kernel)] * kernel[KERNEL_INDEX(i_out_channels, i_in_channels, i_kernel)];
-            }
-        }
-#ifdef DEBUG_NNDSP
-        printf("kernel norm: %f, %f\n", norm, sqrt(norm));
-#endif
-        norm = 1.f / (1e-6f + sqrt(norm));
-        for (i_in_channels = 0; i_in_channels < in_channels; i_in_channels++)
-        {
-            for (i_kernel = 0; i_kernel < kernel_size; i_kernel++)
-            {
-
-                kernel[KERNEL_INDEX(i_out_channels, i_in_channels, i_kernel)] *= norm * gain[i_out_channels];
-            }
-        }
-    }
-}
-
-static void transform_gains(
-    float *gains,
-    int num_gains,
-    float filter_gain_a,
-    float filter_gain_b
-)
-{
-    int i;
-    for (i = 0; i < num_gains; i++)
-    {
-        gains[i] = exp(filter_gain_a * gains[i] + filter_gain_b);
-    }
-}
-
-void adaconv_process_frame(
-    AdaConvState* hAdaConv,
-    float *x_out,
-    const float *x_in,
-    const float *features,
-    const LinearLayer *kernel_layer,
-    const LinearLayer *gain_layer,
-    int feature_dim,
-    int frame_size,
-    int overlap_size,
-    int in_channels,
-    int out_channels,
-    int kernel_size,
-    int left_padding,
-    float filter_gain_a,
-    float filter_gain_b,
-    float shape_gain,
-    float *window,
-    int arch
-)
-{
-    float output_buffer[ADACONV_MAX_FRAME_SIZE * ADACONV_MAX_OUTPUT_CHANNELS];
-    float kernel_buffer[ADACONV_MAX_KERNEL_SIZE * ADACONV_MAX_INPUT_CHANNELS * ADACONV_MAX_OUTPUT_CHANNELS];
-    float input_buffer[ADACONV_MAX_INPUT_CHANNELS * (ADACONV_MAX_FRAME_SIZE + ADACONV_MAX_KERNEL_SIZE)];
-    float kernel0[ADACONV_MAX_KERNEL_SIZE];
-    float kernel1[ADACONV_MAX_KERNEL_SIZE];
-    float channel_buffer0[ADACONV_MAX_OVERLAP_SIZE];
-    float channel_buffer1[ADACONV_MAX_FRAME_SIZE];
-    float gain_buffer[ADACONV_MAX_OUTPUT_CHANNELS];
-    float *p_input;
-    int i_in_channels, i_out_channels, i_sample;
-
-    (void) feature_dim; /* ToDo: figure out whether we might need this information */
-
-    celt_assert(shape_gain == 1);
-    celt_assert(left_padding == kernel_size - 1); /* currently only supports causal version. Non-causal version not difficult to implement but will require third loop */
-    celt_assert(kernel_size < frame_size);
-
-    OPUS_CLEAR(output_buffer, ADACONV_MAX_FRAME_SIZE * ADACONV_MAX_OUTPUT_CHANNELS);
-    OPUS_CLEAR(kernel_buffer, ADACONV_MAX_KERNEL_SIZE * ADACONV_MAX_INPUT_CHANNELS * ADACONV_MAX_OUTPUT_CHANNELS);
-    OPUS_CLEAR(input_buffer, ADACONV_MAX_INPUT_CHANNELS * (ADACONV_MAX_FRAME_SIZE + ADACONV_MAX_KERNEL_SIZE));
-
-#ifdef DEBUG_NNDSP
-    print_float_vector("x_in", x_in, in_channels * frame_size);
-#endif
-
-    /* prepare input */
-    for (i_in_channels=0; i_in_channels < in_channels; i_in_channels ++)
-    {
-        OPUS_COPY(input_buffer + i_in_channels * (kernel_size + frame_size), hAdaConv->history + i_in_channels * kernel_size, kernel_size);
-        OPUS_COPY(input_buffer + kernel_size + i_in_channels * (kernel_size + frame_size), x_in + frame_size * i_in_channels, frame_size);
-    }
-    p_input = input_buffer + kernel_size;
-
-
-    /* calculate new kernel and new gain */
-    compute_generic_dense(kernel_layer, kernel_buffer, features, ACTIVATION_LINEAR, arch);
-    compute_generic_dense(gain_layer, gain_buffer, features, ACTIVATION_TANH, arch);
-#ifdef DEBUG_NNDSP
-    print_float_vector("features", features, feature_dim);
-    print_float_vector("adaconv_kernel_raw", kernel_buffer, in_channels * out_channels * kernel_size);
-    print_float_vector("adaconv_gain_raw", gain_buffer, out_channels);
-#endif
-    transform_gains(gain_buffer, out_channels, filter_gain_a, filter_gain_b);
-    scale_kernel(kernel_buffer, in_channels, out_channels, kernel_size, gain_buffer);
-
-#ifdef DEBUG_NNDSP
-    print_float_vector("adaconv_kernel", kernel_buffer, in_channels * out_channels * kernel_size);
-    print_float_vector("adaconv_gain", gain_buffer, out_channels);
-#endif
-
-    /* calculate overlapping part using kernel from last frame */
-
-    for (i_out_channels = 0; i_out_channels < out_channels; i_out_channels++)
-    {
-        for (i_in_channels = 0; i_in_channels < in_channels; i_in_channels++)
-        {
-            OPUS_CLEAR(kernel0, ADACONV_MAX_KERNEL_SIZE);
-            OPUS_CLEAR(kernel1, ADACONV_MAX_KERNEL_SIZE);
-
-            OPUS_COPY(kernel0, hAdaConv->last_kernel + KERNEL_INDEX(i_out_channels, i_in_channels, 0), kernel_size);
-            OPUS_COPY(kernel1, kernel_buffer + KERNEL_INDEX(i_out_channels, i_in_channels, 0), kernel_size);
-            celt_pitch_xcorr(kernel0, p_input + i_in_channels * (frame_size + kernel_size) - left_padding, channel_buffer0, ADACONV_MAX_KERNEL_SIZE, overlap_size, arch);
-            celt_pitch_xcorr(kernel1, p_input + i_in_channels * (frame_size + kernel_size) - left_padding, channel_buffer1, ADACONV_MAX_KERNEL_SIZE, frame_size, arch);
-            for (i_sample = 0; i_sample < overlap_size; i_sample++)
-            {
-                output_buffer[i_sample + i_out_channels * frame_size] +=  window[i_sample] * channel_buffer0[i_sample];
-                output_buffer[i_sample + i_out_channels * frame_size] += (1.f - window[i_sample]) * channel_buffer1[i_sample];
-            }
-            for (i_sample = overlap_size; i_sample < frame_size; i_sample++)
-            {
-                output_buffer[i_sample + i_out_channels * frame_size] += channel_buffer1[i_sample];
-            }
-        }
-    }
-
-    OPUS_COPY(x_out, output_buffer, out_channels * frame_size);
-
-#ifdef DEBUG_NNDSP
-    print_float_vector("x_out", x_out, out_channels * frame_size);
-#endif
-
-    /* buffer update */
-    for (i_in_channels=0; i_in_channels < in_channels; i_in_channels ++)
-    {
-        OPUS_COPY(hAdaConv->history + i_in_channels * kernel_size, p_input + i_in_channels * (frame_size + kernel_size) + frame_size - kernel_size, kernel_size);
-    }
-    OPUS_COPY(hAdaConv->last_kernel, kernel_buffer, kernel_size * in_channels * out_channels);
-}
-
-void adacomb_process_frame(
-    AdaCombState* hAdaComb,
-    float *x_out,
-    const float *x_in,
-    const float *features,
-    const LinearLayer *kernel_layer,
-    const LinearLayer *gain_layer,
-    const LinearLayer *global_gain_layer,
-    int pitch_lag,
-    int feature_dim,
-    int frame_size,
-    int overlap_size,
-    int kernel_size,
-    int left_padding,
-    float filter_gain_a,
-    float filter_gain_b,
-    float log_gain_limit,
-    float *window,
-    int arch
-)
-{
-    float output_buffer[ADACOMB_MAX_FRAME_SIZE];
-    float output_buffer_last[ADACOMB_MAX_FRAME_SIZE];
-    float kernel_buffer[ADACOMB_MAX_KERNEL_SIZE];
-    float input_buffer[ADACOMB_MAX_FRAME_SIZE + ADACOMB_MAX_LAG + ADACOMB_MAX_KERNEL_SIZE];
-    float gain, global_gain;
-    float *p_input;
-    int i_sample;
-    float kernel[16];
-    float last_kernel[16];
-
-    (void) feature_dim; /* ToDo: figure out whether we might need this information */
-
-    OPUS_CLEAR(output_buffer, ADACOMB_MAX_FRAME_SIZE);
-    OPUS_CLEAR(kernel_buffer, ADACOMB_MAX_KERNEL_SIZE);
-    OPUS_CLEAR(input_buffer, ADACOMB_MAX_FRAME_SIZE + ADACOMB_MAX_LAG + ADACOMB_MAX_KERNEL_SIZE);
-
-    OPUS_COPY(input_buffer, hAdaComb->history, kernel_size + ADACOMB_MAX_LAG);
-    OPUS_COPY(input_buffer + kernel_size + ADACOMB_MAX_LAG, x_in, frame_size);
-    p_input = input_buffer + kernel_size + ADACOMB_MAX_LAG;
-
-    /* calculate new kernel and new gain */
-    compute_generic_dense(kernel_layer, kernel_buffer, features, ACTIVATION_LINEAR, arch);
-    compute_generic_dense(gain_layer, &gain, features, ACTIVATION_RELU, arch);
-    compute_generic_dense(global_gain_layer, &global_gain, features, ACTIVATION_TANH, arch);
-#ifdef DEBUG_NNDSP
-    print_float_vector("features", features, feature_dim);
-    print_float_vector("adacomb_kernel_raw", kernel_buffer, kernel_size);
-    print_float_vector("adacomb_gain_raw", &gain, 1);
-    print_float_vector("adacomb_global_gain_raw", &global_gain, 1);
-#endif
-    gain = exp(log_gain_limit - gain);
-    global_gain = exp(filter_gain_a * global_gain + filter_gain_b);
-    scale_kernel(kernel_buffer, 1, 1, kernel_size, &gain);
-
-#ifdef DEBUG_NNDSP
-    print_float_vector("adacomb_kernel", kernel_buffer, kernel_size);
-    print_float_vector("adacomb_gain", &gain, 1);
-#endif
-
-    OPUS_CLEAR(kernel, ADACOMB_MAX_KERNEL_SIZE);
-    OPUS_CLEAR(last_kernel, ADACOMB_MAX_KERNEL_SIZE);
-    OPUS_COPY(kernel, kernel_buffer, kernel_size);
-    OPUS_COPY(last_kernel, hAdaComb->last_kernel, kernel_size);
-
-    celt_pitch_xcorr(last_kernel, &p_input[- left_padding - hAdaComb->last_pitch_lag], output_buffer_last, ADACOMB_MAX_KERNEL_SIZE, overlap_size, arch);
-
-    celt_pitch_xcorr(kernel, &p_input[- left_padding - pitch_lag], output_buffer, ADACOMB_MAX_KERNEL_SIZE, frame_size, arch);
-    for (i_sample = 0; i_sample < overlap_size; i_sample++)
-    {
-      output_buffer[i_sample] = hAdaComb->last_global_gain * window[i_sample] * output_buffer_last[i_sample] + global_gain * (1.f - window[i_sample]) * output_buffer[i_sample];
-    }
-
-    for (i_sample = 0; i_sample < overlap_size; i_sample++)
-    {
-      output_buffer[i_sample] += (window[i_sample] * hAdaComb->last_global_gain + (1.f - window[i_sample]) * global_gain) * p_input[i_sample];
-    }
-
-    for (i_sample = overlap_size; i_sample < frame_size; i_sample++)
-    {
-      output_buffer[i_sample] = global_gain * (output_buffer[i_sample] + p_input[i_sample]);
-    }
-    OPUS_COPY(x_out, output_buffer, frame_size);
-
-#ifdef DEBUG_NNDSP
-    print_float_vector("x_out", x_out, frame_size);
-#endif
-
-    /* buffer update */
-    OPUS_COPY(hAdaComb->last_kernel, kernel_buffer, kernel_size);
-    OPUS_COPY(hAdaComb->history, p_input + frame_size - kernel_size - ADACOMB_MAX_LAG, kernel_size + ADACOMB_MAX_LAG);
-    hAdaComb->last_pitch_lag = pitch_lag;
-    hAdaComb->last_global_gain = global_gain;
-}
-
-
-void adashape_process_frame(
-    AdaShapeState *hAdaShape,
-    float *x_out,
-    const float *x_in,
-    const float *features,
-    const LinearLayer *alpha1f,
-    const LinearLayer *alpha1t,
-    const LinearLayer *alpha2,
-    int feature_dim,
-    int frame_size,
-    int avg_pool_k,
-    int arch
-)
-{
-    float in_buffer[ADASHAPE_MAX_INPUT_DIM + ADASHAPE_MAX_FRAME_SIZE];
-    float out_buffer[ADASHAPE_MAX_FRAME_SIZE];
-    float tmp_buffer[ADASHAPE_MAX_FRAME_SIZE];
-    int i, k;
-    int tenv_size;
-    float mean;
-    float *tenv;
-
-    celt_assert(frame_size % avg_pool_k == 0);
-    celt_assert(feature_dim + frame_size / avg_pool_k + 1 < ADASHAPE_MAX_INPUT_DIM);
-
-    tenv_size = frame_size / avg_pool_k;
-    tenv = in_buffer + feature_dim;
-    OPUS_CLEAR(tenv, tenv_size + 1);
-
-    OPUS_COPY(in_buffer, features, feature_dim);
-
-    /* calculate temporal envelope */
-    mean = 0;
-    for (i = 0; i < tenv_size; i++)
-    {
-        for (k = 0; k < avg_pool_k; k++)
-        {
-            tenv[i] += fabs(x_in[i * avg_pool_k + k]);
-        }
-        tenv[i] = log(tenv[i] / avg_pool_k + 1.52587890625e-05f);
-        mean += tenv[i];
-    }
-    mean /= tenv_size;
-    for (i = 0; i < tenv_size; i++)
-    {
-        tenv[i] -= mean;
-    }
-    tenv[tenv_size] = mean;
-#ifdef DEBUG_NNDSP
-    print_float_vector("tenv", tenv, tenv_size + 1);
-#endif
-
-    /* calculate temporal weights */
-#ifdef DEBUG_NNDSP
-    print_float_vector("alpha1_in", in_buffer, feature_dim + tenv_size + 1);
-#endif
-    compute_generic_conv1d(alpha1f, out_buffer, hAdaShape->conv_alpha1f_state, in_buffer, feature_dim, ACTIVATION_LINEAR, arch);
-    compute_generic_conv1d(alpha1t, tmp_buffer, hAdaShape->conv_alpha1t_state, tenv, tenv_size + 1, ACTIVATION_LINEAR, arch);
-#ifdef DEBUG_NNDSP
-    print_float_vector("alpha1_out", out_buffer, frame_size);
-#endif
-    /* compute leaky ReLU by hand. ToDo: try tanh activation */
-    for (i = 0; i < frame_size; i ++)
-    {
-        float tmp = out_buffer[i] + tmp_buffer[i];
-        in_buffer[i] = tmp >= 0 ? tmp : 0.2 * tmp;
-    }
-#ifdef DEBUG_NNDSP
-    print_float_vector("post_alpha1", in_buffer, frame_size);
-#endif
-    compute_generic_conv1d(alpha2, out_buffer, hAdaShape->conv_alpha2_state, in_buffer, frame_size, ACTIVATION_LINEAR, arch);
-
-    /* shape signal */
-    for (i = 0; i < frame_size; i ++)
-    {
-        x_out[i] = exp(out_buffer[i]) * x_in[i];
-    }
-
-}

package/opus/dnn/nndsp.h

@@ -1,143 +0,0 @@
-/* Copyright (c) 2023 Amazon
-   Written by Jan Buethe */
-/*
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions
-   are met:
-
-   - Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-
-   - Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
-   OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifndef NNDSP_H
-#define NNDSP_H
-
-#include "opus_types.h"
-#include "nnet.h"
-#include <string.h>
-
-
-#define ADACONV_MAX_KERNEL_SIZE 16
-#define ADACONV_MAX_INPUT_CHANNELS 2
-#define ADACONV_MAX_OUTPUT_CHANNELS 2
-#define ADACONV_MAX_FRAME_SIZE 80
-#define ADACONV_MAX_OVERLAP_SIZE 40
-
-#define ADACOMB_MAX_LAG 300
-#define ADACOMB_MAX_KERNEL_SIZE 16
-#define ADACOMB_MAX_FRAME_SIZE 80
-#define ADACOMB_MAX_OVERLAP_SIZE 40
-
-#define ADASHAPE_MAX_INPUT_DIM 512
-#define ADASHAPE_MAX_FRAME_SIZE 160
-
-/*#define DEBUG_NNDSP*/
-#ifdef DEBUG_NNDSP
-#include <stdio.h>
-#endif
-
-
-void print_float_vector(const char* name, const float *vec, int length);
-
-typedef struct {
-    float history[ADACONV_MAX_KERNEL_SIZE * ADACONV_MAX_INPUT_CHANNELS];
-    float last_kernel[ADACONV_MAX_KERNEL_SIZE * ADACONV_MAX_INPUT_CHANNELS * ADACONV_MAX_OUTPUT_CHANNELS];
-    float last_gain;
-} AdaConvState;
-
-
-typedef struct {
-    float history[ADACOMB_MAX_KERNEL_SIZE + ADACOMB_MAX_LAG];
-    float last_kernel[ADACOMB_MAX_KERNEL_SIZE];
-    float last_global_gain;
-    int last_pitch_lag;
-} AdaCombState;
-
-
-typedef struct {
-    float conv_alpha1f_state[ADASHAPE_MAX_INPUT_DIM];
-    float conv_alpha1t_state[ADASHAPE_MAX_INPUT_DIM];
-    float conv_alpha2_state[ADASHAPE_MAX_FRAME_SIZE];
-} AdaShapeState;
-
-void init_adaconv_state(AdaConvState *hAdaConv);
-
-void init_adacomb_state(AdaCombState *hAdaComb);
-
-void init_adashape_state(AdaShapeState *hAdaShape);
-
-void compute_overlap_window(float *window, int overlap_size);
-
-void adaconv_process_frame(
-    AdaConvState* hAdaConv,
-    float *x_out,
-    const float *x_in,
-    const float *features,
-    const LinearLayer *kernel_layer,
-    const LinearLayer *gain_layer,
-    int feature_dim, /* not strictly necessary */
-    int frame_size,
-    int overlap_size,
-    int in_channels,
-    int out_channels,
-    int kernel_size,
-    int left_padding,
-    float filter_gain_a,
-    float filter_gain_b,
-    float shape_gain,
-    float *window,
-    int arch
-);
-
-void adacomb_process_frame(
-    AdaCombState* hAdaComb,
-    float *x_out,
-    const float *x_in,
-    const float *features,
-    const LinearLayer *kernel_layer,
-    const LinearLayer *gain_layer,
-    const LinearLayer *global_gain_layer,
-    int pitch_lag,
-    int feature_dim,
-    int frame_size,
-    int overlap_size,
-    int kernel_size,
-    int left_padding,
-    float filter_gain_a,
-    float filter_gain_b,
-    float log_gain_limit,
-    float *window,
-    int arch
-);
-
-void adashape_process_frame(
-    AdaShapeState *hAdaShape,
-    float *x_out,
-    const float *x_in,
-    const float *features,
-    const LinearLayer *alpha1f,
-    const LinearLayer *alpha1t,
-    const LinearLayer *alpha2,
-    int feature_dim,
-    int frame_size,
-    int avg_pool_k,
-    int arch
-);
-
-#endif

package/opus/dnn/nnet.c

@@ -1,149 +0,0 @@
-/* Copyright (c) 2018 Mozilla
-                 2008-2011 Octasic Inc.
-                 2012-2017 Jean-Marc Valin */
-/*
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions
-   are met:
-
-   - Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-
-   - Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
-   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <stdlib.h>
-#include <math.h>
-#include "opus_types.h"
-#include "arch.h"
-#include "nnet.h"
-#include "dred_rdovae_constants.h"
-#include "plc_data.h"
-#include "fargan.h"
-#include "os_support.h"
-#include "vec.h"
-
-#ifdef ENABLE_OSCE
-#include "osce.h"
-#endif
-
-#ifdef NO_OPTIMIZATIONS
-#if defined(_MSC_VER)
-#pragma message ("Compiling without any vectorization. This code will be very slow")
-#else
-#warning Compiling without any vectorization. This code will be very slow
-#endif
-#endif
-
-
-#define SOFTMAX_HACK
-
-
-void compute_generic_dense(const LinearLayer *layer, float *output, const float *input, int activation, int arch)
-{
-   compute_linear(layer, output, input, arch);
-   compute_activation(output, output, layer->nb_outputs, activation, arch);
-}
-
-#ifdef ENABLE_OSCE
-#define MAX_RNN_NEURONS_ALL IMAX(IMAX(IMAX(FARGAN_MAX_RNN_NEURONS, PLC_MAX_RNN_UNITS), DRED_MAX_RNN_NEURONS), OSCE_MAX_RNN_NEURONS)
-#else
-#define MAX_RNN_NEURONS_ALL IMAX(IMAX(FARGAN_MAX_RNN_NEURONS, PLC_MAX_RNN_UNITS), DRED_MAX_RNN_NEURONS)
-#endif
-
-void compute_generic_gru(const LinearLayer *input_weights, const LinearLayer *recurrent_weights, float *state, const float *in, int arch)
-{
-  int i;
-  int N;
-  float zrh[3*MAX_RNN_NEURONS_ALL];
-  float recur[3*MAX_RNN_NEURONS_ALL];
-  float *z;
-  float *r;
-  float *h;
-  celt_assert(3*recurrent_weights->nb_inputs == recurrent_weights->nb_outputs);
-  celt_assert(input_weights->nb_outputs == recurrent_weights->nb_outputs);
-  N = recurrent_weights->nb_inputs;
-  z = zrh;
-  r = &zrh[N];
-  h = &zrh[2*N];
-  celt_assert(recurrent_weights->nb_outputs <= 3*MAX_RNN_NEURONS_ALL);
-  celt_assert(in != state);
-  compute_linear(input_weights, zrh, in, arch);
-  compute_linear(recurrent_weights, recur, state, arch);
-  for (i=0;i<2*N;i++)
-     zrh[i] += recur[i];
-  compute_activation(zrh, zrh, 2*N, ACTIVATION_SIGMOID, arch);
-  for (i=0;i<N;i++)
-     h[i] += recur[2*N+i]*r[i];
-  compute_activation(h, h, N, ACTIVATION_TANH, arch);
-  for (i=0;i<N;i++)
-     h[i] = z[i]*state[i] + (1-z[i])*h[i];
-  for (i=0;i<N;i++)
-     state[i] = h[i];
-}
-
-void compute_glu(const LinearLayer *layer, float *output, const float *input, int arch)
-{
-   int i;
-   float act2[MAX_INPUTS];
-   celt_assert(layer->nb_inputs == layer->nb_outputs);
-   compute_linear(layer, act2, input, arch);
-   compute_activation(act2, act2, layer->nb_outputs, ACTIVATION_SIGMOID, arch);
-   if (input == output) {
-     /* Give a vectorization hint to the compiler for the in-place case. */
-     for (i=0;i<layer->nb_outputs;i++) output[i] = output[i]*act2[i];
-   } else {
-     for (i=0;i<layer->nb_outputs;i++) output[i] = input[i]*act2[i];
-   }
-}
-
-#define MAX_CONV_INPUTS_ALL DRED_MAX_CONV_INPUTS
-
-void compute_generic_conv1d(const LinearLayer *layer, float *output, float *mem, const float *input, int input_size, int activation, int arch)
-{
-   float tmp[MAX_CONV_INPUTS_ALL];
-   celt_assert(input != output);
-   celt_assert(layer->nb_inputs <= MAX_CONV_INPUTS_ALL);
-   if (layer->nb_inputs!=input_size) OPUS_COPY(tmp, mem, layer->nb_inputs-input_size);
-   OPUS_COPY(&tmp[layer->nb_inputs-input_size], input, input_size);
-   compute_linear(layer, output, tmp, arch);
-   compute_activation(output, output, layer->nb_outputs, activation, arch);
-   if (layer->nb_inputs!=input_size) OPUS_COPY(mem, &tmp[input_size], layer->nb_inputs-input_size);
-}
-
-void compute_generic_conv1d_dilation(const LinearLayer *layer, float *output, float *mem, const float *input, int input_size, int dilation, int activation, int arch)
-{
-   float tmp[MAX_CONV_INPUTS_ALL];
-   int ksize = layer->nb_inputs/input_size;
-   int i;
-   celt_assert(input != output);
-   celt_assert(layer->nb_inputs <= MAX_CONV_INPUTS_ALL);
-   if (dilation==1) OPUS_COPY(tmp, mem, layer->nb_inputs-input_size);
-   else for (i=0;i<ksize-1;i++) OPUS_COPY(&tmp[i*input_size], &mem[i*input_size*dilation], input_size);
-   OPUS_COPY(&tmp[layer->nb_inputs-input_size], input, input_size);
-   compute_linear(layer, output, tmp, arch);
-   compute_activation(output, output, layer->nb_outputs, activation, arch);
-   if (dilation==1) OPUS_COPY(mem, &tmp[input_size], layer->nb_inputs-input_size);
-   else {
-     OPUS_COPY(mem, &mem[input_size], input_size*dilation*(ksize-1)-input_size);
-     OPUS_COPY(&mem[input_size*dilation*(ksize-1)-input_size], input, input_size);
-   }
-}