|
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 |