Merge pull request #38 from octu0/v1.20.0

v1.20.0

Author: octu0

.dockerignore

@@ -1,3 +1,4 @@
+out
 *.out
 /Halide-Runtime*
 .git

Makefile

@@ -29,7 +29,7 @@ ifeq ($(shell [ -d detector/Halide-Runtime ] && echo "1"),1)
 else
 	curl -O -sSL https://github.com/halide/Halide/releases/download/v14.0.0/Halide-14.0.0-x86-64-linux-6b9ed2afd1d6d0badf04986602c943e287d44e46.tar.gz
 	tar xzf Halide-14.0.0-x86-64-linux-6b9ed2afd1d6d0badf04986602c943e287d44e46.tar.gz
-	mv Halide-14.0.0-x86-64-linux detector/Halide-Runtime
+	mv Halide-14.0.0-x86-64-linux ./Halide-Runtime
 	rm Halide-14.0.0-x86-64-linux-6b9ed2afd1d6d0badf04986602c943e287d44e46.tar.gz
 endif
 

README.md

@@ -19,57 +19,58 @@ darwin/amd64 Intel(R) Core(TM) i7-8569U CPU @ 2.80GHz
 
 ```
 src 320x240
-BenchmarkJIT/cloneimg                      : 0.00767ms
-BenchmarkJIT/convert_from_argb             : 0.02328ms
-BenchmarkJIT/convert_from_abgr             : 0.03573ms
-BenchmarkJIT/convert_from_bgra             : 0.02430ms
-BenchmarkJIT/convert_from_rabg             : 0.03159ms
-BenchmarkJIT/convert_from_yuv_420          : 0.02964ms
-BenchmarkJIT/convert_from_yuv_444          : 0.02652ms
-BenchmarkJIT/convert_to_yuv_420            : 0.05654ms
-BenchmarkJIT/convert_to_yuv_444            : 0.07356ms
-BenchmarkJIT/rotate0                       : 0.00828ms
-BenchmarkJIT/rotate90                      : 0.02600ms
-BenchmarkJIT/rotate180                     : 0.00792ms
-BenchmarkJIT/rotate270                     : 0.02560ms
-BenchmarkJIT/crop                          : 0.06128ms
-BenchmarkJIT/scale                         : 0.13941ms
-BenchmarkJIT/scale_box                     : 0.20701ms
-BenchmarkJIT/scale_linear                  : 0.20637ms
-BenchmarkJIT/scale_gaussian                : 0.31937ms
-BenchmarkJIT/blend_normal                  : 0.09480ms
-BenchmarkJIT/blend_sub                     : 0.08381ms
-BenchmarkJIT/blend_add                     : 0.08439ms
-BenchmarkJIT/blend_diff                    : 0.08445ms
-BenchmarkJIT/grayscale                     : 0.03752ms
-BenchmarkJIT/invert                        : 0.03684ms
-BenchmarkJIT/brightness                    : 0.04142ms
-BenchmarkJIT/gammacorrection               : 0.07600ms
-BenchmarkJIT/contrast                      : 0.01532ms
-BenchmarkJIT/boxblur                       : 0.10674ms
-BenchmarkJIT/gaussianblur                  : 0.31972ms
-BenchmarkJIT/blockmozaic                   : 0.27346ms
-BenchmarkJIT/erosion                       : 0.11407ms
-BenchmarkJIT/dilation                      : 0.11997ms
-BenchmarkJIT/morphology_open               : 0.14157ms
-BenchmarkJIT/morphology_close              : 0.10427ms
-BenchmarkJIT/morphology_gradient           : 0.07612ms
-BenchmarkJIT/emboss                        : 0.06083ms
-BenchmarkJIT/laplacian                     : 0.04251ms
-BenchmarkJIT/highpass                      : 0.03843ms
-BenchmarkJIT/gradient                      : 0.03320ms
-BenchmarkJIT/edgedetect                    : 0.02701ms
-BenchmarkJIT/sobel                         : 0.06392ms
-BenchmarkJIT/canny                         : 0.28839ms
-BenchmarkJIT/canny_dilate                  : 0.34880ms
-BenchmarkJIT/canny_morphology_open         : 0.38943ms
-BenchmarkJIT/canny_morphology_close        : 0.39011ms
-BenchmarkJIT/match_template_sad            : 5.69188ms
-BenchmarkJIT/match_template_ssd            : 4.75666ms
-BenchmarkJIT/match_template_ncc            : 8.98426ms
-BenchmarkJIT/prepared_match_template_ncc   : 6.23328ms
-BenchmarkJIT/match_template_zncc           : 12.64066ms
-BenchmarkJIT/prepared_match_template_zncc  : 11.67131ms
+BenchmarkJIT/cloneimg                      : 0.00788ms
+BenchmarkJIT/convert_from_argb             : 0.02375ms
+BenchmarkJIT/convert_from_abgr             : 0.03884ms
+BenchmarkJIT/convert_from_bgra             : 0.02470ms
+BenchmarkJIT/convert_from_rabg             : 0.03655ms
+BenchmarkJIT/convert_from_yuv_420          : 0.03168ms
+BenchmarkJIT/convert_from_yuv_444          : 0.02686ms
+BenchmarkJIT/convert_to_yuv_420            : 0.06742ms
+BenchmarkJIT/convert_to_yuv_444            : 0.07209ms
+BenchmarkJIT/rotate0                       : 0.00774ms
+BenchmarkJIT/rotate90                      : 0.02599ms
+BenchmarkJIT/rotate180                     : 0.00802ms
+BenchmarkJIT/rotate270                     : 0.02582ms
+BenchmarkJIT/crop                          : 0.06126ms
+BenchmarkJIT/scale                         : 0.14009ms
+BenchmarkJIT/scale_box                     : 0.20598ms
+BenchmarkJIT/scale_linear                  : 0.20440ms
+BenchmarkJIT/scale_gaussian                : 0.31444ms
+BenchmarkJIT/blend_normal                  : 0.08443ms
+BenchmarkJIT/blend_sub                     : 0.08398ms
+BenchmarkJIT/blend_add                     : 0.08364ms
+BenchmarkJIT/blend_diff                    : 0.08453ms
+BenchmarkJIT/grayscale                     : 0.03687ms
+BenchmarkJIT/invert                        : 0.03730ms
+BenchmarkJIT/brightness                    : 0.04703ms
+BenchmarkJIT/gammacorrection               : 0.08013ms
+BenchmarkJIT/contrast                      : 0.01549ms
+BenchmarkJIT/boxblur                       : 0.11211ms
+BenchmarkJIT/gaussianblur                  : 0.33058ms
+BenchmarkJIT/blockmozaic                   : 0.27455ms
+BenchmarkJIT/erosion                       : 0.11934ms
+BenchmarkJIT/dilation                      : 0.12013ms
+BenchmarkJIT/morphology_open               : 0.10370ms
+BenchmarkJIT/morphology_close              : 0.10435ms
+BenchmarkJIT/morphology_gradient           : 0.07684ms
+BenchmarkJIT/emboss                        : 0.04402ms
+BenchmarkJIT/laplacian                     : 0.03192ms
+BenchmarkJIT/highpass                      : 0.03847ms
+BenchmarkJIT/gradient                      : 0.03322ms
+BenchmarkJIT/edgedetect                    : 0.02705ms
+BenchmarkJIT/sobel                         : 0.06276ms
+BenchmarkJIT/canny                         : 0.29922ms
+BenchmarkJIT/canny_dilate                  : 0.35114ms
+BenchmarkJIT/canny_morphology_open         : 0.44488ms
+BenchmarkJIT/canny_morphology_close        : 0.40522ms
+BenchmarkJIT/match_template_sad            : 5.75482ms
+BenchmarkJIT/match_template_ssd            : 4.48363ms
+BenchmarkJIT/match_template_ncc            : 8.32420ms
+BenchmarkJIT/prepared_match_template_ncc   : 6.22423ms
+BenchmarkJIT/match_template_zncc           : 12.73780ms
+BenchmarkJIT/prepared_match_template_zncc  : 11.38906ms
+BenchmarkJIT/pcm16_decibel                 : 0.00257ms
 ```
 
 ## AOT benchmarks
