Add export to animated GIF, wrt GH-9
This commit is contained in:
Gavin MacGregor
45
3rdparty/QtGifImage/.gitignore
vendored
Normal file
45
3rdparty/QtGifImage/.gitignore
vendored
Normal file
@@ -0,0 +1,45 @@
|
||||
syntax: glob
|
||||
*.pro.user*
|
||||
*.autosave
|
||||
*.app
|
||||
*.moc
|
||||
*.prl
|
||||
Makefile*
|
||||
doc/html/
|
||||
*.framework/
|
||||
*.xcodeproj/
|
||||
debug/
|
||||
release/
|
||||
qtc-gdbmacros/
|
||||
*.rej
|
||||
*.orig
|
||||
*.obj
|
||||
*.swp
|
||||
*.dll
|
||||
*.exp
|
||||
*.ilk
|
||||
*.pdb
|
||||
*.lib
|
||||
Thumbs.db
|
||||
moc_*.cpp
|
||||
qrc_*.cpp
|
||||
*.o
|
||||
*.so.*
|
||||
*.so
|
||||
*.pdb
|
||||
ui_*.h
|
||||
*~
|
||||
.qmake.cache
|
||||
lib/*
|
||||
*.orig
|
||||
*.exe
|
||||
*.vcproj
|
||||
*.vcproj.*.user
|
||||
*_resource.rc
|
||||
*.sln
|
||||
*.idb
|
||||
*.ncb
|
||||
*.suo
|
||||
|
||||
*.zip
|
||||
*.xlsx
|
||||
32
3rdparty/QtGifImage/CMakeLists.txt
vendored
Normal file
32
3rdparty/QtGifImage/CMakeLists.txt
vendored
Normal file
@@ -0,0 +1,32 @@
|
||||
cmake_minimum_required(VERSION 3.5...3.16)
|
||||
project(QtGifImage)
|
||||
|
||||
set(CMAKE_CXX_STANDARD 17)
|
||||
|
||||
find_package(QT NAMES Qt6 REQUIRED COMPONENTS Core Gui)
|
||||
find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS Core Gui)
|
||||
|
||||
set(LIB_LIBRARIES Qt${QT_VERSION_MAJOR}::Core Qt${QT_VERSION_MAJOR}::Gui)
|
||||
|
||||
set(GIF_IMAGE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include/gifimage)
|
||||
set(GIF_LIB_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include/3rdparty/giflib)
|
||||
|
||||
# Next line was "add_library(${PROJECT_NAME} SHARED"
|
||||
# but it breaks MXE static compilation
|
||||
add_library(${PROJECT_NAME}
|
||||
${GIF_IMAGE_DIR}/qgifglobal.h ${GIF_IMAGE_DIR}/qgifimage.cpp
|
||||
${GIF_IMAGE_DIR}/qgifimage.h ${GIF_IMAGE_DIR}/qgifimage_p.h
|
||||
|
||||
${GIF_LIB_DIR}/dgif_lib.c ${GIF_LIB_DIR}/egif_lib.c
|
||||
${GIF_LIB_DIR}/gif_err.c ${GIF_LIB_DIR}/gif_font.c
|
||||
${GIF_LIB_DIR}/gif_hash.c ${GIF_LIB_DIR}/gif_hash.h
|
||||
${GIF_LIB_DIR}/gif_lib.h ${GIF_LIB_DIR}/gif_lib_private.h
|
||||
${GIF_LIB_DIR}/gifalloc.c ${GIF_LIB_DIR}/quantize.c
|
||||
)
|
||||
|
||||
add_library(${PROJECT_NAME}::${PROJECT_NAME} ALIAS ${PROJECT_NAME})
|
||||
|
||||
target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
|
||||
target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include/3rdparty)
|
||||
|
||||
target_link_libraries(${PROJECT_NAME} PRIVATE ${LIB_LIBRARIES})
|
||||
36
3rdparty/QtGifImage/include/3rdparty/giflib/AUTHORS
vendored
Normal file
36
3rdparty/QtGifImage/include/3rdparty/giflib/AUTHORS
vendored
Normal 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
3rdparty/QtGifImage/include/3rdparty/giflib/COPYING
vendored
Normal file
19
3rdparty/QtGifImage/include/3rdparty/giflib/COPYING
vendored
Normal 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
3rdparty/QtGifImage/include/3rdparty/giflib/README
vendored
Normal file
27
3rdparty/QtGifImage/include/3rdparty/giflib/README
vendored
Normal 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.
|
||||
|
||||
1135
3rdparty/QtGifImage/include/3rdparty/giflib/dgif_lib.c
vendored
Normal file
1135
3rdparty/QtGifImage/include/3rdparty/giflib/dgif_lib.c
vendored
Normal file
File diff suppressed because it is too large
Load Diff
1175
3rdparty/QtGifImage/include/3rdparty/giflib/egif_lib.c
vendored
Normal file
1175
3rdparty/QtGifImage/include/3rdparty/giflib/egif_lib.c
vendored
Normal file
File diff suppressed because it is too large
Load Diff
67
3rdparty/QtGifImage/include/3rdparty/giflib/gif_err.c
vendored
Normal file
67
3rdparty/QtGifImage/include/3rdparty/giflib/gif_err.c
vendored
Normal file
@@ -0,0 +1,67 @@
|
||||
/*****************************************************************************
|
||||
|
||||
gif_err.c - handle error reporting for the GIF library.
|
||||
|
||||
****************************************************************************/
|
||||
|
||||
#include <giflib/gif_lib.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;
|
||||
}
|
||||
246
3rdparty/QtGifImage/include/3rdparty/giflib/gif_font.c
vendored
Normal file
246
3rdparty/QtGifImage/include/3rdparty/giflib/gif_font.c
vendored
Normal file
@@ -0,0 +1,246 @@
|
||||
/*****************************************************************************
|
||||
|
||||
gif_font.c - utility font handling and simple drawing for the GIF library
|
||||
|
||||
****************************************************************************/
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include <giflib/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 = (int)(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);
|
||||
}
|
||||
121
3rdparty/QtGifImage/include/3rdparty/giflib/gif_hash.c
vendored
Normal file
121
3rdparty/QtGifImage/include/3rdparty/giflib/gif_hash.c
vendored
Normal file
@@ -0,0 +1,121 @@
|
||||
/*****************************************************************************
|
||||
|
||||
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 <string.h>
|
||||
|
||||
#include <giflib/gif_hash.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 (int)(((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 */
|
||||
39
3rdparty/QtGifImage/include/3rdparty/giflib/gif_hash.h
vendored
Normal file
39
3rdparty/QtGifImage/include/3rdparty/giflib/gif_hash.h
vendored
Normal file
@@ -0,0 +1,39 @@
|
||||
/******************************************************************************
|
||||
|
||||
gif_hash.h - magfic constants and declarations for GIF LZW
|
||||
|
||||
******************************************************************************/
|
||||
|
||||
#ifndef GIF_LIB_GIF_HASH_H_
|
||||
#define GIF_LIB_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_LIB_GIF_HASH_H_
|
||||
319
3rdparty/QtGifImage/include/3rdparty/giflib/gif_lib.h
vendored
Normal file
319
3rdparty/QtGifImage/include/3rdparty/giflib/gif_lib.h
vendored
Normal file
@@ -0,0 +1,319 @@
|
||||
/******************************************************************************
|
||||
|
||||
gif_lib.h - service library for decoding and encoding GIF images
|
||||
|
||||
*****************************************************************************/
|
||||
|
||||
#ifndef GIF_LIB_GIF_LIB_H_
|
||||
#define GIF_LIB_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>
|
||||
|
||||
#define BOOL int
|
||||
#define TRUE 1
|
||||
#define FALSE 0
|
||||
|
||||
//#ifdef _MSC_VER
|
||||
//#define BOOL int
|
||||
//#define TRUE 1
|
||||
//#define FALSE 0
|
||||
//#else
|
||||
//#include <stdbool.h>
|
||||
//#define BOOL int
|
||||
//#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
|
||||
******************************************************************************/
|
||||
|
||||
#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 */
|
||||
#define NO_TRANSPARENT_COLOR (-1)
|
||||
|
||||
typedef struct GraphicsControlBlock {
|
||||
int DisposalMode;
|
||||
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 */
|
||||
} GraphicsControlBlock;
|
||||
|
||||
/******************************************************************************
|
||||
GIF encoding routines
|
||||
******************************************************************************/
|
||||
|
||||
/* Main entry points */
|
||||
GifFileType *EGifOpenFileName(const char *GifFileName,
|
||||
BOOL GifTestExistence, int *Error);
|
||||
GifFileType *EGifOpenFileHandle(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);
|
||||
int EGifCloseFile1(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,
|
||||
int GifWidth, int GifHeight,
|
||||
int GifColorRes, int GifBackGround,
|
||||
const ColorMapObject *GifColorMap);
|
||||
int EGifPutImageDesc(GifFileType *GifFile,
|
||||
int GifLeft, int GifTop,
|
||||
int GifWidth, int GifHeight,
|
||||
BOOL GifInterlace,
|
||||
const ColorMapObject *GifColorMap);
|
||||
void EGifSetGifVersion(GifFileType *GifFile, BOOL gif89);
|
||||
int EGifPutLine(GifFileType *GifFile, GifPixelType *GifLine,
|
||||
int GifLineLen);
|
||||
int EGifPutPixel(GifFileType *GifFile, GifPixelType GifPixel);
|
||||
int EGifPutComment(GifFileType *GifFile, const char *GifComment);
|
||||
int EGifPutExtensionLeader(GifFileType *GifFile, int GifExtCode);
|
||||
int EGifPutExtensionBlock(GifFileType *GifFile,
|
||||
int GifExtLen, const void *GifExtension);
|
||||
int EGifPutExtensionTrailer(GifFileType *GifFile);
|
||||
int EGifPutExtension(GifFileType *GifFile, int GifExtCode,
|
||||
int GifExtLen,
|
||||
const void *GifExtension);
|
||||
int EGifPutCode(GifFileType *GifFile, 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, const GifByteType *RedInput,
|
||||
const GifByteType *GreenInput, const 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, const 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 void FreeLastSavedImage(GifFileType *GifFile);
|
||||
extern SavedImage *GifMakeSavedImage(GifFileType *GifFile,
|
||||
const SavedImage *CopyFrom);
|
||||
extern void GifFreeSavedImages(GifFileType *GifFile);
|
||||
|
||||
/******************************************************************************
|
||||
5.x functions for GIF89 graphics control blocks
|
||||
******************************************************************************/
|
||||
|
||||
int DGifExtensionToGCB(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,
|
||||
int x, int y,
|
||||
const char *legend, int color);
|
||||
|
||||
extern void GifDrawBox(SavedImage *Image,
|
||||
int x, int y,
|
||||
int w, int d, int color);
|
||||
|
||||
extern void GifDrawRectangle(SavedImage *Image,
|
||||
int x, int y,
|
||||
int w, int d, int color);
|
||||
|
||||
extern void GifDrawBoxedText8x8(SavedImage *Image,
|
||||
int x, int y,
|
||||
const char *legend,
|
||||
int border, int bg, int fg);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
#endif // GIF_LIB_GIF_LIB_H_
|
||||
59
3rdparty/QtGifImage/include/3rdparty/giflib/gif_lib_private.h
vendored
Normal file
59
3rdparty/QtGifImage/include/3rdparty/giflib/gif_lib_private.h
vendored
Normal file
@@ -0,0 +1,59 @@
|
||||
/****************************************************************************
|
||||
|
||||
gif_lib_private.h - internal giflib routines and structures
|
||||
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef GIF_LIB_GIF_LIB_PRIVATE_H_
|
||||
#define GIF_LIB_GIF_LIB_PRIVATE_H_
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include <giflib/gif_lib.h>
|
||||
#include <giflib/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_GIF_LIB_PRIVATE_H_
|
||||
393
3rdparty/QtGifImage/include/3rdparty/giflib/gifalloc.c
vendored
Normal file
393
3rdparty/QtGifImage/include/3rdparty/giflib/gifalloc.c
vendored
Normal file
@@ -0,0 +1,393 @@
|
||||
/*****************************************************************************
|
||||
|
||||
GIF construction tools
|
||||
|
||||
****************************************************************************/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <giflib/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 NULL;
|
||||
}
|
||||
|
||||
Object = (ColorMapObject *)malloc(sizeof(ColorMapObject));
|
||||
if (Object == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
Object->Colors = (GifColorType *)calloc(ColorCount, sizeof(GifColorType));
|
||||
if (Object->Colors == NULL) {
|
||||
free(Object);
|
||||
return 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 && Object->Colors != NULL) {
|
||||
free(Object->Colors);
|
||||
}
|
||||
if (Object) {
|
||||
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 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, const 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 = (int)(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++) {
|
||||
free((char *)ep->Bytes);
|
||||
}
|
||||
|
||||
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 != NULL && 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 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 NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* next, the raster */
|
||||
sp->RasterBits = (unsigned char *)malloc(sizeof(GifPixelType) *
|
||||
CopyFrom->ImageDesc.Height *
|
||||
CopyFrom->ImageDesc.Width);
|
||||
if (sp->RasterBits == NULL) {
|
||||
FreeLastSavedImage(GifFile);
|
||||
return 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 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 != NULL && sp->RasterBits != NULL) {
|
||||
free((char *)sp->RasterBits);
|
||||
}
|
||||
|
||||
GifFreeExtensions(&sp->ExtensionBlockCount, &sp->ExtensionBlocks);
|
||||
}
|
||||
|
||||
free((char *)GifFile->SavedImages);
|
||||
GifFile->SavedImages = NULL;
|
||||
}
|
||||
308
3rdparty/QtGifImage/include/3rdparty/giflib/quantize.c
vendored
Normal file
308
3rdparty/QtGifImage/include/3rdparty/giflib/quantize.c
vendored
Normal file
@@ -0,0 +1,308 @@
|
||||
/*****************************************************************************
|
||||
|
||||
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 <giflib/gif_lib.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,
|
||||
const GifByteType *RedInput,
|
||||
const GifByteType *GreenInput,
|
||||
const 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 = (int)(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 = (int)(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 = (int)(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 = (int)(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 = (long int)(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];
|
||||
}
|
||||
40
3rdparty/QtGifImage/include/gifimage/qgifglobal.h
vendored
Normal file
40
3rdparty/QtGifImage/include/gifimage/qgifglobal.h
vendored
Normal file
@@ -0,0 +1,40 @@
|
||||
/****************************************************************************
|
||||
** 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 GIF_IMAGE_Q_GIF_GLOBAL_H_
|
||||
#define GIF_IMAGE_Q_GIF_GLOBAL_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 // GIF_IMAGE_Q_GIF_GLOBAL_H_
|
||||
668
3rdparty/QtGifImage/include/gifimage/qgifimage.cpp
vendored
Normal file
668
3rdparty/QtGifImage/include/gifimage/qgifimage.cpp
vendored
Normal file
@@ -0,0 +1,668 @@
|
||||
/****************************************************************************
|
||||
** 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 <gifimage/qgifimage.h>
|
||||
#include <gifimage/qgifimage_p.h>
|
||||
|
||||
#include <QFile>
|
||||
#include <QImage>
|
||||
#include <QDebug>
|
||||
#include <QScopedPointer>
|
||||
|
||||
namespace {
|
||||
|
||||
int writeToIODevice(GifFileType *gifFile, const GifByteType *data,
|
||||
int maxSize) {
|
||||
return static_cast<int>(
|
||||
static_cast<QIODevice *>(
|
||||
gifFile->UserData)->write(
|
||||
reinterpret_cast<const char *>(data), maxSize));
|
||||
}
|
||||
|
||||
int readFromIODevice(GifFileType *gifFile, GifByteType *data, int maxSize) {
|
||||
return static_cast<int>(
|
||||
static_cast<QIODevice *>(
|
||||
gifFile->UserData)->read(
|
||||
reinterpret_cast<char *>(data), maxSize));
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
QGifImagePrivate::QGifImagePrivate(QGifImage *p)
|
||||
: loopCount(0), defaultDelayTime(1000), q_ptr(p) {}
|
||||
|
||||
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 nullptr;
|
||||
|
||||
auto cmap = (ColorMapObject *)malloc(sizeof(ColorMapObject));
|
||||
// num of colors must be a power of 2
|
||||
int numColors = 1 << GifBitSize(static_cast<int>(colorTable.size()));
|
||||
cmap->ColorCount = numColors;
|
||||
// Maybe a bug of giflib, BitsPerPixel is used as size of the color table
|
||||
// size.
|
||||
cmap->BitsPerPixel = GifBitSize(static_cast<int>(colorTable.size())); // Todo!
|
||||
cmap->SortFlag = false;
|
||||
|
||||
auto 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 {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 = static_cast<int>(frameInfo.image.colorTable().indexOf(transColor.rgb()));
|
||||
else if (!globalColorTable.isEmpty())
|
||||
index = static_cast<int>(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) {
|
||||
char *temp = GifErrorString(error);
|
||||
qWarning("%s", temp);
|
||||
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) {
|
||||
char *temp = GifErrorString(error);
|
||||
qWarning("%s", temp);
|
||||
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 = static_cast<int>(globalColorTable.indexOf(bgColor.rgba()));
|
||||
gifFile->SBackGroundColor = idx == -1 ? 0 : idx;
|
||||
}
|
||||
|
||||
gifFile->ImageCount = static_cast<int>(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 = nullptr;
|
||||
|
||||
auto 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_char[3];
|
||||
data_char[0] = 0x01;
|
||||
data_char[1] = loopCount & 0xFF;
|
||||
data_char[2] = (loopCount >> 8) & 0xFF;
|
||||
GifAddExtensionBlock(&gifImage->ExtensionBlockCount,
|
||||
&gifImage->ExtensionBlocks, CONTINUE_EXT_FUNC_CODE,
|
||||
3, data_char);
|
||||
}
|
||||
|
||||
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);
|
||||
|
||||
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 static_cast<int>(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 {};
|
||||
|
||||
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 {};
|
||||
|
||||
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 {};
|
||||
|
||||
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)) {
|
||||
bool res = d->save(&file);
|
||||
// d->~QGifImagePrivate();
|
||||
// delete d;
|
||||
return res;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
89
3rdparty/QtGifImage/include/gifimage/qgifimage.h
vendored
Normal file
89
3rdparty/QtGifImage/include/gifimage/qgifimage.h
vendored
Normal file
@@ -0,0 +1,89 @@
|
||||
/****************************************************************************
|
||||
** 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 GIF_IMAGE_Q_GIF_IMAGE_H_
|
||||
#define GIF_IMAGE_Q_GIF_IMAGE_H_
|
||||
|
||||
#include <gifimage/qgifglobal.h>
|
||||
|
||||
#include <QList>
|
||||
#include <QImage>
|
||||
#include <QColor>
|
||||
#include <QVector>
|
||||
|
||||
class QGifImagePrivate;
|
||||
|
||||
class QGifImage {
|
||||
Q_DECLARE_PRIVATE(QGifImage)
|
||||
|
||||
public:
|
||||
QGifImage();
|
||||
explicit QGifImage(const QString &fileName);
|
||||
explicit QGifImage(const QSize &size);
|
||||
|
||||
~QGifImage();
|
||||
|
||||
public:
|
||||
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 // GIF_IMAGE_Q_GIF_IMAGE_H_
|
||||
75
3rdparty/QtGifImage/include/gifimage/qgifimage_p.h
vendored
Normal file
75
3rdparty/QtGifImage/include/gifimage/qgifimage_p.h
vendored
Normal file
@@ -0,0 +1,75 @@
|
||||
/****************************************************************************
|
||||
** 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 GIF_IMAGE_Q_GIF_IMAGE_P_H_
|
||||
#define GIF_IMAGE_Q_GIF_IMAGE_P_H_
|
||||
|
||||
#include <giflib/gif_lib.h>
|
||||
#include <gifimage/qgifimage.h>
|
||||
|
||||
#include <QVector>
|
||||
#include <QColor>
|
||||
|
||||
struct QGifFrameInfoData {
|
||||
QGifFrameInfoData() : delayTime(-1), interlace(false) {}
|
||||
|
||||
public:
|
||||
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:
|
||||
explicit QGifImagePrivate(QGifImage *p);
|
||||
~QGifImagePrivate() = default;
|
||||
|
||||
public:
|
||||
bool load(QIODevice *device);
|
||||
bool save(QIODevice *device) const;
|
||||
|
||||
QVector<QRgb> colorTableFromColorMapObject(ColorMapObject *object, int transColorIndex = -1) const;
|
||||
[[nodiscard]] ColorMapObject *colorTableToColorMapObject(QVector<QRgb> colorTable) const;
|
||||
|
||||
[[nodiscard]] QSize getCanvasSize() const;
|
||||
[[nodiscard]] int getFrameTransparentColorIndex(const QGifFrameInfoData &info) const;
|
||||
|
||||
public:
|
||||
QSize canvasSize;
|
||||
int loopCount;
|
||||
int defaultDelayTime;
|
||||
QColor defaultTransparentColor;
|
||||
|
||||
QVector<QRgb> globalColorTable;
|
||||
QColor bgColor;
|
||||
QList<QGifFrameInfoData> frameInfos;
|
||||
|
||||
QGifImage *q_ptr;
|
||||
};
|
||||
|
||||
#endif // GIF_IMAGE_Q_GIF_IMAGE_P_H_
|
||||
@@ -15,10 +15,12 @@ qt_standard_project_setup()
|
||||
|
||||
add_subdirectory(src/qteletextdecoder)
|
||||
|
||||
add_subdirectory(3rdparty/QtGifImage)
|
||||
|
||||
file (GLOB SOURCES src/qteletextmaker/*.cpp)
|
||||
qt_add_executable(qteletextmaker ${SOURCES} src/qteletextmaker/actionicons.qrc)
|
||||
|
||||
target_link_libraries(qteletextmaker PRIVATE qteletextdecoder Qt::Widgets)
|
||||
target_link_libraries(qteletextmaker PRIVATE QtGifImage::QtGifImage qteletextdecoder Qt::Widgets)
|
||||
|
||||
set_target_properties(qteletextmaker PROPERTIES
|
||||
WIN32_EXECUTABLE ON
|
||||
|
||||
@@ -140,13 +140,18 @@ void TeletextWidget::timerEvent(QTimerEvent *event)
|
||||
QWidget::timerEvent(event);
|
||||
}
|
||||
|
||||
void TeletextWidget::pauseFlash(bool pauseNow)
|
||||
void TeletextWidget::pauseFlash(int p)
|
||||
{
|
||||
if (pauseNow && m_flashTiming != 0) {
|
||||
if (m_flashTiming != 0) {
|
||||
m_flashTimer.stop();
|
||||
m_flashPhase = 0;
|
||||
m_flashPhase = p;
|
||||
update();
|
||||
} else if (m_flashTiming != 0)
|
||||
}
|
||||
}
|
||||
|
||||
void TeletextWidget::resumeFlash()
|
||||
{
|
||||
if (m_flashTiming != 0)
|
||||
m_flashTimer.start((m_flashTiming == 1) ? 500 : 167, this);
|
||||
}
|
||||
|
||||
|
||||
@@ -48,6 +48,7 @@ public:
|
||||
bool insertMode() const { return m_insertMode; };
|
||||
void setInsertMode(bool insertMode);
|
||||
bool showControlCodes() const { return m_pageRender.showControlCodes(); };
|
||||
int flashTiming() const { return m_flashTiming; };
|
||||
|
||||
QSize sizeHint() { return QSize(480+(pageDecode()->leftSidePanelColumns()+pageDecode()->rightSidePanelColumns())*12, 250); }
|
||||
|
||||
@@ -68,7 +69,8 @@ public slots:
|
||||
void setShowControlCodes(bool showControlCodes);
|
||||
void setRenderMode(TeletextPageRender::RenderMode renderMode);
|
||||
void updateFlashTimer(int newFlashTimer);
|
||||
void pauseFlash(bool pauseNow);
|
||||
void pauseFlash(int p);
|
||||
void resumeFlash();
|
||||
|
||||
void setControlBit(int bitNumber, bool active);
|
||||
void setDefaultCharSet(int newDefaultCharSet);
|
||||
|
||||
@@ -50,6 +50,8 @@
|
||||
#include "palettedockwidget.h"
|
||||
#include "x26dockwidget.h"
|
||||
|
||||
#include "gifimage/qgifimage.h"
|
||||
|
||||
MainWindow::MainWindow()
|
||||
{
|
||||
init();
|
||||
@@ -179,49 +181,132 @@ void MainWindow::reload()
|
||||
m_textWidget->document()->selectSubPageIndex(subPageIndex, true);
|
||||
}
|
||||
|
||||
void MainWindow::exportPNG()
|
||||
void MainWindow::exportImage()
|
||||
{
|
||||
QString exportFileName = QFileDialog::getSaveFileName(this, tr("Export PNG"), QString(), "PNG image (*.png)");
|
||||
QString exportFileName, selectedFilter, gifFilter;
|
||||
|
||||
if (!m_exportImageFileName.isEmpty())
|
||||
exportFileName = m_exportImageFileName;
|
||||
else {
|
||||
// Image not exported before: suggest a filename with image extension
|
||||
// If page has flashing, suggest GIF
|
||||
exportFileName = m_curFile;
|
||||
if (m_textWidget->flashTiming() != 0)
|
||||
changeSuffixFromTTI(exportFileName, "gif");
|
||||
else
|
||||
changeSuffixFromTTI(exportFileName, "png");
|
||||
}
|
||||
|
||||
if (m_textWidget->flashTiming() != 0)
|
||||
gifFilter = "Animated GIF image (*.gif)";
|
||||
else
|
||||
gifFilter = "GIF image (*.gif)";
|
||||
|
||||
// Set the filter in the file dialog to the same as the current filename extension
|
||||
if (QFileInfo(exportFileName).suffix().toLower() == "gif")
|
||||
selectedFilter = gifFilter;
|
||||
else
|
||||
selectedFilter = "PNG image (*.png)";
|
||||
|
||||
exportFileName = QFileDialog::getSaveFileName(this, tr("Export image"), exportFileName, "PNG image (*.png);;" + gifFilter, &selectedFilter);
|
||||
if (exportFileName.isEmpty())
|
||||
return;
|
||||
|
||||
const QString suffix = QFileInfo(exportFileName).suffix().toLower();
|
||||
|
||||
if (suffix.isEmpty()) {
|
||||
QMessageBox::warning(this, QApplication::applicationDisplayName(), tr("No filename extension specified."));
|
||||
return;
|
||||
} else if (suffix != "png" && suffix != "gif") {
|
||||
QMessageBox::warning(this, QApplication::applicationDisplayName(), tr("Cannot export image of format %1.").arg(suffix));
|
||||
return;
|
||||
}
|
||||
|
||||
// Disable flash exporting if extension is not GIF
|
||||
const int flashTiming = suffix == "gif" ? m_textWidget->flashTiming() : 0;
|
||||
|
||||
// Prepare widget image for extraction
|
||||
m_textWidget->pauseFlash(true);
|
||||
m_textScene->hideGUIElements(true);
|
||||
// Disable exporting in Mix mode as it corrupts the background
|
||||
bool reMix = m_textWidget->pageRender()->renderMode() == TeletextPageRender::RenderMix;
|
||||
if (reMix)
|
||||
m_textScene->setRenderMode(TeletextPageRender::RenderNormal);
|
||||
|
||||
// Extract the image from the scene
|
||||
QImage interImage = QImage(m_textScene->sceneRect().size().toSize(), QImage::Format_RGB32);
|
||||
// This ought to make the background transparent in Mix mode, but it doesn't
|
||||
// if (m_textWidget->pageDecode()->mix())
|
||||
// interImage.fill(QColor(0, 0, 0, 0));
|
||||
QPainter interPainter(&interImage);
|
||||
m_textScene->render(&interPainter);
|
||||
// Allocate initial image, with additional images for flashing if necessary
|
||||
QImage interImage[6];
|
||||
|
||||
interImage[0] = QImage(m_textScene->sceneRect().size().toSize(), QImage::Format_RGB32);
|
||||
if (flashTiming != 0) {
|
||||
interImage[3] = QImage(m_textScene->sceneRect().size().toSize(), QImage::Format_RGB32);
|
||||
if (flashTiming == 2) {
|
||||
interImage[1] = QImage(m_textScene->sceneRect().size().toSize(), QImage::Format_RGB32);
|
||||
interImage[2] = QImage(m_textScene->sceneRect().size().toSize(), QImage::Format_RGB32);
|
||||
interImage[4] = QImage(m_textScene->sceneRect().size().toSize(), QImage::Format_RGB32);
|
||||
interImage[5] = QImage(m_textScene->sceneRect().size().toSize(), QImage::Format_RGB32);
|
||||
}
|
||||
}
|
||||
|
||||
// Now extract the image(s) from the scene
|
||||
for (int p=0; p<6; p++)
|
||||
if (!interImage[p].isNull()) {
|
||||
m_textWidget->pauseFlash(p);
|
||||
// This ought to make the background transparent in Mix mode, but it doesn't
|
||||
// if (m_textWidget->pageDecode()->mix())
|
||||
// interImage.fill(QColor(0, 0, 0, 0));
|
||||
QPainter interPainter(&interImage[p]);
|
||||
m_textScene->render(&interPainter);
|
||||
}
|
||||
|
||||
// Now we've extracted the image we can put the GUI things back
|
||||
m_textScene->hideGUIElements(false);
|
||||
if (reMix)
|
||||
m_textScene->setRenderMode(TeletextPageRender::RenderMix);
|
||||
m_textWidget->pauseFlash(false);
|
||||
m_textWidget->resumeFlash();
|
||||
|
||||
// Now scale the extracted image to the selected aspect ratio
|
||||
// We do this in two steps so that anti-aliasing only occurs on vertical lines
|
||||
// Now scale the extracted image(s) to the selected aspect ratio
|
||||
QImage scaledImage[6];
|
||||
|
||||
// Double the vertical height first
|
||||
const QImage doubleHeightImage = interImage.scaled(interImage.width(), interImage.height()*2, Qt::IgnoreAspectRatio, Qt::FastTransformation);
|
||||
for (int p=0; p<6; p++)
|
||||
if (!interImage[p].isNull())
|
||||
if (m_viewAspectRatio == 3)
|
||||
// Aspect ratio is Pixel 1:2 so we only need to double the vertical height
|
||||
scaledImage[p] = interImage[p].scaled(interImage[p].width(), interImage[p].height()*2, Qt::IgnoreAspectRatio, Qt::FastTransformation);
|
||||
else {
|
||||
// Scale the image in two steps so that smoothing only occurs on vertical lines
|
||||
// Double the vertical height first
|
||||
const QImage doubleHeightImage = interImage[p].scaled(interImage[p].width(), interImage[p].height()*2, Qt::IgnoreAspectRatio, Qt::FastTransformation);
|
||||
// then scale it horizontally to the selected aspect ratio
|
||||
// Don't smooth GIF as it's bound to break the 256 colour limit
|
||||
scaledImage[p] = doubleHeightImage.scaled((int)((float)doubleHeightImage.width() * aspectRatioHorizontalScaling[m_viewAspectRatio] * 2), doubleHeightImage.height(), Qt::IgnoreAspectRatio, (suffix == "gif") ? Qt::FastTransformation : Qt::SmoothTransformation);
|
||||
}
|
||||
|
||||
// If aspect ratio is Pixel 1:2 we're already at the correct scale
|
||||
if (m_viewAspectRatio != 3) {
|
||||
// Scale it horizontally to the selected aspect ratio
|
||||
const QImage scaledImage = doubleHeightImage.scaled((int)((float)doubleHeightImage.width() * aspectRatioHorizontalScaling[m_viewAspectRatio] * 2), doubleHeightImage.height(), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
|
||||
if (suffix == "png") {
|
||||
if (scaledImage[0].save(exportFileName, "PNG"))
|
||||
m_exportImageFileName = exportFileName;
|
||||
else
|
||||
QMessageBox::warning(this, QApplication::applicationDisplayName(), tr("Cannot export image %1.").arg(QDir::toNativeSeparators(exportFileName)));
|
||||
}
|
||||
|
||||
if (!scaledImage.save(exportFileName, "PNG"))
|
||||
QMessageBox::warning(this, QApplication::applicationDisplayName(), tr("Cannot export file %1.").arg(QDir::toNativeSeparators(exportFileName)));
|
||||
} else if (!doubleHeightImage.save(exportFileName, "PNG"))
|
||||
QMessageBox::warning(this, QApplication::applicationDisplayName(), tr("Cannot export file %1.").arg(QDir::toNativeSeparators(exportFileName)));
|
||||
if (suffix == "gif") {
|
||||
QGifImage gif(scaledImage[0].size());
|
||||
|
||||
if (scaledImage[3].isNull())
|
||||
// No flashing
|
||||
gif.addFrame(scaledImage[0], 0);
|
||||
else if (interImage[1].isNull()) {
|
||||
// 1Hz flashing
|
||||
gif.addFrame(scaledImage[0], 500);
|
||||
gif.addFrame(scaledImage[3], 500);
|
||||
} else
|
||||
// 2Hz flashing
|
||||
for (int p=0; p<6; p++)
|
||||
gif.addFrame(scaledImage[p], (p % 3 == 0) ? 166 : 167);
|
||||
|
||||
if (gif.save(exportFileName))
|
||||
m_exportImageFileName = exportFileName;
|
||||
else
|
||||
QMessageBox::warning(this, QApplication::applicationDisplayName(), tr("Cannot export image %1.").arg(QDir::toNativeSeparators(exportFileName)));
|
||||
}
|
||||
}
|
||||
|
||||
void MainWindow::exportZXNet()
|
||||
@@ -391,9 +476,9 @@ void MainWindow::createActions()
|
||||
exportEditTFAct->setStatusTip("Export and open this subpage in the edit.tf online editor");
|
||||
connect(exportEditTFAct, &QAction::triggered, this, &MainWindow::exportEditTF);
|
||||
|
||||
QAction *exportPNGAct = fileMenu->addAction(tr("Export subpage as PNG..."));
|
||||
exportPNGAct->setStatusTip("Export a PNG image of this subpage");
|
||||
connect(exportPNGAct, &QAction::triggered, this, &MainWindow::exportPNG);
|
||||
QAction *exportImageAct = fileMenu->addAction(tr("Export subpage as image..."));
|
||||
exportImageAct->setStatusTip("Export an image of this subpage");
|
||||
connect(exportImageAct, &QAction::triggered, this, &MainWindow::exportImage);
|
||||
|
||||
QAction *exportM29Act = fileMenu->addAction(tr("Export subpage X/28 as M/29..."));
|
||||
exportM29Act->setStatusTip("Export this subpage's X/28 packets as a tti file with M/29 packets");
|
||||
|
||||
@@ -64,7 +64,7 @@ private slots:
|
||||
void exportT42(bool fromAuto);
|
||||
void exportZXNet();
|
||||
void exportEditTF();
|
||||
void exportPNG();
|
||||
void exportImage();
|
||||
void exportM29();
|
||||
void updateRecentFileActions();
|
||||
void updateExportAutoAction();
|
||||
@@ -136,7 +136,7 @@ private:
|
||||
QPushButton *m_insertModePushButton;
|
||||
QRadioButton *m_levelRadioButton[4];
|
||||
|
||||
QString m_curFile, m_exportAutoFileName;
|
||||
QString m_curFile, m_exportAutoFileName, m_exportImageFileName;
|
||||
bool m_isUntitled;
|
||||
};
|
||||
|
||||
|
||||
Reference in New Issue
Block a user