atiran/porymap
3
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

Add ability to export map timelapse GIFs

Browse source
This commit is contained in:
Marcus Huderle 2021-01-18 15:13:51 -06:00
parent 2bf33a14b8
commit c354142f1b
35 changed files with 5419 additions and 54 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

47
forms/mainwindow.ui
View file

@ -831,8 +831,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>443</width>
<height>74</height>
<width>428</width>
<height>77</height>
</rect>
</property>
<layout class="QHBoxLayout" name="horizontalLayout_7">
@ -1019,10 +1019,10 @@
</property>
<property name="geometry">
<rect>
<x>8</x>
<x>0</x>
<y>0</y>
<width>431</width>
<height>341</height>
<width>411</width>
<height>449</height>
</rect>
</property>
<property name="sizePolicy">
@ -1172,8 +1172,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>434</width>
<height>643</height>
<width>428</width>
<height>704</height>
</rect>
</property>
<layout class="QGridLayout" name="gridLayout_7">
@ -1471,8 +1471,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>430</width>
<height>521</height>
<width>98</width>
<height>28</height>
</rect>
</property>
<property name="sizePolicy">
@ -1516,8 +1516,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>430</width>
<height>521</height>
<width>98</width>
<height>28</height>
</rect>
</property>
<property name="sizePolicy">
@ -1561,8 +1561,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>430</width>
<height>521</height>
<width>98</width>
<height>28</height>
</rect>
</property>
<property name="sizePolicy">
@ -1606,8 +1606,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>430</width>
<height>521</height>
<width>98</width>
<height>28</height>
</rect>
</property>
<property name="sizePolicy">
@ -1651,8 +1651,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>430</width>
<height>521</height>
<width>98</width>
<height>28</height>
</rect>
</property>
<property name="sizePolicy">
@ -1702,8 +1702,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>430</width>
<height>521</height>
<width>98</width>
<height>28</height>
</rect>
</property>
<property name="sizePolicy">
@ -2593,7 +2593,7 @@
<x>0</x>
<y>0</y>
<width>1287</width>
<height>22</height>
<height>21</height>
</rect>
</property>
<widget class="QMenu" name="menuFile">
@ -2607,6 +2607,7 @@
<addaction name="separator"/>
<addaction name="action_Export_Map_Image"/>
<addaction name="actionExport_Stitched_Map_Image"/>
<addaction name="actionExport_Map_Timelapse_Image"/>
<addaction name="separator"/>
<addaction name="action_Exit"/>
</widget>
@ -2938,6 +2939,11 @@
<string>Edit Shortcuts...</string>
</property>
</action>
<action name="actionExport_Map_Timelapse_Image">
<property name="text">
<string>Export Map Timelapse Image...</string>
</property>
</action>
</widget>
<layoutdefault spacing="6" margin="11"/>
<customwidgets>
@ -2950,6 +2956,7 @@
<class>AdjustingStackedWidget</class>
<extends>QStackedWidget</extends>
<header>adjustingstackedwidget.h</header>
<container>1</container>
</customwidget>
<customwidget>
<class>GraphicsView</class>

66
forms/mapimageexporter.ui
View file

@ -33,8 +33,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>373</width>
<height>334</height>
<width>403</width>
<height>343</height>
</rect>
</property>
<layout class="QGridLayout" name="gridLayout">
@ -262,6 +262,61 @@
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="groupBox_Timelapse">
<property name="title">
<string>Timelapse</string>
</property>
<layout class="QGridLayout" name="gridLayout_7">
<item row="2" column="1">
<widget class="QSpinBox" name="spinBox_TimelapseDelay">
<property name="specialValueText">
<string/>
</property>
<property name="suffix">
<string>ms</string>
</property>
<property name="minimum">
<number>1</number>
</property>
<property name="maximum">
<number>2000</number>
</property>
<property name="value">
<number>200</number>
</property>
</widget>
</item>
<item row="2" column="0">
<widget class="QLabel" name="label">
<property name="text">
<string>Frame Delay</string>
</property>
</widget>
</item>
<item row="3" column="1">
<widget class="QSpinBox" name="spinBox_FrameSkip">
<property name="suffix">
<string/>
</property>
<property name="minimum">
<number>1</number>
</property>
<property name="maximum">
<number>999</number>
</property>
</widget>
</item>
<item row="3" column="0">
<widget class="QLabel" name="label_3">
<property name="text">
<string>Edit Frame Skip</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<spacer name="verticalSpacer">
<property name="orientation">
@ -317,6 +372,13 @@
</item>
</layout>
</widget>
<customwidgets>
<customwidget>
<class>NoScrollComboBox</class>
<extends>QComboBox</extends>
<header>noscrollcombobox.h</header>
</customwidget>
</customwidgets>
<resources/>
<connections/>
</ui>

3
include/mainwindow.h
View file

@ -187,6 +187,7 @@ private slots:
void on_action_Export_Map_Image_triggered();
void on_actionExport_Stitched_Map_Image_triggered();
void on_actionExport_Map_Timelapse_Image_triggered();
void on_comboBox_ConnectionDirection_currentIndexChanged(const QString &arg1);
void on_spinBox_ConnectionOffset_valueChanged(int offset);
@ -323,7 +324,7 @@ private:
void connectSubEditorsToShortcutsEditor();
bool isProjectOpen();
void showExportMapImageWindow(bool stitchMode);
void showExportMapImageWindow(ImageExporterMode mode);
void redrawMetatileSelection();
QObjectList shortcutableObjects() const;

14
include/ui/mapimageexporter.h
View file

@ -10,12 +10,18 @@ namespace Ui {
class MapImageExporter;
}
enum ImageExporterMode {
Normal,
Stitch,
Timelapse,
};
class MapImageExporter : public QDialog
{
Q_OBJECT
public:
explicit MapImageExporter(QWidget *parent, Editor *editor, bool stitchMode);
explicit MapImageExporter(QWidget *parent, Editor *editor, ImageExporterMode mode);
~MapImageExporter();
private:
@ -39,7 +45,9 @@ private:
bool showGrid = false;
bool showBorder = false;
bool showCollision = false;
bool stitchMode = false;
int timelapseSkipAmount = 1;
int timelapseDelayMs = 200;
ImageExporterMode mode = ImageExporterMode::Normal;
void updatePreview();
void saveImage();
@ -65,6 +73,8 @@ private slots:
void on_pushButton_Save_pressed();
void on_pushButton_Reset_pressed();
void on_pushButton_Cancel_pressed();
void on_spinBox_TimelapseDelay_valueChanged(int delayMs);
void on_spinBox_FrameSkip_valueChanged(int skip);
};
#endif // MAPIMAGEEXPORTER_H

2
porymap.pro
View file

@ -176,3 +176,5 @@ INCLUDEPATH += include
INCLUDEPATH += include/core
INCLUDEPATH += include/ui
INCLUDEPATH += include/lib
include(src/vendor/QtGifImage/gifimage/qtgifimage.pri)

12
src/mainwindow.cpp
View file

