Move virtual camera service to frameworks/av/services
Bug: 311647154
Bug: 301023410
Test: atest virtual_camera_tests
Test: build & flash & adb shell cmd virtual_camera help
Change-Id: I6d43a2b70f454c9c01ec2abcae9f138cd78c6a85
diff --git a/services/camera/virtualcamera/util/EglDisplayContext.cc b/services/camera/virtualcamera/util/EglDisplayContext.cc
new file mode 100644
index 0000000..6d343a2
--- /dev/null
+++ b/services/camera/virtualcamera/util/EglDisplayContext.cc
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2023 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_NDEBUG 0
+#define LOG_TAG "EglDisplayContext"
+#define EGL_EGLEXT_PROTOTYPES
+#define GL_GLEXT_PROTOTYPES
+
+#include "EglDisplayContext.h"
+
+#include "EGL/egl.h"
+#include "EglDisplayContext.h"
+#include "EglFramebuffer.h"
+#include "log/log.h"
+
+namespace android {
+namespace companion {
+namespace virtualcamera {
+
+EglDisplayContext::EglDisplayContext()
+ : mEglDisplay(EGL_NO_DISPLAY),
+ mEglContext(EGL_NO_CONTEXT),
+ mEglConfig(nullptr) {
+ EGLBoolean result;
+
+ mEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+ if (mEglDisplay == EGL_NO_DISPLAY) {
+ ALOGE("eglGetDisplay failed: %#x", eglGetError());
+ return;
+ }
+
+ EGLint majorVersion, minorVersion;
+ result = eglInitialize(mEglDisplay, &majorVersion, &minorVersion);
+ if (result != EGL_TRUE) {
+ ALOGE("eglInitialize failed: %#x", eglGetError());
+ return;
+ }
+ ALOGV("Initialized EGL v%d.%d", majorVersion, minorVersion);
+
+ EGLint numConfigs = 0;
+ EGLint configAttribs[] = {
+ EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, EGL_RENDERABLE_TYPE,
+ EGL_OPENGL_ES2_BIT, EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8,
+ // no alpha
+ EGL_NONE};
+
+ result =
+ eglChooseConfig(mEglDisplay, configAttribs, &mEglConfig, 1, &numConfigs);
+ if (result != EGL_TRUE) {
+ ALOGE("eglChooseConfig error: %#x", eglGetError());
+ return;
+ }
+
+ EGLint contextAttribs[] = {EGL_CONTEXT_MAJOR_VERSION_KHR, 3, EGL_NONE};
+ mEglContext =
+ eglCreateContext(mEglDisplay, mEglConfig, EGL_NO_CONTEXT, contextAttribs);
+ if (mEglContext == EGL_NO_CONTEXT) {
+ ALOGE("eglCreateContext error: %#x", eglGetError());
+ return;
+ }
+
+ if (!makeCurrent()) {
+ ALOGE(
+ "Failed to set newly initialized EGLContext and EGLDisplay connection "
+ "as current.");
+ } else {
+ ALOGV("EGL successfully initialized.");
+ }
+}
+
+EglDisplayContext::~EglDisplayContext() {
+ if (mEglDisplay != EGL_NO_DISPLAY) {
+ eglTerminate(mEglDisplay);
+ }
+ if (mEglContext != EGL_NO_CONTEXT) {
+ eglDestroyContext(mEglDisplay, mEglContext);
+ }
+ eglReleaseThread();
+}
+
+EGLDisplay EglDisplayContext::getEglDisplay() const {
+ return mEglDisplay;
+}
+
+bool EglDisplayContext::isInitialized() const {
+ return mEglContext != EGL_NO_CONTEXT && mEglDisplay != EGL_NO_DISPLAY;
+}
+
+bool EglDisplayContext::makeCurrent() {
+ if (!eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, mEglContext)) {
+ ALOGE("eglMakeCurrent failed: %#x", eglGetError());
+ return false;
+ }
+ return true;
+}
+
+} // namespace virtualcamera
+} // namespace companion
+} // namespace android
diff --git a/services/camera/virtualcamera/util/EglDisplayContext.h b/services/camera/virtualcamera/util/EglDisplayContext.h
new file mode 100644
index 0000000..402ca3c
--- /dev/null
+++ b/services/camera/virtualcamera/util/EglDisplayContext.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2023 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.
+ */
+
+#ifndef ANDROID_COMPANION_VIRTUALCAMERA_EGLDISPLAYCONTEXT_H
+#define ANDROID_COMPANION_VIRTUALCAMERA_EGLDISPLAYCONTEXT_H
+
+#include "EGL/egl.h"
+
+namespace android {
+namespace companion {
+namespace virtualcamera {
+
+// Encapsulated EGLDisplay & EGLContext.
+//
+// Upon construction, this object will create and configure new
+// EGLDisplay & EGLContext and will destroy them once it goes
+// out of scope.
+class EglDisplayContext {
+ public:
+ EglDisplayContext();
+ ~EglDisplayContext();
+
+ // Sets EGLDisplay & EGLContext for current thread.
+ //
+ // Returns true on success, false otherwise.
+ bool makeCurrent();
+
+ EGLDisplay getEglDisplay() const;
+
+ // Returns true if this instance encapsulates successfully initialized
+ // EGLDisplay & EGLContext.
+ bool isInitialized() const;
+
+ private:
+ EGLDisplay mEglDisplay;
+ EGLContext mEglContext;
+ EGLConfig mEglConfig;
+};
+
+} // namespace virtualcamera
+} // namespace companion
+} // namespace android
+
+#endif // ANDROID_COMPANION_VIRTUALCAMERA_EGLDISPLAYCONTEXT_H
diff --git a/services/camera/virtualcamera/util/EglFramebuffer.cc b/services/camera/virtualcamera/util/EglFramebuffer.cc
new file mode 100644
index 0000000..acf0122
--- /dev/null
+++ b/services/camera/virtualcamera/util/EglFramebuffer.cc
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2023 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_NDEBUG 0
+#define LOG_TAG "EglFramebuffer"
+#include "EglFramebuffer.h"
+
+#include "EGL/eglext.h"
+#include "EglUtil.h"
+#include "GLES/gl.h"
+#include "GLES2/gl2.h"
+#include "GLES2/gl2ext.h"
+#include "android/hardware_buffer.h"
+#include "log/log.h"
+
+namespace android {
+namespace companion {
+namespace virtualcamera {
+
+EglFrameBuffer::EglFrameBuffer(EGLDisplay display,
+ std::shared_ptr<AHardwareBuffer> hwBuffer)
+ : mHardwareBuffer(hwBuffer), mEglDisplay(display) {
+ if (hwBuffer == nullptr) {
+ ALOGE("Cannot construct EglFramebuffer from null hwBuffer");
+ return;
+ }
+
+ AHardwareBuffer_Desc hwBufferDesc;
+ AHardwareBuffer_describe(hwBuffer.get(), &hwBufferDesc);
+ mWidth = hwBufferDesc.width;
+ mHeight = hwBufferDesc.height;
+
+ EGLClientBuffer clientBuffer = eglGetNativeClientBufferANDROID(hwBuffer.get());
+ mEglImageKhr = eglCreateImageKHR(display, EGL_NO_CONTEXT,
+ EGL_NATIVE_BUFFER_ANDROID, clientBuffer, 0);
+ if (checkEglError("eglCreateImageKHR")) {
+ return;
+ }
+
+ // Create texture backed by the hardware buffer.
+ glGenTextures(1, &mTextureId);
+ glBindTexture(GL_TEXTURE_EXTERNAL_OES, mTextureId);
+ glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES,
+ (GLeglImageOES)mEglImageKhr);
+ if (checkEglError("configure external texture")) {
+ return;
+ }
+
+ // Create framebuffer backed by the texture.
+ glGenFramebuffers(1, &mFramebufferId);
+ glBindFramebuffer(GL_FRAMEBUFFER, mFramebufferId);
+ glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+ GL_TEXTURE_EXTERNAL_OES, mTextureId, 0);
+ GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+ if (status != GL_FRAMEBUFFER_COMPLETE) {
+ ALOGE("Failed to configure framebuffer for texture");
+ return; // false;
+ }
+ if (checkEglError("glCheckFramebufferStatus")) {
+ return; // false;
+ }
+}
+
+EglFrameBuffer::~EglFrameBuffer() {
+ if (mFramebufferId != 0) {
+ glDeleteFramebuffers(1, &mFramebufferId);
+ }
+ if (mTextureId != 0) {
+ glDeleteTextures(1, &mTextureId);
+ }
+ if (mEglImageKhr != EGL_NO_IMAGE_KHR) {
+ eglDestroyImageKHR(mEglDisplay, mEglDisplay);
+ }
+}
+
+bool EglFrameBuffer::beforeDraw() {
+ glBindFramebuffer(GL_FRAMEBUFFER, mFramebufferId);
+ if (checkEglError("glBindFramebuffer")) {
+ return false;
+ }
+
+ glViewport(0, 0, mWidth, mHeight);
+
+ return true;
+}
+
+bool EglFrameBuffer::afterDraw() {
+ glFinish();
+ glBindFramebuffer(GL_FRAMEBUFFER, 0);
+ glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
+ return true;
+}
+
+int EglFrameBuffer::getWidth() const {
+ return mWidth;
+}
+
+int EglFrameBuffer::getHeight() const {
+ return mHeight;
+}
+
+} // namespace virtualcamera
+} // namespace companion
+} // namespace android
diff --git a/services/camera/virtualcamera/util/EglFramebuffer.h b/services/camera/virtualcamera/util/EglFramebuffer.h
new file mode 100644
index 0000000..35f85e2
--- /dev/null
+++ b/services/camera/virtualcamera/util/EglFramebuffer.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2023 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.
+ */
+
+#ifndef ANDROID_COMPANION_VIRTUALCAMERA_EGLFRAMEBUFFER_H
+#define ANDROID_COMPANION_VIRTUALCAMERA_EGLFRAMEBUFFER_H
+
+#define EGL_EGLEXT_PROTOTYPES
+#define GL_GLEXT_PROTOTYPES
+
+#include <memory>
+
+#include "EGL/egl.h"
+#include "EGL/eglext.h"
+#include "GLES/gl.h"
+
+namespace android {
+namespace companion {
+namespace virtualcamera {
+
+// Encapsulates EGL Framebuffer backed by AHardwareBuffer instance.
+//
+// Note that the framebuffer is tied to EGLDisplay connection.
+class EglFrameBuffer {
+ public:
+ EglFrameBuffer(EGLDisplay display, std::shared_ptr<AHardwareBuffer> hwBuffer);
+ virtual ~EglFrameBuffer();
+
+ // Prepare for rendering into the framebuffer.
+ bool beforeDraw();
+
+ // Finishes rendering into the framebuffer.
+ bool afterDraw();
+
+ // Return width of framebuffer (in pixels).
+ int getWidth() const;
+
+ // Return height of framebuffer (in pixels).
+ int getHeight() const;
+
+ private:
+ // Keeping shared_ptr to hardware buffer instance here prevents it from being
+ // freed while tied to EGL framebufer / EGL texture.
+ std::shared_ptr<AHardwareBuffer> mHardwareBuffer;
+ EGLDisplay mEglDisplay;
+ EGLImageKHR mEglImageKhr{EGL_NO_IMAGE_KHR};
+ GLuint mTextureId;
+ GLuint mFramebufferId;
+
+ int mWidth;
+ int mHeight;
+};
+
+} // namespace virtualcamera
+} // namespace companion
+} // namespace android
+
+#endif // ANDROID_COMPANION_VIRTUALCAMERA_EGLFRAMEBUFFER_H
diff --git a/services/camera/virtualcamera/util/EglProgram.cc b/services/camera/virtualcamera/util/EglProgram.cc
new file mode 100644
index 0000000..c468d39
--- /dev/null
+++ b/services/camera/virtualcamera/util/EglProgram.cc
@@ -0,0 +1,292 @@
+/*
+ * Copyright (C) 2023 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_NDEBUG 0
+#define LOG_TAG "EglProgram"
+#include "EglProgram.h"
+
+#include <array>
+#include <complex>
+
+#include "EglUtil.h"
+#include "GLES/gl.h"
+#include "GLES2/gl2.h"
+#include "GLES2/gl2ext.h"
+#include "log/log.h"
+
+namespace android {
+namespace companion {
+namespace virtualcamera {
+
+namespace {
+
+constexpr char kGlExtYuvTarget[] = "GL_EXT_YUV_target";
+
+constexpr char kIdentityVertexShader[] = R"(
+ attribute vec4 vPosition;
+ void main() {
+ gl_Position = vPosition;
+ })";
+
+constexpr char kJuliaFractalFragmentShader[] = R"(
+ precision mediump float;
+ uniform vec2 uResolution;
+ uniform vec2 uC;
+ uniform vec2 uUV;
+ const float kIter = 64.0;
+
+ vec2 imSq(vec2 n){
+ return vec2(pow(n.x,2.0)-pow(n.y,2.0), 2.0*n.x*n.y);
+ }
+
+ float julia(vec2 n, vec2 c) {
+ vec2 z = n;
+ for (float i=0.0;i<kIter; i+=1.0) {
+ z = imSq(z) + c;
+ if (length(z) > 2.0) return i/kIter;
+ }
+ return kIter;
+ }
+
+ void main() {
+ vec2 uv = vec2(gl_FragCoord.x / uResolution.x - 0.5, gl_FragCoord.y / uResolution.y - 0.5);
+ float juliaVal = julia(uv * 4.0, uC);
+ gl_FragColor = vec4( juliaVal,uUV.x,uUV.y,0.0);
+ })";
+
+constexpr char kExternalTextureVertexShader[] = R"(#version 300 es
+ in vec4 aPosition;
+ in vec2 aTextureCoord;
+ out vec2 vTextureCoord;
+ void main() {
+ gl_Position = aPosition;
+ vTextureCoord = aTextureCoord;
+ })";
+
+constexpr char kExternalTextureFragmentShader[] = R"(#version 300 es
+ #extension GL_OES_EGL_image_external_essl3 : require
+ #extension GL_EXT_YUV_target : require
+ precision mediump float;
+ in vec2 vTextureCoord;
+ out vec4 fragColor;
+ uniform __samplerExternal2DY2YEXT uTexture;
+ void main() {
+ fragColor = texture(uTexture, vTextureCoord);
+ })";
+
+constexpr int kCoordsPerVertex = 3;
+constexpr std::array<float, 12> kSquareCoords{-1.f, 1.0f, 0.0f, // top left
+ -1.f, -1.f, 0.0f, // bottom left
+ 1.0f, -1.f, 0.0f, // bottom right
+ 1.0f, 1.0f, 0.0f}; // top right
+
+constexpr std::array<float, 8> kTextureCoords{0.0f, 1.0f, // top left
+ 0.0f, 0.0f, // bottom left
+ 1.0f, 0.0f, // bottom right
+ 1.0f, 1.0f}; // top right
+
+constexpr std::array<uint8_t, 6> kDrawOrder{0, 1, 2, 0, 2, 3};
+
+GLuint compileShader(GLenum shaderType, const char* src) {
+ GLuint shader = glCreateShader(shaderType);
+ if (shader == 0) {
+ ALOGE("glCreateShader(shaderType=%x) error: %#x",
+ static_cast<unsigned int>(shaderType), glGetError());
+ return 0;
+ }
+
+ glShaderSource(shader, 1, &src, NULL);
+ glCompileShader(shader);
+
+ GLint compiled = 0;
+ glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
+ if (!compiled) {
+ ALOGE("Compile of shader type %d failed", shaderType);
+ GLint infoLen = 0;
+ glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
+ if (infoLen) {
+ char* buf = new char[infoLen];
+ if (buf) {
+ glGetShaderInfoLog(shader, infoLen, NULL, buf);
+ ALOGE("Compile log: %s", buf);
+ delete[] buf;
+ }
+ }
+ glDeleteShader(shader);
+ return 0;
+ }
+ return shader;
+}
+
+} // namespace
+
+EglProgram::~EglProgram() {
+ if (mProgram) {
+ glDeleteProgram(mProgram);
+ }
+}
+
+bool EglProgram::initialize(const char* vertexShaderSrc,
+ const char* fragmentShaderSrc) {
+ GLuint vertexShaderId = compileShader(GL_VERTEX_SHADER, vertexShaderSrc);
+ if (checkEglError("compileShader(vertex)")) {
+ return false;
+ }
+ GLuint fragmentShaderId = compileShader(GL_FRAGMENT_SHADER, fragmentShaderSrc);
+ if (checkEglError("compileShader(fragment)")) {
+ return false;
+ }
+
+ GLuint programId = glCreateProgram();
+
+ glAttachShader(programId, vertexShaderId);
+ glAttachShader(programId, fragmentShaderId);
+ glLinkProgram(programId);
+
+ GLint linkStatus = GL_FALSE;
+ glGetProgramiv(programId, GL_LINK_STATUS, &linkStatus);
+ if (linkStatus != GL_TRUE) {
+ ALOGE("glLinkProgram failed");
+ GLint bufLength = 0;
+ glGetProgramiv(programId, GL_INFO_LOG_LENGTH, &bufLength);
+ if (bufLength) {
+ char* buf = new char[bufLength];
+ if (buf) {
+ glGetProgramInfoLog(programId, bufLength, NULL, buf);
+ ALOGE("Link log: %s", buf);
+ delete[] buf;
+ }
+ }
+ glDeleteProgram(programId);
+ return false;
+ }
+
+ mProgram = programId;
+
+ mIsInitialized = true;
+ return mIsInitialized;
+}
+
+bool EglProgram::isInitialized() const {
+ return mIsInitialized;
+}
+
+EglTestPatternProgram::EglTestPatternProgram() {
+ if (initialize(kIdentityVertexShader, kJuliaFractalFragmentShader)) {
+ ALOGV("Successfully initialized EGL shaders for test pattern program.");
+ } else {
+ ALOGE("Test pattern EGL shader program initialization failed.");
+ }
+}
+
+bool EglTestPatternProgram::draw(int width, int height, int frameNumber) {
+ glViewport(0, 0, static_cast<GLsizei>(width), static_cast<GLsizei>(height));
+ checkEglError("glViewport");
+
+ // Load compiled shader.
+ glUseProgram(mProgram);
+ checkEglError("glUseProgram");
+
+ // Compute point in complex plane corresponding to fractal for this frame number.
+ float time = float(frameNumber) / 120.0f;
+ const std::complex<float> c(std::sin(time) * 0.78f, std::cos(time) * 0.78f);
+
+ // Pass uniform values to the shader.
+ int resolutionHandle = glGetUniformLocation(mProgram, "uResolution");
+ checkEglError("glGetUniformLocation -> uResolution");
+ glUniform2f(resolutionHandle, static_cast<float>(width),
+ static_cast<float>(height));
+ checkEglError("glUniform2f -> uResolution");
+
+ // Pass "C" constant value determining the Julia set to the shader.
+ int cHandle = glGetUniformLocation(mProgram, "uC");
+ glUniform2f(cHandle, c.imag(), c.real());
+
+ // Pass chroma value to the shader.
+ int uvHandle = glGetUniformLocation(mProgram, "uUV");
+ glUniform2f(uvHandle, (c.imag() + 1.f) / 2.f, (c.real() + 1.f) / 2.f);
+
+ // Pass vertex array to draw.
+ int positionHandle = glGetAttribLocation(mProgram, "vPosition");
+ glEnableVertexAttribArray(positionHandle);
+
+ // Prepare the triangle coordinate data.
+ glVertexAttribPointer(positionHandle, kCoordsPerVertex, GL_FLOAT, false,
+ kSquareCoords.size(), kSquareCoords.data());
+
+ // Draw triangle strip forming a square filling the viewport.
+ glDrawElements(GL_TRIANGLES, kDrawOrder.size(), GL_UNSIGNED_BYTE,
+ kDrawOrder.data());
+ if (checkEglError("glDrawElements")) {
+ return false;
+ }
+
+ return true;
+}
+
+EglTextureProgram::EglTextureProgram() {
+ if (!isGlExtensionSupported(kGlExtYuvTarget)) {
+ ALOGE(
+ "Cannot initialize external texture program due to missing "
+ "GL_EXT_YUV_target extension");
+ return;
+ }
+
+ if (initialize(kExternalTextureVertexShader, kExternalTextureFragmentShader)) {
+ ALOGV("Successfully initialized EGL shaders for external texture program.");
+ } else {
+ ALOGE("External texture EGL shader program initialization failed.");
+ }
+}
+
+bool EglTextureProgram::draw(GLuint textureId) {
+ // Load compiled shader.
+ glUseProgram(mProgram);
+ if (checkEglError("glUseProgram")) {
+ return false;
+ }
+
+ // Pass vertex array to the shader.
+ int positionHandle = glGetAttribLocation(mProgram, "aPosition");
+ glEnableVertexAttribArray(positionHandle);
+ glVertexAttribPointer(positionHandle, kCoordsPerVertex, GL_FLOAT, false,
+ kSquareCoords.size(), kSquareCoords.data());
+
+ // Pass texture coordinates corresponding to vertex array to the shader.
+ int textureCoordHandle = glGetAttribLocation(mProgram, "aTextureCoord");
+ glEnableVertexAttribArray(textureCoordHandle);
+ glVertexAttribPointer(textureCoordHandle, 2, GL_FLOAT, false,
+ kTextureCoords.size(), kTextureCoords.data());
+
+ // Configure texture for the shader.
+ int textureHandle = glGetUniformLocation(mProgram, "uTexture");
+ glActiveTexture(GL_TEXTURE0);
+ glBindTexture(GL_TEXTURE_EXTERNAL_OES, textureId);
+ glUniform1i(textureHandle, 0);
+
+ // Draw triangle strip forming a square filling the viewport.
+ glDrawElements(GL_TRIANGLES, kDrawOrder.size(), GL_UNSIGNED_BYTE,
+ kDrawOrder.data());
+ if (checkEglError("glDrawElements")) {
+ return false;
+ }
+
+ return true;
+}
+
+} // namespace virtualcamera
+} // namespace companion
+} // namespace android
diff --git a/services/camera/virtualcamera/util/EglProgram.h b/services/camera/virtualcamera/util/EglProgram.h
new file mode 100644
index 0000000..8e394e7
--- /dev/null
+++ b/services/camera/virtualcamera/util/EglProgram.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2023 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.
+ */
+
+#ifndef ANDROID_COMPANION_VIRTUALCAMERA_EGLPROGRAM_H
+#define ANDROID_COMPANION_VIRTUALCAMERA_EGLPROGRAM_H
+
+#include "GLES/gl.h"
+
+namespace android {
+namespace companion {
+namespace virtualcamera {
+
+// Base class for EGL Shader programs representation.
+class EglProgram {
+ public:
+ virtual ~EglProgram();
+
+ // Returns whether the EGL Program was successfully compiled and linked.
+ bool isInitialized() const;
+
+ protected:
+ // Compile & link program from the vertex & fragment shader source.
+ bool initialize(const char* vertexShaderSrc, const char* fragmentShaderSrc);
+ GLuint mProgram;
+ // Whether the EGL Program was successfully compiled and linked.
+ bool mIsInitialized = false;
+};
+
+// Shader program to draw Julia Set test pattern.
+class EglTestPatternProgram : public EglProgram {
+ public:
+ EglTestPatternProgram();
+
+ bool draw(int width, int height, int frameNumber);
+};
+
+// Shader program to draw texture.
+//
+// Shader stretches the texture over the viewport (if the texture is not same
+// aspect ratio as viewport, it will be deformed).
+//
+// TODO(b/301023410) Add support for translation / cropping.
+class EglTextureProgram : public EglProgram {
+ public:
+ EglTextureProgram();
+
+ bool draw(GLuint textureId);
+};
+
+} // namespace virtualcamera
+} // namespace companion
+} // namespace android
+
+#endif // ANDROID_COMPANION_VIRTUALCAMERA_EGLPROGRAM_H
diff --git a/services/camera/virtualcamera/util/EglSurfaceTexture.cc b/services/camera/virtualcamera/util/EglSurfaceTexture.cc
new file mode 100644
index 0000000..ac92bc4
--- /dev/null
+++ b/services/camera/virtualcamera/util/EglSurfaceTexture.cc
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2023 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_NDEBUG 0
+#include <memory>
+#define LOG_TAG "EglSurfaceTexture"
+
+#include <cstdint>
+
+#include "EglSurfaceTexture.h"
+#include "EglUtil.h"
+#include "GLES/gl.h"
+#include "gui/BufferQueue.h"
+#include "gui/GLConsumer.h"
+#include "gui/IGraphicBufferProducer.h"
+#include "hardware/gralloc.h"
+
+namespace android {
+namespace companion {
+namespace virtualcamera {
+
+EglSurfaceTexture::EglSurfaceTexture(const uint32_t width, const uint32_t height)
+ : mWidth(width), mHeight(height) {
+ glGenTextures(1, &mTextureId);
+ if (checkEglError("EglSurfaceTexture(): glGenTextures")) {
+ ALOGE("Failed to generate texture");
+ return;
+ }
+ BufferQueue::createBufferQueue(&mBufferProducer, &mBufferConsumer);
+ mGlConsumer = sp<GLConsumer>::make(
+ mBufferConsumer, mTextureId, GLConsumer::TEXTURE_EXTERNAL, false, false);
+ mGlConsumer->setName(String8("VirtualCameraEglSurfaceTexture"));
+ mGlConsumer->setDefaultBufferSize(mWidth, mHeight);
+ mGlConsumer->setConsumerUsageBits(GRALLOC_USAGE_HW_TEXTURE);
+ mGlConsumer->setDefaultBufferFormat(AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420);
+
+ mSurface = sp<Surface>::make(mBufferProducer);
+}
+
+EglSurfaceTexture::~EglSurfaceTexture() {
+ if (mTextureId != 0) {
+ glDeleteTextures(1, &mTextureId);
+ }
+}
+
+sp<Surface> EglSurfaceTexture::getSurface() {
+ return mSurface;
+}
+
+sp<GraphicBuffer> EglSurfaceTexture::getCurrentBuffer() {
+ return mGlConsumer->getCurrentBuffer();
+}
+
+GLuint EglSurfaceTexture::updateTexture() {
+ mGlConsumer->updateTexImage();
+ return mTextureId;
+}
+
+uint32_t EglSurfaceTexture::getWidth() const {
+ return mWidth;
+}
+
+uint32_t EglSurfaceTexture::getHeight() const {
+ return mHeight;
+}
+
+} // namespace virtualcamera
+} // namespace companion
+} // namespace android
diff --git a/services/camera/virtualcamera/util/EglSurfaceTexture.h b/services/camera/virtualcamera/util/EglSurfaceTexture.h
new file mode 100644
index 0000000..14dc7d6
--- /dev/null
+++ b/services/camera/virtualcamera/util/EglSurfaceTexture.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2023 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.
+ */
+
+#ifndef ANDROID_COMPANION_VIRTUALCAMERA_EGLSURFACETEXTURE_H
+#define ANDROID_COMPANION_VIRTUALCAMERA_EGLSURFACETEXTURE_H
+
+#include <cstdint>
+
+#include "GLES/gl.h"
+#include "gui/Surface.h"
+#include "utils/RefBase.h"
+
+namespace android {
+
+class IGraphicBufferProducer;
+class IGraphicBufferConsumer;
+class GLConsumer;
+
+namespace companion {
+namespace virtualcamera {
+
+// Encapsulates GLConsumer & Surface for rendering into EGL texture.
+class EglSurfaceTexture {
+ public:
+ // Create new EGL Texture with specified size.
+ EglSurfaceTexture(uint32_t width, uint32_t height);
+ ~EglSurfaceTexture();
+
+ // Get Surface backing up the texture.
+ sp<Surface> getSurface();
+
+ // Get GraphicBuffer backing the current texture.
+ sp<GraphicBuffer> getCurrentBuffer();
+
+ // Get width of surface / texture.
+ uint32_t getWidth() const;
+
+ // Get height of surface / texture.
+ uint32_t getHeight() const;
+
+ // Update the texture with the most recent submitted buffer.
+ // Most be called on thread with EGL context.
+ //
+ // Returns EGL texture id of the texture.
+ GLuint updateTexture();
+
+ private:
+ sp<IGraphicBufferProducer> mBufferProducer;
+ sp<IGraphicBufferConsumer> mBufferConsumer;
+ sp<GLConsumer> mGlConsumer;
+ sp<Surface> mSurface;
+ GLuint mTextureId;
+ const uint32_t mWidth;
+ const uint32_t mHeight;
+};
+
+} // namespace virtualcamera
+} // namespace companion
+} // namespace android
+
+#endif // ANDROID_COMPANION_VIRTUALCAMERA_EGLSURFACETEXTURE_H
diff --git a/services/camera/virtualcamera/util/EglUtil.cc b/services/camera/virtualcamera/util/EglUtil.cc
new file mode 100644
index 0000000..481d8f0
--- /dev/null
+++ b/services/camera/virtualcamera/util/EglUtil.cc
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2023 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_NDEBUG 0
+#define LOG_TAG "EglUtil"
+#include "EglUtil.h"
+
+#include <cstring>
+
+#include "GLES/gl.h"
+#include "log/log.h"
+
+namespace android {
+namespace companion {
+namespace virtualcamera {
+
+bool checkEglError(const char* operation) {
+ GLenum err = glGetError();
+ if (err == GL_NO_ERROR) {
+ return false;
+ }
+ ALOGE("%s failed: %d", operation, err);
+ return true;
+}
+
+bool isGlExtensionSupported(const char* extension) {
+ const char* extensions =
+ reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));
+ if (extension == nullptr || extensions == nullptr) {
+ return false;
+ }
+ return strstr(extensions, extension) != nullptr;
+}
+
+} // namespace virtualcamera
+} // namespace companion
+} // namespace android
diff --git a/services/camera/virtualcamera/util/EglUtil.h b/services/camera/virtualcamera/util/EglUtil.h
new file mode 100644
index 0000000..71640e3
--- /dev/null
+++ b/services/camera/virtualcamera/util/EglUtil.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2023 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.
+ */
+
+#ifndef ANDROID_COMPANION_VIRTUALCAMERA_EGLUTIL_H
+#define ANDROID_COMPANION_VIRTUALCAMERA_EGLUTIL_H
+
+namespace android {
+namespace companion {
+namespace virtualcamera {
+
+// Returns true if the EGL is in an error state and logs the error.
+bool checkEglError(const char* operation = "EGL operation");
+
+// Returns true if the GL extension is supported, false otherwise.
+bool isGlExtensionSupported(const char* extension);
+
+} // namespace virtualcamera
+} // namespace companion
+} // namespace android
+
+#endif // ANDROID_COMPANION_VIRTUALCAMERA_EGLUTIL_H
diff --git a/services/camera/virtualcamera/util/JpegUtil.cc b/services/camera/virtualcamera/util/JpegUtil.cc
new file mode 100644
index 0000000..6f10376
--- /dev/null
+++ b/services/camera/virtualcamera/util/JpegUtil.cc
@@ -0,0 +1,228 @@
+/*
+ * Copyright (C) 2023 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_NDEBUG 0
+#define LOG_TAG "JpegUtil"
+#include "JpegUtil.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+
+#include "android/hardware_buffer.h"
+#include "jpeglib.h"
+#include "log/log.h"
+#include "ui/GraphicBuffer.h"
+#include "ui/GraphicBufferMapper.h"
+#include "utils/Errors.h"
+
+namespace android {
+namespace companion {
+namespace virtualcamera {
+namespace {
+
+constexpr int kJpegQuality = 80;
+
+class LibJpegContext {
+ public:
+ LibJpegContext(int width, int height, const android_ycbcr& ycbcr,
+ const size_t outBufferSize, void* outBuffer)
+ : mYCbCr(ycbcr),
+ mWidth(width),
+ mHeight(height),
+ mDstBufferSize(outBufferSize),
+ mDstBuffer(outBuffer) {
+ // Initialize error handling for libjpeg.
+ // We call jpeg_std_error to initialize standard error
+ // handling and then override:
+ // * output_message not to print to stderr, but use ALOG instead.
+ // * error_exit not to terminate the process, but failure flag instead.
+ mCompressStruct.err = jpeg_std_error(&mErrorMgr);
+ mCompressStruct.err->output_message = onOutputError;
+ mCompressStruct.err->error_exit = onErrorExit;
+ jpeg_create_compress(&mCompressStruct);
+
+ // Configure input image parameters.
+ mCompressStruct.image_width = width;
+ mCompressStruct.image_height = height;
+ mCompressStruct.input_components = 3;
+ mCompressStruct.in_color_space = JCS_YCbCr;
+ // We pass pointer to this instance as a client data so we can
+ // access this object from the static callbacks invoked by
+ // libjpeg.
+ mCompressStruct.client_data = this;
+
+ // Configure destination manager for libjpeg.
+ mCompressStruct.dest = &mDestinationMgr;
+ mDestinationMgr.init_destination = onInitDestination;
+ mDestinationMgr.empty_output_buffer = onEmptyOutputBuffer;
+ mDestinationMgr.term_destination = onTermDestination;
+ mDestinationMgr.next_output_byte = reinterpret_cast<JOCTET*>(mDstBuffer);
+ mDestinationMgr.free_in_buffer = mDstBufferSize;
+
+ // Configure everything else based on input configuration above.
+ jpeg_set_defaults(&mCompressStruct);
+
+ // Set quality and colorspace.
+ jpeg_set_quality(&mCompressStruct, kJpegQuality, 1);
+ jpeg_set_colorspace(&mCompressStruct, JCS_YCbCr);
+
+ // Configure RAW input mode - this let's libjpeg know we're providing raw,
+ // subsampled YCbCr data.
+ mCompressStruct.raw_data_in = 1;
+ mCompressStruct.dct_method = JDCT_IFAST;
+
+ // Configure sampling factors - this states that every 2 Y
+ // samples share 1 Cb & 1 Cr component vertically & horizontally (YUV420).
+ mCompressStruct.comp_info[0].h_samp_factor = 2;
+ mCompressStruct.comp_info[0].v_samp_factor = 2;
+ mCompressStruct.comp_info[1].h_samp_factor = 1;
+ mCompressStruct.comp_info[1].v_samp_factor = 1;
+ mCompressStruct.comp_info[2].h_samp_factor = 1;
+ mCompressStruct.comp_info[2].v_samp_factor = 1;
+ }
+
+ bool compress() {
+ // Prepare arrays of pointers to scanlines of each plane.
+ std::vector<JSAMPROW> yLines(mHeight);
+ std::vector<JSAMPROW> cbLines(mHeight / 2);
+ std::vector<JSAMPROW> crLines(mHeight / 2);
+
+ uint8_t* y = static_cast<uint8_t*>(mYCbCr.y);
+ uint8_t* cb = static_cast<uint8_t*>(mYCbCr.cb);
+ uint8_t* cr = static_cast<uint8_t*>(mYCbCr.cr);
+
+ // Since UV samples might be interleaved (semiplanar) we need to copy
+ // them to separate planes, since libjpeg doesn't directly
+ // support processing semiplanar YUV.
+ const int c_samples = (mWidth / 2) * (mHeight / 2);
+ std::vector<uint8_t> cb_plane(c_samples);
+ std::vector<uint8_t> cr_plane(c_samples);
+
+ // TODO(b/301023410) - Use libyuv or ARM SIMD for "unzipping" the data.
+ for (int i = 0; i < c_samples; ++i) {
+ cb_plane[i] = *cb;
+ cr_plane[i] = *cr;
+ cb += mYCbCr.chroma_step;
+ cr += mYCbCr.chroma_step;
+ }
+
+ // Collect pointers to individual scanline of each plane.
+ for (int i = 0; i < mHeight; ++i) {
+ yLines[i] = y + i * mYCbCr.ystride;
+ }
+ for (int i = 0; i < (mHeight / 2); ++i) {
+ cbLines[i] = cb_plane.data() + i * (mWidth / 2);
+ crLines[i] = cr_plane.data() + i * (mWidth / 2);
+ }
+
+ // Perform actual compression.
+ jpeg_start_compress(&mCompressStruct, TRUE);
+
+ while (mCompressStruct.next_scanline < mCompressStruct.image_height) {
+ const uint32_t batchSize = DCTSIZE * 2;
+ const uint32_t nl = mCompressStruct.next_scanline;
+ JSAMPARRAY planes[3]{&yLines[nl], &cbLines[nl / 2], &crLines[nl / 2]};
+
+ uint32_t done = jpeg_write_raw_data(&mCompressStruct, planes, batchSize);
+
+ if (done != batchSize) {
+ ALOGE("%s: compressed %u lines, expected %u (total %u/%u)",
+ __FUNCTION__, done, batchSize, mCompressStruct.next_scanline,
+ mCompressStruct.image_height);
+ return false;
+ }
+ }
+ jpeg_finish_compress(&mCompressStruct);
+ return mSuccess;
+ }
+
+ private:
+ void setSuccess(const boolean success) {
+ mSuccess = success;
+ }
+
+ void initDestination() {
+ mDestinationMgr.next_output_byte = reinterpret_cast<JOCTET*>(mDstBuffer);
+ mDestinationMgr.free_in_buffer = mDstBufferSize;
+ ALOGV("%s:%d jpeg start: %p [%zu]", __FUNCTION__, __LINE__, mDstBuffer,
+ mDstBufferSize);
+ }
+
+ void termDestination() {
+ mEncodedSize = mDstBufferSize - mDestinationMgr.free_in_buffer;
+ ALOGV("%s:%d Done with jpeg: %zu", __FUNCTION__, __LINE__, mEncodedSize);
+ }
+
+ // === libjpeg callbacks below ===
+
+ static void onOutputError(j_common_ptr cinfo) {
+ char buffer[JMSG_LENGTH_MAX];
+ (*cinfo->err->format_message)(cinfo, buffer);
+ ALOGE("libjpeg error: %s", buffer);
+ };
+
+ static void onErrorExit(j_common_ptr cinfo) {
+ static_cast<LibJpegContext*>(cinfo->client_data)->setSuccess(false);
+ };
+
+ static void onInitDestination(j_compress_ptr cinfo) {
+ static_cast<LibJpegContext*>(cinfo->client_data)->initDestination();
+ }
+
+ static int onEmptyOutputBuffer(j_compress_ptr cinfo __unused) {
+ ALOGV("%s:%d Out of buffer", __FUNCTION__, __LINE__);
+ return 0;
+ }
+
+ static void onTermDestination(j_compress_ptr cinfo) {
+ static_cast<LibJpegContext*>(cinfo->client_data)->termDestination();
+ }
+
+ jpeg_compress_struct mCompressStruct;
+ jpeg_error_mgr mErrorMgr;
+ jpeg_destination_mgr mDestinationMgr;
+
+ // Layout of the input image.
+ android_ycbcr mYCbCr;
+
+ // Dimensions of the input image.
+ int mWidth;
+ int mHeight;
+
+ // Destination buffer and it's capacity.
+ size_t mDstBufferSize;
+ void* mDstBuffer;
+
+ // This will be set to size of encoded data
+ // written to the outputBuffer when encoding finishes.
+ size_t mEncodedSize;
+ // Set to true/false based on whether the encoding
+ // was successful.
+ boolean mSuccess = true;
+};
+
+} // namespace
+
+// Returns true if the EGL is in an error state and logs the error.
+bool compressJpeg(int width, int height, const android_ycbcr& ycbcr,
+ size_t outBufferSize, void* outBuffer) {
+ return LibJpegContext(width, height, ycbcr, outBufferSize, outBuffer)
+ .compress();
+}
+
+} // namespace virtualcamera
+} // namespace companion
+} // namespace android
diff --git a/services/camera/virtualcamera/util/JpegUtil.h b/services/camera/virtualcamera/util/JpegUtil.h
new file mode 100644
index 0000000..8bff008
--- /dev/null
+++ b/services/camera/virtualcamera/util/JpegUtil.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2023 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.
+ */
+
+#ifndef ANDROID_COMPANION_VIRTUALCAMERA_JPEGUTIL_H
+#define ANDROID_COMPANION_VIRTUALCAMERA_JPEGUTIL_H
+
+#include <memory>
+
+#include "android/hardware_buffer.h"
+#include "system/graphics.h"
+
+namespace android {
+namespace companion {
+namespace virtualcamera {
+
+// Jpeg-compress image into the output buffer.
+bool compressJpeg(int width, int height, const android_ycbcr& ycbcr,
+ size_t outBufferSize, void* outBuffer);
+
+} // namespace virtualcamera
+} // namespace companion
+} // namespace android
+
+#endif // ANDROID_COMPANION_VIRTUALCAMERA_JPEGUTIL_H
diff --git a/services/camera/virtualcamera/util/MetadataBuilder.cc b/services/camera/virtualcamera/util/MetadataBuilder.cc
new file mode 100644
index 0000000..fb06e31
--- /dev/null
+++ b/services/camera/virtualcamera/util/MetadataBuilder.cc
@@ -0,0 +1,325 @@
+/*
+ * Copyright (C) 2023 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_NDEBUG 0
+#define LOG_TAG "MetadataBuilder"
+
+#include "MetadataBuilder.h"
+
+#include <algorithm>
+#include <cstdint>
+#include <iterator>
+#include <memory>
+#include <utility>
+#include <variant>
+#include <vector>
+
+#include "CameraMetadata.h"
+#include "aidl/android/hardware/camera/device/CameraMetadata.h"
+#include "log/log.h"
+#include "system/camera_metadata.h"
+#include "utils/Errors.h"
+
+namespace android {
+namespace companion {
+namespace virtualcamera {
+
+namespace {
+
+using ::android::hardware::camera::common::helper::CameraMetadata;
+
+template <typename To, typename From>
+std::vector<To> convertTo(const std::vector<From>& from) {
+ std::vector<To> to;
+ to.reserve(from.size());
+ std::transform(from.begin(), from.end(), std::back_inserter(to),
+ [](const From& x) { return static_cast<To>(x); });
+ return to;
+}
+
+} // namespace
+
+MetadataBuilder& MetadataBuilder::setSupportedHardwareLevel(
+ camera_metadata_enum_android_info_supported_hardware_level_t hwLevel) {
+ mEntryMap[ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL] =
+ std::vector<uint8_t>({static_cast<uint8_t>(hwLevel)});
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setFlashAvailable(bool flashAvailable) {
+ const uint8_t metadataVal = flashAvailable
+ ? ANDROID_FLASH_INFO_AVAILABLE_TRUE
+ : ANDROID_FLASH_INFO_AVAILABLE_FALSE;
+ mEntryMap[ANDROID_FLASH_INFO_AVAILABLE] = std::vector<uint8_t>({metadataVal});
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setLensFacing(
+ camera_metadata_enum_android_lens_facing lensFacing) {
+ mEntryMap[ANDROID_LENS_FACING] =
+ std::vector<uint8_t>({static_cast<uint8_t>(lensFacing)});
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setSensorOrientation(int32_t sensorOrientation) {
+ mEntryMap[ANDROID_SENSOR_ORIENTATION] =
+ std::vector<int32_t>({sensorOrientation});
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setSensorTimestamp(
+ std::chrono::nanoseconds timestamp) {
+ mEntryMap[ANDROID_SENSOR_TIMESTAMP] =
+ std::vector<int64_t>({timestamp.count()});
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setAvailableFaceDetectModes(
+ const std::vector<camera_metadata_enum_android_statistics_face_detect_mode_t>&
+ faceDetectModes) {
+ mEntryMap[ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES] =
+ convertTo<uint8_t>(faceDetectModes);
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setControlAfAvailableModes(
+ const std::vector<camera_metadata_enum_android_control_af_mode_t>&
+ availableModes) {
+ mEntryMap[ANDROID_CONTROL_AF_AVAILABLE_MODES] =
+ convertTo<uint8_t>(availableModes);
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setControlAfMode(
+ const camera_metadata_enum_android_control_af_mode_t mode) {
+ mEntryMap[ANDROID_CONTROL_AF_MODE] =
+ std::vector<uint8_t>({static_cast<uint8_t>(mode)});
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setControlAeAvailableFpsRange(
+ const int32_t minFps, const int32_t maxFps) {
+ mEntryMap[ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES] =
+ std::vector<int32_t>({minFps, maxFps});
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setControlMaxRegions(int32_t maxAeRegions,
+ int32_t maxAwbRegions,
+ int32_t maxAfRegions) {
+ mEntryMap[ANDROID_CONTROL_MAX_REGIONS] =
+ std::vector<int32_t>({maxAeRegions, maxAwbRegions, maxAfRegions});
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setControlAeRegions(
+ const std::vector<ControlRegion>& aeRegions) {
+ std::vector<int32_t> regions;
+ regions.reserve(5 * aeRegions.size());
+ for (const ControlRegion& region : aeRegions) {
+ regions.push_back(region.x0);
+ regions.push_back(region.y0);
+ regions.push_back(region.x1);
+ regions.push_back(region.y1);
+ regions.push_back(region.weight);
+ }
+ mEntryMap[ANDROID_CONTROL_AE_REGIONS] = std::move(regions);
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setControlAfRegions(
+ const std::vector<ControlRegion>& afRegions) {
+ std::vector<int32_t> regions;
+ regions.reserve(5 * afRegions.size());
+ for (const ControlRegion& region : afRegions) {
+ regions.push_back(region.x0);
+ regions.push_back(region.y0);
+ regions.push_back(region.x1);
+ regions.push_back(region.y1);
+ regions.push_back(region.weight);
+ }
+ mEntryMap[ANDROID_CONTROL_AF_REGIONS] = std::move(regions);
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setControlAwbRegions(
+ const std::vector<ControlRegion>& awbRegions) {
+ std::vector<int32_t> regions;
+ regions.reserve(5 * awbRegions.size());
+ for (const ControlRegion& region : awbRegions) {
+ regions.push_back(region.x0);
+ regions.push_back(region.y0);
+ regions.push_back(region.x1);
+ regions.push_back(region.y1);
+ regions.push_back(region.weight);
+ }
+ mEntryMap[ANDROID_CONTROL_AWB_REGIONS] = std::move(regions);
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setControlCaptureIntent(
+ const camera_metadata_enum_android_control_capture_intent_t intent) {
+ mEntryMap[ANDROID_CONTROL_CAPTURE_INTENT] =
+ std::vector<uint8_t>({static_cast<uint8_t>(intent)});
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setMaxJpegSize(const int32_t size) {
+ mEntryMap[ANDROID_JPEG_MAX_SIZE] = std::vector<int32_t>({size});
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setAvailableOutputStreamConfigurations(
+ const std::vector<StreamConfiguration>& streamConfigurations) {
+ std::vector<int32_t> metadataStreamConfigs;
+ std::vector<int64_t> metadataMinFrameDurations;
+ std::vector<int64_t> metadataStallDurations;
+ metadataStreamConfigs.reserve(streamConfigurations.size());
+ metadataMinFrameDurations.reserve(streamConfigurations.size());
+ metadataStallDurations.reserve(streamConfigurations.size());
+
+ for (const auto& config : streamConfigurations) {
+ metadataStreamConfigs.push_back(config.format);
+ metadataStreamConfigs.push_back(config.width);
+ metadataStreamConfigs.push_back(config.height);
+ metadataStreamConfigs.push_back(
+ ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT);
+
+ metadataMinFrameDurations.push_back(config.format);
+ metadataMinFrameDurations.push_back(config.width);
+ metadataMinFrameDurations.push_back(config.height);
+ metadataMinFrameDurations.push_back(config.minFrameDuration.count());
+
+ metadataStallDurations.push_back(config.format);
+ metadataStallDurations.push_back(config.width);
+ metadataStallDurations.push_back(config.height);
+ metadataStallDurations.push_back(config.minStallDuration.count());
+ }
+
+ mEntryMap[ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS] =
+ metadataStreamConfigs;
+ mEntryMap[ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS] =
+ metadataMinFrameDurations;
+ mEntryMap[ANDROID_SCALER_AVAILABLE_STALL_DURATIONS] =
+ metadataMinFrameDurations;
+
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setAvailableMaxDigitalZoom(const float maxZoom) {
+ mEntryMap[ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM] =
+ std::vector<float>(maxZoom);
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setSensorActiveArraySize(int x0, int y0,
+ int x1, int y1) {
+ mEntryMap[ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE] =
+ std::vector<int32_t>({x0, y0, x1, y1});
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setControlAeCompensationRange(int32_t min,
+ int32_t max) {
+ mEntryMap[ANDROID_CONTROL_AE_COMPENSATION_RANGE] =
+ std::vector<int32_t>({min, max});
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setControlAeCompensationStep(
+ const camera_metadata_rational step) {
+ mEntryMap[ANDROID_CONTROL_AE_COMPENSATION_STEP] =
+ std::vector<camera_metadata_rational>({step});
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setAvailableRequestKeys(
+ const std::vector<int32_t>& keys) {
+ mEntryMap[ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS] = keys;
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setAvailableResultKeys(
+ const std::vector<int32_t>& keys) {
+ mEntryMap[ANDROID_REQUEST_AVAILABLE_RESULT_KEYS] = keys;
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setAvailableCapabilities(
+ const std::vector<camera_metadata_enum_android_request_available_capabilities_t>&
+ capabilities) {
+ mEntryMap[ANDROID_REQUEST_AVAILABLE_CAPABILITIES] =
+ convertTo<uint8_t>(capabilities);
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setAvailableCharacteristicKeys(
+ const std::vector<camera_metadata_tag_t>& keys) {
+ mEntryMap[ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS] =
+ convertTo<int32_t>(keys);
+ return *this;
+}
+
+MetadataBuilder& MetadataBuilder::setAvailableCharacteristicKeys() {
+ std::vector<camera_metadata_tag_t> availableKeys;
+ availableKeys.reserve(mEntryMap.size());
+ for (const auto& [key, _] : mEntryMap) {
+ if (key != ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS) {
+ availableKeys.push_back(key);
+ }
+ }
+ setAvailableCharacteristicKeys(availableKeys);
+ return *this;
+}
+
+std::unique_ptr<aidl::android::hardware::camera::device::CameraMetadata>
+MetadataBuilder::build() const {
+ CameraMetadata metadataHelper;
+ for (const auto& entry : mEntryMap) {
+ status_t ret = std::visit(
+ [&](auto&& arg) {
+ return metadataHelper.update(entry.first, arg.data(), arg.size());
+ },
+ entry.second);
+ if (ret != NO_ERROR) {
+ ALOGE("Failed to update metadata with key %d - %s: %s", entry.first,
+ get_camera_metadata_tag_name(entry.first),
+ ::android::statusToString(ret).c_str());
+ return nullptr;
+ }
+ }
+
+ const camera_metadata_t* metadata = metadataHelper.getAndLock();
+ if (metadata == nullptr) {
+ ALOGE(
+ "Failure when constructing metadata -> CameraMetadata helper returned "
+ "nullptr");
+ return nullptr;
+ }
+
+ auto aidlMetadata =
+ std::make_unique<aidl::android::hardware::camera::device::CameraMetadata>();
+ const uint8_t* data_ptr = reinterpret_cast<const uint8_t*>(metadata);
+ aidlMetadata->metadata.assign(data_ptr,
+ data_ptr + get_camera_metadata_size(metadata));
+ metadataHelper.unlock(metadata);
+
+ return aidlMetadata;
+}
+
+} // namespace virtualcamera
+} // namespace companion
+} // namespace android
diff --git a/services/camera/virtualcamera/util/MetadataBuilder.h b/services/camera/virtualcamera/util/MetadataBuilder.h
new file mode 100644
index 0000000..25c931c
--- /dev/null
+++ b/services/camera/virtualcamera/util/MetadataBuilder.h
@@ -0,0 +1,196 @@
+/*
+ * Copyright (C) 2023 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.
+ */
+
+#ifndef ANDROID_COMPANION_VIRTUALCAMERA_METADATABUILDER_H
+#define ANDROID_COMPANION_VIRTUALCAMERA_METADATABUILDER_H
+
+#include <chrono>
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <variant>
+#include <vector>
+
+#include "aidl/android/hardware/camera/device/CameraMetadata.h"
+#include "system/camera_metadata.h"
+
+namespace android {
+namespace companion {
+namespace virtualcamera {
+
+// Convenience builder for the
+// aidl::android::hardware::camera::device::CameraMetadata.
+//
+// Calling the same builder setter multiple will overwrite the value.
+// This class is not thread-safe.
+class MetadataBuilder {
+ public:
+ struct StreamConfiguration {
+ int32_t width = 0;
+ int32_t height = 0;
+ int32_t format = 0;
+ // Minimal frame duration - corresponds to maximal FPS for given format.
+ // See ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS in CameraMetadataTag.aidl.
+ std::chrono::nanoseconds minFrameDuration{std::chrono::seconds(1) / 30};
+ // Minimal stall duration.
+ // See ANDROID_SCALER_AVAILABLE_STALL_DURATIONS in CameraMetadataTag.aidl.
+ std::chrono::nanoseconds minStallDuration{0};
+ };
+
+ struct ControlRegion {
+ int32_t x0 = 0;
+ int32_t y0 = 0;
+ int32_t x1 = 0;
+ int32_t y1 = 0;
+ int32_t weight = 0;
+ };
+
+ MetadataBuilder() = default;
+ ~MetadataBuilder() = default;
+
+ // See ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL in CameraMetadataTag.aidl.
+ MetadataBuilder& setSupportedHardwareLevel(
+ camera_metadata_enum_android_info_supported_hardware_level_t hwLevel);
+
+ // Whether this camera device has a flash unit
+ // See ANDROID_FLASH_INFO_AVAILABLE in CameraMetadataTag.aidl.
+ MetadataBuilder& setFlashAvailable(bool flashAvailable);
+
+ // See ANDROID_LENS_FACING in CameraMetadataTag.aidl.
+ MetadataBuilder& setLensFacing(
+ camera_metadata_enum_android_lens_facing lensFacing);
+
+ // See ANDROID_SENSOR_ORIENTATION in CameraMetadataTag.aidl.
+ MetadataBuilder& setSensorOrientation(int32_t sensorOrientation);
+
+ // Time at start of exposure of first row of the image
+ // sensor active array, in nanoseconds.
+ //
+ // See ANDROID_SENSOR_TIMESTAMP in CameraMetadataTag.aidl.
+ MetadataBuilder& setSensorTimestamp(std::chrono::nanoseconds timestamp);
+
+ // See ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE in CameraMetadataTag.aidl.
+ MetadataBuilder& setSensorActiveArraySize(int x0, int y0, int x1, int y1);
+
+ // See ANDROID_STATISTICS_FACE_DETECT_MODE in CameraMetadataTag.aidl.
+ MetadataBuilder& setAvailableFaceDetectModes(
+ const std::vector<camera_metadata_enum_android_statistics_face_detect_mode_t>&
+ faceDetectMode);
+
+ // Sets available stream configurations along with corresponding minimal frame
+ // durations (corresponding to max fps) and stall durations.
+ //
+ // See ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
+ // ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS and
+ // ANDROID_SCALER_AVAILABLE_STALL_DURATIONS in CameraMetadataTag.aidl.
+ MetadataBuilder& setAvailableOutputStreamConfigurations(
+ const std::vector<StreamConfiguration>& streamConfigurations);
+
+ // See ANDROID_CONTROL_AE_COMPENSATION_RANGE in CameraMetadataTag.aidl.
+ MetadataBuilder& setControlAeCompensationRange(int32_t min, int32_t max);
+
+ // See ANDROID_CONTROL_AE_COMPENSATION_STEP in CameraMetadataTag.aidl.
+ MetadataBuilder& setControlAeCompensationStep(camera_metadata_rational step);
+
+ // See ANDROID_CONTROL_AF_AVAILABLE_MODES in CameraMetadataTag.aidl.
+ MetadataBuilder& setControlAfAvailableModes(
+ const std::vector<camera_metadata_enum_android_control_af_mode_t>&
+ availableModes);
+
+ // See ANDROID_CONTROL_AF_MODE in CameraMetadataTag.aidl.
+ MetadataBuilder& setControlAfMode(
+ const camera_metadata_enum_android_control_af_mode_t mode);
+
+ // See ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES in CameraMetadataTag.aidl.
+ MetadataBuilder& setControlAeAvailableFpsRange(int32_t min, int32_t max);
+
+ // See ANDROID_CONTROL_CAPTURE_INTENT in CameraMetadataTag.aidl.
+ MetadataBuilder& setControlCaptureIntent(
+ camera_metadata_enum_android_control_capture_intent_t intent);
+
+ // See ANDROID_CONTROL_MAX_REGIONS in CameraMetadataTag.aidl.
+ MetadataBuilder& setControlMaxRegions(int32_t maxAeRegions,
+ int32_t maxAwbRegions,
+ int32_t maxAfRegions);
+
+ // See ANDROID_CONTROL_AE_REGIONS in CameraMetadataTag.aidl.
+ MetadataBuilder& setControlAeRegions(
+ const std::vector<ControlRegion>& aeRegions);
+
+ // See ANDROID_CONTROL_AWB_REGIONS in CameraMetadataTag.aidl.
+ MetadataBuilder& setControlAwbRegions(
+ const std::vector<ControlRegion>& awbRegions);
+
+ // See ANDROID_CONTROL_AF_REGIONS in CameraMetadataTag.aidl.
+ MetadataBuilder& setControlAfRegions(
+ const std::vector<ControlRegion>& afRegions);
+
+ // The size of the compressed JPEG image, in bytes.
+ //
+ // See ANDROID_JPEG_SIZE in CameraMetadataTag.aidl.
+ MetadataBuilder& setMaxJpegSize(int32_t size);
+
+ // See ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM in CameraMetadataTag.aidl.
+ MetadataBuilder& setAvailableMaxDigitalZoom(const float maxZoom);
+
+ // A list of all keys that the camera device has available to use with
+ // CaptureRequest.
+ //
+ // See ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS in CameraMetadataTag.aidl.
+ MetadataBuilder& setAvailableRequestKeys(const std::vector<int32_t>& keys);
+
+ // A list of all keys that the camera device has available to use with
+ // CaptureResult.
+ //
+ // See ANDROID_RESULT_AVAILABLE_REQUEST_KEYS in CameraMetadataTag.aidl.
+ MetadataBuilder& setAvailableResultKeys(const std::vector<int32_t>& keys);
+
+ // See ANDROID_REQUEST_AVAILABLE_CAPABILITIES in CameraMetadataTag.aidl.
+ MetadataBuilder& setAvailableCapabilities(
+ const std::vector<
+ camera_metadata_enum_android_request_available_capabilities_t>&
+ capabilities);
+
+ // A list of all keys that the camera device has available to use.
+ //
+ // See ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS in CameraMetadataTag.aidl.
+ MetadataBuilder& setAvailableCharacteristicKeys(
+ const std::vector<camera_metadata_tag_t>& keys);
+
+ // Extends metadata with ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS
+ // containing all previously set tags.
+ MetadataBuilder& setAvailableCharacteristicKeys();
+
+ // Build CameraMetadata instance.
+ //
+ // Returns nullptr in case something went wrong.
+ std::unique_ptr<::aidl::android::hardware::camera::device::CameraMetadata>
+ build() const;
+
+ private:
+ // Maps metadata tags to vectors of values for the given tag.
+ std::map<camera_metadata_tag_t,
+ std::variant<std::vector<int64_t>, std::vector<int32_t>,
+ std::vector<uint8_t>, std::vector<float>,
+ std::vector<camera_metadata_rational_t>>>
+ mEntryMap;
+};
+
+} // namespace virtualcamera
+} // namespace companion
+} // namespace android
+
+#endif // ANDROID_COMPANION_VIRTUALCAMERA_METADATABUILDER_H
diff --git a/services/camera/virtualcamera/util/TestPatternHelper.cc b/services/camera/virtualcamera/util/TestPatternHelper.cc
new file mode 100644
index 0000000..a00a1b8
--- /dev/null
+++ b/services/camera/virtualcamera/util/TestPatternHelper.cc
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2023 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_NDEBUG 0
+#define LOG_TAG "TestPatternHelper"
+
+#include "TestPatternHelper.h"
+
+#include <complex>
+#include <cstdint>
+
+#include "log/log.h"
+#include "utils/Errors.h"
+
+namespace android {
+namespace companion {
+namespace virtualcamera {
+
+namespace {
+
+uint8_t julia(const std::complex<float> n, const std::complex<float> c) {
+ std::complex<float> z = n;
+ for (int i = 0; i < 64; i++) {
+ z = z * z + c;
+ if (std::abs(z) > 2.0) return i * 4;
+ }
+ return 0xff;
+}
+
+uint8_t pixelToFractal(const int x, const int y, const std::complex<float> c) {
+ std::complex<float> n(float(x) / 640.0f - 0.5, float(y) / 480.0f - 0.5);
+ return julia(n * 5.f, c);
+}
+
+void renderTestPatternYcbCr420(uint8_t* data_ptr, const int width,
+ const int height, const int frameNumber) {
+ float time = float(frameNumber) / 120.0f;
+ const std::complex<float> c(std::sin(time), std::cos(time));
+
+ uint8_t* y_data = data_ptr;
+ uint8_t* uv_data = static_cast<uint8_t*>(y_data + width * height);
+
+ for (int i = 0; i < width; ++i) {
+ for (int j = 0; j < height; ++j) {
+ y_data[j * width + i] = pixelToFractal(i, j, c * 0.78f);
+ if ((i & 1) && (j & 1)) {
+ uv_data[((j / 2) * (width / 2) + i / 2) * 2] =
+ static_cast<uint8_t>((float(i) / float(width)) * 255.f);
+ uv_data[((j / 2) * (width / 2) + i / 2) * 2 + 1] =
+ static_cast<uint8_t>((float(j) / float(height)) * 255.f);
+ }
+ }
+ }
+}
+
+} // namespace
+
+// This is just to see some meaningfull image in the buffer for testing, only
+// works with YcbCr420.
+void renderTestPatternYCbCr420(const std::shared_ptr<AHardwareBuffer> buffer,
+ const int frameNumber, const int fence) {
+ AHardwareBuffer_Planes planes_info;
+
+ AHardwareBuffer_Desc hwBufferDesc;
+ AHardwareBuffer_describe(buffer.get(), &hwBufferDesc);
+
+ const int width = hwBufferDesc.width;
+ const int height = hwBufferDesc.height;
+
+ int result = AHardwareBuffer_lockPlanes(buffer.get(),
+ AHARDWAREBUFFER_USAGE_CPU_READ_RARELY,
+ fence, nullptr, &planes_info);
+ if (result != OK) {
+ ALOGE("%s: Failed to lock planes: %d", __func__, result);
+ return;
+ }
+
+ renderTestPatternYcbCr420(
+ reinterpret_cast<uint8_t*>(planes_info.planes[0].data), width, height,
+ frameNumber);
+
+ AHardwareBuffer_unlock(buffer.get(), nullptr);
+}
+
+void renderTestPatternYCbCr420(sp<Surface> surface, int frameNumber) {
+ ANativeWindow_Buffer buffer;
+ surface->lock(&buffer, nullptr);
+
+ ALOGV("buffer: %dx%d stride %d, pixfmt %d", buffer.width, buffer.height,
+ buffer.stride, buffer.format);
+
+ renderTestPatternYcbCr420(reinterpret_cast<uint8_t*>(buffer.bits),
+ buffer.width, buffer.height, frameNumber);
+
+ surface->unlockAndPost();
+}
+
+} // namespace virtualcamera
+} // namespace companion
+} // namespace android
diff --git a/services/camera/virtualcamera/util/TestPatternHelper.h b/services/camera/virtualcamera/util/TestPatternHelper.h
new file mode 100644
index 0000000..aca1cdd
--- /dev/null
+++ b/services/camera/virtualcamera/util/TestPatternHelper.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2023 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.
+ */
+
+#ifndef ANDROID_COMPANION_VIRTUALCAMERA_TESTPATTERNHELPER_H
+#define ANDROID_COMPANION_VIRTUALCAMERA_TESTPATTERNHELPER_H
+
+#include <memory>
+
+#include "android/hardware_buffer.h"
+#include "gui/Surface.h"
+
+namespace android {
+namespace companion {
+namespace virtualcamera {
+
+// Helper function filling hardware buffer with test pattern for debugging /
+// testing purposes.
+void renderTestPatternYCbCr420(std::shared_ptr<AHardwareBuffer> buffer,
+ int frameNumber, int fence = -1);
+
+// Helper function for rendering test pattern into Surface.
+void renderTestPatternYCbCr420(sp<Surface> surface, int frameNumber);
+
+} // namespace virtualcamera
+} // namespace companion
+} // namespace android
+
+#endif // ANDROID_COMPANION_VIRTUALCAMERA_TESTPATTERNHELPER_H
diff --git a/services/camera/virtualcamera/util/Util.cc b/services/camera/virtualcamera/util/Util.cc
new file mode 100644
index 0000000..90f5916
--- /dev/null
+++ b/services/camera/virtualcamera/util/Util.cc
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2023 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_NDEBUG 0
+#define LOG_TAG "VirtualCameraUtil"
+#include "Util.h"
+
+#include <unistd.h>
+
+#include "log/log.h"
+
+namespace android {
+namespace companion {
+namespace virtualcamera {
+
+using ::aidl::android::hardware::common::NativeHandle;
+
+sp<Fence> importFence(const NativeHandle& aidlHandle) {
+ if (aidlHandle.fds.size() != 1) {
+ ALOGE(
+ "%s: Cannot import fence from aidlHandle containing %d file "
+ "descriptors.",
+ __func__, static_cast<int>(aidlHandle.fds.size()));
+ return sp<Fence>::make();
+ }
+
+ return sp<Fence>::make(::dup(aidlHandle.fds[0].get()));
+}
+
+} // namespace virtualcamera
+} // namespace companion
+} // namespace android
diff --git a/services/camera/virtualcamera/util/Util.h b/services/camera/virtualcamera/util/Util.h
new file mode 100644
index 0000000..1a0a458
--- /dev/null
+++ b/services/camera/virtualcamera/util/Util.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2023 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.
+ */
+
+#ifndef ANDROID_COMPANION_VIRTUALCAMERA_UTIL_H
+#define ANDROID_COMPANION_VIRTUALCAMERA_UTIL_H
+
+#include <cstdint>
+
+#include "aidl/android/hardware/camera/common/Status.h"
+#include "aidl/android/hardware/camera/device/StreamBuffer.h"
+#include "android/binder_auto_utils.h"
+#include "ui/Fence.h"
+
+namespace android {
+namespace companion {
+namespace virtualcamera {
+
+// Converts camera AIDL status to ndk::ScopedAStatus
+inline ndk::ScopedAStatus cameraStatus(
+ const ::aidl::android::hardware::camera::common::Status status) {
+ return ndk::ScopedAStatus::fromServiceSpecificError(
+ static_cast<int32_t>(status));
+}
+
+// Import Fence from AIDL NativeHandle.
+//
+// If the handle can't be used to construct Fence (is empty or doesn't contain
+// only single fd) this function will return Fence instance in invalid state.
+sp<Fence> importFence(
+ const ::aidl::android::hardware::common::NativeHandle& handle);
+
+} // namespace virtualcamera
+} // namespace companion
+} // namespace android
+
+#endif // ANDROID_COMPANION_VIRTUALCAMERA_UTIL_H