source: trunk/src/gui/image/qmnghandler.cpp@ 1063

Last change on this file since 1063 was 846, checked in by Dmitry A. Kuminov, 15 years ago

trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.
File size: 13.9 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2011 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** Commercial Usage
11** Licensees holding valid Qt Commercial licenses may use this file in
12** accordance with the Qt Commercial License Agreement provided with the
13** Software or, alternatively, in accordance with the terms contained in
14** a written agreement between you and Nokia.
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** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
36** If you have questions regarding the use of this file, please contact
37** Nokia at qt-info@nokia.com.
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
51QT_BEGIN_NAMESPACE
52
53class 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
85static 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
104static 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
115static void myfree(mng_ptr pPtr, mng_size_t /*iSize*/)
116{
117 free(pPtr);
118}
119
120static mng_bool myopenstream(mng_handle)
121{
122 return MNG_TRUE;
123}
124
125static 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
132static 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
141static 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
150static 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
158static 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
165static 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
174static mng_uint32 mygettickcount(mng_handle hMNG)
175{
176 QMngHandlerPrivate *pMydata = reinterpret_cast<QMngHandlerPrivate *>(mng_get_userdata(hMNG));
177 return pMydata->elapsed++;
178}
179
180static 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
189static 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
201static 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
210QMngHandlerPrivate::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
235QMngHandlerPrivate::~QMngHandlerPrivate()
236{
237 mng_cleanup(&hMNG);
238}
239
240mng_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
247mng_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
254mng_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
263bool 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
282bool 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
309int QMngHandlerPrivate::currentImageNumber() const
310{
311// return mng_get_currentframe(hMNG) % imageCount(); not implemented, apparently
312 return frameIndex;
313}
314
315int 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
323bool 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
342bool QMngHandlerPrivate::jumpToNextImage()
343{
344 return jumpToImage((currentImageNumber()+1) % imageCount());
345}
346
347int QMngHandlerPrivate::nextImageDelay() const
348{
349 return nextDelay;
350}
351
352bool 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
360QColor 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
370QMngHandler::QMngHandler()
371 : d_ptr(new QMngHandlerPrivate(this))
372{
373}
374
375QMngHandler::~QMngHandler()
376{
377}
378
379/*! \reimp */
380bool 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 */
394bool 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 */
405QByteArray QMngHandler::name() const
406{
407 return "mng";
408}
409
410/*! \reimp */
411bool QMngHandler::read(QImage *image)
412{
413 Q_D(QMngHandler);
414 return canRead() ? d->getNextImage(image) : false;
415}
416
417/*! \reimp */
418bool QMngHandler::write(const QImage &image)
419{
420 Q_D(QMngHandler);
421 return d->writeImage(image);
422}
423
424/*! \reimp */
425int QMngHandler::currentImageNumber() const
426{
427 Q_D(const QMngHandler);
428 return d->currentImageNumber();
429}
430
431/*! \reimp */
432int QMngHandler::imageCount() const
433{
434 Q_D(const QMngHandler);
435 return d->imageCount();
436}
437
438/*! \reimp */
439bool QMngHandler::jumpToImage(int imageNumber)
440{
441 Q_D(QMngHandler);
442 return d->jumpToImage(imageNumber);
443}
444
445/*! \reimp */
446bool QMngHandler::jumpToNextImage()
447{
448 Q_D(QMngHandler);
449 return d->jumpToNextImage();
450}
451
452/*! \reimp */
453int 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 */
462int QMngHandler::nextImageDelay() const
463{
464 Q_D(const QMngHandler);
465 return d->nextImageDelay();
466}
467
468/*! \reimp */
469QVariant 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 */
480void 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 */
488bool 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
497QT_END_NAMESPACE
Note: See TracBrowser for help on using the repository browser.