@ -2442,20 +2442,24 @@ void MainWindow::moveEvent(QMoveEvent *event) {
}
void MainWindow::on_action_Export_Map_Image_triggered() {
showExportMapImageWindow(false);
showExportMapImageWindow(ImageExporterMode::Normal);
}
void MainWindow::on_actionExport_Stitched_Map_Image_triggered() {
showExportMapImageWindow(true);
showExportMapImageWindow(ImageExporterMode::Stitch);
}
void MainWindow::showExportMapImageWindow(bool stitchMode) {
void MainWindow::on_actionExport_Map_Timelapse_Image_triggered() {
showExportMapImageWindow(ImageExporterMode::Timelapse);
}
void MainWindow::showExportMapImageWindow(ImageExporterMode mode) {
if (!editor->project) return;
if (this->mapImageExporter)
delete this->mapImageExporter;
this->mapImageExporter = new MapImageExporter(this, this->editor, stitchMode);
this->mapImageExporter = new MapImageExporter(this, this->editor, mode);
connect(this->mapImageExporter, &QObject::destroyed, [=](QObject *) { this->mapImageExporter = nullptr; });
this->mapImageExporter->setAttribute(Qt::WA_DeleteOnClose);

144
src/ui/mapimageexporter.cpp
View file

@ -1,5 +1,6 @@
#include "mapimageexporter.h"
#include "ui_mapimageexporter.h"
#include "qgifimage.h"
#include <QFileDialog>
#include <QMatrix>
@ -9,17 +10,30 @@
#define STITCH_MODE_BORDER_DISTANCE 2
MapImageExporter::MapImageExporter(QWidget *parent_, Editor *editor_, bool stitchMode) :
QString getTitle(ImageExporterMode mode) {
switch (mode)
{
case ImageExporterMode::Normal:
return "Export Map Image";
case ImageExporterMode::Stitch:
return "Export Map Stitch Image";
case ImageExporterMode::Timelapse:
return "Export Map Timelapse Image";
}
return "";
}
MapImageExporter::MapImageExporter(QWidget *parent_, Editor *editor_, ImageExporterMode mode) :
QDialog(parent_),
ui(new Ui::MapImageExporter)
{
ui->setupUi(this);
this->map = editor_->map;
this->editor = editor_;
this->stitchMode = stitchMode;
this->setWindowTitle(this->stitchMode ? "Export Map Stitch Image" : "Export Map Image");
this->ui->groupBox_Connections->setVisible(!this->stitchMode);
this->mode = mode;
this->setWindowTitle(getTitle(this->mode));
this->ui->groupBox_Connections->setVisible(this->mode == ImageExporterMode::Normal);
this->ui->groupBox_Timelapse->setVisible(this->mode == ImageExporterMode::Timelapse);
this->ui->comboBox_MapSelection->addItems(*editor->project->mapNames);
this->ui->comboBox_MapSelection->setCurrentText(map->name);
@ -34,13 +48,33 @@ MapImageExporter::~MapImageExporter() {
}
void MapImageExporter::saveImage() {
QString title = this->stitchMode ? "Export Map Stitch Image" : "Export Map Image";
QString defaultFilename = this->stitchMode ? QString("Stitch_From_%1").arg(map->name) : map->name;
QString defaultFilepath = QString("%1/%2.png").arg(editor->project->root).arg(defaultFilename);
QString filepath = QFileDialog::getSaveFileName(this, title, defaultFilepath,
"Image Files (*.png *.jpg *.bmp)");
QString title = getTitle(this->mode);
QString defaultFilename;
switch (this->mode)
{
case ImageExporterMode::Normal:
defaultFilename = map->name;
break;
case ImageExporterMode::Stitch:
defaultFilename = QString("Stitch_From_%1").arg(map->name);
break;
case ImageExporterMode::Timelapse:
defaultFilename = QString("Timelapse_%1").arg(map->name);
break;
}
QString defaultFilepath = QString("%1/%2.%3")
.arg(editor->project->root)
.arg(defaultFilename)
.arg(this->mode == ImageExporterMode::Timelapse ? "gif" : "png");
QString filter = this->mode == ImageExporterMode::Timelapse ? "Image Files (*.gif)" : "Image Files (*.png *.jpg *.bmp)";
QString filepath = QFileDialog::getSaveFileName(this, title, defaultFilepath, filter);
if (!filepath.isEmpty()) {
if (this->stitchMode) {
switch (this->mode) {
case ImageExporterMode::Normal:
this->preview.save(filepath);
break;
case ImageExporterMode::Stitch: {
QProgressDialog progress("Building map stitch...", "Cancel", 0, 1, this);
progress.setAutoClose(true);
progress.setWindowModality(Qt::WindowModal);
@ -52,8 +86,80 @@ void MapImageExporter::saveImage() {
}
pixmap.save(filepath);
progress.close();
} else {
this->preview.save(filepath);
break;
}
case ImageExporterMode::Timelapse:
QProgressDialog progress("Building map timelapse...", "Cancel", 0, 1, this);
progress.setAutoClose(true);
progress.setWindowModality(Qt::WindowModal);
progress.setModal(true);
progress.setMaximum(1);
progress.setValue(0);
int maxWidth = this->map->getWidth() * 16;
int maxHeight = this->map->getHeight() * 16;
if (showBorder) {
maxWidth += STITCH_MODE_BORDER_DISTANCE * 16;
maxHeight += STITCH_MODE_BORDER_DISTANCE * 16;
}
// Rewind to the specified start of the map edit history.
int i = 0;
while (this->map->editHistory.canUndo()) {
progress.setValue(i);
this->map->editHistory.undo();
int width = this->map->getWidth() * 16;
int height = this->map->getHeight() * 16;
if (showBorder) {
width += STITCH_MODE_BORDER_DISTANCE * 16;
height += STITCH_MODE_BORDER_DISTANCE * 16;
}
if (width > maxWidth) {
maxWidth = width;
}
if (height > maxHeight) {
maxHeight = height;
}
i++;
}
QGifImage timelapseImg(QSize(maxWidth, maxHeight));
timelapseImg.setDefaultDelay(timelapseDelayMs);
timelapseImg.setDefaultTransparentColor(QColor(0, 0, 0));
// Draw each frame, skpping the specified number of map edits in
// the undo history.
progress.setMaximum(i);
while (i > 0) {
if (progress.wasCanceled()) {
progress.close();
while (i > 0 && this->map->editHistory.canRedo()) {
i--;
this->map->editHistory.redo();
}
return;
}
progress.setValue(progress.maximum() - i);
QPixmap pixmap = this->getFormattedMapPixmap(this->map, !this->showBorder);
if (pixmap.width() < maxWidth || pixmap.height() < maxHeight) {
QPixmap pixmap2 = QPixmap(maxWidth, maxHeight);
QPainter painter(&pixmap2);
pixmap2.fill(QColor(0, 0, 0));
painter.drawPixmap(0, 0, pixmap.width(), pixmap.height(), pixmap);
painter.end();
pixmap = pixmap2;
}
timelapseImg.addFrame(pixmap.toImage());
for (int j = 0; j < timelapseSkipAmount; j++) {
if (i > 0) {
i--;
this->map->editHistory.redo();
}
}
}
// The latest map state is the last animated frame.
QPixmap pixmap = this->getFormattedMapPixmap(this->map, !this->showBorder);
timelapseImg.addFrame(pixmap.toImage());
timelapseImg.save(filepath);
progress.close();
break;
}
this->close();
}
@ -236,7 +342,7 @@ QPixmap MapImageExporter::getFormattedMapPixmap(Map *map, bool ignoreBorder) {
int borderHeight = 0, borderWidth = 0;
bool forceDrawBorder = showUpConnections || showDownConnections || showLeftConnections || showRightConnections;
if (!ignoreBorder && (showBorder || forceDrawBorder)) {
int borderDistance = this->stitchMode ? STITCH_MODE_BORDER_DISTANCE : BORDER_DISTANCE;
int borderDistance = this->mode ? STITCH_MODE_BORDER_DISTANCE : BORDER_DISTANCE;
map->renderBorder();
int borderHorzDist = editor->getBorderDrawDistance(map->getBorderWidth());
int borderVertDist = editor->getBorderDrawDistance(map->getBorderHeight());
@ -255,7 +361,7 @@ QPixmap MapImageExporter::getFormattedMapPixmap(Map *map, bool ignoreBorder) {
pixmap = newPixmap;
}
if (!this->stitchMode) {
if (!this->mode) {
// if showing connections, draw on outside of image
QPainter connectionPainter(&pixmap);
for (auto connectionItem : editor->connection_edit_items) {
@ -365,3 +471,11 @@ void MapImageExporter::on_pushButton_Reset_pressed() {
void MapImageExporter::on_pushButton_Cancel_pressed() {
this->close();
}
void MapImageExporter::on_spinBox_TimelapseDelay_valueChanged(int delayMs) {
timelapseDelayMs = delayMs;
}
void MapImageExporter::on_spinBox_FrameSkip_valueChanged(int skip) {
timelapseSkipAmount = skip;
}

9
src/vendor/QtGifImage/3rdParty/giflib.pri vendored Normal file
View file

@ -0,0 +1,9 @@
INCLUDEPATH += $$PWD/giflib
SOURCES += $$PWD/giflib/dgif_lib.c \
$$PWD/giflib/egif_lib.c \
$$PWD/giflib/gif_err.c \
$$PWD/giflib/gif_hash.c \
$$PWD/giflib/gifalloc.c \
$$PWD/giflib/quantize.c

36
src/vendor/QtGifImage/3rdParty/giflib/AUTHORS vendored Normal file
View file

@ -0,0 +1,36 @@
Michael Brown <michael_brown_uk[AT]hotmail.com>
callbacks to write data via user defined function
Daniel Eisenbud <eisenbud[AT]google.com>
Fixes for crashes with invalid gif files and double freeing of
colormaps
Gershon Elber <gershon[AT]cs.technion.sc.il>
original giflib code
Marc Ewing <marc[AT]redhat.com>
spec file (for rpms) updates
Toshio Kuratomi <toshio[AT]tiki-lounge.com>
uncompressed gif writing code
autoconf/automake process
former maintainer
marek <marwaw[AT]users.sourceforge.net>
Gif initialization fix
windows build code
Peter Mehlitz <peter[AT]transvirtual.com>
callbacks to read data from arbitrary sources (like libjpeg/libpng)
Dick Porter <dick[AT]cymru.net>
int/pointer fixes for Alpha
Eric Raymond <esr[AT]snark.thyrsus.com>
current as well as long time former maintainer of giflib code
Petter Reinholdtsen <pere[AT]hungry.com>
Tru64 build fixs
Georg Schwarz <geos[AT]epost.de>
IRIX fixes

19
src/vendor/QtGifImage/3rdParty/giflib/COPYING vendored Normal file
View file

@ -0,0 +1,19 @@
The GIFLIB distribution is Copyright (c) 1997 Eric S. Raymond
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

27
src/vendor/QtGifImage/3rdParty/giflib/README vendored Normal file
View file

@ -0,0 +1,27 @@
= GIFLIB =
This is the README file of GIFLIB, a library for manipulating GIF files.
Latest versions of GIFLIB are currently hosted at:
http://sourceforge.net/projects/giflib
== Overview ==
GIF is a legacy format; we recommend against generating new images in
it. For a cleaner, more extensible design with better color support
and compression, look up PNG.
giflib provides code for reading GIF files and transforming them into
RGB bitmaps, and for writing RGB bitmaps as GIF files.
The (permissive) open-source license is in the file COPYING.
You will find build instructions in build.asc
You will find full documentation of the API in doc/ and on the
project website.
The project has a long and confusing history, described in history.asc
The project to-do list is in TODO.

1169
src/vendor/QtGifImage/3rdParty/giflib/dgif_lib.c vendored Normal file
View file

File diff suppressed because it is too large Load diff

1147
src/vendor/QtGifImage/3rdParty/giflib/egif_lib.c vendored Normal file
View file

File diff suppressed because it is too large Load diff

97
src/vendor/QtGifImage/3rdParty/giflib/gif_err.c vendored Normal file
View file

@ -0,0 +1,97 @@
/*****************************************************************************
gif_err.c - handle error reporting for the GIF library.
****************************************************************************/
#include <stdio.h>
#include "gif_lib.h"
#include "gif_lib_private.h"
/*****************************************************************************
Return a string description of the last GIF error
*****************************************************************************/
char *
GifErrorString(int ErrorCode)
{
char *Err;
switch (ErrorCode) {
case E_GIF_ERR_OPEN_FAILED:
Err = "Failed to open given file";
break;
case E_GIF_ERR_WRITE_FAILED:
Err = "Failed to write to given file";
break;
case E_GIF_ERR_HAS_SCRN_DSCR:
Err = "Screen descriptor has already been set";
break;
case E_GIF_ERR_HAS_IMAG_DSCR:
Err = "Image descriptor is still active";
break;
case E_GIF_ERR_NO_COLOR_MAP:
Err = "Neither global nor local color map";
break;
case E_GIF_ERR_DATA_TOO_BIG:
Err = "Number of pixels bigger than width * height";
break;
case E_GIF_ERR_NOT_ENOUGH_MEM:
Err = "Failed to allocate required memory";
break;
case E_GIF_ERR_DISK_IS_FULL:
Err = "Write failed (disk full?)";
break;
case E_GIF_ERR_CLOSE_FAILED:
Err = "Failed to close given file";
break;
case E_GIF_ERR_NOT_WRITEABLE:
Err = "Given file was not opened for write";
break;
case D_GIF_ERR_OPEN_FAILED:
Err = "Failed to open given file";
break;
case D_GIF_ERR_READ_FAILED:
Err = "Failed to read from given file";
break;
case D_GIF_ERR_NOT_GIF_FILE:
Err = "Data is not in GIF format";
break;
case D_GIF_ERR_NO_SCRN_DSCR:
Err = "No screen descriptor detected";
break;
case D_GIF_ERR_NO_IMAG_DSCR:
Err = "No Image Descriptor detected";
break;
case D_GIF_ERR_NO_COLOR_MAP:
Err = "Neither global nor local color map";
break;
case D_GIF_ERR_WRONG_RECORD:
Err = "Wrong record type detected";
break;
case D_GIF_ERR_DATA_TOO_BIG:
Err = "Number of pixels bigger than width * height";
break;
case D_GIF_ERR_NOT_ENOUGH_MEM:
Err = "Failed to allocate required memory";
break;
case D_GIF_ERR_CLOSE_FAILED:
Err = "Failed to close given file";
break;
case D_GIF_ERR_NOT_READABLE:
Err = "Given file was not opened for read";
break;
case D_GIF_ERR_IMAGE_DEFECT:
Err = "Image is defective, decoding aborted";
break;
case D_GIF_ERR_EOF_TOO_SOON:
Err = "Image EOF detected before image complete";
break;
default:
Err = NULL;
break;
}
return Err;
}
/* end */

252
src/vendor/QtGifImage/3rdParty/giflib/gif_font.c vendored Normal file
View file

@ -0,0 +1,252 @@
/*****************************************************************************
gif_font.c - utility font handling and simple drawing for the GIF library
****************************************************************************/
#include <string.h>
#include "gif_lib.h"
/*****************************************************************************
Ascii 8 by 8 regular font - only first 128 characters are supported.
*****************************************************************************/
/*
* Each array entry holds the bits for 8 horizontal scan lines, topmost
* first. The most significant bit of each constant is the leftmost bit of
* the scan line.
*/
/*@+charint@*/
const unsigned char GifAsciiTable8x8[][GIF_FONT_WIDTH] = {
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* Ascii 0 */
{0x3c, 0x42, 0xa5, 0x81, 0xbd, 0x42, 0x3c, 0x00}, /* Ascii 1 */
{0x3c, 0x7e, 0xdb, 0xff, 0xc3, 0x7e, 0x3c, 0x00}, /* Ascii 2 */
{0x00, 0xee, 0xfe, 0xfe, 0x7c, 0x38, 0x10, 0x00}, /* Ascii 3 */
{0x10, 0x38, 0x7c, 0xfe, 0x7c, 0x38, 0x10, 0x00}, /* Ascii 4 */
{0x00, 0x3c, 0x18, 0xff, 0xff, 0x08, 0x18, 0x00}, /* Ascii 5 */
{0x10, 0x38, 0x7c, 0xfe, 0xfe, 0x10, 0x38, 0x00}, /* Ascii 6 */
{0x00, 0x00, 0x18, 0x3c, 0x18, 0x00, 0x00, 0x00}, /* Ascii 7 */
{0xff, 0xff, 0xe7, 0xc3, 0xe7, 0xff, 0xff, 0xff}, /* Ascii 8 */
{0x00, 0x3c, 0x42, 0x81, 0x81, 0x42, 0x3c, 0x00}, /* Ascii 9 */
{0xff, 0xc3, 0xbd, 0x7e, 0x7e, 0xbd, 0xc3, 0xff}, /* Ascii 10 */
{0x1f, 0x07, 0x0d, 0x7c, 0xc6, 0xc6, 0x7c, 0x00}, /* Ascii 11 */
{0x00, 0x7e, 0xc3, 0xc3, 0x7e, 0x18, 0x7e, 0x18}, /* Ascii 12 */
{0x04, 0x06, 0x07, 0x04, 0x04, 0xfc, 0xf8, 0x00}, /* Ascii 13 */
{0x0c, 0x0a, 0x0d, 0x0b, 0xf9, 0xf9, 0x1f, 0x1f}, /* Ascii 14 */
{0x00, 0x92, 0x7c, 0x44, 0xc6, 0x7c, 0x92, 0x00}, /* Ascii 15 */
{0x00, 0x00, 0x60, 0x78, 0x7e, 0x78, 0x60, 0x00}, /* Ascii 16 */
{0x00, 0x00, 0x06, 0x1e, 0x7e, 0x1e, 0x06, 0x00}, /* Ascii 17 */
{0x18, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x7e, 0x18}, /* Ascii 18 */
{0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x66, 0x00}, /* Ascii 19 */
{0xff, 0xb6, 0x76, 0x36, 0x36, 0x36, 0x36, 0x00}, /* Ascii 20 */
{0x7e, 0xc1, 0xdc, 0x22, 0x22, 0x1f, 0x83, 0x7e}, /* Ascii 21 */
{0x00, 0x00, 0x00, 0x7e, 0x7e, 0x00, 0x00, 0x00}, /* Ascii 22 */
{0x18, 0x7e, 0x18, 0x18, 0x7e, 0x18, 0x00, 0xff}, /* Ascii 23 */
{0x18, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00}, /* Ascii 24 */
{0x18, 0x18, 0x18, 0x18, 0x18, 0x7e, 0x18, 0x00}, /* Ascii 25 */
{0x00, 0x04, 0x06, 0xff, 0x06, 0x04, 0x00, 0x00}, /* Ascii 26 */
{0x00, 0x20, 0x60, 0xff, 0x60, 0x20, 0x00, 0x00}, /* Ascii 27 */
{0x00, 0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xff, 0x00}, /* Ascii 28 */
{0x00, 0x24, 0x66, 0xff, 0x66, 0x24, 0x00, 0x00}, /* Ascii 29 */
{0x00, 0x00, 0x10, 0x38, 0x7c, 0xfe, 0x00, 0x00}, /* Ascii 30 */
{0x00, 0x00, 0x00, 0xfe, 0x7c, 0x38, 0x10, 0x00}, /* Ascii 31 */
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* */
{0x30, 0x30, 0x30, 0x30, 0x30, 0x00, 0x30, 0x00}, /* ! */
{0x66, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* " */
{0x6c, 0x6c, 0xfe, 0x6c, 0xfe, 0x6c, 0x6c, 0x00}, /* # */
{0x10, 0x7c, 0xd2, 0x7c, 0x86, 0x7c, 0x10, 0x00}, /* $ */
{0xf0, 0x96, 0xfc, 0x18, 0x3e, 0x72, 0xde, 0x00}, /* % */
{0x30, 0x48, 0x30, 0x78, 0xce, 0xcc, 0x78, 0x00}, /* & */
{0x0c, 0x0c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00}, /* ' */
{0x10, 0x60, 0xc0, 0xc0, 0xc0, 0x60, 0x10, 0x00}, /* ( */
{0x10, 0x0c, 0x06, 0x06, 0x06, 0x0c, 0x10, 0x00}, /* ) */
{0x00, 0x54, 0x38, 0xfe, 0x38, 0x54, 0x00, 0x00}, /* * */
{0x00, 0x18, 0x18, 0x7e, 0x18, 0x18, 0x00, 0x00}, /* + */
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x70}, /* , */
{0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00}, /* - */
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00}, /* . */
{0x02, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x00}, /* / */
{0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00}, /* 0 */
{0x18, 0x38, 0x78, 0x18, 0x18, 0x18, 0x3c, 0x00}, /* 1 */
{0x7c, 0xc6, 0x06, 0x0c, 0x30, 0x60, 0xfe, 0x00}, /* 2 */
{0x7c, 0xc6, 0x06, 0x3c, 0x06, 0xc6, 0x7c, 0x00}, /* 3 */
{0x0e, 0x1e, 0x36, 0x66, 0xfe, 0x06, 0x06, 0x00}, /* 4 */
{0xfe, 0xc0, 0xc0, 0xfc, 0x06, 0x06, 0xfc, 0x00}, /* 5 */
{0x7c, 0xc6, 0xc0, 0xfc, 0xc6, 0xc6, 0x7c, 0x00}, /* 6 */
{0xfe, 0x06, 0x0c, 0x18, 0x30, 0x60, 0x60, 0x00}, /* 7 */
{0x7c, 0xc6, 0xc6, 0x7c, 0xc6, 0xc6, 0x7c, 0x00}, /* 8 */
{0x7c, 0xc6, 0xc6, 0x7e, 0x06, 0xc6, 0x7c, 0x00}, /* 9 */
{0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00}, /* : */
{0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x20, 0x00}, /* }, */
{0x00, 0x1c, 0x30, 0x60, 0x30, 0x1c, 0x00, 0x00}, /* < */
{0x00, 0x00, 0x7e, 0x00, 0x7e, 0x00, 0x00, 0x00}, /* = */
{0x00, 0x70, 0x18, 0x0c, 0x18, 0x70, 0x00, 0x00}, /* > */
{0x7c, 0xc6, 0x0c, 0x18, 0x30, 0x00, 0x30, 0x00}, /* ? */
{0x7c, 0x82, 0x9a, 0xaa, 0xaa, 0x9e, 0x7c, 0x00}, /* @ */
{0x38, 0x6c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0x00}, /* A */
{0xfc, 0xc6, 0xc6, 0xfc, 0xc6, 0xc6, 0xfc, 0x00}, /* B */
{0x7c, 0xc6, 0xc6, 0xc0, 0xc0, 0xc6, 0x7c, 0x00}, /* C */
{0xf8, 0xcc, 0xc6, 0xc6, 0xc6, 0xcc, 0xf8, 0x00}, /* D */
{0xfe, 0xc0, 0xc0, 0xfc, 0xc0, 0xc0, 0xfe, 0x00}, /* E */
{0xfe, 0xc0, 0xc0, 0xfc, 0xc0, 0xc0, 0xc0, 0x00}, /* F */
{0x7c, 0xc6, 0xc0, 0xce, 0xc6, 0xc6, 0x7e, 0x00}, /* G */
{0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x00}, /* H */
{0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x78, 0x00}, /* I */
{0x1e, 0x06, 0x06, 0x06, 0xc6, 0xc6, 0x7c, 0x00}, /* J */
{0xc6, 0xcc, 0xd8, 0xf0, 0xd8, 0xcc, 0xc6, 0x00}, /* K */
{0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfe, 0x00}, /* L */
{0xc6, 0xee, 0xfe, 0xd6, 0xc6, 0xc6, 0xc6, 0x00}, /* M */
{0xc6, 0xe6, 0xf6, 0xde, 0xce, 0xc6, 0xc6, 0x00}, /* N */
{0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00}, /* O */
{0xfc, 0xc6, 0xc6, 0xfc, 0xc0, 0xc0, 0xc0, 0x00}, /* P */
{0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x06}, /* Q */
{0xfc, 0xc6, 0xc6, 0xfc, 0xc6, 0xc6, 0xc6, 0x00}, /* R */
{0x78, 0xcc, 0x60, 0x30, 0x18, 0xcc, 0x78, 0x00}, /* S */
{0xfc, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x00}, /* T */
{0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00}, /* U */
{0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x00}, /* V */
{0xc6, 0xc6, 0xc6, 0xd6, 0xfe, 0xee, 0xc6, 0x00}, /* W */
{0xc6, 0xc6, 0x6c, 0x38, 0x6c, 0xc6, 0xc6, 0x00}, /* X */
{0xc3, 0xc3, 0x66, 0x3c, 0x18, 0x18, 0x18, 0x00}, /* Y */
{0xfe, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0xfe, 0x00}, /* Z */
{0x3c, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3c, 0x00}, /* [ */
{0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x03, 0x00}, /* \ */
{0x3c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x3c, 0x00}, /* ] */
{0x00, 0x38, 0x6c, 0xc6, 0x00, 0x00, 0x00, 0x00}, /* ^ */
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff}, /* _ */
{0x30, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00}, /* ` */
{0x00, 0x00, 0x7c, 0x06, 0x7e, 0xc6, 0x7e, 0x00}, /* a */
{0xc0, 0xc0, 0xfc, 0xc6, 0xc6, 0xe6, 0xdc, 0x00}, /* b */
{0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0x7e, 0x00}, /* c */
{0x06, 0x06, 0x7e, 0xc6, 0xc6, 0xce, 0x76, 0x00}, /* d */
{0x00, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0x7e, 0x00}, /* e */
{0x1e, 0x30, 0x7c, 0x30, 0x30, 0x30, 0x30, 0x00}, /* f */
{0x00, 0x00, 0x7e, 0xc6, 0xce, 0x76, 0x06, 0x7c}, /* g */
{0xc0, 0xc0, 0xfc, 0xc6, 0xc6, 0xc6, 0xc6, 0x00}, /* */
{0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x3c, 0x00}, /* i */
{0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0xf0}, /* j */
{0xc0, 0xc0, 0xcc, 0xd8, 0xf0, 0xd8, 0xcc, 0x00}, /* k */
{0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00}, /* l */
{0x00, 0x00, 0xcc, 0xfe, 0xd6, 0xc6, 0xc6, 0x00}, /* m */
{0x00, 0x00, 0xfc, 0xc6, 0xc6, 0xc6, 0xc6, 0x00}, /* n */
{0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00}, /* o */
{0x00, 0x00, 0xfc, 0xc6, 0xc6, 0xe6, 0xdc, 0xc0}, /* p */
{0x00, 0x00, 0x7e, 0xc6, 0xc6, 0xce, 0x76, 0x06}, /* q */
{0x00, 0x00, 0x6e, 0x70, 0x60, 0x60, 0x60, 0x00}, /* r */
{0x00, 0x00, 0x7c, 0xc0, 0x7c, 0x06, 0xfc, 0x00}, /* s */
{0x30, 0x30, 0x7c, 0x30, 0x30, 0x30, 0x1c, 0x00}, /* t */
{0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0x7e, 0x00}, /* u */
{0x00, 0x00, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x00}, /* v */
{0x00, 0x00, 0xc6, 0xc6, 0xd6, 0xfe, 0x6c, 0x00}, /* w */
{0x00, 0x00, 0xc6, 0x6c, 0x38, 0x6c, 0xc6, 0x00}, /* x */
{0x00, 0x00, 0xc6, 0xc6, 0xce, 0x76, 0x06, 0x7c}, /* y */
{0x00, 0x00, 0xfc, 0x18, 0x30, 0x60, 0xfc, 0x00}, /* z */
{0x0e, 0x18, 0x18, 0x70, 0x18, 0x18, 0x0e, 0x00}, /* { */
{0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x00}, /* | */
{0xe0, 0x30, 0x30, 0x1c, 0x30, 0x30, 0xe0, 0x00}, /* } */
{0x00, 0x00, 0x70, 0x9a, 0x0e, 0x00, 0x00, 0x00}, /* ~ */
{0x00, 0x00, 0x18, 0x3c, 0x66, 0xff, 0x00, 0x00} /* Ascii 127 */
};
/*@=charint@*/
void
GifDrawText8x8(SavedImage *Image,
const int x, const int y,
const char *legend,
const int color)
{
int i, j;
int base;
const char *cp;
for (i = 0; i < GIF_FONT_HEIGHT; i++) {
base = Image->ImageDesc.Width * (y + i) + x;
for (cp = legend; *cp; cp++)
for (j = 0; j < GIF_FONT_WIDTH; j++) {
if (GifAsciiTable8x8[(short)(*cp)][i] & (1 << (GIF_FONT_WIDTH - j)))
Image->RasterBits[base] = color;
base++;
}
}
}
void
GifDrawBox(SavedImage *Image,
const int x, const int y,
const int w, const int d,
const int color)
{
int j, base = Image->ImageDesc.Width * y + x;
for (j = 0; j < w; j++)
Image->RasterBits[base + j] =
Image->RasterBits[base + (d * Image->ImageDesc.Width) + j] = color;
for (j = 0; j < d; j++)
Image->RasterBits[base + j * Image->ImageDesc.Width] =
Image->RasterBits[base + j * Image->ImageDesc.Width + w] = color;
}
void
GifDrawRectangle(SavedImage *Image,
const int x, const int y,
const int w, const int d,
const int color)
{
unsigned char *bp = Image->RasterBits + Image->ImageDesc.Width * y + x;
int i;
for (i = 0; i < d; i++)
memset(bp + (i * Image->ImageDesc.Width), color, (size_t)w);
}
void
GifDrawBoxedText8x8(SavedImage *Image,
const int x, const int y,
const char *legend,
const int border,
const int bg, const int fg)
{
int i, j = 0, LineCount = 0, TextWidth = 0;
const char *cp;
/* compute size of text to box */
for (cp = legend; *cp; cp++)
if (*cp == '\r') {
if (j > TextWidth)
TextWidth = j;
j = 0;
LineCount++;
} else if (*cp != '\t')
++j;
LineCount++; /* count last line */
if (j > TextWidth) /* last line might be longer than any previous */
TextWidth = j;
/* fill the box */
GifDrawRectangle(Image, x + 1, y + 1,
border + TextWidth * GIF_FONT_WIDTH + border - 1,
border + LineCount * GIF_FONT_HEIGHT + border - 1, bg);
/* draw the text */
i = 0;
cp = strtok((char *)legend, "\r\n");
do {
int leadspace = 0;
if (cp[0] == '\t')
leadspace = (TextWidth - strlen(++cp)) / 2;
GifDrawText8x8(Image, x + border + (leadspace * GIF_FONT_WIDTH),
y + border + (GIF_FONT_HEIGHT * i++), cp, fg);
cp = strtok((char *)NULL, "\r\n");
} while (cp);
/* outline the box */
GifDrawBox(Image, x, y, border + TextWidth * GIF_FONT_WIDTH + border,
border + LineCount * GIF_FONT_HEIGHT + border, fg);
}
/* end */

131
src/vendor/QtGifImage/3rdParty/giflib/gif_hash.c vendored Normal file
View file

@ -0,0 +1,131 @@
/*****************************************************************************
gif_hash.c -- module to support the following operations:
1. InitHashTable - initialize hash table.
2. ClearHashTable - clear the hash table to an empty state.
2. InsertHashTable - insert one item into data structure.
3. ExistsHashTable - test if item exists in data structure.
This module is used to hash the GIF codes during encoding.
*****************************************************************************/
#include <stdint.h>
#include <stdlib.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include "gif_lib.h"
#include "gif_hash.h"
#include "gif_lib_private.h"
/* #define DEBUG_HIT_RATE Debug number of misses per hash Insert/Exists. */
#ifdef DEBUG_HIT_RATE
static long NumberOfTests = 0,
NumberOfMisses = 0;
#endif /* DEBUG_HIT_RATE */
static int KeyItem(uint32_t Item);
/******************************************************************************
Initialize HashTable - allocate the memory needed and clear it. *
******************************************************************************/
GifHashTableType *_InitHashTable(void)
{
GifHashTableType *HashTable;
if ((HashTable = (GifHashTableType *) malloc(sizeof(GifHashTableType)))
== NULL)
return NULL;
_ClearHashTable(HashTable);
return HashTable;
}
/******************************************************************************
Routine to clear the HashTable to an empty state. *
This part is a little machine depended. Use the commented part otherwise. *
******************************************************************************/
void _ClearHashTable(GifHashTableType *HashTable)
{
memset(HashTable -> HTable, 0xFF, HT_SIZE * sizeof(uint32_t));
}
/******************************************************************************
Routine to insert a new Item into the HashTable. The data is assumed to be *
new one. *
******************************************************************************/
void _InsertHashTable(GifHashTableType *HashTable, uint32_t Key, int Code)
{
int HKey = KeyItem(Key);
uint32_t *HTable = HashTable -> HTable;
#ifdef DEBUG_HIT_RATE
NumberOfTests++;
NumberOfMisses++;
#endif /* DEBUG_HIT_RATE */
while (HT_GET_KEY(HTable[HKey]) != 0xFFFFFL) {
#ifdef DEBUG_HIT_RATE
NumberOfMisses++;
#endif /* DEBUG_HIT_RATE */
HKey = (HKey + 1) & HT_KEY_MASK;
}
HTable[HKey] = HT_PUT_KEY(Key) | HT_PUT_CODE(Code);
}
/******************************************************************************
Routine to test if given Key exists in HashTable and if so returns its code *
Returns the Code if key was found, -1 if not. *
******************************************************************************/
int _ExistsHashTable(GifHashTableType *HashTable, uint32_t Key)
{
int HKey = KeyItem(Key);
uint32_t *HTable = HashTable -> HTable, HTKey;
#ifdef DEBUG_HIT_RATE
NumberOfTests++;
NumberOfMisses++;
#endif /* DEBUG_HIT_RATE */
while ((HTKey = HT_GET_KEY(HTable[HKey])) != 0xFFFFFL) {
#ifdef DEBUG_HIT_RATE
NumberOfMisses++;
#endif /* DEBUG_HIT_RATE */
if (Key == HTKey) return HT_GET_CODE(HTable[HKey]);
HKey = (HKey + 1) & HT_KEY_MASK;
}
return -1;
}
/******************************************************************************
Routine to generate an HKey for the hashtable out of the given unique key. *
The given Key is assumed to be 20 bits as follows: lower 8 bits are the *
new postfix character, while the upper 12 bits are the prefix code. *
Because the average hit ratio is only 2 (2 hash references per entry), *
evaluating more complex keys (such as twin prime keys) does not worth it! *
******************************************************************************/
static int KeyItem(uint32_t Item)
{
return ((Item >> 12) ^ Item) & HT_KEY_MASK;
}
#ifdef DEBUG_HIT_RATE
/******************************************************************************
Debugging routine to print the hit ratio - number of times the hash table *
was tested per operation. This routine was used to test the KeyItem routine *
******************************************************************************/
void HashTablePrintHitRatio(void)
{
printf("Hash Table Hit Ratio is %ld/%ld = %ld%%.\n",
NumberOfMisses, NumberOfTests,
NumberOfMisses * 100 / NumberOfTests);
}
#endif /* DEBUG_HIT_RATE */
/* end */

41
src/vendor/QtGifImage/3rdParty/giflib/gif_hash.h vendored Normal file
View file

@ -0,0 +1,41 @@
/******************************************************************************
gif_hash.h - magfic constants and declarations for GIF LZW
******************************************************************************/
#ifndef _GIF_HASH_H_
#define _GIF_HASH_H_
#ifndef _WIN32
#include <unistd.h>
#endif
#include <stdint.h>
#define HT_SIZE 8192 /* 12bits = 4096 or twice as big! */
#define HT_KEY_MASK 0x1FFF /* 13bits keys */
#define HT_KEY_NUM_BITS 13 /* 13bits keys */
#define HT_MAX_KEY 8191 /* 13bits - 1, maximal code possible */
#define HT_MAX_CODE 4095 /* Biggest code possible in 12 bits. */
/* The 32 bits of the long are divided into two parts for the key & code: */
/* 1. The code is 12 bits as our compression algorithm is limited to 12bits */
/* 2. The key is 12 bits Prefix code + 8 bit new char or 20 bits. */
/* The key is the upper 20 bits. The code is the lower 12. */
#define HT_GET_KEY(l) (l >> 12)
#define HT_GET_CODE(l) (l & 0x0FFF)
#define HT_PUT_KEY(l) (l << 12)
#define HT_PUT_CODE(l) (l & 0x0FFF)
typedef struct GifHashTableType {
uint32_t HTable[HT_SIZE];
} GifHashTableType;
GifHashTableType *_InitHashTable(void);
void _ClearHashTable(GifHashTableType *HashTable);
void _InsertHashTable(GifHashTableType *HashTable, uint32_t Key, int Code);
int _ExistsHashTable(GifHashTableType *HashTable, uint32_t Key);
#endif /* _GIF_HASH_H_ */
/* end */

316
src/vendor/QtGifImage/3rdParty/giflib/gif_lib.h vendored Normal file
View file

@ -0,0 +1,316 @@
/******************************************************************************
gif_lib.h - service library for decoding and encoding GIF images
*****************************************************************************/
#ifndef _GIF_LIB_H_
#define _GIF_LIB_H_ 1
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#define GIFLIB_MAJOR 5
#define GIFLIB_MINOR 0
#define GIFLIB_RELEASE 5
#define GIF_ERROR 0
#define GIF_OK 1
#include <stddef.h>
#ifdef _MSC_VER
#define BOOL int
#define TRUE 1
#define FALSE 0
#else
#include <stdbool.h>
#define BOOL _Bool
#define TRUE 1
#define FALSE 0
#endif
#define GIF_STAMP "GIFVER" /* First chars in file - GIF stamp. */
#define GIF_STAMP_LEN sizeof(GIF_STAMP) - 1
#define GIF_VERSION_POS 3 /* Version first character in stamp. */
#define GIF87_STAMP "GIF87a" /* First chars in file - GIF stamp. */
#define GIF89_STAMP "GIF89a" /* First chars in file - GIF stamp. */
typedef unsigned char GifPixelType;
typedef unsigned char *GifRowType;
typedef unsigned char GifByteType;
typedef unsigned int GifPrefixType;
typedef int GifWord;
typedef struct GifColorType {
GifByteType Red, Green, Blue;
} GifColorType;
typedef struct ColorMapObject {
int ColorCount;
int BitsPerPixel;
BOOL SortFlag;
GifColorType *Colors; /* on malloc(3) heap */
} ColorMapObject;
typedef struct GifImageDesc {
GifWord Left, Top, Width, Height; /* Current image dimensions. */
BOOL Interlace; /* Sequential/Interlaced lines. */
ColorMapObject *ColorMap; /* The local color map */
} GifImageDesc;
typedef struct ExtensionBlock {
int ByteCount;
GifByteType *Bytes; /* on malloc(3) heap */
int Function; /* The block function code */
#define CONTINUE_EXT_FUNC_CODE 0x00 /* continuation subblock */
#define COMMENT_EXT_FUNC_CODE 0xfe /* comment */
#define GRAPHICS_EXT_FUNC_CODE 0xf9 /* graphics control (GIF89) */
#define PLAINTEXT_EXT_FUNC_CODE 0x01 /* plaintext */
#define APPLICATION_EXT_FUNC_CODE 0xff /* application block */
} ExtensionBlock;
typedef struct SavedImage {
GifImageDesc ImageDesc;
GifByteType *RasterBits; /* on malloc(3) heap */
int ExtensionBlockCount; /* Count of extensions before image */
ExtensionBlock *ExtensionBlocks; /* Extensions before image */
} SavedImage;
typedef struct GifFileType {
GifWord SWidth, SHeight; /* Size of virtual canvas */
GifWord SColorResolution; /* How many colors can we generate? */
GifWord SBackGroundColor; /* Background color for virtual canvas */
GifByteType AspectByte; /* Used to compute pixel aspect ratio */
ColorMapObject *SColorMap; /* Global colormap, NULL if nonexistent. */
int ImageCount; /* Number of current image (both APIs) */
GifImageDesc Image; /* Current image (low-level API) */
SavedImage *SavedImages; /* Image sequence (high-level API) */
int ExtensionBlockCount; /* Count extensions past last image */
ExtensionBlock *ExtensionBlocks; /* Extensions past last image */
int Error; /* Last error condition reported */
void *UserData; /* hook to attach user data (TVT) */
void *Private; /* Don't mess with this! */
} GifFileType;
#define GIF_ASPECT_RATIO(n) ((n)+15.0/64.0)
typedef enum {
UNDEFINED_RECORD_TYPE,
SCREEN_DESC_RECORD_TYPE,
IMAGE_DESC_RECORD_TYPE, /* Begin with ',' */
EXTENSION_RECORD_TYPE, /* Begin with '!' */
TERMINATE_RECORD_TYPE /* Begin with ';' */
} GifRecordType;
/* func type to read gif data from arbitrary sources (TVT) */
typedef int (*InputFunc) (GifFileType *, GifByteType *, int);
/* func type to write gif data to arbitrary targets.
* Returns count of bytes written. (MRB)
*/
typedef int (*OutputFunc) (GifFileType *, const GifByteType *, int);
/******************************************************************************
GIF89 structures
******************************************************************************/
typedef struct GraphicsControlBlock {
int DisposalMode;
#define DISPOSAL_UNSPECIFIED 0 /* No disposal specified. */
#define DISPOSE_DO_NOT 1 /* Leave image in place */
#define DISPOSE_BACKGROUND 2 /* Set area too background color */
#define DISPOSE_PREVIOUS 3 /* Restore to previous content */
BOOL UserInputFlag; /* User confirmation required before disposal */
int DelayTime; /* pre-display delay in 0.01sec units */
int TransparentColor; /* Palette index for transparency, -1 if none */
#define NO_TRANSPARENT_COLOR -1
} GraphicsControlBlock;
/******************************************************************************
GIF encoding routines
******************************************************************************/
/* Main entry points */
GifFileType *EGifOpenFileName(const char *GifFileName,
const BOOL GifTestExistence, int *Error);
GifFileType *EGifOpenFileHandle(const int GifFileHandle, int *Error);
GifFileType *EGifOpen(void *userPtr, OutputFunc writeFunc, int *Error);
int EGifSpew(GifFileType * GifFile);
char *EGifGetGifVersion(GifFileType *GifFile); /* new in 5.x */
int EGifCloseFile(GifFileType * GifFile);
#define E_GIF_ERR_OPEN_FAILED 1 /* And EGif possible errors. */
#define E_GIF_ERR_WRITE_FAILED 2
#define E_GIF_ERR_HAS_SCRN_DSCR 3
#define E_GIF_ERR_HAS_IMAG_DSCR 4
#define E_GIF_ERR_NO_COLOR_MAP 5
#define E_GIF_ERR_DATA_TOO_BIG 6
#define E_GIF_ERR_NOT_ENOUGH_MEM 7
#define E_GIF_ERR_DISK_IS_FULL 8
#define E_GIF_ERR_CLOSE_FAILED 9
#define E_GIF_ERR_NOT_WRITEABLE 10
/* These are legacy. You probably do not want to call them directly */
int EGifPutScreenDesc(GifFileType *GifFile,
const int GifWidth, const int GifHeight,
const int GifColorRes,
const int GifBackGround,
const ColorMapObject *GifColorMap);
int EGifPutImageDesc(GifFileType *GifFile,
const int GifLeft, const int GifTop,
const int GifWidth, const int GifHeight,
const BOOL GifInterlace,
const ColorMapObject *GifColorMap);
void EGifSetGifVersion(GifFileType *GifFile, const BOOL gif89);
int EGifPutLine(GifFileType *GifFile, GifPixelType *GifLine,
int GifLineLen);
int EGifPutPixel(GifFileType *GifFile, const GifPixelType GifPixel);
int EGifPutComment(GifFileType *GifFile, const char *GifComment);
int EGifPutExtensionLeader(GifFileType *GifFile, const int GifExtCode);
int EGifPutExtensionBlock(GifFileType *GifFile,
const int GifExtLen, const void *GifExtension);
int EGifPutExtensionTrailer(GifFileType *GifFile);
int EGifPutExtension(GifFileType *GifFile, const int GifExtCode,
const int GifExtLen,
const void *GifExtension);
int EGifPutCode(GifFileType *GifFile, int GifCodeSize,
const GifByteType *GifCodeBlock);
int EGifPutCodeNext(GifFileType *GifFile,
const GifByteType *GifCodeBlock);
/******************************************************************************
GIF decoding routines
******************************************************************************/
/* Main entry points */
GifFileType *DGifOpenFileName(const char *GifFileName, int *Error);
GifFileType *DGifOpenFileHandle(int GifFileHandle, int *Error);
int DGifSlurp(GifFileType * GifFile);
GifFileType *DGifOpen(void *userPtr, InputFunc readFunc, int *Error); /* new one (TVT) */
int DGifCloseFile(GifFileType * GifFile);
#define D_GIF_ERR_OPEN_FAILED 101 /* And DGif possible errors. */
#define D_GIF_ERR_READ_FAILED 102
#define D_GIF_ERR_NOT_GIF_FILE 103
#define D_GIF_ERR_NO_SCRN_DSCR 104
#define D_GIF_ERR_NO_IMAG_DSCR 105
#define D_GIF_ERR_NO_COLOR_MAP 106
#define D_GIF_ERR_WRONG_RECORD 107
#define D_GIF_ERR_DATA_TOO_BIG 108
#define D_GIF_ERR_NOT_ENOUGH_MEM 109
#define D_GIF_ERR_CLOSE_FAILED 110
#define D_GIF_ERR_NOT_READABLE 111
#define D_GIF_ERR_IMAGE_DEFECT 112
#define D_GIF_ERR_EOF_TOO_SOON 113
/* These are legacy. You probably do not want to call them directly */
int DGifGetScreenDesc(GifFileType *GifFile);
int DGifGetRecordType(GifFileType *GifFile, GifRecordType *GifType);
int DGifGetImageDesc(GifFileType *GifFile);
int DGifGetLine(GifFileType *GifFile, GifPixelType *GifLine, int GifLineLen);
int DGifGetPixel(GifFileType *GifFile, GifPixelType GifPixel);
int DGifGetComment(GifFileType *GifFile, char *GifComment);
int DGifGetExtension(GifFileType *GifFile, int *GifExtCode,
GifByteType **GifExtension);
int DGifGetExtensionNext(GifFileType *GifFile, GifByteType **GifExtension);
int DGifGetCode(GifFileType *GifFile, int *GifCodeSize,
GifByteType **GifCodeBlock);
int DGifGetCodeNext(GifFileType *GifFile, GifByteType **GifCodeBlock);
int DGifGetLZCodes(GifFileType *GifFile, int *GifCode);
/******************************************************************************
Color table quantization (deprecated)
******************************************************************************/
int GifQuantizeBuffer(unsigned int Width, unsigned int Height,
int *ColorMapSize, GifByteType * RedInput,
GifByteType * GreenInput, GifByteType * BlueInput,
GifByteType * OutputBuffer,
GifColorType * OutputColorMap);
/******************************************************************************
Error handling and reporting.
******************************************************************************/
extern char *GifErrorString(int ErrorCode); /* new in 2012 - ESR */
/*****************************************************************************
Everything below this point is new after version 1.2, supporting `slurp
mode' for doing I/O in two big belts with all the image-bashing in core.
******************************************************************************/
/******************************************************************************
Color map handling from gif_alloc.c
******************************************************************************/
extern ColorMapObject *GifMakeMapObject(int ColorCount,
const GifColorType *ColorMap);
extern void GifFreeMapObject(ColorMapObject *Object);
extern ColorMapObject *GifUnionColorMap(const ColorMapObject *ColorIn1,
const ColorMapObject *ColorIn2,
GifPixelType ColorTransIn2[]);
extern int GifBitSize(int n);
/******************************************************************************
Support for the in-core structures allocation (slurp mode).
******************************************************************************/
extern void GifApplyTranslation(SavedImage *Image, GifPixelType Translation[]);
extern int GifAddExtensionBlock(int *ExtensionBlock_Count,
ExtensionBlock **ExtensionBlocks,
int Function,
unsigned int Len, unsigned char ExtData[]);
extern void GifFreeExtensions(int *ExtensionBlock_Count,
ExtensionBlock **ExtensionBlocks);
extern SavedImage *GifMakeSavedImage(GifFileType *GifFile,
const SavedImage *CopyFrom);
extern void GifFreeSavedImages(GifFileType *GifFile);
/******************************************************************************
5.x functions for GIF89 graphics control blocks
******************************************************************************/
int DGifExtensionToGCB(const size_t GifExtensionLength,
const GifByteType *GifExtension,
GraphicsControlBlock *GCB);
size_t EGifGCBToExtension(const GraphicsControlBlock *GCB,
GifByteType *GifExtension);
int DGifSavedExtensionToGCB(GifFileType *GifFile,
int ImageIndex,
GraphicsControlBlock *GCB);
int EGifGCBToSavedExtension(const GraphicsControlBlock *GCB,
GifFileType *GifFile,
int ImageIndex);
/******************************************************************************
The library's internal utility font
******************************************************************************/
#define GIF_FONT_WIDTH 8
#define GIF_FONT_HEIGHT 8
extern const unsigned char GifAsciiTable8x8[][GIF_FONT_WIDTH];
extern void GifDrawText8x8(SavedImage *Image,
const int x, const int y,
const char *legend, const int color);
extern void GifDrawBox(SavedImage *Image,
const int x, const int y,
const int w, const int d, const int color);
extern void GifDrawRectangle(SavedImage *Image,
const int x, const int y,
const int w, const int d, const int color);
extern void GifDrawBoxedText8x8(SavedImage *Image,
const int x, const int y,
const char *legend,
const int border, const int bg, const int fg);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* _GIF_LIB_H */
/* end */

59
src/vendor/QtGifImage/3rdParty/giflib/gif_lib_private.h vendored Normal file
View file

@ -0,0 +1,59 @@
/****************************************************************************
gif_lib_private.h - internal giflib routines and structures
****************************************************************************/
#ifndef _GIF_LIB_PRIVATE_H
#define _GIF_LIB_PRIVATE_H
#include "gif_lib.h"
#include "gif_hash.h"
#define EXTENSION_INTRODUCER 0x21
#define DESCRIPTOR_INTRODUCER 0x2c
#define TERMINATOR_INTRODUCER 0x3b
#define LZ_MAX_CODE 4095 /* Biggest code possible in 12 bits. */
#define LZ_BITS 12
#define FLUSH_OUTPUT 4096 /* Impossible code, to signal flush. */
#define FIRST_CODE 4097 /* Impossible code, to signal first. */
#define NO_SUCH_CODE 4098 /* Impossible code, to signal empty. */
#define FILE_STATE_WRITE 0x01
#define FILE_STATE_SCREEN 0x02
#define FILE_STATE_IMAGE 0x04
#define FILE_STATE_READ 0x08
#define IS_READABLE(Private) (Private->FileState & FILE_STATE_READ)
#define IS_WRITEABLE(Private) (Private->FileState & FILE_STATE_WRITE)
typedef struct GifFilePrivateType {
GifWord FileState, FileHandle, /* Where all this data goes to! */
BitsPerPixel, /* Bits per pixel (Codes uses at least this + 1). */
ClearCode, /* The CLEAR LZ code. */
EOFCode, /* The EOF LZ code. */
RunningCode, /* The next code algorithm can generate. */
RunningBits, /* The number of bits required to represent RunningCode. */
MaxCode1, /* 1 bigger than max. possible code, in RunningBits bits. */
LastCode, /* The code before the current code. */
CrntCode, /* Current algorithm code. */
StackPtr, /* For character stack (see below). */
CrntShiftState; /* Number of bits in CrntShiftDWord. */
unsigned long CrntShiftDWord; /* For bytes decomposition into codes. */
unsigned long PixelCount; /* Number of pixels in image. */
FILE *File; /* File as stream. */
InputFunc Read; /* function to read gif input (TVT) */
OutputFunc Write; /* function to write gif output (MRB) */
GifByteType Buf[256]; /* Compressed input is buffered here. */
GifByteType Stack[LZ_MAX_CODE]; /* Decoded pixels are stacked here. */
GifByteType Suffix[LZ_MAX_CODE + 1]; /* So we can trace the codes. */
GifPrefixType Prefix[LZ_MAX_CODE + 1];
GifHashTableType *HashTable;
BOOL gif89;
} GifFilePrivateType;
#endif /* _GIF_LIB_PRIVATE_H */
/* end */

400
src/vendor/QtGifImage/3rdParty/giflib/gifalloc.c vendored Normal file
View file

@ -0,0 +1,400 @@
/*****************************************************************************
GIF construction tools
****************************************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "gif_lib.h"
#define MAX(x, y) (((x) > (y)) ? (x) : (y))
/******************************************************************************
Miscellaneous utility functions
******************************************************************************/
/* return smallest bitfield size n will fit in */
int
GifBitSize(int n)
{
register int i;
for (i = 1; i <= 8; i++)
if ((1 << i) >= n)
break;
return (i);
}
/******************************************************************************
Color map object functions
******************************************************************************/
/*
* Allocate a color map of given size; initialize with contents of
* ColorMap if that pointer is non-NULL.
*/
ColorMapObject *
GifMakeMapObject(int ColorCount, const GifColorType *ColorMap)
{
ColorMapObject *Object;
/*** FIXME: Our ColorCount has to be a power of two. Is it necessary to
* make the user know that or should we automatically round up instead? */
if (ColorCount != (1 << GifBitSize(ColorCount))) {
return ((ColorMapObject *) NULL);
}
Object = (ColorMapObject *)malloc(sizeof(ColorMapObject));
if (Object == (ColorMapObject *) NULL) {
return ((ColorMapObject *) NULL);
}
Object->Colors = (GifColorType *)calloc(ColorCount, sizeof(GifColorType));
if (Object->Colors == (GifColorType *) NULL) {
free(Object);
return ((ColorMapObject *) NULL);
}
Object->ColorCount = ColorCount;
Object->BitsPerPixel = GifBitSize(ColorCount);
if (ColorMap != NULL) {
memcpy((char *)Object->Colors,
(char *)ColorMap, ColorCount * sizeof(GifColorType));
}
return (Object);
}
/*******************************************************************************
Free a color map object
*******************************************************************************/
void
GifFreeMapObject(ColorMapObject *Object)
{
if (Object != NULL) {
(void)free(Object->Colors);
(void)free(Object);
}
}
#ifdef DEBUG
void
DumpColorMap(ColorMapObject *Object,
FILE * fp)
{
if (Object != NULL) {
int i, j, Len = Object->ColorCount;
for (i = 0; i < Len; i += 4) {
for (j = 0; j < 4 && j < Len; j++) {
(void)fprintf(fp, "%3d: %02x %02x %02x ", i + j,
Object->Colors[i + j].Red,
Object->Colors[i + j].Green,
Object->Colors[i + j].Blue);
}
(void)fprintf(fp, "\n");
}
}
}
#endif /* DEBUG */
/*******************************************************************************
Compute the union of two given color maps and return it. If result can't
fit into 256 colors, NULL is returned, the allocated union otherwise.
ColorIn1 is copied as is to ColorUnion, while colors from ColorIn2 are
copied iff they didn't exist before. ColorTransIn2 maps the old
ColorIn2 into the ColorUnion color map table./
*******************************************************************************/
ColorMapObject *
GifUnionColorMap(const ColorMapObject *ColorIn1,
const ColorMapObject *ColorIn2,
GifPixelType ColorTransIn2[])
{
int i, j, CrntSlot, RoundUpTo, NewGifBitSize;
ColorMapObject *ColorUnion;
/*
* We don't worry about duplicates within either color map; if
* the caller wants to resolve those, he can perform unions
* with an empty color map.
*/
/* Allocate table which will hold the result for sure. */
ColorUnion = GifMakeMapObject(MAX(ColorIn1->ColorCount,
ColorIn2->ColorCount) * 2, NULL);
if (ColorUnion == NULL)
return (NULL);
/*
* Copy ColorIn1 to ColorUnion.
*/
for (i = 0; i < ColorIn1->ColorCount; i++)
ColorUnion->Colors[i] = ColorIn1->Colors[i];
CrntSlot = ColorIn1->ColorCount;
/*
* Potentially obnoxious hack:
*
* Back CrntSlot down past all contiguous {0, 0, 0} slots at the end
* of table 1. This is very useful if your display is limited to
* 16 colors.
*/
while (ColorIn1->Colors[CrntSlot - 1].Red == 0
&& ColorIn1->Colors[CrntSlot - 1].Green == 0
&& ColorIn1->Colors[CrntSlot - 1].Blue == 0)
CrntSlot--;
/* Copy ColorIn2 to ColorUnion (use old colors if they exist): */
for (i = 0; i < ColorIn2->ColorCount && CrntSlot <= 256; i++) {
/* Let's see if this color already exists: */
for (j = 0; j < ColorIn1->ColorCount; j++)
if (memcmp (&ColorIn1->Colors[j], &ColorIn2->Colors[i],
sizeof(GifColorType)) == 0)
break;
if (j < ColorIn1->ColorCount)
ColorTransIn2[i] = j; /* color exists in Color1 */
else {
/* Color is new - copy it to a new slot: */
ColorUnion->Colors[CrntSlot] = ColorIn2->Colors[i];
ColorTransIn2[i] = CrntSlot++;
}
}
if (CrntSlot > 256) {
GifFreeMapObject(ColorUnion);
return ((ColorMapObject *) NULL);
}
NewGifBitSize = GifBitSize(CrntSlot);
RoundUpTo = (1 << NewGifBitSize);
if (RoundUpTo != ColorUnion->ColorCount) {
register GifColorType *Map = ColorUnion->Colors;
/*
* Zero out slots up to next power of 2.
* We know these slots exist because of the way ColorUnion's
* start dimension was computed.
*/
for (j = CrntSlot; j < RoundUpTo; j++)
Map[j].Red = Map[j].Green = Map[j].Blue = 0;
/* perhaps we can shrink the map? */
if (RoundUpTo < ColorUnion->ColorCount)
ColorUnion->Colors = (GifColorType *)realloc(Map,
sizeof(GifColorType) * RoundUpTo);
}
ColorUnion->ColorCount = RoundUpTo;
ColorUnion->BitsPerPixel = NewGifBitSize;
return (ColorUnion);
}
/*******************************************************************************
Apply a given color translation to the raster bits of an image
*******************************************************************************/
void
GifApplyTranslation(SavedImage *Image, GifPixelType Translation[])
{
register int i;
register int RasterSize = Image->ImageDesc.Height * Image->ImageDesc.Width;
for (i = 0; i < RasterSize; i++)
Image->RasterBits[i] = Translation[Image->RasterBits[i]];
}
/******************************************************************************
Extension record functions
******************************************************************************/
int
GifAddExtensionBlock(int *ExtensionBlockCount,
ExtensionBlock **ExtensionBlocks,
int Function,
unsigned int Len,
unsigned char ExtData[])
{
ExtensionBlock *ep;
if (*ExtensionBlocks == NULL)
*ExtensionBlocks=(ExtensionBlock *)malloc(sizeof(ExtensionBlock));
else
*ExtensionBlocks = (ExtensionBlock *)realloc(*ExtensionBlocks,
sizeof(ExtensionBlock) *
(*ExtensionBlockCount + 1));
if (*ExtensionBlocks == NULL)
return (GIF_ERROR);
ep = &(*ExtensionBlocks)[(*ExtensionBlockCount)++];
ep->Function = Function;
ep->ByteCount=Len;
ep->Bytes = (GifByteType *)malloc(ep->ByteCount);
if (ep->Bytes == NULL)
return (GIF_ERROR);
if (ExtData != NULL) {
memcpy(ep->Bytes, ExtData, Len);
}
return (GIF_OK);
}
void
GifFreeExtensions(int *ExtensionBlockCount,
ExtensionBlock **ExtensionBlocks)
{
ExtensionBlock *ep;
if (*ExtensionBlocks == NULL)
return;
for (ep = *ExtensionBlocks;
ep < (*ExtensionBlocks + *ExtensionBlockCount);
ep++)
(void)free((char *)ep->Bytes);
(void)free((char *)*ExtensionBlocks);
*ExtensionBlocks = NULL;
*ExtensionBlockCount = 0;
}
/******************************************************************************
Image block allocation functions
******************************************************************************/
/* Private Function:
* Frees the last image in the GifFile->SavedImages array
*/
void
FreeLastSavedImage(GifFileType *GifFile)
{
SavedImage *sp;
if ((GifFile == NULL) || (GifFile->SavedImages == NULL))
return;
/* Remove one SavedImage from the GifFile */
GifFile->ImageCount--;
sp = &GifFile->SavedImages[GifFile->ImageCount];
/* Deallocate its Colormap */
if (sp->ImageDesc.ColorMap != NULL) {
GifFreeMapObject(sp->ImageDesc.ColorMap);
sp->ImageDesc.ColorMap = NULL;
}
/* Deallocate the image data */
if (sp->RasterBits != NULL)
free((char *)sp->RasterBits);
/* Deallocate any extensions */
GifFreeExtensions(&sp->ExtensionBlockCount, &sp->ExtensionBlocks);
/*** FIXME: We could realloc the GifFile->SavedImages structure but is
* there a point to it? Saves some memory but we'd have to do it every
* time. If this is used in GifFreeSavedImages then it would be inefficient
* (The whole array is going to be deallocated.) If we just use it when
* we want to free the last Image it's convenient to do it here.
*/
}
/*
* Append an image block to the SavedImages array
*/
SavedImage *
GifMakeSavedImage(GifFileType *GifFile, const SavedImage *CopyFrom)
{
if (GifFile->SavedImages == NULL)
GifFile->SavedImages = (SavedImage *)malloc(sizeof(SavedImage));
else
GifFile->SavedImages = (SavedImage *)realloc(GifFile->SavedImages,
sizeof(SavedImage) * (GifFile->ImageCount + 1));
if (GifFile->SavedImages == NULL)
return ((SavedImage *)NULL);
else {
SavedImage *sp = &GifFile->SavedImages[GifFile->ImageCount++];
memset((char *)sp, '\0', sizeof(SavedImage));
if (CopyFrom != NULL) {
memcpy((char *)sp, CopyFrom, sizeof(SavedImage));
/*
* Make our own allocated copies of the heap fields in the
* copied record. This guards against potential aliasing
* problems.
*/
/* first, the local color map */
if (sp->ImageDesc.ColorMap != NULL) {
sp->ImageDesc.ColorMap = GifMakeMapObject(
CopyFrom->ImageDesc.ColorMap->ColorCount,
CopyFrom->ImageDesc.ColorMap->Colors);
if (sp->ImageDesc.ColorMap == NULL) {
FreeLastSavedImage(GifFile);
return (SavedImage *)(NULL);
}
}
/* next, the raster */
sp->RasterBits = (unsigned char *)malloc(sizeof(GifPixelType) *
CopyFrom->ImageDesc.Height *
CopyFrom->ImageDesc.Width);
if (sp->RasterBits == NULL) {
FreeLastSavedImage(GifFile);
return (SavedImage *)(NULL);
}
memcpy(sp->RasterBits, CopyFrom->RasterBits,
sizeof(GifPixelType) * CopyFrom->ImageDesc.Height *
CopyFrom->ImageDesc.Width);
/* finally, the extension blocks */
if (sp->ExtensionBlocks != NULL) {
sp->ExtensionBlocks = (ExtensionBlock *)malloc(
sizeof(ExtensionBlock) *
CopyFrom->ExtensionBlockCount);
if (sp->ExtensionBlocks == NULL) {
FreeLastSavedImage(GifFile);
return (SavedImage *)(NULL);
}
memcpy(sp->ExtensionBlocks, CopyFrom->ExtensionBlocks,
sizeof(ExtensionBlock) * CopyFrom->ExtensionBlockCount);
}
}
return (sp);
}
}
void
GifFreeSavedImages(GifFileType *GifFile)
{
SavedImage *sp;
if ((GifFile == NULL) || (GifFile->SavedImages == NULL)) {
return;
}
for (sp = GifFile->SavedImages;
sp < GifFile->SavedImages + GifFile->ImageCount; sp++) {
if (sp->ImageDesc.ColorMap != NULL) {
GifFreeMapObject(sp->ImageDesc.ColorMap);
sp->ImageDesc.ColorMap = NULL;
}
if (sp->RasterBits != NULL)
free((char *)sp->RasterBits);
GifFreeExtensions(&sp->ExtensionBlockCount, &sp->ExtensionBlocks);
}
free((char *)GifFile->SavedImages);
GifFile->SavedImages = NULL;
}
/* end */

309
src/vendor/QtGifImage/3rdParty/giflib/quantize.c vendored Normal file
View file

@ -0,0 +1,309 @@
/*****************************************************************************
quantize.c - quantize a high resolution image into lower one
Based on: "Color Image Quantization for frame buffer Display", by
Paul Heckbert SIGGRAPH 1982 page 297-307.
This doesn't really belong in the core library, was undocumented,
and was removed in 4.2. Then it turned out some client apps were
actually using it, so it was restored in 5.0.
******************************************************************************/
#include <stdlib.h>
#include <stdio.h>
#include "gif_lib.h"
#include "gif_lib_private.h"
#define ABS(x) ((x) > 0 ? (x) : (-(x)))
#define COLOR_ARRAY_SIZE 32768
#define BITS_PER_PRIM_COLOR 5
#define MAX_PRIM_COLOR 0x1f
static int SortRGBAxis;
typedef struct QuantizedColorType {
GifByteType RGB[3];
GifByteType NewColorIndex;
long Count;
struct QuantizedColorType *Pnext;
} QuantizedColorType;
typedef struct NewColorMapType {
GifByteType RGBMin[3], RGBWidth[3];
unsigned int NumEntries; /* # of QuantizedColorType in linked list below */
unsigned long Count; /* Total number of pixels in all the entries */
QuantizedColorType *QuantizedColors;
} NewColorMapType;
static int SubdivColorMap(NewColorMapType * NewColorSubdiv,
unsigned int ColorMapSize,
unsigned int *NewColorMapSize);
static int SortCmpRtn(const void *Entry1, const void *Entry2);
/******************************************************************************
Quantize high resolution image into lower one. Input image consists of a
2D array for each of the RGB colors with size Width by Height. There is no
Color map for the input. Output is a quantized image with 2D array of
indexes into the output color map.
Note input image can be 24 bits at the most (8 for red/green/blue) and
the output has 256 colors at the most (256 entries in the color map.).
ColorMapSize specifies size of color map up to 256 and will be updated to
real size before returning.
Also non of the parameter are allocated by this routine.
This function returns GIF_OK if successful, GIF_ERROR otherwise.
******************************************************************************/
int
GifQuantizeBuffer(unsigned int Width,
unsigned int Height,
int *ColorMapSize,
GifByteType * RedInput,
GifByteType * GreenInput,
GifByteType * BlueInput,
GifByteType * OutputBuffer,
GifColorType * OutputColorMap) {
unsigned int Index, NumOfEntries;
int i, j, MaxRGBError[3];
unsigned int NewColorMapSize;
long Red, Green, Blue;
NewColorMapType NewColorSubdiv[256];
QuantizedColorType *ColorArrayEntries, *QuantizedColor;
ColorArrayEntries = (QuantizedColorType *)malloc(
sizeof(QuantizedColorType) * COLOR_ARRAY_SIZE);
if (ColorArrayEntries == NULL) {
return GIF_ERROR;
}
for (i = 0; i < COLOR_ARRAY_SIZE; i++) {
ColorArrayEntries[i].RGB[0] = i >> (2 * BITS_PER_PRIM_COLOR);
ColorArrayEntries[i].RGB[1] = (i >> BITS_PER_PRIM_COLOR) &
MAX_PRIM_COLOR;
ColorArrayEntries[i].RGB[2] = i & MAX_PRIM_COLOR;
ColorArrayEntries[i].Count = 0;
}
/* Sample the colors and their distribution: */
for (i = 0; i < (int)(Width * Height); i++) {
Index = ((RedInput[i] >> (8 - BITS_PER_PRIM_COLOR)) <<
(2 * BITS_PER_PRIM_COLOR)) +
((GreenInput[i] >> (8 - BITS_PER_PRIM_COLOR)) <<
BITS_PER_PRIM_COLOR) +
(BlueInput[i] >> (8 - BITS_PER_PRIM_COLOR));
ColorArrayEntries[Index].Count++;
}
/* Put all the colors in the first entry of the color map, and call the
* recursive subdivision process. */
for (i = 0; i < 256; i++) {
NewColorSubdiv[i].QuantizedColors = NULL;
NewColorSubdiv[i].Count = NewColorSubdiv[i].NumEntries = 0;
for (j = 0; j < 3; j++) {
NewColorSubdiv[i].RGBMin[j] = 0;
NewColorSubdiv[i].RGBWidth[j] = 255;
}
}
/* Find the non empty entries in the color table and chain them: */
for (i = 0; i < COLOR_ARRAY_SIZE; i++)
if (ColorArrayEntries[i].Count > 0)
break;
QuantizedColor = NewColorSubdiv[0].QuantizedColors = &ColorArrayEntries[i];
NumOfEntries = 1;
while (++i < COLOR_ARRAY_SIZE)
if (ColorArrayEntries[i].Count > 0) {
QuantizedColor->Pnext = &ColorArrayEntries[i];
QuantizedColor = &ColorArrayEntries[i];
NumOfEntries++;
}
QuantizedColor->Pnext = NULL;
NewColorSubdiv[0].NumEntries = NumOfEntries; /* Different sampled colors */
NewColorSubdiv[0].Count = ((long)Width) * Height; /* Pixels */
NewColorMapSize = 1;
if (SubdivColorMap(NewColorSubdiv, *ColorMapSize, &NewColorMapSize) !=
GIF_OK) {
free((char *)ColorArrayEntries);
return GIF_ERROR;
}
if (NewColorMapSize < *ColorMapSize) {
/* And clear rest of color map: */
for (i = NewColorMapSize; i < *ColorMapSize; i++)
OutputColorMap[i].Red = OutputColorMap[i].Green =
OutputColorMap[i].Blue = 0;
}
/* Average the colors in each entry to be the color to be used in the
* output color map, and plug it into the output color map itself. */
for (i = 0; i < NewColorMapSize; i++) {
if ((j = NewColorSubdiv[i].NumEntries) > 0) {
QuantizedColor = NewColorSubdiv[i].QuantizedColors;
Red = Green = Blue = 0;
while (QuantizedColor) {
QuantizedColor->NewColorIndex = i;
Red += QuantizedColor->RGB[0];
Green += QuantizedColor->RGB[1];
Blue += QuantizedColor->RGB[2];
QuantizedColor = QuantizedColor->Pnext;
}
OutputColorMap[i].Red = (Red << (8 - BITS_PER_PRIM_COLOR)) / j;
OutputColorMap[i].Green = (Green << (8 - BITS_PER_PRIM_COLOR)) / j;
OutputColorMap[i].Blue = (Blue << (8 - BITS_PER_PRIM_COLOR)) / j;
}
}
/* Finally scan the input buffer again and put the mapped index in the
* output buffer. */
MaxRGBError[0] = MaxRGBError[1] = MaxRGBError[2] = 0;
for (i = 0; i < (int)(Width * Height); i++) {
Index = ((RedInput[i] >> (8 - BITS_PER_PRIM_COLOR)) <<
(2 * BITS_PER_PRIM_COLOR)) +
((GreenInput[i] >> (8 - BITS_PER_PRIM_COLOR)) <<
BITS_PER_PRIM_COLOR) +
(BlueInput[i] >> (8 - BITS_PER_PRIM_COLOR));
Index = ColorArrayEntries[Index].NewColorIndex;
OutputBuffer[i] = Index;
if (MaxRGBError[0] < ABS(OutputColorMap[Index].Red - RedInput[i]))
MaxRGBError[0] = ABS(OutputColorMap[Index].Red - RedInput[i]);
if (MaxRGBError[1] < ABS(OutputColorMap[Index].Green - GreenInput[i]))
MaxRGBError[1] = ABS(OutputColorMap[Index].Green - GreenInput[i]);
if (MaxRGBError[2] < ABS(OutputColorMap[Index].Blue - BlueInput[i]))
MaxRGBError[2] = ABS(OutputColorMap[Index].Blue - BlueInput[i]);
}
#ifdef DEBUG
fprintf(stderr,
"Quantization L(0) errors: Red = %d, Green = %d, Blue = %d.\n",
MaxRGBError[0], MaxRGBError[1], MaxRGBError[2]);
#endif /* DEBUG */
free((char *)ColorArrayEntries);
*ColorMapSize = NewColorMapSize;
return GIF_OK;
}
/******************************************************************************
Routine to subdivide the RGB space recursively using median cut in each
axes alternatingly until ColorMapSize different cubes exists.
The biggest cube in one dimension is subdivide unless it has only one entry.
Returns GIF_ERROR if failed, otherwise GIF_OK.
*******************************************************************************/
static int
SubdivColorMap(NewColorMapType * NewColorSubdiv,
unsigned int ColorMapSize,
unsigned int *NewColorMapSize) {
int MaxSize;
unsigned int i, j, Index = 0, NumEntries, MinColor, MaxColor;
long Sum, Count;
QuantizedColorType *QuantizedColor, **SortArray;
while (ColorMapSize > *NewColorMapSize) {
/* Find candidate for subdivision: */
MaxSize = -1;
for (i = 0; i < *NewColorMapSize; i++) {
for (j = 0; j < 3; j++) {
if ((((int)NewColorSubdiv[i].RGBWidth[j]) > MaxSize) &&
(NewColorSubdiv[i].NumEntries > 1)) {
MaxSize = NewColorSubdiv[i].RGBWidth[j];
Index = i;
SortRGBAxis = j;
}
}
}
if (MaxSize == -1)
return GIF_OK;
/* Split the entry Index into two along the axis SortRGBAxis: */
/* Sort all elements in that entry along the given axis and split at
* the median. */
SortArray = (QuantizedColorType **)malloc(
sizeof(QuantizedColorType *) *
NewColorSubdiv[Index].NumEntries);
if (SortArray == NULL)
return GIF_ERROR;
for (j = 0, QuantizedColor = NewColorSubdiv[Index].QuantizedColors;
j < NewColorSubdiv[Index].NumEntries && QuantizedColor != NULL;
j++, QuantizedColor = QuantizedColor->Pnext)
SortArray[j] = QuantizedColor;
qsort(SortArray, NewColorSubdiv[Index].NumEntries,
sizeof(QuantizedColorType *), SortCmpRtn);
/* Relink the sorted list into one: */
for (j = 0; j < NewColorSubdiv[Index].NumEntries - 1; j++)
SortArray[j]->Pnext = SortArray[j + 1];
SortArray[NewColorSubdiv[Index].NumEntries - 1]->Pnext = NULL;
NewColorSubdiv[Index].QuantizedColors = QuantizedColor = SortArray[0];
free((char *)SortArray);
/* Now simply add the Counts until we have half of the Count: */
Sum = NewColorSubdiv[Index].Count / 2 - QuantizedColor->Count;
NumEntries = 1;
Count = QuantizedColor->Count;
while (QuantizedColor->Pnext != NULL &&
(Sum -= QuantizedColor->Pnext->Count) >= 0 &&
QuantizedColor->Pnext->Pnext != NULL) {
QuantizedColor = QuantizedColor->Pnext;
NumEntries++;
Count += QuantizedColor->Count;
}
/* Save the values of the last color of the first half, and first
* of the second half so we can update the Bounding Boxes later.
* Also as the colors are quantized and the BBoxes are full 0..255,
* they need to be rescaled.
*/
MaxColor = QuantizedColor->RGB[SortRGBAxis]; /* Max. of first half */
/* coverity[var_deref_op] */
MinColor = QuantizedColor->Pnext->RGB[SortRGBAxis]; /* of second */
MaxColor <<= (8 - BITS_PER_PRIM_COLOR);
MinColor <<= (8 - BITS_PER_PRIM_COLOR);
/* Partition right here: */
NewColorSubdiv[*NewColorMapSize].QuantizedColors =
QuantizedColor->Pnext;
QuantizedColor->Pnext = NULL;
NewColorSubdiv[*NewColorMapSize].Count = Count;
NewColorSubdiv[Index].Count -= Count;
NewColorSubdiv[*NewColorMapSize].NumEntries =
NewColorSubdiv[Index].NumEntries - NumEntries;
NewColorSubdiv[Index].NumEntries = NumEntries;
for (j = 0; j < 3; j++) {
NewColorSubdiv[*NewColorMapSize].RGBMin[j] =
NewColorSubdiv[Index].RGBMin[j];
NewColorSubdiv[*NewColorMapSize].RGBWidth[j] =
NewColorSubdiv[Index].RGBWidth[j];
}
NewColorSubdiv[*NewColorMapSize].RGBWidth[SortRGBAxis] =
NewColorSubdiv[*NewColorMapSize].RGBMin[SortRGBAxis] +
NewColorSubdiv[*NewColorMapSize].RGBWidth[SortRGBAxis] - MinColor;
NewColorSubdiv[*NewColorMapSize].RGBMin[SortRGBAxis] = MinColor;
NewColorSubdiv[Index].RGBWidth[SortRGBAxis] =
MaxColor - NewColorSubdiv[Index].RGBMin[SortRGBAxis];
(*NewColorMapSize)++;
}
return GIF_OK;
}
/****************************************************************************
Routine called by qsort to compare two entries.
*****************************************************************************/
static int
SortCmpRtn(const void *Entry1,
const void *Entry2) {
return (*((QuantizedColorType **) Entry1))->RGB[SortRGBAxis] -
(*((QuantizedColorType **) Entry2))->RGB[SortRGBAxis];
}
/* end */

75
src/vendor/QtGifImage/gifimage/doc/qtgifimage.qdocconf vendored Normal file
View file

@ -0,0 +1,75 @@
include($QT_INSTALL_DOCS/global/qt-html-templates-offline.qdocconf)
include($QT_INSTALL_DOCS/global/qt-module-defaults.qdocconf)
project = QtGifImage
description = Qt GifImage Reference Documentation
url = http://qtgifimage.debao.me
version = $QT_VERSION
qhp.projects = QtGifImage
qhp.QtGifImage.file = qtgifimage.qhp
qhp.QtGifImage.namespace = me.debao.qtgifimage.$QT_VERSION_TAG
qhp.QtGifImage.virtualFolder = qtgifimage
qhp.QtGifImage.indexTitle = Qt GifImage
qhp.QtGifImage.indexRoot =
qhp.QtGifImage.filterAttributes = qtgifimage $QT_VERSION qtrefdoc
qhp.QtGifImage.customFilters.Qt.name = QtGifImage $QT_VERSION
qhp.QtGifImage.customFilters.Qt.filterAttributes = qtgifimage $QT_VERSION
qhp.QtGifImage.subprojects = overviews classes qmltypes examples
qhp.QtGifImage.subprojects.overviews.title = Overview
qhp.QtGifImage.subprojects.overviews.indexTitle = Qt GifImage
qhp.QtGifImage.subprojects.overviews.selectors = fake:page,group,module
qhp.QtGifImage.subprojects.classes.title = C++ Classes
qhp.QtGifImage.subprojects.classes.indexTitle = Qt GifImage C++ Classes
qhp.QtGifImage.subprojects.classes.selectors = class fake:headerfile
qhp.QtGifImage.subprojects.classes.sortPages = true
qhp.QtGifImage.subprojects.examples.title = Examples
qhp.QtGifImage.subprojects.examples.indexTitle = Qt GifImage Examples
qhp.QtGifImage.subprojects.examples.selectors = fake:example
tagfile = ../../../doc/qtgifimage/qtgifimage.tags
headerdirs += ..
sourcedirs += ..
exampledirs += ../../../examples/gifimage \
snippets/
# Specify the install path under QT_INSTALL_EXAMPLES
examplesinstallpath = gifimage
imagedirs += images
depends += qtcore qtdoc qtgui
HTML.footer = \
" </div>\n" \
" </div>\n" \
" </div>\n" \
" </div>\n" \
"</div>\n" \
"<div class=\"footer\">\n" \
" <div class=\"qt13a-copyright\" id=\"copyright\">\n" \
" <div class=\"qt13a-container\">\n" \
" <p>\n" \
" <acronym title=\"Copyright\">&copy;</acronym> 2013 Debao Zhang. \n" \
" Documentation contributions included herein are the copyrights of\n" \
" their respective owners.</p>\n" \
" <p>\n" \
" The documentation provided herein is licensed under the terms of the\n" \
" <a href=\"http://www.gnu.org/licenses/fdl.html\">GNU Free Documentation\n" \
" License version 1.3</a> as published by the Free Software Foundation.</p>\n" \
" <p>\n" \
" Documentation sources may be obtained from <a href=\"https://github.com/dbzhang800/QtGifImage\">\n" \
" github.com/dbzhang800</a>.</p>\n" \
" <p>\n" \
" Qt and their respective logos are trademarks of Digia Plc \n" \
" in Finland and/or other countries worldwide. All other trademarks are property\n" \
" of their respective owners. <a title=\"Privacy Policy\"\n" \
" href=\"http://en.gitorious.org/privacy_policy/\">Privacy Policy</a></p>\n" \
" </div>\n" \
" </div>\n" \
"</div>\n" \

8
src/vendor/QtGifImage/gifimage/doc/snippets/doc_src_qtgifimage.cpp vendored Normal file
View file

@ -0,0 +1,8 @@
//! [0]
#include <QtGifImage>
//! [0]
//! [1]
#include <QtGifImage>
//! [1]

3
src/vendor/QtGifImage/gifimage/doc/snippets/doc_src_qtgifimage.pro vendored Normal file
View file

@ -0,0 +1,3 @@
#! [1]
QT += gifimage
#! [1]

8
src/vendor/QtGifImage/gifimage/doc/src/examples.qdoc vendored Normal file
View file

@ -0,0 +1,8 @@
/*!
\group qtgifimage-examples
\title Qt GifImage Examples
\brief Examples for the Qt GifImage module
\ingroup all-examples
Qt GifImage comes with the following examples:
*/

71
src/vendor/QtGifImage/gifimage/doc/src/index.qdoc vendored Normal file
View file

@ -0,0 +1,71 @@
/****************************************************************************
** Copyright (c) 2013 Debao Zhang <hello@debao.me>
** All right reserved.
**
** Permission is hereby granted, free of charge, to any person obtaining
** a copy of this software and associated documentation files (the
** "Software"), to deal in the Software without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Software, and to
** permit persons to whom the Software is furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be
** included in all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
** NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
** LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
** OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
** WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
**
****************************************************************************/
/*!
\title Qt GifImage
\page index.html
\brief Qt GifImage provides functionality for handling .gif files.
The \l{Qt GifImage C++ Classes}{Qt GifImage Module} provides a set of classes to read and write .gif files.
The library can be used to
\list
\li Generate a new .gif file from a list of QImage files.
\li Extract frames to a list of QImage files.
\endlist
\image demo1.gif
\table
\row
\li Source code: \li \l{https://github.com/dbzhang800/QtGifImage}
\row
\li Issures: \li \l{https://github.com/dbzhang800/QtGifImage/issues}
\row
\li License: \li MIT
\endtable
\section1 Getting Started
To include the definitions of the module's classes, using the following directive:
\code
#include <QtGifImage>
\endcode
To link against the module, add this line to your qmake .pro file:
\code
QT += gifimage
\endcode
More information can be found in \l{Qt GifImage Build} page.
\section1 Related information
\list
\li \l{Qt GifImage C++ Classes}
\li \l{Qt GifImage Examples}
\endlist
*/

34
src/vendor/QtGifImage/gifimage/doc/src/qtgifimage.qdoc vendored Normal file
View file

@ -0,0 +1,34 @@
/****************************************************************************
** Copyright (c) 2013 Debao Zhang <hello@debao.me>
** All right reserved.
**
** Permission is hereby granted, free of charge, to any person obtaining
** a copy of this software and associated documentation files (the
** "Software"), to deal in the Software without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Software, and to
** permit persons to whom the Software is furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be
** included in all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
** NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
** LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
** OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
** WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
**
****************************************************************************/
/*!
\module QtGifImage
\title Qt GifImage C++ Classes
\ingroup modules
\brief The Qt GifImage module provides functionality for handling .gif files.
*/

53
src/vendor/QtGifImage/gifimage/doc/src/usage.qdoc vendored Normal file
View file

@ -0,0 +1,53 @@
/*!
\page building
\title Qt GifImage Build
\section1 Usage(1): Use Qt GifImage as Qt5's addon module
1. Download the source code from \l {https://github.com/dbzhang800/QtGifImage/archive/master.zip} {github.com}.
2. Put the source code in any directory you like. At the toplevel directory run
\note Perl is needed in this step.
\code
qmake
make
make install
\endcode
The library, the header files, and others will be installed to your system.
3. Add following line to your qmake's project file:
\code
QT += gifimage
\endcode
4. Then, using Qt Qt GifImage in your code
\section1 Usage(2): Use source code directly
The package contains a qtgifimage.pri file that allows you to integrate
the component into applications that use qmake for the build step.
1. Download the source code from \l {https://github.com/dbzhang800/QtGifImage/archive/master.zip} {github.com}
2. Put the source code in any directory you like. For example, 3rdparty:
\code
|-- project.pro
|-- ....
|-- 3rdparty\
| |-- qtgifimage\
| |
\endcode
3. Add following line to your qmake project file:
\code
include(3rdparty/qtgifimage/src/gifimage/qtgifimage.pri)
\endcode
4. Then, using Qt GifImage in your code
*/

13
src/vendor/QtGifImage/gifimage/gifimage.pro vendored Normal file
View file

@ -0,0 +1,13 @@
TARGET = QtGifImage
QMAKE_DOCS = $$PWD/doc/qtgifimage.qdocconf
load(qt_module)
CONFIG += build_gifimage_lib
include(qtgifimage.pri)
QMAKE_TARGET_COMPANY = "Debao Zhang"
QMAKE_TARGET_COPYRIGHT = "Copyright (C) 2013 Debao Zhang <hello@debao.me>"
QMAKE_TARGET_DESCRIPTION = ".gif file reader and wirter for Qt"

39
src/vendor/QtGifImage/gifimage/qgifglobal.h vendored Normal file
View file

@ -0,0 +1,39 @@
/****************************************************************************
** Copyright (c) 2013 Debao Zhang <hello@debao.me>
** All right reserved.
**
** Permission is hereby granted, free of charge, to any person obtaining
** a copy of this software and associated documentation files (the
** "Software"), to deal in the Software without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Software, and to
** permit persons to whom the Software is furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be
** included in all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
** NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
** LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
** OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
** WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
**
****************************************************************************/
#ifndef QGIFGLOBAL_H
#define QGIFGLOBAL_H
#include <QtGlobal>
#if !defined(QT_STATIC) && !defined(GIFIMAGE_NO_LIB)
# if defined(QT_BUILD_GIFIMAGE_LIB)
# define Q_GIFIMAGE_EXPORT Q_DECL_EXPORT
# else
# define Q_GIFIMAGE_EXPORT Q_DECL_IMPORT
# endif
#else
# define Q_GIFIMAGE_EXPORT
#endif
#endif // QGIFGLOBAL_H

678
src/vendor/QtGifImage/gifimage/qgifimage.cpp vendored Normal file
View file

@ -0,0 +1,678 @@
/****************************************************************************
** Copyright (c) 2013 Debao Zhang <hello@debao.me>
** All right reserved.
**
** Permission is hereby granted, free of charge, to any person obtaining
** a copy of this software and associated documentation files (the
** "Software"), to deal in the Software without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Software, and to
** permit persons to whom the Software is furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be
** included in all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
** NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
** LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
** OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
** WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
**
****************************************************************************/
#include "qgifimage.h"
#include "qgifimage_p.h"
#include <QFile>
#include <QImage>
#include <QDebug>
#include <QScopedPointer>
namespace
{
int writeToIODevice(GifFileType *gifFile, const GifByteType *data, int maxSize)
{
return static_cast<QIODevice *>(gifFile->UserData)->write(reinterpret_cast<const char *>(data), maxSize);
}
int readFromIODevice(GifFileType *gifFile, GifByteType *data, int maxSize)
{
return static_cast<QIODevice *>(gifFile->UserData)->read(reinterpret_cast<char *>(data), maxSize);
}
}
QGifImagePrivate::QGifImagePrivate(QGifImage *p)
: loopCount(0), defaultDelayTime(1000), q_ptr(p)
{
}
QGifImagePrivate::~QGifImagePrivate()
{
}
QVector<QRgb> QGifImagePrivate::colorTableFromColorMapObject(ColorMapObject *colorMap, int transColorIndex) const
{
QVector<QRgb> colorTable;
if (colorMap) {
for (int idx=0; idx<colorMap->ColorCount; ++idx) {
GifColorType gifColor = colorMap->Colors[idx];
QRgb color = gifColor.Blue | (gifColor.Green << 8) | (gifColor.Red << 16);
// For non-transparent color, set the alpha to opaque.
if (idx != transColorIndex)
color |= 0xff << 24;
colorTable.append(color);
}
}
return colorTable;
}
ColorMapObject *QGifImagePrivate::colorTableToColorMapObject(QVector<QRgb> colorTable) const
{
if (colorTable.isEmpty())
return 0;
ColorMapObject *cmap = (ColorMapObject *)malloc(sizeof(ColorMapObject));
// num of colors must be a power of 2
int numColors = 1 << GifBitSize(colorTable.size());
cmap->ColorCount = numColors;
//Maybe a bug of giflib, BitsPerPixel is used as size of the color table size.
cmap->BitsPerPixel = GifBitSize(colorTable.size()); //Todo!
cmap->SortFlag = false;
GifColorType* colorValues = (GifColorType*)calloc(numColors, sizeof(GifColorType));
for(int idx=0; idx < colorTable.size(); ++idx) {
colorValues[idx].Red = qRed(colorTable[idx]);
colorValues[idx].Green = qGreen(colorTable[idx]);
colorValues[idx].Blue = qBlue(colorTable[idx]);
}
cmap->Colors = colorValues;
return cmap;
}
QSize QGifImagePrivate::getCanvasSize() const
{
//If canvasSize has been set by user.
if (canvasSize.isValid())
return canvasSize;
//Calc the right canvasSize from the frame size.
int width = -1;
int height = -1;
foreach (QGifFrameInfoData info, frameInfos) {
int w = info.image.width() + info.offset.x();
int h = info.image.height() + info.offset.y();
if (w > width) width = w;
if (h > height) height = h;
}
return QSize(width, height);
}
int QGifImagePrivate::getFrameTransparentColorIndex(const QGifFrameInfoData &frameInfo) const
{
int index = -1;
QColor transColor = frameInfo.transparentColor.isValid() ? frameInfo.transparentColor : defaultTransparentColor;
if (transColor.isValid()) {
if (!frameInfo.image.colorTable().isEmpty())
index = frameInfo.image.colorTable().indexOf(transColor.rgb());
else if (!globalColorTable.isEmpty())
index = globalColorTable.indexOf(transColor.rgb());
}
return index;
}
bool QGifImagePrivate::load(QIODevice *device)
{
static int interlacedOffset[] = { 0, 4, 2, 1 }; /* The way Interlaced image should. */
static int interlacedJumps[] = { 8, 8, 4, 2 }; /* be read - offsets and jumps... */
int error;
GifFileType *gifFile = DGifOpen(device, readFromIODevice, &error);
if (!gifFile) {
qWarning(GifErrorString(error));
return false;
}
if (DGifSlurp(gifFile) == GIF_ERROR)
return false;
canvasSize.setWidth(gifFile->SWidth);
canvasSize.setHeight(gifFile->SHeight);
if (gifFile->SColorMap) {
globalColorTable = colorTableFromColorMapObject(gifFile->SColorMap);
if (gifFile->SBackGroundColor < globalColorTable.size())
bgColor = QColor(globalColorTable[gifFile->SBackGroundColor]);
}
for (int idx=0; idx<gifFile->ImageCount; ++idx) {
SavedImage gifImage = gifFile->SavedImages[idx];
int top = gifImage.ImageDesc.Top;
int left = gifImage.ImageDesc.Left;
int width = gifImage.ImageDesc.Width;
int height = gifImage.ImageDesc.Height;
QGifFrameInfoData frameInfo;
GraphicsControlBlock gcb;
DGifSavedExtensionToGCB(gifFile, idx, &gcb);
int transColorIndex = gcb.TransparentColor;
QVector<QRgb> colorTable;
if (gifImage.ImageDesc.ColorMap)
colorTable = colorTableFromColorMapObject(gifImage.ImageDesc.ColorMap, transColorIndex);
else if (transColorIndex != -1)
colorTable = colorTableFromColorMapObject(gifFile->SColorMap, transColorIndex);
else
colorTable = globalColorTable;
if (transColorIndex != -1)
frameInfo.transparentColor = colorTable[transColorIndex];
frameInfo.delayTime = gcb.DelayTime * 10; //convert to milliseconds
frameInfo.interlace = gifImage.ImageDesc.Interlace;
frameInfo.offset = QPoint(left, top);
QImage image(width, height, QImage::Format_Indexed8);
image.setOffset(QPoint(left, top)); //Maybe useful for some users.
image.setColorTable(colorTable);
if (transColorIndex != -1)
image.fill(transColorIndex);
else if (!globalColorTable.isEmpty())
image.fill(gifFile->SBackGroundColor); //!ToDo
if (gifImage.ImageDesc.Interlace) {
int line = 0;
for (int i = 0; i < 4; i++) {
for (int row = interlacedOffset[i]; row <height; row += interlacedJumps[i]) {
memcpy(image.scanLine(row), gifImage.RasterBits+line*width, width);
line ++;
}
}
} else {
for (int row = 0; row < height; row++) {
memcpy(image.scanLine(row), gifImage.RasterBits+row*width, width);
}
}
//Extract other data for the image.
if (idx == 0) {
if (gifImage.ExtensionBlockCount > 2) {
ExtensionBlock *extBlock = gifImage.ExtensionBlocks;
if (extBlock->Function == APPLICATION_EXT_FUNC_CODE && extBlock->ByteCount == 8) {
if (QByteArray((char *)extBlock->Bytes) == QByteArray("NETSCAPE2.0")) {
ExtensionBlock *block = gifImage.ExtensionBlocks+1;
if (block->ByteCount == 3) {
loopCount = uchar(block->Bytes[1])
+ uchar((block->Bytes[2])<<8);
}
}
}
}
}
frameInfo.image = image;
frameInfos.append(frameInfo);
}
DGifCloseFile(gifFile);
return true;
}
bool QGifImagePrivate::save(QIODevice *device) const
{
int error;
GifFileType *gifFile = EGifOpen(device, writeToIODevice, &error);
if (!gifFile) {
qWarning(GifErrorString(error));
return false;
}
QSize _canvasSize = getCanvasSize();
gifFile->SWidth = _canvasSize.width();
gifFile->SHeight = _canvasSize.height();
gifFile->SColorResolution = 8;
if (!globalColorTable.isEmpty()) {
gifFile->SColorMap = colorTableToColorMapObject(globalColorTable);
int idx = globalColorTable.indexOf(bgColor.rgba());
gifFile->SBackGroundColor = idx == -1 ? 0 : idx;
}
gifFile->ImageCount = frameInfos.size();
gifFile->SavedImages = (SavedImage *)calloc(frameInfos.size(), sizeof(SavedImage));
for (int idx=0; idx < frameInfos.size(); ++idx) {
const QGifFrameInfoData frameInfo = frameInfos.at(idx);
QImage image = frameInfo.image;
if (image.format() != QImage::Format_Indexed8) {
if (!globalColorTable.isEmpty())
image = image.convertToFormat(QImage::Format_Indexed8, globalColorTable);
else
image = image.convertToFormat(QImage::Format_Indexed8);
}
SavedImage *gifImage = gifFile->SavedImages + idx;
gifImage->ImageDesc.Left = frameInfo.offset.x();
gifImage->ImageDesc.Top = frameInfo.offset.y();
gifImage->ImageDesc.Width = image.width();
gifImage->ImageDesc.Height = image.height();
gifImage->ImageDesc.Interlace = frameInfo.interlace;
if (!image.colorTable().isEmpty() && (image.colorTable() != globalColorTable))
gifImage->ImageDesc.ColorMap = colorTableToColorMapObject(image.colorTable());
else
gifImage->ImageDesc.ColorMap = 0;
GifByteType *data = (GifByteType *)malloc(image.width() * image.height() * sizeof(GifByteType));
for (int row=0; row<image.height(); ++row) {
memcpy(data+row*image.width(), image.scanLine(row), image.width());
}
gifImage->RasterBits = data;
if (idx == 0) {
uchar data8[12] = "NETSCAPE2.0";
GifAddExtensionBlock(&gifImage->ExtensionBlockCount, &gifImage->ExtensionBlocks
, APPLICATION_EXT_FUNC_CODE, 11, data8);
uchar data[3];
data[0] = 0x01;
data[1] = loopCount & 0xFF;
data[2] = (loopCount >> 8) & 0xFF;
GifAddExtensionBlock(&gifImage->ExtensionBlockCount, &gifImage->ExtensionBlocks
, CONTINUE_EXT_FUNC_CODE, 3, data);
}
GraphicsControlBlock gcbBlock;
gcbBlock.DisposalMode = 0;
gcbBlock.UserInputFlag = false;
gcbBlock.TransparentColor = getFrameTransparentColorIndex(frameInfo);
if (frameInfo.delayTime != -1)
gcbBlock.DelayTime = frameInfo.delayTime / 10; //convert from milliseconds
else
gcbBlock.DelayTime = defaultDelayTime / 10;
EGifGCBToSavedExtension(&gcbBlock, gifFile, idx);
}
EGifSpew(gifFile);
//EGifCloseFile(gifFile);
return true;
}
/*!
\class QGifImage
\inmodule QtGifImage
\brief Class used to read/wirte .gif files.
*/
/*!
Constructs a gif image
*/
QGifImage::QGifImage()
:d_ptr(new QGifImagePrivate(this))
{
}
/*!
Constructs a gif image and tries to load the image from the
file with the given \a fileName
*/
QGifImage::QGifImage(const QString &fileName)
:d_ptr(new QGifImagePrivate(this))
{
load(fileName);
}
/*!
Constructs a gif image with the given \a size
*/
QGifImage::QGifImage(const QSize &size)
:d_ptr(new QGifImagePrivate(this))
{
d_ptr->canvasSize = size;
}
/*!
Destroys the gif image and cleans up.
*/
QGifImage::~QGifImage()
{
delete d_ptr;
}
/*!
Return global color table.
*/
QVector<QRgb> QGifImage::globalColorTable() const
{
Q_D(const QGifImage);
return d->globalColorTable;
}
/*!
Return background color of the gif canvas. It only makes sense when
global color table is not empty.
*/
QColor QGifImage::backgroundColor() const
{
Q_D(const QGifImage);
return d->bgColor;
}
/*!
Set the global color table \a colors and background color \a bgColor.
\a bgColor must be one the color in \a colors.
Unlike other image formats that support alpha (e.g. png), GIF does not
support semi-transparent pixels. So the alpha channel of the color table
will be ignored.
*/
void QGifImage::setGlobalColorTable(const QVector<QRgb> &colors, const QColor &bgColor)
{
Q_D(QGifImage);
d->globalColorTable = colors;
d->bgColor = bgColor;
}
/*!
Return the default delay in milliseconds. The default value is 1000 ms.
The time delay can be different for every frame.
*/
int QGifImage::defaultDelay() const
{
Q_D(const QGifImage);
return d->defaultDelayTime;
}
/*!
Set the default \a delay in milliseconds.
*/
void QGifImage::setDefaultDelay(int delay)
{
Q_D(QGifImage);
d->defaultDelayTime = delay;
}
/*!
Return the default transparent color.
The transparent color can be different for every frame.
*/
QColor QGifImage::defaultTransparentColor() const
{
Q_D(const QGifImage);
return d->defaultTransparentColor;
}
/*!
Set the default transparent \a color.
Unlike other image formats that support alpha (e.g. png), GIF does
not support semi-transparent pixels. The way to achieve transparency
is to set a color that will be transparent when rendering the GIF.
So, if you set the transparent color to black, the black pixels in
the gif file will be transparent.
*/
void QGifImage::setDefaultTransparentColor(const QColor &color)
{
Q_D(QGifImage);
d->defaultTransparentColor = color;
}
/*!
Return the loop count.
*/
int QGifImage::loopCount() const
{
Q_D(const QGifImage);
return d->loopCount;
}
/*!
Set the loop count. The default value of \a loop is 0, which means loop forever.
*/
void QGifImage::setLoopCount(int loop)
{
Q_D(QGifImage);
d->loopCount = loop;
}
/*!
Insert the QImage object \a frame at position \a index with \a delay.
As gif file only support indexed image, so all the \a frame will be converted
to the QImage::Format_Indexed8 format. Global color table will be used in the
convertion if it has been set.
QImage::offset() will be used when insert the QImage to the gif canvas.
*/
void QGifImage::insertFrame(int index, const QImage &frame, int delay)
{
Q_D(QGifImage);
QGifFrameInfoData data;
data.image = frame;
data.delayTime = delay;
data.offset = frame.offset();
d->frameInfos.insert(index, data);
}
/*!
\overload
Insert the QImage object \a frame at position \a index with the given \a offset and
\a delay.
As gif file only support indexed image, so all the \a frame will be converted
to the QImage::Format_Indexed8 format. Global color table will be used in the
convertion if it has been set.
*/
void QGifImage::insertFrame(int index, const QImage &frame, const QPoint &offset, int delay)
{
Q_D(QGifImage);
QGifFrameInfoData data;
data.image = frame;
data.delayTime = delay;
data.offset = offset;
d->frameInfos.insert(index, data);
}
/*!
Append the QImage object \a frame with \a delay.
As gif file only support indexed image, so all the \a frame will be converted
to the QImage::Format_Indexed8 format. Global color table will be used in the
convertion if it has been set.
QImage::offset() will be used when insert the QImage to the gif canvas.
*/
void QGifImage::addFrame(const QImage &frame, int delay)
{
Q_D(QGifImage);
QGifFrameInfoData data;
data.image = frame;
data.delayTime = delay;
data.offset = frame.offset();
d->frameInfos.append(data);
}
/*!
\overload
Append the QImage object \a frame with the given \a offset and \a delay.
*/
void QGifImage::addFrame(const QImage &frame, const QPoint& offset, int delay)
{
Q_D(QGifImage);
QGifFrameInfoData data;
data.image = frame;
data.delayTime = delay;
data.offset = offset;
d->frameInfos.append(data);
}
/*!
Return frame count contained in the gif file.
*/
int QGifImage::frameCount() const
{
Q_D(const QGifImage);
return d->frameInfos.count();
}
/*!
Return the image at \a index.
*/
QImage QGifImage::frame(int index) const
{
Q_D(const QGifImage);
if (index < 0 || index >= d->frameInfos.size())
return QImage();
return d->frameInfos[index].image;
}
/*!
Return the offset value of the frame at \a index
*/
QPoint QGifImage::frameOffset(int index) const
{
Q_D(const QGifImage);
if (index < 0 || index >= d->frameInfos.size())
return QPoint();
return d->frameInfos[index].offset;
}
/*!
Set the \a offset value for the frame at \a index
*/
void QGifImage::setFrameOffset(int index, const QPoint &offset)
{
Q_D(QGifImage);
if (index < 0 || index >= d->frameInfos.size())
return;
d->frameInfos[index].offset = offset;
}
/*!
Return the delay value of the frame at \a index
*/
int QGifImage::frameDelay(int index) const
{
Q_D(const QGifImage);
if (index < 0 || index >= d->frameInfos.size())
return -1;
return d->frameInfos[index].delayTime;
}
/*!
Set the \a delay value for the frame at \a index
*/
void QGifImage::setFrameDelay(int index, int delay)
{
Q_D(QGifImage);
if (index < 0 || index >= d->frameInfos.size())
return;
d->frameInfos[index].delayTime = delay;
}
/*!
Return the transparent color of the frame at \a index
*/
QColor QGifImage::frameTransparentColor(int index) const
{
Q_D(const QGifImage);
if (index < 0 || index >= d->frameInfos.size())
return QColor();
return d->frameInfos[index].transparentColor;
}
/*!
Sets the transparent \a color of the frame \a index. Unlike other image formats
that support alpha (e.g. PNG), GIF does not support semi-transparent pixels.
The way to achieve transparency is to set a color that will be transparent
when rendering the GIF. So, if you set the transparent color to black, the
black pixels in your gif file will be transparent.
*/
void QGifImage::setFrameTransparentColor(int index, const QColor &color)
{
Q_D(QGifImage);
if (index < 0 || index >= d->frameInfos.size())
return;
d->frameInfos[index].transparentColor = color;
}
/*!
Saves the gif image to the file with the given \a fileName.
Returns \c true if the image was successfully saved; otherwise
returns \c false.
*/
bool QGifImage::save(const QString &fileName) const
{
Q_D(const QGifImage);
QFile file(fileName);
if (file.open(QIODevice::WriteOnly))
return d->save(&file);
return false;
}
/*!
\overload
This function writes a QImage to the given \a device.
*/
bool QGifImage::save(QIODevice *device) const
{
Q_D(const QGifImage);
if (device->openMode() | QIODevice::WriteOnly)
return d->save(device);
return false;
}
/*!
Loads an gif image from the file with the given \a fileName. Returns \c true if
the image was successfully loaded; otherwise invalidates the image
and returns \c false.
*/
bool QGifImage::load(const QString &fileName)
{
Q_D(QGifImage);
QFile file(fileName);
if (file.open(QIODevice::ReadOnly))
return d->load(&file);
return false;
}
/*!
\overload
This function reads a gif image from the given \a device. This can,
for example, be used to load an image directly into a QByteArray.
*/
bool QGifImage::load(QIODevice *device)
{
Q_D(QGifImage);
if (device->openMode() | QIODevice::ReadOnly)
return d->load(device);
return false;
}

79
src/vendor/QtGifImage/gifimage/qgifimage.h vendored Normal file
View file

@ -0,0 +1,79 @@
/****************************************************************************
** Copyright (c) 2013 Debao Zhang <hello@debao.me>
** All right reserved.
**
** Permission is hereby granted, free of charge, to any person obtaining
** a copy of this software and associated documentation files (the
** "Software"), to deal in the Software without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Software, and to
** permit persons to whom the Software is furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be
** included in all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
** NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
** LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
** OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
** WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
**
****************************************************************************/
#ifndef QGIFIMAGE_H
#define QGIFIMAGE_H
#include "qgifglobal.h"
#include <QImage>
#include <QColor>
#include <QList>
#include <QVector>
class QGifImagePrivate;
class Q_GIFIMAGE_EXPORT QGifImage
{
Q_DECLARE_PRIVATE(QGifImage)
public:
QGifImage();
QGifImage(const QString &fileName);
QGifImage(const QSize &size);
~QGifImage();
QVector<QRgb> globalColorTable() const;
QColor backgroundColor() const;
void setGlobalColorTable(const QVector<QRgb> &colors, const QColor &bgColor = QColor());
int defaultDelay() const;
void setDefaultDelay(int internal);
QColor defaultTransparentColor() const;
void setDefaultTransparentColor(const QColor &color);
int loopCount() const;
void setLoopCount(int loop);
int frameCount() const;
QImage frame(int index) const;
void addFrame(const QImage &frame, int delay=-1);
void addFrame(const QImage &frame, const QPoint &offset, int delay=-1);
void insertFrame(int index, const QImage &frame, int delay=-1);
void insertFrame(int index, const QImage &frame, const QPoint &offset, int delay=-1);
QPoint frameOffset(int index) const;
void setFrameOffset(int index, const QPoint &offset);
int frameDelay(int index) const;
void setFrameDelay(int index, int delay);
QColor frameTransparentColor(int index) const;
void setFrameTransparentColor(int index, const QColor &color);
bool load(QIODevice *device);
bool load(const QString &fileName);
bool save(QIODevice *device) const;
bool save(const QString &fileName) const;
private:
QGifImagePrivate * const d_ptr;
};
#endif // QGIFIMAGE_H

74
src/vendor/QtGifImage/gifimage/qgifimage_p.h vendored Normal file
View file

@ -0,0 +1,74 @@
/****************************************************************************
** Copyright (c) 2013 Debao Zhang <hello@debao.me>
** All right reserved.
**
** Permission is hereby granted, free of charge, to any person obtaining
** a copy of this software and associated documentation files (the
** "Software"), to deal in the Software without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Software, and to
** permit persons to whom the Software is furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be
** included in all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
** NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
** LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
** OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
** WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
**
****************************************************************************/
#ifndef QGIFIMAGE_P_H
#define QGIFIMAGE_P_H
#include "qgifimage.h"
#include "gif_lib.h"
#include <QVector>
#include <QColor>
class QGifFrameInfoData
{
public:
QGifFrameInfoData()
:delayTime(-1), interlace(false)
{
}
QImage image;
QPoint offset; //offset info of QImage will lost when convert from One format to another.
int delayTime;
bool interlace;
QColor transparentColor;
};
class QGifImagePrivate
{
Q_DECLARE_PUBLIC(QGifImage)
public:
QGifImagePrivate(QGifImage *p);
~QGifImagePrivate();
bool load(QIODevice *device);
bool save(QIODevice *device) const;
QVector<QRgb> colorTableFromColorMapObject(ColorMapObject *object, int transColorIndex=-1) const;
ColorMapObject * colorTableToColorMapObject(QVector<QRgb> colorTable) const;
QSize getCanvasSize() const;
int getFrameTransparentColorIndex(const QGifFrameInfoData &info) const;
QSize canvasSize;
int loopCount;
int defaultDelayTime;
QColor defaultTransparentColor;
QVector<QRgb> globalColorTable;
QColor bgColor;
QList<QGifFrameInfoData> frameInfos;
QGifImage *q_ptr;
};
#endif // QGIFIMAGE_P_H

15
src/vendor/QtGifImage/gifimage/qtgifimage.pri vendored Normal file
View file

@ -0,0 +1,15 @@
INCLUDEPATH += $$PWD
DEPENDPATH += $$PWD
QT += core gui
!build_gifimage_lib:DEFINES += GIFIMAGE_NO_LIB
include($$PWD/../3rdParty/giflib.pri)
HEADERS += \
$$PWD/qgifglobal.h \
$$PWD/qgifimage.h \
$$PWD/qgifimage_p.h
SOURCES += \
$$PWD/qgifimage.cpp

3
src/vendor/QtGifImage/src.pro vendored Normal file
View file

@ -0,0 +1,3 @@
TEMPLATE = subdirs
SUBDIRS = gifimage