#include <stdlib.h> #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <time.h> #include <semaphore.h> #include <pthread.h> #include <string.h> #include <climits> #include <math.h> #include <gui/GLConsumer.h> #include <gui/Surface.h> #include <ui/GraphicBuffer.h> #include <ui/GraphicBufferMapper.h> #include <camera/Camera.h> #include <camera/ICamera.h> #include <media/mediarecorder.h> #include <binder/IPCThreadState.h> #include <binder/ProcessState.h> #include <binder/IServiceManager.h> #include <cutils/properties.h> #include <camera/CameraParameters.h> #include <camera/ShotParameters.h> #include <camera/CameraMetadata.h> #include <system/audio.h> #include <system/camera.h> #include <cutils/memory.h> #include <utils/Log.h> #include <sys/wait.h> #include "camera_test.h" #include "camera_test_surfacetexture.h" #define ASSERT(X) \ do { \ if(!(X)) { \ printf("error: %s():%d", __FUNCTION__, __LINE__); \ return; \ } \ } while(0); #define ALIGN_DOWN(x, n) ((x) & (~((n) - 1))) #define ALIGN_UP(x, n) ((((x) + (n) - 1)) & (~((n) - 1))) #define ALIGN_WIDTH 32 // Should be 32...but the calculated dimension causes an ion crash #define ALIGN_HEIGHT 2 // Should be 2...but the calculated dimension causes an ion crash //temporarily define format here #define HAL_PIXEL_FORMAT_TI_NV12 0x100 #define HAL_PIXEL_FORMAT_TI_Y8 0x103 #define HAL_PIXEL_FORMAT_TI_Y16 0x104 #define HAL_PIXEL_FORMAT_TI_UYVY 0x105 using namespace android; static EGLint getSurfaceWidth() { return 512; } static EGLint getSurfaceHeight() { return 512; } static size_t calcBufSize(int format, int width, int height) { int buf_size; switch (format) { case HAL_PIXEL_FORMAT_TI_NV12: buf_size = width * height * 3 /2; break; case HAL_PIXEL_FORMAT_TI_Y16: case HAL_PIXEL_FORMAT_TI_UYVY: buf_size = width * height * 2; break; // add more formats later default: buf_size = width * height * 3 /2; break; } return buf_size; } static unsigned int calcOffset(int format, unsigned int width, unsigned int top, unsigned int left) { unsigned int bpp; switch (format) { case HAL_PIXEL_FORMAT_TI_NV12: bpp = 1; break; case HAL_PIXEL_FORMAT_TI_UYVY: case HAL_PIXEL_FORMAT_TI_Y16: bpp = 2; break; // add more formats later default: bpp = 1; break; } return top * width + left * bpp; } static int getHalPixFormat(const char *format) { int pixformat = HAL_PIXEL_FORMAT_TI_NV12; if ( NULL != format ) { if ( strcmp(format, CameraParameters::PIXEL_FORMAT_BAYER_RGGB) == 0 ) { pixformat = HAL_PIXEL_FORMAT_TI_Y16; } else if ( strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420SP) == 0 ) { pixformat = HAL_PIXEL_FORMAT_TI_NV12; } else if ( strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422I) == 0 ) { pixformat = HAL_PIXEL_FORMAT_TI_UYVY; } else { pixformat = HAL_PIXEL_FORMAT_TI_NV12; } } return pixformat; } static int getUsageFromANW(int format) { int usage = GRALLOC_USAGE_SW_READ_RARELY | GRALLOC_USAGE_SW_WRITE_NEVER; switch (format) { case HAL_PIXEL_FORMAT_TI_NV12: case HAL_PIXEL_FORMAT_TI_Y16: // This usage flag indicates to gralloc we want the // buffers to come from system heap usage |= GRALLOC_USAGE_PRIVATE_0; break; default: // No special flags needed break; } return usage; } static status_t writeCroppedNV12(unsigned int offset, unsigned int stride, unsigned int bufWidth, unsigned int bufHeight, const Rect &crop, int fd, unsigned char *buffer) { unsigned char *luma = NULL, *chroma = NULL, *src = NULL; unsigned int uvoffset; int write_size; if (!buffer || !crop.isValid()) { return BAD_VALUE; } src = buffer; // offset to beginning of uv plane uvoffset = stride * bufHeight; // offset to beginning of valid region of uv plane uvoffset += (offset - (offset % stride)) / 2 + (offset % stride); // start of valid luma region luma = src + offset; // start of valid chroma region chroma = src + uvoffset; // write luma line x line unsigned int height = crop.height(); unsigned int width = crop.width(); write_size = width; for (unsigned int i = 0; i < height; i++) { if (write_size != write(fd, luma, width)) { printf("Bad Write error (%d)%s\n", errno, strerror(errno)); return UNKNOWN_ERROR; } luma += stride; } // write chroma line x line height /= 2; write_size = width; for (unsigned int i = 0; i < height; i++) { if (write_size != write(fd, chroma, width)) { printf("Bad Write error (%d)%s\n", errno, strerror(errno)); return UNKNOWN_ERROR; } chroma += stride; } return NO_ERROR; } static status_t writeCroppedUYVY(unsigned int offset, unsigned int stride, unsigned int bufWidth, unsigned int bufHeight, const Rect &crop, int fd, unsigned char *buffer) { unsigned char *src = NULL; int write_size; if (!buffer) { return BAD_VALUE; } src = buffer + offset; int height = crop.height(); int width = crop.width(); write_size = width*2; for (unsigned int i = 0; i < height; i++) { if (write_size != write(fd, src, width*2)) { printf("Bad Write error (%d)%s\n", errno, strerror(errno)); return UNKNOWN_ERROR; } src += stride*2; } return NO_ERROR; } static status_t copyCroppedNV12(unsigned int offset, unsigned int strideSrc, unsigned int strideDst, unsigned int bufWidth, unsigned int bufHeight, const Rect &crop, void *bufferSrc, void *bufferDst) { unsigned char *lumaSrc = NULL, *chromaSrc = NULL; unsigned char *lumaDst = NULL, *chromaDst = NULL; unsigned int uvoffset; int write_size; if (!bufferSrc || !bufferDst) { return BAD_VALUE; } uvoffset = strideSrc * crop.height(); uvoffset += (offset - (offset % strideSrc)) / 2 + (offset % strideSrc); lumaSrc = static_cast<unsigned char *>(bufferSrc) + offset; chromaSrc = static_cast<unsigned char *>(bufferSrc) + uvoffset; int height = crop.height(); int width = crop.width(); uvoffset = strideDst * height; lumaDst = static_cast<unsigned char *>(bufferDst); chromaDst = static_cast<unsigned char *>(bufferDst) + uvoffset; write_size = width; for (unsigned int i = 0; i < height; i++) { memcpy(lumaDst, lumaSrc, width); lumaSrc += strideSrc; lumaDst += strideDst; } height /= 2; write_size = width; for (unsigned int i = 0; i < height; i++) { memcpy(chromaDst, chromaSrc, width); chromaSrc += strideSrc; chromaDst += strideDst; } return NO_ERROR; } static status_t copyCroppedPacked16(unsigned int offset, unsigned int stride, unsigned int bufWidth, unsigned int bufHeight, const Rect &crop, void *bufferSrc, void *bufferDst) { unsigned char *src = NULL, *dst = NULL; if (!bufferSrc || !bufferDst) { return BAD_VALUE; } src = static_cast<unsigned char *>(bufferSrc) + offset; dst = static_cast<unsigned char *>(bufferDst); int height = crop.height(); int width = crop.width(); for (unsigned int i = 0; i < height; i++) { memcpy(dst, src, width*2); src += stride*2; dst += width*2; } return NO_ERROR; } void GLSurface::initialize(int display) { mEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY); ASSERT(EGL_SUCCESS == eglGetError()); ASSERT(EGL_NO_DISPLAY != mEglDisplay); EGLint majorVersion; EGLint minorVersion; ASSERT(eglInitialize(mEglDisplay, &majorVersion, &minorVersion)); ASSERT(EGL_SUCCESS == eglGetError()); EGLint numConfigs = 0; ASSERT(eglChooseConfig(mEglDisplay, getConfigAttribs(), &mGlConfig, 1, &numConfigs)); ASSERT(EGL_SUCCESS == eglGetError()); if (display) { mComposerClient = new SurfaceComposerClient; ASSERT(NO_ERROR == mComposerClient->initCheck()); mSurfaceControl = mComposerClient->createSurface( String8("Test Surface"), 0, 800, 480, HAL_PIXEL_FORMAT_YCrCb_420_SP, 0); ASSERT(mSurfaceControl != NULL); ASSERT(mSurfaceControl->isValid()); SurfaceComposerClient::openGlobalTransaction(); ASSERT(NO_ERROR == mSurfaceControl->setLayer(0x7FFFFFFF)); ASSERT(NO_ERROR == mSurfaceControl->show()); SurfaceComposerClient::closeGlobalTransaction(); sp<ANativeWindow> window = mSurfaceControl->getSurface(); mEglSurface = eglCreateWindowSurface(mEglDisplay, mGlConfig, window.get(), NULL); } else { EGLint pbufferAttribs[] = { EGL_WIDTH, getSurfaceWidth(), EGL_HEIGHT, getSurfaceHeight(), EGL_NONE }; mEglSurface = eglCreatePbufferSurface(mEglDisplay, mGlConfig, pbufferAttribs); } ASSERT(EGL_SUCCESS == eglGetError()); ASSERT(EGL_NO_SURFACE != mEglSurface); mEglContext = eglCreateContext(mEglDisplay, mGlConfig, EGL_NO_CONTEXT, getContextAttribs()); ASSERT(EGL_SUCCESS == eglGetError()); ASSERT(EGL_NO_CONTEXT != mEglContext); ASSERT(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)); ASSERT(EGL_SUCCESS == eglGetError()); EGLint w, h; ASSERT(eglQuerySurface(mEglDisplay, mEglSurface, EGL_WIDTH, &w)); ASSERT(EGL_SUCCESS == eglGetError()); ASSERT(eglQuerySurface(mEglDisplay, mEglSurface, EGL_HEIGHT, &h)); ASSERT(EGL_SUCCESS == eglGetError()); glViewport(0, 0, w, h); ASSERT(GLenum(GL_NO_ERROR) == glGetError()); } void GLSurface::deinit() { if (mComposerClient != NULL) { mComposerClient->dispose(); } if (mEglContext != EGL_NO_CONTEXT) { eglDestroyContext(mEglDisplay, mEglContext); } if (mEglSurface != EGL_NO_SURFACE) { eglDestroySurface(mEglDisplay, mEglSurface); } if (mEglDisplay != EGL_NO_DISPLAY) { eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); eglTerminate(mEglDisplay); } ASSERT(EGL_SUCCESS == eglGetError()); } EGLint const* GLSurface::getConfigAttribs() { static EGLint sDefaultConfigAttribs[] = { 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, EGL_ALPHA_SIZE, 8, EGL_DEPTH_SIZE, 16, EGL_STENCIL_SIZE, 8, EGL_NONE }; return sDefaultConfigAttribs; } EGLint const* GLSurface::getContextAttribs() { static EGLint sDefaultContextAttribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE }; return sDefaultContextAttribs; } void GLSurface::loadShader(GLenum shaderType, const char* pSource, GLuint* outShader) { GLuint shader = glCreateShader(shaderType); ASSERT(GLenum(GL_NO_ERROR) == glGetError()); if (shader) { glShaderSource(shader, 1, &pSource, NULL); ASSERT(GLenum(GL_NO_ERROR) == glGetError()); glCompileShader(shader); ASSERT(GLenum(GL_NO_ERROR) == glGetError()); GLint compiled = 0; glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled); ASSERT(GLenum(GL_NO_ERROR) == glGetError()); if (!compiled) { GLint infoLen = 0; glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen); ASSERT(GLenum(GL_NO_ERROR) == glGetError()); if (infoLen) { char* buf = (char*) malloc(infoLen); if (buf) { glGetShaderInfoLog(shader, infoLen, NULL, buf); printf("Shader compile log:\n%s\n", buf); free(buf); } } else { char* buf = (char*) malloc(0x1000); if (buf) { glGetShaderInfoLog(shader, 0x1000, NULL, buf); printf("Shader compile log:\n%s\n", buf); free(buf); } } glDeleteShader(shader); shader = 0; } } ASSERT(shader != 0); *outShader = shader; } void GLSurface::createProgram(const char* pVertexSource, const char* pFragmentSource, GLuint* outPgm) { GLuint vertexShader, fragmentShader; { loadShader(GL_VERTEX_SHADER, pVertexSource, &vertexShader); } { loadShader(GL_FRAGMENT_SHADER, pFragmentSource, &fragmentShader); } GLuint program = glCreateProgram(); ASSERT(GLenum(GL_NO_ERROR) == glGetError()); if (program) { glAttachShader(program, vertexShader); ASSERT(GLenum(GL_NO_ERROR) == glGetError()); glAttachShader(program, fragmentShader); ASSERT(GLenum(GL_NO_ERROR) == glGetError()); glLinkProgram(program); GLint linkStatus = GL_FALSE; glGetProgramiv(program, GL_LINK_STATUS, &linkStatus); if (linkStatus != GL_TRUE) { GLint bufLength = 0; glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength); if (bufLength) { char* buf = (char*) malloc(bufLength); if (buf) { glGetProgramInfoLog(program, bufLength, NULL, buf); printf("Program link log:\n%s\n", buf); free(buf); } } glDeleteProgram(program); program = 0; } } glDeleteShader(vertexShader); glDeleteShader(fragmentShader); ASSERT(program != 0); *outPgm = program; } // GLConsumer specific sp<GLConsumer> SurfaceTextureBase::getST() { return mST; } void SurfaceTextureBase::initialize(int tex_id, EGLenum tex_target) { mTexId = tex_id; sp<BufferQueue> bq = new BufferQueue(); mST = new GLConsumer(bq, tex_id, tex_target); mSTC = new Surface(mST); mANW = mSTC; } void SurfaceTextureBase::deinit() { mANW.clear(); mSTC.clear(); mST->abandon(); mST.clear(); } void SurfaceTextureBase::getId(const char **name) { sp<ANativeWindow> windowTapOut = mSTC; *name = NULL; if (windowTapOut.get()) { windowTapOut->perform(windowTapOut.get(), NATIVE_WINDOW_GET_ID, name); } windowTapOut.clear(); } // GLConsumer with GL specific void SurfaceTextureGL::initialize(int display, int tex_id) { GLSurface::initialize(display); SurfaceTextureBase::initialize(tex_id, GL_TEXTURE_EXTERNAL_OES); const char vsrc[] = "attribute vec4 vPosition;\n" "varying vec2 texCoords;\n" "uniform mat4 texMatrix;\n" "void main() {\n" " vec2 vTexCoords = 0.5 * (vPosition.xy + vec2(1.0, 1.0));\n" " texCoords = (texMatrix * vec4(vTexCoords, 0.0, 1.0)).xy;\n" " gl_Position = vPosition;\n" "}\n"; const char fsrc[] = "#extension GL_OES_EGL_image_external : require\n" "precision mediump float;\n" "uniform samplerExternalOES texSampler;\n" "varying vec2 texCoords;\n" "void main() {\n" " gl_FragColor = texture2D(texSampler, texCoords);\n" "}\n"; { createProgram(vsrc, fsrc, &mPgm); } mPositionHandle = glGetAttribLocation(mPgm, "vPosition"); ASSERT(GLenum(GL_NO_ERROR) == glGetError()); ASSERT(-1 != mPositionHandle); mTexSamplerHandle = glGetUniformLocation(mPgm, "texSampler"); ASSERT(GLenum(GL_NO_ERROR) == glGetError()); ASSERT(-1 != mTexSamplerHandle); mTexMatrixHandle = glGetUniformLocation(mPgm, "texMatrix"); ASSERT(GLenum(GL_NO_ERROR) == glGetError()); ASSERT(-1 != mTexMatrixHandle); } void SurfaceTextureGL::deinit() { SurfaceTextureBase::deinit(); GLSurface::deinit(); } // drawTexture draws the GLConsumer over the entire GL viewport. void SurfaceTextureGL::drawTexture() { const GLfloat triangleVertices[] = { -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f, }; glVertexAttribPointer(mPositionHandle, 2, GL_FLOAT, GL_FALSE, 0, triangleVertices); ASSERT(GLenum(GL_NO_ERROR) == glGetError()); glEnableVertexAttribArray(mPositionHandle); ASSERT(GLenum(GL_NO_ERROR) == glGetError()); glUseProgram(mPgm); glUniform1i(mTexSamplerHandle, 0); ASSERT(GLenum(GL_NO_ERROR) == glGetError()); glBindTexture(GL_TEXTURE_EXTERNAL_OES, mTexId); ASSERT(GLenum(GL_NO_ERROR) == glGetError()); // XXX: These calls are not needed for GL_TEXTURE_EXTERNAL_OES as // they're setting the defautls for that target, but when hacking things // to use GL_TEXTURE_2D they are needed to achieve the same behavior. glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR); ASSERT(GLenum(GL_NO_ERROR) == glGetError()); glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR); ASSERT(GLenum(GL_NO_ERROR) == glGetError()); glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); ASSERT(GLenum(GL_NO_ERROR) == glGetError()); glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); ASSERT(GLenum(GL_NO_ERROR) == glGetError()); GLfloat texMatrix[16]; mST->getTransformMatrix(texMatrix); glUniformMatrix4fv(mTexMatrixHandle, 1, GL_FALSE, texMatrix); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); ASSERT(GLenum(GL_NO_ERROR) == glGetError()); eglSwapBuffers(mEglDisplay, mEglSurface); } // buffer source stuff void BufferSourceThread::handleBuffer(sp<GraphicBuffer> &graphic_buffer, uint8_t *buffer, unsigned int count, const Rect &crop) { int size; buffer_info_t info; unsigned int offset = 0; int fd = -1; char fn[256]; if (!graphic_buffer.get()) { printf("Invalid graphic_buffer!\n"); return; } size = calcBufSize((int)graphic_buffer->getPixelFormat(), graphic_buffer->getWidth(), graphic_buffer->getHeight()); if (size <= 0) { printf("Can't get size!\n"); return; } if (!buffer) { printf("Invalid mapped buffer!\n"); return; } info.size = size; info.width = graphic_buffer->getWidth(); info.height = graphic_buffer->getHeight(); info.format = graphic_buffer->getPixelFormat(); info.buf = graphic_buffer; info.crop = crop; { Mutex::Autolock lock(mReturnedBuffersMutex); if (mReturnedBuffers.size() >= kReturnedBuffersMaxCapacity) mReturnedBuffers.removeAt(0); } // re-calculate size and offset size = calcBufSize((int) graphic_buffer->getPixelFormat(), crop.width(), crop.height()); offset = calcOffset((int) graphic_buffer->getPixelFormat(), info.width, crop.top, crop.left); // Do not write buffer to file if we are streaming capture // It adds too much latency if (!mRestartCapture) { fn[0] = 0; sprintf(fn, "/sdcard/img%03d.raw", count); fd = open(fn, O_CREAT | O_WRONLY | O_TRUNC, 0777); if (fd >= 0) { if (HAL_PIXEL_FORMAT_TI_NV12 == info.format) { writeCroppedNV12(offset, info.width, info.width, info.height, crop, fd, buffer); } else if (HAL_PIXEL_FORMAT_TI_UYVY == info.format) { writeCroppedUYVY(offset, info.width, info.width, info.height, crop, fd, buffer); } else if (size != write(fd, buffer + offset, size)) { printf("Bad Write int a %s error (%d)%s\n", fn, errno, strerror(errno)); } printf("%s: buffer=%08X, size=%d stored at %s\n" "\tRect: top[%d] left[%d] right[%d] bottom[%d] width[%d] height[%d] offset[%d] stride[%d]\n", __FUNCTION__, (int)buffer, size, fn, crop.top, crop.left, crop.right, crop.bottom, crop.width(), crop.height(), offset, info.width); close(fd); } else { printf("error opening or creating %s\n", fn); } } } Rect BufferSourceThread::getCrop(sp<GraphicBuffer> &graphic_buffer, const float *mtx) { Rect crop(graphic_buffer->getWidth(), graphic_buffer->getHeight()); // calculate crop rectangle from tranformation matrix float sx, sy, tx, ty, h, w; unsigned int rect_x, rect_y; /* sx, 0, 0, 0, 0, sy, 0, 0, 0, 0, 1, 0, tx, ty, 0, 1 */ sx = mtx[0]; sy = mtx[5]; tx = mtx[12]; ty = mtx[13]; w = float(graphic_buffer->getWidth()); h = float(graphic_buffer->getHeight()); unsigned int bottom = (unsigned int)(h - (ty * h + 1)); unsigned int left = (unsigned int)(tx * w -1); rect_y = (unsigned int)(fabsf(sy) * h); rect_x = (unsigned int)(fabsf(sx) * w); // handle v-flip if (sy < 0.0f) { bottom = h - bottom; } // handle h-flip if (sx < 0.0f) { left = w - left; } unsigned int top = bottom - rect_y; unsigned int right = left + rect_x; Rect updatedCrop(left, top, right, bottom); if (updatedCrop.isValid()) { crop = updatedCrop; } else { printf("Crop for buffer %d is not valid: " "left=%u, top=%u, right=%u, bottom=%u. " "Will use default.\n", mCounter, left, top, right, bottom); } return crop; } void BufferSourceInput::setInput(buffer_info_t bufinfo, const char *format, ShotParameters ¶ms) { ANativeWindowBuffer* anb; GraphicBufferMapper &mapper = GraphicBufferMapper::get(); int pixformat = HAL_PIXEL_FORMAT_TI_NV12; size_t tapInMinUndequeued = 0; int aligned_width, aligned_height; pixformat = bufinfo.format; // Aligning is not needed for Bayer if ( ( pixformat == HAL_PIXEL_FORMAT_TI_Y16 ) || ( pixformat == HAL_PIXEL_FORMAT_TI_UYVY ) ) { aligned_width = bufinfo.crop.right - bufinfo.crop.left; } else { aligned_width = ALIGN_UP(bufinfo.crop.right - bufinfo.crop.left, ALIGN_WIDTH); } aligned_height = bufinfo.crop.bottom - bufinfo.crop.top; printf("aligned width: %d height: %d \n", aligned_width, aligned_height); if (mWindowTapIn.get() == 0) { return; } native_window_set_usage(mWindowTapIn.get(), getUsageFromANW(pixformat)); mWindowTapIn->perform(mWindowTapIn.get(), NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &tapInMinUndequeued);; native_window_set_buffer_count(mWindowTapIn.get(), tapInMinUndequeued); native_window_set_buffers_geometry(mWindowTapIn.get(), aligned_width, aligned_height, bufinfo.format); // if buffer dimensions are the same as the aligned dimensions, then we can // queue the buffer directly to tapin surface. if the dimensions are different // then the aligned ones, then we have to copy the buffer into our own buffer // to make sure the stride of the buffer is correct if ((aligned_width != bufinfo.width) || (aligned_height != bufinfo.height) || ( pixformat == HAL_PIXEL_FORMAT_TI_Y16 ) || ( pixformat == HAL_PIXEL_FORMAT_TI_UYVY) ) { void *dest[3] = { 0 }; void *src[3] = { 0 }; Rect bounds(aligned_width, aligned_height); mWindowTapIn->dequeueBuffer(mWindowTapIn.get(), &anb); mapper.lock(anb->handle, GRALLOC_USAGE_SW_WRITE_OFTEN, bounds, dest); // copy buffer to input buffer if available if (bufinfo.buf.get()) { bufinfo.buf->lock(GRALLOC_USAGE_SW_READ_OFTEN, src); } if (src[0]) { switch (pixformat) { case HAL_PIXEL_FORMAT_TI_Y16: case HAL_PIXEL_FORMAT_TI_UYVY: copyCroppedPacked16(bufinfo.offset, bufinfo.width, bufinfo.width, bufinfo.height, bufinfo.crop, src[0], dest[0]); break; case HAL_PIXEL_FORMAT_TI_NV12: copyCroppedNV12(bufinfo.offset, bufinfo.width, aligned_width, bufinfo.width, bufinfo.height, bufinfo.crop, src[0], dest[0]); break; default: printf("Pixel format 0x%x not supported\n", pixformat); exit(1); break; } } if (bufinfo.buf.get()) { bufinfo.buf->unlock(); } mapper.unlock(anb->handle); } else { mWindowTapIn->perform(mWindowTapIn.get(), NATIVE_WINDOW_ADD_BUFFER_SLOT, &bufinfo.buf); anb = bufinfo.buf->getNativeBuffer(); } mWindowTapIn->queueBuffer(mWindowTapIn.get(), anb); { sp<ANativeWindow> windowTapIn = mWindowTapIn; const char* id = NULL; if (windowTapIn.get()) { windowTapIn->perform(windowTapIn.get(), NATIVE_WINDOW_GET_ID, &id); } if (id) { params.set(KEY_TAP_IN_SURFACE, id); } else { params.remove(KEY_TAP_IN_SURFACE); } windowTapIn.clear(); } } void BufferSourceThread::showMetadata(sp<IMemory> data) { static nsecs_t prevTime = 0; nsecs_t currTime = 0; ssize_t offset; size_t size; if ( NULL == data.get() ) { printf("No Metadata!"); return; } sp<IMemoryHeap> heap = data->getMemory(&offset, &size); camera_metadata_t * meta = static_cast<camera_metadata_t *> (heap->base()); printf(" frame nmber: %d\n", meta->frame_number); printf(" shot number: %d\n", meta->shot_number); printf(" analog gain: %d req: %d range: %d~%d dev: %d err: %d\n", meta->analog_gain, meta->analog_gain_req, meta->analog_gain_min, meta->analog_gain_max, meta->analog_gain_dev, meta->analog_gain_error); printf(" exposure time: %d req: %d range: %d~%d dev: %d err: %d\n", meta->exposure_time, meta->exposure_time_req, meta->exposure_time_min, meta->exposure_time_max, meta->exposure_time_dev, meta->exposure_time_error); printf(" EV compensation: req: %d dev: %d\n", meta->exposure_compensation_req, meta->exposure_dev); printf(" awb gain: %d\n", meta->analog_gain); printf(" awb offsets: %d\n", meta->offset_b); printf(" awb temperature: %d\n", meta->awb_temp); printf(" LSC table applied: %d\n", meta->lsc_table_applied); if ( meta->lsc_table_applied ) { uint8_t *lscTable = (uint8_t *)meta + meta->lsc_table_offset; printf("LSC Table Size:%d Data[0:7]: %d:%d:%d:%d:%d:%d:%d:%d\n", meta->lsc_table_size, lscTable[0], lscTable[1], lscTable[2], lscTable[3], lscTable[4], lscTable[5], lscTable[6], lscTable[7]); } printf(" Faces detected: %d\n", meta->number_of_faces); currTime = meta->timestamp; printf(" timestamp (ns): %llu\n", currTime); if (prevTime) printf("inter-shot time (ms): %llu\n", (currTime - prevTime) / 1000000l); prevTime = currTime; }