Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 28c49c9d authored by Ruben Brunk's avatar Ruben Brunk
Browse files

camera2: Update shader scaling matrix for legacy mode. 

Bug: 15116722
Change-Id: Idaa4311dfd027b2d2b8ea5e2c6cba2da5779d753
parent d4d02282

core/java/android/hardware/camera2/legacy/LegacyCameraDevice.java

+26 −0
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
package android.hardware.camera2.legacy;



import android.graphics.ImageFormat;

import android.graphics.SurfaceTexture;

import android.hardware.Camera;

import android.hardware.camera2.CameraCharacteristics;

import android.hardware.camera2.CaptureRequest;
@@ -463,6 +464,24 @@ public class LegacyCameraDevice implements AutoCloseable { 
        return ids.contains(id);

    }



    static void setSurfaceOrientation(Surface surface, int facing, int sensorOrientation)

            throws BufferQueueAbandonedException {

        checkNotNull(surface);

        LegacyExceptionUtils.throwOnError(nativeSetSurfaceOrientation(surface, facing,

                sensorOrientation));

    }



    static Size getTextureSize(SurfaceTexture surfaceTexture)

            throws BufferQueueAbandonedException {

        checkNotNull(surfaceTexture);



        int[] dimens = new int[2];

        LegacyExceptionUtils.throwOnError(nativeDetectTextureDimens(surfaceTexture,

                /*out*/dimens));



        return new Size(dimens[0], dimens[1]);

    }



    private static native int nativeDetectSurfaceType(Surface surface);



    private static native int nativeDetectSurfaceDimens(Surface surface,
@@ -479,4 +498,11 @@ public class LegacyCameraDevice implements AutoCloseable { 
    private static native int nativeSetSurfaceDimens(Surface surface, int width, int height);



    private static native long nativeGetSurfaceId(Surface surface);



    private static native int nativeSetSurfaceOrientation(Surface surface, int facing,

                                                             int sensorOrientation);



    private static native int nativeDetectTextureDimens(SurfaceTexture surfaceTexture,

            /*out*/int[/*2*/] dimens);



}

core/java/android/hardware/camera2/legacy/RequestThreadManager.java

+3 −0
Original line number Diff line number Diff line
@@ -292,10 +292,13 @@ public class RequestThreadManager { 
        mInFlightPreview = null;

        mInFlightJpeg = null;



        int facing = mCharacteristics.get(CameraCharacteristics.LENS_FACING);

        int orientation = mCharacteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);

        if (outputs != null) {

            for (Surface s : outputs) {

                try {

                    int format = LegacyCameraDevice.detectSurfaceType(s);

                    LegacyCameraDevice.setSurfaceOrientation(s, facing, orientation);

                    switch (format) {

                        case CameraMetadataNative.NATIVE_JPEG_FORMAT:

                            mCallbackOutputs.add(s);

core/java/android/hardware/camera2/legacy/SurfaceTextureRenderer.java

+79 −35
Original line number Diff line number Diff line
@@ -189,12 +189,56 @@ public class SurfaceTextureRenderer { 
        return program;

    }



    private void drawFrame(SurfaceTexture st) {

    private void drawFrame(SurfaceTexture st, int width, int height) {

        checkGlError("onDrawFrame start");

        st.getTransformMatrix(mSTMatrix);



        Size dimens;

        try {

            dimens = LegacyCameraDevice.getTextureSize(st);

        } catch (LegacyExceptionUtils.BufferQueueAbandonedException e) {

            // Should never hit this.

            throw new IllegalStateException("Surface abandoned, skipping drawFrame...", e);

        }



        Matrix.setIdentityM(mMVPMatrix, /*smOffset*/0);



        float texWidth = dimens.getWidth();

        float texHeight = dimens.getHeight();



        if (texWidth <= 0 || texHeight <= 0) {

            throw new IllegalStateException("Illegal intermediate texture with dimension of 0");

        }



        // Find largest scaling factor from the intermediate texture dimension to the

        // output surface dimension.  Scaling the intermediate texture by this allows

        // us to letterbox/pillerbox the output surface into the intermediate texture.

        float widthRatio = width / texWidth;

        float heightRatio = height / texHeight;

        float actual = (widthRatio < heightRatio) ? heightRatio : widthRatio;



        if (DEBUG) {

            GLES20.glClearColor(0.0f, 1.0f, 0.0f, 1.0f);

            Log.d(TAG, "Scaling factor " + actual + " used for " + width + "x" + height +

                    " surface, intermediate buffer size is " + texWidth + "x" + texHeight);

        }



        // Set the viewport height and width to be the scaled intermediate texture dimensions.

        int viewportW = (int) (actual * texWidth);

        int viewportH = (int) (actual * texHeight);



        // Set the offset of the viewport so that the output surface is centered in the viewport.

        float dx = (width - viewportW) / 2f;

        float dy = (height - viewportH) / 2f;



        if (DEBUG) {

            Log.d(TAG, "Translation " + dx + "," + dy + " used for " + width + "x" + height +

                    " surface");

        }



        GLES20.glViewport((int) dx, (int) dy, viewportW, viewportH);



        if (DEBUG) {

            GLES20.glClearColor(1.0f, 0.0f, 0.0f, 1.0f);

            GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);

        }
@@ -218,7 +262,6 @@ public class SurfaceTextureRenderer { 
        GLES20.glEnableVertexAttribArray(maTextureHandle);

        checkGlError("glEnableVertexAttribArray maTextureHandle");



        Matrix.setIdentityM(mMVPMatrix, 0);

        GLES20.glUniformMatrix4fv(muMVPMatrixHandle, /*count*/ 1, /*transpose*/ false, mMVPMatrix,

                /*offset*/ 0);

        GLES20.glUniformMatrix4fv(muSTMatrixHandle, /*count*/ 1, /*transpose*/ false, mSTMatrix,
@@ -589,18 +632,19 @@ public class SurfaceTextureRenderer { 
        for (EGLSurfaceHolder holder : mSurfaces) {

            if (LegacyCameraDevice.containsSurfaceId(holder.surface, targetSurfaceIds)) {

                makeCurrent(holder.eglSurface);

                drawFrame(mSurfaceTexture);

                drawFrame(mSurfaceTexture, holder.width, holder.height);

                swapBuffers(holder.eglSurface);

            }

        }

        for (EGLSurfaceHolder holder : mConversionSurfaces) {

            if (LegacyCameraDevice.containsSurfaceId(holder.surface, targetSurfaceIds)) {

                makeCurrent(holder.eglSurface);

                drawFrame(mSurfaceTexture);

                drawFrame(mSurfaceTexture, holder.width, holder.height);

                mPBufferPixels.clear();

                GLES20.glReadPixels(/*x*/ 0, /*y*/ 0, holder.width, holder.height, GLES20.GL_RGBA,

                        GLES20.GL_UNSIGNED_BYTE, mPBufferPixels);

                GLES20.glReadPixels(/*x*/ 0, /*y*/ 0, holder.width, holder.height,

                        GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, mPBufferPixels);

                checkGlError("glReadPixels");



                try {

                    int format = LegacyCameraDevice.detectSurfaceType(holder.surface);

                    LegacyCameraDevice.produceFrame(holder.surface, mPBufferPixels.array(),

core/jni/android_hardware_camera2_legacy_LegacyCameraDevice.cpp

+106 −0
Original line number Diff line number Diff line
@@ -19,17 +19,20 @@ 
#include <utils/Log.h>

#include <utils/Errors.h>

#include <utils/Trace.h>

#include <camera/CameraUtils.h>



#include "jni.h"

#include "JNIHelp.h"

#include "android_runtime/AndroidRuntime.h"

#include "android_runtime/android_view_Surface.h"

#include "android_runtime/android_graphics_SurfaceTexture.h"



#include <gui/Surface.h>

#include <gui/IGraphicBufferProducer.h>

#include <ui/GraphicBuffer.h>

#include <system/window.h>

#include <hardware/camera3.h>

#include <system/camera_metadata.h>



#include <stdint.h>

#include <inttypes.h>
@@ -335,6 +338,25 @@ static sp<ANativeWindow> getNativeWindow(JNIEnv* env, jobject surface) { 
    return anw;

}



static sp<ANativeWindow> getNativeWindowFromTexture(JNIEnv* env, jobject surfaceTexture) {

    sp<ANativeWindow> anw;

    if (surfaceTexture) {

        anw = android_SurfaceTexture_getNativeWindow(env, surfaceTexture);

        if (env->ExceptionCheck()) {

            return NULL;

        }

    } else {

        jniThrowNullPointerException(env, "surfaceTexture");

        return NULL;

    }

    if (anw == NULL) {

        jniThrowExceptionFmt(env, "java/lang/IllegalArgumentException",

                "SurfaceTexture had no valid native window.");

        return NULL;

    }

    return anw;

}



static sp<Surface> getSurface(JNIEnv* env, jobject surface) {

    sp<Surface> s;

    if (surface) {
@@ -376,6 +398,17 @@ static jint LegacyCameraDevice_nativeDetectSurfaceType(JNIEnv* env, jobject thiz 
static jint LegacyCameraDevice_nativeDetectSurfaceDimens(JNIEnv* env, jobject thiz,

          jobject surface, jintArray dimens) {

    ALOGV("nativeGetSurfaceDimens");



    if (dimens == NULL) {

        ALOGE("%s: Null dimens argument passed to nativeDetectSurfaceDimens", __FUNCTION__);

        return BAD_VALUE;

    }



    if (env->GetArrayLength(dimens) < 2) {

        ALOGE("%s: Invalid length of dimens argument in nativeDetectSurfaceDimens", __FUNCTION__);

        return BAD_VALUE;

    }



    sp<ANativeWindow> anw;

    if ((anw = getNativeWindow(env, surface)) == NULL) {

        ALOGE("%s: Could not retrieve native window from surface.", __FUNCTION__);
@@ -398,6 +431,37 @@ static jint LegacyCameraDevice_nativeDetectSurfaceDimens(JNIEnv* env, jobject th 
    return NO_ERROR;

}



static jint LegacyCameraDevice_nativeDetectTextureDimens(JNIEnv* env, jobject thiz,

        jobject surfaceTexture, jintArray dimens) {

    ALOGV("nativeDetectTextureDimens");

    sp<ANativeWindow> anw;

    if ((anw = getNativeWindowFromTexture(env, surfaceTexture)) == NULL) {

        ALOGE("%s: Could not retrieve native window from SurfaceTexture.", __FUNCTION__);

        return BAD_VALUE;

    }



    int32_t dimenBuf[2];

    status_t err = anw->query(anw.get(), NATIVE_WINDOW_WIDTH, dimenBuf);

    if(err != NO_ERROR) {

        ALOGE("%s: Error while querying SurfaceTexture width %s (%d)", __FUNCTION__,

                strerror(-err), err);

        return err;

    }



    err = anw->query(anw.get(), NATIVE_WINDOW_HEIGHT, dimenBuf + 1);

    if(err != NO_ERROR) {

        ALOGE("%s: Error while querying SurfaceTexture height %s (%d)", __FUNCTION__,

                strerror(-err), err);

        return err;

    }



    env->SetIntArrayRegion(dimens, /*start*/0, /*length*/ARRAY_SIZE(dimenBuf), dimenBuf);

    if (env->ExceptionCheck()) {

        return BAD_VALUE;

    }

    return NO_ERROR;

}



static jint LegacyCameraDevice_nativeConfigureSurface(JNIEnv* env, jobject thiz, jobject surface,

        jint width, jint height, jint pixelFormat) {

    ALOGV("nativeConfigureSurface");
@@ -504,6 +568,42 @@ static jlong LegacyCameraDevice_nativeGetSurfaceId(JNIEnv* env, jobject thiz, jo 
    return reinterpret_cast<jlong>(b.get());

}



static jint LegacyCameraDevice_nativeSetSurfaceOrientation(JNIEnv* env, jobject thiz,

        jobject surface, jint facing, jint orientation) {

    ALOGV("nativeSetSurfaceOrientation");

    sp<ANativeWindow> anw;

    if ((anw = getNativeWindow(env, surface)) == NULL) {

        ALOGE("%s: Could not retrieve native window from surface.", __FUNCTION__);

        return BAD_VALUE;

    }



    status_t err = NO_ERROR;

    CameraMetadata staticMetadata;



    int32_t orientVal = static_cast<int32_t>(orientation);

    uint8_t facingVal = static_cast<uint8_t>(facing);

    staticMetadata.update(ANDROID_SENSOR_ORIENTATION, &orientVal, 1);

    staticMetadata.update(ANDROID_LENS_FACING, &facingVal, 1);



    int32_t transform = 0;



    if ((err = CameraUtils::getRotationTransform(staticMetadata, /*out*/&transform)) != OK) {

        ALOGE("%s: Invalid rotation transform %s (%d)", __FUNCTION__, strerror(-err),

                err);

        return err;

    }



    ALOGV("%s: Setting buffer sticky transform to %d", __FUNCTION__, transform);



    if ((err = native_window_set_buffers_sticky_transform(anw.get(), transform)) != OK) {

        ALOGE("%s: Unable to configure surface transform, error %s (%d)", __FUNCTION__,

                strerror(-err), err);

        return err;

    }



    return NO_ERROR;

}



} // extern "C"



static JNINativeMethod gCameraDeviceMethods[] = {
@@ -528,6 +628,12 @@ static JNINativeMethod gCameraDeviceMethods[] = { 
    { "nativeGetSurfaceId",

    "(Landroid/view/Surface;)J",

    (void *)LegacyCameraDevice_nativeGetSurfaceId },

    { "nativeDetectTextureDimens",

    "(Landroid/graphics/SurfaceTexture;[I)I",

    (void *)LegacyCameraDevice_nativeDetectTextureDimens },

    { "nativeSetSurfaceOrientation",

    "(Landroid/view/Surface;II)I",

    (void *)LegacyCameraDevice_nativeSetSurfaceOrientation },

};



// Get all the required offsets in java class and register native functions