apply code-format changes

futz12 · github-actions[bot] · commit 0546aa4aa238 · 2025-05-29T12:58:50.000Z
diff --git a/src/layer/x86/spectrogram_x86.cpp b/src/layer/x86/spectrogram_x86.cpp
@@ -99,37 +99,38 @@ int Spectrogram_x86::load_param(const ParamDict& pd)
     if (onesided)
     {
         n_freq = n_fft / 2 + 1;
-    } else
+    }
+    else
     {
         n_freq = n_fft;
     }
-    theta.create(n_fft,n_freq,size_t(8));
+    theta.create(n_fft, n_freq, size_t(8));
 
-    for (int i = 0; i<n_freq; i++)
+    for (int i = 0; i < n_freq; i++)
     {
-        for (int j = 0; j<n_fft; j++)
+        for (int j = 0; j < n_fft; j++)
         {
             theta.row<double>(i)[j] = 2 * 3.14159265358979323846 * i * j / n_fft;
         }
     }
 
     Mat real_basis, imag_basis;
-    real_basis.create(n_fft,n_freq,size_t(8));
-    imag_basis.create(n_fft,n_freq,size_t(8));
+    real_basis.create(n_fft, n_freq, size_t(8));
+    imag_basis.create(n_fft, n_freq, size_t(8));
 
-    for (int i = 0; i<n_freq; i++)
+    for (int i = 0; i < n_freq; i++)
     {
-        for (int j = 0; j<n_fft; j++)
+        for (int j = 0; j < n_fft; j++)
         {
             real_basis.row<double>(i)[j] = cos(theta.row<double>(i)[j]);
             imag_basis.row<double>(i)[j] = -sin(theta.row<double>(i)[j]);
         }
     }
 
     // multiply window