@@ -620,6 +621,20 @@ ycbcr, err := blurry.ConvertToYUV444(rgba)
 | 420          | `blurry.ConvertToYUV420(*image.RGBA)` |
 | 444          | `blurry.ConvertToYUV444(*image.RGBA)` |
 
+#### PCM16 Decibel
+
+Gets the decibel of given PCM16.
+
+```go
+var data []byte
+decibel, err := blurry.PCM16Decibel(data, length)
+
+or
+
+var input []int16
+decibel, err := blurry.PCM16DecibelFromInt16(input)
+```
+
 ## CLI usage
 
 Run it via docker.  

blurry.cpp

@@ -22,6 +22,8 @@ const Expr degree0 = cast<uint8_t>(0);
 const Expr degree45 = cast<uint8_t>(45);
 const Expr degree90 = cast<uint8_t>(90);
 const Expr degree135 = cast<uint8_t>(135);
+const Expr pcm16_max = cast<float>(32768.0f); // 2^15
+const Expr ln10 = cast<float>(2.30258509299404568401799145468436420760110148862877297603332790f); // https://oeis.org/A002392
 
 const Func kernel_sobel_x = kernel_sobel3x3_x();
 const Func kernel_sobel_y = kernel_sobel3x3_y();
@@ -145,6 +147,34 @@ Func wrapFunc_xy(Buffer<double> buf, const char* name) {
   return f;
 }
 
