Merge pull request #348 from fixstars/fix/binary-loader-1.8x

Fix/binary loader 1.8x

Author: Fixstars-momoko

python/setup.py

@@ -11,7 +11,7 @@
 
 
 def get_plat():
-    if platform.system() == 'Linux':
+    if platform.system() == 'Linux' and platform.machine() == 'x86_64':
         plat_form = "manylinux1_x86_64"
     else:
         plat_form = sysconfig.get_platform()

src/bb/image-io/bb.h

@@ -1124,7 +1124,7 @@ class BinarySaver : public ion::BuildingBlock<BinarySaver<T, D>> {
     BuildingBlockParam<std::string> output_directory_ptr{ "output_directory", "." };
     BuildingBlockParam<std::string> prefix_ptr{"prefix", "raw-"};
 
-    Input<Halide::Func> input_images{"input", Halide::type_of<T>(), D};
+    Input<Halide::Func> input_image{"input", Halide::type_of<T>(), D};
     Input<Halide::Func> input_deviceinfo{ "input_deviceinfo", Halide::type_of<uint8_t>(), 1 };
     Input<Halide::Func> frame_count{ "frame_count", Halide::type_of<uint32_t>(), 1 };
     Input<int32_t> width{ "width" };
@@ -1155,7 +1155,7 @@ class BinarySaver : public ion::BuildingBlock<BinarySaver<T, D>> {
         Buffer<uint8_t> id_buf = this->get_id();
 
         Func image;
-        image(_) = input_images(_);
+        image(_) = input_image(_);
         image.compute_root();
 
         Func deviceinfo;
@@ -1223,47 +1223,68 @@ class BinaryGenDCSaver : public ion::BuildingBlock<BinaryGenDCSaver> {
     }
 };
 
-class BinaryLoader : public ion::BuildingBlock<BinaryLoader> {
+template<typename T>
+class BinaryLoader : public ion::BuildingBlock<BinaryLoader<T>> {
 public:
-    BuildingBlockParam<std::string> output_directory_ptr{ "output_directory_ptr", "" };
-    Input<int32_t> width{ "width", 0 };
-    Input<int32_t> height{ "height", 0 };
-    Output<Halide::Func> output0{ "output0", UInt(16), 2 };
-    Output<Halide::Func> output1{ "output1", UInt(16), 2 };
-    Output<Halide::Func> finished{ "finished", UInt(1), 1};
-    Output<Halide::Func> bin_idx{ "bin_idx", UInt(32), 1 };
+    BuildingBlockParam<std::string> output_directory_ptr{"output_directory", ""};
+    BuildingBlockParam<std::string> prefix_ptr{"prefix", "raw-"};
+    Input<int32_t>width{"width"};
+    Input<int32_t> height{"height"};
+    Output<Halide::Func> output{"output", type_of<T>(), 2};
+    Output<Halide::Func> finished{"finished", Halide::UInt(1), 1};
+    Output<Halide::Func> bin_idx{"bin_idx", Halide::UInt(32), 1};
+    Output<Halide::Func> frame_count{"frame_count", Halide::UInt(32), 1};
 
     void generate() {
         using namespace Halide;
+        Func binaryloader;
 
-        std::string session_id = sole::uuid4().str();
-        Buffer<uint8_t> session_id_buf(static_cast<int>(session_id.size() + 1));
-        session_id_buf.fill(0);
-        std::memcpy(session_id_buf.data(), session_id.c_str(), session_id.size());
+        {
+            Buffer<uint8_t> id_buf = this->get_id();
+            const std::string output_directory(output_directory_ptr);
+            Halide::Buffer<uint8_t> output_directory_buf(static_cast<int>(output_directory.size() + 1));
+            output_directory_buf.fill(0);
+            std::memcpy(output_directory_buf.data(), output_directory.c_str(), output_directory.size());
 
-        const std::string output_directory(output_directory_ptr);
-        Halide::Buffer<uint8_t> output_directory_buf(static_cast<int>(output_directory.size() + 1));
-        output_directory_buf.fill(0);
-        std::memcpy(output_directory_buf.data(), output_directory.c_str(), output_directory.size());
+            const std::string prefix(prefix_ptr);
+            Halide::Buffer<uint8_t> prefix_buf(static_cast<int>(prefix.size() + 1));
+            prefix_buf.fill(0);
+            std::memcpy(prefix_buf.data(), prefix.c_str(), prefix.size());
 
-        std::vector<ExternFuncArgument> params = { session_id_buf, width, height, output_directory_buf };
-        Func binaryloader;
-        binaryloader.define_extern("binaryloader", params, { UInt(16), UInt(16) }, 2);
-        binaryloader.compute_root();
-        output0(_) = binaryloader(_)[0];
-        output1(_) = binaryloader(_)[1];
+            std::vector<ExternFuncArgument> params = {id_buf, width, height, output_directory_buf ,prefix_buf};
 
+            binaryloader.define_extern("binaryloader", params, type_of<T>(), 2);
+            binaryloader.compute_root();
+            output(_) = binaryloader(_);
+        }
 
         Func binaryloader_finished;
-        binaryloader_finished.define_extern("binaryloader_finished",
-            { binaryloader, session_id_buf, width, height, output_directory_buf },
-            { type_of<bool>(), UInt(32)}, 1);
-        binaryloader_finished.compute_root();
-        finished(_) = binaryloader_finished(_)[0];
-        bin_idx(_) = binaryloader_finished(_)[1];
+        {
+            Buffer<uint8_t> id_buf = this->get_id();
+            const std::string prefix(prefix_ptr);
+            Halide::Buffer<uint8_t> prefix_buf(static_cast<int>(prefix.size() + 1));
+            prefix_buf.fill(0);
+            std::memcpy(prefix_buf.data(), prefix.c_str(), prefix.size());
+
+            const std::string output_directory(output_directory_ptr);
+            Halide::Buffer<uint8_t> output_directory_buf(static_cast<int>(output_directory.size() + 1));
+            output_directory_buf.fill(0);
+            std::memcpy(output_directory_buf.data(), output_directory.c_str(), output_directory.size());
+            binaryloader_finished.define_extern("binaryloader_finished",
+                                                  {binaryloader, id_buf, width, height, output_directory_buf, prefix_buf},
+                                                  {UInt(1), UInt(32),UInt(32)}, 1);
+            binaryloader_finished.compute_root();
+            finished(_) = binaryloader_finished(_)[0];
+            bin_idx(_) = binaryloader_finished(_)[1];
+            frame_count(_) = binaryloader_finished(_)[2];
+        }
+        this->register_disposer("reader_dispose");
     }
 };
 
+using BinaryLoader_U8x2 = BinaryLoader<uint8_t>;
+using BinaryLoader_U16x2 = BinaryLoader<uint16_t>;
+
 }  // namespace image_io
 }  // namespace bb
 }  // namespace ion
@@ -1306,7 +1327,9 @@ ION_REGISTER_BUILDING_BLOCK(ion::bb::image_io::BinarySaver_U8x3, image_io_binary
 ION_REGISTER_BUILDING_BLOCK(ion::bb::image_io::BinarySaver_U8x2, image_io_binarysaver_u8x2);
 ION_REGISTER_BUILDING_BLOCK(ion::bb::image_io::BinarySaver_U16x2, image_io_binarysaver_u16x2);
 
-ION_REGISTER_BUILDING_BLOCK(ion::bb::image_io::BinaryLoader, image_io_binaryloader);
+ION_REGISTER_BUILDING_BLOCK(ion::bb::image_io::BinaryLoader_U16x2, image_io_binaryloader);
+ION_REGISTER_BUILDING_BLOCK(ion::bb::image_io::BinaryLoader_U8x2, image_io_binaryloader_u8x2);
+ION_REGISTER_BUILDING_BLOCK(ion::bb::image_io::BinaryLoader_U16x2, image_io_binaryloader_u16x2);
 
 ION_REGISTER_BUILDING_BLOCK(ion::bb::image_io::BinaryGenDCSaver, image_io_binary_gendc_saver);