cmusatyalab/diamond-android

Android library for running Diamond filters

diamond-android's Issues

Correctly release the camera when suspending or exiting the example applications.

JSON Blaster Notes and Filter Execution on Android

• JSON Blaster Wiki
• Read/Execute JSON Blaster filters on Android
• Filter protocol page on Wiki

Separate code into diamond library and example application.

Bump libpng to remove security vulnerability

Update OpenCV/fix haar detect objects call in ocv filter.

cbd5b9f#diff-27ca66bc2580301ed5c2446fc10585e3R71

Small Project Idea: ARM package manager

Hi @bgilbert @theonewolf and @wenluhu - just brainstorming here.
I've been compiling a lot of utility libraries for ARM in addition
to the ones in here, such as tune2fs, mknod, and gammaray.
Mostly, I can build them fine with the snippet below,
but other times a small diff of the original source is required,
or I need to link other static ARM libraries.
I've been thinking that a simple ARM package manager to
build executables and static libraries from the original source
would be helpful to run non-standard C programs on Android.
The benefit of centralizing this is that people wouldn't have to
manually build or chain together dependencies as I've done in https://github.com/cmusatyalab/diamond-android/blob/master/diamond-android-library/jni/build.sh.

Is this a sane idea?
Do you all have any thoughts on this?

if [[ ! -d toolchain ]]; then
  # Using NDK r10b.
  $ANDROID_NDK/build/tools/make-standalone-toolchain.sh \
    --platform=android-18 \
    --toolchain=arm-linux-androideabi-4.8 \
    --install-dir=$PWD/toolchain
fi

# Add the standalone toolchain to the path.
pathadd() { PATH="${PATH:+"$PATH:"}$1"; }
pathadd "$PWD/toolchain/bin"
command -v arm-linux-androideabi-gcc &> /dev/null || exit -1
export SYSROOT=$PWD/toolchain/sysroot
export CC="arm-linux-androideabi-gcc --sysroot=$SYSROOT"
export CXX=arm-linux-androideabi-g++
export LD=arm-linux-androideabi-ld
export RANLIB=arm-linux-androideabi-ranlib
export AR=arm-linux-androideabi-ar
export CROSS_PREFIX=arm-linux-androideabi-
export CFLAGS='-march=armv7-a -mfloat-abi=softfp -mfpu=neon'
export LDFLAGS='-Wl,--fix-cortex-a8'

./configure --enable-static --host=arm-linux || die "Configure failed."
make -j8 bin/gray-crawler || die "Make failed."

Add public domain dedication to new getline code

Text here. This needs to be added for the same reason as #17.

Compile/execute the simplest filter for ARM

Simplest: Minimum external library dependencies.

Fix `sigfillset` error when building/launching from Linux.

130|root@hltevzw:/data/data/edu.cmu.cs.diamond.android.examples.facialrecognition/files # ./rgbimg
CANNOT LINK EXECUTABLE: cannot locate symbol "sigfillset" referenced by "./rgbimg"...

Create simple Android application to execute filter as subprocess

Implement diamondd part of filter protocol

Write detailed javadoc once development stabilizes.

Improve Android application to not convert from NV21->JPG->RGB

Instead, try removing the RGB filter and restructuring InputFormat.RGB565
into the RGB format the filters are expecting.

GPLv2 code linked with GPL-incompatible code

Diamond Core Filters is EPL-licensed, but getline.c is GPLv2. The resulting binaries are non-distributable.

Filters other than ocv hanging.

Debugging is difficult because the filter doesn't return control and
hangs at in indeterminate location.

Update libraries to the newest versions

• http://www.remotesensing.org/libtiff/
• http://libjpeg-turbo.virtualgl.org/

Replace in-situ library modifications

Options:

• git submodules + diff's
• shell script to clone/download repos + diff's

I'm currently leaning towards the 2nd since not every
dependency might not be versioned with git.

Modify Android application to display video in real time.

Hi @bgilbert - can we discuss what the application should do before I make further modifications?

Rename null filter to null_filter to avoid Java name collision

Use TravisCI, publish library javadoc to GH pages.

http://benlimmer.com/2013/12/26/automatically-publish-javadoc-to-gh-pages-with-travis-ci/

JNI dependency handling appears incorrect

build.sh should be doing a depth-first traversal of the dependency tree, but instead it seems to build the JNI libraries in a random order. Libraries are built before their dependencies are even unpacked; how does this even work? Are you sure you're not building with headers from the host?

Pass code as byte[] to Filter rather than an Enum pointing to the resource ID.

OpenCV/C++ perceptual hashing filter.

Since OpenCV is integrated into the diamond-android build,
a perceptual hash OpenCV implementation can easily
be created by using ls64/cvhash as
a reference for OpenCV API calls.

This might also be useful upstream?

Add license blocks to memstream code

The memstream library website says the library is under the MIT license, but this is not apparent in the code itself. Add a header block

• indicating that the upstream website states that the code is under the MIT license,
• linking to the site, and
• quoting the text of the MIT license.

Compile filters as a shared library if using stdio doesn't work.

Upgrade to Android studio/gradle

Choose license, add to all files.

Hi @bgilbert - should this repository be licensed under the EPL like diamond-core-filters?

Create a class to interface (via stdio) with the filter executables.

Implement Android app to run facial recognition filter pipeline on an image.

Complete README

Abstract `Filter` API.

Map[Str,Byte[]]: Double or Map[Str,Byte[]]: Boolean

Add examples of other filters.

Add option to duplicate stdin to a file for debugging

Create experiment to compare Diamond's OpenCV face detector to using Android's OpenCV Java library.

One response to using the Diamond OpenCV face detector could be
that the OpenCV Android library is simpler to use than diamond filters.
I think their Android library is using JNI on the backend, but I wonder
how the performance compares to using diamond filters.

Run perceptual_hash filter on Android

This filter is written in Python.

Show benchmarks of every filter

Depends on #32

Compile/run all executables for ARM

If #1 and #2 work

Implement `createTempDirectory`

From 5b6b978#commitcomment-7951862:

That's mostly harmless in this case, since the cache dir is per-application, but racy in general. Sadly, Android doesn't yet seem to have added createTempDirectory from JDK 7. If it were me, I'd probably implement createTempDirectory myself by looping over random suffixes and trying mkdir, rather than leaving a race lurking in the code, but I could see it either way.