+Func wrapFunc_x(Buffer<uint8_t> buf, const char* name) {
+  Var x("x");
+  Func f = Func(name);
+  f(x) = buf(x);
+  return f;
+}
+
+Func wrapFunc_x(Buffer<int16_t> buf, const char* name) {
+  Var x("x");
+  Func f = Func(name);
+  f(x) = buf(x);
+  return f;
+}
+
+Func wrapFunc_x(Buffer<float> buf, const char* name) {
+  Var x("x");
+  Func f = Func(name);
+  f(x) = buf(x);
+  return f;
+}
+
+Func wrapFunc_x(Buffer<double> buf, const char* name) {
+  Var x("x");
+  Func f = Func(name);
+  f(x) = buf(x);
+  return f;
+}
+
 Func read(Func clamped, const char *name) {
   Var x("x"), y("y"), ch("ch");
   Func read = Func(name);
@@ -2982,3 +3012,40 @@ Func contour_fn(
   f(x, y) = value;
   return f;
 }
+
+Expr log10(Expr v) {
+  return fast_log(v) / ln10;
+}
+
+Func pcm16_decibel_fn(
+  Func input, Param<int32_t> length
+) {
+  Var x("x");
+
+  Func normalize = Func("pcm16_normalize");
+  Expr in = cast<int16_t>(input(x));
+  normalize(x) = cast<float>(in) / pcm16_max; // -1.0 .. x .. 1.0
+
+  Func sq = Func("square");
+  sq(x) = fast_pow(normalize(x), 2);
+
+  RDom rd = RDom(0, length, "length");
+  Func rms = Func("root_mean_square");
+  Expr sum_values = sum(sq(rd));
+  Expr mean = sum_values / cast<float>(length);
+  rms(_) = sqrt(mean);
+
+  Func decibel = Func("pcm16_decibel");
+  decibel(_) = 20 * (log10(rms(_)));
+
+  // schedule
+  
+  normalize.compute_at(sq, x)
+    .store_root()
+    .vectorize(x, 64);
+  sq.compute_root()
+    .store_root()
+    .vectorize(x, 64);
+
+  return decibel;
+}

blurry.hpp

@@ -33,6 +33,14 @@ Func wrapFunc_xy(Buffer<float> buf, const char* name);
 
 Func wrapFunc_xy(Buffer<double> buf, const char* name);
 
+Func wrapFunc_x(Buffer<uint8_t> buf, const char* name);
+
+Func wrapFunc_x(Buffer<int16_t> buf, const char* name);
+
+Func wrapFunc_x(Buffer<float> buf, const char* name);
+
+Func wrapFunc_x(Buffer<double> buf, const char* name);
+
 Func cloneimg_fn(Func input, Param<int32_t> width, Param<int32_t> height);
 
 Func convert_from_abgr_fn(Func input, Param<int32_t> width, Param<int32_t> height);
@@ -225,4 +233,7 @@ Func contour_fn(
   Param<uint8_t> threshold, Param<uint8_t> size
 );
 
+Func pcm16_decibel_fn(
+  Func input, Param<int32_t> length
+);
 #endif // BLURRY_H_

blurry_benchmark.cpp

@@ -15,6 +15,16 @@ int jit_benchmark_bounds(Func fn, int32_t width, int32_t height, std::string nam
   return 0;
 }
 
+int jit_benchmark_pcm16_bounds(Func fn, int32_t length, std::string name) {
+  fn.compile_jit(get_jit_target_from_environment());
+
+  double result = benchmark(100, 10, [&]() {
+    fn.realize({length});
+  });
+  printf("BenchmarkJIT/%-30s: %-3.5fms\n", name.c_str(), result * 1e3);
+  return 0;
+}
+
 int jit_benchmark(Func fn, Buffer<uint8_t> buf_src, std::string name) {
   return jit_benchmark_bounds(fn, buf_src.get()->width(), buf_src.get()->height(), name);
 }
@@ -640,6 +650,27 @@ int benchmark_prepared_match_template_zncc(
   ), buf_src, "prepared_match_template_zncc");
 }
 