-    for (int i = 0; i<n_freq; i++)
+    for (int i = 0; i < n_freq; i++)
     {
-        for (int j = 0; j<n_fft; j++)
+        for (int j = 0; j < n_fft; j++)
         {
             real_basis.row<double>(i)[j] *= window_data[j];
             imag_basis.row<double>(i)[j] *= window_data[j];
@@ -139,34 +140,34 @@ int Spectrogram_x86::load_param(const ParamDict& pd)
     if (normalized == 1)
     {
         double scale = 1.f / sqrt(n_fft);
-        for (int i = 0; i<n_freq; i++)
+        for (int i = 0; i < n_freq; i++)
         {
-            for (int j = 0; j<n_fft; j++)
+            for (int j = 0; j < n_fft; j++)
             {
                 real_basis.row<double>(i)[j] *= scale;
                 imag_basis.row<double>(i)[j] *= scale;
             }
         }
     }
 
-    conv_data.create(n_fft,1,n_freq * 2);
+    conv_data.create(n_fft, 1, n_freq * 2);
 
-    for (int i = 0; i<n_freq; i++)
+    for (int i = 0; i < n_freq; i++)
     {
-        for (int j = 0; j<n_fft; j++)
+        for (int j = 0; j < n_fft; j++)
         {
-            conv_data.channel(i).row<float>(0)[j]= (float)real_basis.row<double>(i)[j];
-            conv_data.channel(i+n_freq).row<float>(0)[j] = (float)imag_basis.row<double>(i)[j];
+            conv_data.channel(i).row<float>(0)[j] = (float)real_basis.row<double>(i)[j];
+            conv_data.channel(i + n_freq).row<float>(0)[j] = (float)imag_basis.row<double>(i)[j];
         }
     }
 
     conv_transpose = ncnn::create_layer("Convolution1D");
     ncnn::ParamDict conv_transpose_pd;
 
-    conv_transpose_pd.set(0,2 * n_freq); // num_output
-    conv_transpose_pd.set(1,n_fft); // kernel_w
-    conv_transpose_pd.set(3,hoplen); // stride_w
-    conv_transpose_pd.set(19,1); // dynamic_weight
+    conv_transpose_pd.set(0, 2 * n_freq); // num_output
+    conv_transpose_pd.set(1, n_fft);      // kernel_w
+    conv_transpose_pd.set(3, hoplen);     // stride_w
+    conv_transpose_pd.set(19, 1);         // dynamic_weight
 
     conv_transpose->load_param(conv_transpose_pd);
 
@@ -226,7 +227,7 @@ int Spectrogram_x86::forward(const Mat& bottom_blob, Mat& top_blob, const Option
     opt_conv.use_packing_layout = false;
 
     conv_transpose->create_pipeline(opt_conv);
-    conv_transpose->forward(inputs,outputs,opt_conv);
+    conv_transpose->forward(inputs, outputs, opt_conv);
     conv_transpose->destroy_pipeline(opt_conv);
 
     Mat conv_top_blob = outputs[0]; // (2 * n_freq, frames)
@@ -235,15 +236,16 @@ int Spectrogram_x86::forward(const Mat& bottom_blob, Mat& top_blob, const Option
     if (power == 0) // as complex
     {
         // copy
-        for (int i = 0; i<frames; i++)
+        for (int i = 0; i < frames; i++)
         {
-            for (int j = 0; j<n_freq; j++)
+            for (int j = 0; j < n_freq; j++)
             {
                 top_blob.channel(j).row<float>(i)[0] = conv_top_data[j * frames + i];
                 top_blob.channel(j).row<float>(i)[1] = conv_top_data[(j + n_freq) * frames + i];
             }
         }
-    } else
+    }
+    else
     {
         if (power == 1) // magnitude sqrt(re * re + im * im);
         {
@@ -255,12 +257,13 @@ int Spectrogram_x86::forward(const Mat& bottom_blob, Mat& top_blob, const Option
                     top_blob.row<float>(j)[i] = sqrtf(conv_top_data[j * frames + i] * conv_top_data[j * frames + i] + conv_top_data[(j + n_freq) * frames + i] * conv_top_data[(j + n_freq) * frames + i]);
                 }
             }
-        } else if (power == 2) // power re * re + im * im;
+        }
+        else if (power == 2) // power re * re + im * im;
         {
             // copy
             for (int i = 0; i < frames; i++)
             {
-                for (int j = 0; j< n_freq; j++)
+                for (int j = 0; j < n_freq; j++)
                 {
                     top_blob.row<float>(j)[i] = conv_top_data[j * frames + i] * conv_top_data[j * frames + i] + conv_top_data[(j + n_freq) * frames + i] * conv_top_data[(j + n_freq) * frames + i];
                 }
diff --git a/tests/test_spectrogram.cpp b/tests/test_spectrogram.cpp
@@ -50,9 +50,9 @@ static int test_spectrogram_0()
            || test_spectrogram(124, 55, 2, 12, 55, 1, 1, 2, 2, 0);
 }
 
-static int test_spectrogram_eval(int size, int n_fft, int power, int hoplen, int winlen, int window_type, int center, int pad_type, int normalized, int onesided,float * in,float * std)
+static int test_spectrogram_eval(int size, int n_fft, int power, int hoplen, int winlen, int window_type, int center, int pad_type, int normalized, int onesided, float* in, float* std)
 {
-    ncnn::Layer * layer = ncnn::create_layer("Spectrogram");
+    ncnn::Layer* layer = ncnn::create_layer("Spectrogram");
 
     ncnn::ParamDict pd;
     pd.set(0, n_fft);
@@ -82,7 +82,7 @@ static int test_spectrogram_eval(int size, int n_fft, int power, int hoplen, int
 
     for (int i = 0; i < output.c; i++)
     {
-        float * output_data = output.channel(i);
+        float* output_data = output.channel(i);
         for (int j = 0; j < output.h; j++)
         {
             for (int k = 0; k < output.w; k++)
@@ -113,11 +113,9 @@ static int test_spectrogram_1()
         0.28284273f, 0.49497476f, 0.70710677f, 0.24271232f, 0.42322639f, 0.60407096f, 0.14577380f, 0.25000000f, 0.35531676f, 0.04838108f, 0.07667736f, 0.10652842f, 0.00000000f, 0.00000002f, 0.00000000f, 0.04838108f, 0.07667736f, 0.10652842f, 0.14577380f, 0.25000000f, 0.35531676f, 0.24271232f, 0.42322639f, 0.60407096f
     };
 
-    return
-    test_spectrogram_eval(16, 4, 1, 2, 4, 1, 1, 0, 0, 1, input_0, std_0)
-    || test_spectrogram_eval(16, 8, 1, 2, 4, 1, 0, 0, 0, 1, input_0, std_1)
-    || test_spectrogram_eval(16, 8, 1, 3, 4, 1, 0, 0, 1, 0, input_0, std_2);
-
+    return test_spectrogram_eval(16, 4, 1, 2, 4, 1, 1, 0, 0, 1, input_0, std_0)
+           || test_spectrogram_eval(16, 8, 1, 2, 4, 1, 0, 0, 0, 1, input_0, std_1)
+           || test_spectrogram_eval(16, 8, 1, 3, 4, 1, 0, 0, 1, 0, input_0, std_2);
 }
 
 int main()

Original file line number	Diff line number	Diff line change
`@@ -99,37 +99,38 @@ int Spectrogram_x86::load_param(const ParamDict& pd)`
`99`	`99`	`if (onesided)`
`100`	`100`	`{`
`101`	`101`	`n_freq = n_fft / 2 + 1;`
`102`		`- } else`
	`102`	`+ }`
	`103`	`+ else`
`103`	`104`	`{`
`104`	`105`	`n_freq = n_fft;`
`105`	`106`	`}`
`106`		`- theta.create(n_fft,n_freq,size_t(8));`
	`107`	`+ theta.create(n_fft, n_freq, size_t(8));`
`107`	`108`
`108`		`- for (int i = 0; i<n_freq; i++)`
	`109`	`+ for (int i = 0; i < n_freq; i++)`
`109`	`110`	`{`
`110`		`- for (int j = 0; j<n_fft; j++)`
	`111`	`+ for (int j = 0; j < n_fft; j++)`
`111`	`112`	`{`
`112`	`113`	`theta.row<double>(i)[j] = 2 * 3.14159265358979323846 * i * j / n_fft;`
`113`	`114`	`}`
`114`	`115`	`}`
`115`	`116`
`116`	`117`	`Mat real_basis, imag_basis;`
`117`		`- real_basis.create(n_fft,n_freq,size_t(8));`
`118`		`- imag_basis.create(n_fft,n_freq,size_t(8));`
	`118`	`+ real_basis.create(n_fft, n_freq, size_t(8));`
	`119`	`+ imag_basis.create(n_fft, n_freq, size_t(8));`
`119`	`120`
`120`		`- for (int i = 0; i<n_freq; i++)`
	`121`	`+ for (int i = 0; i < n_freq; i++)`
`121`	`122`	`{`
`122`		`- for (int j = 0; j<n_fft; j++)`
	`123`	`+ for (int j = 0; j < n_fft; j++)`
`123`	`124`	`{`
`124`	`125`	`real_basis.row<double>(i)[j] = cos(theta.row<double>(i)[j]);`
`125`	`126`	`imag_basis.row<double>(i)[j] = -sin(theta.row<double>(i)[j]);`
`126`	`127`	`}`
`127`	`128`	`}`
`128`	`129`
`129`	`130`	`// multiply window`
`130`		`- for (int i = 0; i<n_freq; i++)`
	`131`	`+ for (int i = 0; i < n_freq; i++)`
`131`	`132`	`{`
`132`		`- for (int j = 0; j<n_fft; j++)`
	`133`	`+ for (int j = 0; j < n_fft; j++)`
`133`	`134`	`{`
`134`	`135`	`real_basis.row<double>(i)[j] *= window_data[j];`
`135`	`136`	`imag_basis.row<double>(i)[j] *= window_data[j];`
`@@ -139,34 +140,34 @@ int Spectrogram_x86::load_param(const ParamDict& pd)`
`139`	`140`	`if (normalized == 1)`
`140`	`141`	`{`
`141`	`142`	`double scale = 1.f / sqrt(n_fft);`
`142`		`- for (int i = 0; i<n_freq; i++)`
	`143`	`+ for (int i = 0; i < n_freq; i++)`
`143`	`144`	`{`
`144`		`- for (int j = 0; j<n_fft; j++)`
	`145`	`+ for (int j = 0; j < n_fft; j++)`
`145`	`146`	`{`
`146`	`147`	`real_basis.row<double>(i)[j] *= scale;`
`147`	`148`	`imag_basis.row<double>(i)[j] *= scale;`
`148`	`149`	`}`
`149`	`150`	`}`
`150`	`151`	`}`
`151`	`152`
`152`		`- conv_data.create(n_fft,1,n_freq * 2);`
	`153`	`+ conv_data.create(n_fft, 1, n_freq * 2);`
`153`	`154`
`154`		`- for (int i = 0; i<n_freq; i++)`
	`155`	`+ for (int i = 0; i < n_freq; i++)`
`155`	`156`	`{`
`156`		`- for (int j = 0; j<n_fft; j++)`
	`157`	`+ for (int j = 0; j < n_fft; j++)`
`157`	`158`	`{`
`158`		`- conv_data.channel(i).row<float>(0)[j]= (float)real_basis.row<double>(i)[j];`
`159`		`- conv_data.channel(i+n_freq).row<float>(0)[j] = (float)imag_basis.row<double>(i)[j];`
	`159`	`+ conv_data.channel(i).row<float>(0)[j] = (float)real_basis.row<double>(i)[j];`
	`160`	`+ conv_data.channel(i + n_freq).row<float>(0)[j] = (float)imag_basis.row<double>(i)[j];`
`160`	`161`	`}`
`161`	`162`	`}`
`162`	`163`
`163`	`164`	`conv_transpose = ncnn::create_layer("Convolution1D");`
`164`	`165`	`ncnn::ParamDict conv_transpose_pd;`
`165`	`166`
`166`		`- conv_transpose_pd.set(0,2 * n_freq); // num_output`
`167`		`- conv_transpose_pd.set(1,n_fft); // kernel_w`
`168`		`- conv_transpose_pd.set(3,hoplen); // stride_w`
`169`		`- conv_transpose_pd.set(19,1); // dynamic_weight`
	`167`	`+ conv_transpose_pd.set(0, 2 * n_freq); // num_output`
	`168`	`+ conv_transpose_pd.set(1, n_fft); // kernel_w`
	`169`	`+ conv_transpose_pd.set(3, hoplen); // stride_w`
	`170`	`+ conv_transpose_pd.set(19, 1); // dynamic_weight`
`170`	`171`
`171`	`172`	`conv_transpose->load_param(conv_transpose_pd);`
`172`	`173`
`@@ -226,7 +227,7 @@ int Spectrogram_x86::forward(const Mat& bottom_blob, Mat& top_blob, const Option`
`226`	`227`	`opt_conv.use_packing_layout = false;`
`227`	`228`
`228`	`229`	`conv_transpose->create_pipeline(opt_conv);`
`229`		`- conv_transpose->forward(inputs,outputs,opt_conv);`
	`230`	`+ conv_transpose->forward(inputs, outputs, opt_conv);`
`230`	`231`	`conv_transpose->destroy_pipeline(opt_conv);`
`231`	`232`
`232`	`233`	`Mat conv_top_blob = outputs[0]; // (2 * n_freq, frames)`
`@@ -235,15 +236,16 @@ int Spectrogram_x86::forward(const Mat& bottom_blob, Mat& top_blob, const Option`
`235`	`236`	`if (power == 0) // as complex`
`236`	`237`	`{`
`237`	`238`	`// copy`
`238`		`- for (int i = 0; i<frames; i++)`
	`239`	`+ for (int i = 0; i < frames; i++)`
`239`	`240`	`{`
`240`		`- for (int j = 0; j<n_freq; j++)`
	`241`	`+ for (int j = 0; j < n_freq; j++)`
`241`	`242`	`{`
`242`	`243`	`top_blob.channel(j).row<float>(i)[0] = conv_top_data[j * frames + i];`
`243`	`244`	`top_blob.channel(j).row<float>(i)[1] = conv_top_data[(j + n_freq) * frames + i];`
`244`	`245`	`}`
`245`	`246`	`}`
`246`		`- } else`
	`247`	`+ }`
	`248`	`+ else`
`247`	`249`	`{`
`248`	`250`	`if (power == 1) // magnitude sqrt(re * re + im * im);`
`249`	`251`	`{`
`@@ -255,12 +257,13 @@ int Spectrogram_x86::forward(const Mat& bottom_blob, Mat& top_blob, const Option`
`255`	`257`	`top_blob.row<float>(j)[i] = sqrtf(conv_top_data[j * frames + i] * conv_top_data[j * frames + i] + conv_top_data[(j + n_freq) * frames + i] * conv_top_data[(j + n_freq) * frames + i]);`
`256`	`258`	`}`
`257`	`259`	`}`
`258`		`- } else if (power == 2) // power re * re + im * im;`
	`260`	`+ }`
	`261`	`+ else if (power == 2) // power re * re + im * im;`
`259`	`262`	`{`
`260`	`263`	`// copy`
`261`	`264`	`for (int i = 0; i < frames; i++)`
`262`	`265`	`{`
`263`		`- for (int j = 0; j< n_freq; j++)`
	`266`	`+ for (int j = 0; j < n_freq; j++)`
`264`	`267`	`{`
`265`	`268`	`top_blob.row<float>(j)[i] = conv_top_data[j * frames + i] * conv_top_data[j * frames + i] + conv_top_data[(j + n_freq) * frames + i] * conv_top_data[(j + n_freq) * frames + i];`
`266`	`269`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,9 +50,9 @@ static int test_spectrogram_0()`
`50`	`50`	`\|\| test_spectrogram(124, 55, 2, 12, 55, 1, 1, 2, 2, 0);`
`51`	`51`	`}`
`52`	`52`
`53`		`-static int test_spectrogram_eval(int size, int n_fft, int power, int hoplen, int winlen, int window_type, int center, int pad_type, int normalized, int onesided,float * in,float * std)`
	`53`	`+static int test_spectrogram_eval(int size, int n_fft, int power, int hoplen, int winlen, int window_type, int center, int pad_type, int normalized, int onesided, float* in, float* std)`
`54`	`54`	`{`
`55`		`- ncnn::Layer * layer = ncnn::create_layer("Spectrogram");`
	`55`	`+ ncnn::Layer* layer = ncnn::create_layer("Spectrogram");`
`56`	`56`
`57`	`57`	`ncnn::ParamDict pd;`
`58`	`58`	`pd.set(0, n_fft);`
`@@ -82,7 +82,7 @@ static int test_spectrogram_eval(int size, int n_fft, int power, int hoplen, int`
`82`	`82`
`83`	`83`	`for (int i = 0; i < output.c; i++)`
`84`	`84`	`{`
`85`		`- float * output_data = output.channel(i);`
	`85`	`+ float* output_data = output.channel(i);`
`86`	`86`	`for (int j = 0; j < output.h; j++)`
`87`	`87`	`{`
`88`	`88`	`for (int k = 0; k < output.w; k++)`
`@@ -113,11 +113,9 @@ static int test_spectrogram_1()`
`113`	`113`	`0.28284273f, 0.49497476f, 0.70710677f, 0.24271232f, 0.42322639f, 0.60407096f, 0.14577380f, 0.25000000f, 0.35531676f, 0.04838108f, 0.07667736f, 0.10652842f, 0.00000000f, 0.00000002f, 0.00000000f, 0.04838108f, 0.07667736f, 0.10652842f, 0.14577380f, 0.25000000f, 0.35531676f, 0.24271232f, 0.42322639f, 0.60407096f`
`114`	`114`	`};`
`115`	`115`
`116`		`- return`
`117`		`- test_spectrogram_eval(16, 4, 1, 2, 4, 1, 1, 0, 0, 1, input_0, std_0)`
`118`		`- \|\| test_spectrogram_eval(16, 8, 1, 2, 4, 1, 0, 0, 0, 1, input_0, std_1)`
`119`		`- \|\| test_spectrogram_eval(16, 8, 1, 3, 4, 1, 0, 0, 1, 0, input_0, std_2);`
`120`		`-`
	`116`	`+ return test_spectrogram_eval(16, 4, 1, 2, 4, 1, 1, 0, 0, 1, input_0, std_0)`
	`117`	`+ \|\| test_spectrogram_eval(16, 8, 1, 2, 4, 1, 0, 0, 0, 1, input_0, std_1)`
	`118`	`+ \|\| test_spectrogram_eval(16, 8, 1, 3, 4, 1, 0, 0, 1, 0, input_0, std_2);`
`121`	`119`	`}`
`122`	`120`
`123`	`121`	`int main()`