src/FMedia_CameraUtil.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file                        FMedia_CamcorderUtil.cpp
  20  * @brief                       This file contains the utility of camera.
  21  *
  22  */
  23
  24 #include <FBaseSysLog.h>
  25 #include "FMedia_CameraUtil.h"
  26 #include "FMedia_Ffmpeg.h"
  27
  28 using namespace Tizen::Graphics;
  29
  30 namespace Tizen { namespace Media
  31 {
  32
  33 typedef struct
  34 {
  35         camera_pixel_format_e mmFormat;
  36         MediaPixelFormat mediaFormat;
  37         Tizen::Graphics::PixelFormat grpFormat;
  38         double sizeRatio;
  39 }_PixelConvertTable;
  40
  41 const static _PixelConvertTable _PIXEL_CONVERT[] =
  42 {
  43         { ::CAMERA_PIXEL_FORMAT_NV12, MEDIA_PIXEL_FORMAT_NV12, PIXEL_FORMAT_NV12, 1.5 },
  44         { ::CAMERA_PIXEL_FORMAT_I420, MEDIA_PIXEL_FORMAT_YUV420P, PIXEL_FORMAT_YCbCr420_PLANAR, 1.5 },
  45         { ::CAMERA_PIXEL_FORMAT_YUYV, MEDIA_PIXEL_FORMAT_YUYV422, (Tizen::Graphics::PixelFormat)-1, 2.0 },
  46         { ::CAMERA_PIXEL_FORMAT_UYVY, MEDIA_PIXEL_FORMAT_UYVY422, PIXEL_FORMAT_UYVY, 2.0 },
  47         { ::CAMERA_PIXEL_FORMAT_RGB565, MEDIA_PIXEL_FORMAT_RGB565LE, PIXEL_FORMAT_RGB565, 2.0 },
  48         { ::CAMERA_PIXEL_FORMAT_RGBA, MEDIA_PIXEL_FORMAT_RGBA8888, PIXEL_FORMAT_R8G8B8A8, 4.0 },
  49         { ::CAMERA_PIXEL_FORMAT_ARGB, MEDIA_PIXEL_FORMAT_BGRA8888, PIXEL_FORMAT_ARGB8888, 4.0 },
  50         { ::CAMERA_PIXEL_FORMAT_JPEG, MEDIA_PIXEL_FORMAT_NONE , PIXEL_FORMAT_JPEG, 0.0},                //MediaPixelFormat does not express the compressed type.
  51 };
  52
  53 void
  54 _CameraUtil::GetOspMediaPixelFormat(camera_pixel_format_e mmFormat, MediaPixelFormat& mediaFormat, double& sizeRatio)
  55 {
  56         for (unsigned int i = 0; i < sizeof(_PIXEL_CONVERT)/sizeof(_PIXEL_CONVERT[0]); i++ )
  57         {
  58                 if ( mmFormat == _PIXEL_CONVERT[i].mmFormat )
  59                 {
  60                         mediaFormat = _PIXEL_CONVERT[i].mediaFormat;
  61                         sizeRatio = _PIXEL_CONVERT[i].sizeRatio;
  62                         break;
  63                 }
  64         }
  65 }
  66
  67 void
  68 _CameraUtil::GetOspMediaPixelFormat(Tizen::Graphics::PixelFormat grpFormat, MediaPixelFormat& mediaFormat, double& sizeRatio)
  69 {
  70         for (unsigned int i = 0; i < sizeof(_PIXEL_CONVERT)/sizeof(_PIXEL_CONVERT[0]); i++ )
  71         {
  72                 if ( grpFormat == _PIXEL_CONVERT[i].grpFormat )
  73                 {
  74                         mediaFormat = _PIXEL_CONVERT[i].mediaFormat;
  75                         sizeRatio = _PIXEL_CONVERT[i].sizeRatio;
  76                         break;
  77                 }
  78         }
  79 }
  80
  81 result
  82 _CameraUtil::_CameraUtil::GetOspGrpPixelFormat(camera_pixel_format_e mmFormat, Tizen::Graphics::PixelFormat& grpFormat)
  83 {
  84         bool findFlag = false;
  85         int size = sizeof(_PIXEL_CONVERT)/sizeof(_PIXEL_CONVERT[0]);
  86
  87         for (int i = 0; i < size; i++)
  88         {
  89                 if ((_PIXEL_CONVERT[i].mmFormat == mmFormat) &&
  90                         ((_PIXEL_CONVERT[i].grpFormat >= PIXEL_FORMAT_RGB565) && (_PIXEL_CONVERT[i].grpFormat <= PIXEL_FORMAT_UYVY)))
  91                 {
  92                         grpFormat = _PIXEL_CONVERT[i].grpFormat;
  93                         findFlag = true;
  94                         break;
  95                 }
  96         }
  97         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
  98 }
  99
 100 result
 101 _CameraUtil::_CameraUtil::GetMmPixelFormat(Tizen::Graphics::PixelFormat grpFormat, camera_pixel_format_e& mmFormat)
 102 {
 103         bool findFlag = false;
 104         int size = sizeof(_PIXEL_CONVERT)/sizeof(_PIXEL_CONVERT[0]);
 105
 106         for (int i = 0; i < size; i++)
 107         {
 108                 if (_PIXEL_CONVERT[i].grpFormat == grpFormat)
 109                 {
 110                         mmFormat = _PIXEL_CONVERT[i].mmFormat;
 111                         findFlag = true;
 112                         break;
 113                 }
 114         }
 115         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 116 }
 117
 118 typedef struct
 119 {
 120         camera_pixel_format_e mmAttr;
 121         CodecType value;
 122 }_CodecConvertTable;
 123
 124 const static _CodecConvertTable _CODEC_CONVERT[] =
 125 {
 126         { ::CAMERA_PIXEL_FORMAT_JPEG, CODEC_JPEG },
 127 };
 128
 129 result
 130 _CameraUtil::GetOspCodecType(camera_pixel_format_e mmAttr, CodecType value)
 131 {
 132         bool findFlag = false;
 133         int size = sizeof(_CODEC_CONVERT)/sizeof(_CODEC_CONVERT[0]);
 134
 135         for (int i = 0; i < size; i++)
 136         {
 137                 if (_CODEC_CONVERT[i].mmAttr == mmAttr)
 138                 {
 139                         value = _CODEC_CONVERT[i].value;
 140                         findFlag = true;
 141                         break;
 142                 }
 143         }
 144         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 145 }
 146
 147 typedef struct
 148 {
 149         CameraSelection selection;
 150         camera_flip_e mmAttr;
 151         CameraFlipType value;
 152 }_CameraFlipTable;
 153
 154 static const _CameraFlipTable _CAMERA_FLIP[] =
 155 {
 156         {CAMERA_PRIMARY, ::CAMERA_FLIP_NONE, CAMERA_FLIP_NONE},
 157         {CAMERA_PRIMARY, ::CAMERA_FLIP_HORIZONTAL, CAMERA_FLIP_HORIZONTAL},
 158         {CAMERA_PRIMARY, ::CAMERA_FLIP_VERTICAL, CAMERA_FLIP_VERTICAL},
 159 //      {CAMERA_PRIMARY, ::CAMERA_FLIP_BOTH, },
 160         {CAMERA_SECONDARY, ::CAMERA_FLIP_NONE, CAMERA_FLIP_NONE},
 161         {CAMERA_SECONDARY, ::CAMERA_FLIP_HORIZONTAL, CAMERA_FLIP_HORIZONTAL},
 162         {CAMERA_SECONDARY, ::CAMERA_FLIP_VERTICAL, CAMERA_FLIP_VERTICAL},
 163 //      {CAMERA_SECONDARY, ::CAMERA_FLIP_BOTH, },
 164 };
 165
 166 result
 167 _CameraUtil::GetMmFlip(CameraSelection selection, CameraFlipType value, camera_flip_e& mmAttr)
 168 {
 169         bool findFlag = false;
 170         int size = sizeof(_CAMERA_FLIP)/sizeof(_CAMERA_FLIP[0]);
 171
 172         for (int i = 0; i < size; i++)
 173         {
 174                 if (_CAMERA_FLIP[i].selection == selection && _CAMERA_FLIP[i].value == value)
 175                 {
 176                         mmAttr = _CAMERA_FLIP[i].mmAttr;
 177                         findFlag = true;
 178                         break;
 179                 }
 180         }
 181         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 182 }
 183
 184 result
 185 _CameraUtil::GetOspFlip(camera_flip_e mmAttr, CameraFlipType& value)
 186 {
 187         bool findFlag = false;
 188         int size = sizeof(_CAMERA_FLIP)/sizeof(_CAMERA_FLIP[0]);
 189
 190         for (int i = 0; i < size; i++)
 191         {
 192                 if (_CAMERA_FLIP[i].mmAttr == mmAttr)
 193                 {
 194                         value = _CAMERA_FLIP[i].value;
 195                         findFlag = true;
 196                         break;
 197                 }
 198         }
 199         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 200 }
 201
 202 typedef struct
 203 {
 204         camera_rotation_e mmAttr;
 205         CameraRotation value;
 206 }_CameraRotationTable;
 207
 208 static const _CameraRotationTable _CAMERA_ROTATION[] =
 209 {
 210         {::CAMERA_ROTATION_NONE, CAMERA_ROTATION_NONE},
 211         {::CAMERA_ROTATION_90, CAMERA_ROTATION_90},
 212         {::CAMERA_ROTATION_180, CAMERA_ROTATION_180},
 213         {::CAMERA_ROTATION_270, CAMERA_ROTATION_270},
 214 };
 215
 216 result
 217 _CameraUtil::GetMmRotation(CameraRotation value, camera_rotation_e& mmAttr)
 218 {
 219         bool findFlag = false;
 220         int size = sizeof(_CAMERA_ROTATION)/sizeof(_CAMERA_ROTATION[0]);
 221
 222         for (int i = 0; i < size; i++)
 223         {
 224                 if (_CAMERA_ROTATION[i].value == value)
 225                 {
 226                         mmAttr = _CAMERA_ROTATION[i].mmAttr;
 227                         findFlag = true;
 228                         break;
 229                 }
 230         }
 231         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 232 }
 233
 234 result
 235 _CameraUtil::GetOspRotation(camera_rotation_e mmAttr, CameraRotation& value)
 236 {
 237         bool findFlag = false;
 238         int size = sizeof(_CAMERA_ROTATION)/sizeof(_CAMERA_ROTATION[0]);
 239
 240         for (int i = 0; i < size; i++)
 241         {
 242                 if (_CAMERA_ROTATION[i].mmAttr == mmAttr)
 243                 {
 244                         value = _CAMERA_ROTATION[i].value;
 245                         findFlag = true;
 246                         break;
 247                 }
 248         }
 249         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 250 }
 251
 252 typedef struct
 253 {
 254         camera_attr_fps_e mmAttr;
 255         int value;
 256 }_CameraFpsTable;
 257
 258 static const _CameraFpsTable _CAMERA_FPS[] =
 259 {
 260         {::CAMERA_ATTR_FPS_8, 8},
 261         {::CAMERA_ATTR_FPS_15, 15},
 262         {::CAMERA_ATTR_FPS_24, 24},
 263         {::CAMERA_ATTR_FPS_25, 25},
 264         {::CAMERA_ATTR_FPS_30, 30},
 265 // This means that below fps are not supported in osp.
 266 //      {::CAMERA_ATTR_FPS_AUTO, 0xffffffff},
 267 //      {::CAMERA_ATTR_FPS_60, 60},
 268 //      {::CAMERA_ATTR_FPS_120, 120},
 269 };
 270
 271 result
 272 _CameraUtil::GetMmFps(int value, camera_attr_fps_e& mmAttr)
 273 {
 274         bool findFlag = false;
 275         int size = sizeof(_CAMERA_FPS)/sizeof(_CAMERA_FPS[0]);
 276
 277         for (int i = 0; i < size; i++)
 278         {
 279                 if (_CAMERA_FPS[i].value == value)
 280                 {
 281                         mmAttr = _CAMERA_FPS[i].mmAttr;
 282                         findFlag = true;
 283                         break;
 284                 }
 285         }
 286         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 287 }
 288
 289 result
 290 _CameraUtil::GetOspFps(camera_attr_fps_e mmAttr, int& value)
 291 {
 292         bool findFlag = false;
 293         int size = sizeof(_CAMERA_FPS)/sizeof(_CAMERA_FPS[0]);
 294
 295         for (int i = 0; i < size; i++)
 296         {
 297                 if (_CAMERA_FPS[i].mmAttr == mmAttr)
 298                 {
 299                         value = _CAMERA_FPS[i].value;
 300                         findFlag = true;
 301                         break;
 302                 }
 303         }
 304         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 305 }
 306
 307 typedef struct
 308 {
 309         camera_attr_effect_mode_e mmAttr;
 310         CameraEffect value;
 311 }_CameraEffectTable;
 312
 313 static const _CameraEffectTable _CAMERA_EFFECT[] =
 314 {
 315 //      {::CAMERA_ATTR_EFFECT_NONE, CAMERA_EFFECT_COLOR},
 316         {::CAMERA_ATTR_EFFECT_NONE, CAMERA_EFFECT_NONE},
 317         {::CAMERA_ATTR_EFFECT_MONO, CAMERA_EFFECT_BW},
 318         {::CAMERA_ATTR_EFFECT_SEPIA, CAMERA_EFFECT_SEPIA},
 319         {::CAMERA_ATTR_EFFECT_NEGATIVE, CAMERA_EFFECT_NEGATIVE},
 320 //      {::CAMERA_ATTR_EFFECT_BLUE, },
 321 //      {::CAMERA_ATTR_EFFECT_GREEN, },
 322 //      {::CAMERA_ATTR_EFFECT_AQUA, },
 323 //      {::CAMERA_ATTR_EFFECT_VIOLET, },
 324 //      {::CAMERA_ATTR_EFFECT_ORANGE, },
 325 //      {::CAMERA_ATTR_EFFECT_GRAY, CAMERA_EFFECT_BW},
 326 //      {::CAMERA_ATTR_EFFECT_RED, },
 327 //      {::CAMERA_ATTR_EFFECT_ANTIQUE, },
 328 //      {::CAMERA_ATTR_EFFECT_WARM, },
 329 //      {::CAMERA_ATTR_EFFECT_PINK, },
 330 //      {::CAMERA_ATTR_EFFECT_YELLOW, },
 331 //      {::CAMERA_ATTR_EFFECT_PURPLE, },
 332 //      {::CAMERA_ATTR_EFFECT_EMBOSS, },
 333 //      {::CAMERA_ATTR_EFFECT_OUTLINE, },
 334         {::CAMERA_ATTR_EFFECT_SOLARIZATION, CAMERA_EFFECT_SOLARIZE},
 335 //      {::CAMERA_ATTR_EFFECT_SKETCH, },
 336 //      {, CAMERA_EFFECT_NIGHT},
 337 };
 338
 339 result
 340 _CameraUtil::GetMmEffect(CameraEffect value, camera_attr_effect_mode_e& mmAttr)
 341 {
 342         bool findFlag = false;
 343         int size = sizeof(_CAMERA_EFFECT)/sizeof(_CAMERA_EFFECT[0]);
 344
 345         for (int i = 0; i < size; i++)
 346         {
 347                 if (_CAMERA_EFFECT[i].value == value)
 348                 {
 349                         mmAttr = _CAMERA_EFFECT[i].mmAttr;
 350                         findFlag = true;
 351                         break;
 352                 }
 353         }
 354         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 355 }
 356
 357 result
 358 _CameraUtil::GetOspEffect(camera_attr_effect_mode_e mmAttr, CameraEffect& value)
 359 {
 360         bool findFlag = false;
 361         int size = sizeof(_CAMERA_EFFECT)/sizeof(_CAMERA_EFFECT[0]);
 362
 363         for (int i = 0; i < size; i++)
 364         {
 365                 if (_CAMERA_EFFECT[i].mmAttr == mmAttr)
 366                 {
 367                         value = _CAMERA_EFFECT[i].value;
 368                         findFlag = true;
 369                         break;
 370                 }
 371         }
 372         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 373 }
 374
 375 typedef struct
 376 {
 377         camera_attr_whitebalance_e mmAttr;
 378         CameraWhiteBalance value;
 379 }_CameraWbTable;
 380
 381 static const _CameraWbTable _CAMERA_WB[] =
 382 {
 383 //      {::CAMERA_ATTR_WHITE_BALANCE_NONE, },
 384         {::CAMERA_ATTR_WHITE_BALANCE_AUTOMATIC, CAMERA_WHITE_BALANCE_AUTO},
 385         {::CAMERA_ATTR_WHITE_BALANCE_DAYLIGHT, CAMERA_WHITE_BALANCE_SUNNY},
 386         {::CAMERA_ATTR_WHITE_BALANCE_CLOUDY, CAMERA_WHITE_BALANCE_CLOUDY},
 387         {::CAMERA_ATTR_WHITE_BALANCE_FLUORESCENT, CAMERA_WHITE_BALANCE_FLUORESCENT},
 388         {::CAMERA_ATTR_WHITE_BALANCE_INCANDESCENT, CAMERA_WHITE_BALANCE_TUNGSTEN},
 389 //      {::CAMERA_ATTR_WHITE_BALANCE_SHADE, },
 390 //      {::CAMERA_ATTR_WHITE_BALANCE_HORIZON, },
 391 //      {::CAMERA_ATTR_WHITE_BALANCE_FLASH, },
 392 //      {::CAMERA_ATTR_WHITE_BALANCE_CUSTOM, },
 393 };
 394
 395 result
 396 _CameraUtil::GetMmWhiteBalance(CameraWhiteBalance value, camera_attr_whitebalance_e& mmAttr)
 397 {
 398         bool findFlag = false;
 399         int size = sizeof(_CAMERA_WB)/sizeof(_CAMERA_WB[0]);
 400
 401         for (int i = 0; i < size; i++)
 402         {
 403                 if (_CAMERA_WB[i].value == value)
 404                 {
 405                         mmAttr = _CAMERA_WB[i].mmAttr;
 406                         findFlag = true;
 407                         break;
 408                 }
 409         }
 410         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 411 }
 412
 413 result
 414 _CameraUtil::GetOspWhiteBalance(camera_attr_whitebalance_e mmAttr, CameraWhiteBalance& value)
 415 {
 416         bool findFlag = false;
 417         int size = sizeof(_CAMERA_WB)/sizeof(_CAMERA_WB[0]);
 418
 419         for (int i = 0; i < size; i++)
 420         {
 421                 if (_CAMERA_WB[i].mmAttr == mmAttr)
 422                 {
 423                         value = _CAMERA_WB[i].value;
 424                         findFlag = true;
 425                         break;
 426                 }
 427         }
 428         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 429 }
 430
 431 typedef struct
 432 {
 433         camera_attr_scene_mode_e mmAttr;
 434         CameraSceneMode value;
 435 }_CameraSceneTable;
 436
 437 static const _CameraSceneTable _CAMERA_SCENE_MODE[] =
 438 {
 439         {::CAMERA_ATTR_SCENE_MODE_NORMAL, CAMERA_SCENE_OFF},
 440 //      {::, CAMERA_SCENE_AUTO},
 441         {::CAMERA_ATTR_SCENE_MODE_PORTRAIT, CAMERA_SCENE_PORTRAIT},
 442         {::CAMERA_ATTR_SCENE_MODE_LANDSCAPE, CAMERA_SCENE_LANDSCAPE},
 443         {::CAMERA_ATTR_SCENE_MODE_SPORTS, CAMERA_SCENE_SPORTS},
 444         {::CAMERA_ATTR_SCENE_MODE_PARTY_N_INDOOR, CAMERA_SCENE_PARTY_INDOOR},
 445         {::CAMERA_ATTR_SCENE_MODE_BEACH_N_INDOOR, CAMERA_SCENE_BEACH_SHOW},
 446         {::CAMERA_ATTR_SCENE_MODE_SUNSET, CAMERA_SCENE_SUNSET},
 447         {::CAMERA_ATTR_SCENE_MODE_DUSK_N_DAWN, CAMERA_SCENE_DUSK_DAWN},
 448         {::CAMERA_ATTR_SCENE_MODE_FALL_COLOR, CAMERA_SCENE_AUTUMN_COLOR},
 449         {::CAMERA_ATTR_SCENE_MODE_NIGHT_SCENE, CAMERA_SCENE_NIGHT},
 450         {::CAMERA_ATTR_SCENE_MODE_FIREWORK, CAMERA_SCENE_FIREWORK},
 451         {::CAMERA_ATTR_SCENE_MODE_TEXT, CAMERA_SCENE_TEXT},
 452         {::CAMERA_ATTR_SCENE_MODE_SHOW_WINDOW, CAMERA_SCENE_SHOW_WINDOW},
 453         {::CAMERA_ATTR_SCENE_MODE_CANDLE_LIGHT, CAMERA_SCENE_CANDLELIGHT},
 454         {::CAMERA_ATTR_SCENE_MODE_BACKLIGHT, CAMERA_SCENE_BACKLIGHT},
 455 };
 456
 457 result
 458 _CameraUtil::GetMmSceneMode(CameraSceneMode value, camera_attr_scene_mode_e& mmAttr)
 459 {
 460         bool findFlag = false;
 461         int size = sizeof(_CAMERA_SCENE_MODE)/sizeof(_CAMERA_SCENE_MODE[0]);
 462
 463         for (int i = 0; i < size; i++)
 464         {
 465                 if (_CAMERA_SCENE_MODE[i].value == value)
 466                 {
 467                         mmAttr = _CAMERA_SCENE_MODE[i].mmAttr;
 468                         findFlag = true;
 469                         break;
 470                 }
 471         }
 472         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 473 }
 474
 475 result
 476 _CameraUtil::GetOspSceneMode(camera_attr_scene_mode_e mmAttr, CameraSceneMode& value)
 477 {
 478         bool findFlag = false;
 479         int size = sizeof(_CAMERA_SCENE_MODE)/sizeof(_CAMERA_SCENE_MODE[0]);
 480
 481         for (int i = 0; i < size; i++)
 482         {
 483                 if (_CAMERA_SCENE_MODE[i].mmAttr == mmAttr)
 484                 {
 485                         value = _CAMERA_SCENE_MODE[i].value;
 486                         findFlag = true;
 487                         break;
 488                 }
 489         }
 490         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 491 }
 492
 493 typedef struct
 494 {
 495         camera_attr_af_mode_e mmAttr;
 496         CameraFocusMode value;
 497         bool additionalMode;
 498         CameraFocusMode additionalValue;
 499 }_CameraFocusModeTable;
 500
 501 static const _CameraFocusModeTable _CAMERA_FOCUS_MODE[] =
 502 {
 503 //      {::CAMERA_ATTR_AF_NONE, CAMERA_FOCUS_MODE_NONE, false, CAMERA_FOCUS_MODE_NONE},
 504         {::CAMERA_ATTR_AF_NORMAL, CAMERA_FOCUS_MODE_NORMAL, true, CAMERA_FOCUS_MODE_CONTINUOUS_AUTO},
 505         {::CAMERA_ATTR_AF_MACRO, CAMERA_FOCUS_MODE_MACRO, false, CAMERA_FOCUS_MODE_NONE},
 506 //      {::CAMERA_ATTR_INFINITE, CAMERA_FOCUS_MODE_INFINITE, false, },
 507 };
 508
 509 result
 510 _CameraUtil::GetMmFocusMode(CameraFocusMode value, camera_attr_af_mode_e& mmAttr)
 511 {
 512         bool findFlag = false;
 513         int size = sizeof(_CAMERA_FOCUS_MODE)/sizeof(_CAMERA_FOCUS_MODE[0]);
 514
 515         for (int i = 0; i < size; i++)
 516         {
 517                 if (_CAMERA_FOCUS_MODE[i].value == value
 518                         || (_CAMERA_FOCUS_MODE[i].additionalValue != CAMERA_FOCUS_MODE_NONE && _CAMERA_FOCUS_MODE[i].additionalValue == value))
 519                 {
 520                         mmAttr = _CAMERA_FOCUS_MODE[i].mmAttr;
 521                         findFlag = true;
 522                         break;
 523                 }
 524         }
 525         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 526 }
 527
 528 result
 529 _CameraUtil::GetOspFocusMode(camera_attr_af_mode_e mmAttr, CameraFocusMode& value)
 530 {
 531         bool findFlag = false;
 532         int size = sizeof(_CAMERA_FOCUS_MODE)/sizeof(_CAMERA_FOCUS_MODE[0]);
 533
 534         for (int i = 0; i < size; i++)
 535         {
 536                 if (_CAMERA_FOCUS_MODE[i].mmAttr == mmAttr)
 537                 {
 538                         value = _CAMERA_FOCUS_MODE[i].value;
 539                         findFlag = true;
 540                         break;
 541                 }
 542         }
 543         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 544 }
 545
 546 result
 547 _CameraUtil::GetOspFocusMode(camera_attr_af_mode_e mmAttr, CameraFocusMode& value, bool& additionalMode, CameraFocusMode& additionalValue)
 548 {
 549         bool findFlag = false;
 550         int size = sizeof(_CAMERA_FOCUS_MODE)/sizeof(_CAMERA_FOCUS_MODE[0]);
 551
 552         for (int i = 0; i < size; i++)
 553         {
 554                 if (_CAMERA_FOCUS_MODE[i].mmAttr == mmAttr)
 555                 {
 556                         value = _CAMERA_FOCUS_MODE[i].value;
 557
 558                         if (_CAMERA_FOCUS_MODE[i].additionalMode == true)
 559                         {
 560                                 additionalMode = true;
 561                                 additionalValue = _CAMERA_FOCUS_MODE[i].additionalValue;
 562                         }
 563
 564                         findFlag = true;
 565                         break;
 566                 }
 567         }
 568         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 569 }
 570
 571 typedef struct
 572 {
 573         camera_attr_iso_e mmAttr;
 574         CameraIsoLevel value;
 575 }_CameraIsoTable;
 576
 577 static const _CameraIsoTable _CAMERA_ISO[] =
 578 {
 579         {::CAMERA_ATTR_ISO_AUTO, CAMERA_ISO_AUTO},
 580         {::CAMERA_ATTR_ISO_50, CAMERA_ISO_50},
 581         {::CAMERA_ATTR_ISO_100, CAMERA_ISO_100},
 582         {::CAMERA_ATTR_ISO_200, CAMERA_ISO_200},
 583         {::CAMERA_ATTR_ISO_400, CAMERA_ISO_400},
 584         {::CAMERA_ATTR_ISO_800, CAMERA_ISO_800},
 585         {::CAMERA_ATTR_ISO_1600, CAMERA_ISO_1600},
 586 //      {::CAMERA_ATTR_ISO_3200, },
 587         {::CAMERA_ATTR_ISO_AUTO, CAMERA_ISO_DEFAULT},
 588         {::CAMERA_ATTR_ISO_100, CAMERA_ISO_MIN},
 589         {::CAMERA_ATTR_ISO_800, CAMERA_ISO_MAX},
 590         //Todo : Max ISO of U1 target is 800. Someday,
 591         // We will implement that ISO MAX is setted to the highest thing among surpported ISO.
 592 };
 593
 594 result
 595 _CameraUtil::GetMmIso(CameraIsoLevel value, camera_attr_iso_e& mmAttr)
 596 {
 597         bool findFlag = false;
 598         int size = sizeof(_CAMERA_ISO)/sizeof(_CAMERA_ISO[0]);
 599
 600         for (int i = 0; i < size; i++)
 601         {
 602                 if (_CAMERA_ISO[i].value == value)
 603                 {
 604                         mmAttr = _CAMERA_ISO[i].mmAttr;
 605                         findFlag = true;
 606                         break;
 607                 }
 608         }
 609         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 610 }
 611
 612 result
 613 _CameraUtil::GetOspIso(camera_attr_iso_e mmAttr, CameraIsoLevel& value)
 614 {
 615         bool findFlag = false;
 616         int size = sizeof(_CAMERA_ISO)/sizeof(_CAMERA_ISO[0]);
 617
 618         for (int i = 0; i < size; i++)
 619         {
 620                 if (_CAMERA_ISO[i].mmAttr == mmAttr)
 621                 {
 622                         value = _CAMERA_ISO[i].value;
 623                         findFlag = true;
 624                         break;
 625                 }
 626         }
 627         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 628 }
 629
 630 typedef struct
 631 {
 632         camera_attr_exposure_mode_e mmAttr;
 633         CameraMeteringMode value;
 634 }_CameraMeteringModeTable;
 635
 636 static const _CameraMeteringModeTable _CAMERA_METERING_MODE[] =
 637 {
 638         {::CAMERA_ATTR_EXPOSURE_MODE_OFF, CAMERA_METERING_MODE_NONE},
 639         {::CAMERA_ATTR_EXPOSURE_MODE_ALL, CAMERA_METERING_MODE_AVERAGE},
 640         {::CAMERA_ATTR_EXPOSURE_MODE_CENTER, CAMERA_METERING_MODE_CENTER_WEIGHTED},
 641         {::CAMERA_ATTR_EXPOSURE_MODE_SPOT, CAMERA_METERING_MODE_SPOT},
 642 //      {::CAMERA_ATTR_EXPOSURE_MODE_CUSTOM, CAMERA_METERING_MODE_CUSTOM},
 643 };
 644
 645 result
 646 _CameraUtil::GetMmMeteringMode(CameraMeteringMode value, camera_attr_exposure_mode_e& mmAttr)
 647 {
 648         bool findFlag = false;
 649         int size = sizeof(_CAMERA_METERING_MODE)/sizeof(_CAMERA_METERING_MODE[0]);
 650
 651         for (int i = 0; i < size; i++)
 652         {
 653                 if (_CAMERA_METERING_MODE[i].value == value)
 654                 {
 655                         mmAttr = _CAMERA_METERING_MODE[i].mmAttr;
 656                         findFlag = true;
 657                         break;
 658                 }
 659         }
 660         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 661 }
 662
 663 result
 664 _CameraUtil::GetOspMeteringMode(camera_attr_exposure_mode_e mmAttr, CameraMeteringMode& value)
 665 {
 666         bool findFlag = false;
 667         int size = sizeof(_CAMERA_METERING_MODE)/sizeof(_CAMERA_METERING_MODE[0]);
 668
 669         for (int i = 0; i < size; i++)
 670         {
 671                 if (_CAMERA_METERING_MODE[i].mmAttr == mmAttr)
 672                 {
 673                         value = _CAMERA_METERING_MODE[i].value;
 674                         findFlag = true;
 675                         break;
 676                 }
 677         }
 678         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 679 }
 680
 681 typedef struct
 682 {
 683         camera_attr_flash_mode_e mmAttr;
 684         CameraFlashMode value;
 685 }_CameraFlashModeTable;
 686
 687 static const _CameraFlashModeTable _FLASH_MODE[] =
 688 {
 689         {::CAMERA_ATTR_FLASH_MODE_OFF, CAMERA_FLASH_MODE_OFF},
 690         {::CAMERA_ATTR_FLASH_MODE_ON, CAMERA_FLASH_MODE_ON},
 691         {::CAMERA_ATTR_FLASH_MODE_AUTO, CAMERA_FLASH_MODE_AUTO},
 692         {::CAMERA_ATTR_FLASH_MODE_REDEYE_REDUCTION, CAMERA_FLASH_MODE_RED_EYE_REDUCTION},
 693 //      {::CAMERA_ATTR_FLASH_MODE_SLOW_SYNC, CAMERA_FLASH_MODE_SLOW_SYNC},
 694 //      {::CAMERA_ATTR_FLASH_MODE_FRONT_CURTAIN, CAMERA_FLASH_MODE_FRONT_CURTAIN},
 695 //      {::CAMERA_ATTR_FLASH_MODE_REAR_CURTAIN, CAMERA_FLASH_MODE_REAR_CURTAIN},
 696         {::CAMERA_ATTR_FLASH_MODE_PERMANENT, CAMERA_FLASH_MODE_CONTINUOUS},
 697 };
 698
 699 result
 700 _CameraUtil::GetMmFlashMode(CameraFlashMode value, camera_attr_flash_mode_e& mmAttr)
 701 {
 702         bool findFlag = false;
 703         int size = sizeof(_FLASH_MODE)/sizeof(_FLASH_MODE[0]);
 704
 705         for (int i = 0; i < size; i++)
 706         {
 707                 if (_FLASH_MODE[i].value == value)
 708                 {
 709                         mmAttr = _FLASH_MODE[i].mmAttr;
 710                         findFlag = true;
 711                         break;
 712                 }
 713         }
 714         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 715 }
 716
 717 result
 718 _CameraUtil::GetOspFlashMode(camera_attr_flash_mode_e mmAttr, CameraFlashMode& value)
 719 {
 720         bool findFlag = false;
 721         int size = sizeof(_FLASH_MODE)/sizeof(_FLASH_MODE[0]);
 722
 723         for (int i = 0; i < size; i++)
 724         {
 725                 if (_FLASH_MODE[i].mmAttr == mmAttr)
 726                 {
 727                         value = _FLASH_MODE[i].value;
 728                         findFlag = true;
 729                         break;
 730                 }
 731         }
 732         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 733 }
 734
 735 typedef struct
 736 {
 737         int mmAttr;
 738         CameraQuality value;
 739 }_CameraQualityTable;
 740
 741 static const _CameraQualityTable _CAMERA_QUALITY[] =
 742 {
 743         {30, CAMERA_QUALITY_NORMAL},
 744         {70, CAMERA_QUALITY_FINE},
 745         {100, CAMERA_QUALITY_SUPER_FINE},
 746 //      {, CAMERA_QUALITY_MAX},
 747 };
 748
 749 result
 750 _CameraUtil::GetMmQuality(CameraQuality value, int& mmAttr)
 751 {
 752         bool findFlag = false;
 753         int size = sizeof(_CAMERA_QUALITY)/sizeof(_CAMERA_QUALITY[0]);
 754
 755         for (int i = 0; i < size; i++)
 756         {
 757                 if (_CAMERA_QUALITY[i].value == value)
 758                 {
 759                         mmAttr = _CAMERA_QUALITY[i].mmAttr;
 760                         findFlag = true;
 761                         break;
 762                 }
 763         }
 764         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 765 }
 766
 767 result
 768 _CameraUtil::GetOspQuality(int mmAttr, CameraQuality& value)
 769 {
 770         bool findFlag = false;
 771         int size = sizeof(_CAMERA_QUALITY)/sizeof(_CAMERA_QUALITY[0]);
 772
 773         for (int i = 0; i < size; i++)
 774         {
 775                 if (_CAMERA_QUALITY[i].mmAttr == mmAttr)
 776                 {
 777                         value = _CAMERA_QUALITY[i].value;
 778                         findFlag = true;
 779                         break;
 780                 }
 781         }
 782         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 783 }
 784
 785 typedef struct
 786 {
 787         camera_attr_tag_orientation_e mmAttr;
 788         CameraExifOrientation orientation;
 789         CameraRotation rotation;
 790 }_CameraExifOrientationTable;
 791
 792 static const _CameraExifOrientationTable _CAMERA_EXIF_ORIENTATION[] =
 793 {
 794         {::CAMERA_ATTR_TAG_ORIENTATION_TOP_LEFT, CAMERA_EXIF_ORIENTATION_TOP_LEFT, CAMERA_ROTATION_NONE},
 795         {::CAMERA_ATTR_TAG_ORIENTATION_TOP_RIGHT, CAMERA_EXIF_ORIENTATION_TOP_RIGHT, (CameraRotation)-1},
 796         {::CAMERA_ATTR_TAG_ORIENTATION_BOTTOM_RIGHT, CAMERA_EXIF_ORIENTATION_BOTTOM_RIGHT, CAMERA_ROTATION_180},
 797         {::CAMERA_ATTR_TAG_ORIENTATION_BOTTOM_LEFT, CAMERA_EXIF_ORIENTATION_BOTTOM_LEFT, (CameraRotation)-1},
 798         {::CAMERA_ATTR_TAG_ORIENTATION_LEFT_TOP, CAMERA_EXIF_ORIENTATION_LEFT_TOP, (CameraRotation)-1},
 799         {::CAMERA_ATTR_TAG_ORIENTATION_RIGHT_TOP, CAMERA_EXIF_ORIENTATION_RIGHT_TOP, CAMERA_ROTATION_90},
 800         {::CAMERA_ATTR_TAG_ORIENTATION_RIGHT_BOTTOM, CAMERA_EXIF_ORIENTATION_RIGHT_BOTTOM, (CameraRotation)-1},
 801         {::CAMERA_ATTR_TAG_ORIENTATION_LEFT_BOTTOM, CAMERA_EXIF_ORIENTATION_LEFT_BOTTOM, CAMERA_ROTATION_270},
 802 };
 803
 804 result
 805 _CameraUtil::GetMmExifOrientation(CameraExifOrientation value, camera_attr_tag_orientation_e& mmAttr)
 806 {
 807         bool findFlag = false;
 808         int size = sizeof(_CAMERA_EXIF_ORIENTATION)/sizeof(_CAMERA_EXIF_ORIENTATION[0]);
 809
 810         for (int i = 0; i < size; i++)
 811         {
 812                 if (_CAMERA_EXIF_ORIENTATION[i].orientation == value)
 813                 {
 814                         mmAttr = _CAMERA_EXIF_ORIENTATION[i].mmAttr;
 815                         findFlag = true;
 816                         break;
 817                 }
 818         }
 819         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 820 }
 821
 822 result
 823 _CameraUtil::GetMmExifOrientation(CameraRotation value, camera_attr_tag_orientation_e& mmAttr)
 824 {
 825         bool findFlag = false;
 826         int size = sizeof(_CAMERA_EXIF_ORIENTATION)/sizeof(_CAMERA_EXIF_ORIENTATION[0]);
 827
 828         for (int i = 0; i < size; i++)
 829         {
 830                 if (_CAMERA_EXIF_ORIENTATION[i].rotation == value)
 831                 {
 832                         mmAttr = _CAMERA_EXIF_ORIENTATION[i].mmAttr;
 833                         findFlag = true;
 834                         break;
 835                 }
 836         }
 837         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 838 }
 839
 840 result
 841 _CameraUtil::GetOspExifOrientation(camera_attr_tag_orientation_e mmAttr, CameraExifOrientation& value)
 842 {
 843         bool findFlag = false;
 844         int size = sizeof(_CAMERA_EXIF_ORIENTATION)/sizeof(_CAMERA_EXIF_ORIENTATION[0]);
 845
 846         for (int i = 0; i < size; i++)
 847         {
 848                 if (_CAMERA_EXIF_ORIENTATION[i].mmAttr == mmAttr)
 849                 {
 850                         value = _CAMERA_EXIF_ORIENTATION[i].orientation;
 851                         findFlag = true;
 852                         break;
 853                 }
 854         }
 855         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 856 }
 857
 858 typedef struct
 859 {
 860         CameraDirection physicalDirection;
 861         _BufferInfoImpl::Orientation orientation;
 862         CameraRotation displayRotation;
 863 }_CameraNormalRotationTable;
 864
 865 // If the OverlayRegion type is NORMAL. _BufferInfoImpl::ROTATION_0
 866 static const _CameraNormalRotationTable _CAMERA_NORMAL_ROTATION[] =
 867 {
 868         // Primary camera
 869         {CAMERA_DIRECTION_BACK, _BufferInfoImpl::ORIENTATION_PORTRAIT, CAMERA_ROTATION_NONE},
 870         {CAMERA_DIRECTION_BACK, _BufferInfoImpl::ORIENTATION_LANDSCAPE_REVERSE, CAMERA_ROTATION_90},
 871         {CAMERA_DIRECTION_BACK, _BufferInfoImpl::ORIENTATION_PORTRAIT_REVERSE, CAMERA_ROTATION_180},
 872         {CAMERA_DIRECTION_BACK, _BufferInfoImpl::ORIENTATION_LANDSCAPE, CAMERA_ROTATION_270},
 873         // Secondary camera
 874         {CAMERA_DIRECTION_FRONT, _BufferInfoImpl::ORIENTATION_PORTRAIT, CAMERA_ROTATION_NONE},
 875         {CAMERA_DIRECTION_FRONT, _BufferInfoImpl::ORIENTATION_LANDSCAPE_REVERSE, CAMERA_ROTATION_90},
 876         {CAMERA_DIRECTION_FRONT, _BufferInfoImpl::ORIENTATION_PORTRAIT_REVERSE, CAMERA_ROTATION_180},
 877         {CAMERA_DIRECTION_FRONT, _BufferInfoImpl::ORIENTATION_LANDSCAPE, CAMERA_ROTATION_270},
 878 };
 879
 880 result
 881 _CameraUtil::GetDisplayRotation(CameraDirection physicalDirection, _BufferInfoImpl::Orientation orientation, CameraRotation& displayRotation)
 882 {
 883         bool findFlag = false;
 884         int size = sizeof(_CAMERA_NORMAL_ROTATION)/sizeof(_CAMERA_NORMAL_ROTATION[0]);
 885
 886         for (int i = 0; i < size; i++)
 887         {
 888                 if (_CAMERA_NORMAL_ROTATION[i].physicalDirection == physicalDirection && _CAMERA_NORMAL_ROTATION[i].orientation == orientation)
 889                 {
 890                         displayRotation = _CAMERA_NORMAL_ROTATION[i].displayRotation;
 891                         findFlag = true;
 892                         break;
 893                 }
 894         }
 895         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 896 }
 897
 898 typedef struct
 899 {
 900         CameraDirection physicalDirection;
 901         CameraRotation physicalRotation;
 902         _BufferInfoImpl::Orientation orientation;
 903         CameraRotation displayRotation;
 904 }_CameraAutoRotationTable;
 905
 906 enum
 907 {
 908         ANY_VALUE = 0xfe
 909 };
 910
 911 // In case of internal automatic rotation.   not _BufferInfoImpl::ROTATION_0
 912 static const _CameraAutoRotationTable _CAMERA_AUTO_ROTATION[] =
 913 {
 914         // Primary camera
 915         {CAMERA_DIRECTION_BACK, CAMERA_ROTATION_NONE, _BufferInfoImpl::Orientation(ANY_VALUE), CAMERA_ROTATION_NONE},
 916         {CAMERA_DIRECTION_BACK, CAMERA_ROTATION_90, _BufferInfoImpl::Orientation(ANY_VALUE), CAMERA_ROTATION_270},
 917         {CAMERA_DIRECTION_BACK, CAMERA_ROTATION_180, _BufferInfoImpl::Orientation(ANY_VALUE), CAMERA_ROTATION_180},
 918         {CAMERA_DIRECTION_BACK, CAMERA_ROTATION_270, _BufferInfoImpl::Orientation(ANY_VALUE), CAMERA_ROTATION_90},
 919         // Secondary camera
 920 #if defined (_OSP_EMUL_)
 921         {CAMERA_DIRECTION_FRONT, CAMERA_ROTATION_270, _BufferInfoImpl::ORIENTATION_PORTRAIT, CAMERA_ROTATION_90},
 922         {CAMERA_DIRECTION_FRONT, CAMERA_ROTATION_270, _BufferInfoImpl::ORIENTATION_LANDSCAPE_REVERSE, CAMERA_ROTATION_270},
 923         {CAMERA_DIRECTION_FRONT, CAMERA_ROTATION_270, _BufferInfoImpl::ORIENTATION_PORTRAIT_REVERSE, CAMERA_ROTATION_90},
 924         {CAMERA_DIRECTION_FRONT, CAMERA_ROTATION_270, _BufferInfoImpl::ORIENTATION_LANDSCAPE, CAMERA_ROTATION_270},
 925 #else
 926         {CAMERA_DIRECTION_FRONT, CAMERA_ROTATION_90, _BufferInfoImpl::ORIENTATION_PORTRAIT, CAMERA_ROTATION_270},
 927         {CAMERA_DIRECTION_FRONT, CAMERA_ROTATION_90, _BufferInfoImpl::ORIENTATION_LANDSCAPE_REVERSE, CAMERA_ROTATION_90},
 928         {CAMERA_DIRECTION_FRONT, CAMERA_ROTATION_90, _BufferInfoImpl::ORIENTATION_PORTRAIT_REVERSE, CAMERA_ROTATION_NONE},
 929         {CAMERA_DIRECTION_FRONT, CAMERA_ROTATION_90, _BufferInfoImpl::ORIENTATION_LANDSCAPE, CAMERA_ROTATION_90},
 930
 931         {CAMERA_DIRECTION_FRONT, CAMERA_ROTATION_270, _BufferInfoImpl::ORIENTATION_PORTRAIT, CAMERA_ROTATION_90},
 932         {CAMERA_DIRECTION_FRONT, CAMERA_ROTATION_270, _BufferInfoImpl::ORIENTATION_LANDSCAPE_REVERSE, CAMERA_ROTATION_270},
 933         {CAMERA_DIRECTION_FRONT, CAMERA_ROTATION_270, _BufferInfoImpl::ORIENTATION_PORTRAIT_REVERSE, CAMERA_ROTATION_180},
 934         {CAMERA_DIRECTION_FRONT, CAMERA_ROTATION_270, _BufferInfoImpl::ORIENTATION_LANDSCAPE, CAMERA_ROTATION_270},
 935 #endif
 936 };
 937
 938 result
 939 _CameraUtil::GetDisplayRotation(CameraDirection physicalDirection, CameraRotation physicalRotation, _BufferInfoImpl::Orientation orientation, CameraRotation& displayRotation)
 940 {
 941         bool findFlag = false;
 942         int size = sizeof(_CAMERA_AUTO_ROTATION)/sizeof(_CAMERA_AUTO_ROTATION[0]);
 943
 944         for (int i = 0; i < size; i++)
 945         {
 946                 if (_CAMERA_AUTO_ROTATION[i].physicalDirection == physicalDirection && _CAMERA_AUTO_ROTATION[i].physicalRotation == physicalRotation)
 947                 {
 948                         if (_CAMERA_AUTO_ROTATION[i].orientation == orientation ||
 949                                 (_CAMERA_AUTO_ROTATION[i].orientation < _BufferInfoImpl::ORIENTATION_PORTRAIT   // Any value is ok.
 950                                 || _CAMERA_AUTO_ROTATION[i].orientation > _BufferInfoImpl::ORIENTATION_LANDSCAPE_REVERSE))
 951                         {
 952                                 displayRotation = _CAMERA_AUTO_ROTATION[i].displayRotation;
 953                                 findFlag = true;
 954                                 break;
 955                         }
 956                 }
 957         }
 958         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 959 }
 960
 961 // Convert from YUYV to YUV420P only.
 962 result
 963 _CameraUtil::ConvertColorScale(const Tizen::Base::ByteBuffer& srcBuf, Tizen::Base::ByteBuffer& dstBuf, const Tizen::Graphics::Dimension& dim)
 964 {
 965         int  r = -1;
 966         int width = dim.width;
 967         int height = dim.height;
 968         uint8_t *pDestBuf = null;
 969         AVFrame picture;
 970         AVFrame frame;
 971         SwsContext *pSws = null;
 972
 973         frame.data[0] = (uint8_t *)srcBuf.GetPointer();
 974         frame.data[1] = frame.data[0] + (width * height);
 975         frame.data[2] = frame.data[1] + ((width * height)/2);
 976         frame.data[3] = 0;
 977         frame.linesize[0] = width;
 978         frame.linesize[1] = width / 2;
 979         frame.linesize[2] = width / 2;
 980         frame.linesize[3] = 0;
 981
 982         pDestBuf = (uint8_t *)dstBuf.GetPointer();
 983
 984         picture.data[0] = (uint8_t*)pDestBuf;
 985         picture.data[1] = pDestBuf + (width * height);
 986         picture.data[2] = pDestBuf + ((width * height * 5)/ 4);
 987         picture.data[3] = 0;
 988
 989         picture.linesize[0] = width;
 990         picture.linesize[1] = width / 2;
 991         picture.linesize[2] = width / 2;
 992         picture.linesize[3] = 0;
 993
 994         pSws = sws_getCachedContext(pSws, width, height, PIX_FMT_YUYV422,
 995                                 width, height, PIX_FMT_YUV420P, SWS_FAST_BILINEAR, NULL, NULL, NULL);
 996         if (pSws == null)
 997         {
 998                 SysLogException(NID_MEDIA, false, "[E_SYSTEM] A system error has been occurred.  Failed to get sws context.");
 999                 return E_SYSTEM;
1000         }
1001
1002         r = sws_scale(pSws, frame.data, frame.linesize, 0, height, picture.data, picture.linesize);
1003
1004         SysLog(NID_MEDIA, "[E_SUCCESS] Converted buffer.");
1005         return E_SUCCESS;
1006
1007 }
1008
1009 }}// Tizen::Media