/*
|
* Copyright (C) 2014 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
#define LOG_TAG "Camera2-Legacy-PerfMeasurement-JNI"
|
#include <utils/Log.h>
|
#include <utils/Errors.h>
|
#include <utils/Trace.h>
|
#include <utils/Vector.h>
|
|
#include "jni.h"
|
#include <nativehelper/JNIHelp.h>
|
#include "core_jni_helpers.h"
|
|
#include <ui/GraphicBuffer.h>
|
#include <system/window.h>
|
#include <GLES2/gl2.h>
|
#include <GLES2/gl2ext.h>
|
|
using namespace android;
|
|
// fully-qualified class name
|
#define PERF_MEASUREMENT_CLASS_NAME "android/hardware/camera2/legacy/PerfMeasurement"
|
|
/** GL utility methods copied from com_google_android_gles_jni_GLImpl.cpp */
|
|
// Check if the extension at the head of pExtensions is pExtension. Note that pExtensions is
|
// terminated by either 0 or space, while pExtension is terminated by 0.
|
|
static bool
|
extensionEqual(const GLubyte* pExtensions, const GLubyte* pExtension) {
|
while (true) {
|
char a = *pExtensions++;
|
char b = *pExtension++;
|
bool aEnd = a == '\0' || a == ' ';
|
bool bEnd = b == '\0';
|
if (aEnd || bEnd) {
|
return aEnd == bEnd;
|
}
|
if (a != b) {
|
return false;
|
}
|
}
|
}
|
|
static const GLubyte*
|
nextExtension(const GLubyte* pExtensions) {
|
while (true) {
|
char a = *pExtensions++;
|
if (a == '\0') {
|
return pExtensions-1;
|
} else if ( a == ' ') {
|
return pExtensions;
|
}
|
}
|
}
|
|
static bool
|
checkForExtension(const GLubyte* pExtensions, const GLubyte* pExtension) {
|
for (; *pExtensions != '\0'; pExtensions = nextExtension(pExtensions)) {
|
if (extensionEqual(pExtensions, pExtension)) {
|
return true;
|
}
|
}
|
return false;
|
}
|
|
/** End copied GL utility methods */
|
|
bool checkGlError(JNIEnv* env) {
|
int error;
|
if ((error = glGetError()) != GL_NO_ERROR) {
|
jniThrowExceptionFmt(env, "java/lang/IllegalStateException",
|
"GLES20 error: 0x%d", error);
|
return true;
|
}
|
return false;
|
}
|
|
/**
|
* Asynchronous low-overhead GL performance measurement using
|
* http://www.khronos.org/registry/gles/extensions/EXT/EXT_disjoint_timer_query.txt
|
*
|
* Measures the duration of GPU processing for a set of GL commands, delivering
|
* the measurement asynchronously once processing completes.
|
*
|
* All calls must come from a single thread with a valid GL context active.
|
**/
|
class PerfMeasurementContext {
|
private:
|
Vector<GLuint> mTimingQueries;
|
size_t mTimingStartIndex;
|
size_t mTimingEndIndex;
|
size_t mTimingQueryIndex;
|
size_t mFreeQueries;
|
|
bool mInitDone;
|
public:
|
|
/**
|
* maxQueryCount should be a conservative estimate of how many query objects
|
* will be active at once, which is a function of the GPU's level of
|
* pipelining and the frequency of queries.
|
*/
|
explicit PerfMeasurementContext(size_t maxQueryCount):
|
mTimingStartIndex(0),
|
mTimingEndIndex(0),
|
mTimingQueryIndex(0) {
|
mTimingQueries.resize(maxQueryCount);
|
mFreeQueries = maxQueryCount;
|
mInitDone = false;
|
}
|
|
int getMaxQueryCount() {
|
return mTimingQueries.size();
|
}
|
|
/**
|
* Start a measurement period using the next available query object.
|
* Returns INVALID_OPERATION if called multiple times in a row,
|
* and BAD_VALUE if no more query objects are available.
|
*/
|
int startGlTimer() {
|
// Lazy init of queries to avoid needing GL context during construction
|
if (!mInitDone) {
|
glGenQueriesEXT(mTimingQueries.size(), mTimingQueries.editArray());
|
mInitDone = true;
|
}
|
|
if (mTimingEndIndex != mTimingStartIndex) {
|
return INVALID_OPERATION;
|
}
|
|
if (mFreeQueries == 0) {
|
return BAD_VALUE;
|
}
|
|
glBeginQueryEXT(GL_TIME_ELAPSED_EXT, mTimingQueries[mTimingStartIndex]);
|
|
mTimingStartIndex = (mTimingStartIndex + 1) % mTimingQueries.size();
|
mFreeQueries--;
|
|
return OK;
|
}
|
|
/**
|
* Finish the current measurement period
|
* Returns INVALID_OPERATION if called before any startGLTimer calls
|
* or if called multiple times in a row.
|
*/
|
int stopGlTimer() {
|
size_t nextEndIndex = (mTimingEndIndex + 1) % mTimingQueries.size();
|
if (nextEndIndex != mTimingStartIndex) {
|
return INVALID_OPERATION;
|
}
|
glEndQueryEXT(GL_TIME_ELAPSED_EXT);
|
|
mTimingEndIndex = nextEndIndex;
|
|
return OK;
|
}
|
|
static const nsecs_t NO_DURATION_YET = -1L;
|
static const nsecs_t FAILED_MEASUREMENT = -2L;
|
|
/**
|
* Get the next available duration measurement.
|
*
|
* Returns NO_DURATION_YET if no new measurement is available,
|
* and FAILED_MEASUREMENT if an error occurred during the next
|
* measurement period.
|
*
|
* Otherwise returns a positive number of nanoseconds measuring the
|
* duration of the oldest completed query.
|
*/
|
nsecs_t getNextGlDuration() {
|
if (!mInitDone) {
|
// No start/stop called yet
|
return NO_DURATION_YET;
|
}
|
|
GLint available;
|
glGetQueryObjectivEXT(mTimingQueries[mTimingQueryIndex],
|
GL_QUERY_RESULT_AVAILABLE_EXT, &available);
|
if (!available) {
|
return NO_DURATION_YET;
|
}
|
|
GLint64 duration = FAILED_MEASUREMENT;
|
GLint disjointOccurred;
|
glGetIntegerv(GL_GPU_DISJOINT_EXT, &disjointOccurred);
|
|
if (!disjointOccurred) {
|
glGetQueryObjecti64vEXT(mTimingQueries[mTimingQueryIndex],
|
GL_QUERY_RESULT_EXT,
|
&duration);
|
}
|
|
mTimingQueryIndex = (mTimingQueryIndex + 1) % mTimingQueries.size();
|
mFreeQueries++;
|
|
return static_cast<nsecs_t>(duration);
|
}
|
|
static bool isMeasurementSupported() {
|
const GLubyte* extensions = glGetString(GL_EXTENSIONS);
|
return checkForExtension(extensions,
|
reinterpret_cast<const GLubyte*>("GL_EXT_disjoint_timer_query"));
|
}
|
|
};
|
|
PerfMeasurementContext* getContext(jlong context) {
|
return reinterpret_cast<PerfMeasurementContext*>(context);
|
}
|
|
extern "C" {
|
|
static jlong PerfMeasurement_nativeCreateContext(JNIEnv* env, jobject thiz,
|
jint maxQueryCount) {
|
PerfMeasurementContext *context = new PerfMeasurementContext(maxQueryCount);
|
return reinterpret_cast<jlong>(context);
|
}
|
|
static void PerfMeasurement_nativeDeleteContext(JNIEnv* env, jobject thiz,
|
jlong contextHandle) {
|
PerfMeasurementContext *context = getContext(contextHandle);
|
delete(context);
|
}
|
|
static jboolean PerfMeasurement_nativeQuerySupport(JNIEnv* env, jobject thiz) {
|
bool supported = PerfMeasurementContext::isMeasurementSupported();
|
checkGlError(env);
|
return static_cast<jboolean>(supported);
|
}
|
|
static void PerfMeasurement_nativeStartGlTimer(JNIEnv* env, jobject thiz,
|
jlong contextHandle) {
|
|
PerfMeasurementContext *context = getContext(contextHandle);
|
status_t err = context->startGlTimer();
|
if (err != OK) {
|
switch (err) {
|
case INVALID_OPERATION:
|
jniThrowExceptionFmt(env, "java/lang/IllegalStateException",
|
"Mismatched start/end GL timing calls");
|
return;
|
case BAD_VALUE:
|
jniThrowExceptionFmt(env, "java/lang/IllegalStateException",
|
"Too many timing queries in progress, max %d",
|
context->getMaxQueryCount());
|
return;
|
default:
|
jniThrowExceptionFmt(env, "java/lang/IllegalStateException",
|
"Unknown error starting GL timing");
|
return;
|
}
|
}
|
checkGlError(env);
|
}
|
|
static void PerfMeasurement_nativeStopGlTimer(JNIEnv* env, jobject thiz,
|
jlong contextHandle) {
|
|
PerfMeasurementContext *context = getContext(contextHandle);
|
status_t err = context->stopGlTimer();
|
if (err != OK) {
|
switch (err) {
|
case INVALID_OPERATION:
|
jniThrowExceptionFmt(env, "java/lang/IllegalStateException",
|
"Mismatched start/end GL timing calls");
|
return;
|
default:
|
jniThrowExceptionFmt(env, "java/lang/IllegalStateException",
|
"Unknown error ending GL timing");
|
return;
|
}
|
}
|
checkGlError(env);
|
}
|
|
static jlong PerfMeasurement_nativeGetNextGlDuration(JNIEnv* env,
|
jobject thiz, jlong contextHandle) {
|
PerfMeasurementContext *context = getContext(contextHandle);
|
nsecs_t duration = context->getNextGlDuration();
|
|
checkGlError(env);
|
return static_cast<jlong>(duration);
|
}
|
|
} // extern "C"
|
|
static const JNINativeMethod gPerfMeasurementMethods[] = {
|
{ "nativeCreateContext",
|
"(I)J",
|
(jlong *)PerfMeasurement_nativeCreateContext },
|
{ "nativeDeleteContext",
|
"(J)V",
|
(void *)PerfMeasurement_nativeDeleteContext },
|
{ "nativeQuerySupport",
|
"()Z",
|
(jboolean *)PerfMeasurement_nativeQuerySupport },
|
{ "nativeStartGlTimer",
|
"(J)V",
|
(void *)PerfMeasurement_nativeStartGlTimer },
|
{ "nativeStopGlTimer",
|
"(J)V",
|
(void *)PerfMeasurement_nativeStopGlTimer },
|
{ "nativeGetNextGlDuration",
|
"(J)J",
|
(jlong *)PerfMeasurement_nativeGetNextGlDuration }
|
};
|
|
|
// Get all the required offsets in java class and register native functions
|
int register_android_hardware_camera2_legacy_PerfMeasurement(JNIEnv* env)
|
{
|
// Register native functions
|
return RegisterMethodsOrDie(env,
|
PERF_MEASUREMENT_CLASS_NAME,
|
gPerfMeasurementMethods,
|
NELEM(gPerfMeasurementMethods));
|
}
|
