Hey there! I’ve tinkered with Open Camera’s codebase before, so I know exactly how frustrating it can be to get mirror effects working smoothly—let’s walk through two reliable approaches to solve this.

Approach 1: Mirror the Raw Preview Frame Data (YUV Processing) #

Open Camera typically uses the legacy Android Camera API, which delivers preview frames in NV21/YUV_420_888 format. Mirroring these frames directly (before converting to RGB) is efficient for real-time performance.

Step 1: Locate the Preview Callback #

First, find where Open Camera handles preview frames. Look for classes like CameraHolder or Preview that implement Camera.PreviewCallback. The key method is onPreviewFrame(byte[] data, Camera camera).

Step 2: Add a Frame Mirroring Utility #

Add this helper method to mirror NV21-formatted frames (the most common format for Android camera previews):

private byte[] mirrorNV21(byte[] data, int width, int height) {
    int yPlaneSize = width * height;
    int uvPlaneSize = yPlaneSize / 2;
    byte[] mirroredFrame = new byte[data.length];

    // Mirror the Y (luminance) plane
    for (int row = 0; row < height; row++) {
        int rowStart = row * width;
        int rowEnd = rowStart + width - 1;
        for (int col = 0; col < width; col++) {
            mirroredFrame[rowStart + col] = data[rowEnd - col];
        }
    }

    // Mirror the UV (chrominance) plane (interleaved pairs)
    for (int row = 0; row < height / 2; row++) {
        int rowStart = yPlaneSize + row * width;
        int rowEnd = rowStart + width - 2; // Step by 2 for UV pairs
        for (int col = 0; col < width; col += 2) {
            mirroredFrame[rowStart + col] = data[rowEnd - col];
            mirroredFrame[rowStart + col + 1] = data[rowEnd - col + 1];
        }
    }

    return mirroredFrame;
}

Step 3: Integrate into the Preview Flow #

Modify the onPreviewFrame method to process the frame before passing it to the display/rendering pipeline:

@Override
public void onPreviewFrame(byte[] data, Camera camera) {
    Camera.Parameters params = camera.getParameters();
    Size previewSize = params.getPreviewSize();
    
    // Only mirror if using front camera (adjust logic based on your needs)
    Camera.CameraInfo info = new Camera.CameraInfo();
    Camera.getCameraInfo(mCurrentCameraId, info);
    if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
        data = mirrorNV21(data, previewSize.width, previewSize.height);
    }

    // Pass the mirrored frame to Open Camera's existing rendering logic
    mPreviewCallbackHandler.onPreviewFrame(data, camera);
}

Approach 2: Mirror via OpenGL ES Rendering (Better Performance) #

If Open Camera uses GLSurfaceView for preview rendering (which it often does for smoother display), leveraging GPU-based mirroring is more efficient.

Step 1: Modify the Vertex Shader #

Find the OpenGL vertex shader file (usually named something like preview_vertex_shader.glsl) and adjust the texture coordinate to flip horizontally:

attribute vec4 aPosition;
attribute vec2 aTexCoord;
varying vec2 vTexCoord;

void main() {
    gl_Position = aPosition;
    // Flip the X-coordinate for mirror effect
    vTexCoord = vec2(1.0 - aTexCoord.x, aTexCoord.y);
}

Step 2: Add Camera Facing Logic (Optional) #

If you only want mirroring for the front camera, add a uniform variable to toggle the effect:

attribute vec4 aPosition;
attribute vec2 aTexCoord;
varying vec2 vTexCoord;
uniform bool uMirrorEnabled;

void main() {
    gl_Position = aPosition;
    vTexCoord = uMirrorEnabled ? vec2(1.0 - aTexCoord.x, aTexCoord.y) : aTexCoord;
}

Then in your Java OpenGL code, set the uniform based on the current camera:

int mirrorUniformHandle = GLES20.glGetUniformLocation(mProgram, "uMirrorEnabled");
Camera.CameraInfo info = new Camera.CameraInfo();
Camera.getCameraInfo(mCurrentCameraId, info);
GLES20.glUniform1i(mirrorUniformHandle, info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT ? 1 : 0);

Key Notes for Debugging #

• Performance: Avoid processing frames on the main thread—use a background handler or GPU rendering to prevent lag.
• Camera Format: Double-check the preview format returned by Camera.Parameters.getPreviewFormat() to ensure your mirroring logic matches (NV21 is standard, but some devices use YUV_420_888).
• Preview Orientation: Mirroring might interact with existing rotation logic—test both portrait and landscape modes to ensure consistency.

内容的提问来源于stack exchange，提问作者Rudra Goswami