#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;
    mST = new GLConsumer(tex_id, true, 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 &params) {
    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;
}