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

     2 **

     3 ** Copyright (C) 2009 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.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         image.fill(0);

   275         frameIndex = nextIndex++;

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

   277             frameCount = nextIndex;

   278         return true;

   279     }

   280     return false;

   281 }

   282 

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

   284 {

   285     mng_reset(hMNG);

   286     if (mng_create(hMNG) != MNG_NOERROR)

   287 	return false;

   288 

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

   290     int w = image.width();

   291     int h = image.height();

   292 

   293     if (

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

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

   296     // termination_action, action_after_iterations, delay, iteration_max

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

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

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

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

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

   302          (mng_putchunk_iend(hMNG) == MNG_NOERROR) &&

   303          (mng_putchunk_mend(hMNG) == MNG_NOERROR) &&

   304          (mng_write(hMNG) == MNG_NOERROR)

   305         )

   306         return true;

   307     return false;

   308 }

   309 

   310 int QMngHandlerPrivate::currentImageNumber() const

   311 {

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

   313     return frameIndex;

   314 }

   315 

   316 int QMngHandlerPrivate::imageCount() const

   317 {

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

   319     if (haveReadAll)

   320         return frameCount;

   321     return 0; // Don't know

   322 }

   323 

   324 bool QMngHandlerPrivate::jumpToImage(int imageNumber)

   325 {

   326     if (imageNumber == nextIndex)

   327         return true;

   328 

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

   330         // Loop!

   331         nextIndex = 0;

   332         return true;

   333     }

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

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

   336             nextIndex = imageNumber;

   337             return true;

   338         }

   339     }

   340     return false;

   341 }

   342 

   343 bool QMngHandlerPrivate::jumpToNextImage()

   344 {

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

   346 }

   347 

   348 int QMngHandlerPrivate::nextImageDelay() const

   349 {

   350     return nextDelay;

   351 }

   352 

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

   354 {

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

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

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

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

   359 }

   360 

   361 QColor QMngHandlerPrivate::backgroundColor() const

   362 {

   363     mng_uint16 iRed;

   364     mng_uint16 iBlue;

   365     mng_uint16 iGreen;

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

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

   368     return QColor();

   369 }

   370 

   371 QMngHandler::QMngHandler()

   372     : d_ptr(new QMngHandlerPrivate(this))

   373 {

   374 }

   375 

   376 QMngHandler::~QMngHandler()

   377 {

   378 }

   379 

   380 /*! \reimp */

   381 bool QMngHandler::canRead() const

   382 {

   383     Q_D(const QMngHandler);

   384     if (!d->haveReadNone)

   385 	return (!d->haveReadAll || (d->haveReadAll && (d->nextIndex < d->frameCount)));

   386 

   387     if (canRead(device())) {

   388         setFormat("mng");

   389         return true;

   390     }

   391     return false;

   392 }

   393 

   394 /*! \internal */

   395 bool QMngHandler::canRead(QIODevice *device)

   396 {

   397     if (!device) {

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

   399         return false;

   400     }

   401 

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

   403 }

   404 

   405 /*! \reimp */

   406 QByteArray QMngHandler::name() const

   407 {

   408     return "mng";    

   409 }

   410 

   411 /*! \reimp */

   412 bool QMngHandler::read(QImage *image)

   413 {

   414     Q_D(QMngHandler);

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

   416 }

   417 

   418 /*! \reimp */

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

   420 {

   421     Q_D(QMngHandler);

   422     return d->writeImage(image);

   423 }

   424 

   425 /*! \reimp */

   426 int QMngHandler::currentImageNumber() const

   427 {

   428     Q_D(const QMngHandler);

   429     return d->currentImageNumber();

   430 }

   431 

   432 /*! \reimp */

   433 int QMngHandler::imageCount() const

   434 {

   435     Q_D(const QMngHandler);

   436     return d->imageCount();

   437 }

   438 

   439 /*! \reimp */

   440 bool QMngHandler::jumpToImage(int imageNumber)

   441 {

   442     Q_D(QMngHandler);

   443     return d->jumpToImage(imageNumber);

   444 }

   445 

   446 /*! \reimp */

   447 bool QMngHandler::jumpToNextImage()

   448 {

   449     Q_D(QMngHandler);

   450     return d->jumpToNextImage();

   451 }

   452 

   453 /*! \reimp */

   454 int QMngHandler::loopCount() const

   455 {

   456     Q_D(const QMngHandler);

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

   458         return -1; // infinite loop

   459     return d->iterCount-1;

   460 }

   461 

   462 /*! \reimp */

   463 int QMngHandler::nextImageDelay() const

   464 {

   465     Q_D(const QMngHandler);

   466     return d->nextImageDelay();

   467 }

   468 

   469 /*! \reimp */

   470 QVariant QMngHandler::option(ImageOption option) const

   471 {

   472     Q_D(const QMngHandler);

   473     if (option == QImageIOHandler::Animation)

   474         return true;

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

   476         return d->backgroundColor();

   477     return QVariant();

   478 }

   479 

   480 /*! \reimp */

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

   482 {

   483     Q_D(QMngHandler);

   484     if (option == QImageIOHandler::BackgroundColor)

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

   486 }

   487 

   488 /*! \reimp */

   489 bool QMngHandler::supportsOption(ImageOption option) const

   490 {

   491     if (option == QImageIOHandler::Animation)

   492         return true;

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

   494         return true;

   495     return false;

   496 }

   497 

   498 QT_END_NAMESPACE