// Copyright (c) 2012-2017 VideoStitch SAS
// Copyright (c) 2018 stitchEm
#include <cassert>
#include <sstream>
#include <iostream>
#include <stdio.h>
#include <android/log.h>
#include <unistd.h>
#include <stdlib.h> /* getenv() */
#include <libgen.h> /* dirname() */
#include "NvGLUtils/NvGLSLProgram.h"
#include "NvAssetLoader/NvAssetLoader.h"
#include <libgpudiscovery/backendLibHelper.hpp>
#include <libvideostitch/algorithm.hpp>
#include <libvideostitch/audioPipeDef.hpp>
#include <libvideostitch/controller.hpp>
#include <libvideostitch/context.hpp>
#include <libvideostitch/imageMergerFactory.hpp>
#include <libvideostitch/imageWarperFactory.hpp>
#include <libvideostitch/imageFlowFactory.hpp>
#include <libvideostitch/inputFactory.hpp>
#include <libvideostitch/logging.hpp>
#include <libvideostitch/output.hpp>
#include <libvideostitch/panoDef.hpp>
#include <libvideostitch/parse.hpp>
#include <libvideostitch/profile.hpp>
#include <libvideostitch/ptv.hpp>
#include <libvideostitch/stitchOutput.hpp>
#include <libvideostitch/frame.hpp>
#define APPNAME "OrahDemo"
static std::string ANDROIDTag(APPNAME);
#include "NativeApp.h"
extern void NvInitSharedFoundation(void);
extern void NvReleaseSharedFoundation(void);
static bool stop = false;
typedef struct {
double x;
double y;
double z;
} vector3d;
static std::string ASSETSDIR = "/data/user/videostitch/assets/";
void launchStitcher(void* outBuffer, std::mutex& outMutex, const char* fileName);
static double SphereRadius = 0.0;
double degToRad(double v) { return M_PI * (v / 180.0); }
double radToDeg(double v) { return v * (180.0 / M_PI); }
void equirectangular2sphere(vector2d uv, vector3d& vec, double sphereRadius) {
uv.x /= sphereRadius;
uv.y /= sphereRadius;
double phi = uv.x;
double theta = -uv.y + M_PI / 2.0;
// Pass above the north pole
if (theta < 0.0) {
theta = -theta;
phi += M_PI;
}
// Pass above the south pole
if (theta > M_PI) {
theta = 2.0 * M_PI - theta;
phi += M_PI;
}
double sinTheta = sin(theta);
vector2d v;
v.x = sinTheta * sin(phi);
v.y = cos(theta);
double r = sqrt(v.x * v.x + v.y * v.y);
if (r != 0.0f) {
// Normal case, atan2f is defined in this domain.
uv.x = (atan2(r, sinTheta * cos(phi)) / r) * v.x;
uv.y = (atan2(r, sinTheta * cos(phi)) / r) * v.y;
} else {
// atan2f is not defined around (0,0) and (pi + k pi, pi/2).
// The result is taken to be 0 at (0,0) and defined by continuity modulo (2 pi) along the phi axis to be (pi at (pi
// + k pi, pi/2).
if (std::abs(phi) < 0.001f) { // <==> sin(theta) * cos(phi) >= 0
uv.x = 0.0;
uv.y = 0.0;
} else {
uv.x = M_PI;
uv.y = 0.0;
}
}
theta = sqrt(uv.x * uv.x + uv.y * uv.y);
vec.x = (uv.x * sin(theta) / theta);
vec.y = (uv.y * sin(theta) / theta);
vec.z = (cos(theta));
}
void quaternion2euler(double q0, double q1, double q2, double q3, double& yaw, double& pitch, double& roll) {
yaw = atan2(2.0 * (q1 * q3 - q0 * q2), q3 * q3 - q2 * q2 - q1 * q1 + q0 * q0);
pitch = -asin(2.0 * (q2 * q3 + q0 * q1));
roll = atan2(2.0 * (q1 * q2 - q0 * q3), q2 * q2 - q3 * q3 + q0 * q0 - q1 * q1);
}
void sphere2orientation(const vector3d& v1, const vector3d& v2, double& yaw, double& pitch, double& roll) {
double dotProduct = (v1.x * v2.x) + (v1.y * v2.y) + (v1.z * v2.z);
if (dotProduct > 1.0) {
dotProduct = 1.0;
}
double theta_2 = acos(dotProduct) / 2.0;
vector3d nu;
nu.x = (v1.y * v2.z) - (v1.z * v2.y);
nu.y = (v1.z * v2.x) - (v1.x * v2.z);
nu.z = (v1.x * v2.y) - (v1.y * v2.x);
double sintheta_2 = sin(theta_2);
double q0 = cos(theta_2);
double q1 = sintheta_2 * nu.x;
double q2 = sintheta_2 * nu.y;
double q3 = sintheta_2 * nu.z;
quaternion2euler(q0, q1, q2, q3, yaw, pitch, roll);
}
void NVPlatformLog(const char* fmt, ...) {
va_list ap;
va_start(ap, fmt);
__android_log_vprint(ANDROID_LOG_INFO, APPNAME, fmt, ap);
va_end(ap);
}
// redirect stdout & stderr to android logcat
static int pfd[2];
static pthread_t thr;
static void* thread_func(void*) {
ssize_t rdsz;
char buf[128];
while ((rdsz = read(pfd[0], buf, sizeof buf - 1)) > 0) {
if (buf[rdsz - 1] == '\n') --rdsz;
buf[rdsz] = 0; /* add null-terminator */
__android_log_write(ANDROID_LOG_DEBUG, APPNAME, buf);
}
return 0;
}
static int start_logger() {
/* make stdout line-buffered and stderr unbuffered */
setvbuf(stdout, 0, _IOLBF, 0);
setvbuf(stderr, 0, _IONBF, 0);
/* create the pipe and redirect stdout and stderr */
pipe(pfd);
dup2(pfd[1], 1);
dup2(pfd[1], 2);
/* spawn the logging thread */
if (pthread_create(&thr, 0, thread_func, 0) == -1) return -1;
pthread_detach(thr);
return 0;
}
NativeApp::NativeApp(android_app* app, NvEGLUtil* egl)
: mTextureWidth(1920),
mTextureHeight(960),
mEgl(egl),
mNativeAppInstance(app),
mStitcherBuffer(NULL),
mStitcherThread(NULL),
mOrientationFlag(false),
mColorChannels{1.0, 1.0, 1.0} {
app->userData = this;
app->onAppCmd = HandleCommand;
app->onInputEvent = HandleInput;
mCurrentApplicationState = INITIALIZATION;
mScreenPressed = false;
mYaw = 0.0f;
mPitch = 0.0f;
mRoll = 0.0f;
mAlphaStep = -0.05f;
mPos.x = 0.0f;
mPos.y = 0.0f;
}
NativeApp::~NativeApp() {
mStitcherThread->join();
delete[] mStitcherBuffer;
}
/**
* Called every frame
*/
void NativeApp::renderFrame(void) {
if (!mEgl->isReadyToRender(true)) {
return;
}
if (mEgl->checkWindowResized()) {
glViewport(0, 0, mEgl->getWidth(), mEgl->getHeight());
}
switch (mCurrentApplicationState) {
case INITIALIZATION: {
// vertex shader
const char* vertexShaderSource =
"attribute vec2 aPosition;\n"
"attribute vec2 aTexCoord;\n"
"varying vec2 vTexCoord;\n"
"void main(void)\n"
"{\n"
" vTexCoord = aTexCoord;\n"
" gl_Position = vec4(aPosition.x, aPosition.y, 0.0, 1.0);\n"
"}\n";
// fragment shader
const char* fragmentShaderSource =
"precision mediump float;\n"
"uniform sampler2D uSourceTex;\n"
"varying vec2 vTexCoord;\n"
"void main(void)\n"
"{\n"
" gl_FragColor = texture2D(uSourceTex, vTexCoord);\n"
"}\n";
// mPlainTextureProgram = NvGLSLProgram::createFromFiles("plain.vert", "plain.frag",
// true)->getProgram();
mPlainTextureProgram =
NvGLSLProgram::createFromStrings(vertexShaderSource, fragmentShaderSource, true)->getProgram();
// output from Stitcher is stored in mStitcherBuffer
mStitcherBuffer = new unsigned int[mTextureWidth * mTextureHeight];
// generate output texture
glGenTextures(1, &mOutputImageTexture);
glBindTexture(GL_TEXTURE_2D, mOutputImageTexture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, mTextureWidth, mTextureHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
mAlphaStep = -0.05f;
mColorChannels[0] = 1.0;
mColorChannels[1] = mColorChannels[0];
mColorChannels[2] = mColorChannels[0];
glClearColor(mColorChannels[0], mColorChannels[1], mColorChannels[2], 1.0);
glClear(GL_COLOR_BUFFER_BIT);
glFinish();
// mCurrentApplicationState = MAIN_LOOP;
mCurrentApplicationState = SELECTION;
break;
}
case SELECTION: {
mColorChannels[0] += mAlphaStep;
mColorChannels[1] += mAlphaStep;
mColorChannels[2] += mAlphaStep;
if ((mColorChannels[0] < 0.0) || (mColorChannels[0] > 1.0)) {
mAlphaStep = -mAlphaStep;
mColorChannels[0] += mAlphaStep;
mColorChannels[1] += mAlphaStep;
mColorChannels[2] += mAlphaStep;
}
glClearColor(mColorChannels[0], mColorChannels[1], mColorChannels[2], 1.0);
glClear(GL_COLOR_BUFFER_BIT);
glFinish();
} break;
case MAIN_LOOP: {
// bind output texture
glBindTexture(GL_TEXTURE_2D, mOutputImageTexture);
mStitcherMutex.lock();
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, mTextureWidth, mTextureHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE,
(unsigned char*)mStitcherBuffer);
mStitcherMutex.unlock();
float const vertexPosition[] = {1.0f, -1.0f, -1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f};
float const textureCoord[] = {1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f};
// Setup fragment program uniforms
int program = mPlainTextureProgram;
glUseProgram(program);
// Setup uniforms
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, mOutputImageTexture);
glUniform1i(glGetUniformLocation(program, "uSourceTex"), 0);
// Rendering quad
int aPosCoord = glGetAttribLocation(program, "aPosition");
int aTexCoord = glGetAttribLocation(program, "aTexCoord");
glVertexAttribPointer(aPosCoord, 2, GL_FLOAT, GL_FALSE, 0, vertexPosition);
glVertexAttribPointer(aTexCoord, 2, GL_FLOAT, GL_FALSE, 0, textureCoord);
glEnableVertexAttribArray(aPosCoord);
glEnableVertexAttribArray(aTexCoord);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glDisableVertexAttribArray(aPosCoord);
glDisableVertexAttribArray(aTexCoord);
break;
}
case EXIT:
mStitcherThread->join();
// delete [] mStitcherBuffer;
// NOP
break;
}
mEgl->swap();
}
/**
* returns current Sate of the application
*/
NativeApp::State NativeApp::getState(void) const { return mCurrentApplicationState; }
/**
* Handle commands.
*/
void NativeApp::handleCommand(int cmd) {
switch (cmd) {
case APP_CMD_INIT_WINDOW:
case APP_CMD_WINDOW_RESIZED:
mEgl->setWindow(mNativeAppInstance->window);
break;
case APP_CMD_TERM_WINDOW:
mEgl->setWindow(NULL);
break;
default:
break;
}
}
/**
* Handle inputs.
*/
int NativeApp::handleInput(AInputEvent const* event) {
// Here we only handle key back event
int32_t type = AInputEvent_getType(event);
if (type == AINPUT_EVENT_TYPE_KEY) {
if (AKeyEvent_getKeyCode(event) == AKEYCODE_BACK) {
ANativeActivity_finish(mNativeAppInstance->activity);
__android_log_print(ANDROID_LOG_INFO, APPNAME, "ANativeActivity_finish()");
stop = true;
return 1;
}
} else {
int32_t action = AMotionEvent_getAction(event) & AMOTION_EVENT_ACTION_MASK;
switch (action) {
case AMOTION_EVENT_ACTION_DOWN:
if (mCurrentApplicationState == MAIN_LOOP) {
mPos.x = (AMotionEvent_getX(event, 0) - (mEgl->getWidth() / 2)) * (mTextureWidth * 1.0f / mEgl->getWidth());
mPos.y =
(AMotionEvent_getY(event, 0) - (mEgl->getHeight() / 2)) * (mTextureHeight * 1.0f / mEgl->getHeight());
mScreenPressed = true;
} else if (mCurrentApplicationState == SELECTION) {
float x = AMotionEvent_getX(event, 0);
__android_log_print(ANDROID_LOG_INFO, APPNAME, "AMotionEvent_getX() %d / %d", (int)x, mEgl->getWidth());
float fX = x / mEgl->getWidth();
if (fX < 0.4f) {
mStitcherThread =
new std::thread([=]() { launchStitcher((void*)mStitcherBuffer, mStitcherMutex, "av-rtmp.ptv"); });
glClearColor(1.0, 0.0, 0.0, 1.0);
} else if (fX < 0.7f) {
mStitcherThread =
new std::thread([=]() { launchStitcher((void*)mStitcherBuffer, mStitcherMutex, "procedural.ptv"); });
glClearColor(0.0, 1.0, 0.0, 1.0);
} else {
mStitcherThread =
new std::thread([=]() { launchStitcher((void*)mStitcherBuffer, mStitcherMutex, "profiling.ptv"); });
glClearColor(0.0, 0.0, 1.0, 1.0);
}
glClear(GL_COLOR_BUFFER_BIT);
glFinish();
mCurrentApplicationState = MAIN_LOOP;
}
break;
case AMOTION_EVENT_ACTION_UP:
if (mCurrentApplicationState == MAIN_LOOP) {
mScreenPressed = false;
}
break;
case AMOTION_EVENT_ACTION_MOVE:
if (mCurrentApplicationState == MAIN_LOOP) {
vector2d pos;
pos.x = (AMotionEvent_getX(event, 0) - (mEgl->getWidth() / 2)) * (mTextureWidth * 1.0f / mEgl->getWidth());
pos.y = (AMotionEvent_getY(event, 0) - (mEgl->getHeight() / 2)) * (mTextureHeight * 1.0f / mEgl->getHeight());
// point2pano(curPos);
// QPoint topLeftCorner((width - texWidth * zoom / 100) / (2 * devicePixelRatio),
// (height - texHeight * zoom / 100) / (2 * devicePixelRatio));
// p -= topLeftCorner;
// p *= 100 / zoom * devicePixelRatio;
// p.rx() -= texWidth / 2;
// p.ry() -= texHeight / 2;
vector3d v1, v2;
equirectangular2sphere(pos, v2, SphereRadius);
equirectangular2sphere(mPos, v1, SphereRadius);
double y, p, r;
sphere2orientation(v2, v1, y, p, r);
mOrientationMutex.lock();
mRoll = radToDeg(r);
mYaw = radToDeg(y);
mPitch = radToDeg(p);
mPos = pos;
mOrientationFlag = true;
mOrientationMutex.unlock();
}
break;
}
return 1;
}
return 0;
}
/**
* Wrapper to handle commands generated by the UI.
*/
void NativeApp::HandleCommand(android_app* app, int32_t cmd) {
static_cast<NativeApp*>(app->userData)->handleCommand(cmd);
}
/**
* Wrapper to handle input events generated by the UI.
*/
int32_t NativeApp::HandleInput(android_app* app, AInputEvent* event) {
return static_cast<NativeApp*>(app->userData)->handleInput(event);
}
class AndroidOutputWriter : public VideoStitch::Output::VideoWriter {
public:
AndroidOutputWriter(const std::string& name, void* outBuffer, std::mutex& outMutex, unsigned int w, unsigned int h)
: Output(name),
VideoWriter(w, h, {30, 1}, VideoStitch::PixelFormat::RGBA, AddressSpace::Host),
dst(outBuffer),
mutex(outMutex) {
__android_log_print(ANDROID_LOG_INFO, APPNAME, "AndroidOutputWriter::AndroidOutputWriter()");
// frame = std::make_shared<Frame>(w, h);
}
~AndroidOutputWriter() {
__android_log_print(ANDROID_LOG_INFO, APPNAME, "AndroidOutputWriter::~AndroidOutputWriter()");
}
virtual void pushVideo(const Frame& videoFrame) { // int frameId, const char* video, size_t, uint8_t* const*) {
mutex.lock();
memcpy(dst, videoFrame.planes[0], videoFrame.width * videoFrame.height * 4);
mutex.unlock();
}
private:
// std::shared_ptr<Frame> frame;
void* dst;
std::mutex& mutex;
};
struct ParsingError {
explicit ParsingError(std::string const& msg) : msg_(msg) {
__android_log_print(ANDROID_LOG_INFO, APPNAME, "ParsingError: %s", msg_.c_str());
}
const std::string msg_;
};
struct StitchError {
explicit StitchError(std::string const& msg) : msg_(msg) {
__android_log_print(ANDROID_LOG_INFO, APPNAME, "StitchError: %s", msg_.c_str());
}
const std::string msg_;
};
void normalizeOutputConfig(VideoStitch::Ptv::Value* outputConfig, VideoStitch::Core::Controller const* controller) {
// If the input frame rate is known, set the output frame rate.
VideoStitch::Logger::get(VideoStitch::Logger::Verbose)
<< "Setting output frame rate to " << controller->getReaderSpec(0).frameRate << "." << std::endl;
outputConfig->get("fps")->asDouble() =
controller->getReaderSpec(0).frameRate.num * 1.0 / controller->getReaderSpec(0).frameRate.den;
}
bool normalizeFrameBoundaries(VideoStitch::Core::Controller const* controller, const int firstFrame, int& lastFrame) {
lastFrame = (lastFrame < 0) ? controller->getLastStitchableFrame()
: std::min(lastFrame, controller->getLastStitchableFrame());
if (lastFrame == (int)NO_LAST_FRAME && lastFrame < 0) {
VideoStitch::Logger::get(VideoStitch::Logger::Error) << "Last frame autodetection was enabled, but all the readers "
"are unbounded (Are you using only procedural readers ?)."
<< std::endl;
return false;
}
if (lastFrame < firstFrame) {
VideoStitch::Logger::get(VideoStitch::Logger::Error)
<< "Nothing to stitch: last_frame = " << lastFrame << " < first_frame = " << firstFrame << "." << std::endl;
return false;
}
VideoStitch::Logger::get(VideoStitch::Logger::Info)
<< "Will stitch " << lastFrame - firstFrame + 1 << " images." << std::endl;
return true;
}
template <typename Controller>
Output::Output* makeCallback(Controller* controller, Core::PanoDefinition& pano, Ptv::Value* outputConfig,
Audio::SamplingRate outRate, Audio::SamplingDepth outDepth,
Audio::ChannelLayout outLayout) {
size_t width = pano.getWidth(), height = pano.getHeight();
if (pano.getProjection() == VideoStitch::Core::PanoProjection::Cubemap ||
pano.getProjection() == VideoStitch::Core::PanoProjection::EquiangularCubemap) {
width = 3 * pano.getLength();
height = 2 * pano.getLength();
} else {
width = pano.getWidth();
height = pano.getHeight();
}
Potential<Output::Output> pot =
Output::create(*outputConfig, outputConfig->has("filename")->asString(), (unsigned)width, (unsigned)height,
controller->getFrameRate(), outRate, outDepth, outLayout);
if (!pot.ok()) {
Logger::get(Logger::Error) << "Output writer creation failed!" << std::endl;
return nullptr;
}
return pot.release();
}
VideoStitch::Potential<VideoStitch::Core::StitchOutput> createStitchOutput(
VideoStitch::Core::Controller* controller, VideoStitch::Core::PanoDefinition const& pano,
std::shared_ptr<Output::VideoWriter> writer) {
std::vector<std::shared_ptr<Core::PanoSurface>> surfs;
for (int i = 0; i < 2; ++i) {
auto panoSurface = Core::OffscreenAllocator::createPanoSurface(pano.getWidth(), pano.getHeight(), "StitchOutput");
FAIL_RETURN(panoSurface.status());
surfs.push_back(std::shared_ptr<Core::PanoSurface>(panoSurface.release()));
}
// TODO: allow only one thread for this one; this is not thread-safe.
return controller->createAsyncStitchOutput(surfs, writer);
}
/**
* The stitcher loop for one device.
*/
int NativeApp::stitchRun(VideoStitch::Core::Controller* controller, VideoStitch::Core::StitchOutput* stitchOutput,
const int firstFrame, const int lastFrame) {
auto stitcher = controller->createStitcher();
if (!stitcher.ok()) throw StitchError("Could not create stitcher for GPU 0.");
int curFrame = firstFrame;
while (!stop && (curFrame <= lastFrame)) {
double yaw, pitch, roll;
int frame = (++curFrame) - 1;
yaw = 0.0;
pitch = 0.0;
roll = 0.0;
if (mOrientationFlag) {
mOrientationMutex.lock();
yaw = mYaw;
// pitch = mPitch;
// roll = mRoll;
mOrientationFlag = false;
mOrientationMutex.unlock();
controller->applyRotation(yaw, pitch, roll);
}
if (!controller->stitch(stitchOutput).ok()) {
std::ostringstream str;
str << "Failed to stitch frame " << frame;
throw StitchError(str.str());
}
usleep(10000);
}
return 0;
}
void NativeApp::launchStitcher(void* outBuffer, std::mutex& outMutex, const char* fileName) {
Potential<Ptv::Parser> parser = Ptv::Parser::create();
if (!parser.ok()) throw ParsingError("Error: Cannot create parser.");
__android_log_print(ANDROID_LOG_INFO, APPNAME, "void NativeApp::launchStitcher() starting");
// Load the project and parse it.
if (!parser->parse(fileName)) {
std::ostringstream l_str;
l_str << "Error: Cannot parse PTV file: " << parser->getErrorMessage();
throw ParsingError(l_str.str());
}
bool needToRestart = false;
VideoStitch::Discovery::Framework selectedFramework = VideoStitch::BackendLibHelper::getBestFrameworkAndBackend();
if (VideoStitch::BackendLibHelper::selectBackend(selectedFramework, &needToRestart)) {
__android_log_print(ANDROID_LOG_INFO, APPNAME, "%s backend selected",
VideoStitch::Discovery::getFrameworkName(selectedFramework).c_str());
} else {
throw StitchError("No capable GPU detected on your system");
}
int device;
if ((!Discovery::getBackendDeviceIndex(0, device)) || (!GPU::setDefaultBackendDeviceVS(device).ok()) ||
(!GPU::checkDefaultBackendDeviceInitialization().ok())) {
throw StitchError("Cannot set default device");
}
Core::PanoDefinition* panoDef = Core::PanoDefinition::create(*parser->getRoot().has("pano"));
if (!panoDef) {
throw StitchError("Invalid panorama definition!");
}
std::unique_ptr<Core::PanoDefinition> pano(panoDef);
SphereRadius = panoDef->getWidth() / (7.0f * /*tanf*/ (degToRad(pano->getHFOV()) /*/ 2.0f*/));
// SphereRadius = 960.0 / (8.0 * degToRad(pano->getHFOV()));
// __android_log_print(ANDROID_LOG_INFO, APPNAME, "HFOV: %f (%f)", float(pano->getHFOV()),
//float(degToRad(pano->getHFOV())));
// __android_log_print(ANDROID_LOG_INFO, APPNAME, "SphereRadius: %f", float(SphereRadius));
Potential<Core::ImageMergerFactory> imageMergerFactory =
Core::ImageMergerFactory::createMergerFactory(*parser->getRoot().has("merger"));
const Ptv::Value* output = parser->getRoot().has("output");
if (!output) {
__android_log_print(ANDROID_LOG_INFO, APPNAME, "Missing output config");
}
Potential<Core::ImageWarperFactory> imageWarperFactory =
Core::ImageWarperFactory::createWarperFactory(parser->getRoot().has("warper"));
Potential<Core::ImageFlowFactory> imageFlowFactory =
Core::ImageFlowFactory::createFlowFactory(parser->getRoot().has("flow"));
std::unique_ptr<Core::AudioPipeDefinition> audioPipeDef;
if (parser->getRoot().has("audio_pipe")) {
audioPipeDef = std::unique_ptr<Core::AudioPipeDefinition>(
Core::AudioPipeDefinition::create(*parser->getRoot().has("audio_pipe")));
} else {
audioPipeDef = std::unique_ptr<Core::AudioPipeDefinition>(
Core::AudioPipeDefinition::createAudioPipeFromPanoInputs(pano.get()));
}
const int firstFrame = 0;
int lastFrame = 5000;
Input::ReaderFactory* readerFactory = new Input::DefaultReaderFactory(firstFrame, lastFrame);
if (!readerFactory) throw StitchError("Reader factory creation failed!");
Core::PotentialController controller =
Core::createController(*pano, *imageMergerFactory.object(), *imageWarperFactory.object(),
*imageFlowFactory.object(), readerFactory, *audioPipeDef.get());
if (!controller.ok()) throw StitchError("Controller creation failed!");
assert(controller->getPano().numInputs());
const std::unique_ptr<Ptv::Value> outputConfig((*output).clone());
normalizeOutputConfig(outputConfig.get(), controller.object());
std::shared_ptr<Output::Output> sharedWriter(makeCallback(controller.object(), *pano, outputConfig.get(),
Audio::SamplingRate::SR_48000, Audio::SamplingDepth::FLT_P,
Audio::STEREO));
if (!sharedWriter) {
throw StitchError("Output writer creation failed!");
}
normalizeFrameBoundaries(controller.object(), firstFrame, lastFrame);
// PROBLEM HERE BELOW!!! (40 seconds wait)
// Create (possibly buffered) StitchOutput(s).
const Potential<Core::StitchOutput> stitchOutput(createStitchOutput(
controller.object(), *pano, std::dynamic_pointer_cast<VideoStitch::Output::VideoWriter>(sharedWriter)));
if (panoDef->getWidth() <= mTextureWidth && panoDef->getHeight() <= mTextureHeight) {
VideoStitch::Potential<Output::VideoWriter> writerDisplay(
new AndroidOutputWriter("Suzanne", outBuffer, outMutex, mTextureWidth, mTextureHeight));
if (!writerDisplay.ok()) throw StitchError("Output Display creation failed!");
std::shared_ptr<Output::Output> sharedWriterDisplay(writerDisplay.release());
stitchOutput.object()->addWriter(std::dynamic_pointer_cast<VideoStitch::Output::VideoWriter>(sharedWriterDisplay));
}
stitchRun(controller.object(), stitchOutput.object(), firstFrame, lastFrame);
// delete readerFactory;
delete panoDef;
}
/**
* This is the main entry point of a native application that is using
* android_native_app_glue. It runs in its own thread, with its own
* event loop for receiving input events and doing other things.
*/
void android_main(android_app* androidApp) {
// Make sure glue isn't stripped.
app_dummy();
NvInitSharedFoundation();
NvAssetLoaderInit((void*)androidApp->activity->assetManager);
// redirect Videostitch library logs to android logging
Logger::setLevel(Logger::Info);
start_logger();
NvEGLUtil* egl = NvEGLUtil::create();
if (egl == 0) {
// If we have a basic EGL failure, we need to exit immediately; nothing else we can do
nv_app_force_quit_no_cleanup(androidApp);
return;
}
// some cache directory will be created to store Opencl compiled code while default HOME is "/"
setenv("HOME", androidApp->activity->obbPath, 0);
NativeApp* instance = new NativeApp(androidApp, egl);
JNIEnv* env = nullptr;
androidApp->activity->vm->AttachCurrentThread(&env, NULL);
jclass android_content_Context = env->GetObjectClass(androidApp->activity->clazz);
jmethodID midGetPackageCodePath =
env->GetMethodID(android_content_Context, "getPackageCodePath", "()Ljava/lang/String;");
jstring packageCodePath = (jstring)env->CallObjectMethod(androidApp->activity->clazz, midGetPackageCodePath);
std::string dir = dirname(env->GetStringUTFChars(packageCodePath, 0));
int count = VideoStitch::Plugin::loadPlugins(dir + "/lib/" + ANDROID_ARCH_NAME);
__android_log_print(ANDROID_LOG_INFO, APPNAME, "Loaded %d plugin(s) in %s.", count, dir.c_str());
if (chdir(ASSETSDIR.c_str()) != 0) {
// getExternalFilesDir should correspond to /storage/emulated/0/Android/data/co.orah.stitch360/files
jmethodID midGetFilesDir =
env->GetMethodID(android_content_Context, "getExternalFilesDir", "(Ljava/lang/String;)Ljava/io/File;");
jobject objectFile = env->CallObjectMethod(androidApp->activity->clazz, midGetFilesDir, NULL);
// Call method on File object to retrieve String object.
jclass classFile = env->GetObjectClass(objectFile);
jmethodID methodIDgetAbsolutePath2 = env->GetMethodID(classFile, "getAbsolutePath", "()Ljava/lang/String;");
jstring stringPath = (jstring)env->CallObjectMethod(objectFile, methodIDgetAbsolutePath2);
// Extract a C string from the String object, and chdir() to it.
const char* wpath = env->GetStringUTFChars(stringPath, NULL);
if (chdir(wpath) != 0) {
__android_log_print(ANDROID_LOG_INFO, APPNAME, "Unable to change working directory to %s.", wpath);
} else {
__android_log_print(ANDROID_LOG_INFO, APPNAME, "Working directory set to %s.", wpath);
}
env->ReleaseStringUTFChars(stringPath, wpath);
} else {
__android_log_print(ANDROID_LOG_INFO, APPNAME, "Working directory set to %s.", ASSETSDIR.c_str());
}
androidApp->activity->vm->DetachCurrentThread();
while (nv_app_status_running(androidApp)) {
// Read all pending events.
int ident, events;
struct android_poll_source* source;
// If not rendering, we will block forever waiting for events.
// If animating, we loop until all events are read, then continue
// to draw the next frame of animation.
while ((ident = ALooper_pollAll((nv_app_status_focused(androidApp) ? 1 : 250), NULL, &events, (void**)&source)) >=
0) {
// If we timed out, then there are no pending messages.
if (ident == ALOOPER_POLL_TIMEOUT) {
break;
}
// Process this event.
if (source != NULL) {
source->process(androidApp, source);
}
// Check if we are exiting. If so, dump out.
if (!nv_app_status_running(androidApp)) {
break;
}
}
if (nv_app_status_interactable(androidApp)) {
instance->renderFrame();
}
}
// Remove application instance
delete instance;
// Remove EGL instance
delete egl;
NvReleaseSharedFoundation();
NvAssetLoaderShutdown();
}