AUSBC - Android USB Camera Engine

RapidJSON provides several specialized stream classes to optimize JSON parsing and generation:

• Memory Streams: Simple streams for handling data in memory.
• File Streams: Reduces memory footprint by reading/writing directly to the file system (FileReadStream for input, FileWriteStream for output).
• Encoded Streams: Handles conversion between byte streams and character streams (e.g., EncodedInputStream, EncodedOutputStream, AutoUTFInputStream, AutoUTFOutputStream).
• Custom Streams: Users can implement their own stream interfaces for specialized requirements.

RapidJSON provides two primary API styles depending on your performance and ease-of-use requirements:

1. DOM (Document Object Model): Uses rapidjson::GenericDocument. It parses JSON into a tree structure for easy manipulation and stringification. It is easier to use but has more memory overhead than SAX.
2. SAX (Simple API for XML): Uses rapidjson::GenericReader (event-based parser) and rapidjson::Writer (generator). This is a sequential access API that is faster and more memory-efficient than DOM.

To use the AUSBC library, add the JitPack repository to your project's root build.gradle or settings.gradle and then add the dependency to your app-level build.gradle.

// 1. Add to root build.gradle or settings.gradle
allprojects {
    repositories {
        google()
        jcenter()
        maven { url "https://jitpack.io" }
    }
}

// 2. Add to app/build.gradle
dependencies {
    implementation 'com.github.jiangdongguo.AndroidUSBCamera:libausbc:latest_tag'
}

JsonCpp uses Scons as its build system and requires Python to be installed. To build, follow these steps:

1. Download the scons-local distribution and unzip it in the directory containing the README.txt file (ensure scons.py is at the same level as the README).
2. Run the build command using the following syntax: python scons.py platform=PLTFRM [TARGET]

Available Platforms (PLTFRM):

• suncc: Sun C++ (Solaris)
• vacpp: Visual Age C++ (AIX)
• mingw
• msvc6: Microsoft Visual Studio 6 (SP5-6)
• msvc70: Microsoft Visual Studio 2002
• msvc71: Microsoft Visual Studio 2003
• msvc80: Microsoft Visual Studio 2005
• linux-gcc: Gnu C++ (Linux/Mac OS X)

Available Targets (TARGET):

• check: Builds the library and runs unit tests.

In RapidJSON, the Value::Accept() method is used to publish SAX events about a DOM value to a handler. This decouples the Value (the data) from the Writer (the handler).

This pattern allows you to create custom handlers to transform a DOM into other formats, such as converting JSON DOM into XML. To stringify a DOM using a Writer, you call Accept() on the DOM value.

// Stringifying a DOM with a Writer
Writer<StringBuffer> writer(buffer);
d.Accept(writer);

You can add custom visual effects by extending AbstractEffect. You must provide the vertex and fragment shader resource IDs.

class EffectBlackWhite(ctx: Context) : AbstractEffect(ctx) {
    override fun getId(): Int = ID
    override fun getClassifyId(): Int = CameraEffect.CLASSIFY_ID_FILTER
    override fun getVertexSourceId(): Int = R.raw.base_vertex
    override fun getFragmentSourceId(): Int = R.raw.effect_blackw_fragment

    companion object {
        const val ID = 100
    }
}

// Usage
addRenderEffect(effect)
removeRenderEffect(effect)
updateRenderEffect(classifyId, effect)

Navigate to the test directory to run various test suites manually.

Reader/Writer Tests: Run these using runjsontests.py and provide the path to the test executable: python runjsontests.py "path to jsontest.exe"

To use the JSONChecker test suite: python runjsontests.py --with-json-checker "path to jsontest.exe"

Unit Tests (Value tests): Run these using rununittests.py: python rununittests.py "path to test_lib_json.exe"

To run unit tests with Valgrind: python rununittests.py --valgrind "path to test_lib_json.exe"