add xaudio.hpp (#1)

testing, and xaudio.hpp

Author: wolfv

.travis.yml

@@ -1,5 +1,5 @@
 language: cpp
-dist: precise
+dist: trusty
 env:
 matrix:
   fast_finish: true
@@ -17,19 +17,8 @@ env:
     - MINCONDA_VERSION="latest"
     - MINCONDA_LINUX="Linux-x86_64"
     - MINCONDA_OSX="MacOSX-x86_64"
-before_install:
-    - |
-      # Configure build variables
-      if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then
-        if [[ "$COMPILER" == "gcc" ]]; then
-          export CXX=g++-$GCC CC=gcc-$GCC;
-        fi
-        if [[ "$COMPILER" == "clang" ]]; then
-          export CXX=clang++-$CLANG CC=clang-$CLANG;
-        fi
-      elif [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
-        export CXX=clang++ CC=clang;
-      fi
+# before_install:
+
 install:
     # Define the version of miniconda to download
     - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then
@@ -43,13 +32,19 @@ install:
     - hash -r
     - conda config --set always_yes yes --set changeps1 no
     - conda update -q conda
-    - conda install gtest cmake -c conda-forge
-    - conda install xtensor==0.13.0 -c conda-forge
-    - conda install zlib openimageio -c QuantStack -c conda-forge
+    - conda info -a
+    # Start test environement
+    - conda env create -f ./test/test-environment.yml
+    - source activate test-xtensorio
+    - export CC=$CONDA_PREFIX/bin/gcc
+    - export CXX=$CONDA_PREFIX/bin/g++
+    # from conda toolchain package
+    - export LDFLAGS="${LDFLAGS} -Wl,-rpath,$CONDA_PREFIX/lib"
+    - export LINKFLAGS="${LDFLAGS}"
     # Testing
     - mkdir build
     - cd build
-    - cmake -DBUILD_TESTS=ON -DDOWNLOAD_GTEST=ON ..;
+    - cmake -DBUILD_TESTS=ON -DDOWNLOAD_GTEST=ON -DCMAKE_PREFIX_PATH=$CONDA_PREFIX ..;
     - make -j2 test_xtensor_io
     - cd test
 script:

CMakeLists.txt

@@ -33,19 +33,13 @@ message(STATUS "Found xtensor: ${xtensor_INCLUDE_DIRS}/xtensor")
 
 # Find OpenImageIO
 set(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}" "${CMAKE_SOURCE_DIR}/modules")
-message("MODULE PATH: ${CMAKE_MODULE_PATH}")
-
-find_package(OIIO)
-message(STATUS "Found OpenImageIO: ${OIIO_INCLUDE_DIRS}")
-
-find_package(ZLIB)
-message(STATUS "Found zlib: ${zlib_INCLUDE_DIRS}")
 
 # Build
 # =====
 
 set(XTENSOR_IO_HEADERS
-    ${XTENSOR_IO_INCLUDE_DIR}/xtensor-io/ximageio.hpp
+    ${XTENSOR_IO_INCLUDE_DIR}/xtensor-io/ximage.hpp
+    ${XTENSOR_IO_INCLUDE_DIR}/xtensor-io/xaudio.hpp
     ${XTENSOR_IO_INCLUDE_DIR}/xtensor-io/xnpz.hpp
     ${XTENSOR_IO_INCLUDE_DIR}/xtensor-io/xtensor_io_config.hpp
 )

README.md

@@ -1,10 +1,19 @@
-# xtensor-io
+# ![xtensor-io](http://quantstack.net/assets/images/xtensor-io.svg)
 
-This library delivers a couple of function to efficiently in- and output
-images and NumPy compressed arrays (npz) to xtensor data structures.
-In order to read and write images, the ![OpenImageIO](https://github.com/OpenImageIO/oiio)
-library is utilized. We only provide a few simple functions, but upon demand
-can improve this interface.
+[![Travis](https://travis-ci.org/QuantStack/xtensor-io.svg?branch=master)](https://travis-ci.org/QuantStack/xtensor-io)
+[![Join the Gitter Chat](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/QuantStack/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+
+xtensor-io offers a couple of functions to read and write images, audio files, and
+NumPy's compressed storage format (NPZ) from C++ into xtensor data structures.
+It makes use of well known libraries for image and audio handling (OpenImageIO and libsndfile).
+Currently, only a few basic functions are provided, but upon demand we can consider to
+improve the interface and offer more options to customize and improve the input-output
+performance.
+
+We haven't started building and testing on Windows, yet! Contributions welcome!
+
+### Example
 
 ```cpp
 // loads png image into xarray with shape WIDTH x HEIGHT x CHANNELS
@@ -18,14 +27,70 @@ auto npy_map = xt::load_npz("test.npz");
 
 auto arr_0 = npy_map["arr_0"].cast<double>();
 auto arr_1 = npy_map["arr_1"].cast<unsigned long>();
+
+// open a wav file
+auto audio = xt::load_wav("files/xtensor.wav");
+auto& arr = std::get<1>(audio); // audio contents (like scipy.io.wavfile results)
+
+// save a sine wave sound
+int freq = 2000;
+int sampling_freq = 44100;
+double duration = 1.0;
+
+auto t = xt::arange(0.0, duration, 1.0 / sampling_freq);
+auto y = xt::sin(2.0 * numeric_constants<double>::PI * freq * t);
+
+xt::dump_wav("files/sine.wav", y, SF_FORMAT_WAV | SF_FORMAT_PCM_16, sampling_freq);
+```
+
+### Installation
+
+xtensor-io depends on thirdparty libraries for audio and image handling.
+
+The easiest installation (including all dependencies) is through conda:
+
+```bash
+conda install xtensor-io
+```
+
+To use xaudio linking with [`libsndfile`](http://www.mega-nerd.com/libsndfile/).
+Libsndfile can be installed as follows:
+
+```bash
+# Conda
+conda install libsndfile -c conda-forge
+# Ubuntu / Debian
+sudo apt-get install libsndfile-dev
+# Fedora
+sudo dnf install libsndfile-devel
 ```
 
-## Installation
+For image handling, [`OpenImageIO`](http://openimageio.org/) is required.
+We have a build of OpenImageIO on the conda QuantStack channel, but it can also
+be optained from your favorite package manager on Linux. Note the conda build
+is only tested with the `gcc-6` package from the QuantStack channel.
+
+```bash
+# Conda
+(maybe: ) conda install gcc-6 -c QuantStack
+conda install openimageio -c QuantStack
+# Ubuntu / Debian
+sudo apt-get install libopenimageio-dev
+# Fedora
+sudo dnf install OpenImageIO-devel
+```
 
-In order to install this library on linux systems, please find a copy
-of `libopenimageio` (on fedora: `dnf install OpenImageIO-devel`,
-ubuntu: `apt-get install libopenimageio-dev`). This should enable you 
-to build the library like a regular cmake package:
+In order to decompress and read NPZ files, zlib is needed. It should be installed
+on linux, but you can also obtain it:
+
+```bash
+# Conda
+conda install zlib -c conda-forge
+# Ubuntu / Debian
+sudo apt-get install zlib1g-dev
+# Fedora
+sudo dnf install zlib-devel
+```
 
 From this directory:
 

include/xtensor-io/xaudio.hpp

@@ -0,0 +1,44 @@
+#include <stdexcept>
+#include <string>
+
+#include <sndfile.hh>
+
+#include "xtensor/xarray.hpp"
+#include "xtensor/xeval.hpp"
+
+namespace xt
+{
+    /**
+     * Read a WAV file
+     *
+     * @param filename Open file with file name
+     *
+     * @return tuple with (samplerate, xarray holding the data)
+     *
+     * @tparam T select type
+     */
+    template <class T = short>
+    auto load_wav(std::string filename)
+    {
+        SndfileHandle file(filename);
+        auto result = xarray<T>::from_shape({(std::size_t) file.frames(), (std::size_t) file.channels()});
+        file.read(result.raw_data(), (sf_count_t) result.size());
+        return std::make_tuple(file.samplerate(), std::move(result));
+    }
+
+    /**
+     * Save an xarray in WAV sound file format
+     *
+     * @param filename save under filename
+     * @param e xarray/xexpression
+     * @param format select format (see sndfile documentation). Combine flags such as SF_FORMAT_WAV | SF_FORMAT_PCM_16
+     * @param samplerate The samplerate
+     */
+    template <class E>
+    void dump_wav(std::string filename, const xexpression<E>& e, int format, int samplerate)
+    {
+        auto&& de = xt::eval(e.derived_cast());
+        SndfileHandle file(filename, SFM_WRITE, format, (int) de.shape()[1], samplerate);
+        file.write(de.raw_data(), (sf_count_t) de.size());
+    }
+}

include/xtensor-io/ximageio.hpp include/xtensor-io/ximage.hppinclude/xtensor-io/ximageio.hpp renamed to include/xtensor-io/ximage.hpp

@@ -6,21 +6,19 @@
 #include "xtensor/xarray.hpp"
 #include "xtensor/xeval.hpp"
 
-using namespace OIIO;
-
 namespace xt
 {
     // Handle types better ...
     template <class T = unsigned char>
     xarray<T> load_image(std::string filename)
     {
-        ImageInput *in = ImageInput::open(filename);
+        OIIO::ImageInput *in = OIIO::ImageInput::open(filename);
         if (!in)
         {
             // something went wrong
             throw std::runtime_error("Couldn't read image");
         }
-        const ImageSpec &spec = in->spec();
+        const OIIO::ImageSpec &spec = in->spec();
         int xres = spec.width;
         int yres = spec.height;
         int channels = spec.nchannels;
@@ -30,9 +28,9 @@ namespace xt
                                             static_cast<std::size_t>(spec.height),
                                             static_cast<std::size_t>(spec.nchannels)});
 
-        in->read_image(TypeDesc::UINT8, image.raw_data());
+        in->read_image(OIIO::TypeDesc::UINT8, image.raw_data());
         in->close();
-        ImageInput::destroy(in);
+        OIIO::ImageInput::destroy(in);
 
         return image;
     }
@@ -42,19 +40,19 @@ namespace xt
     {
         auto&& ex = eval(e.derived_cast());
 
-        ImageOutput *out = ImageOutput::create(filename);
+        OIIO::ImageOutput *out = OIIO::ImageOutput::create(filename);
         if (!out)
         {
             // something went wrong
             throw std::runtime_error("Couldn't open file to write image.");
         }
-        ImageSpec spec((int) ex.shape()[0], (int) ex.shape()[1], (int) ex.shape()[2], TypeDesc::UINT8);
+        OIIO::ImageSpec spec((int) ex.shape()[0], (int) ex.shape()[1], (int) ex.shape()[2], OIIO::TypeDesc::UINT8);
 
         spec.attribute("CompressionQuality", quality);
 
         out->open(filename, spec);
-        out->write_image(TypeDesc::UINT8, ex.raw_data());
+        out->write_image(OIIO::TypeDesc::UINT8, ex.raw_data());
         out->close();
-        ImageOutput::destroy(out);
+        OIIO::ImageOutput::destroy(out);
     }
 }

include/xtensor-io/xtensor_io_config.hpp

@@ -10,7 +10,7 @@
 #define XTENSOR_IO_CONFIG_HPP
 
 #define XTENSOR_IO_VERSION_MAJOR 0
-#define XTENSOR_IO_VERSION_MINOR 1
+#define XTENSOR_IO_VERSION_MINOR 2
 #define XTENSOR_IO_VERSION_PATCH 0
 
 #endif

modules/FindSndFile.cmake

@@ -0,0 +1,37 @@
+# Copyright: Apache License, Audaspace Project
+# Source: https://github.com/neXyon/audaspace/blob/d27746ca8550e2adae6ba54ded0c6dfac58d69b8/cmake/FindLibSndFile.cmake
+
+# Try to find libsndfile
+# Once done, this will define
+#
+#  LIBSNDFILE_FOUND - system has libsndfile
+#  LIBSNDFILE_INCLUDE_DIRS - the libsndfile include directories
+#  LIBSNDFILE_LIBRARIES - link these to use libsndfile
+
+# Use pkg-config to get hints about paths
+find_package(PkgConfig QUIET)
+if(PKG_CONFIG_FOUND)
+	pkg_check_modules(LIBSNDFILE_PKGCONF sndfile)
+endif(PKG_CONFIG_FOUND)
+
+# Include dir
+find_path(LIBSNDFILE_INCLUDE_DIR
+	NAMES sndfile.h
+	PATHS ${LIBSNDFILE_PKGCONF_INCLUDE_DIRS}
+)
+
+# Library
+find_library(LIBSNDFILE_LIBRARY
+	NAMES sndfile libsndfile-1
+	PATHS ${LIBSNDFILE_PKGCONF_LIBRARY_DIRS}
+)
+
+find_package(PackageHandleStandardArgs)
+find_package_handle_standard_args(LibSndFile  DEFAULT_MSG  LIBSNDFILE_LIBRARY LIBSNDFILE_INCLUDE_DIR)
+
+if(LIBSNDFILE_FOUND)
+  set(LIBSNDFILE_LIBRARIES ${LIBSNDFILE_LIBRARY})
+  set(LIBSNDFILE_INCLUDE_DIRS ${LIBSNDFILE_INCLUDE_DIR})
+endif(LIBSNDFILE_FOUND)
+
+mark_as_advanced(LIBSNDFILE_LIBRARY LIBSNDFILE_LIBRARIES LIBSNDFILE_INCLUDE_DIR LIBSNDFILE_INCLUDE_DIRS)