From fd7c880b8d0f591186994c206463373869e9ec4f Mon Sep 17 00:00:00 2001 From: atinm Date: Fri, 18 Nov 2011 16:41:18 -0500 Subject: Initial crap Change-Id: Iea55d594ffc24d554371006682cc954dc91d185d --- apns-conf.xml | 1330 +++++++++++++++++ libcamera/Android.mk | 19 - libcamera/LibCameraWrapper.cpp | 436 ------ libcamera/LibCameraWrapper.h | 65 - liboverlay/Android.mk | 35 - liboverlay/overlay.cpp | 1490 -------------------- liboverlay/v4l2_utils.c | 788 ----------- liboverlay/v4l2_utils.h | 75 - libs3cjpeg/Android.mk | 36 - libs3cjpeg/Exif.h | 233 --- libs3cjpeg/JpegEncoder.cpp | 796 ----------- libs3cjpeg/JpegEncoder.h | 240 ---- libstagefrighthw/Android.mk | 27 - libstagefrighthw/SEC_OMX_Plugin.cpp | 147 -- libstagefrighthw/SEC_OMX_Plugin.h | 76 - libstagefrighthw/SecHardwareRenderer.cpp | 228 --- libstagefrighthw/SecHardwareRenderer.h | 78 - libstagefrighthw/stagefright_overlay_output.cpp | 51 - .../res/res/drawable-hdpi/default_wallpaper.jpg | Bin 298259 -> 0 bytes .../base/core/res/res/values-de/arrays.xml | 26 - .../base/core/res/res/values-fi-rFI/arrays.xml | 28 - .../base/core/res/res/values-fr/arrays.xml | 25 - .../base/core/res/res/values-it/arrays.xml | 31 - .../base/core/res/res/values-pt-rBR/arrays.xml | 36 - .../base/core/res/res/values-ru/arrays.xml | 10 - .../base/core/res/res/values-sv/arrays.xml | 28 - .../base/core/res/res/values-uk/arrays.xml | 10 - .../base/core/res/res/values-zh-rTW/arrays.xml | 39 - .../frameworks/base/core/res/res/values/arrays.xml | 125 -- .../frameworks/base/core/res/res/values/config.xml | 185 --- .../base/core/res/res/xml/power_profile.xml | 60 - .../SettingsProvider/res/values/defaults.xml | 22 - .../base/tests/ImfTest/res/values/config.xml | 21 - .../packages/apps/CMParts/res/values/config.xml | 8 - overlay/packages/apps/Camera/res/values/config.xml | 24 - .../packages/apps/Contacts/res/values/config.xml | 21 - overlay/packages/apps/FM/res/values/config.xml | 9 - .../res/drawable-hdpi/wallpaper_grass.jpg | Bin 420605 -> 0 bytes .../res/drawable-hdpi/wallpaper_grass_small.jpg | Bin 27168 -> 0 bytes .../res/drawable-hdpi/wallpaper_mountains.jpg | Bin 323665 -> 0 bytes .../drawable-hdpi/wallpaper_mountains_small.jpg | Bin 19299 -> 0 bytes .../res/drawable-hdpi/wallpaper_phasebeam.jpg | Bin 39209 -> 0 bytes .../drawable-hdpi/wallpaper_phasebeam_small.jpg | Bin 6547 -> 0 bytes .../res/drawable-hdpi/wallpaper_pulse.jpg | Bin 42199 -> 0 bytes .../res/drawable-hdpi/wallpaper_pulse_small.jpg | Bin 5871 -> 0 bytes .../res/drawable-hdpi/wallpaper_shuttle.jpg | Bin 154313 -> 0 bytes .../res/drawable-hdpi/wallpaper_shuttle_small.jpg | Bin 8190 -> 0 bytes .../res/drawable-hdpi/wallpaper_stars.jpg | Bin 439193 -> 0 bytes .../res/drawable-hdpi/wallpaper_stars_small.jpg | Bin 33400 -> 0 bytes .../res/drawable-hdpi/wallpaper_stream.jpg | Bin 42360 -> 0 bytes .../res/drawable-hdpi/wallpaper_stream_small.jpg | Bin 5707 -> 0 bytes .../res/drawable-hdpi/wallpaper_street_lights.jpg | Bin 227572 -> 0 bytes .../wallpaper_street_lights_small.jpg | Bin 23522 -> 0 bytes .../res/drawable-hdpi/wallpaper_sunset.jpg | Bin 206025 -> 0 bytes .../res/drawable-hdpi/wallpaper_sunset_small.jpg | Bin 14751 -> 0 bytes .../apps/Launcher2/res/values-hdpi/wallpapers.xml | 36 - overlay/packages/apps/Phone/res/values/config.xml | 36 - .../packages/apps/Settings/res/values/bools.xml | 23 - .../Basic/res/drawable-hdpi/nexus_thumb.png | Bin 14743 -> 0 bytes .../Basic/res/drawable-hdpi/pyramid_background.png | Bin 688177 -> 0 bytes overlay/packages/wallpapers/Basic/res/raw/nexus.rs | 313 ---- .../wallpapers/Basic/res/values/surfacemode.xml | 18 - shbootimg.mk | 2 +- 63 files changed, 1331 insertions(+), 5955 deletions(-) create mode 100644 apns-conf.xml delete mode 100644 libcamera/Android.mk delete mode 100644 libcamera/LibCameraWrapper.cpp delete mode 100644 libcamera/LibCameraWrapper.h delete mode 100644 liboverlay/Android.mk delete mode 100644 liboverlay/overlay.cpp delete mode 100644 liboverlay/v4l2_utils.c delete mode 100644 liboverlay/v4l2_utils.h delete mode 100644 libs3cjpeg/Android.mk delete mode 100644 libs3cjpeg/Exif.h delete mode 100644 libs3cjpeg/JpegEncoder.cpp delete mode 100644 libs3cjpeg/JpegEncoder.h delete mode 100644 libstagefrighthw/Android.mk delete mode 100644 libstagefrighthw/SEC_OMX_Plugin.cpp delete mode 100644 libstagefrighthw/SEC_OMX_Plugin.h delete mode 100644 libstagefrighthw/SecHardwareRenderer.cpp delete mode 100644 libstagefrighthw/SecHardwareRenderer.h delete mode 100644 libstagefrighthw/stagefright_overlay_output.cpp delete mode 100644 overlay/frameworks/base/core/res/res/drawable-hdpi/default_wallpaper.jpg delete mode 100644 overlay/frameworks/base/core/res/res/values-de/arrays.xml delete mode 100644 overlay/frameworks/base/core/res/res/values-fi-rFI/arrays.xml delete mode 100644 overlay/frameworks/base/core/res/res/values-fr/arrays.xml delete mode 100644 overlay/frameworks/base/core/res/res/values-it/arrays.xml delete mode 100755 overlay/frameworks/base/core/res/res/values-pt-rBR/arrays.xml delete mode 100644 overlay/frameworks/base/core/res/res/values-ru/arrays.xml delete mode 100644 overlay/frameworks/base/core/res/res/values-sv/arrays.xml delete mode 100644 overlay/frameworks/base/core/res/res/values-uk/arrays.xml delete mode 100644 overlay/frameworks/base/core/res/res/values-zh-rTW/arrays.xml delete mode 100644 overlay/frameworks/base/core/res/res/values/arrays.xml delete mode 100644 overlay/frameworks/base/core/res/res/values/config.xml delete mode 100644 overlay/frameworks/base/core/res/res/xml/power_profile.xml delete mode 100644 overlay/frameworks/base/packages/SettingsProvider/res/values/defaults.xml delete mode 100644 overlay/frameworks/base/tests/ImfTest/res/values/config.xml delete mode 100644 overlay/packages/apps/CMParts/res/values/config.xml delete mode 100644 overlay/packages/apps/Camera/res/values/config.xml delete mode 100644 overlay/packages/apps/Contacts/res/values/config.xml delete mode 100644 overlay/packages/apps/FM/res/values/config.xml delete mode 100644 overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_grass.jpg delete mode 100644 overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_grass_small.jpg delete mode 100644 overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_mountains.jpg delete mode 100644 overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_mountains_small.jpg delete mode 100644 overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_phasebeam.jpg delete mode 100644 overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_phasebeam_small.jpg delete mode 100644 overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_pulse.jpg delete mode 100644 overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_pulse_small.jpg delete mode 100644 overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_shuttle.jpg delete mode 100644 overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_shuttle_small.jpg delete mode 100644 overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_stars.jpg delete mode 100644 overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_stars_small.jpg delete mode 100644 overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_stream.jpg delete mode 100644 overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_stream_small.jpg delete mode 100644 overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_street_lights.jpg delete mode 100644 overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_street_lights_small.jpg delete mode 100644 overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_sunset.jpg delete mode 100644 overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_sunset_small.jpg delete mode 100644 overlay/packages/apps/Launcher2/res/values-hdpi/wallpapers.xml delete mode 100644 overlay/packages/apps/Phone/res/values/config.xml delete mode 100644 overlay/packages/apps/Settings/res/values/bools.xml delete mode 100644 overlay/packages/wallpapers/Basic/res/drawable-hdpi/nexus_thumb.png delete mode 100644 overlay/packages/wallpapers/Basic/res/drawable-hdpi/pyramid_background.png delete mode 100644 overlay/packages/wallpapers/Basic/res/raw/nexus.rs delete mode 100644 overlay/packages/wallpapers/Basic/res/values/surfacemode.xml diff --git a/apns-conf.xml b/apns-conf.xml new file mode 100644 index 0000000..e6cce49 --- /dev/null +++ b/apns-conf.xml @@ -0,0 +1,1330 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/libcamera/Android.mk b/libcamera/Android.mk deleted file mode 100644 index fb274e8..0000000 --- a/libcamera/Android.mk +++ /dev/null @@ -1,19 +0,0 @@ -LOCAL_PATH:= $(call my-dir) - -include $(CLEAR_VARS) - -LOCAL_SRC_FILES:= LibCameraWrapper.cpp - -LOCAL_SHARED_LIBRARIES:= libdl libutils libcutils libcamera_client - -LOCAL_MODULE := libcamera -LOCAL_MODULE_TAGS := optional - -LOCAL_PRELINK_MODULE := false - -ifdef BOARD_SECOND_CAMERA_DEVICE - LOCAL_CFLAGS += -DFFC_PRESENT -endif - -include $(BUILD_SHARED_LIBRARY) - diff --git a/libcamera/LibCameraWrapper.cpp b/libcamera/LibCameraWrapper.cpp deleted file mode 100644 index a34c9b2..0000000 --- a/libcamera/LibCameraWrapper.cpp +++ /dev/null @@ -1,436 +0,0 @@ -/* - * Copyright (C) 2011 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. - */ - -// Adapted from JordanCameraWrapper - -// We can't use CameraParameters constants because we're linking against -// Samsung's libcamera_client.so - -#define LOG_TAG "LibCameraWrapper" -//#define LOG_NDEBUG 0 - -#include -#include -#include -#include -#include -#include -#include -#include -#include "LibCameraWrapper.h" - -namespace android { - -typedef sp (*OpenCamFunc)(int); -typedef void (*GetCamInfo)(int, struct CameraInfo*); - -static void * g_libHandle = NULL; -static OpenCamFunc g_openCameraHardware = NULL; -static GetCamInfo g_getCameraInfo = NULL; - -static const int CAMERA_CMD_SET_OBJECT_TRACKING_POSITION = 1103; -static const int CAMERA_CMD_SET_TOUCH_AF = 1105; - -static void ensureLibOpened() -{ - if (g_libHandle == NULL) { - g_libHandle = ::dlopen("libsamsungcamera.so", RTLD_NOW); - if (g_libHandle == NULL) { - assert(0); - LOGE("dlopen() error: %s\n", dlerror()); - } else { - g_openCameraHardware = (OpenCamFunc) ::dlsym(g_libHandle, "HAL_openCameraHardware"); - g_getCameraInfo = (GetCamInfo) ::dlsym(g_libHandle, "HAL_getCameraInfo"); - assert(g_openCameraHardware != NULL); - } - } -} - -extern "C" int HAL_getNumberOfCameras() -{ -#ifdef FFC_PRESENT - return 2; -#else - return 1; -#endif -} - -extern "C" void HAL_getCameraInfo(int cameraId, struct CameraInfo* cameraInfo) -{ - ensureLibOpened(); - g_getCameraInfo(cameraId, cameraInfo); -} - -extern "C" sp HAL_openCameraHardware(int cameraId) -{ - LOGV("openCameraHardware: call createInstance"); - ensureLibOpened(); - return LibCameraWrapper::createInstance(cameraId); -} - -wp LibCameraWrapper::singleton[2] = { 0 }; - -sp LibCameraWrapper::createInstance(int cameraId) -{ - LOGV("%s :", __func__); - if (singleton[cameraId] != NULL) { - sp hardware = singleton[cameraId].promote(); - if (hardware != NULL) { - return hardware; - } - } - - ensureLibOpened(); - - sp hardware(new LibCameraWrapper(cameraId)); - singleton[cameraId] = hardware; - return hardware; -} - -LibCameraWrapper::LibCameraWrapper(int cameraId) : - mLibInterface(g_openCameraHardware(cameraId)), - mCameraId(cameraId), - mVideoMode(false), - mContinuousAf(false), - mFixFocus(false), - mTouchFocus(false) -{ - LOGV("%s :", __func__); -} - -LibCameraWrapper::~LibCameraWrapper() -{ - LOGV("%s :", __func__); -} - -sp -LibCameraWrapper::getPreviewHeap() const -{ - LOGV("%s :", __func__); - return mLibInterface->getPreviewHeap(); -} - -sp -LibCameraWrapper::getRawHeap() const -{ - LOGV("%s :", __func__); - return mLibInterface->getRawHeap(); -} - -void -LibCameraWrapper::setCallbacks(notify_callback notify_cb, - data_callback data_cb, - data_callback_timestamp data_cb_timestamp, - void* user) -{ - LOGV("%s :", __func__); - mLibInterface->setCallbacks(notify_cb, data_cb, data_cb_timestamp, user); -} - -void -LibCameraWrapper::enableMsgType(int32_t msgType) -{ - LOGV("%s :", __func__); - mLibInterface->enableMsgType(msgType); -} - -void -LibCameraWrapper::disableMsgType(int32_t msgType) -{ - LOGV("%s :", __func__); - mLibInterface->disableMsgType(msgType); -} - -bool -LibCameraWrapper::msgTypeEnabled(int32_t msgType) -{ - LOGV("%s :", __func__); - return mLibInterface->msgTypeEnabled(msgType); -} - -status_t -LibCameraWrapper::startPreview() -{ - LOGV("%s :", __func__); - status_t ret = mLibInterface->startPreview(); - - if (mFixFocus) { - LOGV("Fix focus mode"); - // We need to switch the focus mode once after switching from video or the camera won't work. - // Note: If the previous mode was macro, then it actually doesn't matter since the bug doesn't affect that case. - CameraParameters pars = mLibInterface->getParameters(); - const char *prevFocusMode = pars.get("focus-mode"); - pars.set("focus-mode", "macro"); - mLibInterface->setParameters(pars); - pars.set("focus-mode", prevFocusMode); - mLibInterface->setParameters(pars); - mFixFocus = false; - } - - return ret; -} - -bool -LibCameraWrapper::useOverlay() -{ - LOGV("%s :", __func__); - return mLibInterface->useOverlay(); -} - -status_t -LibCameraWrapper::setOverlay(const sp &overlay) -{ - LOGV("%s :", __func__); - return mLibInterface->setOverlay(overlay); -} - -void -LibCameraWrapper::stopPreview() -{ - LOGV("%s :", __func__); - mLibInterface->stopPreview(); -} - -bool -LibCameraWrapper::previewEnabled() -{ - LOGV("%s :", __func__); - return mLibInterface->previewEnabled(); -} - -status_t -LibCameraWrapper::startRecording() -{ - LOGV("%s :", __func__); - return mLibInterface->startRecording(); -} - -void -LibCameraWrapper::stopRecording() -{ - LOGV("%s :", __func__); - mLibInterface->stopRecording(); -} - -bool -LibCameraWrapper::recordingEnabled() -{ - LOGV("%s :", __func__); - return mLibInterface->recordingEnabled(); -} - -void -LibCameraWrapper::releaseRecordingFrame(const sp& mem) -{ - LOGV("%s :", __func__); - return mLibInterface->releaseRecordingFrame(mem); -} - -status_t -LibCameraWrapper::autoFocus() -{ - LOGV("%s :", __func__); - return mLibInterface->autoFocus(); -} - -status_t -LibCameraWrapper::cancelAutoFocus() -{ - LOGV("%s :", __func__); - return mLibInterface->cancelAutoFocus(); -} - -status_t -LibCameraWrapper::takePicture() -{ - LOGV("%s :", __func__); - return mLibInterface->takePicture(); -} - -status_t -LibCameraWrapper::cancelPicture() -{ - LOGV("%s :", __func__); - return mLibInterface->cancelPicture(); -} - -status_t -LibCameraWrapper::setParameters(const CameraParameters& params) -{ - LOGV("%s :", __func__); - CameraParameters pars(params.flatten()); - - if (mCameraId == 0) { - const char *metering; - const char *conAf; - const char *touchCoordinate; - bool prevContinuousAf; - - /* - * getInt returns -1 if the value isn't present and 0 on parse failure, - * so if it's larger than 0, we can be sure the value was parsed properly - */ - mVideoMode = pars.getInt("cam-mode") > 0; - pars.remove("cam-mode"); - - if (mVideoMode) { - // Special settings in video mode - pars.set("video_recording_gamma", "on"); - pars.set("slow_ae", "on"); - pars.set("iso", "movie"); - pars.set("metering", "matrix"); - } - else { - pars.set("video_recording_gamma", "off"); - pars.set("slow_ae", "off"); - } - - // Parse continuous autofocus into a format the driver understands - conAf = pars.get("enable-caf"); - prevContinuousAf = mContinuousAf; - mContinuousAf = (conAf != 0 && strcmp(conAf, "on") == 0); - pars.set("continuous_af", mContinuousAf ? 1 : 0); - - if (prevContinuousAf && !mContinuousAf) { - mFixFocus = true; - } - - // Always set antibanding to 50hz - pars.set("antibanding", "50hz"); - - // Parse metering into something the driver understands - metering = pars.get("meter-mode"); - if (metering != 0) { - if (strcmp(metering, "meter-center") == 0) { - pars.set("metering", "center"); - } - else if (strcmp(metering, "meter-spot") == 0) { - pars.set("metering", "spot"); - } - else if (strcmp(metering, "meter-matrix") == 0) { - pars.set("metering", "matrix"); - } - pars.remove("meter-mode"); - } - - // Read touch-to-focus - touchCoordinate = pars.get("touch-focus"); - if (touchCoordinate != 0) { - int width, height; - int x, y; - char *comma; - x = mTouchFocusX = strtol(touchCoordinate, &comma, 10); - y = mTouchFocusY = strtol(comma + 1, NULL, 10); - - pars.getPreviewSize(&width, &height); - if (fabs((float)width/height - 1.66) > 0.1) { - LOGV("Non-widescreen touch focus"); - x += 80; // Only aries' Camera needs this for non-widescreen - } - - sendCommand(CAMERA_CMD_SET_TOUCH_AF, 0, 0); - sendCommand(CAMERA_CMD_SET_OBJECT_TRACKING_POSITION, x, y); - sendCommand(CAMERA_CMD_SET_TOUCH_AF, 1, 0); - - mTouchFocus = true; - pars.remove("touch-focus"); - } - else if (mTouchFocus) { - LOGV("Disabling touch focus"); - sendCommand(CAMERA_CMD_SET_TOUCH_AF, 0, 0); - mTouchFocus = false; - } - - } - - return mLibInterface->setParameters(pars); -} - -CameraParameters -LibCameraWrapper::getParameters() const -{ - LOGV("%s :", __func__); - CameraParameters ret = mLibInterface->getParameters(); - - if (mCameraId == 0) { - // The only value of antibanding supported is 50hz. Let's not say we support anything - ret.remove("antibanding-values"); - - // We support facedetect as well - ret.set("focus-mode-values", "auto,macro,facedetect"); - - // Auto-exposure modes. NOTE: matrix isn't a value supported in stock android - ret.set("meter-mode-values", "meter-center,meter-spot,meter-matrix"); - - // ISO values. The driver fails to return any of this. - ret.set("iso-values", "auto,50,100,200,400,800,1600,3200,sports,night,movie"); - - // Scene modes. The driver fails to return its proper supported values. - ret.set("scene-mode-values", "auto,portrait,landscape,sports,sunset,dusk-dawn,fireworks,beach,party,night,fall-color,text,candlelight,back-light"); - - // This is for detecting if we're in camcorder mode or not - ret.set("cam-mode", mVideoMode ? "1" : "0"); - - // Continuous AF - ret.set("enable-caf", mContinuousAf ? "on" : "off"); - - // Touch-to-focus - if (mTouchFocus) { - if (mTouchFocusX > 9999 || mTouchFocusY > 9999) { - LOGE("ERROR: Touch focus X, Y coordinate too large."); - ret.set("touch-focus", ""); - } - else { - char touchfocus[10] = ""; - sprintf(touchfocus, "%d,%d", mTouchFocusX, mTouchFocusY); - ret.set("touch-focus", touchfocus); - } - } - else { - ret.set("touch-focus", ""); - } - } - else if (mCameraId == 1) { - // FFC: We need more preview and picture size to support GTalk - ret.set("preview-size-values", "176x144,320x240,640x480"); - ret.set("picture-size-values", "176x144,320x240,640x480"); - } - - return ret; -} - -status_t -LibCameraWrapper::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) -{ - LOGV("%s :", __func__); - return mLibInterface->sendCommand(cmd, arg1, arg2); -} - -void -LibCameraWrapper::release() -{ - LOGV("%s :", __func__); - mLibInterface->release(); -} - -status_t -LibCameraWrapper::dump(int fd, const Vector& args) const -{ - LOGV("%s :", __func__); - return mLibInterface->dump(fd, args); -} - -}; //namespace android diff --git a/libcamera/LibCameraWrapper.h b/libcamera/LibCameraWrapper.h deleted file mode 100644 index 79c7586..0000000 --- a/libcamera/LibCameraWrapper.h +++ /dev/null @@ -1,65 +0,0 @@ -#ifndef ANDROID_HARDWARE_LIB_CAMERA_WRAPPER_H -#define ANDROID_HARDWARE_LIB_CAMERA_WRAPPER_H - -#include - -namespace android { - -class LibCameraWrapper : public CameraHardwareInterface { -public: - virtual sp getPreviewHeap() const; - virtual sp getRawHeap() const; - - virtual void setCallbacks(notify_callback notify_cb, - data_callback data_cb, - data_callback_timestamp data_cb_timestamp, - void *user); - - virtual void enableMsgType(int32_t msgType); - virtual void disableMsgType(int32_t msgType); - virtual bool msgTypeEnabled(int32_t msgType); - - virtual status_t startPreview(); - virtual bool useOverlay(); - virtual status_t setOverlay(const sp &overlay); - virtual void stopPreview(); - virtual bool previewEnabled(); - - virtual status_t startRecording(); - virtual void stopRecording(); - virtual bool recordingEnabled(); - virtual void releaseRecordingFrame(const sp &mem); - - virtual status_t autoFocus(); - virtual status_t cancelAutoFocus(); - virtual status_t takePicture(); - virtual status_t cancelPicture(); - virtual status_t dump(int fd, const Vector &args) const; - virtual status_t setParameters(const CameraParameters& params); - virtual CameraParameters getParameters() const; - virtual status_t sendCommand(int32_t command, int32_t arg1, - int32_t arg2); - virtual void release(); - - static sp createInstance(int cameraId); - -private: - LibCameraWrapper(int CameraId); - virtual ~LibCameraWrapper(); - - sp mLibInterface; - int mCameraId; - bool mVideoMode; - bool mContinuousAf; - bool mFixFocus; - bool mTouchFocus; - int mTouchFocusX; - int mTouchFocusY; - - static wp singleton[2]; - -}; - -}; // namespace android - -#endif diff --git a/liboverlay/Android.mk b/liboverlay/Android.mk deleted file mode 100644 index c4de48c..0000000 --- a/liboverlay/Android.mk +++ /dev/null @@ -1,35 +0,0 @@ -# Copyright (C) 2008 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. - -LOCAL_PATH:= $(call my-dir) -# HAL module implemenation, not prelinked and stored in -# hw/..so - -include $(CLEAR_VARS) -LOCAL_PRELINK_MODULE := false -LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw -LOCAL_SHARED_LIBRARIES := liblog libcutils - -ifdef BOARD_V4L2_DEVICE - LOCAL_CFLAGS += -DV4L2_DEVICE=\"$(BOARD_V4L2_DEVICE)\" -endif - -LOCAL_C_INCLUDES := \ - $(LOCAL_PATH)/../include - -LOCAL_SRC_FILES := v4l2_utils.c overlay.cpp - -LOCAL_MODULE := overlay.aries -LOCAL_MODULE_TAGS := optional -include $(BUILD_SHARED_LIBRARY) diff --git a/liboverlay/overlay.cpp b/liboverlay/overlay.cpp deleted file mode 100644 index d0a4289..0000000 --- a/liboverlay/overlay.cpp +++ /dev/null @@ -1,1490 +0,0 @@ -/* - * Copyright (C) 2008 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 "SEC_Overlay" - -#include -#include - -extern "C" { -#include "v4l2_utils.h" -} - -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include - -#include "linux/fb.h" - -/*****************************************************************************/ - -#define LOG_FUNCTION_NAME LOGV(" %s %s", __FILE__, __func__) - -#define NUM_OVERLAY_BUFFERS_REQUESTED (3) -/* OVRLYSHM on phone keypad*/ -#define SHARED_DATA_MARKER (0x68759746) - -/* These values should come from Surface Flinger */ -unsigned int g_lcd_width = 480; -unsigned int g_lcd_height = 800; -unsigned int g_lcd_bpp = 32; - -#define CACHEABLE_BUFFERS 0x1 - -/* shared with Camera/Video Playback HAL */ -#define ALL_BUFFERS_FLUSHED -66 - -uint32_t phyAddr; -s5p_fimc_t g_s5p_fimc; - -typedef struct -{ - uint32_t posX; - uint32_t posY; - uint32_t posW; - uint32_t posH; - uint32_t rotation; - uint32_t flip; - - uint32_t posX_org; - uint32_t posY_org; - uint32_t posW_org; - uint32_t posH_org; - -} overlay_ctrl_t; - -typedef struct -{ - uint32_t cropX; - uint32_t cropY; - uint32_t cropW; - uint32_t cropH; -} overlay_data_t; - -typedef struct -{ - uint32_t marker; - uint32_t size; - - volatile int32_t refCnt; - - uint32_t controlReady; /* Only updated by the control side */ - uint32_t dataReady; /* Only updated by the data side */ - - pthread_mutex_t lock; - pthread_mutexattr_t attr; - - uint32_t streamEn; - uint32_t streamingReset; - - uint32_t dispW; - uint32_t dispH; - -} overlay_shared_t; - -/* Only one instance is created per platform */ -struct overlay_control_context_t { - struct overlay_control_device_t device; - /* our private state goes below here */ - struct overlay_t* overlay_video1; - struct overlay_t* overlay_video2; -}; - -/* A separate instance is created per overlay data side user*/ -struct overlay_data_context_t { - struct overlay_data_device_t device; - /* our private state goes below here */ - int ctl_fd; - int shared_fd; - int shared_size; - int width; - int height; - int format; - int num_buffers; - size_t *buffers_len; - void **buffers; - - overlay_data_t data; - overlay_shared_t *shared; - struct mapping_data *mapping_data; - /* Need to count Qd buffers - to be sure we don't block DQ'ing when exiting */ - int qd_buf_count; - int cacheable_buffers; - - bool zerocopy; -}; - -static int create_shared_data(overlay_shared_t **shared); -static void destroy_shared_data(int shared_fd, overlay_shared_t *shared, - bool closefd); -static int open_shared_data(overlay_data_context_t *ctx); -static void close_shared_data(overlay_data_context_t *ctx); -enum { LOCK_REQUIRED = 1, NO_LOCK_NEEDED = 0 }; -static int enable_streaming(overlay_shared_t *shared, int ovly_fd, - int lock_required ); - -static int overlay_device_open(const struct hw_module_t* module, - const char* name, struct hw_device_t** device); - -static int check_fimc_dst_constraints(s5p_fimc_t *s5p_fimc, - unsigned int rotation); -static int check_fimc_src_constraints(s5p_fimc_t *s5p_fimc); - -static struct hw_module_methods_t overlay_module_methods = { -open: overlay_device_open -}; - -struct overlay_module_t HAL_MODULE_INFO_SYM = { -common: { -tag: HARDWARE_MODULE_TAG, - version_major: 1, - version_minor: 0, - id: OVERLAY_HARDWARE_MODULE_ID, - name: "SEC Overlay module", - author: "The Android Open Source Project", - methods: &overlay_module_methods, - } -}; - -/*****************************************************************************/ - -/* - * This is the overlay_t object, it is returned to the user and represents - * an overlay. here we use a subclass, where we can store our own state. - * This handles will be passed across processes and possibly given to other - * HAL modules (for instance video decode modules). - */ -struct handle_t : public native_handle { - /* add the data fields we need here, for instance: */ - int ctl_fd; - int shared_fd; - int width; - int height; - int format; - int num_buffers; - int shared_size; -}; - -static int handle_format(const overlay_handle_t overlay) { - return static_cast(overlay)->format; -} - -static int handle_ctl_fd(const overlay_handle_t overlay) { - return static_cast(overlay)->ctl_fd; -} - -static int handle_shared_fd(const overlay_handle_t overlay) { - return static_cast(overlay)->shared_fd; -} - -static int handle_num_buffers(const overlay_handle_t overlay) { - return static_cast(overlay)->num_buffers; -} - -static int handle_width(const overlay_handle_t overlay) { - return static_cast(overlay)->width; -} - -static int handle_height(const overlay_handle_t overlay) { - return static_cast(overlay)->height; -} - -static int handle_shared_size(const overlay_handle_t overlay) { - return static_cast(overlay)->shared_size; -} - -/* A separate instance of this class is created per overlay */ -class overlay_object : public overlay_t -{ - handle_t mHandle; - - overlay_ctrl_t mCtl; - overlay_ctrl_t mCtlStage; - overlay_shared_t *mShared; - - static overlay_handle_t getHandleRef(struct overlay_t* overlay) { - /* returns a reference to the handle, caller doesn't take ownership */ - return &(static_cast(overlay)->mHandle); - } - - public: - overlay_object(int ctl_fd, int shared_fd, int shared_size, int w, int h, - int format, int num_buffers) { - this->overlay_t::getHandleRef = getHandleRef; - mHandle.version = sizeof(native_handle); - mHandle.numFds = 2; - mHandle.numInts = 5; /* extra ints we have in our handle */ - mHandle.ctl_fd = ctl_fd; - mHandle.shared_fd = shared_fd; - mHandle.width = w; - mHandle.height = h; - mHandle.format = format; - mHandle.num_buffers = num_buffers; - mHandle.shared_size = shared_size; - this->w = w; - this->h = h; - this->format = format; - - memset( &mCtl, 0, sizeof( mCtl ) ); - memset( &mCtlStage, 0, sizeof( mCtlStage ) ); - } - - int ctl_fd() { return mHandle.ctl_fd; } - int shared_fd() { return mHandle.shared_fd; } - overlay_ctrl_t* data() { return &mCtl; } - overlay_ctrl_t* staging() { return &mCtlStage; } - overlay_shared_t* getShared() { return mShared; } - void setShared( overlay_shared_t *p ) { mShared = p; } -}; - -/***************************************************************************** - * Local Functions - *****************************************************************************/ - -static int create_shared_data(overlay_shared_t **shared) -{ - int fd; - /* assuming sizeof(overlay_shared_t) < a single page */ - int size = getpagesize(); - overlay_shared_t *p; - - if ((fd = ashmem_create_region("overlay_data", size)) < 0) { - LOGE("Failed to Create Overlay Shared Data!\n"); - return fd; - } - - p = (overlay_shared_t*)mmap(NULL, size, PROT_READ | PROT_WRITE, - MAP_SHARED, fd, 0); - if (p == MAP_FAILED) { - LOGE("Failed to Map Overlay Shared Data!\n"); - close(fd); - return -1; - } - - memset(p, 0, size); - p->marker = SHARED_DATA_MARKER; - p->size = size; - p->refCnt = 1; - if (pthread_mutexattr_init(&p->attr) != 0) { - LOGE("Failed to initialize overlay mutex attr"); - goto MutexAttrErr; - } - if (pthread_mutexattr_setpshared(&p->attr, PTHREAD_PROCESS_SHARED) != 0) { - LOGE("Failed to set the overlay mutex attr to be shared across-processes"); - goto MutexAttrSetErr; - } - if (pthread_mutex_init(&p->lock, &p->attr) != 0) { - LOGE("Failed to initialize overlay mutex\n"); - goto MutexErr; - } - - *shared = p; - return fd; - -MutexErr: -MutexAttrSetErr: - pthread_mutexattr_destroy(&p->attr); -MutexAttrErr: - munmap(p, size); - close(fd); - return -1; -} - -static void destroy_shared_data(int shared_fd, overlay_shared_t *shared, - bool closefd ) -{ - if (shared == NULL) - return; - - /* Last side deallocated releases the mutex, otherwise the remaining */ - /* side will deadlock trying to use an already released mutex */ - if (android_atomic_dec(&shared->refCnt) == 1) { - if (pthread_mutex_destroy(&shared->lock)) { - LOGE("Failed to uninitialize overlay mutex!\n"); - } - - if (pthread_mutexattr_destroy(&shared->attr)) { - LOGE("Failed to uninitialize the overlay mutex attr!\n"); - } - shared->marker = 0; - } - - if (munmap(shared, shared->size)) { - LOGE("Failed to Unmap Overlay Shared Data!\n"); - } - - if (closefd && close(shared_fd)) { - LOGE("Failed to Close Overlay Shared Data!\n"); - } -} - -static int open_shared_data( overlay_data_context_t *ctx ) -{ - int rc = -1; - int mode = PROT_READ | PROT_WRITE; - int fd = ctx->shared_fd; - int size = ctx->shared_size; - - if (ctx->shared != NULL) { - /* Already open, return success */ - LOGI("Overlay Shared Data Already Open\n"); - return 0; - } - ctx->shared = (overlay_shared_t*)mmap(0, size, mode, MAP_SHARED, fd, 0); - - if (ctx->shared == MAP_FAILED) { - LOGE("Failed to Map Overlay Shared Data!\n"); - } else if ( ctx->shared->marker != SHARED_DATA_MARKER ) { - LOGE("Invalid Overlay Shared Marker!\n"); - munmap( ctx->shared, size); - } else if ( (int)ctx->shared->size != size ) { - LOGE("Invalid Overlay Shared Size!\n"); - munmap(ctx->shared, size); - } else { - android_atomic_inc(&ctx->shared->refCnt); - rc = 0; - } - - return rc; -} - -static void close_shared_data(overlay_data_context_t *ctx) -{ - destroy_shared_data(ctx->shared_fd, ctx->shared, false); - ctx->shared = NULL; -} - -static int enable_streaming_locked(overlay_shared_t *shared, int ovly_fd) -{ - int rc = 0; - - if (!shared->controlReady || !shared->dataReady) { - LOGI("Postponing Stream Enable/%d/%d\n", shared->controlReady, - shared->dataReady); - } else { - shared->streamEn = 1; - rc = v4l2_overlay_stream_on(ovly_fd); - if (rc) { - LOGE("Stream Enable Failed!/%d\n", rc); - shared->streamEn = 0; - } - } - - return rc; -} - -static int enable_streaming(overlay_shared_t *shared, int ovly_fd) -{ - int ret; - - pthread_mutex_lock(&shared->lock); - ret = enable_streaming_locked(shared, ovly_fd); - pthread_mutex_unlock(&shared->lock); - return ret; -} - -static int disable_streaming_locked(overlay_shared_t *shared, int ovly_fd) -{ - int ret = 0; - - if (shared->streamEn) { - ret = v4l2_overlay_stream_off( ovly_fd ); - if (ret) { - LOGE("Stream Off Failed!/%d\n", ret); - } else { - shared->streamingReset = 1; - shared->streamEn = 0; - } - } - - return ret; -} - -static void set_color_space(unsigned int overlay_color_format, unsigned int *v4l2_color_format) -{ - switch (overlay_color_format) { - case OVERLAY_FORMAT_RGB_565: - *v4l2_color_format = V4L2_PIX_FMT_RGB565; - break; - - case OVERLAY_FORMAT_YCbYCr_422_I: - case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_422_I: - *v4l2_color_format = V4L2_PIX_FMT_YUYV; - break; - - case OVERLAY_FORMAT_CbYCrY_422_I: - case HAL_PIXEL_FORMAT_CUSTOM_CbYCrY_422_I: - *v4l2_color_format = V4L2_PIX_FMT_UYVY; - break; - - case HAL_PIXEL_FORMAT_YCbCr_420_P: - *v4l2_color_format = V4L2_PIX_FMT_YUV420; - break; - - case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP: - *v4l2_color_format = V4L2_PIX_FMT_NV12T; - break; - - case HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP: - *v4l2_color_format = V4L2_PIX_FMT_NV21; - break; - - default : - LOGE("unsupported pixel format (0x%x)", overlay_color_format); - *v4l2_color_format = -1; - } -} - -/**************************************************************************** - * Control module - *****************************************************************************/ - -static int overlay_get(struct overlay_control_device_t *dev, int name) -{ - int result = -1; - - switch (name) { - /* 0 = no limit */ - case OVERLAY_MINIFICATION_LIMIT: result = 0; break; - /* 0 = no limit */ - case OVERLAY_MAGNIFICATION_LIMIT: result = 0; break; - /* 0 = infinite */ - case OVERLAY_SCALING_FRAC_BITS: result = 0; break; - /* 90 rotation steps (for instance) */ - case OVERLAY_ROTATION_STEP_DEG: result = 90; break; - /* 1-pixel alignment */ - case OVERLAY_HORIZONTAL_ALIGNMENT: result = 1; break; - /* 1-pixel alignment */ - case OVERLAY_VERTICAL_ALIGNMENT: result = 1; break; - /* 1-pixel alignment */ - case OVERLAY_WIDTH_ALIGNMENT: result = 1; break; - case OVERLAY_HEIGHT_ALIGNMENT: break; - } - - return result; -} - -static int get_fb_var_screeninfo( struct fb_var_screeninfo *info ) -{ - int fd = -1; - int i=0; - char name[64]; - int ret = 0; - - char const * const device_template[] = { - "/dev/graphics/fb%u", - "/dev/fb%u", - 0 }; - - while ((fd==-1) && device_template[i]) { - snprintf(name, 64, device_template[i], 0); - fd = open(name, O_RDWR, 0); - i++; - } - - if (fd < 0) - ret = -EINVAL; - - if (ioctl(fd, FBIOGET_VSCREENINFO, info) == -1) - ret = -EINVAL; - - if (fd > 0) - close(fd); - - return 0; -} -static overlay_t* overlay_createOverlay(struct overlay_control_device_t *dev, - uint32_t w, uint32_t h, int32_t format) -{ - LOGD("overlay_createOverlay:IN w=%d h=%d format=%d\n", w, h, format); - LOG_FUNCTION_NAME; - - overlay_object *overlay; - overlay_control_context_t *ctx = (overlay_control_context_t *)dev; - overlay_shared_t *shared; - - int ret; - uint32_t num = NUM_OVERLAY_BUFFERS_REQUESTED; - int fd; - int shared_fd; - struct fb_var_screeninfo info; - bool zerocopy = false; - - phyAddr = 0; - - if (format == OVERLAY_FORMAT_DEFAULT) { - LOGD("format == OVERLAY_FORMAT_DEFAULT\n"); - LOGD("set to HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP\n"); - format = HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP; - } - - if (ctx->overlay_video1) { - LOGE("Error - overlays already in use\n"); - return NULL; - } - - shared_fd = create_shared_data(&shared); - if (shared_fd < 0) { - LOGE("Failed to create shared data"); - return NULL; - } - - fd = v4l2_overlay_open(V4L2_OVERLAY_PLANE_VIDEO1); - if (fd < 0) { - LOGE("Failed to open overlay device : %s\n", strerror(errno)); - goto error; - } - - g_s5p_fimc.params.src.full_width = w; - g_s5p_fimc.params.src.full_height = h; - g_s5p_fimc.params.src.width = w; - g_s5p_fimc.params.src.height = h; - set_color_space(format, &g_s5p_fimc.params.src.color_space); - ret = check_fimc_src_constraints(&g_s5p_fimc); - if(ret != 0) { - if(ret < 0) { - LOGE("Not supported source image size"); - goto error1; - } else { - LOGD("src width, height are changed [w= %d, h= %d]->[w=%d, h= %d]" - , w, h, g_s5p_fimc.params.src.width - , g_s5p_fimc.params.src.height); - w = g_s5p_fimc.params.src.width; - h = g_s5p_fimc.params.src.height; - } - } - - if (v4l2_overlay_init(fd, w, h, format, phyAddr)) { - LOGE("Failed initializing overlays\n"); - goto error1; - } - - if (v4l2_overlay_set_crop(fd, 0, 0, w, h)) { - LOGE("Failed defaulting crop window\n"); - goto error1; - } - - if (v4l2_overlay_set_flip(fd, 0)) { - LOGE("Failed defaulting flip\n"); - goto error1; - } - - if (v4l2_overlay_set_rotation(fd, 0, 0)) { - LOGE("Failed defaulting rotation\n"); - goto error1; - } - - if (format >= HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP - && format < HAL_PIXEL_FORMAT_CUSTOM_MAX) - zerocopy = true; - - if (v4l2_overlay_req_buf(fd, &num, 0, (int)zerocopy)) { - LOGE("Failed requesting buffers\n"); - goto error1; - } - - v4l2_overlay_init_fimc(fd, &g_s5p_fimc); - - overlay = new overlay_object(fd, shared_fd, shared->size, - w, h, format, num); - if (overlay == NULL) { - LOGE("Failed to create overlay object\n"); - goto error1; - } - ctx->overlay_video1 = overlay; - - overlay->setShared(shared); - - shared->controlReady = 0; - shared->streamEn = 0; - shared->streamingReset = 0; - - /* get lcd size from kernel framebuffer */ - if(get_fb_var_screeninfo(&info) == 0) { - shared->dispW = info.xres; - shared->dispH = info.yres; - g_lcd_width = info.xres; - g_lcd_height = info.yres; - g_lcd_bpp = info.bits_per_pixel; - } else { - shared->dispW = g_lcd_width; /* Need to determine this properly */ - shared->dispH = g_lcd_height; /* Need to determine this properly */ - } - - LOGI("Opened video1/fd=%d/obj=%08lx/shm=%d/size=%d", fd, - (unsigned long)overlay, shared_fd, shared->size); - - return overlay; - -error1: - close(fd); -error: - destroy_shared_data(shared_fd, shared, true); - return NULL; -} - -static void overlay_destroyOverlay(struct overlay_control_device_t *dev, - overlay_t* overlay) -{ - LOGD("overlay_destroyOverlay:IN dev (%p) and overlay (%p)", dev, overlay); - LOG_FUNCTION_NAME; - - overlay_control_context_t *ctx = (overlay_control_context_t *)dev; - overlay_object *obj = static_cast(overlay); - - int rc; - int fd = obj->ctl_fd(); - uint32_t num = 0; - - overlay_shared_t *shared = obj->getShared(); - - if (shared == NULL) { - LOGE("Overlay was already destroyed - nothing needs to be done\n"); - return; - } - - pthread_mutex_lock(&shared->lock); - - disable_streaming_locked(shared, fd); - - pthread_mutex_unlock(&shared->lock); - - destroy_shared_data(obj->shared_fd(), shared, true); - obj->setShared(NULL); - - if (v4l2_overlay_req_buf(fd, &num, 0, 0)) { - LOGE("Failed requesting buffers\n"); - } - - LOGI("Destroying overlay/fd=%d/obj=%08lx", fd, (unsigned long)overlay); - - if (close(fd)) { - LOGE( "Error closing overly fd/%d\n", errno); - } - - if (overlay) { - if (ctx->overlay_video1 == overlay) - ctx->overlay_video1 = NULL; - delete overlay; - overlay = NULL; - } - LOGD("overlay_destroyOverlay:OUT"); -} - -static int overlay_setPosition(struct overlay_control_device_t *dev, - overlay_t* overlay, int x, int y, uint32_t w, - uint32_t h) -{ - LOG_FUNCTION_NAME; - - overlay_object *obj = static_cast(overlay); - - overlay_ctrl_t *stage = obj->staging(); - overlay_shared_t *shared = obj->getShared(); - - int rc = 0; - int temp_x = x, temp_y = y, temp_w = w, temp_h = h; - - /* - * This logic here is to return an error if the rectangle is not fully - * within the display, unless we have not received a valid position yet, - * in which case we will do our best to adjust the rectangle to be within - * the display. - */ - - /* Require a minimum size */ - if (temp_w < 16) - temp_w = 16; - if (temp_h < 8) - temp_h = 8; - - if (!shared->controlReady) { - if ( temp_x < 0 ) temp_x = 0; - if ( temp_y < 0 ) temp_y = 0; - if ( temp_w > shared->dispW ) temp_w = shared->dispW; - if ( temp_h > shared->dispH ) temp_h = shared->dispH; - if ( (temp_x + temp_w) > shared->dispW ) temp_w = shared->dispW - temp_x; - if ( (temp_y + temp_h) > shared->dispH ) temp_h = shared->dispH - temp_y; - } else if (temp_x < 0 || temp_y < 0 || (temp_x + temp_w) > shared->dispW || - (temp_y + temp_h) > shared->dispH) { - /* Return an error */ - rc = -1; - } - - if (rc == 0) { - stage->posX = temp_x; - stage->posY = temp_y; - stage->posW = temp_w; - stage->posH = temp_h; - - stage->posX_org = x; - stage->posY_org = y; - stage->posW_org = w; - stage->posH_org = h; - } - - return rc; -} - -static int overlay_getPosition(struct overlay_control_device_t *dev, - overlay_t* overlay, int* x, int* y, uint32_t* w, - uint32_t* h) -{ - LOG_FUNCTION_NAME; - - overlay_object *obj = static_cast(overlay); - overlay_ctrl_t *stage = obj->staging(); - - *x = stage->posX_org; - *y = stage->posY_org; - *w = stage->posW_org; - *h = stage->posH_org; - - return 0; -} - -static int overlay_setParameter(struct overlay_control_device_t *dev, - overlay_t* overlay, int param, int value) -{ - LOG_FUNCTION_NAME; - - overlay_ctrl_t *stage = static_cast(overlay)->staging(); - int rc = 0; - - switch (param) { - case OVERLAY_DITHER: - break; - - case OVERLAY_TRANSFORM: - switch ( value ) - { - case 0: - stage->rotation = 0; - stage->flip = 0; - break; - case OVERLAY_TRANSFORM_ROT_90: - stage->rotation = 90; - stage->flip = 0; - break; - case OVERLAY_TRANSFORM_ROT_180: - stage->rotation = 180; - stage->flip = 0; - break; - case OVERLAY_TRANSFORM_ROT_270: - stage->rotation = 270; - stage->flip = 0; - break; - // FIMC VFLIP = android overlay FLIP_H. - case OVERLAY_TRANSFORM_FLIP_H: - stage->rotation = 0; - stage->flip = V4L2_CID_VFLIP; - break; - case OVERLAY_TRANSFORM_FLIP_V: - stage->rotation = 0; - stage->flip = V4L2_CID_HFLIP; - break; - // FIMC rotates first but android flips first. - case OVERLAY_TRANSFORM_ROT_90+OVERLAY_TRANSFORM_FLIP_H: - stage->rotation = 90; - stage->flip = V4L2_CID_HFLIP; - break; - case OVERLAY_TRANSFORM_ROT_90+OVERLAY_TRANSFORM_FLIP_V: - stage->rotation = 90; - stage->flip = V4L2_CID_VFLIP; - break; - - default: - rc = -EINVAL; - break; - } - break; - } - - return rc; -} - -static int overlay_stage(struct overlay_control_device_t *dev, - overlay_t* overlay) { - return 0; -} - -static int overlay_commit(struct overlay_control_device_t *dev, - overlay_t* overlay) { - LOG_FUNCTION_NAME; - - overlay_object *obj = static_cast(overlay); - - overlay_ctrl_t *data = obj->data(); - overlay_ctrl_t *stage = obj->staging(); - overlay_shared_t *shared = obj->getShared(); - - int ret = 0; - int fd = obj->ctl_fd(); - - if (shared == NULL) { - LOGI("Shared Data Not Init'd!\n"); - return -1; - } - - pthread_mutex_lock(&shared->lock); - - if (!shared->controlReady) { - shared->controlReady = 1; - } - - g_s5p_fimc.params.dst.full_width = g_lcd_width; - g_s5p_fimc.params.dst.full_height = g_lcd_height; - g_s5p_fimc.params.dst.width = stage->posW; - g_s5p_fimc.params.dst.height = stage->posH; - if (g_lcd_bpp == 32) - g_s5p_fimc.params.dst.color_space = V4L2_PIX_FMT_RGB32; - else - g_s5p_fimc.params.dst.color_space = V4L2_PIX_FMT_RGB565; - ret = check_fimc_dst_constraints(&g_s5p_fimc, stage->rotation); - if (ret != 0) { - if (ret < 0) { - LOGE("Unsupported destination image size"); - goto end; - } else { - LOGD("dst width, height have changed [w= %d, h= %d] -> [w=%d, h= %d]", - stage->posW, stage->posH, g_s5p_fimc.params.dst.width, - g_s5p_fimc.params.dst.height); - stage->posW = g_s5p_fimc.params.dst.width; - stage->posH = g_s5p_fimc.params.dst.height; - } - } - - if (data->posX == stage->posX && data->posY == stage->posY && - data->posW == stage->posW && data->posH == stage->posH && - data->rotation == stage->rotation && - data->flip == stage->flip) { - LOGI("Nothing to do!\n"); - goto end; - } - - LOGD("Position/X%d/Y%d/W%d/H%d\n", data->posX, data->posY, data->posW, - data->posH); - LOGD("Adjusted Position/X%d/Y%d/W%d/H%d\n", stage->posX, stage->posY, - stage->posW, stage->posH); - LOGD("Rotation/%d\n", stage->rotation ); - - if ((ret = disable_streaming_locked(shared, fd))) - goto end; - - if (stage->flip != data->flip) { - ret = v4l2_overlay_set_flip(fd, stage->flip); - if (ret) { - LOGE("Set Flip Failed!/%d\n", ret); - goto end; - } - } - - if (stage->rotation != data->rotation) { - ret = v4l2_overlay_set_rotation(fd, stage->rotation, 0); - if (ret) { - LOGE("Set Rotation Failed!/%d\n", ret); - goto end; - } - v4l2_overlay_s_fbuf(fd, stage->rotation); - } - - ret = v4l2_overlay_set_position(fd, stage->posX, stage->posY, - stage->posW, stage->posH, stage->rotation); - if (ret) { - LOGE("Set Position Failed!/%d\n", ret); - goto end; - } - - data->posX = stage->posX; - data->posY = stage->posY; - data->posW = stage->posW; - data->posH = stage->posH; - data->rotation = stage->rotation; - data->flip = stage->flip; - - ret = enable_streaming_locked(shared, fd); - -end: - pthread_mutex_unlock(&shared->lock); - - return ret; -} - -static int overlay_control_close(struct hw_device_t *dev) -{ - LOG_FUNCTION_NAME; - - struct overlay_control_context_t* ctx = - (struct overlay_control_context_t*)dev; - overlay_object *overlay_v1; - - if (ctx) { - overlay_v1 = static_cast(ctx->overlay_video1); - - overlay_destroyOverlay((struct overlay_control_device_t *)ctx, - overlay_v1); - - free(ctx); - } - return 0; -} - -static int get_pixel_format_type(unsigned int pixelformat) -{ - switch(pixelformat) { - case V4L2_PIX_FMT_RGB32: - case V4L2_PIX_FMT_RGB565: - return PFT_RGB; - - case V4L2_PIX_FMT_NV12: - case V4L2_PIX_FMT_NV12T: - case V4L2_PIX_FMT_NV21: - case V4L2_PIX_FMT_YUV420: - return PFT_YUV420; - - case V4L2_PIX_FMT_YUYV: - case V4L2_PIX_FMT_UYVY: - case V4L2_PIX_FMT_YVYU: - case V4L2_PIX_FMT_VYUY: - case V4L2_PIX_FMT_NV16: - case V4L2_PIX_FMT_NV61: - case V4L2_PIX_FMT_YUV422P: - return PFT_YUV422; - - default: - return PFT_YUV444; - } -} - -/* check the constraints of destination image size */ -static int check_fimc_dst_constraints(s5p_fimc_t *s5p_fimc, - unsigned int rotation) -{ - int tmp = 0; - - if((s5p_fimc->params.dst.height > 0) && (s5p_fimc->params.dst.height < 16)) - s5p_fimc->params.dst.height = 16; - - if(s5p_fimc->params.dst.width%8 != 0) { - tmp = s5p_fimc->params.dst.width - (s5p_fimc->params.dst.width%8); - if(tmp <= 0) - return -1; - else - s5p_fimc->params.dst.width = tmp; - } - - return 1; -} -/* check the constraints of source image size */ -static int check_fimc_src_constraints(s5p_fimc_t *s5p_fimc) -{ - int format_type = 0; - - if(s5p_fimc->params.src.full_width < 16 || - s5p_fimc->params.src.full_height < 8 ) - return -1; - - if(s5p_fimc->hw_ver == 0x50) { - format_type = get_pixel_format_type(s5p_fimc->params.src.color_space); - switch (format_type) { - case PFT_YUV420: - if (s5p_fimc->params.src.height%2 != 0) - s5p_fimc->params.src.height = s5p_fimc->params.src.height - - (s5p_fimc->params.src.height)%2; - - if (s5p_fimc->params.src.width%2 != 0) - s5p_fimc->params.src.width = s5p_fimc->params.src.width - - (s5p_fimc->params.src.width)%2; - break; - - case PFT_YUV422: - if (s5p_fimc->params.src.width%2 != 0) - s5p_fimc->params.src.width = s5p_fimc->params.src.width - - (s5p_fimc->params.src.width)%2; - } - } else { - if (s5p_fimc->params.src.height < 8) { - s5p_fimc->params.src.height = 8; - } - - if (s5p_fimc->params.src.width%16 != 0) { - s5p_fimc->params.src.width = s5p_fimc->params.src.width - - (s5p_fimc->params.src.width)%16; - } - } - - return 1; -} - -/**************************************************************************** - * Data module - *****************************************************************************/ - -int overlay_initialize(struct overlay_data_device_t *dev, - overlay_handle_t handle) -{ - LOG_FUNCTION_NAME; - - struct overlay_data_context_t* ctx = (struct overlay_data_context_t*)dev; - struct stat stat; - - int i; - int rc = -1; - - ctx->num_buffers = handle_num_buffers(handle); - ctx->width = handle_width(handle); - ctx->height = handle_height(handle); - ctx->format = handle_format(handle); - ctx->ctl_fd = handle_ctl_fd(handle); - ctx->shared_fd = handle_shared_fd(handle); - ctx->shared_size = handle_shared_size(handle); - ctx->shared = NULL; - ctx->qd_buf_count = 0; - ctx->cacheable_buffers = 0; - - if (ctx->format >= HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP - && ctx->format < HAL_PIXEL_FORMAT_CUSTOM_MAX) - ctx->zerocopy = true; - else - ctx->zerocopy = false; - - if (fstat(ctx->ctl_fd, &stat)) { - LOGE("Error = %s from %s\n", strerror(errno), "overlay initialize"); - return -1; - } - - if (open_shared_data(ctx)) { - return -1; - } - - ctx->shared->dataReady = 0; - - ctx->mapping_data = new struct mapping_data; - ctx->buffers = new void* [ctx->num_buffers]; - ctx->buffers_len = new size_t[ctx->num_buffers]; - - if (!ctx->buffers || !ctx->buffers_len || !ctx->mapping_data) { - LOGE("Failed alloc'ing buffer arrays\n"); - goto error; - } else { - - /* - * in the zero copy case, - * don't need to mmap buffer for source - */ - if (ctx->zerocopy) - rc = 0; - else { - for (i = 0; i < ctx->num_buffers; i++) { - rc = v4l2_overlay_map_buf(ctx->ctl_fd, i, &ctx->buffers[i], - &ctx->buffers_len[i]); - if (rc) { - LOGE("Failed mapping buffers\n"); - goto error; - } - } - } - } - - v4l2_overlay_init_fimc(ctx->ctl_fd, &g_s5p_fimc); - - return ( rc ); - -error: - - if(ctx->mapping_data) - delete (ctx->mapping_data); - if(ctx->buffers) - delete [] ctx->buffers; - if(ctx->buffers_len) - delete [] ctx->buffers_len; - - close_shared_data( ctx ); - - return -1; -} - -static int overlay_resizeInput(struct overlay_data_device_t *dev, uint32_t w, - uint32_t h) -{ - int rc = -1; - int ret = 0; - - struct overlay_data_context_t* ctx = (struct overlay_data_context_t*)dev; - - if ((ctx->width == (int)w) && (ctx->width == (int)h)) { - LOGV("same as current width and height. so do nothing"); - return 0; - } - - if (!ctx->shared) { - LOGI("Shared Data Not Init'd!\n"); - return -1; - } - - if (ctx->shared->dataReady) { - LOGV("Either setCrop() or queueBuffer() was called prior to this!" - "Therefore failing this call.\n"); - return -1; - } - - pthread_mutex_lock(&ctx->shared->lock); - - if ((rc = disable_streaming_locked(ctx->shared, ctx->ctl_fd))) - goto end; - - if (!ctx->zerocopy) { - for (int i = 0; i < ctx->num_buffers; i++) { - v4l2_overlay_unmap_buf(ctx->buffers[i], ctx->buffers_len[i]); - } - } - - g_s5p_fimc.params.src.full_width = w; - g_s5p_fimc.params.src.full_height = h; - g_s5p_fimc.params.src.width = w; - g_s5p_fimc.params.src.height = h; - set_color_space(ctx->format, &g_s5p_fimc.params.src.color_space); - ret = check_fimc_src_constraints(&g_s5p_fimc); - - if(ret != 0) { - if(ret < 0) { - LOGE("Not supported source image size"); - goto end; - } else { - LOGD("src width, height are changed [w= %d, h= %d] -> [w=%d, h= %d]" - , w, h, g_s5p_fimc.params.src.width - , g_s5p_fimc.params.src.height); - w = g_s5p_fimc.params.src.width; - h = g_s5p_fimc.params.src.height; - } - } - - rc = v4l2_overlay_init(ctx->ctl_fd, w, h, ctx->format, phyAddr); - if (rc) { - LOGE("Error initializing overlay"); - goto end; - } - rc = v4l2_overlay_set_crop(ctx->ctl_fd, 0, 0, w, h); - if (rc) { - LOGE("Error setting crop window\n"); - goto end; - } - rc = v4l2_overlay_req_buf(ctx->ctl_fd, (uint32_t *)(&ctx->num_buffers), - ctx->cacheable_buffers, (int)ctx->zerocopy); - if (rc) { - LOGE("Error creating buffers"); - goto end; - } - - if (!ctx->zerocopy) { - for (int i = 0; i < ctx->num_buffers; i++) - v4l2_overlay_map_buf(ctx->ctl_fd, i, &ctx->buffers[i], - &ctx->buffers_len[i]); - } - - rc = enable_streaming_locked(ctx->shared, ctx->ctl_fd); - -end: - pthread_mutex_unlock(&ctx->shared->lock); - - return rc; -} - - -static int overlay_data_setParameter(struct overlay_data_device_t *dev, - int param, int value) -{ - int ret = 0; - struct overlay_data_context_t* ctx = (struct overlay_data_context_t*)dev; - - if (ctx->shared == NULL) { - LOGI("Shared Data Not Init'd!\n"); - return -1; - } - - if (ctx->shared->dataReady) { - LOGI("Too late. Cant set it now!\n"); - return -1; - } - - if (param == CACHEABLE_BUFFERS) - ctx->cacheable_buffers = value; - - return ( ret ); -} - - -static int overlay_setCrop(struct overlay_data_device_t *dev, uint32_t x, - uint32_t y, uint32_t w, uint32_t h) { - LOG_FUNCTION_NAME; - - int rc = 0; - int cnt = 0; - struct overlay_data_context_t* ctx = (struct overlay_data_context_t*)dev; - - if (ctx->shared == NULL) { - LOGI("Shared Data Not Init'd!\n"); - return -1; - } - - pthread_mutex_lock(&ctx->shared->lock); - - ctx->shared->dataReady = 1; - - if (ctx->data.cropX == x && ctx->data.cropY == y && ctx->data.cropW == w - && ctx->data.cropH == h) { - goto end; - } - - ctx->data.cropX = x; - ctx->data.cropY = y; - ctx->data.cropW = w; - ctx->data.cropH = h; - - LOGD("Crop Win/X%d/Y%d/W%d/H%d\n", x, y, w, h ); - - if ((rc = disable_streaming_locked(ctx->shared, ctx->ctl_fd))) - goto end; - - rc = v4l2_overlay_set_crop(ctx->ctl_fd, x, y, w, h); - if (rc) { - LOGE("Set Crop Window Failed!/%d\n", rc); - } - - rc = enable_streaming_locked(ctx->shared, ctx->ctl_fd); - -end: - pthread_mutex_unlock(&ctx->shared->lock); - return rc; -} - -static int overlay_getCrop(struct overlay_data_device_t *dev , uint32_t* x, - uint32_t* y, uint32_t* w, uint32_t* h) { - struct overlay_data_context_t* ctx = (struct overlay_data_context_t*)dev; - - return v4l2_overlay_get_crop(ctx->ctl_fd, x, y, w, h); -} - -int overlay_dequeueBuffer(struct overlay_data_device_t *dev, - overlay_buffer_t *buffer) { - /* blocks until a buffer is available and return an opaque structure - * representing this buffer. - */ - - struct overlay_data_context_t* ctx = (struct overlay_data_context_t*)dev; - - int rc=0; - int i = -1; - uint32_t num = 0; - int cnt = 0; - - pthread_mutex_lock(&ctx->shared->lock); - if ( ctx->shared->streamingReset ) { - ctx->shared->streamingReset = 0; - pthread_mutex_unlock(&ctx->shared->lock); - return ALL_BUFFERS_FLUSHED; - } - pthread_mutex_unlock(&ctx->shared->lock); - - /* If we are not streaming dequeue will fail, - skip to prevent error printouts */ - if (ctx->shared->streamEn && ctx->qd_buf_count) { - if ((rc = v4l2_overlay_dq_buf( ctx->ctl_fd, &i ,ctx->zerocopy)) != 0) { - LOGE("Failed to DQ/%d\n", rc); - } - else if (i < 0 || i > ctx->num_buffers) { - rc = -EINVAL; - } else { - *((int *)buffer) = i; - ctx->qd_buf_count --; - } - } else { - rc = -1; - } - - return rc; -} - -int overlay_queueBuffer(struct overlay_data_device_t *dev, - overlay_buffer_t buffer) { - struct overlay_data_context_t* ctx = (struct overlay_data_context_t*)dev; - - int cnt = 0; - - pthread_mutex_lock(&ctx->shared->lock); - if ( ctx->shared->streamingReset ) { - ctx->shared->streamingReset = 0; - pthread_mutex_unlock(&ctx->shared->lock); - return ALL_BUFFERS_FLUSHED; - } - pthread_mutex_unlock(&ctx->shared->lock); - - /* Catch the case where the data side had no need to set the crop window */ - if (!ctx->shared->dataReady) { - ctx->shared->dataReady = 1; - enable_streaming(ctx->shared, ctx->ctl_fd); - } - - if (!ctx->shared->controlReady) return -1; - int rc = v4l2_overlay_q_buf( ctx->ctl_fd, (int)buffer, (int) ctx->zerocopy ); - if (rc == 0 && ctx->qd_buf_count < ctx->num_buffers) { - ctx->qd_buf_count ++; - } - - return rc; -} - -void *overlay_getBufferAddress(struct overlay_data_device_t *dev, - overlay_buffer_t buffer) -{ - LOG_FUNCTION_NAME; - - /* this may fail (NULL) if this feature is not supported. In that case, - * presumably, there is some other HAL module that can fill the buffer, - * using a DSP for instance - */ - int ret; - struct v4l2_buffer buf; - struct overlay_data_context_t* ctx = (struct overlay_data_context_t*)dev; - - if (ctx->zerocopy) - return NULL; - - if ((int)buffer >= 0 && (int)buffer < ctx->num_buffers) - return (void*) ctx->buffers[(int)buffer]; - else - return NULL; -} - -int overlay_getBufferCount(struct overlay_data_device_t *dev) -{ - LOG_FUNCTION_NAME; - - struct overlay_data_context_t* ctx = (struct overlay_data_context_t*)dev; - - return (ctx->num_buffers); -} - -static int overlay_data_close(struct hw_device_t *dev) { - - LOG_FUNCTION_NAME; - - struct overlay_data_context_t* ctx = (struct overlay_data_context_t*)dev; - int rc; - - if (ctx) { - overlay_data_device_t *overlay_dev = &ctx->device; - int buf; - int i; - - pthread_mutex_lock(&ctx->shared->lock); - - if (!ctx->zerocopy) - for (i = 0; i < ctx->num_buffers; i++) { - LOGV("Unmap Buffer/%d/%08lx/%d", i, (unsigned long)ctx->buffers[i], - ctx->buffers_len[i] ); - rc = v4l2_overlay_unmap_buf(ctx->buffers[i], ctx->buffers_len[i]); - if (rc != 0) { - LOGE("Error unmapping the buffer/%d/%d", i, rc); - } - } - - delete (ctx->mapping_data); - delete [] ctx->buffers; - delete [] ctx->buffers_len; - - pthread_mutex_unlock(&ctx->shared->lock); - - ctx->shared->dataReady = 0; - close_shared_data( ctx ); - - free(ctx); - } - - return 0; -} - -/*****************************************************************************/ - -static int overlay_device_open(const struct hw_module_t* module, - const char* name, struct hw_device_t** device) -{ - LOG_FUNCTION_NAME; - int status = -EINVAL; - - if (!strcmp(name, OVERLAY_HARDWARE_CONTROL)) { - struct overlay_control_context_t *dev; - dev = (overlay_control_context_t*)malloc(sizeof(*dev)); - - /* initialize our state here */ - memset(dev, 0, sizeof(*dev)); - - /* initialize the procs */ - dev->device.common.tag = HARDWARE_DEVICE_TAG; - dev->device.common.version = 0; - dev->device.common.module = const_cast(module); - dev->device.common.close = overlay_control_close; - - dev->device.get = overlay_get; - dev->device.createOverlay = overlay_createOverlay; - dev->device.destroyOverlay = overlay_destroyOverlay; - dev->device.setPosition = overlay_setPosition; - dev->device.getPosition = overlay_getPosition; - dev->device.setParameter = overlay_setParameter; - dev->device.stage = overlay_stage; - dev->device.commit = overlay_commit; - - *device = &dev->device.common; - status = 0; - } else if (!strcmp(name, OVERLAY_HARDWARE_DATA)) { - struct overlay_data_context_t *dev; - dev = (overlay_data_context_t*)malloc(sizeof(*dev)); - - /* initialize our state here */ - memset(dev, 0, sizeof(*dev)); - - /* initialize the procs */ - dev->device.common.tag = HARDWARE_DEVICE_TAG; - dev->device.common.version = 0; - dev->device.common.module = const_cast(module); - dev->device.common.close = overlay_data_close; - - dev->device.initialize = overlay_initialize; - dev->device.resizeInput = overlay_resizeInput; - dev->device.setCrop = overlay_setCrop; - dev->device.getCrop = overlay_getCrop; - dev->device.setParameter = overlay_data_setParameter; - dev->device.dequeueBuffer = overlay_dequeueBuffer; - dev->device.queueBuffer = overlay_queueBuffer; - dev->device.getBufferAddress = overlay_getBufferAddress; - dev->device.getBufferCount = overlay_getBufferCount; - - *device = &dev->device.common; - status = 0; - } - return status; -} diff --git a/liboverlay/v4l2_utils.c b/liboverlay/v4l2_utils.c deleted file mode 100644 index f3ebbc2..0000000 --- a/liboverlay/v4l2_utils.c +++ /dev/null @@ -1,788 +0,0 @@ -/* - * Copyright (C) 2008 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 OVERLAY_DEBUG 1 */ -#define LOG_TAG "v4l2_utils" - -#include -#include -#include -#include -#include -#include -#include -#include "v4l2_utils.h" - -#ifndef V4L2_DEVICE -#define V4L2_DEVICE "/dev/video1" -#endif - - - -#define LOG_FUNCTION_NAME LOGV("%s: %s", __FILE__, __func__); - -#define V4L2_CID_PRIV_OFFSET 0x0 -#define V4L2_CID_PRIV_ROTATION (V4L2_CID_PRIVATE_BASE \ - + V4L2_CID_PRIV_OFFSET + 0) -#define V4L2_CID_PRIV_COLORKEY (V4L2_CID_PRIVATE_BASE \ - + V4L2_CID_PRIV_OFFSET + 1) -#define V4L2_CID_PRIV_COLORKEY_EN (V4L2_CID_PRIVATE_BASE \ - + V4L2_CID_PRIV_OFFSET + 2) - -extern unsigned int g_lcd_width; -extern unsigned int g_lcd_height; -extern unsigned int g_lcd_bpp; - -int v4l2_overlay_get(int name) -{ - int result = -1; - switch (name) { - case OVERLAY_MINIFICATION_LIMIT: - result = 4; /* 0 = no limit */ - break; - case OVERLAY_MAGNIFICATION_LIMIT: - result = 2; /* 0 = no limit */ - break; - case OVERLAY_SCALING_FRAC_BITS: - result = 0; /* 0 = infinite */ - break; - case OVERLAY_ROTATION_STEP_DEG: - result = 90; /* 90 rotation steps (for instance) */ - break; - case OVERLAY_HORIZONTAL_ALIGNMENT: - result = 1; /* 1-pixel alignment */ - break; - case OVERLAY_VERTICAL_ALIGNMENT: - result = 1; /* 1-pixel alignment */ - break; - case OVERLAY_WIDTH_ALIGNMENT: - result = 1; /* 1-pixel alignment */ - break; - case OVERLAY_HEIGHT_ALIGNMENT: - result = 1; /* 1-pixel alignment */ - break; - } - return result; -} - -int v4l2_overlay_open(int id) -{ - LOG_FUNCTION_NAME - return open(V4L2_DEVICE, O_RDWR); -} - -int v4l2_overlay_init_fimc(int fd, s5p_fimc_t *s5p_fimc) -{ - int ret; - struct v4l2_control vc; - - if (fd < 0) - return -1; - - vc.id = V4L2_CID_FIMC_VERSION; - vc.value = 0; - - s5p_fimc->dev_fd = fd; - - ret = ioctl(s5p_fimc->dev_fd, VIDIOC_G_CTRL, &vc); - if (ret < 0) { - LOGE("Error in video VIDIOC_G_CTRL - V4L2_CID_FIMC_VERSION (%d)", ret); - LOGE("FIMC version is set with default"); - vc.value = 0x43; - } - s5p_fimc->hw_ver = vc.value; - return 0; -} - -void dump_pixfmt(struct v4l2_pix_format *pix) -{ - LOGV("w: %d\n", pix->width); - LOGV("h: %d\n", pix->height); - LOGV("color: %x\n", pix->colorspace); - - switch (pix->pixelformat) { - case V4L2_PIX_FMT_YUYV: - LOGV("YUYV\n"); - break; - case V4L2_PIX_FMT_UYVY: - LOGV("UYVY\n"); - break; - case V4L2_PIX_FMT_RGB565: - LOGV("RGB565\n"); - break; - case V4L2_PIX_FMT_RGB565X: - LOGV("RGB565X\n"); - break; - default: - LOGV("not supported\n"); - } -} - -void dump_crop(struct v4l2_crop *crop) -{ - LOGV("crop l: %d ", crop->c.left); - LOGV("crop t: %d ", crop->c.top); - LOGV("crop w: %d ", crop->c.width); - LOGV("crop h: %d\n", crop->c.height); -} - -void dump_window(struct v4l2_window *win) -{ - LOGV("window l: %d ", win->w.left); - LOGV("window t: %d ", win->w.top); - LOGV("window w: %d ", win->w.width); - LOGV("window h: %d\n", win->w.height); -} - -void v4l2_overlay_dump_state(int fd) -{ - struct v4l2_format format; - struct v4l2_crop crop; - int ret; - - LOGV("dumping driver state:"); - format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT; - ret = ioctl(fd, VIDIOC_G_FMT, &format); - if (ret < 0) - return; - LOGV("output pixfmt:\n"); - dump_pixfmt(&format.fmt.pix); - - format.type = V4L2_BUF_TYPE_VIDEO_OVERLAY; - ret = ioctl(fd, VIDIOC_G_FMT, &format); - if (ret < 0) - return; - LOGV("v4l2_overlay window:\n"); - dump_window(&format.fmt.win); - - crop.type = V4L2_BUF_TYPE_VIDEO_OUTPUT; - ret = ioctl(fd, VIDIOC_G_CROP, &crop); - if (ret < 0) - return; - LOGV("output crop:\n"); - dump_crop(&crop); -} - -static void error(int fd, const char *msg) -{ - LOGE("Error = %s from %s", strerror(errno), msg); -#ifdef OVERLAY_DEBUG - v4l2_overlay_dump_state(fd); -#endif -} - -static int v4l2_overlay_ioctl(int fd, int req, void *arg, const char* msg) -{ - int ret; - ret = ioctl(fd, req, arg); - if (ret < 0) { - error(fd, msg); - return -1; - } - return 0; -} - -#define v4l2_fourcc(a, b, c, d) ((__u32)(a) | ((__u32)(b) << 8) | \ - ((__u32)(c) << 16) | ((__u32)(d) << 24)) -/* 12 Y/CbCr 4:2:0 64x32 macroblocks */ -#define V4L2_PIX_FMT_NV12T v4l2_fourcc('T', 'V', '1', '2') - -int configure_pixfmt(struct v4l2_pix_format *pix, int32_t fmt, - uint32_t w, uint32_t h) -{ - LOG_FUNCTION_NAME - int fd; - - switch (fmt) { - case OVERLAY_FORMAT_RGBA_8888: - return -1; - case OVERLAY_FORMAT_RGB_565: - pix->pixelformat = V4L2_PIX_FMT_RGB565; - break; - case OVERLAY_FORMAT_BGRA_8888: - return -1; - case OVERLAY_FORMAT_YCbYCr_422_I: - case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_422_I: - pix->pixelformat = V4L2_PIX_FMT_YUYV; - break; - case OVERLAY_FORMAT_CbYCrY_422_I: - case HAL_PIXEL_FORMAT_CUSTOM_CbYCrY_422_I: - pix->pixelformat = V4L2_PIX_FMT_UYVY; - break; - case HAL_PIXEL_FORMAT_YCbCr_420_P: - pix->pixelformat = V4L2_PIX_FMT_YUV420; - break; - case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP: - pix->pixelformat = V4L2_PIX_FMT_NV12T; - break; - case HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP: - pix->pixelformat = V4L2_PIX_FMT_NV21; - break; - default: - return -1; - } - pix->width = w; - pix->height = h; - return 0; -} - -static void configure_window(struct v4l2_window *win, int32_t w, - int32_t h, int32_t x, int32_t y) -{ - LOG_FUNCTION_NAME - - win->w.left = x; - win->w.top = y; - win->w.width = w; - win->w.height = h; -} - -void get_window(struct v4l2_format *format, int32_t *x, - int32_t *y, int32_t *w, int32_t *h) -{ - LOG_FUNCTION_NAME - - *x = format->fmt.win.w.left; - *y = format->fmt.win.w.top; - *w = format->fmt.win.w.width; - *h = format->fmt.win.w.height; -} - -int v4l2_overlay_init(int fd, uint32_t w, uint32_t h, uint32_t fmt, - uint32_t addr) -{ - LOG_FUNCTION_NAME - - struct v4l2_format format; - struct v4l2_framebuffer fbuf; - int ret; - - format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT; - ret = v4l2_overlay_ioctl(fd, VIDIOC_G_FMT, &format, "get format"); - if (ret) - return ret; - LOGV("v4l2_overlay_init:: w=%d h=%d\n", format.fmt.pix.width, - format.fmt.pix.height); - - format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT; - configure_pixfmt(&format.fmt.pix, fmt, w, h); - LOGV("v4l2_overlay_init:: w=%d h=%d\n", format.fmt.pix.width, - format.fmt.pix.height); - ret = v4l2_overlay_ioctl(fd, VIDIOC_S_FMT, &format, "set output format"); - if (ret) - return ret; - - ret = v4l2_overlay_s_fbuf(fd, 0); - if (ret) - return ret; - - return ret; -} - -int v4l2_overlay_s_fbuf(int fd, int rotation) -{ - struct v4l2_framebuffer fbuf; - int ret; - - /* configure the v4l2_overlay framebuffer */ - ret = v4l2_overlay_ioctl(fd, VIDIOC_G_FBUF, &fbuf, "get fbuf"); - if (ret) - return ret; - - /* if fbuf.base value is set by 0, using local DMA. */ - fbuf.base = (void *)0; - if (rotation == 0 || rotation == 180) { - fbuf.fmt.width = g_lcd_width; - fbuf.fmt.height = g_lcd_height; - } else { - fbuf.fmt.width = g_lcd_height; - fbuf.fmt.height = g_lcd_width; - } - - if (g_lcd_bpp == 32) - fbuf.fmt.pixelformat = V4L2_PIX_FMT_RGB32; - else - fbuf.fmt.pixelformat = V4L2_PIX_FMT_RGB565; - - ret = v4l2_overlay_ioctl(fd, VIDIOC_S_FBUF, &fbuf, "set fbuf"); - if (ret) - return ret; - - return ret; -} - -int v4l2_overlay_get_input_size_and_format(int fd, uint32_t *w, uint32_t *h - , uint32_t *fmt) -{ - LOG_FUNCTION_NAME - - struct v4l2_format format; - int ret; - - format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT; - ret = v4l2_overlay_ioctl(fd, VIDIOC_G_FMT, &format, "get format"); - *w = format.fmt.pix.width; - *h = format.fmt.pix.height; - if (format.fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV) - *fmt = OVERLAY_FORMAT_CbYCrY_422_I; - else - return -EINVAL; - return ret; -} - -int v4l2_overlay_set_position(int fd, int32_t x, int32_t y - , int32_t w, int32_t h, int rotation) -{ - LOG_FUNCTION_NAME - - struct v4l2_format format; - int ret; - int rot_x = 0, rot_y = 0 , rot_w = 0, rot_h = 0; - - /* configure the src format pix */ - /* configure the dst v4l2_overlay window */ - format.type = V4L2_BUF_TYPE_VIDEO_OVERLAY; - ret = v4l2_overlay_ioctl(fd, VIDIOC_G_FMT, &format, - "get v4l2_overlay format"); - if (ret) - return ret; - LOGV("v4l2_overlay_set_position:: w=%d h=%d", format.fmt.win.w.width - , format.fmt.win.w.height); - - if (rotation == 0) { - rot_x = x; - rot_y = y; - rot_w = w; - rot_h = h; - } else if (rotation == 90) { - rot_x = y; - rot_y = g_lcd_width - (x + w); - rot_w = h; - rot_h = w; - } else if (rotation == 180) { - rot_x = g_lcd_width - (x + w); - rot_y = g_lcd_height - (y + h); - rot_w = w; - rot_h = h; - } else if (rotation == 270) { - rot_x = g_lcd_height - (y + h); - rot_y = x; - rot_w = h; - rot_h = w; - } - - configure_window(&format.fmt.win, rot_w, rot_h, rot_x, rot_y); - - format.type = V4L2_BUF_TYPE_VIDEO_OVERLAY; - ret = v4l2_overlay_ioctl(fd, VIDIOC_S_FMT, &format, - "set v4l2_overlay format"); - - LOGV("v4l2_overlay_set_position:: w=%d h=%d rotation=%d" - , format.fmt.win.w.width, format.fmt.win.w.height, rotation); - - if (ret) - return ret; - v4l2_overlay_dump_state(fd); - - return 0; -} - -int v4l2_overlay_get_position(int fd, int32_t *x, int32_t *y, int32_t *w, - int32_t *h) -{ - struct v4l2_format format; - int ret; - - format.type = V4L2_BUF_TYPE_VIDEO_OVERLAY; - ret = v4l2_overlay_ioctl(fd, VIDIOC_G_FMT, &format, - "get v4l2_overlay format"); - - if (ret) - return ret; - - get_window(&format, x, y, w, h); - - return 0; -} - -int v4l2_overlay_set_crop(int fd, uint32_t x, uint32_t y, uint32_t w, - uint32_t h) -{ - LOG_FUNCTION_NAME - - struct v4l2_crop crop; - int ret; - - crop.type = V4L2_BUF_TYPE_VIDEO_OUTPUT; - ret = v4l2_overlay_ioctl(fd, VIDIOC_G_CROP, &crop, "get crop"); - crop.c.left = x; - crop.c.top = y; - crop.c.width = w; - crop.c.height = h; - crop.type = V4L2_BUF_TYPE_VIDEO_OUTPUT; - - LOGV("%s:crop.c.left = %d\n", __func__, crop.c.left); - LOGV("%s:crop.c.top = %d\n", __func__, crop.c.top); - LOGV("%s:crop.c.width = %d\n", __func__, crop.c.width); - LOGV("%s:crop.c.height = %d\n", __func__, crop.c.height); - LOGV("%s:crop.type = 0x%x\n", __func__, crop.type); - - return v4l2_overlay_ioctl(fd, VIDIOC_S_CROP, &crop, "set crop"); -} - -int v4l2_overlay_get_crop(int fd, uint32_t *x, uint32_t *y, uint32_t *w, - uint32_t *h) -{ - LOG_FUNCTION_NAME - - struct v4l2_crop crop; - int ret; - - crop.type = V4L2_BUF_TYPE_VIDEO_OUTPUT; - ret = v4l2_overlay_ioctl(fd, VIDIOC_G_CROP, &crop, "get crop"); - *x = crop.c.left; - *y = crop.c.top; - *w = crop.c.width; - *h = crop.c.height; - return ret; -} - -int v4l2_overlay_set_flip(int fd, int flip) -{ - LOG_FUNCTION_NAME - - int ret; - struct v4l2_control ctrl_v; - struct v4l2_control ctrl_h; - - switch (flip) { - case 0: - ctrl_v.value = 0; - ctrl_h.value = 0; - break; - case V4L2_CID_HFLIP: - ctrl_v.value = 0; - ctrl_h.value = 1; - break; - case V4L2_CID_VFLIP: - ctrl_v.value = 1; - ctrl_h.value = 0; - break; - default: - return -1; - } - - ctrl_v.id = V4L2_CID_VFLIP; - ret = v4l2_overlay_ioctl(fd, VIDIOC_S_CTRL, &ctrl_v, "set vflip"); - if (ret) return ret; - - ctrl_h.id = V4L2_CID_HFLIP; - ret = v4l2_overlay_ioctl(fd, VIDIOC_S_CTRL, &ctrl_h, "set hflip"); - return ret; -} - -int v4l2_overlay_set_rotation(int fd, int degree, int step) -{ - LOG_FUNCTION_NAME - - int ret; - struct v4l2_control ctrl; - - ctrl.id = V4L2_CID_PRIV_ROTATION; - ctrl.value = degree; - ret = v4l2_overlay_ioctl(fd, VIDIOC_S_CTRL, &ctrl, "set rotation"); - - return ret; -} - -int v4l2_overlay_set_colorkey(int fd, int enable, int colorkey) -{ - LOG_FUNCTION_NAME - - int ret; - struct v4l2_framebuffer fbuf; - struct v4l2_format fmt; - - memset(&fbuf, 0, sizeof(fbuf)); - ret = v4l2_overlay_ioctl(fd, VIDIOC_G_FBUF, &fbuf, - "get transparency enables"); - - if (ret) - return ret; - - if (enable) - fbuf.flags |= V4L2_FBUF_FLAG_CHROMAKEY; - else - fbuf.flags &= ~V4L2_FBUF_FLAG_CHROMAKEY; - - ret = v4l2_overlay_ioctl(fd, VIDIOC_S_FBUF, &fbuf, "enable colorkey"); - - if (ret) - return ret; - - if (enable) { - memset(&fmt, 0, sizeof(fmt)); - fmt.type = V4L2_BUF_TYPE_VIDEO_OVERLAY; - ret = v4l2_overlay_ioctl(fd, VIDIOC_G_FMT, &fmt, "get colorkey"); - - if (ret) - return ret; - - fmt.fmt.win.chromakey = colorkey & 0xFFFFFF; - - ret = v4l2_overlay_ioctl(fd, VIDIOC_S_FMT, &fmt, "set colorkey"); - } - - return ret; -} - -int v4l2_overlay_set_global_alpha(int fd, int enable, int alpha) -{ - LOG_FUNCTION_NAME - - int ret; - struct v4l2_framebuffer fbuf; - struct v4l2_format fmt; - - memset(&fbuf, 0, sizeof(fbuf)); - ret = v4l2_overlay_ioctl(fd, VIDIOC_G_FBUF, &fbuf, - "get transparency enables"); - - if (ret) - return ret; - - if (enable) - fbuf.flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA; - else - fbuf.flags &= ~V4L2_FBUF_FLAG_GLOBAL_ALPHA; - - ret = v4l2_overlay_ioctl(fd, VIDIOC_S_FBUF, &fbuf, "enable global alpha"); - - if (ret) - return ret; - - if (enable) { - memset(&fmt, 0, sizeof(fmt)); - fmt.type = V4L2_BUF_TYPE_VIDEO_OVERLAY; - ret = v4l2_overlay_ioctl(fd, VIDIOC_G_FMT, &fmt, "get global alpha"); - - if (ret) - return ret; - - fmt.fmt.win.global_alpha = alpha & 0xFF; - - ret = v4l2_overlay_ioctl(fd, VIDIOC_S_FMT, &fmt, "set global alpha"); - } - - return ret; -} - -int v4l2_overlay_set_local_alpha(int fd, int enable) -{ - int ret; - struct v4l2_framebuffer fbuf; - - ret = 0; - - return ret; -} - -int v4l2_overlay_req_buf(int fd, uint32_t *num_bufs, int cacheable_buffers, int zerocopy) -{ - struct v4l2_requestbuffers reqbuf; - int ret, i; - - reqbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT; - - if (zerocopy) - reqbuf.memory = V4L2_MEMORY_USERPTR; - else - reqbuf.memory = V4L2_MEMORY_MMAP; - reqbuf.count = *num_bufs; - - ret = ioctl(fd, VIDIOC_REQBUFS, &reqbuf); - if (ret < 0) { - error(fd, "reqbuf ioctl"); - return ret; - } - - if (reqbuf.count > *num_bufs) { - error(fd, "Not enough buffer structs passed to get_buffers"); - return -ENOMEM; - } - *num_bufs = reqbuf.count; - - return 0; -} - -static int is_mmaped(struct v4l2_buffer *buf) -{ - return buf->flags == V4L2_BUF_FLAG_MAPPED; -} - -static int is_queued(struct v4l2_buffer *buf) -{ - /* is either on the input or output queue in the kernel */ - return (buf->flags & V4L2_BUF_FLAG_QUEUED) || - (buf->flags & V4L2_BUF_FLAG_DONE); -} - -static int is_dequeued(struct v4l2_buffer *buf) -{ - /* is on neither input or output queue in kernel */ - return !(buf->flags & V4L2_BUF_FLAG_QUEUED) && - !(buf->flags & V4L2_BUF_FLAG_DONE); -} - -int v4l2_overlay_query_buffer(int fd, int index, struct v4l2_buffer *buf) -{ - LOG_FUNCTION_NAME - - memset(buf, 0, sizeof(struct v4l2_buffer)); - - buf->type = V4L2_BUF_TYPE_VIDEO_OUTPUT; - buf->memory = V4L2_MEMORY_MMAP; - buf->index = index; - LOGV("query buffer, mem=%u type=%u index=%u\n", - buf->memory, buf->type, buf->index); - return v4l2_overlay_ioctl(fd, VIDIOC_QUERYBUF, buf, "querybuf ioctl"); -} - -int v4l2_overlay_map_buf(int fd, int index, void **start, size_t *len) -{ - LOG_FUNCTION_NAME - - struct v4l2_buffer buf; - int ret; - - ret = v4l2_overlay_query_buffer(fd, index, &buf); - if (ret) - return ret; - - if (is_mmaped(&buf)) { - LOGE("Trying to mmap buffers that are already mapped!\n"); - return -EINVAL; - } - - *len = buf.length; - *start = mmap(NULL, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, - fd, buf.m.offset); - if (*start == MAP_FAILED) { - LOGE("map failed, length=%u offset=%u\n", buf.length, buf.m.offset); - return -EINVAL; - } - return 0; -} - -int v4l2_overlay_unmap_buf(void *start, size_t len) -{ - LOG_FUNCTION_NAME - return munmap(start, len); -} - - -int v4l2_overlay_get_caps(int fd, struct v4l2_capability *caps) -{ - return v4l2_overlay_ioctl(fd, VIDIOC_QUERYCAP, caps, "query cap"); -} - -int v4l2_overlay_stream_on(int fd) -{ - int ret; - uint32_t type = V4L2_BUF_TYPE_VIDEO_OUTPUT; - - ret = v4l2_overlay_set_local_alpha(fd, 1); - if (ret) - return ret; - - ret = v4l2_overlay_ioctl(fd, VIDIOC_STREAMON, &type, "stream on"); - - return ret; -} - -int v4l2_overlay_stream_off(int fd) -{ - int ret; - uint32_t type = V4L2_BUF_TYPE_VIDEO_OUTPUT; - - ret = v4l2_overlay_set_local_alpha(fd, 0); - if (ret) - return ret; - - ret = v4l2_overlay_ioctl(fd, VIDIOC_STREAMOFF, &type, "stream off"); - - return ret; -} - -int v4l2_overlay_q_buf(int fd, int buffer, int zerocopy) -{ - struct v4l2_buffer buf; - int ret; - - if (zerocopy) { - uint8_t *pPhyYAddr; - uint8_t *pPhyCAddr; - struct fimc_buf fimc_src_buf; - uint8_t index; - - memcpy(&pPhyYAddr, (void *) buffer, sizeof(pPhyYAddr)); - memcpy(&pPhyCAddr, (void *) (buffer + sizeof(pPhyYAddr)), - sizeof(pPhyCAddr)); - memcpy(&index, - (void *) (buffer + sizeof(pPhyYAddr) + sizeof(pPhyCAddr)), - sizeof(index)); - - fimc_src_buf.base[0] = (dma_addr_t) pPhyYAddr; - fimc_src_buf.base[1] = (dma_addr_t) pPhyCAddr; - fimc_src_buf.base[2] = - (dma_addr_t) (pPhyCAddr + (pPhyCAddr - pPhyYAddr)/4); - - buf.index = index; - buf.memory = V4L2_MEMORY_USERPTR; - buf.m.userptr = (unsigned long)&fimc_src_buf; - buf.length = 0; - } else { - buf.index = buffer; - buf.memory = V4L2_MEMORY_MMAP; - } - - buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT; - buf.field = V4L2_FIELD_NONE; - buf.timestamp.tv_sec = 0; - buf.timestamp.tv_usec = 0; - buf.flags = 0; - - return v4l2_overlay_ioctl(fd, VIDIOC_QBUF, &buf, "qbuf"); -} - -int v4l2_overlay_dq_buf(int fd, int *index, int zerocopy) -{ - struct v4l2_buffer buf; - int ret; - - buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT; - - if (zerocopy) - buf.memory = V4L2_MEMORY_USERPTR; - else - buf.memory = V4L2_MEMORY_MMAP; - - ret = v4l2_overlay_ioctl(fd, VIDIOC_DQBUF, &buf, "dqbuf"); - if (ret) - return ret; - *index = buf.index; - return 0; -} diff --git a/liboverlay/v4l2_utils.h b/liboverlay/v4l2_utils.h deleted file mode 100644 index 02797c3..0000000 --- a/liboverlay/v4l2_utils.h +++ /dev/null @@ -1,75 +0,0 @@ -/* - * Copyright 2009 Google Inc. All Rights Reserved. - * Author: rschultz@google.com (Rebecca Schultz Zavin) - */ - -#ifndef ANDROID_ZOOM_REPO_HARDWARE_SEC_LIBOVERLAY_V4L2_UTILS_H_ -#define ANDROID_ZOOM_REPO_HARDWARE_SEC_LIBOVERLAY_V4L2_UTILS_H_ - -#include "s5p_fimc.h" - -int v4l2_overlay_open(int id); -int v4l2_overlay_get_caps(int fd, struct v4l2_capability *caps); -int v4l2_overlay_req_buf(int fd, uint32_t *num_bufs, int cacheable_buffers, - int zerocopy); -int v4l2_overlay_query_buffer(int fd, int index, struct v4l2_buffer *buf); -int v4l2_overlay_map_buf(int fd, int index, void **start, size_t *len); -int v4l2_overlay_unmap_buf(void *start, size_t len); -int v4l2_overlay_stream_on(int fd); -int v4l2_overlay_stream_off(int fd); -int v4l2_overlay_q_buf(int fd, int index, int zerocopy); -int v4l2_overlay_dq_buf(int fd, int *index, int zerocopy); -int v4l2_overlay_init(int fd, uint32_t w, uint32_t h, uint32_t fmt, - uint32_t addr); -int v4l2_overlay_get_input_size(int fd, uint32_t *w, uint32_t *h, - uint32_t *fmt); -int v4l2_overlay_set_position(int fd, int32_t x, int32_t y, int32_t w, - int32_t h, int rotation); -int v4l2_overlay_get_position(int fd, int32_t *x, int32_t *y, int32_t *w, - int32_t *h); -int v4l2_overlay_set_crop(int fd, uint32_t x, uint32_t y, uint32_t w, - uint32_t h); -int v4l2_overlay_get_crop(int fd, uint32_t *x, uint32_t *y, uint32_t *w, - uint32_t *h); -int v4l2_overlay_set_flip(int fd, int degree); -int v4l2_overlay_set_rotation(int fd, int degree, int step); -int v4l2_overlay_set_colorkey(int fd, int enable, int colorkey); -int v4l2_overlay_set_global_alpha(int fd, int enable, int alpha); -int v4l2_overlay_set_local_alpha(int fd, int enable); -int v4l2_overlay_init_fimc(int fd, s5p_fimc_t *s5p_fimc); -int v4l2_overlay_s_fbuf(int fd, int rotation); - -enum { - V4L2_OVERLAY_PLANE_GRAPHICS, - V4L2_OVERLAY_PLANE_VIDEO1, - V4L2_OVERLAY_PLANE_VIDEO2, -}; - -enum { - /* support customed format for zero copy */ - HAL_PIXEL_FORMAT_YCbCr_420_SP = 0x21, - HAL_PIXEL_FORMAT_YCbCr_420_P = 0x13, - HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP = 0x100, - HAL_PIXEL_FORMAT_CUSTOM_YCbCr_422_I = 0x101, - HAL_PIXEL_FORMAT_CUSTOM_CbYCrY_422_I = 0x102, - HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP = 0x103, - HAL_PIXEL_FORMAT_CUSTOM_MAX -}; - -enum { - PFT_RGB, - PFT_YUV420, - PFT_YUV422, - PFT_YUV444, -}; - -struct mapping_data { - int fd; - size_t length; - uint32_t offset; - void *ptr; -}; - -#define ALL_BUFFERS_FLUSHED -66 - -#endif /* ANDROID_ZOOM_REPO_HARDWARE_SEC_LIBOVERLAY_V4L2_UTILS_H_*/ diff --git a/libs3cjpeg/Android.mk b/libs3cjpeg/Android.mk deleted file mode 100644 index 7a1acd6..0000000 --- a/libs3cjpeg/Android.mk +++ /dev/null @@ -1,36 +0,0 @@ -ifeq ($(Y_U_NO_HAVE_CAMERA),true) -# Copyright (C) 2008 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. - -LOCAL_PATH:= $(call my-dir) -include $(CLEAR_VARS) - - -LOCAL_C_INCLUDES := $(LOCAL_PATH) -LOCAL_C_INCLUDES += $(LOCAL_PATH)/../include - -LOCAL_SRC_FILES:= \ - JpegEncoder.cpp - -LOCAL_SHARED_LIBRARIES:= liblog -LOCAL_SHARED_LIBRARIES+= libdl - -LOCAL_MODULE:= libs3cjpeg.aries - -LOCAL_MODULE_TAGS := optional - -LOCAL_PRELINK_MODULE := false - -include $(BUILD_SHARED_LIBRARY) -endif diff --git a/libs3cjpeg/Exif.h b/libs3cjpeg/Exif.h deleted file mode 100644 index 96e11dd..0000000 --- a/libs3cjpeg/Exif.h +++ /dev/null @@ -1,233 +0,0 @@ -/* - * Copyright Samsung Electronics Co.,LTD. - * Copyright (C) 2010 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_HARDWARE_EXIF_H -#define ANDROID_HARDWARE_EXIF_H - -#include - -#define EXIF_LOG2(x) (log((double)(x)) / log(2.0)) -#define APEX_FNUM_TO_APERTURE(x) ((int)(EXIF_LOG2((double)(x)) * 2 + 0.5)) -#define APEX_EXPOSURE_TO_SHUTTER(x) ((x) >= 1 ? \ - (int)(-(EXIF_LOG2((double)(x)) + 0.5)) : \ - (int)(-(EXIF_LOG2((double)(x)) - 0.5))) -#define APEX_ISO_TO_FILMSENSITIVITY(x) ((int)(EXIF_LOG2((x) / 3.125) + 0.5)) - -#define NUM_SIZE 2 -#define IFD_SIZE 12 -#define OFFSET_SIZE 4 - -#define NUM_0TH_IFD_TIFF 10 -#define NUM_0TH_IFD_EXIF 22 -#define NUM_0TH_IFD_GPS 10 -#define NUM_1TH_IFD_TIFF 9 - -/* Type */ -#define EXIF_TYPE_BYTE 1 -#define EXIF_TYPE_ASCII 2 -#define EXIF_TYPE_SHORT 3 -#define EXIF_TYPE_LONG 4 -#define EXIF_TYPE_RATIONAL 5 -#define EXIF_TYPE_UNDEFINED 7 -#define EXIF_TYPE_SLONG 9 -#define EXIF_TYPE_SRATIONAL 10 - -#define EXIF_FILE_SIZE 28800 - -/* 0th IFD TIFF Tags */ -#define EXIF_TAG_IMAGE_WIDTH 0x0100 -#define EXIF_TAG_IMAGE_HEIGHT 0x0101 -#define EXIF_TAG_MAKE 0x010f -#define EXIF_TAG_MODEL 0x0110 -#define EXIF_TAG_ORIENTATION 0x0112 -#define EXIF_TAG_SOFTWARE 0x0131 -#define EXIF_TAG_DATE_TIME 0x0132 -#define EXIF_TAG_YCBCR_POSITIONING 0x0213 -#define EXIF_TAG_EXIF_IFD_POINTER 0x8769 -#define EXIF_TAG_GPS_IFD_POINTER 0x8825 - -/* 0th IFD Exif Private Tags */ -#define EXIF_TAG_EXPOSURE_TIME 0x829A -#define EXIF_TAG_FNUMBER 0x829D -#define EXIF_TAG_EXPOSURE_PROGRAM 0x8822 -#define EXIF_TAG_ISO_SPEED_RATING 0x8827 -#define EXIF_TAG_EXIF_VERSION 0x9000 -#define EXIF_TAG_DATE_TIME_ORG 0x9003 -#define EXIF_TAG_DATE_TIME_DIGITIZE 0x9004 -#define EXIF_TAG_SHUTTER_SPEED 0x9201 -#define EXIF_TAG_APERTURE 0x9202 -#define EXIF_TAG_BRIGHTNESS 0x9203 -#define EXIF_TAG_EXPOSURE_BIAS 0x9204 -#define EXIF_TAG_MAX_APERTURE 0x9205 -#define EXIF_TAG_METERING_MODE 0x9207 -#define EXIF_TAG_FLASH 0x9209 -#define EXIF_TAG_FOCAL_LENGTH 0x920A -#define EXIF_TAG_USER_COMMENT 0x9286 -#define EXIF_TAG_COLOR_SPACE 0xA001 -#define EXIF_TAG_PIXEL_X_DIMENSION 0xA002 -#define EXIF_TAG_PIXEL_Y_DIMENSION 0xA003 -#define EXIF_TAG_EXPOSURE_MODE 0xA402 -#define EXIF_TAG_WHITE_BALANCE 0xA403 -#define EXIF_TAG_SCENCE_CAPTURE_TYPE 0xA406 - -/* 0th IFD GPS Info Tags */ -#define EXIF_TAG_GPS_VERSION_ID 0x0000 -#define EXIF_TAG_GPS_LATITUDE_REF 0x0001 -#define EXIF_TAG_GPS_LATITUDE 0x0002 -#define EXIF_TAG_GPS_LONGITUDE_REF 0x0003 -#define EXIF_TAG_GPS_LONGITUDE 0x0004 -#define EXIF_TAG_GPS_ALTITUDE_REF 0x0005 -#define EXIF_TAG_GPS_ALTITUDE 0x0006 -#define EXIF_TAG_GPS_TIMESTAMP 0x0007 -#define EXIF_TAG_GPS_PROCESSING_METHOD 0x001B -#define EXIF_TAG_GPS_DATESTAMP 0x001D - -/* 1th IFD TIFF Tags */ -#define EXIF_TAG_COMPRESSION_SCHEME 0x0103 -#define EXIF_TAG_X_RESOLUTION 0x011A -#define EXIF_TAG_Y_RESOLUTION 0x011B -#define EXIF_TAG_RESOLUTION_UNIT 0x0128 -#define EXIF_TAG_JPEG_INTERCHANGE_FORMAT 0x0201 -#define EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LEN 0x0202 - - -typedef enum { - EXIF_ORIENTATION_UP = 1, - EXIF_ORIENTATION_90 = 6, - EXIF_ORIENTATION_180 = 3, - EXIF_ORIENTATION_270 = 8, -} ExifOrientationType; - -typedef enum { - EXIF_SCENE_STANDARD, - EXIF_SCENE_LANDSCAPE, - EXIF_SCENE_PORTRAIT, - EXIF_SCENE_NIGHT, -} CamExifSceneCaptureType; - -typedef enum { - EXIF_METERING_UNKNOWN, - EXIF_METERING_AVERAGE, - EXIF_METERING_CENTER, - EXIF_METERING_SPOT, - EXIF_METERING_MULTISPOT, - EXIF_METERING_PATTERN, - EXIF_METERING_PARTIAL, - EXIF_METERING_OTHER = 255, -} CamExifMeteringModeType; - -typedef enum { - EXIF_EXPOSURE_AUTO, - EXIF_EXPOSURE_MANUAL, - EXIF_EXPOSURE_AUTO_BRACKET, -} CamExifExposureModeType; - -typedef enum { - EXIF_WB_AUTO, - EXIF_WB_MANUAL, -} CamExifWhiteBalanceType; - -/* Values */ -#define EXIF_DEF_MAKER "SAMSUNG" -#define EXIF_DEF_MODEL "GT-I9020" -#define EXIF_DEF_SOFTWARE "CRESPOJH2" -#define EXIF_DEF_EXIF_VERSION "0220" -#define EXIF_DEF_USERCOMMENTS "User comments" - -#define EXIF_DEF_YCBCR_POSITIONING 1 /* centered */ -#define EXIF_DEF_FNUMBER_NUM 26 /* 2.6 */ -#define EXIF_DEF_FNUMBER_DEN 10 -#define EXIF_DEF_EXPOSURE_PROGRAM 3 /* aperture priority */ -#define EXIF_DEF_FOCAL_LEN_NUM 278 /* 2.78mm */ -#define EXIF_DEF_FOCAL_LEN_DEN 100 -#define EXIF_DEF_FLASH 0 /* O: off, 1: on*/ -#define EXIF_DEF_COLOR_SPACE 1 -#define EXIF_DEF_EXPOSURE_MODE EXIF_EXPOSURE_AUTO -#define EXIF_DEF_APEX_DEN 10 - -#define EXIF_DEF_COMPRESSION 6 -#define EXIF_DEF_RESOLUTION_NUM 72 -#define EXIF_DEF_RESOLUTION_DEN 1 -#define EXIF_DEF_RESOLUTION_UNIT 2 /* inches */ - -typedef struct { - uint32_t num; - uint32_t den; -} rational_t; - -typedef struct { - int32_t num; - int32_t den; -} srational_t; - -typedef struct { - bool enableGps; - bool enableThumb; - - unsigned char maker[32]; - unsigned char model[32]; - unsigned char software[32]; - unsigned char exif_version[4]; - unsigned char date_time[20]; - unsigned char user_comment[150]; - - uint32_t width; - uint32_t height; - uint32_t widthThumb; - uint32_t heightThumb; - - uint16_t orientation; - uint16_t ycbcr_positioning; - uint16_t exposure_program; - uint16_t iso_speed_rating; - uint16_t metering_mode; - uint16_t flash; - uint16_t color_space; - uint16_t exposure_mode; - uint16_t white_balance; - uint16_t scene_capture_type; - - rational_t exposure_time; - rational_t fnumber; - rational_t aperture; - rational_t max_aperture; - rational_t focal_length; - - srational_t shutter_speed; - srational_t brightness; - srational_t exposure_bias; - - unsigned char gps_latitude_ref[2]; - unsigned char gps_longitude_ref[2]; - - uint8_t gps_version_id[4]; - uint8_t gps_altitude_ref; - - rational_t gps_latitude[3]; - rational_t gps_longitude[3]; - rational_t gps_altitude; - rational_t gps_timestamp[3]; - unsigned char gps_datestamp[11]; - unsigned char gps_processing_method[100]; - - rational_t x_resolution; - rational_t y_resolution; - uint16_t resolution_unit; - uint16_t compression_scheme; -} exif_attribute_t; - - -#endif /* ANDROID_HARDWARE_EXIF_H */ diff --git a/libs3cjpeg/JpegEncoder.cpp b/libs3cjpeg/JpegEncoder.cpp deleted file mode 100644 index 1361bca..0000000 --- a/libs3cjpeg/JpegEncoder.cpp +++ /dev/null @@ -1,796 +0,0 @@ -/* - * Copyright Samsung Electronics Co.,LTD. - * Copyright (C) 2010 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. - * - * JPEG DRIVER MODULE (JpegEncoder.cpp) - * Author : ge.lee -- initial version - * Date : 03 June 2010 - * Purpose : This file implements the JPEG encoder APIs as needed by Camera HAL - */ -#define LOG_TAG "JpegEncoder" -#define MAIN_DUMP 0 -#define THUMB_DUMP 0 - -#include -#include -#include - -#include "JpegEncoder.h" - -static const char ExifAsciiPrefix[] = { 0x41, 0x53, 0x43, 0x49, 0x49, 0x0, 0x0, 0x0 }; - -namespace android { -JpegEncoder::JpegEncoder() : available(false) -{ - mArgs.mmapped_addr = (char *)MAP_FAILED; - mArgs.enc_param = NULL; - mArgs.thumb_enc_param = NULL; - - mDevFd = open(JPG_DRIVER_NAME, O_RDWR); - if (mDevFd < 0) { - LOGE("Failed to open the device"); - return; - } - - mArgs.mmapped_addr = (char *)mmap(0, - JPG_TOTAL_BUF_SIZE, - PROT_READ | PROT_WRITE, - MAP_SHARED, - mDevFd, - 0); - - if (mArgs.mmapped_addr == MAP_FAILED) { - LOGE("Failed to mmap"); - return; - } - - mArgs.enc_param = new jpg_enc_proc_param; - if (mArgs.enc_param == NULL) { - LOGE("Failed to allocate the memory for enc_param"); - return; - } - memset(mArgs.enc_param, 0, sizeof(jpg_enc_proc_param)); - - mArgs.thumb_enc_param = new jpg_enc_proc_param; - if (mArgs.thumb_enc_param == NULL) { - LOGE("Failed to allocate the memory for thumb_enc_param"); - delete mArgs.enc_param; - return; - } - memset(mArgs.thumb_enc_param, 0, sizeof(jpg_enc_proc_param)); - - mArgs.enc_param->sample_mode = JPG_420; - mArgs.enc_param->enc_type = JPG_MAIN; - mArgs.thumb_enc_param->sample_mode = JPG_420; - mArgs.thumb_enc_param->enc_type = JPG_THUMBNAIL; - - available = true; -} - -JpegEncoder::~JpegEncoder() -{ - if (mArgs.mmapped_addr != (char*)MAP_FAILED) - munmap(mArgs.mmapped_addr, JPG_TOTAL_BUF_SIZE); - - delete mArgs.enc_param; - - delete mArgs.thumb_enc_param; - - if (mDevFd > 0) - close(mDevFd); -} - -jpg_return_status JpegEncoder::setConfig(jpeg_conf type, int32_t value) -{ - if (!available) - return JPG_FAIL; - - jpg_return_status ret = JPG_SUCCESS; - - switch (type) { - case JPEG_SET_ENCODE_WIDTH: - if (value < 0 || value > MAX_JPG_WIDTH) - ret = JPG_FAIL; - else - mArgs.enc_param->width = value; - break; - - case JPEG_SET_ENCODE_HEIGHT: - if (value < 0 || value > MAX_JPG_HEIGHT) - ret = JPG_FAIL; - else - mArgs.enc_param->height = value; - break; - - case JPEG_SET_ENCODE_QUALITY: - if (value < JPG_QUALITY_LEVEL_1 || value > JPG_QUALITY_LEVEL_4) - ret = JPG_FAIL; - else - mArgs.enc_param->quality = (image_quality_type_t)value; - break; - - case JPEG_SET_ENCODE_IN_FORMAT: - if (value != JPG_MODESEL_YCBCR && value != JPG_MODESEL_RGB) { - ret = JPG_FAIL; - } else { - mArgs.enc_param->in_format = (in_mode_t)value; - mArgs.thumb_enc_param->in_format = (in_mode_t)value; - } - break; - - case JPEG_SET_SAMPING_MODE: - if (value != JPG_420 && value != JPG_422) { - ret = JPG_FAIL; - } else { - mArgs.enc_param->sample_mode = (sample_mode_t)value; - mArgs.thumb_enc_param->sample_mode = (sample_mode_t)value; - } - break; - - case JPEG_SET_THUMBNAIL_WIDTH: - if (value < 0 || value > MAX_JPG_THUMBNAIL_WIDTH) - ret = JPG_FAIL; - else - mArgs.thumb_enc_param->width = value; - break; - - case JPEG_SET_THUMBNAIL_HEIGHT: - if (value < 0 || value > MAX_JPG_THUMBNAIL_HEIGHT) - ret = JPG_FAIL; - else - mArgs.thumb_enc_param->height = value; - break; - - default: - LOGE("Invalid Config type"); - ret = ERR_UNKNOWN; - } - - if (ret == JPG_FAIL) - LOGE("Invalid value(%d) for %d type", value, type); - - return ret; -} - -void* JpegEncoder::getInBuf(uint64_t size) -{ - if (!available) - return NULL; - - if (size > JPG_FRAME_BUF_SIZE) { - LOGE("The buffer size requested is too large"); - return NULL; - } - mArgs.in_buf = (char *)ioctl(mDevFd, IOCTL_JPG_GET_FRMBUF, mArgs.mmapped_addr); - return (void *)(mArgs.in_buf); -} - -void* JpegEncoder::getOutBuf(uint64_t *size) -{ - if (!available) - return NULL; - - if (mArgs.enc_param->file_size <= 0) { - LOGE("The buffer requested doesn't have data"); - return NULL; - } - mArgs.out_buf = (char *)ioctl(mDevFd, IOCTL_JPG_GET_STRBUF, mArgs.mmapped_addr); - *size = mArgs.enc_param->file_size; - return (void *)(mArgs.out_buf); -} - -void* JpegEncoder::getThumbInBuf(uint64_t size) -{ - if (!available) - return NULL; - - if (size > JPG_FRAME_THUMB_BUF_SIZE) { - LOGE("The buffer size requested is too large"); - return NULL; - } - mArgs.in_thumb_buf = (char *)ioctl(mDevFd, IOCTL_JPG_GET_THUMB_FRMBUF, mArgs.mmapped_addr); - return (void *)(mArgs.in_thumb_buf); -} - -void* JpegEncoder::getThumbOutBuf(uint64_t *size) -{ - if (!available) - return NULL; - - if (mArgs.thumb_enc_param->file_size <= 0) { - LOGE("The buffer requested doesn't have data"); - return NULL; - } - mArgs.out_thumb_buf = (char *)ioctl(mDevFd, IOCTL_JPG_GET_THUMB_STRBUF, mArgs.mmapped_addr); - *size = mArgs.thumb_enc_param->file_size; - return (void *)(mArgs.out_thumb_buf); -} - -jpg_return_status JpegEncoder::encode(unsigned int *size, exif_attribute_t *exifInfo) -{ - if (!available) - return JPG_FAIL; - - LOGD("encode E"); - - jpg_return_status ret = JPG_FAIL; - unsigned char *exifOut = NULL; - jpg_enc_proc_param *param = mArgs.enc_param; - - ret = checkMcu(param->sample_mode, param->width, param->height, false); - if (ret != JPG_SUCCESS) - return ret; - - param->enc_type = JPG_MAIN; - ret = (jpg_return_status)ioctl(mDevFd, IOCTL_JPG_ENCODE, &mArgs); - if (ret != JPG_SUCCESS) { - LOGE("Failed to encode main image"); - return ret; - } - - mArgs.out_buf = (char *)ioctl(mDevFd, IOCTL_JPG_GET_STRBUF, mArgs.mmapped_addr); - - if (exifInfo) { - unsigned int thumbLen, exifLen; - - uint_t bufSize = 0; - if (exifInfo->enableThumb) { - ret = encodeThumbImg(&thumbLen); - if (ret != JPG_SUCCESS) { - LOGE("Failed to encode for thumbnail image"); - bufSize = EXIF_FILE_SIZE; - exifInfo->enableThumb = false; - } else { - bufSize = EXIF_FILE_SIZE + thumbLen; - } - } else { - bufSize = EXIF_FILE_SIZE; - } - - if (mArgs.enc_param->file_size + bufSize > JPG_TOTAL_BUF_SIZE) - return ret; - - exifOut = new unsigned char[bufSize]; - if (exifOut == NULL) { - LOGE("Failed to allocate for exifOut"); - return ret; - } - memset(exifOut, 0, bufSize); - - ret = makeExif (exifOut, exifInfo, &exifLen); - if (ret != JPG_SUCCESS) { - LOGE("Failed to make EXIF"); - delete[] exifOut; - return ret; - } - - memmove(&mArgs.out_buf[exifLen + 2], &mArgs.out_buf[2], param->file_size - 2); - memcpy(&mArgs.out_buf[2], exifOut, exifLen); - param->file_size += exifLen; - } - - delete[] exifOut; - - *size = param->file_size; - -#if MAIN_DUMP - FILE *fout = NULL; - char file_name[50] = "/data/main.jpg"; - fout = fopen(file_name, "wb"); - if (!fout) - perror(&file_name[0]); - size_t nwrite = fwrite(mArgs.out_buf, sizeof(char), param->file_size, fout); - fclose(fout); -#endif - - LOGD("encode X"); - - return ret; -} - -jpg_return_status JpegEncoder::encodeThumbImg(unsigned int *size, bool useMain) -{ - if (!available) - return JPG_FAIL; - - LOGD("encodeThumbImg E"); - - jpg_return_status ret = JPG_FAIL; - jpg_enc_proc_param *param = mArgs.thumb_enc_param; - - if (useMain) { - mArgs.in_thumb_buf = (char *)getThumbInBuf(param->width*param->height*2); - if (mArgs.in_thumb_buf == NULL) { - LOGE("Failed to get the buffer for thumbnail"); - return JPG_FAIL; - } - - ret = (jpg_return_status)scaleDownYuv422(mArgs.in_buf, - mArgs.enc_param->width, - mArgs.enc_param->height, - mArgs.in_thumb_buf, - param->width, - param->height); - if (ret != JPG_SUCCESS) - return JPG_FAIL; - } - - ret = checkMcu(param->sample_mode, param->width, param->height, true); - if (ret != JPG_SUCCESS) - return JPG_FAIL; - - mArgs.enc_param->enc_type = JPG_THUMBNAIL; - ret = (jpg_return_status)ioctl(mDevFd, IOCTL_JPG_ENCODE, &mArgs); - if (ret != JPG_SUCCESS) { - LOGE("Failed to encode for thumbnail"); - return JPG_FAIL; - } - - mArgs.out_thumb_buf = (char *)ioctl(mDevFd, IOCTL_JPG_GET_THUMB_STRBUF, mArgs.mmapped_addr); - -#if THUMB_DUMP - FILE *fout = NULL; - char file_name[50] = "/data/thumb.jpg"; - fout = fopen(file_name, "wb"); - if (!fout) - perror(&file_name[0]); - size_t nwrite = fwrite(mArgs.out_thumb_buf, sizeof(char), param->file_size, fout); - fclose(fout); -#endif - - LOGD("encodeThumbImg X"); - - return JPG_SUCCESS; -} - -jpg_return_status JpegEncoder::makeExif (unsigned char *exifOut, - exif_attribute_t *exifInfo, - unsigned int *size, - bool useMainbufForThumb) -{ - if (!available) - return JPG_FAIL; - - LOGD("makeExif E"); - - unsigned char *pCur, *pApp1Start, *pIfdStart, *pGpsIfdPtr, *pNextIfdOffset; - unsigned int tmp, LongerTagOffest = 0; - pApp1Start = pCur = exifOut; - - //2 Exif Identifier Code & TIFF Header - pCur += 4; // Skip 4 Byte for APP1 marker and length - unsigned char ExifIdentifierCode[6] = { 0x45, 0x78, 0x69, 0x66, 0x00, 0x00 }; - memcpy(pCur, ExifIdentifierCode, 6); - pCur += 6; - - /* Byte Order - little endian, Offset of IFD - 0x00000008.H */ - unsigned char TiffHeader[8] = { 0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00 }; - memcpy(pCur, TiffHeader, 8); - pIfdStart = pCur; - pCur += 8; - - //2 0th IFD TIFF Tags - if (exifInfo->enableGps) - tmp = NUM_0TH_IFD_TIFF; - else - tmp = NUM_0TH_IFD_TIFF - 1; - - memcpy(pCur, &tmp, NUM_SIZE); - pCur += NUM_SIZE; - - LongerTagOffest += 8 + NUM_SIZE + tmp*IFD_SIZE + OFFSET_SIZE; - - writeExifIfd(&pCur, EXIF_TAG_IMAGE_WIDTH, EXIF_TYPE_LONG, - 1, exifInfo->width); - writeExifIfd(&pCur, EXIF_TAG_IMAGE_HEIGHT, EXIF_TYPE_LONG, - 1, exifInfo->height); - writeExifIfd(&pCur, EXIF_TAG_MAKE, EXIF_TYPE_ASCII, - strlen((char *)exifInfo->maker) + 1, exifInfo->maker, &LongerTagOffest, pIfdStart); - writeExifIfd(&pCur, EXIF_TAG_MODEL, EXIF_TYPE_ASCII, - strlen((char *)exifInfo->model) + 1, exifInfo->model, &LongerTagOffest, pIfdStart); - writeExifIfd(&pCur, EXIF_TAG_ORIENTATION, EXIF_TYPE_SHORT, - 1, exifInfo->orientation); - writeExifIfd(&pCur, EXIF_TAG_SOFTWARE, EXIF_TYPE_ASCII, - strlen((char *)exifInfo->software) + 1, exifInfo->software, &LongerTagOffest, pIfdStart); - writeExifIfd(&pCur, EXIF_TAG_DATE_TIME, EXIF_TYPE_ASCII, - 20, exifInfo->date_time, &LongerTagOffest, pIfdStart); - writeExifIfd(&pCur, EXIF_TAG_YCBCR_POSITIONING, EXIF_TYPE_SHORT, - 1, exifInfo->ycbcr_positioning); - writeExifIfd(&pCur, EXIF_TAG_EXIF_IFD_POINTER, EXIF_TYPE_LONG, - 1, LongerTagOffest); - if (exifInfo->enableGps) { - pGpsIfdPtr = pCur; - pCur += IFD_SIZE; // Skip a ifd size for gps IFD pointer - } - - pNextIfdOffset = pCur; // Skip a offset size for next IFD offset - pCur += OFFSET_SIZE; - - //2 0th IFD Exif Private Tags - pCur = pIfdStart + LongerTagOffest; - - tmp = NUM_0TH_IFD_EXIF; - memcpy(pCur, &tmp , NUM_SIZE); - pCur += NUM_SIZE; - - LongerTagOffest += NUM_SIZE + NUM_0TH_IFD_EXIF*IFD_SIZE + OFFSET_SIZE; - - writeExifIfd(&pCur, EXIF_TAG_EXPOSURE_TIME, EXIF_TYPE_RATIONAL, - 1, &exifInfo->exposure_time, &LongerTagOffest, pIfdStart); - writeExifIfd(&pCur, EXIF_TAG_FNUMBER, EXIF_TYPE_RATIONAL, - 1, &exifInfo->fnumber, &LongerTagOffest, pIfdStart); - writeExifIfd(&pCur, EXIF_TAG_EXPOSURE_PROGRAM, EXIF_TYPE_SHORT, - 1, exifInfo->exposure_program); - writeExifIfd(&pCur, EXIF_TAG_ISO_SPEED_RATING, EXIF_TYPE_SHORT, - 1, exifInfo->iso_speed_rating); - writeExifIfd(&pCur, EXIF_TAG_EXIF_VERSION, EXIF_TYPE_UNDEFINED, - 4, exifInfo->exif_version); - writeExifIfd(&pCur, EXIF_TAG_DATE_TIME_ORG, EXIF_TYPE_ASCII, - 20, exifInfo->date_time, &LongerTagOffest, pIfdStart); - writeExifIfd(&pCur, EXIF_TAG_DATE_TIME_DIGITIZE, EXIF_TYPE_ASCII, - 20, exifInfo->date_time, &LongerTagOffest, pIfdStart); - writeExifIfd(&pCur, EXIF_TAG_SHUTTER_SPEED, EXIF_TYPE_SRATIONAL, - 1, (rational_t *)&exifInfo->shutter_speed, &LongerTagOffest, pIfdStart); - writeExifIfd(&pCur, EXIF_TAG_APERTURE, EXIF_TYPE_RATIONAL, - 1, &exifInfo->aperture, &LongerTagOffest, pIfdStart); - writeExifIfd(&pCur, EXIF_TAG_BRIGHTNESS, EXIF_TYPE_SRATIONAL, - 1, (rational_t *)&exifInfo->brightness, &LongerTagOffest, pIfdStart); - writeExifIfd(&pCur, EXIF_TAG_EXPOSURE_BIAS, EXIF_TYPE_SRATIONAL, - 1, (rational_t *)&exifInfo->exposure_bias, &LongerTagOffest, pIfdStart); - writeExifIfd(&pCur, EXIF_TAG_MAX_APERTURE, EXIF_TYPE_RATIONAL, - 1, &exifInfo->max_aperture, &LongerTagOffest, pIfdStart); - writeExifIfd(&pCur, EXIF_TAG_METERING_MODE, EXIF_TYPE_SHORT, - 1, exifInfo->metering_mode); - writeExifIfd(&pCur, EXIF_TAG_FLASH, EXIF_TYPE_SHORT, - 1, exifInfo->flash); - writeExifIfd(&pCur, EXIF_TAG_FOCAL_LENGTH, EXIF_TYPE_RATIONAL, - 1, &exifInfo->focal_length, &LongerTagOffest, pIfdStart); - char code[8] = { 0x00, 0x00, 0x00, 0x49, 0x49, 0x43, 0x53, 0x41 }; - int commentsLen = strlen((char *)exifInfo->user_comment) + 1; - memmove(exifInfo->user_comment + sizeof(code), exifInfo->user_comment, commentsLen); - memcpy(exifInfo->user_comment, code, sizeof(code)); - writeExifIfd(&pCur, EXIF_TAG_USER_COMMENT, EXIF_TYPE_UNDEFINED, - commentsLen + sizeof(code), exifInfo->user_comment, &LongerTagOffest, pIfdStart); - writeExifIfd(&pCur, EXIF_TAG_COLOR_SPACE, EXIF_TYPE_SHORT, - 1, exifInfo->color_space); - writeExifIfd(&pCur, EXIF_TAG_PIXEL_X_DIMENSION, EXIF_TYPE_LONG, - 1, exifInfo->width); - writeExifIfd(&pCur, EXIF_TAG_PIXEL_Y_DIMENSION, EXIF_TYPE_LONG, - 1, exifInfo->height); - writeExifIfd(&pCur, EXIF_TAG_EXPOSURE_MODE, EXIF_TYPE_LONG, - 1, exifInfo->exposure_mode); - writeExifIfd(&pCur, EXIF_TAG_WHITE_BALANCE, EXIF_TYPE_LONG, - 1, exifInfo->white_balance); - writeExifIfd(&pCur, EXIF_TAG_SCENCE_CAPTURE_TYPE, EXIF_TYPE_LONG, - 1, exifInfo->scene_capture_type); - tmp = 0; - memcpy(pCur, &tmp, OFFSET_SIZE); // next IFD offset - pCur += OFFSET_SIZE; - - //2 0th IFD GPS Info Tags - if (exifInfo->enableGps) { - writeExifIfd(&pGpsIfdPtr, EXIF_TAG_GPS_IFD_POINTER, EXIF_TYPE_LONG, - 1, LongerTagOffest); // GPS IFD pointer skipped on 0th IFD - - pCur = pIfdStart + LongerTagOffest; - - if (exifInfo->gps_processing_method[0] == 0) { - // don't create GPS_PROCESSING_METHOD tag if there isn't any - tmp = NUM_0TH_IFD_GPS - 1; - } else { - tmp = NUM_0TH_IFD_GPS; - } - memcpy(pCur, &tmp, NUM_SIZE); - pCur += NUM_SIZE; - - LongerTagOffest += NUM_SIZE + tmp*IFD_SIZE + OFFSET_SIZE; - - writeExifIfd(&pCur, EXIF_TAG_GPS_VERSION_ID, EXIF_TYPE_BYTE, - 4, exifInfo->gps_version_id); - writeExifIfd(&pCur, EXIF_TAG_GPS_LATITUDE_REF, EXIF_TYPE_ASCII, - 2, exifInfo->gps_latitude_ref); - writeExifIfd(&pCur, EXIF_TAG_GPS_LATITUDE, EXIF_TYPE_RATIONAL, - 3, exifInfo->gps_latitude, &LongerTagOffest, pIfdStart); - writeExifIfd(&pCur, EXIF_TAG_GPS_LONGITUDE_REF, EXIF_TYPE_ASCII, - 2, exifInfo->gps_longitude_ref); - writeExifIfd(&pCur, EXIF_TAG_GPS_LONGITUDE, EXIF_TYPE_RATIONAL, - 3, exifInfo->gps_longitude, &LongerTagOffest, pIfdStart); - writeExifIfd(&pCur, EXIF_TAG_GPS_ALTITUDE_REF, EXIF_TYPE_BYTE, - 1, exifInfo->gps_altitude_ref); - writeExifIfd(&pCur, EXIF_TAG_GPS_ALTITUDE, EXIF_TYPE_RATIONAL, - 1, &exifInfo->gps_altitude, &LongerTagOffest, pIfdStart); - writeExifIfd(&pCur, EXIF_TAG_GPS_TIMESTAMP, EXIF_TYPE_RATIONAL, - 3, exifInfo->gps_timestamp, &LongerTagOffest, pIfdStart); - tmp = strlen((char*)exifInfo->gps_processing_method); - if (tmp > 0) { - if (tmp > 100) { - tmp = 100; - } - unsigned char tmp_buf[100+sizeof(ExifAsciiPrefix)]; - memcpy(tmp_buf, ExifAsciiPrefix, sizeof(ExifAsciiPrefix)); - memcpy(&tmp_buf[sizeof(ExifAsciiPrefix)], exifInfo->gps_processing_method, tmp); - writeExifIfd(&pCur, EXIF_TAG_GPS_PROCESSING_METHOD, EXIF_TYPE_UNDEFINED, - tmp+sizeof(ExifAsciiPrefix), tmp_buf, &LongerTagOffest, pIfdStart); - } - writeExifIfd(&pCur, EXIF_TAG_GPS_DATESTAMP, EXIF_TYPE_ASCII, - 11, exifInfo->gps_datestamp, &LongerTagOffest, pIfdStart); - tmp = 0; - memcpy(pCur, &tmp, OFFSET_SIZE); // next IFD offset - pCur += OFFSET_SIZE; - } - - //2 1th IFD TIFF Tags - char *thumbBuf; - int thumbSize; - - if (useMainbufForThumb) { - thumbBuf = mArgs.out_buf; - thumbSize = mArgs.enc_param->file_size; - } else { - thumbBuf = mArgs.out_thumb_buf; - thumbSize = mArgs.thumb_enc_param->file_size; - } - - if (exifInfo->enableThumb && (thumbBuf != NULL) && (thumbSize > 0)) { - tmp = LongerTagOffest; - memcpy(pNextIfdOffset, &tmp, OFFSET_SIZE); // NEXT IFD offset skipped on 0th IFD - - pCur = pIfdStart + LongerTagOffest; - - tmp = NUM_1TH_IFD_TIFF; - memcpy(pCur, &tmp, NUM_SIZE); - pCur += NUM_SIZE; - - LongerTagOffest += NUM_SIZE + NUM_1TH_IFD_TIFF*IFD_SIZE + OFFSET_SIZE; - - writeExifIfd(&pCur, EXIF_TAG_IMAGE_WIDTH, EXIF_TYPE_LONG, - 1, exifInfo->widthThumb); - writeExifIfd(&pCur, EXIF_TAG_IMAGE_HEIGHT, EXIF_TYPE_LONG, - 1, exifInfo->heightThumb); - writeExifIfd(&pCur, EXIF_TAG_COMPRESSION_SCHEME, EXIF_TYPE_SHORT, - 1, exifInfo->compression_scheme); - writeExifIfd(&pCur, EXIF_TAG_ORIENTATION, EXIF_TYPE_SHORT, - 1, exifInfo->orientation); - writeExifIfd(&pCur, EXIF_TAG_X_RESOLUTION, EXIF_TYPE_RATIONAL, - 1, &exifInfo->x_resolution, &LongerTagOffest, pIfdStart); - writeExifIfd(&pCur, EXIF_TAG_Y_RESOLUTION, EXIF_TYPE_RATIONAL, - 1, &exifInfo->y_resolution, &LongerTagOffest, pIfdStart); - writeExifIfd(&pCur, EXIF_TAG_RESOLUTION_UNIT, EXIF_TYPE_SHORT, - 1, exifInfo->resolution_unit); - writeExifIfd(&pCur, EXIF_TAG_JPEG_INTERCHANGE_FORMAT, EXIF_TYPE_LONG, - 1, LongerTagOffest); - writeExifIfd(&pCur, EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LEN, EXIF_TYPE_LONG, - 1, thumbSize); - - tmp = 0; - memcpy(pCur, &tmp, OFFSET_SIZE); // next IFD offset - pCur += OFFSET_SIZE; - - memcpy(pIfdStart + LongerTagOffest, - thumbBuf, thumbSize); - LongerTagOffest += thumbSize; - } else { - tmp = 0; - memcpy(pNextIfdOffset, &tmp, OFFSET_SIZE); // NEXT IFD offset skipped on 0th IFD - } - - unsigned char App1Marker[2] = { 0xff, 0xe1 }; - memcpy(pApp1Start, App1Marker, 2); - pApp1Start += 2; - - *size = 10 + LongerTagOffest; - tmp = *size - 2; // APP1 Maker isn't counted - unsigned char size_mm[2] = {(tmp >> 8) & 0xFF, tmp & 0xFF}; - memcpy(pApp1Start, size_mm, 2); - - LOGD("makeExif X"); - - return JPG_SUCCESS; -} - -jpg_return_status JpegEncoder::checkMcu(sample_mode_t sampleMode, - uint32_t width, uint32_t height, bool isThumb) -{ - if (!available) - return JPG_FAIL; - - uint32_t expectedWidth = width; - uint32_t expectedHeight = height; - - switch (sampleMode){ - case JPG_422: - if (width % 16 != 0) - expectedWidth = width + 16 - (width % 16); - if (height % 8 != 0) - expectedHeight = height + 8 - (height % 8); - break; - - case JPG_420: - if (width % 16 != 0) - expectedWidth = width + 16 - (width % 16); - if (height % 16 != 0) - expectedHeight = height + 16 - (height % 16); - break; - - default: - LOGE("Invaild sample mode"); - return JPG_FAIL; - } - - if (expectedWidth == width && expectedHeight == height) - return JPG_SUCCESS; - - LOGW("The image is not matched for MCU"); - - uint32_t size = width*height * 2; - char *srcBuf, *dstBuf; - - if ((srcBuf = new char[size]) == NULL) { - LOGE("Failed to allocate for srcBuf"); - return JPG_FAIL; - } - - if (!isThumb) - dstBuf = mArgs.in_buf; - else - dstBuf = mArgs.in_thumb_buf; - - memcpy(srcBuf, dstBuf, size); - bool ret = pad(srcBuf, width, height, dstBuf, expectedWidth, expectedHeight); - - delete[] srcBuf; - - return JPG_SUCCESS; -} - -bool JpegEncoder::pad(char *srcBuf, uint32_t srcWidth, uint32_t srcHight, - char *dstBuf, uint32_t dstWidth, uint32_t dstHight) -{ - if (!available) - return false; - - if (srcBuf == NULL || dstBuf == NULL) { - LOGE("srcBuf or dstBuf is NULL"); - return false; - } - - int padW = dstWidth - srcWidth; - int padH = dstHight - srcHight; - - if ((int)(dstWidth - srcWidth) < 0 || - (int)(dstHight - srcHight) < 0) { - LOGE("dstSize is smaller than srcSize"); - return false; - } - memset(dstBuf, 0, dstWidth*dstHight * 2); - - for (uint32_t i = 0; i < srcHight; i++) - memcpy(dstBuf + i * dstWidth * 2, srcBuf + i * srcWidth * 2, srcWidth * 2); - - return true; -} - -bool JpegEncoder::scaleDownYuv422(char *srcBuf, uint32_t srcWidth, uint32_t srcHight, - char *dstBuf, uint32_t dstWidth, uint32_t dstHight) -{ - if (!available) - return false; - - int32_t step_x, step_y; - int32_t iXsrc, iXdst; - int32_t x, y, src_y_start_pos, dst_pos, src_pos; - - if (dstWidth % 2 != 0 || dstHight % 2 != 0){ - LOGE("scale_down_yuv422: invalid width, height for scaling"); - return false; - } - - step_x = srcWidth / dstWidth; - step_y = srcHight / dstHight; - - dst_pos = 0; - for (uint32_t y = 0; y < dstHight; y++) { - src_y_start_pos = (y * step_y * (srcWidth * 2)); - - for (uint32_t x = 0; x < dstWidth; x += 2) { - src_pos = src_y_start_pos + (x * (step_x * 2)); - - dstBuf[dst_pos++] = srcBuf[src_pos ]; - dstBuf[dst_pos++] = srcBuf[src_pos + 1]; - dstBuf[dst_pos++] = srcBuf[src_pos + 2]; - dstBuf[dst_pos++] = srcBuf[src_pos + 3]; - } - } - - return true; -} - -inline void JpegEncoder::writeExifIfd(unsigned char **pCur, - unsigned short tag, - unsigned short type, - unsigned int count, - uint32_t value) -{ - memcpy(*pCur, &tag, 2); - *pCur += 2; - memcpy(*pCur, &type, 2); - *pCur += 2; - memcpy(*pCur, &count, 4); - *pCur += 4; - memcpy(*pCur, &value, 4); - *pCur += 4; -} - -inline void JpegEncoder::writeExifIfd(unsigned char **pCur, - unsigned short tag, - unsigned short type, - unsigned int count, - unsigned char *pValue) -{ - char buf[4] = { 0,}; - - memcpy(buf, pValue, count); - memcpy(*pCur, &tag, 2); - *pCur += 2; - memcpy(*pCur, &type, 2); - *pCur += 2; - memcpy(*pCur, &count, 4); - *pCur += 4; - memcpy(*pCur, buf, 4); - *pCur += 4; -} - - -inline void JpegEncoder::writeExifIfd(unsigned char **pCur, - unsigned short tag, - unsigned short type, - unsigned int count, - unsigned char *pValue, - unsigned int *offset, - unsigned char *start) -{ - memcpy(*pCur, &tag, 2); - *pCur += 2; - memcpy(*pCur, &type, 2); - *pCur += 2; - memcpy(*pCur, &count, 4); - *pCur += 4; - memcpy(*pCur, offset, 4); - *pCur += 4; - memcpy(start + *offset, pValue, count); - *offset += count; -} - -inline void JpegEncoder::writeExifIfd(unsigned char **pCur, - unsigned short tag, - unsigned short type, - unsigned int count, - rational_t *pValue, - unsigned int *offset, - unsigned char *start) -{ - memcpy(*pCur, &tag, 2); - *pCur += 2; - memcpy(*pCur, &type, 2); - *pCur += 2; - memcpy(*pCur, &count, 4); - *pCur += 4; - memcpy(*pCur, offset, 4); - *pCur += 4; - memcpy(start + *offset, pValue, 8 * count); - *offset += 8 * count; -} - -}; diff --git a/libs3cjpeg/JpegEncoder.h b/libs3cjpeg/JpegEncoder.h deleted file mode 100644 index b95b1b1..0000000 --- a/libs3cjpeg/JpegEncoder.h +++ /dev/null @@ -1,240 +0,0 @@ -/* - * Copyright Samsung Electronics Co.,LTD. - * Copyright (C) 2010 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. - * - * JPEG DRIVER MODULE (JpegEncoder.h) - * Author : ge.lee -- initial version - * Date : 03 June 2010 - * Purpose : This file implements the JPEG encoder APIs as needed by Camera HAL - */ -#ifndef __JPG_API_H__ -#define __JPG_API_H__ - -#include -#include - -#include "Exif.h" - -namespace android { -#define MAX_JPG_WIDTH 800 -#define MAX_JPG_HEIGHT 480 -#define MAX_JPG_RESOLUTION (MAX_JPG_WIDTH * MAX_JPG_HEIGHT) - -#define MAX_JPG_THUMBNAIL_WIDTH 320 -#define MAX_JPG_THUMBNAIL_HEIGHT 240 -#define MAX_JPG_THUMBNAIL_RESOLUTION (MAX_JPG_THUMBNAIL_WIDTH * \ - MAX_JPG_THUMBNAIL_HEIGHT) - -#define MAX_RGB_WIDTH 800 -#define MAX_RGB_HEIGHT 480 -#define MAX_RGB_RESOLUTION (MAX_RGB_WIDTH * MAX_RGB_HEIGHT) - -/*******************************************************************************/ -/* define JPG & image memory */ -/* memory area is 4k(PAGE_SIZE) aligned because of VirtualCopyEx() */ -#define JPG_STREAM_BUF_SIZE \ - (MAX_JPG_RESOLUTION / PAGE_SIZE + 1) * PAGE_SIZE -#define JPG_STREAM_THUMB_BUF_SIZE \ - (MAX_JPG_THUMBNAIL_RESOLUTION / PAGE_SIZE + 1) * PAGE_SIZE -#define JPG_FRAME_BUF_SIZE \ - ((MAX_JPG_RESOLUTION * 3) / PAGE_SIZE + 1) * PAGE_SIZE -#define JPG_FRAME_THUMB_BUF_SIZE \ - ((MAX_JPG_THUMBNAIL_RESOLUTION * 3) / PAGE_SIZE + 1) * PAGE_SIZE -#define JPG_RGB_BUF_SIZE \ - ((MAX_RGB_RESOLUTION * 4) / PAGE_SIZE + 1) * PAGE_SIZE - -#define JPG_TOTAL_BUF_SIZE (JPG_STREAM_BUF_SIZE + \ - JPG_STREAM_THUMB_BUF_SIZE + \ - JPG_FRAME_BUF_SIZE + \ - JPG_FRAME_THUMB_BUF_SIZE + \ - JPG_RGB_BUF_SIZE) - -#define JPG_MAIN_START 0x00 -#define JPG_THUMB_START JPG_STREAM_BUF_SIZE -#define IMG_MAIN_START (JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE) -#define IMG_THUMB_START (IMG_MAIN_START + JPG_FRAME_BUF_SIZE) -/*******************************************************************************/ - -#define JPG_DRIVER_NAME "/dev/s3c-jpg" - -#define JPEG_IOCTL_MAGIC 'J' -#define IOCTL_JPG_DECODE _IO(JPEG_IOCTL_MAGIC, 1) -#define IOCTL_JPG_ENCODE _IO(JPEG_IOCTL_MAGIC, 2) -#define IOCTL_JPG_GET_STRBUF _IO(JPEG_IOCTL_MAGIC, 3) -#define IOCTL_JPG_GET_FRMBUF _IO(JPEG_IOCTL_MAGIC, 4) -#define IOCTL_JPG_GET_THUMB_STRBUF _IO(JPEG_IOCTL_MAGIC, 5) -#define IOCTL_JPG_GET_THUMB_FRMBUF _IO(JPEG_IOCTL_MAGIC, 6) -#define IOCTL_JPG_GET_PHY_FRMBUF _IO(JPEG_IOCTL_MAGIC, 7) -#define IOCTL_JPG_GET_PHY_THUMB_FRMBUF _IO(JPEG_IOCTL_MAGIC, 8) - -typedef enum { - JPEG_SET_ENCODE_WIDTH, - JPEG_SET_ENCODE_HEIGHT, - JPEG_SET_ENCODE_QUALITY, - JPEG_SET_ENCODE_IN_FORMAT, - JPEG_SET_SAMPING_MODE, - JPEG_SET_THUMBNAIL_WIDTH, - JPEG_SET_THUMBNAIL_HEIGHT -} jpeg_conf; - -typedef enum { - JPG_FAIL, - JPG_SUCCESS, - OK_HD_PARSING, - ERR_HD_PARSING, - OK_ENC_OR_DEC, - ERR_ENC_OR_DEC, - ERR_UNKNOWN -} jpg_return_status; - -typedef enum { - JPG_RGB16, - JPG_YCBYCR, - JPG_TYPE_UNKNOWN -} image_type_t; - -typedef enum { - JPG_444, - JPG_422, - JPG_420, - JPG_400, - RESERVED1, - RESERVED2, - JPG_411, - JPG_SAMPLE_UNKNOWN -} sample_mode_t; - -typedef enum { - YCBCR_422, - YCBCR_420, - YCBCR_SAMPLE_UNKNOWN -} out_mode_t; - -typedef enum { - JPG_MODESEL_YCBCR = 1, - JPG_MODESEL_RGB, - JPG_MODESEL_UNKNOWN -} in_mode_t; - -typedef enum { - JPG_MAIN, - JPG_THUMBNAIL -} encode_type_t; - -typedef enum { - JPG_QUALITY_LEVEL_1, /* high */ - JPG_QUALITY_LEVEL_2, - JPG_QUALITY_LEVEL_3, - JPG_QUALITY_LEVEL_4 /* low */ -} image_quality_type_t; - -typedef struct { - sample_mode_t sample_mode; - encode_type_t dec_type; - out_mode_t out_format; - uint32_t width; - uint32_t height; - uint32_t data_size; - uint32_t file_size; -} jpg_dec_proc_param; - -typedef struct { - sample_mode_t sample_mode; - encode_type_t enc_type; - in_mode_t in_format; - image_quality_type_t quality; - uint32_t width; - uint32_t height; - uint32_t data_size; - uint32_t file_size; - uint32_t set_framebuf; -} jpg_enc_proc_param; - -typedef struct { - char *in_buf; - char *phy_in_buf; - int in_buf_size; - char *out_buf; - char *phy_out_buf; - int out_buf_size; - char *in_thumb_buf; - char *phy_in_thumb_buf; - int in_thumb_buf_size; - char *out_thumb_buf; - char *phy_out_thumb_buf; - int out_thumb_buf_size; - char *mmapped_addr; - jpg_dec_proc_param *dec_param; - jpg_enc_proc_param *enc_param; - jpg_enc_proc_param *thumb_enc_param; -} jpg_args; - -class JpegEncoder { -public: - JpegEncoder(); - virtual ~JpegEncoder(); - - int openHardware(); - jpg_return_status setConfig(jpeg_conf type, int32_t value); - void *getInBuf(uint64_t size); - void *getOutBuf(uint64_t *size); - void *getThumbInBuf(uint64_t size); - void *getThumbOutBuf(uint64_t *size); - jpg_return_status encode(unsigned int *size, exif_attribute_t *exifInfo); - jpg_return_status encodeThumbImg(unsigned int *size, bool useMain = true); - jpg_return_status makeExif(unsigned char *exifOut, - exif_attribute_t *exifIn, - unsigned int *size, - bool useMainbufForThumb = false); - -private: - jpg_return_status checkMcu(sample_mode_t sampleMode, uint32_t width, uint32_t height, bool isThumb); - bool pad(char *srcBuf, uint32_t srcWidth, uint32_t srcHight, - char *dstBuf, uint32_t dstWidth, uint32_t dstHight); - bool scaleDownYuv422(char *srcBuf, uint32_t srcWidth, uint32_t srcHight, - char *dstBuf, uint32_t dstWidth, uint32_t dstHight); - - inline void writeExifIfd(unsigned char **pCur, - unsigned short tag, - unsigned short type, - unsigned int count, - uint32_t value); - inline void writeExifIfd(unsigned char **pCur, - unsigned short tag, - unsigned short type, - unsigned int count, - unsigned char *pValue); - inline void writeExifIfd(unsigned char **pCur, - unsigned short tag, - unsigned short type, - unsigned int count, - rational_t *pValue, - unsigned int *offset, - unsigned char *start); - inline void writeExifIfd(unsigned char **pCur, - unsigned short tag, - unsigned short type, - unsigned int count, - unsigned char *pValue, - unsigned int *offset, - unsigned char *start); - int mDevFd; - jpg_args mArgs; - - bool available; - -}; -}; -#endif /* __JPG_API_H__ */ diff --git a/libstagefrighthw/Android.mk b/libstagefrighthw/Android.mk deleted file mode 100644 index 7716541..0000000 --- a/libstagefrighthw/Android.mk +++ /dev/null @@ -1,27 +0,0 @@ -LOCAL_PATH := $(call my-dir) -include $(CLEAR_VARS) - -LOCAL_SRC_FILES := \ - stagefright_overlay_output.cpp \ - SecHardwareRenderer.cpp \ - SEC_OMX_Plugin.cpp - -LOCAL_CFLAGS += $(PV_CFLAGS_MINUS_VISIBILITY) - -LOCAL_C_INCLUDES:= \ - $(TOP)/frameworks/base/include/media/stagefright/openmax \ - $(LOCAL_PATH)/../include \ - $(LOCAL_PATH)/../liboverlay - -LOCAL_SHARED_LIBRARIES := \ - libbinder \ - libutils \ - libcutils \ - libui \ - libdl \ - libsurfaceflinger_client - -LOCAL_MODULE := libstagefrighthw - -LOCAL_MODULE_TAGS := optional -include $(BUILD_SHARED_LIBRARY) diff --git a/libstagefrighthw/SEC_OMX_Plugin.cpp b/libstagefrighthw/SEC_OMX_Plugin.cpp deleted file mode 100644 index 0bb70c5..0000000 --- a/libstagefrighthw/SEC_OMX_Plugin.cpp +++ /dev/null @@ -1,147 +0,0 @@ -/* - * Copyright (C) 2010 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. - */ - -#include "SEC_OMX_Plugin.h" - -#include - -#include -#include - -namespace android { - -OMXPluginBase *createOMXPlugin() { - return new SECOMXPlugin; -} - -SECOMXPlugin::SECOMXPlugin() - : mLibHandle(dlopen("libSEC_OMX_Core.aries.so", RTLD_NOW)), - mInit(NULL), - mDeinit(NULL), - mComponentNameEnum(NULL), - mGetHandle(NULL), - mFreeHandle(NULL), - mGetRolesOfComponentHandle(NULL) { - if (mLibHandle != NULL) { - mInit = (InitFunc)dlsym(mLibHandle, "SEC_OMX_Init"); - mDeinit = (DeinitFunc)dlsym(mLibHandle, "SEC_OMX_DeInit"); - - mComponentNameEnum = - (ComponentNameEnumFunc)dlsym(mLibHandle, "SEC_OMX_ComponentNameEnum"); - - mGetHandle = (GetHandleFunc)dlsym(mLibHandle, "SEC_OMX_GetHandle"); - mFreeHandle = (FreeHandleFunc)dlsym(mLibHandle, "SEC_OMX_FreeHandle"); - - mGetRolesOfComponentHandle = - (GetRolesOfComponentFunc)dlsym( - mLibHandle, "SEC_OMX_GetRolesOfComponent"); - - (*mInit)(); - - } -} - -SECOMXPlugin::~SECOMXPlugin() { - if (mLibHandle != NULL) { - (*mDeinit)(); - - dlclose(mLibHandle); - mLibHandle = NULL; - } -} - -OMX_ERRORTYPE SECOMXPlugin::makeComponentInstance( - const char *name, - const OMX_CALLBACKTYPE *callbacks, - OMX_PTR appData, - OMX_COMPONENTTYPE **component) { - if (mLibHandle == NULL) { - return OMX_ErrorUndefined; - } - - return (*mGetHandle)( - reinterpret_cast(component), - const_cast(name), - appData, const_cast(callbacks)); -} - -OMX_ERRORTYPE SECOMXPlugin::destroyComponentInstance( - OMX_COMPONENTTYPE *component) { - if (mLibHandle == NULL) { - return OMX_ErrorUndefined; - } - - return (*mFreeHandle)(reinterpret_cast(component)); -} - -OMX_ERRORTYPE SECOMXPlugin::enumerateComponents( - OMX_STRING name, - size_t size, - OMX_U32 index) { - if (mLibHandle == NULL) { - return OMX_ErrorUndefined; - } - - return (*mComponentNameEnum)(name, size, index); -} - -OMX_ERRORTYPE SECOMXPlugin::getRolesOfComponent( - const char *name, - Vector *roles) { - roles->clear(); - - if (mLibHandle == NULL) { - return OMX_ErrorUndefined; - } - - OMX_U32 numRoles; - OMX_ERRORTYPE err = (*mGetRolesOfComponentHandle)( - const_cast(name), &numRoles, NULL); - - if (err != OMX_ErrorNone) { - return err; - } - - if (numRoles > 0) { - OMX_U8 **array = new OMX_U8 *[numRoles]; - for (OMX_U32 i = 0; i < numRoles; ++i) { - array[i] = new OMX_U8[OMX_MAX_STRINGNAME_SIZE]; - } - - OMX_U32 numRoles2; - err = (*mGetRolesOfComponentHandle)( - const_cast(name), &numRoles2, array); - - CHECK_EQ(err, OMX_ErrorNone); - CHECK_EQ(numRoles, numRoles2); - - for (OMX_U32 i = 0; i < numRoles; ++i) { - String8 s((const char *)array[i]); - roles->push(s); - - delete[] array[i]; - array[i] = NULL; - } - - delete[] array; - array = NULL; - } - - return OMX_ErrorNone; -} - -} // namespace android - diff --git a/libstagefrighthw/SEC_OMX_Plugin.h b/libstagefrighthw/SEC_OMX_Plugin.h deleted file mode 100644 index 6df2d31..0000000 --- a/libstagefrighthw/SEC_OMX_Plugin.h +++ /dev/null @@ -1,76 +0,0 @@ -/* - * Copyright (C) 2010 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 SEC_OMX_PLUGIN - -#define SEC_OMX_PLUGIN - -#include - -namespace android { - -struct SECOMXPlugin : public OMXPluginBase { - SECOMXPlugin(); - virtual ~SECOMXPlugin(); - - virtual OMX_ERRORTYPE makeComponentInstance( - const char *name, - const OMX_CALLBACKTYPE *callbacks, - OMX_PTR appData, - OMX_COMPONENTTYPE **component); - - virtual OMX_ERRORTYPE destroyComponentInstance( - OMX_COMPONENTTYPE *component); - - virtual OMX_ERRORTYPE enumerateComponents( - OMX_STRING name, - size_t size, - OMX_U32 index); - - virtual OMX_ERRORTYPE getRolesOfComponent( - const char *name, - Vector *roles); - -private: - void *mLibHandle; - - typedef OMX_ERRORTYPE (*InitFunc)(); - typedef OMX_ERRORTYPE (*DeinitFunc)(); - typedef OMX_ERRORTYPE (*ComponentNameEnumFunc)( - OMX_STRING, OMX_U32, OMX_U32); - - typedef OMX_ERRORTYPE (*GetHandleFunc)( - OMX_HANDLETYPE *, OMX_STRING, OMX_PTR, OMX_CALLBACKTYPE *); - - typedef OMX_ERRORTYPE (*FreeHandleFunc)(OMX_HANDLETYPE *); - - typedef OMX_ERRORTYPE (*GetRolesOfComponentFunc)( - OMX_STRING, OMX_U32 *, OMX_U8 **); - - InitFunc mInit; - DeinitFunc mDeinit; - ComponentNameEnumFunc mComponentNameEnum; - GetHandleFunc mGetHandle; - FreeHandleFunc mFreeHandle; - GetRolesOfComponentFunc mGetRolesOfComponentHandle; - - SECOMXPlugin(const SECOMXPlugin &); - SECOMXPlugin &operator=(const SECOMXPlugin &); -}; - -} // namespace android - -#endif // SEC_OMX_PLUGIN diff --git a/libstagefrighthw/SecHardwareRenderer.cpp b/libstagefrighthw/SecHardwareRenderer.cpp deleted file mode 100644 index cb9e8e8..0000000 --- a/libstagefrighthw/SecHardwareRenderer.cpp +++ /dev/null @@ -1,228 +0,0 @@ -/* - * Copyright (C) 2010 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_TAG "SecHardwareRenderer" -#define LOG_NDEBUG 0 -#include - -#include "SecHardwareRenderer.h" - -#include -#include -#include - -#include - -#include "v4l2_utils.h" -#include "utils/Timers.h" - -#define CACHEABLE_BUFFERS 0x1 - -#define USE_ZERO_COPY -//#define SEC_DEBUG - -namespace android { - -//////////////////////////////////////////////////////////////////////////////// - -SecHardwareRenderer::SecHardwareRenderer( - const sp &surface, - size_t displayWidth, size_t displayHeight, - size_t decodedWidth, size_t decodedHeight, - OMX_COLOR_FORMATTYPE colorFormat, - int32_t rotationDegrees, - bool fromHardwareDecoder) - : mISurface(surface), - mDisplayWidth(displayWidth), - mDisplayHeight(displayHeight), - mDecodedWidth(decodedWidth), - mDecodedHeight(decodedHeight), - mColorFormat(colorFormat), - mInitCheck(NO_INIT), - mFrameSize(mDecodedWidth * mDecodedHeight * 2), - mIsFirstFrame(true), - mCustomFormat(false), - mIndex(0) { - - CHECK(mISurface.get() != NULL); - CHECK(mDecodedWidth > 0); - CHECK(mDecodedHeight > 0); - - if (colorFormat != OMX_COLOR_FormatCbYCrY - && colorFormat != OMX_COLOR_FormatYUV420Planar - && colorFormat != OMX_COLOR_FormatYUV420SemiPlanar) { - LOGE("Invalid colorFormat (0x%x)", colorFormat); - return; - } - - uint32_t orientation; - switch (rotationDegrees) { - case 0: orientation = ISurface::BufferHeap::ROT_0; break; - case 90: orientation = ISurface::BufferHeap::ROT_90; break; - case 180: orientation = ISurface::BufferHeap::ROT_180; break; - case 270: orientation = ISurface::BufferHeap::ROT_270; break; - default: orientation = ISurface::BufferHeap::ROT_0; break; - } - - sp ref; - -#if defined (USE_ZERO_COPY) - if (fromHardwareDecoder) { - ref = mISurface->createOverlay( - mDecodedWidth, mDecodedHeight, - HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP, orientation); - mCustomFormat = true; - } -#else - else - { - ref = mISurface->createOverlay( - mDecodedWidth, mDecodedHeight, HAL_PIXEL_FORMAT_YCbCr_420_P, - orientation); - } -#endif - - if (ref.get() == NULL) { - LOGE("Unable to create the overlay!"); - return; - } - - mOverlay = new Overlay(ref); - mOverlay->setParameter(CACHEABLE_BUFFERS, 0); - - mNumBuf = mOverlay->getBufferCount(); - - if (mCustomFormat) { - mFrameSize = 32; - mMemoryHeap = new MemoryHeapBase(mNumBuf * mFrameSize); - } else { - for (size_t i = 0; i < (size_t)mNumBuf; ++i) { - void *addr = mOverlay->getBufferAddress((void *)i); - mOverlayAddresses.push(addr); - } - } - - mInitCheck = OK; -} - -SecHardwareRenderer::~SecHardwareRenderer() { - - if(mMemoryHeap != NULL) - mMemoryHeap.clear(); - - if (mOverlay.get() != NULL) { - mOverlay->destroy(); - mOverlay.clear(); - } -} - -void SecHardwareRenderer::handleYUV420Planar( - const void *data, size_t size) { - - int FrameSize; - uint8_t* pPhyYAddr; - uint8_t* pPhyCAddr; - int AddrSize; - size_t offset; - - CHECK(size >= (mDecodedWidth * mDecodedHeight * 3) / 2); - - offset = mIndex * mFrameSize; - void *dst = (uint8_t *)mMemoryHeap->getBase() + offset; - - AddrSize = sizeof(void *); - memcpy(&FrameSize, data, sizeof(FrameSize)); - memcpy(&pPhyYAddr, data + sizeof(FrameSize), sizeof(pPhyYAddr)); - memcpy(&pPhyCAddr, data + sizeof(FrameSize) + (AddrSize * 1), sizeof(pPhyCAddr)); - - memcpy(dst , &pPhyYAddr, sizeof(pPhyYAddr)); - memcpy(dst + sizeof(pPhyYAddr) , &pPhyCAddr, sizeof(pPhyCAddr)); - memcpy(dst + sizeof(pPhyYAddr) + sizeof(pPhyCAddr), &mIndex, sizeof(mIndex)); -} - -void SecHardwareRenderer::render( - const void *data, size_t size, void *platformPrivate) { - - if (mOverlay.get() == NULL) { - return; - } - - if (mCustomFormat) { - /* zero copy solution case */ - - overlay_buffer_t dst = (uint8_t *)mMemoryHeap->getBase() + mIndex*mFrameSize; - - if (mColorFormat == OMX_COLOR_FormatYUV420Planar || - mColorFormat == OMX_COLOR_FormatYUV420SemiPlanar) { - handleYUV420Planar(data, size); - } - - if (mOverlay->queueBuffer(dst) == ALL_BUFFERS_FLUSHED) { - mIsFirstFrame = true; - if (mOverlay->queueBuffer((void *)dst) != 0) { - return; - } - } - - if (++mIndex == mNumBuf) { - mIndex = 0; - } - - overlay_buffer_t overlay_buffer; - if (!mIsFirstFrame) { - status_t err = mOverlay->dequeueBuffer(&overlay_buffer); - if (err == ALL_BUFFERS_FLUSHED) { - mIsFirstFrame = true; - } else { - return; - } - } else { - mIsFirstFrame = false; - } - } else { - /* normal frame case */ - if (mColorFormat == OMX_COLOR_FormatYUV420Planar) { - memcpy(mOverlayAddresses[mIndex], data, size); - } - - if (mOverlay->queueBuffer((void *)mIndex) == ALL_BUFFERS_FLUSHED) { - mIsFirstFrame = true; - if (mOverlay->queueBuffer((void *)mIndex) != 0) { - return; - } - } - - if (++mIndex == mNumBuf) { - mIndex = 0; - } - - overlay_buffer_t overlay_buffer; - if (!mIsFirstFrame) { - status_t err = mOverlay->dequeueBuffer(&overlay_buffer); - - if (err == ALL_BUFFERS_FLUSHED) { - mIsFirstFrame = true; - } else { - return; - } - } else { - mIsFirstFrame = false; - } - } -} - -} // namespace android - diff --git a/libstagefrighthw/SecHardwareRenderer.h b/libstagefrighthw/SecHardwareRenderer.h deleted file mode 100644 index 3fad243..0000000 --- a/libstagefrighthw/SecHardwareRenderer.h +++ /dev/null @@ -1,78 +0,0 @@ -/* - * Copyright (C) 2010 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 SEC_HARDWARE_RENDERER_H_ - -#define SEC_HARDWARE_RENDERER_H_ - -#include -#include -#include - -#include - -#include -#include - -namespace android { - -class ISurface; -class Overlay; - -class SecHardwareRenderer : public VideoRenderer { -public: - SecHardwareRenderer( - const sp &surface, - size_t displayWidth, size_t displayHeight, - size_t decodedWidth, size_t decodedHeight, - OMX_COLOR_FORMATTYPE colorFormat, - int32_t rotationDegrees, - bool fromHardwareDecoder); - - virtual ~SecHardwareRenderer(); - - status_t initCheck() const { return mInitCheck; } - - virtual void render( - const void *data, size_t size, void *platformPrivate); - - -private: - sp mISurface; - size_t mDisplayWidth, mDisplayHeight; - size_t mDecodedWidth, mDecodedHeight; - OMX_COLOR_FORMATTYPE mColorFormat; - status_t mInitCheck; - size_t mFrameSize; - sp mOverlay; - sp mMemoryHeap; - Vector mOverlayAddresses; - bool mIsFirstFrame; - int mNumBuf; - size_t mIndex; - bool mCustomFormat; - - - SecHardwareRenderer(const SecHardwareRenderer &); - SecHardwareRenderer &operator=(const SecHardwareRenderer &); - - void handleYUV420Planar(const void *, size_t); -}; - -} // namespace android - -#endif // SEC_HARDWARE_RENDERER_H_ - diff --git a/libstagefrighthw/stagefright_overlay_output.cpp b/libstagefrighthw/stagefright_overlay_output.cpp deleted file mode 100644 index fce1d7e..0000000 --- a/libstagefrighthw/stagefright_overlay_output.cpp +++ /dev/null @@ -1,51 +0,0 @@ -/* - * Copyright (C) 2010 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. - */ - -#include "SecHardwareRenderer.h" - -#include - -using android::sp; -using android::ISurface; -using android::VideoRenderer; - -VideoRenderer *createRendererWithRotation( - const sp &surface, - const char *componentName, - OMX_COLOR_FORMATTYPE colorFormat, - size_t displayWidth, size_t displayHeight, - size_t decodedWidth, size_t decodedHeight, - int32_t rotationDegrees) { - using android::SecHardwareRenderer; - - bool fromHardwareDecoder = !strncmp(componentName, "OMX.SEC.", 8); - - SecHardwareRenderer *renderer = - new SecHardwareRenderer( - surface, displayWidth, displayHeight, - decodedWidth, decodedHeight, - colorFormat, - rotationDegrees, - fromHardwareDecoder); - - if (renderer->initCheck() != android::OK) { - delete renderer; - renderer = NULL; - } - - return renderer; -} - diff --git a/overlay/frameworks/base/core/res/res/drawable-hdpi/default_wallpaper.jpg b/overlay/frameworks/base/core/res/res/drawable-hdpi/default_wallpaper.jpg deleted file mode 100644 index 811149b..0000000 Binary files a/overlay/frameworks/base/core/res/res/drawable-hdpi/default_wallpaper.jpg and /dev/null differ diff --git a/overlay/frameworks/base/core/res/res/values-de/arrays.xml b/overlay/frameworks/base/core/res/res/values-de/arrays.xml deleted file mode 100644 index 7f97684..0000000 --- a/overlay/frameworks/base/core/res/res/values-de/arrays.xml +++ /dev/null @@ -1,26 +0,0 @@ - - - - - - Neu starten - Recovery - - diff --git a/overlay/frameworks/base/core/res/res/values-fi-rFI/arrays.xml b/overlay/frameworks/base/core/res/res/values-fi-rFI/arrays.xml deleted file mode 100644 index 00eb6cb..0000000 --- a/overlay/frameworks/base/core/res/res/values-fi-rFI/arrays.xml +++ /dev/null @@ -1,28 +0,0 @@ - - - - - - - Käynnistä uudelleen - Recovery - - - diff --git a/overlay/frameworks/base/core/res/res/values-fr/arrays.xml b/overlay/frameworks/base/core/res/res/values-fr/arrays.xml deleted file mode 100644 index 69eeb7a..0000000 --- a/overlay/frameworks/base/core/res/res/values-fr/arrays.xml +++ /dev/null @@ -1,25 +0,0 @@ - - - - - Redémarrage - Recovery - - diff --git a/overlay/frameworks/base/core/res/res/values-it/arrays.xml b/overlay/frameworks/base/core/res/res/values-it/arrays.xml deleted file mode 100644 index 3984c9a..0000000 --- a/overlay/frameworks/base/core/res/res/values-it/arrays.xml +++ /dev/null @@ -1,31 +0,0 @@ - - - - - - - - - Riavvia - Recovery - - - - diff --git a/overlay/frameworks/base/core/res/res/values-pt-rBR/arrays.xml b/overlay/frameworks/base/core/res/res/values-pt-rBR/arrays.xml deleted file mode 100755 index 7cde789..0000000 --- a/overlay/frameworks/base/core/res/res/values-pt-rBR/arrays.xml +++ /dev/null @@ -1,36 +0,0 @@ - - - - - - - -22863878 - -43244097 - - - - 3 - - - - Reiniciar - Recuperação - - diff --git a/overlay/frameworks/base/core/res/res/values-ru/arrays.xml b/overlay/frameworks/base/core/res/res/values-ru/arrays.xml deleted file mode 100644 index 88a5b21..0000000 --- a/overlay/frameworks/base/core/res/res/values-ru/arrays.xml +++ /dev/null @@ -1,10 +0,0 @@ - - - - - - Перезагрузить - Recovery - - - diff --git a/overlay/frameworks/base/core/res/res/values-sv/arrays.xml b/overlay/frameworks/base/core/res/res/values-sv/arrays.xml deleted file mode 100644 index d5adb37..0000000 --- a/overlay/frameworks/base/core/res/res/values-sv/arrays.xml +++ /dev/null @@ -1,28 +0,0 @@ - - - - - - - Omstart - Recovery - - - diff --git a/overlay/frameworks/base/core/res/res/values-uk/arrays.xml b/overlay/frameworks/base/core/res/res/values-uk/arrays.xml deleted file mode 100644 index 9b0081d..0000000 --- a/overlay/frameworks/base/core/res/res/values-uk/arrays.xml +++ /dev/null @@ -1,10 +0,0 @@ - - - - - - Перезавантажити - Реж. відновлення - - - diff --git a/overlay/frameworks/base/core/res/res/values-zh-rTW/arrays.xml b/overlay/frameworks/base/core/res/res/values-zh-rTW/arrays.xml deleted file mode 100644 index fca8906..0000000 --- a/overlay/frameworks/base/core/res/res/values-zh-rTW/arrays.xml +++ /dev/null @@ -1,39 +0,0 @@ - - - - - - - 25022112 - 121478019 - - - - 3 - - - - - - 重新開機 - Recovery - - - diff --git a/overlay/frameworks/base/core/res/res/values/arrays.xml b/overlay/frameworks/base/core/res/res/values/arrays.xml deleted file mode 100644 index 3b32312..0000000 --- a/overlay/frameworks/base/core/res/res/values/arrays.xml +++ /dev/null @@ -1,125 +0,0 @@ - - - - - - - @drawable/sym_def_app_icon - @drawable/arrow_down_float - @drawable/btn_check - @drawable/btn_check_label_background - @drawable/btn_check_off - @drawable/btn_check_on - @drawable/btn_default - @drawable/btn_default_small - @drawable/btn_dropdown - @drawable/btn_plus - @drawable/btn_minus - @drawable/btn_radio - @drawable/btn_star - @drawable/btn_toggle - @drawable/ic_emergency - @drawable/divider_horizontal_bright - @drawable/divider_horizontal_dark - @drawable/edit_text - @drawable/expander_group - @drawable/list_selector_background - @drawable/menu_background - @drawable/menu_background_fill_parent_width - @drawable/menu_selector - @drawable/panel_background - @drawable/popup_bottom_bright - @drawable/popup_bottom_dark - @drawable/popup_bottom_medium - @drawable/popup_center_bright - @drawable/popup_center_dark - @drawable/popup_full_dark - @drawable/popup_top_bright - @drawable/popup_top_dark - @drawable/progress_horizontal - @drawable/progress_indeterminate_horizontal - @drawable/progress_small - @drawable/progress_small_titlebar - @drawable/screen_background_dark - @drawable/screen_background_light - @drawable/scrollbar_handle_horizontal - @drawable/scrollbar_handle_vertical - @drawable/spinner_dropdown_background - @drawable/text_select_handle_left - @drawable/text_select_handle_middle - @drawable/text_select_handle_right - @drawable/title_bar - @drawable/title_bar_shadow - - @drawable/indicator_code_lock_drag_direction_green_up - @drawable/indicator_code_lock_drag_direction_red_up - @drawable/indicator_code_lock_point_area_default - @drawable/indicator_code_lock_point_area_green - @drawable/indicator_code_lock_point_area_red - - @drawable/overscroll_glow - @drawable/overscroll_edge - - - - - @color/hint_foreground_dark - @color/hint_foreground_light - @color/primary_text_dark - @color/primary_text_dark_disable_only - @color/primary_text_light - @color/primary_text_light_disable_only - @color/primary_text_light_nodisable - @color/secondary_text_dark - @color/secondary_text_light - @color/tab_indicator_text - @color/tertiary_text_dark - @color/tertiary_text_light - #ff000000 - #00000000 - #ffffffff - - - - - 36149777 - -95993398 - - - - 3 - - - - - Reboot - Recovery - - - - - - recovery - - - diff --git a/overlay/frameworks/base/core/res/res/values/config.xml b/overlay/frameworks/base/core/res/res/values/config.xml deleted file mode 100644 index 6336d69..0000000 --- a/overlay/frameworks/base/core/res/res/values/config.xml +++ /dev/null @@ -1,185 +0,0 @@ - - - - - - - true - - - true - - - false - - - true - - - - 10 - 160 - 225 - 320 - 640 - 1280 - 2600 - 10240 - - - - - 20 - 20 - 20 - 20 - 35 - 50 - 50 - 100 - 255 - - - - - 255 - 255 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - - - - - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - - - - com.android.wallpaper/.nexus.NexusWallpaper - - 0 - 1 - - - #ffffffff - - - 9000 - - - com.google.android.location.NetworkLocationProvider - - - com.google.android.location.GeocodeProvider - - - - - - - - "wifi,1,1,1" - "mobile,0,0,0" - "mobile_mms,2,0,2" - "mobile_supl,3,0,2" - "mobile_dun,4,0,4" - "mobile_hipri,5,0,3" - - - - - "usb0" - - - - - "pdp\\d" - "eth\\d" - - - - - "wl0.1" - - - - - false - - - - 30 - - - - - 1 - - - - true - - - - - true - diff --git a/overlay/frameworks/base/core/res/res/xml/power_profile.xml b/overlay/frameworks/base/core/res/res/xml/power_profile.xml deleted file mode 100644 index a00f060..0000000 --- a/overlay/frameworks/base/core/res/res/xml/power_profile.xml +++ /dev/null @@ -1,60 +0,0 @@ - - - - - 0 - 49 - 142 - 0.3 - - 35690 - 260 - 4 - 120 - 220 - 88 - 88 - 185 - 50 - 1500 - 88 - - 3.4 - 3.4 - - - 100000 - 200000 - 400000 - 800000 - 1000000 - - - 1.4 - - 44 - - - 55.4 - 82.1 - 113.7 - 205.4 - 259.0 - - diff --git a/overlay/frameworks/base/packages/SettingsProvider/res/values/defaults.xml b/overlay/frameworks/base/packages/SettingsProvider/res/values/defaults.xml deleted file mode 100644 index a6af5fd..0000000 --- a/overlay/frameworks/base/packages/SettingsProvider/res/values/defaults.xml +++ /dev/null @@ -1,22 +0,0 @@ - - - - true - true - diff --git a/overlay/frameworks/base/tests/ImfTest/res/values/config.xml b/overlay/frameworks/base/tests/ImfTest/res/values/config.xml deleted file mode 100644 index 157d04a..0000000 --- a/overlay/frameworks/base/tests/ImfTest/res/values/config.xml +++ /dev/null @@ -1,21 +0,0 @@ - - - - true - diff --git a/overlay/packages/apps/CMParts/res/values/config.xml b/overlay/packages/apps/CMParts/res/values/config.xml deleted file mode 100644 index 5818480..0000000 --- a/overlay/packages/apps/CMParts/res/values/config.xml +++ /dev/null @@ -1,8 +0,0 @@ - - - - false - - - true - diff --git a/overlay/packages/apps/Camera/res/values/config.xml b/overlay/packages/apps/Camera/res/values/config.xml deleted file mode 100644 index a1445c4..0000000 --- a/overlay/packages/apps/Camera/res/values/config.xml +++ /dev/null @@ -1,24 +0,0 @@ - - - - - - touch-focus - false - diff --git a/overlay/packages/apps/Contacts/res/values/config.xml b/overlay/packages/apps/Contacts/res/values/config.xml deleted file mode 100644 index 6e48cd8..0000000 --- a/overlay/packages/apps/Contacts/res/values/config.xml +++ /dev/null @@ -1,21 +0,0 @@ - - - - - - - true - diff --git a/overlay/packages/apps/FM/res/values/config.xml b/overlay/packages/apps/FM/res/values/config.xml deleted file mode 100644 index 4ee80db..0000000 --- a/overlay/packages/apps/FM/res/values/config.xml +++ /dev/null @@ -1,9 +0,0 @@ - - - - - false - - - true - diff --git a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_grass.jpg b/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_grass.jpg deleted file mode 100644 index 5518d6d..0000000 Binary files a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_grass.jpg and /dev/null differ diff --git a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_grass_small.jpg b/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_grass_small.jpg deleted file mode 100644 index a1751e2..0000000 Binary files a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_grass_small.jpg and /dev/null differ diff --git a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_mountains.jpg b/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_mountains.jpg deleted file mode 100644 index 95c59ea..0000000 Binary files a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_mountains.jpg and /dev/null differ diff --git a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_mountains_small.jpg b/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_mountains_small.jpg deleted file mode 100644 index 956e8f0..0000000 Binary files a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_mountains_small.jpg and /dev/null differ diff --git a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_phasebeam.jpg b/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_phasebeam.jpg deleted file mode 100644 index 4bc7ff3..0000000 Binary files a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_phasebeam.jpg and /dev/null differ diff --git a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_phasebeam_small.jpg b/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_phasebeam_small.jpg deleted file mode 100644 index f034b33..0000000 Binary files a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_phasebeam_small.jpg and /dev/null differ diff --git a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_pulse.jpg b/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_pulse.jpg deleted file mode 100644 index 2f96d02..0000000 Binary files a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_pulse.jpg and /dev/null differ diff --git a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_pulse_small.jpg b/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_pulse_small.jpg deleted file mode 100644 index 34ca847..0000000 Binary files a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_pulse_small.jpg and /dev/null differ diff --git a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_shuttle.jpg b/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_shuttle.jpg deleted file mode 100644 index f4a3934..0000000 Binary files a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_shuttle.jpg and /dev/null differ diff --git a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_shuttle_small.jpg b/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_shuttle_small.jpg deleted file mode 100644 index d580182..0000000 Binary files a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_shuttle_small.jpg and /dev/null differ diff --git a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_stars.jpg b/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_stars.jpg deleted file mode 100644 index 8f3ec2d..0000000 Binary files a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_stars.jpg and /dev/null differ diff --git a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_stars_small.jpg b/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_stars_small.jpg deleted file mode 100644 index ba76f18..0000000 Binary files a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_stars_small.jpg and /dev/null differ diff --git a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_stream.jpg b/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_stream.jpg deleted file mode 100644 index fdd4aaf..0000000 Binary files a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_stream.jpg and /dev/null differ diff --git a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_stream_small.jpg b/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_stream_small.jpg deleted file mode 100644 index 432d67d..0000000 Binary files a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_stream_small.jpg and /dev/null differ diff --git a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_street_lights.jpg b/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_street_lights.jpg deleted file mode 100644 index a8b6880..0000000 Binary files a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_street_lights.jpg and /dev/null differ diff --git a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_street_lights_small.jpg b/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_street_lights_small.jpg deleted file mode 100644 index 11c253e..0000000 Binary files a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_street_lights_small.jpg and /dev/null differ diff --git a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_sunset.jpg b/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_sunset.jpg deleted file mode 100644 index 660040e..0000000 Binary files a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_sunset.jpg and /dev/null differ diff --git a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_sunset_small.jpg b/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_sunset_small.jpg deleted file mode 100644 index ed79925..0000000 Binary files a/overlay/packages/apps/Launcher2/res/drawable-hdpi/wallpaper_sunset_small.jpg and /dev/null differ diff --git a/overlay/packages/apps/Launcher2/res/values-hdpi/wallpapers.xml b/overlay/packages/apps/Launcher2/res/values-hdpi/wallpapers.xml deleted file mode 100644 index 40033cf..0000000 --- a/overlay/packages/apps/Launcher2/res/values-hdpi/wallpapers.xml +++ /dev/null @@ -1,36 +0,0 @@ - - - - - - wallpaper_street_lights - wallpaper_stream - wallpaper_phasebeam - wallpaper_pulse - wallpaper_nexusrain - wallpaper_stars - wallpaper_canyon - wallpaper_grass - wallpaper_zanzibar - wallpaper_cloud - wallpaper_monumentvalley - wallpaper_mountains - wallpaper_sunset - wallpaper_goldengate - wallpaper_shuttle - - diff --git a/overlay/packages/apps/Phone/res/values/config.xml b/overlay/packages/apps/Phone/res/values/config.xml deleted file mode 100644 index 69d82c1..0000000 --- a/overlay/packages/apps/Phone/res/values/config.xml +++ /dev/null @@ -1,36 +0,0 @@ - - - - - - - - true - true - - - false - - - true - - - true - - diff --git a/overlay/packages/apps/Settings/res/values/bools.xml b/overlay/packages/apps/Settings/res/values/bools.xml deleted file mode 100644 index 83d1213..0000000 --- a/overlay/packages/apps/Settings/res/values/bools.xml +++ /dev/null @@ -1,23 +0,0 @@ - - - - - - false - - true - diff --git a/overlay/packages/wallpapers/Basic/res/drawable-hdpi/nexus_thumb.png b/overlay/packages/wallpapers/Basic/res/drawable-hdpi/nexus_thumb.png deleted file mode 100644 index 84462e2..0000000 Binary files a/overlay/packages/wallpapers/Basic/res/drawable-hdpi/nexus_thumb.png and /dev/null differ diff --git a/overlay/packages/wallpapers/Basic/res/drawable-hdpi/pyramid_background.png b/overlay/packages/wallpapers/Basic/res/drawable-hdpi/pyramid_background.png deleted file mode 100644 index 2310a91..0000000 Binary files a/overlay/packages/wallpapers/Basic/res/drawable-hdpi/pyramid_background.png and /dev/null differ diff --git a/overlay/packages/wallpapers/Basic/res/raw/nexus.rs b/overlay/packages/wallpapers/Basic/res/raw/nexus.rs deleted file mode 100644 index df79689..0000000 --- a/overlay/packages/wallpapers/Basic/res/raw/nexus.rs +++ /dev/null @@ -1,313 +0,0 @@ -// Copyright (C) 2009 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. - -#pragma version(1) -#pragma stateVertex(PVOrtho) -#pragma stateStore(PSSolid) - -#define MAX_PULSES 20 -#define MAX_EXTRAS 40 -#define PULSE_SIZE 14 // Size in pixels of a cell -#define HALF_PULSE_SIZE 7 -#define GLOW_SIZE 64 // Size of the leading glow in pixels -#define HALF_GLOW_SIZE 32 -#define SPEED 0.2f // (200 / 1000) Pixels per ms -#define SPEED_VARIANCE 0.3f -#define PULSE_NORMAL 0 -#define PULSE_EXTRA 1 -#define TRAIL_SIZE 40 // Number of cells in a trail -#define MAX_DELAY 2000 // Delay between a pulse going offscreen and restarting - -struct pulse_s { - int pulseType; - float originX; - float originY; - int color; - int startTime; - float dx; - float dy; - float scale; - int active; -}; -struct pulse_s gPulses[MAX_PULSES]; - -struct pulse_s gExtras[MAX_EXTRAS]; - -int gNow; - - -void setColor(int c) { - if (State->mode == 1) { - // sholes red - color(0.9f, 0.1f, 0.1f, 0.8f); - } else if (c == 0) { - // red - color(1.0f, 0.0f, 0.0f, 0.8f); - } else if (c == 1) { - // green - color(0.0f, 0.8f, 0.0f, 0.8f); - } else if (c == 2) { - // blue - color(0.0f, 0.4f, 0.9f, 0.8f); - } else if (c == 3) { - // yellow - color(1.0f, 0.8f, 0.0f, 0.8f); - } -} - -void initPulse(struct pulse_s * pulse, int pulseType) { - float scale = randf2(0.7f, 1.7f); - pulse->scale = scale; - if (randf(1) > 0.5f) { - pulse->originX = (int)randf(State->width * 2 / PULSE_SIZE) * PULSE_SIZE; - pulse->dx = 0; - if (randf(1) > 0.5f) { - // Top - pulse->originY = 0; - pulse->dy = scale; - } else { - // Bottom - pulse->originY = State->height / scale; - pulse->dy = -scale; - } - } else { - pulse->originY = (int)randf(State->height / PULSE_SIZE) * PULSE_SIZE; - pulse->dy = 0; - if (randf(1) > 0.5f) { - // Left - pulse->originX = 0; - pulse->dx = scale; - } else { - // Right - pulse->originX = State->width * 2 / scale; - pulse->dx = -scale; - } - } - pulse->startTime = gNow + (int)randf(MAX_DELAY); - - pulse->color = (int)randf(4.0f); - - pulse->pulseType = pulseType; - if (pulseType == PULSE_EXTRA) { - pulse->active = 0; - } else { - pulse->active = 1; - } -} - -void initPulses() { - gNow = uptimeMillis(); - int i; - for (i=0; ipulseType = PULSE_EXTRA; - p->active = 0; - } -} - -void drawBackground(int width, int height) { - bindProgramFragment(NAMED_PFTextureBG); - bindTexture(NAMED_PFTextureBG, 0, NAMED_TBackground); - color(1.0f, 1.0f, 1.0f, 1.0f); - if (State->rotate) { - drawRect(0.0f, 0.0f, height*2, width, 0.0f); - } else { - drawRect(0.0f, 0.0f, width*2, height, 0.0f); - } -} - -void drawPulses(struct pulse_s * pulseSet, int setSize) { - bindProgramFragment(NAMED_PFTexture); - bindProgramFragmentStore(NAMED_PSBlend); - - float matrix[16]; - float modelMatrix[16]; - - int i; - for (i=0; istartTime; - - if (p->active != 0 && delta >= 0) { - - matrixLoadIdentity(modelMatrix); - if (State->rotate) { - //matrixLoadRotate(modelMatrix, 90.0f, 0.0f, 0.0f, 1.0f); - //matrixTranslate(modelMatrix, 0.0f, -height, 1.0f); - // XXX: HAX: do not slide display in landscape - } else { - matrixTranslate(modelMatrix, -(State->xOffset * State->width), 0, 0); - } - matrixScale(modelMatrix, p->scale, p->scale, 1.0f); - vpLoadModelMatrix(modelMatrix); - - float x = p->originX + (p->dx * SPEED * delta); - float y = p->originY + (p->dy * SPEED * delta); - - matrixLoadIdentity(matrix); - if (p->dx < 0) { - vpLoadTextureMatrix(matrix); - float xx = x + (TRAIL_SIZE * PULSE_SIZE); - if (xx <= 0) { - initPulse(p, p->pulseType); - } else { - setColor(p->color); - bindTexture(NAMED_PFTexture, 0, NAMED_TPulse); - drawRect(x, y, xx, y + PULSE_SIZE, 0.0f); - bindTexture(NAMED_PFTexture, 0, NAMED_TGlow); - drawRect(x + HALF_PULSE_SIZE - HALF_GLOW_SIZE, - y + HALF_PULSE_SIZE - HALF_GLOW_SIZE, - x + HALF_PULSE_SIZE + HALF_GLOW_SIZE, - y + HALF_PULSE_SIZE + HALF_GLOW_SIZE, - 0.0f); - } - } else if (p->dx > 0) { - x += PULSE_SIZE; // need to start on the other side of this cell - vpLoadTextureMatrix(matrix); - float xx = x - (TRAIL_SIZE * PULSE_SIZE); - if (xx >= State->width * 2) { - initPulse(p, p->pulseType); - } else { - setColor(p->color); - bindTexture(NAMED_PFTexture, 0, NAMED_TPulse); - drawRect(x, y, xx, y + PULSE_SIZE, 0.0f); - bindTexture(NAMED_PFTexture, 0, NAMED_TGlow); - drawRect(x - HALF_PULSE_SIZE - HALF_GLOW_SIZE, - y + HALF_PULSE_SIZE - HALF_GLOW_SIZE, - x - HALF_PULSE_SIZE + HALF_GLOW_SIZE, - y + HALF_PULSE_SIZE + HALF_GLOW_SIZE, - 0.0f); - } - } else if (p->dy < 0) { - vpLoadTextureMatrix(matrix); - float yy = y + (TRAIL_SIZE * PULSE_SIZE); - if (yy <= 0) { - initPulse(p, p->pulseType); - } else { - setColor(p->color); - bindTexture(NAMED_PFTexture, 0, NAMED_TPulseVert); - drawRect(x, yy, x + PULSE_SIZE, y, 0.0f); - bindTexture(NAMED_PFTexture, 0, NAMED_TGlow); - drawRect(x + HALF_PULSE_SIZE - HALF_GLOW_SIZE, - y + HALF_PULSE_SIZE - HALF_GLOW_SIZE, - x + HALF_PULSE_SIZE + HALF_GLOW_SIZE, - y + HALF_PULSE_SIZE + HALF_GLOW_SIZE, - 0.0f); - } - } else if (p->dy > 0) { - y += PULSE_SIZE; // need to start on the other side of this cell - vpLoadTextureMatrix(matrix); - float yy = y - (TRAIL_SIZE * PULSE_SIZE); - if (yy >= State->height) { - initPulse(p, p->pulseType); - } else { - setColor(p->color); - bindTexture(NAMED_PFTexture, 0, NAMED_TPulseVert); - drawRect(x, yy, x + PULSE_SIZE, y, 0.0f); - bindTexture(NAMED_PFTexture, 0, NAMED_TGlow); - drawRect(x + HALF_PULSE_SIZE - HALF_GLOW_SIZE, - y - HALF_PULSE_SIZE - HALF_GLOW_SIZE, - x + HALF_PULSE_SIZE + HALF_GLOW_SIZE, - y - HALF_PULSE_SIZE + HALF_GLOW_SIZE, - 0.0f); - } - } - } - } - - - matrixLoadIdentity(matrix); - vpLoadTextureMatrix(matrix); -} - -void addTap(int x, int y) { - int i; - int count = 0; - int color = (int)randf(4.0f); - float scale = randf2(0.9f, 1.9f); - x = (int)(x / PULSE_SIZE) * PULSE_SIZE; - y = (int)(y / PULSE_SIZE) * PULSE_SIZE; - for (i=0; iactive == 0) { - p->originX = x/scale; - p->originY = y/scale; - p->scale = scale; - - if (count == 0) { - p->dx = scale; - p->dy = 0.0f; - } else if (count == 1) { - p->dx = -scale; - p->dy = 0.0f; - } else if (count == 2) { - p->dx = 0.0f; - p->dy = scale; - } else if (count == 3) { - p->dx = 0.0f; - p->dy = -scale; - } - - p->active = 1; - p->color = color; - color++; - if (color >= 4) { - color = 0; - } - p->startTime = gNow; - count++; - if (count == 4) { - break; - } - } - } -} - -int main(int index) { - - gNow = uptimeMillis(); - - if (Command->command != 0) { - //debugF("x", Command->x); - //debugF("y", Command->y); - Command->command = 0; - addTap(Command->x, Command->y); - } - - int width = State->width; - int height = State->height; - - float matrix[16]; - matrixLoadIdentity(matrix); - if (State->rotate) { - //matrixLoadRotate(matrix, 90.0f, 0.0f, 0.0f, 1.0f); - //matrixTranslate(matrix, 0.0f, -height, 1.0f); - // XXX: HAX: do not slide display in landscape - } else { - matrixTranslate(matrix, -(State->xOffset * width), 0, 0); - } - - vpLoadModelMatrix(matrix); - - drawBackground(width, height); - - drawPulses(gPulses, MAX_PULSES); - drawPulses(gExtras, MAX_EXTRAS); - - return 45; -} diff --git a/overlay/packages/wallpapers/Basic/res/values/surfacemode.xml b/overlay/packages/wallpapers/Basic/res/values/surfacemode.xml deleted file mode 100644 index 37774ed..0000000 --- a/overlay/packages/wallpapers/Basic/res/values/surfacemode.xml +++ /dev/null @@ -1,18 +0,0 @@ - - - - true - diff --git a/shbootimg.mk b/shbootimg.mk index 5412568..c78cab3 100644 --- a/shbootimg.mk +++ b/shbootimg.mk @@ -1,7 +1,7 @@ LOCAL_PATH := $(call my-dir) INSTALLED_BOOTIMAGE_TARGET := $(PRODUCT_OUT)/boot.img -$(INSTALLED_BOOTIMAGE_TARGET): $(TARGET_PREBUILT_KERNEL) $(recovery_ramdisk) $(INSTALLED_RAMDISK_TARGET) $(PRODUCT_OUT)/utilities/flash_image $(PRODUCT_OUT)/utilities/busybox $(PRODUCT_OUT)/utilities/make_ext4fs $(PRODUCT_OUT)/utilities/erase_image $(PRODUCT_OUT)/modem.bin +$(INSTALLED_BOOTIMAGE_TARGET): $(TARGET_PREBUILT_KERNEL) $(recovery_ramdisk) $(INSTALLED_RAMDISK_TARGET) $(PRODUCT_OUT)/utilities/flash_image $(PRODUCT_OUT)/utilities/busybox $(PRODUCT_OUT)/utilities/erase_image $(PRODUCT_OUT)/modem.bin $(call pretty,"Boot image: $@") $(hide) ./device/samsung/aries-common/mkshbootimg.py $@ $(TARGET_PREBUILT_KERNEL) $(INSTALLED_RAMDISK_TARGET) $(recovery_ramdisk) -- cgit v1.1