patches/frameworks/av/0002-Implement-MediaTek-Camera-Support.patch

   1 From 3ed5dd81041727ea352fc3e85a197311bd917577 Mon Sep 17 00:00:00 2001
   2 From: adi766 <adityakumarteli7846@gmail.com>
   3 Date: Sat, 23 Sep 2017 15:56:27 +0000
   4 Subject: [PATCH] Implement MediaTek Camera Support
   5
   6 Change-Id: Iaae7c60d6711c6af53e59b966d2548c9cad8dfab
   7 ---
   8  camera/Android.mk                                  |   5 +
   9  camera/MtkCameraParameters.cpp                     | 294 +++++++++++++++++
  10  include/camera/MtkCameraParameters.h               | 351 +++++++++++++++++++++
  11  .../libstagefright/foundation/MediaBufferGroup.cpp |   6 +
  12  services/camera/libcameraservice/Android.mk        |   4 +
  13  .../camera/libcameraservice/api1/CameraClient.cpp  |  42 +++
  14  6 files changed, 702 insertions(+)
  15  create mode 100644 camera/MtkCameraParameters.cpp
  16  create mode 100644 include/camera/MtkCameraParameters.h
  17
  18 diff --git a/camera/Android.mk b/camera/Android.mk
  19 index 8a32299fa..8ba0e610f 100644
  20 --- a/camera/Android.mk
  21 +++ b/camera/Android.mk
  22 @@ -52,6 +52,11 @@ LOCAL_SRC_FILES += \
  23         CameraUtils.cpp \
  24         VendorTagDescriptor.cpp
  25
  26 +ifeq ($(BOARD_HAS_MTK_HARDWARE),true)
  27 +LOCAL_SRC_FILES+= \
  28 +       MtkCameraParameters.cpp
  29 +endif
  30 +
  31  LOCAL_SHARED_LIBRARIES := \
  32         libcutils \
  33         libutils \
  34 diff --git a/camera/MtkCameraParameters.cpp b/camera/MtkCameraParameters.cpp
  35 new file mode 100644
  36 index 000000000..7d7042aad
  37 --- /dev/null
  38 +++ b/camera/MtkCameraParameters.cpp
  39 @@ -0,0 +1,294 @@
  40 +/*
  41 + *
  42 + * Copyright 2008, The Android Open Source Project
  43 + *
  44 + * Licensed under the Apache License, Version 2.0 (the "License");
  45 + * you may not use this file except in compliance with the License.
  46 + * You may obtain a copy of the License at
  47 + *
  48 + *     http://www.apache.org/licenses/LICENSE-2.0
  49 + *
  50 + * Unless required by applicable law or agreed to in writing, software
  51 + * distributed under the License is distributed on an "AS IS" BASIS,
  52 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  53 + * See the License for the specific language governing permissions and
  54 + * limitations under the License.
  55 + */
  56 +
  57 +#define LOG_TAG "MTKCameraParams"
  58 +#include <utils/Log.h>
  59 +
  60 +#include <string.h>
  61 +#include <stdlib.h>
  62 +#include <camera/MtkCameraParameters.h>
  63 +
  64 +namespace android {
  65 +
  66 +
  67 +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  68 +//  App Mode.
  69 +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  70 +const char MtkCameraParameters::PROPERTY_KEY_CLIENT_APPMODE[]   = "client.appmode";
  71 +//
  72 +const char MtkCameraParameters::APP_MODE_NAME_DEFAULT[]         = "Default";
  73 +const char MtkCameraParameters::APP_MODE_NAME_MTK_ENG[]         = "MtkEng";
  74 +const char MtkCameraParameters::APP_MODE_NAME_MTK_ATV[]         = "MtkAtv";
  75 +const char MtkCameraParameters::APP_MODE_NAME_MTK_S3D[]         = "MtkS3d";
  76 +const char MtkCameraParameters::APP_MODE_NAME_MTK_VT[]          = "MtkVt";
  77 +const char MtkCameraParameters::APP_MODE_NAME_MTK_PHOTO[]       = "MtkPhoto";
  78 +const char MtkCameraParameters::APP_MODE_NAME_MTK_VIDEO[]       = "MtkVideo";
  79 +const char MtkCameraParameters::APP_MODE_NAME_MTK_ZSD[]         = "MtkZsd";
  80 +
  81 +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  82 +//  Scene Mode
  83 +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  84 +const char MtkCameraParameters::SCENE_MODE_NORMAL[] = "normal";
  85 +
  86 +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  87 +//  Face Beauty
  88 +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  89 +const char MtkCameraParameters::KEY_FB_SMOOTH_LEVEL[]       = "fb-smooth-level";
  90 +const char MtkCameraParameters::KEY_FB_SMOOTH_LEVEL_MIN[]   = "fb-smooth-level-min";
  91 +const char MtkCameraParameters::KEY_FB_SMOOTH_LEVEL_MAX[]   = "fb-smooth-level-max";
  92 +//
  93 +const char MtkCameraParameters::KEY_FB_SKIN_COLOR[]         = "fb-skin-color";
  94 +const char MtkCameraParameters::KEY_FB_SKIN_COLOR_MIN[]     = "fb-skin-color-min";
  95 +const char MtkCameraParameters::KEY_FB_SKIN_COLOR_MAX[]     = "fb-skin-color-max";
  96 +//
  97 +const char MtkCameraParameters::KEY_FB_SHARP[]              = "fb-sharp";
  98 +const char MtkCameraParameters::KEY_FB_SHARP_MIN[]          = "fb-sharp-min";
  99 +const char MtkCameraParameters::KEY_FB_SHARP_MAX[]          = "fb-sharp-max";
 100 +//
 101 +const char MtkCameraParameters::KEY_FB_ENLARGE_EYE[]        = "fb-enlarge-eye";
 102 +const char MtkCameraParameters::KEY_FB_ENLARGE_EYE_MIN[]    = "fb-enlarge-eye-min";
 103 +const char MtkCameraParameters::KEY_FB_ENLARGE_EYE_MAX[]    = "fb-enlarge-eye-max";
 104 +//
 105 +const char MtkCameraParameters::KEY_FB_SLIM_FACE[]          = "fb-slim-face";
 106 +const char MtkCameraParameters::KEY_FB_SLIM_FACE_MIN[]      = "fb-slim-face-min";
 107 +const char MtkCameraParameters::KEY_FB_SLIM_FACE_MAX[]      = "fb-slim-face-max";
 108 +//
 109 +const char MtkCameraParameters::KEY_FB_EXTREME_BEAUTY[]     = "fb-extreme-beauty";
 110 +//
 111 +const char MtkCameraParameters::KEY_FACE_BEAUTY[]           = "face-beauty";
 112 +
 113 +
 114 +//
 115 +const char MtkCameraParameters::KEY_EXPOSURE[] = "exposure";
 116 +const char MtkCameraParameters::KEY_EXPOSURE_METER[] = "exposure-meter";
 117 +const char MtkCameraParameters::KEY_ISO_SPEED[] = "iso-speed";
 118 +const char MtkCameraParameters::KEY_AE_MODE[] = "ae-mode";
 119 +const char MtkCameraParameters::KEY_FOCUS_METER[] = "focus-meter";
 120 +const char MtkCameraParameters::KEY_EDGE[] = "edge";
 121 +const char MtkCameraParameters::KEY_HUE[] = "hue";
 122 +const char MtkCameraParameters::KEY_SATURATION[] = "saturation";
 123 +const char MtkCameraParameters::KEY_BRIGHTNESS[] = "brightness";
 124 +const char MtkCameraParameters::KEY_CONTRAST[] = "contrast";
 125 +const char MtkCameraParameters::KEY_AF_LAMP_MODE [] = "aflamp-mode";
 126 +const char MtkCameraParameters::KEY_STEREO_3D_PREVIEW_SIZE[] = "stereo3d-preview-size";
 127 +const char MtkCameraParameters::KEY_STEREO_3D_PICTURE_SIZE[] = "stereo3d-picture-size";
 128 +const char MtkCameraParameters::KEY_STEREO_3D_TYPE [] = "stereo3d-type";
 129 +const char MtkCameraParameters::KEY_STEREO_3D_MODE [] = "stereo3d-mode";
 130 +const char MtkCameraParameters::KEY_STEREO_3D_IMAGE_FORMAT [] = "stereo3d-image-format";
 131 +
 132 +// ZSD
 133 +const char MtkCameraParameters::KEY_ZSD_MODE[] = "zsd-mode";
 134 +const char MtkCameraParameters::KEY_SUPPORTED_ZSD_MODE[] = "zsd-supported";
 135 +//
 136 +const char MtkCameraParameters::KEY_FPS_MODE[] = "fps-mode";
 137 +//
 138 +const char MtkCameraParameters::KEY_FOCUS_DRAW[] = "af-draw";
 139 +//
 140 +const char MtkCameraParameters::KEY_CAPTURE_MODE[] = "cap-mode";
 141 +const char MtkCameraParameters::KEY_SUPPORTED_CAPTURE_MODES[] = "cap-mode-values";
 142 +const char MtkCameraParameters::KEY_CAPTURE_PATH[] = "capfname";
 143 +const char MtkCameraParameters::KEY_BURST_SHOT_NUM[] = "burst-num";
 144 +//
 145 +const char MtkCameraParameters::KEY_MATV_PREVIEW_DELAY[] = "tv-delay";
 146 +const char MtkCameraParameters::KEY_PANORAMA_IDX[] = "pano-idx";
 147 +const char MtkCameraParameters::KEY_PANORAMA_DIR[] = "pano-dir";
 148 +
 149 +// Values for KEY_EXPOSURE
 150 +const char MtkCameraParameters::EXPOSURE_METER_SPOT[] = "spot";
 151 +const char MtkCameraParameters::EXPOSURE_METER_CENTER[] = "center";
 152 +const char MtkCameraParameters::EXPOSURE_METER_AVERAGE[] = "average";
 153 +
 154 +// Valeus for KEY_ISO_SPEED
 155 +const char MtkCameraParameters::ISO_SPEED_AUTO[] = "auto";
 156 +const char MtkCameraParameters::ISO_SPEED_100[] = "100";
 157 +const char MtkCameraParameters::ISO_SPEED_200[] = "200";
 158 +const char MtkCameraParameters::ISO_SPEED_400[] = "400";
 159 +const char MtkCameraParameters::ISO_SPEED_800[] = "800";
 160 +const char MtkCameraParameters::ISO_SPEED_1600[] = "1600";
 161 +
 162 +// Values for KEY_AE_MODE = "ae-mode"
 163 +
 164 +// Values for KEY_FOCUS_METER
 165 +const char MtkCameraParameters::FOCUS_METER_SPOT[] = "spot";
 166 +const char MtkCameraParameters::FOCUS_METER_MULTI[] = "multi";
 167 +
 168 +// AWB2PASS
 169 +const char MtkCameraParameters::KEY_AWB2PASS[] = "awb-2pass";
 170 +
 171 +
 172 +//
 173 +//  Camera Mode
 174 +const char MtkCameraParameters::KEY_CAMERA_MODE[] = "mtk-cam-mode";
 175 +// Values for KEY_CAMERA_MODE
 176 +const int MtkCameraParameters::CAMERA_MODE_NORMAL  = 0;
 177 +const int MtkCameraParameters::CAMERA_MODE_MTK_PRV = 1;
 178 +const int MtkCameraParameters::CAMERA_MODE_MTK_VDO = 2;
 179 +const int MtkCameraParameters::CAMERA_MODE_MTK_VT  = 3;
 180 +
 181 +// Values for KEY_FPS_MODE
 182 +const int MtkCameraParameters::FPS_MODE_NORMAL = 0;
 183 +const int MtkCameraParameters::FPS_MODE_FIX = 1;
 184 +
 185 +// Values for raw save mode
 186 +
 187 +// Values for KEY_FOCUS_DRAW
 188 +
 189 +// Values for capture mode
 190 +const char MtkCameraParameters::CAPTURE_MODE_PANORAMA_SHOT[] = "panoramashot";
 191 +const char MtkCameraParameters::CAPTURE_MODE_BURST_SHOT[] = "burstshot";
 192 +const char MtkCameraParameters::CAPTURE_MODE_NORMAL[] = "normal";
 193 +const char MtkCameraParameters::CAPTURE_MODE_BEST_SHOT[] = "bestshot";
 194 +const char MtkCameraParameters::CAPTURE_MODE_EV_BRACKET_SHOT[] = "evbracketshot";
 195 +const char MtkCameraParameters::CAPTURE_MODE_SMILE_SHOT[] = "smileshot";
 196 +const char MtkCameraParameters::CAPTURE_MODE_MAV_SHOT[] = "mav";
 197 +const char MtkCameraParameters::CAPTURE_MODE_AUTO_PANORAMA_SHOT[] = "autorama";
 198 +const char MtkCameraParameters::CAPTURE_MODE_MOTION_TRACK_SHOT[] = "motiontrack";
 199 +const char MtkCameraParameters::CAPTURE_MODE_HDR_SHOT[] = "hdr";
 200 +const char MtkCameraParameters::CAPTURE_MODE_ASD_SHOT[] = "asd";
 201 +const char MtkCameraParameters::CAPTURE_MODE_ZSD_SHOT[] = "zsd";
 202 +const char MtkCameraParameters::CAPTURE_MODE_PANO_3D[] = "pano_3d";
 203 +const char MtkCameraParameters::CAPTURE_MODE_SINGLE_3D[] = "single_3d";
 204 +const char MtkCameraParameters::CAPTURE_MODE_FACE_BEAUTY[] = "face_beauty";
 205 +const char MtkCameraParameters::CAPTURE_MODE_CONTINUOUS_SHOT[] = "continuousshot";
 206 +const char MtkCameraParameters::CAPTURE_MODE_MULTI_MOTION[] = "multi_motion";
 207 +const char MtkCameraParameters::CAPTURE_MODE_GESTURE_SHOT[] = "gestureshot";
 208 +
 209 +// Values for panorama direction settings
 210 +const char MtkCameraParameters::PANORAMA_DIR_RIGHT[] = "right";
 211 +const char MtkCameraParameters::PANORAMA_DIR_LEFT[] = "left";
 212 +const char MtkCameraParameters::PANORAMA_DIR_TOP[] = "top";
 213 +const char MtkCameraParameters::PANORAMA_DIR_DOWN[] = "down";
 214 +
 215 +//
 216 +const int MtkCameraParameters::ENABLE = 1;
 217 +const int MtkCameraParameters::DISABLE = 0;
 218 +
 219 +// Values for KEY_EDGE, KEY_HUE, KEY_SATURATION, KEY_BRIGHTNESS, KEY_CONTRAST
 220 +const char MtkCameraParameters::HIGH[] = "high";
 221 +const char MtkCameraParameters::MIDDLE[] = "middle";
 222 +const char MtkCameraParameters::LOW[] = "low";
 223 +
 224 +// Preview Internal Format.
 225 +const char MtkCameraParameters::KEY_PREVIEW_INT_FORMAT[] = "prv-int-fmt";
 226 +
 227 +// Pixel color formats for KEY_PREVIEW_FORMAT, KEY_PICTURE_FORMAT,
 228 +// and KEY_VIDEO_FRAME_FORMAT
 229 +const char MtkCameraParameters::PIXEL_FORMAT_YUV420I[] = "yuv420i-yyuvyy-3plane";
 230 +const char MtkCameraParameters::PIXEL_FORMAT_YV12_GPU[] = "yv12-gpu";
 231 +const char MtkCameraParameters::PIXEL_FORMAT_YUV422I_UYVY[] = "yuv422i-uyvy";
 232 +const char MtkCameraParameters::PIXEL_FORMAT_YUV422I_VYUY[] = "yuv422i-vyuy";
 233 +const char MtkCameraParameters::PIXEL_FORMAT_YUV422I_YVYU[] = "yuv422i-yvyu";
 234 +
 235 +const char MtkCameraParameters::PIXEL_FORMAT_BAYER8[] = "bayer8";
 236 +const char MtkCameraParameters::PIXEL_FORMAT_BAYER10[] = "bayer10";
 237 +
 238 +const char MtkCameraParameters::KEY_BRIGHTNESS_VALUE[] = "brightness_value";
 239 +
 240 +// ISP Operation mode for meta mode use
 241 +const char MtkCameraParameters::KEY_ISP_MODE[] = "isp-mode";
 242 +// AF
 243 +const char MtkCameraParameters::KEY_AF_X[] = "af-x";
 244 +const char MtkCameraParameters::KEY_AF_Y[] = "af-y";
 245 +// Effect
 246 +const char MtkCameraParameters::EFFECT_SEPIA_BLUE[] = "sepiablue";
 247 +const char MtkCameraParameters::EFFECT_SEPIA_GREEN[] = "sepiagreen";
 248 +
 249 +//
 250 +//  on/off => FIXME: should be replaced with TRUE[]
 251 +const char MtkCameraParameters::ON[] = "on";
 252 +const char MtkCameraParameters::OFF[] = "off";
 253 +//
 254 +const char MtkCameraParameters::WHITE_BALANCE_TUNGSTEN[] = "tungsten";
 255 +//
 256 +const char MtkCameraParameters::ISO_SPEED_ENG[] = "iso-speed-eng";
 257 +const char MtkCameraParameters::KEY_RAW_SAVE_MODE[] = "rawsave-mode";
 258 +const char MtkCameraParameters::KEY_RAW_PATH[] = "rawfname";
 259 +
 260 +const char MtkCameraParameters::KEY_FAST_CONTINUOUS_SHOT[] = "fast-continuous-shot";
 261 +
 262 +const char MtkCameraParameters::KEY_CSHOT_INDICATOR[] = "cshot-indicator";
 263 +
 264 +// AF EM MODE
 265 +const char MtkCameraParameters::KEY_FOCUS_ENG_MODE[]           = "afeng-mode";
 266 +const char MtkCameraParameters::KEY_FOCUS_ENG_STEP[]           = "afeng-pos";
 267 +const char MtkCameraParameters::KEY_FOCUS_ENG_MAX_STEP[]       = "afeng-max-focus-step";
 268 +const char MtkCameraParameters::KEY_FOCUS_ENG_MIN_STEP[]       = "afeng-min-focus-step";
 269 +const char MtkCameraParameters::KEY_FOCUS_ENG_BEST_STEP[]   = "afeng-best-focus-step";
 270 +const char MtkCameraParameters::KEY_RAW_DUMP_FLAG[]         = "afeng_raw_dump_flag";
 271 +const char MtkCameraParameters::KEY_PREVIEW_DUMP_RESOLUTION[] = "preview-dump-resolution";
 272 +// Values for KEY_PREVIEW_DUMP_RESOLUTION
 273 +const int MtkCameraParameters::PREVIEW_DUMP_RESOLUTION_NORMAL  = 0;
 274 +const int MtkCameraParameters::PREVIEW_DUMP_RESOLUTION_CROP  = 1;
 275 +//
 276 +const char MtkCameraParameters::KEY_MAX_NUM_DETECTED_OBJECT[] = "max-num-ot";
 277 +//
 278 +const char MtkCameraParameters::KEY_VIDEO_HDR[] = "video-hdr";
 279 +
 280 +// KEY for [Engineer Mode] Add new camera paramters for new requirements
 281 +const char MtkCameraParameters::KEY_ENG_AE_ENABLE[] = "eng-ae-enable";
 282 +const char MtkCameraParameters::KEY_ENG_PREVIEW_SHUTTER_SPEED[] = "eng-preview-shutter-speed";
 283 +const char MtkCameraParameters::KEY_ENG_PREVIEW_SENSOR_GAIN[] = "eng-preview-sensor-gain";
 284 +const char MtkCameraParameters::KEY_ENG_PREVIEW_ISP_GAIN[] = "eng-preview-isp-gain";
 285 +const char MtkCameraParameters::KEY_ENG_PREVIEW_AE_INDEX[] = "eng-preview-ae-index";
 286 +const char MtkCameraParameters::KEY_ENG_CAPTURE_SENSOR_GAIN[] = "eng-capture-sensor-gain";
 287 +const char MtkCameraParameters::KEY_ENG_CAPTURE_ISP_GAIN[] = "eng-capture-isp-gain";
 288 +const char MtkCameraParameters::KEY_ENG_CAPTURE_SHUTTER_SPEED[] = "eng-capture-shutter-speed";
 289 +const char MtkCameraParameters::KEY_ENG_CAPTURE_ISO[] = "eng-capture-iso";
 290 +const char MtkCameraParameters::KEY_ENG_FLASH_DUTY_VALUE[] = "eng-flash-duty-value";
 291 +const char MtkCameraParameters::KEY_ENG_FLASH_DUTY_MIN[] = "eng-flash-duty-min";
 292 +const char MtkCameraParameters::KEY_ENG_FLASH_DUTY_MAX[] = "eng-flash-duty-max";
 293 +const char MtkCameraParameters::KEY_ENG_ZSD_ENABLE[] = "eng-zsd-enable";
 294 +const char MtkCameraParameters::KEY_SENSOR_TYPE[] = "sensor-type";
 295 +const char MtkCameraParameters::KEY_ENG_PREVIEW_FPS[] = "eng-preview-fps";
 296 +const char MtkCameraParameters::KEY_ENG_MSG[] = "eng-msg";
 297 +const int  MtkCameraParameters::KEY_ENG_FLASH_DUTY_DEFAULT_VALUE = -1;
 298 +const int  MtkCameraParameters::KEY_ENG_FLASH_STEP_DEFAULT_VALUE = -1;
 299 +const char MtkCameraParameters::KEY_ENG_FLASH_STEP_MIN[] = "eng-flash-step-min";
 300 +const char MtkCameraParameters::KEY_ENG_FLASH_STEP_MAX[] = "eng-flash-step-max";
 301 +const char MtkCameraParameters::KEY_ENG_FOCUS_FULLSCAN_FRAME_INTERVAL[] = "eng-focus-fullscan-frame-interval";
 302 +const char MtkCameraParameters::KEY_ENG_FOCUS_FULLSCAN_FRAME_INTERVAL_MAX[] = "eng-focus-fullscan-frame-interval-max";
 303 +const char MtkCameraParameters::KEY_ENG_FOCUS_FULLSCAN_FRAME_INTERVAL_MIN[] = "eng-focus-fullscan-frame-interval-min";
 304 +const int  MtkCameraParameters::KEY_ENG_FOCUS_FULLSCAN_FRAME_INTERVAL_MAX_DEFAULT = 65535;
 305 +const int  MtkCameraParameters::KEY_ENG_FOCUS_FULLSCAN_FRAME_INTERVAL_MIN_DEFAULT = 0;
 306 +const char MtkCameraParameters::KEY_ENG_PREVIEW_FRAME_INTERVAL_IN_US[] = "eng-preview-frame-interval-in-us";
 307 +const char MtkCameraParameters::KEY_ENG_PARAMETER1[] = "key-eng-parameter1";
 308 +const char MtkCameraParameters::KEY_ENG_PARAMETER2[] = "key-eng-parameter2";
 309 +const char MtkCameraParameters::KEY_ENG_PARAMETER3[] = "key-eng-parameter3";
 310 +
 311 +const char MtkCameraParameters::KEY_ENG_SAVE_SHADING_TABLE[] = "eng-save-shading-table";
 312 +const char MtkCameraParameters::KEY_ENG_SHADING_TABLE[] = "eng-shading-table";
 313 +const int MtkCameraParameters::KEY_ENG_SHADING_TABLE_AUTO = 0;
 314 +const int MtkCameraParameters::KEY_ENG_SHADING_TABLE_LOW = 1;
 315 +const int MtkCameraParameters::KEY_ENG_SHADING_TABLE_MIDDLE = 2;
 316 +const int MtkCameraParameters::KEY_ENG_SHADING_TABLE_HIGH = 3;
 317 +const int MtkCameraParameters::KEY_ENG_SHADING_TABLE_TSF = 4;
 318 +
 319 +// KEY for [Engineer Mode] Add new camera paramters for ev calibration
 320 +const char MtkCameraParameters::KEY_ENG_EV_CALBRATION_OFFSET_VALUE[] = "eng-ev-cal-offset";
 321 +
 322 +#ifdef MTK_SLOW_MOTION_VIDEO_SUPPORT
 323 +// High Speed Video Record
 324 +const char MtkCameraParameters::KEY_HSVR_PRV_SIZE[] = "hsvr-prv-size";
 325 +const char MtkCameraParameters::KEY_SUPPORTED_HSVR_PRV_SIZE[] = "hsvr-prv-size-values";
 326 +const char MtkCameraParameters::KEY_HSVR_PRV_FPS[] = "hsvr-prv-fps";
 327 +const char MtkCameraParameters::KEY_SUPPORTED_HSVR_PRV_FPS[] = "hsvr-prv-fps-values";
 328 +#endif
 329 +const char MtkCameraParameters::KEY_DXOEIS_ONOFF[] = "dxo-eis";
 330 +const char MtkCameraParameters::KEY_FIX_EXPOSURE_TIME[] = "fix-exposure-time";
 331 +
 332 +}; // namespace android
 333 +
 334 diff --git a/include/camera/MtkCameraParameters.h b/include/camera/MtkCameraParameters.h
 335 new file mode 100644
 336 index 000000000..e9456d53d
 337 --- /dev/null
 338 +++ b/include/camera/MtkCameraParameters.h
 339 @@ -0,0 +1,351 @@
 340 +/*
 341 + * Copyright (C) 2008 The Android Open Source Project
 342 + *
 343 + * Licensed under the Apache License, Version 2.0 (the "License");
 344 + * you may not use this file except in compliance with the License.
 345 + * You may obtain a copy of the License at
 346 + *
 347 + *      http://www.apache.org/licenses/LICENSE-2.0
 348 + *
 349 + * Unless required by applicable law or agreed to in writing, software
 350 + * distributed under the License is distributed on an "AS IS" BASIS,
 351 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 352 + * See the License for the specific language governing permissions and
 353 + * limitations under the License.
 354 + */
 355 +
 356 +#ifndef ANDROID_HARDWARE_MTK_CAMERA_PARAMETERS_H
 357 +#define ANDROID_HARDWARE_MTK_CAMERA_PARAMETERS_H
 358 +
 359 +#include <camera/CameraParameters.h>
 360 +
 361 +namespace android {
 362 +
 363 +
 364 +/**
 365 + * @class      MtkCameraParameters
 366 + * @brief      MTK-proprietary camera parameters.
 367 + * @details    This class is derived from CameraParameters and defines MTK-proprietary camera parameters.
 368 + */
 369 +class MtkCameraParameters : public CameraParameters
 370 +{
 371 +public:
 372 +    MtkCameraParameters() : CameraParameters() {}
 373 +    MtkCameraParameters(const String8 &params) { unflatten(params); }
 374 +    ~MtkCameraParameters()  {}
 375 +
 376 +    MtkCameraParameters& operator=(CameraParameters const& params)
 377 +    {
 378 +        unflatten(params.flatten());
 379 +        return  (*this);
 380 +    }
 381 +    //
 382 +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 383 +//  App Mode.
 384 +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 385 +    static const char PROPERTY_KEY_CLIENT_APPMODE[];
 386 +    //
 387 +    static const char APP_MODE_NAME_DEFAULT[];
 388 +    static const char APP_MODE_NAME_MTK_ENG[];
 389 +    static const char APP_MODE_NAME_MTK_ATV[];
 390 +    static const char APP_MODE_NAME_MTK_S3D[];
 391 +    static const char APP_MODE_NAME_MTK_VT[];
 392 +    static const char APP_MODE_NAME_MTK_PHOTO[];
 393 +    static const char APP_MODE_NAME_MTK_VIDEO[];
 394 +    static const char APP_MODE_NAME_MTK_ZSD[];
 395 +    //
 396 +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 397 +//  Scene Mode
 398 +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 399 +    static const char SCENE_MODE_NORMAL[];
 400 +    //
 401 +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 402 +//  Face Beauty
 403 +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 404 +    static const char KEY_FB_SMOOTH_LEVEL[];
 405 +    static const char KEY_FB_SMOOTH_LEVEL_MIN[];
 406 +    static const char KEY_FB_SMOOTH_LEVEL_MAX[];
 407 +    //
 408 +    static const char KEY_FB_SKIN_COLOR[];
 409 +    static const char KEY_FB_SKIN_COLOR_MIN[];
 410 +    static const char KEY_FB_SKIN_COLOR_MAX[];
 411 +    //
 412 +    static const char KEY_FB_SHARP[];
 413 +    static const char KEY_FB_SHARP_MIN[];
 414 +    static const char KEY_FB_SHARP_MAX[];
 415 +    //
 416 +    static const char KEY_FB_ENLARGE_EYE[];
 417 +    static const char KEY_FB_ENLARGE_EYE_MIN[];
 418 +    static const char KEY_FB_ENLARGE_EYE_MAX[];
 419 +    //
 420 +    static const char KEY_FB_SLIM_FACE[];
 421 +    static const char KEY_FB_SLIM_FACE_MIN[];
 422 +    static const char KEY_FB_SLIM_FACE_MAX[];
 423 +    //
 424 +    static const char KEY_FB_EXTREME_BEAUTY[];
 425 +    //
 426 +    static const char KEY_FACE_BEAUTY[];
 427 +    //
 428 +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 429 +//
 430 +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 431 +    static const char KEY_EXPOSURE[];
 432 +    static const char KEY_EXPOSURE_METER[];
 433 +    static const char KEY_ISO_SPEED[];
 434 +    static const char KEY_AE_MODE[];
 435 +    static const char KEY_FOCUS_METER[];
 436 +    static const char KEY_EDGE[];
 437 +    static const char KEY_HUE[];
 438 +    static const char KEY_SATURATION[];
 439 +    static const char KEY_BRIGHTNESS[];
 440 +    static const char KEY_CONTRAST[];
 441 +    static const char KEY_ZSD_MODE[];
 442 +    static const char KEY_SUPPORTED_ZSD_MODE[];
 443 +    static const char KEY_AWB2PASS[];
 444 +    static const char KEY_AF_LAMP_MODE [];
 445 +
 446 +    static const char KEY_STEREO_3D_PREVIEW_SIZE[];
 447 +    static const char KEY_STEREO_3D_PICTURE_SIZE[];
 448 +    static const char KEY_STEREO_3D_TYPE [];
 449 +    static const char KEY_STEREO_3D_MODE [];
 450 +    static const char KEY_STEREO_3D_IMAGE_FORMAT [];
 451 +    //
 452 +    static const char KEY_FPS_MODE[];       // normal,fix
 453 +    //
 454 +    static const char KEY_FOCUS_DRAW[];     // 0,1
 455 +    //
 456 +    static const char KEY_CAPTURE_MODE[];   // normal,bestshot,evbracketshot,burstshot,smileshot,panoramashot
 457 +    static const char KEY_SUPPORTED_CAPTURE_MODES[];
 458 +    static const char KEY_CAPTURE_PATH[];
 459 +    static const char KEY_BURST_SHOT_NUM[];
 460 +    //
 461 +    static const char KEY_MATV_PREVIEW_DELAY[];
 462 +    //
 463 +    static const char KEY_PANORAMA_IDX[];
 464 +    static const char KEY_PANORAMA_DIR[];   // right,left,top,bottom
 465 +    //
 466 +    static const char KEY_SENSOR_DEV[];    // main,sub,atv
 467 +    static const char KEY_SUPPORTED_SENSOR_DEVS[];
 468 +
 469 +    // Values for KEY_EXPOSURE
 470 +    static const char EXPOSURE_METER_SPOT[];
 471 +    static const char EXPOSURE_METER_CENTER[];
 472 +    static const char EXPOSURE_METER_AVERAGE[];
 473 +
 474 +    // Valeus for KEY_ISO_SPEED
 475 +    static const char ISO_SPEED_AUTO[];
 476 +    static const char ISO_SPEED_100[];
 477 +    static const char ISO_SPEED_200[];
 478 +    static const char ISO_SPEED_400[];
 479 +    static const char ISO_SPEED_800[];
 480 +    static const char ISO_SPEED_1600[];
 481 +
 482 +    // Values for KEY_FOCUS_METER
 483 +    static const char FOCUS_METER_SPOT[];
 484 +    static const char FOCUS_METER_MULTI[];
 485 +
 486 +    static const char KEY_CAMERA_MODE[];
 487 +    // Values for KEY_CAMERA_MODE
 488 +    static const int CAMERA_MODE_NORMAL;
 489 +    static const int CAMERA_MODE_MTK_PRV;
 490 +    static const int CAMERA_MODE_MTK_VDO;
 491 +    static const int CAMERA_MODE_MTK_VT;
 492 +
 493 +    // Values for KEY_FPS_MODE
 494 +    static const int FPS_MODE_NORMAL;
 495 +    static const int FPS_MODE_FIX;
 496 +
 497 +    // Values for KEY_CAPTURE_MODE
 498 +    static const char CAPTURE_MODE_PANORAMA_SHOT[];
 499 +    static const char CAPTURE_MODE_BURST_SHOT[];
 500 +    static const char CAPTURE_MODE_NORMAL[];
 501 +    static const char CAPTURE_MODE_BEST_SHOT[];
 502 +    static const char CAPTURE_MODE_EV_BRACKET_SHOT[];
 503 +    static const char CAPTURE_MODE_SMILE_SHOT[];
 504 +    static const char CAPTURE_MODE_AUTO_PANORAMA_SHOT[];
 505 +    static const char CAPTURE_MODE_MOTION_TRACK_SHOT[];
 506 +    static const char CAPTURE_MODE_MAV_SHOT[];
 507 +    static const char CAPTURE_MODE_HDR_SHOT[];
 508 +    static const char CAPTURE_MODE_ASD_SHOT[];
 509 +    static const char CAPTURE_MODE_ZSD_SHOT[];
 510 +    static const char CAPTURE_MODE_PANO_3D[];
 511 +    static const char CAPTURE_MODE_SINGLE_3D[];
 512 +    static const char CAPTURE_MODE_FACE_BEAUTY[];
 513 +    static const char CAPTURE_MODE_CONTINUOUS_SHOT[];
 514 +    static const char CAPTURE_MODE_MULTI_MOTION[];
 515 +    static const char CAPTURE_MODE_GESTURE_SHOT[];
 516 +
 517 +    // Values for KEY_PANORAMA_DIR
 518 +    static const char PANORAMA_DIR_RIGHT[];
 519 +    static const char PANORAMA_DIR_LEFT[];
 520 +    static const char PANORAMA_DIR_TOP[];
 521 +    static const char PANORAMA_DIR_DOWN[];
 522 +    //
 523 +    static const int ENABLE;
 524 +    static const int DISABLE;
 525 +
 526 +    // Values for KEY_EDGE, KEY_HUE, KEY_SATURATION, KEY_BRIGHTNESS, KEY_CONTRAST
 527 +    static const char HIGH[];
 528 +    static const char MIDDLE[];
 529 +    static const char LOW[];
 530 +
 531 +    // Preview Internal Format.
 532 +    static const char KEY_PREVIEW_INT_FORMAT[];
 533 +
 534 +    // Pixel color formats for KEY_PREVIEW_FORMAT, KEY_PICTURE_FORMAT,
 535 +    // and KEY_VIDEO_FRAME_FORMAT
 536 +    static const char PIXEL_FORMAT_YUV420I[]; // I420
 537 +
 538 +    /**
 539 +     * @var PIXEL_FORMAT_YV12_GPU
 540 +     *
 541 +     * GPU YUV format:
 542 +     *
 543 +     * YV12 is a 4:2:0 YCrCb planar format comprised of a WxH Y plane followed
 544 +     * by (W/2) x (H/2) Cr and Cb planes.
 545 +     *
 546 +     * This format assumes
 547 +     * - an even width
 548 +     * - an even height
 549 +     * - a vertical stride equal to the height
 550 +     * - a horizontal stride multiple of 32/16/16 pixels for y/cr/cb respectively
 551 +     *   i.e.
 552 +     *   y_stride = ALIGN(width, 32)
 553 +     *   c_stride = y_stride / 2
 554 +     *
 555 +     *   y_size = y_stride * height
 556 +     *   c_size = c_stride * height / 2
 557 +     *   size = y_size + c_size * 2
 558 +     *   cr_offset = y_size
 559 +     *   cb_offset = y_size + c_size
 560 +     *
 561 +     *   for example:
 562 +     *      width/height = 176x144
 563 +     *      y stride     = 192x144
 564 +     *      cr stride    = 96x72
 565 +     *      cb stride    = 96x72
 566 +     *
 567 +     */
 568 +    static const char PIXEL_FORMAT_YV12_GPU[];
 569 +
 570 +    /*
 571 +     *  YUV422 format, 1 plane (UYVY)
 572 +     *
 573 +     *  Effective bits per pixel : 16
 574 +     *
 575 +     *  Y sample at every pixel, U and V sampled at every second pixel horizontally on each line.
 576 +     *  A macropixel contains 2 pixels in 1 uint32_t.
 577 +     *
 578 +     */
 579 +    static const char PIXEL_FORMAT_YUV422I_UYVY[];
 580 +    //
 581 +    static const char PIXEL_FORMAT_YUV422I_VYUY[];
 582 +    static const char PIXEL_FORMAT_YUV422I_YVYU[];
 583 +    static const char PIXEL_FORMAT_BAYER8[];
 584 +    static const char PIXEL_FORMAT_BAYER10[];
 585 +
 586 +    /**
 587 +     * @var KEY_BRIGHTNESS_VALUE
 588 +     *
 589 +     * This is a key string of brightness value, scaled by 10.
 590 +     *
 591 +     */
 592 +    static const char KEY_BRIGHTNESS_VALUE[];
 593 +
 594 +    // ISP Operation mode for meta mode use
 595 +    static const char KEY_ISP_MODE[];
 596 +    // AF
 597 +    static const char KEY_AF_X[];
 598 +    static const char KEY_AF_Y[];
 599 +    static const char KEY_FOCUS_ENG_MAX_STEP[];
 600 +    static const char KEY_FOCUS_ENG_MIN_STEP[];
 601 +    static const char KEY_FOCUS_ENG_BEST_STEP[];
 602 +    static const char KEY_RAW_DUMP_FLAG[];
 603 +    static const char KEY_PREVIEW_DUMP_RESOLUTION[];
 604 +    static const int  PREVIEW_DUMP_RESOLUTION_NORMAL;
 605 +    static const int  PREVIEW_DUMP_RESOLUTION_CROP;
 606 +
 607 +    // Values for effect
 608 +    static const char EFFECT_SEPIA_BLUE[];
 609 +    static const char EFFECT_SEPIA_GREEN[];
 610 +    // Values for AWB
 611 +    static const char WHITE_BALANCE_TUNGSTEN[];
 612 +    // Eng
 613 +    static const char ISO_SPEED_ENG[];
 614 +    static const char KEY_FOCUS_ENG_MODE[]; // 0,1,2,3 (0: normal)
 615 +    static const char KEY_FOCUS_ENG_STEP[];
 616 +    static const char KEY_RAW_SAVE_MODE[];  // on, off
 617 +    static const char KEY_RAW_PATH[];
 618 +
 619 +       // KEY for Continuous shot speed
 620 +    static const char KEY_FAST_CONTINUOUS_SHOT[];
 621 +
 622 +    static const char KEY_VIDEO_HDR[];
 623 +
 624 +    static const char KEY_MAX_NUM_DETECTED_OBJECT[];
 625 +
 626 +    // KEY for c_shot indicator
 627 +    static const char KEY_CSHOT_INDICATOR[];
 628 +
 629 +    // KEY for [Engineer Mode] Add new camera paramters for new requirements
 630 +    static const char KEY_ENG_AE_ENABLE[];
 631 +    static const char KEY_ENG_PREVIEW_SHUTTER_SPEED[];
 632 +    static const char KEY_ENG_PREVIEW_SENSOR_GAIN[];
 633 +    static const char KEY_ENG_PREVIEW_ISP_GAIN[];
 634 +    static const char KEY_ENG_PREVIEW_AE_INDEX[];
 635 +    static const char KEY_ENG_CAPTURE_SENSOR_GAIN[];
 636 +    static const char KEY_ENG_CAPTURE_ISP_GAIN[];
 637 +    static const char KEY_ENG_CAPTURE_SHUTTER_SPEED[];
 638 +    static const char KEY_ENG_CAPTURE_ISO[];
 639 +    static const char KEY_ENG_FLASH_DUTY_VALUE[];
 640 +    static const char KEY_ENG_FLASH_DUTY_MIN[];
 641 +    static const char KEY_ENG_FLASH_DUTY_MAX[];
 642 +    static const char KEY_ENG_ZSD_ENABLE[];
 643 +    static const char KEY_SENSOR_TYPE[];
 644 +    static const char KEY_ENG_PREVIEW_FPS[];
 645 +    static const char KEY_ENG_MSG[];
 646 +    static const int  KEY_ENG_FLASH_DUTY_DEFAULT_VALUE;
 647 +    static const int  KEY_ENG_FLASH_STEP_DEFAULT_VALUE;
 648 +    static const char KEY_ENG_FLASH_STEP_MIN[];
 649 +    static const char KEY_ENG_FLASH_STEP_MAX[];
 650 +    static const char KEY_ENG_FOCUS_FULLSCAN_FRAME_INTERVAL[];
 651 +    static const char KEY_ENG_FOCUS_FULLSCAN_FRAME_INTERVAL_MAX[];
 652 +    static const char KEY_ENG_FOCUS_FULLSCAN_FRAME_INTERVAL_MIN[];
 653 +    static const int  KEY_ENG_FOCUS_FULLSCAN_FRAME_INTERVAL_MAX_DEFAULT;
 654 +    static const int  KEY_ENG_FOCUS_FULLSCAN_FRAME_INTERVAL_MIN_DEFAULT;
 655 +    static const char KEY_ENG_PREVIEW_FRAME_INTERVAL_IN_US[];
 656 +    static const char KEY_ENG_PARAMETER1[];
 657 +    static const char KEY_ENG_PARAMETER2[];
 658 +    static const char KEY_ENG_PARAMETER3[];
 659 +
 660 +    static const char KEY_ENG_SAVE_SHADING_TABLE[];
 661 +    static const char KEY_ENG_SHADING_TABLE[];
 662 +    static const int KEY_ENG_SHADING_TABLE_AUTO;
 663 +    static const int KEY_ENG_SHADING_TABLE_LOW;
 664 +    static const int KEY_ENG_SHADING_TABLE_MIDDLE;
 665 +    static const int KEY_ENG_SHADING_TABLE_HIGH;
 666 +    static const int KEY_ENG_SHADING_TABLE_TSF;
 667 +
 668 +    // KEY for [Engineer Mode] Add new camera paramters for ev calibration
 669 +    static const char KEY_ENG_EV_CALBRATION_OFFSET_VALUE[];
 670 +
 671 +#ifdef MTK_SLOW_MOTION_VIDEO_SUPPORT
 672 +    // High Speed Video Record
 673 +    static const char KEY_HSVR_PRV_SIZE[];
 674 +    static const char KEY_SUPPORTED_HSVR_PRV_SIZE[];
 675 +    static const char KEY_HSVR_PRV_FPS[];
 676 +    static const char KEY_SUPPORTED_HSVR_PRV_FPS[];
 677 +#endif
 678 +
 679 +    static const char KEY_DXOEIS_ONOFF[];
 680 +    static const char KEY_FIX_EXPOSURE_TIME[];
 681 +       //
 682 +public:     ////    on/off => FIXME: should be replaced with TRUE[]
 683 +    static const char ON[];
 684 +    static const char OFF[];
 685 +};
 686 +
 687 +}; // namespace android
 688 +
 689 +#endif
 690 +
 691 diff --git a/media/libstagefright/foundation/MediaBufferGroup.cpp b/media/libstagefright/foundation/MediaBufferGroup.cpp
 692 index 8e4d0641c..9fdeccbdd 100644
 693 --- a/media/libstagefright/foundation/MediaBufferGroup.cpp
 694 +++ b/media/libstagefright/foundation/MediaBufferGroup.cpp
 695 @@ -138,6 +138,12 @@ bool MediaBufferGroup::has_buffers() {
 696      return false;
 697  }
 698
 699 +extern "C" status_t _ZN7android16MediaBufferGroupC1Ev(
 700 +                    MediaBufferGroup* group, MediaBuffer **out, bool nonBlocking) {
 701 +    ALOGD("_ZN7android16MediaBufferGroupC1Ev");
 702 +    return group->acquire_buffer(out, nonBlocking, 0);
 703 +}
 704 +
 705  status_t MediaBufferGroup::acquire_buffer(
 706          MediaBuffer **out, bool nonBlocking, size_t requestedSize) {
 707      Mutex::Autolock autoLock(mLock);
 708 diff --git a/services/camera/libcameraservice/Android.mk b/services/camera/libcameraservice/Android.mk
 709 index ced1232b0..bddfb5fb2 100644
 710 --- a/services/camera/libcameraservice/Android.mk
 711 +++ b/services/camera/libcameraservice/Android.mk
 712 @@ -96,6 +96,10 @@ ifeq ($(BOARD_NEEDS_MEMORYHEAPION),true)
 713      LOCAL_CFLAGS += -DUSE_MEMORY_HEAP_ION
 714  endif
 715
 716 +ifeq ($(BOARD_HAS_MTK_HARDWARE),true)
 717 +    LOCAL_CFLAGS += -DMTK_HARDWARE
 718 +endif
 719 +
 720  LOCAL_MODULE:= libcameraservice
 721
 722  include $(BUILD_SHARED_LIBRARY)
 723 diff --git a/services/camera/libcameraservice/api1/CameraClient.cpp b/services/camera/libcameraservice/api1/CameraClient.cpp
 724 index b02d8f967..60232d8e5 100644
 725 --- a/services/camera/libcameraservice/api1/CameraClient.cpp
 726 +++ b/services/camera/libcameraservice/api1/CameraClient.cpp
 727 @@ -496,6 +496,7 @@ void CameraClient::releaseRecordingFrame(const sp<IMemory>& mem) {
 728  void CameraClient::releaseRecordingFrameHandle(native_handle_t *handle) {
 729      if (handle == nullptr) return;
 730
 731 +
 732      sp<IMemory> dataPtr;
 733      {
 734          Mutex::Autolock l(mAvailableCallbackBuffersLock);
 735 @@ -750,6 +751,9 @@ void CameraClient::disableMsgType(int32_t msgType) {
 736
 737  #define CHECK_MESSAGE_INTERVAL 10 // 10ms
 738  bool CameraClient::lockIfMessageWanted(int32_t msgType) {
 739 +#ifdef MTK_HARDWARE
 740 +    return true;
 741 +#endif
 742      int sleepCount = 0;
 743      while (mMsgEnabled & msgType) {
 744          if (mLock.tryLock() == NO_ERROR) {
 745 @@ -793,6 +797,17 @@ bool CameraClient::lockIfMessageWanted(int32_t msgType) {
 746  void CameraClient::notifyCallback(int32_t msgType, int32_t ext1,
 747          int32_t ext2, void* user) {
 748      LOG2("notifyCallback(%d)", msgType);
 749 +#ifdef MTK_HARDWARE
 750 +    if (msgType == 0x40000000) { //MTK_CAMERA_MSG_EXT_NOTIFY
 751 +        if (ext1 == 0x11) { //MTK_CAMERA_MSG_EXT_NOTIFY_SHUTTER
 752 +            msgType = CAMERA_MSG_SHUTTER;
 753 +        }
 754 +        if (ext1 == 0x10) { //MTK_CAMERA_MSG_EXT_CAPTURE_DONE
 755 +            return;
 756 +        }
 757 +        LOG2("MtknotifyCallback(0x%x, 0x%x)", ext1, ext2);
 758 +    }
 759 +#endif
 760
 761      sp<CameraClient> client = static_cast<CameraClient*>(getClientFromCookie(user).get());
 762      if (client.get() == nullptr) return;
 763 @@ -823,6 +838,33 @@ void CameraClient::dataCallback(int32_t msgType,
 764          client->handleGenericNotify(CAMERA_MSG_ERROR, UNKNOWN_ERROR, 0);
 765          return;
 766      }
 767 +#ifdef MTK_HARDWARE
 768 +    if (int32_t msgType = 0x80000000) { //MTK_CAMERA_MSG_EXT_DATA
 769 +        struct DataHeader {
 770 +            uint32_t        extMsgType;
 771 +        } dataHeader;
 772 +        sp<IMemoryHeap> heap = 0;
 773 +        ssize_t         offset = 0;
 774 +        size_t          size = 0;
 775 +
 776 +        if (dataPtr.get()) {
 777 +
 778 +            heap = dataPtr->getMemory(&offset, &size);
 779 +            if  ( NULL != heap.get() && NULL != heap->base() )
 780 +                ::memcpy(&dataHeader, ((uint8_t*)heap->base()) + offset, sizeof(DataHeader));
 781 +
 782 +            if (dataHeader.extMsgType == 0x10) { //MTK_CAMERA_MSG_EXT_DATA_COMPRESSED_IMAGE
 783 +                msgType = CAMERA_MSG_COMPRESSED_IMAGE;
 784 +                sp<MemoryBase> image = new MemoryBase(heap,
 785 +                        (offset + sizeof(DataHeader) + sizeof(uint_t) * 1),
 786 +                        (size - sizeof(DataHeader) - sizeof(uint_t) * 1));
 787 +                client->handleCompressedPicture(image);
 788 +                return;
 789 +            }
 790 +        }
 791 +        LOG2("MtkDataCallback(0x%x)", dataHeader.extMsgType);
 792 +    }
 793 +#endif
 794
 795      switch (msgType & ~CAMERA_MSG_PREVIEW_METADATA) {
 796          case CAMERA_MSG_PREVIEW_FRAME:
 797 --
 798 2.15.0.windows.1
 799