+int benchmark_pcm16_decibel(){
+  FILE *const f = fopen("./testdata/pcm16_1.data", "rb");
+  if(f == nullptr) {
+    return 1;
+  }
+  int32_t length = 1024;
+  int16_t *data = (int16_t *) calloc(length, sizeof(int16_t));
+  fread(data, sizeof(int16_t), length, f);
+  fclose(f);
+
+  Buffer<int16_t> buf_src = Buffer<int16_t>::make_interleaved(data, length, 0, 1);
+  buf_src.raw_buffer()->dimensions = 1;
+  buf_src.raw_buffer()->dim[0].extent = length;
+  buf_src.raw_buffer()->dim[0].stride = 1;
+  Param<int32_t> _length{"length", length};
+
+  return jit_benchmark_pcm16_bounds(pcm16_decibel_fn(
+    wrapFunc_x(buf_src, "buf_src"), _length
+  ), length, "pcm16_decibel");
+}
+
 int benchmark(char **argv) {
   printf("benchmark...\n");
   Buffer<uint8_t> buf_src = load_and_convert_image(argv[2]);
@@ -702,6 +733,7 @@ int benchmark(char **argv) {
   benchmark_prepared_match_template_ncc(buf_src, width, height, buf_tpl, tpl_width, tpl_height);
   benchmark_match_template_zncc(buf_src, width, height, buf_tpl, tpl_width, tpl_height);
   benchmark_prepared_match_template_zncc(buf_src, width, height, buf_tpl, tpl_width, tpl_height);
+  benchmark_pcm16_decibel();
   return 0;
 }
 

blurry_gen.cpp

@@ -134,6 +134,11 @@ void init_input_yuv_444(ImageParam in_y, ImageParam in_u, ImageParam in_v, Param
   in_v.dim(1).set_stride(width);
 }
 
+void init_input_array(ImageParam in, Param<int32_t> size) {
+  in.dim(0).set_stride(1);
+  in.dim(1).set_stride(size);
+}
+
 void init_input_array(ImageParam in, Param<int32_t> width, Param<int32_t> height) {
   in.dim(0).set_stride(1);
   in.dim(1).set_stride(width);
@@ -155,6 +160,11 @@ void init_output_yuv_444(OutputImageParam out, Param<int32_t> width, Param<int32
   out.dim(1).set_stride(width);
 }
 
+void init_output_array(OutputImageParam out, Param<int32_t> size) {
+  out.dim(0).set_stride(1);
+  out.dim(1).set_stride(size);
+}
+
 void init_output_array(OutputImageParam out, Param<int32_t> width, Param<int32_t> height) {
   out.dim(0).set_stride(1);
   out.dim(1).set_stride(width);
@@ -1665,6 +1675,22 @@ void generate_contour(std::vector<Target::Feature> features) {
 // }}} contour
 //
 
+//
+// {{{ pcm16_decibel
+//
+void generate_pcm16_decibel(std::vector<Target::Feature> features) {
+  ImageParam src(type_of<int16_t>(), 1, "src");
+
+  Param<int32_t> length{"length", 1024};
+
+  Func fn = pcm16_decibel_fn(src.in(), length);
+
+  generate_static_link(features, fn, { src, length }, "pcm16_decibel");
+}
+//
+// }}} pcm16_decibel
+//
+
 int generate(char **argv){
   printf("generate...\n");
 
@@ -1735,6 +1761,7 @@ int generate(char **argv){
   generate_prepare_zncc_template(features);
   generate_prepared_match_template_zncc(features);
   generate_contour(features);
+  generate_pcm16_decibel(features);
 
   return 0;
 }