src/FMedia_ImageImpl.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_ImageImpl.cpp
  20  * @brief  This file contains the implementation of subsystem's Image.
  21  */
  22
  23 #include <unique_ptr.h>
  24 #include <FIoFile.h>
  25 #include <FMediaImage.h>
  26 #include <FMediaImageUtil.h>
  27 #include <FMediaIImageEventListener.h>
  28 #include <FBaseSysLog.h>
  29 #include "FMedia_MediaUtil.h"
  30 #include "FMedia_ImageImpl.h"
  31 #include "FMedia_ImageUtilImpl.h"
  32 #include "FMedia_ImageDecoder.h"
  33 #include "FMedia_ImageEncoder.h"
  34 #include "FMedia_ImageUriDataFactory.h"
  35
  36 using namespace Tizen::Graphics;
  37 using namespace Tizen::Base;
  38 using namespace Tizen::Io;
  39
  40 namespace Tizen { namespace Media
  41 {
  42
  43 static const float _SCALE_DOWN_RATIO = 0.5;
  44 static const int _RGB565_PIXEL_DEPTH = 2;
  45 static const int _MIN_ENCODE_QUALITY = 20; // Changed from 50 to 20 to allow greater compression.
  46 static const int _MAX_ENCODE_QUALITY = 99;
  47 static const int _DEFAULT_ENCODE_QUALITY = 50;
  48 static const int _MAX_ENCODE_LOOP = 2;
  49 static const int _MAX_ENCODE_RESIZE_LOOP = 2;
  50 //static const int MAX_IMGFILE_SIZE = 4096000;
  51
  52 _ImageImpl::_ImageImpl(void)
  53 {
  54 }
  55
  56 _ImageImpl::~_ImageImpl(void)
  57 {
  58 }
  59
  60 _ImageImpl*
  61 _ImageImpl::GetInstance(Image* pImage)
  62 {
  63         if (pImage != null)
  64         {
  65                 return pImage->__pImageImpl;
  66         }
  67
  68         return null;
  69 }
  70
  71 const _ImageImpl*
  72 _ImageImpl::GetInstance(const Image* pImage)
  73 {
  74         if (pImage != null)
  75         {
  76                 return pImage->__pImageImpl;
  77         }
  78
  79         return null;
  80 }
  81
  82 result
  83 _ImageImpl::Construct(void)
  84 {
  85         return E_SUCCESS;
  86 }
  87
  88 Bitmap*
  89 _ImageImpl::DecodeToBitmapN(const String& srcImgPath, BitmapPixelFormat pixelFormat,
  90                                                         const Tizen::Graphics::Dimension &dstDim,
  91                                                         Tizen::Graphics::BufferScaling bufferScaling,
  92                                                         ImageFormat imgFormat, bool keepAspectRatio)
  93 {
  94         std::unique_ptr<ByteBuffer> pBuf;
  95         Bitmap* pBmp = null;
  96
  97         pBuf.reset(_MediaUtil::FileToBufferN(srcImgPath));
  98         SysTryReturn(NID_MEDIA, pBuf.get() != null, null, GetLastResult(),
  99                            "[%s] FileToBufferN %S", GetErrorMessage(GetLastResult()), srcImgPath.GetPointer());
 100
 101         pBmp = DecodeToBitmapN(*pBuf.get(), pixelFormat, dstDim, bufferScaling, imgFormat, keepAspectRatio);
 102         return pBmp;
 103 }
 104
 105 Tizen::Graphics::Bitmap*
 106 _ImageImpl::DecodeToBitmapN(const Tizen::Base::ByteBuffer& srcImageBuf,
 107                                                         Tizen::Graphics::BitmapPixelFormat pixelFormat,
 108                                                         const Tizen::Graphics::Dimension &dstDim,
 109                                                         Tizen::Graphics::BufferScaling bufferScaling,
 110                                                         ImageFormat imgFormat, bool keepAspectRatio)
 111 {
 112         result r = E_SUCCESS;
 113         std::unique_ptr<ByteBuffer> pBuf;
 114         std::unique_ptr<Bitmap> pBmp;
 115         Dimension outDim;
 116
 117         //SysTryCatch(NID_MEDIA, IS_VALID_BITMAP_PIXEL(pixelFormat), , E_INVALID_ARG,
 118         //                 "[E_INVALID_ARG] pixelFormat:%d", pixelFormat);
 119         //SysTryCatch(NID_MEDIA, IS_VALID_DIMENSION(dstDim), , E_OUT_OF_RANGE,
 120         //                 "[E_OUT_OF_RANGE] dest dimension:%d,%d", dstDim.width, dstDim.height);
 121
 122         pBuf.reset(DecodeToBufferN(srcImageBuf, outDim, dstDim, pixelFormat, imgFormat, keepAspectRatio));
 123         SysTryReturn(NID_MEDIA, pBuf.get() != null, null, GetLastResult(),
 124                            "[%s] Propagated", GetErrorMessage(GetLastResult()));
 125
 126         pBmp.reset(new (std::nothrow) Bitmap);
 127         SysTryReturn(NID_MEDIA, pBmp != null, null, E_OUT_OF_MEMORY,
 128                            "[%s] new Bitmap", GetErrorMessage(GetLastResult()));
 129         r = pBmp->Construct(*pBuf.get(), outDim, pixelFormat, bufferScaling);
 130         SysTryReturn(NID_MEDIA, r == E_SUCCESS, null, r, "[%s] Propagated. ", GetErrorMessage(r));
 131
 132         SetLastResult(E_SUCCESS);
 133         return pBmp.release();
 134 }
 135
 136 Tizen::Base::ByteBuffer*
 137 _ImageImpl::DecodeToBufferN(const Tizen::Base::String& srcImagePath,
 138                                                         Tizen::Graphics::Dimension &restDim,
 139                                                         const Tizen::Graphics::Dimension &dstDim,
 140                                                         Tizen::Graphics::BitmapPixelFormat pixelFormat,
 141                                                         ImageFormat imgFormat, bool keepAspectRatio)
 142 {
 143         std::unique_ptr<ByteBuffer> pBuf;
 144         ByteBuffer* pRetBuf = null;
 145
 146         //SysTryCatch(NID_MEDIA, IS_VALID_DIMENSION(dstDim), , E_OUT_OF_RANGE,
 147         //"[E_OUT_OF_RANGE] dest dimension:%d,%d", dstDim.width, dstDim.height);
 148
 149         pBuf.reset(_MediaUtil::FileToBufferN(srcImagePath));
 150         SysTryReturn(NID_MEDIA, pBuf.get() != null, null, GetLastResult(),
 151                            "[%s] FileToBufferN %S", GetErrorMessage(GetLastResult()), srcImagePath.GetPointer());
 152
 153         pRetBuf = DecodeToBufferN(*pBuf.get(), restDim, dstDim, pixelFormat, imgFormat, keepAspectRatio);
 154         return pRetBuf;
 155 }
 156
 157 Tizen::Base::ByteBuffer*
 158 _ImageImpl::DecodeToBufferN(const Tizen::Base::ByteBuffer &srcImageBuf,
 159                                                         Tizen::Graphics::Dimension &retDim,
 160                                                         const Tizen::Graphics::Dimension &dstDim,
 161                                                         Tizen::Graphics::BitmapPixelFormat pixelFormat,
 162                                                         ImageFormat imgFormat, bool keepAspectRatio)
 163 {
 164         result r = E_SUCCESS;
 165         std::unique_ptr<ByteBuffer> pBuf;
 166         _ImageDecoder dec;
 167
 168         //SysTryCatch(NID_MEDIA, IS_VALID_BITMAP_PIXEL(pixelFormat), , E_INVALID_ARG,
 169         //"[E_INVALID_ARG] pixelFormat:%d", pixelFormat);
 170
 171         r = dec.Construct(srcImageBuf, _ImageUtilImpl::ToMediaPixelFormat(pixelFormat), imgFormat);
 172         SysTryReturn(NID_MEDIA, r == E_SUCCESS, null, r, "[%s] Decoder construct failed.", GetErrorMessage(r));
 173
 174         // Reset decoder output demension
 175         dec.SetOutputDimension(dstDim.width, dstDim.height, keepAspectRatio);
 176
 177         pBuf.reset(dec.DecodeN());
 178         r = GetLastResult();
 179         SysTryReturn(NID_MEDIA, r == E_SUCCESS, null, r, "[%s] Propagated. ", GetErrorMessage(r));
 180
 181         r = dec.GetDimension(retDim.width, retDim.height);
 182         SysTryReturn(NID_MEDIA, r == E_SUCCESS, null, r, "[%s] Propagated. ", GetErrorMessage(r));
 183
 184         SetLastResult(E_SUCCESS);
 185         return pBuf.release();
 186 }
 187
 188 Tizen::Base::ByteBuffer*
 189 _ImageImpl::DecodeToBufferN(const Tizen::Base::String& srcImagePath,
 190                                                         Tizen::Graphics::BitmapPixelFormat pixelFormat,
 191                                                         int& imageWidth, int& imageHeight, bool keepAspectRatio)
 192 {
 193         ByteBuffer *pBuf = null;
 194         Dimension dim;
 195
 196         pBuf = DecodeToBufferN(srcImagePath, dim, Dimension(0, 0), pixelFormat, IMG_FORMAT_NONE, keepAspectRatio);
 197         imageWidth = dim.width;
 198         imageHeight = dim.height;
 199         return pBuf;
 200 }
 201
 202
 203 Tizen::Base::ByteBuffer*
 204 _ImageImpl::DecodeN(const Tizen::Base::String& srcImagePath,
 205                                         Tizen::Graphics::BitmapPixelFormat pixelFormat,
 206                                         int destWidth, int destHeight, bool keepAspectRatio)
 207 {
 208         Dimension dim;
 209
 210         return DecodeToBufferN(srcImagePath, dim, Dimension(destWidth, destHeight), pixelFormat, IMG_FORMAT_NONE, keepAspectRatio);
 211 }
 212
 213 result
 214 _ImageImpl::DecodeUrl(const Tizen::Base::Utility::Uri& srcImageUrl,
 215                                           Tizen::Graphics::BitmapPixelFormat colorFormat,
 216                                           int destWidth, int destHeight, RequestId& reqId,
 217                                           const IImageDecodeUrlEventListener& listener, long timeout)
 218 {
 219         result r = E_SUCCESS;
 220
 221         _ImageUriDataFactory *pFactory = null;
 222
 223         SysTryCatch(NID_MEDIA, (colorFormat > Tizen::Graphics::BITMAP_PIXEL_FORMAT_MIN)
 224         && colorFormat < Tizen::Graphics::BITMAP_PIXEL_FORMAT_MAX, , E_INVALID_ARG,
 225         "[E_INVALID_ARG] Wrong color format.");
 226
 227         SysTryCatch(NID_MEDIA, destWidth > 0 && destHeight > 0, , E_OUT_OF_RANGE,
 228         "[E_OUT_OF_RANGE] The designated width and height SHOUL be greater than 0.");
 229
 230         SysTryCatch(NID_MEDIA, timeout == _TIMEOUT_INFINITE || timeout > 0 ,
 231         r = E_OUT_OF_RANGE, E_OUT_OF_RANGE,
 232         "[E_OUT_OF_RANGE] The designated timeout SHOUL be greater than 0");
 233
 234         pFactory = _ImageUriDataFactory::GetInstance();
 235         SysTryCatch(NID_MEDIA, pFactory != null, r = GetLastResult(), r,
 236         "[%s] Failed to GetInstance().", GetErrorMessage(r));
 237
 238         r = pFactory->DecodeUrl(srcImageUrl, colorFormat, destWidth,destHeight, reqId, listener, timeout);
 239         SysTryCatch(NID_MEDIA, r == E_SUCCESS , , r,"[%s] Propagated.", GetErrorMessage(r));
 240
 241         return r;
 242
 243 CATCH:
 244         return r;
 245 }
 246
 247 ByteBuffer*
 248 _ImageImpl::EncodeToBufferN(const Bitmap& srcBmp, ImageFormat dstFormat)
 249 {
 250         std::unique_ptr<ByteBuffer> pBuf;
 251         BufferInfo bmpInfo;
 252         Dimension dim;
 253
 254         // ClearLastResult();
 255
 256         Tizen::Graphics::Bitmap& tmpBmp = const_cast<Tizen::Graphics::Bitmap&>(srcBmp);
 257
 258         // Create src buf
 259         tmpBmp.Lock(bmpInfo);
 260
 261         dim.SetSize(bmpInfo.width, bmpInfo.height);
 262
 263         // TODO: handle case that pitch != width * bpp/8
 264         SysTryReturn(NID_MEDIA, bmpInfo.pitch == bmpInfo.width*bmpInfo.bitsPerPixel/8, null, E_SYSTEM,
 265                            "[E_SYSTEM] pitch=%d bpp=%d", bmpInfo.pitch, bmpInfo.bitsPerPixel);
 266
 267         pBuf.reset(_ImageEncoder::EncodeN(dstFormat, (const byte*)bmpInfo.pPixels, bmpInfo.pitch * bmpInfo.height,
 268                                                            dim.width, dim.height,
 269                                                            _ImageUtilImpl::ToMediaPixelFormat(srcBmp.GetPixelColorFormat()),
 270                                                            _DEFAULT_ENCODE_QUALITY));
 271         SysTryReturn(NID_MEDIA, pBuf.get() != null, null, GetLastResult(), "[%s] Propagated. ", GetErrorMessage(GetLastResult()));
 272
 273         return pBuf.release();
 274 }
 275
 276 result
 277 _ImageImpl::EncodeToFile(const Bitmap& srcBmp, ImageFormat dstFormat,
 278                                                  const String& dstPath, bool overwrite)
 279 {
 280         result r = E_SUCCESS;
 281         std::unique_ptr<ByteBuffer> pBuf;
 282
 283         pBuf.reset(EncodeToBufferN(srcBmp, dstFormat));
 284         SysTryReturn(NID_MEDIA, pBuf.get() != null, GetLastResult(), GetLastResult(),
 285                            "[%s] Propagated.", GetErrorMessage(GetLastResult()));
 286
 287         r = _MediaUtil::BufferToFile(*pBuf.get(), dstPath, overwrite);
 288         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagated. ", GetErrorMessage(r));
 289
 290         SetLastResult(r);
 291         return r;
 292 }
 293
 294 Tizen::Base::ByteBuffer*
 295 _ImageImpl::CompressJpegN(const Tizen::Base::ByteBuffer& srcImageBuf, int limitSize)
 296 {
 297         result r = E_SUCCESS;
 298         std::unique_ptr<ByteBuffer> pDecBuf;
 299         std::unique_ptr<ByteBuffer> pEncBuf;
 300         Dimension srcDim;
 301         _ImageDecoder dec;
 302         volatile int limit = limitSize;
 303         MediaPixelFormat pixelFormat = MEDIA_PIXEL_FORMAT_BGRA8888;
 304
 305         // TODO : use yuv pixel format
 306
 307         r = dec.Construct(srcImageBuf, pixelFormat);
 308         SysTryReturn(NID_MEDIA, r == E_SUCCESS, null, r, "[%s] Decoder construct failed.", GetErrorMessage(r));
 309
 310         pDecBuf.reset(dec.DecodeN());
 311         r = GetLastResult();
 312         SysTryReturn(NID_MEDIA, r == E_SUCCESS, null, r, "[%s] Propagated. ", GetErrorMessage(r));
 313         SysTryReturn(NID_MEDIA, pDecBuf.get() != null, null, E_SYSTEM, "[E_SYSTEM] Propagated.");
 314
 315         r = dec.GetDimension(srcDim.width, srcDim.height);
 316         SysTryReturn(NID_MEDIA, r == E_SUCCESS, null, r, "[%s] Propagated. ", GetErrorMessage(r));
 317
 318         for (int i = 0; i < _MAX_ENCODE_RESIZE_LOOP; i++)
 319         {
 320                 Dimension dstDim;
 321                 ByteBuffer *pTmpBuf = null;
 322
 323                 pEncBuf.reset(EncodeToBufferLimitN(*pDecBuf.get(), srcDim, pixelFormat, IMG_FORMAT_JPG, limit));
 324
 325                 if (pEncBuf.get() != null)
 326                 {
 327                         break;
 328                 }
 329
 330                 // halve and make even number
 331                 dstDim.width = srcDim.width >> 2;
 332                 dstDim.height = srcDim.height >> 2;
 333
 334                 dstDim.width = dstDim.width << 1;
 335                 dstDim.height = dstDim.height << 1;
 336
 337                 SysTryReturn(NID_MEDIA, srcDim != dstDim && dstDim.width > 0 && dstDim.height > 0, null, E_SYSTEM,
 338                                    "[E_SYSTEM] Resize failed:src:%dx%d dst:%dx%d, %d %d, %d",
 339                                    srcDim.width, srcDim.height, dstDim.width, dstDim.height, i, _SCALE_DOWN_RATIO,
 340                                    limit);
 341
 342                 pTmpBuf = _ImageUtilImpl::ResizeN(*pDecBuf.get(), srcDim, pixelFormat, dstDim);
 343                 SysTryReturn(NID_MEDIA, pTmpBuf != null, null, GetLastResult(),
 344                                    "[%s] ResizeN: %dx%d->%dx%d", GetErrorMessage(GetLastResult()),
 345                                    srcDim.width, srcDim.height, dstDim.width, dstDim.height);
 346
 347                 srcDim = dstDim;
 348                 pDecBuf.reset(pTmpBuf);
 349         }
 350         SysTryReturn(NID_MEDIA, pEncBuf.get() != null, null, E_SYSTEM, "[E_SYSTEM] Compress failed");
 351         SetLastResult(E_SUCCESS);
 352         return pEncBuf.release();
 353 }
 354
 355 result
 356 _ImageImpl::CompressJpeg(const Tizen::Base::String& srcImagePath,
 357                                                  const Tizen::Base::String& dstImagePath, int limitSize)
 358 {
 359         File file;
 360         result r = E_SUCCESS;
 361         std::unique_ptr<ByteBuffer> pSrcBuf;
 362         std::unique_ptr<ByteBuffer> pEncBuf;
 363
 364         pSrcBuf.reset(_MediaUtil::FileToBufferN(srcImagePath));
 365         SysTryReturn(NID_MEDIA, pSrcBuf.get() != null, GetLastResult(), GetLastResult(),
 366                            "[%s] Propagated. ", GetErrorMessage(GetLastResult()));
 367
 368 //      SysTryCatch(NID_MEDIA, pSrcBuf->GetCapacity() < MAX_IMGFILE_SIZE, r = E_OVERFLOW, E_OVERFLOW,
 369 //                         "[E_OUT_OF_RANGE] Input file size is smaller than limitSize.");
 370
 371         SysTryReturn(NID_MEDIA, pSrcBuf.get()->GetCapacity() > limitSize, E_OUT_OF_RANGE, E_OUT_OF_RANGE,
 372                            "[E_OUT_OF_RANGE] Input file size is smaller than limitSize.");
 373
 374         pEncBuf.reset(CompressJpegN(*pSrcBuf, limitSize));
 375         SysTryReturn(NID_MEDIA, pEncBuf != null, GetLastResult(), GetLastResult(),
 376                            "[%s] Propagated. ", GetErrorMessage(GetLastResult()));
 377
 378         if (File::IsFileExist(dstImagePath))
 379         {
 380                 File::Remove(dstImagePath);
 381         }
 382
 383         r = file.Construct(dstImagePath, "wb", true);
 384         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagated. ", GetErrorMessage(r));
 385         r = file.Write(*pEncBuf);
 386         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagated. ", GetErrorMessage(r));
 387
 388         return r;
 389 }
 390
 391 Tizen::Base::ByteBuffer*
 392 _ImageImpl::ConvertToBufferN(const Tizen::Base::String& srcImagePath, ImageFormat destImageFormat)
 393 {
 394         std::unique_ptr<Bitmap> pBmp;
 395         ByteBuffer* pBuf = null;
 396
 397         pBmp.reset(DecodeToBitmapN(srcImagePath, BITMAP_PIXEL_FORMAT_ARGB8888, Dimension(0, 0),
 398                                                    BUFFER_SCALING_NONE));
 399         SysTryReturn(NID_MEDIA, pBmp.get(), null, GetLastResult(),
 400                            "[%s] Propagated. ", GetErrorMessage(GetLastResult()));
 401
 402         pBuf = EncodeToBufferN(*pBmp.get(), destImageFormat);
 403         SysTryReturn(NID_MEDIA, pBuf != null, null, GetLastResult(),
 404                            "[%s] Propagated.", GetErrorMessage(GetLastResult()));
 405
 406         SetLastResult(E_SUCCESS);
 407         return pBuf;
 408 }
 409
 410 Tizen::Base::ByteBuffer*
 411 _ImageImpl::EncodeToBufferLimitN(const Tizen::Base::ByteBuffer &srcBuf,
 412                                                                  const Tizen::Graphics::Dimension& dim,
 413                                                                  MediaPixelFormat pixelFormat, ImageFormat imgFormat, int limit)
 414 {
 415         int minQuality = _MIN_ENCODE_QUALITY;
 416         int maxQuality = _MAX_ENCODE_QUALITY;
 417         int curQuality = 0;
 418         int minDiff = 0;
 419         int maxDiff = 0;
 420
 421         std::unique_ptr<ByteBuffer> pMaxBuf;
 422         std::unique_ptr<ByteBuffer> pMinBuf;
 423
 424         pMaxBuf.reset(EncodeToBufferQualityN(srcBuf, dim, pixelFormat, imgFormat, maxQuality));
 425         SysTryReturn(NID_MEDIA, pMaxBuf.get() != null, pMinBuf.get(), E_SYSTEM, "[E_SYSTEM] maxBuf is null");
 426         maxDiff = pMaxBuf->GetLimit() - limit;
 427         SysLog(NID_MEDIA, "maxDiff:%d buf:%d limit:%d q:%d",
 428                                 maxDiff, pMaxBuf->GetLimit(), limit, maxQuality);
 429         if (maxDiff <= 0)
 430         {
 431                 SetLastResult(E_SUCCESS);
 432                 return pMaxBuf.release();
 433         }
 434         pMinBuf.reset(EncodeToBufferQualityN(srcBuf, dim, pixelFormat, imgFormat, minQuality));
 435         SysTryReturn(NID_MEDIA, pMinBuf.get() != null, pMinBuf.release(), E_SYSTEM, "[E_SYSTEM] minBuf is null");
 436         minDiff = pMinBuf->GetLimit() - limit;
 437         SysLog(NID_MEDIA, "minDiff:%d buf:%d limit:%d q:%d",
 438                                         minDiff, pMinBuf->GetLimit(), limit, minQuality);
 439         if (minDiff > 0)
 440         {
 441                 SetLastResult(E_OVERFLOW);
 442                 return null;
 443         }
 444         if (minDiff == 0)
 445         {
 446                 SetLastResult(E_SUCCESS);
 447                 return pMinBuf.release();
 448         }
 449
 450         for (int i = 0; i < _MAX_ENCODE_LOOP; i++)
 451         {
 452                 int prevQuality = curQuality;
 453                 int curDiff = 0;
 454                 ByteBuffer *pCurBuf = null;
 455
 456                 curQuality = (minQuality + maxQuality) / 2;
 457                 if (prevQuality == curQuality)
 458                 {
 459                         break;
 460                 }
 461                 pCurBuf = EncodeToBufferQualityN(srcBuf, dim, pixelFormat, imgFormat, curQuality);
 462                 if (pCurBuf == null && pMinBuf.get() != null)
 463                 {
 464                         break;
 465                 }
 466                 SysTryReturn(NID_MEDIA, pCurBuf != null, pMinBuf.release(), E_SYSTEM,
 467                                    "[E_SYSTEM] curBuf is null : %d %d %d", dim.width, dim.height, curQuality);
 468                 curDiff = pCurBuf->GetLimit() - limit;
 469                 SysLog(NID_MEDIA, "curDiff:%d buf:%d limit:%d q:%d",
 470                                         curDiff, pCurBuf->GetLimit(), limit, curQuality);
 471                 if (curDiff == 0)
 472                 {
 473                         SetLastResult(E_SUCCESS);
 474                         return pCurBuf;
 475                 }
 476                 else if (curDiff > 0)
 477                 {
 478                         maxDiff = curDiff;
 479                         maxQuality = curQuality;
 480                         pMaxBuf.reset(pCurBuf);
 481                 }
 482                 else if (curDiff < 0)
 483                 {
 484                         pMinBuf.reset(pCurBuf);
 485                         minDiff = curDiff;
 486                         minQuality = curQuality;
 487                 }
 488         }
 489         if (pMinBuf.get())
 490         {
 491                 SetLastResult(E_SUCCESS);
 492         }
 493         else
 494         {
 495                 // should not come here.
 496                 SetLastResult(E_SYSTEM);
 497         }
 498         return pMinBuf.release();
 499 }
 500
 501 Tizen::Base::ByteBuffer*
 502 _ImageImpl::EncodeToBufferQualityN(const Tizen::Base::ByteBuffer &srcBuf,
 503                                                                    const Tizen::Graphics::Dimension& dim,
 504                                                                    MediaPixelFormat pixelFormat, ImageFormat imgFormat, int quality)
 505 {
 506         ByteBuffer* pBuf = null;
 507
 508         pBuf = _ImageEncoder::EncodeN(imgFormat, srcBuf.GetPointer(), srcBuf.GetLimit(),
 509                                                            dim.width, dim.height, pixelFormat, quality);
 510         SysTryReturn(NID_MEDIA, pBuf != null, pBuf, GetLastResult(),
 511                 "[%s] enc.EncodeN. ", GetErrorMessage(GetLastResult()));
 512
 513         return pBuf;
 514 }
 515
 516 result
 517 _ImageImpl::GetImageInfo(const Tizen::Base::String& path, ImageFormat &imgFormat,
 518                                                  Tizen::Graphics::Dimension &dim)
 519 {
 520         return _ImageDecoder::GetImageInfo(path, imgFormat, dim.width, dim.height);
 521 }
 522
 523 }} // Tizen::Media