1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the plugins of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qmnghandler_p.h"

    43 

    44 #include "qimage.h"

    45 #include "qvariant.h"

    46 #include "qcolor.h"

    47 

    48 #define MNG_USE_SO

    49 #include <libmng.h>

    50 

    51 QT_BEGIN_NAMESPACE

    52 

    53 class QMngHandlerPrivate

    54 {

    55     Q_DECLARE_PUBLIC(QMngHandler)

    56     public:

    57     bool haveReadNone;

    58     bool haveReadAll;

    59     mng_handle hMNG;

    60     QImage image;

    61     int elapsed;

    62     int nextDelay;

    63     int iterCount;

    64     int frameIndex;

    65     int nextIndex;

    66     int frameCount;

    67     mng_uint32 iStyle;

    68     mng_bool readData(mng_ptr pBuf, mng_uint32 iSize, mng_uint32p pRead);

    69     mng_bool writeData(mng_ptr pBuf, mng_uint32 iSize, mng_uint32p pWritten);

    70     mng_bool processHeader(mng_uint32 iWidth, mng_uint32 iHeight);

    71     QMngHandlerPrivate(QMngHandler *q_ptr);

    72     ~QMngHandlerPrivate();

    73     bool getNextImage(QImage *result);

    74     bool writeImage(const QImage &image);

    75     int currentImageNumber() const;

    76     int imageCount() const;

    77     bool jumpToImage(int imageNumber);

    78     bool jumpToNextImage();

    79     int nextImageDelay() const;

    80     bool setBackgroundColor(const QColor &color);

    81     QColor backgroundColor() const;

    82     QMngHandler *q_ptr;

    83 };

    84 

    85 static mng_bool myerror(mng_handle /*hMNG*/,

    86     mng_int32   iErrorcode,

    87     mng_int8    /*iSeverity*/,

    88     mng_chunkid iChunkname,

    89     mng_uint32  /*iChunkseq*/,

    90     mng_int32   iExtra1,

    91     mng_int32   iExtra2,

    92     mng_pchar   zErrortext)

    93 {

    94     qWarning("MNG error %d: %s; chunk %c%c%c%c; subcode %d:%d",

    95         iErrorcode,zErrortext,

    96         (iChunkname>>24)&0xff,

    97         (iChunkname>>16)&0xff,

    98         (iChunkname>>8)&0xff,

    99         (iChunkname>>0)&0xff,

   100         iExtra1,iExtra2);

   101     return TRUE;

   102 }

   103 

   104 static mng_ptr myalloc(mng_size_t iSize)

   105 {

   106 #if defined(Q_OS_WINCE)

   107     mng_ptr ptr = malloc(iSize);

   108     memset(ptr, 0, iSize);

   109     return ptr;

   110 #else

   111     return (mng_ptr)calloc(1, iSize);

   112 #endif

   113 }

   114 

   115 static void myfree(mng_ptr pPtr, mng_size_t /*iSize*/)

   116 {

   117     free(pPtr);

   118 }

   119 

   120 static mng_bool myopenstream(mng_handle)

   121 {

   122     return MNG_TRUE;

   123 }

   124 

   125 static mng_bool myclosestream(mng_handle hMNG)

   126 {

   127     QMngHandlerPrivate *pMydata = reinterpret_cast<QMngHandlerPrivate *>(mng_get_userdata(hMNG));

   128     pMydata->haveReadAll = true;

   129     return MNG_TRUE;

   130 }

   131 

   132 static mng_bool myreaddata(mng_handle hMNG,

   133                     mng_ptr    pBuf,

   134                     mng_uint32 iSize,

   135                     mng_uint32p pRead)

   136 {

   137     QMngHandlerPrivate *pMydata = reinterpret_cast<QMngHandlerPrivate *>(mng_get_userdata(hMNG));

   138     return pMydata->readData(pBuf, iSize, pRead);

   139 }

   140 

   141 static mng_bool mywritedata(mng_handle hMNG,

   142 		     mng_ptr pBuf,

   143 		     mng_uint32 iSize,

   144 		     mng_uint32p pWritten)

   145 {

   146     QMngHandlerPrivate *pMydata = reinterpret_cast<QMngHandlerPrivate *>(mng_get_userdata(hMNG));

   147     return pMydata->writeData(pBuf, iSize, pWritten);

   148 }

   149 

   150 static mng_bool myprocessheader(mng_handle hMNG,

   151                                 mng_uint32 iWidth,

   152                                 mng_uint32 iHeight)

   153 {

   154     QMngHandlerPrivate *pMydata = reinterpret_cast<QMngHandlerPrivate *>(mng_get_userdata(hMNG));

   155     return pMydata->processHeader(iWidth, iHeight);

   156 }

   157 

   158 static mng_ptr mygetcanvasline(mng_handle hMNG,

   159 			mng_uint32 iLinenr)

   160 {

   161     QMngHandlerPrivate *pMydata = reinterpret_cast<QMngHandlerPrivate *>(mng_get_userdata(hMNG));

   162     return (mng_ptr)pMydata->image.scanLine(iLinenr);

   163 }

   164 

   165 static mng_bool myrefresh(mng_handle /*hMNG*/,

   166                           mng_uint32 /*iX*/,

   167                           mng_uint32 /*iY*/,

   168                           mng_uint32 /*iWidth*/,

   169                           mng_uint32 /*iHeight*/)

   170 {

   171     return MNG_TRUE;

   172 }

   173 

   174 static mng_uint32 mygettickcount(mng_handle hMNG)

   175 {

   176     QMngHandlerPrivate *pMydata = reinterpret_cast<QMngHandlerPrivate *>(mng_get_userdata(hMNG));

   177     return pMydata->elapsed++;

   178 }

   179 

   180 static mng_bool mysettimer(mng_handle hMNG,

   181 		    mng_uint32 iMsecs)

   182 {

   183     QMngHandlerPrivate *pMydata = reinterpret_cast<QMngHandlerPrivate *>(mng_get_userdata(hMNG));

   184     pMydata->elapsed += iMsecs;

   185     pMydata->nextDelay = iMsecs;

   186     return MNG_TRUE;

   187 }

   188 

   189 static mng_bool myprocessterm(mng_handle hMNG,

   190                         mng_uint8   iTermaction,

   191                         mng_uint8   /*iIteraction*/,

   192                         mng_uint32  /*iDelay*/,

   193                         mng_uint32  iItermax)

   194 {

   195     QMngHandlerPrivate *pMydata = reinterpret_cast<QMngHandlerPrivate *>(mng_get_userdata(hMNG));

   196     if (iTermaction == 3)

   197         pMydata->iterCount = iItermax;

   198     return MNG_TRUE;

   199 }

   200 

   201 static mng_bool mytrace(mng_handle,

   202                         mng_int32   iFuncnr,

   203                         mng_int32   iFuncseq,

   204                         mng_pchar   zFuncname)

   205 {

   206     qDebug("mng trace: iFuncnr: %d iFuncseq: %d zFuncname: %s", iFuncnr, iFuncseq, zFuncname);

   207     return MNG_TRUE;

   208 }

   209 

   210 QMngHandlerPrivate::QMngHandlerPrivate(QMngHandler *q_ptr)

   211     : haveReadNone(true), haveReadAll(false), elapsed(0), nextDelay(0), iterCount(1),

   212       frameIndex(-1), nextIndex(0), frameCount(0), q_ptr(q_ptr)

   213 {

   214     iStyle = (QSysInfo::ByteOrder == QSysInfo::LittleEndian) ? MNG_CANVAS_BGRA8 : MNG_CANVAS_ARGB8;

   215     // Initialize libmng

   216     hMNG = mng_initialize((mng_ptr)this, myalloc, myfree, mytrace);

   217     if (hMNG) {

   218 	// Set callback functions

   219         mng_setcb_errorproc(hMNG, myerror);

   220         mng_setcb_openstream(hMNG, myopenstream);

   221         mng_setcb_closestream(hMNG, myclosestream);

   222         mng_setcb_readdata(hMNG, myreaddata);

   223         mng_setcb_writedata(hMNG, mywritedata);

   224         mng_setcb_processheader(hMNG, myprocessheader);

   225         mng_setcb_getcanvasline(hMNG, mygetcanvasline);

   226         mng_setcb_refresh(hMNG, myrefresh);

   227         mng_setcb_gettickcount(hMNG, mygettickcount);

   228         mng_setcb_settimer(hMNG, mysettimer);

   229         mng_setcb_processterm(hMNG, myprocessterm);

   230         mng_set_doprogressive(hMNG, MNG_FALSE);

   231 	mng_set_suspensionmode(hMNG, MNG_TRUE);

   232     }

   233 }

   234 

   235 QMngHandlerPrivate::~QMngHandlerPrivate()

   236 {

   237     mng_cleanup(&hMNG);

   238 }

   239 

   240 mng_bool QMngHandlerPrivate::readData(mng_ptr pBuf, mng_uint32 iSize, mng_uint32p pRead)

   241 {

   242     Q_Q(QMngHandler);

   243     *pRead = q->device()->read((char *)pBuf, iSize);

   244     return (*pRead > 0) ? MNG_TRUE : MNG_FALSE;

   245 }

   246 

   247 mng_bool QMngHandlerPrivate::writeData(mng_ptr pBuf, mng_uint32 iSize, mng_uint32p pWritten)

   248 {

   249     Q_Q(QMngHandler);

   250     *pWritten = q->device()->write((char *)pBuf, iSize);

   251     return MNG_TRUE;

   252 }

   253 

   254 mng_bool QMngHandlerPrivate::processHeader(mng_uint32 iWidth, mng_uint32 iHeight)

   255 {

   256     if (mng_set_canvasstyle(hMNG, iStyle) != MNG_NOERROR)

   257         return MNG_FALSE;

   258     image = QImage(iWidth, iHeight, QImage::Format_ARGB32);

   259     image.fill(0);

   260     return MNG_TRUE;

   261 }

   262 

   263 bool QMngHandlerPrivate::getNextImage(QImage *result)

   264 {

   265     mng_retcode ret;

   266     if (haveReadNone) {

   267         haveReadNone = false;

   268         ret = mng_readdisplay(hMNG);

   269     } else {

   270         ret = mng_display_resume(hMNG);

   271     }

   272     if ((MNG_NOERROR == ret) || (MNG_NEEDTIMERWAIT == ret)) {

   273         *result = image;

   274         frameIndex = nextIndex++;

   275         if (haveReadAll && (frameCount == 0))

   276             frameCount = nextIndex;

   277         return true;

   278     }

   279     return false;

   280 }

   281 

   282 bool QMngHandlerPrivate::writeImage(const QImage &image)

   283 {

   284     mng_reset(hMNG);

   285     if (mng_create(hMNG) != MNG_NOERROR)

   286 	return false;

   287 

   288     this->image = image.convertToFormat(QImage::Format_ARGB32);

   289     int w = image.width();

   290     int h = image.height();

   291 

   292     if (

   293     // width, height, ticks, layercount, framecount, playtime, simplicity

   294          (mng_putchunk_mhdr(hMNG, w, h, 1000, 0, 0, 0, 7) == MNG_NOERROR) &&

   295     // termination_action, action_after_iterations, delay, iteration_max

   296          (mng_putchunk_term(hMNG, 3, 0, 1, 0x7FFFFFFF) == MNG_NOERROR) &&

   297     // width, height, bitdepth, colortype, compression, filter, interlace

   298          (mng_putchunk_ihdr(hMNG, w, h, 8, 6, 0, 0, 0) == MNG_NOERROR) &&

   299     // width, height, colortype, bitdepth, compression, filter, interlace, canvasstyle, getcanvasline

   300          (mng_putimgdata_ihdr(hMNG, w, h, 6, 8, 0, 0, 0, iStyle, mygetcanvasline) == MNG_NOERROR) &&

   301          (mng_putchunk_iend(hMNG) == MNG_NOERROR) &&

   302          (mng_putchunk_mend(hMNG) == MNG_NOERROR) &&

   303          (mng_write(hMNG) == MNG_NOERROR)

   304         )

   305         return true;

   306     return false;

   307 }

   308 

   309 int QMngHandlerPrivate::currentImageNumber() const

   310 {

   311 //    return mng_get_currentframe(hMNG) % imageCount(); not implemented, apparently

   312     return frameIndex;

   313 }

   314 

   315 int QMngHandlerPrivate::imageCount() const

   316 {

   317 //    return mng_get_totalframes(hMNG); not implemented, apparently

   318     if (haveReadAll)

   319         return frameCount;

   320     return 0; // Don't know

   321 }

   322 

   323 bool QMngHandlerPrivate::jumpToImage(int imageNumber)

   324 {

   325     if (imageNumber == nextIndex)

   326         return true;

   327 

   328     if ((imageNumber == 0) && haveReadAll && (nextIndex == frameCount)) {

   329         // Loop!

   330         nextIndex = 0;

   331         return true;

   332     }

   333     if (mng_display_freeze(hMNG) == MNG_NOERROR) {

   334         if (mng_display_goframe(hMNG, imageNumber) == MNG_NOERROR) {

   335             nextIndex = imageNumber;

   336             return true;

   337         }

   338     }

   339     return false;

   340 }

   341 

   342 bool QMngHandlerPrivate::jumpToNextImage()

   343 {

   344     return jumpToImage((currentImageNumber()+1) % imageCount());

   345 }

   346 

   347 int QMngHandlerPrivate::nextImageDelay() const

   348 {

   349     return nextDelay;

   350 }

   351 

   352 bool QMngHandlerPrivate::setBackgroundColor(const QColor &color)

   353 {

   354     mng_uint16 iRed = (mng_uint16)(color.red() << 8);

   355     mng_uint16 iBlue = (mng_uint16)(color.blue() << 8);

   356     mng_uint16 iGreen = (mng_uint16)(color.green() << 8);

   357     return (mng_set_bgcolor(hMNG, iRed, iBlue, iGreen) == MNG_NOERROR);

   358 }

   359 

   360 QColor QMngHandlerPrivate::backgroundColor() const

   361 {

   362     mng_uint16 iRed;

   363     mng_uint16 iBlue;

   364     mng_uint16 iGreen;

   365     if (mng_get_bgcolor(hMNG, &iRed, &iBlue, &iGreen) == MNG_NOERROR)

   366         return QColor((iRed >> 8) & 0xFF, (iGreen >> 8) & 0xFF, (iBlue >> 8) & 0xFF);

   367     return QColor();

   368 }

   369 

   370 QMngHandler::QMngHandler()

   371     : d_ptr(new QMngHandlerPrivate(this))

   372 {

   373 }

   374 

   375 QMngHandler::~QMngHandler()

   376 {

   377 }

   378 

   379 /*! \reimp */

   380 bool QMngHandler::canRead() const

   381 {

   382     Q_D(const QMngHandler);

   383     if ((!d->haveReadNone

   384          && (!d->haveReadAll || (d->haveReadAll && (d->nextIndex < d->frameCount))))

   385         || canRead(device()))

   386     {

   387         setFormat("mng");

   388         return true;

   389     }

   390     return false;

   391 }

   392 

   393 /*! \internal */

   394 bool QMngHandler::canRead(QIODevice *device)

   395 {

   396     if (!device) {

   397         qWarning("QMngHandler::canRead() called with no device");

   398         return false;

   399     }

   400 

   401     return device->peek(8) == "\x8A\x4D\x4E\x47\x0D\x0A\x1A\x0A";

   402 }

   403 

   404 /*! \reimp */

   405 QByteArray QMngHandler::name() const

   406 {

   407     return "mng";    

   408 }

   409 

   410 /*! \reimp */

   411 bool QMngHandler::read(QImage *image)

   412 {

   413     Q_D(QMngHandler);

   414     return canRead() ? d->getNextImage(image) : false;

   415 }

   416 

   417 /*! \reimp */

   418 bool QMngHandler::write(const QImage &image)

   419 {

   420     Q_D(QMngHandler);

   421     return d->writeImage(image);

   422 }

   423 

   424 /*! \reimp */

   425 int QMngHandler::currentImageNumber() const

   426 {

   427     Q_D(const QMngHandler);

   428     return d->currentImageNumber();

   429 }

   430 

   431 /*! \reimp */

   432 int QMngHandler::imageCount() const

   433 {

   434     Q_D(const QMngHandler);

   435     return d->imageCount();

   436 }

   437 

   438 /*! \reimp */

   439 bool QMngHandler::jumpToImage(int imageNumber)

   440 {

   441     Q_D(QMngHandler);

   442     return d->jumpToImage(imageNumber);

   443 }

   444 

   445 /*! \reimp */

   446 bool QMngHandler::jumpToNextImage()

   447 {

   448     Q_D(QMngHandler);

   449     return d->jumpToNextImage();

   450 }

   451 

   452 /*! \reimp */

   453 int QMngHandler::loopCount() const

   454 {

   455     Q_D(const QMngHandler);

   456     if (d->iterCount == 0x7FFFFFFF)

   457         return -1; // infinite loop

   458     return d->iterCount-1;

   459 }

   460 

   461 /*! \reimp */

   462 int QMngHandler::nextImageDelay() const

   463 {

   464     Q_D(const QMngHandler);

   465     return d->nextImageDelay();

   466 }

   467 

   468 /*! \reimp */

   469 QVariant QMngHandler::option(ImageOption option) const

   470 {

   471     Q_D(const QMngHandler);

   472     if (option == QImageIOHandler::Animation)

   473         return true;

   474     else if (option == QImageIOHandler::BackgroundColor)

   475         return d->backgroundColor();

   476     return QVariant();

   477 }

   478 

   479 /*! \reimp */

   480 void QMngHandler::setOption(ImageOption option, const QVariant & value)

   481 {

   482     Q_D(QMngHandler);

   483     if (option == QImageIOHandler::BackgroundColor)

   484         d->setBackgroundColor(qVariantValue<QColor>(value));

   485 }

   486 

   487 /*! \reimp */

   488 bool QMngHandler::supportsOption(ImageOption option) const

   489 {

   490     if (option == QImageIOHandler::Animation)

   491         return true;

   492     else if (option == QImageIOHandler::BackgroundColor)

   493         return true;

   494     return false;

   495 }

   496 

   497 QT_END_NAMESPACE